public void TestSort_IAtomContainerSet()
{
// Create some IAtomContainers
var cycloPentane = builder.NewRing(5, "C");
var cycloHexane = builder.NewRing(6, "C");
var hexaneNitrogen = builder.NewRing(6, "N");
hexaneNitrogen.Bonds.RemoveAt(0);
var cycloHexaneNitrogen = builder.NewRing(6, "N");
var cycloHexeneNitrogen = builder.NewRing(6, "N");
cycloHexeneNitrogen.Bonds[0].Order = BondOrder.Double;
// Add them to a IAtomContainerSet
var atomContainerSet = builder.NewAtomContainerSet();
atomContainerSet.Add(cycloHexane);
atomContainerSet.Add(cycloHexeneNitrogen);
atomContainerSet.Add(cycloPentane);
atomContainerSet.Add(hexaneNitrogen);
atomContainerSet.Add(cycloHexaneNitrogen);
// Sort the IAtomContainerSet
AtomContainerSetManipulator.Sort(atomContainerSet);
// Assert.assert the correct order
Assert.AreSame(cycloPentane, atomContainerSet[0], "first order: cycloPentane");
Assert.AreSame(cycloHexane, atomContainerSet[1], "second order: cycloHexane");
Assert.AreSame(hexaneNitrogen, atomContainerSet[2], "third order: hexaneNitrogen");
Assert.AreSame(cycloHexaneNitrogen, atomContainerSet[3], "forth order: cycloHexaneNitrogen");
Assert.AreSame(cycloHexeneNitrogen, atomContainerSet[4], "firth order: cycloHexeneNitrogen");
}
/// <summary>
/// This badly named methods tries to determine which AtomContainer in the
/// ChemModel is best suited to contain added Atom's and Bond's.
/// </summary>
public static IAtomContainer GetRelevantAtomContainer(IChemModel chemModel, IAtom atom)
{
IAtomContainer result = null;
if (chemModel.MoleculeSet != null)
{
var moleculeSet = chemModel.MoleculeSet;
result = MoleculeSetManipulator.GetRelevantAtomContainer(moleculeSet, atom);
if (result != null)
{
return(result);
}
}
if (chemModel.ReactionSet != null)
{
var reactionSet = chemModel.ReactionSet;
return(ReactionSetManipulator.GetRelevantAtomContainer(reactionSet, atom));
}
if (chemModel.Crystal != null && chemModel.Crystal.Contains(atom))
{
return(chemModel.Crystal);
}
if (chemModel.RingSet != null)
{
return(AtomContainerSetManipulator.GetRelevantAtomContainer(chemModel.RingSet, atom));
}
throw new ArgumentException("The provided atom is not part of this IChemModel.");
}
public void TestGetRelevantAtomContainer_IAtomContainerSet_IAtom()
{
var ac1 = AtomContainerSetManipulator.GetRelevantAtomContainer(som, atomInMol1);
Assert.AreEqual(mol1, ac1);
var ac2 = AtomContainerSetManipulator.GetRelevantAtomContainer(som, atomInMol2);
Assert.AreEqual(mol2, ac2);
}
public void TestSetAtomProperties_IAtomContainerSet_Object_Object()
{
var key = "key";
var value = "value";
AtomContainerSetManipulator.SetAtomProperties(som, key, value);
Assert.AreEqual(value, atomInMol1.GetProperty <string>(key));
Assert.AreEqual(value, atomInMol2.GetProperty <string>(key));
}
public static IEnumerable <string> GetAllIDs(IChemObjectSet <IAtomContainer> set)
{
// the ID is set in AtomContainerSetManipulator.GetAllIDs()
foreach (var id in AtomContainerSetManipulator.GetAllIDs(set))
{
yield return(id);
}
yield break;
}
public void TestContainsByID_IAtomContainerSet_IAtomContainer()
{
var relevantAtomContainer = builder.NewAtomContainer();
var atomContainerSet = builder.NewAtomContainerSet();
atomContainerSet.Add(relevantAtomContainer);
Assert.IsFalse(AtomContainerSetManipulator.ContainsByID(atomContainerSet, relevantAtomContainer.Id));
relevantAtomContainer.Id = "1";
Assert.IsTrue(AtomContainerSetManipulator.ContainsByID(atomContainerSet, relevantAtomContainer.Id));
}
public void TestGetAllIDs_IAtomContainerSet()
{
som.Id = "som";
mol2.Id = "mol";
atomInMol2.Id = "atom";
bondInMol1.Id = "bond";
var list = AtomContainerSetManipulator.GetAllIDs(som);
Assert.AreEqual(4, list.Count());
}
public void TestRemoveElectronContainer_IAtomContainerSet_IElectronContainer()
{
var ms = builder.NewChemObjectSet <IAtomContainer>();
var mol = builder.NewAtomContainer();
mol.Atoms.Add(builder.NewAtom("O"));
mol.Atoms.Add(builder.NewAtom("O"));
mol.AddBond(mol.Atoms[0], mol.Atoms[1], BondOrder.Double);
var bond = mol.Bonds[0];
ms.Add(mol);
var otherBond = builder.NewBond(builder.NewAtom(), builder.NewAtom());
AtomContainerSetManipulator.RemoveElectronContainer(ms, otherBond);
Assert.AreEqual(1, AtomContainerSetManipulator.GetBondCount(ms));
AtomContainerSetManipulator.RemoveElectronContainer(ms, bond);
Assert.AreEqual(0, AtomContainerSetManipulator.GetBondCount(ms));
}
/// <summary>
/// Gets a reaction from a ReactionSet by ID of any product or reactant. If several exist,
/// only the first one will be returned.
/// </summary>
/// <param name="reactionSet">The reactionSet to search in</param>
/// <param name="id">The id to search for.</param>
/// <returns>The Reaction or null;</returns>
public static IReaction GetReactionByAtomContainerID(IReactionSet reactionSet, string id)
{
foreach (var reaction in reactionSet)
{
if (AtomContainerSetManipulator.ContainsByID(reaction.Products, id))
{
return(reaction);
}
}
foreach (var reaction in reactionSet)
{
if (AtomContainerSetManipulator.ContainsByID(reaction.Reactants, id))
{
return(reaction);
}
}
return(null);
}
public void TestRemoveAtomAndConnectedElectronContainers_IAtomContainerSet_IAtom()
{
var ms = builder.NewChemObjectSet <IAtomContainer>();
var mol = builder.NewAtomContainer();
mol.Atoms.Add(builder.NewAtom("O"));
mol.Atoms.Add(builder.NewAtom("O"));
mol.AddBond(mol.Atoms[0], mol.Atoms[1], BondOrder.Double);
var atom = mol.Atoms[0];
ms.Add(mol);
var otherAtom = builder.NewAtom("O");
AtomContainerSetManipulator.RemoveAtomAndConnectedElectronContainers(ms, otherAtom);
Assert.AreEqual(1, AtomContainerSetManipulator.GetBondCount(ms));
Assert.AreEqual(2, AtomContainerSetManipulator.GetAtomCount(ms));
AtomContainerSetManipulator.RemoveAtomAndConnectedElectronContainers(ms, atom);
Assert.AreEqual(0, AtomContainerSetManipulator.GetBondCount(ms));
Assert.AreEqual(1, AtomContainerSetManipulator.GetAtomCount(ms));
}
public void TestGetTotalHydrogenCount_IAtomContainerSet()
{
var hCount = AtomContainerSetManipulator.GetTotalHydrogenCount(som);
Assert.AreEqual(3, hCount);
}
/// <summary>
/// </summary>
/// <param name="set">The collection of IAtomContainer objects</param>
/// <seealso cref="AtomContainerSetManipulator"/>
/// <returns>The total formal charge on the collection of molecules</returns>
public static double GetTotalFormalCharge(IChemObjectSet <IAtomContainer> set)
{
return(AtomContainerSetManipulator.GetTotalFormalCharge(set));
}
/// <summary>
/// </summary>
/// <param name="set">The collection of IAtomContainer objects</param>
/// <seealso cref="AtomContainerSetManipulator"/>
/// <returns>the total implicit hydrogen count on the collection of molecules</returns>
public static int GetTotalHydrogenCount(IChemObjectSet <IAtomContainer> set)
{
return(AtomContainerSetManipulator.GetTotalHydrogenCount(set));
}
public static void RemoveElectronContainer(IChemObjectSet <IAtomContainer> set, IElectronContainer electrons)
{
AtomContainerSetManipulator.RemoveElectronContainer(set, electrons);
}
/// <summary>
/// Returns all the AtomContainer's of a MoleculeSet.
/// </summary>
/// <param name="set">The collection of IAtomContainer objects</param>
/// <returns>a list containing individual IAtomContainer's</returns>
public static IEnumerable <IAtomContainer> GetAllAtomContainers(IEnumerable <IAtomContainer> set)
{
return(AtomContainerSetManipulator.GetAllAtomContainers(set));
}
public static IEnumerable <IChemObject> GetAllChemObjects(IChemObjectSet <IAtomContainer> set)
{
return(AtomContainerSetManipulator.GetAllChemObjects(set));
}
public static void RemoveAtomAndConnectedElectronContainers(IChemObjectSet <IAtomContainer> set, IAtom atom)
{
AtomContainerSetManipulator.RemoveAtomAndConnectedElectronContainers(set, atom);
}
public static void SetAtomProperties(IChemObjectSet <IAtomContainer> set, string propKey, object propVal)
{
AtomContainerSetManipulator.SetAtomProperties(set, propKey, propVal);
}
public static IAtomContainer GetRelevantAtomContainer(IChemObjectSet <IAtomContainer> moleculeSet, IBond bond)
{
return(AtomContainerSetManipulator.GetRelevantAtomContainer(moleculeSet, bond));
}
public void TestGetTotalFormalCharge_IAtomContainerSet()
{
var charge = AtomContainerSetManipulator.GetTotalFormalCharge(som);
Assert.AreEqual(-1.0, charge, 0.000001);
}
public void TestGetBondCount_IAtomContainerSet()
{
var count = AtomContainerSetManipulator.GetBondCount(som);
Assert.AreEqual(1, count);
}
public void TestGetAllAtomContainers_IAtomContainerSet()
{
var list = AtomContainerSetManipulator.GetAllAtomContainers(som);
Assert.AreEqual(2, list.Count());
}
public void TestGetRelevantAtomContainer_IAtomContainerSet_IBond()
{
var ac1 = AtomContainerSetManipulator.GetRelevantAtomContainer(som, bondInMol1);
Assert.AreEqual(mol1, ac1);
}
public void TestGetAllChemObjects_IAtomContainerSet()
{
var list = AtomContainerSetManipulator.GetAllChemObjects(som);
Assert.AreEqual(3, list.Count()); // only AtomContainerSets and AtomContainers at the moment (see source code comment)
}
