gridBasedScoring.h

Go to the documentation of this file.

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

#ifndef BALL_SCORING_COMMON_GRIDBASEDSCORING_H
#define BALL_SCORING_COMMON_GRIDBASEDSCORING_H

#include <BALL/SCORING/COMMON/scoringFunction.h>
#include <BALL/SCORING/COMMON/scoreGridSet.h>
#include <BALL/MOLMEC/PARAMETER/atomTypes.h>
#include <set>
#include <map>

namespace BALL
{
  class ScoreGridSet;
  class Residue;
  class Rotamer;

  class BALL_EXPORT GridBasedScoring : public ScoringFunction
  {
    public:
      struct Option
      {
        static const char* SCOREGRID_RESOLUTION;

        static const char* SCOREGRID_INTERPOLATION;
      };

      struct Default
      {
        static double SCOREGRID_RESOLUTION;
        static bool SCOREGRID_INTERPOLATION;
      };

      GridBasedScoring(AtomContainer& receptor, AtomContainer& ligand, Options& options);

      GridBasedScoring(AtomContainer& receptor, Vector3& hashgrid_origin, Options& options);

      virtual ~GridBasedScoring();

      void defineGridSet(AtomContainer* sys, Vector3& angstroem, double out_of_grid_penalty, bool enforce_grid_boundaries, double resolution, double interaction_no_scale = 1);

      void defineGridSet(AtomContainer* sys, double out_of_grid_penalty, bool enforce_grid_boundaries, double resolution, double interaction_no_scale = 1);

      void defineFlexibleResiduesGridSet();

      void printResult();

      void setAtomTypeNames(std::set<String>& types);

      void precalculateGrids(bool ony_flexRes_grids = false);

      void saveGridSetsToFile(String file, String receptor_name);

      void readAdditionalGridSetFromFile(String file);

      void replaceGridSetFromFile(String file);

      void loadFlexibleResidueScoreGrids(std::list<std::pair<const Residue*, const Rotamer*> > residue_list);

      void setupReferenceLigand();

      void setCombineOperation(int i);

      int getNoNeighboringReceptorAtoms();

      std::vector<ScoreGridSet*>* getScoreGridSets();

      void validateGridSets();

    protected:
      void setup();

      struct GridSetsResult
      {
        std::vector<double> gridSet_scores;

        std::vector<double> no_neighbors;

        std::vector<Size> no_out_of_grid;

        void setup(Size no_gridSets);
      };

      GridSetsResult gridsets_result_;

      double calculateGridScore();

      void defineReceptorGridSet(Vector3& origin, Vector3& size, double out_of_grid_penalty, bool enforce_grid_boundaries, double resolution = 0.5, double interaction_no_scale = 1);

      virtual AtomTypes& getAtomTypes() = 0;

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

      virtual void setAtomType(Atom* atom, const String& type_name);

      String getGridAtomTypeName(int grid_id);

      /* --------- protected members ------------------ */
      int combine_operation_;

      std::map<String, int> atom_types_map_;

      std::vector<BALL::ScoreGridSet*> grid_sets_;

      virtual void updatePrecalculatedScore(Size set) = 0;

      double scoregrid_resolution_;

      bool scoregrid_interpolation_;

      int flex_gridset_id_;

      std::map<const Residue*, ScoreGridSet*> flex_gridsets_;

      friend class ScoreGridSet;
      friend class PharmacophoreConstraint;
  };
}

#endif // BALL_SCORING_COMMON_GRIDBASEDSCORING_H