LVL1CTP::ItemMap Class Reference

Map associating item name to CTPTriggerItem objects. More...

#include <ItemMap.h>

Collaboration diagram for LVL1CTP::ItemMap:

Public Member Functions
	ItemMap (const TrigConf::L1Menu *l1menu)
	ItemMap (const TrigConf::ItemContainer &item_vector, const TrigConf::PrescaleSet &prescales)
	constructor setting list of trigger items and associated prescales (random prescale offset if randEngine is given)
	~ItemMap ()
	default destructor
const CTPTriggerItem *	getItem (const std::string &itemName) const
const std::set< std::string > &	itemNames () const

Private Member Functions
std::string	getDefinition (const TrigConf::TriggerItem *item) const

Private Attributes
std::map< std::string, const CTPTriggerItem * >	m_map
	map from item name to CTPTriggerItem
std::set< std::string >	m_itemNames {}

Detailed Description

Map associating item name to CTPTriggerItem objects.

Definition at line 37 of file ItemMap.h.

Constructor & Destructor Documentation

ItemMap() [1/2]

LVL1CTP::ItemMap::ItemMap

(

const TrigConf::L1Menu *

l1menu

)

Definition at line 22 of file ItemMap.cxx.

{
   for( const TrigConf::L1Item & item : *l1menu ) {
      const std::string & itemName( item.name() );
 
      // get postion from ctp id
      unsigned int ctpId = item.ctpId();
 
      CTPTriggerItem * ctpItem = new CTPTriggerItem();
      ctpItem->setPrescale( 1 );
      ctpItem->setCtpId( ctpId );
      ctpItem->setName(itemName);
      ctpItem->setLogic(item.definition());
      ctpItem->setTriggerType(item.triggerTypeAsUChar());
      ctpItem->setBunchGroups(item.bunchgroups());
 
      m_map[ itemName ] = ctpItem;
      m_itemNames.insert( itemName );
      
   }
}

ItemMap() [2/2]

LVL1CTP::ItemMap::ItemMap	(	const TrigConf::ItemContainer &	item_vector,
		const TrigConf::PrescaleSet &	prescales )

constructor setting list of trigger items and associated prescales (random prescale offset if randEngine is given)

Definition at line 52 of file ItemMap.cxx.

{
   for( const TrigConf::TriggerItem * item : item_vector ) {
 
      std::string definition = getDefinition(item);
 
      const std::string & itemName( item->name() );
 
      // get postion from ctp id
      unsigned int ctpId = item->ctpId();
 
      CTPTriggerItem * ctpItem = new CTPTriggerItem();
      ctpItem->setPrescale( prescales.prescales_float()[ ctpId ] );
      ctpItem->setCtpId( ctpId );
      ctpItem->setName(itemName);
      ctpItem->setLogic(definition);
      ctpItem->setTriggerType(item->triggerType());
 
      m_map[ itemName ] = ctpItem;
      m_itemNames.insert( itemName );
   }
}

~ItemMap()

LVL1CTP::ItemMap::~ItemMap

(

)

default destructor

Definition at line 45 of file ItemMap.cxx.

                         {
   for( auto & entry : m_map ) {
      delete entry.second;
   }
}

Member Function Documentation

getDefinition()

std::string LVL1CTP::ItemMap::getDefinition ( const TrigConf::TriggerItem * item ) const

private

Definition at line 86 of file ItemMap.cxx.

                                                                      {
 
 
   std::vector<std::string> thresholdlist;
   std::string logic, conditions;
   item->buildLogic(logic, thresholdlist); // get's the list of thresholds, e.g. 1,EM15VHI_x1,EM15VHI  2,HA12IM_x2,HA12IM  1,J25_x1,J25  3,J12_x3,J12  BGRP0  BGRP1
 
   std::map<unsigned int, std::string> thrNames;
   size_t idx = 1;
   for(const std::string & thrmult : thresholdlist) {
      std::vector<std::string> res;
      boost::split(res, thrmult, boost::is_any_of(",")); // split 1,EM15VHI_x1,EM15VHI into multiplicity,name_mult, and name
 
      std::string name_mult("");
      if(res.size() == 1) {
         name_mult=res[0]; // for thresholds without multiplicity requirement like RNDM0 or BGRP0,...
      } else {
         name_mult = res[2]+"[x"+res[0]+"]"; // build "EM15VHI[x1]"
      }
      thrNames[idx++] = std::move(name_mult);
   }
 
   // now take the logic (1&2&3&4&5&6) apart and replace the numbers with names "thr[xmult]"
   std::string def = item->definition();
   std::vector<std::string> tokens;
   // build tokens with separators ()&|! and <space>. Keeps all separators except <space> in the list of tokens
   for ( auto & tok : boost::tokenizer<boost::char_separator<char> > (item->definition(), boost::char_separator<char>(" ", "()&|!")) ) {
     int n;
     auto [ptr, ec] = std::from_chars(tok.data(), tok.data() + tok.size(), n);
     if (ec == std::errc()) {
       tokens.emplace_back(thrNames[n]);//AV: Note that this might be out of bounds
     } else {
       tokens.emplace_back(tok);
     }
   }
 
   // and reassemble the logic definition string
   std::string definition("");
   for( auto & tok : tokens ) {
      definition += tok;
   }
      
   return definition;
}

getItem()

const CTPTriggerItem * LVL1CTP::ItemMap::getItem ( const std::string & itemName ) const

inline

Definition at line 50 of file ItemMap.h.

      { return m_map.find( itemName )->second; }

itemNames()

const std::set< std::string > & LVL1CTP::ItemMap::itemNames ( ) const

inline

Definition at line 53 of file ItemMap.h.

      { return m_itemNames; }

Member Data Documentation

m_itemNames

std::set<std::string> LVL1CTP::ItemMap::m_itemNames {}

private

Definition at line 65 of file ItemMap.h.

{};

m_map

std::map< std::string, const CTPTriggerItem* > LVL1CTP::ItemMap::m_map

private

map from item name to CTPTriggerItem

Definition at line 63 of file ItemMap.h.

---

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

• ItemMap.h
• ItemMap.cxx