grid.h

Go to the documentation of this file.

/**********************************************************************
grid.h - Handle grids of values.

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2006 by Geoffrey R. Hutchison
Some Portions Copyright (C) 2008 by Marcus D. Hanwell

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_GRID_H
#define OB_GRID_H

#include <openbabel/babelconfig.h>
#include <openbabel/math/vector3.h>
#include <openbabel/base.h>

// Necessary evil for 2.x series -- should use OBMol* below
#include <openbabel/mol.h>

#include <iosfwd>
#include <algorithm>
#include <vector>
#include <string>

namespace OpenBabel
{

 // Forward declaration
 class OBMol;

 class OBAPI OBGrid: public OBBase
 {
 protected:
 double _xmin,_xmax,_ymin,_ymax,_zmin,_zmax; 

 public:
 OBGrid() {}

 virtual void Init(OBMol &box);

 double GetXmin() const { return(_xmin); }
 double GetYmin() const { return(_ymin); }
 double GetZmin() const { return(_zmin); }
 double GetXmax() const { return(_xmax); }
 double GetYmax() const { return(_ymax); }
 double GetZmax() const { return(_zmax); }

 bool PointIsInBox(double x,double y,double z)
 {
 return (x>=_xmin) && (x<=_xmax) &&
 (y>=_ymin) && (y<=_ymax) &&
 (z>=_zmin) && (z<=_zmax);
 }
 bool PointIsInBox(double *c)
 {
 return (c[0]>=_xmin) && (c[0]<=_xmax) &&
 (c[1]>=_ymin) && (c[1]<=_ymax) &&
 (c[2]>=_zmin) && (c[2]<=_zmax);
 }

 bool PointIsInBox(vector3 v)
 {
 return (v.x() >= _xmin) && (v.x() <=_xmax) &&
 (v.y()>=_ymin) && (v.y()<=_ymax) &&
 (v.z()>=_zmin) && (v.z()<=_zmax);
 }
 };

 class OBAPI OBFloatGrid: public OBGrid
 {
 protected:
 std::vector<double> _values; 
 int *_ival; 
 double _midz,_midx,_midy; 
 int _ydim,_xdim,_zdim; 
 double _spacing,_inv_spa; 
 double _halfSpace; 
 vector3 _xAxis, _yAxis, _zAxis;

 public:

 OBFloatGrid() : _ival(NULL), _halfSpace(0.0) {}
 ~OBFloatGrid()
 {
 if (_ival) delete [] _ival;
 }

 void Init(OBMol &box,double spacing, double pad=0.0);

 vector3 GetMin() { return vector3(_xmin, _ymin, _zmin); }

 void GetMin(double *a)
 {
 a[0]=_xmin;
 a[1]=_ymin;
 a[2]=_zmin;
 }

 vector3 GetMax() { return vector3(_xmax, _ymax, _zmax); }

 void GetMax(double *a)
 {
 a[0]=_xmax;
 a[1]=_ymax;
 a[2]=_zmax;
 }

 double GetSpacing() const { return(_spacing); }
 void GetSpacing(double &s)
 {
 s=_spacing;
 }
 double GetScale() const { return(_inv_spa); }
 double GetHalfSpace() const {return(_halfSpace);}
 int GetXdim() const { return(_xdim); }
 int GetYdim() const { return(_ydim); }
 int GetZdim() const { return(_zdim); }
 void GetDim(int *a)
 {
 a[0]=_xdim;
 a[1]=_ydim;
 a[2]=_zdim;
 }

 vector3 GetMidpointVector()
 {
 vector3 v;
 v.Set(_midx,_midy,_midz);
 return(v);
 }

 vector3 GetXAxis() const
 {
 return _xAxis;
 }

 vector3 GetYAxis() const
 {
 return _yAxis;
 }

 vector3 GetZAxis() const
 {
 return _zAxis;
 }

 void SetNumberOfPoints(int nx, int ny, int nz);

 void SetXAxis(vector3);
 void SetYAxis(vector3);
 void SetZAxis(vector3);

 void SetLimits(const vector3& origin, const vector3& x, const vector3& y,
 const vector3& z);
 void SetLimits(const double origin[3], const double x[3], const double y[3],
 const double z[3]);

 std::vector<double> GetDataVector();
 void SetVals(const std::vector<double> & vals);

 double *GetVals() { return(&_values[0]); }

 double GetValue(int i, int j, int k)
 {
 if (i*_ydim*_zdim + j*_zdim + k > _xdim*_ydim*_zdim)
 return 0.0;
 else
 return _values[i*_ydim*_zdim + j*_zdim + k];
 }

 void SetVals(double *ptr)
 {
 for (int i = 0; i < _xdim*_ydim*_zdim; ++i)
 _values[i] = ptr[i];
 }

 bool SetValue(int i, int j, int k, double val)
 {
 if (i*_ydim*_zdim + j*_zdim + k > _xdim*_ydim*_zdim)
 return false;

 _values[i*_ydim*_zdim + j*_zdim + k] = val;
 return true;
 }

 vector3 Center()
 {
 return vector3(_midx,_midy,_midz);
 }

 friend std::ostream& operator<< ( std::ostream&, const OBFloatGrid& ) ;
 friend std::istream& operator>> ( std::istream&,OBFloatGrid& ) ;

 double Inject(double x,double y,double z);
 void IndexToCoords(int idx, double &x, double &y, double &z);
 void CoordsToIndex(int*,double*);
 int CoordsToIndex(double x, double y, double z);
 double Interpolate(double,double,double);
 double InterpolateDerivatives(double,double,double,double *derivatives);
 };

#ifndef OBPolarGrid
#define OBPolarGrid 0x01 /* polar interactions? */
#endif //OBPolarGrid

#ifndef OBLipoGrid
#define OBLipoGrid 0x02 /* lipophilicity? */
#endif //OBLipoGrid

 class OBAPI OBProxGrid: public OBGrid
 {
 protected:
 int _gridtype;
 int _nxinc,_nyinc,_nzinc,_maxinc;
 double _inc;
 std::vector<std::vector<int> > cell;

 public:

 OBProxGrid(int gridtype=0)
 {
 _gridtype=gridtype;
 }
 ~OBProxGrid()
 {}
 void Setup(OBMol &mol,OBMol &box, double cutoff,double resolution = 0.5);
 void Setup(OBMol &mol,OBMol &box, double cutoff,
 std::vector<bool> &use,double resolution = 0.5);
 std::vector<int> *GetProxVector(double,double,double);
 std::vector<int> *GetProxVector(double*);

 bool LipoGrid()
 {
 return((_gridtype&OBLipoGrid) ? true : false);
 }
 bool PolarGrid()
 {
 return(_gridtype&OBPolarGrid);
 }
 void SetGridType(int gridtype)
 {
 _gridtype = gridtype;
 }
 };

 // scoring function used: PLP = Piecewise Linear Potential or ChemScore algorithm
 typedef enum { Undefined = -1, PLP, ChemScore } score_t;

 class OBAPI OBScoreGrid
 {
 protected:
 score_t gridtype;
 bool verbose;

 public:

 double score;

 OBScoreGrid(void) { verbose = false; }
 virtual ~OBScoreGrid(void) {}

 void SetVerbose(bool v) { verbose = v; }
 void SetType(score_t type) { gridtype = type; }
 score_t GetType(void) { return gridtype; }

 virtual void Clear(void) { }
 virtual double Eval(double *) { return -1; }
 virtual double Eval(OBMol &mol){return Eval(mol.GetCoordinates());}
 virtual void Init(OBMol &, OBMol &, std::string &, double){}
 virtual void Setup(OBMol &) {}
 virtual void Setup(OBMol &, std::vector<int> &){}
 virtual void Setup(std::vector<int> &) {}
 virtual void Config(std::string) {}
 virtual bool Read(std::string) { return false; }
 virtual bool Write(std::string) { return false; }
 virtual vector3 Center() { return VZero; }
 virtual vector3 CenterMol(OBMol &) { return VZero; }
 };

} // end namespace OpenBabel

#endif // OB_GRID_H