ATLAS Offline Software
Loading...
Searching...
No Matches
MuFastSteering.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
4
5#include "MuFastSteering.h"
10#include "xAODTrigger/MuonRoI.h"
11
12#include "CxxUtils/phihelper.h"
15
17
18// --------------------------------------------------------------------------------
19// --------------------------------------------------------------------------------
20
21MuFastSteering::MuFastSteering(const std::string& name, ISvcLocator* svc)
22 : AthReentrantAlgorithm(name, svc),
24{
25}
26// --------------------------------------------------------------------------------
27// --------------------------------------------------------------------------------
28
30{
31 // Locate DataPreparator
32 ATH_CHECK(m_dataPreparator.retrieve());
33
34 // Locate PatternFinder
35 ATH_CHECK(m_patternFinder.retrieve());
36
37 // Locate StationFitter
38 ATH_CHECK(m_stationFitter.retrieve());
39
40 // Locate TrackFitter
41 ATH_CHECK(m_trackFitter.retrieve());
42
43 // Locate TrackExtrapolator
45
46 // BackExtrapolator services
48
49 // CscSegmentMaker
50 ATH_CHECK(m_cscsegmaker.retrieve());
51
52 // FtfRoadDefiner
53 ATH_CHECK(m_ftfRoadDefiner.retrieve());
54
55 // Set service tools
56 m_trackExtrapolator->setExtrapolatorTool(&m_backExtrapolatorTool);
57 m_dataPreparator->setExtrapolatorTool(&m_backExtrapolatorTool);
58
59 // set road width in case TGC/RPC readout failure
61
62 m_dataPreparator->setRpcGeometry(m_use_rpc);
63
64 // set the flag whether to use NSW or not
65 m_dataPreparator->setStgcGeometry(m_use_stgc);
66 m_dataPreparator->setMmGeometry(m_use_mm);
67
74
75 // set data or MC flag
77
81 m_trackFitter -> setUseEIFromBarrel( m_use_endcapInnerFromBarrel );
82
83 // initialize handle keys.
84 ATH_CHECK(m_eventInfoKey.initialize());
85 ATH_CHECK(m_roiCollectionKey.initialize());
88 // for Inside-Out mode ---
91 // ----
92 ATH_CHECK(m_muFastContainerKey.initialize());
93 ATH_CHECK(m_muIdContainerKey.initialize());
95
96
97 ATH_CHECK(m_muMsContainerKey.initialize());
98 if (not m_monTool.name().empty()) {
99 ATH_CHECK(m_monTool.retrieve());
100 }
101 ATH_MSG_DEBUG( "topoRoad = " << m_topoRoad);
102
103 if (m_fill_FSIDRoI) {
104 ATH_MSG_INFO("will fill " << m_muIdContainerKey.key() << " in Full Scan mode. Please check if it's correct.");
105 }
106
107 ATH_MSG_DEBUG("InsideOutMode: " << m_insideOut);
108 ATH_MSG_DEBUG("Multi-TrackMode: " << m_multiTrack << "/ run for endcap RoI -> " << m_doEndcapForl2mt);
109
110 //
111 // Initialize the calibration streamer
112 ATH_CHECK(m_calStreamer.retrieve(EnableTool(m_calDataScouting)));
113
114 return StatusCode::SUCCESS;
115}
116
117
118// --------------------------------------------------------------------------------
119// --------------------------------------------------------------------------------
120
121const LVL1::RecMuonRoI* matchingRecRoI( uint32_t roiWord,
122 const DataVector<LVL1::RecMuonRoI>& collection )
123{
124 for ( auto recRoI: collection ) {
125 if ( recRoI->roiWord() == roiWord ){
126 return recRoI;
127 }
128 }
129 return nullptr;
130}
131
132// --------------------------------------------------------------------------------
133// --------------------------------------------------------------------------------
134
135const xAOD::MuonRoI* matchingRecRoI( uint32_t roiWord,
136 const xAOD::MuonRoIContainer& collection )
137{
138 for ( auto recRoI: collection ) {
139 if ( recRoI->roiWord() == roiWord ){
140 return recRoI;
141 }
142 }
143 return nullptr;
144}
145
146// --------------------------------------------------------------------------------
147// --------------------------------------------------------------------------------
148
149StatusCode MuFastSteering::execute(const EventContext& ctx) const
150{
151 if(!m_useRun3Config) {
152 ATH_MSG_ERROR("You are not supposed to run trigger on RUN2 layout anymore.");
153 return StatusCode::FAILURE;
154 }
155
156 auto totalTimer = Monitored::Timer( "TIME_Total" );
157 auto monitorIt = Monitored::Group(m_monTool, totalTimer );
158
159 // retrieve with ReadHandle
160 auto roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
161 const TrigRoiDescriptorCollection *roiCollection = roiCollectionHandle.cptr();
162 if (!roiCollectionHandle.isValid()){
163 ATH_MSG_ERROR("ReadHandle for TrigRoiDescriptorCollection key:" << m_roiCollectionKey.key() << " isn't Valid");
164 return StatusCode::FAILURE;
165 }
166
167 auto recRoiCollectionHandle = SG::makeHandle( m_recRoiCollectionKey, ctx );
168 const xAOD::MuonRoIContainer *recRoiCollection = recRoiCollectionHandle.cptr();
169 if (!recRoiCollectionHandle.isValid()){
170 ATH_MSG_ERROR("ReadHandle for xAOD::MuonRoIContainer key:" << m_recRoiCollectionKey.key() << " isn't Valid");
171 return StatusCode::FAILURE;
172 }
173
174 std::vector< const TrigRoiDescriptor* > internalRoI;
175 TrigRoiDescriptorCollection::const_iterator p_roids = roiCollection->begin();
176 TrigRoiDescriptorCollection::const_iterator p_roidsEn = roiCollection->end();
177
178 for(; p_roids != p_roidsEn; ++p_roids ) {
179 internalRoI.push_back(*p_roids);
180 ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " eta = " << "(" << (*p_roids)->etaMinus() << ")" << (*p_roids)->eta() << "(" << (*p_roids)->etaPlus() << ")");
181 ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " phi = " << "(" << (*p_roids)->phiMinus() << ")" << (*p_roids)->phi() << "(" << (*p_roids)->phiPlus() << ")");
182 ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " zed = " << "(" << (*p_roids)->zedMinus() << ")" << (*p_roids)->zed() << "(" << (*p_roids)->zedPlus() << ")");
183 }
184 ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " size = " << internalRoI.size());
185
186 // make RecMURoIs maching with MURoIs
187 std::vector< const xAOD::MuonRoI* > recRoIVector;
188 std::vector< const xAOD::MuonRoI* > surrRoIs;
189
190 for (size_t size=0; size<roiCollection->size(); size++){
191 const xAOD::MuonRoI* recRoI = matchingRecRoI( roiCollection->at(size)->roiWord(), *recRoiCollection );
192 if( recRoI == nullptr ) continue;
193 recRoIVector.push_back(recRoI);
194 ATH_MSG_DEBUG("REGTEST: " << m_recRoiCollectionKey.key() << " eta/phi = " << (recRoI)->eta() << "/" << (recRoI)->phi());
195 ATH_MSG_DEBUG("REGTEST: " << m_recRoiCollectionKey.key() << " size = " << recRoIVector.size());
196 }
197
198 bool dynamicDeltaRpc = false;
199 int nPassedBarrelSurrRoi = 0;
200 if(m_topoRoad ){
201 for( const auto recRoI: *recRoiCollection ){
202 if(std::find(recRoIVector.begin(), recRoIVector.end(), recRoI) != recRoIVector.end()) continue;
203
204 bool surrounding = false;
205 for( const auto matchedRoI: recRoIVector ){
206 float deta = std::abs(recRoI->eta() - matchedRoI->eta());
207 float dphi = std::abs(recRoI->phi() - matchedRoI->phi());
208 if( dphi > M_PI )dphi = 2.*M_PI - dphi;
209 if( deta < m_dEtasurrRoI && dphi < m_dPhisurrRoI)
210 surrounding = true;
211 }
212
213 if(surrounding)
214 surrRoIs.push_back(recRoI);
215 }
216
217 ATH_MSG_DEBUG("surrRoI: " << " size = " << surrRoIs.size());
218 for( const auto recRoI: surrRoIs ){
219 ATH_MSG_DEBUG("surrRoI: " << " eta/phi = " << (recRoI)->eta() << "/" << (recRoI)->phi() );
220 if( std::abs((recRoI)->eta()) <= 1.05 && (recRoI)->getThrNumber() >= 1 )nPassedBarrelSurrRoi++;
221 }
222 ATH_MSG_DEBUG( "nPassedBarrelSurrRoi = " << nPassedBarrelSurrRoi);
223 //dynamicDeltaRpcMode
224 if( nPassedBarrelSurrRoi >= 1 )
225 dynamicDeltaRpc = true;
226 }
227
228 // record data objects with WriteHandle
229 auto muFastContainer = SG::makeHandle(m_muFastContainerKey, ctx);
230 ATH_CHECK(muFastContainer.record(std::make_unique<xAOD::L2StandAloneMuonContainer>(), std::make_unique<xAOD::L2StandAloneMuonAuxContainer>()));
231
232 auto muCompositeContainer = std::make_unique<xAOD::TrigCompositeContainer>();
233 auto muCompositeAuxContainer = std::make_unique<xAOD::TrigCompositeAuxContainer>();
234 muCompositeContainer->setStore(muCompositeAuxContainer.get());
235
236 auto muIdContainer = SG::makeHandle(m_muIdContainerKey, ctx);
237 ATH_CHECK(muIdContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
238
239 auto muMsContainer = SG::makeHandle(m_muMsContainerKey, ctx);
240 ATH_CHECK(muMsContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
241
242
243 // Inside-out L2Muon mode
244 if(m_insideOut) {
245 ATH_MSG_DEBUG("start inside-out mode...");
246
247 auto muonCBColl = SG::makeHandle (m_outputCBmuonCollKey, ctx);
248 ATH_CHECK( muonCBColl.record (std::make_unique<xAOD::L2CombinedMuonContainer>(),
249 std::make_unique<xAOD::L2CombinedMuonAuxContainer>()) );
250
251 auto trackHandle = SG::makeHandle( m_FTFtrackKey, ctx );
252 if (!trackHandle.isValid()){
253 ATH_MSG_ERROR("ReadHandle for TrackParticleContainer key:" << m_FTFtrackKey.key() << " isn't Valid");
254 return StatusCode::FAILURE;
255 }
256 const xAOD::TrackParticleContainer *tracks = trackHandle.cptr();
257
258 ATH_CHECK(findMuonSignatureIO(*tracks, internalRoI, recRoIVector,
259 *muonCBColl, *muFastContainer, dynamicDeltaRpc, ctx ));
260
261 if (msgLvl(MSG::DEBUG)) {
262 ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " size = " << muonCBColl->size());
263 for (const auto p_CBmuon : *muonCBColl){
264 ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " pt = " << (*p_CBmuon).pt() << " GeV");
265 ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " eta/phi = " << (*p_CBmuon).eta() << "/" << (*p_CBmuon).phi());
266 }
267 }
268 }
269 else if(m_multiTrack){ //multi-track SA mode
270 ATH_MSG_DEBUG("start multi-track SA mode...");
271 ATH_CHECK(findMultiTrackSignature(internalRoI, recRoIVector, *muFastContainer, dynamicDeltaRpc, ctx));
272 }
273 else {
274 ATH_CHECK(findMuonSignature(internalRoI, recRoIVector,
275 *muFastContainer, muCompositeContainer.get(), *muIdContainer, *muMsContainer, dynamicDeltaRpc, ctx));
276 }
277
278 if (!m_muCompositeContainerKey.empty()){
280 ATH_CHECK(wh_muCompositeCont.record(std::move(muCompositeContainer), std::move(muCompositeAuxContainer)));
281 }
282
283 if (msgLvl(MSG::DEBUG)) {
284 // DEBUG TEST: Recorded data objects
285 ATH_MSG_DEBUG("Recorded data objects");
286 ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " size = " << muFastContainer->size());
287
288 for (auto p_muon : *muFastContainer) {
289 ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " pt = " << (*p_muon).pt() << " GeV");
290 ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " eta/phi = " << (*p_muon).eta() << "/" << (*p_muon).phi());
291 }
292
293 ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " size = " << muIdContainer->size());
294 for (auto p_muonID : *muIdContainer) {
295 ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " eta/phi = " << (*p_muonID).eta() << "/" << (*p_muonID).phi());
296 }
297
298 ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " size = " << muMsContainer->size());
299 for (auto p_muonMS : *muMsContainer) {
300 ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " eta/phi = " << (*p_muonMS).eta() << "/" << (*p_muonMS).phi());
301 }
302 }
303
304 ATH_MSG_DEBUG("StatusCode MuFastSteering::execute(const EventContext& ctx) success");
305 return StatusCode::SUCCESS;
306}
307
308// --------------------------------------------------------------------------------
309// --------------------------------------------------------------------------------
310
311StatusCode MuFastSteering::findMuonSignature(const std::vector<const TrigRoiDescriptor*>& roids,
312 const std::vector<const xAOD::MuonRoI*>& muonRoIs,
314 xAOD::TrigCompositeContainer* outputMuonCal,
317 const bool dynamicDeltaRpc,
318 const EventContext& ctx) const
319{
320 ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignature start");
321 StatusCode sc = StatusCode::SUCCESS;
322
323 auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
324 auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
325 auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
326 auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
327 auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
328 auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
329
330 auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
331 trackFitterTimer, trackExtraTimer, calibrationTimer );
332
333 TrigL2MuonSA::RpcHits rpcHits;
334 TrigL2MuonSA::TgcHits tgcHits;
335 TrigL2MuonSA::MdtRegion mdtRegion;
336 TrigL2MuonSA::MuonRoad muonRoad;
337 TrigL2MuonSA::RpcFitResult rpcFitResult;
338 TrigL2MuonSA::TgcFitResult tgcFitResult;
339 TrigL2MuonSA::MdtHits mdtHits;
340 TrigL2MuonSA::CscHits cscHits;
341 TrigL2MuonSA::StgcHits stgcHits;
343
346
347 // muonRoIs = RecMURoIs, roids = MURoIs
348 p_roids = roids.begin();
349 for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
350
351 prepTimer.start();
352 std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
353 rpcHits.clear();
354 tgcHits.clear();
355 mdtRegion.Clear();
356 muonRoad.Clear();
357 rpcFitResult.Clear();
358 tgcFitResult.Clear();
359 mdtHits.clear();
360 cscHits.clear();
361 stgcHits.clear();
362 mmHits.clear();
363
364 if ( m_recMuonRoIUtils.isBarrel(*p_roi) ) { // Barrel
365 ATH_MSG_DEBUG("Barrel");
366
370
371 // Data preparation
372 sc = m_dataPreparator->prepareData(ctx,
373 *p_roi,
374 *p_roids,
376 rpcHits,
377 muonRoad,
378 mdtRegion,
379 rpcFitResult,
380 mdtHits,
381 dynamicDeltaRpc);
382 if (!sc.isSuccess()) {
383 ATH_MSG_WARNING("Data preparation failed");
384 TrigL2MuonSA::TrackPattern trackPattern;
385 trackPatterns.push_back(std::move(trackPattern));
386 // Update output trigger element
387 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
388 rpcFitResult, tgcFitResult, mdtHits, cscHits,
389 stgcHits, mmHits,
390 trackPatterns, outputTracks, outputID, outputMS, ctx);
391 continue;
392 }
393 prepTimer.stop();
394
395 // Pattern finding
396 patternTimer.start();
397 sc = m_patternFinder->findPatterns(ctx,
398 muonRoad,
399 mdtHits,
400 trackPatterns);
401 if (!sc.isSuccess()) {
402 ATH_MSG_WARNING("Pattern finder failed");
403 // Update output trigger element
404 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
405 rpcFitResult, tgcFitResult, mdtHits, cscHits,
406 stgcHits, mmHits,
407 trackPatterns, outputTracks, outputID, outputMS, ctx);
408 continue;
409 }
410 patternTimer.stop();
411
412 // Superpoint fit
413 stationFitterTimer.start();
414 sc = m_stationFitter->findSuperPoints(muonRoad,
415 rpcFitResult,
416 trackPatterns);
417 if (!sc.isSuccess()) {
418 ATH_MSG_WARNING("Super point fitter failed");
419 // Update output trigger element
420 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
421 rpcFitResult, tgcFitResult, mdtHits, cscHits,
422 stgcHits, mmHits,
423 trackPatterns, outputTracks, outputID, outputMS, ctx);
424 continue;
425 }
426 stationFitterTimer.stop();
427
428 // Track fitting
429 trackFitterTimer.start();
430 sc = m_trackFitter->findTracks(*p_roids,
431 rpcFitResult,
432 trackPatterns);
433
434 if (!sc.isSuccess()) {
435 ATH_MSG_WARNING("Track fitter failed");
436 // Update output trigger element
437 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
438 rpcFitResult, tgcFitResult, mdtHits, cscHits,
439 stgcHits, mmHits,
440 trackPatterns, outputTracks, outputID, outputMS, ctx);
441 continue;
442 }
443 trackFitterTimer.stop();
444
445 }
446 else { // Endcap
447 ATH_MSG_DEBUG("Endcap");
448
449 prepTimer.start();
450 // Data preparation
451 sc = m_dataPreparator->prepareData(ctx,
452 *p_roi,
453 *p_roids,
455 tgcHits,
456 muonRoad,
457 mdtRegion,
458 tgcFitResult,
459 mdtHits,
460 cscHits,
461 stgcHits,
462 mmHits);
463 if (!sc.isSuccess()) {
464 ATH_MSG_WARNING("Data preparation failed");
465 TrigL2MuonSA::TrackPattern trackPattern;
466 trackPatterns.push_back(std::move(trackPattern));
467 // Update output trigger element
468 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
469 rpcFitResult, tgcFitResult, mdtHits, cscHits,
470 stgcHits, mmHits,
471 trackPatterns, outputTracks, outputID, outputMS, ctx);
472 continue;
473 }
474 prepTimer.stop();
475
476 // Pattern finding
477 patternTimer.start();
478 sc = m_patternFinder->findPatterns(ctx,
479 muonRoad,
480 mdtHits,
481 stgcHits,
482 mmHits,
483 trackPatterns);
484
485 if (!sc.isSuccess()) {
486 ATH_MSG_WARNING("Pattern finder failed");
487 // Update output trigger element
488 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
489 rpcFitResult, tgcFitResult, mdtHits, cscHits,
490 stgcHits, mmHits,
491 trackPatterns, outputTracks, outputID, outputMS, ctx);
492 continue;
493 }
494 patternTimer.stop();
495
496 // Superpoint fit
497 stationFitterTimer.start();
499 sc = m_stationFitter->findSuperPointsSimple(*p_roids,
500 muonRoad,
501 tgcFitResult,
502 trackPatterns,
503 stgcHits,
504 mmHits);
505 }
506 else{
507 sc = m_stationFitter->findSuperPoints(*p_roids,
508 muonRoad,
509 tgcFitResult,
510 trackPatterns,
511 stgcHits,
512 mmHits);
513 }
515 m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
516
517 if (!sc.isSuccess()) {
518 ATH_MSG_WARNING("Super point fitter failed");
519 // Update output trigger element
520 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
521 rpcFitResult, tgcFitResult, mdtHits, cscHits,
522 stgcHits, mmHits,
523 trackPatterns, outputTracks, outputID, outputMS, ctx);
524 continue;
525 }
526
527 stationFitterTimer.stop();
528
529 // Track fittingh
530 trackFitterTimer.start();
531 sc = m_trackFitter->findTracks(*p_roids,
532 tgcFitResult,
533 trackPatterns,
534 muonRoad);
535
536 if (!sc.isSuccess()) {
537 ATH_MSG_WARNING("Track fitter failed");
538 // Update output trigger element
539 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
540 rpcFitResult, tgcFitResult, mdtHits, cscHits,
541 stgcHits, mmHits,
542 trackPatterns, outputTracks, outputID, outputMS, ctx);
543 continue;
544 }
545 trackFitterTimer.stop();
546 }
547
548 // fix if eta is strange
549 const float ETA_LIMIT = 2.8;
550 const float DELTA_ETA_LIMIT = 1.0;
551 const float ZERO_LIMIT = 1.e-5;
552 for (TrigL2MuonSA::TrackPattern& track : trackPatterns) {
553 float roiEta = (*p_roi)->eta();
554 if ( std::abs(track.pt) > ZERO_LIMIT &&
555 ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
556 track.etaMap = roiEta;
557 }
558 }
559
560 // Track extrapolation for ID combined
561 trackExtraTimer.start();
562
563 sc = m_trackExtrapolator->extrapolateTrack(trackPatterns, m_winPt);
564
565 if (sc != StatusCode::SUCCESS) {
566 ATH_MSG_WARNING("Track extrapolator failed");
567 // Update output trigger element
568 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
569 rpcFitResult, tgcFitResult, mdtHits, cscHits,
570 stgcHits, mmHits,
571 trackPatterns, outputTracks, outputID, outputMS, ctx);
572 continue;
573 }
574 trackExtraTimer.stop();
575
576 // Update monitoring variables
577 sc = updateMonitor(*p_roi, mdtHits, trackPatterns );
578 if (sc != StatusCode::SUCCESS) {
579 ATH_MSG_WARNING("Failed to update monitoring variables");
580 // Update output trigger element
581 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
582 rpcFitResult, tgcFitResult, mdtHits, cscHits,
583 stgcHits, mmHits,
584 trackPatterns, outputTracks, outputID, outputMS, ctx);
585 continue;
586 }
587
588 // Update output trigger element
589 updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
590 rpcFitResult, tgcFitResult, mdtHits, cscHits,
591 stgcHits, mmHits,
592 trackPatterns, outputTracks, outputID, outputMS, ctx);
593
594
595 //-----------------------
596 // call the calibration streamer
597 //---------------------------
598 if (m_calDataScouting && trackPatterns.size()>0 ) {
599 TrigL2MuonSA::TrackPattern tp = trackPatterns[0];
600 std::vector<uint32_t> localBuffer; // init localBuffer parameter
601 sc = m_calStreamer->createRoiFragment(*p_roi,tp,mdtHits,
602 rpcHits,
603 tgcHits,
604 localBuffer,
605 ctx);
606 if (sc != StatusCode::SUCCESS ) {
607 ATH_MSG_WARNING("Calibration streamer: create Roi Fragment failed");
608 }
609 ATH_MSG_DEBUG("Retrieved the buffer, with size: " << localBuffer.size());
610
611 // create the TrigCompositeContainer to store the calibration buffer
613 if (outputMuonCal){
614 outputMuonCal->push_back(tc);
615 ATH_MSG_DEBUG("The size of the TrigCompositeContainer is: " << outputMuonCal->size() );
616 } else {
617 ATH_MSG_ERROR("Trying to fill nullptr container.");
618 delete tc;
619 return StatusCode::FAILURE;
620 }
621 tc->setDetail("muCalibDS", localBuffer );
622 }
623
624 ++p_roids;
625 if (p_roids==roids.end()) break;
626 }
627
628 ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignature success");
629 return StatusCode::SUCCESS;
630}
631
632// --------------------------------------------------------------------------------
633// --------------------------------------------------------------------------------
634
635// findMuonSignature of L2 inside-out version
636// try to find MS tracks seeded by FTF tracks
638 const std::vector<const TrigRoiDescriptor*>& roids,
639 const std::vector<const xAOD::MuonRoI*>& muonRoIs,
642 const bool dynamicDeltaRpc,
643 const EventContext& ctx) const
644{
645 ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignatureIO start");
646 StatusCode sc = StatusCode::SUCCESS;
647 const float ZERO_LIMIT = 1.e-5;
648
649 auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
650 auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
651 auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
652 auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
653 auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
654 auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
655
656 auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
657 trackFitterTimer, trackExtraTimer, calibrationTimer );
658
659 TrigL2MuonSA::RpcHits rpcHits;
660 TrigL2MuonSA::TgcHits tgcHits;
661 TrigL2MuonSA::MdtRegion mdtRegion;
662 TrigL2MuonSA::MuonRoad muonRoad;
663 TrigL2MuonSA::RpcFitResult rpcFitResult;
664 TrigL2MuonSA::TgcFitResult tgcFitResult;
665 TrigL2MuonSA::MdtHits mdtHits;
666 TrigL2MuonSA::CscHits cscHits;
667 TrigL2MuonSA::StgcHits stgcHits;
669
671
672 p_roids = roids.begin();
673 for (const auto p_roi : muonRoIs) {
674 ATH_MSG_DEBUG("roi eta/phi: " << (*p_roi).eta() << "/" << (*p_roi).phi());
675
676 // idtracks loop
677 if ( (idtracks).empty() ) ATH_MSG_DEBUG("IO TEST: xAOD::TrackParticleContainer has 0 tracks --> Can not use FTF tracks...");
678 else ATH_MSG_DEBUG("IO TEST: xAOD::TrackParticleContainer has " << (idtracks).size() << " tracks --> Start inside-out mode!");
679
680 std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
681 int idtrack_idx = -1;
682 for (auto idtrack : idtracks) {
683
684 idtrack_idx++;
685 ATH_MSG_DEBUG("IO TEST: FTF track key:" << m_FTFtrackKey.key() << " pt = " << idtrack->pt()/1000 << " GeV");
686 ATH_MSG_DEBUG("IO TEST: FTF track key:" << m_FTFtrackKey.key() << " eta/phi = " << idtrack->eta() << "/" << idtrack->phi());
687
688 if(idtrack->pt() < m_ftfminPt) {
689 ATH_MSG_DEBUG("IO TEST: skip FTF track due to pT threshold: " << m_ftfminPt << " MeV");
690 continue;
691 }
692
693 prepTimer.start();
694 rpcHits.clear();
695 tgcHits.clear();
696 mdtRegion.Clear();
697 muonRoad.Clear();
698 rpcFitResult.Clear();
699 tgcFitResult.Clear();
700 mdtHits.clear();
701 cscHits.clear();
702 stgcHits.clear();
703 mmHits.clear();
704 trackPatterns.clear();
705
706 sc = m_ftfRoadDefiner->defineRoad(ctx, idtrack, muonRoad);
707 if (!sc.isSuccess()) {
708 ATH_MSG_WARNING("FtfRoadDefiner failed");
709 continue;
710 } else {
711 ATH_MSG_DEBUG("FtfRoadDefiner::defineRoad success");
712 }
713
714 if ( std::abs(idtrack->eta()) < 1.05 ){
715 ATH_MSG_DEBUG("FTF track at IP is in Barrel: " << idtrack->eta());
716 } else {
717 ATH_MSG_DEBUG("FTF track at IP is in Endcap: " << idtrack->eta());
718 }
719
720 if ( m_recMuonRoIUtils.isBarrel(p_roi) ) { // Barrel Inside-out
721 ATH_MSG_DEBUG("muonRoad.extFtfMiddleEta Barrel: " << muonRoad.extFtfMiddleEta);
722
723 ATH_MSG_DEBUG("Barrel algorithm of IOmode starts");
724
728
729 // Data preparation
730 sc = m_dataPreparator->prepareData(ctx,
731 p_roi,
732 *p_roids,
734 rpcHits,
735 muonRoad,
736 mdtRegion,
737 rpcFitResult,
738 mdtHits,
739 dynamicDeltaRpc);
740 if (!sc.isSuccess()) {
741 ATH_MSG_WARNING("Data preparation failed");
742 continue;
743 } else {
744 ATH_MSG_DEBUG("Data preparation success");
745 }
746 prepTimer.stop();
747
748 // Pattern finding
749 patternTimer.start();
750 sc = m_patternFinder->findPatterns(ctx,
751 muonRoad,
752 mdtHits,
753 trackPatterns);
754 if (!sc.isSuccess()) {
755 ATH_MSG_WARNING("Pattern finder failed");
756 continue;
757 }
758 patternTimer.stop();
759
760 // Superpoint fit
761 stationFitterTimer.start();
762 sc = m_stationFitter->findSuperPoints(muonRoad,
763 rpcFitResult,
764 trackPatterns);
765 if (!sc.isSuccess()) {
766 ATH_MSG_WARNING("Super point fitter failed");
767 continue;
768 }
769 stationFitterTimer.stop();
770
771 // Track fitting
772 trackFitterTimer.start();
773 sc = m_trackFitter->findTracks(*p_roids,
774 rpcFitResult,
775 trackPatterns);
776 if (!sc.isSuccess()) {
777 ATH_MSG_WARNING("Track fitter failed");
778 continue;
779 }
780 trackFitterTimer.stop();
781
782 } else { // Endcap Inside-out
783 ATH_MSG_DEBUG("muonRoad.extFtfMiddleEta Endcap: " << muonRoad.extFtfMiddleEta);
784 ATH_MSG_DEBUG("Endcap algorithm of IOmode starts");
785
786 prepTimer.start();
787 // Data preparation
788 sc = m_dataPreparator->prepareData(ctx,
789 p_roi,
790 *p_roids,
792 tgcHits,
793 muonRoad,
794 mdtRegion,
795 tgcFitResult,
796 mdtHits,
797 cscHits,
798 stgcHits,
799 mmHits);
800 if (!sc.isSuccess()) {
801 ATH_MSG_WARNING("Data preparation failed");
802 continue;
803 } else{
804 ATH_MSG_DEBUG("Data preparation success");
805 }
806 prepTimer.stop();
807
808 // Pattern finding
809 patternTimer.start();
810 sc = m_patternFinder->findPatterns(ctx,
811 muonRoad,
812 mdtHits,
813 stgcHits,
814 mmHits,
815 trackPatterns);
816 if (!sc.isSuccess()) {
817 ATH_MSG_WARNING("Pattern finder failed");
818 continue;
819 }
820 patternTimer.stop();
821
822 // Superpoint fit
823 stationFitterTimer.start();
824 sc = m_stationFitter->findSuperPointsSimple(*p_roids,
825 muonRoad,
826 tgcFitResult,
827 trackPatterns,
828 stgcHits,
829 mmHits);
831 m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
832 if (!sc.isSuccess()) {
833 ATH_MSG_WARNING("Super point fitter failed");
834 continue;
835 }
836 stationFitterTimer.stop();
837
838 // Track fittingh
839 trackFitterTimer.start();
840 sc = m_trackFitter->findTracks(*p_roids,
841 tgcFitResult,
842 trackPatterns,
843 muonRoad);
844 if (!sc.isSuccess()) {
845 ATH_MSG_WARNING("Track fitter failed");
846 continue;
847 }
848 trackFitterTimer.stop();
849
850 }
851
852 // fix if eta is strange
853 TrigL2MuonSA::TrackPattern track = trackPatterns.back();
854 const float ETA_LIMIT = 2.8;
855 const float DELTA_ETA_LIMIT = 1.0;
856 float roiEta = (*p_roi).eta();
857 if (std::abs(track.pt) > ZERO_LIMIT
858 && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
859 trackPatterns.back().etaMap = roiEta;
860 }
861
862 // Update monitoring variables
863 sc = updateMonitor(p_roi, mdtHits, trackPatterns );
864 if (sc != StatusCode::SUCCESS) {
865 ATH_MSG_WARNING("Failed to update monitoring variables");
866 }
867
868 // Update output trigger element
869 if ( std::abs(trackPatterns.back().pt) > ZERO_LIMIT ) {
870 storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
871 rpcFitResult, tgcFitResult, mdtHits, cscHits,
872 stgcHits, mmHits,
873 trackPatterns.back(), outputSAs, ctx);
875 muonCB->makePrivateStore();
876 muonCB->setStrategy(0);
877 muonCB->setErrorFlag(-9);
878 muonCB->setPt(idtrack->pt());
879 muonCB->setEta(idtrack->eta());
880 muonCB->setPhi(idtrack->phi());
881 muonCB->setCharge(idtrack->charge());
882 ElementLink<xAOD::L2StandAloneMuonContainer> muonSAEL(outputSAs, outputSAs.size()-1, ctx);
883 muonCB->setMuSATrackLink(muonSAEL);
884 ElementLink<xAOD::TrackParticleContainer> idtrkEL(idtracks, idtrack_idx, ctx);
885 muonCB->setIdTrackLink(idtrkEL);
886 outputCBs.push_back(muonCB);
887 }
888
889 }
890
891 if(outputSAs.empty()) {
892 ATH_MSG_DEBUG("outputSAs size = 0 -> push_back dummy");
893 muonRoad.Clear();
894 mdtRegion.Clear();
895 rpcHits.clear();
896 tgcHits.clear();
897 rpcFitResult.Clear();
898 tgcFitResult.Clear();
899 mdtHits.clear();
900 cscHits.clear();
901 stgcHits.clear();
902 mmHits.clear();
903 trackPatterns.clear();
904 TrigL2MuonSA::TrackPattern trackPattern;
905 storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
906 rpcFitResult, tgcFitResult, mdtHits, cscHits,
907 stgcHits, mmHits,
908 trackPattern, outputSAs, ctx);
909 if (outputSAs.empty())[[unlikely]]{
910 ATH_MSG_ERROR("outputSAs is still empty after attempted dummy store.");
911 return StatusCode::FAILURE;
912 }
914 muonCB->makePrivateStore();
915 muonCB->setStrategy(-9);
916 muonCB->setErrorFlag(-9);
917 muonCB->setPt(0);
918 muonCB->setEta(99999.);
919 muonCB->setPhi(99999.);
920 ElementLink<xAOD::L2StandAloneMuonContainer> muonSAEL(outputSAs, outputSAs.size()-1, ctx);
921 muonCB->setMuSATrackLink(muonSAEL);
922 outputCBs.push_back(muonCB);
923 }
924
925
926 ATH_MSG_DEBUG("outputSAs size: " << outputSAs.size());
927 ATH_MSG_DEBUG("idtracks size: " << idtracks.size());
928 for (auto outputSA : outputSAs){
929 ATH_MSG_DEBUG("outputSA pt/eta/phi: " << outputSA->pt() << "/" << outputSA->etaMS() << "/" << outputSA->phiMS());
930 }
931
932 ATH_MSG_DEBUG("outputCBs size: " << outputCBs.size());
933 for (auto outputCB : outputCBs){
934 ATH_MSG_DEBUG("outputCB pt/eta/phi: " << outputCB->pt() << "/" << outputCB->eta() << "/" << outputCB->phi());
935 }
936
937 ++p_roids;
938 if (p_roids==roids.end()) break;
939 }
940
941 ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignatureIO success");
942 return StatusCode::SUCCESS;
943}
944
945// findMuonSignature of L2 multi-track SA version
946// --------------------------------------------------------------------------------
947// --------------------------------------------------------------------------------
948
949StatusCode MuFastSteering::findMultiTrackSignature(const std::vector<const TrigRoiDescriptor*>& roids,
950 const std::vector<const xAOD::MuonRoI*>& muonRoIs,
952 const bool dynamicDeltaRpc,
953 const EventContext& ctx) const
954{
955 ATH_MSG_DEBUG("StatusCode MuFastSteering::findMultiTrackSignature start");
956 StatusCode sc = StatusCode::SUCCESS;
957 const float ZERO_LIMIT = 1.e-5;
958
959 // for RPC clustering and clusterRoad
960 std::vector<TrigL2MuonSA::RpcFitResult> clusterFitResults;
961 std::vector< TrigL2MuonSA::MuonRoad > clusterRoad;
962 std::vector<TrigL2MuonSA::MdtHits> mdtHits_cluster_normal;
963
964
965 auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
966 auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
967 auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
968 auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
969 auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
970 auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
971
972 auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
973 trackFitterTimer, trackExtraTimer, calibrationTimer );
974
975 TrigL2MuonSA::RpcHits rpcHits;
976 TrigL2MuonSA::TgcHits tgcHits;
977 TrigL2MuonSA::MdtRegion mdtRegion;
978 TrigL2MuonSA::MuonRoad muonRoad;
979 TrigL2MuonSA::RpcFitResult rpcFitResult;
980 TrigL2MuonSA::TgcFitResult tgcFitResult;
981 TrigL2MuonSA::MdtHits mdtHits;
982 TrigL2MuonSA::CscHits cscHits;
983 TrigL2MuonSA::StgcHits stgcHits;
985
988
989 // muonRoIs = RecMURoIs, roids = MURoIs
990 p_roids = roids.begin();
991 for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
992
993 prepTimer.start();
994 std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
995 rpcHits.clear();
996 tgcHits.clear();
997 mdtRegion.Clear();
998 muonRoad.Clear();
999 rpcFitResult.Clear();
1000 tgcFitResult.Clear();
1001 mdtHits.clear();
1002 cscHits.clear();
1003 stgcHits.clear();
1004 mmHits.clear();
1005
1006 clusterFitResults.clear();
1007 clusterRoad.clear();
1008 mdtHits_cluster_normal.clear();
1009
1010 if ( m_recMuonRoIUtils.isBarrel(*p_roi) ) { // Barrel
1011 ATH_MSG_DEBUG("Barrel");
1012
1016
1017 // Data preparation
1018 sc = m_dataPreparator->prepareData(ctx,
1019 *p_roi,
1020 *p_roids,
1021 clusterRoad,
1022 clusterFitResults,
1023 mdtHits,
1024 mdtHits_cluster_normal,
1025 dynamicDeltaRpc);
1026
1027 if (!sc.isSuccess()) {
1028 ATH_MSG_WARNING("Data preparation failed");
1029 continue;
1030 }
1031 ATH_MSG_DEBUG("clusterRoad size = " << clusterRoad.size());
1032
1033 prepTimer.stop();
1034
1035 for(unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
1036 // Pattern finding
1037 std::vector<TrigL2MuonSA::TrackPattern> tmp_trkPats; tmp_trkPats.clear();
1038
1039 patternTimer.start();
1040 sc = m_patternFinder->findPatterns(ctx,
1041 clusterRoad.at(i_road),
1042 mdtHits_cluster_normal.at(i_road),
1043 tmp_trkPats);
1044 if (!sc.isSuccess()) {
1045 ATH_MSG_WARNING("Pattern finder failed");
1046 continue;
1047 }
1048 patternTimer.stop();
1049
1050 // Superpoint fit
1051 stationFitterTimer.start();
1052 sc = m_stationFitter->findSuperPoints(clusterRoad.at(i_road),
1053 clusterFitResults.at(i_road),
1054 tmp_trkPats);
1055 if (!sc.isSuccess()) {
1056 ATH_MSG_WARNING("Super point fitter failed");
1057 // Update output trigger element
1058 continue;
1059 }
1060 stationFitterTimer.stop();
1061
1062 // Track fitting
1063 trackFitterTimer.start();
1064 sc = m_trackFitter->findTracks(*p_roids,
1065 clusterFitResults.at(i_road),
1066 tmp_trkPats);
1067
1068 if (!sc.isSuccess()) {
1069 ATH_MSG_WARNING("Track fitter failed");
1070 continue;
1071 }
1072 trackFitterTimer.stop();
1073
1074 // fix if eta is strange
1075 const float ETA_LIMIT = 2.8;
1076 const float DELTA_ETA_LIMIT = 1.0;
1077 for (TrigL2MuonSA::TrackPattern& track : tmp_trkPats) {
1078 float roiEta = (*p_roi)->eta();
1079 if (std::abs(track.pt) > ZERO_LIMIT
1080 && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1081 track.etaMap = roiEta;
1082 }
1083 }
1084
1085 // Track extrapolation for ID combined
1086 trackExtraTimer.start();
1087
1088 sc = m_trackExtrapolator->extrapolateTrack(tmp_trkPats, m_winPt);
1089 ATH_MSG_DEBUG("test trackExtrapolator end");
1090
1091 if (sc != StatusCode::SUCCESS) {
1092 ATH_MSG_WARNING("Track extrapolator failed");
1093 // Update output trigger element
1094 continue;
1095 }
1096 trackExtraTimer.stop();
1097
1098 if(tmp_trkPats.size() > 0){
1099 ATH_MSG_DEBUG("temp pT calculated 2mu-in-1RoI alg = " << tmp_trkPats[0].pt << " GeV");
1100 if( (std::abs(tmp_trkPats[0].barrelSagitta) < ZERO_LIMIT &&
1101 std::abs(tmp_trkPats[0].barrelRadius) < ZERO_LIMIT) ||
1102 std::abs(tmp_trkPats[0].pt) < ZERO_LIMIT )
1103 continue;
1104 trackPatterns.push_back(tmp_trkPats[0]);
1105 }
1106
1107 storeMuonSA(*p_roi, *p_roids, clusterRoad.at(i_road), mdtRegion, rpcHits, tgcHits,
1108 clusterFitResults.at(i_road), tgcFitResult, mdtHits_cluster_normal.at(i_road), cscHits,
1109 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1110
1111 } // end the clusterRoad loop
1112 if(trackPatterns.empty()){
1113 ATH_MSG_DEBUG("multi-track SA falied to reconstruct muons");
1114 trackPatterns.emplace_back();
1115 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1116 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1117 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1118
1119 continue;
1120 }
1121 } else { // Endcap
1122 ATH_MSG_DEBUG("Endcap");
1123 if(!m_doEndcapForl2mt){
1124 ATH_MSG_DEBUG("multi-track SA does nothings and skips for EndcapRoI");
1125 } else {
1126 prepTimer.start();
1127 // Data preparation
1128 sc = m_dataPreparator->prepareData(ctx,
1129 *p_roi,
1130 *p_roids,
1132 tgcHits,
1133 muonRoad,
1134 mdtRegion,
1135 tgcFitResult,
1136 mdtHits,
1137 cscHits,
1138 stgcHits,
1139 mmHits);
1140 if (!sc.isSuccess()) {
1141 ATH_MSG_WARNING("Data preparation failed");
1142 trackPatterns.emplace_back();
1143 // Update output trigger element
1144 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1145 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1146 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1147 continue;
1148 }
1149 prepTimer.stop();
1150
1151 // Pattern finding
1152 patternTimer.start();
1153 sc = m_patternFinder->findPatterns(ctx,
1154 muonRoad,
1155 mdtHits,
1156 stgcHits,
1157 mmHits,
1158 trackPatterns);
1159
1160
1161
1162 if (!sc.isSuccess()) {
1163 ATH_MSG_WARNING("Pattern finder failed");
1164 // Update output trigger element
1165 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1166 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1167 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1168 continue;
1169 }
1170 patternTimer.stop();
1171
1172 // Superpoint fit
1173 stationFitterTimer.start();
1175 sc = m_stationFitter->findSuperPointsSimple(*p_roids,
1176 muonRoad,
1177 tgcFitResult,
1178 trackPatterns,
1179 stgcHits,
1180 mmHits);
1181 }else{
1182 sc = m_stationFitter->findSuperPoints(*p_roids,
1183 muonRoad,
1184 tgcFitResult,
1185 trackPatterns,
1186 stgcHits,
1187 mmHits);
1188 }
1190 m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
1191
1192 if (!sc.isSuccess()) {
1193 ATH_MSG_WARNING("Super point fitter failed");
1194 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1195 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1196 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1197 continue;
1198 }
1199
1200 stationFitterTimer.stop();
1201
1202 // Track fittingh
1203 trackFitterTimer.start();
1204 sc = m_trackFitter->findTracks(*p_roids,
1205 tgcFitResult,
1206 trackPatterns,
1207 muonRoad);
1208
1209 if (!sc.isSuccess()) {
1210 ATH_MSG_WARNING("Track fitter failed");
1211 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1212 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1213 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1214 continue;
1215 }
1216 trackFitterTimer.stop();
1217
1218 // fix if eta is strange
1219 const float ETA_LIMIT = 2.8;
1220 const float DELTA_ETA_LIMIT = 1.0;
1221 for (TrigL2MuonSA::TrackPattern& track : trackPatterns) {
1222 float roiEta = (*p_roi)->eta();
1223 if (std::abs(track.pt) > ZERO_LIMIT
1224 && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1225 track.etaMap = roiEta;
1226 }
1227 }
1228
1229 // Track extrapolation for ID combined
1230 trackExtraTimer.start();
1231
1232 sc = m_trackExtrapolator->extrapolateTrack(trackPatterns, m_winPt);
1233
1234 if (sc != StatusCode::SUCCESS) {
1235 ATH_MSG_WARNING("Track extrapolator failed");
1236 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1237 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1238 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1239 continue;
1240 }
1241 trackExtraTimer.stop();
1242
1243 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1244 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1245 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1246 }
1247 }
1248 // Update monitoring variables
1249 sc = updateMonitor(*p_roi, mdtHits, trackPatterns );
1250 if (sc != StatusCode::SUCCESS) {
1251 ATH_MSG_WARNING("Failed to update monitoring variables");
1252 }
1253
1254 ++p_roids;
1255 if (p_roids==roids.end()) break;
1256 }
1257
1258 ATH_MSG_DEBUG("StatusCode MuFastSteering::findMultiTrackSignature success");
1259 return StatusCode::SUCCESS;
1260}
1261
1262// --------------------------------------------------------------------------------
1263// --------------------------------------------------------------------------------
1264
1266 const TrigRoiDescriptor* roids,
1267 const TrigL2MuonSA::MuonRoad& muonRoad,
1268 const TrigL2MuonSA::MdtRegion& mdtRegion,
1269 const TrigL2MuonSA::RpcHits& rpcHits,
1270 const TrigL2MuonSA::TgcHits& tgcHits,
1271 const TrigL2MuonSA::RpcFitResult& rpcFitResult,
1272 const TrigL2MuonSA::TgcFitResult& tgcFitResult,
1273 const TrigL2MuonSA::MdtHits& mdtHits,
1274 const TrigL2MuonSA::CscHits& cscHits,
1275 const TrigL2MuonSA::StgcHits& stgcHits,
1276 const TrigL2MuonSA::MmHits& mmHits,
1277 const std::vector<TrigL2MuonSA::TrackPattern>& trackPatterns,
1281 const EventContext& ctx) const
1282{
1283
1284 if( trackPatterns.size() > 0 ) {
1285
1286 const TrigL2MuonSA::TrackPattern& pattern = trackPatterns.back();
1287
1288 // Update output trigger element
1289 storeMuonSA(roi, roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1290 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1291 stgcHits, mmHits,
1292 pattern, outputTracks, ctx);
1293 storeMSRoiDescriptor(roids, pattern, outputTracks, outputMS);
1294 storeIDRoiDescriptor(roids, pattern, outputTracks, outputID);
1295
1296 } else {
1297 ATH_MSG_DEBUG("Not update output objects because trackPatterns has no object");
1298 }
1299
1300 return true;
1301}
1302
1304 const TrigRoiDescriptor* roids,
1305 const TrigL2MuonSA::MuonRoad& muonRoad,
1306 const TrigL2MuonSA::MdtRegion& mdtRegion,
1307 const TrigL2MuonSA::RpcHits& rpcHits,
1308 const TrigL2MuonSA::TgcHits& tgcHits,
1309 const TrigL2MuonSA::RpcFitResult& rpcFitResult,
1310 const TrigL2MuonSA::TgcFitResult& tgcFitResult,
1311 const TrigL2MuonSA::MdtHits& mdtHits,
1312 const TrigL2MuonSA::CscHits& cscHits,
1313 const TrigL2MuonSA::StgcHits& stgcHits,
1314 const TrigL2MuonSA::MmHits& mmHits,
1315 const TrigL2MuonSA::TrackPattern& pattern,
1317 const EventContext& ctx ) const
1318{
1319 const float ZERO_LIMIT = 1.e-5;
1320
1321 const int currentRoIId = roids->roiId();
1322
1323 const EventIDBase& eventID = ctx.eventID();
1324 auto eventInfo = SG::makeHandle(m_eventInfoKey, ctx);
1325 if (!eventInfo.isValid()) {
1326 ATH_MSG_ERROR("Failed to retrieve xAOD::EventInfo object");
1327 return false;
1328 }
1329
1330 int inner = 0;
1331 int middle = 1;
1332 int outer = 2;
1333 int ee = 6;
1334 int csc = 7;
1335 int barrelinner = 0;
1336 int endcapinner = 3;
1337 int bee = 8;
1338 int bme = 9;
1339 // int bmg = 10;
1340
1341 // define inner, middle, outer
1342 if (pattern.s_address==-1) {
1349 } else {
1355 }
1356
1357 ATH_MSG_DEBUG("### Hit patterns at the Muon Spectrometer ###");
1358 ATH_MSG_DEBUG("pattern#0: # of hits at inner =" << pattern.mdtSegments[inner].size());
1359 ATH_MSG_DEBUG("pattern#0: # of hits at middle =" << pattern.mdtSegments[middle].size());
1360 ATH_MSG_DEBUG("pattern#0: # of hits at outer =" << pattern.mdtSegments[outer].size());
1361 if (pattern.s_address==-1){
1362 ATH_MSG_DEBUG("pattern#0: # of hits at ee =" << pattern.mdtSegments[ee].size());
1363 ATH_MSG_DEBUG("pattern#0: # of hits at endcap barrel inner =" << pattern.mdtSegments[barrelinner].size());
1364 ATH_MSG_DEBUG("pattern#0: # of hits at BEE =" << pattern.mdtSegments[bee].size());
1365 } else {
1366 ATH_MSG_DEBUG("pattern#0: # of hits at BME =" << pattern.mdtSegments[bme].size());
1367 ATH_MSG_DEBUG("pattern#0: # of hits at barrel endcap inner =" << pattern.mdtSegments[endcapinner].size());
1368 }
1369 ATH_MSG_DEBUG("### ************************************* ###");
1370 ATH_MSG_DEBUG("Estimated muon pt = " << pattern.pt << " GeV");
1371
1372 // ---------
1373 // store xAOD
1374
1376 muonSA->makePrivateStore();
1377
1378 // add pT
1379 muonSA->setPt(pattern.pt*pattern.charge);
1380 muonSA->setPtEndcapAlpha(pattern.ptEndcapAlpha*pattern.charge);
1381 muonSA->setPtEndcapBeta(pattern.ptEndcapBeta*pattern.charge);
1382 muonSA->setPtEndcapRadius(pattern.ptEndcapRadius*pattern.charge);
1383 muonSA->setPtCSC(pattern.ptCSC*pattern.charge);
1384
1385 muonSA->setEta(pattern.etaVtx);
1386 muonSA->setPhi(pattern.phiVtx);
1387 muonSA->setDeltaPt(pattern.deltaPt);
1388 muonSA->setDeltaEta(pattern.deltaEtaVtx);
1389 muonSA->setDeltaPhi(pattern.deltaPhiVtx);
1390
1391 // add s_address
1392 muonSA->setSAddress(pattern.s_address);
1393
1394 // add positions at MS
1395 muonSA->setEtaMS(pattern.etaMap);
1396 muonSA->setPhiMS(pattern.phiMS);
1397 muonSA->setDirPhiMS(pattern.phiMSDir);
1398 muonSA->setRMS(pattern.superPoints[inner].R);
1399 muonSA->setZMS(pattern.superPoints[inner].Z);
1400 muonSA->setDirZMS(pattern.superPoints[inner].Alin);
1401
1402 // add pt variables
1403 // Endcap
1404 muonSA->setEndcapAlpha(pattern.endcapAlpha);
1405 muonSA->setEndcapBeta(pattern.endcapBeta);
1406 muonSA->setEndcapRadius(pattern.endcapRadius3P);
1407 // Barrel
1408 muonSA->setBarrelRadius(pattern.barrelRadius);
1409 muonSA->setBarrelSagitta(pattern.barrelSagitta);
1410
1411 // store eta and phi used as argument to pT LUT
1412 muonSA->setEtaMap(pattern.etaMap);
1413 muonSA->setPhiMap(pattern.phiMap);
1414 muonSA->setEtaBin(pattern.etaBin);
1415 muonSA->setPhiBin(pattern.phiBin);
1416
1417 // store TGC/RPC readout failure flags
1418 muonSA->setIsTgcFailure((int)pattern.isTgcFailure);
1419 muonSA->setIsRpcFailure((int)pattern.isRpcFailure);
1420
1421 // add superpoints
1422 muonSA->setSuperPoint(inner, pattern.superPoints[inner].R, pattern.superPoints[inner].Z,
1423 pattern.superPoints[inner].Alin, pattern.superPoints[inner].Blin, pattern.superPoints[inner].Chi2);
1424 muonSA->setSuperPoint(middle, pattern.superPoints[middle].R, pattern.superPoints[middle].Z,
1425 pattern.superPoints[middle].Alin, pattern.superPoints[middle].Blin, pattern.superPoints[middle].Chi2);
1426 muonSA->setSuperPoint(outer, pattern.superPoints[outer].R, pattern.superPoints[outer].Z,
1427 pattern.superPoints[outer].Alin, pattern.superPoints[outer].Blin, pattern.superPoints[outer].Chi2);
1428 if (pattern.s_address==-1){
1429 muonSA->setSuperPoint(ee, pattern.superPoints[ee].R, pattern.superPoints[ee].Z,
1430 pattern.superPoints[ee].Alin, pattern.superPoints[ee].Blin, pattern.superPoints[ee].Chi2);
1431 muonSA->setSuperPoint(barrelinner, pattern.superPoints[barrelinner].R, pattern.superPoints[barrelinner].Z,
1432 pattern.superPoints[barrelinner].Alin, pattern.superPoints[barrelinner].Blin, pattern.superPoints[barrelinner].Chi2);
1433 muonSA->setSuperPoint(csc, pattern.superPoints[csc].R, pattern.superPoints[csc].Z,
1434 pattern.superPoints[csc].Alin, pattern.superPoints[csc].Blin, pattern.superPoints[csc].Chi2);
1435 } else {
1436 muonSA->setSuperPoint(endcapinner, pattern.superPoints[endcapinner].R, pattern.superPoints[endcapinner].Z,
1437 pattern.superPoints[endcapinner].Alin, pattern.superPoints[endcapinner].Blin, pattern.superPoints[endcapinner].Chi2);
1438 }
1439
1441 // Below are detailed information
1442
1443 uint32_t muondetmask = 0;
1444
1446 muonSA->setAlgoId( L2MuonAlgoMap(name()) );
1448 //muonSA->setTeId( inputTE->getId() ); // move to hltExecute()
1450 muonSA->setLvl1Id( eventInfo->extendedLevel1ID() );
1452 muonSA->setLumiBlock( eventID.lumi_block() );
1454 muonSA->setMuonDetMask( muondetmask );
1456 muonSA->setRoiId( currentRoIId );
1458 muonSA->setRoiSystem( roi->getSource() );
1460 muonSA->setRoiSubsystem( 1 - roi->getHemisphere() );
1462 muonSA->setRoiSector( roi->getSectorID() );
1464 muonSA->setRoiNumber( roi->getRoI() );
1466 muonSA->setRoiThreshold( roi->getThrNumber() );
1468 muonSA->setRoiEta( roi->eta() );
1470 muonSA->setRoiPhi( roi->phi() );
1472 muonSA->setRoIWord( roi->roiWord() );
1473
1481
1482 // MDT hits
1483 std::vector<std::string> mdtId;
1484 for (const TrigL2MuonSA::MdtHitData& mdtHit : mdtHits) {
1485 if ( mdtHit.isOutlier==0 || mdtHit.isOutlier==1 ) {
1486 muonSA->setMdtHit(mdtHit.OnlineId, mdtHit.isOutlier, mdtHit.Chamber,
1487 mdtHit.R, mdtHit.Z, mdtHit.cPhi0, mdtHit.Residual,
1488 mdtHit.DriftTime, mdtHit.DriftSpace, mdtHit.DriftSigma);
1489 mdtId.push_back(mdtHit.Id.getString());
1490 }
1491 }
1492 static const SG::Accessor< std::vector<std::string> > accessor_mdthitid( "mdtHitId" );
1493 accessor_mdthitid( *muonSA ) = std::move(mdtId);
1494
1495 //CSC hits
1496 std::vector<float> cscResol;
1497 for (const TrigL2MuonSA::CscHitData& cscHit : cscHits) {
1498 if ( 1/*cscHit.MeasuresPhi==0*/ ){
1499 if ( cscHit.isOutlier==0 || cscHit.isOutlier==1 ) {
1500 muonSA->setCscHit(cscHit.isOutlier, cscHit.Chamber, cscHit.StationName,
1501 cscHit.StationEta, cscHit.StationPhi,
1502 cscHit.ChamberLayer, cscHit.WireLayer, cscHit.MeasuresPhi, cscHit.Strip,
1503 cscHit.eta, cscHit.phi, cscHit.r, cscHit.z,
1504 cscHit.charge, cscHit.time, cscHit.Residual);
1505 cscResol.push_back(cscHit.resolution);
1506 ATH_MSG_VERBOSE("CSC Hits stored in xAOD: "
1507 << "OL=" << cscHit.isOutlier << ","
1508 << "Ch=" << cscHit.Chamber << ","
1509 << "StationName=" << cscHit.StationName << ","
1510 << "StationEta=" << cscHit.StationEta << ","
1511 << "StationPhi=" << cscHit.StationPhi << ","
1512 << "ChamberLayer=" << cscHit.ChamberLayer << ","
1513 << "WireLayer=" << cscHit.WireLayer << ","
1514 << "MeasuresPhi=" << cscHit.MeasuresPhi << ","
1515 << "Strip=" << cscHit.Strip << ","
1516 << "eta=" << cscHit.eta << ","
1517 << "phi=" << cscHit.phi << ","
1518 << "r=" << cscHit.r << ","
1519 << "z=" << cscHit.z << ","
1520 << "charge=" << cscHit.charge << ","
1521 << "Rs=" << cscHit.Residual << ","
1522 << "t=" << cscHit.time);
1523 }
1524 }
1525 }
1526 static const SG::Accessor< std::vector<float> > accessor_cschitresol( "cscHitResolution" );
1527 accessor_cschitresol( *muonSA ) = std::move(cscResol);
1528
1529 // RPC hits
1530 float sumbeta[8]={0};
1531 float nhit_layer[8]={0};
1532 for (const TrigL2MuonSA::RpcHitData& rpcHit : rpcHits) {
1533 muonSA->setRpcHit(rpcHit.layer, rpcHit.measuresPhi,
1534 rpcHit.x, rpcHit.y, rpcHit.z,
1535 rpcHit.time, rpcHit.distToEtaReadout, rpcHit.distToPhiReadout,
1536 rpcHit.stationName);
1537 ATH_MSG_VERBOSE("RPC hits stored in xAOD: "
1538 << "stationName=" << rpcHit.stationName << ","
1539 << "layer=" << rpcHit.layer << ","
1540 << "measuresPhi=" << rpcHit.measuresPhi << ","
1541 << "x=" << rpcHit.x << ","
1542 << "y=" << rpcHit.y << ","
1543 << "y=" << rpcHit.z);
1544
1545 float dRMS = std::sqrt( std::abs(pattern.etaMap-rpcHit.eta)*std::abs(pattern.etaMap-rpcHit.eta) + std::acos(std::cos(pattern.phiMS-rpcHit.phi))*std::acos(std::cos(pattern.phiMS-rpcHit.phi)) );
1546 if(dRMS>0.05) continue;
1547 float muToF = rpcHit.l/1000/(CLHEP::c_light/1000);
1548 float Tprop = rpcHit.distToPhiReadout/1000*4.8;
1549 float beta = rpcHit.l/1000/(muToF+rpcHit.time-Tprop+3.125/2)/(CLHEP::c_light/1000);
1550 sumbeta[rpcHit.layer]=sumbeta[rpcHit.layer]+beta;
1551 nhit_layer[rpcHit.layer]=nhit_layer[rpcHit.layer]+1;
1552 }
1553
1554 std::vector<float> Avebeta_layer;
1555 for(int i_layer=0;i_layer<8;i_layer++){
1556 if(nhit_layer[i_layer]!=0)Avebeta_layer.push_back( sumbeta[i_layer]/nhit_layer[i_layer] );
1557 }
1558 if(Avebeta_layer.size()>0) muonSA->setBeta( std::accumulate(Avebeta_layer.begin(),Avebeta_layer.end(),0.0)/Avebeta_layer.size() );
1559 else muonSA->setBeta( 9999 );
1560 Avebeta_layer.clear();
1561
1562 // TGC hits
1563 for (const TrigL2MuonSA::TgcHitData& tgcHit : tgcHits) {
1564 muonSA->setTgcHit(tgcHit.eta, tgcHit.phi, tgcHit.r, tgcHit.z,
1565 tgcHit.width, tgcHit.sta, tgcHit.isStrip,
1566 tgcHit.bcTag, tgcHit.inRoad);
1567 ATH_MSG_VERBOSE("TGC hits stored in xAOD: "
1568 << "eta=" << tgcHit.eta << ","
1569 << "phi=" << tgcHit.phi << ","
1570 << "r=" << tgcHit.r << ","
1571 << "z=" << tgcHit.z << ","
1572 << "width=" << tgcHit.width << ","
1573 << "stationNum=" << tgcHit.sta << ","
1574 << "isStrip=" << tgcHit.isStrip << ","
1575 << "bcTag=" << tgcHit.bcTag << ","
1576 << "inRoad=" << tgcHit.inRoad);
1577 }
1578
1579
1580 // sTGC clusters
1581 for(unsigned int i_hit=0; i_hit<stgcHits.size(); i_hit++) {
1582 if ( stgcHits[i_hit].isOutlier==0 || stgcHits[i_hit].isOutlier==1 ) {
1583
1584
1585 muonSA->setStgcCluster(stgcHits[i_hit].layerNumber, stgcHits[i_hit].isOutlier, stgcHits[i_hit].channelType,
1586 stgcHits[i_hit].eta, stgcHits[i_hit].phi, stgcHits[i_hit].r, stgcHits[i_hit].z,
1587 stgcHits[i_hit].ResidualR, stgcHits[i_hit].ResidualPhi,
1588 stgcHits[i_hit].stationEta, stgcHits[i_hit].stationPhi, stgcHits[i_hit].stationName);
1589
1590 ATH_MSG_VERBOSE("sTGC hits stored in xAOD: "
1591 << "eta=" << stgcHits[i_hit].eta << ","
1592 << "phi=" << stgcHits[i_hit].phi << ","
1593 << "r=" << stgcHits[i_hit].r << ","
1594 << "z=" << stgcHits[i_hit].z << ","
1595 << "z=" << stgcHits[i_hit].ResidualR << ","
1596 << "z=" << stgcHits[i_hit].ResidualPhi);
1597 }
1598 }
1599
1600 // MM clusters
1601 for(unsigned int i_hit=0; i_hit<mmHits.size(); i_hit++) {
1602 if ( mmHits[i_hit].isOutlier==0 || mmHits[i_hit].isOutlier==1 ) {
1603
1604
1605 muonSA->setMmCluster(mmHits[i_hit].layerNumber, mmHits[i_hit].isOutlier,
1606 mmHits[i_hit].eta, mmHits[i_hit].phi, mmHits[i_hit].r, mmHits[i_hit].z,
1607 mmHits[i_hit].ResidualR, mmHits[i_hit].ResidualPhi,
1608 mmHits[i_hit].stationEta, mmHits[i_hit].stationPhi, mmHits[i_hit].stationName);
1609
1610 ATH_MSG_VERBOSE("mm hits stored in xAOD: "
1611 << "eta=" << tgcHits[i_hit].eta << ","
1612 << "phi=" << tgcHits[i_hit].phi << ","
1613 << "r=" << tgcHits[i_hit].r << ","
1614 << "z=" << tgcHits[i_hit].z << ","
1615 << "width=" << tgcHits[i_hit].width << ","
1616 << "stationNum=" << tgcHits[i_hit].sta << ","
1617 << "isStrip=" << tgcHits[i_hit].isStrip << ","
1618 << "bcTag=" << tgcHits[i_hit].bcTag << ","
1619 << "inRoad=" << tgcHits[i_hit].inRoad);
1620 }
1621 }
1622
1623 // Muon road
1624 for (int i_station=0; i_station<8; i_station++) {
1625 for (int i_sector=0; i_sector<2; i_sector++) {
1626 muonSA->setRoad(i_station, i_sector, muonRoad.aw[i_station][i_sector], muonRoad.bw[i_station][i_sector]);
1627 muonSA->setRegionZ(i_station, i_sector, mdtRegion.zMin[i_station][i_sector], mdtRegion.zMax[i_station][i_sector]);
1628 muonSA->setRegionR(i_station, i_sector, mdtRegion.rMin[i_station][i_sector], mdtRegion.rMax[i_station][i_sector]);
1629 muonSA->setRegionEta(i_station, i_sector, mdtRegion.etaMin[i_station][i_sector], mdtRegion.etaMax[i_station][i_sector]);
1630 muonSA->setChamberType1(i_station, i_sector, mdtRegion.chamberType[i_station][i_sector][0]);
1631 muonSA->setChamberType2(i_station, i_sector, mdtRegion.chamberType[i_station][i_sector][1]);
1632 }
1633 }
1634
1635 if ( muonRoad.isEndcap ) {
1636 // TGC fit results
1637 if (tgcFitResult.isSuccess ) {
1638 muonSA->setTgcPt(tgcFitResult.tgcPT);
1639
1640 muonSA->setTgcInn(tgcFitResult.tgcInn[0], tgcFitResult.tgcInn[1],
1641 tgcFitResult.tgcInn[2], tgcFitResult.tgcInn[3]);
1642 muonSA->setTgcInnF(tgcFitResult.tgcInnRhoStd, tgcFitResult.tgcInnRhoNin,
1643 tgcFitResult.tgcInnPhiStd, tgcFitResult.tgcInnPhiNin);
1644
1645 muonSA->setTgcMid1(tgcFitResult.tgcMid1[0], tgcFitResult.tgcMid1[1],
1646 tgcFitResult.tgcMid1[2], tgcFitResult.tgcMid1[3]);
1647 muonSA->setTgcMid2(tgcFitResult.tgcMid2[0], tgcFitResult.tgcMid2[1],
1648 tgcFitResult.tgcMid2[2], tgcFitResult.tgcMid2[3]);
1649 muonSA->setTgcMidF(tgcFitResult.tgcMidRhoChi2, tgcFitResult.tgcMidRhoNin,
1650 tgcFitResult.tgcMidPhiChi2, tgcFitResult.tgcMidPhiNin);
1651 }
1652 } else {
1653 // RPC fit results
1654 if (rpcFitResult.isSuccess ) {
1655 // Fill middle fit results for the moment
1656
1657 muonSA->setRpcFitInn(rpcFitResult.phi_inner, rpcFitResult.slope_inner, rpcFitResult.offset_inner);
1658 muonSA->setRpcFitMid(rpcFitResult.phi_middle, rpcFitResult.slope_middle, rpcFitResult.offset_middle);
1659 muonSA->setRpcFitOut(rpcFitResult.phi_outer, rpcFitResult.slope_outer, rpcFitResult.offset_outer);
1660 }
1661 }
1662
1663 // Store track positions if set of (R, Z, eta, phi) are all available
1664 if (pattern.s_address==-1) { // endcap
1665
1666 // Inner
1667 if ( std::abs(pattern.superPoints[inner].R) > ZERO_LIMIT && std::abs(pattern.superPoints[inner].Z) > ZERO_LIMIT ) { // if R and Z exist
1668 if ( tgcFitResult.isSuccess && std::abs(tgcFitResult.tgcInn[3]) > ZERO_LIMIT ) { // if phi exist
1669 float theta = std::atan(pattern.superPoints[inner].R/std::abs(pattern.superPoints[inner].Z));
1670 float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[inner].Z/std::abs(pattern.superPoints[inner].Z): 0.;
1671 muonSA->setTrackPosition( pattern.superPoints[inner].R, pattern.superPoints[inner].Z, eta, tgcFitResult.tgcInn[1] );
1672 }
1673 }
1674
1675 // Middle
1676 if ( std::abs(pattern.superPoints[middle].R) > ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) > ZERO_LIMIT ) { // if R and Z exist
1677 float phi = 0;
1678 if (tgcFitResult.isSuccess && ( std::abs(tgcFitResult.tgcMid1[3]) > ZERO_LIMIT || std::abs(tgcFitResult.tgcMid2[3]) > ZERO_LIMIT )) { // if phi exist
1679 double phi1 = tgcFitResult.tgcMid1[1];
1680 double phi2 = tgcFitResult.tgcMid2[1];
1681 if ( tgcFitResult.tgcMid1[3]==0. || tgcFitResult.tgcMid2[3]==0. ) {
1682 if ( std::abs(tgcFitResult.tgcMid1[3]) > ZERO_LIMIT ) phi = phi1;
1683 if ( std::abs(tgcFitResult.tgcMid2[3]) > ZERO_LIMIT ) phi = phi2;
1684 } else if( phi1*phi2 < 0 && std::abs(phi1)>(M_PI/2.) ) {
1685 double tmp1 = (phi1>0)? phi1 - M_PI : phi1 + M_PI;
1686 double tmp2 = (phi2>0)? phi2 - M_PI : phi2 + M_PI;
1687 double tmp = (tmp1+tmp2)/2.;
1688 phi = (tmp>0.)? tmp - M_PI : tmp + M_PI;
1689 } else {
1690 phi = (phi2+phi1)/2.;
1691 }
1692 } else {
1693 phi = roi->phi();
1694 }
1695 float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
1696 float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
1697 muonSA->setTrackPosition( pattern.superPoints[middle].R, pattern.superPoints[middle].Z, eta, phi );
1698 }
1699
1700 } else { // barrel
1701
1702 // Middle
1703 if ( std::abs(pattern.superPoints[middle].R) > ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) > ZERO_LIMIT ) { // if R and Z exist
1704 float phi = 0;
1705 if (rpcFitResult.isSuccess) {
1706 phi = rpcFitResult.phi;
1707 } else {
1708 phi = roi->phi();
1709 }
1710 float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
1711 float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
1712 muonSA->setTrackPosition( pattern.superPoints[middle].R, pattern.superPoints[middle].Z, eta, phi );
1713 }
1714
1715 // Not stored outer position for the moment as the phi is not available
1716
1717 }
1718 outputTracks.push_back(muonSA);
1719
1720 return true;
1721}
1722
1723
1725 const TrigL2MuonSA::TrackPattern& pattern,
1726 const DataVector<xAOD::L2StandAloneMuon>& outputTracks,
1727 TrigRoiDescriptorCollection& outputMS) const
1728{
1729 const float ZERO_LIMIT = 1.e-5;
1730
1731 const xAOD::L2StandAloneMuon* muonSA = outputTracks[0];
1732
1733 float mseta = pattern.etaMap;
1734 float msphi = pattern.phiMS;
1735
1736 // store TrigRoiDescriptor
1737 if (std::abs(muonSA->pt()) < ZERO_LIMIT ) {
1738 mseta = roids->eta();
1739 msphi = roids->phi();
1740 }
1741
1742 // set width of 0.1 so that ID tracking monitoring works
1743 const float phiHalfWidth = 0.1;
1744 const float etaHalfWidth = 0.1;
1745
1746 TrigRoiDescriptor* MSroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
1747 roids->l1Id(),
1748 roids->roiId(),
1749 mseta,
1750 mseta - etaHalfWidth,
1751 mseta + etaHalfWidth,
1752 msphi,
1753 msphi - phiHalfWidth,
1754 msphi + phiHalfWidth);
1755
1756 ATH_MSG_VERBOSE("...TrigRoiDescriptor for MS "
1757 << "mseta/msphi="
1758 << mseta << "/" << msphi);
1759
1760 ATH_MSG_VERBOSE("will Record an RoiDescriptor for TrigMoore:"
1761 << " phi=" << MSroiDescriptor->phi()
1762 << ", eta=" << MSroiDescriptor->eta());
1763
1764 outputMS.push_back(MSroiDescriptor);
1765
1766 return true;
1767}
1768
1769
1771 const TrigL2MuonSA::TrackPattern& pattern,
1772 const DataVector<xAOD::L2StandAloneMuon>& outputTracks,
1773 TrigRoiDescriptorCollection& outputID) const
1774{
1775
1776 if (m_fill_FSIDRoI) { // this mode will be used in cosmic run, if ID expert want to run full scan FTF.
1777 TrigRoiDescriptor* IDroiDescriptor = new TrigRoiDescriptor(true);
1778 outputID.push_back(IDroiDescriptor);
1779 return true;
1780 }
1781
1782 const float ZERO_LIMIT = 1.e-5;
1783
1784 const double scalePhiWidthForFailure = 2;
1785 const double scaleRoIforZeroPt = 2;
1786
1787 const xAOD::L2StandAloneMuon* muonSA = outputTracks[0];
1788
1789 // store TrigRoiDescriptor
1790 if (std::abs(muonSA->pt()) > ZERO_LIMIT ) {
1791
1792 // patch for the ID RoI descriptor
1793 float phiHalfWidth = 0.1;
1794 float etaHalfWidth = 0.1;
1795
1796 // 2010 runs
1797 // if ( std::abs(pattern.etaVtx)>1 && std::abs(pattern.etaVtx)<1.5 ) {
1798 // phiHalfWidth = 0.25;
1799 // etaHalfWidth = 0.4;
1800 // } else {
1801 // phiHalfWidth = 0.1;
1802 // etaHalfWidth = 0.15;
1803 // }
1804
1805 // 2011a tuning
1806 phiHalfWidth = getRoiSizeForID(false,muonSA);
1807 etaHalfWidth = getRoiSizeForID(true, muonSA);
1808
1809 if (pattern.isTgcFailure || pattern.isRpcFailure)
1810 phiHalfWidth *= scalePhiWidthForFailure;
1811
1812 TrigRoiDescriptor* IDroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
1813 roids->l1Id(),
1814 roids->roiId(),
1815 pattern.etaVtx,
1816 pattern.etaVtx - etaHalfWidth,
1817 pattern.etaVtx + etaHalfWidth,
1818 pattern.phiVtx,
1819 pattern.phiVtx - phiHalfWidth,
1820 pattern.phiVtx + phiHalfWidth);
1821
1822 ATH_MSG_VERBOSE("...TrigRoiDescriptor for ID "
1823 << "pattern.etaVtx/pattern.phiVtx="
1824 << pattern.etaVtx << "/" << pattern.phiVtx);
1825
1826 ATH_MSG_VERBOSE("will Record an RoiDescriptor for Inner Detector:"
1827 << " phi=" << IDroiDescriptor->phi()
1828 << ", eta=" << IDroiDescriptor->eta());
1829
1830 outputID.push_back(IDroiDescriptor);
1831
1832 } else { // pt = 0.
1833
1834 TrigRoiDescriptor* IDroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
1835 roids->l1Id(),
1836 roids->roiId(),
1837 roids->eta(),
1838 roids->eta() - (roids->eta() - roids->etaMinus()) * scaleRoIforZeroPt,
1839 roids->eta() + (roids->etaPlus() - roids->eta()) * scaleRoIforZeroPt,
1840 roids->phi(),
1841 CxxUtils::wrapToPi(roids->phi() - CxxUtils::wrapToPi(roids->phiPlus() - roids->phiMinus())/2. * scaleRoIforZeroPt),
1842 CxxUtils::wrapToPi(roids->phi() + CxxUtils::wrapToPi(roids->phiPlus() - roids->phiMinus())/2. * scaleRoIforZeroPt));
1843
1844 ATH_MSG_VERBOSE("will Record an RoiDescriptor for Inner Detector in case with zero pT:"
1845 << " phi=" << IDroiDescriptor->phi()
1846 << ", phi min=" << IDroiDescriptor->phiMinus()
1847 << ", phi max=" << IDroiDescriptor->phiPlus()
1848 << ", eta=" << IDroiDescriptor->eta()
1849 << ", eta min=" << IDroiDescriptor->etaMinus()
1850 << ", eta max=" << IDroiDescriptor->etaPlus());
1851
1852 outputID.push_back(IDroiDescriptor);
1853 }
1854
1855 return true;
1856}
1857
1858
1859// --------------------------------------------------------------------------------
1860// --------------------------------------------------------------------------------
1861
1862int MuFastSteering::L2MuonAlgoMap(const std::string& name) const
1863{
1864 int algoId = 0;
1865 if (name == "MuFastSteering_Muon") {
1867 } else if (name == "MuFastSteering_900GeV") {
1869 } else {
1871 }
1872
1873 return algoId;
1874}
1875
1876// --------------------------------------------------------------------------------
1877// --------------------------------------------------------------------------------
1878
1879float MuFastSteering::getRoiSizeForID(bool isEta, const xAOD::L2StandAloneMuon* muonSA) const
1880{
1881 bool isBarrel = (muonSA->sAddress()==-1) ? true : false;
1882 float eta = muonSA->etaMS();
1883 float phi = muonSA->phiMS();
1884 float pt = muonSA->pt();
1885
1886 //
1887 const int N_PARAMS = 2;
1888
1889 //
1890 const float etaMinWin_brl = 0.10;
1891 const float etaMinWin_ec1 = 0.10;
1892 const float etaMinWin_ec2 = 0.10;
1893 const float etaMinWin_ec3 = 0.10;
1894 const float etaMinWin_ecA = 0.10;
1895 const float etaMinWin_ecB = 0.10;
1896
1897 const float etaMaxWin_brl = 0.20;
1898 const float etaMaxWin_ec1 = 0.20;
1899 const float etaMaxWin_ec2 = 0.20;
1900 const float etaMaxWin_ec3 = 0.20;
1901 const float etaMaxWin_ecA = 0.20;
1902 const float etaMaxWin_ecB = 0.20;
1903
1904 const float etaParams_brl[N_PARAMS] = { 0.038, 0.284};
1905 const float etaParams_ec1[N_PARAMS] = { 0.011, 0.519};
1906 const float etaParams_ec2[N_PARAMS] = { 0.023, 0.253};
1907 const float etaParams_ec3[N_PARAMS] = { 0.018, 0.519};
1908 const float etaParams_ecA[N_PARAMS] = { 0.010, 0.431};
1909 const float etaParams_ecB[N_PARAMS] = { 0.023, 0.236};
1910
1911 //
1912 const float phiMinWin_brl = 0.125;
1913 const float phiMinWin_ec1 = 0.125;
1914 const float phiMinWin_ec2 = 0.125;
1915 const float phiMinWin_ec3 = 0.10;
1916 const float phiMinWin_ecA = 0.15;
1917 const float phiMinWin_ecB = 0.15;
1918
1919 const float phiMaxWin_brl = 0.20;
1920 const float phiMaxWin_ec1 = 0.20;
1921 const float phiMaxWin_ec2 = 0.20;
1922 const float phiMaxWin_ec3 = 0.20;
1923 const float phiMaxWin_ecA = 0.25;
1924 const float phiMaxWin_ecB = 0.20;
1925
1926 const float phiParams_brl[N_PARAMS] = { 0.000, 0.831};
1927 const float phiParams_ec1[N_PARAMS] = { 0.000, 0.885};
1928 const float phiParams_ec2[N_PARAMS] = { 0.015, 0.552};
1929 const float phiParams_ec3[N_PARAMS] = { 0.008, 0.576};
1930 const float phiParams_ecA[N_PARAMS] = { 0.000, 0.830};
1931 const float phiParams_ecB[N_PARAMS] = { 0.006, 1.331};
1932
1933 //
1934 float minWin;
1935 float maxWin;
1936 float params[N_PARAMS];
1937 if( isBarrel ) {
1938 if( isEta ) {
1939 memcpy(params,etaParams_brl,sizeof(params));
1940 minWin = etaMinWin_brl;
1941 maxWin = etaMaxWin_brl;
1942 }
1943 else {
1944 memcpy(params,phiParams_brl,sizeof(params));
1945 minWin = phiMinWin_brl;
1946 maxWin = phiMaxWin_brl;
1947 }
1948 }
1949 else { // endcap
1952
1953 if( isEta ) {
1954 memcpy(params,etaParams_ecA,sizeof(params));
1955 minWin = etaMinWin_ecA;
1956 maxWin = etaMaxWin_ecA;
1957 }
1958 else {
1959 memcpy(params,phiParams_ecA,sizeof(params));
1960 minWin = phiMinWin_ecA;
1961 maxWin = phiMaxWin_ecA;
1962 }
1963 }
1965 if( isEta ) {
1966 memcpy(params,etaParams_ecB,sizeof(params));
1967 minWin = etaMinWin_ecB;
1968 maxWin = etaMaxWin_ecB;
1969 }
1970 else {
1971 memcpy(params,phiParams_ecB,sizeof(params));
1972 minWin = phiMinWin_ecB;
1973 maxWin = phiMaxWin_ecB;
1974 }
1975 }
1976 else {
1977 if( std::abs(eta) < 1.5 ) {
1978 if( isEta ) {
1979 memcpy(params,etaParams_ec1,sizeof(params));
1980 minWin = etaMinWin_ec1;
1981 maxWin = etaMaxWin_ec1;
1982 }
1983 else {
1984 memcpy(params,phiParams_ec1,sizeof(params));
1985 minWin = phiMinWin_ec1;
1986 maxWin = phiMaxWin_ec1;
1987 }
1988 }
1989 else if( std::abs(eta) < 2.0 ) {
1990 if( isEta ) {
1991 memcpy(params,etaParams_ec2,sizeof(params));
1992 minWin = etaMinWin_ec2;
1993 maxWin = etaMaxWin_ec2;
1994 }
1995 else {
1996 memcpy(params,phiParams_ec2,sizeof(params));
1997 minWin = phiMinWin_ec2;
1998 maxWin = phiMaxWin_ec2;
1999 }
2000 }
2001 else {
2002 if( isEta ) {
2003 memcpy(params,etaParams_ec3,sizeof(params));
2004 minWin = etaMinWin_ec3;
2005 maxWin = etaMaxWin_ec3;
2006 }
2007 else {
2008 memcpy(params,phiParams_ec3,sizeof(params));
2009 minWin = phiMinWin_ec3;
2010 maxWin = phiMaxWin_ec3;
2011 }
2012 }
2013 }
2014 }
2015
2016 //
2017 float x = params[0] + params[1] / pt;
2018 float retval = x;
2019 if( x < minWin ) retval = minWin;
2020 if( x > maxWin ) retval = maxWin;
2021
2022 return retval;
2023}
2024
2025// --------------------------------------------------------------------------------
2026// --------------------------------------------------------------------------------
2027
2029 const TrigL2MuonSA::MdtHits& mdtHits,
2030 std::vector<TrigL2MuonSA::TrackPattern>& trackPatterns ) const
2031{
2032 // initialize monitored variable
2033 auto inner_mdt_hits = Monitored::Scalar("InnMdtHits", -1);
2034 auto middle_mdt_hits = Monitored::Scalar("MidMdtHits", -1);
2035 auto outer_mdt_hits = Monitored::Scalar("OutMdtHits", -1);
2036 auto invalid_rpc_roi_number = Monitored::Scalar("InvalidRpcRoINumber", -1);
2037
2038 auto efficiency = Monitored::Scalar("Efficiency", 0);
2039 auto sag_inverse = Monitored::Scalar("SagInv", 9999.);
2040 auto address = Monitored::Scalar("Address", 9999.);
2041 auto absolute_pt = Monitored::Scalar("AbsPt", 9999.);
2042 auto sagitta = Monitored::Scalar("Sagitta", 9999.);
2043 auto track_pt = Monitored::Scalar("TrackPt", 9999.);
2044
2045 std::vector<float> t_eta, t_phi;
2046 std::vector<float> f_eta, f_phi;
2047 std::vector<float> r_inner, r_middle, r_outer;
2048 std::vector<float> f_residuals;
2049
2050 auto track_eta = Monitored::Collection("TrackEta", t_eta);
2051 auto track_phi = Monitored::Collection("TrackPhi", t_phi);
2052 auto failed_eta = Monitored::Collection("FailedRoIEta", f_eta);
2053 auto failed_phi = Monitored::Collection("FailedRoIPhi", f_phi);
2054 auto res_inner = Monitored::Collection("ResInner", r_inner);
2055 auto res_middle = Monitored::Collection("ResMiddle", r_middle);
2056 auto res_outer = Monitored::Collection("ResOuter", r_outer);
2057 auto fit_residuals = Monitored::Collection("FitResiduals", f_residuals);
2058
2059 auto monitorIt = Monitored::Group(m_monTool, inner_mdt_hits, middle_mdt_hits, outer_mdt_hits,
2060 invalid_rpc_roi_number,
2061 efficiency, sag_inverse, address, absolute_pt, sagitta, track_pt,
2062 track_eta, track_phi, failed_eta, failed_phi,
2063 res_inner, res_middle, res_outer, fit_residuals );
2064
2065 const float ZERO_LIMIT = 1e-5;
2066
2067 if( !trackPatterns.empty() ) {
2068
2069 efficiency = 1;
2070
2071 const TrigL2MuonSA::TrackPattern& pattern = trackPatterns[0];
2072 float norm = 10.;
2073
2074 float count_inner = 0;
2075 float count_middle = 0;
2076 float count_outer = 0;
2077
2078 for (const TrigL2MuonSA::MdtHitData& mdtHit : mdtHits) {
2079
2080 if (std::abs(mdtHit.DriftSpace) < ZERO_LIMIT) continue;
2081
2082 char st = mdtHit.cType[1];
2083
2084 if (st=='I') {
2085 count_inner++;
2086 r_inner.push_back(mdtHit.Residual/norm);
2087 if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2088 }
2089
2090 if (st=='M') {
2091 count_middle++;
2092 r_middle.push_back(mdtHit.Residual/norm);
2093 if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2094 }
2095
2096 if (st=='O') {
2097 count_outer++;
2098 r_outer.push_back(mdtHit.Residual/norm);
2099 if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2100 }
2101 }
2102
2103 inner_mdt_hits = count_inner;
2104 middle_mdt_hits = count_middle;
2105 outer_mdt_hits = count_outer;
2106
2107 track_pt = (std::abs(pattern.pt ) > ZERO_LIMIT)? pattern.charge*pattern.pt: 9999.;
2108 absolute_pt = std::abs(track_pt);
2109
2110 if ( std::abs(pattern.etaMap) > ZERO_LIMIT || std::abs(pattern.phiMS) > ZERO_LIMIT ) {
2111 t_eta.push_back(pattern.etaMap);
2112 t_phi.push_back(pattern.phiMS);
2113 }
2114 if ( std::abs(pattern.pt ) < ZERO_LIMIT){
2115 f_eta.push_back(roi->eta());
2116 f_phi.push_back(roi->phi());
2117 }
2118
2119 sagitta = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? pattern.barrelSagitta: 9999.;
2120 sag_inverse = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? 1./pattern.barrelSagitta: 9999.;
2121 address = pattern.s_address;
2122 }
2123
2124 return StatusCode::SUCCESS;
2125}
#define M_PI
Scalar eta() const
pseudorapidity method
Scalar phi() const
phi method
Scalar theta() const
theta method
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_ERROR(x,...)
#define ATH_MSG_WARNING(x,...)
#define ATH_MSG_VERBOSE(x,...)
#define ATH_MSG_INFO(x,...)
static Double_t tc
static Double_t sc
Header file to be included by clients of the Monitored infrastructure.
const LVL1::RecMuonRoI * matchingRecRoI(uint32_t roiWord, const DataVector< LVL1::RecMuonRoI > &collection)
static const double ZERO_LIMIT
size_t size() const
Number of registered mappings.
const double width
unsigned bcTag(unsigned bcBitMap)
#define x
#define z
static const Attributes_t empty
bool msgLvl(const MSG::Level lvl) const
An algorithm that can be simultaneously executed in multiple threads.
Derived DataVector<T>.
Definition DataVector.h:818
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:861
const T * at(size_type n) const
Access an element, as an rvalue.
value_type push_back(value_type pElem)
Add an element to the end of the collection.
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
size_type size() const noexcept
Returns the number of elements in the collection.
bool empty() const noexcept
Returns true if the collection is empty.
This class defines the reconstructed Muon ROI.
Definition RecMuonRoI.h:60
Group of local monitoring quantities and retain correlation when filling histograms
Declare a monitored scalar variable.
A monitored timer.
int L2MuonAlgoMap(const std::string &name) const
ToolHandle< GenericMonitoringTool > m_monTool
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muIdContainerKey
Gaudi::Property< float > m_scaleRoadBarrelMiddle
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_recRoiCollectionKey
Gaudi::Property< bool > m_use_new_segmentfit
Gaudi::Property< bool > m_use_RoIBasedDataAccess_RPC
Gaudi::Property< int > m_esd_mm_size
Gaudi::Property< float > m_dPhisurrRoI
ToolHandle< TrigL2MuonSA::MuCalStreamerTool > m_calStreamer
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
virtual StatusCode initialize() override
Gaudi::Property< int > m_esd_rpc_size
Gaudi::Property< bool > m_use_RoIBasedDataAccess_TGC
Gaudi::Property< bool > m_use_mm
Gaudi::Property< bool > m_fill_FSIDRoI
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_muCompositeContainerKey
SG::WriteHandleKey< xAOD::L2StandAloneMuonContainer > m_muFastContainerKey
StatusCode findMultiTrackSignature(const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMultiTrackSignature(), includes reconstract algorithms for multi-track mode
Gaudi::Property< bool > m_insideOut
Gaudi::Property< int > m_esd_csc_size
StatusCode findMuonSignatureIO(const xAOD::TrackParticleContainer &idtracks, const std::vector< const TrigRoiDescriptor * > &roids, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2CombinedMuon > &outputCBs, DataVector< xAOD::L2StandAloneMuon > &outputSAs, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMuonSignatureIO(), includes reconstract algorithms for inside-out mode
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MM
Gaudi::Property< bool > m_multiTrack
Gaudi::Property< double > m_rWidth_RPC_Failed
Gaudi::Property< bool > m_use_RoIBasedDataAccess_STGC
Gaudi::Property< float > m_ftfminPt
ToolHandle< TrigL2MuonSA::MuFastTrackFitter > m_trackFitter
Gaudi::Property< float > m_scaleRoadBarrelInner
ToolHandle< TrigL2MuonSA::FtfRoadDefiner > m_ftfRoadDefiner
Gaudi::Property< bool > m_use_endcapInnerFromBarrel
Gaudi::Property< int > m_esd_tgc_size
bool storeIDRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID) const
Gaudi::Property< float > m_dEtasurrRoI
Gaudi::Property< int > m_esd_mdt_size
ToolHandle< TrigL2MuonSA::MuFastPatternFinder > m_patternFinder
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muMsContainerKey
Gaudi::Property< bool > m_calDataScouting
Gaudi::Property< bool > m_use_RoIBasedDataAccess_CSC
ToolHandle< ITrigMuonBackExtrapolator > m_backExtrapolatorTool
Handle to MuonBackExtrapolator tool.
ToolHandle< TrigL2MuonSA::MuFastDataPreparator > m_dataPreparator
Gaudi::Property< bool > m_use_mcLUT
TrigL2MuonSA::RecMuonRoIUtils m_recMuonRoIUtils
ToolHandle< TrigL2MuonSA::CscSegmentMaker > m_cscsegmaker
Gaudi::Property< bool > m_use_rpc
Gaudi::Property< bool > m_topoRoad
SG::ReadHandleKey< DataVector< LVL1::RecMuonRoI > > m_run2recRoiCollectionKey
Gaudi::Property< int > m_esd_stgc_size
SG::WriteHandleKey< xAOD::L2CombinedMuonContainer > m_outputCBmuonCollKey
float getRoiSizeForID(bool isEta, const xAOD::L2StandAloneMuon *muonSA) const
bool updateOutputObjects(const xAOD::MuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns, DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const EventContext &ctx) const
Called at the end of the algorithm processing to set the steering navigation properly.
Gaudi::Property< bool > m_use_stgc
Gaudi::Property< float > m_scaleRoadBarrelOuter
Gaudi::Property< bool > m_useRun3Config
Gaudi::Property< double > m_rWidth_TGC_Failed
ToolHandle< TrigL2MuonSA::MuFastTrackExtrapolator > m_trackExtrapolator
ToolHandle< TrigL2MuonSA::MuFastStationFitter > m_stationFitter
StatusCode updateMonitor(const xAOD::MuonRoI *roi, const TrigL2MuonSA::MdtHits &mdtHits, std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns) const
Update monitoring variables.
MuFastSteering(const std::string &name, ISvcLocator *svc)
Constructor.
bool storeMuonSA(const xAOD::MuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const TrigL2MuonSA::TrackPattern &pattern, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const EventContext &ctx) const
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MDT
Gaudi::Property< double > m_winPt
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_FTFtrackKey
StatusCode findMuonSignature(const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, xAOD::TrigCompositeContainer *outputMuonCal, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMuonSignature(), includes reconstract algorithms
bool storeMSRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputMS) const
virtual StatusCode execute(const EventContext &ctx) const override
execute(), main code of the algorithm for AthenaMT
Gaudi::Property< bool > m_doEndcapForl2mt
virtual double etaMinus() const override final
gets eta at zMinus
virtual double etaPlus() const override final
gets eta at zedPlus
virtual double phi() const override final
Methods to retrieve data members.
virtual double phiMinus() const override final
gets phiMinus
virtual double eta() const override final
virtual double phiPlus() const override final
gets phiPlus
Helper class to provide type-safe access to aux data.
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
double zMin[N_STATION][N_SECTOR]
Definition MdtRegion.h:37
double rMin[N_STATION][N_SECTOR]
Definition MdtRegion.h:39
double zMax[N_STATION][N_SECTOR]
Definition MdtRegion.h:38
double etaMax[N_STATION][N_SECTOR]
Definition MdtRegion.h:42
double etaMin[N_STATION][N_SECTOR]
Definition MdtRegion.h:41
int chamberType[N_STATION][N_SECTOR][2]
Definition MdtRegion.h:45
double rMax[N_STATION][N_SECTOR]
Definition MdtRegion.h:40
double aw[N_STATION][N_SECTOR]
Definition MuonRoad.h:83
void setScales(double inner, double middle, double outer)
Definition MuonRoad.h:69
double bw[N_STATION][N_SECTOR]
Definition MuonRoad.h:84
nope - should be used for standalone also, perhaps need to protect the class def bits ifndef XAOD_ANA...
virtual unsigned int roiWord() const override final
virtual unsigned int roiId() const override final
these quantities probably don't need to be used any more
virtual unsigned int l1Id() const override final
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
void setStrategy(int value)
set algorithm strategy flag
void setErrorFlag(int value)
set algorithm error flag
void setIdTrackLink(const ElementLink< xAOD::TrackParticleContainer > &link)
set ID track used to make the CB muon
void setMuSATrackLink(const ElementLink< xAOD::L2StandAloneMuonContainer > &link)
set SA muon used to make the CB muon
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
void setCharge(float value)
set seeding muon charge
void setRegionR(int station, int sector, float min, float max)
R range.
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
void setStgcCluster(const unsigned int layer, const int isOutlier, const int type, const float eta, const float phi, const float r, const float z, const float residualR, const float residualPhi, const int stationEta, const int stationPhi, const int stationName)
Set sTGC hits.
void setBeta(float value)
Set beta.
void setRpcFitInn(float phi, float slope, float offset)
Set the results of RPC fit.
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
void setRpcHit(uint32_t layer, uint32_t measuresPhi, float x, float y, float z, float time, float distEta, float distPhi, const std::string &stationName)
Set RPC hits.
void setCscHit(int isOutlier, int chamber, uint32_t stationName, int stationEta, int stationPhi, int chamberLayer, int wireLayer, int measuresPhi, int strip, float eta, float phi, float r, float z, int charge, float time, float residual)
Set the properties of each CSC tube.
void setBarrelSagitta(float value)
Set the fitted sagitta of the muon in the barrel.
int sAddress() const
Get the station address of the muon.
void setDeltaPt(float value)
Set error of pT.
void setEtaMS(float value)
Set the eta at muon spectrometer.
void setMdtHit(uint32_t onlineId, int isOutier, int chamber, float r, float z, float phi, float residual, float time, float space, float sigma)
Set the properties of each MDT tube.
void setTgcInn(float eta, float phi, float r, float z)
Set the results of TGC fit.
void setMmClustersCapacity(const int value)
Set size of storage for MM clusters.
void setDeltaEta(float value)
Set error of eta.
void setRoiSystem(uint32_t value)
void setRoad(int station, int sector, float aw, float bw)
Road.
void setTgcHit(float eta, float phi, float r, float z, float width, int stationNum, bool isStrip, int bcTag, bool inRoad)
Set TGC hits.
void setRoiNumber(uint32_t value)
void setDeltaPhi(float value)
Set error of phi.
void setPtEndcapRadius(float value)
void setTgcMid2(float eta, float phi, float r, float z)
float etaMS() const
Get the eta at muon spectrometer.
float phiMS() const
Get the phi at muon spectrometer.
void setStgcClustersCapacity(const int value)
Set size of storage for sTGC clusters.
void setTrackPosition(float r, float z, float eta, float phi)
Set position of muon track.
void setRMS(float value)
Set the R at muon spectrometer.
void setPtCSC(float value)
void setLumiBlock(uint32_t value)
void setRoiThreshold(uint32_t value)
void setTgcMidF(float rhoChi2, long rhoN, float phiChi2, long phiN)
void setPhiMap(float value)
Set phi used to refer pT LUT.
void setIsTgcFailure(int value)
Set flag to record if TGC is properly read.
void setRoiSubsystem(uint32_t value)
void setRpcHitsCapacity(int value)
Size of storage to be reserved.
virtual double pt() const
The transverse momentum ( ) of the particle.
void setRoiSector(uint32_t value)
void setRpcFitOut(float phi, float slope, float offset)
void setLvl1Id(uint32_t value)
void setChamberType2(int station, int sector, int chamberType)
void setMmCluster(const unsigned int layer, const int isOutlier, const float eta, const float phi, const float r, const float z, const float residualR, const float residualPhi, const int stationEta, const int stationPhi, const int stationName)
Set MM hits.
void setEtaBin(int value)
Set eta bin of pT LUT.
void setEtaMap(float value)
Set eta used to refer pT LUT.
void setMuonDetMask(uint32_t value)
void setDirPhiMS(float value)
Set tan phi at muon spectrometer.
void setPtEndcapBeta(float value)
void setCscHitsCapacity(int value)
Set size of storage for CSC hits.
void setRegionZ(int station, int sector, float min, float max)
Z range.
void setEndcapRadius(float value)
Set the fitted radius of the muon in the endcap.
void setEndcapBeta(float value)
Set the fitted value in the endcap.
void setChamberType1(int station, int sector, int chamberType)
Set the muon road information.
void setSAddress(int value)
Set the station address of the muon.
void setRpcFitMid(float phi, float slope, float offset)
void setPhiMS(float value)
Set the phi at muon spectrometer.
void setEndcapAlpha(float value)
Set the fitted value in the endcap.
void setRoIWord(uint32_t value)
Set the RoI ID of the seeding LVL1 muon.
void setRoiId(uint32_t value)
void setTgcHitsCapacity(int value)
Set size of storage for TGC hits.
void setRoiEta(float value)
void setTgcMid1(float eta, float phi, float r, float z)
void setRegionEta(int station, int sector, float min, float max)
Eta range.
void setIsRpcFailure(int value)
Set flag to record if RPC is properly read.
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
void setRoiPhi(float value)
void setSuperPoint(int chamber, float r, float z, float slope, float intercept=0., float chi2=0.)
Set the properties of one particular super point measurement.
void setMdtHitsCapacity(int value)
Set size of storage for MDT hits.
void setDirZMS(float value)
Set dRdZ at muon spectrometer.
void setAlgoId(int value)
void setPhiBin(int value)
Set phi bin of pT LUT.
void setZMS(float value)
Set the Z at muon spectrometer.
void setBarrelRadius(float value)
Set the fitted radius of the muon in the barrel.
void setPtEndcapAlpha(float value)
void setTgcPt(float value)
void setTgcInnF(float rhoStd, long rhoN, float phiStd, long phiN)
float eta() const
The pseudorapidity ( ) of the muon candidate.
Hemisphere getHemisphere() const
Returns the hemisphere that detected the muon candidate.
RoISource getSource() const
Returns the system that detected the muon candidate.
uint32_t roiWord() const
The "raw" RoI word describing the muon candidate.
int getThrNumber() const
Get the logic number of the highest threshold this RoI passed.
float phi() const
The azimuthal angle ( ) of the muon candidate.
int getSectorID() const
Get the sector ID number.
int getRoI() const
Get the "RoI number" (position inside the sector).
void efficiency(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
int r
Definition globals.cxx:22
constexpr T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition phihelper.h:31
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
std::vector< StgcHitData > StgcHits
Definition StgcData.h:49
std::vector< MdtHitData > MdtHits
Definition MdtData.h:56
std::vector< MmHitData > MmHits
Definition MmData.h:47
std::vector< CscHitData > CscHits
Definition CscData.h:40
std::vector< RpcHitData > RpcHits
Definition RpcData.h:57
std::vector< TgcHitData > TgcHits
Definition TgcData.h:43
@ BarrelInner
Inner station in the barrel spectrometer.
@ EndcapOuter
Outer station in the endcap spectrometer.
@ BarrelMiddle
Middle station in the barrel spectrometer.
@ EndcapMiddle
Middle station in the endcap spectrometer.
@ BEE
BEE measurement point.
@ EndcapExtra
Extra station in the endcap spectrometer.
@ BarrelOuter
Outer station in the barrel spectrometer.
@ BME
BME measurement point.
@ EndcapInner
Inner station in the endcap spectrometer.
ECRegions whichECRegion(const float eta, const float phi)
TrigCompositeContainer_v1 TrigCompositeContainer
Declare the latest version of the container.
MuonRoIContainer_v1 MuonRoIContainer
L2CombinedMuon_v1 L2CombinedMuon
Define the latest version of the muon CB class.
TrigComposite_v1 TrigComposite
Declare the latest version of the class.
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
L2StandAloneMuon_v2 L2StandAloneMuon
Define the latest version of the muon SA class.
MuonRoI_v1 MuonRoI
Definition MuonRoI.h:15
Helper for azimuthal angle calculations.
#define unlikely(x)