scoringFunction.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
 
#ifndef BALL_SCORING_COMMON_SCORINGFUNCTION_H
#define BALL_SCORING_COMMON_SCORINGFUNCTION_H
 
#include <set>
 
#include <BALL/KERNEL/system.h>
#include <BALL/DATATYPE/options.h>
#include <BALL/DATATYPE/string.h>
#include <BALL/DATATYPE/hashGrid.h>
#include <BALL/KERNEL/atomContainer.h>
#include <BALL/DOCKING/COMMON/staticLigandFragment.h>
#include <BALL/DOCKING/COMMON/constraints.h>
#include <BALL/SCORING/COMMON/baseFunction.h>
#include <BALL/SCORING/COMMON/scoringComponent.h>
#include <BALL/STRUCTURE/residueRotamerSet.h>
 
namespace BALL
{
  typedef std::list<std::pair<Atom*, Atom*> > AtomPairList;
  typedef std::vector<std::pair<Atom*, Atom*> > AtomPairVector;
 
  class ScoringComponent;
 
  class BALL_EXPORT ScoringFunction
  {
 
    friend class PharmacophoreConstraint;
    friend class SideChainOptimizer;
 
    public:
 
      static const char* SUBCATEGORY_NAME;
 
      struct Option
      {
        static const char* VERBOSITY;

        static const char* BASE_FUNCTION_TYPE;

        static const char* HASHGRID_RESOLUTION;

        static const char* HASHGRID_SIZE;

        static const char* NONBONDED_CUTOFF;

        static const char* CONFORMATION_SCALE;

        static const char* ALL_LIG_NONB_PAIRS;

        static const char* USE_STATIC_LIG_FRAGMENTS;

        static const char* IGNORE_H_CLASHES;

        static const char* ALLOWED_INTERMOL_OVERLAP;

        static const char* ALLOWED_INTRAMOL_OVERLAP;

        static const char* BURIAL_DEPTH_SCALE;
      };
 
 
      struct Default
      {
        static const Size VERBOSITY;

        static const Size BASE_FUNCTION_TYPE;

        static double HASHGRID_RESOLUTION;

        static int HASHGRID_SIZE;
 
        static double NONBONDED_CUTOFF;

        static double CONFORMATION_SCALE;

        static bool ALL_LIG_NONB_PAIRS;

        static bool USE_STATIC_LIG_FRAGMENTS;

        static bool IGNORE_H_CLASHES;

        static double ALLOWED_INTERMOL_OVERLAP;

        static double ALLOWED_INTRAMOL_OVERLAP;
 
        static int BURIAL_DEPTH_SCALE;
      };

      ScoringFunction();

      ScoringFunction(const ScoringFunction& sf);

      ScoringFunction(AtomContainer& receptor, AtomContainer& ligand);

      ScoringFunction(AtomContainer& receptor, AtomContainer& ligand,
          const Options& options);
 
      ScoringFunction(AtomContainer& receptor,
          AtomContainer& ligand, Options& options);

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

      virtual ~ScoringFunction();

      virtual void clear();

      ScoringFunction& operator = (const ScoringFunction& sf);

      bool setup();

      bool setup(AtomContainer& receptor, AtomContainer& ligand);

      bool setup(AtomContainer& receptor, AtomContainer& ligand, const Options& options);

      void setMaximumNumberOfErrors(Size nr);

      Size getMaximumNumberOfErrors() const;

      void setFirstMolecule(AtomContainer& molecule1);

      AtomContainer* getFirstMolecule() const;

      void setSecondMolecule(AtomContainer& molecule2);

      AtomContainer* getSecondMolecule() const;

      void setReceptor(AtomContainer& receptor);

      AtomContainer* getReceptor() const;

      void setLigand(AtomContainer& ligand);

      AtomContainer* getLigand() const;

      void setIntercept(double intercept);

      double getIntercept() const;

      void setBaseFunction(ScoringBaseFunction& base_function);

      ScoringBaseFunction* getBaseFunction() const;

      void insertComponent(ScoringComponent* component);

      void insertComponent(ScoringComponent* component, float coefficient);

      void removeComponent(const ScoringComponent* component);

      void removeComponent(const String& name);

      void setCoefficient(const ScoringComponent* component, float coefficient);

      void setCoefficient(const String& name, float coefficient);

      bool getCoefficient(const ScoringComponent* component,
          float& coefficient) const;

      bool getCoefficient(const String& name, float& coefficient) const;

      ScoringComponent* getComponent(const String& name) const;

      ScoringComponent* getComponent(const Size index) const;

      double calculateScore();

      const HashSet<const Atom*>& getUnassignedAtoms() const;

      HashSet<const Atom*>& getUnassignedAtoms();

      static HashGrid3<Atom*>* initializeHashGrid(AtomContainer* sys,
                    Vector3& center,
                    double& resolution,
                    int hashgrid_size);

      double getExpEnergyStddev();
 
      void enableStoreInteractionsOnlyForPhContraints();

      String convertTime(double seconds);

      virtual void update();

      virtual double updateScore();

      virtual void printResult(bool detail = 0);
 
      void getScoreContributions(vector<double>& score_contributions, vector<String>& names);

      static void getDefaultOptions(Options& options);

      String getEquation();

      void enableStoreInteractions(bool b = true);

      String getName();
 
      int getBurialDepthScale();
 
      String valueToString(double value);

      void unsetTrainingParameters();

      void setNormalizationParameters(double stddev, double mean);
 
      const HashGrid3<Atom*>* getHashGrid();

      const Vector3& getLigandCenter() const;
 
      double getLigandRadius() const;

      bool storeInteractionsEnabled();

      virtual int getNoNeighboringReceptorAtoms();

      int getNoLigandAtoms();

      Options getOptions();

      Options* getOptionsToModify();

      void createStaticLigandFragments();
 
      const vector<Bond*>* getRotatableLigandBonds() const;
 
      const vector<StaticLigandFragment*>* getStaticLigandFragments() const;
 
      bool hasFlexibleResidues();
 
      void setFlexibleResidues(const std::set<Residue*>& flexible_residues);

      bool assignRotamer(Residue* residue, ResidueRotamerSet* rotamer_set, const Rotamer* rotamer);

      void resetFlexibleResidues();

      Size countNeighboringReceptorAtoms(const Atom* atom,
                 double distance_threshold,
                 bool onePerCell = 0,
                 int* number_of_overlaps = 0) const;
 
      void resetResiduePositions(Residue* residue, list<Vector3>& old_positions);

      double getScore();
 
      const std::map<Atom*, int>* getAtomFragmentMap();

      list<Constraint*> constraints {};
 
    protected:
      /* @name Protected structs */
      struct Result
      {
        double ligand_conformation;

        double interaction_score;

        vector<double> refArea_penalties;
      };

      void setName(String name);
 
      void updateComponent(int id, AtomPairList*);

      Vector3 calculateGeometricalCenter(AtomContainer* s, int* no_ligand_atoms = NULL);

      double calculateMoleculeRadius(AtomContainer* sys, Vector3& center);
 
      void setupFlexibleResidues_();

      virtual void setupReferenceLigand();

      int checkForAtomOverlaps(const AtomPairVector* pair_vector);

      AtomPairVector* createNonbondedPairVector(HashGrid3<Atom*>* hashgrid, int& overlaps, bool rec_lig, bool check_fragments = 0, bool intra_fragment = 0);

      AtomPairVector* createLigandNonbondedPairVector(bool intra_fragment, int& overlaps);
 
      bool hasPharmacophoreConstraints_();

      void clearStoredInteractions_();

      double calculateConstraintsScore();

      void enableInteractionComponents_(const list<String>& type_names);
 
      virtual double getES();

      void enableAllComponents_();

      void fetchStaticLigandFragment(Atom* a1, int index);

      int countCovalentBonds(const Atom* atom, int threshold = -1);

      virtual void createAllLigandNonBondedPairs();

      virtual double calculateStaticLigandFragmentEnergy();

      bool isPeptideBond(const Bond* bond) const;

      String name_ {""};

      Options options_ {};

      AtomContainer* receptor_ {nullptr};

      AtomContainer* ligand_ {nullptr};

      double score_ {0.0};

      double intercept_ {0.0};

      ScoringBaseFunction* base_function_ {nullptr};

      vector<ScoringComponent*> scoring_components_ {};

      HashSet<const Atom*> unassigned_atoms_ {};

      Size max_number_of_errors_ {0};

      Size number_of_errors_ {0};

      double ligand_radius_ {0.0};

      int ligand_atoms_ {0};

      Vector3 ligand_center_ {};

      HashGrid3<Atom*>* hashgrid_ {nullptr};
 
      HashGrid3<Atom*>* all_residues_hashgrid_ {nullptr};
      HashGrid3<Atom*>* static_residues_hashgrid_ {nullptr};
      HashGrid3<Atom*>* flexible_residues_hashgrid_ {nullptr};

      double resolution_ {0.0};

      std::map<Atom*, int> atoms_to_fragments_ {};

      int reference_neighbors_ {0};

      int neighboring_target_atoms_ {0};

      int misplaced_ligand_atoms_ {0};

      int hashgrid_search_radius_ {0};

      double nonbonded_cutoff_ {0.0};

      double nonbonded_cutoff_2_ {0.0};

      bool ignore_h_clashes_ {false};

      int overlaps_ {0};

      int ligand_intramol_overlaps_ {0};

      double allowed_intermolecular_overlap_ {0.0};

      double allowed_intramolecular_overlap_ {0.0};

      double neighbor_cutoff_2_ {0.0};

      vector<StaticLigandFragment*> static_ligand_fragments_ {};

      bool store_interactions_ {false};
 
      bool store_interactions_phC_only_ {false};

      AtomPairVector* all_ligand_nonbonded_ {nullptr};

      double conformation_scale_ {0.0};

      bool use_all_lig_nonb_ {false};

      bool use_static_lig_fragments_ {false};
 
      int burial_depth_scale_ {0};

      double exp_energy_stddev_ {0.0};

      double exp_energy_mean_ {0.0};
 
      std::set<Residue*> flexible_residues_ {};

      Result result_ {};

      double static_ligand_energy_ {0.0};

      vector<Bond*> rotatable_ligand_bonds_ {};

      list<list<Vector3> > flexres_org_positions_ {};
 
  };
 
} // namespace BALL
 
#endif // BALL_SCORING_COMMON_SCORINGFUNCTION_H