ATLAS Offline Software
PseudoTrackSelector.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // PseudoTrackSelector
7 // Author: Sebastien Rettie, sebastien.rettie@cern.ch
8 // This is a modified version of exisitng TrackParticleMerger
10 
12 // Pseudotrack selector to be used mainly for creating new track
13 // collections with a subset of input pseudotracks
15 
16 #include "DerivationFrameworkInDet/PseudoTrackSelector.h"
17 #include "GaudiKernel/MsgStream.h"
18 #include "xAODTracking/TrackParticleAuxContainer.h"
19 #include "InDetTrackSystematicsTools/InDetTrackTruthOriginDefs.h"
20 #include "AthContainers/ConstAccessor.h"
22 // Constructor
24 
25 namespace DerivationFramework {
26 
27  PseudoTrackSelector::PseudoTrackSelector(const std::string& t,
28  const std::string& n,
29  const IInterface* p) : base_class(t,n,p)
30  {
31  // The default goal of this selector is to create a track collection from a subset of pseudo tracks
32  declareProperty("RecoTrackParticleLocation", m_in_recoTrackParticleLocation);
33  declareProperty("PseudoTrackParticleLocation", m_in_pseudoTrackParticleLocation);
34  declareProperty("OutputRecoReplacedWithPseudo", m_out_recoReplacedWithPseudo);
35  declareProperty("OutputRecoReplacedWithPseudoFromB", m_out_recoReplacedWithPseudoFromB);
36  declareProperty("OutputRecoReplacedWithPseudoNotFromB", m_out_recoReplacedWithPseudoNotFromB);
37  declareProperty("OutputRecoPlusPseudo", m_out_recoPlusPseudo);
38  declareProperty("OutputRecoPlusPseudoFromB", m_out_recoPlusPseudoFromB);
39  declareProperty("OutputRecoPlusPseudoNotFromB", m_out_recoPlusPseudoNotFromB);
40  declareProperty("OutputRecoNoFakes", m_out_recoNoFakes);
41  declareProperty("OutputRecoNoFakesFromB", m_out_recoNoFakesFromB);
42  declareProperty("OutputRecoNoFakesNotFromB", m_out_recoNoFakesNotFromB);
43  }
44 
46  // Initialisation
48 
49  StatusCode PseudoTrackSelector::initialize()
50  {
51  ATH_MSG_DEBUG("Initializing PseudoTrackSelector");
52  ATH_CHECK( m_in_recoTrackParticleLocation.initialize() );
53  ATH_CHECK( m_in_pseudoTrackParticleLocation.initialize() );
54  ATH_CHECK( m_out_recoReplacedWithPseudo.initialize() );
55  ATH_CHECK( m_out_recoReplacedWithPseudoFromB.initialize() );
56  ATH_CHECK( m_out_recoReplacedWithPseudoNotFromB.initialize() );
57  ATH_CHECK( m_out_recoPlusPseudo.initialize() );
58  ATH_CHECK( m_out_recoPlusPseudoFromB.initialize() );
59  ATH_CHECK( m_out_recoPlusPseudoNotFromB.initialize() );
60  ATH_CHECK( m_out_recoNoFakes.initialize() );
61  ATH_CHECK( m_out_recoNoFakesFromB.initialize() );
62  ATH_CHECK( m_out_recoNoFakesNotFromB.initialize() );
63  ATH_CHECK( m_trackOriginTool.retrieve() );
64  return StatusCode::SUCCESS;
65  }
66 
68  // Finalize
70 
71  StatusCode PseudoTrackSelector::finalize()
72  {
73  return StatusCode::SUCCESS;
74  }
75 
76  StatusCode PseudoTrackSelector::addBranches(const EventContext& ctx) const
77  {
78  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudo = std::make_unique<xAOD::TrackParticleContainer>();
79  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
80  outputRecoReplacedWithPseudo->setStore(outputRecoReplacedWithPseudoAux.get());
81  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudoFromB = std::make_unique<xAOD::TrackParticleContainer>();
82  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
83  outputRecoReplacedWithPseudoFromB->setStore(outputRecoReplacedWithPseudoFromBAux.get());
84  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudoNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
85  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
86  outputRecoReplacedWithPseudoNotFromB->setStore(outputRecoReplacedWithPseudoNotFromBAux.get());
87  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudo = std::make_unique<xAOD::TrackParticleContainer>();
88  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
89  outputRecoPlusPseudo->setStore(outputRecoPlusPseudoAux.get());
90  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudoFromB = std::make_unique<xAOD::TrackParticleContainer>();
91  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
92  outputRecoPlusPseudoFromB->setStore(outputRecoPlusPseudoFromBAux.get());
93  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudoNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
94  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
95  outputRecoPlusPseudoNotFromB->setStore(outputRecoPlusPseudoNotFromBAux.get());
96  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakes = std::make_unique<xAOD::TrackParticleContainer>();
97  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
98  outputRecoNoFakes->setStore(outputRecoNoFakesAux.get());
99  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakesFromB = std::make_unique<xAOD::TrackParticleContainer>();
100  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
101  outputRecoNoFakesFromB->setStore(outputRecoNoFakesFromBAux.get());
102  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakesNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
103  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
104  outputRecoNoFakesNotFromB->setStore(outputRecoNoFakesNotFromBAux.get());
105 
106  // retrieve reco and pseudo tracks
107  SG::ReadHandle<xAOD::TrackParticleContainer> recoTrackParticleCol (m_in_recoTrackParticleLocation, ctx);
108  SG::ReadHandle<xAOD::TrackParticleContainer> pseudoTrackParticleCol (m_in_pseudoTrackParticleLocation, ctx);
109 
110  // fail if containers not available
111  if (!recoTrackParticleCol.isValid()){
112  ATH_MSG_ERROR( m_in_recoTrackParticleLocation.key() << " not valid!" );
113  return StatusCode::FAILURE;
114  }
115  if (!pseudoTrackParticleCol.isValid()){
116  ATH_MSG_ERROR( m_in_pseudoTrackParticleLocation.key() << " not valid!" );
117  return StatusCode::FAILURE;
118  }
119 
120  // select subset of tracks
121  fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudo.get());
122  fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudoFromB.get(), true, false);
123  fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudoNotFromB.get(), false, true);
124  fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudo.get());
125  fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudoFromB.get(), true, false);
126  fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudoNotFromB.get(), false, true);
127  fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakes.get());
128  fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakesFromB.get(), true, false);
129  fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakesNotFromB.get(), false, true);
130 
131  // Write tracks to store
132  ATH_MSG_DEBUG("outputRecoReplacedWithPseudo has "<<outputRecoReplacedWithPseudo.get()->size()<<" tracks");
133  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudo(m_out_recoReplacedWithPseudo, ctx);
134  ATH_CHECK(h_write_recoReplacedWithPseudo.record(std::move(outputRecoReplacedWithPseudo), std::move(outputRecoReplacedWithPseudoAux)));
135  ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudo<<" to store");
136 
137  ATH_MSG_DEBUG("outputRecoReplacedWithPseudoFromB has "<<outputRecoReplacedWithPseudoFromB.get()->size()<<" tracks");
138  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudoFromB(m_out_recoReplacedWithPseudoFromB, ctx);
139  ATH_CHECK(h_write_recoReplacedWithPseudoFromB.record(std::move(outputRecoReplacedWithPseudoFromB), std::move(outputRecoReplacedWithPseudoFromBAux)));
140  ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudoFromB<<" to store");
141 
142  ATH_MSG_DEBUG("outputRecoReplacedWithPseudoNotFromB has "<<outputRecoReplacedWithPseudoNotFromB.get()->size()<<" tracks");
143  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudoNotFromB(m_out_recoReplacedWithPseudoNotFromB, ctx);
144  ATH_CHECK(h_write_recoReplacedWithPseudoNotFromB.record(std::move(outputRecoReplacedWithPseudoNotFromB), std::move(outputRecoReplacedWithPseudoNotFromBAux)));
145  ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudoNotFromB<<" to store");
146 
147  ATH_MSG_DEBUG("outputRecoPlusPseudo has "<<outputRecoPlusPseudo.get()->size()<<" tracks");
148  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudo(m_out_recoPlusPseudo, ctx);
149  ATH_CHECK(h_write_recoPlusPseudo.record(std::move(outputRecoPlusPseudo), std::move(outputRecoPlusPseudoAux)));
150  ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudo<<" to store");
151 
152  ATH_MSG_DEBUG("outputRecoPlusPseudoFromB has "<<outputRecoPlusPseudoFromB.get()->size()<<" tracks");
153  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudoFromB(m_out_recoPlusPseudoFromB, ctx);
154  ATH_CHECK(h_write_recoPlusPseudoFromB.record(std::move(outputRecoPlusPseudoFromB), std::move(outputRecoPlusPseudoFromBAux)));
155  ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudoFromB<<" to store");
156 
157  ATH_MSG_DEBUG("outputRecoPlusPseudoNotFromB has "<<outputRecoPlusPseudoNotFromB.get()->size()<<" tracks");
158  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudoNotFromB(m_out_recoPlusPseudoNotFromB, ctx);
159  ATH_CHECK(h_write_recoPlusPseudoNotFromB.record(std::move(outputRecoPlusPseudoNotFromB), std::move(outputRecoPlusPseudoNotFromBAux)));
160  ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudoNotFromB<<" to store");
161 
162  ATH_MSG_DEBUG("outputRecoNoFakes has "<<outputRecoNoFakes.get()->size()<<" tracks");
163  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakes(m_out_recoNoFakes, ctx);
164  ATH_CHECK(h_write_recoNoFakes.record(std::move(outputRecoNoFakes), std::move(outputRecoNoFakesAux)));
165  ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakes<<" to store");
166 
167  ATH_MSG_DEBUG("outputRecoNoFakesFromB has "<<outputRecoNoFakesFromB.get()->size()<<" tracks");
168  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakesFromB(m_out_recoNoFakesFromB, ctx);
169  ATH_CHECK(h_write_recoNoFakesFromB.record(std::move(outputRecoNoFakesFromB), std::move(outputRecoNoFakesFromBAux)));
170  ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakesFromB<<" to store");
171 
172  ATH_MSG_DEBUG("outputRecoNoFakesNotFromB has "<<outputRecoNoFakesNotFromB.get()->size()<<" tracks");
173  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakesNotFromB(m_out_recoNoFakesNotFromB, ctx);
174  ATH_CHECK(h_write_recoNoFakesNotFromB.record(std::move(outputRecoNoFakesNotFromB), std::move(outputRecoNoFakesNotFromBAux)));
175  ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakesNotFromB<<" to store");
176 
177  return StatusCode::SUCCESS;
178  }
179 
181  // Select relevant pseudo tracks
183 
184  void PseudoTrackSelector::fillRecoReplacedWithPseudo(const xAOD::TrackParticleContainer* recoTrackParticleCol,
185  const xAOD::TrackParticleContainer* pseudoTrackParticleCol,
186  xAOD::TrackParticleContainer* outputCol,
187  bool onlyFromB /*= false*/,
188  bool onlyNotFromB /*= false*/) const
189  {
190  ATH_MSG_DEBUG("Start fillRecoReplacedWithPseudo with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
191  // loop over tracks, accept them and add them into output collection
192  if((recoTrackParticleCol && !recoTrackParticleCol->empty()) &&
193  (pseudoTrackParticleCol && !pseudoTrackParticleCol->empty())) {
194  ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
195  ATH_MSG_DEBUG("Size of pseudo track particle collection " << pseudoTrackParticleCol->size());
196  int n_saved = 0;
197  // loop over reco tracks
198  for(const auto *const tp_reco: *recoTrackParticleCol){
199  // Get truth particle
200  const xAOD::TruthParticle* truth_reco = getTruth(tp_reco);
201  if (truth_reco){
202  bool match_found = false;
203  // loop over pseudo tracks to look for a match
204  for(const auto *const tp_pseudo: *pseudoTrackParticleCol){
205  const xAOD::TruthParticle* truth_pseudo = getTruth(tp_pseudo);
206  if (truth_reco == truth_pseudo){
207  ATH_MSG_DEBUG("reco track has truth-matched pseudo track!");
208  match_found = true;
209  // add pseudo track into output
210  if (!onlyFromB && !onlyNotFromB){
211  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
212  outputCol->push_back(newTrackParticle);
213  n_saved++;
214  ATH_MSG_DEBUG("saving pseudo track");
215  }
216  // Check origin of track
217  int origin = m_trackOriginTool->getTrackOrigin(tp_pseudo);
218  ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
219  if (onlyFromB){
220  if (InDet::TrkOrigin::isFromB(origin)){
221  // Track is from B hadron, replace with pseudo track
222  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
223  outputCol->push_back(newTrackParticle);
224  n_saved++;
225  ATH_MSG_DEBUG("saving fromB pseudo track");
226  }
227  else{
228  // Track is not from B hadron, keep reco track
229  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
230  outputCol->push_back(newTrackParticle);
231  n_saved++;
232  ATH_MSG_DEBUG("keeping notFromB reco track");
233  }
234  }
235  if (onlyNotFromB){
236  if (!InDet::TrkOrigin::isFromB(origin)){
237  // Track is not from B hadron, replace with pseudo track
238  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
239  outputCol->push_back(newTrackParticle);
240  n_saved++;
241  ATH_MSG_DEBUG("saving notFromB pseudo track");
242  }
243  else{
244  // Track is from B hadron, keep reco track
245  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
246  outputCol->push_back(newTrackParticle);
247  n_saved++;
248  ATH_MSG_DEBUG("keeping FromB reco track");
249  }
250  }
251  // Found match and replaced relevant track
252  break;
253  }
254  else{
255  ATH_MSG_VERBOSE("truth-matched pseudo track not found yet...");
256  }
257  }
258  if(!match_found){
259  ATH_MSG_DEBUG("reco track that has truth link DOES NOT have truth-matched pseudo track! :(");
260  }
261  }
262  else{
263  ATH_MSG_DEBUG("no truth particle for reco track!");
264  }
265  }
266  ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
267  }
268  }
269 
270  void PseudoTrackSelector::fillRecoPlusPseudo(const xAOD::TrackParticleContainer* recoTrackParticleCol,
271  const xAOD::TrackParticleContainer* pseudoTrackParticleCol,
272  xAOD::TrackParticleContainer* outputCol,
273  bool onlyFromB /*= false*/,
274  bool onlyNotFromB /*= false*/) const
275  {
276  ATH_MSG_DEBUG("Start fillRecoPlusPseudo with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
277  // loop over tracks, accept them and add them into output collection
278  if((recoTrackParticleCol && !recoTrackParticleCol->empty()) &&
279  (pseudoTrackParticleCol && !pseudoTrackParticleCol->empty())) {
280  ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
281  ATH_MSG_DEBUG("Size of pseudo track particle collection " << pseudoTrackParticleCol->size());
282  int n_saved = 0;
283  // Start by keeping reco tracks
284  for(const auto *const tp_reco: *recoTrackParticleCol){
285  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
286  outputCol->push_back(newTrackParticle);
287  n_saved++;
288  }
289  // Now add pseudo tracks that are not matched to reco tracks
290  for(const auto *const tp_pseudo: *pseudoTrackParticleCol){
291  bool match_found = false;
292  const xAOD::TruthParticle* truth_pseudo = getTruth(tp_pseudo);
293  for(const auto *const tp_reco: *recoTrackParticleCol){
294  // Get truth particle
295  const xAOD::TruthParticle* truth_reco = getTruth(tp_reco);
296  if (truth_reco){
297  if (truth_reco == truth_pseudo){
298  ATH_MSG_DEBUG("reco track has truth-matched pseudo track!");
299  match_found = true;
300  break;
301  }
302  }
303  else{
304  ATH_MSG_DEBUG("no truth particle for reco track!");
305  }
306  }
307  if(!match_found){
308  ATH_MSG_DEBUG("no match found, so adding pseudo track to output");
309  if(!onlyFromB && !onlyNotFromB){
310  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
311  outputCol->push_back(newTrackParticle);
312  n_saved++;
313  ATH_MSG_DEBUG("saving pseudo track");
314  }
315  int origin = m_trackOriginTool->getTrackOrigin(tp_pseudo);
316  ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
317  if(onlyFromB && InDet::TrkOrigin::isFromB(origin)){
318  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
319  outputCol->push_back(newTrackParticle);
320  n_saved++;
321  ATH_MSG_DEBUG("saving fromB pseudo track");
322  }
323  if(onlyNotFromB && !InDet::TrkOrigin::isFromB(origin)){
324  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
325  outputCol->push_back(newTrackParticle);
326  n_saved++;
327  ATH_MSG_DEBUG("saving notFromB pseudo track");
328  }
329  }
330  else{
331  ATH_MSG_DEBUG("match found so not adding pseudo track to output");
332  }
333  }
334  ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
335  }
336  }
337 
338  void PseudoTrackSelector::fillRecoNoFakes(const xAOD::TrackParticleContainer* recoTrackParticleCol,
339  xAOD::TrackParticleContainer* outputCol,
340  bool onlyFromB /*= false*/,
341  bool onlyNotFromB /*= false*/) const
342  {
343  ATH_MSG_DEBUG("Start fillRecoNoFakes with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
344  // loop over tracks, accept them and add them into output collection
345  if((recoTrackParticleCol && !recoTrackParticleCol->empty())){
346  ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
347  int n_saved = 0;
348  static const SG::ConstAccessor< float > acc_truthProb("truthMatchProbability");
349 
350  // loop over tracks
351  for(const auto *const tp_reco: *recoTrackParticleCol){
352  // place cut on truth match probability
353  if (!onlyFromB && !onlyNotFromB){
354  if( acc_truthProb( *tp_reco ) < 0.5) {
355  ATH_MSG_DEBUG("Fake track!");
356  continue;
357  }
358  }
359  int origin = m_trackOriginTool->getTrackOrigin(tp_reco);
360  ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
361  if (onlyFromB && InDet::TrkOrigin::isFromB(origin)){
362  if( acc_truthProb( *tp_reco ) < 0.5) {
363  ATH_MSG_DEBUG("Fake track fromB!");
364  continue;
365  }
366  }
367  if (onlyNotFromB && !InDet::TrkOrigin::isFromB(origin)){
368  if( acc_truthProb( *tp_reco ) < 0.5) {
369  ATH_MSG_DEBUG("Fake track notFromB!");
370  continue;
371  }
372  }
373  // add track into output
374  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
375  outputCol->push_back(newTrackParticle);
376  n_saved++;
377  }
378  ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
379  }
380  }
381 
382  const xAOD::TruthParticle* PseudoTrackSelector::getTruth( const xAOD::TrackParticle* track ) {
383  // create a pointer to a truth particle which will correspond to this track
384  const xAOD::TruthParticle* linkedTruthParticle = nullptr;
385 
386  // if the track doesnt't have a valid truth link, skip to the next track
387  // in practice, all tracks seem to have a truth link, but we need to also
388  // check whether it's valid
389  static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
390  if ( !truthParticleLinkAcc.isAvailable(*track) ) {
391  return nullptr;
392  }
393 
394  // retrieve the link and check its validity
395  const TruthLink &link = truthParticleLinkAcc(*track);
396 
397  // a missing or invalid link implies truth particle has been dropped from
398  // the truth record at some stage - probably it was a pileup or low pT GEANT
399  // particle.
400  if(!link or !link.isValid()) {
401  return nullptr;
402  }
403 
404  // seems safe to access and return the linked truth particle
405  linkedTruthParticle = (*link);
406  return linkedTruthParticle;
407  }
408 }
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
DerivationFramework::PseudoTrackSelector::m_out_recoNoFakesNotFromB
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoNoFakesNotFromB
Output track collection.
Definition: PseudoTrackSelector.h:59
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:51
DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudoNotFromB
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoReplacedWithPseudoNotFromB
Output track collection.
Definition: PseudoTrackSelector.h:53
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
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::PseudoTrackSelector
PseudoTrackSelector(const std::string &t, const std::string &n, const IInterface *p)
Standard Algotithm methods:
Definition: PseudoTrackSelector.cxx:27
DerivationFramework::PseudoTrackSelector::m_trackOriginTool
ToolHandle< InDet::IInDetTrackTruthOriginTool > m_trackOriginTool
Definition: PseudoTrackSelector.h:87
DerivationFramework::PseudoTrackSelector::addBranches
virtual StatusCode addBranches(const EventContext &ctx) const
Definition: PseudoTrackSelector.cxx:76
DerivationFramework::PseudoTrackSelector::m_in_recoTrackParticleLocation
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_in_recoTrackParticleLocation
Protected data:
Definition: PseudoTrackSelector.h:49
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:56
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
PseudoTrackSelector.h
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:338
TrackParticleAuxContainer.h
beamspotman.n
n
Definition: beamspotman.py:727
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
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:58
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:270
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:184
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:52
DerivationFramework
THE reconstruction tool.
Definition: ParticleSortingAlg.h:24
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
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
DerivationFramework::PseudoTrackSelector::m_in_pseudoTrackParticleLocation
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_in_pseudoTrackParticleLocation
Reco track collection.
Definition: PseudoTrackSelector.h:50
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:57
InDetTrackTruthOriginDefs.h
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudo
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoPlusPseudo
Output track collection.
Definition: PseudoTrackSelector.h:54
DerivationFramework::PseudoTrackSelector::finalize
StatusCode finalize()
Definition: PseudoTrackSelector.cxx:71
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudoFromB
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_out_recoPlusPseudoFromB
Output track collection.
Definition: PseudoTrackSelector.h:55
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:44
DerivationFramework::PseudoTrackSelector::initialize
StatusCode initialize()
Definition: PseudoTrackSelector.cxx:49
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
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:382
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
Generated on Thu Oct 30 2025 21:16:36 for ATLAS Offline Software by   doxygen 1.8.18