Ejemplo n.º 1
0
        /// <summary>  Converts a RingSet to an AtomContainer.
        ///
        /// </summary>
        /// <param name="ringSet"> The RingSet to be converted.
        /// </param>
        /// <returns>          The AtomContainer containing the bonds and atoms of the ringSet.
        /// </returns>
        public static IAtomContainer convertToAtomContainer(IRingSet ringSet)
        {
            IRing ring = (IRing)ringSet.getAtomContainer(0);

            if (ring == null)
            {
                return(null);
            }
            IAtomContainer ac = ring.Builder.newAtomContainer();

            for (int i = 0; i < ringSet.AtomContainerCount; i++)
            {
                ring = (IRing)ringSet.getAtomContainer(i);
                for (int r = 0; r < ring.getBondCount(); r++)
                {
                    IBond bond = ring.getBondAt(r);
                    if (!ac.contains(bond))
                    {
                        for (int j = 0; j < bond.AtomCount; j++)
                        {
                            ac.addAtom(bond.getAtomAt(j));
                        }
                        ac.addBond(bond);
                    }
                }
            }
            return(ac);
        }
Ejemplo n.º 2
0
        /// <summary> Check whether a set of atoms in an atomcontainer is connected
        ///
        /// </summary>
        /// <param name="atomContainer"> The AtomContainer to be check for connectedness
        /// </param>
        /// <returns>                 true if the AtomContainer is connected
        /// </returns>
        public static bool isConnected(IAtomContainer atomContainer)
        {
            IAtomContainer ac       = atomContainer.Builder.newAtomContainer();
            IAtom          atom     = null;
            IMolecule      molecule = atomContainer.Builder.newMolecule();

            System.Collections.ArrayList sphere = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
            for (int f = 0; f < atomContainer.AtomCount; f++)
            {
                atom = atomContainer.getAtomAt(f);
                atomContainer.getAtomAt(f).setFlag(CDKConstants.VISITED, false);
                ac.addAtom(atomContainer.getAtomAt(f));
            }
            IBond[] bonds = atomContainer.Bonds;
            for (int f = 0; f < bonds.Length; f++)
            {
                bonds[f].setFlag(CDKConstants.VISITED, false);
                ac.addBond(bonds[f]);
            }
            atom = ac.getAtomAt(0);
            sphere.Add(atom);
            atom.setFlag(CDKConstants.VISITED, true);
            PathTools.breadthFirstSearch(ac, sphere, molecule);
            if (molecule.AtomCount == atomContainer.AtomCount)
            {
                return(true);
            }
            return(false);
        }
Ejemplo n.º 3
0
        /// <summary> Partitions the atoms in an AtomContainer into covalently connected components.
        ///
        /// </summary>
        /// <param name="atomContainer"> The AtomContainer to be partitioned into connected components, i.e. molecules
        /// </param>
        /// <returns>                 A SetOfMolecules.
        ///
        /// </returns>
        /// <cdk.dictref>    blue-obelisk:graphPartitioning </cdk.dictref>
        public static ISetOfMolecules partitionIntoMolecules(IAtomContainer atomContainer)
        {
            IAtomContainer     ac         = atomContainer.Builder.newAtomContainer();
            IAtom              atom       = null;
            IElectronContainer eContainer = null;
            IMolecule          molecule   = null;
            ISetOfMolecules    molecules  = atomContainer.Builder.newSetOfMolecules();

            System.Collections.ArrayList sphere = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
            for (int f = 0; f < atomContainer.AtomCount; f++)
            {
                atom = atomContainer.getAtomAt(f);
                atom.setFlag(CDKConstants.VISITED, false);
                ac.addAtom(atom);
            }
            IElectronContainer[] eContainers = atomContainer.ElectronContainers;
            for (int f = 0; f < eContainers.Length; f++)
            {
                eContainer = eContainers[f];
                eContainer.setFlag(CDKConstants.VISITED, false);
                ac.addElectronContainer(eContainer);
            }
            while (ac.AtomCount > 0)
            {
                atom     = ac.getAtomAt(0);
                molecule = atomContainer.Builder.newMolecule();
                sphere.Clear();
                sphere.Add(atom);
                atom.setFlag(CDKConstants.VISITED, true);
                PathTools.breadthFirstSearch(ac, sphere, molecule);
                molecules.addMolecule(molecule);
                ac.remove(molecule);
            }
            return(molecules);
        }
Ejemplo n.º 4
0
        /// <summary> Recursivly perfoms a depth first search in a molecular graphs contained in
        /// the AtomContainer molecule, starting at the root atom and returning when it
        /// hits the target atom.
        /// CAUTION: This recursive method sets the VISITED flag of each atom
        /// does not reset it after finishing the search. If you want to do the
        /// operation on the same collection of atoms more than once, you have
        /// to set all the VISITED flags to false before each operation
        /// by looping of the atoms and doing a
        /// "atom.setFlag((CDKConstants.VISITED, false));"
        ///
        /// </summary>
        /// <param name="molecule">The
        /// AtomContainer to be searched
        /// </param>
        /// <param name="root">    The root atom
        /// to start the search at
        /// </param>
        /// <param name="target">  The target
        /// </param>
        /// <param name="path">    An
        /// AtomContainer to be filled with the path
        /// </param>
        /// <returns> true if the
        /// target atom was found during this function call
        /// </returns>
        public static bool depthFirstTargetSearch(IAtomContainer molecule, IAtom root, IAtom target, IAtomContainer path)
        {
            IBond[] bonds = molecule.getConnectedBonds(root);
            IAtom   nextAtom;

            root.setFlag(CDKConstants.VISITED, true);
            for (int f = 0; f < bonds.Length; f++)
            {
                nextAtom = bonds[f].getConnectedAtom(root);
                if (!nextAtom.getFlag(CDKConstants.VISITED))
                {
                    path.addAtom(nextAtom);
                    path.addBond(bonds[f]);
                    if (nextAtom == target)
                    {
                        return(true);
                    }
                    else
                    {
                        if (!depthFirstTargetSearch(molecule, nextAtom, target, path))
                        {
                            // we did not find the target
                            path.removeAtom(nextAtom);
                            path.removeElectronContainer(bonds[f]);
                        }
                        else
                        {
                            return(true);
                        }
                    }
                }
            }
            return(false);
        }
Ejemplo n.º 5
0
        /// <summary> Converts a Jmol <i>model</i> to a CDK AtomContainer.
        ///
        /// </summary>
        /// <param name="model">A Jmol model as returned by the method ModelAdapter.openBufferedReader()
        /// </param>
        public virtual IAtomContainer convert(System.Object model)
        {
            IAtomContainer     atomContainer = builder.newAtomContainer();
            SmarterJmolAdapter adapter       = new SmarterJmolAdapter();

            // use this hashtable to map the ModelAdapter Unique IDs to
            // our CDK Atom's
            System.Collections.Hashtable          htMapUidsToAtoms = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
            Org.Jmol.Api.JmolAdapter.AtomIterator atomIterator     = adapter.getAtomIterator(model);
            while (atomIterator.hasNext())
            {
                IAtom atom = builder.newAtom(atomIterator.ElementSymbol);
                atom.X3d = atomIterator.X;
                atom.Y3d = atomIterator.Y;
                atom.Z3d = atomIterator.Z;
                htMapUidsToAtoms[atomIterator.UniqueID] = atom;
                atomContainer.addAtom(atom);
            }
            Org.Jmol.Api.JmolAdapter.BondIterator bondIterator = adapter.getBondIterator(model);
            while (bondIterator.hasNext())
            {
                System.Object uid1  = bondIterator.AtomUniqueID1;
                System.Object uid2  = bondIterator.AtomUniqueID2;
                int           order = bondIterator.EncodedOrder;
                // now, look up the uids in our atom map.
                IAtom atom1 = (IAtom)htMapUidsToAtoms[uid1];
                IAtom atom2 = (IAtom)htMapUidsToAtoms[uid2];
                IBond bond  = builder.newBond(atom1, atom2, (double)order);
                atomContainer.addBond(bond);
            }
            return(atomContainer);
        }
Ejemplo n.º 6
0
        public virtual IAtomContainer getPath(IAtomContainer spt, IAtom a1, IAtom a2)
        {
            IAtomContainer path = spt.Builder.newAtomContainer();

            PathTools.resetFlags(spt);
            path.addAtom(a1);
            PathTools.depthFirstTargetSearch(spt, a1, a2, path);
            return(path);
        }
Ejemplo n.º 7
0
        /// <summary> Processes the content from the formula field of the INChI.
        /// Typical values look like C6H6, from INChI=1.12Beta/C6H6/c1-2-4-6-5-3-1/h1-6H.
        /// </summary>
        public virtual IAtomContainer processFormula(IAtomContainer parsedContent, System.String atomsEncoding)
        {
            //logger.debug("Parsing atom data: ", atomsEncoding);

            Regex pattern = new Regex("([A-Z][a-z]?)(\\d+)?(.*)");

            //Pattern pattern = Pattern.compile("([A-Z][a-z]?)(\\d+)?(.*)");
            System.String remainder = atomsEncoding;
            while (remainder.Length > 0)
            {
                //logger.debug("Remaining: ", remainder);
                Match matcher = pattern.Match(remainder);
                //Matcher matcher = pattern.matcher(remainder);
                //if (matcher.matches())
                if (matcher != null && matcher.Success)
                {
                    System.String symbol = matcher.Groups[1].Value;
                    //logger.debug("Atom symbol: ", symbol);
                    if (symbol.Equals("H"))
                    {
                        // don't add explicit hydrogens
                    }
                    else
                    {
                        System.String occurenceStr = matcher.Groups[2].Value;
                        int           occurence    = 1;
                        if (occurenceStr != null)
                        {
                            occurence = System.Int32.Parse(occurenceStr);
                        }
                        //logger.debug("  occurence: ", occurence);
                        for (int i = 1; i <= occurence; i++)
                        {
                            parsedContent.addAtom(parsedContent.Builder.newAtom(symbol));
                        }
                    }
                    remainder = matcher.Groups[3].Value;
                    if (remainder == null)
                    {
                        remainder = "";
                    }
                    //logger.debug("  Remaining: ", remainder);
                }
                else
                {
                    //logger.error("No match found!");
                    remainder = "";
                }
                //logger.debug("NO atoms: ", parsedContent.AtomCount);
            }
            return(parsedContent);
        }
        /// <summary> Processes the content from the formula field of the INChI.
        /// Typical values look like C6H6, from INChI=1.12Beta/C6H6/c1-2-4-6-5-3-1/h1-6H.
        /// </summary>
        public virtual IAtomContainer processFormula(IAtomContainer parsedContent, System.String atomsEncoding)
        {
            //logger.debug("Parsing atom data: ", atomsEncoding);

            Regex pattern = new Regex("([A-Z][a-z]?)(\\d+)?(.*)");
            //Pattern pattern = Pattern.compile("([A-Z][a-z]?)(\\d+)?(.*)");
            System.String remainder = atomsEncoding;
            while (remainder.Length > 0)
            {
                //logger.debug("Remaining: ", remainder);
                Match matcher = pattern.Match(remainder);
                //Matcher matcher = pattern.matcher(remainder);
                //if (matcher.matches())
                if (matcher != null && matcher.Success)
                {
                    System.String symbol = matcher.Groups[1].Value;
                    //logger.debug("Atom symbol: ", symbol);
                    if (symbol.Equals("H"))
                    {
                        // don't add explicit hydrogens
                    }
                    else
                    {
                        System.String occurenceStr = matcher.Groups[2].Value;
                        int occurence = 1;
                        if (occurenceStr != null)
                        {
                            occurence = System.Int32.Parse(occurenceStr);
                        }
                        //logger.debug("  occurence: ", occurence);
                        for (int i = 1; i <= occurence; i++)
                        {
                            parsedContent.addAtom(parsedContent.Builder.newAtom(symbol));
                        }
                    }
                    remainder = matcher.Groups[3].Value;
                    if (remainder == null)
                        remainder = "";
                    //logger.debug("  Remaining: ", remainder);
                }
                else
                {
                    //logger.error("No match found!");
                    remainder = "";
                }
                //logger.debug("NO atoms: ", parsedContent.AtomCount);
            }
            return parsedContent;
        }
Ejemplo n.º 9
0
        public virtual IAtomContainer getSpanningTree()
        {
            IAtomContainer ac = molecule.Builder.newAtomContainer();

            for (int a = 0; a < V; a++)
            {
                ac.addAtom(molecule.getAtomAt(a));
            }
            for (int b = 0; b < E; b++)
            {
                if (bondsInTree[b])
                {
                    ac.addBond(molecule.getBondAt(b));
                }
            }
            return(ac);
        }
Ejemplo n.º 10
0
        /// <summary> Method that saturates an atom in a molecule by adding explicit hydrogens.
        ///
        /// </summary>
        /// <param name="atom">     Atom to saturate
        /// </param>
        /// <param name="container">AtomContainer containing the atom
        /// </param>
        /// <param name="count">    Number of hydrogens to add
        /// </param>
        /// <param name="totalContainer">In case you have a container containing multiple structures, this is the total container, whereas container is a partial structure
        ///
        /// </param>
        /// <cdk.keyword>           hydrogen, adding </cdk.keyword>
        /// <cdk.keyword>           explicit hydrogen </cdk.keyword>
        public virtual IAtomContainer addExplicitHydrogensToSatisfyValency(IAtomContainer container, IAtom atom, int count, IAtomContainer totalContainer)
        {
            //boolean create2DCoordinates = GeometryTools.has2DCoordinates(container);

            IIsotope isotope = IsotopeFactory.getInstance(container.Builder).getMajorIsotope("H");

            atom.setHydrogenCount(0);
            IAtomContainer changedAtomsAndBonds = container.Builder.newAtomContainer();

            for (int i = 1; i <= count; i++)
            {
                IAtom hydrogen = container.Builder.newAtom("H");
                IsotopeFactory.getInstance(container.Builder).configure(hydrogen, isotope);
                totalContainer.addAtom(hydrogen);
                IBond newBond = container.Builder.newBond((IAtom)atom, hydrogen, 1.0);
                totalContainer.addBond(newBond);
                changedAtomsAndBonds.addAtom(hydrogen);
                changedAtomsAndBonds.addBond(newBond);
            }
            return(changedAtomsAndBonds);
        }
Ejemplo n.º 11
0
        private IChemModel readChemModel(IChemModel model)
        {
            int[]    atoms       = new int[1];
            double[] atomxs      = new double[1];
            double[] atomys      = new double[1];
            double[] atomzs      = new double[1];
            double[] atomcharges = new double[1];

            int[] bondatomid1 = new int[1];
            int[] bondatomid2 = new int[1];
            int[] bondorder   = new int[1];

            int numberOfAtoms = 0;
            int numberOfBonds = 0;

            try
            {
                System.String line = input.ReadLine();
                while (line != null)
                {
                    SupportClass.Tokenizer st      = new SupportClass.Tokenizer(line);
                    System.String          command = st.NextToken();
                    if ("!Header".Equals(command))
                    {
                        //logger.warn("Ignoring header");
                    }
                    else if ("!Info".Equals(command))
                    {
                        //logger.warn("Ignoring info");
                    }
                    else if ("!Atoms".Equals(command))
                    {
                        //logger.info("Reading atom block");
                        // determine number of atoms to read
                        try
                        {
                            numberOfAtoms = System.Int32.Parse(st.NextToken());
                            //logger.debug("  #atoms: " + numberOfAtoms);
                            atoms       = new int[numberOfAtoms];
                            atomxs      = new double[numberOfAtoms];
                            atomys      = new double[numberOfAtoms];
                            atomzs      = new double[numberOfAtoms];
                            atomcharges = new double[numberOfAtoms];

                            for (int i = 0; i < numberOfAtoms; i++)
                            {
                                line = input.ReadLine();
                                SupportClass.Tokenizer atomInfoFields = new SupportClass.Tokenizer(line);
                                int atomID = System.Int32.Parse(atomInfoFields.NextToken());
                                atoms[atomID] = System.Int32.Parse(atomInfoFields.NextToken());
                                //logger.debug("Set atomic number of atom (" + atomID + ") to: " + atoms[atomID]);
                            }
                        }
                        catch (System.Exception exception)
                        {
                            //logger.error("Error while reading Atoms block");
                            //logger.debug(exception);
                        }
                    }
                    else if ("!Bonds".Equals(command))
                    {
                        //logger.info("Reading bond block");
                        try
                        {
                            // determine number of bonds to read
                            numberOfBonds = System.Int32.Parse(st.NextToken());
                            bondatomid1   = new int[numberOfAtoms];
                            bondatomid2   = new int[numberOfAtoms];
                            bondorder     = new int[numberOfAtoms];

                            for (int i = 0; i < numberOfBonds; i++)
                            {
                                line = input.ReadLine();
                                SupportClass.Tokenizer bondInfoFields = new SupportClass.Tokenizer(line);
                                bondatomid1[i] = System.Int32.Parse(bondInfoFields.NextToken());
                                bondatomid2[i] = System.Int32.Parse(bondInfoFields.NextToken());
                                System.String order = bondInfoFields.NextToken();
                                if ("D".Equals(order))
                                {
                                    bondorder[i] = 2;
                                }
                                else if ("S".Equals(order))
                                {
                                    bondorder[i] = 1;
                                }
                                else if ("T".Equals(order))
                                {
                                    bondorder[i] = 3;
                                }
                                else
                                {
                                    // ignore order, i.e. set to single
                                    //logger.warn("Unrecognized bond order, using single bond instead. Found: " + order);
                                    bondorder[i] = 1;
                                }
                            }
                        }
                        catch (System.Exception exception)
                        {
                            //logger.error("Error while reading Bonds block");
                            //logger.debug(exception);
                        }
                    }
                    else if ("!Coord".Equals(command))
                    {
                        //logger.info("Reading coordinate block");
                        try
                        {
                            for (int i = 0; i < numberOfAtoms; i++)
                            {
                                line = input.ReadLine();
                                SupportClass.Tokenizer atomInfoFields = new SupportClass.Tokenizer(line);
                                int    atomID = System.Int32.Parse(atomInfoFields.NextToken());
                                double x      = System.Double.Parse(atomInfoFields.NextToken());
                                double y      = System.Double.Parse(atomInfoFields.NextToken());
                                double z      = System.Double.Parse(atomInfoFields.NextToken());
                                atomxs[atomID] = x;
                                atomys[atomID] = y;
                                atomzs[atomID] = z;
                            }
                        }
                        catch (System.Exception exception)
                        {
                            //logger.error("Error while reading Coord block");
                            //logger.debug(exception);
                        }
                    }
                    else if ("!Charges".Equals(command))
                    {
                        //logger.info("Reading charges block");
                        try
                        {
                            for (int i = 0; i < numberOfAtoms; i++)
                            {
                                line = input.ReadLine();
                                SupportClass.Tokenizer atomInfoFields = new SupportClass.Tokenizer(line);
                                int    atomID = System.Int32.Parse(atomInfoFields.NextToken());
                                double charge = System.Double.Parse(atomInfoFields.NextToken());
                                atomcharges[atomID] = charge;
                            }
                        }
                        catch (System.Exception exception)
                        {
                            //logger.error("Error while reading Charges block");
                            //logger.debug(exception);
                        }
                    }
                    else if ("!End".Equals(command))
                    {
                        //logger.info("Found end of file");
                        // Store atoms
                        IAtomContainer container = model.Builder.newAtomContainer();
                        for (int i = 0; i < numberOfAtoms; i++)
                        {
                            try
                            {
                                IAtom atom = model.Builder.newAtom(IsotopeFactory.getInstance(container.Builder).getElementSymbol(atoms[i]));
                                atom.AtomicNumber = atoms[i];
                                atom.setPoint3d(new Point3d(atomxs[i], atomys[i], atomzs[i]));
                                atom.setCharge(atomcharges[i]);
                                container.addAtom(atom);
                                //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
                                //logger.debug("Stored atom: " + atom);
                            }
                            catch (System.Exception exception)
                            {
                                //logger.error("Cannot create an atom with atomic number: " + atoms[i]);
                                //logger.debug(exception);
                            }
                        }

                        // Store bonds
                        for (int i = 0; i < numberOfBonds; i++)
                        {
                            container.addBond(bondatomid1[i], bondatomid2[i], bondorder[i]);
                        }

                        ISetOfMolecules moleculeSet = model.Builder.newSetOfMolecules();
                        moleculeSet.addMolecule(model.Builder.newMolecule(container));
                        model.SetOfMolecules = moleculeSet;

                        return(model);
                    }
                    else
                    {
                        //logger.warn("Skipping line: " + line);
                    }

                    line = input.ReadLine();
                }
            }
            catch (System.Exception exception)
            {
                //logger.error("Error while reading file");
                //logger.debug(exception);
            }

            // this should not happen, file is lacking !End command
            return(null);
        }
Ejemplo n.º 12
0
 /// <summary> Procedure required by the CDOInterface. This function is only
 /// supposed to be called by the JCFL library
 /// </summary>
 public virtual void endObject(System.String objectType)
 {
     //logger.debug("END: " + objectType);
     if (objectType.Equals("Molecule"))
     {
         if (currentMolecule is IMolecule)
         {
             //logger.debug("Adding molecule to set");
             currentSetOfMolecules.addMolecule((IMolecule)currentMolecule);
             //logger.debug("#mols in set: " + currentSetOfMolecules.MoleculeCount);
         }
         else if (currentMolecule is ICrystal)
         {
             //logger.debug("Adding crystal to chemModel");
             currentChemModel.Crystal = (ICrystal)currentMolecule;
             currentChemSequence.addChemModel(currentChemModel);
         }
     }
     else if (objectType.Equals("SetOfMolecules"))
     {
         currentChemModel.SetOfMolecules = currentSetOfMolecules;
         currentChemSequence.addChemModel(currentChemModel);
     }
     else if (objectType.Equals("Frame"))
     {
         // endObject("Molecule");
     }
     else if (objectType.Equals("Animation"))
     {
         addChemSequence(currentChemSequence);
         //logger.info("This file has " + ChemSequenceCount + " sequence(s).");
     }
     else if (objectType.Equals("Atom"))
     {
         currentMolecule.addAtom(currentAtom);
     }
     else if (objectType.Equals("Bond"))
     {
         //logger.debug("Bond(" + bond_id + "): " + bond_a1 + ", " + bond_a2 + ", " + bond_order);
         if (bond_a1 > currentMolecule.AtomCount || bond_a2 > currentMolecule.AtomCount)
         {
             //logger.error("Cannot add bond between at least one non-existant atom: " + bond_a1 + " and " + bond_a2);
         }
         else
         {
             IAtom a1 = currentMolecule.getAtomAt(bond_a1);
             IAtom a2 = currentMolecule.getAtomAt(bond_a2);
             IBond b  = currentChemFile.Builder.newBond(a1, a2, bond_order);
             if (bond_id != null)
             {
                 b.ID = bond_id;
             }
             if (bond_stereo != -99)
             {
                 b.Stereo = bond_stereo;
             }
             if (bond_order == CDKConstants.BONDORDER_AROMATIC)
             {
                 b.setFlag(CDKConstants.ISAROMATIC, true);
             }
             currentMolecule.addBond(b);
         }
     }
     else if (objectType.Equals("a-axis"))
     {
         // set these variables
         if (currentMolecule is ICrystal)
         {
             ICrystal current = (ICrystal)currentMolecule;
             current.A = new Vector3d(crystal_axis_x, crystal_axis_y, crystal_axis_z);
         }
         else
         {
             //logger.warn("Current object is not a crystal");
         }
     }
     else if (objectType.Equals("b-axis"))
     {
         if (currentMolecule is ICrystal)
         {
             ICrystal current = (ICrystal)currentMolecule;
             current.B = new Vector3d(crystal_axis_x, crystal_axis_y, crystal_axis_z);
         }
         else
         {
             //logger.warn("Current object is not a crystal");
         }
     }
     else if (objectType.Equals("c-axis"))
     {
         if (currentMolecule is ICrystal)
         {
             ICrystal current = (ICrystal)currentMolecule;
             current.C = new Vector3d(crystal_axis_x, crystal_axis_y, crystal_axis_z);
         }
         else
         {
             //logger.warn("Current object is not a crystal");
         }
     }
     else if (objectType.Equals("SetOfReactions"))
     {
         currentChemModel.SetOfReactions = currentSetOfReactions;
         currentChemSequence.addChemModel(currentChemModel);
         /* FIXME: this should be when document is closed! */
     }
     else if (objectType.Equals("Reaction"))
     {
         //logger.debug("Adding reaction to SOR");
         currentSetOfReactions.addReaction(currentReaction);
     }
     else if (objectType.Equals("Reactant"))
     {
         currentReaction.addReactant((IMolecule)currentMolecule);
     }
     else if (objectType.Equals("Product"))
     {
         currentReaction.addProduct((IMolecule)currentMolecule);
     }
     else if (objectType.Equals("Crystal"))
     {
         //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
         //logger.debug("Crystal: " + currentMolecule);
     }
 }
Ejemplo n.º 13
0
 /// <summary> Recursivly perfoms a depth first search in a molecular graphs contained in
 /// the AtomContainer molecule, starting at the root atom and returning when it
 /// hits the target atom.
 /// CAUTION: This recursive method sets the VISITED flag of each atom
 /// does not reset it after finishing the search. If you want to do the
 /// operation on the same collection of atoms more than once, you have
 /// to set all the VISITED flags to false before each operation
 /// by looping of the atoms and doing a
 /// "atom.setFlag((CDKConstants.VISITED, false));"
 /// 
 /// </summary>
 /// <param name="molecule">The
 /// AtomContainer to be searched
 /// </param>
 /// <param name="root">    The root atom
 /// to start the search at
 /// </param>
 /// <param name="target">  The target
 /// </param>
 /// <param name="path">    An
 /// AtomContainer to be filled with the path
 /// </param>
 /// <returns> true if the
 /// target atom was found during this function call
 /// </returns>
 public static bool depthFirstTargetSearch(IAtomContainer molecule, IAtom root, IAtom target, IAtomContainer path)
 {
     IBond[] bonds = molecule.getConnectedBonds(root);
     IAtom nextAtom;
     root.setFlag(CDKConstants.VISITED, true);
     for (int f = 0; f < bonds.Length; f++)
     {
         nextAtom = bonds[f].getConnectedAtom(root);
         if (!nextAtom.getFlag(CDKConstants.VISITED))
         {
             path.addAtom(nextAtom);
             path.addBond(bonds[f]);
             if (nextAtom == target)
             {
                 return true;
             }
             else
             {
                 if (!depthFirstTargetSearch(molecule, nextAtom, target, path))
                 {
                     // we did not find the target
                     path.removeAtom(nextAtom);
                     path.removeElectronContainer(bonds[f]);
                 }
                 else
                 {
                     return true;
                 }
             }
         }
     }
     return false;
 }
Ejemplo n.º 14
0
        //////////////////////////////////////
        //    Manipulation tools

        /// <summary>  Projects a list of RMap on a molecule
        ///
        /// </summary>
        /// <param name="rMapList"> the list to project
        /// </param>
        /// <param name="g">        the molecule on which project
        /// </param>
        /// <param name="id">       the id in the RMap of the molecule g
        /// </param>
        /// <returns>           an AtomContainer
        /// </returns>
        public static IAtomContainer project(System.Collections.IList rMapList, IAtomContainer g, int id)
        {
            IAtomContainer ac = g.Builder.newAtomContainer();

            IBond[] bondList = g.Bonds;

            System.Collections.Hashtable table = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
            IAtom a1;
            IAtom a2;
            IAtom a;
            IBond bond;

            //UPGRADE_TODO: Method 'java.util.Iterator.hasNext' was converted to 'System.Collections.IEnumerator.MoveNext' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilIteratorhasNext'"
            for (System.Collections.IEnumerator i = rMapList.GetEnumerator(); i.MoveNext();)
            {
                //UPGRADE_TODO: Method 'java.util.Iterator.next' was converted to 'System.Collections.IEnumerator.Current' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilIteratornext'"
                RMap rMap = (RMap)i.Current;
                if (id == UniversalIsomorphismTester.ID1)
                {
                    bond = bondList[rMap.Id1];
                }
                else
                {
                    bond = bondList[rMap.Id2];
                }

                a  = bond.getAtomAt(0);
                a1 = (IAtom)table[a];

                if (a1 == null)
                {
                    try
                    {
                        a1 = (IAtom)a.Clone();
                    }
                    //UPGRADE_NOTE: Exception 'java.lang.CloneNotSupportedException' was converted to 'System.Exception' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'"
                    catch (System.Exception e)
                    {
                        SupportClass.WriteStackTrace(e, Console.Error);
                    }
                    ac.addAtom(a1);
                    table[a] = a1;
                }

                a  = bond.getAtomAt(1);
                a2 = (IAtom)table[a];

                if (a2 == null)
                {
                    try
                    {
                        a2 = (IAtom)a.Clone();
                    }
                    //UPGRADE_NOTE: Exception 'java.lang.CloneNotSupportedException' was converted to 'System.Exception' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'"
                    catch (System.Exception e)
                    {
                        SupportClass.WriteStackTrace(e, Console.Error);
                    }
                    ac.addAtom(a2);
                    table[a] = a2;
                }
                IBond newBond = g.Builder.newBond(a1, a2, bond.Order);
                newBond.setFlag(CDKConstants.ISAROMATIC, bond.getFlag(CDKConstants.ISAROMATIC));
                ac.addBond(newBond);
            }
            return(ac);
        }
Ejemplo n.º 15
0
        /// <summary> Reads the atoms, coordinates and charges.
        /// 
        /// <p>IMPORTANT: it does not support the atom list and its negation!
        /// </summary>
        public virtual void readAtomBlock(IAtomContainer readData)
        {
            bool foundEND = false;
            while (Ready && !foundEND)
            {
                System.String command = readCommand();
                if ("END ATOM".Equals(command))
                {
                    // FIXME: should check wether 3D is really 2D
                    foundEND = true;
                }
                else
                {
                    //logger.debug("Parsing atom from: " + command);
                    SupportClass.Tokenizer tokenizer = new SupportClass.Tokenizer(command);
                    IAtom atom = readData.Builder.newAtom("C");
                    // parse the index
                    try
                    {
                        System.String indexString = tokenizer.NextToken();
                        atom.ID = indexString;
                    }
                    catch (System.Exception exception)
                    {
                        System.String error = "Error while parsing atom index";
                        //logger.error(error);
                        //logger.debug(exception);
                        throw new CDKException(error, exception);
                    }
                    // parse the element
                    System.String element = tokenizer.NextToken();
                    bool isElement = false;
                    try
                    {
                        isElement = IsotopeFactory.getInstance(atom.Builder).isElement(element);
                    }
                    catch (System.Exception exception)
                    {
                        throw new CDKException("Could not determine if element exists!", exception);
                    }
                    if (isPseudoAtom(element))
                    {
                        atom = readData.Builder.newPseudoAtom(atom);
                    }
                    else if (isElement)
                    {
                        atom.Symbol = element;
                    }
                    else
                    {
                        System.String error = "Cannot parse element of type: " + element;
                        //logger.error(error);
                        throw new CDKException("(Possible CDK bug) " + error);
                    }
                    // parse atom coordinates (in Angstrom)
                    try
                    {
                        System.String xString = tokenizer.NextToken();
                        System.String yString = tokenizer.NextToken();
                        System.String zString = tokenizer.NextToken();
                        double x = System.Double.Parse(xString);
                        double y = System.Double.Parse(yString);
                        double z = System.Double.Parse(zString);
                        atom.setPoint3d(new Point3d(x, y, z));
                        atom.setPoint2d(new Point2d(x, y)); // FIXME: dirty!
                    }
                    catch (System.Exception exception)
                    {
                        System.String error = "Error while parsing atom coordinates";
                        //logger.error(error);
                        //logger.debug(exception);
                        throw new CDKException(error, exception);
                    }
                    // atom-atom mapping
                    System.String mapping = tokenizer.NextToken();
                    if (!mapping.Equals("0"))
                    {
                        //logger.warn("Skipping atom-atom mapping: " + mapping);
                    } // else: default 0 is no mapping defined

                    // the rest are key value things
                    if (command.IndexOf("=") != -1)
                    {
                        System.Collections.Hashtable options = parseOptions(exhaustStringTokenizer(tokenizer));
                        System.Collections.IEnumerator keys = options.Keys.GetEnumerator();
                        //UPGRADE_TODO: Method 'java.util.Enumeration.hasMoreElements' was converted to 'System.Collections.IEnumerator.MoveNext' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilEnumerationhasMoreElements'"
                        while (keys.MoveNext())
                        {
                            //UPGRADE_TODO: Method 'java.util.Enumeration.nextElement' was converted to 'System.Collections.IEnumerator.Current' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilEnumerationnextElement'"
                            System.String key = (System.String)keys.Current;
                            System.String value_Renamed = (System.String)options[key];
                            try
                            {
                                if (key.Equals("CHG"))
                                {
                                    int charge = System.Int32.Parse(value_Renamed);
                                    if (charge != 0)
                                    {
                                        // zero is no charge specified
                                        atom.setFormalCharge(charge);
                                    }
                                }
                                else
                                {
                                    //logger.warn("Not parsing key: " + key);
                                }
                            }
                            catch (System.Exception exception)
                            {
                                //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
                                System.String error = "Error while parsing key/value " + key + "=" + value_Renamed + ": " + exception.Message;
                                //logger.error(error);
                                //logger.debug(exception);
                                throw new CDKException(error, exception);
                            }
                        }
                    }

                    // store atom
                    readData.addAtom(atom);
                    //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
                    //logger.debug("Added atom: " + atom);
                }
            }
        }
Ejemplo n.º 16
0
		/// <summary> Method that saturates an atom in a molecule by adding explicit hydrogens.
		/// 
		/// </summary>
		/// <param name="atom">     Atom to saturate
		/// </param>
		/// <param name="container">AtomContainer containing the atom
		/// </param>
		/// <param name="count">    Number of hydrogens to add
		/// </param>
		/// <param name="totalContainer">In case you have a container containing multiple structures, this is the total container, whereas container is a partial structure
		/// 
		/// </param>
		/// <cdk.keyword>           hydrogen, adding </cdk.keyword>
		/// <cdk.keyword>           explicit hydrogen </cdk.keyword>
		public virtual IAtomContainer addExplicitHydrogensToSatisfyValency(IAtomContainer container, IAtom atom, int count, IAtomContainer totalContainer)
		{
			//boolean create2DCoordinates = GeometryTools.has2DCoordinates(container);
			
			IIsotope isotope = IsotopeFactory.getInstance(container.Builder).getMajorIsotope("H");
			atom.setHydrogenCount(0);
			IAtomContainer changedAtomsAndBonds = container.Builder.newAtomContainer();
			for (int i = 1; i <= count; i++)
			{
				IAtom hydrogen = container.Builder.newAtom("H");
				IsotopeFactory.getInstance(container.Builder).configure(hydrogen, isotope);
				totalContainer.addAtom(hydrogen);
				IBond newBond = container.Builder.newBond((IAtom) atom, hydrogen, 1.0);
				totalContainer.addBond(newBond);
				changedAtomsAndBonds.addAtom(hydrogen);
				changedAtomsAndBonds.addBond(newBond);
			}
			return changedAtomsAndBonds;
		}
Ejemplo n.º 17
0
        /// <summary> Reads the atoms, coordinates and charges.
        ///
        /// <p>IMPORTANT: it does not support the atom list and its negation!
        /// </summary>
        public virtual void readAtomBlock(IAtomContainer readData)
        {
            bool foundEND = false;

            while (Ready && !foundEND)
            {
                System.String command = readCommand();
                if ("END ATOM".Equals(command))
                {
                    // FIXME: should check wether 3D is really 2D
                    foundEND = true;
                }
                else
                {
                    //logger.debug("Parsing atom from: " + command);
                    SupportClass.Tokenizer tokenizer = new SupportClass.Tokenizer(command);
                    IAtom atom = readData.Builder.newAtom("C");
                    // parse the index
                    try
                    {
                        System.String indexString = tokenizer.NextToken();
                        atom.ID = indexString;
                    }
                    catch (System.Exception exception)
                    {
                        System.String error = "Error while parsing atom index";
                        //logger.error(error);
                        //logger.debug(exception);
                        throw new CDKException(error, exception);
                    }
                    // parse the element
                    System.String element   = tokenizer.NextToken();
                    bool          isElement = false;
                    try
                    {
                        isElement = IsotopeFactory.getInstance(atom.Builder).isElement(element);
                    }
                    catch (System.Exception exception)
                    {
                        throw new CDKException("Could not determine if element exists!", exception);
                    }
                    if (isPseudoAtom(element))
                    {
                        atom = readData.Builder.newPseudoAtom(atom);
                    }
                    else if (isElement)
                    {
                        atom.Symbol = element;
                    }
                    else
                    {
                        System.String error = "Cannot parse element of type: " + element;
                        //logger.error(error);
                        throw new CDKException("(Possible CDK bug) " + error);
                    }
                    // parse atom coordinates (in Angstrom)
                    try
                    {
                        System.String xString = tokenizer.NextToken();
                        System.String yString = tokenizer.NextToken();
                        System.String zString = tokenizer.NextToken();
                        double        x       = System.Double.Parse(xString);
                        double        y       = System.Double.Parse(yString);
                        double        z       = System.Double.Parse(zString);
                        atom.setPoint3d(new Point3d(x, y, z));
                        atom.setPoint2d(new Point2d(x, y)); // FIXME: dirty!
                    }
                    catch (System.Exception exception)
                    {
                        System.String error = "Error while parsing atom coordinates";
                        //logger.error(error);
                        //logger.debug(exception);
                        throw new CDKException(error, exception);
                    }
                    // atom-atom mapping
                    System.String mapping = tokenizer.NextToken();
                    if (!mapping.Equals("0"))
                    {
                        //logger.warn("Skipping atom-atom mapping: " + mapping);
                    } // else: default 0 is no mapping defined

                    // the rest are key value things
                    if (command.IndexOf("=") != -1)
                    {
                        System.Collections.Hashtable   options = parseOptions(exhaustStringTokenizer(tokenizer));
                        System.Collections.IEnumerator keys    = options.Keys.GetEnumerator();
                        //UPGRADE_TODO: Method 'java.util.Enumeration.hasMoreElements' was converted to 'System.Collections.IEnumerator.MoveNext' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilEnumerationhasMoreElements'"
                        while (keys.MoveNext())
                        {
                            //UPGRADE_TODO: Method 'java.util.Enumeration.nextElement' was converted to 'System.Collections.IEnumerator.Current' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilEnumerationnextElement'"
                            System.String key           = (System.String)keys.Current;
                            System.String value_Renamed = (System.String)options[key];
                            try
                            {
                                if (key.Equals("CHG"))
                                {
                                    int charge = System.Int32.Parse(value_Renamed);
                                    if (charge != 0)
                                    {
                                        // zero is no charge specified
                                        atom.setFormalCharge(charge);
                                    }
                                }
                                else
                                {
                                    //logger.warn("Not parsing key: " + key);
                                }
                            }
                            catch (System.Exception exception)
                            {
                                //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
                                System.String error = "Error while parsing key/value " + key + "=" + value_Renamed + ": " + exception.Message;
                                //logger.error(error);
                                //logger.debug(exception);
                                throw new CDKException(error, exception);
                            }
                        }
                    }

                    // store atom
                    readData.addAtom(atom);
                    //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
                    //logger.debug("Added atom: " + atom);
                }
            }
        }
Ejemplo n.º 18
0
        /// <summary> Reads a set of coordinates into ChemModel.
        ///
        /// </summary>
        /// <param name="model">the destination ChemModel
        /// </param>
        /// <throws>  IOException if an I/O error occurs </throws>
        private void readCoordinates(IChemModel model)
        {
            IAtomContainer container = model.Builder.newAtomContainer();

            System.String line = input.ReadLine();
            line = input.ReadLine();
            line = input.ReadLine();
            line = input.ReadLine();
            while (input.Peek() != -1)
            {
                line = input.ReadLine();
                if ((line == null) || (line.IndexOf("-----") >= 0))
                {
                    break;
                }
                int atomicNumber          = 0;
                System.IO.StringReader sr = new System.IO.StringReader(line);
                SupportClass.StreamTokenizerSupport token = new SupportClass.StreamTokenizerSupport(sr);
                token.NextToken();

                // ignore first token
                if (token.NextToken() == SupportClass.StreamTokenizerSupport.TT_NUMBER)
                {
                    //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'"
                    atomicNumber = (int)token.nval;
                    if (atomicNumber == 0)
                    {
                        // Skip dummy atoms. Dummy atoms must be skipped
                        // if frequencies are to be read because Gaussian
                        // does not report dummy atoms in frequencies, and
                        // the number of atoms is used for reading frequencies.
                        continue;
                    }
                }
                else
                {
                    throw new System.IO.IOException("Error reading coordinates");
                }
                token.NextToken();

                // ignore third token
                double x = 0.0;
                double y = 0.0;
                double z = 0.0;
                if (token.NextToken() == SupportClass.StreamTokenizerSupport.TT_NUMBER)
                {
                    x = token.nval;
                }
                else
                {
                    throw new System.IO.IOException("Error reading coordinates");
                }
                if (token.NextToken() == SupportClass.StreamTokenizerSupport.TT_NUMBER)
                {
                    y = token.nval;
                }
                else
                {
                    throw new System.IO.IOException("Error reading coordinates");
                }
                if (token.NextToken() == SupportClass.StreamTokenizerSupport.TT_NUMBER)
                {
                    z = token.nval;
                }
                else
                {
                    throw new System.IO.IOException("Error reading coordinates");
                }
                System.String symbol = "Du";
                try
                {
                    symbol = IsotopeFactory.getInstance(model.Builder).getElementSymbol(atomicNumber);
                }
                catch (System.Exception exception)
                {
                    throw new CDKException("Could not determine element symbol!", exception);
                }
                IAtom atom = model.Builder.newAtom(symbol);
                atom.setPoint3d(new Point3d(x, y, z));
                container.addAtom(atom);
            }
            ISetOfMolecules moleculeSet = model.Builder.newSetOfMolecules();

            moleculeSet.addMolecule(model.Builder.newMolecule(container));
            model.SetOfMolecules = moleculeSet;
        }