dockResult.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: dockResult.h,v 1.2.16.2 2007/08/07 16:16:15 bertsch Exp $
//

#ifndef BALL_STRUCTURE_DOCKING_DOCKRESULT_H
#define BALL_STRUCTURE_DOCKING_DOCKRESULT_H

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

#ifndef BALL_STRUCTURE_DOCKING_CONFORMATIONSET_H
# include <BALL/STRUCTURE/DOCKING/conformationSet.h>
#endif

namespace BALL
{
    class BALL_EXPORT DockResult
    {
      public:
          
          
        DockResult()
          ;
          
        DockResult(const String& docking_algorithm, ConformationSet* conformation_set,
                    const Options& docking_options)
          ;
        
        DockResult(const DockResult& dock_res)
          ;
          
        virtual ~DockResult()
          ;
          
        
        
        const DockResult& operator =(const DockResult& dock_res)
          ;
          
        
        
        void setConformationSet(ConformationSet* conformation_set)
          ;
        
        const String& getDockingAlgorithm() const
          ;
          
        const Options& getDockingOptions() const
          ;
        
        const ConformationSet* getConformationSet() const
          ;
        
        ConformationSet* getConformationSet()
          ;
        
        /*  Sets scoring flag by which all scores are sorted displayed
            a negative index corresponds to sorting by snapshot index
         */
         void sortBy(Index scoring_index)
          throw(Exception::IndexOverflow);
          
        /*  Get the number of the scoring by which all scores are sorted displayed
         */
        Index isSortedBy() const
          ;
        
        float operator()(Position i, Position j)
          throw(Exception::IndexOverflow);
        
        const vector<ConformationSet::Conformation> getScores(Position i) const
          throw(Exception::IndexOverflow);
          
        const String& getScoringName(Position i) const
          throw(Exception::IndexOverflow);
          
        const Options& getScoringOptions(Position i) const
          throw(Exception::IndexOverflow);
          
        Size numberOfScorings() const
          ;
          
        void addScoring(const String& name, const Options& options, vector<ConformationSet::Conformation> scores)
          ;
          
        void deleteScoring(Position i)
          throw(Exception::IndexOverflow);
        
          
          
        bool writeDockResult(const String& filename)
          ;
        
        bool writeDockResult(std::ostream& file) const
          ;
          
        bool readDockResult(const String& filename)
          ;
          
        bool readDockResult(std::istream& file)
          ;
        
        friend std::ostream& operator <<(std::ostream& out, const DockResult& dock_res)
          ;
        
        friend std::istream& operator >>(std::istream& in, DockResult& dock_res)
          ;
        
        
      protected:
        
        class Scoring_
        {
          public:
          
            Scoring_() ;
            
            Scoring_(const Scoring_& scoring)
              ;
            
            Scoring_(const String& name, const Options& options, const vector<float>& scores, const vector<Index>& snapshot_order) ;
            
            ~Scoring_() ;
            
            const Scoring_& operator =(const Scoring_& scoring)
              ;
            
            String name_;
            Options options_;
            vector<float> scores_;
            vector<Index> snapshot_order_;
        };
        
        class Compare_
        {
          public:

            Compare_() ;

            ~Compare_() ;

            //bool operator() (const std::pair<Index, float>& a, const std::pair<Index, float>& b) const
            bool operator() (const ConformationSet::Conformation& a, const ConformationSet::Conformation& b) const
              ;
        };
        
        String docking_algorithm_;
        Options docking_options_;
        ConformationSet* conformation_set_;
        vector<Scoring_> scorings_;
        Index sorted_by_;
    };
    
    std::ostream& operator <<(std::ostream& out, const DockResult& dock_res)
      ;
      
    std::istream& operator >>(std::istream& in, DockResult& dock_res)
      ;
}
#endif