ATLAS Offline Software
Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Types | Private Attributes | List of all members
DerivationFramework::PseudoTrackSelector Class Reference

Class-algorithm for pseudo track selection. More...

#include <PseudoTrackSelector.h>

Inheritance diagram for DerivationFramework::PseudoTrackSelector:
Collaboration diagram for DerivationFramework::PseudoTrackSelector:

Public Member Functions

virtual StatusCode initialize () override final
 
virtual StatusCode addBranches (const EventContext &ctx) const override final
 

Protected Member Functions

void fillRecoReplacedWithPseudo (const xAOD::TrackParticleContainer *recoTrackParticleCol, const xAOD::TrackParticleContainer *pseudoTrackParticleCol, xAOD::TrackParticleContainer *outputCol, bool onlyFromB=false, bool onlyNotFromB=false) const
 Output track collection. More...
 
void fillRecoPlusPseudo (const xAOD::TrackParticleContainer *recoTrackParticleCol, const xAOD::TrackParticleContainer *pseudoTrackParticleCol, xAOD::TrackParticleContainer *outputCol, bool onlyFromB=false, bool onlyNotFromB=false) const
 
void fillRecoNoFakes (const xAOD::TrackParticleContainer *recoTrackParticleCol, xAOD::TrackParticleContainer *outputCol, bool onlyFromB=false, bool onlyNotFromB=false) const
 

Static Protected Member Functions

static const xAOD::TruthParticle * getTruth (const xAOD::TrackParticle *track)
 

Protected Attributes

SG::ReadHandleKey< xAOD::TrackParticleContainer > m_in_recoTrackParticleLocation {this, "RecoTrackParticleLocation", ""}
 Protected data:
More...
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_in_pseudoTrackParticleLocation {this, "PseudoTrackParticleLocation", ""}
 Reco track collection. More...
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoReplacedWithPseudo {this, "OutputRecoReplacedWithPseudo", ""}
 Pseudo track collection. More...
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoReplacedWithPseudoFromB {this, "OutputRecoReplacedWithPseudoFromB", ""}
 Output track collection. More...
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoReplacedWithPseudoNotFromB {this, "OutputRecoReplacedWithPseudoNotFromB", ""}
 Output track collection. More...
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoPlusPseudo {this, "OutputRecoPlusPseudo", ""}
 Output track collection. More...
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoPlusPseudoFromB {this, "OutputRecoPlusPseudoFromB", ""}
 Output track collection. More...
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoPlusPseudoNotFromB {this, "OutputRecoPlusPseudoNotFromB", ""}
 Output track collection. More...
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoNoFakes {this, "OutputRecoNoFakes", ""}
 Output track collection. More...
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoNoFakesFromB {this, "OutputRecoNoFakesFromB", ""}
 Output track collection. More...
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoNoFakesNotFromB {this, "OutputRecoNoFakesNotFromB", ""}
 Output track collection. More...
 

Private Types

typedef ElementLink< xAOD::TruthParticleContainer > TruthLink
 

Private Attributes

ToolHandle< InDet::IInDetTrackTruthOriginTool > m_trackOriginTool {this, "trackTruthOriginTool", "InDet::InDetTrackTruthOriginTool", "truth track origin tool"}
 

Detailed Description

Class-algorithm for pseudo track selection.

Definition at line 31 of file PseudoTrackSelector.h.

Member Typedef Documentation

◆ TruthLink

typedef ElementLink<xAOD::TruthParticleContainer> DerivationFramework::PseudoTrackSelector::TruthLink
private

Definition at line 83 of file PseudoTrackSelector.h.

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::PseudoTrackSelector::addBranches ( const EventContext &  ctx) const
finaloverridevirtual

Definition at line 51 of file PseudoTrackSelector.cxx.

52  {
53  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudo = std::make_unique<xAOD::TrackParticleContainer>();
54  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
55  outputRecoReplacedWithPseudo->setStore(outputRecoReplacedWithPseudoAux.get());
56  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudoFromB = std::make_unique<xAOD::TrackParticleContainer>();
57  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
58  outputRecoReplacedWithPseudoFromB->setStore(outputRecoReplacedWithPseudoFromBAux.get());
59  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudoNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
60  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
61  outputRecoReplacedWithPseudoNotFromB->setStore(outputRecoReplacedWithPseudoNotFromBAux.get());
62  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudo = std::make_unique<xAOD::TrackParticleContainer>();
63  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
64  outputRecoPlusPseudo->setStore(outputRecoPlusPseudoAux.get());
65  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudoFromB = std::make_unique<xAOD::TrackParticleContainer>();
66  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
67  outputRecoPlusPseudoFromB->setStore(outputRecoPlusPseudoFromBAux.get());
68  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudoNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
69  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
70  outputRecoPlusPseudoNotFromB->setStore(outputRecoPlusPseudoNotFromBAux.get());
71  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakes = std::make_unique<xAOD::TrackParticleContainer>();
72  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
73  outputRecoNoFakes->setStore(outputRecoNoFakesAux.get());
74  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakesFromB = std::make_unique<xAOD::TrackParticleContainer>();
75  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
76  outputRecoNoFakesFromB->setStore(outputRecoNoFakesFromBAux.get());
77  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakesNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
78  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
79  outputRecoNoFakesNotFromB->setStore(outputRecoNoFakesNotFromBAux.get());
80 
81  // retrieve reco and pseudo tracks
82  SG::ReadHandle<xAOD::TrackParticleContainer> recoTrackParticleCol (m_in_recoTrackParticleLocation, ctx);
83  SG::ReadHandle<xAOD::TrackParticleContainer> pseudoTrackParticleCol (m_in_pseudoTrackParticleLocation, ctx);
84 
85  // fail if containers not available
86  if (!recoTrackParticleCol.isValid()){
87  ATH_MSG_ERROR( m_in_recoTrackParticleLocation.key() << " not valid!" );
88  return StatusCode::FAILURE;
89  }
90  if (!pseudoTrackParticleCol.isValid()){
91  ATH_MSG_ERROR( m_in_pseudoTrackParticleLocation.key() << " not valid!" );
92  return StatusCode::FAILURE;
93  }
94 
95  // select subset of tracks
96  fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudo.get());
97  fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudoFromB.get(), true, false);
98  fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudoNotFromB.get(), false, true);
99  fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudo.get());
100  fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudoFromB.get(), true, false);
101  fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudoNotFromB.get(), false, true);
102  fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakes.get());
103  fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakesFromB.get(), true, false);
104  fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakesNotFromB.get(), false, true);
105 
106  // Write tracks to store
107  ATH_MSG_DEBUG("outputRecoReplacedWithPseudo has "<<outputRecoReplacedWithPseudo.get()->size()<<" tracks");
108  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudo(m_out_recoReplacedWithPseudo, ctx);
109  ATH_CHECK(h_write_recoReplacedWithPseudo.record(std::move(outputRecoReplacedWithPseudo), std::move(outputRecoReplacedWithPseudoAux)));
110  ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudo<<" to store");
111 
112  ATH_MSG_DEBUG("outputRecoReplacedWithPseudoFromB has "<<outputRecoReplacedWithPseudoFromB.get()->size()<<" tracks");
113  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudoFromB(m_out_recoReplacedWithPseudoFromB, ctx);
114  ATH_CHECK(h_write_recoReplacedWithPseudoFromB.record(std::move(outputRecoReplacedWithPseudoFromB), std::move(outputRecoReplacedWithPseudoFromBAux)));
115  ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudoFromB<<" to store");
116 
117  ATH_MSG_DEBUG("outputRecoReplacedWithPseudoNotFromB has "<<outputRecoReplacedWithPseudoNotFromB.get()->size()<<" tracks");
118  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudoNotFromB(m_out_recoReplacedWithPseudoNotFromB, ctx);
119  ATH_CHECK(h_write_recoReplacedWithPseudoNotFromB.record(std::move(outputRecoReplacedWithPseudoNotFromB), std::move(outputRecoReplacedWithPseudoNotFromBAux)));
120  ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudoNotFromB<<" to store");
121 
122  ATH_MSG_DEBUG("outputRecoPlusPseudo has "<<outputRecoPlusPseudo.get()->size()<<" tracks");
123  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudo(m_out_recoPlusPseudo, ctx);
124  ATH_CHECK(h_write_recoPlusPseudo.record(std::move(outputRecoPlusPseudo), std::move(outputRecoPlusPseudoAux)));
125  ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudo<<" to store");
126 
127  ATH_MSG_DEBUG("outputRecoPlusPseudoFromB has "<<outputRecoPlusPseudoFromB.get()->size()<<" tracks");
128  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudoFromB(m_out_recoPlusPseudoFromB, ctx);
129  ATH_CHECK(h_write_recoPlusPseudoFromB.record(std::move(outputRecoPlusPseudoFromB), std::move(outputRecoPlusPseudoFromBAux)));
130  ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudoFromB<<" to store");
131 
132  ATH_MSG_DEBUG("outputRecoPlusPseudoNotFromB has "<<outputRecoPlusPseudoNotFromB.get()->size()<<" tracks");
133  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudoNotFromB(m_out_recoPlusPseudoNotFromB, ctx);
134  ATH_CHECK(h_write_recoPlusPseudoNotFromB.record(std::move(outputRecoPlusPseudoNotFromB), std::move(outputRecoPlusPseudoNotFromBAux)));
135  ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudoNotFromB<<" to store");
136 
137  ATH_MSG_DEBUG("outputRecoNoFakes has "<<outputRecoNoFakes.get()->size()<<" tracks");
138  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakes(m_out_recoNoFakes, ctx);
139  ATH_CHECK(h_write_recoNoFakes.record(std::move(outputRecoNoFakes), std::move(outputRecoNoFakesAux)));
140  ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakes<<" to store");
141 
142  ATH_MSG_DEBUG("outputRecoNoFakesFromB has "<<outputRecoNoFakesFromB.get()->size()<<" tracks");
143  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakesFromB(m_out_recoNoFakesFromB, ctx);
144  ATH_CHECK(h_write_recoNoFakesFromB.record(std::move(outputRecoNoFakesFromB), std::move(outputRecoNoFakesFromBAux)));
145  ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakesFromB<<" to store");
146 
147  ATH_MSG_DEBUG("outputRecoNoFakesNotFromB has "<<outputRecoNoFakesNotFromB.get()->size()<<" tracks");
148  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakesNotFromB(m_out_recoNoFakesNotFromB, ctx);
149  ATH_CHECK(h_write_recoNoFakesNotFromB.record(std::move(outputRecoNoFakesNotFromB), std::move(outputRecoNoFakesNotFromBAux)));
150  ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakesNotFromB<<" to store");
151 
152  return StatusCode::SUCCESS;
153  }

◆ fillRecoNoFakes()

void DerivationFramework::PseudoTrackSelector::fillRecoNoFakes ( const xAOD::TrackParticleContainer *  recoTrackParticleCol,
xAOD::TrackParticleContainer *  outputCol,
bool  onlyFromB = false,
bool  onlyNotFromB = false 
) const
protected

Definition at line 313 of file PseudoTrackSelector.cxx.

317  {
318  ATH_MSG_DEBUG("Start fillRecoNoFakes with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
319  // loop over tracks, accept them and add them into output collection
320  if((recoTrackParticleCol && !recoTrackParticleCol->empty())){
321  ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
322  int n_saved = 0;
323  static const SG::ConstAccessor< float > acc_truthProb("truthMatchProbability");
324 
325  // loop over tracks
326  for(const auto *const tp_reco: *recoTrackParticleCol){
327  // place cut on truth match probability
328  if (!onlyFromB && !onlyNotFromB){
329  if( acc_truthProb( *tp_reco ) < 0.5) {
330  ATH_MSG_DEBUG("Fake track!");
331  continue;
332  }
333  }
334  int origin = m_trackOriginTool->getTrackOrigin(tp_reco);
335  ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
336  if (onlyFromB && InDet::TrkOrigin::isFromB(origin)){
337  if( acc_truthProb( *tp_reco ) < 0.5) {
338  ATH_MSG_DEBUG("Fake track fromB!");
339  continue;
340  }
341  }
342  if (onlyNotFromB && !InDet::TrkOrigin::isFromB(origin)){
343  if( acc_truthProb( *tp_reco ) < 0.5) {
344  ATH_MSG_DEBUG("Fake track notFromB!");
345  continue;
346  }
347  }
348  // add track into output
349  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
350  outputCol->push_back(newTrackParticle);
351  n_saved++;
352  }
353  ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
354  }
355  }

◆ fillRecoPlusPseudo()

void DerivationFramework::PseudoTrackSelector::fillRecoPlusPseudo ( const xAOD::TrackParticleContainer *  recoTrackParticleCol,
const xAOD::TrackParticleContainer *  pseudoTrackParticleCol,
xAOD::TrackParticleContainer *  outputCol,
bool  onlyFromB = false,
bool  onlyNotFromB = false 
) const
protected

Definition at line 245 of file PseudoTrackSelector.cxx.

250  {
251  ATH_MSG_DEBUG("Start fillRecoPlusPseudo with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
252  // loop over tracks, accept them and add them into output collection
253  if((recoTrackParticleCol && !recoTrackParticleCol->empty()) &&
254  (pseudoTrackParticleCol && !pseudoTrackParticleCol->empty())) {
255  ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
256  ATH_MSG_DEBUG("Size of pseudo track particle collection " << pseudoTrackParticleCol->size());
257  int n_saved = 0;
258  // Start by keeping reco tracks
259  for(const auto *const tp_reco: *recoTrackParticleCol){
260  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
261  outputCol->push_back(newTrackParticle);
262  n_saved++;
263  }
264  // Now add pseudo tracks that are not matched to reco tracks
265  for(const auto *const tp_pseudo: *pseudoTrackParticleCol){
266  bool match_found = false;
267  const xAOD::TruthParticle* truth_pseudo = getTruth(tp_pseudo);
268  for(const auto *const tp_reco: *recoTrackParticleCol){
269  // Get truth particle
270  const xAOD::TruthParticle* truth_reco = getTruth(tp_reco);
271  if (truth_reco){
272  if (truth_reco == truth_pseudo){
273  ATH_MSG_DEBUG("reco track has truth-matched pseudo track!");
274  match_found = true;
275  break;
276  }
277  }
278  else{
279  ATH_MSG_DEBUG("no truth particle for reco track!");
280  }
281  }
282  if(!match_found){
283  ATH_MSG_DEBUG("no match found, so adding pseudo track to output");
284  if(!onlyFromB && !onlyNotFromB){
285  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
286  outputCol->push_back(newTrackParticle);
287  n_saved++;
288  ATH_MSG_DEBUG("saving pseudo track");
289  }
290  int origin = m_trackOriginTool->getTrackOrigin(tp_pseudo);
291  ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
292  if(onlyFromB && InDet::TrkOrigin::isFromB(origin)){
293  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
294  outputCol->push_back(newTrackParticle);
295  n_saved++;
296  ATH_MSG_DEBUG("saving fromB pseudo track");
297  }
298  if(onlyNotFromB && !InDet::TrkOrigin::isFromB(origin)){
299  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
300  outputCol->push_back(newTrackParticle);
301  n_saved++;
302  ATH_MSG_DEBUG("saving notFromB pseudo track");
303  }
304  }
305  else{
306  ATH_MSG_DEBUG("match found so not adding pseudo track to output");
307  }
308  }
309  ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
310  }
311  }

◆ fillRecoReplacedWithPseudo()

void DerivationFramework::PseudoTrackSelector::fillRecoReplacedWithPseudo ( const xAOD::TrackParticleContainer *  recoTrackParticleCol,
const xAOD::TrackParticleContainer *  pseudoTrackParticleCol,
xAOD::TrackParticleContainer *  outputCol,
bool  onlyFromB = false,
bool  onlyNotFromB = false 
) const
protected

Output track collection.

Protected methods:

Routines that selects the relevant (pseudo) tracks.

Definition at line 159 of file PseudoTrackSelector.cxx.

164  {
165  ATH_MSG_DEBUG("Start fillRecoReplacedWithPseudo with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
166  // loop over tracks, accept them and add them into output collection
167  if((recoTrackParticleCol && !recoTrackParticleCol->empty()) &&
168  (pseudoTrackParticleCol && !pseudoTrackParticleCol->empty())) {
169  ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
170  ATH_MSG_DEBUG("Size of pseudo track particle collection " << pseudoTrackParticleCol->size());
171  int n_saved = 0;
172  // loop over reco tracks
173  for(const auto *const tp_reco: *recoTrackParticleCol){
174  // Get truth particle
175  const xAOD::TruthParticle* truth_reco = getTruth(tp_reco);
176  if (truth_reco){
177  bool match_found = false;
178  // loop over pseudo tracks to look for a match
179  for(const auto *const tp_pseudo: *pseudoTrackParticleCol){
180  const xAOD::TruthParticle* truth_pseudo = getTruth(tp_pseudo);
181  if (truth_reco == truth_pseudo){
182  ATH_MSG_DEBUG("reco track has truth-matched pseudo track!");
183  match_found = true;
184  // add pseudo track into output
185  if (!onlyFromB && !onlyNotFromB){
186  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
187  outputCol->push_back(newTrackParticle);
188  n_saved++;
189  ATH_MSG_DEBUG("saving pseudo track");
190  }
191  // Check origin of track
192  int origin = m_trackOriginTool->getTrackOrigin(tp_pseudo);
193  ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
194  if (onlyFromB){
195  if (InDet::TrkOrigin::isFromB(origin)){
196  // Track is from B hadron, replace with pseudo track
197  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
198  outputCol->push_back(newTrackParticle);
199  n_saved++;
200  ATH_MSG_DEBUG("saving fromB pseudo track");
201  }
202  else{
203  // Track is not from B hadron, keep reco track
204  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
205  outputCol->push_back(newTrackParticle);
206  n_saved++;
207  ATH_MSG_DEBUG("keeping notFromB reco track");
208  }
209  }
210  if (onlyNotFromB){
211  if (!InDet::TrkOrigin::isFromB(origin)){
212  // Track is not from B hadron, replace with pseudo track
213  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
214  outputCol->push_back(newTrackParticle);
215  n_saved++;
216  ATH_MSG_DEBUG("saving notFromB pseudo track");
217  }
218  else{
219  // Track is from B hadron, keep reco track
220  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
221  outputCol->push_back(newTrackParticle);
222  n_saved++;
223  ATH_MSG_DEBUG("keeping FromB reco track");
224  }
225  }
226  // Found match and replaced relevant track
227  break;
228  }
229  else{
230  ATH_MSG_VERBOSE("truth-matched pseudo track not found yet...");
231  }
232  }
233  if(!match_found){
234  ATH_MSG_DEBUG("reco track that has truth link DOES NOT have truth-matched pseudo track! :(");
235  }
236  }
237  else{
238  ATH_MSG_DEBUG("no truth particle for reco track!");
239  }
240  }
241  ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
242  }
243  }

◆ getTruth()

const xAOD::TruthParticle * DerivationFramework::PseudoTrackSelector::getTruth ( const xAOD::TrackParticle *  track)
staticprotected

Definition at line 357 of file PseudoTrackSelector.cxx.

357  {
358  // create a pointer to a truth particle which will correspond to this track
359  const xAOD::TruthParticle* linkedTruthParticle = nullptr;
360 
361  // if the track doesnt't have a valid truth link, skip to the next track
362  // in practice, all tracks seem to have a truth link, but we need to also
363  // check whether it's valid
364  static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
365  if ( !truthParticleLinkAcc.isAvailable(*track) ) {
366  return nullptr;
367  }
368 
369  // retrieve the link and check its validity
370  const TruthLink &link = truthParticleLinkAcc(*track);
371 
372  // a missing or invalid link implies truth particle has been dropped from
373  // the truth record at some stage - probably it was a pileup or low pT GEANT
374  // particle.
375  if(!link or !link.isValid()) {
376  return nullptr;
377  }
378 
379  // seems safe to access and return the linked truth particle
380  linkedTruthParticle = (*link);
381  return linkedTruthParticle;
382  }

◆ initialize()

StatusCode DerivationFramework::PseudoTrackSelector::initialize ( )
finaloverridevirtual

Definition at line 33 of file PseudoTrackSelector.cxx.

34  {
35  ATH_MSG_DEBUG("Initializing PseudoTrackSelector");
36  ATH_CHECK( m_in_recoTrackParticleLocation.initialize() );
37  ATH_CHECK( m_in_pseudoTrackParticleLocation.initialize() );
38  ATH_CHECK( m_out_recoReplacedWithPseudo.initialize() );
39  ATH_CHECK( m_out_recoReplacedWithPseudoFromB.initialize() );
40  ATH_CHECK( m_out_recoReplacedWithPseudoNotFromB.initialize() );
41  ATH_CHECK( m_out_recoPlusPseudo.initialize() );
42  ATH_CHECK( m_out_recoPlusPseudoFromB.initialize() );
43  ATH_CHECK( m_out_recoPlusPseudoNotFromB.initialize() );
44  ATH_CHECK( m_out_recoNoFakes.initialize() );
45  ATH_CHECK( m_out_recoNoFakesFromB.initialize() );
46  ATH_CHECK( m_out_recoNoFakesNotFromB.initialize() );
47  ATH_CHECK( m_trackOriginTool.retrieve() );
48  return StatusCode::SUCCESS;
49  }

Member Data Documentation

◆ m_in_pseudoTrackParticleLocation

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_in_pseudoTrackParticleLocation {this, "PseudoTrackParticleLocation", ""}
protected

Reco track collection.


Definition at line 48 of file PseudoTrackSelector.h.

◆ m_in_recoTrackParticleLocation

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_in_recoTrackParticleLocation {this, "RecoTrackParticleLocation", ""}
protected

Protected data:

Definition at line 47 of file PseudoTrackSelector.h.

◆ m_out_recoNoFakes

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoNoFakes {this, "OutputRecoNoFakes", ""}
protected

Output track collection.

Definition at line 55 of file PseudoTrackSelector.h.

◆ m_out_recoNoFakesFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoNoFakesFromB {this, "OutputRecoNoFakesFromB", ""}
protected

Output track collection.

Definition at line 56 of file PseudoTrackSelector.h.

◆ m_out_recoNoFakesNotFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoNoFakesNotFromB {this, "OutputRecoNoFakesNotFromB", ""}
protected

Output track collection.

Definition at line 57 of file PseudoTrackSelector.h.

◆ m_out_recoPlusPseudo

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudo {this, "OutputRecoPlusPseudo", ""}
protected

Output track collection.

Definition at line 52 of file PseudoTrackSelector.h.

◆ m_out_recoPlusPseudoFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudoFromB {this, "OutputRecoPlusPseudoFromB", ""}
protected

Output track collection.

Definition at line 53 of file PseudoTrackSelector.h.

◆ m_out_recoPlusPseudoNotFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudoNotFromB {this, "OutputRecoPlusPseudoNotFromB", ""}
protected

Output track collection.

Definition at line 54 of file PseudoTrackSelector.h.

◆ m_out_recoReplacedWithPseudo

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudo {this, "OutputRecoReplacedWithPseudo", ""}
protected

Pseudo track collection.

Definition at line 49 of file PseudoTrackSelector.h.

◆ m_out_recoReplacedWithPseudoFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudoFromB {this, "OutputRecoReplacedWithPseudoFromB", ""}
protected

Output track collection.

Definition at line 50 of file PseudoTrackSelector.h.

◆ m_out_recoReplacedWithPseudoNotFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudoNotFromB {this, "OutputRecoReplacedWithPseudoNotFromB", ""}
protected

Output track collection.

Definition at line 51 of file PseudoTrackSelector.h.

◆ m_trackOriginTool

ToolHandle< InDet::IInDetTrackTruthOriginTool > DerivationFramework::PseudoTrackSelector::m_trackOriginTool {this, "trackTruthOriginTool", "InDet::InDetTrackTruthOriginTool", "truth track origin tool"}
private

Definition at line 85 of file PseudoTrackSelector.h.

The documentation for this class was generated from the following files:
DerivationFramework::PseudoTrackSelector::m_out_recoNoFakesNotFromB
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoNoFakesNotFromB
Output track collection.
Definition: PseudoTrackSelector.h:57
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
SG::ConstAccessor< float >
DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudo
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoReplacedWithPseudo
Pseudo track collection.
Definition: PseudoTrackSelector.h:49
DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudoNotFromB
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoReplacedWithPseudoNotFromB
Output track collection.
Definition: PseudoTrackSelector.h:51
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
DerivationFramework::PseudoTrackSelector::m_trackOriginTool
ToolHandle< InDet::IInDetTrackTruthOriginTool > m_trackOriginTool
Definition: PseudoTrackSelector.h:85
DerivationFramework::PseudoTrackSelector::m_in_recoTrackParticleLocation
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_in_recoTrackParticleLocation
Protected data:
Definition: PseudoTrackSelector.h:47
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition: Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudoNotFromB
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoPlusPseudoNotFromB
Output track collection.
Definition: PseudoTrackSelector.h:54
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
DerivationFramework::PseudoTrackSelector::fillRecoNoFakes
void fillRecoNoFakes(const xAOD::TrackParticleContainer *recoTrackParticleCol, xAOD::TrackParticleContainer *outputCol, bool onlyFromB=false, bool onlyNotFromB=false) const
Definition: PseudoTrackSelector.cxx:313
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:37
DerivationFramework::PseudoTrackSelector::m_out_recoNoFakesFromB
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoNoFakesFromB
Output track collection.
Definition: PseudoTrackSelector.h:56
DerivationFramework::PseudoTrackSelector::fillRecoPlusPseudo
void fillRecoPlusPseudo(const xAOD::TrackParticleContainer *recoTrackParticleCol, const xAOD::TrackParticleContainer *pseudoTrackParticleCol, xAOD::TrackParticleContainer *outputCol, bool onlyFromB=false, bool onlyNotFromB=false) const
Definition: PseudoTrackSelector.cxx:245
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
DerivationFramework::PseudoTrackSelector::fillRecoReplacedWithPseudo
void fillRecoReplacedWithPseudo(const xAOD::TrackParticleContainer *recoTrackParticleCol, const xAOD::TrackParticleContainer *pseudoTrackParticleCol, xAOD::TrackParticleContainer *outputCol, bool onlyFromB=false, bool onlyNotFromB=false) const
Output track collection.
Definition: PseudoTrackSelector.cxx:159
InDet::TrkOrigin::isFromB
bool isFromB(int origin)
from B decay chain including B-->D
Definition: InDetTrackTruthOriginDefs.h:111
DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudoFromB
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoReplacedWithPseudoFromB
Output track collection.
Definition: PseudoTrackSelector.h:50
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
DerivationFramework::PseudoTrackSelector::m_in_pseudoTrackParticleLocation
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_in_pseudoTrackParticleLocation
Reco track collection.
Definition: PseudoTrackSelector.h:48
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
DerivationFramework::PseudoTrackSelector::m_out_recoNoFakes
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoNoFakes
Output track collection.
Definition: PseudoTrackSelector.h:55
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudo
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoPlusPseudo
Output track collection.
Definition: PseudoTrackSelector.h:52
DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudoFromB
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoPlusPseudoFromB
Output track collection.
Definition: PseudoTrackSelector.h:53
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:44
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
DerivationFramework::PseudoTrackSelector::getTruth
static const xAOD::TruthParticle * getTruth(const xAOD::TrackParticle *track)
Definition: PseudoTrackSelector.cxx:357
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
Generated on Thu Nov 20 2025 22:02:40 for ATLAS Offline Software by   doxygen 1.8.18