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< unsigned int > > m_trigger_diamond_realCount ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_iX ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_iU ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_iV ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_XbkgCount ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_UVbkgCount ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_XmuonCount ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< unsigned int > > m_trigger_diamond_UVmuonCount ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_diamond_age ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_mx ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_my ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_Uavg ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_Vavg ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_mxl ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_theta ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_eta ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_dtheta ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_phi ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_diamond_phiShf ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_trigger_diamond_TP_phi_id ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_trigger_diamond_TP_R_id ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_trigger_diamond_TP_dTheta_id ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_RZslopes ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueEtaRange ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_truePtRange ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_VMM ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_plane ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_station ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_trigger_strip ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_slope ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueThe ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_truePhi ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueDth ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueEtaEnt ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueTheEnt ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_truePhiEnt ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueEtaPos ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_trueThePos ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< double > > m_trigger_truePhiPos ATLAS_THREAD_SAFE {}

Detailed Description

Definition at line 30 of file MMTriggerTool.h.

Constructor & Destructor Documentation

◆ MMTriggerTool()

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

Definition at line 9 of file MMTriggerTool.cxx.

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

◆ ~MMTriggerTool()

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

Member Function Documentation

◆ attachBranches()

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

Definition at line 35 of file MMTriggerTool.cxx.

35 {
36 m_trigger_diamond_ntrig = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_ntrig");
37 m_trigger_diamond_bc = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_bc");
38 m_trigger_diamond_sector = std::make_shared<MuonVal::VectorBranch<char> >(tree, "MM_diamond_sector");
39 m_trigger_diamond_sectorPhi = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_sectorPhi");
40 m_trigger_diamond_totalCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_totalCount");
41 m_trigger_diamond_realCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_realCount");
42 m_trigger_diamond_iX = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iX");
43 m_trigger_diamond_iU = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iU");
44 m_trigger_diamond_iV = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_iV");
45 m_trigger_diamond_XbkgCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_XbkgCount");
46 m_trigger_diamond_UVbkgCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_UVbkgCount");
47 m_trigger_diamond_XmuonCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_XmuonCount");
48 m_trigger_diamond_UVmuonCount = std::make_shared<MuonVal::VectorBranch<unsigned int> >(tree, "MM_diamond_UVmuonCount");
49 m_trigger_diamond_age = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_diamond_age");
50 m_trigger_diamond_mx = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mx");
51 m_trigger_diamond_my = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_my");
52 m_trigger_diamond_Uavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Uavg");
53 m_trigger_diamond_Vavg = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_Vavg");
54 m_trigger_diamond_mxl = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_mxl");
55 m_trigger_diamond_theta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_theta");
56 m_trigger_diamond_eta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_eta");
57 m_trigger_diamond_dtheta = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_dtheta");
58 m_trigger_diamond_phi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phi");
59 m_trigger_diamond_phiShf = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_diamond_phiShf");
60 m_trigger_diamond_TP_phi_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_phi_id");
61 m_trigger_diamond_TP_R_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_R_id");
62 m_trigger_diamond_TP_dTheta_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "MM_diamond_TP_dTheta_id");
63 m_trigger_RZslopes = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_RZslopes");
64 m_trigger_trueEtaRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaRange");
65 m_trigger_truePtRange = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePtRange");
66 m_trigger_VMM = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_VMM");
67 m_trigger_plane = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_plane");
68 m_trigger_station = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_station");
69 m_trigger_strip = std::make_shared<MuonVal::VectorBranch<int> >(tree, "MM_strip");
70 m_trigger_slope = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_slope");
71 m_trigger_trueThe = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThe");
72 m_trigger_truePhi = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhi");
73 m_trigger_trueDth = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueDth");
74 m_trigger_trueEtaEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaEnt");
75 m_trigger_trueTheEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueTheEnt");
76 m_trigger_truePhiEnt = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiEnt");
77 m_trigger_trueEtaPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueEtaPos");
78 m_trigger_trueThePos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_trueThePos");
79 m_trigger_truePhiPos = std::make_shared<MuonVal::VectorBranch<double> >(tree, "MM_truePhiPos");
80
81 tree.addBranch(m_trigger_diamond_ntrig);
82 tree.addBranch(m_trigger_diamond_bc);
83 tree.addBranch(m_trigger_diamond_sector);
84 tree.addBranch(m_trigger_diamond_sectorPhi);
85 tree.addBranch(m_trigger_diamond_totalCount);
86 tree.addBranch(m_trigger_diamond_realCount);
87 tree.addBranch(m_trigger_diamond_iX);
88 tree.addBranch(m_trigger_diamond_iU);
89 tree.addBranch(m_trigger_diamond_iV);
90 tree.addBranch(m_trigger_diamond_XbkgCount);
91 tree.addBranch(m_trigger_diamond_UVbkgCount);
92 tree.addBranch(m_trigger_diamond_XmuonCount);
93 tree.addBranch(m_trigger_diamond_UVmuonCount);
94 tree.addBranch(m_trigger_diamond_age);
95 tree.addBranch(m_trigger_diamond_mx);
96 tree.addBranch(m_trigger_diamond_my);
97 tree.addBranch(m_trigger_diamond_Uavg);
98 tree.addBranch(m_trigger_diamond_Vavg);
99 tree.addBranch(m_trigger_diamond_mxl);
100 tree.addBranch(m_trigger_diamond_theta);
101 tree.addBranch(m_trigger_diamond_eta);
102 tree.addBranch(m_trigger_diamond_dtheta);
103 tree.addBranch(m_trigger_diamond_phi);
104 tree.addBranch(m_trigger_diamond_phiShf);
105 tree.addBranch(m_trigger_diamond_TP_phi_id);
106 tree.addBranch(m_trigger_diamond_TP_R_id);
107 tree.addBranch(m_trigger_diamond_TP_dTheta_id);
108 tree.addBranch(m_trigger_RZslopes);
109 tree.addBranch(m_trigger_trueEtaRange);
110 tree.addBranch(m_trigger_truePtRange);
111 tree.addBranch(m_trigger_VMM);
112 tree.addBranch(m_trigger_plane);
113 tree.addBranch(m_trigger_station);
114 tree.addBranch(m_trigger_strip);
115 tree.addBranch(m_trigger_slope);
116 tree.addBranch(m_trigger_trueThe);
117 tree.addBranch(m_trigger_truePhi);
118 tree.addBranch(m_trigger_trueDth);
119 tree.addBranch(m_trigger_trueEtaEnt);
120 tree.addBranch(m_trigger_trueTheEnt);
121 tree.addBranch(m_trigger_truePhiEnt);
122 tree.addBranch(m_trigger_trueEtaPos);
123 tree.addBranch(m_trigger_trueThePos);
124 tree.addBranch(m_trigger_truePhiPos);
125 return StatusCode::SUCCESS;
126 }
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 128 of file MMTriggerTool.cxx.

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

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/44]

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

Definition at line 76 of file MMTriggerTool.h.

76{};

◆ ATLAS_THREAD_SAFE [2/44]

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

Definition at line 77 of file MMTriggerTool.h.

77{};

◆ ATLAS_THREAD_SAFE [3/44]

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

Definition at line 78 of file MMTriggerTool.h.

78{};

◆ ATLAS_THREAD_SAFE [4/44]

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

Definition at line 79 of file MMTriggerTool.h.

79{};

◆ ATLAS_THREAD_SAFE [5/44]

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

Definition at line 80 of file MMTriggerTool.h.

80{};

◆ ATLAS_THREAD_SAFE [6/44]

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

Definition at line 81 of file MMTriggerTool.h.

81{};

◆ ATLAS_THREAD_SAFE [7/44]

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

Definition at line 82 of file MMTriggerTool.h.

82{};

◆ ATLAS_THREAD_SAFE [8/44]

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

Definition at line 83 of file MMTriggerTool.h.

83{};

◆ ATLAS_THREAD_SAFE [9/44]

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

Definition at line 84 of file MMTriggerTool.h.

84{};

◆ ATLAS_THREAD_SAFE [10/44]

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

Definition at line 85 of file MMTriggerTool.h.

85{};

◆ ATLAS_THREAD_SAFE [11/44]

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

Definition at line 86 of file MMTriggerTool.h.

86{};

◆ ATLAS_THREAD_SAFE [12/44]

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

Definition at line 87 of file MMTriggerTool.h.

87{};

◆ ATLAS_THREAD_SAFE [13/44]

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

Definition at line 88 of file MMTriggerTool.h.

88{};

◆ ATLAS_THREAD_SAFE [14/44]

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

Definition at line 89 of file MMTriggerTool.h.

89{};

◆ ATLAS_THREAD_SAFE [15/44]

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

Definition at line 90 of file MMTriggerTool.h.

90{};

◆ ATLAS_THREAD_SAFE [16/44]

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

Definition at line 91 of file MMTriggerTool.h.

91{};

◆ ATLAS_THREAD_SAFE [17/44]

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

Definition at line 92 of file MMTriggerTool.h.

92{};

◆ ATLAS_THREAD_SAFE [18/44]

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

Definition at line 93 of file MMTriggerTool.h.

93{};

◆ ATLAS_THREAD_SAFE [19/44]

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

Definition at line 94 of file MMTriggerTool.h.

94{};

◆ ATLAS_THREAD_SAFE [20/44]

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

Definition at line 95 of file MMTriggerTool.h.

95{};

◆ ATLAS_THREAD_SAFE [21/44]

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

Definition at line 96 of file MMTriggerTool.h.

96{};

◆ ATLAS_THREAD_SAFE [22/44]

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

Definition at line 97 of file MMTriggerTool.h.

97{};

◆ ATLAS_THREAD_SAFE [23/44]

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

Definition at line 98 of file MMTriggerTool.h.

98{};

◆ ATLAS_THREAD_SAFE [24/44]

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

Definition at line 99 of file MMTriggerTool.h.

99{};

◆ ATLAS_THREAD_SAFE [25/44]

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

Definition at line 100 of file MMTriggerTool.h.

100{};

◆ ATLAS_THREAD_SAFE [26/44]

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

Definition at line 101 of file MMTriggerTool.h.

101{};

◆ ATLAS_THREAD_SAFE [27/44]

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

Definition at line 102 of file MMTriggerTool.h.

102{};

◆ ATLAS_THREAD_SAFE [28/44]

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

Definition at line 103 of file MMTriggerTool.h.

103{};

◆ ATLAS_THREAD_SAFE [29/44]

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

Definition at line 104 of file MMTriggerTool.h.

104{};

◆ ATLAS_THREAD_SAFE [30/44]

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

Definition at line 105 of file MMTriggerTool.h.

105{};

◆ ATLAS_THREAD_SAFE [31/44]

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

Definition at line 106 of file MMTriggerTool.h.

106{};

◆ ATLAS_THREAD_SAFE [32/44]

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

Definition at line 107 of file MMTriggerTool.h.

107{};

◆ ATLAS_THREAD_SAFE [33/44]

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

Definition at line 108 of file MMTriggerTool.h.

108{};

◆ ATLAS_THREAD_SAFE [34/44]

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

Definition at line 109 of file MMTriggerTool.h.

109{};

◆ ATLAS_THREAD_SAFE [35/44]

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

Definition at line 110 of file MMTriggerTool.h.

110{};

◆ ATLAS_THREAD_SAFE [36/44]

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

Definition at line 111 of file MMTriggerTool.h.

111{};

◆ ATLAS_THREAD_SAFE [37/44]

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

Definition at line 112 of file MMTriggerTool.h.

112{};

◆ ATLAS_THREAD_SAFE [38/44]

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

Definition at line 113 of file MMTriggerTool.h.

113{};

◆ ATLAS_THREAD_SAFE [39/44]

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

Definition at line 114 of file MMTriggerTool.h.

114{};

◆ ATLAS_THREAD_SAFE [40/44]

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

Definition at line 115 of file MMTriggerTool.h.

115{};

◆ ATLAS_THREAD_SAFE [41/44]

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

Definition at line 116 of file MMTriggerTool.h.

116{};

◆ ATLAS_THREAD_SAFE [42/44]

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

Definition at line 117 of file MMTriggerTool.h.

117{};

◆ ATLAS_THREAD_SAFE [43/44]

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

Definition at line 118 of file MMTriggerTool.h.

118{};

◆ ATLAS_THREAD_SAFE [44/44]

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

Definition at line 119 of file MMTriggerTool.h.

119{};

◆ 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