result.h

Go to the documentation of this file.

// ----------------------------------------------------
// $Maintainer: Marc Röttig $
// $Authors: Marc Röttig, Marcel Schumann $
// ----------------------------------------------------

#ifndef BALL_DOCKING_RESULT_H
#define BALL_DOCKING_RESULT_H

#include <BALL/DOCKING/COMMON/receptor.h>
#include <BALL/DOCKING/COMMON/flexibleMolecule.h>
#include <vector>
#include <map>


namespace BALL
{
  class BALL_EXPORT Result
  {
    public:

      enum BALL_EXPORT Method
      {
        UNKNOWN = -1,
        RECEPTORIMPORT,
        LIGANDIMPORT,
        DOCKING,
        RESCORING,
        MDRESCORING,
        CONSENSUSRESCORING,
        MOLECULE_CHECK
      };

      class BALL_EXPORT ResultData
      {
        public:
          ResultData();
          ResultData(int result_type);
          void setReceptorConformationId(String id);
          void setReceptorConformation(Conformation* conf);
          bool hasReceptorConformationId() const;
          String  getReceptorConformationId() const;
          void setLigandConformationId(String id);
          void setLigandConformation(Conformation* conf);
          String  getLigandConformationId() const;
          bool hasLigandConformationId() const;
          void setScoringMethod(int method);
          bool hasScoringMethod() const;
          int  getScoringMethod() const;
          void setEnergy(double e);
          double getEnergy() const;
          bool hasEnergy() const;
          bool check() const;
          void setConformation(Conformation* conf);
          Conformation* getConformation();
        private:
          Conformation* conformation;
          bool    has_rec_id;
          bool    has_lig_id;
          bool    has_energy;
          bool    has_method;
          String     rec_conf_id;
          String     lig_conf_id;
          int     scoringmethod;
          double  energy;
          int     resulttype;
      };

      static Result::Method getMethod(int i);
      static Result* makeLigandImportResult();
      static Result* makeReceptorImportResult();
      static Result* makeDockingResult();
      static Result* makeRescoringResult();
      BALL_CREATE(Result)
      Result();

      /* Constructor.
       */
      Result(const Result::Method& _method);

      Result(const Result& res);

      Result(const Result& res, const HashSet<String>& IDs);

      /* Destructor.
       */
      virtual ~Result();

      void clear();

      void operator = (const Result& res);

      void operator += (const Result& res);

      Result::Method getMethod();

      String getMethodString();

      void setMethod(Result::Method _method);

      const vector < String > * getInputConformations();

      Conformation* getInputConformer(Ligand* lig) throw(Exception::GeneralException);

      Conformation* getFirstOutputConformation(Ligand* lig) throw(Exception::GeneralException);

      vector < Result::ResultData > getOutputConformations(Ligand* lig);

      const HashSet<String>* getInputIds();
      HashSet<String> getOutputIds();
      ResultData getOutputData(String id);
      bool hasOutputData(String id);

      void add(Conformation* lig_conf_in, ResultData &rd);

      void add(Conformation* lig_conf_in, Conformation* lig_conf_out, int scoringmethod, double energy, Conformation* rec_conf);

      void add(const String& lig_conf_in, const String& lig_conf_out, int scoringmethod, double energy, const String& rec_conf);

      void add(String lig_conf_id_in, Result::ResultData &rd);

      const vector<Result::ResultData>* get(String inpose_id);

      static String toString(const ResultData &rd);

      void erase(const FlexibleMolecule* flexmol);

      void erase(const String& ID);

      void sort(const list<String>& input_order, list<String>& output_order);

      void setTimestamp(const String& timestamp);

      const String& getTimestamp();

      void setDescription(const String& text);

      const String& getDescription();

      void setToolInfo(const String& toolinfo);

      const String& getToolInfo();

      const HashMap<String, vector<ResultData> >* getData();

    protected:

      String timestamp_;
      String toolinfo_;
      Result::Method method;
      HashMap<String, vector<ResultData> >     result_data_;
      HashMap<String, ResultData> result_output_data_;
      vector < String > input_conformations_;
      HashSet < String > input_conformations_map_;

      String description_;
  };
}
#endif /* BALL_DOCKING_RESULT_H */