PFUnifiedSubtractionOnlyTruthTool Class Reference

#include <PFUnifiedSubtractionOnlyTruthTool.h>

Inheritance diagram for PFUnifiedSubtractionOnlyTruthTool:

Collaboration diagram for PFUnifiedSubtractionOnlyTruthTool:

Public Member Functions
	~PFUnifiedSubtractionOnlyTruthTool ()
virtual StatusCode	initialize () override
virtual StatusCode	processPFlowData (const EventContext &ctx, PFData &thePFData) const override
	PFUnifiedSubtractionOnlyTool (const std::string &type, const std::string &name, const IInterface *parent)

Protected Member Functions
unsigned int	matchAndCreateEflowCaloObj (PFData &data) const
	This matches ID tracks and CaloClusters, and then creates eflowCaloObjects.
void	simulateShowers (const EventContext &ctx, eflowCaloObjectContainer &eflowCaloObjects, const unsigned int &nCaloObj) const
bool	isEOverPFail (double expectedEnergy, double sigma, double clusterEnergy) const
bool	canAnnihilate (double expectedEnergy, double sigma, double clusterEnergy) const
void	addSubtractedCells (eflowCaloObject &thisEflowCaloObject, const std::vector< std::pair< xAOD::CaloCluster *, bool > > &clusterList) const

Protected Attributes
ToolHandle< IEFlowCellEOverPTool >	m_theEOverPTool {this, "eflowCellEOverPTool", "eflowCellEOverPTool", "Energy Flow E/P Values and Shower Parameters Tool"}
	Tool for getting e/p values and hadronic shower cell ordering principle parameters.
std::unique_ptr< eflowEEtaBinnedParameters >	m_binnedParameters
std::unique_ptr< PFMatch::TrackEtaPhiInFixedLayersProvider >	m_trkpos
	Track position provider to be used to preselect clusters.
Gaudi::Property< bool >	m_recoverSplitShowers {this,"RecoverSplitShowers",false,"Toggle whether we are recovering split showers or not"}
	Toggle whether we are recovering split showers or not.
Gaudi::Property< bool >	m_calcEOverP {this, "CalcEOverP", false, "Toggle EOverP algorithm mode, whereby no charged shower subtraction is performed"}
	Toggle EOverP algorithm mode, whereby no charged shower subtraction is performed.
Gaudi::Property< double >	m_consistencySigmaCut {this, "ConsistencySigmaCut", 1.0, "Parameter that controls whether a track, in a track-cluster system, will be processed by the split shower recovery algorithm"}
	Parameter that controls whether a track, in a track-cluster system, will be processed by the split shower recovery algorithm.
Gaudi::Property< double >	m_subtractionSigmaCut {this, "SubtractionSigmaCut", 1.5, "Parameter that controls whether to use retain remaining calorimeter energy in track-cluster system, after charged shower subtraction"}
	Parameter that controls whether to use retain remaining calorimeter energy in track-cluster system, after charged shower subtraction.
Gaudi::Property< bool >	m_isHLLHC {this, "isHLLHC", false, "Toggle whether we have the HLLHC setup"}
	Toggle whether we have the HLLHC setup.
Gaudi::Property< bool >	m_addCPData {this,"addCPData",false,"Toggle whether to decorate FlowElements with additional data for Combined Performance studies "}
	Toggle whether to decorate eflowRecTrack with additional data for Combined Performance studies.
PFSubtractionStatusSetter	m_pfSubtractionStatusSetter {}
PFSubtractionEnergyRatioCalculator	m_pfSubtractionEnergyRatioCalculator {}
eflowSubtract::Subtractor	m_subtractor {}
ToolHandle< PFEnergyPredictorTool >	m_NNEnergyPredictorTool {this, "NNEnergyPredictorTool", "","Tool for getting predictiing the energy using an ONNX model "}
	Tool for getting predictiing the energy using an ONNX model.
Gaudi::Property< bool >	m_useNNEnergy {this, "useNNEnergy", false, "Toggle whether we use the neural net energy"}
	Toggle whether we use the neural net energy.
Gaudi::Property< bool >	m_useLegacyEBinIndex {this, "useLegacyEBinIndex", true, "Toggle whether we use the legacy energy bin index"}
	Further discussion about why this flag exists can be found in https://its.cern.ch/jira/browse/ATLJETMET-1692 and https://indico.cern.ch/event/1388633/contributions/5837876/attachments/2809591/4903439/PFlow_EOverP_Feb2024.pdf The Jira report discusses assorted problems with the treatment of energy bin indexes for the lookup of e/p values.

Private Member Functions
void	performSubtraction (const EventContext &ctx, const unsigned int &startingPoint, const unsigned int &nCaloObj, PFData &data) const override
void	performSubtraction (eflowCaloObject &thisEflowCaloObject) const override

Private Attributes
Gaudi::Property< bool >	m_useFullCellTruthSubtraction {this,"useFullCellTruthSubtraction",true,"Toggle whether we fully remove a cell with a truth deposit or reweight it based on truth contribution"}
	Toggle whether we fully remove a cell with a truth deposit or reweight it based on truth contribution.
ToolHandle< PFSimulateTruthShowerTool >	m_theTruthShowerSimulator {this, "PFSimulateTruthShowerTool", "", "The truth shower simulator"}

Detailed Description

Definition at line 15 of file PFUnifiedSubtractionOnlyTruthTool.h.

Constructor & Destructor Documentation

~PFUnifiedSubtractionOnlyTruthTool()

PFUnifiedSubtractionOnlyTruthTool::~PFUnifiedSubtractionOnlyTruthTool ( )

default

Member Function Documentation

addSubtractedCells()

void PFUnifiedSubtractionOnlyTool::addSubtractedCells ( eflowCaloObject & thisEflowCaloObject, const std::vector< std::pair< xAOD::CaloCluster *, bool > > & clusterList ) const

protectedinherited

Definition at line 334 of file PFUnifiedSubtractionOnlyTool.cxx.

                                                                                                                                                                {
 
  unsigned int numTracks = thisEflowCaloObject.nTracks();
 
  for (unsigned int iTrack = 0; iTrack < numTracks; ++iTrack){
    eflowRecTrack* thisTrack = thisEflowCaloObject.efRecTrack(iTrack);
    for (const auto& thisPair : clusterList){
      xAOD::CaloCluster* thisCluster = thisPair.first;
      const CaloClusterCellLink* theCellLink = thisCluster->getCellLinks();
      CaloClusterCellLink::const_iterator theCell = theCellLink->begin();
      CaloClusterCellLink::const_iterator lastCell = theCellLink->end();
      for (; theCell != lastCell; ++theCell) thisTrack->addSubtractedCaloCell(ElementLink<CaloCellContainer>("AllCalo",theCell.index()),theCell.weight()/numTracks);
    }
  }
}

canAnnihilate()

bool PFUnifiedSubtractionOnlyTool::canAnnihilate ( double expectedEnergy, double sigma, double clusterEnergy ) const

protectedinherited

Definition at line 329 of file PFUnifiedSubtractionOnlyTool.cxx.

{
  return clusterEnergy - expectedEnergy < m_subtractionSigmaCut * sigma;
}

initialize()

StatusCode PFUnifiedSubtractionOnlyTruthTool::initialize ( )

overridevirtual

Reimplemented from PFUnifiedSubtractionOnlyTool.

Definition at line 26 of file PFUnifiedSubtractionOnlyTruthTool.cxx.

{
 
  ATH_CHECK(m_theEOverPTool.retrieve());
 
  ATH_CHECK(m_theEOverPTool->fillBinnedParameters(m_binnedParameters.get()));
 
  m_trkpos.reset(dynamic_cast<PFMatch::TrackEtaPhiInFixedLayersProvider *>(PFMatch::TrackPositionFactory::Get("EM2EtaPhi").release()));
  if (!m_trkpos)
  {
    ATH_MSG_ERROR("Failed to get TrackPositionProvider for cluster preselection!");
    return StatusCode::FAILURE;
  }
 
  if (!m_NNEnergyPredictorTool.empty()) ATH_CHECK(m_NNEnergyPredictorTool.retrieve());
 
  if (!m_theTruthShowerSimulator.empty()) ATH_CHECK(m_theTruthShowerSimulator.retrieve());
 
 
  //Set the level of the helpers to the same as the tool here
  m_pfSubtractionStatusSetter.msg().setLevel(this->msg().level());
  m_pfSubtractionEnergyRatioCalculator.msg().setLevel(this->msg().level());
  m_subtractor.m_facilitator.msg().setLevel(this->msg().level());
 
 
  return StatusCode::SUCCESS;
 
}

isEOverPFail()

bool PFUnifiedSubtractionOnlyTool::isEOverPFail ( double expectedEnergy, double sigma, double clusterEnergy ) const

protectedinherited

Definition at line 323 of file PFUnifiedSubtractionOnlyTool.cxx.

{
  if ((expectedEnergy == 0) && (clusterEnergy > 0)) return false;
  return clusterEnergy < expectedEnergy - m_consistencySigmaCut * sigma;
}

matchAndCreateEflowCaloObj()

unsigned int PFUnifiedSubtractionOnlyTool::matchAndCreateEflowCaloObj ( PFData & data ) const

protectedinherited

This matches ID tracks and CaloClusters, and then creates eflowCaloObjects.

performSubtraction() [1/2]

void PFUnifiedSubtractionOnlyTruthTool::performSubtraction ( const EventContext & ctx, const unsigned int & startingPoint, const unsigned int & nCaloObj, PFData & data ) const

overrideprivatevirtual

Start loop from nCaloObj, which should be zero on a first pass

Reimplemented from PFUnifiedSubtractionOnlyTool.

Definition at line 70 of file PFUnifiedSubtractionOnlyTruthTool.cxx.

                                                                                                                                                                       {
 
  //starting point is defined in the base class API and used in other derived API.
  //It is not used here, so we silence compiler warnings about it being unused
  (void)startingPoint;
 
  ATH_MSG_DEBUG("In performTruthSubtraction");
 
  const double gaussianRadius = 0.032;
  const double gaussianRadiusError = 1.0e-3;
  const double maximumRadiusSigma = 3.0;
 
  eflowLayerIntegrator integrator(gaussianRadius, gaussianRadiusError, maximumRadiusSigma, m_isHLLHC);

  if (!m_recoverSplitShowers && 0 != nCaloObj) ATH_MSG_WARNING("Not in Split Showers Mode and already have " << nCaloObj << " eflowCaloObjects");
 
  //For each eflowCaloObject we calculate the expected energy deposit in the calorimeter and cell ordering for subtraction.
  for (unsigned int iCalo = nCaloObj; iCalo < data.caloObjects->size(); ++iCalo) {
    eflowCaloObject* thisEflowCaloObject = data.caloObjects->at(iCalo);
    thisEflowCaloObject->simulateShower(ctx, &integrator, m_binnedParameters.get(), m_useNNEnergy ? &(*m_NNEnergyPredictorTool) : nullptr, m_useLegacyEBinIndex);
    m_theTruthShowerSimulator->simulateShower(*thisEflowCaloObject);    
 
  }
 
  unsigned int nEFCaloObs = data.caloObjects->size();
 
  for (unsigned int iCalo = 0; iCalo < nEFCaloObs; ++iCalo) {
    eflowCaloObject* thisEflowCaloObject = data.caloObjects->at(iCalo);
    this->performSubtraction(*thisEflowCaloObject);
  }
 
}

performSubtraction() [2/2]

void PFUnifiedSubtractionOnlyTruthTool::performSubtraction ( eflowCaloObject & thisEflowCaloObject ) const

overrideprivatevirtual

Reimplemented from PFUnifiedSubtractionOnlyTool.

Definition at line 104 of file PFUnifiedSubtractionOnlyTruthTool.cxx.

                                                                                                    {
 
  for (unsigned iTrack = 0; iTrack < thisEflowCaloObject.nTracks(); ++iTrack){
    eflowRecTrack *thisEfRecTrack = thisEflowCaloObject.efRecTrack(iTrack);
 
    //although we are subtracting the truth, to be consistent we only do it if a reco
    //e/p lookup bin exists for this track
    if (!thisEfRecTrack->hasBin()) continue;
 
    //Similarly we skip tracks in a dense environment
    if (thisEfRecTrack->isInDenseEnvironment()) continue;
 
    thisEfRecTrack->setSubtracted();
 
    //get the set of matched clusters
    std::vector<eflowTrackClusterLink *> links = thisEfRecTrack->getClusterMatches();
 
    for (auto thisLink : links){
      xAOD::CaloCluster *thisCluster = thisLink->getCluster()->getCluster();
      CaloClusterCellLink* theCellLinks = thisCluster->getOwnCellLinks();
      CaloClusterCellLink::iterator theCell = theCellLinks->begin();
      CaloClusterCellLink::iterator lastCell = theCellLinks->end();
 
      //loop over the cells in this cluster and subtract shower using truth information
      //We can either remove a cell entireley if it has any truth deposit (closer to what the real 
      //reco algorithm does) or reweight the cells contribution based on subtracting the truth
      //energy from the reco cell energy
      //We only advance the iterator, theCell, if we *dont* call removeCell to avoid issues with
      //invalid iterators
      //We also have to reset the lastCell iterator after each call to ensure the loop exits at the end, 
      //instead of being stuck in an infinite loop.
      for (; theCell != lastCell;){
        //get the truth energy for this cell
        double truthEnergy = thisEfRecTrack->getCellTruthEnergy(*theCell);
        //reweight the cell such that energy*weight gives the new energy
        double oldCellEnergy = theCell->energy()*(theCell.weight());
        double subtractedCellWeight = (oldCellEnergy - truthEnergy)/oldCellEnergy;
 
        if (0.0 != truthEnergy && m_useFullCellTruthSubtraction) {
          thisCluster->removeCell(*theCell);
          lastCell = theCellLinks->end();
        }
        else if (!m_useFullCellTruthSubtraction) {
          theCell.reweight(subtractedCellWeight);
          ++theCell;
        }
        else ++theCell;
 
      }//cell loop
 
      float oldEnergy = thisCluster->e();
      CaloClusterKineHelper::calculateKine(thisCluster, true, true);
      if (0.0 != oldEnergy) {
        float energyAdjustment = thisCluster->e() / oldEnergy;
        thisCluster->setRawE(thisCluster->rawE() * energyAdjustment);
        thisCluster->setRawEta(thisCluster->eta());
        thisCluster->setRawPhi(thisCluster->phi());
      }
    }
 
  }//eflowCaloObject track loop
 
}

PFUnifiedSubtractionOnlyTool()

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

Definition at line 31 of file PFUnifiedSubtractionOnlyTool.cxx.

                                                                                                                                 : base_class(type, name, parent),
                                                                                                                   m_binnedParameters(std::make_unique<eflowEEtaBinnedParameters>())
{
}

processPFlowData()

StatusCode PFUnifiedSubtractionOnlyTruthTool::processPFlowData ( const EventContext & ctx, PFData & thePFData ) const

overridevirtual

Reimplemented from PFUnifiedSubtractionOnlyTool.

Definition at line 55 of file PFUnifiedSubtractionOnlyTruthTool.cxx.

{
  if (!data.caloObjects) {
    ATH_MSG_ERROR("PFData::caloObjects is null; caller must set it before invoking the truth subtraction tool");
    return StatusCode::FAILURE;
  }
 
  performSubtraction(ctx, data.nMatches, 0, data);
  return StatusCode::SUCCESS;
}

simulateShowers()

void PFUnifiedSubtractionOnlyTool::simulateShowers ( const EventContext & ctx, eflowCaloObjectContainer & eflowCaloObjects, const unsigned int & nCaloObj ) const

protectedinherited

Definition at line 93 of file PFUnifiedSubtractionOnlyTool.cxx.

                                                                                                                                                          {
 
  const double gaussianRadius = 0.032;
  const double gaussianRadiusError = 1.0e-3;
  const double maximumRadiusSigma = 3.0;
 
  eflowLayerIntegrator integrator(gaussianRadius, gaussianRadiusError, maximumRadiusSigma, m_isHLLHC);
 
  //For each eflowCaloObject we calculate the expected energy deposit in the calorimeter and cell ordering for subtraction.
  for (unsigned int iCalo = nCaloObj; iCalo < eflowCaloObjects.size(); ++iCalo) {
    eflowCaloObject* thisEflowCaloObject = eflowCaloObjects.at(iCalo);
    thisEflowCaloObject->simulateShower(ctx, &integrator, m_binnedParameters.get(), m_useNNEnergy ? &(*m_NNEnergyPredictorTool) : nullptr, m_useLegacyEBinIndex);
  }
}

Member Data Documentation

m_addCPData

Gaudi::Property<bool> PFUnifiedSubtractionOnlyTool::m_addCPData {this,"addCPData",false,"Toggle whether to decorate FlowElements with additional data for Combined Performance studies "}

protectedinherited

Toggle whether to decorate eflowRecTrack with additional data for Combined Performance studies.

Definition at line 79 of file PFUnifiedSubtractionOnlyTool.h.

{this,"addCPData",false,"Toggle whether to decorate FlowElements with additional data for Combined Performance studies "};

m_binnedParameters

std::unique_ptr<eflowEEtaBinnedParameters> PFUnifiedSubtractionOnlyTool::m_binnedParameters

protectedinherited

Definition at line 58 of file PFUnifiedSubtractionOnlyTool.h.

m_calcEOverP

Gaudi::Property<bool> PFUnifiedSubtractionOnlyTool::m_calcEOverP {this, "CalcEOverP", false, "Toggle EOverP algorithm mode, whereby no charged shower subtraction is performed"}

protectedinherited

Toggle EOverP algorithm mode, whereby no charged shower subtraction is performed.

Definition at line 67 of file PFUnifiedSubtractionOnlyTool.h.

{this, "CalcEOverP", false, "Toggle EOverP algorithm mode, whereby no charged shower subtraction is performed"};

m_consistencySigmaCut

Gaudi::Property<double> PFUnifiedSubtractionOnlyTool::m_consistencySigmaCut {this, "ConsistencySigmaCut", 1.0, "Parameter that controls whether a track, in a track-cluster system, will be processed by the split shower recovery algorithm"}

protectedinherited

Parameter that controls whether a track, in a track-cluster system, will be processed by the split shower recovery algorithm.

Definition at line 70 of file PFUnifiedSubtractionOnlyTool.h.

{this, "ConsistencySigmaCut", 1.0, "Parameter that controls whether a track, in a track-cluster system, will be processed by the split shower recovery algorithm"};

m_isHLLHC

Gaudi::Property<bool> PFUnifiedSubtractionOnlyTool::m_isHLLHC {this, "isHLLHC", false, "Toggle whether we have the HLLHC setup"}

protectedinherited

Toggle whether we have the HLLHC setup.

Definition at line 76 of file PFUnifiedSubtractionOnlyTool.h.

{this, "isHLLHC", false, "Toggle whether we have the HLLHC setup"};

m_NNEnergyPredictorTool

ToolHandle<PFEnergyPredictorTool> PFUnifiedSubtractionOnlyTool::m_NNEnergyPredictorTool {this, "NNEnergyPredictorTool", "","Tool for getting predictiing the energy using an ONNX model "}

protectedinherited

Tool for getting predictiing the energy using an ONNX model.

Definition at line 87 of file PFUnifiedSubtractionOnlyTool.h.

{this, "NNEnergyPredictorTool", "","Tool for getting predictiing the energy using an ONNX model "};

m_pfSubtractionEnergyRatioCalculator

PFSubtractionEnergyRatioCalculator PFUnifiedSubtractionOnlyTool::m_pfSubtractionEnergyRatioCalculator {}

protectedinherited

Definition at line 83 of file PFUnifiedSubtractionOnlyTool.h.

{};

m_pfSubtractionStatusSetter

PFSubtractionStatusSetter PFUnifiedSubtractionOnlyTool::m_pfSubtractionStatusSetter {}

protectedinherited

Definition at line 82 of file PFUnifiedSubtractionOnlyTool.h.

{};

m_recoverSplitShowers

Gaudi::Property<bool> PFUnifiedSubtractionOnlyTool::m_recoverSplitShowers {this,"RecoverSplitShowers",false,"Toggle whether we are recovering split showers or not"}

protectedinherited

Toggle whether we are recovering split showers or not.

Definition at line 64 of file PFUnifiedSubtractionOnlyTool.h.

{this,"RecoverSplitShowers",false,"Toggle whether we are recovering split showers or not"};

m_subtractionSigmaCut

Gaudi::Property<double> PFUnifiedSubtractionOnlyTool::m_subtractionSigmaCut {this, "SubtractionSigmaCut", 1.5, "Parameter that controls whether to use retain remaining calorimeter energy in track-cluster system, after charged shower subtraction"}

protectedinherited

Parameter that controls whether to use retain remaining calorimeter energy in track-cluster system, after charged shower subtraction.

Definition at line 73 of file PFUnifiedSubtractionOnlyTool.h.

{this, "SubtractionSigmaCut", 1.5, "Parameter that controls whether to use retain remaining calorimeter energy in track-cluster system, after charged shower subtraction"};

m_subtractor

eflowSubtract::Subtractor PFUnifiedSubtractionOnlyTool::m_subtractor {}

protectedinherited

Definition at line 84 of file PFUnifiedSubtractionOnlyTool.h.

{};

m_theEOverPTool

ToolHandle<IEFlowCellEOverPTool> PFUnifiedSubtractionOnlyTool::m_theEOverPTool {this, "eflowCellEOverPTool", "eflowCellEOverPTool", "Energy Flow E/P Values and Shower Parameters Tool"}

protectedinherited

Tool for getting e/p values and hadronic shower cell ordering principle parameters.

Definition at line 56 of file PFUnifiedSubtractionOnlyTool.h.

{this, "eflowCellEOverPTool", "eflowCellEOverPTool", "Energy Flow E/P Values and Shower Parameters Tool"};

m_theTruthShowerSimulator

ToolHandle<PFSimulateTruthShowerTool> PFUnifiedSubtractionOnlyTruthTool::m_theTruthShowerSimulator {this, "PFSimulateTruthShowerTool", "", "The truth shower simulator"}

private

Definition at line 32 of file PFUnifiedSubtractionOnlyTruthTool.h.

{this, "PFSimulateTruthShowerTool", "", "The truth shower simulator"};

m_trkpos

std::unique_ptr<PFMatch::TrackEtaPhiInFixedLayersProvider> PFUnifiedSubtractionOnlyTool::m_trkpos

protectedinherited

Track position provider to be used to preselect clusters.

Definition at line 61 of file PFUnifiedSubtractionOnlyTool.h.

m_useFullCellTruthSubtraction

Gaudi::Property<bool> PFUnifiedSubtractionOnlyTruthTool::m_useFullCellTruthSubtraction {this,"useFullCellTruthSubtraction",true,"Toggle whether we fully remove a cell with a truth deposit or reweight it based on truth contribution"}

private

Toggle whether we fully remove a cell with a truth deposit or reweight it based on truth contribution.

Definition at line 30 of file PFUnifiedSubtractionOnlyTruthTool.h.

{this,"useFullCellTruthSubtraction",true,"Toggle whether we fully remove a cell with a truth deposit or reweight it based on truth contribution"};

m_useLegacyEBinIndex

Gaudi::Property<bool> PFUnifiedSubtractionOnlyTool::m_useLegacyEBinIndex {this, "useLegacyEBinIndex", true, "Toggle whether we use the legacy energy bin index"}

protectedinherited

Further discussion about why this flag exists can be found in https://its.cern.ch/jira/browse/ATLJETMET-1692 and https://indico.cern.ch/event/1388633/contributions/5837876/attachments/2809591/4903439/PFlow_EOverP_Feb2024.pdf The Jira report discusses assorted problems with the treatment of energy bin indexes for the lookup of e/p values.

In order to not change the behaviour of produciton code a legacy option is introduced to allow us to fix the problem in future iterations of e/p derivations.s

Definition at line 97 of file PFUnifiedSubtractionOnlyTool.h.

{this, "useLegacyEBinIndex", true, "Toggle whether we use the legacy energy bin index"};

m_useNNEnergy

Gaudi::Property<bool> PFUnifiedSubtractionOnlyTool::m_useNNEnergy {this, "useNNEnergy", false, "Toggle whether we use the neural net energy"}

protectedinherited

Toggle whether we use the neural net energy.

Definition at line 90 of file PFUnifiedSubtractionOnlyTool.h.

{this, "useNNEnergy", false, "Toggle whether we use the neural net energy"};

---

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

• PFUnifiedSubtractionOnlyTruthTool.h
• PFUnifiedSubtractionOnlyTruthTool.cxx