#include <RDBReaderAtlas.h>

Inheritance diagram for MuonGM::RDBReaderAtlas:

Collaboration 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. More...

MsgStream &	msg () const
	The standard message stream. More...

MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

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. More...

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. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

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 25 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 retriving 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.

22 { 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();
   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 164 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 179 of file AthMessaging.h.

180 { 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_initialized.test_and_set()) initMessaging();
   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 178 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 221 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 269 of file RDBReaderAtlas.cxx.

                                                        {
  
         if (getGeometryVersion().substr(0, 1) == "P") {
             IRDBRecordset_ptr ggsd = m_pRDBAccess->getRecordsetPtr("GGSD", m_geoTag, m_geoNode);
             IRDBRecordset_ptr ggcd = m_pRDBAccess->getRecordsetPtr("GGCD", m_geoTag, m_geoNode);
             ATH_MSG_INFO( "RDBReaderAtlas::ProcessTGCreadout GGSD, GGCD retrieven from Oracle" );
  
             int version = (int)(*ggsd)[0]->getDouble("VERS");
             float wirespacing = (*ggsd)[0]->getDouble("WIRESP") * Gaudi::Units::cm;
             ATH_MSG_INFO( " ProcessTGCreadout - version " << version << " wirespacing " << wirespacing );
  
             //
             // in case of the layout P03
             //
  
             // loop over the banks of station components: ALMN
             for (unsigned int ich = 0; ich < ggcd->size(); ++ich) {
                 int type = (int)(*ggcd)[ich]->getDouble("ICHTYP");
  
                 if (ich < 19) {
                     std::string name = RDBReaderAtlas::TGCreadoutName(type);
  
                     int nchrng = (int)(*ggcd)[ich]->getDouble("NCHRNG");
            
                     GasGapIntArray nwgs{}, nsps{};
                     WiregangArray iwgs1{}, iwgs2{}, iwgs3{};
  
                     for (int i = 0; i < 3; ++i) {
                         nwgs[i] = (*ggcd)[ich]->getDouble("NWGS", i);
                         nsps[i] = (*ggcd)[ich]->getDouble("NSPS", i);
                     }
  
                     for (int i = 0; i < nwgs[0]; ++i) {
                         iwgs1[i] = (*ggcd)[ich]->getDouble("IWGS1", i);
                     }
                     for (int i = 0; i < nwgs[1]; ++i) {
                         iwgs2[i] = (*ggcd)[ich]->getDouble("IWGS2" , i);
                     }
  
                     for (int i = 0; i < nwgs[2]; ++i) {
                         iwgs3[i] = (*ggcd)[ich]->getDouble("IWGS3", i);
                     }
                     GeoModel::TransientConstSharedPtr<TgcReadoutParams> rpar = 
                                 std::make_unique<TgcReadoutParams>(name, type, version, wirespacing, nchrng, 
                                                                    std::move(nwgs), std::move(iwgs1), 
                                                                    std::move(iwgs2), std::move(iwgs3), 
                                                                    std::move(nsps));
                     mysql.StoreTgcRPars(rpar);
                 }
             }
         } else {
             //
             // 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;
                 }
                 GasGapIntArray nwgs{}, nsps{};
                 WiregangArray iwgs1{}, iwgs2{}, iwgs3{};
                 StripArray slarge{}, sshort{};
  
                 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[i] = (*ggln)[ich]->getFloat("SLARGE", i);
                     sshort[i] = (*ggln)[ich]->getFloat("SHORT", i);
                 }
                 GeoModel::TransientConstSharedPtr<TgcReadoutParams> rpar = 
                         std::make_unique<TgcReadoutParams>(name, type, version, 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.

20 { 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.

121 { m_mgr = detmgr; };

◆ TGCreadoutName()

std::string MuonGM::RDBReaderAtlas::TGCreadoutName ( int ichtyp )

Definition at line 412 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.

◆ m_alin

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

private

Definition at line 68 of file RDBReaderAtlas.h.

◆ m_almn

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

private

Definition at line 63 of file RDBReaderAtlas.h.

◆ m_aptp

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

private

Definition at line 64 of file RDBReaderAtlas.h.

◆ 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.

◆ m_aszt

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

private

Definition at line 80 of file RDBReaderAtlas.h.

◆ m_atyp

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

private

Definition at line 61 of file RDBReaderAtlas.h.

◆ m_dbam

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

private

Definition at line 60 of file RDBReaderAtlas.h.

◆ m_dhacut

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

private

Definition at line 44 of file RDBReaderAtlas.h.

◆ m_dhalin

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

private

Definition at line 45 of file RDBReaderAtlas.h.

◆ m_dhalmn

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

private

Definition at line 40 of file RDBReaderAtlas.h.

◆ m_dhaptp

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

private

Definition at line 41 of file RDBReaderAtlas.h.

◆ m_dhasmp

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

private

Definition at line 39 of file RDBReaderAtlas.h.

◆ m_dhaszt

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

private

Definition at line 57 of file RDBReaderAtlas.h.

◆ m_dhatyp

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

private

Definition at line 38 of file RDBReaderAtlas.h.

◆ m_dhdbam

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

private

Definition at line 37 of file RDBReaderAtlas.h.

◆ m_dhiacsc

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

private

Definition at line 58 of file RDBReaderAtlas.h.

◆ m_dhwchv

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

private

Definition at line 53 of file RDBReaderAtlas.h.

◆ m_dhwcmi

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

private

Definition at line 55 of file RDBReaderAtlas.h.

◆ m_dhwcro

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

private

Definition at line 54 of file RDBReaderAtlas.h.

◆ m_dhwcsc

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

private

Definition at line 47 of file RDBReaderAtlas.h.

◆ m_dhwded

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

private

Definition at line 50 of file RDBReaderAtlas.h.

◆ m_dhwlbi

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

private

Definition at line 56 of file RDBReaderAtlas.h.

◆ m_dhwmdt

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

private

Definition at line 46 of file RDBReaderAtlas.h.

◆ m_dhwrpc

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

private

Definition at line 42 of file RDBReaderAtlas.h.

◆ m_dhwrpcall

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

private

Definition at line 48 of file RDBReaderAtlas.h.

◆ m_dhwspa

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

private

Definition at line 52 of file RDBReaderAtlas.h.

◆ m_dhwsup

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

private

Definition at line 51 of file RDBReaderAtlas.h.

◆ m_dhwtgc

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

private

Definition at line 43 of file RDBReaderAtlas.h.

◆ m_dhwtgcall

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

private

Definition at line 49 of file RDBReaderAtlas.h.

◆ m_dhxtomo

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

private

Definition at line 59 of file RDBReaderAtlas.h.

◆ 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.

◆ m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ 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.

◆ 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.

◆ m_wcmi

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

private

Definition at line 78 of file RDBReaderAtlas.h.

◆ m_wcro

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

private

Definition at line 77 of file RDBReaderAtlas.h.

◆ m_wcsc

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

private

Definition at line 70 of file RDBReaderAtlas.h.

◆ m_wded

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

private

Definition at line 73 of file RDBReaderAtlas.h.

◆ m_wlbi

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

private

Definition at line 79 of file RDBReaderAtlas.h.

◆ m_wmdt

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

private

Definition at line 69 of file RDBReaderAtlas.h.

◆ m_wrpc

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

private

Definition at line 65 of file RDBReaderAtlas.h.

◆ m_wrpcall

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

private

Definition at line 71 of file RDBReaderAtlas.h.

◆ m_wspa

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

private

Definition at line 75 of file RDBReaderAtlas.h.

◆ m_wsup

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

private

Definition at line 74 of file RDBReaderAtlas.h.

◆ m_wtgc

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

private

Definition at line 66 of file RDBReaderAtlas.h.

◆ m_wtgcall

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

private

Definition at line 72 of file RDBReaderAtlas.h.

◆ m_xtomo

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

private

Definition at line 82 of file RDBReaderAtlas.h.

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

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RDBReaderAtlas()

◆ ~RDBReaderAtlas()

Member Function Documentation

◆ getGeometryVersion()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ ProcessCscInternalAlignments()

◆ ProcessDB()

◆ ProcessTechnologies()

◆ ProcessTGCreadout()

◆ setGeometryVersion()

◆ setLevel()

◆ setManager()

◆ TGCreadoutName()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_acut

◆ m_alin

◆ m_almn

◆ m_aptp

◆ m_asciiFileDB

◆ m_asmp

◆ m_aszt

◆ m_atyp

◆ m_dbam

◆ m_dhacut

◆ m_dhalin

◆ m_dhalmn

◆ m_dhaptp

◆ m_dhasmp

◆ m_dhaszt

◆ m_dhatyp

◆ m_dhdbam

◆ m_dhiacsc

◆ m_dhwchv

◆ m_dhwcmi

◆ m_dhwcro

◆ m_dhwcsc

◆ m_dhwded

◆ m_dhwlbi

◆ m_dhwmdt

◆ m_dhwrpc

◆ m_dhwrpcall

◆ m_dhwspa

◆ m_dhwsup

◆ m_dhwtgc

◆ m_dhwtgcall

◆ m_dhxtomo

◆ m_geoNode

◆ m_geoTag

◆ m_iacsc

◆ m_imsg

◆ m_lvl

◆ m_mgr

◆ m_msg_tls

◆ m_msgSvc

◆ m_nm

◆ m_pRDBAccess

◆ m_SCdbaccess

◆ m_tgcReadoutMapping

◆ m_version

◆ m_wchv

◆ m_wcmi

◆ m_wcro

◆ m_wcsc

◆ m_wded

◆ m_wlbi

◆ m_wmdt

◆ m_wrpc

◆ m_wrpcall

◆ m_wspa

◆ m_wsup