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