generic.h

Go to the documentation of this file.

/**********************************************************************
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-2010 by Geoffrey R. Hutchison

This file is part of the Open Babel project.
For more information, see <http://openbabel.org/>

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 <openbabel/babelconfig.h>

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

#include <openbabel/math/spacegroup.h>
#include <openbabel/obutil.h>
#include <openbabel/base.h>

namespace OpenBabel
{

 // Forward declarations
 class OBBase;
 class OBAtom;
 class OBBond;
 class OBMol;
 class OBRing;

 class OBAPI OBCommentData : public OBGenericData
 {
 protected:
 std::string _data;
 public:
 OBCommentData();
 OBCommentData(const OBCommentData&);
 virtual OBGenericData* Clone(OBBase* /*parent*/) const{return new OBCommentData(*this);}

 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); }
 virtual const std::string &GetValue() const
 { return(_data); }
 };

 class OBAPI OBExternalBond
 {
 int _idx;
 OBAtom *_atom;
 OBBond *_bond;
 public:
 OBExternalBond(): _idx(0), _atom(NULL), _bond(NULL) {}
 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; }
 };

 class OBAPI OBExternalBondData : public OBGenericData
 {
 protected:
 std::vector<OBExternalBond> _vexbnd;
 public:
 OBExternalBondData();

 //Copying is not used and too much work to set up
 virtual OBGenericData* Clone(OBBase* /*parent*/) const{return NULL;}

 void SetData(OBAtom*,OBBond*,int);
 std::vector<OBExternalBond> *GetData()
 {
 return(&_vexbnd);
 }
 };

 class OBAPI OBPairData : public OBGenericData
 {
 protected:
 std::string _value; 
 public:
 OBPairData();
 virtual OBGenericData* Clone(OBBase* /*parent*/) const
 {return new OBPairData(*this);}
 void SetValue(const char *v) { _value = v; }
 void SetValue(const std::string &v) { _value = v; }
 virtual const std::string &GetValue() const
 { return(_value); }
 };

 // More detailed description in generic.cpp
 template <class ValueT>
 class OBPairTemplate : public OBGenericData // Note: no OBAPI should be used
 {
 protected:
 ValueT _value; 
 public:
 OBPairTemplate():
 OBGenericData("PairData", OBGenericDataType::PairData) {};
 virtual OBGenericData* Clone(OBBase* /*parent*/) const
 {return new OBPairTemplate<ValueT>(*this);}
 void SetValue(const ValueT t) { _value = t; }
 virtual const ValueT &GetGenericValue() const { return(_value); }
 };

 typedef OBPairTemplate<int> OBPairInteger;
 typedef OBPairTemplate<double> OBPairFloatingPoint;
 typedef OBPairTemplate<bool> OBPairBool;

 class OBAPI OBSetData : public OBGenericData
 {
 protected:
 std::vector<OBGenericData *> _vdata;
 public:
 OBSetData() : OBGenericData("SetData", OBGenericDataType::SetData) {}
 virtual OBGenericData* Clone(OBBase* /*parent*/) const{return new OBSetData(*this);}

 void AddData(OBGenericData *d)
 {
 if(d)
 {
 _vdata.push_back(d);
 }
 }

 void SetData(std::vector<OBGenericData *> &vdata)
 {
 _vdata = vdata;
 }

 OBGenericData *GetData(const char *s)
 {
 std::vector<OBGenericData*>::iterator i;

 for (i = _vdata.begin();i != _vdata.end();++i)
 if ((*i)->GetAttribute() == s)
 return(*i);

 return(NULL);
 }

 OBGenericData *GetData(const std::string &s)
 {
 std::vector<OBGenericData*>::iterator i;

 for (i = _vdata.begin();i != _vdata.end();++i)
 if ((*i)->GetAttribute() == s)
 return(*i);

 return(NULL);
 }

 virtual const std::vector<OBGenericData *> &GetData() const //now virtual and const
 {
 return(_vdata);
 }

 std::vector<OBGenericData*>::iterator GetBegin()
 {
 return _vdata.begin();
 }

 std::vector<OBGenericData*>::iterator GetEnd()
 {
 return _vdata.end();
 }

 void DeleteData(OBGenericData *gd)
 {
 std::vector<OBGenericData*>::iterator i;
 for (i = _vdata.begin();i != _vdata.end();++i)
 if (*i == gd)
 {
 delete *i;
 _vdata.erase(i);
 break; // Done, don't do anything more, since iterator is invalid
 }
 }

 }; // OBSetData

 class OBAPI OBVirtualBond : public OBGenericData
 {
 protected:
 unsigned int _bgn;
 unsigned int _end;
 unsigned int _ord;
 int _stereo;
 public:
 OBVirtualBond();
 virtual OBGenericData* Clone(OBBase* /*parent*/) const{return new OBVirtualBond(*this);}
 OBVirtualBond(unsigned int, unsigned int, unsigned int,int stereo=0);
 unsigned int GetBgn() { return(_bgn); }
 unsigned int GetEnd() { return(_end); }
 unsigned int GetOrder() { return(_ord); }
 int GetStereo() { return(_stereo); }
 };

 class OBAPI OBRingData : public OBGenericData
 {
 protected:
 std::vector<OBRing*> _vr;
 public:
 OBRingData();
 OBRingData(const OBRingData &);
 // When copying a molecule, don't copy the RingData. Why not? Well,
 // if you do, you'll end up with two RingDatas because one will already
 // exist due to Kekulize() in EndModify() in operator= in OBMol. Having
 // more than one RingData causes problems as one of them can become invalid
 // and cause segfaults.
 virtual OBGenericData* Clone(OBBase* /*parent*/) const{return NULL;}
 ~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);
 }

 std::vector<OBRing*>::iterator BeginRings()
 { return(_vr.begin()); }
 std::vector<OBRing*>::iterator EndRings()
 { return(_vr.end()); }
 OBRing *BeginRing(std::vector<OBRing*>::iterator &i);
 OBRing *NextRing(std::vector<OBRing*>::iterator &i);
 };

 class OBAPI OBUnitCell: public OBGenericData
 {
 public:
 enum LatticeType { Undefined,
 Triclinic,
 Monoclinic,
 Orthorhombic,
 Tetragonal,
 Rhombohedral ,
 Hexagonal,
 Cubic};


 protected:
 matrix3x3 _mOrtho;// Orthogonal matrix of column vectors
 matrix3x3 _mOrient;// Orientation matrix
 vector3 _offset;
 std::string _spaceGroupName;
 const SpaceGroup* _spaceGroup;
 LatticeType _lattice;
 public:
 OBUnitCell();
 OBUnitCell(const OBUnitCell &);
 virtual OBGenericData* Clone(OBBase* /*parent*/) const
 {return new OBUnitCell(*this);}
 ~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);
 void SetData(const vector3 v1, const vector3 v2, const vector3 v3);

 void SetData(const matrix3x3 m);

 void SetOffset(const vector3 v1);

 void SetSpaceGroup(const SpaceGroup* sg) { _spaceGroup = sg; }

 void SetSpaceGroup(const std::string sg) { _spaceGroup = SpaceGroup::GetSpaceGroup (sg);
 _spaceGroupName = sg; }

 void SetSpaceGroup(const int sg) { _spaceGroup = SpaceGroup::GetSpaceGroup (sg); }

 void SetLatticeType(const LatticeType lt) { _lattice = lt; }

 void FillUnitCell(OBMol *);


 double GetA();
 double GetA() const;
 double GetB();
 double GetB() const;
 double GetC();
 double GetC() const;
 double GetAlpha();
 double GetAlpha() const;
 double GetBeta();
 double GetBeta() const;
 double GetGamma();
 double GetGamma() const;
 vector3 GetOffset();
 vector3 GetOffset() const;

 const SpaceGroup* GetSpaceGroup() { return(_spaceGroup); }
 const SpaceGroup* GetSpaceGroup() const { return(_spaceGroup); }

 const std::string GetSpaceGroupName() { return(_spaceGroupName); }
 const std::string GetSpaceGroupName() const { return(_spaceGroupName); }

 LatticeType GetLatticeType( int spacegroup );
 LatticeType GetLatticeType( int spacegroup ) const;

 LatticeType GetLatticeType();
 LatticeType GetLatticeType() const;

 std::vector<vector3> GetCellVectors();
 std::vector<vector3> GetCellVectors() const;
 matrix3x3 GetCellMatrix();
 matrix3x3 GetCellMatrix() const;
 matrix3x3 GetOrthoMatrix();
 matrix3x3 GetOrthoMatrix() const;
 matrix3x3 GetOrientationMatrix();
 matrix3x3 GetOrientationMatrix() const;
 matrix3x3 GetFractionalMatrix();
 matrix3x3 GetFractionalMatrix() const;

 vector3 FractionalToCartesian(vector3 frac);
 vector3 FractionalToCartesian(vector3 frac) const;
 vector3 CartesianToFractional(vector3 cart);
 vector3 CartesianToFractional(vector3 cart) const;

 vector3 WrapCartesianCoordinate(vector3 cart);
 vector3 WrapCartesianCoordinate(vector3 cart) const;
 vector3 WrapFractionalCoordinate(vector3 frac);
 vector3 WrapFractionalCoordinate(vector3 frac) const;

 int GetSpaceGroupNumber( std::string name = "" );
 int GetSpaceGroupNumber( std::string name = "" ) const;
 double GetCellVolume();
 double GetCellVolume() const;
 };

 class OBAPI OBConformerData: public OBGenericData
 {
 protected:
 std::vector<unsigned short> _vDimension;
 std::vector<double> _vEnergies;
 std::vector< std::vector< vector3 > > _vForces;
 std::vector< std::vector< vector3 > > _vVelocity;
 std::vector< std::vector< vector3 > > _vDisplace;
 std::vector<std::string> _vData;

 public:
 OBConformerData();
 OBConformerData(const OBConformerData &);
 virtual OBGenericData* Clone(OBBase* /*parent*/) const{return new OBConformerData(*this);}
 ~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; }

 };

 class OBAPI OBSymmetryData: public OBGenericData
 {
 protected:
 std::string _spaceGroup;
 std::string _pointGroup;
 public:
 OBSymmetryData();
 OBSymmetryData(const OBSymmetryData &);
 virtual OBGenericData* Clone(OBBase* /*parent*/) const{return new OBSymmetryData(*this);}
 ~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; }
 };

 class OBAPI OBTorsion
 {
 friend class OBMol;
 friend class OBTorsionData;

 protected:
 std::pair<OBAtom*,OBAtom*> _bc;
 std::vector<triple<OBAtom*,OBAtom*,double> > _ads;

 OBTorsion(): _bc((OBAtom *)NULL, (OBAtom *)NULL) { }
 //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*/) { return false; }

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

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

 bool IsProtonRotor();
 };

 class OBAPI OBTorsionData : public OBGenericData
 {
 friend class OBMol;

 protected:
 std::vector<OBTorsion> _torsions;

 OBTorsionData();
 OBTorsionData(const OBTorsionData &);

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

 virtual OBGenericData* Clone(OBBase* /*parent*/) const
 {return new OBTorsionData(*this);}

 void Clear();

 std::vector<OBTorsion> GetData() const
 {
 return _torsions;
 }

 size_t GetSize() const
 {
 return _torsions.size();
 }

 void SetData(OBTorsion &torsion);

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

 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 angle)
 {
 _radians = angle;
 }
 void SetAtoms(OBAtom *vertex,OBAtom *a,OBAtom *b);
 void SetAtoms(triple<OBAtom*,OBAtom*,OBAtom*> &atoms);

 };

 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 &);
 virtual OBGenericData* Clone(OBBase* /*parent*/) const
 {return new OBAngleData(*this);}

 void Clear();
 unsigned int FillAngleArray(int **angles, unsigned int &size);
 bool FillAngleArray(std::vector<std::vector<unsigned int> > &angles);

 void SetData(OBAngle &);
 size_t GetSize() const
 {
 return _angles.size();
 }
 };


 class OBSerialNums : public OBGenericData
 {
 protected:
 std::map<int, OBAtom*> _serialMap; 

 public:

 OBSerialNums() :
 OBGenericData("obSerialNums", OBGenericDataType::SerialNums)
 {}

 OBSerialNums(const OBSerialNums &cp) : OBGenericData(cp)
 {
 _serialMap = cp._serialMap;
 }
 virtual OBGenericData* Clone(OBBase* /*parent*/) const
 {return new OBSerialNums(*this);}

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

 };

 class OBAPI OBVibrationData: public OBGenericData
 {
 protected:
 std::vector< std::vector< vector3 > > _vLx;

 std::vector<double> _vFrequencies;

 std::vector<double> _vIntensities;

 std::vector<double> _vRamanActivities;

 public:
 OBVibrationData(): OBGenericData("VibrationData", OBGenericDataType::VibrationData){};
 virtual ~OBVibrationData() {}
 virtual OBGenericData* Clone(OBBase*) const
 {return new OBVibrationData(*this);}

 OBVibrationData & operator=(const OBVibrationData &);

 void SetData(const std::vector< std::vector< vector3 > > & lx,
 const std::vector<double> & frequencies,
 const std::vector<double> & intensities);
 void SetData(const std::vector< std::vector< vector3 > > &,
 const std::vector<double> &,
 const std::vector<double> &,
 const std::vector<double> &);

 std::vector< std::vector< vector3 > > GetLx() const
 { return this->_vLx; }
 std::vector<double> GetFrequencies() const
 { return this->_vFrequencies; }
 std::vector<double> GetIntensities() const
 { return this->_vIntensities; }
 std::vector<double> GetRamanActivities() const
 { return this->_vRamanActivities; }

 unsigned int GetNumberOfFrequencies() const;
};

 class OBAPI OBDOSData: public OBGenericData
 {
 protected:
 double _fermi;

 std::vector<double> _vEnergies;

 std::vector<double> _vDensities;

 std::vector<double> _vIntegration;

 public:
 OBDOSData(): OBGenericData("DOSData", OBGenericDataType::DOSData){};
 virtual ~OBDOSData() {}
 virtual OBGenericData* Clone(OBBase*) const
 {return new OBDOSData(*this);}

 OBDOSData & operator=(const OBDOSData &);

 void SetData(double,
 const std::vector<double> &,
 const std::vector<double> &,
 const std::vector<double> &);

 double GetFermiEnergy() const
 { return this->_fermi; }
 std::vector<double> GetEnergies() const
 { return this->_vEnergies; }
 std::vector<double> GetDensities() const
 { return this->_vDensities; }
 std::vector<double> GetIntegration() const
 { return this->_vIntegration; }
 };

 class OBAPI OBOrbital
 {
 friend class OBOrbitalData;
 protected:
 double _energy; 
 double _occupation; 
 std::string _mullikenSymbol; 
 public:
 void SetData(double energy, double occupation = 2.0, std::string symbol = "A")
 { _energy = energy; _occupation = occupation; _mullikenSymbol = symbol; }

 double GetEnergy() const { return _energy; }
 double GetOccupation() const { return _occupation; }
 std::string GetSymbol() const { return _mullikenSymbol; }
 };

 class OBAPI OBOrbitalData: public OBGenericData
 {
 public:
 OBOrbitalData(): OBGenericData("OrbitalData", OBGenericDataType::ElectronicData),
 _alphaHOMO(0), _betaHOMO(0), _openShell(false) {};
 virtual ~OBOrbitalData() {}
 virtual OBGenericData* Clone(OBBase*) const
 {return new OBOrbitalData(*this);}

 OBOrbitalData & operator=(const OBOrbitalData &);

 void SetAlphaOrbitals(std::vector<OBOrbital> orbitalList)
 { _alphaOrbitals = orbitalList; }
 void SetBetaOrbitals(std::vector<OBOrbital> orbitalList)
 { _betaOrbitals = orbitalList; }
 void SetHOMO(int alpha, int beta = 0)
 { _alphaHOMO = alpha; _betaHOMO = beta; }
 void SetOpenShell(bool openShell)
 { _openShell = openShell; }

 bool IsOpenShell() { return _openShell; }

 unsigned int GetAlphaHOMO() { return _alphaHOMO; }
 unsigned int GetBetaHOMO() { return _betaHOMO; }
 std::vector<OBOrbital> GetAlphaOrbitals() { return _alphaOrbitals; }
 std::vector<OBOrbital> GetBetaOrbitals() { return _betaOrbitals; }

 void LoadClosedShellOrbitals(std::vector<double> energies, std::vector<std::string> symmetries, unsigned int alphaHOMO);
 void LoadAlphaOrbitals(std::vector<double> energies, std::vector<std::string> symmetries, unsigned int alphaHOMO);
 void LoadBetaOrbitals(std::vector<double> energies, std::vector<std::string> symmetries, unsigned int betaHOMO);

 protected:
 std::vector<OBOrbital> _alphaOrbitals; 
 std::vector<OBOrbital> _betaOrbitals; 
 unsigned int _alphaHOMO; 
 unsigned int _betaHOMO; 
 bool _openShell; 
 };

 class OBAPI OBElectronicTransitionData: public OBGenericData
 {
 protected:
 std::vector<double> _vWavelengths;

 std::vector<double> _vForces;

 std::vector<double> _vEDipole;

 std::vector<double> _vRotatoryStrengthsVelocity;

 std::vector<double> _vRotatoryStrengthsLength;

 public:
 OBElectronicTransitionData(): OBGenericData("ElectronicTransitionData", OBGenericDataType::ElectronicTransitionData) {}
 virtual ~OBElectronicTransitionData() {}
 virtual OBGenericData* Clone(OBBase*) const
 {return new OBElectronicTransitionData(*this);}

 OBElectronicTransitionData & operator=(const OBElectronicTransitionData &);

 void SetData(const std::vector<double> & wavelengths,
 const std::vector<double> & forces);

 void SetEDipole(const std::vector<double> &);
 void SetRotatoryStrengthsVelocity(const std::vector<double> &);
 void SetRotatoryStrengthsLength(const std::vector<double> &);

 std::vector<double> GetWavelengths() const
 { return this->_vWavelengths; }
 std::vector<double> GetForces() const
 { return this->_vForces; }
 std::vector<double> GetEDipole() const
 { return this->_vEDipole; }
 std::vector<double> GetRotatoryStrengthsVelocity() const
 { return this->_vRotatoryStrengthsVelocity; }
 std::vector<double> GetRotatoryStrengthsLength() const
 { return this->_vRotatoryStrengthsLength; }
};

 class OBAPI OBRotationData: public OBGenericData
 {
 public:
 enum RType{UNKNOWN, ASYMMETRIC, SYMMETRIC, LINEAR};
 OBRotationData(): OBGenericData("RotationData", OBGenericDataType::RotationData){}
 virtual ~OBRotationData(){};
 virtual OBGenericData* Clone(OBBase*) const
 {return new OBRotationData(*this);}
 void SetData(RType RotorType, std::vector<double> RotationalConstants, int SymmetryNumber)
 {
 RotConsts = RotationalConstants;
 type = RotorType;
 SymNum = SymmetryNumber;
 }

 std::vector<double> GetRotConsts()const{ return RotConsts; }

 int GetSymmetryNumber()const{ return SymNum; }
 RType GetRotorType()const { return type; }

 protected:
 std::vector<double> RotConsts;
 int SymNum; 
 RType type; 
 };

 class OBAPI OBVectorData: public OBGenericData
 {
 public:
 OBVectorData(): OBGenericData("VectorData", OBGenericDataType::VectorData){}
 virtual ~OBVectorData(){};
 virtual OBGenericData* Clone(OBBase*) const
 {return new OBVectorData(*this);}
 void SetData(double x, double y, double z)
 { _vec = vector3(x, y, z); }
 void SetData(vector3 data)
 { _vec = data; }
 vector3 GetData() const
 { return _vec; }

 protected:
 vector3 _vec; 
 };

 class OBAPI OBMatrixData: public OBGenericData
 {
 public:
 OBMatrixData(): OBGenericData("MatrixData", OBGenericDataType::MatrixData){}
 virtual ~OBMatrixData(){};
 virtual OBGenericData* Clone(OBBase*) const
 {return new OBMatrixData(*this);}
 void SetData(matrix3x3 data)
 { _matrix = data; }
 matrix3x3 GetData() const
 { return _matrix; }

 protected:
 matrix3x3 _matrix; 
 };

 class OBAPI OBFreeGridPoint
 {
 protected:
 double _x,_y,_z,_V;
 
 public:
 OBFreeGridPoint() {};
 OBFreeGridPoint(double x,double y,double z,double V) { _x = x; _y = y; _z = z; _V = V; }
 ~OBFreeGridPoint() {};
 double GetX() { return _x; }
 double GetY() { return _y; }
 double GetZ() { return _z; }
 double GetV() { return _V; }
 void SetX(double x) { _x = x; }
 void SetY(double y) { _y = y; }
 void SetZ(double z) { _z = z; }
 void SetV(double V) { _V = V; }
 };
 
 typedef std::vector<OBFreeGridPoint*>::iterator OBFreeGridPointIterator;

 class OBAPI OBFreeGrid: public OBGenericData
 {
 protected:
 std::vector<OBFreeGridPoint*> _points; 
 public:

 OBFreeGrid() 
 {
 }
 
 ~OBFreeGrid() 
 {
 //delete _points;
 }

 int NumPoints() 
 { 
 return (int)_points.size();
 }
 
 void AddPoint(double x,double y,double z, double V) 
 {
 _points.push_back(new OpenBabel::OBFreeGridPoint(x,y,z,V));
 }

 OBFreeGridPointIterator BeginPoints() 
 { 
 return _points.begin(); 
 }
 
 OBFreeGridPointIterator EndPoints() 
 {
 return _points.begin() + NumPoints(); 
 }
 
 OBFreeGridPoint *BeginPoint(OBFreeGridPointIterator &i)
 {
 i = _points.begin();
 return((i == _points.end()) ? (OBFreeGridPoint*)NULL : (OBFreeGridPoint*)*i);
 }

 OBFreeGridPoint *NextPoint(OBFreeGridPointIterator &i)
 {
 ++i;
 return((i == _points.end()) ? (OBFreeGridPoint*)NULL : (OBFreeGridPoint*)*i);
 }
 
 void Clear();

 };
 
 class OBAPI OBPcharge: public OBGenericData
 {
 protected:
 std::vector<double> _PartialCharge;
 public:
 OBPcharge(){};
 ~OBPcharge(){};

 int NumPartialCharges() 
 { 
 return (int)_PartialCharge.size(); 
 }
 
 void AddPartialCharge(std::vector<double> q)
 {
 _PartialCharge = q;
 }

 std::vector<double> GetPartialCharge()
 {
 return _PartialCharge;
 }
 };

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

} //end namespace OpenBabel

#endif // OB_GENERIC_H