NeutralPFOClusterMLCorrectionTool Class Reference

Applies ML corrections to PFO ML corrections are stored in linked CaloClusters as decorations. More...

#include <NeutralPFOClusterMLCorrectionTool.h>

Inheritance diagram for NeutralPFOClusterMLCorrectionTool:

Collaboration diagram for NeutralPFOClusterMLCorrectionTool:

Public Member Functions
	NeutralPFOClusterMLCorrectionTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~NeutralPFOClusterMLCorrectionTool ()=default
virtual StatusCode	initialize () override
virtual void	correctContainer (xAOD::FlowElementContainer &neutral_pfos, xAOD::FlowElementContainer &charged_pfos, const EventContext &ctx) const override

Private Member Functions
void	correctNeutralFlowElement (xAOD::FlowElement &pfo, const SG::ReadDecorHandle< xAOD::CaloClusterContainer, double > &clusterMLReadHandle) const
const xAOD::CaloCluster *	getLinkedCluster (const xAOD::FlowElement &pfo) const

Private Attributes
SG::ReadDecorHandleKey< xAOD::CaloClusterContainer >	m_clusterMLCorrectedEnergyKey
Gaudi::Property< float >	m_max_allowed_charged_correction_fraction {this, "MaxAllowedChargedCorrectionFraction", 0.001, "ClusterML correction will be applied only if |npfo_E - cls_EM_E| <= |MaxAllowedChargedCorrectionFraction * cls_EM_E|"}
Gaudi::Property< float >	m_min_allowed_em_energy {this,"MinAllowedEMEnergyMeV", 300, "Minimum allowed energy in MeV of matched cluster at EM scale. ClusterML correction will not be applied below this limit."}

Detailed Description

Applies ML corrections to PFO ML corrections are stored in linked CaloClusters as decorations.

The correction is applied as a scale factor to the PFO.

Definition at line 29 of file NeutralPFOClusterMLCorrectionTool.h.

Constructor & Destructor Documentation

NeutralPFOClusterMLCorrectionTool()

NeutralPFOClusterMLCorrectionTool::NeutralPFOClusterMLCorrectionTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 11 of file NeutralPFOClusterMLCorrectionTool.cxx.

  : base_class(type, name, parent) {}

~NeutralPFOClusterMLCorrectionTool()

virtual NeutralPFOClusterMLCorrectionTool::~NeutralPFOClusterMLCorrectionTool ( )

virtualdefault

Member Function Documentation

correctContainer()

void NeutralPFOClusterMLCorrectionTool::correctContainer ( xAOD::FlowElementContainer & neutral_pfos, xAOD::FlowElementContainer & charged_pfos, const EventContext & ctx ) const

overridevirtual

Definition at line 22 of file NeutralPFOClusterMLCorrectionTool.cxx.

{
 
  SG::ReadDecorHandle<xAOD::CaloClusterContainer, double> clusterMLReadHandle(m_clusterMLCorrectedEnergyKey, ctx);
  if (!clusterMLReadHandle.isValid()) {
    throw std::runtime_error("Invalid decoration handle: " +
                             m_clusterMLCorrectedEnergyKey.key());
  }
 
  for (xAOD::FlowElement *neutral_pfo : neutral_pfos)
  { correctNeutralFlowElement(*neutral_pfo, clusterMLReadHandle); }
}

correctNeutralFlowElement()

void NeutralPFOClusterMLCorrectionTool::correctNeutralFlowElement ( xAOD::FlowElement & pfo, const SG::ReadDecorHandle< xAOD::CaloClusterContainer, double > & clusterMLReadHandle ) const

private

Definition at line 36 of file NeutralPFOClusterMLCorrectionTool.cxx.

{
  // The correction is applied only if link to cluster exists.
  // If no link exists, it can be due to negative cell subtraction. In this case, no correction is applied.
  // The corrected neutral pfo energy is calculated from ML-corrected cluster energy
  if (neutral_pfo.isCharged())
  {
    throw std::runtime_error("Charged FlowElement found in neutral FlowElementContainer with index " + std::to_string(neutral_pfo.index()));
  }
  const xAOD::CaloCluster *cls = getLinkedCluster(neutral_pfo);
  if (cls == nullptr)
  { return; }
 
  const double cluster_EM_energy = cls->rawE();
 
  bool apply_ML_correction = (std::abs(neutral_pfo.e() - cluster_EM_energy) <= std::abs(m_max_allowed_charged_correction_fraction.value() * cluster_EM_energy));
  apply_ML_correction = apply_ML_correction && (cluster_EM_energy > m_min_allowed_em_energy.value());
  if (apply_ML_correction)
  {
    const double cluster_ML_energy = clusterMLReadHandle(*cls);
    neutral_pfo.setP4(cluster_ML_energy / cosh(neutral_pfo.eta()), neutral_pfo.eta(), neutral_pfo.phi(), neutral_pfo.m());
  }
 
}

getLinkedCluster()

const xAOD::CaloCluster * NeutralPFOClusterMLCorrectionTool::getLinkedCluster ( const xAOD::FlowElement & pfo ) const

private

Definition at line 62 of file NeutralPFOClusterMLCorrectionTool.cxx.

{
  // Returns xAOD::Type::CaloCluster type link. There should be at most one such link.
  // It can happen that no such link exists. This can happen due to negative cells subtraction.
  // Empty link is returned if no valid cluster link is found.
  const std::vector<ElementLink<xAOD::IParticleContainer>> &otherObjectLinks = neutral_pfo.otherObjectLinks();
  if (otherObjectLinks.size() > 1)
    throw std::runtime_error("NeutralPFOClusterMLCorrectionTool: Multiple links found for neutral FlowElement with index " + std::to_string(neutral_pfo.index()));
 
  bool hasValidLink = !otherObjectLinks.empty() && otherObjectLinks[0].isValid();
  if (!hasValidLink)
  { return nullptr; }
 
  if ((**otherObjectLinks[0]).type() != xAOD::Type::CaloCluster)
    throw std::runtime_error("NeutralPFOClusterMLCorrectionTool: Link for neutral FlowElement with index " + std::to_string(neutral_pfo.index()) + " is not of type CaloCluster");
 
  return static_cast<const xAOD::CaloCluster *>(*otherObjectLinks[0]);
}

initialize()

StatusCode NeutralPFOClusterMLCorrectionTool::initialize ( )

overridevirtual

Definition at line 14 of file NeutralPFOClusterMLCorrectionTool.cxx.

                                                         {
  ATH_CHECK(m_clusterMLCorrectedEnergyKey.initialize());
  ATH_MSG_DEBUG("Initializing with ClusterMLCorrectedEnergyDecorationKey: " << m_clusterMLCorrectedEnergyKey.key());
  ATH_MSG_DEBUG("Initializing with MaxAllowedChargedCorrectionFraction: " << m_max_allowed_charged_correction_fraction.value());
  ATH_MSG_DEBUG("Initializing with MinAllowedEMEnergyMeV: " << m_min_allowed_em_energy.value());
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_clusterMLCorrectedEnergyKey

SG::ReadDecorHandleKey<xAOD::CaloClusterContainer> NeutralPFOClusterMLCorrectionTool::m_clusterMLCorrectedEnergyKey

private

Initial value:

{
      this,
      "ClusterMLCorrectedEnergyDecorationKey",
      "CaloCalTopoClusters.clusterE_ML",
      "Decoration storing ML-corrected cluster energy"
  }

Definition at line 40 of file NeutralPFOClusterMLCorrectionTool.h.

                                                                              {
      this,
      "ClusterMLCorrectedEnergyDecorationKey",
      "CaloCalTopoClusters.clusterE_ML",
      "Decoration storing ML-corrected cluster energy"
  };

m_max_allowed_charged_correction_fraction

Gaudi::Property<float> NeutralPFOClusterMLCorrectionTool::m_max_allowed_charged_correction_fraction {this, "MaxAllowedChargedCorrectionFraction", 0.001, "ClusterML correction will be applied only if |npfo_E - cls_EM_E| <= |MaxAllowedChargedCorrectionFraction * cls_EM_E|"}

private

Definition at line 47 of file NeutralPFOClusterMLCorrectionTool.h.

{this, "MaxAllowedChargedCorrectionFraction", 0.001, "ClusterML correction will be applied only if |npfo_E - cls_EM_E| <= |MaxAllowedChargedCorrectionFraction * cls_EM_E|"};

m_min_allowed_em_energy

Gaudi::Property<float> NeutralPFOClusterMLCorrectionTool::m_min_allowed_em_energy {this,"MinAllowedEMEnergyMeV", 300, "Minimum allowed energy in MeV of matched cluster at EM scale. ClusterML correction will not be applied below this limit."}

private

Definition at line 48 of file NeutralPFOClusterMLCorrectionTool.h.

{this,"MinAllowedEMEnergyMeV", 300, "Minimum allowed energy in MeV of matched cluster at EM scale. ClusterML correction will not be applied below this limit."};

---

The documentation for this class was generated from the following files:

• NeutralPFOClusterMLCorrectionTool.h
• NeutralPFOClusterMLCorrectionTool.cxx