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"}
SG::ReadCondHandleKey< NswDcsDbData > m_dcsKey {this, "DCSDataKey", "NswDcsDbData", "Read key for the NSW DCS 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 31 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 36 of file MMTriggerTool.cxx.

36 {
37 m_trigger_diamond_ntrig = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_ntrig");
38 m_trigger_diamond_bc = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_bc");
39 m_trigger_diamond_sector = std::make_shared<MuonVal::VectorBranch<char> >(tree, "MM_diamond_sector");
40 m_trigger_diamond_sectorPhi = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_sectorPhi");
41 m_trigger_diamond_totalCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_totalCount");
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_xCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_xCount");
46 m_trigger_diamond_uCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_uCount");
47 m_trigger_diamond_age = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_age");
48 m_trigger_diamond_mx = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mx");
49 m_trigger_diamond_my = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_my");
50 m_trigger_diamond_Uavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Uavg");
51 m_trigger_diamond_Vavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Vavg");
52 m_trigger_diamond_mxl = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mxl");
53 m_trigger_diamond_theta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_theta");
54 m_trigger_diamond_eta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_eta");
55 m_trigger_diamond_dtheta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_dtheta");
56 m_trigger_diamond_phi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phi");
57 m_trigger_diamond_phiShf = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phiShf");
58 m_trigger_diamond_TP_phi_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_phi_id");
59 m_trigger_diamond_TP_R_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_R_id");
60 m_trigger_diamond_TP_dTheta_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_dTheta_id");
61 m_trigger_RZslopes = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_RZslopes");
62 m_trigger_trueEtaRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaRange");
63 m_trigger_truePtRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePtRange");
64 m_trigger_VMM = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_VMM");
65 m_trigger_plane = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_plane");
66 m_trigger_station = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_station");
67 m_trigger_strip = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_strip");
68 m_trigger_slope = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_slope");
69 m_trigger_trueThe = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThe");
70 m_trigger_truePhi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhi");
71 m_trigger_trueDth = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueDth");
72 m_trigger_trueEtaEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaEnt");
73 m_trigger_trueTheEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueTheEnt");
74 m_trigger_truePhiEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiEnt");
75 m_trigger_trueEtaPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaPos");
76 m_trigger_trueThePos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThePos");
77 m_trigger_truePhiPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiPos");
78
79 tree.addBranch(m_trigger_diamond_ntrig);
80 tree.addBranch(m_trigger_diamond_bc);
81 tree.addBranch(m_trigger_diamond_sector);
82 tree.addBranch(m_trigger_diamond_sectorPhi);
83 tree.addBranch(m_trigger_diamond_totalCount);
84 tree.addBranch(m_trigger_diamond_iX);
85 tree.addBranch(m_trigger_diamond_iU);
86 tree.addBranch(m_trigger_diamond_iV);
87 tree.addBranch(m_trigger_diamond_xCount);
88 tree.addBranch(m_trigger_diamond_uCount);
89 tree.addBranch(m_trigger_diamond_age);
90 tree.addBranch(m_trigger_diamond_mx);
91 tree.addBranch(m_trigger_diamond_my);
92 tree.addBranch(m_trigger_diamond_Uavg);
93 tree.addBranch(m_trigger_diamond_Vavg);
94 tree.addBranch(m_trigger_diamond_mxl);
95 tree.addBranch(m_trigger_diamond_theta);
96 tree.addBranch(m_trigger_diamond_eta);
97 tree.addBranch(m_trigger_diamond_dtheta);
98 tree.addBranch(m_trigger_diamond_phi);
99 tree.addBranch(m_trigger_diamond_phiShf);
100 tree.addBranch(m_trigger_diamond_TP_phi_id);
101 tree.addBranch(m_trigger_diamond_TP_R_id);
102 tree.addBranch(m_trigger_diamond_TP_dTheta_id);
103 tree.addBranch(m_trigger_RZslopes);
104 tree.addBranch(m_trigger_trueEtaRange);
105 tree.addBranch(m_trigger_truePtRange);
106 tree.addBranch(m_trigger_VMM);
107 tree.addBranch(m_trigger_plane);
108 tree.addBranch(m_trigger_station);
109 tree.addBranch(m_trigger_strip);
110 tree.addBranch(m_trigger_slope);
111 tree.addBranch(m_trigger_trueThe);
112 tree.addBranch(m_trigger_truePhi);
113 tree.addBranch(m_trigger_trueDth);
114 tree.addBranch(m_trigger_trueEtaEnt);
115 tree.addBranch(m_trigger_trueTheEnt);
116 tree.addBranch(m_trigger_truePhiEnt);
117 tree.addBranch(m_trigger_trueEtaPos);
118 tree.addBranch(m_trigger_trueThePos);
119 tree.addBranch(m_trigger_truePhiPos);
120 return StatusCode::SUCCESS;
121 }
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 ATH_CHECK(m_dcsKey.initialize(!m_isMC));
25
26 if(m_doNtuple and Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
27 ATH_MSG_ERROR("DoNtuple is not possible in multi-threaded mode");
28 return StatusCode::FAILURE;
29 }
30
31 m_diamond = std::make_unique<MMT_Diamond>(m_diamXthreshold, m_uv, m_diamUVthreshold, m_diamRoadSize, m_diamOverlapEtaUp, m_diamOverlapEtaDown, m_diamOverlapStereoUp, m_diamOverlapStereoDown);
32
33 return StatusCode::SUCCESS;
34 }
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:61
NSWL1::MMTriggerTool::m_diamXthreshold
Gaudi::Property< int > m_diamXthreshold
Definition MMTriggerTool.h:56
NSWL1::MMTriggerTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition MMTriggerTool.h:48
NSWL1::MMTriggerTool::m_diamUVthreshold
Gaudi::Property< int > m_diamUVthreshold
Definition MMTriggerTool.h:57
NSWL1::MMTriggerTool::m_detectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detectorManagerKey
Definition MMTriggerTool.h:46
NSWL1::MMTriggerTool::m_diamond
std::unique_ptr< MMT_Diamond > m_diamond
Definition MMTriggerTool.h:76
NSWL1::MMTriggerTool::m_diamOverlapEtaUp
Gaudi::Property< int > m_diamOverlapEtaUp
Definition MMTriggerTool.h:58
NSWL1::MMTriggerTool::m_doNtuple
Gaudi::Property< bool > m_doNtuple
Definition MMTriggerTool.h:65
NSWL1::MMTriggerTool::m_mmDigitContainer
Gaudi::Property< std::string > m_mmDigitContainer
Definition MMTriggerTool.h:64
NSWL1::MMTriggerTool::m_diamOverlapStereoUp
Gaudi::Property< int > m_diamOverlapStereoUp
Definition MMTriggerTool.h:60
NSWL1::MMTriggerTool::m_keyMmDigitContainer
SG::ReadHandleKey< MmDigitContainer > m_keyMmDigitContainer
Definition MMTriggerTool.h:45
NSWL1::MMTriggerTool::m_keyMcEventCollection
SG::ReadHandleKey< McEventCollection > m_keyMcEventCollection
Definition MMTriggerTool.h:43
NSWL1::MMTriggerTool::m_uv
Gaudi::Property< bool > m_uv
Definition MMTriggerTool.h:55
NSWL1::MMTriggerTool::m_keyMuonEntryLayer
SG::ReadHandleKey< TrackRecordCollection > m_keyMuonEntryLayer
Definition MMTriggerTool.h:44
NSWL1::MMTriggerTool::m_isMC
Gaudi::Property< bool > m_isMC
Definition MMTriggerTool.h:50
NSWL1::MMTriggerTool::m_diamRoadSize
Gaudi::Property< int > m_diamRoadSize
Definition MMTriggerTool.h:54
NSWL1::MMTriggerTool::m_diamOverlapEtaDown
Gaudi::Property< int > m_diamOverlapEtaDown
Definition MMTriggerTool.h:59
NSWL1::MMTriggerTool::m_dcsKey
SG::ReadCondHandleKey< NswDcsDbData > m_dcsKey
Definition MMTriggerTool.h:47

◆ runTrigger()

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

Definition at line 123 of file MMTriggerTool.cxx.

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

78{};

◆ ATLAS_THREAD_SAFE [2/41]

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

Definition at line 79 of file MMTriggerTool.h.

79{};

◆ ATLAS_THREAD_SAFE [3/41]

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

Definition at line 80 of file MMTriggerTool.h.

80{};

◆ ATLAS_THREAD_SAFE [4/41]

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

Definition at line 81 of file MMTriggerTool.h.

81{};

◆ 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 82 of file MMTriggerTool.h.

82{};

◆ ATLAS_THREAD_SAFE [6/41]

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

Definition at line 83 of file MMTriggerTool.h.

83{};

◆ ATLAS_THREAD_SAFE [7/41]

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

Definition at line 84 of file MMTriggerTool.h.

84{};

◆ ATLAS_THREAD_SAFE [8/41]

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

Definition at line 85 of file MMTriggerTool.h.

85{};

◆ 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 86 of file MMTriggerTool.h.

86{};

◆ 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 87 of file MMTriggerTool.h.

87{};

◆ ATLAS_THREAD_SAFE [11/41]

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

Definition at line 88 of file MMTriggerTool.h.

88{};

◆ ATLAS_THREAD_SAFE [12/41]

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

Definition at line 89 of file MMTriggerTool.h.

89{};

◆ ATLAS_THREAD_SAFE [13/41]

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

Definition at line 90 of file MMTriggerTool.h.

90{};

◆ ATLAS_THREAD_SAFE [14/41]

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

Definition at line 91 of file MMTriggerTool.h.

91{};

◆ ATLAS_THREAD_SAFE [15/41]

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

Definition at line 92 of file MMTriggerTool.h.

92{};

◆ ATLAS_THREAD_SAFE [16/41]

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

Definition at line 93 of file MMTriggerTool.h.

93{};

◆ ATLAS_THREAD_SAFE [17/41]

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

Definition at line 94 of file MMTriggerTool.h.

94{};

◆ ATLAS_THREAD_SAFE [18/41]

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

Definition at line 95 of file MMTriggerTool.h.

95{};

◆ ATLAS_THREAD_SAFE [19/41]

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

Definition at line 96 of file MMTriggerTool.h.

96{};

◆ ATLAS_THREAD_SAFE [20/41]

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

Definition at line 97 of file MMTriggerTool.h.

97{};

◆ ATLAS_THREAD_SAFE [21/41]

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

Definition at line 98 of file MMTriggerTool.h.

98{};

◆ 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 99 of file MMTriggerTool.h.

99{};

◆ 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 100 of file MMTriggerTool.h.

100{};

◆ 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 101 of file MMTriggerTool.h.

101{};

◆ ATLAS_THREAD_SAFE [25/41]

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

Definition at line 102 of file MMTriggerTool.h.

102{};

◆ ATLAS_THREAD_SAFE [26/41]

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

Definition at line 103 of file MMTriggerTool.h.

103{};

◆ ATLAS_THREAD_SAFE [27/41]

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

Definition at line 104 of file MMTriggerTool.h.

104{};

◆ ATLAS_THREAD_SAFE [28/41]

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

Definition at line 105 of file MMTriggerTool.h.

105{};

◆ ATLAS_THREAD_SAFE [29/41]

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

Definition at line 106 of file MMTriggerTool.h.

106{};

◆ ATLAS_THREAD_SAFE [30/41]

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

Definition at line 107 of file MMTriggerTool.h.

107{};

◆ ATLAS_THREAD_SAFE [31/41]

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

Definition at line 108 of file MMTriggerTool.h.

108{};

◆ ATLAS_THREAD_SAFE [32/41]

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

Definition at line 109 of file MMTriggerTool.h.

109{};

◆ ATLAS_THREAD_SAFE [33/41]

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

Definition at line 110 of file MMTriggerTool.h.

110{};

◆ ATLAS_THREAD_SAFE [34/41]

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

Definition at line 111 of file MMTriggerTool.h.

111{};

◆ ATLAS_THREAD_SAFE [35/41]

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

Definition at line 112 of file MMTriggerTool.h.

112{};

◆ ATLAS_THREAD_SAFE [36/41]

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

Definition at line 113 of file MMTriggerTool.h.

113{};

◆ ATLAS_THREAD_SAFE [37/41]

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

Definition at line 114 of file MMTriggerTool.h.

114{};

◆ ATLAS_THREAD_SAFE [38/41]

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

Definition at line 115 of file MMTriggerTool.h.

115{};

◆ ATLAS_THREAD_SAFE [39/41]

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

Definition at line 116 of file MMTriggerTool.h.

116{};

◆ ATLAS_THREAD_SAFE [40/41]

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

Definition at line 117 of file MMTriggerTool.h.

117{};

◆ ATLAS_THREAD_SAFE [41/41]

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

Definition at line 118 of file MMTriggerTool.h.

118{};

◆ m_dcsKey

SG::ReadCondHandleKey<NswDcsDbData> NSWL1::MMTriggerTool::m_dcsKey {this, "DCSDataKey", "NswDcsDbData", "Read key for the NSW DCS data"}
private

Definition at line 47 of file MMTriggerTool.h.

47{this, "DCSDataKey", "NswDcsDbData", "Read key for the NSW DCS data"};

◆ m_detectorManagerKey

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

Definition at line 46 of file MMTriggerTool.h.

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

◆ m_diamond

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

Definition at line 76 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 59 of file MMTriggerTool.h.

59{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 58 of file MMTriggerTool.h.

58{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 61 of file MMTriggerTool.h.

61{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 60 of file MMTriggerTool.h.

60{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 54 of file MMTriggerTool.h.

54{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 57 of file MMTriggerTool.h.

57{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 56 of file MMTriggerTool.h.

56{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 65 of file MMTriggerTool.h.

65{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 51 of file MMTriggerTool.h.

51{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 74 of file MMTriggerTool.h.

74{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 73 of file MMTriggerTool.h.

73{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 72 of file MMTriggerTool.h.

72{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 48 of file MMTriggerTool.h.

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

◆ m_isMC

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

Definition at line 50 of file MMTriggerTool.h.

50{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 43 of file MMTriggerTool.h.

43{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 45 of file MMTriggerTool.h.

45{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 44 of file MMTriggerTool.h.

44{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 64 of file MMTriggerTool.h.

64{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 68 of file MMTriggerTool.h.

68{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 67 of file MMTriggerTool.h.

67{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 66 of file MMTriggerTool.h.

66{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 71 of file MMTriggerTool.h.

71{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 70 of file MMTriggerTool.h.

70{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 69 of file MMTriggerTool.h.

69{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 55 of file MMTriggerTool.h.

55{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