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:
      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_;

      AtomContainer* ligand_;

      double score_;

      double intercept_;

      ScoringBaseFunction* base_function_;

      vector<ScoringComponent*> scoring_components_;

      HashSet<const Atom*> unassigned_atoms_;

      Size max_number_of_errors_;

      Size number_of_errors_;

      double ligand_radius_;

      int ligand_atoms_;

      Vector3 ligand_center_;

      HashGrid3<Atom*>* hashgrid_;

      HashGrid3<Atom*>* all_residues_hashgrid_;
      HashGrid3<Atom*>* static_residues_hashgrid_;
      HashGrid3<Atom*>* flexible_residues_hashgrid_;

      double resolution_;

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

      int reference_neighbors_;

      int neighboring_target_atoms_;

      int misplaced_ligand_atoms_;

      int hashgrid_search_radius_;

      double nonbonded_cutoff_;

      double nonbonded_cutoff_2_;

      bool ignore_h_clashes_;

      int overlaps_;

      int ligand_intramol_overlaps_;

      double allowed_intermolecular_overlap_;

      double allowed_intramolecular_overlap_;

      double neighbor_cutoff_2_;

      vector<StaticLigandFragment*> static_ligand_fragments_;

      bool store_interactions_;

      bool store_interactions_phC_only_;

      AtomPairVector* all_ligand_nonbonded_;

      double conformation_scale_;

      bool use_all_lig_nonb_;

      bool use_static_lig_fragments_;

      int burial_depth_scale_;

      double exp_energy_stddev_;

      double exp_energy_mean_;

      std::set<Residue*> flexible_residues_;

      Result result_;

      double static_ligand_energy_;

      vector<Bond*> rotatable_ligand_bonds_;

      list<list<Vector3> > flexres_org_positions_;

  };

} // namespace BALL

#endif // BALL_SCORING_COMMON_SCORINGFUNCTION_H