Namespaces
	detail

	OBAminoAcidProperty

	OBElements

	OBGenericDataType

	OBResidueAtomProperty

	OBResidueIndex

	OBResidueProperty

Classes
union	_AtomExpr

union	_BondExpr

class	AliasData

class	ASCIIPainter

struct	AtomSpec

struct	BondSpec

class	CairoPainter

struct	CharPtrLess

class	CommandPainter

struct	DeleteObject

struct	DoubleType

class	FastSearch

class	FastSearchIndexer

class	FilteringInputStream

class	FilteringInputStreambuf

struct	FptIndex

struct	FptIndexHeader

class	GasteigerState

class	LineEndingExtractor

struct	LineSearchType

class	matrix3x3

class	OBAlign

class	OBAngle

class	OBAngleData

class	OBAromaticTyper

class	OBAtom

class	OBAtomAtomIter

class	OBAtomBondIter

class	OBAtomHOF

class	OBAtomicHeatOfFormationTable

class	OBAtomTyper

class	OBBase

class	OBBitVec

class	OBBond

class	OBBondTyper

class	OBBuilder

class	OBChainsParser

class	OBChargeModel

class	OBChemTsfm

struct	OBCisTransConfig

class	OBCisTransStereo

class	OBColor

class	OBCommentData

class	OBConformerData

class	OBConformerFilter

class	OBConformerFilters

class	OBConformerScore

class	OBConformerSearch

class	OBConversion

class	OBDepict

class	OBDescriptor

class	OBDOSData

class	OBElectronicTransitionData

class	OBEnergyConformerScore

class	OBError

class	OBExternalBond

class	OBExternalBondData

class	OBFFCalculation2

class	OBFFCalculation3

class	OBFFCalculation4

class	OBFFConstraint

class	OBFFConstraints

class	OBFFParameter

class	OBFingerprint

class	OBFloatGrid

class	OBFontMetrics

class	OBForceField

class	OBFormat

class	OBFreeGrid

class	OBFreeGridPoint

class	OBGastChrg

class	OBGenericData

class	OBGlobalDataBase

class	OBGraphSym

class	OBGrid

class	OBGridData

class	OBGroupContrib

class	OBInternalCoord

class	OBIsomorphismMapper

class	OBLocale

class	obLogBuf

class	OBMatrixData

class	OBMessageHandler

class	OBMinimizingEnergyConformerScore

class	OBMinimizingRMSDConformerScore

class	OBMol

class	OBMolAngleIter

class	OBMolAtomBFSIter

class	OBMolAtomDFSIter

class	OBMolAtomIter

class	OBMolBondBFSIter

class	OBMolBondIter

class	OBMoleculeFormat

class	OBMolPairIter

class	OBMolRingIter

class	OBMolTorsionIter

class	OBNasaThermoData

class	OBOp

class	OBOrbital

class	OBOrbitalData

class	OBPainter

class	OBPairData

class	OBPairTemplate

class	OBPcharge

class	OBPhModel

class	OBPlugin

class	OBPointGroup

class	OBProxGrid

class	OBQuery

class	OBQueryAtom

class	OBQueryBond

class	OBRandom

class	OBRateData

class	OBReaction

class	OBReactionFacade

class	OBResidue

class	OBResidueAtomIter

class	OBResidueData

class	OBResidueIter

class	OBRing

class	OBRingData

class	OBRingSearch

class	OBRingTyper

class	OBRMSDConformerScore

class	OBRotamerList

class	OBRotationData

class	OBRotor

class	OBRotorKeys

class	OBRotorList

class	OBRotorRule

class	OBRotorRules

class	OBRTree

class	OBScoreGrid

class	OBSerialNums

class	OBSetData

class	OBSmartsMatcher

class	OBSmartsPattern

class	OBSpectrophore

class	OBSqrtTbl

struct	OBSquarePlanarConfig

class	OBSquarePlanarStereo

class	OBSSMatch

class	OBStereo

class	OBStereoBase

class	OBStereoFacade

struct	OBStereoUnit

class	OBStericConformerFilter

class	OBStopwatch

class	OBSymmetryData

struct	OBTetrahedralConfig

class	OBTetrahedralStereo

class	OBTetraNonPlanarStereo

class	OBTetraPlanarStereo

class	OBText

class	OBTorsion

class	OBTorsionData

class	OBTypeTable

class	OBUnitCell

class	OBVectorData

class	OBVibrationData

class	OBVirtualBond

class	OpTransform

struct	ParseState

struct	Pattern

class	patty

class	quad

class	SpaceGroup

class	TautomerFunctor

class	transform3d

class	triple

class	vector3

class	XMLBaseFormat

class	XMLConversion

class	XMLMoleculeFormat

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)

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

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

bool	IsNear (const double &a, const double &b, const double epsilon)

bool	IsNearZero (const double &a, const double epsilon)

bool	IsNan (const double &a)

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

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

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

bool	CanBeSquared (const double &)

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

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

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

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=" \\)

bool	tokenize (std::vector< std::string > &, std::string &, const char *delimstr=" \\, 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 (int, GetSpaceGroupNumber, std::string)

	OBUNITCELL_CALL_CONST_OVERLOAD (double, GetCellVolume)

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

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

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

ostream &	operator<< (ostream &os, const OBFloatGrid &fg)

istream &	operator>> (istream &is, OBFloatGrid &fg)

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

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

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

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

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)

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

static unsigned int	isqrt (unsigned int val)

static int	IsOddPrime (unsigned int x)

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

static 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<< (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 *)

High level functions
void	PerceiveStereo (OBMol *mol, bool force=false)

void	StereoFrom2D (OBMol mol, std::map< OBBond , enum OBStereo::BondDirection > *updown=NULL, bool force=false)

void	StereoFrom3D (OBMol *mol, bool force=false)

void	StereoFrom0D (OBMol *mol)

Low level functions
std::vector< OBTetrahedralStereo * >	TetrahedralFrom3D (OBMol *mol, const OBStereoUnitSet &stereoUnits, bool addToMol=true)

std::vector< OBTetrahedralStereo * >	TetrahedralFrom2D (OBMol *mol, const OBStereoUnitSet &stereoUnits, bool addToMol=true)

std::vector< OBTetrahedralStereo * >	TetrahedralFrom0D (OBMol *mol, const OBStereoUnitSet &stereoUnits, bool addToMol=true)

std::vector< OBCisTransStereo * >	CisTransFrom3D (OBMol *mol, const OBStereoUnitSet &stereoUnits, bool addToMol=true)

std::vector< OBCisTransStereo * >	CisTransFrom2D (OBMol mol, const OBStereoUnitSet &stereoUnits, const std::map< OBBond , enum OBStereo::BondDirection > *updown=NULL, bool addToMol=true)

bool	TetStereoToWedgeHash (OBMol &mol, std::map< OBBond , enum OBStereo::BondDirection > &updown, std::map< OBBond , OBStereo::Ref > &from)

std::set< OBBond * >	GetUnspecifiedCisTrans (OBMol &mol)

void	StereoRefToImplicit (OBMol &mol, OBStereo::Ref atomId)

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

OBChainsParser	chainsparser

OBTypeTable	ttab

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 OBAtomTyper	atomtyper

THREAD_LOCAL OBAromaticTyper	aromtyper

const vector3	VZero

const vector3	VX

const vector3	VY

const vector3	VZ

THREAD_LOCAL OBPhModel	phmodel

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)

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

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

Referenced by OBFingerprint::DescribeBits(), FastSearch::FindSimilar(), and OBBitVec::operator[]().

◆ 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

Referenced by print_sym_classes().

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

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

◆ maxValency()

int maxValency ( int na )

Referenced by alternate().

◆ alternate() [1/3]

int OpenBabel::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
	)

Referenced by alternate().

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

Referenced by compareAtoms(), and intToStr().

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

Referenced by alternate().

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

Referenced by AliasData::Expand().

◆ 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

Referenced by OBMol::NextInternalCoord().

◆ 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 OpenBabel::CartesianToInternal	(	std::vector< OBInternalCoord * > &	vic,
		OBMol &	mol
	)

Convert Cartesian XYZ to a set of OBInternalCoord coordinates.

Use the supplied OBMol and its Cartesian coordinates to generate a set of internal (z-matrix) coordinates as supplied in the vector<OBInternalCoord*> argument. Implements blue-obelisk:cartesianCoordinatesIntoZmatrixCoordinates.

Referenced by OBMol::GetInternalCoord(), and OBMol::NextInternalCoord().

◆ InternalToCartesian()

void OpenBabel::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

Referenced by OBMol::NextInternalCoord().

◆ NewExtension()

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

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

Referenced by OBMol::NextInternalCoord().

◆ 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 OpenBabel::rotate_coords	(	double *	,
		double	m[3][3],
		unsigned
	)

Referenced by OBSqrtTbl::Init().

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

Referenced by OBSqrtTbl::Init().

◆ ToUpper() [1/2]

void ToUpper ( std::string & s )

Shift the supplied string to uppercase.

Referenced by OBSqrtTbl::Init().

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

Referenced by OBSqrtTbl::Init().

◆ ToLower() [2/2]

void ToLower ( char * cptr )

Shift the supplied char* to lowercase.

◆ InvertCase() [1/3]

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

Referenced by OBSqrtTbl::Init().

◆ 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

Referenced by OBSqrtTbl::Init().

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

Referenced by OBSqrtTbl::Init().

◆ 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(), and OBSqrtTbl::Init().

◆ 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(), OBSqrtTbl::Init(), 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 OBGastChrg::AssignPartialCharges(), OBAtom::GetAngle(), OBMol::Has2D(), OBMol::Has3D(), OBSqrtTbl::Init(), OBForceField::Newton2NumLineSearch(), OBBond::SetLength(), OBForceField::VectorAngle(), OBForceField::VectorAngleDerivative(), OBForceField::VectorOOP(), OBForceField::VectorOOPDerivative(), OBForceField::VectorTorsion(), and OBForceField::VectorTorsionDerivative().

◆ IsNan()

bool IsNan ( const double & a )

Comparison for nan (not a number)

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

◆ IsNegligible()

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

inline

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

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

◆ IsApprox()

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

inline

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

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

Referenced by OBUnitCell::GetLatticeType(), matrix3x3::isSymmetric(), matrix3x3::isUnitMatrix(), vector3::operator!=(), and OBMol::PerceiveBondOrders().

◆ IsApprox_pos()

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

inline

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

◆ CanBeSquared()

bool CanBeSquared ( const double & a )

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

Referenced by vector3::CanBeNormalized(), and IsApprox_pos().

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

◆ 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() [1/2]

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

◆ 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 OBRing::GetParent(), and OBRingSearch::SortRings().

◆ Swab()

int Swab ( int i )

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

Referenced by OBRotamerList::NumAtoms().

◆ 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

Referenced by TautomerFunctor::~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.

Referenced by TautomerFunctor::~TautomerFunctor().

◆ tokenize() [1/2]

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

Break a string (supplied as the second argument) into tokens, returned in the first argument. Tokens are determined by the delimiters supplied (defaults to whitespace (i.e., spaces, tabs, newlines)

Referenced by patty::assign_rules(), OBDescriptor::DeleteProperties(), OBMol::DoTransformations(), AliasData::Expand(), DLHandler::findFiles(), OBBuilder::GetFragmentCoord(), OBBuilder::LoadFragments(), OBBondTyper::ParseLine(), OBAtomTyper::ParseLine(), OBRingTyper::ParseLine(), OBRotorRules::ParseLine(), OBPhModel::ParseLine(), OBAtomicHeatOfFormationTable::ParseLine(), OBTypeTable::ParseLine(), OBResidueData::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(), and OBMol::SetTitle().

◆ toString()

std::string OpenBabel::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 upto the occurence of a string

Parameters

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

Returns: the stream.

Referenced by DeleteObject::operator()().

◆ 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 alternate(), AliasData::Expand(), OBBuilder::GetFragmentCoord(), OBGlobalDataBase::Init(), OBBuilder::LoadFragments(), DeleteObject::operator()(), and OBMoleculeFormat::ReadNameIndex().

◆ center_coords() [1/2]

vector3 OpenBabel::center_coords	(	double *	,
		int
	)

Referenced by matrix3x3::operator/=().

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

Referenced by OBFloatGrid::Center(), vector3::distSq(), OBSquarePlanarStereo::operator!=(), OBTetrahedralStereo::operator!=(), OBCisTransStereo::operator!=(), matrix3x3::operator/=(), and OBBitVec::operator[]().

◆ operator+()

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

inline

Vector addition.

◆ operator-() [1/3]

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

inline

Vector subtraction.

Referenced by OBBitVec::operator[]().

◆ operator-() [2/3]

vector3 OpenBabel::operator- ( const vector3 & v )

inline

Unary minus.

◆ operator*() [1/4]

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

inline

Multiplication with a scalar.

Referenced by operator/(), matrix3x3::operator/=(), and transform3d::transform3d().

◆ operator*() [2/4]

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

inline

Multiplication with a scalar.

◆ operator/()

vector3 OpenBabel::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 OpenBabel::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(), OBBuilder::Build(), CalcTorsionAngle(), OBBuilder::Connect(), dot(), OBDepict::DrawMolecule(), 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(), OBAtom::AverageBondAngle(), OBBuilder::Build(), CartesianToInternal(), OBBuilder::Connect(), dot(), OBUnitCell::GetAlpha(), OBAtom::GetAngle(), OBUnitCell::GetBeta(), OBUnitCell::GetGamma(), Point2PlaneAngle(), OBUnitCell::SetData(), OBAtom::SetHybAndGeom(), OBAtom::SmallestBondAngle(), 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(), dot(), OBMol::GetTorsion(), OBBond::IsDoubleBondGeometry(), 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 dot(), and 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.

Referenced by dot().

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

Referenced by dot().

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

Referenced by dot().

◆ IsSulfoneOxygen()

static bool OpenBabel::IsSulfoneOxygen ( OBAtom * atm )

static

Referenced by OBAtom::IsHbondAcceptor().

◆ CorrectedBondRad() [1/3]

static double OpenBabel::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 OBAtom::HtoMethyl(), OBMol::PerceiveBondOrders(), and OBAtom::SetHybAndGeom().

◆ ApplyRotMatToBond()

static void OpenBabel::ApplyRotMatToBond	(	OBMol &	mol,
		matrix3x3 &	m,
		OBAtom *	a1,
		OBAtom *	a2
	)

static

Referenced by OBAtom::SetHybAndGeom().

◆ operator|()

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

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

Parameters

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

Returns: A bit vector

Referenced by OBBitVec::operator[]().

◆ operator &()

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

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

Parameters

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

Returns: A bit vector

Referenced by OBBitVec::operator[]().

◆ operator^()

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

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

Parameters

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

Returns: A bit vector

Referenced by OBBitVec::operator[]().

◆ operator-() [3/3]

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

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

Parameters

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

Returns: A bit vector

◆ operator==()

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

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

Parameters

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

Returns: true if equal, false otherwise

Referenced by OBSquarePlanarStereo::Config::Config(), OBTetrahedralStereo::Config::Config(), OBCisTransStereo::Config::Config(), OBError::GetLevel(), SpaceGroup::GetOriginAlternative(), OBSquarePlanarStereo::GetType(), OBTetrahedralStereo::GetType(), OBCisTransStereo::GetType(), OBBitVec::operator[](), vector3::z(), and OBAngle::~OBAngle().

◆ operator<()

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

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

Parameters

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

Returns: true if equal, false otherwise

Referenced by findMetalloceneBonds(), and OBBitVec::operator[]().

◆ operator>>() [1/2]

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

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

Parameters

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

Referenced by OBFloatGrid::Center(), and OBBitVec::operator[]().

◆ operator<<() [2/4]

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

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

Parameters

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

◆ CorrectedBondRad() [2/3]

static double OpenBabel::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 OBBond::GetEquibLength().

◆ GetCorrectedBondVector()

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

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

◆ TotalHydrogenCount()

static unsigned int OpenBabel::TotalHydrogenCount ( OBAtom * atom )

static

Referenced by findMetalloceneBonds().

◆ CompareBondPairSecond()

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

inline

Referenced by findMetalloceneBonds().

◆ addNbrs()

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

Helper function for getFragment below.

Referenced by 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 OpenBabel::getFragment	(	OBAtom *	atom,
		OBAtom *	skip,
		const OBBitVec &	mask
	)

Referenced by findMetalloceneBonds().

◆ isFerroceneBond()

bool isFerroceneBond ( OBBond * bond )

Referenced by CompileAutomorphismQuery(), findMetalloceneBonds(), and OBIsomorphismMapper::GetInstance().

◆ findMetalloceneBonds()

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

Referenced by CanonicalLabels().

◆ AllocateByteCode()

static ByteCode* OpenBabel::AllocateByteCode ( int type )

static

Referenced by GenerateByteCodes().

◆ DeleteByteCode()

static void OpenBabel::DeleteByteCode ( ByteCode * node )

static

Free a ByteCode and all corresponding data.

Referenced by OBChainsParser::~OBChainsParser().

◆ FatalMemoryError()

static void OpenBabel::FatalMemoryError ( void )

static

Referenced by GenerateByteCodes().

◆ GenerateByteCodes()

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

Referenced by OBChainsParser::PerceiveChains().

◆ sortpred_b()

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

Referenced by UpdateConformersFromTree().

◆ GetHeavyAtomCoords()

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

◆ UpdateConformersFromTree()

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

◆ UnitNameToConversionFactor()

static double OpenBabel::UnitNameToConversionFactor ( const char * unit )

static

Referenced by OBAtomicHeatOfFormationTable::GetHeatOfFormation().

◆ Toupper()

void OpenBabel::Toupper ( string & s )

◆ Tolower()

void OpenBabel::Tolower ( string & s )

◆ Reweight()

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

Referenced by OBForceField::WeightedRotorSearch().

◆ areDuplicateAtoms()

bool OpenBabel::areDuplicateAtoms	(	vector3	v1,
		vector3	v2
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [1/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	double	,
		GetA
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [2/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	double	,
		GetB
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [3/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	double	,
		GetC
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [4/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	double	,
		GetAlpha
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [5/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	double	,
		GetBeta
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [6/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	double	,
		GetGamma
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [7/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	vector3	,
		GetOffset
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [1/6]

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

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [8/14]

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

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [9/14]

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

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [10/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	matrix3x3	,
		GetCellMatrix
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [11/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	matrix3x3	,
		GetOrthoMatrix
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [12/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	matrix3x3	,
		GetOrientationMatrix
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [13/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	matrix3x3	,
		GetFractionalMatrix
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [2/6]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD_ARG	(	vector3	,
		FractionalToCartesian	,
		vector3
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [3/6]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD_ARG	(	vector3	,
		CartesianToFractional	,
		vector3
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [4/6]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD_ARG	(	vector3	,
		WrapCartesianCoordinate	,
		vector3
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [5/6]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD_ARG	(	vector3	,
		WrapFractionalCoordinate	,
		vector3
	)

◆ OBUNITCELL_CALL_CONST_OVERLOAD_ARG() [6/6]

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

◆ OBUNITCELL_CALL_CONST_OVERLOAD() [14/14]

OpenBabel::OBUNITCELL_CALL_CONST_OVERLOAD	(	double	,
		GetCellVolume
	)

◆ CompareUnsigned()

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

inline

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

Referenced by ComparePairSecond().

◆ ComparePairFirst()

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

inline

◆ ComparePairSecond()

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

inline

◆ operator<<() [3/4]

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

◆ operator>>() [2/2]

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

◆ print_vector()

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

◆ CompileAutomorphismQuery()

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

Referenced by FindAutomorphisms().

◆ FindAutomorphisms() [1/2]

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

◆ FindAutomorphisms() [2/2]

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

◆ GetMaxAtomIdx()

static unsigned int OpenBabel::GetMaxAtomIdx ( OBMol * mol )

static

Referenced by GetMaxBondIdx().

◆ GetMaxBondIdx()

static unsigned int OpenBabel::GetMaxBondIdx ( OBMol * mol )

static

◆ IsSpecialCase()

static bool OpenBabel::IsSpecialCase ( OBAtom * atom )

static

Referenced by NeedsDoubleBond().

◆ NeedsDoubleBond()

static bool OpenBabel::NeedsDoubleBond ( OBAtom * atom )

static

◆ intToStr()

string OpenBabel::intToStr ( int k )

Referenced by getAtomMCDL(), getBondMCDL(), and ptInRect().

◆ xDistPoint()

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

Referenced by overlapped().

◆ overlapped()

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

◆ sproduct()

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

Referenced by getBondMCDL().

◆ compareAtoms()

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

◆ incrementValues()

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

◆ CompareRotor() [1/2]

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

◆ deleteIntElement()

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

Referenced by alternate().

◆ findAlternateSinglets()

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

static

Referenced by determineBondsOrder(), and makeAssignment().

◆ makeAssignment()

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

static

Referenced by determineBondsOrder().

◆ analyzeOK()

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

static

Referenced by determineBondsOrder().

◆ incrementAssignment()

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

static

Referenced by determineBondsOrder().

◆ determineBondsOrder()

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

static

Referenced by alternate().

◆ alternate() [3/3]

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

◆ ptInRect()

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

◆ compareStringsNumbers()

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

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

◆ getAtomSymbol() [1/2]

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

nepravil'no

◆ getAtomSymbol() [2/2]

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

Referenced by getAtomMCDL(), and getBondMCDL().

◆ indexOf()

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

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

◆ removeZeroeth()

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

Referenced by getAtomMCDL(), and getBondMCDL().

◆ analizeParity()

int OpenBabel::analizeParity ( string data )

Referenced by getAtomMCDL().

◆ analizeParityBond()

int OpenBabel::analizeParityBond ( string data )

Referenced by getBondMCDL().

◆ changeParity()

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

Referenced by getAtomMCDL().

◆ changeParityBond()

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

Referenced by getBondMCDL().

◆ bondEquivalent()

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

Referenced by alternate(), getBondMCDL(), and intToStr().

◆ addZeroeth()

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

Referenced by implementAtomStereo(), and implementBondStereo().

◆ setUpDownBonds()

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

!! By unknown reason inversion of configuration took place.

Referenced by implementAtomStereo().

◆ SortVVInt()

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

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

static

Referenced by ClassCount().

◆ OBComparePairFirst()

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

static

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

◆ ClassCount()

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

static

counts the number of unique symmetry classes in a list

Referenced by OBMol::GetGIDVector().

◆ CreateNewClassVector()

static void OpenBabel::CreateNewClassVector	(	vector< pair< OBAtom *, unsigned int > > &	vp1,
		vector< pair< OBAtom *, unsigned int > > &	vp2
	)

static

creates a new vector of symmetry classes base on an existing vector helper routine to GetGIDVector

Referenced by ComparePairSecond(), OBMol::GetGIDVector(), and print_sym_classes().

◆ IsSuppressibleHydrogen()

static bool OpenBabel::IsSuppressibleHydrogen ( OBAtom * atom )

static

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

◆ AtomIsNSOP()

static bool OpenBabel::AtomIsNSOP ( OBAtom * atom )

static

Referenced by OBMol::AddNewHydrogens().

◆ CorrectedBondRad() [3/3]

static double OpenBabel::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(), and OBMol::AddNewHydrogens().

◆ DeleteStereoOnAtom()

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

static

Referenced by OBMol::DeleteAtom().

◆ WriteTitles()

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

◆ validAdditionalBond()

static bool OpenBabel::validAdditionalBond	(	OBAtom *	a,
		OBAtom *	n
	)

static

Referenced by OBMol::ConnectTheDots().

◆ IsNotCorH()

static bool OpenBabel::IsNotCorH ( OBAtom * atom )

static

Referenced by OBMol::MakeDativeBonds().

◆ center_coords() [2/2]

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

Returns: the geometric centroid to an array of coordinates in double* format and center the coordinates to the origin. Operates on the first "size" coordinates in the array.

◆ rotate_coords() [2/2]

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

Rotates the coordinate set *c by the transformation matrix m[3][3] Operates on the first "size" coordinates in the array.

◆ SetRotorToAngle() [1/2]

void OpenBabel::SetRotorToAngle	(	double *	c,
		vector< int > &	tor,
		double	ang,
		vector< int > &	atoms
	)

Rotate the coordinates of 'atoms' such that tor == ang - atoms in 'tor' should be ordered such that the 3rd atom is the pivot around which atoms rotate

◆ SafeOpen() [3/4]

bool OpenBabel::SafeOpen	(	std::ifstream &	fs,
		const string &	filename
	)

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

◆ SafeOpen() [4/4]

bool OpenBabel::SafeOpen	(	std::ofstream &	fs,
		const string &	filename
	)

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

Referenced by SafeOpen().

◆ InvertCase() [3/3]

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

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

Parameters

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

◆ SolveLinear()

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

Referenced by SolveQuadratic().

◆ SolveQuadratic()

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

Referenced by SolveCubic().

◆ CubeRoot()

double OpenBabel::CubeRoot ( double X )

Referenced by SolveCubic().

◆ SolveCubic()

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

◆ get_roots_3_3()

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

static

Referenced by get_rmat(), and superimpose().

◆ CreateAtom()

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

static

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

◆ FatalAllocationError()

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

static

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

◆ FreePattern()

static void FreePattern ( Pattern * pat )

static

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

◆ CopyPattern()

static Pattern * CopyPattern ( Pattern * pat )

static

Referenced by CopyAtomExpr(), and FatalAllocationError().

◆ CopyAtomExpr()

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

static

Referenced by CopyPattern().

◆ FreeAtomExpr()

static void OpenBabel::FreeAtomExpr ( AtomExpr * expr )

static

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

◆ BuildAtomPred()

static AtomExpr* OpenBabel::BuildAtomPred ( int type )

static

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

◆ BuildAtomLeaf()

static AtomExpr* OpenBabel::BuildAtomLeaf	(	int	type,
		int	val
	)

static

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

◆ BuildAtomNot()

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

static

Referenced by OBSmartsPattern::ParseAtomExpr().

◆ BuildAtomBin()

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

static

Referenced by OBSmartsPattern::ParseAtomExpr().

◆ BuildAtomRecurs()

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

static

Referenced by OBSmartsPattern::ParseComplexAtomPrimitive().

◆ GenerateElement()

static AtomExpr* OpenBabel::GenerateElement ( int elem )

static

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

◆ GenerateAromElem()

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

static

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

◆ CopyBondExpr()

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

static

Referenced by CopyPattern().

◆ EquivalentBondExpr()

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

static

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

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

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

C1CCCCC#1 C1CCCCC=1

Referenced by OBSmartsPattern::SMARTSParser().

◆ FreeBondExpr()

static void OpenBabel::FreeBondExpr ( BondExpr * expr )

static

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

◆ BuildBondLeaf()

static BondExpr* OpenBabel::BuildBondLeaf ( int type )

static

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

◆ BuildBondNot()

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

static

Referenced by OBSmartsPattern::ParseBondExpr().

◆ BuildBondBin()

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

static

Referenced by OBSmartsPattern::ParseBondExpr().

◆ GenerateDefaultBond()

static BondExpr* OpenBabel::GenerateDefaultBond ( void )

static

Referenced by OBSmartsPattern::SMARTSParser().

◆ AllocPattern()

static Pattern* OpenBabel::AllocPattern ( void )

static

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

◆ CreateBond()

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

static

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

◆ MarkGrowBonds()

static void OpenBabel::MarkGrowBonds ( Pattern * pat )

static

Referenced by OBSmartsPattern::ParseSMARTSPart().

◆ GetChiralFlag()

static int OpenBabel::GetChiralFlag ( AtomExpr * expr )

static

Referenced by OBSmartsPattern::ParseSMARTSPart().

◆ GetExprOrder()

static int OpenBabel::GetExprOrder ( BondExpr * expr )

static

Referenced by OBSmartsPattern::GetBond().

◆ GetExprCharge()

static int OpenBabel::GetExprCharge ( AtomExpr * expr )

static

Referenced by OBSmartsPattern::GetCharge().

◆ GetExprAtomicNum()

static int OpenBabel::GetExprAtomicNum ( AtomExpr * expr )

static

Referenced by OBSmartsPattern::GetAtomicNum().

◆ SmartsLexReplace() [2/2]

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

◆ isqrt()

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

static

Referenced by IsOddPrime().

◆ IsOddPrime()

static int OpenBabel::IsOddPrime ( unsigned int x )

static

Referenced by DetermineFactors().

◆ RelativelyPrime()

static int OpenBabel::RelativelyPrime	(	unsigned int	x,
		unsigned int	y
	)

static

Referenced by DetermineIncrement().

◆ DoubleAdd()

static void OpenBabel::DoubleAdd	(	DoubleType *	x,
		unsigned int	y
	)

static

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

◆ DoubleMultiply()

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

static

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

◆ LeadingZeros()

static int OpenBabel::LeadingZeros ( unsigned int x )

static

Referenced by DoubleModulus().

◆ DoubleModulus()

static unsigned int OpenBabel::DoubleModulus	(	DoubleType *	n,
		unsigned int	d
	)

static

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

◆ DeterminePotency()

static int OpenBabel::DeterminePotency	(	unsigned int	m,
		unsigned int	a
	)

static

Referenced by DetermineSequence().

◆ DetermineFactors()

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

static

Referenced by DetermineSequence().

◆ DetermineIncrement()

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

static

Referenced by DetermineSequence().

◆ DetermineSequence()

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

static

Referenced by OBRandom::OBRandom().

◆ GenerateSequence()

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

static

◆ GetAtomIDNumber()

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

static

Referenced by OBResidue::GetAtomProperty().

◆ GetResidueNumber()

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

static

Referenced by SetResidueKeys().

◆ SetResidueKeys()

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

static

Referenced by OBResidue::SetName().

◆ DetermineFRJ()

static 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> OpenBabel::atomRingToBondRing	(	OBMol *	mol,
		const std::vector< int > &	atoms
	)

Referenced by visitRing().

◆ visitRing()

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

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

A cycle (C) is relevant if:

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

This is based on lemma 1 from:

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

Referenced by OBRingSearch::RemoveRedundant().

◆ FindRingAtomsAndBonds2()

static unsigned int FindRingAtomsAndBonds2 ( OBMol & mol )

static

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

◆ FindRings()

static int OpenBabel::FindRings	(	OBAtom *	atom,
		int *	avisit,
		unsigned char *	bvisit,
		unsigned int &	frj,
		int	depth
	)

static

Referenced by FindRingAtomsAndBonds2().

◆ rint()

double OpenBabel::rint ( double x )

inline

Referenced by 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

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

◆ PackCoordinate()

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

◆ UnpackCoordinate()

void OpenBabel::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

Referenced by OBRotorList::FindRotors().

◆ trim_spaces()

char* OpenBabel::trim_spaces ( char * string )

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

◆ FindExocyclicAtom()

static ExocyclicAtom OpenBabel::FindExocyclicAtom ( OBAtom * atm )

static

Referenced by AssignOBAromaticityModel().

◆ HasExocyclicBondToOxygenMinus()

static bool OpenBabel::HasExocyclicBondToOxygenMinus ( OBAtom * atm )

static

Referenced by AssignOBAromaticityModel().

◆ HasExocyclicDblBondToOxygen()

static bool OpenBabel::HasExocyclicDblBondToOxygen ( OBAtom * atm )

static

Referenced by AssignOBAromaticityModel().

◆ HasExocyclicDblBondToHet()

static bool OpenBabel::HasExocyclicDblBondToHet ( OBAtom * atm )

static

Referenced by AssignOBAromaticityModel().

◆ AssignOBAromaticityModel()

static bool OpenBabel::AssignOBAromaticityModel	(	OBAtom *	atm,
		int &	min,
		int &	max
	)

static

◆ eval_horn_NR_corrxn()

static double OpenBabel::eval_horn_NR_corrxn	(	const vector< double > &	c,
		const double	x
	)

static

Referenced by QCProot().

◆ QCProot()

static double OpenBabel::QCProot	(	const vector< double > &	coeff,
		double	guess,
		const double	delta
	)

static

Referenced by CalcQuarticCoeffs().

◆ CalcQuarticCoeffs()

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

◆ operator*() [4/4]

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

◆ SQUARE()

static double OpenBabel::SQUARE ( double x )

inlinestatic

Referenced by OBMol::ConnectTheDots(), and matrix3x3::FillOrth().

◆ operator<<() [4/4]

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

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

◆ RemoveWhiteSpaceUnderscore()

std::string OpenBabel::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 OpenBabel::VZero	(	0.	0,
		0.	0,
		0.	0
	)

Referenced by vector3::createOrthoVector().

◆ VX()

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

Referenced by vector3::createOrthoVector().

◆ VY()

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

Referenced by vector3::createOrthoVector().

◆ VZ()

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

Referenced by vector3::createOrthoVector().

◆ getdelta()

int OpenBabel::getdelta	(	int	x,
		int	y,
		int	x2,
		int	y2
	)

Referenced by ASCIIPainter::Bresenham().

◆ getsymbols()

string OpenBabel::getsymbols	(	int	x,
		int	y,
		int	x2,
		int	y2
	)

Referenced by ASCIIPainter::Bresenham().

◆ writeFunction()

static cairo_status_t OpenBabel::writeFunction	(	void *	closure,
		const unsigned char *	data,
		unsigned int	length
	)

static

Referenced by CairoPainter::WriteImage().

◆ GetLabelAlignment()

int OpenBabel::GetLabelAlignment ( OBAtom * atom )

Referenced by OBDepict::DrawMolecule().

◆ GetAtomSymClass()

unsigned int OpenBabel::GetAtomSymClass ( OBAtom * atom )

Referenced by OBDepict::AddAtomLabels().

◆ AssignRadicalDots()

static Radical OpenBabel::AssignRadicalDots ( OBAtom * atom )

static

Referenced by OBDepict::DrawMolecule().

Variable Documentation

◆ AliasDataType

const unsigned int AliasDataType = 0x7883

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

◆ chainsparser

OBChainsParser chainsparser

Global OBChainsParser for detecting macromolecular chains and residues.

◆ ttab

OBTypeTable ttab

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

Referenced by 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

◆ 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

◆ 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(), OBMol::Align(), alternate(), OBChemTsfm::Apply(), 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(), OBPhModel::CorrectForPH(), OBMol::CorrectForPH(), OBBuilder::CorrectStereoAtoms(), OBMoleculeFormat::DeferMolOutput(), OBMoleculeFormat::DeleteDeferredMols(), OBMol::DeleteHydrogens(), OBMol::DeleteNonPolarHydrogens(), OBMol::DeletePolarHydrogens(), DeleteStereoOnAtom(), OBMol::DoTransformations(), OBMol::EndModify(), AliasData::Expand(), FatalAllocationError(), OBDescriptor::FilterCompare(), SpaceGroup::Find(), FastSearch::Find(), OBMol::FindLSSR(), findMetalloceneBonds(), OBMol::FindRingAtomsAndBonds(), OBRotorList::FindRotors(), OBMol::FindSSSR(), OBFingerprint::Fold(), OBConversion::FullConvert(), OBMol::GetAtom(), OBMol::GetAtomById(), GetAtomIDNumber(), OBMol::GetBond(), OBMol::GetBondById(), OBMol::GetFormula(), OBBuilder::GetFragmentCoord(), OBDescriptor::GetIdentifier(), OBMol::GetResidue(), 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(), OBAtomTyper::ParseLine(), OBRingTyper::ParseLine(), OBRotorRules::ParseLine(), OBPhModel::ParseLine(), OBTypeTable::ParseLine(), OBMol::PerceiveBondOrders(), patty::read_rules(), OBConversion::ReadFile(), OBMoleculeFormat::ReadNameIndex(), OBDescriptor::ReadStringFromFilter(), OBConversion::RegisterOptionParam(), OBMol::RenumberAtoms(), OBMol::Rotate(), SafeOpen(), OBTypeTable::SetFromType(), OBAtom::SetHybAndGeom(), OBMol::SetInternalCoord(), OBMol::SetTorsion(), OBTypeTable::SetToType(), OBRotorList::Setup(), OBSmartsPattern::SMARTSError(), OBMol::StripSalts(), ThrowError(), OBTetraNonPlanarStereo::ToConfig(), OBMol::ToInertialFrame(), OBTypeTable::Translate(), OBMol::Translate(), patty::type_to_int(), UnitNameToConversionFactor(), 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)

◆ aromtyper

THREAD_LOCAL OBAromaticTyper aromtyper

Global OBAromaticTyper for detecting aromatic atoms and bonds.

◆ VZero

const vector3 VZero(0.0, 0.0, 0.0)

The zero vector: <0.0, 0.0, 0.0>

Referenced by OBDepict::AddAtomLabels(), OBBuilder::Build(), OBScoreGrid::Center(), center_coords(), OBScoreGrid::CenterMol(), dot(), OBDepict::DrawMolecule(), 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(), dot(), 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 dot(), and InternalToCartesian().

◆ VZ

const vector3 VZ(0.0, 0.0, 1.0)

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

Referenced by dot(), OBDepict::DrawMolecule(), and OBBuilder::GetNewBondVector().

◆ phmodel

THREAD_LOCAL OBPhModel phmodel

◆ 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
    }

◆ nibble_bit_count

const unsigned nibble_bit_count[0x10]

Initial value:

◆ bondtyper

THREAD_LOCAL OBBondTyper bondtyper

Global OBBondTyper for perception of bond order assignment.

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

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

◆ MonoAtom

MonoAtomType MonoAtom[MaxMonoAtom]

static

◆ MonoBond

MonoBondType MonoBond[MaxMonoBond]

static

◆ MonoAtomCount

int MonoAtomCount

static

Referenced by GenerateByteCodes(), and OBChainsParser::PerceiveChains().

◆ MonoBondCount

int MonoBondCount

static

Referenced by GenerateByteCodes(), and OBChainsParser::PerceiveChains().

◆ Stack

StackType Stack[STACKSIZE]

static

◆ StackPtr

int StackPtr

static

Referenced by GenerateByteCodes(), and OBChainsParser::PerceiveChains().

◆ AtomIndex

int AtomIndex

static

Referenced by GenerateByteCodes().

◆ BondIndex

int BondIndex

static

Referenced by GenerateByteCodes().

◆ StrictFlag

bool StrictFlag = false

static

◆ red

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

static

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

◆ green

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

static

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

◆ yellow

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

static

◆ blue

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

static

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

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

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

◆ 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" ,""  ,""  ,""  ,""  ,""  ,""}

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

◆ Roots

double Roots[4]

static

◆ SmartsImplicitRef

const int SmartsImplicitRef = -9999

Referenced by OBSmartsMatcher::match().

◆ 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
  }

◆ Residue

char Residue[MAXRES][4]

◆ ElemDesc

char ElemDesc[MAXELEM][4]

◆ ringtyper

OBRingTyper ringtyper

◆ SINT

int SINT = 0x00000001

static

◆ STPTR

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

static

◆ _SpaceGroups

SpaceGroups _SpaceGroups

static

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ OBNodeBase

◆ OBBondIterator

◆ OBAtomIterator

◆ OBDataIterator

◆ Template

◆ RotorKey

◆ RotorKeys

◆ mapRotorEnergy

◆ OBPairInteger

◆ OBPairFloatingPoint

◆ OBPairBool

◆ OBFreeGridPointIterator

◆ OBResidueIterator

◆ Formatpos

◆ AtomExpr

◆ BondExpr

◆ OBRotorIterator

◆ transform3dIterator

◆ ByteCode

◆ adjustedlist

◆ neighbourlist

Enumeration Type Documentation

◆ DataOrigin

◆ score_t

◆ HydrogenType

◆ obMessageLevel

◆ errorQualifier

◆ OBReactionRole

◆ ExocyclicAtom

◆ anonymous enum

◆ anonymous enum

◆ Radical

Function Documentation

◆ OBReleaseVersion()

◆ Tanimoto()

◆ CanonicalLabels()

◆ extract_thermochemistry()

◆ DoComparison()

◆ OBKekulize()

◆ print_matrix()

◆ print_matrix_f()

◆ print_matrix_ff()

◆ mult_matrix()

◆ mult_matrix_f()

◆ mult_matrix_ff()

◆ invert_matrix()

◆ invert_matrix_f()

◆ invert_matrix_ff()

◆ convert_matrix_f() [1/2]

◆ convert_matrix_ff() [1/2]

◆ convert_matrix_f() [2/2]

◆ convert_matrix_ff() [2/2]

◆ convert_matrix_ff_f()

◆ convert_matrix_f_ff()

◆ hydrogenValency()

◆ maxValency()

◆ alternate() [1/3]

◆ alternate() [2/3]

◆ generateDiagram() [1/3]

◆ generateDiagram() [2/3]

◆ generateDiagram() [3/3]

◆ fragmentSearch() [1/2]

◆ fragmentSearch() [2/2]

◆ equivalenceList() [1/2]

◆ equivalenceList() [2/2]

◆ addFragment()

◆ createStereoLists()

◆ getAtomMCDL()

◆ getBondMCDL()

◆ implementAtomStereo()

◆ implementBondStereo()

◆ groupRedraw()