public void TotalBondEnergy_WhenThereAreNoBonds_ReturnsZero()
{
// Arrange
var molecule = new AtomContainer();
var calculator = new BondEnergyCalculator(molecule);
// Act
var bondEnergy = calculator.TotalBondEnergy();
// Assert
Assert.That(bondEnergy, Is.EqualTo(0));
}
public void TestCalculateBounds_IReactionSet()
{
IAtomContainer container = new AtomContainer();
container.Atoms.Add(container.Builder.NewAtom("C"));
container.Atoms.Add(container.Builder.NewAtom("C"));
IReaction reaction = container.Builder.NewReaction();
reaction.Reactants.Add(container.Builder.NewAtomContainer(container));
IReactionSet set = container.Builder.NewReactionSet();
set.Add(reaction);
BoundsCalculator.CalculateBounds(set);
}
public void TerminalAtomsAreFoundUnordered()
{
var ac = new AtomContainer();
ac.Atoms.Add(new Atom("C"));
ac.Atoms.Add(new Atom("C"));
ac.Atoms.Add(new Atom("C"));
ac.AddBond(ac.Atoms[0], ac.Atoms[1], BondOrder.Double);
ac.AddBond(ac.Atoms[1], ac.Atoms[2], BondOrder.Double);
IAtom[] terminals = ExtendedTetrahedral.FindTerminalAtoms(ac, ac.Atoms[1]);
// note order may change
Assert.AreEqual(ac.Atoms[0], terminals[0]);
Assert.AreEqual(ac.Atoms[2], terminals[1]);
}
public void C13_nonIsomeric()
{
var ac = new AtomContainer();
var a = new Atom("C")
{
MassNumber = 13
};
ac.Atoms.Add(a);
var g = Convert(ac, false, 0); // non-isomeric
Assert.AreEqual(-1, g.GetAtom(0).Isotope);
Assert.AreEqual("C", g.ToSmiles());
}
public void TestCalculateBounds_IChemModel()
{
IAtomContainer container = new AtomContainer();
container.Atoms.Add(container.Builder.NewAtom("C"));
container.Atoms.Add(container.Builder.NewAtom("C"));
var set = container.Builder.NewAtomContainerSet();
set.Add(container);
IChemModel model = container.Builder.NewChemModel();
model.MoleculeSet = set;
BoundsCalculator.CalculateBounds(model);
}
public void Script3_15()
{
var mol = new AtomContainer();
mol.Atoms.Add(new Atom("C"));
for (var i = 0; i < 4; i++)
{
mol.Atoms.Add(new Atom("H"));
}
for (var i = 0; i < 4; i++)
{
mol.AddBond(mol.Atoms[0], mol.Atoms[i + 1], BondOrder.Single);
}
}
public void TestGetInChIGenerator_IAtomContainer_NullString()
{
var ac = new AtomContainer();
var a = new Atom("Cl")
{
ImplicitHydrogenCount = 1
};
ac.Atoms.Add(a);
var gen = InChIGeneratorFactory.Instance.GetInChIGenerator(ac, (string)null);
Assert.AreEqual(gen.ReturnStatus, InChIReturnCode.Ok);
Assert.AreEqual("InChI=1S/ClH/h1H", gen.InChI);
}
public void Script3_14()
{
var mol = new AtomContainer();
mol.Atoms.Add(new Atom("C"));
for (var i = 0; i < 4; i++)
{
mol.Atoms.Add(new Atom("H"));
}
for (var i = 0; i < 4; i++)
{
mol.Bonds.Add(new Bond(mol.Atoms[0], mol.Atoms[i + 1]));
}
}
public void MarkBut2eneWithWavyBond()
{
var m = new AtomContainer();
m.Atoms.Add(Atom("C", 3, 0.000, 0.000));
m.Atoms.Add(Atom("C", 1, 1.299, -0.750));
m.Atoms.Add(Atom("C", 1, 2.598, -0.000));
m.Atoms.Add(Atom("C", 3, 3.897, -0.750));
m.AddBond(m.Atoms[0], m.Atoms[1], BondOrder.Single);
m.AddBond(m.Atoms[1], m.Atoms[2], BondOrder.Double);
m.AddBond(m.Atoms[2], m.Atoms[3], BondOrder.Single);
NonplanarBonds.Assign(m);
Assert.AreEqual(BondStereo.UpOrDown, m.Bonds[0].Stereo);
}
public void C13_Isomeric()
{
var ac = new AtomContainer();
var a = new Atom("C")
{
MassNumber = 13
};
ac.Atoms.Add(a);
var g = Convert(ac, SmiFlavors.AtomicMass);
Assert.AreEqual(13, g.GetAtom(0).Isotope);
Assert.AreEqual("[13CH4]", g.ToSmiles());
}
public void TestAtom()
{
var mol = new AtomContainer();
Atom atom = new Atom("N");
mol.Atoms.Add(atom);
IAtomContainer roundTrippedMol = CMLRoundTripTool.RoundTripMolecule(convertor, mol);
Assert.AreEqual(1, roundTrippedMol.Atoms.Count);
IAtom roundTrippedAtom = roundTrippedMol.Atoms[0];
Assert.AreEqual(atom.Symbol, roundTrippedAtom.Symbol);
}
public void Azanium()
{
var ac = new AtomContainer();
var a = new Atom("N")
{
FormalCharge = +1
};
ac.Atoms.Add(a);
var g = Convert(ac, 0);
Assert.AreEqual(+1, g.GetAtom(0).Charge);
Assert.AreEqual("[NH4+]", g.ToSmiles());
}
public void Oxidandiide()
{
var ac = new AtomContainer();
var a = new Atom("O")
{
FormalCharge = -2
};
ac.Atoms.Add(a);
var g = Convert(ac, 0);
Assert.AreEqual(-2, g.GetAtom(0).Charge);
Assert.AreEqual("[O-2]", g.ToSmiles());
}
public void WriteAtomClass()
{
var ac = new AtomContainer();
ac.Atoms.Add(new Atom("C"));
ac.Atoms.Add(new Atom("C"));
ac.Atoms.Add(new Atom("O"));
ac.AddBond(ac.Atoms[0], ac.Atoms[1], BondOrder.Single);
ac.AddBond(ac.Atoms[1], ac.Atoms[2], BondOrder.Single);
ac.Atoms[0].SetProperty(CDKPropertyName.AtomAtomMapping, 3);
ac.Atoms[1].SetProperty(CDKPropertyName.AtomAtomMapping, 1);
ac.Atoms[2].SetProperty(CDKPropertyName.AtomAtomMapping, 2);
Assert.AreEqual("[CH3:3][CH2:1][OH:2]", Convert(ac, SmiFlavors.AtomAtomMap).ToSmiles());
}
public void BadExprs()
{
var mol = new AtomContainer();
Assert.IsFalse(Smarts.Parse(mol, "*-,*"));
Assert.IsFalse(Smarts.Parse(mol, "*-;*"));
Assert.IsFalse(Smarts.Parse(mol, "*-!*"));
Assert.IsFalse(Smarts.Parse(mol, "*-&*"));
Assert.IsFalse(Smarts.Parse(mol, "*!*"));
Assert.IsFalse(Smarts.Parse(mol, "*,*"));
Assert.IsFalse(Smarts.Parse(mol, "*;*"));
Assert.IsFalse(Smarts.Parse(mol, "*&*"));
Assert.IsFalse(Smarts.Parse(mol, "*,-*"));
}
public static IAtomContainer CitricAcid()
{
var citricAcid = new AtomContainer();
var carbons = Enumerable.Range(0, 6).Select(i => citricAcid.AddAtom("C")).ToList();
var oxygens = Enumerable.Range(0, 7).Select(i => citricAcid.AddAtom("O")).ToList();
citricAcid.AddBond(oxygens[0], citricAcid.AddAtom("H"), BondOrder.Single);
citricAcid.AddBond(oxygens[0], carbons[0], BondOrder.Single);
citricAcid.AddBond(oxygens[1], carbons[0], BondOrder.Double);
citricAcid.AddBond(carbons[0], carbons[1], BondOrder.Single);
citricAcid.AddBond(carbons[1], citricAcid.AddAtom("H"), BondOrder.Single);
citricAcid.AddBond(carbons[1], citricAcid.AddAtom("H"), BondOrder.Single);
citricAcid.AddBond(carbons[1], carbons[2], BondOrder.Single);
citricAcid.AddBond(oxygens[2], citricAcid.AddAtom("H"), BondOrder.Single);
citricAcid.AddBond(carbons[2], oxygens[2], BondOrder.Single);
citricAcid.AddBond(carbons[2], carbons[3], BondOrder.Single);
citricAcid.AddBond(oxygens[3], citricAcid.AddAtom("H"), BondOrder.Single);
citricAcid.AddBond(carbons[3], oxygens[3], BondOrder.Single);
citricAcid.AddBond(carbons[3], oxygens[4], BondOrder.Double);
citricAcid.AddBond(carbons[2], carbons[4], BondOrder.Single);
citricAcid.AddBond(carbons[4], citricAcid.AddAtom("H"), BondOrder.Single);
citricAcid.AddBond(carbons[4], citricAcid.AddAtom("H"), BondOrder.Single);
citricAcid.AddBond(carbons[4], carbons[5], BondOrder.Single);
citricAcid.AddBond(oxygens[5], citricAcid.AddAtom("H"), BondOrder.Single);
citricAcid.AddBond(carbons[5], oxygens[5], BondOrder.Single);
citricAcid.AddBond(carbons[5], oxygens[6], BondOrder.Double);
citricAcid.Title = nameof(citricAcid);
return(citricAcid);
}
public void TestPyrrole()
{
IAtomContainer enol = new AtomContainer();
// atom block
IAtom atom1 = new Atom(ChemicalElement.C);
AddHydrogens(enol, atom1, 1);
IAtom atom2 = new Atom(ChemicalElement.C);
AddHydrogens(enol, atom2, 1);
IAtom atom3 = new Atom(ChemicalElement.C);
AddHydrogens(enol, atom3, 1);
IAtom atom4 = new Atom(ChemicalElement.C);
AddHydrogens(enol, atom4, 1);
IAtom atom5 = new Atom(ChemicalElement.N);
AddHydrogens(enol, atom5, 1);
// bond block
IBond bond1 = new Bond(atom1, atom2);
IBond bond2 = new Bond(atom2, atom3);
IBond bond3 = new Bond(atom3, atom4);
IBond bond4 = new Bond(atom4, atom5);
IBond bond5 = new Bond(atom5, atom1);
enol.Atoms.Add(atom1);
enol.Atoms.Add(atom2);
enol.Atoms.Add(atom3);
enol.Atoms.Add(atom4);
enol.Atoms.Add(atom5);
enol.Bonds.Add(bond1);
enol.Bonds.Add(bond2);
enol.Bonds.Add(bond3);
enol.Bonds.Add(bond4);
enol.Bonds.Add(bond5);
// now have the algorithm have a go at it
dboTool.Saturate(enol);
// now check whether it did the right thing
Assert.AreEqual(BondOrder.Double, bond1.Order);
Assert.AreEqual(BondOrder.Single, bond2.Order);
Assert.AreEqual(BondOrder.Double, bond3.Order);
Assert.AreEqual(BondOrder.Single, bond4.Order);
Assert.AreEqual(BondOrder.Single, bond5.Order);
}
public void AssignEthanolNoEntry()
{
IAtomContainer container = new AtomContainer();
container.Atoms.Add(new Atom("O"));
container.Atoms.Add(new Atom("C"));
container.Atoms.Add(new Atom("C"));
container.Atoms[0].ImplicitHydrogenCount = 0;
container.Atoms[1].ImplicitHydrogenCount = 0;
container.Atoms[2].ImplicitHydrogenCount = 0;
container.AddBond(container.Atoms[0], container.Atoms[1], BondOrder.Single);
container.AddBond(container.Atoms[1], container.Atoms[2], BondOrder.Single);
Assert.IsFalse(IdentityTemplateLibrary.Empty().AssignLayout(container));
}
private static IAtomContainer MoleculeMaker()
{
var molecule = new AtomContainer();
molecule.Atoms.Add(new Atom("Cl"));
molecule.Atoms.Add(new Atom("C"));
molecule.Atoms.Add(new Atom("Br"));
molecule.Atoms.Add(new Atom("I"));
molecule.Atoms.Add(new Atom("H"));
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Single);
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[2], BondOrder.Single);
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[3], BondOrder.Single);
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[4], BondOrder.Single);
return(molecule);
}
public void Tin_iv()
{
IAtomContainer container = new AtomContainer();
IAtom atom = new Atom("Sn");
atom.Valency = 4;
IAtom hydrogen = new Atom("H");
container.Atoms.Add(atom);
container.Atoms.Add(hydrogen);
container.AddBond(container.Atoms[0], container.Atoms[1], BondOrder.Single);
MDLValence.Apply(container);
Assert.AreEqual(4, atom.Valency);
Assert.AreEqual(3, atom.ImplicitHydrogenCount); // 4 - explicit H
}
public static IAtomContainer Hydronium()
{
var hydronium = new AtomContainer();
var oxy = hydronium.AddAtom("O");
for (var i = 0; i < 3; i++)
{
hydronium.AddBond(oxy, hydronium.AddAtom("H"), BondOrder.Single);
}
hydronium.Title = nameof(hydronium);
return(hydronium);
}
/// <remarks>
/// <![CDATA[
/// Ammonium Acetate by neutralizing clear household ammonia with
/// distilled white vinegar and evaporating to dryness
/// Ammonium Chloride by neutralizing clear household ammonia with
/// hardware store muriatic acid and evaporating to dryness
/// ]]>
/// </remarks>
public static IAtomContainer Ammonia()
{
var ammonia = new AtomContainer();
var nitrogen = ammonia.AddAtom("N");
for (var i = 0; i < 3; i++)
{
ammonia.AddBond(nitrogen, ammonia.AddAtom("H"), BondOrder.Single);
}
ammonia.Title = nameof(ammonia);
return(ammonia);
}
public void TestChargedCompounds()
{
var mol = new AtomContainer();
IAtom aluminum = new Atom("Al");
aluminum.FormalCharge = +3;
mol.Atoms.Add(aluminum);
StringWriter strWriter = new StringWriter();
Mopac7Writer writer = new Mopac7Writer(strWriter);
writer.Write(mol);
writer.Close();
Assert.IsTrue(strWriter.ToString().Contains("CHARGE=3"));
}
public void TestWrite()
{
StringWriter strWriter = new StringWriter();
Mopac7Writer writer = new Mopac7Writer(strWriter);
var mol = new AtomContainer();
mol.Atoms.Add(new Atom("Cr"));
writer.Write(mol);
writer.Close();
Assert.IsTrue(strWriter.ToString().Contains("PM3"));
Assert.IsTrue(strWriter.ToString().Contains("Cr "));
Assert.IsTrue(strWriter.ToString().Contains("Generated by"));
}
static IAtomContainer Dimethylpropane()
{
var container = new AtomContainer();
container.Atoms.Add(Atom("C", 0));
container.Atoms.Add(Atom("C", 3));
container.Atoms.Add(Atom("C", 3));
container.Atoms.Add(Atom("C", 3));
container.Atoms.Add(Atom("C", 3));
container.AddBond(container.Atoms[0], container.Atoms[1], BondOrder.Single);
container.AddBond(container.Atoms[0], container.Atoms[2], BondOrder.Single);
container.AddBond(container.Atoms[0], container.Atoms[3], BondOrder.Single);
container.AddBond(container.Atoms[0], container.Atoms[4], BondOrder.Single);
return(container);
}
public void TestGetOverLaps()
{
IAtom atomSource = new Atom("R");
IAtom atomTarget = new Atom("R");
IAtomContainer source = new AtomContainer();
source.Atoms.Add(atomSource);
IAtomContainer target = new AtomContainer();
target.Atoms.Add(atomTarget);
bool removeHydrogen = false;
SingleMapping instance = new SingleMapping();
Assert.IsNotNull(instance.GetOverLaps(source, target, removeHydrogen));
}
public void ContainerFromPermutationTest()
{
IAtomContainer atomContainer = new AtomContainer();
atomContainer.Atoms.Add(new Atom("C"));
atomContainer.Atoms.Add(new Atom("O"));
atomContainer.Atoms.Add(new Atom("S"));
atomContainer.AddBond(atomContainer.Atoms[0], atomContainer.Atoms[1], BondOrder.Single);
atomContainer.AddBond(atomContainer.Atoms[0], atomContainer.Atoms[2], BondOrder.Single);
AtomContainerAtomPermutor acap = new AtomContainerAtomPermutor(atomContainer);
IAtomContainer permuted = acap.ContainerFromPermutation(new int[] { 1, 0, 2 });
Assert.IsNotNull(permuted);
Assert.AreEqual(atomContainer.Atoms.Count, permuted.Atoms.Count);
Assert.AreEqual(atomContainer.Bonds.Count, permuted.Bonds.Count);
}
public void TestAtom2D()
{
var mol = new AtomContainer();
Atom atom = new Atom("N");
Vector2 p2d = new Vector2(1.3, 1.4);
atom.Point2D = p2d;
mol.Atoms.Add(atom);
IAtomContainer roundTrippedMol = CMLRoundTripTool.RoundTripMolecule(convertor, mol);
Assert.AreEqual(1, roundTrippedMol.Atoms.Count);
IAtom roundTrippedAtom = roundTrippedMol.Atoms[0];
base.AssertAreEqual(atom.Point2D, roundTrippedAtom.Point2D, 0.00001);
}
public void TestWriteWithOptimizationFalse()
{
var mol = new AtomContainer();
mol.Atoms.Add(new Atom("Cr"));
StringWriter strWriter = new StringWriter();
Mopac7Writer writer = new Mopac7Writer(strWriter);
var customizations = new NameValueCollection();
customizations["optimize"] = "false";
writer.Listeners.Add(new PropertiesListener(customizations));
writer.Write(mol);
writer.Close();
Assert.IsFalse(strWriter.ToString().Contains("PRECISE"));
}
public void TestWriteWithCustomCommands()
{
var mol = new AtomContainer();
mol.Atoms.Add(new Atom("Cr"));
StringWriter strWriter = new StringWriter();
Mopac7Writer writer = new Mopac7Writer(strWriter);
var customizations = new NameValueCollection();
customizations["Commands"] = "THIS IS NOT GOING TO WORK";
writer.Listeners.Add(new PropertiesListener(customizations));
writer.Write(mol);
writer.Close();
Assert.IsTrue(strWriter.ToString().Contains("THIS IS NOT GOING TO WORK"));
}
public void TestSpinMultiplicity()
{
var mol = new AtomContainer();
Atom atom = new Atom("C");
mol.Atoms.Add(atom);
mol.SingleElectrons.Add(new SingleElectron(atom));
IAtomContainer roundTrippedMol = CMLRoundTripTool.RoundTripMolecule(convertor, mol);
Assert.AreEqual(1, roundTrippedMol.Atoms.Count);
Assert.AreEqual(1, roundTrippedMol.GetElectronContainers().Count());
IAtom roundTrippedAtom = roundTrippedMol.Atoms[0];
Assert.AreEqual(1, roundTrippedMol.GetConnectedSingleElectrons(roundTrippedAtom).Count());
}
public void TotalBondEnergy_WhenThereAreBondRings_ReturnsTheSumOfAllBonds()
{
// Arrange
var molecule = new AtomContainer();
// Bonds: 5 carbon ring, each with an H bonded by C-H
molecule.addAtom(new Atom(new Element("C")));
molecule.addAtom(new Atom(new Element("C")));
molecule.addAtom(new Atom(new Element("C")));
molecule.addAtom(new Atom(new Element("C")));
molecule.addAtom(new Atom(new Element("C")));
molecule.addAtom(new Atom(new Element("H")));
molecule.addAtom(new Atom(new Element("H")));
molecule.addAtom(new Atom(new Element("H")));
molecule.addAtom(new Atom(new Element("H")));
molecule.addAtom(new Atom(new Element("H")));
// Ring
molecule.addBond(0, 1, IBond.Order.SINGLE);
molecule.addBond(1, 2, IBond.Order.SINGLE);
molecule.addBond(2, 3, IBond.Order.SINGLE);
molecule.addBond(3, 4, IBond.Order.SINGLE);
molecule.addBond(4, 0, IBond.Order.SINGLE);
// C-H bonds
molecule.addBond(0, 5, IBond.Order.SINGLE);
molecule.addBond(1, 6, IBond.Order.SINGLE);
molecule.addBond(2, 7, IBond.Order.SINGLE);
molecule.addBond(3, 8, IBond.Order.SINGLE);
molecule.addBond(4, 9, IBond.Order.SINGLE);
var calculator = new BondEnergyCalculator(molecule);
// Act
var bondEnergy = calculator.TotalBondEnergy();
// Assert
Assert.That(bondEnergy, Is.EqualTo(5 * 348 + 5 * 412));
}
public void TotalBondEnergy_WhenThereAreBonds_ReturnsSumOfTheBondEnergies()
{
// Arrange
var molecule = new AtomContainer();
// Bonds: C=C, C-H, C~N
molecule.addAtom(new Atom(new Element("C")));
molecule.addAtom(new Atom(new Element("C")));
molecule.addAtom(new Atom(new Element("H")));
molecule.addAtom(new Atom(new Element("N")));
molecule.addBond(0, 1, IBond.Order.DOUBLE);
molecule.addBond(1, 2, IBond.Order.SINGLE);
molecule.addBond(1, 3, IBond.Order.TRIPLE);
var calculator = new BondEnergyCalculator(molecule);
// Act
var bondEnergy = calculator.TotalBondEnergy();
// Assert
Assert.That(bondEnergy, Is.EqualTo(612 + 412 + 890));
}
public void TotalBondEnergy_WhenThereAreUnknownBonds_ReplacesUnknownsWithC_CBond()
{
// Arrange
var molecule = new AtomContainer();
// Bonds: C=C, C-H, C~N, N~X (Unknown)
molecule.addAtom(new Atom(new Element("C")));
molecule.addAtom(new Atom(new Element("C")));
molecule.addAtom(new Atom(new Element("H")));
molecule.addAtom(new Atom(new Element("N")));
molecule.addAtom(new Atom(new Element("X")));
molecule.addBond(0, 1, IBond.Order.DOUBLE);
molecule.addBond(1, 2, IBond.Order.SINGLE);
molecule.addBond(1, 3, IBond.Order.TRIPLE);
molecule.addBond(3, 4, IBond.Order.TRIPLE);
var calculator = new BondEnergyCalculator(molecule);
// Act
var bondEnergy = calculator.TotalBondEnergy();
// Assert
Assert.That(bondEnergy, Is.EqualTo(612 + 412 + 890 + 348));
}
/// <summary> Grows the atomContainer array by a given size.
///
/// </summary>
/// <seealso cref="growArraySize">
/// </seealso>
protected internal virtual void growAtomContainerArray()
{
growArraySize = atomContainers.Length;
AtomContainer[] newatomContainers = new AtomContainer[atomContainers.Length + growArraySize];
Array.Copy(atomContainers, 0, newatomContainers, 0, atomContainers.Length);
atomContainers = newatomContainers;
double[] newMultipliers = new double[multipliers.Length + growArraySize];
Array.Copy(multipliers, 0, newMultipliers, 0, multipliers.Length);
multipliers = newMultipliers;
}
/**
* Make atom container from a given bond list. For each bond iterate over atoms and add them to the partContainer
*
* @param the atom
* @param List of parts
*
* @return partContainer
*/
private IAtomContainer makeAtomContainer(IAtom atom, List<IBond> parts)
{
var atoms = new List<IAtom>();
var bonds = new List<IBond>();
var atomsDone = new Dictionary<string, bool>();
atoms.Add(atom);
atomsDone[atom.getID()] = true;
foreach (var aBond in parts)
{
foreach (var bondedAtom in aBond.atoms().ToWindowsEnumerable<IAtom>())
{
var done = false;
atomsDone.TryGetValue(bondedAtom.getID(), out done);
//check if the atom is already contained
if (done)
{
continue;
}
atoms.Add(bondedAtom);
atomsDone[bondedAtom.getID()] = true;
}
bonds.Add(aBond);
}
IAtomContainer partContainer = new AtomContainer();
partContainer.setAtoms(atoms.ToArray());
partContainer.setBonds(bonds.ToArray());
return partContainer;
}
/// <summary> Constructs a new AtomEnumeration.
///
/// </summary>
/// <param name="container"> AtomContainer which contains the atoms
/// </param>
public AtomEnumeration(AtomContainer container)
{
this.container = container;
}
/**
* Post process a fragment. --> find neutral possible neutral losses read in
* from the file
*
* @param original
* the original
*
* @return the i atom container set
*
* @throws CDKException
* the CDK exception
* @throws CloneNotSupportedException
* the clone not supported exception
*/
public List<IAtomContainer> PostProcess(IAtomContainer original, double neutralLossMass)
{
// Render.Draw(original, "Original Main");
var ret = new List<IAtomContainer>();
allRings = new RingSet();
if (allRingsOrig.getAtomContainerCount() > 0)
{
// get the rings which are not broken up yet
var bondMap = new Dictionary<IBond, int>();
var count = 0;
foreach (var bondOrig in original.bonds().ToWindowsEnumerable<IBond>())
{
bondMap[bondOrig] = count;
count++;
}
// check for rings which are not broken up!
IRingSet validRings = new RingSet();
for (var i = 0; i < allRingsOrig.getAtomContainerCount(); i++)
{
var bondcount = 0;
foreach (var bondRing in allRingsOrig.getAtomContainer(i).bonds().ToWindowsEnumerable<IBond>())
{
if (bondMap.ContainsKey(bondRing))
{
bondcount++;
}
}
if (bondcount == allRingsOrig.getAtomContainer(i).getBondCount())
{
validRings.addAtomContainer(allRingsOrig.getAtomContainer(i));
}
}
// rings which are not split up
allRings = validRings;
}
IAtomContainer temp = new AtomContainer();
var doneAtoms = new List<IAtom>();
var doneBonds = new List<IBond>();
// now find out the important atoms of the neutral loss
var atomToStart = neutralLoss[neutralLossMass].AtomToStart;
foreach (var bond in original.bonds().ToWindowsEnumerable<IBond>())
{
if (doneBonds.Contains(bond))
{
continue;
}
else
{
doneBonds.Add(bond);
}
// check if this was checked b4
foreach (var atom in bond.atoms().ToWindowsEnumerable<IAtom>())
{
if (doneAtoms.Contains(atom))
{
continue;
}
else
{
doneAtoms.Add(atom);
}
// a possible hit
if (atom.getSymbol().Equals(atomToStart) && !allRings.contains(atom))
{
// Render.Draw(original, "BEFORE");
// check if it is a terminal bond...and not in between!
var atomList = original.getConnectedAtomsList(atom);
var atomCount = 0;
foreach (var iAtom in atomList.ToWindowsEnumerable<IAtom>())
{
// dont check
if (iAtom.getSymbol().Equals("H"))
{
continue;
}
else
{
atomCount++;
}
}
// not a terminal atom...so skip it!
if (atomCount > 1)
{
continue;
}
temp = checkForCompleteNeutralLoss(original, atom,
neutralLossMass);
if (temp.getAtomCount() > 0)
{
if (ConnectivityChecker.isConnected(temp))
{
ret.Add(temp);
}
else
{
var set = ConnectivityChecker
.partitionIntoMolecules(temp);
foreach (var molecule in set.molecules().ToWindowsEnumerable<IMolecule>())
{
ret.Add(molecule);
}
}
// create a atom container
temp = new AtomContainer();
}
}
}
}
return ret;
}
/**
* Check for the other atoms nearby in the fragment.
*
* @param candidateOxygen
* the candidate oxygen atom
* @param frag
* the frag
* @param proton
* the proton
*
* @return true, if successful
* @throws CloneNotSupportedException
* @throws CDKException
*/
private IAtomContainer checkForCompleteNeutralLoss(IAtomContainer frag, IAtom candidateAtom, double neutralLossMass)
{
IAtomContainer ret = new AtomContainer();
// create a copy from the original fragment
var part = new List<IBond>();
part = traverse(frag, candidateAtom, part);
var fragCopy = makeAtomContainer(candidateAtom, part);
// set properties again
var properties = frag.getProperties();
fragCopy.setProperties(properties);
// now get the other atoms from the neutral loss
var atomsToFind = new List<string>();
var addHydrogen = false;
// one hydrogen is lost with the neutral loss
if (neutralLoss[neutralLossMass].HydrogenDifference == -1)
{
foreach (var isotope in neutralLoss[neutralLossMass].ElementalComposition.isotopes().ToWindowsEnumerable<IIsotope>())
{
var c = neutralLoss[neutralLossMass].ElementalComposition.getIsotopeCount(isotope);
for (var i = 0; i < c; i++)
{
atomsToFind.Add(isotope.getSymbol());
}
}
}
else
{
foreach (var isotope in neutralLoss[neutralLossMass].TopoFragment.isotopes().ToWindowsEnumerable<IIsotope>())
{
var c = neutralLoss[neutralLossMass].ElementalComposition.getIsotopeCount(isotope);
for (var i = 0; i < c; i++)
{
atomsToFind.Add(isotope.getSymbol());
}
addHydrogen = true;
}
}
// at most 2 bonds between the oxygen and other atoms (at most 1 H and 2
// C)
var count = neutralLoss[neutralLossMass].Distance;
// list storing all atoms to be removed later on if complete neutral
// loss was found
var foundAtoms = new List<IAtom>();
// list storing all bonds to remove
var foundBonds = new List<IBond>();
// list storing all bonds already checked
var checkedBonds = new List<IBond>();
// list storing all checked atoms
var checkedAtoms = new List<IAtom>();
// queue storing all bonds to check for a particular distance
var bondQueue = new List<IBond>();
// List storing all bonds to be checked for the next distance
var bondsFurther = new List<IBond>();
// get all bonds from this atom distance = 1
var bondList = fragCopy.getConnectedBondsList(candidateAtom);
foreach (var bond in bondList.ToWindowsEnumerable<IBond>())
{
if (bond != null)
{
bondQueue.Add(bond);
}
}
var hydrogenStartAtom = neutralLoss[neutralLossMass].HydrogenOnStartAtom;
var firstBonds = true;
while (count > 0)
{
IBond currentBond = null;
if (bondQueue.Count > 0)
{
currentBond = bondQueue[bondQueue.Count - 1];
bondQueue.RemoveAt(bondQueue.Count - 1);
}
// check for already tried bonds
if (checkedBonds.Contains(currentBond) && currentBond != null)
{
continue;
}
else if (currentBond != null)
{
checkedBonds.Add(currentBond);
}
if (currentBond != null)
{
foreach (var atom in currentBond.atoms().ToWindowsEnumerable<IAtom>())
{
// check for already tried atoms
if (checkedAtoms.Contains(atom))
{
continue;
}
else
{
checkedAtoms.Add(atom);
}
if (firstBonds && atom.getSymbol().Equals("H"))
{
hydrogenStartAtom--;
}
// thats the starting atom
if (atom.getSymbol().Equals(candidateAtom.getSymbol()))
{
var removed = atomsToFind.Remove(candidateAtom.getSymbol());
if (removed)
{
foundAtoms.Add(atom);
// remove bond
if (!foundBonds.Contains(currentBond))
{
foundBonds.Add(currentBond);
}
}
// this bond has to be removed
else if (!foundBonds.Contains(currentBond) && atomsToFind.Contains(atom.getSymbol()))
{
foundBonds.Add(currentBond);
}
continue;
}
// found atom...remove it from the atoms to find list
// do not remove atoms from ring
if (atomsToFind.Contains(atom.getSymbol()) && !allRings.contains(atom) && atomsToFind.Count > 0)
{
var removed = atomsToFind.Remove(atom.getSymbol());
if (removed)
{
foundAtoms.Add(atom);
}
else
{
continue;
}
if (!foundBonds.Contains(currentBond))
{
foundBonds.Add(currentBond);
}
continue;
}
// only walk along C-Atoms!
if (!atom.getSymbol().Equals("C"))
{
continue;
}
// get new bonds
var bondsToAddTemp = fragCopy.getConnectedBondsList(atom);
foreach (var bond in bondsToAddTemp.ToWindowsEnumerable<IBond>())
{
if (bond != null)
{
bondsFurther.Add(bond);
}
}
}
}
// break condition
if (currentBond == null && bondQueue.Count == 0 && bondsFurther.Count == 0)
{
break;
}
// now check if the queue is empty...checked all bonds in this
// distance
if (bondQueue.Count == 0)
{
count--;
// set new queue data
foreach (var bond in bondsFurther)
{
if (bond != null)
{
bondQueue.Add(bond);
}
}
// reinitialize
bondsFurther = new List<IBond>();
// the initially connected bonds are all checked!
firstBonds = false;
}
}
// found complete neutral loss
if (atomsToFind.Count == 0)
{
foreach (var atom in foundAtoms)
{
fragCopy.removeAtomAndConnectedElectronContainers(atom);
}
// TODO add hydrogen somewhere
if (addHydrogen)
{
var props = fragCopy.getProperties();
props.put("hydrogenAddFromNL", "1");
fragCopy.setProperties(props);
}
// add fragment to return if enough H were connected and fragment is
// still connected
if (hydrogenStartAtom <= 0)
{
ret.add(fragCopy);
}
}
return ret;
}
private IAtomContainer makeAtomContainer(IAtom atom, List<IBond> parts)
{
IAtomContainer partContainer = new AtomContainer();
partContainer.addAtom(atom);
foreach (var aBond in parts)
{
foreach (var bondedAtom in aBond.atoms().ToWindowsEnumerable<IAtom>())
{
if (!partContainer.contains(bondedAtom))
{
partContainer.addAtom(bondedAtom);
}
}
partContainer.addBond(aBond);
}
return partContainer;
}
