Open Babel: OpenBabel Namespace Reference

Namespaces | Classes | Typedefs | Enumerations | Functions | Variables

# OpenBabel Namespace Reference

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

## Namespaces
namespace | OBGenericDataType
namespace | detail
namespace | OBAminoAcidProperty
namespace | OBResidueAtomProperty
namespace | OBResidueIndex
namespace | OBResidueProperty
## 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 | OBChargeModel
| Atomic partial charge models. More...
class | OBConformerFilter
| Interface used by OBConformerSearch for filtering conformers. More...
class | OBConformerFilters
| Class for combining OBConformerFilter objects. More...
class | OBStericConformerFilter
| A steric conformer filter class. More...
class | OBConformerScore
| Interface used by OBConformerSearch for scoring conformers. More...
class | OBRMSDConformerScore
| A RMSD conformer scoring class. More...
class | OBEnergyConformerScore
| A lowest energy conformer scoring class. More...
class | OBConformerSearch
| Conformer searching using genetic algorithm. See Conformer Searching. 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 | OBDOSData
| Used to hold density of states information. More...
class | OBOrbital
| Used to store energy, occupation, and orbital symmetry of a particular orbital. More...
class | OBOrbitalData
| Used to hold information about orbital energies. More...
class | OBElectronicTransitionData
| Used to hold information about electronic transitions. 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 | OBGraphSym
| Handle and perceive graph symmtery for canonical numbering . 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 | OBIsomorphismMapper
| Abstract class defining interface for isomorphism (i.e. substructure) searches. 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 | GasteigerState
| Helper class for OBGastChrg which stores the Gasteiger states of a given atom. More...
class | OBGastChrg
| Assigns Gasteiger partial charges. 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 | OBMolBondBFSIter
| Iterate over all bonds 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 reactions/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...
struct | ParseState
| A SMARTS parser internal state. More...
class | OBSmartsPattern
| SMARTS (SMiles ARbitrary Target Specification) substructure searching. More...
class | OBSmartsMatcher
| Internal class: performs matching; a wrapper around previous C matching code to make it thread safe. 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...
class | OBQueryAtom
| Atom in an OBQuery. More...
class | OBQueryBond
| Bond in an OBQuery. More...
class | OBQuery
| A substructure query. 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 | OBSpectrophore
| Class to compute Spectrophores™. More...
class | OBText
| An object containing just text. More...
struct | DeleteObject
| Functor for deleting containers of pointers. Scott Meyers, Effective STL, Item 7. 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 | OBAlign
| Perform a least-squares alignment of two molecules or two vectors of vector3 objects. 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...
class | OBCisTransStereo
| Class for handling and storing cis/trans stereochemistry. More...
class | OBSquarePlanarStereo
| Class for handling and storing square planar stereochemistry. More...
class | OBStereo
| Placeholder for enums & Ref/Refs related functions. More...
struct | OBStereoUnit
| Struct representing a single stereogenic unit. More...
class | OBStereoBase
| Base class for all stereochemistry classes. More...
class | OBStereoFacade
| Facade to simplify retrieval of OBStereoBase derived objects. More...
class | OBTetrahedralStereo
| Class for handling and storing tetrahedral atom stereochemistry. More...
class | OBTetraNonPlanarStereo
| Base class for handling and storing non-planar stereochemistry with 4 reference atom ids. More...
class | OBTetraPlanarStereo
| Base class for handling and storing planar stereochemistry with 4 reference atoms. More...
class | OBDepict
| 2D depiction of molecules using OBPainter. More...
class | OBColor
| Color class used by OBDepict. More...
class | OBFontMetrics
| Font metrics class used by OBDepict. More...
class | OBPainter
| Abstract painter base class used by OBDepict. More...
## 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 std::vector< int > | RotorKey
typedef std::vector< RotorKey > | RotorKeys
typedef OBPairTemplate< int > | OBPairInteger
typedef OBPairTemplate< double > | OBPairFloatingPoint
typedef OBIsomorphismMapper::Mapping | Automorphism
typedef OBIsomorphismMapper::Mappings | Automorphisms
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 std::vector< OBStereoUnit > | OBStereoUnitSet
typedef std::vector < OBStereoUnitSet > | OBStereoUnitSetOfSets
typedef union OpenBabel::_ByteCode | ByteCode
typedef struct OpenBabel::adjustedlist | adjustedlist
typedef adjustedlist | neigbourlist [NATOMSMAX]
## Enumerations
enum | DataOrigin { any, fileformatInput, userInput, perceived, external, local }
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 }
enum | { TopLeft = 1, TopCenter = 2, TopRight = 3, CenterLeft = 4, Center = 5, CenterRight = 6, BottomLeft = 7, BottomCenter = 8, BottomRight = 9 }
## Functions
std::string | OBReleaseVersion ()
double | Tanimoto (const OBBitVec &bv1, const OBBitVec &bv2)
void | CanonicalLabels (OBMol *mol, const std::vector< unsigned int > &symmetry_classes, std::vector< unsigned int > &canonical_labels, const OBBitVec &mask=OBBitVec(), int maxSeconds=5, bool onlyOne=false)
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)
bool | MapsTo (const OBIsomorphismMapper::Mapping &map, unsigned int queryIndex, unsigned int &queriedIndex)
bool | FindAutomorphisms (OBMol *mol, std::vector< OBIsomorphismMapper::Mapping > &aut, const std::vector< unsigned int > &symmetry_classes, const OBBitVec &mask=OBBitVec(), std::size_t maxMemory=3000000)
bool | FindAutomorphisms (OBMol *mol, std::vector< OBIsomorphismMapper::Mapping > &aut, const OBBitVec &mask=OBBitVec(), std::size_t maxMemory=3000000)
void | FindAutomorphisms (OBIsomorphismMapper::Functor &functor, OBMol *mol, const std::vector< unsigned int > &symmetry_classes, const OBBitVec &mask=OBBitVec())
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)
int | hydrogenValency (int na)
int | maxValency (int na)
int | alternate (OBMol *pmol, const int nH[], int bondOrders[])
int | alternate (const std::vector< int > aPosition, const std::vector< int > aCharge, const std::vector< int > aRad, const std::vector< int > nHydr, const std::vector< int > iA1, const std::vector< int > iA2, std::vector< int > &bondOrders, int nAtoms, int nBonds)
void | generateDiagram (OBMol *pmol)
void | generateDiagram (const std::vector< int > iA1, const std::vector< int > iA2, std::vector< double > &rx, std::vector< double > &ry, int nAtoms, int nBonds)
void | generateDiagram (OBMol *pmol, std::ostream &ofs)
bool | fragmentSearch (OBMol *query, OBMol *structure)
bool | fragmentSearch (const std::vector< int > aPositionQuery, const std::vector< int > iA1Query, const std::vector< int > iA2Query, const std::vector< int > bondTypesQuery, const std::vector< int > aPositionStructure, const std::vector< int > iA1Structure, const std::vector< int > iA2Structure, const std::vector< int > bondTypesStructure, int nAtomsQuery, int nBondsQuery, int nAtomsStructure, int nBondsStructure)
void | equivalenceList (OBMol *pmol, std::vector< int > &eqList)
void | equivalenceList (const std::vector< int > aPosition, const std::vector< int > aCharge, const std::vector< int > aRad, const std::vector< int > iA1, const std::vector< int > iA2, const std::vector< int > bondTypes, std::vector< int > &eqList, int nAtoms, int nBonds)
void | addFragment (OBMol *molecule, OBMol *fragment, int molAN, int fragAN, int molBN, int fragBN, bool isAddition)
void | createStereoLists (OBMol *pmol, std::vector< int > &bondStereoList, std::vector< int > &atomStereoList, std::vector< int > &eqList)
std::string | getAtomMCDL (OBMol *pmol, int ntatoms, const std::vector< int > ix, const std::vector< int > aNumber, const std::vector< int > atomStereoList, const std::vector< int > eqList)
std::string | getBondMCDL (OBMol *pmol, int nbStore, int ntatoms, const std::vector< int > ix, const std::vector< int > aNumber, int bonds[MAXBONDS][4], const std::vector< int > bondStereoList, const std::vector< int > eqList)
void | implementAtomStereo (std::vector< int > &iA1, std::vector< int > &iA2, std::vector< int > &stereoBonds, const std::vector< double >rx, const std::vector< double > ry, int acount, int bcount, std::string astereo)
void | implementBondStereo (const std::vector< int > iA1, const std::vector< int > iA2, std::vector< double > &rx, std::vector< double > &ry, int acount, int bcount, std::string bstereo)
int | groupRedraw (OBMol *pmol, int bondN, int atomN, bool atomNInGroup)
int | canonizeMCDL (const std::string atomBlock, std::vector< std::string > &structureList)
bool | parseFormula (const std::string formulaString, std::vector< int > &enumber, int &valency)
void | prepareTest (OBMol *pmol, std::ostream &ofs)
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], unsigned)
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 > > &)
| OB_STATIC_PLUGIN (ACRFormat, theACRFormat)
| OB_STATIC_PLUGIN (ADFOutputFormat, theADFOutputFormat)
| OB_STATIC_PLUGIN (ADFInputFormat, theADFInputFormat)
| OB_STATIC_PLUGIN (AlchemyFormat, theAlchemyFormat)
| OB_STATIC_PLUGIN (AmberPrepFormat, theAmberPrepFormat)
| OB_STATIC_PLUGIN (OBAPIInterface, theOBAPIInterface)
| OB_STATIC_PLUGIN (BallStickFormat, theBallStickFormat)
| OB_STATIC_PLUGIN (BGFFormat, theBGFFormat)
| OB_STATIC_PLUGIN (BoxFormat, theBoxFormat)
| OB_STATIC_PLUGIN (CacaoFormat, theCacaoFormat)
| OB_STATIC_PLUGIN (CacheFormat, theCacheFormat)
| OB_STATIC_PLUGIN (CARFormat, theCARFormat)
| OB_STATIC_PLUGIN (CCCFormat, theCCCFormat)
| OB_STATIC_PLUGIN (CHEM3D1Format, theCHEM3D1Format)
| OB_STATIC_PLUGIN (CHEM3D2Format, theCHEM3D2Format)
| OB_STATIC_PLUGIN (ChemDrawBinaryFormat, theChemDrawBinaryFormat)
| OB_STATIC_PLUGIN (ChemDrawFormat, theChemDrawFormat)
| OB_STATIC_PLUGIN (ChemKinFormat, theChemKinFormat)
| OB_STATIC_PLUGIN (CHTFormat, theCHTFormat)
| OB_STATIC_PLUGIN (CIFFormat, theCIFFormat)
| OB_STATIC_PLUGIN (CopyFormat, theCopyFormat)
| OB_STATIC_PLUGIN (CRK2DFormat, theCRK2DFormat)
| OB_STATIC_PLUGIN (CRK3DFormat, theCRK3DFormat)
| OB_STATIC_PLUGIN (CSRFormat, theCSRFormat)
| OB_STATIC_PLUGIN (CSSRFormat, theCSSRFormat)
| OB_STATIC_PLUGIN (DlpolyConfigFormat, theDlpolyConfigFormat)
| OB_STATIC_PLUGIN (DlpolyHISTORYFormat, theDlpolyHISTORYFormat)
| OB_STATIC_PLUGIN (DMolFormat, theDMolFormat)
| OB_STATIC_PLUGIN (FASTAFormat, theFASTAFormat)
| OB_STATIC_PLUGIN (FastSearchFormat, theFastSearchFormat)
| OB_STATIC_PLUGIN (FCHKFormat, theFCHKFormat)
| OB_STATIC_PLUGIN (FEATFormat, theFEATFormat)
| OB_STATIC_PLUGIN (FenskeZmatFormat, theFenskeZmatFormat)
| OB_STATIC_PLUGIN (FHIaimsFormat, theFHIaimsFormat)
| OB_STATIC_PLUGIN (FingerprintFormat, theFingerprintFormat)
| OB_STATIC_PLUGIN (FreeFormFractionalFormat, theFreeFormFractionalFormat)
| OB_STATIC_PLUGIN (GAMESSOutputFormat, theGAMESSOutputFormat)
| OB_STATIC_PLUGIN (GAMESSInputFormat, theGAMESSInputFormat)
| OB_STATIC_PLUGIN (GAMESSUKInputFormat, theGAMESSUKInputFormat)
| OB_STATIC_PLUGIN (GAMESSUKOutputFormat, theGAMESSUKOutputFormat)
| OB_STATIC_PLUGIN (OBGaussianCubeFormat, theGaussianCubeFormat)
| OB_STATIC_PLUGIN (GaussianOutputFormat, theGaussianOutputFormat)
| OB_STATIC_PLUGIN (GaussianInputFormat, theGaussianInputFormat)
| OB_STATIC_PLUGIN (GaussianZMatrixInputFormat, theGaussianZMatrixInputFormat)
| OB_STATIC_PLUGIN (GenBankFormat, theGenBankFormat)
| OB_STATIC_PLUGIN (GhemicalFormat, theGhemicalFormat)
| OB_STATIC_PLUGIN (GROMOS96Format, theGROMOS96Format)
| OB_STATIC_PLUGIN (GULPFormat, theGULPFormat)
| OB_STATIC_PLUGIN (HINFormat, theHINFormat)
| OB_STATIC_PLUGIN (JaguarOutputFormat, theJaguarOutputFormat)
| OB_STATIC_PLUGIN (JaguarInputFormat, theJaguarInputFormat)
| OB_STATIC_PLUGIN (MCDLFormat, theMCDLFormat)
| OB_STATIC_PLUGIN (MOLFormat, theMOLFormat)
| OB_STATIC_PLUGIN (SDFormat, theSDFormat)
| OB_STATIC_PLUGIN (OBT41Format, t41Format__)
| OB_STATIC_PLUGIN (OBMoldenFormat, moldenFormat__)
| OB_STATIC_PLUGIN (mmCIFFormat, themmCIFFormat)
| OB_STATIC_PLUGIN (MacroModFormat, theMacroModFormat)
| OB_STATIC_PLUGIN (MNAFormat, theMNAFormat)
| OB_STATIC_PLUGIN (MOL2Format, theMOL2Format)
| OB_STATIC_PLUGIN (MolproOutputFormat, theMolproOutputFormat)
| OB_STATIC_PLUGIN (MolproInputFormat, theMolproInputFormat)
| OB_STATIC_PLUGIN (MolReportFormat, theMolReportFormat)
| OB_STATIC_PLUGIN (MOPACFormat, theMOPACFormat)
| OB_STATIC_PLUGIN (MOPACCARTFormat, theMOPACCARTFormat)
| OB_STATIC_PLUGIN (MOPACINTFormat, theMOPACINTFormat)
| OB_STATIC_PLUGIN (MPDFormat, theMPDFormat)
| OB_STATIC_PLUGIN (MPQCFormat, theMPQCFormat)
| OB_STATIC_PLUGIN (MPQCInputFormat, theMPQCInputFormat)
| OB_STATIC_PLUGIN (MSIFormat, theMSIFormat)
| OB_STATIC_PLUGIN (OBMSMSFormat, msmsFormat__)
| OB_STATIC_PLUGIN (NulFormat, theNulFormat)
| OB_STATIC_PLUGIN (NWChemOutputFormat, theNWChemOutputFormat)
| OB_STATIC_PLUGIN (NWChemInputFormat, theNWChemInputFormat)
| OB_STATIC_PLUGIN (OBOpenDXCubeFormat, theOpenDXCubeFormat)
| OB_STATIC_PLUGIN (OutputFormat, theOutputFormat)
| OB_STATIC_PLUGIN (PCModelFormat, thePCModelFormat)
| OB_STATIC_PLUGIN (PDBFormat, thePDBFormat)
| OB_STATIC_PLUGIN (PDBQTFormat, thePDBQTFormat)
| OB_STATIC_PLUGIN (PNGFormat, thePNGFormat)
| OB_STATIC_PLUGIN (PovrayFormat, thePovrayFormat)
| OB_STATIC_PLUGIN (PQRFormat, thePQRFormat)
| OB_STATIC_PLUGIN (PQSFormat, thePQSFormat)
| OB_STATIC_PLUGIN (PWscfFormat, thePWscfFormat)
| OB_STATIC_PLUGIN (QChemOutputFormat, theQChemOutputFormat)
| OB_STATIC_PLUGIN (QChemInputFormat, theQChemInputFormat)
| OB_STATIC_PLUGIN (ReportFormat, theReportFormat)
| OB_STATIC_PLUGIN (SmiReactFormat, theSmiReactFormat)
| OB_STATIC_PLUGIN (RXNFormat, theRXNFormat)
| OB_STATIC_PLUGIN (ShelXFormat, theShelXFormat)
| OB_STATIC_PLUGIN (SMIFormat, theSMIFormat)
| OB_STATIC_PLUGIN (CANSMIFormat, theCANSMIFormat)
| OB_STATIC_PLUGIN (FIXFormat, theFIXFormat)
| OB_STATIC_PLUGIN (SVGFormat, theSVGFormat)
| OB_STATIC_PLUGIN (TextFormat, theTextFormat)
| OB_STATIC_PLUGIN (ThermoFormat, theThermoFormat)
| OB_STATIC_PLUGIN (TinkerFormat, theTinkerFormat)
| OB_STATIC_PLUGIN (TitleFormat, theTitleFormat)
| OB_STATIC_PLUGIN (TurbomoleFormat, theTurbomoleFormat)
| OB_STATIC_PLUGIN (UniChemFormat, theUniChemFormat)
| OB_STATIC_PLUGIN (VASPFormat, theVASPFormat)
| OB_STATIC_PLUGIN (ViewMolFormat, theViewMolFormat)
| OB_STATIC_PLUGIN (XEDFormat, theXEDFormat)
| OB_STATIC_PLUGIN (XTCFormat, theXTCFormat)
| OB_STATIC_PLUGIN (XYZFormat, theXYZFormat)
| OB_STATIC_PLUGIN (YOBFormat, theYOBFormat)
| OB_STATIC_PLUGIN (ZINDOFormat, theZINDOFormat)
| OB_STATIC_PLUGIN (ChemDrawXMLFormat, theChemDrawXMLFormat)
| OB_STATIC_PLUGIN (CMLFormat, theCMLFormat)
| OB_STATIC_PLUGIN (CMLReactFormat, theCMLReactFormat)
| OB_STATIC_PLUGIN (PubChemFormat, thePubChemFormat)
| OB_STATIC_PLUGIN (XMLFormat, theXMLFormat)
| OB_STATIC_PLUGIN (InChIFormat, theInChIFormat)
| OB_STATIC_PLUGIN (CanSmiles, theCanSmiles)
| OB_STATIC_PLUGIN (CompoundFilter, dummyCmpFilter)
| OB_STATIC_PLUGIN (MWFilter, theMWFilter)
| OB_STATIC_PLUGIN (SmartsFilter, firstSmartsFilter)
| OB_STATIC_PLUGIN (SmartsFilter, secondSmartsFilter)
| OB_STATIC_PLUGIN (TitleFilter, theTitleFilter)
| OB_STATIC_PLUGIN (FormulaDescriptor, TheFormulaDescriptor)
| OB_STATIC_PLUGIN (InChIFilter, theInChIFilter)
| OB_STATIC_PLUGIN (SmartsDescriptor, theHBD)
| OB_STATIC_PLUGIN (SmartsDescriptor, theHBA1)
| OB_STATIC_PLUGIN (SmartsDescriptor, theHBA2)
| OB_STATIC_PLUGIN (SmartsDescriptor, thenF)
| OB_STATIC_PLUGIN (OBGroupContrib, thelogP)
| OB_STATIC_PLUGIN (OBGroupContrib, theTPSA)
| OB_STATIC_PLUGIN (OBGroupContrib, theMR)
| OB_STATIC_PLUGIN (fingerprint2, thefingerprint2)
| OB_STATIC_PLUGIN (OBForceFieldGaff, theForceFieldGaff)
| OB_STATIC_PLUGIN (OBForceFieldGhemical, theForceFieldGhemical)
| OB_STATIC_PLUGIN (OBForceFieldMMFF94, theForceFieldMMFF94)
| OB_STATIC_PLUGIN (OBForceFieldMMFF94, theForceFieldMMFF94s)
| OB_STATIC_PLUGIN (OBForceFieldUFF, theForceFieldUFF)
| OB_STATIC_PLUGIN (OpAddInIndex, theOpAddInIndex)
| OB_STATIC_PLUGIN (OpAddPolarH, theOpAddPolarH)
| OB_STATIC_PLUGIN (OpCanonical, theOpCanonical)
| OB_STATIC_PLUGIN (OpConformer, theOpConformer)
| OB_STATIC_PLUGIN (OpFillUC, theOpFillUC)
| OB_STATIC_PLUGIN (OpEnergy, theOpEnergy)
| OB_STATIC_PLUGIN (OpMinimize, theOpMinimize)
| OB_STATIC_PLUGIN (OpGen2D, theOpGen2D)
| OB_STATIC_PLUGIN (OpGen3D, theOpGen3D)
| OB_STATIC_PLUGIN (OpNewS, theOpNewS)
| OB_STATIC_PLUGIN (OpPartialCharge, theOpPartialCharge)
| OB_STATIC_PLUGIN (OpReadConformers, theOpReadConformers)
| OB_STATIC_PLUGIN (OpSort, theOpSort)
| OB_STATIC_PLUGIN (OpUnique, theOpUnique)
| OB_STATIC_PLUGIN (OpExtraOut, theOpExtraOut)
| OB_STATIC_PLUGIN (GasteigerCharges, theGasteigerCharges)
| OB_STATIC_PLUGIN (MMFF94Charges, theMMFF94Charges)
| OB_STATIC_PLUGIN (QEqCharges, theQEqCharges)
| OB_STATIC_PLUGIN (QTPIECharges, theQTPIECharges)
std::vector< std::string > | EnableStaticPlugins ()
OBQuery * | CompileMoleculeQuery (OBMol *mol, const OBBitVec &mask=OBBitVec())
OBQuery * | CompileSmilesQuery (const std::string &smiles, const OBBitVec &mask=OBBitVec())
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)
bool | tokenize (std::vector< std::string > &, const char *buf, const char *delimstr=" \t\n\r")
bool | tokenize (std::vector< std::string > &, std::string &, const char *delimstr=" \t\n\r", int limit=-1)
std::string & | Trim (std::string &txt)
template<typename T >
std::string | toString (T val)
std::istream & | ignore (std::istream &ifs, const std::string &txt)
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 | Point2PlaneSigned (vector3 a, vector3 b, vector3 c, 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)
double | Point2Line (const vector3 &a, const vector3 &b, const vector3 &c)
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)
vector3 | GetCorrectedBondVector (OBAtom *atom1, OBAtom *atom2, int bondOrder=1)
bool | CompareBondPairSecond (const std::pair< OBBond *, unsigned int > &a, const std::pair< OBBond *, unsigned int > &b)
void | addNbrs (OBBitVec &fragment, OBAtom *atom, const OBBitVec &mask, const std::vector< OBBond * > &metalloceneBonds)
OBBitVec | getFragment (OBAtom *atom, const OBBitVec &mask, const std::vector< OBBond * > &metalloceneBonds=std::vector< OBBond * >())
OBBitVec | getFragment (OBAtom *atom, OBAtom *skip, const OBBitVec &mask)
bool | isFerroceneBond (OBBond *bond)
void | findMetalloceneBonds (std::vector< OBBond * > &bonds, OBMol *mol, const std::vector< unsigned int > &symmetry_classes)
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)
vector3 | transformedFractionalCoordinate (vector3 originalCoordinate)
bool | CompareUnsigned (const unsigned int &a, const unsigned int &b)
bool | ComparePairFirst (const std::pair< OBAtom *, unsigned int > &a, const std::pair< OBAtom *, unsigned int > &b)
bool | ComparePairSecond (const std::pair< OBAtom *, unsigned int > &a, const std::pair< OBAtom *, unsigned int > &b)
ostream & | operator<< (ostream &os, const OBFloatGrid &fg)
istream & | operator>> (istream &is, OBFloatGrid &fg)
template<typename T >
void | print_vector (const std::string &label, const std::vector< T > &v)
OBQuery * | CompileAutomorphismQuery (OBMol *mol, const OBBitVec &mask, const std::vector< unsigned int > &symClasses)
bool | FindAutomorphisms (OBMol *mol, Automorphisms &maps, const OBBitVec &mask, std::size_t maxMemory)
bool | FindAutomorphisms (OBMol *mol, Automorphisms &maps, const std::vector< unsigned int > &symClasses, const OBBitVec &mask, std::size_t maxMemory)
int | expand_cycle (OBMol *mol, OBAtom *atom, OBBitVec &avisit, OBBitVec &cvisit, const OBBitVec &potAromBonds, int rootIdx, Timeout &timeout, int prevAtomIdx, int depth)
bool | expandKekulize (OBMol *mol, int bond_idx, std::vector< int > &atomState, std::vector< int > &bondState, Timeout &timeout)
bool | expand_kekulize_lssr (OBMol *mol, std::vector< int > &atomState, std::vector< int > &bondState, std::vector< OBRing * > &lssr, std::vector< bool > &lssrAssigned, std::vector< OBBond * > &bondsThisRing)
int | count_assigned_bonds (std::vector< OBBond * > &bondsThisRing, std::vector< int > &bondState)
bool | isPotentialAromaticAtom (OBAtom *atom)
void | potentialAromaticBonds (OBMol *mol, OBBitVec &bonds)
void | get_bonds_of_ring (OBMol *mol, OBRing *ring, std::vector< OBBond * > &ring_bonds)
bool | has_leftover_electrons (OBMol *mol, std::vector< int > &atomState)
bool | has_leftover_electrons (OBMol *mol, std::vector< int > &atomState, std::vector< int > &bondState)
string | intToStr (int k)
double | xDistPoint (double x1, double y1, double x2, double y2, double x0, double y0)
bool | overlapped (double x1A, double y1A, double x2A, double y2A, double x1B, double y1B, double x2B, double y2B, double delta)
bool | compareAtoms (int a1, int a2, const std::vector< std::vector< int > * > aeqList)
bool | incrementValues (std::vector< int > &currentValues, const std::vector< int > maxValues)
void | deleteIntElement (std::vector< int > *source, int index)
static int | findAlternateSinglets (const std::vector< int >iA1, const std::vector< int >iA2, const std::vector< int > nH, const std::vector< int > hydrogenValency, std::vector< int > &bondOrder, int nAtoms, int nBonds)
static void | makeAssignment (const std::vector< int > iA1, const std::vector< int > iA2, const std::vector< int > nH, const std::vector< int > hydrogenValency, const std::vector< int > bondAssignment, const std::vector< int > specialFlag, std::vector< int > &bondOrder, int nAtoms, int nBonds, int &nAss)
static bool | analyzeOK (const std::vector< int > iA1, const std::vector< int > iA2, const std::vector< int > nH, const std::vector< int > hydrogenValency, const std::vector< int > maxValency, const std::vector< int > bondOrder, const std::vector< int > atomCheckFlag, int nAtoms, int nBonds, int &nGtMax, int &nNEH, int &nOddEven, bool testExceedHydrogen, bool oddEvenCheck)
static bool | incrementAssignment (std::vector< int > &bondAssignment, int nAss)
static int | determineBondsOrder (const std::vector< int > iA1, const std::vector< int > iA2, const std::vector< int > nH, const std::vector< int > maxValency, std::vector< int > &bondOrder, std::vector< int > &hydrogenValency, int nAtoms, int nBonds, bool oddEvenViolate)
int | alternate (OBMol *pmol, const std::vector< int > nH, std::vector< int > &bondOrders)
bool | ptInRect (const Rect r, const Point p)
int | compareStringsNumbers (string s1, string s2)
std::string | getAtomSymbol (TSimpleMolecule &sm, int atAtom, int atEx, int priority, string ndData)
std::string | getAtomSymbol (TSimpleMolecule &sm, int atAtom)
int | indexOf (const string instring, const string substring, int fromPos=0)
std::string | removeZeroeth (std::string instring)
int | analizeParity (string data)
int | analizeParityBond (string data)
std::string | changeParity (std::string data)
std::string | changeParityBond (std::string data)
int | sproduct (TSimpleMolecule &sm, int br, int i1, int i2)
bool | bondEquivalent (int bn1, int bn2, const std::vector< int > eqList, TSimpleMolecule &sm)
std::string | addZeroeth (std::string instring, std::string stringAdd)
void | setUpDownBonds (int atomNo, int parity, TSimpleMolecule &sm, std::vector< int > &iA1, std::vector< int > &iA2, std::vector< int > &stereoBonds)
bool | restoreDoubleBonds (TEditedMolecule &sm, bool putEither)
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])
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 void | MarkGrowBonds (Pattern *pat)
static int | GetChiralFlag (AtomExpr *expr)
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 | 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 &)
std::vector< unsigned int > | atomRingToBondRing (OBMol *mol, const std::vector< int > &atoms)
void | visitRing (OBMol *mol, OBRing *ring, std::vector< OBRing * > &rlist, std::vector< OBRing * > &rignored)
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)
std::string | RemoveWhiteSpaceUnderscore (const string &in)
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)
int | GetLabelAlignment (OBAtom *atom)
unsigned int | GetAtomSymClass (OBAtom *atom)
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 *)
High level functions
void | PerceiveStereo (OBMol *mol, bool force=false)
void | StereoFrom2D (OBMol *mol, std::map< OBBond *, enum OBStereo::BondDirection > *updown=NULL, bool force=false)
void | StereoFrom3D (OBMol *mol, bool force=false)
void | StereoFrom0D (OBMol *mol)
Low level functions
std::vector < OBTetrahedralStereo * > | TetrahedralFrom3D (OBMol *mol, const OBStereoUnitSet &stereoUnits, bool addToMol=true)
std::vector < OBTetrahedralStereo * > | TetrahedralFrom2D (OBMol *mol, const OBStereoUnitSet &stereoUnits, bool addToMol=true)
std::vector < OBTetrahedralStereo * > | TetrahedralFrom0D (OBMol *mol, const OBStereoUnitSet &stereoUnits, bool addToMol=true)
std::vector< OBCisTransStereo * > | CisTransFrom3D (OBMol *mol, const OBStereoUnitSet &stereoUnits, bool addToMol=true)
std::vector< OBCisTransStereo * > | CisTransFrom2D (OBMol *mol, const OBStereoUnitSet &stereoUnits, const std::map< OBBond *, enum OBStereo::BondDirection > *updown=NULL, bool addToMol=true)
bool | TetStereoToWedgeHash (OBMol &mol, std::map< OBBond *, enum OBStereo::BondDirection > &updown, std::map< OBBond *, OBStereo::Ref > &from)
std::set< OBBond * > | GetUnspecifiedCisTrans (OBMol &mol)
void | StereoRefToImplicit (OBMol &mol, OBStereo::Ref atomId)
std::vector< OBCisTransStereo * > | CisTransFrom0D (OBMol *mol, const OBStereoUnitSet &stereoUnits, bool addToMol=true)
Stereogenic unit identification
OBStereoUnitSet | FindStereogenicUnits (OBMol *mol, const std::vector< unsigned int > &symClasses)
OBStereoUnitSet | FindStereogenicUnits (OBMol *mol, const std::vector< unsigned int > &symClasses, const Automorphisms &automorphisms)
## Variables
const unsigned int | AliasDataType = 0x7883
const unsigned | RateData = 55555
const unsigned | ThermoData = 55556
OBLocale | obLocale
static const int | MAXBONDS = 300
static const int | MAXFRAGS = 200
static const int | MAXCHARS = 1000
static const int | MAX_DEPTH = 10
static const int | NELEMMAX = 120
OBElementTable | etab
OBTypeTable | ttab
OBIsotopeTable | isotab
OBAromaticTyper | aromtyper
OBAtomTyper | atomtyper
OBChainsParser | chainsparser
OBMessageHandler | obErrorLog
OBResidueData | resdat
static const unsigned long | NoId = detail::max_value<unsigned long>::result
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
static const char * | red = "\033[1;31m"
static const char * | green = "\033[1;32m"
static const char * | yellow = "\033[1;33m"
static const char * | blue = "\033[1;34m"
static const char * | normal = "\033[0m"
const int | hVal [NELEMMCDL]
const int | maxVal [NELEMMCDL]
const int | chargeVal [NELEMMCDL]
const string | aSymb [NELEMMCDL]
const int | exactAtom [NEXACTATOMS] = {6,14,5,50,82,8,16,34,52,7,15,33,51,9,17,35,53,32,13,26,80}
const int | alkaly [NALKALYATOMS] = {3,11,19,37,55}
const int | alkalyEarth [NALKALYEARTHATOMS] = {4,12,20,38,56}
const int | trivalent [NTRIVALENTATOMS] = {21,31,39,49,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,81,89,90,91,92,93,94,95,96,97,98,99}
const int | titan [NTITANATOMS] = {22,40,72}
const int | vanadium [NVANADIUMATOMS] = {23,41,73}
const int | cromium [NCHROMIUMATOMS] = {24,42,74}
const int | manganeze [NMANGANESEATOMS] = {25,43,75}
const int | likeFe [NLIKEFEATOMS] = {27,28}
const int | platinum [NPLATINUMATOMS] = {44,45,46,76,77,78}
const int | copper [NCOPPERATOMS] = {29,47,79}
const int | zink [NZINKATOMS] = {30,48}
const int | possibleAromatic [NAROMMAX] = {7,8,15,16,33,34,51,52,HETERO_ATOM}
const int | metals [NMETALS]
const int | lightMetals [NLIGHT_METALS]
const int | heavyMetals [NHEAVY_METALS]
const int | halogens [NHALOGENS] = {9,17,35,53,85}
const int | hetero [NHETERO] = {7,8,14,15,16,33,34,51,52,84}
const string | strData [NDATABASE_MOLECULES]
const int | bondValence [NBONDTYPES] = {1,2,3,1,1,0,0,0,1,1,1}
const string | fsastart = "{SA:"
const string | fsbstart = "{SB:"
bool | SwabInt = (STPTR[0]!=0)
static double | Roots [4]
static int | N_parsed_bonds
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 std::vector<int> RotorKey

typedef std::vector<RotorKey> RotorKeys

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.

typedef struct OpenBabel::adjustedlist adjustedlist

typedef adjustedlist neigbourlist[NATOMSMAX]

## 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.
  local | Not for routine external use (e.g. in sdf or cml properties)

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 |

anonymous enum

Enumerator:

  TopLeft |
  TopCenter |
  TopRight |
  CenterLeft |
  Center |
  CenterRight |
  BottomLeft |
  BottomCenter |
  BottomRight |

## Function Documentation

std::string OBReleaseVersion | ( | ) |

Returns:
  the version of the Open Babel library for feature-detection (e.g. "2.3.1")

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 * | mol,
|  | const std::vector< unsigned int > & | symmetry_classes,
|  | std::vector< unsigned int > & | canonical_labels,
|  | const OBBitVec & | mask = `OBBitVec()`,
|  | int | maxSeconds = `5`,
|  | bool | onlyOne = `false`
| ) |  |

Calculate the canonical labels for the molecule. Stereochemistry is included in the algorithm and the canonical labels. The result will be stored in `canonical_labels`.

Parameters:

  mol | The molecule.
  symmetry_classes | The symmetry_classes for the molecule. These can be obtained using the OBGraphSym class.
  canonical_labels | Reference to the object to store the results in.
  mask | The fragment to label. When the bit for an atom is set, it is included in the fragment. If no bits are set, all atoms will be included. Atoms are indexed from 1 (i.e. OBAtom::GetIdx()).
  maxSeconds | Timeout in seconds.
  onlyOne | If true, the first found labels are returned. These are canonical labels without considering stereochemistry and other attributes not included in the symmetry classes.

Returns:
  The canonical labels for the molecule in `canonical_labels`.

See also:
  Canonical Coding Algorithm

Since:
  2.3

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

Calculate the Graph Potentials of a molecule.

Deprecated:

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

Deprecated:

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

Deprecated:

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 = `true`
| ) |  |

Deprecated:
  Use new Stereochemistry classes.

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.

Deprecated:
  Use new Stereochemistry classes.

Referenced by CalcSignedVolume().

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

Deprecated:
  Use new Stereochemistry classes.

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

Deprecated:
  Use new Stereochemistry classes.

Referenced by CorrectChirality().

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

Deprecated:
  Use new Stereochemistry classes.

static bool OpenBabel::DoComparison | ( | char | ch1,
|  | char | ch2,
|  | T & | val,
|  | T & | filterval
| ) |  | `[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
| ) |  |

int hydrogenValency | ( | int | na ) |

Referenced by alternate().

int maxValency | ( | int | na ) |

Referenced by alternate().

int OpenBabel::alternate | ( | OBMol * | pmol,
|  | const int | nH[],
|  | int | bondOrders[]
| ) |  |

int alternate | ( | const std::vector< int > | aPosition,
|  | const std::vector< int > | aCharge,
|  | const std::vector< int > | aRad,
|  | const std::vector< int > | nHydr,
|  | const std::vector< int > | iA1,
|  | const std::vector< int > | iA2,
|  | std::vector< int > & | bondOrders,
|  | int | nAtoms,
|  | int | nBonds
| ) |  |

void generateDiagram | ( | OBMol * | pmol ) |

Since:
  version 2.3

void generateDiagram | ( | const std::vector< int > | iA1,
|  | const std::vector< int > | iA2,
|  | std::vector< double > & | rx,
|  | std::vector< double > & | ry,
|  | int | nAtoms,
|  | int | nBonds
| ) |  |

void generateDiagram | ( | OBMol * | pmol,
|  | std::ostream & | ofs
| ) |  |

bool fragmentSearch | ( | OBMol * | query,
|  | OBMol * | structure
| ) |  |

bool fragmentSearch | ( | const std::vector< int > | aPositionQuery,
|  | const std::vector< int > | iA1Query,
|  | const std::vector< int > | iA2Query,
|  | const std::vector< int > | bondTypesQuery,
|  | const std::vector< int > | aPositionStructure,
|  | const std::vector< int > | iA1Structure,
|  | const std::vector< int > | iA2Structure,
|  | const std::vector< int > | bondTypesStructure,
|  | int | nAtomsQuery,
|  | int | nBondsQuery,
|  | int | nAtomsStructure,
|  | int | nBondsStructure
| ) |  |

void equivalenceList | ( | OBMol * | pmol,
|  | std::vector< int > & | eqList
| ) |  |

Equivalence list generation.

void equivalenceList | ( | const std::vector< int > | aPosition,
|  | const std::vector< int > | aCharge,
|  | const std::vector< int > | aRad,
|  | const std::vector< int > | iA1,
|  | const std::vector< int > | iA2,
|  | const std::vector< int > | bondTypes,
|  | std::vector< int > & | eqList,
|  | int | nAtoms,
|  | int | nBonds
| ) |  |

void addFragment | ( | OBMol * | molecule,
|  | OBMol * | fragment,
|  | int | molAN,
|  | int | fragAN,
|  | int | molBN,
|  | int | fragBN,
|  | bool | isAddition
| ) |  |

void createStereoLists | ( | OBMol * | pmol,
|  | std::vector< int > & | bondStereoList,
|  | std::vector< int > & | atomStereoList,
|  | std::vector< int > & | eqList
| ) |  |

std::string getAtomMCDL | ( | OBMol * | pmol,
|  | int | ntatoms,
|  | const std::vector< int > | ix,
|  | const std::vector< int > | aNumber,
|  | const std::vector< int > | atomStereoList,
|  | const std::vector< int > | eqList
| ) |  |

std::string getBondMCDL | ( | OBMol * | pmol,
|  | int | nbStore,
|  | int | ntatoms,
|  | const std::vector< int > | ix,
|  | const std::vector< int > | aNumber,
|  | int | bonds[MAXBONDS][4],
|  | const std::vector< int > | bondStereoList,
|  | const std::vector< int > | eqList
| ) |  |

void implementAtomStereo | ( | std::vector< int > & | iA1,
|  | std::vector< int > & | iA2,
|  | std::vector< int > & | stereoBonds,
|  | const std::vector< double > | rx,
|  | const std::vector< double > | ry,
|  | int | acount,
|  | int | bcount,
|  | std::string | astereo
| ) |  |

void implementBondStereo | ( | const std::vector< int > | iA1,
|  | const std::vector< int > | iA2,
|  | std::vector< double > & | rx,
|  | std::vector< double > & | ry,
|  | int | acount,
|  | int | bcount,
|  | std::string | bstereo
| ) |  |

int groupRedraw | ( | OBMol * | pmol,
|  | int | bondN,
|  | int | atomN,
|  | bool | atomNInGroup
| ) |  |

int canonizeMCDL | ( | const std::string | atomBlock,
|  | std::vector< std::string > & | structureList
| ) |  |

bool parseFormula | ( | const std::string | formulaString,
|  | std::vector< int > & | enumber,
|  | int & | valency
| ) |  |

void prepareTest | ( | OBMol * | pmol,
|  | std::ostream & | ofs
| ) |  |

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],
|  | unsigned |
| ) |  |

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(), OBConformerSearch::Search(), 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(), OBBond::SetLength(), 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(), 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 patty::assign_rules(), OBDescriptor::DeleteProperties(), DLHandler::findFiles(), 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 ) |

Remove leading and trailing whitespace from a string (docs in tokenst.cpp)

Removes white space from front and back of string.

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

std::string OpenBabel::toString | ( | T | val ) |

std::istream & ignore | ( | std::istream & | ifs,
|  | const std::string & | txt
| ) |  |

Read and discard all characters from input stream up to, and including, a string.

Read and discard all characters from input stream upto the occurence of a string

Parameters:

  ifs | The input file stream.
  txt | (which is also discarded), or the end of the stream.

Returns:
  the stream.

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(), OBBuilder::GetNewBondVector(), Point2PlaneSigned(), 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(), InternalToCartesian(), Point2Line(), Point2PlaneAngle(), Point2PlaneSigned(), 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(), OBUnitCell::GetAlpha(), OBAtom::GetAngle(), OBUnitCell::GetBeta(), OBUnitCell::GetGamma(), 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(), CartesianToInternal(), OBMol::GetTorsion(), and OBBond::IsDoubleBondGeometry().

double Point2PlaneSigned | ( | vector3 | a,
|  | vector3 | b,
|  | vector3 | c,
|  | vector3 | d
| ) |  |

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

Referenced by Point2Plane().

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.

double Point2Line | ( | const vector3 & | a,
|  | const vector3 & | b,
|  | const vector3 & | c
| ) |  |

Calculate the distance of a point a to a line determined by b and c.

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

vector3 OpenBabel::GetCorrectedBondVector | ( | OBAtom * | atom1,
|  | OBAtom * | atom2,
|  | int | bondOrder = `1`
| ) |  |

Referenced by OBBuilder::Build(), and OBBuilder::Connect().

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

void OpenBabel::addNbrs | ( | OBBitVec & | fragment,
|  | OBAtom * | atom,
|  | const OBBitVec & | mask,
|  | const std::vector< OBBond * > & | metalloceneBonds
| ) |  |

Helper function for getFragment below.

Referenced by getFragment().

OBBitVec getFragment | ( | OBAtom * | atom,
|  | const OBBitVec & | mask,
|  | const std::vector< OBBond * > & | metalloceneBonds = `std::vector< OBBond * >()`
| ) |  |

Create an OBBitVec objects with bets set for the fragment consisting of all atoms for which there is a path to atom without going through skip. These fragment bitvecs are indexed by atom idx (i.e. OBAtom::GetIdx()).

Referenced by FindAutomorphisms().

OBBitVec OpenBabel::getFragment | ( | OBAtom * | atom,
|  | OBAtom * | skip,
|  | const OBBitVec & | mask
| ) |  |

bool isFerroceneBond | ( | OBBond * | bond ) |

Referenced by CompileAutomorphismQuery().

void OpenBabel::findMetalloceneBonds | ( | std::vector< OBBond * > & | bonds,
|  | OBMol * | mol,
|  | const std::vector< unsigned int > & | symmetry_classes
| ) |  |

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

vector3 OpenBabel::transformedFractionalCoordinate | ( | vector3 | originalCoordinate ) |

Referenced by OBUnitCell::FillUnitCell().

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

Functions for use by the sort() method of a vector.

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

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

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

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

void OpenBabel::print_vector | ( | const std::string & | label,
|  | const std::vector< T > & | v
| ) |  |

OBQuery* OpenBabel::CompileAutomorphismQuery | ( | OBMol * | mol,
|  | const OBBitVec & | mask,
|  | const std::vector< unsigned int > & | symClasses
| ) |  |

Referenced by FindAutomorphisms().

bool OpenBabel::FindAutomorphisms | ( | OBMol * | mol,
|  | Automorphisms & | maps,
|  | const OBBitVec & | mask,
|  | std::size_t | maxMemory
| ) |  |

bool OpenBabel::FindAutomorphisms | ( | OBMol * | mol,
|  | Automorphisms & | maps,
|  | const std::vector< unsigned int > & | symClasses,
|  | const OBBitVec & | mask,
|  | std::size_t | maxMemory
| ) |  |

int expand_cycle | ( | OBMol * | mol,
|  | OBAtom * | atom,
|  | OBBitVec & | avisit,
|  | OBBitVec & | cvisit,
|  | const OBBitVec & | potAromBonds,
|  | int | rootIdx,
|  | Timeout & | timeout,
|  | int | prevAtomIdx = `-1`,
|  | int | depth = `MAX_DEPTH`
| ) |  |

Recursively find the aromatic atoms with an aromatic bond to the current atom.

Referenced by OBMol::NewPerceiveKekuleBonds().

bool expandKekulize | ( | OBMol * | mol,
|  | int | bond_idx,
|  | std::vector< int > & | atomState,
|  | std::vector< int > & | bondState,
|  | Timeout & | timeout
| ) |  |

Referenced by OBMol::expand_kekulize(), and OBMol::start_kekulize().

bool expand_kekulize_lssr | ( | OBMol * | mol,
|  | std::vector< int > & | atomState,
|  | std::vector< int > & | bondState,
|  | std::vector< OBRing * > & | lssr,
|  | std::vector< bool > & | lssrAssigned,
|  | std::vector< OBBond * > & | bondsThisRing
| ) |  |

NEW ANALYSIS methods: rely on LSSR methods to only target one ring. Works much faster on fullerens, graphene, etc.

Recursive function to find a sensible kekule assignment of single and double bonds for an aromatic ring system.

Referenced by OBMol::start_kekulize().

int OpenBabel::count_assigned_bonds | ( | std::vector< OBBond * > & | bondsThisRing,
|  | std::vector< int > & | bondState
| ) |  |

Referenced by expand_kekulize_lssr().

bool OpenBabel::isPotentialAromaticAtom | ( | OBAtom * | atom ) |

Referenced by OBMol::NewPerceiveKekuleBonds(), and potentialAromaticBonds().

void OpenBabel::potentialAromaticBonds | ( | OBMol * | mol,
|  | OBBitVec & | bonds
| ) |  |

Referenced by OBMol::NewPerceiveKekuleBonds().

void OpenBabel::get_bonds_of_ring | ( | OBMol * | mol,
|  | OBRing * | ring,
|  | std::vector< OBBond * > & | ring_bonds
| ) |  |

Returns a vector of the bonds in a ring, in circular order around the ring,

Referenced by expand_kekulize_lssr().

bool OpenBabel::has_leftover_electrons | ( | OBMol * | mol,
|  | std::vector< int > & | atomState
| ) |  |

Referenced by expand_kekulize_lssr(), expandKekulize(), and OBMol::has_no_leftover_electrons().

bool OpenBabel::has_leftover_electrons | ( | OBMol * | mol,
|  | std::vector< int > & | atomState,
|  | std::vector< int > & | bondState
| ) |  |

string OpenBabel::intToStr | ( | int | k ) |

Referenced by getAtomMCDL(), and getBondMCDL().

double OpenBabel::xDistPoint | ( | double | x1,
|  | double | y1,
|  | double | x2,
|  | double | y2,
|  | double | x0,
|  | double | y0
| ) |  |

Referenced by overlapped().

bool OpenBabel::overlapped | ( | double | x1A,
|  | double | y1A,
|  | double | x2A,
|  | double | y2A,
|  | double | x1B,
|  | double | y1B,
|  | double | x2B,
|  | double | y2B,
|  | double | delta
| ) |  |

bool OpenBabel::compareAtoms | ( | int | a1,
|  | int | a2,
|  | const std::vector< std::vector< int > * > | aeqList
| ) |  |

bool OpenBabel::incrementValues | ( | std::vector< int > & | currentValues,
|  | const std::vector< int > | maxValues
| ) |  |

void OpenBabel::deleteIntElement | ( | std::vector< int > * | source,
|  | int | index
| ) |  |

static int OpenBabel::findAlternateSinglets | ( | const std::vector< int > | iA1,
|  | const std::vector< int > | iA2,
|  | const std::vector< int > | nH,
|  | const std::vector< int > | hydrogenValency,
|  | std::vector< int > & | bondOrder,
|  | int | nAtoms,
|  | int | nBonds
| ) |  | `[static]`

Referenced by determineBondsOrder(), and makeAssignment().

static void OpenBabel::makeAssignment | ( | const std::vector< int > | iA1,
|  | const std::vector< int > | iA2,
|  | const std::vector< int > | nH,
|  | const std::vector< int > | hydrogenValency,
|  | const std::vector< int > | bondAssignment,
|  | const std::vector< int > | specialFlag,
|  | std::vector< int > & | bondOrder,
|  | int | nAtoms,
|  | int | nBonds,
|  | int & | nAss
| ) |  | `[static]`

Referenced by determineBondsOrder().

static bool OpenBabel::analyzeOK | ( | const std::vector< int > | iA1,
|  | const std::vector< int > | iA2,
|  | const std::vector< int > | nH,
|  | const std::vector< int > | hydrogenValency,
|  | const std::vector< int > | maxValency,
|  | const std::vector< int > | bondOrder,
|  | const std::vector< int > | atomCheckFlag,
|  | int | nAtoms,
|  | int | nBonds,
|  | int & | nGtMax,
|  | int & | nNEH,
|  | int & | nOddEven,
|  | bool | testExceedHydrogen,
|  | bool | oddEvenCheck
| ) |  | `[static]`

Referenced by determineBondsOrder().

static bool OpenBabel::incrementAssignment | ( | std::vector< int > & | bondAssignment,
|  | int | nAss
| ) |  | `[static]`

Referenced by determineBondsOrder().

static int OpenBabel::determineBondsOrder | ( | const std::vector< int > | iA1,
|  | const std::vector< int > | iA2,
|  | const std::vector< int > | nH,
|  | const std::vector< int > | maxValency,
|  | std::vector< int > & | bondOrder,
|  | std::vector< int > & | hydrogenValency,
|  | int | nAtoms,
|  | int | nBonds,
|  | bool | oddEvenViolate
| ) |  | `[static]`

Referenced by alternate().

int OpenBabel::alternate | ( | OBMol * | pmol,
|  | const std::vector< int > | nH,
|  | std::vector< int > & | bondOrders
| ) |  |

bool OpenBabel::ptInRect | ( | const Rect | r,
|  | const Point | p
| ) |  |

int OpenBabel::compareStringsNumbers | ( | string | s1,
|  | string | s2
| ) |  |

Referenced by analizeParity(), analizeParityBond(), getAtomMCDL(), getBondMCDL(), implementAtomStereo(), and implementBondStereo().

std::string OpenBabel::getAtomSymbol | ( | TSimpleMolecule & | sm,
|  | int | atAtom,
|  | int | atEx,
|  | int | priority,
|  | string | ndData
| ) |  |

nepravil'no

Referenced by getAtomMCDL(), and getBondMCDL().

std::string OpenBabel::getAtomSymbol | ( | TSimpleMolecule & | sm,
|  | int | atAtom
| ) |  |

int OpenBabel::indexOf | ( | const string | instring,
|  | const string | substring,
|  | int | fromPos = `0`
| ) |  |

Referenced by addZeroeth(), getAtomMCDL(), getBondMCDL(), implementAtomStereo(), implementBondStereo(), parseFormula(), and removeZeroeth().

std::string OpenBabel::removeZeroeth | ( | std::string | instring ) |

Referenced by getAtomMCDL(), and getBondMCDL().

int OpenBabel::analizeParity | ( | string | data ) |

Referenced by getAtomMCDL().

int OpenBabel::analizeParityBond | ( | string | data ) |

Referenced by getBondMCDL().

std::string OpenBabel::changeParity | ( | std::string | data ) |

Referenced by getAtomMCDL().

std::string OpenBabel::changeParityBond | ( | std::string | data ) |

Referenced by getBondMCDL().

int OpenBabel::sproduct | ( | TSimpleMolecule & | sm,
|  | int | br,
|  | int | i1,
|  | int | i2
| ) |  |

Referenced by getBondMCDL(), and restoreDoubleBonds().

bool OpenBabel::bondEquivalent | ( | int | bn1,
|  | int | bn2,
|  | const std::vector< int > | eqList,
|  | TSimpleMolecule & | sm
| ) |  |

Referenced by getBondMCDL().

std::string OpenBabel::addZeroeth | ( | std::string | instring,
|  | std::string | stringAdd
| ) |  |

Referenced by implementAtomStereo(), and implementBondStereo().

void OpenBabel::setUpDownBonds | ( | int | atomNo,
|  | int | parity,
|  | TSimpleMolecule & | sm,
|  | std::vector< int > & | iA1,
|  | std::vector< int > & | iA2,
|  | std::vector< int > & | stereoBonds
| ) |  |

!! By unknown reason inversion of configuration took place.

Referenced by implementAtomStereo().

bool OpenBabel::restoreDoubleBonds | ( | TEditedMolecule & | sm,
|  | bool | putEither
| ) |  |

Referenced by implementBondStereo().

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

Referenced by OBMol::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().

static int OpenBabel::GetVectorBinding | ( | ) | `[static]`

Referenced by OBSmartsPattern::SMARTSParser().

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

Referenced by OBMol::AddAtom(), CopyPattern(), OBMol::NewAtom(), and OBSmartsPattern::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(), OBSmartsPattern::ParseComplexAtomPrimitive(), OBSmartsPattern::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 OBSmartsPattern::ParseAtomExpr().

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

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

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

Referenced by NotAtomExpr(), and OBSmartsPattern::ParseAtomExpr().

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

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

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

Referenced by OBSmartsPattern::ParseComplexAtomPrimitive().

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

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

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

Referenced by OBSmartsPattern::ParseComplexAtomPrimitive(), and OBSmartsPattern::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]`

Check if two BondExpr objects are the same. This is used for ring closures to identify invalid SMARTS like:

C-1CCCCC#1 C=1CCCCC:1

However, the SMARTS below are valid and the bond expression next to the the second closure digit is used.

C1CCCCC#1 C1CCCCC=1

Referenced by OBSmartsPattern::SMARTSParser().

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

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

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

Referenced by GenerateDefaultBond(), and OBSmartsPattern::ParseBondPrimitive().

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

Referenced by OBSmartsPattern::ParseBondExpr().

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

Referenced by GenerateDefaultBond(), and OBSmartsPattern::ParseBondExpr().

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

Referenced by OBSmartsPattern::SMARTSParser().

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

Referenced by CopyPattern(), and OBSmartsPattern::ParseSMARTSPattern().

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

Referenced by OBMol::AddBond(), CopyPattern(), OBMol::NewBond(), and OBSmartsPattern::SMARTSParser().

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

Referenced by OBSmartsPattern::ParseSMARTSPart().

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

Referenced by OBSmartsPattern::ParseSMARTSPart().

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::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::FindLSSR(), and OBMol::FindSSSR().

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

Referenced by OBRingSearch::AddRingFromClosure().

std::vector<unsigned int> OpenBabel::atomRingToBondRing | ( | OBMol * | mol,
|  | const std::vector< int > & | atoms
| ) |  |

Referenced by visitRing().

void OpenBabel::visitRing | ( | OBMol * | mol,
|  | OBRing * | ring,
|  | std::vector< OBRing * > & | rlist,
|  | std::vector< OBRing * > & | rignored
| ) |  |

This function finds the LSSR containing all relevant cycles. A cycle is relevant if it belongs to at least one minimum cycle basis. Another description is more useful though:

A cycle (C) is relevant if:

- no smaller cycles C_i, ..., C_k exist such that C = C_1 + ... + C_k
- both bonds & atoms are checked

This is based on lemma 1 from:

P. Vismara, Union of all the minimum cycle bases of a graph, The electronic journal of combinatorics, Vol. 4, 1997 http://www.emis.de/journals/EJC/Volume_4/PostScriptfiles/v4i1r9.ps

Referenced by OBRingSearch::RemoveRedundant().

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 OBMol::ConnectTheDots().

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.

std::string OpenBabel::RemoveWhiteSpaceUnderscore | ( | const string & | in ) |

Function to remove whitespaces from a string, returning a new string

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

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

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

int OpenBabel::GetLabelAlignment | ( | OBAtom * | atom ) |

Referenced by OBDepict::DrawMolecule().

unsigned int OpenBabel::GetAtomSymClass | ( | OBAtom * | atom ) |

Referenced by OBDepict::AddAtomLabels().

## Variable Documentation

const unsigned int AliasDataType = 0x7883

Referenced by OBDepict::DrawMolecule(), and AliasData::RevertToAliasForm().

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

const int MAXBONDS = 300`[static]`

const int MAXFRAGS = 200`[static]`

const int MAXCHARS = 1000`[static]`

const int MAX_DEPTH = 10`[static]`

const int NELEMMAX = 120`[static]`

OBElementTable etab

Global OBElementTable for element properties.

Referenced by OBMol::AddHydrogens(), OBMol::ConnectTheDots(), OBDepict::DrawMolecule(), AliasData::Expand(), OBAtom::GetAtomicMass(), GetCorrectedBondVector(), 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 OBSmartsMatcher::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(), OBAlign::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(), OBBuilder::CorrectStereoAtoms(), OBMoleculeFormat::DeferMolOutput(), OBMol::DeleteHydrogens(), OBMol::DeleteNonPolarHydrogens(), OBMol::DoTransformations(), OBMol::EndModify(), AliasData::Expand(), expand_cycle(), expandKekulize(), FatalAllocationError(), FatalMemoryError(), OBDescriptor::FilterCompare(), SpaceGroup::Find(), FastSearch::Find(), OBMol::FindLSSR(), OBMol::FindRingAtomsAndBonds(), OBRotorList::FindRotors(), OBMol::FindSSSR(), OBFingerprint::Fold(), OBBitVec::FromString(), OBConversion::FullConvert(), GenerateByteCodes(), OBAlign::GetAlignment(), OBMol::GetAtom(), OBChiralData::GetAtom4Refs(), OBMol::GetAtomById(), OBElementTable::GetAtomicNum(), GetAtomIDNumber(), OBChiralData::GetAtomRef(), OBMol::GetBond(), OBMol::GetBondById(), OBMol::GetFormula(), OBDescriptor::GetIdentifier(), OBMol::GetResidue(), OBAlign::GetRMSD(), OBAlign::GetRotMatrix(), OBRotorRules::GetRotorIncrements(), OBChiralData::GetSize(), OBMol::GetTotalCharge(), OBMol::GetTotalSpinMultiplicity(), OBDescriptor::GetValues(), OBAtom::HtoMethyl(), OBGlobalDataBase::Init(), InternalToCartesian(), OBBond::IsClosure(), OBMol::Kekulize(), OBBuilder::LoadFragments(), OBMoleculeFormat::MakeCombinedMolecule(), OBMol::NewPerceiveKekuleBonds(), OBConversion::NumInputObjects(), OBConversion::OpenAndSetFormat(), OBConversion::OpenInAndOutFiles(), DLHandler::openLib(), 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(), OBSmartsPattern::SMARTSError(), OBMol::start_kekulize(), OBMol::StripSalts(), obLogBuf::sync(), ThrowError(), OBTetraNonPlanarStereo::ToConfig(), OBMol::ToInertialFrame(), OBMol::Translate(), OBTypeTable::Translate(), patty::type_to_int(), OBAlign::UpdateCoords(), OBMoleculeFormat::WriteChemObjectImpl(), OBConversion::WriteFile(), and FastSearchIndexer::~FastSearchIndexer().

OBResidueData resdat

Global OBResidueData biomolecule residue database.

const unsigned long NoId = detail::max_value<unsigned long>::result`[static]`

Referenced by OBMol::AddAtom(), OBAtom::Clear(), and OBMol::operator+=().

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 CalcSignedVolume(), OBScoreGrid::Center(), center_coords(), OBScoreGrid::CenterMol(), OBDepict::DrawMolecule(), OBChargeModel::GetDipoleMoment(), OBFFConstraint::GetGradient(), GetLabelAlignment(), OBBuilder::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(), and OBBuilder::GetNewBondVector().

const vector3 VY(0.0, 1.0, 0.0)

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

Referenced by InternalToCartesian().

const vector3 VZ(0.0, 0.0, 1.0)

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

Referenced by OBBuilder::GetNewBondVector().

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:

        {
          0,
          1,
          1,
          2,
          1,
          2,
          2,
          3,
          1,
          2,
          2,
          3,
          2,
          3,
          3,
          4
        }

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.
col 1: bitmask
col 2: element number
col 3: neighbour count
col 4-7: 1-4 bitmasks for neighbour atoms (-6 means carbon)

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 OpenBabel::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 OpenBabel::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 char* red = "\033[1;31m"`[static]`

Referenced by OBColor::operator!=(), and OBElementTable::ParseLine().

const char* green = "\033[1;32m"`[static]`

Referenced by OBColor::operator!=(), and OBElementTable::ParseLine().

const char* yellow = "\033[1;33m"`[static]`

const char* blue = "\033[1;34m"`[static]`

Referenced by OBColor::operator!=(), and OBElementTable::ParseLine().

const char* normal = "\033[0m"`[static]`

Referenced by Point2PlaneAngle().

const int hVal[NELEMMCDL]

Initial value:

     {
            0,1,0,0,0,3,4,3,2,1,
            0,0,0,3,4,3,2,1,0,0,
            0,0,0,0,0,0,0,0,0,0,
            0,0,4,3,2,1,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,
            2,3,2,1,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,
            0,0,2,0,2,1,0,1,2,0,
            0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,1,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0}

Referenced by alternate(), hydrogenValency(), and parseFormula().

const int maxVal[NELEMMCDL]

Initial value:

     {
        0,1,0,1,2,4,4,5,3,1,
            0,1,2,4,4,6,6,7,0,1,
            2,3,4,5,6,7,6,4,4,2,
            2,3,4,5,6,7,8,1,2,3,
            4,5,6,7,8,6,6,2,2,3,
            4,5,6,7,8,1,2,3,4,4,
            3,3,3,3,3,4,3,3,3,3,
            3,3,4,5,6,7,8,6,6,3,
            2,3,4,5,6,7,8,1,2,3,
            4,5,6,6,6,6,3,4,3,3,
            3,3,1,1,1,0,0,0,0,0,
            0,8,1,8,5,0,0,0,0,0,0}

Referenced by OBSpectrophore::_luDecompose(), alternate(), and maxValency().

const int chargeVal[NELEMMCDL]

Initial value:

     {
       0,-1,-1,-1,-1,-1,-1, 1, 1, 1,-1,
      -1,-1,-1,-1, 1, 1, 1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1, 1, 1, 1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
       1, 1, 1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1, 1, 1, 1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1}

const string aSymb[NELEMMCDL]

Initial value:

     {"0",
        "H" ,"He","Li","Be","B" ,"C" ,"N" ,"O" ,"F" ,"Ne",
        "Na","Mg","Al","Si","P" ,"S" ,"Cl","Ar","K" ,"Ca",
        "Sc","Ti","V" ,"Cr","Mn","Fe","Co","Ni","Cu","Zn",
        "Ga","Ge","As","Se","Br","Kr","Rb","Sr","Y" ,"Zr",
        "Nb","Mo","Tc","Ru","Rh","Pd","Ag","Cd","In","Sn",
        "Sb","Te","I" ,"Xe","Cs","Ba","La","Ce","Pr","Nd",
        "Pm","Sm","Eu","Gd","Tb","Dy","Ho","Er","Tm","Yb",
        "Lu","Hf","Ta","W" ,"Re","Os","Ir","Pt","Au","Hg",
        "Tl","Pb","Bi","Po","At","Rn","Fr","Ra","Ac","Th",
        "Pa","U" ,"Np","Pu","Am","Cm","Bk","Cf","Es","Fm",
        "Md","No","Lr","D" ,""  ,"G" ,"0" ,"Xx",""  ,""  ,
        "M" ,"X" ,"A" ,"Q" ,""  ,""  ,""  ,""  ,""  ,""}

Referenced by getAtomSymbol(), and parseFormula().

const int exactAtom[NEXACTATOMS] = {6,14,5,50,82,8,16,34,52,7,15,33,51,9,17,35,53,32,13,26,80}

const int alkaly[NALKALYATOMS] = {3,11,19,37,55}

const int alkalyEarth[NALKALYEARTHATOMS] = {4,12,20,38,56}

const int trivalent[NTRIVALENTATOMS] = {21,31,39,49,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,81,89,90,91,92,93,94,95,96,97,98,99}

const int titan[NTITANATOMS] = {22,40,72}

const int vanadium[NVANADIUMATOMS] = {23,41,73}

const int cromium[NCHROMIUMATOMS] = {24,42,74}

const int manganeze[NMANGANESEATOMS] = {25,43,75}

const int likeFe[NLIKEFEATOMS] = {27,28}

const int platinum[NPLATINUMATOMS] = {44,45,46,76,77,78}

const int copper[NCOPPERATOMS] = {29,47,79}

const int zink[NZINKATOMS] = {30,48}

const int possibleAromatic[NAROMMAX] = {7,8,15,16,33,34,51,52,HETERO_ATOM}

const int metals[NMETALS]

Initial value:

     {
      3,4,11,12,13,19,20,21,22,23,24,25,26,27,28,29,
      30,31,37,38,39,40,41,42,43,44,45,46,47,48,49,50,55,56,57,58,59,60,61,62,63,
      64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,87,88,89,90,91,
      92,93,94,95,96,97,98,99,100,101,102,103}

const int lightMetals[NLIGHT_METALS]

Initial value:

     {
      3,4,11,12,13,19,20,21,22,23,24,25,26,27,28,29,30,31,37,38}

const int heavyMetals[NHEAVY_METALS]

Initial value:

     {
        39,40,41,42,43,44,45,46,47,48,49,50,55,56,57,58,59,60,61,62,63,
        64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,87,88,89,90,91,
        92,93,94,95,96,97,98,99,100,101,102,103}

const int halogens[NHALOGENS] = {9,17,35,53,85}

const int hetero[NHETERO] = {7,8,14,15,16,33,34,51,52,84}

const string strData[NDATABASE_MOLECULES]

const int bondValence[NBONDTYPES] = {1,2,3,1,1,0,0,0,1,1,1}

const string fsastart = "{SA:"

Referenced by getAtomMCDL().

const string fsbstart = "{SB:"

Referenced by getBondMCDL().

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

double Roots[4]`[static]`

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

int N_parsed_bonds`[static]`

Referenced by OBSmartsPattern::ParseSMARTSPart(), and OBSmartsPattern::SMARTSParser().

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

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines