dockingAlgorithm.h

Go to the documentation of this file.

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


#ifndef BALL_DOCKING_COMMON_DOCKINGALGORITHM_H
#define BALL_DOCKING_COMMON_DOCKINGALGORITHM_H

#ifndef BALL_DATATYPE_OPTIONS_H
# include <BALL/DATATYPE/options.h>
#endif

#ifndef BALL_KERNEL_SYSTEM_H
# include <BALL/KERNEL/system.h>
#endif

#ifndef BALL_DOCKING_COMMON_CONFORMATIONSET_H
# include <BALL/DOCKING/COMMON/conformationSet.h>
#endif

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

#ifndef BALL_SYSTEM_TIMER_H
#include <BALL/SYSTEM/timer.h>
#endif

#ifndef BALL_DOCKING_COMMON_CONSTRAINTS_H
#include <BALL/DOCKING/COMMON/constraints.h>
#endif


namespace BALL
{

  //namespace Docking
  //{
  class ScoringFunction;
  //}

  class BALL_EXPORT DockingAlgorithm
  {
    public:

      enum DISPLAYMODE
      {
        NO_DISPLAY = 0,
        BEST_INTERMEDIATE_POSES = 1,
        ALL_INTERMEDIATE_POSES = 2,
        NO_INTERMEDIATE_POSES = 3
      };

      DockingAlgorithm();

      DockingAlgorithm(System& receptor, System& ligand, Options& new_options);

      DockingAlgorithm(System& receptor, System& ligand);

      virtual ~DockingAlgorithm();

      Options options;


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

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

      static void readOptionFile(String filename, Options& output_options, list<Constraint*>& output_constraints, const AtomContainer* ref_ligand = 0);

      static void writeOptionFile(String filename, Options& input_options, list<Constraint*>& input_constraints);

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

      ScoringFunction* getScoringFunction();

      void setScoringFunction(ScoringFunction* scoring) { scoring_function_ = scoring;}

      void processMultiMoleculeFile(string input_filename, string output_filename, double score_cutoff, vector<double>* min_atoms_in_ref_areas = 0, String toolinfo="", String timestamp="");

      void setLigand(AtomContainer* ligand);

      const AtomContainer* getLigand();

      const AtomContainer* getReferenceLigand();

      const String& getName();

      virtual void start();

      virtual void pause();

      virtual void proceed();

      virtual void abort();

      virtual void finish();

      virtual void reset();

      virtual bool hasFinished() const;

      virtual bool wasAborted() const
        { return abort_;}

      virtual bool wasPaused() const
        { return pause_;}

      virtual float getProgress() const;

      virtual ConformationSet getConformationSet(Index total_conformations = 0);

      double calculateRMSD(const AtomContainer& S1, const AtomContainer& S2, int* no_matched_atoms = NULL);

      static Matrix4x4 mapCompounds(const AtomContainer& S1, const AtomContainer& S2, Size& no_matched_heavy_atoms, double& rmsd, double upper_bound, double lower_bound, double tolerance);

      const static String OPTION_FILE_PARAMETER_NAME;

      const AtomContainer* getVisualizationPose();

      void setVisualizationPose(const double& score);

      double getVisualizationPoseScore();

      bool new_pose_to_be_visualized;

      DISPLAYMODE getDisplayMode();

      void setDisplayMode(DISPLAYMODE display_mode);

      void setMaxFps(int no);

    protected:

      static void writeSubcategories_(Options& category, std::ostream& out);

      System* system1_;
      System* system2_;

      bool   pause_;
      bool   abort_;
      bool finished_;

      AtomContainer* reference_ligand_;

      String name_;

      AtomContainer* receptor_;

      AtomContainer* ligand_;

      void mapLigandOntoReferenceLigand();

      ScoringFunction* scoring_function_;

      String parameter_filename_;

      String scoring_type_;

      DISPLAYMODE display_mode_;

      AtomContainer visualization_pose_;

      double visualization_pose_score_;

      double min_sec_between_visualizations_;
      Timer visualization_timer_;
  };

} // namespace BALL

#endif // BALL_DOCKING_COMMON_DOCKINGALGORITHM_H