/** * 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); } } }
/** * 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; }
/** * 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; }
/** 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); }