pub_soft/rdkit
3
0
Fork 0
mirror of https://github.com/rdkit/rdkit.git synced 2026-06-03 21:44:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

initial addition of avalontoolkit support

Browse Source
This commit is contained in:
Greg Landrum
2011-12-23 06:17:39 +00:00
parent 0c06670340
commit 2575bfbfb6
21 changed files with 2165 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@@ -1,4 +1,5 @@
cmake_minimum_required(VERSION 2.6)
cmake_policy(SET CMP0015 OLD)
project (RDKit)
IF(NOT CMAKE_BUILD_TYPE)
@@ -16,9 +17,11 @@ option(RDK_BUILD_SWIG_WRAPPERS "build the experimental SWIG wrappers" OFF )
option(RDK_BUILD_PYTHON_WRAPPERS "build the standard python wrappers" ON )
option(RDK_BUILD_COMPRESSED_SUPPLIERS "build in support for compressed MolSuppliers" OFF )
option(RDK_BUILD_INCHI_SUPPORT "build the rdkit inchi wrapper" OFF )
option(RDK_BUILD_AVALON_SUPPORT "install support for the avalon toolkit. Use the variable AVALONTOOLS_DIR to set the location of the source." OFF )
option(RDK_INSTALL_INTREE "install the rdkit in the source tree (former behavior)" ON )
option(RDK_INSTALL_STATIC_LIBS "install the rdkit static libraries" ON )
# At build time put runtime binaries in the bin subdirectory
set(RDK_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
set(RDK_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/lib")

41
Code/JavaWrappers/AvalonLib.i Executable file
View File

@@ -0,0 +1,41 @@
/*
* $Id$
*
* Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Novartis Institutes for BioMedical Research Inc.
* nor the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
%include "std_pair.i"
%{
#include <AvalonTools/AvalonTools.h>
%}
%template(StringInt_Pair) std::pair<std::string, int >;
%include <AvalonTools/AvalonTools.h>

8
Code/JavaWrappers/CMakeLists.txt
View File

@@ -22,6 +22,9 @@ if(WIN32)
if(RDK_BUILD_INCHI_SUPPORT)
set(RDKit_Wrapper_Libs RDInchiLib ${INCHI_LIBRARIES} ${RDKit_Wrapper_Libs})
endif(RDK_BUILD_INCHI_SUPPORT)
if(RDK_BUILD_AVALON_SUPPORT)
set(RDKit_Wrapper_Libs AvalonLib avalon_clib ${RDKit_Wrapper_Libs})
endif(RDK_BUILD_AVALON_SUPPORT)
else()
set(RDKit_Wrapper_Libs
FileParsers_static SmilesParse_static
@@ -37,8 +40,9 @@ else()
if(RDK_BUILD_INCHI_SUPPORT)
set(RDKit_Wrapper_Libs RDInchiLib_static Inchi_static ${RDKit_Wrapper_Libs})
endif(RDK_BUILD_INCHI_SUPPORT)
if(RDK_BUILD_AVALON_SUPPORT)
set(RDKit_Wrapper_Libs AvalonLib_static avalon_clib_static ${RDKit_Wrapper_Libs})
endif(RDK_BUILD_AVALON_SUPPORT)
endif()
add_subdirectory(gmwrapper)

41
Code/JavaWrappers/gmwrapper/CMakeLists.txt
View File

@@ -1,5 +1,7 @@
project (jGraphMolJava Java)
include_directories( ${RDKit_ExternalDir} )
find_package(Java REQUIRED)
find_package(JNI REQUIRED)
@@ -21,7 +23,6 @@ INCLUDE_DIRECTORIES(${JNI_INCLUDE_DIRS})
SET_SOURCE_FILES_PROPERTIES(GraphMolJava.i PROPERTIES CPLUSPLUS ON )
FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../*.java COPY_SOURCE)
FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/src/org/RDKit COPY_DEST)
@@ -47,6 +48,14 @@ else()
endif()
SET(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_SOURCE_DIR}/src/org/RDKit )
if(RDK_BUILD_INCHI_SUPPORT)
SET(CMAKE_SWIG_FLAGS "-DBUILD_INCHI_SUPPORT" ${CMAKE_SWIG_FLAGS} )
endif()
if(RDK_BUILD_AVALON_SUPPORT)
SET(CMAKE_SWIG_FLAGS "-DBUILD_AVALON_SUPPORT" ${CMAKE_SWIG_FLAGS} )
endif()
# enable this line to build the ErrorGenerator class for testing handling of C++ errors in the JNI layer
#SET(CMAKE_SWIG_FLAGS ${CMAKE_SWIG_FLAGS} "-D INCLUDE_ERROR_GENERATOR" )
@@ -54,7 +63,6 @@ SWIG_ADD_MODULE(GraphMolWrap "java" GraphMolJava.i)
SET(SWIG_MODULE_GraphMolWrap_EXTRA_DEPS ../*.i)
SWIG_LINK_LIBRARIES(GraphMolWrap ${RDKit_Wrapper_Libs} )
# code adapted from the wrapper code for
@@ -97,9 +105,20 @@ ADD_CUSTOM_TARGET(GraphMolWrapJar ALL
## Tests -- note that building/rebuilding them keys on the file WrapperTests.class
SET(CMAKE_JAVA_TEST_OUTDIR ${CMAKE_CURRENT_SOURCE_DIR}/build-test )
FILE(GLOB JAVA_TEST_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src-test/org/RDKit/*.java")
# we added all source files, now remove the ones that we're not supporting in this build:
if(NOT RDK_BUILD_AVALON_SUPPORT)
LIST(REMOVE_ITEM JAVA_TEST_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src-test/org/RDKit/AvalonLibTests.java")
endif()
if(NOT RDK_BUILD_INCHI_SUPPORT)
LIST(REMOVE_ITEM JAVA_TEST_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src-test/org/RDKit/InchiTests.java")
endif()
ADD_CUSTOM_COMMAND(
OUTPUT ${CMAKE_JAVA_TEST_OUTDIR}/org/RDKit/WrapperTests.class
COMMAND ${JAVA_COMPILE} -d ${CMAKE_JAVA_TEST_OUTDIR} -cp "${CMAKE_CURRENT_SOURCE_DIR}/org.RDKit.jar${PATH_SEP}${JUNIT_JAR}" "src-test/org/RDKit/*.java"
COMMAND ${JAVA_COMPILE} -d ${CMAKE_JAVA_TEST_OUTDIR} -cp "${CMAKE_CURRENT_SOURCE_DIR}/org.RDKit.jar${PATH_SEP}${JUNIT_JAR}" ${JAVA_TEST_FILES}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/org.RDKit.jar
)
@@ -208,7 +227,21 @@ ADD_TEST(JavaWrapperTests
java -Djava.library.path=${CMAKE_CURRENT_SOURCE_DIR}
-cp "${JUNIT_JAR}${PATH_SEP}${CMAKE_JAVA_TEST_OUTDIR}${PATH_SEP}${CMAKE_CURRENT_SOURCE_DIR}/org.RDKit.jar"
org.RDKit.WrapperTests)
if(RDK_BUILD_AVALON_SUPPORT)
ADD_TEST(JavaAvalonTests
java -Djava.library.path=${CMAKE_CURRENT_SOURCE_DIR}
-cp "${JUNIT_JAR}${PATH_SEP}${CMAKE_JAVA_TEST_OUTDIR}${PATH_SEP}${CMAKE_CURRENT_SOURCE_DIR}/org.RDKit.jar"
org.RDKit.AvalonLibTests)
endif(RDK_BUILD_AVALON_SUPPORT)
if (RDK_BUILD_INCHI_SUPPORT)
ADD_TEST(JavaInchiTests
java -Djava.library.path=${CMAKE_CURRENT_SOURCE_DIR}
-cp "${JUNIT_JAR}${PATH_SEP}${CMAKE_JAVA_TEST_OUTDIR}${PATH_SEP}${CMAKE_CURRENT_SOURCE_DIR}/org.RDKit.jar"
org.RDKit.InchiTests)
endif (RDK_BUILD_INCHI_SUPPORT)
#ADD_TEST(JavaMemoryTests
# java -Djava.library.path=${CMAKE_CURRENT_SOURCE_DIR}
# -cp "${JUNIT_JAR}${PATH_SEP}${CMAKE_JAVA_TEST_OUTDIR}${PATH_SEP}${CMAKE_CURRENT_SOURCE_DIR}/org.RDKit.jar"

4
Code/JavaWrappers/gmwrapper/GraphMolJava.i
View File

@@ -249,6 +249,10 @@ typedef unsigned long long int uintmax_t;
}
%include "../Descriptors.i"
#ifdef BUILD_AVALON_SUPPORT
%include "../AvalonLib.i"
#endif
#ifdef BUILD_INCHI_SUPPORT
%include "../Inchi.i"
#endif

83
Code/JavaWrappers/gmwrapper/src-test/org/RDKit/AvalonLibTests.java Normal file
View File

@@ -0,0 +1,83 @@
/*
* $Id$
*
* Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Novartis Institutes for BioMedical Research Inc.
* nor the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.RDKit;
import static org.junit.Assert.*;
import org.junit.Test;
public class AvalonLibTests extends GraphMolTest {
@Test public void testAvalonTools1() {
ROMol m1;
m1 = RWMol.MolFromSmiles("n1ccccc1");
String newsmi=RDKFuncs.getCanonSmiles(m1);
assertEquals(newsmi,"c1ccncc1",newsmi);
newsmi=RDKFuncs.getCanonSmiles("n1ccccc1",true);
assertEquals(newsmi,"c1ccncc1",newsmi);
}
@Test public void testStereochem() {
ROMol m1;
m1 = RWMol.MolFromSmiles("C[C@H](F)C(F)Cl");
RDKFuncs.assignStereochemistry(m1,true,true,true);
int nKnown=0;
int nPossible=0;
for(int i=0;i<m1.getNumAtoms();i++){
if(m1.getAtomWithIdx(i).hasProp("_CIPCode")){
nKnown++;
nPossible++;
} else if(m1.getAtomWithIdx(i).hasProp("_ChiralityPossible")){
nPossible++;
}
}
assertEquals(nKnown,1);
assertEquals(nPossible,2);
}
@Test public void testAvalonTools2() {
StringInt_Pair res;
res=RDKFuncs.checkMolString("c1ccccn1",true);
assertEquals(res.getSecond(),0,res.getSecond());
assertFalse(res.getFirst(),""==res.getFirst());
res=RDKFuncs.checkMolString("c1c(R)cccc1C1(CC-C(C)C1)",true);
assertEquals(1,res.getSecond());
assertEquals(res.getFirst(),"",res.getFirst());
}
public static void main(String args[]) {
org.junit.runner.JUnitCore.main("org.RDKit.AvalonLibTests");
}
}

54
Code/JavaWrappers/gmwrapper/src-test/org/RDKit/InchiTests.java Executable file
View File

@@ -0,0 +1,54 @@
/*
* $Id: ChemTests.java 131 2011-01-20 22:01:29Z ebakke $
*
* Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Novartis Institutes for BioMedical Research Inc.
* nor the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.RDKit;
import static org.junit.Assert.*;
import org.junit.Test;
public class InchiTests extends GraphMolTest {
@Test public void testInchi() {
ROMol m1;
m1 = RWMol.MolFromSmiles("C[C@H](F)C(F)Cl");
ExtraInchiReturnValues evs=new ExtraInchiReturnValues();
String inchi=RDKFuncs.MolToInchi(m1,evs);
String key=RDKFuncs.InchiToInchiKey(inchi);
assertEquals(inchi,"InChI=1S/C3H5ClF2/c1-2(5)3(4)6/h2-3H,1H3/t2-,3?/m0/s1");
assertEquals(key,"NCBHZPYEURSCDF-SCQFTWEKSA-N");
}
public static void main(String args[]) {
org.junit.runner.JUnitCore.main("org.RDKit.InchiTests");
}
}

607
Data/struchk/checkfgs.chk Executable file
View File

@@ -0,0 +1,607 @@
606 ! _N10_, 12.Dec.2008 incl. Sandoz R-...; C-C(=O)-D,T.
/* 00 */ "Li,Na,K,Rb,Cs,Fr,Tl+1"
/* 00 */ "Be,Mg,Ca,Sr,Ba,Ra,Sn,Pb+2"
/* 00 */ "Al,Ga,In,Tl,Sb,Bi,Fe+3"
/* 00 */ "B,Si,Ge,N,O,S,F,Cl,Br,I"
/* 00 */ "Cu,Ag,Au,Zn,Cd,Hg"
/* 00 */ "Cu,Ag,Au,Fe,Ru+1"
/* 00 */ "Cu,Zn,Cd,Hg,Fe+2"
/* 00 */ "Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re"
/* 00 */ "Au,Sc,Y,La,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu+3"
/* 00 */ "B-1"
/* 00R*/ "Ar,He,C,P,Sb"
/* 01 */ "B(-C,N)"
/* 01 */ "C(-B,C,Si,Ge,Sn,Pb,N,P,As,O,S,Se,Te,F,Cl,Br,I)"
/* 01 */ "C(-N,O,P,S,I+1)"
/* 01 */ "C(-B,C-1)"
/* 01 */ "C(=C,N,P,O,S)"
/* 01 */ "C(=N+1)"
/* 01 */ "C,N(#C,N)"
/* 01 */ "C,B,F,Cl,Br,I(-C.)"
/* 01 */ "C,B-1(-N+1)"
/* 01 */ "C-1(#N+1)"
/* 01 */ "C.(-C.)"
/* 01 */ "H,D,T(-C,Si,Ge,Sn,N,P,O,S,F,Cl,Br,I)"
/* 01 */ "C,F,Cl,Br,I(-B,P,As,Sb-1)"
/* 01 */ "Cl,Br,I(-Zn,Cd,Hg-1)"
/* 01 */ "F,Cl,Br,I(-T,D,H)"
/* 01 */ "F,Cl,Br,I(-N+1)"
/* 01 */ "F,Cl,Br,I(-Sn,Nb,V-1)"
/* 01 */ "N,O,S,F,Cl,Br,I(-C,Si,Ge,Sn,Pb,T,D,H,N,P,As,Sb,Bi,O,S,Se,Te,Po)"
/* 01 */ "N,O,F,Cl,Br,I(-F,Cl,Br,I)"
/* 01 */ "N,O,S,Br,Cl,I(-N+1)"
/* 01 */ "C,O(-B,Si-1)"
/* 01 */ "N(-S+1)"
/* 01 */ "N,O(=B,C,Si,Sn,Ge,N,P,As,Sb,S,Se,Cl,Br,I)"
/* 01 */ "N,O,S(=N,S,I+1)"
/* 01 */ "N(#N+1)"
/* 01 */ "O+1(#C)"
/* 01 */ "N+1(=N-1)"
/* 01 */ "N+1(-Pd,Pt)"
/* 01 */ "N+1(=N+1)"
/* 01 */ "N-1(=N+1)"
/* 01 */ "B-1(-P+1)"
/* 01 */ "O,S-1(-C,N,P,S)"
/* 01 */ "N,O,S-1(-N+1)"
/* 01 */ "O.(-C,N)"
/* 01 */ "O.(-N+1)"
/* 01 */ "P(-C,Si,Ge,Sn)"
/* 01 */ "S,Se(-C,Si,Ge,Sn,N,P,S)"
/* 01 */ "S,Se,Cl,Br,I(-P+1)"
/* 01 */ "S(=C,Sn,N,P,As,Sb,O,S)"
/* 01 */ "Se(=C,P,S)"
/* 01 */ "Si(-C)"
/* 01 */ "Li,Na,K,Cs,Rb,Fr,Cu,Ag(-C)"
/* 01 */ "Zn,Cd,Hg(=O)"
/* 01 */ "Al(#P)"
/* 01 */ "C(-Li,Na,K,Rb,Cs,Be,Mg,Ca,Sr,Ba,Al,Ga,In,Tl,Sb,Bi)"
/* 01 */ "C(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)"
/* 01 */ "N,O,S,F,Cl,Br,I(-Be,Mg,Ca,Sr,Ba,B,Al,Ga,In,Tl,Cu,Ag,Au,Zn,Cd,Hg)"
/* 01 */ "N,O,S,F,Cl,Br,I(-Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)"
/* 01 */ "N,O,S,F,Cl,Br,I(-Sc,Y,La,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu)"
/* 01 */ "P(#Al)"
/* 01 */ "C,N,O,S,F,Cl,Br,I(-Cu,Ag,Au,Mn,Ru,Al-1)"
/* 01 */ "C,O,F,Cl,Br,I(-Fe,Co,Ni,Mn,Ru,Al-2)"
/* 01 */ "O(=Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt,Zn,Cd,Hg,Sc,Ti,V,Cr,Mn,Y,Zr,Nb,Mo,La,Hf,Ta,W,Re)"
/* 01 */ "C(=Ru-2)"
/* 01 */ "O,Cl(-Co,Mn,Ru-3)"
/* 01 */ "O,Cl(-Pd-1)"
/* 01 */ "N+1(-Co-3)"
/* 01 */ "N,O(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Ala(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Arg(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Asn(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Asp(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Cys(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Gln(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Glu(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Gly(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "His(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Ile(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Leu(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Lys(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Met(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Phe(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Pro(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Ser(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Thr(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Trp(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Tyr(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01 */ "Val(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 01R*/ "Ba,Ca,Mg,Pb(=O)"
/* 01R*/ "F,Cl,Br,I(-H)"
/* 01R*/ "H(-N,O,S,F,Cl,Br,I)"
/* 01R*/ "O(=O,Ba,Ca,Mg,Al,Bi,Pb)"
/* 01R*/ "O(=N.)"
/* 01R*/ "S(=Mo)"
/* 01R*/ "C-1(#O+1)"
/* 01R*/ "H(-Al)"
/* 01R*/ "H(-Fe+1)"
/* 01R*/ "H(-N+1)"
/* 01R*/ "Hyd(-Hyd)"
/* 01R*/ "O+1(#C-1)"
/* 01S*/ "R(-C,N,O)"
/* 01S*/ "X(-N)"
/* 02 */ "B(-C,N)(-C,N,P,O,S)"
/* 02 */ "B(-N+1)(-C,N)"
/* 02 */ "B-1(-N+1)(-C)"
/* 02 */ "B(=O)(-O)"
/* 02 */ "C(-B,C,Si)(-B,C,Si,Ge,Sn,Pb,N,P,O,S,Se,Te,F,Cl,Br,I,D,T)"
/* 02 */ "C(-N,P,O,S,Se,Te,F,Cl,Br,I)(-N,P,O,S,Se,Te,F,Cl,Br,I)"
/* 02 */ "C(-C,Si,P,S)(-B-1)"
/* 02 */ "C(-P+1)(-B-1)"
/* 02 */ "C(-N,P,O,S,I+1)(-B,C,Si,N,O,P,S,Se,F,Cl,Br,I)"
/* 02 */ "C(-N,P+1)(-N,P+1)"
/* 02 */ "C(-Sn,Pb)(-Sn,Pb,N,P,O,S)"
/* 02 */ "C(=C,N)(-B,F,Cl,Br,I,H,D,T)"
/* 02 */ "C(=C,N,P,O,S)(-C,Si,Ge,Sn,N,P,O,S,Se)"
/* 02 */ "C(=C,N)(-N,P,S,Se+1)"
/* 02 */ "C(=C)(-C+1)"
/* 02 */ "C(=C)(-C-1)"
/* 02 */ "C(=C,N,O,S)(=C,N,O,S)"
/* 02 */ "C(=O+1)(-C)"
/* 02 */ "C(=N,S+1)(-C,N,P,O,S)"
/* 02 */ "C(=N+1)(-N+1)"
/* 02 */ "C(=N+1)(=N)"
/* 02 */ "C(=P)(-C)"
/* 02 */ "C(=Ru-2)(-N,O,S)"
/* 02 */ "C(=Ru-3)(-C)"
/* 02 */ "C(#C,N,S)(-H,D,T,B,C,Si,Ge,Sn,N,P,O,S,Se,F,Cl,Br,I)"
/* 02 */ "C(#C)(-C+1)"
/* 02 */ "C(#N)(-N+1)"
/* 02 */ "C(#N)(-N,B-1)"
/* 02 */ "C(#N+1)(-C,N,P)"
/* 02 */ "C,N(-C.)(-C,Si,O)"
/* 02 */ "C(-C.)(=C,O)"
/* 02 */ "C.(-C.)(-C)"
/* 02 */ "C.(-C.)(-C.)"
/* 02 */ "I(-C)(-C)"
/* 02 */ "I(-I,Cl)(-I,Cl)"
/* 02 */ "I(=C,O)(-C)"
/* 02 */ "I+1(-C)(-C)"
/* 02 */ "N(-C,Si,N,P,O,S)(-B,C,Si,Ge,Sn,Pb,N,P,O,S,F,Cl,Br,I,H,D,T)"
/* 02 */ "N(-N,P,S+1)(-C,N,O,S)"
/* 02 */ "N(=C,N)(-B,C,Si,Sn,N,P,O,S,Se,F,Cl,Br,I,H,D,T)"
/* 02 */ "N(=C,N,O)(-N+1)"
/* 02 */ "N(=C)(-S+1)"
/* 02 */ "N(=C,N)(-B-1)"
/* 02 */ "N(=N,S+1)(-C,Si,Sn,N,P,O,S)"
/* 02 */ "N(=N-1)(-C)"
/* 02 */ "N(=O)(-C,N,O,S)"
/* 02 */ "N(=P,S,Se)(-C,Si,N,P,S)"
/* 02 */ "N(=S)(-Cl,Br,I)"
/* 02 */ "N(=O,S,P)(-N,P,S+1)"
/* 02 */ "N+1(=C)(-B)"
/* 02 */ "N+1(=N,P,S)(=N,P,S)"
/* 02 */ "N+1(=C,N)(=N-1)"
/* 02 */ "N+1(#C,N)(-O,S-1)"
/* 02 */ "N+1(#C-1)(-C,N)"
/* 02 */ "N+1(#N)(-C)"
/* 02 */ "N-1(-N+1)(-C,N,O)"
/* 02 */ "N-1(-N+1)(-N+1)"
/* 02 */ "N.(-C)(-N)"
/* 02 */ "O(-B,Al,Ga,In,Tl)(-B,C,Si,Sn,N,P,S)"
/* 02 */ "O(-C,Si,Ge,Sn,Pb,N,P,As,S,Se,T,D,H)(-C,Si,Ge,Sn,Pb,N,P,As,Sb,O,S,Se,Cl,Br,I)"
/* 02 */ "O(-N,P,S+1)(-C,Si,N,S)"
/* 02 */ "O(-I+1)(-C)"
/* 02 */ "C,O(-B,Si-1)(-C)"
/* 02 */ "O(-B-1)(-N+1)"
/* 02 */ "O(-N-1)(-C)"
/* 02 */ "O(-C.)(-C)"
/* 02 */ "O+1(=C)(-C)"
/* 02 */ "O+1(=C)(-Ru-2)"
/* 02 */ "P(-C,N,O)(-C,N,P,O)"
/* 02 */ "P(=C,N,O,S)(-C,N,O,S)"
/* 02 */ "S(-C,N,P,O,S)(-B,C,O,S,Se,N,P,As,Sb,F,Cl,Br,I,T,D,H)"
/* 02 */ "S(-C)(-Si,Ge,Sn,Pb)"
/* 02 */ "S(-N,P,S+1)(-C,N)"
/* 02 */ "S(-Sn)(-P,Sn)"
/* 02 */ "S(=C,N)(=C,N,O)"
/* 02 */ "S(=N)(=S+1)"
/* 02 */ "S(#C)(-N)"
/* 02 */ "S,Se+1(=C,N,P,S)(-C,N,S)"
/* 02 */ "S(-C.)(-C)"
/* 02 */ "Se,Te(-C,N)(-C,N,O,S,Se,Te,Cl,Br,I)"
/* 02 */ "Se(=N)(=N)"
/* 02 */ "Se(=N+1)(=N)"
/* 02 */ "Si(-C,Si,O,F,Cl,Br,I)(-C,O,F,Cl,Br,I)"
/* 02 */ "As(=O,S,N,P,As)(-C)"
/* 02 */ "Be,Mg,Ca,Sr,Ba(-C)(-C,N,P,O,S,F,Cl,Br,I)"
/* 02 */ "Sb(=O)(-C)"
/* 02 */ "Ge,Sn,Pb(-C,N,O,S,F,Cl,Br,I)(-C,Sn,N,O,S,F,Cl,Br,I)"
/* 02 */ "Au(-P+1)(-O,S,F,Cl,Br,I)"
/* 02 */ "Be,Mg,Ca,Sr,Ba(-N,O)(-N,O)"
/* 02 */ "Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re(-C,N,P,O,S,F,Cl,Br,I)(-C,N,P,O,S,F,Cl,Br,I)"
/* 02 */ "Cu,Ag,Au,Zn,Cd,Hg(-C,N,P,O,S,F,Cl,Br,I)(-C,N,P,O,S,F,Cl,Br,I)"
/* 02 */ "Cu,Ag,Au,Zn,Cd,Hg-1(-P,As+1)(-C,N,P,O,S,F,Cl,Br,I)"
/* 02 */ "Zn,Cd,Hg,Cr(-N+1)(-C,O,S)"
/* 02 */ "Ti(-O+1)(-O)"
/* 02 */ "Hg(-C.)(-F,Cl,Br,I)"
/* 02 */ "Au-1(-C)(-S)"
/* 02 */ "Au-1(-C)(-N+1)"
/* 02 */ "Au-1(-N,S+1)(-P+1)"
/* 02 */ "Pd-1(-Cl)(-P+1)"
/* 02 */ "Pd-1(-Cl+1)(-Cl+1)"
/* 02 */ "Ti-1(-O)(-O+1)"
/* 02 */ "C(-Li,Na,K,Rb,Cs,Be,Mg,Ca,Sr,Ba,Al,Ga,In,Tl,Sb,Bi)(-C)"
/* 02 */ "C(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)(-C)"
/* 02 */ "C(-Hg)(-Cl,Br,I)"
/* 02 */ "C(-Hg,Mg)(=C)"
/* 02 */ "C(-Li,Na,K,Rb,Cs)(#C)"
/* 02 */ "C(-Cu,Ag,Au,Zn,Cd,Hg)(#C,N)"
/* 02 */ "C(-Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)(#N)"
/* 02 */ "C(-Au-1)(-P+1)"
/* 02 */ "C(-Fe-2)(-C)"
/* 02 */ "C(-Fe-2)(#O+1)"
/* 02 */ "C(-Fe,Cr-3)(#O+1)"
/* 02 */ "C(-Pd,Pt-2)(#N)"
/* 02 */ "C(=Ru-2)(-C)"
/* 02 */ "N,O,S(-Be,Mg,Ca,Sr,Ba,Al,Ga,In,Tl,Sb,Bi)(-C,Si,N)"
/* 02 */ "N,O,S(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)(-C,Si,N)"
/* 02 */ "N(-Be,Mg,Ca,Sr,Ba,Al,Ga,In,Tl,As,Sb,Bi)(=C)"
/* 02 */ "N(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)(=O)"
/* 02 */ "N,O,S(-Cu,Fe,Co,Ni,Cr,Mn,Ti-1)(-C,Si,N)"
/* 02 */ "N,O,S(-Fe,Co,Ni,Mn-2)(-C,Si,N)"
/* 02 */ "N,O,S(-Mn-3)(-C,Si,N)"
/* 02 */ "O(-Cu,Ag,Au,Zn,Cd,Hg)(-N,P,S,B,Al,Ga,In,Tl)"
/* 02 */ "O(-Hg)(-N+1)"
/* 02 */ "O(-Mn)(-Cl)"
/* 02 */ "O(-V)(-O)"
/* 02 */ "O(-Sc,Y,La,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu)(-C)"
/* 02 */ "O,S(-Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)(-N,P,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)"
/* 02 */ "S(-Au-1)(-C)"
/* 02 */ "O(-Zr,Cr,V,Zn,Al-2)(-C)"
/* 02 */ "O(-Cr-3)(-C)"
/* 02 */ "O(-Co-2)(-N+1)"
/* 02 */ "O(-Fe,V-3)(-Fe,V-3)"
/* 02 */ "O(-Fe,Co,Ni,V,Nb,Ta-3)(-C)"
/* 02 */ "O(-Fe,Co,Ni,V,Nb,Ta-3)(=C)"
/* 02 */ "N+1(-Cu,Zn,Cd,Ni,Pd,Pt)(-C)"
/* 02 */ "O,S+1(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt,Sc,Y,La,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Tc,Re)(=C)"
/* 02 */ "N+1(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt)(#C)"
/* 02 */ "N+1(-Mn-1)(-C,N)"
/* 02 */ "O+1(-Ti-1)(=C)"
/* 02 */ "N+1(-Ni,Mn-2)(-C,N)"
/* 02 */ "O+1(-Mn,V-2)(=C)"
/* 02 */ "N+1(-Ru-2)(#C)"
/* 02 */ "N+1(-Co-3)(-C)"
/* 02 */ "O+1(-Fe,Co,Ni,V,Nb,Ta-3)(=C)"
/* 02 */ "C,Cl+1(-Al,Ru-1)(-Ru-1)"
/* 02 */ "Cl+1(-Rh-3)(-Rh-3)"
/* 02 */ "Cl+1(-Pd-1)(-Pd-1)"
/* 02 */ "S(-Cys)(-S)"
/* 02 */ "N,O,S(-C)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val(-C)(-N,O,S)"
/* 02 */ "Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val(-C,N,O,S)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Ala(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Arg(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Asn(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Asp(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Cys(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Gln(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Glu(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Gly(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "His(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Ile(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Leu(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Lys(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Met(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Phe(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Pro(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Ser(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Thr(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Trp(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Tyr(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02 */ "Val(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 02R*/ "Al,Bi,Sb(=O)(-O)"
/* 02R*/ "C(=O)(-H)"
/* 02R*/ "Cl(=O)(-O)"
/* 02R*/ "Cr,Fe(=O)(-O)"
/* 02R*/ "Mn,Mo(=O,S)(=O,S)"
/* 02R*/ "N.(=O)(=O)"
/* 02R*/ "O(-Al,Bi,Sb)(-Al,Bi,Sb)"
/* 02R*/ "O(-C,B)(-O,H)"
/* 02R*/ "O(-Cr,Mn,Fe,Co)(-S)"
/* 02R*/ "O(-Fe)(-Fe,V)"
/* 02R*/ "O(-O,S,H)(-H)"
/* 02R*/ "O(-Zn)(-N+1)"
/* 02R*/ "S(-Cl)(-Cl)"
/* 02R*/ "S(-H)(-H)"
/* 02R*/ "S,Si(=O)(=O)"
/* 02R*/ "Ti,Zr(=O)(=O)"
/* 02R*/ "Al+1(-N)(-N)"
/* 02R*/ "O(-N+1)(-H)"
/* 02R*/ "O(-Al-1)(-C)"
/* 02R*/ "Fe+1(-C)(-C)"
/* 02R*/ "Mn+2(-N)(-N)"
/* 02S*/ "C,N,O(-C)(-R,X)"
/* 03 */ "B(-C,N,O,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)"
/* 03 */ "B(-N+1)(-C,N)(-N,O,F,Cl,Br,I)"
/* 03 */ "B(-N+1)(-F,Cl,Br,I)(-F,Cl,Br,I)"
/* 03 */ "B-1(-N+1)(-C)(-C)"
/* 03 */ "C(-B)(-B,C,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)"
/* 03 */ "C(-C,N,P,O,S,Se,F,Cl,Br,I)(-C,N,P,O,S,F,Cl,Br,I)(-C,F,Cl,Br,I,D,T)"
/* 03 */ "C(-C,Si,Ge,Sn,Pb,N,P,O,S,Se)(-C,Si,Ge,Sn,Pb,N,P,O,S)(-Si,Ge,Sn,Pb,N,P,O,S)"
/* 03 */ "C(-C)(-Si)(-F,Cl,Br,I)"
/* 03 */ "C(-C)(-C)(-B-1)"
/* 03 */ "C(-N,P,S+1)(-C,N,O,S,F,Cl,Br,I)(-C,N,P,O,S,F,Br,Cl,I,D,T)"
/* 03 */ "C(-C+1)(=C)(-C,N)"
/* 03C*/ "C(-C+1)(-C)(-C)"
/* 03 */ "C(-I+1)(-C)(-C)"
/* 03 */ "C(-N+1)(-N+1)(-C)"
/* 03 */ "C(=C)(-B)(-B,C,N,O,S)"
/* 03 */ "C(=C)(-C,Si,Ge,Sn,Pb)(-C,Si,Ge,Sn,Pb,O,S,Se,Te,N,P,As,F,Cl,Br,I,D,T)"
/* 03 */ "C(=C)(-O,S,Se,Te,N,P,F,Cl,Br,I)(-O,S,Se,Te,N,P,F,Cl,Br,I)"
/* 03 */ "C(=C)(-N,P,As,S,I+1)(-C,N,P,O,S)"
/* 03 */ "C(=C)(-N+1)(-F,Cl,Br,I)"
/* 03 */ "C(=C)(-N+1)(-N+1)"
/* 03 */ "C(=C)(-O+1)(-C,N)"
/* 03 */ "C(=C,N)(-B,C,Sn-1)(-C)"
/* 03 */ "C(=I)(-C)(-C)"
/* 03 */ "C(=N,P)(-C,N,P,O,S,F,Cl,Br,I)(-B,C,N,P,O,S,Se,Te,F,Cl,Br,I)"
/* 03 */ "C(=N,P)(-C,N,P,S)(-Si,Ge,Sn,H,D,T)"
/* 03 */ "C(=O,S,Se)(-C,N,P,O,S,Se,F,Cl,Br,I)(-C,N,P,O,S,Se,Cl,Br,I,D,T)"
/* 03 */ "C(=O)(-B,Cl,Br)(-N,O,Cl,Br)"
/* 03 */ "C(=O)(-Si,Ge,Sn)(-C,N,O)"
/* 03 */ "C(=N)(-N+1)(-C,N,P,O,S,F,Cl,Br,I)"
/* 03 */ "C(=N)(-O,S,I+1)(-C,N)"
/* 03 */ "C(=N,P)(-P,S+1)(-N,P,S)"
/* 03 */ "C(=O,S)(-N,P+1)(-C,N,O,S)"
/* 03 */ "C(=O)(-N+1)(-O,S-1)"
/* 03 */ "C(=N+1)(-O,S,Se,Te)(-S,Se,Te,Cl,Br,I)"
/* 03 */ "C(=N+1)(-C,N)(-C,N,P,O,S,Se,Te,F,Cl,Br,I)"
/* 03 */ "C(=N+1)(-N+1)(-C,N)"
/* 03 */ "C(=O,S+1)(-C)(-C,N,O,S)"
/* 03 */ "C(=S+1)(-N)(-N)"
/* 03 */ "C(=O,S,Se+1)(-S)(-S)"
/* 03 */ "B,C,Si(-C.)(-C,F,Cl,Br,I)(-C,N,P,O,F,Cl,Br,I)"
/* 03 */ "C(-C.)(=C,O,N)(-C,N,P,O,S)"
/* 03 */ "C(-N,O.)(=C,N)(-C,N)"
/* 03 */ "C(-N+1.)(=C)(-C)"
/* 03 */ "C+1(-C)(-C)(-C)"
/* 03 */ "C-1(-I,N+1)(-C)(-C)"
/* 03 */ "C-1(-S+1)(-S)(-S)"
/* 03 */ "C.(-C.)(-C.)(-C,Si,Sn,N,P,O,S,B,F,Cl,Br,I)"
/* 03 */ "C.(-C.)(-C.)(-B-1)"
/* 03 */ "I(-C)(-C,O,S,F,Cl)(-O,S,F,Cl)"
/* 03 */ "I(=O)(=O)(-C)"
/* 03 */ "I+1(=O)(-C)(-C)"
/* 03 */ "Cl,Br,I(=O)(=O)(-O)"
/* 03 */ "N(-B)(-B,C,N)(-C,S)"
/* 03 */ "N(-C,N,P,O,S)(-C,N,P,O,S,Se,T,D,H)(-C,N,P,O,S,Se,T,D,H)"
/* 03 */ "N(-C,S)(-C,N,O,S,F,Cl,Br,I)(-F,Cl,Br,I)"
/* 03 */ "N(-C,Si,N)(-Si,Sn)(-C,Si,N,P,O,S)"
/* 03 */ "N(-C)(-C)(-B-1)"
/* 03 */ "N(-N,P,S+1)(-C,N)(-C,N,O,S)"
/* 03 */ "N(-N,O.)(-C)(-C)"
/* 03 */ "N+1(=C)(-C,Si,Ge,Sn,N,O,S)(-C,Si,N,O,S)"
/* 03 */ "N+1(=C)(-C)(-B,F,Cl,Br,I)"
/* 03 */ "N+1(=C)(-C,N,S,B-1)(-C)"
/* 03 */ "N+1(=C,O)(-O-1)(-C,N,O)"
/* 03 */ "N+1(=C,O)(-O-1)(-N+1)"
/* 03 */ "N+1(=C,O)(-O-1)(-N-1)"
/* 03 */ "N+1(=C)(-Ru-2)(-C)"
/* 03 */ "N+1(=C)(-Ru-3)(-C)"
/* 03 */ "N+1(-O.)(=C)(-C)"
/* 03 */ "N+1(=N)(-C,Si)(-C,Si,N,O,S)"
/* 03 */ "N+1(=N,O)(-N,O-1)(-C,N,S)"
/* 03 */ "N+1(=O,S,Se)(-C)(-C)"
/* 03 */ "N+1(=N+1)(-C)(-C)"
/* 03 */ "N+1(=N+1)(-O-1)(-C,S)"
/* 03 */ "N+1.(-C)(-C)(-C)"
/* 03 */ "O+1(-C)(-C)(-C)"
/* 03 */ "P(-Cl)(-Cl)(-Cl)"
/* 03 */ "P(-C,Si,N,O,S)(-C,Si,N,P,O,S,F,Cl,Br,I,T,D,H)(-C,Si,N,P,O,S,F,Cl,Br,I,T,D,H)"
/* 03 */ "P(=N,O,S)(-C,N,O)(-C,N,O,S)"
/* 03 */ "P(-C.)(-C)(-C)"
/* 03 */ "S(=C)(-C,N,O,S)(-C,N,O,S,F,Cl,Br,I)"
/* 03 */ "S(=C,O)(=O)(=O)"
/* 03 */ "S(=C)(-N+1)(-C)"
/* 03 */ "S(=N,O)(-C,N,O,S,F,Cl,Br,I)(-C,N,P,O,S,F,Cl,Br,I)"
/* 03 */ "S(=P)(-C,O)(-C,N,O)"
/* 03 */ "S(=S)(-C,N)(-C,N,P)"
/* 03 */ "S(=N+1)(-C)(-C)"
/* 03 */ "S(-C.)(=N)(-N)"
/* 03 */ "S+1(-C)(-C)(-C,N,O,S)"
/* 03 */ "S+1(-S+1)(-C)(-C)"
/* 03 */ "Se,Te(=O)(-C)(-C,O)"
/* 03 */ "Si(-C,Si,N,O,S,F,Cl,Br,I)(-C,Si,N,O,S,F,Cl,Br,I)(-C,Si,N,O,S,F,Cl,Br,I)"
/* 03 */ "Al,Ga,In,Tl(-C,N,O,S)(-C,N,O,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)"
/* 03 */ "As,Sb,Bi(-C,O,S)(-C,O,S,F,Cl,Br,I)(-C,O,S,F,Cl,Br,I)"
/* 03 */ "Ge,Sn(=O,S)(-C,N)(-C,N,O,S)"
/* 03 */ "Sn(-C)(-C)(-C)"
/* 03 */ "Au(-O,S)(-O,S,F,Cl,Br,I)(-F,Cl,Br,I)"
/* 03 */ "Cu,Zn,Cd,Ni(-N+1)(-N)(-O)"
/* 03 */ "Sc,Y,La,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu(-N,O,F,Cl,Br,I)(-N,O,F,Cl,Br,I)(-O,F,Cl,Br,I)"
/* 03 */ "Fe,Co,Ni,Mn,Cr,Mo,W,Ru(-N,O,S,F,Cl,Br,I)(-N,O,S,F,Cl,Br,I)(-N,O,S,F,Cl,Br,I)"
/* 03 */ "Ti(-C,F,Cl,Br,I)(-N,O)(-N,O)"
/* 03 */ "Zr(-C)(-C)(-F,Cl,Br,I)"
/* 03 */ "Fe,Co,Ni,Cr,Mo,W,Cu(-N+1)(-N,O)(-N,O)"
/* 03 */ "Fe,Co,Ni,Cr,Mo,W,Cu(-N+1)(-N+1)(-N,O)"
/* 03 */ "Fe,V,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu(-N+1)(-N+1)(-N+1)"
/* 03 */ "Ti(=O)(-O)(-O)"
/* 03 */ "V(=O)(-O)(-O)"
/* 03 */ "V(=O)(=O)(-O)"
/* 03 */ "Zn,Cd,Hg-1(-Cl,Br,I)(-Cl,Br,I)(-Cl,Br,I)"
/* 03 */ "Co,Cr,Cu-1(-N+1)(-O)(-O)"
/* 03 */ "Ru-1(-P+1)(-F,Cl,Br,I)(-F,Cl,Br,I)"
/* 03 */ "Ru-1(-C,P,Cl,Br,I+1)(-O,Cl,Br,I+1)(-F,Cl,Br,I)"
/* 03 */ "Mn-1(-N+1)(-N+1)(-O)"
/* 03 */ "Cu-1(-N+1)(-N+1)(-N+1)"
/* 03 */ "Fe-2(-C,F,Cl,Br,I)(-C)(-C)"
/* 03 */ "Mn-2(-N+1)(-N+1)(-O)"
/* 03 */ "Ru-2(-N+1)(-N+1)(-N+1)"
/* 03 */ "Fe,Cr-3(-C)(-C)(-C)"
/* 03 */ "Cr-3(-P+1)(-C)(-C)"
/* 03 */ "Au-3(-P+1)(-S+1)(-S+1)"
/* 03 */ "C(-C)(-C)(-Li,Na,K,Rb,Cs,Be,Mg,Ca,Sr,Ba,Al,Ga,In,Tl,As,Sb,Bi)"
/* 03 */ "C(-C)(-C)(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)"
/* 03 */ "C(-S)(-S)(-Li,Na,K,Rb,Cs)"
/* 03 */ "C(=C,N)(-C)(-Li,Na,K,Rb,Cs,Be,Mg,Ca,Sr,Ba,Al,Ga,In,Tl,Sb,Bi)"
/* 03 */ "C(=C,N)(-C,O)(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)"
/* 03 */ "C(=C,O)(-O,S)(-Cu,Ag,Au,Zn,Cd,Hg,Ti)"
/* 03 */ "N(-C)(-C,N,S)(-Be,Mg,Ca,Sr,Ba,Al,Ga,In,Tl,Ge,Sn,Pb,Sb,Bi)"
/* 03 */ "N(-C,Si)(-C,N,Si)(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)"
/* 03 */ "N(-C)(-C,N)(-Sc,Y,La,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu)"
/* 03 */ "N(-C)(-C,N)(-Cu,Cr,Co-1)"
/* 03 */ "C(-C)(-C)(-Fe-2)"
/* 03 */ "C(=O)(-C)(-Fe-2)"
/* 03 */ "N(-C)(-C,N)(-Cu,Zn,Fe,Co,Ni,Cr-2)"
/* 03 */ "N(-C)(-N+1)(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt)"
/* 03 */ "N+1(-C)(-C)(-Zr,Mn,Co-2)"
/* 03 */ "N+1(-C)(-C)(-Co,Mn-3)"
/* 03 */ "N+1(=C,N)(-C,N,O)(-Al,Ge,Cu,Ag,Au,Zn,Cd,Hg)"
/* 03 */ "N+1(=C,N)(-C,N,O)(-Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt,Sc,Ti,V,Cr,Mn,Y,Zr,Nb,Mo,La,Hf,Ta,W,Re)"
/* 03 */ "N+1(=C,N)(-C,N,O)(-Mn,Sc,Y,La,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu)"
/* 03 */ "N+1(=C,N)(-C,N,O)(-Mn,Sc,Y,La,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu-3)"
/* 03 */ "N+1(=C,N)(-C)(-Cr,Co,Mn-3)"
/* 03 */ "N+1(=C,N)(-C,N,O)(-Cu,Zn,Cd,Fe,Co,Ni,Mn,Cr,Al-2)"
/* 03 */ "N+1(=C,N)(-C,N)(-Cu,Au,Fe,Co,Cr,Mn,Al-1)"
/* 03 */ "N+1(=C)(-N+1)(-Cu,Zn,Cd,Ni)"
/* 03 */ "N+1(=C)(-O-1)(-Cu,Zn,Cd,Ni-2)"
/* 03 */ "N+1(=C,N+1)(-C)(-Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt,Sc,Ti,V,Cr,Mn,Y,Zr,Nb,Mo,La,Hf,Ta,W,Re,Cu,Ag,Au,Zn,Cd,Hg)"
/* 03 */ "O,S+1(-C)(-C)(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt)"
/* 03 */ "O+1(-C)(-C)(-Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)"
/* 03 */ "O+1(-C)(-C)(-Ru-1)"
/* 03 */ "S+1(-Au-1)(-Au-3)(-C)"
/* 03 */ "P(-Zn)(-Zn)(-Zn)"
/* 03 */ "C.(-C.)(-C.)(-Hg)"
/* 03 */ "C(=O)(-C,O)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 03 */ "Cys(-S)(-C,O,Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)(-Ala,Arg,Asn,Asp,Cys,Gln,Glu,Gly,His,Ile,Leu,Lys,Met,Phe,Pro,Ser,Thr,Trp,Tyr,Val)"
/* 03R*/ "Al(-C)(-C)(-H)"
/* 03R*/ "C(-C)(-C)(-Fe+1)"
/* 03R*/ "C(=C)(-C)(-Fe+1)"
/* 03R*/ "C(=C,O)(-C,N,O,H)(-H)"
/* 03R*/ "Cr,Fe(-F,Cl)(-F,Cl)(-F,Cl,O)"
/* 03R*/ "Fe+1(-C)(-C)(-H)"
/* 03R*/ "N(-C,O,H)(-H)(-H)"
/* 03R*/ "Si(=O)(-O)(-O)"
/* 03R*/ "P(=O)(=O)(-O)"
/* 03R*/ "N(-C)(-C)(-Al+1)"
/* 03R*/ "N(-C)(-C)(-Mn+2)"
/* 03S*/ "C(-C)(-C)(-R)"
/* 03S*/ "C(=O)(-C)(-R)"
/* 03S*/ "N+1(-O-1)(-C)(-N)"
/* 04 */ "B-1(-C,N,O,F,Cl,Br,I)(-C,N,O,F,Cl,Br,I)(-C,N,O,F,Cl,Br,I)(-C,N,O,F,Cl,Br,I)"
/* 04 */ "B-1(-N+1)(-C,N,O)(-C,F,Cl,Br,I)(-C,F,Cl,Br,I)"
/* 04 */ "B-1(-C.)(-C)(-C)(-C)"
/* 04 */ "C(-B)(-C)(-C)(-C,S)"
/* 04 */ "C(-H,D,T)(-C,D,T,Cl,Br)(-C,D,T,N,P,O,S,Se,F,Cl,Br,I)(-B,C,D,T,N,P,O,S,Se,Te,F,Cl,Br,I)"
/* 04 */ "C(-H,D,T)(-N,P+1)(-C)(-C)"
/* 04 */ "C(-C,N,O,S)(-C,N,P,O,S)(-C,N,P,O,S,Se)(-C,N,P,O,S,Se,Te)"
/* 04 */ "C(-F,Cl,Br,I)(-C,O,S,F,Cl,Br,I)(-C,N,P,O,S,F,Cl,Br,I)(-C,N,P,O,S,Se,F,Cl,Br,I)"
/* 04 */ "C(-Si,Ge,Sn)(-C,Si,Ge,Sn,F,Cl,Br,I)(-C,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)"
/* 04 */ "C(-N,P,S,I+1)(-C,O,S)(-C,O,S)(-C,N,O,S,F,Cl,Br,I)"
/* 04 */ "C(-N,P+1)(-F,Cl,Br,I)(-F,Cl,Br,I)(-C,O,S,F,Cl,Br,I)"
/* 04 */ "C(-N+1)(-N+1)(-C)(-C,F,Cl,Br,I)"
/* 04 */ "C(-N+1)(-N+1)(-N+1)(-C)"
/* 04 */ "C(-N,P+1)(-B-1)(-C)(-C)"
/* 04 */ "C(-B,C-1)(-C)(-C)(-C)"
/* 04 */ "C,Si,Sn(-C.)(-C,F,Cl,Br,I)(-C,F,Cl,Br,I)(-C,O,F,Cl,Br,I)"
/* 04 */ "C(-C.)(-C.)(-C)(-C)"
/* 04 */ "Cl,Br,I(=O)(-C,O)(-C,O)(-C,O)"
/* 04 */ "Cl,Br,I(=O)(=O)(=O)(-O)"
/* 04 */ "N+1(-C)(-C)(-C)(-C,Sn,B,N,P,O,S,F,Cl,Br,I)"
/* 04 */ "N+1(-C,Si,B-1)(-C)(-C)(-C)"
/* 04 */ "N+1(-N,O,S-1)(-C)(-C,N)(-C,N,O)"
/* 04 */ "P(-C)(-C)(-C)(-N,O)"
/* 04 */ "P(-C)(-N,O)(-N,O)(-N,O)"
/* 04 */ "P(-N,O)(-N,O)(-N,O)(-N,O)"
/* 04 */ "P(=C)(-C,N,O)(-C,N,O)(-C,N,O)"
/* 04 */ "P(=O)(-H)(-C,N,O)(-C,N,O)"
/* 04 */ "P(=O,S,N,Se)(-C,Si,N,P,O,S,Se,F,Cl,Br,I)(-C,N,P,O,S,Se,F,Cl,Br,I)(-C,N,P,O,S,Se,F,Cl,Br,I)"
/* 04 */ "P(=O)(-N+1)(-O)(-S)"
/* 04 */ "P(=N,S+1)(-C)(-C)(-C)"
/* 04 */ "P(-C.)(=O)(-C)(-C)"
/* 04 */ "P+1(-C,N)(-C,N,O,S,Se)(-C,N,O,S,Se)(-C,N,O,S,Se,Cl,Br,I)"
/* 04 */ "P+1(-B-1)(-C)(-C)(-C)"
/* 04 */ "P+1(-Ru-3)(-C)(-C)(-C)"
/* 04 */ "S(-C)(-C,O)(-C,N,O,Cl,Br,I)(-C,O,P,Cl,Br,I)"
/* 04 */ "S(-N)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)"
/* 04 */ "S,Se(=C,N,O)(=N,O)(-C,N,O,S,F,Cl,Br,I)(-C,Sn,N,P,O,S,F,Cl,Br,I)"
/* 04 */ "S(=O)(=O)(-N+1)(-C,N,O)"
/* 04 */ "S(-C.)(=O)(=O)(-C)"
/* 04 */ "S+1(=O)(-C)(-C,O)(-C,N,O)"
/* 04 */ "S+1(=N)(-C)(-C)(-N)"
/* 04 */ "Se,Te(-C)(-C,Cl,Br,I)(-Cl,Br,I)(-Cl,Br,I)"
/* 04 */ "Si(-C,N,O,S)(-C,N,O,S,Cl,Br,I)(-C,N,P,O,S,Cl,Br,I)(-C,N,P,O,S,F,Cl,Br,I,H,D,T)"
/* 04 */ "Si(-Si)(-C,Si)(-C,Si)(-C,Si,O,F,Cl,Br,I,H,D,T)"
/* 04 */ "Si(-C,F,Cl,Br,I)(-C,F,Cl,Br,I)(-C,F,Cl,Br,I)(-C,F,Cl,Br,I)"
/* 04 */ "Si(-N+1)(-N+1)(-N)(-N)"
/* 04 */ "Si,Sn(-N+1)(-C)(-C)(-C)"
/* 04 */ "Ge(-C,O)(-C,O)(-C,O,S,Cl,Br,I)(-C,O,S,Cl,Br,I)"
/* 04 */ "Sn(-C,Sn)(-C,N,O,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I,D,T)"
/* 04 */ "Sn(-O,S,F,Cl,Br,I)(-O,S,F,Cl,Br,I)(-O,S,F,Cl,Br,I)(-O,S,F,Cl,Br,I)"
/* 04 */ "Pb(-C)(-C,N,O,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)"
/* 04 */ "As,Sb(=O,S)(-C,O)(-C,O)(-C,O)"
/* 04 */ "Al,Ge,Sn(-N+1)(-N+1)(-N,O)(-N,O)"
/* 04 */ "Al-1(-C+1)(-Cl,Br,I+1)(-C)(-C)"
/* 04 */ "Al-1(-N+1)(-N+1)(-O)(-O)"
/* 04 */ "Hg(-N)(-N)(-S)(-S)"
/* 04 */ "Cu,Ag,Au,Zn,Cd,Hg(-N,O+1)(-N,O)(-N,O)(-N,O)"
/* 04 */ "Cu,Ag,Au,Zn,Cd,Hg(-N,P,O+1)(-N,P,O+1)(-N,O,F,Cl,Br,I)(-N,O,F,Cl,Br,I)"
/* 04 */ "Fe,Co,Ni(-N,P,O,S+1)(-N,P,O,S+1)(-C,N,O,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)"
/* 04 */ "Cr,Mn,Mo,W,Re(-N,P,O,S+1)(-N,P,O,S+1)(-N,O,S,F,Cl,Br,I)(-N,O,S,F,Cl,Br,I)"
/* 04 */ "Ru,Rh,Pd,Os,Ir,Pt(-N,P,O,S+1)(-N,P,O,S+1)(-C,N,O,S,F,Cl,Br,I)(-C,N,O,S,F,Cl,Br,I)"
/* 04 */ "Ru,Rh,Pd,Os,Ir,Pt(-N,P,O,S+1)(-N,P,O,S+1)(-N,P,O,S+1)(-N,P,O,S+1)"
/* 04 */ "Cu-1(-N+1)(-N)(-O)(-O)"
/* 04 */ "Ru,Rh,Pd,Os,Ir,Pt-2(-C,N)(-C,N)(-C,N,O,F,Cl,Br,I)(-C,N,O,F,Cl,Br,I)"
/* 04 */ "Cu,Zn,Cd,Fe,Co,Ni,Mn,Ru-2(-N+1)(-N+1)(-N,O,F,Cl,Br,I)(-N,O,F,Cl,Br,I)"
/* 04 */ "Co-2(-N+1)(-N+1)(-N+1)(-F)"
/* 04 */ "Cu,Zn,Cd,Ni-2(-N+1)(-N+1)(-N+1)(-N+1)"
/* 04 */ "Rh-3(-Cl+1)(-Cl+1)(-P+1)(-P+1)"
/* 04 */ "Mn,Re(=O)(=O)(=O)(-O)"
/* 04 */ "Cr,Mo,W(=O,S)(=O,S)(-O,S)(-O,S)"
/* 04 */ "Ni(-C,S)(-C,S)(-C,S)(-C,S)"
/* 04 */ "Ni-1(-S)(-S)(-S)(-S)"
/* 04 */ "Mn-1(-N+1)(-O)(-O)(-O)"
/* 04 */ "Ti(-C,N,O,Cl)(-C,N,O,Cl)(-C,N,O,Cl)(-C,N,O,Cl)"
/* 04 */ "V(=O)(-C,O,S)(-C,O,S)(-C,O,S)"
/* 04 */ "Zr(-C,O,S)(-C,O,S,F,Cl,Br,I)(-N,O,S,F,Cl,Br,I)(-N,O,S,F,Cl,Br,I)"
/* 04 */ "C(-Zn)(-C)(-C,F,Cl,Br,I)(-F,Cl,Br,I)"
/* 04 */ "C(-Li,Na,K,Rb,Cs,Be,Mg,Ca,Sr,Ba,Al,Ga,In,Tl,Sb,Bi)(-C)(-C)(-C)"
/* 04 */ "C(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Ru,Os,Co,Rh,Ir,Ni,Pd,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Re)(-C)(-C)(-C)"
/* 04 */ "C(-Li,Na,K,Rb,Cs)(-N+1)(-C)(-C)"
/* 04 */ "P(-Zn)(=O)(-C)(-C)"
/* 04 */ "C(-Fe-2)(-C)(-C)(-C)"
/* 04 */ "N,P,As+1(-Cu,Ag,Au,Zn,Cd,Hg,Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt,Ti,Zr,Hf,V,Nb,Ta,Cr,Mo,W,Mn,Tc,Re)(-C)(-C)(-C)"
/* 04 */ "N,P,As+1(-Cu,Ag,Au,Zn,Cd,Hg-1)(-C)(-C)(-C)"
/* 04 */ "P+1(-Ru-1)(-C)(-C)(-C)"
/* 04 */ "P+1(-Pd-1)(-C)(-C)(-C)"
/* 04 */ "P+1(-Ru-2)(-C)(-C)(-C)"
/* 04 */ "N,P+1(-Au,Fe,Co,V,Mn,Cr-3)(-C)(-C)(-C)"
/* 04 */ "P+1(-Cr,Rh-3)(-O)(-O)(-O)"
/* 04R*/ "C(-C,Br,H)(-H)(-H)(-H)"
/* 04R*/ "C(-C,N)(-C,N,O,F,Cl,Br)(-H)(-H)"
/* 04R*/ "C(-C,O,Cl)(-C,F,Cl)(-F,Cl)(-H)"
/* 04R*/ "C(-C)(-H)(-H)(-N+1)"
/* 04R*/ "Co,Cu,Fe,Sc,Y,La,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu(-N,O)(-N,O)(-N,O)(-N,O)"
/* 04R*/ "Co,Cr-1(-O)(-O)(-O)(-O)"
/* 04R*/ "Ni(-N)(-N)(-O)(-O)"
/* 04R*/ "P(=O)(-H)(-H)(-O)"
/* 04R*/ "Zn(-O)(-O)(-S)(-S)"
/* 04R*/ "Al-1(-O)(-O)(-O)(-O)"
/* 05 */ "Al(-N+1)(-N+1)(-N)(-N)(-Cl,Br,I)"
/* 05 */ "As(-C)(-C)(-C)(-C,O)(-C,O,Cl,Br,I)"
/* 05 */ "Bi(-C)(-C)(-C)(-Cl)(-Cl)"
/* 05 */ "I(-C)(-O)(-O)(-O)(-O)"
/* 05 */ "P(-C,N,O)(-C,N,O)(-C,N,O,F,Cl,Br,I)(-C,O,F,Cl,Br,I)(-O,S,F,Cl,Br,I)"
/* 05 */ "Sb(-C)(-C)(-C)(-C,O,S,F,Cl,Br,I)(-C,O,S,F,Cl,Br,I)"
/* 05 */ "Si-1(-N+1)(-C)(-O)(-O)(-O)"
/* 05 */ "Sn-1(-C)(-C)(-C)(-Br)(-Cl)"
/* 05 */ "Cu,Zn,Cd,Ni(-S+1)(-N+1)(-N+1)(-O)(-O)"
/* 05 */ "Fe,Cr,Mn(-N,P,O+1)(-N,P,O+1)(-N,O)(-N,O)(-N,O,F,Cl,Br,I)"
/* 05 */ "Co,Mn,Al-2(-N,P,O+1)(-N,P,O+1)(-N,O)(-N,O)(-N,O,F,Cl,Br,I)"
/* 05 */ "Co,Mn-3(-N,P,O+1)(-N,P,O+1)(-N,P+1)(-N,O)(-N,O,F,Cl,Br,I)"
/* 05R*/ "P,Sb(-Cl)(-Cl)(-Cl)(-Cl)(-Cl)"
/* 05 */ "V(-O)(-O)(-O)(-O)(-O)"
/* 05 */ "V(=O)(-N,O+1)(-N,O+1)(-N,O)(-N,O)"
/* 05 */ "V-2(=O)(-N,O+1)(-N,O+1)(-N,O)(-N,O)"
/* 05 */ "Ru-2(=C)(-N,P,O+1)(-N,P,O+1)(-F,Cl,Br,I)(-F,Cl,Br,I)"
/* 05 */ "Ru-3(-P+1)(-P+1)(-P+1)(-Cl)(-Cl)"
/* 06 */ "Al(-N+1)(-N+1)(-N+1)(-O)(-O)(-O)"
/* 06 */ "Ge,Sn(-N,O+1)(-N,O+1)(-N,O)(-N,O)(-N,O,S,F,Cl,Br,I)(-N,O,S,F,Cl,Br,I)"
/* 06 */ "P(-N)(-O)(-O)(-O)(-O)(-O)"
/* 06 */ "S(-C)(-F)(-F)(-F)(-F)(-F)"
/* 06 */ "Si(-F)(-F)(-F)(-F)(-F)(-F)"
/* 06 */ "P,As,Sb-1(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)"
/* 06 */ "Nb,V-1(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)"
/* 06 */ "Ti(-C)(-C)(-C)(-C)(-C)(-C)"
/* 06 */ "Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)"
/* 06 */ "Fe,Co,Ni,Cr,Mn,Mo,W(-N,O+1)(-N,O+1)(-C,N,O)(-C,N,O)(-C,N,O,F,Cl,Br,I)(-C,N,O,F,Cl,Br,I)"
/* 06 */ "Fe,Co,Ni,Cr,Mn,Mo,W(-N,O+1)(-N,O+1)(-N,O+1)(-N,O)(-C,N,O,F,Cl,Br,I)(-C,N,O,F,Cl,Br,I)"
/* 06 */ "Fe,Co,Ni,Cr,Mn,Mo,W(-N,O+1)(-N,O+1)(-N,O+1)(-N,O+1)(-C,N,O,F,Cl,Br,I)(-C,N,O,F,Cl,Br,I)"
/* 06 */ "Ru,Rh,Pd,Os,Ir,Pt(-N,O+1)(-N,O+1)(-N,O+1)(-N,O+1)(-F,Cl,Br,I)(-F,Cl,Br,I)"
/* 06 */ "Fe,Co,Ni,Cr,Mn,Mo,W,Ru,Rh,Pd,Os,Ir,Pt(-N,O+1)(-N,O+1)(-N,O+1)(-N,O+1)(-N,O+1)(-N,O+1)"
/* 06 */ "Sc,Y,La,Ce,Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu-3(-N,O+1)(-N,O+1)(-N,O+1)(-N,O+1)(-N,O+1)(-N,O+1)"
/* 06 */ "Fe,Co,Cr-1(-N+1)(-N+1)(-N,O)(-N,O)(-O)(-O)"
/* 06 */ "Fe,Co,Ni,Cr,Zr-2(-N,O+1)(-N,O+1)(-C,N,O)(-C,N,O)(-C,N,O,F,Cl,Br,I)(-C,N,O,F,Cl,Br,I)"
/* 06 */ "Co-2(-N+1)(-N+1)(-N+1)(-Cl)(-Cl)(-Cl)"
/* 06 */ "Cr,Mn-3(-N+1)(-N+1)(-N+1)(-O)(-O)(-O)"
/* 06 */ "Fe-3(-N+1)(-N+1)(-N,O)(-N,O)(-O)(-O)"
/* 06 */ "Fe,Co,Ni,V,Nb,Ta-3(-N,O+1)(-N,O+1)(-N,O+1)(-N,O+1)(-O,Cl)(-O,Cl)"
/* 06 */ "Ru-3(=C)(-N+1)(-N+1)(-P+1)(-Cl)(-Cl)"
/* 06 */ "Co-3(-N+1)(-N+1)(-N+1)(-N+1)(-N+1)(-Cl)"
/* 06 */ "Co-3(-N+1)(-N+1)(-N+1)(-N+1)(-N+1)(-N+1)"
/* 07 */ "Zr(-N+1)(-N+1)(-N+1)(-N,O)(-N,O)(-N,O)(-O)"
/* 08 */ "Zr(-N+1)(-N+1)(-N+1)(-N+1)(-N,O)(-N,O)(-N,O)(-N,O)"

11
Data/struchk/checkfgs.opt Executable file
View File

@@ -0,0 +1,11 @@
# Parameter file for STRUCHK 2.0
# for use with CORDAT
#
ta \apps\chemistry\checkfgs.trn # augmented atom transformations
or # create data fields with STRUCHK results
ca \apps\chemistry\checkfgs.chk # table of allowed augmented atoms
cc # check for atom collisions
cl 3 # collision limit is 3% of bond length
cs # check stereo conventions
cn 999 # max number of atoms or bonds
l struchk.log

149
Data/struchk/checkfgs.trn Executable file
View File

@@ -0,0 +1,149 @@
145 ! T92 , 29.6.99: transform O-1(-I) --> O(-I) included.
/*A000*/ "Li,Na,K,Rb,Cs,Fr" --> "Li,Na,K,Rb,Cs,Fr+1" SAF metal
/*A010*/ "Be,Mg,Ca,Sr,Ba,Ra" --> "Be,Mg,Ca,Sr,Ba,Ra+2" SAF metal
/*A020*/ "Al,Ga,In,Tl" --> "Al,Ga,In,Tl+3" SAF metal
/*A030*/ "Sb,Bi" --> "Sb,Bi+3" SAF metal
/*A040*/ "Sn,Pb" --> "Sn,Pb+2" SAF metal
/*A080*/ "Sc,Y,La,Ce,Pr,Nd,Pm,Sm" --> "Sc,Y,La,Ce,Pr,Nd,Pm,Sm+3" SAF metal
/*A090*/ "Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu" --> "Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu+3" SAF metal
/*A100*/ "N,O,S,F,Cl,Br,I-1" --> "N,O,S,F,Cl,Br,I" SAF anion
/*A110*/ "N+1" --> "N" SAF ammonium
/*A201*/ "Li,Na,K(-N,O,S,Se,F,Cl,Br,I)" --> "Li,Na,K+1(?N,O,S,Se,F,Cl,Br,I)" SAF
/*A211*/ "Cs,Rb(-N,O,S,Se,F,Cl,Br,I)" --> "Cs,Rb+1(?N,O,S,Se,F,Cl,Br,I)" SAF
/*A302*/ "Be,Mg,Ca(-F,Cl,Br,I)(-F,Cl,Br,I)" --> "Be,Mg,Ca+2(?F,Cl,Br,I)(?F,Cl,Br,I)"
/*A312*/ "Sr,Ba(-F,Cl,Br,I)(-F,Cl,Br,I)" --> "Sr,Ba+2(?F,Cl,Br,I)(?F,Cl,Br,I)"
/*A322*/ "Pb(-F,Cl,Br,I)(-F,Cl,Br,I)" --> "Pb+2(?F,Cl,Br,I)(?F,Cl,Br,I)" SAF
/*A403*/ "Al,Ga(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)" --> "Al,Ga+3(?F,Cl,Br,I)(?F,Cl,Br,I)(?F,Cl,Br,I)"
/*A413*/ "In,Tl(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)" --> "In,Tl+3(?F,Cl,Br,I)(?F,Cl,Br,I)(?F,Cl,Br,I)"
/*A701*/ "Cu,Ag,Au,Hg(-N,O,S,Cl,Br,I)" --> "Cu,Ag,Au,Hg+1(?N,O,S,Cl,Br,I)" SAF
/*A702*/ "Zn(-N+1)(-N+1)" --> "Zn+2(?N)(?N)" SAF
/*A703*/ "Au(-F,Cl,Br,I)(-F,Cl,Br,I)(-F,Cl,Br,I)" --> "Au+3(?F,Cl,Br,I)(?F,Cl,Br,I)(?F,Cl,Br,I)"
/*A803*/ "Sc,Y,La,Ce,Pr,Nd,Pm,Sm(-O)(-O)(-O)" --> "Sc,Y,La,Ce,Pr,Nd,Pm,Sm+3(?O)(?O)(?O)"
/*A813*/ "Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu(-O)(-O)(-O)" --> "Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu+3(?O)(?O)(?O)"
/*AA04*/ "N(=C)(-C)(-C)(-F,Cl,Br,I)" --> "N+1(=C)(-C)(-C)(?F,Cl,Br,I)"
/*AA05*/ "N(-C)(-C)(-C)(-C)(-F,Cl,Br,I)" --> "N+1(-C)(-C)(-C)(-C)(?F,Cl,Br,I)"
/*AX02*/ "O+1(=C)(-B-1)" --> "O(=C)(?B)" bor addukt
/*B101*/ "N+1(-C,N,O)" --> "N(-C,N,O)" onium
/*B112*/ "N(-C+1)(-C,N)" --> "N(=C)(-C,N)" onium
/*B121*/ "N(-C+1)" --> "N(=C)" onium
/*B131*/ "N+1(=C,N)" --> "N(=C,N)" onium
/*B302*/ "N+1(-C)(-C,N)" --> "N(-C)(-C,N)" onium
/*B312*/ "N+1(=C)(-C,N)" --> "N(=C)(-C,N)" onium
/*b322*/ "N+1(=C)(-B-1)" --> "N(=C)(-B-1)" MAAG N4B
/*B503*/ "N+1(-C)(-C,N)(-C,N)" --> "N(-C)(-C,N)(-C,N)" onium
/*C002*/ "I+1(-C,O-1)(-C)" --> "I(=C,O)(-C)" ylid pos.
/*C012*/ "N+1(-O-1)(-N)" --> "N(=O)(-N)" ylid pos.
/*C103*/ "S+1(-C,O-1)(-C)(-C)" --> "S(=C,O)(-C)(-C)" ylid pos.
/*C204*/ "P+1(-C-1)(-C)(-C)(-C)" --> "P(=C)(-C)(-C)(-C)" ylid pos.
/*C214*/ "P+1(-O-1)(-N)(-N)(-N)" --> "P(=O)(-N)(-N)(-N)" ylid pos.
/*C224*/ "S+1(=O)(-C-1)(-C)(-C)" --> "S(=O)(=C)(-C)(-C)" ylid pos.
/*C301*/ "O-1(-P,S,I+1)" --> "O(=P,S,I)" ylid neg.
/*C402*/ "C-1(-P,S+1)(-C)" --> "C(=P,S)(-C)" ylid neg.
/*C503*/ "C-1(-S+1)(-C)(-C)" --> "C(=S)(-C)(-C)" ylid neg.
/*C513*/ "S-1(-C+1)(-C)(-C)" --> "S(=C)(-C)(-C)" ylid neg.
/*C601*/ "O(-I+1)" --> "O(=I)" ylid spez.
/*C702*/ "S(-C+1)(-C)" --> "S+1(=C)(-C)" ylid spez.
/*C803*/ "S(=O)(=O)(-C,N,O,F,Cl,Br,I)" --> "S(=O)(-O)(-C,N,O,F,Cl,Br,I)" R-SO-OH,O-SO-OH
/*C804*/ "P,As,Sb(~O)(~O)(~O)(~O)" --> "P,As,Sb(=O)(-O)(-O)(-O)" phosphate
/*C901*/ "N+1(=N-1)" --> "N-1(=N+1)" diazo
/*D004*/ "B(-O)(-O)(-O)(-O)" --> "B-1(-O)(-O)(-O)(-O)" complex ion
/*D104*/ "B+3(-O-1)(-O-1)(-O-1)(-O-1)" --> "B-1(-O)(-O)(-O)(-O)" complex ion
/*D306*/ "Si.(-F-1)(-F-1)(-F-1)(-F-1)(-F-1)(-F-1)" --> "Si(-F)(-F)(-F)(-F)(-F)(-F)"
/*D402*/ "Au(=P)(-O,S,F,Cl,Br,I)" --> "Au(-P+1)(-O,S,F,Cl,Br,I)" coord.comp.
/*D414*/ "Fe,Co,Ni(=P)(=P)(-F,Cl,Br,I)(-F,Cl,Br,I)" --> "Fe,Co,Ni(-P+1)(-P+1)(-F,Cl,Br,I)(-F,Cl,Br,I)" coord.comp.
/*D424*/ "Hg+2(-N)(-N)(-S-1)(-S-1)" -> "Hg(-N)(-N)(-S)(-S)" coord.comp.
/*D504*/ "P(=Cu,Ag,Au,Zn,Cd,Hg)(-C)(-C)(-C)" --> "P+1(-Cu,Ag,Au,Zn,Cd,Hg)(-C)(-C)(-C)" coord.comp.
/*D514*/ "P(=Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt)(-C)(-C)(-C)" --> "P+1(-Fe,Co,Ni,Ru,Rh,Pd,Os,Ir,Pt)(-C)(-C)(-C)" coord.comp.
/*D522*/ "O(=C)(-Sc,Ti,V,Cr,Mn,Fe,Co,Ni,Cu,Zn)" --> "O+1(=C)(-Sc,Ti,V,Cr,Mn,Fe,Co,Ni,Cu,Zn)" coord.comp.
/*D523*/ "N(=C,N)(-Al,Ge,V,Cr,Mn,Fe,Co,Ni,Cu,Zn)(-C,N,O)" --> "N+1(=C,N)(-Al,Ge,V,Cr,Mn,Fe,Co,Ni,Cu,Zn)(-C,N,O)" coord.comp.
/*D533*/ "O(-C)(-C)(-Cr,Mn,Fe,Co,Ni,Cu,Zn)" --> "O+1(-C)(-C)(-Cr,Mn,Fe,Co,Ni,Cu,Zn)" coord.comp.
/*E003*/ "N(=C)(=C)(-C)" --> "N+1(=C)(-C-1)(-C)" quart. N
/*E013*/ "N(=C)(=N,O)(-C,N,O)" --> "N+1(=C)(-N,O-1)(-C,N,O)" quart. N
/*E023*/ "N(=N)(=N,O)(-C)" --> "N+1(=N)(-N,O-1)(-C)" quart. N
/*E033*/ "N(=O)(=O)(-C,N,O)" --> "N+1(=O)(-O-1)(-C,N,O)" quart. N
/*E104*/ "N(=C,O,S)(-C)(-C,N)(-C,N,O)" --> "N+1(-C,O,S-1)(-C)(-C,N)(-C,N,O)" quart. N
/*E203*/ "N(=C,O)(=O)(-O-1)" --> "N+1(=C,O)(-O-1)(-O)" quart. N spez.
/*E302*/ "N(#C)(=O,S)" --> "N+1(#C)(-O,S-1)" quart. N
/*E402*/ "N(#N)(=C)" --> "N+1(=N-1)(=C)" quart. N
/*E502*/ "N+1(#N)(-C,N-1)" --> "N+1(=N-1)(=C,N)" quart. N
/*E601*/ "N(#N)" --> "N-1(=N+1)" quart. N allg.
/*F001*/ "C-1(#N)" --> "C(#N)" prot.
/*F002*/ "C(#N)(-C,O,S-1)" --> "C(#N)(-C,O,S)" prot.
/*F011*/ "C(-N,P,O,S-1)" --> "C(-N,P,O,S)" prot.
/*F012*/ "C(-C,N,O)(-N,P,O,S-1)" --> "C(-C,N,O)(-N,P,O,S)" prot.
/*F022*/ "C(=C)(-N,O-1)" --> "C(-C)(=N,O)" prot. enol
/*F032*/ "C(=C)(=N-1)" --> "C(-C)(#N)" prot. spez.
/*F042*/ "C(=O,S)(-O,S-1)" --> "C(=O,S)(-O,S)" prot.
/*F052*/ "N+1(=N-1)(=N-1)" --> "N+1(=N-1)(=N)" MAAG N3
/*F113*/ "C(-C)(-N,O,S-1)(-C,N,O)" --> "C(-C)(-N,O,S)(-C,N,O)" prot.
/*F123*/ "C(-C)(-O-1)(-N+1)" --> "C(-C)(-O)(-N+1)" prot.
/*F203*/ "C(=C)(-N-1)(-C,N)" --> "C(=C)(-N)(-C,N)" prot.
/*F213*/ "C(=C)(-O,S-1)(-C)" --> "C(=C)(-O,S)(-C)" prot. enol C
/*F223*/ "C(=C)(-O-1)(-N,O,S)" --> "C(-C)(=O)(-N,O,S)" prot. enol Het.
/*F233*/ "C(=C)(-S-1)(-N,S)" --> "C(-C)(=S)(-N,S)" prot. enol
/*F243*/ "C(=C)(-O-1)(-N+1)" --> "C(-C)(=O)(-N+1)" prot. enol
/*F303*/ "C(=N)(-C,N,O,S-1)(-C,N,O,S)" --> "C(=N)(-C,N,O,S)(-C,N,O,S)" prot.
/*F313*/ "C(=N)(-N-1)(-C,N)" --> "C(=N)(-N)(-C,N)" prot.
/*F323*/ "C(=N)(-N,O,S-1)(-N,P+1)" --> "C(=N)(-N,O,S)(-N,P+1)" prot.
/*F333*/ "C(=N+1)(-O,S-1)(-C,N)" --> "C(=N+1)(-O,S)(-C,N)" prot.
/*F343*/ "C(=N+1)(-N-1)(-S)" --> "C(=N+1)(-N)(-S)" prot.
/*F403*/ "C(=O)(-C,N,P,O,S-1)(-C,N,P,O,S)" --> "C(=O)(-C,N,P,O,S)(-C,N,P,O,S)" prot.
/*F413*/ "C(=S)(-C,N,O,S-1)(-N,P,O,S)" --> "C(=S)(-C,N,O,S)(-N,P,O,S)" prot.
/*F423*/ "C(=O)(-O,S-1)(-N+1)" --> "C(=O)(-O,S)(-N+1)" prot.
/*F503*/ "N(-N,O-1)(-C)(-C)" --> "N(-N,O)(-C)(-C)" prot.
/*F513*/ "N+1(-O-1)(-C)(-C)" --> "N(-O)(-C)(-C)" prot.
/*F523*/ "N+1(=C,O)(-O-1)(-O-1)" --> "N+1(=C,O)(-O-1)(-O)" prot.
/*F603*/ "P(=O)(-O-1)(-C,O)" --> "P(=O)(-O)(-C,O)" prot.
/*F703*/ "S,Se(=O)(-O-1)(-C,O)" --> "S,Se(=O)(-O)(-C,O)" prot.
/*F804*/ "C(-C)(-O-1)(-N)(-O)" --> "C(-C)(-O)(-N)(-O)" prot.
/*F904*/ "P,As(=O)(-O,S-1)(-C,N,O,S)(-C,N,O,S)" --> "P,As(=O)(-O,S)(-C,N,O,S)(-C,N,O,S)"
/*F914*/ "P(=S)(-O,S-1)(-C,N,O,S)(-C,N,O,S)" --> "P(=S)(-O,S)(-C,N,O,S)(-C,N,O,S)"
/*FA04*/ "S(=N)(=O)(-N,O-1)(-C,N,O,S)" --> "S(=N)(=O)(-N,O)(-C,N,O,S)" prot.
/*FA14*/ "S(=O)(=O)(-N,O-1)(-C,N,O,S)" --> "S(=O)(=O)(-N,O)(-C,N,O,S)" prot.
/*FA24*/ "S(=O)(=O)(-N,O-1)(-N+1)" --> "S(=O)(=O)(-N,O)(-N+1)" prot.
/*G003*/ "C(=N,O)(-N,P,O,S-1)(-N,P,O,S-1)" --> "C(=N,O)(-N,P,O,S)(-N,P,O,S)" prot.2x
/*G104*/ "P,As(=O)(-C,N,O)(-O-1)(-O-1)" --> "P,As(=O)(-C,N,O)(-O)(-O)" prot.2x
/*G204*/ "S(=O)(=O)(-O-1)(-O-1)" --> "S(=O)(=O)(-O)(-O)" prot. 2x
/*H003*/ "V(=O)(=O)(-O-1)" --> "V(=O)(=O)(-O)" prot. trans.met.
/*I001*/ "O-1(-B,N,P,As,O,Se,Cl,I)" --> "O(-B,N,P,As,O,Se,Cl,I)" prot. allg.
/*I011*/ "S-1(-S)" --> "S(-S)" prot. allg.
/*I021*/ "O-1(-V)" --> "O(-V)" prot. allg.
/*I101*/ "N-1(=C,N)" --> "N(=C,N)" prot. allg.
/*I202*/ "C-1(-C)(-C,N)" --> "C(-C)(-C,N)" prot. allg.
/*I212*/ "N-1(-C,N)(-C,N,S)" --> "N(-C,N)(-C,N,S)" prot. allg.
/*I303*/ "C-1(-C)(-C)(-C,N)" --> "C(-C)(-C)(-C,N)" prot. allg.
/*K002*/ "S(-C+1)(-S)" --> "S(-C)(=S+1)" MAAG special
/*K006*/ "Si-2(-F)(-F)(-F)(-F)(-F)(-F)" --> "Si(-F)(-F)(-F)(-F)(-F)(-F)" MAAG special
/*L000*/ "P,Sb-3" --> "P,Sb"
/*L000*/ "S-2" --> "S"
/*L100*/ "Ca+1(-O)" --> "Ca+2(?O)"
/*L100*/ "O-1(-O-1)" --> "O(=O)"
/*L200*/ "C(#N)(-Na)" --> "C(#N)(?Na+1)"
/*L200*/ "Ca(-O)(-S,Cl)" --> "Ca+2(?O)(?S,Cl)"
/*L200*/ "O(=C)(-Cr)" --> "O+1(=C)(-Cr)"
/*L300*/ "N(=O)(=O)(-N+1)" --> "N+1(=O)(-O-1)(-N+1)"
/*L300*/ "N(=C)(-C)(-Co,Ni,Cu)" --> "N+1(=C)(-C)(-Co,Ni,Cu)"
/*L400*/ "Al(-O)(-O)(-O)(-O)" --> "Al-1(-O)(-O)(-O)(-O)"
/*L200*/ "Ca,Ba,Mg(-O)(-O)" --> "Ca,Ba,Mg+2(?O)(?O)"
/*L100*/ "C+2(=O)" --> "C-1(#O+1)"
/*L400*/ "N+1(-H)(-H)(-H)(-O)" --> "N(-H)(-H)(-H)(?O)"
/*L400*/ "N(-O,Cl,Br)(-H)(-H)(-H)" --> "N(?O,Cl,Br)(-H)(-H)(-H)"
/*L500*/ "N+1(-Br-1)(-C)(-C)(-C)(-C)" --> "N+1(?Br)(-C)(-C)(-C)(-C)"
/*L100*/ "Ca(-O)" --> "Ca+2(?O)"
/*L200*/ "N(=N+3)(-C)" --> "N+1(#N)(-C)"
/*L200*/ "N+1(-C)(-H)" --> "N(-C)(-H)"
/*L200*/ "N+1(=N-1)(=O)" --> "N+1(#N)(-O-1)"
/*L200*/ "N+1(=O-1)(=O)" --> "N.(=O)(=O)"
/*L200*/ "O(=C)(-C)" --> "O+1(=C)(-C)"
/*L200*/ "O-1(-N+1)(-Na)" --> "O-1(-N+1)(?Na+1)"
/*L300*/ "Bi(-O)(-O)(-O)" --> "Bi+3(?O)(?O)(?O)"
/*L300*/ "Zn(-Cl)(-Cl)(-Cl)" --> "Zn-1(-Cl)(-Cl)(-Cl)"
/*L300*/ "N+1(=O)(=O)(-O)" --> "N+1(=O)(-O-1)(-O)"
/*L400*/ "S(=O)(=O)(=O)(-C,O)" --> "S(=O)(=O)(-O)(-C,O)"
/*L400*/ "Cr+1(-O)(-O)(-O)(-O)" --> "Cr-1(-O)(-O)(-O)(-O)"
/*L400*/ "Cr+2(-O)(-O)(-O)(-O)" --> "Cr-1(-O)(-O)(-O)(-O)"
/*L400*/ "Cr-3(-O)(-O)(-O)(-O)" --> "Cr-1(-O)(-O)(-O)(-O)"
/*L100*/ "H(-H)" --> "Hyd(-Hyd)"
/*====================================================================*/
/*B202*/ "I+1(-C)(-C)" --> "I(-C)(-C)" onium
/*F253*/ "C(=C)(-N+1)(-S-1)" --> "C(=C)(-N+1)(-S)" MAAG SH+Noxid

375
External/AvalonTools/AvalonTools.cpp vendored Executable file
View File

@@ -0,0 +1,375 @@
// $Id$
//
// Created by Greg Landrum, July 2008
//
#include <DataStructs/ExplicitBitVect.h>
#include <RDGeneral/Invariant.h>
#include <RDGeneral/RDLog.h>
#include <GraphMol/RDKitBase.h>
#include <GraphMol/FileParsers/FileParsers.h>
#include <GraphMol/SmilesParse/SmilesParse.h>
#include <GraphMol/SmilesParse/SmilesWrite.h>
#include <Geometry/point.h>
#include "AvalonTools.h"
extern "C" {
#include "local.h"
#include "reaccs.h"
#include "reaccsio.h"
#include "utilities.h"
#include "ssmatch.h"
#include "smi2mol.h"
#include "canonizer.h"
#include "layout.h"
#include "struchk.h"
extern int RunStruchk(struct reaccs_molecule_t **mpp,
struct data_line_t *data_list);
}
// already defined in struchk.c
// FILE *log_file=NULL;
namespace AvalonTools {
using namespace RDKit;
namespace {
char *getFp(struct reaccs_molecule_t *molPtr,unsigned int bitFlags,
bool isQuery,unsigned int nBytes){
PRECONDITION(molPtr,"bad molecule");
while(nBytes%4) ++nBytes;
char *fingerprint = TypeAlloc(nBytes, char);
SetFingerprintBits(molPtr,fingerprint,static_cast<int>(nBytes),
static_cast<int>(bitFlags),
static_cast<int>(isQuery),0);
if(!isQuery){
SetFingerprintBits(molPtr,fingerprint,static_cast<int>(nBytes),
static_cast<int>(bitFlags),
static_cast<int>(0),
ACCUMULATE_BITS|USE_DY_AROMATICITY);
}
return fingerprint;
}
void reaccsToFingerprint(struct reaccs_molecule_t *molPtr,std::vector<boost::uint32_t> &res,
unsigned int bitFlags=32767U,bool isQuery=false,bool resetVect=true,
unsigned int nBytes=64){
res.clear();
char *fingerprint=getFp(molPtr,bitFlags,isQuery,nBytes);
for(unsigned int i=0;i<nBytes;i+=4){
boost::uint32_t word;
word = fingerprint[i] | (fingerprint[i+1]<<8) | (fingerprint[i+2]<<16) | (fingerprint[i+3]<<24);
res.push_back(word);
}
MyFree(fingerprint);
};
void reaccsToFingerprint(struct reaccs_molecule_t *molPtr,ExplicitBitVect &res,
unsigned int bitFlags=32767U,bool isQuery=false,
bool resetVect=true,unsigned int nBytes=64){
PRECONDITION(molPtr,"bad molecule");
PRECONDITION(res.getNumBits()>=nBytes*8U,"res too small");
if(resetVect) res.clearBits();
char *fingerprint=getFp(molPtr,bitFlags,isQuery,nBytes);
for(unsigned int i=0;i<nBytes;++i){
char byte = fingerprint[i];
if(byte){
char mask=1;
for (int j=0;j<8;++j){
if(byte&mask){
res.setBit(i*8+j);
}
mask = mask<<1;
}
}
}
MyFree(fingerprint);
};
struct reaccs_molecule_t *reaccsGetCoords(struct reaccs_molecule_t *molPtr){
PRECONDITION(molPtr,"bad molecule");
RecolorMolecule(molPtr);
struct reaccs_molecule_t *res = LayoutMolecule(molPtr);
POSTCONDITION(res,"could not layout molecule");
return res;
};
struct reaccs_molecule_t *molToReaccs(ROMol &mol,bool viaSmiles=false){
struct reaccs_molecule_t *res;
if(viaSmiles || !mol.getNumConformers() ){
std::string smiles=MolToSmiles(mol,true);
res = SMIToMOL(smiles.c_str(),DY_AROMATICITY|ISOMERIC_SMILES);
} else {
std::string molB=MolToMolBlock(mol,true);
res= MolStr2Mol((char *)molB.c_str());
}
POSTCONDITION(res,"could not build a molecule");
return res;
}
struct reaccs_molecule_t *molToReaccs(const ROMol &mol){
if(!mol.getNumConformers()){
return molToReaccs(const_cast<ROMol &>(mol),true);
}
std::string molB=MolToMolBlock(mol);
struct reaccs_molecule_t *res= MolStr2Mol((char *)molB.c_str());
POSTCONDITION(res,"could not build a molecule");
return res;
}
struct reaccs_molecule_t *stringToReaccs(const std::string &data,bool isSmiles){
struct reaccs_molecule_t *res;
if(isSmiles){
res = SMIToMOL(data.c_str(),DY_AROMATICITY);
} else {
res= MolStr2Mol((char *)data.c_str());
}
if(!res){
if(isSmiles){
BOOST_LOG(rdErrorLog)<<"ERROR could not build molecule from smiles: "<<data<<std::endl;
} else {
BOOST_LOG(rdErrorLog)<<"ERROR could not build molecule from molblock: \n"<<data<<std::endl;
}
}
return res;
}
} // end of anonymous namespace
std::string getCanonSmiles(ROMol &mol,int flags){
if(flags==-1) flags=DB_STEREO | CENTER_STEREO;
std::string rdSmi=MolToSmiles(mol,true);
char *canSmiles = CanSmiles(const_cast<char *>(rdSmi.c_str()),flags);
std::string res;
if(canSmiles){
res=canSmiles;
MyFree(canSmiles);
}else {
BOOST_LOG(rdErrorLog)<<"ERROR: no smiles generated for molecule."<<std::endl;
}
return res;
}
void getAvalonFP(const ROMol &mol,ExplicitBitVect &res,
unsigned int nBits,
bool isQuery,
bool resetVect,
unsigned int bitFlags){
if(nBits%8) {
BOOST_LOG(rdWarningLog)<<"Warning: number of bits ("<<nBits<<") is not evenly divisible by 8. Rounding to the nearest byte."<<std::endl;
}
unsigned int nBytes = nBits/8;
struct reaccs_molecule_t *mp=molToReaccs(mol);
reaccsToFingerprint(mp,res,bitFlags,isQuery,resetVect,nBytes);
FreeMolecule(mp);
}
void getAvalonFP(const ROMol &mol,std::vector<boost::uint32_t> &res,
unsigned int nBits,
bool isQuery,
bool resetVect,
unsigned int bitFlags){
if(nBits%8) {
BOOST_LOG(rdWarningLog)<<"Warning: number of bits ("<<nBits<<") is not evenly divisible by 8. Rounding to the nearest byte."<<std::endl;
}
unsigned int nBytes = nBits/8;
struct reaccs_molecule_t *mp=molToReaccs(mol);
reaccsToFingerprint(mp,res,bitFlags,isQuery,resetVect,nBytes);
FreeMolecule(mp);
}
unsigned int set2DCoords(ROMol &mol,bool clearConfs){
struct reaccs_molecule_t *mp=molToReaccs(mol,false);
struct reaccs_molecule_t *mp2=reaccsGetCoords(mp);
//std::cerr<<"----\n"<<MolToMolStr(mp2)<<"--------\n";
TEST_ASSERT(mp2->n_atoms==mol.getNumAtoms());
RDKit::Conformer *conf = new RDKit::Conformer(mol.getNumAtoms());
conf->set3D(false);
for(unsigned int i=0;i<mol.getNumAtoms();++i){
RDGeom::Point3D loc(mp2->atom_array[i].x,mp2->atom_array[i].y,mp2->atom_array[i].z);
conf->setAtomPos(i,loc);
}
unsigned int res;
if (clearConfs) {
mol.clearConformers();
conf->setId(0);
mol.addConformer(conf);
res=0;
} else {
res=mol.addConformer(conf,true);
}
FreeMolecule(mp);
FreeMolecule(mp2);
return res;
}
std::string getCanonSmiles(const std::string &data,bool isSmiles,int flags){
if(flags==-1) flags=DB_STEREO | CENTER_STEREO;
char *smiles=0,*canSmiles=0;
if(!isSmiles){
struct reaccs_molecule_t *mp=stringToReaccs(data,isSmiles);
if(mp){
smiles = MOLToSMI(mp,ISOMERIC_SMILES);
FreeMolecule(mp);
canSmiles = CanSmiles(smiles, flags);
MyFree(smiles);
}
} else {
canSmiles = CanSmiles((char *)data.c_str(), flags);
}
std::string res="";
if(canSmiles){
res=canSmiles;
MyFree(canSmiles);
} else {
BOOST_LOG(rdErrorLog)<<"ERROR: no smiles generated for molecule."<<std::endl;
}
return res;
}
void getAvalonFP(const std::string &data,bool isSmiles,ExplicitBitVect &res,
unsigned int nBits,
bool isQuery,
bool resetVect,
unsigned int bitFlags){
if(nBits%8) {
BOOST_LOG(rdWarningLog)<<"Warning: number of bits ("<<nBits<<") is not evenly divisible by 8. Rounding to the nearest byte."<<std::endl;
}
unsigned int nBytes = nBits/8;
struct reaccs_molecule_t *mp=stringToReaccs(data,isSmiles);
if(mp){
reaccsToFingerprint(mp,res,bitFlags,isQuery,resetVect,nBytes);
FreeMolecule(mp);
} else {
BOOST_LOG(rdErrorLog)<<"ERROR: no fingeprint generated for molecule."<<std::endl;
}
}
void getAvalonFP(const std::string &data,bool isSmiles,std::vector<boost::uint32_t> &res,
unsigned int nBits,
bool isQuery,
bool resetVect,
unsigned int bitFlags){
if(nBits%8) {
BOOST_LOG(rdWarningLog)<<"Warning: number of bits ("<<nBits<<") is not evenly divisible by 8. Rounding to the nearest byte."<<std::endl;
}
unsigned int nBytes = nBits/8;
struct reaccs_molecule_t *mp=stringToReaccs(data,isSmiles);
if(mp){
reaccsToFingerprint(mp,res,bitFlags,isQuery,resetVect,nBytes);
FreeMolecule(mp);
} else {
BOOST_LOG(rdErrorLog)<<"ERROR: no fingeprint generated for molecule."<<std::endl;
}
}
std::string set2DCoords(const std::string &data,bool isSmiles){
struct reaccs_molecule_t *mp=stringToReaccs(data,isSmiles);
std::string res="";
if(mp){
struct reaccs_molecule_t *mp2=reaccsGetCoords(mp);
FreeMolecule(mp);
char *molB = MolToMolStr(mp2);
res=molB;
FreeMolecule(mp2);
MyFree(molB);
}
return res;
}
int _checkMolWrapper(struct reaccs_molecule_t **mpp){
if(!*mpp) return BAD_MOLECULE;
int res;
struct reaccs_molecule_t *tmp=*mpp;
res = RunStruchk(mpp,NULL);
if(*mpp != tmp) {
FreeMolecule(tmp);
}
return res;
}
/**
* Wrapper around struchk.CheckMol
* The molecule to check is passed in as a string. isSmiles
* should be set to TRUE if the molecule is encoded as SMILES,
* to FALSE if the molecule is encoded as sn MDL CTAB.
* mp is an output parameter - it will point to the checked
* molecule upon successful checking. In case of errors, mp may be 0.
**/
int checkMolString(const std::string &data, const bool isSmiles,
struct reaccs_molecule_t **mp) {
int errs = 0;
if(isSmiles){
*mp = SMIToMOL(data.c_str(),DY_AROMATICITY);
} else {
*mp= MolStr2Mol((char *)data.c_str());
}
if(*mp) {
errs = _checkMolWrapper(mp);
} else {
errs = BAD_MOLECULE;
}
return errs;
}
int initCheckMol(const std::string &optString) {
return InitCheckMol((char *) optString.c_str());
}
RDKit::ROMOL_SPTR checkMol(int &errs, RDKit::ROMol& inMol) {
bool viaSmiles = false;
struct reaccs_molecule_t *mp;
RDKit::ROMol *rMol = 0;
mp = molToReaccs(inMol, viaSmiles);
errs = _checkMolWrapper(&mp);
if(mp){
char *molStr = MolToMolStr(mp);
FreeMolecule(mp);
if(molStr){
rMol = MolBlockToMol(molStr);
MyFree(molStr);
}
}
return RDKit::ROMOL_SPTR(rMol);
}
RDKit::ROMOL_SPTR checkMol(int &errs, const std::string &data, const bool isSmiles) {
struct reaccs_molecule_t *mp;
errs = checkMolString(data, isSmiles, &mp);
if(mp) {
char *molStr = MolToMolStr(mp);
RDKit::ROMol *rMol = MolBlockToMol(molStr);
FreeMolecule(mp);
MyFree(molStr);
return RDKit::ROMOL_SPTR(rMol);
} else {
return RDKit::ROMOL_SPTR();
}
}
std::pair<std::string,int> checkMolString(const std::string &data, bool isSmiles){
struct reaccs_molecule_t *mp;
int errs = checkMolString(data, isSmiles, &mp);
std::string molStr;
if(mp) {
char *tmp=MolToMolStr(mp);
molStr = std::string(tmp);
FreeMolecule(mp);
MyFree(tmp);
} else {
molStr="";
}
return std::make_pair(molStr,errs);
}
void closeCheckMolFiles() {
CloseOpenFiles();
}
}

50
External/AvalonTools/AvalonTools.h vendored Executable file
View File

@@ -0,0 +1,50 @@
// $Id$
//
// Created by Greg Landrum, July 2008
//
#ifndef __AVALONTOOLS_H__
#define __AVALONTOOLS_H__
#include <string>
#include <GraphMol/RDKitBase.h>
#include <DataStructs/ExplicitBitVect.h>
#include <vector>
#include <boost/cstdint.hpp>
namespace AvalonTools {
static int avalonSSSBits=0x007FFF;
static int avalonSimilarityBits=0xF07FFF;
std::string getCanonSmiles(RDKit::ROMol &mol,int flags=-1);
void getAvalonFP(const RDKit::ROMol &mol,ExplicitBitVect &res,
unsigned int nBits=512,
bool isQuery=false,
bool resetVect=true,
unsigned int bitFlags=avalonSSSBits);
void getAvalonFP(const RDKit::ROMol &mol,std::vector<boost::uint32_t> &res,
unsigned int nBits=512,
bool isQuery=false,
bool resetVect=true,
unsigned int bitFlags=avalonSSSBits);
unsigned int set2DCoords(RDKit::ROMol &mol,bool clearConfs=true);
std::string getCanonSmiles(const std::string &data,bool isSmiles,int flags=-1);
void getAvalonFP(const std::string &data,bool isSmiles,ExplicitBitVect &res,
unsigned int nBits=512,
bool isQuery=false,
bool resetVect=true,
unsigned int bitFlags=avalonSSSBits);
void getAvalonFP(const std::string &data,bool isSmiles,std::vector<boost::uint32_t> &res,
unsigned int nBits=512,
bool isQuery=false,
bool resetVect=true,
unsigned int bitFlags=avalonSSSBits);
std::string set2DCoords(const std::string &data,bool isSmiles);
int initCheckMol(const std::string &optString);
RDKit::ROMOL_SPTR checkMol(int &errors, RDKit::ROMol& inMol);
RDKit::ROMOL_SPTR checkMol(int &errors, const std::string &data, bool isSmiles);
std::pair<std::string,int> checkMolString(const std::string &data, bool isSmiles);
void closeCheckMolFiles();
}
#endif

45
External/AvalonTools/CMakeLists.txt vendored Executable file
View File

@@ -0,0 +1,45 @@
if(RDK_BUILD_AVALON_SUPPORT)
set(AVALON_SRC_PATH ${AVALONTOOLS_DIR}/common)
add_definitions(-DBUILD_AVALON_SUPPORT)
set(avalon_clib_srcs ${AVALON_SRC_PATH}/layout.c
${AVALON_SRC_PATH}/symboltable.c
${AVALON_SRC_PATH}/patclean.c
${AVALON_SRC_PATH}/utilities.c
${AVALON_SRC_PATH}/symbol_lists.c
${AVALON_SRC_PATH}/stereo.c
${AVALON_SRC_PATH}/set.c
${AVALON_SRC_PATH}/perceive.c
${AVALON_SRC_PATH}/local.c
${AVALON_SRC_PATH}/graph.c
${AVALON_SRC_PATH}/geometry.c
${AVALON_SRC_PATH}/forio.c
${AVALON_SRC_PATH}/depictutil.c
${AVALON_SRC_PATH}/denormal.c
${AVALON_SRC_PATH}/casutils.c
${AVALON_SRC_PATH}/ssmatch.c
${AVALON_SRC_PATH}/rtutils.c
${AVALON_SRC_PATH}/smi2mol.c
${AVALON_SRC_PATH}/didepict.c
${AVALON_SRC_PATH}/pattern.c
${AVALON_SRC_PATH}/canonizer.c
${AVALON_SRC_PATH}/aacheck.c
${AVALON_SRC_PATH}/fixcharges.c
${AVALON_SRC_PATH}/struchk.c
${AVALON_SRC_PATH}/reaccsio.c
${AVALON_SRC_PATH}/hashcode.c
)
rdkit_library(avalon_clib ${avalon_clib_srcs})
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
include_directories(${AVALON_SRC_PATH})
rdkit_library(AvalonLib AvalonTools.cpp SHARED LINK_LIBRARIES avalon_clib FileParsers SmilesParse GraphMol DataStructs RDGeometryLib RDGeneral )
rdkit_test(testAvalonLib1 test1.cpp
LINK_LIBRARIES AvalonLib avalon_clib FileParsers SmilesParse GraphMol DataStructs RDGeometryLib RDGeneral)
add_subdirectory(Wrap)
endif(RDK_BUILD_AVALON_SUPPORT)

8
External/AvalonTools/Wrap/CMakeLists.txt vendored Executable file
View File

@@ -0,0 +1,8 @@
include_directories( ${RDKit_ExternalDir}/AvalonTools )
rdkit_python_extension(pyAvalonTools
pyAvalonTools.cpp
DEST Avalon
LINK_LIBRARIES
AvalonLib avalon_clib SmilesParse FileParsers GraphMol DataStructs RDGeometryLib RDGeneral RDBoost)
add_test(pyAvalonTools ${PYTHON_EXECUTABLE}
${CMAKE_CURRENT_SOURCE_DIR}/testAvalonTools.py)

262
External/AvalonTools/Wrap/pyAvalonTools.cpp vendored Executable file
View File

@@ -0,0 +1,262 @@
// $Id: pyAvalonTools.cpp 4504 2011-03-04 13:57:07Z landrgr1 $
//
// Created by Greg Landrum, July 2008
//
#include <boost/python.hpp>
#include <GraphMol/GraphMol.h>
#include <DataStructs/ExplicitBitVect.h>
#include <RDBoost/Wrap.h>
#include <AvalonTools.h>
#include <boost/cstdint.hpp>
extern "C" {
#include "struchk.h"
}
namespace python = boost::python;
namespace {
ExplicitBitVect *getAvalonFP(const RDKit::ROMol &mol,
unsigned int nBits,
bool isQuery,
bool resetVect,
unsigned int bitFlags){
ExplicitBitVect *res=new ExplicitBitVect(nBits);
AvalonTools::getAvalonFP(mol,*res,nBits,isQuery,resetVect,bitFlags);
return res;
}
python::list getAvalonFPAsWords(const RDKit::ROMol &mol,
unsigned int nBits,
bool isQuery,
bool resetVect,
unsigned int bitFlags){
std::vector<boost::uint32_t> words;
AvalonTools::getAvalonFP(mol,words,nBits,isQuery,resetVect,bitFlags);
python::list res;
for(std::vector<boost::uint32_t>::const_iterator ci=words.begin();
ci!=words.end();++ci){
res.append(static_cast<unsigned long>(*ci));
}
return res;
}
ExplicitBitVect *getAvalonFP(const std::string &data,bool isSmiles,
unsigned int nBits,
bool isQuery,
bool resetVect,
unsigned int bitFlags){
ExplicitBitVect *res=new ExplicitBitVect(nBits);
AvalonTools::getAvalonFP(data,isSmiles,*res,nBits,isQuery,resetVect,bitFlags);
return res;
}
python::list getAvalonFPAsWords(const std::string &data,bool isSmiles,
unsigned int nBits,
bool isQuery,
bool resetVect,
unsigned int bitFlags){
std::vector<boost::uint32_t> words;
AvalonTools::getAvalonFP(data,isSmiles,words,nBits,isQuery,resetVect,bitFlags);
python::list res;
for(std::vector<boost::uint32_t>::const_iterator ci=words.begin();
ci!=words.end();++ci){
res.append(static_cast<unsigned long>(*ci));
}
return res;
}
python::tuple CheckMolecule(const std::string &data, bool isSmiles) {
int errs = 0;
RDKit::ROMOL_SPTR rMol = AvalonTools::checkMol(errs, data, isSmiles);
return python::make_tuple(errs, rMol);;
}
python::tuple CheckMolecule(RDKit::ROMol &mol) {
int errs = 0;
RDKit::ROMOL_SPTR rMol = AvalonTools::checkMol(errs, mol);
return python::make_tuple(errs, rMol);;
}
python::tuple CheckMoleculeString(const std::string &data, bool isSmiles){
int errs = 0;
std::pair<std::string,int> res=AvalonTools::checkMolString(data,isSmiles);
return python::make_tuple(res.second,res.first);;
}
enum StruChkFlag {
bad_molecule=BAD_MOLECULE,
alias_conversion_failed=ALIAS_CONVERSION_FAILED,
transformed=TRANSFORMED,
fragments_found=FRAGMENTS_FOUND,
either_warning=EITHER_WARNING,
stereo_error=STEREO_ERROR,
dubious_stereo_removed=DUBIOUS_STEREO_REMOVED,
atom_clash=ATOM_CLASH,
atom_check_failed=ATOM_CHECK_FAILED,
size_check_failed=SIZE_CHECK_FAILED,
recharged=RECHARGED,
stereo_forced_bad=STEREO_FORCED_BAD,
stereo_transformed=STEREO_TRANSFORMED,
template_transformed=TEMPLATE_TRANSFORMED,
} ;
enum StruChkResult {
success=0,
bad_set=BAD_SET,
transformed_set=TRANSFORMED_SET,
} ;
}
BOOST_PYTHON_MODULE(pyAvalonTools) {
python::scope().attr("__doc__") =
"Module containing functionality from the Avalon toolkit.\n\
\n\
The functions currently exposed are:\n\
- GetCanonSmiles() : return the canonical smiles for a molecule\n\
- GetAvalonFP() : return the Avalon fingerprint for a molecule as\n\
an RDKit ExplicitBitVector\n\
- Generate2DCoords() : use the Avalon coordinate generator to create\n\
a set of 2D coordinates for a molecule\n\
Each function can be called with either an RDKit molecule or some\n\
molecule data as text (e.g. a SMILES or an MDL mol block).\n\
\n\
See the individual docstrings for more information.\n\
";
std::string docString = "returns canonical smiles for an RDKit molecule";
python::def("GetCanonSmiles", (std::string (*)(RDKit::ROMol &,int))AvalonTools::getCanonSmiles,
(python::arg("mol"), python::arg("flags")=-1),
docString.c_str());
docString = "Returns canonical smiles for some molecule data.\n\
If the isSmiles argument is true, the data is assumed to be SMILES, otherwise\n\
MDL mol data is assumed.";
python::def("GetCanonSmiles", (std::string (*)(const std::string &,bool,int))AvalonTools::getCanonSmiles,
(python::arg("molData"), python::arg("isSmiles"), python::arg("flags")=-1),
docString.c_str());
docString = "returns the Avalon fingerprint for an RDKit molecule";
python::def("GetAvalonFP",
(ExplicitBitVect *(*)(const RDKit::ROMol &,unsigned int,bool,bool,unsigned int))getAvalonFP,
(python::arg("mol"),
python::arg("nBits")=512,
python::arg("isQuery")=false,
python::arg("resetVect")=false,
python::arg("bitFlags")=AvalonTools::avalonSimilarityBits),
docString.c_str(),
python::return_value_policy<python::manage_new_object>());
docString = "returns the Avalon fingerprint for some molecule data.\n\
If the isSmiles argument is true, the data is assumed to be SMILES, otherwise\n\
MDL mol data is assumed.";
python::def("GetAvalonFP",
(ExplicitBitVect *(*)(const std::string&,bool,unsigned int,bool,bool,unsigned int))getAvalonFP,
(python::arg("molData"),python::arg("isSmiles"),
python::arg("nBits")=512,
python::arg("isQuery")=false,
python::arg("resetVect")=false,
python::arg("bitFlags")=AvalonTools::avalonSimilarityBits),
docString.c_str(),
python::return_value_policy<python::manage_new_object>());
docString = "Generates 2d coordinates for an RDKit molecule";
python::def("Generate2DCoords", (unsigned int (*)(RDKit::ROMol &,bool))AvalonTools::set2DCoords,
(python::arg("mol"),python::arg("clearConfs")=true),
docString.c_str());
docString = "returns an MDL mol block with 2D coordinates for some molecule data.\n\
If the isSmiles argument is true, the data is assumed to be SMILES, otherwise\n\
MDL mol data is assumed.";
python::def("Generate2DCoords", (std::string (*)(const std::string &,bool))AvalonTools::set2DCoords,
(python::arg("molData"),python::arg("isSmiles")),
docString.c_str());
docString = "returns the Avalon fingerprint for an RDKit molecule as a list of ints";
python::def("GetAvalonFPAsWords",
(python::list (*)(const RDKit::ROMol &,unsigned int,bool,bool,unsigned int))getAvalonFPAsWords,
(python::arg("mol"),
python::arg("nBits")=512,
python::arg("isQuery")=false,
python::arg("resetVect")=false,
python::arg("bitFlags")=AvalonTools::avalonSimilarityBits),
docString.c_str());
docString = "returns the Avalon fingerprint for some molecule data as a list of ints.\n\
If the isSmiles argument is true, the data is assumed to be SMILES, otherwise\n\
MDL mol data is assumed.";
python::def("GetAvalonFPAsWords",
(python::list (*)(const std::string&,bool,unsigned int,bool,bool,unsigned int))getAvalonFPAsWords,
(python::arg("molData"),python::arg("isSmiles"),
python::arg("nBits")=512,
python::arg("isQuery")=false,
python::arg("resetVect")=false,
python::arg("bitFlags")=AvalonTools::avalonSimilarityBits),
docString.c_str());
docString = "initializes the structure checker.\n\
The argument should contain option lines separated by embedded newlines.\
An empty string will be used if the argument is omitted.\
An non-zero error code is returned in case of failure.";
python::def("InitializeCheckMol",
(int(*)(const std::string&)) AvalonTools::initCheckMol,
(python::arg("options") = ""),
docString.c_str());
docString = "close open files used by molecule-checking functions.";
python::def("CloseCheckMolFiles",
AvalonTools::closeCheckMolFiles,
docString.c_str());
docString = "check a molecule passed in as a string.\n\
If the isSmiles argument is true, the string should represent the SMILES encoding\n\
of the molecule, otherwise it should be encoded as an MDL molfile.\n\
The first member of the return tuple contains the bit-encoded corrections made to the molecule.\n\
If possible, the molecule (corrected when appropriate) is returned as the second member of \n\
the return tuple. Otherwise, None is returned.";
python::def("CheckMolecule",
(python::tuple(*)(const std::string&, bool)) CheckMolecule,
(python::arg("molstring"), python::arg("isSmiles")),
docString.c_str());
docString = "check a molecule passed in as an RDKit molecule.\n\
The first member of the return tuple contains the bit-encoded corrections made to the molecule.\n\
If possible, the molecule (corrected when appropriate) is returned as the second member of \n\
the return tuple. Otherwise, None is returned.";
python::def("CheckMolecule",
(python::tuple(*)(RDKit::ROMol&)) CheckMolecule,
(python::arg("mol")),
docString.c_str());
docString = "check a molecule passed in as a string and returns the result as a string.\n\
If the isSmiles argument is true, the string should represent the SMILES encoding\n\
of the molecule, otherwise it should be encoded as an MDL molfile.\n\
The first member of the return tuple contains the bit-encoded corrections made to the molecule.\n\
If possible, a corrected CTAB for the molecule is returned as the second member of \n\
the return tuple.";
python::def("CheckMoleculeString",
CheckMoleculeString,
(python::arg("molstring"), python::arg("isSmiles")),
docString.c_str());
python::scope().attr("avalonSSSBits")=AvalonTools::avalonSSSBits;
python::scope().attr("avalonSimilarityBits")=AvalonTools::avalonSimilarityBits;
python::enum_<StruChkFlag>("StruChkFlag")
.value("bad_molecule",bad_molecule)
.value("alias_conversion_failed",alias_conversion_failed)
.value("transformed",transformed)
.value("fragments_found",fragments_found)
.value("either_warning",either_warning)
.value("stereo_error",stereo_error)
.value("dubious_stereo_removed",dubious_stereo_removed)
.value("atom_clash",atom_clash)
.value("atom_check_failed",atom_check_failed)
.value("size_check_failed",size_check_failed)
.value("recharged",recharged)
.value("stereo_forced_bad",stereo_forced_bad)
.value("stereo_transformed",stereo_transformed)
.value("template_transformed",template_transformed)
;
python::enum_<StruChkResult>("StruChkResult")
.value("success",success)
.value("bad_set",bad_set)
.value("transformed_set",transformed_set)
;
}

136
External/AvalonTools/Wrap/testAvalonTools.py vendored Executable file
View File

@@ -0,0 +1,136 @@
# $Id$
#
# Created by Greg Landrum, July 2008
#
from rdkit import RDConfig
import os
import unittest
from rdkit import DataStructs, Chem
from rdkit.Avalon import pyAvalonTools
struchk_conf_path = os.path.join(RDConfig.RDDataDir, 'struchk', '')
struchk_log_path = ''
STRUCHK_INIT = '''-ta %(struchk_conf_path)scheckfgs.trn
-or
-ca %(struchk_conf_path)scheckfgs.chk
-cc
-cl 3
-cs
-cn 999
-l %(struchk_log_path)sstruchk.log'''%locals()
def feq(v1,v2,tol=1e-4):
return abs(v1-v2)<tol
class TestCase(unittest.TestCase):
def setUp(self) :
pass
def test1(self):
m1 = Chem.MolFromSmiles('c1cccnc1')
smi = pyAvalonTools.GetCanonSmiles(m1)
self.failUnless(smi=='c1ccncc1')
smi = pyAvalonTools.GetCanonSmiles('c1cccnc1',True)
self.failUnless(smi=='c1ccncc1')
def test2(self):
tgts=['CC1=CC(=O)C=CC1=O','c2ccc1SC(=Nc1c2)SSC4=Nc3ccccc3S4','[O-][N+](=O)c1cc(Cl)c(O)c(c1)[N+]([O-])=O',
'N=C1NC=C(S1)[N+]([O-])=O','Nc3ccc2C(=O)c1ccccc1C(=O)c2c3',
'OC(=O)c1ccccc1C3=C2C=CC(=O)C(Br)=C2Oc4c3ccc(O)c4Br','CN(C)C2C(=O)c1ccccc1C(=O)C=2Cl',
'Cc3ccc2C(=O)c1ccccc1C(=O)c2c3[N+]([O-])=O',r'C/C(=N\O)/C(/C)=N/O',
'c1ccc(cc1)P(c2ccccc2)c3ccccc3']
d= file(os.path.join(RDConfig.RDDataDir,'NCI','first_200.props.sdf'),'r').read()
mbs = d.split('$$$$\n')[:10]
smis = [pyAvalonTools.GetCanonSmiles(mb,False) for mb in mbs]
self.failUnless(smis==tgts)
smis = [pyAvalonTools.GetCanonSmiles(smi,True) for smi in smis]
self.failUnless(smis==tgts)
def test3(self):
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1ccccn1'))
self.failUnlessEqual(len(bv),512)
self.failUnlessEqual(bv.GetNumOnBits(),21)
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1ccccc1'))
self.failUnlessEqual(bv.GetNumOnBits(),8)
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1nnccc1'))
self.failUnlessEqual(bv.GetNumOnBits(),29)
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1ncncc1'))
self.failUnlessEqual(bv.GetNumOnBits(),29)
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1ncncc1'),nBits=1024)
self.failUnlessEqual(len(bv),1024)
self.failUnless(bv.GetNumOnBits()>27)
def test4(self):
bv = pyAvalonTools.GetAvalonFP('c1ccccn1',True)
self.failUnlessEqual(bv.GetNumOnBits(),21)
bv = pyAvalonTools.GetAvalonFP('c1ccccc1',True)
self.failUnlessEqual(bv.GetNumOnBits(),8)
bv = pyAvalonTools.GetAvalonFP('c1nnccc1',True)
self.failUnlessEqual(bv.GetNumOnBits(),29)
bv = pyAvalonTools.GetAvalonFP('c1ncncc1',True)
self.failUnlessEqual(bv.GetNumOnBits(),29)
bv = pyAvalonTools.GetAvalonFP('c1ncncc1',True,nBits=1024)
self.failUnlessEqual(len(bv),1024)
self.failUnless(bv.GetNumOnBits()>27)
bv = pyAvalonTools.GetAvalonFP(Chem.MolToMolBlock(Chem.MolFromSmiles('c1ccccn1')),False)
self.failUnlessEqual(len(bv),512)
self.failUnlessEqual(bv.GetNumOnBits(),21)
bv = pyAvalonTools.GetAvalonFP(Chem.MolToMolBlock(Chem.MolFromSmiles('c1ccccc1')),False)
self.failUnlessEqual(bv.GetNumOnBits(),8)
def test4b(self):
words = pyAvalonTools.GetAvalonFPAsWords(Chem.MolFromSmiles('c1ccccn1'))
words2 = pyAvalonTools.GetAvalonFPAsWords(Chem.MolFromSmiles('Cc1ccccn1'))
self.failUnlessEqual(len(words),len(words2))
for i,word in enumerate(words):
self.failUnlessEqual(word&words2[i],word)
def test5(self):
m = Chem.MolFromSmiles('c1ccccc1C1(CC1)N')
pyAvalonTools.Generate2DCoords(m)
self.failUnlessEqual(m.GetNumConformers(),1)
self.failUnless(m.GetConformer(0).Is3D()==False)
def test6(self):
mb=pyAvalonTools.Generate2DCoords('c1ccccc1C1(CC1)N',True)
m = Chem.MolFromMolBlock(mb)
self.failUnlessEqual(m.GetNumConformers(),1)
self.failUnless(m.GetConformer(0).Is3D()==False)
def testRDK151(self):
smi="C[C@H](F)Cl"
m = Chem.MolFromSmiles(smi)
temp = pyAvalonTools.GetCanonSmiles(smi,True)
self.failUnlessEqual(temp,smi)
temp = pyAvalonTools.GetCanonSmiles(m)
self.failUnlessEqual(temp,smi)
def testStruChk(self):
smi_good='c1ccccc1C1(CC-C(C)C1)C'
smi_bad='c1c(R)cccc1C1(CC-C(C)C1)C'
r = pyAvalonTools.InitializeCheckMol(STRUCHK_INIT)
self.failUnlessEqual(r, 0)
(err, fixed_mol) = pyAvalonTools.CheckMolecule(smi_good, True)
self.failUnlessEqual(err, 0)
mol = Chem.MolFromSmiles(smi_good)
(err, fixed_mol)=pyAvalonTools.CheckMolecule(mol)
self.failUnlessEqual(err, 0)
(err, fixed_mol)=pyAvalonTools.CheckMoleculeString(smi_good,True)
self.failUnlessEqual(err, 0)
self.failIfEqual(fixed_mol,"")
self.failUnless(fixed_mol.find('M END')>0)
(err, fixed_mol)=pyAvalonTools.CheckMolecule(smi_bad, False)
self.failIfEqual(err, 0)
self.failIf(fixed_mol)
(err, fixed_mol)=pyAvalonTools.CheckMoleculeString(smi_bad, False)
self.failIfEqual(err, 0)
self.failIf(fixed_mol)
pyAvalonTools.CloseCheckMolFiles()
if __name__ == '__main__':
unittest.main()

15
External/AvalonTools/Wrap/test_list.py vendored Executable file
View File

@@ -0,0 +1,15 @@
tests=[
("python","testAvalonTools.py",{}),
]
longTests=[]
if __name__=='__main__':
import sys
from rdkit import TestRunner
failed,tests = TestRunner.RunScript('test_list.py',0,1)
sys.exit(len(failed))

262
External/AvalonTools/test1.cpp vendored Executable file
View File

@@ -0,0 +1,262 @@
// $Id$
//
// Created by Greg Landrum, July 2008
//
#include <RDGeneral/RDLog.h>
#include <GraphMol/RDKitBase.h>
#include <GraphMol/SmilesParse/SmilesParse.h>
#include <RDGeneral/Invariant.h>
#include <DataStructs/ExplicitBitVect.h>
#include "AvalonTools.h"
#include <string>
using namespace RDKit;
void test1(){
BOOST_LOG(rdInfoLog) << "testing canonical smiles generation" << std::endl;
{
ROMol *m = static_cast<ROMol *>(SmilesToMol("c1ccccc1"));
TEST_ASSERT(m);
std::string smi=AvalonTools::getCanonSmiles(*m);
TEST_ASSERT(smi=="c1ccccc1");
delete m;
}
{
ROMol *m = static_cast<ROMol *>(SmilesToMol("c1cccnc1"));
TEST_ASSERT(m);
std::string smi=AvalonTools::getCanonSmiles(*m);
TEST_ASSERT(smi=="c1ccncc1");
delete m;
}
{
ROMol *m = static_cast<ROMol *>(SmilesToMol("n1ccccc1"));
TEST_ASSERT(m);
std::string smi=AvalonTools::getCanonSmiles(*m);
TEST_ASSERT(smi=="c1ccncc1");
delete m;
}
{
std::string smi=AvalonTools::getCanonSmiles("n1ccccc1",true);
TEST_ASSERT(smi=="c1ccncc1");
}
{
std::string smi=AvalonTools::getCanonSmiles("c1cccnc1",true);
TEST_ASSERT(smi=="c1ccncc1");
}
BOOST_LOG(rdInfoLog) << "done" << std::endl;
}
void test2(){
BOOST_LOG(rdInfoLog) << "testing coordinate generation" << std::endl;
#if 0
{
RWMol *m = SmilesToMol("c1cccnc1");
TEST_ASSERT(m);
unsigned int confId=AvalonTools::set2DCoords(*m);
TEST_ASSERT(m->getNumConformers()==1);
TEST_ASSERT(confId==0);
delete m;
}
#endif
{
std::string molb = AvalonTools::set2DCoords("c1cccnc1",true);
TEST_ASSERT(molb!="");
}
BOOST_LOG(rdInfoLog) << "done" << std::endl;
}
void test3(){
BOOST_LOG(rdInfoLog) << "testing fingerprint generation" << std::endl;
{
ROMol *m = static_cast<ROMol *>(SmilesToMol("c1ccccn1"));
TEST_ASSERT(m);
ExplicitBitVect bv(512);
AvalonTools::getAvalonFP(*m,bv,512,false,true,0x00006FFF);
BOOST_LOG(rdInfoLog) << "c1ccccn1 " << bv.getNumOnBits() << std::endl;
TEST_ASSERT(bv.getNumOnBits()==19);
delete m;
}
{
ROMol *m = static_cast<ROMol *>(SmilesToMol("c1ccccc1"));
TEST_ASSERT(m);
ExplicitBitVect bv(512);
AvalonTools::getAvalonFP(*m,bv,512,false,true,0x006FFF);
BOOST_LOG(rdInfoLog) << "c1ccccn1 " << bv.getNumOnBits() << std::endl;
TEST_ASSERT(bv.getNumOnBits()==6);
delete m;
}
{
ROMol *m = static_cast<ROMol *>(SmilesToMol("c1nnccc1"));
TEST_ASSERT(m);
ExplicitBitVect bv(512);
AvalonTools::getAvalonFP(*m,bv,512,false,true,0x006FFF);
BOOST_LOG(rdInfoLog) << "c1nnccc1 " << bv.getNumOnBits() << std::endl;
TEST_ASSERT(bv.getNumOnBits()==27);
delete m;
}
{
ROMol *m = static_cast<ROMol *>(SmilesToMol("c1ncncc1"));
TEST_ASSERT(m);
ExplicitBitVect bv(512);
AvalonTools::getAvalonFP(*m,bv,512,false,true,0x006FFF);
BOOST_LOG(rdInfoLog) << "c1ncncc1 " << bv.getNumOnBits() << std::endl;
TEST_ASSERT(bv.getNumOnBits()==27);
delete m;
}
{
ExplicitBitVect bv(512);
AvalonTools::getAvalonFP("c1cccnc1",true,bv,512,false,true,0x006FFF);
BOOST_LOG(rdInfoLog) << "c1cccnc1 " << bv.getNumOnBits() << std::endl;
TEST_ASSERT(bv.getNumOnBits()==19);
}
{
ExplicitBitVect bv(512);
AvalonTools::getAvalonFP("c1ccccc1",true,bv,512,false,true,0x006FFF);
BOOST_LOG(rdInfoLog) << "c1ccccc1 " << bv.getNumOnBits() << std::endl;
TEST_ASSERT(bv.getNumOnBits()==6);
}
{
ROMol *m = static_cast<ROMol *>(SmilesToMol("c1cccnc1"));
TEST_ASSERT(m);
ExplicitBitVect bv(1024);
AvalonTools::getAvalonFP(*m,bv,1024,false,true,0x006FFF);
BOOST_LOG(rdInfoLog) << "c1cccnc1 " << bv.getNumOnBits() << std::endl;
TEST_ASSERT(bv.getNumOnBits()==20);
delete m;
}
{
ExplicitBitVect bv(2048);
AvalonTools::getAvalonFP("c1cocc1",true,bv,2048,false,true,0x006FFF);
BOOST_LOG(rdInfoLog) << "c1cocc1 " << bv.getNumOnBits() << std::endl;
TEST_ASSERT(bv.getNumOnBits()==48);
}
{
ExplicitBitVect bv(2048);
AvalonTools::getAvalonFP("C1=COC=C1",true,bv,2048,false,true,0x006FFF);
BOOST_LOG(rdInfoLog) << "C1=COC=C1 " << bv.getNumOnBits() << std::endl;
TEST_ASSERT(bv.getNumOnBits()==48);
}
BOOST_LOG(rdInfoLog) << "done" << std::endl;
}
void testRDK151(){
BOOST_LOG(rdInfoLog) << "testing Jira issue RDK-151: pyAvalonTools not generating chiral smiles from molecules" << std::endl;
{
std::string tSmi="C[C@H](F)Cl";
ROMol *m = static_cast<ROMol *>(SmilesToMol(tSmi));
TEST_ASSERT(m);
std::string smi=AvalonTools::getCanonSmiles(tSmi,true);
CHECK_INVARIANT(smi==tSmi,smi+"!="+tSmi);
smi=AvalonTools::getCanonSmiles(*m);
CHECK_INVARIANT(smi==tSmi,smi+"!="+tSmi);
delete m;
}
BOOST_LOG(rdInfoLog) << "done" << std::endl;
}
void testSmilesFailures(){
BOOST_LOG(rdInfoLog) << "testing handling of bad smiles strings" << std::endl;
{
std::string tSmi="C1C";
std::string smi=AvalonTools::getCanonSmiles(tSmi,true);
CHECK_INVARIANT(smi=="",smi);
}
BOOST_LOG(rdInfoLog) << "done" << std::endl;
}
void testSubstructFps(){
BOOST_LOG(rdInfoLog) << "testing substructure fingerprints " << std::endl;
{
ExplicitBitVect bv1(512),bv2(512);
AvalonTools::getAvalonFP("c1ccccc1",true,bv1,512,true,true,AvalonTools::avalonSSSBits);
AvalonTools::getAvalonFP("c1ccccc1C(F)(F)F",true,bv2,512);
TEST_ASSERT((bv1&bv2)==bv1);
AvalonTools::getAvalonFP("c1ccccc1C(F)(F)F",true,bv1,512);
TEST_ASSERT((bv1&bv2)==bv1);
AvalonTools::getAvalonFP("c1cccc(C)c1C(F)(F)F",true,bv2,512);
TEST_ASSERT((bv1&bv2)==bv1);
}
{
ExplicitBitVect bv1(512),bv2(512);
AvalonTools::getAvalonFP("c1ccccc1O",true,bv1,512,true,true,AvalonTools::avalonSSSBits);
AvalonTools::getAvalonFP("c1ccccc1OC",true,bv2,512);
TEST_ASSERT((bv1&bv2)==bv1);
}
BOOST_LOG(rdInfoLog) << "done" << std::endl;
}
void testStruChk(){
BOOST_LOG(rdInfoLog) << "testing structure checking " << std::endl;
{
int errs = 0;
RDKit::ROMOL_SPTR m = AvalonTools::checkMol(errs, "c1ccccc1",true);
TEST_ASSERT(errs==0);
m = AvalonTools::checkMol(errs, "c1c(R)cccc1C1(CC-C(C)C1)C",true);
TEST_ASSERT(errs!=0);
}
{
int errs = 0;
std::string res;
boost::tie(res,errs)=AvalonTools::checkMolString("c1ccccc1",true);
TEST_ASSERT(errs==0);
TEST_ASSERT(res!="");
boost::tie(res,errs)=AvalonTools::checkMolString("c1c(R)cccc1C1(CC-C(C)C1)C",true);
TEST_ASSERT(errs==1);
TEST_ASSERT(res=="");
}
BOOST_LOG(rdInfoLog) << "done" << std::endl;
}
void testBadMolfile() {
BOOST_LOG(rdInfoLog) << "testing handling bad molecules " << std::endl;
// some tests around dealing with bad mol blocks
{
std::string molb="SNAP007157A\n\
MACCS-II3194121345\n\
\n\
0 0 0 0 0";
std::string smi=AvalonTools::getCanonSmiles(molb,false);
CHECK_INVARIANT(smi=="",smi);
ExplicitBitVect bv(1024);
AvalonTools::getAvalonFP(molb,false,bv,1024);
TEST_ASSERT(bv.getNumOnBits()==0);
std::string oMolb;
AvalonTools::set2DCoords(molb,false);
CHECK_INVARIANT(oMolb=="",oMolb);
}
BOOST_LOG(rdInfoLog) << "done" << std::endl;
}
int main(int argc,char *argv[]){
RDLog::InitLogs();
test1();
test2();
test3();
testRDK151();
testSmilesFailures();
testSubstructFps();
testStruChk();
testBadMolfile();
return 0;
}

16
External/AvalonTools/test_list.py vendored Executable file
View File

@@ -0,0 +1,16 @@
tests=[
("testExecs/test1.exe","",{}),
("python","test_list.py",{"dir":"Wrap"}),
]
longTests=[]
if __name__=='__main__':
import sys
import TestRunner
failed,tests = TestRunner.RunScript('test_list.py',0,1)
sys.exit(len(failed))

1
External/CMakeLists.txt vendored
View File

@@ -1,3 +1,4 @@
add_subdirectory(cmim-1.0)
add_subdirectory(INCHI-API)
add_subdirectory(AvalonTools)

0
rdkit/Avalon/__init__.py Normal file
View File