MuonGMR4::TgcReadoutGeomTool Class Reference

#include <TgcReadoutGeomTool.h>

Inheritance diagram for MuonGMR4::TgcReadoutGeomTool:

Collaboration diagram for MuonGMR4::TgcReadoutGeomTool:

Classes
struct	FactoryCache
struct	wTgcTable
	Helper struct to cache the essential readout parameters from the WTGC tables. More...

Public Member Functions
StatusCode	buildReadOutElements (MuonDetectorManager &mgr) override final

Private Member Functions
StatusCode	writeSectorMapping (const MuonDetectorManager &mgr) const
	Map the Tgc sectors to the classical Muon System sectors.
StatusCode	readParameterBook (FactoryCache &cache)
	Retrieves the auxillary tables from the database.
StatusCode	loadDimensions (TgcReadoutElement::defineArgs &args, FactoryCache &factory)
	Loads the chamber dimensions from GeoModel.
std::unique_ptr< WireGroupDesign >	constructWireDesign (const wTgcTable &table, const GeoTrd *gapTrd) const
	Constructs a new wire group design, if the table has wires defined.
std::unique_ptr< RadialStripDesign >	constructRadialDesign (const wTgcTable &table, const GeoTrd *gapTrd) const
	Constructs a new radial strip design, if the table contains radial strips.

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
ServiceHandle< IGeoDbTagSvc >	m_geoDbTagSvc {this, "GeoDbTagSvc", "GeoDbTagSvc"}
PublicToolHandle< IMuonGeoUtilityTool >	m_geoUtilTool {this,"GeoUtilTool", "" }

Detailed Description

Definition at line 20 of file TgcReadoutGeomTool.h.

Member Function Documentation

buildReadOutElements()

StatusCode MuonGMR4::TgcReadoutGeomTool::buildReadOutElements ( MuonDetectorManager & mgr )

finaloverride

Retrieve the list of full physical volumes & alignable nodes and connect them together afterwards

The keys should be formatted like <CHAMBERTYPE>_<STATIONNAME>_<STATIONETA>_<STATIONPHI> where CHAMBERTYPE has to start with TGC

Retrieve first the station Identifier

Definition at line 171 of file TgcReadoutGeomTool.cxx.

                                                                            {
    ATH_CHECK(m_geoDbTagSvc.retrieve());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_geoUtilTool.retrieve());
    GeoModelIO::ReadGeoModel* sqliteReader = m_geoDbTagSvc->getSqliteReader();
    if (!sqliteReader) {
        ATH_MSG_FATAL("Error, the tool works exclusively from sqlite geometry inputs");
        return StatusCode::FAILURE;
    }
    
    FactoryCache facCache{};
    ATH_CHECK(readParameterBook(facCache));
 
#ifndef SIMULATIONBASE
    auto layerBounds = std::make_shared<Acts::SurfaceBoundFactory>();
#endif    
    const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
    // Get the list of full phys volumes from SQLite, and create detector elements
    physNodeMap mapFPV = sqliteReader->getPublishedNodes<std::string, GeoFullPhysVol*>("Muon");
    for (auto& [key, pv] : mapFPV) {
        std::vector<std::string> key_tokens = tokenize(key, "_");
        if (key_tokens.size() < 4 ||
            !key_tokens[0].starts_with( "TGC"))
            continue;
        
        bool isValid{false};
        const Identifier elementID = idHelper.elementID(key_tokens[1].substr(0,3), atoi(key_tokens[2]), atoi(key_tokens[3]), isValid);
        if (!isValid){
            ATH_MSG_FATAL("Failed to construct the station Identifier from "<<key);
            return StatusCode::FAILURE;
        }        
        defineArgs define{};
        define.physVol = pv;
        define.detElId = elementID;
        define.chambDesign = key_tokens[0];
        define.alignTransform = m_geoUtilTool->findAlignableTransform(define.physVol);
#ifndef SIMULATIONBASE
        define.layerBounds = layerBounds;
#endif
        ATH_MSG_DEBUG("Key  "<<key<<" lead to Identifier "<<m_idHelperSvc->toStringDetEl(define.detElId));
        ATH_CHECK(loadDimensions(define, facCache));
        std::unique_ptr<TgcReadoutElement> readoutEle = std::make_unique<TgcReadoutElement>(std::move(define));
        ATH_CHECK(mgr.addTgcReadoutElement(std::move(readoutEle)));
    }
    ATH_CHECK(writeSectorMapping(mgr));
    return StatusCode::SUCCESS;
}

constructRadialDesign()

std::unique_ptr< RadialStripDesign > MuonGMR4::TgcReadoutGeomTool::constructRadialDesign ( const wTgcTable & table, const GeoTrd * gapTrd ) const

private

Constructs a new radial strip design, if the table contains radial strips.

Parameters

table	: Reference to the detector table entry defining the muonting points of the strips
gapTrd	Pointer to the GeoShape describing the Tgc gas gap

Definition at line 60 of file TgcReadoutGeomTool.cxx.

                                                                          {
    if (table.bottomStripPos.empty()) {
        return nullptr;
    }
    const double halfMinX = std::min(gapTrd->getYHalfLength1(), gapTrd->getYHalfLength2());
    const double halfMaxX = std::max(gapTrd->getYHalfLength1(), gapTrd->getYHalfLength2());
    const double halfY = gapTrd->getZHalfLength();
 
    auto design = std::make_unique<RadialStripDesign>();
 
    design->defineTrapezoid(halfMinX, halfMaxX, halfY);
    design->defineStripLayout(Amg::Vector2D{-halfY,0.},
                              0.,0.,table.bottomStripPos.size());
    design->flipTrapezoid();
    for (size_t s = 0; s < table.bottomStripPos.size(); ++s) {
        design->addStrip(table.bottomStripPos.at(s),
                         table.topStripPos.at(s));
    }
    return design;
}

constructWireDesign()

std::unique_ptr< WireGroupDesign > MuonGMR4::TgcReadoutGeomTool::constructWireDesign ( const wTgcTable & table, const GeoTrd * gapTrd ) const

private

Constructs a new wire group design, if the table has wires defined.

Parameters

table	: Reference to the detector table entry defining the wires per group
gapTrd	Pointer to the GeoShape describing the Tgc gas gap

Definition at line 41 of file TgcReadoutGeomTool.cxx.

                                                                        {
    if (table.wireGangs.empty()) {
        return nullptr;
    }
    const double halfMinX = std::min(gapTrd->getYHalfLength1(), gapTrd->getYHalfLength2());
    const double halfMaxX = std::max(gapTrd->getYHalfLength1(), gapTrd->getYHalfLength2());
    const double halfY = gapTrd->getZHalfLength();
    auto design = std::make_unique<WireGroupDesign>();
    design->defineTrapezoid(halfMinX, halfMaxX, halfY);
    for (unsigned gang : table.wireGangs) {
        design->declareGroup(gang); 
    }
    const double wireOffSet = -0.5*table.wirePitch * design->nAllWires();
    design->defineStripLayout(Amg::Vector2D{wireOffSet, 0.},
                              table.wirePitch, 0., table.wireGangs.size());
    return design;
}

loadDimensions()

StatusCode MuonGMR4::TgcReadoutGeomTool::loadDimensions ( TgcReadoutElement::defineArgs & args, FactoryCache & factory )

private

Loads the chamber dimensions from GeoModel.

Navigate through the GeoModel tree to find all gas volume leaves

Place the strip-readout into the readout element's sensor layouts

Wire groups measure eta & radial strips measure phi

Definition at line 82 of file TgcReadoutGeomTool.cxx.

                                                                          {
    ATH_MSG_VERBOSE("Load dimensions of "<<m_idHelperSvc->toString(define.detElId)
                     <<std::endl<<std::endl<<m_geoUtilTool->dumpVolume(define.physVol));
    const GeoShape* shape = m_geoUtilTool->extractShape(define.physVol);
    if (!shape) {
        ATH_MSG_FATAL("Failed to deduce a valid shape for "<<m_idHelperSvc->toString(define.detElId));
        return StatusCode::FAILURE;
    }
 
    if (shape->typeID() != GeoTrd::getClassTypeID()) {
        ATH_MSG_FATAL("The shape of "<<m_idHelperSvc->toStringDetEl(define.detElId)
                    <<" is expected to be a trapezoid "<<m_geoUtilTool->dumpShape(shape));
        return StatusCode::FAILURE;
    }
    const GeoTrd* chambTrd = static_cast<const GeoTrd*>(shape);
    define.halfWidthShort = std::min(chambTrd->getYHalfLength1(), chambTrd->getYHalfLength2());
    define.halfWidthLong = std::max(chambTrd->getYHalfLength1(), chambTrd->getYHalfLength2());
    define.halfHeight = chambTrd->getZHalfLength();
    define.halfThickness = chambTrd->getXHalfLength1();
    std::vector<physVolWithTrans> allGasGaps = m_geoUtilTool->findAllLeafNodesByName(define.physVol, "TgcGas");
    if (allGasGaps.empty()) {
        ATH_MSG_FATAL("The volume "<<m_idHelperSvc->toStringDetEl(define.detElId)<<" does not have any childern TgcGas"
            <<std::endl<<m_geoUtilTool->dumpVolume(define.physVol));
        return StatusCode::FAILURE;
    }
    unsigned gasGap{0};
    auto assignReadoutLayer = [&define, & gasGap, this] (const StripLayerPtr& layerReadout) {
        if (!layerReadout) {
            return StatusCode::SUCCESS;
        }
        unsigned layerIdx = static_cast<unsigned>(layerReadout->hash());
        if (layerIdx >= define.sensorLayouts.size()) {
            ATH_MSG_FATAL("The strip index "<<layerIdx<<" is out of range for gasGap "<<gasGap);
            return StatusCode::FAILURE;
        }           
        define.sensorLayouts[layerIdx] = layerReadout;
        return StatusCode::SUCCESS;
    };
    for (const physVolWithTrans& pVolTrans : allGasGaps) {
        const std::string key = std::format("{:}_{:}{:}",define.chambDesign, gasGap+1,
                                            (m_idHelperSvc->stationEta(define.detElId) > 0 ? "A" : "C"));
        StripLayerPtr& wireReadout{factoryCache.readoutLayers[key]};
        if (!wireReadout) {
            const wTgcTable& table{factoryCache.parameterBook[key]};
            if (!table.gasGap) {
                ATH_MSG_FATAL("No wTGC table could be found for "<<m_idHelperSvc->toStringDetEl(define.detElId)
                            <<" "<<define.chambDesign<<", gasGap "<<(gasGap+1));
                return StatusCode::FAILURE;
            }
            const GeoShape* gapShape = m_geoUtilTool->extractShape(pVolTrans.volume);
            if (gapShape->typeID() != GeoTrd::getClassTypeID()) {
                ATH_MSG_FATAL("Expected shape "<<m_geoUtilTool->dumpShape(gapShape)<<" to be a trapezoid");
                return StatusCode::FAILURE;
            }
            const GeoTrd* gapTrd = static_cast<const GeoTrd*>(gapShape);
            WireDesignPtr wireDesign = constructWireDesign(table, gapTrd);
            RadialStripDesignPtr radDesign = constructRadialDesign(table, gapTrd);
            if (wireDesign) {
                wireDesign = (*factoryCache.wireLayouts.insert(std::move(wireDesign)).first);
            }
            if (radDesign) {
                radDesign = (*factoryCache.stripReadouts.insert(std::move(radDesign)).first);
            }
            if (!wireReadout && wireDesign) {
                const IdentifierHash layHash = TgcReadoutElement::constructHash(0, gasGap+1, false);
                ATH_MSG_VERBOSE("Wire hash "<<layHash);
                const Amg::Transform3D trans{pVolTrans.transform 
                                             * Amg::getRotateY3D(-90.*Gaudi::Units::deg)
                                             * Amg::getRotateX3D(180.* Gaudi::Units::deg)};
                if (radDesign) {
                    wireReadout = std::make_unique<StripLayer>(factoryCache.trfNodeMaker.makeTransform(trans), 
                                                                wireDesign, radDesign, layHash);
                    wireReadout->flipPhiRotation();
                } else {
                    wireReadout = std::make_unique<StripLayer>(factoryCache.trfNodeMaker.makeTransform(trans), 
                                                                wireDesign, layHash);
                }
            } 
        }
        ATH_CHECK(assignReadoutLayer(wireReadout));
        ++gasGap;
    }
    define.nGasGaps = gasGap;        
    return StatusCode::SUCCESS;
}

readParameterBook()

StatusCode MuonGMR4::TgcReadoutGeomTool::readParameterBook ( FactoryCache & cache )

private

Retrieves the auxillary tables from the database.

Definition at line 237 of file TgcReadoutGeomTool.cxx.

                                                                    {
    ServiceHandle<IRDBAccessSvc> accessSvc(m_geoDbTagSvc->getParamSvcName(), name());
    ATH_CHECK(accessSvc.retrieve());
    IRDBRecordset_ptr paramTable = accessSvc->getRecordsetPtr("TgcSensorLayout", "");
    if (paramTable->size() == 0) {
        ATH_MSG_FATAL("Empty parameter book table found");
        return StatusCode::FAILURE;
    }
    for (const IRDBRecord_ptr& record : *paramTable) {
        const std::string chambType = record->getString("technology");
        const int gasGap = record->getInt("gasGap");
        const std::vector<int> wireGangs{tokenizeInt(record->getString("wireGangs"),",")};
        const std::vector<double> botStrips = tokenizeDouble(record->getString("bottomStrips"), ",");
        const std::vector<double> topStrips = tokenizeDouble(record->getString("topStrips"), ",");
        const std::vector<std::string> sides = tokenize(record->getString("side"), ";");
        const double wirePitch = record->getDouble("wirePitch");
        for (const std::string& side : sides) {
            const std::string key = std::format("{:}_{:}{:}", chambType, gasGap, side);
            wTgcTable& parBook{cache.parameterBook[key]};
            parBook.wireGangs.insert(parBook.wireGangs.end(), wireGangs.begin(), wireGangs.end());
            parBook.bottomStripPos = botStrips;
            parBook.topStripPos = topStrips;
            parBook.wirePitch = wirePitch;
            parBook.gasGap = gasGap;
        }
       
    }
    ATH_MSG_DEBUG("Read in total "<<cache.parameterBook.size()<<" chamber layouts");
    return StatusCode::SUCCESS;
}

writeSectorMapping()

StatusCode MuonGMR4::TgcReadoutGeomTool::writeSectorMapping ( const MuonDetectorManager & mgr ) const

private

Map the Tgc sectors to the classical Muon System sectors.

Map the Tgc sectors to the classic muon sectors

Definition at line 223 of file TgcReadoutGeomTool.cxx.

                                                                                      {
    std::vector<const TgcReadoutElement*> tgcReadOutEles = mgr.getAllTgcReadoutElements();
    std::unique_ptr<std::vector<int>> tgcSectorMapping = std::make_unique<std::vector<int>>();
    tgcSectorMapping->resize(m_idHelperSvc->tgcIdHelper().module_hash_max());
    Muon::MuonSectorMapping sectorMapping{};
    const ActsTrk::GeometryContext gctx{};
    for (const TgcReadoutElement* readoutEle : tgcReadOutEles) {
        int& sectNumb = (*tgcSectorMapping)[m_idHelperSvc->moduleHash(readoutEle->identify())];
        sectNumb = sectorMapping.getSector(readoutEle->center(gctx).phi());
    }
    ATH_CHECK(detStore()->record(std::move(tgcSectorMapping), "TGC_SectorMapping"));
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_geoDbTagSvc

ServiceHandle<IGeoDbTagSvc> MuonGMR4::TgcReadoutGeomTool::m_geoDbTagSvc {this, "GeoDbTagSvc", "GeoDbTagSvc"}

private

Definition at line 33 of file TgcReadoutGeomTool.h.

{this, "GeoDbTagSvc", "GeoDbTagSvc"};

m_geoUtilTool

PublicToolHandle<IMuonGeoUtilityTool> MuonGMR4::TgcReadoutGeomTool::m_geoUtilTool {this,"GeoUtilTool", "" }

private

Definition at line 35 of file TgcReadoutGeomTool.h.

{this,"GeoUtilTool", "" };

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonGMR4::TgcReadoutGeomTool::m_idHelperSvc

private

Initial value:

{this, "IdHelperSvc", 
                                          "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 30 of file TgcReadoutGeomTool.h.

                                                     {this, "IdHelperSvc", 
                                          "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

---

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

• TgcReadoutGeomTool.h
• TgcReadoutGeomTool.cxx