forcefield.h

Go to the documentation of this file.

/**********************************************************************
forcefield.h - Handle OBForceField class.
 
Copyright (C) 2006-2007 by Tim Vandermeersch <[email protected]>
 
This file is part of the Open Babel project.
For more information, see <http://openbabel.sourceforge.net/>
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
***********************************************************************/

#ifndef OB_FORCEFIELD_H
#define OB_FORCEFIELD_H

#include <vector>
#include <string>
#include <map>

#include <list>
#include <set>
#include <openbabel/base.h>
#include <openbabel/mol.h>
#include <openbabel/pluginiter.h>

namespace OpenBabel
{
  // log levels
#define OBFF_LOGLVL_NONE        0   
#define OBFF_LOGLVL_LOW 1     
#define OBFF_LOGLVL_MEDIUM      2 
#define OBFF_LOGLVL_HIGH        3   

  // terms
#define OBFF_ENERGY             (1 << 0)   
#define OBFF_EBOND              (1 << 1)   
#define OBFF_EANGLE             (1 << 2)   
#define OBFF_ESTRBND            (1 << 3) 
#define OBFF_ETORSION           (1 << 4) 
#define OBFF_EOOP               (1 << 5)     
#define OBFF_EVDW               (1 << 6)     
#define OBFF_EELECTROSTATIC     (1 << 7) 

  // mode arguments for SteepestDescent, ConjugateGradients, ...
#define OBFF_NUMERICAL_GRADIENT   (1 << 0)  
#define OBFF_ANALYTICAL_GRADIENT        (1 << 1)  

#define KCAL_TO_KJ      4.1868

  // inline if statements for logging.
#define IF_OBFF_LOGLVL_LOW    if(loglvl >= OBFF_LOGLVL_LOW)
#define IF_OBFF_LOGLVL_MEDIUM if(loglvl >= OBFF_LOGLVL_MEDIUM)
#define IF_OBFF_LOGLVL_HIGH   if(loglvl >= OBFF_LOGLVL_HIGH)
  
  class OBFFParameter {
  public:
    int         a, b, c, d;
    std::string _a, _b, _c, _d; 

    int       ipar1, ipar2, ipar3, ipar4, ipar5;
    double    dpar1, dpar2, dpar3, dpar4, dpar5;

    OBFFParameter& operator=(const OBFFParameter &ai) 
    {
      if (this != &ai) {
        a = ai.a;
        b = ai.b;
        c = ai.c;
        d = ai.d;
        _a = ai._a;
        _b = ai._b;
        _c = ai._c;
        _d = ai._d;
        ipar1 = ai.ipar1;
        ipar2 = ai.ipar2;
        ipar3 = ai.ipar3;
        ipar4 = ai.ipar4;
        ipar5 = ai.ipar5;
        dpar1 = ai.dpar1;
        dpar2 = ai.dpar2;
        dpar3 = ai.dpar3;
        dpar4 = ai.dpar4;
        dpar5 = ai.dpar5;
      }
        
      return *this;
    }

    void clear () 
    {
      a = 0;
      b = 0;
      c = 0;
      d = 0;
      ipar1 = 0;
      ipar2 = 0;
      ipar3 = 0;
      ipar4 = 0;
      ipar5 = 0;
      dpar1 = 0.0f;
      dpar2 = 0.0f;
      dpar3 = 0.0f;
      dpar4 = 0.0f;
      dpar5 = 0.0f;
    }
  }; // class OBFFParameter
  
  // specific class introductions in forcefieldYYYY.cpp (for YYYY calculations)
  class OBFFCalculation
  {
    public:
      double energy;
      vector3 grada, gradb, gradc, gradd;
      OBAtom *a, *b, *c, *d;

      OBFFCalculation() 
        {
          a = NULL;
          b = NULL;
          c = NULL;
          d = NULL;
          energy = 0.0f;
          grada = VZero;
          gradb = VZero;
          gradc = VZero;
          gradd = VZero;
        }
      virtual ~OBFFCalculation()
        {
        }
      
      virtual void Compute(bool gradients = true) 
        {
        }
      virtual double GetEnergy() 
      {
        if (!energy)
          Compute(false);

        return energy; 
      }
      virtual vector3 GetGradient(OBAtom *atom) 
      {
        if (atom == a)
          return grada;
        else if (atom == b)
          return gradb;
        else if (atom == c)
          return gradc;
        else if (atom == d)
          return gradd;
        else 
          return  VZero;
      }
  };

  // Class OBForceField
  // class introduction in forcefield.cpp
  class OBAPI OBForceField
  {
  
  MAKE_PLUGIN(OBForceField)
  
    protected:
    OBFFParameter* GetParameter(int a, int b, int c, int d, std::vector<OBFFParameter> &parameter);
    OBFFParameter* GetParameter(const char* a, const char* b, const char* c, const char* d, std::vector<OBFFParameter> &parameter);
           

    vector3 NumericalDerivative(OBAtom *a, int terms = OBFF_ENERGY);
    vector3 NumericalSecondDerivative(OBAtom *a, int terms = OBFF_ENERGY);
    virtual vector3 GetGradient(OBAtom *a, int terms = OBFF_ENERGY) 
    { 
      return -NumericalDerivative(a, terms); 
    }
    bool IsInSameRing(OBAtom* a, OBAtom* b);
 
    OBMol _mol; 

    std::ostream* logos;
    char logbuf[200];
    int loglvl; 

    int current_conformer;

    double _econv, _e_n1;
    int _method, _cstep, _nsteps;
    std::vector<vector3> _grad1, _dir1;

  public:
    virtual ~OBForceField()
      {
      }
    //virtual std::string Description()=0;
    static OBForceField* FindForceField(const std::string& ID)
    { 
      return Iter().FindType(ID);
    } 
    static OBForceField* FindForceField(const char *ID)
    {
      std::string ffname(ID);
      return FindForceField(ffname);
    }
    virtual std::string GetUnit() { return std::string("au"); }
    virtual bool Setup(OBMol &mol) { return false; }
    bool UpdateCoordinates(OBMol &mol);
    bool UpdateConformers(OBMol &mol);
    void OBFFLog(std::string msg)
    {
      if (!logos)
        return;
      
      *logos << msg;
    }
    void OBFFLog(const char *msg)
    {
      if (!logos)
        return;
      
      *logos << msg;
    }

    // Energy Evaluation                                                   //
      


    virtual double Energy(bool gradients = true) { return 0.0f; }
    virtual double E_Bond(bool gradients = true) { return 0.0f; }
    virtual double E_Angle(bool gradients = true) { return 0.0f; }
    virtual double E_StrBnd(bool gradients = true) { return 0.0f; }
    virtual double E_Torsion(bool gradients = true) { return 0.0f; }
    virtual double E_OOP(bool gradients = true) { return 0.0f; }
    virtual double E_VDW(bool gradients = true) { return 0.0f; }
    virtual double E_Electrostatic(bool gradients = true) { return 0.0f; }
     
    // Logging                                                             //
      


    bool SetLogFile(std::ostream *pos);
    bool SetLogLevel(int level);
    int GetLogLevel() { return loglvl; }
     
    // Structure Generation                                                //
      


    void SystematicRotorSearch();
      
    // Energy Minimization                                                 //
      


    vector3 LineSearch(OBAtom *atom, vector3 &direction);
    void SteepestDescent(int steps, double econv = 1e-6f, int method = OBFF_ANALYTICAL_GRADIENT);
    void SteepestDescentInitialize(int steps = 1000, double econv = 1e-6f, int method = OBFF_ANALYTICAL_GRADIENT);
    bool SteepestDescentTakeNSteps(int n);
    void ConjugateGradients(int steps, double econv = 1e-6f, int method = OBFF_ANALYTICAL_GRADIENT);
    void ConjugateGradientsInitialize(int steps = 1000, double econv = 1e-6f, int method = OBFF_ANALYTICAL_GRADIENT);
    bool ConjugateGradientsTakeNSteps(int n);
      
    // Validation                                                          //
      


    virtual bool Validate() { return false; }
    virtual bool ValidateGradients() { return false; }
    vector3 ValidateGradientError(vector3 &numgrad, vector3 &anagrad);
     
    // Vector Analysis                                                     //
      


    static double VectorLengthDerivative(vector3 &a, vector3 &b);
    static double VectorAngleDerivative(vector3 &a, vector3 &b, vector3 &c);
    static double VectorTorsionDerivative(vector3 &a, vector3 &b, vector3 &c, vector3 &d);

    void kludge()
    {
      PluginIter<OBForceField> it;
      (++it)->SetLogLevel(1);
      if(it)it.ID();
    }

  }; // class OBForceField

}// namespace OpenBabel

#endif   // OB_FORCEFIELD_H

---

This file is part of the documentation for Open Babel, version 2.1.0.

Documentation copyright © 1998-2007, the Open Babel Developers.
Open Babel is hosted by:
Generated on Tue Apr 24 18:08:04 2007 by  1.5.2.