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