Groups a variety of molecular query and transformation operations. More...

Namespaces
namespace	details

Classes
struct	AdjustQueryParameters
	Parameters controlling the behavior of MolOps::adjustQueryProperties. More...

class	Hybridizations

struct	RemoveHsParameters

Functions
RDKIT_GRAPHMOL_EXPORT int	countAtomElec (const Atom *at)

RDKIT_GRAPHMOL_EXPORT int	getFormalCharge (const ROMol &mol)
	sums up all atomic formal charges and returns the result

RDKIT_GRAPHMOL_EXPORT bool	atomHasConjugatedBond (const Atom *at)
	returns whether or not the given Atom is involved in a conjugated bond

RDKIT_GRAPHMOL_EXPORT unsigned int	getMolFrags (const ROMol &mol, std::vector< int > &mapping)
	find fragments (disconnected components of the molecular graph)

RDKIT_GRAPHMOL_EXPORT unsigned int	getMolFrags (const ROMol &mol, std::vector< std::vector< int > > &frags)
	find fragments (disconnected components of the molecular graph)

RDKIT_GRAPHMOL_EXPORT unsigned int	getMolFrags (const ROMol &mol, std::vector< std::unique_ptr< ROMol > > &molFrags, bool sanitizeFrags=true, std::vector< int > frags=nullptr, std::vector< std::vector< int > > fragsMolAtomMapping=nullptr, bool copyConformers=true)

RDKIT_GRAPHMOL_EXPORT std::vector< boost::shared_ptr< ROMol > >	getMolFrags (const ROMol &mol, bool sanitizeFrags=true, std::vector< int > frags=nullptr, std::vector< std::vector< int > > fragsMolAtomMapping=nullptr, bool copyConformers=true)

template<typename T >
RDKIT_GRAPHMOL_EXPORT std::map< T, boost::shared_ptr< ROMol > >	getMolFragsWithQuery (const ROMol &mol, T(query)(const ROMol &, const Atom ), bool sanitizeFrags=true, const std::vector< T > *whiteList=nullptr, bool negateList=false)
	splits a molecule into pieces based on labels assigned using a query

template<typename T >
RDKIT_GRAPHMOL_EXPORT unsigned int	getMolFragsWithQuery (const ROMol &mol, T(query)(const ROMol &, const Atom ), std::map< T, std::unique_ptr< ROMol > > &molFrags, bool sanitizeFrags=true, const std::vector< T > *whiteList=nullptr, bool negateList=false)

RDKIT_GRAPHMOL_EXPORT unsigned	getNumAtomsWithDistinctProperty (const ROMol &mol, std::string prop)
	returns the number of atoms which have a particular property set

RDKIT_GRAPHMOL_EXPORT bool	needsHs (const ROMol &mol)
	returns whether or not a molecule needs to have Hs added to it.

RDKIT_GRAPHMOL_EXPORT ROMol *	hapticBondsToDative (const ROMol &mol)
	Replaces haptic bond with explicit dative bonds.

RDKIT_GRAPHMOL_EXPORT void	hapticBondsToDative (RWMol &mol)

RDKIT_GRAPHMOL_EXPORT ROMol *	dativeBondsToHaptic (const ROMol &mol)
	Replaces explicit dative bonds with haptic.

RDKIT_GRAPHMOL_EXPORT void	dativeBondsToHaptic (RWMol &mol)

RDKIT_GRAPHMOL_EXPORT double	getAvgMolWt (const ROMol &mol, bool onlyHeavy=false)

RDKIT_GRAPHMOL_EXPORT double	getExactMolWt (const ROMol &mol, bool onlyHeavy=false)

RDKIT_GRAPHMOL_EXPORT std::string	getMolFormula (const ROMol &mol, bool separateIsotopes=false, bool abbreviateHIsotopes=true)

RDKIT_GRAPHMOL_EXPORT void	expandAttachmentPoints (RWMol &mol, bool addAsQueries=true, bool addCoords=true)

RDKIT_GRAPHMOL_EXPORT void	collapseAttachmentPoints (RWMol &mol, bool markedOnly=true)

Ring finding and SSSR
RDKIT_GRAPHMOL_EXPORT int	findSSSR (const ROMol &mol, std::vector< std::vector< int > > &res, bool includeDativeBonds=false)
	finds a molecule's Smallest Set of Smallest Rings

RDKIT_GRAPHMOL_EXPORT int	findSSSR (const ROMol &mol, std::vector< std::vector< int > > *res=nullptr, bool includeDativeBonds=false)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

RDKIT_GRAPHMOL_EXPORT void	fastFindRings (const ROMol &mol)
	use a DFS algorithm to identify ring bonds and atoms in a molecule

RDKIT_GRAPHMOL_EXPORT void	findRingFamilies (const ROMol &mol)

RDKIT_GRAPHMOL_EXPORT int	symmetrizeSSSR (ROMol &mol, std::vector< std::vector< int > > &res, bool includeDativeBonds=false)
	symmetrize the molecule's Smallest Set of Smallest Rings

RDKIT_GRAPHMOL_EXPORT int	symmetrizeSSSR (ROMol &mol, bool includeDativeBonds=false)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Shortest paths and other matrices
RDKIT_GRAPHMOL_EXPORT double *	getAdjacencyMatrix (const ROMol &mol, bool useBO=false, int emptyVal=0, bool force=false, const char propNamePrefix=nullptr, const boost::dynamic_bitset<> bondsToUse=nullptr)
	returns a molecule's adjacency matrix

RDKIT_GRAPHMOL_EXPORT double *	getDistanceMat (const ROMol &mol, bool useBO=false, bool useAtomWts=false, bool force=false, const char *propNamePrefix=nullptr)
	Computes the molecule's topological distance matrix.

RDKIT_GRAPHMOL_EXPORT double *	getDistanceMat (const ROMol &mol, const std::vector< int > &activeAtoms, const std::vector< const Bond * > &bonds, bool useBO=false, bool useAtomWts=false)
	Computes the molecule's topological distance matrix.

RDKIT_GRAPHMOL_EXPORT double *	get3DDistanceMat (const ROMol &mol, int confId=-1, bool useAtomWts=false, bool force=false, const char *propNamePrefix=nullptr)
	Computes the molecule's 3D distance matrix.

RDKIT_GRAPHMOL_EXPORT std::list< int >	getShortestPath (const ROMol &mol, int aid1, int aid2)
	Find the shortest path between two atoms.

Stereochemistry
RDKIT_GRAPHMOL_EXPORT void	cleanupChirality (RWMol &mol)
	removes bogus chirality markers (e.g. tetrahedral flags on non-sp3 centers):

RDKIT_GRAPHMOL_EXPORT void	cleanupAtropisomers (RWMol &)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

RDKIT_GRAPHMOL_EXPORT void	cleanupAtropisomers (RWMol &mol, Hybridizations &hybridizations)

RDKIT_GRAPHMOL_EXPORT void	assignChiralTypesFrom3D (ROMol &mol, int confId=-1, bool replaceExistingTags=true)
	Uses a conformer to assign ChiralTypes to a molecule's atoms.

RDKIT_GRAPHMOL_EXPORT void	assignStereochemistryFrom3D (ROMol &mol, int confId=-1, bool replaceExistingTags=true)
	Uses a conformer to assign ChiralTypes to a molecule's atoms and stereo flags to its bonds.

RDKIT_GRAPHMOL_EXPORT void	assignChiralTypesFromBondDirs (ROMol &mol, int confId=-1, bool replaceExistingTags=true)
	Use bond directions to assign ChiralTypes to a molecule's atoms and stereo flags to its bonds.

RDKIT_GRAPHMOL_EXPORT void	detectBondStereochemistry (ROMol &mol, int confId=-1)

RDKIT_GRAPHMOL_EXPORT void	setDoubleBondNeighborDirections (ROMol &mol, const Conformer *conf=nullptr)
	Sets bond directions based on double bond stereochemistry.

RDKIT_GRAPHMOL_EXPORT void	clearSingleBondDirFlags (ROMol &mol, bool onlyWedgeFlags=false)

RDKIT_GRAPHMOL_EXPORT void	clearAllBondDirFlags (ROMol &mol)

RDKIT_GRAPHMOL_EXPORT void	clearDirFlags (ROMol &mol, bool onlyWedgeFlags=false)

RDKIT_GRAPHMOL_EXPORT void	setBondStereoFromDirections (ROMol &mol)

RDKIT_GRAPHMOL_EXPORT void	assignStereochemistry (ROMol &mol, bool cleanIt=false, bool force=false, bool flagPossibleStereoCenters=false)
	Assign stereochemistry tags to atoms and bonds.

RDKIT_GRAPHMOL_EXPORT void	removeStereochemistry (ROMol &mol)

RDKIT_GRAPHMOL_EXPORT void	findPotentialStereoBonds (ROMol &mol, bool cleanIt=false)
	finds bonds that could be cis/trans in a molecule and mark them as Bond::STEREOANY.

RDKIT_GRAPHMOL_EXPORT void	assignChiralTypesFromMolParity (ROMol &mol, bool replaceExistingTags=true)
	Uses the molParity atom property to assign ChiralType to a molecule's atoms.

Dealing with hydrogens
enum	AdjustQueryWhichFlags { ADJUST_IGNORENONE = 0x0 , ADJUST_IGNORECHAINS = 0x1 , ADJUST_IGNORERINGS = 0x4 , ADJUST_IGNOREDUMMIES = 0x2 , ADJUST_IGNORENONDUMMIES = 0x8 , ADJUST_IGNOREMAPPED = 0x10 , ADJUST_IGNOREALL = 0xFFFFFFF }

RDKIT_GRAPHMOL_EXPORT ROMol *	addHs (const ROMol &mol, bool explicitOnly=false, bool addCoords=false, const UINT_VECT *onlyOnAtoms=nullptr, bool addResidueInfo=false)
	returns a copy of a molecule with hydrogens added in as explicit Atoms

RDKIT_GRAPHMOL_EXPORT void	addHs (RWMol &mol, bool explicitOnly=false, bool addCoords=false, const UINT_VECT *onlyOnAtoms=nullptr, bool addResidueInfo=false)

RDKIT_GRAPHMOL_EXPORT void	setTerminalAtomCoords (ROMol &mol, unsigned int idx, unsigned int otherIdx)

RDKIT_GRAPHMOL_EXPORT ROMol *	removeHs (const ROMol &mol, bool implicitOnly=false, bool updateExplicitCount=false, bool sanitize=true)
	returns a copy of a molecule with hydrogens removed

RDKIT_GRAPHMOL_EXPORT void	removeHs (RWMol &mol, bool implicitOnly=false, bool updateExplicitCount=false, bool sanitize=true)

RDKIT_GRAPHMOL_EXPORT void	removeHs (RWMol &mol, const RemoveHsParameters &ps, bool sanitize=true)

RDKIT_GRAPHMOL_EXPORT ROMol *	removeHs (const ROMol &mol, const RemoveHsParameters &ps, bool sanitize=true)

RDKIT_GRAPHMOL_EXPORT void	removeAllHs (RWMol &mol, bool sanitize=true)
	removes all Hs from a molecule

RDKIT_GRAPHMOL_EXPORT ROMol *	removeAllHs (const ROMol &mol, bool sanitize=true)

RDKIT_GRAPHMOL_EXPORT ROMol *	mergeQueryHs (const ROMol &mol, bool mergeUnmappedOnly=false, bool mergeIsotopes=false)

RDKIT_GRAPHMOL_EXPORT void	mergeQueryHs (RWMol &mol, bool mergeUnmappedOnly=false, bool mergeIsotopes=false)

RDKIT_GRAPHMOL_EXPORT std::pair< bool, bool >	hasQueryHs (const ROMol &mol)
	returns a pair of booleans (hasQueryHs, hasUnmergaebleQueryHs)

RDKIT_GRAPHMOL_EXPORT void	parseAdjustQueryParametersFromJSON (MolOps::AdjustQueryParameters &p, const std::string &json)
	updates an AdjustQueryParameters object from a JSON string

RDKIT_GRAPHMOL_EXPORT ROMol *	adjustQueryProperties (const ROMol &mol, const AdjustQueryParameters *params=nullptr)
	returns a copy of a molecule with query properties adjusted

RDKIT_GRAPHMOL_EXPORT void	adjustQueryProperties (RWMol &mol, const AdjustQueryParameters *params=nullptr)

RDKIT_GRAPHMOL_EXPORT ROMol *	renumberAtoms (const ROMol &mol, const std::vector< unsigned int > &newOrder)
	returns a copy of a molecule with the atoms renumbered

Sanitization
{
enum	SanitizeFlags { SANITIZE_NONE = 0x0 , SANITIZE_CLEANUP = 0x1 , SANITIZE_PROPERTIES = 0x2 , SANITIZE_SYMMRINGS = 0x4 , SANITIZE_KEKULIZE = 0x8 , SANITIZE_FINDRADICALS = 0x10 , SANITIZE_SETAROMATICITY = 0x20 , SANITIZE_SETCONJUGATION = 0x40 , SANITIZE_SETHYBRIDIZATION = 0x80 , SANITIZE_CLEANUPCHIRALITY = 0x100 , SANITIZE_ADJUSTHS = 0x200 , SANITIZE_CLEANUP_ORGANOMETALLICS = 0x400 , SANITIZE_CLEANUPATROPISOMERS = 0x800 , SANITIZE_ALL = 0xFFFFFFF }

enum	AromaticityModel { AROMATICITY_DEFAULT = 0x0 , AROMATICITY_RDKIT = 0x1 , AROMATICITY_SIMPLE = 0x2 , AROMATICITY_MDL = 0x4 , AROMATICITY_MMFF94 = 0x8 , AROMATICITY_CUSTOM = 0xFFFFFFF }
	Possible aromaticity models. More...

RDKIT_GRAPHMOL_EXPORT void	sanitizeMol (RWMol &mol, unsigned int &operationThatFailed, unsigned int sanitizeOps=SANITIZE_ALL)
	carries out a collection of tasks for cleaning up a molecule and ensuring that it makes "chemical sense"

RDKIT_GRAPHMOL_EXPORT void	sanitizeMol (RWMol &mol)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

RDKIT_GRAPHMOL_EXPORT std::vector< std::unique_ptr< MolSanitizeException > >	detectChemistryProblems (const ROMol &mol, unsigned int sanitizeOps=SANITIZE_ALL)
	Identifies chemistry problems (things that don't make chemical sense) in a molecule.

RDKIT_GRAPHMOL_EXPORT void	setMMFFAromaticity (RWMol &mol)

RDKIT_GRAPHMOL_EXPORT int	setAromaticity (RWMol &mol, AromaticityModel model=AROMATICITY_DEFAULT, int(*func)(RWMol &)=nullptr)
	Sets up the aromaticity for a molecule.

RDKIT_GRAPHMOL_EXPORT void	cleanUp (RWMol &mol)

RDKIT_GRAPHMOL_EXPORT void	cleanUpOrganometallics (RWMol &mol)

RDKIT_GRAPHMOL_EXPORT void	assignRadicals (RWMol &mol)
	Called by the sanitizer to assign radical counts to atoms.

RDKIT_GRAPHMOL_EXPORT void	adjustHs (RWMol &mol)
	adjust the number of implicit and explicit Hs for special cases

RDKIT_GRAPHMOL_EXPORT void	Kekulize (RWMol &mol, bool markAtomsBonds=true, unsigned int maxBackTracks=100)
	Kekulizes the molecule.

RDKIT_GRAPHMOL_EXPORT bool	KekulizeIfPossible (RWMol &mol, bool markAtomsBonds=true, unsigned int maxBackTracks=100)

RDKIT_GRAPHMOL_EXPORT void	setConjugation (ROMol &mol)
	flags the molecule's conjugated bonds

RDKIT_GRAPHMOL_EXPORT void	setHybridization (ROMol &mol)
	calculates and sets the hybridization of all a molecule's Stoms

Detailed Description

Groups a variety of molecular query and transformation operations.

Enumeration Type Documentation

◆ AdjustQueryWhichFlags

enum RDKit::MolOps::AdjustQueryWhichFlags

Enumerator
ADJUST_IGNORENONE
ADJUST_IGNORECHAINS
ADJUST_IGNORERINGS
ADJUST_IGNOREDUMMIES
ADJUST_IGNORENONDUMMIES
ADJUST_IGNOREMAPPED
ADJUST_IGNOREALL

Definition at line 373 of file MolOps.h.

◆ AromaticityModel

enum RDKit::MolOps::AromaticityModel

Possible aromaticity models.

AROMATICITY_DEFAULT at the moment always uses AROMATICITY_RDKIT
AROMATICITY_RDKIT is the standard RDKit model (as documented in the RDKit Book)
AROMATICITY_SIMPLE only considers 5- and 6-membered simple rings (it does not consider the outer envelope of fused rings)
AROMATICITY_MDL
AROMATICITY_CUSTOM uses a caller-provided function

Enumerator
AROMATICITY_DEFAULT	future proofing
AROMATICITY_RDKIT
AROMATICITY_SIMPLE
AROMATICITY_MDL
AROMATICITY_MMFF94
AROMATICITY_CUSTOM	use a function

Definition at line 588 of file MolOps.h.

◆ SanitizeFlags

enum RDKit::MolOps::SanitizeFlags

Enumerator
SANITIZE_NONE
SANITIZE_CLEANUP
SANITIZE_PROPERTIES
SANITIZE_SYMMRINGS
SANITIZE_KEKULIZE
SANITIZE_FINDRADICALS
SANITIZE_SETAROMATICITY
SANITIZE_SETCONJUGATION
SANITIZE_SETHYBRIDIZATION
SANITIZE_CLEANUPCHIRALITY
SANITIZE_ADJUSTHS
SANITIZE_CLEANUP_ORGANOMETALLICS
SANITIZE_CLEANUPATROPISOMERS
SANITIZE_ALL

Definition at line 494 of file MolOps.h.

Function Documentation

◆ addHs() [1/2]

RDKIT_GRAPHMOL_EXPORT ROMol * RDKit::MolOps::addHs	(	const ROMol &	mol,
		bool	explicitOnly = `false`,
		bool	addCoords = `false`,
		const UINT_VECT *	onlyOnAtoms = `nullptr`,
		bool	addResidueInfo = `false`
	)

returns a copy of a molecule with hydrogens added in as explicit Atoms

Parameters

mol	the molecule to add Hs to
explicitOnly	(optional) if this `true`, only explicit Hs will be added
addCoords	(optional) If this is true, estimates for the atomic coordinates of the added Hs will be used.
onlyOnAtoms	(optional) if provided, this should be a vector of IDs of the atoms that will be considered for H addition.
addResidueInfo	(optional) if this is true, add residue info to hydrogen atoms (useful for PDB files).

Returns: the new molecule

Notes:

it makes no sense to use the addCoords option if the molecule's heavy atoms don't already have coordinates.
the caller is responsible for deleteing the pointer this returns.

◆ addHs() [2/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::addHs	(	RWMol &	mol,
		bool	explicitOnly = `false`,
		bool	addCoords = `false`,
		const UINT_VECT *	onlyOnAtoms = `nullptr`,
		bool	addResidueInfo = `false`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. modifies the molecule in place

◆ adjustHs()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::adjustHs ( RWMol & mol )

adjust the number of implicit and explicit Hs for special cases

Currently this:

modifies aromatic nitrogens so that, when appropriate, they have an explicit H marked (e.g. so that we get things like "c1cc[nH]cc1"

Parameters

mol	the molecule of interest

Assumptions

this is called after the molecule has been sanitized, aromaticity has been perceived, and the implicit valence of everything has been calculated.

◆ adjustQueryProperties() [1/2]

RDKIT_GRAPHMOL_EXPORT ROMol * RDKit::MolOps::adjustQueryProperties	(	const ROMol &	mol,
		const AdjustQueryParameters *	params = `nullptr`
	)

returns a copy of a molecule with query properties adjusted

Parameters

mol	the molecule to adjust
params	controls the adjustments made

Returns: the new molecule, the caller owns the memory

◆ adjustQueryProperties() [2/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::adjustQueryProperties	(	RWMol &	mol,
		const AdjustQueryParameters *	params = `nullptr`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. modifies the molecule in place

◆ assignChiralTypesFrom3D()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::assignChiralTypesFrom3D	(	ROMol &	mol,
		int	confId = `-1`,
		bool	replaceExistingTags = `true`
	)

Uses a conformer to assign ChiralTypes to a molecule's atoms.

Parameters

mol	the molecule of interest
confId	the conformer to use
replaceExistingTags	if this flag is true, any existing atomic chiral tags will be replaced

If the conformer provided is not a 3D conformer, nothing will be done.

NOTE that this does not check to see if atoms are chiral centers (i.e. all substituents are different), it merely sets the chiral type flags based on the coordinates and atom ordering. Use assignStereochemistryFrom3D() if you want chiral flags only on actual stereocenters.

◆ assignChiralTypesFromBondDirs()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::assignChiralTypesFromBondDirs	(	ROMol &	mol,
		int	confId = `-1`,
		bool	replaceExistingTags = `true`
	)

Use bond directions to assign ChiralTypes to a molecule's atoms and stereo flags to its bonds.

Parameters

mol	the molecule of interest
confId	the conformer to use
replaceExistingTags	if this flag is true, any existing info about stereochemistry will be replaced

◆ assignChiralTypesFromMolParity()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::assignChiralTypesFromMolParity	(	ROMol &	mol,
		bool	replaceExistingTags = `true`
	)

Uses the molParity atom property to assign ChiralType to a molecule's atoms.

Parameters

mol	the molecule of interest
replaceExistingTags	if this flag is true, any existing atomic chiral tags will be replaced

◆ assignRadicals()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::assignRadicals ( RWMol & mol )

Called by the sanitizer to assign radical counts to atoms.

◆ assignStereochemistry()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::assignStereochemistry	(	ROMol &	mol,
		bool	cleanIt = `false`,
		bool	force = `false`,
		bool	flagPossibleStereoCenters = `false`
	)

Assign stereochemistry tags to atoms and bonds.

If useLegacyStereoPerception is true, it also does the CIP stereochemistry assignment for the molecule's atoms (R/S) and double bonds (Z/E). This assignment is based on legacy code which is fast, but is known to incorrectly assign CIP labels in some cases. instead, to assign CIP labels based on an accurate, though slower, implementation of the CIP rules, call CIPLabeler::assignCIPLabels(). Chiral atoms will have a property '_CIPCode' indicating their chiral code.

Parameters

mol	the molecule to use
cleanIt	if true, any existing values of the property `_CIPCode` will be cleared, atoms with a chiral specifier that aren't actually chiral (e.g. atoms with duplicate substituents or only 2 substituents, etc.) will have their chiral code set to CHI_UNSPECIFIED. Bonds with STEREOCIS/STEREOTRANS specified that have duplicate substituents based upon the CIP atom ranks will be marked STEREONONE.
force	causes the calculation to be repeated even if it has already been done
flagPossibleStereoCenters	set the _ChiralityPossible property on atoms that are possible stereocenters

Notes:M

Throughout we assume that we're working with a hydrogen-suppressed graph.

◆ assignStereochemistryFrom3D()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::assignStereochemistryFrom3D	(	ROMol &	mol,
		int	confId = `-1`,
		bool	replaceExistingTags = `true`
	)

Uses a conformer to assign ChiralTypes to a molecule's atoms and stereo flags to its bonds.

Parameters

mol	the molecule of interest
confId	the conformer to use
replaceExistingTags	if this flag is true, any existing info about stereochemistry will be replaced

If the conformer provided is not a 3D conformer, nothing will be done.

◆ atomHasConjugatedBond()

RDKIT_GRAPHMOL_EXPORT bool RDKit::MolOps::atomHasConjugatedBond ( const Atom * at )

returns whether or not the given Atom is involved in a conjugated bond

◆ cleanUp()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::cleanUp ( RWMol & mol )

Designed to be called by the sanitizer to handle special cases before anything is done.

Currently this:

modifies nitro groups, so that the nitrogen does not have an unreasonable valence of 5, as follows:
- the nitrogen gets a positive charge
- one of the oxygens gets a negative chage and the double bond to this oxygen is changed to a single bond The net result is that nitro groups can be counted on to be: "[N+](=O)[O-]"
modifies halogen-oxygen containing species as follows: [Cl,Br,I](=O)(=O)(=O)O -> [X+3]([O-])([O-])([O-])O [Cl,Br,I](=O)(=O)O -> [X+3]([O-])([O-])O [Cl,Br,I](=O)O -> [X+]([O-])O
converts the substructure [N,C]=P(=O)-* to [N,C]=[P+](-[O-])-*

Parameters

mol	the molecule of interest

◆ cleanupAtropisomers() [1/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::cleanupAtropisomers ( RWMol & )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ cleanupAtropisomers() [2/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::cleanupAtropisomers	(	RWMol &	mol,
		Hybridizations &	hybridizations
	)

removes bogus atropisomeric markers (e.g. those without sp2 begin and end atoms):

◆ cleanupChirality()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::cleanupChirality ( RWMol & mol )

removes bogus chirality markers (e.g. tetrahedral flags on non-sp3 centers):

◆ cleanUpOrganometallics()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::cleanUpOrganometallics ( RWMol & mol )

Designed to be called by the sanitizer to handle special cases for organometallic species before valence is perceived

Note that this function is experimental and may either change in behavior or be replaced with something else in future releases.

Currently this:

replaces single bonds between "hypervalent" organic atoms and metals with dative bonds (this is following an IUPAC recommendation: https://iupac.qmul.ac.uk/tetrapyrrole/TP8.html)

Parameters

mol	the molecule of interest

◆ clearAllBondDirFlags()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::clearAllBondDirFlags ( ROMol & mol )

removes directions from all bonds. Wiggly bonds and cross bonds will have the property _UnknownStereo set on them

◆ clearDirFlags()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::clearDirFlags	(	ROMol &	mol,
		bool	onlyWedgeFlags = `false`
	)

◆ clearSingleBondDirFlags()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::clearSingleBondDirFlags	(	ROMol &	mol,
		bool	onlyWedgeFlags = `false`
	)

removes directions from single bonds. Wiggly bonds will have the property _UnknownStereo set on them

◆ collapseAttachmentPoints()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::collapseAttachmentPoints	(	RWMol &	mol,
		bool	markedOnly = `true`
	)

dummy atoms in the graph are removed and replaced with attachment point annotations on the attached atoms

Parameters

mol	the molecule of interest
markedOnly	if true, only dummy atoms with the _fromAttachPoint property will be collapsed

In order for a dummy atom to be considered for collapsing it must have:

degree 1 with a single or unspecified bond
the bond to it can not be wedged
either no query or be an AtomNullQuery

◆ countAtomElec()

RDKIT_GRAPHMOL_EXPORT int RDKit::MolOps::countAtomElec ( const Atom * at )

return the number of electrons available on an atom to donate for aromaticity

The result is determined using the default valency, number of lone pairs, number of bonds and the formal charge. Note that the atom may not donate all of these electrons to a ring for aromaticity (also used in Conjugation and hybridization code).

Parameters

at	the atom of interest

Returns: the number of electrons

◆ dativeBondsToHaptic() [1/2]

RDKIT_GRAPHMOL_EXPORT ROMol * RDKit::MolOps::dativeBondsToHaptic ( const ROMol & mol )

Replaces explicit dative bonds with haptic.

Parameters

mol	the molecule of interest

Does the reverse of hapticBondsToDative. If there are multiple contiguous atoms attached by dative bonds to an atom (probably a metal atom), the dative bonds will be replaced by a dummy atom in their centre attached to the (metal) atom by a dative bond, which is labelled with ENDPTS of the atoms that had the original dative bonds.

◆ dativeBondsToHaptic() [2/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::dativeBondsToHaptic ( RWMol & mol )

◆ detectBondStereochemistry()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::detectBondStereochemistry	(	ROMol &	mol,
		int	confId = `-1`
	)

Deprecated:: : this function will be removed in a future release. Use setDoubleBondNeighborDirections() instead

◆ detectChemistryProblems()

RDKIT_GRAPHMOL_EXPORT std::vector< std::unique_ptr< MolSanitizeException > > RDKit::MolOps::detectChemistryProblems	(	const ROMol &	mol,
		unsigned int	sanitizeOps = `SANITIZE_ALL`
	)

Identifies chemistry problems (things that don't make chemical sense) in a molecule.

This functions uses the operations in sanitizeMol but does not change the input structure and returns a list of the problems encountered instead of stopping at the first failure,

The problems this looks for come from the sanitization operations:

mol.updatePropertyCache() : Unreasonable valences
MolOps::Kekulize() : Unkekulizable ring systems, aromatic atoms not in rings, aromatic bonds to non-aromatic atoms.

Parameters

mol	: the ROMol to be cleaned
sanitizeOps	: the bits here are used to set which sanitization operations are carried out. The elements of the `SanitizeFlags` enum define the operations.

Returns: a vector of MolSanitizeException values that indicate what problems were encountered

◆ expandAttachmentPoints()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::expandAttachmentPoints	(	RWMol &	mol,
		bool	addAsQueries = `true`,
		bool	addCoords = `true`
	)

attachment points encoded as attachPt properties are added to the graph as dummy atoms

Parameters

mol	the molecule of interest
addAsQueries	if true, the dummy atoms will be added as null queries (i.e. they will match any atom in a substructure search)
addCoords	if true and the molecule has one or more conformers, positions for the attachment points will be added to the conformer(s).

◆ fastFindRings()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::fastFindRings ( const ROMol & mol )

use a DFS algorithm to identify ring bonds and atoms in a molecule

NOTE: though the RingInfo structure is populated by this function, the only really reliable calls that can be made are to check if mol.getRingInfo().numAtomRings(idx) or mol.getRingInfo().numBondRings(idx) return values >0

◆ findPotentialStereoBonds()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::findPotentialStereoBonds	(	ROMol &	mol,
		bool	cleanIt = `false`
	)

finds bonds that could be cis/trans in a molecule and mark them as Bond::STEREOANY.

Parameters

mol	the molecule of interest
cleanIt	toggles removal of stereo flags from double bonds that can not have stereochemistry

This function finds any double bonds that can potentially be part of a cis/trans system. No attempt is made here to mark them cis or trans. No attempt is made to detect double bond stereo in ring systems.

This function is useful in the following situations:

when parsing a mol file; for the bonds marked here, coordinate information on the neighbors can be used to indentify cis or trans states
when writing a mol file; bonds that can be cis/trans but not marked as either need to be specially marked in the mol file
finding double bonds with unspecified stereochemistry so they can be enumerated for downstream 3D tools

The CIPranks on the neighboring atoms are checked in this function. The _CIPCode property if set to any on the double bond.

◆ findRingFamilies()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::findRingFamilies ( const ROMol & mol )

◆ findSSSR() [1/2]

RDKIT_GRAPHMOL_EXPORT int RDKit::MolOps::findSSSR	(	const ROMol &	mol,
		std::vector< std::vector< int > > &	res,
		bool	includeDativeBonds = `false`
	)

finds a molecule's Smallest Set of Smallest Rings

Currently this implements a modified form of Figueras algorithm (JCICS - Vol. 36, No. 5, 1996, 986-991)

Parameters

mol	the molecule of interest
res	used to return the vector of rings. Each entry is a vector with atom indices. This information is also stored in the molecule's RingInfo structure, so this argument is optional (see overload)
includeDativeBonds	- determines whether or not dative bonds are used in the ring finding.

Returns: number of smallest rings found

Base algorithm:

The original algorithm starts by finding representative degree 2 nodes.
Representative because if a series of deg 2 nodes are found only one of them is picked.
The smallest ring around each of them is found.
The bonds that connect to this degree 2 node are them chopped off, yielding new deg two nodes
The process is repeated on the new deg 2 nodes.
If no deg 2 nodes are found, a deg 3 node is picked. The smallest ring with it is found. A bond from this is "carefully" (look in the paper) selected and chopped, yielding deg 2 nodes. The process is same as above once this is done.

Our Modifications:

If available, more than one smallest ring around a representative deg 2 node will be computed and stored
Typically 3 rings are found around a degree 3 node (when no deg 2s are available) and all the bond to that node are chopped.
The extra rings that were found in this process are removed after all the nodes have been covered.

These changes were motivated by several factors:

We believe the original algorithm fails to find the correct SSSR (finds the correct number of them but the wrong ones) on some sample mols
Since SSSR may not be unique, a post-SSSR step to symmetrize may be done. The extra rings this process adds can be quite useful.

◆ findSSSR() [2/2]

RDKIT_GRAPHMOL_EXPORT int RDKit::MolOps::findSSSR	(	const ROMol &	mol,
		std::vector< std::vector< int > > *	res = `nullptr`,
		bool	includeDativeBonds = `false`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ get3DDistanceMat()

RDKIT_GRAPHMOL_EXPORT double * RDKit::MolOps::get3DDistanceMat	(	const ROMol &	mol,
		int	confId = `-1`,
		bool	useAtomWts = `false`,
		bool	force = `false`,
		const char *	propNamePrefix = `nullptr`
	)

Computes the molecule's 3D distance matrix.

Parameters

mol	the molecule of interest
confId	the conformer to use
useAtomWts	sets the diagonal elements of the result to 6.0/(atomic number)
force	forces calculation of the matrix, even if already computed
propNamePrefix	used to set the cached property name (if set to an empty string, the matrix will not be cached)

Returns: the distance matrix.

Notes

If propNamePrefix is not empty the result of this is cached in the molecule's local property dictionary, which will handle deallocation. In other cases the caller is responsible for freeing the memory.

◆ getAdjacencyMatrix()

RDKIT_GRAPHMOL_EXPORT double * RDKit::MolOps::getAdjacencyMatrix	(	const ROMol &	mol,
		bool	useBO = `false`,
		int	emptyVal = `0`,
		bool	force = `false`,
		const char *	propNamePrefix = `nullptr`,
		const boost::dynamic_bitset<> *	bondsToUse = `nullptr`
	)

returns a molecule's adjacency matrix

Parameters

mol	the molecule of interest
useBO	toggles use of bond orders in the matrix
emptyVal	sets the empty value (for non-adjacent atoms)
force	forces calculation of the matrix, even if already computed
propNamePrefix	used to set the cached property name

Returns: the adjacency matrix.

Notes

The result of this is cached in the molecule's local property dictionary, which will handle deallocation. The caller should not delete this pointer.

◆ getAvgMolWt()

RDKIT_GRAPHMOL_EXPORT double RDKit::MolOps::getAvgMolWt	(	const ROMol &	mol,
		bool	onlyHeavy = `false`
	)

Calculates a molecule's average molecular weight

Parameters

mol	the molecule of interest
onlyHeavy	(optional) if this is true (the default is false), only heavy atoms will be included in the MW calculation

Returns: the AMW

◆ getDistanceMat() [1/2]

RDKIT_GRAPHMOL_EXPORT double * RDKit::MolOps::getDistanceMat	(	const ROMol &	mol,
		bool	useBO = `false`,
		bool	useAtomWts = `false`,
		bool	force = `false`,
		const char *	propNamePrefix = `nullptr`
	)

Computes the molecule's topological distance matrix.

Uses the Floyd-Warshall all-pairs-shortest-paths algorithm.

Parameters

mol	the molecule of interest
useBO	toggles use of bond orders in the matrix
useAtomWts	sets the diagonal elements of the result to 6.0/(atomic number) so that the matrix can be used to calculate Balaban J values. This does not affect the bond weights.
force	forces calculation of the matrix, even if already computed
propNamePrefix	used to set the cached property name

Returns: the distance matrix.

Notes

The result of this is cached in the molecule's local property dictionary, which will handle deallocation. The caller should not delete this pointer.

◆ getDistanceMat() [2/2]

RDKIT_GRAPHMOL_EXPORT double * RDKit::MolOps::getDistanceMat	(	const ROMol &	mol,
		const std::vector< int > &	activeAtoms,
		const std::vector< const Bond * > &	bonds,
		bool	useBO = `false`,
		bool	useAtomWts = `false`
	)

Computes the molecule's topological distance matrix.

Uses the Floyd-Warshall all-pairs-shortest-paths algorithm.

Parameters

mol	the molecule of interest
activeAtoms	only elements corresponding to these atom indices will be included in the calculation
bonds	only bonds found in this list will be included in the calculation
useBO	toggles use of bond orders in the matrix
useAtomWts	sets the diagonal elements of the result to 6.0/(atomic number) so that the matrix can be used to calculate Balaban J values. This does not affect the bond weights.

Returns: the distance matrix.

Notes

The results of this call are not cached, the caller should delete this pointer.

◆ getExactMolWt()

RDKIT_GRAPHMOL_EXPORT double RDKit::MolOps::getExactMolWt	(	const ROMol &	mol,
		bool	onlyHeavy = `false`
	)

Calculates a molecule's exact molecular weight

Parameters

mol	the molecule of interest
onlyHeavy	(optional) if this is true (the default is false), only heavy atoms will be included in the MW calculation

Returns: the exact MW

◆ getFormalCharge()

RDKIT_GRAPHMOL_EXPORT int RDKit::MolOps::getFormalCharge ( const ROMol & mol )

sums up all atomic formal charges and returns the result

◆ getMolFormula()

RDKIT_GRAPHMOL_EXPORT std::string RDKit::MolOps::getMolFormula	(	const ROMol &	mol,
		bool	separateIsotopes = `false`,
		bool	abbreviateHIsotopes = `true`
	)

Calculates a molecule's formula

Parameters

mol	the molecule of interest
separateIsotopes	if true, isotopes will show up separately in the formula. So C[13CH2]O will give the formula: C[13C]H6O
abbreviateHIsotopes	if true, 2H and 3H will be represented as D and T instead of [2H] and [3H]. This only applies if `separateIsotopes` is true

Returns: the formula as a string

◆ getMolFrags() [1/4]

RDKIT_GRAPHMOL_EXPORT std::vector< boost::shared_ptr< ROMol > > RDKit::MolOps::getMolFrags	(	const ROMol &	mol,
		bool	sanitizeFrags = `true`,
		std::vector< int > *	frags = `nullptr`,
		std::vector< std::vector< int > > *	fragsMolAtomMapping = `nullptr`,
		bool	copyConformers = `true`
	)

splits a molecule into its component fragments (disconnected components of the molecular graph)

Parameters

mol	the molecule of interest
sanitizeFrags	toggles sanitization of the fragments after they are built
frags	used to return the mapping of Atoms->fragments. if provided, `frags` will be `mol->getNumAtoms()` long on return and will contain the fragment assignment for each Atom
fragsMolAtomMapping	used to return the Atoms in each fragment On return `mapping` will be `numFrags` long, and each entry will contain the indices of the Atoms in that fragment.
copyConformers	toggles copying conformers of the fragments after they are built

Returns: a vector of the fragments as smart pointers to ROMols

◆ getMolFrags() [2/4]

RDKIT_GRAPHMOL_EXPORT unsigned int RDKit::MolOps::getMolFrags	(	const ROMol &	mol,
		std::vector< int > &	mapping
	)

find fragments (disconnected components of the molecular graph)

Parameters

mol	the molecule of interest
mapping	used to return the mapping of Atoms->fragments. On return `mapping` will be `mol->getNumAtoms()` long and will contain the fragment assignment for each Atom

Returns: the number of fragments found.

◆ getMolFrags() [3/4]

RDKIT_GRAPHMOL_EXPORT unsigned int RDKit::MolOps::getMolFrags	(	const ROMol &	mol,
		std::vector< std::unique_ptr< ROMol > > &	molFrags,
		bool	sanitizeFrags = `true`,
		std::vector< int > *	frags = `nullptr`,
		std::vector< std::vector< int > > *	fragsMolAtomMapping = `nullptr`,
		bool	copyConformers = `true`
	)

splits a molecule into its component fragments (disconnected components of the molecular graph)

Parameters

mol	the molecule of interest
molFrags	used to return the disconnected fragments as molecules. Any contents on input will be cleared.
sanitizeFrags	toggles sanitization of the fragments after they are built
frags	used to return the mapping of Atoms->fragments. if provided, `frags` will be `mol->getNumAtoms()` long on return and will contain the fragment assignment for each Atom.
fragsMolAtomMapping	used to return the Atoms in each fragment On return `mapping` will be `numFrags` long, and each entry will contain the indices of the Atoms in that fragment.
copyConformers	toggles copying conformers of the fragments after they are built

Returns: the number of fragments found.

◆ getMolFrags() [4/4]

RDKIT_GRAPHMOL_EXPORT unsigned int RDKit::MolOps::getMolFrags	(	const ROMol &	mol,
		std::vector< std::vector< int > > &	frags
	)

find fragments (disconnected components of the molecular graph)

Parameters

mol	the molecule of interest
frags	used to return the Atoms in each fragment On return `mapping` will be `numFrags` long, and each entry will contain the indices of the Atoms in that fragment.

Returns: the number of fragments found.

◆ getMolFragsWithQuery() [1/2]

template<typename T >

RDKIT_GRAPHMOL_EXPORT std::map< T, boost::shared_ptr< ROMol > > RDKit::MolOps::getMolFragsWithQuery	(	const ROMol &	mol,
		T()(const ROMol &, const Atom )	query,
		bool	sanitizeFrags = `true`,
		const std::vector< T > *	whiteList = `nullptr`,
		bool	negateList = `false`
	)

splits a molecule into pieces based on labels assigned using a query

Parameters

mol	the molecule of interest
query	the query used to "label" the molecule for fragmentation
sanitizeFrags	toggles sanitization of the fragments after they are built
whiteList	if provided, only labels in the list will be kept
negateList	if true, the white list logic will be inverted: only labels not in the list will be kept

Returns: a map of the fragments and their labels

◆ getMolFragsWithQuery() [2/2]

template<typename T >

RDKIT_GRAPHMOL_EXPORT unsigned int RDKit::MolOps::getMolFragsWithQuery	(	const ROMol &	mol,
		T()(const ROMol &, const Atom )	query,
		std::map< T, std::unique_ptr< ROMol > > &	molFrags,
		bool	sanitizeFrags = `true`,
		const std::vector< T > *	whiteList = `nullptr`,
		bool	negateList = `false`
	)

splits a molecule into pieces based on labels assigned using a query, putting them into a map of std::unique_ptr<ROMol>.

Parameters

mol	the molecule of interest
query	the query used to "label" the molecule for fragmentation
molFrags	used to return the disconnected fragments as molecules. Any contents on input will be cleared.
sanitizeFrags	toggles sanitization of the fragments after they are built
whiteList	if provided, only labels in the list will be kept
negateList	if true, the white list logic will be inverted: only labels not in the list will be kept

Returns: the number of fragments

◆ getNumAtomsWithDistinctProperty()

RDKIT_GRAPHMOL_EXPORT unsigned RDKit::MolOps::getNumAtomsWithDistinctProperty	(	const ROMol &	mol,
		std::string	prop
	)

returns the number of atoms which have a particular property set

◆ getShortestPath()

RDKIT_GRAPHMOL_EXPORT std::list< int > RDKit::MolOps::getShortestPath	(	const ROMol &	mol,
		int	aid1,
		int	aid2
	)

Find the shortest path between two atoms.

Uses the Bellman-Ford algorithm

Parameters

mol	molecule of interest
aid1	index of the first atom
aid2	index of the second atom

Returns: an std::list with the indices of the atoms along the shortest path

Notes:

the starting and end atoms are included in the path
if no path is found, an empty path is returned

◆ hapticBondsToDative() [1/2]

RDKIT_GRAPHMOL_EXPORT ROMol * RDKit::MolOps::hapticBondsToDative ( const ROMol & mol )

Replaces haptic bond with explicit dative bonds.

Parameters

mol	the molecule of interest

One way of showing haptic bonds (such as cyclopentadiene to iron in ferrocene) is to use a dummy atom with a dative bond to the iron atom with the bond labelled with the atoms involved in the organic end of the bond. Another way is to have explicit dative bonds from the atoms of the haptic group to the metal atom. This function converts the former representation to the latter.

◆ hapticBondsToDative() [2/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::hapticBondsToDative ( RWMol & mol )

◆ hasQueryHs()

RDKIT_GRAPHMOL_EXPORT std::pair< bool, bool > RDKit::MolOps::hasQueryHs ( const ROMol & mol )

returns a pair of booleans (hasQueryHs, hasUnmergaebleQueryHs)

This is really intended to be used with molecules that contain QueryAtoms such as when checking smarts patterns for explicit hydrogens

Parameters

mol	the molecule to check for query Hs from

Returns: std::pair if pair.first is true if the molecule has query hydrogens, if pair.second is true, the queryHs cannot be removed my mergeQueryHs

◆ Kekulize()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::Kekulize	(	RWMol &	mol,
		bool	markAtomsBonds = `true`,
		unsigned int	maxBackTracks = `100`
	)

Kekulizes the molecule.

Parameters

mol	the molecule of interest
markAtomsBonds	if this is set to true, `isAromatic` boolean settings on both the Bonds and Atoms are turned to false following the Kekulization, otherwise they are left alone in their original state.
maxBackTracks	the maximum number of attempts at back-tracking. The algorithm uses a back-tracking procedure to revisit a previous setting of double bond if we hit a wall in the kekulization process

Notes:

this does not modify query bonds which have bond type queries (like those which come from SMARTS) or rings containing them.
even if markAtomsBonds is false the BondType for all modified aromatic bonds will be changed from RDKit::Bond::AROMATIC to RDKit::Bond::SINGLE or RDKit::Bond::DOUBLE during Kekulization.

◆ KekulizeIfPossible()

RDKIT_GRAPHMOL_EXPORT bool RDKit::MolOps::KekulizeIfPossible	(	RWMol &	mol,
		bool	markAtomsBonds = `true`,
		unsigned int	maxBackTracks = `100`
	)

Kekulizes the molecule if possible. If the kekulization fails the molecule will not be modified

Parameters

mol	the molecule of interest
markAtomsBonds	if this is set to true, `isAromatic` boolean settings on both the Bonds and Atoms are turned to false following the Kekulization, otherwise they are left alone in their original state.
maxBackTracks	the maximum number of attempts at back-tracking. The algorithm uses a back-tracking procedure to revisit a previous setting of double bond if we hit a wall in the kekulization process

Returns: whether or not the kekulization succeeded

Notes:

even if markAtomsBonds is false the BondType for all aromatic bonds will be changed from RDKit::Bond::AROMATIC to RDKit::Bond::SINGLE or RDKit::Bond::DOUBLE during Kekulization.

◆ mergeQueryHs() [1/2]

RDKIT_GRAPHMOL_EXPORT ROMol * RDKit::MolOps::mergeQueryHs	(	const ROMol &	mol,
		bool	mergeUnmappedOnly = `false`,
		bool	mergeIsotopes = `false`
	)

returns a copy of a molecule with hydrogens removed and added as queries to the heavy atoms to which they are bound.

This is really intended to be used with molecules that contain QueryAtoms

Parameters

mol	the molecule to remove Hs from

Returns: the new molecule

Notes:

Atoms that do not already have hydrogen count queries will have one added, other H-related queries will not be touched. Examples:
- C[H] -> [C;!H0]
- [C;H1][H] -> [C;H1]
- [C;H2][H] -> [C;H2]
Hydrogens which aren't connected to a heavy atom will not be removed. This prevents molecules like "[H][H]" from having all atoms removed.
the caller is responsible for deleteing the pointer this returns.
By default all hydrogens are removed, however if mergeUnmappedOnly is true, any hydrogen participating in an atom map will be retained

◆ mergeQueryHs() [2/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::mergeQueryHs	(	RWMol &	mol,
		bool	mergeUnmappedOnly = `false`,
		bool	mergeIsotopes = `false`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. modifies the molecule in place

◆ needsHs()

RDKIT_GRAPHMOL_EXPORT bool RDKit::MolOps::needsHs ( const ROMol & mol )

returns whether or not a molecule needs to have Hs added to it.

◆ parseAdjustQueryParametersFromJSON()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::parseAdjustQueryParametersFromJSON	(	MolOps::AdjustQueryParameters &	p,
		const std::string &	json
	)

updates an AdjustQueryParameters object from a JSON string

◆ removeAllHs() [1/2]

RDKIT_GRAPHMOL_EXPORT ROMol * RDKit::MolOps::removeAllHs	(	const ROMol &	mol,
		bool	sanitize = `true`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. The caller owns the pointer this returns

◆ removeAllHs() [2/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::removeAllHs	(	RWMol &	mol,
		bool	sanitize = `true`
	)

removes all Hs from a molecule

◆ removeHs() [1/4]

RDKIT_GRAPHMOL_EXPORT ROMol * RDKit::MolOps::removeHs	(	const ROMol &	mol,
		bool	implicitOnly = `false`,
		bool	updateExplicitCount = `false`,
		bool	sanitize = `true`
	)

returns a copy of a molecule with hydrogens removed

Parameters

mol	the molecule to remove Hs from
implicitOnly	(optional) if this `true`, only implicit Hs will be removed
updateExplicitCount	(optional) If this is `true`, when explicit Hs are removed from the graph, the heavy atom to which they are bound will have its counter of explicit Hs increased.
sanitize	(optional) If this is `true`, the final molecule will be sanitized

Returns: the new molecule

Notes:

Hydrogens which aren't connected to a heavy atom will not be removed. This prevents molecules like "[H][H]" from having all atoms removed.
Labelled hydrogen (e.g. atoms with atomic number=1, but mass > 1), will not be removed.
two coordinate Hs, like the central H in C[H-]C, will not be removed
Hs connected to dummy atoms will not be removed
Hs that are part of the definition of double bond Stereochemistry will not be removed
Hs that are not connected to anything else will not be removed
Hs that have a query defined (i.e. hasQuery() returns true) will not be removed
the caller is responsible for deleteing the pointer this returns.

Referenced by RDKit::RGroupMatch::getTargetMoleculeForHighlights().

◆ removeHs() [2/4]

RDKIT_GRAPHMOL_EXPORT ROMol * RDKit::MolOps::removeHs	(	const ROMol &	mol,
		const RemoveHsParameters &	ps,
		bool	sanitize = `true`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. The caller owns the pointer this returns

◆ removeHs() [3/4]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::removeHs	(	RWMol &	mol,
		bool	implicitOnly = `false`,
		bool	updateExplicitCount = `false`,
		bool	sanitize = `true`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. modifies the molecule in place

◆ removeHs() [4/4]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::removeHs	(	RWMol &	mol,
		const RemoveHsParameters &	ps,
		bool	sanitize = `true`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. modifies the molecule in place

◆ removeStereochemistry()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::removeStereochemistry ( ROMol & mol )

Removes all stereochemistry information from atoms (i.e. R/S) and bonds i.e. Z/E)

Parameters

mol	the molecule of interest

◆ renumberAtoms()

RDKIT_GRAPHMOL_EXPORT ROMol * RDKit::MolOps::renumberAtoms	(	const ROMol &	mol,
		const std::vector< unsigned int > &	newOrder
	)

returns a copy of a molecule with the atoms renumbered

Parameters

mol	the molecule to work with
newOrder	the new ordering of the atoms (should be numAtoms long) for example: if newOrder is [3,2,0,1], then atom 3 in the original molecule will be atom 0 in the new one

Returns: the new molecule

Notes:

the caller is responsible for deleteing the pointer this returns.

◆ sanitizeMol() [1/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::sanitizeMol ( RWMol & mol )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ sanitizeMol() [2/2]

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::sanitizeMol	(	RWMol &	mol,
		unsigned int &	operationThatFailed,
		unsigned int	sanitizeOps = `SANITIZE_ALL`
	)

carries out a collection of tasks for cleaning up a molecule and ensuring that it makes "chemical sense"

This functions calls the following in sequence

Parameters

mol	: the RWMol to be cleaned
operationThatFailed	: the first (if any) sanitization operation that fails is set here. The values are taken from the `SanitizeFlags` enum. On success, the value is `SanitizeFlags::SANITIZE_NONE`
sanitizeOps	: the bits here are used to set which sanitization operations are carried out. The elements of the `SanitizeFlags` enum define the operations.

Notes:

If there is a failure in the sanitization, a MolSanitizeException will be thrown.
in general the user of this function should cast the molecule following this function to a ROMol, so that new atoms and bonds cannot be added to the molecule and screw up the sanitizing that has been done here

◆ setAromaticity()

RDKIT_GRAPHMOL_EXPORT int RDKit::MolOps::setAromaticity	(	RWMol &	mol,
		AromaticityModel	model = `AROMATICITY_DEFAULT`,
		int(*)(RWMol &)	func = `nullptr`
	)

Sets up the aromaticity for a molecule.

This is what happens here:

find all the simple rings by calling the findSSSR function
loop over all the Atoms in each ring and mark them if they are candidates for aromaticity. A ring atom is a candidate if it can spare electrons to the ring and if it's from the first two rows of the periodic table.
based on the candidate atoms, mark the rings to be either candidates or non-candidates. A ring is a candidate only if all its atoms are candidates
apply Hueckel rule to each of the candidate rings to check if the ring can be aromatic

Parameters

mol	the RWMol of interest
model	the aromaticity model to use
func	a custom function for assigning aromaticity (only used when model=`AROMATICITY_CUSTOM`)

Returns: >0 on success, <= 0 otherwise

Assumptions:

Kekulization has been done (i.e. MolOps::Kekulize() has already been called)

◆ setBondStereoFromDirections()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::setBondStereoFromDirections ( ROMol & mol )

Assign CIS/TRANS bond stereochemistry tags based on neighboring directions

◆ setConjugation()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::setConjugation ( ROMol & mol )

flags the molecule's conjugated bonds

◆ setDoubleBondNeighborDirections()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::setDoubleBondNeighborDirections	(	ROMol &	mol,
		const Conformer *	conf = `nullptr`
	)

Sets bond directions based on double bond stereochemistry.

◆ setHybridization()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::setHybridization ( ROMol & mol )

calculates and sets the hybridization of all a molecule's Stoms

◆ setMMFFAromaticity()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::setMMFFAromaticity ( RWMol & mol )

◆ setTerminalAtomCoords()

RDKIT_GRAPHMOL_EXPORT void RDKit::MolOps::setTerminalAtomCoords	(	ROMol &	mol,
		unsigned int	idx,
		unsigned int	otherIdx
	)

Sets Cartesian coordinates for a terminal atom. Useful for growing an atom off a molecule with sensible coordinates based on the geometry of the neighbor.

NOTE: this sets appropriate coordinates in all of the molecule's conformers.

Parameters

mol	the molecule the atoms belong to
idx	index of the terminal atom whose coordinates are set
otherIdx	index of the bonded neighbor atom

◆ symmetrizeSSSR() [1/2]

RDKIT_GRAPHMOL_EXPORT int RDKit::MolOps::symmetrizeSSSR	(	ROMol &	mol,
		bool	includeDativeBonds = `false`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ symmetrizeSSSR() [2/2]

RDKIT_GRAPHMOL_EXPORT int RDKit::MolOps::symmetrizeSSSR	(	ROMol &	mol,
		std::vector< std::vector< int > > &	res,
		bool	includeDativeBonds = `false`
	)

symmetrize the molecule's Smallest Set of Smallest Rings

SSSR rings obatined from "findSSSR" can be non-unique in some case. For example, cubane has five SSSR rings, not six as one would hope.

This function adds additional rings to the SSSR list if necessary to make the list symmetric, e.g. all atoms in cubane will be part of the same number of SSSRs. This function choses these extra rings from the extra rings computed and discarded during findSSSR. The new ring are chosen such that:

replacing a same sized ring in the SSSR list with an extra ring yields the same union of bond IDs as the original SSSR list

Parameters

mol	- the molecule of interest
res	used to return the vector of rings. Each entry is a vector with atom indices. This information is also stored in the molecule's RingInfo structure, so this argument is optional (see overload)
includeDativeBonds	- determines whether or not dative bonds are used in the ring finding.

Returns: the total number of rings = (new rings + old SSSRs)

Notes:

if no SSSR rings are found on the molecule - MolOps::findSSSR() is called first

Namespaces

Classes

Functions

Dealing with hydrogens

Sanitization

Detailed Description

Enumeration Type Documentation

◆ AdjustQueryWhichFlags

◆ AromaticityModel

◆ SanitizeFlags

Function Documentation

◆ addHs() [1/2]

◆ addHs() [2/2]

◆ adjustHs()

◆ adjustQueryProperties() [1/2]

◆ adjustQueryProperties() [2/2]

◆ assignChiralTypesFrom3D()

◆ assignChiralTypesFromBondDirs()

◆ assignChiralTypesFromMolParity()

◆ assignRadicals()

◆ assignStereochemistry()

◆ assignStereochemistryFrom3D()

◆ atomHasConjugatedBond()

◆ cleanUp()

◆ cleanupAtropisomers() [1/2]

◆ cleanupAtropisomers() [2/2]

◆ cleanupChirality()

◆ cleanUpOrganometallics()

◆ clearAllBondDirFlags()

◆ clearDirFlags()

◆ clearSingleBondDirFlags()

◆ collapseAttachmentPoints()

◆ countAtomElec()

◆ dativeBondsToHaptic() [1/2]

◆ dativeBondsToHaptic() [2/2]

◆ detectBondStereochemistry()

◆ detectChemistryProblems()

◆ expandAttachmentPoints()

◆ fastFindRings()

◆ findPotentialStereoBonds()

◆ findRingFamilies()

◆ findSSSR() [1/2]

◆ findSSSR() [2/2]

◆ get3DDistanceMat()

◆ getAdjacencyMatrix()

◆ getAvgMolWt()

◆ getDistanceMat() [1/2]

◆ getDistanceMat() [2/2]

◆ getExactMolWt()

◆ getFormalCharge()

◆ getMolFormula()

◆ getMolFrags() [1/4]

◆ getMolFrags() [2/4]

◆ getMolFrags() [3/4]

◆ getMolFrags() [4/4]

◆ getMolFragsWithQuery() [1/2]

◆ getMolFragsWithQuery() [2/2]

◆ getNumAtomsWithDistinctProperty()

◆ getShortestPath()

◆ hapticBondsToDative() [1/2]

◆ hapticBondsToDative() [2/2]

◆ hasQueryHs()

◆ Kekulize()

◆ KekulizeIfPossible()

◆ mergeQueryHs() [1/2]

◆ mergeQueryHs() [2/2]

◆ needsHs()

◆ parseAdjustQueryParametersFromJSON()

◆ removeAllHs() [1/2]

◆ removeAllHs() [2/2]

◆ removeHs() [1/4]

◆ removeHs() [2/4]

◆ removeHs() [3/4]

◆ removeHs() [4/4]

◆ removeStereochemistry()

◆ renumberAtoms()

◆ sanitizeMol() [1/2]

◆ sanitizeMol() [2/2]

◆ setAromaticity()

◆ setBondStereoFromDirections()