TrigConf::CTPFilesLoader Class Reference

TriggerDB loader of the LVL1 LUT and CAM tables. More...

#include <CTPFilesLoader.h>

Inheritance diagram for TrigConf::CTPFilesLoader:

Collaboration diagram for TrigConf::CTPFilesLoader:

Public Member Functions
	CTPFilesLoader (StorageMgr &sm, coral::ISessionProxy &session)
	constructor
virtual	~CTPFilesLoader () override=default
	destructor
virtual bool	load (CTPFiles &data) override
virtual void	setLevel (MSGTC::Level lvl) override
	access to output stream
virtual MSGTC::Level	outputLevel () const override
void	startSession ()
	start session if not already active
void	commitSession ()
	commit session if not already done
bool	loadL1MasterKey (int SuperMasterKey, int &Lvl1MasterKey)
	get l1 master from super master
bool	loadL1MenuKey (int SuperMasterKey, int &Lvl1MenuKey)
	get l1 menu id from super master
unsigned int	triggerDBSchemaVersion ()
virtual int	verbose () const override
virtual void	setVerbose (int v) override
bool	isRun1 ()
bool	isRun2 ()
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 Attributes
StorageMgr &	m_storageMgr
	reference to the storage manager
coral::ISessionProxy &	m_session
	CORAL interface to database session.
bool	m_sessionOwner {false}
	remember if the loader started the session in the first place

Private Member Functions
bool	loadCtpcoreData (CTPFiles &)
bool	loadCtpinData (CTPFiles &)
bool	loadCtpmonData (CTPFiles &)
int	getMenuIdFromMaster (int mid)
long	getFilesIdFromMenu (int mid)
long	getSmxIdFromMenu (int mid)
void	parseHexString (std::vector< u_int > &vec, const std::string &str, bool verbose=false)
template<class T>
bool	convert_hex_string (T &t, const std::string &s)
template<class T>
bool	convert_string (T &t, const std::string &s)
std::tuple< unsigned int, unsigned int >	loadSchemaVersion () const
	get DB schema version and run number

Private Attributes
int	m_verbose {1}
boost::thread_specific_ptr< MsgStreamTC >	m_msg_tls
	MsgStreamTC instance (a std::cout like with print-out levels)
std::string	m_name

Detailed Description

TriggerDB loader of the LVL1 LUT and CAM tables.

Definition at line 33 of file CTPFilesLoader.h.

Constructor & Destructor Documentation

CTPFilesLoader()

TrigConf::CTPFilesLoader::CTPFilesLoader ( StorageMgr & sm, coral::ISessionProxy & session )

inline

constructor

Parameters

sm	reference to storage manager
session	reference to the database session

Definition at line 42 of file CTPFilesLoader.h.

         : DBLoader("CTPFilesLoader", sm, session) {}

~CTPFilesLoader()

virtual TrigConf::CTPFilesLoader::~CTPFilesLoader ( )

overridevirtualdefault

destructor

Member Function Documentation

commitSession()

void TrigConf::DBLoader::commitSession ( )

inherited

commit session if not already done

Definition at line 45 of file DBLoader.cxx.

{
   if ( m_session.transaction().isActive() && m_sessionOwner) {
      m_session.transaction().commit();
   }
}

convert_hex_string()

template<class T>

bool TrigConf::CTPFilesLoader::convert_hex_string ( T & t, const std::string & s )

inlineprivate

Definition at line 63 of file CTPFilesLoader.h.

      {
         std::istringstream iss(s);
         return !(iss >> std::hex >> t).fail();
      }

convert_string()

template<class T>

bool TrigConf::CTPFilesLoader::convert_string ( T & t, const std::string & s )

inlineprivate

Definition at line 71 of file CTPFilesLoader.h.

      {
         std::istringstream iss(s);
         return !(iss >> t).fail();
      }

getFilesIdFromMenu()

long TrigConf::CTPFilesLoader::getFilesIdFromMenu ( int mid )

private

Definition at line 97 of file CTPFilesLoader.cxx.

                                                       {
   coral::ITable& table = m_session.nominalSchema().tableHandle( "L1_TRIGGER_MENU");
   coral::IQuery* query = table.newQuery();
   query->setRowCacheSize( 5 );
 
   //Binding
   coral::AttributeList emptyBindVariableList0;
   std::string condition = "L1TM_ID = :tmId";
   emptyBindVariableList0.extend<int>("tmId");
   emptyBindVariableList0[0].data<int>() = mid;
   query->setCondition( condition, emptyBindVariableList0 );
 
   coral::AttributeList attList;
   attList.extend<int>( "L1TM_CTP_FILES_ID" );
   query->defineOutput(attList);
   query->addToOutputList( "L1TM_CTP_FILES_ID" );
      
   coral::ICursor& cursor = query->execute();
   if ( ! cursor.next() ) {
      TRG_MSG_ERROR("No such Trigger_Menu exists " << mid);
      delete query;
      commitSession();
      throw std::runtime_error( "CTPFilesLoader" );
   }
   const coral::AttributeList& row = cursor.currentRow();
   return static_cast<long>(row["L1TM_CTP_FILES_ID"].data<int>());
}

getMenuIdFromMaster()

int TrigConf::CTPFilesLoader::getMenuIdFromMaster ( int mid )

private

Definition at line 63 of file CTPFilesLoader.cxx.

                                                       {
 
   unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_MASTER_TABLE").newQuery() );
   query->setRowCacheSize( 5 );
 
   //Binding
   coral::AttributeList emptyBindVariableList0;
   std::string condition = "L1MT_ID = :mtId";
   emptyBindVariableList0.extend<int>("mtId");
   emptyBindVariableList0[0].data<int>() = mid;
   query->setCondition( condition, emptyBindVariableList0 );
 
   coral::AttributeList attList;
   attList.extend<int>( "L1MT_TRIGGER_MENU_ID" );
   fillQuery(query.get(),attList);
 
   coral::ICursor& cursor = query->execute();
   if ( ! cursor.next() ) {
      TRG_MSG_ERROR("No such Master_Table exists " << mid);
      commitSession();
      throw std::runtime_error( "CTPFilesLoader" );
   }
   const coral::AttributeList& row = cursor.currentRow();
   int menuid = row["L1MT_TRIGGER_MENU_ID"].data<int>(); 
   if ( cursor.next() ) {
      TRG_MSG_ERROR("More than one Master_Table exists " << mid);
      commitSession();
      throw std::runtime_error( "CTPFilesLoader >>  Master_Table not available" );
   }
   return menuid;
}

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;
  }

getSmxIdFromMenu()

long TrigConf::CTPFilesLoader::getSmxIdFromMenu ( int mid )

private

Definition at line 127 of file CTPFilesLoader.cxx.

                                                     {
   coral::ITable& table = m_session.nominalSchema().tableHandle( "L1_TRIGGER_MENU");
   coral::IQuery* query = table.newQuery();
   query->setRowCacheSize( 5 );
 
   //Binding
   coral::AttributeList emptyBindVariableList0;
   std::string condition = "L1TM_ID = :tmId";
   emptyBindVariableList0.extend<int>("tmId");
   emptyBindVariableList0[0].data<int>() = mid;
   query->setCondition( condition, emptyBindVariableList0 );
 
   coral::AttributeList attList;
   attList.extend<int>( "L1TM_CTP_SMX_ID" );
   query->defineOutput(attList);
   query->addToOutputList( "L1TM_CTP_SMX_ID" );
 
   coral::ICursor& cursor = query->execute();
   if ( ! cursor.next() ) {
      TRG_MSG_ERROR("No such Trigger_Menu exists " << mid);
      delete query;
      commitSession();
      throw std::runtime_error( "CTPFilesLoader" );
   }
   const coral::AttributeList& row = cursor.currentRow();
   return static_cast<long>(row["L1TM_CTP_SMX_ID"].data<int>());
}

isRun1()

bool TrigConf::DBLoader::isRun1 ( )

inlineinherited

Definition at line 60 of file DBLoader.h.

{ return ! isRun2(); }

isRun2()

bool DBLoader::isRun2 ( )

inherited

Definition at line 54 of file DBLoader.cxx.

                 {
   const static unsigned int run = std::get<1>(loadSchemaVersion());
   return run == 2;
}

load()

bool TrigConf::CTPFilesLoader::load ( CTPFiles & data )

overridevirtual

Implements TrigConf::ICTPFilesLoader.

Definition at line 46 of file CTPFilesLoader.cxx.

                                                 {
   bool retVal = true;
   triggerDBSchemaVersion();
   if(isRun1()) {
      data.setFileSizes(1);
   } else {
      data.setFileSizes(2);
   }
 
   if( data.loadCtpcoreFiles() ) retVal &= loadCtpcoreData(data);
   if( data.loadCtpinFiles()   ) retVal &= loadCtpinData(data);
   if( data.loadCtpmonFiles()  ) retVal &= loadCtpmonData(data);
   return retVal;
}

loadCtpcoreData()

bool TrigConf::CTPFilesLoader::loadCtpcoreData ( CTPFiles & ctpFiles )

private

Definition at line 158 of file CTPFilesLoader.cxx.

                                                           {
 
   TRG_MSG_INFO("start loading CTPCORE data");
   try {
      startSession();
      // first check if we need to obtain the CTP files ID, or if it
      // was passed in
      if(ctpFiles.id() <= 0) {
         int l1id = ctpFiles.lvl1MasterTableId();
         int menuid = getMenuIdFromMaster(l1id);
         long filesid = getFilesIdFromMenu(menuid);
         ctpFiles.setId(filesid);
      }
 
      unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_CTP_FILES").newQuery() );
      query->setRowCacheSize( 10 );
 
      //Binding
      coral::AttributeList emptyBindVariableList0;
      emptyBindVariableList0.extend<long>("fId");
      emptyBindVariableList0[0].data<long>() = ctpFiles.id();
      query->setCondition( "L1CF_ID = :fId", emptyBindVariableList0 );
 
      coral::AttributeList attList;
      attList.extend<std::string>( "L1CF_NAME" );
      attList.extend<int>( "L1CF_VERSION" );
      attList.extend<std::string>( "L1CF_LUT" );
      attList.extend<std::string>( "L1CF_CAM" );
      fillQuery(query.get(),attList);
 
      coral::ICursor& cursor = query->execute();
 
      if ( ! cursor.next() ) {
         TRG_MSG_ERROR("No such L1_CTP_Files exists " << ctpFiles.id());
         commitSession();
         throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
      }
 
      const coral::AttributeList& row = cursor.currentRow();
      std::string name = row["L1CF_NAME"].data<std::string>();
      int version = row["L1CF_VERSION"].data<int>();
      std::string ctpcoreLUT_str = row["L1CF_LUT"].data<std::string>();
      std::string ctpcoreCAM_str = row["L1CF_CAM"].data<std::string>();
 
      if ( cursor.next() ) {
         TRG_MSG_ERROR("More than one GetFile exists "   << ctpFiles.id());
         commitSession();
         throw std::runtime_error( "CTPFilesLoader >>  CTPFiles not available" );
      }
 
      std::vector<u_int> lutVec(CTPFiles::ALL_CTPCORELUT_SIZE);
      TRG_MSG_INFO("Loading LUT of size " << lutVec.size());
      parseHexString(lutVec, ctpcoreLUT_str, true);
 
      std::vector<u_int> camVec(CTPFiles::ALL_CTPCORECAM_SIZE);
      TRG_MSG_INFO("Loading CAM of size " << camVec.size());
      parseHexString(camVec,ctpcoreCAM_str);
 
      // Fill the object with data
      ctpFiles.setName( name );
      ctpFiles.setVersion( version );
      ctpFiles.setCtpcoreLUT(lutVec);
      ctpFiles.setCtpcoreCAM(camVec);
 
      commitSession();
   } catch( const coral::Exception& e ) {
      TRG_MSG_ERROR("coral::Exception: " << e.what());
      commitSession();
      throw;
   }
   return true;
}

loadCtpinData()

bool TrigConf::CTPFilesLoader::loadCtpinData ( CTPFiles & ctpFiles )

private

Definition at line 231 of file CTPFilesLoader.cxx.

                                                              {
   TRG_MSG_INFO("start loading CTPIN data");
   try {
      startSession();
      // first check if we need to obtain the CTP files ID, or if it
      // was passed in
      if(ctpFiles.id() <= 0 || ctpFiles.smxId() <= 0) {
         int l1id = ctpFiles.lvl1MasterTableId();
         int menuid = getMenuIdFromMaster(l1id);
         if(ctpFiles.id() <= 0) {
            long filesid = getFilesIdFromMenu(menuid);
            ctpFiles.setId(filesid);
         }
         if(ctpFiles.smxId() <= 0) {
            long id = getSmxIdFromMenu(menuid);
            ctpFiles.setSmxId(id);
         }
      }
 
      { // restrict scope to re-use variables
         unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_CTP_FILES").newQuery() );
         query->setRowCacheSize( 13 );
 
         //Binding
         coral::AttributeList emptyBindVariableList0;
         std::string condition = "L1CF_ID = :fId";
         emptyBindVariableList0.extend<long>("fId");
         emptyBindVariableList0[0].data<long>() = ctpFiles.id();
         query->setCondition( condition, emptyBindVariableList0 );
        
         coral::AttributeList attList;
         attList.extend<std::string>( "L1CF_NAME" );
         attList.extend<int>( "L1CF_VERSION" );
         attList.extend<std::string>( "L1CF_MON_SEL_SLOT7" );
         attList.extend<std::string>( "L1CF_MON_SEL_SLOT8" );
         attList.extend<std::string>( "L1CF_MON_SEL_SLOT9" );
         attList.extend<std::string>( "L1CF_MON_DEC_SLOT7" );
         attList.extend<std::string>( "L1CF_MON_DEC_SLOT8" );
         attList.extend<std::string>( "L1CF_MON_DEC_SLOT9" );
         fillQuery(query.get(),attList);
 
         coral::ICursor& cursor = query->execute();
         if ( ! cursor.next() ) {
            TRG_MSG_ERROR("No such L1_CTP_Files exists " << ctpFiles.id());
            commitSession();
            throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
         }
 
         const coral::AttributeList& row = cursor.currentRow();
         std::string name = row["L1CF_NAME"].data<std::string>();
         int version = row["L1CF_VERSION"].data<int>();
         std::string strMonSel7 = row["L1CF_MON_SEL_SLOT7"].data<std::string>();
         std::string strMonSel8 = row["L1CF_MON_SEL_SLOT8"].data<std::string>();
         std::string strMonSel9 = row["L1CF_MON_SEL_SLOT9"].data<std::string>();
         std::string strMonDec7 = row["L1CF_MON_DEC_SLOT7"].data<std::string>();
         std::string strMonDec8 = row["L1CF_MON_DEC_SLOT8"].data<std::string>();
         std::string strMonDec9 = row["L1CF_MON_DEC_SLOT9"].data<std::string>();
    
         if ( cursor.next() ) {
            TRG_MSG_ERROR("More than one GetFile exists "   << ctpFiles.id());
            commitSession();
            throw std::runtime_error( "CTPFilesLoader >>  CTPFiles not available" );
         }
 
         std::vector<u_int> monDecSlot7(CTPFiles::ALL_CTPINMONDEC_SIZE);
         TRG_MSG_INFO("Loading MON Slot7 of size " << monDecSlot7.size());
         parseHexString(monDecSlot7,strMonDec7);
         std::vector<u_int> monDecSlot8(CTPFiles::ALL_CTPINMONDEC_SIZE);
         TRG_MSG_INFO("Loading MON Slot8 of size " << monDecSlot8.size());
         parseHexString(monDecSlot8,strMonDec8);
         std::vector<u_int> monDecSlot9(CTPFiles::ALL_CTPINMONDEC_SIZE);
         TRG_MSG_INFO("Loading MON Slot9 of size " << monDecSlot9.size());
         parseHexString(monDecSlot9,strMonDec9);
        
         std::vector<u_int> monSelSlot7(CTPFiles::ALL_CTPINMONSEL_SIZE);
         TRG_MSG_INFO("Loading MON SEL Slot7 of size " << monSelSlot7.size());
         parseHexString(monSelSlot7,strMonSel7);
         std::vector<u_int> monSelSlot8(CTPFiles::ALL_CTPINMONSEL_SIZE);
         TRG_MSG_INFO("Loading MON SEL Slot8 of size " << monSelSlot8.size());
         parseHexString(monSelSlot8,strMonSel8);
         std::vector<u_int> monSelSlot9(CTPFiles::ALL_CTPINMONSEL_SIZE);
         TRG_MSG_INFO("Loading MON SEL Slot9 of size " << monSelSlot9.size());
         parseHexString(monSelSlot9,strMonSel9);
 
         // Fill the object with data
         ctpFiles.setName( name );
         ctpFiles.setVersion( version );
         ctpFiles.setCtpinMonDecoderSlot7(monDecSlot7);
         ctpFiles.setCtpinMonDecoderSlot8(monDecSlot8);
         ctpFiles.setCtpinMonDecoderSlot9(monDecSlot9);
         ctpFiles.setCtpinMonSelectorSlot7(monSelSlot7);
         ctpFiles.setCtpinMonSelectorSlot8(monSelSlot8);
         ctpFiles.setCtpinMonSelectorSlot9(monSelSlot9);
      }
     
      {
         unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_CTP_SMX").newQuery() );
         query->setRowCacheSize( 13 );
 
         //Binding
         coral::AttributeList emptyBindVariableList0;
         std::string condition = "L1SMX_ID = :sId";
         emptyBindVariableList0.extend<long>("sId");
         emptyBindVariableList0[0].data<long>() = ctpFiles.smxId();
         query->setCondition( condition, emptyBindVariableList0 );
        
         coral::AttributeList attList;
         attList.extend<std::string>( "L1SMX_NAME" );
         attList.extend<std::string>( "L1SMX_OUTPUT" );
         attList.extend<std::string>( "L1SMX_VHDL_SLOT7" );
         attList.extend<std::string>( "L1SMX_VHDL_SLOT8" );
         attList.extend<std::string>( "L1SMX_VHDL_SLOT9" );
         attList.extend<std::string>( "L1SMX_SVFI_SLOT7" );
         attList.extend<std::string>( "L1SMX_SVFI_SLOT8" );
         attList.extend<std::string>( "L1SMX_SVFI_SLOT9" );
         fillQuery(query.get(),attList);
 
         coral::ICursor& cursor = query->execute();
         if ( ! cursor.next() ) {
            TRG_MSG_ERROR("No such L1_CTP_SMX entry " << ctpFiles.smxId() << " exists");
            commitSession();
            throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
         }
 
         const coral::AttributeList& row = cursor.currentRow();
         ctpFiles.setSmxName(row["L1SMX_NAME"].data<std::string>());
         ctpFiles.setCtpinSmxOutput(row["L1SMX_OUTPUT"].data<std::string>());
 
         ctpFiles.setCtpinSmxVhdlSlot7(row["L1SMX_VHDL_SLOT7"].data<std::string>());
         ctpFiles.setCtpinSmxVhdlSlot8(row["L1SMX_VHDL_SLOT8"].data<std::string>());
         ctpFiles.setCtpinSmxVhdlSlot9(row["L1SMX_VHDL_SLOT9"].data<std::string>());
         ctpFiles.setCtpinSmxSvfiSlot7(row["L1SMX_SVFI_SLOT7"].data<std::string>());
         ctpFiles.setCtpinSmxSvfiSlot8(row["L1SMX_SVFI_SLOT8"].data<std::string>());
         ctpFiles.setCtpinSmxSvfiSlot9(row["L1SMX_SVFI_SLOT9"].data<std::string>());
      }
     
      commitSession();
   }
   catch( const coral::Exception& e ) {
      TRG_MSG_ERROR("coral::Exception: " << e.what());
      commitSession();
      throw;
   }
   return true;
}

loadCtpmonData()

bool TrigConf::CTPFilesLoader::loadCtpmonData ( CTPFiles & ctpFiles )

private

Definition at line 379 of file CTPFilesLoader.cxx.

                                                               {
   TRG_MSG_INFO("start loading CTPMON data");
   try {
      startSession();
      // first check if we need to obtain the CTP files ID, or if it
      // was passed in
      if(ctpFiles.id() <= 0) {
         int l1id = ctpFiles.lvl1MasterTableId();
         int menuid = getMenuIdFromMaster(l1id);
         long filesid = getFilesIdFromMenu(menuid);
         ctpFiles.setId(filesid);
      }
 
      unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_CTP_FILES").newQuery() );
      query->setRowCacheSize( 13 );
 
      //Binding
      coral::AttributeList emptyBindVariableList0;
      std::string condition = "L1CF_ID = :fId";
      emptyBindVariableList0.extend<long>("fId");
      emptyBindVariableList0[0].data<long>() = ctpFiles.id();
      query->setCondition( condition, emptyBindVariableList0 );
        
      coral::AttributeList attList;
      attList.extend<std::string>( "L1CF_NAME" );
      attList.extend<int>( "L1CF_VERSION" );
      attList.extend<std::string>( "L1CF_MON_SEL_CTPMON" );
      attList.extend<std::string>( "L1CF_MON_DEC_CTPMON" );
      fillQuery(query.get(),attList);
 
 
      coral::ICursor& cursor = query->execute();
      if ( ! cursor.next() ) {
         TRG_MSG_ERROR("No such L1_CTP_Files exists " << ctpFiles.id());
         commitSession();
         throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
      }
 
      const coral::AttributeList& row = cursor.currentRow();
 
      std::string name = row["L1CF_NAME"].data<std::string>();
      int version = row["L1CF_VERSION"].data<int>();
      std::string ctpmonSelector_str = row["L1CF_MON_SEL_CTPMON"].data<std::string>();
      std::string ctpmonDecoder_str = row["L1CF_MON_DEC_CTPMON"].data<std::string>();
    
      if ( cursor.next() ) {
         TRG_MSG_ERROR("More than one GetFile exists "   << ctpFiles.id());
         commitSession();
         throw std::runtime_error( "CTPFilesLoader >>  CTPFiles not available" );
      }
     
      std::vector<u_int> monDecVec(CTPFiles::ALL_CTPMONDECODER_SIZE);
      TRG_MSG_INFO("Loading MON DEC vec of size " << monDecVec.size());
      parseHexString(monDecVec,ctpmonDecoder_str);
 
      //Selector for CTPMON - note the different format requires
      //different parsing here!
      std::vector<u_int> monSelVec(CTPFiles::ALL_CTPMONSELECTOR_SIZE);
      std::stringstream stream(ctpmonSelector_str);
      std::string val;
      u_int index = 0;
      u_int data = 0;
      while(stream >> val) {
         // get rid of possible '0x'
         std::string::size_type loc = val.find("0x");
         if(loc != std::string::npos) val.replace(loc,2,"");
         if(!convert_string<u_int>(data, val)) {
            TRG_MSG_ERROR("Conversion of CTPMONSELECTOR no" << index << " failed!");
            commitSession();
            throw std::runtime_error( "CTPFilesLoader >> CTPMONSELECTOR conversion failed." );    
         }
         if( index >=  CTPFiles::ALL_CTPMONSELECTOR_SIZE) {
            TRG_MSG_ERROR("CTPMON selector word no" << index << " out of bounds");
            commitSession();
            throw std::runtime_error( "CTPFilesLoader >> CTPMONSELECTOR conversion failed." );
         }
         monSelVec[index] = data;
         ++index;
      }
    
      // Fill the object with data
      ctpFiles.setName( name );
      ctpFiles.setVersion( version );
      ctpFiles.setCtpmonDecoder(monDecVec);
      ctpFiles.setCtpmonSelector(monSelVec); 
 
      commitSession();
   }
   catch( const coral::Exception& e ) {
      TRG_MSG_ERROR("coral::Exception: " << e.what());
      commitSession();
      throw;
   }
   return true;
}

loadL1MasterKey()

bool TrigConf::DBLoader::loadL1MasterKey ( int SuperMasterKey, int & Lvl1MasterKey )

inherited

get l1 master from super master

Definition at line 128 of file DBLoader.cxx.

                                                             {
   try {
      startSession();
      
      unique_ptr< coral::IQuery > q( m_session.nominalSchema().tableHandle( "SUPER_MASTER_TABLE").newQuery() );
      q->setRowCacheSize( 5 );
 
      //Bind list
      coral::AttributeList bindings;
      bindings.extend<int>("smtid");
      bindings[0].data<int>() = smk;
      q->setCondition( "SMT_ID = :smtid", bindings );
 
      //Output data and types
      coral::AttributeList attList;
      attList.extend<int>( "SMT_L1_MASTER_TABLE_ID" );
      fillQuery(q.get(), attList);
 
      coral::ICursor& cursor = q->execute();
      if ( ! cursor.next() ) {
         msg() << "DBLoader:           No such SuperMaster key exists " << smk << endl;
         throw runtime_error( "DBLoader:        SuperMasterKey not available" );
      }
    
      const coral::AttributeList& row = cursor.currentRow();
      Lvl1MasterKey = row["SMT_L1_MASTER_TABLE_ID"].data<int>();
   }
   catch( const std::exception& e ) {
      commitSession();
      msg() << "DBLoader:         C++ exception: " << e.what() << std::endl;
      throw;
   }
   commitSession();
   return true; 
}

loadL1MenuKey()

bool TrigConf::DBLoader::loadL1MenuKey ( int SuperMasterKey, int & Lvl1MenuKey )

inherited

get l1 menu id from super master

Definition at line 167 of file DBLoader.cxx.

                                                                    {
   try {
 
      int l1Master = 0;
      loadL1MasterKey(SuperMasterKey, l1Master);
 
      startSession();
    
      unique_ptr< coral::IQuery > q( m_session.nominalSchema().tableHandle( "L1_MASTER_TABLE").newQuery() );
      q->setRowCacheSize( 5 );
 
      //Bind list
      coral::AttributeList bindings;
      bindings.extend<int>("l1mtid");
      bindings[0].data<int>() = l1Master;
      q->setCondition( "L1MT_ID = :l1mtid" , bindings );
 
      //Output data and types
      coral::AttributeList attList;
      attList.extend<int>( "L1MT_TRIGGER_MENU_ID" );
      q->defineOutput(attList);
      q->addToOutputList( "L1MT_TRIGGER_MENU_ID" );
 
      coral::ICursor& cursor = q->execute();
      if ( ! cursor.next() ) {
         msg() << "DBLoader >> No such L1 Master key exists " << l1Master << std::endl;
         throw std::runtime_error( "DBLoader >> L1MasterKey not available" );
         commitSession();
      }
    
      const coral::AttributeList& row = cursor.currentRow();
      Lvl1MenuKey = row["L1MT_TRIGGER_MENU_ID"].data<int>();
 
      commitSession();
 
   }
   catch( const std::exception& e ) {
      msg() << "DBLoader >> Standard C++ exception: " << e.what() << std::endl;
      m_session.transaction().rollback();
      throw;
   }
   return true; 
}

loadSchemaVersion()

std::tuple< unsigned int, unsigned int > DBLoader::loadSchemaVersion ( ) const

privateinherited

get DB schema version and run number

Definition at line 81 of file DBLoader.cxx.

{
   const static auto versions = [&]() -> std::tuple<unsigned int,unsigned int> {
      bool mySession = false;
      if ( ! m_session.transaction().isActive() ) {
         m_session.transaction().start(true);
         mySession = true;
      }
 
      std::unique_ptr< coral::IQuery > q( m_session.nominalSchema().tableHandle( "TRIGGER_SCHEMA").newQuery() );
      q->setRowCacheSize( 1 );
 
      //Output data and types
      coral::AttributeList attList;
      attList.extend<int>( "TS_ID" );
      q->defineOutput(attList);
      q->addToOutputList( "TS_ID" );
 
      q->addToOrderList("TS_ID desc");
      coral::ICursor& cursor = q->execute();
 
      if ( ! cursor.next() ) {
         TRG_MSG_ERROR("Table TRIGGER_SCHEMA is not filled");
         if ( mySession ) m_session.transaction().commit();
         throw std::runtime_error( "DBLoader::loadSchemaVersion() >> Table TRIGGER_SCHEMA is not filled" );
      }
 
      const coral::AttributeList& row = cursor.currentRow();
      const unsigned int triggerDBSchemaVersion = row["TS_ID"].data<int>();
 
      TRG_MSG_INFO("TriggerDB schema version: " << triggerDBSchemaVersion);
 
      const unsigned int run = m_session.nominalSchema().existsTable( "ACTIVE_MASTERS" ) ? 2 : 1;
 
      TRG_MSG_INFO("Database has Run " << run << " schema");
      TRG_MSG_INFO("Total number of tables : " <<  m_session.nominalSchema().listTables().size());
 
      //commitSession();
      if ( mySession ) m_session.transaction().commit();
 
      return {triggerDBSchemaVersion, run};
   }();
 
   return versions;
}

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()

virtual MSGTC::Level TrigConf::DBLoader::outputLevel ( ) const

inlineoverridevirtualinherited

Implements TrigConf::ILoader.

Definition at line 40 of file DBLoader.h.

{ return msg().level(); }

parseHexString()

void TrigConf::CTPFilesLoader::parseHexString ( std::vector< u_int > & vec, const std::string & str, bool verbose = false )

private

Definition at line 476 of file CTPFilesLoader.cxx.

                                                                                                    {
   u_int data;
   const static u_int significantBits = 8;
   const static u_int preFix = 2;
   const static u_int postFix = 1;
   const static u_int wordsize = (preFix + significantBits + postFix);
 
   if(str.size() != 0) {
      if(str.size() != wordsize * vec.size()) {
         TRG_MSG_ERROR("File content from DB of size " << str.size() << ", but expects " << wordsize * vec.size() << " [11 * " << vec.size() << "]");
         throw std::runtime_error( "CTPFilesLoader: file of unexpected size" );
      }
   } else {
      TRG_MSG_INFO("DB File content is 0, which is expected for MC, Reprocessing, and ATN databases");
      return;
   }
 
   for(u_int i=0; i < vec.size(); ++i) {
      if( ! convert_hex_string<u_int>(data, str.substr(i*wordsize+preFix,significantBits))) {
         TRG_MSG_ERROR("Conversion no " << i << " failed!");
         commitSession();
         throw std::runtime_error( "CTPFilesLoader >> Conversion failed." );     
      }
      if(verbose) {
         //cout << "joerg " << str.substr(i*wordsize+preFix,significantBits) << "   ----->   " << i << "  " << data << endl;
      }
      vec[i] = data;
   }
}

setLevel()

void DBLoader::setLevel ( MSGTC::Level lvl )

overridevirtualinherited

access to output stream

Implements TrigConf::ILoader.

Definition at line 60 of file DBLoader.cxx.

                                 {
   msg().setLevel(lvl);
 
   switch(lvl) {
   case MSGTC::ALWAYS: m_verbose = 5; break;
   case MSGTC::VERBOSE: m_verbose = 4; break;
   case MSGTC::DEBUG: m_verbose = 3; break;
   case MSGTC::INFO: m_verbose = 2; break;
   case MSGTC::WARNING:
   case MSGTC::ERROR:
   case MSGTC::FATAL: m_verbose = 0; break;
   default: m_verbose = 0;
   }
}

setVerbose()

virtual void TrigConf::DBLoader::setVerbose ( int v )

inlineoverridevirtualinherited

Implements TrigConf::ILoader.

Definition at line 58 of file DBLoader.h.

{ m_verbose=v; }

startSession()

void TrigConf::DBLoader::startSession ( )

inherited

start session if not already active

Definition at line 35 of file DBLoader.cxx.

{
   if ( ! m_session.transaction().isActive() ) {
      //std::cout << "DBLoader: startSession(readonly=true)" << std::endl;
      bool readOnly = true;
      m_session.transaction().start(readOnly);
      m_sessionOwner = true;
   }
}

triggerDBSchemaVersion()

unsigned int DBLoader::triggerDBSchemaVersion ( )

inherited

Definition at line 76 of file DBLoader.cxx.

                                 {
   return std::get<0>(loadSchemaVersion());
}

verbose()

virtual int TrigConf::DBLoader::verbose ( ) const

inlineoverridevirtualinherited

Implements TrigConf::ILoader.

Definition at line 57 of file DBLoader.h.

{ return m_verbose; }

Member Data Documentation

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_name

std::string TrigConf::TrigConfMessaging::m_name

privateinherited

Definition at line 72 of file TrigConfMessaging.h.

m_session

coral::ISessionProxy& TrigConf::DBLoader::m_session

protectedinherited

CORAL interface to database session.

Definition at line 68 of file DBLoader.h.

m_sessionOwner

bool TrigConf::DBLoader::m_sessionOwner {false}

protectedinherited

remember if the loader started the session in the first place

Definition at line 69 of file DBLoader.h.

{false}; 

m_storageMgr

StorageMgr& TrigConf::DBLoader::m_storageMgr

protectedinherited

reference to the storage manager

Definition at line 67 of file DBLoader.h.

m_verbose

int TrigConf::DBLoader::m_verbose {1}

privateinherited

Definition at line 64 of file DBLoader.h.

{1};

---

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

• CTPFilesLoader.h
• CTPFilesLoader.cxx