egammaTruthAssociationAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EGAMMAALGS_EGAMMATRUTHASSOCIATIONALG_H
#define EGAMMAALGS_EGAMMATRUTHASSOCIATIONALG_H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "GaudiKernel/EventContext.h"
#include "GaudiKernel/ToolHandle.h"
#include "MCTruthClassifier/IMCTruthClassifier.h"
#include "MCTruthClassifier/MCTruthClassifierDefs.h"
#include "xAODEgamma/EgammaContainer.h"
 
#include "xAODEgamma/ElectronContainer.h"
#include "xAODEgamma/PhotonContainer.h"
#include "xAODTruth/TruthEventContainer.h"
#include "xAODTruth/TruthParticle.h"
#include "xAODTruth/TruthParticleAuxContainer.h"
#include "xAODTruth/TruthParticleContainer.h"
 
#include "RecoToolInterfaces/IParticleCaloExtensionTool.h"
 
#include "StoreGate/ReadHandle.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteDecorHandle.h"
#include "StoreGate/WriteDecorHandleKeyArray.h"
#include "StoreGate/WriteHandleKey.h"
 
#include <string>

 
class egammaTruthAssociationAlg : public AthReentrantAlgorithm
{
 
public:

  egammaTruthAssociationAlg(const std::string& name, ISvcLocator* pSvcLocator);

  virtual ~egammaTruthAssociationAlg() = default;

  virtual StatusCode initialize() override final;
  virtual StatusCode finalize() override final;

  virtual StatusCode execute(const EventContext& ctx) const override final;
 
private:
  struct MCTruthInfo_t
  {
    MCTruthPartClassifier::ParticleType first;
    MCTruthPartClassifier::ParticleOrigin second;
    const xAOD::TruthParticle* genPart;
  };

  template<class T>
  StatusCode initializeDecorKeys(SG::WriteDecorHandleKeyArray<T>& keys,
                                 const std::string& name);

  template<class T>
  struct writeDecorHandles
  {
    writeDecorHandles(const SG::WriteDecorHandleKeyArray<T>& keys,
                      const EventContext& ctx); // constructor
 
    SG::WriteDecorHandle<T, ElementLink<xAOD::TruthParticleContainer>> el;
    SG::WriteDecorHandle<T, int> type;
    SG::WriteDecorHandle<T, int> origin;
    SG::WriteDecorHandle<T, unsigned int> classification;
 
    // any of the handles should function as a read handle, choice is arbitrary
    SG::ReadHandle<T>& readHandle() { return type; };
  };

  template<class T, class L>
  StatusCode match(const EventContext& ctx,
                   const xAOD::TruthParticleContainer& truthParticles,
                   const SG::WriteDecorHandleKeyArray<T>& hkeys,
                   const SG::AuxElement::Accessor<L>& linkAccess,
                   xAOD::TruthParticleContainer* egammaTruthContainer) const;

  template<class T>
  MCTruthInfo_t particleTruthClassifier(const EventContext& ctx,
                                        const T*) const;

  void getNewTruthParticle(
    const EventContext& ctx,
    xAOD::TruthParticleContainer& egammaTruthContainer,
    const xAOD::TruthParticle* truth,
    const xAOD::TruthParticleContainer* oldContainer) const;

  bool isPromptEgammaParticle(const EventContext& ctx,
                              const xAOD::TruthParticle* truth) const;

  Gaudi::Property<bool> m_doEgammaTruthContainer{
    this,
    "CreateEgammaTruthContainer",
    true,
    "Create egammaTruthContainer?"
  };

  Gaudi::Property<bool> m_matchElectrons{ this,
                                          "MatchElectrons",
                                          true,
                                          "Match (central) electrons?" };

  Gaudi::Property<bool> m_matchPhotons{ this,
                                        "MatchPhotons",
                                        true,
                                        "Match photons?" };

  Gaudi::Property<bool> m_matchForwardElectrons{ this,
                                                 "MatchForwardElectrons",
                                                 true,
                                                 "Match forward electrons?" };

  Gaudi::Property<bool> m_matchClusters{ this,
                                         "MatchClusters",
                                         false,
                                         "Match clusters?" };

  SG::WriteDecorHandleKeyArray<xAOD::CaloClusterContainer> m_clusterDecKeys{
    this,
    "DoNotSet_ClusterContainerName",
    {},
    "Do not set; configuration via the string property"
  };

  Gaudi::Property<std::string> m_clusterDecName{
    this,
    "ClusterContainerName",
    "",
    "Name of the egamma cluster container"
  };

  SG::WriteDecorHandleKeyArray<xAOD::ElectronContainer> m_electronDecKeys{
    this,
    "DoNotSet_ElectronContainerName",
    {},
    "Do not set; configuration via the string property"
  };

  Gaudi::Property<std::string> m_electronDecName{
    this,
    "ElectronContainerName",
    "",
    "Name of the input electron container"
  };

  SG::WriteDecorHandleKeyArray<xAOD::ElectronContainer> m_fwdElectronDecKeys{
    this,
    "DoNotSet_FwdElectronContainerName",
    {},
    "Do not set; configuration via the string property"
  };

  Gaudi::Property<std::string> m_fwdElectronDecName{
    this,
    "FwdElectronContainerName",
    "",
    "Name of the input fwd electron container"
  };

  SG::WriteDecorHandleKeyArray<xAOD::PhotonContainer> m_photonDecKeys{
    this,
    "DoNotSet_PhotonContainerName",
    {},
    "Do not set; configuration via the string property"
  };

  Gaudi::Property<std::string> m_photonDecName{
    this,
    "PhotonContainerName",
    "",
    "Name of the input photon container"
  };

  SG::ReadHandleKey<xAOD::TruthEventContainer> m_truthEventContainerKey{
    this,
    "TruthEventContainerName",
    "",
    "Name of the truth event container"
  };

  SG::ReadHandleKey<xAOD::TruthParticleContainer> m_truthParticleContainerKey{
    this,
    "TruthParticleContainerName",
    "",
    "Name of the truth particle container"
  };

  SG::WriteHandleKey<xAOD::TruthParticleContainer>
    m_egammaTruthParticleContainerKey{
      this,
      "EgammaTruthContainerName",
      "",
      "Name of the output egamma truth particle container"
    };

  Gaudi::Property<float> m_minPt{
    this,
    "MinPtEgammaTruth",
    10,
    "Minimum Pt to enter egamma truth particle container"
  };

  Gaudi::Property<float> m_minPtFSR{
    this,
    "MinPtEgammaTruthFSR",
    1e3,
    "Minimum Pt for FSR to enter egamma truth particle container"
  };

  Gaudi::Property<bool> m_UPCmode{
    this,
    "UPCmode",
    false,
    "Allow electron from photon in egamma truth particle container"
  };
 

  ToolHandle<IMCTruthClassifier> m_mcTruthClassifier{
    this,
    "MCTruthClassifier",
    "EMMCTruthClassifier",
    "Handle of MCTruthClassifier"
  };
};
 
#endif // EGAMMAALGS_EGAMMATRUTHASSOCIATIONALG_H