ATLAS Offline Software
Loading...
Searching...
No Matches
MuonDetectorTool Class Referencefinal

#include <MuonDetectorTool.h>

Inheritance diagram for MuonDetectorTool:
Collaboration diagram for MuonDetectorTool:

Public Member Functions

 MuonDetectorTool (const std::string &type, const std::string &name, const IInterface *parent)
 Constructor(s)
virtual ~MuonDetectorTool () override final
virtual StatusCode initialize () override
virtual StatusCode create () override final
 Create the Detector Node corresponding to this tool.
StatusCode createFactory (MuonGM::MuonDetectorManager *&, GeoPhysVol *world) const
virtual StatusCode clear () override final
virtual GeoVDetectorManager * manager ()
virtual const GeoVDetectorManager * manager () const
virtual StatusCode align () override

Protected Attributes

GeoVDetectorManager * m_detector {nullptr}

Private Attributes

Gaudi::Property< std::string > m_layout {this, "LayoutName", "R.08" }
Gaudi::Property< bool > m_accessCondDb {this,"UseConditionDb", true}
Gaudi::Property< bool > m_asciiCondData {this,"UseAsciiConditionData", false}
Gaudi::Property< bool > m_includeCutouts {this, "IncludeCutouts", false}
Gaudi::Property< bool > m_includeCutoutsBog {this, "IncludeCutoutsBog", false }
Gaudi::Property< bool > m_includeCtbBis {this, "IncludeCtbBis" , false }
Gaudi::Property< bool > m_dumpMemoryBreakDown {this, "DumpMemoryBreakDown", false}
Gaudi::Property< bool > m_enableFineClashFixing {this, "EnableFineClashFixing", false}
Gaudi::Property< bool > m_hasCSC {this,"HasCSC", true}
Gaudi::Property< bool > m_hasSTgc {this, "HasSTgc", true}
Gaudi::Property< bool > m_hasMM {this, "HasMM", true}
Gaudi::Property< bool > m_stationSelection {this, "StationSelection", false}
Gaudi::Property< std::vector< std::string > > m_selectedStations {this, "SelectedStations", {}}
Gaudi::Property< std::vector< int > > m_selectedStEta {this,"SelectedStJzz",{}}
Gaudi::Property< std::vector< int > > m_selectedStPhi {this,"SelectedStJff",{}}
Gaudi::Property< int > m_controlAlines {this, "ControlAlines", 111111, "allowed values are 0 - 111111"}
Gaudi::Property< bool > m_dumpAlines {this, "DumpAlines", false}
Gaudi::Property< std::string > m_altAsztFile {this, "AlternateASZTFile", "" }
Gaudi::Property< int > m_minimalGeoFlag {this, "MinimalGeoFlag", 0}
Gaudi::Property< bool > m_useCscIntAlines {this, "EnableCscInternalAlignment", false}
Gaudi::Property< int > m_controlCscIntAlines {this, "ControlCscInternalAlines", 111111 , "allowed values are 0 - 111111"}
Gaudi::Property< bool > m_dumpCscIntAlines {this, "DumpCscInternalAlines", false}
Gaudi::Property< bool > m_useCscIntAlinesFromGM {this, "UseIlinesFromGM", true}
Gaudi::Property< std::string > m_altCscIntAlinesFile {this, "AlternateCscIntAlignFile", ""}
Gaudi::Property< bool > m_beeNoShiftInDefault {this, "BEENoShift", false, "Turn off the initial 111 mm shift in BEE station (real data)"}
MuonGM::MuonDetectorManagerm_manager {nullptr}

Detailed Description

Constructor & Destructor Documentation

◆ MuonDetectorTool()

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

Constructor(s)

Definition at line 31 of file MuonDetDescr/MuonGeoModel/src/MuonDetectorTool.cxx.

31 :
32 GeoModelTool(type, name, parent) {
33 declareInterface<IGeoModelTool>(this);
34}

◆ ~MuonDetectorTool()

MuonDetectorTool::~MuonDetectorTool ( )
finaloverridevirtualdefault

Member Function Documentation

◆ align()

virtual StatusCode GeoModelTool::align ( )
inlineoverridevirtualinherited

Reimplemented in ALFA_DetectorTool, LArDetectorToolNV, PixelDetectorTool, SCT_DetectorTool, and TRT_DetectorTool.

Definition at line 25 of file GeoModelTool.h.

25{return StatusCode::SUCCESS;}

◆ clear()

StatusCode MuonDetectorTool::clear ( )
finaloverridevirtual

Reimplemented from GeoModelTool.

Definition at line 266 of file MuonDetDescr/MuonGeoModel/src/MuonDetectorTool.cxx.

266 {
267 SG::DataProxy *proxy = detStore()->proxy(ClassID_traits<MuonGM::MuonDetectorManager>::ID(), m_manager->getName());
268 if (proxy) {
269 proxy->reset();
270 m_manager = nullptr;
271 }
272 return StatusCode::SUCCESS;
273}

◆ create()

StatusCode MuonDetectorTool::create ( )
finaloverridevirtual

Create the Detector Node corresponding to this tool.

add hash look-up for TGC sectors to the detector store here

Definition at line 46 of file MuonDetDescr/MuonGeoModel/src/MuonDetectorTool.cxx.

46 {
47
48 std::ofstream geoModelStats;
49 int mem{0}, umem{0};
50 float cpu{0.f}, ucpu{0.f};
51
52 MuonGM::MuonDetectorManager *mgr=nullptr;
53 GeoModelExperiment *theExpt = nullptr;
54 ATH_CHECK(detStore()->retrieve(theExpt, "ATLAS"));
55 GeoIntrusivePtr<GeoPhysVol> world{theExpt->getPhysVol()};
56 ATH_CHECK(createFactory(mgr, world));
57
58 ATH_CHECK(detStore()->record(mgr,mgr->getName()));
59 theExpt->addManager(mgr);
60
61 m_manager = mgr;
62
64 umem = GeoPerfUtils::getMem();
65 ucpu = float(GeoPerfUtils::getCpu() / 100.);
66 geoModelStats << "At MuonDetectorTool::everything done \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds ---- \t DeltaM = " << umem - mem
67 << " \t Delta T =" << ucpu - cpu << std::endl;
68 geoModelStats.close();
69 }
70
71 Muon::MuonSectorMapping mapping;
73 if (m_manager && m_manager->tgcIdHelper()) {
74 unsigned int tgcHashMax = m_manager->tgcIdHelper()->detectorElement_hash_max();
75 std::vector<int> *sectorHashVec = new std::vector<int>(tgcHashMax, 0);
76 for (unsigned int i = 0; i < tgcHashMax; ++i) {
77 const MuonGM::TgcReadoutElement *detEl = m_manager->getTgcReadoutElement(i);
78 if (detEl)
79 (*sectorHashVec)[i] = mapping.getSector(detEl->center().phi());
80 }
81 if (detStore()->record(sectorHashVec, "TGC_SectorMapping").isFailure()) {
82 ATH_MSG_WARNING(" failed to record TGC sector mapping ");
83 }
84 }
85 return StatusCode::SUCCESS;
86}
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_WARNING(x)
GeoPhysVol * getPhysVol()
Destructor.
void addManager(const GeoVDetectorManager *)
StatusCode createFactory(MuonGM::MuonDetectorManager *&, GeoPhysVol *world) const
virtual const Amg::Vector3D & center() const override
Return the center of the element.

◆ createFactory()

StatusCode MuonDetectorTool::createFactory ( MuonGM::MuonDetectorManager *& mgr,
GeoPhysVol * world ) const

Definition at line 88 of file MuonDetDescr/MuonGeoModel/src/MuonDetectorTool.cxx.

88 {
89
90 std::ofstream geoModelStats;
91 int mem{0}, umem{0};
92 float cpu{0.f}, ucpu{0.f};
93
95 geoModelStats.open("MuonGeoModelStatistics_MuonDetectorTool");
96 mem = GeoPerfUtils::getMem();
97 cpu = float(GeoPerfUtils::getCpu() / 100.);
98 geoModelStats << "At MuonDetectorTool::create entry point: \t SZ= " << mem << " Kb \t Time = " << cpu << " seconds " << std::endl;
99
100 umem = GeoPerfUtils::getMem();
101 ucpu = float(GeoPerfUtils::getCpu() / 100.);
102 geoModelStats << "At MuonDetectorTool::resetting to 0: \t SZ= " << umem - mem << " Kb \t Time = " << ucpu - cpu << " seconds " << std::endl;
103 mem = umem;
104 cpu = ucpu;
105 }
106
107 ATH_MSG_VERBOSE(" Show properties (user sett.s or default): LayoutName "
108 << m_layout << endmsg << " Show properties (user sett.s or default): IncludeCutouts " << m_includeCutouts << endmsg
109 << " Show properties (user sett.s or default): IncludeCutoutsBog " << m_includeCutoutsBog << endmsg
110 << " Show properties (user sett.s or default): IncludeCtbBis " << m_includeCtbBis);
111
112 // Get the detector configuration.
113 SmartIF<IGeoModelSvc> geoModel{Gaudi::svcLocator()->service("GeoModelSvc")};
114 ATH_CHECK(geoModel.isValid());
115
116 std::string AtlasVersion = geoModel->atlasVersion();
117 std::string MuonVersion = geoModel->muonVersionOverride();
118
119 ATH_MSG_INFO("create MuonDetectorTool");
120 ATH_MSG_INFO("(from GeoModelSvc) AtlasVersion = <" << AtlasVersion << "> MuonVersion = <" << MuonVersion << ">");
121
122 // Unless we are using custom muons, the switch positions are going to
123 // come from the database:
124
125 std::string detectorKey = MuonVersion.empty() ? AtlasVersion : MuonVersion;
126 std::string detectorNode = MuonVersion.empty() ? "ATLAS" : "MuonSpectrometer";
127 ATH_MSG_INFO("Keys for Muon Switches are (key) " << detectorKey << " (node) " << detectorNode);
128
129 std::string tempLayout = m_layout;
130 std::map<std::string, std::string> altAsciiDBMap{};
131
132
133 // Get the detector configuration.
134 ServiceHandle<IGeoDbTagSvc> geoDbTag("GeoDbTagSvc",name());
135 ATH_CHECK(geoDbTag.retrieve());
136 ServiceHandle<IRDBAccessSvc> accessSvc(geoDbTag->getParamSvcName(),name());
137 ATH_CHECK(accessSvc.retrieve());
138 GeoModelIO::ReadGeoModel* sqliteReader = geoDbTag->getSqliteReader();
139
140 if (sqliteReader) {
141
142 ATH_MSG_INFO("New DD Activated; Muon detector description input from SQLITE file");
143
144 MuonDetectorFactoryLite theFactory(detStore().operator->(),sqliteReader);
145 theFactory.setRDBAccess(accessSvc.get());
146 theFactory.create(world);
147
148
149 mgr=theFactory.getDetectorManager();
150 mgr->setMinimalGeoFlag(m_minimalGeoFlag);
151 mgr->setGeometryVersion(tempLayout);
152 mgr->fillCache();
153
154 return StatusCode::SUCCESS;
155 }
156 //
157 // New DD: action ends here!!
158 //
159 //=====================================================
160 //
161 // Old DD: action starts here:
162 //
163
164 MuonDetectorFactory001 theFactory(detStore().operator->());
165 theFactory.disableBEEShift(m_beeNoShiftInDefault);
166
167
168 ATH_MSG_DEBUG("Detector Information coming from the database (job options IGNORED)");
169
170 IRDBRecordset_ptr switchSet = accessSvc->getRecordsetPtr("MuonSwitches", detectorKey, detectorNode);
171 if (switchSet->size() == 0) {
172 ATH_MSG_ERROR("Failed to retrieve MuonSwitches from the database!");
173 return StatusCode::FAILURE;
174 }
175 const IRDBRecord *switches = (*switchSet)[0];
176
177 tempLayout = switches->getString("LAYOUTNAME");
178 if (MuonVersion.empty()) {
179 MuonVersion = accessSvc->getChildTag("MuonSpectrometer", detectorKey, detectorNode);
180 ATH_MSG_INFO("(from GeoModelSvc) in AtlasVersion = <" << AtlasVersion << "> default MuonVersion is <" << MuonVersion << ">");
181 }
182
183 ATH_MSG_DEBUG(" m_altAsztFile: " << m_altAsztFile);
184 // use ascii file to read in ASZT parameters
185 if (m_altAsztFile != "")
186 altAsciiDBMap.insert(std::make_pair("ASZT", m_altAsztFile));
187 if (m_altCscIntAlinesFile != "")
188 altAsciiDBMap.insert(std::make_pair("IACSC", m_altCscIntAlinesFile));
189
190 //
191 // Locate the top level experiment node
192 //
193 ATH_MSG_INFO("Properties have been set as follows: " << endmsg
194 << " LayoutName " << tempLayout.substr(0, 1) << endmsg
195 << " IncludeCutouts " << m_includeCutouts << endmsg
196 << " IncludeCutoutsBog " << m_includeCutoutsBog << endmsg
197 << " IncludeCtbBis " << m_includeCtbBis << endmsg
198 << " MinimalGeoFlag " << m_minimalGeoFlag << endmsg
199 << " EnableCscIntAlignmentFromGM " << m_useCscIntAlinesFromGM);
200
201 if (m_stationSelection > 0) {
203 if ((m_selectedStations.size() + m_selectedStEta.size() + m_selectedStPhi.size()) < 1) {
204 ATH_MSG_ERROR(" **** Badly set Option " << endmsg << " **** SelectedStations size =" << m_selectedStations.size() << endmsg
205 << " **** SelectedStJzz size =" << m_selectedStations.size() << endmsg
206 << " **** SelectedStJff size =" << m_selectedStations.size() << endmsg << " **** while StationSelection = 1");
207 return (StatusCode::FAILURE);
208 }
209 for (const std::string& station : m_selectedStations) {
210 ATH_MSG_INFO(" Selected stations " << station);
211 }
212
213 for (int stEta : m_selectedStEta) {
214 ATH_MSG_INFO(" Selected Jzz locations " << stEta);
215 }
216 for (int stPhi : m_selectedStPhi) {
217 ATH_MSG_INFO(" Selected Jff locations " << stPhi);
218 }
219 }
220
222 umem = GeoPerfUtils::getMem();
223 ucpu = float(GeoPerfUtils::getCpu() / 100.);
224 geoModelStats << "At MuonDetectorTool::material mgr done \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds ---- \t DeltaM = " << umem - mem
225 << " \t Delta T =" << ucpu - cpu << std::endl;
226 mem = umem;
227 cpu = ucpu;
228 }
229
230 theFactory.setDBAtlasVersion(AtlasVersion);
231 theFactory.setDBMuonVersion(MuonVersion);
232 theFactory.setDBkey(detectorKey);
233 theFactory.setDBnode(detectorNode);
234 theFactory.setLayout(tempLayout);
235 theFactory.setCutoutsFlag(m_includeCutouts);
236 theFactory.setCutoutsBogFlag(m_includeCutoutsBog);
237 theFactory.setCtbBisFlag(m_includeCtbBis);
238 theFactory.setMinimalGeoFlag(m_minimalGeoFlag);
239 theFactory.setDumpMemoryBreakDown(m_dumpMemoryBreakDown);
240 theFactory.setFineClashFixingFlag(m_enableFineClashFixing);
241 theFactory.hasCSC(m_hasCSC);
242 theFactory.hasSTgc(m_hasSTgc);
243 theFactory.hasMM(m_hasMM);
244 if (m_stationSelection > 0)
245 theFactory.setSelection(m_selectedStations, m_selectedStEta, m_selectedStPhi);
246
247 theFactory.setRDBAccess(accessSvc.get());
248 theFactory.setAltAsciiDBMap(altAsciiDBMap);
249
250 theFactory.create(world);
251
253 umem = GeoPerfUtils::getMem();
254 ucpu = float(GeoPerfUtils::getCpu() / 100.);
255 geoModelStats << "At MuonDetectorTool::factory created \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds ---- \t DeltaM = " << umem - mem
256 << " \t Delta T =" << ucpu - cpu << std::endl;
257 mem = umem;
258 cpu = ucpu;
259 }
260
261 mgr=theFactory.getDetectorManager();
262 mgr->fillCache();
263 return StatusCode::SUCCESS;
264}
#define endmsg
#define ATH_MSG_ERROR(x)
#define ATH_MSG_INFO(x)
#define ATH_MSG_VERBOSE(x)
#define ATH_MSG_DEBUG(x)
std::shared_ptr< IRDBRecordset > IRDBRecordset_ptr
virtual const std::string & getString(const std::string &fieldName) const =0
Get string field value.
virtual unsigned int size() const =0
Gaudi::Property< std::vector< int > > m_selectedStPhi
Gaudi::Property< std::vector< int > > m_selectedStEta
Gaudi::Property< std::vector< std::string > > m_selectedStations
static void SetSelectionType(int t)

◆ initialize()

StatusCode MuonDetectorTool::initialize ( )
overridevirtual

Definition at line 38 of file MuonDetDescr/MuonGeoModel/src/MuonDetectorTool.cxx.

38 {
39 ATH_MSG_INFO("Initializing ...");
40 return StatusCode::SUCCESS;
41}

◆ manager() [1/2]

virtual GeoVDetectorManager * GeoModelTool::manager ( )
inlinevirtualinherited

Definition at line 21 of file GeoModelTool.h.

21{return m_detector;}
GeoVDetectorManager * m_detector

◆ manager() [2/2]

virtual const GeoVDetectorManager * GeoModelTool::manager ( ) const
inlinevirtualinherited

Definition at line 22 of file GeoModelTool.h.

22{return m_detector;}

Member Data Documentation

◆ m_accessCondDb

Gaudi::Property<bool> MuonDetectorTool::m_accessCondDb {this,"UseConditionDb", true}
private

Definition at line 38 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

38{this,"UseConditionDb", true};

◆ m_altAsztFile

Gaudi::Property<std::string> MuonDetectorTool::m_altAsztFile {this, "AlternateASZTFile", "" }
private

Definition at line 59 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

59{this, "AlternateASZTFile", "" };

◆ m_altCscIntAlinesFile

Gaudi::Property<std::string> MuonDetectorTool::m_altCscIntAlinesFile {this, "AlternateCscIntAlignFile", ""}
private

Definition at line 66 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

66{this, "AlternateCscIntAlignFile", ""};

◆ m_asciiCondData

Gaudi::Property<bool> MuonDetectorTool::m_asciiCondData {this,"UseAsciiConditionData", false}
private

Definition at line 39 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

39{this,"UseAsciiConditionData", false};

◆ m_beeNoShiftInDefault

Gaudi::Property<bool> MuonDetectorTool::m_beeNoShiftInDefault {this, "BEENoShift", false, "Turn off the initial 111 mm shift in BEE station (real data)"}
private

Definition at line 68 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

68{this, "BEENoShift", false, "Turn off the initial 111 mm shift in BEE station (real data)"};

◆ m_controlAlines

Gaudi::Property<int> MuonDetectorTool::m_controlAlines {this, "ControlAlines", 111111, "allowed values are 0 - 111111"}
private

Definition at line 57 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

57{this, "ControlAlines", 111111, "allowed values are 0 - 111111"};

◆ m_controlCscIntAlines

Gaudi::Property<int> MuonDetectorTool::m_controlCscIntAlines {this, "ControlCscInternalAlines", 111111 , "allowed values are 0 - 111111"}
private

Definition at line 63 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

63{this, "ControlCscInternalAlines", 111111 , "allowed values are 0 - 111111"};

◆ m_detector

GeoVDetectorManager* GeoModelTool::m_detector {nullptr}
protectedinherited

Definition at line 28 of file GeoModelTool.h.

28{nullptr};

◆ m_dumpAlines

Gaudi::Property<bool> MuonDetectorTool::m_dumpAlines {this, "DumpAlines", false}
private

Definition at line 58 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

58{this, "DumpAlines", false};

◆ m_dumpCscIntAlines

Gaudi::Property<bool> MuonDetectorTool::m_dumpCscIntAlines {this, "DumpCscInternalAlines", false}
private

Definition at line 64 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

64{this, "DumpCscInternalAlines", false};

◆ m_dumpMemoryBreakDown

Gaudi::Property<bool> MuonDetectorTool::m_dumpMemoryBreakDown {this, "DumpMemoryBreakDown", false}
private

Definition at line 45 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

45{this, "DumpMemoryBreakDown", false};

◆ m_enableFineClashFixing

Gaudi::Property<bool> MuonDetectorTool::m_enableFineClashFixing {this, "EnableFineClashFixing", false}
private

Definition at line 46 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

46{this, "EnableFineClashFixing", false};

◆ m_hasCSC

Gaudi::Property<bool> MuonDetectorTool::m_hasCSC {this,"HasCSC", true}
private

Definition at line 47 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

47{this,"HasCSC", true};

◆ m_hasMM

Gaudi::Property<bool> MuonDetectorTool::m_hasMM {this, "HasMM", true}
private

Definition at line 49 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

49{this, "HasMM", true};

◆ m_hasSTgc

Gaudi::Property<bool> MuonDetectorTool::m_hasSTgc {this, "HasSTgc", true}
private

Definition at line 48 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

48{this, "HasSTgc", true};

◆ m_includeCtbBis

Gaudi::Property<bool> MuonDetectorTool::m_includeCtbBis {this, "IncludeCtbBis" , false }
private

Definition at line 43 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

43{this, "IncludeCtbBis" , false };

◆ m_includeCutouts

Gaudi::Property<bool> MuonDetectorTool::m_includeCutouts {this, "IncludeCutouts", false}
private

Definition at line 41 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

41{this, "IncludeCutouts", false};

◆ m_includeCutoutsBog

Gaudi::Property<bool> MuonDetectorTool::m_includeCutoutsBog {this, "IncludeCutoutsBog", false }
private

Definition at line 42 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

42{this, "IncludeCutoutsBog", false };

◆ m_layout

Gaudi::Property<std::string> MuonDetectorTool::m_layout {this, "LayoutName", "R.08" }
private

Definition at line 37 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

37{this, "LayoutName", "R.08" };

◆ m_manager

MuonGM::MuonDetectorManager* MuonDetectorTool::m_manager {nullptr}
private

Definition at line 69 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

69{nullptr};

◆ m_minimalGeoFlag

Gaudi::Property<int> MuonDetectorTool::m_minimalGeoFlag {this, "MinimalGeoFlag", 0}
private

Definition at line 60 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

60{this, "MinimalGeoFlag", 0};

◆ m_selectedStations

Gaudi::Property<std::vector<std::string> > MuonDetectorTool::m_selectedStations {this, "SelectedStations", {}}
private

Definition at line 52 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

52{this, "SelectedStations", {}};

◆ m_selectedStEta

Gaudi::Property<std::vector<int> > MuonDetectorTool::m_selectedStEta {this,"SelectedStJzz",{}}
private

Definition at line 53 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

53{this,"SelectedStJzz",{}};

◆ m_selectedStPhi

Gaudi::Property<std::vector<int> > MuonDetectorTool::m_selectedStPhi {this,"SelectedStJff",{}}
private

Definition at line 54 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

54{this,"SelectedStJff",{}};

◆ m_stationSelection

Gaudi::Property<bool> MuonDetectorTool::m_stationSelection {this, "StationSelection", false}
private

Definition at line 51 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

51{this, "StationSelection", false};

◆ m_useCscIntAlines

Gaudi::Property<bool> MuonDetectorTool::m_useCscIntAlines {this, "EnableCscInternalAlignment", false}
private

Definition at line 62 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

62{this, "EnableCscInternalAlignment", false};

◆ m_useCscIntAlinesFromGM

Gaudi::Property<bool> MuonDetectorTool::m_useCscIntAlinesFromGM {this, "UseIlinesFromGM", true}
private

Definition at line 65 of file MuonDetDescr/MuonGeoModel/MuonGeoModel/MuonDetectorTool.h.

65{this, "UseIlinesFromGM", true};

The documentation for this class was generated from the following files: