PFUnifiedSubtractionOnlyTool Class Reference

#include <PFUnifiedSubtractionOnlyTool.h>

Inheritance diagram for PFUnifiedSubtractionOnlyTool:

Collaboration diagram for PFUnifiedSubtractionOnlyTool:

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

Protected Member Functions
unsigned int	matchAndCreateEflowCaloObj (PFData &data) const
	This matches ID tracks and CaloClusters, and then creates eflowCaloObjects.
virtual void	performSubtraction (const EventContext &ctx, const unsigned int &startingPoint, const unsigned int &nCaloObj, PFData &data) const
virtual void	performSubtraction (eflowCaloObject &thisEflowCaloObject) const
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.

Detailed Description

Definition at line 27 of file PFUnifiedSubtractionOnlyTool.h.

Constructor & Destructor Documentation

PFUnifiedSubtractionOnlyTool()

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

Definition at line 24 of file PFUnifiedSubtractionOnlyTool.cxx.

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

~PFUnifiedSubtractionOnlyTool()

PFUnifiedSubtractionOnlyTool::~PFUnifiedSubtractionOnlyTool ( )

default

Member Function Documentation

addSubtractedCells()

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

protected

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

protected

Definition at line 329 of file PFUnifiedSubtractionOnlyTool.cxx.

{
  return clusterEnergy - expectedEnergy < m_subtractionSigmaCut * sigma;
}

initialize()

StatusCode PFUnifiedSubtractionOnlyTool::initialize ( )

overridevirtual

Definition at line 32 of file PFUnifiedSubtractionOnlyTool.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());
 
 
  //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

protected

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

protected

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

performSubtraction() [1/2]

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

protectedvirtual

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

Definition at line 108 of file PFUnifiedSubtractionOnlyTool.cxx.

                                                                                                                                                                  {

  if (!m_recoverSplitShowers && 0 != nCaloObj) ATH_MSG_WARNING("Not in Split Showers Mode and already have " << nCaloObj << " eflowCaloObjects");
 
  simulateShowers(ctx, *(data.caloObjects), nCaloObj);
 
  unsigned int nEFCaloObs = data.caloObjects->size();
  for (unsigned int iCalo = startingPoint; iCalo < nEFCaloObs; ++iCalo) {
    eflowCaloObject* thisEflowCaloObject = data.caloObjects->at(iCalo);
    this->performSubtraction(*thisEflowCaloObject);
  }
}

performSubtraction() [2/2]

void PFUnifiedSubtractionOnlyTool::performSubtraction ( eflowCaloObject & thisEflowCaloObject ) const

protectedvirtual

Definition at line 122 of file PFUnifiedSubtractionOnlyTool.cxx.

                                                                                               {
 
  ATH_MSG_DEBUG("In performSubtraction");
 
  unsigned int nClusters = thisEflowCaloObject.nClusters();
  unsigned int nTrackMatches = thisEflowCaloObject.nTracks();
 
  ATH_MSG_DEBUG("Have got an eflowCaloObject with " << nClusters << " clusters and " << nTrackMatches << " track matches");
 
  if (msgLevel(MSG::DEBUG)){
    for (unsigned int iTrack = 0; iTrack < nTrackMatches; ++iTrack){
       eflowRecTrack* thisTrack = thisEflowCaloObject.efRecTrack(iTrack);
       ATH_MSG_DEBUG("eflowCaloObject has track with E, pt and eta " << thisTrack->getTrack()->e() << ", " << thisTrack->getTrack()->pt() << " and " << thisTrack->getTrack()->eta());
    }
  }
  
  //To keep historical behaviour when in recover split showers mode allow tracks with no cluster matches to proceed.
  if (!m_recoverSplitShowers && nClusters < 1) return;  
 
  //Need at least one track in this eflowCaloObject to continue.
  if (nTrackMatches < 1) return;
 
  double expectedEnergy = thisEflowCaloObject.getExpectedEnergy();
  double clusterEnergy = thisEflowCaloObject.getClusterEnergy();
  double expectedSigma = sqrt(thisEflowCaloObject.getExpectedVariance());
 
  /* Check e/p, if on first pass - return if e/p not consistent with expected e/p */
  if (!m_recoverSplitShowers){
    if (isEOverPFail(expectedEnergy, expectedSigma, clusterEnergy)) return;
  }
  
  const std::vector<std::pair<eflowTrackClusterLink *, std::pair<float, float>>> &matchedTrackList = thisEflowCaloObject.efRecLink();
 
  ATH_MSG_DEBUG("Matched Track List has size " << matchedTrackList.size());
 
  if (msgLevel(MSG::DEBUG))
  {
    for (unsigned int iTrack = 0; iTrack < nTrackMatches; ++iTrack)
    {
      const xAOD::TrackParticle *thisTrack = thisEflowCaloObject.efRecTrack(iTrack)->getTrack();      
      ATH_MSG_DEBUG("eflowCaloObject has track match with E, pt and eta " << thisTrack->e() << ", " << thisTrack->pt() << " and " << thisTrack->eta());
    }
  }
 
  ATH_MSG_DEBUG("About to perform subtraction for this eflowCaloObject");
 
  bool wasAnnihilated = false;
 
  //First deal with non-split showers mode
  if (!m_recoverSplitShowers){
    /* Check if we can annihilate right away - true if matched cluster has only the expected energy deposit */
    if (canAnnihilate(expectedEnergy, expectedSigma, clusterEnergy)){
 
      wasAnnihilated = true;
 
      std::vector<std::pair<xAOD::CaloCluster *, bool>> clusterList;
      std::map<xAOD::CaloCluster *, double> clusterEnergyMap;
      unsigned nCluster = thisEflowCaloObject.nClusters();
      for (unsigned iCluster = 0; iCluster < nCluster; ++iCluster){
        clusterList.emplace_back(thisEflowCaloObject.efRecCluster(iCluster)->getCluster(), false);
      }
 
      ATH_MSG_DEBUG("We are going to annihilate. ExpectedEnergy, expectedSigma and clusterEnergy are " << expectedEnergy << ", " << expectedSigma << " and " << clusterEnergy);
      if (msgLevel(MSG::DEBUG))
        for (auto thisPair : clusterList)
          ATH_MSG_DEBUG("Annihilating cluster with E and eta " << thisPair.first->e() << " and " << thisPair.first->eta());
 
      m_pfSubtractionStatusSetter.markAllTracksAnnihStatus(thisEflowCaloObject);
 
      //before we remove all the cells, we create a list of the removed cells if in doCPData mode
      if (m_addCPData) this->addSubtractedCells(thisEflowCaloObject, clusterList);
 
      Subtractor::annihilateClusters(clusterList);
 
      if (msgLevel(MSG::DEBUG))
        for (auto thisPair : clusterList)
          ATH_MSG_DEBUG("Have Annihilated cluster with E and eta " << thisPair.first->e() << " and " << thisPair.first->eta());
      
      /* Flag all tracks in this system as subtracted */
      for (unsigned iTrack = 0; iTrack < thisEflowCaloObject.nTracks(); ++iTrack){
        eflowRecTrack *thisEfRecTrack = (matchedTrackList[iTrack].first)->getTrack();
        if (!thisEfRecTrack->isSubtracted()) thisEfRecTrack->setSubtracted();
      }
 
    }//if can annihilate this track-cluster systems matched cluster
  }//split shower recovery mode or regular mode where above annihilation was not triggered
  if (m_recoverSplitShowers || !wasAnnihilated){
 
    for (unsigned iTrack = 0; iTrack < thisEflowCaloObject.nTracks(); ++iTrack){
 
      eflowRecTrack *thisEfRecTrack = thisEflowCaloObject.efRecTrack(iTrack);
 
      ATH_MSG_DEBUG("About to subtract track with e, pt, eta and phi of " << thisEfRecTrack->getTrack()->e() << ", " << thisEfRecTrack->getTrack()->pt() << ", " << thisEfRecTrack->getTrack()->eta() << " and "
                                                                       << thisEfRecTrack->getTrack()->eta());
      
      if (!thisEfRecTrack->hasBin()) continue;
 
      ATH_MSG_DEBUG("Have bin for this eflowCaloObject");
 
      if (thisEfRecTrack->isInDenseEnvironment() && !m_recoverSplitShowers) continue;
 
      ATH_MSG_DEBUG("Am not in dense environment for this eflowCaloObject");
 
      /* Get matched cluster via Links */
      std::vector<eflowRecCluster *> matchedClusters;
      const std::vector<eflowTrackClusterLink *>& links = thisEfRecTrack->getClusterMatches();
      matchedClusters.reserve(links.size());
      for (auto* thisEFlowTrackClusterLink : links)
        matchedClusters.push_back(thisEFlowTrackClusterLink->getCluster());
      if (m_recoverSplitShowers)
        std::sort(matchedClusters.begin(),
                  matchedClusters.end(),
                  eflowRecCluster::SortDescendingPt());
 
      if (msgLvl(MSG::DEBUG)) {
        for (auto* thisClus : matchedClusters)
          ATH_MSG_DEBUG(
            "Haved matched cluster "
            << thisClus->getCluster()->index() << " with e,pt, eta and phi of "
            << thisClus->getCluster()->e() << ", "
            << thisClus->getCluster()->pt() << ", "
            << thisClus->getCluster()->eta() << " and "
            << thisClus->getCluster()->phi() << " will be subtracted");
      }
 
      /* Do subtraction */
      std::vector<std::pair<xAOD::CaloCluster *, bool>> clusterSubtractionList;
      clusterSubtractionList.reserve(matchedClusters.size());
      std::map<xAOD::CaloCluster *, double> clusterEnergyMap;
      for (auto *thisEFlowRecCluster : matchedClusters){
        xAOD::CaloCluster *thisCluster = thisEFlowRecCluster->getCluster();
        clusterSubtractionList.emplace_back(thisCluster, false);
        clusterEnergyMap[thisCluster] = thisCluster->e();
      }
 
      ATH_MSG_DEBUG("Have filled clusterSubtractionList for this eflowCaloObject");
 
      unsigned int trackIndex = thisEfRecTrack->getTrack()->index();
 
      //Previously we only checked this in recover split showers, but makes sense to check it in both passes.
      auto sumClusEnergy = [](double accumulator, std::pair<xAOD::CaloCluster *, bool> thisPair){ return accumulator += thisPair.first->e();};
      double totalClusterEnergy = std::accumulate(clusterSubtractionList.begin(),clusterSubtractionList.end(),0.0,sumClusEnergy);      
 
      /* Check if we can annihilate right away - true if matched cluster has only the expected energy deposit */
      if(canAnnihilate(thisEfRecTrack->getEExpect(),sqrt(thisEfRecTrack->getVarEExpect()),totalClusterEnergy)){
        
        if (msgLevel(MSG::DEBUG))
          for (auto thisPair : clusterSubtractionList)
            ATH_MSG_DEBUG("Annihilating cluster with E and eta " << thisPair.first->e() << " and " << thisPair.first->eta());
 
        //before we remove all the cells, we create a list of the removed cells if in doCPData mode
        if (m_addCPData) this->addSubtractedCells(thisEflowCaloObject, clusterSubtractionList);
 
        Subtractor::annihilateClusters(clusterSubtractionList);
        //Now we should mark all of these clusters as being subtracted
        //Now need to mark which clusters were modified in the subtraction procedure
        std::vector<std::pair<float, float>> clusterSubtractedEnergyRatios;
        m_pfSubtractionEnergyRatioCalculator.calculateSubtractedEnergyRatiosForAnnih(clusterSubtractionList, clusterEnergyMap, clusterSubtractedEnergyRatios);
        m_pfSubtractionStatusSetter.markSubtractionStatus(clusterSubtractionList, clusterSubtractedEnergyRatios, thisEflowCaloObject, trackIndex);
      }
      else
      {
 
        /* Subtract the track from all matched clusters */
        m_subtractor.subtractTracksFromClusters(thisEfRecTrack, clusterSubtractionList, m_addCPData);
 
        //recalculate total cluster energy from the clusters afer subtraction
        totalClusterEnergy = std::accumulate(clusterSubtractionList.begin(),clusterSubtractionList.end(),0.0,sumClusEnergy);        
 
        /* Annihilate the cluster(s) if the remnant is small (i.e. below k*sigma) */
        if (canAnnihilate(0.0,sqrt(thisEfRecTrack->getVarEExpect()), totalClusterEnergy)){
 
          if (msgLevel(MSG::DEBUG))
          for (auto thisPair : clusterSubtractionList){
            ATH_MSG_DEBUG("Annihilating remnant cluster with E and eta " << thisPair.first->e() << " and " << thisPair.first->eta());
          }
          eflowSubtract::Subtractor::annihilateClusters(clusterSubtractionList);
          //Now we should mark all of these clusters as being subtracted
          std::vector<std::pair<float, float>> clusterSubtractedEnergyRatios;
          m_pfSubtractionEnergyRatioCalculator.calculateSubtractedEnergyRatiosForAnnih(clusterSubtractionList, clusterEnergyMap, clusterSubtractedEnergyRatios);
          m_pfSubtractionStatusSetter.markSubtractionStatus(clusterSubtractionList, clusterSubtractedEnergyRatios, thisEflowCaloObject, trackIndex);
        }//if remove the remnant after cell by cell subtraction
        else
        { 
          std::vector<std::pair<float, float>> clusterSubtractedEnergyRatios;
          m_pfSubtractionEnergyRatioCalculator.calculateSubtractedEnergyRatios(clusterSubtractionList, clusterEnergyMap, clusterSubtractedEnergyRatios);
          m_pfSubtractionStatusSetter.markSubtractionStatus(clusterSubtractionList, clusterSubtractedEnergyRatios, thisEflowCaloObject, trackIndex);
        }//if don't remove the remnant after cell by cell subtraction
 
      }//if not annihilating, and instead subtracting cell by cell
 
      ATH_MSG_DEBUG("Have subtracted charged shower for this eflowRecTrack");
 
      /* Flag tracks as subtracted */
      if (!thisEfRecTrack->isSubtracted()) thisEfRecTrack->setSubtracted();
 
    }//loop over tracks in eflowCaloObject
  }//cell by cell subtraction
 
}

processPFlowData()

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

overridevirtual

Definition at line 59 of file PFUnifiedSubtractionOnlyTool.cxx.

{
 
  if (!data.caloObjects) {
    ATH_MSG_ERROR("PFData::caloObjects is null; caller must set it before invoking the subtraction tool");
    return StatusCode::FAILURE;
  }
 
  unsigned int numMatches;
  unsigned int nCaloObj;
 
  if (m_recoverSplitShowers){
    numMatches = data.nOrigCaloObj;
    nCaloObj = data.nOrigCaloObj;
  }
  else{
    numMatches = data.nMatches;
    nCaloObj = 0;
  }
 
  if (!m_calcEOverP){
    if (!m_recoverSplitShowers) performSubtraction(ctx, 0, nCaloObj, data);
    else performSubtraction(ctx, numMatches, nCaloObj, data);
  }
  //in e/p mode we want to simulate showers for all eflowCaloObjects and then decorate the eflowTrack with the relevant e/p information, but not perform any subtraction.
  //in particular simulateShowers calculates the LHED which is used for the binning of e/p when we measure it.
  else simulateShowers(ctx, *(data.caloObjects), nCaloObj);
 
  return StatusCode::SUCCESS;
}

simulateShowers()

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

protected

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 "}

protected

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

protected

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"}

protected

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"}

protected

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"}

protected

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 "}

protected

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 {}

protected

Definition at line 83 of file PFUnifiedSubtractionOnlyTool.h.

{};

m_pfSubtractionStatusSetter

PFSubtractionStatusSetter PFUnifiedSubtractionOnlyTool::m_pfSubtractionStatusSetter {}

protected

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"}

protected

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"}

protected

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 {}

protected

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"}

protected

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_trkpos

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

protected

Track position provider to be used to preselect clusters.

Definition at line 61 of file PFUnifiedSubtractionOnlyTool.h.

m_useLegacyEBinIndex

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

protected

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"}

protected

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:

• PFUnifiedSubtractionOnlyTool.h
• PFUnifiedSubtractionOnlyTool.cxx