/// <summary> /// Calculates the topological polar surface area and expresses it as a ratio to molecule size. /// </summary> /// <returns>Descriptor(s) retaining to polar surface area</returns> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); // type & assign implicit hydrogens var matcher = CDK.AtomTypeMatcher; foreach (var atom in container.Atoms) { var type = matcher.FindMatchingAtomType(container, atom); AtomTypeManipulator.Configure(atom, type); } var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(container); double polar = 0; double weight = 0; // polar surface area: chain it off the TPSADescriptor var tpsa = new TPSADescriptor(); var value = tpsa.Calculate(container); polar = value.Value; // molecular weight foreach (var atom in container.Atoms) { weight += CDK.IsotopeFactory.GetMajorIsotope(atom.Symbol).ExactMass.Value; weight += (atom.ImplicitHydrogenCount ?? 0) * 1.00782504; } return(new Result(weight == 0 ? 0 : polar / weight)); }
public StabilizationPlusChargeDescriptor(IAtomContainer container) { this.clonedContainer = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(this.clonedContainer); this.container = container; }
/// <summary> /// This method calculate the ATS Autocorrelation descriptor. /// </summary> public Result Calculate(IAtomContainer container, int count = DefaultSize) { container = (IAtomContainer)container.Clone(); container = AtomContainerManipulator.RemoveHydrogens(container); var w = ListConvertion(container); var natom = container.Atoms.Count; var distancematrix = TopologicalMatrix.GetMatrix(container); var masSum = new double[count]; for (int k = 0; k < count; k++) { for (int i = 0; i < natom; i++) { for (int j = 0; j < natom; j++) { if (distancematrix[i][j] == k) { masSum[k] += w[i] * w[j]; } else { masSum[k] += 0; } } } if (k > 0) { masSum[k] = masSum[k] / 2; } } return(new Result(masSum)); }
/// <summary> /// Calculates the FMF descriptor value for the given <see cref="IAtomContainer"/>. /// </summary> /// <returns>An object of <see cref="Result"/> that contains the /// calculated FMF descriptor value as well as specification details</returns> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); var fragmenter = new MurckoFragmenter(true, 3); fragmenter.GenerateFragments(container); var framework = fragmenter.GetFrameworksAsContainers().ToReadOnlyList(); var ringSystems = fragmenter.GetRingSystemsAsContainers().ToReadOnlyList(); { double result; if (framework.Count == 1) { result = framework[0].Atoms.Count / (double)container.Atoms.Count; } else if (framework.Count == 0 && ringSystems.Count == 1) { result = ringSystems[0].Atoms.Count / (double)container.Atoms.Count; } else { result = 0; } return(new Result(result)); } }
/// <summary> /// Calculate the complexity in the supplied <see cref="IAtomContainer"/>. /// </summary> /// <returns>the complexity</returns> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); int a = 0; double h = 0; foreach (var atom in container.Atoms) { switch (atom.AtomicNumber) { default: h++; goto case AtomicNumbers.C; case AtomicNumbers.C: a++; goto case AtomicNumbers.H; case AtomicNumbers.H: break; } } var b = container.Bonds.Count + AtomContainerManipulator.GetImplicitHydrogenCount(container); var c = Math.Abs(b * b - a * a + a) + (h / 100); return(new Result(c)); }
/// <param name="maxIterations">Number of maximum iterations</param> /// <param name="checkLonePairElectron">Checking lone pair electrons. Default <see langword="true"/></param> /// <param name="maxResonanceStructures">Number of maximum resonance structures to be searched</param> public PartialPiChargeDescriptor(IAtomContainer container, int maxIterations = int.MaxValue, bool checkLonePairElectron = true, int maxResonanceStructures = int.MaxValue) { clonedContainer = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(clonedContainer); var pepe = new GasteigerPEPEPartialCharges(); if (checkLonePairElectron) { CDK.LonePairElectronChecker.Saturate(clonedContainer); } if (maxIterations != int.MaxValue) { pepe.MaxGasteigerIterations = maxIterations; } if (maxResonanceStructures != int.MaxValue) { pepe.MaxResonanceStructures = maxResonanceStructures; } foreach (var catom in clonedContainer.Atoms) { catom.Charge = 0; } pepe.AssignGasteigerPiPartialCharges(clonedContainer, true); this.container = container; }
/// <summary> /// Calculate sp3/sp2 hybridization ratio in the supplied <see cref="IAtomContainer"/>. /// </summary> /// <returns>The ratio of sp3 to sp2 carbons</returns> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); int nsp2 = 0; int nsp3 = 0; foreach (var atom in container.Atoms) { if (!atom.AtomicNumber.Equals(AtomicNumbers.C)) { continue; } switch (atom.Hybridization) { case Hybridization.SP2: nsp2++; break; case Hybridization.SP3: nsp3++; break; } } double ratio = nsp3 / (double)(nsp2 + nsp3); return(new Result(ratio)); }
/// <summary> /// Returns deep copy of the molecule /// </summary> /// <param name="container"></param> /// <returns>deep copy of the mol</returns> public static IAtomContainer MakeDeepCopy(IAtomContainer container) { var newAtomContainer = (IAtomContainer)container.Clone(); newAtomContainer.NotifyChanged(); return(newAtomContainer); }
public override void TestClone() { IAtomContainer molecule = (IAtomContainer)NewChemObject(); object clone = molecule.Clone(); Assert.IsTrue(clone is IAtomContainer); Assert.AreNotSame(molecule, clone); }
/// <summary> /// Singleton template instance, mainly useful for aligning molecules. /// </summary> /// <remarks> /// If the template does not have coordinates an error is thrown. /// For safety we clone the molecule. /// </remarks> /// <param name="template">the molecule</param> /// <returns>new template handler</returns> public static TemplateHandler CreateSingleton(IAtomContainer template) { var handler = new TemplateHandler(); var copy = (IAtomContainer)template.Clone(); handler.AddMolecule(copy); return(handler); }
private bool ShowIt(IAtomContainer molecule, string name) { StructureDiagramGenerator sdg = new StructureDiagramGenerator { Molecule = (IAtomContainer)molecule.Clone() }; sdg.GenerateCoordinates(new Vector2(0, 1)); return(true); }
public Result Calculate(IAtomContainer container, Func <IAtomContainer, double> calcLogP = null, Func <IAtomContainer, int> calcHBondAcceptorCount = null, Func <IAtomContainer, int> calcHBondDonorCount = null, Func <IAtomContainer, double> calcWeight = null, Func <IAtomContainer, int> calcRotatableBondsCount = null) { // do aromaticity detection if (checkAromaticity) { container = (IAtomContainer)container.Clone(); // don't mod original AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); Aromaticity.CDKLegacy.Apply(container); } calcLogP = calcLogP ?? (mol => new XLogPDescriptor().Calculate(mol, correctSalicylFactor: true).Value); calcHBondAcceptorCount = calcHBondAcceptorCount ?? (mol => new HBondAcceptorCountDescriptor().Calculate(mol).Value); calcHBondDonorCount = calcHBondDonorCount ?? (mol => new HBondDonorCountDescriptor().Calculate(mol).Value); calcWeight = calcWeight ?? (mol => new WeightDescriptor().Calculate(mol).Value); calcRotatableBondsCount = calcRotatableBondsCount ?? (mol => new RotatableBondsCountDescriptor().Calculate(mol, includeTerminals: false, excludeAmides: true).Value); int lipinskifailures = 0; var xlogPvalue = calcLogP(container); var acceptors = calcHBondAcceptorCount(container); var donors = calcHBondDonorCount(container); var mwvalue = calcWeight(container); // exclude (heavy atom) terminal bonds // exclude amide C-N bonds because of their high rotational barrier // see Veber, D.F. et al., 2002, 45(12), pp.2615–23. var rotatablebonds = calcRotatableBondsCount(container); if (xlogPvalue > 5.0) { lipinskifailures += 1; } if (acceptors > 10) { lipinskifailures += 1; } if (donors > 5) { lipinskifailures += 1; } if (mwvalue > 500.0) { lipinskifailures += 1; } if (rotatablebonds > 10.0) { lipinskifailures += 1; } return(new Result(lipinskifailures)); }
public IPAtomicHOSEDescriptor(IAtomContainer container) { this.container = container; container = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); CDK.LonePairElectronChecker.Saturate(container); this.clonedContainer = container; }
public static IAtomContainer CreateAnyAtomAtomContainer(IAtomContainer atomContainer) { var query = (IAtomContainer)atomContainer.Clone(); for (int i = 0; i < query.Atoms.Count; i++) { query.Atoms[i].Symbol = "C"; } return(query); }
/// <summary> /// Given a structure in the correct configuration (explicit H and aromatised) it will return the logP as a Double /// or if it is out of domain (encounters an unknown atomtype) it will return <see cref="Double.NaN"/>. /// </summary> /// <param name="container">the structure to calculate which have explicit H and be aromatised.</param> /// <returns>The calculated logP</returns> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); var hAdder = CDK.HydrogenAdder; hAdder.AddImplicitHydrogens(container); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container); Aromaticity.CDKLegacy.Apply(container); return(new JPlogPCalculator(container, coeffs).Calculate()); }
public ProtonTotalPartialChargeDescriptor(IAtomContainer container) { clonedContainer = (IAtomContainer)container.Clone(); var peoe = new GasteigerMarsiliPartialCharges { MaxGasteigerIterations = 6 }; peoe.AssignGasteigerMarsiliSigmaPartialCharges(this.clonedContainer, true); this.container = container; }
public IsProtonInAromaticSystemDescriptor(IAtomContainer container, bool checkAromaticity = false) { clonedAtomContainer = (IAtomContainer)container.Clone(); if (checkAromaticity) { AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(clonedAtomContainer); Aromaticity.CDKLegacy.Apply(clonedAtomContainer); } this.container = container; }
/// <param name="maxIterations">Number of maximum iterations</param> public SigmaElectronegativityDescriptor(IAtomContainer container, int maxIterations = int.MaxValue) { this.clonedContainer = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(this.clonedContainer); electronegativity = new Electronegativity(); if (maxIterations != int.MaxValue) { electronegativity.MaxIterations = maxIterations; } this.container = container; }
/// <summary> /// Calculates the descriptor value using the <see cref="VABCVolume"/> class. /// </summary> /// <returns>A double containing the volume</returns> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); // don't mod original try { return(new Result(VABCVolume.Calculate(container))); } catch (CDKException e) { return(new Result(e)); } }
/// <param name="maxIterations">Number of maximum iterations</param> public PartialSigmaChargeDescriptor(IAtomContainer container, int maxIterations = int.MaxValue) { clonedContainer = (IAtomContainer)container.Clone(); var peoe = new GasteigerMarsiliPartialCharges(); if (maxIterations != int.MaxValue) { peoe.MaxGasteigerIterations = maxIterations; } peoe.AssignGasteigerMarsiliSigmaPartialCharges(clonedContainer, true); this.container = container; }
public PiContactDetectionDescriptor(IAtomContainer container, bool checkAromaticity = false) { clonedContainer = (IAtomContainer)container.Clone(); mol = clonedContainer.Builder.NewAtomContainer(clonedContainer); if (checkAromaticity) { AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol); Aromaticity.CDKLegacy.Apply(mol); } acSet = ConjugatedPiSystemsDetector.Detect(mol); this.container = container; }
/// <summary> /// Calculate the count of aromatic atoms in the supplied <see cref="IAtomContainer"/>. /// </summary> /// <remarks> /// The method take a boolean checkAromaticity: if the boolean is <see langword="true"/>, it means that /// aromaticity has to be checked. /// </remarks> /// <returns>the number of aromatic bonds</returns> public Result Calculate(IAtomContainer container) { if (checkAromaticity) { container = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); Aromaticity.CDKLegacy.Apply(container); } var count = container.Bonds.Count(bond => bond.IsAromatic); return(new Result(count)); }
/// <summary> /// Returns IAtomContainer without Hydrogen. If an AtomContainer has atom single atom which /// is atom Hydrogen then its not removed. /// </summary> /// <param name="atomContainer"></param> /// <returns>IAtomContainer without Hydrogen. If an AtomContainer has atom single atom which is atom Hydrogen then its not removed.</returns> public static IAtomContainer RemoveHydrogensExceptSingleAndPreserveAtomID(IAtomContainer atomContainer) { var map = new CDKObjectMap(); // maps original object to clones. if (atomContainer.Bonds.Count > 0) { var mol = (IAtomContainer)atomContainer.Clone(map); List <IAtom> remove = new List <IAtom>(); // lists removed Hs. foreach (var atom in atomContainer.Atoms) { if (atom.AtomicNumber.Equals(AtomicNumbers.H)) { remove.Add(atom); } } foreach (var a in remove) { mol.RemoveAtomAndConnectedElectronContainers(map.Get(a)); } foreach (var atom in mol.Atoms.Where(n => !n.ImplicitHydrogenCount.HasValue)) { atom.ImplicitHydrogenCount = 0; } // Recompute hydrogen counts of neighbours of removed Hydrogens. mol = RecomputeHydrogens(mol, atomContainer, remove, map); return(mol); } else { var mol = (IAtomContainer)atomContainer.Clone(map); if (string.Equals(atomContainer.Atoms[0].Symbol, "H", StringComparison.OrdinalIgnoreCase)) { Console.Error.WriteLine("WARNING: single hydrogen atom removal not supported!"); } return(mol); } }
/// <summary> /// This method calculate the ATS Autocorrelation descriptor. /// </summary> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); var hAdder = CDK.HydrogenAdder; hAdder.AddImplicitHydrogens(container); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container); Aromaticity.CDKLegacy.Apply(container); // get the distance matrix for pol calcs as well as for later on var distancematrix = PathTools.ComputeFloydAPSP(AdjacencyMatrix.GetMatrix(container)); var w = Listpolarizability(container, distancematrix); var natom = container.Atoms.Count; var polarizabilitySum = new double[5]; for (int k = 0; k < 5; k++) { for (int i = 0; i < natom; i++) { if (container.Atoms[i].AtomicNumber.Equals(AtomicNumbers.H)) { continue; } for (int j = 0; j < natom; j++) { if (container.Atoms[j].AtomicNumber.Equals(AtomicNumbers.H)) { continue; } if (distancematrix[i][j] == k) { polarizabilitySum[k] += w[i] * w[j]; } else { polarizabilitySum[k] += 0.0; } } } if (k > 0) { polarizabilitySum[k] = polarizabilitySum[k] / 2; } } return(new Result(polarizabilitySum)); }
/// <summary> /// Returns IAtomContainer without Hydrogen. If an AtomContainer has atom single atom which /// is atom Hydrogen then its not removed. /// </summary> /// <param name="atomContainer"></param> /// <returns>IAtomContainer without Hydrogen. If an AtomContainer has atom single atom which is atom Hydrogen then its not removed.</returns> public static IAtomContainer ConvertExplicitToImplicitHydrogens(IAtomContainer atomContainer) { IAtomContainer mol = (IAtomContainer)atomContainer.Clone(); ConvertImplicitToExplicitHydrogens(mol); if (mol.Atoms.Count > 1) { mol = RemoveHydrogens(mol); } else if (string.Equals(mol.Atoms.First().Symbol, "H", StringComparison.OrdinalIgnoreCase)) { Console.Error.WriteLine("WARNING: single hydrogen atom removal not supported!"); } return(mol); }
public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); // don't mod original // do aromaticity detection if (checkAromaticity) { AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); Aromaticity.CDKLegacy.Apply(container); } var count = tools.Select(n => n.MatchAll(container).Count()).Sum(); return(new Result(count)); }
/// <summary> /// Determine the number of amino acids groups the supplied <see cref="IAtomContainer"/>. /// </summary> /// <returns>the number of aromatic atoms of this AtomContainer</returns> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); var results = new List <int>(substructureSet.Count); var universalIsomorphismTester = new UniversalIsomorphismTester(); foreach (var substructure in substructureSet) { var maps = universalIsomorphismTester.GetSubgraphMaps(container, substructure); results.Add(maps.Count()); } return(new Result(results)); }
public void TestClone() { IAtomContainer molecule = TestMoleculeFactory.MakeAlphaPinene(); IAtomContainer clonedMol = (IAtomContainer)molecule.Clone(); Assert.IsTrue(molecule.Atoms.Count == clonedMol.Atoms.Count); for (int f = 0; f < molecule.Atoms.Count; f++) { for (int g = 0; g < clonedMol.Atoms.Count; g++) { Assert.IsNotNull(molecule.Atoms[f]); Assert.IsNotNull(clonedMol.Atoms[g]); Assert.IsTrue(molecule.Atoms[f] != clonedMol.Atoms[g]); } } }
public void TestFingerPrint() { IFingerprinter printer = new GraphOnlyFingerprinter(); IAtomContainer mol1 = CreateMolecule(molecule_test_2); IAtomContainer mol2 = CreateMolecule(ethanolamine); Assert.IsTrue(new UniversalIsomorphismTester().IsSubgraph(mol1, mol2), "SubGraph does NOT match"); BitArray bs1 = printer.GetBitFingerprint((IAtomContainer)mol1.Clone()).AsBitSet(); BitArray bs2 = printer.GetBitFingerprint((IAtomContainer)mol2.Clone()).AsBitSet(); Assert.IsTrue(FingerprinterTool.IsSubset(bs1, bs2), "Subset (with fingerprint) does NOT match"); // Match OK Debug.WriteLine("Subset (with fingerprint) does match"); }
public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); int nSpiro = 0; Cycles.MarkRingAtomsAndBonds(container); foreach (var atom in container.Atoms) { if (GetSpiroDegree(container, atom) != 0) { nSpiro++; } } return(new Result(nSpiro)); }
/// <summary> Returns a ringset containing all rings in the given AtomContainer /// /// </summary> /// <param name="atomContainer"> The AtomContainer to be searched for rings /// </param> /// <returns> A RingSet with all rings in the AtomContainer /// </returns> /// <exception cref="CDKException"> An exception thrown if something goes wrong or if the timeout limit is reached /// </exception> public virtual IRingSet findAllRings(IAtomContainer atomContainer) { startTime = (System.DateTime.Now.Ticks - 621355968000000000) / 10000; SpanningTree spanningTree; try { spanningTree = new SpanningTree((IAtomContainer)atomContainer.Clone()); } //UPGRADE_NOTE: Exception 'java.lang.CloneNotSupportedException' was converted to 'System.Exception' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'" catch (System.Exception e) { throw new CDKException("Could not clone IAtomContainer!", e); } spanningTree.identifyBonds(); if (spanningTree.BondsCyclicCount < 37) { findAllRings(atomContainer, false); } return findAllRings(atomContainer, true); }
private static void getLargestAtomContainer(IAtomContainer firstAC, IAtomContainer secondAC) { if (firstAC.AtomCount < secondAC.AtomCount) { IAtomContainer tmp; try { tmp = (IAtomContainer)firstAC.Clone(); firstAC = (IAtomContainer)secondAC.Clone(); secondAC = (IAtomContainer)tmp.Clone(); } //UPGRADE_NOTE: Exception 'java.lang.CloneNotSupportedException' was converted to 'System.Exception' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'" catch (System.Exception e) { // TODO Auto-generated catch block SupportClass.WriteStackTrace(e, Console.Error); } } }