Esempio n. 1
0
File: Bond.tt.cs Progetto: qize/NCDK
 private void UpdateElectronCount(BondOrder order)
 {
     if (order == BondOrder.Unset)
     {
         return;
     }
     this.ElectronCount = order.Numeric() * 2;
 }
Esempio n. 2
0
        /// <summary>
        /// Get the single bond equivalent (SBE) of a list of bonds, given an iterator to the list.
        /// </summary>
        /// <param name="bonds">An iterator to the list of bonds</param>
        /// <returns>The SBE sum</returns>
        public static int GetSingleBondEquivalentSum(IEnumerable <IBond> bonds)
        {
            int sum = 0;

            foreach (var bond in bonds)
            {
                BondOrder order = bond.Order;
                if (!order.IsUnset())
                {
                    sum += order.Numeric();
                }
            }
            return(sum);
        }
Esempio n. 3
0
        private void SetTargetSingleAtomMap(bool removeHydrogen)
        {
            int          counter = 0;
            BondEnergies be      = BondEnergies.Instance;

            foreach (var targetAtom in target.Atoms)
            {
                if ((removeHydrogen && !targetAtom.AtomicNumber.Equals(AtomicNumbers.H)) || (!removeHydrogen))
                {
                    foreach (var sourceAtoms in source.Atoms)
                    {
                        var mapAtoms = new Dictionary <IAtom, IAtom>();

                        if (string.Equals(targetAtom.Symbol, sourceAtoms.Symbol, StringComparison.OrdinalIgnoreCase))
                        {
                            mapAtoms[sourceAtoms] = targetAtom;
                            var bonds = source.GetConnectedBonds(sourceAtoms);

                            double totalOrder = 0;
                            foreach (var bond in bonds)
                            {
                                BondOrder order = bond.Order;
                                totalOrder += order.Numeric() + BondEnergies.GetEnergies(bond);
                            }
                            if (sourceAtoms.FormalCharge != targetAtom.FormalCharge)
                            {
                                totalOrder += 0.5;
                            }
                            connectedBondOrder[counter] = totalOrder;
                            mappings.Insert(counter++, mapAtoms);
                        }
                    }
                }
                else
                {
                    Console.Error.WriteLine("Skipping Hydrogen mapping or This is not a single mapping case!");
                }
            }
        }
Esempio n. 4
0
        private void SetSourceSingleAtomMap(IQueryAtomContainer source, bool removeHydrogen)
        {
            int          counter = 0;
            BondEnergies be      = BondEnergies.Instance;

            foreach (var sourceAtom in source.Atoms)
            {
                var smartAtom = (IQueryAtom)sourceAtom;
                if ((removeHydrogen && !smartAtom.AtomicNumber.Equals(AtomicNumbers.H)) || (!removeHydrogen))
                {
                    foreach (var targetAtom in target.Atoms)
                    {
                        var mapAtoms = new Dictionary <IAtom, IAtom>();
                        if (smartAtom.Matches(targetAtom))
                        {
                            mapAtoms[sourceAtom] = targetAtom;
                            var bonds = target.GetConnectedBonds(targetAtom);

                            double totalOrder = 0;
                            foreach (var bond in bonds)
                            {
                                BondOrder order = bond.Order;
                                totalOrder += order.Numeric() + BondEnergies.GetEnergies(bond);
                            }
                            if (targetAtom.FormalCharge != sourceAtom.FormalCharge)
                            {
                                totalOrder += 0.5;
                            }
                            connectedBondOrder[counter] = totalOrder;
                            mappings.Insert(counter++, mapAtoms);
                        }
                    }
                }
                else
                {
                    Console.Error.WriteLine("Skipping Hydrogen mapping or This is not a single mapping case!");
                }
            }
        }
Esempio n. 5
0
 /// <summary>
 /// Returns the number of times the side chain should end up as the CIP-expanded ligand list. The CIP
 /// rules prescribe that a double bonded oxygen should be represented twice in the list.
 /// </summary>
 /// <param name="order"><see cref="BondOrder"/> of the bond</param>
 /// <returns>int reflecting the duplication number</returns>
 private static int GetDuplication(BondOrder order)
 {
     return(order.Numeric());
 }
Esempio n. 6
0
        public static double[] GetAtomWeights(IAtomContainer atomContainer)
        {
            IAtom atom, headAtom, endAtom;
            int   headAtomPosition, endAtomPosition;

            //int k = 0;
            double[]   weightArray = new double[atomContainer.Atoms.Count];
            double[][] adjaMatrix  = ConnectionMatrix.GetMatrix(atomContainer);

            int[][] apspMatrix = PathTools.ComputeFloydAPSP(adjaMatrix);
            int[]   atomLayers = GetAtomLayers(apspMatrix);

            int[] valenceSum;
            int[] interLayerBondSum;

            Debug.WriteLine("adjacency matrix: ");
            DisplayMatrix(adjaMatrix);
            Debug.WriteLine("all-pairs-shortest-path matrix: ");
            DisplayMatrix(apspMatrix);
            Debug.WriteLine("atom layers: ");
            DisplayArray(atomLayers);

            for (int i = 0; i < atomContainer.Atoms.Count; i++)
            {
                atom = atomContainer.Atoms[i];

                valenceSum = new int[atomLayers[i]];
                for (int v = 0; v < valenceSum.Length; v++)
                {
                    valenceSum[v] = 0;
                }

                interLayerBondSum = new int[atomLayers[i] - 1];
                for (int v = 0; v < interLayerBondSum.Length; v++)
                {
                    interLayerBondSum[v] = 0;
                }

                //weightArray[k] = atom.GetValenceElectronsCount() - atom.GetHydrogenCount(); // method unfinished
                if (AtomicNumbers.O.Equals(atom.AtomicNumber))
                {
                    weightArray[i] = 6 - atom.ImplicitHydrogenCount.Value;
                }
                else
                {
                    weightArray[i] = 4 - atom.ImplicitHydrogenCount.Value;
                }

                for (int j = 0; j < apspMatrix.Length; j++)
                {
                    if (string.Equals("O", atomContainer.Atoms[j].Symbol, StringComparison.Ordinal))
                    {
                        valenceSum[apspMatrix[j][i]] += 6 - atomContainer.Atoms[j].ImplicitHydrogenCount.Value;
                    }
                    else
                    {
                        valenceSum[apspMatrix[j][i]] += 4 - atomContainer.Atoms[j].ImplicitHydrogenCount.Value;
                    }
                }

                var bonds = atomContainer.Bonds;
                foreach (var bond in bonds)
                {
                    headAtom = bond.Begin;
                    endAtom  = bond.End;

                    headAtomPosition = atomContainer.Atoms.IndexOf(headAtom);
                    endAtomPosition  = atomContainer.Atoms.IndexOf(endAtom);

                    if (Math.Abs(apspMatrix[i][headAtomPosition] - apspMatrix[i][endAtomPosition]) == 1)
                    {
                        int       min   = Math.Min(apspMatrix[i][headAtomPosition], apspMatrix[i][endAtomPosition]);
                        BondOrder order = bond.Order;
                        interLayerBondSum[min] += order.IsUnset() ? 0 : order.Numeric();
                    }
                }

                for (int j = 0; j < interLayerBondSum.Length; j++)
                {
                    weightArray[i] += interLayerBondSum[j] * valenceSum[j + 1] * Math.Pow(10, -(j + 1));
                }

                Debug.WriteLine("valence sum: ");
                DisplayArray(valenceSum);
                Debug.WriteLine("inter-layer bond sum: ");
                DisplayArray(interLayerBondSum);
            }

            Debug.WriteLine("weight array: ");
            DisplayArray(weightArray);

            return(weightArray);
        }
Esempio n. 7
0
 public static double DestroyBondOrder(BondOrder bondOrder)
 {
     return(bondOrder.Numeric());
 }