ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Attributes | List of all members
NSWL1::MMTriggerTool Class Reference

#include <MMTriggerTool.h>

Inheritance 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< 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_xCount ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_uCount 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_iX = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iX");
42 m_trigger_diamond_iU = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iU");
43 m_trigger_diamond_iV = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iV");
44 m_trigger_diamond_xCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_xCount");
45 m_trigger_diamond_uCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_uCount");
46 m_trigger_diamond_age = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_age");
47 m_trigger_diamond_mx = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mx");
48 m_trigger_diamond_my = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_my");
49 m_trigger_diamond_Uavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Uavg");
50 m_trigger_diamond_Vavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Vavg");
51 m_trigger_diamond_mxl = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mxl");
52 m_trigger_diamond_theta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_theta");
53 m_trigger_diamond_eta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_eta");
54 m_trigger_diamond_dtheta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_dtheta");
55 m_trigger_diamond_phi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phi");
56 m_trigger_diamond_phiShf = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phiShf");
57 m_trigger_diamond_TP_phi_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_phi_id");
58 m_trigger_diamond_TP_R_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_R_id");
59 m_trigger_diamond_TP_dTheta_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_dTheta_id");
60 m_trigger_RZslopes = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_RZslopes");
61 m_trigger_trueEtaRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaRange");
62 m_trigger_truePtRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePtRange");
63 m_trigger_VMM = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_VMM");
64 m_trigger_plane = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_plane");
65 m_trigger_station = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_station");
66 m_trigger_strip = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_strip");
67 m_trigger_slope = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_slope");
68 m_trigger_trueThe = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThe");
69 m_trigger_truePhi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhi");
70 m_trigger_trueDth = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueDth");
71 m_trigger_trueEtaEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaEnt");
72 m_trigger_trueTheEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueTheEnt");
73 m_trigger_truePhiEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiEnt");
74 m_trigger_trueEtaPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaPos");
75 m_trigger_trueThePos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThePos");
76 m_trigger_truePhiPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiPos");
77
78 tree.addBranch(m_trigger_diamond_ntrig);
79 tree.addBranch(m_trigger_diamond_bc);
80 tree.addBranch(m_trigger_diamond_sector);
81 tree.addBranch(m_trigger_diamond_sectorPhi);
82 tree.addBranch(m_trigger_diamond_totalCount);
83 tree.addBranch(m_trigger_diamond_iX);
84 tree.addBranch(m_trigger_diamond_iU);
85 tree.addBranch(m_trigger_diamond_iV);
86 tree.addBranch(m_trigger_diamond_xCount);
87 tree.addBranch(m_trigger_diamond_uCount);
88 tree.addBranch(m_trigger_diamond_age);
89 tree.addBranch(m_trigger_diamond_mx);
90 tree.addBranch(m_trigger_diamond_my);
91 tree.addBranch(m_trigger_diamond_Uavg);
92 tree.addBranch(m_trigger_diamond_Vavg);
93 tree.addBranch(m_trigger_diamond_mxl);
94 tree.addBranch(m_trigger_diamond_theta);
95 tree.addBranch(m_trigger_diamond_eta);
96 tree.addBranch(m_trigger_diamond_dtheta);
97 tree.addBranch(m_trigger_diamond_phi);
98 tree.addBranch(m_trigger_diamond_phiShf);
99 tree.addBranch(m_trigger_diamond_TP_phi_id);
100 tree.addBranch(m_trigger_diamond_TP_R_id);
101 tree.addBranch(m_trigger_diamond_TP_dTheta_id);
102 tree.addBranch(m_trigger_RZslopes);
103 tree.addBranch(m_trigger_trueEtaRange);
104 tree.addBranch(m_trigger_truePtRange);
105 tree.addBranch(m_trigger_VMM);
106 tree.addBranch(m_trigger_plane);
107 tree.addBranch(m_trigger_station);
108 tree.addBranch(m_trigger_strip);
109 tree.addBranch(m_trigger_slope);
110 tree.addBranch(m_trigger_trueThe);
111 tree.addBranch(m_trigger_truePhi);
112 tree.addBranch(m_trigger_trueDth);
113 tree.addBranch(m_trigger_trueEtaEnt);
114 tree.addBranch(m_trigger_trueTheEnt);
115 tree.addBranch(m_trigger_truePhiEnt);
116 tree.addBranch(m_trigger_trueEtaPos);
117 tree.addBranch(m_trigger_trueThePos);
118 tree.addBranch(m_trigger_truePhiPos);
119 return StatusCode::SUCCESS;
120 }
tree
TChain * tree
Definition tile_monitor.h:30

◆ 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 }
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
NSWL1::MMTriggerTool::m_diamOverlapStereoDown
Gaudi::Property< int > m_diamOverlapStereoDown
Definition MMTriggerTool.h:59
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
NSWL1::MMTriggerTool::m_diamUVthreshold
Gaudi::Property< int > m_diamUVthreshold
Definition MMTriggerTool.h:55
NSWL1::MMTriggerTool::m_detectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detectorManagerKey
Definition MMTriggerTool.h:45
NSWL1::MMTriggerTool::m_diamond
std::unique_ptr< MMT_Diamond > m_diamond
Definition MMTriggerTool.h:74
NSWL1::MMTriggerTool::m_diamOverlapEtaUp
Gaudi::Property< int > m_diamOverlapEtaUp
Definition MMTriggerTool.h:56
NSWL1::MMTriggerTool::m_doNtuple
Gaudi::Property< bool > m_doNtuple
Definition MMTriggerTool.h:63
NSWL1::MMTriggerTool::m_mmDigitContainer
Gaudi::Property< std::string > m_mmDigitContainer
Definition MMTriggerTool.h:62
NSWL1::MMTriggerTool::m_diamOverlapStereoUp
Gaudi::Property< int > m_diamOverlapStereoUp
Definition MMTriggerTool.h:58
NSWL1::MMTriggerTool::m_keyMmDigitContainer
SG::ReadHandleKey< MmDigitContainer > m_keyMmDigitContainer
Definition MMTriggerTool.h:44
NSWL1::MMTriggerTool::m_keyMcEventCollection
SG::ReadHandleKey< McEventCollection > m_keyMcEventCollection
Definition MMTriggerTool.h:42
NSWL1::MMTriggerTool::m_uv
Gaudi::Property< bool > m_uv
Definition MMTriggerTool.h:53
NSWL1::MMTriggerTool::m_keyMuonEntryLayer
SG::ReadHandleKey< TrackRecordCollection > m_keyMuonEntryLayer
Definition MMTriggerTool.h:43
NSWL1::MMTriggerTool::m_isMC
Gaudi::Property< bool > m_isMC
Definition MMTriggerTool.h:48
NSWL1::MMTriggerTool::m_diamRoadSize
Gaudi::Property< int > m_diamRoadSize
Definition MMTriggerTool.h:52
NSWL1::MMTriggerTool::m_diamOverlapEtaDown
Gaudi::Property< int > m_diamOverlapEtaDown
Definition MMTriggerTool.h:57

◆ runTrigger()

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

Definition at line 122 of file MMTriggerTool.cxx.

122 {
123
124 uint64_t event = ctx.eventID().event_number();
125 ATH_MSG_DEBUG("********************************************************* EVENT NUMBER = " << event);
126
127 SG::ReadCondHandle<MuonGM::MuonDetectorManager> detManager{m_detectorManagerKey, ctx};
128 if(!detManager.isValid()){
129 ATH_MSG_ERROR("Failed to retrieve the MuonDetectorManager conditions object");
130 return StatusCode::FAILURE;
131 }
132
133 const McEventCollection* ptrMcEventCollection = nullptr;
134 const TrackRecordCollection* ptrMuonEntryLayer = nullptr;
135 if(m_isMC){
136 SG::ReadHandle<McEventCollection> readMcEventCollection( m_keyMcEventCollection, ctx );
137 if( !readMcEventCollection.isValid() ){
138 ATH_MSG_ERROR("Cannot retrieve McEventCollection");
139 return StatusCode::FAILURE;
140 }
141 if(m_doTruth) ptrMcEventCollection = readMcEventCollection.cptr();
142 SG::ReadHandle<TrackRecordCollection> readMuonEntryLayer( m_keyMuonEntryLayer, ctx );
143 if( !readMuonEntryLayer.isValid() ){
144 ATH_MSG_ERROR("Cannot retrieve MuonEntryLayer");
145 return StatusCode::FAILURE;
146 }
147 if(m_doTruth and m_doNtuple) {
148 ptrMuonEntryLayer = readMuonEntryLayer.cptr();
149 MMLoadVariables load = MMLoadVariables();
150 std::map<std::pair<uint64_t, unsigned int>,evInf_entry> Event_Info;
151 ATH_CHECK(load.getTruthInfo(ctx, ptrMcEventCollection, ptrMuonEntryLayer, Event_Info));
152
153 // Extract truth info, if available
154 for (const auto &it : Event_Info) {
155 m_trigger_trueEtaRange->push_back(it.second.eta_ip);
156 m_trigger_truePtRange->push_back(it.second.pt);
157 m_trigger_trueThe->push_back(it.second.theta_ip);
158 m_trigger_truePhi->push_back(it.second.phi_ip);
159 m_trigger_trueDth->push_back(it.second.dtheta); // theta_pos-theta_ent
160 m_trigger_trueEtaPos->push_back(it.second.eta_pos);
161 m_trigger_trueThePos->push_back(it.second.theta_pos);
162 m_trigger_truePhiPos->push_back(it.second.phi_pos);
163 m_trigger_trueEtaEnt->push_back(it.second.eta_ent);
164 m_trigger_trueTheEnt->push_back(it.second.theta_ent);
165 m_trigger_truePhiEnt->push_back(it.second.phi_ent);
166 }
167 }
168 }
169
170 SG::ReadHandle<MmDigitContainer> readMmDigitContainer( m_keyMmDigitContainer, ctx );
171 if( !readMmDigitContainer.isValid() ){
172 ATH_MSG_ERROR("Cannot retrieve MmDigitContainer");
173 return StatusCode::FAILURE;
174 }
175
176 for (const MmDigitCollection* digitCollection : *readMmDigitContainer) {
177
178 std::vector<std::shared_ptr<MMT_Hit> > ev_hits;
179 for (const MmDigit* digit : *digitCollection) {
180 const Identifier id = digit->identify();
181 if (not m_idHelperSvc->isMM(id)) continue;
182
183 const std::string stationName = m_idHelperSvc->chamberNameString(id);
184 const int stationEta = m_idHelperSvc->stationEta(id);
185 const int stationPhi = m_idHelperSvc->stationPhi(id);
186 const int sector = m_idHelperSvc->sector(id);
187 const int multiplet = m_idHelperSvc->mmIdHelper().multilayer(id);
188 const int gasGap = m_idHelperSvc->mmIdHelper().gasGap(id);
189
190 const int channel = m_idHelperSvc->mmIdHelper().channel(id);
191 // Checking whether strip exceeds allowed ranges
192 const MuonGM::MMReadoutElement* readout = detManager->getMMReadoutElement(id);
193 if (channel < 1 or channel > (readout->getDesign(id))->totalStrips) continue;
194
195 const float stripTime = digit->stripResponseTime();
196 // Checking positive digitization time
197 if (stripTime < 0.) continue;
198 const int BC = std::ceil(stripTime/25.);
199 ev_hits.emplace_back(std::make_shared<MMT_Hit>(id, stationName, stationEta, stationPhi, sector, multiplet, gasGap, channel, stripTime, BC, detManager.cptr()));
200
201 if (ev_hits.back()->infSlope()) {
202 ATH_MSG_WARNING("Infinite slope, removing hit");
203 ev_hits.pop_back();
204 continue;
205 }
206 if (m_doNtuple) {
207 m_trigger_VMM->push_back(ev_hits.back()->getVMM());
208 m_trigger_plane->push_back(ev_hits.back()->getPlane());
209 m_trigger_station->push_back(ev_hits.back()->getStationEta());
210 m_trigger_strip->push_back(ev_hits.back()->getChannel());
211 m_trigger_RZslopes->push_back(ev_hits.back()->getRZSlope());
212 }
213 }
214
215 // Go ahead when hits are more than X+UV thresholds
216 if (do_MMDiamonds and ev_hits.size() >= (m_diamond->getXthreshold()+m_diamond->getUVthreshold())) {
217 const bool isLarge = (std::ranges::all_of(ev_hits, [](const auto &hit) { return hit->getSector() == 'L'; }));
218 const char sector = (isLarge) ? 'L' : 'S';
219 const char side = (std::ranges::all_of(ev_hits, [](const auto &hit) { return hit->getStationEta() < 0; })) ? 'C' : 'A';
220 const int sectorPhi = ev_hits[0]->getSectorPhi();
221 const bool allSectorPhi = (std::ranges::all_of(ev_hits, [&](const auto &hit) { return hit->getSectorPhi() == sectorPhi; }));
222 if (not allSectorPhi) {
223 ATH_MSG_ERROR("Available digits belongs to different sectors IDs, unable to assign an unique ID in output RDO");
224 return StatusCode::FAILURE;
225 }
226 const bool isEta1 = (std::ranges::all_of(ev_hits, [](const auto &hit) { return std::abs(hit->getStationEta()) == 1; }));
227
228 // Setup roads
229 std::vector<MMT_Road> ev_roads;
230 m_diamond->createRoads(ev_roads, isLarge, isEta1);
231
232 // Evaluate coincidences
233 std::vector<slope_t> diamondSlopes;
234 m_diamond->findDiamonds(ev_hits, ev_roads, diamondSlopes, sectorPhi);
235
236 // Store output, if any, in debug ntuple (if enabled) and in trigger RDO
237 if (not diamondSlopes.empty()) {
238 if (m_doNtuple) {
239 m_trigger_diamond_ntrig->push_back(diamondSlopes.size());
240 for (const auto &slope : diamondSlopes) {
241 m_trigger_diamond_sector->push_back(sector);
242 m_trigger_diamond_sectorPhi->push_back(sectorPhi);
243 m_trigger_diamond_bc->push_back(slope.BC);
244 m_trigger_diamond_totalCount->push_back(slope.totalCount);
245 m_trigger_diamond_xCount->push_back(slope.xCount);
246 m_trigger_diamond_uCount->push_back(slope.uCount);
247 m_trigger_diamond_iX->push_back(slope.iRoad);
248 m_trigger_diamond_iU->push_back(slope.iRoadu);
249 m_trigger_diamond_iV->push_back(slope.iRoadv);
250 m_trigger_diamond_age->push_back(slope.age);
251 m_trigger_diamond_mx->push_back(slope.mx);
252 m_trigger_diamond_my->push_back(slope.my);
253 m_trigger_diamond_Uavg->push_back(slope.uavg);
254 m_trigger_diamond_Vavg->push_back(slope.vavg);
255 m_trigger_diamond_mxl->push_back(slope.mxl);
256 m_trigger_diamond_theta->push_back(slope.theta);
257 m_trigger_diamond_eta->push_back(slope.eta);
258 m_trigger_diamond_dtheta->push_back(slope.dtheta);
259 m_trigger_diamond_phi->push_back(slope.phi);
260 m_trigger_diamond_phiShf->push_back(slope.phiShf);
261 }
262 }
263
264 // MM RDO filling below
265 std::vector<int> slopeBC;
266 for (const auto &slope : diamondSlopes) slopeBC.push_back(slope.BC);
267 std::ranges::sort(slopeBC);
268 slopeBC.erase( std::unique(slopeBC.begin(), slopeBC.end()), slopeBC.end() );
269 for (const auto bc : slopeBC) {
270 Muon::NSW_TrigRawData* trigRawData = new Muon::NSW_TrigRawData(sectorPhi-1, side, bc);
271
272 for (const auto &slope : diamondSlopes) {
273 if (bc == slope.BC) {
274 Muon::NSW_TrigRawDataSegment* trigRawDataSegment = new Muon::NSW_TrigRawDataSegment();
275
276 // Phi-id - here use local phi (not phiShf)
277 uint8_t phi_id = 0;
278 if (slope.phi > m_phiMax || slope.phi < m_phiMin) trigRawDataSegment->setPhiIndex(phi_id);
279 else {
280 uint8_t nPhi = (1<<m_phiBits) -2; // To accomodate the new phi-id encoding prescription around 0
281 float phiSteps = (m_phiMax - m_phiMin)/nPhi;
282 for (uint8_t i=0; i<nPhi; i++) {
283 if ((slope.phi) < (m_phiMin+i*phiSteps)) {
284 phi_id = i;
285 break;
286 }
287 }
288 trigRawDataSegment->setPhiIndex(phi_id);
289 }
290 if (m_doNtuple) m_trigger_diamond_TP_phi_id->push_back(phi_id);
291
292 // R-id
293 double extrapolatedR = 7824.46*std::abs(std::tan(slope.theta)); // The Z plane is a fixed value, taken from SL-TP documentation
294 uint8_t R_id = 0;
295 if (extrapolatedR > m_rMax || extrapolatedR < m_rMin) trigRawDataSegment->setRIndex(R_id);
296 else {
297 uint8_t nR = (1<<m_rBits) -1;
298 float Rsteps = (m_rMax - m_rMin)/nR;
299 for (uint8_t j=0; j<nR; j++) {
300 if (extrapolatedR < (m_rMin+j*Rsteps)) {
301 R_id = j;
302 break;
303 }
304 }
305 trigRawDataSegment->setRIndex(R_id);
306 }
307 if (m_doNtuple) m_trigger_diamond_TP_R_id->push_back(R_id);
308
309 // DeltaTheta-id
310 uint8_t dTheta_id = 0;
311 if (slope.dtheta > m_dThetaMax || slope.dtheta < m_dThetaMin) trigRawDataSegment->setDeltaTheta(dTheta_id);
312 else {
313 uint8_t ndTheta = (1<<m_dThetaBits) -1;
314 float dThetaSteps = (m_dThetaMax - m_dThetaMin)/ndTheta;
315 for (uint8_t k=0; k<ndTheta; k++) {
316 if ((slope.dtheta) < (m_dThetaMin+k*dThetaSteps)) {
317 dTheta_id = k;
318 break;
319 }
320 }
321 trigRawDataSegment->setDeltaTheta(dTheta_id);
322 }
323 if (m_doNtuple) m_trigger_diamond_TP_dTheta_id->push_back(dTheta_id);
324
325 // Low R-resolution bit
326 trigRawDataSegment->setLowRes(slope.lowRes);
327
328 trigRawData->push_back(trigRawDataSegment);
329 }
330 }
331 rdo->push_back(trigRawData);
332 }
333 }
334 }
335 else {
336 ATH_MSG_DEBUG("Available hits are " << ev_hits.size() << ", less than X+UV threshold, skipping digit collection");
337 }
338 }
339
340 return StatusCode::SUCCESS;
341 }
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
TrackRecordCollection
AtlasHitsVector< TrackRecord > TrackRecordCollection
Definition TrackRecordCollection.h:12
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
MuonGM::MMReadoutElement::getDesign
const MuonChannelDesign * getDesign(const Identifier &id) const
returns the MuonChannelDesign class for the given identifier
Definition MMReadoutElement.h:190
Muon::NSW_TrigRawDataSegment::setLowRes
void setLowRes(bool lowRes)
Definition NSW_TrigRawDataSegment.h:41
Muon::NSW_TrigRawDataSegment::setPhiIndex
void setPhiIndex(uint8_t phiIndex)
Definition NSW_TrigRawDataSegment.h:37
Muon::NSW_TrigRawDataSegment::setDeltaTheta
void setDeltaTheta(uint8_t deltaTheta)
Definition NSW_TrigRawDataSegment.h:36
Muon::NSW_TrigRawDataSegment::setRIndex
void setRIndex(uint8_t rIndex)
Definition NSW_TrigRawDataSegment.h:38
NSWL1::MMTriggerTool::m_rMax
Gaudi::Property< float > m_rMax
Definition MMTriggerTool.h:68
NSWL1::MMTriggerTool::m_phiMax
Gaudi::Property< float > m_phiMax
Definition MMTriggerTool.h:65
NSWL1::MMTriggerTool::m_dThetaMax
Gaudi::Property< float > m_dThetaMax
Definition MMTriggerTool.h:71
NSWL1::MMTriggerTool::m_phiMin
Gaudi::Property< float > m_phiMin
Definition MMTriggerTool.h:64
NSWL1::MMTriggerTool::m_rBits
Gaudi::Property< int > m_rBits
Definition MMTriggerTool.h:69
NSWL1::MMTriggerTool::m_phiBits
Gaudi::Property< int > m_phiBits
Definition MMTriggerTool.h:66
NSWL1::MMTriggerTool::m_dThetaBits
Gaudi::Property< int > m_dThetaBits
Definition MMTriggerTool.h:72
NSWL1::MMTriggerTool::m_rMin
Gaudi::Property< float > m_rMin
Definition MMTriggerTool.h:67
NSWL1::MMTriggerTool::m_dThetaMin
Gaudi::Property< float > m_dThetaMin
Definition MMTriggerTool.h:70
NSWL1::MMTriggerTool::m_doTruth
Gaudi::Property< bool > m_doTruth
Definition MMTriggerTool.h:49
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition ReadCondHandle.h:67
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition NSWSTGTPDecodeBitmaps.h:161
TauHitVars::j
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)
Definition ConstituentLoaderTauHit.cxx:102
TrigVSI::AlgConsts::nPhi
constexpr int nPhi
Default bin number of phi for vertex map.
Definition Trigger/TrigTools/TrigVrtSecInclusive/TrigVrtSecInclusive/Constants.h:27
plotting.yearwise_efficiency.channel
channel
Definition yearwise_efficiency.py:24
python.root_pickle.load
load(f, use_proxy=1, key=None)
Definition root_pickle.py:430
std::unique
DataModel_detail::iterator< DVL > unique(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of unique for DataVector/List.
Definition DVL_algorithms.h:135

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/41]

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.

76{};

◆ ATLAS_THREAD_SAFE [2/41]

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

Definition at line 77 of file MMTriggerTool.h.

77{};

◆ ATLAS_THREAD_SAFE [3/41]

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

Definition at line 78 of file MMTriggerTool.h.

78{};

◆ ATLAS_THREAD_SAFE [4/41]

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

Definition at line 79 of file MMTriggerTool.h.

79{};

◆ ATLAS_THREAD_SAFE [5/41]

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.

80{};

◆ ATLAS_THREAD_SAFE [6/41]

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

Definition at line 81 of file MMTriggerTool.h.

81{};

◆ ATLAS_THREAD_SAFE [7/41]

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

Definition at line 82 of file MMTriggerTool.h.

82{};

◆ ATLAS_THREAD_SAFE [8/41]

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

Definition at line 83 of file MMTriggerTool.h.

83{};

◆ ATLAS_THREAD_SAFE [9/41]

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

Definition at line 84 of file MMTriggerTool.h.

84{};

◆ ATLAS_THREAD_SAFE [10/41]

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

Definition at line 85 of file MMTriggerTool.h.

85{};

◆ ATLAS_THREAD_SAFE [11/41]

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

Definition at line 86 of file MMTriggerTool.h.

86{};

◆ ATLAS_THREAD_SAFE [12/41]

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

Definition at line 87 of file MMTriggerTool.h.

87{};

◆ ATLAS_THREAD_SAFE [13/41]

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

Definition at line 88 of file MMTriggerTool.h.

88{};

◆ ATLAS_THREAD_SAFE [14/41]

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

Definition at line 89 of file MMTriggerTool.h.

89{};

◆ ATLAS_THREAD_SAFE [15/41]

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

Definition at line 90 of file MMTriggerTool.h.

90{};

◆ ATLAS_THREAD_SAFE [16/41]

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

Definition at line 91 of file MMTriggerTool.h.

91{};

◆ ATLAS_THREAD_SAFE [17/41]

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

Definition at line 92 of file MMTriggerTool.h.

92{};

◆ ATLAS_THREAD_SAFE [18/41]

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

Definition at line 93 of file MMTriggerTool.h.

93{};

◆ ATLAS_THREAD_SAFE [19/41]

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

Definition at line 94 of file MMTriggerTool.h.

94{};

◆ ATLAS_THREAD_SAFE [20/41]

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

Definition at line 95 of file MMTriggerTool.h.

95{};

◆ ATLAS_THREAD_SAFE [21/41]

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

Definition at line 96 of file MMTriggerTool.h.

96{};

◆ ATLAS_THREAD_SAFE [22/41]

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

Definition at line 97 of file MMTriggerTool.h.

97{};

◆ ATLAS_THREAD_SAFE [23/41]

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

Definition at line 98 of file MMTriggerTool.h.

98{};

◆ ATLAS_THREAD_SAFE [24/41]

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

Definition at line 99 of file MMTriggerTool.h.

99{};

◆ ATLAS_THREAD_SAFE [25/41]

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

Definition at line 100 of file MMTriggerTool.h.

100{};

◆ ATLAS_THREAD_SAFE [26/41]

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

Definition at line 101 of file MMTriggerTool.h.

101{};

◆ ATLAS_THREAD_SAFE [27/41]

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

Definition at line 102 of file MMTriggerTool.h.

102{};

◆ ATLAS_THREAD_SAFE [28/41]

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

Definition at line 103 of file MMTriggerTool.h.

103{};

◆ ATLAS_THREAD_SAFE [29/41]

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

Definition at line 104 of file MMTriggerTool.h.

104{};

◆ ATLAS_THREAD_SAFE [30/41]

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

Definition at line 105 of file MMTriggerTool.h.

105{};

◆ ATLAS_THREAD_SAFE [31/41]

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

Definition at line 106 of file MMTriggerTool.h.

106{};

◆ ATLAS_THREAD_SAFE [32/41]

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

Definition at line 107 of file MMTriggerTool.h.

107{};

◆ ATLAS_THREAD_SAFE [33/41]

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

Definition at line 108 of file MMTriggerTool.h.

108{};

◆ ATLAS_THREAD_SAFE [34/41]

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

Definition at line 109 of file MMTriggerTool.h.

109{};

◆ ATLAS_THREAD_SAFE [35/41]

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

Definition at line 110 of file MMTriggerTool.h.

110{};

◆ ATLAS_THREAD_SAFE [36/41]

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

Definition at line 111 of file MMTriggerTool.h.

111{};

◆ ATLAS_THREAD_SAFE [37/41]

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

Definition at line 112 of file MMTriggerTool.h.

112{};

◆ ATLAS_THREAD_SAFE [38/41]

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

Definition at line 113 of file MMTriggerTool.h.

113{};

◆ ATLAS_THREAD_SAFE [39/41]

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

Definition at line 114 of file MMTriggerTool.h.

114{};

◆ ATLAS_THREAD_SAFE [40/41]

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

Definition at line 115 of file MMTriggerTool.h.

115{};

◆ ATLAS_THREAD_SAFE [41/41]

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

Definition at line 116 of file MMTriggerTool.h.

116{};

◆ 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.

45{this, "DetectorManagerKey", "MuonDetectorManager", "Key of MuonDetectorManager condition data"};

◆ 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.

57{this, "DiamondEtaDownOverlap", 0, "Number of Eta strips for lower road overlap"};

◆ 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.

56{this, "DiamondEtaUpOverlap", 4, "Number of Eta strips for upper road overlap"};

◆ 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.

59{this, "DiamondStereoDownOverlap", 0, "Number of Stereo strips for lower road overlap"};

◆ 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.

58{this, "DiamondStereoUpOverlap", 4, "Number of Stereo strips for upper road overlap"};

◆ 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.

52{this, "DiamondRoadSize", 8, "Number of strips to create a road"};

◆ 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.

55{this, "DiamondStereoThreshold", 3, "Number of Stereo planes for coincidences"};

◆ 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.

54{this, "DiamondEtaThreshold", 3, "Number of Eta planes for coincidences"};

◆ 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.

63{this, "DoNtuple", false, "Input the MMStrip branches into the analysis ntuple"};

◆ 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.

49{this, "DoTruth", false, "Process truth information. Disabled by default"};

◆ 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.

72{this, "DThetaBits", 5, "Number of dTheta bits"};

◆ 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.

71{this, "DThetaMax", 0.015, "Maximum dTheta [rad]"};

◆ 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.

70{this, "DThetaMin", -0.015, "Minimum dTheta [rad]"};

◆ m_idHelperSvc

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

Definition at line 46 of file MMTriggerTool.h.

46{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

◆ m_isMC

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

Definition at line 48 of file MMTriggerTool.h.

48{this, "IsMC", true, "This is MC"};

◆ m_keyMcEventCollection

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

Definition at line 42 of file MMTriggerTool.h.

42{this,"McEventCollection","TruthEvent","Location of TruthEvent"};

◆ 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.

44{this,"MmDigitContainer","MM_DIGITS","Location of MmDigitContainer"};

◆ m_keyMuonEntryLayer

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

Definition at line 43 of file MMTriggerTool.h.

43{this,"MuonEntryLayer","MuonEntryLayer","Location of MuonEntryLayer"};

◆ 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.

62{this, "MM_DigitContainerName", "MM_DIGITS", "Name of the MM digit container"};

◆ 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.

66{this, "PhiBits", 6, "Number of Phi bits"};

◆ 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.

65{this, "PhiMax", 16.*M_PI/180.0, "Maximum Phi"};
M_PI
#define M_PI
Definition ActiveFraction.h:11

◆ 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.

64{this, "PhiMin", -16.*M_PI/180.0, "Minimum Phi"};

◆ 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.

69{this, "RBits", 8, "Number of R bits"};

◆ 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.

68{this, "RMax", 5000.0, "Maximum R [mm]"};

◆ 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.

67{this, "RMin", 900.0, "Minimum R [mm]"};

◆ 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.

53{this, "DiamondUV", true, "Include Stereo planes for tracking"};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0