src/openbabel/data.hpp

/**********************************************************************
data.h - Global data and resource file parsers.
 
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_DATA_H
#define OB_DATA_H

#include "babelconfig.hpp"

#include <stdio.h>

#if HAVE_IOSTREAM
#include <iostream>
#elif HAVE_IOSTREAM_H
#include <iostream.h>
#endif

#if HAVE_FSTREAM
#include <fstream>
#elif HAVE_FSTREAM_H
#include <fstream.h>
#endif

#include <vector>
#include <string>

namespace OpenBabel
{

class OBElement;
class OBAtom;
class OBElementTable;

class OBMol;
class OBBitVec;

//! \brief Base data table class, handles reading data files
//!
//! Base data table class--reads ASCII data files in various formats
//! -# Checks for the environment variable _envvar (defaults to "BABEL_DATADIR")
//!     - Tries the _subdir directory if defined (def. "data") and then the main directory
//! -# Checks for the directory _dir (def. determined by the build environment)
//!     - Tries the subdirectory corresponding to this version, then the main directory
//! -# Reverts to the compiled-in default data
class OBAPI OBGlobalDataBase
{
protected:
    bool         _init;         //!< whether the data been read already
    const char  *_dataptr;      //!< default data table if file is unreadable
    std::string  _filename;     //!< file to search for
    std::string  _dir;          //!< data directory for file if _envvar fails
    std::string  _subdir;       //!< subdirectory (if using environment variable)
    std::string  _envvar;       //!< environment variable to check first

public:
    //! Constructor
    OBGlobalDataBase()
    {
        _init = false;
        _dataptr = (char*)NULL;
    }
    //! Destructor
    virtual ~OBGlobalDataBase()                  {}
    //! Read in the data file, falling back as needed
    void  Init();
    //! \return the size of the database (for error checking)
    virtual unsigned int GetSize()                 { return 0;}
    //! Set the directory before calling Init()
    void  SetReadDirectory(char *dir)            { _dir = dir;    }
    //! Set the environment variable to use before calling Init()
    void  SetEnvironmentVariable(char *var)      { _envvar = var; }
    //! Specified by particular table classes (parses an individual data line)
    virtual void ParseLine(const char*)          {}
};

//! \brief Individual element data type
//!
//! Stores a variety of data about an individual element
class OBAPI OBElement
{
    int _num;
    char _symbol[3];
    std::string _name;
    double _Rcov,_Rvdw,_mass,_elNeg,_ionize,_elAffinity;
    double _red, _green, _blue;
    int _maxbonds;
public:
    OBElement()    {}
    OBElement(int num, const char *sym, 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), _ionize(ionize), _elAffinity(elAffin), 
      _red(red), _green(green), _blue(blue),
      _maxbonds(maxbo)
    {
      strncpy(_symbol, sym, 3);
    }

    //! \return the atomic number of this element
    int GetAtomicNum()         {       return(_num);    }
    //! \return the atomic symbol for this element
    char *GetSymbol()          {       return(_symbol); }
    //! \return the covalent radius of this element
    double GetCovalentRad()    {       return(_Rcov);   }
    //! \return the van der Waals radius of this element
    double GetVdwRad()         {       return(_Rvdw);   }
    //! \return the standard atomic mass for this element (in amu)
    double GetMass()           {       return(_mass);   }
    //! \return the maximum expected number of bonds to this element
    int GetMaxBonds()          {       return(_maxbonds);}
    //! \return the Pauling electronegativity for this element
    double GetElectroNeg()     {       return(_elNeg);  }
    //! \return the ionization potential (in eV) of this element
    double GetIonization()     {       return(_ionize);  }
    //! \return the electron affinity (in eV) of this element
    double GetElectronAffinity(){      return(_elAffinity);  }
    //! \return the name of this element (in English)
    std::string GetName()      {       return(_name);    }
    //! \return the red component of this element's default visualization color
    double GetRed()            {       return(_red);     }
    //! \return the green component of this element's default color
    double GetGreen()          {       return(_green);   }
    //! \return the blue component of this element's default color
    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*);

    //! \return the number of elements in the periodic table
    unsigned int                GetNumberOfElements();
    unsigned int GetSize() { return GetNumberOfElements(); }

    //! \deprecated Does not properly handle 'D' or 'T' hydrogen isotopes
    int   GetAtomicNum(const char *);
    //! \return the atomic number matching the element symbol passed
    //! or 0 if not defined. For 'D' or 'T' hydrogen isotopes, will return
    //! a value in the second argument
    int   GetAtomicNum(const char *, int &iso);
    //! \return the element symbol matching the atomic number passed
    char *GetSymbol(int);
    //! \return the van der Waals radius for this atomic number
    double GetVdwRad(int);
    //! \return the covalent radius for this atomic number
    double GetCovalentRad(int);
    //! \return the average atomic mass for this element.
    //! For exact isotope masses, use OpenBabel::OBIsotopeTable
    double GetMass(int);
    //! \return a "corrected" bonding radius based on the hybridization.
    //! Scales the covalent radius by 0.95 for sp2 and 0.90 for sp hybrids
    double CorrectedBondRad(int,int = 3); // atomic #, hybridization
    //! \return a "corrected" vdW radius based on the hybridization.
    //! Scales the van der Waals radius by 0.95 for sp2 and 0.90 for sp hybrids
    double CorrectedVdwRad(int,int = 3); // atomic #, hybridization
    //! \return the maximum expected number of bonds to this element
    int GetMaxBonds(int);
    //! \return the Pauling electronegativity for this element
    double GetElectroNeg(int);
    //! \return the ionization potential (in eV) for this element
    double GetIonization(int);
    //! \return the electron affinity (in eV) for this element
    double GetElectronAffinity(int);
    //! \return a vector with red, green, blue color values for this element
    std::vector<double> GetRGB(int);
    //! \return the name of this element
    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()    {}

    //! \return the number of elements in the isotope table
    unsigned int GetSize() { return _isotopes.size(); }

    void        ParseLine(const char*);
    //! \return the exact masss of the isotope
    //!   (or by default (i.e. "isotope 0") the most abundant isotope)
    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*);

    //! \return the number of atom types in the translation table
    unsigned int GetSize() { return _table.size(); }

    //! Set the initial atom type to be translated
    bool SetFromType(const char*);
    //! Set the destination atom type for translation
    bool SetToType(const char*);
    //! Translate atom types
    bool Translate(char *to, const char *from); // to, from
    //! Translate atom types
    bool Translate(std::string &to, const std::string &from); // to, from

    //! \return the initial atom type to be translated
    std::string GetFromType();
    //! \return the destination atom type for translation
    std::string GetToType();
};

//! \brief Table of common biomolecule residues (for PDB or other files).
//!   Can assign atom types and bond orders for arbitrary residues
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*);

    //! \return the number of residues in the table
    unsigned int GetSize() { return _resname.size(); }

    //! Sets the table to access the residue information for a specified
    //!  residue name
    //! \return whether this residue name is in the table
    bool SetResName(const std::string &);
    //! \return the bond order for the bond specified in the current residue
    //! \deprecated Easier to use the two-argument form
    int  LookupBO(const std::string &);
    //! \return the bond order for the bond specified between the two specified
    //! atom labels
    int  LookupBO(const std::string &, const std::string&);
    //! Look up the atom type and hybridization for the atom label specified
    //! in the first argument for the current residue
    //! \return whether the atom label specified is found in the current residue
    bool LookupType(const std::string &,std::string&,int&);
    //! Assign bond orders, atom types and residues for the supplied OBMol
    //! based on the residue information assigned to atoms
    //! \deprecated second OBBitVec argument is ignored
    bool AssignBonds(OBMol &,OBBitVec &);
};

// Used by other code for reading files
#ifdef WIN32
#define FILE_SEP_CHAR "\\"
#else
#define FILE_SEP_CHAR "/"
#endif

} // end namespace OpenBabel

#endif //DATA_H

//! \file data.h
//! \brief Global data and resource file parsers.
Revision:	741
Committed:	Wed Nov 16 19:42:11 2005 UTC (19 years, 5 months ago) by tim
File size:	11209 byte(s)
Log Message:	adding openbabel
#	User	Rev	Content
1	tim	741	/**********************************************************************
2			data.h - Global data and resource file parsers.
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_DATA_H
21			#define OB_DATA_H
22
23			#include "babelconfig.hpp"
24
25			#include <stdio.h>
26
27			#if HAVE_IOSTREAM
28			#include <iostream>
29			#elif HAVE_IOSTREAM_H
30			#include <iostream.h>
31			#endif
32
33			#if HAVE_FSTREAM
34			#include <fstream>
35			#elif HAVE_FSTREAM_H
36			#include <fstream.h>
37			#endif
38
39			#include <vector>
40			#include <string>
41
42			namespace OpenBabel
43			{
44
45			class OBElement;
46			class OBAtom;
47			class OBElementTable;
48
49			class OBMol;
50			class OBBitVec;
51
52			//! \brief Base data table class, handles reading data files
53			//!
54			//! Base data table class--reads ASCII data files in various formats
55			//! -# Checks for the environment variable _envvar (defaults to "BABEL_DATADIR")
56			//! - Tries the _subdir directory if defined (def. "data") and then the main directory
57			//! -# Checks for the directory _dir (def. determined by the build environment)
58			//! - Tries the subdirectory corresponding to this version, then the main directory
59			//! -# Reverts to the compiled-in default data
60			class OBAPI OBGlobalDataBase
61			{
62			protected:
63			bool _init; //!< whether the data been read already
64			const char *_dataptr; //!< default data table if file is unreadable
65			std::string _filename; //!< file to search for
66			std::string _dir; //!< data directory for file if _envvar fails
67			std::string _subdir; //!< subdirectory (if using environment variable)
68			std::string _envvar; //!< environment variable to check first
69
70			public:
71			//! Constructor
72			OBGlobalDataBase()
73			{
74			_init = false;
75			_dataptr = (char*)NULL;
76			}
77			//! Destructor
78			virtual ~OBGlobalDataBase() {}
79			//! Read in the data file, falling back as needed
80			void Init();
81			//! \return the size of the database (for error checking)
82			virtual unsigned int GetSize() { return 0;}
83			//! Set the directory before calling Init()
84			void SetReadDirectory(char *dir) { _dir = dir; }
85			//! Set the environment variable to use before calling Init()
86			void SetEnvironmentVariable(char *var) { _envvar = var; }
87			//! Specified by particular table classes (parses an individual data line)
88			virtual void ParseLine(const char*) {}
89			};
90
91			//! \brief Individual element data type
92			//!
93			//! Stores a variety of data about an individual element
94			class OBAPI OBElement
95			{
96			int _num;
97			char _symbol[3];
98			std::string _name;
99			double _Rcov,_Rvdw,_mass,_elNeg,_ionize,_elAffinity;
100			double _red, _green, _blue;
101			int _maxbonds;
102			public:
103			OBElement() {}
104			OBElement(int num, const char *sym, double rcov, double rvdw,
105			int maxbo, double mass, double elNeg, double ionize,
106			double elAffin, double red, double green, double blue,
107			std::string name) :
108			_num(num), _name(name), _Rcov(rcov), _Rvdw(rvdw), _mass(mass),
109			_elNeg(elNeg), _ionize(ionize), _elAffinity(elAffin),
110			_red(red), _green(green), _blue(blue),
111			_maxbonds(maxbo)
112			{
113			strncpy(_symbol, sym, 3);
114			}
115
116			//! \return the atomic number of this element
117			int GetAtomicNum() { return(_num); }
118			//! \return the atomic symbol for this element
119			char *GetSymbol() { return(_symbol); }
120			//! \return the covalent radius of this element
121			double GetCovalentRad() { return(_Rcov); }
122			//! \return the van der Waals radius of this element
123			double GetVdwRad() { return(_Rvdw); }
124			//! \return the standard atomic mass for this element (in amu)
125			double GetMass() { return(_mass); }
126			//! \return the maximum expected number of bonds to this element
127			int GetMaxBonds() { return(_maxbonds);}
128			//! \return the Pauling electronegativity for this element
129			double GetElectroNeg() { return(_elNeg); }
130			//! \return the ionization potential (in eV) of this element
131			double GetIonization() { return(_ionize); }
132			//! \return the electron affinity (in eV) of this element
133			double GetElectronAffinity(){ return(_elAffinity); }
134			//! \return the name of this element (in English)
135			std::string GetName() { return(_name); }
136			//! \return the red component of this element's default visualization color
137			double GetRed() { return(_red); }
138			//! \return the green component of this element's default color
139			double GetGreen() { return(_green); }
140			//! \return the blue component of this element's default color
141			double GetBlue() { return(_blue); }
142			};
143
144			// class introduction in data.cpp
145			class OBAPI OBElementTable : public OBGlobalDataBase
146			{
147			std::vector<OBElement*> _element;
148
149			public:
150
151			OBElementTable(void);
152			~OBElementTable();
153
154			void ParseLine(const char*);
155
156			//! \return the number of elements in the periodic table
157			unsigned int GetNumberOfElements();
158			unsigned int GetSize() { return GetNumberOfElements(); }
159
160			//! \deprecated Does not properly handle 'D' or 'T' hydrogen isotopes
161			int GetAtomicNum(const char *);
162			//! \return the atomic number matching the element symbol passed
163			//! or 0 if not defined. For 'D' or 'T' hydrogen isotopes, will return
164			//! a value in the second argument
165			int GetAtomicNum(const char *, int &iso);
166			//! \return the element symbol matching the atomic number passed
167			char *GetSymbol(int);
168			//! \return the van der Waals radius for this atomic number
169			double GetVdwRad(int);
170			//! \return the covalent radius for this atomic number
171			double GetCovalentRad(int);
172			//! \return the average atomic mass for this element.
173			//! For exact isotope masses, use OpenBabel::OBIsotopeTable
174			double GetMass(int);
175			//! \return a "corrected" bonding radius based on the hybridization.
176			//! Scales the covalent radius by 0.95 for sp2 and 0.90 for sp hybrids
177			double CorrectedBondRad(int,int = 3); // atomic #, hybridization
178			//! \return a "corrected" vdW radius based on the hybridization.
179			//! Scales the van der Waals radius by 0.95 for sp2 and 0.90 for sp hybrids
180			double CorrectedVdwRad(int,int = 3); // atomic #, hybridization
181			//! \return the maximum expected number of bonds to this element
182			int GetMaxBonds(int);
183			//! \return the Pauling electronegativity for this element
184			double GetElectroNeg(int);
185			//! \return the ionization potential (in eV) for this element
186			double GetIonization(int);
187			//! \return the electron affinity (in eV) for this element
188			double GetElectronAffinity(int);
189			//! \return a vector with red, green, blue color values for this element
190			std::vector<double> GetRGB(int);
191			//! \return the name of this element
192			std::string GetName(int);
193			};
194
195			// class introduction in data.cpp
196			class OBAPI OBIsotopeTable : public OBGlobalDataBase
197			{
198			std::vector<std::vector<std::pair <unsigned int, double> > > _isotopes;
199
200			public:
201
202			OBIsotopeTable(void);
203			~OBIsotopeTable() {}
204
205			//! \return the number of elements in the isotope table
206			unsigned int GetSize() { return _isotopes.size(); }
207
208			void ParseLine(const char*);
209			//! \return the exact masss of the isotope
210			//! (or by default (i.e. "isotope 0") the most abundant isotope)
211			double GetExactMass(const unsigned int atomicNum,
212			const unsigned int isotope = 0);
213			};
214
215			// class introduction in data.cpp
216			class OBAPI OBTypeTable : public OBGlobalDataBase
217			{
218			int _linecount;
219			unsigned int _ncols,_nrows;
220			int _from,_to;
221			std::vector<std::string> _colnames;
222			std::vector<std::vector<std::string> > _table;
223
224			public:
225
226			OBTypeTable(void);
227			~OBTypeTable() {}
228
229			void ParseLine(const char*);
230
231			//! \return the number of atom types in the translation table
232			unsigned int GetSize() { return _table.size(); }
233
234			//! Set the initial atom type to be translated
235			bool SetFromType(const char*);
236			//! Set the destination atom type for translation
237			bool SetToType(const char*);
238			//! Translate atom types
239			bool Translate(char to, const char from); // to, from
240			//! Translate atom types
241			bool Translate(std::string &to, const std::string &from); // to, from
242
243			//! \return the initial atom type to be translated
244			std::string GetFromType();
245			//! \return the destination atom type for translation
246			std::string GetToType();
247			};
248
249			//! \brief Table of common biomolecule residues (for PDB or other files).
250			//! Can assign atom types and bond orders for arbitrary residues
251			class OBAPI OBResidueData : public OBGlobalDataBase
252			{
253			int _resnum;
254			std::vector<std::string> _resname;
255			std::vector<std::vector<std::string> > _resatoms;
256			std::vector<std::vector<std::pair<std::string,int> > > _resbonds;
257
258			//variables used only temporarily for parsing resdata.txt
259			std::vector<std::string> _vatmtmp;
260			std::vector<std::pair<std::string,int> > _vtmp;
261			public:
262
263			OBResidueData();
264			void ParseLine(const char*);
265
266			//! \return the number of residues in the table
267			unsigned int GetSize() { return _resname.size(); }
268
269			//! Sets the table to access the residue information for a specified
270			//! residue name
271			//! \return whether this residue name is in the table
272			bool SetResName(const std::string &);
273			//! \return the bond order for the bond specified in the current residue
274			//! \deprecated Easier to use the two-argument form
275			int LookupBO(const std::string &);
276			//! \return the bond order for the bond specified between the two specified
277			//! atom labels
278			int LookupBO(const std::string &, const std::string&);
279			//! Look up the atom type and hybridization for the atom label specified
280			//! in the first argument for the current residue
281			//! \return whether the atom label specified is found in the current residue
282			bool LookupType(const std::string &,std::string&,int&);
283			//! Assign bond orders, atom types and residues for the supplied OBMol
284			//! based on the residue information assigned to atoms
285			//! \deprecated second OBBitVec argument is ignored
286			bool AssignBonds(OBMol &,OBBitVec &);
287			};
288
289			// Used by other code for reading files
290			#ifdef WIN32
291			#define FILE_SEP_CHAR "\\"
292			#else
293			#define FILE_SEP_CHAR "/"
294			#endif
295
296			} // end namespace OpenBabel
297
298			#endif //DATA_H
299
300			//! \file data.h
301			//! \brief Global data and resource file parsers.