CscCalcPed.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CSCCALCPED_H
#define CSCCALCPED_H
 
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
 
#include "AthContainers/DataVector.h"
#include "CscCalibData/CscCalibResultCollection.h"
#include "MuonCondData/CscCondDbData.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonCSC_CnvTools/ICSC_RDO_Decoder.h"
 
#include <string>
#include <vector>
#include <bitset>
 
#include "TH1I.h"
#include "TH1F.h"
#include "TH2F.h"
#include <algorithm>//for min_Element, max_element
 
namespace MuonCalib{
  class CscCalcPed: public AthAlgorithm
  {
    public:
      CscCalcPed(const std::string& name, ISvcLocator* pSvcLocator);
      ~CscCalcPed()=default;
 
      StatusCode initialize(void);
      StatusCode execute(void);
      StatusCode finalize(void); 
 
    private:
 
      /***********Private member functions*/
      StatusCode collectEventInfo();
      StatusCode calculateParameters();
      StatusCode writeCalibrationFile();
      StatusCode storeGateRecord();
      DataVector<TH2F> * makeBitCorrelation();
 
      StatusCode calOutput0();
      StatusCode calOutput1();
      StatusCode calOutput3();
      void outputParameter3(const CscCalibResultCollection & results, std::ofstream & out);
 
      StatusCode hashToChamberName(IdentifierHash,std::string);     
      StatusCode fillBitHist(TH1I * bitHist, const uint16_t & val, TH2F* bitProds);
      template <typename dataType> dataType GetMinMax(std::vector<dataType> & vec) {
        const auto [pMin, pMax] = std::minmax_element(vec.begin(), vec.end());
        return *pMax - *pMin;
      }
  
      void onlineToOfflineHashId(const unsigned int & onlineId, unsigned int &hashId) const;
 
      /*********Private member variables*/
      ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
      IChronoStatSvc* m_chronoSvc;
      ToolHandle<Muon::ICSC_RDO_Decoder> m_cscRdoDecoderTool{this,"CscRdoDecoderTool","Muon::CscRDO_Decoder"};
      SG::ReadCondHandleKey<CscCondDbData> m_readKey{this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"};   
 
 
      std::string m_outputFileName;
      std::string m_titlePrefix, m_titlePostfix;
      std::string m_calOutputVersion;
      bool m_doCorrelation;
 
 
      //bool m_makeHists, m_dumpAllHists;
      float m_thresholdMultiplier;
      int m_expectedChamberLayer;
 
      std::string m_onlineDbFile; 
 
      unsigned int m_maxStripHash;
 
      unsigned int m_ampHistLowBound, m_ampHistHighBound, m_ampHistNumBins; 
 
      const unsigned int m_numBits;
 
      bool m_doBitHists;    
      bool m_doSampleHists;
 
      int m_numSamplesExpected;
 
      bool m_doF001;
 
      DataVector<TH1I> * m_ampHists;
      DataVector< DataVector<TH1I> > * m_sampHists;
      DataVector<TH1I> * m_bitHists;
      DataVector<TH2F> * m_bitProds;
      DataVector<TH1F> * m_bitCorrelation;
      std::vector<int> m_onlineThresholds;
      std::vector<int> m_onlineThresholdFailureCount;
      CscCalibResultCollection * m_peds;
      CscCalibResultCollection * m_noises;
      CscCalibResultCollection * m_rmses;
      CscCalibResultCollection * m_f001s;
      CscCalibResultCollection * m_onlineTHoldBreaches;
      int m_eventCnt;   
      double * m_crossTalkFix;
 
      //String for interface to patch changes
      std::string m_cmt_parameter;
 
      bool m_doOnlineDbFile;
 
  };//end class CscCalcPed
 
 
  inline StatusCode CscCalcPed::fillBitHist(TH1I * bitHist, const uint16_t & val, TH2F* bitProds)
  {
    if(!bitHist)
      return StatusCode::RECOVERABLE;
 
    //Num bits should always be m_numBits
    std::bitset<12> bitVal(val);
 
    for(unsigned int bitIndex = 0; bitIndex < m_numBits; bitIndex++){
      if(bitVal[bitIndex]){
        bitHist->Fill(bitIndex);
        if(bitProds){
          for(unsigned int bitIndex2 = 0 ; bitIndex2 <= bitIndex ; bitIndex2++) {
            if(bitVal[bitIndex2]){
              bitProds->Fill(bitIndex,bitIndex2);
              if(bitIndex != bitIndex2)
                bitProds->Fill(bitIndex2,bitIndex);
            }
 
          }
        }
      }
 
    }
 
 
    return StatusCode::SUCCESS;
  }
 
}//end namespace:
 
#endif