Generic2D.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#ifndef GAUDISVC_GENERIC2D_H
#define GAUDISVC_GENERIC2D_H 1

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

// Hide warning message:
// warning: 'XYZ' overrides a member function but is not marked 'override'
#ifdef __clang__
#  pragma clang diagnostic push
#  pragma clang diagnostic ignored "-Winconsistent-missing-override"
#elif defined( __GNUC__ ) && __GNUC__ >= 5
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wsuggest-override"
#endif

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:
    TObject* representation() const override { return m_rep.get(); }
    void adoptRepresentation( TObject* rep ) override;
    std::string title() const override { return m_annotation.value( "Title" ); }
    bool setTitle( const std::string& title ) override;
    std::string name() const { return m_annotation.value( "Name" ); }
    bool setName( const std::string& newName );
    AIDA::IAnnotation& annotation() override { return m_annotation; }
    const AIDA::IAnnotation& annotation() const override { return m_annotation; }

    const AIDA::IAxis& xAxis() const override { return m_xAxis; }
    const AIDA::IAxis& yAxis() const override { 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 ); }

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

    double binMeanX( int indexX, int indexY ) const override;
    double binMeanY( int indexX, int indexY ) const override;
    int binEntries( int indexX, int indexY ) const override;
    int binEntriesX( int indexX ) const override;
    int binEntriesY( int indexY ) const override;
    double binHeight( int indexX, int indexY ) const override;
    double binHeightX( int indexX ) const override;
    double binHeightY( int indexY ) const override;
    double binError( int indexX, int indexY ) const override;
    virtual double binRms( int indexX, int indexY ) const;
    double meanX() const override;
    double meanY() const override;
    double rmsX() const override;
    double rmsY() const override;
    int coordToIndexX( double coordX ) const override;
    int coordToIndexY( double coordY ) const override;
    virtual double equivalentBinEntries() const;
    virtual bool scale( double scaleFactor );
    bool add( const INTERFACE& h ) override;
    // overwrite reset
    bool reset() override;
    void* cast( const std::string& className ) const override;
    const std::string& userLevelClassType() const { return m_classType; }
    int dimension() const override { 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;
  }
} // namespace Gaudi

#ifdef __clang__
#  pragma clang diagnostic pop
#elif defined( __GNUC__ ) && __GNUC__ >= 5
#  pragma GCC diagnostic pop
#endif

#endif // GAUDIPI_GENERIC2D_H