src/openbabel/generic.hpp

/**********************************************************************
generic.h - Handle generic data classes. Custom data for atoms, bonds, etc.
 
Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
 
This file is part of the Open Babel project.
For more information, see <http://openbabel.sourceforge.net/>
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
***********************************************************************/

#ifndef OB_GENERIC_H
#define OB_GENERIC_H

#include "config.h"

#include <string>
#include <vector>
#include <map>

namespace OpenBabel
{

class OBAtom;
class OBBond;
class OBRing;

OBAPI void Trim(std::string& txt);

//! \brief Classification of data stored via OBGenericData class and subclasses.
//!
//! OBGenericDataType can be used as a faster, direct access to a particular category
//! instead of the slower access via GetData(std::string), which must loop
//! through all data to find a match with the supplied key. It is implemented
//! as a set of unsigned integer constants for maximum flexibility and future
//! expansion.
//! 
//! CustomData0 through CustomData15 are data slots that are not used in 
//! OpenBabel directly and are meant for use in derivative programs.
//! Macro definitions can be used to define what each data slot is used in your code.
namespace OBGenericDataType
{
  //! Unknown data type (default)
  static const unsigned int UndefinedData =      0;

  //! Arbitrary key/value data, i.e., OBPairData
  static const unsigned int PairData      =      1;

  //! Energetics data (e.g., total energy, heat of formation, etc.)
  static const unsigned int EnergyData    =      2;

  //! Storing text comments (one per molecule, atom, bond, etc.) (for other data, e.g., author, keyword, ... use OBPairData)
  static const unsigned int CommentData   =      3;

  //! Arbitrary information about conformers, i.e., OBConformerData
  static const unsigned int ConformerData =      4;

  //! Bond data external to OpenBabel, i.e., OBExternalBond, OBExternalBondData
  static const unsigned int ExternalBondData =   5;

  //! Information for generating & manipulating rotamers, i.e. OBRotamerList
  static const unsigned int RotamerList =        6;

  //! Info. for storing bonds to atoms yet to be added, i.e. OBVirtualBond
  static const unsigned int VirtualBondData =    7;

  //! Information on rings in a molecule, i.e., OBRingData
  static const unsigned int RingData =           8;

  //! Information about torsion/dihedral angles, i.e., OBTorsionData and OBTorsion
  static const unsigned int TorsionData =        9;

  //! Bond angles in a molecule, i.e., OBAngle, OBAngleData
  static const unsigned int AngleData =         10;

  //! Residue serial numbers
  static const unsigned int SerialNums =        11;

  //! Crystallographic unit cell data, i.e., OBUnitCell
  static const unsigned int UnitCell =          12;

  //! Spin data, including NMR, atomic and molecular spin, etc.
  static const unsigned int SpinData =          13;

  //! Arbitrary partial and total charges, dipole moments, etc.
  static const unsigned int ChargeData =        14;

  //! Symmetry data -- point and space groups, transforms, etc. i.e., OBSymmetryData
  static const unsigned int SymmetryData =      15;

  //! Arbitrary chiral information (atom, bond, molecule, etc.) i.e., OBChiralData
  static const unsigned int ChiralData =        16;

  //! Atomic and molecular occupation data
  static const unsigned int OccupationData =    17;

  //! Density (cube) data and surfaces
  static const unsigned int DensityData =       18;

  //! Electronic levels, redox states, orbitals, etc.
  static const unsigned int ElectronicData =    19;

  //! Vibrational modes, frequencies, etc.
  static const unsigned int VibrationData =     20;

  //! Rotational energy information
  static const unsigned int RotationData =      21;

  //! Nuclear transitions (e.g., decay, fission, fusion)
  static const unsigned int NuclearData =       22;

  // space for up to 2^14 more entries...

  //! Custom (user-defined data)
  static const unsigned int CustomData0 = 16384;
  static const unsigned int CustomData1 = 16385;
  static const unsigned int CustomData2 = 16386;
  static const unsigned int CustomData3 = 16387;
  static const unsigned int CustomData4 = 16388;
  static const unsigned int CustomData5 = 16389;
  static const unsigned int CustomData6 = 16390;
  static const unsigned int CustomData7 = 16391;
  static const unsigned int CustomData8 = 16392;
  static const unsigned int CustomData9 = 16393;
  static const unsigned int CustomData10 = 16394;
  static const unsigned int CustomData11 = 16395;
  static const unsigned int CustomData12 = 16396;
  static const unsigned int CustomData13 = 16397;
  static const unsigned int CustomData14 = 16398;
  static const unsigned int CustomData15 = 16399;
} // end namespace

//! \brief Base class for generic data
// class introduction in generic.cpp
class OBAPI OBGenericData
{
protected:
    std::string     _attr; //!< attribute tag (e.g., "UnitCell", "Comment" or "Author")
    unsigned int            _type; //!< attribute type -- declared for each subclass
public:
    OBGenericData();
    OBGenericData(const OBGenericData&);
    virtual ~OBGenericData()    {}
    OBGenericData& operator=(const OBGenericData &src);

    void                      SetAttribute(const std::string &v)
    {        _attr = v;        }
    virtual const std::string &GetAttribute()  const
    {        return(_attr);    }
    unsigned int                GetDataType()    const
    {        return(_type);    }
};

//! Used to store a comment string (can be multiple lines long)
class OBAPI OBCommentData : public OBGenericData
{
protected:
    std::string _data;
public:
    OBCommentData();
    OBCommentData(const OBCommentData&);
    OBCommentData& operator=(const OBCommentData &src);

    void          SetData(const std::string &data)
    { _data = data; Trim(_data); }
    void          SetData(const char *d)
    {_data = d; Trim(_data);     }
    const std::string &GetData()              const
    {        return(_data);      }
};

//! \brief Used to store information on an external bond 
//! (e.g., SMILES fragments)
class OBAPI OBExternalBond
{
    int     _idx;
    OBAtom *_atom;
    OBBond *_bond;
public:
    OBExternalBond()    {}
    OBExternalBond(OBAtom *,OBBond *,int);
    OBExternalBond(const OBExternalBond &);
    ~OBExternalBond()   {}

    int     GetIdx()  const    {        return(_idx);    }
    OBAtom *GetAtom() const    {        return(_atom);   }
    OBBond *GetBond() const    {        return(_bond);   }
    void SetIdx(int idx)       {        _idx = idx;      }
    void SetAtom(OBAtom *atom) {        _atom = atom;    }
    void SetBond(OBBond *bond) {        _bond = bond;    }
};

//! \brief Used to store information on external bonds (e.g., in SMILES fragments)
class OBAPI OBExternalBondData : public OBGenericData
{
protected:
    std::vector<OBExternalBond> _vexbnd;
public:
    OBExternalBondData();
    void SetData(OBAtom*,OBBond*,int);
    std::vector<OBExternalBond> *GetData()
    {
        return(&_vexbnd);
    }
};

//! \brief Used to store arbitrary attribute/value relationships.
//!
//! Ideal for arbitrary text descriptors for molecules, atoms, bonds, residues,
//!  e.g. in QSAR.
class OBAPI OBPairData : public OBGenericData
{
protected:
    std::string _value;
public:
    OBPairData();
    void    SetValue(const char *v)
    {
        _value = v;
    }
    void    SetValue(const std::string &v)
    {
        _value = v;
    }
    std::string &GetValue()
    {
        return(_value);
    }
};

//! \brief Used to temporarily store bonds that reference
//! an atom that has not yet been added to a molecule
class OBAPI OBVirtualBond : public OBGenericData
{
protected:
    int _bgn;
    int _end;
    int _ord;
    int _stereo;
public:
    OBVirtualBond();
    OBVirtualBond(int,int,int,int stereo=0);
    int GetBgn()
    {
        return(_bgn);
    }
    int GetEnd()
    {
        return(_end);
    }
    int GetOrder()
    {
        return(_ord);
    }
    int GetStereo()
    {
        return(_stereo);
    }
};

//! Used to store the SSSR set (filled in by OBMol::GetSSSR())
class OBAPI OBRingData : public OBGenericData
{
protected:
    std::vector<OBRing*> _vr;
public:
    OBRingData();
    OBRingData(const OBRingData &);
    ~OBRingData();

    OBRingData &operator=(const OBRingData &);

    void SetData(std::vector<OBRing*> &vr)
    {
        _vr = vr;
    }
    void PushBack(OBRing *r)
    {
        _vr.push_back(r);
    }
    std::vector<OBRing*> &GetData()
    {
        return(_vr);
    }
};

//! \brief Used for storing information about periodic boundary conditions
//!   with conversion to/from translation vectors and
//!  (a, b, c, alpha, beta, gamma)
class OBAPI OBUnitCell: public OBGenericData
{
protected:
    double _a, _b, _c, _alpha, _beta, _gamma;
    vector3 _offset; //!< offset for origin
    vector3 _v1, _v2, _v3; //!< translation vectors
    std::string _spaceGroup;
public:
    OBUnitCell();
    OBUnitCell(const OBUnitCell &);
    ~OBUnitCell()    {}

    OBUnitCell &operator=(const OBUnitCell &);

    void SetData(const double a, const double b, const double c,
                 const double alpha, const double beta, const double gamma)
    {   _a = a; _b = b; _c = c;
        _alpha = alpha; _beta = beta; _gamma = gamma; }
    void SetData(const vector3 v1, const vector3 v2, const vector3 v3);
    void SetOffset(const vector3 v1) { _offset = v1; }
    //! Set the space group symbol for this unit cell.
    //! Does not create an OBSymmetryData entry or attempt to convert
    //!  between different symbol notations
    void SetSpaceGroup(const std::string sg) { _spaceGroup = sg; }

    double GetA()    { return(_a);    }
    double GetB()    { return(_b);    }
    double GetC()    { return(_c);    }
    double GetAlpha(){ return(_alpha);}
    double GetBeta() { return(_beta); }
    double GetGamma(){ return(_gamma);}
    vector3 GetOffset() { return(_offset); }
    const std::string GetSpaceGroup() { return(_spaceGroup); }

    //! \return v1, v2, v3 cell vectors
    std::vector<vector3> GetCellVectors();
    //! \return v1, v2, v3 cell vectors as a 3x3 matrix
    matrix3x3   GetCellMatrix();
    //! \return The orthogonalization matrix, used for converting from fractional to Cartesian coords.
    matrix3x3 GetOrthoMatrix();
    //! \return The fractionalization matrix, used for converting from Cartesian to fractional coords.
    matrix3x3 GetFractionalMatrix();
};

//! \brief Used to hold data on conformers or geometry optimization steps
class OBAPI OBConformerData: public OBGenericData
{
protected:
  //! Dimensionalities of conformers
  std::vector<unsigned short>              _vDimension;
  //! Relative energies of conformers (preferably in kJ/mol)
  std::vector<double>                      _vEnergies;
  //! Atomic forces for each conformer
  std::vector< std::vector< vector3 > >    _vForces;
  //! Atomic velocities for each conformer (e.g., trajectories)
  std::vector< std::vector< vector3 > >    _vVelocity;
  //! Atomic displacements for each conformer (e.g., RMS distances)
  std::vector< std::vector< vector3 > >    _vDisplace;
  //! Additional data (as strings)
  std::vector<std::string>                 _vData;
    
public:
    OBConformerData();
    OBConformerData(const OBConformerData &);
    ~OBConformerData()    {}

    OBConformerData &operator=(const OBConformerData &);

    void SetDimension(std::vector<unsigned short> vd) { _vDimension = vd; }
    void SetEnergies(std::vector<double> ve) { _vEnergies = ve; }
    void SetForces(std::vector< std::vector< vector3 > > vf) {_vForces = vf;}
    void SetVelocities(std::vector< std::vector< vector3 > > vv)
      { _vVelocity = vv; }
    void SetDisplacements(std::vector< std::vector< vector3 > > vd)
      { _vDisplace = vd; }
    void SetData(std::vector<std::string> vdat) { _vData = vdat; }

    std::vector<unsigned short> GetDimension() { return _vDimension; }
    std::vector<double>         GetEnergies()  { return _vEnergies; }
    std::vector< std::vector< vector3 > > GetForces() {return _vForces; }
    std::vector< std::vector< vector3 > > GetVelocities()
      {return _vVelocity;}
    std::vector< std::vector< vector3 > > GetDisplacements()
      {return _vDisplace;}
    std::vector<std::string>    GetData() { return _vData; }

};

//! \brief Used to hold the point-group and/or space-group symmetry
//! \todo Add support for translation between symbol notations.
//!        Add symmetry perception routines.
class OBAPI OBSymmetryData: public OBGenericData
{
protected:
    std::string _spaceGroup;
    std::string _pointGroup;
public:
    OBSymmetryData();
    OBSymmetryData(const OBSymmetryData &);
    ~OBSymmetryData()    {}

    OBSymmetryData &operator=(const OBSymmetryData &);

    void SetData(std::string pg, std::string sg = "")
      { _pointGroup = pg; _spaceGroup = sg; }
    void SetPointGroup(std::string pg) { _pointGroup = pg; }
    void SetSpaceGroup(std::string sg) { _spaceGroup = sg; }

    std::string GetPointGroup() { return _pointGroup; }
    std::string GetSpaceGroup() { return _spaceGroup; }
};

//! \brief Used to hold the torsion data for a single rotatable bond
//! and all four atoms around it
class OBAPI OBTorsion
{
    friend class OBMol;
    friend class OBTorsionData;

protected:
    std::pair<OBAtom*,OBAtom*> _bc;
    //! double is angle in rads
    std::vector<triple<OBAtom*,OBAtom*,double> > _ads;

    OBTorsion()
    {
        _bc.first=0;
        _bc.second=0;
    }
    ;  //protected for use only by friend classes
    OBTorsion(OBAtom *, OBAtom *, OBAtom *, OBAtom *);

    std::vector<quad<OBAtom*,OBAtom*,OBAtom*,OBAtom*> > GetTorsions();

public:
    OBTorsion(const OBTorsion &);
    ~OBTorsion()
    {}

    OBTorsion& operator=(const OBTorsion &);

    void Clear();
    bool Empty()
    {
        return(_bc.first == 0 && _bc.second == 0);
    }

    bool AddTorsion(OBAtom *a,OBAtom *b, OBAtom *c,OBAtom *d);
    bool AddTorsion(quad<OBAtom*,OBAtom*,OBAtom*,OBAtom*> &atoms);

    bool SetAngle(double radians, unsigned int index = 0);
    bool SetData(OBBond *bond);

    bool GetAngle(double &radians, unsigned int index =0);
    unsigned int GetBondIdx();
    unsigned int GetSize() const
    {
        return (unsigned int)_ads.size();
    }

    std::pair<OBAtom*,OBAtom*>                  GetBC()
    {
        return(_bc);
    }
    std::vector<triple<OBAtom*,OBAtom*,double> > GetADs()
    {
        return(_ads) ;
    }

    bool IsProtonRotor();
};

//! \brief Used to hold torsions as generic data for OBMol.
//! Filled by OBMol::FindTorsions()
class OBAPI OBTorsionData : public OBGenericData
{
    friend class OBMol;

protected:
    std::vector<OBTorsion> _torsions;

    OBTorsionData();
    OBTorsionData(const OBTorsionData &);

public:
    OBTorsionData &operator=(const OBTorsionData &);

    void Clear();

    std::vector<OBTorsion> GetData() const
    {
        return _torsions;
    }
    unsigned int      GetSize() const
    {
        return (unsigned int)_torsions.size();
    }

    void SetData(OBTorsion &torsion);

    bool FillTorsionArray(std::vector<std::vector<unsigned int> > &torsions);
};

//! Used to hold the 3 atoms in an angle and the angle itself
class OBAPI OBAngle
{
    friend class OBMol;
    friend class OBAngleData;

protected:

    //member data

    OBAtom                *_vertex;
    std::pair<OBAtom*,OBAtom*>  _termini;
    double                  _radians;

    //protected member functions

    OBAngle();  //protect constructor for use only by friend classes
    OBAngle(OBAtom *vertex,OBAtom *a,OBAtom *b);

    triple<OBAtom*,OBAtom*,OBAtom*> GetAtoms();
    void SortByIndex();

public:

    OBAngle(const OBAngle &);
    ~OBAngle()
    {
        _vertex = NULL;
    }

    OBAngle &operator = (const OBAngle &);
    bool     operator ==(const OBAngle &);

    void  Clear();

    double GetAngle() const
    {
        return(_radians);
    }

    void  SetAngle(double radians)
    {
        _radians = radians;
    }
    void  SetAtoms(OBAtom *vertex,OBAtom *a,OBAtom *b);
    void  SetAtoms(triple<OBAtom*,OBAtom*,OBAtom*> &atoms);

};


//! \brief Used to hold all angles in a molecule as generic data for OBMol
class OBAPI OBAngleData : public OBGenericData
{
    friend class OBMol;

protected:
    std::vector<OBAngle> _angles;

    OBAngleData();
    OBAngleData(const OBAngleData &);
    std::vector<OBAngle> GetData() const
    {
        return(_angles);
    }

public:
    OBAngleData &operator =(const OBAngleData &);

    void Clear();
    unsigned int FillAngleArray(int **angles, unsigned int &size);
    void         SetData(OBAngle &);
    unsigned int GetSize() const
    {
        return (unsigned int)_angles.size();
    }
};

enum atomreftype{output,input,calcvolume}; // sets which atom4ref is accessed

//! \brief Used to hold chiral inforamtion about the atom as OBGenericData
class OBAPI OBChiralData : public OBGenericData
{
    friend class OBMol;
    friend class OBAtom;

protected:
    std::vector<unsigned int> _atom4refs;
    int parity;
    std::vector<unsigned int> _atom4refo;
    std::vector<unsigned int> _atom4refc;

public:
    std::vector<unsigned int> GetAtom4Refs(atomreftype t) const;
    unsigned int GetAtomRef(int a,atomreftype t);

    OBChiralData();
    OBChiralData(const OBChiralData &src);
    OBChiralData &operator =(const OBChiralData &);
    ~OBChiralData(){}

    void Clear();
    bool SetAtom4Refs(std::vector<unsigned int> atom4refs, atomreftype t);
    int AddAtomRef(unsigned int atomref, atomreftype t);
    unsigned int GetSize(atomreftype t) const;
};

//! Defines a map between serial numbers (e.g., in a PDB file) and OBAtom objects
class OBSerialNums : public OBGenericData
{
protected:
    std::map<int, OBAtom*> _serialMap;

public:

    OBSerialNums()
    {
        _attr = "obSerialNums";
        _type = OBGenericDataType::SerialNums;
    }
    OBSerialNums(const OBSerialNums &cp) : OBGenericData(cp)
    {
        _serialMap = cp._serialMap;
    }

    std::map<int,OBAtom*> &GetData()    { return _serialMap;    }
    void SetData(std::map<int,OBAtom*> &sm) { _serialMap = sm;  }

};

//****************doxygen for inline functions***********
/*!
**\fn OBTorsionData::GetSize() const
**\brief Gets the number of torsion structs
**\return integer count of the number of torsions
*/

/*!
**\fn OBTorsionData::GetData() const
**\brief Gets a vector of the OBTorsions
**\return the vector of torsions
*/

/*!
**\fn OBAngleData::GetSize() const
**\brief Gets the number of angles 
**\return integer count of the number of angles
*/

/*!
**\fn OBAngleData::GetData() const
**\brief Gets the angle vector data
**\return pointer to vector<OBAngle>
*/

/*!
**\fn OBAngle::SetAngle(double angle)
**\brief Sets the OBAngle angle value
**\param angle in radians
*/

/*!
**\fn OBAngle::GetAngle() const
**\brief Gets the OBAngle angle value
**\return angle in radians
*/

/*!
**\fn OBTorsion::GetBondIdx()
**\brief Gets the bond index of the central bond
**\return int bond index
*/

/*!
**\fn OBTorsion::GetBC()
**\brief Gets the two central atoms of ABCD torsion
**\return pair<OBAtom*,OBAtom*>
*/

/*!
**\fn OBTorsion::GetADs()
**\brief Gets the vector of distal atoms of ABCD torsion
**\return vector of A,D atom pointers and a double
*/

} //end namespace OpenBabel

#endif // OB_GENERIC_H

//! \file generic.h
//! \brief Handle generic data classes. Custom data for atoms, bonds, etc.
Revision:	751
Committed:	Thu Nov 17 20:38:45 2005 UTC (19 years, 11 months ago) by gezelter
File size:	20034 byte(s)
Log Message:	Unifying config.h stuff and making sure the OpenBabel codes can find our default (and environment variable) Force Field directories.
#	User	Rev	Content
1	tim	741	/**********************************************************************
2			generic.h - Handle generic data classes. Custom data for atoms, bonds, etc.
3
4			Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
5			Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
6
7			This file is part of the Open Babel project.
8			For more information, see <http://openbabel.sourceforge.net/>
9
10			This program is free software; you can redistribute it and/or modify
11			it under the terms of the GNU General Public License as published by
12			the Free Software Foundation version 2 of the License.
13
14			This program is distributed in the hope that it will be useful,
15			but WITHOUT ANY WARRANTY; without even the implied warranty of
16			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			GNU General Public License for more details.
18			***********************************************************************/
19
20			#ifndef OB_GENERIC_H
21			#define OB_GENERIC_H
22
23	gezelter	751	#include "config.h"
24	tim	741
25			#include <string>
26			#include <vector>
27			#include <map>
28
29			namespace OpenBabel
30			{
31
32			class OBAtom;
33			class OBBond;
34			class OBRing;
35
36			OBAPI void Trim(std::string& txt);
37
38			//! \brief Classification of data stored via OBGenericData class and subclasses.
39			//!
40			//! OBGenericDataType can be used as a faster, direct access to a particular category
41			//! instead of the slower access via GetData(std::string), which must loop
42			//! through all data to find a match with the supplied key. It is implemented
43			//! as a set of unsigned integer constants for maximum flexibility and future
44			//! expansion.
45			//!
46			//! CustomData0 through CustomData15 are data slots that are not used in
47			//! OpenBabel directly and are meant for use in derivative programs.
48			//! Macro definitions can be used to define what each data slot is used in your code.
49			namespace OBGenericDataType
50			{
51			//! Unknown data type (default)
52			static const unsigned int UndefinedData = 0;
53
54			//! Arbitrary key/value data, i.e., OBPairData
55			static const unsigned int PairData = 1;
56
57			//! Energetics data (e.g., total energy, heat of formation, etc.)
58			static const unsigned int EnergyData = 2;
59
60			//! Storing text comments (one per molecule, atom, bond, etc.) (for other data, e.g., author, keyword, ... use OBPairData)
61			static const unsigned int CommentData = 3;
62
63			//! Arbitrary information about conformers, i.e., OBConformerData
64			static const unsigned int ConformerData = 4;
65
66			//! Bond data external to OpenBabel, i.e., OBExternalBond, OBExternalBondData
67			static const unsigned int ExternalBondData = 5;
68
69			//! Information for generating & manipulating rotamers, i.e. OBRotamerList
70			static const unsigned int RotamerList = 6;
71
72			//! Info. for storing bonds to atoms yet to be added, i.e. OBVirtualBond
73			static const unsigned int VirtualBondData = 7;
74
75			//! Information on rings in a molecule, i.e., OBRingData
76			static const unsigned int RingData = 8;
77
78			//! Information about torsion/dihedral angles, i.e., OBTorsionData and OBTorsion
79			static const unsigned int TorsionData = 9;
80
81			//! Bond angles in a molecule, i.e., OBAngle, OBAngleData
82			static const unsigned int AngleData = 10;
83
84			//! Residue serial numbers
85			static const unsigned int SerialNums = 11;
86
87			//! Crystallographic unit cell data, i.e., OBUnitCell
88			static const unsigned int UnitCell = 12;
89
90			//! Spin data, including NMR, atomic and molecular spin, etc.
91			static const unsigned int SpinData = 13;
92
93			//! Arbitrary partial and total charges, dipole moments, etc.
94			static const unsigned int ChargeData = 14;
95
96			//! Symmetry data -- point and space groups, transforms, etc. i.e., OBSymmetryData
97			static const unsigned int SymmetryData = 15;
98
99			//! Arbitrary chiral information (atom, bond, molecule, etc.) i.e., OBChiralData
100			static const unsigned int ChiralData = 16;
101
102			//! Atomic and molecular occupation data
103			static const unsigned int OccupationData = 17;
104
105			//! Density (cube) data and surfaces
106			static const unsigned int DensityData = 18;
107
108			//! Electronic levels, redox states, orbitals, etc.
109			static const unsigned int ElectronicData = 19;
110
111			//! Vibrational modes, frequencies, etc.
112			static const unsigned int VibrationData = 20;
113
114			//! Rotational energy information
115			static const unsigned int RotationData = 21;
116
117			//! Nuclear transitions (e.g., decay, fission, fusion)
118			static const unsigned int NuclearData = 22;
119
120			// space for up to 2^14 more entries...
121
122			//! Custom (user-defined data)
123			static const unsigned int CustomData0 = 16384;
124			static const unsigned int CustomData1 = 16385;
125			static const unsigned int CustomData2 = 16386;
126			static const unsigned int CustomData3 = 16387;
127			static const unsigned int CustomData4 = 16388;
128			static const unsigned int CustomData5 = 16389;
129			static const unsigned int CustomData6 = 16390;
130			static const unsigned int CustomData7 = 16391;
131			static const unsigned int CustomData8 = 16392;
132			static const unsigned int CustomData9 = 16393;
133			static const unsigned int CustomData10 = 16394;
134			static const unsigned int CustomData11 = 16395;
135			static const unsigned int CustomData12 = 16396;
136			static const unsigned int CustomData13 = 16397;
137			static const unsigned int CustomData14 = 16398;
138			static const unsigned int CustomData15 = 16399;
139			} // end namespace
140
141			//! \brief Base class for generic data
142			// class introduction in generic.cpp
143			class OBAPI OBGenericData
144			{
145			protected:
146			std::string _attr; //!< attribute tag (e.g., "UnitCell", "Comment" or "Author")
147			unsigned int _type; //!< attribute type -- declared for each subclass
148			public:
149			OBGenericData();
150			OBGenericData(const OBGenericData&);
151			virtual ~OBGenericData() {}
152			OBGenericData& operator=(const OBGenericData &src);
153
154			void SetAttribute(const std::string &v)
155			{ _attr = v; }
156			virtual const std::string &GetAttribute() const
157			{ return(_attr); }
158			unsigned int GetDataType() const
159			{ return(_type); }
160			};
161
162			//! Used to store a comment string (can be multiple lines long)
163			class OBAPI OBCommentData : public OBGenericData
164			{
165			protected:
166			std::string _data;
167			public:
168			OBCommentData();
169			OBCommentData(const OBCommentData&);
170			OBCommentData& operator=(const OBCommentData &src);
171
172			void SetData(const std::string &data)
173			{ _data = data; Trim(_data); }
174			void SetData(const char *d)
175			{_data = d; Trim(_data); }
176			const std::string &GetData() const
177			{ return(_data); }
178			};
179
180			//! \brief Used to store information on an external bond
181			//! (e.g., SMILES fragments)
182			class OBAPI OBExternalBond
183			{
184			int _idx;
185			OBAtom *_atom;
186			OBBond *_bond;
187			public:
188			OBExternalBond() {}
189			OBExternalBond(OBAtom ,OBBond ,int);
190			OBExternalBond(const OBExternalBond &);
191			~OBExternalBond() {}
192
193			int GetIdx() const { return(_idx); }
194			OBAtom *GetAtom() const { return(_atom); }
195			OBBond *GetBond() const { return(_bond); }
196			void SetIdx(int idx) { _idx = idx; }
197			void SetAtom(OBAtom *atom) { _atom = atom; }
198			void SetBond(OBBond *bond) { _bond = bond; }
199			};
200
201			//! \brief Used to store information on external bonds (e.g., in SMILES fragments)
202			class OBAPI OBExternalBondData : public OBGenericData
203			{
204			protected:
205			std::vector<OBExternalBond> _vexbnd;
206			public:
207			OBExternalBondData();
208			void SetData(OBAtom,OBBond,int);
209			std::vector<OBExternalBond> *GetData()
210			{
211			return(&_vexbnd);
212			}
213			};
214
215			//! \brief Used to store arbitrary attribute/value relationships.
216			//!
217			//! Ideal for arbitrary text descriptors for molecules, atoms, bonds, residues,
218			//! e.g. in QSAR.
219			class OBAPI OBPairData : public OBGenericData
220			{
221			protected:
222			std::string _value;
223			public:
224			OBPairData();
225			void SetValue(const char *v)
226			{
227			_value = v;
228			}
229			void SetValue(const std::string &v)
230			{
231			_value = v;
232			}
233			std::string &GetValue()
234			{
235			return(_value);
236			}
237			};
238
239			//! \brief Used to temporarily store bonds that reference
240			//! an atom that has not yet been added to a molecule
241			class OBAPI OBVirtualBond : public OBGenericData
242			{
243			protected:
244			int _bgn;
245			int _end;
246			int _ord;
247			int _stereo;
248			public:
249			OBVirtualBond();
250			OBVirtualBond(int,int,int,int stereo=0);
251			int GetBgn()
252			{
253			return(_bgn);
254			}
255			int GetEnd()
256			{
257			return(_end);
258			}
259			int GetOrder()
260			{
261			return(_ord);
262			}
263			int GetStereo()
264			{
265			return(_stereo);
266			}
267			};
268
269			//! Used to store the SSSR set (filled in by OBMol::GetSSSR())
270			class OBAPI OBRingData : public OBGenericData
271			{
272			protected:
273			std::vector<OBRing*> _vr;
274			public:
275			OBRingData();
276			OBRingData(const OBRingData &);
277			~OBRingData();
278
279			OBRingData &operator=(const OBRingData &);
280
281			void SetData(std::vector<OBRing*> &vr)
282			{
283			_vr = vr;
284			}
285			void PushBack(OBRing *r)
286			{
287			_vr.push_back(r);
288			}
289			std::vector<OBRing*> &GetData()
290			{
291			return(_vr);
292			}
293			};
294
295			//! \brief Used for storing information about periodic boundary conditions
296			//! with conversion to/from translation vectors and
297			//! (a, b, c, alpha, beta, gamma)
298			class OBAPI OBUnitCell: public OBGenericData
299			{
300			protected:
301			double _a, _b, _c, _alpha, _beta, _gamma;
302			vector3 _offset; //!< offset for origin
303			vector3 _v1, _v2, _v3; //!< translation vectors
304			std::string _spaceGroup;
305			public:
306			OBUnitCell();
307			OBUnitCell(const OBUnitCell &);
308			~OBUnitCell() {}
309
310			OBUnitCell &operator=(const OBUnitCell &);
311
312			void SetData(const double a, const double b, const double c,
313			const double alpha, const double beta, const double gamma)
314			{ _a = a; _b = b; _c = c;
315			_alpha = alpha; _beta = beta; _gamma = gamma; }
316			void SetData(const vector3 v1, const vector3 v2, const vector3 v3);
317			void SetOffset(const vector3 v1) { _offset = v1; }
318			//! Set the space group symbol for this unit cell.
319			//! Does not create an OBSymmetryData entry or attempt to convert
320			//! between different symbol notations
321			void SetSpaceGroup(const std::string sg) { _spaceGroup = sg; }
322
323			double GetA() { return(_a); }
324			double GetB() { return(_b); }
325			double GetC() { return(_c); }
326			double GetAlpha(){ return(_alpha);}
327			double GetBeta() { return(_beta); }
328			double GetGamma(){ return(_gamma);}
329			vector3 GetOffset() { return(_offset); }
330			const std::string GetSpaceGroup() { return(_spaceGroup); }
331
332			//! \return v1, v2, v3 cell vectors
333			std::vector<vector3> GetCellVectors();
334			//! \return v1, v2, v3 cell vectors as a 3x3 matrix
335			matrix3x3 GetCellMatrix();
336			//! \return The orthogonalization matrix, used for converting from fractional to Cartesian coords.
337			matrix3x3 GetOrthoMatrix();
338			//! \return The fractionalization matrix, used for converting from Cartesian to fractional coords.
339			matrix3x3 GetFractionalMatrix();
340			};
341
342			//! \brief Used to hold data on conformers or geometry optimization steps
343			class OBAPI OBConformerData: public OBGenericData
344			{
345			protected:
346			//! Dimensionalities of conformers
347			std::vector<unsigned short> _vDimension;
348			//! Relative energies of conformers (preferably in kJ/mol)
349			std::vector<double> _vEnergies;
350			//! Atomic forces for each conformer
351			std::vector< std::vector< vector3 > > _vForces;
352			//! Atomic velocities for each conformer (e.g., trajectories)
353			std::vector< std::vector< vector3 > > _vVelocity;
354			//! Atomic displacements for each conformer (e.g., RMS distances)
355			std::vector< std::vector< vector3 > > _vDisplace;
356			//! Additional data (as strings)
357			std::vector<std::string> _vData;
358
359			public:
360			OBConformerData();
361			OBConformerData(const OBConformerData &);
362			~OBConformerData() {}
363
364			OBConformerData &operator=(const OBConformerData &);
365
366			void SetDimension(std::vector<unsigned short> vd) { _vDimension = vd; }
367			void SetEnergies(std::vector<double> ve) { _vEnergies = ve; }
368			void SetForces(std::vector< std::vector< vector3 > > vf) {_vForces = vf;}
369			void SetVelocities(std::vector< std::vector< vector3 > > vv)
370			{ _vVelocity = vv; }
371			void SetDisplacements(std::vector< std::vector< vector3 > > vd)
372			{ _vDisplace = vd; }
373			void SetData(std::vector<std::string> vdat) { _vData = vdat; }
374
375			std::vector<unsigned short> GetDimension() { return _vDimension; }
376			std::vector<double> GetEnergies() { return _vEnergies; }
377			std::vector< std::vector< vector3 > > GetForces() {return _vForces; }
378			std::vector< std::vector< vector3 > > GetVelocities()
379			{return _vVelocity;}
380			std::vector< std::vector< vector3 > > GetDisplacements()
381			{return _vDisplace;}
382			std::vector<std::string> GetData() { return _vData; }
383
384			};
385
386			//! \brief Used to hold the point-group and/or space-group symmetry
387			//! \todo Add support for translation between symbol notations.
388			//! Add symmetry perception routines.
389			class OBAPI OBSymmetryData: public OBGenericData
390			{
391			protected:
392			std::string _spaceGroup;
393			std::string _pointGroup;
394			public:
395			OBSymmetryData();
396			OBSymmetryData(const OBSymmetryData &);
397			~OBSymmetryData() {}
398
399			OBSymmetryData &operator=(const OBSymmetryData &);
400
401			void SetData(std::string pg, std::string sg = "")
402			{ _pointGroup = pg; _spaceGroup = sg; }
403			void SetPointGroup(std::string pg) { _pointGroup = pg; }
404			void SetSpaceGroup(std::string sg) { _spaceGroup = sg; }
405
406			std::string GetPointGroup() { return _pointGroup; }
407			std::string GetSpaceGroup() { return _spaceGroup; }
408			};
409
410			//! \brief Used to hold the torsion data for a single rotatable bond
411			//! and all four atoms around it
412			class OBAPI OBTorsion
413			{
414			friend class OBMol;
415			friend class OBTorsionData;
416
417			protected:
418			std::pair<OBAtom,OBAtom> _bc;
419			//! double is angle in rads
420			std::vector<triple<OBAtom,OBAtom,double> > _ads;
421
422			OBTorsion()
423			{
424			_bc.first=0;
425			_bc.second=0;
426			}
427			; //protected for use only by friend classes
428			OBTorsion(OBAtom , OBAtom , OBAtom , OBAtom );
429
430			std::vector<quad<OBAtom,OBAtom,OBAtom,OBAtom> > GetTorsions();
431
432			public:
433			OBTorsion(const OBTorsion &);
434			~OBTorsion()
435			{}
436
437			OBTorsion& operator=(const OBTorsion &);
438
439			void Clear();
440			bool Empty()
441			{
442			return(_bc.first == 0 && _bc.second == 0);
443			}
444
445			bool AddTorsion(OBAtom a,OBAtom b, OBAtom c,OBAtom d);
446			bool AddTorsion(quad<OBAtom,OBAtom,OBAtom,OBAtom> &atoms);
447
448			bool SetAngle(double radians, unsigned int index = 0);
449			bool SetData(OBBond *bond);
450
451			bool GetAngle(double &radians, unsigned int index =0);
452			unsigned int GetBondIdx();
453			unsigned int GetSize() const
454			{
455			return (unsigned int)_ads.size();
456			}
457
458			std::pair<OBAtom,OBAtom> GetBC()
459			{
460			return(_bc);
461			}
462			std::vector<triple<OBAtom,OBAtom,double> > GetADs()
463			{
464			return(_ads) ;
465			}
466
467			bool IsProtonRotor();
468			};
469
470			//! \brief Used to hold torsions as generic data for OBMol.
471			//! Filled by OBMol::FindTorsions()
472			class OBAPI OBTorsionData : public OBGenericData
473			{
474			friend class OBMol;
475
476			protected:
477			std::vector<OBTorsion> _torsions;
478
479			OBTorsionData();
480			OBTorsionData(const OBTorsionData &);
481
482			public:
483			OBTorsionData &operator=(const OBTorsionData &);
484
485			void Clear();
486
487			std::vector<OBTorsion> GetData() const
488			{
489			return _torsions;
490			}
491			unsigned int GetSize() const
492			{
493			return (unsigned int)_torsions.size();
494			}
495
496			void SetData(OBTorsion &torsion);
497
498			bool FillTorsionArray(std::vector<std::vector<unsigned int> > &torsions);
499			};
500
501			//! Used to hold the 3 atoms in an angle and the angle itself
502			class OBAPI OBAngle
503			{
504			friend class OBMol;
505			friend class OBAngleData;
506
507			protected:
508
509			//member data
510
511			OBAtom *_vertex;
512			std::pair<OBAtom,OBAtom> _termini;
513			double _radians;
514
515			//protected member functions
516
517			OBAngle(); //protect constructor for use only by friend classes
518			OBAngle(OBAtom vertex,OBAtom a,OBAtom *b);
519
520			triple<OBAtom,OBAtom,OBAtom*> GetAtoms();
521			void SortByIndex();
522
523			public:
524
525			OBAngle(const OBAngle &);
526			~OBAngle()
527			{
528			_vertex = NULL;
529			}
530
531			OBAngle &operator = (const OBAngle &);
532			bool operator ==(const OBAngle &);
533
534			void Clear();
535
536			double GetAngle() const
537			{
538			return(_radians);
539			}
540
541			void SetAngle(double radians)
542			{
543			_radians = radians;
544			}
545			void SetAtoms(OBAtom vertex,OBAtom a,OBAtom *b);
546			void SetAtoms(triple<OBAtom,OBAtom,OBAtom*> &atoms);
547
548			};
549
550
551			//! \brief Used to hold all angles in a molecule as generic data for OBMol
552			class OBAPI OBAngleData : public OBGenericData
553			{
554			friend class OBMol;
555
556			protected:
557			std::vector<OBAngle> _angles;
558
559			OBAngleData();
560			OBAngleData(const OBAngleData &);
561			std::vector<OBAngle> GetData() const
562			{
563			return(_angles);
564			}
565
566			public:
567			OBAngleData &operator =(const OBAngleData &);
568
569			void Clear();
570			unsigned int FillAngleArray(int **angles, unsigned int &size);
571			void SetData(OBAngle &);
572			unsigned int GetSize() const
573			{
574			return (unsigned int)_angles.size();
575			}
576			};
577
578			enum atomreftype{output,input,calcvolume}; // sets which atom4ref is accessed
579
580			//! \brief Used to hold chiral inforamtion about the atom as OBGenericData
581			class OBAPI OBChiralData : public OBGenericData
582			{
583			friend class OBMol;
584			friend class OBAtom;
585
586			protected:
587			std::vector<unsigned int> _atom4refs;
588			int parity;
589			std::vector<unsigned int> _atom4refo;
590			std::vector<unsigned int> _atom4refc;
591
592			public:
593			std::vector<unsigned int> GetAtom4Refs(atomreftype t) const;
594			unsigned int GetAtomRef(int a,atomreftype t);
595
596			OBChiralData();
597			OBChiralData(const OBChiralData &src);
598			OBChiralData &operator =(const OBChiralData &);
599			~OBChiralData(){}
600
601			void Clear();
602			bool SetAtom4Refs(std::vector<unsigned int> atom4refs, atomreftype t);
603			int AddAtomRef(unsigned int atomref, atomreftype t);
604			unsigned int GetSize(atomreftype t) const;
605			};
606
607			//! Defines a map between serial numbers (e.g., in a PDB file) and OBAtom objects
608			class OBSerialNums : public OBGenericData
609			{
610			protected:
611			std::map<int, OBAtom*> _serialMap;
612
613			public:
614
615			OBSerialNums()
616			{
617			_attr = "obSerialNums";
618			_type = OBGenericDataType::SerialNums;
619			}
620			OBSerialNums(const OBSerialNums &cp) : OBGenericData(cp)
621			{
622			_serialMap = cp._serialMap;
623			}
624
625			std::map<int,OBAtom*> &GetData() { return _serialMap; }
626			void SetData(std::map<int,OBAtom*> &sm) { _serialMap = sm; }
627
628			};
629
630			//**************doxygen for inline functions*********
631			/*!
632			**\fn OBTorsionData::GetSize() const
633			**\brief Gets the number of torsion structs
634			**\return integer count of the number of torsions
635			*/
636
637			/*!
638			**\fn OBTorsionData::GetData() const
639			**\brief Gets a vector of the OBTorsions
640			**\return the vector of torsions
641			*/
642
643			/*!
644			**\fn OBAngleData::GetSize() const
645			**\brief Gets the number of angles
646			**\return integer count of the number of angles
647			*/
648
649			/*!
650			**\fn OBAngleData::GetData() const
651			**\brief Gets the angle vector data
652			**\return pointer to vector<OBAngle>
653			*/
654
655			/*!
656			**\fn OBAngle::SetAngle(double angle)
657			**\brief Sets the OBAngle angle value
658			**\param angle in radians
659			*/
660
661			/*!
662			**\fn OBAngle::GetAngle() const
663			**\brief Gets the OBAngle angle value
664			**\return angle in radians
665			*/
666
667			/*!
668			**\fn OBTorsion::GetBondIdx()
669			**\brief Gets the bond index of the central bond
670			**\return int bond index
671			*/
672
673			/*!
674			**\fn OBTorsion::GetBC()
675			**\brief Gets the two central atoms of ABCD torsion
676			*\return pair<OBAtom,OBAtom*>
677			*/
678
679			/*!
680			**\fn OBTorsion::GetADs()
681			**\brief Gets the vector of distal atoms of ABCD torsion
682			**\return vector of A,D atom pointers and a double
683			*/
684
685			} //end namespace OpenBabel
686
687			#endif // OB_GENERIC_H
688
689			//! \file generic.h
690			//! \brief Handle generic data classes. Custom data for atoms, bonds, etc.