RDKit
Open-source cheminformatics and machine learning.
Loading...
Searching...
No Matches
RDKit Namespace Reference

Std stuff. More...

Namespaces

namespace  Abbreviations
 
namespace  AtomPair
 
namespace  AtomPairs
 
namespace  Canon
 
namespace  Chirality
 
namespace  CIPLabeler
 
namespace  CIPLabeler_detail
 
namespace  common_properties
 
namespace  constants
 
namespace  Deprotect
 
namespace  Descriptors
 
namespace  detail
 
namespace  details
 
namespace  DGeomHelpers
 
namespace  DTags
 
namespace  EnumerationStrategyPickler
 
namespace  EnumerationTypes
 
namespace  FileParserUtils
 
namespace  FilterMatchOps
 
namespace  FMCS
 
namespace  ForceFieldsHelper
 
namespace  GeneralizedSubstruct
 
namespace  GeneralMolSupplier
 
namespace  GenericGroups
 
namespace  Local
 
namespace  MACCSFingerprints
 
namespace  MHFPFingerprints
 
namespace  MMFF
 
namespace  MMPA
 
namespace  MolAlign
 
namespace  MolDraw2D_detail
 
namespace  MolDraw2DUtils
 
namespace  MolEnumerator
 
namespace  MolFragmenter
 
namespace  MolHash
 
namespace  MolInterchange
 
namespace  MolOps
 Groups a variety of molecular query and transformation operations.
 
namespace  MolShapes
 
namespace  MolStandardize
 
namespace  MorganFingerprint
 
namespace  MorganFingerprints
 
namespace  PicklerOps
 
namespace  PNGData
 Tags used for PNG metadata.
 
namespace  QueryOps
 
namespace  RascalMCES
 
namespace  RDKitFP
 
namespace  RDKitFPUtils
 
namespace  RDTypeTag
 
namespace  ReactionRunnerUtils
 
namespace  ReducedGraphs
 
namespace  RxnOps
 
namespace  ScaffoldNetwork
 
namespace  SGroupParsing
 
namespace  SGroupWriting
 
namespace  SLNParse
 
namespace  SmartsWrite
 
namespace  SmilesWrite
 
namespace  StructureCheck
 
namespace  Subgraphs
 
namespace  SubstanceGroupChecks
 
namespace  TopologicalTorsion
 
namespace  UFF
 
namespace  Utils
 

Classes

struct  AdditionalOutput
 
class  AromaticAtomIterator_
 Iterate over aromatic atoms, this is bidirectional. More...
 
class  Atom
 The class for representing atoms. More...
 
class  AtomEnvironment
 abstract base class that holds atom-environments that will be hashed to generate the fingerprint More...
 
class  AtomEnvironmentGenerator
 abstract base class that generates atom-environments from a molecule More...
 
class  atomicData
 
class  AtomInvariantsGenerator
 abstract base class for atom invariants generators More...
 
class  AtomIterator_
 A general random access iterator. More...
 
class  AtomKekulizeException
 
class  AtomMonomerInfo
 The abstract base class for atom-level monomer info. More...
 
class  AtomPDBResidueInfo
 Captures atom-level information about peptide residues. More...
 
class  AtomRingQuery
 
class  AtomSanitizeException
 
class  AtomValenceException
 
class  BadFileException
 used by various file parsing classes to indicate a bad file More...
 
class  Bond
 class for representing a bond More...
 
class  BondInvariantsGenerator
 abstract base class for bond invariants generators More...
 
class  BondIterator_
 iterator for a molecule's bonds, currently BiDirectional, but it theoretically ought to be RandomAccess. More...
 
class  CachedMolHolder
 Concrete class that holds binary cached molecules in memory. More...
 
class  CachedSmilesMolHolder
 Concrete class that holds smiles strings in memory. More...
 
class  CachedTrustedSmilesMolHolder
 Concrete class that holds trusted smiles strings in memory. More...
 
struct  CartesianProduct
 iterate through all possible permutations of the rgroups More...
 
class  CartesianProductStrategy
 
struct  charptr_functor
 functor for comparing two strings More...
 
class  ChemicalReaction
 This is a class for storing and applying general chemical reactions. More...
 
class  ChemicalReactionException
 used to indicate an error in the chemical reaction engine More...
 
class  ChemicalReactionParserException
 used to indicate an error in parsing reaction data More...
 
class  Conformer
 The class for representing 2D or 3D conformation of a molecule. More...
 
class  ConformerException
 used to indicate errors from incorrect conformer access More...
 
class  ConstBondIterator_
 const iterator for a molecule's bonds, currently BiDirectional, but it theoretically ought to be RandomAccess. More...
 
class  CustomPropHandler
 
struct  CXXAtomIterator
 
struct  CXXBondIterator
 
class  DataStructsExplicitBitVecPropHandler
 
class  Dict
 The Dict class can be used to store objects of arbitrary type keyed by strings. More...
 
class  DiscreteDistMat
 
class  DiscreteValueVect
 a class for efficiently storing vectors of discrete values More...
 
struct  DrawColour
 
class  EnumerateLibrary
 This is a class for running reactions on sets of reagents. More...
 
class  EnumerateLibraryBase
 
struct  EnumerationParams
 
class  EnumerationStrategyBase
 
class  EnumerationStrategyException
 class for flagging enumeration strategy errors More...
 
class  EvenSamplePairsStrategy
 EvenSamplePairsStrategy. More...
 
class  ExclusionList
 
class  FeatureFileParseException
 class used to indicate errors in parsing feature definition files. More...
 
class  FileParseException
 used by various file parsing classes to indicate a parse error More...
 
class  FilterCatalog
 
class  FilterCatalogEntry
 
class  FilterCatalogParams
 
struct  FilterData_t
 
class  FilterHierarchyMatcher
 
struct  FilterMatch
 Holds the atomPairs matched by the underlying matcher. More...
 
class  FilterMatcherBase
 
struct  FilterProperty_t
 
class  FingerprintArguments
 Abstract base class that holds molecule independent arguments that are common amongst all fingerprint types and classes inherited from this would hold fingerprint type specific arguments. More...
 
struct  FingerprintFuncArguments
 struct that makes calling the fingerprint generation functions easier More...
 
class  FingerprintGenerator
 class that generates same fingerprint style for different output formats More...
 
struct  FingerprintVarianceScoreData
 
class  FixedMolSizeMolBundle
 
class  ForwardSDMolSupplier
 
class  FPBReader
 class for reading and searching FPB files More...
 
class  FPHolderBase
 Base FPI for the fingerprinter used to rule out impossible matches. More...
 
class  FragCatalogEntry
 
class  FragCatGenerator
 
class  FragCatParams
 container for user parameters used to create a fragment catalog More...
 
class  FragFPGenerator
 
struct  GaResult
 
class  GasteigerParams
 
class  HasPropQuery
 
class  HasPropWithValueQuery
 
class  HasPropWithValueQuery< TargetPtr, ExplicitBitVect >
 
class  HasPropWithValueQuery< TargetPtr, std::string >
 
class  HeteroatomIterator_
 Iterate over heteroatoms, this is bidirectional. More...
 
class  KekulizeException
 
class  KeyFromPropHolder
 
class  KeyHolderBase
 
struct  larger_of
 functor for returning the larger of two values More...
 
struct  ltDouble
 functor to compare two doubles with a tolerance More...
 
class  MarvinArrow
 
class  MarvinAtom
 
class  MarvinAttachmentPoint
 
class  MarvinBond
 
class  MarvinBondStereo
 
class  MarvinCondition
 
class  MarvinDataSgroup
 
class  MarvinGenericSgroup
 
class  MarvinMol
 
class  MarvinMolBase
 
class  MarvinMonomerSgroup
 
class  MarvinMulticenterSgroup
 
class  MarvinMultipleSgroup
 
class  MarvinPlus
 
class  MarvinReaction
 
class  MarvinRectangle
 
class  MarvinSruCoModSgroup
 
class  MarvinStereoGroup
 
class  MarvinSuperatomSgroup
 
class  MarvinSuperatomSgroupExpanded
 
class  MarvinWriterException
 
class  MatchingAtomIterator_
 Iterate over atoms matching a query function. This is bidirectional. More...
 
struct  MCSAtomCompareParameters
 
struct  MCSBondCompareParameters
 
struct  MCSParameters
 
struct  MCSProgressData
 
struct  MCSResult
 
class  MolBundle
 MolBundle contains a collection of related ROMols. More...
 
class  MolCatalogEntry
 This class is used to store ROMol objects in a MolCatalog. More...
 
class  MolCatalogParams
 container for user parameters used to create a mol catalog More...
 
class  MolChemicalFeature
 
class  MolChemicalFeatureDef
 
class  MolChemicalFeatureFactory
 The class for finding chemical features in molecules. More...
 
class  MolDraw2D
 MolDraw2D is the base class for doing 2D renderings of molecules. More...
 
class  MolDraw2DCairo
 
class  MolDraw2DJS
 
class  MolDraw2DQt
 
class  MolDraw2DSVG
 
class  MolDraw2Dwx
 
struct  MolDrawOptions
 
class  MolFileUnhandledFeatureException
 
class  MolHolder
 Concrete class that holds molecules in memory. More...
 
class  MolHolderBase
 Base class API for holding molecules to substructure search. More...
 
class  MolMatchFinalCheckFunctor
 
class  MolPickler
 handles pickling (serializing) molecules More...
 
class  MolPicklerException
 used to indicate exceptions whilst pickling (serializing) molecules More...
 
class  MolSanitizeException
 class for flagging sanitization errors More...
 
class  MolSupplier
 
class  MolWriter
 
struct  MolzipParams
 
class  MultiFPBReader
 class for reading and searching multiple FPB files More...
 
class  PatternHolder
 
class  PDBMolSupplier
 lazy file parser for PDB files More...
 
class  PDBWriter
 
class  PeriodicTable
 singleton class for retrieving information about atoms More...
 
class  QueryAtom
 Class for storing atomic queries. More...
 
class  QueryAtomIterator_
 Iterate over atoms matching a query. This is bidirectional. More...
 
class  QueryBond
 Class for storing Bond queries. More...
 
class  RandomSampleAllBBsStrategy
 
class  RandomSampleStrategy
 
struct  RCore
 RCore is the core common to a series of molecules. More...
 
struct  RDAny
 
class  RDProps
 
struct  RDValue
 
struct  ReactionFingerprintParams
 
class  ReactionPickler
 handles pickling (serializing) reactions More...
 
class  ReactionPicklerException
 used to indicate exceptions whilst pickling (serializing) reactions More...
 
class  RecursiveStructureQuery
 allows use of recursive structure queries (e.g. recursive SMARTS) More...
 
class  ResonanceMolSupplier
 
class  ResonanceMolSupplierCallback
 
struct  RGroupData
 A single rgroup attached to a given core. More...
 
struct  RGroupDecompData
 
class  RGroupDecomposition
 
class  RGroupDecompositionChromosome
 
struct  RGroupDecompositionParameters
 
struct  RGroupDecompositionProcessResult
 
class  RGroupGa
 
struct  RGroupMatch
 RGroupMatch is the decomposition for a single molecule. More...
 
class  RGroupScorer
 
class  RingInfo
 A class to store information about a molecule's rings. More...
 
class  ROMol
 
class  RWMol
 RWMol is a molecule class that is intended to be edited. More...
 
class  RxnSanitizeException
 class for flagging sanitization errors More...
 
class  SDMolSupplier
 
class  SDWriter
 
class  SLNParseException
 
class  SmartsMatcher
 
struct  SmartsParserParams
 
class  SmilesMolSupplier
 lazy file parser for Smiles tables More...
 
class  SmilesParseException
 
struct  SmilesParserParams
 
struct  SmilesWriteParams
 
class  SmilesWriter
 
class  Snapshot
 
class  SparseIntVect
 a class for efficiently storing sparse vectors of ints More...
 
struct  StereoBondThresholds
 
class  StereoGroup
 
class  SubstanceGroup
 The class for representing SubstanceGroups. More...
 
class  SubstanceGroupException
 used to indicate errors from incorrect sgroup access More...
 
class  SubstructLibrary
 Substructure Search a library of molecules. More...
 
struct  SubstructMatchParameters
 
class  TautomerPatternHolder
 
class  TautomerQuery
 
class  TDTMolSupplier
 lazy file parser for TDT files More...
 
class  TDTWriter
 
class  Trajectory
 
class  UnimplementedFPException
 
class  UsedLabelMap
 
struct  VarianceDataForLabel
 

Typedefs

typedef boost::shared_ptr< ConformerCONFORMER_SPTR
 
typedef std::uint32_t atomindex_t
 
typedef std::vector< RWMOL_SPTRRWMOL_SPTR_VECT
 
typedef RDCatalog::Catalog< FilterCatalogEntry, FilterCatalogParamsFCatalog
 
typedef std::map< std::string, std::string > STRING_PROPS
 
typedef bool(* MCSAtomCompareFunction) (const MCSAtomCompareParameters &, const ROMol &, unsigned int, const ROMol &, unsigned int, void *)
 
typedef bool(* MCSBondCompareFunction) (const MCSBondCompareParameters &, const ROMol &, unsigned int, const ROMol &, unsigned int, void *)
 
typedef bool(* MCSAcceptanceFunction) (const ROMol &, const ROMol &, const std::vector< std::pair< int, int > > &, const std::vector< std::pair< int, int > > &, const MCSParameters *)
 
typedef bool(* MCSFinalMatchCheckFunction) (const std::uint32_t[], const std::uint32_t[], const ROMol &, const FMCS::Graph &, const ROMol &, const FMCS::Graph &, const MCSParameters *)
 
typedef bool(* MCSProgressCallback) (const MCSProgressData &stat, const MCSParameters &params, void *userData)
 
typedef RDCatalog::HierarchCatalog< FragCatalogEntry, FragCatParams, intFragCatalog
 
typedef std::vector< std::pair< int, int > > MatchVectType
 used to return matches from substructure searching, The format is (queryAtomIdx, molAtomIdx)
 
typedef RDCatalog::HierarchCatalog< MolCatalogEntry, MolCatalogParams, intMolCatalog
 a hierarchical catalog for holding molecules
 
typedef boost::shared_ptr< MolChemicalFeatureFeatSPtr
 
typedef std::list< FeatSPtrFeatSPtrList
 
typedef FeatSPtrList::iterator FeatSPtrList_I
 
typedef std::map< int, DrawColourColourPalette
 
typedef std::vector< doubleDashPattern
 
typedef std::vector< doubleINVAR_VECT
 
typedef INVAR_VECT::iterator INVAR_VECT_I
 
typedef INVAR_VECT::const_iterator INVAR_VECT_CI
 
typedef Queries::Query< bool, Atom const *, trueATOM_BOOL_QUERY
 
typedef Queries::Query< bool, Bond const *, trueBOND_BOOL_QUERY
 
typedef Queries::AndQuery< int, Atom const *, trueATOM_AND_QUERY
 
typedef Queries::AndQuery< int, Bond const *, trueBOND_AND_QUERY
 
typedef Queries::OrQuery< int, Atom const *, trueATOM_OR_QUERY
 
typedef Queries::OrQuery< int, Bond const *, trueBOND_OR_QUERY
 
typedef Queries::XOrQuery< int, Atom const *, trueATOM_XOR_QUERY
 
typedef Queries::XOrQuery< int, Bond const *, trueBOND_XOR_QUERY
 
typedef Queries::EqualityQuery< int, Atom const *, trueATOM_EQUALS_QUERY
 
typedef Queries::EqualityQuery< int, Bond const *, trueBOND_EQUALS_QUERY
 
typedef Queries::GreaterQuery< int, Atom const *, trueATOM_GREATER_QUERY
 
typedef Queries::GreaterQuery< int, Bond const *, trueBOND_GREATER_QUERY
 
typedef Queries::GreaterEqualQuery< int, Atom const *, trueATOM_GREATEREQUAL_QUERY
 
typedef Queries::GreaterEqualQuery< int, Bond const *, trueBOND_GREATEREQUAL_QUERY
 
typedef Queries::LessQuery< int, Atom const *, trueATOM_LESS_QUERY
 
typedef Queries::LessQuery< int, Bond const *, trueBOND_LESS_QUERY
 
typedef Queries::LessEqualQuery< int, Atom const *, trueATOM_LESSEQUAL_QUERY
 
typedef Queries::LessEqualQuery< int, Bond const *, trueBOND_LESSEQUAL_QUERY
 
typedef Queries::RangeQuery< int, Atom const *, trueATOM_RANGE_QUERY
 
typedef Queries::RangeQuery< int, Bond const *, trueBOND_RANGE_QUERY
 
typedef Queries::SetQuery< int, Atom const *, trueATOM_SET_QUERY
 
typedef Queries::SetQuery< int, Bond const *, trueBOND_SET_QUERY
 
typedef Queries::Query< int, Bond const *, trueBOND_NULL_QUERY
 
typedef Queries::Query< int, Atom const *, trueATOM_NULL_QUERY
 
typedef Atom constConstAtomPtr
 
typedef Bond constConstBondPtr
 
typedef Queries::EqualityQuery< int, Atom const *, trueATOM_PROP_QUERY
 
typedef Queries::EqualityQuery< int, Bond const *, trueBOND_PROP_QUERY
 
typedef std::map< unsigned int, BondElectrons * > ConjBondMap
 
typedef std::map< unsigned int, AtomElectrons * > ConjAtomMap
 
typedef std::vector< ConjElectrons * > CEVect
 
typedef std::vector< CEVect2 * > CEVect3
 
typedef std::vector< std::uint8_t > ConjFP
 
typedef std::unordered_map< std::size_t, ConjElectrons * > CEMap
 
typedef std::map< std::string, ROMOL_SPTRRGroupRow
 
typedef std::vector< ROMOL_SPTRRGroupColumn
 
typedef std::vector< RGroupRowRGroupRows
 
typedef std::map< std::string, RGroupColumnRGroupColumns
 
typedef LinkedPopLinearSel< RGroupDecompositionChromosome, RGroupGaRGroupGaPopulation
 
typedef boost::shared_ptr< RGroupDataRData
 
typedef std::map< int, RDataR_DECOMP
 
typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, Atom *, Bond * > MolGraph
 This is the BGL type used to store the topology:
 
typedef boost::shared_ptr< RWMolRWMOL_SPTR
 
typedef std::vector< intPATH_TYPE
 
typedef std::list< PATH_TYPEPATH_LIST
 
typedef PATH_LIST::const_iterator PATH_LIST_CI
 
typedef std::map< int, PATH_LISTINT_PATH_LIST_MAP
 
typedef INT_PATH_LIST_MAP::const_iterator INT_PATH_LIST_MAP_CI
 
typedef INT_PATH_LIST_MAP::iterator INT_PATH_LIST_MAP_I
 
typedef std::vector< SnapshotSnapshotVect
 
typedef std::vector< std::string > STR_VECT
 
typedef RDValue RDValue_cast_t
 
typedef std::vector< std::shared_ptr< const CustomPropHandler > > CustomPropHandlerVec
 
typedef long long int LONGINT
 
typedef unsigned int UINT
 
typedef unsigned short USHORT
 
typedef unsigned char UCHAR
 
typedef std::vector< intINT_VECT
 
typedef INT_VECT::iterator INT_VECT_I
 
typedef INT_VECT::const_iterator INT_VECT_CI
 
typedef INT_VECT::reverse_iterator INT_VECT_RI
 
typedef INT_VECT::const_reverse_iterator INT_VECT_CRI
 
typedef std::list< intINT_LIST
 
typedef INT_LIST::iterator INT_LIST_I
 
typedef INT_LIST::const_iterator INT_LIST_CI
 
typedef std::list< INT_VECTLIST_INT_VECT
 
typedef LIST_INT_VECT::iterator LIST_INT_VECT_I
 
typedef LIST_INT_VECT::const_iterator LIST_INT_VECT_CI
 
typedef std::vector< INT_VECTVECT_INT_VECT
 
typedef VECT_INT_VECT::iterator VECT_INT_VECT_I
 
typedef VECT_INT_VECT::const_iterator VECT_INT_VECT_CI
 
typedef std::vector< UINT >::const_iterator UINT_VECT_CI
 
typedef std::vector< UINTUINT_VECT
 
typedef std::vector< std::string >::const_iterator STR_VECT_CI
 
typedef std::vector< std::string >::iterator STR_VECT_I
 
typedef std::vector< doubleDOUBLE_VECT
 
typedef DOUBLE_VECT::iterator DOUBLE_VECT_I
 
typedef DOUBLE_VECT::const_iterator DOUBLE_VECT_CI
 
typedef std::vector< DOUBLE_VECTVECT_DOUBLE_VECT
 
typedef VECT_DOUBLE_VECT::iterator VECT_DOUBLE_VECT_I
 
typedef VECT_DOUBLE_VECT::const_iterator VECT_DOUBLE_VECT_CI
 
typedef std::map< std::string, UINTSTR_UINT_MAP
 
typedef std::map< std::string, UINT >::const_iterator STR_UINT_MAP_CI
 
typedef std::map< int, INT_VECTINT_INT_VECT_MAP
 
typedef INT_INT_VECT_MAP::const_iterator INT_INT_VECT_MAP_CI
 
typedef std::map< int, intINT_MAP_INT
 
typedef INT_MAP_INT::iterator INT_MAP_INT_I
 
typedef INT_MAP_INT::const_iterator INT_MAP_INT_CI
 
typedef std::deque< intINT_DEQUE
 
typedef INT_DEQUE::iterator INT_DEQUE_I
 
typedef INT_DEQUE::const_iterator INT_DEQUE_CI
 
typedef std::map< int, INT_DEQUEINT_INT_DEQ_MAP
 
typedef INT_INT_DEQ_MAP::const_iterator INT_INT_DEQ_MAP_CI
 
typedef std::set< intINT_SET
 
typedef INT_SET::iterator INT_SET_I
 
typedef INT_SET::const_iterator INT_SET_CI
 
typedef std::map< double, int, ltDoubleDOUBLE_INT_MAP
 std::map from double to integer.
 
typedef boost::minstd_rand rng_type
 
typedef boost::uniform_int uniform_int
 
typedef boost::uniform_real uniform_double
 
typedef boost::variate_generator< rng_type &, uniform_intint_source_type
 
typedef boost::variate_generator< rng_type &, uniform_doubledouble_source_type
 
C++11 Iterators

ROMol is a molecule class that is intended to have a fixed topology

This is the primary class for most molecule operations.

If you need to be manipulating the molecule (e.g. adding or deleting atoms or bonds, use an RWMol instead.

Notes:

  • each ROMol maintains a Dict of properties:
    • Each property is keyed by name and can store an arbitrary type.
    • Properties can be marked as calculated, in which case they will be cleared when the clearComputedProps() method is called.
    • Because they have no impact upon chemistry, all property operations are const, this allows extra flexibility for clients who need to store extra data on ROMol objects.
  • each ROMol has collections of bookmarks for Atoms and Bonds:
    • the Atom bookmarks and Bond bookmarks are stored separately from each other
    • each bookmark, an integer, can map to more than one Atom or Bond
    • these are currently used in molecule construction, but could also be useful for reaction mapping and the like
  • information about rings (SSSR and the like) is stored in the molecule's RingInfo pointer.
typedef boost::shared_ptr< ROMolROMOL_SPTR
 
typedef std::vector< boost::shared_ptr< ROMol > > MOL_SPTR_VECT
 
typedef std::vector< ROMolMOL_VECT
 
typedef std::vector< ROMol * > MOL_PTR_VECT
 
typedef MOL_PTR_VECT::const_iterator MOL_PTR_VECT_CI
 
typedef MOL_PTR_VECT::iterator MOL_PTR_VECT_I
 

Enumerations

enum  FingerprintType {
  AtomPairFP = 1 , TopologicalTorsion , MorganFP , RDKitFP ,
  PatternFP
}
 
enum  ReactionMoleculeType { Reactant , Product , Agent }
 
enum class  MolzipLabel {
  AtomMapNumber , Isotope , FragmentOnBonds , AtomType ,
  AtomProperty
}
 
enum  Mol2Type { CORINA = 0 }
 
enum class  FPType { AtomPairFP , MorganFP , RDKitFP , TopologicalTorsionFP }
 
enum  AtomComparator { AtomCompareAny , AtomCompareElements , AtomCompareIsotopes , AtomCompareAnyHeavyAtom }
 
enum  BondComparator { BondCompareAny , BondCompareOrder , BondCompareOrderExact }
 
enum  RingComparator { IgnoreRingFusion , PermissiveRingFusion , StrictRingFusion }
 
enum  IsSgroupInAtomSetResult { SgroupInAtomSet , SgroupNotInAtomSet , SgroupBothInAndNotInAtomSet }
 
enum class  MultiColourHighlightStyle { CIRCLEANDLINE , LASSO }
 
enum  RGroupLabels {
  IsotopeLabels = 0x01 , AtomMapLabels = 0x02 , AtomIndexLabels = 0x04 , RelabelDuplicateLabels = 0x08 ,
  MDLRGroupLabels = 0x10 , DummyAtomLabels = 0x20 , AutoDetect = 0xFF
}
 
enum  RGroupMatching {
  Greedy = 0x01 , GreedyChunks = 0x02 , Exhaustive = 0x04 , NoSymmetrization = 0x08 ,
  GA = 0x10
}
 
enum  RGroupLabelling { AtomMap = 0x01 , Isotope = 0x02 , MDLRGroup = 0x04 }
 
enum  RGroupCoreAlignment { None = 0x0 , NoAlignment = 0x0 , MCS = 0x01 }
 
enum  RGroupScore { Match = 0x1 , FingerprintVariance = 0x4 }
 
enum  OperationName { RgroupMutate = 0x01 , Crossover = 0x02 , Create = 0x04 }
 
enum class  Labelling {
  RGROUP_LABELS , ISOTOPE_LABELS , ATOMMAP_LABELS , INDEX_LABELS ,
  DUMMY_LABELS , INTERNAL_LABELS
}
 
enum class  StereoGroupType { STEREO_ABSOLUTE = 0 , STEREO_OR = 1 , STEREO_AND = 2 }
 
enum  EEndian { LITTLE_ENDIAN_ORDER , BIG_ENDIAN_ORDER }
 

Functions

RDKIT_GRAPHMOL_EXPORT void setAtomRLabel (Atom *atm, int rlabel)
 
RDKIT_GRAPHMOL_EXPORT int getAtomRLabel (const Atom *atm)
 
RDKIT_GRAPHMOL_EXPORT void setAtomAlias (Atom *atom, const std::string &alias)
 
RDKIT_GRAPHMOL_EXPORT std::string getAtomAlias (const Atom *atom)
 
RDKIT_GRAPHMOL_EXPORT void setAtomValue (Atom *atom, const std::string &value)
 
RDKIT_GRAPHMOL_EXPORT std::string getAtomValue (const Atom *atom)
 
RDKIT_GRAPHMOL_EXPORT void setSupplementalSmilesLabel (Atom *atom, const std::string &label)
 
RDKIT_GRAPHMOL_EXPORT std::string getSupplementalSmilesLabel (const Atom *atom)
 
RDKIT_GRAPHMOL_EXPORT bool isEarlyAtom (int atomicNum)
 returns true if the atom is to the left of C
 
RDKIT_GRAPHMOL_EXPORT bool isAromaticAtom (const Atom &atom)
 returns true if the atom is aromatic or has an aromatic bond
 
RDKIT_GRAPHMOL_EXPORT uint8_t getTwiceBondType (const RDKit::Bond &b)
 
RDKIT_CHEMREACTIONS_EXPORT EnumerationTypes::BBS removeNonmatchingReagents (const ChemicalReaction &rxn, EnumerationTypes::BBS bbs, const EnumerationParams &params=EnumerationParams())
 
RDKIT_CHEMREACTIONS_EXPORT bool EnumerateLibraryCanSerialize ()
 
template<class T >
EnumerationTypes::RGROUPS getSizesFromBBs (const std::vector< std::vector< T > > &bbs)
 Return the number of elements per input vector.
 
RDKIT_CHEMREACTIONS_EXPORT EnumerationTypes::RGROUPS getSizesFromReactants (const std::vector< MOL_SPTR_VECT > &bbs)
 
RDKIT_CHEMREACTIONS_EXPORT MOL_SPTR_VECT getReactantsFromRGroups (const std::vector< MOL_SPTR_VECT > &bbs, const EnumerationTypes::RGROUPS &rgroups)
 
RDKIT_CHEMREACTIONS_EXPORT boost::uint64_t computeNumProducts (const EnumerationTypes::RGROUPS &sizes)
 
RDKIT_CHEMREACTIONS_EXPORT bool preprocessReaction (ChemicalReaction &rxn, const std::string &propName=common_properties::molFileValue)
 
RDKIT_CHEMREACTIONS_EXPORT bool preprocessReaction (ChemicalReaction &rxn, unsigned int &numWarnings, unsigned int &numErrors, std::vector< std::vector< std::pair< unsigned int, std::string > > > &reactantLabels, const std::string &propName=common_properties::molFileValue)
 
RDKIT_CHEMREACTIONS_EXPORT bool preprocessReaction (ChemicalReaction &rxn, const std::map< std::string, ROMOL_SPTR > &queries, const std::string &propName=common_properties::molFileValue)
 
RDKIT_CHEMREACTIONS_EXPORT bool preprocessReaction (ChemicalReaction &rxn, unsigned int &numWarnings, unsigned int &numErrors, std::vector< std::vector< std::pair< unsigned int, std::string > > > &reactantLabels, const std::map< std::string, ROMOL_SPTR > &queries, const std::string &propName=common_properties::molFileValue)
 
RDKIT_CHEMREACTIONS_EXPORT bool isMoleculeReactantOfReaction (const ChemicalReaction &rxn, const ROMol &mol, std::vector< unsigned int > &which, bool stopAtFirstMatch=false)
 
RDKIT_CHEMREACTIONS_EXPORT bool isMoleculeReactantOfReaction (const ChemicalReaction &rxn, const ROMol &mol, unsigned int &which)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_CHEMREACTIONS_EXPORT bool isMoleculeReactantOfReaction (const ChemicalReaction &rxn, const ROMol &mol)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_CHEMREACTIONS_EXPORT bool isMoleculeProductOfReaction (const ChemicalReaction &rxn, const ROMol &mol, std::vector< unsigned int > &which, bool stopAtFirstMatch=false)
 
RDKIT_CHEMREACTIONS_EXPORT bool isMoleculeProductOfReaction (const ChemicalReaction &rxn, const ROMol &mol, unsigned int &which)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_CHEMREACTIONS_EXPORT bool isMoleculeProductOfReaction (const ChemicalReaction &rxn, const ROMol &mol)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_CHEMREACTIONS_EXPORT bool isMoleculeAgentOfReaction (const ChemicalReaction &rxn, const ROMol &mol, unsigned int &which)
 
RDKIT_CHEMREACTIONS_EXPORT bool isMoleculeAgentOfReaction (const ChemicalReaction &rxn, const ROMol &mol)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_CHEMREACTIONS_EXPORT VECT_INT_VECT getReactingAtoms (const ChemicalReaction &rxn, bool mappedAtomsOnly=false)
 
RDKIT_CHEMREACTIONS_EXPORT void addRecursiveQueriesToReaction (ChemicalReaction &rxn, const std::map< std::string, ROMOL_SPTR > &queries, const std::string &propName, std::vector< std::vector< std::pair< unsigned int, std::string > > > *reactantLabels=nullptr)
 add the recursive queries to the reactants of a reaction
 
RDKIT_CHEMREACTIONS_EXPORT ExplicitBitVectStructuralFingerprintChemReaction (const ChemicalReaction &rxn, const ReactionFingerprintParams &params=DefaultStructuralFPParams)
 
RDKIT_CHEMREACTIONS_EXPORT SparseIntVect< std::uint32_t > * DifferenceFingerprintChemReaction (const ChemicalReaction &rxn, const ReactionFingerprintParams &params=DefaultDifferenceFPParams)
 
std::unique_ptr< ChemicalReactionoperator""_rxnsmarts (const char *text, size_t len)
 
std::unique_ptr< ChemicalReactionoperator""_rxnsmiles (const char *text, size_t len)
 
RDKIT_CHEMREACTIONS_EXPORT std::vector< MOL_SPTR_VECTrun_Reactants (const ChemicalReaction &rxn, const MOL_SPTR_VECT &reactants, unsigned int maxProducts=1000)
 Runs the reaction on a set of reactants.
 
RDKIT_CHEMREACTIONS_EXPORT std::vector< MOL_SPTR_VECTrun_Reactant (const ChemicalReaction &rxn, const ROMOL_SPTR &reactant, unsigned int reactantIdx)
 Runs a single reactant against a single reactant template.
 
RDKIT_CHEMREACTIONS_EXPORT bool run_Reactant (const ChemicalReaction &rxn, RWMol &reactant, bool removeUnmatchedAtoms=true)
 
RDKIT_CHEMREACTIONS_EXPORT ROMolreduceProductToSideChains (const ROMOL_SPTR &product, bool addDummyAtoms=true)
 
RDKIT_CHEMREACTIONS_EXPORT MOL_SPTR_VECT::const_iterator getStartIterator (const ChemicalReaction &rxn, ReactionMoleculeType t)
 
RDKIT_CHEMREACTIONS_EXPORT MOL_SPTR_VECT::const_iterator getEndIterator (const ChemicalReaction &rxn, ReactionMoleculeType t)
 
RDKIT_CHEMREACTIONS_EXPORT bool hasReactantTemplateSubstructMatch (const ChemicalReaction &rxn, const ChemicalReaction &query_rxn)
 
RDKIT_CHEMREACTIONS_EXPORT bool hasProductTemplateSubstructMatch (const ChemicalReaction &rxn, const ChemicalReaction &query_rxn)
 
RDKIT_CHEMREACTIONS_EXPORT bool hasAgentTemplateSubstructMatch (const ChemicalReaction &rxn, const ChemicalReaction &query_rxn)
 
RDKIT_CHEMREACTIONS_EXPORT bool hasReactionSubstructMatch (const ChemicalReaction &rxn, const ChemicalReaction &query_rxn, bool includeAgents=false)
 
RDKIT_CHEMREACTIONS_EXPORT bool hasReactionAtomMapping (const ChemicalReaction &rxn)
 
RDKIT_CHEMREACTIONS_EXPORT bool isReactionTemplateMoleculeAgent (const ROMol &mol, double agentThreshold)
 
RDKIT_CHEMREACTIONS_EXPORT void updateProductsStereochem (ChemicalReaction *rxn)
 
RDKIT_CHEMREACTIONS_EXPORT void removeMappingNumbersFromReactions (const ChemicalReaction &rxn)
 
RDKIT_CHEMTRANSFORMS_EXPORT ROMoldeleteSubstructs (const ROMol &mol, const ROMol &query, bool onlyFrags=false, bool useChirality=false)
 Returns a copy of an ROMol with the atoms and bonds that match a pattern removed.
 
RDKIT_CHEMTRANSFORMS_EXPORT std::vector< ROMOL_SPTRreplaceSubstructs (const ROMol &mol, const ROMol &query, const ROMol &replacement, bool replaceAll=false, unsigned int replacementConnectionPoint=0, bool useChirality=false)
 Returns a list of copies of an ROMol with the atoms and bonds that match a pattern replaced with the atoms contained in another molecule.
 
RDKIT_CHEMTRANSFORMS_EXPORT ROMolreplaceSidechains (const ROMol &mol, const ROMol &coreQuery, bool useChirality=false)
 Returns a copy of an ROMol with the atoms and bonds that don't fall within a substructure match removed.
 
RDKIT_CHEMTRANSFORMS_EXPORT ROMolreplaceCore (const ROMol &mol, const ROMol &core, const MatchVectType &matchVect, bool replaceDummies=true, bool labelByIndex=false, bool requireDummyMatch=false)
 Returns a copy of an ROMol with the atoms and bonds that are referenced by the MatchVector removed. MatchVector must be defined between mol and the specified core.
 
RDKIT_CHEMTRANSFORMS_EXPORT ROMolreplaceCore (const ROMol &mol, const ROMol &coreQuery, bool replaceDummies=true, bool labelByIndex=false, bool requireDummyMatch=false, bool useChirality=false)
 Returns a copy of an ROMol with the atoms and bonds that do fall within a substructure match removed.
 
RDKIT_CHEMTRANSFORMS_EXPORT ROMolMurckoDecompose (const ROMol &mol)
 Carries out a Murcko decomposition on the molecule provided.
 
RDKIT_CHEMTRANSFORMS_EXPORT ROMolcombineMols (const ROMol &mol1, const ROMol &mol2, RDGeom::Point3D offset=RDGeom::Point3D(0, 0, 0))
 Combined two molecules to create a new one.
 
RDKIT_CHEMTRANSFORMS_EXPORT void addRecursiveQueries (ROMol &mol, const std::map< std::string, ROMOL_SPTR > &queries, const std::string &propName, std::vector< std::pair< unsigned int, std::string > > *reactantLabels=nullptr)
 Adds named recursive queries to a molecule's atoms based on atom labels.
 
RDKIT_CHEMTRANSFORMS_EXPORT void parseQueryDefFile (const std::string &filename, std::map< std::string, ROMOL_SPTR > &queryDefs, bool standardize=true, const std::string &delimiter="\t", const std::string &comment="//", unsigned int nameColumn=0, unsigned int smartsColumn=1)
 parses a query definition file and sets up a set of definitions suitable for use by addRecursiveQueries()
 
RDKIT_CHEMTRANSFORMS_EXPORT void parseQueryDefFile (std::istream *inStream, std::map< std::string, ROMOL_SPTR > &queryDefs, bool standardize=true, const std::string &delimiter="\t", const std::string &comment="//", unsigned int nameColumn=0, unsigned int smartsColumn=1)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_CHEMTRANSFORMS_EXPORT void parseQueryDefText (const std::string &queryDefText, std::map< std::string, ROMOL_SPTR > &queryDefs, bool standardize=true, const std::string &delimiter="\t", const std::string &comment="//", unsigned int nameColumn=0, unsigned int smartsColumn=1)
 equivalent to parseQueryDefFile() but the query definitions are explicitly passed in
 
RDKIT_CHEMTRANSFORMS_EXPORT std::unique_ptr< ROMolmolzip (const ROMol &a, const ROMol &b, const MolzipParams &params=MolzipParams())
 
RDKIT_CHEMTRANSFORMS_EXPORT std::unique_ptr< ROMolmolzip (const ROMol &a, const MolzipParams &params=MolzipParams())
 
RDKIT_CHEMTRANSFORMS_EXPORT std::unique_ptr< ROMolmolzip (std::vector< ROMOL_SPTR > &decomposition, const MolzipParams &params=MolzipParams())
 Creates a molecule from an R group decomposition.
 
bool hasNonZeroZCoords (const Conformer &conf)
 Returns true if any of the z coords are non zero, false otherwise.
 
RDKIT_DETERMINEBONDS_EXPORT void determineConnectivity (RWMol &mol, bool useHueckel=false, int charge=0, double covFactor=1.3, bool useVdw=false)
 
RDKIT_DETERMINEBONDS_EXPORT void determineBondOrders (RWMol &mol, int charge=0, bool allowChargedFragments=true, bool embedChiral=true, bool useAtomMap=false)
 
RDKIT_DETERMINEBONDS_EXPORT void determineBonds (RWMol &mol, bool useHueckel=false, int charge=0, double covFactor=1.3, bool allowChargedFragments=true, bool embedChiral=true, bool useAtomMap=false, bool useVdw=false)
 
RDKIT_FILEPARSERS_EXPORT std::vector< std::unique_ptr< RWMol > > CDXMLDataStreamToMols (std::istream &inStream, bool sanitize=true, bool removeHs=true)
 construct molecules from a CDXML file Note that the CDXML format is large and complex, the RDKit doesn't support full functionality, just the base ones required for molecule and reaction parsing.
 
RDKIT_FILEPARSERS_EXPORT std::vector< std::unique_ptr< RWMol > > CDXMLFileToMols (const std::string &filename, bool sanitize=true, bool removeHs=true)
 construct molecules from a CDXML file Note that the CDXML format is large and complex, the RDKit doesn't support full functionality, just the base ones required for molecule and reaction parsing.
 
RDKIT_FILEPARSERS_EXPORT std::vector< std::unique_ptr< RWMol > > CDXMLToMols (const std::string &cdxml, bool sanitize=true, bool removeHs=true)
 construct molecules from a CDXML file Note that the CDXML format is large and complex, the RDKit doesn't support full functionality, just the base ones required for molecule and reaction parsing.
 
RDKIT_FILEPARSERS_EXPORT std::string strip (const std::string &orig)
 
RDKIT_FILEPARSERS_EXPORT RWMolMolDataStreamToMol (std::istream *inStream, unsigned int &line, bool sanitize=true, bool removeHs=true, bool strictParsing=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolMolDataStreamToMol (std::istream &inStream, unsigned int &line, bool sanitize=true, bool removeHs=true, bool strictParsing=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolMolBlockToMol (const std::string &molBlock, bool sanitize=true, bool removeHs=true, bool strictParsing=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolMolFileToMol (const std::string &fName, bool sanitize=true, bool removeHs=true, bool strictParsing=true)
 
RDKIT_FILEPARSERS_EXPORT std::string MolToMolBlock (const ROMol &mol, bool includeStereo=true, int confId=-1, bool kekulize=true, bool forceV3000=false)
 
std::string MolToV3KMolBlock (const ROMol &mol, bool includeStereo=true, int confId=-1, bool kekulize=true)
 
RDKIT_FILEPARSERS_EXPORT void MolToMolFile (const ROMol &mol, const std::string &fName, bool includeStereo=true, int confId=-1, bool kekulize=true, bool forceV3000=false)
 
void MolToV3KMolFile (const ROMol &mol, const std::string &fName, bool includeStereo=true, int confId=-1, bool kekulize=true)
 
RDKIT_FILEPARSERS_EXPORT std::string MolToCMLBlock (const ROMol &mol, int confId=-1, bool kekulize=true)
 
RDKIT_FILEPARSERS_EXPORT void MolToCMLFile (const ROMol &mol, const std::string &fName, int confId=-1, bool kekulize=true)
 
RDKIT_FILEPARSERS_EXPORT std::string MolToXYZBlock (const ROMol &mol, int confId=-1)
 
RDKIT_FILEPARSERS_EXPORT void MolToXYZFile (const ROMol &mol, const std::string &fName, int confId=-1)
 
RDKIT_FILEPARSERS_EXPORT RWMolTPLDataStreamToMol (std::istream *inStream, unsigned int &line, bool sanitize=true, bool skipFirstConf=false)
 translate TPL data (BioCad format) into a multi-conf molecule
 
RDKIT_FILEPARSERS_EXPORT RWMolTPLFileToMol (const std::string &fName, bool sanitize=true, bool skipFirstConf=false)
 construct a multi-conf molecule from a TPL (BioCad format) file
 
RDKIT_FILEPARSERS_EXPORT std::string MolToTPLText (const ROMol &mol, const std::string &partialChargeProp="_GasteigerCharge", bool writeFirstConfTwice=false)
 
RDKIT_FILEPARSERS_EXPORT void MolToTPLFile (const ROMol &mol, const std::string &fName, const std::string &partialChargeProp="_GasteigerCharge", bool writeFirstConfTwice=false)
 
RDKIT_FILEPARSERS_EXPORT RWMolMol2FileToMol (const std::string &fName, bool sanitize=true, bool removeHs=true, Mol2Type variant=CORINA, bool cleanupSubstructures=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolMol2DataStreamToMol (std::istream *inStream, bool sanitize=true, bool removeHs=true, Mol2Type variant=CORINA, bool cleanupSubstructures=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolMol2DataStreamToMol (std::istream &inStream, bool sanitize=true, bool removeHs=true, Mol2Type variant=CORINA, bool cleanupSubstructures=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolMol2BlockToMol (const std::string &molBlock, bool sanitize=true, bool removeHs=true, Mol2Type variant=CORINA, bool cleanupSubstructures=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolXYZDataStreamToMol (std::istream &inStream)
 
RDKIT_FILEPARSERS_EXPORT RWMolXYZBlockToMol (const std::string &xyzBlock)
 
RDKIT_FILEPARSERS_EXPORT RWMolXYZFileToMol (const std::string &fName)
 
RDKIT_FILEPARSERS_EXPORT RWMolPDBBlockToMol (const char *str, bool sanitize=true, bool removeHs=true, unsigned int flavor=0, bool proximityBonding=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolPDBBlockToMol (const std::string &str, bool sanitize=true, bool removeHs=true, unsigned int flavor=0, bool proximityBonding=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolPDBDataStreamToMol (std::istream *inStream, bool sanitize=true, bool removeHs=true, unsigned int flavor=0, bool proximityBonding=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolPDBDataStreamToMol (std::istream &inStream, bool sanitize=true, bool removeHs=true, unsigned int flavor=0, bool proximityBonding=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolPDBFileToMol (const std::string &fname, bool sanitize=true, bool removeHs=true, unsigned int flavor=0, bool proximityBonding=true)
 
RDKIT_FILEPARSERS_EXPORT std::string MolToPDBBlock (const ROMol &mol, int confId=-1, unsigned int flavor=0)
 
RDKIT_FILEPARSERS_EXPORT void MolToPDBFile (const ROMol &mol, const std::string &fname, int confId=-1, unsigned int flavor=0)
 
RDKIT_FILEPARSERS_EXPORT RWMolRDKitSVGToMol (const std::string &svg, bool sanitize=true, bool removeHs=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolRDKitSVGToMol (std::istream *instream, bool sanitize=true, bool removeHs=true)
 
std::unique_ptr< RDKit::RWMoloperator""_ctab (const char *text, size_t len)
 
std::unique_ptr< RDKit::RWMoloperator""_mol2 (const char *text, size_t len)
 
std::unique_ptr< RDKit::RWMoloperator""_pdb (const char *text, size_t len)
 
RDKIT_FILEPARSERS_EXPORT void DetectAtomStereoChemistry (RWMol &mol, const Conformer *conf)
 deprecated, please use MolOps::assignChiralTypesFromBondDirs instead
 
RDKIT_FILEPARSERS_EXPORT void DetectBondStereoChemistry (ROMol &mol, const Conformer *conf)
 deprecated, please use MolOps::detectBondStereoChemistry instead
 
RDKIT_FILEPARSERS_EXPORT void WedgeMolBonds (ROMol &mol, const Conformer *conf)
 
RDKIT_FILEPARSERS_EXPORT void WedgeBond (Bond *bond, unsigned int fromAtomIdx, const Conformer *conf)
 
RDKIT_FILEPARSERS_EXPORT void addWavyBondsForStereoAny (ROMol &mol, bool clearDoubleBondFlags=true, unsigned addWhenImpossible=StereoBondThresholds::DBL_BOND_NO_STEREO)
 set wavy bonds around double bonds with STEREOANY stereo
 
RDKIT_FILEPARSERS_EXPORT INT_MAP_INT pickBondsToWedge (const ROMol &mol)
 
RDKIT_FILEPARSERS_EXPORT void ClearSingleBondDirFlags (ROMol &mol)
 
RDKIT_FILEPARSERS_EXPORT Bond::BondDir DetermineBondWedgeState (const Bond *bond, unsigned int fromAtomIdx, const Conformer *conf)
 
RDKIT_FILEPARSERS_EXPORT Bond::BondDir DetermineBondWedgeState (const Bond *bond, const INT_MAP_INT &wedgeBonds, const Conformer *conf)
 
RDKIT_FILEPARSERS_EXPORT void reapplyMolBlockWedging (ROMol &mol)
 
RDKIT_FILEPARSERS_EXPORT void clearMolBlockWedgingInfo (ROMol &mol)
 
RDKIT_FILEPARSERS_EXPORT void invertMolBlockWedgingInfo (ROMol &mol)
 
RDKIT_FILEPARSERS_EXPORT void markUnspecifiedStereoAsUnknown (ROMol &mol, int confId=-1)
 
RDKIT_FILEPARSERS_EXPORT void translateChiralFlagToStereoGroups (ROMol &mol, StereoGroupType zeroFlagGroupType=StereoGroupType::STEREO_AND)
 
RDKIT_FILEPARSERS_EXPORT bool IsBlacklistedPair (Atom *beg_atom, Atom *end_atom)
 
RDKIT_FILEPARSERS_EXPORT void ConnectTheDots (RWMol *mol, unsigned int flags=0)
 
RDKIT_FILEPARSERS_EXPORT void StandardPDBResidueBondOrders (RWMol *mol)
 
RDKIT_FILEPARSERS_EXPORT bool SamePDBResidue (AtomPDBResidueInfo *p, AtomPDBResidueInfo *q)
 
RDKIT_FILEPARSERS_EXPORT RWMolSequenceToMol (const char *seq, bool sanitize, bool lowerD)
 
RDKIT_FILEPARSERS_EXPORT RWMolSequenceToMol (const std::string &seq, bool sanitize, bool lowerD)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_FILEPARSERS_EXPORT RWMolSequenceToMol (const char *seq, bool sanitize=true, int flavor=0)
 
RDKIT_FILEPARSERS_EXPORT RWMolSequenceToMol (const std::string &seq, bool sanitize=true, int flavor=0)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_FILEPARSERS_EXPORT RWMolFASTAToMol (const char *seq, bool sanitize, bool lowerD)
 
RDKIT_FILEPARSERS_EXPORT RWMolFASTAToMol (const std::string &seq, bool sanitize, bool lowerD)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_FILEPARSERS_EXPORT RWMolFASTAToMol (const char *seq, bool sanitize=true, int flavor=0)
 
RDKIT_FILEPARSERS_EXPORT RWMolFASTAToMol (const std::string &seq, bool sanitize=true, int flavor=0)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_FILEPARSERS_EXPORT RWMolHELMToMol (const char *helm, bool sanitize=true)
 
RDKIT_FILEPARSERS_EXPORT RWMolHELMToMol (const std::string &helm, 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.
 
RDKIT_FILEPARSERS_EXPORT std::string MolToSequence (const ROMol &mol)
 
RDKIT_FILEPARSERS_EXPORT std::string MolToFASTA (const ROMol &mol)
 
RDKIT_FILEPARSERS_EXPORT std::string MolToHELM (const ROMol &mol)
 
RDKIT_FILTERCATALOG_EXPORT bool FilterCatalogCanSerialize ()
 
RDKIT_FILTERCATALOG_EXPORT std::vector< std::vector< boost::shared_ptr< const FilterCatalogEntry > > > RunFilterCatalog (const FilterCatalog &filterCatalog, const std::vector< std::string > &smiles, int numThreads=1)
 Run a filter catalog on a set of smiles strings.
 
unsigned int GetNumEntries (FilterCatalogParams::FilterCatalogs catalog)
 
const FilterData_tGetFilterData (FilterCatalogParams::FilterCatalogs catalog)
 
unsigned int GetNumPropertyEntries (FilterCatalogParams::FilterCatalogs catalog)
 
const FilterProperty_tGetFilterProperties (FilterCatalogParams::FilterCatalogs catalog)
 
FilterCatalogEntryMakeFilterCatalogEntry (const FilterData_t &, unsigned int num_props=0, const FilterProperty_t *props=nullptr)
 
RDKIT_FILTERCATALOG_EXPORT const FilterCatalogGetFunctionalGroupHierarchy ()
 Return the functional group hierarchy as a FilterCatalog.
 
RDKIT_FILTERCATALOG_EXPORT const std::map< std::string, ROMOL_SPTR > & GetFlattenedFunctionalGroupHierarchy (bool normalized=false)
 
RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint64_t > * getSparseCountFP (const ROMol &mol, FPType fPType)
 
RDKIT_FINGERPRINTS_EXPORT SparseBitVectgetSparseFP (const ROMol &mol, FPType fPType)
 
RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint32_t > * getCountFP (const ROMol &mol, FPType fPType)
 
RDKIT_FINGERPRINTS_EXPORT ExplicitBitVectgetFP (const ROMol &mol, FPType fPType)
 
RDKIT_FINGERPRINTS_EXPORT std::vector< SparseIntVect< std::uint64_t > * > * getSparseCountFPBulk (const std::vector< const ROMol * > molVector, FPType fPType)
 
RDKIT_FINGERPRINTS_EXPORT std::vector< SparseBitVect * > * getSparseFPBulk (const std::vector< const ROMol * > molVector, FPType fPType)
 
RDKIT_FINGERPRINTS_EXPORT std::vector< SparseIntVect< std::uint32_t > * > * getCountFPBulk (const std::vector< const ROMol * > molVector, FPType fPType)
 
RDKIT_FINGERPRINTS_EXPORT std::vector< ExplicitBitVect * > * getFPBulk (const std::vector< const ROMol * > molVector, FPType fPType)
 
RDKIT_FINGERPRINTS_EXPORT ExplicitBitVectRDKFingerprintMol (const ROMol &mol, unsigned int minPath=1, unsigned int maxPath=7, unsigned int fpSize=2048, unsigned int nBitsPerHash=2, bool useHs=true, double tgtDensity=0.0, unsigned int minSize=128, bool branchedPaths=true, bool useBondOrder=true, std::vector< std::uint32_t > *atomInvariants=nullptr, const std::vector< std::uint32_t > *fromAtoms=nullptr, std::vector< std::vector< std::uint32_t > > *atomBits=nullptr, std::map< std::uint32_t, std::vector< std::vector< int > > > *bitInfo=nullptr)
 Generates a topological (Daylight like) fingerprint for a molecule using an alternate (faster) hashing algorithm.
 
RDKIT_FINGERPRINTS_EXPORT ExplicitBitVectLayeredFingerprintMol (const ROMol &mol, unsigned int layerFlags=0xFFFFFFFF, unsigned int minPath=1, unsigned int maxPath=7, unsigned int fpSize=2048, std::vector< unsigned int > *atomCounts=nullptr, ExplicitBitVect *setOnlyBits=nullptr, bool branchedPaths=true, const std::vector< std::uint32_t > *fromAtoms=nullptr)
 Generates a topological (Daylight like) fingerprint for a molecule using a layer-based hashing algorithm.
 
RDKIT_FINGERPRINTS_EXPORT ExplicitBitVectPatternFingerprintMol (const ROMol &mol, unsigned int fpSize=2048, std::vector< unsigned int > *atomCounts=nullptr, ExplicitBitVect *setOnlyBits=nullptr, bool tautomericFingerprint=false)
 Generates a topological fingerprint for a molecule using a series of pre-defined structural patterns.
 
RDKIT_FINGERPRINTS_EXPORT ExplicitBitVectPatternFingerprintMol (const MolBundle &bundle, unsigned int fpSize=2048, ExplicitBitVect *setOnlyBits=nullptr, bool tautomericFingerprint=false)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
RDKIT_FINGERPRINTS_EXPORT SparseIntVect< boost::uint64_t > * getUnfoldedRDKFingerprintMol (const ROMol &mol, unsigned int minPath=1, unsigned int maxPath=7, bool useHs=true, bool branchedPaths=true, bool useBondOrder=true, std::vector< std::uint32_t > *atomInvariants=nullptr, const std::vector< std::uint32_t > *fromAtoms=nullptr, std::vector< std::vector< boost::uint64_t > > *atomBits=nullptr, std::map< boost::uint64_t, std::vector< std::vector< int > > > *bitInfo=nullptr)
 
RDKIT_FMCS_EXPORT bool checkAtomRingMatch (const MCSAtomCompareParameters &p, const ROMol &mol1, unsigned int atom1, const ROMol &mol2, unsigned int atom2)
 
RDKIT_FMCS_EXPORT bool checkAtomCharge (const MCSAtomCompareParameters &p, const ROMol &mol1, unsigned int atom1, const ROMol &mol2, unsigned int atom2)
 
RDKIT_FMCS_EXPORT bool checkAtomChirality (const MCSAtomCompareParameters &p, const ROMol &mol1, unsigned int atom1, const ROMol &mol2, unsigned int atom2)
 
RDKIT_FMCS_EXPORT bool checkAtomDistance (const MCSAtomCompareParameters &p, const ROMol &mol1, unsigned int atom1, const ROMol &mol2, unsigned int atom2)
 
RDKIT_FMCS_EXPORT bool MCSAtomCompareAny (const MCSAtomCompareParameters &p, const ROMol &mol1, unsigned int atom1, const ROMol &mol2, unsigned int atom2, void *userData)
 
RDKIT_FMCS_EXPORT bool MCSAtomCompareAnyHeavyAtom (const MCSAtomCompareParameters &p, const ROMol &mol1, unsigned int atom1, const ROMol &mol2, unsigned int atom2, void *userData)
 
RDKIT_FMCS_EXPORT bool MCSAtomCompareElements (const MCSAtomCompareParameters &p, const ROMol &mol1, unsigned int atom1, const ROMol &mol2, unsigned int atom2, void *userData)
 
RDKIT_FMCS_EXPORT bool MCSAtomCompareIsotopes (const MCSAtomCompareParameters &p, const ROMol &mol1, unsigned int atom1, const ROMol &mol2, unsigned int atom2, void *userData)
 
RDKIT_FMCS_EXPORT bool checkBondStereo (const MCSBondCompareParameters &p, const ROMol &mol1, unsigned int bond1, const ROMol &mol2, unsigned int bond2)
 
RDKIT_FMCS_EXPORT bool havePairOfCompatibleRings (const MCSBondCompareParameters &p, const ROMol &mol1, unsigned int bond1, const ROMol &mol2, unsigned int bond2)
 
RDKIT_FMCS_EXPORT bool checkBondRingMatch (const MCSBondCompareParameters &p, const ROMol &mol1, unsigned int bond1, const ROMol &mol2, unsigned int bond2)
 
RDKIT_FMCS_EXPORT bool MCSBondCompareAny (const MCSBondCompareParameters &p, const ROMol &mol1, unsigned int bond1, const ROMol &mol2, unsigned int bond2, void *userData)
 
RDKIT_FMCS_EXPORT bool MCSBondCompareOrder (const MCSBondCompareParameters &p, const ROMol &mol1, unsigned int bond1, const ROMol &mol2, unsigned int bond2, void *userData)
 
RDKIT_FMCS_EXPORT bool MCSBondCompareOrderExact (const MCSBondCompareParameters &p, const ROMol &mol1, unsigned int bond1, const ROMol &mol2, unsigned int bond2, void *userData)
 
RDKIT_FMCS_EXPORT bool MCSProgressCallbackTimeout (const MCSProgressData &stat, const MCSParameters &params, void *userData)
 
RDKIT_FMCS_EXPORT void parseMCSParametersJSON (const char *json, MCSParameters *params)
 
RDKIT_FMCS_EXPORT MCSResult findMCS (const std::vector< ROMOL_SPTR > &mols, const MCSParameters *params=nullptr)
 
RDKIT_FMCS_EXPORT MCSResult findMCS_P (const std::vector< ROMOL_SPTR > &mols, const char *params_json)
 
RDKIT_FMCS_EXPORT MCSResult findMCS (const std::vector< ROMOL_SPTR > &mols, bool maximizeBonds, double threshold, unsigned int timeout, bool verbose, bool matchValences, bool ringMatchesRingOnly, bool completeRingsOnly, bool matchChiralTag, AtomComparator atomComp, BondComparator bondComp, RingComparator ringComp)
 
RDKIT_FMCS_EXPORT MCSResult findMCS (const std::vector< ROMOL_SPTR > &mols, bool maximizeBonds, double threshold=1.0, unsigned int timeout=3600, bool verbose=false, bool matchValences=false, bool ringMatchesRingOnly=false, bool completeRingsOnly=false, bool matchChiralTag=false, AtomComparator atomComp=AtomCompareElements, BondComparator bondComp=BondCompareOrder)
 
bool FinalChiralityCheckFunction (const std::uint32_t c1[], const std::uint32_t c2[], const ROMol &mol1, const FMCS::Graph &query, const ROMol &mol2, const FMCS::Graph &target, const MCSParameters *p)
 
bool FinalMatchCheckFunction (const std::uint32_t c1[], const std::uint32_t c2[], const ROMol &mol1, const FMCS::Graph &query, const ROMol &mol2, const FMCS::Graph &target, const MCSParameters *p)
 
RDKIT_FRAGCATALOG_EXPORT MOL_SPTR_VECT readFuncGroups (std::string fileName)
 
RDKIT_FRAGCATALOG_EXPORT MOL_SPTR_VECT readFuncGroups (std::istream &inStream, int nToRead=-1)
 
RDKIT_FRAGCATALOG_EXPORT MatchVectType findFuncGroupsOnMol (const ROMol &mol, const FragCatParams *params, INT_VECT &fgBonds)
 
RDKIT_FRAGCATALOG_EXPORT ROMolprepareMol (const ROMol &mol, const FragCatParams *fparams, MatchVectType &aToFmap)
 
template<typename T >
std::vector< std::unique_ptr< T > >::iterator findUniquePtr (std::vector< std ::unique_ptr< T > > &vector, T *itemToFind)
 
template<typename T >
void eraseUniquePtr (std::vector< std ::unique_ptr< T > > &vector, T *itemToErase)
 
template<typename T >
bool getCleanNumber (std::string strToParse, T &outInt)
 
RDKIT_MARVINPARSER_EXPORT bool MrvFileIsReaction (const std::string &fname)
 
RDKIT_MARVINPARSER_EXPORT bool MrvDataStreamIsReaction (std::istream *inStream)
 
RDKIT_MARVINPARSER_EXPORT bool MrvDataStreamIsReaction (std::istream &inStream)
 
RDKIT_MARVINPARSER_EXPORT bool MrvBlockIsReaction (const std::string &molmrvText)
 
RDKIT_MARVINPARSER_EXPORT RWMolMrvDataStreamToMol (std::istream *inStream, bool sanitize=false, bool removeHs=false)
 
RDKIT_MARVINPARSER_EXPORT RWMolMrvDataStreamToMol (std::istream &inStream, bool sanitize=false, bool removeHs=false)
 
RDKIT_MARVINPARSER_EXPORT RWMolMrvBlockToMol (const std::string &molmrvText, bool sanitize=false, bool removeHs=false)
 
RDKIT_MARVINPARSER_EXPORT RWMolMrvFileToMol (const std::string &fName, bool sanitize=false, bool removeHs=false)
 
RDKIT_MARVINPARSER_EXPORT ChemicalReactionMrvDataStreamToChemicalReaction (std::istream *inStream, bool sanitize=false, bool removeHs=false)
 
RDKIT_MARVINPARSER_EXPORT ChemicalReactionMrvDataStreamToChemicalReaction (std::istream &inStream, bool sanitize=false, bool removeHs=false)
 
RDKIT_MARVINPARSER_EXPORT ChemicalReactionMrvBlockToChemicalReaction (const std::string &molmrvText, bool sanitize=false, bool removeHs=false)
 
RDKIT_MARVINPARSER_EXPORT ChemicalReactionMrvFileToChemicalReaction (const std::string &fName, bool sanitize=false, bool removeHs=false)
 
RDKIT_MARVINPARSER_EXPORT void MolToMrvFile (const ROMol &mol, const std::string &fName, bool includeStereo=true, int confId=-1, bool kekulize=true, bool prettyPrint=false)
 
RDKIT_MARVINPARSER_EXPORT std::string MolToMrvBlock (const ROMol &mol, bool includeStereo=true, int confId=-1, bool kekulize=true, bool prettyPrint=false)
 
RDKIT_MARVINPARSER_EXPORT std::string ChemicalReactionToMrvBlock (const ChemicalReaction &rxn, bool prettyPrint=false)
 
RDKIT_MARVINPARSER_EXPORT void ChemicalReactionToMrvFile (const ChemicalReaction &rxn, const std::string &fName, bool prettyPrint=false)
 
bool MolBundleCanSerialize ()
 
RDKIT_MOLCHEMICALFEATURES_EXPORT int parseFeatureData (const std::string &defnText, MolChemicalFeatureDef::CollectionType &featDefs)
 
RDKIT_MOLCHEMICALFEATURES_EXPORT int parseFeatureData (std::istream &istream, MolChemicalFeatureDef::CollectionType &featDefs)
 
RDKIT_MOLCHEMICALFEATURES_EXPORT int parseFeatureFile (const std::string &fileName, MolChemicalFeatureDef::CollectionType &featDefs)
 
RDKIT_MOLCHEMICALFEATURES_EXPORT MolChemicalFeatureFactorybuildFeatureFactory (std::istream &inStream)
 constructs a MolChemicalFeatureFactory from the data in a stream
 
RDKIT_MOLCHEMICALFEATURES_EXPORT MolChemicalFeatureFactorybuildFeatureFactory (const std::string &featureData)
 constructs a MolChemicalFeatureFactory from the data in a string
 
void setDarkMode (MolDrawOptions &opts)
 
void setDarkMode (MolDraw2D &d2d)
 
void setMonochromeMode (MolDrawOptions &opts, const DrawColour &fgColour, const DrawColour &bgColour)
 
void setMonochromeMode (MolDraw2D &drawer, const DrawColour &fgColour, const DrawColour &bgColour)
 
void assignDefaultPalette (ColourPalette &palette)
 use the RDKit's default palette r
 
void assignAvalonPalette (ColourPalette &palette)
 use the color palette from the Avalon renderer
 
void assignCDKPalette (ColourPalette &palette)
 use (part of) the CDK color palette
 
void assignDarkModePalette (ColourPalette &palette)
 
void assignBWPalette (ColourPalette &palette)
 
RDKIT_PARTIALCHARGES_EXPORT void computeGasteigerCharges (const ROMol *mol, int nIter=12, bool throwOnParamFailure=false)
 
RDKIT_PARTIALCHARGES_EXPORT void computeGasteigerCharges (const ROMol &mol, int nIter=12, bool throwOnParamFailure=false)
 
RDKIT_PARTIALCHARGES_EXPORT void computeGasteigerCharges (const ROMol &mol, std::vector< double > &charges, int nIter=12, bool throwOnParamFailure=false)
 
std::string describeQuery (const Atom *atom)
 
std::string describeQuery (const Bond *bond)
 
static int queryAtomAromatic (Atom const *at)
 
static int queryAtomAliphatic (Atom const *at)
 
static int queryAtomExplicitDegree (Atom const *at)
 
static int queryAtomTotalDegree (Atom const *at)
 
static int queryAtomNonHydrogenDegree (Atom const *at)
 D and T are treated as "non-hydrogen" here.
 
static int queryAtomHeavyAtomDegree (Atom const *at)
 D and T are not treated as heavy atoms here.
 
static int queryAtomHCount (Atom const *at)
 
static int queryAtomImplicitHCount (Atom const *at)
 
static int queryAtomHasImplicitH (Atom const *at)
 
static int queryAtomImplicitValence (Atom const *at)
 
static int queryAtomExplicitValence (Atom const *at)
 
static int queryAtomTotalValence (Atom const *at)
 
static int queryAtomUnsaturated (Atom const *at)
 
static int queryAtomNum (Atom const *at)
 
static int makeAtomType (int atomic_num, bool aromatic)
 
static void parseAtomType (int val, int &atomic_num, bool &aromatic)
 
static bool getAtomTypeIsAromatic (int val)
 
static int getAtomTypeAtomicNum (int val)
 
static int queryAtomType (Atom const *at)
 
static int queryAtomMass (Atom const *at)
 
static int queryAtomIsotope (Atom const *at)
 
static int queryAtomFormalCharge (Atom const *at)
 
static int queryAtomNegativeFormalCharge (Atom const *at)
 
static int queryAtomHybridization (Atom const *at)
 
static int queryAtomNumRadicalElectrons (Atom const *at)
 
static int queryAtomHasChiralTag (Atom const *at)
 
static int queryAtomMissingChiralTag (Atom const *at)
 
static int queryAtomHasHeteroatomNbrs (Atom const *at)
 
static int queryAtomNumHeteroatomNbrs (Atom const *at)
 
static int queryAtomHasAliphaticHeteroatomNbrs (Atom const *at)
 
static int queryAtomNumAliphaticHeteroatomNbrs (Atom const *at)
 
RDKIT_GRAPHMOL_EXPORT unsigned int queryAtomBondProduct (Atom const *at)
 
RDKIT_GRAPHMOL_EXPORT unsigned int queryAtomAllBondProduct (Atom const *at)
 
static int queryBondOrder (Bond const *bond)
 
static int queryBondIsSingleOrAromatic (Bond const *bond)
 
static int queryBondIsDoubleOrAromatic (Bond const *bond)
 
static int queryBondIsSingleOrDouble (Bond const *bond)
 
static int queryBondIsSingleOrDoubleOrAromatic (Bond const *bond)
 
static int queryBondDir (Bond const *bond)
 
static int queryIsBondInNRings (Bond const *at)
 
static int queryBondHasStereo (Bond const *bnd)
 
static int queryIsAtomInNRings (Atom const *at)
 
static int queryIsAtomInRing (Atom const *at)
 
static int queryAtomHasRingBond (Atom const *at)
 
RDKIT_GRAPHMOL_EXPORT int queryIsAtomBridgehead (Atom const *at)
 
static int queryIsBondInRing (Bond const *bond)
 
static int queryAtomMinRingSize (Atom const *at)
 
static int queryBondMinRingSize (Bond const *bond)
 
static int queryAtomRingBondCount (Atom const *at)
 
template<int tgt>
int queryAtomIsInRingOfSize (Atom const *at)
 
template<int tgt>
int queryBondIsInRingOfSize (Bond const *bond)
 
template<class T >
T * makeAtomSimpleQuery (int what, int func(Atom const *), const std::string &description="Atom Simple")
 
static ATOM_RANGE_QUERYmakeAtomRangeQuery (int lower, int upper, bool lowerOpen, bool upperOpen, int func(Atom const *), const std::string &description="Atom Range")
 
template<class T >
T * makeAtomNumQuery (int what, const std::string &descr)
 returns a Query for matching atomic number
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomNumQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomTypeQuery (int num, int aromatic, const std::string &descr)
 returns a Query for matching atomic number and aromaticity
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomTypeQuery (int num, int aromatic)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomImplicitValenceQuery (int what, const std::string &descr)
 returns a Query for matching implicit valence
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomImplicitValenceQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomExplicitValenceQuery (int what, const std::string &descr)
 returns a Query for matching explicit valence
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomExplicitValenceQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomTotalValenceQuery (int what, const std::string &descr)
 returns a Query for matching total valence
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomTotalValenceQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomExplicitDegreeQuery (int what, const std::string &descr)
 returns a Query for matching explicit degree
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomExplicitDegreeQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomTotalDegreeQuery (int what, const std::string &descr)
 returns a Query for matching atomic degree
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomTotalDegreeQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomHeavyAtomDegreeQuery (int what, const std::string &descr)
 returns a Query for matching heavy atom degree
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomHeavyAtomDegreeQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomHCountQuery (int what, const std::string &descr)
 returns a Query for matching hydrogen count
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomHCountQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomHasImplicitHQuery (const std::string &descr)
 returns a Query for matching ring atoms
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomHasImplicitHQuery ()
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomImplicitHCountQuery (int what, const std::string &descr)
 returns a Query for matching implicit hydrogen count
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomImplicitHCountQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomAromaticQuery (const std::string &descr)
 returns a Query for matching the isAromatic flag
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomAromaticQuery ()
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomAliphaticQuery (const std::string &descr)
 returns a Query for matching aliphatic atoms
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomAliphaticQuery ()
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomMassQuery (int what, const std::string &descr)
 returns a Query for matching atoms with a particular mass
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomMassQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomIsotopeQuery (int what, const std::string &descr)
 returns a Query for matching atoms with a particular isotope
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomIsotopeQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomFormalChargeQuery (int what, const std::string &descr)
 returns a Query for matching formal charge
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomFormalChargeQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomNegativeFormalChargeQuery (int what, const std::string &descr)
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomNegativeFormalChargeQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomHybridizationQuery (int what, const std::string &descr)
 returns a Query for matching hybridization
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomHybridizationQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomNumRadicalElectronsQuery (int what, const std::string &descr)
 returns a Query for matching the number of radical electrons
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomNumRadicalElectronsQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomHasChiralTagQuery (const std::string &descr)
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomHasChiralTagQuery ()
 \overloadquery
 
template<class T >
T * makeAtomMissingChiralTagQuery (const std::string &descr)
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomMissingChiralTagQuery ()
 \overloadquery
 
template<class T >
T * makeAtomUnsaturatedQuery (const std::string &descr)
 returns a Query for matching atoms with unsaturation:
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomUnsaturatedQuery ()
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomInRingQuery (const std::string &descr)
 returns a Query for matching ring atoms
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomInRingQuery ()
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomInNRingsQuery (int what, const std::string &descr)
 returns a Query for matching atoms in a particular number of rings
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomInNRingsQuery (int what)
 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 ATOM_EQUALS_QUERYmakeAtomInRingOfSizeQuery (int tgt)
 returns a Query for matching atoms in rings of a particular size
 
template<class T >
T * makeAtomMinRingSizeQuery (int tgt, const std::string &descr)
 returns a Query for matching an atom's minimum ring size
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomMinRingSizeQuery (int tgt)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomRingBondCountQuery (int what, const std::string &descr)
 returns a Query for matching atoms with a particular number of ring bonds
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomRingBondCountQuery (int what)
 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 ATOM_EQUALS_QUERYmakeAAtomQuery ()
 returns a Query for matching generic A atoms (heavy atoms)
 
RDKIT_GRAPHMOL_EXPORT ATOM_NULL_QUERYmakeAHAtomQuery ()
 returns a Query for matching generic AH atoms (any atom)
 
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERYmakeQAtomQuery ()
 returns a Query for matching generic Q atoms (heteroatoms)
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeQHAtomQuery ()
 returns a Query for matching generic QH atoms (heteroatom or H)
 
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERYmakeXAtomQuery ()
 returns a Query for matching generic X atoms (halogens)
 
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERYmakeXHAtomQuery ()
 returns a Query for matching generic XH atoms (halogen or H)
 
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERYmakeMAtomQuery ()
 returns a Query for matching generic M atoms (metals)
 
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERYmakeMHAtomQuery ()
 returns a Query for matching generic MH atoms (metals or H)
 
RDKIT_GRAPHMOL_EXPORT void convertComplexNameToQuery (Atom *query, std::string_view symb)
 
template<class T >
T * makeAtomHasRingBondQuery (const std::string &descr)
 returns a Query for matching atoms that have ring bonds
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomHasRingBondQuery ()
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomNumHeteroatomNbrsQuery (int what, const std::string &descr)
 returns a Query for matching the number of heteroatom neighbors
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomNumHeteroatomNbrsQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomHasHeteroatomNbrsQuery (const std::string &descr)
 returns a Query for matching atoms that have heteroatom neighbors
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomHasHeteroatomNbrsQuery ()
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomNumAliphaticHeteroatomNbrsQuery (int what, const std::string &descr)
 returns a Query for matching the number of aliphatic heteroatom neighbors
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomNumAliphaticHeteroatomNbrsQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomHasAliphaticHeteroatomNbrsQuery (const std::string &descr)
 returns a Query for matching atoms that have heteroatom neighbors
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomHasAliphaticHeteroatomNbrsQuery ()
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomNonHydrogenDegreeQuery (int what, const std::string &descr)
 returns a Query for matching the number of non-hydrogen neighbors
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomNonHydrogenDegreeQuery (int what)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
T * makeAtomIsBridgeheadQuery (const std::string &descr)
 returns a Query for matching bridgehead atoms
 
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERYmakeAtomIsBridgeheadQuery ()
 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 BOND_EQUALS_QUERYmakeBondOrderEqualsQuery (Bond::BondType what)
 returns a Query for matching bond orders
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeSingleOrAromaticBondQuery ()
 returns a Query for unspecified SMARTS bonds
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeDoubleOrAromaticBondQuery ()
 returns a Query for double|aromatic bonds
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeSingleOrDoubleBondQuery ()
 returns a Query for single|double bonds
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeSingleOrDoubleOrAromaticBondQuery ()
 returns a Query for tautomeric bonds
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeBondDirEqualsQuery (Bond::BondDir what)
 returns a Query for matching bond directions
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeBondHasStereoQuery ()
 returns a Query for matching bonds with stereo set
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeBondIsInRingQuery ()
 returns a Query for matching ring bonds
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeBondInRingOfSizeQuery (int what)
 returns a Query for matching bonds in rings of a particular size
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeBondMinRingSizeQuery (int what)
 returns a Query for matching a bond's minimum ring size
 
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERYmakeBondInNRingsQuery (int tgt)
 returns a Query for matching bonds in a particular number of rings
 
RDKIT_GRAPHMOL_EXPORT BOND_NULL_QUERYmakeBondNullQuery ()
 returns a Query for matching any bond
 
RDKIT_GRAPHMOL_EXPORT ATOM_NULL_QUERYmakeAtomNullQuery ()
 returns a Query for matching any atom
 
static int queryAtomRingMembership (Atom const *at)
 
template<typename T >
int nullDataFun (T)
 
template<typename T >
bool nullQueryFun (T)
 
template<class Target >
Queries::EqualityQuery< int, const Target *, true > * makeHasPropQuery (const std::string &property)
 returns a Query for matching atoms that have a particular property
 
template<class Target , class T >
Queries::EqualityQuery< int, const Target *, true > * makePropQuery (const std::string &propname, const T &val, const T &tolerance=T())
 
template<class Target >
Queries::EqualityQuery< int, const Target *, true > * makePropQuery (const std::string &propname, const ExplicitBitVect &val, float tolerance=0.0)
 
RDKIT_GRAPHMOL_EXPORT bool isComplexQuery (const Bond *b)
 
RDKIT_GRAPHMOL_EXPORT bool isComplexQuery (const Atom *a)
 
RDKIT_GRAPHMOL_EXPORT bool isAtomAromatic (const Atom *a)
 
RDKIT_GRAPHMOL_EXPORT bool isAtomListQuery (const Atom *a)
 
RDKIT_GRAPHMOL_EXPORT void getAtomListQueryVals (const Atom::QUERYATOM_QUERY *q, std::vector< int > &vals)
 
bool isAtomDummy (const Atom *a)
 
RDKIT_RGROUPDECOMPOSITION_EXPORT unsigned int RGroupDecompose (const std::vector< ROMOL_SPTR > &cores, const std::vector< ROMOL_SPTR > &mols, RGroupRows &rows, std::vector< unsigned int > *unmatched=nullptr, const RGroupDecompositionParameters &options=RGroupDecompositionParameters())
 
RDKIT_RGROUPDECOMPOSITION_EXPORT unsigned int RGroupDecompose (const std::vector< ROMOL_SPTR > &cores, const std::vector< ROMOL_SPTR > &mols, RGroupColumns &columns, std::vector< unsigned int > *unmatched=nullptr, const RGroupDecompositionParameters &options=RGroupDecompositionParameters())
 
bool checkForTimeout (const std::chrono::steady_clock::time_point &t0, double timeout, bool throwOnTimeout=true)
 
RDKIT_RGROUPDECOMPOSITION_EXPORT double fingerprintVarianceScore (const std::vector< size_t > &permutation, const std::vector< std::vector< RGroupMatch > > &matches, const std::set< int > &labels, FingerprintVarianceScoreData *fingerprintVarianceScoreData=nullptr)
 
void copyVarianceData (const FingerprintVarianceScoreData &fromData, FingerprintVarianceScoreData &toData)
 
void clearVarianceData (FingerprintVarianceScoreData &fingerprintVarianceScoreData)
 
std::string labellingToString (Labelling type)
 return the user friendly name for the given labelling
 
std::map< int, Atom * > getRlabels (const RWMol &mol)
 Get the RLabels,atom mapping for the current molecule.
 
void clearInputLabels (Atom *atom)
 Remove the user labels from the atom.
 
bool setLabel (Atom *atom, int label, std::set< int > &labels, int &maxLabel, bool relabel, Labelling type)
 
bool hasDummy (const RWMol &core)
 Returns true if the core has a dummy atom.
 
bool isAtomWithMultipleNeighborsOrNotDummyRGroupAttachment (const Atom &atom)
 
bool isUserRLabel (const Atom &atom)
 Return true if the atom has a user-defined R group label.
 
bool isDummyRGroupAttachment (const Atom &atom)
 
bool isAnyAtomWithMultipleNeighborsOrNotUserRLabel (const Atom &atom)
 
RDKIT_RGROUPDECOMPOSITION_EXPORT std::string toJSON (const RGroupRow &rgr, const std::string &prefix="")
 
RDKIT_RGROUPDECOMPOSITION_EXPORT std::string toJSON (const RGroupRows &rgr, const std::string &prefix="")
 
RDKIT_RGROUPDECOMPOSITION_EXPORT std::string toJSON (const RGroupColumn &rgr, const std::string &prefix="")
 
RDKIT_RGROUPDECOMPOSITION_EXPORT void relabelMappedDummies (ROMol &mol, unsigned int inputLabels=AtomMap|Isotope|MDLRGroup, unsigned int outputLabels=MDLRGroup)
 
RDKIT_SLNPARSE_EXPORT RWMolSLNToMol (const std::string &smi, bool sanitize=true, int debugParse=0)
 
RDKIT_SLNPARSE_EXPORT RWMolSLNQueryToMol (const std::string &smi, bool mergeHs=true, int debugParse=0)
 
RDKIT_SMILESPARSE_EXPORT std::string MolToSmarts (const ROMol &mol, bool doIsomericSmarts=true, int rootedAtAtom=-1)
 returns the SMARTS for a molecule
 
RDKIT_SMILESPARSE_EXPORT std::string MolFragmentToSmarts (const ROMol &mol, const std::vector< int > &atomsToUse, const std::vector< int > *bondsToUse=nullptr, bool doIsomericSmarts=true)
 
RDKIT_SMILESPARSE_EXPORT std::string MolToCXSmarts (const ROMol &mol, bool doIsomericSmarts=true)
 returns the CXSMARTS for a molecule
 
RDKIT_SMILESPARSE_EXPORT std::string MolFragmentToCXSmarts (const ROMol &mol, const std::vector< int > &atomsToUse, const std::vector< int > *bondsToUse=nullptr, bool doIsomericSmarts=true)
 
RDKIT_SMILESPARSE_EXPORT RWMolSmilesToMol (const std::string &smi, const SmilesParserParams &params)
 
RDKIT_SMILESPARSE_EXPORT AtomSmilesToAtom (const std::string &smi)
 
RDKIT_SMILESPARSE_EXPORT BondSmilesToBond (const std::string &smi)
 
RWMolSmilesToMol (const std::string &smi, int debugParse=0, bool sanitize=true, std::map< std::string, std::string > *replacements=nullptr)
 Construct a molecule from a SMILES string.
 
RDKIT_SMILESPARSE_EXPORT RWMolSmartsToMol (const std::string &sma, const SmartsParserParams &ps)
 
RWMolSmartsToMol (const std::string &sma, int debugParse=0, bool mergeHs=false, std::map< std::string, std::string > *replacements=nullptr)
 Construct a molecule from a SMARTS string.
 
RDKIT_SMILESPARSE_EXPORT AtomSmartsToAtom (const std::string &sma)
 
RDKIT_SMILESPARSE_EXPORT BondSmartsToBond (const std::string &sma)
 
std::unique_ptr< RDKit::RWMoloperator""_smiles (const char *text, size_t len)
 
std::unique_ptr< RDKit::RWMoloperator""_smarts (const char *text, size_t len)
 
RDKIT_SMILESPARSE_EXPORT std::string MolToSmiles (const ROMol &mol, const SmilesWriteParams &params)
 returns canonical SMILES for a molecule
 
std::string MolToSmiles (const ROMol &mol, bool doIsomericSmiles=true, bool doKekule=false, int rootedAtAtom=-1, bool canonical=true, bool allBondsExplicit=false, bool allHsExplicit=false, bool doRandom=false)
 returns canonical SMILES for a molecule
 
RDKIT_SMILESPARSE_EXPORT std::vector< std::string > MolToRandomSmilesVect (const ROMol &mol, unsigned int numSmiles, unsigned int randomSeed=0, bool doIsomericSmiles=true, bool doKekule=false, bool allBondsExplicit=false, bool allHsExplicit=false)
 returns a vector of random SMILES for a molecule (may contain duplicates)
 
RDKIT_SMILESPARSE_EXPORT std::string MolFragmentToSmiles (const ROMol &mol, const SmilesWriteParams &params, const std::vector< int > &atomsToUse, const std::vector< int > *bondsToUse=nullptr, const std::vector< std::string > *atomSymbols=nullptr, const std::vector< std::string > *bondSymbols=nullptr)
 returns canonical SMILES for part of a molecule
 
std::string MolFragmentToSmiles (const ROMol &mol, const std::vector< int > &atomsToUse, const std::vector< int > *bondsToUse=nullptr, const std::vector< std::string > *atomSymbols=nullptr, const std::vector< std::string > *bondSymbols=nullptr, bool doIsomericSmiles=true, bool doKekule=false, int rootedAtAtom=-1, bool canonical=true, bool allBondsExplicit=false, bool allHsExplicit=false)
 returns canonical SMILES for part of a molecule
 
RDKIT_SMILESPARSE_EXPORT std::string MolToCXSmiles (const ROMol &mol, const SmilesWriteParams &ps, std::uint32_t flags=SmilesWrite::CXSmilesFields::CX_ALL)
 returns canonical CXSMILES for a molecule
 
std::string MolToCXSmiles (const ROMol &mol, bool doIsomericSmiles=true, bool doKekule=false, int rootedAtAtom=-1, bool canonical=true, bool allBondsExplicit=false, bool allHsExplicit=false, bool doRandom=false)
 returns canonical CXSMILES for a molecule
 
RDKIT_SMILESPARSE_EXPORT std::string MolFragmentToCXSmiles (const ROMol &mol, const SmilesWriteParams &params, const std::vector< int > &atomsToUse, const std::vector< int > *bondsToUse=nullptr, const std::vector< std::string > *atomSymbols=nullptr, const std::vector< std::string > *bondSymbols=nullptr)
 returns canonical CXSMILES for part of a molecule
 
std::string MolFragmentToCXSmiles (const ROMol &mol, const std::vector< int > &atomsToUse, const std::vector< int > *bondsToUse=nullptr, const std::vector< std::string > *atomSymbols=nullptr, const std::vector< std::string > *bondSymbols=nullptr, bool doIsomericSmiles=true, bool doKekule=false, int rootedAtAtom=-1, bool canonical=true, bool allBondsExplicit=false, bool allHsExplicit=false)
 returns canonical CXSMILES for part of a molecule
 
RDKIT_GRAPHMOL_EXPORT void removeGroupsWithAtom (const Atom *atom, std::vector< StereoGroup > &groups)
 
RDKIT_GRAPHMOL_EXPORT void removeGroupsWithAtoms (const std::vector< Atom * > &atoms, std::vector< StereoGroup > &groups)
 
RDKIT_GRAPHMOL_EXPORT void assignStereoGroupIds (std::vector< StereoGroup > &groups)
 
RDKIT_GRAPHMOL_EXPORT void forwardStereoGroupIds (ROMol &mol)
 
RDKIT_SUBGRAPHS_EXPORT INT_PATH_LIST_MAP findAllSubgraphsOfLengthsMtoN (const ROMol &mol, unsigned int lowerLen, unsigned int upperLen, bool useHs=false, int rootedAtAtom=-1)
 find all bond subgraphs in a range of sizes
 
RDKIT_SUBGRAPHS_EXPORT PATH_LIST findAllSubgraphsOfLengthN (const ROMol &mol, unsigned int targetLen, bool useHs=false, int rootedAtAtom=-1)
 find all bond subgraphs of a particular size
 
RDKIT_SUBGRAPHS_EXPORT PATH_LIST findUniqueSubgraphsOfLengthN (const ROMol &mol, unsigned int targetLen, bool useHs=false, bool useBO=true, int rootedAtAtom=-1)
 find unique bond subgraphs of a particular size
 
RDKIT_SUBGRAPHS_EXPORT PATH_LIST findAllPathsOfLengthN (const ROMol &mol, unsigned int targetLen, bool useBonds=true, bool useHs=false, int rootedAtAtom=-1, bool onlyShortestPaths=false)
 find all paths of a particular size
 
RDKIT_SUBGRAPHS_EXPORT INT_PATH_LIST_MAP findAllPathsOfLengthsMtoN (const ROMol &mol, unsigned int lowerLen, unsigned int upperLen, bool useBonds=true, bool useHs=false, int rootedAtAtom=-1, bool onlyShortestPaths=false)
 
RDKIT_SUBGRAPHS_EXPORT PATH_TYPE findAtomEnvironmentOfRadiusN (const ROMol &mol, unsigned int radius, unsigned int rootedAtAtom, bool useHs=false, bool enforceSize=true, std::unordered_map< unsigned int, unsigned int > *atomMap=nullptr)
 Find bond subgraphs of a particular radius around an atom. Return empty result if there is no bond at the requested radius.
 
RDKIT_SUBSTRUCTMATCH_EXPORT void updateSubstructMatchParamsFromJSON (SubstructMatchParameters &params, const std::string &json)
 
RDKIT_SUBSTRUCTMATCH_EXPORT std::string substructMatchParamsToJSON (const SubstructMatchParameters &params)
 
RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectTypeSubstructMatch (const ROMol &mol, const ROMol &query, const SubstructMatchParameters &params=SubstructMatchParameters())
 Find a substructure match for a query in a molecule.
 
RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectTypeSubstructMatch (ResonanceMolSupplier &resMolSuppl, const ROMol &query, const SubstructMatchParameters &params=SubstructMatchParameters())
 Find all substructure matches for a query in a ResonanceMolSupplier object.
 
RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectTypeSubstructMatch (const MolBundle &bundle, const ROMol &query, const SubstructMatchParameters &params=SubstructMatchParameters())
 
RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectTypeSubstructMatch (const ROMol &mol, const MolBundle &query, const SubstructMatchParameters &params=SubstructMatchParameters())
 
RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectTypeSubstructMatch (const MolBundle &bundle, const MolBundle &query, const SubstructMatchParameters &params=SubstructMatchParameters())
 
template<typename T1 , typename T2 >
bool SubstructMatch (T1 &mol, const T2 &query, MatchVectType &matchVect, bool recursionPossible=true, bool useChirality=false, bool useQueryQueryMatches=false)
 Find a substructure match for a query.
 
template<typename T1 , typename T2 >
unsigned int SubstructMatch (T1 &mol, const T2 &query, std::vector< MatchVectType > &matchVect, bool uniquify=true, bool recursionPossible=true, bool useChirality=false, bool useQueryQueryMatches=false, unsigned int maxMatches=1000, int numThreads=1)
 Find all substructure matches for a query.
 
template<>
bool SubstructMatch (ResonanceMolSupplier &resMolSupplier, const ROMol &query, MatchVectType &matchVect, bool recursionPossible, bool useChirality, bool useQueryQueryMatches)
 
template<>
unsigned int SubstructMatch (ResonanceMolSupplier &resMolSupplier, const ROMol &query, std::vector< MatchVectType > &matchVect, bool uniquify, bool recursionPossible, bool useChirality, bool useQueryQueryMatches, unsigned int maxMatches, int numThreads)
 
RDKIT_SUBSTRUCTMATCH_EXPORT double toPrime (const MatchVectType &v)
 
RDKIT_SUBSTRUCTMATCH_EXPORT void removeDuplicates (std::vector< MatchVectType > &v, unsigned int nAtoms)
 
RDKIT_SUBSTRUCTMATCH_EXPORT bool propertyCompat (const RDProps *r1, const RDProps *r2, const std::vector< std::string > &properties)
 
RDKIT_SUBSTRUCTMATCH_EXPORT bool atomCompat (const Atom *a1, const Atom *a2, const SubstructMatchParameters &ps)
 
RDKIT_SUBSTRUCTMATCH_EXPORT bool chiralAtomCompat (const Atom *a1, const Atom *a2)
 
RDKIT_SUBSTRUCTMATCH_EXPORT bool bondCompat (const Bond *b1, const Bond *b2, const SubstructMatchParameters &ps)
 
RDKIT_SUBSTRUCTMATCH_EXPORT const MatchVectTypegetMostSubstitutedCoreMatch (const ROMol &mol, const ROMol &core, const std::vector< MatchVectType > &matches)
 
RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectTypesortMatchesByDegreeOfCoreSubstitution (const ROMol &mol, const ROMol &core, const std::vector< MatchVectType > &matches)
 
RDKIT_SUBSTRUCTMATCH_EXPORT bool isAtomTerminalRGroupOrQueryHydrogen (const Atom *atom)
 
RDKIT_SUBSTRUCTLIBRARY_EXPORT void addPatterns (SubstructLibrary &sslib, boost::shared_ptr< FPHolderBase > patterns, int numThreads=1)
 
RDKIT_SUBSTRUCTLIBRARY_EXPORT void addPatterns (SubstructLibrary &sslib, int numThreads=1)
 
RDKIT_SUBSTRUCTLIBRARY_EXPORT bool SubstructLibraryCanSerialize ()
 
RDKIT_TAUTOMERQUERY_EXPORT bool TautomerQueryCanSerialize ()
 
RDKIT_TAUTOMERQUERY_EXPORT std::vector< MatchVectTypeSubstructMatch (const ROMol &mol, const TautomerQuery &query, const SubstructMatchParameters &params)
 
RDKIT_TRAJECTORY_EXPORT unsigned int readAmberTrajectory (const std::string &fName, Trajectory &traj)
 Reads coordinates from an AMBER trajectory file into the traj Trajectory object.
 
RDKIT_TRAJECTORY_EXPORT unsigned int readGromosTrajectory (const std::string &fName, Trajectory &traj)
 Reads coordinates from a GROMOS trajectory file into the traj Trajectory object.
 
DiscreteDistMatgetDiscreteDistMat ()
 
RDKIT_DATASTRUCTS_EXPORT unsigned int computeL1Norm (const DiscreteValueVect &v1, const DiscreteValueVect &v2)
 
RDKIT_DATASTRUCTS_EXPORT DiscreteValueVect operator+ (const DiscreteValueVect &p1, const DiscreteValueVect &p2)
 
RDKIT_DATASTRUCTS_EXPORT DiscreteValueVect operator- (const DiscreteValueVect &p1, const DiscreteValueVect &p2)
 
template<typename IndexType , typename SequenceType >
void updateFromSequence (SparseIntVect< IndexType > &vect, const SequenceType &seq)
 
template<typename IndexType >
double DiceSimilarity (const SparseIntVect< IndexType > &v1, const SparseIntVect< IndexType > &v2, bool returnDistance=false, double bounds=0.0)
 
template<typename IndexType >
double TverskySimilarity (const SparseIntVect< IndexType > &v1, const SparseIntVect< IndexType > &v2, double a, double b, bool returnDistance=false, double bounds=0.0)
 
template<typename IndexType >
double TanimotoSimilarity (const SparseIntVect< IndexType > &v1, const SparseIntVect< IndexType > &v2, bool returnDistance=false, double bounds=0.0)
 
template<class T >
void mergeNullQueries (T *&returnQuery, bool isQueryNull, T *&otherQuery, bool isOtherQNull, Queries::CompositeQueryType how)
 
template<>
std::string Dict::getVal< std::string > (const std::string &what) const
 
template<typename CompareFunc >
bool hanoi (int *base, int nel, int *temp, int *count, int *changed, CompareFunc compar)
 
template<typename CompareFunc >
void hanoisort (int *base, int nel, int *count, int *changed, CompareFunc compar)
 
template<class T >
constrdany_cast (const RDAny &d)
 
template<class T >
rdany_cast (RDAny &d)
 
template<class T >
boost::enable_if< boost::is_arithmetic< T >, T >::type from_rdany (const RDAny &arg)
 
template<class T >
boost::disable_if< boost::is_arithmetic< T >, T >::type from_rdany (const RDAny &arg)
 
unsigned int getNumThreadsToUse (int target)
 
void copy_rdvalue (RDValue &dest, const RDValue &src)
 
template<class T >
bool rdvalue_is (const RDValue_cast_t)
 
template<>
bool rdvalue_is< double > (const RDValue_cast_t)
 
template<>
bool rdvalue_is< const double & > (const RDValue_cast_t)
 
template<class T >
rdvalue_cast (RDValue_cast_t v)
 
template<>
double rdvalue_cast< double > (RDValue_cast_t v)
 
template<>
float rdvalue_cast< float > (RDValue_cast_t v)
 
template<>
int rdvalue_cast< int > (RDValue_cast_t v)
 
template<>
unsigned int rdvalue_cast< unsigned int > (RDValue_cast_t v)
 
template<>
bool rdvalue_cast< bool > (RDValue_cast_t v)
 
template<>
bool rdvalue_is< std::any > (RDValue_cast_t v)
 
template<>
double rdvalue_cast< double > (RDValue_cast_t v)
 
template<>
float rdvalue_cast< float > (RDValue_cast_t v)
 
template<>
int rdvalue_cast< int > (RDValue_cast_t v)
 
template<>
std::int8_t rdvalue_cast< std::int8_t > (RDValue_cast_t v)
 
template<>
std::int16_t rdvalue_cast< std::int16_t > (RDValue_cast_t v)
 
template<>
std::int64_t rdvalue_cast< std::int64_t > (RDValue_cast_t v)
 
template<>
unsigned int rdvalue_cast< unsigned int > (RDValue_cast_t v)
 
template<>
std::uint8_t rdvalue_cast< std::uint8_t > (RDValue_cast_t v)
 
template<>
std::uint16_t rdvalue_cast< std::uint16_t > (RDValue_cast_t v)
 
template<>
std::uint64_t rdvalue_cast< std::uint64_t > (RDValue_cast_t v)
 
template<>
bool rdvalue_cast< bool > (RDValue_cast_t v)
 
template<>
std::string rdvalue_cast< std::string > (RDValue_cast_t v)
 
template<>
std::string & rdvalue_cast< std::string & > (RDValue_cast_t v)
 
template<>
std::vector< doublerdvalue_cast< std::vector< double > > (RDValue_cast_t v)
 
template<>
std::vector< double > & rdvalue_cast< std::vector< double > & > (RDValue_cast_t v)
 
template<>
std::vector< floatrdvalue_cast< std::vector< float > > (RDValue_cast_t v)
 
template<>
std::vector< float > & rdvalue_cast< std::vector< float > & > (RDValue_cast_t v)
 
template<>
std::vector< std::string > rdvalue_cast< std::vector< std::string > > (RDValue_cast_t v)
 
template<>
std::vector< std::string > & rdvalue_cast< std::vector< std::string > & > (RDValue_cast_t v)
 
template<>
std::vector< intrdvalue_cast< std::vector< int > > (RDValue_cast_t v)
 
template<>
std::vector< int > & rdvalue_cast< std::vector< int > & > (RDValue_cast_t v)
 
template<>
std::vector< unsigned intrdvalue_cast< std::vector< unsigned int > > (RDValue_cast_t v)
 
template<>
std::vector< unsigned int > & rdvalue_cast< std::vector< unsigned int > & > (RDValue_cast_t v)
 
template<>
std::any rdvalue_cast< std::any > (RDValue_cast_t v)
 
template<>
std::any & rdvalue_cast< std::any & > (RDValue_cast_t v)
 
template<>
const std::any & rdvalue_cast< const std::any & > (RDValue_cast_t v)
 
template<class T >
std::string vectToString (RDValue val)
 
bool rdvalue_tostring (RDValue_cast_t val, std::string &res)
 
template<class T >
boost::enable_if< boost::is_arithmetic< T >, T >::type from_rdvalue (RDValue_cast_t arg)
 
template<class T >
boost::disable_if< boost::is_arithmetic< T >, T >::type from_rdvalue (RDValue_cast_t arg)
 
template<class T , unsigned int size>
SwapBytes (T value)
 
template<EEndian from, EEndian to, class T >
EndianSwapBytes (T value)
 
template<EEndian from, EEndian to>
char EndianSwapBytes (char value)
 
template<EEndian from, EEndian to>
unsigned char EndianSwapBytes (unsigned char value)
 
template<EEndian from, EEndian to>
signed char EndianSwapBytes (signed char value)
 
void appendPackedIntToStream (std::stringstream &ss, boost::uint32_t num)
 Packs an integer and outputs it to a stream.
 
boost::uint32_t readPackedIntFromStream (std::stringstream &ss)
 Reads an integer from a stream in packed format and returns the result.
 
boost::uint32_t pullPackedIntFromString (const char *&text)
 
template<typename T >
void streamWrite (std::ostream &ss, const T &val)
 does a binary write of an object to a stream
 
void streamWrite (std::ostream &ss, const std::string &what)
 special case for string
 
template<typename T >
void streamWriteVec (std::ostream &ss, const T &val)
 
template<typename T >
void streamRead (std::istream &ss, T &loc)
 does a binary read of an object from a stream
 
template<class T >
void streamRead (std::istream &ss, T &obj, int version)
 special case for string
 
void streamRead (std::istream &ss, std::string &what, int version)
 
template<class T >
void streamReadVec (std::istream &ss, T &val)
 
void streamReadStringVec (std::istream &ss, std::vector< std::string > &val, int version)
 
std::string getLine (std::istream *inStream)
 grabs the next line from an instream and returns it.
 
std::string getLine (std::istream &inStream)
 grabs the next line from an instream and returns it.
 
bool isSerializable (const Dict::Pair &pair, const CustomPropHandlerVec &handlers={})
 
bool streamWriteProp (std::ostream &ss, const Dict::Pair &pair, const CustomPropHandlerVec &handlers={})
 
template<typename COUNT_TYPE = unsigned int>
bool streamWriteProps (std::ostream &ss, const RDProps &props, bool savePrivate=false, bool saveComputed=false, const CustomPropHandlerVec &handlers={}, const std::unordered_set< std::string > &ignore={})
 
template<class T >
void readRDValue (std::istream &ss, RDValue &value)
 
template<class T >
void readRDVecValue (std::istream &ss, RDValue &value)
 
void readRDValueString (std::istream &ss, RDValue &value)
 
void readRDStringVecValue (std::istream &ss, RDValue &value)
 
bool streamReadProp (std::istream &ss, Dict::Pair &pair, bool &dictHasNonPOD, const CustomPropHandlerVec &handlers={})
 
template<typename COUNT_TYPE = unsigned int>
unsigned int streamReadProps (std::istream &ss, RDProps &props, const CustomPropHandlerVec &handlers={}, bool reset=true)
 
RDKIT_RDGENERAL_EXPORT void Union (const INT_VECT &r1, const INT_VECT &r2, INT_VECT &res)
 calculate the union of two INT_VECTs and put the results in a third vector
 
RDKIT_RDGENERAL_EXPORT void Intersect (const INT_VECT &r1, const INT_VECT &r2, INT_VECT &res)
 calculate the intersection of two INT_VECTs and put the results in a third vector
 
RDKIT_RDGENERAL_EXPORT void Union (const VECT_INT_VECT &rings, INT_VECT &res, const INT_VECT *exclude=nullptr)
 calculating the union of the INT_VECT's in a VECT_INT_VECT
 
RDKIT_RDGENERAL_EXPORT int nextCombination (INT_VECT &comb, int tot)
 given a current combination of numbers change it to the next possible
 
RDKIT_RDGENERAL_EXPORT double computeIntVectPrimesProduct (const INT_VECT &ring)
 compute the product of the set of primes corresponding to the values in an INT_VECT
 
RDKIT_RDGENERAL_EXPORT bool feq (double v1, double v2, double tol=1e-4)
 floating point comparison with a tolerance
 
RDKIT_RDGENERAL_EXPORT rng_typegetRandomGenerator (int seed=-1)
 
RDKIT_RDGENERAL_EXPORT double getRandomVal (int seed=-1)
 
RDKIT_RDGENERAL_EXPORT double_source_typegetDoubleRandomSource ()
 return a reference to the global (Boost) random source
 
template<class T >
unsigned int countSwapsToInterconvert (const T &ref, T probe)
 
RDKIT_RDGENERAL_EXPORT std::string augmentTagName (const std::string &tag)
 
Reaction SMARTS/SMILES Support
RDKIT_CHEMREACTIONS_EXPORT ChemicalReactionRxnSmartsToChemicalReaction (const std::string &text, std::map< std::string, std::string > *replacements=nullptr, bool useSmiles=false, bool allowCXSMILES=true)
 Parse a string containing "Reaction SMARTS" into a ChemicalReaction.
 
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnSmarts (const ChemicalReaction &rxn)
 returns the reaction SMARTS for a reaction
 
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnSmiles (const ChemicalReaction &rxn, bool canonical=true)
 returns the reaction SMILES for a reaction
 
Reaction Mol Support
RDKIT_CHEMREACTIONS_EXPORT ChemicalReactionRxnMolToChemicalReaction (const ROMol &mol)
 Parse a ROMol into a ChemicalReaction, RXN role must be set before.
 
RDKIT_CHEMREACTIONS_EXPORT ROMolChemicalReactionToRxnMol (const ChemicalReaction &rxn)
 returns a ROMol with RXN roles used to describe the reaction
 
MDL rxn Support
RDKIT_CHEMREACTIONS_EXPORT ChemicalReactionRxnBlockToChemicalReaction (const std::string &rxnBlock, bool sanitize=false, bool removeHs=false, bool strictParsing=true)
 Parse a text block in MDL rxn format into a ChemicalReaction.
 
RDKIT_CHEMREACTIONS_EXPORT ChemicalReactionRxnFileToChemicalReaction (const std::string &fileName, bool sanitize=false, bool removeHs=false, bool strictParsing=true)
 Parse a file in MDL rxn format into a ChemicalReaction.
 
RDKIT_CHEMREACTIONS_EXPORT ChemicalReactionRxnDataStreamToChemicalReaction (std::istream &rxnStream, unsigned int &line, bool sanitize=false, bool removeHs=false, bool strictParsing=true)
 Parse a text stream in MDL rxn format into a ChemicalReaction.
 
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnBlock (const ChemicalReaction &rxn, bool separateAgents=false, bool forceV3000=false)
 returns an rxn block for a reaction
 
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToV3KRxnBlock (const ChemicalReaction &rxn, bool separateAgents=false)
 returns an V3000 rxn block for a reaction
 
PNG Support
RDKIT_CHEMREACTIONS_EXPORT ChemicalReactionPNGStreamToChemicalReaction (std::istream &pngStream)
 constructs a ChemicalReaction from the metadata in a PNG stream
 
ChemicalReactionPNGStringToChemicalReaction (const std::string &data)
 constructs a ChemicalReaction from the metadata in a PNG string See PNGStreamToChemicalReaction() for more details
 
ChemicalReactionPNGFileToChemicalReaction (const std::string &fname)
 constructs a ChemicalReaction from the metadata in a PNG file See PNGStreamToChemicalReaction() for more details
 
RDKIT_CHEMREACTIONS_EXPORT std::string addChemicalReactionToPNGStream (const ChemicalReaction &rxn, std::istream &iStream, bool includePkl=true, bool includeSmiles=true, bool includeSmarts=false, bool includeRxn=false)
 adds metadata for a ChemicalReaction to the data from a PNG stream. The modified PNG data is returned.
 
std::string addChemicalReactionToPNGString (const ChemicalReaction &rxn, const std::string &pngString, bool includePkl=true, bool includeSmiles=true, bool includeSmarts=false, bool includeRxn=false)
 adds metadata for a ChemicalReaction to the data from a PNG string. See addChemicalReactionToPNGStream() for more details.
 
std::string addChemicalReactionToPNGFile (const ChemicalReaction &rxn, const std::string &fname, bool includePkl=true, bool includeSmiles=true, bool includeSmarts=false, bool includeRxn=false)
 adds metadata for a ChemicalReaction to the data from a PNG string. See addChemicalReactionToPNGStream() for more details.
 
CDXML rxn Support
RDKIT_CHEMREACTIONS_EXPORT std::vector< std::unique_ptr< ChemicalReaction > > CDXMLToChemicalReactions (const std::string &rxnBlock, bool sanitize=false, bool removeHs=false)
 Parse text in CDXML rxn format into a vector of ChemicalReactions.
 
RDKIT_CHEMREACTIONS_EXPORT std::vector< std::unique_ptr< ChemicalReaction > > CDXMLFileToChemicalReactions (const std::string &fileName, bool sanitize=false, bool removeHs=false)
 Parse a file in CDXML rxn format into a vector of ChemicalReactions.
 
RDKIT_CHEMREACTIONS_EXPORT std::vector< std::unique_ptr< ChemicalReaction > > CDXMLDataStreamToChemicalReactions (std::istream &rxnStream, bool sanitize=false, bool removeHs=false)
 Parse a text stream in CDXML rxn format into a vector of ChemicalReactions.
 
metadata to/from PNG
RDKIT_FILEPARSERS_EXPORT std::vector< std::pair< std::string, std::string > > PNGStreamToMetadata (std::istream &inStream)
 returns the metadata (tEXt and zTXt chunks) from PNG data
 
std::vector< std::pair< std::string, std::string > > PNGFileToMetadata (const std::string &fname)
 returns the metadata (tEXt and zTXt chunks) from PNG data
 
std::vector< std::pair< std::string, std::string > > PNGStringToMetadata (const std::string &data)
 returns the metadata (tEXt and zTXt chunks) from PNG data
 
RDKIT_FILEPARSERS_EXPORT std::string addMetadataToPNGStream (std::istream &iStream, const std::vector< std::pair< std::string, std::string > > &metadata, bool compressed=true)
 adds metadata to a PNG stream. The modified PNG data is returned.
 
std::string addMetadataToPNGString (const std::string &pngString, const std::vector< std::pair< std::string, std::string > > &metadata, bool compressed=true)
 adds metadata to a PNG string. The modified PNG data is returned.
 
std::string addMetadataToPNGFile (const std::string &fname, const std::vector< std::pair< std::string, std::string > > &metadata, bool compressed=true)
 adds metadata to a PNG file. The modified PNG data is returned.
 
molecules to/from PNG
RDKIT_FILEPARSERS_EXPORT ROMolPNGStreamToMol (std::istream &inStream, const SmilesParserParams &params=SmilesParserParams())
 constructs an ROMol from the metadata in a PNG stream
 
ROMolPNGFileToMol (const std::string &fname, const SmilesParserParams &params=SmilesParserParams())
 constructs an ROMol from the metadata in a PNG file. See PNGStreamToMol() for more details.
 
ROMolPNGStringToMol (const std::string &data, const SmilesParserParams &params=SmilesParserParams())
 constructs an ROMol from the metadata in a PNG string. See PNGStreamToMol() for more details.
 
RDKIT_FILEPARSERS_EXPORT std::vector< std::unique_ptr< ROMol > > PNGStreamToMols (std::istream &inStream, const std::string &tagToUse=PNGData::pklTag, const SmilesParserParams &params=SmilesParserParams())
 constructs a vector of ROMol from the metadata in a PNG stream
 
std::vector< std::unique_ptr< ROMol > > PNGFileToMols (const std::string &fname, const std::string &tagToUse=PNGData::pklTag, const SmilesParserParams &params=SmilesParserParams())
 constructs a vector of ROMol from the metadata in a PNG file. See PNGStreamToMols() for more details.
 
std::vector< std::unique_ptr< ROMol > > PNGStringToMols (const std::string &data, const std::string &tagToUse=PNGData::pklTag, const SmilesParserParams &params=SmilesParserParams())
 constructs a vector of ROMol from the metadata in a PNG string. See PNGStreamToMols() for more details.
 
RDKIT_FILEPARSERS_EXPORT std::string addMolToPNGStream (const ROMol &mol, std::istream &iStream, bool includePkl=true, bool includeSmiles=true, bool includeMol=false)
 adds metadata for an ROMol to the data from a PNG stream. The modified PNG data is returned.
 
std::string addMolToPNGString (const ROMol &mol, const std::string &pngString, bool includePkl=true, bool includeSmiles=true, bool includeMol=false)
 adds metadata for an ROMol to a PNG string. The modified PNG data is returned. See addMolToPNGStream() for more details.
 
std::string addMolToPNGFile (const ROMol &mol, const std::string &fname, bool includePkl=true, bool includeSmiles=true, bool includeMol=false)
 adds metadata for an ROMol to the data from a PNG file. The modified PNG data is returned. See addMolToPNGStream() for more details.
 
SubstanceGroups and molecules
RDKIT_GRAPHMOL_EXPORT std::vector< SubstanceGroup > & getSubstanceGroups (ROMol &mol)
 
RDKIT_GRAPHMOL_EXPORT const std::vector< SubstanceGroup > & getSubstanceGroups (const ROMol &mol)
 
RDKIT_GRAPHMOL_EXPORT unsigned int addSubstanceGroup (ROMol &mol, SubstanceGroup sgroup)
 
RDKIT_GRAPHMOL_EXPORT void removeSubstanceGroupsReferencingAtom (RWMol &mol, unsigned int idx)
 Removes SubstanceGroups which reference a particular atom index.
 
RDKIT_GRAPHMOL_EXPORT void removeSubstanceGroupsReferencingBond (RWMol &mol, unsigned int idx)
 Removes SubstanceGroups which reference a particular bond index.
 

Variables

RDKIT_GRAPHMOL_EXPORT const std::string periodicTableAtomData
 
RDKIT_GRAPHMOL_EXPORT const std::string isotopesAtomData []
 
RDKIT_GRAPHMOL_EXPORT const std::vector< std::string > elementNames
 
RDKIT_CHEMREACTIONS_EXPORT const ReactionFingerprintParams DefaultStructuralFPParams
 
RDKIT_CHEMREACTIONS_EXPORT const ReactionFingerprintParams DefaultDifferenceFPParams
 
const int MOLFILE_MAXLINE = 256
 
static int defaultConfId = -1
 
static const unsigned int ctdIGNORE_H_H_CONTACTS = 0x1
 
RDKIT_FILTERCATALOG_EXPORT const charDEFAULT_FILTERMATCHERBASE_NAME
 
RDKIT_FILTERCATALOG_EXPORT const charSMARTS_MATCH_NAME_DEFAULT
 
const std::string RDKFingerprintMolVersion = "2.0.0"
 
const unsigned int maxFingerprintLayers = 10
 
const std::string LayeredFingerprintMolVersion = "0.7.0"
 
const unsigned int substructLayers = 0x07
 
const std::string PatternFingerprintMolVersion = "1.0.0"
 
const std::vector< std::string > sruSgroupConnectChoices {"hh", "ht", "eu"}
 
const std::vector< std::string > marvinBondOrders {"1", "2", "3", "A"}
 
const std::vector< std::string > marvinQueryBondsTypes {"SD", "SA", "DA", "Any"}
 
const std::vector< std::string > marvinConventionTypes {"cxn:coord"}
 
const std::vector< std::string > marvinStereoDictRefTypes {"cml:W", "cml:H"}
 
const std::vector< std::string > marvinStereoConventionTypes {"1", "3", "4", "6"}
 
const std::vector< std::string > marvinRadicalVals
 
const std::map< std::string, intmarvinRadicalToRadicalElectrons
 
const std::map< int, std::string > radicalElectronsToMarvinRadical
 
const DashPattern noDash
 
const DashPattern dots {2.0, 6.0}
 
const DashPattern dashes {6.0, 4.0}
 
const DashPattern shortDashes {2.0, 2.0}
 
static const double lineWidthScaleFactor = 0.02
 
RDKIT_MOLDRAW2DQT_EXPORT const charrdkitQtVersion
 
std::string paramData
 
std::string additionalParamData
 
const double IONXH = 20.02
 
const double DAMP_SCALE = 0.5
 
const double DAMP = 0.5
 
const int massIntegerConversionFactor = 1000
 
const std::vector< std::string > complexQueries
 
const std::string _rgroupInputDummy
 
RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string RLABEL
 
RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string RLABEL_TYPE
 
RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string RLABEL_CORE_INDEX
 
RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string SIDECHAIN_RLABELS
 
RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string done
 
RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string UNLABELED_CORE_ATTACHMENT
 
const unsigned int EMPTY_CORE_LABEL = -100000
 
RDKIT_GRAPHMOL_EXPORT const int ci_RIGHTMOST_ATOM
 
RDKIT_GRAPHMOL_EXPORT const int ci_LEADING_BOND
 
RDKIT_GRAPHMOL_EXPORT const int ci_ATOM_HOLDER
 
const int NUM_PRIMES_AVAIL = 1000
 the number of primes available and stored
 
int firstThousandPrimes [NUM_PRIMES_AVAIL]
 
const unsigned int BITS_PER_INT = 32
 
RDKIT_RDGENERAL_EXPORT const double MAX_DOUBLE
 
RDKIT_RDGENERAL_EXPORT const double EPS_DOUBLE
 
RDKIT_RDGENERAL_EXPORT const double SMALL_DOUBLE
 
RDKIT_RDGENERAL_EXPORT const double MAX_INT
 
RDKIT_RDGENERAL_EXPORT const double MAX_LONGINT
 
const int FILE_MAXLINE
 an assumed maximum length for lines read from files
 
RDKIT_RDGENERAL_EXPORT const charrdkitVersion
 
RDKIT_RDGENERAL_EXPORT const charboostVersion
 
RDKIT_RDGENERAL_EXPORT const charrdkitBuild
 

Detailed Description

Std stuff.

Includes a bunch of functionality for handling Atom and Bond queries.

Utilities to handle atomic numbers in Mancude (maximum number of noncumulative double bonds) rings

This guarantees that aromatic rings containing heteroatoms are always resolved in the same way

Typedef Documentation

◆ ATOM_AND_QUERY

◆ ATOM_BOOL_QUERY

◆ ATOM_EQUALS_QUERY

◆ ATOM_GREATER_QUERY

◆ ATOM_GREATEREQUAL_QUERY

◆ ATOM_LESS_QUERY

◆ ATOM_LESSEQUAL_QUERY

◆ ATOM_NULL_QUERY

◆ ATOM_OR_QUERY

◆ ATOM_PROP_QUERY

◆ ATOM_RANGE_QUERY

◆ ATOM_SET_QUERY

◆ ATOM_XOR_QUERY

◆ atomindex_t

typedef std::uint32_t RDKit::atomindex_t

Definition at line 14 of file details.h.

◆ BOND_AND_QUERY

◆ BOND_BOOL_QUERY

◆ BOND_EQUALS_QUERY

◆ BOND_GREATER_QUERY

◆ BOND_GREATEREQUAL_QUERY

◆ BOND_LESS_QUERY

◆ BOND_LESSEQUAL_QUERY

◆ BOND_NULL_QUERY

◆ BOND_OR_QUERY

◆ BOND_PROP_QUERY

◆ BOND_RANGE_QUERY

◆ BOND_SET_QUERY

◆ BOND_XOR_QUERY

◆ CEMap

typedef std::unordered_map<std::size_t, ConjElectrons *> RDKit::CEMap

Definition at line 32 of file Resonance.h.

◆ CEVect

Definition at line 29 of file Resonance.h.

◆ CEVect3

typedef std::vector<CEVect2 *> RDKit::CEVect3

Definition at line 30 of file Resonance.h.

◆ ColourPalette

Definition at line 57 of file MolDraw2DHelpers.h.

◆ CONFORMER_SPTR

Definition at line 167 of file Conformer.h.

◆ ConjAtomMap

Definition at line 28 of file Resonance.h.

◆ ConjBondMap

Definition at line 27 of file Resonance.h.

◆ ConjFP

typedef std::vector<std::uint8_t> RDKit::ConjFP

Definition at line 31 of file Resonance.h.

◆ ConstAtomPtr

Definition at line 705 of file QueryOps.h.

◆ ConstBondPtr

Definition at line 815 of file QueryOps.h.

◆ CustomPropHandlerVec

Definition at line 382 of file StreamOps.h.

◆ DashPattern

Definition at line 58 of file MolDraw2DHelpers.h.

◆ DOUBLE_INT_MAP

std::map from double to integer.

Definition at line 351 of file types.h.

◆ double_source_type

Definition at line 40 of file utils.h.

◆ DOUBLE_VECT

Definition at line 306 of file types.h.

◆ DOUBLE_VECT_CI

typedef DOUBLE_VECT::const_iterator RDKit::DOUBLE_VECT_CI

Definition at line 308 of file types.h.

◆ DOUBLE_VECT_I

typedef DOUBLE_VECT::iterator RDKit::DOUBLE_VECT_I

Definition at line 307 of file types.h.

◆ FCatalog

◆ FeatSPtr

Definition at line 20 of file MolChemicalFeatureFactory.h.

◆ FeatSPtrList

Definition at line 21 of file MolChemicalFeatureFactory.h.

◆ FeatSPtrList_I

typedef FeatSPtrList::iterator RDKit::FeatSPtrList_I

Definition at line 22 of file MolChemicalFeatureFactory.h.

◆ FragCatalog

◆ INT_DEQUE

Definition at line 323 of file types.h.

◆ INT_DEQUE_CI

typedef INT_DEQUE::const_iterator RDKit::INT_DEQUE_CI

Definition at line 325 of file types.h.

◆ INT_DEQUE_I

typedef INT_DEQUE::iterator RDKit::INT_DEQUE_I

Definition at line 324 of file types.h.

◆ INT_INT_DEQ_MAP

Definition at line 327 of file types.h.

◆ INT_INT_DEQ_MAP_CI

typedef INT_INT_DEQ_MAP::const_iterator RDKit::INT_INT_DEQ_MAP_CI

Definition at line 328 of file types.h.

◆ INT_INT_VECT_MAP

Definition at line 316 of file types.h.

◆ INT_INT_VECT_MAP_CI

typedef INT_INT_VECT_MAP::const_iterator RDKit::INT_INT_VECT_MAP_CI

Definition at line 317 of file types.h.

◆ INT_LIST

Definition at line 287 of file types.h.

◆ INT_LIST_CI

typedef INT_LIST::const_iterator RDKit::INT_LIST_CI

Definition at line 289 of file types.h.

◆ INT_LIST_I

typedef INT_LIST::iterator RDKit::INT_LIST_I

Definition at line 288 of file types.h.

◆ INT_MAP_INT

Definition at line 319 of file types.h.

◆ INT_MAP_INT_CI

typedef INT_MAP_INT::const_iterator RDKit::INT_MAP_INT_CI

Definition at line 321 of file types.h.

◆ INT_MAP_INT_I

typedef INT_MAP_INT::iterator RDKit::INT_MAP_INT_I

Definition at line 320 of file types.h.

◆ INT_PATH_LIST_MAP

Definition at line 46 of file Subgraphs.h.

◆ INT_PATH_LIST_MAP_CI

typedef INT_PATH_LIST_MAP::const_iterator RDKit::INT_PATH_LIST_MAP_CI

Definition at line 47 of file Subgraphs.h.

◆ INT_PATH_LIST_MAP_I

typedef INT_PATH_LIST_MAP::iterator RDKit::INT_PATH_LIST_MAP_I

Definition at line 48 of file Subgraphs.h.

◆ INT_SET

Definition at line 330 of file types.h.

◆ INT_SET_CI

typedef INT_SET::const_iterator RDKit::INT_SET_CI

Definition at line 332 of file types.h.

◆ INT_SET_I

typedef INT_SET::iterator RDKit::INT_SET_I

Definition at line 331 of file types.h.

◆ int_source_type

typedef boost::variate_generator<rng_type &, uniform_int> RDKit::int_source_type

Definition at line 39 of file utils.h.

◆ INT_VECT

typedef std::vector<int> RDKit::INT_VECT

Definition at line 281 of file types.h.

◆ INT_VECT_CI

typedef INT_VECT::const_iterator RDKit::INT_VECT_CI

Definition at line 283 of file types.h.

◆ INT_VECT_CRI

typedef INT_VECT::const_reverse_iterator RDKit::INT_VECT_CRI

Definition at line 285 of file types.h.

◆ INT_VECT_I

typedef INT_VECT::iterator RDKit::INT_VECT_I

Definition at line 282 of file types.h.

◆ INT_VECT_RI

typedef INT_VECT::reverse_iterator RDKit::INT_VECT_RI

Definition at line 284 of file types.h.

◆ INVAR_VECT

Definition at line 32 of file MolOps.h.

◆ INVAR_VECT_CI

typedef INVAR_VECT::const_iterator RDKit::INVAR_VECT_CI

Definition at line 34 of file MolOps.h.

◆ INVAR_VECT_I

typedef INVAR_VECT::iterator RDKit::INVAR_VECT_I

Definition at line 33 of file MolOps.h.

◆ LIST_INT_VECT

Definition at line 291 of file types.h.

◆ LIST_INT_VECT_CI

typedef LIST_INT_VECT::const_iterator RDKit::LIST_INT_VECT_CI

Definition at line 293 of file types.h.

◆ LIST_INT_VECT_I

typedef LIST_INT_VECT::iterator RDKit::LIST_INT_VECT_I

Definition at line 292 of file types.h.

◆ LONGINT

Definition at line 260 of file types.h.

◆ MatchVectType

typedef std::vector< std::pair< int, int > > RDKit::MatchVectType

used to return matches from substructure searching, The format is (queryAtomIdx, molAtomIdx)

Definition at line 24 of file FragFPGenerator.h.

◆ MCSAcceptanceFunction

typedef bool(* RDKit::MCSAcceptanceFunction) (const ROMol &, const ROMol &, const std::vector< std::pair< int, int > > &, const std::vector< std::pair< int, int > > &, const MCSParameters *)

Definition at line 65 of file FMCS.h.

◆ MCSAtomCompareFunction

typedef bool(* RDKit::MCSAtomCompareFunction) (const MCSAtomCompareParameters &, const ROMol &, unsigned int, const ROMol &, unsigned int, void *)

Definition at line 59 of file FMCS.h.

◆ MCSBondCompareFunction

typedef bool(* RDKit::MCSBondCompareFunction) (const MCSBondCompareParameters &, const ROMol &, unsigned int, const ROMol &, unsigned int, void *)

Definition at line 62 of file FMCS.h.

◆ MCSFinalMatchCheckFunction

typedef bool(* RDKit::MCSFinalMatchCheckFunction) (const std::uint32_t[], const std::uint32_t[], const ROMol &, const FMCS::Graph &, const ROMol &, const FMCS::Graph &, const MCSParameters *)

Definition at line 69 of file FMCS.h.

◆ MCSProgressCallback

typedef bool(* RDKit::MCSProgressCallback) (const MCSProgressData &stat, const MCSParameters &params, void *userData)

Definition at line 140 of file FMCS.h.

◆ MOL_PTR_VECT

Definition at line 877 of file ROMol.h.

◆ MOL_PTR_VECT_CI

typedef MOL_PTR_VECT::const_iterator RDKit::MOL_PTR_VECT_CI

Definition at line 880 of file ROMol.h.

◆ MOL_PTR_VECT_I

typedef MOL_PTR_VECT::iterator RDKit::MOL_PTR_VECT_I

Definition at line 881 of file ROMol.h.

◆ MOL_SPTR_VECT

Definition at line 21 of file FragCatParams.h.

◆ MOL_VECT

Definition at line 875 of file ROMol.h.

◆ MolCatalog

a hierarchical catalog for holding molecules

Definition at line 17 of file MolCatalog.h.

◆ MolGraph

typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, Atom *, Bond *> RDKit::MolGraph

This is the BGL type used to store the topology:

Definition at line 55 of file ROMol.h.

◆ PATH_LIST

Definition at line 43 of file Subgraphs.h.

◆ PATH_LIST_CI

typedef PATH_LIST::const_iterator RDKit::PATH_LIST_CI

Definition at line 44 of file Subgraphs.h.

◆ PATH_TYPE

Definition at line 42 of file Subgraphs.h.

◆ R_DECOMP

Definition at line 16 of file RGroupMatch.h.

◆ RData

typedef boost::shared_ptr<RGroupData> RDKit::RData

Definition at line 15 of file RGroupMatch.h.

◆ RDValue_cast_t

◆ RGroupColumn

Definition at line 32 of file RGroupDecomp.h.

◆ RGroupColumns

typedef std::map<std::string, RGroupColumn> RDKit::RGroupColumns

Definition at line 35 of file RGroupDecomp.h.

◆ RGroupGaPopulation

◆ RGroupRow

typedef std::map<std::string, ROMOL_SPTR> RDKit::RGroupRow

Definition at line 31 of file RGroupDecomp.h.

◆ RGroupRows

Definition at line 34 of file RGroupDecomp.h.

◆ rng_type

typedef boost::minstd_rand RDKit::rng_type

Definition at line 36 of file utils.h.

◆ ROMOL_SPTR

typedef boost::shared_ptr< ROMol > RDKit::ROMOL_SPTR

Definition at line 23 of file ChemTransforms.h.

◆ RWMOL_SPTR

typedef boost::shared_ptr<RWMol> RDKit::RWMOL_SPTR

Definition at line 216 of file RWMol.h.

◆ RWMOL_SPTR_VECT

Definition at line 48 of file FileParsers.h.

◆ SnapshotVect

Definition at line 21 of file Snapshot.h.

◆ STR_UINT_MAP

typedef std::map<std::string, UINT> RDKit::STR_UINT_MAP

Definition at line 313 of file types.h.

◆ STR_UINT_MAP_CI

typedef std::map<std::string,UINT>::const_iterator RDKit::STR_UINT_MAP_CI

Definition at line 314 of file types.h.

◆ STR_VECT

typedef std::vector< std::string > RDKit::STR_VECT

Definition at line 29 of file Dict.h.

◆ STR_VECT_CI

typedef std::vector<std::string>::const_iterator RDKit::STR_VECT_CI

Definition at line 302 of file types.h.

◆ STR_VECT_I

typedef std::vector<std::string>::iterator RDKit::STR_VECT_I

Definition at line 303 of file types.h.

◆ STRING_PROPS

typedef std::map<std::string, std::string> RDKit::STRING_PROPS

Definition at line 54 of file FilterCatalogEntry.h.

◆ UCHAR

Definition at line 279 of file types.h.

◆ UINT

Definition at line 277 of file types.h.

◆ UINT_VECT

Definition at line 300 of file types.h.

◆ UINT_VECT_CI

typedef std::vector<UINT>::const_iterator RDKit::UINT_VECT_CI

Definition at line 299 of file types.h.

◆ uniform_double

typedef boost::uniform_real RDKit::uniform_double

Definition at line 38 of file utils.h.

◆ uniform_int

typedef boost::uniform_int RDKit::uniform_int

Definition at line 37 of file utils.h.

◆ USHORT

Definition at line 278 of file types.h.

◆ VECT_DOUBLE_VECT

Definition at line 309 of file types.h.

◆ VECT_DOUBLE_VECT_CI

typedef VECT_DOUBLE_VECT::const_iterator RDKit::VECT_DOUBLE_VECT_CI

Definition at line 311 of file types.h.

◆ VECT_DOUBLE_VECT_I

typedef VECT_DOUBLE_VECT::iterator RDKit::VECT_DOUBLE_VECT_I

Definition at line 310 of file types.h.

◆ VECT_INT_VECT

Definition at line 295 of file types.h.

◆ VECT_INT_VECT_CI

typedef VECT_INT_VECT::const_iterator RDKit::VECT_INT_VECT_CI

Definition at line 297 of file types.h.

◆ VECT_INT_VECT_I

typedef VECT_INT_VECT::iterator RDKit::VECT_INT_VECT_I

Definition at line 296 of file types.h.

Enumeration Type Documentation

◆ AtomComparator

Enumerator
AtomCompareAny 
AtomCompareElements 
AtomCompareIsotopes 
AtomCompareAnyHeavyAtom 

Definition at line 22 of file FMCS.h.

◆ BondComparator

Enumerator
BondCompareAny 
BondCompareOrder 
BondCompareOrderExact 

Definition at line 29 of file FMCS.h.

◆ EEndian

Enumerator
LITTLE_ENDIAN_ORDER 
BIG_ENDIAN_ORDER 

Definition at line 28 of file StreamOps.h.

◆ FingerprintType

Enumerator
AtomPairFP 
TopologicalTorsion 
MorganFP 
RDKitFP 
PatternFP 

Definition at line 43 of file ReactionFingerprints.h.

◆ FPType

Enumerator
AtomPairFP 
MorganFP 
RDKitFP 
TopologicalTorsionFP 

Definition at line 454 of file FingerprintGenerator.h.

◆ IsSgroupInAtomSetResult

Enumerator
SgroupInAtomSet 
SgroupNotInAtomSet 
SgroupBothInAndNotInAtomSet 

Definition at line 56 of file MarvinDefs.h.

◆ Labelling

Enumerator
RGROUP_LABELS 
ISOTOPE_LABELS 
ATOMMAP_LABELS 
INDEX_LABELS 
DUMMY_LABELS 
INTERNAL_LABELS 

Definition at line 31 of file RGroupUtils.h.

◆ Mol2Type

Enumerator
CORINA 

supports output from Corina and some dbtranslate output

Definition at line 236 of file FileParsers.h.

◆ MolzipLabel

Enumerator
AtomMapNumber 
Isotope 
FragmentOnBonds 
AtomType 
AtomProperty 

Definition at line 106 of file MolFragmenter.h.

◆ MultiColourHighlightStyle

Enumerator
CIRCLEANDLINE 
LASSO 

Definition at line 146 of file MolDraw2DHelpers.h.

◆ OperationName

Enumerator
RgroupMutate 
Crossover 
Create 

Definition at line 39 of file RGroupGa.h.

◆ ReactionMoleculeType

Enumerator
Reactant 
Product 
Agent 

Definition at line 41 of file ReactionUtils.h.

◆ RGroupCoreAlignment

Enumerator
None 
NoAlignment 
MCS 

Definition at line 44 of file RGroupDecompParams.h.

◆ RGroupLabelling

Enumerator
AtomMap 
Isotope 
MDLRGroup 

Definition at line 38 of file RGroupDecompParams.h.

◆ RGroupLabels

Enumerator
IsotopeLabels 
AtomMapLabels 
AtomIndexLabels 
RelabelDuplicateLabels 
MDLRGroupLabels 
DummyAtomLabels 
AutoDetect 

Definition at line 20 of file RGroupDecompParams.h.

◆ RGroupMatching

Enumerator
Greedy 
GreedyChunks 
Exhaustive 
NoSymmetrization 
GA 

Definition at line 30 of file RGroupDecompParams.h.

◆ RGroupScore

Enumerator
Match 
FingerprintVariance 

Definition at line 51 of file RGroupDecompParams.h.

◆ RingComparator

Enumerator
IgnoreRingFusion 
PermissiveRingFusion 
StrictRingFusion 

Definition at line 35 of file FMCS.h.

◆ StereoGroupType

Enumerator
STEREO_ABSOLUTE 
STEREO_OR 
STEREO_AND 

Definition at line 30 of file StereoGroup.h.

Function Documentation

◆ addChemicalReactionToPNGFile()

std::string RDKit::addChemicalReactionToPNGFile ( const ChemicalReaction rxn,
const std::string &  fname,
bool  includePkl = true,
bool  includeSmiles = true,
bool  includeSmarts = false,
bool  includeRxn = false 
)
inline

adds metadata for a ChemicalReaction to the data from a PNG string. See addChemicalReactionToPNGStream() for more details.

Definition at line 239 of file ReactionParser.h.

References addChemicalReactionToPNGFile(), and addChemicalReactionToPNGStream().

Referenced by addChemicalReactionToPNGFile().

◆ addChemicalReactionToPNGStream()

RDKIT_CHEMREACTIONS_EXPORT std::string RDKit::addChemicalReactionToPNGStream ( const ChemicalReaction rxn,
std::istream &  iStream,
bool  includePkl = true,
bool  includeSmiles = true,
bool  includeSmarts = false,
bool  includeRxn = false 
)

adds metadata for a ChemicalReaction to the data from a PNG stream. The modified PNG data is returned.

Parameters
rxnthe reaction to add
iStreamthe stream to read from
includePklinclude a reaction pickle
includeSmilesinclude reaction SMILES for the reaction
includeSmartsinclude reaction SMARTS for the reaction
includeRxninclude an RXN block for the reaction

References addChemicalReactionToPNGStream().

Referenced by addChemicalReactionToPNGFile(), addChemicalReactionToPNGStream(), and addChemicalReactionToPNGString().

◆ addChemicalReactionToPNGString()

std::string RDKit::addChemicalReactionToPNGString ( const ChemicalReaction rxn,
const std::string &  pngString,
bool  includePkl = true,
bool  includeSmiles = true,
bool  includeSmarts = false,
bool  includeRxn = false 
)
inline

adds metadata for a ChemicalReaction to the data from a PNG string. See addChemicalReactionToPNGStream() for more details.

Definition at line 227 of file ReactionParser.h.

References addChemicalReactionToPNGStream(), and addChemicalReactionToPNGString().

Referenced by addChemicalReactionToPNGString().

◆ addMetadataToPNGFile()

std::string RDKit::addMetadataToPNGFile ( const std::string &  fname,
const std::vector< std::pair< std::string, std::string > > &  metadata,
bool  compressed = true 
)
inline

adds metadata to a PNG file. The modified PNG data is returned.

Definition at line 84 of file PNGParser.h.

References addMetadataToPNGStream(), and rdvalue_is().

◆ addMetadataToPNGStream()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::addMetadataToPNGStream ( std::istream &  iStream,
const std::vector< std::pair< std::string, std::string > > &  metadata,
bool  compressed = true 
)

adds metadata to a PNG stream. The modified PNG data is returned.

The compressed flag is ignored if the RDKit is not built with boost::iostreams support

Referenced by addMetadataToPNGFile(), and addMetadataToPNGString().

◆ addMetadataToPNGString()

std::string RDKit::addMetadataToPNGString ( const std::string &  pngString,
const std::vector< std::pair< std::string, std::string > > &  metadata,
bool  compressed = true 
)
inline

adds metadata to a PNG string. The modified PNG data is returned.

Definition at line 74 of file PNGParser.h.

References addMetadataToPNGStream(), and rdvalue_is().

◆ addMolToPNGFile()

std::string RDKit::addMolToPNGFile ( const ROMol mol,
const std::string &  fname,
bool  includePkl = true,
bool  includeSmiles = true,
bool  includeMol = false 
)
inline

adds metadata for an ROMol to the data from a PNG file. The modified PNG data is returned. See addMolToPNGStream() for more details.

Definition at line 191 of file PNGParser.h.

References addMolToPNGStream(), and rdvalue_is().

◆ addMolToPNGStream()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::addMolToPNGStream ( const ROMol mol,
std::istream &  iStream,
bool  includePkl = true,
bool  includeSmiles = true,
bool  includeMol = false 
)

adds metadata for an ROMol to the data from a PNG stream. The modified PNG data is returned.

Parameters
molthe molecule to add
iStreamthe stream to read from
includePklinclude a molecule pickle
includeSmilesinclude CXSMILES for the molecule
includeMolinclude a mol block for the molecule

Referenced by addMolToPNGFile(), and addMolToPNGString().

◆ addMolToPNGString()

std::string RDKit::addMolToPNGString ( const ROMol mol,
const std::string &  pngString,
bool  includePkl = true,
bool  includeSmiles = true,
bool  includeMol = false 
)
inline

adds metadata for an ROMol to a PNG string. The modified PNG data is returned. See addMolToPNGStream() for more details.

Definition at line 179 of file PNGParser.h.

References addMolToPNGStream(), and rdvalue_is().

◆ addPatterns() [1/2]

RDKIT_SUBSTRUCTLIBRARY_EXPORT void RDKit::addPatterns ( SubstructLibrary sslib,
boost::shared_ptr< FPHolderBase patterns,
int  numThreads = 1 
)

Create pattern fingerprints for the given substructure library The substructure library must not already have fingerprints

◆ addPatterns() [2/2]

RDKIT_SUBSTRUCTLIBRARY_EXPORT void RDKit::addPatterns ( SubstructLibrary sslib,
int  numThreads = 1 
)

Create default pattern fingerprints for the given substructure library The substructure library must not already have fingerprints

◆ addRecursiveQueries()

RDKIT_CHEMTRANSFORMS_EXPORT void RDKit::addRecursiveQueries ( ROMol mol,
const std::map< std::string, ROMOL_SPTR > &  queries,
const std::string &  propName,
std::vector< std::pair< unsigned int, std::string > > *  reactantLabels = nullptr 
)

Adds named recursive queries to a molecule's atoms based on atom labels.

Parameters
mol- the molecule to be modified
queries- the dictionary of named queries to add
propName- the atom property to use to get query names
reactantLabels- to store pairs of (atom index, query string)

NOTES:

  • existing query information, if present, will be supplemented (AND logic)
  • non-query atoms will be replaced with query atoms using only the query logic
  • query names can be present as comma separated lists, they will then be combined using OR logic.
  • throws a KeyErrorException if a particular query name is not present in queries

◆ addRecursiveQueriesToReaction()

RDKIT_CHEMREACTIONS_EXPORT void RDKit::addRecursiveQueriesToReaction ( ChemicalReaction rxn,
const std::map< std::string, ROMOL_SPTR > &  queries,
const std::string &  propName,
std::vector< std::vector< std::pair< unsigned int, std::string > > > *  reactantLabels = nullptr 
)

add the recursive queries to the reactants of a reaction

This does its work using RDKit::addRecursiveQueries()

Parameters
rxnthe reaction we are interested in
queries- the dictionary of named queries to add
propName- the atom property to use to get query names optional:
reactantLabels- to store pairs of (atom index, query string) per reactant

NOTES:

  • existing query information, if present, will be supplemented (AND logic)
  • non-query atoms will be replaced with query atoms using only the query logic
  • query names can be present as comma separated lists, they will then be combined using OR logic.
  • throws a KeyErrorException if a particular query name is not present in queries

References addRecursiveQueriesToReaction().

Referenced by addRecursiveQueriesToReaction().

◆ addSubstanceGroup()

RDKIT_GRAPHMOL_EXPORT unsigned int RDKit::addSubstanceGroup ( ROMol mol,
SubstanceGroup  sgroup 
)

Add a new SubstanceGroup. A copy is added, so we can be sure that no other references to the SubstanceGroup exist.

Parameters
sgroup- SubstanceGroup to be added to the molecule.

◆ addWavyBondsForStereoAny()

RDKIT_FILEPARSERS_EXPORT void RDKit::addWavyBondsForStereoAny ( ROMol mol,
bool  clearDoubleBondFlags = true,
unsigned  addWhenImpossible = StereoBondThresholds::DBL_BOND_NO_STEREO 
)

set wavy bonds around double bonds with STEREOANY stereo

Parameters
molmolecule to be modified
clearDoubleBondFlagswhen this is true flags for unknown double bond stereo will also be removed.
addWhenImpossibleif nonzero a neighboring single bond will be made wavy even if it connects to a chiral center or double bond with specified stereo. one example of this would be the middle double bond in C/C=C/C=C/C=C/C (if that's set to STEREOANY after constructing the molecule) Otherwise, no wavy bond will be set

◆ appendPackedIntToStream()

void RDKit::appendPackedIntToStream ( std::stringstream &  ss,
boost::uint32_t  num 
)
inline

Packs an integer and outputs it to a stream.

Definition at line 106 of file StreamOps.h.

References CHECK_INVARIANT, and rdvalue_is().

◆ assignAvalonPalette()

void RDKit::assignAvalonPalette ( ColourPalette palette)
inline

use the color palette from the Avalon renderer

Definition at line 85 of file MolDraw2DHelpers.h.

References rdvalue_is().

◆ assignBWPalette()

void RDKit::assignBWPalette ( ColourPalette palette)
inline

Definition at line 141 of file MolDraw2DHelpers.h.

References rdvalue_is().

◆ assignCDKPalette()

void RDKit::assignCDKPalette ( ColourPalette palette)
inline

◆ assignDarkModePalette()

void RDKit::assignDarkModePalette ( ColourPalette palette)
inline

Definition at line 125 of file MolDraw2DHelpers.h.

References rdvalue_is().

Referenced by setDarkMode().

◆ assignDefaultPalette()

void RDKit::assignDefaultPalette ( ColourPalette palette)
inline

use the RDKit's default palette r

Definition at line 67 of file MolDraw2DHelpers.h.

References rdvalue_is().

Referenced by RDKit::MolDrawOptions::MolDrawOptions().

◆ assignStereoGroupIds()

RDKIT_GRAPHMOL_EXPORT void RDKit::assignStereoGroupIds ( std::vector< StereoGroup > &  groups)

Assign Group output IDs to all AND and OR StereoGroups in the vector that don't already have one. The IDs are assigned based on the order of the groups.

◆ atomCompat()

RDKIT_SUBSTRUCTMATCH_EXPORT bool RDKit::atomCompat ( const Atom a1,
const Atom a2,
const SubstructMatchParameters ps 
)

◆ augmentTagName()

RDKIT_RDGENERAL_EXPORT std::string RDKit::augmentTagName ( const std::string &  tag)

◆ bondCompat()

RDKIT_SUBSTRUCTMATCH_EXPORT bool RDKit::bondCompat ( const Bond b1,
const Bond b2,
const SubstructMatchParameters ps 
)

◆ buildFeatureFactory() [1/2]

RDKIT_MOLCHEMICALFEATURES_EXPORT MolChemicalFeatureFactory * RDKit::buildFeatureFactory ( const std::string &  featureData)

constructs a MolChemicalFeatureFactory from the data in a string

◆ buildFeatureFactory() [2/2]

RDKIT_MOLCHEMICALFEATURES_EXPORT MolChemicalFeatureFactory * RDKit::buildFeatureFactory ( std::istream &  inStream)

constructs a MolChemicalFeatureFactory from the data in a stream

◆ CDXMLDataStreamToChemicalReactions()

RDKIT_CHEMREACTIONS_EXPORT std::vector< std::unique_ptr< ChemicalReaction > > RDKit::CDXMLDataStreamToChemicalReactions ( std::istream &  rxnStream,
bool  sanitize = false,
bool  removeHs = false 
)

Parse a text stream in CDXML rxn format into a vector of ChemicalReactions.

References CDXMLDataStreamToChemicalReactions().

Referenced by CDXMLDataStreamToChemicalReactions().

◆ CDXMLDataStreamToMols()

RDKIT_FILEPARSERS_EXPORT std::vector< std::unique_ptr< RWMol > > RDKit::CDXMLDataStreamToMols ( std::istream &  inStream,
bool  sanitize = true,
bool  removeHs = true 
)

construct molecules from a CDXML file Note that the CDXML format is large and complex, the RDKit doesn't support full functionality, just the base ones required for molecule and reaction parsing.

Parameters
inStream- string containing the mol block
sanitize- toggles sanitization and stereochemistry perception of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized correctness of the contents.

◆ CDXMLFileToChemicalReactions()

RDKIT_CHEMREACTIONS_EXPORT std::vector< std::unique_ptr< ChemicalReaction > > RDKit::CDXMLFileToChemicalReactions ( const std::string &  fileName,
bool  sanitize = false,
bool  removeHs = false 
)

Parse a file in CDXML rxn format into a vector of ChemicalReactions.

References CDXMLFileToChemicalReactions().

Referenced by CDXMLFileToChemicalReactions().

◆ CDXMLFileToMols()

RDKIT_FILEPARSERS_EXPORT std::vector< std::unique_ptr< RWMol > > RDKit::CDXMLFileToMols ( const std::string &  filename,
bool  sanitize = true,
bool  removeHs = true 
)

construct molecules from a CDXML file Note that the CDXML format is large and complex, the RDKit doesn't support full functionality, just the base ones required for molecule and reaction parsing.

Parameters
fileName- cdxml fileName
sanitize- toggles sanitization and stereochemistry perception of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized correctness of the contents.

◆ CDXMLToChemicalReactions()

RDKIT_CHEMREACTIONS_EXPORT std::vector< std::unique_ptr< ChemicalReaction > > RDKit::CDXMLToChemicalReactions ( const std::string &  rxnBlock,
bool  sanitize = false,
bool  removeHs = false 
)

Parse text in CDXML rxn format into a vector of ChemicalReactions.

References CDXMLToChemicalReactions().

Referenced by CDXMLToChemicalReactions().

◆ CDXMLToMols()

RDKIT_FILEPARSERS_EXPORT std::vector< std::unique_ptr< RWMol > > RDKit::CDXMLToMols ( const std::string &  cdxml,
bool  sanitize = true,
bool  removeHs = true 
)

construct molecules from a CDXML file Note that the CDXML format is large and complex, the RDKit doesn't support full functionality, just the base ones required for molecule and reaction parsing.

Parameters
cdxml- string containing the mol block
sanitize- toggles sanitization and stereochemistry perception of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized correctness of the contents.

◆ checkAtomCharge()

RDKIT_FMCS_EXPORT bool RDKit::checkAtomCharge ( const MCSAtomCompareParameters p,
const ROMol mol1,
unsigned int  atom1,
const ROMol mol2,
unsigned int  atom2 
)

◆ checkAtomChirality()

RDKIT_FMCS_EXPORT bool RDKit::checkAtomChirality ( const MCSAtomCompareParameters p,
const ROMol mol1,
unsigned int  atom1,
const ROMol mol2,
unsigned int  atom2 
)

◆ checkAtomDistance()

RDKIT_FMCS_EXPORT bool RDKit::checkAtomDistance ( const MCSAtomCompareParameters p,
const ROMol mol1,
unsigned int  atom1,
const ROMol mol2,
unsigned int  atom2 
)

◆ checkAtomRingMatch()

RDKIT_FMCS_EXPORT bool RDKit::checkAtomRingMatch ( const MCSAtomCompareParameters p,
const ROMol mol1,
unsigned int  atom1,
const ROMol mol2,
unsigned int  atom2 
)

◆ checkBondRingMatch()

RDKIT_FMCS_EXPORT bool RDKit::checkBondRingMatch ( const MCSBondCompareParameters p,
const ROMol mol1,
unsigned int  bond1,
const ROMol mol2,
unsigned int  bond2 
)

◆ checkBondStereo()

RDKIT_FMCS_EXPORT bool RDKit::checkBondStereo ( const MCSBondCompareParameters p,
const ROMol mol1,
unsigned int  bond1,
const ROMol mol2,
unsigned int  bond2 
)

◆ checkForTimeout()

bool RDKit::checkForTimeout ( const std::chrono::steady_clock::time_point &  t0,
double  timeout,
bool  throwOnTimeout = true 
)
inline

Definition at line 123 of file RGroupDecomp.h.

References rdvalue_is().

◆ ChemicalReactionToMrvBlock()

RDKIT_MARVINPARSER_EXPORT std::string RDKit::ChemicalReactionToMrvBlock ( const ChemicalReaction rxn,
bool  prettyPrint = false 
)

◆ ChemicalReactionToMrvFile()

RDKIT_MARVINPARSER_EXPORT void RDKit::ChemicalReactionToMrvFile ( const ChemicalReaction rxn,
const std::string &  fName,
bool  prettyPrint = false 
)

◆ ChemicalReactionToRxnBlock()

RDKIT_CHEMREACTIONS_EXPORT std::string RDKit::ChemicalReactionToRxnBlock ( const ChemicalReaction rxn,
bool  separateAgents = false,
bool  forceV3000 = false 
)

returns an rxn block for a reaction

Parameters
rxnchemical reaction
separateAgentsflag to decide if agents are put in a separate block, otherwise they are included in the reactants block (default)
forceV3000flag to cause the V3000 format to be used instead of V2000

◆ ChemicalReactionToRxnMol()

RDKIT_CHEMREACTIONS_EXPORT ROMol * RDKit::ChemicalReactionToRxnMol ( const ChemicalReaction rxn)

returns a ROMol with RXN roles used to describe the reaction

◆ ChemicalReactionToRxnSmarts()

RDKIT_CHEMREACTIONS_EXPORT std::string RDKit::ChemicalReactionToRxnSmarts ( const ChemicalReaction rxn)

returns the reaction SMARTS for a reaction

◆ ChemicalReactionToRxnSmiles()

RDKIT_CHEMREACTIONS_EXPORT std::string RDKit::ChemicalReactionToRxnSmiles ( const ChemicalReaction rxn,
bool  canonical = true 
)

returns the reaction SMILES for a reaction

◆ ChemicalReactionToV3KRxnBlock()

RDKIT_CHEMREACTIONS_EXPORT std::string RDKit::ChemicalReactionToV3KRxnBlock ( const ChemicalReaction rxn,
bool  separateAgents = false 
)

returns an V3000 rxn block for a reaction

Parameters
rxnchemical reaction
separateAgentsflag to decide if agents are put in a separate block, otherwise they are included in the reactants block (default)

◆ chiralAtomCompat()

RDKIT_SUBSTRUCTMATCH_EXPORT bool RDKit::chiralAtomCompat ( const Atom a1,
const Atom a2 
)

◆ clearInputLabels()

void RDKit::clearInputLabels ( Atom atom)

Remove the user labels from the atom.

◆ clearMolBlockWedgingInfo()

RDKIT_FILEPARSERS_EXPORT void RDKit::clearMolBlockWedgingInfo ( ROMol mol)

◆ ClearSingleBondDirFlags()

RDKIT_FILEPARSERS_EXPORT void RDKit::ClearSingleBondDirFlags ( ROMol mol)

◆ clearVarianceData()

void RDKit::clearVarianceData ( FingerprintVarianceScoreData fingerprintVarianceScoreData)

◆ combineMols()

RDKIT_CHEMTRANSFORMS_EXPORT ROMol * RDKit::combineMols ( const ROMol mol1,
const ROMol mol2,
RDGeom::Point3D  offset = RDGeom::Point3D(0, 0, 0) 
)

Combined two molecules to create a new one.

Parameters
mol1- the first ROMol to be combined
mol2- the second ROMol to be combined
offset- a constant offset to be added to every atom position in mol2
Returns
a new ROMol with the two molecules combined. The new molecule has not been sanitized. The client is responsible for deleting this molecule.

◆ computeGasteigerCharges() [1/3]

RDKIT_PARTIALCHARGES_EXPORT void RDKit::computeGasteigerCharges ( const ROMol mol,
int  nIter = 12,
bool  throwOnParamFailure = false 
)

◆ computeGasteigerCharges() [2/3]

RDKIT_PARTIALCHARGES_EXPORT void RDKit::computeGasteigerCharges ( const ROMol mol,
std::vector< double > &  charges,
int  nIter = 12,
bool  throwOnParamFailure = false 
)

◆ computeGasteigerCharges() [3/3]

RDKIT_PARTIALCHARGES_EXPORT void RDKit::computeGasteigerCharges ( const ROMol mol,
int  nIter = 12,
bool  throwOnParamFailure = false 
)

◆ computeIntVectPrimesProduct()

RDKIT_RDGENERAL_EXPORT double RDKit::computeIntVectPrimesProduct ( const INT_VECT ring)

compute the product of the set of primes corresponding to the values in an INT_VECT

◆ computeL1Norm()

◆ computeNumProducts()

RDKIT_CHEMREACTIONS_EXPORT boost::uint64_t RDKit::computeNumProducts ( const EnumerationTypes::RGROUPS sizes)

computeNumProducts Returns the number of possible product combination from The given numbers of building blocks for each rgroup or EnumerationStrategyBase::EnumerationOverflow if the number will not fit into the machines integer type. n.b. An overflow simply means there are a lot of products not that they cannot be enumerated

References computeNumProducts().

Referenced by computeNumProducts(), RDKit::EnumerationStrategyBase::initialize(), and RDKit::EnumerationStrategyBase::internalInitialize().

◆ ConnectTheDots()

RDKIT_FILEPARSERS_EXPORT void RDKit::ConnectTheDots ( RWMol mol,
unsigned int  flags = 0 
)

◆ convertComplexNameToQuery()

RDKIT_GRAPHMOL_EXPORT void RDKit::convertComplexNameToQuery ( Atom query,
std::string_view  symb 
)

◆ copy_rdvalue()

◆ copyVarianceData()

void RDKit::copyVarianceData ( const FingerprintVarianceScoreData fromData,
FingerprintVarianceScoreData toData 
)

◆ countSwapsToInterconvert()

template<class T >
unsigned int RDKit::countSwapsToInterconvert ( const T &  ref,
probe 
)

Definition at line 54 of file utils.h.

References CHECK_INVARIANT, PRECONDITION, and rdvalue_is().

◆ deleteSubstructs()

RDKIT_CHEMTRANSFORMS_EXPORT ROMol * RDKit::deleteSubstructs ( const ROMol mol,
const ROMol query,
bool  onlyFrags = false,
bool  useChirality = false 
)

Returns a copy of an ROMol with the atoms and bonds that match a pattern removed.

Parameters
molthe ROMol of interest
querythe query ROMol
onlyFragsif this is set, atoms will only be removed if the entire fragment in which they are found is matched by the query.
useChirality- if set, match the coreQuery using chirality
Returns
a copy of mol with the matching atoms and bonds (if any) removed.

◆ describeQuery() [1/2]

std::string RDKit::describeQuery ( const Atom atom)
inline

◆ describeQuery() [2/2]

std::string RDKit::describeQuery ( const Bond bond)
inline

◆ DetectAtomStereoChemistry()

RDKIT_FILEPARSERS_EXPORT void RDKit::DetectAtomStereoChemistry ( RWMol mol,
const Conformer conf 
)

deprecated, please use MolOps::assignChiralTypesFromBondDirs instead

◆ DetectBondStereoChemistry()

RDKIT_FILEPARSERS_EXPORT void RDKit::DetectBondStereoChemistry ( ROMol mol,
const Conformer conf 
)

deprecated, please use MolOps::detectBondStereoChemistry instead

◆ determineBondOrders()

RDKIT_DETERMINEBONDS_EXPORT void RDKit::determineBondOrders ( RWMol mol,
int  charge = 0,
bool  allowChargedFragments = true,
bool  embedChiral = true,
bool  useAtomMap = false 
)

This is based on xyz2mol: https://github.com/jensengroup/xyz2mol

Parameters
molis the molecule of interest; it must have single bonds corresponding to the atomic connectivity
charge(optional) the charge of the molecule; it must be provided if charge is non-zero
allowChargedFragments(optional) if this is true, formal charges will be placed on atoms according to their valency; otherwise, radical electrons will be placed on the atoms
embedChiral(optional) if this is true, chirality information will be embedded into the molecule; the function calls sanitizeMol() when this is true
useAtomMap(optional) if this is true, an atom map will be created for the molecule

◆ determineBonds()

RDKIT_DETERMINEBONDS_EXPORT void RDKit::determineBonds ( RWMol mol,
bool  useHueckel = false,
int  charge = 0,
double  covFactor = 1.3,
bool  allowChargedFragments = true,
bool  embedChiral = true,
bool  useAtomMap = false,
bool  useVdw = false 
)

This is based on xyz2mol: https://github.com/jensengroup/xyz2mol

Parameters
molis the molecule of interest; it must have a 3D conformer
useHueckel(optional) if this is true, extended Hueckel theory will be used to determine connectivity rather than the van der Waals or connect-the-dots method
charge(optional) the charge of the molecule; it must be provided if charge is non-zero
covFactor(optional) the factor with which to multiply each covalent radius if the van der Waals method is used
allowChargedFragments(optional) if this is true, formal charges will be placed on atoms according to their valency; otherwise, radical electrons will be placed on the atoms
embedChiral(optional) if this is true, chirality information will be embedded into the molecule; the function calls sanitizeMol() when this is true
useAtomMap(optional) if this is true, an atom map will be created for the molecule
useVdw(optional) if this is false, the connect-the-dots method will be used instead of the van der Waals method

◆ DetermineBondWedgeState() [1/2]

RDKIT_FILEPARSERS_EXPORT Bond::BondDir RDKit::DetermineBondWedgeState ( const Bond bond,
const INT_MAP_INT wedgeBonds,
const Conformer conf 
)

◆ DetermineBondWedgeState() [2/2]

RDKIT_FILEPARSERS_EXPORT Bond::BondDir RDKit::DetermineBondWedgeState ( const Bond bond,
unsigned int  fromAtomIdx,
const Conformer conf 
)

◆ determineConnectivity()

RDKIT_DETERMINEBONDS_EXPORT void RDKit::determineConnectivity ( RWMol mol,
bool  useHueckel = false,
int  charge = 0,
double  covFactor = 1.3,
bool  useVdw = false 
)

This is based on xyz2mol: https://github.com/jensengroup/xyz2mol

Parameters
molis the molecule of interest; it must have a 3D conformer
useHueckel(optional) if this is true, extended Hueckel theory will be used to determine connectivity rather than the van der Waals or connect-the-dots method
charge(optional) the charge of the molecule; it must be provided if the Hueckel method is used and charge is non-zero
covFactor(optional) the factor with which to multiply each covalent radius if the van der Waals method is used
useVdw(optional) if this is false, the connect-the-dots method will be used instead of the van der Waals method

◆ DiceSimilarity()

template<typename IndexType >
double RDKit::DiceSimilarity ( const SparseIntVect< IndexType > &  v1,
const SparseIntVect< IndexType > &  v2,
bool  returnDistance = false,
double  bounds = 0.0 
)

Definition at line 492 of file SparseIntVect.h.

References rdvalue_is().

◆ Dict::getVal< std::string >()

template<>
std::string RDKit::Dict::getVal< std::string > ( const std::string &  what) const
inline

Definition at line 346 of file Dict.h.

References rdvalue_is().

◆ DifferenceFingerprintChemReaction()

RDKIT_CHEMREACTIONS_EXPORT SparseIntVect< std::uint32_t > * RDKit::DifferenceFingerprintChemReaction ( const ChemicalReaction rxn,
const ReactionFingerprintParams params = DefaultDifferenceFPParams 
)

Generates a difference fingerprint for a reaction to use in similarity search of reactions

A difference fingerprint is generated as a SparseIntVect to use for similarity search of reactions. By default the fingerprint is generated as 2048 bit hashed fingerprint subtracting AtompairFP of the reactants from the products' AtompairFP and tentatively the agent AtompairFP is added

Parameters
rxnthe reaction to be fingerprinted
paramsspecific settings to manipulate fingerprint generation
Returns
the reaction fingerprint, as an SparseIntVec

Notes:

  • the caller is responsible for deleteing the result

◆ EndianSwapBytes() [1/4]

template<EEndian from, EEndian to>
char RDKit::EndianSwapBytes ( char  value)
inline

Definition at line 92 of file StreamOps.h.

◆ EndianSwapBytes() [2/4]

template<EEndian from, EEndian to>
signed char RDKit::EndianSwapBytes ( signed char  value)
inline

Definition at line 100 of file StreamOps.h.

◆ EndianSwapBytes() [3/4]

template<EEndian from, EEndian to, class T >
T RDKit::EndianSwapBytes ( value)
inline

Definition at line 73 of file StreamOps.h.

References rdvalue_is().

◆ EndianSwapBytes() [4/4]

template<EEndian from, EEndian to>
unsigned char RDKit::EndianSwapBytes ( unsigned char  value)
inline

Definition at line 96 of file StreamOps.h.

◆ EnumerateLibraryCanSerialize()

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::EnumerateLibraryCanSerialize ( )

◆ eraseUniquePtr()

template<typename T >
void RDKit::eraseUniquePtr ( std::vector< std ::unique_ptr< T > > &  vector,
T *  itemToErase 
)

Definition at line 236 of file MarvinDefs.h.

References rdvalue_is().

◆ FASTAToMol() [1/4]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::FASTAToMol ( const char seq,
bool  sanitize,
bool  lowerD 
)
Parameters
seq- the string to be processed
sanitize- toggles sanitization and stereochemistry perception of the molecule
lowerD- if set, lower case letters will be parsed as the d form of the corresponding amino acid

◆ FASTAToMol() [2/4]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::FASTAToMol ( const char seq,
bool  sanitize = true,
int  flavor = 0 
)
Parameters
seq- the string to be processed
sanitize- toggles sanitization and stereochemistry perception of the molecule
flavor- 0 Protein, L amino acids (default) 1 Protein, D amino acids 2 RNA, no cap 3 RNA, 5' cap 4 RNA, 3' cap 5 RNA, both caps 6 DNA, no cap 7 DNA, 5' cap 8 DNA, 3' cap 9 DNA, both caps

◆ FASTAToMol() [3/4]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::FASTAToMol ( const std::string &  seq,
bool  sanitize,
bool  lowerD 
)

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

◆ FASTAToMol() [4/4]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::FASTAToMol ( const std::string &  seq,
bool  sanitize = true,
int  flavor = 0 
)

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

◆ feq()

RDKIT_RDGENERAL_EXPORT bool RDKit::feq ( double  v1,
double  v2,
double  tol = 1e-4 
)

floating point comparison with a tolerance

◆ FilterCatalogCanSerialize()

RDKIT_FILTERCATALOG_EXPORT bool RDKit::FilterCatalogCanSerialize ( )

◆ FinalChiralityCheckFunction()

bool RDKit::FinalChiralityCheckFunction ( const std::uint32_t  c1[],
const std::uint32_t  c2[],
const ROMol mol1,
const FMCS::Graph query,
const ROMol mol2,
const FMCS::Graph target,
const MCSParameters p 
)
inline

◆ FinalMatchCheckFunction()

bool RDKit::FinalMatchCheckFunction ( const std::uint32_t  c1[],
const std::uint32_t  c2[],
const ROMol mol1,
const FMCS::Graph query,
const ROMol mol2,
const FMCS::Graph target,
const MCSParameters p 
)

◆ findAllPathsOfLengthN()

RDKIT_SUBGRAPHS_EXPORT PATH_LIST RDKit::findAllPathsOfLengthN ( const ROMol mol,
unsigned int  targetLen,
bool  useBonds = true,
bool  useHs = false,
int  rootedAtAtom = -1,
bool  onlyShortestPaths = false 
)

find all paths of a particular size

Parameters
mol- the molecule to be considered
targetLen- the length of the paths to be returned
useBonds- if set, the path indices will be bond indices, not atom indices
useHs- if set, hydrogens in the graph will be considered eligible to be in paths. NOTE: this will not add Hs to the graph.
rootedAtAtom- if non-negative, only subgraphs that start at this atom will be returned.
onlyShortestPaths- if set then only paths which are <= the shortest path between the begin and end atoms will be included in the results

The result is a list of paths (i.e. list of list of bond indices)

◆ findAllPathsOfLengthsMtoN()

RDKIT_SUBGRAPHS_EXPORT INT_PATH_LIST_MAP RDKit::findAllPathsOfLengthsMtoN ( const ROMol mol,
unsigned int  lowerLen,
unsigned int  upperLen,
bool  useBonds = true,
bool  useHs = false,
int  rootedAtAtom = -1,
bool  onlyShortestPaths = false 
)

◆ findAllSubgraphsOfLengthN()

RDKIT_SUBGRAPHS_EXPORT PATH_LIST RDKit::findAllSubgraphsOfLengthN ( const ROMol mol,
unsigned int  targetLen,
bool  useHs = false,
int  rootedAtAtom = -1 
)

find all bond subgraphs of a particular size

Parameters
mol- the molecule to be considered
targetLen- the length of the subgraphs to be returned
useHs- if set, hydrogens in the graph will be considered eligible to be in paths. NOTE: this will not add Hs to the graph.
rootedAtAtom- if non-negative, only subgraphs that start at this atom will be returned.

The result is a list of paths (i.e. list of list of bond indices)

◆ findAllSubgraphsOfLengthsMtoN()

RDKIT_SUBGRAPHS_EXPORT INT_PATH_LIST_MAP RDKit::findAllSubgraphsOfLengthsMtoN ( const ROMol mol,
unsigned int  lowerLen,
unsigned int  upperLen,
bool  useHs = false,
int  rootedAtAtom = -1 
)

find all bond subgraphs in a range of sizes

Parameters
mol- the molecule to be considered
lowerLen- the minimum subgraph size to find
upperLen- the maximum subgraph size to find
useHs- if set, hydrogens in the graph will be considered eligible to be in paths. NOTE: this will not add Hs to the graph.
rootedAtAtom- if non-negative, only subgraphs that start at this atom will be returned.

The result is a map from subgraph size -> list of paths (i.e. list of list of bond indices)

◆ findAtomEnvironmentOfRadiusN()

RDKIT_SUBGRAPHS_EXPORT PATH_TYPE RDKit::findAtomEnvironmentOfRadiusN ( const ROMol mol,
unsigned int  radius,
unsigned int  rootedAtAtom,
bool  useHs = false,
bool  enforceSize = true,
std::unordered_map< unsigned int, unsigned int > *  atomMap = nullptr 
)

Find bond subgraphs of a particular radius around an atom. Return empty result if there is no bond at the requested radius.

Parameters
mol- the molecule to be considered
radius- the radius of the subgraphs to be considered
rootedAtAtom- the atom to consider
useHs- if set, hydrogens in the graph will be considered eligible to be in paths. NOTE: this will not add Hs to the graph.
enforceSize- If false, all the bonds within the requested radius (<= radius) is collected. Otherwise, at least one bond located at the requested radius must be found and added.
atomMap- Optional: If provided, it will measure the minimum distance of the atom from the rooted atom (start with 0 from the rooted atom). The result is a pair of the atom ID and the distance. The result is a path (a vector of bond indices)

◆ findFuncGroupsOnMol()

RDKIT_FRAGCATALOG_EXPORT MatchVectType RDKit::findFuncGroupsOnMol ( const ROMol mol,
const FragCatParams params,
INT_VECT fgBonds 
)

◆ findMCS() [1/3]

RDKIT_FMCS_EXPORT MCSResult RDKit::findMCS ( const std::vector< ROMOL_SPTR > &  mols,
bool  maximizeBonds,
double  threshold,
unsigned int  timeout,
bool  verbose,
bool  matchValences,
bool  ringMatchesRingOnly,
bool  completeRingsOnly,
bool  matchChiralTag,
AtomComparator  atomComp,
BondComparator  bondComp,
RingComparator  ringComp 
)

◆ findMCS() [2/3]

RDKIT_FMCS_EXPORT MCSResult RDKit::findMCS ( const std::vector< ROMOL_SPTR > &  mols,
bool  maximizeBonds,
double  threshold = 1.0,
unsigned int  timeout = 3600,
bool  verbose = false,
bool  matchValences = false,
bool  ringMatchesRingOnly = false,
bool  completeRingsOnly = false,
bool  matchChiralTag = false,
AtomComparator  atomComp = AtomCompareElements,
BondComparator  bondComp = BondCompareOrder 
)

◆ findMCS() [3/3]

RDKIT_FMCS_EXPORT MCSResult RDKit::findMCS ( const std::vector< ROMOL_SPTR > &  mols,
const MCSParameters params = nullptr 
)

◆ findMCS_P()

RDKIT_FMCS_EXPORT MCSResult RDKit::findMCS_P ( const std::vector< ROMOL_SPTR > &  mols,
const char params_json 
)

◆ findUniquePtr()

template<typename T >
std::vector< std::unique_ptr< T > >::iterator RDKit::findUniquePtr ( std::vector< std ::unique_ptr< T > > &  vector,
T *  itemToFind 
)

Definition at line 221 of file MarvinDefs.h.

References rdvalue_is().

◆ findUniqueSubgraphsOfLengthN()

RDKIT_SUBGRAPHS_EXPORT PATH_LIST RDKit::findUniqueSubgraphsOfLengthN ( const ROMol mol,
unsigned int  targetLen,
bool  useHs = false,
bool  useBO = true,
int  rootedAtAtom = -1 
)

find unique bond subgraphs of a particular size

Parameters
mol- the molecule to be considered
targetLen- the length of the subgraphs to be returned
useHs- if set, hydrogens in the graph will be considered eligible to be in paths. NOTE: this will not add Hs to the graph.
useBO- if set, bond orders will be considered when uniquifying the paths
rootedAtAtom- if non-negative, only subgraphs that start at this atom will be returned.

The result is a list of paths (i.e. list of list of bond indices)

◆ fingerprintVarianceScore()

RDKIT_RGROUPDECOMPOSITION_EXPORT double RDKit::fingerprintVarianceScore ( const std::vector< size_t > &  permutation,
const std::vector< std::vector< RGroupMatch > > &  matches,
const std::set< int > &  labels,
FingerprintVarianceScoreData fingerprintVarianceScoreData = nullptr 
)

◆ forwardStereoGroupIds()

RDKIT_GRAPHMOL_EXPORT void RDKit::forwardStereoGroupIds ( ROMol mol)

Copy StereoGroup "read" IDs to "write" IDs so that they will be preserved when the mol is exported.

◆ from_rdany() [1/2]

template<class T >
boost::enable_if< boost::is_arithmetic< T >, T >::type RDKit::from_rdany ( const RDAny arg)

Definition at line 190 of file RDAny.h.

References rdvalue_is(), and RDKit::RDTypeTag::StringTag.

◆ from_rdany() [2/2]

template<class T >
boost::disable_if< boost::is_arithmetic< T >, T >::type RDKit::from_rdany ( const RDAny arg)

Definition at line 211 of file RDAny.h.

References rdvalue_is().

◆ from_rdvalue() [1/2]

template<class T >
boost::enable_if< boost::is_arithmetic< T >, T >::type RDKit::from_rdvalue ( RDValue_cast_t  arg)

◆ from_rdvalue() [2/2]

template<class T >
boost::disable_if< boost::is_arithmetic< T >, T >::type RDKit::from_rdvalue ( RDValue_cast_t  arg)

Definition at line 286 of file RDValue.h.

References rdvalue_is().

◆ getAtomAlias()

RDKIT_GRAPHMOL_EXPORT std::string RDKit::getAtomAlias ( const Atom atom)

◆ getAtomListQueryVals()

RDKIT_GRAPHMOL_EXPORT void RDKit::getAtomListQueryVals ( const Atom::QUERYATOM_QUERY q,
std::vector< int > &  vals 
)

◆ getAtomRLabel()

RDKIT_GRAPHMOL_EXPORT int RDKit::getAtomRLabel ( const Atom atm)

◆ getAtomTypeAtomicNum()

static int RDKit::getAtomTypeAtomicNum ( int  val)
inlinestatic

Definition at line 145 of file QueryOps.h.

◆ getAtomTypeIsAromatic()

static bool RDKit::getAtomTypeIsAromatic ( int  val)
inlinestatic

Definition at line 144 of file QueryOps.h.

◆ getAtomValue()

RDKIT_GRAPHMOL_EXPORT std::string RDKit::getAtomValue ( const Atom atom)

◆ getCleanNumber()

template<typename T >
bool RDKit::getCleanNumber ( std::string  strToParse,
T &  outInt 
)

◆ getCountFP()

RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint32_t > * RDKit::getCountFP ( const ROMol mol,
FPType  fPType 
)

◆ getCountFPBulk()

RDKIT_FINGERPRINTS_EXPORT std::vector< SparseIntVect< std::uint32_t > * > * RDKit::getCountFPBulk ( const std::vector< const ROMol * >  molVector,
FPType  fPType 
)

◆ getDiscreteDistMat()

DiscreteDistMat * RDKit::getDiscreteDistMat ( )
extern

◆ getDoubleRandomSource()

RDKIT_RDGENERAL_EXPORT double_source_type & RDKit::getDoubleRandomSource ( )

return a reference to the global (Boost) random source

◆ getEndIterator()

RDKIT_CHEMREACTIONS_EXPORT MOL_SPTR_VECT::const_iterator RDKit::getEndIterator ( const ChemicalReaction rxn,
ReactionMoleculeType  t 
)

◆ GetFilterData()

const FilterData_t * RDKit::GetFilterData ( FilterCatalogParams::FilterCatalogs  catalog)

◆ GetFilterProperties()

const FilterProperty_t * RDKit::GetFilterProperties ( FilterCatalogParams::FilterCatalogs  catalog)

◆ GetFlattenedFunctionalGroupHierarchy()

RDKIT_FILTERCATALOG_EXPORT const std::map< std::string, ROMOL_SPTR > & RDKit::GetFlattenedFunctionalGroupHierarchy ( bool  normalized = false)

Return the flattened functional group hierarchy as a string->ROMOL_SPTR map The label is the name of the functional group in the hiearchy e.g. Halogen.Bromine.Aliphatic

◆ getFP()

RDKIT_FINGERPRINTS_EXPORT ExplicitBitVect * RDKit::getFP ( const ROMol mol,
FPType  fPType 
)

◆ getFPBulk()

RDKIT_FINGERPRINTS_EXPORT std::vector< ExplicitBitVect * > * RDKit::getFPBulk ( const std::vector< const ROMol * >  molVector,
FPType  fPType 
)

◆ GetFunctionalGroupHierarchy()

RDKIT_FILTERCATALOG_EXPORT const FilterCatalog & RDKit::GetFunctionalGroupHierarchy ( )

Return the functional group hierarchy as a FilterCatalog.

◆ getLine() [1/2]

std::string RDKit::getLine ( std::istream &  inStream)
inline

grabs the next line from an instream and returns it.

Definition at line 347 of file StreamOps.h.

References getLine(), and rdvalue_is().

◆ getLine() [2/2]

std::string RDKit::getLine ( std::istream *  inStream)
inline

grabs the next line from an instream and returns it.

Definition at line 338 of file StreamOps.h.

References rdvalue_is().

Referenced by getLine().

◆ getMostSubstitutedCoreMatch()

RDKIT_SUBSTRUCTMATCH_EXPORT const MatchVectType & RDKit::getMostSubstitutedCoreMatch ( const ROMol mol,
const ROMol core,
const std::vector< MatchVectType > &  matches 
)

This postprocesses the passed substruct matches and returns the match that has the largest number of non-hydrogen atoms in correspondence of terminal dummy atoms

◆ GetNumEntries()

unsigned int RDKit::GetNumEntries ( FilterCatalogParams::FilterCatalogs  catalog)

◆ GetNumPropertyEntries()

unsigned int RDKit::GetNumPropertyEntries ( FilterCatalogParams::FilterCatalogs  catalog)

◆ getNumThreadsToUse()

unsigned int RDKit::getNumThreadsToUse ( int  target)
inline

◆ getRandomGenerator()

RDKIT_RDGENERAL_EXPORT rng_type & RDKit::getRandomGenerator ( int  seed = -1)

Optionally seed and return a reference to the global (Boost) random generator

◆ getRandomVal()

RDKIT_RDGENERAL_EXPORT double RDKit::getRandomVal ( int  seed = -1)

Return a random double value between 0.0 and 1.0 Optionally seed the random number generator

◆ getReactantsFromRGroups()

RDKIT_CHEMREACTIONS_EXPORT MOL_SPTR_VECT RDKit::getReactantsFromRGroups ( const std::vector< MOL_SPTR_VECT > &  bbs,
const EnumerationTypes::RGROUPS rgroups 
)

getReactantsFromRGroups Helper function for enumeration, bbs are stored in a std::vector< std::vector<boost:shared_ptr<ROMol> >

References getReactantsFromRGroups().

Referenced by getReactantsFromRGroups().

◆ getReactingAtoms()

RDKIT_CHEMREACTIONS_EXPORT VECT_INT_VECT RDKit::getReactingAtoms ( const ChemicalReaction rxn,
bool  mappedAtomsOnly = false 
)

returns indices of the atoms in each reactant that are changed in the reaction

Parameters
rxnthe reaction we are interested in
mappedAtomsOnlyif set, atoms that are not mapped will not be included in the list of changed atoms (otherwise they are automatically included)

How are changed atoms recognized? 1) Atoms whose degree changes 2) Atoms whose bonding pattern changes 3) unmapped atoms (unless the mappedAtomsOnly flag is set) 4) Atoms connected to unmapped atoms 5) Atoms whose atomic number changes (unless the corresponding product atom is a dummy) 6) Atoms with more than one atomic number query (unless the corresponding product atom is a dummy)

Note that the atomic number of a query atom depends on how it's constructed. When coming from SMARTS: if the first query is an atomic label/number that sets the atomic number, otherwise it's zero. For example [O;] is atomic number 8 while [;O] is atomic number 0. When coming from RXN: the atomic number of the atom in the rxn file sets the value.

References getReactingAtoms().

Referenced by getReactingAtoms().

◆ getRlabels()

std::map< int, Atom * > RDKit::getRlabels ( const RWMol mol)

Get the RLabels,atom mapping for the current molecule.

◆ getSizesFromBBs()

template<class T >
EnumerationTypes::RGROUPS RDKit::getSizesFromBBs ( const std::vector< std::vector< T > > &  bbs)

Return the number of elements per input vector.

Parameters
bbsvector<vector<T> >
Returns
vector<unint64_t> number of elements in each vector

Definition at line 75 of file EnumerationStrategyBase.h.

Referenced by RDKit::EnumerationStrategyBase::initialize().

◆ getSizesFromReactants()

RDKIT_CHEMREACTIONS_EXPORT EnumerationTypes::RGROUPS RDKit::getSizesFromReactants ( const std::vector< MOL_SPTR_VECT > &  bbs)

getSizesFromReactants Helper function for enumeration, bbs are stored in a std::vector< std::vector<boost:shared_ptr<ROMol> >

References getSizesFromReactants().

Referenced by getSizesFromReactants().

◆ getSparseCountFP()

RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint64_t > * RDKit::getSparseCountFP ( const ROMol mol,
FPType  fPType 
)

◆ getSparseCountFPBulk()

RDKIT_FINGERPRINTS_EXPORT std::vector< SparseIntVect< std::uint64_t > * > * RDKit::getSparseCountFPBulk ( const std::vector< const ROMol * >  molVector,
FPType  fPType 
)

◆ getSparseFP()

RDKIT_FINGERPRINTS_EXPORT SparseBitVect * RDKit::getSparseFP ( const ROMol mol,
FPType  fPType 
)

◆ getSparseFPBulk()

RDKIT_FINGERPRINTS_EXPORT std::vector< SparseBitVect * > * RDKit::getSparseFPBulk ( const std::vector< const ROMol * >  molVector,
FPType  fPType 
)

◆ getStartIterator()

RDKIT_CHEMREACTIONS_EXPORT MOL_SPTR_VECT::const_iterator RDKit::getStartIterator ( const ChemicalReaction rxn,
ReactionMoleculeType  t 
)

◆ getSubstanceGroups() [1/2]

RDKIT_GRAPHMOL_EXPORT const std::vector< SubstanceGroup > & RDKit::getSubstanceGroups ( const ROMol mol)

◆ getSubstanceGroups() [2/2]

RDKIT_GRAPHMOL_EXPORT std::vector< SubstanceGroup > & RDKit::getSubstanceGroups ( ROMol mol)

◆ getSupplementalSmilesLabel()

RDKIT_GRAPHMOL_EXPORT std::string RDKit::getSupplementalSmilesLabel ( const Atom atom)

◆ getTwiceBondType()

RDKIT_GRAPHMOL_EXPORT uint8_t RDKit::getTwiceBondType ( const RDKit::Bond b)
extern

returns twice the bondType (e.g. SINGLE->2, AROMATIC->3, etc.)

◆ getUnfoldedRDKFingerprintMol()

RDKIT_FINGERPRINTS_EXPORT SparseIntVect< boost::uint64_t > * RDKit::getUnfoldedRDKFingerprintMol ( const ROMol mol,
unsigned int  minPath = 1,
unsigned int  maxPath = 7,
bool  useHs = true,
bool  branchedPaths = true,
bool  useBondOrder = true,
std::vector< std::uint32_t > *  atomInvariants = nullptr,
const std::vector< std::uint32_t > *  fromAtoms = nullptr,
std::vector< std::vector< boost::uint64_t > > *  atomBits = nullptr,
std::map< boost::uint64_t, std::vector< std::vector< int > > > *  bitInfo = nullptr 
)

◆ hanoi()

template<typename CompareFunc >
bool RDKit::hanoi ( int base,
int  nel,
int temp,
int count,
int changed,
CompareFunc  compar 
)

changed ||

changed ||

Definition at line 27 of file hanoiSort.h.

References hanoi(), and rdvalue_is().

Referenced by hanoi(), and hanoisort().

◆ hanoisort()

template<typename CompareFunc >
void RDKit::hanoisort ( int base,
int  nel,
int count,
int changed,
CompareFunc  compar 
)

Definition at line 151 of file hanoiSort.h.

References hanoi(), and rdvalue_is().

Referenced by RDKit::Canon::RefinePartitions().

◆ hasAgentTemplateSubstructMatch()

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::hasAgentTemplateSubstructMatch ( const ChemicalReaction rxn,
const ChemicalReaction query_rxn 
)

◆ hasDummy()

bool RDKit::hasDummy ( const RWMol core)

Returns true if the core has a dummy atom.

◆ hasNonZeroZCoords()

bool RDKit::hasNonZeroZCoords ( const Conformer conf)
inline

Returns true if any of the z coords are non zero, false otherwise.

Parameters
confConformer object to analyze

Definition at line 173 of file Conformer.h.

References RDKit::Conformer::getPositions(), and hasNonZeroZCoords().

Referenced by hasNonZeroZCoords().

◆ hasProductTemplateSubstructMatch()

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::hasProductTemplateSubstructMatch ( const ChemicalReaction rxn,
const ChemicalReaction query_rxn 
)

◆ hasReactantTemplateSubstructMatch()

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::hasReactantTemplateSubstructMatch ( const ChemicalReaction rxn,
const ChemicalReaction query_rxn 
)

◆ hasReactionAtomMapping()

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::hasReactionAtomMapping ( const ChemicalReaction rxn)

◆ hasReactionSubstructMatch()

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::hasReactionSubstructMatch ( const ChemicalReaction rxn,
const ChemicalReaction query_rxn,
bool  includeAgents = false 
)

◆ havePairOfCompatibleRings()

RDKIT_FMCS_EXPORT bool RDKit::havePairOfCompatibleRings ( const MCSBondCompareParameters p,
const ROMol mol1,
unsigned int  bond1,
const ROMol mol2,
unsigned int  bond2 
)

◆ HELMToMol() [1/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::HELMToMol ( const char helm,
bool  sanitize = true 
)
Parameters
seq- the string to be processed
sanitize- toggles sanitization and stereochemistry perception of the molecule

◆ HELMToMol() [2/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::HELMToMol ( const std::string &  helm,
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.

◆ Intersect()

RDKIT_RDGENERAL_EXPORT void RDKit::Intersect ( const INT_VECT r1,
const INT_VECT r2,
INT_VECT res 
)

calculate the intersection of two INT_VECTs and put the results in a third vector

◆ invertMolBlockWedgingInfo()

RDKIT_FILEPARSERS_EXPORT void RDKit::invertMolBlockWedgingInfo ( ROMol mol)

◆ isAnyAtomWithMultipleNeighborsOrNotUserRLabel()

bool RDKit::isAnyAtomWithMultipleNeighborsOrNotUserRLabel ( const Atom atom)
inline

Returns true if the core atom is either a dummy atom with multiple connections or a dummy atom with a single connection that has no user defined rgroup label

Definition at line 72 of file RGroupUtils.h.

References RDKit::Atom::getAtomicNum(), and isAtomWithMultipleNeighborsOrNotDummyRGroupAttachment().

◆ isAromaticAtom()

RDKIT_GRAPHMOL_EXPORT bool RDKit::isAromaticAtom ( const Atom atom)

returns true if the atom is aromatic or has an aromatic bond

◆ isAtomAromatic()

RDKIT_GRAPHMOL_EXPORT bool RDKit::isAtomAromatic ( const Atom a)

◆ isAtomDummy()

◆ isAtomListQuery()

RDKIT_GRAPHMOL_EXPORT bool RDKit::isAtomListQuery ( const Atom a)

◆ isAtomTerminalRGroupOrQueryHydrogen()

RDKIT_SUBSTRUCTMATCH_EXPORT bool RDKit::isAtomTerminalRGroupOrQueryHydrogen ( const Atom atom)

◆ isAtomWithMultipleNeighborsOrNotDummyRGroupAttachment()

bool RDKit::isAtomWithMultipleNeighborsOrNotDummyRGroupAttachment ( const Atom atom)

Returns true if the core atom is either an atom with multiple connections or an atom with a single connection that has no user defined rgroup label

Referenced by isAnyAtomWithMultipleNeighborsOrNotUserRLabel().

◆ IsBlacklistedPair()

RDKIT_FILEPARSERS_EXPORT bool RDKit::IsBlacklistedPair ( Atom beg_atom,
Atom end_atom 
)

◆ isComplexQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT bool RDKit::isComplexQuery ( const Atom a)

◆ isComplexQuery() [2/2]

RDKIT_GRAPHMOL_EXPORT bool RDKit::isComplexQuery ( const Bond b)

◆ isDummyRGroupAttachment()

bool RDKit::isDummyRGroupAttachment ( const Atom atom)

◆ isEarlyAtom()

RDKIT_GRAPHMOL_EXPORT bool RDKit::isEarlyAtom ( int  atomicNum)

returns true if the atom is to the left of C

◆ isMoleculeAgentOfReaction() [1/2]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::isMoleculeAgentOfReaction ( const ChemicalReaction rxn,
const ROMol mol 
)

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

References isMoleculeAgentOfReaction().

◆ isMoleculeAgentOfReaction() [2/2]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::isMoleculeAgentOfReaction ( const ChemicalReaction rxn,
const ROMol mol,
unsigned int which 
)

tests whether or not the molecule has a substructure match to any of the reaction's agents the which argument is used to return which of the agents the molecule matches. If there's no match, it is equal to the number of agents on return

References isMoleculeAgentOfReaction().

Referenced by isMoleculeAgentOfReaction(), and isMoleculeAgentOfReaction().

◆ isMoleculeProductOfReaction() [1/3]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::isMoleculeProductOfReaction ( const ChemicalReaction rxn,
const ROMol mol 
)

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

References isMoleculeProductOfReaction().

◆ isMoleculeProductOfReaction() [2/3]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::isMoleculeProductOfReaction ( const ChemicalReaction rxn,
const ROMol mol,
std::vector< unsigned int > &  which,
bool  stopAtFirstMatch = false 
)

tests whether or not the molecule has a substructure match to the reaction's products the which argument is used to return which of the products the molecule matches.

References isMoleculeProductOfReaction().

Referenced by isMoleculeProductOfReaction(), isMoleculeProductOfReaction(), and isMoleculeProductOfReaction().

◆ isMoleculeProductOfReaction() [3/3]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::isMoleculeProductOfReaction ( const ChemicalReaction rxn,
const ROMol mol,
unsigned int which 
)

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

References isMoleculeProductOfReaction().

◆ isMoleculeReactantOfReaction() [1/3]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::isMoleculeReactantOfReaction ( const ChemicalReaction rxn,
const ROMol mol 
)

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

References isMoleculeReactantOfReaction().

◆ isMoleculeReactantOfReaction() [2/3]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::isMoleculeReactantOfReaction ( const ChemicalReaction rxn,
const ROMol mol,
std::vector< unsigned int > &  which,
bool  stopAtFirstMatch = false 
)

tests whether or not the molecule has a substructure match to the reaction's reactants the which argument is used to return which of the reactants the molecule matches.

References isMoleculeReactantOfReaction().

Referenced by isMoleculeReactantOfReaction(), isMoleculeReactantOfReaction(), and isMoleculeReactantOfReaction().

◆ isMoleculeReactantOfReaction() [3/3]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::isMoleculeReactantOfReaction ( const ChemicalReaction rxn,
const ROMol mol,
unsigned int which 
)

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

References isMoleculeReactantOfReaction().

◆ isReactionTemplateMoleculeAgent()

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::isReactionTemplateMoleculeAgent ( const ROMol mol,
double  agentThreshold 
)

◆ isSerializable()

bool RDKit::isSerializable ( const Dict::Pair pair,
const CustomPropHandlerVec handlers = {} 
)
inline

Definition at line 384 of file StreamOps.h.

◆ isUserRLabel()

bool RDKit::isUserRLabel ( const Atom atom)

Return true if the atom has a user-defined R group label.

◆ labellingToString()

std::string RDKit::labellingToString ( Labelling  type)

return the user friendly name for the given labelling

◆ LayeredFingerprintMol()

RDKIT_FINGERPRINTS_EXPORT ExplicitBitVect * RDKit::LayeredFingerprintMol ( const ROMol mol,
unsigned int  layerFlags = 0xFFFFFFFF,
unsigned int  minPath = 1,
unsigned int  maxPath = 7,
unsigned int  fpSize = 2048,
std::vector< unsigned int > *  atomCounts = nullptr,
ExplicitBitVect setOnlyBits = nullptr,
bool  branchedPaths = true,
const std::vector< std::uint32_t > *  fromAtoms = nullptr 
)

Generates a topological (Daylight like) fingerprint for a molecule using a layer-based hashing algorithm.

Experimental: This function is experimental. The API or results may change from release to release.

Parameters
molthe molecule to be fingerprinted
layerFlagsthe layers to be included (see below)
minPaththe minimum path length (in bonds) to be included
maxPaththe minimum path length (in bonds) to be included
fpSizethe size of the fingerprint
atomCountsif provided, this will be used to provide the count of the number of paths that set bits each atom is involved in. The vector should have at least as many entries as the molecule has atoms and is not zeroed out here.
setOnlyBitsif provided, only bits that are set in this bit vector will be set in the result. This is essentially the same as doing: (*res) &= (*setOnlyBits); but also has an impact on the atomCounts (if being used)
branchedPathstoggles generation of branched subgraphs, not just linear paths
Returns
the molecular fingerprint, as an ExplicitBitVect

Notes:

  • the caller is responsible for deleteing the result

Layer definitions:

  • 0x01: pure topology
  • 0x02: bond order
  • 0x04: atom types
  • 0x08: presence of rings
  • 0x10: ring sizes
  • 0x20: aromaticity

◆ makeAAtomQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAAtomQuery ( )

returns a Query for matching generic A atoms (heavy atoms)

◆ makeAHAtomQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_NULL_QUERY * RDKit::makeAHAtomQuery ( )

returns a Query for matching generic AH atoms (any atom)

◆ makeAtomAliphaticQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomAliphaticQuery ( )

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

◆ makeAtomAliphaticQuery() [2/2]

template<class T >
T * RDKit::makeAtomAliphaticQuery ( const std::string &  descr)

returns a Query for matching aliphatic atoms

Definition at line 461 of file QueryOps.h.

References queryAtomAliphatic(), and rdvalue_is().

◆ makeAtomAromaticQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomAromaticQuery ( )

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

◆ makeAtomAromaticQuery() [2/2]

template<class T >
T * RDKit::makeAtomAromaticQuery ( const std::string &  descr)

returns a Query for matching the isAromatic flag

Definition at line 453 of file QueryOps.h.

References queryAtomAromatic(), and rdvalue_is().

◆ makeAtomExplicitDegreeQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomExplicitDegreeQuery ( int  what)

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

◆ makeAtomExplicitDegreeQuery() [2/2]

template<class T >
T * RDKit::makeAtomExplicitDegreeQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching explicit degree

Definition at line 405 of file QueryOps.h.

References queryAtomExplicitDegree(), and rdvalue_is().

◆ makeAtomExplicitValenceQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomExplicitValenceQuery ( int  what)

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

◆ makeAtomExplicitValenceQuery() [2/2]

template<class T >
T * RDKit::makeAtomExplicitValenceQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching explicit valence

Definition at line 389 of file QueryOps.h.

References queryAtomExplicitValence(), and rdvalue_is().

◆ makeAtomFormalChargeQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomFormalChargeQuery ( int  what)

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

◆ makeAtomFormalChargeQuery() [2/2]

template<class T >
T * RDKit::makeAtomFormalChargeQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching formal charge

Definition at line 486 of file QueryOps.h.

References queryAtomFormalCharge(), and rdvalue_is().

Referenced by RDKit::QueryAtom::QueryAtom().

◆ makeAtomHasAliphaticHeteroatomNbrsQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomHasAliphaticHeteroatomNbrsQuery ( )

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

◆ makeAtomHasAliphaticHeteroatomNbrsQuery() [2/2]

template<class T >
T * RDKit::makeAtomHasAliphaticHeteroatomNbrsQuery ( const std::string &  descr)

returns a Query for matching atoms that have heteroatom neighbors

Definition at line 640 of file QueryOps.h.

References queryAtomHasAliphaticHeteroatomNbrs(), and rdvalue_is().

◆ makeAtomHasChiralTagQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomHasChiralTagQuery ( )

\overloadquery

◆ makeAtomHasChiralTagQuery() [2/2]

template<class T >
T * RDKit::makeAtomHasChiralTagQuery ( const std::string &  descr)

returns a Query for matching whether or not chirality has been set on the atom

Definition at line 522 of file QueryOps.h.

References queryAtomHasChiralTag(), and rdvalue_is().

◆ makeAtomHasHeteroatomNbrsQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomHasHeteroatomNbrsQuery ( )

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

◆ makeAtomHasHeteroatomNbrsQuery() [2/2]

template<class T >
T * RDKit::makeAtomHasHeteroatomNbrsQuery ( const std::string &  descr)

returns a Query for matching atoms that have heteroatom neighbors

Definition at line 622 of file QueryOps.h.

References queryAtomHasHeteroatomNbrs(), and rdvalue_is().

◆ makeAtomHasImplicitHQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomHasImplicitHQuery ( )

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

◆ makeAtomHasImplicitHQuery() [2/2]

template<class T >
T * RDKit::makeAtomHasImplicitHQuery ( const std::string &  descr)

returns a Query for matching ring atoms

Definition at line 437 of file QueryOps.h.

References queryAtomHasImplicitH(), and rdvalue_is().

◆ makeAtomHasRingBondQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomHasRingBondQuery ( )

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

◆ makeAtomHasRingBondQuery() [2/2]

template<class T >
T * RDKit::makeAtomHasRingBondQuery ( const std::string &  descr)

returns a Query for matching atoms that have ring bonds

Definition at line 605 of file QueryOps.h.

References queryAtomHasRingBond(), and rdvalue_is().

◆ makeAtomHCountQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomHCountQuery ( int  what)

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

◆ makeAtomHCountQuery() [2/2]

template<class T >
T * RDKit::makeAtomHCountQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching hydrogen count

Definition at line 429 of file QueryOps.h.

References queryAtomHCount(), and rdvalue_is().

◆ makeAtomHeavyAtomDegreeQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomHeavyAtomDegreeQuery ( int  what)

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

◆ makeAtomHeavyAtomDegreeQuery() [2/2]

template<class T >
T * RDKit::makeAtomHeavyAtomDegreeQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching heavy atom degree

Definition at line 421 of file QueryOps.h.

References queryAtomHeavyAtomDegree(), and rdvalue_is().

◆ makeAtomHybridizationQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomHybridizationQuery ( int  what)

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

◆ makeAtomHybridizationQuery() [2/2]

template<class T >
T * RDKit::makeAtomHybridizationQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching hybridization

Definition at line 504 of file QueryOps.h.

References queryAtomHybridization(), and rdvalue_is().

◆ makeAtomImplicitHCountQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomImplicitHCountQuery ( int  what)

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

◆ makeAtomImplicitHCountQuery() [2/2]

template<class T >
T * RDKit::makeAtomImplicitHCountQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching implicit hydrogen count

Definition at line 445 of file QueryOps.h.

References queryAtomImplicitHCount(), and rdvalue_is().

◆ makeAtomImplicitValenceQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomImplicitValenceQuery ( int  what)

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

◆ makeAtomImplicitValenceQuery() [2/2]

template<class T >
T * RDKit::makeAtomImplicitValenceQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching implicit valence

Definition at line 381 of file QueryOps.h.

References queryAtomImplicitValence(), and rdvalue_is().

◆ makeAtomInNRingsQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomInNRingsQuery ( int  what)

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

◆ makeAtomInNRingsQuery() [2/2]

template<class T >
T * RDKit::makeAtomInNRingsQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching atoms in a particular number of rings

Definition at line 555 of file QueryOps.h.

References queryIsAtomInNRings(), and rdvalue_is().

◆ makeAtomInRingOfSizeQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomInRingOfSizeQuery ( int  tgt)

returns a Query for matching atoms in rings of a particular size

◆ makeAtomInRingQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomInRingQuery ( )

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

◆ makeAtomInRingQuery() [2/2]

template<class T >
T * RDKit::makeAtomInRingQuery ( const std::string &  descr)

returns a Query for matching ring atoms

Definition at line 547 of file QueryOps.h.

References queryIsAtomInRing(), and rdvalue_is().

◆ makeAtomIsBridgeheadQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomIsBridgeheadQuery ( )

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

◆ makeAtomIsBridgeheadQuery() [2/2]

template<class T >
T * RDKit::makeAtomIsBridgeheadQuery ( const std::string &  descr)

returns a Query for matching bridgehead atoms

Definition at line 658 of file QueryOps.h.

References queryIsAtomBridgehead(), and rdvalue_is().

◆ makeAtomIsotopeQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomIsotopeQuery ( int  what)

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

◆ makeAtomIsotopeQuery() [2/2]

template<class T >
T * RDKit::makeAtomIsotopeQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching atoms with a particular isotope

Definition at line 478 of file QueryOps.h.

References queryAtomIsotope(), and rdvalue_is().

Referenced by RDKit::QueryAtom::QueryAtom().

◆ makeAtomMassQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomMassQuery ( int  what)

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

◆ makeAtomMassQuery() [2/2]

template<class T >
T * RDKit::makeAtomMassQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching atoms with a particular mass

Definition at line 469 of file QueryOps.h.

References massIntegerConversionFactor, queryAtomMass(), and rdvalue_is().

◆ makeAtomMinRingSizeQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomMinRingSizeQuery ( int  tgt)

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

◆ makeAtomMinRingSizeQuery() [2/2]

template<class T >
T * RDKit::makeAtomMinRingSizeQuery ( int  tgt,
const std::string &  descr 
)

returns a Query for matching an atom's minimum ring size

Definition at line 566 of file QueryOps.h.

References queryAtomMinRingSize(), and rdvalue_is().

◆ makeAtomMissingChiralTagQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomMissingChiralTagQuery ( )

\overloadquery

◆ makeAtomMissingChiralTagQuery() [2/2]

template<class T >
T * RDKit::makeAtomMissingChiralTagQuery ( const std::string &  descr)

returns a Query for matching whether or not a potentially chiral atom is missing a chiral tag

Definition at line 531 of file QueryOps.h.

References queryAtomMissingChiralTag(), and rdvalue_is().

◆ makeAtomNegativeFormalChargeQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomNegativeFormalChargeQuery ( int  what)

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

◆ makeAtomNegativeFormalChargeQuery() [2/2]

template<class T >
T * RDKit::makeAtomNegativeFormalChargeQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching negative formal charges (i.e. a query val of 1 matches a formal charge of -1)

Definition at line 495 of file QueryOps.h.

References queryAtomNegativeFormalCharge(), and rdvalue_is().

◆ makeAtomNonHydrogenDegreeQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomNonHydrogenDegreeQuery ( int  what)

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

◆ makeAtomNonHydrogenDegreeQuery() [2/2]

template<class T >
T * RDKit::makeAtomNonHydrogenDegreeQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching the number of non-hydrogen neighbors

Definition at line 649 of file QueryOps.h.

References queryAtomNonHydrogenDegree(), and rdvalue_is().

◆ makeAtomNullQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_NULL_QUERY * RDKit::makeAtomNullQuery ( )

returns a Query for matching any atom

◆ makeAtomNumAliphaticHeteroatomNbrsQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomNumAliphaticHeteroatomNbrsQuery ( int  what)

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

◆ makeAtomNumAliphaticHeteroatomNbrsQuery() [2/2]

template<class T >
T * RDKit::makeAtomNumAliphaticHeteroatomNbrsQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching the number of aliphatic heteroatom neighbors

Definition at line 630 of file QueryOps.h.

References queryAtomNumAliphaticHeteroatomNbrs(), and rdvalue_is().

◆ makeAtomNumHeteroatomNbrsQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomNumHeteroatomNbrsQuery ( int  what)

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

◆ makeAtomNumHeteroatomNbrsQuery() [2/2]

template<class T >
T * RDKit::makeAtomNumHeteroatomNbrsQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching the number of heteroatom neighbors

Definition at line 613 of file QueryOps.h.

References queryAtomNumHeteroatomNbrs(), and rdvalue_is().

◆ makeAtomNumQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomNumQuery ( int  what)

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

◆ makeAtomNumQuery() [2/2]

template<class T >
T * RDKit::makeAtomNumQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching atomic number

Definition at line 363 of file QueryOps.h.

References queryAtomNum(), and rdvalue_is().

Referenced by RDKit::QueryAtom::QueryAtom(), and RDKit::QueryAtom::QueryAtom().

◆ makeAtomNumRadicalElectronsQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomNumRadicalElectronsQuery ( int  what)

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

◆ makeAtomNumRadicalElectronsQuery() [2/2]

template<class T >
T * RDKit::makeAtomNumRadicalElectronsQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching the number of radical electrons

Definition at line 512 of file QueryOps.h.

References queryAtomNumRadicalElectrons(), and rdvalue_is().

Referenced by RDKit::QueryAtom::QueryAtom().

◆ makeAtomRangeQuery()

static ATOM_RANGE_QUERY * RDKit::makeAtomRangeQuery ( int  lower,
int  upper,
bool  lowerOpen,
bool  upperOpen,
int   funcAtom const *,
const std::string &  description = "Atom Range" 
)
inlinestatic

Definition at line 351 of file QueryOps.h.

References rdvalue_is().

◆ makeAtomRingBondCountQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomRingBondCountQuery ( int  what)

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

◆ makeAtomRingBondCountQuery() [2/2]

template<class T >
T * RDKit::makeAtomRingBondCountQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching atoms with a particular number of ring bonds

Definition at line 574 of file QueryOps.h.

References queryAtomRingBondCount(), and rdvalue_is().

◆ makeAtomSimpleQuery()

template<class T >
T * RDKit::makeAtomSimpleQuery ( int  what,
int   funcAtom const *,
const std::string &  description = "Atom Simple" 
)

Definition at line 342 of file QueryOps.h.

References rdvalue_is().

◆ makeAtomTotalDegreeQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomTotalDegreeQuery ( int  what)

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

◆ makeAtomTotalDegreeQuery() [2/2]

template<class T >
T * RDKit::makeAtomTotalDegreeQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching atomic degree

Definition at line 413 of file QueryOps.h.

References queryAtomTotalDegree(), and rdvalue_is().

◆ makeAtomTotalValenceQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomTotalValenceQuery ( int  what)

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

◆ makeAtomTotalValenceQuery() [2/2]

template<class T >
T * RDKit::makeAtomTotalValenceQuery ( int  what,
const std::string &  descr 
)

returns a Query for matching total valence

Definition at line 397 of file QueryOps.h.

References queryAtomTotalValence(), and rdvalue_is().

◆ makeAtomType()

static int RDKit::makeAtomType ( int  atomic_num,
bool  aromatic 
)
inlinestatic

Definition at line 132 of file QueryOps.h.

References rdvalue_is().

Referenced by makeAtomTypeQuery(), and queryAtomType().

◆ makeAtomTypeQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomTypeQuery ( int  num,
int  aromatic 
)

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

◆ makeAtomTypeQuery() [2/2]

template<class T >
T * RDKit::makeAtomTypeQuery ( int  num,
int  aromatic,
const std::string &  descr 
)

returns a Query for matching atomic number and aromaticity

Definition at line 371 of file QueryOps.h.

References makeAtomType(), queryAtomType(), and rdvalue_is().

◆ makeAtomUnsaturatedQuery() [1/2]

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeAtomUnsaturatedQuery ( )

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

◆ makeAtomUnsaturatedQuery() [2/2]

template<class T >
T * RDKit::makeAtomUnsaturatedQuery ( const std::string &  descr)

returns a Query for matching atoms with unsaturation:

Definition at line 539 of file QueryOps.h.

References queryAtomUnsaturated(), and rdvalue_is().

◆ makeBondDirEqualsQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeBondDirEqualsQuery ( Bond::BondDir  what)

returns a Query for matching bond directions

◆ makeBondHasStereoQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeBondHasStereoQuery ( )

returns a Query for matching bonds with stereo set

◆ makeBondInNRingsQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeBondInNRingsQuery ( int  tgt)

returns a Query for matching bonds in a particular number of rings

◆ makeBondInRingOfSizeQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeBondInRingOfSizeQuery ( int  what)

returns a Query for matching bonds in rings of a particular size

◆ makeBondIsInRingQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeBondIsInRingQuery ( )

returns a Query for matching ring bonds

◆ makeBondMinRingSizeQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeBondMinRingSizeQuery ( int  what)

returns a Query for matching a bond's minimum ring size

◆ makeBondNullQuery()

RDKIT_GRAPHMOL_EXPORT BOND_NULL_QUERY * RDKit::makeBondNullQuery ( )

returns a Query for matching any bond

◆ makeBondOrderEqualsQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeBondOrderEqualsQuery ( Bond::BondType  what)

returns a Query for matching bond orders

Referenced by RDKit::QueryBond::QueryBond().

◆ makeDoubleOrAromaticBondQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeDoubleOrAromaticBondQuery ( )

returns a Query for double|aromatic bonds

◆ MakeFilterCatalogEntry()

FilterCatalogEntry * RDKit::MakeFilterCatalogEntry ( const FilterData_t ,
unsigned int  num_props = 0,
const FilterProperty_t props = nullptr 
)

◆ makeHasPropQuery()

template<class Target >
Queries::EqualityQuery< int, const Target *, true > * RDKit::makeHasPropQuery ( const std::string &  property)

returns a Query for matching atoms that have a particular property

Definition at line 857 of file QueryOps.h.

References rdvalue_is().

◆ makeMAtomQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * RDKit::makeMAtomQuery ( )

returns a Query for matching generic M atoms (metals)

◆ makeMHAtomQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * RDKit::makeMHAtomQuery ( )

returns a Query for matching generic MH atoms (metals or H)

◆ makePropQuery() [1/2]

template<class Target >
Queries::EqualityQuery< int, const Target *, true > * RDKit::makePropQuery ( const std::string &  propname,
const ExplicitBitVect val,
float  tolerance = 0.0 
)

Definition at line 1073 of file QueryOps.h.

References rdvalue_is().

◆ makePropQuery() [2/2]

template<class Target , class T >
Queries::EqualityQuery< int, const Target *, true > * RDKit::makePropQuery ( const std::string &  propname,
const T &  val,
const T &  tolerance = T() 
)

Definition at line 1067 of file QueryOps.h.

References rdvalue_is().

◆ makeQAtomQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * RDKit::makeQAtomQuery ( )

returns a Query for matching generic Q atoms (heteroatoms)

◆ makeQHAtomQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * RDKit::makeQHAtomQuery ( )

returns a Query for matching generic QH atoms (heteroatom or H)

◆ makeSingleOrAromaticBondQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeSingleOrAromaticBondQuery ( )

returns a Query for unspecified SMARTS bonds

◆ makeSingleOrDoubleBondQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeSingleOrDoubleBondQuery ( )

returns a Query for single|double bonds

◆ makeSingleOrDoubleOrAromaticBondQuery()

RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * RDKit::makeSingleOrDoubleOrAromaticBondQuery ( )

returns a Query for tautomeric bonds

◆ makeXAtomQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * RDKit::makeXAtomQuery ( )

returns a Query for matching generic X atoms (halogens)

◆ makeXHAtomQuery()

RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * RDKit::makeXHAtomQuery ( )

returns a Query for matching generic XH atoms (halogen or H)

◆ markUnspecifiedStereoAsUnknown()

RDKIT_FILEPARSERS_EXPORT void RDKit::markUnspecifiedStereoAsUnknown ( ROMol mol,
int  confId = -1 
)

Set double bonds with unspecified stereo to STEREOANY and add wavy bonds to potential stereocenters with unspecified chirality

◆ MCSAtomCompareAny()

RDKIT_FMCS_EXPORT bool RDKit::MCSAtomCompareAny ( const MCSAtomCompareParameters p,
const ROMol mol1,
unsigned int  atom1,
const ROMol mol2,
unsigned int  atom2,
void userData 
)

◆ MCSAtomCompareAnyHeavyAtom()

RDKIT_FMCS_EXPORT bool RDKit::MCSAtomCompareAnyHeavyAtom ( const MCSAtomCompareParameters p,
const ROMol mol1,
unsigned int  atom1,
const ROMol mol2,
unsigned int  atom2,
void userData 
)

◆ MCSAtomCompareElements()

RDKIT_FMCS_EXPORT bool RDKit::MCSAtomCompareElements ( const MCSAtomCompareParameters p,
const ROMol mol1,
unsigned int  atom1,
const ROMol mol2,
unsigned int  atom2,
void userData 
)

◆ MCSAtomCompareIsotopes()

RDKIT_FMCS_EXPORT bool RDKit::MCSAtomCompareIsotopes ( const MCSAtomCompareParameters p,
const ROMol mol1,
unsigned int  atom1,
const ROMol mol2,
unsigned int  atom2,
void userData 
)

◆ MCSBondCompareAny()

RDKIT_FMCS_EXPORT bool RDKit::MCSBondCompareAny ( const MCSBondCompareParameters p,
const ROMol mol1,
unsigned int  bond1,
const ROMol mol2,
unsigned int  bond2,
void userData 
)

◆ MCSBondCompareOrder()

RDKIT_FMCS_EXPORT bool RDKit::MCSBondCompareOrder ( const MCSBondCompareParameters p,
const ROMol mol1,
unsigned int  bond1,
const ROMol mol2,
unsigned int  bond2,
void userData 
)

◆ MCSBondCompareOrderExact()

RDKIT_FMCS_EXPORT bool RDKit::MCSBondCompareOrderExact ( const MCSBondCompareParameters p,
const ROMol mol1,
unsigned int  bond1,
const ROMol mol2,
unsigned int  bond2,
void userData 
)

◆ MCSProgressCallbackTimeout()

RDKIT_FMCS_EXPORT bool RDKit::MCSProgressCallbackTimeout ( const MCSProgressData stat,
const MCSParameters params,
void userData 
)

◆ mergeNullQueries()

template<class T >
void RDKit::mergeNullQueries ( T *&  returnQuery,
bool  isQueryNull,
T *&  otherQuery,
bool  isOtherQNull,
Queries::CompositeQueryType  how 
)

◆ Mol2BlockToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::Mol2BlockToMol ( const std::string &  molBlock,
bool  sanitize = true,
bool  removeHs = true,
Mol2Type  variant = CORINA,
bool  cleanupSubstructures = true 
)
Parameters
molBlock- string containing the mol block
sanitize- toggles sanitization of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized
variant- the atom type definitions to use
cleanupSubstructures- toggles recognition and cleanup of common substructures

References Mol2BlockToMol().

Referenced by Mol2BlockToMol(), and operator""_mol2().

◆ Mol2DataStreamToMol() [1/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::Mol2DataStreamToMol ( std::istream &  inStream,
bool  sanitize = true,
bool  removeHs = true,
Mol2Type  variant = CORINA,
bool  cleanupSubstructures = true 
)

References Mol2DataStreamToMol().

◆ Mol2DataStreamToMol() [2/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::Mol2DataStreamToMol ( std::istream *  inStream,
bool  sanitize = true,
bool  removeHs = true,
Mol2Type  variant = CORINA,
bool  cleanupSubstructures = true 
)
Parameters
inStream- stream containing the data
sanitize- toggles sanitization of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized
variant- the atom type definitions to use
cleanupSubstructures- toggles recognition and cleanup of common substructures

References Mol2DataStreamToMol().

Referenced by Mol2DataStreamToMol(), and Mol2DataStreamToMol().

◆ Mol2FileToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::Mol2FileToMol ( const std::string &  fName,
bool  sanitize = true,
bool  removeHs = true,
Mol2Type  variant = CORINA,
bool  cleanupSubstructures = true 
)
Parameters
fName- string containing the file name
sanitize- toggles sanitization of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized
variant- the atom type definitions to use
cleanupSubstructures- toggles recognition and cleanup of common substructures

References Mol2FileToMol().

Referenced by Mol2FileToMol().

◆ MolBlockToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::MolBlockToMol ( const std::string &  molBlock,
bool  sanitize = true,
bool  removeHs = true,
bool  strictParsing = true 
)
Parameters
molBlock- string containing the mol block
sanitize- toggles sanitization and stereochemistry perception of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized
strictParsing- if set to false, the parser is more lax about correctness of the contents.

Referenced by operator""_ctab().

◆ MolBundleCanSerialize()

bool RDKit::MolBundleCanSerialize ( )
inline

Definition at line 46 of file MolBundle.h.

◆ MolDataStreamToMol() [1/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::MolDataStreamToMol ( std::istream &  inStream,
unsigned int line,
bool  sanitize = true,
bool  removeHs = true,
bool  strictParsing = true 
)

◆ MolDataStreamToMol() [2/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::MolDataStreamToMol ( std::istream *  inStream,
unsigned int line,
bool  sanitize = true,
bool  removeHs = true,
bool  strictParsing = true 
)
Parameters
inStream- stream containing the data
line- current line number (used for error reporting)
sanitize- toggles sanitization and stereochemistry perception of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized
line- current line number (used for error reporting)
strictParsing- if set to false, the parser is more lax about correctness of the contents.

◆ MolFileToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::MolFileToMol ( const std::string &  fName,
bool  sanitize = true,
bool  removeHs = true,
bool  strictParsing = true 
)
Parameters
fName- string containing the file name
sanitize- toggles sanitization and stereochemistry perception of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized
strictParsing- if set to false, the parser is more lax about correctness of the contents.

◆ MolFragmentToCXSmarts()

RDKIT_SMILESPARSE_EXPORT std::string RDKit::MolFragmentToCXSmarts ( const ROMol mol,
const std::vector< int > &  atomsToUse,
const std::vector< int > *  bondsToUse = nullptr,
bool  doIsomericSmarts = true 
)

◆ MolFragmentToCXSmiles() [1/2]

RDKIT_SMILESPARSE_EXPORT std::string RDKit::MolFragmentToCXSmiles ( const ROMol mol,
const SmilesWriteParams params,
const std::vector< int > &  atomsToUse,
const std::vector< int > *  bondsToUse = nullptr,
const std::vector< std::string > *  atomSymbols = nullptr,
const std::vector< std::string > *  bondSymbols = nullptr 
)

returns canonical CXSMILES for part of a molecule

Referenced by MolFragmentToCXSmiles().

◆ MolFragmentToCXSmiles() [2/2]

std::string RDKit::MolFragmentToCXSmiles ( const ROMol mol,
const std::vector< int > &  atomsToUse,
const std::vector< int > *  bondsToUse = nullptr,
const std::vector< std::string > *  atomSymbols = nullptr,
const std::vector< std::string > *  bondSymbols = nullptr,
bool  doIsomericSmiles = true,
bool  doKekule = false,
int  rootedAtAtom = -1,
bool  canonical = true,
bool  allBondsExplicit = false,
bool  allHsExplicit = false 
)
inline

returns canonical CXSMILES for part of a molecule

Parameters
mol: the molecule in question.
atomsToUse: indices of the atoms in the fragment
bondsToUse: indices of the bonds in the fragment. If this is not provided, all bonds between the atoms in atomsToUse will be included
atomSymbols: symbols to use for the atoms in the output SMILES
bondSymbols: symbols to use for the bonds in the output SMILES
doIsomericSmiles: include stereochemistry and isotope information in the SMILES
doKekule: do Kekule smiles (i.e. don't use aromatic bonds)
rootedAtAtom: make sure the SMILES starts at the specified atom. The resulting SMILES is not, of course, canonical.
canonical: if false, no attempt will be made to canonicalize the SMILES
allBondsExplicit: if true, symbols will be included for all bonds.
allHsExplicit: if true, hydrogen counts will be provided for every atom.

NOTE: the bondSymbols are not currently used in the canonicalization.

Definition at line 276 of file SmilesWrite.h.

References RDKit::SmilesWriteParams::doIsomericSmiles, MolFragmentToCXSmiles(), and rdvalue_is().

◆ MolFragmentToSmarts()

RDKIT_SMILESPARSE_EXPORT std::string RDKit::MolFragmentToSmarts ( const ROMol mol,
const std::vector< int > &  atomsToUse,
const std::vector< int > *  bondsToUse = nullptr,
bool  doIsomericSmarts = true 
)

◆ MolFragmentToSmiles() [1/2]

RDKIT_SMILESPARSE_EXPORT std::string RDKit::MolFragmentToSmiles ( const ROMol mol,
const SmilesWriteParams params,
const std::vector< int > &  atomsToUse,
const std::vector< int > *  bondsToUse = nullptr,
const std::vector< std::string > *  atomSymbols = nullptr,
const std::vector< std::string > *  bondSymbols = nullptr 
)

returns canonical SMILES for part of a molecule

Referenced by MolFragmentToSmiles().

◆ MolFragmentToSmiles() [2/2]

std::string RDKit::MolFragmentToSmiles ( const ROMol mol,
const std::vector< int > &  atomsToUse,
const std::vector< int > *  bondsToUse = nullptr,
const std::vector< std::string > *  atomSymbols = nullptr,
const std::vector< std::string > *  bondSymbols = nullptr,
bool  doIsomericSmiles = true,
bool  doKekule = false,
int  rootedAtAtom = -1,
bool  canonical = true,
bool  allBondsExplicit = false,
bool  allHsExplicit = false 
)
inline

returns canonical SMILES for part of a molecule

Parameters
mol: the molecule in question.
atomsToUse: indices of the atoms in the fragment
bondsToUse: indices of the bonds in the fragment. If this is not provided, all bonds between the atoms in atomsToUse will be included
atomSymbols: symbols to use for the atoms in the output SMILES
bondSymbols: symbols to use for the bonds in the output SMILES
doIsomericSmiles: include stereochemistry and isotope information in the SMILES
doKekule: do Kekule smiles (i.e. don't use aromatic bonds)
rootedAtAtom: make sure the SMILES starts at the specified atom. The resulting SMILES is not, of course, canonical.
canonical: if false, no attempt will be made to canonicalize the SMILES
allBondsExplicit: if true, symbols will be included for all bonds.
allHsExplicit: if true, hydrogen counts will be provided for every atom.
doRandom: generate a randomized smiles string by randomly choosing the priority to follow in the DFS traversal. [default false]

NOTE: the bondSymbols are not currently used in the canonicalization.

Definition at line 190 of file SmilesWrite.h.

References RDKit::SmilesWriteParams::doIsomericSmiles, MolFragmentToSmiles(), and rdvalue_is().

◆ MolToCMLBlock()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::MolToCMLBlock ( const ROMol mol,
int  confId = -1,
bool  kekulize = true 
)

References MolToCMLBlock().

Referenced by MolToCMLBlock().

◆ MolToCMLFile()

RDKIT_FILEPARSERS_EXPORT void RDKit::MolToCMLFile ( const ROMol mol,
const std::string &  fName,
int  confId = -1,
bool  kekulize = true 
)

References MolToCMLFile().

Referenced by MolToCMLFile().

◆ MolToCXSmarts()

RDKIT_SMILESPARSE_EXPORT std::string RDKit::MolToCXSmarts ( const ROMol mol,
bool  doIsomericSmarts = true 
)

returns the CXSMARTS for a molecule

◆ MolToCXSmiles() [1/2]

std::string RDKit::MolToCXSmiles ( const ROMol mol,
bool  doIsomericSmiles = true,
bool  doKekule = false,
int  rootedAtAtom = -1,
bool  canonical = true,
bool  allBondsExplicit = false,
bool  allHsExplicit = false,
bool  doRandom = false 
)
inline

returns canonical CXSMILES for a molecule

Parameters
mol: the molecule in question.
doIsomericSmiles: include stereochemistry and isotope information in the SMILES
doKekule: do Kekule smiles (i.e. don't use aromatic bonds)
rootedAtAtom: make sure the SMILES starts at the specified atom. The resulting SMILES is not, of course, canonical.
canonical: if false, no attempt will be made to canonicalize the SMILES
allBondsExplicit: if true, symbols will be included for all bonds.
allHsExplicit: if true, hydrogen counts will be provided for every atom.

Definition at line 228 of file SmilesWrite.h.

References RDKit::SmilesWriteParams::doIsomericSmiles, MolToCXSmiles(), and rdvalue_is().

◆ MolToCXSmiles() [2/2]

RDKIT_SMILESPARSE_EXPORT std::string RDKit::MolToCXSmiles ( const ROMol mol,
const SmilesWriteParams ps,
std::uint32_t  flags = SmilesWrite::CXSmilesFields::CX_ALL 
)

returns canonical CXSMILES for a molecule

Referenced by MolToCXSmiles().

◆ MolToFASTA()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::MolToFASTA ( const ROMol mol)
Parameters
mol- the molecule to work with
Note
mol should contain monomer information in AtomMonomerInfo structures

◆ MolToHELM()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::MolToHELM ( const ROMol mol)
Parameters
mol- the molecule to work with
Note
mol should contain monomer information in AtomMonomerInfo structures

◆ MolToMolBlock()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::MolToMolBlock ( const ROMol mol,
bool  includeStereo = true,
int  confId = -1,
bool  kekulize = true,
bool  forceV3000 = false 
)
Parameters
mol- the molecule in question
includeStereo- toggles inclusion of stereochemistry information
confId- selects the conformer to be used
kekulize- triggers kekulization of the molecule before it is written
forceV3000- force generation a V3000 mol block (happens automatically with more than 999 atoms or bonds)

Referenced by MolToV3KMolBlock().

◆ MolToMolFile()

RDKIT_FILEPARSERS_EXPORT void RDKit::MolToMolFile ( const ROMol mol,
const std::string &  fName,
bool  includeStereo = true,
int  confId = -1,
bool  kekulize = true,
bool  forceV3000 = false 
)
Parameters
mol- the molecule in question
fName- the name of the file to use
includeStereo- toggles inclusion of stereochemistry information
confId- selects the conformer to be used
kekulize- triggers kekulization of the molecule before it is written
forceV3000- force generation a V3000 mol block (happens automatically with more than 999 atoms or bonds)

References MolToMolFile().

Referenced by MolToMolFile(), and MolToV3KMolFile().

◆ MolToMrvBlock()

RDKIT_MARVINPARSER_EXPORT std::string RDKit::MolToMrvBlock ( const ROMol mol,
bool  includeStereo = true,
int  confId = -1,
bool  kekulize = true,
bool  prettyPrint = false 
)

◆ MolToMrvFile()

RDKIT_MARVINPARSER_EXPORT void RDKit::MolToMrvFile ( const ROMol mol,
const std::string &  fName,
bool  includeStereo = true,
int  confId = -1,
bool  kekulize = true,
bool  prettyPrint = false 
)

◆ MolToPDBBlock()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::MolToPDBBlock ( const ROMol mol,
int  confId = -1,
unsigned int  flavor = 0 
)
Parameters
mol- the molecule in question
confId- selects the conformer to be used
flavor- controls what gets written: flavor & 1 : Write MODEL/ENDMDL lines around each record flavor & 2 : Don't write single CONECT records flavor & 4 : Write CONECT records in both directions flavor & 8 : Don't use multiple CONECTs to encode bond order flavor & 16 : Write MASTER record flavor & 32 : Write TER record

References MolToPDBBlock().

Referenced by MolToPDBBlock().

◆ MolToPDBFile()

RDKIT_FILEPARSERS_EXPORT void RDKit::MolToPDBFile ( const ROMol mol,
const std::string &  fname,
int  confId = -1,
unsigned int  flavor = 0 
)
Parameters
mol- the molecule in question
fName- the name of the file to use
confId- selects the conformer to be used
flavor- controls what gets written: flavor & 1 : Write MODEL/ENDMDL lines around each record flavor & 2 : Don't write single CONECT records flavor & 4 : Write CONECT records in both directions flavor & 8 : Don't use multiple CONECTs to encode bond order flavor & 16 : Write MASTER record flavor & 32 : Write TER record

References MolToPDBFile().

Referenced by MolToPDBFile().

◆ MolToRandomSmilesVect()

RDKIT_SMILESPARSE_EXPORT std::vector< std::string > RDKit::MolToRandomSmilesVect ( const ROMol mol,
unsigned int  numSmiles,
unsigned int  randomSeed = 0,
bool  doIsomericSmiles = true,
bool  doKekule = false,
bool  allBondsExplicit = false,
bool  allHsExplicit = false 
)

returns a vector of random SMILES for a molecule (may contain duplicates)

Parameters
mol: the molecule in question.
numSmiles: the number of SMILES to return
randomSeed: if >0, will be used to seed the random number generator
doIsomericSmiles: include stereochemistry and isotope information in the SMILES
doKekule: do Kekule smiles (i.e. don't use aromatic bonds)
allBondsExplicit: if true, symbols will be included for all bonds.
allHsExplicit: if true, hydrogen counts will be provided for every atom.

◆ MolToSequence()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::MolToSequence ( const ROMol mol)
Parameters
mol- the molecule to work with
Note
mol should contain monomer information in AtomMonomerInfo structures

◆ MolToSmarts()

RDKIT_SMILESPARSE_EXPORT std::string RDKit::MolToSmarts ( const ROMol mol,
bool  doIsomericSmarts = true,
int  rootedAtAtom = -1 
)

returns the SMARTS for a molecule

◆ MolToSmiles() [1/2]

std::string RDKit::MolToSmiles ( const ROMol mol,
bool  doIsomericSmiles = true,
bool  doKekule = false,
int  rootedAtAtom = -1,
bool  canonical = true,
bool  allBondsExplicit = false,
bool  allHsExplicit = false,
bool  doRandom = false 
)
inline

returns canonical SMILES for a molecule

Parameters
mol: the molecule in question.
doIsomericSmiles: include stereochemistry and isotope information in the SMILES
doKekule: do Kekule smiles (i.e. don't use aromatic bonds) NOTE that this will throw an exception if the molecule cannot be kekulized.
rootedAtAtom: make sure the SMILES starts at the specified atom. The resulting SMILES is not, of course, canonical.
canonical: if false, no attempt will be made to canonicalize the SMILES
allBondsExplicit: if true, symbols will be included for all bonds.
allHsExplicit: if true, hydrogen counts will be provided for every atom.

Definition at line 122 of file SmilesWrite.h.

References RDKit::SmilesWriteParams::doIsomericSmiles, MolToSmiles(), and rdvalue_is().

◆ MolToSmiles() [2/2]

RDKIT_SMILESPARSE_EXPORT std::string RDKit::MolToSmiles ( const ROMol mol,
const SmilesWriteParams params 
)

returns canonical SMILES for a molecule

Referenced by MolToSmiles().

◆ MolToTPLFile()

RDKIT_FILEPARSERS_EXPORT void RDKit::MolToTPLFile ( const ROMol mol,
const std::string &  fName,
const std::string &  partialChargeProp = "_GasteigerCharge",
bool  writeFirstConfTwice = false 
)

References MolToTPLFile().

Referenced by MolToTPLFile().

◆ MolToTPLText()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::MolToTPLText ( const ROMol mol,
const std::string &  partialChargeProp = "_GasteigerCharge",
bool  writeFirstConfTwice = false 
)

References MolToTPLText().

Referenced by MolToTPLText().

◆ MolToV3KMolBlock()

std::string RDKit::MolToV3KMolBlock ( const ROMol mol,
bool  includeStereo = true,
int  confId = -1,
bool  kekulize = true 
)
inline
Parameters
mol- the molecule in question
includeStereo- toggles inclusion of stereochemistry information
confId- selects the conformer to be used
kekulize- triggers kekulization of the molecule before it is written

Definition at line 128 of file FileParsers.h.

References MolToMolBlock().

◆ MolToV3KMolFile()

void RDKit::MolToV3KMolFile ( const ROMol mol,
const std::string &  fName,
bool  includeStereo = true,
int  confId = -1,
bool  kekulize = true 
)
inline
Parameters
mol- the molecule in question
fName- the name of the file to use
includeStereo- toggles inclusion of stereochemistry information
confId- selects the conformer to be used
kekulize- triggers kekulization of the molecule before it is written

Definition at line 158 of file FileParsers.h.

References MolToMolFile(), and MolToV3KMolFile().

Referenced by MolToV3KMolFile().

◆ MolToXYZBlock()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::MolToXYZBlock ( const ROMol mol,
int  confId = -1 
)

References MolToXYZBlock().

Referenced by MolToXYZBlock().

◆ MolToXYZFile()

RDKIT_FILEPARSERS_EXPORT void RDKit::MolToXYZFile ( const ROMol mol,
const std::string &  fName,
int  confId = -1 
)

References MolToXYZFile().

Referenced by MolToXYZFile().

◆ molzip() [1/3]

RDKIT_CHEMTRANSFORMS_EXPORT std::unique_ptr< ROMol > RDKit::molzip ( const ROMol a,
const MolzipParams params = MolzipParams() 
)

◆ molzip() [2/3]

RDKIT_CHEMTRANSFORMS_EXPORT std::unique_ptr< ROMol > RDKit::molzip ( const ROMol a,
const ROMol b,
const MolzipParams params = MolzipParams() 
)

◆ molzip() [3/3]

RDKIT_CHEMTRANSFORMS_EXPORT std::unique_ptr< ROMol > RDKit::molzip ( std::vector< ROMOL_SPTR > &  decomposition,
const MolzipParams params = MolzipParams() 
)

Creates a molecule from an R group decomposition.

Parameters
decomposition- A list of molecules that comprises an R group decomposition. The core must be the first molecule in the list. If generateCoordinates is set in the parameters then aligned depiction coordinates will be set on the returned molecule and the input decomposition

optional:

Parameters
params- molzip parameters
Returns
the zipped molecule

◆ MrvBlockIsReaction()

RDKIT_MARVINPARSER_EXPORT bool RDKit::MrvBlockIsReaction ( const std::string &  molmrvText)

◆ MrvBlockToChemicalReaction()

RDKIT_MARVINPARSER_EXPORT ChemicalReaction * RDKit::MrvBlockToChemicalReaction ( const std::string &  molmrvText,
bool  sanitize = false,
bool  removeHs = false 
)

◆ MrvBlockToMol()

RDKIT_MARVINPARSER_EXPORT RWMol * RDKit::MrvBlockToMol ( const std::string &  molmrvText,
bool  sanitize = false,
bool  removeHs = false 
)

◆ MrvDataStreamIsReaction() [1/2]

RDKIT_MARVINPARSER_EXPORT bool RDKit::MrvDataStreamIsReaction ( std::istream &  inStream)

◆ MrvDataStreamIsReaction() [2/2]

RDKIT_MARVINPARSER_EXPORT bool RDKit::MrvDataStreamIsReaction ( std::istream *  inStream)

◆ MrvDataStreamToChemicalReaction() [1/2]

RDKIT_MARVINPARSER_EXPORT ChemicalReaction * RDKit::MrvDataStreamToChemicalReaction ( std::istream &  inStream,
bool  sanitize = false,
bool  removeHs = false 
)

◆ MrvDataStreamToChemicalReaction() [2/2]

RDKIT_MARVINPARSER_EXPORT ChemicalReaction * RDKit::MrvDataStreamToChemicalReaction ( std::istream *  inStream,
bool  sanitize = false,
bool  removeHs = false 
)

◆ MrvDataStreamToMol() [1/2]

RDKIT_MARVINPARSER_EXPORT RWMol * RDKit::MrvDataStreamToMol ( std::istream &  inStream,
bool  sanitize = false,
bool  removeHs = false 
)

◆ MrvDataStreamToMol() [2/2]

RDKIT_MARVINPARSER_EXPORT RWMol * RDKit::MrvDataStreamToMol ( std::istream *  inStream,
bool  sanitize = false,
bool  removeHs = false 
)

◆ MrvFileIsReaction()

RDKIT_MARVINPARSER_EXPORT bool RDKit::MrvFileIsReaction ( const std::string &  fname)

◆ MrvFileToChemicalReaction()

RDKIT_MARVINPARSER_EXPORT ChemicalReaction * RDKit::MrvFileToChemicalReaction ( const std::string &  fName,
bool  sanitize = false,
bool  removeHs = false 
)

◆ MrvFileToMol()

RDKIT_MARVINPARSER_EXPORT RWMol * RDKit::MrvFileToMol ( const std::string &  fName,
bool  sanitize = false,
bool  removeHs = false 
)

◆ MurckoDecompose()

RDKIT_CHEMTRANSFORMS_EXPORT ROMol * RDKit::MurckoDecompose ( const ROMol mol)

Carries out a Murcko decomposition on the molecule provided.

Parameters
mol- the ROMol of interest
Returns
a new ROMol with the Murcko scaffold The client is responsible for deleting this molecule.

◆ nextCombination()

RDKIT_RDGENERAL_EXPORT int RDKit::nextCombination ( INT_VECT comb,
int  tot 
)

given a current combination of numbers change it to the next possible

Parameters
combthe sorted vector to consider
totthe maximum number possible in the vector
Returns
-1 on failure, the index of the last number changed on success. Example: for all combinations 3 of numbers between 0 and tot=5 given (0,1,2) the function wil return (0,1,3) etc.

◆ nullDataFun()

template<typename T >
int RDKit::nullDataFun ( )

Definition at line 807 of file QueryOps.h.

◆ nullQueryFun()

template<typename T >
bool RDKit::nullQueryFun ( )

Definition at line 811 of file QueryOps.h.

◆ operator""_ctab()

std::unique_ptr< RDKit::RWMol > RDKit::operator""_ctab ( const char text,
size_t  len 
)
inline

Definition at line 375 of file FileParsers.h.

References MolBlockToMol().

◆ operator""_mol2()

std::unique_ptr< RDKit::RWMol > RDKit::operator""_mol2 ( const char text,
size_t  len 
)
inline

Definition at line 386 of file FileParsers.h.

References Mol2BlockToMol().

◆ operator""_pdb()

std::unique_ptr< RDKit::RWMol > RDKit::operator""_pdb ( const char text,
size_t  len 
)
inline

Definition at line 398 of file FileParsers.h.

References PDBBlockToMol().

◆ operator""_rxnsmarts()

std::unique_ptr< ChemicalReaction > RDKit::operator""_rxnsmarts ( const char text,
size_t  len 
)
inline

Definition at line 251 of file ReactionParser.h.

References RxnSmartsToChemicalReaction().

◆ operator""_rxnsmiles()

std::unique_ptr< ChemicalReaction > RDKit::operator""_rxnsmiles ( const char text,
size_t  len 
)
inline

Definition at line 262 of file ReactionParser.h.

References RxnSmartsToChemicalReaction().

◆ operator""_smarts()

std::unique_ptr< RDKit::RWMol > RDKit::operator""_smarts ( const char text,
size_t  len 
)
inline

Definition at line 147 of file SmilesParse.h.

References SmartsToMol().

◆ operator""_smiles()

std::unique_ptr< RDKit::RWMol > RDKit::operator""_smiles ( const char text,
size_t  len 
)
inline

Definition at line 136 of file SmilesParse.h.

References SmilesToMol().

◆ operator+()

◆ operator-()

◆ parseAtomType()

static void RDKit::parseAtomType ( int  val,
int atomic_num,
bool aromatic 
)
inlinestatic

Definition at line 135 of file QueryOps.h.

References rdvalue_is().

◆ parseFeatureData() [1/2]

RDKIT_MOLCHEMICALFEATURES_EXPORT int RDKit::parseFeatureData ( const std::string &  defnText,
MolChemicalFeatureDef::CollectionType featDefs 
)

◆ parseFeatureData() [2/2]

RDKIT_MOLCHEMICALFEATURES_EXPORT int RDKit::parseFeatureData ( std::istream &  istream,
MolChemicalFeatureDef::CollectionType featDefs 
)

◆ parseFeatureFile()

RDKIT_MOLCHEMICALFEATURES_EXPORT int RDKit::parseFeatureFile ( const std::string &  fileName,
MolChemicalFeatureDef::CollectionType featDefs 
)

◆ parseMCSParametersJSON()

RDKIT_FMCS_EXPORT void RDKit::parseMCSParametersJSON ( const char json,
MCSParameters params 
)

◆ parseQueryDefFile() [1/2]

RDKIT_CHEMTRANSFORMS_EXPORT void RDKit::parseQueryDefFile ( const std::string &  filename,
std::map< std::string, ROMOL_SPTR > &  queryDefs,
bool  standardize = true,
const std::string &  delimiter = "\t",
const std::string &  comment = "//",
unsigned int  nameColumn = 0,
unsigned int  smartsColumn = 1 
)

parses a query definition file and sets up a set of definitions suitable for use by addRecursiveQueries()

Parameters
filename- the name of the file to be read
queryDefs- the dictionary of named queries (return value)
standardize- if true, query names will be converted to lower case
delimiter- the line delimiter in the file
comment- text used to recognize comment lines
nameColumn- column with the names of queries
smartsColumn- column with the SMARTS definitions of the queries

◆ parseQueryDefFile() [2/2]

RDKIT_CHEMTRANSFORMS_EXPORT void RDKit::parseQueryDefFile ( std::istream *  inStream,
std::map< std::string, ROMOL_SPTR > &  queryDefs,
bool  standardize = true,
const std::string &  delimiter = "\t",
const std::string &  comment = "//",
unsigned int  nameColumn = 0,
unsigned int  smartsColumn = 1 
)

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

◆ parseQueryDefText()

RDKIT_CHEMTRANSFORMS_EXPORT void RDKit::parseQueryDefText ( const std::string &  queryDefText,
std::map< std::string, ROMOL_SPTR > &  queryDefs,
bool  standardize = true,
const std::string &  delimiter = "\t",
const std::string &  comment = "//",
unsigned int  nameColumn = 0,
unsigned int  smartsColumn = 1 
)

equivalent to parseQueryDefFile() but the query definitions are explicitly passed in

◆ PatternFingerprintMol() [1/2]

RDKIT_FINGERPRINTS_EXPORT ExplicitBitVect * RDKit::PatternFingerprintMol ( const MolBundle bundle,
unsigned int  fpSize = 2048,
ExplicitBitVect setOnlyBits = nullptr,
bool  tautomericFingerprint = false 
)

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

◆ PatternFingerprintMol() [2/2]

RDKIT_FINGERPRINTS_EXPORT ExplicitBitVect * RDKit::PatternFingerprintMol ( const ROMol mol,
unsigned int  fpSize = 2048,
std::vector< unsigned int > *  atomCounts = nullptr,
ExplicitBitVect setOnlyBits = nullptr,
bool  tautomericFingerprint = false 
)

Generates a topological fingerprint for a molecule using a series of pre-defined structural patterns.

Experimental: This function is experimental. The API or results may change from release to release.

Parameters
molthe molecule to be fingerprinted
fpSizethe size of the fingerprint
atomCountsif provided, this will be used to provide the count of the number of paths that set bits each atom is involved in. The vector should have at least as many entries as the molecule has atoms and is not zeroed out here.
setOnlyBitsif provided, only bits that are set in this bit vector will be set in the result. This is essentially the same as doing: (*res) &= (*setOnlyBits); but also has an impact on the atomCounts (if being used)
Returns
the molecular fingerprint, as an ExplicitBitVect

Notes:

  • the caller is responsible for deleteing the result

Referenced by RDKit::PatternHolder::makeFingerprint(), and RDKit::TautomerPatternHolder::makeFingerprint().

◆ PDBBlockToMol() [1/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::PDBBlockToMol ( const char str,
bool  sanitize = true,
bool  removeHs = true,
unsigned int  flavor = 0,
bool  proximityBonding = true 
)

◆ PDBBlockToMol() [2/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::PDBBlockToMol ( const std::string &  str,
bool  sanitize = true,
bool  removeHs = true,
unsigned int  flavor = 0,
bool  proximityBonding = true 
)

References PDBBlockToMol().

◆ PDBDataStreamToMol() [1/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::PDBDataStreamToMol ( std::istream &  inStream,
bool  sanitize = true,
bool  removeHs = true,
unsigned int  flavor = 0,
bool  proximityBonding = true 
)

References PDBDataStreamToMol().

◆ PDBDataStreamToMol() [2/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::PDBDataStreamToMol ( std::istream *  inStream,
bool  sanitize = true,
bool  removeHs = true,
unsigned int  flavor = 0,
bool  proximityBonding = true 
)

◆ PDBFileToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::PDBFileToMol ( const std::string &  fname,
bool  sanitize = true,
bool  removeHs = true,
unsigned int  flavor = 0,
bool  proximityBonding = true 
)

References PDBFileToMol().

Referenced by PDBFileToMol().

◆ pickBondsToWedge()

◆ PNGFileToChemicalReaction()

ChemicalReaction * RDKit::PNGFileToChemicalReaction ( const std::string &  fname)
inline

constructs a ChemicalReaction from the metadata in a PNG file See PNGStreamToChemicalReaction() for more details

Definition at line 201 of file ReactionParser.h.

References PNGFileToChemicalReaction(), and PNGStreamToChemicalReaction().

Referenced by PNGFileToChemicalReaction().

◆ PNGFileToMetadata()

std::vector< std::pair< std::string, std::string > > RDKit::PNGFileToMetadata ( const std::string &  fname)
inline

returns the metadata (tEXt and zTXt chunks) from PNG data

Definition at line 43 of file PNGParser.h.

References PNGStreamToMetadata(), and rdvalue_is().

◆ PNGFileToMol()

ROMol * RDKit::PNGFileToMol ( const std::string &  fname,
const SmilesParserParams params = SmilesParserParams() 
)
inline

constructs an ROMol from the metadata in a PNG file. See PNGStreamToMol() for more details.

Definition at line 112 of file PNGParser.h.

References PNGStreamToMol(), and rdvalue_is().

◆ PNGFileToMols()

std::vector< std::unique_ptr< ROMol > > RDKit::PNGFileToMols ( const std::string &  fname,
const std::string &  tagToUse = PNGData::pklTag,
const SmilesParserParams params = SmilesParserParams() 
)
inline

constructs a vector of ROMol from the metadata in a PNG file. See PNGStreamToMols() for more details.

Definition at line 143 of file PNGParser.h.

References PNGStreamToMols(), and rdvalue_is().

◆ PNGStreamToChemicalReaction()

RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction * RDKit::PNGStreamToChemicalReaction ( std::istream &  pngStream)

constructs a ChemicalReaction from the metadata in a PNG stream

Looks through the metadata in the PNG to find the first tag that matches one of the tags in RDKit::PNGData. A molecule is constructed from this chunk.

Throws a FileParseException if no suitable tag is found.

The caller is responsible for the returned pointer.

References PNGStreamToChemicalReaction().

Referenced by PNGFileToChemicalReaction(), PNGStreamToChemicalReaction(), and PNGStringToChemicalReaction().

◆ PNGStreamToMetadata()

RDKIT_FILEPARSERS_EXPORT std::vector< std::pair< std::string, std::string > > RDKit::PNGStreamToMetadata ( std::istream &  inStream)

returns the metadata (tEXt and zTXt chunks) from PNG data

Referenced by PNGFileToMetadata(), and PNGStringToMetadata().

◆ PNGStreamToMol()

RDKIT_FILEPARSERS_EXPORT ROMol * RDKit::PNGStreamToMol ( std::istream &  inStream,
const SmilesParserParams params = SmilesParserParams() 
)

constructs an ROMol from the metadata in a PNG stream

Looks through the metadata in the PNG to find the first tag that matches one of the tags in RDKit::PNGData. A molecule is constructed from this chunk.

Throws a FileParseException if no suitable tag is found.

The caller is responsible for the returned pointer.

Referenced by PNGFileToMol(), and PNGStringToMol().

◆ PNGStreamToMols()

RDKIT_FILEPARSERS_EXPORT std::vector< std::unique_ptr< ROMol > > RDKit::PNGStreamToMols ( std::istream &  inStream,
const std::string &  tagToUse = PNGData::pklTag,
const SmilesParserParams params = SmilesParserParams() 
)

constructs a vector of ROMol from the metadata in a PNG stream

Looks through the metadata in the PNG to find tags that start with tagToUse (must be one of the tags in RDKit::PNGData). The molecules constructed from these data are returned.

Referenced by PNGFileToMols(), and PNGStringToMols().

◆ PNGStringToChemicalReaction()

ChemicalReaction * RDKit::PNGStringToChemicalReaction ( const std::string &  data)
inline

constructs a ChemicalReaction from the metadata in a PNG string See PNGStreamToChemicalReaction() for more details

Definition at line 195 of file ReactionParser.h.

References PNGStreamToChemicalReaction(), and PNGStringToChemicalReaction().

Referenced by PNGStringToChemicalReaction().

◆ PNGStringToMetadata()

std::vector< std::pair< std::string, std::string > > RDKit::PNGStringToMetadata ( const std::string &  data)
inline

returns the metadata (tEXt and zTXt chunks) from PNG data

Definition at line 53 of file PNGParser.h.

References PNGStreamToMetadata(), and rdvalue_is().

◆ PNGStringToMol()

ROMol * RDKit::PNGStringToMol ( const std::string &  data,
const SmilesParserParams params = SmilesParserParams() 
)
inline

constructs an ROMol from the metadata in a PNG string. See PNGStreamToMol() for more details.

Definition at line 123 of file PNGParser.h.

References PNGStreamToMol(), and rdvalue_is().

◆ PNGStringToMols()

std::vector< std::unique_ptr< ROMol > > RDKit::PNGStringToMols ( const std::string &  data,
const std::string &  tagToUse = PNGData::pklTag,
const SmilesParserParams params = SmilesParserParams() 
)
inline

constructs a vector of ROMol from the metadata in a PNG string. See PNGStreamToMols() for more details.

Definition at line 154 of file PNGParser.h.

References PNGStreamToMols(), and rdvalue_is().

◆ prepareMol()

RDKIT_FRAGCATALOG_EXPORT ROMol * RDKit::prepareMol ( const ROMol mol,
const FragCatParams fparams,
MatchVectType aToFmap 
)

◆ preprocessReaction() [1/4]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::preprocessReaction ( ChemicalReaction rxn,
const std::map< std::string, ROMOL_SPTR > &  queries,
const std::string &  propName = common_properties::molFileValue 
)

◆ preprocessReaction() [2/4]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::preprocessReaction ( ChemicalReaction rxn,
const std::string &  propName = common_properties::molFileValue 
)

◆ preprocessReaction() [3/4]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::preprocessReaction ( ChemicalReaction rxn,
unsigned int numWarnings,
unsigned int numErrors,
std::vector< std::vector< std::pair< unsigned int, std::string > > > &  reactantLabels,
const std::map< std::string, ROMOL_SPTR > &  queries,
const std::string &  propName = common_properties::molFileValue 
)

◆ preprocessReaction() [4/4]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::preprocessReaction ( ChemicalReaction rxn,
unsigned int numWarnings,
unsigned int numErrors,
std::vector< std::vector< std::pair< unsigned int, std::string > > > &  reactantLabels,
const std::string &  propName = common_properties::molFileValue 
)

◆ propertyCompat()

RDKIT_SUBSTRUCTMATCH_EXPORT bool RDKit::propertyCompat ( const RDProps r1,
const RDProps r2,
const std::vector< std::string > &  properties 
)

◆ pullPackedIntFromString()

boost::uint32_t RDKit::pullPackedIntFromString ( const char *&  text)
inline

Reads an integer from a char * in packed format and returns the result. The argument is advanced

Definition at line 216 of file StreamOps.h.

References rdvalue_is().

◆ queryAtomAliphatic()

static int RDKit::queryAtomAliphatic ( Atom const at)
inlinestatic

Definition at line 75 of file QueryOps.h.

References RDKit::Atom::getIsAromatic().

Referenced by makeAtomAliphaticQuery().

◆ queryAtomAllBondProduct()

RDKIT_GRAPHMOL_EXPORT unsigned int RDKit::queryAtomAllBondProduct ( Atom const at)

◆ queryAtomAromatic()

static int RDKit::queryAtomAromatic ( Atom const at)
inlinestatic

Definition at line 72 of file QueryOps.h.

References RDKit::Atom::getIsAromatic().

Referenced by makeAtomAromaticQuery().

◆ queryAtomBondProduct()

RDKIT_GRAPHMOL_EXPORT unsigned int RDKit::queryAtomBondProduct ( Atom const at)

◆ queryAtomExplicitDegree()

static int RDKit::queryAtomExplicitDegree ( Atom const at)
inlinestatic

Definition at line 78 of file QueryOps.h.

References RDKit::Atom::getDegree().

Referenced by makeAtomExplicitDegreeQuery().

◆ queryAtomExplicitValence()

static int RDKit::queryAtomExplicitValence ( Atom const at)
inlinestatic

◆ queryAtomFormalCharge()

static int RDKit::queryAtomFormalCharge ( Atom const at)
inlinestatic

Definition at line 163 of file QueryOps.h.

References RDKit::Atom::getFormalCharge().

Referenced by makeAtomFormalChargeQuery().

◆ queryAtomHasAliphaticHeteroatomNbrs()

static int RDKit::queryAtomHasAliphaticHeteroatomNbrs ( Atom const at)
inlinestatic

◆ queryAtomHasChiralTag()

static int RDKit::queryAtomHasChiralTag ( Atom const at)
inlinestatic

Definition at line 175 of file QueryOps.h.

References RDKit::Atom::CHI_UNSPECIFIED, and RDKit::Atom::getChiralTag().

Referenced by makeAtomHasChiralTagQuery().

◆ queryAtomHasHeteroatomNbrs()

static int RDKit::queryAtomHasHeteroatomNbrs ( Atom const at)
inlinestatic

◆ queryAtomHasImplicitH()

static int RDKit::queryAtomHasImplicitH ( Atom const at)
inlinestatic

Definition at line 116 of file QueryOps.h.

References RDKit::Atom::getTotalNumHs(), and rdvalue_is().

Referenced by makeAtomHasImplicitHQuery().

◆ queryAtomHasRingBond()

◆ queryAtomHCount()

static int RDKit::queryAtomHCount ( Atom const at)
inlinestatic

Definition at line 110 of file QueryOps.h.

References RDKit::Atom::getTotalNumHs().

Referenced by makeAtomHCountQuery().

◆ queryAtomHeavyAtomDegree()

static int RDKit::queryAtomHeavyAtomDegree ( Atom const at)
inlinestatic

D and T are not treated as heavy atoms here.

Definition at line 98 of file QueryOps.h.

References RDKit::ROMol::getAtomNeighbors(), RDKit::Atom::getOwningMol(), and rdvalue_is().

Referenced by makeAtomHeavyAtomDegreeQuery().

◆ queryAtomHybridization()

static int RDKit::queryAtomHybridization ( Atom const at)
inlinestatic

Definition at line 169 of file QueryOps.h.

References RDKit::Atom::getHybridization().

Referenced by makeAtomHybridizationQuery().

◆ queryAtomImplicitHCount()

static int RDKit::queryAtomImplicitHCount ( Atom const at)
inlinestatic

Definition at line 113 of file QueryOps.h.

References RDKit::Atom::getTotalNumHs().

Referenced by makeAtomImplicitHCountQuery().

◆ queryAtomImplicitValence()

static int RDKit::queryAtomImplicitValence ( Atom const at)
inlinestatic

Definition at line 119 of file QueryOps.h.

References RDKit::Atom::getImplicitValence().

Referenced by makeAtomImplicitValenceQuery().

◆ queryAtomIsInRingOfSize()

template<int tgt>
int RDKit::queryAtomIsInRingOfSize ( Atom const at)

◆ queryAtomIsotope()

static int RDKit::queryAtomIsotope ( Atom const at)
inlinestatic

Definition at line 160 of file QueryOps.h.

References RDKit::Atom::getIsotope().

Referenced by makeAtomIsotopeQuery().

◆ queryAtomMass()

static int RDKit::queryAtomMass ( Atom const at)
inlinestatic

Definition at line 156 of file QueryOps.h.

References RDKit::Atom::getMass(), and massIntegerConversionFactor.

Referenced by makeAtomMassQuery().

◆ queryAtomMinRingSize()

static int RDKit::queryAtomMinRingSize ( Atom const at)
inlinestatic

◆ queryAtomMissingChiralTag()

static int RDKit::queryAtomMissingChiralTag ( Atom const at)
inlinestatic

◆ queryAtomNegativeFormalCharge()

static int RDKit::queryAtomNegativeFormalCharge ( Atom const at)
inlinestatic

Definition at line 166 of file QueryOps.h.

References RDKit::Atom::getFormalCharge().

Referenced by makeAtomNegativeFormalChargeQuery().

◆ queryAtomNonHydrogenDegree()

static int RDKit::queryAtomNonHydrogenDegree ( Atom const at)
inlinestatic

D and T are treated as "non-hydrogen" here.

Definition at line 85 of file QueryOps.h.

References RDKit::ROMol::getAtomNeighbors(), RDKit::Atom::getOwningMol(), and rdvalue_is().

Referenced by makeAtomNonHydrogenDegreeQuery().

◆ queryAtomNum()

static int RDKit::queryAtomNum ( Atom const at)
inlinestatic

Definition at line 131 of file QueryOps.h.

References RDKit::Atom::getAtomicNum().

Referenced by makeAtomNumQuery().

◆ queryAtomNumAliphaticHeteroatomNbrs()

static int RDKit::queryAtomNumAliphaticHeteroatomNbrs ( Atom const at)
inlinestatic

◆ queryAtomNumHeteroatomNbrs()

static int RDKit::queryAtomNumHeteroatomNbrs ( Atom const at)
inlinestatic

◆ queryAtomNumRadicalElectrons()

static int RDKit::queryAtomNumRadicalElectrons ( Atom const at)
inlinestatic

Definition at line 172 of file QueryOps.h.

References RDKit::Atom::getNumRadicalElectrons().

Referenced by makeAtomNumRadicalElectronsQuery().

◆ queryAtomRingBondCount()

◆ queryAtomRingMembership()

◆ queryAtomTotalDegree()

static int RDKit::queryAtomTotalDegree ( Atom const at)
inlinestatic

Definition at line 81 of file QueryOps.h.

References RDKit::Atom::getTotalDegree().

Referenced by makeAtomTotalDegreeQuery().

◆ queryAtomTotalValence()

static int RDKit::queryAtomTotalValence ( Atom const at)
inlinestatic

Definition at line 125 of file QueryOps.h.

References RDKit::Atom::getTotalValence().

Referenced by makeAtomTotalValenceQuery().

◆ queryAtomType()

static int RDKit::queryAtomType ( Atom const at)
inlinestatic

Definition at line 152 of file QueryOps.h.

References RDKit::Atom::getAtomicNum(), RDKit::Atom::getIsAromatic(), and makeAtomType().

Referenced by makeAtomTypeQuery().

◆ queryAtomUnsaturated()

static int RDKit::queryAtomUnsaturated ( Atom const at)
inlinestatic

Definition at line 128 of file QueryOps.h.

References RDKit::Atom::getTotalDegree(), and RDKit::Atom::getTotalValence().

Referenced by makeAtomUnsaturatedQuery().

◆ queryBondDir()

static int RDKit::queryBondDir ( Bond const bond)
inlinestatic

Definition at line 265 of file QueryOps.h.

References RDKit::Bond::getBondDir().

◆ queryBondHasStereo()

static int RDKit::queryBondHasStereo ( Bond const bnd)
inlinestatic

Definition at line 271 of file QueryOps.h.

References rdvalue_is(), and RDKit::Bond::STEREONONE.

◆ queryBondIsDoubleOrAromatic()

static int RDKit::queryBondIsDoubleOrAromatic ( Bond const bond)
inlinestatic

◆ queryBondIsInRingOfSize()

template<int tgt>
int RDKit::queryBondIsInRingOfSize ( Bond const bond)

◆ queryBondIsSingleOrAromatic()

static int RDKit::queryBondIsSingleOrAromatic ( Bond const bond)
inlinestatic

◆ queryBondIsSingleOrDouble()

static int RDKit::queryBondIsSingleOrDouble ( Bond const bond)
inlinestatic

Definition at line 256 of file QueryOps.h.

References RDKit::Bond::DOUBLE, RDKit::Bond::getBondType(), and RDKit::Bond::SINGLE.

◆ queryBondIsSingleOrDoubleOrAromatic()

static int RDKit::queryBondIsSingleOrDoubleOrAromatic ( Bond const bond)
inlinestatic

◆ queryBondMinRingSize()

static int RDKit::queryBondMinRingSize ( Bond const bond)
inlinestatic

◆ queryBondOrder()

static int RDKit::queryBondOrder ( Bond const bond)
inlinestatic

Definition at line 245 of file QueryOps.h.

References RDKit::Bond::getBondType().

◆ queryIsAtomBridgehead()

RDKIT_GRAPHMOL_EXPORT int RDKit::queryIsAtomBridgehead ( Atom const at)

◆ queryIsAtomInNRings()

static int RDKit::queryIsAtomInNRings ( Atom const at)
inlinestatic

◆ queryIsAtomInRing()

static int RDKit::queryIsAtomInRing ( Atom const at)
inlinestatic

◆ queryIsBondInNRings()

static int RDKit::queryIsBondInNRings ( Bond const at)
inlinestatic

◆ queryIsBondInRing()

static int RDKit::queryIsBondInRing ( Bond const bond)
inlinestatic

◆ rdany_cast() [1/2]

template<class T >
const T RDKit::rdany_cast ( const RDAny d)

Definition at line 179 of file RDAny.h.

References RDKit::RDAny::m_value, and rdvalue_is().

◆ rdany_cast() [2/2]

template<class T >
T RDKit::rdany_cast ( RDAny d)

Definition at line 185 of file RDAny.h.

References RDKit::RDAny::m_value, and rdvalue_is().

◆ RDKFingerprintMol()

RDKIT_FINGERPRINTS_EXPORT ExplicitBitVect * RDKit::RDKFingerprintMol ( const ROMol mol,
unsigned int  minPath = 1,
unsigned int  maxPath = 7,
unsigned int  fpSize = 2048,
unsigned int  nBitsPerHash = 2,
bool  useHs = true,
double  tgtDensity = 0.0,
unsigned int  minSize = 128,
bool  branchedPaths = true,
bool  useBondOrder = true,
std::vector< std::uint32_t > *  atomInvariants = nullptr,
const std::vector< std::uint32_t > *  fromAtoms = nullptr,
std::vector< std::vector< std::uint32_t > > *  atomBits = nullptr,
std::map< std::uint32_t, std::vector< std::vector< int > > > *  bitInfo = nullptr 
)

Generates a topological (Daylight like) fingerprint for a molecule using an alternate (faster) hashing algorithm.

Parameters
molthe molecule to be fingerprinted
minPaththe minimum path length (in bonds) to be included
maxPaththe minimum path length (in bonds) to be included
fpSizethe size of the fingerprint
nBitsPerHashthe number of bits to be set by each path
useHstoggles inclusion of Hs in paths (if the molecule has explicit Hs)
tgtDensityif the generated fingerprint is below this density, it will be folded until the density is reached.
minSizethe minimum size to which the fingerprint will be folded
branchedPathstoggles generation of branched subgraphs, not just linear paths
useBondOrderstoggles inclusion of bond orders in the path hashes
atomInvariantsa vector of atom invariants to use while hashing the paths
fromAtomsonly paths starting at these atoms will be included
atomBitsused to return the bits that each atom is involved in (should be at least mol.numAtoms long)
Returns
the molecular fingerprint, as an ExplicitBitVect

Notes:

  • the caller is responsible for deleteing the result

◆ RDKitSVGToMol() [1/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::RDKitSVGToMol ( const std::string &  svg,
bool  sanitize = true,
bool  removeHs = true 
)
Parameters
svg- string containing the SVG
sanitize- toggles sanitization of the molecule
removeHs- toggles removal of Hs from the molecule. H removal is only done if the molecule is sanitized

NOTE This functionality should be considered beta.

References RDKitSVGToMol().

Referenced by RDKitSVGToMol(), and RDKitSVGToMol().

◆ RDKitSVGToMol() [2/2]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::RDKitSVGToMol ( std::istream *  instream,
bool  sanitize = true,
bool  removeHs = true 
)

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

References RDKitSVGToMol().

◆ rdvalue_cast()

template<class T >
T RDKit::rdvalue_cast ( RDValue_cast_t  v)
inline

◆ rdvalue_cast< bool >() [1/2]

template<>
bool RDKit::rdvalue_cast< bool > ( RDValue_cast_t  v)
inline

Definition at line 471 of file RDValue-doublemagic.h.

References RDKit::RDValue::otherBits, and rdvalue_is().

Referenced by rdvalue_tostring().

◆ rdvalue_cast< bool >() [2/2]

◆ rdvalue_cast< const std::any & >()

template<>
const std::any & RDKit::rdvalue_cast< const std::any & > ( RDValue_cast_t  v)
inline

Definition at line 166 of file RDValue.h.

References RDKit::RDValue::ptrCast(), and rdvalue_is< std::any >().

◆ rdvalue_cast< double >() [1/2]

template<>
double RDKit::rdvalue_cast< double > ( RDValue_cast_t  v)
inline

Definition at line 440 of file RDValue-doublemagic.h.

References RDKit::RDValue::doubleBits, and rdvalue_is< double >().

Referenced by rdvalue_tostring().

◆ rdvalue_cast< double >() [2/2]

◆ rdvalue_cast< float >() [1/2]

template<>
float RDKit::rdvalue_cast< float > ( RDValue_cast_t  v)
inline

Definition at line 446 of file RDValue-doublemagic.h.

References RDKit::RDValue::otherBits, and rdvalue_is().

Referenced by rdvalue_tostring().

◆ rdvalue_cast< float >() [2/2]

◆ rdvalue_cast< int >() [1/2]

template<>
int RDKit::rdvalue_cast< int > ( RDValue_cast_t  v)
inline

Definition at line 458 of file RDValue-doublemagic.h.

References RDKit::RDValue::otherBits, and rdvalue_is().

Referenced by rdvalue_tostring().

◆ rdvalue_cast< int >() [2/2]

◆ rdvalue_cast< std::any & >()

template<>
std::any & RDKit::rdvalue_cast< std::any & > ( RDValue_cast_t  v)
inline

Definition at line 158 of file RDValue.h.

References RDKit::RDValue::ptrCast(), and rdvalue_is< std::any >().

Referenced by rdvalue_tostring().

◆ rdvalue_cast< std::any >()

template<>
std::any RDKit::rdvalue_cast< std::any > ( RDValue_cast_t  v)
inline

Definition at line 150 of file RDValue.h.

References RDKit::RDValue::ptrCast(), and rdvalue_is< std::any >().

◆ rdvalue_cast< std::int16_t >()

template<>
std::int16_t RDKit::rdvalue_cast< std::int16_t > ( RDValue_cast_t  v)
inline

◆ rdvalue_cast< std::int64_t >()

◆ rdvalue_cast< std::int8_t >()

template<>
std::int8_t RDKit::rdvalue_cast< std::int8_t > ( RDValue_cast_t  v)
inline

◆ rdvalue_cast< std::string & >()

template<>
std::string & RDKit::rdvalue_cast< std::string & > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

References RDKit::RDValue::ptrCast(), and rdvalue_is().

◆ rdvalue_cast< std::string >()

template<>
std::string RDKit::rdvalue_cast< std::string > ( RDValue_cast_t  v)
inline

Definition at line 46 of file RDValue.h.

References RDKit::RDValue::ptrCast(), and rdvalue_is().

Referenced by from_rdvalue(), and rdvalue_tostring().

◆ rdvalue_cast< std::uint16_t >()

template<>
std::uint16_t RDKit::rdvalue_cast< std::uint16_t > ( RDValue_cast_t  v)
inline

◆ rdvalue_cast< std::uint64_t >()

◆ rdvalue_cast< std::uint8_t >()

template<>
std::uint8_t RDKit::rdvalue_cast< std::uint8_t > ( RDValue_cast_t  v)
inline

◆ rdvalue_cast< std::vector< double > & >()

template<>
std::vector< double > & RDKit::rdvalue_cast< std::vector< double > & > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< std::vector< double > >()

template<>
std::vector< double > RDKit::rdvalue_cast< std::vector< double > > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< std::vector< float > & >()

template<>
std::vector< float > & RDKit::rdvalue_cast< std::vector< float > & > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< std::vector< float > >()

template<>
std::vector< float > RDKit::rdvalue_cast< std::vector< float > > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< std::vector< int > & >()

template<>
std::vector< int > & RDKit::rdvalue_cast< std::vector< int > & > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< std::vector< int > >()

template<>
std::vector< int > RDKit::rdvalue_cast< std::vector< int > > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< std::vector< std::string > & >()

template<>
std::vector< std::string > & RDKit::rdvalue_cast< std::vector< std::string > & > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< std::vector< std::string > >()

template<>
std::vector< std::string > RDKit::rdvalue_cast< std::vector< std::string > > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< std::vector< unsigned int > & >()

template<>
std::vector< unsigned int > & RDKit::rdvalue_cast< std::vector< unsigned int > & > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< std::vector< unsigned int > >()

template<>
std::vector< unsigned int > RDKit::rdvalue_cast< std::vector< unsigned int > > ( RDValue_cast_t  v)
inline

Definition at line 54 of file RDValue.h.

◆ rdvalue_cast< unsigned int >() [1/2]

Definition at line 464 of file RDValue-doublemagic.h.

References RDKit::RDValue::otherBits, and rdvalue_is().

Referenced by rdvalue_tostring().

◆ rdvalue_cast< unsigned int >() [2/2]

◆ rdvalue_is()

template<class T >
bool RDKit::rdvalue_is ( const RDValue_cast_t  v)
inline

Definition at line 372 of file RDValue-doublemagic.h.

References RDKit::RDTypeTag::AnyTag, and rdvalue_is().

Referenced by RDKit::FMCS::DuplicatedSeedCache::add(), RDKit::CIPLabeler::Rules::add(), RDKit::CIPLabeler::PairList::addAll(), RDKit::FMCS::DuplicatedSeedCache::TKey::addAtom(), RDKit::MolDraw2D_detail::addAtomIndices(), RDKit::SLNParse::addAtomToMol(), RDKit::SLNParse::addAtomToMol(), RDKit::FMCS::DuplicatedSeedCache::TKey::addBond(), RDKit::MolDraw2D_detail::addBondIndices(), RDKit::SLNParse::addBranchToMol(), RDKit::SLNParse::addBranchToMol(), RDKit::SLNParse::addFragToMol(), addMetadataToPNGFile(), addMetadataToPNGString(), RDKit::MolBundle::addMol(), RDKit::FixedMolSizeMolBundle::addMol(), addMolToPNGFile(), addMolToPNGString(), appendPackedIntToStream(), RDKit::FileParserUtils::applyMolListPropsToAtoms(), RDKit::FileParserUtils::applyMolListPropToAtoms(), assignAvalonPalette(), assignBWPalette(), assignCDKPalette(), assignDarkModePalette(), assignDefaultPalette(), RDKit::Canon::BreakTies(), RDKit::MolDraw2D_detail::StringRect::calcCentre(), RDKit::MolDraw2D_detail::StringRect::calcCorners(), RDKit::DataStructsExplicitBitVecPropHandler::canSerialize(), checkForTimeout(), RDKit::RDValue::cleanup_rdvalue(), RDKit::RDProps::clearComputedProps(), RDKit::RDProps::clearProp(), RDKit::SLNParse::closeRingBond(), RDKit::SLNParse::closeRingBond(), RDKit::CIPLabeler::Rules::compare(), RDKit::CIPLabeler::PairList::compareTo(), RDKit::MolDraw2DUtils::contourAndDrawGaussians(), RDKit::MolDraw2DUtils::contourAndDrawGrid(), RDKit::SLNParse::convertToString(), RDKit::HasPropQuery< TargetPtr >::copy(), RDKit::HasPropWithValueQuery< TargetPtr, T >::copy(), RDKit::HasPropWithValueQuery< TargetPtr, std::string >::copy(), RDKit::HasPropWithValueQuery< TargetPtr, ExplicitBitVect >::copy(), copy_rdvalue(), countSwapsToInterconvert(), RDKit::FileParserUtils::createAtomBoolPropertyList(), RDKit::FileParserUtils::createAtomDoublePropertyList(), RDKit::FileParserUtils::createAtomIntPropertyList(), RDKit::FileParserUtils::createAtomStringPropertyList(), RDKit::ScaffoldNetwork::createScaffoldNetwork(), describeQuery(), describeQuery(), RDKit::RDValue::destroy(), RDKit::GeneralMolSupplier::determineFormat(), DiceSimilarity(), Dict::getVal< std::string >(), RDKit::MolDraw2D_detail::StringRect::doesItIntersect(), RDKit::DGeomHelpers::EmbedMolecule(), RDKit::DGeomHelpers::EmbedMultipleConfs(), RDKit::DGeomHelpers::EmbedMultipleConfs(), RDKit::DGeomHelpers::EmbedMultipleConfs(), EndianSwapBytes(), eraseUniquePtr(), RDKit::DrawColour::feq(), RDKit::FMCS::DuplicatedSeedCache::find(), findUniquePtr(), RDKit::SGroupWriting::FormatV2000DoubleField(), RDKit::SGroupWriting::FormatV2000IntField(), RDKit::SGroupWriting::FormatV2000NumEntriesField(), RDKit::SGroupWriting::FormatV2000StringField(), RDKit::MolStandardize::fragmentRemoverFromParams(), from_rdany(), from_rdvalue(), RDKit::SparseIntVect< IndexType >::fromString(), RDKit::FMCS::Composition2N::generateNext(), RDKit::FileParserUtils::getAtomPropertyList(), RDKit::CIPLabeler::Rules::getComparision(), getLine(), getLine(), RDKit::MolEnumerator::utils::getMolLinkNodes(), getNumThreadsToUse(), RDKit::RDProps::getProp(), RDKit::RDProps::getPropIfPresent(), RDKit::RDProps::getPropList(), RDKit::GeneralMolSupplier::getSupplier(), RDKit::RDValue::getTag(), RDKit::SparseIntVect< IndexType >::getTotalVal(), RDKit::MolStandardize::getV1TautomerEnumerator(), RDKit::SparseIntVect< IndexType >::getVal(), hanoi(), hanoisort(), RDKit::MHFPFingerprints::FNV::hash(), RDKit::GeneralizedSubstruct::hasSubstructMatch(), RDKit::CartesianProduct::increment(), RDKit::FMCS::TargetMatch::init(), RDKit::MolBundle::initFromStream(), RDKit::MolBundle::initFromString(), RDKit::FMCS::Composition2N::is2Power(), RDKit::MolDraw2D_detail::StringRect::isPointInside(), RDKit::FMCS::Composition2N::isSet(), makeAtomAliphaticQuery(), makeAtomAromaticQuery(), makeAtomExplicitDegreeQuery(), makeAtomExplicitValenceQuery(), makeAtomFormalChargeQuery(), makeAtomHasAliphaticHeteroatomNbrsQuery(), makeAtomHasChiralTagQuery(), makeAtomHasHeteroatomNbrsQuery(), makeAtomHasImplicitHQuery(), makeAtomHasRingBondQuery(), makeAtomHCountQuery(), makeAtomHeavyAtomDegreeQuery(), makeAtomHybridizationQuery(), makeAtomImplicitHCountQuery(), makeAtomImplicitValenceQuery(), makeAtomInNRingsQuery(), makeAtomInRingQuery(), makeAtomIsBridgeheadQuery(), makeAtomIsotopeQuery(), makeAtomMassQuery(), makeAtomMinRingSizeQuery(), makeAtomMissingChiralTagQuery(), makeAtomNegativeFormalChargeQuery(), makeAtomNonHydrogenDegreeQuery(), makeAtomNumAliphaticHeteroatomNbrsQuery(), makeAtomNumHeteroatomNbrsQuery(), makeAtomNumQuery(), makeAtomNumRadicalElectronsQuery(), makeAtomRangeQuery(), makeAtomRingBondCountQuery(), makeAtomSimpleQuery(), makeAtomTotalDegreeQuery(), makeAtomTotalValenceQuery(), makeAtomType(), makeAtomTypeQuery(), makeAtomUnsaturatedQuery(), makeHasPropQuery(), RDKit::Descriptors::makePropertyQuery(), makePropQuery(), makePropQuery(), RDKit::HasPropQuery< TargetPtr >::Match(), RDKit::HasPropWithValueQuery< TargetPtr, T >::Match(), RDKit::HasPropWithValueQuery< TargetPtr, std::string >::Match(), RDKit::HasPropWithValueQuery< TargetPtr, ExplicitBitVect >::Match(), mergeNullQueries(), RDKit::MMFF::MMFFOptimizeMolecule(), RDKit::MMFF::MMFFOptimizeMoleculeConfs(), RDKit::MolBundle::MolBundle(), RDKit::MolBundle::MolBundle(), MolFragmentToCXSmiles(), MolFragmentToSmiles(), MolToCXSmiles(), RDKit::MolInterchange::MolToJSONData(), MolToSmiles(), RDKit::CIPLabeler::CIPMolSpan< T, U >::CIPMolIter::operator!=(), RDKit::CXXAtomIterator< Graph, Vertex, Iterator >::CXXAtomIter::operator!=(), RDKit::CXXBondIterator< Graph, Edge, Iterator >::CXXBondIter::operator!=(), RDKit::DrawColour::operator!=(), RDKit::SparseIntVect< IndexType >::operator!=(), RDKit::SparseIntVect< IndexType >::operator&(), RDKit::SparseIntVect< IndexType >::operator&=(), RDKit::SparseIntVect< IndexType >::operator*(), RDKit::SparseIntVect< IndexType >::operator*=(), RDKit::DrawColour::operator+(), RDKit::SparseIntVect< IndexType >::operator+(), RDKit::SparseIntVect< IndexType >::operator+(), RDKit::SparseIntVect< IndexType >::operator+=(), RDKit::SparseIntVect< IndexType >::operator+=(), RDKit::DrawColour::operator-(), RDKit::SparseIntVect< IndexType >::operator-(), RDKit::SparseIntVect< IndexType >::operator-(), RDKit::SparseIntVect< IndexType >::operator-=(), RDKit::SparseIntVect< IndexType >::operator-=(), RDKit::SparseIntVect< IndexType >::operator/(), RDKit::SparseIntVect< IndexType >::operator/=(), RDKit::CIPLabeler::PairList::operator<(), RDKit::FMCS::DuplicatedSeedCache::TKey::operator<(), RDKit::ScaffoldNetwork::operator<<(), RDKit::ScaffoldNetwork::operator<<(), RDKit::RDAny::operator=(), RDKit::RDProps::operator=(), RDKit::SparseIntVect< IndexType >::operator=(), RDKit::FMCS::TargetMatch::operator=(), RDKit::CXXAtomIterator< Graph, Vertex, Iterator >::CXXAtomIter::operator==(), RDKit::CXXBondIterator< Graph, Edge, Iterator >::CXXBondIter::operator==(), RDKit::DrawColour::operator==(), RDKit::SparseIntVect< IndexType >::operator==(), RDKit::FMCS::DuplicatedSeedCache::TKey::operator==(), RDKit::SparseIntVect< IndexType >::operator|(), RDKit::SparseIntVect< IndexType >::operator|=(), RDKit::ForceFieldsHelper::OptimizeMolecule(), RDKit::ForceFieldsHelper::OptimizeMoleculeConfs(), RDKit::ForceFieldsHelper::detail::OptimizeMoleculeConfsST(), RDKit::CIPLabeler::PairList::PairList(), RDKit::CIPLabeler::Configuration::parity4(), parseAtomType(), RDKit::SGroupParsing::ParseV3000Array(), PNGFileToMetadata(), PNGFileToMol(), PNGFileToMols(), PNGStringToMetadata(), PNGStringToMol(), PNGStringToMols(), RDKit::FileParserUtils::processMolPropertyList(), RDKit::FileParserUtils::processMolPropertyLists(), RDKit::RDValue::ptrCast(), pullPackedIntFromString(), RDKit::detail::qhelper(), queryAtomHasAliphaticHeteroatomNbrs(), queryAtomHasHeteroatomNbrs(), queryAtomHasImplicitH(), queryAtomHeavyAtomDegree(), queryAtomIsInRingOfSize(), queryAtomNonHydrogenDegree(), queryAtomNumAliphaticHeteroatomNbrs(), queryAtomNumHeteroatomNbrs(), queryAtomRingBondCount(), queryBondHasStereo(), queryBondIsInRingOfSize(), RDKit::Canon::rankFragmentAtoms(), RDKit::RDAny::RDAny(), rdany_cast(), rdany_cast(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), RDKit::RDValue::RDValue(), rdvalue_cast(), rdvalue_cast< bool >(), rdvalue_cast< double >(), rdvalue_cast< float >(), rdvalue_cast< int >(), rdvalue_cast< std::int16_t >(), rdvalue_cast< std::int64_t >(), rdvalue_cast< std::int8_t >(), rdvalue_cast< std::string & >(), rdvalue_cast< std::string >(), rdvalue_cast< std::uint16_t >(), rdvalue_cast< std::uint64_t >(), rdvalue_cast< std::uint8_t >(), rdvalue_cast< unsigned int >(), rdvalue_is(), rdvalue_is< std::any >(), rdvalue_tostring(), RDKit::DataStructsExplicitBitVecPropHandler::read(), readPackedIntFromStream(), readRDStringVecValue(), readRDValue(), readRDValueString(), readRDVecValue(), RDKit::Canon::RefinePartitions(), RDKit::CIPLabeler::Rules::Rules(), RDKit::MolBundle::serialize(), setDarkMode(), setDarkMode(), setMonochromeMode(), setMonochromeMode(), RDKit::RDProps::setProp(), RDKit::SparseIntVect< IndexType >::setVal(), RDKit::SGroupParsing::SGroupWarnOrThrow(), SmartsToMol(), SmilesToMol(), RDKit::SparseIntVect< IndexType >::SparseIntVect(), RDKit::SparseIntVect< IndexType >::SparseIntVect(), RDKit::SparseIntVect< IndexType >::SparseIntVect(), RDKit::SLNParse::startMol(), streamRead(), streamRead(), streamRead(), streamReadStringVec(), streamReadVec(), streamWrite(), streamWrite(), streamWriteVec(), RDKit::FileParserUtils::strip(), RDKit::FileParserUtils::stripSpacesAndCast(), RDKit::FileParserUtils::stripSpacesAndCast(), SubstructMatch(), SubstructMatch(), SubstructMatch(), SubstructMatch(), SwapBytes(), TanimotoSimilarity(), RDKit::FMCS::TargetMatch::TargetMatch(), RDKit::CIPLabeler::to_string(), RDKit::MolBundle::toStream(), RDKit::SparseIntVect< IndexType >::toString(), RDKit::CIPLabeler::PairList::toString(), RDKit::RGroupMatch::toString(), TverskySimilarity(), RDKit::UFF::UFFOptimizeMolecule(), RDKit::UFF::UFFOptimizeMoleculeConfs(), updateFromSequence(), RDKit::RDProps::updateProps(), RDKit::UsedLabelMap::UsedLabelMap(), vectToString(), RDKit::DataStructsExplicitBitVecPropHandler::write(), and RDKit::CIPLabeler::Rules::~Rules().

◆ rdvalue_is< const double & >()

template<>
bool RDKit::rdvalue_is< const double & > ( const RDValue_cast_t  )
inline

Definition at line 392 of file RDValue-doublemagic.h.

References rdvalue_is< double >().

◆ rdvalue_is< double >()

◆ rdvalue_is< std::any >()

◆ rdvalue_tostring()

◆ readAmberTrajectory()

RDKIT_TRAJECTORY_EXPORT unsigned int RDKit::readAmberTrajectory ( const std::string &  fName,
Trajectory traj 
)

Reads coordinates from an AMBER trajectory file into the traj Trajectory object.

Returns
the number of Snapshot objects read in

◆ readFuncGroups() [1/2]

RDKIT_FRAGCATALOG_EXPORT MOL_SPTR_VECT RDKit::readFuncGroups ( std::istream &  inStream,
int  nToRead = -1 
)

◆ readFuncGroups() [2/2]

RDKIT_FRAGCATALOG_EXPORT MOL_SPTR_VECT RDKit::readFuncGroups ( std::string  fileName)

◆ readGromosTrajectory()

RDKIT_TRAJECTORY_EXPORT unsigned int RDKit::readGromosTrajectory ( const std::string &  fName,
Trajectory traj 
)

Reads coordinates from a GROMOS trajectory file into the traj Trajectory object.

Returns
the number of Snapshot objects read in

◆ readPackedIntFromStream()

boost::uint32_t RDKit::readPackedIntFromStream ( std::stringstream &  ss)
inline

Reads an integer from a stream in packed format and returns the result.

Definition at line 150 of file StreamOps.h.

References rdvalue_is().

◆ readRDStringVecValue()

void RDKit::readRDStringVecValue ( std::istream &  ss,
RDValue value 
)
inline

Definition at line 549 of file StreamOps.h.

References rdvalue_is(), and streamReadStringVec().

◆ readRDValue()

template<class T >
void RDKit::readRDValue ( std::istream &  ss,
RDValue value 
)

Definition at line 529 of file StreamOps.h.

References rdvalue_is(), and streamRead().

◆ readRDValueString()

void RDKit::readRDValueString ( std::istream &  ss,
RDValue value 
)
inline

Definition at line 542 of file StreamOps.h.

References rdvalue_is(), and streamRead().

◆ readRDVecValue()

template<class T >
void RDKit::readRDVecValue ( std::istream &  ss,
RDValue value 
)

Definition at line 536 of file StreamOps.h.

References rdvalue_is(), and streamReadVec().

◆ reapplyMolBlockWedging()

RDKIT_FILEPARSERS_EXPORT void RDKit::reapplyMolBlockWedging ( ROMol mol)

◆ reduceProductToSideChains()

RDKIT_CHEMREACTIONS_EXPORT ROMol * RDKit::reduceProductToSideChains ( const ROMOL_SPTR product,
bool  addDummyAtoms = true 
)

Reduce the product generated by run_Reactants or run_Reactant to the sidechains that come from the reagents

Parameters
addDummyAtomsIf true, add dummy atoms to the sidechains for the non-reagent parts of the sidechain. Dummy atoms are annotated with the atom maps from the reaction. If False, then any sidechain atom where a bond was cleaved is annotated with: _rgroupAtomMaps property which indicates the scaffold atommaps that where bonded _rgroupBonds property which indicates the bondtype for each atommap bonded

◆ relabelMappedDummies()

RDKIT_RGROUPDECOMPOSITION_EXPORT void RDKit::relabelMappedDummies ( ROMol mol,
unsigned int  inputLabels = AtomMap|Isotope|MDLRGroup,
unsigned int  outputLabels = MDLRGroup 
)

Relabel dummy atoms bearing an R-group mapping (as atom map number, isotope or MDLRGroup label) such that they will be displayed by the rendering code as R# rather than #*, *:#, #*:#, etc. By default, only the MDLRGroup label is retained on output; this may be configured through the outputLabels parameter. In case there are multiple potential R-group mappings, the priority on input is Atom map number > Isotope > MDLRGroup. The inputLabels parameter allows to configure which mappings are taken into consideration.

◆ removeDuplicates()

RDKIT_SUBSTRUCTMATCH_EXPORT void RDKit::removeDuplicates ( std::vector< MatchVectType > &  v,
unsigned int  nAtoms 
)

◆ removeGroupsWithAtom()

RDKIT_GRAPHMOL_EXPORT void RDKit::removeGroupsWithAtom ( const Atom atom,
std::vector< StereoGroup > &  groups 
)

◆ removeGroupsWithAtoms()

RDKIT_GRAPHMOL_EXPORT void RDKit::removeGroupsWithAtoms ( const std::vector< Atom * > &  atoms,
std::vector< StereoGroup > &  groups 
)

◆ removeMappingNumbersFromReactions()

RDKIT_CHEMREACTIONS_EXPORT void RDKit::removeMappingNumbersFromReactions ( const ChemicalReaction rxn)

◆ removeNonmatchingReagents()

Helper function, remove reagents that are incompatible with the reaction. rxn must be sanitized, initialized and preprocessed. this happens automatically in EnumerateLibrary

◆ removeSubstanceGroupsReferencingAtom()

RDKIT_GRAPHMOL_EXPORT void RDKit::removeSubstanceGroupsReferencingAtom ( RWMol mol,
unsigned int  idx 
)

Removes SubstanceGroups which reference a particular atom index.

Parameters
mol- molecule to be edited.
idx- atom index

◆ removeSubstanceGroupsReferencingBond()

RDKIT_GRAPHMOL_EXPORT void RDKit::removeSubstanceGroupsReferencingBond ( RWMol mol,
unsigned int  idx 
)

Removes SubstanceGroups which reference a particular bond index.

Parameters
mol- molecule to be edited.
idx- bond index

◆ replaceCore() [1/2]

RDKIT_CHEMTRANSFORMS_EXPORT ROMol * RDKit::replaceCore ( const ROMol mol,
const ROMol core,
const MatchVectType matchVect,
bool  replaceDummies = true,
bool  labelByIndex = false,
bool  requireDummyMatch = false 
)

Returns a copy of an ROMol with the atoms and bonds that are referenced by the MatchVector removed. MatchVector must be defined between mol and the specified core.

dummy atoms are left to indicate attachment points. These dummy atoms can be labeled either by the matching index in the query or by an arbitrary "first match" found. Additional matching options are given below.

Note that this is essentially identical to the replaceSidechains function, except we invert the query and replace the atoms that do match the query.

Parameters
mol- the ROMol of interest
core- the core being matched against
matchVect- a matchVect of the type returned by Substructure Matching
replaceDummies- if set, atoms matching dummies in the core will also be replaced
labelByIndex- if set, the dummy atoms at attachment points are labelled with the index+1 of the corresponding atom in the core
requireDummyMatch- if set, only side chains that are connected to atoms in the core that have attached dummies will be considered. Molecules that have sidechains that are attached at other points will be rejected (NULL returned).
useChirality- if set, match the coreQuery using chirality
Returns
a copy of mol with the non-matching atoms and bonds (if any) removed and dummies at the connection points. The client is responsible for deleting this molecule. If the core query is not matched, NULL is returned.

◆ replaceCore() [2/2]

RDKIT_CHEMTRANSFORMS_EXPORT ROMol * RDKit::replaceCore ( const ROMol mol,
const ROMol coreQuery,
bool  replaceDummies = true,
bool  labelByIndex = false,
bool  requireDummyMatch = false,
bool  useChirality = false 
)

Returns a copy of an ROMol with the atoms and bonds that do fall within a substructure match removed.

dummy atoms are left to indicate attachment points.

Note that this is essentially identical to the replaceSidechains function, except we invert the query and replace the atoms that do match the query.

Parameters
mol- the ROMol of interest
coreQuery- a query ROMol to be used to match the core
replaceDummies- if set, atoms matching dummies in the core will also be replaced
labelByIndex- if set, the dummy atoms at attachment points are labelled with the index+1 of the corresponding atom in the core
requireDummyMatch- if set, only side chains that are connected to atoms in the core that have attached dummies will be considered. Molecules that have sidechains that are attached at other points will be rejected (NULL returned).
useChirality- if set, match the coreQuery using chirality
Returns
a copy of mol with the non-matching atoms and bonds (if any) removed and dummies at the connection points. The client is responsible for deleting this molecule. If the core query is not matched, NULL is returned.

◆ replaceSidechains()

RDKIT_CHEMTRANSFORMS_EXPORT ROMol * RDKit::replaceSidechains ( const ROMol mol,
const ROMol coreQuery,
bool  useChirality = false 
)

Returns a copy of an ROMol with the atoms and bonds that don't fall within a substructure match removed.

dummy atoms are left to indicate attachment points.

Parameters
molthe ROMol of interest
coreQuerya query ROMol to be used to match the core
useChirality- if set, match the coreQuery using chirality
Returns
a copy of mol with the non-matching atoms and bonds (if any) removed and dummies at the connection points.

◆ replaceSubstructs()

RDKIT_CHEMTRANSFORMS_EXPORT std::vector< ROMOL_SPTR > RDKit::replaceSubstructs ( const ROMol mol,
const ROMol query,
const ROMol replacement,
bool  replaceAll = false,
unsigned int  replacementConnectionPoint = 0,
bool  useChirality = false 
)

Returns a list of copies of an ROMol with the atoms and bonds that match a pattern replaced with the atoms contained in another molecule.

Bonds are created between the joining atom in the existing molecule and the atoms in the new molecule. So, using SMILES instead of molecules: replaceSubstructs('OC(=O)NCCNC(=O)O','C(=O)O','[X]') -> ['[X]NCCNC(=O)O','OC(=O)NCCN[X]'] replaceSubstructs('OC(=O)NCCNC(=O)O','C(=O)O','[X]',true) -> ['[X]NCCN[X]'] Chains should be handled "correctly": replaceSubstructs('CC(=O)C','C(=O)','[X]') -> ['C[X]C'] As should rings: replaceSubstructs('C1C(=O)C1','C(=O)','[X]') -> ['C1[X]C1'] And higher order branches: replaceSubstructs('CC(=O)(C)C','C(=O)','[X]') -> ['C[X](C)C'] Note that the client is responsible for making sure that the resulting molecule actually makes sense - this function does not perform sanitization.

Parameters
molthe ROMol of interest
querythe query ROMol
replacementthe ROMol to be inserted
replaceAllif this is true, only a single result, with all
useChirality- if set, match the coreQuery using chirality

occurrences of the substructure replaced, will be returned.

Parameters
replacementConnectionPointindex of the atom in the replacement that the bond should made to
Returns
a vector of pointers to copies of mol with the matching atoms and bonds (if any) replaced

◆ RGroupDecompose() [1/2]

RDKIT_RGROUPDECOMPOSITION_EXPORT unsigned int RDKit::RGroupDecompose ( const std::vector< ROMOL_SPTR > &  cores,
const std::vector< ROMOL_SPTR > &  mols,
RGroupColumns columns,
std::vector< unsigned int > *  unmatched = nullptr,
const RGroupDecompositionParameters options = RGroupDecompositionParameters() 
)

◆ RGroupDecompose() [2/2]

RDKIT_RGROUPDECOMPOSITION_EXPORT unsigned int RDKit::RGroupDecompose ( const std::vector< ROMOL_SPTR > &  cores,
const std::vector< ROMOL_SPTR > &  mols,
RGroupRows rows,
std::vector< unsigned int > *  unmatched = nullptr,
const RGroupDecompositionParameters options = RGroupDecompositionParameters() 
)

◆ run_Reactant() [1/2]

RDKIT_CHEMREACTIONS_EXPORT std::vector< MOL_SPTR_VECT > RDKit::run_Reactant ( const ChemicalReaction rxn,
const ROMOL_SPTR reactant,
unsigned int  reactantIdx 
)

Runs a single reactant against a single reactant template.

Parameters
reactantThe single reactant to use
reactantTemplateIdxthe reactant template to target in the reaction
Returns
a vector of vectors of products. Each subvector will be rxn->getNumProductTemplates() long.

We return a vector of vectors of products because each individual template may map multiple times onto its reactant. This leads to multiple possible result sets.

◆ run_Reactant() [2/2]

RDKIT_CHEMREACTIONS_EXPORT bool RDKit::run_Reactant ( const ChemicalReaction rxn,
RWMol reactant,
bool  removeUnmatchedAtoms = true 
)

◆ run_Reactants()

RDKIT_CHEMREACTIONS_EXPORT std::vector< MOL_SPTR_VECT > RDKit::run_Reactants ( const ChemicalReaction rxn,
const MOL_SPTR_VECT reactants,
unsigned int  maxProducts = 1000 
)

Runs the reaction on a set of reactants.

Parameters
rxnthe template reaction we are interested
reactantsthe reactants to be used. The length of this must be equal to rxn->getNumReactantTemplates() Caution: The order of the reactant templates determines the order of the reactants!
maxProductsif non zero, the maximum number of products to generate before stopping. If hit a warning will be generated.
Returns
a vector of vectors of products. Each subvector will be rxn->getNumProductTemplates() long.

We return a vector of vectors of products because each individual template may map multiple times onto its reactant. This leads to multiple possible result sets.

◆ RunFilterCatalog()

RDKIT_FILTERCATALOG_EXPORT std::vector< std::vector< boost::shared_ptr< const FilterCatalogEntry > > > RDKit::RunFilterCatalog ( const FilterCatalog filterCatalog,
const std::vector< std::string > &  smiles,
int  numThreads = 1 
)

Run a filter catalog on a set of smiles strings.

◆ RxnBlockToChemicalReaction()

RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction * RDKit::RxnBlockToChemicalReaction ( const std::string &  rxnBlock,
bool  sanitize = false,
bool  removeHs = false,
bool  strictParsing = true 
)

Parse a text block in MDL rxn format into a ChemicalReaction.

◆ RxnDataStreamToChemicalReaction()

RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction * RDKit::RxnDataStreamToChemicalReaction ( std::istream &  rxnStream,
unsigned int line,
bool  sanitize = false,
bool  removeHs = false,
bool  strictParsing = true 
)

Parse a text stream in MDL rxn format into a ChemicalReaction.

◆ RxnFileToChemicalReaction()

RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction * RDKit::RxnFileToChemicalReaction ( const std::string &  fileName,
bool  sanitize = false,
bool  removeHs = false,
bool  strictParsing = true 
)

Parse a file in MDL rxn format into a ChemicalReaction.

◆ RxnMolToChemicalReaction()

RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction * RDKit::RxnMolToChemicalReaction ( const ROMol mol)

Parse a ROMol into a ChemicalReaction, RXN role must be set before.

Alternative to build a reaction from a molecule (fragments) which have RXN roles set as atom properties: common_properties::molRxnRole (1=reactant, 2=product, 3=agent)

Parameters
molROMol with RXN roles set

◆ RxnSmartsToChemicalReaction()

RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction * RDKit::RxnSmartsToChemicalReaction ( const std::string &  text,
std::map< std::string, std::string > *  replacements = nullptr,
bool  useSmiles = false,
bool  allowCXSMILES = true 
)

Parse a string containing "Reaction SMARTS" into a ChemicalReaction.

Our definition of Reaction SMARTS is something that looks a lot like reaction SMILES, except that SMARTS queries are allowed on the reactant side and that atom-map numbers are required (at least for now)

Parameters
textthe SMARTS to convert
replacementsa string->string map of replacement strings.
See also
SmilesToMol for more information about replacements
Parameters
useSmilesif set, the SMILES parser will be used instead of the SMARTS parserfor the individual components
allowCXSMILESif set, any CXSMILES extensions present will be parsed, otherwise it will be ignored

Referenced by operator""_rxnsmarts(), and operator""_rxnsmiles().

◆ SamePDBResidue()

RDKIT_FILEPARSERS_EXPORT bool RDKit::SamePDBResidue ( AtomPDBResidueInfo p,
AtomPDBResidueInfo q 
)

◆ SequenceToMol() [1/4]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::SequenceToMol ( const char seq,
bool  sanitize,
bool  lowerD 
)
Parameters
seq- the string to be processed
sanitize- toggles sanitization and stereochemistry perception of the molecule
lowerD- if set, lower case letters will be parsed as the d form of the corresponding amino acid

◆ SequenceToMol() [2/4]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::SequenceToMol ( const char seq,
bool  sanitize = true,
int  flavor = 0 
)
Parameters
seq- the string to be processed
sanitize- toggles sanitization and stereochemistry perception of the molecule
flavor- 0 Protein, L amino acids (default) 1 Protein, D amino acids 2 RNA, no cap 3 RNA, 5' cap 4 RNA, 3' cap 5 RNA, both caps 6 DNA, no cap 7 DNA, 5' cap 8 DNA, 3' cap 9 DNA, both caps

◆ SequenceToMol() [3/4]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::SequenceToMol ( const std::string &  seq,
bool  sanitize,
bool  lowerD 
)

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

◆ SequenceToMol() [4/4]

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::SequenceToMol ( const std::string &  seq,
bool  sanitize = true,
int  flavor = 0 
)

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

◆ setAtomAlias()

RDKIT_GRAPHMOL_EXPORT void RDKit::setAtomAlias ( Atom atom,
const std::string &  alias 
)

Set the atom's MDL atom alias Setting to an empty string clears the alias

◆ setAtomRLabel()

RDKIT_GRAPHMOL_EXPORT void RDKit::setAtomRLabel ( Atom atm,
int  rlabel 
)

Set the atom's MDL integer RLabel Setting to 0 clears the rlabel. Rlabel must be in the range [0..99]

◆ setAtomValue()

RDKIT_GRAPHMOL_EXPORT void RDKit::setAtomValue ( Atom atom,
const std::string &  value 
)

Set the atom's MDL atom value Setting to an empty string clears the value This is where recursive smarts get stored in MolBlock Queries

◆ setDarkMode() [1/2]

void RDKit::setDarkMode ( MolDraw2D d2d)
inline

Definition at line 555 of file MolDraw2D.h.

References rdvalue_is(), and setDarkMode().

◆ setDarkMode() [2/2]

void RDKit::setDarkMode ( MolDrawOptions opts)
inline

Definition at line 547 of file MolDraw2D.h.

References assignDarkModePalette(), and rdvalue_is().

Referenced by setDarkMode().

◆ setLabel()

bool RDKit::setLabel ( Atom atom,
int  label,
std::set< int > &  labels,
int maxLabel,
bool  relabel,
Labelling  type 
)

Set the rgroup label for the current atom, this also sets the appropriate MDL or other label

◆ setMonochromeMode() [1/2]

void RDKit::setMonochromeMode ( MolDraw2D drawer,
const DrawColour fgColour,
const DrawColour bgColour 
)
inline

Definition at line 566 of file MolDraw2D.h.

References rdvalue_is(), and setMonochromeMode().

◆ setMonochromeMode() [2/2]

void RDKit::setMonochromeMode ( MolDrawOptions opts,
const DrawColour fgColour,
const DrawColour bgColour 
)
inline

Definition at line 556 of file MolDraw2D.h.

References rdvalue_is().

Referenced by setMonochromeMode().

◆ setSupplementalSmilesLabel()

RDKIT_GRAPHMOL_EXPORT void RDKit::setSupplementalSmilesLabel ( Atom atom,
const std::string &  label 
)

Sets the supplemental label that will follow the atom when writing smiles strings.

◆ SLNQueryToMol()

RDKIT_SLNPARSE_EXPORT RWMol * RDKit::SLNQueryToMol ( const std::string &  smi,
bool  mergeHs = true,
int  debugParse = 0 
)

◆ SLNToMol()

RDKIT_SLNPARSE_EXPORT RWMol * RDKit::SLNToMol ( const std::string &  smi,
bool  sanitize = true,
int  debugParse = 0 
)

◆ SmartsToAtom()

RDKIT_SMILESPARSE_EXPORT Atom * RDKit::SmartsToAtom ( const std::string &  sma)

◆ SmartsToBond()

RDKIT_SMILESPARSE_EXPORT Bond * RDKit::SmartsToBond ( const std::string &  sma)

◆ SmartsToMol() [1/2]

RDKIT_SMILESPARSE_EXPORT RWMol * RDKit::SmartsToMol ( const std::string &  sma,
const SmartsParserParams ps 
)

Referenced by operator""_smarts(), and SmartsToMol().

◆ SmartsToMol() [2/2]

RWMol * RDKit::SmartsToMol ( const std::string &  sma,
int  debugParse = 0,
bool  mergeHs = false,
std::map< std::string, std::string > *  replacements = nullptr 
)
inline

Construct a molecule from a SMARTS string.

Parameters
smathe SMARTS to convert
debugParsetoggles verbose debugging information from the parser
mergeHstoggles merging H atoms in the SMARTS into neighboring atoms
replacementsa string->string map of replacement strings.
See also
SmilesToMol for more information about replacements
Returns
a pointer to the new molecule; the caller is responsible for free'ing this.

Definition at line 112 of file SmilesParse.h.

References RDKit::SmartsParserParams::debugParse, rdvalue_is(), and SmartsToMol().

◆ SmilesToAtom()

RDKIT_SMILESPARSE_EXPORT Atom * RDKit::SmilesToAtom ( const std::string &  smi)

◆ SmilesToBond()

RDKIT_SMILESPARSE_EXPORT Bond * RDKit::SmilesToBond ( const std::string &  smi)

◆ SmilesToMol() [1/2]

◆ SmilesToMol() [2/2]

RWMol * RDKit::SmilesToMol ( const std::string &  smi,
int  debugParse = 0,
bool  sanitize = true,
std::map< std::string, std::string > *  replacements = nullptr 
)
inline

Construct a molecule from a SMILES string.

Parameters
smithe SMILES to convert
debugParsetoggles verbose debugging information from the parser
sanitizetoggles H removal and sanitization of the molecule
replacementsa string->string map of replacement strings. See below for more information about replacements.
Returns
a pointer to the new molecule; the caller is responsible for free'ing this.

The optional replacements map can be used to do string substitution of abbreviations in the input SMILES. The set of substitutions is repeatedly looped through until the string no longer changes. It is the responsibility of the caller to make sure that substitutions results in legal and sensible SMILES.

Examples of substitutions:

CC{Q}C with {"{Q}":"OCCO"} -> CCOCCOC
C{A}C{Q}C with {"{Q}":"OCCO", "{A}":"C1(CC1)"} -> CC1(CC1)COCCOC
C{A}C{Q}C with {"{Q}":"{X}CC{X}", "{A}":"C1CC1", "{X}":"N"} -> CC1CC1CNCCNC
bool rdvalue_is(const RDValue_cast_t)

Definition at line 68 of file SmilesParse.h.

References RDKit::SmilesParserParams::debugParse, rdvalue_is(), RDKit::SmilesParserParams::removeHs, RDKit::SmilesParserParams::replacements, RDKit::SmilesParserParams::sanitize, and SmilesToMol().

◆ sortMatchesByDegreeOfCoreSubstitution()

RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectType > RDKit::sortMatchesByDegreeOfCoreSubstitution ( const ROMol mol,
const ROMol core,
const std::vector< MatchVectType > &  matches 
)

This returns a copy of the passed substruct matches sorted by decreasing number of non-hydrogen atoms in correspondence of terminal dummy atoms

◆ StandardPDBResidueBondOrders()

RDKIT_FILEPARSERS_EXPORT void RDKit::StandardPDBResidueBondOrders ( RWMol mol)

◆ streamRead() [1/3]

void RDKit::streamRead ( std::istream &  ss,
std::string &  what,
int  version 
)
inline

Definition at line 299 of file StreamOps.h.

References RDUNUSED_PARAM, and rdvalue_is().

◆ streamRead() [2/3]

template<typename T >
void RDKit::streamRead ( std::istream &  ss,
T &  loc 
)

◆ streamRead() [3/3]

template<class T >
void RDKit::streamRead ( std::istream &  ss,
T &  obj,
int  version 
)

special case for string

Definition at line 294 of file StreamOps.h.

References RDUNUSED_PARAM, rdvalue_is(), and streamRead().

◆ streamReadProp()

bool RDKit::streamReadProp ( std::istream &  ss,
Dict::Pair pair,
bool dictHasNonPOD,
const CustomPropHandlerVec handlers = {} 
)
inline

Definition at line 556 of file StreamOps.h.

◆ streamReadProps()

template<typename COUNT_TYPE = unsigned int>
unsigned int RDKit::streamReadProps ( std::istream &  ss,
RDProps props,
const CustomPropHandlerVec handlers = {},
bool  reset = true 
)
inline

Definition at line 626 of file StreamOps.h.

◆ streamReadStringVec()

void RDKit::streamReadStringVec ( std::istream &  ss,
std::vector< std::string > &  val,
int  version 
)
inline

Definition at line 326 of file StreamOps.h.

References rdvalue_is(), and streamRead().

Referenced by readRDStringVecValue().

◆ streamReadVec()

template<class T >
void RDKit::streamReadVec ( std::istream &  ss,
T &  val 
)

Definition at line 316 of file StreamOps.h.

References rdvalue_is(), and streamRead().

Referenced by readRDVecValue().

◆ streamWrite() [1/2]

void RDKit::streamWrite ( std::ostream &  ss,
const std::string &  what 
)
inline

special case for string

Definition at line 267 of file StreamOps.h.

References rdvalue_is().

◆ streamWrite() [2/2]

template<typename T >
void RDKit::streamWrite ( std::ostream &  ss,
const T &  val 
)

◆ streamWriteProp()

bool RDKit::streamWriteProp ( std::ostream &  ss,
const Dict::Pair pair,
const CustomPropHandlerVec handlers = {} 
)
inline

Definition at line 412 of file StreamOps.h.

◆ streamWriteProps()

template<typename COUNT_TYPE = unsigned int>
bool RDKit::streamWriteProps ( std::ostream &  ss,
const RDProps props,
bool  savePrivate = false,
bool  saveComputed = false,
const CustomPropHandlerVec handlers = {},
const std::unordered_set< std::string > &  ignore = {} 
)
inline

Definition at line 485 of file StreamOps.h.

◆ streamWriteVec()

template<typename T >
void RDKit::streamWriteVec ( std::ostream &  ss,
const T &  val 
)

Definition at line 274 of file StreamOps.h.

References rdvalue_is(), and streamWrite().

◆ strip()

RDKIT_FILEPARSERS_EXPORT std::string RDKit::strip ( const std::string &  orig)

◆ StructuralFingerprintChemReaction()

RDKIT_CHEMREACTIONS_EXPORT ExplicitBitVect * RDKit::StructuralFingerprintChemReaction ( const ChemicalReaction rxn,
const ReactionFingerprintParams params = DefaultStructuralFPParams 
)

Generates a structural fingerprint for a reaction to use in screening

A structural fingerprint is generated as an ExplicitBitVect to use for searching e.g. substructure in reactions. By default the fingerprint is generated as 4096 BitVect using a PatternFP for reactants and products and tentatively agents which were finally concatenated

Parameters
rxnthe reaction to be fingerprinted
paramsspecific settings to manipulate fingerprint generation
Returns
the reaction fingerprint, as an ExplicitBitVect

Notes:

  • the caller is responsible for deleteing the result

◆ SubstructLibraryCanSerialize()

RDKIT_SUBSTRUCTLIBRARY_EXPORT bool RDKit::SubstructLibraryCanSerialize ( )

◆ SubstructMatch() [1/10]

RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectType > RDKit::SubstructMatch ( const MolBundle bundle,
const MolBundle query,
const SubstructMatchParameters params = SubstructMatchParameters() 
)

◆ SubstructMatch() [2/10]

RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectType > RDKit::SubstructMatch ( const MolBundle bundle,
const ROMol query,
const SubstructMatchParameters params = SubstructMatchParameters() 
)

◆ SubstructMatch() [3/10]

RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectType > RDKit::SubstructMatch ( const ROMol mol,
const MolBundle query,
const SubstructMatchParameters params = SubstructMatchParameters() 
)

◆ SubstructMatch() [4/10]

RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectType > RDKit::SubstructMatch ( const ROMol mol,
const ROMol query,
const SubstructMatchParameters params = SubstructMatchParameters() 
)

Find a substructure match for a query in a molecule.

Parameters
molThe ROMol to be searched
queryThe query ROMol
matchParamsParameters controlling the matching
Returns
The matches, if any

Referenced by SubstructMatch(), SubstructMatch(), SubstructMatch(), and SubstructMatch().

◆ SubstructMatch() [5/10]

RDKIT_TAUTOMERQUERY_EXPORT std::vector< MatchVectType > RDKit::SubstructMatch ( const ROMol mol,
const TautomerQuery query,
const SubstructMatchParameters params 
)

◆ SubstructMatch() [6/10]

RDKIT_SUBSTRUCTMATCH_EXPORT std::vector< MatchVectType > RDKit::SubstructMatch ( ResonanceMolSupplier resMolSuppl,
const ROMol query,
const SubstructMatchParameters params = SubstructMatchParameters() 
)

Find all substructure matches for a query in a ResonanceMolSupplier object.

Parameters
resMolSupplThe ResonanceMolSupplier object to be searched
queryThe query ROMol
matchParamsParameters controlling the matching
Returns
The matches, if any

◆ SubstructMatch() [7/10]

template<>
bool RDKit::SubstructMatch ( ResonanceMolSupplier resMolSupplier,
const ROMol query,
MatchVectType matchVect,
bool  recursionPossible,
bool  useChirality,
bool  useQueryQueryMatches 
)
inline

◆ SubstructMatch() [8/10]

template<>
unsigned int RDKit::SubstructMatch ( ResonanceMolSupplier resMolSupplier,
const ROMol query,
std::vector< MatchVectType > &  matchVect,
bool  uniquify,
bool  recursionPossible,
bool  useChirality,
bool  useQueryQueryMatches,
unsigned int  maxMatches,
int  numThreads 
)
inline

◆ SubstructMatch() [9/10]

template<typename T1 , typename T2 >
bool RDKit::SubstructMatch ( T1 mol,
const T2 query,
MatchVectType matchVect,
bool  recursionPossible = true,
bool  useChirality = false,
bool  useQueryQueryMatches = false 
)

Find a substructure match for a query.

Parameters
molThe object to be searched
queryThe query
matchVectUsed to return the match (pre-existing contents will be deleted)
recursionPossibleflags whether or not recursive matches are allowed
useChiralityuse atomic CIP codes as part of the comparison
useQueryQueryMatchesif set, the contents of atom and bond queries will be used as part of the matching
Returns
whether or not a match was found

Definition at line 130 of file SubstructMatch.h.

References RDKit::SubstructMatchParameters::maxMatches, rdvalue_is(), RDKit::SubstructMatchParameters::recursionPossible, SubstructMatch(), RDKit::SubstructMatchParameters::useChirality, and RDKit::SubstructMatchParameters::useQueryQueryMatches.

◆ SubstructMatch() [10/10]

template<typename T1 , typename T2 >
unsigned int RDKit::SubstructMatch ( T1 mol,
const T2 query,
std::vector< MatchVectType > &  matchVect,
bool  uniquify = true,
bool  recursionPossible = true,
bool  useChirality = false,
bool  useQueryQueryMatches = false,
unsigned int  maxMatches = 1000,
int  numThreads = 1 
)

Find all substructure matches for a query.

Parameters
molThe object to be searched
queryThe query
matchVectUsed to return the matches (pre-existing contents will be deleted)
uniquifyToggles uniquification (by atom index) of the results
recursionPossibleflags whether or not recursive matches are allowed
useChiralityuse atomic CIP codes as part of the comparison
useQueryQueryMatchesif set, the contents of atom and bond queries will be used as part of the matching
maxMatchesThe maximum number of matches that will be returned. In high-symmetry cases with medium-sized molecules, it is very easy to end up with a combinatorial explosion in the number of possible matches. This argument prevents that from having unintended consequences
Returns
the number of matches found

Definition at line 170 of file SubstructMatch.h.

References RDKit::SubstructMatchParameters::maxMatches, RDKit::SubstructMatchParameters::numThreads, rdvalue_is(), RDKit::SubstructMatchParameters::recursionPossible, SubstructMatch(), RDKit::SubstructMatchParameters::uniquify, RDKit::SubstructMatchParameters::useChirality, and RDKit::SubstructMatchParameters::useQueryQueryMatches.

◆ substructMatchParamsToJSON()

RDKIT_SUBSTRUCTMATCH_EXPORT std::string RDKit::substructMatchParamsToJSON ( const SubstructMatchParameters params)

◆ SwapBytes()

template<class T , unsigned int size>
T RDKit::SwapBytes ( value)
inline

Definition at line 45 of file StreamOps.h.

References rdvalue_is().

◆ TanimotoSimilarity()

template<typename IndexType >
double RDKit::TanimotoSimilarity ( const SparseIntVect< IndexType > &  v1,
const SparseIntVect< IndexType > &  v2,
bool  returnDistance = false,
double  bounds = 0.0 
)

◆ TautomerQueryCanSerialize()

RDKIT_TAUTOMERQUERY_EXPORT bool RDKit::TautomerQueryCanSerialize ( )

◆ toJSON() [1/3]

RDKIT_RGROUPDECOMPOSITION_EXPORT std::string RDKit::toJSON ( const RGroupColumn rgr,
const std::string &  prefix = "" 
)

Returns a JSON form The prefix argument is added to each line in the output

◆ toJSON() [2/3]

RDKIT_RGROUPDECOMPOSITION_EXPORT std::string RDKit::toJSON ( const RGroupRow rgr,
const std::string &  prefix = "" 
)

Returns a JSON form The prefix argument is added to each line in the output

◆ toJSON() [3/3]

RDKIT_RGROUPDECOMPOSITION_EXPORT std::string RDKit::toJSON ( const RGroupRows rgr,
const std::string &  prefix = "" 
)

Returns a JSON form The prefix argument is added to each line in the output

◆ toPrime()

◆ TPLDataStreamToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::TPLDataStreamToMol ( std::istream *  inStream,
unsigned int line,
bool  sanitize = true,
bool  skipFirstConf = false 
)

translate TPL data (BioCad format) into a multi-conf molecule

Parameters
inStreamthe stream from which to read
lineused to track the line number of errors
sanitizetoggles sanitization and stereochemistry perception of the molecule
skipFirstConfaccording to the TPL format description, the atomic coords in the atom-information block describe the first conformation and the first conf block describes second conformation. The CombiCode, on the other hand, writes the first conformation data both to the atom-information block and to the first conf block. We want to be able to read CombiCode-style tpls, so we'll allow this mis-feature to be parsed when this flag is set.

References TPLDataStreamToMol().

Referenced by TPLDataStreamToMol().

◆ TPLFileToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::TPLFileToMol ( const std::string &  fName,
bool  sanitize = true,
bool  skipFirstConf = false 
)

construct a multi-conf molecule from a TPL (BioCad format) file

Parameters
fNamethe name of the file from which to read
sanitizetoggles sanitization and stereochemistry perception of the molecule
skipFirstConfaccording to the TPL format description, the atomic coords in the atom-information block describe the first conformation and the first conf block describes second conformation. The CombiCode, on the other hand, writes the first conformation data both to the atom-information block and to the first conf block. We want to be able to read CombiCode-style tpls, so we'll allow this mis-feature to be parsed when this flag is set.

References TPLFileToMol().

Referenced by TPLFileToMol().

◆ translateChiralFlagToStereoGroups()

RDKIT_FILEPARSERS_EXPORT void RDKit::translateChiralFlagToStereoGroups ( ROMol mol,
StereoGroupType  zeroFlagGroupType = StereoGroupType::STEREO_AND 
)

generate enhanced stereo groups based on the status of the chiral flag property

◆ TverskySimilarity()

template<typename IndexType >
double RDKit::TverskySimilarity ( const SparseIntVect< IndexType > &  v1,
const SparseIntVect< IndexType > &  v2,
double  a,
double  b,
bool  returnDistance = false,
double  bounds = 0.0 
)

Definition at line 535 of file SparseIntVect.h.

References RDUNUSED_PARAM, and rdvalue_is().

Referenced by TanimotoSimilarity().

◆ Union() [1/2]

RDKIT_RDGENERAL_EXPORT void RDKit::Union ( const INT_VECT r1,
const INT_VECT r2,
INT_VECT res 
)

calculate the union of two INT_VECTs and put the results in a third vector

◆ Union() [2/2]

RDKIT_RDGENERAL_EXPORT void RDKit::Union ( const VECT_INT_VECT rings,
INT_VECT res,
const INT_VECT exclude = nullptr 
)

calculating the union of the INT_VECT's in a VECT_INT_VECT

Parameters
ringsthe INT_VECT's to consider
resused to return results
excludeany values in this optional INT_VECT will be excluded from the union.

◆ updateFromSequence()

void RDKit::updateFromSequence ( SparseIntVect< IndexType > &  vect,
const SequenceType seq 
)

Definition at line 416 of file SparseIntVect.h.

References rdvalue_is().

◆ updateProductsStereochem()

RDKIT_CHEMREACTIONS_EXPORT void RDKit::updateProductsStereochem ( ChemicalReaction rxn)

◆ updateSubstructMatchParamsFromJSON()

RDKIT_SUBSTRUCTMATCH_EXPORT void RDKit::updateSubstructMatchParamsFromJSON ( SubstructMatchParameters params,
const std::string &  json 
)

◆ vectToString()

template<class T >
std::string RDKit::vectToString ( RDValue  val)

Definition at line 176 of file RDValue.h.

References rdvalue_is().

◆ WedgeBond()

RDKIT_FILEPARSERS_EXPORT void RDKit::WedgeBond ( Bond bond,
unsigned int  fromAtomIdx,
const Conformer conf 
)

◆ WedgeMolBonds()

RDKIT_FILEPARSERS_EXPORT void RDKit::WedgeMolBonds ( ROMol mol,
const Conformer conf 
)

◆ XYZBlockToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::XYZBlockToMol ( const std::string &  xyzBlock)
Parameters
xyzBlock- string containing the xyz block

References XYZBlockToMol().

Referenced by XYZBlockToMol().

◆ XYZDataStreamToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::XYZDataStreamToMol ( std::istream &  inStream)

References XYZDataStreamToMol().

Referenced by XYZDataStreamToMol().

◆ XYZFileToMol()

RDKIT_FILEPARSERS_EXPORT RWMol * RDKit::XYZFileToMol ( const std::string &  fName)
Parameters
fName- string containing the file name

References XYZFileToMol().

Referenced by XYZFileToMol().

Variable Documentation

◆ _rgroupInputDummy

const std::string RDKit::_rgroupInputDummy
extern

◆ additionalParamData

std::string RDKit::additionalParamData
extern

◆ BITS_PER_INT

const unsigned int RDKit::BITS_PER_INT = 32

Definition at line 21 of file DiscreteValueVect.h.

Referenced by RDKit::DiscreteValueVect::DiscreteValueVect().

◆ boostVersion

RDKIT_RDGENERAL_EXPORT const char* RDKit::boostVersion
extern

◆ ci_ATOM_HOLDER

RDKIT_GRAPHMOL_EXPORT const int RDKit::ci_ATOM_HOLDER
extern

◆ ci_LEADING_BOND

RDKIT_GRAPHMOL_EXPORT const int RDKit::ci_LEADING_BOND
extern

◆ ci_RIGHTMOST_ATOM

RDKIT_GRAPHMOL_EXPORT const int RDKit::ci_RIGHTMOST_ATOM
extern

◆ complexQueries

const std::vector<std::string> RDKit::complexQueries
Initial value:
= {"A", "AH", "Q", "QH",
"X", "XH", "M", "MH"}

Definition at line 599 of file QueryOps.h.

◆ ctdIGNORE_H_H_CONTACTS

const unsigned int RDKit::ctdIGNORE_H_H_CONTACTS = 0x1
static

Definition at line 16 of file ProximityBonds.h.

◆ DAMP

const double RDKit::DAMP = 0.5

Definition at line 28 of file GasteigerParams.h.

◆ DAMP_SCALE

const double RDKit::DAMP_SCALE = 0.5

Definition at line 27 of file GasteigerParams.h.

◆ dashes

const DashPattern RDKit::dashes {6.0, 4.0}

Definition at line 28 of file DrawShape.h.

◆ DEFAULT_FILTERMATCHERBASE_NAME

RDKIT_FILTERCATALOG_EXPORT const char* RDKit::DEFAULT_FILTERMATCHERBASE_NAME
extern

◆ defaultConfId

int RDKit::defaultConfId = -1
static

Definition at line 35 of file MolWriters.h.

◆ DefaultDifferenceFPParams

RDKIT_CHEMREACTIONS_EXPORT const ReactionFingerprintParams RDKit::DefaultDifferenceFPParams
extern

◆ DefaultStructuralFPParams

RDKIT_CHEMREACTIONS_EXPORT const ReactionFingerprintParams RDKit::DefaultStructuralFPParams
extern

◆ done

RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string RDKit::done
extern

◆ dots

const DashPattern RDKit::dots {2.0, 6.0}

Definition at line 27 of file DrawShape.h.

◆ elementNames

RDKIT_GRAPHMOL_EXPORT const std::vector<std::string> RDKit::elementNames
extern

◆ EMPTY_CORE_LABEL

const unsigned int RDKit::EMPTY_CORE_LABEL = -100000

Definition at line 27 of file RGroupUtils.h.

◆ EPS_DOUBLE

RDKIT_RDGENERAL_EXPORT const double RDKit::EPS_DOUBLE
extern

◆ FILE_MAXLINE

const int RDKit::FILE_MAXLINE
Initial value:
=
256

an assumed maximum length for lines read from files

Definition at line 26 of file utils.h.

◆ firstThousandPrimes

RDKIT_RDGENERAL_EXPORT int RDKit::firstThousandPrimes
extern

Definition at line 24 of file utils.h.

◆ IONXH

const double RDKit::IONXH = 20.02

Definition at line 25 of file GasteigerParams.h.

◆ isotopesAtomData

RDKIT_GRAPHMOL_EXPORT const std::string RDKit::isotopesAtomData[]
extern

◆ LayeredFingerprintMolVersion

const std::string RDKit::LayeredFingerprintMolVersion = "0.7.0"

Definition at line 113 of file Fingerprints.h.

◆ lineWidthScaleFactor

const double RDKit::lineWidthScaleFactor = 0.02
static

Definition at line 63 of file MolDraw2DHelpers.h.

◆ marvinBondOrders

const std::vector<std::string> RDKit::marvinBondOrders {"1", "2", "3", "A"}

Definition at line 40 of file MarvinDefs.h.

◆ marvinConventionTypes

const std::vector<std::string> RDKit::marvinConventionTypes {"cxn:coord"}

Definition at line 42 of file MarvinDefs.h.

◆ marvinQueryBondsTypes

const std::vector<std::string> RDKit::marvinQueryBondsTypes {"SD", "SA", "DA", "Any"}

Definition at line 41 of file MarvinDefs.h.

◆ marvinRadicalToRadicalElectrons

const std::map<std::string, int> RDKit::marvinRadicalToRadicalElectrons
Initial value:
{
{"monovalent", 1}, {"divalent", 2}, {"divalent1", 2}, {"divalent3", 2},
{"trivalent", 3}, {"trivalent2", 3}, {"trivalent4", 3}, {"4", 4}}

Definition at line 49 of file MarvinDefs.h.

◆ marvinRadicalVals

const std::vector<std::string> RDKit::marvinRadicalVals
Initial value:
{
"monovalent", "divalent", "divalent1", "divalent3",
"trivalent", "trivalent2", "trivalent4", "4"}

Definition at line 46 of file MarvinDefs.h.

◆ marvinStereoConventionTypes

const std::vector<std::string> RDKit::marvinStereoConventionTypes {"1", "3", "4", "6"}

Definition at line 44 of file MarvinDefs.h.

◆ marvinStereoDictRefTypes

const std::vector<std::string> RDKit::marvinStereoDictRefTypes {"cml:W", "cml:H"}

Definition at line 43 of file MarvinDefs.h.

◆ massIntegerConversionFactor

const int RDKit::massIntegerConversionFactor = 1000

Definition at line 155 of file QueryOps.h.

Referenced by makeAtomMassQuery(), and queryAtomMass().

◆ MAX_DOUBLE

RDKIT_RDGENERAL_EXPORT const double RDKit::MAX_DOUBLE
extern

◆ MAX_INT

RDKIT_RDGENERAL_EXPORT const double RDKit::MAX_INT
extern

◆ MAX_LONGINT

RDKIT_RDGENERAL_EXPORT const double RDKit::MAX_LONGINT
extern

◆ maxFingerprintLayers

const unsigned int RDKit::maxFingerprintLayers = 10

Definition at line 112 of file Fingerprints.h.

◆ MOLFILE_MAXLINE

const int RDKit::MOLFILE_MAXLINE = 256

Definition at line 26 of file FileParsers.h.

◆ noDash

const DashPattern RDKit::noDash

Definition at line 26 of file DrawShape.h.

◆ NUM_PRIMES_AVAIL

const int RDKit::NUM_PRIMES_AVAIL = 1000

the number of primes available and stored

Definition at line 15 of file primes.h.

◆ paramData

std::string RDKit::paramData
extern

◆ PatternFingerprintMolVersion

const std::string RDKit::PatternFingerprintMolVersion = "1.0.0"

Definition at line 149 of file Fingerprints.h.

◆ periodicTableAtomData

RDKIT_GRAPHMOL_EXPORT const std::string RDKit::periodicTableAtomData
extern

◆ radicalElectronsToMarvinRadical

const std::map<int, std::string> RDKit::radicalElectronsToMarvinRadical
Initial value:
{
{1, "monovalent"}, {2, "divalent"}, {3, "trivalent4"}, {4, "4"}}

Definition at line 53 of file MarvinDefs.h.

◆ RDKFingerprintMolVersion

const std::string RDKit::RDKFingerprintMolVersion = "2.0.0"

Definition at line 63 of file Fingerprints.h.

◆ rdkitBuild

RDKIT_RDGENERAL_EXPORT const char* RDKit::rdkitBuild
extern

◆ rdkitQtVersion

RDKIT_MOLDRAW2DQT_EXPORT const char* RDKit::rdkitQtVersion
extern

◆ rdkitVersion

RDKIT_RDGENERAL_EXPORT const char* RDKit::rdkitVersion
extern

◆ RLABEL

RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string RDKit::RLABEL
extern

◆ RLABEL_CORE_INDEX

RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string RDKit::RLABEL_CORE_INDEX
extern

◆ RLABEL_TYPE

RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string RDKit::RLABEL_TYPE
extern

◆ shortDashes

const DashPattern RDKit::shortDashes {2.0, 2.0}

Definition at line 29 of file DrawShape.h.

◆ SIDECHAIN_RLABELS

RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string RDKit::SIDECHAIN_RLABELS
extern

◆ SMALL_DOUBLE

RDKIT_RDGENERAL_EXPORT const double RDKit::SMALL_DOUBLE
extern

◆ SMARTS_MATCH_NAME_DEFAULT

RDKIT_FILTERCATALOG_EXPORT const char* RDKit::SMARTS_MATCH_NAME_DEFAULT
extern

◆ sruSgroupConnectChoices

const std::vector<std::string> RDKit::sruSgroupConnectChoices {"hh", "ht", "eu"}

Definition at line 39 of file MarvinDefs.h.

◆ substructLayers

const unsigned int RDKit::substructLayers = 0x07

Definition at line 114 of file Fingerprints.h.

◆ UNLABELED_CORE_ATTACHMENT

RDKIT_RGROUPDECOMPOSITION_EXPORT const std::string RDKit::UNLABELED_CORE_ATTACHMENT
extern