IMGDock.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_DOCKING_IMGDOCK_IMGDOCK_H
#define BALL_DOCKING_IMGDOCK_IMGDOCK_H

#ifndef BALL_DOCKING_COMMON_DOCKINGALGORITHEM_H
#include <BALL/DOCKING/COMMON/dockingAlgorithm.h>
#endif

#ifndef BALL_MOLMEC_COMMON_FORCEFIELD_H
#include <BALL/MOLMEC/COMMON/forceField.h>
#endif

#ifndef BALL_MATH_MATRIX44_H
#include <BALL/MATHS/matrix44.h>
#endif

#ifndef BALL_SCORING_COMMON_SCORINGFUNCTION_H
#include <BALL/SCORING/COMMON/scoringFunction.h>
#endif

#ifndef BALL_DOCKING_COMMON_STATICLIGANDFRAGMENT_H
#include <BALL/DOCKING/COMMON/staticLigandFragment.h>
#endif

#ifndef BALL_DOCKING_COMMON_SIDECHAINOPTIMIZER_H
#include <BALL/DOCKING/COMMON/sideChainOptimizer.h>
#endif

#include <map>


namespace BALL
{
  class BALL_EXPORT IMGDock : public DockingAlgorithm
  {
    public:
      IMGDock(System& receptor, System& ligand, Options& new_options);

      IMGDock(System& receptor, System& ligand);

      IMGDock(System& receptor, System& ligand, string config_file);

      ~IMGDock();

      struct Option
      {
        static const char* STEP_WIDTH;
        static const char* NO_SOLUTIONS;
        static const char* GLOBAL_ROTATION;
        static const char* POST_OPTIMIZATION_STEPS;
        static const char* POST_OPTIMIZATION_STEP_WIDTH;
        static const char* MIN_INHIBITOR_ATOMS;
        static const char* SCORING_TYPE;
        static const char* ITERATIONS;
        static const char* DECREASE_STEPWIDTH;
        static const char* SUPERPOSE_LIGAND;
      };

      struct Default
      {
        static int STEP_WIDTH;
        static int NO_SOLUTIONS;
        static bool GLOBAL_ROTATION;
        static int POST_OPTIMIZATION_STEPS;
        static double POST_OPTIMIZATION_STEP_WIDTH;
        static int MIN_INHIBITOR_ATOMS;
        static String SCORING_TYPE;
        static int ITERATIONS;
        static bool DECREASE_STEPWIDTH;
        static bool SUPERPOSE_LIGAND;
      };

      void setup(System& receptor, System& ligand, Options& new_options);

      void setup(System& receptor, System& ligand);

      void start();

      double dockLigand(AtomContainer& ligand, bool verbose = 0);

      double getEnergy();

      double getScore();

      void printFragments(std::ostream& out = std::cout);

      void printResults(std::ostream& out = std::cout);

      void rotateLigandFragment(Size fragment, Size bond, int degree);

      void steps(Size no = 1);

      void update();

      void startDock(bool verbose = 0);

      const AtomContainer* getLigand();

      //ConformationSet getConformationSet(Index total_conformations);

      static void getDefaultOptions(Options& options);

      int rec;

    private:
      typedef std::multimap<double, std::vector<int> > PoseList;

      void rotateLigandFragment(StaticLigandFragment* lf, TMatrix4x4<float>& M, Vector3& origin, int static_fragment);

      void translateLigand(Vector3& v);

      void calculateScore(double& interact_energy, double& conf_energy);

      void createLigandFragments();

      void storeForces();

      void reassignForces();

      void saveBondInformation();

      void saveBondInformation(AtomPairList* mapped_atoms);

      bool findUnfrozenFragments(int fragment, std::set<int> frozen_fragments, std::set<int>& processed_fragments);

      void postDockOptimization(double step_width, int no_steps);

      void recursionPrint(string line);

      void optimizeRotation(std::vector < int > & conf, PoseList& best_conformations, Size bond, bool ignore_original_angle);

      void displayConformation(const std::vector < int > & conf, const double& energy);

      void applyConformation(const std::vector < int > & conf, bool verbose = 0);

      //void findBestFragmentRotation(int fragment, Size& bond, int& degree, map<int>* ignore_bonds);

      //void findBestRotation(int& fragment, Size& bond, int& degree, map* ignore_bonds = NULL, bool use_fragment_force = 0);

      void rotateLigand(int a, int degree);

      void resetRotations();

      void saveAtomPositions();



      int iterations_;

      bool superpose_ligand_;

      int no_steps_;

      std::vector<Vector3> original_atom_positions_;

      //AtomContainer* receptor_;

      double score_;

      Vector3 reference_center_;

      std::vector < Vector3 > old_forces_;

      std::vector < int > current_conformation_;

      std::vector < std::vector < int > > bond_information_;

      int max_rotated_pos_;

      bool decrease_stepwidth_;

      int step_width_;

      Size no_solutions_;

      int post_optimization_steps_;

      double post_optimization_step_width_;

      bool global_rotation_;

      int min_inhibitor_atoms_;

      int av_ref_lig_neighbors_;

      PoseList best_conformations_;

      SideChainOptimizer* sidechain_optimizer_;

  };
}

#endif // BALL_DOCKING_IMGDOCK_IMGDOCK_H