LArCellMonTool.h

Go to the documentation of this file.

//Dear emacs, this is -*-c++-*-
 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
 
//W.Lampl  - Spring 2017: Major re-design
 
#ifndef CALOMONITORING_LARCELLMONTOOL_H
#define CALOMONITORING_LARCELLMONTOOL_H
 
#include "CaloMonToolBase.h"
#include "GaudiKernel/ToolHandle.h"
 
#include "LArRecConditions/LArBadChannelMask.h"
#include "CaloConditions/CaloNoise.h"
#include "CaloDetDescr/CaloDetDescrManager.h"
 
#include "LArIdentifier/LArOnlineID.h"
#include "Identifier/IdentifierHash.h"
 
#include "StoreGate/ReadCondHandleKey.h"
#include "LArRecConditions/LArBadChannelCont.h"
#include "LArCabling/LArOnOffIdMapping.h"
 
#include "TrigDecisionTool/TrigDecisionTool.h"
 
#include "LArCellBinning.h"
          
#include <vector>
#include <string>
#include <bitset>
#include <array>
#include <map>
#include <unordered_map>
 
namespace Trig {
  class ChainGroup;
}
 
class CaloCell;
class TileID;
class CaloCell_ID;
 
class TH1F;
class TH1D;
class TH2F;
class TProfile;
 
 
class LArCellMonTool : public CaloMonToolBase {
 
 public:
 
  LArCellMonTool(const std::string & type, const std::string& name, 
         const IInterface* parent);
  virtual ~LArCellMonTool();
  
  //Methods implementing the ManagedMonitorToolBase interface
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
  virtual StatusCode bookHistograms() override;
  virtual StatusCode procHistograms() override;
  virtual StatusCode fillHistograms() override;
 
private:
 
  //enums to help with the conversion of Layer, partitions and such:
 
  //Enumerate layers 
  enum LayerEnum{EMBPA=0, EMBPC, EMB1A, EMB1C, EMB2A, EMB2C, EMB3A, EMB3C,
         HEC0A, HEC0C, HEC1A, HEC1C, HEC2A, HEC2C, HEC3A, HEC3C,
         EMECPA,EMECPC,EMEC1A,EMEC1C,EMEC2A,EMEC2C,EMEC3A,EMEC3C,
         FCAL1A,FCAL1C,FCAL2A,FCAL2C,FCAL3A,FCAL3C,MAXLAYER};
 
  //Enumerate layer-types, ignoring sides. Useful for configuration that is per-definition symmetric 
  enum LayerEnumNoSides{EMBPNS=0, EMB1NS, EMB2NS, EMB3NS, HEC0NS, HEC1NS, HEC2NS, HEC3NS,
            EMECPNS,EMEC1NS,EMEC2NS,EMEC3NS,FCAL1NS,FCAL2NS,FCAL3NS,MAXLYRNS};
 
  //Enumerate partitions
  enum PartitionEnum{EMBA,EMBC,EMECA,EMECC,HECA,HECC,FCALA,FCALC,MAXPARTITIONS};
 
 
  //Mapping of layer-enum to their string-names (for histogram titles, etc)
  const std::array<std::string,MAXLAYER> m_layerNames={{"EMBPA", "EMBPC", "EMB1A", "EMB1C", "EMB2A", "EMB2C", "EMB3A", "EMB3C",
                            "HEC0A", "HEC0C", "HEC1A", "HEC1C", "HEC2A", "HEC2C", "HEC3A", "HEC3C",
                            "EMECPA", "EMECPC", "EMEC1A", "EMEC1C", "EMEC2A", "EMEC2C", "EMEC3A", "EMEC3C", 
                            "FCAL1A", "FCAL1C", "FCAL2A", "FCAL2C", "FCAL3A", "FCAL3C"}};
 
  //Mapping of layer-no-side enum to their string-names (for histogram titles, etc)
  const std::array<std::string,MAXLYRNS> m_lyrNSNames={{"EMBPS","EMB1" ,"EMB2" ,"EMB3" ,"HEC0" ,"HEC1" ,"HEC2","HEC3",
                            "EMECP","EMEC1","EMEC2","EMEC3","FCAL1","FCAL2","FCAL3"}};
  //Mapping of partition-enum to their string-name
  const std::array<std::string,MAXPARTITIONS> m_partitionNames{{"EMBA","EMBC","EMECA","EMECC","HECA","HECC","FCALA","FCALC"}};  
 
  //Mapping of CaloCell nomencature to CaloCellMonitoring nomencature
  const std::map<unsigned,LayerEnumNoSides> m_caloSamplingToLyrNS{ 
    {CaloSampling::PreSamplerB, EMBPNS},{CaloSampling::EMB1,EMB1NS},{CaloSampling::EMB2,EMB2NS},{CaloSampling::EMB3,EMB3NS},         //LAr Barrel
    {CaloSampling::PreSamplerE, EMECPNS},{CaloSampling::EME1,EMEC1NS}, {CaloSampling::EME2,EMEC2NS}, {CaloSampling::EME3,EMEC3NS},   //LAr Endcap     
    {CaloSampling::HEC0,HEC0NS}, {CaloSampling::HEC1,HEC1NS}, {CaloSampling::HEC2,HEC2NS}, {CaloSampling::HEC3,HEC3NS},              //Hadronic endcap
    {CaloSampling::FCAL0,FCAL1NS}, {CaloSampling::FCAL1,FCAL2NS}, {CaloSampling::FCAL2,FCAL3NS}                                      //FCAL
  };
 
  //Mapping of layers to the partition the layer belongs to
  const std::array<PartitionEnum,MAXLAYER> m_layerEnumtoPartitionEnum{{
    //EMBPA EMBPC, EMB1A, EMB1C, EMB2A, EMB2C, EMB3A, EMB3C,
      EMBA, EMBC,  EMBA,  EMBC,  EMBA,  EMBC,  EMBA,  EMBC,
   //HEC0A, HEC0C, HEC1A, HEC1C, HEC2A, HEC2C, HEC3A, HEC3C,
      HECA, HECC,  HECA,  HECC,  HECA,  HECC,  HECA,   HECC,
  //EMECPA,  EMECPC,EMEC1A,EMEC1C,EMEC2A,EMEC2C,EMEC3A,EMEC3C,
      EMECA, EMECC, EMECA, EMECC, EMECA, EMECC, EMECA, EMECC,
   //FCAL1A,FCAL1C,FCAL2A,FCAL2C, FCAL3A,FCAL3C,MAXLAYER
      FCALA, FCALC, FCALA, FCALC, FCALA, FCALC
    }};
  
  //Enumerations of possible threshold directions and trigger types:
  enum Direction{OVER,UNDER,NONE,BOTH}; 
  enum TriggerType{RNDM,CALO,MINBIAS,MET,MISC,NOTA,MAXTRIGTYPE};
 
 
  //Histogram path in root file:
  const std::string m_lArPath{"/CaloMonitoring/LArCellMon_NoTrigSel_OldTool/"};
 
  // Thresholds for time and Time vs Energy plots:
  // Energy thresholds hardcoded following official timing analysis. See for example:
  // https://indico.cern.ch/event/522351/
  const std::array<float ,MAXLYRNS> m_eCutForTiming {
  //EMBPNS=0, EMB1NS, EMB2NS, EMB3NS, HEC0NS, HEC1NS, HEC2NS, HEC3NS,EMECPNS,EMEC1NS,EMEC2NS,EMEC3NS,FCAL1NS,FCAL2NS,FCAL3NS
    {1000.,    1000.,  3000.,  1500.,  3500.,  3500.,  3500.,  3500., 1500.,  3000.,  3000.,  2000.,  10000., 10000., 10000.}
  };
 
 
  //Private methods: Initialization and job-option interpretation
  StatusCode initThreshHists();
  void setLArCellBinning();
  void resetInternals();
 
  //Private methods: Histogramm booking
  StatusCode bookLarMultThreHists(); 
  StatusCode bookSporHists();
  StatusCode bookLarNonThreHists();
  static TH2F* newEtaPhiHist(const std::string& hName, const std::string& hTitle, const CaloMonitoring::LArCellBinning& binning) ;
  static std::string strToLower(const std::string& input) ;
  void regTempHist(TH1* h, MonGroup& mg) const;
 
  //Private methods: Histogram filling
  StatusCode createPerJobHistograms(const EventContext& ctx,
                                    const CaloCellContainer* cellcont);
  void checkTriggerAndBeamBackground();
  void sporadicNoiseCandidate(const CaloCell* cell, const LArCellMonTool::LayerEnum iLyr,const float threshold, const LArOnOffIdMapping* cabling);
 
  //Helpers for histogram filling
  void getHistoCoordinates(const CaloDetDescrElement* dde, float& celleta, float& cellphi, unsigned& iLyr, unsigned& iLyrNS) const; 
  static void divideByOccupancy(TH2F* fraction, const TH2F* total, const TH2* occupancy) ;
 
 
  //Job Properties and other private variables
  bool m_oncePerJobHistosDone=false;
  SG::ReadHandleKey<CaloCellContainer> m_cellContainerName { this, "CaloCellContainer", "AllCalo", "SG key of the input cell container" };
 
  SG::ReadCondHandleKey<CaloNoise> m_noiseKey
    { this, "NoiseKey", "totalNoise", "SG key for noise" };
 
  SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey { this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" };
 
  // Trigger Awareness:
  bool m_useTriggerCaloMon;
  ToolHandle<Trig::TrigDecisionTool> m_trigDec; 
  std::array<std::string,NOTA> m_triggerNames; 
  std::array<const Trig::ChainGroup*, NOTA> m_chainGroups{{}};
 
  // bad channel mask  
  LArBadChannelMask m_bcMask;
  Gaudi::Property<std::vector<std::string> > m_problemsToMask{this,"ProblemsToMask",{}, "Bad-Channel categories to mask"};
  
  bool m_maskKnownBadChannels;
  bool m_maskNoCondChannels;
 
  bool m_doSaveTempHists;
  bool m_doKnownBadChannelsVsEtaPhi;
  bool m_doDatabaseNoiseVsEtaPhi;
  bool m_doEnergyVsTime;
  bool m_doUnnormalized1DEnergy;
  bool m_useLogarithmicEnergyBinning;
  bool m_useWeightedEffMerging;
    
 //threshold for sporadic plots
  bool m_sporadic_switch;
  float m_threshold_em_S0S1;
  float m_threshold_HECFCALEMS2S3;
  unsigned m_sporadicPlotLimit;
  unsigned m_sporadic_protc;
  unsigned m_minSporadicNoiseEventsPerCell;
 
 // Variables to configure LAr threshold plots:
 // Used to pass variable sized array through JO
  StringArrayProperty  m_thresholdNameProp;
  StringArrayProperty  m_thresholdDirectionProp;
  StringArrayProperty  m_triggersToIncludeProp;
  StringArrayProperty  m_triggersToExcludeProp;
  StringArrayProperty  m_thresholdTitleTemplates;
  FloatArrayProperty   m_defaultThresholds;
  BooleanArrayProperty m_inSigNoise;
  BooleanArrayProperty m_doPercentageOccupancyProp;
  BooleanArrayProperty m_doEtaPhiOccupancyProp;
  BooleanArrayProperty m_doEtaOccupancyProp;
  BooleanArrayProperty m_doPhiOccupancyProp;
  BooleanArrayProperty m_doEtaPhiTotalEnergyProp;
  BooleanArrayProperty m_doEtaPhiAverageEnergyProp;
  BooleanArrayProperty m_doEtaPhiAverageQualityProp;
  BooleanArrayProperty m_doEtaPhiFractionOverQthProp;
  FloatArrayProperty   m_qualityFactorThresholdProp;
  BooleanArrayProperty m_doEtaPhiAverageTimeProp;
  BooleanArrayProperty m_doEtaPhiFractionPastTthProp;
  FloatArrayProperty   m_timeThresholdProp;
  BooleanArrayProperty m_doBeamBackgroundRemovalProp; 
 
  StringArrayProperty  m_thresholdColumnType;
  FloatArrayProperty   m_thresholdsProp[MAXLYRNS];
 
  //The threshold-related variables and histograms are grouped in the following struct
  //one instance per threshold-type
  struct thresholdHist_t {
    //Configuration variables
    std::string m_threshName;                        
    std::string m_threshTitleTemplate;               
    std::array<float,MAXLYRNS> m_threshValue{{}};    
    std::array<std::string,MAXLYRNS> m_threshTitles; 
    bool m_inSigNoise=false;                         
    Direction m_threshDirection=OVER;
    bool m_doBeamBackgroundRemoval=false; 
    float m_qualityFactorThreshold=4000;
    float m_timeThreshold=4.;
 
    //Variables related to trigger-filtering
    std::bitset<MAXTRIGTYPE> m_triggersToInclude;
    std::bitset<MAXTRIGTYPE> m_triggersToExclude;
    bool m_threshTriggerDecision=true;
 
    //Switch histograms on/off
    bool m_doPercentageOccupancy=false;
    bool m_doEtaPhiOccupancy=false;
    bool m_doEtaOccupancy=false;
    bool m_doPhiOccupancy=false;
 
    bool m_doEtaPhiTotalEnergy=false;
    bool m_doEtaPhiAverageEnergy=false;
 
    bool m_doEtaPhiAverageQuality=false;
    bool m_doEtaPhiFractionOverQth=false;
    
    bool m_doEtaPhiAverageTime=false;
    bool m_doEtaPhiFractionPastTth=false;
 
    //Histogram pointers, per layer
    std::array<TH2F*,MAXLAYER> m_h_occupancy_etaphi{{}};  //Filled from  m_occupancyCounter
    std::array<TH1F*,MAXLAYER> m_h_occupancy_eta{{}};     //Filled from  m_occupancyCounter
    std::array<TH1F*,MAXLAYER> m_h_occupancy_phi{{}};     //Filled from  m_occupancyCounter
    
    std::array<TH2F*,MAXLAYER> m_h_totalEnergy_etaphi{{}}; //Filled directly
    std::array<TH2F*,MAXLAYER> m_h_averageEnergy_etaphi{{}}; //derived
    
    std::array<TH2F*,MAXLAYER> m_h_poorQualityOccupancy_etaphi{{}}; //Filled directly
    std::array<TH2F*,MAXLAYER> m_h_totalQuality_etaphi{{}}; //Filled directly
    std::array<TH2F*,MAXLAYER> m_h_fractionOverQth_etaphi{{}}; //derived
    std::array<TH2F*,MAXLAYER> m_h_averageQuality_etaphi{{}};//derived
 
    std::array<TH2F*,MAXLAYER> m_h_poorTimeOccupancy_etaphi{{}}; //Filled directly
    std::array<TH2F*,MAXLAYER> m_h_totalTime_etaphi{{}}; //Filled directly
    std::array<TH2F*,MAXLAYER> m_h_fractionPastTth_etaphi{{}}; //derived
    std::array<TH2F*,MAXLAYER> m_h_averageTime_etaphi{{}}; //derived
 
    //Occupancy-counter
    std::array<unsigned,185000> m_occupancyCounter{}; //Hardwired max not ideal but more efficient
 
    //Counter (for normalization)
    unsigned m_eventsPassed=0;
  };
 
  std::vector<thresholdHist_t> m_thresholdHists;
 
  StatusCode fillOccupancyHist(LArCellMonTool::thresholdHist_t& thr
                   , const CaloDetDescrManager* detDescMgr);
 
  // Identifer helpers and such
 
  const LArOnlineID* m_LArOnlineIDHelper;
  const CaloCell_ID* m_calo_id;
 
  SG::ReadCondHandleKey<LArOnOffIdMapping> m_cablingKey{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};
  SG::ReadCondHandleKey<LArBadChannelCont> m_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"};
  
  std::array<CaloMonitoring::LArCellBinning,MAXLAYER> m_binning;
 
  //Sporadic monitoring related variables and structs
  std::string m_sporadicDir;
  unsigned m_counter_sporadic_protc=0;
 
  struct SporadicNoiseCell_t{
    TH1F* m_h_energy=nullptr;
    TH1F* m_h_quality=nullptr;
    TProfile* m_h_energyVsLB=nullptr;
    unsigned m_counter=0; 
    //Note wrt AthenaMP: Counting noisy event is obviously flawed, even for 
    //serial processing as events are scattered over many files
  };
 
  struct idHasher {
    std::size_t operator()(const Identifier& id) const {
      return std::hash<Identifier::value_type>{}(id.get_compact());
    }
  };
 
  std::unordered_map<Identifier,SporadicNoiseCell_t,idHasher> m_sporadicNoiseCells;
  
  void bookNoisyCellHistos(SporadicNoiseCell_t& result, const CaloDetDescrElement* dde, const PartitionEnum part, const float threshold, const LArOnOffIdMapping* cabling);
 
  std::array<TH1F*,MAXPARTITIONS> m_h_sporadicHists;
  std::array<unsigned,MAXPARTITIONS> m_sporadicPerPartCounter{};
 
 
  // summary plot
  TH1F* m_h_n_trigEvent=nullptr;
 
  // energy and time distribution for cell neither badcell nor noconditions 
  std::array<TH1F*,MAXLAYER> m_h_energy{{}};  // define when m_doUnnormalized1DEnergy==1
  std::array<TH2F*,MAXLAYER> m_h_energyVsTime{{}};
  std::array<TH1F*,MAXLAYER> m_h_cellTime{{}};
  std::array<TH1F*,MAXLAYER> m_h_energyVsTime_DifferThresholds{{}};
 
 
  // Reference Type Histograms (Filled solely with database information)
  std::array<TH2F*,MAXLAYER> m_h_badChannels_etaphi{{}};
  std::array<TH2F*,MAXLAYER> m_h_dbnoise_etaphi{{}};
 
  // temporary plots used for m_percentOccupancy_eta(phi) 
  std::array<TH1F*,MAXLAYER>  m_h_nActiveCellsFirstEvent_eta{{}}; 
  std::array<TH1F*,MAXLAYER>  m_h_nActiveCellsFirstEvent_phi{{}};
 
};
 
#endif 
 
//Histograms dropped during the redesign in spring 2017:
// * All inverse-masking
// * Cell Occupancy Eta/Phi Vs LumiBlock
// * DBNoiseNormalizedEnergy per layer 
// * doEtaPhiEnergyRMS per layer and threshold
// * DoEtaPhiRMSvsDBnoise per layer and threshold