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

#include <MMTriggerTool.h>

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

Public Member Functions

 MMTriggerTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~MMTriggerTool ()=default
 
virtual StatusCode initialize ()
 
virtual void handle (const Incident &inc)
 
StatusCode runTrigger (const EventContext &ctx, Muon::NSW_TrigRawDataContainer *rdo, const bool do_MMDiamonds) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode book_branches ()
 book the branches More...
 
void clear_ntuple_variables ()
 clear the variables used in the analysis ntuple More...
 
void fillNtuple (const histogramDigitVariables &histDigVars) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

ServiceHandle< IIncidentSvc > m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
 Athena/Gaudi incident Service. More...
 
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"}
 
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< bool > m_trapShape {this, "TrapezoidalShape", true, "Consider the quadruplet as a trapezoid"}
 
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::shared_ptr< MMT_Parameters > m_par_large
 
std::shared_ptr< MMT_Parameters > m_par_small
 
const MuonGM::MuonDetectorManager * m_detManager
 MuonDetectorManager. More...
 
const MmIdHelper * m_MmIdHelper
 MM offline Id helper. More...
 
TTree *m_tree ATLAS_THREAD_SAFE {nullptr}
 ntuple for analysis More...
 
std::vector< unsigned int > *m_trigger_diamond_ntrig ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_diamond_bc ATLAS_THREAD_SAFE {nullptr}
 
std::vector< char > *m_trigger_diamond_sector ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_diamond_stationPhi ATLAS_THREAD_SAFE {nullptr}
 
std::vector< unsigned int > *m_trigger_diamond_totalCount ATLAS_THREAD_SAFE {nullptr}
 
std::vector< unsigned int > *m_trigger_diamond_realCount ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_diamond_iX ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_diamond_iU ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_diamond_iV ATLAS_THREAD_SAFE {nullptr}
 
std::vector< unsigned int > *m_trigger_diamond_XbkgCount ATLAS_THREAD_SAFE {nullptr}
 
std::vector< unsigned int > *m_trigger_diamond_UVbkgCount ATLAS_THREAD_SAFE {nullptr}
 
std::vector< unsigned int > *m_trigger_diamond_XmuonCount ATLAS_THREAD_SAFE {nullptr}
 
std::vector< unsigned int > *m_trigger_diamond_UVmuonCount ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_diamond_age ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_mx ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_my ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_Uavg ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_Vavg ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_mxl ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_theta ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_eta ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_dtheta ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_phi ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_diamond_phiShf ATLAS_THREAD_SAFE {nullptr}
 
std::vector< uint8_t > *m_trigger_diamond_TP_phi_id ATLAS_THREAD_SAFE {nullptr}
 
std::vector< uint8_t > *m_trigger_diamond_TP_R_id ATLAS_THREAD_SAFE {nullptr}
 
std::vector< uint8_t > *m_trigger_diamond_TP_dTheta_id ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_RZslopes ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_trueEtaRange ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_truePtRange ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_VMM ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_plane ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_station ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_trigger_strip ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_slope ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_trueThe ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_truePhi ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_trueDth ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_trueEtaEnt ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_trueTheEnt ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_truePhiEnt ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_trueEtaPos ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_trueThePos ATLAS_THREAD_SAFE {nullptr}
 
std::vector< double > *m_trigger_truePhiPos ATLAS_THREAD_SAFE {nullptr}
 
std::vector< std::string > *m_NSWMM_dig_stationName ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_NSWMM_dig_stationEta ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_NSWMM_dig_stationPhi ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_NSWMM_dig_multiplet ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_NSWMM_dig_gas_gap ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_NSWMM_dig_channel ATLAS_THREAD_SAFE {nullptr}
 
std::vector< std::vector< float > > *m_NSWMM_dig_time ATLAS_THREAD_SAFE {nullptr}
 
std::vector< std::vector< float > > *m_NSWMM_dig_charge ATLAS_THREAD_SAFE {nullptr}
 
std::vector< std::vector< int > > *m_NSWMM_dig_stripPosition ATLAS_THREAD_SAFE {nullptr}
 
std::vector< std::vector< double > > *m_NSWMM_dig_stripLposX ATLAS_THREAD_SAFE {nullptr}
 
std::vector< std::vector< double > > *m_NSWMM_dig_stripLposY ATLAS_THREAD_SAFE {nullptr}
 
std::vector< std::vector< double > > *m_NSWMM_dig_stripGposX ATLAS_THREAD_SAFE {nullptr}
 
std::vector< std::vector< double > > *m_NSWMM_dig_stripGposY ATLAS_THREAD_SAFE {nullptr}
 
std::vector< std::vector< double > > *m_NSWMM_dig_stripGposZ ATLAS_THREAD_SAFE {nullptr}
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 36 of file MMTriggerTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MMTriggerTool()

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

Definition at line 11 of file MMTriggerTool.cxx.

11  :
12  AthAlgTool(type,name,parent),
13  m_detManager(nullptr),
14  m_MmIdHelper(nullptr),
15  m_tree(nullptr)
16  {
17  declareInterface<NSWL1::IMMTriggerTool>(this);
18  }

◆ ~MMTriggerTool()

virtual NSWL1::MMTriggerTool::~MMTriggerTool ( )
virtualdefault

Member Function Documentation

◆ book_branches()

StatusCode NSWL1::MMTriggerTool::book_branches ( )
private

book the branches

Definition at line 27 of file MMTriggerToolTree.cxx.

27  {
28  m_trigger_diamond_ntrig = new std::vector<unsigned int>();
29  m_trigger_diamond_bc = new std::vector<int>();
30  m_trigger_diamond_sector = new std::vector<char>();
31  m_trigger_diamond_stationPhi = new std::vector<int>();
32  m_trigger_diamond_totalCount = new std::vector<unsigned int>();
33  m_trigger_diamond_realCount = new std::vector<unsigned int>();
34  m_trigger_diamond_XbkgCount = new std::vector<unsigned int>();
35  m_trigger_diamond_UVbkgCount = new std::vector<unsigned int>();
36  m_trigger_diamond_XmuonCount = new std::vector<unsigned int>();
37  m_trigger_diamond_UVmuonCount = new std::vector<unsigned int>();
38  m_trigger_diamond_iX = new std::vector<int>();
39  m_trigger_diamond_iU = new std::vector<int>();
40  m_trigger_diamond_iV = new std::vector<int>();
41  m_trigger_diamond_age = new std::vector<int>();
42  m_trigger_diamond_mx = new std::vector<double>();
43  m_trigger_diamond_my = new std::vector<double>();
44  m_trigger_diamond_Uavg = new std::vector<double>();
45  m_trigger_diamond_Vavg = new std::vector<double>();
46  m_trigger_diamond_mxl = new std::vector<double>();
47  m_trigger_diamond_theta = new std::vector<double>();
48  m_trigger_diamond_eta = new std::vector<double>();
49  m_trigger_diamond_dtheta = new std::vector<double>();
50  m_trigger_diamond_phi = new std::vector<double>();
51  m_trigger_diamond_phiShf = new std::vector<double>();
52  m_trigger_diamond_TP_phi_id = new std::vector<uint8_t>();
53  m_trigger_diamond_TP_R_id = new std::vector<uint8_t>();
54  m_trigger_diamond_TP_dTheta_id = new std::vector<uint8_t>();
55 
56  m_trigger_RZslopes = new std::vector<double>();
57  m_trigger_trueEtaRange = new std::vector<double>();
58  m_trigger_truePtRange = new std::vector<double>();
59 
60  m_trigger_VMM = new std::vector<int>();
61  m_trigger_plane = new std::vector<int>();
62  m_trigger_station = new std::vector<int>();
63  m_trigger_strip = new std::vector<int>();
64  m_trigger_slope = new std::vector<double>();
65  m_trigger_trueThe = new std::vector<double>();
66  m_trigger_truePhi = new std::vector<double>();
67  m_trigger_trueDth = new std::vector<double>();
68  m_trigger_trueEtaEnt = new std::vector<double>();
69  m_trigger_trueTheEnt = new std::vector<double>();
70  m_trigger_truePhiEnt = new std::vector<double>();
71  m_trigger_trueEtaPos = new std::vector<double>();
72  m_trigger_trueThePos = new std::vector<double>();
73  m_trigger_truePhiPos = new std::vector<double>();
74 
75  m_NSWMM_dig_stationName = new std::vector<std::string>();
76  m_NSWMM_dig_stationEta = new std::vector<int>();
77  m_NSWMM_dig_stationPhi = new std::vector<int>();
78  m_NSWMM_dig_multiplet = new std::vector<int>();
79  m_NSWMM_dig_gas_gap = new std::vector<int>();
80  m_NSWMM_dig_channel = new std::vector<int>();
81 
82  m_NSWMM_dig_time = new std::vector< std::vector<float> >;
83  m_NSWMM_dig_charge = new std::vector< std::vector<float> >;
84  m_NSWMM_dig_stripPosition = new std::vector< std::vector<int> >;
85  m_NSWMM_dig_stripLposX = new std::vector< std::vector<double> >;
86  m_NSWMM_dig_stripLposY = new std::vector< std::vector<double> >;
87  m_NSWMM_dig_stripGposX = new std::vector< std::vector<double> >;
88  m_NSWMM_dig_stripGposY = new std::vector< std::vector<double> >;
89  m_NSWMM_dig_stripGposZ = new std::vector< std::vector<double> >;
90 
91  if (m_tree) {
92  m_tree->Branch("MM_diamond_bc", &m_trigger_diamond_bc);
93  m_tree->Branch("MM_diamond_ntrig", &m_trigger_diamond_ntrig);
94  m_tree->Branch("MM_diamond_sector", &m_trigger_diamond_sector);
95  m_tree->Branch("MM_diamond_stationPhi", &m_trigger_diamond_stationPhi);
96  m_tree->Branch("MM_diamond_totalCount", &m_trigger_diamond_totalCount);
97  m_tree->Branch("MM_diamond_realCount", &m_trigger_diamond_realCount);
98  m_tree->Branch("MM_diamond_XbkgCount", &m_trigger_diamond_XbkgCount);
99  m_tree->Branch("MM_diamond_UVbkgCount", &m_trigger_diamond_UVbkgCount);
100  m_tree->Branch("MM_diamond_XmuonCount", &m_trigger_diamond_XmuonCount);
101  m_tree->Branch("MM_diamond_UVmuonCount", &m_trigger_diamond_UVmuonCount);
102  m_tree->Branch("MM_diamond_iX", &m_trigger_diamond_iX);
103  m_tree->Branch("MM_diamond_iU", &m_trigger_diamond_iU);
104  m_tree->Branch("MM_diamond_iV", &m_trigger_diamond_iV);
105  m_tree->Branch("MM_diamond_age", &m_trigger_diamond_age);
106  m_tree->Branch("MM_diamond_mx", &m_trigger_diamond_mx);
107  m_tree->Branch("MM_diamond_my", &m_trigger_diamond_my);
108  m_tree->Branch("MM_diamond_Uavg", &m_trigger_diamond_Uavg);
109  m_tree->Branch("MM_diamond_Vavg", &m_trigger_diamond_Vavg);
110  m_tree->Branch("MM_diamond_mxl", &m_trigger_diamond_mxl);
111  m_tree->Branch("MM_diamond_theta", &m_trigger_diamond_theta);
112  m_tree->Branch("MM_diamond_eta", &m_trigger_diamond_eta);
113  m_tree->Branch("MM_diamond_dtheta", &m_trigger_diamond_dtheta);
114  m_tree->Branch("MM_diamond_phi", &m_trigger_diamond_phi);
115  m_tree->Branch("MM_diamond_phiShf", &m_trigger_diamond_phiShf);
116  m_tree->Branch("MM_diamond_TP_phi_id", &m_trigger_diamond_TP_phi_id);
117  m_tree->Branch("MM_diamond_TP_R_id", &m_trigger_diamond_TP_R_id);
118  m_tree->Branch("MM_diamond_TP_dTheta_id", &m_trigger_diamond_TP_dTheta_id);
119 
120  m_tree->Branch("MM_RZslopes", &m_trigger_RZslopes);
121  m_tree->Branch("MM_trueEtaRange", &m_trigger_trueEtaRange);
122  m_tree->Branch("MM_truePtRange", &m_trigger_truePtRange);
123 
124  m_tree->Branch("MM_VMM", &m_trigger_VMM);
125  m_tree->Branch("MM_plane", &m_trigger_plane);
126  m_tree->Branch("MM_station", &m_trigger_station);
127  m_tree->Branch("MM_strip", &m_trigger_strip);
128  m_tree->Branch("MM_slope", &m_trigger_slope);
129  m_tree->Branch("MM_trueThe", &m_trigger_trueThe);
130  m_tree->Branch("MM_truePhi", &m_trigger_truePhi);
131  m_tree->Branch("MM_trueDth", &m_trigger_trueDth);
132  m_tree->Branch("MM_trueEtaEnt", &m_trigger_trueEtaEnt);
133  m_tree->Branch("MM_trueTheEnt", &m_trigger_trueTheEnt);
134  m_tree->Branch("MM_truePhiEnt", &m_trigger_truePhiEnt);
135  m_tree->Branch("MM_trueEtaPos", &m_trigger_trueEtaPos);
136  m_tree->Branch("MM_trueThePos", &m_trigger_trueThePos);
137  m_tree->Branch("MM_truePhiPos", &m_trigger_truePhiPos);
138 
139  m_tree->Branch("Digits_MM_stationName", &m_NSWMM_dig_stationName);
140  m_tree->Branch("Digits_MM_stationEta", &m_NSWMM_dig_stationEta);
141  m_tree->Branch("Digits_MM_stationPhi", &m_NSWMM_dig_stationPhi);
142  m_tree->Branch("Digits_MM_multiplet", &m_NSWMM_dig_multiplet);
143  m_tree->Branch("Digits_MM_gas_gap", &m_NSWMM_dig_gas_gap);
144  m_tree->Branch("Digits_MM_channel", &m_NSWMM_dig_channel);
145 
146  m_tree->Branch("Digits_MM_time", &m_NSWMM_dig_time);
147  m_tree->Branch("Digits_MM_charge", &m_NSWMM_dig_charge);
148  m_tree->Branch("Digits_MM_stripPosition", &m_NSWMM_dig_stripPosition);
149  m_tree->Branch("Digits_MM_stripLposX", &m_NSWMM_dig_stripLposX);
150  m_tree->Branch("Digits_MM_stripLposY", &m_NSWMM_dig_stripLposY);
151  m_tree->Branch("Digits_MM_stripGposX", &m_NSWMM_dig_stripGposX);
152  m_tree->Branch("Digits_MM_stripGposY", &m_NSWMM_dig_stripGposY);
153  m_tree->Branch("Digits_MM_stripGposZ", &m_NSWMM_dig_stripGposZ);
154  } else {
155  return StatusCode::FAILURE;
156  }
157 
158  return StatusCode::SUCCESS;
159  }

◆ clear_ntuple_variables()

void NSWL1::MMTriggerTool::clear_ntuple_variables ( )
private

clear the variables used in the analysis ntuple

Definition at line 161 of file MMTriggerToolTree.cxx.

161  {
162  //clear the ntuple variables
163  if(m_tree==0) return;
164 
165  m_trigger_diamond_bc->clear();
166  m_trigger_diamond_ntrig->clear();
167  m_trigger_diamond_sector->clear();
168  m_trigger_diamond_stationPhi->clear();
169  m_trigger_diamond_totalCount->clear();
170  m_trigger_diamond_realCount->clear();
171  m_trigger_diamond_XbkgCount->clear();
172  m_trigger_diamond_UVbkgCount->clear();
173  m_trigger_diamond_XmuonCount->clear();
174  m_trigger_diamond_UVmuonCount->clear();
175  m_trigger_diamond_iX->clear();
176  m_trigger_diamond_iU->clear();
177  m_trigger_diamond_iV->clear();
178  m_trigger_diamond_age->clear();
179  m_trigger_diamond_mx->clear();
180  m_trigger_diamond_my->clear();
181  m_trigger_diamond_Uavg->clear();
182  m_trigger_diamond_Vavg->clear();
183  m_trigger_diamond_mxl->clear();
184  m_trigger_diamond_theta->clear();
185  m_trigger_diamond_eta->clear();
186  m_trigger_diamond_dtheta->clear();
187  m_trigger_diamond_phi->clear();
188  m_trigger_diamond_phiShf->clear();
189  m_trigger_diamond_TP_phi_id->clear();
190  m_trigger_diamond_TP_R_id->clear();
191  m_trigger_diamond_TP_dTheta_id->clear();
192 
193  m_trigger_RZslopes->clear();
194  m_trigger_trueEtaRange->clear();
195  m_trigger_truePtRange->clear();
196 
197  m_trigger_VMM->clear();
198  m_trigger_plane->clear();
199  m_trigger_station->clear();
200  m_trigger_strip->clear();
201  m_trigger_slope->clear();
202  m_trigger_trueThe->clear();
203  m_trigger_truePhi->clear();
204  m_trigger_trueDth->clear();
205  m_trigger_trueEtaEnt->clear();
206  m_trigger_trueTheEnt->clear();
207  m_trigger_truePhiEnt->clear();
208  m_trigger_trueEtaPos->clear();
209  m_trigger_trueThePos->clear();
210  m_trigger_truePhiPos->clear();
211 
212  // information of the module down to the channel closest to the initial G4 hit
213  // size of vector is m_NSWMM_nDigits
214  m_NSWMM_dig_stationName->clear();
215  m_NSWMM_dig_stationEta->clear();
216  m_NSWMM_dig_stationPhi->clear();
217  m_NSWMM_dig_multiplet->clear();
218  m_NSWMM_dig_gas_gap->clear();
219  m_NSWMM_dig_channel->clear();
220 
221  // vectors of size m_NSWMM_nDigits that hold vectors in which an entry
222  // corresponds to a strip that was decided to be fired by the digit
223  // (information from VMM chip response emulation)
224  m_NSWMM_dig_time->clear();
225  m_NSWMM_dig_charge->clear();
226  m_NSWMM_dig_stripPosition->clear();
227  m_NSWMM_dig_stripLposX->clear();
228  m_NSWMM_dig_stripLposY->clear();
229  m_NSWMM_dig_stripGposX->clear();
230  m_NSWMM_dig_stripGposY->clear();
231  m_NSWMM_dig_stripGposZ->clear();
232  }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ fillNtuple()

void NSWL1::MMTriggerTool::fillNtuple ( const histogramDigitVariables &  histDigVars) const
private

Definition at line 233 of file MMTriggerToolTree.cxx.

233  {
234 
235  *m_NSWMM_dig_stationName = histDigVars.NSWMM_dig_stationName;
236  *m_NSWMM_dig_stationEta = histDigVars.NSWMM_dig_stationEta;
237  *m_NSWMM_dig_stationPhi = histDigVars.NSWMM_dig_stationPhi;
238  *m_NSWMM_dig_multiplet = histDigVars.NSWMM_dig_multiplet;
239  *m_NSWMM_dig_gas_gap = histDigVars.NSWMM_dig_gas_gap;
240  *m_NSWMM_dig_channel = histDigVars.NSWMM_dig_channel;
241  *m_NSWMM_dig_time = histDigVars.NSWMM_dig_time;
242  *m_NSWMM_dig_charge = histDigVars.NSWMM_dig_charge;
243  *m_NSWMM_dig_stripPosition = histDigVars.NSWMM_dig_stripPosition;
244  *m_NSWMM_dig_stripLposX = histDigVars.NSWMM_dig_stripLposX;
245  *m_NSWMM_dig_stripLposY = histDigVars.NSWMM_dig_stripLposY;
246  *m_NSWMM_dig_stripGposX = histDigVars.NSWMM_dig_stripGposX;
247  *m_NSWMM_dig_stripGposY = histDigVars.NSWMM_dig_stripGposY;
248  *m_NSWMM_dig_stripGposZ = histDigVars.NSWMM_dig_stripGposZ;
249  }

◆ handle()

void NSWL1::MMTriggerTool::handle ( const Incident &  inc)
virtual

Definition at line 20 of file MMTriggerToolTree.cxx.

20  {
21  if( inc.type()==IncidentType::BeginEvent ) {
22  ATH_MSG_DEBUG( "Handling..." );
23  this->clear_ntuple_variables();
24  }
25  }

◆ initialize()

StatusCode NSWL1::MMTriggerTool::initialize ( )
virtual

Definition at line 20 of file MMTriggerTool.cxx.

20  {
21 
22  ATH_MSG_DEBUG( "initializing -- " << name() );
23 
24  ATH_MSG_DEBUG( name() << " configuration:");
25  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_mmDigitContainer.name() << m_mmDigitContainer.value());
26  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_doNtuple.name() << ((m_doNtuple)? "[True]":"[False]")
27  << std::setfill(' ') << std::setiosflags(std::ios::right) );
28 
29  ATH_CHECK(m_keyMcEventCollection.initialize(m_isMC));
30  ATH_CHECK(m_keyMuonEntryLayer.initialize(m_isMC));
31  ATH_CHECK(m_keyMmDigitContainer.initialize());
32 
33  const IInterface* parent = this->parent();
34  const INamedInterface* pnamed = dynamic_cast<const INamedInterface*>(parent);
35  const std::string& algo_name = pnamed->name();
36  if ( m_doNtuple ) {
37  if (Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
38  ATH_MSG_ERROR("DoNtuple is not possible in multi-threaded mode");
39  return StatusCode::FAILURE;
40  }
41 
42  ATH_CHECK( m_incidentSvc.retrieve() );
43  m_incidentSvc->addListener(this,IncidentType::BeginEvent);
44 
45  if ( algo_name=="NSWL1Simulation" ) {
46  SmartIF<ITHistSvc> tHistSvc{service("THistSvc")};
47  ATH_CHECK( tHistSvc.isValid() );
48 
49  m_tree = nullptr;
50  std::string ntuple_name = algo_name+"Tree";
51  ATH_CHECK( tHistSvc->getTree(ntuple_name,m_tree) );
52  ATH_MSG_DEBUG("Analysis ntuple succesfully retrieved");
53  ATH_CHECK( this->book_branches() );
54  }
55  }
56 
57  // retrieve the MuonDetectormanager
58  ATH_CHECK( detStore()->retrieve( m_detManager ) );
59 
60  // retrieve the Mm offline Id helper
61  ATH_CHECK( detStore()->retrieve( m_MmIdHelper ) );
62 
63  m_par_large = std::make_shared<MMT_Parameters>("xxuvuvxx",'L', m_detManager);
64  m_par_small = std::make_shared<MMT_Parameters>("xxuvuvxx",'S', m_detManager);
65 
66  return StatusCode::SUCCESS;
67  }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

static const InterfaceID& NSWL1::IMMTriggerTool::interfaceID ( )
inlinestaticinherited

Definition at line 26 of file IMMTriggerTool.h.

26  {
27  static const InterfaceID IID_IMMTriggerTool("NSWL1::IMMTriggerTool", 1 ,0);
28  return IID_IMMTriggerTool;
29  }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ runTrigger()

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

Implements NSWL1::IMMTriggerTool.

Definition at line 69 of file MMTriggerTool.cxx.

69  {
70 
71  int event = ctx.eventID().event_number();
72  ATH_MSG_DEBUG("********************************************************* EVENT NUMBER = " << event);
73 
75  // //
76  // Load Variables From Containers into our Data Structures //
77  // //
79 
80  std::map<std::string, std::shared_ptr<MMT_Parameters> > pars;
81  pars["MML"] = m_par_large;
82  pars["MMS"] = m_par_small;
83  MMLoadVariables load = MMLoadVariables(m_detManager, m_MmIdHelper);
84 
85  std::map<std::pair<int, unsigned int>,std::vector<digitWrapper> > entries;
86  std::map<std::pair<int, unsigned int>,std::vector<hitData_entry> > Hits_Data_Set_Time;
87  std::map<std::pair<int, unsigned int>,evInf_entry> Event_Info;
88 
89  const McEventCollection* ptrMcEventCollection = nullptr;
90  const TrackRecordCollection* ptrMuonEntryLayer = nullptr;
91  if(m_isMC){
92  SG::ReadHandle<McEventCollection> readMcEventCollection( m_keyMcEventCollection, ctx );
93  if( !readMcEventCollection.isValid() ){
94  ATH_MSG_ERROR("Cannot retrieve McEventCollection");
95  return StatusCode::FAILURE;
96  }
97  if(m_doTruth) ptrMcEventCollection = readMcEventCollection.cptr();
98  SG::ReadHandle<TrackRecordCollection> readMuonEntryLayer( m_keyMuonEntryLayer, ctx );
99  if( !readMuonEntryLayer.isValid() ){
100  ATH_MSG_ERROR("Cannot retrieve MuonEntryLayer");
101  return StatusCode::FAILURE;
102  }
103  if(m_doTruth) ptrMuonEntryLayer = readMuonEntryLayer.cptr();
104  }
105 
106  SG::ReadHandle<MmDigitContainer> readMmDigitContainer( m_keyMmDigitContainer, ctx );
107  if( !readMmDigitContainer.isValid() ){
108  ATH_MSG_ERROR("Cannot retrieve MmDigitContainer");
109  return StatusCode::FAILURE;
110  }
111  histogramDigitVariables histDigVars;
112  ATH_CHECK( load.getMMDigitsInfo(ctx, ptrMcEventCollection, ptrMuonEntryLayer, readMmDigitContainer.cptr(), entries, Hits_Data_Set_Time, Event_Info, histDigVars) );
113  if (m_doNtuple) this->fillNtuple(histDigVars);
114 
115  if (entries.empty()) {
116  ATH_MSG_WARNING("No digits available for processing, exiting");
117  Hits_Data_Set_Time.clear();
118  Event_Info.clear();
119  return StatusCode::SUCCESS;
120  }
121 
122  std::unique_ptr<MMT_Diamond> diamond = std::make_unique<MMT_Diamond>(m_detManager);
123  if (do_MMDiamonds) {
124  diamond->setTrapezoidalShape(m_trapShape);
125  diamond->setXthreshold(m_diamXthreshold);
126  diamond->setUV(m_uv);
127  diamond->setUVthreshold(m_diamUVthreshold);
128  diamond->setRoadSize(m_diamRoadSize);
129  diamond->setRoadSizeUpX(m_diamOverlapEtaUp);
130  diamond->setRoadSizeDownX(m_diamOverlapEtaDown);
131  diamond->setRoadSizeUpUV(m_diamOverlapStereoUp);
132  diamond->setRoadSizeDownUV(m_diamOverlapStereoDown);
133  }
134 
135  // We need to extract truth info, if available
136  for (const auto &it : Event_Info) {
137  double trueta = -999., truphi = -999., trutheta = -999., trupt = -999., dt = -999., tpos = -999., ppos = -999., epos = -999., tent = -999., pent = -999., eent = -999.;
138  trutheta = it.second.theta_ip; // truth muon at the IP
139  truphi = it.second.phi_ip;
140  trueta = it.second.eta_ip;
141  trupt = it.second.pt;
142  tpos = it.second.theta_pos; // muEntry position
143  ppos = it.second.phi_pos;
144  epos = it.second.eta_pos;
145  tent = it.second.theta_ent; // muEntry momentum
146  pent = it.second.phi_ent;
147  eent = it.second.eta_ent;
148  dt = it.second.dtheta;
149  if (m_doNtuple) {
150  m_trigger_trueEtaRange->push_back(trueta);
151  m_trigger_truePtRange->push_back(trupt);
152  m_trigger_trueThe->push_back(trutheta);
153  m_trigger_truePhi->push_back(truphi);
154  m_trigger_trueDth->push_back(dt); // theta_pos-theta_ent
155  m_trigger_trueEtaPos->push_back(epos);
156  m_trigger_trueThePos->push_back(tpos);
157  m_trigger_truePhiPos->push_back(ppos);
158  m_trigger_trueEtaEnt->push_back(eent);
159  m_trigger_trueTheEnt->push_back(tent);
160  m_trigger_truePhiEnt->push_back(pent);
161  }
162  }
163 
164  unsigned int particles = entries.rbegin()->first.second +1, nskip=0;
165  for (unsigned int i=0; i<particles; i++) {
166  std::pair<int, unsigned int> pair_event (event,i);
167 
168  // Now let's switch to reco hits: firstly, extracting the station name we're working on...
169  std::string station = "-";
170  auto event_it = entries.find(pair_event);
171  station = event_it->second[0].stName; // Station name is taken from the first digit! In MMLoadVariables there's a check to ensure all digits belong to the same station
172 
173  // Secondly, extracting the Phi of the station we're working on...
174  int stationPhi = -999;
175  digitWrapper dW = event_it->second[0];
176  Identifier tmpID = dW.id();
177  stationPhi = m_MmIdHelper->stationPhi(tmpID);
178 
179  // Finally, let's start with hits
180  auto reco_it = Hits_Data_Set_Time.find(pair_event);
181  if (reco_it != Hits_Data_Set_Time.end()) {
182  if (reco_it->second.size() >= (diamond->getXthreshold()+diamond->getUVthreshold())) {
183  if (do_MMDiamonds) {
184  /*
185  * Filling hits for each event: a new class, MMT_Hit, is called in
186  * order to use both algorithms witghout interferences
187  */
188  diamond->createRoads_fillHits(i-nskip, reco_it->second, m_detManager, pars[station], stationPhi);
189  if (m_doNtuple) {
190  for(const auto &hit : reco_it->second) {
191  m_trigger_VMM->push_back(hit.VMM_chip);
192  m_trigger_plane->push_back(hit.plane);
193  m_trigger_station->push_back(hit.station_eta);
194  m_trigger_strip->push_back(hit.strip);
195  }
196  std::vector<double> slopes = diamond->getHitSlopes();
197  for (const auto &s : slopes) m_trigger_RZslopes->push_back(s);
198  slopes.clear();
199  }
200  diamond->resetSlopes();
201  /*
202  * Here we create roads with all MMT_Hit collected before (if any), then we save the results
203  */
204  diamond->findDiamonds(i-nskip, event);
205 
206  if (!diamond->getSlopeVector(i-nskip).empty()) {
207  if (m_doNtuple) {
208  m_trigger_diamond_ntrig->push_back(diamond->getSlopeVector(i-nskip).size());
209  for (const auto &slope : diamond->getSlopeVector(i-nskip)) {
210  m_trigger_diamond_sector->push_back(diamond->getDiamond(i-nskip).sector);
211  m_trigger_diamond_stationPhi->push_back(diamond->getDiamond(i-nskip).stationPhi);
212  m_trigger_diamond_bc->push_back(slope.BC);
213  m_trigger_diamond_totalCount->push_back(slope.totalCount);
214  m_trigger_diamond_realCount->push_back(slope.realCount);
215  m_trigger_diamond_XbkgCount->push_back(slope.xbkg);
216  m_trigger_diamond_UVbkgCount->push_back(slope.uvbkg);
217  m_trigger_diamond_XmuonCount->push_back(slope.xmuon);
218  m_trigger_diamond_UVmuonCount->push_back(slope.uvmuon);
219  m_trigger_diamond_iX->push_back(slope.iRoad);
220  m_trigger_diamond_iU->push_back(slope.iRoadu);
221  m_trigger_diamond_iV->push_back(slope.iRoadv);
222  m_trigger_diamond_age->push_back(slope.age);
223  m_trigger_diamond_mx->push_back(slope.mx);
224  m_trigger_diamond_my->push_back(slope.my);
225  m_trigger_diamond_Uavg->push_back(slope.uavg);
226  m_trigger_diamond_Vavg->push_back(slope.vavg);
227  m_trigger_diamond_mxl->push_back(slope.mxl);
228  m_trigger_diamond_theta->push_back(slope.theta);
229  m_trigger_diamond_eta->push_back(slope.eta);
230  m_trigger_diamond_dtheta->push_back(slope.dtheta);
231  m_trigger_diamond_phi->push_back(slope.phi);
232  m_trigger_diamond_phiShf->push_back(slope.phiShf);
233  }
234  }
235 
236  // MM RDO filling below
237  std::vector<int> slopeBC;
238  for (const auto &slope : diamond->getSlopeVector(i-nskip)) slopeBC.push_back(slope.BC);
239  std::sort(slopeBC.begin(), slopeBC.end());
240  slopeBC.erase( std::unique(slopeBC.begin(), slopeBC.end()), slopeBC.end() );
241  for (const auto &bc : slopeBC) {
242  Muon::NSW_TrigRawData* trigRawData = new Muon::NSW_TrigRawData(diamond->getDiamond(i-nskip).stationPhi, diamond->getDiamond(i-nskip).side, bc);
243 
244  for (const auto &slope : diamond->getSlopeVector(i-nskip)) {
245  if (bc == slope.BC) {
246  Muon::NSW_TrigRawDataSegment* trigRawDataSegment = new Muon::NSW_TrigRawDataSegment();
247 
248  // Phi-id - here use local phi (not phiShf)
249  uint8_t phi_id = 0;
250  if (slope.phi > m_phiMax || slope.phi < m_phiMin) trigRawDataSegment->setPhiIndex(phi_id);
251  else {
252  uint8_t nPhi = (1<<m_phiBits) -2; // To accomodate the new phi-id encoding prescription around 0
253  float phiSteps = (m_phiMax - m_phiMin)/nPhi;
254  for (uint8_t i=0; i<nPhi; i++) {
255  if ((slope.phi) < (m_phiMin+i*phiSteps)) {
256  phi_id = i;
257  break;
258  }
259  }
260  trigRawDataSegment->setPhiIndex(phi_id);
261  }
262  if (m_doNtuple) m_trigger_diamond_TP_phi_id->push_back(phi_id);
263 
264  // R-id
265  double extrapolatedR = 7824.46*std::abs(std::tan(slope.theta)); // The Z plane is a fixed value, taken from SL-TP documentation
266  uint8_t R_id = 0;
267  if (extrapolatedR > m_rMax || extrapolatedR < m_rMin) trigRawDataSegment->setRIndex(R_id);
268  else {
269  uint8_t nR = (1<<m_rBits) -1;
270  float Rsteps = (m_rMax - m_rMin)/nR;
271  for (uint8_t j=0; j<nR; j++) {
272  if (extrapolatedR < (m_rMin+j*Rsteps)) {
273  R_id = j;
274  break;
275  }
276  }
277  trigRawDataSegment->setRIndex(R_id);
278  }
279  if (m_doNtuple) m_trigger_diamond_TP_R_id->push_back(R_id);
280 
281  // DeltaTheta-id
282  uint8_t dTheta_id = 0;
283  if (slope.dtheta > m_dThetaMax || slope.dtheta < m_dThetaMin) trigRawDataSegment->setDeltaTheta(dTheta_id);
284  else {
285  uint8_t ndTheta = (1<<m_dThetaBits) -1;
286  float dThetaSteps = (m_dThetaMax - m_dThetaMin)/ndTheta;
287  for (uint8_t k=0; k<ndTheta; k++) {
288  if ((slope.dtheta) < (m_dThetaMin+k*dThetaSteps)) {
289  dTheta_id = k;
290  break;
291  }
292  }
293  trigRawDataSegment->setDeltaTheta(dTheta_id);
294  }
295  if (m_doNtuple) m_trigger_diamond_TP_dTheta_id->push_back(dTheta_id);
296 
297  // Low R-resolution bit
298  trigRawDataSegment->setLowRes(slope.lowRes);
299 
300  trigRawData->push_back(trigRawDataSegment);
301  }
302  }
303  rdo->push_back(trigRawData);
304  }
305  ATH_MSG_DEBUG("Filled MM RDO container now having size: " << rdo->size() << ". Clearing event information!");
306  } else ATH_MSG_DEBUG("No output slopes to store");
307  } else ATH_MSG_WARNING("No algorithm defined, exiting gracefully");
308  } else {
309  ATH_MSG_DEBUG( "Available hits are " << reco_it->second.size() << ", less than X+UV threshold, skipping" );
310  nskip++;
311  }
312  } else {
313  ATH_MSG_WARNING( "Empty hit map, skipping" );
314  nskip++;
315  }
316  } // Main particle loop
317  entries.clear();
318  Hits_Data_Set_Time.clear();
319  Event_Info.clear();
320  if (do_MMDiamonds) diamond->clearEvent();
321 
322  return StatusCode::SUCCESS;
323  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/59]

TTree* m_tree NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

ntuple for analysis

Definition at line 101 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [2/59]

std::vector<unsigned int>* m_trigger_diamond_ntrig NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 102 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [3/59]

std::vector<int>* m_trigger_diamond_bc NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 103 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [4/59]

std::vector<char>* m_trigger_diamond_sector NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 104 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [5/59]

std::vector<int>* m_trigger_diamond_stationPhi NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 105 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [6/59]

std::vector<unsigned int>* m_trigger_diamond_totalCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 106 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [7/59]

std::vector<unsigned int>* m_trigger_diamond_realCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 107 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [8/59]

std::vector<int>* m_trigger_diamond_iX NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 108 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [9/59]

std::vector<int>* m_trigger_diamond_iU NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 109 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [10/59]

std::vector<int>* m_trigger_diamond_iV NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 110 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [11/59]

std::vector<unsigned int>* m_trigger_diamond_XbkgCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 111 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [12/59]

std::vector<unsigned int>* m_trigger_diamond_UVbkgCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 112 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [13/59]

std::vector<unsigned int>* m_trigger_diamond_XmuonCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 113 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [14/59]

std::vector<unsigned int>* m_trigger_diamond_UVmuonCount NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 114 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [15/59]

std::vector<int>* m_trigger_diamond_age NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 115 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [16/59]

std::vector<double>* m_trigger_diamond_mx NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 116 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [17/59]

std::vector<double>* m_trigger_diamond_my NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 117 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [18/59]

std::vector<double>* m_trigger_diamond_Uavg NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 118 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [19/59]

std::vector<double>* m_trigger_diamond_Vavg NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 119 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [20/59]

std::vector<double>* m_trigger_diamond_mxl NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 120 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [21/59]

std::vector<double>* m_trigger_diamond_theta NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 121 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [22/59]

std::vector<double>* m_trigger_diamond_eta NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 122 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [23/59]

std::vector<double>* m_trigger_diamond_dtheta NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 123 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [24/59]

std::vector<double>* m_trigger_diamond_phi NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 124 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [25/59]

std::vector<double>* m_trigger_diamond_phiShf NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 125 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [26/59]

std::vector<uint8_t>* m_trigger_diamond_TP_phi_id NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 126 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [27/59]

std::vector<uint8_t>* m_trigger_diamond_TP_R_id NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 127 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [28/59]

std::vector<uint8_t>* m_trigger_diamond_TP_dTheta_id NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 128 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [29/59]

std::vector<double>* m_trigger_RZslopes NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 130 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [30/59]

std::vector<double>* m_trigger_trueEtaRange NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 131 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [31/59]

std::vector<double>* m_trigger_truePtRange NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 132 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [32/59]

std::vector<int>* m_trigger_VMM NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 134 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [33/59]

std::vector<int>* m_trigger_plane NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 135 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [34/59]

std::vector<int>* m_trigger_station NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 136 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [35/59]

std::vector<int>* m_trigger_strip NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 137 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [36/59]

std::vector<double>* m_trigger_slope NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 138 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [37/59]

std::vector<double>* m_trigger_trueThe NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 139 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [38/59]

std::vector<double>* m_trigger_truePhi NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 140 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [39/59]

std::vector<double>* m_trigger_trueDth NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 141 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [40/59]

std::vector<double>* m_trigger_trueEtaEnt NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 142 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [41/59]

std::vector<double>* m_trigger_trueTheEnt NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 143 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [42/59]

std::vector<double>* m_trigger_truePhiEnt NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 144 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [43/59]

std::vector<double>* m_trigger_trueEtaPos NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 145 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [44/59]

std::vector<double>* m_trigger_trueThePos NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 146 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [45/59]

std::vector<double>* m_trigger_truePhiPos NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 147 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [46/59]

std::vector<std::string>* m_NSWMM_dig_stationName NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 149 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [47/59]

std::vector<int>* m_NSWMM_dig_stationEta NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 150 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [48/59]

std::vector<int>* m_NSWMM_dig_stationPhi NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 151 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [49/59]

std::vector<int>* m_NSWMM_dig_multiplet NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 152 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [50/59]

std::vector<int>* m_NSWMM_dig_gas_gap NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 153 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [51/59]

std::vector<int>* m_NSWMM_dig_channel NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 154 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [52/59]

std::vector< std::vector<float> >* m_NSWMM_dig_time NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 156 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [53/59]

std::vector< std::vector<float> >* m_NSWMM_dig_charge NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 157 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [54/59]

std::vector< std::vector<int> >* m_NSWMM_dig_stripPosition NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 158 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [55/59]

std::vector< std::vector<double> >* m_NSWMM_dig_stripLposX NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 159 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [56/59]

std::vector< std::vector<double> >* m_NSWMM_dig_stripLposY NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 160 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [57/59]

std::vector< std::vector<double> >* m_NSWMM_dig_stripGposX NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 161 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [58/59]

std::vector< std::vector<double> >* m_NSWMM_dig_stripGposY NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 162 of file MMTriggerTool.h.

◆ ATLAS_THREAD_SAFE [59/59]

std::vector< std::vector<double> >* m_NSWMM_dig_stripGposZ NSWL1::MMTriggerTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 163 of file MMTriggerTool.h.

◆ m_detManager

const MuonGM::MuonDetectorManager* NSWL1::MMTriggerTool::m_detManager
private

MuonDetectorManager.

Definition at line 90 of file MMTriggerTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.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 71 of file MMTriggerTool.h.

◆ m_diamOverlapEtaUp

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

Definition at line 70 of file MMTriggerTool.h.

◆ m_diamOverlapStereoDown

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

Definition at line 73 of file MMTriggerTool.h.

◆ m_diamOverlapStereoUp

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

Definition at line 72 of file MMTriggerTool.h.

◆ m_diamRoadSize

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

Definition at line 66 of file MMTriggerTool.h.

◆ m_diamUVthreshold

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

Definition at line 69 of file MMTriggerTool.h.

◆ m_diamXthreshold

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

Definition at line 68 of file MMTriggerTool.h.

◆ m_doNtuple

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

Definition at line 77 of file MMTriggerTool.h.

◆ m_doTruth

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

Definition at line 62 of file MMTriggerTool.h.

◆ m_dThetaBits

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

Definition at line 86 of file MMTriggerTool.h.

◆ m_dThetaMax

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

Definition at line 85 of file MMTriggerTool.h.

◆ m_dThetaMin

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

Definition at line 84 of file MMTriggerTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_incidentSvc

ServiceHandle< IIncidentSvc > NSWL1::MMTriggerTool::m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
private

Athena/Gaudi incident Service.

Definition at line 55 of file MMTriggerTool.h.

◆ m_isMC

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

Definition at line 61 of file MMTriggerTool.h.

◆ m_keyMcEventCollection

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

Definition at line 58 of file MMTriggerTool.h.

◆ m_keyMmDigitContainer

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

Definition at line 60 of file MMTriggerTool.h.

◆ m_keyMuonEntryLayer

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

Definition at line 59 of file MMTriggerTool.h.

◆ m_mmDigitContainer

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

Definition at line 76 of file MMTriggerTool.h.

◆ m_MmIdHelper

const MmIdHelper* NSWL1::MMTriggerTool::m_MmIdHelper
private

MM offline Id helper.

Definition at line 91 of file MMTriggerTool.h.

◆ m_par_large

std::shared_ptr<MMT_Parameters> NSWL1::MMTriggerTool::m_par_large
private

Definition at line 88 of file MMTriggerTool.h.

◆ m_par_small

std::shared_ptr<MMT_Parameters> NSWL1::MMTriggerTool::m_par_small
private

Definition at line 89 of file MMTriggerTool.h.

◆ m_phiBits

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

Definition at line 80 of file MMTriggerTool.h.

◆ m_phiMax

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

Definition at line 79 of file MMTriggerTool.h.

◆ m_phiMin

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

Definition at line 78 of file MMTriggerTool.h.

◆ m_rBits

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

Definition at line 83 of file MMTriggerTool.h.

◆ m_rMax

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

Definition at line 82 of file MMTriggerTool.h.

◆ m_rMin

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

Definition at line 81 of file MMTriggerTool.h.

◆ m_trapShape

Gaudi::Property<bool> NSWL1::MMTriggerTool::m_trapShape {this, "TrapezoidalShape", true, "Consider the quadruplet as a trapezoid"}
private

Definition at line 65 of file MMTriggerTool.h.

◆ m_uv

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

Definition at line 67 of file MMTriggerTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
NSWL1::MMTriggerTool::m_keyMmDigitContainer
SG::ReadHandleKey< MmDigitContainer > m_keyMmDigitContainer
Definition: MMTriggerTool.h:60
MMT_Diamond::getSlopeVector
std::vector< slope_t > getSlopeVector(const unsigned int iterator) const
Definition: MMT_Diamond.h:65
NSWL1::MMTriggerTool::m_diamXthreshold
Gaudi::Property< int > m_diamXthreshold
Definition: MMTriggerTool.h:68
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
NSWL1::MMTriggerTool::m_diamOverlapStereoDown
Gaudi::Property< int > m_diamOverlapStereoDown
Definition: MMTriggerTool.h:73
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
NSWL1::MMTriggerTool::m_diamOverlapEtaUp
Gaudi::Property< int > m_diamOverlapEtaUp
Definition: MMTriggerTool.h:70
histogramDigitVariables::NSWMM_dig_stripLposY
std::vector< std::vector< double > > NSWMM_dig_stripLposY
Definition: MMLoadVariables.h:42
MMT_Diamond::setUV
void setUV(bool flag)
Definition: MMT_Diamond.h:88
MMT_Diamond::resetSlopes
void resetSlopes()
Definition: MMT_Diamond.cxx:278
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
NSWL1::MMTriggerTool::m_dThetaMin
Gaudi::Property< float > m_dThetaMin
Definition: MMTriggerTool.h:84
SG::ReadHandle< McEventCollection >
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
NSWL1::MMTriggerTool::m_phiMax
Gaudi::Property< float > m_phiMax
Definition: MMTriggerTool.h:79
histogramDigitVariables::NSWMM_dig_channel
std::vector< int > NSWMM_dig_channel
Definition: MMLoadVariables.h:36
AtlasHitsVector
Definition: AtlasHitsVector.h:33
Muon::NSW_TrigRawData
Definition: NSW_TrigRawData.h:15
skel.it
it
Definition: skel.GENtoEVGEN.py:396
histogramDigitVariables::NSWMM_dig_multiplet
std::vector< int > NSWMM_dig_multiplet
Definition: MMLoadVariables.h:34
NSWL1::MMTriggerTool::m_diamOverlapEtaDown
Gaudi::Property< int > m_diamOverlapEtaDown
Definition: MMTriggerTool.h:71
NSWL1::MMTriggerTool::clear_ntuple_variables
void clear_ntuple_variables()
clear the variables used in the analysis ntuple
Definition: MMTriggerToolTree.cxx:161
histogramDigitVariables::NSWMM_dig_stripGposX
std::vector< std::vector< double > > NSWMM_dig_stripGposX
Definition: MMLoadVariables.h:43
NSWL1::MMTriggerTool::book_branches
StatusCode book_branches()
book the branches
Definition: MMTriggerToolTree.cxx:27
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
Muon::NSW_TrigRawDataSegment::setDeltaTheta
void setDeltaTheta(uint8_t deltaTheta)
Definition: NSW_TrigRawDataSegment.h:36
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
MMT_Diamond::setRoadSizeUpX
void setRoadSizeUpX(int sizeUp)
Definition: MMT_Diamond.h:77
MMLoadVariables
Definition: MMLoadVariables.h:49
NSWL1::MMTriggerTool::m_rMax
Gaudi::Property< float > m_rMax
Definition: MMTriggerTool.h:82
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
MMT_Diamond::getDiamond
diamond_t getDiamond(const unsigned int iterator) const
Definition: MMT_Diamond.h:62
TrigVSI::AlgConsts::nPhi
constexpr int nPhi
Default bin number of phi for vertex map.
Definition: Trigger/TrigTools/TrigVrtSecInclusive/TrigVrtSecInclusive/Constants.h:27
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
histogramDigitVariables::NSWMM_dig_stripGposY
std::vector< std::vector< double > > NSWMM_dig_stripGposY
Definition: MMLoadVariables.h:44
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
histogramDigitVariables::NSWMM_dig_stationEta
std::vector< int > NSWMM_dig_stationEta
Definition: MMLoadVariables.h:32
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
MMT_Diamond::createRoads_fillHits
void createRoads_fillHits(const unsigned int iterator, std::vector< hitData_entry > &hitDatas, const MuonGM::MuonDetectorManager *detManager, std::shared_ptr< MMT_Parameters > par, const int phi)
Definition: MMT_Diamond.cxx:22
Muon::NSW_TrigRawDataSegment::setRIndex
void setRIndex(uint8_t rIndex)
Definition: NSW_TrigRawDataSegment.h:38
histogramDigitVariables::NSWMM_dig_stripPosition
std::vector< std::vector< int > > NSWMM_dig_stripPosition
Definition: MMLoadVariables.h:40
NSWL1::MMTriggerTool::m_uv
Gaudi::Property< bool > m_uv
Definition: MMTriggerTool.h:67
Muon::NSW_TrigRawDataSegment::setPhiIndex
void setPhiIndex(uint8_t phiIndex)
Definition: NSW_TrigRawDataSegment.h:37
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
NSWL1::MMTriggerTool::m_mmDigitContainer
Gaudi::Property< std::string > m_mmDigitContainer
Definition: MMTriggerTool.h:76
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
NSWL1::MMTriggerTool::m_MmIdHelper
const MmIdHelper * m_MmIdHelper
MM offline Id helper.
Definition: MMTriggerTool.h:91
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
diamond_t::stationPhi
int stationPhi
Definition: MMT_Diamond.h:47
lumiFormat.i
int i
Definition: lumiFormat.py:85
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CaloNoise_fillDB.dt
dt
Definition: CaloNoise_fillDB.py:58
NSWL1::MMTriggerTool::m_detManager
const MuonGM::MuonDetectorManager * m_detManager
MuonDetectorManager.
Definition: MMTriggerTool.h:90
test_pyathena.parent
parent
Definition: test_pyathena.py:15
MMT_Diamond::setTrapezoidalShape
void setTrapezoidalShape(bool flag)
Definition: MMT_Diamond.h:69
MMT_Diamond::getXthreshold
unsigned int getXthreshold() const
Definition: MMT_Diamond.h:85
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MMT_Diamond::setRoadSizeDownUV
void setRoadSizeDownUV(int sizeDownUV)
Definition: MMT_Diamond.h:83
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
NSWL1::MMTriggerTool::m_keyMuonEntryLayer
SG::ReadHandleKey< TrackRecordCollection > m_keyMuonEntryLayer
Definition: MMTriggerTool.h:59
evInf_entry
Definition: MMT_struct.h:59
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
histogramDigitVariables::NSWMM_dig_stationName
std::vector< std::string > NSWMM_dig_stationName
Definition: MMLoadVariables.h:31
histogramDigitVariables::NSWMM_dig_stationPhi
std::vector< int > NSWMM_dig_stationPhi
Definition: MMLoadVariables.h:33
McEventCollection
This defines the McEventCollection, which is really just an ObjectVector of McEvent objects.
Definition: McEventCollection.h:33
NSWL1::MMTriggerTool::fillNtuple
void fillNtuple(const histogramDigitVariables &histDigVars) const
Definition: MMTriggerToolTree.cxx:233
MMT_Diamond::setRoadSizeUpUV
void setRoadSizeUpUV(int sizeUpUV)
Definition: MMT_Diamond.h:81
Muon::NSW_TrigRawDataSegment
Definition: NSW_TrigRawDataSegment.h:15
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
MuonIdHelper::stationPhi
int stationPhi(const Identifier &id) const
Definition: MuonIdHelper.cxx:810
MMT_Diamond::setXthreshold
void setXthreshold(int threshold)
Definition: MMT_Diamond.h:86
MMT_Diamond::findDiamonds
void findDiamonds(const unsigned int iterator, const int event)
Definition: MMT_Diamond.cxx:110
MMT_Diamond::clearEvent
void clearEvent()
Definition: MMT_Diamond.cxx:11
NSWL1::MMTriggerTool::m_trapShape
Gaudi::Property< bool > m_trapShape
Definition: MMTriggerTool.h:65
NSWL1::MMTriggerTool::m_diamRoadSize
Gaudi::Property< int > m_diamRoadSize
Definition: MMTriggerTool.h:66
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
diamond_t::sector
char sector
Definition: MMT_Diamond.h:45
NSWL1::MMTriggerTool::m_dThetaMax
Gaudi::Property< float > m_dThetaMax
Definition: MMTriggerTool.h:85
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
mc.nskip
nskip
Definition: mc.PhPy8EG_Hto4l_NNLOPS_nnlo_30_ggH125_ZZ4l.py:41
histogramDigitVariables::NSWMM_dig_gas_gap
std::vector< int > NSWMM_dig_gas_gap
Definition: MMLoadVariables.h:35
MMT_Diamond::getUVthreshold
unsigned int getUVthreshold() const
Definition: MMT_Diamond.h:89
NSWL1::MMTriggerTool::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Athena/Gaudi incident Service.
Definition: MMTriggerTool.h:55
NSWL1::MMTriggerTool::m_keyMcEventCollection
SG::ReadHandleKey< McEventCollection > m_keyMcEventCollection
Definition: MMTriggerTool.h:58
NSWL1::MMTriggerTool::m_par_small
std::shared_ptr< MMT_Parameters > m_par_small
Definition: MMTriggerTool.h:89
histogramDigitVariables
Definition: MMLoadVariables.h:30
diamond_t::side
char side
Definition: MMT_Diamond.h:46
histogramDigitVariables::NSWMM_dig_stripGposZ
std::vector< std::vector< double > > NSWMM_dig_stripGposZ
Definition: MMLoadVariables.h:45
MMT_Diamond::setUVthreshold
void setUVthreshold(int threshold)
Definition: MMT_Diamond.h:90
a
TList * a
Definition: liststreamerinfos.cxx:10
h
Muon::NSW_TrigRawDataSegment::setLowRes
void setLowRes(bool lowRes)
Definition: NSW_TrigRawDataSegment.h:41
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
jobOptions.epos
epos
Definition: jobOptions.crmc.py:50
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
histogramDigitVariables::NSWMM_dig_stripLposX
std::vector< std::vector< double > > NSWMM_dig_stripLposX
Definition: MMLoadVariables.h:41
LArG4FSStartPointFilter.particles
list particles
Definition: LArG4FSStartPointFilter.py:84
MMT_Diamond::getHitSlopes
const std::vector< double > & getHitSlopes() const
Definition: MMT_Diamond.h:63
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
entries
double entries
Definition: listroot.cxx:49
MMT_Diamond::setRoadSize
void setRoadSize(int size)
Definition: MMT_Diamond.h:75
histogramDigitVariables::NSWMM_dig_charge
std::vector< std::vector< float > > NSWMM_dig_charge
Definition: MMLoadVariables.h:39
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
NSWL1::MMTriggerTool::m_isMC
Gaudi::Property< bool > m_isMC
Definition: MMTriggerTool.h:61
NSWL1::MMTriggerTool::m_diamUVthreshold
Gaudi::Property< int > m_diamUVthreshold
Definition: MMTriggerTool.h:69
histogramDigitVariables::NSWMM_dig_time
std::vector< std::vector< float > > NSWMM_dig_time
Definition: MMLoadVariables.h:38
NSWL1::MMTriggerTool::m_diamOverlapStereoUp
Gaudi::Property< int > m_diamOverlapStereoUp
Definition: MMTriggerTool.h:72
python.root_pickle.load
def load(f, use_proxy=1, key=None)
Definition: root_pickle.py:476
NSWL1::MMTriggerTool::m_doTruth
Gaudi::Property< bool > m_doTruth
Definition: MMTriggerTool.h:62
digitWrapper::id
Identifier id() const
Definition: MMT_struct.h:98
LArCellBinning.phiSteps
dictionary phiSteps
Definition: LArCellBinning.py:37
NSWL1::MMTriggerTool::m_rBits
Gaudi::Property< int > m_rBits
Definition: MMTriggerTool.h:83
MMT_Diamond::setRoadSizeDownX
void setRoadSizeDownX(int sizeDown)
Definition: MMT_Diamond.h:79
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
NSWL1::MMTriggerTool::m_rMin
Gaudi::Property< float > m_rMin
Definition: MMTriggerTool.h:81
digitWrapper
Definition: MMT_struct.h:82
NSWL1::MMTriggerTool::m_phiBits
Gaudi::Property< int > m_phiBits
Definition: MMTriggerTool.h:80
NSWL1::MMTriggerTool::m_phiMin
Gaudi::Property< float > m_phiMin
Definition: MMTriggerTool.h:78
NSWL1::MMTriggerTool::m_doNtuple
Gaudi::Property< bool > m_doNtuple
Definition: MMTriggerTool.h:77
fitman.k
k
Definition: fitman.py:528
NSWL1::MMTriggerTool::m_par_large
std::shared_ptr< MMT_Parameters > m_par_large
Definition: MMTriggerTool.h:88
NSWL1::MMTriggerTool::m_dThetaBits
Gaudi::Property< int > m_dThetaBits
Definition: MMTriggerTool.h:86
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Dec 22 2024 22:05:49 for ATLAS Offline Software by   doxygen 1.8.18