Generic1D.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 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.                                             *
\***********************************************************************************/
#pragma once
 
#include "Annotation.h"
#include "Axis.h"
#include <AIDA/IProfile1D.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 "-Wsuggest-override"
#  pragma clang diagnostic ignored "-Winconsistent-missing-override"
#elif defined( __GNUC__ )
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wsuggest-override"
#endif
 
namespace Gaudi {

  template <class INTERFACE, class IMPLEMENTATION>
  class GAUDI_API Generic1D : virtual public INTERFACE, virtual public HistogramBase {
  public:
    typedef Generic1D<INTERFACE, IMPLEMENTATION> Base;
    Generic1D() = default;
 
  protected:
    Generic1D( IMPLEMENTATION* p ) : m_rep( p ) {}
 
  public:
    virtual const std::string& userLevelClassType() const { return m_classType; }
    void* cast( const std::string& cl ) const override;
    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; }
    Axis& axis() { return m_axis; }
    const Axis& axis() const override { return m_axis; }

    int entries() const override { return m_rep->GetEntries(); }
    int allEntries() const override { return m_rep->GetEntries(); }
    int extraEntries() const override;
    int binEntries( int index ) const override;
    // spread
    virtual double binRms( int index ) const;
    double sumBinHeights() const override { return m_rep->GetSumOfWeights(); }
    double sumAllBinHeights() const override { return m_rep->GetSum(); }
    double sumExtraBinHeights() const override { return sumAllBinHeights() - sumBinHeights(); }
    double minBinHeight() const override { return m_rep->GetMinimum(); }
    double maxBinHeight() const override { return m_rep->GetMaximum(); }

    virtual double equivalentBinEntries() const;
    virtual bool scale( double scaleFactor );
    bool reset() override;
    bool add( const INTERFACE& profile ) override;
    virtual int rIndex( int index ) const { return m_axis.rIndex( index ); }
    double binMean( int index ) const override;
    double binHeight( int index ) const override;
    double binError( int index ) const override;
    double mean() const override { return m_rep->GetMean(); }
    double rms() const override { return m_rep->GetRMS(); }
    int coordToIndex( double coord ) const override { return axis().coordToIndex( coord ); }
    int dimension() const override { return 1; }
    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_axis;
    mutable AIDA::Annotation m_annotation;
    std::unique_ptr<IMPLEMENTATION> m_rep;
    // class type
    std::string m_classType;
    // cache sumEntries (allEntries)   when setting contents since Root can't compute by himself
    int m_sumEntries{ 0 };
  }; // end class Generic1D
 
  template <class INTERFACE, class IMPLEMENTATION>
  bool Generic1D<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 Generic1D<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>
  double Generic1D<INTERFACE, IMPLEMENTATION>::binRms( int index ) const {
    return m_rep->GetBinError( rIndex( index ) );
  }
 
  template <class INTERFACE, class IMPLEMENTATION>
  double Generic1D<INTERFACE, IMPLEMENTATION>::binMean( int index ) const {
    return m_rep->GetBinCenter( rIndex( index ) );
  }
 
  template <class INTERFACE, class IMPLEMENTATION>
  double Generic1D<INTERFACE, IMPLEMENTATION>::binHeight( int index ) const {
    return m_rep->GetBinContent( rIndex( index ) );
  }
 
  template <class INTERFACE, class IMPLEMENTATION>
  double Generic1D<INTERFACE, IMPLEMENTATION>::binError( int index ) const {
    return m_rep->GetBinError( rIndex( index ) );
  }
 
  template <class INTERFACE, class IMPLEMENTATION>
  int Generic1D<INTERFACE, IMPLEMENTATION>::extraEntries() const {
    return binEntries( AIDA::IAxis::UNDERFLOW_BIN ) + binEntries( AIDA::IAxis::OVERFLOW_BIN );
  }
  template <class INTERFACE, class IMPLEMENTATION>
  bool Generic1D<INTERFACE, IMPLEMENTATION>::reset() {
    m_sumEntries = 0;
    m_rep->Reset();
    return true;
  }
 
  template <class INTERFACE, class IMPLEMENTATION>
  double Generic1D<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 Generic1D<INTERFACE, IMPLEMENTATION>::scale( double scaleFactor ) {
    m_rep->Scale( scaleFactor );
    return true;
  }
 
  template <class INTERFACE, class IMPLEMENTATION>
  bool Generic1D<INTERFACE, IMPLEMENTATION>::add( const INTERFACE& h ) {
    const Generic1D<INTERFACE, IMPLEMENTATION>* p = dynamic_cast<const Generic1D<INTERFACE, IMPLEMENTATION>*>( &h );
    if ( p ) {
      m_rep->Add( p->m_rep.get() );
      return true;
    }
    throw std::runtime_error( "Cannot add profile histograms of different implementations." );
  }
 
  template <class INTERFACE, class IMPLEMENTATION>
  std::ostream& Generic1D<INTERFACE, IMPLEMENTATION>::print( std::ostream& s ) const {
    m_rep->Print( "all" );
    return s;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  std::ostream& Generic1D<INTERFACE, IMPLEMENTATION>::write( std::ostream& s ) const {
    s << "\n1D Histogram Table: " << std::endl;
    s << "Bin, Height, Error " << std::endl;
    for ( int i = 0; i < axis().bins(); ++i )
      s << binMean( i ) << ", " << binHeight( i ) << ", " << binError( i ) << std::endl;
    s << std::endl;
    return s;
  }

  template <class INTERFACE, class IMPLEMENTATION>
  int Generic1D<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__ )
#  pragma GCC diagnostic pop
#endif