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