conformersearch.h

Go to the documentation of this file.

/**********************************************************************
conformersearch.h - Conformer searching using genetic algorithm.

Copyright (C) 2010 Tim Vandermeersch

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_CONFORMERSEARCH_H
#define OB_CONFORMERSEARCH_H

#include <openbabel/mol.h>
#include <openbabel/rotor.h>
#include <openbabel/rotamer.h>

namespace OpenBabel {

  typedef std::vector<int> RotorKey;
  typedef std::vector<RotorKey> RotorKeys;


  //
  //  OBConformerFilter(s)
  //

  class OBAPI OBConformerFilter
  {
    public:
      virtual bool IsGood(const OBMol &mol, const RotorKey &key, double *coords) = 0;
  };

  class OBAPI OBConformerFilters : public OBConformerFilter
  {
    public:
      OBConformerFilters(const std::vector<OBConformerFilter*> &filters) : m_filters(filters)
      {
      }
      bool IsGood(const OBMol &mol, const RotorKey &key, double *coords)
      {
        for (unsigned int i = 0; i < m_filters.size(); ++i)
          if (!m_filters[i]->IsGood(mol, key, coords))
            return false;
        return true;
      }
    protected:
      std::vector<OBConformerFilter*> m_filters;
  };

  class OBAPI OBStericConformerFilter : public OBConformerFilter
  {
    public:
      OBStericConformerFilter(double cutoff) : m_cutoff(cutoff) {}
      bool IsGood(const OBMol &mol, const RotorKey &key, double *coords);
    private:
      double m_cutoff;
  };

  //
  //  OBConformerScore(s)
  //

  class OBAPI OBConformerScore
  {
    public:
      enum Preferred { HighScore, LowScore };
      virtual Preferred GetPreferred() = 0;
      enum Convergence { Highest, Lowest, Sum, Average };
      virtual Convergence GetConvergence() = 0;
      virtual double Score(OBMol &mol, unsigned int index, const RotorKeys &keys,
          const std::vector<double*> &conformers) = 0;
  };

  class OBAPI OBRMSDConformerScore : public OBConformerScore
  {
    public:
      Preferred GetPreferred() { return HighScore; }
      Convergence GetConvergence() { return Average; }
      double Score(OBMol &mol, unsigned int index, const RotorKeys &keys,
          const std::vector<double*> &conformers);
  };

  class OBAPI OBEnergyConformerScore : public OBConformerScore
  {
    public:
      Preferred GetPreferred() { return LowScore; }
      Convergence GetConvergence() { return Lowest; }
      double Score(OBMol &mol, unsigned int index, const RotorKeys &keys,
          const std::vector<double*> &conformers);
  };

  class OBAPI OBMinimizingEnergyConformerScore : public OBConformerScore
  {
    public:
      Preferred GetPreferred() { return LowScore; }
      Convergence GetConvergence() { return Lowest; }
      double Score(OBMol &mol, unsigned int index, const RotorKeys &keys,
          const std::vector<double*> &conformers);
  };

  //
  //  OBConformerSearch
  //

  class OBAPI OBConformerSearch
  {
    public:
      OBConformerSearch();
      ~OBConformerSearch();
      bool Setup(const OBMol &mol, int numConformers = 30, int numChildren = 5,
          int mutability = 5, int convergence = 25);
      void SetNumConformers(int numConformers) { m_numConformers = numConformers; }
      void SetNumChildren(int numChildren) { m_numChildren = numChildren; }
      void SetMutability(int mutability) { m_mutability = mutability; }
      void SetConvergence(int convergence) { m_convergence = convergence; }
      void SetFixedBonds(const OBBitVec &fixedBonds) { m_fixedBonds = fixedBonds; }


      void SetFilter(OBConformerFilter *filter)
      {
        delete m_filter;
        m_filter = filter;
      }
      void SetScore(OBConformerScore *score)
      {
        delete m_score;
        m_score = score;
      }

      void Search();

      const RotorKeys& GetRotorKeys() const
      {
        return m_rotorKeys;
      }

      void GetConformers(OBMol &mol);
    private:
      void NextGeneration();
      double MakeSelection();
      bool IsUniqueKey(const RotorKeys &keys, const RotorKey &key) const;
      bool IsGood(const RotorKey &key);

      int m_numConformers; 
      int m_numChildren; 
      int m_mutability; 
      int m_convergence; 

      OBBitVec      m_fixedBonds; 
      OBMol         m_mol; 
      OBRotorList   m_rotorList; 
      RotorKeys     m_rotorKeys; 

      OBConformerFilter *m_filter;
      OBConformerScore  *m_score;


  };


};

#endif