MMFF94.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: MMFF94.h,v 1.1.8.3 2007/06/15 09:24:20 amoll Exp $ 
//
 
// Molecular Mechanics: MMFF94 force field class
 
#ifndef BALL_MOLMEC_MMFF94_MMFF94_H
#define BALL_MOLMEC_MMFF94_MMFF94_H
 
#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif
 
#ifndef BALL_MOLMEC_COMMON_FORCEFIELD_H
# include <BALL/MOLMEC/COMMON/forceField.h>
#endif
 
#ifndef BALL_KERNEL_SYSTEM_H
# include <BALL/KERNEL/system.h>
#endif
 
#ifndef BALL_MOLMEC_MMFF94_MMFF94PARAMETERS_H
# include <BALL/MOLMEC/MMFF94/MMFF94Parameters.h>
#endif
 
#ifndef BALL_MOLMEC_MMFF94_MMFF94PROCESSORS_H
# include <BALL/MOLMEC/MMFF94/MMFF94Processors.h>
#endif
 
#ifndef BALL_DATATYPE_HASHSET_H
# include <BALL/DATATYPE/hashSet.h>
#endif
 
#ifndef BALL_STRUCTURE_KEKULIZER_H
# include <BALL/STRUCTURE/kekulizer.h>
#endif
 
#include <vector>
 
namespace BALL 
{
  using std::vector;

  class BALL_EXPORT MMFF94 
    : public ForceField
  {
    public:


    struct BALL_EXPORT Option
    {
      static const char* FOLDER;

      static const char* ASSIGN_CHARGES;

      static const char* ASSIGN_TYPENAMES;

      static const char* ASSIGN_TYPES;

      static const char* OVERWRITE_CHARGES;

      static const char* OVERWRITE_TYPENAMES;

      static const char* NONBONDED_CUTOFF;

      static const char* VDW_CUTOFF;

      static const char* VDW_CUTON;

      static const char* ELECTROSTATIC_CUTOFF;

      static const char* ELECTROSTATIC_CUTON;

      static const char* DISTANCE_DEPENDENT_DIELECTRIC;
    };

    struct BALL_EXPORT Default
    {
      static const char* FOLDER;

      static const bool ASSIGN_CHARGES;

      static const bool ASSIGN_TYPENAMES;

      static const bool ASSIGN_TYPES;

      static const bool OVERWRITE_CHARGES;

      static const bool OVERWRITE_TYPENAMES;

      static const float NONBONDED_CUTOFF;

      static const float VDW_CUTOFF;

      static const float VDW_CUTON;

      static const float ELECTROSTATIC_CUTOFF;

      static const float ELECTROSTATIC_CUTON;

      static const bool DISTANCE_DEPENDENT_DIELECTRIC;
    };


 
    BALL_CREATE(MMFF94)
 
    
    MMFF94();

    MMFF94(System& system);

    MMFF94(System& system, const Options& options);
 
    MMFF94(const MMFF94& force_field);

    virtual ~MMFF94();



    const MMFF94& operator = (const MMFF94& force_field)
      ;

    virtual void clear()
      ;
    


    virtual bool specificSetup();



    double getStretchEnergy() const;

    double getBendEnergy() const;

    double getStretchBendEnergy() const;

    double getTorsionEnergy() const;

    double getNonbondedEnergy() const;

    double getESEnergy() const;

    double getVdWEnergy() const;

    double getPlaneEnergy() const;

    bool hasInitializedParameters() const;

    Size getUpdateFrequency() const;

    virtual String getResults() const
      ;

    const vector<Bond*> getBonds() const { return bonds_;}
    
    const vector<HashSet<Atom*> >& getRings() const { return rings_;}
    
    const vector<HashSet<Atom*> >& getAromaticRings() const { return aromatic_rings_;}
    
    bool isInOneAromaticRing(const Bond& bond) const;
    
    bool assignMMFF94BondType(Bond& bond) const;

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

    const MMFF94StretchParameters& getStretchParameters() const { return bond_parameters_;}

    const MMFF94AtomTypeEquivalences & getEquivalences() const { return equivalences_;}

    bool areInOneRing(vector<Atom*> v, Size ring_size = 0) const;
    
    bool areInOneAromaticRing(const vector<Atom*>& v, Size ring_size = 0) const;

    bool checkAtomType(Atom& atom);

 
    protected:
 
    void insertComponents_();
 
    void transformAromaticBonds_();
    void collectBonds_();
    void assignBondTypes_();
    void collectRings_();
      
    String                      folder_;
    MMFF94AtomTypes             atom_types_;
    MMFF94StretchParameters     bond_parameters_;
    MMFF94AtomTypeEquivalences  equivalences_;
    MMFF94ESParameters          es_parameters_;
    vector<HashSet<Atom*> >     rings_;
    vector<HashSet<Atom*> >     aromatic_rings_;
    bool                        parameters_initialized_;
    vector<Bond*>               bonds_;
    MMFF94AtomTyper             atom_typer_;
    MMFF94ChargeProcessor       charge_processor_;
    Kekuliser                   kekuliser_;
    HashSet<Bond*>              aromatic_bonds_;
  };
 
} // namespace BALL
 
#endif // BALL_MOLMEC_MMFF94_H