data.h

Go to the documentation of this file.

/**********************************************************************
data.h - Global data and resource file parsers.

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2006 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_DATA_H
#define OB_DATA_H

#include <openbabel/babelconfig.h>

#include <stdio.h>
#include <cstring>
#include <fstream>
#include <vector>
#include <string>
#include <cstring>

namespace OpenBabel
{

  class OBAtom;
  class OBMol;
  class OBBitVec;

  class OBAPI OBGlobalDataBase
    {
    protected:
      bool         _init;               
      const char  *_dataptr;
      std::string  _filename;
      std::string  _dir;                
      std::string  _subdir;     
      std::string  _envvar;     

    public:
      OBGlobalDataBase(): _init(false), _dataptr(NULL) { }
      virtual ~OBGlobalDataBase()                  {}
      void  Init();
      virtual size_t GetSize()                 { return 0;}
      void  SetReadDirectory(char *dir)            { _dir = dir;    }
      void  SetEnvironmentVariable(char *var)      { _envvar = var; }
      virtual void ParseLine(const char*)          {}
    };

  class OBAPI OBElement
    {
      int _num;
      char _symbol[4];
      std::string _name;
      double _Rcov,_Rvdw,_mass,_elNeg,_ARENeg,_ionize,_elAffinity;
      double _red, _green, _blue;
      int _maxbonds;
    public:
      OBElement()    {}
      OBElement(int num, const char *sym, double ARENeg, double rcov,
                double rvdw, int maxbo, double mass, double elNeg, double ionize,
                double elAffin, double red, double green, double blue,
                std::string name) :
        _num(num), _name(name), _Rcov(rcov), _Rvdw(rvdw), _mass(mass),
        _elNeg(elNeg), _ARENeg(ARENeg), _ionize(ionize), _elAffinity(elAffin),
        _red(red), _green(green), _blue(blue),
        _maxbonds(maxbo)
        {
          strncpy(_symbol, sym, 4);
        }

      int GetAtomicNum()         {       return(_num);    }
      char *GetSymbol()          {       return(_symbol); }
      double GetCovalentRad()    {       return(_Rcov);   }
      double GetVdwRad()         {       return(_Rvdw);   }
      double GetMass()           {       return(_mass);   }
      int GetMaxBonds()          {       return(_maxbonds);}
      double GetElectroNeg()     {       return(_elNeg);  }
      double GetAllredRochowElectroNeg() { return(_ARENeg); }
      double GetIonization()     {       return(_ionize);  }
      double GetElectronAffinity(){      return(_elAffinity);  }
      std::string GetName()      {       return(_name);    }
      double GetRed()            {       return(_red);     }
      double GetGreen()          {       return(_green);   }
      double GetBlue()           {       return(_blue);    }
    };

  // class introduction in data.cpp
  class OBAPI OBElementTable : public OBGlobalDataBase
    {
      std::vector<OBElement*> _element;

    public:

      OBElementTable(void);
      ~OBElementTable();

      void  ParseLine(const char*);

      unsigned int              GetNumberOfElements();
      size_t    GetSize() { return GetNumberOfElements(); }

      int   GetAtomicNum(const char *);
      int   GetAtomicNum(const char *, int &iso);
      int   GetAtomicNum(std::string name, int &iso);
      const char *GetSymbol(int);
      double GetVdwRad(int);
      double GetCovalentRad(int);
      double GetMass(int);
      double CorrectedBondRad(int,int = 3); // atomic #, hybridization
      double CorrectedVdwRad(int,int = 3); // atomic #, hybridization
      int       GetMaxBonds(int);
      double GetElectroNeg(int);
      double GetAllredRochowElectroNeg(int);
      double GetIonization(int);
      double GetElectronAffinity(int);
      std::vector<double> GetRGB(int);
      std::string GetName(int);
    };

  // class introduction in data.cpp
  class OBAPI OBIsotopeTable : public OBGlobalDataBase
    {
      std::vector<std::vector<std::pair <unsigned int, double> > > _isotopes;

    public:

      OBIsotopeTable(void);
      ~OBIsotopeTable()    {}

      size_t GetSize() { return _isotopes.size(); }

      void      ParseLine(const char*);
      double    GetExactMass(const unsigned int atomicNum,
                           const unsigned int isotope = 0);
    };

  // class introduction in data.cpp
  class OBAPI OBTypeTable : public OBGlobalDataBase
    {
      int             _linecount;
      unsigned int    _ncols,_nrows;
      int             _from,_to;
      std::vector<std::string> _colnames;
      std::vector<std::vector<std::string> > _table;

    public:

      OBTypeTable(void);
      ~OBTypeTable() {}

      void ParseLine(const char*);

      size_t GetSize() { return _table.size(); }

      bool SetFromType(const char*);
      bool SetToType(const char*);
      bool Translate(char *to, const char *from); // to, from
      bool Translate(std::string &to, const std::string &from); // to, from
      std::string Translate(const std::string &from);

      std::string GetFromType();
      std::string GetToType();
    };

  class OBAPI OBResidueData : public OBGlobalDataBase
    {
      int                                               _resnum;
      std::vector<std::string>                          _resname;
      std::vector<std::vector<std::string> >            _resatoms;
      std::vector<std::vector<std::pair<std::string,int> > > _resbonds;

      //variables used only temporarily for parsing resdata.txt
      std::vector<std::string>                          _vatmtmp;
      std::vector<std::pair<std::string,int> >          _vtmp;
    public:

      OBResidueData();
      void ParseLine(const char*);

      size_t GetSize() { return _resname.size(); }

      bool SetResName(const std::string &);
      int  LookupBO(const std::string &);
      int  LookupBO(const std::string &, const std::string&);
      bool LookupType(const std::string &,std::string&,int&);
      bool AssignBonds(OBMol &,OBBitVec &);
    };

} // end namespace OpenBabel

#endif //DATA_H