/**
  * Generate coordinates for all atoms which are singly bonded and have no coordinates. This is
  * useful when hydrogens are present but have no coords. It knows about C, O, N, S only and will
  * give tetrahedral or trigonal geometry elsewhere. Bond lengths are computed from covalent radii
  * if available. Angles are tetrahedral or trigonal
  *
  * @param atomContainer the set of atoms involved
  * @cdk.keyword coordinate calculation
  * @cdk.keyword 3D model
  */
 public static void add3DCoordinates1(AtomContainer atomContainer) {
   // atoms without coordinates
   AtomContainer noCoords = new AtomContainer();
   // get vector of possible referenceAtoms?
   AtomContainer refAtoms = new AtomContainer();
   for (int i = 0; i < atomContainer.getAtomCount(); i++) {
     IAtom atom = atomContainer.getAtom(i);
     // is this atom without 3D coords, and has only one ligand?
     if (atom.getPoint3d() == null) {
       java.util.List connectedAtoms = atomContainer.getConnectedAtomsList(atom);
       if (connectedAtoms.size() == 1) {
         IAtom refAtom = (IAtom) connectedAtoms.get(0);
         ;
         if (refAtom.getPoint3d() != null) {
           refAtoms.addAtom(refAtom);
           // store atoms with no coords and ref atoms in a
           // single container
           noCoords.addAtom(atom);
           noCoords.addAtom(refAtom);
           // bond is required to extract ligands
           noCoords.addBond(new Bond(atom, refAtom, CDKConstants.BONDORDER_SINGLE));
         }
       }
     }
   }
   // now add coordinates to ligands of reference atoms
   // use default length of 1.0, which can be adjusted later
   double length = 1.0;
   double angle = TETRAHEDRAL_ANGLE;
   for (int i = 0; i < refAtoms.getAtomCount(); i++) {
     IAtom refAtom = refAtoms.getAtom(i);
     java.util.List noCoordLigands = noCoords.getConnectedAtomsList(refAtom);
     int nLigands = noCoordLigands.size();
     int nwanted = nLigands;
     String elementType = refAtom.getSymbol();
     // try to deal with lone pairs on small hetero
     if (elementType.equals("N") || elementType.equals("O") || elementType.equals("S")) {
       nwanted = 3;
     }
     Point3d[] newPoints =
         calculate3DCoordinatesForLigands(atomContainer, refAtom, nwanted, length, angle);
     for (int j = 0; j < nLigands; j++) {
       IAtom ligand = (IAtom) noCoordLigands.get(j);
       Point3d newPoint = rescaleBondLength(refAtom, ligand, newPoints[j]);
       ligand.setPoint3d(newPoint);
     }
   }
 }
示例#2
0
  /**
   * 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));
      }
    }

    for (IStereoElement se : atomContainer.stereoElements()) stereoElements.add(se);

    notifyChanged();
  }
 /**
  * Adds 3D coordinates for singly-bonded ligands of a reference atom (A). Initially designed for
  * hydrogens. The ligands of refAtom are identified and those with 3D coordinates used to generate
  * the new points. (This allows structures with partially known 3D coordinates to be used, as when
  * groups are added.) "Bent" and "non-planar" groups can be formed by taking a subset of the
  * calculated points. Thus R-NH2 could use 2 of the 3 points calculated from (1,iii) nomenclature:
  * A is point to which new ones are "attached". A may have ligands B, C... B may have ligands J,
  * K.. points X1, X2... are returned The cases (see individual routines, which use idealised
  * geometry by default): (0) zero ligands of refAtom. The resultant points are randomly oriented:
  * (i) 1 points required; +x,0,0 (ii) 2 points: use +x,0,0 and -x,0,0 (iii) 3 points: equilateral
  * triangle in xy plane (iv) 4 points x,x,x, x,-x,-x, -x,x,-x, -x,-x,x (1a) 1 ligand(B) of refAtom
  * which itself has a ligand (J) (i) 1 points required; vector along AB vector (ii) 2 points: 2
  * vectors in ABJ plane, staggered and eclipsed wrt J (iii) 3 points: 1 staggered wrt J, the
  * others +- gauche wrt J (1b) 1 ligand(B) of refAtom which has no other ligands. A random J is
  * generated and (1a) applied (2) 2 ligands(B, C) of refAtom A (i) 1 points required; vector in
  * ABC plane bisecting AB, AC. If ABC is linear, no points (ii) 2 points: 2 vectors at angle ang,
  * whose resultant is 2i (3) 3 ligands(B, C, D) of refAtom A (i) 1 points required; if A, B, C, D
  * coplanar, no points. else vector is resultant of BA, CA, DA
  *
  * <p>fails if atom itself has no coordinates or >4 ligands
  *
  * @param atomContainer describing the ligands of refAtom. It could be the whole molecule, or
  *     could be a selected subset of ligands
  * @param refAtom (A) to which new ligands coordinates could be added
  * @param length A-X length
  * @param angle B-A-X angle (used in certain cases)
  * @return Point3D[] points calculated. If request could not be fulfilled (e.g. too many atoms, or
  *     strange geometry, returns empty array (zero length, not null)
  * @cdk.keyword coordinate generation
  */
 public static Point3d[] calculate3DCoordinatesForLigands(
     AtomContainer atomContainer, IAtom refAtom, int nwanted, double length, double angle) {
   Point3d newPoints[] = new Point3d[0];
   Point3d aPoint = refAtom.getPoint3d();
   // get ligands
   List connectedAtoms = atomContainer.getConnectedAtomsList(refAtom);
   if (connectedAtoms == null) {
     return newPoints;
   }
   int nligands = connectedAtoms.size();
   AtomContainer ligandsWithCoords = new AtomContainer();
   for (int i = 0; i < nligands; i++) {
     Atom ligand = (Atom) connectedAtoms.get(i);
     if (ligand.getPoint3d() != null) {
       ligandsWithCoords.addAtom(ligand);
     }
   }
   int nwithCoords = ligandsWithCoords.getAtomCount();
   // too many ligands at present
   if (nwithCoords > 3) {
     return newPoints;
   }
   if (nwithCoords == 0) {
     newPoints = calculate3DCoordinates0(refAtom.getPoint3d(), nwanted, length);
   } else if (nwithCoords == 1) {
     // ligand on A
     IAtom bAtom = ligandsWithCoords.getAtom(0);
     connectedAtoms = ligandsWithCoords.getConnectedAtomsList(bAtom);
     // does B have a ligand (other than A)
     Atom jAtom = null;
     for (int i = 0; i < connectedAtoms.size(); i++) {
       Atom connectedAtom = (Atom) connectedAtoms.get(i);
       if (!connectedAtom.equals(refAtom)) {
         jAtom = connectedAtom;
         break;
       }
     }
     newPoints =
         calculate3DCoordinates1(
             aPoint,
             bAtom.getPoint3d(),
             (jAtom != null) ? jAtom.getPoint3d() : null,
             nwanted,
             length,
             angle);
   } else if (nwithCoords == 2) {
     Point3d bPoint = ligandsWithCoords.getAtom(0).getPoint3d();
     Point3d cPoint = ligandsWithCoords.getAtom(1).getPoint3d();
     newPoints = calculate3DCoordinates2(aPoint, bPoint, cPoint, nwanted, length, angle);
   } else if (nwithCoords == 3) {
     Point3d bPoint = ligandsWithCoords.getAtom(0).getPoint3d();
     Point3d cPoint = ligandsWithCoords.getAtom(1).getPoint3d();
     Point3d dPoint = ligandsWithCoords.getAtom(2).getPoint3d();
     newPoints = new Point3d[1];
     newPoints[0] = calculate3DCoordinates3(aPoint, bPoint, cPoint, dPoint, length);
   }
   return newPoints;
 }
示例#4
0
  /**
   * Create a benzene molecule with 2 residues and 2 charge groups
   *
   * @return
   */
  public MDMolecule makeMDBenzene() {

    MDMolecule mol = new MDMolecule();
    mol.addAtom(new Atom("C")); // 0
    mol.addAtom(new Atom("C")); // 1
    mol.addAtom(new Atom("C")); // 2
    mol.addAtom(new Atom("C")); // 3
    mol.addAtom(new Atom("C")); // 4
    mol.addAtom(new Atom("C")); // 5

    mol.addBond(0, 1, IBond.Order.SINGLE); // 1
    mol.addBond(1, 2, IBond.Order.DOUBLE); // 2
    mol.addBond(2, 3, IBond.Order.SINGLE); // 3
    mol.addBond(3, 4, IBond.Order.DOUBLE); // 4
    mol.addBond(4, 5, IBond.Order.SINGLE); // 5
    mol.addBond(5, 0, IBond.Order.DOUBLE); // 6

    // Create 2 residues
    AtomContainer ac = new AtomContainer();
    ac.addAtom(mol.getAtom(0));
    ac.addAtom(mol.getAtom(1));
    ac.addAtom(mol.getAtom(2));
    Residue res1 = new Residue(ac, 0, mol);
    res1.setName("myResidue1");
    mol.addResidue(res1);

    AtomContainer ac2 = new AtomContainer();
    ac2.addAtom(mol.getAtom(3));
    ac2.addAtom(mol.getAtom(4));
    ac2.addAtom(mol.getAtom(5));
    Residue res2 = new Residue(ac2, 1, mol);
    res2.setName("myResidue2");
    mol.addResidue(res2);

    // Create 2 chargegroups
    AtomContainer ac3 = new AtomContainer();
    ac3.addAtom(mol.getAtom(0));
    ac3.addAtom(mol.getAtom(1));
    ChargeGroup chg1 = new ChargeGroup(ac3, 2, mol);
    chg1.setSwitchingAtom(mol.getAtom(1));
    mol.addChargeGroup(chg1);

    AtomContainer ac4 = new AtomContainer();
    ac4.addAtom(mol.getAtom(2));
    ac4.addAtom(mol.getAtom(3));
    ac4.addAtom(mol.getAtom(4));
    ac4.addAtom(mol.getAtom(5));
    ChargeGroup chg2 = new ChargeGroup(ac4, 3, mol);
    chg2.setSwitchingAtom(mol.getAtom(4));
    mol.addChargeGroup(chg2);

    return mol;
  }
示例#5
0
  /** Test an MDMolecule with residues and charge groups */
  @Test
  public void testMDMolecule() {

    MDMolecule mol = new MDMolecule();
    mol.addAtom(new Atom("C")); // 0
    mol.addAtom(new Atom("C")); // 1
    mol.addAtom(new Atom("C")); // 2
    mol.addAtom(new Atom("C")); // 3
    mol.addAtom(new Atom("C")); // 4
    mol.addAtom(new Atom("C")); // 5

    mol.addBond(0, 1, IBond.Order.SINGLE); // 1
    mol.addBond(1, 2, IBond.Order.DOUBLE); // 2
    mol.addBond(2, 3, IBond.Order.SINGLE); // 3
    mol.addBond(3, 4, IBond.Order.DOUBLE); // 4
    mol.addBond(4, 5, IBond.Order.SINGLE); // 5
    mol.addBond(5, 0, IBond.Order.DOUBLE); // 6

    // Create 2 residues
    AtomContainer ac = new AtomContainer();
    ac.addAtom(mol.getAtom(0));
    ac.addAtom(mol.getAtom(1));
    ac.addAtom(mol.getAtom(2));
    Residue res1 = new Residue(ac, 0, mol);
    res1.setName("myResidue1");
    mol.addResidue(res1);

    AtomContainer ac2 = new AtomContainer();
    ac2.addAtom(mol.getAtom(3));
    ac2.addAtom(mol.getAtom(4));
    ac2.addAtom(mol.getAtom(5));
    Residue res2 = new Residue(ac2, 1, mol);
    res2.setName("myResidue2");
    mol.addResidue(res2);

    // Test residue creation
    Assert.assertEquals(res1.getParentMolecule(), mol);
    Assert.assertEquals(res2.getParentMolecule(), mol);
    Assert.assertEquals(res1.getAtomCount(), 3);
    Assert.assertEquals(res2.getAtomCount(), 3);
    Assert.assertEquals(res1.getName(), "myResidue1");
    Assert.assertEquals(res2.getName(), "myResidue2");
    Assert.assertNotNull(mol.getResidues());
    Assert.assertEquals(mol.getResidues().size(), 2);
    Assert.assertEquals(mol.getResidues().get(0), res1);
    Assert.assertEquals(mol.getResidues().get(1), res2);

    // Create 2 chargegroups
    AtomContainer ac3 = new AtomContainer();
    ac3.addAtom(mol.getAtom(0));
    ac3.addAtom(mol.getAtom(1));
    ChargeGroup chg1 = new ChargeGroup(ac3, 0, mol);
    mol.addChargeGroup(chg1);

    AtomContainer ac4 = new AtomContainer();
    ac4.addAtom(mol.getAtom(2));
    ac4.addAtom(mol.getAtom(3));
    ac4.addAtom(mol.getAtom(4));
    ac4.addAtom(mol.getAtom(5));
    ChargeGroup chg2 = new ChargeGroup(ac4, 1, mol);
    mol.addChargeGroup(chg2);

    // Test chargegroup creation
    Assert.assertEquals(chg1.getParentMolecule(), mol);
    Assert.assertEquals(chg2.getParentMolecule(), mol);
    Assert.assertEquals(chg1.getAtomCount(), 2);
    Assert.assertEquals(chg2.getAtomCount(), 4);

    Assert.assertNotNull(mol.getChargeGroups());
    Assert.assertEquals(mol.getChargeGroups().size(), 2);
    Assert.assertEquals(mol.getChargeGroups().get(0), chg1);
    Assert.assertEquals(mol.getChargeGroups().get(1), chg2);
  }
 public void addAtom(IAtom atom) {
   logger.debug("Adding atom: ", atom);
   super.addAtom(atom);
 }