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 OBAPI OBPairTemplate : public OBGenericData
  {
  protected:
    ValueT _value; 
  public:
  OBPairTemplate():
    OBGenericData("PairData", OBGenericDataType::PairData) {};
    void SetValue(const ValueT t)             { _value = t;     }
    virtual const ValueT &GetGenericValue() const    { return(_value); }
  };

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

 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:
    int _bgn;
    int _end;
    int _ord;
    int _stereo;
  public:
    OBVirtualBond();
    virtual OBGenericData* Clone(OBBase* /*parent*/) const{return new OBVirtualBond(*this);}
    OBVirtualBond(int,int,int,int stereo=0);
    int GetBgn()    {      return(_bgn);    }
    int GetEnd()    {      return(_end);    }
    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 GetB();
    double GetC();
    double GetAlpha();
    double GetBeta();
    double GetGamma();
    vector3 GetOffset();

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

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

    LatticeType GetLatticeType( int spacegroup );

    LatticeType GetLatticeType();

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

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

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

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

 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();
    }
  };

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

 class OBAPI OBChiralData : public OBGenericData
  {
    friend class OBMol;
    friend class OBAtom;

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

    int parity;

  public:

    OBChiralData();
    OBChiralData(const OBChiralData &src);
    virtual OBGenericData* Clone(OBBase* /*parent*/) const
      { return new OBChiralData(*this); }
    OBChiralData &operator =(const OBChiralData &);
    ~OBChiralData(){}

    void Clear();

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

    bool SetAtom4Refs(std::vector<unsigned int> atom4refs, atomreftype t);
    int AddAtomRef(unsigned int atomref, atomreftype t);

    unsigned int GetSize(atomreftype t) const;
  };

 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, int alphaHOMO);
    void LoadAlphaOrbitals(std::vector<double> energies, std::vector<std::string> symmetries, int alphaHOMO);
    void LoadBetaOrbitals(std::vector<double> energies, std::vector<std::string> symmetries, 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; 
  };

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

} //end namespace OpenBabel

#endif // OB_GENERIC_H