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] = 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( 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.

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

52 { 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:

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TrigDBCTPFilesLoader()

◆ ~TrigDBCTPFilesLoader()

Member Function Documentation

◆ createDBSession()

◆ getQueryDefinition()

◆ loadCTPFiles()

◆ loadCTPSMX()

◆ loadDBFieldIntoString()

◆ loadDBFieldIntoVector()

◆ loadHardwareFiles()

◆ loadMUCTPI()

◆ loadTMC()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputLevel()

◆ schemaVersion()

◆ setLevel()

◆ writeRawFile()

Member Data Documentation

◆ m_connection

◆ m_connectionTimeout

◆ m_ctpfiles_queries

◆ m_ctpsmx_queries

◆ m_link_queries

◆ m_msg_tls

◆ m_muctpi_queries

◆ m_name

◆ m_retrialPeriod

◆ m_retrialTimeout

◆ m_tmcsig_queries