CscCalibMonToolBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CSCCALIBMONITORING_CSCCALIBMONTOOLBASE_H
#define CSCCALIBMONITORING_CSCCALIBMONTOOLBASE_H
 
 
 
#include "Rtypes.h"
 
#include "AthenaMonitoring/ManagedMonitorToolBase.h"
 
#include "StoreGate/StoreGateSvc.h"
#include "GaudiKernel/MsgStream.h"
 
#include "MuonCondData/CscCondDataCollection.h"
#include "MuonCondData/CscCondDataContainer.h"
#include "MuonCondData/CscCondDbData.h"
 
#include "CscCalibData/CscCalibResultContainer.h"
 
#include "GaudiKernel/ServiceHandle.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
 
#include <vector>
#include <set>
#include <string>
 
class TH1I;
class TH1F;
class TH2F;
class TProfile;
 
 
class CscCondDbData;

 
 
class CscCalibMonToolBase: public ManagedMonitorToolBase  
{
 
    public:
  
        CscCalibMonToolBase (const std::string & type, const std::string & name, 
                const IInterface* parent);
 
        ~CscCalibMonToolBase() {};

        virtual StatusCode initialize();

        virtual StatusCode finalize();

        virtual StatusCode bookHistograms();

        virtual StatusCode fillHistograms();

        virtual StatusCode procHistograms();

        virtual StatusCode checkHists(bool fromFinalise);
 
 
    protected:
        unsigned int m_maxHashId{};
        unsigned int m_maxChamId{};
        unsigned int m_numBad{};
        unsigned int m_expectedChamberLayer{};
 
        
        bool  m_makeHashHists{}, m_makeAllChan1dHists{}, m_makeAllChan2dHists{},  m_makeLayHists{}, 
              m_makeLaySummHists{}, m_makeChamProfs{}, 
              m_makeChamSummHists{}, m_makeChamHists{},
              m_doAllDetailed{}, m_doBadDetailed{};
 
 
        
        int m_maxDetailedChannels{};
        bool * m_detailedHashIds{};

        bool m_onlyExpectPrecisionHashIds{};
        std::set<int> m_expectedHashIdsAll,m_expectedHashIdsPrec;

        std::string m_hashName, 
          m_hashTitle,
          m_allChan1dName, 
          m_allChan1dTitle, 
          m_allChan2dName, 
          m_allChan2dTitle, 
          m_chamProfName, 
          m_chamProfTitle, 
          m_layHistName, 
          m_layHistTitle, 
          m_chamSummHistName, 
          m_chamSummHistTitle, 
          m_chamHistName, 
          m_chamHistTitle, 
          m_laySummHistName, 
          m_laySummHistTitle;

        int m_histCol{}, m_histColAlert{};

        std::string m_generic_path_csccalibmonitoring;
        std::string m_hashPath, m_allChan2dPath, m_chamProfPath, m_layHistPath, 
          m_chamSummHistPath, m_laySummHistPath;

        DataVector<MonGroup> * m_monGroupVec{};
        std::map<std::string, MonGroup*> m_monGroupMap;

        std::string m_calibResultKey;
 
        ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

        SG::ReadCondHandleKey<CscCondDbData> m_readKey{this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"};   
 

        struct ProcSetupInfo
        {
 
          ProcSetupInfo() : badHist(NULL), overDiff(NULL), overChi2(NULL),
          missingChans(NULL),
          badBin(0), missingBadBin(0), 
          chi2BadBin(0), maxDiff(0.0), chi2Max(9999.), expectedVal(9999.), doChi2(false),
          dbName(""),vals(NULL),errors(NULL),oldVals(NULL),
          diffs(NULL),chi2s(NULL)
          {}
 
          TH1I *badHist{};
          TH1F *overDiff{}, *overChi2{} ;
          TH1F *missingChans{};
          int badBin{}, missingBadBin{}, chi2BadBin{};
          float maxDiff{}, chi2Max{}, expectedVal{};
          std::set<int> expectedChannels;
          bool doChi2{};
          std::string dbName;
          //float *vals,*errors,*oldVals,*diffs,*chi2s;
          std::vector<float> *vals{}, *errors{}, *oldVals{}, *diffs{},* chi2s{};
        };

        struct HistCollection{
          HistCollection(): 
            ignoreY(false), 
          hashHist(NULL), allChan1dHistX(NULL), allChan1dHistY(NULL), allChan2dHist(NULL), chamProf(NULL),  
          abs2d(true)
          {}
 
          HistCollection(int arraySize, int errorSize = 0): 
            ignoreY(false),
            hashHist(NULL), allChan1dHistX(NULL), allChan1dHistY(NULL), allChan2dHist(NULL), chamProf(NULL),
            abs2d(true)
          {
            data.resize(arraySize);
            if(errorSize)
              errors.resize(errorSize);
          }
 
          ~HistCollection() {
          }
          bool ignoreY;
          std::vector<float>  data;
          std::vector<float> errors;
          std::vector<TH1F *> cscSpec{};
          TH1F * hashHist{};
          TH1F * allChan1dHistX{};
          TH1F * allChan1dHistY{};
          TH2F * allChan2dHist{};
          TProfile * chamProf{};
          std::vector<TH1F*> layHistVect{};
          std::vector<TH1F*> laySummVect{};
          std::vector<TH1F*> chamSummVect{};
          std::vector<TH1F*> chamHistVect{};
          bool abs2d{};
        };
 
        //Stat bit from database
        bool m_doStatDb{};
        HistCollection * m_statDbColl{};
 
    protected:
        virtual StatusCode bookHistCollection(HistCollection *histCollection,
            const std::string & dataTypeName, const std::string & dataTypeTitle, const std::string & categoryName, const std::string & categoryTitle,
            const std::string & axisLabel, int numBins, float lowBound, float highBound, const std::string & parDir ="", 
            uint16_t toSkip =0);

        virtual StatusCode bookLayHists(const std::string & histTypeDir, const std::string & parTypeDir,
            std::vector<TH1F*> &vector, 
            const std::string & namePrefix, const std::string & titlePrefix,
            const std::string & xaxis, const std::string & yaxis,  bool chanView = true, 
            bool ignoreY = false, unsigned int numBins = 100, 
            float lowBound = 0, float highbound = 100);
 

        virtual StatusCode  bookChamHists(const std::string & histTypeDir, const std::string & parTypeDir, 
            std::vector<TH1F*>&  histVector,
            const std::string & namePrefix, const std::string & titlePrefix,
            const std::string & xaxis = "", const std::string & yaxis = "", bool chanView = true, bool ignoreY = false, 
            unsigned int numBins = 100, float lowBound = 0, float highbound = 100);

        virtual StatusCode handleParameter(const CscCalibResultCollection *parVals);

        virtual StatusCode procParameter(const CscCalibResultCollection *parVals,
            ProcSetupInfo* simpleSet);
        virtual StatusCode copyDataToHists(HistCollection * histCollection);

        virtual StatusCode postProc();

        virtual int getLayIndex(int measuresPhi, int stationEta, int sector, int layer);
        virtual int getChamIndex(int measuresPhi, int stationEta, int sector);
        virtual int getSector(int stationPhi, int stationSize);
        std::string getEndCap(int eta);

        std::string getGeoPath( int eta = -9999, int sector = -9999,  
            int wireLayer = -9999,int measuresPhi = -9999 , int channel =-9999);

        std::string getFullPath(const std::string& geoPath, const std::string& histTypeDir, const std::string& parTypeDir);
 
};
 
#endif