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
77  {
78  const EventContext& ctx = Gaudi::Hive::currentContext();
79  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudo = std::make_unique<xAOD::TrackParticleContainer>();
80  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
81  outputRecoReplacedWithPseudo->setStore(outputRecoReplacedWithPseudoAux.get());
82  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudoFromB = std::make_unique<xAOD::TrackParticleContainer>();
83  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
84  outputRecoReplacedWithPseudoFromB->setStore(outputRecoReplacedWithPseudoFromBAux.get());
85  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudoNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
86  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
87  outputRecoReplacedWithPseudoNotFromB->setStore(outputRecoReplacedWithPseudoNotFromBAux.get());
88  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudo = std::make_unique<xAOD::TrackParticleContainer>();
89  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
90  outputRecoPlusPseudo->setStore(outputRecoPlusPseudoAux.get());
91  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudoFromB = std::make_unique<xAOD::TrackParticleContainer>();
92  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
93  outputRecoPlusPseudoFromB->setStore(outputRecoPlusPseudoFromBAux.get());
94  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudoNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
95  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
96  outputRecoPlusPseudoNotFromB->setStore(outputRecoPlusPseudoNotFromBAux.get());
97  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakes = std::make_unique<xAOD::TrackParticleContainer>();
98  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
99  outputRecoNoFakes->setStore(outputRecoNoFakesAux.get());
100  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakesFromB = std::make_unique<xAOD::TrackParticleContainer>();
101  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
102  outputRecoNoFakesFromB->setStore(outputRecoNoFakesFromBAux.get());
103  std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakesNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
104  std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
105  outputRecoNoFakesNotFromB->setStore(outputRecoNoFakesNotFromBAux.get());
106 
107  // retrieve reco and pseudo tracks
108  SG::ReadHandle<xAOD::TrackParticleContainer> recoTrackParticleCol (m_in_recoTrackParticleLocation, ctx);
109  SG::ReadHandle<xAOD::TrackParticleContainer> pseudoTrackParticleCol (m_in_pseudoTrackParticleLocation, ctx);
110 
111  // fail if containers not available
112  if (!recoTrackParticleCol.isValid()){
113  ATH_MSG_ERROR( m_in_recoTrackParticleLocation.key() << " not valid!" );
114  return StatusCode::FAILURE;
115  }
116  if (!pseudoTrackParticleCol.isValid()){
117  ATH_MSG_ERROR( m_in_pseudoTrackParticleLocation.key() << " not valid!" );
118  return StatusCode::FAILURE;
119  }
120 
121  // select subset of tracks
122  fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudo.get());
123  fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudoFromB.get(), true, false);
124  fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudoNotFromB.get(), false, true);
125  fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudo.get());
126  fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudoFromB.get(), true, false);
127  fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudoNotFromB.get(), false, true);
128  fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakes.get());
129  fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakesFromB.get(), true, false);
130  fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakesNotFromB.get(), false, true);
131 
132  // Write tracks to store
133  ATH_MSG_DEBUG("outputRecoReplacedWithPseudo has "<<outputRecoReplacedWithPseudo.get()->size()<<" tracks");
134  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudo(m_out_recoReplacedWithPseudo, ctx);
135  ATH_CHECK(h_write_recoReplacedWithPseudo.record(std::move(outputRecoReplacedWithPseudo), std::move(outputRecoReplacedWithPseudoAux)));
136  ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudo<<" to store");
137 
138  ATH_MSG_DEBUG("outputRecoReplacedWithPseudoFromB has "<<outputRecoReplacedWithPseudoFromB.get()->size()<<" tracks");
139  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudoFromB(m_out_recoReplacedWithPseudoFromB, ctx);
140  ATH_CHECK(h_write_recoReplacedWithPseudoFromB.record(std::move(outputRecoReplacedWithPseudoFromB), std::move(outputRecoReplacedWithPseudoFromBAux)));
141  ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudoFromB<<" to store");
142 
143  ATH_MSG_DEBUG("outputRecoReplacedWithPseudoNotFromB has "<<outputRecoReplacedWithPseudoNotFromB.get()->size()<<" tracks");
144  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudoNotFromB(m_out_recoReplacedWithPseudoNotFromB, ctx);
145  ATH_CHECK(h_write_recoReplacedWithPseudoNotFromB.record(std::move(outputRecoReplacedWithPseudoNotFromB), std::move(outputRecoReplacedWithPseudoNotFromBAux)));
146  ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudoNotFromB<<" to store");
147 
148  ATH_MSG_DEBUG("outputRecoPlusPseudo has "<<outputRecoPlusPseudo.get()->size()<<" tracks");
149  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudo(m_out_recoPlusPseudo, ctx);
150  ATH_CHECK(h_write_recoPlusPseudo.record(std::move(outputRecoPlusPseudo), std::move(outputRecoPlusPseudoAux)));
151  ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudo<<" to store");
152 
153  ATH_MSG_DEBUG("outputRecoPlusPseudoFromB has "<<outputRecoPlusPseudoFromB.get()->size()<<" tracks");
154  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudoFromB(m_out_recoPlusPseudoFromB, ctx);
155  ATH_CHECK(h_write_recoPlusPseudoFromB.record(std::move(outputRecoPlusPseudoFromB), std::move(outputRecoPlusPseudoFromBAux)));
156  ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudoFromB<<" to store");
157 
158  ATH_MSG_DEBUG("outputRecoPlusPseudoNotFromB has "<<outputRecoPlusPseudoNotFromB.get()->size()<<" tracks");
159  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudoNotFromB(m_out_recoPlusPseudoNotFromB, ctx);
160  ATH_CHECK(h_write_recoPlusPseudoNotFromB.record(std::move(outputRecoPlusPseudoNotFromB), std::move(outputRecoPlusPseudoNotFromBAux)));
161  ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudoNotFromB<<" to store");
162 
163  ATH_MSG_DEBUG("outputRecoNoFakes has "<<outputRecoNoFakes.get()->size()<<" tracks");
164  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakes(m_out_recoNoFakes, ctx);
165  ATH_CHECK(h_write_recoNoFakes.record(std::move(outputRecoNoFakes), std::move(outputRecoNoFakesAux)));
166  ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakes<<" to store");
167 
168  ATH_MSG_DEBUG("outputRecoNoFakesFromB has "<<outputRecoNoFakesFromB.get()->size()<<" tracks");
169  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakesFromB(m_out_recoNoFakesFromB, ctx);
170  ATH_CHECK(h_write_recoNoFakesFromB.record(std::move(outputRecoNoFakesFromB), std::move(outputRecoNoFakesFromBAux)));
171  ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakesFromB<<" to store");
172 
173  ATH_MSG_DEBUG("outputRecoNoFakesNotFromB has "<<outputRecoNoFakesNotFromB.get()->size()<<" tracks");
174  SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakesNotFromB(m_out_recoNoFakesNotFromB, ctx);
175  ATH_CHECK(h_write_recoNoFakesNotFromB.record(std::move(outputRecoNoFakesNotFromB), std::move(outputRecoNoFakesNotFromBAux)));
176  ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakesNotFromB<<" to store");
177 
178  return StatusCode::SUCCESS;
179  }
180 
182  // Select relevant pseudo tracks
184 
185  void PseudoTrackSelector::fillRecoReplacedWithPseudo(const xAOD::TrackParticleContainer* recoTrackParticleCol,
186  const xAOD::TrackParticleContainer* pseudoTrackParticleCol,
187  xAOD::TrackParticleContainer* outputCol,
188  bool onlyFromB /*= false*/,
189  bool onlyNotFromB /*= false*/) const
190  {
191  ATH_MSG_DEBUG("Start fillRecoReplacedWithPseudo with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
192  // loop over tracks, accept them and add them into output collection
193  if((recoTrackParticleCol && !recoTrackParticleCol->empty()) &&
194  (pseudoTrackParticleCol && !pseudoTrackParticleCol->empty())) {
195  ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
196  ATH_MSG_DEBUG("Size of pseudo track particle collection " << pseudoTrackParticleCol->size());
197  int n_saved = 0;
198  // loop over reco tracks
199  for(const auto *const tp_reco: *recoTrackParticleCol){
200  // Get truth particle
201  const xAOD::TruthParticle* truth_reco = getTruth(tp_reco);
202  if (truth_reco){
203  bool match_found = false;
204  // loop over pseudo tracks to look for a match
205  for(const auto *const tp_pseudo: *pseudoTrackParticleCol){
206  const xAOD::TruthParticle* truth_pseudo = getTruth(tp_pseudo);
207  if (truth_reco == truth_pseudo){
208  ATH_MSG_DEBUG("reco track has truth-matched pseudo track!");
209  match_found = true;
210  // add pseudo track into output
211  if (!onlyFromB && !onlyNotFromB){
212  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
213  outputCol->push_back(newTrackParticle);
214  n_saved++;
215  ATH_MSG_DEBUG("saving pseudo track");
216  }
217  // Check origin of track
218  int origin = m_trackOriginTool->getTrackOrigin(tp_pseudo);
219  ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
220  if (onlyFromB){
221  if (InDet::TrkOrigin::isFromB(origin)){
222  // Track is from B hadron, replace with pseudo track
223  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
224  outputCol->push_back(newTrackParticle);
225  n_saved++;
226  ATH_MSG_DEBUG("saving fromB pseudo track");
227  }
228  else{
229  // Track is not from B hadron, keep reco track
230  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
231  outputCol->push_back(newTrackParticle);
232  n_saved++;
233  ATH_MSG_DEBUG("keeping notFromB reco track");
234  }
235  }
236  if (onlyNotFromB){
237  if (!InDet::TrkOrigin::isFromB(origin)){
238  // Track is not from B hadron, replace with pseudo track
239  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
240  outputCol->push_back(newTrackParticle);
241  n_saved++;
242  ATH_MSG_DEBUG("saving notFromB pseudo track");
243  }
244  else{
245  // Track is from B hadron, keep reco track
246  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
247  outputCol->push_back(newTrackParticle);
248  n_saved++;
249  ATH_MSG_DEBUG("keeping FromB reco track");
250  }
251  }
252  // Found match and replaced relevant track
253  break;
254  }
255  else{
256  ATH_MSG_VERBOSE("truth-matched pseudo track not found yet...");
257  }
258  }
259  if(!match_found){
260  ATH_MSG_DEBUG("reco track that has truth link DOES NOT have truth-matched pseudo track! :(");
261  }
262  }
263  else{
264  ATH_MSG_DEBUG("no truth particle for reco track!");
265  }
266  }
267  ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
268  }
269  }
270 
271  void PseudoTrackSelector::fillRecoPlusPseudo(const xAOD::TrackParticleContainer* recoTrackParticleCol,
272  const xAOD::TrackParticleContainer* pseudoTrackParticleCol,
273  xAOD::TrackParticleContainer* outputCol,
274  bool onlyFromB /*= false*/,
275  bool onlyNotFromB /*= false*/) const
276  {
277  ATH_MSG_DEBUG("Start fillRecoPlusPseudo with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
278  // loop over tracks, accept them and add them into output collection
279  if((recoTrackParticleCol && !recoTrackParticleCol->empty()) &&
280  (pseudoTrackParticleCol && !pseudoTrackParticleCol->empty())) {
281  ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
282  ATH_MSG_DEBUG("Size of pseudo track particle collection " << pseudoTrackParticleCol->size());
283  int n_saved = 0;
284  // Start by keeping reco tracks
285  for(const auto *const tp_reco: *recoTrackParticleCol){
286  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
287  outputCol->push_back(newTrackParticle);
288  n_saved++;
289  }
290  // Now add pseudo tracks that are not matched to reco tracks
291  for(const auto *const tp_pseudo: *pseudoTrackParticleCol){
292  bool match_found = false;
293  const xAOD::TruthParticle* truth_pseudo = getTruth(tp_pseudo);
294  for(const auto *const tp_reco: *recoTrackParticleCol){
295  // Get truth particle
296  const xAOD::TruthParticle* truth_reco = getTruth(tp_reco);
297  if (truth_reco){
298  if (truth_reco == truth_pseudo){
299  ATH_MSG_DEBUG("reco track has truth-matched pseudo track!");
300  match_found = true;
301  break;
302  }
303  }
304  else{
305  ATH_MSG_DEBUG("no truth particle for reco track!");
306  }
307  }
308  if(!match_found){
309  ATH_MSG_DEBUG("no match found, so adding pseudo track to output");
310  if(!onlyFromB && !onlyNotFromB){
311  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
312  outputCol->push_back(newTrackParticle);
313  n_saved++;
314  ATH_MSG_DEBUG("saving pseudo track");
315  }
316  int origin = m_trackOriginTool->getTrackOrigin(tp_pseudo);
317  ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
318  if(onlyFromB && InDet::TrkOrigin::isFromB(origin)){
319  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
320  outputCol->push_back(newTrackParticle);
321  n_saved++;
322  ATH_MSG_DEBUG("saving fromB pseudo track");
323  }
324  if(onlyNotFromB && !InDet::TrkOrigin::isFromB(origin)){
325  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
326  outputCol->push_back(newTrackParticle);
327  n_saved++;
328  ATH_MSG_DEBUG("saving notFromB pseudo track");
329  }
330  }
331  else{
332  ATH_MSG_DEBUG("match found so not adding pseudo track to output");
333  }
334  }
335  ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
336  }
337  }
338 
339  void PseudoTrackSelector::fillRecoNoFakes(const xAOD::TrackParticleContainer* recoTrackParticleCol,
340  xAOD::TrackParticleContainer* outputCol,
341  bool onlyFromB /*= false*/,
342  bool onlyNotFromB /*= false*/) const
343  {
344  ATH_MSG_DEBUG("Start fillRecoNoFakes with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
345  // loop over tracks, accept them and add them into output collection
346  if((recoTrackParticleCol && !recoTrackParticleCol->empty())){
347  ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
348  int n_saved = 0;
349  static const SG::ConstAccessor< float > acc_truthProb("truthMatchProbability");
350 
351  // loop over tracks
352  for(const auto *const tp_reco: *recoTrackParticleCol){
353  // place cut on truth match probability
354  if (!onlyFromB && !onlyNotFromB){
355  if( acc_truthProb( *tp_reco ) < 0.5) {
356  ATH_MSG_DEBUG("Fake track!");
357  continue;
358  }
359  }
360  int origin = m_trackOriginTool->getTrackOrigin(tp_reco);
361  ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
362  if (onlyFromB && InDet::TrkOrigin::isFromB(origin)){
363  if( acc_truthProb( *tp_reco ) < 0.5) {
364  ATH_MSG_DEBUG("Fake track fromB!");
365  continue;
366  }
367  }
368  if (onlyNotFromB && !InDet::TrkOrigin::isFromB(origin)){
369  if( acc_truthProb( *tp_reco ) < 0.5) {
370  ATH_MSG_DEBUG("Fake track notFromB!");
371  continue;
372  }
373  }
374  // add track into output
375  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
376  outputCol->push_back(newTrackParticle);
377  n_saved++;
378  }
379  ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
380  }
381  }
382 
383  const xAOD::TruthParticle* PseudoTrackSelector::getTruth( const xAOD::TrackParticle* track ) {
384  // create a pointer to a truth particle which will correspond to this track
385  const xAOD::TruthParticle* linkedTruthParticle = nullptr;
386 
387  // if the track doesnt't have a valid truth link, skip to the next track
388  // in practice, all tracks seem to have a truth link, but we need to also
389  // check whether it's valid
390  static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
391  if ( !truthParticleLinkAcc.isAvailable(*track) ) {
392  return nullptr;
393  }
394 
395  // retrieve the link and check its validity
396  const TruthLink &link = truthParticleLinkAcc(*track);
397 
398  // a missing or invalid link implies truth particle has been dropped from
399  // the truth record at some stage - probably it was a pileup or low pT GEANT
400  // particle.
401  if(!link or !link.isValid()) {
402  return nullptr;
403  }
404 
405  // seems safe to access and return the linked truth particle
406  linkedTruthParticle = (*link);
407  return linkedTruthParticle;
408  }
409 }
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::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:339
TrackParticleAuxContainer.h
beamspotman.n
n
Definition: beamspotman.py:729
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:271
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:185
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:794
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
DerivationFramework::PseudoTrackSelector::addBranches
virtual StatusCode addBranches() const
Definition: PseudoTrackSelector.cxx:76
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:43
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:383
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
Generated on Mon Sep 1 2025 21:17:31 for ATLAS Offline Software by   doxygen 1.8.18