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