ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
NSWL1::MMTriggerTool Class Reference

#include <MMTriggerTool.h>

Inheritance diagram for NSWL1::MMTriggerTool:
Collaboration diagram for NSWL1::MMTriggerTool:

Public Member Functions

 MMTriggerTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~MMTriggerTool () override=default
 
virtual StatusCode initialize () override
 
StatusCode attachBranches (MuonVal::MuonTesterTree &tree) override
 
StatusCode runTrigger (const EventContext &ctx, Muon::NSW_TrigRawDataContainer *rdo, const bool do_MMDiamonds) const override
 

Private Attributes

SG::ReadHandleKey< McEventCollection > m_keyMcEventCollection {this,"McEventCollection","TruthEvent","Location of TruthEvent"}
 
SG::ReadHandleKey< TrackRecordCollection > m_keyMuonEntryLayer {this,"MuonEntryLayer","MuonEntryLayer","Location of MuonEntryLayer"}
 
SG::ReadHandleKey< MmDigitContainer > m_keyMmDigitContainer {this,"MmDigitContainer","MM_DIGITS","Location of MmDigitContainer"}
 
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detectorManagerKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of MuonDetectorManager condition data"}
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
Gaudi::Property< bool > m_isMC {this, "IsMC", true, "This is MC"}
 
Gaudi::Property< bool > m_doTruth {this, "DoTruth", false, "Process truth information. Disabled by default"}
 
Gaudi::Property< int > m_diamRoadSize {this, "DiamondRoadSize", 8, "Number of strips to create a road"}
 
Gaudi::Property< bool > m_uv {this, "DiamondUV", true, "Include Stereo planes for tracking"}
 
Gaudi::Property< int > m_diamXthreshold {this, "DiamondEtaThreshold", 3, "Number of Eta planes for coincidences"}
 
Gaudi::Property< int > m_diamUVthreshold {this, "DiamondStereoThreshold", 3, "Number of Stereo planes for coincidences"}
 
Gaudi::Property< int > m_diamOverlapEtaUp {this, "DiamondEtaUpOverlap", 4, "Number of Eta strips for upper road overlap"}
 
Gaudi::Property< int > m_diamOverlapEtaDown {this, "DiamondEtaDownOverlap", 0, "Number of Eta strips for lower road overlap"}
 
Gaudi::Property< int > m_diamOverlapStereoUp {this, "DiamondStereoUpOverlap", 4, "Number of Stereo strips for upper road overlap"}
 
Gaudi::Property< int > m_diamOverlapStereoDown {this, "DiamondStereoDownOverlap", 0, "Number of Stereo strips for lower road overlap"}
 
Gaudi::Property< std::string > m_mmDigitContainer {this, "MM_DigitContainerName", "MM_DIGITS", "Name of the MM digit container"}
 
Gaudi::Property< bool > m_doNtuple {this, "DoNtuple", false, "Input the MMStrip branches into the analysis ntuple"}
 
Gaudi::Property< float > m_phiMin {this, "PhiMin", -16.*M_PI/180.0, "Minimum Phi"}
 
Gaudi::Property< float > m_phiMax {this, "PhiMax", 16.*M_PI/180.0, "Maximum Phi"}
 
Gaudi::Property< int > m_phiBits {this, "PhiBits", 6, "Number of Phi bits"}
 
Gaudi::Property< float > m_rMin {this, "RMin", 900.0, "Minimum R [mm]"}
 
Gaudi::Property< float > m_rMax {this, "RMax", 5000.0, "Maximum R [mm]"}
 
Gaudi::Property< int > m_rBits {this, "RBits", 8, "Number of R bits"}
 
Gaudi::Property< float > m_dThetaMin {this, "DThetaMin", -0.015, "Minimum dTheta [rad]"}
 
Gaudi::Property< float > m_dThetaMax {this, "DThetaMax", 0.015, "Maximum dTheta [rad]"}
 
Gaudi::Property< int > m_dThetaBits {this, "DThetaBits", 5, "Number of dTheta bits"}
 
std::unique_ptr< MMT_Diamond > m_diamond
 
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_ntrig ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_bc ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< char > > m_trigger_diamond_sector ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_sectorPhi ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_totalCount ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_realCount ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_iX ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_iU ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_iV ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_XbkgCount ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_UVbkgCount ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_XmuonCount ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_UVmuonCount ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_age ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_mx ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_my ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_Uavg ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_Vavg ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_mxl ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_theta ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_eta ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_dtheta ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_phi ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_phiShf ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_trigger_diamond_TP_phi_id ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_trigger_diamond_TP_R_id ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_trigger_diamond_TP_dTheta_id ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_RZslopes ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueEtaRange ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_truePtRange ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_VMM ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_plane ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_station ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_strip ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_slope ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueThe ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_truePhi ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueDth ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueEtaEnt ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueTheEnt ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_truePhiEnt ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueEtaPos ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueThePos ATLAS_THREAD_SAFE {}
 
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_truePhiPos ATLAS_THREAD_SAFE {}
 

Detailed Description

Definition at line 30 of file MMTriggerTool.h.

Constructor & Destructor Documentation

◆ MMTriggerTool()

NSWL1::MMTriggerTool::MMTriggerTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 9 of file MMTriggerTool.cxx.

9  :
10  base_class(type,name,parent) {}

◆ ~MMTriggerTool()

virtual NSWL1::MMTriggerTool::~MMTriggerTool ( )
overridevirtualdefault

Member Function Documentation

◆ attachBranches()

StatusCode NSWL1::MMTriggerTool::attachBranches ( MuonVal::MuonTesterTree &  tree)
override

Definition at line 35 of file MMTriggerTool.cxx.

35  {
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  }

◆ initialize()

StatusCode NSWL1::MMTriggerTool::initialize ( )
overridevirtual

Definition at line 12 of file MMTriggerTool.cxx.

12  {
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  }

◆ runTrigger()

StatusCode NSWL1::MMTriggerTool::runTrigger ( const EventContext &  ctx,
Muon::NSW_TrigRawDataContainer *  rdo,
const bool  do_MMDiamonds 
) const
override

Definition at line 128 of file MMTriggerTool.cxx.

128  {
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  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/44]

std::shared_ptr<MuonVal::VectorBranch<unsigned int> > m_trigger_diamond_ntrig NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 76 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [2/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_diamond_bc NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 77 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [3/44]

std::shared_ptr<MuonVal::VectorBranch<char> > m_trigger_diamond_sector NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 78 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [4/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_diamond_sectorPhi NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 79 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [5/44]

std::shared_ptr<MuonVal::VectorBranch<unsigned int> > m_trigger_diamond_totalCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 80 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [6/44]

std::shared_ptr<MuonVal::VectorBranch<unsigned int> > m_trigger_diamond_realCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 81 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [7/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_diamond_iX NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 82 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [8/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_diamond_iU NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 83 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [9/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_diamond_iV NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 84 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [10/44]

std::shared_ptr<MuonVal::VectorBranch<unsigned int> > m_trigger_diamond_XbkgCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 85 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [11/44]

std::shared_ptr<MuonVal::VectorBranch<unsigned int> > m_trigger_diamond_UVbkgCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 86 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [12/44]

std::shared_ptr<MuonVal::VectorBranch<unsigned int> > m_trigger_diamond_XmuonCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 87 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [13/44]

std::shared_ptr<MuonVal::VectorBranch<unsigned int> > m_trigger_diamond_UVmuonCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 88 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [14/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_diamond_age NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 89 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [15/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_mx NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 90 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [16/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_my NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 91 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [17/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_Uavg NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 92 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [18/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_Vavg NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 93 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [19/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_mxl NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 94 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [20/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_theta NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 95 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [21/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_eta NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 96 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [22/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_dtheta NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 97 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [23/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_phi NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 98 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [24/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_diamond_phiShf NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 99 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [25/44]

std::shared_ptr<MuonVal::VectorBranch<uint8_t> > m_trigger_diamond_TP_phi_id NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 100 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [26/44]

std::shared_ptr<MuonVal::VectorBranch<uint8_t> > m_trigger_diamond_TP_R_id NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 101 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [27/44]

std::shared_ptr<MuonVal::VectorBranch<uint8_t> > m_trigger_diamond_TP_dTheta_id NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 102 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [28/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_RZslopes NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 103 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [29/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_trueEtaRange NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 104 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [30/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_truePtRange NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 105 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [31/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_VMM NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 106 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [32/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_plane NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 107 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [33/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_station NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 108 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [34/44]

std::shared_ptr<MuonVal::VectorBranch<int> > m_trigger_strip NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 109 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [35/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_slope NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 110 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [36/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_trueThe NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 111 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [37/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_truePhi NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 112 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [38/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_trueDth NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 113 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [39/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_trueEtaEnt NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 114 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [40/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_trueTheEnt NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 115 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [41/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_truePhiEnt NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 116 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [42/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_trueEtaPos NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 117 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [43/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_trueThePos NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 118 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [44/44]

std::shared_ptr<MuonVal::VectorBranch<double> > m_trigger_truePhiPos NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {}
private

Definition at line 119 of file MMTriggerTool.h.

◆ m_detectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> NSWL1::MMTriggerTool::m_detectorManagerKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of MuonDetectorManager condition data"}
private

Definition at line 45 of file MMTriggerTool.h.

◆ m_diamond

std::unique_ptr<MMT_Diamond> NSWL1::MMTriggerTool::m_diamond
private

Definition at line 74 of file MMTriggerTool.h.

◆ m_diamOverlapEtaDown

Gaudi::Property<int> NSWL1::MMTriggerTool::m_diamOverlapEtaDown {this, "DiamondEtaDownOverlap", 0, "Number of Eta strips for lower road overlap"}
private

Definition at line 57 of file MMTriggerTool.h.

◆ m_diamOverlapEtaUp

Gaudi::Property<int> NSWL1::MMTriggerTool::m_diamOverlapEtaUp {this, "DiamondEtaUpOverlap", 4, "Number of Eta strips for upper road overlap"}
private

Definition at line 56 of file MMTriggerTool.h.

◆ m_diamOverlapStereoDown

Gaudi::Property<int> NSWL1::MMTriggerTool::m_diamOverlapStereoDown {this, "DiamondStereoDownOverlap", 0, "Number of Stereo strips for lower road overlap"}
private

Definition at line 59 of file MMTriggerTool.h.

◆ m_diamOverlapStereoUp

Gaudi::Property<int> NSWL1::MMTriggerTool::m_diamOverlapStereoUp {this, "DiamondStereoUpOverlap", 4, "Number of Stereo strips for upper road overlap"}
private

Definition at line 58 of file MMTriggerTool.h.

◆ m_diamRoadSize

Gaudi::Property<int> NSWL1::MMTriggerTool::m_diamRoadSize {this, "DiamondRoadSize", 8, "Number of strips to create a road"}
private

Definition at line 52 of file MMTriggerTool.h.

◆ m_diamUVthreshold

Gaudi::Property<int> NSWL1::MMTriggerTool::m_diamUVthreshold {this, "DiamondStereoThreshold", 3, "Number of Stereo planes for coincidences"}
private

Definition at line 55 of file MMTriggerTool.h.

◆ m_diamXthreshold

Gaudi::Property<int> NSWL1::MMTriggerTool::m_diamXthreshold {this, "DiamondEtaThreshold", 3, "Number of Eta planes for coincidences"}
private

Definition at line 54 of file MMTriggerTool.h.

◆ m_doNtuple

Gaudi::Property<bool> NSWL1::MMTriggerTool::m_doNtuple {this, "DoNtuple", false, "Input the MMStrip branches into the analysis ntuple"}
private

Definition at line 63 of file MMTriggerTool.h.

◆ m_doTruth

Gaudi::Property<bool> NSWL1::MMTriggerTool::m_doTruth {this, "DoTruth", false, "Process truth information. Disabled by default"}
private

Definition at line 49 of file MMTriggerTool.h.

◆ m_dThetaBits

Gaudi::Property<int> NSWL1::MMTriggerTool::m_dThetaBits {this, "DThetaBits", 5, "Number of dTheta bits"}
private

Definition at line 72 of file MMTriggerTool.h.

◆ m_dThetaMax

Gaudi::Property<float> NSWL1::MMTriggerTool::m_dThetaMax {this, "DThetaMax", 0.015, "Maximum dTheta [rad]"}
private

Definition at line 71 of file MMTriggerTool.h.

◆ m_dThetaMin

Gaudi::Property<float> NSWL1::MMTriggerTool::m_dThetaMin {this, "DThetaMin", -0.015, "Minimum dTheta [rad]"}
private

Definition at line 70 of file MMTriggerTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> NSWL1::MMTriggerTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 46 of file MMTriggerTool.h.

◆ m_isMC

Gaudi::Property<bool> NSWL1::MMTriggerTool::m_isMC {this, "IsMC", true, "This is MC"}
private

Definition at line 48 of file MMTriggerTool.h.

◆ m_keyMcEventCollection

SG::ReadHandleKey<McEventCollection> NSWL1::MMTriggerTool::m_keyMcEventCollection {this,"McEventCollection","TruthEvent","Location of TruthEvent"}
private

Definition at line 42 of file MMTriggerTool.h.

◆ m_keyMmDigitContainer

SG::ReadHandleKey<MmDigitContainer> NSWL1::MMTriggerTool::m_keyMmDigitContainer {this,"MmDigitContainer","MM_DIGITS","Location of MmDigitContainer"}
private

Definition at line 44 of file MMTriggerTool.h.

◆ m_keyMuonEntryLayer

SG::ReadHandleKey<TrackRecordCollection> NSWL1::MMTriggerTool::m_keyMuonEntryLayer {this,"MuonEntryLayer","MuonEntryLayer","Location of MuonEntryLayer"}
private

Definition at line 43 of file MMTriggerTool.h.

◆ m_mmDigitContainer

Gaudi::Property<std::string> NSWL1::MMTriggerTool::m_mmDigitContainer {this, "MM_DigitContainerName", "MM_DIGITS", "Name of the MM digit container"}
private

Definition at line 62 of file MMTriggerTool.h.

◆ m_phiBits

Gaudi::Property<int> NSWL1::MMTriggerTool::m_phiBits {this, "PhiBits", 6, "Number of Phi bits"}
private

Definition at line 66 of file MMTriggerTool.h.

◆ m_phiMax

Gaudi::Property<float> NSWL1::MMTriggerTool::m_phiMax {this, "PhiMax", 16.*M_PI/180.0, "Maximum Phi"}
private

Definition at line 65 of file MMTriggerTool.h.

◆ m_phiMin

Gaudi::Property<float> NSWL1::MMTriggerTool::m_phiMin {this, "PhiMin", -16.*M_PI/180.0, "Minimum Phi"}
private

Definition at line 64 of file MMTriggerTool.h.

◆ m_rBits

Gaudi::Property<int> NSWL1::MMTriggerTool::m_rBits {this, "RBits", 8, "Number of R bits"}
private

Definition at line 69 of file MMTriggerTool.h.

◆ m_rMax

Gaudi::Property<float> NSWL1::MMTriggerTool::m_rMax {this, "RMax", 5000.0, "Maximum R [mm]"}
private

Definition at line 68 of file MMTriggerTool.h.

◆ m_rMin

Gaudi::Property<float> NSWL1::MMTriggerTool::m_rMin {this, "RMin", 900.0, "Minimum R [mm]"}
private

Definition at line 67 of file MMTriggerTool.h.

◆ m_uv

Gaudi::Property<bool> NSWL1::MMTriggerTool::m_uv {this, "DiamondUV", true, "Include Stereo planes for tracking"}
private

Definition at line 53 of file MMTriggerTool.h.

The documentation for this class was generated from the following files:
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
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
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
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::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
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
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
lumiFormat.i
int i
Definition: lumiFormat.py:85
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
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::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
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
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
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:159
NSWL1::MMTriggerTool::m_doTruth
Gaudi::Property< bool > m_doTruth
Definition: MMTriggerTool.h:49
LArCellBinning.phiSteps
dictionary phiSteps
Definition: LArCellBinning.py:37
NSWL1::MMTriggerTool::m_rBits
Gaudi::Property< int > m_rBits
Definition: MMTriggerTool.h:69
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 22:10:42 for ATLAS Offline Software by   doxygen 1.8.18