public void TestBug1701073()
{
string[] smiles = new string[]
{
"C1CCCC=2[C]1(C(=O)NN2)C",
"C1CCCC=2[C]1(C(=O)NN2)O",
"C[Si](C)(C)[CH](Br)CC(F)(Br)F",
"c1(ccc(cc1)O)C#N",
"CCN(CC)C#CC#CC(=O)OC",
"C(#CN1CCCCC1)[Sn](C)(C)C",
"c1([As+](c2ccccc2)(c2ccccc2)C)ccccc1.[I-]",
"c1(noc(n1)CCC(=O)N(CC)CC)c1ccc(cc1)C",
"c1c(c(ccc1)O)/C=N/CCCC",
"c1(ccc(cc1)C#Cc1ccc(cc1)C#C)OC",
};
var sp = CDK.SmilesParser;
foreach (var smile in smiles)
{
var mol = sp.ParseSmiles(smile);
AddImplicitHydrogens(mol);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol);
var descriptor = CreateDescriptor(mol);
foreach (var atom in mol.Atoms)
{
var dummy = descriptor.Calculate(atom).Value;
}
}
}
public void TestFingerprint()
{
IFingerprinter printer = new PubchemFingerprinter();
var adder = CDK.HydrogenAdder;
var mol1 = parser.ParseSmiles("c1ccccc1CCc1ccccc1");
var mol2 = parser.ParseSmiles("c1ccccc1CC");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol1);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol2);
adder.AddImplicitHydrogens(mol1);
adder.AddImplicitHydrogens(mol2);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol1);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol2);
Aromaticity.CDKLegacy.Apply(mol1);
Aromaticity.CDKLegacy.Apply(mol2);
BitArray bs1 = printer.GetBitFingerprint(mol1).AsBitSet();
BitArray bs2 = printer.GetBitFingerprint(mol2).AsBitSet();
Assert.AreEqual(881, printer.Length);
Assert.IsFalse(FingerprinterTool.IsSubset(bs1, bs2),
"c1ccccc1CC was detected as a subset of c1ccccc1CCc1ccccc1");
}
private IAtomContainer LoadSmi(string smi)
{
var mol = smipar.ParseSmiles(smi);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol);
return(mol);
}
public static IAtomContainer ParseSmiles(string smiles)
{
var molecule = CDK.SmilesParser.ParseSmiles(smiles);
AtomContainerManipulator.PercieveAtomTypesAndConfigureUnsetProperties(molecule);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(molecule);
Aromaticity.CDKLegacy.Apply(molecule);
return(molecule);
}
// check if the first atom of the container is accepted
static void Test(IAtomContainer container, CoordinateType type, string mesg, bool hnorm)
{
Assert.AreEqual(type, Stereocenters.Of(container).ElementType(0), mesg);
if (hnorm)
{
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container);
Assert.AreEqual(type, Stereocenters.Of(container).ElementType(0), mesg + " (unsupressed hydrogens)");
}
}
/// <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 void TestEthaneIncludeTerminalsExplicitH()
{
var container = MakeEthane();
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container);
var adder = CDK.HydrogenAdder;
adder.AddImplicitHydrogens(container);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container);
var result = CreateDescriptor().Calculate(container, true, false);
Assert.AreEqual(1, result.Value);
}
/// <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));
}
public void TestCID25181289()
{
var mol = parser.ParseSmiles("C=C(C1=CC=C(C=C1)O)NNC2=C(C(=NC(=C2Cl)Cl)C(=O)O)Cl");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
var adder = CDK.HydrogenAdder;
adder.AddImplicitHydrogens(mol);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol);
Aromaticity.CDKLegacy.Apply(mol);
IFingerprinter printer = new PubchemFingerprinter();
BitArray fp = printer.GetBitFingerprint(mol).AsBitSet();
BitArray ref_ = PubchemFingerprinter
.Decode("AAADccBzMAAGAAAAAAAAAAAAAAAAAAAAAAA8QAAAAAAAAAABwAAAHgIYCAAADA6BniAwzpJqEgCoAyTyTASChCAnJiIYumGmTtgKJnLD1/PEdQhkwBHY3Qe82AAOIAAAAAAAAABAAAAAAAAAAAAAAAAAAA==");
Assert.IsTrue(BitArrays.Equals(ref_, fp));
}
public void TestCID5934166()
{
var mol = parser.ParseSmiles("C1=CC=C(C=C1)C[N+]2=C(C=C(C=C2C=CC3=CC=CC=C3)C4=CC=CC=C4)C5=CC=CC=C5");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
var adder = CDK.HydrogenAdder;
adder.AddImplicitHydrogens(mol);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol);
Aromaticity.CDKLegacy.Apply(mol);
IFingerprinter printer = new PubchemFingerprinter();
BitArray fp = printer.GetBitFingerprint(mol).AsBitSet();
BitArray ref_ = PubchemFingerprinter
.Decode("AAADceB+AAAAAAAAAAAAAAAAAAAAAAAAAAA8YMGCAAAAAAAB1AAAHAAAAAAADAjBHgQwgJMMEACgAyRiRACCgCAhAiAI2CA4ZJgIIOLAkZGEIAhggADIyAcQgMAOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==");
Assert.IsTrue(BitArrays.Equals(ref_, fp));
}
public void TestCID2518130()
{
var mol = parser.ParseSmiles("COC1C(C(C(C(O1)CO)OC2C(C(C(C(O2)CO)S)O)O)O)O");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
var adder = CDK.HydrogenAdder;
adder.AddImplicitHydrogens(mol);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol);
Aromaticity.CDKLegacy.Apply(mol);
IFingerprinter printer = new PubchemFingerprinter();
BitArray fp = printer.GetBitFingerprint(mol).AsBitSet();
BitArray ref_ = PubchemFingerprinter
.Decode("AAADceBwPABAAAAAAAAAAAAAAAAAAAAAAAAkSAAAAAAAAAAAAAAAGgQACAAACBS0wAOCCAAABgQAAAAAAAAAAAAAAAAAAAAAAAAREAIAAAAiQAAFAAAHAAHAYAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==");
Assert.IsTrue(BitArrays.Equals(ref_, fp));
}
public void TestBenzene()
{
var mol = parser.ParseSmiles("c1ccccc1");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
var adder = CDK.HydrogenAdder;
adder.AddImplicitHydrogens(mol);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol);
Aromaticity.CDKLegacy.Apply(mol);
IFingerprinter printer = new PubchemFingerprinter();
BitArray fp = printer.GetBitFingerprint(mol).AsBitSet();
BitArray ref_ = PubchemFingerprinter
.Decode("AAADcYBgAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAABAAAAGAAAAAAACACAEAAwAIAAAACAACBCAAACAAAgAAAIiAAAAIgIICKAERCAIAAggAAIiAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==");
Assert.IsTrue(BitArrays.Equals(ref_, fp));
}
public void TestBenzeneFromSmiles()
{
var sp = CDK.SmilesParser;
mol = sp.ParseSmiles("C1=CC=CC=C1");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
Aromaticity.CDKLegacy.Apply(mol);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol);
matcher.RingSet = GetRings();
foreach (var atom in mol.Atoms)
{
if (atom.Symbol.Equals("C"))
{
Assert.IsTrue(TestAtom("SaaCH", atom));
}
}
}
public static void Script8_3()
{
var parser = new SmilesParser();
var hAdder = CDKHydrogenAdder.GetInstance();
var methanol = parser.ParseSmiles("CO");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(methanol);
hAdder.AddImplicitHydrogens(methanol);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(methanol);
var dimethoxymethane = parser.ParseSmiles("COC");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(dimethoxymethane);
hAdder.AddImplicitHydrogens(dimethoxymethane);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(dimethoxymethane);
var water = parser.ParseSmiles("O");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(water);
hAdder.AddImplicitHydrogens(water);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(water);
var reaction = new Reaction();
reaction.Reactants.Add(methanol, 2.0D);
reaction.Products.Add(dimethoxymethane);
reaction.Products.Add(water);
Console.WriteLine("Reactants:");
foreach (var reactant in reaction.Reactants)
{
var formula = MolecularFormulaManipulator.GetMolecularFormula(reactant);
Console.WriteLine(MolecularFormulaManipulator.GetString(formula));
}
Console.WriteLine("Products: ");
foreach (var product in reaction.Products)
{
var formula = MolecularFormulaManipulator.GetMolecularFormula(product);
Console.WriteLine(MolecularFormulaManipulator.GetString(formula));
}
}
public void TestGetFingerprintAsBytes()
{
var mol = parser.ParseSmiles("C=C(C1=CC=C(C=C1)O)NNC2=C(C(=NC(=C2Cl)Cl)C(=O)O)Cl");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
var adder = CDK.HydrogenAdder;
adder.AddImplicitHydrogens(mol);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol);
Aromaticity.CDKLegacy.Apply(mol);
PubchemFingerprinter printer = new PubchemFingerprinter();
BitArray fp = printer.GetBitFingerprint(mol).AsBitSet();
byte[] actual = printer.GetFingerprintAsBytes();
byte[] expected = Arrays.CopyOf(ToByteArray(fp), actual.Length);
Assert.IsTrue(Compares.AreEqual(expected, actual));
}
public void Ctor()
{
#region
SmilesParser sp = new SmilesParser();
IAtomContainer ac = sp.ParseSmiles("CC");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(ac);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(ac);
MMFF94PartialCharges mmff = new MMFF94PartialCharges();
mmff.AssignMMFF94PartialCharges(ac);
#endregion
foreach (var atom in ac.Atoms)
{
Console.WriteLine(
#region result
atom.GetProperty <double>("MMFF94charge")
#endregion
);
}
}
private static void AddExplicitHydrogens(IAtomContainer container)
{
try
{
var matcher = CDK.AtomTypeMatcher;
foreach (var atom in container.Atoms)
{
var type = matcher.FindMatchingAtomType(container, atom);
AtomTypeManipulator.Configure(atom, type);
}
var hAdder = CDK.HydrogenAdder;
hAdder.AddImplicitHydrogens(container);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container);
}
catch (Exception)
{
Debug.WriteLine("Error in hydrogen addition");
}
}
public void TestMultithReadedUsage()
{
var mol1 = parser.ParseSmiles("C=C(C1=CC=C(C=C1)O)NNC2=C(C(=NC(=C2Cl)Cl)C(=O)O)Cl");
IAtomContainer mol2 = parser
.ParseSmiles("C1=CC=C(C=C1)C[N+]2=C(C=C(C=C2C=CC3=CC=CC=C3)C4=CC=CC=C4)C5=CC=CC=C5");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol1);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol2);
var adder = CDK.HydrogenAdder;
adder.AddImplicitHydrogens(mol1);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol1);
Aromaticity.CDKLegacy.Apply(mol1);
adder.AddImplicitHydrogens(mol2);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol2);
Aromaticity.CDKLegacy.Apply(mol2);
IFingerprinter fp = new PubchemFingerprinter();
BitArray bs1 = fp.GetBitFingerprint(mol1).AsBitSet();
BitArray bs2 = fp.GetBitFingerprint(mol2).AsBitSet();
// now lets run some threads
var objs = new List <FpRunner>
{
new FpRunner(mol1),
new FpRunner(mol2)
};
var ret = Parallel.ForEach(objs, o => o.Call());
Assert.IsTrue(ret.IsCompleted);
BitArray fb1 = objs[0].Result;
Assert.IsNotNull(fb1);
BitArray fb2 = objs[1].Result;
Assert.IsNotNull(fb2);
Assert.IsTrue(BitArrays.Equals(bs1, fb1));
Assert.IsTrue(BitArrays.Equals(bs2, fb2));
}
public void TestUITTimeoutFix()
{
// Load molecules
var filename = "NCDK.Data.MDL.UITTimeout.sdf";
var ins = ResourceLoader.GetAsStream(filename);
var reader = new MDLV2000Reader(ins);
var content = reader.Read(builder.NewChemFile());
var cList = ChemFileManipulator.GetAllAtomContainers(content).ToReadOnlyList();
var molecules = new IAtomContainer[2];
for (int j = 0; j < 2; j++)
{
var aAtomContainer = cList[j];
var tmpMatcher = CDK.AtomTypeMatcher;
var tmpAdder = CDK.HydrogenAdder;
for (int i = 0; i < aAtomContainer.Atoms.Count; i++)
{
var tmpAtom = aAtomContainer.Atoms[i];
var tmpType = tmpMatcher.FindMatchingAtomType(aAtomContainer, tmpAtom);
AtomTypeManipulator.Configure(tmpAtom, tmpType);
tmpAdder.AddImplicitHydrogens(aAtomContainer, tmpAtom);
}
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(aAtomContainer);
molecules[j] = aAtomContainer;
}
var query = QueryAtomContainerCreator.CreateAnyAtomForPseudoAtomQueryContainer(molecules[1]);
// test
var starttime = System.DateTime.Now.Ticks;
uiTester.Timeout = 200;
uiTester.GetSubgraphAtomsMaps(molecules[0], query);
var duration = System.DateTime.Now.Ticks - starttime;
// The search must last much longer then two seconds if the timeout not works
Assert.IsTrue(duration < 2000 * 10000); // 1 msec = 10000 ticks
}
/// <summary>
/// Calculates the three classes of BCUT descriptors.
/// </summary>
/// <returns>An ArrayList containing the descriptors. The default is to return
/// all calculated eigenvalues of the Burden matrices in the order described
/// above. If a parameter list was supplied, then only the specified number
/// of highest and lowest eigenvalues (for each class of BCUT) will be returned.
/// </returns>
/// <param name="nhigh">The number of highest eigenvalue</param>
/// <param name="nlow">The number of lowest eigenvalue</param>
public Result Calculate(IAtomContainer container, int nhigh = 1, int nlow = 1)
{
container = (IAtomContainer)container.Clone();
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container);
var hAdder = CDK.HydrogenAdder;
hAdder.AddImplicitHydrogens(container);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container);
if (checkAromaticity)
{
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container);
Aromaticity.CDKLegacy.Apply(container);
}
try
{
return(CalculateMain(container, nhigh, nlow));
}
catch (CDKException e)
{
return(new Result(e));
}
}
public void TestBiphenyl()
{
//get the biphenyl as aromatic smiles
var parser = CDK.SmilesParser;
var biphenyl_aromaticsmiles = parser.ParseSmiles("c1ccccc1-c2ccccc2");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(biphenyl_aromaticsmiles);
var hAdder = CDK.HydrogenAdder;
hAdder.AddImplicitHydrogens(biphenyl_aromaticsmiles);
Aromaticity.CDKLegacy.Apply(biphenyl_aromaticsmiles);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(biphenyl_aromaticsmiles);
//get the biphenyl as Kekule smiles
var biphenyl_kekulesmiles = parser.ParseSmiles("C1=C(C=CC=C1)C2=CC=CC=C2");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(biphenyl_kekulesmiles);
hAdder = CDK.HydrogenAdder;
hAdder.AddImplicitHydrogens(biphenyl_kekulesmiles);
Aromaticity.CDKLegacy.Apply(biphenyl_kekulesmiles);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(biphenyl_kekulesmiles);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(biphenyl_aromaticsmiles, biphenyl_kekulesmiles));
}
/// <summary>
/// Convenience method that perceives atom types (CDK scheme) and
/// adds explicit hydrogens accordingly. It does not create 2D or 3D
/// coordinates for the new hydrogens.
/// </summary>
/// <param name="container">to which explicit hydrogens are added.</param>
protected void AddExplicitHydrogens(IAtomContainer container)
{
AddImplicitHydrogens(container);
AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container);
}
