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:

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