ATLAS Offline Software
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 
12  StatusCode MMTriggerTool::initialize() {
13 
14  ATH_MSG_DEBUG( name() << " configuration:");
15  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_mmDigitContainer.name() << m_mmDigitContainer.value());
16  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_doNtuple.name() << ((m_doNtuple)? "[True]":"[False]")
17  << std::setfill(' ') << std::setiosflags(std::ios::right) );
18 
19  ATH_CHECK(m_keyMcEventCollection.initialize(m_isMC));
20  ATH_CHECK(m_keyMuonEntryLayer.initialize(m_isMC));
21  ATH_CHECK(m_keyMmDigitContainer.initialize());
22  ATH_CHECK(m_idHelperSvc.retrieve());
23  ATH_CHECK(m_detectorManagerKey.initialize());
24 
25  if(m_doNtuple and Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
26  ATH_MSG_ERROR("DoNtuple is not possible in multi-threaded mode");
27  return StatusCode::FAILURE;
28  }
29 
30  m_diamond = std::make_unique<MMT_Diamond>(m_diamXthreshold, m_uv, m_diamUVthreshold, m_diamRoadSize, m_diamOverlapEtaUp, m_diamOverlapEtaDown, m_diamOverlapStereoUp, m_diamOverlapStereoDown);
31 
32  return StatusCode::SUCCESS;
33  }
34 
35  StatusCode MMTriggerTool::attachBranches(MuonVal::MuonTesterTree &tree) {
36  m_trigger_diamond_ntrig = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_ntrig");
37  m_trigger_diamond_bc = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_bc");
38  m_trigger_diamond_sector = std::make_shared<MuonVal::VectorBranch<char> >(tree, "MM_diamond_sector");
39  m_trigger_diamond_sectorPhi = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_sectorPhi");
40  m_trigger_diamond_totalCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_totalCount");
41  m_trigger_diamond_realCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_realCount");
42  m_trigger_diamond_iX = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iX");
43  m_trigger_diamond_iU = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iU");
44  m_trigger_diamond_iV = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iV");
45  m_trigger_diamond_XbkgCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_XbkgCount");
46  m_trigger_diamond_UVbkgCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_UVbkgCount");
47  m_trigger_diamond_XmuonCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_XmuonCount");
48  m_trigger_diamond_UVmuonCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_UVmuonCount");
49  m_trigger_diamond_age = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_age");
50  m_trigger_diamond_mx = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mx");
51  m_trigger_diamond_my = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_my");
52  m_trigger_diamond_Uavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Uavg");
53  m_trigger_diamond_Vavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Vavg");
54  m_trigger_diamond_mxl = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mxl");
55  m_trigger_diamond_theta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_theta");
56  m_trigger_diamond_eta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_eta");
57  m_trigger_diamond_dtheta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_dtheta");
58  m_trigger_diamond_phi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phi");
59  m_trigger_diamond_phiShf = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phiShf");
60  m_trigger_diamond_TP_phi_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_phi_id");
61  m_trigger_diamond_TP_R_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_R_id");
62  m_trigger_diamond_TP_dTheta_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_dTheta_id");
63  m_trigger_RZslopes = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_RZslopes");
64  m_trigger_trueEtaRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaRange");
65  m_trigger_truePtRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePtRange");
66  m_trigger_VMM = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_VMM");
67  m_trigger_plane = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_plane");
68  m_trigger_station = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_station");
69  m_trigger_strip = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_strip");
70  m_trigger_slope = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_slope");
71  m_trigger_trueThe = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThe");
72  m_trigger_truePhi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhi");
73  m_trigger_trueDth = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueDth");
74  m_trigger_trueEtaEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaEnt");
75  m_trigger_trueTheEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueTheEnt");
76  m_trigger_truePhiEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiEnt");
77  m_trigger_trueEtaPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaPos");
78  m_trigger_trueThePos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThePos");
79  m_trigger_truePhiPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiPos");
80 
81  tree.addBranch(m_trigger_diamond_ntrig);
82  tree.addBranch(m_trigger_diamond_bc);
83  tree.addBranch(m_trigger_diamond_sector);
84  tree.addBranch(m_trigger_diamond_sectorPhi);
85  tree.addBranch(m_trigger_diamond_totalCount);
86  tree.addBranch(m_trigger_diamond_realCount);
87  tree.addBranch(m_trigger_diamond_iX);
88  tree.addBranch(m_trigger_diamond_iU);
89  tree.addBranch(m_trigger_diamond_iV);
90  tree.addBranch(m_trigger_diamond_XbkgCount);
91  tree.addBranch(m_trigger_diamond_UVbkgCount);
92  tree.addBranch(m_trigger_diamond_XmuonCount);
93  tree.addBranch(m_trigger_diamond_UVmuonCount);
94  tree.addBranch(m_trigger_diamond_age);
95  tree.addBranch(m_trigger_diamond_mx);
96  tree.addBranch(m_trigger_diamond_my);
97  tree.addBranch(m_trigger_diamond_Uavg);
98  tree.addBranch(m_trigger_diamond_Vavg);
99  tree.addBranch(m_trigger_diamond_mxl);
100  tree.addBranch(m_trigger_diamond_theta);
101  tree.addBranch(m_trigger_diamond_eta);
102  tree.addBranch(m_trigger_diamond_dtheta);
103  tree.addBranch(m_trigger_diamond_phi);
104  tree.addBranch(m_trigger_diamond_phiShf);
105  tree.addBranch(m_trigger_diamond_TP_phi_id);
106  tree.addBranch(m_trigger_diamond_TP_R_id);
107  tree.addBranch(m_trigger_diamond_TP_dTheta_id);
108  tree.addBranch(m_trigger_RZslopes);
109  tree.addBranch(m_trigger_trueEtaRange);
110  tree.addBranch(m_trigger_truePtRange);
111  tree.addBranch(m_trigger_VMM);
112  tree.addBranch(m_trigger_plane);
113  tree.addBranch(m_trigger_station);
114  tree.addBranch(m_trigger_strip);
115  tree.addBranch(m_trigger_slope);
116  tree.addBranch(m_trigger_trueThe);
117  tree.addBranch(m_trigger_truePhi);
118  tree.addBranch(m_trigger_trueDth);
119  tree.addBranch(m_trigger_trueEtaEnt);
120  tree.addBranch(m_trigger_trueTheEnt);
121  tree.addBranch(m_trigger_truePhiEnt);
122  tree.addBranch(m_trigger_trueEtaPos);
123  tree.addBranch(m_trigger_trueThePos);
124  tree.addBranch(m_trigger_truePhiPos);
125  return StatusCode::SUCCESS;
126  }
127 
128  StatusCode MMTriggerTool::runTrigger(const EventContext& ctx, Muon::NSW_TrigRawDataContainer* rdo, const bool do_MMDiamonds) const {
129 
130  uint64_t event = ctx.eventID().event_number();
131  ATH_MSG_DEBUG("********************************************************* EVENT NUMBER = " << event);
132 
133  SG::ReadCondHandle<MuonGM::MuonDetectorManager> detManager{m_detectorManagerKey, ctx};
134  if(!detManager.isValid()){
135  ATH_MSG_ERROR("Failed to retrieve the MuonDetectorManager conditions object");
136  return StatusCode::FAILURE;
137  }
138 
139  const McEventCollection* ptrMcEventCollection = nullptr;
140  const TrackRecordCollection* ptrMuonEntryLayer = nullptr;
141  if(m_isMC){
142  SG::ReadHandle<McEventCollection> readMcEventCollection( m_keyMcEventCollection, ctx );
143  if( !readMcEventCollection.isValid() ){
144  ATH_MSG_ERROR("Cannot retrieve McEventCollection");
145  return StatusCode::FAILURE;
146  }
147  if(m_doTruth) ptrMcEventCollection = readMcEventCollection.cptr();
148  SG::ReadHandle<TrackRecordCollection> readMuonEntryLayer( m_keyMuonEntryLayer, ctx );
149  if( !readMuonEntryLayer.isValid() ){
150  ATH_MSG_ERROR("Cannot retrieve MuonEntryLayer");
151  return StatusCode::FAILURE;
152  }
153  if(m_doTruth and m_doNtuple) {
154  ptrMuonEntryLayer = readMuonEntryLayer.cptr();
155  MMLoadVariables load = MMLoadVariables();
156  std::map<std::pair<uint64_t, unsigned int>,evInf_entry> Event_Info;
157  ATH_CHECK(load.getTruthInfo(ctx, ptrMcEventCollection, ptrMuonEntryLayer, Event_Info));
158 
159  // Extract truth info, if available
160  for (const auto &it : Event_Info) {
161  m_trigger_trueEtaRange->push_back(it.second.eta_ip);
162  m_trigger_truePtRange->push_back(it.second.pt);
163  m_trigger_trueThe->push_back(it.second.theta_ip);
164  m_trigger_truePhi->push_back(it.second.phi_ip);
165  m_trigger_trueDth->push_back(it.second.dtheta); // theta_pos-theta_ent
166  m_trigger_trueEtaPos->push_back(it.second.eta_pos);
167  m_trigger_trueThePos->push_back(it.second.theta_pos);
168  m_trigger_truePhiPos->push_back(it.second.phi_pos);
169  m_trigger_trueEtaEnt->push_back(it.second.eta_ent);
170  m_trigger_trueTheEnt->push_back(it.second.theta_ent);
171  m_trigger_truePhiEnt->push_back(it.second.phi_ent);
172  }
173  }
174  }
175 
176  SG::ReadHandle<MmDigitContainer> readMmDigitContainer( m_keyMmDigitContainer, ctx );
177  if( !readMmDigitContainer.isValid() ){
178  ATH_MSG_ERROR("Cannot retrieve MmDigitContainer");
179  return StatusCode::FAILURE;
180  }
181 
182  for (const MmDigitCollection* digitCollection : *readMmDigitContainer) {
183 
184  std::vector<std::shared_ptr<MMT_Hit> > ev_hits;
185  for (const MmDigit* digit : *digitCollection) {
186  const Identifier id = digit->identify();
187  if (not m_idHelperSvc->isMM(id)) continue;
188 
189  const std::string stationName = m_idHelperSvc->chamberNameString(id);
190  const int stationEta = m_idHelperSvc->stationEta(id);
191  const int stationPhi = m_idHelperSvc->stationPhi(id);
192  const int sector = m_idHelperSvc->sector(id);
193  const int multiplet = m_idHelperSvc->mmIdHelper().multilayer(id);
194  const int gasGap = m_idHelperSvc->mmIdHelper().gasGap(id);
195 
196  const int channel = m_idHelperSvc->mmIdHelper().channel(id);
197  // Checking whether strip exceeds allowed ranges
198  const MuonGM::MMReadoutElement* readout = detManager->getMMReadoutElement(id);
199  if (channel < 1 or channel > (readout->getDesign(id))->totalStrips) continue;
200 
201  const float stripTime = digit->stripResponseTime();
202  // Checking positive digitization time
203  if (stripTime < 0.) continue;
204  const int BC = std::ceil(stripTime/25.);
205  ev_hits.emplace_back(std::make_shared<MMT_Hit>(id, stationName, stationEta, stationPhi, sector, multiplet, gasGap, channel, stripTime, BC, detManager.cptr()));
206 
207  if (ev_hits.back()->infSlope()) {
208  ATH_MSG_WARNING("Infinite slope, removing hit");
209  ev_hits.pop_back();
210  continue;
211  }
212  if (m_doNtuple) {
213  m_trigger_VMM->push_back(ev_hits.back()->getVMM());
214  m_trigger_plane->push_back(ev_hits.back()->getPlane());
215  m_trigger_station->push_back(ev_hits.back()->getStationEta());
216  m_trigger_strip->push_back(ev_hits.back()->getChannel());
217  m_trigger_RZslopes->push_back(ev_hits.back()->getRZSlope());
218  }
219  }
220 
221  // Go ahead when hits are more than X+UV thresholds
222  if (do_MMDiamonds and ev_hits.size() >= (m_diamond->getXthreshold()+m_diamond->getUVthreshold())) {
223  const bool isLarge = (std::all_of(ev_hits.begin(), ev_hits.end(), [] (const auto &hit) { return hit->getSector() == 'L'; }));
224  const char sector = (isLarge) ? 'L' : 'S';
225  const char side = (std::all_of(ev_hits.begin(), ev_hits.end(), [] (const auto &hit) { return hit->getStationEta() < 0; })) ? 'C' : 'A';
226  const int sectorPhi = ev_hits[0]->getSectorPhi();
227  const bool allSectorPhi = (std::all_of(ev_hits.begin(), ev_hits.end(), [&] (const auto &hit) { return hit->getSectorPhi() == sectorPhi; }));
228  if (not allSectorPhi) {
229  ATH_MSG_ERROR("Available digits belongs to different sectors IDs, unable to assign an unique ID in output RDO");
230  return StatusCode::FAILURE;
231  }
232 
233  // Setup roads
234  std::vector<MMT_Road> ev_roads;
235  m_diamond->createRoads(ev_roads, isLarge);
236 
237  // Evaluate coincidences
238  std::vector<slope_t> diamondSlopes;
239  m_diamond->findDiamonds(ev_hits, ev_roads, diamondSlopes, sectorPhi);
240 
241  // Store output, if any, in debug ntuple (if enabled) and in trigger RDO
242  if (not diamondSlopes.empty()) {
243  if (m_doNtuple) {
244  m_trigger_diamond_ntrig->push_back(diamondSlopes.size());
245  for (const auto &slope : diamondSlopes) {
246  m_trigger_diamond_sector->push_back(sector);
247  m_trigger_diamond_sectorPhi->push_back(sectorPhi);
248  m_trigger_diamond_bc->push_back(slope.BC);
249  m_trigger_diamond_totalCount->push_back(slope.totalCount);
250  m_trigger_diamond_realCount->push_back(slope.realCount);
251  m_trigger_diamond_XbkgCount->push_back(slope.xbkg);
252  m_trigger_diamond_UVbkgCount->push_back(slope.uvbkg);
253  m_trigger_diamond_XmuonCount->push_back(slope.xmuon);
254  m_trigger_diamond_UVmuonCount->push_back(slope.uvmuon);
255  m_trigger_diamond_iX->push_back(slope.iRoad);
256  m_trigger_diamond_iU->push_back(slope.iRoadu);
257  m_trigger_diamond_iV->push_back(slope.iRoadv);
258  m_trigger_diamond_age->push_back(slope.age);
259  m_trigger_diamond_mx->push_back(slope.mx);
260  m_trigger_diamond_my->push_back(slope.my);
261  m_trigger_diamond_Uavg->push_back(slope.uavg);
262  m_trigger_diamond_Vavg->push_back(slope.vavg);
263  m_trigger_diamond_mxl->push_back(slope.mxl);
264  m_trigger_diamond_theta->push_back(slope.theta);
265  m_trigger_diamond_eta->push_back(slope.eta);
266  m_trigger_diamond_dtheta->push_back(slope.dtheta);
267  m_trigger_diamond_phi->push_back(slope.phi);
268  m_trigger_diamond_phiShf->push_back(slope.phiShf);
269  }
270  }
271 
272  // MM RDO filling below
273  std::vector<int> slopeBC;
274  for (const auto &slope : diamondSlopes) slopeBC.push_back(slope.BC);
275  std::sort(slopeBC.begin(), slopeBC.end());
276  slopeBC.erase( std::unique(slopeBC.begin(), slopeBC.end()), slopeBC.end() );
277  for (const auto &bc : slopeBC) {
278  Muon::NSW_TrigRawData* trigRawData = new Muon::NSW_TrigRawData(sectorPhi-1, side, bc);
279 
280  for (const auto &slope : diamondSlopes) {
281  if (bc == slope.BC) {
282  Muon::NSW_TrigRawDataSegment* trigRawDataSegment = new Muon::NSW_TrigRawDataSegment();
283 
284  // Phi-id - here use local phi (not phiShf)
285  uint8_t phi_id = 0;
286  if (slope.phi > m_phiMax || slope.phi < m_phiMin) trigRawDataSegment->setPhiIndex(phi_id);
287  else {
288  uint8_t nPhi = (1<<m_phiBits) -2; // To accomodate the new phi-id encoding prescription around 0
289  float phiSteps = (m_phiMax - m_phiMin)/nPhi;
290  for (uint8_t i=0; i<nPhi; i++) {
291  if ((slope.phi) < (m_phiMin+i*phiSteps)) {
292  phi_id = i;
293  break;
294  }
295  }
296  trigRawDataSegment->setPhiIndex(phi_id);
297  }
298  if (m_doNtuple) m_trigger_diamond_TP_phi_id->push_back(phi_id);
299 
300  // R-id
301  double extrapolatedR = 7824.46*std::abs(std::tan(slope.theta)); // The Z plane is a fixed value, taken from SL-TP documentation
302  uint8_t R_id = 0;
303  if (extrapolatedR > m_rMax || extrapolatedR < m_rMin) trigRawDataSegment->setRIndex(R_id);
304  else {
305  uint8_t nR = (1<<m_rBits) -1;
306  float Rsteps = (m_rMax - m_rMin)/nR;
307  for (uint8_t j=0; j<nR; j++) {
308  if (extrapolatedR < (m_rMin+j*Rsteps)) {
309  R_id = j;
310  break;
311  }
312  }
313  trigRawDataSegment->setRIndex(R_id);
314  }
315  if (m_doNtuple) m_trigger_diamond_TP_R_id->push_back(R_id);
316 
317  // DeltaTheta-id
318  uint8_t dTheta_id = 0;
319  if (slope.dtheta > m_dThetaMax || slope.dtheta < m_dThetaMin) trigRawDataSegment->setDeltaTheta(dTheta_id);
320  else {
321  uint8_t ndTheta = (1<<m_dThetaBits) -1;
322  float dThetaSteps = (m_dThetaMax - m_dThetaMin)/ndTheta;
323  for (uint8_t k=0; k<ndTheta; k++) {
324  if ((slope.dtheta) < (m_dThetaMin+k*dThetaSteps)) {
325  dTheta_id = k;
326  break;
327  }
328  }
329  trigRawDataSegment->setDeltaTheta(dTheta_id);
330  }
331  if (m_doNtuple) m_trigger_diamond_TP_dTheta_id->push_back(dTheta_id);
332 
333  // Low R-resolution bit
334  trigRawDataSegment->setLowRes(slope.lowRes);
335 
336  trigRawData->push_back(trigRawDataSegment);
337  }
338  }
339  rdo->push_back(trigRawData);
340  }
341  }
342  }
343  else {
344  ATH_MSG_DEBUG("Available hits are " << ev_hits.size() << ", less than X+UV threshold, skipping digit collection");
345  }
346  }
347 
348  return StatusCode::SUCCESS;
349  }
350 }//end namespace
MmDigitCollection
Definition: MmDigitCollection.h:18
NSWL1::MMTriggerTool::m_keyMmDigitContainer
SG::ReadHandleKey< MmDigitContainer > m_keyMmDigitContainer
Definition: MMTriggerTool.h:44
NSWL1::MMTriggerTool::m_diamXthreshold
Gaudi::Property< int > m_diamXthreshold
Definition: MMTriggerTool.h:54
NSWL1::MMTriggerTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MMTriggerTool.h:46
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
NSWL1::MMTriggerTool::m_diamOverlapStereoDown
Gaudi::Property< int > m_diamOverlapStereoDown
Definition: MMTriggerTool.h:59
NSWL1::MMTriggerTool::m_diamOverlapEtaUp
Gaudi::Property< int > m_diamOverlapEtaUp
Definition: MMTriggerTool.h:56
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
NSWL1::MMTriggerTool::m_dThetaMin
Gaudi::Property< float > m_dThetaMin
Definition: MMTriggerTool.h:70
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
SG::ReadHandle< McEventCollection >
NSWL1::MMTriggerTool::attachBranches
StatusCode attachBranches(MuonVal::MuonTesterTree &tree) override
Definition: MMTriggerTool.cxx:35
NSWL1::MMTriggerTool::m_phiMax
Gaudi::Property< float > m_phiMax
Definition: MMTriggerTool.h:65
MuonGM::MMReadoutElement::getDesign
const MuonChannelDesign * getDesign(const Identifier &id) const
returns the MuonChannelDesign class for the given identifier
Definition: MMReadoutElement.h:190
tree
TChain * tree
Definition: tile_monitor.h:30
AtlasHitsVector
Definition: AtlasHitsVector.h:32
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:57
Muon::NSW_TrigRawDataSegment::setDeltaTheta
void setDeltaTheta(uint8_t deltaTheta)
Definition: NSW_TrigRawDataSegment.h:36
MmDigit
Definition: MmDigit.h:20
MMLoadVariables
Definition: MMLoadVariables.h:28
NSWL1::MMTriggerTool::m_rMax
Gaudi::Property< float > m_rMax
Definition: MMTriggerTool.h:68
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
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
TRT::Hit::side
@ side
Definition: HitInfo.h:83
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:53
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:62
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MuonVal::MuonTesterTree
Definition: MuonTesterTree.h:30
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
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
test_pyathena.parent
parent
Definition: test_pyathena.py:15
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
NSWL1::MMTriggerTool::m_keyMuonEntryLayer
SG::ReadHandleKey< TrackRecordCollection > m_keyMuonEntryLayer
Definition: MMTriggerTool.h:43
evInf_entry
Definition: MMLoadVariables.h:17
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:32
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:128
NSWL1::MMTriggerTool::MMTriggerTool
MMTriggerTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: MMTriggerTool.cxx:9
NSWL1::MMTriggerTool::m_diamRoadSize
Gaudi::Property< int > m_diamRoadSize
Definition: MMTriggerTool.h:52
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
NSWL1::MMTriggerTool::m_dThetaMax
Gaudi::Property< float > m_dThetaMax
Definition: MMTriggerTool.h:71
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)
NSWL1::MMTriggerTool::m_keyMcEventCollection
SG::ReadHandleKey< McEventCollection > m_keyMcEventCollection
Definition: MMTriggerTool.h:42
Muon::EnumDefs::BC
@ BC
Definition: MuonEnumDefs.h:13
NSWL1::MMTriggerTool::initialize
virtual StatusCode initialize() override
Definition: MMTriggerTool.cxx:12
NSWL1::MMTriggerTool::m_detectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detectorManagerKey
Definition: MMTriggerTool.h:45
Muon::NSW_TrigRawDataSegment::setLowRes
void setLowRes(bool lowRes)
Definition: NSW_TrigRawDataSegment.h:41
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
NSWL1::MMTriggerTool::m_diamond
std::unique_ptr< MMT_Diamond > m_diamond
Definition: MMTriggerTool.h:74
MuonGM::MMReadoutElement
An MMReadoutElement corresponds to a single STGC module; therefore typicaly a barrel muon station con...
Definition: MMReadoutElement.h:25
NSWL1::MMTriggerTool::m_isMC
Gaudi::Property< bool > m_isMC
Definition: MMTriggerTool.h:48
NSWL1::MMTriggerTool::m_diamUVthreshold
Gaudi::Property< int > m_diamUVthreshold
Definition: MMTriggerTool.h:55
NSWL1::MMTriggerTool::m_diamOverlapStereoUp
Gaudi::Property< int > m_diamOverlapStereoUp
Definition: MMTriggerTool.h:58
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:49
Muon::NSW_TrigRawDataContainer
Definition: NSW_TrigRawDataContainer.h:14
LArCellBinning.phiSteps
dictionary phiSteps
Definition: LArCellBinning.py:37
NSWL1::MMTriggerTool::m_rBits
Gaudi::Property< int > m_rBits
Definition: MMTriggerTool.h:69
NSWL1
A trigger trigger candidate for a stgc sector.
Definition: NSWL1Simulation.cxx:7
NSWL1::MMTriggerTool::m_rMin
Gaudi::Property< float > m_rMin
Definition: MMTriggerTool.h:67
NSWL1::MMTriggerTool::m_phiBits
Gaudi::Property< int > m_phiBits
Definition: MMTriggerTool.h:66
NSWL1::MMTriggerTool::m_phiMin
Gaudi::Property< float > m_phiMin
Definition: MMTriggerTool.h:64
NSWL1::MMTriggerTool::m_doNtuple
Gaudi::Property< bool > m_doNtuple
Definition: MMTriggerTool.h:63
fitman.k
k
Definition: fitman.py:528
NSWL1::MMTriggerTool::m_dThetaBits
Gaudi::Property< int > m_dThetaBits
Definition: MMTriggerTool.h:72
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Sep 29 2025 21:14:58 for ATLAS Offline Software by   doxygen 1.8.18