ActsTrk::MuonDetectorBuilderTool Class Reference

#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 66 of file MuonDetectorBuilderTool.cxx.

                                                                                                                            :
        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 317 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 77 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{}.setLayer(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{}.setVolume(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 188 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{}.setLayer(chId.first).setVolume(chId.second).setBoundary(mdtId).setSensitive(++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();
                mlCfg.mlBinning = {Acts::Experimental::ProtoBinning(Acts::BinningValue::binY, Acts::AxisBoundaryType::Bound,                   
                                                                    -mdtBounds->get(BoundsV::eHalfLengthXnegY), 
                                                                     mdtBounds->get(BoundsV::eHalfLengthXposY), 
                                                                     std::lround(2*mdtBounds->get(BoundsV::eHalfLengthXposY)/parameters.tubePitch), 0u), 
                                    Acts::Experimental::ProtoBinning(Acts::BinningValue::binZ, Acts::AxisBoundaryType::Bound,                   
                                                                    -mdtBounds->get(BoundsV::eHalfLengthY), 
                                                                     mdtBounds->get(BoundsV::eHalfLengthY), 
                                                                     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{}.setLayer(chId.first).setVolume(chId.second).setBoundary(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{}.setLayer(chId.first).setVolume(chId.second).setSensitive(++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 263 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{}.setVolume(29).setSensitive(totalMaterials));
        return surface;
    }

getMaterial()

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

private

Definition at line 282 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 303 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 69 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 328 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{}.setVolume(30).setSensitive(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:

• MuonDetectorBuilderTool.h
• MuonDetectorBuilderTool.cxx