/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/PATCore/PATCore/TResult.h

// Dear emacs, this is -*-c++-*-

#ifndef __TRESULT__
#define __TRESULT__

#include <TString.h>
#include <map>
#include <vector>




namespace Root {
  class TResult
  {

  public: 
    TResult(const char* name="TResult");

    TResult( const TResult& parent );
  
    TResult& operator= ( const TResult& rhs );
  
    virtual ~TResult();
  
  public:
    inline operator double() const
    {
      return getNResults() >= 1 ? m_result[0] : m_defaultResult;
    }


    inline operator std::pair<double,double>() const
    {
      return getNResults() >= 2 ? std::make_pair( m_result[0], m_result[1] ) : std::make_pair( m_defaultResult, m_defaultResult );
    }


    inline double getEfficiency() const { return double(*this); };

    inline double getScaleFactor() const { return double(*this); };

    inline double getMVAResponse() const { return double(*this); };

    inline double getTotalUncertainty() const
    {
      return getNResults() >= 2 ? m_result[1] : m_defaultResult;
    }



    inline const char* getName() const { return m_name; }


    inline void clear() 
    {
      for ( unsigned int i=0; i < m_result.size(); i++ )
        {
          m_result[i] = m_defaultResult;
        }
    }



    inline unsigned int getNResults() const { return m_resultMap.size(); }


    int addResult( const TString& resultName, const TString& resultDescription );


    inline unsigned int getResultPosition( const TString& resultName ) const 
     {
      std::map< TString, std::pair< TString, unsigned int > >::const_iterator it = m_resultMap.find(resultName);
      return (it != m_resultMap.end()) ? (it->second).second : 999999;
    }


    const TString& getResultName( unsigned int resultPosition ) const;


    inline const TString& getResultDescription( const TString& resultName ) const
    {
      std::map< TString, std::pair< TString, unsigned int > >::const_iterator it = m_resultMap.find(resultName);
      return (it != m_resultMap.end()) ? (it->second).first : m_emptyString;
    }

    const TString& getResultDescription( unsigned int resultPosition ) const;


    inline double getResult( const TString& resultName ) const
    {
      unsigned int resultPosition = getResultPosition(resultName);
      return getResult(resultPosition);
    }

    inline double getResult( unsigned int resultPosition ) const
    {
      return m_result[resultPosition];
    }


    inline std::vector<double> getResults() const
    {
      return m_result;
    }


    inline void setResult( const TString& resultName, double resultResult )
    {
      unsigned int resultPosition = getResultPosition(resultName);
      return setResult( resultPosition, resultResult );
    }

    inline void setResult( unsigned int resultPosition, double resultResult )
    {
      m_result[resultPosition] = resultResult;
      return;
    }


    inline void setResultDescription( const TString& resultName, const TString& resultDescription )
    {
      unsigned int resultPosition = getResultPosition(resultName);
      return setResultDescription( resultPosition, resultDescription );
    }

    void setResultDescription( unsigned int resultPosition, const TString& resultDescription );


#ifdef ROOTCORE

    ClassDef(TResult,1);
#endif


    // Protected members
  protected:
    TString m_name;


    // Private members
  private:
    double m_defaultResult;

    std::vector<double> m_result;

    std::map< TString, std::pair< TString, unsigned int > > m_resultMap;

    TString m_emptyString;


  }; // End: class definition

} // End: namespace Root


#endif

---