public static void PerceiveDativeBonds(IReaction reaction) { foreach (var mol in ReactionManipulator.GetAllMolecules(reaction)) { AtomContainerManipulator.PerceiveDativeBonds(mol); } }
public static void RemoveAtomAndConnectedElectronContainers(IReactionSet set, IAtom atom) { foreach (var reaction in set) { ReactionManipulator.RemoveAtomAndConnectedElectronContainers(reaction, atom); } }
public static void SetAtomProperties(IReactionSet set, string propKey, object propVal) { foreach (var reaction in set) { ReactionManipulator.SetAtomProperties(reaction, propKey, propVal); } }
public void TestGetMappedChemObject_IReaction_IBond() { var builder = ChemObjectBuilder.Instance; IReaction reaction = builder.NewReaction(); IAtomContainer reactant = CDK.SmilesParser.ParseSmiles("[C+]-C=C"); IAtomContainer product = CDK.SmilesParser.ParseSmiles("C=C=C"); IMapping mapping = builder.NewMapping(reactant.Atoms[0], product.Atoms[0]); reaction.Mappings.Add(mapping); mapping = builder.NewMapping(reactant.Bonds[0], product.Bonds[0]); reaction.Mappings.Add(mapping); mapping = builder.NewMapping(reactant.Bonds[1], product.Bonds[1]); reaction.Mappings.Add(mapping); reaction.Reactants.Add(reactant); reaction.Products.Add(product); IBond mappedBond = (IBond)ReactionManipulator.GetMappedChemObject(reaction, reactant.Bonds[0]); Assert.AreEqual(mappedBond, product.Bonds[0]); mappedBond = (IBond)ReactionManipulator.GetMappedChemObject(reaction, product.Bonds[1]); Assert.AreEqual(mappedBond, reactant.Bonds[1]); }
public static void RemoveElectronContainer(IReactionSet set, IElectronContainer electrons) { foreach (var reaction in set) { ReactionManipulator.RemoveElectronContainer(reaction, electrons); } }
/// <summary> /// get all Molecules object from a set of Reactions. /// </summary> /// <param name="set">The set of reaction to inspect</param> /// <returns>The IAtomContanerSet</returns> public static IChemObjectSet <IAtomContainer> GetAllMolecules(IReactionSet set) { var moleculeSet = set.Builder.NewAtomContainerSet(); foreach (var reaction in set) { var molecules = ReactionManipulator.GetAllMolecules(reaction); foreach (var ac in molecules) { bool contain = false; foreach (var atomContainer in moleculeSet) { if (atomContainer.Equals(ac)) { contain = true; break; } } if (!contain) { moleculeSet.Add(ac); } } } return(moleculeSet); }
public void TestGetRelevantAtomContainer_IReaction_IBond() { foreach (var container in ReactionManipulator.GetAllAtomContainers(reaction)) { IBond aBond = container.Bonds[0]; Assert.AreEqual(container, ReactionManipulator.GetRelevantAtomContainer(reaction, aBond)); } }
public void TestGetRelevantAtomContainer_IReaction_IAtom() { foreach (var container in ReactionManipulator.GetAllAtomContainers(reaction)) { IAtom anAtom = container.Atoms[0]; Assert.AreEqual(container, ReactionManipulator.GetRelevantAtomContainer(reaction, anAtom)); } }
public void TestGetAllChemObjects_IReactionSet() { var allObjects = ReactionManipulator.GetAllChemObjects(reaction); // does not recurse beyond the IAtomContainer, so: // reaction, 2xreactant, 1xproduct Assert.AreEqual(4, allObjects.Count()); }
public static int GetBondCount(IReactionSet set) { int count = 0; foreach (var iReaction in set) { count += ReactionManipulator.GetBondCount(iReaction); } return(count); }
public void TestSetAtomProperties_IReactionSet_Object_Object() { ReactionManipulator.SetAtomProperties(reaction, "test", "ok"); foreach (var container in ReactionManipulator.GetAllAtomContainers(reaction)) { foreach (var atom in container.Atoms) { Assert.IsNotNull(atom.GetProperty <string>("test")); Assert.AreEqual("ok", atom.GetProperty <string>("test")); } } }
public void TestGetAllReactants_IReaction() { var builder = ChemObjectBuilder.Instance; IReaction reaction = builder.NewReaction(); reaction.Reactants.Add(builder.NewAtomContainer()); reaction.Reactants.Add(builder.NewAtomContainer()); reaction.Reactants.Add(builder.NewAtomContainer()); reaction.Products.Add(builder.NewAtomContainer()); reaction.Products.Add(builder.NewAtomContainer()); Assert.AreEqual(2, ReactionManipulator.GetAllProducts(reaction).Count()); }
public void InliningReactionsWithRadicals() { IChemObjectBuilder bldr = ChemObjectBuilder.Instance; SmilesParser smipar = new SmilesParser(bldr); IReaction reaction = smipar.ParseReactionSmiles("[CH2]CO.CC(=O)O>[H+]>CCOC(=O)C.O |^1:0| ethyl esterification"); SmilesGenerator smigen = new SmilesGenerator(SmiFlavors.CxSmiles); // convert to molecule IAtomContainer mol = ReactionManipulator.ToMolecule(reaction); Assert.AreEqual("[CH2]CO.CC(=O)O.[H+].CCOC(=O)C.O |^1:0|", smigen.Create(mol)); Assert.AreEqual("[CH2]CO.CC(=O)O>[H+]>CCOC(=O)C.O |^1:0|", smigen.CreateReactionSMILES(ReactionManipulator.ToReaction(mol))); }
public static IReaction GetRelevantReaction(IReactionSet set, IAtom atom) { foreach (var reaction in set) { var container = ReactionManipulator.GetRelevantAtomContainer(reaction, atom); if (container != null) { // a match! return(reaction); } } return(null); }
public static IAtomContainer GetRelevantAtomContainer(IReactionSet set, IBond bond) { foreach (var reaction in set) { var container = ReactionManipulator.GetRelevantAtomContainer(reaction, bond); if (container != null) { // a match! return(container); } } return(null); }
public static List <IChemObject> GetAllChemObjects(IReactionSet set) { List <IChemObject> list = new List <IChemObject> { set }; foreach (var reaction in set) { list.AddRange(ReactionManipulator.GetAllChemObjects(reaction)); } return(list); }
public static IEnumerable <IChemObject> GetAllChemObjects(IReactionSet set) { yield return(set); foreach (var reaction in set) { foreach (var o in ReactionManipulator.GetAllChemObjects(reaction)) { yield return(o); } } yield break; }
public static IEnumerable <string> GetAllIDs(IReactionSet set) { if (set.Id != null) { yield return(set.Id); } foreach (var reaction in set) { foreach (var e in ReactionManipulator.GetAllIDs(reaction)) { yield return(e); } } yield break; }
/// <summary> /// Get all molecule objects from a set of Reactions given a <see cref="IAtomContainerSet"/> to add. /// </summary> /// <param name="scheme">The set of reaction to inspect</param> /// <param name="molSet">The set of molecules to be added</param> /// <returns>All molecules</returns> public static IChemObjectSet <IAtomContainer> GetAllAtomContainers(IReactionScheme scheme, IChemObjectSet <IAtomContainer> molSet) { // A ReactionScheme can contain other IRreactionSet objects foreach (var rm in scheme.Schemes) { foreach (var ac in GetAllAtomContainers(rm, molSet)) { bool contain = false; foreach (var atomContainer in molSet) { if (atomContainer.Equals(ac)) { contain = true; break; } } if (!contain) { molSet.Add((IAtomContainer)(ac)); } } } foreach (var reaction in scheme.Reactions) { var newAtomContainerSet = ReactionManipulator.GetAllAtomContainers(reaction); foreach (var ac in newAtomContainerSet) { bool contain = false; foreach (var atomContainer in molSet) { if (atomContainer.Equals(ac)) { contain = true; break; } } if (!contain) { molSet.Add(ac); } } } return(molSet); }
public void TestReverse_IReaction() { Reaction reaction = new Reaction { Direction = ReactionDirection.Backward }; IAtomContainer water = new AtomContainer(); reaction.Reactants.Add(water, 3.0); reaction.Reactants.Add(new AtomContainer()); reaction.Products.Add(new AtomContainer()); Reaction reversedReaction = (Reaction)ReactionManipulator.Reverse(reaction); Assert.AreEqual(ReactionDirection.Forward, reversedReaction.Direction); Assert.AreEqual(2, reversedReaction.Products.Count); Assert.AreEqual(1, reversedReaction.Reactants.Count); Assert.AreEqual(3.0, reversedReaction.Products.GetMultiplier(water).Value, 0.00001); }
/// <summary> /// Get all ID of this IReactionSet. /// </summary> /// <param name="scheme">The IReactionScheme to analyze</param> /// <returns>A List with all ID</returns> public static IEnumerable <string> GetAllIDs(IReactionScheme scheme) { var IDlist = new List <string>(); if (scheme.Id != null) { IDlist.Add(scheme.Id); } foreach (var reaction in scheme.Reactions) { IDlist.AddRange(ReactionManipulator.GetAllIDs(reaction)); } if (scheme.Schemes.Count != 0) { foreach (var rs in scheme.Schemes) { IDlist.AddRange(GetAllIDs(rs)); } } return(IDlist); }
public void TestRemoveAtomAndConnectedElectronContainers_IReaction_IAtom() { var builder = ChemObjectBuilder.Instance; IReaction reaction = builder.NewReaction(); IAtomContainer mol = builder.NewAtomContainer(); mol.Atoms.Add(builder.NewAtom("C")); mol.Atoms.Add(builder.NewAtom("C")); mol.AddBond(mol.Atoms[0], mol.Atoms[1], BondOrder.Single); Assert.AreEqual(2, mol.Atoms.Count); Assert.AreEqual(1, mol.Bonds.Count); reaction.Reactants.Add(mol); reaction.Reactants.Add(builder.NewAtomContainer()); reaction.Reactants.Add(builder.NewAtomContainer()); reaction.Products.Add(builder.NewAtomContainer()); reaction.Products.Add(builder.NewAtomContainer()); ReactionManipulator.RemoveAtomAndConnectedElectronContainers(reaction, mol.Atoms[0]); Assert.AreEqual(1, mol.Atoms.Count); Assert.AreEqual(0, mol.Bonds.Count); }
public void TestGetAllIDs_IReaction() { Reaction reaction = new Reaction() { Id = "r1" }; IAtomContainer water = new AtomContainer { Id = "m1" }; Atom oxygen = new Atom("O") { Id = "a1" }; water.Atoms.Add(oxygen); reaction.Reactants.Add(water); reaction.Products.Add(water); var ids = ReactionManipulator.GetAllIDs(reaction); Assert.IsNotNull(ids); Assert.AreEqual(5, ids.Count()); }
public void TestGetAtomCount_IReaction() { Assert.AreEqual(19, ReactionManipulator.GetAtomCount(reaction)); }
public void TestGetBondCount_IReaction() { Assert.AreEqual(18, ReactionManipulator.GetBondCount(reaction)); }
public void TestGetAllAtomContainers_IReaction() { Assert.AreEqual(3, ReactionManipulator.GetAllAtomContainers(reaction).Count()); }