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 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
void	getChamberPassives (const ActsGeometryContext &gctx, const MuonGMR4::Chamber &chamber, std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume >> &passiveVolumes) 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

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_buildSensitives {this, "BuildSensitives", true, "If set to true all sensitive elements are built"}

Detailed Description

Definition at line 15 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 61 of file MuonDetectorBuilderTool.cxx.

                                                                                                                            :
        base_class(type, name, parent){}

~MuonDetectorBuilderTool()

virtual ActsTrk::MuonDetectorBuilderTool::~MuonDetectorBuilderTool ( )

virtualdefault

Member Function Documentation

construct()

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

finaloverride

Definition at line 139 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::pair<std::vector<volumePtr>, std::vector<surfacePtr>> readoutElements; 
 
        auto portalGenerator = Acts::Experimental::defaultPortalAndSubPortalGenerator();
        unsigned int numChambers = chambers.size();
 
        for(const MuonGMR4::Chamber* chamber : chambers){
            unsigned int num = 0;
            //Gather the passives in each chamber
            getChamberPassives(*gctx, *chamber, detectorVolumePassiveVolumes);
            std::shared_ptr<Acts::TrapezoidVolumeBounds> bounds = chamber->bounds();
            readoutElements = constructElements(*gctx, *chamber, std::make_pair(numChambers,num));
            volumePtr detectorVolume = Acts::Experimental::DetectorVolumeFactory::construct(portalGenerator, 
                                                                                            gctx->context(), 
                                                                                            chamber->identString(),
                                                                                            chamber->localToGlobalTrans(*gctx), 
                                                                                            bounds, readoutElements.second, 
                                                                                            readoutElements.first, 
                                                                                            Acts::Experimental::tryRootVolumes(), 
                                                                                            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();
        }
 
        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::tryRootVolumes(), 
                    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::tryRootVolumes()}};
    }

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 237 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));
 
    }

getChamberPassives()

void ActsTrk::MuonDetectorBuilderTool::getChamberPassives ( const ActsGeometryContext &  gctx, const MuonGMR4::Chamber &  chamber, std::vector< std::shared_ptr< Acts::Experimental::DetectorVolume >> &  passiveVolumes  ) const

private

Definition at line 72 of file MuonDetectorBuilderTool.cxx.

                                                                                                 {
 
        for(const MuonGMR4::MuonReadoutElement* ele : chamber.readoutEles()){
            const GeoVFullPhysVol* readOutVol = ele->getMaterialGeom();
            PVConstLink parentVolume = readOutVol->getParent();
            const Amg::Transform3D stationTransform = parentVolume->getX();
            //Loop through the parent, skipping the fullphysvol which are the readOutElements
            const std::vector<GeoChildNodeWithTrf> children = getChildrenWithRef(parentVolume, false);
            for(const GeoChildNodeWithTrf& childNode : children){
                auto& childVol = *(childNode.volume);
                if(typeid(childVol) == typeid(GeoFullPhysVol)){
                    continue;
                }
                ATH_MSG_VERBOSE("Processing " << childNode.nodeName);
                const GeoShape* shape = childNode.volume->getLogVol()->getShape();
                if(shape->typeID() == GeoSimplePolygonBrep::getClassTypeID() or 
                   shape->typeID() == GeoShapeUnion::getClassTypeID() or
                   shape->typeID() == GeoShapeShift::getClassTypeID() or
                   shape->typeID() == GeoShapeSubtraction::getClassTypeID()){
                    //Skip these for now until https://github.com/acts-project/acts/pull/3713 is merged in
                    continue;
                }
                const GeoMaterial* geoMaterial = childNode.volume->getLogVol()->getMaterial();
                const Acts::Material aMat = Acts::GeoModel::geoMaterialConverter(*geoMaterial);
                std::shared_ptr<Acts::HomogeneousVolumeMaterial> material = std::make_shared<Acts::HomogeneousVolumeMaterial>(aMat);
                volumePtr passiveVolume = Acts::GeoModel::convertDetectorVolume(gctx.context(), *shape, "PASSIVE_"+childNode.nodeName+std::to_string(passiveVolumes.size()), childNode.transform * stationTransform, {});
                passiveVolume->assignVolumeMaterial(material);
                passiveVolume->assignGeometryId(Acts::GeometryIdentifier{}.setVolume(30).setSensitive(passiveVolumes.size()));
                passiveVolumes.push_back(passiveVolume);
            }
        }
    }

initialize()

StatusCode ActsTrk::MuonDetectorBuilderTool::initialize ( )

finaloverride

Definition at line 64 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 107 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();
        if(shape->typeID() == GeoSimplePolygonBrep::getClassTypeID() or 
            shape->typeID() == GeoShapeUnion::getClassTypeID() or
            shape->typeID() == GeoShapeShift::getClassTypeID() or
            shape->typeID() == GeoShapeSubtraction::getClassTypeID()){
            //Skip these for now until https://github.com/acts-project/acts/pull/3713 is merged in
            return;
        }
        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 49 of file MuonDetectorBuilderTool.h.

m_detMgr

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

private

Definition at line 40 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 43 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 47 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 45 of file MuonDetectorBuilderTool.h.

m_idHelperSvc

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

private

Definition at line 41 of file MuonDetectorBuilderTool.h.

---

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

• MuonDetectorBuilderTool.h
• MuonDetectorBuilderTool.cxx