00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef OB_GENERIC_H
00021 #define OB_GENERIC_H
00022
00023 #include <openbabel/babelconfig.h>
00024
00025 #include <string>
00026 #include <vector>
00027 #include <map>
00028
00029 #include <openbabel/math/spacegroup.h>
00030 #include <openbabel/obutil.h>
00031 #include <openbabel/base.h>
00032
00033 namespace OpenBabel
00034 {
00035
00036
00037 class OBBase;
00038 class OBAtom;
00039 class OBBond;
00040 class OBMol;
00041 class OBRing;
00042
00045 class OBAPI OBCommentData : public OBGenericData
00046 {
00047 protected:
00048 std::string _data;
00049 public:
00050 OBCommentData();
00051 OBCommentData(const OBCommentData&);
00052 virtual OBGenericData* Clone(OBBase* ) const{return new OBCommentData(*this);}
00053
00054 OBCommentData& operator=(const OBCommentData &src);
00055
00056 void SetData(const std::string &data)
00057 { _data = data; Trim(_data); }
00058 void SetData(const char *d)
00059 {_data = d; Trim(_data); }
00060 const std::string &GetData() const
00061 { return(_data); }
00062 virtual const std::string &GetValue() const
00063 { return(_data); }
00064 };
00065
00069 class OBAPI OBExternalBond
00070 {
00071 int _idx;
00072 OBAtom *_atom;
00073 OBBond *_bond;
00074 public:
00075 OBExternalBond(): _idx(0), _atom(NULL), _bond(NULL) {}
00076 OBExternalBond(OBAtom *,OBBond *,int);
00077 OBExternalBond(const OBExternalBond &);
00078 ~OBExternalBond() {}
00079
00080 int GetIdx() const { return(_idx); }
00081 OBAtom *GetAtom() const { return(_atom); }
00082 OBBond *GetBond() const { return(_bond); }
00083 void SetIdx(int idx) { _idx = idx; }
00084 void SetAtom(OBAtom *atom) { _atom = atom; }
00085 void SetBond(OBBond *bond) { _bond = bond; }
00086 };
00087
00090 class OBAPI OBExternalBondData : public OBGenericData
00091 {
00092 protected:
00093 std::vector<OBExternalBond> _vexbnd;
00094 public:
00095 OBExternalBondData();
00096
00097
00098 virtual OBGenericData* Clone(OBBase* ) const{return NULL;}
00099
00100 void SetData(OBAtom*,OBBond*,int);
00101 std::vector<OBExternalBond> *GetData()
00102 {
00103 return(&_vexbnd);
00104 }
00105 };
00106
00112 class OBAPI OBPairData : public OBGenericData
00113 {
00114 protected:
00115 std::string _value;
00116 public:
00117 OBPairData();
00118 virtual OBGenericData* Clone(OBBase* ) const
00119 {return new OBPairData(*this);}
00120 void SetValue(const char *v) { _value = v; }
00121 void SetValue(const std::string &v) { _value = v; }
00122 virtual const std::string &GetValue() const
00123 { return(_value); }
00124 };
00125
00128
00129 template <class ValueT>
00130 class OBAPI OBPairTemplate : public OBGenericData
00131 {
00132 protected:
00133 ValueT _value;
00134 public:
00135 OBPairTemplate():
00136 OBGenericData("PairData", OBGenericDataType::PairData) {};
00137 void SetValue(const ValueT t) { _value = t; }
00138 virtual const ValueT &GetGenericValue() const { return(_value); }
00139 };
00140
00142 typedef OBPairTemplate<int> OBPairInteger;
00144 typedef OBPairTemplate<double> OBPairFloatingPoint;
00145
00149 class OBAPI OBSetData : public OBGenericData
00150 {
00151 protected:
00152 std::vector<OBGenericData *> _vdata;
00153 public:
00154 OBSetData() : OBGenericData("SetData", OBGenericDataType::SetData) {}
00155 virtual OBGenericData* Clone(OBBase* ) const{return new OBSetData(*this);}
00156
00158 void AddData(OBGenericData *d)
00159 {
00160 if(d)
00161 {
00162 _vdata.push_back(d);
00163 }
00164 }
00165
00167 void SetData(std::vector<OBGenericData *> &vdata)
00168 {
00169 _vdata = vdata;
00170 }
00171
00173 OBGenericData *GetData(const char *s)
00174 {
00175 std::vector<OBGenericData*>::iterator i;
00176
00177 for (i = _vdata.begin();i != _vdata.end();++i)
00178 if ((*i)->GetAttribute() == s)
00179 return(*i);
00180
00181 return(NULL);
00182 }
00183
00185 OBGenericData *GetData(const std::string &s)
00186 {
00187 std::vector<OBGenericData*>::iterator i;
00188
00189 for (i = _vdata.begin();i != _vdata.end();++i)
00190 if ((*i)->GetAttribute() == s)
00191 return(*i);
00192
00193 return(NULL);
00194 }
00195
00197 virtual const std::vector<OBGenericData *> &GetData() const
00198 {
00199 return(_vdata);
00200 }
00201
00203 std::vector<OBGenericData*>::iterator GetBegin()
00204 {
00205 return _vdata.begin();
00206 }
00207
00209 std::vector<OBGenericData*>::iterator GetEnd()
00210 {
00211 return _vdata.end();
00212 }
00213
00215 void DeleteData(OBGenericData *gd)
00216 {
00217 std::vector<OBGenericData*>::iterator i;
00218 for (i = _vdata.begin();i != _vdata.end();++i)
00219 if (*i == gd)
00220 {
00221 delete *i;
00222 _vdata.erase(i);
00223 }
00224 }
00225
00226 };
00227
00231 class OBAPI OBVirtualBond : public OBGenericData
00232 {
00233 protected:
00234 int _bgn;
00235 int _end;
00236 int _ord;
00237 int _stereo;
00238 public:
00239 OBVirtualBond();
00240 virtual OBGenericData* Clone(OBBase* ) const{return new OBVirtualBond(*this);}
00241 OBVirtualBond(int,int,int,int stereo=0);
00242 int GetBgn() { return(_bgn); }
00243 int GetEnd() { return(_end); }
00244 int GetOrder() { return(_ord); }
00245 int GetStereo() { return(_stereo); }
00246 };
00247
00250 class OBAPI OBRingData : public OBGenericData
00251 {
00252 protected:
00253 std::vector<OBRing*> _vr;
00254 public:
00255 OBRingData();
00256 OBRingData(const OBRingData &);
00257 virtual OBGenericData* Clone(OBBase* ) const{return new OBRingData(*this);}
00258 ~OBRingData();
00259
00260 OBRingData &operator=(const OBRingData &);
00261
00262 void SetData(std::vector<OBRing*> &vr)
00263 {
00264 _vr = vr;
00265 }
00266 void PushBack(OBRing *r)
00267 {
00268 _vr.push_back(r);
00269 }
00270 std::vector<OBRing*> &GetData()
00271 {
00272 return(_vr);
00273 }
00274
00275 std::vector<OBRing*>::iterator BeginRings()
00276 { return(_vr.begin()); }
00277 std::vector<OBRing*>::iterator EndRings()
00278 { return(_vr.end()); }
00279 OBRing *BeginRing(std::vector<OBRing*>::iterator &i);
00280 OBRing *NextRing(std::vector<OBRing*>::iterator &i);
00281 };
00282
00287 class OBAPI OBUnitCell: public OBGenericData
00288 {
00289 public:
00290 enum LatticeType { Undefined,
00291 Triclinic,
00292 Monoclinic,
00293 Orthorhombic,
00294 Tetragonal,
00295 Rhombohedral ,
00296 Hexagonal,
00297 Cubic};
00298
00299
00300 protected:
00301 double _a, _b, _c, _alpha, _beta, _gamma;
00302 vector3 _offset;
00303 vector3 _v1, _v2, _v3;
00304 std::string _spaceGroupName;
00305 const SpaceGroup* _spaceGroup;
00306 LatticeType _lattice;
00307 public:
00309 OBUnitCell();
00310 OBUnitCell(const OBUnitCell &);
00311 virtual OBGenericData* Clone(OBBase* ) const
00312 {return new OBUnitCell(*this);}
00313 ~OBUnitCell() {}
00314
00315 OBUnitCell &operator=(const OBUnitCell &);
00316
00326 void SetData(const double a, const double b, const double c,
00327 const double alpha, const double beta, const double gamma)
00328 { _a = a; _b = b; _c = c;
00329 _alpha = alpha; _beta = beta; _gamma = gamma; }
00330 void SetData(const vector3 v1, const vector3 v2, const vector3 v3);
00331
00333 void SetOffset(const vector3 v1) { _offset = v1; }
00334
00337 void SetSpaceGroup(const SpaceGroup* sg) { _spaceGroup = sg; }
00338
00342 void SetSpaceGroup(const std::string sg) { _spaceGroup = SpaceGroup::GetSpaceGroup (sg);
00343 _spaceGroupName = sg; }
00344
00350 void SetSpaceGroup(const int sg) { _spaceGroup = SpaceGroup::GetSpaceGroup (sg); }
00351
00353 void SetLatticeType(const LatticeType lt) { _lattice = lt; }
00354
00357 void FillUnitCell(OBMol *);
00358
00360 double GetA() { return(_a); }
00362 double GetB() { return(_b); }
00364 double GetC() { return(_c); }
00366 double GetAlpha(){ return(_alpha);}
00368 double GetBeta() { return(_beta); }
00370 double GetGamma(){ return(_gamma);}
00372 vector3 GetOffset() { return(_offset); }
00373
00375 const SpaceGroup* GetSpaceGroup() { return(_spaceGroup); }
00376
00378 const std::string GetSpaceGroupName() { return(_spaceGroupName); }
00379
00381 LatticeType GetLatticeType( int spacegroup );
00382
00384 LatticeType GetLatticeType();
00385
00387 std::vector<vector3> GetCellVectors();
00389 matrix3x3 GetCellMatrix();
00391 matrix3x3 GetOrthoMatrix();
00393 matrix3x3 GetFractionalMatrix();
00394
00396 int GetSpaceGroupNumber( std::string name = "" );
00398 double GetCellVolume();
00399 };
00400
00406 class OBAPI OBConformerData: public OBGenericData
00407 {
00408 protected:
00410 std::vector<unsigned short> _vDimension;
00412 std::vector<double> _vEnergies;
00414 std::vector< std::vector< vector3 > > _vForces;
00416 std::vector< std::vector< vector3 > > _vVelocity;
00418 std::vector< std::vector< vector3 > > _vDisplace;
00420 std::vector<std::string> _vData;
00421
00422 public:
00423 OBConformerData();
00424 OBConformerData(const OBConformerData &);
00425 virtual OBGenericData* Clone(OBBase* ) const{return new OBConformerData(*this);}
00426 ~OBConformerData() {}
00427
00428 OBConformerData &operator=(const OBConformerData &);
00429
00430 void SetDimension(std::vector<unsigned short> vd) { _vDimension = vd; }
00431 void SetEnergies(std::vector<double> ve) { _vEnergies = ve; }
00432 void SetForces(std::vector< std::vector< vector3 > > vf) {_vForces = vf;}
00433 void SetVelocities(std::vector< std::vector< vector3 > > vv)
00434 { _vVelocity = vv; }
00435 void SetDisplacements(std::vector< std::vector< vector3 > > vd)
00436 { _vDisplace = vd; }
00437 void SetData(std::vector<std::string> vdat) { _vData = vdat; }
00438
00439 std::vector<unsigned short> GetDimension() { return _vDimension; }
00440 std::vector<double> GetEnergies() { return _vEnergies; }
00441 std::vector< std::vector< vector3 > > GetForces() {return _vForces; }
00442 std::vector< std::vector< vector3 > > GetVelocities()
00443 {return _vVelocity;}
00444 std::vector< std::vector< vector3 > > GetDisplacements()
00445 {return _vDisplace;}
00446 std::vector<std::string> GetData() { return _vData; }
00447
00448 };
00449
00454 class OBAPI OBSymmetryData: public OBGenericData
00455 {
00456 protected:
00457 std::string _spaceGroup;
00458 std::string _pointGroup;
00459 public:
00460 OBSymmetryData();
00461 OBSymmetryData(const OBSymmetryData &);
00462 virtual OBGenericData* Clone(OBBase* ) const{return new OBSymmetryData(*this);}
00463 ~OBSymmetryData() {}
00464
00465 OBSymmetryData &operator=(const OBSymmetryData &);
00466
00467 void SetData(std::string pg, std::string sg = "")
00468 { _pointGroup = pg; _spaceGroup = sg; }
00469 void SetPointGroup(std::string pg) { _pointGroup = pg; }
00470 void SetSpaceGroup(std::string sg) { _spaceGroup = sg; }
00471
00472 std::string GetPointGroup() { return _pointGroup; }
00473 std::string GetSpaceGroup() { return _spaceGroup; }
00474 };
00475
00479 class OBAPI OBTorsion
00480 {
00481 friend class OBMol;
00482 friend class OBTorsionData;
00483
00484 protected:
00485 std::pair<OBAtom*,OBAtom*> _bc;
00487 std::vector<triple<OBAtom*,OBAtom*,double> > _ads;
00488
00489 OBTorsion(): _bc(NULL, NULL) { }
00490
00491 OBTorsion(OBAtom *, OBAtom *, OBAtom *, OBAtom *);
00492
00493 std::vector<quad<OBAtom*,OBAtom*,OBAtom*,OBAtom*> > GetTorsions();
00494
00495 public:
00496 OBTorsion(const OBTorsion &);
00497 ~OBTorsion() {}
00498
00499 OBTorsion& operator=(const OBTorsion &);
00500
00501 void Clear();
00502 bool Empty() { return(_bc.first == 0 && _bc.second == 0); }
00503
00504 bool AddTorsion(OBAtom *a,OBAtom *b, OBAtom *c,OBAtom *d);
00505 bool AddTorsion(quad<OBAtom*,OBAtom*,OBAtom*,OBAtom*> &atoms);
00506
00507 bool SetAngle(double radians, unsigned int index = 0);
00508 bool SetData(OBBond * ) { return false; }
00509
00510 bool GetAngle(double &radians, unsigned int index =0);
00513 unsigned int GetBondIdx();
00514 unsigned int GetSize() const { return _ads.size(); }
00515
00518 std::pair<OBAtom*,OBAtom*> GetBC()
00519 {
00520 return(_bc);
00521 }
00524 std::vector<triple<OBAtom*,OBAtom*,double> > GetADs()
00525 {
00526 return(_ads) ;
00527 }
00528
00529 bool IsProtonRotor();
00530 };
00531
00536 class OBAPI OBTorsionData : public OBGenericData
00537 {
00538 friend class OBMol;
00539
00540 protected:
00541 std::vector<OBTorsion> _torsions;
00542
00543 OBTorsionData();
00544 OBTorsionData(const OBTorsionData &);
00545
00546 public:
00547 OBTorsionData &operator=(const OBTorsionData &);
00548
00550 virtual OBGenericData* Clone(OBBase* ) const
00551 {return new OBTorsionData(*this);}
00552
00553 void Clear();
00554
00557 std::vector<OBTorsion> GetData() const
00558 {
00559 return _torsions;
00560 }
00561
00564 unsigned int GetSize() const
00565 {
00566 return _torsions.size();
00567 }
00568
00569 void SetData(OBTorsion &torsion);
00570
00571 bool FillTorsionArray(std::vector<std::vector<unsigned int> > &torsions);
00572 };
00573
00576 class OBAPI OBAngle
00577 {
00578 friend class OBMol;
00579 friend class OBAngleData;
00580
00581 protected:
00582
00583
00584
00585 OBAtom *_vertex;
00586 std::pair<OBAtom*,OBAtom*> _termini;
00587 double _radians;
00588
00589
00590
00591 OBAngle();
00592 OBAngle(OBAtom *vertex,OBAtom *a,OBAtom *b);
00593
00594 triple<OBAtom*,OBAtom*,OBAtom*> GetAtoms();
00595 void SortByIndex();
00596
00597 public:
00598
00599 OBAngle(const OBAngle &);
00600 ~OBAngle()
00601 {
00602 _vertex = NULL;
00603 }
00604
00605 OBAngle &operator = (const OBAngle &);
00606 bool operator ==(const OBAngle &);
00607
00608 void Clear();
00609
00612 double GetAngle() const
00613 {
00614 return(_radians);
00615 }
00618 void SetAngle(double angle)
00619 {
00620 _radians = angle;
00621 }
00622 void SetAtoms(OBAtom *vertex,OBAtom *a,OBAtom *b);
00623 void SetAtoms(triple<OBAtom*,OBAtom*,OBAtom*> &atoms);
00624
00625 };
00626
00629 class OBAPI OBAngleData : public OBGenericData
00630 {
00631 friend class OBMol;
00632
00633 protected:
00634 std::vector<OBAngle> _angles;
00635
00636 OBAngleData();
00637 OBAngleData(const OBAngleData &);
00639
00640 std::vector<OBAngle> GetData() const
00641 {
00642 return(_angles);
00643 }
00644
00645 public:
00646 OBAngleData &operator =(const OBAngleData &);
00647 virtual OBGenericData* Clone(OBBase* ) const
00648 {return new OBAngleData(*this);}
00649
00650 void Clear();
00651 unsigned int FillAngleArray(int **angles, unsigned int &size);
00652 bool FillAngleArray(std::vector<std::vector<unsigned int> > &angles);
00653
00654 void SetData(OBAngle &);
00657 unsigned int GetSize() const
00658 {
00659 return _angles.size();
00660 }
00661 };
00662
00663 enum atomreftype{
00664 output,
00665 input,
00666 calcvolume
00667 };
00668
00671 class OBAPI OBChiralData : public OBGenericData
00672 {
00673 friend class OBMol;
00674 friend class OBAtom;
00675
00676 protected:
00677 std::vector<unsigned int> _atom4refs;
00678 std::vector<unsigned int> _atom4refo;
00679 std::vector<unsigned int> _atom4refc;
00680
00683 int parity;
00684
00685 public:
00686
00687 OBChiralData();
00688 OBChiralData(const OBChiralData &src);
00689 virtual OBGenericData* Clone(OBBase* ) const
00690 { return new OBChiralData(*this); }
00691 OBChiralData &operator =(const OBChiralData &);
00692 ~OBChiralData(){}
00693
00694 void Clear();
00695
00697 std::vector<unsigned int> GetAtom4Refs(atomreftype t) const;
00699 unsigned int GetAtomRef(int a,atomreftype t);
00700
00701 bool SetAtom4Refs(std::vector<unsigned int> atom4refs, atomreftype t);
00702 int AddAtomRef(unsigned int atomref, atomreftype t);
00703
00705 unsigned int GetSize(atomreftype t) const;
00706 };
00707
00710 class OBSerialNums : public OBGenericData
00711 {
00712 protected:
00713 std::map<int, OBAtom*> _serialMap;
00714
00715 public:
00716
00717 OBSerialNums() :
00718 OBGenericData("obSerialNums", OBGenericDataType::SerialNums)
00719 {}
00720
00721 OBSerialNums(const OBSerialNums &cp) : OBGenericData(cp)
00722 {
00723 _serialMap = cp._serialMap;
00724 }
00727 virtual OBGenericData* Clone(OBBase* ) const
00728 {return new OBSerialNums(*this);}
00729
00730 std::map<int,OBAtom*> &GetData() { return _serialMap; }
00731 void SetData(std::map<int,OBAtom*> &sm) { _serialMap = sm; }
00732
00733 };
00734
00737 class OBAPI OBVibrationData: public OBGenericData
00738 {
00739 protected:
00741 std::vector< std::vector< vector3 > > _vLx;
00742
00744 std::vector<double> _vFrequencies;
00745
00747 std::vector<double> _vIntensities;
00748
00749
00750 public:
00751 OBVibrationData(): OBGenericData("VibrationData", OBGenericDataType::VibrationData){};
00752 virtual ~OBVibrationData() {}
00753 virtual OBGenericData* Clone(OBBase*) const
00754 {return new OBVibrationData(*this);}
00755
00756 OBVibrationData & operator=(const OBVibrationData &);
00757
00758 void SetData(const std::vector< std::vector< vector3 > > &,
00759 const std::vector<double> &,
00760 const std::vector<double> &);
00761
00762 std::vector< std::vector< vector3 > > GetLx() const
00763 { return this->_vLx; }
00764 std::vector<double> GetFrequencies() const
00765 { return this->_vFrequencies; }
00766 std::vector<double> GetIntensities() const
00767 { return this->_vIntensities; }
00768
00769 unsigned int GetNumberOfFrequencies() const;
00770 };
00771
00774 class OBAPI OBRotationData: public OBGenericData
00775 {
00776 public:
00777 enum RType{UNKNOWN, ASYMMETRIC, SYMMETRIC, LINEAR};
00778 OBRotationData(): OBGenericData("RotationData", OBGenericDataType::RotationData){}
00779 virtual ~OBRotationData(){};
00780 virtual OBGenericData* Clone(OBBase*) const
00781 {return new OBRotationData(*this);}
00782 void SetData(RType RotorType, std::vector<double> RotationalConstants, int SymmetryNumber)
00783 {
00784 RotConsts = RotationalConstants;
00785 type = RotorType;
00786 SymNum = SymmetryNumber;
00787 }
00788
00790 std::vector<double> GetRotConsts()const{ return RotConsts; }
00791
00792 int GetSymmetryNumber()const{ return SymNum; }
00793 RType GetRotorType()const { return type; }
00794
00795 protected:
00796 std::vector<double> RotConsts;
00797 int SymNum;
00798 RType type;
00799 };
00800
00804 class OBAPI OBVectorData: public OBGenericData
00805 {
00806 public:
00807 OBVectorData(): OBGenericData("VectorData", OBGenericDataType::VectorData){}
00808 virtual ~OBVectorData(){};
00809 virtual OBGenericData* Clone(OBBase*) const
00810 {return new OBVectorData(*this);}
00811 void SetData(double x, double y, double z)
00812 { _vec = vector3(x, y, z); }
00813 void SetData(vector3 data)
00814 { _vec = data; }
00815 vector3 GetData() const
00816 { return _vec; }
00817
00818 protected:
00819 vector3 _vec;
00820 };
00821
00825 class OBAPI OBMatrixData: public OBGenericData
00826 {
00827 public:
00828 OBMatrixData(): OBGenericData("MatrixData", OBGenericDataType::MatrixData){}
00829 virtual ~OBMatrixData(){};
00830 virtual OBGenericData* Clone(OBBase*) const
00831 {return new OBMatrixData(*this);}
00832 void SetData(matrix3x3 data)
00833 { _matrix = data; }
00834 matrix3x3 GetData() const
00835 { return _matrix; }
00836
00837 protected:
00838 matrix3x3 _matrix;
00839 };
00840
00842 typedef std::vector<OBGenericData*>::iterator OBDataIterator;
00843
00844 }
00845
00846 #endif // OB_GENERIC_H
00847