conformersearch.h

Go to the documentation of this file.

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

Copyright (C) 2010 Tim Vandermeersch
Some portions Copyright (C) 2012 Materials Design, Inc.
Some portions Copyright (C) 2016 Torsten Sachse

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;
  typedef std::map<std::vector<int>,double> mapRotorEnergy;


  //
  //  OBConformerFilter(s)
  //

  class OBAPI OBConformerFilter
  {
    public:
      virtual bool IsGood(const OBMol &mol, const RotorKey &key, double *coords) = 0;
      virtual ~OBConformerFilter() = 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 ();
      OBStericConformerFilter (double cutoff, double vdw_factor = 0.5, bool check_hydrogens = true);
      bool IsGood(const OBMol &mol, const RotorKey &key, double *coords);
    private:
      double m_cutoff; 
      double m_vdw_factor;              
      bool m_check_hydrogens;           
  };

  //
  //  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;
      virtual ~OBConformerScore() = 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:
      OBEnergyConformerScore () {
        energy_map.clear ();
        energy_ncompute = 0;
        energy_nrequest = 0;
      }
      long unsigned int GetNbEnergyCompute () {return energy_ncompute;}
      long unsigned int GetNbEnergyRequest () {return energy_nrequest;}
      Preferred GetPreferred() { return LowScore; }
      Convergence GetConvergence() { return Lowest; }
      double Score(OBMol &mol, unsigned int index, const RotorKeys &keys,
          const std::vector<double*> &conformers);
    private:
      mapRotorEnergy energy_map;
      long unsigned int energy_ncompute;
      long unsigned int energy_nrequest;
  };
  
  class OBAPI OBMinimizingEnergyConformerScore : public OBConformerScore
  {
    public:
      OBMinimizingEnergyConformerScore () {
        energy_map.clear ();
        energy_ncompute = 0;
        energy_nrequest = 0;
      }
      long unsigned int GetNbEnergyCompute () {return energy_ncompute;}
      long unsigned int GetNbEnergyRequest () {return energy_nrequest;}
      Preferred GetPreferred() { return LowScore; }
      Convergence GetConvergence() { return Lowest; }
      double Score(OBMol &mol, unsigned int index, const RotorKeys &keys,
          const std::vector<double*> &conformers);
    private:
      mapRotorEnergy energy_map;
      long unsigned int energy_ncompute;
      long unsigned int energy_nrequest;
  };

  class OBAPI OBMinimizingRMSDConformerScore : 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);
  };

  //
  //  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 PrintRotors(bool printrotors) { m_printrotors = printrotors; }

      void Search();

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

      void GetConformers(OBMol &mol);

      /* @brief Set an output stream for logging. If NULL pointer is provided, logging is disabled. */
      void SetLogStream  (std::ostream *sptr) {m_logstream = sptr;}

      /*************************************************/
      /* Methods related to fitness sharing parameters */
      
      /* @brief Set the use of fitness sharing ON (default) or OFF*/
      void SetSharing (bool value = true)  {use_sharing = value;}
      
      /* @brief Get the targeted number of niches, for dynamic niche sharing */
      int GetNbNiches () {return nb_niches;}
      
      /* @brief Set the targeted number of niches, for dynamic niche sharing */
      void SetNbNiches (int value) {nb_niches = value;}
      
      /* @brief Get niches radius, for dynamic niche sharing.*/
      double GetNicheRadius () {return niche_radius;}
      
      /* @brief Set niches radius, for dynamic niche sharing.*/
      void SetNicheRadius (double value) {niche_radius = value;}
      
      /* @brief Get the alpha sharing parameter */
      double GetAlphaSharing () {return alpha_share;}
      
      /* @brief Set the alpha sharing parameter */
      void SetAlphaSharing (double value) {alpha_share = value;}
      
      /* @brief Get the sigma sharing parameter */
      double GetSigmaSharing () {return sigma_share;}
      
      /* @brief Set the sigma sharing parameter */
      void SetSigmaSharing (double value) {sigma_share = value;}
      
      /* @brief Get the (uniform) crossover probability */
      double GetCrossoverProbability () {return p_crossover;}
      
      /* @brief Set the (uniform) crossover probability */
      void SetCrossoverProbability (double value) {p_crossover = value;}
      
      /* @brief Get the niche mating probability, for dynamic niche sharing */
      double GetNicheMating () {return niche_mating;}
      
      /* @brief Set the (uniform) crossover probability */
      void SetNicheMating (double value) {niche_mating = value;}
      
      /* @brief Set the local optimization rate */
      void SetLocalOptRate (int value) {local_opt_rate = value;}
      
      /* @brief Get the local optimization rate*/
      int  SetLocalOptRate() {return local_opt_rate;}
    
    private:
      void NextGeneration();
      double MakeSelection();
      bool IsUniqueKey(const RotorKeys &keys, const RotorKey &key) const;
      bool IsGood(const RotorKey &key);

      int key_distance (const RotorKey &key1, const RotorKey &key2);      
      int local_opt ();
      int reproduce (RotorKey &key1, RotorKey &key2);
      int score_population ();
      int share_fitness ();
      double sharing_generation ();

      unsigned int m_numConformers; 
      int m_numChildren; 
      int m_mutability; 
      int m_convergence; 
      
      std::vector<double> vscores;                    
      std::vector<double> vshared_fitnes;             
      std::vector<std::vector <int> > dynamic_niches; 
      std::vector<int> niche_map;                     
      
      void *d; // Opaque pointer - currently for storing OBRandom* which may be removed in future
      bool use_sharing;         
      double alpha_share;       
      double sigma_share;               
      int nb_niches;            
      double niche_radius;              
      double p_crossover;       
      double niche_mating;      
      int local_opt_rate;       
      OBBitVec      m_fixedBonds; 
      OBMol         m_mol; 
      OBRotorList   m_rotorList; 
      RotorKeys     m_rotorKeys; 
      bool          m_printrotors; 

      OBConformerFilter *m_filter;
      OBConformerScore  *m_score;

      std::ostream *m_logstream;        
  };

};

#endif