* @cdk.bug 1095690 **/ public class CDKBugTaglet implements Taglet { private static final String NAME = "cdk.bug"; public String getName() { return NAME; } public boolean inField() { return false; } public boolean inConstructor() { return false; } public boolean inMethod() { return false; } public boolean inOverview() { return false; } public boolean inPackage() { return false; } public boolean inType() { return true; } public boolean isInlineTag() { return false; } public static void register(Map
* This class does nothing {@cdk.cite NULL}.
*
* For this code a reference is created like this:
* * NULL ** *
Citations can be singular, like The known dictionaries are:
* {@cdk.cite BLA},
* and multiple, like {@cdk.cite BLA,BLA2,FOO}.
*/
public class CDKCiteTaglet implements Taglet {
private static final String NAME = "cdk.cite";
private static BibTeXMLFile bibtex = null;
static {
try {
Builder parser = new Builder();
Document doc = parser.build(new File("doc/refs/cheminf.bibx"));
bibtex = new BibTeXMLFile(doc.getRootElement());
} catch (Exception exc) {
System.out.println("Horrible problem: " + exc.getMessage());
exc.printStackTrace();
}
}
public String getName() {
return NAME;
}
public boolean inField() {
return true;
}
public boolean inConstructor() {
return true;
}
public boolean inMethod() {
return true;
}
public boolean inOverview() {
return true;
}
public boolean inPackage() {
return true;
}
public boolean inType() {
return true;
}
public boolean isInlineTag() {
return true;
}
public static void register(Map
* @cdk.dictref blue-obelisk:graphPartitioning
*
*
*
*
*/
public class CDKDictRefTaglet implements Taglet {
private static final String NAME = "cdk.dictref";
private static final Map
The syntax must be as follows: *
* @cdk.githash **/ public class CDKGitTaglet implements Taglet { private static final String NAME = "cdk.githash"; private final static Pattern pathPattern = Pattern.compile(".*/(src/.*\\.java)"); public String getName() { return NAME; } public boolean inField() { return false; } public boolean inConstructor() { return false; } public boolean inMethod() { return false; } public boolean inOverview() { return false; } public boolean inPackage() { return false; } public boolean inType() { return true; } public boolean isInlineTag() { return false; } public static void register(Map
* @cdk.inchi InChI=1/CH4/h1H4 **/ public class CDKInChITaglet implements Taglet { private static final String NAME = "cdk.inchi"; public String getName() { return NAME; } public boolean inField() { return false; } public boolean inConstructor() { return false; } public boolean inMethod() { return true; } public boolean inOverview() { return false; } public boolean inPackage() { return false; } public boolean inType() { return true; } public boolean isInlineTag() { return false; } public static void register(Map
* @cdk.threadnonsafe **/ public class CDKThreadNonSafeTaglet implements Taglet { private static final String NAME = "cdk.threadnonsafe"; public String getName() { return NAME; } public boolean inField() { return false; } public boolean inConstructor() { return false; } public boolean inMethod() { return true; } public boolean inOverview() { return false; } public boolean inPackage() { return false; } public boolean inType() { return true; } public boolean isInlineTag() { return false; } public static void register(Map
* @cdk.threadsafe **/ public class CDKThreadSafeTaglet implements Taglet { private static final String NAME = "cdk.threadsafe"; public String getName() { return NAME; } public boolean inField() { return false; } public boolean inConstructor() { return false; } public boolean inMethod() { return true; } public boolean inOverview() { return false; } public boolean inPackage() { return false; } public boolean inType() { return true; } public boolean isInlineTag() { return false; } public static void register(Map
An Atom class is instantiated with at least the atom symbol: *
* Atom a = new Atom("C");
*
*
* Once instantiated all field not filled by passing parameters * to the constructor are null. Atoms can be configured by using * the IsotopeFactory.configure() method: *
* IsotopeFactory if = IsotopeFactory.getInstance(a.getBuilder()); * if.configure(a); ** *
More examples about using this class can be found in the * Junit test for this class. * * @cdk.module data * @cdk.githash * * @author steinbeck * @cdk.created 2000-10-02 * @cdk.keyword atom * * @see org.openscience.cdk.config.IsotopeFactory#getInstance(org.openscience.cdk.interfaces.IChemObjectBuilder) */ public class Atom extends AtomType implements IAtom, Serializable, Cloneable { /* Let's keep this exact specification * of what kind of point2d we're talking of here, * since there are so many around in the java standard api */ /** * Determines if a de-serialized object is compatible with this class. * * This value must only be changed if and only if the new version * of this class is incompatible with the old version. See Sun docs * for details. */ private static final long serialVersionUID = -3137373012494608794L; /** * A 2D point specifying the location of this atom in a 2D coordinate * space. */ protected javax.vecmath.Point2d point2d = (Point2d) CDKConstants.UNSET; /** * A 3 point specifying the location of this atom in a 3D coordinate * space. */ protected javax.vecmath.Point3d point3d = (Point3d) CDKConstants.UNSET; /** * A 3 point specifying the location of this atom in a crystal unit cell. */ protected javax.vecmath.Point3d fractionalPoint3d = (Point3d) CDKConstants.UNSET; /** * The number of implicitly bound hydrogen atoms for this atom. */ protected Integer hydrogenCount = (Integer) CDKConstants.UNSET; /** * A stereo parity descriptor for the stereochemistry of this atom. */ protected Integer stereoParity = (Integer) CDKConstants.UNSET; /** * The partial charge of the atom. * * The default value is {@link CDKConstants#UNSET} and serves to provide a check whether the charge has been * set or not */ protected Double charge = (Double) CDKConstants.UNSET; /** * Constructs an completely unset Atom. */ public Atom() { super((String)null); } /** * Constructs an Atom from a String containing an element symbol. * * @param elementSymbol The String describing the element for the Atom */ public Atom(String elementSymbol) { super(elementSymbol); } /** * Constructs an Atom from an Element and a Point3d. * * @param elementSymbol The symbol of the atom * @param point3d The 3D coordinates of the atom */ public Atom(String elementSymbol, javax.vecmath.Point3d point3d) { this(elementSymbol); this.point3d = point3d; } /** * Constructs an Atom from an Element and a Point2d. * * @param elementSymbol The Element * @param point2d The Point */ public Atom(String elementSymbol, javax.vecmath.Point2d point2d) { this(elementSymbol); this.point2d = point2d; } /** * Constructs an isotope by copying the symbol, atomic number, * flags, identifier, exact mass, natural abundance, mass * number, maximum bond order, bond order sum, van der Waals * and covalent radii, formal charge, hybridization, electron * valency, formal neighbour count and atom type name from the * given IAtomType. It does not copy the listeners and * properties. If the element is an instanceof * IAtom, then the 2D, 3D and fractional coordinates, partial * atomic charge, hydrogen count and stereo parity are copied * too. * * @param element IAtomType to copy information from */ public Atom(IElement element) { super(element); if (element instanceof IAtom) { if (((IAtom)element).getPoint2d() != null) { this.point2d = new Point2d(((IAtom)element).getPoint2d()); } else { this.point2d = null; } if (((IAtom)element).getPoint3d() != null) { this.point3d = new Point3d(((IAtom)element).getPoint3d()); } else { this.point3d = null; } if (((IAtom)element).getFractionalPoint3d() != null) { this.fractionalPoint3d = new Point3d(((IAtom)element).getFractionalPoint3d()); } else { this.fractionalPoint3d = null; } this.hydrogenCount = ((IAtom)element).getHydrogenCount(); this.charge = ((IAtom)element).getCharge(); this.stereoParity = ((IAtom)element).getStereoParity(); } } /** * Sets the partial charge of this atom. * * @param charge The partial charge * * @see #getCharge */ public void setCharge(Double charge) { this.charge = charge; notifyChanged(); } /** * Returns the partial charge of this atom. * * If the charge has not been set the return value is Double.NaN * * @return the charge of this atom * * @see #setCharge */ public Double getCharge() { return this.charge; } /** * Sets the number of implicit hydrogen count of this atom. * * @param hydrogenCount The number of hydrogen atoms bonded to this atom. * * @see #getHydrogenCount */ public void setHydrogenCount(Integer hydrogenCount) { this.hydrogenCount = hydrogenCount; notifyChanged(); } /** * Returns the hydrogen count of this atom. * * @return The hydrogen count of this atom. * * @see #setHydrogenCount */ public Integer getHydrogenCount() { return this.hydrogenCount; } /** * * Sets a point specifying the location of this * atom in a 2D space. * * @param point2d A point in a 2D plane * * @see #getPoint2d */ public void setPoint2d(javax.vecmath.Point2d point2d) { this.point2d = point2d; notifyChanged(); } /** * * Sets a point specifying the location of this * atom in 3D space. * * @param point3d A point in a 3-dimensional space * * @see #getPoint3d */ public void setPoint3d(javax.vecmath.Point3d point3d) { this.point3d = point3d; notifyChanged(); } /** * Sets a point specifying the location of this * atom in a Crystal unit cell. * * @param point3d A point in a 3d fractional unit cell space * * @see #getFractionalPoint3d * @see org.openscience.cdk.Crystal */ public void setFractionalPoint3d(javax.vecmath.Point3d point3d) { this.fractionalPoint3d = point3d; notifyChanged(); } /** * Sets the stereo parity for this atom. * * @param stereoParity The stereo parity for this atom * * @see org.openscience.cdk.CDKConstants for predefined values. * @see #getStereoParity */ public void setStereoParity(Integer stereoParity) { this.stereoParity = stereoParity; notifyChanged(); } /** * Returns a point specifying the location of this * atom in a 2D space. * * @return A point in a 2D plane. Null if unset. * * @see #setPoint2d */ public javax.vecmath.Point2d getPoint2d() { return this.point2d; } /** * Returns a point specifying the location of this * atom in a 3D space. * * @return A point in 3-dimensional space. Null if unset. * * @see #setPoint3d */ public javax.vecmath.Point3d getPoint3d() { return this.point3d; } /** * Returns a point specifying the location of this * atom in a Crystal unit cell. * * @return A point in 3d fractional unit cell space. Null if unset. * * @see #setFractionalPoint3d * @see org.openscience.cdk.CDKConstants for predefined values. */ public javax.vecmath.Point3d getFractionalPoint3d() { return this.fractionalPoint3d; } /** * Returns the stereo parity of this atom. It uses the predefined values * found in CDKConstants. * * @return The stereo parity for this atom * * @see org.openscience.cdk.CDKConstants * @see #setStereoParity */ public Integer getStereoParity() { return this.stereoParity; } /** * Compares a atom with this atom. * * @param object of type Atom * @return true, if the atoms are equal */ public boolean compare(Object object) { if (!(object instanceof IAtom)) { return false; } if (!super.compare(object)) { return false; } Atom atom = (Atom) object; if (((point2d==atom.point2d) || ((point2d!=null) && (point2d.equals(atom.point2d)))) && ((point3d==atom.point3d) || ((point3d!=null) && (point3d.equals(atom.point3d)))) && (hydrogenCount==atom.hydrogenCount) && (stereoParity==atom.stereoParity) && (charge==atom.charge)) { return true; } return false; } /** * Returns a one line string representation of this Atom. * Methods is conform RFC #9. * * @return The string representation of this Atom */ public String toString() { StringBuffer stringContent = new StringBuffer(64); stringContent.append("Atom(").append(hashCode()); if (getSymbol() != null) { stringContent.append(", S:").append(getSymbol()); } if (getHydrogenCount() != null) { stringContent.append(", H:").append(getHydrogenCount()); } if (getStereoParity() != null) { stringContent.append(", SP:").append(getStereoParity()); } if (getPoint2d() != null) { stringContent.append(", 2D:[").append(getPoint2d()).append(']'); } if (getPoint3d() != null) { stringContent.append(", 3D:[").append(getPoint3d()).append(']'); } if (getFractionalPoint3d() != null) { stringContent.append(", F3D:[").append(getFractionalPoint3d()); } if (getCharge() != null) { stringContent.append(", C:").append(getCharge()); } stringContent.append(", ").append(super.toString()); stringContent.append(')'); return stringContent.toString(); } /** * Clones this atom object and its content. * * @return The cloned object */ public Object clone() throws CloneNotSupportedException { Object clone = super.clone(); if (point2d != null) { ((Atom)clone).setPoint2d(new Point2d(point2d.x, point2d.y)); } if (point3d != null) { ((Atom)clone).setPoint3d(new Point3d(point3d.x, point3d.y, point3d.z)); } if (fractionalPoint3d != null) { ((Atom)clone).setFractionalPoint3d(new Point3d(fractionalPoint3d.x, fractionalPoint3d.y, fractionalPoint3d.z)); } return clone; } } cdk-1.2.10/src/main/org/openscience/cdk/AtomContainer.java 100644 0 0 133731 11570154753 20507 0 ustar 0 0 /* $RCSfile$ * $Author$ * $Date$ * $Revision$ * * Copyright (C) 1997-2007 Christoph Steinbeck * * Contact: cdk-devel@lists.sourceforge.net * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2.1 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */ package org.openscience.cdk; import java.io.Serializable; import java.util.ArrayList; import java.util.Hashtable; import java.util.Iterator; import java.util.List; import java.util.Map; import org.openscience.cdk.interfaces.IAtom; import org.openscience.cdk.interfaces.IAtomContainer; import org.openscience.cdk.interfaces.IAtomParity; import org.openscience.cdk.interfaces.IBond; import org.openscience.cdk.interfaces.IChemObjectChangeEvent; import org.openscience.cdk.interfaces.IChemObjectListener; import org.openscience.cdk.interfaces.IElectronContainer; import org.openscience.cdk.interfaces.ILonePair; import org.openscience.cdk.interfaces.ISingleElectron; import org.openscience.cdk.interfaces.IBond.Order; /** * Base class for all chemical objects that maintain a list of Atoms and * ElectronContainers.
* * Looping over all Bonds in the AtomContainer is typically done like:
* Iterator iter = atomContainer.bonds();
* while (iter.hasNext()) {
* IBond aBond = (IBond) iter.next();
* }
*
*
*
* @cdk.module data
* @cdk.githash
*
* @author steinbeck
* @cdk.created 2000-10-02
*/
public class AtomContainer extends ChemObject
implements IAtomContainer, IChemObjectListener, Serializable, Cloneable {
/**
* Determines if a de-serialized object is compatible with this class.
*
* This value must only be changed if and only if the new version
* of this class is incompatible with the old version. See Sun docs
* for details.
*/
private static final long serialVersionUID = 5678100348445919254L;
/**
* Number of atoms contained by this object.
*/
protected int atomCount;
/**
* Number of bonds contained by this object.
*/
protected int bondCount;
/**
* Number of lone pairs contained by this object.
*/
protected int lonePairCount;
/**
* Number of single electrons contained by this object.
*/
protected int singleElectronCount;
/**
* Amount by which the bond and atom arrays grow when elements are added and
* the arrays are not large enough for that.
*/
protected int growArraySize = 10;
/**
* Internal array of atoms.
*/
protected IAtom[] atoms;
/**
* Internal array of bonds.
*/
protected IBond[] bonds;
/**
* Internal array of lone pairs.
*/
protected ILonePair[] lonePairs;
/**
* Internal array of single electrons.
*/
protected ISingleElectron[] singleElectrons;
/**
* Internal list of atom parities.
*/
protected Mapnumber in [0,..].
*
*@param number The position of the atom to be set.
*@param atom The atom to be stored at position number
*@see #getAtom(int)
*/
public void setAtom(int number, IAtom atom)
{
atom.addListener(this);
atoms[number] = atom;
notifyChanged();
}
/**
* Get the atom at position number in [0,..].
*
*@param number The position of the atom to be retrieved.
*@return The atomAt value
* @see #setAtom(int, org.openscience.cdk.interfaces.IAtom)
* @see #setAtoms(org.openscience.cdk.interfaces.IAtom[])
*
*/
public IAtom getAtom(int number)
{
return atoms[number];
}
/**
* Get the bond at position number in [0,..].
*
*@param number The position of the bond to be retrieved.
*@return The bondAt value
*/
public IBond getBond(int number)
{
return bonds[number];
}
/**
* Get the lone pair at position number in [0,..].
*
*@param number The position of the LonePair to be retrieved.
*@return The lone pair number
*/
public ILonePair getLonePair(int number)
{
return lonePairs[number];
}
/**
* Get the single electron at position number in [0,..].
*
*@param number The position of the SingleElectron to be retrieved.
*@return The single electron number
*/
public ISingleElectron getSingleElectron(int number)
{
return singleElectrons[number];
}
/**
* Sets the ElectronContainer at position number in [0,..].
*
* @param number The position of the ElectronContainer to be set.
* @param electronContainer The ElectronContainer to be stored at position number
* @see #getElectronContainer(int)
*/
// public void setElectronContainer(int number, IElectronContainer electronContainer)
// {
// electronContainer.addListener(this);
// electronContainers[number] = electronContainer;
// notifyChanged();
// }
/**
* Sets the number of electronContainers in this container.
*
* @param electronContainerCount The number of electronContainers in this
* container
* @see #getElectronContainerCount
*/
// public void setElectronContainerCount(int electronContainerCount)
// {
// this.electronContainerCount = electronContainerCount;
// notifyChanged();
// }
/**
* Sets the number of atoms in this container.
*
*@param atomCount The number of atoms in this container
*@see #getAtomCount
*/
// public void setAtomCount(int atomCount)
// {
// this.atomCount = atomCount;
// notifyChanged();
// }
/**
* Returns an Iterable for looping over all atoms in this container.
*
*@return An Iterable with the atoms in this container
*/
public Iterablenumber in the
* container.
*
* @param number The position of the ElectronContainer to be returned.
* @return The ElectronContainer at position number.
*/
public IElectronContainer getElectronContainer(int number)
{
if (number < this.bondCount) return bonds[number];
number -= this.bondCount;
if (number < this.lonePairCount) return lonePairs[number];
number -= this.lonePairCount;
if (number < this.singleElectronCount) return singleElectrons[number];
return null;
}
/**
* Returns the bond that connects the two given atoms.
*
* @param atom1 The first atom
* @param atom2 The second atom
* @return The bond that connects the two atoms
*/
public IBond getBond(IAtom atom1, IAtom atom2)
{
for (int i = 0; i < getBondCount(); i++)
{
if (bonds[i].contains(atom1) &&
bonds[i].getConnectedAtom(atom1) == atom2) {
return bonds[i];
}
}
return null;
}
/**
* Returns the number of Atoms in this Container.
*
*@return The number of Atoms in this Container
*/
public int getAtomCount()
{
return this.atomCount;
}
/**
* Returns the number of Bonds in this Container.
*
*@return The number of Bonds in this Container
*/
public int getBondCount()
{
return this.bondCount;
}
/**
* Returns the number of LonePairs in this Container.
*
*@return The number of LonePairs in this Container
*/
public int getLonePairCount()
{
return this.lonePairCount;
}
/**
* Returns the number of the single electrons in this container,
*
*@return The number of SingleElectron objects of this AtomContainer
*/
public int getSingleElectronCount()
{
return this.singleElectronCount;
}
/**
* Returns the number of ElectronContainers in this Container.
*
* @return The number of ElectronContainers in this Container
*/
public int getElectronContainerCount()
{
return this.bondCount + this.lonePairCount + this.singleElectronCount;
}
/**
* Returns an ArrayList of all atoms connected to the given atom.
*
*@param atom The atom the bond partners are searched of.
*@return The ArrayList with the connected atoms
*/
public ListAtomContainerManipulator#getBondOrderSum(IAtomContainer, IAtom)
*/
public double getBondOrderSum(IAtom atom)
{
double count = 0;
for (int i = 0; i < bondCount; i++)
{
if (bonds[i].contains(atom)) {
if (bonds[i].getOrder() == IBond.Order.SINGLE) {
count += 1;
} else if (bonds[i].getOrder() == IBond.Order.DOUBLE) {
count += 2;
} else if (bonds[i].getOrder() == IBond.Order.TRIPLE) {
count += 3;
} else if (bonds[i].getOrder() == IBond.Order.QUADRUPLE) {
count += 4;
}
}
}
return count;
}
/**
* Returns the maximum bond order that this atom currently has in the context
* of this AtomContainer.
*
* @param atom The atom
* @return The maximum bond order that this atom currently has
*/
public Order getMaximumBondOrder(IAtom atom) {
IBond.Order max = IBond.Order.SINGLE;
for (int i = 0; i < bondCount; i++) {
if (bonds[i].contains(atom) &&
bonds[i].getOrder().ordinal() > max.ordinal()) {
max = bonds[i].getOrder();
}
}
return max;
}
/**
* Returns the minimum bond order that this atom currently has in the context
* of this AtomContainer.
*
*@param atom The atom
*@return The minimum bond order that this atom currently has
*/
public Order getMinimumBondOrder(IAtom atom)
{
IBond.Order min = IBond.Order.QUADRUPLE;
for (int i = 0; i < bondCount; i++) {
if (bonds[i].contains(atom) &&
bonds[i].getOrder().ordinal() < min.ordinal()) {
min = bonds[i].getOrder();
}
}
return min;
}
/**
* Adds all atoms and electronContainers of a given atomcontainer to this
* container.
*
*@param atomContainer The atomcontainer to be added
*/
public void add(IAtomContainer atomContainer)
{
for (int f = 0; f < atomContainer.getAtomCount(); f++)
{
if (!contains(atomContainer.getAtom(f)))
{
addAtom(atomContainer.getAtom(f));
}
}
for (int f = 0; f < atomContainer.getBondCount(); f++)
{
if (!contains(atomContainer.getBond(f)))
{
addBond(atomContainer.getBond(f));
}
}
for (int f = 0; f < atomContainer.getLonePairCount(); f++)
{
if (!contains(atomContainer.getLonePair(f)))
{
addLonePair(atomContainer.getLonePair(f));
}
}
for (int f = 0; f < atomContainer.getSingleElectronCount(); f++)
{
if (!contains(atomContainer.getSingleElectron(f)))
{
addSingleElectron(atomContainer.getSingleElectron(f));
}
}
notifyChanged();
}
/**
* Adds the ElectronContainers found in atomContainer to this
* container.
*
*@param atomContainer AtomContainer with the new ElectronContainers
*/
// public void addElectronContainers(IAtomContainer atomContainer)
// {
//
// notifyChanged();
// }
/**
* Adds an atom to this container.
*
*@param atom The atom to be added to this container
*/
public void addAtom(IAtom atom)
{
if (contains(atom))
{
return;
}
if (atomCount + 1 >= atoms.length)
{
growAtomArray();
}
atom.addListener(this);
atoms[atomCount] = atom;
atomCount++;
notifyChanged();
}
/**
* Adds a Bond to this AtomContainer.
*
*@param bond The bond to added to this container
*/
public void addBond(IBond bond)
{
if (bondCount >= bonds.length) growBondArray();
bonds[bondCount] = bond;
++bondCount;
notifyChanged();
}
/**
* Adds a lone pair to this AtomContainer.
*
*@param lonePair The LonePair to added to this container
*/
public void addLonePair(ILonePair lonePair)
{
if (lonePairCount >= lonePairs.length) growLonePairArray();
lonePairs[lonePairCount] = lonePair;
++lonePairCount;
notifyChanged();
}
/**
* Adds a single electron to this AtomContainer.
*
*@param singleElectron The SingleElectron to added to this container
*/
public void addSingleElectron(ISingleElectron singleElectron)
{
if (singleElectronCount >= singleElectrons.length) growSingleElectronArray();
singleElectrons[singleElectronCount] = singleElectron;
++singleElectronCount;
notifyChanged();
}
/**
* Adds a ElectronContainer to this AtomContainer.
*
*@param electronContainer The ElectronContainer to added to this container
*/
public void addElectronContainer(IElectronContainer electronContainer)
{
if (electronContainer instanceof IBond) this.addBond((IBond)electronContainer);
if (electronContainer instanceof ILonePair) this.addLonePair((ILonePair)electronContainer);
if (electronContainer instanceof ISingleElectron) this.addSingleElectron((ISingleElectron)electronContainer);
}
/**
* Removes all atoms and electronContainers of a given atomcontainer from this
* container.
*
*@param atomContainer The atomcontainer to be removed
*/
public void remove(IAtomContainer atomContainer)
{
for (int f = 0; f < atomContainer.getAtomCount(); f++)
{
removeAtom(atomContainer.getAtom(f));
}
for (int f = 0; f < atomContainer.getBondCount(); f++)
{
removeBond(atomContainer.getBond(f));
}
for (int f = 0; f < atomContainer.getLonePairCount(); f++)
{
removeLonePair(atomContainer.getLonePair(f));
}
for (int f = 0; f < atomContainer.getSingleElectronCount(); f++)
{
removeSingleElectron(atomContainer.getSingleElectron(f));
}
}
/**
* Removes the atom at the given position from the AtomContainer. Note that
* the electronContainers are unaffected: you also have to take care of
* removing all electronContainers to this atom from the container manually.
*
*@param position The position of the atom to be removed.
*/
public void removeAtom(int position)
{
atoms[position].removeListener(this);
for (int i = position; i < atomCount - 1; i++)
{
atoms[i] = atoms[i + 1];
}
atoms[atomCount - 1] = null;
atomCount--;
notifyChanged();
}
/**
* Removes the given atom from the AtomContainer. Note that the
* electronContainers are unaffected: you also have to take care of removing
* all electronContainers to this atom from the container.
*
*@param atom The atom to be removed
*/
public void removeAtom(IAtom atom)
{
int position = getAtomNumber(atom);
if (position != -1)
{
removeAtom(position);
}
}
/**
* Removes the bond at the given position from the AtomContainer.
*
*@param position The position of the bond to be removed.
*/
public IBond removeBond(int position)
{
IBond bond = bonds[position];
bond.removeListener(this);
for (int i = position; i < bondCount - 1; i++)
{
bonds[i] = bonds[i + 1];
}
bonds[bondCount - 1] = null;
bondCount--;
notifyChanged();
return bond;
}
/**
* Removes the bond that connects the two given atoms.
*
* @param atom1 The first atom
* @param atom2 The second atom
* @return The bond that connects the two atoms
*/
public IBond removeBond(IAtom atom1, IAtom atom2)
{
int pos = getBondNumber(atom1, atom2);
IBond bond = null;
if (pos != -1) {
bond = bonds[pos];
removeBond(pos);
}
return bond;
}
/**
* Removes the bond from this container.
*
* @param bond The bond to be removed.
*/
public void removeBond(IBond bond)
{
int pos = getBondNumber(bond);
if (pos != -1) removeBond(pos);
}
/**
* Removes the lone pair at the given position from the AtomContainer.
*
*@param position The position of the LonePair to be removed.
*/
public ILonePair removeLonePair(int position)
{
ILonePair lp = lonePairs[position];
lp.removeListener(this);
for (int i = position; i < lonePairCount - 1; i++)
{
lonePairs[i] = lonePairs[i + 1];
}
lonePairs[lonePairCount - 1] = null;
lonePairCount--;
notifyChanged();
return lp;
}
/**
* Removes the lone pair from the AtomContainer.
*
*@param lonePair The LonePair to be removed.
*/
public void removeLonePair(ILonePair lonePair)
{
int pos = getLonePairNumber(lonePair);
if (pos != -1) removeLonePair(pos);
}
/**
* Removes the single electron at the given position from the AtomContainer.
*
*@param position The position of the SingleElectron to be removed.
*/
public ISingleElectron removeSingleElectron(int position)
{
ISingleElectron se = singleElectrons[position];
se.removeListener(this);
for (int i = position; i < singleElectronCount - 1; i++)
{
singleElectrons[i] = singleElectrons[i + 1];
}
singleElectrons[singleElectronCount - 1] = null;
singleElectronCount--;
notifyChanged();
return se;
}
/**
* Removes the single electron from the AtomContainer.
*
*@param singleElectron The SingleElectron to be removed.
*/
public void removeSingleElectron(ISingleElectron singleElectron)
{
int pos = getSingleElectronNumber(singleElectron);
if (pos != -1) removeSingleElectron(pos);
}
/**
* Removes the bond at the given position from this container.
*
* @param number The position of the bond in the electronContainers array
* @return Bond that was removed
*/
public IElectronContainer removeElectronContainer(int number)
{
if (number < this.bondCount) return removeBond(number);
number -= this.bondCount;
if (number < this.lonePairCount) return removeLonePair(number);
number -= this.lonePairCount;
if (number < this.singleElectronCount) return removeSingleElectron(number);
return null;
}
/**
* Removes this ElectronContainer from this container.
*
* @param electronContainer The electronContainer to be removed
*/
public void removeElectronContainer(IElectronContainer electronContainer) {
if (electronContainer instanceof IBond) removeBond((IBond) electronContainer);
else if (electronContainer instanceof ILonePair) removeLonePair((ILonePair) electronContainer);
else
if (electronContainer instanceof ISingleElectron) removeSingleElectron((ISingleElectron) electronContainer);
}
/**
* Removes the given atom and all connected electronContainers from the
* AtomContainer.
*
*@param atom The atom to be removed
*/
public void removeAtomAndConnectedElectronContainers(IAtom atom)
{
int position = getAtomNumber(atom);
if (position != -1)
{
for (int i = 0; i < bondCount; i++)
{
if (bonds[i].contains(atom)) {
removeBond(i);
--i;
}
}
for (int i = 0; i < lonePairCount; i++)
{
if (lonePairs[i].contains(atom)) {
removeLonePair(i);
--i;
}
}
for (int i = 0; i < singleElectronCount; i++)
{
if (singleElectrons[i].contains(atom)) {
removeSingleElectron(i);
--i;
}
}
removeAtom(position);
}
notifyChanged();
}
/**
* Removes all atoms and bond from this container.
*/
public void removeAllElements() {
removeAllElectronContainers();
for (int f = 0; f < getAtomCount(); f++) {
getAtom(f).removeListener(this);
}
atoms = new IAtom[growArraySize];
atomCount = 0;
notifyChanged();
}
/**
* Removes electronContainers from this container.
*/
public void removeAllElectronContainers()
{
removeAllBonds();
for (int f = 0; f < getLonePairCount(); f++) {
getLonePair(f).removeListener(this);
}
for (int f = 0; f < getSingleElectronCount(); f++) {
getSingleElectron(f).removeListener(this);
}
lonePairs = new ILonePair[growArraySize];
singleElectrons = new ISingleElectron[growArraySize];
lonePairCount = 0;
singleElectronCount = 0;
notifyChanged();
}
/**
* Removes all Bonds from this container.
*/
public void removeAllBonds() {
for (int f = 0; f < getBondCount(); f++) {
getBond(f).removeListener(this);
}
bonds = new IBond[growArraySize];
bondCount = 0;
notifyChanged();
}
/**
* Adds a bond to this container.
*
*@param atom1 Id of the first atom of the Bond in [0,..]
*@param atom2 Id of the second atom of the Bond in [0,..]
*@param order Bondorder
*@param stereo Stereochemical orientation
*/
public void addBond(int atom1, int atom2, IBond.Order order, int stereo)
{
IBond bond = getBuilder().newBond(getAtom(atom1), getAtom(atom2), order, stereo);
if (contains(bond))
{
return;
}
if (bondCount >= bonds.length)
{
growBondArray();
}
addBond(bond);
/* no notifyChanged() here because addBond(bond) does
it already */
}
/**
* Adds a bond to this container.
*
*@param atom1 Id of the first atom of the Bond in [0,..]
*@param atom2 Id of the second atom of the Bond in [0,..]
*@param order Bondorder
*/
public void addBond(int atom1, int atom2, IBond.Order order)
{
IBond bond = getBuilder().newBond(getAtom(atom1), getAtom(atom2), order);
if (bondCount >= bonds.length)
{
growBondArray();
}
addBond(bond);
/* no notifyChanged() here because addBond(bond) does
it already */
}
/**
* Adds a LonePair to this Atom.
*
*@param atomID The atom number to which the LonePair is added in [0,..]
*/
public void addLonePair(int atomID)
{
ILonePair lonePair = getBuilder().newLonePair(atoms[atomID]);
lonePair.addListener(this);
addLonePair(lonePair);
/* no notifyChanged() here because addElectronContainer() does
it already */
}
/**
* Adds a LonePair to this Atom.
*
*@param atomID The atom number to which the LonePair is added in [0,..]
*/
public void addSingleElectron(int atomID)
{
ISingleElectron singleElectron = getBuilder().newSingleElectron(atoms[atomID]);
singleElectron.addListener(this);
addSingleElectron(singleElectron);
/* no notifyChanged() here because addSingleElectron() does
it already */
}
/**
* True, if the AtomContainer contains the given atom object.
*
*@param atom the atom this AtomContainer is searched for
*@return true if the AtomContainer contains the given atom object
*/
public boolean contains(IAtom atom)
{
for (int i = 0; i < getAtomCount(); i++)
{
if (atom == atoms[i]) return true;
}
return false;
}
/**
* True, if the AtomContainer contains the given bond object.
*
*@param bond the bond this AtomContainer is searched for
*@return true if the AtomContainer contains the given bond object
*/
public boolean contains(IBond bond)
{
for (int i = 0; i < getBondCount(); i++)
{
if (bond == bonds[i]) return true;
}
return false;
}
/**
* True, if the AtomContainer contains the given LonePair object.
*
*@param lonePair the LonePair this AtomContainer is searched for
*@return true if the AtomContainer contains the given LonePair object
*/
public boolean contains(ILonePair lonePair)
{
for (int i = 0; i < getLonePairCount(); i++)
{
if (lonePair == lonePairs[i]) return true;
}
return false;
}
/**
* True, if the AtomContainer contains the given SingleElectron object.
*
*@param singleElectron the LonePair this AtomContainer is searched for
*@return true if the AtomContainer contains the given LonePair object
*/
public boolean contains(ISingleElectron singleElectron)
{
for (int i = 0; i < getSingleElectronCount(); i++)
{
if (singleElectron == singleElectrons[i]) return true;
}
return false;
}
/**
* True, if the AtomContainer contains the given ElectronContainer object.
*
*@param electronContainer ElectronContainer that is searched for
*@return true if the AtomContainer contains the given bond object
*/
public boolean contains(IElectronContainer electronContainer)
{
if (electronContainer instanceof IBond) return contains((IBond)electronContainer);
if (electronContainer instanceof ILonePair) return contains((ILonePair)electronContainer);
if (electronContainer instanceof ISingleElectron) return contains((SingleElectron)electronContainer);
return false;
}
/**
* Returns a one line string representation of this Container. This method is
* conform RFC #9.
*
*@return The string representation of this Container
*/
public String toString()
{
StringBuffer stringContent = new StringBuffer(64);
stringContent.append("AtomContainer(");
stringContent.append(this.hashCode());
if (getAtomCount() > 0) {
stringContent.append(", #A:").append(getAtomCount());
for (int i = 0; i < getAtomCount(); i++) {
stringContent.append(", ").append(getAtom(i).toString());
}
}
if (getBondCount() > 0) {
stringContent.append(", #B:").append(getBondCount());
for (int i = 0; i < getBondCount(); i++) {
stringContent.append(", ").append(getBond(i).toString());
}
}
if (getLonePairCount() > 0) {
stringContent.append(", #LP:").append(getLonePairCount());
for (int i = 0; i < getLonePairCount(); i++) {
stringContent.append(", ").append(getLonePair(i).toString());
}
}
if (getSingleElectronCount() > 0) {
stringContent.append(", #SE:").append(getSingleElectronCount());
for (int i = 0; i < getSingleElectronCount(); i++) {
stringContent.append(", ").append(getSingleElectron(i).toString());
}
}
if (atomParities.size() > 0) {
stringContent.append(", AP:[#").append(atomParities.size());
for (IAtomParity iAtomParity : atomParities.values()) {
stringContent.append(", ").append(iAtomParity.toString());
}
stringContent.append(']');
}
stringContent.append(')');
return stringContent.toString();
}
/**
* Clones this AtomContainer object and its content.
*
* @return The cloned object
* @see #shallowCopy
*/
public Object clone() throws CloneNotSupportedException {
IAtom[] newAtoms;
IAtomContainer clone = (IAtomContainer) super.clone();
// start from scratch
clone.removeAllElements();
// clone all atoms
for (int f = 0; f < getAtomCount(); f++) {
clone.addAtom((Atom) getAtom(f).clone());
}
// clone bonds
IBond bond;
IBond newBond;
for (int i = 0; i < getBondCount(); ++i) {
bond = getBond(i);
newBond = (IBond)bond.clone();
newAtoms = new IAtom[bond.getAtomCount()];
for (int j = 0; j < bond.getAtomCount(); ++j) {
newAtoms[j] = clone.getAtom(getAtomNumber(bond.getAtom(j)));
}
newBond.setAtoms(newAtoms);
clone.addBond(newBond);
}
ILonePair lp;
ILonePair newLp;
for (int i = 0; i < getLonePairCount(); ++i) {
lp = getLonePair(i);
newLp = (ILonePair)lp.clone();
if (lp.getAtom() != null) {
newLp.setAtom(clone.getAtom(getAtomNumber(lp.getAtom())));
}
clone.addLonePair(newLp);
}
ISingleElectron se;
ISingleElectron newSe;
for (int i = 0; i < getSingleElectronCount(); ++i) {
se = getSingleElectron(i);
newSe = (ISingleElectron)se.clone();
if (se.getAtom() != null) {
newSe.setAtom(clone.getAtom(getAtomNumber(se.getAtom())));
}
clone.addSingleElectron(newSe);
}
// for (int f = 0; f < getElectronContainerCount(); f++) {
// electronContainer = this.getElectronContainer(f);
// newEC = getBuilder().newElectronContainer();
// if (electronContainer instanceof IBond) {
// IBond bond = (IBond) electronContainer;
// newEC = (IElectronContainer)bond.clone();
// newAtoms = new IAtom[bond.getAtomCount()];
// for (int g = 0; g < bond.getAtomCount(); g++) {
// newAtoms[g] = clone.getAtom(getAtomNumber(bond.getAtom(g)));
// }
// ((IBond) newEC).setAtoms(newAtoms);
// } else if (electronContainer instanceof ILonePair) {
// IAtom atom = ((ILonePair) electronContainer).getAtom();
// newEC = (ILonePair)electronContainer.clone();
// ((ILonePair) newEC).setAtom(clone.getAtom(getAtomNumber(atom)));
// } else if (electronContainer instanceof ISingleElectron) {
// IAtom atom = ((ISingleElectron) electronContainer).getAtom();
// newEC = (ISingleElectron)electronContainer.clone();
// ((ISingleElectron) newEC).setAtom(clone.getAtom(getAtomNumber(atom)));
// } else {
// //logger.debug("Expecting EC, got: " + electronContainer.getClass().getName());
// newEC = (IElectronContainer) electronContainer.clone();
// }
// clone.addElectronContainer(newEC);
// }
return clone;
}
/**
* Grows the ElectronContainer array by a given size.
*
*@see #growArraySize
*/
// protected void growElectronContainerArray()
// {
// growArraySize = (electronContainers.length < growArraySize) ? growArraySize : electronContainers.length;
// IElectronContainer[] newelectronContainers = new IElectronContainer[electronContainers.length + growArraySize];
// System.arraycopy(electronContainers, 0, newelectronContainers, 0, electronContainers.length);
// electronContainers = newelectronContainers;
// }
/**
* Grows the atom array by a given size.
*
*@see #growArraySize
*/
private void growAtomArray()
{
growArraySize = (atoms.length < growArraySize) ? growArraySize : atoms.length;
IAtom[] newatoms = new IAtom[atoms.length + growArraySize];
System.arraycopy(atoms, 0, newatoms, 0, atoms.length);
atoms = newatoms;
}
/**
* Grows the bond array by a given size.
*
*@see #growArraySize
*/
private void growBondArray()
{
growArraySize = (bonds.length < growArraySize) ? growArraySize : bonds.length;
IBond[] newBonds = new IBond[bonds.length + growArraySize];
System.arraycopy(bonds, 0, newBonds, 0, bonds.length);
bonds = newBonds;
}
/**
* Grows the lone pair array by a given size.
*
*@see #growArraySize
*/
private void growLonePairArray()
{
growArraySize = (lonePairs.length < growArraySize) ? growArraySize : lonePairs.length;
ILonePair[] newLonePairs = new ILonePair[lonePairs.length + growArraySize];
System.arraycopy(lonePairs, 0, newLonePairs, 0, lonePairs.length);
lonePairs = newLonePairs;
}
/**
* Grows the single electron array by a given size.
*
*@see #growArraySize
*/
private void growSingleElectronArray()
{
growArraySize = (singleElectrons.length < growArraySize) ? growArraySize : singleElectrons.length;
ISingleElectron[] newSingleElectrons = new ISingleElectron[singleElectrons.length + growArraySize];
System.arraycopy(singleElectrons, 0, newSingleElectrons, 0, singleElectrons.length);
singleElectrons = newSingleElectrons;
}
/**
* Called by objects to which this object has
* registered as a listener.
*
*@param event A change event pointing to the source of the change
*/
public void stateChanged(IChemObjectChangeEvent event)
{
notifyChanged(event);
}
}
cdk-1.2.10/src/main/org/openscience/cdk/AtomContainerSet.java 100644 0 0 26575 11570154753 21152 0 ustar 0 0 /* $Revision$ $Author$ $Date$
*
* Copyright (C) 2003-2007 Christoph Steinbeck position
* @see #getMultiplier(int)
*/
public void setMultiplier(int position, Double multiplier) {
multipliers[position] = multiplier;
notifyChanged();
}
/**
* Returns an array of double with the stoichiometric coefficients
* of the products.
*
* @return The multipliers for the AtomContainer's in this set
* @see #setMultipliers
*/
public Double[] getMultipliers() {
Double[] returnArray = new Double[this.atomContainerCount];
System.arraycopy(this.multipliers, 0, returnArray, 0, this.atomContainerCount);
return returnArray;
}
/**
* Sets the multipliers of the AtomContainers.
*
* @param newMultipliers The new multipliers for the AtomContainers in this set
* @return true if multipliers have been set.
* @see #getMultipliers
*/
public boolean setMultipliers(Double[] newMultipliers) {
if (newMultipliers.length == atomContainerCount) {
if (multipliers == null) {
multipliers = new Double[atomContainerCount];
}
System.arraycopy(newMultipliers, 0, multipliers, 0, atomContainerCount);
notifyChanged();
return true;
}
return false;
}
/**
* Adds an atomContainer to this container with the given
* multiplier.
*
* @param atomContainer The atomContainer to be added to this container
* @param multiplier The multiplier of this atomContainer
*/
public void addAtomContainer(IAtomContainer atomContainer, double multiplier) {
if (atomContainerCount + 1 >= atomContainers.length) {
growAtomContainerArray();
}
atomContainer.addListener(this);
atomContainers[atomContainerCount] = atomContainer;
multipliers[atomContainerCount] = multiplier;
atomContainerCount++;
notifyChanged();
}
/**
* Adds all atomContainers in the AtomContainerSet to this container.
*
* @param atomContainerSet The AtomContainerSet
*/
public void add(IAtomContainerSet atomContainerSet) {
for (IAtomContainer iter : atomContainerSet.atomContainers()) {
addAtomContainer(iter);
}
/*
* notifyChanged() is called by addAtomContainer()
*/
}
/**
* Get an iterator for this AtomContainerSet.
*
* @return A new Iterator for this AtomContainerSet.
*/
public Iterablenumber in the
* container.
*
* @param number The position of the AtomContainer to be returned.
* @return The AtomContainer at position number .
*/
public IAtomContainer getAtomContainer(int number) {
return atomContainers[number];
}
/**
* Returns the multiplier for the AtomContainer at position number in the
* container.
*
* @param number The position of the multiplier of the AtomContainer to be returned.
* @return The multiplier for the AtomContainer at position number .
* @see #setMultiplier(int, Double)
*/
public Double getMultiplier(int number) {
return multipliers[number];
}
/**
* Returns the multiplier of the given AtomContainer.
*
* @param container The AtomContainer for which the multiplier is given
* @return -1, if the given molecule is not a container in this set
* @see #setMultiplier(IAtomContainer, Double)
*/
public Double getMultiplier(IAtomContainer container) {
for (int i = 0; i < atomContainerCount; i++) {
if (atomContainers[i].equals(container)) {
return multipliers[i];
}
}
return -1.0;
}
/**
* Grows the atomContainer array by a given size.
*
* @see growArraySize
*/
protected void growAtomContainerArray() {
growArraySize = atomContainers.length;
IAtomContainer[] newatomContainers = new IAtomContainer[atomContainers.length + growArraySize];
System.arraycopy(atomContainers, 0, newatomContainers, 0, atomContainers.length);
atomContainers = newatomContainers;
Double[] newMultipliers = new Double[multipliers.length + growArraySize];
System.arraycopy(multipliers, 0, newMultipliers, 0, multipliers.length);
multipliers = newMultipliers;
}
/**
* Returns the number of AtomContainers in this Container.
*
* @return The number of AtomContainers in this Container
*/
public int getAtomContainerCount() {
return this.atomContainerCount;
}
/**
* Returns the String representation of this AtomContainerSet.
*
* @return The String representation of this AtomContainerSet
*/
public String toString() {
StringBuffer buffer = new StringBuffer(32);
buffer.append("AtomContainerSet(");
buffer.append(this.hashCode());
if (getAtomContainerCount() > 0) {
buffer.append(", M=").append(getAtomContainerCount());
for (int i = 0; i < atomContainerCount; i++) {
buffer.append(", ").append(atomContainers[i].toString());
}
}
buffer.append(')');
return buffer.toString();
}
/**
* Clones this AtomContainerSet and its content.
*
* @return the cloned Object
*/
public Object clone() throws CloneNotSupportedException {
AtomContainerSet clone = (AtomContainerSet)super.clone();
clone.atomContainers = new IAtomContainer[atomContainerCount];
clone.atomContainerCount = 0;
for (int i = 0; i < atomContainerCount; i++) {
clone.addAtomContainer((IAtomContainer)atomContainers[i].clone());
clone.setMultiplier(i, getMultiplier(i));
}
return clone;
}
/**
* Called by objects to which this object has
* registered as a listener.
*
* @param event A change event pointing to the source of the change
*/
public void stateChanged(IChemObjectChangeEvent event) {
notifyChanged(event);
}
}
cdk-1.2.10/src/main/org/openscience/cdk/AtomParity.java 100644 0 0 12104 11570154753 20003 0 ustar 0 0 /* $RCSfile$
* $Author$
* $Date$
* $Revision$
*
* Copyright (C) 2004-2007 Egon Willighagen Monomers in this
* BioPolymer.
*
* @return a Collection of all the monomer names.
*/
public CollectionStrands in this
* BioPolymer.
*
* @return a Collection of all the strand names.
*/
public Collection* IBond.Order singleBondOrder = CDKConstants.BONDORDER_SINGLE; ** * @cdk.module core * @cdk.githash * * @cdk.keyword bond order * @cdk.keyword stereochemistry */ @TestClass("org.openscience.cdk.CDKConstantsTest") public class CDKConstants { public final static Object UNSET = null; /** A bond of degree 1.0. */ public final static IBond.Order BONDORDER_SINGLE = IBond.Order.SINGLE; /** A bond of degree 2.0. */ public final static IBond.Order BONDORDER_DOUBLE = IBond.Order.DOUBLE; /** A bond of degree 3.0. */ public final static IBond.Order BONDORDER_TRIPLE = IBond.Order.TRIPLE; public final static IBond.Order BONDORDER_QUADRUPLE = IBond.Order.QUADRUPLE; /** A bonds which end is above the drawing plane. */ public final static int STEREO_BOND_UP = 1; /** A bonds which start is above the drawing plane. */ public final static int STEREO_BOND_UP_INV = 2; /** A bonds for which the stereochemistry is undefined. */ public final static int STEREO_BOND_UNDEFINED = 4; /** A bonds for which there is no stereochemistry. */ public final static int STEREO_BOND_NONE = 0; /** A bonds which end is below the drawing plane. * The bond is draw from the first to the second bond atom. */ public final static int STEREO_BOND_DOWN = -1; /** A bonds which end is below the drawing plane. * The bond is draw from the second to the first bond atom. */ public final static int STEREO_BOND_DOWN_INV = -2; /** A positive atom parity. */ public final static int STEREO_ATOM_PARITY_PLUS = 1; /** A negative atom parity. */ public final static int STEREO_ATOM_PARITY_MINUS = -1; /** A undefined atom parity. */ public final static int STEREO_ATOM_PARITY_UNDEFINED = 0; /** A undefined hybridization. */ public final static int HYBRIDIZATION_UNSET = 0; /** A geometry of neighboring atoms when an s orbital is hybridized * with one p orbital. */ public final static int HYBRIDIZATION_SP1 = 1; /** A geometry of neighboring atoms when an s orbital is hybridized * with two p orbitals. */ public final static int HYBRIDIZATION_SP2 = 2; /** A geometry of neighboring atoms when an s orbital is hybridized * with three p orbitals. */ public final static int HYBRIDIZATION_SP3 = 3; /** A geometry of neighboring atoms when an s orbital is hybridized * with three p orbitals with one d orbital. */ public final static int HYBRIDIZATION_SP3D1 = 4; /** A geometry of neighboring atoms when an s orbital is hybridized * with three p orbitals with two d orbitals. */ public final static int HYBRIDIZATION_SP3D2 = 5; /** A geometry of neighboring atoms when an s orbital is hybridized * with three p orbitals with three d orbitals. */ public final static int HYBRIDIZATION_SP3D3 = 6; /** A geometry of neighboring atoms when an s orbital is hybridized * with three p orbitals with four d orbitals. */ public final static int HYBRIDIZATION_SP3D4 = 7; /** A geometry of neighboring atoms when an s orbital is hybridized * with three p orbitals with five d orbitals. */ public final static int HYBRIDIZATION_SP3D5 = 8; /** * Carbon NMR shift constant for use as a key in the * IChemObject.physicalProperties hashtable. * @see org.openscience.cdk.ChemObject */ public final static String NMRSHIFT_CARBON = "carbon nmr shift"; /** Hydrogen NMR shift constant for use as a key in the * IChemObject.physicalProperties hashtable. * @see org.openscience.cdk.ChemObject */ public final static String NMRSHIFT_HYDROGEN = "hydrogen nmr shift"; /** Nitrogen NMR shift constant for use as a key in the * IChemObject.physicalProperties hashtable. * @see org.openscience.cdk.ChemObject */ public final static String NMRSHIFT_NITROGEN = "nitrogen nmr shift"; /** Phosphorus NMR shift constant for use as a key in the * IChemObject.physicalProperties hashtable. * @see org.openscience.cdk.ChemObject */ public final static String NMRSHIFT_PHOSPORUS = "phosphorus nmr shift"; /** Fluorine NMR shift constant for use as a key in the * IChemObject.physicalProperties hashtable. * @see org.openscience.cdk.ChemObject */ public final static String NMRSHIFT_FLUORINE = "fluorine nmr shift"; /** Deuterium NMR shift constant for use as a key in the * IChemObject.physicalProperties hashtable. * @see org.openscience.cdk.ChemObject */ public final static String NMRSHIFT_DEUTERIUM = "deuterium nmr shift"; /**************************************** * Some predefined flags - keep the * * numbers below 50 free for other * * purposes * ****************************************/ /** Flag that is set if the chemobject is placed (somewhere). */ public final static int ISPLACED = 0; /** Flag that is set when the chemobject is part of a ring. */ public final static int ISINRING = 1; /** Flag that is set when the chemobject is part of a ring. */ public final static int ISNOTINRING = 2; /** Flag that is set if a chemobject is part of an aliphatic chain. */ public final static int ISALIPHATIC = 3; /** Flag is set if chemobject has been visited. */ public final static int VISITED = 4; // Use in tree searches /** Flag is set if chemobject is part of an aromatic system. */ public final static int ISAROMATIC = 5; /** Flag is set if chemobject is part of a conjugated system. */ public final static int ISCONJUGATED = 6; /** Flag is set if a chemobject is mapped to another chemobject. * It is used for example in subgraph isomorphism search. */ public final static int MAPPED = 7; /** Sets to true if the atom is an hydrogen bond donor. */ public final static int IS_HYDROGENBOND_DONOR = 8; /** Sets to true if the atom is an hydrogen bond acceptor. */ public final static int IS_HYDROGENBOND_ACCEPTOR = 9; /** Flag is set if a chemobject has reactive center. * It is used for example in reaction. */ public static final int REACTIVE_CENTER = 10; /** * Maximum flags array index. */ public final static int MAX_FLAG_INDEX = 10; /** * Flag used for JUnit testing the pointer functionality. */ public final static int DUMMY_POINTER = 1; /** * Maximum pointers array index. */ public final static int MAX_POINTER_INDEX = 1; /**************************************** * Some predefined property names for * * ChemObjects * ****************************************/ /** The title for a IChemObject. */ public static final String TITLE = "cdk:Title"; /** A remark for a IChemObject.*/ public static final String REMARK = "cdk:Remark"; /** A String comment. */ public static final String COMMENT = "cdk:Comment"; /** A List of names. */ public static final String NAMES = "cdk:Names"; /** A List of annotation remarks. */ public static final String ANNOTATIONS = "cdk:Annotations"; /** A description for a IChemObject. */ public static final String DESCRIPTION = "cdk:Description"; /**************************************** * Some predefined property names for * * Molecules * ****************************************/ /** The Daylight SMILES. */ public static final String SMILES = "cdk:SMILES"; /** The IUPAC International Chemical Identifier. */ public static final String INCHI = "cdk:InChI"; /** The Molecular Formula Identifier. */ public static final String FORMULA = "cdk:Formula"; /** The IUPAC compatible name generated with AutoNom. */ public static final String AUTONOMNAME = "cdk:AutonomName"; /** The Beilstein Registry Number. */ public static final String BEILSTEINRN = "cdk:BeilsteinRN"; /** The CAS Registry Number. */ public static final String CASRN = "cdk:CasRN"; /** A set of all rings computed for this molecule. */ public static final String ALL_RINGS = "cdk:AllRings"; /** A smallest set of smallest rings computed for this molecule. */ public static final String SMALLEST_RINGS = "cdk:SmallestRings"; /** The essential rings computed for this molecule. * The concept of Essential Rings is defined in * SSSRFinder */ public static final String ESSENTIAL_RINGS = "cdk:EssentialRings"; /** The relevant rings computed for this molecule. * The concept of relevant Rings is defined in * SSSRFinder */ public static final String RELEVANT_RINGS = "cdk:RelevantRings"; /**************************************** * Some predefined property names for * * Atoms * ****************************************/ /** * This property will contain an ArrayList of Integers. Each * element of the list indicates the size of the ring the given * atom belongs to (if it is a ring atom at all). */ public static final String RING_SIZES = "cdk:RingSizes"; /** * This property indicates how many ring bonds are connected to * the given atom. */ public static final String RING_CONNECTIONS = "cdk:RingConnections"; /* *This property indicate how many bond are present on the atom. * */ public static final String TOTAL_CONNECTIONS = "cdk:TotalConnections"; /* *Hydrogen count * */ public static final String TOTAL_H_COUNT = "cdk:TotalHydrogenCount"; /** The Isotropic Shielding, usually calculated by * a quantum chemistry program like Gaussian. * This is a property used for calculating NMR chemical * shifts by subtracting the value from the * isotropic shielding value of a standard (e.g. TMS). */ public static final String ISOTROPIC_SHIELDING = "cdk:IsotropicShielding"; /**************************************** * Some predefined property names for * * AtomTypes * ****************************************/ /** Used as property key for indicating the ring size of a certain atom type. */ public static final String PART_OF_RING_OF_SIZE = "cdk:Part of ring of size"; /** Used as property key for indicating the chemical group of a certain atom type. */ public static final String CHEMICAL_GROUP_CONSTANT = "cdk:Chemical Group"; /** Used as property key for indicating the HOSE code for a certain atom type. */ public static final String SPHERICAL_MATCHER = "cdk:HOSE code spherical matcher"; /** Used as property key for indicating the HOSE code for a certain atom type. */ public static final String PI_BOND_COUNT = "cdk:Pi Bond Count"; /** Used as property key for indicating the HOSE code for a certain atom type. */ public static final String LONE_PAIR_COUNT = "cdk:Lone Pair Count"; } cdk-1.2.10/src/main/org/openscience/cdk/ChemFile.java 100644 0 0 14744 11570154753 17402 0 ustar 0 0 /* * $RCSfile$ * $Author$ * $Date$ * $Revision$ * * Copyright (C) 1997-2007 Christoph Steinbeck
number in the container.
*
*@param number The position of the ChemSequence to be returned.
*@return The ChemSequence at position number.
*@see #addChemSequence
*/
public IChemSequence getChemSequence(int number)
{
return chemSequences[number];
}
/**
* Grows the ChemSequence array by a given size.
*
*@see #growArraySize
*/
protected void growChemSequenceArray()
{
growArraySize = chemSequences.length;
IChemSequence[] newchemSequences = new ChemSequence[chemSequences.length + growArraySize];
System.arraycopy(chemSequences, 0, newchemSequences, 0, chemSequences.length);
chemSequences = newchemSequences;
}
/**
* Returns the number of ChemSequences in this Container.
*
*@return The number of ChemSequences in this Container
*/
public int getChemSequenceCount()
{
return this.chemSequenceCount;
}
/**
* Returns a String representation of this class. It implements
* RFC #9.
*
*@return String representation of the Object
*/
public String toString()
{
StringBuffer buffer = new StringBuffer();
buffer.append("ChemFile(#S=");
buffer.append(chemSequenceCount);
if (chemSequenceCount > 0) {
for (IChemSequence iChemSequence : chemSequences()) {
buffer.append(", ");
buffer.append(iChemSequence.toString());
}
}
buffer.append(')');
return buffer.toString();
}
/**
* Allows for getting an clone of this object.
*
*@return a clone of this object
*/
public Object clone() throws CloneNotSupportedException
{
ChemFile clone = (ChemFile) super.clone();
// clone the chemModels
clone.chemSequenceCount = getChemSequenceCount();
clone.chemSequences = new ChemSequence[clone.chemSequenceCount];
for (int f = 0; f < clone.chemSequenceCount; f++)
{
clone.chemSequences[f] = (ChemSequence)((ChemSequence)chemSequences[f]).clone();
}
return clone;
}
/**
* Called by objects to which this object has
* registered as a listener.
*
*@param event A change event pointing to the source of the change
*/
public void stateChanged(IChemObjectChangeEvent event)
{
notifyChanged(event);
}
}
cdk-1.2.10/src/main/org/openscience/cdk/ChemModel.java 100644 0 0 15173 11570154753 17560 0 ustar 0 0 /* $RCSfile$
* $Author$
* $Date$
* $Revision$
*
* Copyright (C) 1997-2007 Christoph Steinbeck ChemModel and its content.
*
* @return The cloned object
*/
public Object clone() throws CloneNotSupportedException {
ChemModel clone = (ChemModel)super.clone();
// clone the content
if (setOfMolecules != null) {
clone.setOfMolecules = (MoleculeSet)((MoleculeSet)setOfMolecules).clone();
} else {
clone.setOfMolecules = null;
}
if (setOfReactions != null) {
clone.setOfReactions = (IReactionSet)((ReactionSet)setOfReactions).clone();
} else {
clone.setOfReactions = null;
}
if (crystal != null) {
clone.crystal = (Crystal)((Crystal)crystal).clone();
} else {
clone.crystal = null;
}
if (ringSet != null) {
clone.ringSet = (RingSet)((RingSet)ringSet).clone();
} else {
clone.ringSet = null;
}
return clone;
}
/**
* Called by objects to which this object has
* registered as a listener.
*
*@param event A change event pointing to the source of the change
*/
public void stateChanged(IChemObjectChangeEvent event)
{
notifyChanged(event);
}
}
cdk-1.2.10/src/main/org/openscience/cdk/ChemObject.java 100644 0 0 30053 11570154753 17720 0 ustar 0 0 /* $Revision$ $Author$ $Date$
*
* Copyright (C) 1997-2007 Christoph Steinbeck IChemObject. It clones the identifier, flags,
* properties and pointer vectors. The ChemObjectListeners are not cloned, and
* neither is the content of the pointer vectors.
*
*@return The cloned object
*/
public Object clone() throws CloneNotSupportedException
{
ChemObject clone = (ChemObject)super.clone();
// clone the flags
clone.flags = new boolean[CDKConstants.MAX_FLAG_INDEX + 1];
System.arraycopy(flags, 0, clone.flags, 0, flags.length);
// clone the properties
if (properties != null) {
Map