MMFF94Parameters.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: MMFF94Parameters.h,v 1.1.8.1 2007/03/25 21:25:17 oliver Exp $ 
//

// Molecular Mechanics: MMFF94 force field class

#ifndef BALL_MOLMEC_MMFF94_MMFF94PARAMETERS_H
#define BALL_MOLMEC_MMFF94_MMFF94PARAMETERS_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#ifndef BALL_DATATYPE_HASHMAP_H
# include <BALL/DATATYPE/hashMap.h>
#endif 

using namespace std;

namespace BALL 
{

  class Atom;
  class Parameters;

  Position getMMFF94Index(Position atom_type1, Position atom_type2);

  extern Size MMFF94_number_atom_types;
  
  class MMFF94AtomTypeEquivalences;

#define MMFF94_INVALID_VALUE 99.0


  class BALL_EXPORT MMFF94ParametersBase
  {
    public:

    BALL_CREATE(MMFF94ParametersBase)

    
    MMFF94ParametersBase();

    virtual ~MMFF94ParametersBase() {};

    const MMFF94ParametersBase& operator = (const MMFF94ParametersBase&)
       {return *this;};

    virtual void clear()
      ;

    bool isInitialized() { return is_initialized_;}

    bool readParameters(Parameters& p, const String& section)
      throw(Exception::FileNotFound);

    void setEquivalences(const MMFF94AtomTypeEquivalences& equi) { equiv_ = &equi;}
    
    protected:

    virtual bool setup_(const vector<vector<String> >&) { return true;};

    bool is_initialized_;

    // nr of needed fields in parameter files
    Size number_expected_fields_;
    const MMFF94AtomTypeEquivalences* equiv_;
  };


  class BALL_EXPORT MMFF94AtomTypeEquivalences:
    public MMFF94ParametersBase
  {
    public: 

    MMFF94AtomTypeEquivalences();

    MMFF94AtomTypeEquivalences(const MMFF94AtomTypeEquivalences& to_copy);

    ~MMFF94AtomTypeEquivalences();
    
    void clear()
      ;

    Index getEquivalence(Position original, Position number) const;

    protected:

    virtual bool setup_(const vector<vector<String> >&);
    vector<vector<Position> > equivalences_;
    vector<String>   names_;
    vector<bool>     exists_;
  };
  

  struct BALL_EXPORT MMFF94AtomType
  {
    MMFF94AtomType();

    Position aspec;

    Position crd;

    Position val;

    bool pilp;

    Position mltb;

    bool arom;

    bool lin;

    bool sbmb;

    bool valid;
  };



  class BALL_EXPORT MMFF94AtomTypes:
    public MMFF94ParametersBase
  {
    public:

    MMFF94AtomTypes();

    MMFF94AtomTypes(const MMFF94AtomTypes& to_copy);

    ~MMFF94AtomTypes() {};

    const vector<MMFF94AtomType>& getAtomTypes() const { return data_;}

    protected:

    virtual bool setup_(const vector<vector<String> >&);
    vector<MMFF94AtomType> data_;
  };

  
  class BALL_EXPORT MMFF94StretchParameters:
    public MMFF94ParametersBase
  {
    public:

    struct BondData
    {
      BondData();

      double kb_normal;
      double r0_normal;
      bool  standard_bond_exists;
      
      double kb_sbmb;
      double r0_sbmb;
      bool  sbmb_exists;
      bool  empirical;
    };

    struct EmpiricalBondData
    {
      double kb;
      double r0;
    };
  
    typedef HashMap<Position, BondData> StretchMap;
    typedef HashMap<Position, EmpiricalBondData> EmpiricalStretchMap;

    BALL_CREATE(MMFF94StretchParameters)

    
    MMFF94StretchParameters();

    virtual ~MMFF94StretchParameters();

    const MMFF94StretchParameters& operator = (const MMFF94StretchParameters& param)
      ;

    virtual void clear()
      ;

    bool assignParameters(Position type1, Position type2, BondData& data) const;

    bool readEmpiricalParameters(Parameters& p, const String& section);

    const StretchMap& getBondParameters() const { return parameters_;}
    
    const EmpiricalStretchMap& getEmpiricalParameters() const { return empirical_parameters_;}

    static double radii[];
    static double electronegatives[];

    protected:

    virtual bool setup_(const vector<vector<String> >&);

    StretchMap parameters_;
    mutable StretchMap buffered_parameters_;
    EmpiricalStretchMap empirical_parameters_;
  };


  class BALL_EXPORT MMFF94BendParameters
    : public MMFF94ParametersBase
  {
    public:

    typedef HashMap<Position, pair<double, double> > BendMap;

    BALL_CREATE(MMFF94BendParameters)

    
    MMFF94BendParameters();

    virtual ~MMFF94BendParameters();

    const MMFF94BendParameters& operator = (const MMFF94BendParameters& param)
      ;

    virtual void clear()
      ;

    bool assignParameters(Position bend_type,
                       Position atom_type1, Position atom_type2, Position atom_type3, 
                       double& ka, double& angle) const;

    protected:

    virtual bool setup_(const vector<vector<String> >&);

    Position getIndex_(Position bend_type, Position atom_type1, Position atom_type2, Position atom_type3) const;

    BendMap parameters_;
    mutable BendMap buffered_parameters_;
  };



  class BALL_EXPORT MMFF94StretchBendParameters
    : public MMFF94ParametersBase
  {
    public:

    typedef HashMap<Position, pair<double, double> > StretchBendMap;

    BALL_CREATE(MMFF94StretchBendParameters)

    
    MMFF94StretchBendParameters();

    virtual ~MMFF94StretchBendParameters();

    const MMFF94StretchBendParameters& operator = (const MMFF94StretchBendParameters& param)
      ;

    virtual void clear()
      ;

    bool assignParameters(Position stretch_bend_type, const Atom& atom1, const Atom& atom2, const Atom& atom3, 
                       double& kba_ijk, double& kba_kji) const;

    bool readEmpiricalParameters(Parameters& p, const String& section)
      throw(Exception::FileNotFound);
    

    protected:

    virtual bool setup_(const vector<vector<String> >&);

    Position getIndex_(Position stretch_bend_type,
                       Position atom_type1, Position atom_type2, Position atom_type3) const; 

    Position getIndexByRow_(Position r1, Position r2, Position r3) const;

    StretchBendMap parameters_;
    mutable StretchBendMap buffered_parameters_;
    StretchBendMap parameters_by_row_;
  };

  
  class BALL_EXPORT MMFF94TorsionParameters
    : public MMFF94ParametersBase
  {
    public:

    typedef HashMap<String, vector<double> > TorsionsMap;

    BALL_CREATE(MMFF94TorsionParameters)

    
    MMFF94TorsionParameters();

    virtual ~MMFF94TorsionParameters();

    const MMFF94TorsionParameters& operator = (const MMFF94TorsionParameters& param)
      ;

    virtual void clear()
      ;

    bool assignParameters(Position type_index,
                       Index at1, Index at2, Index at3, Index at4,
                       double& v1, double& v2, double& v3) const;

    protected:

    virtual bool setup_(const vector<vector<String> >&);

    String getIndex_(Position type, Position atom_type1, Position atom_type2, Position atom_type3, Position atom_type4) const;

    TorsionsMap parameters_;
    mutable TorsionsMap buffered_parameters_;
    static Position ic_[5];
    static Position lc_[5];
  };


  class BALL_EXPORT MMFF94PlaneParameters
    : public MMFF94ParametersBase
  {
    public:

    typedef HashMap<String, double> PlaneMap;

    BALL_CREATE(MMFF94PlaneParameters)

    
    MMFF94PlaneParameters();

    virtual ~MMFF94PlaneParameters();

    const MMFF94PlaneParameters& operator = (const MMFF94PlaneParameters& param)
      ;

    virtual void clear()
      ;

    bool assignParameters(Index at1, Index at2, Index at3, Index at4, double& v) const;

    protected:

    virtual bool setup_(const vector<vector<String> >&);

    String getIndex_(Position atom_type1, Position atom_type2, Position atom_type3, Position atom_type4) const;

    PlaneMap parameters_;
    mutable PlaneMap buffered_parameters_;
  };


  class BALL_EXPORT MMFF94VDWParameters
    : public MMFF94ParametersBase
  {
    public:

    struct VDWEntry
    {
      double alpha_i;
      double ni;
      double ai;
      double gi;
      short  donor_acceptor;
      bool   valid;
    };

    BALL_CREATE(MMFF94VDWParameters)

    
    MMFF94VDWParameters();

    virtual ~MMFF94VDWParameters();

    const MMFF94VDWParameters& operator = (const MMFF94VDWParameters& param)
      ;

    virtual void clear()
      ;

    double getR(Position atom_type) const;

    const VDWEntry& getParameters(Index at) const;

    bool assignParameters(Position at1, Position at2, double& rij, double& rij_7_, double& eij) const;

    protected:

    virtual bool setup_(const vector<vector<String> >&);

    vector<VDWEntry> parameters_;

    // R star ii for all individual atom types
    mutable vector<double> rs_;

    // R star ij for pairs of atom types
    mutable vector<double> rij_;
    // R star ij ^ 7 for pairs of atom types
    mutable vector<double> rij_7_;
    // R star ij and for pairs of atom types
    mutable vector<double> eij_;
    // bools if indivual value was already calculated
    mutable vector<bool>   calculated_;
  };



  class BALL_EXPORT MMFF94ESParameters
    : public MMFF94ParametersBase
  {
    public:

    BALL_CREATE(MMFF94ESParameters)

    
    MMFF94ESParameters();

    virtual ~MMFF94ESParameters();

    const MMFF94ESParameters& operator = (const MMFF94ESParameters& param)
      ;

    virtual void clear()
      ;

    double getPartialCharge(Position at1, Position at2, Position bt) const;
    
    bool readEmpiricalParameters(Parameters& p, const String& section)
      throw(Exception::FileNotFound);

    double getPhi(Index atom_type) const;

    double getPBCI(Index atom_type) const;

    protected:

    virtual bool setup_(const vector<vector<String> >&);
    Position getIndex_(Position at1, Position at2, Position bt) const;

    vector<double> parameters_, phis_, pbcis_;
  };


} // namespace BALL

#endif // BALL_MOLMEC_MMFF94_MMFF94PARAMETERS_H