MMFF.h
Go to the documentation of this file.
//
// Copyright (C) 2015 Greg Landrum
//
// @@ All Rights Reserved @@
// This file is part of the RDKit.
// The contents are covered by the terms of the BSD license
// which is included in the file license.txt, found at the root
// of the RDKit source tree.
//
#ifndef RD_MMFFCONVENIENCE_H
#define RD_MMFFCONVENIENCE_H
#include <ForceField/ForceField.h>
#include "Builder.h"
#ifdef RDK_THREADSAFE_SSS
#include <boost/thread.hpp>
#endif
namespace RDKit {
class ROMol;
namespace MMFF {
//! Convenience function for optimizing a molecule using MMFF
/*
\param mol the molecule to use
\param maxIters the maximum number of force-field iterations
\param mmffVariant the MMFF variant to use, should be "MMFF94" or "MMFF94S"
\param nonBondedThresh the threshold to be used in adding non-bonded terms
to the force field. Any non-bonded contact whose current
distance is greater than \c nonBondedThresh * the minimum value
for that contact will not be included.
\param confId the optional conformer id, if this isn't provided, the molecule's
default confId will be used.
\param ignoreInterfragInteractions if true, nonbonded terms will not be added between
fragments
\return a pair with:
first: -1 if parameters were missing, 0 if the optimization converged, 1 if more iterations are required.
second: the energy
*/
std::pair<int,double> MMFFOptimizeMolecule(ROMol &mol, int maxIters=1000,
std::string mmffVariant="MMFF94",
double nonBondedThresh=10.0, int confId=-1,
bool ignoreInterfragInteractions=true ){
int res = -1;
double e = -1;
MMFF::MMFFMolProperties mmffMolProperties(mol, mmffVariant);
if (mmffMolProperties.isValid()) {
ForceFields::ForceField *ff=MMFF::constructForceField(mol,nonBondedThresh, confId,
ignoreInterfragInteractions);
ff->initialize();
res=ff->minimize(maxIters);
e=ff->calcEnergy();
delete ff;
}
return std::make_pair(res,e);
}
#ifdef RDK_THREADSAFE_SSS
namespace detail {
void MMFFOptimizeMoleculeConfsHelper_(ForceFields::ForceField ff,
ROMol *mol,
std::vector< std::pair<int, double> > *res,
unsigned int threadIdx,
unsigned int numThreads,
int maxIters){
unsigned int i=0;
ff.positions().resize(mol->getNumAtoms());
for(ROMol::ConformerIterator cit=mol->beginConformers();
cit!=mol->endConformers();++cit,++i){
if(i%numThreads != threadIdx) continue;
for(unsigned int aidx=0;aidx<mol->getNumAtoms();++aidx){
ff.positions()[aidx]=&(*cit)->getAtomPos(aidx);
}
ff.initialize();
int needsMore=ff.minimize(maxIters);
double e=ff.calcEnergy();
(*res)[i] = std::make_pair(needsMore,e);
}
}
} //end of detail namespace
#endif
//! Convenience function for optimizing all of a molecule's conformations using MMFF
/*
\param mol the molecule to use
\param res vector of (needsMore,energy) pairs
\param numThreads the number of simultaneous threads to use (only has an
effect if the RDKit is compiled with thread support).
\param maxIters the maximum number of force-field iterations
\param mmffVariant the MMFF variant to use, should be "MMFF94" or "MMFF94S"
\param nonBondedThresh the threshold to be used in adding non-bonded terms
to the force field. Any non-bonded contact whose current
distance is greater than \c nonBondedThresh * the minimum value
for that contact will not be included.
\param ignoreInterfragInteractions if true, nonbonded terms will not be added between
fragments
*/
void MMFFOptimizeMoleculeConfs(ROMol &mol,
std::vector< std::pair<int, double> > &res,
unsigned int numThreads=1,
int maxIters=1000,
std::string mmffVariant="MMFF94",
double nonBondedThresh=10.0,
bool ignoreInterfragInteractions=true ){
res.resize(mol.getNumConformers());
#ifndef RDK_THREADSAFE_SSS
numThreads=1;
#endif
if(numThreads<=1){
unsigned int i=0;
for(ROMol::ConformerIterator cit=mol.beginConformers();
cit!=mol.endConformers();++cit,++i){
res[i] = MMFFOptimizeMolecule(mol,maxIters,mmffVariant,
nonBondedThresh,(*cit)->getId(),
ignoreInterfragInteractions);
}
}
#ifdef RDK_THREADSAFE_SSS
else {
MMFF::MMFFMolProperties mmffMolProperties(mol, mmffVariant);
if(mmffMolProperties.isValid()) {
ForceFields::ForceField *ff=MMFF::constructForceField(mol,nonBondedThresh, -1,
ignoreInterfragInteractions);
boost::thread_group tg;
for(unsigned int ti=0;ti<numThreads;++ti){
tg.add_thread(new boost::thread(detail::MMFFOptimizeMoleculeConfsHelper_,
*ff,
&mol,&res,ti,numThreads,maxIters));
}
tg.join_all();
delete ff;
} else {
for(unsigned int i=0;i<mol.getNumConformers();++i){
res[i] = std::make_pair(static_cast<int>(-1),static_cast<double>(-1));
}
}
}
#endif
}
} // end of namespace UFF
} // end of namespace RDKit
#endif
RDKit::MMFF::MMFFOptimizeMolecule
std::pair< int, double > MMFFOptimizeMolecule(ROMol &mol, int maxIters=1000, std::string mmffVariant="MMFF94", double nonBondedThresh=10.0, int confId=-1, bool ignoreInterfragInteractions=true)
Convenience function for optimizing a molecule using MMFF.
Definition: MMFF.h:40
ForceFields::ForceField::calcEnergy
double calcEnergy() const
calculates and returns the energy (in kcal/mol) based on existing positions in the forcefield ...
RDKit::ROMol::getNumConformers
unsigned int getNumConformers() const
Definition: ROMol.h:315
ForceFields::ForceField::positions
RDGeom::PointPtrVect & positions()
returns a reference to our points (a PointPtrVect)
Definition: ForceField.h:137
ForceField.h
RDKit::ROMol::getNumAtoms
unsigned int getNumAtoms(bool onlyExplicit=1) const
returns our number of atoms
ForceFields::ForceField::minimize
int minimize(unsigned int maxIts=200, double forceTol=1e-4, double energyTol=1e-6)
minimizes the energy of the system by following gradients
RDKit::ROMol
ROMol is a molecule class that is intended to have a fixed topology.
Definition: ROMol.h:105
RDKit::MMFF::MMFFOptimizeMoleculeConfs
void MMFFOptimizeMoleculeConfs(ROMol &mol, std::vector< std::pair< int, double > > &res, unsigned int numThreads=1, int maxIters=1000, std::string mmffVariant="MMFF94", double nonBondedThresh=10.0, bool ignoreInterfragInteractions=true)
Convenience function for optimizing all of a molecule's conformations using MMFF. ...
Definition: MMFF.h:97
ForceFields::ForceField::initialize
void initialize()
does initialization
detail
Definition: types.h:23
RDKit
Includes a bunch of functionality for handling Atom and Bond queries.
Definition: Atom.h:28
RDKit::ROMol::endConformers
ConformerIterator endConformers()
Definition: ROMol.h:498
RDKit::MMFF::MMFFMolProperties
Definition: MMFF/AtomTyper.h:52
RDKit::ROMol::beginConformers
ConformerIterator beginConformers()
Definition: ROMol.h:494
RDKit::MMFF::constructForceField
ForceFields::ForceField * constructForceField(ROMol &mol, double nonBondedThresh=100.0, int confId=-1, bool ignoreInterfragInteractions=true)
Builds and returns a MMFF force field for a molecule.
Builder.h
ForceFields::ForceField
A class to store forcefields and handle minimization.
Definition: ForceField.h:56
RDKit::MMFF::MMFFMolProperties::isValid
bool isValid()
Definition: MMFF/AtomTyper.h:189