/// <summary> /// Tells if a certain bond is center of a valid double bond configuration. /// </summary> /// <param name="container"> The atomcontainer. /// </param> /// <param name="bond"> The bond. /// </param> /// <returns> true=is a potential configuration, false=is not. /// </returns> public static bool isValidDoubleBondConfiguration(IAtomContainer container, IBond bond) { IAtom[] atoms = bond.getAtoms(); IAtom[] connectedAtoms = container.getConnectedAtoms(atoms[0]); IAtom from = null; for (int i = 0; i < connectedAtoms.Length; i++) { if (connectedAtoms[i] != atoms[1]) { from = connectedAtoms[i]; } } bool[] array = new bool[container.Bonds.Length]; for (int i = 0; i < array.Length; i++) { array[i] = true; } if (isStartOfDoubleBond(container, atoms[0], from, array) && isEndOfDoubleBond(container, atoms[1], atoms[0], array) && !bond.getFlag(CDKConstants.ISAROMATIC)) { return (true); } else { return (false); } }
public CouponHistory(IBond instrument, DateTime startAccrualDate, DateTime endAccrualDate) : base(instrument) { if (Util.IsNullDate(startAccrualDate) || Util.IsNullDate(endAccrualDate) || startAccrualDate >= endAccrualDate) throw new ApplicationException("The accrual dates are not correct."); this.StartAccrualDate = startAccrualDate; this.EndAccrualDate = endAccrualDate; this.Description = string.Format("Coupon {0}: {1} - {2}", instrument.DisplayIsinWithName, startAccrualDate.ToString("dd-MM-yyyy"), endAccrualDate.ToString("dd-MM-yyyy")); }
public void TestBond() { var mol = new AtomContainer(); Atom atom = new Atom("C"); Atom atom2 = new Atom("O"); mol.Atoms.Add(atom); mol.Atoms.Add(atom2); Bond bond = new Bond(atom, atom2, BondOrder.Single); mol.Bonds.Add(bond); IAtomContainer roundTrippedMol = CMLRoundTripTool.RoundTripMolecule(convertor, mol); Assert.AreEqual(2, roundTrippedMol.Atoms.Count); Assert.AreEqual(1, roundTrippedMol.Bonds.Count); IBond roundTrippedBond = roundTrippedMol.Bonds[0]; Assert.AreEqual(2, roundTrippedBond.Atoms.Count); Assert.AreEqual("C", roundTrippedBond.Begin.Symbol); // preserved direction? Assert.AreEqual("O", roundTrippedBond.End.Symbol); Assert.AreEqual(bond.Order, roundTrippedBond.Order); }
/// <inheritdoc/> /// <param name="targetConatiner">target container</param> /// <param name="targetBond">target bond</param> /// <returns>true if bonds match</returns> public bool Matches(TargetProperties targetConatiner, IBond targetBond) { if (this.smartQueryBond != null) { return(smartQueryBond.Matches(targetBond)); } else { if (!IsBondMatchFlag) { return(true); } if (IsBondMatchFlag && IsBondTypeMatch(targetBond)) { return(true); } if (IsBondMatchFlag && this.unsaturation == GetUnsaturation(targetConatiner, targetBond)) { return(true); } } return(false); }
internal static bool IsMatchFeasible(IAtomContainer ac1, IBond bondA1, IAtomContainer ac2, IBond bondA2, bool shouldMatchBonds) { if (ac1 is IQueryAtomContainer) { if (((IQueryBond)bondA1).Matches(bondA2)) { IQueryAtom atom1 = (IQueryAtom)(bondA1.Begin); IQueryAtom atom2 = (IQueryAtom)(bondA1.End); // ok, bonds match if (atom1.Matches(bondA2.Begin) && atom2.Matches(bondA2.End) || atom1.Matches(bondA2.End) && atom2.Matches(bondA2.Begin)) { // ok, atoms match in either order return(true); } return(false); } return(false); } else { //Bond Matcher var bondMatcher = new Matchers.DefaultBondMatcher(ac1, bondA1, shouldMatchBonds); //Atom Matcher var atomMatcher1 = new Matchers.DefaultMCSPlusAtomMatcher(ac1, bondA1.Begin, shouldMatchBonds); //Atom Matcher var atomMatcher2 = new Matchers.DefaultMCSPlusAtomMatcher(ac1, bondA1.End, shouldMatchBonds); if (Matchers.DefaultMatcher.IsBondMatch(bondMatcher, ac2, bondA2, shouldMatchBonds) && Matchers.DefaultMatcher.IsAtomMatch(atomMatcher1, atomMatcher2, ac2, bondA2, shouldMatchBonds)) { return(true); } return(false); } }
public static IAtomContainer CreateAcetone() { IAtomContainer result = builder.NewAtomContainer(); IAtom c1 = builder.NewAtom("C"); c1.Id = "1"; IAtom c2 = builder.NewAtom("C"); c2.Id = "2"; IAtom c3 = builder.NewAtom("C"); c3.Id = "3"; IAtom c4 = builder.NewAtom("O"); c4.Id = "4"; result.Atoms.Add(c1); result.Atoms.Add(c2); result.Atoms.Add(c3); result.Atoms.Add(c4); IBond bond1 = builder.NewBond(c1, c2, BondOrder.Single); IBond bond2 = builder.NewBond(c2, c3, BondOrder.Single); IBond bond3 = builder.NewBond(c3, c4, BondOrder.Double); result.Bonds.Add(bond1); result.Bonds.Add(bond2); result.Bonds.Add(bond3); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(result); var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(result); Aromaticity.CDKLegacy.Apply(result); return(result); }
public void ObtainNonPerfectCardinalBonds() { IAtom focus = Atom("C", 0, -0.40d, 3.37d); IAtom north = Atom("C", 0, -0.43d, 4.18d); IAtom east = Atom("O", 1, 0.44d, 3.33d); IAtom south = Atom("C", 2, -0.42d, 2.65d); IAtom west = Atom("H", 0, -1.21d, 3.36d); IBond[] expected = new IBond[] { new Bond(focus, north), new Bond(focus, east), new Bond(focus, south), new Bond(focus, west) }; IBond[] actual = FischerRecognition.CardinalBonds(focus, new IBond[] { expected[1], expected[2], expected[3], expected[0] } ); Assert.IsTrue(Compares.AreDeepEqual(actual, expected)); }
public void ObtainCardinalBonds() { IAtom focus = Atom("C", 0, 0.80d, 0.42d); IAtom north = Atom("C", 0, 0.80d, 1.24d); IAtom east = Atom("O", 1, 1.63d, 0.42d); IAtom south = Atom("C", 2, 0.80d, -0.41d); IAtom west = Atom("H", 0, -0.02d, 0.42d); IBond[] expected = new IBond[] { new Bond(focus, north), new Bond(focus, east), new Bond(focus, south), new Bond(focus, west) }; IBond[] actual = FischerRecognition.CardinalBonds(focus, new IBond[] { expected[1], expected[2], expected[3], expected[0] } ); Assert.IsTrue(Compares.AreDeepEqual(actual, expected)); }
/// <inheritdoc/> public override string GetEdgeLabel(int vertexIndex, int otherVertexIndex) { IAtom atomA = this.molecule.Atoms[vertexIndex]; IAtom atomB = this.molecule.Atoms[otherVertexIndex]; IBond bond = this.molecule.GetBond(atomA, atomB); if (bond != null) { if (bond.IsAromatic) { return("p"); } switch (bond.Order) { // case Single: return "-"; case BondOrder.Single: return(""); case BondOrder.Double: return("="); case BondOrder.Triple: return("#"); case BondOrder.Quadruple: return("$"); default: return(""); } } else { return(""); } }
public void TestS4oxide() { IAtomContainer mol = builder.NewAtomContainer(); IAtom s = builder.NewAtom("S"); IAtom o1 = builder.NewAtom("O"); IAtom o2 = builder.NewAtom("O"); IAtom o3 = builder.NewAtom("O"); IBond b1 = builder.NewBond(s, o1, BondOrder.Double); IBond b2 = builder.NewBond(s, o2, BondOrder.Double); IBond b3 = builder.NewBond(s, o3, BondOrder.Double); mol.Atoms.Add(s); mol.Atoms.Add(o1); mol.Atoms.Add(o2); mol.Atoms.Add(o3); mol.Bonds.Add(b1); mol.Bonds.Add(b2); mol.Bonds.Add(b3); StructGenMatcher matcher = new StructGenMatcher(); IAtomType matched; matched = matcher.FindMatchingAtomType(mol, mol.Atoms[0]); AssertAtomType(testedAtomTypes, "S4", matched); matched = matcher.FindMatchingAtomType(mol, mol.Atoms[1]); AssertAtomType(testedAtomTypes, "O2", matched); matched = matcher.FindMatchingAtomType(mol, mol.Atoms[2]); AssertAtomType(testedAtomTypes, "O2", matched); matched = matcher.FindMatchingAtomType(mol, mol.Atoms[3]); AssertAtomType(testedAtomTypes, "O2", matched); }
public void TestOxygen2() { IAtomContainer mol = builder.NewAtomContainer(); IAtom o1 = builder.NewAtom("O"); IAtom o2 = builder.NewAtom("O"); IAtom h1 = builder.NewAtom("H"); IAtom h2 = builder.NewAtom("H"); IBond bond1 = builder.NewBond(h1, o1, BondOrder.Single); IBond bond2 = builder.NewBond(o1, o2, BondOrder.Single); IBond bond3 = builder.NewBond(o2, h2, BondOrder.Single); mol.Atoms.Add(o1); mol.Atoms.Add(o2); mol.Atoms.Add(h1); mol.Atoms.Add(h2); mol.Bonds.Add(bond1); mol.Bonds.Add(bond2); mol.Bonds.Add(bond3); StructGenMatcher matcher = new StructGenMatcher(); IAtomType matched; matched = matcher.FindMatchingAtomType(mol, mol.Atoms[0]); AssertAtomType(testedAtomTypes, "O2", matched); matched = matcher.FindMatchingAtomType(mol, mol.Atoms[1]); AssertAtomType(testedAtomTypes, "O2", matched); matched = matcher.FindMatchingAtomType(mol, mol.Atoms[2]); AssertAtomType(testedAtomTypes, "H1", matched); matched = matcher.FindMatchingAtomType(mol, mol.Atoms[3]); AssertAtomType(testedAtomTypes, "H1", matched); }
public void CreateCenterWithThreeNeighbors_right() { IAtom focus = Atom("C", 0, 0.80d, 0.42d); IAtom north = Atom("C", 0, 0.80d, 1.24d); IAtom east = Atom("O", 1, 1.63d, 0.42d); IAtom south = Atom("C", 2, 0.80d, -0.41d); IBond[] bonds = new IBond[] { new Bond(focus, south), new Bond(focus, north), new Bond(focus, east) }; ITetrahedralChirality element = FischerRecognition.NewTetrahedralCenter(focus, bonds); Assert.AreSame(focus, element.ChiralAtom); Assert.AreEqual(TetrahedralStereo.AntiClockwise, element.Stereo); Assert.AreSame(north, element.Ligands[0]); Assert.AreSame(east, element.Ligands[1]); Assert.AreSame(south, element.Ligands[2]); Assert.AreSame(focus, element.Ligands[3]); }
private static bool IsInRingSize(IAtom atom, IBond prev, IAtom beg, int size, int req) { atom.IsVisited = true; foreach (var bond in atom.Bonds) { if (bond == prev) { continue; } var nbr = bond.GetOther(atom); if (nbr.Equals(beg)) { return(size == req); } else if (size < req && !nbr.IsVisited && IsInRingSize(nbr, bond, beg, size + 1, req)) { return(true); } } atom.IsVisited = false; return(false); }
/// <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); }
public static IAtomContainer CreateIsobutane() { IAtomContainer result = builder.NewAtomContainer(); IAtom c1 = builder.NewAtom("C"); IAtom c2 = builder.NewAtom("C"); IAtom c3 = builder.NewAtom("C"); IAtom c4 = builder.NewAtom("C"); result.Atoms.Add(c1); result.Atoms.Add(c2); result.Atoms.Add(c3); result.Atoms.Add(c4); IBond bond1 = builder.NewBond(c1, c2, BondOrder.Single); IBond bond2 = builder.NewBond(c2, c3, BondOrder.Single); IBond bond3 = builder.NewBond(c2, c4, BondOrder.Single); result.Bonds.Add(bond1); result.Bonds.Add(bond2); result.Bonds.Add(bond3); return(result); }
public void GetAromaticEdgeLabelTest() { IAtomContainer benzeneRing = builder.NewAtomContainer(); for (int i = 0; i < 6; i++) { benzeneRing.Atoms.Add(builder.NewAtom("C")); } for (int i = 0; i < 6; i++) { IAtom a = benzeneRing.Atoms[i]; IAtom b = benzeneRing.Atoms[(i + 1) % 6]; IBond bond = builder.NewBond(a, b); benzeneRing.Bonds.Add(bond); bond.IsAromatic = true; } AtomSignature signature = new AtomSignature(0, benzeneRing); for (int i = 0; i < 6; i++) { Assert.AreEqual("p", signature.GetEdgeLabel(i, (i + 1) % 6), "Failed for " + i); } }
public virtual void TestGetNextBond_IBond_IAtom() { IRing ring = (IRing)NewChemObject(); IAtom c1 = ring.Builder.NewAtom("C"); IAtom c2 = ring.Builder.NewAtom("C"); IAtom c3 = ring.Builder.NewAtom("C"); IBond b1 = ring.Builder.NewBond(c1, c2, BondOrder.Single); IBond b2 = ring.Builder.NewBond(c3, c2, BondOrder.Single); IBond b3 = ring.Builder.NewBond(c1, c3, BondOrder.Single); ring.Atoms.Add(c1); ring.Atoms.Add(c2); ring.Atoms.Add(c3); ring.Bonds.Add(b1); ring.Bonds.Add(b2); ring.Bonds.Add(b3); Assert.AreEqual(b1, ring.GetNextBond(b2, c2)); Assert.AreEqual(b1, ring.GetNextBond(b3, c1)); Assert.AreEqual(b2, ring.GetNextBond(b1, c2)); Assert.AreEqual(b2, ring.GetNextBond(b3, c3)); Assert.AreEqual(b3, ring.GetNextBond(b1, c1)); Assert.AreEqual(b3, ring.GetNextBond(b2, c3)); }
private bool IsBondMatch(IAtomContainer reactant, IAtomContainer product) { int counter = 0; var ketSet = firstAtomMCS.Keys.ToArray(); for (int i = 0; i < ketSet.Length; i++) { for (int j = i + 1; j < ketSet.Length; j++) { IAtom indexI = (IAtom)ketSet[i]; IAtom indexJ = (IAtom)ketSet[j]; IBond rBond = reactant.GetBond(indexI, indexJ); if (rBond != null) { counter++; } } } var valueSet = firstAtomMCS.Values.ToArray(); for (int i = 0; i < valueSet.Length; i++) { for (int j = i + 1; j < valueSet.Length; j++) { IAtom indexI = (IAtom)valueSet[i]; IAtom indexJ = (IAtom)valueSet[j]; IBond pBond = product.GetBond(indexI, indexJ); if (pBond != null) { counter--; } } } return(counter == 0 ? true : false); }
/// <summary> /// Convert a CDK <see cref="IBond"/> to the Beam edge label type. /// </summary> /// <param name="b">cdk bond</param> /// <returns>the edge label for the Beam edge</returns> /// <exception cref="NullReferenceException">the bond order was null and the bond was not-aromatic</exception> /// <exception cref="ArgumentException">the bond order could not be converted</exception> private static Bond ToBeamEdgeLabel(IBond b, SmiFlavors flavour) { if (SmiFlavorTool.IsSet(flavour, SmiFlavors.UseAromaticSymbols) && b.IsAromatic) { if (!b.Begin.IsAromatic || !b.End.IsAromatic) { throw new InvalidOperationException("Aromatic bond connects non-aromatic atomic atoms"); } return(Bond.Aromatic); } if (b.Order.IsUnset()) { throw new CDKException("A bond had undefined order, possible query bond?"); } var order = b.Order; switch (order) { case BondOrder.Single: return(Bond.Single); case BondOrder.Double: return(Bond.Double); case BondOrder.Triple: return(Bond.Triple); case BondOrder.Quadruple: return(Bond.Quadruple); default: throw new CDKException("Unsupported bond order: " + order); } }
/// <summary> /// Creates a molecule graph for use with jgrapht. /// Bond orders are not respected. /// </summary> /// <param name="molecule">the specified molecule</param> /// <returns>a graph representing the molecule</returns> static public SimpleGraph getMoleculeGraph(IAtomContainer molecule) { SimpleGraph graph = new SimpleGraph(); for (int i = 0; i < molecule.AtomCount; i++) { IAtom atom = molecule.Atoms[i]; graph.addVertex(atom); } for (int i = 0; i < molecule.getBondCount(); i++) { IBond bond = molecule.Bonds[i]; /* * int order = (int) bond.getOrder(); * for (int j=0; j<order; j++) { * graph.addEdge(bond.getAtoms()[0], bond.getAtoms()[1]); * } */ graph.addEdge(bond.getAtoms()[0], bond.getAtoms()[1]); } return(graph); }
/// <summary> Returns the geometric length of this bond in 2D space. /// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets /// /// </summary> /// <param name="bond"> Description of the Parameter /// </param> /// <returns> The geometric length of this bond /// </returns> public static double getLength2D(IBond bond) { if (bond.getAtomAt(0) == null || bond.getAtomAt(1) == null) { return 0.0; } Point2d p1 = bond.getAtomAt(0).getPoint2d(); Point2d p2 = bond.getAtomAt(1).getPoint2d(); if (p1 == null || p2 == null) { return 0.0; } return p1.distance(p2); }
/// <summary> Writes the coordinates of the atoms participating the given bond into an /// array. /// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets /// /// </summary> /// <param name="bond"> The given bond /// </param> /// <returns> The array with the coordinates /// </returns> public static int[] getBondCoordinates(IBond bond) { if (bond.getAtomAt(0).getPoint2d() == null || bond.getAtomAt(1).getPoint2d() == null) { //logger.error("getBondCoordinates() called on Bond without 2D coordinates!"); return new int[0]; } int beginX = (int)bond.getAtomAt(0).getPoint2d().x; int endX = (int)bond.getAtomAt(1).getPoint2d().x; int beginY = (int)bond.getAtomAt(0).getPoint2d().y; int endY = (int)bond.getAtomAt(1).getPoint2d().y; int[] coords = new int[] { beginX, beginY, endX, endY }; return coords; }
public bool Contains(IBond bond) => false;
public static CIPChirality GetCIPChirality(IAtomContainer container, IDoubleBondStereochemistry stereoCenter) { IBond stereoBond = stereoCenter.StereoBond; IBond leftBond = stereoCenter.Bonds[0]; IBond rightBond = stereoCenter.Bonds[1]; // the following variables are usd to label the atoms - makes things // a little more concise // // x y x // \ / \ // u = v or u = v // \ // y // var u = stereoBond.Begin; var v = stereoBond.End; var x = leftBond.GetOther(u); var y = rightBond.GetOther(v); var conformation = stereoCenter.Stereo; var leftLigands = GetLigands(u, container, v).ToList(); var rightLigands = GetLigands(v, container, u).ToList(); if (leftLigands.Count > 2 || rightLigands.Count > 2) { return(CIPChirality.None); } // invert if x/y aren't in the first position if (leftLigands[0].LigandAtom != x) { conformation = conformation.Invert(); } if (rightLigands[0].LigandAtom != y) { conformation = conformation.Invert(); } int p = PermParity(leftLigands) * PermParity(rightLigands); if (p == 0) { return(CIPChirality.None); } else if (p < 0) { conformation = conformation.Invert(); } switch (conformation) { case DoubleBondConformation.Together: return(CIPChirality.Z); case DoubleBondConformation.Opposite: return(CIPChirality.E); default: return(CIPChirality.None); } }
/// <summary> Saturate atom by adjusting its bond orders.</summary> public virtual bool newSaturate(IBond bond, IAtomContainer atomContainer) { IAtom[] atoms = bond.getAtoms(); IAtom atom = atoms[0]; IAtom partner = atoms[1]; //logger.debug(" saturating bond: ", atom.Symbol, "-", partner.Symbol); IAtomType[] atomTypes1 = getAtomTypeFactory(bond.Builder).getAtomTypes(atom.Symbol); IAtomType[] atomTypes2 = getAtomTypeFactory(bond.Builder).getAtomTypes(partner.Symbol); bool bondOrderIncreased = true; while (bondOrderIncreased && !isSaturated(bond, atomContainer)) { //logger.debug("Can increase bond order"); bondOrderIncreased = false; for (int atCounter1 = 0; atCounter1 < atomTypes1.Length && !bondOrderIncreased; atCounter1++) { IAtomType aType1 = atomTypes1[atCounter1]; //logger.debug(" condidering atom type: ", aType1); if (couldMatchAtomType(atomContainer, atom, aType1)) { //logger.debug(" trying atom type: ", aType1); for (int atCounter2 = 0; atCounter2 < atomTypes2.Length && !bondOrderIncreased; atCounter2++) { IAtomType aType2 = atomTypes2[atCounter2]; //logger.debug(" condidering partner type: ", aType1); if (couldMatchAtomType(atomContainer, partner, atomTypes2[atCounter2])) { //logger.debug(" with atom type: ", aType2); if (bond.Order >= aType2.MaxBondOrder || bond.Order >= aType1.MaxBondOrder) { //logger.debug("Bond order not increased: atoms has reached (or exceeded) maximum bond order for this atom type"); } else if (bond.Order < aType2.MaxBondOrder && bond.Order < aType1.MaxBondOrder) { bond.Order = bond.Order + 1; //logger.debug("Bond order now " + bond.Order); bondOrderIncreased = true; } } } } } } return isSaturated(bond, atomContainer); }
/// <summary> Resets the bond order of the Bond to 1.0.</summary> public virtual void unsaturate(IBond[] bonds) { for (int i = 1; i < bonds.Length; i++) { bonds[i].Order = 1.0; } }
/// <summary> Checks wether a bond is connected to another one. /// This can only be true if the bonds have an Atom in common. /// /// </summary> /// <param name="bond"> The bond which is checked to be connect with this one /// </param> /// <returns> True, if the bonds share an atom, otherwise false /// </returns> public virtual bool isConnectedTo(IBond bond) { for (int f = 0; f < AtomCount; f++) { if (bond.contains(getAtomAt(f))) { return true; } } return false; }
/// <summary> Returns the next bond in order, relative to a given bond and atom. /// Example: Let the ring be composed of 0-1, 1-2, 2-3 and 3-0. A request getNextBond(1-2, 2) /// will return Bond 2-3. /// /// </summary> /// <param name="bond"> A bond for which an atom from a consecutive bond is sought /// </param> /// <param name="atom"> A atom from the bond above to assign a search direction /// </param> /// <returns> The next bond in the order given by the above assignment /// </returns> public virtual IBond getNextBond(IBond bond, IAtom atom) { Bond tempBond; for (int f = 0; f < ElectronContainerCount; f++) { IElectronContainer electronContainer = getElectronContainerAt(f); if (electronContainer is IBond) { tempBond = (Bond)electronContainer; if (tempBond.contains(atom) && bond != tempBond) { return tempBond; } } } return null; }
/// <summary> Calculate the number of missing hydrogens by substracting the number of /// bonds for the atom from the expected number of bonds. Charges are included /// in the calculation. The number of expected bonds is defined by the AtomType /// generated with the AtomTypeFactory. /// /// </summary> /// <param name="atom"> Description of the Parameter /// </param> /// <param name="throwExceptionForUnknowAtom"> Should an exception be thrown if an unknown atomtype is found or 0 returned ? /// </param> /// <returns> Description of the Return Value /// </returns> /// <seealso cref="AtomTypeFactory"> /// </seealso> public virtual int calculateNumberOfImplicitHydrogens(IAtom atom, double bondOrderSum, IBond[] connectedBonds, bool throwExceptionForUnknowAtom) { int missingHydrogen = 0; if (atom is IPseudoAtom) { // don't figure it out... it simply does not lack H's } else if (atom.AtomicNumber == 1 || atom.Symbol.Equals("H")) { //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" missingHydrogen = (int) (1 - bondOrderSum - atom.getFormalCharge()); } else { //logger.info("Calculating number of missing hydrogen atoms"); // get default atom IAtomType[] atomTypes = getAtomTypeFactory(atom.Builder).getAtomTypes(atom.Symbol); if (atomTypes.Length == 0 && throwExceptionForUnknowAtom) return 0; //logger.debug("Found atomtypes: " + atomTypes.Length); if (atomTypes.Length > 0) { IAtomType defaultAtom = atomTypes[0]; //logger.debug("DefAtom: ", defaultAtom); //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" missingHydrogen = (int) (defaultAtom.BondOrderSum - bondOrderSum + atom.getFormalCharge()); if (atom.getFlag(CDKConstants.ISAROMATIC)) { bool subtractOne = true; for (int i = 0; i < connectedBonds.Length; i++) { if (connectedBonds[i].Order == 2 || connectedBonds[i].Order == CDKConstants.BONDORDER_AROMATIC) subtractOne = false; } if (subtractOne) missingHydrogen--; } //logger.debug("Atom: ", atom.Symbol); //logger.debug(" max bond order: " + defaultAtom.BondOrderSum); //logger.debug(" bond order sum: " + bondOrderSum); //logger.debug(" charge : " + atom.getFormalCharge()); } else { //logger.warn("Could not find atom type for ", atom.Symbol); } } return missingHydrogen; }
public virtual int calculateNumberOfImplicitHydrogens(IAtom atom) { IBond[] bonds = new IBond[0]; return this.calculateNumberOfImplicitHydrogens(atom, 0, bonds, false); }
private static Expr GetBondExpr(IBond bond) { return(((QueryBond)BondRef.Deref(bond)).Expression); }
/// <summary> Saturates a set of Bonds in an AtomContainer.</summary> public virtual bool saturate(IBond[] bonds, IAtomContainer atomContainer) { //logger.debug("Saturating bond set of size: ", bonds.Length); bool bondsAreFullySaturated = false; if (bonds.Length > 0) { IBond bond = bonds[0]; // determine bonds left int leftBondCount = bonds.Length - 1; IBond[] leftBonds = new IBond[leftBondCount]; Array.Copy(bonds, 1, leftBonds, 0, leftBondCount); // examine this bond //logger.debug("Examining this bond: ", bond); if (isSaturated(bond, atomContainer)) { //logger.debug("OK, bond is saturated, now try to saturate remaining bonds (if needed)"); bondsAreFullySaturated = saturate(leftBonds, atomContainer); } else if (isUnsaturated(bond, atomContainer)) { //logger.debug("Ok, this bond is unsaturated, and can be saturated"); // two options now: // 1. saturate this one directly // 2. saturate this one by saturating the rest //logger.debug("Option 1: Saturating this bond directly, then trying to saturate rest"); // considering organic bonds, the max order is 3, so increase twice double increment = 1.0; bool bondOrderIncreased = saturateByIncreasingBondOrder(bond, atomContainer, increment); bondsAreFullySaturated = bondOrderIncreased && saturate(bonds, atomContainer); if (bondsAreFullySaturated) { //logger.debug("Option 1: worked"); } else { //logger.debug("Option 1: failed. Trying option 2."); //logger.debug("Option 2: Saturing this bond by saturating the rest"); // revert the increase (if succeeded), then saturate the rest if (bondOrderIncreased) unsaturateByDecreasingBondOrder(bond, increment); bondsAreFullySaturated = saturate(leftBonds, atomContainer) && isSaturated(bond, atomContainer); //if (!bondsAreFullySaturated) //logger.debug("Option 2: failed"); } } else { //logger.debug("Ok, this bond is unsaturated, but cannot be saturated"); // try recursing and see if that fixes things bondsAreFullySaturated = saturate(leftBonds, atomContainer) && isSaturated(bond, atomContainer); } } else { bondsAreFullySaturated = true; // empty is saturated by default } return bondsAreFullySaturated; }
/// <summary> /// Initiates the process for the given mechanism. The atoms and bonds to apply are mapped between /// reactants and products. /// </summary> /// <param name="atomContainerSet"></param> /// <param name="atomList">The list of atoms taking part in the mechanism. Only allowed three atoms</param> /// <param name="bondList">The list of bonds taking part in the mechanism. Only allowed one bond</param> /// <returns>The Reaction mechanism</returns> public IReaction Initiate(IChemObjectSet <IAtomContainer> atomContainerSet, IList <IAtom> atomList, IList <IBond> bondList) { var atMatcher = CDK.AtomTypeMatcher; if (atomContainerSet.Count != 2) { throw new CDKException("AdductionPBMechanism expects two IAtomContainer's"); } if (atomList.Count != 3) { throw new CDKException("AdductionPBMechanism expects two atoms in the List"); } if (bondList.Count != 1) { throw new CDKException("AdductionPBMechanism don't expect bonds in the List"); } IAtomContainer molecule1 = atomContainerSet[0]; IAtomContainer molecule2 = atomContainerSet[1]; IAtomContainer reactantCloned; reactantCloned = (IAtomContainer)atomContainerSet[0].Clone(); reactantCloned.Add((IAtomContainer)atomContainerSet[1].Clone()); IAtom atom1 = atomList[0]; // Atom 1: to be deficient in charge IAtom atom1C = reactantCloned.Atoms[molecule1.Atoms.IndexOf(atom1)]; IAtom atom2 = atomList[1]; // Atom 2: receive the adduct IAtom atom2C = reactantCloned.Atoms[molecule1.Atoms.IndexOf(atom2)]; IAtom atom3 = atomList[2]; // Atom 2: deficient in charge IAtom atom3C = reactantCloned.Atoms[molecule1.Atoms.Count + molecule2.Atoms.IndexOf(atom3)]; IBond bond1 = bondList[0]; int posBond1 = atomContainerSet[0].Bonds.IndexOf(bond1); BondManipulator.DecreaseBondOrder(reactantCloned.Bonds[posBond1]); IBond newBond = molecule1.Builder.NewBond(atom2C, atom3C, BondOrder.Single); reactantCloned.Bonds.Add(newBond); int charge = atom1C.FormalCharge.Value; atom1C.FormalCharge = charge + 1; atom1C.Hybridization = Hybridization.Unset; AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactantCloned); IAtomType type = atMatcher.FindMatchingAtomType(reactantCloned, atom1C); if (type == null || type.AtomTypeName.Equals("X", StringComparison.Ordinal)) { return(null); } atom2C.Hybridization = Hybridization.Unset; AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactantCloned); type = atMatcher.FindMatchingAtomType(reactantCloned, atom2C); if (type == null || type.AtomTypeName.Equals("X", StringComparison.Ordinal)) { return(null); } charge = atom3C.FormalCharge.Value; atom3C.FormalCharge = charge - 1; atom3C.Hybridization = Hybridization.Unset; AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactantCloned); type = atMatcher.FindMatchingAtomType(reactantCloned, atom3C); if (type == null || type.AtomTypeName.Equals("X", StringComparison.Ordinal)) { return(null); } IReaction reaction = atom1C.Builder.NewReaction(); reaction.Reactants.Add(molecule1); /* mapping */ foreach (var atom in molecule1.Atoms) { IMapping mapping = atom1C.Builder.NewMapping(atom, reactantCloned.Atoms[molecule1.Atoms.IndexOf(atom)]); reaction.Mappings.Add(mapping); } foreach (var atom in molecule2.Atoms) { IMapping mapping = atom1C.Builder.NewMapping(atom, reactantCloned.Atoms[molecule2.Atoms.IndexOf(atom)]); reaction.Mappings.Add(mapping); } reaction.Products.Add(reactantCloned); return(reaction); }
private IRing getRing(IAtomContainer spt, IBond bond) { IRing ring = spt.Builder.newRing(); PathTools.resetFlags(spt); ring.addAtom(bond.getAtomAt(0)); PathTools.depthFirstTargetSearch(spt, bond.getAtomAt(0), bond.getAtomAt(1), ring); ring.addBond(bond); return ring; }
/// <summary> Returns wether a bond is saturated. A bond is saturated if /// <b>both</b> Atoms in the bond are saturated. /// </summary> public virtual bool isSaturated(IBond bond, IAtomContainer atomContainer) { //logger.debug("isBondSaturated?: ", bond); IAtom[] atoms = bond.getAtoms(); bool isSaturated = true; for (int i = 0; i < atoms.Length; i++) { //logger.debug("isSaturated(Bond, AC): atom I=", i); isSaturated = isSaturated && this.isSaturated(atoms[i], atomContainer); } //logger.debug("isSaturated(Bond, AC): result=", isSaturated); return isSaturated; }
/// <summary> Saturates a set of Bonds in an AtomContainer.</summary> public virtual bool newSaturate(IBond[] bonds, IAtomContainer atomContainer) { //logger.debug("Saturating bond set of size: " + bonds.Length); bool bondsAreFullySaturated = true; if (bonds.Length > 0) { IBond bond = bonds[0]; // determine bonds left int leftBondCount = bonds.Length - 1; IBond[] leftBonds = new IBond[leftBondCount]; Array.Copy(bonds, 1, leftBonds, 0, leftBondCount); // examine this bond if (isUnsaturated(bond, atomContainer)) { // either this bonds should be saturated or not // try to leave this bond unsaturated and saturate the left bondssaturate this bond if (leftBondCount > 0) { //logger.debug("Recursing with unsaturated bond with #bonds: " + leftBondCount); bondsAreFullySaturated = newSaturate(leftBonds, atomContainer) && !isUnsaturated(bond, atomContainer); } else { bondsAreFullySaturated = false; } // ok, did it work? if not, saturate this bond, and recurse if (!bondsAreFullySaturated) { //logger.debug("First try did not work..."); // ok, revert saturating this bond, and recurse again bool couldSaturate = newSaturate(bond, atomContainer); if (couldSaturate) { if (leftBondCount > 0) { //logger.debug("Recursing with saturated bond with #bonds: " + leftBondCount); bondsAreFullySaturated = newSaturate(leftBonds, atomContainer); } else { bondsAreFullySaturated = true; } } else { bondsAreFullySaturated = false; // no need to recurse, because we already know that this bond // unsaturated does not work } } } else if (isSaturated(bond, atomContainer)) { //logger.debug("This bond is already saturated."); if (leftBondCount > 0) { //logger.debug("Recursing with #bonds: " + leftBondCount); bondsAreFullySaturated = newSaturate(leftBonds, atomContainer); } else { bondsAreFullySaturated = true; } } else { //logger.debug("Cannot saturate this bond"); // but, still recurse (if possible) if (leftBondCount > 0) { //logger.debug("Recursing with saturated bond with #bonds: " + leftBondCount); bondsAreFullySaturated = newSaturate(leftBonds, atomContainer) && !isUnsaturated(bond, atomContainer); } else { bondsAreFullySaturated = !isUnsaturated(bond, atomContainer); } } } //logger.debug("Is bond set fully saturated?: " + bondsAreFullySaturated); //logger.debug("Returning to level: " + (bonds.Length + 1)); return bondsAreFullySaturated; }
public virtual void writeBond(IBond bond) { writer.Write(" Bond " + bond.ID + " = new Bond(" + bond.getAtomAt(0).ID + ", " + bond.getAtomAt(1).ID + ", " + bond.Order + ");\n"); }
/// <summary> Saturate atom by adjusting its bond orders.</summary> public virtual bool saturate(IBond bond, IAtomContainer atomContainer) { IAtom[] atoms = bond.getAtoms(); IAtom atom = atoms[0]; IAtom partner = atoms[1]; //logger.debug(" saturating bond: ", atom.Symbol, "-", partner.Symbol); bool bondOrderIncreased = true; while (bondOrderIncreased && isUnsaturated(bond, atomContainer)) { //logger.debug("Can increase bond order"); bondOrderIncreased = saturateByIncreasingBondOrder(bond, atomContainer, 1.0); } return isSaturated(bond, atomContainer); }
public static IAtomContainer getRelevantAtomContainer(ISetOfReactions set_Renamed, IBond bond) { IReaction[] reactions = set_Renamed.Reactions; for (int i = 0; i < reactions.Length; i++) { IReaction reaction = reactions[i]; IAtomContainer container = ReactionManipulator.getRelevantAtomContainer(reaction, bond); if (container != null) { // a match! return container; } } return null; }
public bool Matches(IBond bond, int stereo) { switch (type) { case ExprType.True: return(true); case ExprType.False: return(false); case ExprType.AliphaticOrder: return(!bond.IsAromatic && !bond.Order.IsUnset() && bond.Order.Numeric() == value); case ExprType.Order: return(!bond.Order.IsUnset() && bond.Order.Numeric() == value); case ExprType.IsAromatic: return(bond.IsAromatic); case ExprType.IsAliphatic: return(!bond.IsAromatic); case ExprType.IsInRing: return(bond.IsInRing); case ExprType.IsInChain: return(!bond.IsInRing); case ExprType.SingleOrAromatic: return(bond.IsAromatic || BondOrder.Single.Equals(bond.Order)); case ExprType.DoubleOrAromatic: return(bond.IsAromatic || BondOrder.Double.Equals(bond.Order)); case ExprType.SingleOrDouble: return(BondOrder.Single.Equals(bond.Order) || BondOrder.Double.Equals(bond.Order)); case ExprType.Stereochemistry: return(stereo == UnknownStereo || value == stereo); case ExprType.And: return(left.Matches(bond, stereo) && right.Matches(bond, stereo)); case ExprType.Or: return(left.Matches(bond, stereo) || right.Matches(bond, stereo)); case ExprType.Not: return(!left.Matches(bond, stereo) // XXX: ugly but needed, when matching stereo || (stereo == UnknownStereo && (left.type == ExprType.Stereochemistry || left.type == ExprType.Or && left.left.type == ExprType.Stereochemistry))); default: throw new ArgumentException($"Cannot match BondExpr, type={type}", nameof(type)); } }
public static IAtomContainer getRelevantAtomContainer(IReaction reaction, IBond bond) { IAtomContainer result = SetOfMoleculesManipulator.getRelevantAtomContainer(reaction.Reactants, bond); if (result != null) { return result; } return SetOfMoleculesManipulator.getRelevantAtomContainer(reaction.Products, bond); }
/// <summary> /// Reads atoms, bonds etc from atom container and converts to format /// InChI library requires, then places call for the library to generate /// the InChI. /// </summary> /// <param name="atomContainer">AtomContainer to generate InChI for.</param> /// <param name="ignore"></param> private void GenerateInChIFromCDKAtomContainer(IAtomContainer atomContainer, bool ignore) { this.ReferringAtomContainer = atomContainer; // Check for 3d coordinates bool all3d = true; bool all2d = true; foreach (var atom in atomContainer.Atoms) { if (all3d && atom.Point3D == null) { all3d = false; } if (all2d && atom.Point2D == null) { all2d = false; } } var atomMap = new Dictionary <IAtom, NInchiAtom>(); foreach (var atom in atomContainer.Atoms) { // Get coordinates // Use 3d if possible, otherwise 2d or none double x, y, z; if (all3d) { var p = atom.Point3D.Value; x = p.X; y = p.Y; z = p.Z; } else if (all2d) { var p = atom.Point2D.Value; x = p.X; y = p.Y; z = 0.0; } else { x = 0.0; y = 0.0; z = 0.0; } // Chemical element symbol var el = atom.Symbol; // Generate InChI atom var iatom = Input.Add(new NInchiAtom(x, y, z, el)); atomMap[atom] = iatom; // Check if charged var charge = atom.FormalCharge.Value; if (charge != 0) { iatom.Charge = charge; } // Check whether isotopic var isotopeNumber = atom.MassNumber; if (isotopeNumber != null) { iatom.IsotopicMass = isotopeNumber.Value; } // Check for implicit hydrogens // atom.HydrogenCount returns number of implicit hydrogens, not // total number // Ref: Posting to cdk-devel list by Egon Willighagen 2005-09-17 int?implicitH = atom.ImplicitHydrogenCount; // set implicit hydrogen count, -1 tells the inchi to determine it iatom.ImplicitH = implicitH ?? -1; // Check if radical int count = atomContainer.GetConnectedSingleElectrons(atom).Count(); if (count == 0) { // TODO - how to check whether singlet or undefined multiplicity } else if (count == 1) { iatom.Radical = INCHI_RADICAL.Doublet; } else if (count == 2) { iatom.Radical = INCHI_RADICAL.Triplet; } else { throw new CDKException("Unrecognised radical type"); } } // Process bonds var bondMap = new Dictionary <IBond, NInchiBond>(); foreach (var bond in atomContainer.Bonds) { // Assumes 2 centre bond var at0 = atomMap[bond.Begin]; var at1 = atomMap[bond.End]; // Get bond order INCHI_BOND_TYPE order; var bo = bond.Order; if (!ignore && bond.IsAromatic) { order = INCHI_BOND_TYPE.Altern; } else if (bo == BondOrder.Single) { order = INCHI_BOND_TYPE.Single; } else if (bo == BondOrder.Double) { order = INCHI_BOND_TYPE.Double; } else if (bo == BondOrder.Triple) { order = INCHI_BOND_TYPE.Triple; } else { throw new CDKException("Failed to generate InChI: Unsupported bond type"); } // Create InChI bond var ibond = new NInchiBond(at0, at1, order); bondMap[bond] = ibond; Input.Add(ibond); // Check for bond stereo definitions var stereo = bond.Stereo; // No stereo definition if (stereo == BondStereo.None) { ibond.BondStereo = INCHI_BOND_STEREO.None; } // Bond ending (fat end of wedge) below the plane else if (stereo == BondStereo.Down) { ibond.BondStereo = INCHI_BOND_STEREO.Single1Down; } // Bond ending (fat end of wedge) above the plane else if (stereo == BondStereo.Up) { ibond.BondStereo = INCHI_BOND_STEREO.Single1Up; } // Bond starting (pointy end of wedge) below the plane else if (stereo == BondStereo.DownInverted) { ibond.BondStereo = INCHI_BOND_STEREO.Single2Down; } // Bond starting (pointy end of wedge) above the plane else if (stereo == BondStereo.UpInverted) { ibond.BondStereo = INCHI_BOND_STEREO.Single2Up; } else if (stereo == BondStereo.EOrZ) { ibond.BondStereo = INCHI_BOND_STEREO.DoubleEither; } else if (stereo == BondStereo.UpOrDown) { ibond.BondStereo = INCHI_BOND_STEREO.Single1Either; } else if (stereo == BondStereo.UpOrDownInverted) { ibond.BondStereo = INCHI_BOND_STEREO.Single2Either; } // Bond with undefined stereochemistry else if (stereo == BondStereo.None) { if (order == INCHI_BOND_TYPE.Single) { ibond.BondStereo = INCHI_BOND_STEREO.Single1Either; } else if (order == INCHI_BOND_TYPE.Double) { ibond.BondStereo = INCHI_BOND_STEREO.DoubleEither; } } } // Process tetrahedral stereo elements foreach (var stereoElem in atomContainer.StereoElements) { if (stereoElem is ITetrahedralChirality chirality) { var stereoType = chirality.Stereo; var atC = atomMap[chirality.ChiralAtom]; var at0 = atomMap[chirality.Ligands[0]]; var at1 = atomMap[chirality.Ligands[1]]; var at2 = atomMap[chirality.Ligands[2]]; var at3 = atomMap[chirality.Ligands[3]]; var p = INCHI_PARITY.Unknown; if (stereoType == TetrahedralStereo.AntiClockwise) { p = INCHI_PARITY.Odd; } else if (stereoType == TetrahedralStereo.Clockwise) { p = INCHI_PARITY.Even; } else { throw new CDKException("Unknown tetrahedral chirality"); } var jniStereo = new NInchiStereo0D(atC, at0, at1, at2, at3, INCHI_STEREOTYPE.Tetrahedral, p); Input.Stereos.Add(jniStereo); } else if (stereoElem is IDoubleBondStereochemistry dbStereo) { var surroundingBonds = dbStereo.Bonds; if (surroundingBonds[0] == null || surroundingBonds[1] == null) { throw new CDKException("Cannot generate an InChI with incomplete double bond info"); } var stereoType = dbStereo.Stereo; IBond stereoBond = dbStereo.StereoBond; NInchiAtom at0 = null; NInchiAtom at1 = null; NInchiAtom at2 = null; NInchiAtom at3 = null; // TODO: I should check for two atom bonds... or maybe that should happen when you // create a double bond stereochemistry if (stereoBond.Contains(surroundingBonds[0].Begin)) { // first atom is A at1 = atomMap[surroundingBonds[0].Begin]; at0 = atomMap[surroundingBonds[0].End]; } else { // first atom is X at0 = atomMap[surroundingBonds[0].Begin]; at1 = atomMap[surroundingBonds[0].End]; } if (stereoBond.Contains(surroundingBonds[1].Begin)) { // first atom is B at2 = atomMap[surroundingBonds[1].Begin]; at3 = atomMap[surroundingBonds[1].End]; } else { // first atom is Y at2 = atomMap[surroundingBonds[1].End]; at3 = atomMap[surroundingBonds[1].Begin]; } var p = INCHI_PARITY.Unknown; if (stereoType == DoubleBondConformation.Together) { p = INCHI_PARITY.Odd; } else if (stereoType == DoubleBondConformation.Opposite) { p = INCHI_PARITY.Even; } else { throw new CDKException("Unknown double bond stereochemistry"); } var jniStereo = new NInchiStereo0D(null, at0, at1, at2, at3, INCHI_STEREOTYPE.DoubleBond, p); Input.Stereos.Add(jniStereo); } else if (stereoElem is ExtendedTetrahedral extendedTetrahedral) { TetrahedralStereo winding = extendedTetrahedral.Winding; // The peripherals (p<i>) and terminals (t<i>) are referring to // the following atoms. The focus (f) is also shown. // // p0 p2 // \ / // t0 = f = t1 // / \ // p1 p3 var terminals = extendedTetrahedral.FindTerminalAtoms(atomContainer); var peripherals = extendedTetrahedral.Peripherals.ToArray(); // InChI API is particular about the input, each terminal atom // needs to be present in the list of neighbors and they must // be at index 1 and 2 (i.e. in the middle). This is true even // of explicit atoms. For the implicit atoms, the terminals may // be in the peripherals already and so we correct the winding // and reposition as needed. var t0Bonds = OnlySingleBonded(atomContainer.GetConnectedBonds(terminals[0])); var t1Bonds = OnlySingleBonded(atomContainer.GetConnectedBonds(terminals[1])); // first if there are two explicit atoms we need to replace one // with the terminal atom - the configuration does not change if (t0Bonds.Count == 2) { var orgBond = t0Bonds[0]; t0Bonds.RemoveAt(0); var replace = orgBond.GetOther(terminals[0]); for (int i = 0; i < peripherals.Length; i++) { if (replace == peripherals[i]) { peripherals[i] = terminals[0]; } } } if (t1Bonds.Count == 2) { var orgBond = t0Bonds[0]; t1Bonds.RemoveAt(0); var replace = orgBond.GetOther(terminals[1]); for (int i = 0; i < peripherals.Length; i++) { if (replace == peripherals[i]) { peripherals[i] = terminals[1]; } } } // the neighbor attached to each terminal atom that we will // define the configuration of var t0Neighbor = t0Bonds[0].GetOther(terminals[0]); var t1Neighbor = t1Bonds[0].GetOther(terminals[1]); // we now need to move all the atoms into the correct positions // everytime we exchange atoms the configuration inverts for (int i = 0; i < peripherals.Length; i++) { if (i != 0 && t0Neighbor == peripherals[i]) { Swap(peripherals, i, 0); winding = winding.Invert(); } else if (i != 1 && terminals[0] == peripherals[i]) { Swap(peripherals, i, 1); winding = winding.Invert(); } else if (i != 2 && terminals[1] == peripherals[i]) { Swap(peripherals, i, 2); winding = winding.Invert(); } else if (i != 3 && t1Neighbor == peripherals[i]) { Swap(peripherals, i, 3); winding = winding.Invert(); } } var parity = INCHI_PARITY.Unknown; if (winding == TetrahedralStereo.AntiClockwise) { parity = INCHI_PARITY.Odd; } else if (winding == TetrahedralStereo.Clockwise) { parity = INCHI_PARITY.Even; } else { throw new CDKException("Unknown extended tetrahedral chirality"); } NInchiStereo0D jniStereo = new NInchiStereo0D(atomMap[extendedTetrahedral.Focus], atomMap[peripherals[0]], atomMap[peripherals[1]], atomMap[peripherals[2]], atomMap[peripherals[3]], INCHI_STEREOTYPE.Allene, parity); Input.Stereos.Add(jniStereo); } } try { Output = NInchiWrapper.GetInchi(Input); } catch (NInchiException jie) { throw new CDKException("Failed to generate InChI: " + jie.Message, jie); } }
public override bool Matches(IBond bond) { return(bond.IsInRing); }
/// <summary> Writes the coordinates of the atoms participating the given bond into an /// array, using renderingCoordinates, using an external set of coordinates. /// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets /// /// </summary> /// <param name="bond"> The given bond /// </param> /// <param name="renderingCoordinates"> The set of coordinates to use coming from RendererModel2D /// </param> /// <returns> The array with the coordinates /// </returns> //UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMap'" public static int[] getBondCoordinates(IBond bond, System.Collections.Hashtable renderingCoordinates) { //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'" if (renderingCoordinates[bond.getAtomAt(0)] == null && bond.getAtomAt(0).getPoint2d() != null) { renderingCoordinates[bond.getAtomAt(0)] = new Point2d(bond.getAtomAt(0).getPoint2d().x, bond.getAtomAt(0).getPoint2d().y); } //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'" if (renderingCoordinates[bond.getAtomAt(1)] == null && bond.getAtomAt(1).getPoint2d() != null) { renderingCoordinates[bond.getAtomAt(1)] = new Point2d(bond.getAtomAt(1).getPoint2d().x, bond.getAtomAt(1).getPoint2d().y); } if (bond.getAtomAt(0).getPoint2d() == null || bond.getAtomAt(1).getPoint2d() == null) { //logger.error("getBondCoordinates() called on Bond without 2D coordinates!"); return new int[0]; } //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'" int beginX = (int)((Point2d)renderingCoordinates[bond.getAtomAt(0)]).x; //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'" int endX = (int)((Point2d)renderingCoordinates[bond.getAtomAt(1)]).x; //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'" int beginY = (int)((Point2d)renderingCoordinates[bond.getAtomAt(0)]).y; //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'" int endY = (int)((Point2d)renderingCoordinates[bond.getAtomAt(1)]).y; int[] coords = new int[] { beginX, beginY, endX, endY }; return coords; }
/// <summary> We define the heaviest ring as the one with the highest number of double bonds. /// Needed for example for the placement of in-ring double bonds. /// /// </summary> /// <param name="bond"> A bond which must be contained by the heaviest ring /// </param> /// <returns> The ring with the higest number of double bonds connected to a given bond /// </returns> public static IRing getHeaviestRing(IRingSet ringSet, IBond bond) { System.Collections.IList rings = ringSet.getRings(bond); IRing ring = null; int maxOrderSum = 0; for (int i = 0; i < rings.Count; i++) { if (maxOrderSum < ((IRing)rings[i]).OrderSum) { ring = (IRing)rings[i]; maxOrderSum = ring.OrderSum; } } return ring; }
/// <summary> Returns the geometric length of this bond in 2D space, using an external set of coordinates /// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets /// /// </summary> /// <param name="bond"> Description of the Parameter /// </param> /// <param name="renderingCoordinates"> The set of coordinates to use coming from RendererModel2D /// </param> /// <returns> The geometric length of this bond /// </returns> //UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMap'" public static double getLength2D(IBond bond, System.Collections.Hashtable renderingCoordinates) { if (bond.getAtomAt(0) == null || bond.getAtomAt(1) == null) { return 0.0; } //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'" Point2d p1 = ((Point2d)renderingCoordinates[bond.getAtomAt(0)]); //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'" Point2d p2 = ((Point2d)renderingCoordinates[bond.getAtomAt(1)]); if (p1 == null || p2 == null) { return 0.0; } return p1.distance(p2); }
public virtual bool unsaturateByDecreasingBondOrder(IBond bond, double decrement) { if (bond.Order > decrement) { bond.Order = bond.Order - decrement; return true; } else { return false; } }
/// <summary> Determines if this Bond contains 2D coordinates. /// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets /// /// </summary> /// <param name="b"> Description of the Parameter /// </param> /// <returns> boolean indication that 2D coordinates are available /// </returns> public static bool has2DCoordinates(IBond b) { IAtom[] atoms = b.getAtoms(); for (int i = 0; i < atoms.Length; i++) { if (atoms[i].getPoint2d() == null) { return false; } } return true; }
/// <summary> Returns wether a bond is unsaturated. A bond is unsaturated if /// <b>all</b> Atoms in the bond are unsaturated. /// </summary> public virtual bool isUnsaturated(IBond bond, IAtomContainer atomContainer) { //logger.debug("isBondUnsaturated?: ", bond); IAtom[] atoms = bond.getAtoms(); bool isUnsaturated = true; for (int i = 0; i < atoms.Length && isUnsaturated; i++) { isUnsaturated = isUnsaturated && !isSaturated(atoms[i], atomContainer); } //logger.debug("Bond is unsaturated?: ", isUnsaturated); return isUnsaturated; }
/// <summary> /// Initiates the process for the given mechanism. The atoms to apply are mapped between /// reactants and products. /// </summary> /// <param name="atomContainerSet"></param> /// <param name="atomList"> /// The list of atoms taking part in the mechanism. Only allowed two atoms. /// The first atom is the atom which contains the ISingleElectron and the second /// third is the atom which will be removed /// the first atom</param> /// <param name="bondList">The list of bonds taking part in the mechanism. Only allowed one bond. /// It is the bond which is moved</param> /// <returns>The Reaction mechanism</returns> public IReaction Initiate(IChemObjectSet <IAtomContainer> atomContainerSet, IList <IAtom> atomList, IList <IBond> bondList) { var atMatcher = CDK.AtomTypeMatcher; if (atomContainerSet.Count != 1) { throw new CDKException("RadicalSiteIonizationMechanism only expects one IAtomContainer"); } if (atomList.Count != 3) { throw new CDKException("RadicalSiteIonizationMechanism expects three atoms in the List"); } if (bondList.Count != 2) { throw new CDKException("RadicalSiteIonizationMechanism only expect one bond in the List"); } IAtomContainer molecule = atomContainerSet[0]; IAtomContainer reactantCloned; reactantCloned = (IAtomContainer)molecule.Clone(); IAtom atom1 = atomList[0]; // Atom containing the ISingleElectron IAtom atom1C = reactantCloned.Atoms[molecule.Atoms.IndexOf(atom1)]; IAtom atom2 = atomList[1]; // Atom IAtom atom2C = reactantCloned.Atoms[molecule.Atoms.IndexOf(atom2)]; IAtom atom3 = atomList[2]; // Atom to be saved IAtom atom3C = reactantCloned.Atoms[molecule.Atoms.IndexOf(atom3)]; IBond bond1 = bondList[0]; // Bond to increase the order int posBond1 = molecule.Bonds.IndexOf(bond1); IBond bond2 = bondList[1]; // Bond to remove int posBond2 = molecule.Bonds.IndexOf(bond2); BondManipulator.IncreaseBondOrder(reactantCloned.Bonds[posBond1]); reactantCloned.Bonds.Remove(reactantCloned.Bonds[posBond2]); var selectron = reactantCloned.GetConnectedSingleElectrons(atom1C); reactantCloned.SingleElectrons.Remove(selectron.Last()); atom1C.Hybridization = Hybridization.Unset; AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactantCloned); IAtomType type = atMatcher.FindMatchingAtomType(reactantCloned, atom1C); if (type == null || type.AtomTypeName.Equals("X", StringComparison.Ordinal)) { return(null); } atom2C.Hybridization = Hybridization.Unset; AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactantCloned); type = atMatcher.FindMatchingAtomType(reactantCloned, atom2C); if (type == null || type.AtomTypeName.Equals("X", StringComparison.Ordinal)) { return(null); } reactantCloned.SingleElectrons.Add(atom2C.Builder.NewSingleElectron(atom3C)); atom3C.Hybridization = Hybridization.Unset; AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactantCloned); type = atMatcher.FindMatchingAtomType(reactantCloned, atom3C); if (type == null || type.AtomTypeName.Equals("X", StringComparison.Ordinal)) { return(null); } IReaction reaction = atom2C.Builder.NewReaction(); reaction.Reactants.Add(molecule); /* mapping */ foreach (var atom in molecule.Atoms) { IMapping mapping = atom2C.Builder.NewMapping(atom, reactantCloned.Atoms[molecule.Atoms.IndexOf(atom)]); reaction.Mappings.Add(mapping); } var moleculeSetP = ConnectivityChecker.PartitionIntoMolecules(reactantCloned); foreach (var moleculeP in moleculeSetP) { reaction.Products.Add(moleculeP); } return(reaction); }
/// <summary> Tries to saturate a bond by increasing its bond orders by 1.0. /// /// </summary> /// <returns> true if the bond could be increased /// </returns> public virtual bool saturateByIncreasingBondOrder(IBond bond, IAtomContainer atomContainer, double increment) { IAtom[] atoms = bond.getAtoms(); IAtom atom = atoms[0]; IAtom partner = atoms[1]; //logger.debug(" saturating bond: ", atom.Symbol, "-", partner.Symbol); IAtomType[] atomTypes1 = getAtomTypeFactory(bond.Builder).getAtomTypes(atom.Symbol); IAtomType[] atomTypes2 = getAtomTypeFactory(bond.Builder).getAtomTypes(partner.Symbol); for (int atCounter1 = 0; atCounter1 < atomTypes1.Length; atCounter1++) { IAtomType aType1 = atomTypes1[atCounter1]; //logger.debug(" condidering atom type: ", aType1); if (couldMatchAtomType(atomContainer, atom, aType1)) { //logger.debug(" trying atom type: ", aType1); for (int atCounter2 = 0; atCounter2 < atomTypes2.Length; atCounter2++) { IAtomType aType2 = atomTypes2[atCounter2]; //logger.debug(" condidering partner type: ", aType1); if (couldMatchAtomType(atomContainer, partner, atomTypes2[atCounter2])) { //logger.debug(" with atom type: ", aType2); if (bond.Order < aType2.MaxBondOrder && bond.Order < aType1.MaxBondOrder) { bond.Order = bond.Order + increment; //logger.debug("Bond order now ", bond.Order); return true; } } } } } return false; }
private IEnumerable<IAtomContainer> splitMolecule(IAtomContainer atomContainer, IBond bond, IDictionary<IAtom, IList<IBond>> atomBonds) { //if this bond is in a ring we have to split another bond in this ring where at least one //bond is in between. Otherwise we wont have two fragments. Else normal split. var ret = new List<IAtomContainer>(); //get bond energy for splitting this bond var currentBondEnergy = BondEnergies.Lookup(bond); //bond is in a ring....so we have to split up another bond to break it var rings = allRings.getRings(bond); if (rings.getAtomContainerCount() != 0) { foreach (var bondInRing in rings.getAtomContainer(0).bonds().ToWindowsEnumerable<IBond>()) { //if the bonds are the same...this wont split up the ring if (bondInRing == bond) { continue; } //check for already tried bonds var check = new BondPair(bond, bondInRing); if (knownBonds.Contains(check)) { continue; } knownBonds.Add(new BondPair(bond, bondInRing)); var set = new List<IAtomContainer>(); var bondListList = new List<List<IBond>>(); var fragWeightList = new List<Double>(); foreach (var currentAtom in bond.atoms().ToWindowsEnumerable<IAtom>()) { //List with bonds in Ring var partRing = new List<IBond>(); //reset the weight because it is computed inside the traverse currentFragWeight = 0.0; //initialize new atom list atomList = new List<IAtom>(); //clone current atom because a single electron is being added...homolytic cleavage partRing = traverse(atomBonds, currentAtom, partRing, bond, bondInRing); bondListList.Add(partRing); fragWeightList.Add(currentFragWeight); var temp = makeAtomContainer(currentAtom, partRing); //set the properties again! var properties = atomContainer.getProperties(); temp.setProperties(properties); //********************************************************* //BOND ENERGY CALCULATION //calculate bond energy var currentBondEnergyRing = BondEnergies.Lookup(bondInRing); //********************************************************* //now set property temp = setBondEnergy(temp, (currentBondEnergyRing + currentBondEnergy)); set.Add(temp); } //now maybe add the fragments to the list for (var j = 0; j < set.Count; j++) { //Render.Draw(set.getAtomContainer(j), ""); if (set[j].getAtomCount() > 0 && set[j].getBondCount() > 0 && set[j].getAtomCount() != atomContainer.getAtomCount()) { //now check the current mass var fragMass = getFragmentMass(set[j], fragWeightList[j]); //check the weight of the current fragment if (!isHeavyEnough(fragMass)) { continue; } //returns true if isomorph //set the current sum formula var fragmentFormula = MolecularFormulaTools.GetMolecularFormula(set[j]); var currentSumFormula = MolecularFormulaTools.GetString(fragmentFormula); if (isIdentical(set[j], currentSumFormula)) { continue; } //add the fragment to the return list ret.Add(set[j]); } } } } else { var set = new List<IAtomContainer>(); var bondListList = new List<List<IBond>>(); var fragWeightList = new List<Double>(); //get the atoms from the splitting bond --> create 2 fragments foreach (var currentAtom in bond.atoms().ToWindowsEnumerable<IAtom>()) { var part = new List<IBond>(); //reset the weight because it is computed inside the traverse currentFragWeight = 0.0; //initialize new atom list atomList = new List<IAtom>(); part = traverse(atomBonds, currentAtom, part, bond); bondListList.Add(part); //create Atomcontainer out of bondList var temp = makeAtomContainer(currentAtom, part); //set the properties again! var properties = atomContainer.getProperties(); temp.setProperties(properties); //now calculate the correct weight subtrating the possible neutral loss mass fragWeightList.Add(currentFragWeight); //now set property: BondEnergy! temp = setBondEnergy(temp, currentBondEnergy); set.Add(temp); } //at most 2 new molecules for (var i = 0; i < set.Count; i++) { if (set[i].getAtomCount() > 0 && set[i].getBondCount() > 0 && set[i].getAtomCount() != atomContainer.getAtomCount()) { //now check the current mass var fragMass = getFragmentMass(set[i], fragWeightList[i]); //check the weight of the current fragment if (!isHeavyEnough(fragMass)) { continue; } //set the current sum formula var fragmentFormula = MolecularFormulaTools.GetMolecularFormula(set[i]); var currentSumFormula = MolecularFormulaTools.GetString(fragmentFormula); //returns true if isomorph (fast isomorph check) if (isIdentical(set[i], currentSumFormula)) { continue; } ret.Add(set[i]); } } } return ret; }
/// <summary> Returns wether a bond is saturated. A bond is saturated if /// <b>both</b> Atoms in the bond are saturated. /// </summary> public virtual bool isSaturated(IBond bond, IAtomContainer atomContainer) { IAtom[] atoms = bond.getAtoms(); bool isSaturated = true; for (int i = 0; i < atoms.Length; i++) { isSaturated = isSaturated && this.isSaturated(atoms[i], atomContainer); } return isSaturated; }
public bool Matches(IBond bond) { return(Matches(bond, UnknownStereo)); }
/** * Resursively traverse the molecule to get all the bonds in a list and return them. Start at the given Atom. * Ignore the 2 given bonds --> split up a ring! * * @param atomContainer the atom container * @param atom the atom * @param bondList the bond list * * @return the list< i bond> */ private List<IBond> traverse(IDictionary<IAtom, IList<IBond>> atomBonds, IAtom atom, List<IBond> bondList, IBond bondToRemove, IBond bondToRemove2) { var connectedBonds = atomBonds[atom]; foreach (var aBond in connectedBonds) { if (aBond.Equals(bondToRemove) || aBond.Equals(bondToRemove2) || bondList.Contains(aBond)) { continue; } bondList.Add(aBond); //get the weight of the bonded atoms foreach (var atomWeight in aBond.atoms().ToWindowsEnumerable<IAtom>()) { //get the prepared mass of the atom if it is not already counted if (!atomList.Contains(atomWeight)) { currentFragWeight += atomMasses[atomWeight.getSymbol()]; atomList.Add(atomWeight); } } var nextAtom = aBond.getConnectedAtom(atom); if (atomBonds[nextAtom].Count == 1) { continue; } traverse(atomBonds, nextAtom, bondList, bondToRemove, bondToRemove2); } return bondList; }
public void Test1Sphere() { string[] result = { "O-1;=C(//)", "C-3;=OCC(//)", "C-3;=CC(//)", "C-3;=CC(//)", "C-3;*C*CC(//)", "C-3;*C*C(//)", "C-3;*C*C(//)", "C-3;*C*CC(//)", "C-3;*C*CC(//)", "C-3;*C*C(//)", "C-3;*C*C(//)", "C-3;*C*C(//)", "C-3;*C*C(//)", "C-3;*C*CO(//)", "O-2;CC(//)", "C-3;*C*CO(//)", "C-3;*C*CO(//)", "O-2;CC(//)", "C-4;O(//)", "C-3;*C*C(//)", "C-3;*C*CC(//)", "C-3;*C*C*C(//)", "C-3;*C*C*C(//)" }; var mol = builder.NewAtomContainer(); IAtom a1 = mol.Builder.NewAtom("O"); a1.Point2D = new Vector2(502.88457268119913, 730.4999999999999); mol.Atoms.Add(a1); IAtom a2 = mol.Builder.NewAtom("C"); a2.Point2D = new Vector2(502.8845726811991, 694.4999999999999); mol.Atoms.Add(a2); IAtom a3 = mol.Builder.NewAtom("C"); a3.Point2D = new Vector2(534.0614872174388, 676.4999999999999); mol.Atoms.Add(a3); IAtom a4 = mol.Builder.NewAtom("C"); a4.Point2D = new Vector2(534.0614872174388, 640.4999999999999); mol.Atoms.Add(a4); IAtom a5 = mol.Builder.NewAtom("C"); a5.Point2D = new Vector2(502.8845726811991, 622.4999999999999); mol.Atoms.Add(a5); IAtom a6 = mol.Builder.NewAtom("C"); a6.Point2D = new Vector2(502.8845726811991, 586.4999999999999); mol.Atoms.Add(a6); IAtom a7 = mol.Builder.NewAtom("C"); a7.Point2D = new Vector2(471.7076581449593, 568.4999999999999); mol.Atoms.Add(a7); IAtom a8 = mol.Builder.NewAtom("C"); a8.Point2D = new Vector2(440.5307436087194, 586.5); mol.Atoms.Add(a8); IAtom a9 = mol.Builder.NewAtom("C"); a9.Point2D = new Vector2(409.35382907247964, 568.5); mol.Atoms.Add(a9); IAtom a10 = mol.Builder.NewAtom("C"); a10.Point2D = new Vector2(409.3538290724796, 532.5); mol.Atoms.Add(a10); IAtom a11 = mol.Builder.NewAtom("C"); a11.Point2D = new Vector2(378.1769145362398, 514.5); mol.Atoms.Add(a11); IAtom a12 = mol.Builder.NewAtom("C"); a12.Point2D = new Vector2(347.0, 532.5); mol.Atoms.Add(a12); IAtom a13 = mol.Builder.NewAtom("C"); a13.Point2D = new Vector2(347.0, 568.5); mol.Atoms.Add(a13); IAtom a14 = mol.Builder.NewAtom("C"); a14.Point2D = new Vector2(378.17691453623985, 586.5); mol.Atoms.Add(a14); IAtom a15 = mol.Builder.NewAtom("O"); a15.Point2D = new Vector2(378.17691453623985, 622.5); mol.Atoms.Add(a15); IAtom a16 = mol.Builder.NewAtom("C"); a16.Point2D = new Vector2(409.3538290724797, 640.5); mol.Atoms.Add(a16); IAtom a17 = mol.Builder.NewAtom("C"); a17.Point2D = new Vector2(409.3538290724797, 676.5); mol.Atoms.Add(a17); IAtom a18 = mol.Builder.NewAtom("O"); a18.Point2D = new Vector2(378.17691453623996, 694.5); mol.Atoms.Add(a18); IAtom a19 = mol.Builder.NewAtom("C"); a19.Point2D = new Vector2(378.17691453624, 730.5); mol.Atoms.Add(a19); IAtom a20 = mol.Builder.NewAtom("C"); a20.Point2D = new Vector2(440.5307436087195, 694.4999999999999); mol.Atoms.Add(a20); IAtom a21 = mol.Builder.NewAtom("C"); a21.Point2D = new Vector2(471.7076581449593, 676.4999999999999); mol.Atoms.Add(a21); IAtom a22 = mol.Builder.NewAtom("C"); a22.Point2D = new Vector2(471.7076581449593, 640.4999999999999); mol.Atoms.Add(a22); IAtom a23 = mol.Builder.NewAtom("C"); a23.Point2D = new Vector2(440.53074360871943, 622.4999999999999); mol.Atoms.Add(a23); IBond b1 = mol.Builder.NewBond(a2, a1, BondOrder.Double); mol.Bonds.Add(b1); IBond b2 = mol.Builder.NewBond(a3, a2, BondOrder.Single); mol.Bonds.Add(b2); IBond b3 = mol.Builder.NewBond(a4, a3, BondOrder.Double); mol.Bonds.Add(b3); IBond b4 = mol.Builder.NewBond(a5, a4, BondOrder.Single); mol.Bonds.Add(b4); IBond b5 = mol.Builder.NewBond(a6, a5, BondOrder.Single); mol.Bonds.Add(b5); IBond b6 = mol.Builder.NewBond(a7, a6, BondOrder.Double); mol.Bonds.Add(b6); IBond b7 = mol.Builder.NewBond(a8, a7, BondOrder.Single); mol.Bonds.Add(b7); IBond b8 = mol.Builder.NewBond(a9, a8, BondOrder.Single); mol.Bonds.Add(b8); IBond b9 = mol.Builder.NewBond(a10, a9, BondOrder.Single); mol.Bonds.Add(b9); IBond b10 = mol.Builder.NewBond(a11, a10, BondOrder.Double); mol.Bonds.Add(b10); IBond b11 = mol.Builder.NewBond(a12, a11, BondOrder.Single); mol.Bonds.Add(b11); IBond b12 = mol.Builder.NewBond(a13, a12, BondOrder.Double); mol.Bonds.Add(b12); IBond b13 = mol.Builder.NewBond(a14, a13, BondOrder.Single); mol.Bonds.Add(b13); IBond b14 = mol.Builder.NewBond(a14, a9, BondOrder.Double); mol.Bonds.Add(b14); IBond b15 = mol.Builder.NewBond(a15, a14, BondOrder.Single); mol.Bonds.Add(b15); IBond b16 = mol.Builder.NewBond(a16, a15, BondOrder.Single); mol.Bonds.Add(b16); IBond b17 = mol.Builder.NewBond(a17, a16, BondOrder.Double); mol.Bonds.Add(b17); IBond b18 = mol.Builder.NewBond(a18, a17, BondOrder.Single); mol.Bonds.Add(b18); IBond b19 = mol.Builder.NewBond(a19, a18, BondOrder.Single); mol.Bonds.Add(b19); IBond b20 = mol.Builder.NewBond(a20, a17, BondOrder.Single); mol.Bonds.Add(b20); IBond b21 = mol.Builder.NewBond(a21, a20, BondOrder.Double); mol.Bonds.Add(b21); IBond b22 = mol.Builder.NewBond(a21, a2, BondOrder.Single); mol.Bonds.Add(b22); IBond b23 = mol.Builder.NewBond(a22, a21, BondOrder.Single); mol.Bonds.Add(b23); IBond b24 = mol.Builder.NewBond(a22, a5, BondOrder.Double); mol.Bonds.Add(b24); IBond b25 = mol.Builder.NewBond(a23, a22, BondOrder.Single); mol.Bonds.Add(b25); IBond b26 = mol.Builder.NewBond(a23, a16, BondOrder.Single); mol.Bonds.Add(b26); IBond b27 = mol.Builder.NewBond(a23, a8, BondOrder.Double); mol.Bonds.Add(b27); AddImplicitHydrogens(mol); //MoleculeViewer2D.Display(molecule, true); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol); Aromaticity.CDKLegacy.Apply(mol); HOSECodeGenerator hcg = new HOSECodeGenerator(); string s = null; for (int f = 0; f < 23; f++) { s = hcg.GetHOSECode(mol, mol.Atoms[f], 1); if (standAlone) { Console.Out.Write("|" + s + "| -> " + result[f]); } Assert.AreEqual(result[f], s); if (standAlone) { Console.Out.WriteLine(" OK"); } } }
public void OnNewDataSource(IAtom[] atoms, IBond[] bonds, Vector3 origin, Bounds3D bounds) { sceneGraph = new OcTree<ChemEntity>((int)bounds.radius * 2, -bounds.min); /*screenEntities.Add(new BondAngle(device, atoms[0], atoms[1], atoms[2])); screenEntities[0].Init(device); postSceneWorldEntities.Add(new BoundingBoxEntity(new BoundingBox(bounds.min, bounds.max), false, Color.LightGray.ToArgb())); postSceneWorldEntities[0].Init(device); postSceneWorldEntities.Add(new SphereAxis3D()); postSceneWorldEntities[1].Init(device);*/ sceneGraphEntities = sceneGraph.SceneItems; // create molecule entities foreach (IAtom atom in atoms) { AtomEntity aentity = AtomEntity.BuildEntity(atom); sceneGraph.Insert(aentity); /*ScreenLabelVSpaceEntity entity = new ScreenLabelVSpaceEntity(atom.ID + ":" + aentity.UId.ToString(), (Vector3)aentity.Position3D); entity.Init(device); screenEntities.Add(entity);*/ /*AtomSymbolEntity entity = new AtomSymbolEntity(aentity); entity.Init(device); postSceneViewEntities.Add(entity);*/ } //foreach (IBond bond in bonds) //{ //sceneGraph.Insert(new BondE); //} scheme.SetOutputDescription(coDesc); scheme.SetupScene(origin, bounds.radius); // pass throught scheme & effects IGeometryCreator[] schStreams = scheme.GetAtomStreams(); DataFields[] efxFields = null; //effect.DesiredData(out efxFields, false); DataFields[][] allStreams = new DataFields[1 + (efxFields != null ? 1 : 0 )][]; //if (efxFields != null) // allStreams[1] = efxFields; if (scheme.HandlesAtoms && atoms != null) { GeomDataBufferStream[] geomStream = new GeomDataBufferStream[schStreams.Length]; for (int i = 0; i < geomStream.Length; i++) { allStreams[0] = schStreams[i].Fields; GeomDataTransformer.CreateBufferStream(allStreams, out geomStream[i]); } // fill buffer stream scheme.SetAtomData(atoms, geomStream); } schStreams = scheme.GetBondStreams(); if (scheme.HandlesBonds && bonds != null) { GeomDataBufferStream[] geomStream = new GeomDataBufferStream[schStreams.Length]; for (int i = 0; i < geomStream.Length; i++) { allStreams[0] = schStreams[i].Fields; GeomDataTransformer.CreateBufferStream(allStreams, out geomStream[i]); } // fill buffer stream scheme.SetBondData(bonds, geomStream); } }
protected BondDecorator(IBond toDecorate) { _toDecorate = toDecorate ?? throw new ArgumentNullException(nameof(toDecorate)); }
public void UpdateBonds(CompleteOutputDescription latestCoDesc, IBond[] bonds) { if (scheme.HandlesBonds) { scheme.SetOutputDescription(coDesc); DataFields[][] allStreams = new DataFields[1][]; IGeometryCreator[] schStreams = scheme.GetBondStreams(); GeomDataBufferStream[] geomStream = new GeomDataBufferStream[schStreams.Length]; for (int i = 0; i < geomStream.Length; i++) { allStreams[0] = schStreams[i].Fields; GeomDataTransformer.CreateBufferStream(allStreams, out geomStream[i]); } // fill buffer stream scheme.SetBondData(bonds, geomStream); } }