TriggerDB loader of the HLT job options. More...

#include <JobOptionTableLoader.h>

Inheritance diagram for TrigConf::JobOptionTableLoader:

Collaboration diagram for TrigConf::JobOptionTableLoader:

Classes
class	SplitParam

Public Member Functions
	JobOptionTableLoader (StorageMgr &sm, coral::ISessionProxy &session)
	constructor More...

virtual	~JobOptionTableLoader () override=default
	destructor More...

virtual bool	load (TrigConfData &data)

void	defineQueries ()

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

MsgStreamTC &	msg (const MSGTC::Level lvl) const
	The standard message stream. More...

virtual void	setLevel (MSGTC::Level lvl) override
	access to output stream More...

virtual MSGTC::Level	outputLevel () const override

void	startSession ()
	start session if not already active More...

void	commitSession ()
	commit session if not already done More...

bool	loadL1MasterKey (int SuperMasterKey, int &Lvl1MasterKey)
	get l1 master from super master More...

bool	loadL1MenuKey (int SuperMasterKey, int &Lvl1MenuKey)
	get l1 menu id from super master More...

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

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

MsgStreamTC &	msg (const MSGTC::Level lvl) const
	The standard message stream. More...

Protected Attributes
StorageMgr &	m_storageMgr
	reference to the storage manager More...

coral::ISessionProxy &	m_session
	CORAL interface to database session. More...

bool	m_sessionOwner {false}
	remember if the loader started the session in the first place More...

Private Member Functions
bool	load (JobOptionTable &jot) override

bool	loadHLTMasterTable (int SuperMasterKey, int &masterTableID, int &triggerMenuID, int &l2SetupID, int &efSetupID)

bool	loadComponentNamesAndParameters (TrigConf::JobOptionTable &JOTable, const std::set< int > &compIDsToLoad)

bool	loadComponentNamesAndParameters (TrigConf::JobOptionTable &JOTable, const std::set< int > &compIDsToLoad, std::vector< SplitParam > &splitparams, std::set< int >::const_iterator &current, unsigned int batchSize)

std::set< int >	loadComponentIDsFromSetup (const int setup_id)

std::set< int >	loadComponentIDsFromMenu (const int menu_id, int triggerLevel)

std::set< int >	getChildCompIDs (const std::set< int > &compIDs)

std::string	buildCond_IN_ (const std::string &field, const std::set< int > &IDs, std::set< int >::const_iterator &current, unsigned int batchSize)

unsigned int	assembleSplitParameters (JobOptionTable &jot, const std::vector< SplitParam > &splitparams)

unsigned int	assembleSplitParameters2 (JobOptionTable &jot, const std::vector< SplitParam > &splitparams)

std::tuple< unsigned int, unsigned int >	loadSchemaVersion () const
	get DB schema version and run number More...

Private Attributes
int	m_verbose {1}

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

TriggerDB loader of the HLT job options.

Definition at line 35 of file JobOptionTableLoader.h.

Constructor & Destructor Documentation

◆ JobOptionTableLoader()

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

inline

constructor

Parameters

sm	reference to storage manager
session	reference to the database session

Definition at line 48 of file JobOptionTableLoader.h.

49 : DBLoader("JobOptionTableLoader", sm, session)

50 {}

◆ ~JobOptionTableLoader()

virtual TrigConf::JobOptionTableLoader::~JobOptionTableLoader ( )

overridevirtualdefault

destructor

Member Function Documentation

◆ assembleSplitParameters()

unsigned int TrigConf::JobOptionTableLoader::assembleSplitParameters	(	JobOptionTable &	jot,
		const std::vector< SplitParam > &	splitparams
	)

private

Definition at line 411 of file JobOptionTableLoader.cxx.

                                                                                                                        {
  
    unsigned int paramCount = 0;
  
    // Loop over the vectors and match the alias and parameter names (excluding the __IPC__)
    std::string mergedvalue ="";
    std::string aliasname   ="";
    std::string paraname    ="";
    
    
    //ignore those we have already matched
    vector< SplitParam > alreadymatched_v;
    
    for (unsigned int sit=0; sit<splitparams.size(); sit++) {
       
       const SplitParam & splitpar = splitparams.at(sit);
  
       std::string actualname = splitpar.actualname;
       // std::cout << splitpar.alias << "    " << splitpar.name << std::endl;
          
       // see if already matched - paraname and the alias!
       bool matched = false;
       for (unsigned int mit=0; mit<alreadymatched_v.size(); mit++){ 
          SplitParam matchtemp = alreadymatched_v.at(mit);
          matched = ( matchtemp.actualname==actualname  &&  matchtemp.alias == splitpar.alias );
          if(matched) break;
       }
     
  
       if(!matched) {
          //have we gone on to the next name - if so, we have a merged parameter now
          if( paraname!=actualname || aliasname!=splitpar.alias ){
                
             if(aliasname!=""){
                //MAKE THE NEW JOBOPTION!
                JobOption jo( aliasname, paraname, "type", "set", mergedvalue); 
                jot.addJobOption(jo);
                paramCount++;
             }
             aliasname = splitpar.alias;
             paraname = actualname;
             mergedvalue="";
          }
             
          alreadymatched_v.push_back( splitpar );
          mergedvalue = splitpar.value;
             
          //now look for a match here
          for (unsigned int sit2=sit+1; sit2<splitparams.size(); sit2++){    
             const SplitParam& newtemp2 = splitparams.at(sit2);
             std::string actualname2 = newtemp2.actualname;
         
             if(actualname2==actualname && splitpar.alias==newtemp2.alias ){
                mergedvalue+= newtemp2.value;
                TRG_MSG_VERBOSE("Found split parameters " << splitpar.alias << " : " <<  splitpar.name << " - " << newtemp2.name);
                TRG_MSG_VERBOSE(splitpar.value << " - " << newtemp2.value);
             }
          }
       }
    }
  
    if(aliasname!=""){
       //have to take care of the last one!
       //MAKE THE NEW JOBOPTION!
       JobOption jo( aliasname, paraname, "type", "set", mergedvalue);   
       jot.addJobOption(jo);
       paramCount++;
    }
    return paramCount;
  
 }

◆ assembleSplitParameters2()

unsigned int TrigConf::JobOptionTableLoader::assembleSplitParameters2	(	JobOptionTable &	jot,
		const std::vector< SplitParam > &	splitparams
	)

private

Definition at line 506 of file JobOptionTableLoader.cxx.

                                                                                                                         {
  
    std::map<AssembledPar, std::vector<std::string>, APlessthan > assembled_params;
  
    boost::regex pname_exp("(.*)__IPC__(\\d+)");
    boost::cmatch matches;
  
    //   for(unsigned int i=0; i<splitparams.size(); ++i) {
    for(const SplitParam & splitpar: splitparams ) {
       //const SplitParam & splitpar = splitparams[i];
  
       if(boost::regex_match(splitpar.name.c_str(), matches, pname_exp)) {
  
          const std::string& comp_alias = splitpar.alias;
          std::string par_name(matches[1].first, matches[1].second);
          unsigned int pos = boost::lexical_cast<unsigned int,std::string>(string(matches[2].first, matches[2].second)) - 1;  // start with __IPC__01 
  
          std::vector<std::string>& values = assembled_params[ AssembledPar(comp_alias, par_name) ];
  
          if(values.size()<=pos) values.resize(pos+1);
          values[pos]= splitpar.value;
  
       } else {
          std::cout << "ERROR, can't parse " << splitpar.name << std::endl;
       }
  
    }
  
    for(auto par: assembled_params) {
  
       const string& comp_alias = par.first.comp_alias;
       const string& par_name = par.first.par_name;
       vector<string>& values = par.second;
       stringstream ss;
       copy(values.begin(), values.end(), std::ostream_iterator<std::string>(ss));
       jot.addJobOption( JobOption( comp_alias, par_name, "type", "set", ss.str()) );
    }
  
    return assembled_params.size();
 }

◆ buildCond_IN_()

std::string TrigConf::JobOptionTableLoader::buildCond_IN_	(	const std::string &	field,
		const std::set< int > &	IDs,
		std::set< int >::const_iterator &	current,
		unsigned int	batchSize
	)

private

Definition at line 268 of file JobOptionTableLoader.cxx.

                                                                                                                                                        {
  
    std::stringstream ss;
    ss << "(" << field << " IN (";
  
    unsigned int count(0), totalCount(0);
    set<int>::iterator last = IDs.end(); --last;
    for(; current!=last && totalCount!=batchSize-1; ++current) {
       totalCount++;
       ss << *current;
       if(++count==1000) {
          ss << ") OR " << field << " IN (";
          count=0;
       } else {
          ss << ",";
       }
    }
    ss << *current++ << "))";
  
    return ss.str();
 }

◆ 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();
    }
 }

◆ defineQueries()

void TrigConf::JobOptionTableLoader::defineQueries ( )

◆ getChildCompIDs()

std::set< int > TrigConf::JobOptionTableLoader::getChildCompIDs ( const std::set< int > & compIDs )

private

Definition at line 335 of file JobOptionTableLoader.cxx.

                                                                         {
  
    std::set<int> childCompIDs; // the children IDs
  
    TRG_MSG_DEBUG("Number of parents " << compIDs.size());
  
    vector<int> sortedParentIDs = createSortedVector(compIDs);
  
    vector<string> splitParentIDs = concatAndSplit(sortedParentIDs, 7500);
  
    for(const string& idList : splitParentIDs) {
  
       // condition
       string cond = "HCP2CP_PARENT_COMP_ID IN (" + idList + ")";
  
       coral::ITable& table = m_session.nominalSchema().tableHandle("HLT_CP_TO_CP");
       std::unique_ptr< coral::IQuery > q( table.newQuery() );
  
       coral::AttributeList bind;
       q->setCondition( cond, bind );
  
       // output
       coral::AttributeList attList;
       attList.extend<int>( "HCP2CP_CHILD_COMP_ID" );
       fillQuery(q.get(),attList);
  
       // distinct
       q->setDistinct();
  
       // execute
       coral::ICursor& cursor = q->execute();
  
       // fill output
       while( cursor.next() ) {
          const coral::AttributeList& row = cursor.currentRow();
          int id = row["HCP2CP_CHILD_COMP_ID"].data<int>();
          childCompIDs.insert(id);
       }
  
    }
  
    // no more children, can stop recursion
    if(childCompIDs.size()==0)
       return childCompIDs;
  
    // get all children recursively
    set<int> allSubChildrenIDs = getChildCompIDs(childCompIDs);
  
    // add to set of all children
    childCompIDs.insert(allSubChildrenIDs.begin(),allSubChildrenIDs.end());
  
    return childCompIDs;
 }

◆ isRun1()

bool TrigConf::DBLoader::isRun1 ( )

inlineinherited

Definition at line 60 of file DBLoader.h.

60 { 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() [1/2]

bool TrigConf::JobOptionTableLoader::load ( JobOptionTable & jot )

overrideprivatevirtual

Implements TrigConf::IJobOptionTableLoader.

Definition at line 549 of file JobOptionTableLoader.cxx.

                                                         {
  
    if(jot.smk()==0) {
       TRG_MSG_ERROR("requested SMK is 0");
       return false;
    }
  
    triggerDBSchemaVersion();
  
    TRG_MSG_INFO("Start loading job options with smk " << jot.smk());
  
    startSession();
    
    int masterTableID(0);
    int triggerMenuID(0);
    int l2SetupID(0);
    int efSetupID(0);
    if( ! loadHLTMasterTable( jot.smk(), 
                              masterTableID, 
                              triggerMenuID, 
                              l2SetupID, 
                              efSetupID ) )
       {
          TRG_MSG_ERROR("Could not load menu and setup IDs for SMK " << jot.smk());
          return false;
       }
    
    jot.setHltMasterTableId( masterTableID );
    TRG_MSG_INFO("HLT masterkey: " << jot.hltMasterTableId());
    TRG_MSG_INFO("Menu ID      : " << triggerMenuID);
    if(l2SetupID==efSetupID) {
       TRG_MSG_INFO("Setup ID     : " << l2SetupID);
    } else {
       TRG_MSG_INFO("L2 Setup ID  : " << l2SetupID);
       TRG_MSG_INFO("EF Setup ID  : " << efSetupID);
    }
  
    int level = jot.triggerLevel()==0; // triggerLevel: 0 - L2, 1 - EF, 2 - HLT(combined L2+EF)
    if( l2SetupID == efSetupID || 
        (l2SetupID != 0 && efSetupID==0) )
       level=2; // combined
  
    int setupId = (level==0 || level==2) ? l2SetupID : efSetupID;
  
    std::set<int> compIDsToLoad = loadComponentIDsFromSetup(setupId);
  
  
    TRG_MSG_INFO("Direct components => " << compIDsToLoad.size());
  
    std::set<int> childCompIDs = getChildCompIDs( compIDsToLoad );
    
    TRG_MSG_INFO("All children => " << childCompIDs.size());
  
    compIDsToLoad.insert(childCompIDs.begin(), childCompIDs.end());
  
    TRG_MSG_INFO("All components => " << compIDsToLoad.size());
  
    loadComponentNamesAndParameters(jot, compIDsToLoad);
  
    jot.sort();
  
    commitSession();
  
    // some stats:
    TRG_MSG_INFO("JobOptionTableLoader:             Total parameters  : " << jot.jobOptionVector().size());
    
    return true;        
 }

◆ load() [2/2]

bool TrigConf::JobOptionTableLoader::load ( TrigConfData & data )

virtual

Definition at line 391 of file JobOptionTableLoader.cxx.

                                                        {
  
    JobOptionTable& jot = dynamic_cast<JobOptionTable&>(data);
    try {
       return load(jot);
    }
    catch( const std::exception& e ) {
       TRG_MSG_FATAL("std::exception: " << e.what());
       throw;
    }
    return false;
 }

◆ loadComponentIDsFromMenu()

std::set< int > TrigConf::JobOptionTableLoader::loadComponentIDsFromMenu	(	const int	menu_id,
		int	triggerLevel
	)

private

Definition at line 206 of file JobOptionTableLoader.cxx.

                                                                                           {
  
    std::set<int> compIDs;
  
    std::unique_ptr< coral::IQuery > q( m_session.nominalSchema().newQuery() );
    q->setRowCacheSize( 1000 );
  
    q->addToTableList( "HLT_TM_TO_TC",      "TM2TC" );
    q->addToTableList( "HLT_TRIGGER_CHAIN", "TC"    );
    q->addToTableList( "HLT_TC_TO_TS",      "TC2TS" );
    q->addToTableList( "HLT_TS_TO_TE",      "TS2TE" );
    q->addToTableList( "HLT_TE_TO_CP",      "TE2CP" );
  
    // bind menu ID
    coral::AttributeList bind;
    bind.extend<int>("menuid");
    bind[0].data<int>() = menu_id;
  
  
    // condition
    std::string cond("TM2TC.HTM2TC_TRIGGER_MENU_ID = :menuid");
    cond += " AND TM2TC.HTM2TC_TRIGGER_CHAIN_ID = TC.HTC_ID";
    cond += " AND TM2TC.HTM2TC_TRIGGER_CHAIN_ID = TC2TS.HTC2TS_TRIGGER_CHAIN_ID";
    cond += " AND TC2TS.HTC2TS_TRIGGER_SIGNATURE_ID = TS2TE.HTS2TE_TRIGGER_SIGNATURE_ID";
    cond += " AND TS2TE.HTS2TE_TRIGGER_ELEMENT_ID = TE2CP.HTE2CP_TRIGGER_ELEMENT_ID";
  
    // triggerLevel
    if(triggerLevel!=2) { // 2 means combined
       cond += " AND TC.HTC_L2_OR_EF = ";
       cond += ( triggerLevel==0 ? "'L2'" : "'EF'" );
    }
  
    q->setCondition( cond , bind );
  
    // output
    coral::AttributeList attList;
    attList.extend<int>( "TE2CP.HTE2CP_COMPONENT_ID" );
    fillQuery(q.get(),attList);
  
    // execute
    coral::ICursor& cursor = q->execute();
    while( cursor.next() ) {
       const coral::AttributeList& row = cursor.currentRow();
       int id = row["TE2CP.HTE2CP_COMPONENT_ID"].data<int>();
       compIDs.insert(id);
    }
  
    TRG_MSG_INFO("Loaded M-Components => " << compIDs.size());
  
    return compIDs;
 }

◆ loadComponentIDsFromSetup()

std::set< int > TrigConf::JobOptionTableLoader::loadComponentIDsFromSetup ( const int setup_id )

private

Definition at line 168 of file JobOptionTableLoader.cxx.

                                                                           {
  
    std::set<int> compIDs;
  
    std::unique_ptr< coral::IQuery > q( m_session.nominalSchema().newQuery() );
    q->setRowCacheSize( 1000 );
  
    // tables
    q->addToTableList ( "HLT_ST_TO_CP",  "ST2CP" );
  
    // bind setup id
    coral::AttributeList bind;
    bind.extend<int>("setupid");
    bind[0].data<int>() = setup_id;
    
    std::string cond("ST2CP.HST2CP_SETUP_ID = :setupid");
    q->setCondition( cond , bind );
  
    // output and their types
    coral::AttributeList attList;
    attList.extend<int>( "ST2CP.HST2CP_COMPONENT_ID" );
    fillQuery(q.get(),attList);
  
    // execute
    coral::ICursor& cursor = q->execute();
    while( cursor.next() ) {
       const coral::AttributeList& row = cursor.currentRow();
       int id = row["ST2CP.HST2CP_COMPONENT_ID"].data<int>();
       compIDs.insert(id);
    }
  
    TRG_MSG_INFO("Loaded I-Components => " << compIDs.size());
    return compIDs;
 }

◆ loadComponentNamesAndParameters() [1/2]

bool TrigConf::JobOptionTableLoader::loadComponentNamesAndParameters	(	TrigConf::JobOptionTable &	JOTable,
		const std::set< int > &	compIDsToLoad
	)

private

Definition at line 91 of file JobOptionTableLoader.cxx.

                                                                                                                                {
  
    unsigned int batchSize = 500;
    set<int>::const_iterator current = compIDsToLoad.begin();
    vector< SplitParam > splitparams;
  
  
    while(current!=compIDsToLoad.end()) {
       loadComponentNamesAndParameters(JOTable, compIDsToLoad, splitparams, current, batchSize);
    }
  
  
    TRG_MSG_INFO("Split parameters => " << splitparams.size());
    TRG_MSG_INFO("Non-split parameters => " << JOTable.jobOptionVector().size());
    unsigned int countSplitParam = assembleSplitParameters2(JOTable, splitparams);
    TRG_MSG_INFO("Assembled split parameters => " << countSplitParam);
  
    return true;
 }

◆ loadComponentNamesAndParameters() [2/2]

bool JobOptionTableLoader::loadComponentNamesAndParameters	(	TrigConf::JobOptionTable &	JOTable,
		const std::set< int > &	compIDsToLoad,
		std::vector< SplitParam > &	splitparams,
		std::set< int >::const_iterator &	current,
		unsigned int	batchSize
	)

private

Definition at line 112 of file JobOptionTableLoader.cxx.

                                                                               {
  
    unique_ptr< coral::IQuery > q( m_session.nominalSchema().newQuery() );
    q->setRowCacheSize( 500 );
  
    q->addToTableList ( "HLT_COMPONENT", "CP" );
    q->addToTableList ( "HLT_CP_TO_PA",  "CP2PA" );
    q->addToTableList ( "HLT_PARAMETER", "PA" );
    
    
    // bind
    coral::AttributeList bind;
    
    std::string cond( buildCond_IN_("CP.HCP_ID", compIDsToLoad, current, batchSize) );
    cond += " AND CP2PA.HCP2PA_COMPONENT_ID = CP.HCP_ID";
    cond += " AND CP2PA.HCP2PA_PARAMETER_ID = PA.HPA_ID";
    q->setCondition( cond , bind );
  
    // output and their types
    coral::AttributeList attList;
    attList.extend<std::string>( "CP.HCP_ALIAS" );
    attList.extend<std::string>( "CP.HCP_TYPE" );
    attList.extend<std::string>( "PA.HPA_NAME" );
    attList.extend<std::string>( "PA.HPA_VALUE" );
    fillQuery(q.get(),attList);
    
    coral::ICursor& cursor = q->execute();
    
    while( cursor.next() ) {
       
       const coral::AttributeList& row = cursor.currentRow();
       
       string alias = row["CP.HCP_ALIAS"].data<std::string>();
       string type  = "type"; //row["CP.HCP_TYPE"].data<std::string>();
       string name  = row["PA.HPA_NAME"].data<std::string>();
       string value = row["PA.HPA_VALUE"].data<std::string>();
       
       if( value == "~" ) value = "";
       
       //if the parameter contains __ipc__ then its split - need to merge (after finding what to merge it with!)
       if(name.find("__IPC__",0) != string::npos){
          splitparams.push_back( SplitParam(alias, name, type, "set", value) );
       } else {
          JOTable.addJobOption( JobOption( alias, name, type, "set", value) );
       }      
    }
  
    return true;
 }

◆ loadHLTMasterTable()

bool TrigConf::JobOptionTableLoader::loadHLTMasterTable	(	int	SuperMasterKey,
		int &	masterTableID,
		int &	triggerMenuID,
		int &	l2SetupID,
		int &	efSetupID
	)

private

Definition at line 35 of file JobOptionTableLoader.cxx.

                                                                     {
  
    unique_ptr< coral::IQuery > q( m_session.nominalSchema().newQuery() );
  
    // tables
    q->addToTableList ( "SUPER_MASTER_TABLE", "SM" );
    q->addToTableList ( "HLT_MASTER_TABLE", "HM" );
  
    // Bind variables
    coral::AttributeList bindList;
    bindList.extend<int>("smid");
    bindList[0].data<int>() = SuperMasterKey;
  
    // the select condition
    string theCondition = "SM.SMT_HLT_MASTER_TABLE_ID = HM.HMT_ID AND SM.SMT_ID = :smid";
  
    q->setCondition( theCondition, bindList );
  
    // output fields
    coral::AttributeList attList;
    attList.extend<int> ( "HM.HMT_ID" );
    attList.extend<int> ( "HM.HMT_TRIGGER_MENU_ID" );
    if(isRun1()) {
       attList.extend<int> ( "HM.HMT_L2_SETUP_ID" );
       attList.extend<int> ( "HM.HMT_EF_SETUP_ID" );
    } else {
       attList.extend<int> ( "HM.HMT_SETUP_ID" );
    }
    fillQuery(q.get(),attList);
  
    // query
    coral::ICursor& cursor = q->execute();
  
    // get the HLT master-table id
    if( ! cursor.next() )
       return false;
  
    const coral::AttributeList& row = cursor.currentRow();
  
    masterTableID = row["HM.HMT_ID"].data<int>();
    triggerMenuID = row["HM.HMT_TRIGGER_MENU_ID"].data<int>();
    if(isRun1()) {
       l2SetupID     = row["HM.HMT_L2_SETUP_ID"].data<int>();
       efSetupID     = row["HM.HMT_EF_SETUP_ID"].data<int>();
    } else {
       l2SetupID = efSetupID = row["HM.HMT_SETUP_ID"].data<int>();
    }
    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/4]

MsgStreamTC & TrigConf::TrigConfMessaging::msg

inline

The standard message stream.

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

Definition at line 52 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/4]

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() [3/4]

MsgStreamTC & TrigConf::TrigConfMessaging::msg

inline

The standard message stream.

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

Definition at line 58 of file TrigConfMessaging.h.

   {
     return msg() << lvl;
   }

◆ msg() [4/4]

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

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

inlineoverridevirtualinherited

Implements TrigConf::ILoader.

Definition at line 40 of file DBLoader.h.

40 { return msg().level(); }

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

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

57 { 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 66 of file TrigConfMessaging.h.

◆ m_name

std::string TrigConf::TrigConfMessaging::m_name

privateinherited

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

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

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

Classes

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ JobOptionTableLoader()

◆ ~JobOptionTableLoader()

Member Function Documentation

◆ assembleSplitParameters()

◆ assembleSplitParameters2()

◆ buildCond_IN_()

◆ commitSession()

◆ defineQueries()

◆ getChildCompIDs()

◆ isRun1()

◆ isRun2()

◆ load() [1/2]

◆ load() [2/2]

◆ loadComponentIDsFromMenu()

◆ loadComponentIDsFromSetup()

◆ loadComponentNamesAndParameters() [1/2]

◆ loadComponentNamesAndParameters() [2/2]

◆ loadHLTMasterTable()

◆ loadL1MasterKey()

◆ loadL1MenuKey()

◆ loadSchemaVersion()

◆ msg() [1/4]

◆ msg() [2/4]

◆ msg() [3/4]

◆ msg() [4/4]

◆ msgLvl()

◆ outputLevel()

◆ setLevel()

◆ setVerbose()

◆ startSession()

◆ triggerDBSchemaVersion()

◆ verbose()

Member Data Documentation

◆ m_msg_tls

◆ m_name

◆ m_session

◆ m_sessionOwner

◆ m_storageMgr

◆ m_verbose