rotor.h

Go to the documentation of this file.

/**********************************************************************
rotor.h - Rotate torsional according to rotor rules.

Copyright (C) 1998-2000 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison

This file is part of the Open Babel project.
For more information, see <http://openbabel.org/>

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_ROTOR_H
#define OB_ROTOR_H

#include <openbabel/parsmart.h>
#include <openbabel/typer.h>

namespace OpenBabel
{

#ifndef SQUARE
#define SQUARE(x) ((x)*(x))
#endif

  class OBAPI OBRotorRule
  {
    int                 _ref[4]; 
    double              _delta;  
    std::string         _s;      
    OBSmartsPattern*    _sp;     
    std::vector<double> _vals;   
  public:

  OBRotorRule(char *buffer,int ref[4],std::vector<double> &vals,double d):
    _delta(d), _s(buffer), _vals(vals)
    {
      _sp = new OBSmartsPattern;
      _sp->Init(buffer);
      memcpy(_ref,ref,sizeof(int)*4);
    }

    ~OBRotorRule()
      {
        if (_sp)
          {
            delete _sp;
            _sp = NULL;
          }
      }

    bool    IsValid()    {        return(_sp->IsValid());       }
    void    GetReferenceAtoms(int ref[4]) { memcpy(ref,_ref,sizeof(int)*4); }
    void    SetDelta(double d)    {       _delta = d;           }
    double  GetDelta()            {       return(_delta);       }
    std::vector<double>   &GetTorsionVals()    { return(_vals); }
    std::string  &GetSmartsString(){      return(_s);           }
    OBSmartsPattern *GetSmartsPattern() {  return(_sp);         }
  };

 class OBAPI OBRotorRules : public OBGlobalDataBase
  {
    bool                       _quiet;  
    std::vector<OBRotorRule*>  _vr;     
    std::vector<double>        _sp3sp3; 
    std::vector<double>        _sp3sp2; 
    std::vector<double>        _sp2sp2; 
  public:
    OBRotorRules();
    ~OBRotorRules();

    void ParseLine(const char*);
    size_t GetSize()                 { return _vr.size();}

    void SetFilename(std::string &s)       { _filename = s;    }

    void GetRotorIncrements(OBMol& mol,OBBond* bond,int refs[4],
                            std::vector<double> &vals,double &delta);
    void Quiet()                           { _quiet=true;      }
  };

  class OBAPI OBRotor
  {
    int _idx; 
    std::vector<int> _rotatoms; 
    double _imag, _refang; 
    OBBond *_bond; 
    std::vector<int> _ref, _torsion; 
    OBBitVec _fixedatoms,_fixedbonds, _evalatoms; 
    std::vector<double> _torsionAngles;  
    std::vector<double> _invmag; 
    std::vector<std::vector<double> > _sn,_cs,_t; 
  public:
    OBRotor();
    ~OBRotor()
    {
    }


    void SetBond(OBBond *bond)
    {
      _bond = bond;
    }
    void SetIdx(int idx)
    {
      _idx = idx;
    }
    void SetDihedralAtoms(std::vector<int> &ref);
    void SetDihedralAtoms(int ref[4]);
    void SetRotAtoms(std::vector<int> &atoms);
    void SetTorsionValues(std::vector<double> &angles)
    {
      _torsionAngles = angles;
    }
    void SetFixedBonds(OBBitVec &bv)
    {
      _fixedbonds = bv;
    }


    inline void SetToAngle(double *coordinates, double setang)
    {
      double /*dx,dy,dz,*/ sn,cs,t,ang,mag;
      // compute the angle to rotate (radians)
      ang = setang - CalcTorsion(coordinates);
      // if the angle to rotate is too small, we're done
      if (fabs(ang) < 1e-5)
        return;

      // compute the bond length
      mag = CalcBondLength(coordinates);
      // compute some rotation matrix elements
      sn = sin(ang);
      cs = cos(ang);
      t = 1 - cs;

      // perform rotation
      Set(coordinates, sn, cs, t, 1.0 / mag);
    }
    void SetRotor(double *coordinates, int next, int prev = -1);
    void Set(double *coordinates, double sine, double cosine, double translation, double invmag);
    void Precompute(double *coordinates);
    void Set(double *coordinates, int idx);
    void Precalc(std::vector<double*> &conformers);
    void Set(double *coordinates, int conformer, int idx)
    {
      Set(coordinates, _sn[conformer][idx], _cs[conformer][idx], _t[conformer][idx], _invmag[conformer]);
    }



    OBBond *GetBond()
    {
      return(_bond);
    }
    size_t Size()
    {
      return _torsionAngles.size();
    }
    int GetIdx() const
    {
      return _idx;
    }
    void GetDihedralAtoms(int ref[4])
    {
      for (int i = 0; i < 4; ++i)
        ref[i] = _ref[i];
    }
    std::vector<int> &GetDihedralAtoms()
    {
      return _ref;
    }
    const std::vector<int>& GetRotAtoms() const
    {
      return _rotatoms;
    }
    const std::vector<double> &GetTorsionValues() const
    {
      return _torsionAngles;
    }
    OBBitVec &GetFixedBonds()
    {
      return _fixedbonds;
    }
    double CalcTorsion(double *coordinates);
    double CalcBondLength(double *coordinates);


    std::vector<double>::iterator BeginTorIncrement()
    {
      return _torsionAngles.begin();
    }
    std::vector<double>::iterator EndTorIncrement()
    {
      return _torsionAngles.end();
    }

    void RemoveSymTorsionValues(int);


    void SetDelta(double UNUSED(d)) {}
    double GetDelta() { return 10.0; }
    OBBitVec &GetFixedAtoms() { return _fixedatoms; }
    void SetFixedAtoms(OBBitVec &bv) { _fixedatoms = bv; }
    OBBitVec &GetEvalAtoms() { return _evalatoms; }
    void SetEvalAtoms(OBBitVec &bv) { _evalatoms = bv; }
    void* GetRotAtoms() { return &_rotatoms; }
    std::vector<double> &GetResolution() { return _torsionAngles; }
    void SetNumCoords(int UNUSED(nc)) {}

  };


  typedef std::vector<OBRotor*>::iterator OBRotorIterator;

  class OBAPI OBRotorList
  {
    bool _quiet;                    
    bool _removesym;                
    OBBitVec _fixedatoms, _fixedbonds; 
    OBRotorRules _rr;               
    std::vector<int> _dffv;         
    std::vector<OBRotor*> _rotor;   

    std::vector<std::pair<OBSmartsPattern*,std::pair<int,int> > > _vsym2;
    std::vector<std::pair<OBSmartsPattern*,std::pair<int,int> > > _vsym3;
  public:
    OBRotorList();
    ~OBRotorList();

    void Clear();
    size_t Size()
    {
      return((_rotor.empty()) ? (size_t)0: _rotor.size());
    }
    bool IsFixedBond(OBBond*);
    bool HasFixedBonds()
    {
      return !_fixedbonds.Empty();
    }
    void RemoveSymVals(OBMol&);



    bool Setup(OBMol &mol);
    void SetFixedBonds(OBBitVec &fix)
    {
      _fixedbonds = fix;
      _fixedatoms.Clear();
    }
    void Init(std::string &fname)
    {
      _rr.SetFilename(fname);
      _rr.Init();
    }
    void SetQuiet() {
      _quiet=true;
      _rr.Quiet();
    }
    bool SetRotAtoms(OBMol&);
    bool FindRotors(OBMol &mol);
    bool SetEvalAtoms(OBMol&);
    bool AssignTorVals(OBMol &);



    OBRotor *BeginRotor(OBRotorIterator &i)
    {
      i = _rotor.begin();
      return((i ==_rotor.end()) ? NULL:*i);
    }
    OBRotor *NextRotor(OBRotorIterator &i)
    {
      ++i;
      return((i ==_rotor.end()) ? NULL:*i);
    }
    OBRotorIterator BeginRotors()   { return(_rotor.begin()); }
    OBRotorIterator EndRotors()     { return(_rotor.end());   }

    // Not declared
    bool   IdentifyEvalAtoms(OBMol &mol) { return SetEvalAtoms(mol); }
    void SetFixAtoms(OBBitVec &fix)
    {
      _fixedatoms = fix;
      _fixedbonds.Clear();
    }
    bool HasFixedAtoms()
    {
      return(!_fixedatoms.Empty());
    }
    void IgnoreSymmetryRemoval()    { _removesym = false;}
    void SetRotAtomsByFix(OBMol&);

  };

  class rotor_digit {
    public:
      rotor_digit(unsigned int rs)
      {
        resolution_size = rs;
        state = 0;
      }

      rotor_digit()
      {
        resolution_size = 0;
        state = 0;
      }

      void set_size(unsigned int rs)
      {
        resolution_size = rs;
        state = 0;
      }

      void set_state(int st)
      {
        state = st;
      }

      int get_state()
      {
        return state;
      }

      unsigned int size()
      {
        return resolution_size;
      }

      bool next()
      {
        if (state < static_cast<int>(resolution_size - 1)) {
          ++state;
          return false;
        } else
          state = 0;

        return true;
      }
    private:
      unsigned int resolution_size;
      int state;
#ifndef SWIG
  } typedef rotor_digit;
#else
  };
#endif


  class OBAPI OBRotorKeys
  {
    public:
      OBRotorKeys()
      {
        _vr.clear();
      }

      void Clear(){
        _vr.clear();
      }

      unsigned int NumKeys()
      {
        unsigned int numKeys = 0;

        while (Next())
          numKeys++;

        return numKeys;
      }

      void AddRotor(unsigned int size)
      {
        rotor_digit rd(size);
        _vr.push_back(rd);
      }

      bool Next()
      {
        if(_vr.size() == 0)
          return false;

        bool carry = _vr[0].next();
        unsigned int i = 1;
        while (carry) {
          if(i == _vr.size())
            return false;

          carry = _vr[i].next();
          i++;
        }
        return true;
      }

      std::vector<int> GetKey()
      {
        std::vector<int> rt;
        rt.clear();
        rt.push_back(0);
        for(unsigned int i = 0; i < _vr.size(); i++){
          rt.push_back(_vr[i].get_state());
        }

        return rt;
      }

    private:
      std::vector<rotor_digit> _vr;
  };


} // end namespace OpenBabel

#endif // OB_ROTOR_H