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