Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
MMTriggerTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "TrigT1NSWSimTools/MMTriggerTool.h"
6 
7 namespace NSWL1 {
8 
9  MMTriggerTool::MMTriggerTool( const std::string& type, const std::string& name, const IInterface* parent) :
10  base_class(type,name,parent),
11  m_MmIdHelper(nullptr) {}
12 
13  StatusCode MMTriggerTool::initialize() {
14 
15  ATH_MSG_DEBUG( "initializing -- " << name() );
16 
17  ATH_MSG_DEBUG( name() << " configuration:");
18  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_mmDigitContainer.name() << m_mmDigitContainer.value());
19  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_doNtuple.name() << ((m_doNtuple)? "[True]":"[False]")
20  << std::setfill(' ') << std::setiosflags(std::ios::right) );
21 
22  ATH_CHECK(m_keyMcEventCollection.initialize(m_isMC));
23  ATH_CHECK(m_keyMuonEntryLayer.initialize(m_isMC));
24  ATH_CHECK(m_keyMmDigitContainer.initialize());
25 
26  if(m_doNtuple and Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
27  ATH_MSG_ERROR("DoNtuple is not possible in multi-threaded mode");
28  return StatusCode::FAILURE;
29  }
30 
31  // retrieve the MuonDetectormanager
32  ATH_CHECK(m_detManagerKey.initialize());
33 
34  // retrieve the Mm offline Id helper
35  ATH_CHECK( detStore()->retrieve( m_MmIdHelper ) );
36 
37  return StatusCode::SUCCESS;
38  }
39 
40  void MMTriggerTool::fillPointers(const MuonGM::MuonDetectorManager* detManager) const{
41 
42  std::lock_guard guard{m_mutex};
43  if (m_isInitialized) {
44  return;
45  }
46 
47  m_par_large = std::make_shared<MMT_Parameters>("xxuvuvxx",'L', detManager);
48  m_par_small = std::make_shared<MMT_Parameters>("xxuvuvxx",'S', detManager);
49 
50  m_isInitialized=true;
51  }
52 
53  StatusCode MMTriggerTool::attachBranches(MuonVal::MuonTesterTree &tree) {
54  m_trigger_diamond_ntrig = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_ntrig");
55  m_trigger_diamond_bc = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_bc");
56  m_trigger_diamond_sector = std::make_shared<MuonVal::VectorBranch<char> >(tree, "MM_diamond_sector");
57  m_trigger_diamond_stationPhi = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_stationPhi");
58  m_trigger_diamond_totalCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_totalCount");
59  m_trigger_diamond_realCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_realCount");
60  m_trigger_diamond_iX = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iX");
61  m_trigger_diamond_iU = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iU");
62  m_trigger_diamond_iV = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iV");
63  m_trigger_diamond_XbkgCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_XbkgCount");
64  m_trigger_diamond_UVbkgCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_UVbkgCount");
65  m_trigger_diamond_XmuonCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_XmuonCount");
66  m_trigger_diamond_UVmuonCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_UVmuonCount");
67  m_trigger_diamond_age = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_age");
68  m_trigger_diamond_mx = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mx");
69  m_trigger_diamond_my = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_my");
70  m_trigger_diamond_Uavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Uavg");
71  m_trigger_diamond_Vavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Vavg");
72  m_trigger_diamond_mxl = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mxl");
73  m_trigger_diamond_theta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_theta");
74  m_trigger_diamond_eta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_eta");
75  m_trigger_diamond_dtheta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_dtheta");
76  m_trigger_diamond_phi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phi");
77  m_trigger_diamond_phiShf = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phiShf");
78  m_trigger_diamond_TP_phi_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_phi_id");
79  m_trigger_diamond_TP_R_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_R_id");
80  m_trigger_diamond_TP_dTheta_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_dTheta_id");
81  m_trigger_RZslopes = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_RZslopes");
82  m_trigger_trueEtaRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaRange");
83  m_trigger_truePtRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePtRange");
84  m_trigger_VMM = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_VMM");
85  m_trigger_plane = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_plane");
86  m_trigger_station = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_station");
87  m_trigger_strip = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_strip");
88  m_trigger_slope = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_slope");
89  m_trigger_trueThe = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThe");
90  m_trigger_truePhi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhi");
91  m_trigger_trueDth = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueDth");
92  m_trigger_trueEtaEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaEnt");
93  m_trigger_trueTheEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueTheEnt");
94  m_trigger_truePhiEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiEnt");
95  m_trigger_trueEtaPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaPos");
96  m_trigger_trueThePos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThePos");
97  m_trigger_truePhiPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiPos");
98 
99  tree.addBranch(m_trigger_diamond_ntrig);
100  tree.addBranch(m_trigger_diamond_bc);
101  tree.addBranch(m_trigger_diamond_sector);
102  tree.addBranch(m_trigger_diamond_stationPhi);
103  tree.addBranch(m_trigger_diamond_totalCount);
104  tree.addBranch(m_trigger_diamond_realCount);
105  tree.addBranch(m_trigger_diamond_iX);
106  tree.addBranch(m_trigger_diamond_iU);
107  tree.addBranch(m_trigger_diamond_iV);
108  tree.addBranch(m_trigger_diamond_XbkgCount);
109  tree.addBranch(m_trigger_diamond_UVbkgCount);
110  tree.addBranch(m_trigger_diamond_XmuonCount);
111  tree.addBranch(m_trigger_diamond_UVmuonCount);
112  tree.addBranch(m_trigger_diamond_age);
113  tree.addBranch(m_trigger_diamond_mx);
114  tree.addBranch(m_trigger_diamond_my);
115  tree.addBranch(m_trigger_diamond_Uavg);
116  tree.addBranch(m_trigger_diamond_Vavg);
117  tree.addBranch(m_trigger_diamond_mxl);
118  tree.addBranch(m_trigger_diamond_theta);
119  tree.addBranch(m_trigger_diamond_eta);
120  tree.addBranch(m_trigger_diamond_dtheta);
121  tree.addBranch(m_trigger_diamond_phi);
122  tree.addBranch(m_trigger_diamond_phiShf);
123  tree.addBranch(m_trigger_diamond_TP_phi_id);
124  tree.addBranch(m_trigger_diamond_TP_R_id);
125  tree.addBranch(m_trigger_diamond_TP_dTheta_id);
126  tree.addBranch(m_trigger_RZslopes);
127  tree.addBranch(m_trigger_trueEtaRange);
128  tree.addBranch(m_trigger_truePtRange);
129  tree.addBranch(m_trigger_VMM);
130  tree.addBranch(m_trigger_plane);
131  tree.addBranch(m_trigger_station);
132  tree.addBranch(m_trigger_strip);
133  tree.addBranch(m_trigger_slope);
134  tree.addBranch(m_trigger_trueThe);
135  tree.addBranch(m_trigger_truePhi);
136  tree.addBranch(m_trigger_trueDth);
137  tree.addBranch(m_trigger_trueEtaEnt);
138  tree.addBranch(m_trigger_trueTheEnt);
139  tree.addBranch(m_trigger_truePhiEnt);
140  tree.addBranch(m_trigger_trueEtaPos);
141  tree.addBranch(m_trigger_trueThePos);
142  tree.addBranch(m_trigger_truePhiPos);
143  return StatusCode::SUCCESS;
144  }
145 
146  StatusCode MMTriggerTool::runTrigger(const EventContext& ctx, Muon::NSW_TrigRawDataContainer* rdo, const bool do_MMDiamonds) const {
147 
148  uint64_t event = ctx.eventID().event_number();
149  ATH_MSG_DEBUG("********************************************************* EVENT NUMBER = " << event);
150 
152  // //
153  // Load Variables From Containers into our Data Structures //
154  // //
156  SG::ReadCondHandle<MuonGM::MuonDetectorManager> detManagerHandle{m_detManagerKey, ctx};
157  const MuonGM::MuonDetectorManager* detManager = detManagerHandle.cptr();
158 
159  if(!m_isInitialized) {fillPointers(detManager);}
160  std::map<std::string, std::shared_ptr<MMT_Parameters> > pars;
161  pars["MML"] = m_par_large;
162  pars["MMS"] = m_par_small;
163  MMLoadVariables load = MMLoadVariables(detManager, m_MmIdHelper);
164 
165  std::map<std::pair<uint64_t, unsigned int>,std::vector<digitWrapper> > entries;
166  std::map<std::pair<uint64_t, unsigned int>,std::vector<hitData_entry> > Hits_Data_Set_Time;
167  std::map<std::pair<uint64_t, unsigned int>,evInf_entry> Event_Info;
168 
169  const McEventCollection* ptrMcEventCollection = nullptr;
170  const TrackRecordCollection* ptrMuonEntryLayer = nullptr;
171  if(m_isMC){
172  SG::ReadHandle<McEventCollection> readMcEventCollection( m_keyMcEventCollection, ctx );
173  if( !readMcEventCollection.isValid() ){
174  ATH_MSG_ERROR("Cannot retrieve McEventCollection");
175  return StatusCode::FAILURE;
176  }
177  if(m_doTruth) ptrMcEventCollection = readMcEventCollection.cptr();
178  SG::ReadHandle<TrackRecordCollection> readMuonEntryLayer( m_keyMuonEntryLayer, ctx );
179  if( !readMuonEntryLayer.isValid() ){
180  ATH_MSG_ERROR("Cannot retrieve MuonEntryLayer");
181  return StatusCode::FAILURE;
182  }
183  if(m_doTruth) ptrMuonEntryLayer = readMuonEntryLayer.cptr();
184  }
185 
186  SG::ReadHandle<MmDigitContainer> readMmDigitContainer( m_keyMmDigitContainer, ctx );
187  if( !readMmDigitContainer.isValid() ){
188  ATH_MSG_ERROR("Cannot retrieve MmDigitContainer");
189  return StatusCode::FAILURE;
190  }
191 
192  ATH_CHECK( load.getMMDigitsInfo(ctx, ptrMcEventCollection, ptrMuonEntryLayer, readMmDigitContainer.cptr(), entries, Hits_Data_Set_Time, Event_Info) );
193 
194  if (entries.empty()) {
195  ATH_MSG_WARNING("No digits available for processing, exiting");
196  Hits_Data_Set_Time.clear();
197  Event_Info.clear();
198  return StatusCode::SUCCESS;
199  }
200 
201  std::unique_ptr<MMT_Diamond> diamond = std::make_unique<MMT_Diamond>(detManager);
202  if (do_MMDiamonds) {
203  diamond->setTrapezoidalShape(m_trapShape);
204  diamond->setXthreshold(m_diamXthreshold);
205  diamond->setUV(m_uv);
206  diamond->setUVthreshold(m_diamUVthreshold);
207  diamond->setRoadSize(m_diamRoadSize);
208  diamond->setRoadSizeUpX(m_diamOverlapEtaUp);
209  diamond->setRoadSizeDownX(m_diamOverlapEtaDown);
210  diamond->setRoadSizeUpUV(m_diamOverlapStereoUp);
211  diamond->setRoadSizeDownUV(m_diamOverlapStereoDown);
212  }
213 
214  // We need to extract truth info, if available
215  for (const auto &it : Event_Info) {
216  double trueta = -999., truphi = -999., trutheta = -999., trupt = -999., dt = -999., tpos = -999., ppos = -999., epos = -999., tent = -999., pent = -999., eent = -999.;
217  trutheta = it.second.theta_ip; // truth muon at the IP
218  truphi = it.second.phi_ip;
219  trueta = it.second.eta_ip;
220  trupt = it.second.pt;
221  tpos = it.second.theta_pos; // muEntry position
222  ppos = it.second.phi_pos;
223  epos = it.second.eta_pos;
224  tent = it.second.theta_ent; // muEntry momentum
225  pent = it.second.phi_ent;
226  eent = it.second.eta_ent;
227  dt = it.second.dtheta;
228  if (m_doNtuple) {
229  m_trigger_trueEtaRange->push_back(trueta);
230  m_trigger_truePtRange->push_back(trupt);
231  m_trigger_trueThe->push_back(trutheta);
232  m_trigger_truePhi->push_back(truphi);
233  m_trigger_trueDth->push_back(dt); // theta_pos-theta_ent
234  m_trigger_trueEtaPos->push_back(epos);
235  m_trigger_trueThePos->push_back(tpos);
236  m_trigger_truePhiPos->push_back(ppos);
237  m_trigger_trueEtaEnt->push_back(eent);
238  m_trigger_trueTheEnt->push_back(tent);
239  m_trigger_truePhiEnt->push_back(pent);
240  }
241  }
242 
243  unsigned int particles = entries.rbegin()->first.second +1, nskip=0;
244  for (unsigned int i=0; i<particles; i++) {
245  std::pair<int, unsigned int> pair_event (event,i);
246 
247  // Now let's switch to reco hits: firstly, extracting the station name we're working on...
248  std::string station = "-";
249  auto event_it = entries.find(pair_event);
250  station = event_it->second[0].stName; // Station name is taken from the first digit! In MMLoadVariables there's a check to ensure all digits belong to the same station
251 
252  // Secondly, extracting the Phi of the station we're working on...
253  int stationPhi = -999;
254  digitWrapper dW = event_it->second[0];
255  Identifier tmpID = dW.id();
256  stationPhi = m_MmIdHelper->stationPhi(tmpID);
257 
258  // Finally, let's start with hits
259  auto reco_it = Hits_Data_Set_Time.find(pair_event);
260  if (reco_it != Hits_Data_Set_Time.end()) {
261  if (reco_it->second.size() >= (diamond->getXthreshold()+diamond->getUVthreshold())) {
262  if (do_MMDiamonds) {
263  /*
264  * Filling hits for each event: a new class, MMT_Hit, is called in
265  * order to use both algorithms witghout interferences
266  */
267  diamond->createRoads_fillHits(i-nskip, reco_it->second, detManager, pars[station], stationPhi);
268  if (m_doNtuple) {
269  for(const auto &hit : reco_it->second) {
270  m_trigger_VMM->push_back(hit.VMM_chip);
271  m_trigger_plane->push_back(hit.plane);
272  m_trigger_station->push_back(hit.station_eta);
273  m_trigger_strip->push_back(hit.strip);
274  }
275  std::vector<double> slopes = diamond->getHitSlopes();
276  for (const auto &s : slopes) m_trigger_RZslopes->push_back(s);
277  slopes.clear();
278  }
279  diamond->resetSlopes();
280  /*
281  * Here we create roads with all MMT_Hit collected before (if any), then we save the results
282  */
283  diamond->findDiamonds(i-nskip, event);
284 
285  if (!diamond->getSlopeVector(i-nskip).empty()) {
286  if (m_doNtuple) {
287  m_trigger_diamond_ntrig->push_back(diamond->getSlopeVector(i-nskip).size());
288  for (const auto &slope : diamond->getSlopeVector(i-nskip)) {
289  m_trigger_diamond_sector->push_back(diamond->getDiamond(i-nskip).sector);
290  m_trigger_diamond_stationPhi->push_back(diamond->getDiamond(i-nskip).stationPhi);
291  m_trigger_diamond_bc->push_back(slope.BC);
292  m_trigger_diamond_totalCount->push_back(slope.totalCount);
293  m_trigger_diamond_realCount->push_back(slope.realCount);
294  m_trigger_diamond_XbkgCount->push_back(slope.xbkg);
295  m_trigger_diamond_UVbkgCount->push_back(slope.uvbkg);
296  m_trigger_diamond_XmuonCount->push_back(slope.xmuon);
297  m_trigger_diamond_UVmuonCount->push_back(slope.uvmuon);
298  m_trigger_diamond_iX->push_back(slope.iRoad);
299  m_trigger_diamond_iU->push_back(slope.iRoadu);
300  m_trigger_diamond_iV->push_back(slope.iRoadv);
301  m_trigger_diamond_age->push_back(slope.age);
302  m_trigger_diamond_mx->push_back(slope.mx);
303  m_trigger_diamond_my->push_back(slope.my);
304  m_trigger_diamond_Uavg->push_back(slope.uavg);
305  m_trigger_diamond_Vavg->push_back(slope.vavg);
306  m_trigger_diamond_mxl->push_back(slope.mxl);
307  m_trigger_diamond_theta->push_back(slope.theta);
308  m_trigger_diamond_eta->push_back(slope.eta);
309  m_trigger_diamond_dtheta->push_back(slope.dtheta);
310  m_trigger_diamond_phi->push_back(slope.phi);
311  m_trigger_diamond_phiShf->push_back(slope.phiShf);
312  }
313  }
314 
315  // MM RDO filling below
316  std::vector<int> slopeBC;
317  for (const auto &slope : diamond->getSlopeVector(i-nskip)) slopeBC.push_back(slope.BC);
318  std::sort(slopeBC.begin(), slopeBC.end());
319  slopeBC.erase( std::unique(slopeBC.begin(), slopeBC.end()), slopeBC.end() );
320  for (const auto &bc : slopeBC) {
321  Muon::NSW_TrigRawData* trigRawData = new Muon::NSW_TrigRawData(diamond->getDiamond(i-nskip).stationPhi, diamond->getDiamond(i-nskip).side, bc);
322 
323  for (const auto &slope : diamond->getSlopeVector(i-nskip)) {
324  if (bc == slope.BC) {
325  Muon::NSW_TrigRawDataSegment* trigRawDataSegment = new Muon::NSW_TrigRawDataSegment();
326 
327  // Phi-id - here use local phi (not phiShf)
328  uint8_t phi_id = 0;
329  if (slope.phi > m_phiMax || slope.phi < m_phiMin) trigRawDataSegment->setPhiIndex(phi_id);
330  else {
331  uint8_t nPhi = (1<<m_phiBits) -2; // To accomodate the new phi-id encoding prescription around 0
332  float phiSteps = (m_phiMax - m_phiMin)/nPhi;
333  for (uint8_t i=0; i<nPhi; i++) {
334  if ((slope.phi) < (m_phiMin+i*phiSteps)) {
335  phi_id = i;
336  break;
337  }
338  }
339  trigRawDataSegment->setPhiIndex(phi_id);
340  }
341  if (m_doNtuple) m_trigger_diamond_TP_phi_id->push_back(phi_id);
342 
343  // R-id
344  double extrapolatedR = 7824.46*std::abs(std::tan(slope.theta)); // The Z plane is a fixed value, taken from SL-TP documentation
345  uint8_t R_id = 0;
346  if (extrapolatedR > m_rMax || extrapolatedR < m_rMin) trigRawDataSegment->setRIndex(R_id);
347  else {
348  uint8_t nR = (1<<m_rBits) -1;
349  float Rsteps = (m_rMax - m_rMin)/nR;
350  for (uint8_t j=0; j<nR; j++) {
351  if (extrapolatedR < (m_rMin+j*Rsteps)) {
352  R_id = j;
353  break;
354  }
355  }
356  trigRawDataSegment->setRIndex(R_id);
357  }
358  if (m_doNtuple) m_trigger_diamond_TP_R_id->push_back(R_id);
359 
360  // DeltaTheta-id
361  uint8_t dTheta_id = 0;
362  if (slope.dtheta > m_dThetaMax || slope.dtheta < m_dThetaMin) trigRawDataSegment->setDeltaTheta(dTheta_id);
363  else {
364  uint8_t ndTheta = (1<<m_dThetaBits) -1;
365  float dThetaSteps = (m_dThetaMax - m_dThetaMin)/ndTheta;
366  for (uint8_t k=0; k<ndTheta; k++) {
367  if ((slope.dtheta) < (m_dThetaMin+k*dThetaSteps)) {
368  dTheta_id = k;
369  break;
370  }
371  }
372  trigRawDataSegment->setDeltaTheta(dTheta_id);
373  }
374  if (m_doNtuple) m_trigger_diamond_TP_dTheta_id->push_back(dTheta_id);
375 
376  // Low R-resolution bit
377  trigRawDataSegment->setLowRes(slope.lowRes);
378 
379  trigRawData->push_back(trigRawDataSegment);
380  }
381  }
382  rdo->push_back(trigRawData);
383  }
384  ATH_MSG_DEBUG("Filled MM RDO container now having size: " << rdo->size() << ". Clearing event information!");
385  } else ATH_MSG_DEBUG("No output slopes to store");
386  } else ATH_MSG_WARNING("No algorithm defined, exiting gracefully");
387  } else {
388  ATH_MSG_DEBUG( "Available hits are " << reco_it->second.size() << ", less than X+UV threshold, skipping" );
389  nskip++;
390  }
391  } else {
392  ATH_MSG_WARNING( "Empty hit map, skipping" );
393  nskip++;
394  }
395  } // Main particle loop
396  entries.clear();
397  Hits_Data_Set_Time.clear();
398  Event_Info.clear();
399  if (do_MMDiamonds) diamond->clearEvent();
400 
401  return StatusCode::SUCCESS;
402  }
403 }//end namespace
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
NSWL1::MMTriggerTool::m_keyMmDigitContainer
SG::ReadHandleKey< MmDigitContainer > m_keyMmDigitContainer
Definition: MMTriggerTool.h:49
MMT_Diamond::getSlopeVector
std::vector< slope_t > getSlopeVector(const unsigned int iterator) const
Definition: MMT_Diamond.h:65
NSWL1::MMTriggerTool::m_diamXthreshold
Gaudi::Property< int > m_diamXthreshold
Definition: MMTriggerTool.h:57
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
NSWL1::MMTriggerTool::fillPointers
void fillPointers(const MuonGM::MuonDetectorManager *detManager) const
Definition: MMTriggerTool.cxx:40
NSWL1::MMTriggerTool::m_diamOverlapStereoDown
Gaudi::Property< int > m_diamOverlapStereoDown
Definition: MMTriggerTool.h:62
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
NSWL1::MMTriggerTool::m_diamOverlapEtaUp
Gaudi::Property< int > m_diamOverlapEtaUp
Definition: MMTriggerTool.h:59
MMT_Diamond::setUV
void setUV(bool flag)
Definition: MMT_Diamond.h:88
MMT_Diamond::resetSlopes
void resetSlopes()
Definition: MMT_Diamond.cxx:278
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
NSWL1::MMTriggerTool::m_dThetaMin
Gaudi::Property< float > m_dThetaMin
Definition: MMTriggerTool.h:73
SG::ReadHandle< McEventCollection >
NSWL1::MMTriggerTool::attachBranches
StatusCode attachBranches(MuonVal::MuonTesterTree &tree) override
Definition: MMTriggerTool.cxx:53
NSWL1::MMTriggerTool::m_phiMax
Gaudi::Property< float > m_phiMax
Definition: MMTriggerTool.h:68
tree
TChain * tree
Definition: tile_monitor.h:30
AtlasHitsVector
Definition: AtlasHitsVector.h:33
Muon::NSW_TrigRawData
Definition: NSW_TrigRawData.h:15
skel.it
it
Definition: skel.GENtoEVGEN.py:407
NSWL1::MMTriggerTool::m_diamOverlapEtaDown
Gaudi::Property< int > m_diamOverlapEtaDown
Definition: MMTriggerTool.h:60
Muon::NSW_TrigRawDataSegment::setDeltaTheta
void setDeltaTheta(uint8_t deltaTheta)
Definition: NSW_TrigRawDataSegment.h:36
MMT_Diamond::setRoadSizeUpX
void setRoadSizeUpX(int sizeUp)
Definition: MMT_Diamond.h:77
NSWL1::MMTriggerTool::m_detManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detManagerKey
Definition: MMTriggerTool.h:82
MMLoadVariables
Definition: MMLoadVariables.h:30
NSWL1::MMTriggerTool::m_rMax
Gaudi::Property< float > m_rMax
Definition: MMTriggerTool.h:71
MMT_Diamond::getDiamond
diamond_t getDiamond(const unsigned int iterator) const
Definition: MMT_Diamond.h:62
TrigVSI::AlgConsts::nPhi
constexpr int nPhi
Default bin number of phi for vertex map.
Definition: Trigger/TrigTools/TrigVrtSecInclusive/TrigVrtSecInclusive/Constants.h:27
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
MMT_Diamond::createRoads_fillHits
void createRoads_fillHits(const unsigned int iterator, std::vector< hitData_entry > &hitDatas, const MuonGM::MuonDetectorManager *detManager, std::shared_ptr< MMT_Parameters > par, const int phi)
Definition: MMT_Diamond.cxx:22
Muon::NSW_TrigRawDataSegment::setRIndex
void setRIndex(uint8_t rIndex)
Definition: NSW_TrigRawDataSegment.h:38
NSWL1::MMTriggerTool::m_uv
Gaudi::Property< bool > m_uv
Definition: MMTriggerTool.h:56
Muon::NSW_TrigRawDataSegment::setPhiIndex
void setPhiIndex(uint8_t phiIndex)
Definition: NSW_TrigRawDataSegment.h:37
MMTriggerTool.h
NSWL1::MMTriggerTool::m_mmDigitContainer
Gaudi::Property< std::string > m_mmDigitContainer
Definition: MMTriggerTool.h:65
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
NSWL1::MMTriggerTool::m_MmIdHelper
const MmIdHelper * m_MmIdHelper
MM offline Id helper.
Definition: MMTriggerTool.h:83
MuonVal::MuonTesterTree
Definition: MuonTesterTree.h:30
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
diamond_t::stationPhi
int stationPhi
Definition: MMT_Diamond.h:47
lumiFormat.i
int i
Definition: lumiFormat.py:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CaloNoise_fillDB.dt
dt
Definition: CaloNoise_fillDB.py:58
test_pyathena.parent
parent
Definition: test_pyathena.py:15
MMT_Diamond::setTrapezoidalShape
void setTrapezoidalShape(bool flag)
Definition: MMT_Diamond.h:69
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
MMT_Diamond::getXthreshold
unsigned int getXthreshold() const
Definition: MMT_Diamond.h:85
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MMT_Diamond::setRoadSizeDownUV
void setRoadSizeDownUV(int sizeDownUV)
Definition: MMT_Diamond.h:83
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
NSWL1::MMTriggerTool::m_keyMuonEntryLayer
SG::ReadHandleKey< TrackRecordCollection > m_keyMuonEntryLayer
Definition: MMTriggerTool.h:48
evInf_entry
Definition: MMT_struct.h:59
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
McEventCollection
This defines the McEventCollection, which is really just an ObjectVector of McEvent objects.
Definition: McEventCollection.h:33
MMT_Diamond::setRoadSizeUpUV
void setRoadSizeUpUV(int sizeUpUV)
Definition: MMT_Diamond.h:81
Muon::NSW_TrigRawDataSegment
Definition: NSW_TrigRawDataSegment.h:15
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
NSWL1::MMTriggerTool::runTrigger
StatusCode runTrigger(const EventContext &ctx, Muon::NSW_TrigRawDataContainer *rdo, const bool do_MMDiamonds) const override
Definition: MMTriggerTool.cxx:146
NSWL1::MMTriggerTool::MMTriggerTool
MMTriggerTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: MMTriggerTool.cxx:9
MuonIdHelper::stationPhi
int stationPhi(const Identifier &id) const
Definition: MuonIdHelper.cxx:810
MMT_Diamond::setXthreshold
void setXthreshold(int threshold)
Definition: MMT_Diamond.h:86
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
MMT_Diamond::clearEvent
void clearEvent()
Definition: MMT_Diamond.cxx:11
NSWL1::MMTriggerTool::m_trapShape
Gaudi::Property< bool > m_trapShape
Definition: MMTriggerTool.h:54
NSWL1::MMTriggerTool::m_diamRoadSize
Gaudi::Property< int > m_diamRoadSize
Definition: MMTriggerTool.h:55
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
diamond_t::sector
char sector
Definition: MMT_Diamond.h:45
NSWL1::MMTriggerTool::m_dThetaMax
Gaudi::Property< float > m_dThetaMax
Definition: MMTriggerTool.h:74
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
mc.nskip
nskip
Definition: mc.PhPy8EG_Hto4l_NNLOPS_nnlo_30_ggH125_ZZ4l.py:41
MMT_Diamond::getUVthreshold
unsigned int getUVthreshold() const
Definition: MMT_Diamond.h:89
NSWL1::MMTriggerTool::m_keyMcEventCollection
SG::ReadHandleKey< McEventCollection > m_keyMcEventCollection
Definition: MMTriggerTool.h:47
diamond_t::side
char side
Definition: MMT_Diamond.h:46
NSWL1::MMTriggerTool::initialize
virtual StatusCode initialize() override
Definition: MMTriggerTool.cxx:13
MMT_Diamond::setUVthreshold
void setUVthreshold(int threshold)
Definition: MMT_Diamond.h:90
Muon::NSW_TrigRawDataSegment::setLowRes
void setLowRes(bool lowRes)
Definition: NSW_TrigRawDataSegment.h:41
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:50
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
jobOptions.epos
epos
Definition: jobOptions.crmc.py:50
LArG4FSStartPointFilter.particles
list particles
Definition: LArG4FSStartPointFilter.py:84
MMT_Diamond::getHitSlopes
const std::vector< double > & getHitSlopes() const
Definition: MMT_Diamond.h:63
entries
double entries
Definition: listroot.cxx:49
MMT_Diamond::setRoadSize
void setRoadSize(int size)
Definition: MMT_Diamond.h:75
NSWL1::MMTriggerTool::m_isMC
Gaudi::Property< bool > m_isMC
Definition: MMTriggerTool.h:50
NSWL1::MMTriggerTool::m_diamUVthreshold
Gaudi::Property< int > m_diamUVthreshold
Definition: MMTriggerTool.h:58
NSWL1::MMTriggerTool::m_diamOverlapStereoUp
Gaudi::Property< int > m_diamOverlapStereoUp
Definition: MMTriggerTool.h:61
python.root_pickle.load
def load(f, use_proxy=1, key=None)
Definition: root_pickle.py:476
NSWL1::MMTriggerTool::m_doTruth
Gaudi::Property< bool > m_doTruth
Definition: MMTriggerTool.h:51
Muon::NSW_TrigRawDataContainer
Definition: NSW_TrigRawDataContainer.h:14
digitWrapper::id
Identifier id() const
Definition: MMT_struct.h:99
LArCellBinning.phiSteps
dictionary phiSteps
Definition: LArCellBinning.py:37
NSWL1::MMTriggerTool::m_rBits
Gaudi::Property< int > m_rBits
Definition: MMTriggerTool.h:72
MMT_Diamond::setRoadSizeDownX
void setRoadSizeDownX(int sizeDown)
Definition: MMT_Diamond.h:79
NSWL1
A trigger trigger candidate for a stgc sector.
Definition: NSWL1Simulation.cxx:7
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
NSWL1::MMTriggerTool::m_rMin
Gaudi::Property< float > m_rMin
Definition: MMTriggerTool.h:70
digitWrapper
Definition: MMT_struct.h:83
NSWL1::MMTriggerTool::m_phiBits
Gaudi::Property< int > m_phiBits
Definition: MMTriggerTool.h:69
NSWL1::MMTriggerTool::m_phiMin
Gaudi::Property< float > m_phiMin
Definition: MMTriggerTool.h:67
NSWL1::MMTriggerTool::m_doNtuple
Gaudi::Property< bool > m_doNtuple
Definition: MMTriggerTool.h:66
fitman.k
k
Definition: fitman.py:528
NSWL1::MMTriggerTool::m_dThetaBits
Gaudi::Property< int > m_dThetaBits
Definition: MMTriggerTool.h:75
MMT_Diamond::findDiamonds
void findDiamonds(const unsigned int iterator, const uint64_t event)
Definition: MMT_Diamond.cxx:110
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Wed Apr 9 2025 21:15:08 for ATLAS Offline Software by   doxygen 1.8.18