* @author John L. Moreland * @see edu.sdsc.mbt.StructureComponent * @see edu.sdsc.mbt.Atom */ public class Bond extends StructureComponent implements java.lang.Cloneable { /** * Type for a covalent bond (bonding interaction due to electron sharing). */ public static final String TYPE_COVALENT = "Covalent"; /** * Type for a hydrogen bond (bonding interaction due to partial charges). */ public static final String TYPE_HYDROGEN = "Hydrogen"; /** * Type for an ionic bond (bonding interaction due to electrostatic * attraction between cations and anions). */ public static final String TYPE_IONIC = "Ionic"; // The two atoms forming the bond. private Atom atoms[]; // The order of the bond (how many electron pairs are shared). public float order = 1.0f; private int reference; // // Constructors // /** * Constructor variant used when there will likely be no atom list * (eg: when only sequence data is loaded). */ public Bond( Atom atom0, Atom atom1 ) { if (atom0 == atom1) throw new IllegalArgumentException("duplicate atom"); setStructure( atom0.getStructure() ); atoms = new Atom[]{ atom0, atom1 }; reference = 0; } // // StructureComponent methods. // /** * Copy all of the field values from the parameter object into "this". */ public void copy( StructureComponent structureComponent ) { setStructure( structureComponent.getStructure() ); Bond bond = (Bond) structureComponent; atoms[0] = bond.getAtom( 0 ); atoms[1] = bond.getAtom( 1 ); setReferenceAtom(bond.getReferenceAtom()); } /** * Clone this object. */ public Object clone( ) throws CloneNotSupportedException { return super.clone( ); } /** * One Bond is equal to another Bond if they hashCode values are equal. * That is if they contain (in either order) the same two Atom objects. */ public boolean equals( Object o ) { if ( ! (o instanceof Bond) ) return false; Bond b = (Bond) o; if (b.getAtom(0) == this.getAtom(0) && b.getAtom(1) == this.getAtom(1)) return true; if (b.getAtom(0) == this.getAtom(1) && b.getAtom(1) == this.getAtom(0)) return true; return false; } private static String className = null; /** * This method returns the fully qualified name of this class. *
* This name is used by the StructureComponentRegistry class to enable * dynamic registration and discovery of new StructureComponent * sub-classes/types. The name is also used to create a unique integer * indentifier for each type in order to make run-time type comparisons * fast. */ public static String getClassName() { if ( className == null ) className = ((new Throwable()).getStackTrace())[0].getClassName(); return className; } /** * This method returns the fully qualified name of this class. */ public String getStructureComponentType( ) { return className; } // // Bond methods. // /** * Set the bond order (the number of covalently shared electron pairs). * Generally this is a value from 1.0 to 6.0 but may be 1.5 for aromatic * (benzene ring bonds) or 0.0 for unspecified order (the default). *
* @see #getOrder( ) */ public void setOrder( float order ) { if ( (order < 0.0f) || (order > 6.0f) ) throw new IllegalArgumentException( "Invalid order " + order ); //before changing hybridization of atoms, check whether they participate in //other (perhaps higher order) bonds Atom a1 = getAtom(0); Atom a2 = getAtom(1); //check a1 boolean reset = true; Vector bonds = a1.structure.getStructureMap().getBonds(a1); for (int i = 0; i < bonds.size(); i++){ Bond b = (Bond)bonds.get(i); if (b == this) continue; if (b.order > 1.0f){ reset = false; break; } } if (reset){//the atom is not in any other multiple bond, so do your thing //set the correct hybridization if (order == 1.0f) a1.hybridization = Atom.SP3; if (order == 1.5f) a1.hybridization = Atom.SP2;//aromatic if (order == 2.0f) a1.hybridization = Atom.SP2; if (order == 3.0f) a1.hybridization = Atom.SP; } //check a1 reset = true; bonds = a2.structure.getStructureMap().getBonds(a2); for (int i = 0; i < bonds.size(); i++){ Bond b = (Bond)bonds.get(i); if (b == this) continue; if (b.order > 1.0f){ reset = false; break; } } if (reset){ //set the correct hybridization if (order == 1.0f) a2.hybridization = Atom.SP3; if (order == 1.5f) a2.hybridization = Atom.SP2;//aromatic if (order == 2.0f) a2.hybridization = Atom.SP2; if (order == 3.0f) a2.hybridization = Atom.SP; } this.order = order; } /** * This method sets order without editing atoms' hybridization states * it is used in the loading of data with predefined bonding to avoid overwriting of hybridization * data in subsequent passes over atoms that participate in bonds of different orders * @param order */ public void setOrderOnly(float order){ if ( (order < 0.0f) || (order > 6.0f) ) throw new IllegalArgumentException( "Invalid order " + order ); this.order = order; } /** * Get the distance for the bond. */ public double getDistance( ) { if ( atoms == null ) return 0.0; if ( atoms[0] == null ) return 0.0; if ( atoms[1] == null ) return 0.0; return Algebra.distance( atoms[0].coordinate, atoms[1].coordinate ); } public static final double getDistance( Atom atom0, Atom atom1 ) { return Algebra.distance( atom0.coordinate, atom1.coordinate ); } /** * Get the specified Atom record that forms this Bond. */ public Atom getAtom( int index ) { return atoms[index]; } public void setReferenceAtom(int index){ if (index < 0 || index > 1) return; reference = index; } public void setReferenceAtom(Atom atom){ if (atoms[0] == atom) reference = 0; else if (atoms[1] == atom) reference = 1; } public Atom getReferenceAtom(){ return atoms[reference]; } public short render = (short)StylesPreferences.renderingMode; public short quality = (short)StylesPreferences.startupRenderingQuality; public boolean visible = true; public boolean isVisible(){ return visible; } }