PlotMgr.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETTRACKPERFMON_PLOTMGR_H
#define INDETTRACKPERFMON_PLOTMGR_H


#include "TrkValHistUtils/PlotBase.h"
#include "AthenaBaseComps/AthMsgStreamMacros.h"
#include "AthenaBaseComps/AthCheckMacros.h"
#include "AthenaBaseComps/AthMessaging.h"

#include "SinglePlotDefinition.h"

#include <string>
#include <string_view>
#include <vector>
 
 
namespace IDTPM {
 
  class PlotMgr : public PlotBase, public AthMessaging {
 
  public:

    PlotMgr( const std::string& dirName,
             const std::string& anaTag,
             PlotMgr* pParent = nullptr );

    virtual ~PlotMgr() = default;

    StatusCode initialize();

    SinglePlotDefinition retrieveDefinition(
        const std::string& identifier,
        std::string_view folderOverride = "",
        std::string_view nameOverride = "" ) const;

    template < class P >
    StatusCode retrieveAndBook(
        P*& pHisto,
        const std::string& identifier,
        std::string_view folderOverride = "",
        std::string_view nameOverride = "" )
    {
      const SinglePlotDefinition& def =
          retrieveDefinition( identifier, folderOverride, nameOverride );
      if( def.isEmpty() or not def.isValid() ) {
        ATH_MSG_WARNING( "Trying to book empty or non-valid plot : " << identifier );
        return StatusCode::RECOVERABLE;
      }
      ATH_CHECK( book( pHisto, def ) );
      return StatusCode::SUCCESS;
    }

    StatusCode book( TH1*& pHisto, const SinglePlotDefinition& def );

    StatusCode book( TH2*& pHisto, const SinglePlotDefinition& def );

    StatusCode book( TH3*& pHisto, const SinglePlotDefinition& def );

    StatusCode book( TProfile*& pHisto, const SinglePlotDefinition& def );

    StatusCode book( TProfile2D*& pHisto, const SinglePlotDefinition& def );

    StatusCode book( TEfficiency*& pHisto, const SinglePlotDefinition& def );

    StatusCode fill(
        TH1* pTh1, float value, float weight=1. ) const;

    StatusCode fill(
        TH2* pTh2, float xval, float yval, float weight=1. ) const;

    StatusCode fill(
        TH3* pTh3, float xval, float yval, float zval, float weight=1. ) const;

    StatusCode fill(
        TProfile* pTprofile, float xval, float yval, float weight=1. ) const;

    StatusCode fill(
        TProfile2D* pTprofile, float xval, float yval, float zval, float weight=1. ) const;

    StatusCode fill(
        TEfficiency* pTeff, float value, bool accepted, float weight=1. ) const;

    StatusCode fill(
        TEfficiency* pTeff2d, float xvalue, float yvalue, bool accepted, float weight=1. ) const;
 
  protected:

    template < class P >
    StatusCode setVariableBins(
      P*& pHisto, const std::vector<float>& binning, char axis )
    {
      if( binning.empty() ) {
        ATH_MSG_ERROR( "Non-valid variable plot binning : " << pHisto->GetName() );
        return StatusCode::FAILURE;
      }
      if( axis == 'X' ) pHisto->GetXaxis()->Set( binning.size()-1, binning.data() );
      if( axis == 'Y' ) pHisto->GetYaxis()->Set( binning.size()-1, binning.data() );
      if( axis == 'Z' ) pHisto->GetZaxis()->Set( binning.size()-1, binning.data() );
      return StatusCode::SUCCESS;
    }

    template < class P >
    StatusCode setVariableBinsEff(
      P*& pHisto, const std::vector<float>& binning, char axis )
    {
      if( binning.empty() ) {
        ATH_MSG_ERROR( "Non-valid variable plot binning : " << pHisto->GetName() );
        return StatusCode::FAILURE;
      }
      std::vector<double> binningD( binning.begin(), binning.end() );
      if( axis == 'X' ) pHisto->SetBins( binningD.size()-1, binningD.data() );
      if( axis == 'Y' ) {
        pHisto->SetBins(
          pHisto->GetTotalHistogram()->GetNbinsX(),
          pHisto->GetTotalHistogram()->GetXaxis()->GetXbins()->GetArray(),
          binningD.size()-1, binningD.data() );
      }
      return StatusCode::SUCCESS;
    }

    template < class P >
    StatusCode setLogLinearBins(
      P*& pHisto, unsigned int nBins, float absMin, float absMax, char axis )
    {
      std::vector<float> binning = getLogLinearBins( nBins, absMin, absMax );
      ATH_CHECK( setVariableBins( pHisto, binning, axis ) );
      return StatusCode::SUCCESS;
    }

    template < class P >
    StatusCode setLogLinearBinsEff(
      P*& pHisto, unsigned int nBins, float absMin, float absMax, char axis )
    {
      std::vector<float> binning = getLogLinearBins( nBins, absMin, absMax );
      ATH_CHECK( setVariableBinsEff( pHisto, binning, axis ) );
      return StatusCode::SUCCESS;
    }

    std::vector<float> getLogLinearBins(
        unsigned int nBins, float absMin, float absMax,
        bool symmetriseAroundZero = false );

    template < class P >
    StatusCode setBinLabels(
      P*& pHisto, const std::vector< std::string >& binLabels, char axis )
    {
      if( axis == 'X' ) {
        size_t nBinsX = pHisto->GetXaxis()->GetNbins();
        if( nBinsX != binLabels.size() ) {
          ATH_MSG_ERROR( "Mismstch in number of X bin labels for : " << pHisto->GetName() );
          return StatusCode::FAILURE;
        }
        for( size_t bin = 0; bin < nBinsX; bin++ ) {
          pHisto->GetXaxis()->SetBinLabel( bin+1, binLabels[ bin ].c_str() );
        }
      }
      if( axis == 'Y' ) {
        size_t nBinsY = pHisto->GetYaxis()->GetNbins();
        if( nBinsY != binLabels.size() ) {
          ATH_MSG_ERROR( "Mismstch in number of Y bin labels for : " << pHisto->GetName() );
          return StatusCode::FAILURE;
        }
        for( size_t bin = 0; bin < nBinsY; bin++ ) {
          pHisto->GetYaxis()->SetBinLabel( bin+1, binLabels[ bin ].c_str() );
        }
      }
      if( axis == 'Z' ) {
        size_t nBinsZ = pHisto->GetZaxis()->GetNbins();
        if( nBinsZ != binLabels.size() ) {
          ATH_MSG_ERROR( "Mismstch in number of Z bin labels for : " << pHisto->GetName() );
          return StatusCode::FAILURE;
        }
        for( size_t bin = 0; bin < nBinsZ; bin++ ) {
          pHisto->GetZaxis()->SetBinLabel( bin+1, binLabels[ bin ].c_str() );
        }
      }
      return StatusCode::SUCCESS;
    }
 
    std::string m_anaTag;
 
  }; // class PlotMgr
 
} // namespace IDTPM
 
#endif // > ! INDETTRACKPERFMON_PLOTMGR_H