ATLAS Offline Software
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
ITk::StripDetectorTool Class Reference

#include <StripDetectorTool.h>

Inheritance diagram for ITk::StripDetectorTool:
Collaboration diagram for ITk::StripDetectorTool:

Public Member Functions

 StripDetectorTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~StripDetectorTool ()=default
 
virtual StatusCode create () override final
 
virtual StatusCode clear () override final
 
virtual GeoVDetectorManager * manager ()
 The Detector Node corresponding to this tool. More...
 
virtual const GeoVDetectorManager * manager () const
 
virtual StatusCode registerCallback ATLAS_NOT_THREAD_SAFE () override
 
virtual StatusCode align (IOVSVC_CALLBACK_ARGS) override
 

Protected Member Functions

bool isAvailable (const std::string &versionNode, const std::string &tableNode) const
 
std::string getBlob (const std::string &versionNode, const std::string &tableNode) const
 
StatusCode createBaseTool ()
 
GeoModelIO::ReadGeoModel * getSqliteReader () const
 
const GeoVPhysVol * createTopVolume (GeoPhysVol *worldVol, GmxInterface &interface, const std::string &versionNode, const std::string &tableNode, const std::string &containingDetector="", const std::string &envelopeName="", const GeoModelIO::ReadGeoModel *sqlreader=nullptr) const
 

Protected Attributes

Gaudi::Property< std::string > m_gmxFilename {this, "GmxFilename", "", "The name of the local file to read the geometry from"}
 
Gaudi::Property< std::string > m_detectorName {this, "DetectorName", "ITkStrip", ""}
 
ServiceHandle< IRDBAccessSvcm_rdbAccessSvc {this, "RDBAccessSvc", "RDBAccessSvc", ""}
 
ServiceHandle< IRDBAccessSvcm_sqliteReadSvc {this, "SqliteReadSvc", "SqliteReadSvc", ""}
 
ServiceHandle< IGeoDbTagSvcm_geoDbTagSvc {this, "GeoDbTagSvc", "GeoDbTagSvc", ""}
 
Gaudi::Property< std::string > m_dtdName {this, "OverrideDtdName", "", "Override standard .dtd file from GeoModelXml"}
 
Gaudi::Property< bool > m_deduplicateLogVol
 
Gaudi::Property< bool > m_deduplicatePhysVol
 
Gaudi::Property< bool > m_deduplicateShape
 
Gaudi::Property< bool > m_deduplicateTransf
 
GeoVDetectorManager * m_detector
 

Private Member Functions

void doNumerology (InDetDD::SCT_DetectorManager *manager)
 
void createVolume (GeoPhysVol *worldVol, GmxInterface &interface, const std::string &versionNode, const std::string &tableNode) const
 

Private Attributes

const InDetDD::SCT_DetectorManagerm_detManager {}
 
std::unique_ptr< InDetDD::SiCommonItemsm_commonItems {}
 
WaferTree m_waferTree
 
Gaudi::Property< bool > m_alignable {this, "Alignable", false, ""}
 
Gaudi::Property< std::string > m_alignmentFolderName {this, "AlignmentFolderName", "/Indet/Align", ""}
 
ServiceHandle< IGeometryDBSvcm_geometryDBSvc {this,"GeometryDBSvc","InDetGeometryDBSvc",""}
 
Gaudi::Property< std::string > m_clobOutputFileName {this, "ClobOutputName", "", "Name of file to dump CLOB content to"}
 

Detailed Description

Definition at line 31 of file StripDetectorTool.h.

Constructor & Destructor Documentation

◆ StripDetectorTool()

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

Definition at line 20 of file StripDetectorTool.cxx.

24 {
25 }

◆ ~StripDetectorTool()

virtual ITk::StripDetectorTool::~StripDetectorTool ( )
virtualdefault

Member Function Documentation

◆ align()

StatusCode GeoModelTool::align ( IOVSVC_CALLBACK_ARGS  )
overridevirtualinherited

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

Definition at line 33 of file GeoModelTool.cxx.

34 {
35  return StatusCode::SUCCESS;
36 }

◆ ATLAS_NOT_THREAD_SAFE()

virtual StatusCode registerCallback GeoModelTool::ATLAS_NOT_THREAD_SAFE ( )
overridevirtualinherited

◆ clear()

StatusCode ITk::StripDetectorTool::clear ( )
finaloverridevirtual

Reimplemented from GeoModelTool.

Definition at line 104 of file StripDetectorTool.cxx.

105 {
107  if (proxy) {
108  proxy->reset();
109  m_detManager = nullptr;
110  }
111  return StatusCode::SUCCESS;
112 }

◆ create()

StatusCode ITk::StripDetectorTool::create ( )
finaloverridevirtual

Definition at line 28 of file StripDetectorTool.cxx.

29 {
30  // retrieve the common stuff
32 
33  GeoModelExperiment *theExpt = nullptr;
34  ATH_CHECK(detStore()->retrieve(theExpt, "ATLAS"));
35  const SCT_ID *idHelper = nullptr;
36  ATH_CHECK(detStore()->retrieve(idHelper, "SCT_ID"));
37 
38  m_commonItems = std::make_unique<InDetDD::SiCommonItems>(idHelper);
39 
40 
41  // If we are not taking the geo from sqlite, check the availability of tables
42  // (or that we have a local geometry)
43  std::string node{"SCT"};
44  std::string table{"ITKXDD"};
45 
46  GeoModelIO::ReadGeoModel* sqlreader = getSqliteReader();
47 
48  if(!sqlreader){
49  if (!isAvailable(node, table)) {
50  ATH_MSG_INFO("Trying new " << m_detectorName.value() << " database location.");
51  node = "InnerDetector";
52  table = "StripXDD";
53  if (!isAvailable(node, table)) {
54  ATH_MSG_ERROR("No ITk Strip geometry found. ITk Strip can not be built.");
55  return StatusCode::FAILURE;
56  }
57  }
58  }
59  //
60  // Create the detector manager
61  //
62  // The * converts a ConstPVLink to a ref to a GeoVPhysVol
63  // The & takes the address of the GeoVPhysVol
64  GeoPhysVol *world = &*theExpt->getPhysVol();
66  manager->addFolder(m_alignmentFolderName);
67 
69  // Load the geometry, create the volume,
70  // node,table are the location in the DB to look for the clob
71  // empty strings are the (optional) containing detector and envelope names
72  // allowed to pass a null sqlreader ptr - it will be used to steer the source of the geometry
73  const GeoVPhysVol* topVolume = createTopVolume(world, gmxInterface, node, table,"","",sqlreader);
74  // if we are using SQLite inputs,
75  if(sqlreader){
76  ATH_MSG_INFO("Building Strip Readout Geometry from SQLite using "<<m_geoDbTagSvc->getParamSvcName());
77  gmxInterface.buildReadoutGeometryFromSqlite(m_sqliteReadSvc.operator->(),sqlreader);
78  }
79 
80  if (topVolume) { //see that a valid pointer is returned
81  manager->addTreeTop(topVolume);
83  manager->initNeighbours();
84  } else {
85  ATH_MSG_FATAL("Could not find the Top Volume!!!");
86  return StatusCode::FAILURE;
87  }
88 
89  // set the manager
91 
92  ATH_CHECK(detStore()->record(m_detManager, m_detManager->getName()));
93  theExpt->addManager(m_detManager);
94 
95  // Create a symLink to the SiDetectorManager base class so it can be accessed as either SiDetectorManager or
96  // SCT_DetectorManager
97  const InDetDD::SiDetectorManager *siDetManager = m_detManager;
98  ATH_CHECK(detStore()->symLink(m_detManager, siDetManager));
99 
100  return StatusCode::SUCCESS;
101 }

◆ createBaseTool()

StatusCode GeoModelXmlTool::createBaseTool ( )
protectedinherited

Definition at line 26 of file GeoModelXmlTool.cxx.

27 {
28  ATH_CHECK(m_geoDbTagSvc.retrieve());
29  ATH_CHECK(m_rdbAccessSvc.retrieve());
30  ATH_CHECK(m_sqliteReadSvc.retrieve());
31 
32  return StatusCode::SUCCESS;
33 }

◆ createTopVolume()

const GeoVPhysVol * GeoModelXmlTool::createTopVolume ( GeoPhysVol *  worldVol,
GmxInterface &  interface,
const std::string &  versionNode,
const std::string &  tableNode,
const std::string &  containingDetector = "",
const std::string &  envelopeName = "",
const GeoModelIO::ReadGeoModel *  sqlreader = nullptr 
) const
protectedinherited

Definition at line 35 of file GeoModelXmlTool.cxx.

36 {
37  //If we have a valid sqlreader pointer, it means the volume should already exist,
38  // so we don't need to create it
39  if(!sqlreader) createVolume(world, gmxInterface, vNode, tableName);
40  else ATH_MSG_INFO("Using geometry from .sqlite file for"<<m_detectorName);
41 
42  unsigned int nChildren = world->getNChildVols();
43 
44  const GeoVPhysVol * envVol = nullptr;
45  const GeoVPhysVol * topVol = nullptr;
46 
47  bool foundEnvelope = false;
48  bool foundContainingDetector = false;
49  // find the appropriate volume in the hierarchy, to allow it to be set as the topVolume in
50  // our detectorManager
51  std::string detectorName = m_detectorName;
52  //if a containingDetector is set, which the detector we are dealing with will sit inside, look for that first.
53  // Otherwise its just the name of the detector we are dealing with we look for
54  if(containingDetector!="") detectorName = containingDetector;
55 
56  for (int iChild = nChildren - 1; iChild>=0; --iChild) {
57  if (world->getNameOfChildVol(iChild) == detectorName) {
58  // The * converts from a ConstPVLink to a reference to a GeoVPhysVol;
59  // the & takes its address.
60  envVol = &*world->getChildVol(iChild);
61  foundContainingDetector = true;
62  if(envelopeName=="") {topVol = envVol;break;}
63  unsigned int nGrandchildren = envVol->getNChildVols();
64  for (int iGchild = nGrandchildren - 1; iGchild>=0; --iGchild) {
65  if (envVol->getNameOfChildVol(iGchild) == envelopeName) {
66  topVol = &*(envVol->getChildVol(iGchild));
67  foundEnvelope = true;
68  break;
69  }
70  }
71  }
72  }
73  if(containingDetector!="" && !foundContainingDetector) ATH_MSG_ERROR("Couldn't find the containing detector "<<containingDetector<<" in the world hierarchy!");
74  else if(envelopeName!="" && !foundEnvelope) ATH_MSG_ERROR("Couldn't find the envelope volume "<<envelopeName<<" in the world hierarchy!");
75  return topVol;
76 }

◆ createVolume()

void GeoModelXmlTool::createVolume ( GeoPhysVol *  worldVol,
GmxInterface &  interface,
const std::string &  versionNode,
const std::string &  tableNode 
) const
privateinherited

Definition at line 107 of file GeoModelXmlTool.cxx.

107  {
108  int flags{};
109  std::string gmxInput;
110 
111  if (m_gmxFilename.empty()) {
112  ATH_MSG_INFO("Getting " << m_detectorName.value() << " GeoModelXml description from the geometry database");
113  flags = 0x1; // Lowest bit ==> string; next bit implies gzip'd but we decided not to gzip
114  // how to propagate these to here best...?
115  gmxInput = getBlob(vNode,tableName);
116  if (gmxInput.empty()) { // Invalid blob?
117  std::string errMessage("GeoModelXmlTool::createTopVolume: Empty response received from the database.");
118  throw std::runtime_error(errMessage);
119  }
120  } else {
121  flags = 0;
122  gmxInput = PathResolver::find_file(m_gmxFilename, "DATAPATH");
123  ATH_MSG_INFO("Getting " << m_detectorName.value() << " GeoModelXml description from file "<<gmxInput);
124  if (gmxInput.empty()) { // File not found
125  std::string errMessage("GeoModelXmlTool::createTopVolume: Unable to find file " + m_gmxFilename +
126  " with PathResolver; check filename and DATAPATH environment variable");
127  throw std::runtime_error(errMessage);
128  }
129  }
130 
131  // Use the DTD from GeoModel
132  if (m_gmxFilename.empty()) {
133  std::string replacementName = "GeoModelXml/";
134  //now, work out the specific dtd version in the input .gmx
135  std::string startdelim = "SYSTEM \"";
136  std::string enddelim = "\" [";
137  unsigned startpos = gmxInput.find(startdelim) + startdelim.length();
138  unsigned endpos = gmxInput.find(enddelim);
139  std::string searchName = gmxInput.substr(startpos,(endpos - startpos));
140  if(searchName=="geomodel.dtd") replacementName+="geomodel_v0.dtd"; //used in xml for initial geometry tags - special case
141  else replacementName+=searchName;
142  ATH_MSG_DEBUG("Searching for "<<searchName<<" and replacing it with "<<replacementName);
143  size_t chars = searchName.length();
144  size_t index = gmxInput.find(searchName);
145  if(m_dtdName!="") replacementName=m_dtdName; //allow overriding of dtd version
146  if (index != std::string::npos) {
147  std::string dtdFile = PathResolver::find_file(replacementName, "DATAPATH");
148  ATH_MSG_DEBUG("dtdFile = " << dtdFile);
149  gmxInput.replace(index,chars, dtdFile);
150  } else {
151  throw std::runtime_error("GeoModelXmlTool::createTopVolume: Did not find valid .dtd in the gmx input string.");
152  }
153  }
154 
155  // optionally dump to local file for examination
156  if (m_clobOutputFileName != "") {
157  std::ofstream out(m_clobOutputFileName);
158  if (m_gmxFilename.empty()) {
159  out << gmxInput;
160  } else {
161  std::ifstream in(gmxInput);
162  out << in.rdbuf();
163  }
164  out.close();
165  }
166  gmxInterface.enableLogVolDeDuplication(m_deduplicateLogVol);
167  gmxInterface.enablePhysVolDeDuplication(m_deduplicatePhysVol);
168  gmxInterface.enableShapeDeDuplication(m_deduplicateShape);
169  gmxInterface.enableTransformDeDuplication(m_deduplicateTransf);
170 
171  Gmx2Geo gmx2Geo(gmxInput, world, gmxInterface, flags);
172 }

◆ doNumerology()

void ITk::StripDetectorTool::doNumerology ( InDetDD::SCT_DetectorManager manager)
private

Definition at line 114 of file StripDetectorTool.cxx.

115 {
116  ATH_MSG_INFO("\n\nSCT Numerology:\n===============\n\nNumber of parts is " << m_waferTree.nParts() << "\n");
118 
119  bool barrelDone = false;
120  for (int b = -1; b <= 1; ++b) {
121  if (m_waferTree.count(b)) {
122  msg(MSG::INFO) << " Found barrel with index " << b << std::endl;
123  n.addBarrel(b);
124  if (!barrelDone) {
125  n.setNumLayers(m_waferTree[b].nLayers());
126  msg(MSG::INFO) << " Number of barrel layers = " << n.numLayers() << std::endl;
127  for (LayerDisk::iterator l = m_waferTree[b].begin(); l != m_waferTree[b].end(); ++l) {
128  n.setNumEtaModulesForLayer(l->first, l->second.nEtaModules());
129  // All staves within a layer are assumed identical, so we can just look at the first eta
130  n.setNumPhiModulesForLayer(l->first, l->second.begin()->second.nPhiModules());
131  msg(MSG::INFO) << " layer = " << l->first << " has " << n.numEtaModulesForLayer(l->first)
132  << " etaModules each with " << n.numPhiModulesForLayer(l->first) << " phi modules" << std::endl;
133  }
134  barrelDone = true;
135  }
136  }
137 
138  }
139 
140  bool endcapDone = false;
141  for (int ec = -2; ec <= 2; ec += 4) {
142  if (m_waferTree.count(ec)) {
143  msg(MSG::INFO) << " Found endcap with index " << ec << std::endl;
144  n.addEndcap(ec);
145  if (!endcapDone) {
146  n.setNumDisks(m_waferTree[ec].nLayers());
147  msg(MSG::INFO) << " Number of endcap wheels = " << n.numDisks() << std::endl;
148  for (LayerDisk::iterator l = m_waferTree[ec].begin(); l != m_waferTree[ec].end(); ++l) {
149  n.setNumRingsForDisk(l->first, l->second.nEtaModules());
150  msg(MSG::INFO) << " Wheel " << l->first << " has " << n.numRingsForDisk(l->first) << " rings" << std::endl;
151  for (EtaModule::iterator eta = l->second.begin(); eta != l->second.end(); ++eta) {
152  n.setNumPhiModulesForDiskRing(l->first, eta->first, eta->second.nPhiModules());
153  msg(MSG::INFO) << " Ring " << eta->first << " has "
154  << n.numPhiModulesForDiskRing(l->first, eta->first) << " phi modules" << std::endl;
155  }
156  }
157  endcapDone = true;
158  }
159  }
160  }
161 
162  msg(MSG::INFO) << endmsg;
163 
164  int totalWafers = 0;
165  for (BarrelEndcap::iterator bec = m_waferTree.begin(); bec != m_waferTree.end(); ++bec) {
166  for (LayerDisk::iterator ld = bec->second.begin(); ld != bec->second.end(); ++ld) {
167  for (EtaModule::iterator eta = ld->second.begin(); eta != ld->second.end(); ++eta) {
168  for (PhiModule::iterator phi = eta->second.begin(); phi != eta->second.end(); ++phi) {
169  for (Side::iterator side =phi->second.begin(); side != phi->second.end(); ++side) {
170  totalWafers++;
171  }
172  }
173  }
174  }
175  }
176  ATH_MSG_INFO("Total number of wafers added is " << totalWafers);
177  const SCT_ID *sctIdHelper = dynamic_cast<const SCT_ID *> (m_commonItems->getIdHelper());
178  ATH_MSG_INFO("Total number of wafer identifiers is " << sctIdHelper->wafer_hash_max());
179  //
180  // Used in digitization to create one vector big enough to hold all strips, whichever detector is in consideration.
181  // Anyway they are common to pixels and strips! Pixels dominate the EtaCell count (which traditionally the SCT does not set)
182  //
183  n.setMaxNumEtaCells(1);
184  for (int d = 0; d < manager->numDesigns(); ++d) {
185  n.setMaxNumPhiCells(manager->getSCT_Design(d)->cells());
186  }
187  ATH_MSG_INFO("Max. eta cells is " << n.maxNumEtaCells());
188  ATH_MSG_INFO("Max. phi cells is " << n.maxNumPhiCells());
189  ATH_MSG_INFO("Max. no. strips is " << n.maxNumStrips());
190 
191  manager->numerology() = n;
192 
193  ATH_MSG_INFO("End of numerology\n");
194 
195  //
196  // Alignment preparation
197  //
198  if (m_alignable) {
199  ATH_MSG_INFO("Set up alignment directories");
200  const std::string topFolder(m_alignmentFolderName);
201  const std::string barrelBase("/SCTB");
202  const std::string endcapBase("/SCTE");
203  std::string baseName("");
204 
205  // Register the keys and the level corresponding to the key
206  // and whether it expects a global or local shift.
207  // level 0: sensor, level 1: module, level 2, layer/disc, level 3: whole barrel/enccap
208  //Before the type was determined from content; would be better to just set it explcitly if we only expect one
209  //Format for ITk strip. Set it to "static_run1" for the moment, since this is what exisits in the conditions
210  //but this should be revisited in future
212  manager->addAlignFolderType(alignFolderType);
213 
214  switch (alignFolderType) {
216  manager->addChannel(topFolder + "/ID", 3, InDetDD::global);
217  manager->addChannel(topFolder + "/SCT",2, InDetDD::global);
218  for (BarrelEndcap::iterator bec = m_waferTree.begin(); bec != m_waferTree.end(); ++bec) {
219  switch (bec->first) {
220  case -2:
221  baseName = topFolder + endcapBase + "C";
222  break;
223  case 0:
224  baseName = topFolder + barrelBase;
225  break;
226  case 2:
227  baseName = topFolder + endcapBase + "A";
228  break;
229  default:
230  ATH_MSG_FATAL("Unknown SCT part with bec-ID " << bec->first << " encountered.");
231  throw std::runtime_error("Unknown ITkStrip part for alignment.");
232  }
233  for (LayerDisk::iterator ld = bec->second.begin(); ld != bec->second.end(); ++ld) {
234  std::ostringstream layer;
235  layer << ld->first + 1;
236  manager->addChannel(baseName + layer.str(), 1, InDetDD::local);
237  }
238  }
239  break;
240  // To be added: case InDetDD::timedependent_run2:, see SCT_GeoModel
241  default:
242  ATH_MSG_FATAL("Alignment requested for unknown alignment folder type in StripDetectorFactory.");
243  throw std::runtime_error("Wrong alignment folder type for StripDetectorFactory in StripGeoModelXml.");
244  }
245  }
246 
247  return;
248 }

◆ getBlob()

std::string GeoModelXmlTool::getBlob ( const std::string &  versionNode,
const std::string &  tableNode 
) const
protectedinherited

Definition at line 94 of file GeoModelXmlTool.cxx.

95 {
96  DecodeVersionKey versionKey(&*m_geoDbTagSvc, vNode);
97  const IRDBRecordset_ptr recordSet = m_rdbAccessSvc->getRecordsetPtr(tableName, versionKey.tag(), versionKey.node());
98  if (!recordSet || recordSet->size() == 0) {
99  ATH_MSG_FATAL("Unable to obtain " << vNode << " recordSet");
100  throw std::runtime_error("Unable to obtain recordSet");
101  }
102  const IRDBRecord *record = (*recordSet)[0];
103  std::string clobString = record->getString("XMLCLOB");
104  return clobString;
105 }

◆ getSqliteReader()

GeoModelIO::ReadGeoModel * GeoModelXmlTool::getSqliteReader ( ) const
protectedinherited

Definition at line 174 of file GeoModelXmlTool.cxx.

174  {
175  return m_geoDbTagSvc->getSqliteReader();
176 }

◆ isAvailable()

bool GeoModelXmlTool::isAvailable ( const std::string &  versionNode,
const std::string &  tableNode 
) const
protectedinherited

Definition at line 78 of file GeoModelXmlTool.cxx.

79 {
80  if (m_gmxFilename.empty()) {
81  DecodeVersionKey versionKey(&*m_geoDbTagSvc, vNode);
82  const std::string& versionTag = versionKey.tag();
83  const std::string& versionNode = versionKey.node();
84  const std::string version = m_rdbAccessSvc->getChildTag(tableName, versionTag, versionNode);
85  if (version.empty()) {
86  return false;
87  }
88  ATH_MSG_INFO("Using " << version << " from " << versionNode << " tag " << versionTag);
89  }
90 
91  return true;
92 }

◆ manager() [1/2]

GeoVDetectorManager * GeoModelTool::manager ( )
virtualinherited

The Detector Node corresponding to this tool.

Definition at line 21 of file GeoModelTool.cxx.

21  {
22  return m_detector;
23 }

◆ manager() [2/2]

const GeoVDetectorManager * GeoModelTool::manager ( ) const
virtualinherited

Definition at line 24 of file GeoModelTool.cxx.

24  {
25  return m_detector;
26 }

Member Data Documentation

◆ m_alignable

Gaudi::Property<bool> ITk::StripDetectorTool::m_alignable {this, "Alignable", false, ""}
private

Definition at line 44 of file StripDetectorTool.h.

◆ m_alignmentFolderName

Gaudi::Property<std::string> ITk::StripDetectorTool::m_alignmentFolderName {this, "AlignmentFolderName", "/Indet/Align", ""}
private

Definition at line 46 of file StripDetectorTool.h.

◆ m_clobOutputFileName

Gaudi::Property<std::string> GeoModelXmlTool::m_clobOutputFileName {this, "ClobOutputName", "", "Name of file to dump CLOB content to"}
privateinherited

Definition at line 60 of file GeoModelXmlTool.h.

◆ m_commonItems

std::unique_ptr<InDetDD::SiCommonItems> ITk::StripDetectorTool::m_commonItems {}
private

Definition at line 41 of file StripDetectorTool.h.

◆ m_deduplicateLogVol

Gaudi::Property<bool> GeoModelXmlTool::m_deduplicateLogVol
protectedinherited
Initial value:
{this, "enableLogVolDeduplication", false,
"Remove duplications of equivalent logical volumes"}

Definition at line 48 of file GeoModelXmlTool.h.

◆ m_deduplicatePhysVol

Gaudi::Property<bool> GeoModelXmlTool::m_deduplicatePhysVol
protectedinherited
Initial value:
{this, "enablePhysVolDeduplication", false,
"Remove duplications of equivalent physical volumes"}

Definition at line 50 of file GeoModelXmlTool.h.

◆ m_deduplicateShape

Gaudi::Property<bool> GeoModelXmlTool::m_deduplicateShape
protectedinherited
Initial value:
{this, "enableShapeDeduplication", false,
"Remove duplications of equivalent shapes"}

Definition at line 52 of file GeoModelXmlTool.h.

◆ m_deduplicateTransf

Gaudi::Property<bool> GeoModelXmlTool::m_deduplicateTransf
protectedinherited
Initial value:
{this, "enableTransDeduplication", false,
"Remove duplications of equivalent transform nodes"}

Definition at line 54 of file GeoModelXmlTool.h.

◆ m_detector

GeoVDetectorManager* GeoModelTool::m_detector
protectedinherited

Definition at line 36 of file GeoModelTool.h.

◆ m_detectorName

Gaudi::Property<std::string> GeoModelXmlTool::m_detectorName {this, "DetectorName", "ITkStrip", ""}
protectedinherited

Definition at line 42 of file GeoModelXmlTool.h.

◆ m_detManager

const InDetDD::SCT_DetectorManager* ITk::StripDetectorTool::m_detManager {}
private

Definition at line 40 of file StripDetectorTool.h.

◆ m_dtdName

Gaudi::Property<std::string> GeoModelXmlTool::m_dtdName {this, "OverrideDtdName", "", "Override standard .dtd file from GeoModelXml"}
protectedinherited

Definition at line 46 of file GeoModelXmlTool.h.

◆ m_geoDbTagSvc

ServiceHandle<IGeoDbTagSvc> GeoModelXmlTool::m_geoDbTagSvc {this, "GeoDbTagSvc", "GeoDbTagSvc", ""}
protectedinherited

Definition at line 45 of file GeoModelXmlTool.h.

◆ m_geometryDBSvc

ServiceHandle< IGeometryDBSvc > ITk::StripDetectorTool::m_geometryDBSvc {this,"GeometryDBSvc","InDetGeometryDBSvc",""}
private

Definition at line 49 of file StripDetectorTool.h.

◆ m_gmxFilename

Gaudi::Property<std::string> GeoModelXmlTool::m_gmxFilename {this, "GmxFilename", "", "The name of the local file to read the geometry from"}
protectedinherited

Definition at line 41 of file GeoModelXmlTool.h.

◆ m_rdbAccessSvc

ServiceHandle<IRDBAccessSvc> GeoModelXmlTool::m_rdbAccessSvc {this, "RDBAccessSvc", "RDBAccessSvc", ""}
protectedinherited

Definition at line 43 of file GeoModelXmlTool.h.

◆ m_sqliteReadSvc

ServiceHandle<IRDBAccessSvc> GeoModelXmlTool::m_sqliteReadSvc {this, "SqliteReadSvc", "SqliteReadSvc", ""}
protectedinherited

Definition at line 44 of file GeoModelXmlTool.h.

◆ m_waferTree

WaferTree ITk::StripDetectorTool::m_waferTree
private

Definition at line 42 of file StripDetectorTool.h.


The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
GeoModelXmlTool::m_rdbAccessSvc
ServiceHandle< IRDBAccessSvc > m_rdbAccessSvc
Definition: GeoModelXmlTool.h:43
GeoModelExperiment::getPhysVol
GeoPhysVol * getPhysVol()
Destructor.
Definition: GeoModelExperiment.cxx:21
GeoModelXmlTool::createBaseTool
StatusCode createBaseTool()
Definition: GeoModelXmlTool.cxx:26
test_pyathena.eta
eta
Definition: test_pyathena.py:10
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
InDetDD::SCT_DetectorManager
Definition: SCT_DetectorManager.h:49
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
Definition: PathResolver.cxx:251
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
index
Definition: index.py:1
AthenaPoolTestRead.flags
flags
Definition: AthenaPoolTestRead.py:8
hist_file_dump.d
d
Definition: hist_file_dump.py:137
IRDBRecord::getString
virtual const std::string & getString(const std::string &fieldName) const =0
Get string field value.
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
GeoModelExperiment
Definition: GeoModelExperiment.h:32
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
GeoModelXmlTool::m_clobOutputFileName
Gaudi::Property< std::string > m_clobOutputFileName
Definition: GeoModelXmlTool.h:60
ITk::StripDetectorTool::m_detManager
const InDetDD::SCT_DetectorManager * m_detManager
Definition: StripDetectorTool.h:40
GeoModelXmlTool::isAvailable
bool isAvailable(const std::string &versionNode, const std::string &tableNode) const
Definition: GeoModelXmlTool.cxx:78
InDetDD::ITk::StripGmxInterface
Definition: StripGmxInterface.h:29
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
InDetDD::static_run1
@ static_run1
Definition: InDetDD_Defs.h:19
InDetDD::global
@ global
Definition: InDetDD_Defs.h:16
ITk::StripDetectorTool::m_alignable
Gaudi::Property< bool > m_alignable
Definition: StripDetectorTool.h:44
ITk::StripDetectorTool::m_commonItems
std::unique_ptr< InDetDD::SiCommonItems > m_commonItems
Definition: StripDetectorTool.h:41
TRT::Hit::side
@ side
Definition: HitInfo.h:83
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
GeoModelXmlTool::createTopVolume
const GeoVPhysVol * createTopVolume(GeoPhysVol *worldVol, GmxInterface &interface, const std::string &versionNode, const std::string &tableNode, const std::string &containingDetector="", const std::string &envelopeName="", const GeoModelIO::ReadGeoModel *sqlreader=nullptr) const
Definition: GeoModelXmlTool.cxx:35
GeoModelXmlTool::m_detectorName
Gaudi::Property< std::string > m_detectorName
Definition: GeoModelXmlTool.h:42
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
GeoModelXmlTool::getSqliteReader
GeoModelIO::ReadGeoModel * getSqliteReader() const
Definition: GeoModelXmlTool.cxx:174
GeoModelTool::manager
virtual GeoVDetectorManager * manager()
The Detector Node corresponding to this tool.
Definition: GeoModelTool.cxx:21
GeoModelXmlTool::m_gmxFilename
Gaudi::Property< std::string > m_gmxFilename
Definition: GeoModelXmlTool.h:41
ITk::StripDetectorTool::m_waferTree
WaferTree m_waferTree
Definition: StripDetectorTool.h:42
beamspotman.n
n
Definition: beamspotman.py:731
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
ITk::StripDetectorTool::m_alignmentFolderName
Gaudi::Property< std::string > m_alignmentFolderName
Definition: StripDetectorTool.h:46
DecodeVersionKey
This is a helper class to query the version tags from GeoModelSvc and determine the appropriate tag a...
Definition: DecodeVersionKey.h:18
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
GeoModelXmlTool::createVolume
void createVolume(GeoPhysVol *worldVol, GmxInterface &interface, const std::string &versionNode, const std::string &tableNode) const
Definition: GeoModelXmlTool.cxx:107
GeoModelXmlTool::m_dtdName
Gaudi::Property< std::string > m_dtdName
Definition: GeoModelXmlTool.h:46
GeoModelXmlTool::m_deduplicatePhysVol
Gaudi::Property< bool > m_deduplicatePhysVol
Definition: GeoModelXmlTool.h:50
IRDBRecordset_ptr
std::shared_ptr< IRDBRecordset > IRDBRecordset_ptr
Definition: IRDBAccessSvc.h:25
InDetDD::local
@ local
Definition: InDetDD_Defs.h:16
GeoModelXmlTool::m_deduplicateShape
Gaudi::Property< bool > m_deduplicateShape
Definition: GeoModelXmlTool.h:52
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
GeoModelTool::m_detector
GeoVDetectorManager * m_detector
Definition: GeoModelTool.h:36
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
SCT_ID::wafer_hash_max
size_type wafer_hash_max(void) const
Definition: SCT_ID.cxx:645
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
python.ext.table_printer.table
list table
Definition: table_printer.py:81
InDetDD::SiNumerology
Definition: SiNumerology.h:27
GeoModelExperiment::addManager
void addManager(const GeoVDetectorManager *)
Definition: GeoModelExperiment.cxx:40
get_generator_info.version
version
Definition: get_generator_info.py:33
GeoModelXmlTool::getBlob
std::string getBlob(const std::string &versionNode, const std::string &tableNode) const
Definition: GeoModelXmlTool.cxx:94
GeoModelXmlTool::m_deduplicateLogVol
Gaudi::Property< bool > m_deduplicateLogVol
Definition: GeoModelXmlTool.h:48
SCT_ID
Definition: SCT_ID.h:68
GeoModelXmlTool::m_geoDbTagSvc
ServiceHandle< IGeoDbTagSvc > m_geoDbTagSvc
Definition: GeoModelXmlTool.h:45
IRDBRecord
IRDBRecord is one record in the IRDBRecordset object.
Definition: IRDBRecord.h:27
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
GeoModelXmlTool::m_sqliteReadSvc
ServiceHandle< IRDBAccessSvc > m_sqliteReadSvc
Definition: GeoModelXmlTool.h:44
InDetDD::SiDetectorManager
Definition: SiDetectorManager.h:60
BarrelEndcap::nParts
int nParts() const
Definition: WaferTree.h:69
ITk::StripDetectorTool::doNumerology
void doNumerology(InDetDD::SCT_DetectorManager *manager)
Definition: StripDetectorTool.cxx:114
SG::DataProxy
Definition: DataProxy.h:45
GeoModelXmlTool::m_deduplicateTransf
Gaudi::Property< bool > m_deduplicateTransf
Definition: GeoModelXmlTool.h:54
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
InDetDD::AlignFolderType
AlignFolderType
Definition: InDetDD_Defs.h:19
geometry_dat_to_json.ld
ld
Definition: geometry_dat_to_json.py:32
node
Definition: memory_hooks-stdcmalloc.h:74
GeoModelXmlTool::GeoModelXmlTool
GeoModelXmlTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: GeoModelXmlTool.cxx:19