d2/d91/LArNoiseBursts_8h_source.html

/*

  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