ATLAS Offline Software
TrigHitDVHypoAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 
4  * Trigger Hypo Tool, that is aimed at triggering displaced vertex
5  * author Kunihiro Nagano <kunihiro.nagano@cern.ch> - KEK
6 */
7 #include "TrigHitDVHypoAlg.h"
8 #include "AthViews/ViewHelper.h"
9 #include "TrigCompositeUtils/TrigCompositeUtils.h"
10 #include "GaudiKernel/SystemOfUnits.h"
11 #include "AthenaMonitoringKernel/Monitored.h"
12 #include "GaudiKernel/PhysicalConstants.h"
13 #include "PathResolver/PathResolver.h"
14 #include "xAODTrigger/jFexSRJetRoI.h"
15 
16 #include "TrigInDetPattRecoTools/TrigInDetUtils.h"
17 #include "CxxUtils/phihelper.h"
18 #include "TrigInDetToolInterfaces/ITrigSpacePointConversionTool.h"
19 
20 #include <vector>
21 #include <unordered_map>
22 
23 using TrigCompositeUtils::createAndStore;
24 using TrigCompositeUtils::DecisionContainer;
25 using TrigCompositeUtils::DecisionAuxContainer;
26 using TrigCompositeUtils::DecisionIDContainer;
27 using TrigCompositeUtils::decisionIDs;
28 using TrigCompositeUtils::newDecisionIn;
29 using TrigCompositeUtils::linkToPrevious;
30 using TrigCompositeUtils::viewString;
31 using TrigCompositeUtils::featureString;
32 using TrigCompositeUtils::hypoAlgNodeName;
33 using TrigCompositeUtils::findLink;
34 using TrigCompositeUtils::LinkInfo;
35 using TrigCompositeUtils::Decision;
36 using TrigCompositeUtils::allFailed;
37 
38 using xAOD::JetContainer;
39 
40 // ------------------------------------------------------------------------------------------------
41 // ------------------------------------------------------------------------------------------------
42 
43 TrigHitDVHypoAlg::TrigHitDVHypoAlg( const std::string& name,
44  ISvcLocator* pSvcLocator ) :
45  ::HypoBase( name, pSvcLocator ),
46  m_lumiBlockMuTool("LumiBlockMuTool/LumiBlockMuTool")
47 {}
48 
49 // ------------------------------------------------------------------------------------------------
50 // ------------------------------------------------------------------------------------------------
51 
52 StatusCode TrigHitDVHypoAlg::initialize()
53 {
54  m_tools_lowest_jetEt = 1000;
55  m_tools_loosest_wp = 0;
56  CHECK( m_hypoTools.retrieve() );
57  for ( auto & tool: m_hypoTools ) {
58  ATH_MSG_VERBOSE( "+++++ Hypo Tool name: " << tool->name() );
59  std::cmatch results;
60  if( std::regex_search(tool->name().c_str(),results,std::regex("hitdvjet(\\d+)_(\\w+)_")) ) {
61  std::string sth = results[1].str();
62  std::string swp = results[2].str();
63  ATH_MSG_VERBOSE( " thres = " << sth << ", wp = " << swp );
64  int thres = std::stoi(sth);
65  if( thres < m_tools_lowest_jetEt ) m_tools_lowest_jetEt = thres;
66  if( swp == "loose" && m_tools_loosest_wp >= 1 ) m_tools_loosest_wp = 1;
67  if( swp == "medium" && m_tools_loosest_wp >= 2 ) m_tools_loosest_wp = 2;
68  if( swp == "tight" && m_tools_loosest_wp >= 3 ) m_tools_loosest_wp = 3;
69  }
70  }
71  ATH_MSG_DEBUG( "Lowest jetEt used in hypo tools = " << m_tools_lowest_jetEt << " (GeV)" );
72  ATH_MSG_DEBUG( "Loosest WP used in hypo tools = " << m_tools_loosest_wp << " (loose=1,medium=2,tight=3)");
73  // loose : eta<2.0, SP seed=true, BDT eff=0.9
74  // medium: eta<2.0, SP seed=false, BDT eff=0.75
75  // tight : eta<1.0, SP seed=false, BDT eff=0.75
76 
77  CHECK( m_jetsKey.initialize() );
78  CHECK( m_hitDVKey.initialize());
79  CHECK( m_tracksKey.initialize());
80  CHECK( m_lumiDataKey.initialize(!m_isMC) );
81  ATH_CHECK( m_jetRoiCollectionKey.initialize(m_doHitDV_Seeding) );
82 
83  if ( !m_monTool.empty() ) CHECK( m_monTool.retrieve() );
84 
85  ATH_CHECK(m_beamSpotKey.initialize());
86  ATH_CHECK(m_spacePointTool.retrieve() );
87 
88 
89  for (auto& reader : m_tmva_reader) {
90  // Create two instances with same variables
91  auto tmva = std::array{std::make_unique<TMVA::Reader>( "!Color:!Silent" ),
92  std::make_unique<TMVA::Reader>( "!Color:!Silent" )};
93  for (auto& t : tmva) {
94  t->AddVariable("n_track_qual", &reader.n_track_qual);
95  t->AddVariable("ly0_sp_frac", &reader.ly0_sp_frac);
96  t->AddVariable("ly1_sp_frac", &reader.ly1_sp_frac);
97  t->AddVariable("ly2_sp_frac", &reader.ly2_sp_frac);
98  t->AddVariable("ly3_sp_frac", &reader.ly3_sp_frac);
99  t->AddVariable("ly4_sp_frac", &reader.ly4_sp_frac);
100  t->AddVariable("ly5_sp_frac", &reader.ly5_sp_frac);
101  t->AddVariable("ly6_sp_frac", &reader.ly6_sp_frac);
102  t->AddVariable("ly7_sp_frac", &reader.ly7_sp_frac);
103  };
104  reader.tmva_0eta1 = std::move(tmva[0]);
105  reader.tmva_1eta2 = std::move(tmva[1]);
106 
107  // --- Book the MVA methods specific to eta range
108  const std::string tuningVer = "v22a"; // "v21a";
109  const std::string methodName = "BDT method";
110 
111  const std::string weightfile_0eta1 = PathResolver::find_calib_file(
112  "TrigHitDVHypo/HitDV.BDT.weights.0eta1." + tuningVer + ".xml");
113  const std::string weightfile_1eta2 = PathResolver::find_calib_file(
114  "TrigHitDVHypo/HitDV.BDT.weights.1eta2." + tuningVer + ".xml");
115  ATH_MSG_DEBUG("opening weightfile = " << weightfile_0eta1);
116  ATH_MSG_DEBUG("opening weightfile = " << weightfile_1eta2);
117  reader.tmva_0eta1->BookMVA(methodName, weightfile_0eta1);
118  reader.tmva_1eta2->BookMVA(methodName, weightfile_1eta2);
119  }
120 
121  return StatusCode::SUCCESS;
122 }
123 
124 // ------------------------------------------------------------------------------------------------
125 // ------------------------------------------------------------------------------------------------
126 
127 StatusCode TrigHitDVHypoAlg::execute( const EventContext& context ) const
128 {
129 
130  const TrigRoiDescriptor roi = TrigRoiDescriptor(0, -4.5, 4.5, 0, -M_PI, M_PI, 0, -168.0, 168.0);
131  std::vector<TrigSiSpacePointBase> convertedSpacePoints;
132  convertedSpacePoints.reserve(5000);
133  int mnt_roi_nSPsPIX;
134  int mnt_roi_nSPsSCT;
135  ATH_CHECK(m_spacePointTool->getSpacePoints(roi, convertedSpacePoints, mnt_roi_nSPsPIX, mnt_roi_nSPsSCT, context));
136 
137  // monitoring
138  auto mon_n_dvtrks = Monitored::Scalar<int>( "n_dvtrks", 0 );
139  auto mon_n_dvsps = Monitored::Scalar<int>( "n_dvsps", 0 );
140  auto mon_n_jetseeds = Monitored::Scalar<int>( "n_jetseeds", 0 );
141  auto mon_n_jetseedsdel= Monitored::Scalar<int>( "n_jetseedsdel",0 );
142  auto mon_n_spseeds = Monitored::Scalar<int>( "n_spseeds", 0 );
143  auto mon_n_spseedsdel = Monitored::Scalar<int>( "n_spseedsdel", 0 );
144  auto mon_average_mu = Monitored::Scalar<float>( "average_mu", 0.);
145  auto monitorIt = Monitored::Group( m_monTool, mon_n_dvtrks, mon_n_dvsps, mon_n_jetseeds, mon_n_jetseedsdel, mon_n_spseeds, mon_n_spseedsdel, mon_average_mu );
146 
147  // previous decisions
148  ATH_MSG_DEBUG( "Retrieving pervious decision: \"" << decisionInput().key() << "\"" );
149  auto previousDecisionsHandle = SG::makeHandle( decisionInput(), context );
150  ATH_CHECK( previousDecisionsHandle.isValid() );
151 
152  ATH_MSG_DEBUG( "Running with " << previousDecisionsHandle->size() << " previous decisions" );
153  if( previousDecisionsHandle->size()!=1 ) {
154  ATH_MSG_ERROR( "Previous decision handle size is not 1. It is" << previousDecisionsHandle->size() );
155  return StatusCode::FAILURE;
156  }
157  const Decision * previousDecision = previousDecisionsHandle->at(0);
158 
159  TrigCompositeUtils::DecisionIDContainer previousDecisionIDs;
160  TrigCompositeUtils::decisionIDs(previousDecision, previousDecisionIDs);
161  ATH_MSG_DEBUG( "IDs of active legs:" );
162  for(auto decisionID: previousDecisionIDs) { ATH_MSG_DEBUG( " " << decisionID ); }
163 
164  // new output decisions
165  ATH_MSG_DEBUG( "Creating new output decision handle" );
166  SG::WriteHandle<DecisionContainer> outputHandle = createAndStore(decisionOutput(), context );
167  auto outputDecisions = outputHandle.ptr();
168 
169  // input objects
170 
171  // jets
172  auto jetsHandle = SG::makeHandle(m_jetsKey, context );
173  ATH_CHECK( jetsHandle.isValid() );
174  ATH_MSG_DEBUG( "jet handle size: " << jetsHandle->size() );
175 
176  const xAOD::JetContainer* jetsContainer = jetsHandle.get();
177  if( jetsContainer == nullptr ) {
178  ATH_MSG_ERROR( "ERROR Cannot get jet container" );
179  return StatusCode::FAILURE;
180  }
181  bool isJetEtPassToolsCut = false;
182  float jetEtaToolsCut = 2.0;
183  if( m_tools_loosest_wp >= 3 ) jetEtaToolsCut = 1.0;
184  for ( const xAOD::Jet* jet : *jetsContainer ) {
185  float jet_pt = static_cast<float>(jet->pt() / Gaudi::Units::GeV );
186  float jet_eta = static_cast<float>(jet->eta());
187  if( jet_pt >= m_tools_lowest_jetEt && std::abs(jet_eta)<=jetEtaToolsCut ) {
188  isJetEtPassToolsCut = true;
189  break;
190  }
191  }
192 
193  auto tracks = SG::makeHandle( m_tracksKey, context );
194  ATH_CHECK(tracks.isValid());
195 
196  std::vector<HitDVSeed> hitDVSeedsContainer;
197  std::vector<HitDVTrk> hitDVTrksContainer;
198  std::vector<HitDVSpacePoint> hitDVSPsContainer;
199 
200 
201  ATH_CHECK( findHitDV(context, convertedSpacePoints, *tracks, hitDVSeedsContainer, hitDVTrksContainer, hitDVSPsContainer) );
202 
203  mon_n_dvtrks = hitDVTrksContainer.size();
204  mon_n_dvsps = hitDVSPsContainer.size();
205  const unsigned int N_MAX_SP_STORED = 100000;
206  bool isSPOverflow = false;
207  if( hitDVSPsContainer.size() >= N_MAX_SP_STORED ) isSPOverflow = true;
208  ATH_MSG_DEBUG( "hitDVSP size=" << mon_n_dvsps );
209 
210  // average mu
211  float averageMu = 0;
212  if( m_isMC ) {
213  if( m_lumiBlockMuTool ) {
214  averageMu = static_cast<float>(m_lumiBlockMuTool->averageInteractionsPerCrossing(context));
215  ATH_MSG_DEBUG( "offline averageMu = " << averageMu );
216  }
217  }
218  else {
219  SG::ReadCondHandle<LuminosityCondData> lcd (m_lumiDataKey,context);
220  averageMu = lcd.cptr()->lbAverageInteractionsPerCrossing();
221  ATH_MSG_DEBUG( "online averageMu = " << averageMu );
222  }
223  mon_average_mu = averageMu;
224 
225  // find seeds based on HLT jets
226  std::vector<float> jetSeeds_pt;
227  std::vector<float> jetSeeds_eta;
228  std::vector<float> jetSeeds_phi;
229  ATH_CHECK( findJetSeeds(jetsContainer, m_jetSeed_ptMin, m_jetSeed_etaMax, jetSeeds_pt, jetSeeds_eta, jetSeeds_phi) );
230  int n_alljetseeds = jetSeeds_eta.size();
231  ATH_CHECK( selectSeedsNearby(hitDVSeedsContainer, jetSeeds_eta, jetSeeds_phi, jetSeeds_pt) );
232  mon_n_jetseeds = jetSeeds_eta.size();
233  mon_n_jetseedsdel = n_alljetseeds - jetSeeds_eta.size();
234 
235  // find seeds based on SP frac itself
236  std::vector<float> spSeeds_eta;
237  std::vector<float> spSeeds_phi;
238  std::vector<float> void_pt;
239  int n_allspseeds = 0;
240  if( m_tools_loosest_wp <= 1 ) {
241  ATH_CHECK( findSPSeeds(context, hitDVSPsContainer, spSeeds_eta, spSeeds_phi) );
242  n_allspseeds = spSeeds_eta.size();
243  ATH_CHECK( selectSeedsNearby(hitDVSeedsContainer, spSeeds_eta, spSeeds_phi, void_pt) );
244  mon_n_spseeds = spSeeds_eta.size();
245  mon_n_spseedsdel = n_allspseeds - spSeeds_eta.size();
246  }
247  else {
248  mon_n_spseeds = 0;
249  mon_n_spseedsdel = 0;
250  }
251 
252  // output EDM object
253  auto hitDVContainer = std::make_unique<xAOD::TrigCompositeContainer>();
254  auto hitDVContainerAux = std::make_unique<xAOD::TrigCompositeAuxContainer>();
255  hitDVContainer->setStore(hitDVContainerAux.get());
256 
257  xAOD::TrigCompositeContainer* dvContainer = hitDVContainer.get();
258  std::vector<TrigHitDVHypoTool::HitDVHypoInfo> hitDVHypoInputs;
259  std::unordered_map<Decision*, size_t> mapDecIdx;
260 
261  // calculate BDT and create hitDVContainer EDM
262  if( isJetEtPassToolsCut ) {
263  const float preselBDTthreshold = -0.6;
264 
265  int n_passed_jet = 0;
266  int seed_type = SeedType::HLTJet;
267  ATH_CHECK( calculateBDT(context, hitDVSPsContainer, hitDVTrksContainer, jetSeeds_pt, jetSeeds_eta, jetSeeds_phi, preselBDTthreshold, seed_type, dvContainer, n_passed_jet) );
268 
269  int n_passed_sp = 0;
270  if( m_tools_loosest_wp <= 1 ) {
271  seed_type = SeedType::SP;
272  ATH_CHECK( calculateBDT(context, hitDVSPsContainer, hitDVTrksContainer, void_pt, spSeeds_eta, spSeeds_phi, preselBDTthreshold, seed_type, dvContainer, n_passed_sp) );
273  }
274 
275  ATH_MSG_DEBUG( "nr of dv container / jet-seeded / sp-seed candidates = " << dvContainer->size() << " / " << n_passed_jet << " / " << n_passed_sp );
276 
277  // Prepare inputs to HypoTool
278  for ( auto dv : *dvContainer ) {
279  Decision* newDecision = TrigCompositeUtils::newDecisionIn( outputDecisions, previousDecision, TrigCompositeUtils::hypoAlgNodeName(), context);
280  mapDecIdx.emplace( newDecision, dv->index() );
281  TrigHitDVHypoTool::HitDVHypoInfo hypoInfo{ newDecision, isSPOverflow, averageMu, dv, previousDecisionIDs };
282  hitDVHypoInputs.push_back( hypoInfo );
283  }
284  }
285 
286  // monitor
287  ATH_CHECK( doMonitor(dvContainer) );
288 
289  // Loop over all hypoToolinputs and get their decisions
290  for ( auto & tool: m_hypoTools ) {
291  ATH_MSG_DEBUG( "+++++ Now computing decision for " << tool->name() );
292  ATH_CHECK( tool->decide( hitDVHypoInputs ) );
293  }
294 
295  // record hitDV object
296  SG::WriteHandle<xAOD::TrigCompositeContainer> hitDVHandle(m_hitDVKey, context);
297  ATH_CHECK( hitDVHandle.record( std::move( hitDVContainer ), std::move( hitDVContainerAux ) ) );
298  ATH_MSG_DEBUG( "recorded hitDV object to SG" );
299 
300  DecisionContainer::iterator it = outputDecisions->begin();
301  while(it != outputDecisions->end()) {
302  ATH_MSG_DEBUG( "+++++ outputDecision: " << *it << " +++++" );
303  if ( allFailed( *it ) ) {
304  ATH_MSG_DEBUG( "---> all failed, erasing" );
305  it = outputDecisions->erase(it);
306  } else {
307  ATH_MSG_DEBUG( "---> not all failed" );
308 
309  // Link hitDV object
310  auto decision = *it;
311  size_t idx = mapDecIdx.at(*it);
312 
313  ElementLink<xAOD::TrigCompositeContainer> dvEL = ElementLink<xAOD::TrigCompositeContainer>(*hitDVHandle, idx, context);
314  ATH_CHECK( dvEL.isValid() );
315 
316  ATH_CHECK( decision->setObjectLink<xAOD::TrigCompositeContainer>(featureString(), dvEL) );
317 
318  ATH_MSG_DEBUG(*decision);
319  ++it;
320  }
321  }
322 
323  //
324  ATH_CHECK( hypoBaseOutputProcessing(outputHandle) );
325 
326  //
327  return StatusCode::SUCCESS;
328 }
329 
330 // ------------------------------------------------------------------------------------------------
331 // ------------------------------------------------------------------------------------------------
332 
333 float TrigHitDVHypoAlg::deltaR2(float eta_1, float phi_1, float eta_2, float phi_2) const {
334  float dPhi = CxxUtils::wrapToPi(phi_1 - phi_2);
335  float dEta = eta_1 - eta_2;
336  return (dPhi*dPhi)+(dEta*dEta);
337 }
338 
339 // ------------------------------------------------------------------------------------------------
340 // ------------------------------------------------------------------------------------------------
341 
342 int TrigHitDVHypoAlg::getSPLayer(int layer, float eta) const
343 {
344  float abseta = std::fabs(eta);
345 
346  // if Pixel/SCT barrel, layer number is as it is
347  if( 0<=layer && layer <=7 ) {
348  ATH_MSG_VERBOSE("layer=" << layer << ", eta=" << abseta);
349  return layer;
350  }
351 
352  // for Pixel/SCT endcap, assign layer number of 0-7 depending on eta range
353 
354  int base = 0;
355 
356  //
357  const float PixBR6limit = 1.29612;
358  const float PixBR5limit = 1.45204;
359  const float PixBR4limit = 1.64909;
360  const float PixBR3limit = 1.90036;
361  const float PixBR2limit = 2.2146;
362 
363  // Pixel Endcap #1
364  base = 8;
365  if( layer==base || layer==(base+12) ) {
366  ATH_MSG_VERBOSE("Pix EC1, eta=" << abseta);
367  if( abseta > PixBR2limit ) return 2;
368  return 3;
369  }
370 
371  // Pixel Endcap #2
372  base = 9;
373  if( layer==base || layer==(base+12) ) {
374  ATH_MSG_VERBOSE("Pix EC2, eta=" << abseta);
375  if( abseta > PixBR2limit ) return 2;
376  return 3;
377  }
378 
379  // Pixel Endcap #3
380  base = 10;
381  if( layer==base || layer==(base+12) ) {
382  ATH_MSG_VERBOSE("Pix EC3, eta=" << abseta);
383  return 3;
384  }
385 
386  // SCT Endcap #1
387  base = 11;
388  if( layer==base || layer==(base+12) ) {
389  ATH_MSG_VERBOSE("Sct EC1, eta=" << abseta);
390  if( abseta < PixBR6limit ) return 7;
391  else if( abseta < PixBR5limit ) return 6;
392  return 5;
393  }
394 
395  // SCT Endcap #2
396  base = 12;
397  if( layer==base || layer==(base+12) ) {
398  ATH_MSG_VERBOSE("Sct EC2, eta=" << abseta);
399  if( abseta < PixBR5limit ) return 7;
400  else if( abseta < PixBR4limit ) return 6;
401  return 4;
402  }
403 
404  // SCT Endcap #3
405  base = 13;
406  if( layer==base || layer==(base+12) ) {
407  ATH_MSG_VERBOSE("Sct EC3, eta=" << abseta);
408  if( abseta < PixBR4limit ) return 7;
409  return 5;
410  }
411 
412  // SCT Endcap #4
413  base = 14;
414  if( layer==base || layer==(base+12) ) {
415  ATH_MSG_VERBOSE("Sct EC4, eta=" << abseta);
416  if( abseta < PixBR4limit ) return 6;
417  else if( abseta < PixBR3limit ) return 6;
418  return 4;
419  }
420 
421  // SCT Endcap #5
422  base = 15;
423  if( layer==base || layer==(base+12) ) {
424  ATH_MSG_VERBOSE("Sct EC5, eta=" << abseta);
425  if( abseta < PixBR3limit ) return 7;
426  return 5;
427  }
428 
429  // SCT Endcap #6
430  base = 16;
431  if( layer==base || layer==(base+12) ) {
432  ATH_MSG_VERBOSE("Sct EC6, eta=" << abseta);
433  if( abseta < PixBR3limit ) return 6;
434  return 4;
435  }
436 
437  // SCT Endcap #7
438  base = 17;
439  if( layer==base || layer==(base+12) ) {
440  ATH_MSG_VERBOSE("Sct EC7, eta=" << abseta);
441  if( abseta < PixBR3limit ) return 7;
442  return 5;
443  }
444 
445  // SCT Endcap #8
446  base = 18;
447  if( layer==base || layer==(base+12) ) {
448  ATH_MSG_VERBOSE("Sct EC8, eta=" << abseta);
449  if( abseta < PixBR3limit ) return 7;
450  return 6;
451  }
452 
453  // SCT Endcap #9
454  base = 19;
455  if( layer==base || layer==(base+12) ) {
456  ATH_MSG_VERBOSE("Sct EC9, eta=" << abseta);
457  return 7;
458  }
459 
460  return 0;
461 }
462 
463 // ------------------------------------------------------------------------------------------------
464 // ------------------------------------------------------------------------------------------------
465 
466 StatusCode TrigHitDVHypoAlg::doMonitor(const xAOD::TrigCompositeContainer* dvContainer ) const
467 {
468  std::vector<float> mnt_eta1_ly0_spfr;
469  std::vector<float> mnt_eta1_ly1_spfr;
470  std::vector<float> mnt_eta1_ly2_spfr;
471  std::vector<float> mnt_eta1_ly3_spfr;
472  std::vector<float> mnt_eta1_ly4_spfr;
473  std::vector<float> mnt_eta1_ly5_spfr;
474  std::vector<float> mnt_eta1_ly6_spfr;
475  std::vector<float> mnt_eta1_ly7_spfr;
476  std::vector<int> mnt_eta1_n_qtrk;
477  std::vector<float> mnt_eta1_bdtscore;
478  std::vector<float> mnt_1eta2_ly0_spfr;
479  std::vector<float> mnt_1eta2_ly1_spfr;
480  std::vector<float> mnt_1eta2_ly2_spfr;
481  std::vector<float> mnt_1eta2_ly3_spfr;
482  std::vector<float> mnt_1eta2_ly4_spfr;
483  std::vector<float> mnt_1eta2_ly5_spfr;
484  std::vector<float> mnt_1eta2_ly6_spfr;
485  std::vector<float> mnt_1eta2_ly7_spfr;
486  std::vector<int> mnt_1eta2_n_qtrk;
487  std::vector<float> mnt_1eta2_bdtscore;
488  auto mon_eta1_ly0_spfr = Monitored::Collection("eta1_ly0_spfr", mnt_eta1_ly0_spfr);
489  auto mon_eta1_ly1_spfr = Monitored::Collection("eta1_ly1_spfr", mnt_eta1_ly1_spfr);
490  auto mon_eta1_ly2_spfr = Monitored::Collection("eta1_ly2_spfr", mnt_eta1_ly2_spfr);
491  auto mon_eta1_ly3_spfr = Monitored::Collection("eta1_ly3_spfr", mnt_eta1_ly3_spfr);
492  auto mon_eta1_ly4_spfr = Monitored::Collection("eta1_ly4_spfr", mnt_eta1_ly4_spfr);
493  auto mon_eta1_ly5_spfr = Monitored::Collection("eta1_ly5_spfr", mnt_eta1_ly5_spfr);
494  auto mon_eta1_ly6_spfr = Monitored::Collection("eta1_ly6_spfr", mnt_eta1_ly6_spfr);
495  auto mon_eta1_ly7_spfr = Monitored::Collection("eta1_ly7_spfr", mnt_eta1_ly7_spfr);
496  auto mon_eta1_n_qtrk = Monitored::Collection("eta1_n_qtrk", mnt_eta1_n_qtrk);
497  auto mon_eta1_bdtscore = Monitored::Collection("eta1_bdtscore", mnt_eta1_bdtscore);
498  auto mon_1eta2_ly0_spfr = Monitored::Collection("1eta2_ly0_spfr", mnt_1eta2_ly0_spfr);
499  auto mon_1eta2_ly1_spfr = Monitored::Collection("1eta2_ly1_spfr", mnt_1eta2_ly1_spfr);
500  auto mon_1eta2_ly2_spfr = Monitored::Collection("1eta2_ly2_spfr", mnt_1eta2_ly2_spfr);
501  auto mon_1eta2_ly3_spfr = Monitored::Collection("1eta2_ly3_spfr", mnt_1eta2_ly3_spfr);
502  auto mon_1eta2_ly4_spfr = Monitored::Collection("1eta2_ly4_spfr", mnt_1eta2_ly4_spfr);
503  auto mon_1eta2_ly5_spfr = Monitored::Collection("1eta2_ly5_spfr", mnt_1eta2_ly5_spfr);
504  auto mon_1eta2_ly6_spfr = Monitored::Collection("1eta2_ly6_spfr", mnt_1eta2_ly6_spfr);
505  auto mon_1eta2_ly7_spfr = Monitored::Collection("1eta2_ly7_spfr", mnt_1eta2_ly7_spfr);
506  auto mon_1eta2_n_qtrk = Monitored::Collection("1eta2_n_qtrk", mnt_1eta2_n_qtrk);
507  auto mon_1eta2_bdtscore = Monitored::Collection("1eta2_bdtscore", mnt_1eta2_bdtscore);
508  auto monitorIt = Monitored::Group( m_monTool,
509  mon_eta1_ly0_spfr, mon_eta1_ly1_spfr, mon_eta1_ly2_spfr, mon_eta1_ly3_spfr,
510  mon_eta1_ly4_spfr, mon_eta1_ly5_spfr, mon_eta1_ly6_spfr, mon_eta1_ly7_spfr,
511  mon_eta1_n_qtrk, mon_eta1_bdtscore,
512  mon_1eta2_ly0_spfr, mon_1eta2_ly1_spfr, mon_1eta2_ly2_spfr, mon_1eta2_ly3_spfr,
513  mon_1eta2_ly4_spfr, mon_1eta2_ly5_spfr, mon_1eta2_ly6_spfr, mon_1eta2_ly7_spfr,
514  mon_1eta2_n_qtrk, mon_1eta2_bdtscore);
515 
516  //
517  for ( auto dv : *dvContainer ) {
518  int seed_type = dv->getDetail<int> ("hitDV_seed_type");
519  // do not fill sp-seeded candidates
520  if( seed_type == SeedType::SP ) continue;
521  float seed_eta = dv->getDetail<float>("hitDV_seed_eta");
522  int n_track_qual= dv->getDetail<int> ("hitDV_n_track_qual");
523  float bdt_score = dv->getDetail<float>("hitDV_bdt_score");
524  float ly0_sp_frac = dv->getDetail<float>("hitDV_ly0_sp_frac");
525  float ly1_sp_frac = dv->getDetail<float>("hitDV_ly1_sp_frac");
526  float ly2_sp_frac = dv->getDetail<float>("hitDV_ly2_sp_frac");
527  float ly3_sp_frac = dv->getDetail<float>("hitDV_ly3_sp_frac");
528  float ly4_sp_frac = dv->getDetail<float>("hitDV_ly4_sp_frac");
529  float ly5_sp_frac = dv->getDetail<float>("hitDV_ly5_sp_frac");
530  float ly6_sp_frac = dv->getDetail<float>("hitDV_ly6_sp_frac");
531  float ly7_sp_frac = dv->getDetail<float>("hitDV_ly7_sp_frac");
532  if( std::abs(seed_eta) < 1.0 ) {
533  mnt_eta1_ly0_spfr.push_back(ly0_sp_frac);
534  mnt_eta1_ly1_spfr.push_back(ly1_sp_frac);
535  mnt_eta1_ly2_spfr.push_back(ly2_sp_frac);
536  mnt_eta1_ly3_spfr.push_back(ly3_sp_frac);
537  mnt_eta1_ly4_spfr.push_back(ly4_sp_frac);
538  mnt_eta1_ly5_spfr.push_back(ly5_sp_frac);
539  mnt_eta1_ly6_spfr.push_back(ly6_sp_frac);
540  mnt_eta1_ly7_spfr.push_back(ly7_sp_frac);
541  mnt_eta1_n_qtrk.push_back(n_track_qual);
542  mnt_eta1_bdtscore.push_back(bdt_score);
543  }
544  else if( std::abs(seed_eta) < 2.0 ) {
545  mnt_1eta2_ly0_spfr.push_back(ly0_sp_frac);
546  mnt_1eta2_ly1_spfr.push_back(ly1_sp_frac);
547  mnt_1eta2_ly2_spfr.push_back(ly2_sp_frac);
548  mnt_1eta2_ly3_spfr.push_back(ly3_sp_frac);
549  mnt_1eta2_ly4_spfr.push_back(ly4_sp_frac);
550  mnt_1eta2_ly5_spfr.push_back(ly5_sp_frac);
551  mnt_1eta2_ly6_spfr.push_back(ly6_sp_frac);
552  mnt_1eta2_ly7_spfr.push_back(ly7_sp_frac);
553  mnt_1eta2_n_qtrk.push_back(n_track_qual);
554  mnt_1eta2_bdtscore.push_back(bdt_score);
555  }
556  }
557 
558  //
559  return StatusCode::SUCCESS;
560 }
561 
562 // ------------------------------------------------------------------------------------------------
563 // ------------------------------------------------------------------------------------------------
564 
565 StatusCode TrigHitDVHypoAlg::calculateBDT(const EventContext& context,
566  const std::vector<HitDVSpacePoint>& spsContainer,
567  const std::vector<HitDVTrk>& trksContainer,
568  const std::vector<float>& seeds_pt,
569  const std::vector<float>& seeds_eta, const std::vector<float>& seeds_phi,
570  const float& cutBDTthreshold, const int seed_type,
571  xAOD::TrigCompositeContainer* dvContainer, int& n_passed) const
572 {
573  if( seeds_eta.size() != seeds_phi.size() ) return StatusCode::SUCCESS;
574  n_passed = 0;
575 
576  for(unsigned int iseed=0; iseed<seeds_eta.size(); iseed++) {
577 
578  float seed_eta = seeds_eta[iseed];
579  float seed_phi = seeds_phi[iseed];
580 
581  ATH_MSG_VERBOSE("+++++ seed eta: " << seed_eta << ", phi:" << seed_phi << " +++++");
582 
583  // loop on space points
584  const int N_LAYER = 8;
585  const float DR_SQUARED_TO_REF_CUT = 0.16; // const float DR_TO_REF_CUT = 0.4;
586 
587  int n_sp_injet = 0;
588  int n_sp_injet_usedByTrk = 0;
589  int v_n_sp_injet[N_LAYER];
590  int v_n_sp_injet_usedByTrk[N_LAYER];
591  for(int i=0; i<N_LAYER; i++) { v_n_sp_injet[i]=0; v_n_sp_injet_usedByTrk[i]=0; }
592 
593  for ( const auto & spData : spsContainer ) {
594  // match within dR
595  float sp_eta = spData.eta;
596  float sp_phi = spData.phi;
597  float dR2 = deltaR2(sp_eta,sp_phi,seed_eta,seed_phi);
598  if( dR2 > DR_SQUARED_TO_REF_CUT ) continue;
599 
600  //
601  int sp_layer = (int)spData.layer;
602  int sp_trkid = (int)spData.usedTrkId;
603  bool isUsedByTrk = (sp_trkid != -1);
604 
605  int ilayer = getSPLayer(sp_layer,sp_eta);
606 
607  if( ilayer<=7 ) { // Pixel barrel or Sct barrel
608  n_sp_injet++;
609  v_n_sp_injet[ilayer]++;
610  if( isUsedByTrk ) {
611  n_sp_injet_usedByTrk++;
612  v_n_sp_injet_usedByTrk[ilayer]++;
613  }
614  }
615  }
616  ATH_MSG_VERBOSE("nr of SPs in jet: usedByTrk / all = " << n_sp_injet_usedByTrk << " / " << n_sp_injet);
617  float v_ly_sp_frac[N_LAYER];
618  for(int i=0; i<N_LAYER; i++) {
619  float frac = 0.;
620  if( v_n_sp_injet[i] > 0 ) frac = 1.0 - static_cast<float>(v_n_sp_injet_usedByTrk[i]) / static_cast<float>(v_n_sp_injet[i]);
621  v_ly_sp_frac[i] = frac;
622  ATH_MSG_VERBOSE("Layer " << i << ": frac=" << v_ly_sp_frac[i] << ", n used / all = " << v_n_sp_injet_usedByTrk[i] << " / " << v_n_sp_injet[i]);
623  }
624 
625  // loop on tracks
626  const float TRK_PT_GEV_CUT = 2.0;
627 
628  unsigned int n_qtrk_injet = 0;
629  for ( const auto& trk : trksContainer ) {
630  float trk_ptGeV = trk.pt;
631  trk_ptGeV /= Gaudi::Units::GeV;
632  if( trk_ptGeV < TRK_PT_GEV_CUT ) continue;
633  float dR2 = deltaR2(trk.eta,trk.phi,seed_eta,seed_phi);
634  if( dR2 > DR_SQUARED_TO_REF_CUT ) continue;
635  n_qtrk_injet++;
636  }
637  ATH_MSG_DEBUG("nr of all / quality tracks matched = " << trksContainer.size() << " / " << n_qtrk_injet);
638 
639  // evaluate BDT
640  bool isSeedOutOfRange = false;
641  if( n_qtrk_injet == 0 ) {
642  isSeedOutOfRange = true;
643  for(int i=0; i<N_LAYER; i++) {
644  if( std::fabs(v_ly_sp_frac[i]) > 1e-3 ) {
645  isSeedOutOfRange = false; break;
646  }
647  }
648  }
649  float bdt_score = -2.0;
650  if( ! isSeedOutOfRange ) {
651  auto& reader = *m_tmva_reader.get(context);
652  reader.n_track_qual = static_cast<float>(n_qtrk_injet);
653  reader.ly0_sp_frac = v_ly_sp_frac[0];
654  reader.ly1_sp_frac = v_ly_sp_frac[1];
655  reader.ly2_sp_frac = v_ly_sp_frac[2];
656  reader.ly3_sp_frac = v_ly_sp_frac[3];
657  reader.ly4_sp_frac = v_ly_sp_frac[4];
658  reader.ly5_sp_frac = v_ly_sp_frac[5];
659  reader.ly6_sp_frac = v_ly_sp_frac[6];
660  reader.ly7_sp_frac = v_ly_sp_frac[7];
661 
662  if ( std::abs(seed_eta) < 1 ) {
663  bdt_score = reader.tmva_0eta1->EvaluateMVA("BDT method");
664  } else if ( std::abs(seed_eta) < 2 ) {
665  bdt_score = reader.tmva_1eta2->EvaluateMVA("BDT method");
666  }
667  }
668 
669  // BDT threshold
670  if( bdt_score < cutBDTthreshold ) continue;
671 
672  // passed selection
673  ATH_MSG_VERBOSE("Passed selection");
674  n_passed++;
675 
676  // create EDM object
677  xAOD::TrigComposite *dv = new xAOD::TrigComposite();
678  dv->makePrivateStore();
679  dvContainer->push_back(dv);
680 
681  float seed_pt = 0;
682  if ( seed_type == SeedType::HLTJet ) seed_pt = seeds_pt[iseed];
683  dv->setDetail<float>("hitDV_seed_pt", seed_pt);
684  dv->setDetail<float>("hitDV_seed_eta", seed_eta);
685  dv->setDetail<float>("hitDV_seed_phi", seed_phi);
686  dv->setDetail<int> ("hitDV_seed_type", seed_type);
687  dv->setDetail<int> ("hitDV_n_track_qual", n_qtrk_injet);
688  dv->setDetail<float>("hitDV_ly0_sp_frac", v_ly_sp_frac[0]);
689  dv->setDetail<float>("hitDV_ly1_sp_frac", v_ly_sp_frac[1]);
690  dv->setDetail<float>("hitDV_ly2_sp_frac", v_ly_sp_frac[2]);
691  dv->setDetail<float>("hitDV_ly3_sp_frac", v_ly_sp_frac[3]);
692  dv->setDetail<float>("hitDV_ly4_sp_frac", v_ly_sp_frac[4]);
693  dv->setDetail<float>("hitDV_ly5_sp_frac", v_ly_sp_frac[5]);
694  dv->setDetail<float>("hitDV_ly6_sp_frac", v_ly_sp_frac[6]);
695  dv->setDetail<float>("hitDV_ly7_sp_frac", v_ly_sp_frac[7]);
696  dv->setDetail<float>("hitDV_bdt_score", bdt_score);
697 
698  ATH_MSG_VERBOSE("Created a new entry EDM");
699  }
700  ATH_MSG_DEBUG("nr of BDT passed = " << n_passed);
701 
702  //
703  return StatusCode::SUCCESS;
704 }
705 
706 // ------------------------------------------------------------------------------------------------
707 // ------------------------------------------------------------------------------------------------
708 
709 StatusCode TrigHitDVHypoAlg::findJetSeeds(const xAOD::JetContainer* jetsContainer, const float cutJetPt, const float cutJetEta,
710  std::vector<float>& jetSeeds_pt, std::vector<float>& jetSeeds_eta, std::vector<float>& jetSeeds_phi) const
711 {
712  std::vector<float> mnt_jet_pt;
713  std::vector<float> mnt_jet_eta;
714  auto mon_jet_pt = Monitored::Collection("jet_pt", mnt_jet_pt);
715  auto mon_jet_eta = Monitored::Collection("jet_eta", mnt_jet_eta);
716  auto monitorIt = Monitored::Group( m_monTool, mon_jet_pt, mon_jet_eta );
717 
718  ATH_MSG_VERBOSE("looking for jet seed with pt cut=" << cutJetPt << ", eta cut=" << cutJetEta);
719  for ( const xAOD::Jet* jet : *jetsContainer ) {
720  float jet_pt = static_cast<float>(jet->pt() / Gaudi::Units::GeV );
721  if( jet_pt < cutJetPt ) {
722  ATH_MSG_VERBOSE("Fails jet pt cut, pt = " << jet_pt);
723  continue;
724  }
725  mnt_jet_pt.push_back(jet_pt);
726  float jet_eta = static_cast<float>(jet->eta());
727  mnt_jet_eta.push_back(jet_eta);
728  if( std::fabs(jet_eta) > cutJetEta ) {
729  ATH_MSG_VERBOSE("Fails jet eta cut, eta = " << jet_eta);
730  continue;
731  }
732  float jet_phi = static_cast<float>(jet->phi());
733  jetSeeds_pt.push_back(jet_pt);
734  jetSeeds_eta.push_back(jet_eta);
735  jetSeeds_phi.push_back(jet_phi);
736  }
737  ATH_MSG_VERBOSE("nr of jet seeds=" << jetSeeds_eta.size());
738 
739  return StatusCode::SUCCESS;
740 }
741 
742 // ------------------------------------------------------------------------------------------------
743 // ------------------------------------------------------------------------------------------------
744 
745 StatusCode TrigHitDVHypoAlg::findSPSeeds( const EventContext& ctx, const std::vector<HitDVSpacePoint>& spsContainer,
746  std::vector<float>& seeds_eta, std::vector<float>& seeds_phi ) const
747 {
748  seeds_eta.clear();
749  seeds_phi.clear();
750 
751  const int NBINS_ETA = 50;
752  const float ETA_MIN = -2.5;
753  const float ETA_MAX = 2.5;
754 
755  const int NBINS_PHI = 80;
756  const float PHI_MIN = -4.0;
757  const float PHI_MAX = 4.0;
758 
759  char hname[64];
760 
761  unsigned int slotnr = ctx.slot();
762  unsigned int subSlotnr = ctx.subSlot();
763 
764  sprintf(hname,"hitdv_s%u_ss%u_ly6_h2_nsp",slotnr,subSlotnr);
765  std::unique_ptr<TH2F> ly6_h2_nsp = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
766  sprintf(hname,"hitdv_s%u_ss%u_ly7_h2_nsp",slotnr,subSlotnr);
767  std::unique_ptr<TH2F> ly7_h2_nsp = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
768 
769  sprintf(hname,"hitdv_s%u_ss%u_ly6_h2_nsp_notrk",slotnr,subSlotnr);
770  std::unique_ptr<TH2F> ly6_h2_nsp_notrk = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
771  sprintf(hname,"hitdv_s%u_ss%u_ly7_h2_nsp_notrk",slotnr,subSlotnr);
772  std::unique_ptr<TH2F> ly7_h2_nsp_notrk = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
773 
774  for ( const auto& spData : spsContainer ) {
775  int16_t sp_layer = spData.layer;
776  float sp_eta = spData.eta;
777  int ilayer = getSPLayer(sp_layer,sp_eta);
778  if( ilayer<6 ) continue;
779 
780  int sp_trkid = (int)spData.usedTrkId;
781  bool isUsedByTrk = (sp_trkid != -1);
782  float sp_phi = spData.phi;
783 
784  bool fill_out_of_pi = false;
785  float sp_phi2 = 0;
786  if( sp_phi < 0 ) {
787  sp_phi2 = 2*TMath::Pi() + sp_phi;
788  if( sp_phi2 < PHI_MAX ) fill_out_of_pi = true;
789  }
790  else {
791  sp_phi2 = -2*TMath::Pi() + sp_phi;
792  if( PHI_MIN < sp_phi2 ) fill_out_of_pi = true;
793  }
794  if( ilayer==6 ) {
795  ly6_h2_nsp->Fill(sp_eta,sp_phi);
796  if( fill_out_of_pi ) ly6_h2_nsp->Fill(sp_eta,sp_phi2);
797  if( ! isUsedByTrk ) ly6_h2_nsp_notrk->Fill(sp_eta,sp_phi);
798  if( ! isUsedByTrk && fill_out_of_pi) ly6_h2_nsp_notrk->Fill(sp_eta,sp_phi2);
799  }
800  if( ilayer==7 ) {
801  ly7_h2_nsp->Fill(sp_eta,sp_phi);
802  if( fill_out_of_pi ) ly7_h2_nsp->Fill(sp_eta,sp_phi2);
803  if( ! isUsedByTrk ) ly7_h2_nsp_notrk->Fill(sp_eta,sp_phi);
804  if( ! isUsedByTrk && fill_out_of_pi) ly7_h2_nsp_notrk->Fill(sp_eta,sp_phi2);
805  }
806  }
807 
808  ATH_MSG_VERBOSE("looking for ly6/ly6 doublet seeds");
809 
810  // (idx, sort/weight, eta, phi)
811  std::vector<std::tuple<int,float,float,float>> QT;
812 
813  for(int ly6_ieta=1; ly6_ieta<=NBINS_ETA; ly6_ieta++) {
814  float ly6_eta = (ly6_h2_nsp->GetXaxis()->GetBinLowEdge(ly6_ieta) + ly6_h2_nsp->GetXaxis()->GetBinUpEdge(ly6_ieta))/2.0;
815  for(int ly6_iphi=1; ly6_iphi<=NBINS_PHI; ly6_iphi++) {
816  float ly6_phi = (ly6_h2_nsp->GetYaxis()->GetBinLowEdge(ly6_iphi) + ly6_h2_nsp->GetYaxis()->GetBinUpEdge(ly6_iphi))/2.0;
817 
818  float ly6_nsp = ly6_h2_nsp ->GetBinContent(ly6_ieta,ly6_iphi);
819  float ly6_nsp_notrk = ly6_h2_nsp_notrk->GetBinContent(ly6_ieta,ly6_iphi);
820  float ly6_frac = ( ly6_nsp > 0 ) ? ly6_nsp_notrk / ly6_nsp : 0;
821  if( ly6_nsp < 10 || ly6_frac < 0.85 ) continue;
822 
823  float ly7_frac_max = 0;
824  float ly7_eta_max = 0;
825  float ly7_phi_max = 0;
826  for(int ly7_ieta=std::max(1,ly6_ieta-1); ly7_ieta<std::min(NBINS_ETA,ly6_ieta+1); ly7_ieta++) {
827  for(int ly7_iphi=std::max(1,ly6_iphi-1); ly7_iphi<=std::min(NBINS_PHI,ly6_iphi+1); ly7_iphi++) {
828  float ly7_nsp = ly7_h2_nsp ->GetBinContent(ly7_ieta,ly7_iphi);
829  float ly7_nsp_notrk = ly7_h2_nsp_notrk->GetBinContent(ly7_ieta,ly7_iphi);
830  float ly7_frac = ( ly7_nsp > 0 ) ? ly7_nsp_notrk / ly7_nsp : 0;
831  if( ly7_nsp < 10 ) continue;
832  if( ly7_frac > ly7_frac_max ) {
833  ly7_frac_max = ly7_frac;
834  ly7_eta_max = (ly7_h2_nsp->GetXaxis()->GetBinLowEdge(ly7_ieta) + ly7_h2_nsp->GetXaxis()->GetBinUpEdge(ly7_ieta))/2.0;
835  ly7_phi_max = (ly7_h2_nsp->GetXaxis()->GetBinLowEdge(ly7_iphi) + ly7_h2_nsp->GetXaxis()->GetBinUpEdge(ly7_iphi))/2.0;
836  }
837  }
838  }
839  if( ly7_frac_max < 0.85 ) continue;
840  //
841  float wsum = ly6_frac + ly7_frac_max;
842  float weta = (ly6_eta*ly6_frac + ly7_eta_max*ly7_frac_max) / wsum;
843  float wphi = (ly6_phi*ly6_frac + ly7_phi_max*ly7_frac_max) / wsum;
844  float w = wsum / 2.0;
845  QT.push_back(std::make_tuple(-1,w,weta,wphi));
846  }
847  }
848  ATH_MSG_VERBOSE("nr of ly6/ly7 doublet candidate seeds=" << QT.size() << ", doing clustering...");
849 
850  // sort
851  std::sort(QT.begin(), QT.end(),
852  [](const std::tuple<int,float,float,float>& lhs, const std::tuple<int,float,float,float>& rhs) {
853  return std::get<1>(lhs) > std::get<1>(rhs); } );
854 
855  // clustering
856  const double CLUSTCUT_DIST_SQUARED = 0.04; // const double CLUSTCUT_DIST = 0.2;
857  const double CLUSTCUT_SEED_FRAC = 0.9;
858 
859  std::vector<float> seeds_wsum;
860 
861  for(unsigned int i=0; i<QT.size(); i++) {
862  float phi = std::get<3>(QT[i]);
863  float eta = std::get<2>(QT[i]);
864  float w = std::get<1>(QT[i]);
865  if(i==0) {
866  seeds_eta.push_back(w*eta); seeds_phi.push_back(w*phi);
867  seeds_wsum.push_back(w);
868  continue;
869  }
870  const int IDX_INITIAL = 100;
871  float dist2_min = 100.0;
872  int idx_min = IDX_INITIAL;
873  for(unsigned j=0; j<seeds_eta.size(); j++) {
874  float ceta = seeds_eta[j]/seeds_wsum[j];
875  float cphi = seeds_phi[j]/seeds_wsum[j];
876  // intentionally calculate in this way as phi is defined beyond -Pi/Pi (no boundary)
877  float deta = std::fabs(ceta-eta);
878  float dphi = std::fabs(cphi-phi);
879  float dist2 = dphi*dphi+deta*deta;
880  if( dist2 < dist2_min ) {
881  dist2_min = dist2;
882  idx_min = j;
883  }
884  }
885  int match_idx = IDX_INITIAL;
886  if( idx_min != IDX_INITIAL ) {
887  if( dist2_min < CLUSTCUT_DIST_SQUARED ) { match_idx = idx_min; }
888  }
889  if( match_idx == IDX_INITIAL ) {
890  if( w > CLUSTCUT_SEED_FRAC && dist2_min > CLUSTCUT_DIST_SQUARED ) {
891  seeds_eta.push_back(w*eta); seeds_phi.push_back(w*phi);
892  seeds_wsum.push_back(w);
893  }
894  continue;
895  }
896  float new_eta = seeds_eta[match_idx] + w*eta;
897  float new_phi = seeds_phi[match_idx] + w*phi;
898  float new_wsum = seeds_wsum[match_idx] + w;
899  seeds_eta[match_idx] = new_eta;
900  seeds_phi[match_idx] = new_phi;
901  seeds_wsum[match_idx] = new_wsum;
902  }
903  QT.clear();
904  for(unsigned int i=0; i<seeds_eta.size(); i++) {
905  float eta = seeds_eta[i] / seeds_wsum[i];
906  float phi = seeds_phi[i] / seeds_wsum[i];
907  seeds_eta[i] = eta;
908  seeds_phi[i] = phi;
909  if( phi < -TMath::Pi() ) phi = 2*TMath::Pi() + phi;
910  if( phi > TMath::Pi() ) phi = -2*TMath::Pi() + phi;
911  seeds_phi[i] = phi;
912  }
913  ATH_MSG_VERBOSE("after clustering, nr of seeds = " << seeds_eta.size());
914 
915  // delete overlap (can happen at phi=-Pi/Pi bounadry)
916  std::vector<unsigned int> idx_to_delete;
917  for(unsigned int i=0; i<seeds_eta.size(); i++) {
918  if( std::find(idx_to_delete.begin(),idx_to_delete.end(),i) != idx_to_delete.end() ) continue;
919  float eta_i = seeds_eta[i];
920  float phi_i = seeds_phi[i];
921  for(unsigned int j=i+1; j<seeds_eta.size(); j++) {
922  if( std::find(idx_to_delete.begin(),idx_to_delete.end(),j) != idx_to_delete.end() ) continue;
923  float eta_j = seeds_eta[j];
924  float phi_j = seeds_phi[j];
925  float dR2 = deltaR2(eta_i,phi_i,eta_j,phi_j);
926  if( dR2 < CLUSTCUT_DIST_SQUARED ) idx_to_delete.push_back(j);
927  }
928  }
929  ATH_MSG_VERBOSE("nr of duplicated seeds to be removed = " << idx_to_delete.size());
930  if( idx_to_delete.size() > 0 ) {
931  std::sort(idx_to_delete.begin(),idx_to_delete.end());
932  for(unsigned int j=idx_to_delete.size(); j>0; j--) {
933  unsigned int idx = idx_to_delete[j-1];
934  seeds_eta.erase(seeds_eta.begin()+idx);
935  seeds_phi.erase(seeds_phi.begin()+idx);
936  }
937  }
938 
939  ATH_MSG_VERBOSE("nr of ly6/ly7 seeds=" << seeds_eta.size());
940 
941  // return
942  return StatusCode::SUCCESS;
943 }
944 
945 // ------------------------------------------------------------------------------------------------
946 // ------------------------------------------------------------------------------------------------
947 
948 StatusCode TrigHitDVHypoAlg::selectSeedsNearby(const std::vector<HitDVSeed>& hitDVSeedsContainer,
949  std::vector<float>& jetSeeds_eta, std::vector<float>& jetSeeds_phi, std::vector<float>& jetSeeds_pt) const
950 {
951  std::vector<unsigned int> idx_to_delete;
952  for(unsigned int idx=0; idx<jetSeeds_eta.size(); ++idx) {
953  const float DR_SQUARED_CUT_TO_FTFSEED = 0.09; // const float DR_CUT_TO_FTFSEED = 0.3;
954  float eta = jetSeeds_eta[idx];
955  float phi = jetSeeds_phi[idx];
956  float dR2min = 9999;
957  for ( const auto& seed : hitDVSeedsContainer ) {
958  float dR2 = deltaR2(eta,phi,seed.eta,seed.phi);
959  if( dR2 < dR2min ) dR2min = dR2;
960  }
961  if( dR2min > DR_SQUARED_CUT_TO_FTFSEED ) idx_to_delete.push_back(idx);
962  }
963  if( idx_to_delete.size() > 0 ) {
964  std::sort(idx_to_delete.begin(),idx_to_delete.end());
965  for(unsigned int j=idx_to_delete.size(); j>0; j--) {
966  unsigned int idx = idx_to_delete[j-1];
967  jetSeeds_eta.erase(jetSeeds_eta.begin()+idx);
968  jetSeeds_phi.erase(jetSeeds_phi.begin()+idx);
969  if( jetSeeds_pt.size() > 0 ) jetSeeds_pt.erase(jetSeeds_pt.begin()+idx);
970  }
971  }
972  return StatusCode::SUCCESS;
973 }
974 
975 // ------------------------------------------------------------------------------------------------
976 // ------------------------------------------------------------------------------------------------
977 
978 StatusCode TrigHitDVHypoAlg::findSPSeeds( const EventContext& ctx,
979  const std::vector<float>& v_sp_eta, const std::vector<float>& v_sp_phi,
980  const std::vector<int>& v_sp_layer, const std::vector<int>& v_sp_usedTrkId,
981  std::vector<float>& seeds_eta, std::vector<float>& seeds_phi ) const
982 {
983  const int NBINS_ETA = 50;
984  const float ETA_MIN = -2.5;
985  const float ETA_MAX = 2.5;
986 
987  const int NBINS_PHI = 80;
988  const float PHI_MIN = -4.0;
989  const float PHI_MAX = 4.0;
990 
991  char hname[64];
992 
993  unsigned int slotnr = ctx.slot();
994  unsigned int subSlotnr = ctx.subSlot();
995 
996  sprintf(hname,"ftf_s%u_ss%u_ly6_h2_nsp",slotnr,subSlotnr);
997  std::unique_ptr<TH2F> ly6_h2_nsp = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
998  sprintf(hname,"ftf_s%u_ss%u_ly7_h2_nsp",slotnr,subSlotnr);
999  std::unique_ptr<TH2F> ly7_h2_nsp = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
1000 
1001  sprintf(hname,"ftf_s%u_ss%u_ly6_h2_nsp_notrk",slotnr,subSlotnr);
1002  std::unique_ptr<TH2F> ly6_h2_nsp_notrk = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
1003  sprintf(hname,"ftf_s%u_ss%u_ly7_h2_nsp_notrk",slotnr,subSlotnr);
1004  std::unique_ptr<TH2F> ly7_h2_nsp_notrk = std::make_unique<TH2F>(hname,hname,NBINS_ETA,ETA_MIN,ETA_MAX,NBINS_PHI,PHI_MIN,PHI_MAX);
1005 
1006  for(unsigned int iSeed=0; iSeed<v_sp_eta.size(); ++iSeed) {
1007 
1008  int sp_layer = v_sp_layer[iSeed];
1009  float sp_eta = v_sp_eta[iSeed];
1010  int ilayer = getSPLayer(sp_layer,sp_eta);
1011  if( ilayer<6 ) continue;
1012 
1013  int sp_trkid = v_sp_usedTrkId[iSeed];
1014  bool isUsedByTrk = (sp_trkid != -1);
1015  float sp_phi = v_sp_phi[iSeed];
1016 
1017  bool fill_out_of_pi = false;
1018  float sp_phi2 = 0;
1019  if( sp_phi < 0 ) {
1020  sp_phi2 = 2*TMath::Pi() + sp_phi;
1021  if( sp_phi2 < PHI_MAX ) fill_out_of_pi = true;
1022  }
1023  else {
1024  sp_phi2 = -2*TMath::Pi() + sp_phi;
1025  if( PHI_MIN < sp_phi2 ) fill_out_of_pi = true;
1026  }
1027  if( ilayer==6 ) {
1028  ly6_h2_nsp->Fill(sp_eta,sp_phi);
1029  if( fill_out_of_pi ) ly6_h2_nsp->Fill(sp_eta,sp_phi2);
1030  if( ! isUsedByTrk ) ly6_h2_nsp_notrk->Fill(sp_eta,sp_phi);
1031  if( ! isUsedByTrk && fill_out_of_pi) ly6_h2_nsp_notrk->Fill(sp_eta,sp_phi2);
1032  }
1033  if( ilayer==7 ) {
1034  ly7_h2_nsp->Fill(sp_eta,sp_phi);
1035  if( fill_out_of_pi ) ly7_h2_nsp->Fill(sp_eta,sp_phi2);
1036  if( ! isUsedByTrk ) ly7_h2_nsp_notrk->Fill(sp_eta,sp_phi);
1037  if( ! isUsedByTrk && fill_out_of_pi) ly7_h2_nsp_notrk->Fill(sp_eta,sp_phi2);
1038  }
1039  }
1040 
1041  ATH_MSG_VERBOSE("looking for ly6/ly6 doublet seeds");
1042 
1043  // (idx, sort/weight, eta, phi)
1044  std::vector<std::tuple<int,float,float,float>> QT;
1045 
1046  for(int ly6_ieta=1; ly6_ieta<=NBINS_ETA; ly6_ieta++) {
1047  float ly6_eta = (ly6_h2_nsp->GetXaxis()->GetBinLowEdge(ly6_ieta) + ly6_h2_nsp->GetXaxis()->GetBinUpEdge(ly6_ieta))/2.0;
1048  for(int ly6_iphi=1; ly6_iphi<=NBINS_PHI; ly6_iphi++) {
1049  float ly6_phi = (ly6_h2_nsp->GetYaxis()->GetBinLowEdge(ly6_iphi) + ly6_h2_nsp->GetYaxis()->GetBinUpEdge(ly6_iphi))/2.0;
1050 
1051  float ly6_nsp = ly6_h2_nsp ->GetBinContent(ly6_ieta,ly6_iphi);
1052  float ly6_nsp_notrk = ly6_h2_nsp_notrk->GetBinContent(ly6_ieta,ly6_iphi);
1053  float ly6_frac = ( ly6_nsp > 0 ) ? ly6_nsp_notrk / ly6_nsp : 0;
1054  if( ly6_nsp < 10 || ly6_frac < 0.85 ) continue;
1055 
1056  float ly7_frac_max = 0;
1057  float ly7_eta_max = 0;
1058  float ly7_phi_max = 0;
1059  for(int ly7_ieta=std::max(1,ly6_ieta-1); ly7_ieta<std::min(NBINS_ETA,ly6_ieta+1); ly7_ieta++) {
1060  for(int ly7_iphi=std::max(1,ly6_iphi-1); ly7_iphi<=std::min(NBINS_PHI,ly6_iphi+1); ly7_iphi++) {
1061  float ly7_nsp = ly7_h2_nsp ->GetBinContent(ly7_ieta,ly7_iphi);
1062  float ly7_nsp_notrk = ly7_h2_nsp_notrk->GetBinContent(ly7_ieta,ly7_iphi);
1063  float ly7_frac = ( ly7_nsp > 0 ) ? ly7_nsp_notrk / ly7_nsp : 0;
1064  if( ly7_nsp < 10 ) continue;
1065  if( ly7_frac > ly7_frac_max ) {
1066  ly7_frac_max = ly7_frac;
1067  ly7_eta_max = (ly7_h2_nsp->GetXaxis()->GetBinLowEdge(ly7_ieta) + ly7_h2_nsp->GetXaxis()->GetBinUpEdge(ly7_ieta))/2.0;
1068  ly7_phi_max = (ly7_h2_nsp->GetXaxis()->GetBinLowEdge(ly7_iphi) + ly7_h2_nsp->GetXaxis()->GetBinUpEdge(ly7_iphi))/2.0;
1069  }
1070  }
1071  }
1072  if( ly7_frac_max < 0.85 ) continue;
1073  //
1074  float wsum = ly6_frac + ly7_frac_max;
1075  float weta = (ly6_eta*ly6_frac + ly7_eta_max*ly7_frac_max) / wsum;
1076  float wphi = (ly6_phi*ly6_frac + ly7_phi_max*ly7_frac_max) / wsum;
1077  float w = wsum / 2.0;
1078  QT.push_back(std::make_tuple(-1,w,weta,wphi));
1079  }
1080  }
1081  ATH_MSG_VERBOSE("nr of ly6/ly7 doublet candidate seeds=" << QT.size() << ", doing clustering...");
1082 
1083  // sort
1084  std::sort(QT.begin(), QT.end(),
1085  [](const std::tuple<int,float,float,float>& lhs, const std::tuple<int,float,float,float>& rhs) {
1086  return std::get<1>(lhs) > std::get<1>(rhs); } );
1087 
1088  // clustering
1089  const double CLUSTCUT_DIST_SQUARED = 0.04; // const double CLUSTCUT_DIST = 0.2;
1090  const double CLUSTCUT_SEED_FRAC = 0.9;
1091 
1092  std::vector<float> seeds_wsum;
1093 
1094  for(unsigned int i=0; i<QT.size(); i++) {
1095  float phi = std::get<3>(QT[i]);
1096  float eta = std::get<2>(QT[i]);
1097  float w = std::get<1>(QT[i]);
1098  if(i==0) {
1099  seeds_eta.push_back(w*eta); seeds_phi.push_back(w*phi);
1100  seeds_wsum.push_back(w);
1101  continue;
1102  }
1103  const int IDX_INITIAL = 100;
1104  float dist2_min = 100.0;
1105  int idx_min = IDX_INITIAL;
1106  for(unsigned j=0; j<seeds_eta.size(); j++) {
1107  float ceta = seeds_eta[j]/seeds_wsum[j];
1108  float cphi = seeds_phi[j]/seeds_wsum[j];
1109  // intentionally calculate in this way as phi is defined beyond -Pi/Pi (no boundary)
1110  float deta = std::fabs(ceta-eta);
1111  float dphi = std::fabs(cphi-phi);
1112  float dist2 = dphi*dphi+deta*deta;
1113  if( dist2 < dist2_min ) {
1114  dist2_min = dist2;
1115  idx_min = j;
1116  }
1117  }
1118  int match_idx = IDX_INITIAL;
1119  if( idx_min != IDX_INITIAL ) {
1120  if( dist2_min < CLUSTCUT_DIST_SQUARED ) { match_idx = idx_min; }
1121  }
1122  if( match_idx == IDX_INITIAL ) {
1123  if( w > CLUSTCUT_SEED_FRAC && dist2_min > CLUSTCUT_DIST_SQUARED ) {
1124  seeds_eta.push_back(w*eta); seeds_phi.push_back(w*phi);
1125  seeds_wsum.push_back(w);
1126  }
1127  continue;
1128  }
1129  float new_eta = seeds_eta[match_idx] + w*eta;
1130  float new_phi = seeds_phi[match_idx] + w*phi;
1131  float new_wsum = seeds_wsum[match_idx] + w;
1132  seeds_eta[match_idx] = new_eta;
1133  seeds_phi[match_idx] = new_phi;
1134  seeds_wsum[match_idx] = new_wsum;
1135  }
1136  QT.clear();
1137  for(unsigned int i=0; i<seeds_eta.size(); i++) {
1138  float eta = seeds_eta[i] / seeds_wsum[i];
1139  float phi = seeds_phi[i] / seeds_wsum[i];
1140  seeds_eta[i] = eta;
1141  seeds_phi[i] = phi;
1142  if( phi < -TMath::Pi() ) phi = 2*TMath::Pi() + phi;
1143  if( phi > TMath::Pi() ) phi = -2*TMath::Pi() + phi;
1144  seeds_phi[i] = phi;
1145  }
1146  ATH_MSG_VERBOSE("after clustering, nr of seeds = " << seeds_eta.size());
1147 
1148  // delete overlap (can happen at phi=-Pi/Pi bounadry)
1149  std::vector<unsigned int> idx_to_delete;
1150  for(unsigned int i=0; i<seeds_eta.size(); i++) {
1151  if( std::find(idx_to_delete.begin(),idx_to_delete.end(),i) != idx_to_delete.end() ) continue;
1152  float eta_i = seeds_eta[i];
1153  float phi_i = seeds_phi[i];
1154  for(unsigned int j=i+1; j<seeds_eta.size(); j++) {
1155  if( std::find(idx_to_delete.begin(),idx_to_delete.end(),j) != idx_to_delete.end() ) continue;
1156  float eta_j = seeds_eta[j];
1157  float phi_j = seeds_phi[j];
1158  float dR2 = deltaR2(eta_i,phi_i,eta_j,phi_j);
1159  if( dR2 < CLUSTCUT_DIST_SQUARED ) idx_to_delete.push_back(j);
1160  }
1161  }
1162  ATH_MSG_VERBOSE("nr of duplicated seeds to be removed = " << idx_to_delete.size());
1163  if( idx_to_delete.size() > 0 ) {
1164  std::sort(idx_to_delete.begin(),idx_to_delete.end());
1165  for(unsigned int j=idx_to_delete.size(); j>0; j--) {
1166  unsigned int idx = idx_to_delete[j-1];
1167  seeds_eta.erase(seeds_eta.begin()+idx);
1168  seeds_phi.erase(seeds_phi.begin()+idx);
1169  }
1170  }
1171 
1172  ATH_MSG_VERBOSE("nr of ly6/ly7 seeds=" << seeds_eta.size());
1173 
1174  // return
1175  return StatusCode::SUCCESS;
1176 }
1177 
1178 StatusCode TrigHitDVHypoAlg::findHitDV(const EventContext& ctx, const std::vector<TrigSiSpacePointBase>& convertedSpacePoints,
1179  const DataVector<Trk::Track>& tracks, std::vector<HitDVSeed>& hitDVSeedsContainer,
1180  std::vector<HitDVTrk>& hitDVTrksContainer,
1181  std::vector<HitDVSpacePoint>& hitDVSPsContainer) const
1182 {
1183  std::vector<int> v_dvtrk_id;
1184  std::vector<float> v_dvtrk_pt;
1185  std::vector<float> v_dvtrk_eta;
1186  std::vector<float> v_dvtrk_phi;
1187  std::vector<int> v_dvtrk_n_hits_inner;
1188  std::vector<int> v_dvtrk_n_hits_pix;
1189  std::vector<int> v_dvtrk_n_hits_sct;
1190  std::vector<float> v_dvtrk_a0beam;
1191  std::unordered_map<Identifier, int> umap_fittedTrack_identifier;
1192  int fittedTrack_id = -1;
1193 
1194  static constexpr float TRKCUT_PTGEV_HITDV = 0.5;
1195 
1196  for (const auto track: tracks) {
1197  float shift_x = 0; float shift_y = 0;
1198  if(m_useBeamSpot) {
1199  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
1200  FTF::getBeamSpotShift(shift_x, shift_y, **beamSpotHandle);
1201  }
1202  trackInfo theTrackInfo;
1203  bool igt = FTF::isGoodTrackUTT(track, theTrackInfo, shift_x, shift_y, TRKCUT_PTGEV_HITDV);
1204  if (not igt) {continue;}
1205 
1206  fittedTrack_id++;
1207  ATH_MSG_DEBUG("Selected track pT = " << theTrackInfo.ptGeV << " GeV");
1208 
1209 
1210  DataVector<const Trk::MeasurementBase>::const_iterator
1211  m = track->measurementsOnTrack()->begin(),
1212  me = track->measurementsOnTrack()->end ();
1213  for(; m!=me; ++m ) {
1214  const Trk::PrepRawData* prd = ((const Trk::RIO_OnTrack*)(*m))->prepRawData();
1215  if( prd == nullptr ) continue;
1216  Identifier id_prd = prd->identify();
1217  if( umap_fittedTrack_identifier.find(id_prd) == umap_fittedTrack_identifier.end() ) {
1218  umap_fittedTrack_identifier.insert(std::make_pair(id_prd,fittedTrack_id));
1219  }
1220  }
1221  float phi = track->perigeeParameters()->parameters()[Trk::phi];
1222  v_dvtrk_id.push_back(fittedTrack_id);
1223  v_dvtrk_pt.push_back(theTrackInfo.ptGeV*Gaudi::Units::GeV);
1224  v_dvtrk_eta.push_back(theTrackInfo.eta);
1225  v_dvtrk_phi.push_back(phi);
1226  v_dvtrk_n_hits_inner.push_back(theTrackInfo.n_hits_inner);
1227  v_dvtrk_n_hits_pix.push_back(theTrackInfo.n_hits_pix);
1228  v_dvtrk_n_hits_sct.push_back(theTrackInfo.n_hits_sct);
1229  v_dvtrk_a0beam.push_back(theTrackInfo.a0beam);
1230  }
1231  ATH_MSG_DEBUG("Nr of selected tracks / all = " << fittedTrack_id << " / " << tracks.size());
1232  ATH_MSG_DEBUG("Nr of Identifiers used by selected tracks = " << umap_fittedTrack_identifier.size());
1233 
1234  // space points
1235  int n_sp = 0;
1236  int n_sp_usedByTrk = 0;
1237 
1238  std::unordered_map<Identifier, int> umap_sp_identifier;
1239  umap_sp_identifier.reserve(1.3*convertedSpacePoints.size());//up to 2 Identifiers per spacepoint, end up with 1.3 from measurements
1240 
1241  auto add_to_sp_map = [&](const Trk::PrepRawData* prd) {
1242  if (prd) {
1243  Identifier id_prd = prd->identify();
1244  if( umap_sp_identifier.find(id_prd) == umap_sp_identifier.end() ) {
1245  umap_sp_identifier.insert(std::make_pair(id_prd,-1));
1246  }
1247  }
1248  };
1249 
1250  for(unsigned int iSp=0; iSp<convertedSpacePoints.size(); ++iSp) {
1251  bool isPix = convertedSpacePoints[iSp].isPixel();
1252  bool isSct = convertedSpacePoints[iSp].isSCT();
1253  if( ! isPix && ! isSct ) continue;
1254  const Trk::SpacePoint* sp = convertedSpacePoints[iSp].offlineSpacePoint();
1255  add_to_sp_map(sp->clusterList().first);
1256  add_to_sp_map(sp->clusterList().second);
1257  }
1258  int n_id_usedByTrack = 0;
1259  for(auto it=umap_sp_identifier.begin(); it!=umap_sp_identifier.end(); ++it) {
1260  Identifier id_sp = it->first;
1261  if( umap_fittedTrack_identifier.find(id_sp) != umap_fittedTrack_identifier.end() ) {
1262  umap_sp_identifier[id_sp] = umap_fittedTrack_identifier[id_sp];
1263  ++n_id_usedByTrack;
1264  }
1265  }
1266  ATH_MSG_DEBUG("Nr of SPs / Identifiers (all) / Identifiers (usedByTrack) = " << convertedSpacePoints.size() << " / " << umap_sp_identifier.size() << " / " << n_id_usedByTrack);
1267 
1268  auto sp_map_used_id = [&](const Trk::PrepRawData* prd) {
1269  int usedTrack_id = -1;
1270  if (prd) {
1271  Identifier id_prd = prd->identify();
1272  if( umap_sp_identifier.find(id_prd) != umap_sp_identifier.end() ) {
1273  usedTrack_id = umap_sp_identifier[id_prd];
1274  }
1275  }
1276  return usedTrack_id;
1277  };
1278 
1279  std::vector<float> v_sp_eta;
1280  v_sp_eta.reserve(convertedSpacePoints.size());
1281  std::vector<float> v_sp_r;
1282  v_sp_r.reserve(convertedSpacePoints.size());
1283  std::vector<float> v_sp_phi;
1284  v_sp_phi.reserve(convertedSpacePoints.size());
1285  std::vector<int> v_sp_layer;
1286  v_sp_layer.reserve(convertedSpacePoints.size());
1287  std::vector<bool> v_sp_isPix;
1288  v_sp_isPix.reserve(convertedSpacePoints.size());
1289  std::vector<bool> v_sp_isSct;
1290  v_sp_isSct.reserve(convertedSpacePoints.size());
1291  std::vector<int> v_sp_usedTrkId;
1292  v_sp_usedTrkId.reserve(convertedSpacePoints.size());
1293 
1294  for(const auto& sp : convertedSpacePoints) {
1295  bool isPix = sp.isPixel();
1296  bool isSct = sp.isSCT();
1297  if( ! isPix && ! isSct ) continue;
1298  const Trk::SpacePoint* osp = sp.offlineSpacePoint();
1299 
1300  int usedTrack_id = -1;
1301  int usedTrack_id_first = sp_map_used_id(osp->clusterList().first);
1302  if (usedTrack_id_first != -1) {
1303  usedTrack_id = usedTrack_id_first;
1304  }
1305  int usedTrack_id_second = sp_map_used_id(osp->clusterList().second);
1306  if (usedTrack_id_second != -1) {
1307  usedTrack_id = usedTrack_id_second;
1308  }
1309 
1310  //
1311  n_sp++;
1312  if( usedTrack_id != -1 ) n_sp_usedByTrk++;
1313  int layer = sp.layer();
1314  float sp_r = sp.r();
1315 
1316  const Amg::Vector3D& pos_sp = osp->globalPosition();//Go back to globalPosition to get the non-shifted spacepoint positions
1317  float sp_eta = pos_sp.eta();
1318  float sp_phi = pos_sp.phi();
1319 
1320  v_sp_eta.push_back(sp_eta);
1321  v_sp_r.push_back(sp_r);
1322  v_sp_phi.push_back(sp_phi);
1323  v_sp_layer.push_back(layer);
1324  v_sp_isPix.push_back(isPix);
1325  v_sp_isSct.push_back(isSct);
1326  v_sp_usedTrkId.push_back(usedTrack_id);
1327 
1328  ATH_MSG_VERBOSE("+++ SP eta / phi / layer / ixPix / usedTrack_id = " << sp_eta << " / " << sp_phi << " / " << layer << " / " << isPix << " / " << usedTrack_id);
1329 
1330  }
1331  ATH_MSG_DEBUG("Nr of SPs / all = " << n_sp << " / " << convertedSpacePoints.size());
1332  ATH_MSG_DEBUG("Nr of SPs used by selected tracks = " << n_sp_usedByTrk);
1333 
1334  // Seed
1335  std::vector<float> v_seeds_eta;
1336  std::vector<float> v_seeds_phi;
1337  std::vector<int16_t> v_seeds_type;
1338 
1339  if( m_doHitDV_Seeding ) {
1340 
1341  // add L1 Jet seeds
1342  const unsigned int L1JET_ET_CUT = 27; // Mapping from legacy J30, make configurable?
1343 
1344  auto jetRoiCollectionHandle = SG::makeHandle( m_jetRoiCollectionKey, ctx );
1345  const DataVector<xAOD::jFexSRJetRoI> *jetRoiCollection = jetRoiCollectionHandle.cptr();
1346  if (!jetRoiCollectionHandle.isValid()){
1347  ATH_MSG_ERROR("ReadHandle for DataVector<xAOD::jFexSRJetRoI> key:" << m_jetRoiCollectionKey.key() << " isn't Valid");
1348  return StatusCode::FAILURE;
1349  }
1350  for (size_t size=0; size<jetRoiCollection->size(); ++size){
1351  const xAOD::jFexSRJetRoI* jetRoI = jetRoiCollection->at(size);
1352  if( jetRoI == nullptr ) continue;
1353  // Good seed
1354  if( jetRoI->et() >= L1JET_ET_CUT ) {
1355  v_seeds_eta.push_back(jetRoI->eta());
1356  v_seeds_phi.push_back(jetRoI->phi());
1357  v_seeds_type.push_back(0); // L1_J:0
1358  }
1359  }
1360  ATH_MSG_DEBUG("Nr of L1_J" << L1JET_ET_CUT << " seeds = " << v_seeds_eta.size());
1361 
1362  // space-point based (unseeded mode)
1363  std::vector<float> v_spseeds_eta;
1364  std::vector<float> v_spseeds_phi;
1365  ATH_CHECK( findSPSeeds(ctx, v_sp_eta, v_sp_phi, v_sp_layer, v_sp_usedTrkId, v_spseeds_eta, v_spseeds_phi) );
1366  ATH_MSG_DEBUG("Nr of SP seeds = " << v_spseeds_eta.size());
1367  for(size_t idx=0; idx<v_spseeds_eta.size(); ++idx) {
1368  v_seeds_eta.push_back(v_spseeds_eta[idx]);
1369  v_seeds_phi.push_back(v_spseeds_phi[idx]);
1370  v_seeds_type.push_back(1); // SP: 1
1371  }
1372  ATH_MSG_DEBUG("Nr of SP + L1_J" << L1JET_ET_CUT << " seeds = " << v_seeds_eta.size());
1373  }
1374 
1375  // fill objects
1376 
1377  // seeds
1378  const int N_MAX_SEEDS = 200;
1379  int n_seeds = std::min(N_MAX_SEEDS,(int)v_seeds_eta.size());
1380  hitDVSeedsContainer.reserve(n_seeds);
1381  for(auto iSeed=0; iSeed < n_seeds; ++iSeed) {
1382  HitDVSeed seed;
1383  seed.eta = v_seeds_eta[iSeed];
1384  seed.phi = v_seeds_phi[iSeed];
1385  seed.type = v_seeds_type[iSeed];
1386  hitDVSeedsContainer.push_back(seed);
1387  }
1388 
1389  // track
1390  const float TRKCUT_DELTA_R_TO_SEED = 1.0;
1391  hitDVTrksContainer.reserve(v_dvtrk_pt.size());
1392  for(unsigned int iTrk=0; iTrk<v_dvtrk_pt.size(); ++iTrk) {
1393  float trk_eta = v_dvtrk_eta[iTrk];
1394  float trk_phi = v_dvtrk_phi[iTrk];
1395  if( m_doHitDV_Seeding ) {
1396  bool isNearSeed = false;
1397  for (unsigned int iSeed=0; iSeed<v_seeds_eta.size(); ++iSeed) {
1398  float seed_eta = v_seeds_eta[iSeed];
1399  float seed_phi = v_seeds_phi[iSeed];
1400  float dR2 = deltaR2(trk_eta,trk_phi,seed_eta,seed_phi);
1401  if( dR2 <= TRKCUT_DELTA_R_TO_SEED*TRKCUT_DELTA_R_TO_SEED ) { isNearSeed = true; break; }
1402  }
1403  if( ! isNearSeed ) continue;
1404  }
1405  HitDVTrk hitDVTrk;
1406  hitDVTrk.id = v_dvtrk_id[iTrk];
1407  hitDVTrk.pt = v_dvtrk_pt[iTrk];
1408  hitDVTrk.eta = v_dvtrk_eta[iTrk];
1409  hitDVTrk.phi = v_dvtrk_phi[iTrk];
1410  hitDVTrk.n_hits_inner = v_dvtrk_n_hits_inner[iTrk];
1411  hitDVTrk.n_hits_pix = v_dvtrk_n_hits_pix[iTrk];
1412  hitDVTrk.n_hits_sct = v_dvtrk_n_hits_sct[iTrk];
1413  hitDVTrk.a0beam = v_dvtrk_a0beam[iTrk];
1414 
1415  hitDVTrksContainer.push_back(hitDVTrk);
1416  }
1417 
1418  // space points
1419  const float SPCUT_DELTA_R_TO_SEED = 1.0;
1420  const size_t n_sp_max = std::min<size_t>(100000, v_sp_eta.size());
1421  size_t n_sp_stored = 0;
1422 
1423  hitDVSPsContainer.reserve(n_sp_max);
1424 
1425  for(size_t iSp=0; iSp<v_sp_eta.size(); ++iSp) {
1426  if( m_doHitDV_Seeding ) {
1427  const float sp_eta = v_sp_eta[iSp];
1428  const float sp_phi = v_sp_phi[iSp];
1429  bool isNearSeed = false;
1430  for (size_t iSeed=0; iSeed<v_seeds_eta.size(); ++iSeed) {
1431  const float seed_eta = v_seeds_eta[iSeed];
1432  const float seed_phi = v_seeds_phi[iSeed];
1433  const float dR2 = deltaR2(sp_eta, sp_phi, seed_eta, seed_phi);
1434  if( dR2 <= SPCUT_DELTA_R_TO_SEED*SPCUT_DELTA_R_TO_SEED ) { isNearSeed = true; break; }
1435  }
1436  if( ! isNearSeed ) continue;
1437  }
1438  if( n_sp_stored >= n_sp_max ) break;
1439  HitDVSpacePoint hitDVSP;
1440  hitDVSP.eta = v_sp_eta[iSp];
1441  hitDVSP.r = v_sp_r[iSp];
1442  hitDVSP.phi = v_sp_phi[iSp];
1443  hitDVSP.layer = v_sp_layer[iSp];
1444  hitDVSP.isPix = v_sp_isPix[iSp];
1445  hitDVSP.isSct = v_sp_isSct[iSp];
1446  hitDVSP.usedTrkId = v_sp_usedTrkId[iSp];
1447  hitDVSPsContainer.push_back(hitDVSP);
1448  ++n_sp_stored;
1449  }
1450  ATH_MSG_DEBUG("Nr of SPs stored = " << n_sp_stored);
1451 
1452  return StatusCode::SUCCESS;
1453 }
TrigHitDVHypoAlg::calculateBDT
StatusCode calculateBDT(const EventContext &, const std::vector< HitDVSpacePoint > &, const std::vector< HitDVTrk > &, const std::vector< float > &, const std::vector< float > &, const std::vector< float > &, const float &, const int, xAOD::TrigCompositeContainer *, int &) const
Definition: TrigHitDVHypoAlg.cxx:565
Trk::SpacePoint::clusterList
const std::pair< const PrepRawData *, const PrepRawData * > & clusterList() const
return the pair of cluster pointers by reference
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:127
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
HitDVSpacePoint::isPix
bool isPix
Definition: TrigHitDVHypoAlg.h:57
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
base
std::string base
Definition: hcg.cxx:78
PathResolver::find_calib_file
static std::string find_calib_file(const std::string &logical_file_name)
Definition: PathResolver.cxx:384
Trk::SpacePoint
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:35
TrigHitDVHypoAlg::TrigHitDVHypoAlg
TrigHitDVHypoAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TrigHitDVHypoAlg.cxx:43
HitDVTrk::n_hits_inner
int16_t n_hits_inner
Definition: TrigHitDVHypoAlg.h:46
xAOD::jFexSRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexSRJetRoI_v1.h:23
verify_menu_config.results
results
Definition: verify_menu_config.py:67
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
trackInfo::ptGeV
float ptGeV
Definition: TrigInDetUtils.h:15
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
trackInfo::n_hits_inner
int n_hits_inner
Definition: TrigInDetUtils.h:14
HitDVSpacePoint::r
float r
Definition: TrigHitDVHypoAlg.h:54
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
PlotCalibFromCool.dv
dv
Definition: PlotCalibFromCool.py:762
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
TrigCompositeUtils::DecisionContainer
xAOD::TrigCompositeContainer DecisionContainer
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigCompositeContainer.h:21
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
FTF::isGoodTrackUTT
bool isGoodTrackUTT(const Trk::Track *track, trackInfo &theTrackInfo, const float shift_x, const float shift_y, float trkcut_ptgev)
Definition: TrigInDetUtils.cxx:4
TrigHitDVHypoAlg::m_spacePointTool
ToolHandle< ITrigSpacePointConversionTool > m_spacePointTool
Definition: TrigHitDVHypoAlg.h:72
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::TrigComposite
TrigComposite_v1 TrigComposite
Declare the latest version of the class.
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:16
Trk::SpacePoint::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
Interface method to get the global Position.
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:146
TrigL2MuonSA::N_LAYER
constexpr int N_LAYER
Definition: MuonRoad.h:17
HitDVSpacePoint
Definition: TrigHitDVHypoAlg.h:52
dqt_zlumi_pandas.hname
string hname
Definition: dqt_zlumi_pandas.py:279
TrigCompositeUtils::newDecisionIn
Decision * newDecisionIn(DecisionContainer *dc, const std::string &name)
Helper method to create a Decision object, place it in the container and return a pointer to it.
Definition: TrigCompositeUtilsRoot.cxx:46
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
TrigCompositeUtils::hypoAlgNodeName
const std::string & hypoAlgNodeName()
Definition: TrigCompositeUtilsRoot.cxx:904
CxxUtils::wrapToPi
T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition: phihelper.h:24
TrigHitDVHypoAlg::m_jetRoiCollectionKey
SG::ReadHandleKey< xAOD::jFexSRJetRoIContainer > m_jetRoiCollectionKey
Definition: TrigHitDVHypoAlg.h:137
skel.it
it
Definition: skel.GENtoEVGEN.py:396
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrigHitDVHypoAlg::m_useBeamSpot
bool m_useBeamSpot
Definition: TrigHitDVHypoAlg.h:131
DataVector::get
const T * get(size_type n) const
Access an element, as an rvalue.
HypoBase::decisionInput
const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > & decisionInput() const
methods for derived classes to access handles of the base class input other read/write handles may be...
Definition: HypoBase.cxx:16
TrigHitDVHypoAlg::m_tools_loosest_wp
int m_tools_loosest_wp
Definition: TrigHitDVHypoAlg.h:128
TrigHitDVHypoAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: TrigHitDVHypoAlg.h:96
TrigCompositeUtils::createAndStore
SG::WriteHandle< DecisionContainer > createAndStore(const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx)
Creates and right away records the DecisionContainer with the key.
Definition: TrigCompositeUtilsRoot.cxx:30
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
xAOD::jFexSRJetRoI_v1::eta
float eta() const
xAOD::jFexSRJetRoI_v1::phi
float phi() const
FTF::getBeamSpotShift
void getBeamSpotShift(float &shift_x, float &shift_y, const InDet::BeamSpotData &beamSpotHandle)
Definition: TrigInDetUtils.cxx:30
HitDVTrk::phi
float phi
Definition: TrigHitDVHypoAlg.h:45
HitDVTrk::pt
float pt
Definition: TrigHitDVHypoAlg.h:43
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
HitDVSeed
Definition: TrigHitDVHypoAlg.h:35
ViewHelper.h
xAOD::int16_t
setScaleOne setStatusOne setSaturated int16_t
Definition: gFexGlobalRoI_v1.cxx:55
HypoBase::decisionOutput
const SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > & decisionOutput() const
methods for derived classes to access handles of the base class output other read/write handles may b...
Definition: HypoBase.cxx:20
HitDVTrk::a0beam
float a0beam
Definition: TrigHitDVHypoAlg.h:49
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
TrigHitDVHypoAlg::m_jetSeed_etaMax
Gaudi::Property< float > m_jetSeed_etaMax
Definition: TrigHitDVHypoAlg.h:88
TrigHitDVHypoTool::HitDVHypoInfo
Definition: TrigHitDVHypoTool.h:35
PrepareReferenceFile.regex
regex
Definition: PrepareReferenceFile.py:43
HitDVTrk::n_hits_pix
int16_t n_hits_pix
Definition: TrigHitDVHypoAlg.h:47
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TrigInDetUtils.h
trackInfo::eta
float eta
Definition: TrigInDetUtils.h:15
TrigCompositeUtils.h
TrigHitDVHypoAlg::deltaR2
float deltaR2(float, float, float, float) const
Definition: TrigHitDVHypoAlg.cxx:333
HitDVSpacePoint::phi
float phi
Definition: TrigHitDVHypoAlg.h:55
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
jFexSRJetRoI.h
TrigHitDVHypoAlg::m_doHitDV_Seeding
bool m_doHitDV_Seeding
Definition: TrigHitDVHypoAlg.h:135
trackInfo::n_hits_pix
int n_hits_pix
Definition: TrigInDetUtils.h:14
perfmonmt-refit.idx_min
idx_min
Definition: perfmonmt-refit.py:83
TrigHitDVHypoAlg::selectSeedsNearby
StatusCode selectSeedsNearby(const std::vector< HitDVSeed > &hitDVSeedsContainer, std::vector< float > &jetSeeds_eta, std::vector< float > &jetSeeds_phi, std::vector< float > &jetSeeds_pt) const
Definition: TrigHitDVHypoAlg.cxx:948
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
HitDVTrk::n_hits_sct
int16_t n_hits_sct
Definition: TrigHitDVHypoAlg.h:48
lumiFormat.i
int i
Definition: lumiFormat.py:85
HypoBase::hypoBaseOutputProcessing
StatusCode hypoBaseOutputProcessing(SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &outputHandle, MSG::Level lvl=MSG::DEBUG) const
Base class function to be called once slice specific code has finished. Handles debug printing and va...
Definition: HypoBase.cxx:33
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
checkxAOD.frac
frac
Definition: Tools/PyUtils/bin/checkxAOD.py:259
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:538
TrigHitDVHypoAlg::m_lumiBlockMuTool
ToolHandle< ILumiBlockMuTool > m_lumiBlockMuTool
Definition: TrigHitDVHypoAlg.h:81
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
trackInfo::n_hits_sct
int n_hits_sct
Definition: TrigInDetUtils.h:14
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
TrigHitDVHypoAlg::doMonitor
StatusCode doMonitor(const xAOD::TrigCompositeContainer *) const
Definition: TrigHitDVHypoAlg.cxx:466
TrigHitDVHypoAlg::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: TrigHitDVHypoAlg.h:138
Monitored.h
Header file to be included by clients of the Monitored infrastructure.
trackInfo
Definition: TrigInDetUtils.h:13
TrigCompositeUtils::DecisionAuxContainer
xAOD::TrigCompositeAuxContainer DecisionAuxContainer
Definition: TrigCompositeAuxContainer.h:20
ITrigSpacePointConversionTool.h
TrigHitDVHypoAlg.h
lumiFormat.array
array
Definition: lumiFormat.py:91
Trk::PrepRawData
Definition: PrepRawData.h:62
TrigCompositeUtils::featureString
const std::string & featureString()
Definition: TrigCompositeUtilsRoot.cxx:884
keylayer_zslicemap.isPix
isPix
Definition: keylayer_zslicemap.py:127
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
PathResolver.h
TrigHitDVHypoAlg::findJetSeeds
StatusCode findJetSeeds(const xAOD::JetContainer *, const float, const float, std::vector< float > &, std::vector< float > &, std::vector< float > &) const
Definition: TrigHitDVHypoAlg.cxx:709
trackInfo::a0beam
float a0beam
Definition: TrigInDetUtils.h:15
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
TrigHitDVHypoAlg::m_tracksKey
SG::ReadHandleKey< TrackCollection > m_tracksKey
Definition: TrigHitDVHypoAlg.h:78
HypoBase
Hypothesis algorithms take the output of reco algorithms and the decision from the preceeding InputMa...
Definition: HypoBase.h:13
TrigCompositeUtils::Decision
xAOD::TrigComposite Decision
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:20
LuminosityCondData::lbAverageInteractionsPerCrossing
float lbAverageInteractionsPerCrossing() const
Definition: LuminosityCondData.cxx:26
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:453
TrigHitDVHypoAlg::execute
virtual StatusCode execute(const EventContext &context) const override
Definition: TrigHitDVHypoAlg.cxx:127
HitDVTrk::eta
float eta
Definition: TrigHitDVHypoAlg.h:44
phihelper.h
Helper for azimuthal angle calculations.
TrigHitDVHypoAlg::m_jetsKey
SG::ReadHandleKey< xAOD::JetContainer > m_jetsKey
Definition: TrigHitDVHypoAlg.h:76
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TrigHitDVHypoAlg::m_hitDVKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_hitDVKey
Definition: TrigHitDVHypoAlg.h:77
TrigHitDVHypoAlg::initialize
virtual StatusCode initialize() override
Definition: TrigHitDVHypoAlg.cxx:52
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
TrigHitDVHypoAlg::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition: TrigHitDVHypoAlg.h:83
TrigHitDVHypoAlg::m_isMC
Gaudi::Property< bool > m_isMC
Definition: TrigHitDVHypoAlg.h:85
HitDVSpacePoint::layer
int16_t layer
Definition: TrigHitDVHypoAlg.h:56
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
TrigCompositeUtils::linkToPrevious
void linkToPrevious(Decision *d, const std::string &previousCollectionKey, size_t previousIndex)
Links to the previous object, location of previous 'seed' decision supplied by hand.
Definition: TrigCompositeUtilsRoot.cxx:139
TrigCompositeUtils::LinkInfo
Helper to keep a Decision object, ElementLink and ActiveState (with respect to some requested ChainGr...
Definition: LinkInfo.h:28
TrigCompositeUtils::DecisionIDContainer
std::set< DecisionID > DecisionIDContainer
Definition: TrigComposite_v1.h:28
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
TrigHitDVHypoAlg::m_jetSeed_ptMin
Gaudi::Property< float > m_jetSeed_ptMin
Definition: TrigHitDVHypoAlg.h:87
TrigCompositeUtils::findLink
LinkInfo< T > findLink(const Decision *start, const std::string &linkName, const bool suppressMultipleLinksWarning=false)
Perform a recursive search for ElementLinks of type T and name 'linkName', starting from Decision obj...
HitDVSpacePoint::eta
float eta
Definition: TrigHitDVHypoAlg.h:53
TrigHitDVHypoAlg::findSPSeeds
StatusCode findSPSeeds(const EventContext &, const std::vector< HitDVSpacePoint > &, std::vector< float > &, std::vector< float > &) const
Definition: TrigHitDVHypoAlg.cxx:745
TrigCompositeUtils::allFailed
bool allFailed(const Decision *d)
return true if there is no positive decision stored
Definition: TrigCompositeUtilsRoot.cxx:103
TrigCompositeUtils::decisionIDs
void decisionIDs(const Decision *d, DecisionIDContainer &destination)
Extracts DecisionIDs stored in the Decision object.
Definition: TrigCompositeUtilsRoot.cxx:67
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
HitDVSpacePoint::usedTrkId
int16_t usedTrkId
Definition: TrigHitDVHypoAlg.h:59
Trk::phi
@ phi
Definition: ParamDefs.h:75
Trk::jet_phi
@ jet_phi
Definition: JetVtxParamDefs.h:28
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
xAOD::JetContainer
JetContainer_v1 JetContainer
Definition of the current "jet container version".
Definition: JetContainer.h:17
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
TrigHitDVHypoAlg::m_hypoTools
ToolHandleArray< TrigHitDVHypoTool > m_hypoTools
Definition: TrigHitDVHypoAlg.h:73
collisions.reader
reader
read the goodrunslist xml file(s)
Definition: collisions.py:22
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
TrigHitDVHypoAlg::findHitDV
StatusCode findHitDV(const EventContext &ctx, const std::vector< TrigSiSpacePointBase > &convertedSpacePoints, const DataVector< Trk::Track > &tracks, std::vector< HitDVSeed > &hitDVSeedsContainer, std::vector< HitDVTrk > &hitDVTrksContainer, std::vector< HitDVSpacePoint > &hitDVSPContainer) const
Definition: TrigHitDVHypoAlg.cxx:1178
TauGNNUtils::Variables::Track::dEta
bool dEta(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:527
TrigHitDVHypoAlg::m_tools_lowest_jetEt
int m_tools_lowest_jetEt
Definition: TrigHitDVHypoAlg.h:127
HitDVTrk::id
int id
Definition: TrigHitDVHypoAlg.h:42
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TrigCompositeUtils::viewString
const std::string & viewString()
Definition: TrigCompositeUtilsRoot.cxx:880
HitDVSpacePoint::isSct
bool isSct
Definition: TrigHitDVHypoAlg.h:58
HitDVTrk
Definition: TrigHitDVHypoAlg.h:41
TrigHitDVHypoAlg::getSPLayer
int getSPLayer(int, float) const
Definition: TrigHitDVHypoAlg.cxx:342
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition: ReadCondHandle.h:67
xAOD::jFexSRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition: jFexSRJetRoI_v1.cxx:138
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Dec 23 2024 21:21:18 for ATLAS Offline Software by   doxygen 1.8.18