public void Ctor()
{
{
#region 1
IAtomContainer methane = new AtomContainer();
IAtom carbon = new Atom("C");
methane.Atoms.Add(carbon);
CDKAtomTypeMatcher matcher = CDKAtomTypeMatcher.GetInstance();
foreach (var atom in methane.Atoms)
{
IAtomType type = matcher.FindMatchingAtomType(methane, atom);
AtomTypeManipulator.Configure(atom, type);
}
var adder = CDK.HydrogenAdder;
adder.AddImplicitHydrogens(methane);
#endregion
}
{
#region 2
IAtomContainer ethane = new AtomContainer();
IAtom carbon1 = new Atom("C");
IAtom carbon2 = new Atom("C");
ethane.Atoms.Add(carbon1);
ethane.Atoms.Add(carbon2);
CDKAtomTypeMatcher matcher = CDKAtomTypeMatcher.GetInstance();
IAtomType type = matcher.FindMatchingAtomType(ethane, carbon1);
AtomTypeManipulator.Configure(carbon1, type);
var adder = CDK.HydrogenAdder;
adder.AddImplicitHydrogens(ethane, carbon1);
#endregion
}
}
/// <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 Result Calculate(IAtomContainer container)
{
// we don't make a clone, since removeHydrogens returns a deep copy
container = AtomContainerManipulator.RemoveHydrogens(container);
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);
var subgraph3 = Order3(container);
var subgraph4 = Order4(container);
var subgraph5 = Order5(container);
var subgraph6 = Order6(container);
var subgraph7 = Order7(container);
try
{
var order3s = ChiIndexUtils.EvalSimpleIndex(container, subgraph3);
var order4s = ChiIndexUtils.EvalSimpleIndex(container, subgraph4);
var order5s = ChiIndexUtils.EvalSimpleIndex(container, subgraph5);
var order6s = ChiIndexUtils.EvalSimpleIndex(container, subgraph6);
var order7s = ChiIndexUtils.EvalSimpleIndex(container, subgraph7);
var order3v = ChiIndexUtils.EvalValenceIndex(container, subgraph3);
var order4v = ChiIndexUtils.EvalValenceIndex(container, subgraph4);
var order5v = ChiIndexUtils.EvalValenceIndex(container, subgraph5);
var order6v = ChiIndexUtils.EvalValenceIndex(container, subgraph6);
var order7v = ChiIndexUtils.EvalValenceIndex(container, subgraph7);
return(new Result(new double[]
{
order3s,
order4s,
order5s,
order6s,
order7s,
order3v,
order4v,
order5v,
order6v,
order7v,
}));
}
catch (CDKException e)
{
return(new Result(e));
}
}
private void FindAndConfigureAtomTypesForAllAtoms(IAtomContainer container)
{
var atoms = container.Atoms.GetEnumerator();
while (atoms.MoveNext())
{
var atom = atoms.Current;
var type = matcher.FindMatchingAtomType(container, atom);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(atom, type);
}
}
/// <summary>
/// Convenience method that perceives atom types (CDK scheme) and
/// adds implicit hydrogens accordingly. It does not create 2D or 3D
/// coordinates for the new hydrogens.
/// </summary>
/// <param name="container">to which implicit hydrogens are added.</param>
protected override void AddImplicitHydrogens(IAtomContainer container)
{
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);
}
private void FindAndConfigureAtomTypesForAllAtoms(IAtomContainer container)
{
var matcher = CDK.AtomTypeMatcher;
foreach (var atom in container.Atoms)
{
var type = matcher.FindMatchingAtomType(container, atom);
if (type != null)
{
AtomTypeManipulator.Configure(atom, type);
}
}
}
public void TestMethane()
{
var molecule = builder.NewAtomContainer();
var newAtom = builder.NewAtom(ChemicalElement.C);
molecule.Atoms.Add(newAtom);
var type = matcher.FindMatchingAtomType(molecule, newAtom);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(newAtom, type);
adder.AddImplicitHydrogens(molecule);
Assert.IsNotNull(newAtom.ImplicitHydrogenCount);
Assert.AreEqual(4, newAtom.ImplicitHydrogenCount.Value);
}
public void TestWater()
{
var mol = builder.NewAtomContainer();
var oxygen = builder.NewAtom("O");
mol.Atoms.Add(oxygen);
var type = matcher.FindMatchingAtomType(mol, oxygen);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(oxygen, type);
adder.AddImplicitHydrogens(mol);
Assert.IsNotNull(oxygen.ImplicitHydrogenCount);
Assert.AreEqual(2, oxygen.ImplicitHydrogenCount.Value);
}
private static void PercieveAtomTypesAndConfigureAtoms(IAtomContainer container)
{
var matcher = SybylAtomTypeMatcher.GetInstance();
var atoms = container.Atoms.GetEnumerator();
while (atoms.MoveNext())
{
var atom = atoms.Current;
atom.AtomTypeName = null;
var matched = matcher.FindMatchingAtomType(container, atom);
if (matched != null)
{
AtomTypeManipulator.Configure(atom, matched);
}
}
}
private void HalogenTest(string halogen)
{
var mol = builder.NewAtomContainer();
var atom = builder.NewAtom(halogen);
mol.Atoms.Add(atom);
var type = matcher.FindMatchingAtomType(mol, atom);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(atom, type);
adder.AddImplicitHydrogens(mol);
Assert.AreEqual(1, mol.Atoms.Count);
Assert.IsNotNull(atom.ImplicitHydrogenCount);
Assert.AreEqual(1, atom.ImplicitHydrogenCount.Value);
}
public void TestAmmonium()
{
var mol = builder.NewAtomContainer();
var nitrogen = builder.NewAtom("N");
nitrogen.FormalCharge = +1;
mol.Atoms.Add(nitrogen);
var type = matcher.FindMatchingAtomType(mol, nitrogen);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(nitrogen, type);
adder.AddImplicitHydrogens(mol);
Assert.IsNotNull(nitrogen.ImplicitHydrogenCount);
Assert.AreEqual(4, nitrogen.ImplicitHydrogenCount.Value);
}
/// <summary>
/// Convenience method to perceive atom types for all <see cref="IAtom"/>s in the
/// <see cref="IAtomContainer"/>, using the <see cref="CDKAtomTypeMatcher"/>. If the
/// matcher finds atom matching atom type, the <see cref="IAtom"/> will be configured
/// to have the same properties as the <see cref="IAtomType"/>. If no matching atom
/// type is found, no configuration is performed.
/// </summary>
/// <param name="container"></param>
/// <exception cref="CDKException"></exception>
public static void PercieveAtomTypesAndConfigureAtoms(IAtomContainer container)
{
var matcher = CDK.AtomTypeMatcher;
foreach (var atom in container.Atoms)
{
if (!(atom is IPseudoAtom))
{
var matched = matcher.FindMatchingAtomType(container, atom);
if (matched != null)
{
AtomTypeManipulator.Configure(atom, matched);
}
}
}
}
public void TestSulfite()
{
var mol = builder.NewAtomContainer();
var s = builder.NewAtom("S");
var o1 = builder.NewAtom("O");
var o2 = builder.NewAtom("O");
var o3 = builder.NewAtom("O");
mol.Atoms.Add(s);
mol.Atoms.Add(o1);
mol.Atoms.Add(o2);
mol.Atoms.Add(o3);
var b1 = builder.NewBond(s, o1, BondOrder.Single);
var b2 = builder.NewBond(s, o2, BondOrder.Single);
var b3 = builder.NewBond(s, o3, BondOrder.Double);
mol.Bonds.Add(b1);
mol.Bonds.Add(b2);
mol.Bonds.Add(b3);
var type = matcher.FindMatchingAtomType(mol, s);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(s, type);
type = matcher.FindMatchingAtomType(mol, o1);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(o1, type);
type = matcher.FindMatchingAtomType(mol, o2);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(o2, type);
type = matcher.FindMatchingAtomType(mol, o3);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(o3, type);
adder.AddImplicitHydrogens(mol);
Assert.AreEqual(4, mol.Atoms.Count);
Assert.AreEqual(3, mol.Bonds.Count);
Assert.IsNotNull(s.ImplicitHydrogenCount);
Assert.AreEqual(0, s.ImplicitHydrogenCount.Value);
Assert.IsNotNull(o1.ImplicitHydrogenCount);
Assert.AreEqual(1, o1.ImplicitHydrogenCount.Value);
Assert.IsNotNull(o2.ImplicitHydrogenCount);
Assert.AreEqual(1, o2.ImplicitHydrogenCount.Value);
Assert.IsNotNull(o3.ImplicitHydrogenCount);
Assert.AreEqual(0, o3.ImplicitHydrogenCount.Value);
}
public void TestSulphur()
{
var mol = builder.NewAtomContainer();
var atom = builder.NewAtom("S");
mol.Atoms.Add(atom);
var type = matcher.FindMatchingAtomType(mol, atom);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(atom, type);
Assert.AreNotEqual(2, atom.ImplicitHydrogenCount);
adder.AddImplicitHydrogens(mol);
Assert.AreEqual(1, mol.Atoms.Count);
Assert.IsNotNull(atom.ImplicitHydrogenCount);
Assert.AreEqual(2, atom.ImplicitHydrogenCount.Value);
}
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");
}
}
private bool createBondsWithRebondTool(IBioPolymer pol)
{
RebondTool tool = new RebondTool(2.0, 0.5, 0.5);
try
{
// configure atoms
AtomTypeFactory factory = AtomTypeFactory.getInstance("jmol_atomtypes.txt", pol.Builder);
IAtom[] atoms = pol.Atoms;
for (int i = 0; i < atoms.Length; i++)
{
try
{
IAtomType[] types = factory.getAtomTypes(atoms[i].Symbol);
if (types.Length > 0)
{
// just pick the first one
AtomTypeManipulator.configure(atoms[i], types[0]);
}
else
{
System.Console.Out.WriteLine("Could not configure atom with symbol: " + atoms[i].Symbol);
}
}
catch (System.Exception e)
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
System.Console.Out.WriteLine("Could not configure atom (but don't care): " + e.Message);
//logger.debug(e);
}
}
tool.rebond(pol);
}
catch (System.Exception e)
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
//logger.error("Could not rebond the polymer: " + e.Message);
//logger.debug(e);
}
return(true);
}
/// <summary>
/// Helper method to test if atom types are correctly perceived. Meanwhile, it maintains a list
/// of atom types that have been tested so far, which allows testing afterwards that all atom
/// types are at least tested once.
/// </summary>
/// <param name="testedAtomTypes">List of atom types tested so far.</param>
/// <param name="expectedTypes">Expected atom types for the atoms given in <paramref name="mol"/>.</param>
/// <param name="mol">The <see cref="IAtomContainer"/> with <see cref="IAtom"/>s for which atom types should be perceived.</param>
/// <exception cref="System.Exception">Thrown if something went wrong during the atom type perception.</exception>
public virtual void AssertAtomTypes(IDictionary <string, int> testedAtomTypes, string[] expectedTypes, IAtomContainer mol)
{
Assert.AreEqual(expectedTypes.Length, mol.Atoms.Count, "The number of expected atom types is unequal to the number of atoms");
var atm = GetAtomTypeMatcher(mol.Builder);
for (int i = 0; i < expectedTypes.Length; i++)
{
var testedAtom = mol.Atoms[i];
var foundType = atm.FindMatchingAtomType(mol, testedAtom);
AssertAtomType(testedAtomTypes, "Incorrect perception for atom " + i, expectedTypes[i], foundType);
AssertConsistentProperties(mol, testedAtom, foundType);
// test for bug #1890702: configure, and then make sure the same atom type is perceived
AtomTypeManipulator.Configure(testedAtom, foundType);
var secondType = atm.FindMatchingAtomType(mol, testedAtom);
AssertAtomType(
testedAtomTypes,
$"Incorrect perception *after* assigning atom type properties for atom {i}",
expectedTypes[i],
secondType);
}
}
public void TestHydrogen()
{
var mol = builder.NewAtomContainer();
var proton = builder.NewAtom("H");
mol.Atoms.Add(proton);
var type = matcher.FindMatchingAtomType(mol, proton);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(proton, type);
adder.AddImplicitHydrogens(mol);
Assert.AreEqual(1, mol.Atoms.Count);
IMolecularFormula formula = MolecularFormulaManipulator.GetMolecularFormula(mol);
Assert.AreEqual(2, MolecularFormulaManipulator.GetElementCount(formula, ChemicalElement.H));
Assert.AreEqual(0, mol.GetConnectedBonds(proton).Count());
Assert.IsNotNull(proton.ImplicitHydrogenCount);
Assert.AreEqual(1, proton.ImplicitHydrogenCount.Value);
}
public void TestFormaldehyde()
{
var molecule = builder.NewAtomContainer();
var newAtom = builder.NewAtom(ChemicalElement.C);
var newAtom2 = builder.NewAtom(ChemicalElement.O);
molecule.Atoms.Add(newAtom);
molecule.Atoms.Add(newAtom2);
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Double);
var type = matcher.FindMatchingAtomType(molecule, newAtom);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(newAtom, type);
type = matcher.FindMatchingAtomType(molecule, newAtom2);
Assert.IsNotNull(type);
AtomTypeManipulator.Configure(newAtom2, type);
adder.AddImplicitHydrogens(molecule);
Assert.IsNotNull(newAtom.ImplicitHydrogenCount);
Assert.IsNotNull(newAtom2.ImplicitHydrogenCount);
Assert.AreEqual(2, newAtom.ImplicitHydrogenCount.Value);
Assert.AreEqual(0, newAtom2.ImplicitHydrogenCount.Value);
}
private static void TypeAndRetype(string smiles)
{
var mol = smilesParser.ParseSmiles(smiles);
var types = atomTypeMatcher.FindMatchingAtomTypes(mol).ToReadOnlyList();
for (int i = 0; i < types.Count; i++)
{
AtomTypeManipulator.Configure(mol.Atoms[i], types[i]);
}
var retyped = atomTypeMatcher.FindMatchingAtomTypes(mol).ToReadOnlyList();
for (int i = 0; i < types.Count; i++)
{
Assert.AreEqual(types[i], retyped[i],
$"First perception resulted in {types[i]} but the second perception gave {retyped[i]}");
}
retyped = atomTypeMatcher.FindMatchingAtomTypes(mol).ToReadOnlyList();
for (int i = 0; i < types.Count; i++)
{
Assert.AreEqual(types[i], retyped[i],
$"First perception resulted in {types[i]} but the third perception gave {retyped[i]}");
}
}
private static bool CreateBondsWithRebondTool(IAtomContainer molecule)
{
var tool = new RebondTool(2.0, 0.5, 0.5);
try
{
foreach (var atom in molecule.Atoms)
{
try
{
var types = factory.GetAtomTypes(atom.Symbol);
var type = types.FirstOrDefault();
if (type != null)
{
// just pick the first one
AtomTypeManipulator.Configure(atom, type);
}
else
{
Trace.TraceWarning("Could not configure atom with symbol: " + atom.Symbol);
}
}
catch (Exception e)
{
Trace.TraceWarning("Could not configure atom (but don't care): " + e.Message);
Debug.WriteLine(e);
}
}
tool.Rebond(molecule);
}
catch (Exception e)
{
Trace.TraceError($"Could not rebond the polymer: {e.Message}");
Debug.WriteLine(e);
}
return(true);
}
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
}
public void TestButadiene()
{
var mol = new AtomContainer();
var carbon = new AtomType(ChemicalElement.C);
var a0 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 2
};
AtomTypeManipulator.ConfigureUnsetProperties(a0, carbon);
var a1 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a1, carbon);
var a2 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a2, carbon);
var a3 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 2
};
AtomTypeManipulator.ConfigureUnsetProperties(a3, carbon);
mol.Atoms.Add(a0);
mol.Atoms.Add(a1);
mol.Atoms.Add(a2);
mol.Atoms.Add(a3);
var b0 = new Bond(a0, a1)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b0);
var b1 = new Bond(a1, a2)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b1);
IBond b2 = new Bond(a2, a3)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b2);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
atasc.DecideBondOrder(mol, true);
Assert.AreEqual(BondOrder.Double, mol.Bonds[0].Order);
Assert.AreEqual(BondOrder.Single, mol.Bonds[1].Order);
Assert.AreEqual(BondOrder.Double, mol.Bonds[2].Order);
}
public void TestASimpleCarbonRing()
{
// First we create a simple carbon ring to play with...
var mol = new AtomContainer();
var carbon = new AtomType(ChemicalElement.C);
var a0 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a0, carbon);
var a1 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a1, carbon);
var a2 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a2, carbon);
var a3 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a3, carbon);
var a4 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a4, carbon);
var a5 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a5, carbon);
mol.Atoms.Add(a0);
mol.Atoms.Add(a1);
mol.Atoms.Add(a2);
mol.Atoms.Add(a3);
mol.Atoms.Add(a4);
mol.Atoms.Add(a5);
var b0 = new Bond(a0, a1)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b0);
var b1 = new Bond(a1, a2)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b1);
var b2 = new Bond(a2, a3)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b2);
var b3 = new Bond(a3, a4)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b3);
var b4 = new Bond(a4, a5)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b4);
var b5 = new Bond(a5, a0)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b5);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
// ...then we send it to the method we want to test...
atasc.DecideBondOrder(mol, false);
Assert.AreEqual(BondOrder.Double, b0.Order);
Assert.AreEqual(BondOrder.Single, b1.Order);
Assert.AreEqual(BondOrder.Double, b2.Order);
Assert.AreEqual(BondOrder.Single, b3.Order);
Assert.AreEqual(BondOrder.Double, b4.Order);
Assert.AreEqual(BondOrder.Single, b5.Order);
Assert.IsTrue(satcheck.IsSaturated(a0, mol));
}
/// <summary>
/// Read a Reaction from a file in MDL RXN format
/// </summary>
/// <returns>The Reaction that was read from the MDL file.</returns>
private IAtomContainer ReadMolecule(IAtomContainer molecule)
{
try
{
int atomCount = 0;
int bondCount = 0;
string line;
while (true)
{
line = input.ReadLine();
if (line == null)
{
return(null);
}
if (line.StartsWith("@<TRIPOS>MOLECULE", StringComparison.Ordinal))
{
break;
}
if (!line.StartsWithChar('#') && line.Trim().Length > 0)
{
break;
}
}
// ok, if we're coming from the chemfile function, we've already read the molecule RTI
if (firstLineisMolecule)
{
molecule.Title = line;
}
else
{
line = input.ReadLine();
molecule.Title = line;
}
// get atom and bond counts
var counts = input.ReadLine();
var tokenizer = Strings.Tokenize(counts);
try
{
atomCount = int.Parse(tokenizer[0], NumberFormatInfo.InvariantInfo);
}
catch (FormatException nfExc)
{
string error = "Error while reading atom count from MOLECULE block";
Trace.TraceError(error);
Debug.WriteLine(nfExc);
throw new CDKException(error, nfExc);
}
if (tokenizer.Count > 1)
{
try
{
bondCount = int.Parse(tokenizer[1], NumberFormatInfo.InvariantInfo);
}
catch (FormatException nfExc)
{
string error = "Error while reading atom and bond counts";
Trace.TraceError(error);
Debug.WriteLine(nfExc);
throw new CDKException(error, nfExc);
}
}
else
{
bondCount = 0;
}
Trace.TraceInformation("Reading #atoms: ", atomCount);
Trace.TraceInformation("Reading #bonds: ", bondCount);
// we skip mol type, charge type and status bit lines
Trace.TraceWarning("Not reading molecule qualifiers");
line = input.ReadLine();
bool molend = false;
while (line != null)
{
if (line.StartsWith("@<TRIPOS>MOLECULE", StringComparison.Ordinal))
{
molend = true;
break;
}
else if (line.StartsWith("@<TRIPOS>ATOM", StringComparison.Ordinal))
{
Trace.TraceInformation("Reading atom block");
for (int i = 0; i < atomCount; i++)
{
line = input.ReadLine().Trim();
if (line.StartsWith("@<TRIPOS>MOLECULE", StringComparison.Ordinal))
{
molend = true;
break;
}
tokenizer = Strings.Tokenize(line);
// disregard the id token
var nameStr = tokenizer[1];
var xStr = tokenizer[2];
var yStr = tokenizer[3];
var zStr = tokenizer[4];
var atomTypeStr = tokenizer[5];
// replace unrecognised atom type
if (ATOM_TYPE_ALIASES.ContainsKey(atomTypeStr))
{
atomTypeStr = ATOM_TYPE_ALIASES[atomTypeStr];
}
var atom = molecule.Builder.NewAtom();
IAtomType atomType;
try
{
atomType = atFactory.GetAtomType(atomTypeStr);
}
catch (Exception)
{
// ok, *not* an mol2 atom type
atomType = null;
}
// Maybe it is just an element
if (atomType == null && IsElementSymbol(atomTypeStr))
{
atom.Symbol = atomTypeStr;
}
else
{
if (atomType == null)
{
atomType = atFactory.GetAtomType("X");
Trace.TraceError($"Could not find specified atom type: {atomTypeStr}");
}
AtomTypeManipulator.Configure(atom, atomType);
}
atom.AtomicNumber = ChemicalElement.OfSymbol(atom.Symbol).AtomicNumber;
atom.Id = nameStr;
atom.AtomTypeName = atomTypeStr;
try
{
var x = double.Parse(xStr, NumberFormatInfo.InvariantInfo);
var y = double.Parse(yStr, NumberFormatInfo.InvariantInfo);
var z = double.Parse(zStr, NumberFormatInfo.InvariantInfo);
atom.Point3D = new Vector3(x, y, z);
}
catch (FormatException nfExc)
{
string error = "Error while reading atom coordinates";
Trace.TraceError(error);
Debug.WriteLine(nfExc);
throw new CDKException(error, nfExc);
}
molecule.Atoms.Add(atom);
}
}
else if (line.StartsWith("@<TRIPOS>BOND", StringComparison.Ordinal))
{
Trace.TraceInformation("Reading bond block");
for (int i = 0; i < bondCount; i++)
{
line = input.ReadLine();
if (line.StartsWith("@<TRIPOS>MOLECULE", StringComparison.Ordinal))
{
molend = true;
break;
}
tokenizer = Strings.Tokenize(line);
// disregard the id token
var atom1Str = tokenizer[1];
var atom2Str = tokenizer[2];
var orderStr = tokenizer[3];
try
{
var atom1 = int.Parse(atom1Str, NumberFormatInfo.InvariantInfo);
var atom2 = int.Parse(atom2Str, NumberFormatInfo.InvariantInfo);
if (string.Equals("nc", orderStr, StringComparison.Ordinal))
{
// do not connect the atoms
}
else
{
var bond = molecule.Builder.NewBond(molecule.Atoms[atom1 - 1], molecule.Atoms[atom2 - 1]);
switch (orderStr)
{
case "1":
bond.Order = BondOrder.Single;
break;
case "2":
bond.Order = BondOrder.Double;
break;
case "3":
bond.Order = BondOrder.Triple;
break;
case "am":
case "ar":
bond.Order = BondOrder.Single;
bond.IsAromatic = true;
bond.Begin.IsAromatic = true;
bond.End.IsAromatic = true;
break;
case "du":
bond.Order = BondOrder.Single;
break;
case "un":
bond.Order = BondOrder.Single;
break;
default:
break;
}
molecule.Bonds.Add(bond);
}
}
catch (FormatException nfExc)
{
var error = "Error while reading bond information";
Trace.TraceError(error);
Debug.WriteLine(nfExc);
throw new CDKException(error, nfExc);
}
}
}
if (molend)
{
return(molecule);
}
line = input.ReadLine();
}
}
catch (IOException exception)
{
var error = "Error while reading general structure";
Trace.TraceError(error);
Debug.WriteLine(exception);
throw new CDKException(error, exception);
}
return(molecule);
}
