TrigConf::TriggerItemNode Class Reference

#include <TriggerItemNode.h>

Collaboration diagram for TrigConf::TriggerItemNode:

Public Types
enum	NodeType {   OBJ, NOT, AND, OR,   UNDEF }
typedef std::pair< L1DataDef::TriggerType, unsigned int >	InternalType_t

Public Member Functions
	TriggerItemNode (NodeType)
virtual	~TriggerItemNode ()
bool	isThreshold () const
bool	isInternalTrigger () const
void	addChild (TriggerItemNode *node)
const std::vector< TriggerItemNode * > &	children () const
void	setThresholdName (const std::string &thrname)
void	setPosition (int pos)
void	setMultiplicity (int mult)
void	setTriggerThreshold (TriggerThreshold *thr)
void	setInternalTrigger (L1DataDef::TriggerType x, unsigned int thresholdNumber)
void	setInternalTrigger (const std::string &name)
NodeType	type () const
const std::string &	thresholdName () const
int	position () const
int	multiplicity () const
const TriggerThreshold *	triggerThreshold () const
L1DataDef::TriggerType	internalTriggerType () const
unsigned int	internalTriggerNumber () const
void	getAllFinalNodes (std::vector< const TriggerItemNode * > &) const
void	getAllThresholds (std::vector< const TriggerThreshold * > &) const
void	getAllBunchGroups (std::vector< bool > &) const
void	getBunchGroupsMask (uint16_t &bgmask) const
void	getAllBunchGroups (std::vector< unsigned int > &) const
void	getAllRandomTriggers (std::vector< unsigned int > &) const
void	getAllPrescaledClockTriggers (std::vector< unsigned int > &) const
void	print (const std::string &indent="", unsigned int detail=1) const
void	writeXML (std::ostream &xmlfile, int indentLevel=0, int indentWidth=2, bool omitDelimiter=false) const
void	buildLogic (std::vector< std::string > &conditionList, std::string &logic) const
virtual std::string	__str__ () const

Static Public Member Functions
static NodeType	typeFromString (const std::string &)
static NodeType	typeFromChar (const char &c)
static std::string	typeAsString (NodeType)

Private Member Functions
std::ostream &	indent (std::ostream &o, int lvl, int size) const

Private Attributes
NodeType	m_NodeType
std::vector< TriggerItemNode * >	m_Children
std::string	m_ThresholdName
int	m_Position
int	m_Multiplicity
TriggerThreshold *	m_Threshold
InternalType_t	m_InternalTrigger

Detailed Description

Definition at line 22 of file TriggerItemNode.h.

Member Typedef Documentation

InternalType_t

typedef std::pair<L1DataDef::TriggerType,unsigned int> TrigConf::TriggerItemNode::InternalType_t

Definition at line 32 of file TriggerItemNode.h.

Member Enumeration Documentation

NodeType

enum TrigConf::TriggerItemNode::NodeType

Enumerator
OBJ
NOT
AND
OR
UNDEF

Definition at line 24 of file TriggerItemNode.h.

{OBJ, NOT, AND, OR, UNDEF};

Constructor & Destructor Documentation

TriggerItemNode()

TrigConf::TriggerItemNode::TriggerItemNode

(

NodeType

type

)

Definition at line 22 of file TriggerItemNode.cxx.

                                                      :
   m_NodeType(type), 
   m_ThresholdName(""),
   m_Position(0), 
   m_Multiplicity(0),
   m_Threshold(0), 
   m_InternalTrigger(InternalType_t(L1DataDef::UNDEF,0))
{}

~TriggerItemNode()

TrigConf::TriggerItemNode::~TriggerItemNode ( )

virtual

Definition at line 32 of file TriggerItemNode.cxx.

                                          {
   for(TriggerItemNode * node : m_Children)
      delete node;
}

Member Function Documentation

__str__()

string TriggerItemNode::__str__ ( ) const

virtual

Definition at line 336 of file TriggerItemNode.cxx.

                               {
   stringstream s;
   s << *this;
   return s.str();
}

addChild()

void TrigConf::TriggerItemNode::addChild

(

TriggerItemNode *

node

)

Definition at line 114 of file TriggerItemNode.cxx.

                                                       {
   if(type() == OBJ)
      throw std::runtime_error("TriggerItemNode::addChild: trying to add child to leaf node");
   m_Children.push_back(node);
}

buildLogic()

void TrigConf::TriggerItemNode::buildLogic	(	std::vector< std::string > &	conditionList,
		std::string &	logic
	)		const

Definition at line 237 of file TriggerItemNode.cxx.

                                                               {
 
   if (m_NodeType == OBJ) {
      std::string condition("");
      if (m_Threshold) {
         if( m_Threshold->type() != L1DataDef::rndmType() &&
             m_Threshold->type() != L1DataDef::pclkType() &&
             m_Threshold->type() != L1DataDef::bgrpType()) {
            std::string name = m_Threshold->name();
            name += "_x" + std::to_string(m_Multiplicity);
            condition += '0' + m_Multiplicity;
            condition += "," + name;
            condition += "," + m_Threshold->name();
         } else {
            condition = m_Threshold->name();
         }
      } else {
         condition = thresholdName();
      }
      uint32_t pos = conditionList.size()+1;
      if(pos>9) logic += '0'+pos/10;
      logic += '0'+pos%10;
      conditionList.push_back(condition);
   } else if (m_NodeType == AND || m_NodeType == OR) {
      logic += "(";
      bool first = true;
      for(TriggerItemNode *node : children()) {
         if(!first) { logic += (m_NodeType==AND?"&":"|"); } else { first=false; }
         node->buildLogic(conditionList, logic);
      }
      logic += ")";
   } else if (m_NodeType == NOT) {
      logic += "!";
      children()[0]->buildLogic(conditionList, logic);
   }
 
}

children()

const std::vector<TriggerItemNode*>& TrigConf::TriggerItemNode::children ( ) const

inline

Definition at line 39 of file TriggerItemNode.h.

{ return m_Children; }

getAllBunchGroups() [1/2]

void TrigConf::TriggerItemNode::getAllBunchGroups

(

std::vector< bool > &

vec

)

const

Definition at line 144 of file TriggerItemNode.cxx.

                                                                     {
   unsigned int max_bgrp = L1DataDef::typeConfig(L1DataDef::BGRP).max;
   if(vec.size() < max_bgrp) vec.resize( max_bgrp );
   if(type() == OBJ) {
      if(internalTriggerType() == L1DataDef::BGRP)
         vec[m_InternalTrigger.second] = true;
   } else {
      for(TriggerItemNode * node : m_Children)
         node->getAllBunchGroups(vec);
   }
}

getAllBunchGroups() [2/2]

void TrigConf::TriggerItemNode::getAllBunchGroups

(

std::vector< unsigned int > &

vec

)

const

Definition at line 171 of file TriggerItemNode.cxx.

                                                                             {
   if(type() == OBJ) {
      if(internalTriggerType() == L1DataDef::BGRP)
         vec.push_back(m_InternalTrigger.second);
   } else {
      for(TriggerItemNode * node : m_Children)
         node->getAllBunchGroups(vec);
   }
}

getAllFinalNodes()

void TrigConf::TriggerItemNode::getAllFinalNodes

(

std::vector< const TriggerItemNode * > &

vec

)

const

Definition at line 121 of file TriggerItemNode.cxx.

                                                                                      {
   if(type() == OBJ) {
      vec.push_back(this);
   } else {
      for(TriggerItemNode * node : m_Children)
         node->getAllFinalNodes(vec);
   }
}

getAllPrescaledClockTriggers()

void TrigConf::TriggerItemNode::getAllPrescaledClockTriggers

(

std::vector< unsigned int > &

vec

)

const

Definition at line 193 of file TriggerItemNode.cxx.

                                                                                        {
   if(type() == OBJ) {
      if(internalTriggerType() == L1DataDef::PCLK)
         vec.push_back(m_InternalTrigger.second);
   } else {
      for(TriggerItemNode * node : m_Children)
         node->getAllPrescaledClockTriggers(vec);
   }
   return;
}

getAllRandomTriggers()

void TrigConf::TriggerItemNode::getAllRandomTriggers

(

std::vector< unsigned int > &

vec

)

const

Definition at line 182 of file TriggerItemNode.cxx.

                                                                                {
   if(type() == OBJ) {
      if(internalTriggerType() == L1DataDef::RNDM)
         vec.push_back(m_InternalTrigger.second);
   } else {
      for(TriggerItemNode * node : m_Children)
         node->getAllRandomTriggers(vec);
   }
}

getAllThresholds()

void TrigConf::TriggerItemNode::getAllThresholds

(

std::vector< const TriggerThreshold * > &

vec

)

const

Definition at line 131 of file TriggerItemNode.cxx.

                                                                                       {
   if(type() == OBJ) {
      if(!isInternalTrigger()) {
         if(m_Threshold) vec.push_back(m_Threshold);
      }
   } else {
      for(TriggerItemNode * node : m_Children)
         node->getAllThresholds(vec);
   }
}

getBunchGroupsMask()

void TrigConf::TriggerItemNode::getBunchGroupsMask

(

uint16_t &

bgmask

)

const

Definition at line 158 of file TriggerItemNode.cxx.

                                                                   {
   if(type() == OBJ) {
      if(internalTriggerType() == L1DataDef::BGRP) {
         uint16_t mask(0x1);
         bgmask |= (mask << m_InternalTrigger.second);
      }
   } else {
      for(TriggerItemNode * node : m_Children)
         node->getBunchGroupsMask(bgmask);
   }
}

indent()

std::ostream & TrigConf::TriggerItemNode::indent ( std::ostream &  o, int  lvl, int  size  ) const

private

Definition at line 303 of file TriggerItemNode.cxx.

                                                                                  {
   if(lvl*size==0) return o;
   o << std::setw(lvl*size) << " ";
   return o;
}

internalTriggerNumber()

unsigned int TrigConf::TriggerItemNode::internalTriggerNumber ( ) const

inline

Definition at line 56 of file TriggerItemNode.h.

{ return m_InternalTrigger.second; }

internalTriggerType()

L1DataDef::TriggerType TrigConf::TriggerItemNode::internalTriggerType ( ) const

inline

Definition at line 55 of file TriggerItemNode.h.

{ return m_InternalTrigger.first; }

isInternalTrigger()

bool TrigConf::TriggerItemNode::isInternalTrigger

(

)

const

Definition at line 69 of file TriggerItemNode.cxx.

                                                 {
   return m_InternalTrigger.first != L1DataDef::UNDEF;
}

isThreshold()

bool TrigConf::TriggerItemNode::isThreshold

(

)

const

Definition at line 64 of file TriggerItemNode.cxx.

                                           {
   return m_InternalTrigger.first == L1DataDef::UNDEF;
}

multiplicity()

int TrigConf::TriggerItemNode::multiplicity ( ) const

inline

Definition at line 53 of file TriggerItemNode.h.

{ return m_Multiplicity; }

position()

int TrigConf::TriggerItemNode::position ( ) const

inline

Definition at line 52 of file TriggerItemNode.h.

{ return m_Position; }

print()

void TrigConf::TriggerItemNode::print	(	const std::string &	indent = "",
		unsigned int	detail = 1
	)		const

Definition at line 278 of file TriggerItemNode.cxx.

                                                                                 {
   cout << indent << "TriggerItemNode: "      << endl; 
   cout << indent << "  type        : " << (type()==OBJ?"OBJ":(type()==AND?"AND":(type()==OR?"OR":"NOT"))) << endl;
   cout << indent << "  position    : " << m_Position << endl;
 
   if (m_NodeType == OBJ) {
      cout << indent << "  multiplicity: " << m_Multiplicity << endl;
      if (m_Threshold) {
         cout << indent << "  threshold   : " << m_Threshold->name() << endl;
         m_Threshold->print(indent + indent, detail);
      } else if(isInternalTrigger()) {
         cout << indent << "  InternalTrigger: "
              << thresholdName() << endl;
      } else {
         cout << indent << thresholdName() << endl;
      }
   }
   else {
      for(TriggerItemNode * node : m_Children) {
         cout << indent << "  subnode : "               << endl;
         node->print(indent + indent);
      }
   }
}

setInternalTrigger() [1/2]

void TrigConf::TriggerItemNode::setInternalTrigger

(

const std::string &

name

)

Definition at line 96 of file TriggerItemNode.cxx.

                                                              {
 
   string::size_type pos = name.find_first_of("0123456789");
 
   L1DataDef::TriggerType tt = L1DataDef::stringAsType(name.substr(0,pos));
 
   if( ! L1DataDef::typeConfig(tt).internal ) {
      cerr << "TriggerItemNode::setInternalTrigger: type " << name << " is not an internal trigger" << endl;
      throw runtime_error("TriggerItemNode::setInternalTrigger: type is not an internal trigger");
   }
   m_InternalTrigger.first = tt;
   m_InternalTrigger.second = boost::lexical_cast<unsigned int,string>(name.substr(pos));
   m_ThresholdName = name;
   m_Threshold = 0;
}

setInternalTrigger() [2/2]

void TrigConf::TriggerItemNode::setInternalTrigger	(	L1DataDef::TriggerType	x,
		unsigned int	thresholdNumber
	)

Definition at line 87 of file TriggerItemNode.cxx.

                                                                            {
   m_InternalTrigger.first = x;
   m_InternalTrigger.second = thresholdNumber;
   m_ThresholdName = L1DataDef::typeConfig(x).name + boost::lexical_cast<string,unsigned int>(thresholdNumber);
   m_Threshold = 0;
}

setMultiplicity()

void TrigConf::TriggerItemNode::setMultiplicity ( int  mult )

inline

Definition at line 44 of file TriggerItemNode.h.

{ m_Multiplicity = mult; }

setPosition()

void TrigConf::TriggerItemNode::setPosition ( int  pos )

inline

Definition at line 43 of file TriggerItemNode.h.

{ m_Position = pos; }

setThresholdName()

void TrigConf::TriggerItemNode::setThresholdName ( const std::string &  thrname )

inline

Definition at line 42 of file TriggerItemNode.h.

{ m_ThresholdName = thrname; }

setTriggerThreshold()

void TrigConf::TriggerItemNode::setTriggerThreshold

(

TriggerThreshold *

thr

)

Definition at line 74 of file TriggerItemNode.cxx.

                                                                   {
   if(thr->isInternal()) {
      // from the database internal triggers are also loaded as TriggerThresholds
      setInternalTrigger(thr->name());
   } else {
      m_InternalTrigger.first = L1DataDef::UNDEF;
      m_InternalTrigger.second = 0;
   }
   m_Threshold = thr;
   m_ThresholdName = thr->name();
}

thresholdName()

const std::string& TrigConf::TriggerItemNode::thresholdName ( ) const

inline

Definition at line 51 of file TriggerItemNode.h.

{ return m_ThresholdName; }

triggerThreshold()

const TriggerThreshold* TrigConf::TriggerItemNode::triggerThreshold ( ) const

inline

Definition at line 54 of file TriggerItemNode.h.

{ return m_Threshold; }

type()

NodeType TrigConf::TriggerItemNode::type ( ) const

inline

Definition at line 50 of file TriggerItemNode.h.

{ return m_NodeType; };

typeAsString()

std::string TrigConf::TriggerItemNode::typeAsString ( NodeType  type )

static

Definition at line 57 of file TriggerItemNode.cxx.

                                                   {
   static const std::string typelabel[] = {"OBJ", "NOT", "AND", "OR", "UNDEF"};
   return typelabel[type];
}

typeFromChar()

TriggerItemNode::NodeType TriggerItemNode::typeFromChar ( const char &  c )

static

Definition at line 49 of file TriggerItemNode.cxx.

                                           {
   if(c=='&') return TriggerItemNode::AND;
   if(c=='|') return TriggerItemNode::OR;
   if(c=='!') return TriggerItemNode::NOT;
   return TriggerItemNode::UNDEF;
}

typeFromString()

TrigConf::TriggerItemNode::NodeType TrigConf::TriggerItemNode::typeFromString ( const std::string &  type )

static

Definition at line 38 of file TriggerItemNode.cxx.

                                                             {
   if(type=="AND") return TriggerItemNode::AND;
   if(type=="OR")  return TriggerItemNode::OR;
   if(type=="NOT") return TriggerItemNode::NOT;
   if(type=="OBJ") return TriggerItemNode::OBJ;
   if(type=="TriggerCondition") return TriggerItemNode::OBJ;
   if(type=="InternalTrigger") return TriggerItemNode::OBJ;
   return TriggerItemNode::UNDEF;
}

writeXML()

void TrigConf::TriggerItemNode::writeXML	(	std::ostream &	xmlfile,
		int	indentLevel = 0,
		int	indentWidth = 2,
		bool	omitDelimiter = false
	)		const

Definition at line 205 of file TriggerItemNode.cxx.

                                                                                                      {
   if (m_NodeType == OBJ) {
 
      if(isInternalTrigger()) {
         indent(xmlfile, indentLevel, indentWidth)
            << "<InternalTrigger name=\"" << m_ThresholdName << "\"/>" << endl;
      } else {
         indent(xmlfile, indentLevel, indentWidth)
            << "<TriggerCondition multi=\"" << m_Multiplicity 
            << "\" name=\"" << m_ThresholdName << "_x" << m_Multiplicity 
            << "\" triggerthreshold=\"" << m_ThresholdName << "\"/>" << endl;
      }
      
   } else if (m_NodeType == AND || m_NodeType == OR) {
 
      std::string logic = (m_NodeType==AND?"AND":"OR");
      indent(xmlfile, indentLevel, indentWidth) << "<" << logic << ">" << endl;
      for(TriggerItemNode *node : children())
         node->writeXML(xmlfile, indentLevel+1, indentWidth);
      indent(xmlfile, indentLevel, indentWidth) << "</"<<logic<<">" << endl;
      
   } else if (m_NodeType == NOT) {
 
      indent(xmlfile, indentLevel, indentWidth) << "<NOT>" << endl;
      children()[0]->writeXML(xmlfile, indentLevel+1, indentWidth);
      indent(xmlfile, indentLevel, indentWidth) << "</NOT>" << endl;
 
   }
}

Member Data Documentation

m_Children

std::vector<TriggerItemNode*> TrigConf::TriggerItemNode::m_Children

private

Definition at line 78 of file TriggerItemNode.h.

m_InternalTrigger

InternalType_t TrigConf::TriggerItemNode::m_InternalTrigger

private

Definition at line 87 of file TriggerItemNode.h.

m_Multiplicity

int TrigConf::TriggerItemNode::m_Multiplicity

private

Definition at line 83 of file TriggerItemNode.h.

m_NodeType

NodeType TrigConf::TriggerItemNode::m_NodeType

private

Definition at line 75 of file TriggerItemNode.h.

m_Position

int TrigConf::TriggerItemNode::m_Position

private

Definition at line 82 of file TriggerItemNode.h.

m_Threshold

TriggerThreshold* TrigConf::TriggerItemNode::m_Threshold

private

Definition at line 84 of file TriggerItemNode.h.

m_ThresholdName

std::string TrigConf::TriggerItemNode::m_ThresholdName

private

Definition at line 81 of file TriggerItemNode.h.

---

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

• TriggerItemNode.h
• TriggerItemNode.cxx