MuonGM::RDBReaderAtlas Class Reference

#include <RDBReaderAtlas.h>

Inheritance diagram for MuonGM::RDBReaderAtlas:

Public Member Functions
	RDBReaderAtlas (StoreGateSvc *pDetStore, IRDBAccessSvc *m_pRDBAccess, const std::string &geoTag, const std::string &geoNode, const std::map< std::string, std::string > &asciiFileDBMap)
virtual	~RDBReaderAtlas ()=default
virtual StatusCode	ProcessDB (MYSQL &mysql) override
void	ProcessTGCreadout (MYSQL &mysql)
void	ProcessCscInternalAlignments ()
std::string	TGCreadoutName (int ichtyp)
void	setGeometryVersion (std::string s)
const std::string &	getGeometryVersion () const
void	setManager (MuonDetectorManager *detmgr)
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Protected Attributes
StatusCode	m_SCdbaccess
std::vector< std::string >	m_tgcReadoutMapping
MuonDetectorManager *	m_mgr

Private Member Functions
void	ProcessTechnologies (MYSQL &mysql)
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::unique_ptr< DblQ00Dbam >	m_dhdbam {nullptr}
std::unique_ptr< DblQ00Atyp >	m_dhatyp {nullptr}
std::unique_ptr< DblQ00Asmp >	m_dhasmp {nullptr}
std::unique_ptr< DblQ00Almn >	m_dhalmn {nullptr}
std::unique_ptr< DblQ00Aptp >	m_dhaptp {nullptr}
std::unique_ptr< DblQ00Awln >	m_dhwrpc {nullptr}
std::unique_ptr< DblQ00Atln >	m_dhwtgc {nullptr}
std::unique_ptr< DblQ00Acut >	m_dhacut {nullptr}
std::unique_ptr< DblQ00Alin >	m_dhalin {nullptr}
std::unique_ptr< DblQ00Wmdt >	m_dhwmdt {nullptr}
std::unique_ptr< DblQ00Wcsc >	m_dhwcsc {nullptr}
std::unique_ptr< DblQ00Wrpc >	m_dhwrpcall {nullptr}
std::unique_ptr< DblQ00Wtgc >	m_dhwtgcall {nullptr}
std::unique_ptr< DblQ00Wded >	m_dhwded {nullptr}
std::unique_ptr< DblQ00Wsup >	m_dhwsup {nullptr}
std::unique_ptr< DblQ00Wspa >	m_dhwspa {nullptr}
std::unique_ptr< DblQ00Wchv >	m_dhwchv {nullptr}
std::unique_ptr< DblQ00Wcro >	m_dhwcro {nullptr}
std::unique_ptr< DblQ00Wcmi >	m_dhwcmi {nullptr}
std::unique_ptr< DblQ00Wlbi >	m_dhwlbi {nullptr}
std::unique_ptr< DblQ00Aszt >	m_dhaszt {nullptr}
std::unique_ptr< DblQ00IAcsc >	m_dhiacsc {nullptr}
std::unique_ptr< DblQ00Xtomo >	m_dhxtomo {nullptr}
const DblQ00Dbam::DBAM *	m_dbam {nullptr}
const DblQ00Atyp::ATYP *	m_atyp {nullptr}
const DblQ00Asmp::ASMP *	m_asmp {nullptr}
const DblQ00Almn::ALMN *	m_almn {nullptr}
const DblQ00Aptp::APTP *	m_aptp {nullptr}
const DblQ00Awln::AWLN *	m_wrpc {nullptr}
const DblQ00Atln::ATLN *	m_wtgc {nullptr}
const DblQ00Acut::ACUT *	m_acut {nullptr}
const DblQ00Alin::ALIN *	m_alin {nullptr}
const DblQ00Wmdt::WMDT *	m_wmdt {nullptr}
const DblQ00Wcsc::WCSC *	m_wcsc {nullptr}
const DblQ00Wrpc::WRPC *	m_wrpcall {nullptr}
const DblQ00Wtgc::WTGC *	m_wtgcall {nullptr}
const DblQ00Wded::WDED *	m_wded {nullptr}
const DblQ00Wsup::WSUP *	m_wsup {nullptr}
const DblQ00Wspa::WSPA *	m_wspa {nullptr}
const DblQ00Wchv::WCHV *	m_wchv {nullptr}
const DblQ00Wcro::WCRO *	m_wcro {nullptr}
const DblQ00Wcmi::WCMI *	m_wcmi {nullptr}
const DblQ00Wlbi::WLBI *	m_wlbi {nullptr}
const DblQ00Aszt::ASZT *	m_aszt {nullptr}
const DblQ00IAcsc::IACSC *	m_iacsc {nullptr}
const DblQ00Xtomo::XTOMO *	m_xtomo {nullptr}
const std::string	m_geoTag {}
const std::string	m_geoNode {}
IRDBAccessSvc *	m_pRDBAccess {nullptr}
std::string	m_asciiFileDB {}
IMessageSvc *	m_msgSvc
std::string	m_version
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 21 of file RDBReaderAtlas.h.

Constructor & Destructor Documentation

RDBReaderAtlas()

MuonGM::RDBReaderAtlas::RDBReaderAtlas	(	StoreGateSvc *	pDetStore,
		IRDBAccessSvc *	m_pRDBAccess,
		const std::string &	geoTag,
		const std::string &	geoNode,
		const std::map< std::string, std::string > &	asciiFileDBMap )

Definition at line 26 of file RDBReaderAtlas.cxx.

                                                                                       :
         DBReader(pDetStore), AthMessaging{"MuGM:RDBReadAtlas"},
            m_geoTag(geoTag), m_geoNode(geoNode), m_pRDBAccess(pRDBAccess) {
        m_SCdbaccess = StatusCode::FAILURE;
 
      
        ATH_MSG_INFO("Start retrieving dbObjects with tag = <" << geoTag << "> node <" << geoNode << ">");
        
        // here putting RDB data in private "objects" form       
        m_dhatyp = std::make_unique<DblQ00Atyp>(m_pRDBAccess, geoTag, geoNode);        
        m_atyp = m_dhatyp->data();
 
       
        m_dhasmp = std::make_unique<DblQ00Asmp>(m_pRDBAccess, geoTag, geoNode);      
        m_asmp = m_dhasmp->data();
 
       
        m_dhalmn = std::make_unique<DblQ00Almn>(m_pRDBAccess, geoTag, geoNode); 
        m_almn = m_dhalmn->data();
 
        
        m_dhaptp = std::make_unique<DblQ00Aptp>(m_pRDBAccess, geoTag, geoNode);   
        m_aptp = m_dhaptp->data();
 
       
        m_dhacut = std::make_unique<DblQ00Acut>(m_pRDBAccess, geoTag, geoNode);
        m_acut = m_dhacut->data();
 
        m_dhalin = std::make_unique<DblQ00Alin>(m_pRDBAccess, geoTag, geoNode);
        m_alin = m_dhalin->data();
 
        m_dhdbam = std::make_unique<DblQ00Dbam>(m_pRDBAccess, geoTag, geoNode);
        m_dbam = m_dhdbam->data();
 
       
        m_dhwrpc = std::make_unique<DblQ00Awln>(m_pRDBAccess, geoTag, geoNode);
        m_wrpc = m_dhwrpc->data();
 
        m_dhwtgc = std::make_unique<DblQ00Atln>(m_pRDBAccess, geoTag, geoNode);
        m_wtgc = m_dhwtgc->data();
 
        m_dhwmdt = std::make_unique<DblQ00Wmdt>(m_pRDBAccess, geoTag, geoNode);
        m_wmdt = m_dhwmdt->data();
 
        m_dhwcsc = std::make_unique<DblQ00Wcsc>(m_pRDBAccess, geoTag, geoNode); 
        m_wcsc = m_dhwcsc->data();
 
      
        m_dhwrpcall = std::make_unique<DblQ00Wrpc>(m_pRDBAccess, geoTag, geoNode);   
        m_wrpcall = m_dhwrpcall->data();
 
        m_dhwtgcall = std::make_unique<DblQ00Wtgc>(m_pRDBAccess, geoTag, geoNode); 
        m_wtgcall = m_dhwtgcall->data();
 
        m_dhwspa = std::make_unique<DblQ00Wspa>(m_pRDBAccess, geoTag, geoNode);
        m_wspa = m_dhwspa->data();
 
       
        m_dhwded = std::make_unique<DblQ00Wded>(m_pRDBAccess, geoTag, geoNode);
        m_wded = m_dhwded->data();
 
       
        m_dhwsup = std::make_unique<DblQ00Wsup>(m_pRDBAccess, geoTag, geoNode);   
        m_wsup = m_dhwsup->data();
 
        if (m_pRDBAccess->getRecordsetPtr("XtomoData", geoTag, geoNode)->size()!=0) {
            m_dhxtomo= std::make_unique<DblQ00Xtomo>(pRDBAccess, geoTag, geoNode);
            ATH_MSG_INFO("XtomoData table found in Oracle");
        } else {
            m_dhxtomo= std::make_unique<DblQ00Xtomo>();
            ATH_MSG_INFO("No XtomoData table in Oracle");
        }
        
        if (m_dhxtomo)
            m_xtomo = m_dhxtomo->data();
 
        // ASZT
        if (asciiFileDBMap.find("ASZT") != asciiFileDBMap.end()) {
            ATH_MSG_INFO( "getting aszt from ascii file - named <" << asciiFileDBMap.find("ASZT")->second << ">");
            ATH_MSG_INFO( "Ascii aszt input has priority over A-lines in ORACLE; A-lines from Oracle will not be read");
            // dbdata = 0;
            m_dhaszt = std::make_unique<DblQ00Aszt>(asciiFileDBMap.find("ASZT")->second);
            if (m_dhaszt->size() == 0) {
                ATH_MSG_ERROR("Couldn't read ASZT from ascii file!");
            } else {
                ATH_MSG_INFO("N. of lines read = " << m_dhaszt->size());
            }
        }
 
        if (!m_dhaszt || m_dhaszt->size() == 0) {
            ATH_MSG_INFO( "No Ascii aszt input found: looking for A-lines in ORACLE");
            if (m_pRDBAccess->getRecordsetPtr("ASZT",geoTag,geoNode)->size()==0) {
                m_dhaszt = std::make_unique<DblQ00Aszt>();
                ATH_MSG_INFO("No ASZT table in Oracle");
            } else {
                ATH_MSG_INFO("ASZT table found in Oracle");
                m_dhaszt = std::make_unique<DblQ00Aszt>(m_pRDBAccess, geoTag, geoNode);   
                ATH_MSG_INFO("ASZT size is " << m_dhaszt->size());
            }
        } else {
            ATH_MSG_INFO( "ASZT table in Oracle, if any, will not be read" );
        }
        if (m_dhaszt)
            m_aszt = m_dhaszt->data();
 
        // Internal CSC Alignment parameters
        if (asciiFileDBMap.find("IACSC") != asciiFileDBMap.end()) {
 
            ATH_MSG_INFO( "getting iacsc from ascii file - named <" << asciiFileDBMap.find("IACSC")->second << ">" );
            ATH_MSG_INFO( "Ascii iacsc input has priority over A-lines in ORACLE; A-lines from Oracle will not be read" );
            // dbdata = 0;
            m_dhiacsc = std::make_unique<DblQ00IAcsc>(asciiFileDBMap.find("IACSC")->second);
            if (m_dhiacsc->size() == 0) {
                ATH_MSG_ERROR( "Couldn't read IACSC from ascii file!" );
            } else {
                ATH_MSG_INFO( "N. of lines read = " << m_dhiacsc->size() );
            }
        }
        if (!m_dhiacsc || m_dhiacsc->size() == 0) {
            ATH_MSG_INFO( "No Ascii iacsc input found: looking for A-lines in ORACLE" );
            if (m_pRDBAccess->getRecordsetPtr("IZST", geoTag,geoNode)->size()==0) {
                m_dhiacsc = std::make_unique<DblQ00IAcsc>();
                ATH_MSG_INFO( "No ISZT table in Oracle" );
            } else {
                ATH_MSG_INFO( "ISZT table found in Oracle" );
                m_dhiacsc = std::make_unique<DblQ00IAcsc>(m_pRDBAccess, geoTag, geoNode);                   
            }            
        } else {
            ATH_MSG_INFO( "ISZT table in Oracle, if any, will not be read" );
        }
        if (m_dhiacsc)
            m_iacsc = m_dhiacsc->data();
 
 
        m_dhwchv = std::make_unique<DblQ00Wchv>(m_pRDBAccess, geoTag, geoNode);   
        m_wchv = m_dhwchv->data();
 
        m_dhwcro = std::make_unique<DblQ00Wcro>(m_pRDBAccess, geoTag, geoNode); 
        m_wcro = m_dhwcro->data();
 
        m_dhwcmi = std::make_unique<DblQ00Wcmi>(m_pRDBAccess, geoTag, geoNode);
        m_wcmi = m_dhwcmi->data();
 
       
        m_dhwlbi = std::make_unique<DblQ00Wlbi>(m_pRDBAccess, geoTag, geoNode);
        m_wlbi = m_dhwlbi->data();
 
        // everything fetched
        m_SCdbaccess = StatusCode::SUCCESS;
        ATH_MSG_INFO( "Access granted for all dbObjects needed by muon detectors" );
    }

~RDBReaderAtlas()

virtual MuonGM::RDBReaderAtlas::~RDBReaderAtlas ( )

virtualdefault

Member Function Documentation

getGeometryVersion()

const std::string & MuonGM::DBReader::getGeometryVersion ( ) const

inherited

Definition at line 22 of file DBReader.cxx.

{ return m_version; }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

ProcessCscInternalAlignments()

void MuonGM::RDBReaderAtlas::ProcessCscInternalAlignments

(

)

ProcessDB()

StatusCode MuonGM::RDBReaderAtlas::ProcessDB ( MYSQL & mysql )

overridevirtual

Reimplemented from MuonGM::DBReader.

Definition at line 179 of file RDBReaderAtlas.cxx.

                                                     {
        // Check access to the database (from the constructor)
        if (m_SCdbaccess == StatusCode::FAILURE) {
            return m_SCdbaccess;
        }
 
        // set GeometryVersion in MYSQL
        mysql.setGeometryVersion(getGeometryVersion());
        // set LayoutName read from amdb
        mysql.setLayoutName(m_dbam[0].amdb);
        // set NovaVersion     in MYSQL
        mysql.setNovaVersion(m_dbam[0].version);
        // set AmdbVersion     in MYSQL
        mysql.setNovaReadVersion(m_dbam[0].nvrs);
 
        // Process Stations and components
        MuonGM::ProcessStations(mysql, m_dhalmn.get(), m_almn, m_dhatyp.get(), m_atyp, m_dhwmdt.get(), m_wmdt);
 
        // Process Technologies
        ProcessTechnologies(mysql);
 
        // Process Positions
        MuonGM::ProcessPositions(mysql, m_dhaptp.get(), m_aptp);
 
        // Process Cutouts
        if (getGeometryVersion().substr(0, 1) != "P") {
            MuonGM::ProcessCutouts(mysql, m_dhacut.get(), m_acut, m_dhalin.get(), m_alin, m_dhatyp.get(), m_atyp);
        }
 
        // Process Alignements
        if (m_dhaszt && m_dhaszt->size() > 0) {
            MuonGM::ProcessAlignements(mysql, m_dhaszt.get(), m_aszt);
        }
 
        // Process TgcReadout
        RDBReaderAtlas::ProcessTGCreadout(mysql);
 
        //
        ATH_MSG_INFO( "Intermediate Objects built from primary numbers" );
 
        return m_SCdbaccess;
    }

ProcessTechnologies()

void MuonGM::RDBReaderAtlas::ProcessTechnologies ( MYSQL & mysql )

private

Definition at line 222 of file RDBReaderAtlas.cxx.

                                                         {
        // here loop over station-components to init technologies at each new entry
        std::vector<std::string> slist;
        slist.emplace_back("*");
        StationSelector sel(mysql, slist);
        StationSelector::StationIterator it;
        ATH_MSG_DEBUG( " from RDBReaderAtlas --- start " );
 
        bool have_spa_details = (getGeometryVersion().substr(0, 1) != "P");
 
        for (it = sel.begin(); it != sel.end(); ++it) {
            Station *station = (*it).second;
            for (int ic = 0; ic < station->GetNrOfComponents(); ic++) {
                Component *c = station->GetComponent(ic);
                if (c == nullptr)
                    continue;
                const std::string &cname = c->name;
 
                if (cname.compare(0, 3, "CSC") == 0)
                    MuonGM::ProcessCSC(mysql, m_dhwcsc.get(), m_wcsc, cname);
                else if (cname.compare(0, 3, "MDT") == 0)
                    MuonGM::ProcessMDT(mysql, m_dhwmdt.get(), m_wmdt, cname);
                else if (cname.compare(0, 3, "RPC") == 0)
                    MuonGM::ProcessRPC(mysql, m_dhwrpc.get(), m_wrpc, m_dhwrpcall.get(), m_wrpcall, cname);
                else if (cname.compare(0, 3, "TGC") == 0)
                    MuonGM::ProcessTGC(mysql, m_dhwtgc.get(), m_wtgc, m_dhwtgcall.get(), m_wtgcall, cname);
                else if (cname.compare(0, 3, "SPA") == 0)
                    MuonGM::ProcessSPA(mysql, m_dhwspa.get(), m_wspa, cname);
                else if (cname.compare(0, 3, "DED") == 0)
                    MuonGM::ProcessDED(mysql, m_dhwded.get(), m_wded, cname);
                else if (cname.compare(0, 3, "SUP") == 0)
                    MuonGM::ProcessSUP(mysql, m_dhwsup.get(), m_wsup, cname);
                else if (cname.compare(0, 3, "CHV") == 0 && have_spa_details)
                    MuonGM::ProcessCHV(mysql, m_dhwchv.get(), m_wchv, cname);
                else if (cname.compare(0, 3, "CRO") == 0 && have_spa_details)
                    MuonGM::ProcessCRO(mysql, m_dhwcro.get(), m_wcro, cname);
                else if (cname.compare(0, 3, "CMI") == 0 && have_spa_details)
                    MuonGM::ProcessCMI(mysql, m_dhwcmi.get(), m_wcmi, cname);
                else if (cname.compare(0, 2, "LB") == 0 && have_spa_details)
                    MuonGM::ProcessLBI(mysql, m_dhwlbi.get(), m_wlbi, cname);
            }
        }
 
        ATH_MSG_INFO( "nMDT " << nmdt << " nCSC " << ncsc << " nTGC " << ntgc << " nRPC " << nrpc );
        ATH_MSG_INFO( "nDED " << nded << " nSUP " << nsup << " nSPA " << nspa );
        ATH_MSG_INFO( "nCHV " << nchv << " nCRO " << ncro << " nCMI " << ncmi << " nLBI " << nlbi );
    }

ProcessTGCreadout()

void MuonGM::RDBReaderAtlas::ProcessTGCreadout

(

MYSQL &

mysql

)

Definition at line 270 of file RDBReaderAtlas.cxx.

                                                       {
        //
        // in case of layout Q and following
        //
        IRDBRecordset_ptr ggln = m_pRDBAccess->getRecordsetPtr("GGLN", m_geoTag, m_geoNode);
 
        int version(0);
        float wirespacing(0);
        unsigned int gglnSize(0);
        if (ggln)
            gglnSize = ggln->size();
        else {
            ATH_MSG_WARNING(" ProcessTGCreadout - IRDBRecordset_ptr GGLN is nullptr" );
        }
        if (gglnSize) {
            version = (int)(*ggln)[0]->getInt("VERS");
            wirespacing = (*ggln)[0]->getFloat("WIRESP") * Gaudi::Units::mm;
        }
 
        ATH_MSG_INFO( " ProcessTGCreadout - version " << version << " wirespacing " << wirespacing );
 
        // loop over the banks of station components: ALMN
        for (unsigned int ich = 0; ich < gglnSize; ++ich) {
            int type = (int)(*ggln)[ich]->getInt("JSTA");
            std::string name = "TGCReadout" + MuonGM::buildString(type, 2);
 
            // NCHRNG missing in GGLN, HARD-CODED !!!
            int nchrng;
            if (type == 1 || type == 6 || type == 12 || type >= 18) {
                nchrng = 24;
            } else {
                nchrng = 48;
            }
            using enum TgcReadoutParams::TgcReadoutArraySizes;
            GasGapIntArray nwgs{make_array<int, MaxNGaps>(0)};
            GasGapIntArray nsps{make_array<int, MaxNGaps>(0)};
            WiregangArray iwgs1{make_array<int, MaxNGangs>(0)};
            WiregangArray iwgs2{make_array<int, MaxNGangs>(0)};
            WiregangArray iwgs3{make_array<int, MaxNGangs>(0)};
            std::vector<StripArray> slarge{make_array<double, MaxNStrips>(0)}; 
            std::vector<StripArray> sshort{make_array<double, MaxNStrips>(0)};
 
            for (int i = 0; i < 3; i++) {
                nwgs[i] = (*ggln)[ich]->getInt("NWGS", i );
                nsps[i] = (*ggln)[ich]->getInt("NSPS", i);
            }
            for (int i = 0; i < nwgs[0]; i++) {
                iwgs1[i] = (*ggln)[ich]->getInt("IWGS1", i);
            }
 
            for (int i = 0; i < nwgs[1]; i++) {
                iwgs2[i] = (*ggln)[ich]->getInt("IWGS2", i);
            }
            for (int i = 0; i < nwgs[2]; i++) {
                iwgs3[i] = (*ggln)[ich]->getInt("IWGS3", i);
            }
 
            // read and store parameters for strips
            float pdist = (*ggln)[ich]->getFloat("PDIST");
 
            for (int i = 0; i < nsps[0] + 1; i++) {
                slarge[0][i] = (*ggln)[ich]->getFloat("SLARGE", i);
                sshort[0][i] = (*ggln)[ich]->getFloat("SHORT", i);
            }
            GeoModel::TransientConstSharedPtr<TgcReadoutParams> rpar = 
                    std::make_unique<TgcReadoutParams>(name, type, wirespacing, nchrng, 
                                                      std::move(nwgs), 
                                                      std::move(iwgs1), 
                                                      std::move(iwgs2), 
                                                      std::move(iwgs3), 
                                                      pdist, 
                                                      std::move(slarge), 
                                                      std::move(sshort), 
                                                      std::move(nsps));
            mysql.StoreTgcRPars(rpar);
            // parameters for TGC inactive inner structure
 
            std::ostringstream Astr;
            if (ich < 9) {
                Astr << "0" << ich + 1;
            } else {
                Astr << ich + 1;
            }
            std::string A = Astr.str();
            TGC *tgc = dynamic_cast<TGC*>(mysql.GetTechnology("TGC" + A));
            tgc->widthWireSupport = (*ggln)[ich]->getFloat("S1PP");
            tgc->widthGasChannel = (*ggln)[ich]->getFloat("S2PP");
            tgc->distanceWireSupport = (*ggln)[ich]->getFloat("WSEP");
            tgc->offsetWireSupport[0] = (*ggln)[ich]->getFloat("SP1WI");
            tgc->offsetWireSupport[1] = (*ggln)[ich]->getFloat("SP2WI");
            tgc->offsetWireSupport[2] = (*ggln)[ich]->getFloat("SP3WI");
            tgc->angleTilt = (*ggln)[ich]->getFloat("TILT") * Gaudi::Units::deg;
            tgc->radiusButton = (*ggln)[ich]->getFloat("SP1BU");
            tgc->pitchButton[0] = (*ggln)[ich]->getFloat("SP2BU");
            tgc->pitchButton[1] = (*ggln)[ich]->getFloat("SP3BU");
            tgc->angleButton = (*ggln)[ich]->getFloat("SP4BU") * Gaudi::Units::deg;
        }
        
    }

setGeometryVersion()

void MuonGM::DBReader::setGeometryVersion ( std::string s )

inherited

Definition at line 20 of file DBReader.cxx.

{ m_version = std::move(geoVersion); }

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setManager()

void MuonGM::DBReader::setManager ( MuonDetectorManager * detmgr )

inlineinherited

Definition at line 121 of file DBReader.h.

{ m_mgr = detmgr; };

TGCreadoutName()

std::string MuonGM::RDBReaderAtlas::TGCreadoutName

(

int

ichtyp

)

Definition at line 370 of file RDBReaderAtlas.cxx.

                                                       {
       
        if (getGeometryVersion().substr(0, 1) == "P") {
 
            if (m_tgcReadoutMapping.empty()) {
                // first time fill the vector
                m_tgcReadoutMapping.emplace_back("T1F1"); // 1
 
                m_tgcReadoutMapping.emplace_back("T1E1"); // 2
                m_tgcReadoutMapping.emplace_back("T1E2");
                m_tgcReadoutMapping.emplace_back("T1E3");
                m_tgcReadoutMapping.emplace_back("T1E4");
 
                m_tgcReadoutMapping.emplace_back("T2F1"); // 6
 
                m_tgcReadoutMapping.emplace_back("T2E1"); // 7
                m_tgcReadoutMapping.emplace_back("T2E2");
                m_tgcReadoutMapping.emplace_back("T2E3");
                m_tgcReadoutMapping.emplace_back("T2E4");
                m_tgcReadoutMapping.emplace_back("T2E5"); // 11
 
                m_tgcReadoutMapping.emplace_back("T3F1"); // 12
 
                m_tgcReadoutMapping.emplace_back("T3E1"); // 13
                m_tgcReadoutMapping.emplace_back("T3E2");
                m_tgcReadoutMapping.emplace_back("T3E3");
                m_tgcReadoutMapping.emplace_back("T3E4");
                m_tgcReadoutMapping.emplace_back("T3E5"); // 17
 
                m_tgcReadoutMapping.emplace_back("T4F1"); // 18
 
                m_tgcReadoutMapping.emplace_back("T4E1"); // 19
            }
 
            if (ichtyp < 1 || ichtyp > 19) {
                ATH_MSG_ERROR( " DBReader::TGCreadoutName  - ichtype " << ichtyp << " out of range 1-19" );
                return "XXXY";
            }
        } else { // if (getGeometryVersion().substr(0,1) == "Q")
 
            // Layout Q and following
            //
            if (m_tgcReadoutMapping.empty()) {
                // first time fill the vector
 
                m_tgcReadoutMapping.emplace_back("T1F1_1"); // 1
 
                m_tgcReadoutMapping.emplace_back("T1E1_1"); // 2
                m_tgcReadoutMapping.emplace_back("T1E1_2");
                m_tgcReadoutMapping.emplace_back("T1E1_3");
                m_tgcReadoutMapping.emplace_back("T1E1_4");
 
                m_tgcReadoutMapping.emplace_back("T2F1_1"); // 6
 
                m_tgcReadoutMapping.emplace_back("T2E1_1"); // 7
                m_tgcReadoutMapping.emplace_back("T2E1_2");
                m_tgcReadoutMapping.emplace_back("T2E1_3");
                m_tgcReadoutMapping.emplace_back("T2E1_4");
                m_tgcReadoutMapping.emplace_back("T2E1_5"); // 11
 
                m_tgcReadoutMapping.emplace_back("T3F1_1"); // 12
 
                m_tgcReadoutMapping.emplace_back("T3E1_1"); // 13
                m_tgcReadoutMapping.emplace_back("T3E1_2");
                m_tgcReadoutMapping.emplace_back("T3E1_3");
                m_tgcReadoutMapping.emplace_back("T3E1_4");
                m_tgcReadoutMapping.emplace_back("T3E1_5"); // 17
 
                m_tgcReadoutMapping.emplace_back("T4F1_1"); // 18
                m_tgcReadoutMapping.emplace_back("T4F2_1"); // 19
 
                m_tgcReadoutMapping.emplace_back("T4E1_1"); // 20
                m_tgcReadoutMapping.emplace_back("T4E2_1"); // 21
            }
 
            if (ichtyp < 1 || ichtyp > 21) {
                ATH_MSG_ERROR( " DBReader::TGCreadoutName  - ichtype " << ichtyp << " out of range 1-21" );
                return "XXXY";
            }
        }
 
        return m_tgcReadoutMapping[ichtyp - 1];
    }

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_acut

const DblQ00Acut::ACUT* MuonGM::RDBReaderAtlas::m_acut {nullptr}

private

Definition at line 67 of file RDBReaderAtlas.h.

{nullptr};

m_alin

const DblQ00Alin::ALIN* MuonGM::RDBReaderAtlas::m_alin {nullptr}

private

Definition at line 68 of file RDBReaderAtlas.h.

{nullptr};

m_almn

const DblQ00Almn::ALMN* MuonGM::RDBReaderAtlas::m_almn {nullptr}

private

Definition at line 63 of file RDBReaderAtlas.h.

{nullptr};

m_aptp

const DblQ00Aptp::APTP* MuonGM::RDBReaderAtlas::m_aptp {nullptr}

private

Definition at line 64 of file RDBReaderAtlas.h.

{nullptr};

m_asciiFileDB

std::string MuonGM::RDBReaderAtlas::m_asciiFileDB {}

private

Definition at line 87 of file RDBReaderAtlas.h.

{};

m_asmp

const DblQ00Asmp::ASMP* MuonGM::RDBReaderAtlas::m_asmp {nullptr}

private

Definition at line 62 of file RDBReaderAtlas.h.

{nullptr};

m_aszt

const DblQ00Aszt::ASZT* MuonGM::RDBReaderAtlas::m_aszt {nullptr}

private

Definition at line 80 of file RDBReaderAtlas.h.

{nullptr};

m_atyp

const DblQ00Atyp::ATYP* MuonGM::RDBReaderAtlas::m_atyp {nullptr}

private

Definition at line 61 of file RDBReaderAtlas.h.

{nullptr};

m_dbam

const DblQ00Dbam::DBAM* MuonGM::RDBReaderAtlas::m_dbam {nullptr}

private

Definition at line 60 of file RDBReaderAtlas.h.

{nullptr};

m_dhacut

std::unique_ptr<DblQ00Acut> MuonGM::RDBReaderAtlas::m_dhacut {nullptr}

private

Definition at line 44 of file RDBReaderAtlas.h.

{nullptr};

m_dhalin

std::unique_ptr<DblQ00Alin> MuonGM::RDBReaderAtlas::m_dhalin {nullptr}

private

Definition at line 45 of file RDBReaderAtlas.h.

{nullptr};

m_dhalmn

std::unique_ptr<DblQ00Almn> MuonGM::RDBReaderAtlas::m_dhalmn {nullptr}

private

Definition at line 40 of file RDBReaderAtlas.h.

{nullptr};

m_dhaptp

std::unique_ptr<DblQ00Aptp> MuonGM::RDBReaderAtlas::m_dhaptp {nullptr}

private

Definition at line 41 of file RDBReaderAtlas.h.

{nullptr};

m_dhasmp

std::unique_ptr<DblQ00Asmp> MuonGM::RDBReaderAtlas::m_dhasmp {nullptr}

private

Definition at line 39 of file RDBReaderAtlas.h.

{nullptr};

m_dhaszt

std::unique_ptr<DblQ00Aszt> MuonGM::RDBReaderAtlas::m_dhaszt {nullptr}

private

Definition at line 57 of file RDBReaderAtlas.h.

{nullptr};

m_dhatyp

std::unique_ptr<DblQ00Atyp> MuonGM::RDBReaderAtlas::m_dhatyp {nullptr}

private

Definition at line 38 of file RDBReaderAtlas.h.

{nullptr};

m_dhdbam

std::unique_ptr<DblQ00Dbam> MuonGM::RDBReaderAtlas::m_dhdbam {nullptr}

private

Definition at line 37 of file RDBReaderAtlas.h.

{nullptr};

m_dhiacsc

std::unique_ptr<DblQ00IAcsc> MuonGM::RDBReaderAtlas::m_dhiacsc {nullptr}

private

Definition at line 58 of file RDBReaderAtlas.h.

{nullptr};

m_dhwchv

std::unique_ptr<DblQ00Wchv> MuonGM::RDBReaderAtlas::m_dhwchv {nullptr}

private

Definition at line 53 of file RDBReaderAtlas.h.

{nullptr};

m_dhwcmi

std::unique_ptr<DblQ00Wcmi> MuonGM::RDBReaderAtlas::m_dhwcmi {nullptr}

private

Definition at line 55 of file RDBReaderAtlas.h.

{nullptr};

m_dhwcro

std::unique_ptr<DblQ00Wcro> MuonGM::RDBReaderAtlas::m_dhwcro {nullptr}

private

Definition at line 54 of file RDBReaderAtlas.h.

{nullptr};

m_dhwcsc

std::unique_ptr<DblQ00Wcsc> MuonGM::RDBReaderAtlas::m_dhwcsc {nullptr}

private

Definition at line 47 of file RDBReaderAtlas.h.

{nullptr};

m_dhwded

std::unique_ptr<DblQ00Wded> MuonGM::RDBReaderAtlas::m_dhwded {nullptr}

private

Definition at line 50 of file RDBReaderAtlas.h.

{nullptr};

m_dhwlbi

std::unique_ptr<DblQ00Wlbi> MuonGM::RDBReaderAtlas::m_dhwlbi {nullptr}

private

Definition at line 56 of file RDBReaderAtlas.h.

{nullptr};

m_dhwmdt

std::unique_ptr<DblQ00Wmdt> MuonGM::RDBReaderAtlas::m_dhwmdt {nullptr}

private

Definition at line 46 of file RDBReaderAtlas.h.

{nullptr};

m_dhwrpc

std::unique_ptr<DblQ00Awln> MuonGM::RDBReaderAtlas::m_dhwrpc {nullptr}

private

Definition at line 42 of file RDBReaderAtlas.h.

{nullptr};

m_dhwrpcall

std::unique_ptr<DblQ00Wrpc> MuonGM::RDBReaderAtlas::m_dhwrpcall {nullptr}

private

Definition at line 48 of file RDBReaderAtlas.h.

{nullptr};

m_dhwspa

std::unique_ptr<DblQ00Wspa> MuonGM::RDBReaderAtlas::m_dhwspa {nullptr}

private

Definition at line 52 of file RDBReaderAtlas.h.

{nullptr};

m_dhwsup

std::unique_ptr<DblQ00Wsup> MuonGM::RDBReaderAtlas::m_dhwsup {nullptr}

private

Definition at line 51 of file RDBReaderAtlas.h.

{nullptr};

m_dhwtgc

std::unique_ptr<DblQ00Atln> MuonGM::RDBReaderAtlas::m_dhwtgc {nullptr}

private

Definition at line 43 of file RDBReaderAtlas.h.

{nullptr};

m_dhwtgcall

std::unique_ptr<DblQ00Wtgc> MuonGM::RDBReaderAtlas::m_dhwtgcall {nullptr}

private

Definition at line 49 of file RDBReaderAtlas.h.

{nullptr};

m_dhxtomo

std::unique_ptr<DblQ00Xtomo> MuonGM::RDBReaderAtlas::m_dhxtomo {nullptr}

private

Definition at line 59 of file RDBReaderAtlas.h.

{nullptr};

m_geoNode

const std::string MuonGM::RDBReaderAtlas::m_geoNode {}

private

Definition at line 85 of file RDBReaderAtlas.h.

{};

m_geoTag

const std::string MuonGM::RDBReaderAtlas::m_geoTag {}

private

Definition at line 84 of file RDBReaderAtlas.h.

{};

m_iacsc

const DblQ00IAcsc::IACSC* MuonGM::RDBReaderAtlas::m_iacsc {nullptr}

private

Definition at line 81 of file RDBReaderAtlas.h.

{nullptr};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_mgr

MuonDetectorManager* MuonGM::DBReader::m_mgr

protectedinherited

Definition at line 132 of file DBReader.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_msgSvc

IMessageSvc* MuonGM::DBReader::m_msgSvc

privateinherited

Definition at line 136 of file DBReader.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_pRDBAccess

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

private

Definition at line 86 of file RDBReaderAtlas.h.

{nullptr};

m_SCdbaccess

StatusCode MuonGM::DBReader::m_SCdbaccess

protectedinherited

Definition at line 128 of file DBReader.h.

m_tgcReadoutMapping

std::vector<std::string> MuonGM::DBReader::m_tgcReadoutMapping

protectedinherited

Definition at line 131 of file DBReader.h.

m_version

std::string MuonGM::DBReader::m_version

privateinherited

Definition at line 137 of file DBReader.h.

m_wchv

const DblQ00Wchv::WCHV* MuonGM::RDBReaderAtlas::m_wchv {nullptr}

private

Definition at line 76 of file RDBReaderAtlas.h.

{nullptr};

m_wcmi

const DblQ00Wcmi::WCMI* MuonGM::RDBReaderAtlas::m_wcmi {nullptr}

private

Definition at line 78 of file RDBReaderAtlas.h.

{nullptr};

m_wcro

const DblQ00Wcro::WCRO* MuonGM::RDBReaderAtlas::m_wcro {nullptr}

private

Definition at line 77 of file RDBReaderAtlas.h.

{nullptr};

m_wcsc

const DblQ00Wcsc::WCSC* MuonGM::RDBReaderAtlas::m_wcsc {nullptr}

private

Definition at line 70 of file RDBReaderAtlas.h.

{nullptr};

m_wded

const DblQ00Wded::WDED* MuonGM::RDBReaderAtlas::m_wded {nullptr}

private

Definition at line 73 of file RDBReaderAtlas.h.

{nullptr};

m_wlbi

const DblQ00Wlbi::WLBI* MuonGM::RDBReaderAtlas::m_wlbi {nullptr}

private

Definition at line 79 of file RDBReaderAtlas.h.

{nullptr};

m_wmdt

const DblQ00Wmdt::WMDT* MuonGM::RDBReaderAtlas::m_wmdt {nullptr}

private

Definition at line 69 of file RDBReaderAtlas.h.

{nullptr};

m_wrpc

const DblQ00Awln::AWLN* MuonGM::RDBReaderAtlas::m_wrpc {nullptr}

private

Definition at line 65 of file RDBReaderAtlas.h.

{nullptr};

m_wrpcall

const DblQ00Wrpc::WRPC* MuonGM::RDBReaderAtlas::m_wrpcall {nullptr}

private

Definition at line 71 of file RDBReaderAtlas.h.

{nullptr};

m_wspa

const DblQ00Wspa::WSPA* MuonGM::RDBReaderAtlas::m_wspa {nullptr}

private

Definition at line 75 of file RDBReaderAtlas.h.

{nullptr};

m_wsup

const DblQ00Wsup::WSUP* MuonGM::RDBReaderAtlas::m_wsup {nullptr}

private

Definition at line 74 of file RDBReaderAtlas.h.

{nullptr};

m_wtgc

const DblQ00Atln::ATLN* MuonGM::RDBReaderAtlas::m_wtgc {nullptr}

private

Definition at line 66 of file RDBReaderAtlas.h.

{nullptr};

m_wtgcall

const DblQ00Wtgc::WTGC* MuonGM::RDBReaderAtlas::m_wtgcall {nullptr}

private

Definition at line 72 of file RDBReaderAtlas.h.

{nullptr};

m_xtomo

const DblQ00Xtomo::XTOMO* MuonGM::RDBReaderAtlas::m_xtomo {nullptr}

private

Definition at line 82 of file RDBReaderAtlas.h.

{nullptr};

---

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

• RDBReaderAtlas.h
• RDBReaderAtlas.cxx