MuonDetDescr/MuonGeoModel/src/MuonDetectorTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "MuonGeoModel/MuonDetectorTool.h"
 
#include "AthenaKernel/ClassID_traits.h"
#include "AthenaPoolUtilities/CondAttrListCollection.h"
#include "GeoModelInterfaces/IGeoModelSvc.h"
#include "GeoModelInterfaces/StoredMaterialManager.h"
#include "GeoModelKernel/GeoPerfUtils.h"
#include "GeoModelKernel/GeoPhysVol.h"
#include "GeoModelUtilities/GeoModelExperiment.h"
#include "MuonDetDescrUtils/MuonSectorMapping.h"
#include "MuonGeoModel/StationSelector.h"
#include "MuonGeoModel/MuonDetectorFactory001.h"
#include "MuonGeoModel/MuonDetectorFactoryLite.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
#include "MuonReadoutGeometry/TgcReadoutElement.h"
#include "RDBAccessSvc/IRDBAccessSvc.h"
#include "RDBAccessSvc/IRDBRecord.h"
#include "RDBAccessSvc/IRDBRecordset.h"
 
#include <fstream>
 
using namespace MuonGM;

MuonDetectorTool::MuonDetectorTool(const std::string &type, const std::string &name, const IInterface *parent) : 
    GeoModelTool(type, name, parent) {
    declareInterface<IGeoModelTool>(this);
}
 
MuonDetectorTool::~MuonDetectorTool() = default;
 
StatusCode MuonDetectorTool::initialize() {
    ATH_MSG_INFO("Initializing ...");
    return StatusCode::SUCCESS;
}

StatusCode MuonDetectorTool::create() {
 
    std::ofstream geoModelStats;
    int mem{0}, umem{0};
    float cpu{0.f}, ucpu{0.f};
 
    MuonGM::MuonDetectorManager *mgr=nullptr;
    GeoModelExperiment *theExpt = nullptr;
    ATH_CHECK(detStore()->retrieve(theExpt, "ATLAS"));
    GeoIntrusivePtr<GeoPhysVol> world{theExpt->getPhysVol()};
    ATH_CHECK(createFactory(mgr, world));
 
    ATH_CHECK(detStore()->record(mgr,mgr->getName()));
    theExpt->addManager(mgr);
 
    m_manager = mgr;
 
    if (m_dumpMemoryBreakDown) {
        umem = GeoPerfUtils::getMem();
        ucpu = float(GeoPerfUtils::getCpu() / 100.);
        geoModelStats << "At MuonDetectorTool::everything done     \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = " << umem - mem
                      << " \t Delta T =" << ucpu - cpu << std::endl;
        geoModelStats.close();
    }
 
    Muon::MuonSectorMapping mapping;
    if (m_manager && m_manager->tgcIdHelper()) {
        unsigned int tgcHashMax = m_manager->tgcIdHelper()->detectorElement_hash_max();
        std::vector<int> *sectorHashVec = new std::vector<int>(tgcHashMax, 0);
        for (unsigned int i = 0; i < tgcHashMax; ++i) {
            const MuonGM::TgcReadoutElement *detEl = m_manager->getTgcReadoutElement(i);
            if (detEl)
                (*sectorHashVec)[i] = mapping.getSector(detEl->center().phi());
        }
        if (detStore()->record(sectorHashVec, "TGC_SectorMapping").isFailure()) {
            ATH_MSG_WARNING(" failed to record TGC sector mapping ");
        }
    }
    return StatusCode::SUCCESS;
}
 
StatusCode MuonDetectorTool::createFactory(MuonGM::MuonDetectorManager * & mgr, GeoPhysVol* world) const {
 
    std::ofstream geoModelStats;
    int mem{0}, umem{0};
    float cpu{0.f}, ucpu{0.f};
 
    if (m_dumpMemoryBreakDown) {
        geoModelStats.open("MuonGeoModelStatistics_MuonDetectorTool");
        mem = GeoPerfUtils::getMem();
        cpu = float(GeoPerfUtils::getCpu() / 100.);
        geoModelStats << "At MuonDetectorTool::create entry point: \t SZ= " << mem << " Kb \t Time = " << cpu << " seconds " << std::endl;
 
        umem = GeoPerfUtils::getMem();
        ucpu = float(GeoPerfUtils::getCpu() / 100.);
        geoModelStats << "At MuonDetectorTool::resetting to 0:     \t SZ= " << umem - mem << " Kb \t Time = " << ucpu - cpu << " seconds " << std::endl;
        mem = umem;
        cpu = ucpu;
    }
 
    ATH_MSG_VERBOSE(" Show properties (user sett.s or default): LayoutName                 "
                    << m_layout << endmsg << " Show properties (user sett.s or default): IncludeCutouts             " << m_includeCutouts << endmsg
                    << " Show properties (user sett.s or default): IncludeCutoutsBog          " << m_includeCutoutsBog << endmsg
                    << " Show properties (user sett.s or default): IncludeCtbBis              " << m_includeCtbBis);
 
    // Get the detector configuration.
    SmartIF<IGeoModelSvc> geoModel{Gaudi::svcLocator()->service("GeoModelSvc")};
    ATH_CHECK(geoModel.isValid());
 
    std::string AtlasVersion = geoModel->atlasVersion();
    std::string MuonVersion = geoModel->muonVersionOverride();
 
    ATH_MSG_INFO("create MuonDetectorTool");
    ATH_MSG_INFO("(from GeoModelSvc)    AtlasVersion = <" << AtlasVersion << ">  MuonVersion = <" << MuonVersion << ">");
 
    // Unless we are using custom muons, the switch positions are going to
    // come from the database:
 
    std::string detectorKey = MuonVersion.empty() ? AtlasVersion : MuonVersion;
    std::string detectorNode = MuonVersion.empty() ? "ATLAS" : "MuonSpectrometer";
    ATH_MSG_INFO("Keys for Muon Switches are  (key) " << detectorKey << " (node) " << detectorNode);
 
    std::string tempLayout = m_layout;
    std::map<std::string, std::string> altAsciiDBMap{};
 
    
    // Get the detector configuration.
    ServiceHandle<IGeoDbTagSvc> geoDbTag("GeoDbTagSvc",name());
    ATH_CHECK(geoDbTag.retrieve());
    ServiceHandle<IRDBAccessSvc> accessSvc(geoDbTag->getParamSvcName(),name());
    ATH_CHECK(accessSvc.retrieve());
    GeoModelIO::ReadGeoModel* sqliteReader = geoDbTag->getSqliteReader();
    
    if (sqliteReader) {
 
      ATH_MSG_INFO("New DD Activated; Muon detector description input from SQLITE file");
 
      MuonDetectorFactoryLite theFactory(detStore().operator->(),sqliteReader);
      theFactory.setRDBAccess(accessSvc.get());
      theFactory.create(world);  
 
 
      mgr=theFactory.getDetectorManager();
      mgr->setMinimalGeoFlag(m_minimalGeoFlag);
      mgr->setGeometryVersion(tempLayout);
      mgr->fillCache();
    
      return StatusCode::SUCCESS;
    }
    //
    // New DD:  action ends here!!
    // 
    //=====================================================
    // 
    // Old DD: action starts here:  
    //
    
    MuonDetectorFactory001 theFactory(detStore().operator->());
    theFactory.disableBEEShift(m_beeNoShiftInDefault);
 
 
    ATH_MSG_DEBUG("Detector Information coming from the database (job options IGNORED)");
 
    IRDBRecordset_ptr switchSet = accessSvc->getRecordsetPtr("MuonSwitches", detectorKey, detectorNode);
    if (switchSet->size() == 0) {
      ATH_MSG_ERROR("Failed to retrieve MuonSwitches from the database!");
      return StatusCode::FAILURE;
    }
    const IRDBRecord *switches = (*switchSet)[0];
 
    tempLayout = switches->getString("LAYOUTNAME");
    if (MuonVersion.empty()) {
      MuonVersion = accessSvc->getChildTag("MuonSpectrometer", detectorKey, detectorNode);
      ATH_MSG_INFO("(from GeoModelSvc) in AtlasVersion = <" << AtlasVersion << ">  default MuonVersion is <" << MuonVersion << ">");
    }
 
    ATH_MSG_DEBUG(" m_altAsztFile: " << m_altAsztFile);
    // use ascii file to read in ASZT parameters
    if (m_altAsztFile != "")
      altAsciiDBMap.insert(std::make_pair("ASZT", m_altAsztFile));
    if (m_altCscIntAlinesFile != "")
      altAsciiDBMap.insert(std::make_pair("IACSC", m_altCscIntAlinesFile));
 
    //
    // Locate the top level experiment node
    //
    ATH_MSG_INFO("Properties have been set as follows: " << endmsg
                                                         << "    LayoutName                     " << tempLayout.substr(0, 1) << endmsg 
                                                         << "    IncludeCutouts                 " << m_includeCutouts << endmsg 
                                                         << "    IncludeCutoutsBog              " << m_includeCutoutsBog << endmsg
                                                         << "    IncludeCtbBis                  " << m_includeCtbBis << endmsg 
                                                         << "    MinimalGeoFlag                 " << m_minimalGeoFlag << endmsg
                                                         << "    EnableCscIntAlignmentFromGM    " << m_useCscIntAlinesFromGM);
   
    if (m_stationSelection > 0) {
        StationSelector::SetSelectionType(m_stationSelection);
        if ((m_selectedStations.size() + m_selectedStEta.size() + m_selectedStPhi.size()) < 1) {
            ATH_MSG_ERROR(" **** Badly set Option " << endmsg << " **** SelectedStations size =" << m_selectedStations.size() << endmsg
                                                    << " **** SelectedStJzz    size =" << m_selectedStations.size() << endmsg
                                                    << " **** SelectedStJff    size =" << m_selectedStations.size() << endmsg << " **** while StationSelection = 1");
            return (StatusCode::FAILURE);
        }
    for (const std::string& station : m_selectedStations) {
      ATH_MSG_INFO("          Selected stations      " << station);
        }
 
    for (int stEta : m_selectedStEta) {
      ATH_MSG_INFO("          Selected Jzz locations  " << stEta);
        }
    for (int stPhi : m_selectedStPhi) {
      ATH_MSG_INFO("          Selected Jff locations  " << stPhi);
        }
    }
 
    if (m_dumpMemoryBreakDown) {
        umem = GeoPerfUtils::getMem();
        ucpu = float(GeoPerfUtils::getCpu() / 100.);
        geoModelStats << "At MuonDetectorTool::material mgr done   \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = " << umem - mem
                      << " \t Delta T =" << ucpu - cpu << std::endl;
        mem = umem;
        cpu = ucpu;
    }
 
    theFactory.setDBAtlasVersion(AtlasVersion);
    theFactory.setDBMuonVersion(MuonVersion);
    theFactory.setDBkey(detectorKey);
    theFactory.setDBnode(detectorNode);
    theFactory.setLayout(tempLayout);
    theFactory.setCutoutsFlag(m_includeCutouts);
    theFactory.setCutoutsBogFlag(m_includeCutoutsBog);
    theFactory.setCtbBisFlag(m_includeCtbBis);
    theFactory.setMinimalGeoFlag(m_minimalGeoFlag);
    theFactory.setDumpMemoryBreakDown(m_dumpMemoryBreakDown);
    theFactory.setFineClashFixingFlag(m_enableFineClashFixing);
    theFactory.hasCSC(m_hasCSC);
    theFactory.hasSTgc(m_hasSTgc);
    theFactory.hasMM(m_hasMM);
    if (m_stationSelection > 0)
      theFactory.setSelection(m_selectedStations, m_selectedStEta, m_selectedStPhi);
 
    theFactory.setRDBAccess(accessSvc.get());
    theFactory.setAltAsciiDBMap(altAsciiDBMap);
 
    theFactory.create(world);
 
    if (m_dumpMemoryBreakDown) {
      umem = GeoPerfUtils::getMem();
      ucpu = float(GeoPerfUtils::getCpu() / 100.);
      geoModelStats << "At MuonDetectorTool::factory created     \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = " << umem - mem
            << " \t Delta T =" << ucpu - cpu << std::endl;
      mem = umem;
      cpu = ucpu;
    }
 
    mgr=theFactory.getDetectorManager();
    mgr->fillCache();
    return StatusCode::SUCCESS;
}
 
StatusCode MuonDetectorTool::clear() {
    SG::DataProxy *proxy = detStore()->proxy(ClassID_traits<MuonGM::MuonDetectorManager>::ID(), m_manager->getName());
    if (proxy) {
        proxy->reset();
        m_manager = nullptr;
    }
    return StatusCode::SUCCESS;
}