Generic2D.h

Go to the documentation of this file.

#ifndef GAUDISVC_GENERIC2D_H
#define GAUDISVC_GENERIC2D_H 1
#include "AIDA_visibility_hack.h"

#include <stdexcept>
#include <memory>
#include "AIDA/IProfile2D.h"
#include "GaudiKernel/HistogramBase.h"
#include "Annotation.h"
#include "Axis.h"
#include "TFile.h"


/*
 *    Gaudi namespace
 */
namespace Gaudi {

  template <class INTERFACE, class IMPLEMENTATION>
  class GAUDI_API Generic2D : virtual public INTERFACE, virtual public HistogramBase  {
  public:
    typedef Generic2D<INTERFACE,IMPLEMENTATION> Base;

    Generic2D() = default;
  protected:
    Generic2D(IMPLEMENTATION* p) : m_rep(p) { }
 public:
    ~Generic2D() override  = default;
    TObject* representation() const override             { return m_rep.get();                       }
    void adoptRepresentation(TObject* rep) override;
    virtual std::string title() const                    {  return m_annotation.value( "Title" );    }
    virtual bool setTitle(const std::string & title);
    std::string name() const                             { return m_annotation.value("Name"); }
    bool setName( const std::string& newName );
    virtual AIDA::IAnnotation & annotation()             { return m_annotation;           }
    virtual const AIDA::IAnnotation & annotation() const { return m_annotation;           }

    virtual const AIDA::IAxis & xAxis() const            { return m_xAxis;                }
    virtual const AIDA::IAxis & yAxis() const            { return m_yAxis;                }
    virtual int rIndexX(int index) const                 { return m_xAxis.rIndex(index);  }
    virtual int rIndexY(int index) const                 { return m_yAxis.rIndex(index);  }

    virtual int entries() const;
    virtual int allEntries() const;
    virtual int extraEntries() const;
    virtual double sumBinHeights() const;
    virtual double sumAllBinHeights() const;
    virtual double  sumExtraBinHeights (  ) const  { return  sumAllBinHeights()-sumBinHeights(); }
    virtual double minBinHeight() const;
    virtual double maxBinHeight() const;

    virtual double binMeanX(int indexX,int indexY) const;
    virtual double binMeanY(int indexX,int indexY) const;
    virtual int  binEntries ( int indexX,int indexY ) const;
    virtual int binEntriesX(int indexX) const;
    virtual int binEntriesY(int indexY) const;
    virtual double binHeight(int indexX,int indexY) const;
    virtual double binHeightX(int indexX) const;
    virtual double binHeightY(int indexY) const;
    virtual double binError(int indexX,int indexY) const;
    virtual double binRms(int indexX,int indexY) const;
    virtual double meanX() const;
    virtual double meanY() const;
    virtual double rmsX() const;
    virtual double rmsY() const;
    virtual int coordToIndexX(double coordX) const;
    virtual int coordToIndexY(double coordY) const;
    virtual double equivalentBinEntries (  ) const;
    virtual bool scale( double scaleFactor );
    virtual bool add(const INTERFACE & h);
    // overwrite reset
    bool  reset (  );
    void * cast(const std::string & className) const;
    const std::string& userLevelClassType() const { return m_classType; }
    virtual int  dimension() const  { return 2; }
    std::ostream& print( std::ostream& s ) const override;
    std::ostream& write( std::ostream& s ) const override;
    int write( const char* file_name ) const override;

  protected:
    Axis                     m_xAxis;
    Axis                     m_yAxis;
    mutable AIDA::Annotation m_annotation;
    std::unique_ptr<IMPLEMENTATION> m_rep;
    std::string              m_classType;
    int                      m_sumEntries = 0;
  };

  template <class INTERFACE, class IMPLEMENTATION>
  bool Generic2D<INTERFACE,IMPLEMENTATION>::setTitle(const std::string & title)  {
    m_rep->SetTitle(title.c_str());
    if ( !annotation().addItem( "Title", title ) )
      m_annotation.setValue( "Title" , title );
    if ( !annotation().addItem( "title", title ) )
      annotation().setValue( "title", title );
    return true;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  bool Generic2D<INTERFACE,IMPLEMENTATION>::setName( const std::string& newName ) {
    m_rep->SetName(newName.c_str());
    m_annotation.setValue( "Name", newName );
    return true;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  int Generic2D<INTERFACE,IMPLEMENTATION>::entries() const                       {
    return m_rep->GetEntries();
  }

  template <class INTERFACE, class IMPLEMENTATION>
  int Generic2D<INTERFACE,IMPLEMENTATION>::allEntries (  ) const  {
    return m_rep->GetEntries();
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double  Generic2D<INTERFACE,IMPLEMENTATION>::minBinHeight() const  {
    return m_rep->GetMinimum();
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double  Generic2D<INTERFACE,IMPLEMENTATION>::maxBinHeight() const  {
    return m_rep->GetMaximum();
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::sumBinHeights () const  {
    return m_rep->GetSumOfWeights();
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::sumAllBinHeights () const  {
    return m_rep->GetSum();
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::binRms(int indexX,int indexY) const {
    return m_rep->GetBinError ( rIndexX(indexX), rIndexY(indexY) );
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::binMeanX(int indexX,int ) const {
    return m_rep->GetXaxis()->GetBinCenter( rIndexX(indexX) );
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::binMeanY(int,int indexY) const  {
    return m_rep->GetYaxis()->GetBinCenter( rIndexY(indexY) );
  }

  template <class INTERFACE, class IMPLEMENTATION>
  int Generic2D<INTERFACE,IMPLEMENTATION>::binEntriesX(int index) const   {
    int n = 0;
    for (int iY = -2; iY < yAxis().bins(); ++iY)
      n += binEntries(index,iY);
    return n;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  int Generic2D<INTERFACE,IMPLEMENTATION>::binEntriesY(int index) const    {
    int n = 0;
    for (int iX = -2; iX < xAxis().bins(); ++iX)
      n += binEntries(iX,index);
    return n;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::binHeight ( int indexX,int indexY ) const  {
    return m_rep->GetBinContent ( rIndexX(indexX), rIndexY(indexY) );
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::binHeightX(int index) const  {
    double s = 0;
    for (int iY = -2; iY < yAxis().bins(); ++iY) {
      s += binHeight(index,iY);
    }
    return s;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::binHeightY(int index) const  {
    double s = 0;
    for (int iX = -2; iX < xAxis().bins(); ++iX)
      s += binHeight(iX,index);
    return s;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::binError(int indexX,int indexY) const  {
    return m_rep->GetBinError ( rIndexX(indexX), rIndexY(indexY ) );
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::meanX() const  {
    return m_rep->GetMean(1);
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::meanY() const  {
    return m_rep->GetMean(2);
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::rmsX() const  {
    return m_rep->GetRMS(1);
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::rmsY() const  {
    return m_rep->GetRMS(2);
  }

  template <class INTERFACE, class IMPLEMENTATION>
  int Generic2D<INTERFACE,IMPLEMENTATION>::coordToIndexX ( double coord ) const {
    return xAxis().coordToIndex(coord);
  }

  template <class INTERFACE, class IMPLEMENTATION>
  int Generic2D<INTERFACE,IMPLEMENTATION>::coordToIndexY ( double coord ) const {
    return yAxis().coordToIndex(coord);
  }

  template <class INTERFACE, class IMPLEMENTATION>
  bool Generic2D<INTERFACE,IMPLEMENTATION>::add ( const INTERFACE & hist ) {
    const Base* p = dynamic_cast<const Base*>(&hist);
    if ( !p ) throw std::runtime_error("Cannot add profile histograms of different implementations.");
    m_rep->Add(p->m_rep.get());
    return true;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  int Generic2D<INTERFACE,IMPLEMENTATION>::extraEntries() const {
    return
      binEntries(AIDA::IAxis::UNDERFLOW_BIN,AIDA::IAxis::UNDERFLOW_BIN) +
      binEntries(AIDA::IAxis::UNDERFLOW_BIN,AIDA::IAxis::OVERFLOW_BIN)  +
      binEntries(AIDA::IAxis::OVERFLOW_BIN,AIDA::IAxis::UNDERFLOW_BIN)  +
      binEntries(AIDA::IAxis::OVERFLOW_BIN,AIDA::IAxis::OVERFLOW_BIN);
  }

  template <class INTERFACE, class IMPLEMENTATION>
  double Generic2D<INTERFACE,IMPLEMENTATION>::equivalentBinEntries() const  {
    if (sumBinHeights() <= 0) return 0;
    Stat_t stats[11];   // cover up to 3D...
    m_rep->GetStats(stats);
    return stats[0]*stats[0]/stats[1];
  }

  template <class INTERFACE, class IMPLEMENTATION>
  bool Generic2D<INTERFACE,IMPLEMENTATION>::scale(double scaleFactor)   {
    m_rep->Scale ( scaleFactor );
    return true;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  bool Generic2D<INTERFACE,IMPLEMENTATION>::reset (  )   {
    m_sumEntries = 0;
    m_rep->Reset ( );
    return true;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  std::ostream& Generic2D<INTERFACE,IMPLEMENTATION>::print( std::ostream& s ) const
  {
    m_rep->Print("all");
    return s;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  std::ostream& Generic2D<INTERFACE,IMPLEMENTATION>::write( std::ostream& s ) const
  {
    s << std::endl << "2D Histogram Table: " << std::endl;
    s << "BinX, BinY, Height, Error " << std::endl;
    for ( int i = 0; i < xAxis().bins(); ++i )  {
      for ( int j = 0; j < yAxis().bins(); ++j )  {
        s << binMeanX( i, j )    << ", "
            << binMeanY( i, j )    << ", "
            << binHeight( i, j ) << ", "
            << binError ( i, j ) << std::endl;
      }
    }
    s << std::endl;
    return s;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  int Generic2D<INTERFACE,IMPLEMENTATION>::write( const char* file_name ) const
  {
    TFile *f = TFile::Open(file_name,"RECREATE");
    Int_t nbytes = m_rep->Write();
    f->Close();
    return nbytes;
  }
} // end namespace AIDA
#endif // GAUDIPI_GENERIC2D_H