@Test
  public void methyleneCyclopropeneTest() {
    IAtomContainer mol = builder.newInstance(IAtomContainer.class);
    AbstractSignatureTest.addCarbons(mol, 4);
    AbstractSignatureTest.addHydrogens(mol, 1, 2);
    AbstractSignatureTest.addHydrogens(mol, 2, 1);
    AbstractSignatureTest.addHydrogens(mol, 3, 1);
    mol.addBond(0, 1, IBond.Order.DOUBLE);
    mol.addBond(0, 2, IBond.Order.SINGLE);
    mol.addBond(0, 3, IBond.Order.SINGLE);
    mol.addBond(2, 3, IBond.Order.DOUBLE);
    MoleculeSignature molSig = new MoleculeSignature(mol);

    String sigFor2Height1 = molSig.signatureStringForVertex(2, 1);
    String sigFor3Height1 = molSig.signatureStringForVertex(3, 1);
    Assert.assertTrue(
        "Height 1 signatures for atoms 2 and 3" + " should be the same",
        sigFor2Height1.equals(sigFor3Height1));

    String sigFor2Height2 = molSig.signatureStringForVertex(2, 1);
    String sigFor3Height2 = molSig.signatureStringForVertex(3, 1);
    Assert.assertTrue(
        "Height 2 signatures for atoms 2 and 3" + " should be the same",
        sigFor2Height2.equals(sigFor3Height2));
  }
  @Test
  public void napthaleneSkeletonHeightTest() {
    IAtomContainer napthalene = builder.newInstance(IAtomContainer.class);
    for (int i = 0; i < 10; i++) {
      napthalene.addAtom(builder.newInstance(IAtom.class, "C"));
    }
    napthalene.addBond(0, 1, IBond.Order.SINGLE);
    napthalene.addBond(0, 5, IBond.Order.SINGLE);
    napthalene.addBond(1, 2, IBond.Order.SINGLE);
    napthalene.addBond(1, 6, IBond.Order.SINGLE);
    napthalene.addBond(2, 3, IBond.Order.SINGLE);
    napthalene.addBond(2, 9, IBond.Order.SINGLE);
    napthalene.addBond(3, 4, IBond.Order.SINGLE);
    napthalene.addBond(4, 5, IBond.Order.SINGLE);
    napthalene.addBond(6, 7, IBond.Order.SINGLE);
    napthalene.addBond(7, 8, IBond.Order.SINGLE);
    napthalene.addBond(8, 9, IBond.Order.SINGLE);

    MoleculeSignature molSig = new MoleculeSignature(napthalene);
    int height = 2;
    Map<String, Orbit> orbits = new HashMap<String, Orbit>();
    for (int i = 0; i < napthalene.getAtomCount(); i++) {
      String signatureString = molSig.signatureStringForVertex(i, height);
      Orbit orbit;
      if (orbits.containsKey(signatureString)) {
        orbit = orbits.get(signatureString);
      } else {
        orbit = new Orbit(signatureString, height);
        orbits.put(signatureString, orbit);
      }
      orbit.addAtom(i);
    }
    Assert.assertEquals(3, orbits.size());
  }
 @Test
 public void cycleWheelTest() {
   IAtomContainer mol = AbstractSignatureTest.makeCycleWheel(3, 3);
   String expected = "[C]([C]([C]([C,2])[C,2])" + "[C]([C]([C,1])[C,1])" + "[C]([C]([C,0])[C,0]))";
   MoleculeSignature molSig = new MoleculeSignature(mol);
   String centralSignature = molSig.signatureStringForVertex(0);
   Assert.assertEquals(expected, centralSignature);
 }
 @Test
 public void testEmpty() throws Exception {
   IAtomContainer mol = DefaultChemObjectBuilder.getInstance().newInstance(IAtomContainer.class);
   MoleculeSignature signature = new MoleculeSignature(mol);
   String signatureString = signature.toCanonicalString();
   String expected = "";
   Assert.assertEquals(expected, signatureString);
 }
 @Test
 public void methylFerroceneTest() throws Exception {
   String smiles = "CC12C3C4C5C1[Fe]23456789C%10C6C7C8C9%10";
   IAtomContainer mol = parser.parseSmiles(smiles);
   MoleculeSignature molSig = new MoleculeSignature(mol);
   int feIndex = findFirstAtomIndexForSymbol(mol, "Fe");
   String sigForIron = molSig.signatureStringForVertex(feIndex);
   String expected =
       "[Fe]([C]([C,3][C,4])[C,3]([C,1])[C,4]([C,0])"
           + "[C]([C,5][C,6])[C,5]([C,2])[C,6]([C,7])"
           + "[C,7]([C][C,2])[C,0]([C,1])[C,1][C,2])";
   Assert.assertEquals(expected, sigForIron);
 }
 @Test
 public void fusedSquareMultipleBondTest() {
   IAtomContainer mol = builder.newInstance(IAtomContainer.class);
   String expected = "[C]([C]([C,1])[C]([C,0])[C](=[C,1])[C](=[C,0]))";
   AbstractSignatureTest.addCarbons(mol, 7);
   mol.addBond(0, 1, IBond.Order.SINGLE);
   mol.addBond(0, 2, IBond.Order.SINGLE);
   mol.addBond(0, 3, IBond.Order.SINGLE);
   mol.addBond(0, 4, IBond.Order.SINGLE);
   mol.addBond(1, 5, IBond.Order.DOUBLE);
   mol.addBond(2, 5, IBond.Order.SINGLE);
   mol.addBond(3, 6, IBond.Order.SINGLE);
   mol.addBond(4, 6, IBond.Order.DOUBLE);
   MoleculeSignature molSig = new MoleculeSignature(mol);
   String sigFor0 = molSig.signatureStringForVertex(0);
   Assert.assertEquals(expected, sigFor0);
 }
  @Test
  public void testBenzeneWithDoubleBonds() {
    IAtomContainer benzene = builder.newInstance(IAtomContainer.class);
    AbstractSignatureTest.addCarbons(benzene, 6);
    for (int i = 0; i < 6; i++) {
      AbstractSignatureTest.addHydrogens(benzene, i, 1);
    }
    benzene.addBond(0, 1, IBond.Order.SINGLE);
    benzene.addBond(1, 2, IBond.Order.DOUBLE);
    benzene.addBond(2, 3, IBond.Order.SINGLE);
    benzene.addBond(3, 4, IBond.Order.DOUBLE);
    benzene.addBond(4, 5, IBond.Order.SINGLE);
    benzene.addBond(5, 0, IBond.Order.DOUBLE);

    MoleculeSignature signature = new MoleculeSignature(benzene);
    String carbonSignature = signature.signatureStringForVertex(0);
    for (int i = 1; i < 6; i++) {
      String carbonSignatureI = signature.signatureStringForVertex(i);
      Assert.assertEquals(carbonSignature, carbonSignatureI);
    }
  }
 @Test
 @Category(SlowTest.class)
 public void ttprTest() {
   String expected =
       "[Rh]([P]([C]([C]([C]([C,6]))"
           + "[C]([C]([C,6])))[C]([C]([C]([C,3]))"
           + "[C]([C]([C,3])))[C]([C]([C]([C,2]))"
           + "[C]([C]([C,2]))))[P]([C]([C]([C]([C,7]))"
           + "[C]([C]([C,7])))[C]([C]([C]([C,4]))"
           + "[C]([C]([C,4])))[C]([C]([C]([C,1]))"
           + "[C]([C]([C,1]))))[P]([C]([C]([C]([C,8]))"
           + "[C]([C]([C,8])))[C]([C]([C]([C,5]))"
           + "[C]([C]([C,5])))[C]([C]([C]([C,0]))"
           + "[C]([C]([C,0])))))";
   int phosphateCount = 3;
   int ringCount = 3;
   IAtomContainer ttpr = AbstractSignatureTest.makeRhLikeStructure(phosphateCount, ringCount);
   MoleculeSignature molSig = new MoleculeSignature(ttpr);
   String centralSignature = molSig.signatureStringForVertex(0);
   Assert.assertEquals(expected, centralSignature);
 }
  @Test
  public void getAromaticEdgeLabelTest() {
    IAtomContainer benzeneRing = builder.newInstance(IAtomContainer.class);
    for (int i = 0; i < 6; i++) {
      benzeneRing.addAtom(builder.newInstance(IAtom.class, "C"));
    }
    for (int i = 0; i < 6; i++) {
      IAtom a = benzeneRing.getAtom(i);
      IAtom b = benzeneRing.getAtom((i + 1) % 6);
      IBond bond = builder.newInstance(IBond.class, a, b);
      benzeneRing.addBond(bond);
      bond.setFlag(CDKConstants.ISAROMATIC, true);
    }

    MoleculeSignature molSignature = new MoleculeSignature(benzeneRing);
    System.out.println("" + molSignature.toFullString());
    List<AbstractVertexSignature> signatures = molSignature.getVertexSignatures();
    for (AbstractVertexSignature signature : signatures) {
      for (int i = 0; i < 6; i++) {
        Assert.assertEquals(
            "Failed for " + i, "p", ((AtomSignature) signature).getEdgeLabel(i, (i + 1) % 6));
      }
    }
  }
Beispiel #10
0
 @Test
 public void getSignatureForVertexTest() {
   Assert.assertNotNull(molSig.getVertexSignatures());
 }
Beispiel #11
0
 @Test
 public void getSignatureStringForVertexTest_height() {
   Assert.assertEquals("[C]", molSig.signatureStringForVertex(0, 0));
 }
Beispiel #12
0
 @Test
 public void getSignatureStringForVertexTest() {
   Assert.assertEquals("[C]([C])", molSig.signatureStringForVertex(0));
 }
Beispiel #13
0
 @Test
 public void getVertexCountTest() {
   Assert.assertEquals(mol.getAtomCount(), molSig.getVertexCount());
 }
Beispiel #14
0
 public String canonicalStringFromMolecule(IAtomContainer molecule) {
   MoleculeSignature signature = new MoleculeSignature(molecule);
   return signature.getGraphSignature();
 }
Beispiel #15
0
 public String fullStringFromMolecule(IAtomContainer molecule) {
   MoleculeSignature molSig = new MoleculeSignature(molecule);
   return molSig.toFullString();
 }
Beispiel #16
0
 public String canonicalStringFromSmiles(String smiles) throws InvalidSmilesException {
   IAtomContainer mol = parser.parseSmiles(smiles);
   MoleculeSignature signature = new MoleculeSignature(mol);
   return signature.toCanonicalString();
 }
Beispiel #17
0
 @Test
 public void calculateOrbitsTest() {
   Assert.assertEquals(1, molSig.calculateOrbits().size());
 }
Beispiel #18
0
 public List<String> getAtomicSignatures(IAtomContainer molecule) {
   MoleculeSignature signature = new MoleculeSignature(molecule);
   return signature.getVertexSignatureStrings();
 }
Beispiel #19
0
 @Test
 public void fromSignatureStringTest() {
   String signatureString = molSig.toCanonicalString();
   IAtomContainer reconstructed = MoleculeSignature.fromSignatureString(signatureString, builder);
   Assert.assertEquals(mol.getAtomCount(), reconstructed.getAtomCount());
 }
Beispiel #20
0
 @Test
 public void toCanonicalSignatureStringTest() {
   Assert.assertEquals("[C]", molSig.toCanonicalSignatureString(0));
 }