private static void FixPyridineNOxides(IAtomContainer atomContainer, IRingSet ringSet) { //convert n(=O) to [n+][O-] for (int i = 0; i < atomContainer.Atoms.Count; i++) { var ai = atomContainer.Atoms[i]; if (ai.AtomicNumber.Equals(AtomicNumbers.N) && (ai.FormalCharge == null || ai.FormalCharge == 0)) { if (InRingSet(ai, ringSet)) { var ca = atomContainer.GetConnectedAtoms(ai); foreach (var caj in ca) { if (caj.AtomicNumber.Equals(AtomicNumbers.O) && atomContainer.GetBond(ai, caj).Order == BondOrder.Double) { ai.FormalCharge = 1; caj.FormalCharge = -1; atomContainer.GetBond(ai, caj).Order = BondOrder.Single; } } // end for (int j=0;j<ca.Count;j++) } // end if (InRingSet(ai,ringSet)) { } // end if (ai.Symbol.Equals("N") && ai.FormalCharge==0) } // end for (int i=0;i<atomContainer.Atoms.Count;i++) }
/// <summary> /// Checks whether the P atom is in a PO environment. /// </summary> /// <remarks> /// This environment is noted in Kier & Hall (1986), page 20 /// </remarks> /// <param name="atom">The P atom in question</param> /// <param name="atomContainer">The molecule containing the P atom</param> /// <returns>The empirical delta V if present in the above environment, -1 otherwise</returns> private static double DeltavPhosphorous(IAtom atom, IAtomContainer atomContainer) { if (!atom.AtomicNumber.Equals(AtomicNumbers.P)) { return(-1); } var connected = atomContainer.GetConnectedAtoms(atom); int conditions = 0; if (connected.Count() == 4) { conditions++; } foreach (var connectedAtom in connected) { if (connectedAtom.AtomicNumber.Equals(AtomicNumbers.O) && atomContainer.GetBond(atom, connectedAtom).Order == BondOrder.Double) { conditions++; } if (atomContainer.GetBond(atom, connectedAtom).Order == BondOrder.Single) { conditions++; } } if (conditions == 5) { return(2.22); } return(-1); }
/// <summary> /// Says if an atom is the end of a double bond configuration /// </summary> /// <param name="atom">The atom which is the end of configuration</param> /// <param name="container">The atomContainer the atom is in</param> /// <param name="parent">The atom we came from</param> /// <param name="doubleBondConfiguration">The array indicating where double bond /// configurations are specified (this method ensures that there is /// actually the possibility of a double bond configuration)</param> /// <returns>false=is not end of configuration, true=is</returns> private static bool IsEndOfDoubleBond(IAtomContainer container, IAtom atom, IAtom parent, bool[] doubleBondConfiguration) { var bondNumber = container.Bonds.IndexOf(container.GetBond(atom, parent)); if (bondNumber == -1 || doubleBondConfiguration.Length <= bondNumber || !doubleBondConfiguration[bondNumber]) { return(false); } int hcount = atom.ImplicitHydrogenCount ?? 0; int lengthAtom = container.GetConnectedAtoms(atom).Count() + hcount; hcount = parent.ImplicitHydrogenCount ?? 0; int lengthParent = container.GetConnectedAtoms(parent).Count() + hcount; if (container.GetBond(atom, parent) != null) { if (container.GetBond(atom, parent).Order == BondOrder.Double && (lengthAtom == 3 || (lengthAtom == 2 && atom.AtomicNumber.Equals(AtomicNumbers.N))) && (lengthParent == 3 || (lengthParent == 2 && parent.AtomicNumber.Equals(AtomicNumbers.N)))) { var atoms = container.GetConnectedAtoms(atom); IAtom one = null; IAtom two = null; foreach (var conAtom in atoms) { if (conAtom != parent && one == null) { one = conAtom; } else if (conAtom != parent && one != null) { two = conAtom; } } string[] morgannumbers = MorganNumbersTools.GetMorganNumbersWithElementSymbol(container); if ((one != null && two == null && atom.AtomicNumber.Equals(AtomicNumbers.N) && Math.Abs(GiveAngleBothMethods(parent, atom, one, true)) > Math.PI / 10) || (!atom.AtomicNumber.Equals(AtomicNumbers.N) && one != null && two != null && !morgannumbers[container.Atoms.IndexOf(one)].Equals(morgannumbers[container.Atoms.IndexOf(two)], StringComparison.Ordinal))) { return(true); } else { return(false); } } } return(false); }
/// <summary> /// Says if an atom is the start of a double bond configuration /// </summary> /// <param name="a">The atom which is the start of configuration</param> /// <param name="container">The atomContainer the atom is in</param> /// <param name="parent">The atom we came from</param> /// <param name="doubleBondConfiguration">The array indicating where double bond /// configurations are specified (this method ensures that there is /// actually the possibility of a double bond configuration)</param> /// <returns>false=is not start of configuration, true=is</returns> private static bool IsStartOfDoubleBond(IAtomContainer container, IAtom a, IAtom parent, bool[] doubleBondConfiguration) { int hcount; hcount = a.ImplicitHydrogenCount ?? 0; int lengthAtom = container.GetConnectedAtoms(a).Count() + hcount; if (lengthAtom != 3 && (lengthAtom != 2 && !(a.AtomicNumber.Equals(AtomicNumbers.N)))) { return(false); } var atoms = container.GetConnectedAtoms(a); IAtom one = null; IAtom two = null; bool doubleBond = false; IAtom nextAtom = null; foreach (var atom in atoms) { if (atom != parent && container.GetBond(atom, a).Order == BondOrder.Double && IsEndOfDoubleBond(container, atom, a, doubleBondConfiguration)) { doubleBond = true; nextAtom = atom; } if (atom != nextAtom && one == null) { one = atom; } else if (atom != nextAtom && one != null) { two = atom; } } string[] morgannumbers = MorganNumbersTools.GetMorganNumbersWithElementSymbol(container); if (one != null && ((!a.AtomicNumber.Equals(AtomicNumbers.N) && two != null && !morgannumbers[container.Atoms.IndexOf(one)].Equals(morgannumbers[container.Atoms.IndexOf(two)], StringComparison.Ordinal) && doubleBond && doubleBondConfiguration[container.Bonds.IndexOf(container.GetBond(a, nextAtom))]) || (doubleBond && a.AtomicNumber.Equals(AtomicNumbers.N) && Math.Abs(GiveAngleBothMethods(nextAtom, a, parent, true)) > Math.PI / 10))) { return(true); } else { return(false); } }
/// <summary> /// Prepares for a breadth first search within the <see cref="IAtomContainer"/>. The actual /// recursion is done in <see cref="NextSphere"/>. /// </summary> /// <param name="root">The atom at which we start the search</param> /// <param name="addTreeNode"></param> /// <exception cref="CDKException"> If something goes wrong.</exception> private void BreadthFirstSearch(IAtom root, bool addTreeNode) { sphere = 0; TreeNode tempNode = null; var conAtoms = atomContainer.GetConnectedAtoms(root); IBond bond = null; sphereNodes.Clear(); sphereNodesWithAtoms.Clear(); foreach (var atom in conAtoms) { try { if (atom.AtomicNumber.Equals(AtomicNumbers.H)) { continue; } bond = atomContainer.GetBond(root, atom); // In the first sphere the atoms are labeled with their own atom // atom as source if (bond.IsAromatic) { tempNode = new TreeNode(this, atom.Symbol, new TreeNode(this, root.Symbol, null, root, (double)0, 0, (long)0), atom, 4, atomContainer.GetConnectedBonds(atom).Count(), 0); } else { tempNode = new TreeNode( this, atom.Symbol, new TreeNode(this, root.Symbol, null, root, (double)0, 0, (long)0), atom, bond.Order.Numeric(), atomContainer.GetConnectedBonds(atom).Count(), 0); } sphereNodes.Add(tempNode); if (!addTreeNode) { sphereNodesWithAtoms.Add(atom); } // rootNode.childs.AddElement(tempNode); atom.IsVisited = true; } catch (Exception exc) { throw new CDKException("Error in HOSECodeGenerator->breadthFirstSearch.", exc); } } sphereNodes.Sort(new TreeNodeComparator()); NextSphere(sphereNodes); }
public void Z_1_2_difluroethene() { IAtomContainer ac = Convert("F/C=C\\F"); var se = ac.StereoElements.First(); Assert.IsInstanceOfType(se, typeof(IDoubleBondStereochemistry)); IDoubleBondStereochemistry dbs = (IDoubleBondStereochemistry)se; Assert.AreEqual(ac.GetBond(ac.Atoms[1], ac.Atoms[2]), dbs.StereoBond); Assert.IsTrue(Compares.AreDeepEqual(new IBond[] { ac.GetBond(ac.Atoms[0], ac.Atoms[1]), ac.GetBond(ac.Atoms[2], ac.Atoms[3]) }, dbs.Bonds)); Assert.AreEqual(DoubleBondConformation.Together, dbs.Stereo); }
/// <summary> /// Helper method to locate two terminal atoms in a container for this /// extended tetrahedral element. The atoms are ordered such that the first /// index is attached to the first two peripheral atoms and the second index /// is attached to the second two peripheral atoms. /// </summary> /// <param name="container">structure representation</param> /// <returns>the terminal atoms (ordered)</returns> public IAtom[] FindTerminalAtoms(IAtomContainer container) { var atoms = FindTerminalAtoms(container, Focus); var carriers = Carriers; if (container.GetBond(atoms[0], carriers[2]) != null || container.GetBond(atoms[0], carriers[3]) != null) { var tmp = atoms[0]; atoms[0] = atoms[1]; atoms[1] = tmp; } return(atoms); }
/// <summary> /// Says if of four atoms connected two one atom the up and down bonds are /// opposite or not, i. e.if it's tetrahedral or square planar. The method /// does not check if there are four atoms and if two or up and two are down /// </summary> /// <param name="atom">The atom which is the center</param> /// <param name="container">The atomContainer the atom is in</param> /// <returns>true=are opposite, false=are not</returns> public static bool StereosAreOpposite(IAtomContainer container, IAtom atom) { var atoms = container.GetConnectedAtoms(atom).ToReadOnlyList(); var hm = new SortedDictionary <double, int>(); for (int i = 1; i < atoms.Count; i++) { hm.Add(GiveAngle(atom, atoms[0], atoms[i]), i); } var ohere = hm.Values.ToArray(); var stereoOne = container.GetBond(atom, atoms[0]).Stereo; var stereoOpposite = container.GetBond(atom, atoms[ohere[1]]).Stereo; return(stereoOpposite == stereoOne); }
public void Z_1_2_difluroethene_explicit() { IAtomContainer ac = Convert("FC(\\[H])=C([H])/F"); var se = ac.StereoElements.First(); Assert.IsInstanceOfType(se, typeof(IDoubleBondStereochemistry)); IDoubleBondStereochemistry dbs = (IDoubleBondStereochemistry)se; Assert.AreEqual(ac.GetBond(ac.Atoms[1], ac.Atoms[3]), dbs.StereoBond); Assert.IsTrue(Compares.AreDeepEqual(new IBond[] { ac.GetBond(ac.Atoms[1], ac.Atoms[2]), ac.GetBond(ac.Atoms[3], ac.Atoms[5]) }, dbs.Bonds)); // the two 'F' are together but we use a H so they are 'opposite' Assert.AreEqual(DoubleBondConformation.Opposite, dbs.Stereo); }
/// <summary> /// Returns Ring set based on Hanser Ring Finding method /// <param name="molecule"></param> /// </summary> /// <returns>report collected the rings</returns> /// <seealso cref="IRingFinder.GetRingSet(IAtomContainer)"/> public IRingSet GetRingSet(IAtomContainer molecule) { var cycles = FindRings(molecule); IRingSet ringSet = molecule.Builder.NewRingSet(); foreach (var ringAtoms in cycles) { IRing ring = molecule.Builder.NewRing(); foreach (var atom in ringAtoms) { atom.IsInRing = true; ring.Atoms.Add(atom); foreach (var atomNext in ringAtoms) { if (!atom.Equals(atomNext)) { IBond bond = molecule.GetBond(atom, atomNext); if (bond != null) { bond.IsInRing = true; ring.Bonds.Add(bond); } } } } ringSet.Add(ring); } return(ringSet); }
/// <summary> /// Encode the provided path of atoms to a string. /// </summary> /// <param name="path">inclusive array of vertex indices</param> /// <returns>encoded path</returns> private string Encode(int[] path) { var sb = new StringBuilder(path.Length * 3); for (int i = 0, n = path.Length - 1; i <= n; i++) { var atom = container.Atoms[path[i]]; sb.Append(ToAtomPattern(atom)); if (atom is IPseudoAtom) { pseudoAtoms.Add(atom.Symbol); // potential bug, although the atoms are canonical we cannot guarantee the order we will visit them. // sb.Append(PeriodicTable.GetElementCount() + pseudoAtoms.Count()); } // if we are not at the last index, add the connecting bond if (i < n) { IBond bond = container.GetBond(container.Atoms[path[i]], container.Atoms[path[i + 1]]); sb.Append(GetBondSymbol(bond)); } } return(sb.ToString()); }
/// <summary> /// Constructor for the TopologicalEquivalentClass object. /// </summary> public EquivalentClassPartitioner(IAtomContainer atomContainer) { adjaMatrix = ConnectionMatrix.GetMatrix(atomContainer); apspMatrix = PathTools.ComputeFloydAPSP(adjaMatrix); layerNumber = 1; nodeNumber = atomContainer.Atoms.Count; for (int i = 1; i < atomContainer.Atoms.Count; i++) { for (int j = 0; j < i; j++) { // define the number of layer equal to the longest path obtained // by calculating the all-pair-shortest path if (apspMatrix[i][j] > layerNumber) { layerNumber = apspMatrix[i][j]; } // correct adjacency matrix to consider aromatic bonds as such if (adjaMatrix[i][j] > 0) { IBond bond = atomContainer.GetBond(atomContainer.Atoms[i], atomContainer.Atoms[j]); bool isArom = bond.IsAromatic; adjaMatrix[i][j] = (isArom) ? 1.5 : adjaMatrix[i][j]; adjaMatrix[j][i] = adjaMatrix[i][j]; } } } nodeMatrix = Arrays.CreateJagged <double>(nodeNumber, layerNumber + 1); bondMatrix = Arrays.CreateJagged <double>(nodeNumber, layerNumber); weight = new double[nodeNumber + 1]; }
/// <inheritdoc/> public override bool IsConnected(int index1, int index2) { IAtom atom1 = atomContainer.Atoms[index1]; IAtom atom2 = atomContainer.Atoms[index2]; return(atomContainer.GetBond(atom1, atom2) != null); }
/// <summary> /// /// Returns bond map between source and target molecules based on the atoms /// <param name="ac1">source molecule</param> /// <param name="ac2">target molecule</param> /// <param name="mapping">mappings between source and target molecule atoms</param> /// <returns>bond map between source and target molecules based on the atoms</returns> /// </summary> public static IReadOnlyDictionary <IBond, IBond> MakeBondMapOfAtomMap( IAtomContainer ac1, IAtomContainer ac2, IReadOnlyDictionary <IAtom, IAtom> mapping) { var maps = new Dictionary <IBond, IBond>(); foreach (var mapS in mapping) { IAtom indexI = mapS.Key; IAtom indexJ = mapS.Value; foreach (var mapD in mapping) { IAtom indexIPlus = mapD.Key; IAtom indexJPlus = mapD.Value; if (!indexI.Equals(indexIPlus) && !indexJ.Equals(indexJPlus)) { IBond ac1Bond = ac1.GetBond(indexI, indexIPlus); if (ac1Bond != null) { IBond ac2Bond = ac2.GetBond(indexJ, indexJPlus); if (ac2Bond != null) { maps[ac1Bond] = ac2Bond; } } } } } return(maps); }
/// <summary> /// Obtain the bond between the atoms at index <paramref name="u"/> and 'v'. If the 'bondMap' /// is non-null it is used for direct lookup otherwise the slower linear /// lookup in 'container' is used. /// </summary> /// <param name="container">a structure</param> /// <param name="bondMap">optimised map of atom indices to bond instances</param> /// <param name="u">an atom index</param> /// <param name="v">an atom index (connected to u)</param> /// <returns>the bond between u and v</returns> private static IBond GetBond(IAtomContainer container, EdgeToBondMap bondMap, int u, int v) { if (bondMap != null) { return(bondMap[u, v]); } return(container.GetBond(container.Atoms[u], container.Atoms[v])); }
public static void MakeUpDownBonds(IAtomContainer container) { for (int i = 0; i < container.Atoms.Count; i++) { var a = container.Atoms[i]; var connectedAtoms = container.GetConnectedAtoms(a).ToReadOnlyList(); if (connectedAtoms.Count == 4) { int up = 0; int down = 0; int hs = 0; IAtom h = null; for (int k = 0; k < 4; k++) { IAtom conAtom = connectedAtoms[k]; BondStereo stereo = container.GetBond(a, conAtom).Stereo; if (stereo == BondStereo.Up) { up++; } else if (stereo == BondStereo.Down) { down++; } else if (stereo == BondStereo.None && conAtom.AtomicNumber.Equals(AtomicNumbers.H)) { h = conAtom; hs++; } else { h = null; } } if (up == 0 && down == 1 && h != null && hs == 1) { container.GetBond(a, h).Stereo = BondStereo.Up; } if (up == 1 && down == 0 && h != null && hs == 1) { container.GetBond(a, h).Stereo = BondStereo.Down; } } } }
private static IReadOnlyDictionary <IBond, IBond> MakeBondMapsOfAtomMaps(IAtomContainer ac1, IAtomContainer ac2, IReadOnlyDictionary <int, int> mappings) { var maps = new Dictionary <IBond, IBond>(); foreach (var atoms in ac1.Atoms) { int ac1AtomNumber = ac1.Atoms.IndexOf(atoms); if (mappings.ContainsKey(ac1AtomNumber)) { int ac2AtomNumber = mappings[ac1AtomNumber]; var connectedAtoms = ac1.GetConnectedAtoms(atoms); foreach (var cAtoms in connectedAtoms) { int ac1ConnectedAtomNumber = ac1.Atoms.IndexOf(cAtoms); if (mappings.ContainsKey(ac1ConnectedAtomNumber)) { { int ac2ConnectedAtomNumber = mappings[ac1ConnectedAtomNumber]; IBond ac1Bond = ac1.GetBond(atoms, cAtoms); IBond ac2Bond = ac2.GetBond(ac2.Atoms[ac2AtomNumber], ac2.Atoms[ac2ConnectedAtomNumber]); if (ac2Bond == null) { ac2Bond = ac2.GetBond(ac2.Atoms[ac2ConnectedAtomNumber], ac2.Atoms[ac2AtomNumber]); } if (ac1Bond != null && ac2Bond != null) { maps[ac1Bond] = ac2Bond; } } } } } } return(maps); }
internal static bool IsFurtherMappingPossible(IAtomContainer source, IAtomContainer target, McgregorHelper mcGregorHelper, bool shouldMatchBonds) { int neighborBondNumA = mcGregorHelper.NeighborBondNumA; int neighborBondNumB = mcGregorHelper.NeighborBondNumB; var iBondNeighborAtomsA = mcGregorHelper.GetIBondNeighborAtomsA(); var iBondNeighborAtomsB = mcGregorHelper.GetIBondNeighborAtomsB(); var cBondNeighborsA = mcGregorHelper.GetCBondNeighborsA(); var cBondNeighborsB = mcGregorHelper.GetCBondNeighborsB(); for (int row = 0; row < neighborBondNumA; row++) { // Console.Out.WriteLine("i " + row); string g1A = cBondNeighborsA[row * 4 + 0]; string g2A = cBondNeighborsA[row * 4 + 1]; for (int column = 0; column < neighborBondNumB; column++) { string g1B = cBondNeighborsB[column * 4 + 0]; string g2B = cBondNeighborsB[column * 4 + 1]; if (IsAtomMatch(g1A, g2A, g1B, g2B)) { try { int indexI = iBondNeighborAtomsA[row * 3 + 0]; int indexIPlus1 = iBondNeighborAtomsA[row * 3 + 1]; int indexJ = iBondNeighborAtomsB[column * 3 + 0]; int indexJPlus1 = iBondNeighborAtomsB[column * 3 + 1]; IAtom r1A = source.Atoms[indexI]; IAtom r2A = source.Atoms[indexIPlus1]; IBond reactantBond = source.GetBond(r1A, r2A); IAtom p1B = target.Atoms[indexJ]; IAtom p2B = target.Atoms[indexJPlus1]; IBond productBond = target.GetBond(p1B, p2B); if (IsMatchFeasible(source, reactantBond, target, productBond, shouldMatchBonds)) { return(true); } } catch (Exception e) { Console.Out.WriteLine(e.StackTrace); } } } } return(false); }
private void SetModifedArcs(McgregorHelper mcGregorHelper) { int neighborBondNumA = mcGregorHelper.NeighborBondNumA; int neighborBondNumB = mcGregorHelper.NeighborBondNumB; var iBondNeighborAtomsA = mcGregorHelper.GetIBondNeighborAtomsA(); var iBondNeighborAtomsB = mcGregorHelper.GetIBondNeighborAtomsB(); var cBondNeighborsA = mcGregorHelper.GetCBondNeighborsA(); var cBondNeighborsB = mcGregorHelper.GetCBondNeighborsB(); for (int row = 0; row < neighborBondNumA; row++) { for (int column = 0; column < neighborBondNumB; column++) { string g1A = cBondNeighborsA[row * 4 + 0]; string g2A = cBondNeighborsA[row * 4 + 1]; string g1B = cBondNeighborsB[column * 4 + 0]; string g2B = cBondNeighborsB[column * 4 + 1]; if (MatchGAtoms(g1A, g2A, g1B, g2B)) { int indexI = iBondNeighborAtomsA[row * 3 + 0]; int indexIPlus1 = iBondNeighborAtomsA[row * 3 + 1]; IAtom r1A = source.Atoms[indexI]; IAtom r2A = source.Atoms[indexIPlus1]; IBond reactantBond = source.GetBond(r1A, r2A); int indexJ = iBondNeighborAtomsB[column * 3 + 0]; int indexJPlus1 = iBondNeighborAtomsB[column * 3 + 1]; IAtom p1B = target.Atoms[indexJ]; IAtom p2B = target.Atoms[indexJPlus1]; IBond productBond = target.GetBond(p1B, p2B); if (McGregorChecks.IsMatchFeasible(source, reactantBond, target, productBond, IsBondMatch)) { modifiedARCS[row * neighborBondNumB + column] = 1; } } } } }
/// <summary> /// Says if two atoms are in cis or trans position around a double bond. /// The atoms have to be given to the method like this: firstOuterAtom - firstInnerAtom = secondInnterAtom - secondOuterAtom /// </summary> /// <param name="firstOuterAtom">See above.</param> /// <param name="firstInnerAtom">See above.</param> /// <param name="secondInnerAtom">See above.</param> /// <param name="secondOuterAtom">See above.</param> /// <param name="ac">The atom container the atoms are in.</param> /// <returns>true=trans, false=cis.</returns> /// <exception cref="CDKException"> The atoms are not in a double bond configuration (no double bond in the middle, same atoms on one side)</exception> public static bool IsCisTrans(IAtom firstOuterAtom, IAtom firstInnerAtom, IAtom secondInnerAtom, IAtom secondOuterAtom, IAtomContainer ac) { if (!IsValidDoubleBondConfiguration(ac, ac.GetBond(firstInnerAtom, secondInnerAtom))) { throw new CDKException("There is no valid double bond configuration between your inner atoms!"); } bool firstDirection = IsLeft(firstOuterAtom, firstInnerAtom, secondInnerAtom); bool secondDirection = IsLeft(secondOuterAtom, secondInnerAtom, firstInnerAtom); return(firstDirection == secondDirection); }
public void GetConnectivityTest() { string acpString = "C0C1C2C3 0:1(1),0:3(1),1:2(2),2:3(1)"; IAtomContainer ac = AtomContainerPrinter.FromString(acpString, builder); AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner(); refiner.Refine(ac); IBond bond = ac.GetBond(ac.Atoms[1], ac.Atoms[2]); int orderN = bond.Order.Numeric(); Assert.AreEqual(orderN, refiner.GetConnectivity(1, 2)); }
public void Benzene_kekule() { IAtomContainer ac = Convert("C=1C=CC=CC1"); Assert.AreEqual(6, ac.Atoms.Count); Assert.AreEqual(6, ac.Bonds.Count); foreach (var a in ac.Atoms) { Assert.AreEqual("C", a.Symbol); Assert.AreEqual(1, a.ImplicitHydrogenCount); } Assert.AreEqual(BondOrder.Single, ac.GetBond(ac.Atoms[0], ac.Atoms[1]).Order); Assert.AreEqual(BondOrder.Double, ac.GetBond(ac.Atoms[1], ac.Atoms[2]).Order); Assert.AreEqual(BondOrder.Single, ac.GetBond(ac.Atoms[2], ac.Atoms[3]).Order); Assert.AreEqual(BondOrder.Double, ac.GetBond(ac.Atoms[3], ac.Atoms[4]).Order); Assert.AreEqual(BondOrder.Single, ac.GetBond(ac.Atoms[4], ac.Atoms[5]).Order); Assert.AreEqual(BondOrder.Double, ac.GetBond(ac.Atoms[5], ac.Atoms[0]).Order); Assert.IsFalse(ac.Bonds[0].IsAromatic); Assert.IsFalse(ac.Bonds[1].IsAromatic); Assert.IsFalse(ac.Bonds[2].IsAromatic); Assert.IsFalse(ac.Bonds[3].IsAromatic); Assert.IsFalse(ac.Bonds[4].IsAromatic); Assert.IsFalse(ac.Bonds[5].IsAromatic); }
public void Imidazole_kekule() { IAtomContainer ac = Convert("N1C=CN=C1"); Assert.AreEqual(5, ac.Atoms.Count); Assert.AreEqual(5, ac.Bonds.Count); foreach (var a in ac.Atoms) { Assert.IsFalse(a.IsAromatic); } Assert.AreEqual("N", ac.Atoms[0].Symbol); Assert.AreEqual("C", ac.Atoms[1].Symbol); Assert.AreEqual("C", ac.Atoms[2].Symbol); Assert.AreEqual("N", ac.Atoms[3].Symbol); Assert.AreEqual("C", ac.Atoms[4].Symbol); Assert.AreEqual(1, ac.Atoms[0].ImplicitHydrogenCount); Assert.AreEqual(1, ac.Atoms[1].ImplicitHydrogenCount); Assert.AreEqual(1, ac.Atoms[2].ImplicitHydrogenCount); Assert.AreEqual(0, ac.Atoms[3].ImplicitHydrogenCount); Assert.AreEqual(1, ac.Atoms[4].ImplicitHydrogenCount); foreach (var a in ac.Atoms) { Assert.IsFalse(a.IsAromatic); } Assert.AreEqual(BondOrder.Single, ac.GetBond(ac.Atoms[0], ac.Atoms[1]).Order); Assert.AreEqual(BondOrder.Double, ac.GetBond(ac.Atoms[1], ac.Atoms[2]).Order); Assert.AreEqual(BondOrder.Single, ac.GetBond(ac.Atoms[2], ac.Atoms[3]).Order); Assert.AreEqual(BondOrder.Double, ac.GetBond(ac.Atoms[3], ac.Atoms[4]).Order); Assert.AreEqual(BondOrder.Single, ac.GetBond(ac.Atoms[4], ac.Atoms[0]).Order); foreach (var b in ac.Bonds) { Assert.IsFalse(b.IsAromatic); } }
/// <summary> /// Evaluates the empirical delt V for some S environments. /// </summary> /// <remarks> /// The method checks to see whether a S atom is in a -S-S-, /// -SO-, -SO2- group and returns the empirical values noted /// in Kier & Hall (1986), page 20. /// </remarks> /// <param name="atom">The S atom in question</param> /// <param name="atomContainer">The molecule containing the S</param> /// <returns>The empirical delta V if it is present in one of the above environments, -1 otherwise</returns> protected internal static double DeltavSulphur(IAtom atom, IAtomContainer atomContainer) { if (!atom.AtomicNumber.Equals(AtomicNumbers.S)) { return(-1); } // check whether it's a S in S-S var connected = atomContainer.GetConnectedAtoms(atom); foreach (var connectedAtom in connected) { if (connectedAtom.AtomicNumber.Equals(AtomicNumbers.S) && atomContainer.GetBond(atom, connectedAtom).Order == BondOrder.Single) { return(0.89); } } int count = 0; foreach (var connectedAtom in connected) { if (connectedAtom.AtomicNumber.Equals(AtomicNumbers.O) && atomContainer.GetBond(atom, connectedAtom).Order == BondOrder.Double) { count++; } } if (count == 1) { return(1.33); // check whether it's a S in -SO- } else if (count == 2) { return(2.67); // check whether it's a S in -SO2- } return(-1); }
public static void FixSulphurH(IAtomContainer m) { // removes extra H's attached to sulphurs for (int i = 0; i <= m.Atoms.Count - 1; i++) { var a = m.Atoms[i]; if (a.AtomicNumber.Equals(AtomicNumbers.S)) { var connectedAtoms = m.GetConnectedAtoms(a); int bondOrderSum = 0; foreach (var conAtom in connectedAtoms) { if (!conAtom.AtomicNumber.Equals(AtomicNumbers.H)) { IBond bond = m.GetBond(a, conAtom); if (bond.Order == BondOrder.Single) { bondOrderSum += 1; } else if (bond.Order == BondOrder.Double) { bondOrderSum += 2; } else if (bond.Order == BondOrder.Triple) { bondOrderSum += 3; } else if (bond.Order == BondOrder.Quadruple) { bondOrderSum += 4; } } } if (bondOrderSum > 1) { foreach (var conAtom in connectedAtoms) { if (conAtom.AtomicNumber.Equals(AtomicNumbers.H)) { m.RemoveAtom(conAtom); } } } } } }
/// <summary> /// Checks whether both atoms are involved in an amide C-N bond: *N(*)C(*)=O. /// /// Only the most common constitution is considered. Tautomeric, O\C(*)=N\*, /// and charged forms, [O-]\C(*)=N\*, are ignored. /// </summary> /// <param name="atom0">the first bonding partner</param> /// <param name="atom1">the second bonding partner</param> /// <param name="container">the parent container</param> /// <returns>if both partners are involved in an amide C-N bond</returns> private static bool IsAmide(IAtom atom0, IAtom atom1, IAtomContainer container) { if (atom0.AtomicNumber.Equals(AtomicNumbers.C) && atom1.AtomicNumber.Equals(AtomicNumbers.N)) { foreach (var neighbor in container.GetConnectedAtoms(atom0)) { if (neighbor.AtomicNumber.Equals(AtomicNumbers.O) && container.GetBond(atom0, neighbor).Order == BondOrder.Double) { return(true); } } } return(false); }
private static void ApplyBonds(IAtomContainer m, IList <string> al) { for (int i = 0; i <= al.Count - 1; i++) { var s = al[i]; var s1 = s.Substring(0, s.IndexOf('-')); var s2 = s.Substring(s.IndexOf('-') + 1); var i1 = int.Parse(s1, NumberFormatInfo.InvariantInfo); var i2 = int.Parse(s2, NumberFormatInfo.InvariantInfo); var b = m.GetBond(m.Atoms[i1], m.Atoms[i2]); b.Order = BondOrder.Double; } }
/// <summary> /// Generate Compatibility Graph Nodes Bond Insensitive /// </summary> /// <exception cref="System.IO.IOException"></exception> internal int CompatibilityGraph() { int compGraphNodesListSize = compGraphNodes.Count; cEdges = new List <int>(); //Initialize the cEdges List dEdges = new List <int>(); //Initialize the dEdges List for (int a = 0; a < compGraphNodesListSize; a += 3) { int indexA = compGraphNodes[a]; int indexAPlus1 = compGraphNodes[a + 1]; for (int b = a + 3; b < compGraphNodesListSize; b += 3) { int indexB = compGraphNodes[b]; int indexBPlus1 = compGraphNodes[b + 1]; // if element atomCont !=jIndex and atoms on the adjacent sides of the bonds are not equal if (a != b && indexA != indexB && indexAPlus1 != indexBPlus1) { IBond reactantBond = null; IBond productBond = null; reactantBond = source.GetBond(source.Atoms[indexA], source.Atoms[indexB]); productBond = target.GetBond(target.Atoms[indexAPlus1], target.Atoms[indexBPlus1]); if (reactantBond != null && productBond != null) { AddEdges(reactantBond, productBond, a, b); } } } } cEdgesSize = cEdges.Count; dEdgesSize = dEdges.Count; return(0); }
private void ProcessBondsBlock(int lineCount, IAtomContainer container) { for (int i = 0; i < lineCount; i++) { string line = input.ReadLine(); int atom1 = int.Parse(line.Substring(10, 3).Trim(), NumberFormatInfo.InvariantInfo) - 1; int atom2 = int.Parse(line.Substring(16, 3).Trim(), NumberFormatInfo.InvariantInfo) - 1; if (container.GetBond(container.Atoms[atom1], container.Atoms[atom2]) == null) { IBond bond = container.Builder.NewBond(container.Atoms[atom1], container.Atoms[atom2]); int order = int.Parse(line.Substring(23).Trim(), NumberFormatInfo.InvariantInfo); bond.Order = BondManipulator.CreateBondOrder((double)order); container.Bonds.Add(bond); } // else: bond already present; CTX store the bonds twice } }
/// <summary> /// Encode the provided path of atoms to a string. /// </summary> /// <param name="path">inclusive array of vertex indices</param> /// <returns>encoded path</returns> private string Encode(int[] path) { var sb = new StringBuilder(path.Length * 3); for (int i = 0, n = path.Length - 1; i <= n; i++) { var atom = container.Atoms[path[i]]; sb.Append(ToAtomPattern(atom)); // if we are not at the last index, add the connecting bond if (i < n) { var bond = container.GetBond(container.Atoms[path[i]], container.Atoms[path[i + 1]]); sb.Append(GetBondSymbol(bond)); } } return(sb.ToString()); }