MuonGM::MuonDetectorFactory001 Class Reference

#include <MuonDetectorFactory001.h>

Inheritance diagram for MuonGM::MuonDetectorFactory001:

Collaboration diagram for MuonGM::MuonDetectorFactory001:

Public Member Functions
	MuonDetectorFactory001 (StoreGateSvc *pDetStore)
	~MuonDetectorFactory001 ()
virtual void	create (GeoPhysVol *world) override
virtual const MuonDetectorManager *	getDetectorManager () const override
MuonDetectorManager *	getDetectorManager ()
void	setDBAtlasVersion (const std::string &v)
void	setDBMuonVersion (const std::string &v)
void	setDBkey (const std::string &v)
void	setDBnode (const std::string &v)
void	setLayout (const std::string &str)
void	setCutoutsFlag (int)
void	setCutoutsBogFlag (int)
void	setCtbBisFlag (int)
void	setRDBAccess (IRDBAccessSvc *access)
void	setAltAsciiDBMap (const AltAsciiDBMap &asciidbmap)
void	setUseRDB (int rdb)
void	setMinimalGeoFlag (int minimalGeo)
void	setSelection (const std::vector< std::string > &, const std::vector< int > &, const std::vector< int > &)
void	setDumpMemoryBreakDown (bool value)
void	setCacheFillingFlag (int value)
void	setMdtDeformationFlag (int mdtDeformationFlag)
void	setNswAsBuiltParaFlag (int nswAsBuiltParaFlag)
void	setFineClashFixingFlag (int value)
void	hasCSC (bool value)
void	hasSTgc (bool value)
void	hasMM (bool value)
void	setNSWAsBuiltAsciiPath (const std::string &, const std::string &)
void	disableBEEShift (bool flag)
bool	BEEShiftDisabled () const

Private Types
typedef std::map< std::string, std::string >	AltAsciiDBMap

Private Attributes
std::string	m_DBAtlasVersion {}
std::string	m_DBMuonVersion {}
std::string	m_DBkey {}
std::string	m_DBnode {}
std::string	m_layout {}
int	m_includeCutouts {0}
int	m_includeCutoutsBog {0}
int	m_includeCtbBis {0}
int	m_rdb {1}
int	m_minimalGeoFlag {0}
bool	m_dumpMemoryBreakDown {false}
int	m_enableFineClashFixing {0}
bool	m_hasCSC {true}
bool	m_hasSTgc {true}
bool	m_hasMM {true}
bool	m_disableBEEShift {false}
std::vector< std::string >	m_selectedStations
std::vector< int >	m_selectedStEta
std::vector< int >	m_selectedStPhi
std::unique_ptr< MuonSystemDescription >	m_muon
MuonDetectorManager *	m_manager {nullptr}
StoreGateSvc *	m_pDetStore {nullptr}
IRDBAccessSvc *	m_pRDBAccess {nullptr}
AltAsciiDBMap	m_altAsciiDBMap {}

Detailed Description

Definition at line 21 of file MuonDetectorFactory001.h.

Member Typedef Documentation

AltAsciiDBMap

typedef std::map<std::string, std::string> MuonGM::MuonDetectorFactory001::AltAsciiDBMap

private

Definition at line 23 of file MuonDetectorFactory001.h.

Constructor & Destructor Documentation

MuonDetectorFactory001()

MuonGM::MuonDetectorFactory001::MuonDetectorFactory001

(

StoreGateSvc *

pDetStore

)

Definition at line 71 of file MuonDetectorFactory001.cxx.

                                                                         :
        m_muon (std::make_unique< MuonSystemDescription>("MuonSystem")),
        m_pDetStore{pDetStore} {
        m_muon->barrelInnerRadius = 4.30 * Gaudi::Units::m;
        m_muon->innerRadius = 0.07 * Gaudi::Units::m;
        m_muon->outerRadius = 13.00 * Gaudi::Units::m;
        m_muon->endcapFrontFace = 6.74 * Gaudi::Units::m;
        m_muon->length = 22.03 * Gaudi::Units::m;
        m_muon->barreLength = 6.53 * Gaudi::Units::m;
        m_muon->barrelInterRadius = 3.83 * Gaudi::Units::m;
        m_muon->extraZ = 12.9 * Gaudi::Units::m;
        m_muon->extraR = 12.5 * Gaudi::Units::m;
 
        MsgStream log(Athena::getMessageSvc(), "MuonGeoModel");
        log << MSG::INFO << "MuonDetectorFactory - constructor "
            << " MuonSystem OuterRadius " << m_muon->outerRadius << " Length " << m_muon->length << endmsg;
    }

~MuonDetectorFactory001()

MuonGM::MuonDetectorFactory001::~MuonDetectorFactory001 ( )

default

Member Function Documentation

BEEShiftDisabled()

bool MuonGM::MuonDetectorFactory001::BEEShiftDisabled ( ) const

inline

Definition at line 133 of file MuonDetectorFactory001.h.

{ return m_disableBEEShift;}

create()

void MuonGM::MuonDetectorFactory001::create ( GeoPhysVol * world )

overridevirtual

Definition at line 94 of file MuonDetectorFactory001.cxx.

                                                         {
        MsgStream log(Athena::getMessageSvc(), "MuGM:MuonFactory");
 
        int mem = 0;
        float cpu = 0;
        int umem = 0;
        float ucpu = 0;
        std::ofstream geoModelStats;
        if (m_dumpMemoryBreakDown) {
            geoModelStats.open("MuonGeoModelStatistics_MuonDetectorFactory");
 
            mem = GeoPerfUtils::getMem();
            cpu = int(GeoPerfUtils::getCpu() / 100.);
 
            geoModelStats << "At MuonDetectorFactory::create entry point: \t SZ= " << mem << " Kb \t Time = " << cpu << " seconds " << std::endl;
 
            umem = GeoPerfUtils::getMem();
            ucpu = int(GeoPerfUtils::getCpu() / 100.);
            geoModelStats << "At MuonDetectorFactory::resetting to 0:     \t SZ= " << umem - mem << " Kb \t Time = " << ucpu - cpu << " seconds " << std::endl;
            mem = umem;
            cpu = ucpu;
        } // if (m_dumpMemoryBreakDown) {
 
        if (!m_manager)
            m_manager = new  MuonDetectorManager();
 
        // check consistency of flags coming from the tool
        m_includeCutouts = 1;
        m_includeCutoutsBog = 1;
        log << MSG::INFO << "MuonLayout set to <" << m_layout << "> = Development version for DC3 - infrastructures " << endmsg;
        log << MSG::INFO << "                   BOG cutouts are activated " << m_includeCutoutsBog << " , all other cutouts are disabled " << m_includeCutouts << endmsg;
 
        // set here the flag defining the geometry granularity
        // minimalgeo = 1 => The geo tree is built up to the Detector Level (Full PhysVol)
        //                     no internal structure of the Detector is built
        // minimalgeo = 0 => The geo tree is built in full details
        m_manager->setMinimalGeoFlag(m_minimalGeoFlag);
        
        m_manager->setGeometryVersion(m_layout);
        m_manager->set_DBMuonVersion(m_DBMuonVersion);
 
        log << MSG::INFO << "Manager created for geometry version " << m_manager->geometryVersion() << " from DB MuonVersion <" << m_manager->get_DBMuonVersion() << ">" << endmsg;
 
        // here create the MYSQL singleton and assign to it the geometry version
        MYSQL::LockedMYSQL mysql = MYSQL::GetPointer();
        mysql->setGeometryVersion(m_layout);
        mysql->set_amdb_from_RDB(m_rdb == 1);
 
 
        StatusCode sc = StatusCode::SUCCESS;
 
        
        log << MSG::INFO << "MDTIDHELPER retrieved from DetStore" << endmsg;
        log << MSG::INFO << "RPCIDHELPER retrieved from DetStore" << endmsg;
        log << MSG::INFO << "TGCIDHELPER retrieved from DetStore" << endmsg;
        
        if (m_hasCSC) {
            log << MSG::INFO << "CSCIDHELPER retrieved from DetStore" << endmsg;
        }
        if (m_hasSTgc) {
            log << MSG::INFO << "STGCIDHELPER retrieved from DetStore" << endmsg;
        }
        if (m_hasMM) {
            log << MSG::INFO << "MMIDHELPER retrieved from DetStore" << endmsg;
        }
 
        if (m_dumpMemoryBreakDown) {
            umem = GeoPerfUtils::getMem();
            ucpu = int(GeoPerfUtils::getCpu() / 100.);
            geoModelStats << "At MuonDetectorFactory::IdHelpers loaded    \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = " << umem - mem
                          << " \t Delta T =" << ucpu - cpu << std::endl;
            mem = umem;
            cpu = ucpu;
        }
 
        log << MSG::INFO << " **************** MuonDetectorFactory001 ************************" << endmsg;
        log << " *** Start building the Muon Geometry Tree **********************" << endmsg;
 
        std::string OracleTag = m_DBkey;
        std::string OracleNode = m_DBnode;
 
        if (log.level() <= MSG::DEBUG)
            log << MSG::DEBUG << "calling RDBReaderAtlas with m_altAsciiDBMap" << endmsg;
 
        std::unique_ptr<RDBReaderAtlas> dbr =std::make_unique<RDBReaderAtlas>(m_pDetStore, m_pRDBAccess, OracleTag, OracleNode, m_altAsciiDBMap);
 
 
        // set here the flag deciding whether to include cutouts:
        // m_includeCutouts = 1 => include cutouts
        // m_includeCutouts = 0 => no cutouts
        m_manager->setCutoutsFlag(m_includeCutouts);
        m_manager->setCutoutsBogFlag(m_includeCutoutsBog);
 
        dbr->setGeometryVersion(m_layout);
        dbr->setManager(getDetectorManager());
        sc = dbr->ProcessDB(*mysql);
        if (sc != StatusCode::SUCCESS) {
            log << MSG::ERROR << " FAILURE in DB access; Muon node will not be built" << endmsg;
            return;
        }
       
        if (m_dumpMemoryBreakDown) {
            umem = GeoPerfUtils::getMem();
            ucpu = int(GeoPerfUtils::getCpu() / 100.);
            geoModelStats << "At MuonDetectorFactory::DB read             \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = " << umem - mem
                          << " \t Delta T =" << ucpu - cpu << std::endl;
            mem = umem;
            cpu = ucpu;
        }
 
        StoredMaterialManager *theMaterialManager;
        if (StatusCode::SUCCESS != m_pDetStore->retrieve(theMaterialManager, "MATERIALS")) {
            return;
        } else {
            log << MSG::INFO << " theMaterialManager retrieven successfully from the DetStore" << endmsg;
        }
 
        const GeoMaterial *m4 = theMaterialManager->getMaterial("std::Air");
        GeoLogVol *l4;
        GeoPcon *c4 = new GeoPcon(0, 360 * Gaudi::Units::deg);
 
 
        //--- --- --- CREATE ENVELOPE --- --- ---
        // First try to get data from the GeomDB
        IRDBRecordset_ptr muonSysRec = m_pRDBAccess->getRecordsetPtr("MuonSystem", OracleTag, OracleNode);
 
        // -- Next two lines allow to use MuonSystem-00 by default instead of hardwired numbers
        //    even for geometry tags where MuonSystem was not collected
        if (muonSysRec->size() == 0) {
            muonSysRec = m_pRDBAccess->getRecordsetPtr("MuonSystem", "MuonSystem-00");
            log << MSG::INFO << "MuonSystem description from default node in GeomDB, i.e. MuonSystem-00" << endmsg;
        } else {
            log << MSG::INFO << "MuonSystem description from OracleTag=<" << OracleTag << "> and node=<" << OracleNode << ">" << endmsg;
        }
 
        // --- Envelope from DB ....
        if (muonSysRec->size() != 0) {
            // Data retrieved
            muonsysIndMap indmap;
            muonsysIndMap::const_iterator iter;
            const IRDBRecord *currentRecord;
 
            // First fill the contents of muonsysIndMap
            for (unsigned int ind = 0; ind < muonSysRec->size(); ind++) {
                int key = (*muonSysRec)[ind]->getInt("PLANE_ID");
                indmap[key] = ind;
            }
 
            // Create the polycone
            for (unsigned int ind = 0; ind < indmap.size(); ind++) {
                iter = indmap.find(ind);
 
                if (iter == indmap.end()) {
                    throw std::runtime_error("Error in MuonDetectorFactory, missing plane in MuonSystem");
                } else {
                    currentRecord = (*muonSysRec)[(*iter).second];
                    c4->addPlane(currentRecord->getDouble("ZPLANE"), currentRecord->getDouble("RMIN"), currentRecord->getDouble("RMAX"));
                }
            }
        } else { // ... end if  Envelope from DB ---
            // Muon System node is not present, go for handcoded version
            log << MSG::INFO << "MuonSystem description not available in GeomDB - using hard-wired description" << endmsg;
 
            double ir = m_muon->barrelInnerRadius;
            double pir = m_muon->innerRadius;
            double orad = m_muon->outerRadius;
            double l = m_muon->length;
            double eff = m_muon->endcapFrontFace;
 
            double extraR = m_muon->extraR;
            double extraZ = m_muon->extraZ;
 
            c4->addPlane(-l, pir, extraR);
            c4->addPlane(-extraZ, pir, extraR);
            c4->addPlane(-extraZ, pir, orad);
 
            c4->addPlane(-eff, pir, orad);
            c4->addPlane(-eff, ir, orad);
            c4->addPlane(+eff, ir, orad);
            c4->addPlane(+eff, pir, orad);
 
            c4->addPlane(extraZ, pir, orad);
            c4->addPlane(extraZ, pir, extraR);
            c4->addPlane(l, pir, extraR);
        } // ... end if  Envelope from DB ---
       
 
        l4 = new GeoLogVol("MuonSys", c4, m4);
 
        GeoPhysVol *p4 = new GeoPhysVol(l4);
 
        // Cannot (yet) cope with this:
        // G4UserLimits *ul=new G4UserLimits;
        // ul->SetMaxAllowedStep(5*Gaudi::Units::cm);
        // lv->GetLogicalVolume()->SetUserLimits(ul);
 
        m_manager->addTreeTop(p4); // This is the top!
        log << MSG::INFO << " TreeTop added to the Manager" << endmsg;
        log << MSG::INFO << " Muon Layout " << m_layout << endmsg;
 
        std::vector<std::string> slist;
        if (m_selectedStations.empty())
            slist.emplace_back("*");
        else
            slist = m_selectedStations;
 
        // create the fullphysvol map to allow cloning and save memory
        std::unique_ptr<FPVMAP> savemem = std::make_unique< FPVMAP>();
 
        int nstat_ss = 0;
        int ntpos_ss = 0;
        int npos_ss = 0;
        int nAssemblies = 0;
        if (m_enableFineClashFixing > 0) {
            log << MSG::INFO << "Fine Clash Fixing enabled:  (should be ON/OFF for Simulation/Reconstruction)" << endmsg;
        } else {
            log << MSG::INFO << "Fine Clash Fixing disabled: (should be ON/OFF for Simulation/Reconstruction)" << endmsg;
        }
 
        StationSelector sel(*mysql, slist);
        StationSelector::StationIterator it;
 
        for (it = sel.begin(); it != sel.end(); ++it) {
            Station *station = (*it).second;
            std::string stname(station->GetName(), 0, 3);
            if (m_selectedStations.empty()) {
                if (log.level() <= MSG::VERBOSE) {
                    log << MSG::VERBOSE << "Processing Stations named <" << station->GetName() << "> " << nstat_ss << " built until now" << endmsg;
                }
            }
 
            if ((skip_chambers) && (stname.substr(0, 1) != "X"))
                continue;
 
            bool isAssembly = false;
            if (station->GetNrOfCutouts() > 0 && stname.substr(0, 1) != "T")
                isAssembly = true;
 
            // BIR have multilayers of diff. length and overall station volume clashes with toroids
            if (stname == "BIR")
                isAssembly = true;
 
            MuonChamber l(*mysql, station); // here is where we start to create a MuonChamber with all readoutelements
            l.setFPVMAP(savemem.get());
            l.setFineClashFixingFlag(m_enableFineClashFixing);
 
            PositionIterator pit;
            AlignPosIterator apit;
            AlignPos ap;
            npos_ss = 0;
            for (pit = station->begin(); pit != station->end(); ++pit) {
                int zi = (*pit).second.zindex;
                int fi = (*pit).second.phiindex;
                int sign = 1;
                if (zi)
                    sign = zi / abs(zi);
 
                // if there's a selection of eta location, check if this chamber is selected
                if (!m_selectedStEta.empty()) {
                    bool selectedEta = false;
                    for (auto i = m_selectedStEta.begin(); i < m_selectedStEta.end(); i++) {
                        if (zi == *i) {
                            selectedEta = true;
                            break;
                        }
                    }
 
                    if (!selectedEta)
                        continue;
                }
 
                // if there's a selection of phi location, check if this chamber is selected
                if (!m_selectedStPhi.empty()) {
                    bool selectedPhi = false;
                    for (auto i = m_selectedStPhi.begin(); i < m_selectedStPhi.end(); i++) {
                        if ((fi + 1) == *i) {
                            selectedPhi = true;
                            break;
                        }
                    }
 
                    if (!selectedPhi)
                        continue;
                }
 
                // total number of stations positioned in the layout
                ntpos_ss++;
                // total number of locations for this chamber
                npos_ss++;
 
                if ((m_selectedStPhi.size() + m_selectedStEta.size()) > 0) {
                    log << MSG::INFO << "Build selected Station <" << station->GetName() << "> at Jzz = " << zi << " Jff = " << fi + 1 << " ******* " << nstat_ss
                        << " stat.types built until now" << endmsg;
                }
 
                // here define GeoNameTag
                GeoNameTag *nm = new GeoNameTag(station->GetName() + "_station");
                // here build the physical volume (tree) associated to the chamber
                bool is_mirrored = ((*pit).second).isMirrored;
                int mirsign = 0;
                if (zi < 0 && !is_mirrored)
                    mirsign = 1;
                if (stname == "CSL")
                    isAssembly = true;
 
                // CSL because coffin shape of the station mother volume
                GeoVPhysVol *pv = l.build(*theMaterialManager, *mysql, getDetectorManager(), zi, fi, is_mirrored, isAssembly);
                if (isAssembly)
                    nAssemblies++;
 
                // here define GeoIdentifierTag
                if (useAssemblies || isAssembly) {
                    int sideC = 0;
                    if (zi < 0)
                        sideC = 1;
                    int geoid = (sideC * 10000 + mirsign * 1000 + abs(zi) * 100 + fi + 1) * 100000;
                    if (log.level() <= MSG::DEBUG) {
                        log << MSG::DEBUG << "Adding Station with nameTag=<" << station->GetName() + "_station"
                            << "> and geoId " << geoid << endmsg;
                    }
                    p4->add(new GeoIdentifierTag(geoid));
                } else {
                    int geoid = (mirsign * 1000 + abs(zi) * 100 + fi + 1) * sign;
                    p4->add(new GeoIdentifierTag(geoid));
                    if (log.level() <= MSG::DEBUG) {
                        log << MSG::DEBUG << "Adding Station with nameTag=<" << station->GetName() + "_station"
                            << "> and geoId " << geoid << " for zi/fi = " << zi << "/" << fi << endmsg;
                    }
                }
 
                // alignment issues and readout geometry for station
                MuonStation *mst = m_manager->getMuonStation(station->GetName(), zi, fi + 1);
                if (!mst) {
                    log << MSG::WARNING << "For Station with nameTag=<" << station->GetName() << "> at zi/fi = " << zi << "/" << fi
                        << " no MuonStation found => no possibility to align" << endmsg;
                    continue;
                }
 
                GeoTrf::Transform3D tsz_to_szt = GeoTrf::RotateZ3D(-90 * Gaudi::Units::degree) * GeoTrf::RotateY3D(-90 * Gaudi::Units::degree);
        GeoTrf::Transform3D   nativeToAmdbLRS=tsz_to_szt * station->native_to_tsz_frame(*mysql, (*pit).second);
        
                mst->setNativeToAmdbLRS(nativeToAmdbLRS);
                mst->setNominalAmdbLRSToGlobal(station->tsz_to_global_frame(*mysql, (*pit).second) * tsz_to_szt.inverse());
 
                // find correct alignment information for this position
                // xf->setDelta(DummyAline); // just in case we don't find one
 
                // apit = station->FindAlignPos(zi,fi);
                // number of A-lines for this station
 
                int nAlines = station->CountAlignPos(zi, fi);
                // nAlines=-1;
        if (nAlines == 0 || BEEShiftDisabled() ) {
 
          // here define the GeoAlignableTransform associated to the chamber
          // nominal transform first
          GeoAlignableTransform *xf = new GeoAlignableTransform(station->getNominalTransform(*mysql, (*pit).second));
          
          // add tag, transform and physicalvolume associated to the chamber to the mother-volume
          p4->add(nm);
          p4->add(xf);
          p4->add(pv);
          
 
          mst->setTransform(xf);
          GeoTrf::Transform3D tsz_to_szt = GeoTrf::RotateZ3D(-90 * Gaudi::Units::degree) * GeoTrf::RotateY3D(-90 * Gaudi::Units::degree);
 
          mst->setNativeToAmdbLRS(tsz_to_szt * station->native_to_tsz_frame(*mysql, (*pit).second));
          mst->setNominalAmdbLRSToGlobal(station->tsz_to_global_frame(*mysql, (*pit).second) * tsz_to_szt.inverse());
 
          mst->setDeltaAmdbLRS(GeoTrf::Transform3D::Identity());
 
                } else if (nAlines ==1) {
                    AlignPosIterator alast;
                    AlignPosIterator afirst = station->getFirstAlignPosInRange(zi, fi, alast);
 
                    for (AlignPosIterator acurrent = afirst; acurrent != alast; ++acurrent) {
                        ap = acurrent->second;
 
                        if (ap.phiindex != fi || ap.zindex != zi) {
                            log << MSG::ERROR << "Inconsistent AlignedPosition found in the static Geometry DB: aligPos.fi, zi = " << ap.phiindex << ", " << ap.zindex
                                << " for station " << station->GetName() << " at fi/zi = " << fi << "/" << zi << " AlignPos indices fi/zi " << fi << "/" << zi << endmsg;
                        }
 
                        if (ap.jobindex == 0) {
                            // station
                            if (log.level() <= MSG::DEBUG) {
                                log << MSG::DEBUG << "Going to set delta from A-line for station" << stname << " at zi/fi " << zi << "/" << fi << endmsg;
                                log << MSG::DEBUG << "A-line is: " << ap.tras << " " << ap.traz << " " << ap.trat << " " << ap.rots << " " << ap.rotz << " " << ap.rott << endmsg;
                            }
                // compute the delta transform in the local AMDB frame
                // here define the GeoAlignableTransform associated to the chamber
                // nominal transform first
                GeoTrf::Transform3D delta_amdb = 
                  GeoTrf::TranslateX3D(ap.tras) * GeoTrf::TranslateY3D(ap.traz) * GeoTrf::TranslateZ3D(ap.trat) *
                  GeoTrf::RotateX3D(ap.rots) * GeoTrf::RotateY3D(ap.rotz) * GeoTrf::RotateZ3D(ap.rott);
 
                GeoTrf::Transform3D tsz_to_szt = GeoTrf::RotateZ3D(-90 * Gaudi::Units::degree) * GeoTrf::RotateY3D(-90 * Gaudi::Units::degree);
                GeoTrf::Transform3D nominalTransform=station->getNominalTransform(*mysql, (*pit).second);
                GeoTrf::Transform3D native_to_amdbl=tsz_to_szt * station->native_to_tsz_frame(*mysql, (*pit).second);
                GeoAlignableTransform *xf = new GeoAlignableTransform(nominalTransform*native_to_amdbl.inverse()*delta_amdb*native_to_amdbl);
                
                // add tag, transform and physicalvolume associated to the chamber to the mother-volume
                p4->add(nm);
                p4->add(xf);
                p4->add(pv);
                
 
                
                mst->setTransform(xf);
                mst->setNativeToAmdbLRS(tsz_to_szt * station->native_to_tsz_frame(*mysql, (*pit).second));
                mst->setNominalAmdbLRSToGlobal(station->tsz_to_global_frame(*mysql, (*pit).second) * tsz_to_szt.inverse());
                mst->setDeltaAmdbLRS(GeoTrf::Transform3D::Identity());
                
                            
                        } 
                    }
                }
        else {
        }
            } // end loop on positions
 
            // number of stations realised in the layout
            if (npos_ss > 0)
                nstat_ss++;
        } // for ( it = sel.begin(); it != sel.end(); it++ ) {
 
        log << MSG::INFO << " **************** MuonDetectorFactory001 ****************************" << endmsg << " *** The Muon Chamber Geometry Tree is built with " << endmsg
            << " *** " << p4->getNChildVols() << " child volumes " << endmsg << " *** " << savemem->NDetectors() << " independent elements and " << endmsg << " *** "
            << savemem->NDetectorsReused() << " elements cloned or shared " << endmsg << " *** " << nstat_ss << " kinds of stations" << endmsg << " *** " << ntpos_ss
            << " stations with alignable transforms" << endmsg << " *** " << nAssemblies << " stations are described as Assemblies" << endmsg << " *** "
            << m_manager->nMuonStation() << " MuonStations " << endmsg << " *** \t " << m_manager->nMdtRE() << " MDT Readout Elements \t " << m_manager->nMdtDE()
            << " MDT Detector Elements " << endmsg << " *** \t " << m_manager->nCscRE() << " CSC Readout Elements \t " << m_manager->nCscDE() << " CSC Detector Elements " << endmsg
            << " *** \t " << m_manager->nRpcRE() << " RPC Readout Elements \t " << m_manager->nRpcDE() << " RPC Detector Elements " << endmsg << " *** \t " << m_manager->nTgcRE()
            << " TGC Readout Elements \t " << m_manager->nTgcDE() << " TGC Detector Elements " << endmsg << " ********************************************************************"
            << endmsg;
 
        if (m_dumpMemoryBreakDown) {
            umem = GeoPerfUtils::getMem();
            ucpu = int(GeoPerfUtils::getCpu() / 100.);
            geoModelStats << "At MuonDetectorFactory::active geo done     \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = " << umem - mem
                          << " \t Delta T =" << ucpu - cpu << std::endl;
            mem = umem;
            cpu = ucpu;
        }
 
      
        // delete the station and technology map
        delete mysql.get();
 
        if (m_dumpMemoryBreakDown) {
            umem = GeoPerfUtils::getMem();
            ucpu = int(GeoPerfUtils::getCpu() / 100.);
            geoModelStats << "At MuonDetectorFactory::released access.mem \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = " << umem - mem
                          << " \t Delta T =" << ucpu - cpu << std::endl;
            mem = umem;
            cpu = ucpu;
        }
 
        GeoNameTag *ntg = new GeoNameTag("Muon");
        world->add(ntg);
        world->add(p4);
 
        log << MSG::INFO << " *** Inert Material built according to DB switches and config. ****** " << endmsg;
        log << MSG::INFO << " *** The Muon Geometry Tree has " << p4->getNChildVols() << " child vol.s in total ********" << endmsg
            << " ********************************************************************\n"
            << endmsg;
 
        if (m_dumpMemoryBreakDown) {
            umem = GeoPerfUtils::getMem();
            ucpu = int(GeoPerfUtils::getCpu() / 100.);
            geoModelStats << "At MuonDetectorFactory::inert  geo done     \t SZ= " << umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = " << umem - mem
                          << " \t Delta T =" << ucpu - cpu << std::endl;
            mem = umem;
            cpu = ucpu;
 
            geoModelStats.close();
        }
    } // MuonDetectorFactory001::create

disableBEEShift()

void MuonGM::MuonDetectorFactory001::disableBEEShift ( bool flag )

inline

Definition at line 132 of file MuonDetectorFactory001.h.

{ m_disableBEEShift=flag;}

getDetectorManager() [1/2]

MuonDetectorManager * MuonGM::MuonDetectorFactory001::getDetectorManager

(

)

Definition at line 92 of file MuonDetectorFactory001.cxx.

{ return m_manager; }

getDetectorManager() [2/2]

const MuonDetectorManager * MuonGM::MuonDetectorFactory001::getDetectorManager ( ) const

overridevirtual

Definition at line 91 of file MuonDetectorFactory001.cxx.

{ return m_manager; }

hasCSC()

void MuonGM::MuonDetectorFactory001::hasCSC ( bool value )

inline

Definition at line 129 of file MuonDetectorFactory001.h.

{ m_hasCSC = value; }

hasMM()

void MuonGM::MuonDetectorFactory001::hasMM ( bool value )

inline

Definition at line 131 of file MuonDetectorFactory001.h.

{ m_hasMM = value; }      

hasSTgc()

void MuonGM::MuonDetectorFactory001::hasSTgc ( bool value )

inline

Definition at line 130 of file MuonDetectorFactory001.h.

{ m_hasSTgc = value; }

setAltAsciiDBMap()

void MuonGM::MuonDetectorFactory001::setAltAsciiDBMap ( const AltAsciiDBMap & asciidbmap )

inline

Definition at line 116 of file MuonDetectorFactory001.h.

{ m_altAsciiDBMap = asciidbmap; }

setCacheFillingFlag()

void MuonGM::MuonDetectorFactory001::setCacheFillingFlag ( int value )

inline

setCtbBisFlag()

void MuonGM::MuonDetectorFactory001::setCtbBisFlag ( int flag )

inline

Definition at line 113 of file MuonDetectorFactory001.h.

{ m_includeCtbBis = flag; }

setCutoutsBogFlag()

void MuonGM::MuonDetectorFactory001::setCutoutsBogFlag ( int flag )

inline

Definition at line 112 of file MuonDetectorFactory001.h.

{ m_includeCutoutsBog = flag; }

setCutoutsFlag()

void MuonGM::MuonDetectorFactory001::setCutoutsFlag ( int flag )

inline

Definition at line 111 of file MuonDetectorFactory001.h.

{ m_includeCutouts = flag; }

setDBAtlasVersion()

void MuonGM::MuonDetectorFactory001::setDBAtlasVersion ( const std::string & v )

inline

Definition at line 106 of file MuonDetectorFactory001.h.

{ m_DBAtlasVersion = v; }

setDBkey()

void MuonGM::MuonDetectorFactory001::setDBkey ( const std::string & v )

inline

Definition at line 108 of file MuonDetectorFactory001.h.

{ m_DBkey = v; }

setDBMuonVersion()

void MuonGM::MuonDetectorFactory001::setDBMuonVersion ( const std::string & v )

inline

Definition at line 107 of file MuonDetectorFactory001.h.

{ m_DBMuonVersion = v; }

setDBnode()

void MuonGM::MuonDetectorFactory001::setDBnode ( const std::string & v )

inline

Definition at line 109 of file MuonDetectorFactory001.h.

{ m_DBnode = v; }

setDumpMemoryBreakDown()

void MuonGM::MuonDetectorFactory001::setDumpMemoryBreakDown ( bool value )

inline

Definition at line 127 of file MuonDetectorFactory001.h.

{ m_dumpMemoryBreakDown = value; }

setFineClashFixingFlag()

void MuonGM::MuonDetectorFactory001::setFineClashFixingFlag ( int value )

inline

Definition at line 128 of file MuonDetectorFactory001.h.

{ m_enableFineClashFixing = value; }

setLayout()

void MuonGM::MuonDetectorFactory001::setLayout ( const std::string & str )

inline

Definition at line 110 of file MuonDetectorFactory001.h.

{ m_layout = str; }

setMdtDeformationFlag()

void MuonGM::MuonDetectorFactory001::setMdtDeformationFlag ( int mdtDeformationFlag )

inline

setMinimalGeoFlag()

void MuonGM::MuonDetectorFactory001::setMinimalGeoFlag ( int minimalGeo )

inline

Definition at line 117 of file MuonDetectorFactory001.h.

{ m_minimalGeoFlag = minimalGeo; }

setNSWAsBuiltAsciiPath()

void MuonGM::MuonDetectorFactory001::setNSWAsBuiltAsciiPath ( const std::string & , const std::string &  )

inline

setNswAsBuiltParaFlag()

void MuonGM::MuonDetectorFactory001::setNswAsBuiltParaFlag ( int nswAsBuiltParaFlag )

inline

setRDBAccess()

void MuonGM::MuonDetectorFactory001::setRDBAccess ( IRDBAccessSvc * access )

inline

Definition at line 115 of file MuonDetectorFactory001.h.

{ m_pRDBAccess = access; }

setSelection()

void MuonGM::MuonDetectorFactory001::setSelection ( const std::vector< std::string > & vst, const std::vector< int > & veta, const std::vector< int > & vphi )

inline

Definition at line 119 of file MuonDetectorFactory001.h.

                                                                          {
        m_selectedStations = vst;
        m_selectedStEta = veta;
        m_selectedStPhi = vphi;
    }

setUseRDB()

void MuonGM::MuonDetectorFactory001::setUseRDB ( int rdb )

inline

Definition at line 114 of file MuonDetectorFactory001.h.

{ m_rdb = rdb; }

Member Data Documentation

m_altAsciiDBMap

AltAsciiDBMap MuonGM::MuonDetectorFactory001::m_altAsciiDBMap {}

private

Definition at line 103 of file MuonDetectorFactory001.h.

{};

m_DBAtlasVersion

std::string MuonGM::MuonDetectorFactory001::m_DBAtlasVersion {}

private

Definition at line 75 of file MuonDetectorFactory001.h.

{};

m_DBkey

std::string MuonGM::MuonDetectorFactory001::m_DBkey {}

private

Definition at line 77 of file MuonDetectorFactory001.h.

{};

m_DBMuonVersion

std::string MuonGM::MuonDetectorFactory001::m_DBMuonVersion {}

private

Definition at line 76 of file MuonDetectorFactory001.h.

{};

m_DBnode

std::string MuonGM::MuonDetectorFactory001::m_DBnode {}

private

Definition at line 78 of file MuonDetectorFactory001.h.

{};

m_disableBEEShift

bool MuonGM::MuonDetectorFactory001::m_disableBEEShift {false}

private

Definition at line 93 of file MuonDetectorFactory001.h.

{false};

m_dumpMemoryBreakDown

bool MuonGM::MuonDetectorFactory001::m_dumpMemoryBreakDown {false}

private

Definition at line 87 of file MuonDetectorFactory001.h.

{false};

m_enableFineClashFixing

int MuonGM::MuonDetectorFactory001::m_enableFineClashFixing {0}

private

Definition at line 88 of file MuonDetectorFactory001.h.

{0};

m_hasCSC

bool MuonGM::MuonDetectorFactory001::m_hasCSC {true}

private

Definition at line 89 of file MuonDetectorFactory001.h.

{true};

m_hasMM

bool MuonGM::MuonDetectorFactory001::m_hasMM {true}

private

Definition at line 91 of file MuonDetectorFactory001.h.

{true};

m_hasSTgc

bool MuonGM::MuonDetectorFactory001::m_hasSTgc {true}

private

Definition at line 90 of file MuonDetectorFactory001.h.

{true};

m_includeCtbBis

int MuonGM::MuonDetectorFactory001::m_includeCtbBis {0}

private

Definition at line 83 of file MuonDetectorFactory001.h.

{0};

m_includeCutouts

int MuonGM::MuonDetectorFactory001::m_includeCutouts {0}

private

Definition at line 81 of file MuonDetectorFactory001.h.

{0};

m_includeCutoutsBog

int MuonGM::MuonDetectorFactory001::m_includeCutoutsBog {0}

private

Definition at line 82 of file MuonDetectorFactory001.h.

{0};

m_layout

std::string MuonGM::MuonDetectorFactory001::m_layout {}

private

Definition at line 80 of file MuonDetectorFactory001.h.

{};

m_manager

MuonDetectorManager* MuonGM::MuonDetectorFactory001::m_manager {nullptr}

private

Definition at line 100 of file MuonDetectorFactory001.h.

{nullptr};

m_minimalGeoFlag

int MuonGM::MuonDetectorFactory001::m_minimalGeoFlag {0}

private

Definition at line 85 of file MuonDetectorFactory001.h.

{0};

m_muon

std::unique_ptr<MuonSystemDescription> MuonGM::MuonDetectorFactory001::m_muon

private

Definition at line 99 of file MuonDetectorFactory001.h.

m_pDetStore

StoreGateSvc* MuonGM::MuonDetectorFactory001::m_pDetStore {nullptr}

private

Definition at line 101 of file MuonDetectorFactory001.h.

{nullptr};

m_pRDBAccess

IRDBAccessSvc* MuonGM::MuonDetectorFactory001::m_pRDBAccess {nullptr}

private

Definition at line 102 of file MuonDetectorFactory001.h.

{nullptr};

m_rdb

int MuonGM::MuonDetectorFactory001::m_rdb {1}

private

Definition at line 84 of file MuonDetectorFactory001.h.

{1};

m_selectedStations

std::vector<std::string> MuonGM::MuonDetectorFactory001::m_selectedStations

private

Definition at line 95 of file MuonDetectorFactory001.h.

m_selectedStEta

std::vector<int> MuonGM::MuonDetectorFactory001::m_selectedStEta

private

Definition at line 96 of file MuonDetectorFactory001.h.

m_selectedStPhi

std::vector<int> MuonGM::MuonDetectorFactory001::m_selectedStPhi

private

Definition at line 97 of file MuonDetectorFactory001.h.

---

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

• MuonDetectorFactory001.h
• MuonDetectorFactory001.cxx