#include <MuonDetectorBuilderTool.h>

Inheritance diagram for ActsTrk::MuonDetectorBuilderTool:

Collaboration diagram for ActsTrk::MuonDetectorBuilderTool:

Public Member Functions
	MuonDetectorBuilderTool (const std::string &type, const std::string &name, const IInterface *parent)
	Standard tool constructor. More...

virtual	~MuonDetectorBuilderTool ()=default

StatusCode	initialize () override final

Acts::Experimental::DetectorComponent	construct (const Acts::GeometryContext &context) const override final

Private Types
using	BlendedBoundSet = ActsTrk::SurfaceBoundSet< Acts::TrapezoidBounds >

using	MaterialPtr = GeoIntrusivePtr< const GeoMaterial >

Private Member Functions
void	processPassiveNodes (const ActsGeometryContext &gctx, const GeoChildNodeWithTrf &node, const std::string &name, std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume >> &passiveVolumes, const GeoTrf::Transform3D &transform) const

std::shared_ptr< Acts::Surface >	getChamberMaterial (const MuonGMR4::Chamber &chamber, const Amg::Transform3D &chamberTransform, const int totalMaterials, BlendedBoundSet &boundSet) const

std::pair< std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume > >, std::vector< std::shared_ptr< Acts::Surface > > >	constructElements (const ActsGeometryContext &gctx, const MuonGMR4::Chamber &mChamber, std::pair< unsigned int, unsigned int > chId) const

bool	checkDummyMaterial (const PVConstLink &vol) const

void	getMaterialContent (const PVConstLink &vol, std::vector< std::pair< MaterialPtr, double >> &materialContent) const

std::pair< MaterialPtr, double >	getMaterial (const PVConstLink &vol) const

Private Attributes
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}

ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Gaudi::Property< bool >	m_dumpDetector {this, "dumpDetector", false, "If set to true the entire MS system are dumped into a visualization file format, will take a long time with sensitives"}

Gaudi::Property< bool >	m_dumpPassive {this, "dumpPassive", false, "If set to true the passive volumes are dumped into a visualization file format"}

Gaudi::Property< bool >	m_dumpDetectorVolumes {this, "dumpDetectorVolumes", false, "If set to true the detector volumes are dumped into a visualization file format, will take a long time with sensitives"}

Gaudi::Property< bool >	m_dumpMaterialSurfaces {this, "dumpMaterialSurfaces", false, "If set to true the material surfaces are dumped into a visualization file format"}

Gaudi::Property< bool >	m_buildSensitives {this, "BuildSensitives", true, "If set to true all sensitive elements are built"}

Detailed Description

Definition at line 19 of file MuonDetectorBuilderTool.h.

Member Typedef Documentation

◆ BlendedBoundSet

using ActsTrk::MuonDetectorBuilderTool::BlendedBoundSet = ActsTrk::SurfaceBoundSet<Acts::TrapezoidBounds>

private

Definition at line 40 of file MuonDetectorBuilderTool.h.

◆ MaterialPtr

using ActsTrk::MuonDetectorBuilderTool::MaterialPtr = GeoIntrusivePtr<const GeoMaterial>

private

Definition at line 66 of file MuonDetectorBuilderTool.h.

Constructor & Destructor Documentation

◆ MuonDetectorBuilderTool()

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

Standard tool constructor.

Definition at line 67 of file MuonDetectorBuilderTool.cxx.

67 :

68 base_class(type, name, parent){}

◆ ~MuonDetectorBuilderTool()

virtual ActsTrk::MuonDetectorBuilderTool::~MuonDetectorBuilderTool ( )

virtualdefault

Member Function Documentation

◆ checkDummyMaterial()

bool ActsTrk::MuonDetectorBuilderTool::checkDummyMaterial ( const PVConstLink & vol ) const

private

Definition at line 324 of file MuonDetectorBuilderTool.cxx.

                                                                                  {
        static const std::unordered_set<std::string> dummyMaterials{
             "special::Ether", 
             "WorldLog::Air", 
             "std::Air", 
             "Air"
         };
        const std::string materialName = vol->getLogVol()->getMaterial()->getName();
        return dummyMaterials.find(materialName) != dummyMaterials.end();
     }

◆ construct()

Acts::Experimental::DetectorComponent ActsTrk::MuonDetectorBuilderTool::construct ( const Acts::GeometryContext & context ) const

finaloverride

Definition at line 78 of file MuonDetectorBuilderTool.cxx.

                                                                                                                 {
         ATH_MSG_DEBUG("Building Muon Detector Volume");
         const MuonChamberSet chambers = m_detMgr->getAllChambers();
         const ActsGeometryContext* gctx = context.get<const ActsGeometryContext* >();
         std::vector< volumePtr > detectorVolumeBoundingVolumes{};
         std::vector< volumePtr > detectorVolumePassiveVolumes{};
  
         detectorVolumeBoundingVolumes.reserve(chambers.size());
         std::vector<surfacePtr> surfaces{};
         std::vector<surfacePtr> materialSurfaces{};
  
         auto portalGenerator = Acts::Experimental::defaultPortalAndSubPortalGenerator();
         unsigned int numChambers = chambers.size();
  
         BlendedBoundSet materialBounds{};
         for(const MuonGMR4::Chamber* chamber : chambers){
             unsigned int num = 0;
             //Gather the passives in each chamber
             surfacePtr material{getChamberMaterial(*chamber, chamber->localToGlobalTrans(*gctx), materialSurfaces.size(), materialBounds)};
             std::shared_ptr<Acts::TrapezoidVolumeBounds> bounds = chamber->bounds();
             materialSurfaces.push_back(material);
             std::pair<std::vector<volumePtr>, std::vector<surfacePtr>> readoutElements = 
                 constructElements(*gctx, *chamber, std::make_pair(numChambers,num));
             readoutElements.second.push_back(material);
             volumePtr detectorVolume = Acts::Experimental::DetectorVolumeFactory::construct(portalGenerator, 
                                                                                             gctx->context(), 
                                                                                             chamber->identString(),
                                                                                             chamber->localToGlobalTrans(*gctx), 
                                                                                             bounds, readoutElements.second, 
                                                                                             readoutElements.first, 
                                                                                             Acts::Experimental::tryAllSubVolumes(), 
                                                                                             Acts::Experimental::tryAllPortalsAndSurfaces());
  
             detectorVolume->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(numChambers--));
             if(m_dumpDetectorVolumes){
                 //If we want to view each volume independently                
                 Acts::ObjVisualization3D helper;
                 Acts::GeometryView3D::drawDetectorVolume(helper, *detectorVolume, gctx->context());
                 helper.write(objFileName(chamber->identString()));
                 helper.clear();
             }
             detectorVolumeBoundingVolumes.push_back(std::move(detectorVolume));
             readoutElements.first.clear();
             readoutElements.second.clear();
         }
  
         if(m_dumpMaterialSurfaces){
             Acts::ObjVisualization3D helper;
             for (const auto& surf : materialSurfaces){
                 Acts::GeometryView3D::drawSurface(helper, *surf, gctx->context());
             }
             helper.write("materialSurfaces.obj");
             helper.clear();
         }
  
         ATH_MSG_VERBOSE("Number of detector volumes: "<< detectorVolumeBoundingVolumes.size());
         ATH_MSG_VERBOSE("Number of chamber passives volumes: "<< detectorVolumePassiveVolumes.size());
         std::vector<GeoChildNodeWithTrf> childNodes = getChildrenWithRef(m_detMgr->getTreeTop(0), false);
         std::set<std::string> skipNodes{"MuonBarrel", "NSW", "MuonEndcap_sideA", "MuonEndcap_sideC","TGCSystem"};
         for (const GeoChildNodeWithTrf& node : childNodes){
             //These are taken care of in the chambers
             if(skipNodes.count(node.nodeName)) {
                 ATH_MSG_VERBOSE("Skipping volume "<<node.nodeName);
                 continue;
             }
             ATH_MSG_VERBOSE("Processing passive node "<<node.nodeName);
             // processPassiveNodes(*gctx, node, node.nodeName, detectorVolumePassiveVolumes, node.transform);
         }
         ATH_MSG_VERBOSE("Number of total passive volumes: "<< detectorVolumePassiveVolumes.size());
  
         if (m_dumpPassive){
             ATH_MSG_VERBOSE("Writing passiveVolumes.obj");
             Acts::ObjVisualization3D helper;
             for (const auto& vol : detectorVolumePassiveVolumes){
                 Acts::GeometryView3D::drawDetectorVolume(helper, *vol, gctx->context());
             }     
             helper.write(objFileName("passiveVolumes"));
             helper.clear();
         }
  
         //Add the passive volumes to the end of detectorVolumeBoundingVolumes
         detectorVolumeBoundingVolumes.insert(detectorVolumeBoundingVolumes.end(), detectorVolumePassiveVolumes.begin(), detectorVolumePassiveVolumes.end());
  
         std::unique_ptr<Acts::CutoutCylinderVolumeBounds> msBounds = std::make_unique<Acts::CutoutCylinderVolumeBounds>(0, 4000, 14500, 22500, 3200);
         volumePtr msDetectorVolume = Acts::Experimental::DetectorVolumeFactory::construct(
                     portalGenerator, gctx->context(), "Muon Spectrometer Envelope", 
                     Acts::Transform3::Identity(), std::move(msBounds), surfaces, 
                     detectorVolumeBoundingVolumes, Acts::Experimental::tryAllSubVolumes(), 
                     Acts::Experimental::tryAllPortalsAndSurfaces());
         msDetectorVolume->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(15));
  
         if (m_dumpDetector) {
             ATH_MSG_VERBOSE("Writing detector.obj");
             Acts::ObjVisualization3D helper;
             Acts::GeometryView3D::drawDetectorVolume(helper, *msDetectorVolume, gctx->context());
             helper.write(objFileName("detector"));
             helper.clear();
         }
  
         Acts::Experimental::DetectorComponent::PortalContainer portalContainer;
         for (auto [ip, p] : Acts::enumerate(msDetectorVolume->portalPtrs())) {
             portalContainer[ip] = p;
         }
         detectorVolumeBoundingVolumes.push_back(msDetectorVolume);
         return Acts::Experimental::DetectorComponent{
         {detectorVolumeBoundingVolumes},
         portalContainer,
         {{msDetectorVolume}, Acts::Experimental::tryAllSubVolumes()}};
     }

◆ constructElements()

std::pair< std::vector< volumePtr >, std::vector< surfacePtr > > ActsTrk::MuonDetectorBuilderTool::constructElements	(	const ActsGeometryContext &	gctx,
		const MuonGMR4::Chamber &	mChamber,
		std::pair< unsigned int, unsigned int >	chId
	)		const

private

Definition at line 189 of file MuonDetectorBuilderTool.cxx.

                                                                                               {
     
     std::vector<volumePtr> readoutDetectorVolumes{};
     std::vector<surfacePtr> readoutSurfaces{}; 
     if(!m_buildSensitives) return std::make_pair(readoutDetectorVolumes, readoutSurfaces);
     Acts::GeometryIdentifier::Value surfId{1};
     Acts::GeometryIdentifier::Value mdtId{1};
  
     const MuonGMR4::Chamber::ReadoutSet& readoutElements = mChamber.readoutEles();
  
     for(const MuonGMR4::MuonReadoutElement* ele : readoutElements){
         switch (ele->detectorType()) {
             case DetectorType::Mdt: {    
                 ATH_MSG_VERBOSE("Building MultiLayer for MDT Detector Volume");
                 const auto* mdtReadoutEle = static_cast<const MuonGMR4::MdtReadoutElement*>(ele);
                 const MuonGMR4::MdtReadoutElement::parameterBook& parameters{mdtReadoutEle->getParameters()};
                 std::vector<surfacePtr> surfaces{};
                 //loop over the tubes to get the surfaces  
                 for(unsigned int lay=1; lay<=mdtReadoutEle->numLayers(); ++lay){
                     for(unsigned int tube=1; tube<=mdtReadoutEle->numTubesInLay(); ++tube){
                         const IdentifierHash measHash{mdtReadoutEle->measurementHash(lay,tube)};
                         if (!mdtReadoutEle->isValid(measHash)) continue;         
                         surfacePtr surface = mdtReadoutEle->surfacePtr(measHash);  
                         surface->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(chId.first).withVolume(chId.second).withBoundary(mdtId).withSensitive(++surfId));
                         surfaces.push_back(surface);
                     }
                 }
        
                 //Get the transformation to the chamber's frame
                 const Amg::Vector3D toChamber = mChamber.globalToLocalTrans(gctx)*mdtReadoutEle->center(gctx);
                 const Acts::Transform3 mdtTransform = mChamber.localToGlobalTrans(gctx) * Amg::getTranslate3D(toChamber);       
  
                 Acts::Experimental::MultiWireStructureBuilder::Config mlCfg{};  
                 mlCfg.name = m_idHelperSvc->toStringDetEl(mdtReadoutEle->identify());
                 mlCfg.mlSurfaces = std::move(surfaces);
                 mlCfg.transform = mdtTransform;      
                 auto mdtBounds = std::make_unique<Acts::TrapezoidVolumeBounds>(parameters.shortHalfX, parameters.longHalfX, parameters.halfY, parameters.halfHeight);
                 using BoundsV = Acts::TrapezoidVolumeBounds::BoundValues;
                 mlCfg.mlBounds= mdtBounds->values();
                 Acts::ProtoAxis a1(Acts::AxisDirection::AxisY, 
                                  Acts::AxisBoundaryType::Bound,                   
                                    -mdtBounds->get(BoundsV::eHalfLengthXnegY), 
                                    mdtBounds->get(BoundsV::eHalfLengthXposY), 
                                   std::lround(2*mdtBounds->get(BoundsV::eHalfLengthXposY)/parameters.tubePitch));
  
                 mlCfg.mlBinning = {{{Acts::AxisDirection::AxisY, Acts::AxisBoundaryType::Bound,                   
                                      -mdtBounds->get(BoundsV::eHalfLengthXnegY), 
                                      mdtBounds->get(BoundsV::eHalfLengthXposY), 
                                      static_cast<std::size_t>(std::lround(2*mdtBounds->get(BoundsV::eHalfLengthXposY)/parameters.tubePitch))}, 0u}, 
                                    {{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound,                   
                                      -mdtBounds->get(BoundsV::eHalfLengthY), 
                                      mdtBounds->get(BoundsV::eHalfLengthY), 
                                      static_cast<std::size_t>(std::lround(2*mdtBounds->get(BoundsV::eHalfLengthY)/parameters.tubePitch))}, 0u}};
  
                 Acts::Experimental::MultiWireStructureBuilder mdtBuilder(mlCfg);
                 volumePtr mdtVolume = mdtBuilder.construct(gctx.context()).volumes[0];
                 mdtVolume->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(chId.first).withVolume(chId.second).withBoundary(mdtId++));
                 readoutDetectorVolumes.push_back(mdtVolume); 
                 break;
             } case DetectorType::Rpc: 
               case DetectorType::Tgc:
               case DetectorType::sTgc:
               case DetectorType::Mm: {
                 ATH_MSG_VERBOSE("Building plane surfaces "<<m_idHelperSvc->toStringDetEl(ele->identify()));
                 std::vector<surfacePtr> detSurfaces = ele->getSurfaces();
                 for (surfacePtr& surf : detSurfaces) {
                     surf->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(chId.first).withVolume(chId.second).withSensitive(++surfId));
                     readoutSurfaces.push_back(std::move(surf));
                 } 
                 break;          
             } default:
                 THROW_EXCEPTION("Unknown detector type "<<ActsTrk::to_string(ele->detectorType()));
         }
     }
  
     return std::make_pair(std::move(readoutDetectorVolumes), std::move(readoutSurfaces));
  
     }

◆ getChamberMaterial()

surfacePtr ActsTrk::MuonDetectorBuilderTool::getChamberMaterial	(	const MuonGMR4::Chamber &	chamber,
		const Amg::Transform3D &	chamberTransform,
		const int	totalMaterials,
		BlendedBoundSet &	boundSet
	)		const

private

Definition at line 270 of file MuonDetectorBuilderTool.cxx.

                                                                                             {
         std::shared_ptr<const Acts::PlanarBounds> bounds = boundSet.make_bounds(chamber.halfXShort(), chamber.halfXLong(), chamber.halfY());
         const float thickness = chamber.halfZ() * 2;
         PVConstLink parentVolume = chamber.readoutEles().front()->getMaterialGeom()->getParent();
         std::pair<MaterialPtr, double> geoMaterials = getMaterial(parentVolume);
         const Acts::Material aMat = Acts::GeoModel::geoMaterialConverter(*geoMaterials.first);
         //rotate about the z axis
         std::shared_ptr<Acts::PlaneSurface> surface = Acts::Surface::makeShared<Acts::PlaneSurface>(chamberTransform, bounds);
         Acts::MaterialSlab slab{aMat, thickness};
         std::shared_ptr<Acts::HomogeneousSurfaceMaterial> material = std::make_shared<Acts::HomogeneousSurfaceMaterial>(slab);
         surface->assignSurfaceMaterial(material);
         surface->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(29).withSensitive(totalMaterials));
         return surface;
     }

◆ getMaterial()

std::pair< MuonDetectorBuilderTool::MaterialPtr, double > ActsTrk::MuonDetectorBuilderTool::getMaterial ( const PVConstLink & vol ) const

private

Definition at line 289 of file MuonDetectorBuilderTool.cxx.

                                                                          {
         std::vector<std::pair<MaterialPtr, double>> materialContent{};
         getMaterialContent(vol, materialContent);
  
         //blend the material
         double totalVolume{0.};
         double totalMass{0.};
         for(const auto& [material, volume] : materialContent){
             totalVolume += volume;
             totalMass += volume * material->getDensity();
         }
  
         //create the new GeoMaterial object
         auto blendedMaterial = make_intrusive<GeoMaterial>("BlendedMaterial", totalMass/totalVolume);
         for(const auto& [material, volume] : materialContent){
             blendedMaterial->add(material, material->getDensity() * volume / totalMass);
         }
         blendedMaterial->lock();
         return {blendedMaterial, totalVolume};
     }

◆ getMaterialContent()

void ActsTrk::MuonDetectorBuilderTool::getMaterialContent	(	const PVConstLink &	vol,
		std::vector< std::pair< MaterialPtr, double >> &	materialContent
	)		const

private

Definition at line 310 of file MuonDetectorBuilderTool.cxx.

                                                                                                                                            {
         double volume{0.};
         if(!checkDummyMaterial(vol)) volume = vol->getLogVol()->getShape()->volume();
         for(std::size_t c=0; c < vol->getNChildVols(); ++c){
             const PVConstLink child = vol->getChildVol(c);
             double childVol = child->getLogVol()->getShape()->volume();
             //dummy material does not contribute
             if(!checkDummyMaterial(child)) volume -= childVol;
             getMaterialContent(child, materialContent);
         }
         //skip dummy materials
         if(!checkDummyMaterial(vol)) materialContent.emplace_back(vol->getLogVol()->getMaterial(), volume);
     }

◆ initialize()

StatusCode ActsTrk::MuonDetectorBuilderTool::initialize ( )

finaloverride

Definition at line 70 of file MuonDetectorBuilderTool.cxx.

                                                    {
         ATH_CHECK(detStore()->retrieve(m_detMgr));
         ATH_CHECK(m_idHelperSvc.retrieve());
         ATH_MSG_DEBUG("ACTS version is: v"<< Acts::VersionMajor << "." << Acts::VersionMinor << "." << Acts::VersionPatch << " [" << Acts::CommitHash << "]");
  
         return StatusCode::SUCCESS;
     }

◆ processPassiveNodes()

void ActsTrk::MuonDetectorBuilderTool::processPassiveNodes	(	const ActsGeometryContext &	gctx,
		const GeoChildNodeWithTrf &	node,
		const std::string &	name,
		std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume >> &	passiveVolumes,
		const GeoTrf::Transform3D &	transform
	)		const

private

Definition at line 335 of file MuonDetectorBuilderTool.cxx.

                                                                                                 {
         std::vector<GeoChildNodeWithTrf> children = getChildrenWithRef(node.volume, false);
         for(const GeoChildNodeWithTrf& childNode : children){
             ATH_MSG_DEBUG("Child transform " << GeoTrf::toString(childNode.transform) << " Parent transform " << GeoTrf::toString(transform));
             ATH_MSG_DEBUG("Combined transform " << GeoTrf::toString(transform * childNode.transform));
             ATH_MSG_DEBUG("Child name " << name+"/"+childNode.nodeName);
             processPassiveNodes(gctx, childNode, name+"/"+childNode.nodeName, passiveVolumes, transform * childNode.transform);
         }
         if (!children.empty()) return;
         ATH_MSG_VERBOSE("Drawing volume named "<<name);
         const GeoShape* shape = node.volume->getLogVol()->getShape();
         const GeoMaterial* geoMaterial = node.volume->getLogVol()->getMaterial();
         const Acts::Material aMat = Acts::GeoModel::geoMaterialConverter(*geoMaterial);
         std::shared_ptr<Acts::HomogeneousVolumeMaterial> material = std::make_shared<Acts::HomogeneousVolumeMaterial>(aMat);
         ATH_MSG_DEBUG("FINAL TRANSFORM " << GeoTrf::toString(transform));
         volumePtr volume = Acts::GeoModel::convertDetectorVolume(gctx.context(), *shape, name + "_" + std::to_string(passiveVolumes.size()), transform, {});
         volume->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(30).withSensitive(passiveVolumes.size()));
         volume->assignVolumeMaterial(material);
         passiveVolumes.push_back(volume);
     }

Member Data Documentation

◆ m_buildSensitives

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_buildSensitives {this, "BuildSensitives", true, "If set to true all sensitive elements are built"}

private

Definition at line 57 of file MuonDetectorBuilderTool.h.

◆ m_detMgr

const MuonGMR4::MuonDetectorManager* ActsTrk::MuonDetectorBuilderTool::m_detMgr {nullptr}

private

Definition at line 46 of file MuonDetectorBuilderTool.h.

◆ m_dumpDetector

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_dumpDetector {this, "dumpDetector", false, "If set to true the entire MS system are dumped into a visualization file format, will take a long time with sensitives"}

private

Definition at line 49 of file MuonDetectorBuilderTool.h.

◆ m_dumpDetectorVolumes

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_dumpDetectorVolumes {this, "dumpDetectorVolumes", false, "If set to true the detector volumes are dumped into a visualization file format, will take a long time with sensitives"}

private

Definition at line 53 of file MuonDetectorBuilderTool.h.

◆ m_dumpMaterialSurfaces

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_dumpMaterialSurfaces {this, "dumpMaterialSurfaces", false, "If set to true the material surfaces are dumped into a visualization file format"}

private

Definition at line 55 of file MuonDetectorBuilderTool.h.

◆ m_dumpPassive

Gaudi::Property<bool> ActsTrk::MuonDetectorBuilderTool::m_dumpPassive {this, "dumpPassive", false, "If set to true the passive volumes are dumped into a visualization file format"}

private

Definition at line 51 of file MuonDetectorBuilderTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> ActsTrk::MuonDetectorBuilderTool::m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 47 of file MuonDetectorBuilderTool.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ BlendedBoundSet

◆ MaterialPtr

Constructor & Destructor Documentation

◆ MuonDetectorBuilderTool()

◆ ~MuonDetectorBuilderTool()

Member Function Documentation

◆ checkDummyMaterial()

◆ construct()

◆ constructElements()

◆ getChamberMaterial()

◆ getMaterial()

◆ getMaterialContent()

◆ initialize()

◆ processPassiveNodes()

Member Data Documentation

◆ m_buildSensitives

◆ m_detMgr

◆ m_dumpDetector

◆ m_dumpDetectorVolumes

◆ m_dumpMaterialSurfaces

◆ m_dumpPassive

◆ m_idHelperSvc