OpenBabel Namespace Reference

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

Classes

class AliasData

Indicate atoms as aliases for larger functional groups. More...

class OBAtom

Atom class. More...

class OBAtomClassData

Handle atom classes in reaction SMILES/SMIRKS. More...

class OBGenericData

Base class for generic data. More...

class OBBase

Base Class. More...

class OBBitVec

A speed-optimized vector of bits. More...

class OBBond

Bond class. More...

class OBBondTyper

Assigns bond types for file formats without bond information. More...

class OBBuilder

Class to build 3D structures. 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 OBDescriptor

Base class for molecular properties, descriptors or features. 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...

struct LineSearchType

The type of line search to be used for optimization -- simple or Newton numeric. More...

class OBFFParameter

Internal class for OBForceField to hold forcefield parameters. More...

class OBFFCalculation2

Internal class for OBForceField to hold energy and gradient calculations on specific force fields. More...

class OBFFCalculation3

Internal class for OBForceField to hold energy and gradient calculations on specific force fields. More...

class OBFFCalculation4

Internal class for OBForceField to hold energy and gradient calculations on specific force fields. More...

class OBFFConstraint

Internal class for OBForceField to hold constraints. More...

class OBFFConstraints

Internal class for OBForceField to handle constraints. More...

class OBForceField

Base class for molecular mechanics force fields. More...

class OBFormat

Base class for file formats. 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 OBRotationData

Used to hold the rotational constants and symmetry numbers. More...

class OBVectorData

Used to hold a 3D vector item (e.g., a dipole moment). More...

class OBMatrixData

Used to hold a 3x3 matrix item (e.g., a quadrupole moment). More...

class OBGrid

A base grid class. More...

class OBFloatGrid

Handle double precision 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 OBGridData

Store values for numeric grids such as orbitals or electrostatic potential. More...

class OBGroupContrib

Handle group contribution algorithms. 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 OBLocale

Handle the locale for numeric data parsing. 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 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...

class OBOp

Operations to modify molecules before output. More...

class OpTransform

Applies molecular transforms (OBChemTsfm class) read from a datafile. 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...

struct CharPtrLess

Case insensitive string comparison for PluginMapType key. More...

class OBPlugin

Base class for all types of dynamic classes discovered at runtime. More...

class OBPointGroup

Brute-force point group symmetry perception. 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 OBRotorKeys

A class to generate all possible rotorKeys. More...

class OBAtomTyper

Assigns atom types, hybridization, implicit valence and formal charges. More...

class OBAromaticTyper

Assigns aromatic typing to atoms and bonds. More...

class OBRingTyper

Assigns ring types. 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 SpaceGroup

Handle crystallographic space group symmetry. More...

class transform3d

Handle 3D transformations, such as space group definitions. 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 struct Template Template

typedef OBPairTemplate< int > OBPairInteger

typedef OBPairTemplate< double > OBPairFloatingPoint

typedef OBPlugin::PluginIterator Formatpos

typedef union OpenBabel::_AtomExpr AtomExpr

typedef union OpenBabel::_BondExpr BondExpr

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

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

typedef std::list< transform3d * >
::const_iterator transform3dIterator

typedef union 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
}

enum errorQualifier { always, onceOnly }

enum { SPACE_GROUP_ID, SPACE_GROUP_HALL, SPACE_GROUP_HM, SPACE_GROUP_TRANSFORM }

Functions

OBERROR double Tanimoto (const OBBitVec &bv1, const OBBitVec &bv2)

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)

template<class T>

static bool DoComparison (char ch1, char ch2, T &val, T &filterval)

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)

void ThrowError (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 &)

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

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

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)

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

OBERROR bool tokenize (std::vector< std::string > &, std::string &, const char *delimstr=" \t\n\r", int limit=-1)

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

OBERROR std::string OpenDatafile (std::ifstream &fs, const std::string &filename, const std::string &envvar="BABEL_DATADIR")

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| (const OBBitVec &bv1, const OBBitVec &bv2)

OBBitVec operator & (const OBBitVec &bv1, const OBBitVec &bv2)

OBBitVec operator^ (const OBBitVec &bv1, const OBBitVec &bv2)

OBBitVec operator- (const OBBitVec &bv1, const OBBitVec &bv2)

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

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

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

std::ostream & operator<< (std::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, int nfragatoms, 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)

void Reweight (std::vector< std::vector< double > > &rotorWeights, std::vector< int > rotorKey, double bonus)

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 (std::ifstream &fs, const string &filename)

bool SafeOpen (std::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])

OpCenter theOpCenter ("center")

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)

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

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)

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)

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 int AliasDataType = 0x7883

const unsigned RateData = 55555

const unsigned ThermoData = 55556

OBERROR OBLocale obLocale

OBElementTable etab

OBTypeTable ttab

OBIsotopeTable isotab

OBAromaticTyper aromtyper

OBAtomTyper atomtyper

OBChainsParser chainsparser

OBERROR OBMessageHandler obErrorLog

OBResidueData resdat

char Residue [MAXRES][4]

char ElemDesc [MAXELEM][4]

unsigned int ResNo = MINRES

unsigned int ElemNo = MINELEM

const vector3 VZero

const vector3 VX

const vector3 VY

const vector3 VZ

OBPhModel phmodel

static int bitsoff [SETWORD]

const unsigned nibble_bit_count [0x10]

OBBondTyper bondtyper

static Template Peptide [MAXPEPTIDE]

static Template Nucleotide [MAXNUCLEIC]

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

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

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]

POINT_GROUP PointGroups []

static int primes [MAXPRIMES]

OBRingTyper ringtyper

static int SINT = 0x00000001

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

static SpaceGroups _SpaceGroups

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 struct OpenBabel::Template Template

Structure template for atomic patterns in residues for OBChainsParser.

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 OBPlugin::PluginIterator Formatpos

typedef union OpenBabel::_AtomExpr AtomExpr

typedef union OpenBabel::_BondExpr BondExpr

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 std::list<transform3d*>::const_iterator transform3dIterator

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

enum errorQualifier

Enumerator:

always
onceOnly

anonymous enum

Enumerator:

SPACE_GROUP_ID
SPACE_GROUP_HALL
SPACE_GROUP_HM
SPACE_GROUP_TRANSFORM

Function Documentation

double Tanimoto	(	const OBBitVec &	bv1,
		const OBBitVec &	bv2
	)

The Tanimoto coefficient, which may be regarded as the proportion of the "on-bits" which are shared.

The Tanimoto coefficient may be regarded as the proportion of the "on-bits" which are shared.

Parameters:

`[in]`	bv1	the first bit vector
`[in]`	bv2	the second bit vector

Returns:: the ratio of shared bits to bits which either vector has set.

Referenced by FastSearch::FindSimilar().

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.

Referenced by GraphPotentials().

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

Referenced by GraphPotentials().

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

Referenced by GetChirality().

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.

Referenced by CalcSignedVolume().

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

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

Calculates parity of a vector of 4 items.

Referenced by CorrectChirality().

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

static bool OpenBabel::DoComparison	(	char	ch1,
		char	ch2,
		T &	val,
		T &	filterval
	)			`[inline, static]`

Referenced by OBDescriptor::Compare(), and OBDescriptor::CompareStringWithFilter().

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
	)

Referenced by GraphPotentials().

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
	)

Referenced by GraphPotentials().

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
	)

void ThrowError ( 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.

Referenced by OBMol::GetInternalCoord().

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 &	src,
		char *	ext
	)

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

void get_rmat	(	double *	rvec,
		double *	r,
		double *	f,
		int	size
	)

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

Referenced by get_roots_3_3(), and OBMol::ToInertialFrame().

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

double superimpose	(	double *	r,
		double *	f,
		int	size
	)

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

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

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

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 OpenBabel::InvertCase	(	std::string &	,
		int
	)

void InvertCase ( char * cptr )

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.

Referenced by CreateNewClassVector().

bool IsNear	(	const double &	a,
		const double &	b,
		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

Referenced by OBForceField::ConjugateGradientsTakeNSteps(), OBForceField::LineSearch(), OBForceField::SteepestDescentTakeNSteps(), OBForceField::ValidateConjugateGradients(), OBForceField::ValidateSteepestDescent(), and OBForceField::WeightedRotorSearch().

bool IsNearZero	(	const double &	a,
		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:

Referenced by OBAtom::GetAngle(), OBMol::Has2D(), OBMol::Has3D(), OBForceField::Newton2NumLineSearch(), OBForceField::VectorAngle(), OBForceField::VectorAngleDerivative(), OBForceField::VectorOOP(), OBForceField::VectorOOPDerivative(), OBForceField::VectorTorsion(), and OBForceField::VectorTorsionDerivative().

bool IsNan ( const double & a )

Comparison for nan (not a number).

Referenced by OBDescriptor::CompareStringWithFilter().

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) );

Referenced by vector3::createOrthoVector(), OBUnitCell::GetCellMatrix(), OBUnitCell::GetCellVectors(), and matrix3x3::isDiagonal().

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 )

Referenced by CalcSignedVolume(), OBUnitCell::GetLatticeType(), matrix3x3::isSymmetric(), matrix3x3::isUnitMatrix(), and OBMol::PerceiveBondOrders().

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.

Referenced by vector3::CanBeNormalized().

bool SafeOpen	(	std::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.

Referenced by SafeOpen().

bool SafeOpen	(	std::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.

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

void DoubleMultiply	(	unsigned int	x,
		unsigned int	y,
		DoubleType *	z
	)

Referenced by DeterminePotency(), GenerateSequence(), OBRandom::NextFloat(), and OBRandom::NextInt().

void DoubleAdd	(	DoubleType *	x,
		unsigned int	y
	)

Referenced by GenerateSequence(), OBRandom::NextFloat(), and OBRandom::NextInt().

unsigned int DoubleModulus	(	DoubleType *	n,
		unsigned int	d
	)

Referenced by DeterminePotency(), GenerateSequence(), OBRandom::NextFloat(), and OBRandom::NextInt().

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

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

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

Referenced by OBRingSearch::SortRings().

int Swab ( int i )

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

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)

Referenced by OBDescriptor::AddProperties(), patty::assign_rules(), OBDescriptor::DeleteProperties(), DLHandler::findFiles(), OBDescriptor::GetValues(), OBBuilder::LoadFragments(), OBAromaticTyper::ParseLine(), OBRingTyper::ParseLine(), OBAtomTyper::ParseLine(), OBRotorRules::ParseLine(), OBPhModel::ParseLine(), OBResidueData::ParseLine(), OBTypeTable::ParseLine(), OBIsotopeTable::ParseLine(), OBBondTyper::ParseLine(), and patty::read_rules().

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.

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

Removes white space from front and back of string.

Referenced by OBMol::DoTransformations(), OBCommentData::SetData(), and OBMol::SetTitle().

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:

the current directory
in a subdirectory (of the directory below) with the version of OpenBabel as its name
the parent directory specified by the environment variable named envvar or "BABEL_DATADIR" if envvar is not specified, or the compiled-in macro BABEL_DATADIR if the environment variable is not set

Parameters:

	ifs	Stream to load
	filename	Name of the data file to load
	envvar	Name of the environment variable

Returns:: the name of the file that was opened. This includes the path unless it is in current directory

Referenced by OBGlobalDataBase::Init(), OBBuilder::LoadFragments(), and OBMoleculeFormat::ReadNameIndex().

vector3 OpenBabel::center_coords	(	double *	,
		int
	)

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

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
	)

Multiplication of matrix and vector.

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.

Referenced by CalcTorsionAngle(), OBForceField::ConjugateGradientsTakeNSteps(), Point2Plane(), OBForceField::ValidateConjugateGradients(), vectorAngle(), OBForceField::VectorAngleDerivative(), OBForceField::VectorOOPDerivative(), and OBForceField::VectorTorsionDerivative().

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

Cross product of two vectors.

Referenced by OBMol::Align(), CalcTorsionAngle(), OBBuilder::Connect(), OBRing::findCenterAndNormal(), OBBuilder::GetNewBondVector(), OBAtom::GetNewBondVector(), InternalToCartesian(), Point2Plane(), Point2PlaneAngle(), OBAtom::SetHybAndGeom(), OBForceField::VectorAngleDerivative(), OBForceField::VectorOOPDerivative(), and OBForceField::VectorTorsionDerivative().

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)

Referenced by OBMol::Align(), OBAtom::AverageBondAngle(), CalcTorsionAngle(), CartesianToInternal(), OBBuilder::Connect(), OBAtom::GetAngle(), Point2PlaneAngle(), OBUnitCell::SetData(), OBAtom::SetHybAndGeom(), OBAtom::SmallestBondAngle(), and OBForceField::VectorTorsionDerivative().

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.

Referenced by OBRotamerList::AddRotamer(), BreakChiralTies(), CartesianToInternal(), OBMol::GetTorsion(), OBBond::IsDoubleBondGeometry(), and match().

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]`

Referenced by OBAtom::SetHybAndGeom().

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

Return a bit vector of the results of Or-ing each bit in bv1 with the corresponding bit in bv2

Parameters:

`[in]`	bv1	A bit vector
`[in]`	bv2	Another bit vector

Returns:: A bit vector

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

Return a bit vector of the results of And-ing each bit in bv1 with the corresponding bit in bv2

Parameters:

`[in]`	bv1	A bit vector
`[in]`	bv2	Another bit vector

Returns:: A bit vector

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

Return a bit vector of the results of Exclusive-or-ing each bit in bv1 with the corresponding bit in bv2

Parameters:

`[in]`	bv1	A bit vector
`[in]`	bv2	Another bit vector

Returns:: A bit vector

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

Return a bit vector of the results of clearing each bit in bv1 which is set in bv2

Parameters:

`[in]`	bv1	A bit vector
`[in]`	bv2	Another bit vector

Returns:: A bit vector

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

Return true if bv1 and bv2 are equivalent Not that they may be of different size, and still equivalent provided that the extra bits are all zero.

Parameters:

`[in]`	bv1	A bit vector
`[in]`	bv2	Another bit vector

Returns:: true if equal, false otherwise

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

Return true if bv1 i less than bv2 Lexicographical order, with bit vectors written LSB first.

Parameters:

`[in]`	bv1	A bit vector
`[in]`	bv2	Another bit vector

Returns:: true if equal, false otherwise

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

Sets bits on, listed as a string of character-represented integers in a stream Only reads one line of input The format is "[ n0 n1 n2 n3 ... ]". The square brackets are optional. The whitespace can be SPACE or HTAB For example "[ 1 5 6 9 ]"

Parameters:

`[in,out]`	is	The input stream
`[out]`	bv	The bit vector to contain the result

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

Output this bit vector to a stream The format is "[ n0 n1 n2 n3 ... ]". The whitespace is SPACE For example "[ 1 5 6 9 ]"

Parameters:

`[out]`	os	The output stream
`[in]`	bv	The bit vector to be output

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

Referenced by CreateNewClassVector().

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

Referenced by CanonicalLabels().

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

Referenced by BreakChiralTies(), and CountAndRenumberClasses().

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

Referenced by FixCisTransBonds().

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

Referenced by BreakChiralTies(), and FixCisTransBonds().

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

Referenced by GetGIVector().

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

Referenced by GetGIVector().

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

Referenced by GetGIVector().

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

Referenced by GetGIVector().

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

Referenced by CalculateSymmetry().

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

Referenced by CanonicalLabels(), ExtendInvarients(), and OBMol::GetGIDVector().

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

Referenced by CanonicalLabels(), and ExtendInvarients().

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

Referenced by BreakChiralTies(), and CalculateSymmetry().

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

Referenced by CanonicalLabels().

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

Referenced by CanonicalLabels().

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

Referenced by FixCisTransBonds().

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

Referenced by CanonicalLabels().

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

Referenced by GenerateByteCodes().

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

Free a ByteCode and all corresponding data.

Referenced by OBChainsParser::~OBChainsParser().

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

Referenced by GenerateByteCodes().

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

void OpenBabel::Toupper ( string & s )

void OpenBabel::Tolower ( string & s )

void OpenBabel::Reweight	(	std::vector< std::vector< double > > &	rotorWeights,
		std::vector< int >	rotorKey,
		double	bonus
	)

Referenced by OBForceField::WeightedRotorSearch().

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
	)

Referenced by OBMol::ContigFragList().

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

Referenced by OBMol::ConnectTheDots(), and OBMol::PerceiveBondOrders().

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

Referenced by ClassCount().

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

Referenced by CreateNewClassVector(), and OBMol::GetGIDVector().

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

counts the number of unique symmetry classes in a list

Referenced by OBMol::GetGIDVector().

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]

Referenced by KekulePropagate().

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

int OpenBabel::GetCurrentValence ( OBAtom * atom )

Referenced by ExpandKekule().

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

Referenced by OBMol::PerceiveKekuleBonds().

void OpenBabel::CorrectBadResonanceForm ( OBMol & mol )

Referenced by OBMol::PerceiveKekuleBonds().

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

Referenced by OBRotamerList::CreateConformerList(), and OBRotamerList::SetCurrentCoordinates().

bool OpenBabel::SafeOpen	(	std::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	(	std::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
	)

Referenced by SolveQuadratic().

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

Referenced by SolveCubic().

double OpenBabel::CubeRoot ( double X )

Referenced by SolveCubic().

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]`

Referenced by get_rmat(), and superimpose().

OpCenter OpenBabel::theOpCenter ( "center" )

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

Referenced by patty::assign_types(), EvalAtomExpr(), OBSmartsPattern::Match(), and OBSmartsPattern::RestrictedMatch().

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

Referenced by FastSingleMatch(), OBSSMatch::Match(), and SetupAtomMatchTable().

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

Referenced by FastSingleMatch(), and OBSSMatch::Match().

static int GetVectorBinding ( ) [static]

Referenced by SMARTSParser().

static int CreateAtom	(	Pattern *	pat,
		AtomExpr *	expr,
		int	part,
		int	vb = `0`
	)			`[static]`

Referenced by CopyPattern(), and SMARTSParser().

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

Referenced by AllocPattern(), CreateAtom(), and CreateBond().

static void FreePattern ( Pattern * pat ) [static]

Referenced by ConstrainRecursion(), FreeAtomExpr(), ParseComplexAtomPrimitive(), SMARTSError(), and OBSmartsPattern::~OBSmartsPattern().

static Pattern * CopyPattern ( Pattern * pat ) [static]

Referenced by CopyAtomExpr().

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

Referenced by BuildAtomBin(), BuildAtomLeaf(), BuildAtomNot(), BuildAtomRecurs(), and CopyAtomExpr().

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

Referenced by AndAtomExpr(), and CopyPattern().

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

Referenced by AndAtomExpr(), AndAtomExprLeaf(), AtomExprImplies(), FreePattern(), NotAtomExpr(), OrAtomExpr(), and ParseAtomExpr().

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

Referenced by AndAtomExprLeaf(), ConstrainRecursion(), GenerateAromElem(), GenerateElement(), ParseComplexAtomPrimitive(), and ParseSimpleAtomPrimitive().

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

Referenced by NotAtomExpr(), and ParseAtomExpr().

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

Referenced by AndAtomExprLeaf(), GenerateAromElem(), OrAtomExprLeaf(), and ParseAtomExpr().

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

Referenced by ParseComplexAtomPrimitive().

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

Referenced by ParseComplexAtomPrimitive(), ParseSimpleAtomPrimitive(), and SMARTSParser().

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

Referenced by ParseComplexAtomPrimitive(), and ParseSimpleAtomPrimitive().

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

Referenced by ConstrainRecursion().

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

Referenced by BuildBondBin(), BuildBondLeaf(), BuildBondNot(), and CopyBondExpr().

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

Referenced by CopyPattern().

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

Referenced by SMARTSParser().

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

Referenced by FreePattern(), ParseBondExpr(), ParseSMARTSError(), ParseSMARTSPart(), and SMARTSParser().

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

Referenced by GenerateDefaultBond(), and ParseBondPrimitive().

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

Referenced by ParseBondExpr().

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

Referenced by GenerateDefaultBond(), and ParseBondExpr().

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

Referenced by SMARTSParser().

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

Referenced by CopyPattern(), and ParseSMARTSPattern().

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

Referenced by CopyPattern(), and SMARTSParser().

static Pattern * ParseSMARTSPattern ( void ) [static]

Referenced by ParseComplexAtomPrimitive(), and ParseSMARTSString().

static Pattern * ParseSMARTSPart	(	Pattern *	result,
		int	part
	)			`[static]`

Referenced by ParseSMARTSPattern().

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

Referenced by ParseSMARTSError(), ParseSMARTSPart(), ParseSMARTSPattern(), and ParseSMARTSString().

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

Referenced by SMARTSParser().

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

Referenced by ParseAtomExpr().

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

Referenced by SMARTSParser().

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

Referenced by ParseBondExpr().

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

Referenced by SMARTSParser().

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

Referenced by SMARTSParser().

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

Referenced by ParseSMARTSPart().

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

Referenced by ParseSMARTSPart().

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

Referenced by ParseSMARTSPart().

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

Referenced by ParseSMARTSRecord().

Pattern* OpenBabel::ParseSMARTSRecord ( char * ptr )

Referenced by OBSmartsPattern::Init().

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

static AtomExpr * NotAtomExpr ( AtomExpr * expr ) [static]

static AtomExpr * AndAtomExpr	(	AtomExpr *	lft,
		AtomExpr *	rgt
	)			`[static]`

Referenced by ConstrainRecursion(), and NotAtomExpr().

static AtomExpr * OrAtomExpr	(	AtomExpr *	lft,
		AtomExpr *	rgt
	)			`[static]`

Referenced by AndAtomExpr(), and NotAtomExpr().

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

Referenced by NotAtomExpr().

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

Referenced by AtomLeafConflict(), and NotAtomExpr().

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

Referenced by AndAtomExpr(), and OrAtomExpr().

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

Referenced by AndAtomExpr(), and OrAtomExpr().

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

Referenced by AtomExprConflict().

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

Referenced by AndAtomExprLeaf().

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

Referenced by AtomExprImplied(), and AtomExprImplies().

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

Referenced by AndAtomExprLeaf().

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

Referenced by AndAtomExprLeaf().

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

Referenced by AndAtomExpr().

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

Referenced by AndAtomExpr().

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

Referenced by OrAtomExpr().

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

Referenced by GetBondExprIndex().

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]`

Referenced by match().

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

Referenced by OBSmartsPattern::GetBond().

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

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

Referenced by IsOddPrime().

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

Referenced by DetermineFactors().

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

Referenced by DetermineIncrement().

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

Referenced by DoubleModulus().

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

Referenced by DetermineSequence().

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

Referenced by DetermineSequence().

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

Referenced by DetermineSequence().

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

Referenced by OBRandom::OBRandom().

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

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

Referenced by OBResidue::GetAtomProperty().

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

Referenced by SetResidueKeys().

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

Referenced by OBResidue::SetName().

static int DetermineFRJ ( OBMol & mol ) [static]

Referenced by OBMol::FindSSSR().

void BuildOBRTreeVector	(	OBAtom *	atom,
		OBRTree *	prv,
		vector< OBRTree * > &	vt,
		OBBitVec &	bv
	)			`[static]`

Referenced by OBRingSearch::AddRingFromClosure().

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

Referenced by OBMol::FindRingAtomsAndBonds().

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

Referenced by OBRotamerList::AddRotamer().

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)

Todo:: This code is identical to OBMol::SetTorsion() and should be combined

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

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

bool GetDFFVector	(	OBMol &	mol,
		vector< int > &	dffv,
		OBBitVec &	bv
	)			`[static]`

Referenced by OBRotorList::SetRotAtomsByFix().

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

Referenced by OBRotorList::FindRotors().

static double MinimumPairRMS	(	OBMol &	mol,
		double *	a,
		double *	b,
		bool &	one2one
	)			`[static]`

Referenced by OBRotorList::RemoveSymVals().

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]

Referenced by calc_rms(), OBRotor::CalcBondLength(), OBRotor::CalcTorsion(), OBMol::ConnectTheDots(), matrix3x3::FillOrth(), OBUnitCell::GetCellVolume(), OBUnitCell::GetFractionalMatrix(), OBBond::GetLength(), MinimumPairRMS(), OBRotor::Precompute(), OBRotor::SetRotor(), SetRotorToAngle(), OBRotor::SetToAngle(), OBMol::SetTorsion(), and OBProxGrid::Setup().

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.

const vector3 OpenBabel::VZero	(	0.	0,
		0.	0,
		0.	0
	)

Referenced by CalcSignedVolume().

const vector3 OpenBabel::VX	(	1.	0,
		0.	0,
		0.	0
	)

const vector3 OpenBabel::VY	(	0.	0,
		1.	0,
		0.	0
	)

const vector3 OpenBabel::VZ	(	0.	0,
		0.	0,
		1.	0
	)

Variable Documentation

const unsigned int AliasDataType = 0x7883

const unsigned RateData = 55555

const unsigned ThermoData = 55556

Referenced by OBNasaThermoData::OBNasaThermoData().

OBLocale obLocale

Global OBLocale for setting and restoring locale information.

Referenced by OBGlobalDataBase::Init(), OBBuilder::LoadFragments(), OBConversion::Read(), and OBConversion::Write().

OBElementTable etab

Global OBElementTable for element properties.

Referenced by OBMol::AddHydrogens(), CalculateSymmetry(), OBMol::ConnectTheDots(), AliasData::Expand(), OBAtom::GetAtomicMass(), OBBond::GetEquibLength(), OBMol::GetMolWt(), OBMol::GetSpacedFormula(), OBAtom::HtoMethyl(), OBMol::PerceiveBondOrders(), and OBAtom::SetHybAndGeom().

OBTypeTable ttab

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

Referenced by OBAtom::GetType(), and SetupAtomMatchTable().

OBIsotopeTable isotab

Global OBIsotopeTable for isotope properties.

Referenced by OBAtom::GetAtomicMass(), OBMol::GetExactMass(), and OBAtom::GetExactMass().

OBAromaticTyper aromtyper

Global OBAromaticTyper for detecting aromatic atoms and bonds.

Referenced by OBAtomTyper::AssignHyb(), OBBond::IsAromatic(), OBAtom::IsAromatic(), OBBond::IsDouble(), OBBond::IsSingle(), and OBBond::IsTriple().

OBAtomTyper atomtyper

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

Referenced by OBPhModel::CorrectForPH(), OBAtom::GetHyb(), OBAtom::GetImplicitValence(), OBAtom::GetType(), and OBAtom::ImplicitHydrogenCount().

OBChainsParser chainsparser

Global OBChainsParser for detecting macromolecular chains and residues.

Referenced by OBAtom::GetResidue().

OBMessageHandler obErrorLog

Global OBMessageHandler error handler.

Referenced by FastSearchIndexer::Add(), OBChiralData::AddAtomRef(), OBMol::AddBond(), OBConversion::AddChemObject(), OBMol::AddHydrogens(), OBDescriptor::AddProperties(), OBMol::Align(), AllocateByteCode(), OBChemTsfm::Apply(), patty::assign_types(), OBAromaticTyper::AssignAromaticFlags(), OBAtomTyper::AssignHyb(), OBAtomTyper::AssignImplicitValence(), OBGastChrg::AssignPartialCharges(), OBMol::AssignSpinMultiplicity(), OBRingTyper::AssignTypes(), OBAtomTyper::AssignTypes(), CalcSignedVolume(), CartesianToInternal(), OBMol::Center(), OBConversion::CheckForUnintendedBatch(), FptIndex::CheckFP(), OBMol::Clear(), OBDescriptor::Compare(), OBDescriptor::CompareStringWithFilter(), OBMol::ConnectTheDots(), OBConversion::Convert(), OBMol::ConvertDativeBonds(), CorrectBadResonanceForm(), OBPhModel::CorrectForPH(), OBMol::CorrectForPH(), OBMoleculeFormat::DeferMolOutput(), OBMol::DeleteHydrogens(), OBMol::DeleteNonPolarHydrogens(), OBMol::DoTransformations(), OBMol::EndModify(), OBMol::expand_kekulize(), FatalAllocationError(), FatalMemoryError(), OBDescriptor::FilterCompare(), SpaceGroup::Find(), FastSearch::Find(), OBMol::FindChiralCenters(), OBMol::FindRingAtomsAndBonds(), OBRotorList::FindRotors(), OBMol::FindSSSR(), OBFingerprint::Fold(), OBBitVec::FromString(), OBConversion::FullConvert(), GenerateByteCodes(), OBMol::GetAtom(), OBChiralData::GetAtom4Refs(), GetAtomIDNumber(), OBChiralData::GetAtomRef(), OBMol::GetBond(), OBMol::GetFormula(), OBMol::GetResidue(), OBRotorRules::GetRotorIncrements(), OBChiralData::GetSize(), OBMol::GetTotalCharge(), OBMol::GetTotalSpinMultiplicity(), OBDescriptor::GetValues(), OBAtom::HtoMethyl(), OBGlobalDataBase::Init(), InternalToCartesian(), OBBond::IsClosure(), OBMol::Kekulize(), OBConversion::LoadFormatFiles(), OBBuilder::LoadFragments(), OBMoleculeFormat::MakeCombinedMolecule(), OBMol::NewPerceiveKekuleBonds(), OBConversion::OpenAndSetFormat(), OBConversion::OpenInAndOutFiles(), operator>>(), OBMoleculeFormat::OutputDeferredMols(), OBAromaticTyper::ParseLine(), OBRingTyper::ParseLine(), OBAtomTyper::ParseLine(), OBRotorRules::ParseLine(), OBPhModel::ParseLine(), OBTypeTable::ParseLine(), OBIsotopeTable::ParseLine(), OBBondTyper::ParseLine(), OBMol::PerceiveBondOrders(), OBChainsParser::PerceiveChains(), patty::read_rules(), OBMoleculeFormat::ReadChemObjectImpl(), OBConversion::ReadFile(), OBMoleculeFormat::ReadNameIndex(), OBDescriptor::ReadStringFromFilter(), OBConversion::RegisterOptionParam(), OBRotorList::RemoveSymVals(), OBMol::RenumberAtoms(), OBMol::Rotate(), SafeOpen(), OBChiralData::SetAtom4Refs(), OBTypeTable::SetFromType(), OBAtom::SetHybAndGeom(), OBBond::SetLength(), OBMol::SetTorsion(), OBTypeTable::SetToType(), OBRotorList::Setup(), SMARTSError(), OBMol::start_kekulize(), OBMol::StripSalts(), obLogBuf::sync(), ThrowError(), OBMol::ToInertialFrame(), OBMol::Translate(), OBTypeTable::Translate(), patty::type_to_int(), OBMoleculeFormat::WriteChemObjectImpl(), OBConversion::WriteFile(), and FastSearchIndexer::~FastSearchIndexer().

OBResidueData resdat

Global OBResidueData biomolecule residue database.

char Residue

Referenced by GetResidueNumber().

char ElemDesc

Referenced by GetAtomIDNumber().

unsigned int ResNo = MINRES

Referenced by GetResidueNumber().

unsigned int ElemNo = MINELEM

Referenced by GetAtomIDNumber().

const vector3 VZero(0.0, 0.0, 0.0)

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

Referenced by OBScoreGrid::Center(), center_coords(), OBScoreGrid::CenterMol(), OBFFConstraint::GetGradient(), OBBuilder::GetNewBondVector(), OBAtom::GetNewBondVector(), OBMol::HasNonZeroCoords(), OBForceField::LineSearch(), OBForceField::VectorAngleDerivative(), OBForceField::VectorOOPDerivative(), and OBForceField::VectorTorsionDerivative().

const vector3 VX(1.0, 0.0, 0.0)

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

Referenced by OBBuilder::Build(), OBBuilder::GetNewBondVector(), and OBAtom::GetNewBondVector().

const vector3 VY(0.0, 1.0, 0.0)

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

Referenced by OBBuilder::GetNewBondVector(), OBAtom::GetNewBondVector(), and InternalToCartesian().

const vector3 VZ(0.0, 0.0, 1.0)

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

OBPhModel phmodel

Referenced by OBMol::CorrectForPH(), and OBAtom::GetPartialCharge().

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
    }

Referenced by OBBitVec::NextBit().

const unsigned nibble_bit_count[0x10]

Initial value:

Referenced by OBBitVec::CountBits().

OBBondTyper bondtyper

Global OBBondTyper for perception of bond order assignment.

Referenced by OBMol::PerceiveBondOrders().

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

Referenced by OBChainsParser::OBChainsParser().

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

Referenced by OBChainsParser::OBChainsParser().

MonoAtomType MonoAtom[MaxMonoAtom] [static]

Referenced by GenerateByteCodes().

MonoBondType MonoBond[MaxMonoBond] [static]

Referenced by GenerateByteCodes().

int MonoAtomCount [static]

Referenced by GenerateByteCodes().

int MonoBondCount [static]

Referenced by GenerateByteCodes().

StackType Stack[STACKSIZE] [static]

Referenced by GenerateByteCodes().

int StackPtr [static]

Referenced by GenerateByteCodes().

int AtomIndex [static]

Referenced by GenerateByteCodes().

int BondIndex [static]

Referenced by GenerateByteCodes().

bool StrictFlag = false [static]

Referenced by GenerateByteCodes().

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

double Roots[4] [static]

Referenced by get_roots_3_3(), SolveCubic(), SolveLinear(), and SolveQuadratic().

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

Referenced by EvalAtomExpr(), OBSmartsPattern::Match(), and OBSmartsPattern::RestrictedMatch().

char* MainPtr [static]

Referenced by ParseSMARTSString(), and SMARTSError().

char* LexPtr [static]

Referenced by GetVectorBinding(), ParseAtomExpr(), ParseBondExpr(), ParseBondPrimitive(), ParseComplexAtomPrimitive(), ParseSimpleAtomPrimitive(), ParseSMARTSPattern(), ParseSMARTSString(), SMARTSError(), and SMARTSParser().

char Buffer[BUFF_SIZE] [static]

Referenced by OBSmartsPattern::Init(), and ParseSMARTSRecord().

char Descr[BUFF_SIZE] [static]

Referenced by ParseSMARTSRecord(), and SolveQuadratic().

POINT_GROUP PointGroups[]

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
  }

Referenced by DetermineFactors(), and IsOddPrime().

OBRingTyper ringtyper

Referenced by OBRing::GetType().

int SINT = 0x00000001 [static]

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

SpaceGroups _SpaceGroups [static]

Referenced by SpaceGroup::Find(), SpaceGroup::GetSpaceGroup(), and SpaceGroup::RegisterSpaceGroup().