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. More...
virtual	~TrigDBCTPFilesLoader () override
	Destructor - cannot be defined here because QueryDefinition is an incomplete type. More...
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) More...
size_t	schemaVersion (coral::ISessionProxy *session) const
	access to TriggerDB schema version More...
bool	writeRawFile (const coral::Blob &data, const std::string &outFileName) const
	write data blob into file This can be used to write the DB content to file without going through a ptree More...
void	setLevel (MSGTC::Level lvl)
MSGTC::Level	outputLevel () const
bool	msgLvl (const MSGTC::Level lvl) const
	Test the output level. More...
MsgStreamTC &	msg () const
	The standard message stream. More...
MsgStreamTC &	msg (const MSGTC::Level lvl) const
	The standard message stream. More...

Protected Member Functions
std::unique_ptr< coral::ISessionProxy >	createDBSession () const
	create (if needed) DB session and return the session proxy More...
QueryDefinition	getQueryDefinition (size_t schemaVersion, const std::map< size_t, QueryDefinition > &queries) const
	return query for given schemaVersion from possible queries More...

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
std::string	m_connection {"TRIGGERDB"}
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) More...
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 8 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 94 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;
}

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 122 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( "No query available for schema version" + std::to_string(schemaVersion) );
   }
   return queries.at(maxDefVersion);
}

loadCTPFiles()

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

private

Definition at line 188 of file TrigDBCTPFilesLoader.cxx.

{
   TRG_MSG_INFO("Loading data from table L1_CTP_FILES.");
   try
   {
      auto & cursor = query->execute();
      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 266 of file TrigDBCTPFilesLoader.cxx.

                                                                                                              {
   TRG_MSG_INFO("Loading data from table L1_CTP_SMX");
   try
   {
      auto & cursor = query->execute();
      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 504 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 476 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;
}

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] if set, an outputfile with the raw data blob is written

Definition at line 106 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 290 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();
      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( 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( 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 350 of file TrigDBCTPFilesLoader.cxx.

                                                                                                           {
   TRG_MSG_INFO("Loading data from table L1_TMC_SIGNALS");
   boost::property_tree::ptree pt;
   try
   {
      auto & cursor = query->execute();
      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 81 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 91 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 70 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 54 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( ! startswith(versionTag, versionTagPrefix)) {
      throw std::runtime_error( "Tag format error: Trigger schema version tag " + versionTag + "does not start with " + 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;
}

setLevel()

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

inlineinherited

Definition at line 52 of file TrigDBLoader.h.

{ msg().setLevel(lvl); }

writeRawFile()

bool TrigConf::TrigDBLoader::writeRawFile ( const coral::Blob &  data, const std::string &  outFileName  ) const

inherited

write data blob into file This can be used to write the DB content to file without going through a ptree

Definition at line 80 of file TrigDBLoader.cxx.

{
   if( outFileName.empty() ) {
      return true;
   }
   std::ofstream outFile;
   outFile.open( outFileName, std::ofstream::binary );
   outFile.write( static_cast<const char*> ( data.startingAddress()), data.size() );
   outFile.close();
   TRG_MSG_INFO("Wrote file " << outFileName);
   return true;
}

Member Data Documentation

m_connection

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

privateinherited

Definition at line 68 of file TrigDBLoader.h.

m_connectionTimeout

int TrigConf::TrigDBLoader::m_connectionTimeout {0}

privateinherited

Definition at line 71 of file TrigDBLoader.h.

m_ctpfiles_queries

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

private

Definition at line 67 of file TrigDBCTPFilesLoader.h.

m_ctpsmx_queries

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

private

Definition at line 68 of file TrigDBCTPFilesLoader.h.

m_link_queries

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

private

Definition at line 66 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 66 of file TrigConfMessaging.h.

m_muctpi_queries

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

private

Definition at line 69 of file TrigDBCTPFilesLoader.h.

m_name

std::string TrigConf::TrigConfMessaging::m_name

privateinherited

Definition at line 67 of file TrigConfMessaging.h.

m_retrialPeriod

int TrigConf::TrigDBLoader::m_retrialPeriod {0}

privateinherited

Definition at line 69 of file TrigDBLoader.h.

m_retrialTimeout

int TrigConf::TrigDBLoader::m_retrialTimeout {0}

privateinherited

Definition at line 70 of file TrigDBLoader.h.

m_tmcsig_queries

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

private

Definition at line 70 of file TrigDBCTPFilesLoader.h.

---

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

• TrigDBCTPFilesLoader.h
• TrigDBCTPFilesLoader.cxx