scoreGridSet.h

Go to the documentation of this file.

// ----------------------------------------------------
// $Maintainer: Marcel Schumann $
// $Authors: Marcel Schumann $
// ----------------------------------------------------

#ifndef BALL_SCORING_COMMON_SCOREGRIDSET
#define BALL_SCORING_COMMON_SCOREGRIDSET

#include <BALL/MATHS/vector3.h>
#include <BALL/SCORING/COMMON/gridBasedScoring.h>
#include <BALL/DATATYPE/regularData3D.h>
#include <BALL/DOCKING/COMMON/constraints.h>


namespace BALL
{
  typedef vector<vector<vector<double> > > ScoreGrid;

  class GridBasedScoring;

  class BALL_EXPORT ScoreGridSet
  {
    public:
      ScoreGridSet(GridBasedScoring* gbs, Vector3& v_origin, Vector3& size, double& resolution);

      ScoreGridSet(GridBasedScoring* gbs);

      ScoreGridSet(ScoreGridSet* sgs);

      ScoreGridSet();

      ~ScoreGridSet();

      void operator += (ScoreGridSet& sgs);

      void operator -= (ScoreGridSet& sgs);

      void clearData();

      ScoreGrid& operator[](int i);

      void binaryWrite(std::ostream& output);

      void binaryRead(std::istream& input);

      void saveToFile(std::ostream& output, String receptor_name);

      void readFromFile(std::istream& input);

      void setHashGrid(HashGrid3<Atom*>* hashgrid);

      HashGrid3<Atom*>* getHashGrid();

      void transform(TMatrix4x4 < float > & t);

      void moveTo(Vector3& destination);

      double getGridScore(Size grid, Vector3 position, bool interpolation);

      Size sizeX();

      Size sizeY();

      Size sizeZ();

      Size noGrids();

      void enable();

      void disable();

      bool isEnabled();

      Vector3 getOrigin();

      Vector3 getCenter();

      std::list<std::pair<String, BALL::RegularData3D*> > convertToRegularData3DGrids();

      PharmacophoreConstraint* getPharmacophoreConstraint();

      void setPharmacophoreConstraint(PharmacophoreConstraint* phc);

      void setParameters(bool enforce_grid_boundaries, double out_of_grid_penalty, double interaction_no_scale);

      // -------- public members: -------------
      String name;

      Size reference_interactions;

      double interaction_no_scale_;

    private:
      std::map<String, int>* getAtomTypesMap();

      String getGridAtomTypeName(int grid_id);

      bool is_reference_;

      Vector3 origin_;

      Vector3 original_origin_;

      double resolution_;

      bool enforce_grid_boundaries_;

      double out_of_grid_penalty_;

      bool enabled_;

      std::vector<ScoreGrid*>* score_grids_;

      Size size_x;

      Size size_y;

      Size size_z;

      bool transformed_;

      void initializeEmptyGrids(int no = -1);

      GridBasedScoring* parent;

      bool new_hashgrid_;

      TMatrix4x4<float> T_;

      TMatrix4x4<float> T_i_;

      HashGrid3<Atom*>* hashgrid_;

      std::map<BALL::String, int> atom_types_map_no_parent_;

      PharmacophoreConstraint* pharm_constraint_;

      friend class GridBasedScoring;
  };
}

#endif // BALL_SCORING_COMMON_SCOREGRIDSET