TrigConf::MenuLoader Class Reference

TriggerDB loader of the LVL1 trigger menu configuration. More...

#include <MenuLoader.h>

Inheritance diagram for TrigConf::MenuLoader:

Collaboration diagram for TrigConf::MenuLoader:

Classes
struct	ThrInfo

Public Types
enum	ENV {   ALL , CTP , CTPOnl , HLT ,   COOLL1 , COOLHLT , L1Simu }

Public Member Functions
	MenuLoader (StorageMgr &sm, coral::ISessionProxy &session)
	constructor
virtual	~MenuLoader () override=default
	destructor
virtual bool	load (Menu &data) override
virtual void	setEnv (ENV env) 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
void	loadMenuAttributes (TrigConf::Menu &menu)
void	loadCaloInfo (TrigConf::Menu &menu)
void	loadThresholds (TrigConf::Menu &menu)
void	loadPIT (TrigConf::Menu &menu)
void	loadItems (TrigConf::Menu &menu)
void	loadMonitoring (TrigConf::Menu &menu)
void	createTipFromDirectThresholds (TrigConf::Menu &menu)
TriggerItemNode *	constructTree (const std::string &def, const std::vector< ThrInfo > &)
	New versions for item definition in string.
TriggerItemNode *	constructTree (const LogicExpression &def, const std::vector< ThrInfo > &)
std::tuple< unsigned int, unsigned int >	loadSchemaVersion () const
	get DB schema version and run number

Private Attributes
ENV	m_env {CTP}
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 trigger menu configuration.

Definition at line 21 of file MenuLoader.h.

Member Enumeration Documentation

ENV

enum TrigConf::IMenuLoader::ENV

inherited

Enumerator
ALL
CTP
CTPOnl
HLT
COOLL1
COOLHLT
L1Simu

Definition at line 16 of file IMenuLoader.h.

{ALL, CTP, CTPOnl, HLT, COOLL1, COOLHLT, L1Simu} ENV;

Constructor & Destructor Documentation

MenuLoader()

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

inline

constructor

Parameters

sm	reference to storage manager
session	reference to the database session

Definition at line 29 of file MenuLoader.h.

                                                                :
         IMenuLoader(), DBLoader("MenuLoader", sm, session) {}

~MenuLoader()

virtual TrigConf::MenuLoader::~MenuLoader ( )

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

constructTree() [1/2]

TrigConf::TriggerItemNode * TrigConf::MenuLoader::constructTree ( const LogicExpression & def, const std::vector< ThrInfo > & thr_infos )

private

Definition at line 246 of file MenuLoader.cxx.

                                                                                                 {
   TriggerItemNode* top_node=0;
   const std::vector<std::shared_ptr<LogicExpression>> & sub_logics = def.subLogics();
 
   switch (def.state()) {
   case LogicExpression::kELEMENT: {
      top_node = new TriggerItemNode(TriggerItemNode::OBJ);
      unsigned int pos = static_cast<unsigned int>(std::stoul(def.element()));
      // find all related information
      for(ThrInfo ti : thr_infos) {
         if(ti.thrPos==pos) {
            top_node->setPosition( pos );
            top_node->setMultiplicity( ti.thrMult );
            top_node->setTriggerThreshold( ti.thr );
            break;
         }
      }
      break;
   }
   case LogicExpression::kAND: 
   case LogicExpression::kOPEN:
      top_node = new TriggerItemNode(TriggerItemNode::AND);
      for(auto sl : sub_logics)
         top_node->addChild( constructTree(*sl, thr_infos) );
      break;
   case LogicExpression::kOR:
      if(sub_logics.size()>0) {
         top_node = new TriggerItemNode(TriggerItemNode::OR);
         for(auto sl : sub_logics)
            top_node->addChild( constructTree(*sl, thr_infos) );
      }
      break;
   case LogicExpression::kNOT:
      top_node = new TriggerItemNode(TriggerItemNode::NOT);
      for(auto sl : sub_logics)
         top_node->addChild( constructTree(*sl, thr_infos) );
      break;
   }
 
   return top_node;
}

constructTree() [2/2]

TrigConf::TriggerItemNode * TrigConf::MenuLoader::constructTree ( const std::string & def, const std::vector< ThrInfo > & thr_infos )

private

New versions for item definition in string.

Definition at line 226 of file MenuLoader.cxx.

                                                                                                  {
   LogicExpression logic(msg());
   unsigned int n = logic.parse(definition);
   if ( n <= 0 ) {
      msg() << "Error parsing item definition : " << definition << std::endl;
      return 0;
   }
   unsigned int size = thr_infos.size();
   if (size != (n = logic.totalNumberOfElements()) ) {
      msg() << "Total number of elements are different: "
            << " input=" << size << ", parsed=" << n << endl;
   }
 
   logic.normalize();
 
   return constructTree(logic, thr_infos);
}

createTipFromDirectThresholds()

void TrigConf::MenuLoader::createTipFromDirectThresholds ( TrigConf::Menu & menu )

private

Definition at line 527 of file MenuLoader.cxx.

                                                                    {
 
   // this is only needed as long as the TIPs from the direct input are not in the database
 
   unsigned int ntips(0);
 
   for(TriggerThreshold * thr : menu.thresholdConfig().getThresholdVector() ) {
      if(thr->ttype()==L1DataDef::TOPO || thr->ttype()==L1DataDef::ALFA) {
 
         const string & conn = thr->cableConnector(); // "CON0", "CON1", "CON2"
 
         unsigned int connector = conn[3]-'0';
         unsigned int cableOffset = 320 + connector * 64;
         unsigned int cableBit = (unsigned int) thr->cableStart();
         unsigned int clock = thr->clock();
         unsigned int tipNumber = 2*cableBit + clock + cableOffset;
 
         TIP* tip = new TIP();
         tip->setThresholdName(thr->name());
         tip->setSlot(10);
         tip->setConnector( connector );
         tip->setTipNumber( tipNumber );
         tip->setThresholdBit( thr->clock() );
         tip->setCableBit( thr->cableStart() );
         tip->setTriggerThresholdId(thr->id() );
         tip->setThresholdActive(thr->active());
         tip->setThresholdMapping(thr->mapping());
         tip->setIsDirect(true);
         menu.addTip(tip);
         
         TRG_MSG_DEBUG("TIP from direct input thresholds " << tip->tipNumber() << "  -->  " << thr->name());
 
         ntips++;
         
      }
   }
 
   TRG_MSG_INFO( "Number of TIPs from direct input thresholds " << ntips );
 
}

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

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::MenuLoader::load ( Menu & data )

overridevirtual

Implements TrigConf::IMenuLoader.

Definition at line 34 of file MenuLoader.cxx.

                                     {
 
   if(menu.smk()<=0) return false;
   try {
      startSession();
 
      loadMenuAttributes(menu);
 
      loadCaloInfo(menu);
 
      loadThresholds(menu);
 
      loadItems(menu);
 
      loadMonitoring(menu);
   
      commitSession();
   }
   catch( const coral::Exception& e ) {
      TRG_MSG_ERROR("Caught coral exception: " << e.what());
      commitSession();
      throw;
   }
   catch( const std::exception& e ) {
      TRG_MSG_ERROR("Caught std exception: " << e.what());
      commitSession();
      throw;
   }
   return true;
} 

loadCaloInfo()

void TrigConf::MenuLoader::loadCaloInfo ( TrigConf::Menu & menu )

private

Definition at line 571 of file MenuLoader.cxx.

                                                   {
   // load the CaloInfo
   TrigConf::CaloInfo ci;
   ci.setSMK(menu.smk());
   m_storageMgr.caloInfoLoader().setLevel(outputLevel());
   m_storageMgr.caloInfoLoader().load(ci);
   menu.setCaloInfo(ci);
}

loadItems()

void TrigConf::MenuLoader::loadItems ( TrigConf::Menu & menu )

private

Definition at line 67 of file MenuLoader.cxx.

                                                {
   TRG_MSG_INFO("Loading CTP Items");
 
   // to later load internal triggers
   TriggerThresholdLoader& ttldr = dynamic_cast<TriggerThresholdLoader&>( (dynamic_cast<StorageMgr&>(m_storageMgr))
                                                                          .triggerThresholdLoader() );
   ttldr.setMenuId(menu.id());
   ttldr.setLoadCableInfo(false);
 
   // at this point the internal triggers are not found via the
   // TM->TT link, hence load them when needed, and cache them
   std::map<int,TriggerThreshold*> thresholdNotFoundCache;
 
   unique_ptr< coral::IQuery > query( m_session.nominalSchema().newQuery() );
   query->addToTableList ( "L1_TM_TO_TI",     "TM2TI" );
   query->addToTableList ( "L1_TRIGGER_ITEM", "TI"    );
   query->addToTableList ( "L1_TI_TO_TT",     "TI2TT" );
 
   // bind list
   coral::AttributeList bindList;
   bindList.extend<int>("menuId");
   bindList[0].data<int>() = menu.id();
 
   std::string theCondition = "";
   theCondition += std::string( " TM2TI.L1TM2TI_TRIGGER_MENU_ID = :menuId"        );
   theCondition += std::string( " AND TM2TI.L1TM2TI_TRIGGER_ITEM_ID = TI.L1TI_ID" );
   theCondition += std::string( " AND TI2TT.L1TI2TT_TRIGGER_ITEM_ID = TI.L1TI_ID" );
 
   query->setCondition( theCondition, bindList );
 
   // output data and types
   coral::AttributeList attList;
   attList.extend<int>        ( "TI.L1TI_ID"                         );
   attList.extend<std::string>( "TI.L1TI_NAME"                       );
   attList.extend<int>        ( "TI.L1TI_VERSION"                    );
   if(isRun2()) {
      attList.extend<int>     ( "TI.L1TI_PARTITION"                  );
      attList.extend<string>  ( "TI.L1TI_MONITOR"                    );
   }
   attList.extend<int>        ( "TI.L1TI_CTP_ID"                     );
   attList.extend<std::string>( "TI.L1TI_PRIORITY"                   );
   attList.extend<std::string>( "TI.L1TI_DEFINITION"                 );
   attList.extend<int>        ( "TI.L1TI_TRIGGER_TYPE"               );
   attList.extend<int>        ( "TI2TT.L1TI2TT_TRIGGER_THRESHOLD_ID" );
   attList.extend<int>        ( "TI2TT.L1TI2TT_POSITION"             );
   attList.extend<int>        ( "TI2TT.L1TI2TT_MULTIPLICITY"         );
   fillQuery(query.get(), attList);
 
   // the ordering
   std::string theOrder = "";
   // to get the correct number of items
   theOrder += "  TI.L1TI_CTP_ID ASC";
   // to get the correct TI definition  
   theOrder += ", TI2TT.L1TI2TT_POSITION ASC";
   query->addToOrderList( theOrder );
 
   //query->setRowCacheSize(1000);
   query->setRowCacheSize(500);
 
   query->setDistinct();
 
   coral::ICursor& cursor = query->execute();
 
   // lists to store <ctpId, vector> for later use
   vector<int> ctpIDs;
   map<int,vector<ThrInfo> > item_thrInfo;
 
   // create the items
   while (cursor.next()) {
 
      const coral::AttributeList& row = cursor.currentRow();
      int ctpid = row["TI.L1TI_CTP_ID"].data<int>();
      TriggerItem* item = menu.item(ctpid);
      if(! item) {
         item = new TriggerItem();
         item->setCtpId      (ctpid);
         item->setId         (row["TI.L1TI_ID"].data<int>());
         item->setName       (row["TI.L1TI_NAME"].data<string>());
         item->setVersion    (row["TI.L1TI_VERSION"].data<int>());
         if(isRun2()) {
            item->setPartition  (row["TI.L1TI_PARTITION"].data<int>());
            string mon = row["TI.L1TI_MONITOR"].data<string>();
            unsigned short monMask = 0;
 
            const short TBP = 0x1;
            const short TAP = 0x2;
            const short TAV = 0x4;
            
            vector<string> monLfHf;
            boost::split(monLfHf, mon, boost::is_any_of(":|"));
            //copy(monLfHf.begin(),monLfHf.end(), ostream_iterator<string>(cout,"\n") );
            
            if(monLfHf.size()==4 && monLfHf[0]=="LF" && monLfHf[2]=="HF" && monLfHf[1].size()==3 && monLfHf[3].size()==3) {
               // LF
               if( monLfHf[1][2]=='1' )  monMask |= TBP;
               if( monLfHf[1][1]=='1' )  monMask |= TAP;
               if( monLfHf[1][0]=='1' )  monMask |= TAV;
               // HF
               if( monLfHf[3][2]=='1' )  monMask |= TBP << 3;
               if( monLfHf[3][1]=='1' )  monMask |= TAP << 3;
               if( monLfHf[3][0]=='1' )  monMask |= TAV << 3;
            } else {
               // this is for the temporary solution
               if(mon.find("TBP") != string::npos) monMask |= TBP;
               if(mon.find("TAP") != string::npos) monMask |= TAP;
               if(mon.find("TAV") != string::npos) monMask |= TAV;
            }
            item->setMonitor( monMask );
         }
 
         string priority = row["TI.L1TI_PRIORITY"].data<string>();
         if(priority=="0" || priority=="HIGH") {
            item->setComplexDeadtime(0);
         } else if(priority=="1" || priority=="LOW") {
            item->setComplexDeadtime(1);
         }
         item->setDefinition (row["TI.L1TI_DEFINITION"].data<string>());
         item->setTriggerType(row["TI.L1TI_TRIGGER_TYPE"].data<int>());
         menu.addTriggerItem(item);
         if(verbose()>1)
            msg() << "MenuLoader:                       Created Item " << item->name() << " with CTPID " << item->ctpId() << endl;
         item_thrInfo[ctpid] = vector<ThrInfo>();
         ctpIDs.push_back(ctpid);
      }
 
      ThrInfo thr_info;
      thr_info.thrId = row["TI2TT.L1TI2TT_TRIGGER_THRESHOLD_ID"].data<int>();
      thr_info.thrPos = row["TI2TT.L1TI2TT_POSITION"].data<int>();
      thr_info.thrMult = row["TI2TT.L1TI2TT_MULTIPLICITY"].data<int>();
      thr_info.thr = menu.thresholdConfig().findTriggerThreshold(thr_info.thrId);
      if(thr_info.thr==0) {
         // load threshold (internal thresholds)
         thr_info.thr = new TriggerThreshold();
         thr_info.thr->setId(thr_info.thrId);
         if ( ! ttldr.load( *thr_info.thr ) ) {
            msg() << "MenuLoader:                       Error loading TriggerThreshold " << thr_info.thrId << endl;
            throw runtime_error( "MenuLoader::loadItems: error loading TriggerThreshold " );
         }
         menu.thresholdConfig().addTriggerThreshold(thr_info.thr);
      }
      item_thrInfo[ctpid].push_back(thr_info);
   }
 
   // build the item node tree
   for(int ctpid : ctpIDs) {
      TriggerItem* titem = menu.findTriggerItem( ctpid );
      if(verbose()>2) {
         msg() << "MenuLoader:                       Number of thresholds for item " << titem->name()
               << ": " << item_thrInfo[ctpid].size() << " - definition: " << titem->definition() << endl;
      }
      // construct the tree of TriggerItemNodes according to
      // definition and set the thresholds and multiplicities in each
      // leaf node
      titem->setTopNode( constructTree(titem->definition(), item_thrInfo[ctpid]) );
   }
}

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

loadMenuAttributes()

void TrigConf::MenuLoader::loadMenuAttributes ( TrigConf::Menu & menu )

private

Definition at line 584 of file MenuLoader.cxx.

                                                         {
 
   TRG_MSG_DEBUG("Loading menu data for SMK " << menu.smk());
 
   unique_ptr< coral::IQuery > q( m_session.nominalSchema().newQuery() );
   q->addToTableList ( "SUPER_MASTER_TABLE", "SM"    );
   q->addToTableList ( "L1_MASTER_TABLE",    "MT"    );
   q->addToTableList ( "L1_TRIGGER_MENU",    "TM"    );
 
   //Bind list
   coral::AttributeList bindings;
   bindings.extend<int>("smk");
   bindings[0].data<int>() = menu.smk();
 
   string condition("");
   condition += "SM.SMT_ID = :smk";
   condition += " AND SM.SMT_L1_MASTER_TABLE_ID = MT.L1MT_ID";
   condition += " AND MT.L1MT_TRIGGER_MENU_ID = TM.L1TM_ID";
   q->setCondition( condition , bindings );
 
   //Define the data types
   coral::AttributeList attList;
   attList.extend<int>("TM.L1TM_ID");
   attList.extend<string>("TM.L1TM_NAME");
   attList.extend<int>("TM.L1TM_VERSION");
   attList.extend<int>("MT.L1MT_ID" );
   fillQuery(q.get(), attList);
      
   coral::ICursor& cursor = q->execute();
   if ( ! cursor.next() ) {
      TRG_MSG_ERROR("No trigger menu in SMK " << menu.smk());
      throw runtime_error( "MenuLoader: ERROR trigger menu not available" );
   }
     
   // fill the object with data
   const coral::AttributeList& row = cursor.currentRow();
   menu.setId     ( row["TM.L1TM_ID"].data<int>() );
   menu.setName   ( row["TM.L1TM_NAME"].data<string>() );
   menu.setVersion( row["TM.L1TM_VERSION"].data<int>() );
   menu.thresholdConfig().setLvl1MasterTableId( row["MT.L1MT_ID"].data<int>() );
}

loadMonitoring()

void TrigConf::MenuLoader::loadMonitoring ( TrigConf::Menu & menu )

private

Definition at line 293 of file MenuLoader.cxx.

                                                     {
   if( ! (m_env == MenuLoader::ALL    ||
          m_env == MenuLoader::CTP    ||
          m_env == MenuLoader::CTPOnl ||
          m_env == MenuLoader::COOLL1) ) return;
 
   TRG_MSG_DEBUG("Load monitoring counter mapping ");
 
   unique_ptr< coral::IQuery > q(m_session.nominalSchema().newQuery());
   q->addToTableList ( "L1_TM_TO_TT_MON",      "TM2TTM" );
   q->addToTableList ( "L1_TRIGGER_THRESHOLD", "TT"     );
   q->addToTableList ( "L1_TM_TO_TT",          "TM2TT"  );
 
   //Bind list
   coral::AttributeList bindings;
   bindings.extend<int>("menuId");
   bindings[0].data<int>() = menu.id();
 
   string cond = "";
   cond += " TM2TTM.L1TM2TTM_TRIGGER_MENU_ID = :menuId";
   cond += " AND TM2TT.L1TM2TT_TRIGGER_MENU_ID = :menuId";
   cond += " AND TM2TTM.L1TM2TTM_TRIGGER_THRESHOLD_ID = TM2TT.L1TM2TT_TRIGGER_THRESHOLD_ID";
   cond += " AND TM2TT.L1TM2TT_TRIGGER_THRESHOLD_ID = TT.L1TT_ID";
 
   q->setCondition( cond, bindings );
 
   // Output data and types
   coral::AttributeList output;
   output.extend<std::string>( "TM2TTM.L1TM2TTM_NAME"                        );
   output.extend<int>        ( "TM2TTM.L1TM2TTM_TRIGGER_THRESHOLD_ID"        );
   output.extend<int>        ( "TM2TTM.L1TM2TTM_INTERNAL_COUNTER"            );
   output.extend<int>        ( "TM2TTM.L1TM2TTM_MULTIPLICITY"                );
   output.extend<long>       ( "TM2TTM.L1TM2TTM_BUNCH_GROUP_ID"              );
   output.extend<std::string>( "TM2TTM.L1TM2TTM_COUNTER_TYPE"                );
   output.extend<std::string>( "TT.L1TT_NAME"                                );
   output.extend<int>        ( "TT.L1TT_ACTIVE"                              );
   output.extend<std::string>( "TM2TT.L1TM2TT_CABLE_CTPIN"                   ); 
   output.extend<std::string>( "TM2TT.L1TM2TT_CABLE_CONNECTOR"               );
   output.extend<int>        ( "TM2TT.L1TM2TT_CABLE_START"                   ); 
   output.extend<int>        ( "TM2TT.L1TM2TT_CABLE_END"                     );
   fillQuery(q.get(), output);
 
   q->setRowCacheSize(500);
 
   coral::ICursor& cursor = q->execute();
   ThresholdMonitor* tm = 0;
 
   while (cursor.next()) {
      const coral::AttributeList& row = cursor.currentRow();
      tm = new ThresholdMonitor();
 
      tm->setName           ( row["TM2TTM.L1TM2TTM_NAME"].data<string>());
      tm->setThresholdId    ( row["TM2TTM.L1TM2TTM_TRIGGER_THRESHOLD_ID"].data<int>());
      tm->setInternalCounter( row["TM2TTM.L1TM2TTM_INTERNAL_COUNTER"].data<int>());
      tm->setMultiplicity   ( row["TM2TTM.L1TM2TTM_MULTIPLICITY"].data<int>());
      tm->setBunchGroupId   ( row["TM2TTM.L1TM2TTM_BUNCH_GROUP_ID"].data<long>()); 
      tm->setCounterType    ( row["TM2TTM.L1TM2TTM_COUNTER_TYPE"].data<string>());
      tm->setThresholdName  ( row["TT.L1TT_NAME"].data<string>());
      tm->setThresholdActive( row["TT.L1TT_ACTIVE"].data<int>());
 
      string slotString = row["TM2TT.L1TM2TT_CABLE_CTPIN"].data<std::string>();
      uint16_t slot = slotString[4]-'0'; // "SLOT7" -> 7
      if(slot<7 || slot>9) {
         TRG_MSG_ERROR("Unknown CTPIN string '" << slotString << "'");
         throw runtime_error( "MenuLoader (ThresholdMonitor): Error loading Monitoring counters " );
      }
      tm->setCtpinSlot(slot);
 
      string conString = row["TM2TT.L1TM2TT_CABLE_CONNECTOR"].data<std::string>();
      uint16_t con = conString[3]-'0'; // "CON2" -> 2
      if(con>3) {
         TRG_MSG_ERROR("Unknown CTPIN connector string '" << conString << "'");
         throw runtime_error( "MenuLoader (ThresholdMonitor): Error loading Monitoring counters " );
      }
      tm->setCtpinConnector(con);
      tm->setThresholdStartBit(row["TM2TT.L1TM2TT_CABLE_START"].data<int>());
      tm->setThresholdEndBit  (row["TM2TT.L1TM2TT_CABLE_END"].data<int>());
      menu.addThresholdMonitor(tm);
   } 
 
}

loadPIT()

void TrigConf::MenuLoader::loadPIT ( TrigConf::Menu & menu )

private

Definition at line 410 of file MenuLoader.cxx.

                                              {
   if( ! (m_env == MenuLoader::ALL    ||
          m_env == MenuLoader::CTPOnl ||
          m_env == MenuLoader::COOLL1) ) return;
 
   set<int> tipNumbersUsed;
 
 
   unique_ptr< coral::IQuery > q( m_session.nominalSchema().newQuery() );
   q->addToTableList ( "L1_TM_TO_TT",          "TM2TT" );
   q->addToTableList ( "L1_PITS",              "PITS"  );
 
   //Bind list
   coral::AttributeList bindings;
   bindings.extend<int>("menuId");
   bindings[0].data<int>() = menu.id();
 
   std::string cond("TM2TT.L1TM2TT_TRIGGER_MENU_ID = :menuId");
   cond += " AND PITS.L1PIT_TM_TO_TT_ID = TM2TT.L1TM2TT_ID";
   q->setCondition( cond, bindings );
 
   // should not be necessary, however currently the TriggerTool uploads identical copies in some cases
   q->setDistinct();
 
   // Output data and types
   coral::AttributeList attList;
   attList.extend<int>( "TM2TT.L1TM2TT_TRIGGER_THRESHOLD_ID" );
   attList.extend<int>( "TM2TT.L1TM2TT_ID"                   );
   attList.extend<int>( "PITS.L1PIT_PIT_NUMBER"              );
   attList.extend<int>( "PITS.L1PIT_THRESHOLD_BIT"           );
   fillQuery(q.get(), attList);
 
   uint npits(0), ntips(0);
 
   coral::ICursor& cursor = q->execute();
   while (cursor.next()) {
      const coral::AttributeList& row = cursor.currentRow();
 
      int ttid   = row["TM2TT.L1TM2TT_TRIGGER_THRESHOLD_ID"].data<int>();
      int tmtott = row["TM2TT.L1TM2TT_ID"].data<int>();
      int tipnum = row["PITS.L1PIT_PIT_NUMBER"].data<int>();
      int bitnum = row["PITS.L1PIT_THRESHOLD_BIT"].data<int>();
 
      TriggerThreshold* tt = menu.thresholdConfig().findTriggerThreshold(ttid);
 
 
      string slotString = tt->cableCtpin();
      uint16_t slot = 0;
      if( boost::iequals( slotString, "CTPCORE" ) ) {
         slot = 10;
      } else {
         slot = slotString[4]-'0'; // "SLOT7" -> (uint)7
      }
      if(slot<7 || slot>10) {
         TRG_MSG_ERROR("Unknown CTPIN SLOT '" << slotString << "'");
         throw runtime_error( "MenuLoader: Error loading PITs " );
      }
 
      string conString = tt->cableConnector();
      uint16_t con = conString[3]-'0'; // "CON2" -> (uint)2
      uint16_t conMax = slot==10 ? 2 : 3;
      if( con > conMax ) {
         TRG_MSG_ERROR("Unknown CTPIN CONNECTOR '" << conString << "'");
         throw runtime_error( "MenuLoader: Error loading PITs " );
      }
 
      if(slot!=10) {
         PIT* pit = new PIT();
         pit->setThresholdName(tt->name());
         pit->setCtpinSlot(slot);
         pit->setCtpinConnector( con );
         pit->setPitNumber(tipnum);
         pit->setThresholdBit(bitnum);
         pit->setCableBit( tt->cableStart() + bitnum );
         pit->setTmToTtId(tmtott);
         pit->setTriggerThresholdId(ttid);
         pit->setThresholdActive(tt->active());
         pit->setThresholdMapping(tt->mapping());
         menu.addPit(pit);
         npits++;
      }
 
      // this is for early menus
      if(tipNumbersUsed.count(tipnum) > 0) {
         tipnum = tipnum + 160;
      } else {
         tipNumbersUsed.insert(tipnum);
      }
 
      TIP* tip = new TIP();
      tip->setThresholdName(tt->name());
      tip->setSlot(slot);
      tip->setConnector( con );
      tip->setTipNumber(tipnum);
      tip->setClock( tipnum % 2 );
      tip->setThresholdBit(bitnum);
      tip->setCableBit( tt->cableStart() + bitnum );
      tip->setTmToTtId(tmtott);
      tip->setTriggerThresholdId(ttid);
      tip->setThresholdActive(tt->active());
      tip->setThresholdMapping(tt->mapping());
      if(slot==10) tip->setIsDirect(true);
      else tip->setIsDirect(false);
      menu.addTip(tip);
      ntips++;
 
      TRG_MSG_DEBUG("TIP " << tip->tipNumber() << " -->  " << tt->name());
   }
 
   TRG_MSG_INFO("Loaded " << npits << " PITs and " << ntips << " TIPs");
   TRG_MSG_INFO("Menu has " << menu.pitVector().size() << " PITs and " << menu.tipVector().size() << " TIPs");
 
 
}

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

loadThresholds()

void TrigConf::MenuLoader::loadThresholds ( TrigConf::Menu & menu )

private

Definition at line 386 of file MenuLoader.cxx.

                                                     {
   TRG_MSG_INFO("Loading L1 trigger thresholds");
 
   ThresholdConfigLoader* thrldr = new ThresholdConfigLoader(m_storageMgr, m_session);
   thrldr->setLevel(outputLevel());
   if ( !thrldr->load( menu.thresholdConfig() ) ) {
      TRG_MSG_ERROR("Error loading ThresholdConfig " << menu.thresholdConfig().id());
      throw runtime_error( "MenuLoader: Error loading ThresholdConfig " );
   }
 
   loadPIT(menu);
 
   if( menu.pitVector().size() == menu.tipVector().size() ) {
      // this is the case when we 
      // a) have either no direct inputs in the menu (unlikely, but then the next call doesn't matter), or
      // b) the direct inputs were not filled in the TIP map: this is not the case  since TriggerTool-04-01-06 
      createTipFromDirectThresholds(menu);
   }
 
}

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

setEnv()

virtual void TrigConf::MenuLoader::setEnv ( ENV env )

inlineoverridevirtual

Implements TrigConf::IMenuLoader.

Definition at line 37 of file MenuLoader.h.

{ m_env = env;  }

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_env

ENV TrigConf::MenuLoader::m_env {CTP}

private

Definition at line 39 of file MenuLoader.h.

{CTP};

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:

• MenuLoader.h
• MenuLoader.cxx