LArNoiseBursts.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARCAFJOBS_LARNOISEBURSTS_H
#define LARCAFJOBS_LARNOISEBURSTS_H
 
#include "GaudiKernel/ToolHandle.h"
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/AlgTool.h"
 
#include "CLHEP/Units/SystemOfUnits.h"
#include "GaudiKernel/ITHistSvc.h"
#include "StoreGate/ReadCondHandleKey.h"
 
//LAr services:
#include "Identifier/Range.h" 
#include "Identifier/IdentifierHash.h"
#include "LArRecConditions/LArBadChannelCont.h"
#include "LArCabling/LArOnOffIdMapping.h"
#include "LArIdentifier/LArOnlineID.h"
#include "LArIdentifier/LArElectrodeID.h"
#include "CaloDetDescr/CaloDetDescrManager.h"
#include "CaloIdentifier/CaloCell_ID.h"
#include "LArRecEvent/LArNoisyROSummary.h"
 
// Trigger
#include "TrigDecisionTool/TrigDecisionTool.h"
#include "LumiBlockData/BunchCrossingCondData.h"
 
// Electrons
#include "egammaEvent/ElectronContainer.h"
 
//STL:
#include <string>
#include <bitset>
 
 
class LArOnlineID;
class LArElectrodeID;
class HWIdentifier;
class LArOnlineIDStrHelper;
class LArEM_ID;
class LArHEC_ID;
class LArFCAL_ID;
class CaloNoise;
 
class TileTBID;
class TgcIdHelper;
 
class TTree;
 
class LArHVLineID;
 
class ATLAS_NOT_THREAD_SAFE LArNoiseBursts : public AthAlgorithm  {
 
 public:
 
   LArNoiseBursts(const std::string& name, ISvcLocator* pSvcLocator);
   virtual ~LArNoiseBursts() = default;
 
   virtual StatusCode initialize() override;
   virtual StatusCode finalize() override;
   virtual StatusCode execute() override;
   virtual StatusCode clear();
 
 private:

   StatusCode doTrigger();
   StatusCode doEventProperties();
   StatusCode doLArNoiseBursts();  
 
   //functions
   int GetPartitionLayerIndex(const Identifier& id);
     
   StatusCode fillCell(HWIdentifier onlID
               , float eCalo
               , float qfactor
               , CaloGain::CaloGain gain
               , const LArOnOffIdMapping* cabling
               , const LArBadChannelCont* bcCont
               , const CaloNoise& totalNoise
               , const CaloDetDescrManager* caloMgr);
 
 private:
 
   ServiceHandle<ITHistSvc> m_thistSvc{this,"THistSvc","THistSvc"};
    
   TTree* m_tree;
 
   SG::ReadCondHandleKey<LArOnOffIdMapping> m_cablingKey { this, "CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};
   SG::ReadCondHandleKey<LArBadChannelCont> m_BCKey { this, "BadChanKey","LArBadChannel","SG Key of LArBadChannelCont object"};
   SG::ReadCondHandleKey<CaloNoise> m_totalNoiseKey
     { this, "TotalNoiseKey", "totalNoise", "SG key for total noise" };
   SG::ReadCondHandleKey<BunchCrossingCondData> m_bcDataKey 
     {this, "BunchCrossingCondDataKey", "BunchCrossingData" ,"SG Key of BunchCrossing CDO"};
   /*Tools*/
   PublicToolHandle< Trig::TrigDecisionTool > m_trigDec{this, "TrigDecisionTool", "", "Handle to the TrigDecisionTool"};
 
   SG::ReadHandleKey<LArNoisyROSummary> m_NoisyROKey { this, "LArNoisyROSummaryKey","LArNoisyROSummary","SG Key of LArNoisyROSummar object"};
   /*services*/
   const LArOnlineID* m_LArOnlineIDHelper;
   const LArHVLineID* m_LArHVLineIDHelper;
   const LArElectrodeID* m_LArElectrodeIDHelper;
   const LArEM_ID* m_LArEM_IDHelper;
   const LArFCAL_ID* m_LArFCAL_IDHelper;
   const LArHEC_ID*  m_LArHEC_IDHelper;
   SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey { this
       , "CaloDetDescrManager"
       , "CaloDetDescrManager"
       , "SG Key for CaloDetDescrManager in the Condition Store" };
 
 
   // Electrons
   std::string m_elecContainerName;
 
   /*event cuts */
   double m_sigmacut;
   bool m_CosmicCaloStream;
   unsigned int m_frontbunches;
   bool m_keepOnlyCellID;
 
   /*declaration of branches*/
   int m_nb_sat;
   int m_lowqfactor;
   int m_medqfactor;
   int m_hiqfactor;
   long m_noisycell;
   int  m_nt_larcellsize;
   int  m_nt_cellsize;
   int  m_nt_run ;
   unsigned long  m_nt_evtId;
   int  m_nt_evtTime;
   int  m_nt_evtTime_ns;
   int  m_nt_lb;
   int  m_nt_bcid;
   //int  m_nt_ntracks;
   int  m_nt_isbcidFilled;
   int  m_nt_isbcidInTrain;
   std::vector<int> m_nt_isBunchesInFront;
   int  m_nt_bunchtype;
   float m_nt_bunchtime;
   unsigned int m_nt_atlasready;
   unsigned int m_nt_stablebeams;
   std::vector<std::string> m_nt_streamTagName;
   std::vector<std::string> m_nt_streamTagType;
 
   // LAr event bit info
   bool m_nt_larflag_badFEBs;
   bool m_nt_larflag_mediumSaturatedDQ;
   bool m_nt_larflag_tightSaturatedDQ;
   bool m_nt_larflag_noiseBurstVeto;
   bool m_nt_larflag_dataCorrupted;
   bool m_nt_larflag_dataCorruptedVeto;
   bool m_nt_larflag_badFEBS_w;
   bool m_nt_larflag_mnbLoose;
   bool m_nt_larflag_mnbTight;
   bool m_nt_larflag_mnbTight_psveto;
   bool m_nt_larflag_badHVlines;
 
   uint8_t m_nt_badHVPartitions;
   // bad HV lines
   std::vector<unsigned int> m_nt_badHVlines;
 
   // NoiseBurst trigger
   bool m_nt_L1_J75;
   bool m_nt_L1_J10_EMPTY;
   bool m_nt_L1_J30_FIRSTEMPTY;
   bool m_nt_L1_J30_EMPTY;
   bool m_nt_L1_XE40;
   bool m_nt_L1_XE50;
   bool m_nt_L1_XE50_BGRP7;
   bool m_nt_L1_XE70;
 
   bool m_nt_EF_j165_u0uchad_LArNoiseBurst;
   bool m_nt_EF_j30_u0uchad_empty_LArNoiseBurst;
   bool m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst;
   bool m_nt_EF_j55_u0uchad_empty_LArNoiseBurst;
   bool m_nt_EF_xe45_LArNoiseBurst;
   bool m_nt_EF_xe55_LArNoiseBurst;
   bool m_nt_EF_xe60_LArNoiseBurst;
   bool m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT;
   bool m_nt_EF_j100_u0uchad_LArNoiseBurstT;
   bool m_nt_EF_j165_u0uchad_LArNoiseBurstT;
   bool m_nt_EF_j130_u0uchad_LArNoiseBurstT;
   bool m_nt_EF_j35_u0uchad_empty_LArNoiseBurst;
   bool m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst;
   bool m_nt_EF_j80_u0uchad_LArNoiseBurstT;
   
   //LAr Time variables
   float m_nt_ECTimeDiff;
   float m_nt_ECTimeAvg;
   int  m_nt_nCellA;
   int  m_nt_nCellC;
 
 
   //Quantites for noisy cells
   std::vector<float> m_nt_energycell;
   std::vector<float> m_nt_qfactorcell;
   std::vector<float> m_nt_phicell;
   std::vector<float> m_nt_etacell;
   std::vector<float> m_nt_signifcell;
   //float m_nt_noisycellpercent;
   std::vector<short> m_nt_barrelec_noisy;
   std::vector<short> m_nt_posneg_noisy;
   std::vector<short> m_nt_ft_noisy;
   std::vector<short> m_nt_slot_noisy;
   std::vector<short> m_nt_channel_noisy;
   std::vector<short>    m_nt_cellpartlayerindex;
   std::vector< unsigned int > m_nt_cellIdentifier;
   std::vector< unsigned int > m_nt_onlIdentifier;
   std::vector<float> m_nt_noisycellpart;
   std::vector<int> m_nt_noisycellHVphi;
   std::vector<int> m_nt_noisycellHVeta;
   std::vector<std::vector<short> > m_nt_samples;
   std::vector<int> m_nt_gain;
   std::vector<int> m_nt_isbadcell;
 
   std::vector<int>  m_nt_partition;
   std::vector<int>  m_nt_layer;
   
   //Quanties for the saturated cells
   std::vector<int> m_nt_isbadcell_sat;
   std::vector<int>  m_nt_barrelec_sat;
   std::vector<int>  m_nt_posneg_sat;
   std::vector<short>  m_nt_ft_sat;
   std::vector<short>  m_nt_slot_sat;
   std::vector<short>  m_nt_channel_sat;
   std::vector<int>  m_nt_partition_sat;
   std::vector<float> m_nt_energy_sat;
   std::vector<float> m_nt_phicell_sat;
   std::vector<float> m_nt_etacell_sat;
   std::vector<int> m_nt_layer_sat;
   std::vector<unsigned int> m_nt_cellIdentifier_sat;
 
};
 
#endif // LArNoiseBursts_H