ITk::PixelDetectorTool Class Reference

#include <PixelDetectorTool.h>

Inheritance diagram for ITk::PixelDetectorTool:

Collaboration diagram for ITk::PixelDetectorTool:

Public Member Functions
	PixelDetectorTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~PixelDetectorTool ()=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< IRDBAccessSvc >	m_rdbAccessSvc {this, "RDBAccessSvc", "RDBAccessSvc", ""}
ServiceHandle< IRDBAccessSvc >	m_sqliteReadSvc {this, "SqliteReadSvc", "SqliteReadSvc", ""}
ServiceHandle< IGeoDbTagSvc >	m_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::PixelDetectorManager *manager)
void	createVolume (GeoPhysVol *worldVol, GmxInterface &interface, const std::string &versionNode, const std::string &tableNode) const

Private Attributes
const InDetDD::PixelDetectorManager *	m_detManager {}
std::unique_ptr< InDetDD::SiCommonItems >	m_commonItems {}
WaferTree	m_moduleTree
Gaudi::Property< bool >	m_alignable {this, "Alignable", false, ""}
Gaudi::Property< std::string >	m_alignmentFolderName {this, "AlignmentFolderName", "/Indet/Align", ""}
ServiceHandle< IGeometryDBSvc >	m_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 30 of file ml/PixelGeoModelXml/PixelDetectorTool.h.

Constructor & Destructor Documentation

PixelDetectorTool()

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

Definition at line 22 of file ml/src/PixelDetectorTool.cxx.

 : GeoModelXmlTool(type, name, parent)
{
}

~PixelDetectorTool()

virtual ITk::PixelDetectorTool::~PixelDetectorTool ( )

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.

{
  return StatusCode::SUCCESS;
}

ATLAS_NOT_THREAD_SAFE()

virtual StatusCode registerCallback GeoModelTool::ATLAS_NOT_THREAD_SAFE ( )

overridevirtualinherited

Reimplemented in PixelDetectorTool, HGTD_DetectorTool, TRT_DetectorTool, SCT_DetectorTool, PLRDetectorTool, BCMPrimeDetectorTool, HGTD_GMX_DetectorTool, and LArDetectorToolNV.

clear()

StatusCode PixelDetectorTool::clear ( )

finaloverridevirtual

Reimplemented from GeoModelTool.

Definition at line 120 of file ml/src/PixelDetectorTool.cxx.

{
  SG::DataProxy* proxy = detStore()->proxy(ClassID_traits<InDetDD::PixelDetectorManager>::ID(),m_detManager->getName());
  if (proxy) {
    proxy->reset();
    m_detManager = nullptr;
  }
  return StatusCode::SUCCESS;
}

create()

StatusCode PixelDetectorTool::create ( )

finaloverridevirtual

Definition at line 30 of file ml/src/PixelDetectorTool.cxx.

{
  // retrieve the common stuff
  ATH_CHECK(createBaseTool());
 
  GeoModelExperiment *theExpt = nullptr;
  ATH_CHECK(detStore()->retrieve(theExpt, "ATLAS"));
  const PixelID *idHelper = nullptr;
  ATH_CHECK(detStore()->retrieve(idHelper, "PixelID"));
 
  m_commonItems = std::make_unique<InDetDD::SiCommonItems>(idHelper);
   
  GeoModelIO::ReadGeoModel* sqlreader = getSqliteReader();
  
  // If we are not taking the geo from sqlite, check the availability of tables 
  // (or that we have a local geometry)
  std::string node{"Pixel"};
  std::string table{"PIXXDD"};
  
   if(!sqlreader){
      if (!isAvailable(node, table)) {
       ATH_MSG_INFO("Trying new " << m_detectorName.value() << " database location.");
       node = "InnerDetector";
       table = "PixelXDD";
       if (!isAvailable(node, table)) {
           ATH_MSG_ERROR("No ITk Pixel geometry found. ITk Pixel can not be built.");
           return StatusCode::FAILURE;
        }
     }
   }
  //
  // Create the detector manager
  //
  // The * converts a ConstPVLink to a ref to a GeoVPhysVol
  // The & takes the address of the GeoVPhysVol
  GeoPhysVol *world = &*theExpt->getPhysVol();
  auto *manager = new InDetDD::PixelDetectorManager(&*detStore(), m_detectorName, "PixelID");
  const std::string topFolder(m_alignmentFolderName);
  manager->addFolder(topFolder);
  if (m_alignable) {
    InDetDD::AlignFolderType alignFolderType = InDetDD::static_run1 ;
    manager->addAlignFolderType(alignFolderType);
    manager->addChannel(topFolder +"/ID",     2, InDetDD::global);
    manager->addChannel(topFolder +"/PIX",    1, InDetDD::global);
    manager->addChannel(topFolder +"/PIXB1",  0, InDetDD::local);
    manager->addChannel(topFolder +"/PIXB2",  0, InDetDD::local);
    manager->addChannel(topFolder +"/PIXB3",  0, InDetDD::local);
    manager->addChannel(topFolder +"/PIXB4",  0, InDetDD::local);
    manager->addChannel(topFolder +"/PIXEA1", 0, InDetDD::local);
    manager->addChannel(topFolder +"/PIXEA2", 0, InDetDD::local);
    manager->addChannel(topFolder +"/PIXEA3", 0, InDetDD::local);
    manager->addChannel(topFolder +"/PIXEC1", 0, InDetDD::local);
    manager->addChannel(topFolder +"/PIXEC2", 0, InDetDD::local);
    manager->addChannel(topFolder +"/PIXEC3", 0, InDetDD::local);
  }
  InDetDD::ITk::PixelGmxInterface gmxInterface(manager, m_commonItems.get(), &m_moduleTree);
 
  // Load the geometry, create the volume, 
  // node,table are the location in the DB to look for the clob
  // empty strings are the (optional) containing detector and envelope names
  // allowed to pass a null sqlreader ptr - it will be used to steer the source of the geometry
  const GeoVPhysVol* topVolume = createTopVolume(world, gmxInterface, node, table,"","",sqlreader);
  if(sqlreader){
        ATH_MSG_INFO("Building Pixel Readout Geometry from SQLite using "<<m_geoDbTagSvc->getParamSvcName());
        gmxInterface.buildReadoutGeometryFromSqlite(m_sqliteReadSvc.operator->(),sqlreader);
  }
  if (topVolume) { //see that a valid pointer is returned
    manager->addTreeTop(topVolume);
    doNumerology(manager);
    manager->initNeighbours();
  } else {
    ATH_MSG_FATAL("Could not find the Top Volume!!!");
    return StatusCode::FAILURE;
  }
 
  // set the manager
  m_detManager = manager;
 
  ATH_CHECK(detStore()->record(m_detManager, m_detManager->getName()));
  theExpt->addManager(m_detManager);
 
  // Create a symLink to the SiDetectorManager base class so it can be accessed as either SiDetectorManager or
  // PixelDetectorManager
  const InDetDD::SiDetectorManager *siDetManager = m_detManager;
  ATH_CHECK(detStore()->symLink(m_detManager, siDetManager));
 
  return StatusCode::SUCCESS;
}

createBaseTool()

StatusCode GeoModelXmlTool::createBaseTool ( )

protectedinherited

Definition at line 26 of file GeoModelXmlTool.cxx.

{
  ATH_CHECK(m_geoDbTagSvc.retrieve());
  ATH_CHECK(m_rdbAccessSvc.retrieve());
  ATH_CHECK(m_sqliteReadSvc.retrieve());
 
  return StatusCode::SUCCESS;
}

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.

{
  //If we have a valid sqlreader pointer, it means the volume should already exist,
  // so we don't need to create it  
  if(!sqlreader) createVolume(world, gmxInterface, vNode, tableName);
  else ATH_MSG_INFO("Using geometry from .sqlite file for"<<m_detectorName);
 
  unsigned int nChildren = world->getNChildVols();
 
  const GeoVPhysVol * envVol = nullptr;
  const GeoVPhysVol * topVol = nullptr;
 
  bool foundEnvelope = false;
  bool foundContainingDetector = false;
  // find the appropriate volume in the hierarchy, to allow it to be set as the topVolume in
  // our detectorManager
  std::string detectorName = m_detectorName; 
  //if a containingDetector is set, which the detector we are dealing with will sit inside, look for that first. 
  // Otherwise its just the name of the detector we are dealing with we look for
  if(containingDetector!="") detectorName = containingDetector;
 
  for (int iChild = nChildren - 1; iChild>=0; --iChild) {
    if (world->getNameOfChildVol(iChild) == detectorName) {
      // The * converts from a ConstPVLink to a reference to a GeoVPhysVol;
      // the & takes its address.
      envVol = &*world->getChildVol(iChild);
      foundContainingDetector = true;
      if(envelopeName=="") {topVol = envVol;break;}
      unsigned int nGrandchildren = envVol->getNChildVols();    
    for (int iGchild = nGrandchildren - 1; iGchild>=0; --iGchild) {
     if (envVol->getNameOfChildVol(iGchild) == envelopeName) {  
      topVol = &*(envVol->getChildVol(iGchild));
      foundEnvelope = true;
      break;
     }
    }
   }
  }
  if(containingDetector!="" && !foundContainingDetector) ATH_MSG_ERROR("Couldn't find the containing detector "<<containingDetector<<" in the world hierarchy!");
  else if(envelopeName!="" && !foundEnvelope) ATH_MSG_ERROR("Couldn't find the envelope volume "<<envelopeName<<" in the world hierarchy!");
  return topVol;
}

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.

                                                                                                                                          {
  int flags{};
  std::string gmxInput;
 
  if (m_gmxFilename.empty()) {
    ATH_MSG_INFO("Getting " << m_detectorName.value() << " GeoModelXml description from the geometry database");
    flags = 0x1; // Lowest bit ==> string; next bit implies gzip'd but we decided not to gzip
    // how to propagate these to here best...?
    gmxInput = getBlob(vNode,tableName);
    if (gmxInput.empty()) { // Invalid blob?
      std::string errMessage("GeoModelXmlTool::createTopVolume: Empty response received from the database.");
      throw std::runtime_error(errMessage);
    }
  } else {
    flags = 0;
    gmxInput = PathResolver::find_file(m_gmxFilename, "DATAPATH");
    ATH_MSG_INFO("Getting " << m_detectorName.value() << " GeoModelXml description from file "<<gmxInput);
    if (gmxInput.empty()) { // File not found
      std::string errMessage("GeoModelXmlTool::createTopVolume: Unable to find file " + m_gmxFilename +
                             " with PathResolver; check filename and DATAPATH environment variable");
      throw std::runtime_error(errMessage);
    }
  }
 
  // Use the DTD from GeoModel
  if (m_gmxFilename.empty()) {
    std::string replacementName = "GeoModelXml/";
    //now, work out the specific dtd version in the input .gmx
    std::string startdelim = "SYSTEM \"";
    std::string enddelim = "\" [";
    unsigned startpos = gmxInput.find(startdelim) + startdelim.length();
    unsigned endpos = gmxInput.find(enddelim);
    std::string searchName = gmxInput.substr(startpos,(endpos - startpos));
    if(searchName=="geomodel.dtd") replacementName+="geomodel_v0.dtd"; //used in xml for initial geometry tags - special case
    else replacementName+=searchName;
    ATH_MSG_DEBUG("Searching for "<<searchName<<" and replacing it with "<<replacementName);
    size_t chars = searchName.length();
    size_t index = gmxInput.find(searchName);
    if(m_dtdName!="")  replacementName=m_dtdName; //allow overriding of dtd version
    if (index != std::string::npos) {
        std::string dtdFile = PathResolver::find_file(replacementName, "DATAPATH");
        ATH_MSG_DEBUG("dtdFile = " << dtdFile);  
        gmxInput.replace(index,chars, dtdFile);
    } else {  
      throw std::runtime_error("GeoModelXmlTool::createTopVolume: Did not find valid .dtd in the gmx input string.");
    }
  }
 
  // optionally dump to local file for examination
  if (m_clobOutputFileName != "") {
    std::ofstream out(m_clobOutputFileName);
    if (m_gmxFilename.empty()) {
      out << gmxInput;
    } else {
      std::ifstream in(gmxInput);
      out << in.rdbuf();
    }
    out.close();
  }
  gmxInterface.enableLogVolDeDuplication(m_deduplicateLogVol);
  gmxInterface.enablePhysVolDeDuplication(m_deduplicatePhysVol);
  gmxInterface.enableShapeDeDuplication(m_deduplicateShape);
  gmxInterface.enableTransformDeDuplication(m_deduplicateTransf);
 
  Gmx2Geo gmx2Geo(gmxInput, world, gmxInterface, flags);  
}

doNumerology()

void PixelDetectorTool::doNumerology ( InDetDD::PixelDetectorManager *  manager )

private

Definition at line 130 of file ml/src/PixelDetectorTool.cxx.

{
  ATH_MSG_INFO( "\n\nPixel Numerology:\n===============\n\nNumber of parts is " << m_moduleTree.nParts() );
  InDetDD::SiNumerology n;
 
  bool barrelDone = false;
  for (int b = -1; b <= 1; ++b) {
      if (m_moduleTree.count(b)) {
          msg(MSG::INFO) << "    Found barrel with index " << b << std::endl;
          n.addBarrel(b);
          if (!barrelDone) {
              n.setNumLayers(m_moduleTree[b].nLayers());
              msg(MSG::INFO) << "        Number of barrel layers = " << n.numLayers() << std::endl;
              for (LayerDisk::iterator l = m_moduleTree[b].begin(); l != m_moduleTree[b].end(); ++l) {
                  n.setNumEtaModulesForLayer(l->first, l->second.nEtaModules());
                  // All staves within a layer are assumed identical, so we can just look at the first eta
                  n.setNumPhiModulesForLayer(l->first, l->second.begin()->second.nPhiModules());
                  msg(MSG::INFO) << "        layer = " << l->first << " has " << n.numEtaModulesForLayer(l->first) <<
                                    " etaModules each with " <<  n.numPhiModulesForLayer(l->first) << " phi modules" << std::endl;
              }
              barrelDone = true;
          }
      }
 
  }
 
  bool endcapDone = false;
  for (int ec = -2; ec <= 2; ec += 4) {
      if (m_moduleTree.count(ec)) {
          msg(MSG::INFO) << "    Found endcap with index " << ec << std::endl;
          n.addEndcap(ec);
          if (!endcapDone) {
              n.setNumDiskLayers(m_moduleTree[ec].nLayers());
              msg(MSG::INFO) << "        Number of endcap layers = " << n.numDiskLayers() << std::endl;
              for (LayerDisk::iterator l = m_moduleTree[ec].begin(); l != m_moduleTree[ec].end(); ++l) {
                  n.setNumDisksForLayer(l->first, l->second.nEtaModules());
                  msg(MSG::INFO) << "        Layer " << l->first << " has " << n.numDisksForLayer(l->first) << " disks" << std::endl;
                  for (EtaModule::iterator eta = l->second.begin(); eta != l->second.end(); ++eta) {
                      n.setNumPhiModulesForLayerDisk(l->first, eta->first, eta->second.nPhiModules());
                      msg(MSG::DEBUG) << "            Disk " << eta->first << " has " <<
                                          n.numPhiModulesForLayerDisk(l->first, eta->first) << " phi modules" << std::endl;
                  }
              }
              endcapDone = true;
          }
      }
  }
 
  msg(MSG::INFO) << endmsg;
 
  int totalWafers = 0;
  for (BarrelEndcap::iterator bec = m_moduleTree.begin(); bec != m_moduleTree.end(); ++bec) {
      for (LayerDisk::iterator ld = bec->second.begin(); ld != bec->second.end(); ++ld) {
          for (EtaModule::iterator eta = ld->second.begin(); eta != ld->second.end(); ++eta) {
              for (PhiModule::iterator phi = eta->second.begin(); phi != eta->second.end(); ++phi) {
                  for (Side::iterator side =phi->second.begin(); side != phi->second.end(); ++side) {
                      totalWafers++;
                  }
              }
          }
      }
  }
  ATH_MSG_INFO("Total number of wafers added is " << totalWafers);
  const PixelID *pixelIdHelper = dynamic_cast<const PixelID *> (m_commonItems->getIdHelper());
  ATH_MSG_INFO("Total number of wafer identifiers is " << pixelIdHelper->wafer_hash_max());
 
  //    Used in digitization to create one vector big enough to hold all pixels
  n.setMaxNumEtaCells(1);
  for (int d = 0; d < manager->numDesigns(); ++d) {
    n.setMaxNumPhiCells(manager->getPixelDesign(d)->rows());
    n.setMaxNumEtaCells(manager->getPixelDesign(d)->columns());
  }
  ATH_MSG_INFO("Max. eta cells is " << n.maxNumEtaCells());
  ATH_MSG_INFO("Max. phi cells is " << n.maxNumPhiCells());
 
  manager->numerology() = n;
 
  ATH_MSG_INFO("End of numerology\n");
}

getBlob()

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

protectedinherited

Definition at line 94 of file GeoModelXmlTool.cxx.

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

getSqliteReader()

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

protectedinherited

Definition at line 174 of file GeoModelXmlTool.cxx.

                                                              {
  return m_geoDbTagSvc->getSqliteReader();
}

isAvailable()

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

protectedinherited

Definition at line 78 of file GeoModelXmlTool.cxx.

{
  if (m_gmxFilename.empty()) {
    DecodeVersionKey versionKey(&*m_geoDbTagSvc, vNode);
    const std::string& versionTag  = versionKey.tag();
    const std::string& versionNode = versionKey.node();
    const std::string version = m_rdbAccessSvc->getChildTag(tableName, versionTag, versionNode);
    if (version.empty()) {
      return false;
    }
    ATH_MSG_INFO("Using " << version << " from " << versionNode << " tag " << versionTag);
  }
 
  return true;
}

manager() [1/2]

GeoVDetectorManager * GeoModelTool::manager ( )

virtualinherited

The Detector Node corresponding to this tool.

Definition at line 21 of file GeoModelTool.cxx.

                                           {
  return m_detector;
}

manager() [2/2]

const GeoVDetectorManager * GeoModelTool::manager ( ) const

virtualinherited

Definition at line 24 of file GeoModelTool.cxx.

                                                       {
  return m_detector;
}

Member Data Documentation

m_alignable

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

private

Definition at line 42 of file ml/PixelGeoModelXml/PixelDetectorTool.h.

m_alignmentFolderName

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

private

Definition at line 44 of file ml/PixelGeoModelXml/PixelDetectorTool.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::PixelDetectorTool::m_commonItems {}

private

Definition at line 39 of file ml/PixelGeoModelXml/PixelDetectorTool.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::PixelDetectorManager* ITk::PixelDetectorTool::m_detManager {}

private

Definition at line 38 of file ml/PixelGeoModelXml/PixelDetectorTool.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::PixelDetectorTool::m_geometryDBSvc {this,"GeometryDBSvc","InDetGeometryDBSvc",""}

private

Definition at line 47 of file ml/PixelGeoModelXml/PixelDetectorTool.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_moduleTree

WaferTree ITk::PixelDetectorTool::m_moduleTree

private

Definition at line 40 of file ml/PixelGeoModelXml/PixelDetectorTool.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.

---

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

• ml/PixelGeoModelXml/PixelDetectorTool.h
• ml/src/PixelDetectorTool.cxx