PFUnifiedMatchingTool Class Reference

#include <PFUnifiedMatchingTool.h>

Inheritance diagram for PFUnifiedMatchingTool:

Collaboration diagram for PFUnifiedMatchingTool:

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

Protected Member Functions
virtual unsigned int	matchAndCreateEflowCaloObj (const EventContext &ctx, PFData &data) const
	This matches ID tracks and CaloClusters, and then creates eflowCaloObjects.
void	printAllClusters (const std::vector< eflowRecCluster * > &recClusterVector) const

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

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.
ToolHandle< PFTrackClusterMatchingTool >	m_theMatchingTool {this, "PFTrackClusterMatchingTool", "PFTrackClusterMatchingTool/CalObjBldMatchingTool", "The track-cluster matching tool"}
	Default track-cluster matching tool.
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.
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.
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.
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 25 of file PFUnifiedMatchingTool.h.

Constructor & Destructor Documentation

PFUnifiedMatchingTool()

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

Definition at line 28 of file PFUnifiedMatchingTool.cxx.

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

~PFUnifiedMatchingTool()

PFUnifiedMatchingTool::~PFUnifiedMatchingTool ( )

default

Member Function Documentation

initialize()

StatusCode PFUnifiedMatchingTool::initialize ( )

overridevirtual

Reimplemented in PFUnifiedMatchingTruthTool.

Definition at line 36 of file PFUnifiedMatchingTool.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());
 
  return StatusCode::SUCCESS;
 
}

matchAndCreateEflowCaloObj()

unsigned int PFUnifiedMatchingTool::matchAndCreateEflowCaloObj ( const EventContext & ctx, PFData & data ) const

protectedvirtual

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.

Reimplemented in PFUnifiedMatchingTruthTool.

Definition at line 98 of file PFUnifiedMatchingTool.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();
 
  /* 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_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
          static const std::string cone15Str{"cone_015"};
          thisEfRecTrack->addAlternativeClusterMatch(trackClusterLink, cone15Str);
        }
        static const std::string cone2Str{"cone_02"};
        thisEfRecTrack->addAlternativeClusterMatch(trackClusterLink, cone2Str);
      }//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) {
        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());
      }
    }
  }
 
  if (!m_recoverSplitShowers) return nMatches;
  else return nCaloObj;
}

printAllClusters()

void PFUnifiedMatchingTool::printAllClusters ( const std::vector< eflowRecCluster * > & recClusterVector ) const

protected

Definition at line 233 of file PFUnifiedMatchingTool.cxx.

                                                                                                       {
 
  for ( const auto *thisEFRecCluster : recClusterVector){
    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 PFUnifiedMatchingTool::printCluster ( const xAOD::CaloCluster * cluster )

staticprotected

Definition at line 227 of file PFUnifiedMatchingTool.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 PFUnifiedMatchingTool::printTrack ( const xAOD::TrackParticle * track )

staticprotected

Definition at line 221 of file PFUnifiedMatchingTool.cxx.

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

processPFlowData()

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

overridevirtual

Definition at line 59 of file PFUnifiedMatchingTool.cxx.

{
 
  if (!data.caloObjects) {
    ATH_MSG_ERROR("PFData::caloObjects is null; caller must set it before invoking the matching tool");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Executing");
 
  if (m_recoverSplitShowers){
    // reset tracks in data and refill only with those needed for split showers
    data.tracks.clear();
    PFTrackFiller::fillTracksToRecover(data);
  }
 
  if (m_recoverSplitShowers){
    // reset clusters in data and refill only with those needed for split showers
    data.clusters.clear();
    PFClusterFiller::fillClustersToRecover(data);
  }
 
  ATH_MSG_DEBUG("This event has " << data.tracks.size() << " tracks " << data.clusters.size() << " clusters ");
 
  if (msgLvl(MSG::DEBUG)) printAllClusters(data.clusters);
 
  unsigned int numMatches = matchAndCreateEflowCaloObj(ctx, data);
 
  // store numMatches for later use in subtraction tool
  if (m_recoverSplitShowers) data.nOrigCaloObj = numMatches;
  else data.nMatches = numMatches;
 
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_addCPData

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

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

m_binnedParameters

std::unique_ptr<eflowEEtaBinnedParameters> PFUnifiedMatchingTool::m_binnedParameters

protected

Definition at line 50 of file PFUnifiedMatchingTool.h.

m_nClusterMatchesToUse

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

protected

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

Definition at line 66 of file PFUnifiedMatchingTool.h.

{this, "nClusterMatchesToUse", 1, "Number of clusters to match to each track"};

m_NNEnergyPredictorTool

ToolHandle<PFEnergyPredictorTool> PFUnifiedMatchingTool::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 75 of file PFUnifiedMatchingTool.h.

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

m_recoverSplitShowers

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

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

m_subtractor

eflowSubtract::Subtractor PFUnifiedMatchingTool::m_subtractor {}

protected

Definition at line 72 of file PFUnifiedMatchingTool.h.

{};

m_theEOverPTool

ToolHandle<IEFlowCellEOverPTool> PFUnifiedMatchingTool::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 48 of file PFUnifiedMatchingTool.h.

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

m_theMatchingTool

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

protected

Default track-cluster matching tool.

Definition at line 56 of file PFUnifiedMatchingTool.h.

{this, "PFTrackClusterMatchingTool", "PFTrackClusterMatchingTool/CalObjBldMatchingTool", "The track-cluster matching tool"};

m_theMatchingToolForPull_015

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

protected

Definition at line 59 of file PFUnifiedMatchingTool.h.

{this, "PFTrackClusterMatchingTool_015", "PFTrackClusterMatchingTool/PFPullMatchingTool_015", "The 0.15 track-cluster matching tool to calculate the pull"};

m_theMatchingToolForPull_02

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

protected

Definition at line 60 of file PFUnifiedMatchingTool.h.

{this, "PFTrackClusterMatchingTool_02", "PFTrackClusterMatchingTool/PFPullMatchingTool_02", "The 0.2 track-cluster matching tool to calculate the pull"};

m_trkpos

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

protected

Track position provider to be used to preselect clusters.

Definition at line 53 of file PFUnifiedMatchingTool.h.

m_useLegacyEBinIndex

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

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

m_useNNEnergy

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

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

---

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

• PFUnifiedMatchingTool.h
• PFUnifiedMatchingTool.cxx