rdkit.Chem.AllChem

Package rdkit :: Package Chem :: Module AllChem |
[hide private]
[frames] | no frames]

# Module AllChem

source code

    Import all RDKit chemistry modules

Functions | [hide private]
TransformMol(mol, tform, confId=-1, keepConfs=False) Applies the transformation (usually a 4x4 double matrix) to a molecule... | source code
ComputeMolShape(mol, confId=-1, boxDim=`(`20`,` 20`,` 20`)`, spacing=0.5, **kwargs) returns a grid representation of the molecule's shape... | source code
ComputeMolVolume(mol, confId=-1, gridSpacing=0.2, boxMargin=2.0) Calculates the volume of a particular conformer of a molecule based on a grid-encoding of the molecular shape. | source code
GetConformerRMS(mol, confId1, confId2, atomIds=None, prealigned=False) Returns the RMS between two conformations. | source code
GetConformerRMSMatrix(mol, atomIds=None, prealigned=False) Returns the RMS matrix of the conformers of a molecule. | source code
EnumerateLibraryFromReaction(reaction, sidechainSets, returnReactants=False) Returns a generator for the virtual library defined by a reaction and a sequence of sidechain sets | source code
ConstrainedEmbed(mol, core, useTethers=True, coreConfId=-1, randomseed=2342, getForceField=<Boost.Python.function object at 0x30304e0>, **kwargs) generates an embedding of a molecule where part of the molecule is constrained to have particular coordinates | source code
AssignBondOrdersFromTemplate(refmol, mol) assigns bond orders to a molecule based on the bond orders in a template molecule | source code
_runDoctests(verbose=None) | source code

Variables | [hide private]
| logger = `logger()`
| ADJUST_IGNOREALL = `rdkit.Chem.rdmolops.AdjustQueryWhichFlags.A`...``
| ADJUST_IGNORECHAINS = `rdkit.Chem.rdmolops.AdjustQueryWhichFlag`...``
| ADJUST_IGNOREDUMMIES = `rdkit.Chem.rdmolops.AdjustQueryWhichFla`...``
| ADJUST_IGNORENONDUMMIES = `rdkit.Chem.rdmolops.AdjustQueryWhich`...``
| ADJUST_IGNORENONE = `rdkit.Chem.rdmolops.AdjustQueryWhichFlags.`...``
| ADJUST_IGNORERINGS = `rdkit.Chem.rdmolops.AdjustQueryWhichFlags`...``
| ALLOW_CHARGE_SEPARATION = `rdkit.Chem.rdchem.ResonanceFlags.ALL`...``
| ALLOW_INCOMPLETE_OCTETS = `rdkit.Chem.rdchem.ResonanceFlags.ALL`...``
| AROMATICITY_CUSTOM = `rdkit.Chem.rdmolops.AromaticityModel.AROM`...``
| AROMATICITY_DEFAULT = `rdkit.Chem.rdmolops.AromaticityModel.ARO`...``
| AROMATICITY_RDKIT = `rdkit.Chem.rdmolops.AromaticityModel.AROMA`...``
| AROMATICITY_SIMPLE = `rdkit.Chem.rdmolops.AromaticityModel.AROM`...``
| AllProps = `rdkit.Chem.rdchem.PropertyPickleOptions.AllProps`
| AtomProps = `rdkit.Chem.rdchem.PropertyPickleOptions.AtomProps`
| BondProps = `rdkit.Chem.rdchem.PropertyPickleOptions.BondProps`
| CHI_OTHER = `rdkit.Chem.rdchem.ChiralType.CHI_OTHER`
| CHI_TETRAHEDRAL_CCW = `rdkit.Chem.rdchem.ChiralType.CHI_TETRAHE`...``
| CHI_TETRAHEDRAL_CW = `rdkit.Chem.rdchem.ChiralType.CHI_TETRAHED`...``
| CHI_UNSPECIFIED = `rdkit.Chem.rdchem.ChiralType.CHI_UNSPECIFIED`
| COMPOSITE_AND = `rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE`...``
| COMPOSITE_OR = `rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_OR`
| COMPOSITE_XOR = `rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE`...``
| ComputedProps = `rdkit.Chem.rdchem.PropertyPickleOptions.Comput`...``
| KEKULE_ALL = `rdkit.Chem.rdchem.ResonanceFlags.KEKULE_ALL`
| LayeredFingerprint_substructLayers = `7`
| MolProps = `rdkit.Chem.rdchem.PropertyPickleOptions.MolProps`
| NoProps = `rdkit.Chem.rdchem.PropertyPickleOptions.NoProps`
| PrivateProps = `rdkit.Chem.rdchem.PropertyPickleOptions.Private`...``
| QueryAtomData = `rdkit.Chem.rdchem.PropertyPickleOptions.QueryA`...``
| SANITIZE_ADJUSTHS = `rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE`...``
| SANITIZE_ADJUST_REACTANTS = `rdkit.Chem.rdChemReactions.Sanitiz`...``
| SANITIZE_ALL = `rdkit.Chem.rdChemReactions.SanitizeFlags.SANITI`...``
| SANITIZE_ATOM_MAPS = `rdkit.Chem.rdChemReactions.SanitizeFlags.`...``
| SANITIZE_CLEANUP = `rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_`...``
| SANITIZE_CLEANUPCHIRALITY = `rdkit.Chem.rdmolops.SanitizeFlags.`...``
| SANITIZE_FINDRADICALS = `rdkit.Chem.rdmolops.SanitizeFlags.SANI`...``
| SANITIZE_KEKULIZE = `rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE`...``
| SANITIZE_MERGEHS = `rdkit.Chem.rdChemReactions.SanitizeFlags.SA`...``
| SANITIZE_NONE = `rdkit.Chem.rdChemReactions.SanitizeFlags.SANIT`...``
| SANITIZE_PROPERTIES = `rdkit.Chem.rdmolops.SanitizeFlags.SANITI`...``
| SANITIZE_RGROUP_NAMES = `rdkit.Chem.rdChemReactions.SanitizeFla`...``
| SANITIZE_SETAROMATICITY = `rdkit.Chem.rdmolops.SanitizeFlags.SA`...``
| SANITIZE_SETCONJUGATION = `rdkit.Chem.rdmolops.SanitizeFlags.SA`...``
| SANITIZE_SETHYBRIDIZATION = `rdkit.Chem.rdmolops.SanitizeFlags.`...``
| SANITIZE_SYMMRINGS = `rdkit.Chem.rdmolops.SanitizeFlags.SANITIZ`...``
| UNCONSTRAINED_ANIONS = `rdkit.Chem.rdchem.ResonanceFlags.UNCONS`...``
| UNCONSTRAINED_CATIONS = `rdkit.Chem.rdchem.ResonanceFlags.UNCON`...``
| __package__ = ``'``rdkit.Chem``'``

Imports: sys, warnings, namedtuple, numpy, ForceField, SupplierFromFilename, InchiToInchiKey, DataStructs, rdchem, INCHI_AVAILABLE, QuickSmartsMatch, rdBase, pyPeriodicTable, CanonSmiles, MolFromInchi, MolToInchiAndAuxInfo, RDConfig, FindMolChiralCenters, InchiReadWriteError, MolToInchi, MCFF_GetFeaturesForMol, rdGeometry, StereoEnumerationOptions, EnumerateStereoisomers, AddHs, AddRecursiveQuery, AdjustQueryParameters, AdjustQueryProperties, AdjustQueryWhichFlags, AlignMol, AlignMolConformers, AromaticityModel, AssignAtomChiralTagsFromStructure, AssignRadicals, AssignStereochemistry, Atom, AtomMonomerInfo, AtomMonomerType, AtomNumEqualsQueryAtom, AtomNumGreaterQueryAtom, AtomNumLessQueryAtom, AtomPDBResidueInfo, AtomPairsParameters, Bond, BondDir, BondStereo, BondType, BuildFeatureFactory, BuildFeatureFactoryFromString, BuildFragmentCatalog, CalcAUTOCORR2D, CalcAUTOCORR3D, CalcAsphericity, CalcChi0n, CalcChi0v, CalcChi1n, CalcChi1v, CalcChi2n, CalcChi2v, CalcChi3n, CalcChi3v, CalcChi4n, CalcChi4v, CalcChiNn, CalcChiNv, CalcCrippenDescriptors, CalcEccentricity, CalcExactMolWt, CalcFractionCSP3, CalcGETAWAY, CalcHallKierAlpha, CalcInertialShapeFactor, CalcKappa1, CalcKappa2, CalcKappa3, CalcLabuteASA, CalcMORSE, CalcMolFormula, CalcNPR1, CalcNPR2, CalcNumAliphaticCarbocycles, CalcNumAliphaticHeterocycles, CalcNumAliphaticRings, CalcNumAmideBonds, CalcNumAromaticCarbocycles, CalcNumAromaticHeterocycles, CalcNumAromaticRings, CalcNumAtomStereoCenters, CalcNumBridgeheadAtoms, CalcNumHBA, CalcNumHBD, CalcNumHeteroatoms, CalcNumHeterocycles, CalcNumLipinskiHBA, CalcNumLipinskiHBD, CalcNumRings, CalcNumRotatableBonds, CalcNumSaturatedCarbocycles, CalcNumSaturatedHeterocycles, CalcNumSaturatedRings, CalcNumSpiroAtoms, CalcNumUnspecifiedAtomStereoCenters, CalcPBF, CalcPMI1, CalcPMI2, CalcPMI3, CalcRDF, CalcRadiusOfGyration, CalcSpherocityIndex, CalcTPSA, CalcWHIM, CanonicalRankAtoms, CanonicalRankAtomsInFragment, CanonicalizeConformer, CanonicalizeMol, CartesianProductStrategy, ChemUtils, ChemicalFeatures, ChemicalReaction, ChiralType, Cleanup, CombineMols, CompositeQueryType, Compute2DCoords, Compute2DCoordsForReaction, Compute2DCoordsMimicDistmat, ComputeCanonicalTransform, ComputeCentroid, ComputeConfBox, ComputeConfDimsAndOffset, ComputeGasteigerCharges, ComputeUnionBox, Conformer, CreateDifferenceFingerprintForReaction, CreateStructuralFingerprintForReaction, Crippen, DeleteSubstructs, Descriptors3D, DetectBondStereoChemistry, DetectBondStereochemistry, ETDG, ETKDG, EditableMol, EmbedMolecule, EmbedMultipleConfs, EmbedParameters, EncodeShape, EnumerateLibrary, EnumerateLibraryBase, EnumerateLibraryCanSerialize, EnumerationParams, EnumerationStrategyBase, EvenSamplePairsStrategy, ExplicitDegreeEqualsQueryAtom, ExplicitDegreeGreaterQueryAtom, ExplicitDegreeLessQueryAtom, ExplicitValenceEqualsQueryAtom, ExplicitValenceGreaterQueryAtom, ExplicitValenceLessQueryAtom, FastFindRings, FindAllPathsOfLengthN, FindAllSubgraphsOfLengthMToN, FindAllSubgraphsOfLengthN, FindAtomEnvironmentOfRadiusN, FindPotentialStereoBonds, FindUniqueSubgraphsOfLengthN, FingerprintType, FormalChargeEqualsQueryAtom, FormalChargeGreaterQueryAtom, FormalChargeLessQueryAtom, ForwardSDMolSupplier, FragmentCatalog, FragmentOnBRICSBonds, FragmentOnBonds, FragmentOnSomeBonds, Fragments, FreeChemicalFeature, GenerateDepictionMatching2DStructure, GenerateDepictionMatching3DStructure, GenerateErGFingerprintForReducedGraph, GenerateMolExtendedReducedGraph, Get3DDistanceMatrix, GetAdjacencyMatrix, GetAlignmentTransform, GetAngleDeg, GetAngleRad, GetAtomAlias, GetAtomMatch, GetAtomPairAtomCode, GetAtomPairCode, GetAtomPairFingerprint, GetAtomRLabel, GetAtomValue, GetBestRMS, GetBondLength, GetChemDrawRxnAdjustParams, GetConnectivityInvariants, GetCrippenO3A, GetCrippenO3AForProbeConfs, GetDefaultAdjustParams, GetDefaultPickleProperties, GetDihedralDeg, GetDihedralRad, GetDistanceMatrix, GetErGFingerprint, GetFeatureInvariants, GetFormalCharge, GetHashedAtomPairFingerprint, GetHashedAtomPairFingerprintAsBitVect, GetHashedMorganFingerprint, GetHashedTopologicalTorsionFingerprint, GetHashedTopologicalTorsionFingerprintAsBitVect, GetMACCSKeysFingerprint, GetMolFrags, GetMoleculeBoundsMatrix, GetMorganFingerprint, GetMorganFingerprintAsBitVect, GetO3A, GetO3AForProbeConfs, GetPeriodicTable, GetSSSR, GetShortestPath, GetSupplementalSmilesLabel, GetSymmSSSR, GetTopologicalTorsionFingerprint, GetUFFAngleBendParams, GetUFFBondStretchParams, GetUFFInversionParams, GetUFFTorsionParams, GetUFFVdWParams, GetUSR, GetUSRCAT, GetUSRDistributions, GetUSRDistributionsFromPoints, GetUSRFromDistributions, GetUSRScore, HCountEqualsQueryAtom, HCountGreaterQueryAtom, HCountLessQueryAtom, HasAgentTemplateSubstructMatch, HasBoolPropWithValueQueryAtom, HasBoolPropWithValueQueryBond, HasChiralTagQueryAtom, HasDoublePropWithValueQueryAtom, HasDoublePropWithValueQueryBond, HasIntPropWithValueQueryAtom, HasIntPropWithValueQueryBond, HasProductTemplateSubstructMatch, HasPropQueryAtom, HasPropQueryBond, HasReactantTemplateSubstructMatch, HasReactionAtomMapping, HasReactionSubstructMatch, HasStringPropWithValueQueryAtom, HasStringPropWithValueQueryBond, HybridizationEqualsQueryAtom, HybridizationGreaterQueryAtom, HybridizationLessQueryAtom, HybridizationType, InNRingsEqualsQueryAtom, InNRingsGreaterQueryAtom, InNRingsLessQueryAtom, IsAliphaticQueryAtom, IsAromaticQueryAtom, IsInRingQueryAtom, IsReactionTemplateMoleculeAgent, IsUnsaturatedQueryAtom, IsotopeEqualsQueryAtom, IsotopeGreaterQueryAtom, IsotopeLessQueryAtom, KDG, Kekulize, LayeredFingerprint, LogErrorMsg, LogWarningMsg, MCS, MMFFGetMoleculeForceField, MMFFGetMoleculeProperties, MMFFHasAllMoleculeParams, MMFFOptimizeMolecule, MMFFOptimizeMoleculeConfs, MMFFSanitizeMolecule, MQNs_, MakePropertyRangeQuery, MassEqualsQueryAtom, MassGreaterQueryAtom, MassLessQueryAtom, MatchOnlyAtRgroupsAdjustParams, MergeQueryHs, MinRingSizeEqualsQueryAtom, MinRingSizeGreaterQueryAtom, MinRingSizeLessQueryAtom, MissingChiralTagQueryAtom, Mol, MolAddRecursiveQueries, MolBundle, MolCatalog, MolChemicalFeature, MolChemicalFeatureFactory, MolFragmentToSmiles, MolFromFASTA, MolFromHELM, MolFromMol2Block, MolFromMol2File, MolFromMolBlock, MolFromMolFile, MolFromPDBBlock, MolFromPDBFile, MolFromQuerySLN, MolFromSLN, MolFromSequence, MolFromSmarts, MolFromSmiles, MolFromTPLBlock, MolFromTPLFile, MolSurf, MolToFASTA, MolToHELM, MolToMolBlock, MolToMolFile, MolToPDBBlock, MolToPDBFile, MolToSVG, MolToSequence, MolToSmarts, MolToSmiles, MolToTPLBlock, MolToTPLFile, MurckoDecompose, NumRadicalElectronsEqualsQueryAtom, NumRadicalElectronsGreaterQueryAtom, NumRadicalElectronsLessQueryAtom, NumRotatableBondsOptions, O3A, PDBWriter, PEOE_VSA_, ParseMolQueryDefFile, PathToSubmol, PatternFingerprint, PeriodicTable, PreprocessReaction, Properties, PropertyFunctor, PropertyPickleOptions, PropertyRangeQuery, PyMol, PythonPropertyFunctor, QED, QueryAtom, QueryBond, RDKFingerprint, ROMolList, RWMol, RandomSampleAllBBsStrategy, RandomSampleStrategy, RandomTransform, ReactionFingerprintParams, ReactionFromMolecule, ReactionFromRxnBlock, ReactionFromRxnFile, ReactionFromSmarts, ReactionToMolecule, ReactionToRxnBlock, ReactionToSmarts, ReactionToSmiles, ReduceProductToSideChains, RemoveHs, RemoveMappingNumbersFromReactions, RemoveStereochemistry, RenumberAtoms, ReplaceCore, ReplaceSidechains, ReplaceSubstructs, ResonanceFlags, ResonanceMolSupplier, RingBondCountEqualsQueryAtom, RingBondCountGreaterQueryAtom, RingBondCountLessQueryAtom, RingInfo, SATIS, SDMolSupplier, SDWriter, SMR_VSA_, SaltRemover, SanitizeFlags, SanitizeMol, SanitizeRxn, SetAngleDeg, SetAngleRad, SetAromaticity, SetAtomAlias, SetAtomRLabel, SetAtomValue, SetBondLength, SetConjugation, SetDefaultPickleProperties, SetDihedralDeg, SetDihedralRad, SetHybridization, SetSupplementalSmilesLabel, ShapeProtrudeDist, ShapeTanimotoDist, ShowMols, SlogP_VSA_, SmilesMolSupplier, SmilesMolSupplierFromText, SmilesParserParams, SmilesWriter, SplitMolByPDBChainId, SplitMolByPDBResidues, TDTMolSupplier, TDTWriter, TemplateAlign, TotalDegreeEqualsQueryAtom, TotalDegreeGreaterQueryAtom, TotalDegreeLessQueryAtom, TotalValenceEqualsQueryAtom, TotalValenceGreaterQueryAtom, TotalValenceLessQueryAtom, TransformConformer, UFFGetMoleculeForceField, UFFHasAllMoleculeParams, UFFOptimizeMolecule, UFFOptimizeMoleculeConfs, UnfoldedRDKFingerprintCountBased, UpdateProductsStereochemistry, VectMolVect, VectSizeT, VectorOfStringVectors, WedgeMolBonds, WrapLogs, fmcs, inchi, rdChemReactions, rdChemicalFeatures, rdDepictor, rdForceFieldHelpers, rdMolAlign, rdMolCatalog, rdMolChemicalFeatures, rdMolDescriptors, rdPartialCharges, rdRGroupDecomposition, rdSLNParse, rdSubstructLibrary, rdfiltercatalog, rdfragcatalog, rdinchi, rdmolfiles, rdmolops, tossit

Function Details | [hide private]

### TransformMol(mol, tform, confId=-1, keepConfs=False) | source code
    Applies the transformation (usually a 4x4 double matrix) to a molecule
    if keepConfs is False then all but that conformer are removed

### ComputeMolShape(mol, confId=-1, boxDim=`(`20`,` 20`,` 20`)`, spacing=0.5, **kwargs) | source code
    returns a grid representation of the molecule's shape

### GetConformerRMS(mol, confId1, confId2, atomIds=None, prealigned=False) | source code
    Returns the RMS between two conformations.
    By default, the conformers will be aligned to the first conformer
    before the RMS calculation and, as a side-effect, the second will be left
    in the aligned state.

    Arguments:
      - mol:        the molecule
      - confId1:    the id of the first conformer
      - confId2:    the id of the second conformer
      - atomIds:    (optional) list of atom ids to use a points for
                    alingment - defaults to all atoms
      - prealigned: (optional) by default the conformers are assumed
                    be unaligned and the second conformer be aligned
                    to the first

### GetConformerRMSMatrix(mol, atomIds=None, prealigned=False) | source code
    Returns the RMS matrix of the conformers of a molecule.
    As a side-effect, the conformers will be aligned to the first
    conformer (i.e. the reference) and will left in the aligned state.

    Arguments:
      - mol:     the molecule
      - atomIds: (optional) list of atom ids to use a points for
                 alingment - defaults to all atoms
      - prealigned: (optional) by default the conformers are assumed
                    be unaligned and will therefore be aligned to the
                    first conformer

    Note that the returned RMS matrix is symmetrical, i.e. it is the
    lower half of the matrix, e.g. for 5 conformers:
    rmsmatrix = [ a,
                  b, c,
                  d, e, f,
                  g, h, i, j]
    where a is the RMS between conformers 0 and 1, b is the RMS between
    conformers 0 and 2, etc.
    This way it can be directly used as distance matrix in e.g. Butina
    clustering.

### EnumerateLibraryFromReaction(reaction, sidechainSets, returnReactants=False) | source code
    Returns a generator for the virtual library defined by
     a reaction and a sequence of sidechain sets

    >>> from rdkit import Chem
    >>> from rdkit.Chem import AllChem
    >>> s1=[Chem.MolFromSmiles(x) for x in ('NC','NCC')]
    >>> s2=[Chem.MolFromSmiles(x) for x in ('OC=O','OC(=O)C')]
    >>> rxn = AllChem.ReactionFromSmarts('[O:2]=[C:1][OH].[N:3]>>[O:2]=[C:1][N:3]')
    >>> r = AllChem.EnumerateLibraryFromReaction(rxn,[s2,s1])
    >>> [Chem.MolToSmiles(x[0]) for x in list(r)]
    ['CNC=O', 'CCNC=O', 'CNC(C)=O', 'CCNC(C)=O']

    Note that this is all done in a lazy manner, so "infinitely" large libraries can
    be done without worrying about running out of memory. Your patience will run out first:

    Define a set of 10000 amines:
    >>> amines = (Chem.MolFromSmiles('N'+'C'*x) for x in range(10000))

    ... a set of 10000 acids
    >>> acids = (Chem.MolFromSmiles('OC(=O)'+'C'*x) for x in range(10000))

    ... now the virtual library (1e8 compounds in principle):
    >>> r = AllChem.EnumerateLibraryFromReaction(rxn,[acids,amines])

    ... look at the first 4 compounds:
    >>> [Chem.MolToSmiles(next(r)[0]) for x in range(4)]
    ['NC=O', 'CNC=O', 'CCNC=O', 'CCCNC=O']

### ConstrainedEmbed(mol, core, useTethers=True, coreConfId=-1, randomseed=2342, getForceField=<Boost.Python.function object at 0x30304e0>, **kwargs) | source code
    generates an embedding of a molecule where part of the molecule
    is constrained to have particular coordinates

    Arguments
      - mol: the molecule to embed
      - core: the molecule to use as a source of constraints
      - useTethers: (optional) if True, the final conformation will be
          optimized subject to a series of extra forces that pull the
          matching atoms to the positions of the core atoms. Otherwise
          simple distance constraints based on the core atoms will be
          used in the optimization.
      - coreConfId: (optional) id of the core conformation to use
      - randomSeed: (optional) seed for the random number generator

      An example, start by generating a template with a 3D structure:
      >>> from rdkit.Chem import AllChem
      >>> template = AllChem.MolFromSmiles("c1nn(Cc2ccccc2)cc1")
      >>> AllChem.EmbedMolecule(template)
      0
      >>> AllChem.UFFOptimizeMolecule(template)
      0

      Here's a molecule:
      >>> mol = AllChem.MolFromSmiles("c1nn(Cc2ccccc2)cc1-c3ccccc3")

      Now do the constrained embedding
      >>> newmol=AllChem.ConstrainedEmbed(mol, template)

      Demonstrate that the positions are the same:
      >>> newp=newmol.GetConformer().GetAtomPosition(0)
      >>> molp=mol.GetConformer().GetAtomPosition(0)
      >>> list(newp-molp)==[0.0,0.0,0.0]
      True
      >>> newp=newmol.GetConformer().GetAtomPosition(1)
      >>> molp=mol.GetConformer().GetAtomPosition(1)
      >>> list(newp-molp)==[0.0,0.0,0.0]
      True

### AssignBondOrdersFromTemplate(refmol, mol) | source code
    assigns bond orders to a molecule based on the
        bond orders in a template molecule

    Arguments
      - refmol: the template molecule
      - mol: the molecule to assign bond orders to

      An example, start by generating a template from a SMILES
      and read in the PDB structure of the molecule
      >>> import os
      >>> from rdkit.Chem import AllChem
      >>> template = AllChem.MolFromSmiles("CN1C(=NC(C1=O)(c2ccccc2)c3ccccc3)N")
      >>> mol = AllChem.MolFromPDBFile(os.path.join(RDConfig.RDCodeDir, 'Chem', 'test_data', '4DJU_lig.pdb'))
      >>> len([1 for b in template.GetBonds() if b.GetBondTypeAsDouble() == 1.0])
      8
      >>> len([1 for b in mol.GetBonds() if b.GetBondTypeAsDouble() == 1.0])
      22

      Now assign the bond orders based on the template molecule
      >>> newMol = AllChem.AssignBondOrdersFromTemplate(template, mol)
      >>> len([1 for b in newMol.GetBonds() if b.GetBondTypeAsDouble() == 1.0])
      8

      Note that the template molecule should have no explicit hydrogens
      else the algorithm will fail.

      It also works if there are different formal charges (this was github issue 235):
      >>> template=AllChem.MolFromSmiles('CN(C)C(=O)Cc1ccc2c(c1)NC(=O)c3ccc(cc3N2)c4ccc(c(c4)OC)[N+](=O)[O-]')
      >>> mol = AllChem.MolFromMolFile(os.path.join(RDConfig.RDCodeDir, 'Chem', 'test_data', '4FTR_lig.mol'))
      >>> AllChem.MolToSmiles(mol)
      'COC1CC(C2CCC3C(O)NC4CC(CC(O)N(C)C)CCC4NC3C2)CCC1N(O)O'
      >>> newMol = AllChem.AssignBondOrdersFromTemplate(template, mol)
      >>> AllChem.MolToSmiles(newMol)
      'COc1cc(-c2ccc3c(c2)Nc2ccc(CC(=O)N(C)C)cc2NC3=O)ccc1[N+](=O)[O-]'

Variables Details | [hide private]

  ### ADJUST_IGNOREALL Value:
      rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREALL

  ### ADJUST_IGNORECHAINS Value:
      rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORECHAINS

  ### ADJUST_IGNOREDUMMIES Value:
      rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREDUMMIES

  ### ADJUST_IGNORENONDUMMIES Value:
      rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONDUMMIES

  ### ADJUST_IGNORENONE Value:
      rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONE

  ### ADJUST_IGNORERINGS Value:
      rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORERINGS

  ### ALLOW_CHARGE_SEPARATION Value:
      rdkit.Chem.rdchem.ResonanceFlags.ALLOW_CHARGE_SEPARATION

  ### ALLOW_INCOMPLETE_OCTETS Value:
      rdkit.Chem.rdchem.ResonanceFlags.ALLOW_INCOMPLETE_OCTETS

  ### AROMATICITY_CUSTOM Value:
      rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_CUSTOM

  ### AROMATICITY_DEFAULT Value:
      rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_DEFAULT

  ### AROMATICITY_RDKIT Value:
      rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_RDKIT

  ### AROMATICITY_SIMPLE Value:
      rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_SIMPLE

  ### CHI_TETRAHEDRAL_CCW Value:
      rdkit.Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CCW

  ### CHI_TETRAHEDRAL_CW Value:
      rdkit.Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CW

  ### COMPOSITE_AND Value:
      rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_AND

  ### COMPOSITE_XOR Value:
      rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_XOR

  ### ComputedProps Value:
      rdkit.Chem.rdchem.PropertyPickleOptions.ComputedProps

  ### PrivateProps Value:
      rdkit.Chem.rdchem.PropertyPickleOptions.PrivateProps

  ### QueryAtomData Value:
      rdkit.Chem.rdchem.PropertyPickleOptions.QueryAtomData

  ### SANITIZE_ADJUSTHS Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ADJUSTHS

  ### SANITIZE_ADJUST_REACTANTS Value:
      rdkit.Chem.rdChemReactions.SanitizeFlags.SANITIZE_ADJUST_REACTANTS

  ### SANITIZE_ALL Value:
      rdkit.Chem.rdChemReactions.SanitizeFlags.SANITIZE_ALL

  ### SANITIZE_ATOM_MAPS Value:
      rdkit.Chem.rdChemReactions.SanitizeFlags.SANITIZE_ATOM_MAPS

  ### SANITIZE_CLEANUP Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUP

  ### SANITIZE_CLEANUPCHIRALITY Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUPCHIRALITY

  ### SANITIZE_FINDRADICALS Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_FINDRADICALS

  ### SANITIZE_KEKULIZE Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_KEKULIZE

  ### SANITIZE_MERGEHS Value:
      rdkit.Chem.rdChemReactions.SanitizeFlags.SANITIZE_MERGEHS

  ### SANITIZE_NONE Value:
      rdkit.Chem.rdChemReactions.SanitizeFlags.SANITIZE_NONE

  ### SANITIZE_PROPERTIES Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_PROPERTIES

  ### SANITIZE_RGROUP_NAMES Value:
      rdkit.Chem.rdChemReactions.SanitizeFlags.SANITIZE_RGROUP_NAMES

  ### SANITIZE_SETAROMATICITY Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETAROMATICITY

  ### SANITIZE_SETCONJUGATION Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETCONJUGATION

  ### SANITIZE_SETHYBRIDIZATION Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETHYBRIDIZATION

  ### SANITIZE_SYMMRINGS Value:
      rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SYMMRINGS

  ### UNCONSTRAINED_ANIONS Value:
      rdkit.Chem.rdchem.ResonanceFlags.UNCONSTRAINED_ANIONS

  ### UNCONSTRAINED_CATIONS Value:
      rdkit.Chem.rdchem.ResonanceFlags.UNCONSTRAINED_CATIONS