OpenBabel Namespace Reference

Global namespace for all Open Babel code. More...


Classes

class  OBBase
 Base Class. More...
class  OBNodeBase
 Node Base Class. More...
class  OBEdgeBase
 Edge Base Class. More...
class  OBGraphBase
 Graph Base Class. More...
class  OBBitVec
 Fast and efficient bitstring class. More...
class  OBBondTyper
 Assigns bond types for file formats without bond information. More...
class  OBChainsParser
 Perceives peptide or nucleotide chains and residues in an OBMol. More...
class  OBGlobalDataBase
 Base data table class, handles reading data files. More...
class  OBElement
 Individual element data type. More...
class  OBElementTable
 Periodic Table of the Elements. More...
class  OBIsotopeTable
 Table of atomic isotope masses. More...
class  OBTypeTable
 Atom Type Translation Table. More...
class  OBResidueData
 Table of common biomolecule residues (for PDB or other files). Can assign atom types and bond orders for arbitrary residues. More...
class  OBFingerprint
 The base class for fingerprints. More...
struct  FptIndexHeader
 Header for fastsearch index file. More...
struct  FptIndex
 Structure of fastsearch index files. More...
class  FastSearch
 Class to search fingerprint index files. More...
class  FastSearchIndexer
 Class to prepare fingerprint index files See FastSearch class for details. More...
class  OBGenericData
 Base class for generic data. More...
class  OBCommentData
 Used to store a comment string (can be multiple lines long). More...
class  OBExternalBond
 Used to store information on an external bond (e.g., SMILES fragments). More...
class  OBExternalBondData
 Used to store information on external bonds (e.g., in SMILES fragments). More...
class  OBPairData
 Used to store arbitrary attribute/value relationships. More...
class  OBVirtualBond
 Used to temporarily store bonds that reference an atom that has not yet been added to a molecule. More...
class  OBRingData
 Used to store the SSSR set (filled in by OBMol::GetSSSR()). More...
class  OBUnitCell
 Used for storing information about periodic boundary conditions with conversion to/from translation vectors and (a, b, c, alpha, beta, gamma). More...
class  OBConformerData
 Used to hold data on conformers or geometry optimization steps. More...
class  OBSymmetryData
 Used to hold the point-group and/or space-group symmetry. More...
class  OBTorsion
 Used to hold the torsion data for a single rotatable bond and all four atoms around it. More...
class  OBTorsionData
 Used to hold torsions as generic data for OBMol. Filled by OBMol::FindTorsions(). More...
class  OBAngle
 Used to hold the 3 atoms in an angle and the angle itself. More...
class  OBAngleData
 Used to hold all angles in a molecule as generic data for OBMol. More...
class  OBChiralData
 Used to hold chiral inforamtion about the atom as OBGenericData. More...
class  OBSerialNums
 Defines a map between serial numbers (e.g., in a PDB file) and OBAtom objects. More...
class  OBProxGrid
 A grid for determining the proximity of a given point to atoms in an OBMol. More...
class  OBFloatGrid
 Handle floating-point 3D grids (i.e., charge density around an OBMol). More...
class  OBScoreGrid
 A base class for scoring docking interactions between multiple molecules. More...
class  matrix3x3
 Represents a real 3x3 matrix. More...
class  vector3
 Represents a vector in the 3-dimensional real space. More...
class  OBResidue
 Residue information. More...
class  OBAtom
 Atom class. More...
class  OBBond
 Bond class. More...
class  OBMol
 Molecule Class. More...
class  OBInternalCoord
 Used to transform from z-matrix to cartesian coordinates. More...
class  OBGastChrg
 Assigns Gasteiger partial charges. More...
class  GasteigerState
 Helper class for OBGastChrg which stores the Gasteiger states of a given atom. More...
class  OBFormat
 Base class for file formats. More...
struct  CharPtrLess
 Case insensitive string comparison for FormatsMap key. More...
class  OBConversion
 Class to convert from one format to another. More...
class  OBError
 Customizable error handling and logging -- store a message, including the method yielding the error, causes, etc. More...
class  OBMessageHandler
 Handle error messages, warnings, debugging information and the like. More...
class  obLogBuf
 A minimal streambuf derivative to wrap calls to cerr into calls to OBMessageHandler as needed. More...
class  OBMolAtomIter
 Iterate over all atoms in an OBMol. More...
class  OBMolBondIter
 Iterate over all bonds in an OBMol. More...
class  OBAtomAtomIter
 Iterate over all neighboring atoms to an OBAtom. More...
class  OBAtomBondIter
 Iterate over all bonds on an OBAtom. More...
class  OBResidueIter
 Iterate over all residues in an OBMol. More...
class  OBResidueAtomIter
 Iterate over all atoms in an OBResidue. More...
class  OBMoleculeFormat
 An OBFormat convenience subclass for conversion to/from OBMol data. More...
class  OBStopwatch
 Stopwatch class used for timing length of execution. More...
class  OBSqrtTbl
 sqrt lookup table - given a distance squared returns distance More...
struct  DoubleType
 Used for internal random number generation OBRandom (unless the system random generaor is used). More...
class  OBRandom
 Random number generator. More...
struct  triple
 A 3-element templated, based on the design of the STL pair<>. More...
struct  quad
 A 4-element templated, based on the design of the STL pair<>. More...
union  _AtomExpr
 A SMARTS parser internal atomic expression. More...
union  _BondExpr
 A SMARTS parser internal bond expression. More...
struct  BondSpec
 A SMARTS parser internal bond specification. More...
struct  AtomSpec
 A SMARTS parser internal bond specification. More...
struct  Pattern
 A SMARTS parser internal pattern. More...
class  OBSmartsPattern
 SMARTS (SMiles ARbitrary Target Specification) substructure searching. More...
class  OBSSMatch
 Performs fast, exhaustive matching used to find just a single match in match() using recursion and explicit stack handling. More...
class  patty
 Programmable Atom Typer. More...
class  OBChemTsfm
 SMARTS based structural modification (chemical transformation). More...
class  OBPhModel
 Corrections for pH used by OBMol::CorrectForPH(). More...
class  OBReaction
 Used to store chemical reactions (i.e., reactants -> products). More...
class  OBRTree
 Internal class for OBRing search algorithms to create a search tree of OBAtom objects. More...
class  OBRing
 Stores information on rings in a molecule from SSSR perception. More...
class  OBRingSearch
 Internal class to facilitate OBMol::FindSSSR(). More...
class  OBRotamerList
 Supports a set of rotomer coordinate sets for some number of potentially rotatable bonds. More...
class  OBRotorRule
 A rule for torsional conformer searching, defined by a SMARTS pattern. More...
class  OBRotorRules
 Database of default hybridization torsional rules and SMARTS-defined OBRotorRule objects. More...
class  OBRotor
 A single rotatable OBBond as part of rotomer searching. More...
class  OBRotorList
 Given an OBMol, set up a list of possibly rotatable torsions,. More...
class  OBAtomTyper
 Assigns atom types, hybridization, implicit valence and formal charges. More...
class  OBAromaticTyper
 Assigns aromatic typing to atoms and bonds. More...

Namespaces

namespace  OBGenericDataType
 Classification of data stored via OBGenericData class and subclasses.
namespace  OBAminoAcidProperty
 Residue property definitions.
namespace  OBResidueAtomProperty
 Residue atom properties.
namespace  OBResidueIndex
 Residue names.
namespace  OBResidueProperty
 Residue types.

Typedefs

typedef OpenBabel::Template Template
 Template for backbone atoms in chain perception.
typedef OpenBabel::_ByteCode ByteCode
 Chemical graph matching virtual machine.
typedef Template Template
typedef std::map< string,
int > 		OPAMapType
typedef std::map< const char *,
OBFormat *, CharPtrLess > 		FMapType
typedef FMapType::iterator Formatpos
typedef OpenBabel::_AtomExpr AtomExpr
 A SMARTS parser internal atomic expression.
typedef OpenBabel::_BondExpr BondExpr
 A SMARTS parser internal bond expression.

Enumerations

enum  atomreftype { output, input, calcvolume }
enum  score_t { Undefined = -1, PLP, ChemScore }
enum  obMessageLevel {
  obError, obWarning, obInfo, obAuditMsg,
  obDebug
}
 Levels of error and audit messages to allow filtering. More...

Functions

static void ApplyRotMatToBond (OBMol &mol, matrix3x3 &m, OBAtom *a1, OBAtom *a2)
OBBitVec operator| (OBBitVec &bv1, OBBitVec &bv2)
OBBitVec operator & (OBBitVec &bv1, OBBitVec &bv2)
OBBitVec operator^ (OBBitVec &bv1, OBBitVec &bv2)
bool operator== (const OBBitVec &bv1, const OBBitVec &bv2)
OBBitVec operator- (OBBitVec &bv1, OBBitVec &bv2)
istream & operator>> (istream &is, OBBitVec &bv)
ostream & operator<< (ostream &os, const OBBitVec &bv)
double Tanimoto (OBBitVec &, OBBitVec &)
 This function can change the size of second parameter. There is an alternative with different parameters.
void ThrowError (char *str)
static ByteCode * AllocateByteCode (int type)
static void DeleteByteCode (ByteCode *node)
 Free a ByteCode and all corresponding data.
static void FatalMemoryError (void)
void GenerateByteCodes (ByteCode **node, int resid, int curr, int prev, int bond)
void GetChirality (OBMol &mol, std::vector< int > &chirality)
int GetParity4Ref (vector< unsigned int > pref)
bool CorrectChirality (OBMol &mol, OBAtom *atm, atomreftype i, atomreftype o)
double CalcSignedVolume (OBMol &mol, OBAtom *)
 Calculate the signed volume for an atom.
double signed_volume (const vector3 &a, const vector3 &b, const vector3 &c, const vector3 &d)
 Calculate a signed volume given a set of 4 coordinates.
void GraphPotentials (OBMol &mol, std::vector< double > &pot)
 Calculate the Graph Potentials of a molecule.
void construct_g_matrix (OBMol &mol, std::vector< std::vector< double > > &m)
void construct_c_matrix (OBMol &mol, std::vector< std::vector< double > > &m)
int GetParity4Ref (vector< unsigned int > pref)
 Calculates parity of a vector of 4 items.
void Toupper (string &s)
void Tolower (string &s)
bool tokenize (vector< string > &, const char *, const char *)
fingerprint2 thefingerprint2 ("FP2", true)
PatternFP thePatternFP ("FP3")
PatternFP FP4PatternFP ("FP4","SMARTS_InteLigand.txt")
void Trim (std::string &txt)
 remove leading and trailing whitespace from a string
ostream & operator<< (ostream &os, const OBFloatGrid &fg)
istream & operator>> (istream &is, OBFloatGrid &fg)
vector3 operator * (const matrix3x3 &m, const vector3 &v)
matrix3x3 operator * (const matrix3x3 &A, const matrix3x3 &B)
ostream & operator<< (ostream &co, const matrix3x3 &m)
vector3 center_coords (double *, int)
ostream & operator<< (ostream &co, const vector3 &v)
int operator== (const vector3 &v1, const vector3 &v2)
int operator!= (const vector3 &v1, const vector3 &v2)
double dot (const vector3 &v1, const vector3 &v2)
vector3 cross (const vector3 &v1, const vector3 &v2)
double vectorAngle (const vector3 &v1, const vector3 &v2)
double CalcTorsionAngle (const vector3 &a, const vector3 &b, const vector3 &c, const vector3 &d)
double Point2Plane (vector3 a, vector3 b, vector3 c, vector3 d)
 Calculate the distance of point a to the plane determined by b,c,d.
void print_matrix (std::vector< std::vector< double > > &m)
void print_matrix_f (double *m, int rows, int cols)
void print_matrix_ff (double **m, int rows, int cols)
bool mult_matrix (std::vector< std::vector< double > > &c, std::vector< std::vector< double > > &a, std::vector< std::vector< double > > &b)
bool mult_matrix_f (double *c, double *a, double *b, int rows, int cols)
bool mult_matrix_ff (double **c, double **a, double **b, int rows, int cols)
bool invert_matrix (std::vector< std::vector< double > > &mat, double &det)
bool invert_matrix_f (double *mat, double &det, int rows, int cols)
bool invert_matrix_ff (double **mat, double &det, int rows, int cols)
bool convert_matrix_f (std::vector< std::vector< double > > &src, double *dst)
bool convert_matrix_ff (std::vector< std::vector< double > > &src, double **dst)
bool convert_matrix_f (double *src, std::vector< std::vector< double > > &dst, int rows, int cols)
bool convert_matrix_ff (double **src, std::vector< std::vector< double > > &dst, int rows, int cols)
bool convert_matrix_f_ff (double *src, double **dst, int rows, int cols)
bool convert_matrix_ff_f (double **src, double *dst, int rows, int cols)
bool SortVVInt (const vector< int > &a, const vector< int > &b)
bool SortAtomZ (const pair< OBAtom *, double > &a, const pair< OBAtom *, double > &b)
static bool OBComparePairSecond (const pair< OBAtom *, unsigned int > &a, const pair< OBAtom *, unsigned int > &b)
static bool OBComparePairFirst (const pair< OBAtom *, unsigned int > &a, const pair< OBAtom *, unsigned int > &b)
static void ClassCount (vector< pair< OBAtom *, unsigned int > > &vp, unsigned int &count)
 counts the number of unique symmetry classes in a list
static void CreateNewClassVector (vector< pair< OBAtom *, unsigned int > > &vp1, vector< pair< OBAtom *, unsigned int > > &vp2)
static int ValenceSum (OBAtom *atom)
static bool KekulePropagate (OBAtom *atom, vector< int > &visit, vector< int > &ival, int depth)
int GetCurrentValence (OBAtom *atom)
bool ExpandKekule (OBMol &mol, vector< OBNodeBase * > &va, vector< OBNodeBase * >::iterator i, vector< int > &maxv, bool secondpass)
void CorrectBadResonanceForm (OBMol &mol)
bool WriteTitles (ostream &ofs, OBMol &mol)
bool tokenize (std::vector< std::string > &, std::string &, const char *delimstr=" \t\n", int limit=-1)
void ThrowError (std::string &str)
void CartesianToInternal (std::vector< OBInternalCoord * > &, OBMol &)
void InternalToCartesian (std::vector< OBInternalCoord * > &, OBMol &)
std::string NewExtension (string &src, char *ext)
 Utility function: replace the last extension in string &src with new extension char *ext.
void get_rmat (double *, double *, double *, int)
void ob_make_rmat (double mat[3][3], double rmat[9])
void qtrfit (double *r, double *f, int size, double u[3][3])
double superimpose (double *, double *, int)
bool OBCompareInt (const int &, const int &)
 Comparison -- returns true if first parameter less than second.
bool OBCompareUnsigned (const unsigned int &, const unsigned int &)
 Comparison -- returns true if first parameter less than second.
bool IsNear (const double &, const double &, const double epsilon=2e-6)
 Safe comparison for floats/doubles: true if a and b are closer than epsilon.
bool IsNearZero (const double &, const double epsilon=2e-6)
 Safe comparison for floats/doubles: true if a is less than epsilon.
vector3 center_coords (double *c, unsigned int size)
void rotate_coords (double *c, double m[3][3], unsigned int size)
double calc_rms (double *r, double *f, unsigned int N)
 Calculate the RMS deviation between the first N coordinates of *r and *f.
void SetRotorToAngle (double *c, vector< int > &tor, double ang, vector< int > &atoms)
bool SafeOpen (ifstream &fs, char *filename)
bool SafeOpen (ofstream &fs, char *filename)
bool SafeOpen (ifstream &fs, string &filename)
bool SafeOpen (ofstream &fs, string &filename)
static int get_roots_3_3 (double mat[3][3], double roots[3])
void DoubleMultiply (unsigned int, unsigned int, DoubleType *)
void DoubleAdd (DoubleType *, unsigned int)
unsigned int DoubleModulus (DoubleType *, unsigned int)
void rotate_coords (double *, double m[3][3], int)
static bool match (OBMol &mol, Pattern *pat, std::vector< std::vector< int > > &mlist, bool single=false)
static bool EvalAtomExpr (AtomExpr *expr, OBAtom *atom)
static bool EvalBondExpr (BondExpr *expr, OBBond *bond)
static int GetVectorBinding ()
static int CreateAtom (Pattern *, AtomExpr *, int, int vb=0)
static void FatalAllocationError (char *ptr)
static void FreePattern (Pattern *)
static Pattern * CopyPattern (Pattern *)
static AtomExpr * AllocAtomExpr (void)
static AtomExpr * CopyAtomExpr (AtomExpr *expr)
static void FreeAtomExpr (AtomExpr *expr)
static AtomExpr * BuildAtomLeaf (int prop, int val)
static AtomExpr * BuildAtomNot (AtomExpr *expr)
static AtomExpr * BuildAtomBin (int op, AtomExpr *lft, AtomExpr *rgt)
static AtomExpr * BuildAtomRecurs (Pattern *pat)
static AtomExpr * GenerateElement (int elem)
static AtomExpr * GenerateAromElem (int elem, int flag)
static int IsInvalidAtom (AtomExpr *expr)
static BondExpr * AllocBondExpr (void)
static BondExpr * CopyBondExpr (BondExpr *expr)
static bool EquivalentBondExpr (BondExpr *expr1, BondExpr *expr2)
static void FreeBondExpr (BondExpr *expr)
static BondExpr * BuildBondLeaf (int prop, int val)
static BondExpr * BuildBondNot (BondExpr *expr)
static BondExpr * BuildBondBin (int op, BondExpr *lft, BondExpr *rgt)
static BondExpr * GenerateDefaultBond (void)
static Pattern * AllocPattern (void)
static int CreateBond (Pattern *pat, BondExpr *expr, int src, int dst)
static Pattern * ParseSMARTSPattern (void)
static Pattern * ParseSMARTSPart (Pattern *, int)
static Pattern * SMARTSError (Pattern *pat)
static AtomExpr * ParseSimpleAtomPrimitive (void)
static AtomExpr * ParseComplexAtomPrimitive (void)
static AtomExpr * ParseAtomExpr (int level)
static BondExpr * ParseBondPrimitive (void)
static BondExpr * ParseBondExpr (int level)
static Pattern * ParseSMARTSError (Pattern *pat, BondExpr *expr)
static Pattern * SMARTSParser (Pattern *pat, ParseState *stat, int prev, int part)
static void MarkGrowBonds (Pattern *pat)
static int GetChiralFlag (AtomExpr *expr)
static Pattern * ParseSMARTSString (char *ptr)
Pattern * ParseSMARTSRecord (char *ptr)
static void TraverseSMARTS (Pattern *pat, int i)
static AtomExpr * NotAtomExpr (AtomExpr *)
static AtomExpr * AndAtomExpr (AtomExpr *, AtomExpr *)
static AtomExpr * OrAtomExpr (AtomExpr *, AtomExpr *)
static int IsBooleanAtomLeaf (AtomExpr *expr)
static int IsNegatingAtomLeaf (AtomExpr *expr)
static int EqualAtomExpr (AtomExpr *lft, AtomExpr *rgt)
static int OrderAtomExpr (AtomExpr *lft, AtomExpr *rgt)
static int AtomLeafConflict (AtomExpr *lft, AtomExpr *rgt)
static int AtomExprConflict (AtomExpr *lft, AtomExpr *rgt)
static int AtomLeafImplies (AtomExpr *lft, AtomExpr *rgt)
static int AtomExprImplied (AtomExpr *lft, AtomExpr *rgt)
static AtomExpr * AtomExprImplies (AtomExpr *lft, AtomExpr *rgt)
static AtomExpr * AndAtomExprLeaf (AtomExpr *lft, AtomExpr *rgt)
static AtomExpr * ConstrainRecursion (AtomExpr *recur, AtomExpr *expr)
static AtomExpr * OrAtomExprLeaf (AtomExpr *lft, AtomExpr *rgt)
static int GetBondLeafIndex (BondExpr *expr)
static int GetBondExprIndex (BondExpr *expr)
static BondExpr * NotBondExpr (BondExpr *expr)
static BondExpr * TransformBondExpr (BondExpr *expr)
void SetupAtomMatchTable (std::vector< std::vector< bool > > &ttab, Pattern *pat, OBMol &mol)
static void FastSingleMatch (OBMol &mol, Pattern *pat, std::vector< std::vector< int > > &mlist)
static int GetExprOrder (BondExpr *expr)
void SmartsLexReplace (std::string &s, std::vector< std::pair< std::string, std::string > > &vlex)
void SmartsLexReplace (std::string &, std::vector< std::pair< std::string, std::string > > &)
static unsigned int isqrt (unsigned int val)
static int IsOddPrime (unsigned int x)
static int RelativelyPrime (unsigned int x, unsigned int y)
static int LeadingZeros (unsigned int x)
static int DeterminePotency (unsigned int m, unsigned int a)
static int DetermineFactors (unsigned int x, unsigned int *factors)
static unsigned int DetermineIncrement (unsigned int m)
int DetermineSequence (unsigned int m, unsigned int *pm, unsigned int *pa, unsigned int *pc)
void GenerateSequence (unsigned int p, unsigned int m, unsigned int a, unsigned int c)
static unsigned int GetAtomIDNumber (const char *atomid)
static unsigned int GetResidueNumber (const char *res)
static void SetResidueKeys (const char *residue, unsigned int &reskey, unsigned int &aakey)
static int DetermineFRJ (OBMol &)
static void BuildOBRTreeVector (OBAtom *, OBRTree *, vector< OBRTree * > &, OBBitVec &)
bool CompareRingSize (const OBRing *a, const OBRing *b)
static void FindRings (OBMol &mol, vector< int > &path, OBBitVec &avisit, OBBitVec &bvisit, int natom, int depth)
void SetRotorToAngle (double *c, OBAtom **ref, double ang, vector< int > atoms)
int Swab (int i)
int PackCoordinate (double c[3], double max[3])
void UnpackCoordinate (double c[3], double max[3], int tmp)
static bool GetDFFVector (OBMol &, vector< int > &, OBBitVec &)
static bool CompareRotor (const pair< OBBond *, int > &, const pair< OBBond *, int > &)
static double MinimumPairRMS (OBMol &, double *, double *, bool &)
char * trim_spaces (char *string)
 Trim any trailing spaces at the end of the supplied string.
String conversion utilities
void ToUpper (std::string &s)
 Shift the supplied string to uppercase.
void ToUpper (char *cptr)
 Shift the supplied char* to uppercase.
void ToLower (std::string &s)
 Shift the supplied string to lowercase.
void ToLower (char *cptr)
 Shift the supplied char* to lowercase.
void CleanAtomType (char *)
 "Clean" the supplied atom type

Variables

OBAromaticTyper aromtyper
 Global OBAromaticTyper for detecting aromatic atoms and bonds.
OBAtomTyper atomtyper
OBPhModel phmodel
OBMessageHandler obErrorLog
 Global OBMessageHandler error handler.
static int bitsoff [SETWORD]
OBAromaticTyper aromtyper
 Global OBAromaticTyper for detecting aromatic atoms and bonds.
OBBondTyper bondtyper
 Global OBBondTyper for perception of bond order assignment.
OBChainsParser chainsparser
static Template Peptide [MAXPEPTIDE]
 Generic template for peptide residue backbone.
static Template Nucleotide [MAXNUCLEIC]
 Generic template for peptide nucleotide backbone.
static char ChainsAtomName [ATOMMAX][4]
static ResidType AminoAcids [AMINOMAX]
static ResidType Nucleotides [NUCLEOMAX]
static MonoAtomType MonoAtom [MaxMonoAtom]
static MonoBondType MonoBond [MaxMonoBond]
static int MonoAtomCount
static int MonoBondCount
static StackType Stack [STACKSIZE]
static int StackPtr
static int AtomIndex
static int BondIndex
static bool StrictFlag = false
OBElementTable etab
OBTypeTable ttab
OBIsotopeTable isotab
OBResidueData resdat
const vector3 VZero (0.0, 0.0, 0.0)
const vector3 VX (1.0, 0.0, 0.0)
const vector3 VY (0.0, 1.0, 0.0)
const vector3 VZ (0.0, 0.0, 1.0)
const vector3 VZero
const vector3 VX
const vector3 VY
const vector3 VZ
bool SwabInt
OBPhModel phmodel
OBAromaticTyper aromtyper
 Global OBAromaticTyper for detecting aromatic atoms and bonds.
OBAtomTyper atomtyper
OBBondTyper bondtyper
 Global OBBondTyper for perception of bond order assignment.
OBElementTable etab
 Global OBElementTable for element properties.
OBTypeTable ttab
OBIsotopeTable isotab
 Global OBIsotopeTable for isotope properties.
OBAromaticTyper aromtyper
 Global OBAromaticTyper for detecting aromatic atoms and bonds.
OBAtomTyper atomtyper
OBChainsParser chainsparser
 Global OBChainsParser for detecting macromolecular chains and residues.
OBMessageHandler obErrorLog
 Global OBMessageHandler error handler.
OBResidueData resdat
 Global OBResidueData biomolecule residue database.
OBMessageHandler obErrorLog
 Global OBMessageHandler error handler.
OBMessageHandler obErrorLog
 Global OBMessageHandler error handler.
static double Roots [4]
std::vector< std::pair< Pattern *,
std::vector< bool > > > 		RSCACHE
static char * MainPtr
static char * LexPtr
static char Buffer [BUFMAX]
static char Descr [BUFMAX]
OBPhModel phmodel
OBAtomTyper atomtyper
static int primes [MAXPRIMES]
static char Residue [MAXRES][4]
static char ElemDesc [MAXELEM][4]
static unsigned int ResNo = MINRES
static unsigned int ElemNo = MINELEM
static int SINT = 0x00000001
static unsigned char * STPTR = (unsigned char*)&SINT
const bool SwabInt = (STPTR[0]!=0)
OBAromaticTyper aromtyper
 Global OBAromaticTyper for detecting aromatic atoms and bonds.
OBAtomTyper atomtyper

Detailed Description

Global namespace for all Open Babel code.

Typedef Documentation

typedef struct OpenBabel::Template Template

Template for backbone atoms in chain perception.

typedef union OpenBabel::_ByteCode ByteCode

Chemical graph matching virtual machine.

typedef struct Template Template

Structure for atomic patterns (templates) in residues for OBChainsParser Implementation and documentation in chains.cpp

typedef std::map<string,int> OPAMapType

typedef std::map<const char*,OBFormat*,CharPtrLess > FMapType

typedef FMapType::iterator Formatpos

typedef union OpenBabel::_AtomExpr AtomExpr

A SMARTS parser internal atomic expression.

typedef union OpenBabel::_BondExpr BondExpr

A SMARTS parser internal bond expression.

Enumeration Type Documentation

enum atomreftype

Enumerator:
output 
input 
calcvolume 

enum score_t

Enumerator:
Undefined 
PLP 
ChemScore 

enum obMessageLevel

Levels of error and audit messages to allow filtering.

Enumerator:
obError  for critical errors (e.g., cannot read a file)
obWarning  for non-critical problems (e.g., molecule appears empty)
obInfo  for informative messages (e.g., file is a non-standard format)
obAuditMsg  for messages auditing methods which destroy or perceive molecular data (e.g., kekulization, atom typing, etc.)
obDebug  for messages only useful for debugging purposes

Function Documentation

static void OpenBabel::ApplyRotMatToBond ( OBMol &  mol,
matrix3x3 &  m,
OBAtom *  a1,
OBAtom *  a2 
) [static]

OBBitVec OpenBabel::operator| ( OBBitVec &  bv1,
OBBitVec &  bv2 
)

OBBitVec OpenBabel::operator & ( OBBitVec &  bv1,
OBBitVec &  bv2 
)

OBBitVec OpenBabel::operator^ ( OBBitVec &  bv1,
OBBitVec &  bv2 
)

bool OpenBabel::operator== ( const OBBitVec &  bv1,
const OBBitVec &  bv2 
)

OBBitVec OpenBabel::operator- ( OBBitVec &  bv1,
OBBitVec &  bv2 
)

istream& OpenBabel::operator>> ( std::istream &  is,
OBBitVec &  bv 
)

ostream& OpenBabel::operator<< ( std::ostream &  os,
const OBBitVec &  bv 
)

double Tanimoto ( OBBitVec &  bv1,
OBBitVec &  bv2 
)

This function can change the size of second parameter. There is an alternative with different parameters.

void ThrowError ( char *  str  ) 

Deprecated:
-- use OBMessageHandler class instead

static ByteCode* OpenBabel::AllocateByteCode ( int  type  )  [static]

static void OpenBabel::DeleteByteCode ( ByteCode *  node  )  [static]

Free a ByteCode and all corresponding data.

static void OpenBabel::FatalMemoryError ( void   )  [static]

void OpenBabel::GenerateByteCodes ( ByteCode **  node,
int  resid,
int  curr,
int  prev,
int  bond 
)

void GetChirality ( OBMol &  mol,
std::vector< int > &  chirality 
)

int OpenBabel::GetParity4Ref ( vector< unsigned int >  pref  ) 

bool CorrectChirality ( OBMol &  mol,
OBAtom *  atm,
atomreftype  i = input,
atomreftype  o = output 
)

double CalcSignedVolume ( OBMol &  mol,
OBAtom *  atm 
)

Calculate the signed volume for an atom.

Calculate the signed volume for an atom. If the atom has a valence of 3 the coordinates of an attached hydrogen are calculated Puts attached Hydrogen last at the moment, like mol V3000 format.

double signed_volume ( const vector3 &  a,
const vector3 &  b,
const vector3 &  c,
const vector3 &  d 
)

Calculate a signed volume given a set of 4 coordinates.

void GraphPotentials ( OBMol &  mol,
std::vector< double > &  pot 
)

Calculate the Graph Potentials of a molecule.

based on V.E. and Rozenblit, A.B. Golender Logical and Combinatorial Algorithms for Drug Design.
For an example see: Walters, W. P., Yalkowsky, S. H., JCICS, 1996, 36(5), 1015-1017. DOI: 10.1021/ci950278o

void construct_g_matrix ( OBMol &  mol,
std::vector< std::vector< double > > &  m 
)

Construct the matrix G, which puts each atoms valence+1 on the diagonal and and -1 on the off diagonal if two atoms are connected.

void construct_c_matrix ( OBMol &  mol,
std::vector< std::vector< double > > &  m 
)

Construct the matrix C, which is simply a column vector consisting of the valence for each atom

int OpenBabel::GetParity4Ref ( vector< unsigned int >  pref  ) 

Calculates parity of a vector of 4 items.

void OpenBabel::Toupper ( string &  s  ) 

void OpenBabel::Tolower ( string &  s  ) 

bool tokenize ( vector< string > &  vcr,
const char *  buf,
const char *  delimstr = " \t\n" 
)

Break a string (supplied as the second argument) into tokens, returned in the first argument. Tokens are determined by the delimiters supplied (defaults to whitespace (i.e., spaces, tabs, newlines)

fingerprint2 OpenBabel::thefingerprint2 ( "FP2"  ,
true   
)

PatternFP OpenBabel::thePatternFP ( "FP3"   ) 

PatternFP OpenBabel::FP4PatternFP ( "FP4"  ,
"SMARTS_InteLigand.txt"   
)

void Trim ( std::string &  txt  ) 

remove leading and trailing whitespace from a string

ostream& OpenBabel::operator<< ( std::ostream &  os,
const OBFloatGrid &  fg 
)

istream& OpenBabel::operator>> ( std::istream &  is,
OBFloatGrid &  fg 
)

vector3 OpenBabel::operator * ( const matrix3x3 &  m,
const vector3 &  v 
)

calculates the product m*v of the matrix m and the column vector represented by v

matrix3x3 OpenBabel::operator * ( const matrix3x3 &  A,
const matrix3x3 &  B 
)

ostream& OpenBabel::operator<< ( std::ostream &  co,
const matrix3x3 &  m 
)

vector3 center_coords ( double *  ,
int   
)

ostream& OpenBabel::operator<< ( std::ostream &  co,
const vector3 &  v 
)

int OpenBabel::operator== ( const vector3 &  v1,
const vector3 &  v2 
)

int OpenBabel::operator!= ( const vector3 &  v1,
const vector3 &  v2 
)

double OpenBabel::dot ( const vector3 &  v1,
const vector3 &  v2 
)

vector3 OpenBabel::cross ( const vector3 &  v1,
const vector3 &  v2 
)

double OpenBabel::vectorAngle ( const vector3 &  v1,
const vector3 &  v2 
)

This method calculates the angle between two vectors

Warning:
If length() of any of the two vectors is == 0.0, this method will divide by zero. If the product of the length() of the two vectors is very close to 0.0, but not == 0.0, this method may behave in unexpected ways and return almost random results; details may depend on your particular floating point implementation. The use of this method is therefore highly discouraged, unless you are certain that the length()es are in a reasonable range, away from 0.0 (Stefan Kebekus)
Deprecated:
This method will probably replaced by a safer algorithm in the future.
Todo:
Replace this method with a more fool-proof version.
Returns:
the angle in degrees (0-360)

double OpenBabel::CalcTorsionAngle ( const vector3 &  a,
const vector3 &  b,
const vector3 &  c,
const vector3 &  d 
)

This function calculates the torsion angle of three vectors, represented by four points A--B--C--D, i.e. B and C are vertexes, but none of A--B, B--C, and C--D are colinear. A "torsion angle" is the amount of "twist" or torsion needed around the B--C axis to bring A--B into the same plane as B--C--D. The torsion is measured by "looking down" the vector B--C so that B is superimposed on C, then noting how far you'd have to rotate A--B to superimpose A over D. Angles are + in the anticlockwise direction. The operation is symmetrical in that if you reverse the image (look from C to B and rotate D over A), you get the same answer.

double Point2Plane ( vector3  a,
vector3  b,
vector3  c,
vector3  d 
)

Calculate the distance of point a to the plane determined by b,c,d.

void print_matrix ( std::vector< std::vector< double > > &  m  ) 

void print_matrix_f ( double *  m,
int  rows,
int  cols 
)

void print_matrix_ff ( double **  m,
int  rows,
int  cols 
)

bool mult_matrix ( std::vector< std::vector< double > > &  c,
std::vector< std::vector< double > > &  a,
std::vector< std::vector< double > > &  b 
)

bool mult_matrix_f ( double *  c,
double *  a,
double *  b,
int  rows,
int  cols 
)

bool mult_matrix_ff ( double **  c,
double **  a,
double **  b,
int  rows,
int  cols 
)

bool invert_matrix ( std::vector< std::vector< double > > &  mat,
double &  det 
)

bool invert_matrix_f ( double *  mat,
double &  det,
int  rows,
int  cols 
)

bool invert_matrix_ff ( double **  mat,
double &  det,
int  rows,
int  cols 
)

bool convert_matrix_f ( std::vector< std::vector< double > > &  src,
double *  dst 
)

bool convert_matrix_ff ( std::vector< std::vector< double > > &  src,
double **  dst 
)

bool convert_matrix_f ( double *  src,
std::vector< std::vector< double > > &  dst,
int  rows,
int  cols 
)

bool convert_matrix_ff ( double **  src,
std::vector< std::vector< double > > &  dst,
int  rows,
int  cols 
)

bool convert_matrix_f_ff ( double *  src,
double **  dst,
int  rows,
int  cols 
)

bool convert_matrix_ff_f ( double **  src,
double *  dst,
int  rows,
int  cols 
)

bool OpenBabel::SortVVInt ( const vector< int > &  a,
const vector< int > &  b 
)

bool OpenBabel::SortAtomZ ( const pair< OBAtom *, double > &  a,
const pair< OBAtom *, double > &  b 
)

static bool OpenBabel::OBComparePairSecond ( const pair< OBAtom *, unsigned int > &  a,
const pair< OBAtom *, unsigned int > &  b 
) [static]

static bool OpenBabel::OBComparePairFirst ( const pair< OBAtom *, unsigned int > &  a,
const pair< OBAtom *, unsigned int > &  b 
) [static]

static void OpenBabel::ClassCount ( vector< pair< OBAtom *, unsigned int > > &  vp,
unsigned int &  count 
) [static]

counts the number of unique symmetry classes in a list

static void OpenBabel::CreateNewClassVector ( vector< pair< OBAtom *, unsigned int > > &  vp1,
vector< pair< OBAtom *, unsigned int > > &  vp2 
) [static]

creates a new vector of symmetry classes base on an existing vector helper routine to GetGIDVector

static int OpenBabel::ValenceSum ( OBAtom *  atom  )  [static]

static bool OpenBabel::KekulePropagate ( OBAtom *  atom,
vector< int > &  visit,
vector< int > &  ival,
int  depth 
) [static]

int OpenBabel::GetCurrentValence ( OBAtom *  atom  ) 

bool OpenBabel::ExpandKekule ( OBMol &  mol,
vector< OBNodeBase * > &  va,
vector< OBNodeBase * >::iterator  i,
vector< int > &  maxv,
bool  secondpass 
)

void OpenBabel::CorrectBadResonanceForm ( OBMol &  mol  ) 

bool OpenBabel::WriteTitles ( ostream &  ofs,
OBMol &  mol 
)

bool tokenize ( vector< string > &  vcr,
string &  s,
const char *  delimstr,
int  limit 
)

Break a string (supplied as the second argument) into tokens, returned in the first argument. Tokens are determined by the delimiters supplied (defaults to whitespace (i.e., spaces, tabs, newlines) Only breaks at most 'limit' tokens and the last item in the vector may include un-parsed tokens.

void ThrowError ( std::string &  str  ) 

Deprecated:
-- use OBMessageHandler class instead

void CartesianToInternal ( std::vector< OBInternalCoord * > &  vic,
OBMol &  mol 
)

Use the supplied OBMol and its Cartesian coordinates to generate a set of internal (z-matrix) coordinates as supplied in the vector<OBInternalCoord*> argument. Implements blue-obelisk:cartesianCoordinatesIntoZmatrixCoordinates.

void InternalToCartesian ( std::vector< OBInternalCoord * > &  vic,
OBMol &  mol 
)

Transform the supplied vector<OBInternalCoord*> into cartesian and update the OBMol accordingly. Implements blue-obelisk:zmatrixCoordinatesIntoCartesianCoordinates

string NewExtension ( std::string &  ,
char *   
)

Utility function: replace the last extension in string &src with new extension char *ext.

void get_rmat ( double *  ,
double *  ,
double *  ,
int   
)

void ob_make_rmat ( double  mat[3][3],
double  rmat[9] 
)

void qtrfit ( double *  r,
double *  f,
int  size,
double  u[3][3] 
)

double superimpose ( double *  ,
double *  ,
int   
)

bool OBCompareInt ( const int &  a,
const int &  b 
)

Comparison -- returns true if first parameter less than second.

bool OBCompareUnsigned ( const unsigned int &  a,
const unsigned int &  b 
)

Comparison -- returns true if first parameter less than second.

bool IsNear ( const double &  a,
const double &  b,
const double  epsilon = 2e-6 
)

Safe comparison for floats/doubles: true if a and b are closer than epsilon.

bool IsNearZero ( const double &  a,
const double  epsilon = 2e-6 
)

Safe comparison for floats/doubles: true if a is less than epsilon.

vector3 OpenBabel::center_coords ( double *  c,
unsigned int  size 
)

Return the geometric centroid to an array of coordinates in double* format and center the coordinates to the origin. Operates on the first "size" coordinates in the array.

void OpenBabel::rotate_coords ( double *  c,
double  m[3][3],
unsigned int  size 
)

Rotates the coordinate set *c by the transformation matrix m[3][3] Operates on the first "size" coordinates in the array.

double calc_rms ( double *  r,
double *  f,
unsigned int  N 
)

Calculate the RMS deviation between the first N coordinates of *r and *f.

void OpenBabel::SetRotorToAngle ( double *  c,
vector< int > &  tor,
double  ang,
vector< int > &  atoms 
)

Rotate the coordinates of 'atoms' such that tor == ang - atoms in 'tor' should be ordered such that the 3rd atom is the pivot around which atoms rotate

bool OpenBabel::SafeOpen ( ifstream &  fs,
char *  filename 
)

Safely open the supplied filename and return an ifstream, throwing an error to the default OBMessageHandler error log if it fails.

bool OpenBabel::SafeOpen ( ofstream &  fs,
char *  filename 
)

Safely open the supplied filename and return an ofstream, throwing an error to the default OBMessageHandler error log if it fails.

bool OpenBabel::SafeOpen ( ifstream &  fs,
string &  filename 
)

Safely open the supplied filename and return an ifstream, throwing an error to the default OBMessageHandler error log if it fails.

bool OpenBabel::SafeOpen ( ofstream &  fs,
string &  filename 
)

Safely open the supplied filename and return an ofstream, throwing an error to the default OBMessageHandler error log if it fails.

void ToUpper ( std::string &  s  ) 

Shift the supplied string to uppercase.

void ToUpper ( char *  cptr  ) 

Shift the supplied char* to uppercase.

void ToLower ( std::string &  s  ) 

Shift the supplied string to lowercase.

void ToLower ( char *  cptr  ) 

Shift the supplied char* to lowercase.

void CleanAtomType ( char *  id  ) 

"Clean" the supplied atom type

"Clean" the supplied atom type, shifting the first character to uppercase, the second character (if it's a letter) to lowercase, and terminating with a NULL to strip off any trailing characters

static int OpenBabel::get_roots_3_3 ( double  mat[3][3],
double  roots[3] 
) [static]

void DoubleMultiply ( unsigned  int,
unsigned  int,
DoubleType *   
)

void DoubleAdd ( DoubleType *  ,
unsigned  int 
)

unsigned int DoubleModulus ( DoubleType *  ,
unsigned  int 
)

void OpenBabel::rotate_coords ( double *  ,
double  m[3][3],
int   
)

static bool match ( OBMol &  mol,
Pattern *  pat,
std::vector< std::vector< int > > &  mlist,
bool  single = false 
) [static]

static bool EvalAtomExpr ( AtomExpr *  expr,
OBAtom *  atom 
) [static]

static bool EvalBondExpr ( BondExpr *  expr,
OBBond *  bond 
) [static]

static int GetVectorBinding (  )  [static]

static int CreateAtom ( Pattern *  ,
AtomExpr *  ,
int  ,
int  vb = 0 
) [static]

static void OpenBabel::FatalAllocationError ( char *  ptr  )  [static]

static void FreePattern ( Pattern *   )  [static]

static Pattern * CopyPattern ( Pattern *   )  [static]

static AtomExpr* OpenBabel::AllocAtomExpr ( void   )  [static]

static AtomExpr* OpenBabel::CopyAtomExpr ( AtomExpr *  expr  )  [static]

static void OpenBabel::FreeAtomExpr ( AtomExpr *  expr  )  [static]

static AtomExpr* OpenBabel::BuildAtomLeaf ( int  prop,
int  val 
) [static]

static AtomExpr* OpenBabel::BuildAtomNot ( AtomExpr *  expr  )  [static]

static AtomExpr* OpenBabel::BuildAtomBin ( int  op,
AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static AtomExpr* OpenBabel::BuildAtomRecurs ( Pattern *  pat  )  [static]

static AtomExpr* OpenBabel::GenerateElement ( int  elem  )  [static]

static AtomExpr* OpenBabel::GenerateAromElem ( int  elem,
int  flag 
) [static]

static int OpenBabel::IsInvalidAtom ( AtomExpr *  expr  )  [static]

static BondExpr* OpenBabel::AllocBondExpr ( void   )  [static]

static BondExpr* OpenBabel::CopyBondExpr ( BondExpr *  expr  )  [static]

static bool OpenBabel::EquivalentBondExpr ( BondExpr *  expr1,
BondExpr *  expr2 
) [static]

static void OpenBabel::FreeBondExpr ( BondExpr *  expr  )  [static]

static BondExpr* OpenBabel::BuildBondLeaf ( int  prop,
int  val 
) [static]

static BondExpr* OpenBabel::BuildBondNot ( BondExpr *  expr  )  [static]

static BondExpr* OpenBabel::BuildBondBin ( int  op,
BondExpr *  lft,
BondExpr *  rgt 
) [static]

static BondExpr* OpenBabel::GenerateDefaultBond ( void   )  [static]

static Pattern* OpenBabel::AllocPattern ( void   )  [static]

static int OpenBabel::CreateBond ( Pattern *  pat,
BondExpr *  expr,
int  src,
int  dst 
) [static]

static Pattern * ParseSMARTSPattern ( void   )  [static]

static Pattern * ParseSMARTSPart ( Pattern *  ,
int   
) [static]

static Pattern* OpenBabel::SMARTSError ( Pattern *  pat  )  [static]

static AtomExpr* OpenBabel::ParseSimpleAtomPrimitive ( void   )  [static]

static AtomExpr* OpenBabel::ParseComplexAtomPrimitive ( void   )  [static]

static AtomExpr* OpenBabel::ParseAtomExpr ( int  level  )  [static]

static BondExpr* OpenBabel::ParseBondPrimitive ( void   )  [static]

static BondExpr* OpenBabel::ParseBondExpr ( int  level  )  [static]

static Pattern* OpenBabel::ParseSMARTSError ( Pattern *  pat,
BondExpr *  expr 
) [static]

static Pattern* OpenBabel::SMARTSParser ( Pattern *  pat,
ParseState *  stat,
int  prev,
int  part 
) [static]

static void OpenBabel::MarkGrowBonds ( Pattern *  pat  )  [static]

static int OpenBabel::GetChiralFlag ( AtomExpr *  expr  )  [static]

static Pattern* OpenBabel::ParseSMARTSString ( char *  ptr  )  [static]

Pattern* OpenBabel::ParseSMARTSRecord ( char *  ptr  ) 

static void OpenBabel::TraverseSMARTS ( Pattern *  pat,
int  i 
) [static]

static AtomExpr * NotAtomExpr ( AtomExpr *   )  [static]

static AtomExpr * AndAtomExpr ( AtomExpr *  ,
AtomExpr *   
) [static]

static AtomExpr * OrAtomExpr ( AtomExpr *  ,
AtomExpr *   
) [static]

static int OpenBabel::IsBooleanAtomLeaf ( AtomExpr *  expr  )  [static]

static int OpenBabel::IsNegatingAtomLeaf ( AtomExpr *  expr  )  [static]

static int OpenBabel::EqualAtomExpr ( AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static int OpenBabel::OrderAtomExpr ( AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static int OpenBabel::AtomLeafConflict ( AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static int OpenBabel::AtomExprConflict ( AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static int OpenBabel::AtomLeafImplies ( AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static int OpenBabel::AtomExprImplied ( AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static AtomExpr* OpenBabel::AtomExprImplies ( AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static AtomExpr* OpenBabel::AndAtomExprLeaf ( AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static AtomExpr* OpenBabel::ConstrainRecursion ( AtomExpr *  recur,
AtomExpr *  expr 
) [static]

static AtomExpr* OpenBabel::OrAtomExprLeaf ( AtomExpr *  lft,
AtomExpr *  rgt 
) [static]

static int OpenBabel::GetBondLeafIndex ( BondExpr *  expr  )  [static]

static int OpenBabel::GetBondExprIndex ( BondExpr *  expr  )  [static]

static BondExpr* OpenBabel::NotBondExpr ( BondExpr *  expr  )  [static]

static BondExpr* OpenBabel::TransformBondExpr ( BondExpr *  expr  )  [static]

void OpenBabel::SetupAtomMatchTable ( std::vector< std::vector< bool > > &  ttab,
Pattern *  pat,
OBMol &  mol 
)

static void OpenBabel::FastSingleMatch ( OBMol &  mol,
Pattern *  pat,
std::vector< std::vector< int > > &  mlist 
) [static]

static int OpenBabel::GetExprOrder ( BondExpr *  expr  )  [static]

void OpenBabel::SmartsLexReplace ( std::string &  s,
std::vector< std::pair< std::string, std::string > > &  vlex 
)

void OpenBabel::SmartsLexReplace ( std::string &  ,
std::vector< std::pair< std::string, std::string > > &   
)

static unsigned int OpenBabel::isqrt ( unsigned int  val  )  [static]

static int OpenBabel::IsOddPrime ( unsigned int  x  )  [static]

static int OpenBabel::RelativelyPrime ( unsigned int  x,
unsigned int  y 
) [static]

static int OpenBabel::LeadingZeros ( unsigned int  x  )  [static]

static int OpenBabel::DeterminePotency ( unsigned int  m,
unsigned int  a 
) [static]

static int OpenBabel::DetermineFactors ( unsigned int  x,
unsigned int *  factors 
) [static]

static unsigned int OpenBabel::DetermineIncrement ( unsigned int  m  )  [static]

int OpenBabel::DetermineSequence ( unsigned int  m,
unsigned int *  pm,
unsigned int *  pa,
unsigned int *  pc 
)

void OpenBabel::GenerateSequence ( unsigned int  p,
unsigned int  m,
unsigned int  a,
unsigned int  c 
)

static unsigned int OpenBabel::GetAtomIDNumber ( const char *  atomid  )  [static]

static unsigned int OpenBabel::GetResidueNumber ( const char *  res  )  [static]

static void OpenBabel::SetResidueKeys ( const char *  residue,
unsigned int &  reskey,
unsigned int &  aakey 
) [static]

static int DetermineFRJ ( OBMol &   )  [static]

void BuildOBRTreeVector ( OBAtom *  ,
OBRTree *  ,
vector< OBRTree * > &  ,
OBBitVec &   
) [static]

bool CompareRingSize ( const OBRing *  a,
const OBRing *  b 
)

static void FindRings ( OBMol &  mol,
vector< int > &  path,
OBBitVec &  avisit,
OBBitVec &  bvisit,
int  natom,
int  depth 
) [static]

void SetRotorToAngle ( double *  c,
OBAtom **  ref,
double  ang,
vector< int >  atoms 
)

Rotate the coordinates of 'atoms' such that tor == ang - atoms in 'tor' should be ordered such that the 3rd atom is the pivot around which atoms rotate ang is in degrees

int Swab ( int  i  ) 

int OpenBabel::PackCoordinate ( double  c[3],
double  max[3] 
)

void OpenBabel::UnpackCoordinate ( double  c[3],
double  max[3],
int  tmp 
)

bool GetDFFVector ( OBMol &  ,
vector< int > &  ,
OBBitVec &   
) [static]

bool CompareRotor ( const pair< OBBond *, int > &  ,
const pair< OBBond *, int > &   
) [static]

static double MinimumPairRMS ( OBMol &  ,
double *  ,
double *  ,
bool &   
) [static]

char* OpenBabel::trim_spaces ( char *  string  ) 

Trim any trailing spaces at the end of the supplied string.

Variable Documentation

OBAromaticTyper aromtyper

Global OBAromaticTyper for detecting aromatic atoms and bonds.

OBAtomTyper atomtyper

Global OBAtomTyper for marking internal valence, hybridization, and atom types (for internal and external use)

OBPhModel phmodel

OBMessageHandler obErrorLog

Global OBMessageHandler error handler.

int bitsoff[SETWORD] [static]

Initial value:

    {
        0xFFFFFFFF,0xFFFFFFFE,0xFFFFFFFC,0xFFFFFFF8,0xFFFFFFF0,0xFFFFFFE0,0xFFFFFFC0,
        0xFFFFFF80,0xFFFFFF00,0xFFFFFE00,0xFFFFFC00,0xFFFFF800,0xFFFFF000,0xFFFFE000,
        0xFFFFC000,0xFFFF8000,0xFFFF0000,0xFFFE0000,0xFFFC0000,0xFFF80000,0xFFF00000,
        0xFFE00000,0xFFC00000,0xFF800000,0xFF000000,0xFE000000,0xFC000000,0xF8000000,
        0xF0000000,0xE0000000,0xC0000000,0x80000000
    }

OBAromaticTyper aromtyper

Global OBAromaticTyper for detecting aromatic atoms and bonds.

OBBondTyper bondtyper

Global OBBondTyper for perception of bond order assignment.

OBChainsParser chainsparser

Template Peptide[MAXPEPTIDE] [static]

Initial value:

 {
        {  0x0001, 7, 2, 0x0030, 0x0100,      0, 0 },
        {  0x0002, 7, 1, 0x0030,      0,      0, 0 },
        {  0x0004, 7, 3, 0x0030, 0x0100,     -6, 0 },
        {  0x0008, 7, 2, 0x0030,     -6,      0, 0 },
        {  0x0010, 6, 3, 0x000F, 0x0700,     -6, 0 },
        {  0x0020, 6, 2, 0x0003, 0x0700,      0, 0 },
        {  0x0100, 6, 3, 0x0030, 0x1000, 0x0005, 0 },
        {  0x0200, 6, 2, 0x0030, 0x1000,      0, 0 },
        {  0x0400, 6, 3, 0x0030, 0x1000, 0x2000, 0 },
        {  0x1000, 8, 1, 0x0700,      0,      0, 0 },
        {  0x2000, 8, 1, 0x0400,      0,      0, 0 }
  }
Generic template for peptide residue backbone.

Template Nucleotide[MAXNUCLEIC] [static]

Initial value:

 {
        {  0x0001, 15, 4, 0x0004, 0x0004, 0x0008, 0x0200 },
        {  0x0002, 15, 3, 0x0004, 0x0004, 0x0008,      0 },
        {  0x0004,  8, 1, 0x0003,      0,      0,      0 },
        {  0x0008,  8, 2, 0x0020, 0x0003,      0,      0 },
        {  0x0010,  8, 1, 0x0020,      0,      0,      0 },
        {  0x0020,  6, 2, 0x0018, 0x0040,      0,      0 },
        {  0x0040,  6, 3, 0x0020, 0x0080, 0x0100,      0 },
        {  0x0080,  8, 2, 0x0040, 0x4000,      0,      0 },
        {  0x0100,  6, 3, 0x0040, 0x0600, 0x1800,      0 },
        {  0x0200,  8, 2, 0x0100, 0x0001,      0,      0 },
        {  0x0400,  8, 1, 0x0100,      0,      0,      0 },
        {  0x0800,  6, 3, 0x0100, 0x4000, 0x2000,      0 },
        {  0x1000,  6, 2, 0x0100, 0x4000,      0,      0 },
        {  0x2000,  8, 1, 0x0800,      0,      0,      0 },
        {  0x4000,  6, 3, 0x0080, 0x1800,     -7,      0 }
  }
Generic template for peptide nucleotide backbone.

char ChainsAtomName[ATOMMAX][4] [static]

PDB atom types (i.e., columns 13-16 of a PDB file) index numbers from this array are used in the pseudo-SMILES format for side-chains in the AminoAcids[] & Nucleotides[] global arrays below

ResidType AminoAcids[AMINOMAX] [static]

Initial value:

 {
    { "ILE", "1-4(-9-14)-10"                        },
    { "VAL", "1-4(-9)-10"                           },
    { "ALA", "1-4"                                  },
    { "ASN", "1-4-7(=15)-19"                        },
    { "ASP", "1-4-7(=15)-18"                        },
    { "ARG", "1-4-7-11-21-29(=34)-35"               },
    { "CYS", "1-4-5"                                },
    { "GLN", "1-4-7-11(=23)-27"                     },
    { "GLU", "1-4-7-11(=23)-26"                     },
    { "GLY", "1"                                    },
    { "HIS", "1-4-7^16~22^27^17~7"                  },
    { "HYP", "1-4-7(-12)-11-0"                      },
    { "LEU", "1-4-7(-14)-17"                        },
    { "LYS", "1-4-7-11-20-30"                       },
    { "MET", "1-4-7-13-20"                          },
    { "PHE", "1-4-7~14^22~29^25~17^7"               },
    { "PRO", "1-4-7-11-0"                           },
    { "SER", "1-4-6"                                },
    { "THR", "1-4(-8)-10"                           },
    { "TRP", "1-4-7~14^24^25~17(^7)^28~32^36~31^25" },
    { "TYR", "1-4-7~14^22~29(-33)^25~17^7"          }
  }
Side chains for recognized amino acids using a pseudo-SMARTS syntax for branching and bonds. Numbers indicate atom types defined by ChainsAtomName global array above

ResidType Nucleotides[NUCLEOMAX] [static]

Initial value:

 {
    { "  A", "49-50-51-52-53-54(-56)-57-58-61-62(-53)-50"      },
    { "  C", "49-57-58(-59)-61-62(-64)-65-67-57"               },
    { "  G", "49-50-51-52-53-54(-55)-57-58(-60)-61-62(-53)-50" },
    { "  T", "49-57-58(-59)-61-62(-63)-65(-66)-67-57"          },
    { "  U", "49-57-58(-59)-61-62(-63)-65-67-57"               },
    { "  I", "49-50-51-52-53-54(-55)-57-58-61-62(-53)-50"      }
  }
Side chains for recognized nucleotides using a pseudo-SMARTS syntax for branching and bonds. Numbers indicate atom types defined by ChainsAtomName global array above

MonoAtomType MonoAtom[MaxMonoAtom] [static]

MonoBondType MonoBond[MaxMonoBond] [static]

int MonoAtomCount [static]

int MonoBondCount [static]

StackType Stack[STACKSIZE] [static]

int StackPtr [static]

int AtomIndex [static]

int BondIndex [static]

bool StrictFlag = false [static]

OBElementTable etab

OBTypeTable ttab

OBIsotopeTable isotab

OBResidueData resdat

const vector3 VZero(0.0, 0.0, 0.0)

const vector3 VX(1.0, 0.0, 0.0)

const vector3 VY(0.0, 1.0, 0.0)

const vector3 VZ(0.0, 0.0, 1.0)

const vector3 VZero

const vector3 VX

const vector3 VY

const vector3 VZ

bool SwabInt

OBPhModel phmodel

OBAromaticTyper aromtyper

Global OBAromaticTyper for detecting aromatic atoms and bonds.

OBAtomTyper atomtyper

Global OBAtomTyper for marking internal valence, hybridization, and atom types (for internal and external use)

OBBondTyper bondtyper

Global OBBondTyper for perception of bond order assignment.

OBElementTable etab

Global OBElementTable for element properties.

OBTypeTable ttab

Global OBTypeTable for translating between different atom types (e.g., Sybyl <-> MM2)

OBIsotopeTable isotab

Global OBIsotopeTable for isotope properties.

OBAromaticTyper aromtyper

Global OBAromaticTyper for detecting aromatic atoms and bonds.

OBAtomTyper atomtyper

Global OBAtomTyper for marking internal valence, hybridization, and atom types (for internal and external use)

OBChainsParser chainsparser

Global OBChainsParser for detecting macromolecular chains and residues.

OBMessageHandler obErrorLog

Global OBMessageHandler error handler.

OBResidueData resdat

Global OBResidueData biomolecule residue database.

OBMessageHandler obErrorLog

Global OBMessageHandler error handler.

OBMessageHandler obErrorLog

Global OBMessageHandler error handler.

double Roots[4] [static]

std::vector<std::pair<Pattern*,std::vector<bool> > > RSCACHE

char* MainPtr [static]

char* LexPtr [static]

char Buffer[BUFMAX] [static]

char Descr[BUFMAX] [static]

OBPhModel phmodel

OBAtomTyper atomtyper

Global OBAtomTyper for marking internal valence, hybridization, and atom types (for internal and external use)

int primes[MAXPRIMES] [static]

Initial value:

 {
                                   1,    2,    3,    5,    7,   11,   13,   17,   19,   23,
                                   29,   31,   37,   41,   43,   47,   53,   59,   61,   67,
                                   71,   73,   79,   83,   89,   97,  101,  103,  107,  109,
                                   113,  127,  131,  137,  139,  149,  151,  157,  163,  167,
                                   173,  179,  181,  191,  193,  197,  199,  211,  223,  227,
                                   229,  233,  239,  241,  251,  257,  263,  269,  271,  277,
                                   281,  283,  293,  307,  311,  313,  317,  331,  337,  347,
                                   349,  353,  359,  367,  373,  379,  383,  389,  397,  401,
                                   409,  419,  421,  431,  433,  439,  443,  449,  457,  461,
                                   463,  467,  479,  487,  491,  499,  503,  509,  521,  523,
                                   541,  547,  557,  563,  569,  571,  577,  587,  593,  599,
                                   601,  607,  613,  617,  619,  631,  641,  643,  647,  653,
                                   659,  661,  673,  677,  683,  691,  701,  709,  719,  727,
                                   733,  739,  743,  751,  757,  761,  769,  773,  787,  797,
                                   809,  811,  821,  823,  827,  829,  839,  853,  857,  859,
                                   863,  877,  881,  883,  887,  907,  911,  919,  929,  937,
                                   941,  947,  953,  967,  971,  977,  983,  991,  997, 1009,
                                   1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063,
                                   1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129,
                                   1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217,
                                   1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289,
                                   1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367,
                                   1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447,
                                   1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499,
                                   1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579,
                                   1583, 1597, 1601, 1607, 1609, 1613
                               }

char Residue[MAXRES][4] [static]

char ElemDesc[MAXELEM][4] [static]

unsigned int ResNo = MINRES [static]

unsigned int ElemNo = MINELEM [static]

int SINT = 0x00000001 [static]

unsigned char* STPTR = (unsigned char*)&SINT [static]

const bool SwabInt = (STPTR[0]!=0)

OBAromaticTyper aromtyper

Global OBAromaticTyper for detecting aromatic atoms and bonds.

OBAtomTyper atomtyper

Global OBAtomTyper for marking internal valence, hybridization, and atom types (for internal and external use)