Esempio n. 1
0
        /// <summary>
        /// Remove the following features from a molecule
        ///  - Atom non-standard mass
        ///  - Stereo chemistry
        ///  - explicit hydrogens
        /// </summary>
        /// <param name="src"></param>
        /// <returns>Modified mol</returns>

        public static IAtomContainer RemoveIsotopesStereoExplicitHydrogens(
            IAtomContainer src)
        {
            IAtom[] atoms = new IAtom[src.Atoms.Count];
            IBond[] bonds = new IBond[src.Bonds.Count];

            IChemObjectBuilder builder = src.Builder;

            for (int i = 0; i < atoms.Length; i++)
            {
                IAtom atom  = src.Atoms[i];
                IAtom atom2 = builder.NewAtom(atom.Symbol);
                SetImplicitHydrogenCount(atom2, GetImplicitHydrogenCount(atom));
                atom2.Point2D = atom.Point2D;
                atoms[i]      = atom2;
            }

            for (int i = 0; i < bonds.Length; i++)
            {
                IBond bond = src.Bonds[i];

                int u = bond.Atoms[0].Index;
                int v = bond.Atoms[1].Index;

                IBond bond2 = builder.NewBond(atoms[u], atoms[v]);

                bond2.IsAromatic = bond.IsAromatic;
                bond2.IsInRing   = bond.IsInRing;
                bond2.Order      = bond.Order;

                bond2.IsAromatic       = bond.IsAromatic;
                bond2.IsSingleOrDouble = bond.IsSingleOrDouble;

                bonds[i] = bond2;
            }

            IAtomContainer dest = ChemObjectBuilder.Instance.NewAtomContainer();

            dest.SetAtoms(atoms);
            dest.SetBonds(bonds);

            AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(dest);
            dest = AtomContainerManipulator.SuppressHydrogens(dest);
            GetHydrogenAdder().AddImplicitHydrogens(dest);

            return(dest);
        }
Esempio n. 2
0
        public void TestTraversal_Chain()
        {
            var builder = CDK.Builder;

            IAtom[] atoms = new IAtom[] { builder.NewAtom("C"), builder.NewAtom("C"),
                                          builder.NewAtom("C"), builder.NewAtom("C"),
                                          builder.NewAtom("C"), builder.NewAtom("C") };
            IBond[] bonds = new IBond[] { builder.NewBond(atoms[0], atoms[1]),
                                          builder.NewBond(atoms[1], atoms[2]),
                                          builder.NewBond(atoms[2], atoms[3]),
                                          builder.NewBond(atoms[3], atoms[4]),
                                          builder.NewBond(atoms[4], atoms[5]) };

            IAtomContainer m = builder.NewAtomContainer();

            m.SetAtoms(atoms);
            m.SetBonds(bonds);

            List <IBond> accumulator = new List <IBond>();

            // traverse from one end
            FragmentUtils.Traverse(m, atoms[0], accumulator);

            Assert.AreEqual(5, accumulator.Count);
            Assert.AreEqual(bonds[0], accumulator[0]);
            Assert.AreEqual(bonds[1], accumulator[1]);
            Assert.AreEqual(bonds[2], accumulator[2]);
            Assert.AreEqual(bonds[3], accumulator[3]);
            Assert.AreEqual(bonds[4], accumulator[4]);

            // traverse from the middle
            accumulator.Clear();
            FragmentUtils.Traverse(m, atoms[3], accumulator);

            Assert.AreEqual(5, accumulator.Count);

            Assert.AreEqual(bonds[2], accumulator[0]);
            Assert.AreEqual(bonds[1], accumulator[1]);
            Assert.AreEqual(bonds[0], accumulator[2]);
            Assert.AreEqual(bonds[3], accumulator[3]);
            Assert.AreEqual(bonds[4], accumulator[4]);
        }
Esempio n. 3
0
        /// <summary>
        /// (Converted from Java to C# for possible later modification)
        /// Suppress any explicit hydrogens in the provided container. Only hydrogens
        /// that can be represented as a hydrogen count value on the atom are
        /// suppressed. The container is updated and no elements are copied, please
        /// use either <seealso cref="#copyAndSuppressedHydrogens"/> if you would to preserve
        /// the old instance.
        /// </summary>
        /// <param name="org"> the container from which to remove hydrogens </param>
        /// <returns> the input for convenience </returns>
        /// <seealso cref= #copyAndSuppressedHydrogens </seealso>
        public IAtomContainer suppressHydrogens(IAtomContainer org)
        {
            bool anyHydrogenPresent = false;

            for (int ai = 0; ai < org.Atoms.Count; ai++)
            {
                IAtom atom = org.Atoms[ai];
                if ("H".Equals(atom.Symbol))
                {
                    anyHydrogenPresent = true;
                    break;
                }
            }

            if (!anyHydrogenPresent)
            {
                return(org);
            }

            // we need fast adjacency checks (to check for suppression and
            // update hydrogen counts)
            int[][] graph = GraphUtil.ToAdjList(org);

            int nOrgAtoms = org.Atoms.Count;
            int nOrgBonds = org.Bonds.Count;

            int nCpyAtoms = 0;
            int nCpyBonds = 0;

            ISet <IAtom> hydrogens = new HashSet <IAtom>();

            IAtom[] cpyAtoms = new IAtom[nOrgAtoms];

            // filter the original container atoms for those that can/can't
            // be suppressed
            for (int v = 0; v < nOrgAtoms; v++)
            {
                IAtom atom = org.Atoms[v];
                if (suppressibleHydrogen(org, graph, v))
                {
                    hydrogens.Add(atom);
                    incrementImplHydrogenCount(org.Atoms[graph[v][0]]);
                }
                else
                {
                    cpyAtoms[nCpyAtoms++] = atom;
                }
            }

            // none of the hydrogens could be suppressed - no changes need to be made
            if (hydrogens.Count == 0)
            {
                return(org);
            }

            org.SetAtoms(cpyAtoms);

            // we now update the bonds - we have auxiliary variable remaining that
            // bypasses the set membership checks if all suppressed bonds are found
            IBond[] cpyBonds  = new IBond[nOrgBonds - hydrogens.Count];
            int     remaining = hydrogens.Count;

            for (int bi = 0; bi < org.Bonds.Count; bi++)
            {
                IBond bond = org.Bonds[bi];
                if (remaining > 0 && (hydrogens.Contains(bond.Atoms[0]) || hydrogens.Contains(bond.Atoms[1])))
                {
                    remaining--;
                    continue;
                }
                cpyBonds[nCpyBonds++] = bond;
            }

            // we know how many hydrogens we removed and we should have removed the
            // same number of bonds otherwise the container is strange
            if (nCpyBonds != cpyBonds.Length)
            {
                throw new System.ArgumentException("number of removed bonds was less than the number of removed hydrogens");
            }

            org.SetBonds(cpyBonds);

            return(org);
        }
Esempio n. 4
0
        /// <summary>
        /// Remove explicit and implicit hydrogens bonded to positive nitrogens
        /// </summary>
        /// <param name="org"></param>
        /// <returns></returns>
        public int RemoveHydrogensBondedToPositiveNitrogens(IAtomContainer org)
        {
            int chg, impHydCnt;
            int implicitHydRemoved = 0;

            HashSet <IAtom> atomsToRemove = new HashSet <IAtom>();
            HashSet <IBond> bondsToRemove = new HashSet <IBond>();
            int             nOrgAtoms     = org.Atoms.Count;
            int             nOrgBonds     = org.Bonds.Count;

            // Get H atoms and their bonds to pos-charged Nitrogen, adjusting charge

            for (int bi = 0; bi < org.Bonds.Count; bi++)
            {
                IBond bond = org.Bonds[bi];
                if (bond.Atoms.Count != 2)
                {
                    continue;
                }

                IAtom a1 = bond.Atoms[0];
                IAtom a2 = bond.Atoms[1];
                if (a1.Symbol == "H" && a2.Symbol == "N" && GetFormalCharge(a2) > 0)
                {
                    chg = GetFormalCharge(a2) - 1;
                    SetFormalCharge(a2, chg);
                    atomsToRemove.Add(a1);
                    bondsToRemove.Add(bond);
                }

                else if (a2.Symbol == "H" && a1.Symbol == "N" && GetFormalCharge(a1) > 0)
                {
                    chg = GetFormalCharge(a1) - 1;
                    SetFormalCharge(a1, chg);
                    atomsToRemove.Add(a2);
                    bondsToRemove.Add(bond);
                }
            }

            // Check for implicit H attached to pos-charged N

            for (int ai = 0; ai < nOrgAtoms; ai++)
            {
                IAtom a = org.Atoms[ai];
                if (a.Symbol == "N" && GetFormalCharge(a) > 0 && GetImplicitHydrogenCount(a) > 0)
                {
                    chg = GetFormalCharge(a) - 1;
                    SetFormalCharge(a, chg);

                    impHydCnt = GetImplicitHydrogenCount(a) - 1;
                    SetImplicitHydrogenCount(a, impHydCnt);
                    implicitHydRemoved++;
                }
            }

            if (implicitHydRemoved > 0)
            {
                implicitHydRemoved = implicitHydRemoved;                                     // debug
            }
            if (atomsToRemove.Count == 0)
            {
                return(implicitHydRemoved);                                      // just return if no explicit H to remove
            }
            // Get list of atoms to keep

            IAtom[] cpyAtoms  = new IAtom[nOrgAtoms - atomsToRemove.Count];
            int     nCpyAtoms = 0;

            for (int ai = 0; ai < nOrgAtoms; ai++)
            {
                IAtom atom = org.Atoms[ai];
                if (!atomsToRemove.Contains(atom))
                {
                    cpyAtoms[nCpyAtoms++] = atom;
                }
            }

            org.SetAtoms(cpyAtoms);

            // Get list of bonds to keep

            IBond[] cpyBonds  = new IBond[nOrgBonds - bondsToRemove.Count];
            int     nCpyBonds = 0;

            for (int bi = 0; bi < org.Bonds.Count; bi++)
            {
                IBond bond = org.Bonds[bi];
                if (!bondsToRemove.Contains(bond))
                {
                    cpyBonds[nCpyBonds++] = bond;
                }
            }

            org.SetBonds(cpyBonds);

            return(atomsToRemove.Count + implicitHydRemoved);
        }