Loading...
Searching...
No Matches
OpenBabel Namespace Reference

## Namespaces

namespace | OBGenericDataType
namespace | OBElements
namespace | detail
namespace | OBAminoAcidProperty
namespace | OBResidueAtomProperty
namespace | OBResidueIndex
namespace | OBResidueProperty

## Classes

class | AliasData
class | OBAtom
class | OBGenericData
class | OBBase
class | OBBitVec
class | OBBond
class | OBBondTyper
class | OBBuilder
class | OBChainsParser
class | OBChargeModel
class | OBConformerFilter
class | OBConformerFilters
class | OBStericConformerFilter
class | OBConformerScore
class | OBRMSDConformerScore
class | OBEnergyConformerScore
class | OBMinimizingEnergyConformerScore
class | OBMinimizingRMSDConformerScore
class | OBConformerSearch
class | OBGlobalDataBase
class | OBAtomHOF
class | OBAtomicHeatOfFormationTable
class | OBTypeTable
class | OBResidueData
class | OBDescriptor
class | OBFingerprint
struct | FptIndexHeader
struct | FptIndex
class | FastSearch
class | FastSearchIndexer
struct | LineSearchType
class | OBFFParameter
class | OBFFCalculation2
class | OBFFCalculation3
class | OBFFCalculation4
class | OBFFConstraint
class | OBFFConstraints
class | OBForceField
class | OBFormat
class | OBCommentData
class | OBExternalBond
class | OBExternalBondData
class | OBPairData
class | OBPairTemplate
class | OBSetData
class | OBVirtualBond
class | OBRingData
class | OBUnitCell
class | OBConformerData
class | OBSymmetryData
class | OBTorsion
class | OBTorsionData
class | OBAngle
class | OBAngleData
class | OBSerialNums
class | OBVibrationData
class | OBDOSData
class | OBOrbital
class | OBOrbitalData
class | OBElectronicTransitionData
class | OBRotationData
class | OBVectorData
class | OBMatrixData
class | OBFreeGridPoint
class | OBFreeGrid
class | OBPcharge
class | OBGraphSym
class | OBGrid
class | OBFloatGrid
class | OBProxGrid
class | OBScoreGrid
class | OBGridData
class | OBGroupContrib
class | OBInternalCoord
class | OBIsomorphismMapper
class | OBRateData
class | OBNasaThermoData
class | FilteringInputStreambuf
class | LineEndingExtractor
class | FilteringInputStream
class | OBLocale
class | OBMol
class | GasteigerState
class | OBGastChrg
class | OBConversion
class | OBError
class | OBMessageHandler
class | obLogBuf
class | OBMolAtomIter
class | OBMolAtomDFSIter
class | OBMolAtomBFSIter
class | OBMolBondBFSIter
class | OBMolBondIter
class | OBAtomAtomIter
class | OBAtomBondIter
class | OBResidueIter
class | OBResidueAtomIter
class | OBMolAngleIter
class | OBMolTorsionIter
class | OBMolPairIter
class | OBMolRingIter
class | OBMoleculeFormat
class | OBStopwatch
class | OBSqrtTbl
class | triple
class | quad
class | OBOp
class | OpTransform
union | _AtomExpr
union | _BondExpr
struct | BondSpec
struct | AtomSpec
struct | Pattern
struct | ParseState
class | OBSmartsPattern
class | OBSmartsMatcher
class | OBSSMatch
class | patty
class | OBChemTsfm
class | OBPhModel
struct | CharPtrLess
class | OBPlugin
class | OBPointGroup
class | OBQueryAtom
class | OBQueryBond
class | OBQuery
class | OBReaction
class | OBReactionFacade
class | OBResidue
class | OBRing
class | OBRingSearch
class | OBRTree
class | OBRotamerList
class | OBRotorRule
class | OBRotorRules
class | OBRotor
class | OBRotorList
class | OBRotorKeys
class | OBSpectrophore
class | TautomerFunctor
class | UniqueTautomerFunctor
class | OBText
struct | DeleteObject
class | OBAtomTyper
class | OBAromaticTyper
class | OBRingTyper
class | XMLConversion
class | XMLBaseFormat
class | XMLMoleculeFormat
class | OBAlign
class | matrix3x3
class | SpaceGroup
class | transform3d
class | vector3
struct | OBTetrahedralConfig
struct | OBCisTransConfig
struct | OBSquarePlanarConfig
class | OBCisTransStereo
class | OBSquarePlanarStereo
class | OBStereo
struct | OBStereoUnit
class | OBStereoBase
class | OBStereoFacade
class | OBTetrahedralStereo
class | OBTetraNonPlanarStereo
class | OBTetraPlanarStereo
class | ASCIIPainter
class | CairoPainter
class | CommandPainter
class | OBDepict
class | OBColor
class | OBFontMetrics
class | OBPainter
struct | DoubleType
class | OBRandom

## Typedefs

typedef OBAtom | OBNodeBase
typedef std::vector< OBBond * >::iterator | OBBondIterator
typedef std::vector< OBAtom * >::iterator | OBAtomIterator
typedef std::vector< OBGenericData * >::iterator | OBDataIterator
typedef struct Template | Template
typedef std::vector< int > | RotorKey
typedef std::vector< RotorKey > | RotorKeys
typedef std::map< std::vector< int >, double > | mapRotorEnergy
typedef OBPairTemplate< int > | OBPairInteger
typedef OBPairTemplate< double > | OBPairFloatingPoint
typedef OBPairTemplate< bool > | OBPairBool
typedef std::vector< OBFreeGridPoint * >::iterator | OBFreeGridPointIterator
typedef OBIsomorphismMapper::Mapping | Automorphism
typedef OBIsomorphismMapper::Mappings | Automorphisms
typedef std::vector< OBResidue * >::iterator | OBResidueIterator
typedef OBPlugin::PluginIterator | Formatpos
typedef union OpenBabel::_AtomExpr | AtomExpr
typedef union OpenBabel::_BondExpr | BondExpr
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 | neighbourlist

## Enumerations

enum | DataOrigin { any , fileformatInput , userInput , perceived , external , local }
enum | score_t { Undefined = -1 , PLP , ChemScore }
enum | HydrogenType { AllHydrogen , PolarHydrogen , NonPolarHydrogen }
enum | obMessageLevel { obError , obWarning , obInfo , obAuditMsg , obDebug }
enum | errorQualifier { always , onceOnly }
enum | OBReactionRole { NO_REACTIONROLE , REACTANT , AGENT , PRODUCT }
enum | ExocyclicAtom { NO_EXOCYCLIC_ATOM , EXO_OXYGEN , EXO_NONOXYGEN }
enum | { SPACE_GROUP_ID , SPACE_GROUP_HALL , SPACE_GROUP_HM , SPACE_GROUP_TRANSFORM }
enum | { Left , Right , Up , Down }
enum | Radical { NOT_RADICAL , ONE_DOT , TWO_DOT }

## 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)
bool | extract_thermochemistry (OpenBabel::OBMol &mol, bool bVerbose, int *Nsymm, int Nrotbonds, double dbdt, double *temperature, double *DeltaHf0, double *DeltaHfT, double *DeltaGfT, double *DeltaSfT, double *S0T, double *CVT, double *CPT, std::vector< double > &Scomponents, double *ZPVE)
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())
bool | OBKekulize (OBMol *mol)
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)
unsigned int | OBBondGetSmallestRingSize (OBBond *bond, unsigned int bound)
unsigned int | GetTypicalValence (unsigned int element, unsigned int bosum, int charge)
void | OBAtomAssignTypicalImplicitHydrogens (OBAtom *atom)
void | rotate_coords (double *, double m[3][3], unsigned)
double | calc_rms (double *r, double *f, unsigned int N)
void | SmartsLexReplace (std::string &, std::vector< std::pair< std::string, std::string > > &)
std::vector< std::string > | EnableStaticPlugins ()
OBQuery * | CompileMoleculeQuery (OBMol *mol, const OBBitVec &mask=OBBitVec())
OBQuery * | CompileSmilesQuery (const std::string &smiles, const OBBitVec &mask=OBBitVec())
bool | CompareRingSize (const OBRing *, const OBRing *)
int | Swab (int)
void | EnumerateTautomers (OBMol *mol, TautomerFunctor &functor)
void | CanonicalTautomer (OBMol *mol)
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 bool | IsSulfoneOxygen (OBAtom *atm)
static double | CorrectedBondRad (unsigned int elem, unsigned int hyb)
static void | ApplyRotMatToBond (OBMol &mol, matrix3x3 &m, OBAtom *a1, OBAtom *a2)
OBBitVec | operator| (const OBBitVec &bv1, const OBBitVec &bv2)
OBBitVec | operator& (const OBBitVec &bv1, const OBBitVec &bv2)
OBBitVec | operator^ (const OBBitVec &bv1, const OBBitVec &bv2)
OBBitVec | operator- (const OBBitVec &bv1, const OBBitVec &bv2)
bool | operator== (const OBBitVec &bv1, const OBBitVec &bv2)
bool | operator< (const OBBitVec &bv1, const OBBitVec &bv2)
std::istream & | operator>> (std::istream &is, OBBitVec &bv)
std::ostream & | operator<< (std::ostream &os, const OBBitVec &bv)
static double | CorrectedBondRad (unsigned int elem, unsigned int hyb)
vector3 | GetCorrectedBondVector (OBAtom *atom1, OBAtom *atom2, int bondOrder=1)
static unsigned int | TotalHydrogenCount (OBAtom *atom)
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)
bool | sortpred_b (const OBDiversePoses::PosePair &a, const OBDiversePoses::PosePair &b)
std::vector< vector3 > | GetHeavyAtomCoords (const OBMol *mol, const std::vector< vector3 > &all_coords)
void | UpdateConformersFromTree (OBMol *mol, std::vector< double > &energies, OBDiversePoses *divposes, bool verbose)
static double | UnitNameToConversionFactor (const char *unit)
void | Toupper (string &s)
void | Tolower (string &s)
void | Reweight (std::vector< std::vector< double > > &rotorWeights, std::vector< int > rotorKey, double bonus)
bool | areDuplicateAtoms (vector3 v1, vector3 v2)
| OBUNITCELL_CALL_CONST_OVERLOAD (double, GetA)
| OBUNITCELL_CALL_CONST_OVERLOAD (double, GetB)
| OBUNITCELL_CALL_CONST_OVERLOAD (double, GetC)
| OBUNITCELL_CALL_CONST_OVERLOAD (double, GetAlpha)
| OBUNITCELL_CALL_CONST_OVERLOAD (double, GetBeta)
| OBUNITCELL_CALL_CONST_OVERLOAD (double, GetGamma)
| OBUNITCELL_CALL_CONST_OVERLOAD (vector3, GetOffset)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG (OBUnitCell::LatticeType, GetLatticeType, int)
| OBUNITCELL_CALL_CONST_OVERLOAD (OBUnitCell::LatticeType, GetLatticeType)
| OBUNITCELL_CALL_CONST_OVERLOAD (std::vector< vector3 >, GetCellVectors)
| OBUNITCELL_CALL_CONST_OVERLOAD (matrix3x3, GetCellMatrix)
| OBUNITCELL_CALL_CONST_OVERLOAD (matrix3x3, GetOrthoMatrix)
| OBUNITCELL_CALL_CONST_OVERLOAD (matrix3x3, GetOrientationMatrix)
| OBUNITCELL_CALL_CONST_OVERLOAD (matrix3x3, GetFractionalMatrix)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG (vector3, FractionalToCartesian, vector3)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG (vector3, CartesianToFractional, vector3)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG (vector3, WrapCartesianCoordinate, vector3)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG (vector3, WrapFractionalCoordinate, vector3)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG (vector3, MinimumImageCartesian, vector3)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG (vector3, MinimumImageFractional, vector3)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG (int, GetSpaceGroupNumber, std::string)
| OBUNITCELL_CALL_CONST_OVERLOAD (double, GetCellVolume)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG2 (vector3, UnwrapCartesianNear, vector3, vector3)
| OBUNITCELL_CALL_CONST_OVERLOAD_ARG2 (vector3, UnwrapFractionalNear, vector3, vector3)
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<< (std::ostream &os, const OBFloatGrid &fg)
istream & | operator>> (std::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)
static unsigned int | GetMaxAtomIdx (OBMol *mol)
static unsigned int | GetMaxBondIdx (OBMol *mol)
static bool | IsSpecialCase (OBAtom *atom)
static bool | NeedsDoubleBond (OBAtom *atom)
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)
int | sproduct (TSimpleMolecule &sm, int br, int i1, int i2)
bool | compareAtoms (int a1, int a2, const std::vector< std::vector< int > * > aeqList)
bool | incrementValues (std::vector< int > &currentValues, const std::vector< int > maxValues)
bool | CompareRotor (const pair< int, int > &a, const pair< int, int > &b)
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)
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 | 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 bool | IsSuppressibleHydrogen (OBAtom *atom)
static bool | AtomIsNSOP (OBAtom *atom)
static double | CorrectedBondRad (unsigned int elem, unsigned int hyb)
static void | DeleteStereoOnAtom (OBMol &mol, OBStereo::Ref atomId)
bool | WriteTitles (ostream &ofs, OBMol &mol)
static bool | validAdditionalBond (OBAtom *a, OBAtom *n)
static bool | IsNotCorH (OBAtom *atom)
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 | CreateAtom (Pattern *, AtomExpr *, int, int vb=0)
static void | FatalAllocationError (const char *ptr)
static void | FreePattern (Pattern *)
static Pattern * | CopyPattern (Pattern *)
static AtomExpr * | CopyAtomExpr (AtomExpr *expr)
static void | FreeAtomExpr (AtomExpr *expr)
static AtomExpr * | BuildAtomPred (int type)
static AtomExpr * | BuildAtomLeaf (int type, 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 BondExpr * | CopyBondExpr (BondExpr *expr)
static bool | EquivalentBondExpr (BondExpr *expr1, BondExpr *expr2)
static void | FreeBondExpr (BondExpr *expr)
static BondExpr * | BuildBondLeaf (int type)
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 int | GetExprOrder (BondExpr *expr)
static int | GetExprCharge (AtomExpr *expr)
static int | GetExprAtomicNum (AtomExpr *expr)
static unsigned int | isqrt (unsigned int val)
static int | IsOddPrime (unsigned int x)
static int | RelativelyPrime (unsigned int x, unsigned int y)
static void | DoubleAdd (DoubleType *x, unsigned int y)
static void | DoubleMultiply (unsigned int x, unsigned int y, DoubleType *z)
static int | LeadingZeros (unsigned int x)
static unsigned int | DoubleModulus (DoubleType *n, unsigned int d)
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)
static int | DetermineSequence (unsigned int m, unsigned int *pm, unsigned int *pa, unsigned int *pc)
static 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 unsigned int | FindRingAtomsAndBonds2 (OBMol &mol)
static int | FindRings (OBAtom *atom, int *avisit, unsigned char *bvisit, unsigned int &frj, 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 > &)
char * | trim_spaces (char *string)
static ExocyclicAtom | FindExocyclicAtom (OBAtom *atm)
static bool | HasExocyclicBondToOxygenMinus (OBAtom *atm)
static bool | HasExocyclicDblBondToOxygen (OBAtom *atm)
static bool | HasExocyclicDblBondToHet (OBAtom *atm)
static bool | AssignOBAromaticityModel (OBAtom *atm, int &min, int &max)
static double | eval_horn_NR_corrxn (const vector< double > &c, const double x)
static double | QCProot (const vector< double > &coeff, double guess, const double delta)
vector< double > | CalcQuarticCoeffs (const Eigen::Matrix3d &M)
matrix3x3 | operator* (const matrix3x3 &A, const matrix3x3 &B)
static double | SQUARE (double x)
ostream & | operator<< (std::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 | getdelta (int x, int y, int x2, int y2)
string | getsymbols (int x, int y, int x2, int y2)
static cairo_status_t | writeFunction (void *closure, const unsigned char *data, unsigned int length)
int | GetLabelAlignment (OBAtom *atom)
unsigned int | GetAtomSymClass (OBAtom *atom)
static Radical | AssignRadicalDots (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 *)
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)
High level functions
void | PerceiveStereo (OBMol *mol, bool force=false)
void | StereoFrom2D (OBMol *mol, std::map< OBBond *, enum OBStereo::BondDirection > *updown=nullptr, 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=nullptr, 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)
void | ImplicitRefToStereo (OBMol &mol, OBStereo::Ref centerId, OBStereo::Ref newId)
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
OB_EXTERN OBChainsParser | chainsparser
OB_EXTERN OBTypeTable | ttab
OB_EXTERN OBResidueData | resdat
const double | HARTEE_TO_KCALPERMOL = 627.509469
const double | HARTREE_TO_KJPERMOL = 2625.49962
const double | KJPERMOL_TO_KCALPERMOL = 1.0/4.184
const double | RYDBERG_TO_KCALPERMOL = 313.755026
const double | ELECTRONVOLT_TO_KCALPERMOL = 23.060538
const double | KCAL_TO_KJ = 4.1868
const double | GAS_CONSTANT = 8.31446261815324e-3 / KCAL_TO_KJ
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
static const unsigned long | NoId = detail::max_value<unsigned long>::result
OBMessageHandler | obErrorLog
THREAD_LOCAL OB_EXTERN OBAtomTyper | atomtyper
THREAD_LOCAL OB_EXTERN OBAromaticTyper | aromtyper
const vector3 | VZero
const vector3 | VX
const vector3 | VY
const vector3 | VZ
static unsigned 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)
THREAD_LOCAL OBPhModel | phmodel
static double | Roots [4]
const int | SmartsImplicitRef = -9999
POINT_GROUP | PointGroups []
static int | primes [MAXPRIMES]
char | Residue [MAXRES][4]
char | ElemDesc [MAXELEM][4]
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

## OBNodeBase

typedef OBAtom OBNodeBase

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

## OBBondIterator

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

A standard iterator over a vector of bonds.

## OBAtomIterator

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

A standard iterator over a vector of atoms.

## OBDataIterator

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

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

## Template

typedef struct OpenBabel::Template Template

Structure template for atomic patterns in residues for OBChainsParser.

## RotorKey

typedef std::vector<int> RotorKey

## RotorKeys

typedef std::vector<RotorKey> RotorKeys

Examples
  obconformersearch_default.cpp.

## mapRotorEnergy

typedef std::map<std::vector<int>,double> mapRotorEnergy

## OBPairInteger

typedef OBPairTemplate<int> OBPairInteger

Store arbitrary key/value integer data like OBPairData.

## OBPairFloatingPoint

typedef OBPairTemplate<double> OBPairFloatingPoint

Store arbitrary key/value floating point data like OBPairData.

## OBPairBool

typedef OBPairTemplate<bool> OBPairBool

Store arbitrary key/value boolean data like OBPairData.

## OBFreeGridPointIterator

typedef std::vector<OBFreeGridPoint*>::iterator OBFreeGridPointIterator

A standard iterator over a vector of FreeGridPoints.

## OBResidueIterator

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

## Formatpos

typedef OBPlugin::PluginIterator Formatpos

## AtomExpr

typedef union OpenBabel::_AtomExpr AtomExpr

## BondExpr

typedef union OpenBabel::_BondExpr BondExpr

## OBRotorIterator

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

A standard iterator over a vector of rotors.

## transform3dIterator

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

## ByteCode

typedef union OpenBabel::_ByteCode ByteCode

Chemical graph matching virtual machine.

## adjustedlist

typedef struct OpenBabel::adjustedlist adjustedlist

## neighbourlist

typedef adjustedlist neighbourlist

## Enumeration Type Documentation

## DataOrigin

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

## score_t

enum score_t

Enumerator
Undefined |
PLP |
ChemScore |

## HydrogenType

enum HydrogenType

Enumerator
AllHydrogen |
PolarHydrogen |
NonPolarHydrogen |

## obMessageLevel

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

## errorQualifier

enum errorQualifier

Enumerator
always |
onceOnly |

## OBReactionRole

enum OBReactionRole

The various roles a reaction component can have

See also
  OBReactionFacade

Enumerator
NO_REACTIONROLE | no reaction role - useful for temporarily hiding a component
REACTANT | reactant
AGENT | agent, a term that includes solvents and catalysts
PRODUCT | product

## ExocyclicAtom

enum ExocyclicAtom

Enumerator
NO_EXOCYCLIC_ATOM |
EXO_OXYGEN |
EXO_NONOXYGEN |

## anonymous enum

anonymous enum

Enumerator
SPACE_GROUP_ID |
SPACE_GROUP_HALL |
SPACE_GROUP_HM |
SPACE_GROUP_TRANSFORM |

## anonymous enum

anonymous enum

Enumerator
Left |
Right |
Up |
Down |

## Radical

enum Radical

Enumerator
NOT_RADICAL |
ONE_DOT |
TWO_DOT |

## Function Documentation

## OBReleaseVersion()

std::string OBReleaseVersion | ( |  | ) |

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

## Tanimoto()

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.

## CanonicalLabels()

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

## extract_thermochemistry()

bool extract_thermochemistry | ( | OpenBabel::OBMol & | mol,
|  | bool | bVerbose,
|  | int * | Nsymm,
|  | int | Nrotbonds,
|  | double | dbdt,
|  | double * | temperature,
|  | double * | DeltaHf0,
|  | double * | DeltaHfT,
|  | double * | DeltaGfT,
|  | double * | DeltaSfT,
|  | double * | S0T,
|  | double * | CVT,
|  | double * | CPT,
|  | std::vector< double > & | Scomponents,
|  | double * | ZPVE )

Convenience function to extract thermochemistry from a molecule structure.

Parameters

  [in] | mol | The molecule structure
  [in] | bVerbose | If true will print information
  [in,out] | Nsymm | If not zero and differing from the rotational symmetry in the input molecule, corrections to the entropy and free energy will be applied. If zero will hold the symmetry number from the input molecule on return.
  [out] | temperature | The temperature
  [out] | DeltaHf0 | Enthalpy of formation at T = 0
  [out] | DeltaHfT | Enthalpy of formation at T
  [out] | DeltaGfT | Gibbs energy of formation at T
  [out] | DeltaSfT | Entropy of formation at T
  [out] | S0T | Standard entropy at T
  [out] | CVT | Heat capacity at T and constant Volume
  [out] | Scomponents | Translational, Rotational and Vibrational components of S0

Returns
  true if all values were found, false otherwise.

## DoComparison()

template<class T>

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

static

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

## OBKekulize()

bool OBKekulize | ( | OBMol * | mol | ) |

Kekulize a molecule by assigning bond orders of 1 or 2 to aromatic bonds.

Some file formats describe bond orders as aromatic. Such bonds require kekulization before the molecule is returned by the reader. Normally, a user should never need to call this function themselves.

This function takes an OBMol which has atoms and bonds marked as aromatic, aromatic bonds whose bond orders have been set to single, and aromaticity set as perceived. The function assumes that atoms joined by aromatic bonds have been marked as aromatic (if they are so intended).

The purpose of the function is to set the bond orders of the aromatic bonds to either 1 or 2 in such a way that the valencies of all of the aromatic atoms are satisfied. Failure to do this will result in one or more atoms having unsatisfied valences, indicated by a radical. Such a failure can only occur if an atom is incorrectly marked as aromatic, or is correctly marked as aromatic but has incorrect valence (e.g. 'n' instead of '[nH]' in SMILES).

Returns
  Whether kekulization was successful

Referenced by OBMol::PerceiveBondOrders().

## print_matrix()

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

## print_matrix_f()

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

## print_matrix_ff()

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

## mult_matrix()

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

## mult_matrix_f()

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

## mult_matrix_ff()

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

## invert_matrix()

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

## invert_matrix_f()

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

## invert_matrix_ff()

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

## convert_matrix_f() [1/2]

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

## convert_matrix_ff() [1/2]

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

## convert_matrix_f() [2/2]

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

## convert_matrix_ff() [2/2]

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

## convert_matrix_ff_f()

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

## convert_matrix_f_ff()

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

## hydrogenValency()

int hydrogenValency | ( | int | na | ) |

Referenced by alternate(), alternate(), analyzeOK(), determineBondsOrder(), findAlternateSinglets(), and makeAssignment().

## maxValency()

int maxValency | ( | int | na | ) |

Referenced by alternate(), alternate(), analyzeOK(), and determineBondsOrder().

## alternate() [1/3]

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

## alternate() [2/3]

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 )

## generateDiagram() [1/3]

void generateDiagram | ( | OBMol * | pmol | ) |

Since
  version 2.3

## generateDiagram() [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 )

## generateDiagram() [3/3]

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

## fragmentSearch() [1/2]

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

## fragmentSearch() [2/2]

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 )

## equivalenceList() [1/2]

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

Equivalence list generation.

## equivalenceList() [2/2]

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 )

## addFragment()

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

## createStereoLists()

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

## getAtomMCDL()

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 )

## getBondMCDL()

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 )

## implementAtomStereo()

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 )

## implementBondStereo()

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 )

## groupRedraw()

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

## canonizeMCDL()

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

## parseFormula()

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

## prepareTest()

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

## ThrowError() [1/2]

void ThrowError | ( | char * | str | ) |

Deprecated: use the OBMessageHandler class instead

Deprecated
  Throw an error through the OpenBabel::OBMessageHandler class

## ThrowError() [2/2]

void ThrowError | ( | std::string & | str | ) |

Deprecated: use the OBMessageHandler class instead

Deprecated
  Throw an error through the OpenBabel::OBMessageHandler class

## CartesianToInternal()

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.

Todo
  Consider lengths, angles, and torsions for periodic systems

Referenced by OBMol::GetInternalCoord().

## InternalToCartesian()

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. The size of supplied internal coordinate vector has to be the same as the number of atoms in molecule (+ NULL in the beginning). Implements blue-obelisk:zmatrixCoordinatesIntoCartesianCoordinates

## NewExtension()

string NewExtension | ( | std::string & | src,
|  | char * | ext )

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

## get_rmat()

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

## ob_make_rmat()

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

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

## qtrfit()

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

## superimpose()

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

## OBBondGetSmallestRingSize()

unsigned int OBBondGetSmallestRingSize | ( | OBBond * | bond,
|  | unsigned int | bound )

Return the size of the smallest ring in which a bond appears.

This function returns the size of the smallest ring in which a bond appears. The search is bounded by the specified bound. A value of 0 is returned if the bond is not in a ring or if no ring is found of size less than or equal to the bound.

Note that alternative algorithms may be more appropriate if you wish to calculate this value for all atoms in a molecule.

Returns
  The size of the smallest ring, or 0

## GetTypicalValence()

unsigned int GetTypicalValence | ( | unsigned int | element,
|  | unsigned int | bosum,
|  | int | charge )

Return the typical valence of an atom of a particular element.

This function returns the typical valence of an atom given its element, current valence (that is, the current sum of the bond orders of its bonds) and formal charge.

This is typically used on atoms that are missing hydrogens, to decide how many implicit hydrogens should be assigned (should one have to guess). For example, the value 3 is returned for a positively charged carbon with no attached atoms.

Returns
  A value for the typical valence

Referenced by AssignRadicalDots(), OBMol::AssignTotalChargeToAtoms(), and OBAtomAssignTypicalImplicitHydrogens().

## OBAtomAssignTypicalImplicitHydrogens()

void OBAtomAssignTypicalImplicitHydrogens | ( | OBAtom * | atom | ) |

Assign implicit hydrogens to an OBAtom based on typical valences.

This function uses the return value of GetTypicalValence to determine how many implicit hydrogens to assign to an OBAtom. Note that most file formats describe exactly how many hydrogens are present, and do not require this function.

## rotate_coords() [1/2]

void rotate_coords | ( | double * | ,
|  | double | m[3][3],
|  | unsigned | )

## calc_rms()

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

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

## ToUpper() [1/2]

void ToUpper | ( | std::string & | s | ) |

Shift the supplied string to uppercase.

## ToUpper() [2/2]

void ToUpper | ( | char * | cptr | ) |

Shift the supplied char* to uppercase.

## ToLower() [1/2]

void ToLower | ( | std::string & | s | ) |

Shift the supplied string to lowercase.

## ToLower() [2/2]

void ToLower | ( | char * | cptr | ) |

Shift the supplied char* to lowercase.

## InvertCase() [1/3]

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

## InvertCase() [2/3]

void InvertCase | ( | char * | cptr | ) |

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

## CleanAtomType()

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

## OBCompareInt()

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

Comparison – returns true if first parameter less than second

Returns
  True if `a` < `b`, False otherwise.

## OBCompareUnsigned()

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

## IsNear()

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

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

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

Deprecated
  Use IsApprox() instead

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

## IsNearZero()

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::VectorAngleDerivative(), OBForceField::VectorOOP(), OBForceField::VectorOOPDerivative(), OBForceField::VectorOOPDerivative(), OBForceField::VectorTorsion(), OBForceField::VectorTorsionDerivative(), and OBForceField::VectorTorsionDerivative().

## IsNan()

bool IsNan | ( | const double & | a | ) |

Comparison for nan (not a number).

Referenced by OBBuilder::Build(), and OBDescriptor::CompareStringWithFilter().

## IsNegligible()

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

## IsApprox()

bool 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)
  OpenBabel::IsNegligible
  bool IsNegligible(const double &a, const double &b, const double precision=1e-11)
  Definition obutil.h:205
  instead of
  IsApprox( x, 0.0 )
  OpenBabel::IsApprox
  bool IsApprox(const double &a, const double &b, const double precision=1e-11)
  Definition obutil.h:227

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

## IsApprox_pos()

bool IsApprox_pos | ( | const double & | a,
|  | const double & | b,
|  | const double | precision = 1e-11 )

inline

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

## CanBeSquared()

bool CanBeSquared | ( | const double & | a | ) |

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

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

Referenced by vector3::CanBeNormalized().

## SafeOpen() [1/4]

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(), and SafeOpen().

## SafeOpen() [2/4]

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.

## SmartsLexReplace()

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

## CompareRingSize()

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

## Swab()

int Swab | ( | int | i | ) |

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

## EnumerateTautomers()

void EnumerateTautomers | ( | OBMol * | mol,
|  | TautomerFunctor & | functor )

Enumerate all tautomers for `mol`. Every time a tautomer is discovered, the `functor` will be invoked with the bonds changed to the tautomer. When the enumeration is complete, the bonds will be changed back to the original bond orders.

The algorithm is based on http://www.daylight.com/meetings/emug99/Delany/taut_html/index.htm

Warning
  This function makes hydrogens implicit.

See also
  TautomerFunctor

## CanonicalTautomer()

void CanonicalTautomer | ( | OBMol * | mol | ) |

Compuate the canonical tautomer for `mol`. The canonical tautomer is the first found tautomer in the enumeration algorithm and is a mathematically unique tautomer (i.e. the algorithm does not guarantee that this is the dominant tautomer). The bonds in `mol` will be changed to the canonical tautomer.

Warning
  This function makes hydrogens implicit.

## tokenize() [1/2]

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

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(), OBMol::DoTransformations(), DLHandler::findFiles(), OBBuilder::GetFragmentCoord(), OBBuilder::LoadFragments(), OBAtomicHeatOfFormationTable::ParseLine(), OBAtomTyper::ParseLine(), OBBondTyper::ParseLine(), OBPhModel::ParseLine(), OBResidueData::ParseLine(), OBRingTyper::ParseLine(), OBRotorRules::ParseLine(), OBTypeTable::ParseLine(), and patty::read_rules().

## tokenize() [2/2]

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.

## Trim()

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(), OBMol::GetSpacedFormula(), OBCommentData::SetData(), OBCommentData::SetData(), OBMol::SetTitle(), and OBMol::SetTitle().

## toString()

template<typename T>

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

## ignore()

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 up to the occurrence of a string

Parameters

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

Returns
  the stream.

## OpenDatafile()

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 OBBuilder::GetFragmentCoord(), OBGlobalDataBase::Init(), OBBuilder::LoadFragments(), and OBMoleculeFormat::ReadNameIndex().

## center_coords() [1/2]

vector3 center_coords | ( | double * | ,
|  | int | )

## operator<<() [1/4]

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

## operator+()

vector3 operator+ | ( | const vector3 & | v1,
|  | const vector3 & | v2 )

inline

Vector addition.

## operator-() [1/3]

vector3 operator- | ( | const vector3 & | v1,
|  | const vector3 & | v2 )

inline

Vector subtraction.

## operator-() [2/3]

vector3 operator- | ( | const vector3 & | v | ) |

inline

Unary minus.

## operator*() [1/4]

vector3 operator* | ( | const double & | c,
|  | const vector3 & | v )

inline

Multiplication with a scalar.

## operator*() [2/4]

vector3 operator* | ( | const vector3 & | v,
|  | const double & | c )

inline

Multiplication with a scalar.

## operator/()

vector3 operator/ | ( | const vector3 & | v,
|  | const double & | c )

inline

Division by a scalar.

## operator*() [3/4]

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

## dot()

double dot | ( | const vector3 & | v1,
|  | const vector3 & | v2 )

inline

Dot product of two vectors.

Referenced by CalcTorsionAngle(), OBForceField::ConjugateGradientsTakeNSteps(), OBBuilder::Connect(), OBBuilder::GetNewBondVector(), Point2PlaneSigned(), OBForceField::ValidateConjugateGradients(), vectorAngle(), OBForceField::VectorAngleDerivative(), OBForceField::VectorOOPDerivative(), and OBForceField::VectorTorsionDerivative().

## cross()

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

## vectorAngle()

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(), CartesianToInternal(), OBBuilder::Connect(), OBUnitCell::GetAlpha(), OBAtom::GetAngle(), OBUnitCell::GetBeta(), OBUnitCell::GetGamma(), Point2PlaneAngle(), OBUnitCell::SetData(), OBAtom::SetHybAndGeom(), and OBForceField::VectorTorsionDerivative().

## CalcTorsionAngle()

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

## Point2PlaneSigned()

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

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

## Point2PlaneAngle()

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.

## Point2Line()

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.

## IsSulfoneOxygen()

bool IsSulfoneOxygen | ( | OBAtom * | atm | ) |

static

Referenced by OBAtom::IsHbondAcceptor().

## CorrectedBondRad() [1/3]

double CorrectedBondRad | ( | unsigned int | elem,
|  | unsigned int | hyb )

static

Returns
  a "corrected" bonding radius based on the hybridization. Scales the covalent radius by 0.95 for sp2 and 0.90 for sp hybrids

Referenced by OBMol::AddHydrogens(), OBMol::AddNewHydrogens(), OBBond::GetEquibLength(), OBAtom::HtoMethyl(), OBMol::PerceiveBondOrders(), and OBAtom::SetHybAndGeom().

## ApplyRotMatToBond()

void ApplyRotMatToBond | ( | OBMol & | mol,
|  | matrix3x3 & | m,
|  | OBAtom * | a1,
|  | OBAtom * | a2 )

static

Referenced by OBAtom::SetHybAndGeom().

## operator|()

OBBitVec 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

## operator&()

OBBitVec 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

## operator^()

OBBitVec 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

## operator-() [3/3]

OBBitVec 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

## operator==()

bool 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

## operator<()

bool 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

## operator>>() [1/2]

std::istream & 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

## operator<<() [2/4]

std::ostream & 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

## CorrectedBondRad() [2/3]

double CorrectedBondRad | ( | unsigned int | elem,
|  | unsigned int | hyb )

static

Returns
  a "corrected" bonding radius based on the hybridization. Scales the covalent radius by 0.95 for sp2 and 0.90 for sp hybrids

## GetCorrectedBondVector()

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

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

## TotalHydrogenCount()

unsigned int TotalHydrogenCount | ( | OBAtom * | atom | ) |

static

## CompareBondPairSecond()

bool CompareBondPairSecond | ( | const std::pair< OBBond *, unsigned int > & | a,
|  | const std::pair< OBBond *, unsigned int > & | b )

inline

## addNbrs()

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

Helper function for getFragment below.

Referenced by addNbrs(), getFragment(), and getFragment().

## getFragment() [1/2]

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

## getFragment() [2/2]

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

## isFerroceneBond()

bool isFerroceneBond | ( | OBBond * | bond | ) |

Referenced by CompileAutomorphismQuery().

## findMetalloceneBonds()

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

Referenced by CanonicalLabels().

## AllocateByteCode()

ByteCode * AllocateByteCode | ( | int | type | ) |

static

Referenced by GenerateByteCodes().

## DeleteByteCode()

void DeleteByteCode | ( | ByteCode * | node | ) |

static

Free a ByteCode and all corresponding data.

Referenced by DeleteByteCode(), and OBChainsParser::~OBChainsParser().

## FatalMemoryError()

void FatalMemoryError | ( | void |  | ) |

static

Referenced by GenerateByteCodes().

## GenerateByteCodes()

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

Referenced by GenerateByteCodes().

## sortpred_b()

bool sortpred_b | ( | const OBDiversePoses::PosePair & | a,
|  | const OBDiversePoses::PosePair & | b )

Referenced by sortpred_b(), and UpdateConformersFromTree().

## GetHeavyAtomCoords()

std::vector< vector3 > GetHeavyAtomCoords | ( | const OBMol * | mol,
|  | const std::vector< vector3 > & | all_coords )

Referenced by GetHeavyAtomCoords().

## UpdateConformersFromTree()

void UpdateConformersFromTree | ( | OBMol * | mol,
|  | std::vector< double > & | energies,
|  | OBDiversePoses * | divposes,
|  | bool | verbose )

Referenced by UpdateConformersFromTree().

## UnitNameToConversionFactor()

double UnitNameToConversionFactor | ( | const char * | unit | ) |

static

Referenced by OBAtomicHeatOfFormationTable::GetHeatOfFormation().

## Toupper()

void Toupper | ( | string & | s | ) |

## Tolower()

void Tolower | ( | string & | s | ) |

## Reweight()

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

Referenced by OBForceField::WeightedRotorSearch().

## areDuplicateAtoms()

bool areDuplicateAtoms | ( | vector3 | v1,
|  | vector3 | v2 )

## OBUNITCELL_CALL_CONST_OVERLOAD() [1/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | double | ,
|  | GetA | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [2/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | double | ,
|  | GetB | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [3/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | double | ,
|  | GetC | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [4/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | double | ,
|  | GetAlpha | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [5/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | double | ,
|  | GetBeta | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [6/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | double | ,
|  | GetGamma | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [7/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | vector3 | ,
|  | GetOffset | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [1/8]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG | ( | OBUnitCell::LatticeType | ,
|  | GetLatticeType | ,
|  | int | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [8/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | OBUnitCell::LatticeType | ,
|  | GetLatticeType | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [9/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | std::vector< vector3 > | ,
|  | GetCellVectors | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [10/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | matrix3x3 | ,
|  | GetCellMatrix | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [11/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | matrix3x3 | ,
|  | GetOrthoMatrix | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [12/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | matrix3x3 | ,
|  | GetOrientationMatrix | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [13/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | matrix3x3 | ,
|  | GetFractionalMatrix | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [2/8]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG | ( | vector3 | ,
|  | FractionalToCartesian | ,
|  | vector3 | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [3/8]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG | ( | vector3 | ,
|  | CartesianToFractional | ,
|  | vector3 | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [4/8]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG | ( | vector3 | ,
|  | WrapCartesianCoordinate | ,
|  | vector3 | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [5/8]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG | ( | vector3 | ,
|  | WrapFractionalCoordinate | ,
|  | vector3 | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [6/8]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG | ( | vector3 | ,
|  | MinimumImageCartesian | ,
|  | vector3 | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [7/8]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG | ( | vector3 | ,
|  | MinimumImageFractional | ,
|  | vector3 | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [8/8]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG | ( | int | ,
|  | GetSpaceGroupNumber | ,
|  | std::string | )

## OBUNITCELL_CALL_CONST_OVERLOAD() [14/14]

OBUNITCELL_CALL_CONST_OVERLOAD | ( | double | ,
|  | GetCellVolume | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG2() [1/2]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG2 | ( | vector3 | ,
|  | UnwrapCartesianNear | ,
|  | vector3 | ,
|  | vector3 | )

## OBUNITCELL_CALL_CONST_OVERLOAD_ARG2() [2/2]

OBUNITCELL_CALL_CONST_OVERLOAD_ARG2 | ( | vector3 | ,
|  | UnwrapFractionalNear | ,
|  | vector3 | ,
|  | vector3 | )

## CompareUnsigned()

bool CompareUnsigned | ( | const unsigned int & | a,
|  | const unsigned int & | b )

inline

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

## ComparePairFirst()

bool ComparePairFirst | ( | const std::pair< OBAtom *, unsigned int > & | a,
|  | const std::pair< OBAtom *, unsigned int > & | b )

inline

## ComparePairSecond()

bool ComparePairSecond | ( | const std::pair< OBAtom *, unsigned int > & | a,
|  | const std::pair< OBAtom *, unsigned int > & | b )

inline

## operator<<() [3/4]

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

## operator>>() [2/2]

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

## print_vector()

template<typename T>

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

## CompileAutomorphismQuery()

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

Referenced by FindAutomorphisms().

## FindAutomorphisms() [1/2]

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

## FindAutomorphisms() [2/2]

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

## GetMaxAtomIdx()

unsigned int GetMaxAtomIdx | ( | OBMol * | mol | ) |

static

## GetMaxBondIdx()

unsigned int GetMaxBondIdx | ( | OBMol * | mol | ) |

static

## IsSpecialCase()

bool IsSpecialCase | ( | OBAtom * | atom | ) |

static

Referenced by NeedsDoubleBond().

## NeedsDoubleBond()

bool NeedsDoubleBond | ( | OBAtom * | atom | ) |

static

## intToStr()

string intToStr | ( | int | k | ) |

Referenced by getAtomMCDL(), and getBondMCDL().

## xDistPoint()

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

Referenced by overlapped().

## overlapped()

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

## sproduct()

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

Referenced by getBondMCDL().

## compareAtoms()

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

## incrementValues()

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

## CompareRotor() [1/2]

bool CompareRotor | ( | const pair< int, int > & | a,
|  | const pair< int, int > & | b )

Referenced by OBRotorList::FindRotors().

## deleteIntElement()

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

## findAlternateSinglets()

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

Referenced by determineBondsOrder(), and makeAssignment().

## makeAssignment()

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

Referenced by determineBondsOrder().

## analyzeOK()

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

Referenced by determineBondsOrder().

## incrementAssignment()

bool incrementAssignment | ( | std::vector< int > & | bondAssignment,
|  | int | nAss )

static

Referenced by determineBondsOrder().

## determineBondsOrder()

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 )

static

Referenced by alternate(), and alternate().

## alternate() [3/3]

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

## ptInRect()

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

## compareStringsNumbers()

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

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

## getAtomSymbol() [1/2]

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

nepravil'no

Referenced by getAtomMCDL(), and getBondMCDL().

## getAtomSymbol() [2/2]

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

## indexOf()

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

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

## removeZeroeth()

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

Referenced by getAtomMCDL(), and getBondMCDL().

## analizeParity()

int analizeParity | ( | string | data | ) |

Referenced by getAtomMCDL().

## analizeParityBond()

int analizeParityBond | ( | string | data | ) |

Referenced by getBondMCDL().

## changeParity()

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

Referenced by getAtomMCDL().

## changeParityBond()

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

Referenced by getBondMCDL().

## bondEquivalent()

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

Referenced by getBondMCDL().

## addZeroeth()

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

Referenced by implementAtomStereo(), and implementBondStereo().

## setUpDownBonds()

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

## SortVVInt()

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

Referenced by OBMol::ContigFragList().

## SortAtomZ()

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

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

## OBComparePairSecond()

bool OBComparePairSecond | ( | const pair< OBAtom *, unsigned int > & | a,
|  | const pair< OBAtom *, unsigned int > & | b )

static

Referenced by ClassCount().

## OBComparePairFirst()

bool OBComparePairFirst | ( | const pair< OBAtom *, unsigned int > & | a,
|  | const pair< OBAtom *, unsigned int > & | b )

static

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

## ClassCount()

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

## CreateNewClassVector()

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

## IsSuppressibleHydrogen()

bool IsSuppressibleHydrogen | ( | OBAtom * | atom | ) |

static

Referenced by OBMol::DeleteHydrogens(), OBMol::DeleteHydrogens(), OBMol::DeleteNonPolarHydrogens(), and OBMol::DeletePolarHydrogens().

## AtomIsNSOP()

bool AtomIsNSOP | ( | OBAtom * | atom | ) |

static

Referenced by OBMol::AddNewHydrogens().

## CorrectedBondRad() [3/3]

double CorrectedBondRad | ( | unsigned int | elem,
|  | unsigned int | hyb )

static

Returns
  a "corrected" bonding radius based on the hybridization. Scales the covalent radius by 0.95 for sp2 and 0.90 for sp hybrids

## DeleteStereoOnAtom()

void DeleteStereoOnAtom | ( | OBMol & | mol,
|  | OBStereo::Ref | atomId )

static

Referenced by OBMol::DeleteAtom().

## WriteTitles()

bool WriteTitles | ( | ostream & | ofs,
|  | OBMol & | mol )

## validAdditionalBond()

bool validAdditionalBond | ( | OBAtom * | a,
|  | OBAtom * | n )

static

Referenced by OBMol::ConnectTheDots().

## IsNotCorH()

bool IsNotCorH | ( | OBAtom * | atom | ) |

static

Referenced by OBMol::MakeDativeBonds().

## center_coords() [2/2]

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

## rotate_coords() [2/2]

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

## SetRotorToAngle() [1/2]

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

## SafeOpen() [3/4]

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

## SafeOpen() [4/4]

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

## InvertCase() [3/3]

void 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

## SolveLinear()

int SolveLinear | ( | double | A,
|  | double | B )

Referenced by SolveQuadratic().

## SolveQuadratic()

int SolveQuadratic | ( | double | A,
|  | double | B,
|  | double | C )

Referenced by SolveCubic().

## CubeRoot()

double CubeRoot | ( | double | X | ) |

Referenced by SolveCubic().

## SolveCubic()

int SolveCubic | ( | double | A,
|  | double | B,
|  | double | C,
|  | double | D )

## get_roots_3_3()

int get_roots_3_3 | ( | double | mat[3][3],
|  | double | roots[3] )

static

Referenced by get_rmat(), and superimpose().

## CreateAtom()

int CreateAtom | ( | Pattern * | pat,
|  | AtomExpr * | expr,
|  | int | part,
|  | int | vb = 0 )

static

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

## FatalAllocationError()

void FatalAllocationError | ( | const char * | ptr | ) |

static

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

## FreePattern()

void FreePattern | ( | Pattern * | pat | ) |

static

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

## CopyPattern()

Pattern * CopyPattern | ( | Pattern * | pat | ) |

static

Referenced by CopyAtomExpr().

## CopyAtomExpr()

AtomExpr * CopyAtomExpr | ( | AtomExpr * | expr | ) |

static

Referenced by CopyAtomExpr(), and CopyPattern().

## FreeAtomExpr()

void FreeAtomExpr | ( | AtomExpr * | expr | ) |

static

Referenced by FreeAtomExpr(), FreePattern(), and OBSmartsPattern::ParseAtomExpr().

## BuildAtomPred()

AtomExpr * BuildAtomPred | ( | int | type | ) |

static

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

## BuildAtomLeaf()

AtomExpr * BuildAtomLeaf | ( | int | type,
|  | int | val )

static

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

## BuildAtomNot()

AtomExpr * BuildAtomNot | ( | AtomExpr * | expr | ) |

static

Referenced by OBSmartsPattern::ParseAtomExpr().

## BuildAtomBin()

AtomExpr * BuildAtomBin | ( | int | op,
|  | AtomExpr * | lft,
|  | AtomExpr * | rgt )

static

Referenced by OBSmartsPattern::ParseAtomExpr().

## BuildAtomRecurs()

AtomExpr * BuildAtomRecurs | ( | Pattern * | pat | ) |

static

Referenced by OBSmartsPattern::ParseComplexAtomPrimitive().

## GenerateElement()

AtomExpr * GenerateElement | ( | int | elem | ) |

static

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

## GenerateAromElem()

AtomExpr * GenerateAromElem | ( | int | elem,
|  | int | flag )

static

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

## CopyBondExpr()

BondExpr * CopyBondExpr | ( | BondExpr * | expr | ) |

static

Referenced by CopyBondExpr(), and CopyPattern().

## EquivalentBondExpr()

bool 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 EquivalentBondExpr(), and OBSmartsPattern::SMARTSParser().

## FreeBondExpr()

void FreeBondExpr | ( | BondExpr * | expr | ) |

static

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

## BuildBondLeaf()

BondExpr * BuildBondLeaf | ( | int | type | ) |

static

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

## BuildBondNot()

BondExpr * BuildBondNot | ( | BondExpr * | expr | ) |

static

Referenced by OBSmartsPattern::ParseBondExpr().

## BuildBondBin()

BondExpr * BuildBondBin | ( | int | op,
|  | BondExpr * | lft,
|  | BondExpr * | rgt )

static

Referenced by OBSmartsPattern::ParseBondExpr().

## GenerateDefaultBond()

BondExpr * GenerateDefaultBond | ( | void |  | ) |

static

Referenced by OBSmartsPattern::SMARTSParser().

## AllocPattern()

Pattern * AllocPattern | ( | void |  | ) |

static

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

## CreateBond()

int CreateBond | ( | Pattern * | pat,
|  | BondExpr * | expr,
|  | int | src,
|  | int | dst )

static

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

## MarkGrowBonds()

void MarkGrowBonds | ( | Pattern * | pat | ) |

static

Referenced by OBSmartsPattern::ParseSMARTSPart().

## GetChiralFlag()

int GetChiralFlag | ( | AtomExpr * | expr | ) |

static

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

## GetExprOrder()

int GetExprOrder | ( | BondExpr * | expr | ) |

static

Referenced by OBSmartsPattern::GetBond(), and GetExprOrder().

## GetExprCharge()

int GetExprCharge | ( | AtomExpr * | expr | ) |

static

Referenced by OBSmartsPattern::GetCharge(), and GetExprCharge().

## GetExprAtomicNum()

int GetExprAtomicNum | ( | AtomExpr * | expr | ) |

static

Referenced by OBSmartsPattern::GetAtomicNum(), and GetExprAtomicNum().

## isqrt()

unsigned int isqrt | ( | unsigned int | val | ) |

static

Referenced by IsOddPrime().

## IsOddPrime()

int IsOddPrime | ( | unsigned int | x | ) |

static

Referenced by DetermineFactors().

## RelativelyPrime()

int RelativelyPrime | ( | unsigned int | x,
|  | unsigned int | y )

static

Referenced by DetermineIncrement().

## DoubleAdd()

void DoubleAdd | ( | DoubleType * | x,
|  | unsigned int | y )

static

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

## DoubleMultiply()

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

static

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

## LeadingZeros()

int LeadingZeros | ( | unsigned int | x | ) |

static

Referenced by DoubleModulus().

## DoubleModulus()

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

static

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

## DeterminePotency()

int DeterminePotency | ( | unsigned int | m,
|  | unsigned int | a )

static

Referenced by DetermineSequence().

## DetermineFactors()

int DetermineFactors | ( | unsigned int | x,
|  | unsigned int * | factors )

static

Referenced by DetermineSequence().

## DetermineIncrement()

unsigned int DetermineIncrement | ( | unsigned int | m | ) |

static

Referenced by DetermineSequence().

## DetermineSequence()

int DetermineSequence | ( | unsigned int | m,
|  | unsigned int * | pm,
|  | unsigned int * | pa,
|  | unsigned int * | pc )

static

Referenced by OBRandom::OBRandom().

## GenerateSequence()

void GenerateSequence | ( | unsigned int | p,
|  | unsigned int | m,
|  | unsigned int | a,
|  | unsigned int | c )

static

## GetAtomIDNumber()

unsigned int GetAtomIDNumber | ( | const char * | atomid | ) |

static

Referenced by OBResidue::GetAtomProperty().

## GetResidueNumber()

unsigned int GetResidueNumber | ( | const char * | res | ) |

static

Referenced by SetResidueKeys().

## SetResidueKeys()

void SetResidueKeys | ( | const char * | residue,
|  | unsigned int & | reskey,
|  | unsigned int & | aakey )

static

Referenced by OBResidue::SetName().

## DetermineFRJ()

int DetermineFRJ | ( | OBMol & | mol | ) |

static

Referenced by OBMol::FindLSSR(), and OBMol::FindSSSR().

## BuildOBRTreeVector()

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

static

Referenced by OBRingSearch::AddRingFromClosure().

## atomRingToBondRing()

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

Referenced by visitRing().

## visitRing()

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

## FindRingAtomsAndBonds2()

unsigned int FindRingAtomsAndBonds2 | ( | OBMol & | mol | ) |

static

Referenced by DetermineFRJ(), and OBMol::FindRingAtomsAndBonds().

## FindRings()

int FindRings | ( | OBAtom * | atom,
|  | int * | avisit,
|  | unsigned char * | bvisit,
|  | unsigned int & | frj,
|  | int | depth )

static

Referenced by FindRingAtomsAndBonds2(), and FindRings().

## rint()

double rint | ( | double | x | ) |

inline

Referenced by OBRotamerList::AddRotamer(), OBRotamerList::AddRotamer(), OBRotamerList::AddRotamer(), and OBRotamerList::AddRotamer().

## SetRotorToAngle() [2/2]

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

## PackCoordinate()

int PackCoordinate | ( | double | c[3],
|  | double | max[3] )

## UnpackCoordinate()

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

## GetDFFVector()

bool GetDFFVector | ( | OBMol & | mol,
|  | vector< int > & | dffv,
|  | OBBitVec & | bv )

static

Referenced by OBRotorList::SetRotAtomsByFix().

## CompareRotor() [2/2]

bool CompareRotor | ( | const pair< OBBond *, int > & | a,
|  | const pair< OBBond *, int > & | b )

static

## trim_spaces()

char * trim_spaces | ( | char * | string | ) |

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

## FindExocyclicAtom()

ExocyclicAtom FindExocyclicAtom | ( | OBAtom * | atm | ) |

static

Referenced by AssignOBAromaticityModel().

## HasExocyclicBondToOxygenMinus()

bool HasExocyclicBondToOxygenMinus | ( | OBAtom * | atm | ) |

static

Referenced by AssignOBAromaticityModel().

## HasExocyclicDblBondToOxygen()

bool HasExocyclicDblBondToOxygen | ( | OBAtom * | atm | ) |

static

Referenced by AssignOBAromaticityModel().

## HasExocyclicDblBondToHet()

bool HasExocyclicDblBondToHet | ( | OBAtom * | atm | ) |

static

Referenced by AssignOBAromaticityModel().

## AssignOBAromaticityModel()

bool AssignOBAromaticityModel | ( | OBAtom * | atm,
|  | int & | min,
|  | int & | max )

static

## eval_horn_NR_corrxn()

double eval_horn_NR_corrxn | ( | const vector< double > & | c,
|  | const double | x )

static

Referenced by QCProot().

## QCProot()

double QCProot | ( | const vector< double > & | coeff,
|  | double | guess,
|  | const double | delta )

static

## CalcQuarticCoeffs()

vector< double > CalcQuarticCoeffs | ( | const Eigen::Matrix3d & | M | ) |

## operator*() [4/4]

matrix3x3 operator* | ( | const matrix3x3 & | A,
|  | const matrix3x3 & | B )

## SQUARE()

double SQUARE | ( | double | x | ) |

inline static

## operator<<() [4/4]

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

## RemoveWhiteSpaceUnderscore()

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

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

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

## VZero()

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

## VX()

const vector3 VX | ( | 1. | 0,
|  | 0. | 0,
|  | 0. | 0 )

## VY()

const vector3 VY | ( | 0. | 0,
|  | 1. | 0,
|  | 0. | 0 )

## VZ()

const vector3 VZ | ( | 0. | 0,
|  | 0. | 0,
|  | 1. | 0 )

## getdelta()

int getdelta | ( | int | x,
|  | int | y,
|  | int | x2,
|  | int | y2 )

Referenced by ASCIIPainter::Bresenham().

## getsymbols()

string getsymbols | ( | int | x,
|  | int | y,
|  | int | x2,
|  | int | y2 )

Referenced by ASCIIPainter::Bresenham().

## writeFunction()

cairo_status_t writeFunction | ( | void * | closure,
|  | const unsigned char * | data,
|  | unsigned int | length )

static

Referenced by CairoPainter::WriteImage().

## GetLabelAlignment()

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

Referenced by OBDepict::DrawMolecule().

## GetAtomSymClass()

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

Referenced by OBDepict::AddAtomLabels().

## AssignRadicalDots()

Radical AssignRadicalDots | ( | OBAtom * | atom | ) |

static

Referenced by OBDepict::DrawMolecule().

## Variable Documentation

## AliasDataType

const unsigned int AliasDataType = 0x7883

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

## chainsparser

OBChainsParser chainsparser

Global OBChainsParser for detecting macromolecular chains and residues.

Referenced by OBAtom::GetResidue().

## ttab

OBTypeTable ttab

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

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

## resdat

OBResidueData resdat

Global OBResidueData biomolecule residue database.

## HARTEE_TO_KCALPERMOL

const double HARTEE_TO_KCALPERMOL = 627.509469

Referenced by UnitNameToConversionFactor().

## HARTREE_TO_KJPERMOL

const double HARTREE_TO_KJPERMOL = 2625.49962

## KJPERMOL_TO_KCALPERMOL

const double KJPERMOL_TO_KCALPERMOL = 1.0/4.184

Referenced by UnitNameToConversionFactor().

## RYDBERG_TO_KCALPERMOL

const double RYDBERG_TO_KCALPERMOL = 313.755026

Referenced by UnitNameToConversionFactor().

## ELECTRONVOLT_TO_KCALPERMOL

const double ELECTRONVOLT_TO_KCALPERMOL = 23.060538

Referenced by UnitNameToConversionFactor().

## KCAL_TO_KJ

const double KCAL_TO_KJ = 4.1868

## GAS_CONSTANT

const double GAS_CONSTANT = 8.31446261815324e-3 / KCAL_TO_KJ

kcal mol^-1 K^-1 (2018 CODATA recommended value)

Referenced by OBForceField::CorrectVelocities(), and OBForceField::GenerateVelocities().

## RateData

const unsigned RateData = 55555

Referenced by OBRateData::OBRateData().

## ThermoData

const unsigned ThermoData = 55556

Referenced by OBNasaThermoData::OBNasaThermoData().

## obLocale

OBLocale obLocale

Global OBLocale for setting and restoring locale information.

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

## MAXBONDS

const int MAXBONDS =300

static

Referenced by alternate(), and getBondMCDL().

## MAXFRAGS

const int MAXFRAGS =200

static

## MAXCHARS

const int MAXCHARS =1000

static

## MAX_DEPTH

const int MAX_DEPTH =10

static

## NELEMMAX

const int NELEMMAX =120

static

## NoId

const unsigned long NoId = detail::max_value<unsigned long>::result

static

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

## obErrorLog

OBMessageHandler obErrorLog

Global OBMessageHandler error handler.

Referenced by FastSearchIndexer::Add(), OBMol::AddBond(), OBConversion::AddChemObject(), OBMol::AddNewHydrogens(), OBDescriptor::AddProperties(), OBBuilder::AddRingFragment(), OBAlign::Align(), OBMol::Align(), AllocateByteCode(), OBChemTsfm::Apply(), patty::assign_types(), patty::assign_types(), OBAromaticTyper::AssignAromaticFlags(), OBAtomTyper::AssignHyb(), OBGastChrg::AssignPartialCharges(), OBMol::AssignTotalChargeToAtoms(), OBAtomTyper::AssignTypes(), OBRingTyper::AssignTypes(), OBBuilder::Build(), CartesianToInternal(), OBMol::Center(), OBConversion::CheckForUnintendedBatch(), FptIndex::CheckFP(), OBMol::Clear(), OBDescriptor::Compare(), OBMol::ConnectTheDots(), OBConversion::Convert(), OBMol::ConvertDativeBonds(), OBMol::CorrectForPH(), OBPhModel::CorrectForPH(), OBBuilder::CorrectStereoAtoms(), OBMoleculeFormat::DeferMolOutput(), OBMol::DeleteHydrogens(), OBMol::DeleteNonPolarHydrogens(), OBMol::DeletePolarHydrogens(), DeleteStereoOnAtom(), OBMol::DoTransformations(), OBMol::EndModify(), AliasData::Expand(), FatalAllocationError(), FatalMemoryError(), OBDescriptor::FilterCompare(), FastSearch::Find(), SpaceGroup::Find(), OBMol::FindLSSR(), OBMol::FindRingAtomsAndBonds(), OBRotorList::FindRotors(), OBMol::FindSSSR(), OBFingerprint::Fold(), OBBitVec::FromString(), OBConversion::FullConvert(), GenerateByteCodes(), OBAlign::GetAlignment(), OBMol::GetAtom(), OBMol::GetAtomById(), GetAtomIDNumber(), OBMol::GetBond(), OBMol::GetBondById(), OBMol::GetFormula(), OBBuilder::GetFragmentCoord(), OBDescriptor::GetIdentifier(), OBMol::GetResidue(), OBAlign::GetRMSD(), OBAlign::GetRotMatrix(), OBRotorRules::GetRotorIncrements(), OBMol::GetSpacedFormula(), OBMol::GetTotalCharge(), OBMol::GetTotalSpinMultiplicity(), OBDescriptor::GetValues(), OBAtom::HtoMethyl(), OBGlobalDataBase::Init(), InternalToCartesian(), OBPlugin::LoadAllPlugins(), OBBuilder::LoadFragments(), OBMoleculeFormat::MakeCombinedMolecule(), OBConversion::NumInputObjects(), OBConversion::OpenAndSetFormat(), OBConversion::OpenInAndOutFiles(), DLHandler::openLib(), OBBitVec::operator>>, OBAtomTyper::ParseLine(), OBBondTyper::ParseLine(), OBPhModel::ParseLine(), OBRingTyper::ParseLine(), OBRotorRules::ParseLine(), OBTypeTable::ParseLine(), OBMol::PerceiveBondOrders(), OBChainsParser::PerceiveChains(), patty::read_rules(), OBConversion::ReadFile(), OBMoleculeFormat::ReadNameIndex(), OBDescriptor::ReadStringFromFilter(), OBConversion::RegisterOptionParam(), OBMol::RenumberAtoms(), OBMol::Rotate(), SafeOpen(), SafeOpen(), OBTypeTable::SetFromType(), OBAtom::SetHybAndGeom(), OBMol::SetInternalCoord(), OBBond::SetLength(), OBMol::SetTorsion(), OBTypeTable::SetToType(), OBRotorList::Setup(), OBSmartsPattern::SMARTSError(), OBMol::StripSalts(), obLogBuf::sync(), ThrowError(), ThrowError(), OBTetraNonPlanarStereo::ToConfig(), OBMol::ToInertialFrame(), OBMol::Translate(), OBTypeTable::Translate(), OBTypeTable::Translate(), patty::type_to_int(), UnitNameToConversionFactor(), OBAlign::UpdateCoords(), OBMoleculeFormat::WriteChemObjectImpl(), OBConversion::WriteFile(), and FastSearchIndexer::~FastSearchIndexer().

## atomtyper

THREAD_LOCAL OBAtomTyper atomtyper

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

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

## aromtyper

THREAD_LOCAL OBAromaticTyper aromtyper

Global OBAromaticTyper for detecting aromatic atoms and bonds.

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

## VZero

const vector3 VZero(0.0, 0.0, 0.0)

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

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

## VX

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

## VY

const vector3 VY(0.0, 1.0, 0.0)

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

Referenced by InternalToCartesian().

## VZ

const vector3 VZ(0.0, 0.0, 1.0)

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

Referenced by OBBuilder::GetNewBondVector().

## bitsoff

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

## nibble_bit_count

const unsigned nibble_bit_count[0x10]

Initial value:
=
{
0,
1,
1,
2,
1,
2,
2,
3,
1,
2,
2,
3,
2,
3,
3,
4
}

Referenced by OBBitVec::CountBits().

## bondtyper

THREAD_LOCAL OBBondTyper bondtyper

Global OBBondTyper for perception of bond order assignment.

Referenced by OBMol::PerceiveBondOrders().

## Peptide

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)

## Nucleotide

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.

## ChainsAtomName

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

## AminoAcids

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

## Nucleotides

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

## MonoAtom

MonoAtomType MonoAtom[MaxMonoAtom]

static

Referenced by GenerateByteCodes().

## MonoBond

MonoBondType MonoBond[MaxMonoBond]

static

Referenced by GenerateByteCodes().

## MonoAtomCount

int MonoAtomCount

static

Referenced by GenerateByteCodes().

## MonoBondCount

int MonoBondCount

static

Referenced by GenerateByteCodes().

## Stack

StackType Stack[STACKSIZE]

static

Referenced by GenerateByteCodes().

## StackPtr

int StackPtr

static

Referenced by GenerateByteCodes().

## AtomIndex

int AtomIndex

static

Referenced by GenerateByteCodes().

## BondIndex

int BondIndex

static

Referenced by GenerateByteCodes().

## StrictFlag

bool StrictFlag = false

static

Referenced by GenerateByteCodes().

## red

const char* red = "\033[1;31m"

static

## green

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

static

## yellow

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

static

## blue

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

static

## normal

const char* normal = "\033[0m"

static

Referenced by Point2PlaneAngle().

## hVal

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(), alternate(), hydrogenValency(), and parseFormula().

## maxVal

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(), alternate(), and maxValency().

## chargeVal

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}

## aSymb

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(), getAtomSymbol(), and parseFormula().

## exactAtom

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}

## alkaly

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

## alkalyEarth

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

## trivalent

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}

## titan

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

## vanadium

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

## cromium

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

## manganeze

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

## likeFe

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

## platinum

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

## copper

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

## zink

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

## possibleAromatic

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

## metals

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}

Referenced by OBAtom::IsMetal().

## lightMetals

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}

## heavyMetals

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}

## halogens

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

## hetero

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

## strData

const string strData[NDATABASE_MOLECULES]

## bondValence

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

## fsastart

const string fsastart ="{SA:"

Referenced by getAtomMCDL().

## fsbstart

const string fsbstart ="{SB:"

Referenced by getBondMCDL().

## SwabInt

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

## phmodel

THREAD_LOCAL OBPhModel phmodel

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

## Roots

double Roots[4]

static

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

## SmartsImplicitRef

const int SmartsImplicitRef = -9999

Referenced by OBSmartsMatcher::match(), and OBSmartsPattern::SMARTSParser().

## PointGroups

POINT_GROUP PointGroups[]

Referenced by OBPointGroup::IdentifyPointGroup(), and OBPointGroup::IdentifyPointGroupSymbol().

## primes

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

## Residue

char Residue[MAXRES][4]

## ElemDesc

char ElemDesc[MAXELEM][4]

## ringtyper

OBRingTyper ringtyper

Referenced by OBRing::GetType().

## SINT

int SINT = 0x00000001

static

## STPTR

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

static

## _SpaceGroups

SpaceGroups _SpaceGroups

static

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