OpenBabel Namespace Reference

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


Classes

class  OBAtom
 Atom class. More...
class  OBBase
 Base Class. More...
class  OBBitVec
 Fast and efficient bitstring class. More...
class  OBBond
 Bond 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). 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  OBFFParameter
 Internal class for OBForceField to hold forcefield parameters. More...
class  OBFFCalculation
 Internal class for OBForceField to hold energy and gradient calculations on specific force fields. More...
class  OBForceField
 Base class for molecular mechanics force fields. 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 text attribute/value relationships. More...
class  OBPairTemplate
 Used to store arbitrary attribute/value relationsips of any type. More...
class  OBSetData
 Used to store arbitrary attribute/set relationships. Should be used to store a set of OBGenericData based on an attribute. 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. 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 inside a molecule. More...
class  OBVibrationData
 Used to hold the normal modes of a molecule, etc. More...
class  OBGrid
 A base grid class. More...
class  OBFloatGrid
 Handle floating-point 3D grids (e.g., charge density around an OBMol). More...
class  OBProxGrid
 A grid for determining the proximity of a given point to atoms in an OBMol. More...
class  OBScoreGrid
 A base class for scoring docking interactions between multiple molecules. More...
class  OBGroupContrib
 Handle group contribution algorithms. More...
class  OBLogP
 calculate the LogP (octanol/water partition coefficient). More...
class  OBPSA
 calculate the TPSA (topological polar surface area). More...
class  OBMR
 calculate the MR (molar refractivity). More...
class  OBInternalCoord
 Used to transform from z-matrix to cartesian coordinates. More...
class  OBRateData
 Holds rate constant data for OBReaction. More...
class  OBNasaThermoData
 Thermodynamic data in old style NASA polynomial form for OBMol. More...
class  FilteringInputStreambuf
 Delivers characters from an istream or streambuf from a source while filtering. More...
class  LineEndingExtractor
 Replaces CRLF (DOS) and CR (Mac OS 9) line endings by LF (POSIX). More...
class  OBMol
 Molecule Class. 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  OBMolAtomDFSIter
 Iterate over all atoms in an OBMol in a depth-first search (DFS). More...
class  OBMolAtomBFSIter
 Iterate over all atoms in an OBMol in a breadth-first search (BFS). 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  OBMolAngleIter
 Iterate over all angles in an OBMol. More...
class  OBMolTorsionIter
 Iterate over all torsions in an OBMol. More...
class  OBMolPairIter
 Iterate over all pairs of atoms (>1-4) in an OBMol. More...
class  OBMolRingIter
 Iterate over all rings in an OBMol. 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
 Square Root lookup table - given a distance squared returns distance. More...
class  triple
 A 3-element templated, based on the design of the STL pair<>. More...
class  quad
 A 4-element templated, based on the design of the STL pair<>. More...
union  _AtomExpr
 An internal (SMARTS parser) atomic expression. More...
union  _BondExpr
 An internal (SMARTS parser) bond expression. More...
struct  BondSpec
 An internal (SMARTS parser) bond specification. More...
struct  AtomSpec
 An internal (SMARTS parser) atom specification. More...
struct  Pattern
 A SMARTS parser internal pattern. More...
class  OBSmartsPattern
 SMARTS (SMiles ARbitrary Target Specification) substructure searching. More...
class  OBSSMatch
 Internal class: 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  PluginIter
 Template class used to simplify dynamic classes discovered at runtime. More...
struct  DoubleType
 Used for internal random number generation OBRandom (unless the system random generator is used). More...
class  OBRandom
 Random number generator. More...
class  OBReaction
 Used to store chemical reactions (i.e., reactants -> products). More...
class  OBResidue
 Residue information. More...
class  OBRing
 Stores information on rings in a molecule from SSSR perception. More...
class  OBRingSearch
 Internal class to facilitate OBMol::FindSSSR(). More...
class  OBRTree
 Internal class for OBRing search algorithms to create a search tree of OBAtom objects. More...
class  OBRotamerList
 Supports a set of rotamer 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 rotamer 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...
class  XMLConversion
 A subclass for conversion of XML formats. More...
class  XMLBaseFormat
 Abstract class containing common functionality for XML formats. More...
class  XMLMoleculeFormat
 Abstract class for XML formats which represent molecules. More...
class  matrix3x3
 Represents a real 3x3 matrix. More...
class  vector3
 Represents a vector in 3-dimensional real space. More...

Namespaces

namespace  OBGenericDataType
namespace  OBAminoAcidProperty
namespace  OBResidueAtomProperty
namespace  OBResidueIndex
namespace  OBResidueProperty

Typedefs

typedef OBAtom OBNodeBase
typedef std::vector< OBBond
* >::iterator 		OBBondIterator
typedef std::vector< OBAtom
* >::iterator 		OBAtomIterator
typedef std::vector< OBGenericData
* >::iterator 		OBDataIterator
typedef OBBond OBEdgeBase
typedef std::vector< OBBond
* >::iterator 		OBBondIterator
typedef Template Template
typedef OBPairTemplate< int > OBPairInteger
typedef OBPairTemplate< double > OBPairFloatingPoint
typedef std::vector< OBGenericData
* >::iterator 		OBDataIterator
typedef std::map< const char *,
OBFormat *, CharPtrLess > 		FMapType
typedef FMapType::iterator Formatpos
typedef OpenBabel::_AtomExpr AtomExpr
typedef OpenBabel::_BondExpr BondExpr
typedef std::vector< OBAtom
* >::iterator 		OBAtomIterator
typedef std::vector< OBBond
* >::iterator 		OBBondIterator
typedef std::vector< OBResidue
* >::iterator 		OBResidueIterator
typedef std::vector< OBRotor
* >::iterator 		OBRotorIterator
typedef OpenBabel::Template Template
typedef OpenBabel::_ByteCode ByteCode

Enumerations

enum  DataOrigin {
  any, fileformatInput, userInput, perceived,
  external
}
enum  atomreftype { output, input, calcvolume }
enum  score_t { Undefined = -1, PLP, ChemScore }
enum  obMessageLevel {
  obError, obWarning, obInfo, obAuditMsg,
  obDebug
}

Functions

double Tanimoto (OBBitVec &, OBBitVec &)
void CanonicalLabels (OBMol *pmol, OBBitVec &frag_atoms, std::vector< unsigned int > &symmetry_classes, std::vector< unsigned int > &canonical_labels)
void GraphPotentials (OBMol &mol, std::vector< double > &pot)
void construct_g_matrix (OBMol &mol, std::vector< std::vector< double > > &m)
void construct_c_matrix (OBMol &mol, std::vector< std::vector< double > > &m)
double CalcSignedVolume (OBMol &mol, OBAtom *, bool ReZeroZ=true)
double signed_volume (const vector3 &a, const vector3 &b, const vector3 &c, const vector3 &d)
void GetChirality (OBMol &mol, std::vector< int > &chirality)
int GetParity4Ref (std::vector< unsigned int > pref)
bool CorrectChirality (OBMol &mol, OBAtom *atm, atomreftype i=input, atomreftype o=output)
std::string OpenDatafile (std::ifstream &fs, const std::string &filename, const std::string &envvar="BABEL_DATADIR")
std::string & Trim (std::string &txt)
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 > > &m, double &det)
bool invert_matrix_f (double *m, double &det, int rows, int cols)
bool invert_matrix_ff (double **m, 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_ff_f (double **src, double *dst, int rows, int cols)
bool convert_matrix_f_ff (double *src, double **dst, int rows, int cols)
bool tokenize (std::vector< std::string > &, const char *buf, const char *delimstr=" \t\n")
bool tokenize (std::vector< std::string > &, std::string &, const char *delimstr=" \t\n", int limit=-1)
void ThrowError (const char *str)
void ThrowError (std::string &str)
void CartesianToInternal (std::vector< OBInternalCoord * > &, OBMol &)
void InternalToCartesian (std::vector< OBInternalCoord * > &, OBMol &)
std::string NewExtension (string &src, 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)
void rotate_coords (double *, double m[3][3], int)
double calc_rms (double *r, double *f, unsigned int N)
bool OBCompareInt (const int &a, const int &b)
bool OBCompareUnsigned (const unsigned int &a, const unsigned int &b)
bool IsNear (const double &a, const double &b, const double epsilon)
bool IsNearZero (const double &a, const double epsilon)
bool IsNan (const double &a)
bool IsNegligible (const double &a, const double &b, const double precision=1e-11)
bool IsApprox (const double &a, const double &b, const double precision=1e-11)
bool IsApprox_pos (const double &a, const double &b, const double precision=1e-11)
bool CanBeSquared (const double &)
void SmartsLexReplace (std::string &, std::vector< std::pair< std::string, std::string > > &)
void DoubleMultiply (unsigned int, unsigned int, DoubleType *)
void DoubleAdd (DoubleType *, unsigned int)
unsigned int DoubleModulus (DoubleType *, unsigned int)
bool CompareRingSize (const OBRing *, const OBRing *)
int Swab (int)
vector3 center_coords (double *, int)
std::ostream & operator<< (std::ostream &, const vector3 &)
vector3 operator+ (const vector3 &v1, const vector3 &v2)
vector3 operator- (const vector3 &v1, const vector3 &v2)
vector3 operator- (const vector3 &v)
vector3 operator * (const double &c, const vector3 &v)
vector3 operator * (const vector3 &v, const double &c)
vector3 operator/ (const vector3 &v, const double &c)
vector3 operator * (const matrix3x3 &m, const vector3 &v)
double dot (const vector3 &v1, const vector3 &v2)
vector3 cross (const vector3 &, const vector3 &)
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)
double Point2PlaneAngle (const vector3 a, const vector3 b, const vector3 c, const vector3 d)
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)
bool operator< (const OBBitVec &bv1, const OBBitVec &bv2)
istream & operator>> (istream &is, OBBitVec &bv)
ostream & operator<< (ostream &os, const OBBitVec &bv)
static bool CompareUnsigned (const unsigned int &a, const unsigned int &b)
static bool ComparePairFirst (const pair< OBAtom *, unsigned int > &a, const pair< OBAtom *, unsigned int > &b)
static bool ComparePairSecond (const pair< OBAtom *, unsigned int > &a, const pair< OBAtom *, unsigned int > &b)
static bool CompareBondPairSecond (const pair< OBBond *, unsigned int > &a, const pair< OBBond *, unsigned int > &b)
static unsigned int GetValence (OBAtom *atom, OBBitVec &frag_atoms)
static unsigned int GetHvyValence (OBAtom *atom, OBBitVec &frag_atoms)
static unsigned int GetHvyBondSum (OBAtom *atom, OBBitVec &frag_atoms)
static bool GetGTDVector (OBMol *pmol, OBBitVec &frag_atoms, vector< int > &gtd)
static void FindRingAtoms (OBMol *pmol, OBBitVec &frag_atoms, OBBitVec &ring_atoms)
static void GetGIVector (OBMol *pmol, OBBitVec &frag_atoms, vector< unsigned int > &vid)
static void CreateNewClassVector (vector< pair< OBAtom *, unsigned int > > &vp1, vector< pair< OBAtom *, unsigned int > > &vp2, OBBitVec &frag_atoms, int natoms)
static void CountAndRenumberClasses (vector< pair< OBAtom *, unsigned int > > &vp, unsigned int &count)
static int ExtendInvarients (vector< pair< OBAtom *, unsigned int > > &symmetry_classes, OBBitVec &frag_atoms, unsigned int nfragatoms, unsigned int natoms)
static int CalculateSymmetry (OBMol *pmol, OBBitVec &frag_atoms, vector< pair< OBAtom *, unsigned int > > &symmetry_classes)
static void BreakChiralTies (OBMol *pmol, OBBitVec &frag_atoms, int nfragatoms, vector< pair< OBAtom *, unsigned int > > &atom_sym_classes)
static void FindConjugatedEZBonds (OBAtom *atom, OBBitVec &flip_bonds, OBBitVec &visited_atoms)
static void FixCisTransBonds (OBMol *pmol, OBBitVec &frag_atoms, vector< unsigned int > &symmetry_classes, vector< unsigned int > &canonical_labels)
static ByteCode * AllocateByteCode (int type)
static void DeleteByteCode (ByteCode *node)
static void FatalMemoryError (void)
void GenerateByteCodes (ByteCode **node, int resid, int curr, int prev, int bond)
void Toupper (string &s)
void Tolower (string &s)
bool tokenize (vector< string > &, const char *, const char *)
ostream & operator<< (ostream &os, const OBFloatGrid &fg)
istream & operator>> (istream &is, OBFloatGrid &fg)
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)
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< OBAtom * > &va, vector< OBAtom * >::iterator i, vector< int > &maxv, bool secondpass)
void CorrectBadResonanceForm (OBMol &mol)
bool WriteTitles (ostream &ofs, OBMol &mol)
vector3 center_coords (double *c, unsigned int size)
void rotate_coords (double *c, double m[3][3], unsigned int size)
void SetRotorToAngle (double *c, vector< int > &tor, double ang, vector< int > &atoms)
bool SafeOpen (ifstream &fs, const char *filename)
bool SafeOpen (ofstream &fs, const char *filename)
bool SafeOpen (ifstream &fs, const string &filename)
bool SafeOpen (ofstream &fs, const string &filename)
void InvertCase (std::string &s, unsigned int start)
int SolveLinear (double A, double B)
int SolveQuadratic (double A, double B, double C)
double CubeRoot (double X)
int SolveCubic (double A, double B, double C, double D)
static int get_roots_3_3 (double mat[3][3], double roots[3])
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 (const 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)
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)
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 &)
static void FindRings (OBMol &mol, vector< int > &path, OBBitVec &avisit, OBBitVec &bvisit, int natom, int depth)
double rint (double x)
void SetRotorToAngle (double *c, OBAtom **ref, double ang, vector< int > atoms)
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)
matrix3x3 operator * (const matrix3x3 &A, const matrix3x3 &B)
static double SQUARE (double x)
ostream & operator<< (ostream &co, const matrix3x3 &m)
String conversion utilities
void ToUpper (std::string &s)
void ToUpper (char *cptr)
void ToLower (std::string &s)
void ToLower (char *cptr)
void InvertCase (std::string &, int)
void InvertCase (char *cptr)
void CleanAtomType (char *)

Variables

const unsigned RateData = 55555
const unsigned ThermoData = 55556
OBElementTable etab
OBTypeTable ttab
OBIsotopeTable isotab
OBAromaticTyper aromtyper
OBAtomTyper atomtyper
OBChainsParser chainsparser
OBERROR OBMessageHandler obErrorLog
OBResidueData resdat
OBERROR OBMessageHandler obErrorLog
OBERROR OBMessageHandler obErrorLog
char Residue [MAXRES][4]
char ElemDesc [MAXELEM][4]
unsigned int ResNo
unsigned int ElemNo
const vector3 VZero
const vector3 VX
const vector3 VY
const vector3 VZ
OBAromaticTyper aromtyper
OBAtomTyper atomtyper
OBPhModel phmodel
OBERROR OBMessageHandler obErrorLog
static int bitsoff [SETWORD]
OBAromaticTyper aromtyper
OBBondTyper bondtyper
OBChainsParser chainsparser
static Template Peptide [MAXPEPTIDE]
static Template Nucleotide [MAXNUCLEIC]
static const char ChainsAtomName [ATOMMAX][4]
static const ResidType AminoAcids [AMINOMAX]
static const 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
bool SwabInt
OBPhModel phmodel
OBAromaticTyper aromtyper
OBAtomTyper atomtyper
OBBondTyper bondtyper
OBMessageHandler obErrorLog
static double Roots [4]
std::vector< std::pair< Pattern *,
std::vector< bool > > > 		RSCACHE
static char * MainPtr
static char * LexPtr
static char Buffer [BUFF_SIZE]
static char Descr [BUFF_SIZE]
OBPhModel phmodel
OBAtomTyper atomtyper
static int primes [MAXPRIMES]
char Residue [MAXRES][4]
char ElemDesc [MAXELEM][4]
unsigned int ResNo = MINRES
unsigned int ElemNo = MINELEM
static int SINT = 0x00000001
static unsigned char * STPTR = (unsigned char*)&SINT
const bool SwabInt = (STPTR[0]!=0)
OBAromaticTyper aromtyper
OBAtomTyper atomtyper
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)

Detailed Description

Global namespace for all Open Babel code.

Typedef Documentation

typedef OBAtom OBNodeBase

OBNodeBase is declared for backwards-compatibility with 2.0 and earlier code.

typedef std::vector<OBBond*>::iterator OBBondIterator

A standard iterator over a vector of bonds.

typedef std::vector<OBAtom*>::iterator OBAtomIterator

A standard iterator over a vector of atoms.

typedef std::vector<OBGenericData*>::iterator OBDataIterator

A standard iterator over vectors of OBGenericData (e.g., inherited from OBBase).

typedef OBBond OBEdgeBase

OBEdgeBase is declared for backwards-compatibility with 2.0 and earlier code.

typedef std::vector<OBBond*>::iterator OBBondIterator

A standard iterator over a vector of bonds.

typedef struct Template Template

typedef OBPairTemplate<int> OBPairInteger

Store arbitrary key/value integer data like OBPairData.

typedef OBPairTemplate<double> OBPairFloatingPoint

Store arbitrary key/value floating point data like OBPairData.

typedef std::vector<OBGenericData*>::iterator OBDataIterator

A standard iterator over vectors of OBGenericData (e.g., inherited from OBBase).

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

typedef FMapType::iterator Formatpos

typedef union OpenBabel::_AtomExpr AtomExpr

typedef union OpenBabel::_BondExpr BondExpr

typedef std::vector<OBAtom*>::iterator OBAtomIterator

A standard iterator over a vector of atoms.

typedef std::vector<OBBond*>::iterator OBBondIterator

A standard iterator over a vector of bonds.

typedef std::vector<OBResidue*>::iterator OBResidueIterator

A standard iterator over a vector of residues.

typedef std::vector<OBRotor*>::iterator OBRotorIterator

A standard iterator over a vector of rotors.

typedef struct OpenBabel::Template Template

Structure template for atomic patterns in residues for OBChainsParser.

typedef union OpenBabel::_ByteCode ByteCode

Chemical graph matching virtual machine.

Enumeration Type Documentation

enum DataOrigin

Enumerator:
any  Undefined or unspecified (default).
fileformatInput  Read from an input file.
userInput  Added by the user.
perceived  Perceived by Open Babel library methods.
external  Added by an external program.

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

double Tanimoto ( OBBitVec &  ,
OBBitVec &   
)

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

void CanonicalLabels ( OBMol *  pmol,
OBBitVec &  frag_atoms,
std::vector< unsigned int > &  symmetry_classes,
std::vector< unsigned int > &  canonical_labels 
)

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

double CalcSignedVolume ( OBMol &  mol,
OBAtom *  atm,
bool  ReZeroZ 
)

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. If ReZero=false (the default is true) always make pseudo z coords and leave them in mol

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 GetChirality ( OBMol &  mol,
std::vector< int > &  chirality 
)

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

Calculates parity of a vector of 4 items.

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

std::string OpenDatafile ( std::ifstream &  ifs,
const std::string &  filename,
const std::string &  envvar 
)

Opens a datafile in a directory where OpenBabel expects to find it.

Opens the filestream with the first file called filename found by looking successively in the following directories:

Parameters:
ifs Stream to load
filename Name of the data file to load
envvar Name of the environment variable
Returns:
the full name of the file that was opened (i.e with path) except if it is in current directory

std::string & Trim ( std::string &  txt  ) 

Removes white space from front and back of string.

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 > > &  m,
double &  det 
)

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

bool invert_matrix_ff ( double **  m,
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_ff_f ( double **  src,
double *  dst,
int  rows,
int  cols 
)

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

bool tokenize ( std::vector< std::string > &  vcr,
const char *  buf,
const char *  delimstr 
)

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)

bool tokenize ( std::vector< std::string > &  vcr,
std::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 ( const char *  str  ) 

Deprecated: use the OBMessageHandler class instead

Deprecated:
Throw an error through the OpenBabel::OBMessageHandler class

void ThrowError ( std::string &  str  ) 

Deprecated: use the OBMessageHandler class instead

Deprecated:
Throw an error through the OpenBabel::OBMessageHandler class

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

Convert Cartesian XYZ to a set of OBInternalCoord coordinates.

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 
)

Convert set of OBInternalCoord coordinates into Cartesian XYZ.

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   
)

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

double calc_rms ( double *  ,
double *  ,
unsigned  int 
)

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

void ToUpper ( std::string &   ) 

Shift the supplied string to uppercase.

void ToUpper ( char *   ) 

Shift the supplied char* to uppercase.

void ToLower ( std::string &   ) 

Shift the supplied string to lowercase.

void ToLower ( char *   ) 

Shift the supplied char* to lowercase.

void OpenBabel::InvertCase ( std::string &  ,
int   
)

void InvertCase ( char *   ) 

Shift the supplied char*: lowercase to upper, and upper to lower.

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

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

Comparison -- returns true if first parameter less than second

Returns:
True if a < b, False otherwise.

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

Comparison -- returns true if first parameter less than second

Returns:
True if a < b, False otherwise.

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

Comparison for doubles: returns fabs(a - b) < epsilon.

"Safe" comparison for floats/doubles: returns fabs(a - b) < epsilon This function really doesn't make any sense w.r.t. floating-point representation, so you should never use it. It is provided only for backwards compatibility.

Deprecated:
Use IsApprox() instead

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

Comparison for doubles: returns fabs(a) < epsilon.

"Safe" comparison for floats/doubles: true if a is less than epsilon This function really doesn't make any sense w.r.t. floating-point representation, so you should never use it. It is provided only for backwards compatibility.

Deprecated:

bool IsNan ( const double &   ) 

Comparison for nan (not a number).

bool OpenBabel::IsNegligible ( const double &  a,
const double &  b,
const double  precision = 1e-11 
) [inline]

Returns:
true if a is much smaller than b. More precisely: 
   return( fabs(a) <= precision * fabs(b) );

bool OpenBabel::IsApprox ( const double &  a,
const double &  b,
const double  precision = 1e-11 
) [inline]

Safe comparison for floats/doubles: true if fabs(a - b) <= precision * std::min( fabs(a), fabs(b) ) The parameter precision plays the role of 10^-N where N is the number of significant digits to consider. This is the correct way to replace operator== for doubles. For new code, use this function instead of the old IsNear() function.

Note:
To check if x is zero, use 
   IsNegligible( x, 1.0)
instead of 
   IsApprox( x, 0.0 )

bool OpenBabel::IsApprox_pos ( const double &  a,
const double &  b,
const double  precision = 1e-11 
) [inline]

Same as IsApprox(), but only for positive numbers. Faster.

bool CanBeSquared ( const double &  a  ) 

Tests whether its argument can be squared without triggering an overflow or underflow.

Tests whether its argument can be squared without triggering an overflow or underflow.

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

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

void DoubleAdd ( DoubleType *  ,
unsigned  int 
)

unsigned int DoubleModulus ( DoubleType *  ,
unsigned  int 
)

bool CompareRingSize ( const OBRing *  ,
const OBRing *   
)

Comparison function for rings, used by OBRingSearch::SortRings()

Returns:
true if a.size() > b.size()

int Swab ( int   ) 

Swap Byte instruction (i.e., handle transfers between endian forms).

vector3 OpenBabel::center_coords ( double *  ,
int   
)

ostream & operator<< ( std::ostream &  ,
const vector3 &   
)

Prints a representation of the vector as a row vector of the form "<0.1,1,2>".

vector3 OpenBabel::operator+ ( const vector3 &  v1,
const vector3 &  v2 
) [inline]

Vector addition.

vector3 OpenBabel::operator- ( const vector3 &  v1,
const vector3 &  v2 
) [inline]

Vector subtraction.

vector3 OpenBabel::operator- ( const vector3 &  v  )  [inline]

Unary minus.

vector3 OpenBabel::operator * ( const double &  c,
const vector3 &  v 
) [inline]

Multiplication with a scalar.

vector3 OpenBabel::operator * ( const vector3 &  v,
const double &  c 
) [inline]

Multiplication with a scalar.

vector3 OpenBabel::operator/ ( const vector3 &  v,
const double &  c 
) [inline]

Division by a scalar.

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

Matrix-vector multiplication.

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

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

Dot product of two vectors.

vector3 cross ( const vector3 &  ,
const vector3 &   
)

Cross product of two vectors.

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

Calculate the angle between vectors (in degrees).

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 CalcTorsionAngle ( const vector3 &  a,
const vector3 &  b,
const vector3 &  c,
const vector3 &  d 
)

Calculate the torsion angle between vectors (in degrees).

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 theanticlockwise 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.

double Point2PlaneAngle ( const vector3  a,
const vector3  b,
const vector3  c,
const vector3  d 
)

Calculate the angle between point a and the plane determined by b,c,d.

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 
)

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

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

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

static bool OpenBabel::CompareUnsigned ( const unsigned int &  a,
const unsigned int &  b 
) [static]

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

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

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

static unsigned int OpenBabel::GetValence ( OBAtom *  atom,
OBBitVec &  frag_atoms 
) [static]

static unsigned int OpenBabel::GetHvyValence ( OBAtom *  atom,
OBBitVec &  frag_atoms 
) [static]

static unsigned int OpenBabel::GetHvyBondSum ( OBAtom *  atom,
OBBitVec &  frag_atoms 
) [static]

static bool OpenBabel::GetGTDVector ( OBMol *  pmol,
OBBitVec &  frag_atoms,
vector< int > &  gtd 
) [static]

static void OpenBabel::FindRingAtoms ( OBMol *  pmol,
OBBitVec &  frag_atoms,
OBBitVec &  ring_atoms 
) [static]

static void OpenBabel::GetGIVector ( OBMol *  pmol,
OBBitVec &  frag_atoms,
vector< unsigned int > &  vid 
) [static]

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

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

static int OpenBabel::ExtendInvarients ( vector< pair< OBAtom *, unsigned int > > &  symmetry_classes,
OBBitVec &  frag_atoms,
unsigned int  nfragatoms,
unsigned int  natoms 
) [static]

static int OpenBabel::CalculateSymmetry ( OBMol *  pmol,
OBBitVec &  frag_atoms,
vector< pair< OBAtom *, unsigned int > > &  symmetry_classes 
) [static]

static void OpenBabel::BreakChiralTies ( OBMol *  pmol,
OBBitVec &  frag_atoms,
int  nfragatoms,
vector< pair< OBAtom *, unsigned int > > &  atom_sym_classes 
) [static]

static void OpenBabel::FindConjugatedEZBonds ( OBAtom *  atom,
OBBitVec &  flip_bonds,
OBBitVec &  visited_atoms 
) [static]

static void OpenBabel::FixCisTransBonds ( OBMol *  pmol,
OBBitVec &  frag_atoms,
vector< unsigned int > &  symmetry_classes,
vector< unsigned int > &  canonical_labels 
) [static]

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 OpenBabel::Toupper ( string &  s  ) 

void OpenBabel::Tolower ( string &  s  ) 

bool OpenBabel::tokenize ( vector< string > &  ,
const char *  ,
const char *   
)

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

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

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< OBAtom * > &  va,
vector< OBAtom * >::iterator  i,
vector< int > &  maxv,
bool  secondpass 
)

void OpenBabel::CorrectBadResonanceForm ( OBMol &  mol  ) 

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

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

Returns:
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.

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,
const 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,
const 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,
const 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,
const string &  filename 
)

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

void OpenBabel::InvertCase ( std::string &  s,
unsigned int  start 
)

Shift the supplied string: lowercase to upper, and upper to lower

Parameters:
s - The string to switch case
start - The position to start inverting case

int OpenBabel::SolveLinear ( double  A,
double  B 
)

int OpenBabel::SolveQuadratic ( double  A,
double  B,
double  C 
)

double OpenBabel::CubeRoot ( double  X  ) 

int OpenBabel::SolveCubic ( double  A,
double  B,
double  C,
double  D 
)

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

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 ( const 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]

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]

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]

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

double OpenBabel::rint ( double  x  )  [inline]

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 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.

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

static double OpenBabel::SQUARE ( double  x  )  [inline, static]

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

Print a text representation of the matrix in the standardized form: [ a, b, c ]
[ d, e, f ]
[ g, h, i ]
where the letters represent the appropriate entries in the matrix. Uses the standard output format for the individual entries, separated by ", " for each column, and [ ] indicating each row.

Variable Documentation

const unsigned RateData = 55555

const unsigned ThermoData = 55556

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.

OBERROR OBMessageHandler obErrorLog

Global OBMessageHandler error handler.

OBResidueData resdat

Global OBResidueData biomolecule residue database.

OBERROR OBMessageHandler obErrorLog

Global OBMessageHandler error handler.

OBERROR OBMessageHandler obErrorLog

Global OBMessageHandler error handler.

char Residue[MAXRES][4]

char ElemDesc[MAXELEM][4]

unsigned int ResNo

unsigned int ElemNo

const vector3 VZero

The zero vector: <0.0, 0.0, 0.0>.

const vector3 VX

The x unit vector: <1.0, 0.0, 0.0>.

const vector3 VY

The y unit vector: <0.0, 1.0, 0.0>.

const vector3 VZ

The z unit vector: <0.0, 0.0, 1.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)

OBPhModel phmodel

OBERROR 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.

const 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

const 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

const 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

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.

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[BUFF_SIZE] [static]

char Descr[BUFF_SIZE] [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]

char ElemDesc[MAXELEM][4]

unsigned int ResNo = MINRES

unsigned int ElemNo = MINELEM

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)

const vector3 VZero(0.0, 0.0, 0.0)

The zero vector: <0.0, 0.0, 0.0>.

const vector3 VX(1.0, 0.0, 0.0)

The x unit vector: <1.0, 0.0, 0.0>.

const vector3 VY(0.0, 1.0, 0.0)

The y unit vector: <0.0, 1.0, 0.0>.

const vector3 VZ(0.0, 0.0, 1.0)

The z unit vector: <0.0, 0.0, 1.0>.