TrigConf::TrigDBCTPFilesLoader Class Reference

Loader of trigger configurations from Json files. More...

#include <TrigDBCTPFilesLoader.h>

Inheritance diagram for TrigConf::TrigDBCTPFilesLoader:

Collaboration diagram for TrigConf::TrigDBCTPFilesLoader:

Public Member Functions
	TrigDBCTPFilesLoader (const std::string &connection)
	Constructor.
virtual	~TrigDBCTPFilesLoader () override
	Destructor - cannot be defined here because QueryDefinition is an incomplete type.
bool	loadHardwareFiles (unsigned int smk, L1CTPFiles &ctpfiles, uint8_t loadMask=0x0F, const std::string &outFileName="") const
	Load content from the Trigger DB into an L1CTPFiles object for a given super master key (SMK)
void	setCrestConnection (const std::string &server, const std::string &version="")
	declare CREST as the source of the configuration An empty crest server makes it use Oracle
void	setCrestTrigDB (const std::string &crestTrigDB)
	set trigger db for the crest connection
size_t	schemaVersion (coral::ISessionProxy *session) const
	access to TriggerDB schema version
void	setLevel (MSGTC::Level lvl)
MSGTC::Level	outputLevel () const
bool	msgLvl (const MSGTC::Level lvl) const
	Test the output level.
MsgStreamTC &	msg () const
	The standard message stream.
MsgStreamTC &	msg (const MSGTC::Level lvl) const
	The standard message stream.
const std::string &	getName () const
	name accessor

Protected Member Functions
bool	useCrest () const
std::string	getTrigDataCrest (const std::string &type, int key) const
	Get trigger configuration from the TriggerDB through Crest.
std::unique_ptr< coral::ISessionProxy >	createDBSession () const
	create (if needed) DB session and return the session proxy
QueryDefinition	getQueryDefinition (size_t schemaVersion, const std::map< size_t, QueryDefinition > &queries) const
	return query for given schemaVersion from possible queries
void	loadFromCrest (unsigned int key, boost::property_tree::ptree &pt, const std::string &outFileName, const std::string &description, const std::string &query_type) const
void	loadFromOracle (unsigned int key, boost::property_tree::ptree &pt, const std::string &outFileName, const std::string &description, const std::map< size_t, QueryDefinition > &queries) const

Private Member Functions
void	loadCTPFiles (L1CTPFiles &ctpfiles, std::unique_ptr< coral::IQuery > query, size_t schemaVersion) const
void	loadCTPSMX (L1CTPFiles &ctpfiles, std::unique_ptr< coral::IQuery > query, size_t schemaVersion) const
void	loadTMC (L1CTPFiles &ctpfiles, std::unique_ptr< coral::IQuery > query, size_t schemaVersion) const
void	loadMUCTPI (L1CTPFiles &ctpfiles, std::unique_ptr< coral::IQuery > query, size_t schemaVersion) const
std::vector< uint32_t >	loadDBFieldIntoVector (const coral::AttributeList &row, const std::string &field, size_t size) const
std::string	loadDBFieldIntoString (const coral::AttributeList &row, const std::string &field) const

Private Attributes
std::map< size_t, QueryDefinition >	m_link_queries
std::map< size_t, QueryDefinition >	m_ctpfiles_queries
std::map< size_t, QueryDefinition >	m_ctpsmx_queries
std::map< size_t, QueryDefinition >	m_muctpi_queries
std::map< size_t, QueryDefinition >	m_tmcsig_queries
bool	m_useCrest {false}
std::string	m_connection {""}
std::string	m_crestServer {""}
std::string	m_crestVersion {""}
std::string	m_crestTrigDb {""}
int	m_retrialPeriod {0}
int	m_retrialTimeout {0}
int	m_connectionTimeout {0}
boost::thread_specific_ptr< MsgStreamTC >	m_msg_tls
	MsgStreamTC instance (a std::cout like with print-out levels)
std::string	m_name

Detailed Description

Loader of trigger configurations from Json files.

Definition at line 30 of file TrigDBCTPFilesLoader.h.

Constructor & Destructor Documentation

TrigDBCTPFilesLoader()

TrigConf::TrigDBCTPFilesLoader::TrigDBCTPFilesLoader

(

const std::string &

connection

)

Constructor.

Definition at line 9 of file TrigDBCTPFilesLoader.cxx.

                                                                               : 
   TrigDBLoader("TrigDBCTPFilesLoader", connection)
{
   // CTP and MUCTPI hardware files only exist for schema versions >= 3
 
   { // links to file tables
      auto & q = m_link_queries[3];
      // tables
      q.addToTableList ( "SUPER_MASTER_TABLE", "SMT" );
      q.addToTableList ( "L1_MENU", "L1TM" );
      // bind vars
      q.extendBinding<unsigned int>("smk");
      // conditions
      q.extendCondition("SMT.SMT_ID = :smk AND SMT.SMT_L1_MENU_ID = L1TM.L1TM_ID");
      // attributes
      q.extendOutput<unsigned int>( "L1TM.L1TM_CTP_FILES_ID");
      q.extendOutput<unsigned int>( "L1TM.L1TM_CTP_SMX_ID");
      q.extendOutput<unsigned int>( "L1TM.L1TM_MUCTPI_FILES_ID");
      q.extendOutput<unsigned int>( "L1TM.L1TM_TMC_SIGNALS_ID");
   }
 
   { // ctp files
      auto & q = m_ctpfiles_queries[3];
      // tables
      q.addToTableList ( "L1_CTP_FILES" );
      // bind vars
      q.extendBinding<unsigned int>("id");
      // conditions
      q.extendCondition("L1CF_ID = :id");
      // attributes
      q.extendOutput<coral::Blob>( "L1CF_LUT" );
      q.extendOutput<coral::Blob>( "L1CF_CAM" );
      q.extendOutput<coral::Blob>( "L1CF_MON_SEL_SLOT7" );
      q.extendOutput<coral::Blob>( "L1CF_MON_SEL_SLOT8" );
      q.extendOutput<coral::Blob>( "L1CF_MON_SEL_SLOT9" );
      q.extendOutput<coral::Blob>( "L1CF_MON_SEL_CTPMON" );
      q.extendOutput<coral::Blob>( "L1CF_MON_DEC_SLOT7" );
      q.extendOutput<coral::Blob>( "L1CF_MON_DEC_SLOT8" );
      q.extendOutput<coral::Blob>( "L1CF_MON_DEC_SLOT9" );
      q.extendOutput<coral::Blob>( "L1CF_MON_DEC_CTPMON" );
      q.extendOutput<coral::Blob>( "L1CF_MON_DMX" );
   }
 
   {
      // ctp files >= v6
      // in version 6 this field (ctp core switchmatrix) was added
      auto q = m_ctpfiles_queries[3];
      q.extendOutput<coral::Blob>( "L1CF_SMX" );
      m_ctpfiles_queries[6] = std::move(q);
   }
 
   { // ctp smx
      auto & q = m_ctpsmx_queries[3];
      // tables
      q.addToTableList ( "L1_CTP_SMX" );
      // bind vars
      q.extendBinding<unsigned int>("id");
      // conditions
      q.extendCondition("L1SMX_ID = :id");
      // attributes
      q.extendOutput<coral::Blob>( "L1SMX_OUTPUT" );
      q.extendOutput<coral::Blob>( "L1SMX_VHDL_SLOT7" );
      q.extendOutput<coral::Blob>( "L1SMX_VHDL_SLOT8" );
      q.extendOutput<coral::Blob>( "L1SMX_VHDL_SLOT9" );
      q.extendOutput<coral::Blob>( "L1SMX_SVFI_SLOT7" );
      q.extendOutput<coral::Blob>( "L1SMX_SVFI_SLOT8" );
      q.extendOutput<coral::Blob>( "L1SMX_SVFI_SLOT9" );
   }
 
   { // muctpi
      auto & q = m_muctpi_queries[3];
      // tables
      q.addToTableList ( "L1_MUCTPI_FILES" );
      // bind vars
      q.extendBinding<unsigned int>("id");
      // conditions
      q.extendCondition("L1MF_ID = :id");
      // attributes
      q.extendOutput<coral::Blob>( "L1MF_DATA" );
   }
 
   { // tmc
      auto & q = m_tmcsig_queries[3];
      // tables
      q.addToTableList ( "L1_TMC_SIGNALS" );
      // bind vars
      q.extendBinding<unsigned int>("id");
      // conditions
      q.extendCondition("L1TMC_ID = :id");
      // attributes
      q.extendOutput<coral::Blob>( "L1TMC_DATA" );
   }
}

~TrigDBCTPFilesLoader()

TrigConf::TrigDBCTPFilesLoader::~TrigDBCTPFilesLoader ( )

overridevirtualdefault

Destructor - cannot be defined here because QueryDefinition is an incomplete type.

Member Function Documentation

createDBSession()

std::unique_ptr< coral::ISessionProxy > TrigConf::TrigDBLoader::createDBSession ( ) const

protectedinherited

create (if needed) DB session and return the session proxy

Definition at line 107 of file TrigDBLoader.cxx.

                                            {
 
   coral::ConnectionService connSvc;
   coral::IConnectionServiceConfiguration& csc = connSvc.configuration();
   csc.setConnectionRetrialPeriod( m_retrialPeriod );
   csc.setConnectionRetrialTimeOut( m_retrialTimeout );
   csc.setConnectionTimeOut( m_connectionTimeout );
 
   /* TODO
   if(csc.replicaSortingAlgorithm() == nullptr) { // likely to be standalone, create our own
      TRG_MSG_INFO("Create own ReplicaSortingAlgorithm");
      m_replicaSorter = new TrigConf::ReplicaSorter();
      csc.setReplicaSortingAlgorithm(*m_replicaSorter);
   }
   */
 
   TRG_MSG_INFO("Connecting to " << m_connection);
 
   auto proxy = std::unique_ptr<coral::ISessionProxy>( connSvc.connect(m_connection, coral::AccessMode::ReadOnly) );
 
   TRG_MSG_INFO("Opened session " << m_connection << " with  retrialPeriod/retrialTimeout/connectionTimeout: " 
                << m_retrialPeriod << "/" << m_retrialTimeout << "/" << m_connectionTimeout);
 
   return proxy;
}

getName()

const std::string & TrigConf::TrigConfMessaging::getName ( ) const

inlineinherited

name accessor

Returns

the name

Definition at line 101 of file TrigConfMessaging.h.

                                                           {
    return m_name;
  }

getQueryDefinition()

TrigConf::QueryDefinition TrigConf::TrigDBLoader::getQueryDefinition ( size_t schemaVersion, const std::map< size_t, QueryDefinition > & queries ) const

protectedinherited

return query for given schemaVersion from possible queries

Definition at line 174 of file TrigDBLoader.cxx.

{
   // find the largest version key in the map of defined queries that is <= the schemaVersion
   size_t maxDefVersion = 0;
   for(auto & entry : queries) {
      size_t vkey = entry.first;
      if(vkey>maxDefVersion and vkey<=schemaVersion) {
         maxDefVersion = vkey;
      }
   }
   // if nothing found, throw an error
   if( maxDefVersion==0 ) {
      TRG_MSG_ERROR("No query for schema version " << schemaVersion << " defined" );
      throw TrigConf::NoQueryException(std::format("No query available for schema version {}", schemaVersion));
   }
   return queries.at(maxDefVersion);
}

getTrigDataCrest()

std::string TrigConf::TrigDBLoader::getTrigDataCrest ( const std::string & type, int key ) const

protectedinherited

Get trigger configuration from the TriggerDB through Crest.

Parameters

type	The type of trigger configuration data to access L1PS => L1 prescale (with L1PS key) HLTPS => HLT prescale (with HLTPS key) L1M => L1 menu (with SMK) HLTM => HLT menu (with SMK) JO => Job options (with SMK) BGS => bunch group set (with BGS key) MGS => monitoring group (with SMK)
key	The trigger key

Definition at line 134 of file TrigDBLoader.cxx.

                                                                            {
   /*
   To get the trigger data from the TriggerDB using CrestApi, it has been agreed to 
   use the API's payload query with a special specifier
 
   triggerdb://<TrigDBSpec>/<TypeSpec>/<DBKey>
 
   Possible TrigDBSpec: CONF_DATA_RUN3, CONF_MC_RUN3, CONF_REPR_RUN3
   Possible TypeSpec: L1PS, HLTM, L1M, HLTPS, BGS, MGS, JO
   */
 
   std::string url = m_crestServer + m_crestVersion;
   std::string query = std::format("triggerdb://{}/{}/{}", m_crestTrigDb, type, key);
 
#if 0
   /*
   the final implementation should be the code below
   however, in the version used by 24.0 the function CrestApi.getPayload(hash) does not work
   for the trigger: it includes a hash validation that is not applicable for the trigger
   but only for conditions payload queries by hash
   */ 
   Crest::CrestApi capi = Crest::CrestApi(url);
   std::string payload = capi.getPayload(query);
#else
   /*
   so for release 24.0 and until the access to the trigger payload is implemented in CrestApi
   the CrestRequest is build manually. Luckily all needed functionality is accessible
   (this code is a copy of CrestApi::getPayload() without the checkHash())
   */
   Crest::CrestRequest request = Crest::CrestRequest();
   request.setUrl(url);
   std::string current_path = "payloads/data?format=BLOB&hash=" + query;
   nlohmann::json js = nullptr;
   std::string payload = request.performRequest(current_path, Crest::Action::GET, js, "TrigDbLoader");
#endif
 
   return payload;
}

loadCTPFiles()

void TrigConf::TrigDBCTPFilesLoader::loadCTPFiles ( L1CTPFiles & ctpfiles, std::unique_ptr< coral::IQuery > query, size_t schemaVersion ) const

private

Definition at line 189 of file TrigDBCTPFilesLoader.cxx.

{
   TRG_MSG_INFO("Loading data from table L1_CTP_FILES.");
   try
   {
      auto & cursor = query->execute();
      std::ignore = cursor.next();
      const coral::AttributeList& row = cursor.currentRow();
      {
         ctpfiles.set_Ctpcore_LUT(
            loadDBFieldIntoVector(row, "L1CF_LUT", L1CTPFiles::CTPCORE_LUT_SIZE)
         );
      }
      {
         ctpfiles.set_Ctpcore_CAM(
            loadDBFieldIntoVector(row, "L1CF_CAM", L1CTPFiles::CTPCORE_CAM_SIZE)
         );
      }
      if(schemaVersion>=6) {
         ctpfiles.set_Ctpcore_SMX(
            loadDBFieldIntoVector(row, "L1CF_SMX", L1CTPFiles::CTPCORE_SMX_SIZE)
         );
      }
 
      {
         ctpfiles.set_Ctpin_MonSelector_Slot7(
            loadDBFieldIntoVector(row, "L1CF_MON_SEL_SLOT7", L1CTPFiles::CTPIN_MONSEL_SIZE)
         );
      }
      {
         ctpfiles.set_Ctpin_MonSelector_Slot8(
            loadDBFieldIntoVector(row, "L1CF_MON_SEL_SLOT8", L1CTPFiles::CTPIN_MONSEL_SIZE)
         );
      }
      {
         ctpfiles.set_Ctpin_MonSelector_Slot9(
            loadDBFieldIntoVector(row, "L1CF_MON_SEL_SLOT9", L1CTPFiles::CTPIN_MONSEL_SIZE)
         );
      }
      {
         ctpfiles.set_Ctpin_MonDecoder_Slot7(
            loadDBFieldIntoVector(row, "L1CF_MON_DEC_SLOT7", L1CTPFiles::CTPIN_MONDEC_SIZE)
         );
      }
      {
         ctpfiles.set_Ctpin_MonDecoder_Slot8(
            loadDBFieldIntoVector(row, "L1CF_MON_DEC_SLOT8", L1CTPFiles::CTPIN_MONDEC_SIZE)
         );
      }
      {
         ctpfiles.set_Ctpin_MonDecoder_Slot9(
            loadDBFieldIntoVector(row, "L1CF_MON_DEC_SLOT9", L1CTPFiles::CTPIN_MONDEC_SIZE)
         );
      }
      {
         ctpfiles.set_Ctpmon_MonSelector(
            loadDBFieldIntoVector(row, "L1CF_MON_SEL_CTPMON", L1CTPFiles::CTPMON_SELECTOR_SIZE)
         );
      }
      {
         ctpfiles.set_Ctpmon_MonDecoder(
            loadDBFieldIntoVector(row, "L1CF_MON_DEC_CTPMON", L1CTPFiles::CTPMON_DECODER_SIZE)
         );
      }
      {
         ctpfiles.set_Ctpmon_DMX(
            loadDBFieldIntoVector(row, "L1CF_MON_DMX", L1CTPFiles::CTPMON_DMX_SIZE)
         );
      }
      ctpfiles.set_HasCompleteCtpData(true);
   }
   catch(coral::QueryException & ex) {
      TRG_MSG_ERROR("When reading the L1CTPFiles a coral::QueryException was caught ( " << ex.what() <<" )" );
      throw TrigConf::QueryException("TrigDBCTPFilesLoader: " + std::string(ex.what()));
   }
}

loadCTPSMX()

void TrigConf::TrigDBCTPFilesLoader::loadCTPSMX ( L1CTPFiles & ctpfiles, std::unique_ptr< coral::IQuery > query, size_t schemaVersion ) const

private

Definition at line 267 of file TrigDBCTPFilesLoader.cxx.

                                                                                                              {
   TRG_MSG_INFO("Loading data from table L1_CTP_SMX");
   try
   {
      auto & cursor = query->execute();
      std::ignore = cursor.next();
      const coral::AttributeList& row = cursor.currentRow();
      
      ctpfiles.set_Smx_Output( loadDBFieldIntoString(row, "L1SMX_OUTPUT") );
      ctpfiles.set_Smx_Vhdl_Slot7( loadDBFieldIntoString(row, "L1SMX_VHDL_SLOT7") );
      ctpfiles.set_Smx_Vhdl_Slot8( loadDBFieldIntoString(row, "L1SMX_VHDL_SLOT8") );
      ctpfiles.set_Smx_Vhdl_Slot9( loadDBFieldIntoString(row, "L1SMX_VHDL_SLOT9") );
      ctpfiles.set_Smx_Svfi_Slot7( loadDBFieldIntoString(row, "L1SMX_SVFI_SLOT7") );
      ctpfiles.set_Smx_Svfi_Slot8( loadDBFieldIntoString(row, "L1SMX_SVFI_SLOT8") );
      ctpfiles.set_Smx_Svfi_Slot9( loadDBFieldIntoString(row, "L1SMX_SVFI_SLOT9") );
      ctpfiles.set_HasCompleteSmxData(true);      
   }
   catch(coral::QueryException & ex) {
      TRG_MSG_ERROR("When reading the L1CTPFiles a coral::QueryException was caught ( " << ex.what() <<" )" );
      throw TrigConf::QueryException("TrigDBCTPFilesLoader: " + std::string(ex.what()));
   }
}

loadDBFieldIntoString()

std::string TrigConf::TrigDBCTPFilesLoader::loadDBFieldIntoString ( const coral::AttributeList & row, const std::string & field ) const

private

Definition at line 505 of file TrigDBCTPFilesLoader.cxx.

                                                                                                               {
   std::string result;
   try {
      const coral::Blob& blob = row[field].data<coral::Blob>();
      boost::iostreams::stream<boost::iostreams::array_source> stream(
         static_cast<const char*> (blob.startingAddress()), 
         blob.size()
      );
      result = std::string (
         std::istreambuf_iterator<char>(stream.rdbuf()),
         std::istreambuf_iterator<char>()
      );
      TRG_MSG_INFO("Loading " << field << " of size " << result.size());
   }
   catch(const coral::AttributeException & e) {} // NULL content
   if(result.empty()) {
      TRG_MSG_ERROR("Field " << field << " in DB is empty");
      throw std::runtime_error( "CTPFilesLoader: field " + field + " in DB is empty" );
   }
   return result;
}

loadDBFieldIntoVector()

std::vector< uint32_t > TrigConf::TrigDBCTPFilesLoader::loadDBFieldIntoVector ( const coral::AttributeList & row, const std::string & field, size_t size ) const

private

Definition at line 477 of file TrigDBCTPFilesLoader.cxx.

                                                                                                                            {
   std::vector<uint32_t> vec;
   if(size>0) {
      vec.reserve(size);
   }
   try {
      TRG_MSG_INFO("Loading " << field << " of size (#words) " << size);
      const coral::Blob& blob = row[field].data<coral::Blob>();
      boost::iostreams::stream<boost::iostreams::array_source> stream(
         static_cast<const char*> (blob.startingAddress()), 
         blob.size()
      );
      std::string word{""};
      while(stream >> word) {
         vec.push_back(std::stoul(word,nullptr, 0));
      }
   }
   catch(const coral::AttributeException & e) {} // NULL content
   // check the size if a positive size was requested
   if(size > 0 && size != vec.size()) {
      TRG_MSG_ERROR("File content from DB of size " << vec.size() << ", but expect " << size);
      throw std::runtime_error( "CTPFilesLoader: file of unexpected size" );
   }
 
   return vec;
}

loadFromCrest()

void TrigConf::TrigDBLoader::loadFromCrest ( unsigned int key, boost::property_tree::ptree & pt, const std::string & outFileName, const std::string & description, const std::string & query_type ) const

protectedinherited

Definition at line 194 of file TrigDBLoader.cxx.

{
   std::string payload;
   try {
      payload = getTrigDataCrest(query_type, key);
   }
   catch(Crest::CrestException & ex) {
      TRG_MSG_ERROR("When reading " << description << " for key " << key << " from crest a CrestException was caught ( " << ex.what() <<" )" );
      throw TrigConf::CrestLoadingException(std::format("{}: {}", getName(), ex.what()));
   }
   if(!outFileName.empty()) {
      writeRawFile(payload, outFileName);
      TRG_MSG_INFO("Wrote file " << outFileName);
   }
   try {
      stringToPtree(payload, pt);
   }
   catch(boost::property_tree::json_parser_error & ex) {
      TRG_MSG_ERROR("When reading " << description << " for key " << key << " from crest a ptree json parser error was caught ( " << ex.what() <<" )" );
      throw TrigConf::JsonParsingException(std::format("{}: {}", getName(), ex.what()));
   }
}

loadFromOracle()

void TrigConf::TrigDBLoader::loadFromOracle ( unsigned int key, boost::property_tree::ptree & pt, const std::string & outFileName, const std::string & description, const std::map< size_t, QueryDefinition > & queries ) const

protectedinherited

Definition at line 220 of file TrigDBLoader.cxx.

{
   auto session = createDBSession();
   session->transaction().start( /*bool readonly=*/ true);
   const size_t sv = schemaVersion(session.get());
   QueryDefinition qdef = getQueryDefinition(sv, queries);
   try {
      qdef.setBoundValue<int>("key", key);
      auto q = qdef.createQuery( session.get() );
      auto & cursor = q->execute();
      if ( ! cursor.next() ) {
         TRG_MSG_ERROR("Tried reading " << description << ", but key " << key << " is not available" );
         throw TrigConf::NoKeyException(std::format("{}: key {} not available", getName(), key));
      }
      const coral::AttributeList& row = cursor.currentRow();
      const coral::Blob& dataBlob = row[qdef.dataName()].data<coral::Blob>();
 
      if(!outFileName.empty()) {
         writeRawFile( dataBlob, outFileName );
         TRG_MSG_INFO("Wrote file " << outFileName);
      }
      blobToPtree( dataBlob, pt );
   }
   catch(coral::QueryException & ex) {
      TRG_MSG_ERROR("When reading " << description << " for key " << key << " a coral::QueryException was caught ( " << ex.what() <<" )" );
      throw TrigConf::QueryException(std::format("{}: {}", getName(), ex.what()));
   }
   catch(boost::property_tree::json_parser_error & ex) {
      TRG_MSG_ERROR("When reading " << description << " for key " << key << " a ptree json parser error was caught ( " << ex.what() <<" )" );
      throw TrigConf::JsonParsingException(std::format("{}: {}", getName(), ex.what()));
   }
}

loadHardwareFiles()

bool TrigConf::TrigDBCTPFilesLoader::loadHardwareFiles	(	unsigned int	smk,
		TrigConf::L1CTPFiles &	ctpfiles,
		uint8_t	loadMask = 0x0F,
		const std::string &	outFileName = "" ) const

Load content from the Trigger DB into an L1CTPFiles object for a given super master key (SMK)

Parameters

smk	[in] the SMK that should be loaded
ctpfiles	[out] the loaded L1CTPFiles
loadMask	[in] bit mask which specifies which content should be loaded (default is 0x0F which loads all content) 0x01 - CTPFiles, 0x02 - SMX files, 0x04 - TMC, 0x08 - MUCTPI
outFileName	[in] name of file to write out the loaded data (optional, by default no file will be written)

Returns

true if loading (and optional writing) was successfull

Definition at line 107 of file TrigDBCTPFilesLoader.cxx.

{
   unsigned int ctpFilesID{0};
   unsigned int ctpSmxID{0};
   unsigned int muctpiID{0};
   unsigned int tmcSignalsID{0};
 
   auto session = createDBSession();
   session->transaction().start( /*bool readonly=*/ true);
   const size_t sv = schemaVersion(session.get());
   try {
      QueryDefinition qdef = getQueryDefinition(sv, m_link_queries);
      qdef.setBoundValue<unsigned int>("smk", smk);
      auto q = qdef.createQuery( session.get() );
      auto & cursor = q->execute();
      if ( ! cursor.next() ) {
         TRG_MSG_ERROR("Tried reading L1 CTPFiles, but super master key " << smk << " is not available" );
         throw TrigConf::NoSMKException("TrigDBCTPFilesLoader: super master key " + std::to_string(smk) + " not available");
      }
      const coral::AttributeList& row = cursor.currentRow();
      try {
         ctpFilesID = row["L1TM.L1TM_CTP_FILES_ID"].data<unsigned int>();
      }
      catch(const coral::AttributeException & e) // NULL content
      {}
      try {
         ctpSmxID = row["L1TM.L1TM_CTP_SMX_ID"].data<unsigned int>();
      }
      catch(const coral::AttributeException & e) // NULL content
      {}
      try {
         muctpiID = row["L1TM.L1TM_MUCTPI_FILES_ID"].data<unsigned int>();
      }
      catch(const coral::AttributeException & e) // NULL content
      {}
      try {
         tmcSignalsID = row["L1TM.L1TM_TMC_SIGNALS_ID"].data<unsigned int>();
      }
      catch(const coral::AttributeException & e) // NULL content
      {}
 
      TRG_MSG_INFO("ID of table L1_CTP_FILES    : " <<  ctpFilesID);
      TRG_MSG_INFO("ID of table L1_CTP_SMX      : " <<  ctpSmxID);
      TRG_MSG_INFO("ID of table L1_MUCTPI_FILES : " <<  muctpiID);
      TRG_MSG_INFO("ID of table L1_TMC_SIGNALS  : " <<  tmcSignalsID);
   }
   catch(coral::QueryException & ex) {
      TRG_MSG_ERROR("When reading the files table links for super master key " << smk << " a coral::QueryException was caught ( " << ex.what() <<" )" );
      throw TrigConf::QueryException("TrigDBCTPFilesLoader: " + std::string(ex.what()));
   }
 
   if(ctpFilesID>0 && (loadMask & 0x01)!=0 ) {
      QueryDefinition qdef = getQueryDefinition(sv, m_ctpfiles_queries);
      qdef.setBoundValue<unsigned int>("id", ctpFilesID);
      loadCTPFiles(ctpfiles, qdef.createQuery( session.get() ), sv );
   }
 
   if(ctpSmxID>0 && (loadMask & 0x02)!=0) {
      QueryDefinition qdef = getQueryDefinition(sv, m_ctpsmx_queries);
      qdef.setBoundValue<unsigned int>("id", ctpSmxID);
      loadCTPSMX(ctpfiles, qdef.createQuery( session.get() ), sv );
   }
   
   if(tmcSignalsID>0 && (loadMask & 0x04)!=0) {
      QueryDefinition qdef = getQueryDefinition(sv, m_tmcsig_queries);
      qdef.setBoundValue<unsigned int>("id", tmcSignalsID);
      loadTMC(ctpfiles, qdef.createQuery( session.get() ), sv );
   }
   
   if(muctpiID>0 && (loadMask & 0x08)!=0) {
      QueryDefinition qdef = getQueryDefinition(sv, m_muctpi_queries);
      qdef.setBoundValue<unsigned int>("id", muctpiID);
      loadMUCTPI(ctpfiles, qdef.createQuery( session.get() ), sv );
   }   
   return true;
}

loadMUCTPI()

void TrigConf::TrigDBCTPFilesLoader::loadMUCTPI ( L1CTPFiles & ctpfiles, std::unique_ptr< coral::IQuery > query, size_t schemaVersion ) const

private

Definition at line 291 of file TrigDBCTPFilesLoader.cxx.

                                                                                                              {
   TRG_MSG_INFO("Loading data from table L1_MUCTPI_FILES");
 
   bool incomplete = false;
   boost::property_tree::ptree pt;
   try
   {
      auto & cursor = query->execute();
      std::ignore = cursor.next();
      const coral::AttributeList& row = cursor.currentRow();
      const coral::Blob & blob = row["L1MF_DATA"].data<coral::Blob>();
      blobToPtree(blob, pt);
   }
   catch(coral::QueryException & ex) {
      TRG_MSG_ERROR("When reading the L1CTPFiles a coral::QueryException was caught ( " << ex.what() <<" )" );
      throw TrigConf::QueryException("TrigDBCTPFilesLoader: " + std::string(ex.what()));
   }
   DataStructure ds("L1_MUCTPI_FILES", std::move(pt));
   std::vector<std::string> keys = ds.getKeys();
   for(auto k : {L1CTPFiles::RoiMaskA, L1CTPFiles::RoiMaskC, L1CTPFiles::PtLutBarrel, L1CTPFiles::PtLutEndcap}) {
      if( auto dv = ds.getList_optional(L1CTPFiles::s_keyMap.at(k)) ) {
         keys.erase( std::find(keys.begin(), keys.end(), L1CTPFiles::s_keyMap.at(k)) );
         std::vector<uint32_t> v;
         v.reserve(200);
         for( const auto & x : *dv ) {
            v.push_back(std::stoul(x.getValue<std::string>(), nullptr, 0));
         }
         ctpfiles.set_Muctpi(k, std::move(v));
      } else {
         incomplete = true;
      }
   }
   for(const std::string & k : keys) {
      if(ds.isNull(k)) {
         TRG_MSG_INFO("Attribute " << k << " has null-content");
         incomplete = true;
         continue;
      }
      auto sopt = ds.getAttribute_optional<std::string>(k);
      if(k.compare(0, 6, "pt_lut") == 0) {
         auto dv = ds.getList(k);
         std::vector<uint32_t> v;
         v.reserve(200);
         for( const auto & x : dv ) {
            v.push_back(std::stoul(x.getValue<std::string>(), nullptr, 0));
         }
         ctpfiles.set_Muctpi_Extra_Ptlut(k, std::move(v));
      } else if(k=="multiplicities_nbits") {
         auto dv = ds.getList(k);
         std::vector<uint32_t> v;
         for( const auto & x : dv ) {
            v.push_back(std::stoul(x.getValue<std::string>(), nullptr, 0));
         }
         ctpfiles.set_Muctpi_Nbits(std::move(v));
      }
   }
   ctpfiles.set_HasCompleteMuctpiData(!incomplete);
}

loadTMC()

void TrigConf::TrigDBCTPFilesLoader::loadTMC ( L1CTPFiles & ctpfiles, std::unique_ptr< coral::IQuery > query, size_t schemaVersion ) const

private

Definition at line 351 of file TrigDBCTPFilesLoader.cxx.

                                                                                                           {
   TRG_MSG_INFO("Loading data from table L1_TMC_SIGNALS");
   boost::property_tree::ptree pt;
   try
   {
      auto & cursor = query->execute();
      std::ignore = cursor.next();
      const coral::AttributeList& row = cursor.currentRow();
      const coral::Blob & blob = row["L1TMC_DATA"].data<coral::Blob>();
      blobToPtree(blob, pt);
   }
   catch(coral::QueryException & ex) {
      TRG_MSG_ERROR("When reading the L1CTPFiles a coral::QueryException was caught ( " << ex.what() <<" )" );
      throw TrigConf::QueryException("TrigDBCTPFilesLoader: " + std::string(ex.what()));
   }
 
   DataStructure ds("L1_TMC", std::move(pt));
 
   // should always be the correct type
   if( auto ft = ds.getAttribute<std::string>("filetype"); ft != "tmcresult" ) {
      throw TrigConf::ParsingException("TrigDBCTPFilesLoader::loadTMC: json structure of unexpected file type found. Expected 'tmcresult', but found " + ft);
   }
 
   // read the ctpcore inputs
   if (auto dv = ds.getObject_optional("CTPCORE.TriggerInputs"))
   {
      std::vector<TrigConf::L1CTPFiles::CTPCoreInput> ctpcoreInputs;
      for (const std::string &k : dv->getKeys())
      {
         const TrigConf::DataStructure &inp = dv->getObject(k);
         const std::string &inputType = inp["type"];
         TrigConf::L1CTPFiles::CTPCoreInput::InputType inpEnum = TrigConf::L1CTPFiles::CTPCoreInput::NONE;
         if (inputType == "PIT")
         {
            inpEnum = TrigConf::L1CTPFiles::CTPCoreInput::PIT;
         }
         else if (inputType == "DIR")
         {
            inpEnum = TrigConf::L1CTPFiles::CTPCoreInput::DIR;
         }
         else if (inputType == "CTPX")
            continue;
         else
            continue;
         ctpcoreInputs.push_back(
            TrigConf::L1CTPFiles::CTPCoreInput(
               inp.getAttribute<size_t>("number"), inp.getAttribute<std::string>("name"),
               inp.getAttribute<size_t>("bit"), inp.getAttribute<size_t>("phase"),
               inpEnum));
      }
      TRG_MSG_INFO("Loading ctpcore inputs " << ctpcoreInputs.size());
      ctpfiles.set_Tmc_CtpcoreInputs(std::move(ctpcoreInputs));
   }
 
   // read the ctpcore CTPX inputs
   if (auto dv = ds.getObject_optional("CTPCORE.TriggerInputs"))
   {
      std::vector<TrigConf::L1CTPFiles::CTPCoreCTPXInput> ctpcoreCTPXInputs;
      for (const std::string &k : dv->getKeys())
      {
         const TrigConf::DataStructure &inp = dv->getObject(k);
         const std::string &inputType = inp["type"];
         TrigConf::L1CTPFiles::CTPCoreCTPXInput::InputType inpEnum = TrigConf::L1CTPFiles::CTPCoreCTPXInput::NONE;
         if (inputType == "CTPX")
         {
            inpEnum = TrigConf::L1CTPFiles::CTPCoreCTPXInput::CTPX;
         }
         else if (inputType == "PIT" || inputType == "DIR")
            continue;
         else
            continue;
         ctpcoreCTPXInputs.push_back(
            TrigConf::L1CTPFiles::CTPCoreCTPXInput(
               inp.getAttribute<size_t>("number"), inp.getAttribute<std::string>("name"),
               inp.getAttribute<size_t>("bit"),
               inpEnum));
      }
      TRG_MSG_INFO("Loading ctpcore CTPX inputs " << ctpcoreCTPXInputs.size());
      ctpfiles.set_Tmc_CtpcoreCTPXInputs(std::move(ctpcoreCTPXInputs));
   }
 
   // read the ctpin map
   std::vector<TrigConf::L1CTPFiles::CTPInCounter> ctpinCounters;
   for (size_t slot : {7, 8, 9})
     {
       for (size_t conn : {0, 1, 2, 3})
         {
       std::string path = "CTPINs.SLOT" + std::to_string(slot) + ".Monitoring.Cables.CON" + std::to_string(conn);
       if (auto dv = ds.getObject_optional(path))
         {
               if (auto ov = dv->getList_optional("outputs"))
         {
           for (const DataStructure &output : *ov)
             {
               ctpinCounters.push_back(
              TrigConf::L1CTPFiles::CTPInCounter(
                 output.getAttribute<std::string>("TriggerCounter"), slot, conn, output.getAttribute<size_t>("number")));
             }
         }
         }
         }
     }
   TRG_MSG_INFO("Loading ctpin counters " << ctpinCounters.size());
   ctpfiles.set_Tmc_CtpinCounters(std::move(ctpinCounters));
   
   // read the ctpmon map
   std::vector<TrigConf::L1CTPFiles::CTPMonCounter> ctpmonCounters;
   if( auto dv = ds.getObject_optional("CTPMON.Monitoring") ) {
     if (auto ov = dv->getList_optional("outputs"))
       {
     for (const DataStructure &output : *ov)
       {
         ctpmonCounters.push_back(
        TrigConf::L1CTPFiles::CTPMonCounter(
           output.getAttribute<std::string>("TriggerCounter"), output.getAttribute<size_t>("number")));
       }
       }
   }
   TRG_MSG_INFO("Loading ctpmon counters " << ctpmonCounters.size());
   ctpfiles.set_Tmc_CtpmonCounters(std::move(ctpmonCounters));
 
   ctpfiles.set_Tmc_Data(std::move(ds));
   ctpfiles.set_HasCompleteTmcData(true);
}

msg() [1/2]

MsgStreamTC & TrigConf::TrigConfMessaging::msg ( ) const

inlineinherited

The standard message stream.

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

Definition at line 86 of file TrigConfMessaging.h.

  {
    MsgStreamTC* ms = m_msg_tls.get();
    if (!ms) {
      ms = new MsgStreamTC(m_name);
      m_msg_tls.reset(ms);
    }
    return *ms;
  }

msg() [2/2]

MsgStreamTC & TrigConf::TrigConfMessaging::msg ( const MSGTC::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 96 of file TrigConfMessaging.h.

  {
    return msg() << lvl;
  }

msgLvl()

bool TrigConf::TrigConfMessaging::msgLvl ( const MSGTC::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 75 of file TrigConfMessaging.h.

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

outputLevel()

MSGTC::Level TrigConf::TrigDBLoader::outputLevel ( ) const

inlineinherited

Definition at line 70 of file TrigDBLoader.h.

{ return msg().level(); }

schemaVersion()

size_t TrigConf::TrigDBLoader::schemaVersion ( coral::ISessionProxy * session ) const

inherited

access to TriggerDB schema version

Returns

version of the DB schema (0 - no version, >0 - schema version)

Definition at line 38 of file TrigDBLoader.cxx.

                                                                     {
 
   static const std::string versionTagPrefix("Trigger-Run3-Schema-v");
 
   // if database has no schema version, then we return 0
   if(! session->nominalSchema().existsTable("TRIGGER_SCHEMA") ) {
      throw std::runtime_error( "Trigger schema has no schema version table" );
   }
   
   TrigConf::QueryDefinition qdef;
   // tables
   qdef.addToTableList ( "TRIGGER_SCHEMA" );
   // attributes
   qdef.extendOutput<std::string>( "TS_TAG" );
 
   auto query = qdef.createQuery( session );
   auto & cursor = query->execute();
   if ( ! cursor.next() ) {
      throw std::runtime_error( "Trigger schema has schema version table but it is empty" );
   }
 
   const coral::AttributeList& row = cursor.currentRow();
   std::string versionTag = row["TS_TAG"].data<std::string>();
   if( ! versionTag.starts_with(versionTagPrefix)) {
      throw std::runtime_error(std::format("Tag format error: Trigger schema version tag {} does not start with {}", versionTag, versionTagPrefix));      
   }
   
   std::string vstr = versionTag.substr(versionTagPrefix.size()); // the part of the string containing the version
   size_t schemaVersion{0};
   try {
      schemaVersion = std::stoi(vstr);
   }
   catch (const std::invalid_argument& ia) {
      TRG_MSG_ERROR("Invalid argument when interpreting the version part " << vstr << " of schema tag " << versionTag << ". " << ia.what());
      throw;
   }
 
   TRG_MSG_INFO("TriggerDB schema version: " << schemaVersion);
   return schemaVersion;
}

setCrestConnection()

void TrigConf::TrigDBLoader::setCrestConnection ( const std::string & server, const std::string & version = "" )

inherited

declare CREST as the source of the configuration An empty crest server makes it use Oracle

Parameters

server	The crest server. An empty string disables Crest and enables Oracle (the default)
version	The version of the crest api. Usually not needed. If not given, it defaults to the default API version (see CrestApi/CrestApiBase.h)

Definition at line 80 of file TrigDBLoader.cxx.

                                                                                            {
   // server
   m_crestServer = server;
   if(m_crestServer.ends_with('/')) { // remove trailing '/'
      m_crestServer.pop_back();
   }
 
   // use crest flag
   m_useCrest = ! m_crestServer.empty();
 
   // version
   if(version.empty()) {
      m_crestVersion = DEFAULT_CREST_API_VERSION; // defined in CrestApi/CrestApiBase.h
   } else {
      m_crestVersion = version;
   }
   if(!m_crestVersion.starts_with('/')) { // prepend '/' if not existent
      m_crestVersion = "/" + m_crestVersion;
   }
}

setCrestTrigDB()

void TrigConf::TrigDBLoader::setCrestTrigDB ( const std::string & crestTrigDB )

inherited

set trigger db for the crest connection

Parameters

crestTrigDB

the source trigger DB. Possible values currently CONF_DATA_RUN3 => ATLAS_CONF_TRIGGER_RUN3 CONF_MC_RUN3 => ATLAS_CONF_TRIGGER_MC_RUN3 CONF_REPR_RUN3 => ATLAS_CONF_TRIGGER_REPR_RUN3

Definition at line 102 of file TrigDBLoader.cxx.

                                                                  {
   m_crestTrigDb = crestTrigDB;
}

setLevel()

void TrigConf::TrigDBLoader::setLevel ( MSGTC::Level lvl )

inlineinherited

Definition at line 68 of file TrigDBLoader.h.

{ msg().setLevel(lvl); }

useCrest()

bool TrigConf::TrigDBLoader::useCrest ( ) const

inlineprotectedinherited

Definition at line 74 of file TrigDBLoader.h.

                            {
         return m_useCrest;
      }

Member Data Documentation

m_connection

std::string TrigConf::TrigDBLoader::m_connection {""}

privateinherited

Definition at line 110 of file TrigDBLoader.h.

{""};

m_connectionTimeout

int TrigConf::TrigDBLoader::m_connectionTimeout {0}

privateinherited

Definition at line 116 of file TrigDBLoader.h.

{0};

m_crestServer

std::string TrigConf::TrigDBLoader::m_crestServer {""}

privateinherited

Definition at line 111 of file TrigDBLoader.h.

{""};

m_crestTrigDb

std::string TrigConf::TrigDBLoader::m_crestTrigDb {""}

privateinherited

Definition at line 113 of file TrigDBLoader.h.

{""};

m_crestVersion

std::string TrigConf::TrigDBLoader::m_crestVersion {""}

privateinherited

Definition at line 112 of file TrigDBLoader.h.

{""};

m_ctpfiles_queries

std::map<size_t, QueryDefinition> TrigConf::TrigDBCTPFilesLoader::m_ctpfiles_queries

private

Definition at line 68 of file TrigDBCTPFilesLoader.h.

m_ctpsmx_queries

std::map<size_t, QueryDefinition> TrigConf::TrigDBCTPFilesLoader::m_ctpsmx_queries

private

Definition at line 69 of file TrigDBCTPFilesLoader.h.

m_link_queries

std::map<size_t, QueryDefinition> TrigConf::TrigDBCTPFilesLoader::m_link_queries

private

Definition at line 67 of file TrigDBCTPFilesLoader.h.

m_msg_tls

boost::thread_specific_ptr<MsgStreamTC> TrigConf::TrigConfMessaging::m_msg_tls

mutableprivateinherited

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

Definition at line 71 of file TrigConfMessaging.h.

m_muctpi_queries

std::map<size_t, QueryDefinition> TrigConf::TrigDBCTPFilesLoader::m_muctpi_queries

private

Definition at line 70 of file TrigDBCTPFilesLoader.h.

m_name

std::string TrigConf::TrigConfMessaging::m_name

privateinherited

Definition at line 72 of file TrigConfMessaging.h.

m_retrialPeriod

int TrigConf::TrigDBLoader::m_retrialPeriod {0}

privateinherited

Definition at line 114 of file TrigDBLoader.h.

{0};

m_retrialTimeout

int TrigConf::TrigDBLoader::m_retrialTimeout {0}

privateinherited

Definition at line 115 of file TrigDBLoader.h.

{0};

m_tmcsig_queries

std::map<size_t, QueryDefinition> TrigConf::TrigDBCTPFilesLoader::m_tmcsig_queries

private

Definition at line 71 of file TrigDBCTPFilesLoader.h.

m_useCrest

bool TrigConf::TrigDBLoader::m_useCrest {false}

privateinherited

Definition at line 109 of file TrigDBLoader.h.

{false};

---

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

• TrigDBCTPFilesLoader.h
• TrigDBCTPFilesLoader.cxx