TrigEgammaMonitorBaseAlgorithm.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TrigEgammaMonitorBaseAlgorithm_h 
#define TrigEgammaMonitorBaseAlgorithm_h 
 
#include "AthenaMonitoring/AthMonitorAlgorithm.h"
#include "TriggerMatchingTool/IMatchingTool.h"
#include "TrigCompositeUtils/ChainNameParser.h"
 
#include "TrigEgammaEmulationTool/TrigEgammaEmulationToolMT.h"
 
#include "AthenaMonitoringKernel/GenericMonitoringTool.h"
#include "TrigDecisionTool/TrigDecisionTool.h"
#include "EgammaAnalysisInterfaces/IAsgElectronIsEMSelector.h"
#include "EgammaAnalysisInterfaces/IAsgPhotonIsEMSelector.h"
#include "EgammaAnalysisInterfaces/IAsgElectronLikelihoodTool.h"
 
#include "xAODEventInfo/EventInfo.h"
#include "xAODTruth/TruthParticleContainer.h"
#include "xAODEgamma/Egamma.h"
#include "xAODEgamma/EgammaxAODHelpers.h"
#include "xAODEgamma/ElectronContainer.h"
#include "xAODEgamma/PhotonContainer.h"
#include "xAODTrigEgamma/TrigElectronContainer.h"
#include "xAODTrigEgamma/TrigPhotonContainer.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTrigCalo/TrigEMClusterContainer.h"
#include "xAODJet/JetContainer.h"
#include "xAODMissingET/MissingETContainer.h"
#include "xAODTrigger/EmTauRoIContainer.h"
#include "xAODTrigger/eFexEMRoIContainer.h"
 
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "PATCore/AcceptInfo.h"
#include "PATCore/AcceptData.h"
 
 
// Trigger Information struct
struct TrigInfo{
    // L1 information
    bool L1Legacy{}; 
    std::string L1Threshold; //EM22VHI
    // HLT information
    std::string trigger; //Trigger Name
    std::string signature; //Electron or Photon
    float etthr{}; // HLT Et threshold
    // if trigger is etcut OR idperf, pidname should be default (usually lhloose)
    std::string pidname; // Offline loose, medium, tight, etc...
    // extra HLT information
    bool idperf{}; // Performance chain
    bool etcut{}; // Et cut only chain
    bool nogsf{}; // GSF chain
    bool lrt{}; // LRT chain
    bool ion{}; // Heavy Ion chain
 
    std::string isolation;
    bool isolated{};
};
 
 
class TrigEgammaMonitorBaseAlgorithm : public AthMonitorAlgorithm {
 
  public:
    
    
    TrigEgammaMonitorBaseAlgorithm( const std::string& name, ISvcLocator* pSvcLocator );
    
    virtual ~TrigEgammaMonitorBaseAlgorithm();
    
    virtual StatusCode initialize() override;
 
    virtual StatusCode fillHistograms(const EventContext& /*ctx*/) const override {return StatusCode::SUCCESS;};
 
 
    std::vector<ChainNameParser::LegInfo> 
    getProbeTriggerLeg(const std::string& triggerName) const;
 
    std::string  getProbeInformation(const std::vector<ChainNameParser::LegInfo>& LegParts, const std::string& signature) const;
 
  private:

    ToolHandle<Trig::TrigDecisionTool> m_trigdec;
    std::map<std::string,TrigInfo> m_trigInfo;
    std::map<std::string,TrigInfo> m_trigInfoR3;
 
 
  protected:
 
    /* Trigger e/g matching tool */
    ToolHandle<TrigEgammaMatchingToolMT> m_matchTool;
    ToolHandle<Trig::IMatchingTool> m_matchTool_R3;
 
    /* Trigger e/g emulation tool */
    ToolHandle<Trig::TrigEgammaEmulationToolMT> m_emulatorTool;
    ToolHandleArray<IAsgElectronIsEMSelector> m_electronIsEMTool{this,"ElectronIsEMSelector",{}};
    ToolHandleArray<IAsgElectronLikelihoodTool> m_electronLHTool{this,"ElectronLikelihoodTool",{}};
    ToolHandleArray<IAsgElectronLikelihoodTool> m_electronDNNTool{ this, "ElectronDNNSelectorTool", {},"DNN tools" }; 
    ToolHandleArray<IAsgPhotonIsEMSelector> m_photonIsEMTool{this,"PhotonIsEMSelector",{}};
    
    
    Gaudi::Property<bool> m_doEmulation{this, "DoEmulation", false };
 
    Gaudi::Property<bool> m_doEffwithLH{this, "ComputeEffLH", false};
    Gaudi::Property<bool> m_doEffwithDNN{this, "ComputeEffDNN", false};

    Gaudi::Property<bool> m_tp{this, "TPTrigger", false };
    Gaudi::Property<std::string> m_defaultProbePidElectron{this, "DefaultProbeSelectionElectron", "lhloose"};
    Gaudi::Property<std::string> m_defaultProbePidPhoton{this, "DefaultProbeSelectionPhoton", "loose"};
    Gaudi::Property<std::vector<std::string>> m_isemname{this, "isEMResultNames", {} };
    Gaudi::Property<std::vector<std::string>>  m_lhname{this, "LHResultNames", {} };
    Gaudi::Property<std::vector<std::string>> m_dnnname {this, "DNNResultNames", {}, };
    Gaudi::Property<bool> m_detailedHists{this, "DetailedHistograms", false};
  
 
    asg::AcceptInfo m_accept;


    const std::map<std::string,TrigInfo>& getTrigInfoMap() const { return m_trigInfo; }
    const std::map<std::string,TrigInfo>& getTrigInfoMapR3() const { return m_trigInfoR3; }
    bool ApplyElectronPid(const EventContext& ctx, const xAOD::Electron *eg,const std::string&) const;
    bool ApplyPhotonPid(const EventContext& ctx, const xAOD::Photon *eg,const std::string&) const;
    const ToolHandle<Trig::TrigDecisionTool>& tdt() const {return m_trigdec;};

    const ToolHandle<TrigEgammaMatchingToolMT>& match() const {return m_matchTool;}
    const ToolHandle<Trig::IMatchingTool>& matchR3() const {return m_matchTool_R3;}
 
 

    asg::AcceptData setAccept(const EventContext& ctx, const TrigCompositeUtils::Decision*, const TrigInfo&, const bool) const;
    TrigInfo getTrigInfo(const std::string&) const;
    TrigInfo getTrigInfoR3(const std::string&) const;
    float dR(const float, const float, const float, const float) const;
    std::string getL1Item(const std::string& trigger) const;
    bool isIsolated(const xAOD::Electron*, const std::string&) const;
    bool isPrescaled(const std::string&) const;
    void setTrigInfo(const std::string&);
    void setTrigInfoR3(const std::string&);
    bool isHLTTruncated() const;
   
  
   
  
  
    float getEta2(const xAOD::Egamma* eg) const;
    float getEt(const xAOD::Electron* eg) const ;
    float getEtCluster37(const xAOD::Egamma* eg) const;
    float getDEmaxs1(const xAOD::Egamma *eg) const;
    float rTRT  (const xAOD::Electron* eg) const;
    float getSigmaD0(const xAOD::Electron *eg) const;
    float getD0sig(const xAOD::Electron *eg) const;
    float getEnergyBE0(const xAOD::Egamma *eg) const;
    float getEnergyBE1(const xAOD::Egamma *eg) const;
    float getEnergyBE2(const xAOD::Egamma *eg) const;
    float getEnergyBE3(const xAOD::Egamma *eg) const;
    float getEaccordion(const xAOD::Egamma *eg) const;
    float getE0Eaccordion(const xAOD::Egamma *eg) const;
 
 
 
 
 
 
 
 

#define GETTER(_name_) float getShowerShape_##_name_(const xAOD::Egamma* eg) const;
  GETTER(e011)
      GETTER(e132)
      GETTER(e237)
      GETTER(e277)
      GETTER(ethad)
      GETTER(ethad1)
      GETTER(weta1)
      GETTER(weta2)
      GETTER(f1)
      GETTER(e2tsts1)
      GETTER(emins1)
      GETTER(emaxs1)
      GETTER(wtots1)
      GETTER(fracs1)
      GETTER(Reta)
      GETTER(Rphi)
      GETTER(f3)
      GETTER(f3core)
      GETTER(Eratio)
      GETTER(Rhad)
      GETTER(Rhad1)
      GETTER(DeltaE)
#undef GETTER
 
 
      // GETTER for Isolation monitoring
#define GETTER(_name_) float getIsolation_##_name_(const xAOD::Electron* eg) const;
      GETTER(ptcone20)
      GETTER(ptcone30)
      GETTER(ptcone40)
      GETTER(ptvarcone20)
      GETTER(ptvarcone30)
      GETTER(ptvarcone40)
#undef GETTER
#define GETTER(_name_) float getIsolation_##_name_(const xAOD::Egamma* eg) const;
      GETTER(ptcone20)
      GETTER(etcone20)
      GETTER(etcone30)
      GETTER(etcone40)
      GETTER(topoetcone20)
      GETTER(topoetcone30)
      GETTER(topoetcone40)
#undef GETTER
      // GETTERs for CaloCluster monitoring
#define GETTER(_name_) float getCluster_##_name_(const xAOD::Egamma* eg) const;
      GETTER(et)
      GETTER(phi)
      GETTER(eta)
#undef GETTER
 
      // GETTERs for Track monitoring
#define GETTER(_name_) float getTrack_##_name_(const xAOD::Electron* eg) const;
      GETTER(pt)
      GETTER(phi)
      GETTER(eta)
      GETTER(d0)
      GETTER(z0)
#undef GETTER
 
 
      // GETTERs for Track details monitoring
#define GETTER(_name_) float getTrackSummary_##_name_(const xAOD::Electron* eg) const;
      GETTER(numberOfInnermostPixelLayerHits)
      GETTER(numberOfInnermostPixelLayerOutliers)
      GETTER(numberOfPixelHits)
      GETTER(numberOfPixelOutliers)
      GETTER(numberOfSCTHits)
      GETTER(numberOfSCTOutliers)
      GETTER(numberOfTRTHits)
      GETTER(numberOfTRTHighThresholdHits)
      GETTER(numberOfTRTHighThresholdOutliers)
      GETTER(numberOfTRTOutliers)
      GETTER(expectInnermostPixelLayerHit)
      GETTER(numberOfPixelDeadSensors)
      GETTER(numberOfSCTDeadSensors)
      GETTER(numberOfTRTXenonHits)
#undef GETTER
 
#define GETTER(_name_) float getTrackSummaryFloat_##_name_(const xAOD::Electron* eg) const;
      GETTER(eProbabilityComb)
      GETTER(eProbabilityHT)
      GETTER(pixeldEdx)
#undef GETTER
 
      // GETTERs for Calo-Track monitoring
#define GETTER(_name_) float getCaloTrackMatch_##_name_(const xAOD::Electron* eg) const;
      GETTER(deltaEta0)
      GETTER(deltaPhi0)
      GETTER(deltaPhiRescaled0)
      GETTER(deltaEta1)
      GETTER(deltaPhi1)
      GETTER(deltaPhiRescaled1)
      GETTER(deltaEta2)
      GETTER(deltaPhi2)
      GETTER(deltaPhiRescaled2)
      GETTER(deltaEta3)
      GETTER(deltaPhi3)
      GETTER(deltaPhiRescaled3)
#undef GETTER
 
};
 
 
 
namespace Gaudi
{
  namespace Parsers
  {
    typedef std::map<std::string, std::string> Dict_t;
 
    // A typedef may save a lot of mistakes
    typedef std::vector<Dict_t> VecDict_t;
 
    // Parse function... nothing special, but it must be done explicitly.
    StatusCode parse( VecDict_t & result, const std::string& input );
  }
}
 
 
#endif