PFSubtractionTool Class Reference

#include <PFSubtractionTool.h>

Inheritance diagram for PFSubtractionTool:

Collaboration diagram for PFSubtractionTool:

Public Member Functions
	PFSubtractionTool (const std::string &type, const std::string &name, const IInterface *parent)
	~PFSubtractionTool ()
StatusCode	initialize ()
void	execute (eflowCaloObjectContainer *theEflowCaloObjectContainer, eflowRecTrackContainer *recTrackContainer, eflowRecClusterContainer *recClusterContainer) const
StatusCode	finalize ()

Private Member Functions
unsigned int	matchAndCreateEflowCaloObj (PFData &data) const
	This matches ID tracks and CaloClusters, and then creates eflowCaloObjects. More...
void	performSubtraction (const unsigned int &startingPoint, PFData &data) const
void	performSubtraction (eflowCaloObject &thisEflowCaloObject) const
void	performTruthSubtraction (PFData &data) const
void	performTruthSubtraction (eflowCaloObject &thisEflowCaloObject) const
bool	isEOverPFail (double expectedEnergy, double sigma, double clusterEnergy) const
bool	canAnnihilate (double expectedEnergy, double sigma, double clusterEnergy) const
void	printAllClusters (const eflowRecClusterContainer &recClusterContainer) const
void	addSubtractedCells (eflowCaloObject &thisEflowCaloObject, const std::vector< std::pair< xAOD::CaloCluster *, bool > > &clusterList) const

Static Private Member Functions
static std::string	printTrack (const xAOD::TrackParticle *track)
static std::string	printCluster (const xAOD::CaloCluster *cluster)

Private 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. More...
std::unique_ptr< eflowEEtaBinnedParameters >	m_binnedParameters
std::unique_ptr< PFMatch::TrackEtaPhiInFixedLayersProvider >	m_trkpos
	Track position provider to be used to preselect clusters. More...
ToolHandle< PFTrackClusterMatchingTool >	m_theMatchingTool {this, "PFTrackClusterMatchingTool", "PFTrackClusterMatchingTool/CalObjBldMatchingTool", "The track-cluster matching tool"}
	Default track-cluster matching tool. More...
ToolHandle< PFTrackClusterMatchingTool >	m_theMatchingToolForPull_015 {this, "PFTrackClusterMatchingTool_015", "PFTrackClusterMatchingTool/PFPullMatchingTool_015", "The 0.15 track-cluster matching tool to calculate the pull"}
ToolHandle< PFTrackClusterMatchingTool >	m_theMatchingToolForPull_02 {this, "PFTrackClusterMatchingTool_02", "PFTrackClusterMatchingTool/PFPullMatchingTool_02", "The 0.2 track-cluster matching tool to calculate the pull"}
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. More...
Gaudi::Property< int >	m_nClusterMatchesToUse {this, "nClusterMatchesToUse", 1, "Number of clusters to match to each track"}
	Number of clusters to match to each track if not doing recover split shower subtraction. More...
Gaudi::Property< bool >	m_isHLLHC {this, "isHLLHC", false, "Toggle whether we have the HLLHC setup"}
	Toggle whether we have the HLLHC setup. More...
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. More...
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. More...
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. More...
Gaudi::Property< bool >	m_addCPData {this,"addCPData",false,"Toggle whether to decorate FlowElements with addutional data for Combined Performance studies "}
	Toggle whether to decorate eflowRecTrack with addutional data for Combined Performance studies. More...
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. More...
Gaudi::Property< bool >	m_useNNEnergy {this, "useNNEnergy", false, "Toggle whether we use the neural net energy"}
	Toggle whether we use the neural net energy. More...
Gaudi::Property< bool >	m_useTruthMatching {this, "useTrackClusterTruthMatching", false, "Toggle whether to cheat and use truth information for track-cluster matching"}
	Toggle whether to cheat and use truth information for track-cluster matching - only for performance studies! More...
Gaudi::Property< bool >	m_useTruthForChargedShowerSubtraction {this, "useTruthForChargedShowerSubtraction", false, "Toggle whether we use truth information for the charged shower subtraction or not"}
	Toggle whether we use truth information for the charged shower subtraction or not. More...
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. More...
ToolHandle< PFSimulateTruthShowerTool >	m_theTruthShowerSimulator {this, "PFSimulateTruthShowerTool", "", "The truth shower simulator"}
SG::ReadDecorHandleKey< xAOD::CaloClusterContainer >	m_caloClusterReadDecorHandleKeyNLeadingTruthParticles {this,"CaloClusterReadDecorHandleKey_NLeadingTruthParticles",""}
	Read handle key to decorate CaloCluster with threeN leading truth particle uniqueID and energy. More...
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. More...

Detailed Description

Definition at line 31 of file PFSubtractionTool.h.

Constructor & Destructor Documentation

PFSubtractionTool()

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

Definition at line 23 of file PFSubtractionTool.cxx.

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

~PFSubtractionTool()

PFSubtractionTool::~PFSubtractionTool ( )

default

Member Function Documentation

addSubtractedCells()

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

private

Definition at line 604 of file PFSubtractionTool.cxx.

                                                                                                                                                     {
 
  unsigned int numTracks = thisEflowCaloObject.nTracks();
 
  for (unsigned int iTrack = 0; iTrack < numTracks; ++iTrack){
    eflowRecTrack* thisTrack = thisEflowCaloObject.efRecTrack(iTrack);
    for (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 PFSubtractionTool::canAnnihilate ( double  expectedEnergy, double  sigma, double  clusterEnergy  ) const

private

Definition at line 572 of file PFSubtractionTool.cxx.

{
  return clusterEnergy - expectedEnergy < m_subtractionSigmaCut * sigma;
}

execute()

void PFSubtractionTool::execute	(	eflowCaloObjectContainer *	theEflowCaloObjectContainer,
		eflowRecTrackContainer *	recTrackContainer,
		eflowRecClusterContainer *	recClusterContainer
	)		const

Definition at line 66 of file PFSubtractionTool.cxx.

{
 
  ATH_MSG_DEBUG("Executing");
 
  PFData data;
  data.caloObjects = theEflowCaloObjectContainer;
  const PFTrackFiller pfTrackFiller;
  if (!m_recoverSplitShowers) PFTrackFiller::fillTracksToConsider(data, *recTrackContainer);
  else PFTrackFiller::fillTracksToRecover(data);
 
  const PFClusterFiller pfClusterFiller;
  if (!m_recoverSplitShowers) PFClusterFiller::fillClustersToConsider(data, *recClusterContainer);
  else PFClusterFiller::fillClustersToRecover(data);
 
  ATH_MSG_DEBUG("This event has " << data.tracks.size() << " tracks " << data.clusters.size() << " clusters ");
 
  unsigned int numMatches = matchAndCreateEflowCaloObj(data);
 
  if (msgLvl(MSG::DEBUG)) printAllClusters(*recClusterContainer);
 
  if (!m_calcEOverP){
    if (!m_useTruthForChargedShowerSubtraction){
      if (!m_recoverSplitShowers) performSubtraction(0,data);
      else performSubtraction(numMatches,data);
    }
    else performTruthSubtraction(data);
  }
  //eoverp mode calculation has been moved to a dedicated PFBaseTool.
 
}

finalize()

StatusCode PFSubtractionTool::finalize

(

)

Definition at line 620 of file PFSubtractionTool.cxx.

{ return StatusCode::SUCCESS; }

initialize()

StatusCode PFSubtractionTool::initialize

(

)

Definition at line 31 of file PFSubtractionTool.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;
  }
 
  //Retrieve track-cluster matching tools
  ATH_CHECK(m_theMatchingTool.retrieve());
  ATH_CHECK(m_theMatchingToolForPull_015.retrieve());
  ATH_CHECK(m_theMatchingToolForPull_02.retrieve());
 
  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());
 
  if (!m_caloClusterReadDecorHandleKeyNLeadingTruthParticles.empty()){
    ATH_CHECK(m_caloClusterReadDecorHandleKeyNLeadingTruthParticles.initialize());
  }
 
  if (m_useTruthForChargedShowerSubtraction && !m_theTruthShowerSimulator.empty()) ATH_CHECK(m_theTruthShowerSimulator.retrieve());
 
  return StatusCode::SUCCESS;
}

isEOverPFail()

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

private

Definition at line 566 of file PFSubtractionTool.cxx.

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

matchAndCreateEflowCaloObj()

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

private

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

No point to do anything if e/p reference bin does not exist

Add cluster matches needed for pull calculation (in eflowCaloObject::simulateShowers) which is used to determine whether to run the charged shower subtraction or not. / Clusters in both a cone of 0.15 and 0.2 are needed for this. / The clusters in a cone of 0.2 are also used as the matched cluster list for recover split showers mode.

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

Definition at line 98 of file PFSubtractionTool.cxx.

                                                                            {
 
  //Counts up how many tracks found at least 1 calorimeter cluster matched to it.
  unsigned int nMatches(0);
 
  /* Cache the original number of eflowCaloObjects, if there were any */
  const unsigned int nCaloObj = data.caloObjects->size();
  const EventContext &ctx = Gaudi::Hive::currentContext();
 
  /* loop tracks in data.tracks and do matching */
  for (auto *thisEfRecTrack : data.tracks)
  {
    if (!thisEfRecTrack->hasBin()) {
      std::unique_ptr<eflowCaloObject> thisEflowCaloObject = std::make_unique<eflowCaloObject>();
      thisEflowCaloObject->addTrack(thisEfRecTrack);
      data.caloObjects->push_back(std::move(thisEflowCaloObject));
      continue;
    }
 
    if (msgLvl(MSG::DEBUG))
    {
      const xAOD::TrackParticle *track = thisEfRecTrack->getTrack();
      ATH_MSG_DEBUG("Matching track with e,pt, eta and phi " << track->e() << ", " << track->pt() << ", " << track->eta() << " and " << track->phi());
    }
 
    std::vector<eflowTrackClusterLink*> bestClusters;
    std::vector<float> deltaRPrime;
 
    if (m_useTruthMatching){
 
      const xAOD::TruthParticle* trackMatchedTruthParticle = nullptr;
      typedef ElementLink<xAOD::TruthParticleContainer> TruthLink;
 
      const static SG::AuxElement::Accessor<TruthLink> truthLinkAccessor("truthParticleLink");
      
      TruthLink truthLink = truthLinkAccessor(*(thisEfRecTrack->getTrack()));
      //if not valid don't print a WARNING because this is an expected condition as discussed here:
      //https://indico.cern.ch/event/795039/contributions/3391771/attachments/1857138/3050771/TruthTrackFTAGWS.pdf
      if (truthLink.isValid()) trackMatchedTruthParticle = *truthLink;
 
      if (trackMatchedTruthParticle){
        double uniqueID = HepMC::uniqueID(trackMatchedTruthParticle);
 
        SG::ReadDecorHandle<xAOD::CaloClusterContainer, std::vector< std::pair<unsigned int, double> > > caloClusterReadDecorHandleNLeadingTruthParticles(m_caloClusterReadDecorHandleKeyNLeadingTruthParticles);
        if (!caloClusterReadDecorHandleNLeadingTruthParticles.isValid()){
          ATH_MSG_WARNING("Failed to retrieve CaloCluster decoration with key " << caloClusterReadDecorHandleNLeadingTruthParticles.key());
        }
 
        for (auto * thisCluster : data.clusters){
          //accessor for decoration
          //split key into substring to get the name of the decoration
 
          std::string decorHandleName = m_caloClusterReadDecorHandleKeyNLeadingTruthParticles.key();
          std::string::size_type pos = decorHandleName.find(".");
          std::string decorName = decorHandleName.substr(pos+1);
 
          SG::AuxElement::Accessor< std::vector< std::pair<unsigned int, double> > > accessor(decorName);
 
          std::vector<std::pair<unsigned int, double > > uniqueIDTruthPairs = accessor(*(thisCluster->getCluster()));
 
          for (auto &uniqueIDTruthPair : uniqueIDTruthPairs){
            if (uniqueIDTruthPair.first == uniqueID){
              eflowTrackClusterLink* thisLink = eflowTrackClusterLink::getInstance(thisEfRecTrack, thisCluster, ctx);
              bestClusters.push_back(thisLink);
              break;
            }
          }//loop over calocluster truth pair decorations
        }//loop over caloclusters
        
      }//if have truth particle matched to track
      else ATH_MSG_VERBOSE("Track with pt, eta and phi " << thisEfRecTrack->getTrack()->pt() << ", " << thisEfRecTrack->getTrack()->eta() << " and " << thisEfRecTrack->getTrack()->phi() << " does not have a valid truth pointer");
    }
    else if (!m_recoverSplitShowers){
      std::vector<std::pair<eflowRecCluster *, float>> bestClusters_02 = m_theMatchingToolForPull_02->doMatches(thisEfRecTrack, data.clusters, -1);
      for (auto &matchpair : bestClusters_02)
      {
        eflowRecCluster *theCluster = matchpair.first;
        float distancesq = matchpair.second;
        eflowTrackClusterLink *trackClusterLink = eflowTrackClusterLink::getInstance(thisEfRecTrack, theCluster, ctx);
        if (distancesq < 0.15 * 0.15)
        {
          // Narrower cone is a subset of the selected clusters
          // Distance returned is deltaR^2
          thisEfRecTrack->addAlternativeClusterMatch(trackClusterLink, "cone_015");
        }
        thisEfRecTrack->addAlternativeClusterMatch(trackClusterLink, "cone_02");
      }//loop over bestClusters_02
 
      //This matching scheme is used to match the calorimeter cluster(s) to be used in the charged showers subtraction for this track.
      std::vector<std::pair<eflowRecCluster *, float>> matchedClusters = m_theMatchingTool->doMatches(thisEfRecTrack, data.clusters,m_nClusterMatchesToUse);    
      for (auto thePair : matchedClusters) {
        bestClusters.push_back(eflowTrackClusterLink::getInstance(thisEfRecTrack, thePair.first, ctx));     
        if (m_addCPData) deltaRPrime.push_back(std::sqrt(thePair.second));
      }
    }
    else {
      const std::vector<eflowTrackClusterLink*>* matchedClusters_02 = thisEfRecTrack->getAlternativeClusterMatches("cone_02");
      if (!matchedClusters_02) continue;
      else bestClusters = *matchedClusters_02;
    }
 
    if (bestClusters.empty()) continue;
 
    if (msgLvl(MSG::DEBUG))
    {
      for (auto *thisClusterLink : bestClusters ) {
        xAOD::CaloCluster* thisCluster = thisClusterLink->getCluster()->getCluster();
        ATH_MSG_DEBUG("Matched this track to cluster with e,pt, eta and phi " << thisCluster->e() << ", " << thisCluster->pt() << ", " << thisCluster->eta() << " and " << thisCluster->phi());
      }
    }
 
    nMatches++;
 
    //loop over the matched calorimeter clusters and associate tracks and clusters to each other as needed.
    unsigned int linkIndex = 0;
    for (auto *trkClusLink : bestClusters){
 
      eflowRecCluster *thisEFRecCluster = trkClusLink->getCluster();
 
      if (m_recoverSplitShowers){
        // Look up whether this cluster is intended for recovery
        if (std::find(data.clusters.begin(), data.clusters.end(), trkClusLink->getCluster()) == data.clusters.end()) {
          linkIndex++;
          continue;       
        }
      }
 
      eflowTrackClusterLink *trackClusterLink = eflowTrackClusterLink::getInstance(thisEfRecTrack, thisEFRecCluster, ctx);
      thisEfRecTrack->addClusterMatch(trackClusterLink);
      if (m_addCPData && !m_useTruthMatching) {
        thisEfRecTrack->addDeltaRPrime(deltaRPrime[linkIndex]);
      }
      thisEFRecCluster->addTrackMatch(trackClusterLink);
    }
     linkIndex++;
  }
 
  /* Create 3 types eflowCaloObjects: track-only, cluster-only, track-cluster-link */
  std::vector<eflowRecCluster *> clusters(data.clusters.begin(), data.clusters.end());
  if (m_recoverSplitShowers) std::sort(clusters.begin(), clusters.end(), eflowRecCluster::SortDescendingPt());
  unsigned int nCaloObjects = eflowCaloObjectMaker::makeTrkCluCaloObjects(data.tracks, clusters, data.caloObjects);
  ATH_MSG_DEBUG("Created  " << nCaloObjects << " eflowCaloObjects.");
  if (msgLvl(MSG::DEBUG)){
    for (auto thisEFlowCaloObject : *(data.caloObjects)){
      ATH_MSG_DEBUG("This eflowCaloObject has " << thisEFlowCaloObject->nTracks() << " tracks and " << thisEFlowCaloObject->nClusters() << " clusters ");
      for (unsigned int count = 0; count < thisEFlowCaloObject->nTracks(); count++){
        const xAOD::TrackParticle* thisTrack = thisEFlowCaloObject->efRecTrack(count)->getTrack();
        ATH_MSG_DEBUG("Have track with e, pt, eta and phi of " << thisTrack->e() << ", " << thisTrack->pt() << ", " << thisTrack->eta() << " and " << thisTrack->phi());
      }
      for (unsigned int count = 0; count < thisEFlowCaloObject->nClusters(); count++){
        const xAOD::CaloCluster* thisCluster = thisEFlowCaloObject->efRecCluster(count)->getCluster();
        ATH_MSG_DEBUG("Have cluster with e, pt, eta and phi of " << thisCluster->e() << ", " << thisCluster->pt() << ", " << thisCluster->eta() << " and " << thisCluster->phi());
      }
    }
  }
 
  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(&integrator, m_binnedParameters.get(), m_useNNEnergy ? &(*m_NNEnergyPredictorTool) : nullptr, m_useLegacyEBinIndex);
    if (m_useTruthForChargedShowerSubtraction) m_theTruthShowerSimulator->simulateShower(*thisEflowCaloObject);    
 
  }
 
  if (!m_recoverSplitShowers) return nMatches;
  else return nCaloObj;
}

performSubtraction() [1/2]

void PFSubtractionTool::performSubtraction ( const unsigned int &  startingPoint, PFData &  data  ) const

private

Definition at line 280 of file PFSubtractionTool.cxx.

                                                                                              {
  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 PFSubtractionTool::performSubtraction ( eflowCaloObject &  thisEflowCaloObject ) const

private

Definition at line 288 of file PFSubtractionTool.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;
      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
 
}

performTruthSubtraction() [1/2]

void PFSubtractionTool::performTruthSubtraction ( eflowCaloObject &  thisEflowCaloObject ) const

private

Definition at line 502 of file PFSubtractionTool.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
 
}

performTruthSubtraction() [2/2]

void PFSubtractionTool::performTruthSubtraction ( PFData &  data ) const

private

Definition at line 489 of file PFSubtractionTool.cxx.

                                                                 {
 
  ATH_MSG_DEBUG("In performTruthSubtraction");
 
  unsigned int nEFCaloObs = data.caloObjects->size();
 
  for (unsigned int iCalo = 0; iCalo < nEFCaloObs; ++iCalo) {
    eflowCaloObject* thisEflowCaloObject = data.caloObjects->at(iCalo);
    this->performTruthSubtraction(*thisEflowCaloObject);
  }
 
}

printAllClusters()

void PFSubtractionTool::printAllClusters ( const eflowRecClusterContainer &  recClusterContainer ) const

private

Definition at line 589 of file PFSubtractionTool.cxx.

                                                                                                  {
 
  for ( const auto *thisEFRecCluster : recClusterContainer){
    if (thisEFRecCluster->getTrackMatches().empty()) {
      ATH_MSG_DEBUG("Isolated" << printCluster(thisEFRecCluster->getCluster()));
    } else {
      ATH_MSG_DEBUG("Matched" << printCluster(thisEFRecCluster->getCluster()));
      std::vector<eflowTrackClusterLink*> theTrackLinks = thisEFRecCluster->getTrackMatches();
      for ( auto *thisTrack : theTrackLinks){
       ATH_MSG_DEBUG("Matched" << printTrack(thisTrack->getTrack()->getTrack()));
      }
    }
  }
}

printCluster()

std::string PFSubtractionTool::printCluster ( const xAOD::CaloCluster *  cluster )

staticprivate

Definition at line 583 of file PFSubtractionTool.cxx.

                                                                        {
  std::stringstream result;
  result << " cluster with E, eta and phi of " << cluster->e() << ", " << cluster->eta() << " and " << cluster->phi();
  return result.str();
}

printTrack()

std::string PFSubtractionTool::printTrack ( const xAOD::TrackParticle *  track )

staticprivate

Definition at line 577 of file PFSubtractionTool.cxx.

                                                                      {
  std::stringstream result;
  result << " track with E, eta and phi "<< track->e() << ", " << track->eta() << " and " << track->phi();
  return result.str();
}

Member Data Documentation

m_addCPData

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

private

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

Definition at line 96 of file PFSubtractionTool.h.

m_binnedParameters

std::unique_ptr<eflowEEtaBinnedParameters> PFSubtractionTool::m_binnedParameters

private

Definition at line 65 of file PFSubtractionTool.h.

m_calcEOverP

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

private

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

Definition at line 87 of file PFSubtractionTool.h.

m_caloClusterReadDecorHandleKeyNLeadingTruthParticles

SG::ReadDecorHandleKey<xAOD::CaloClusterContainer> PFSubtractionTool::m_caloClusterReadDecorHandleKeyNLeadingTruthParticles {this,"CaloClusterReadDecorHandleKey_NLeadingTruthParticles",""}

private

Read handle key to decorate CaloCluster with threeN leading truth particle uniqueID and energy.

Definition at line 122 of file PFSubtractionTool.h.

m_consistencySigmaCut

Gaudi::Property<double> PFSubtractionTool::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"}

private

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

Definition at line 90 of file PFSubtractionTool.h.

m_isHLLHC

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

private

Toggle whether we have the HLLHC setup.

Definition at line 84 of file PFSubtractionTool.h.

m_nClusterMatchesToUse

Gaudi::Property<int> PFSubtractionTool::m_nClusterMatchesToUse {this, "nClusterMatchesToUse", 1, "Number of clusters to match to each track"}

private

Number of clusters to match to each track if not doing recover split shower subtraction.

Definition at line 81 of file PFSubtractionTool.h.

m_NNEnergyPredictorTool

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

private

Tool for getting predictiing the energy using an ONNX model.

Definition at line 104 of file PFSubtractionTool.h.

m_pfSubtractionEnergyRatioCalculator

PFSubtractionEnergyRatioCalculator PFSubtractionTool::m_pfSubtractionEnergyRatioCalculator {}

private

Definition at line 100 of file PFSubtractionTool.h.

m_pfSubtractionStatusSetter

PFSubtractionStatusSetter PFSubtractionTool::m_pfSubtractionStatusSetter {}

private

Definition at line 99 of file PFSubtractionTool.h.

m_recoverSplitShowers

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

private

Toggle whether we are recovering split showers or not.

Definition at line 78 of file PFSubtractionTool.h.

m_subtractionSigmaCut

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

private

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

Definition at line 93 of file PFSubtractionTool.h.

m_subtractor

eflowSubtract::Subtractor PFSubtractionTool::m_subtractor {}

private

Definition at line 101 of file PFSubtractionTool.h.

m_theEOverPTool

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

private

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

Definition at line 63 of file PFSubtractionTool.h.

m_theMatchingTool

ToolHandle<PFTrackClusterMatchingTool> PFSubtractionTool::m_theMatchingTool {this, "PFTrackClusterMatchingTool", "PFTrackClusterMatchingTool/CalObjBldMatchingTool", "The track-cluster matching tool"}

private

Default track-cluster matching tool.

Definition at line 71 of file PFSubtractionTool.h.

m_theMatchingToolForPull_015

ToolHandle<PFTrackClusterMatchingTool> PFSubtractionTool::m_theMatchingToolForPull_015 {this, "PFTrackClusterMatchingTool_015", "PFTrackClusterMatchingTool/PFPullMatchingTool_015", "The 0.15 track-cluster matching tool to calculate the pull"}

private

Definition at line 74 of file PFSubtractionTool.h.

m_theMatchingToolForPull_02

ToolHandle<PFTrackClusterMatchingTool> PFSubtractionTool::m_theMatchingToolForPull_02 {this, "PFTrackClusterMatchingTool_02", "PFTrackClusterMatchingTool/PFPullMatchingTool_02", "The 0.2 track-cluster matching tool to calculate the pull"}

private

Definition at line 75 of file PFSubtractionTool.h.

m_theTruthShowerSimulator

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

private

Definition at line 119 of file PFSubtractionTool.h.

m_trkpos

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

private

Track position provider to be used to preselect clusters.

Definition at line 68 of file PFSubtractionTool.h.

m_useFullCellTruthSubtraction

Gaudi::Property<bool> PFSubtractionTool::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 117 of file PFSubtractionTool.h.

m_useLegacyEBinIndex

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

private

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 129 of file PFSubtractionTool.h.

m_useNNEnergy

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

private

Toggle whether we use the neural net energy.

Definition at line 107 of file PFSubtractionTool.h.

m_useTruthForChargedShowerSubtraction

Gaudi::Property<bool> PFSubtractionTool::m_useTruthForChargedShowerSubtraction {this, "useTruthForChargedShowerSubtraction", false, "Toggle whether we use truth information for the charged shower subtraction or not"}

private

Toggle whether we use truth information for the charged shower subtraction or not.

Definition at line 114 of file PFSubtractionTool.h.

m_useTruthMatching

Gaudi::Property<bool> PFSubtractionTool::m_useTruthMatching {this, "useTrackClusterTruthMatching", false, "Toggle whether to cheat and use truth information for track-cluster matching"}

private

Toggle whether to cheat and use truth information for track-cluster matching - only for performance studies!

Definition at line 111 of file PFSubtractionTool.h.

---

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

• PFSubtractionTool.h
• PFSubtractionTool.cxx