TCS::TopoSteering Class Reference

#include <TopoSteering.h>

Inheritance diagram for TCS::TopoSteering:

Collaboration diagram for TCS::TopoSteering:

Public Member Functions
	TopoSteering ()
const TopoSteeringStructure &	structure () const
TopoInputEvent &	inputEvent ()
const TopoCoreSimResult &	simulationResult () const
StatusCode setupFromConfiguration	ATLAS_NOT_THREAD_SAFE (const TrigConf::L1Menu &l1menu)
void	setUseBitwise (bool useBitwise)
StatusCode	initializeAlgorithms ()
StatusCode	executeEvent ()
StatusCode	executeTrigger (const std::string &triggerName)
StatusCode	reset ()
void	printDebugInfo ()
const TCS::ParameterSpace &	parameters (const std::string &algName) const
const std::vector< TCS::Connector * > &	connectors () const
void	printConfiguration (std::ostream &o) const
void	setMsgLevel (TrigConf::MSGTC::Level lvl)
void	setAlgMsgLevel (TrigConf::MSGTC::Level lvl)
void	setLegacyMode (bool isLegacyTopo)
StatusCode	setHistSvc (std::shared_ptr< IL1TopoHistSvc > histSvc)
	enables the histogramming service More...
StatusCode	saveHist ()
void	setHardwareBits (const std::bitset< numberOfL1TopoBits > &triggerBits, const std::bitset< numberOfL1TopoBits > &ovrflowBits)
	cache the decision/overflow bits from hardware These bits are propagated to the algorithms with propagateHardwareBitsToAlgos. More...
void	propagateHardwareBitsToAlgos ()
	propagate the bits from hardware to each simulated decision algo. More...
void	setOutputAlgosFillBasedOnHardware (const bool &value)
	tell output algos to fill accept/reject histos based on hdw decision. More...
void	setOutputAlgosSkipHistograms (const bool &value)
	skip filling the histos More...
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...

Static Public Attributes
static const unsigned int	numberOfL1TopoBits = 128

Private Member Functions
StatusCode	executeConnector (TCS::Connector *conn)
StatusCode	executeInputConnector (TCS::InputConnector *conn)
StatusCode	executeSortingConnector (TCS::SortingConnector *conn)
StatusCode	executeDecisionConnector (TCS::DecisionConnector *conn)
StatusCode	executeCountingConnector (TCS::CountingConnector *conn)
StatusCode	executeAlgorithm (ConfigurableAlg *alg, Connector *connector)
StatusCode	executeSortingAlgorithm (SortingAlg *alg, TCS::InputConnector *inputConnector, TOBArray *&output)
StatusCode	executeDecisionAlgorithm (TCS::DecisionAlg *alg, const std::vector< Connector * > &inputConnectors, const std::vector< TCS::TOBArray * > &output, Decision &decsion)
StatusCode	executeCountingAlgorithm (TCS::CountingAlg *alg, TCS::InputConnector *inputConnector, Count &count)

Private Attributes
bool	m_useBitwise {false}
bool	m_isLegacyTopo {false}
TopoInputEvent	m_inputEvent
TopoCoreSimResult	m_simulationResult
TopoSteeringStructure	m_structure
unsigned int	m_evtCounter {1}
TrigConf::MSGTC::Level	m_AlgMsgLvl { TrigConf::MSGTC::WARNING }
std::shared_ptr< IL1TopoHistSvc >	m_histSvc
std::bitset< numberOfL1TopoBits >	m_triggerHdwBits
std::bitset< numberOfL1TopoBits >	m_ovrflowHdwBits
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

Definition at line 46 of file TopoSteering.h.

Constructor & Destructor Documentation

TopoSteering()

TopoSteering::TopoSteering

(

)

Definition at line 37 of file TopoSteering.cxx.

                           :
   TrigConfMessaging("TopoSteering")
{}

Member Function Documentation

ATLAS_NOT_THREAD_SAFE()

StatusCode setupFromConfiguration TCS::TopoSteering::ATLAS_NOT_THREAD_SAFE

(

const TrigConf::L1Menu &

l1menu

)

connectors()

const std::vector<TCS::Connector*>& TCS::TopoSteering::connectors ( ) const

inline

Definition at line 83 of file TopoSteering.h.

{ return structure().connectors(); } //added

executeAlgorithm()

StatusCode TCS::TopoSteering::executeAlgorithm ( ConfigurableAlg *  alg, Connector *  connector  )

private

executeConnector()

TCS::StatusCode TopoSteering::executeConnector ( TCS::Connector *  conn )

private

Definition at line 189 of file TopoSteering.cxx.

                                                 {
 
   if (conn == NULL) {
     return TCS::StatusCode::FAILURE;
   }
 
   // caching
   if(conn->isExecuted())
      return conn->executionStatusCode();
  
   TCS::StatusCode sc(TCS::StatusCode::SUCCESS);
 
   if(conn->isInputConnector()) {
      //TRG_MSG_DEBUG("  ... executing input connector '" << conn->name() << "'");
      sc = executeInputConnector(dynamic_cast<InputConnector*>(conn));
   } else if(conn->isSortingConnector()) {
      //TRG_MSG_DEBUG("  ... executing sorting connector '" << conn->name() << "'");
      sc = executeSortingConnector(dynamic_cast<SortingConnector*>(conn));
   } else if(conn->isDecisionConnector()){
      //TRG_MSG_DEBUG("  ... executing decision connector '" << conn->name() << "'");
      sc = executeDecisionConnector(dynamic_cast<DecisionConnector*>(conn));
   } else if(conn->isCountingConnector()){
      sc = executeCountingConnector(dynamic_cast<CountingConnector*>(conn));
   }
 
   conn->setIsExecuted(true);
   conn->setExecutionStatusCode(sc);
  
   return sc;
}

executeCountingAlgorithm()

TCS::StatusCode TopoSteering::executeCountingAlgorithm ( TCS::CountingAlg *  alg, TCS::InputConnector *  inputConnector, TCS::Count &  count  )

private

Definition at line 427 of file TopoSteering.cxx.

                                                        {
 
   TRG_MSG_DEBUG("  ... executing multiplicity alg '" <<alg->fullname() << "'");
 
   const InputTOBArray * input = inputConnector->outputData();
 
   alg->process( *input, count);
 
   return TCS::StatusCode::SUCCESS;
}

executeCountingConnector()

TCS::StatusCode TopoSteering::executeCountingConnector ( TCS::CountingConnector *  conn )

private

Definition at line 336 of file TopoSteering.cxx.

                                                                 {
 
   if (conn == NULL) {
      return TCS::StatusCode::FAILURE;
   }
 
   TCS::StatusCode sc = TCS::StatusCode::SUCCESS;
 
   // execute all the prior connectors
   for( TCS::Connector* inputConn: conn->inputConnectors() ){
      sc &= executeConnector(inputConn);
      conn->toggleInputOverflow(conn->hasInputOverflow() ||
                                inputConn->hasInputOverflow());
   }
 
   // execute 
   TCS::CountingAlg* alg = conn->countingAlgorithm();
   
   // Execute algorithm with no output data - not needed for now
   sc &= executeCountingAlgorithm(alg, conn->inputConnector(), conn->m_count);
 
   conn->setIsExecuted(true);
   conn->setExecutionStatusCode(sc);
 
   // TO-DO overflows in multiplicity algorithms
 
   return sc;
}

executeDecisionAlgorithm()

TCS::StatusCode TopoSteering::executeDecisionAlgorithm ( TCS::DecisionAlg *  alg, const std::vector< Connector * > &  inputConnectors, const std::vector< TCS::TOBArray * > &  output, TCS::Decision &  decision  )

private

Definition at line 386 of file TopoSteering.cxx.

                                                               {
 
    TRG_MSG_DEBUG("  ... executing decision alg '" << alg->fullname() << "'"
                  <<(m_useBitwise?" (bitwise)":""));
 
   if(inputConnectors.size()<1) {
      TCS_EXCEPTION("L1Topo Steering: Decision algorithm expects at least 1 input array but got 0");
   }
 
   std::vector<TCS::TOBArray const *> input;  // needs to be optimized
   for(const Connector* inConn: inputConnectors)
   {
      if (inConn == nullptr) continue;
      const SortingConnector * sc = dynamic_cast<const SortingConnector *>(inConn);
      if (sc==nullptr) {
     TCS_EXCEPTION("L1Topo Steering: Decision algorithm " << alg->name() << " could not cast as SortingConnector* the input connector " << inConn->name());
      }
      else {
        const TOBArray * tobA = dynamic_cast<const TOBArray *>( sc->outputData());
        if(tobA==nullptr) {
          TCS_EXCEPTION("L1Topo Steering: Decision algorithm " << alg->name() << " expects TOBArray(s) as input, but did not get it from connector " << (inConn ? inConn->name() : ""));
        }
        input.push_back( tobA );
      }
   }
 
   alg->reset();
 
 
   if(m_useBitwise) alg->processBitCorrect( input, output, decision);   
   else alg->process( input, output, decision );
   //TRG_MSG_ALWAYS("[XS1234sz]L1Topo Steering alg " << alg->name() << " has decision " << decision.decision());
     
   return TCS::StatusCode::SUCCESS;
}

executeDecisionConnector()

TCS::StatusCode TopoSteering::executeDecisionConnector ( TCS::DecisionConnector *  conn )

private

Definition at line 278 of file TopoSteering.cxx.

                                                                 {
 
   if (conn == NULL) {
     return TCS::StatusCode::FAILURE;
   }
 
   TCS::StatusCode sc = TCS::StatusCode::SUCCESS;
  
   // execute all the prior connectors
   for( TCS::Connector* inputConn: conn->inputConnectors() ){
      sc &= executeConnector(inputConn);
      conn->toggleInputOverflow(conn->hasInputOverflow() ||
                                inputConn->hasInputOverflow());
      conn->toggleAmbiguity(conn->hasAmbiguity() ||
                                inputConn->hasAmbiguity());
   }
   // execute
   TCS::DecisionAlg* alg = conn->decisionAlgorithm();
 
   // TRG_MSG_DEBUG("  ... executing decision connector '" << conn->name() << "' with " << conn->triggers().size() << " active trigger lines. The algorithm has " << alg->numberOutputBits() << " output bits.");
 
   // the output is one TOBArray per output line
   vector<TOBArray *> output( alg->numberOutputBits() );
 
   for(unsigned int i=0; i<alg->numberOutputBits(); ++i) {
      output[i] = new TOBArray(conn->triggers()[i].name());
      output[i]->setAmbiguityFlag(conn->hasAmbiguity());
   }
 
   sc &= executeDecisionAlgorithm(alg, conn->inputConnectors(), output, conn->m_decision);
 
   TRG_MSG_DEBUG("  ... executing decision connector '" << conn->name() << "' -> attaching output data:");
   for(TOBArray const * outarr : output) {
      TRG_MSG_DEBUG("           data '" << outarr->name() << "' of size " << outarr->size());
      conn->toggleAmbiguity(outarr->ambiguityFlag());
   }
 
   conn->attachOutputData(output);
 
   conn->setIsExecuted(true);
   conn->setExecutionStatusCode(sc);
   bool sortOverflow = false;
   for(TCS::Connector* inputConnector: conn->inputConnectors()) {
       // TODO DG-2017-04-18 the sort overflow (>10 TOBs) in the SortAlg is not implemented yet
       if(inputConnector->isSortingConnector()) {
         if (auto sortConn = dynamic_cast<SortingConnector*>(inputConnector)) {
           sortOverflow = sortConn->sortingAlgorithm()->overflow();
           if (sortOverflow) break;
         }
       }
   }
   conn->m_decision.setOverflow(conn->hasInputOverflow() || sortOverflow);
   conn->m_decision.setAmbiguity(conn->hasAmbiguity());
   return sc;
}

executeEvent()

TCS::StatusCode TopoSteering::executeEvent

(

)

Definition at line 132 of file TopoSteering.cxx.

                           {
 
 
   TRG_MSG_INFO("L1 TopoSteering: start executing event " << m_evtCounter << "-----------------------------------");
 
 
   if( ! structure().isConfigured() ) {
      TRG_MSG_INFO("L1Topo Steering has not been configured, can't run");
      TCS_EXCEPTION("L1Topo Steering has not been configured, can't run");
   }
 
   inputEvent().print();
 
   // execute all connectors
   TCS::StatusCode sc = TCS::StatusCode::SUCCESS;
   TRG_MSG_INFO("Going to execute " << m_structure.outputConnectors().size() << " decision connectors and " << m_structure.countConnectors().size() << " multiplicity connectors.");
   for(auto outConn: m_structure.outputConnectors()) {
      TRG_MSG_INFO("executing trigger line " << outConn.first);
      sc |= executeConnector(outConn.second);
      TRG_MSG_INFO("result of trigger line " << outConn.first << " : " << outConn.second->decision().decision());
   }   
 
   for(auto multConn: m_structure.countConnectors()) {
      TRG_MSG_INFO("executing trigger line " << multConn.first);
      sc |= executeConnector(multConn.second);
   } 
 
   sc |= m_simulationResult.collectResult(); 
 
   m_simulationResult.globalOutput().print();
 
   TRG_MSG_INFO("finished executing event " << m_evtCounter++);
   return TCS::StatusCode::SUCCESS;
}

executeInputConnector()

TCS::StatusCode TopoSteering::executeInputConnector ( TCS::InputConnector *  conn )

private

Definition at line 223 of file TopoSteering.cxx.

                                                           {
 
   if (conn == NULL) {
     return TCS::StatusCode::FAILURE;
   }
 
   TCS::StatusCode sc(TCS::StatusCode::SUCCESS);
 
   // attaching data from inputEvent to input connector, depending on the configured input type
 
   const InputTOBArray * inputData = inputEvent().inputTOBs( conn->inputTOBType() );
   const bool hasInputOverflow = inputEvent().hasInputOverflow(conn->inputTOBType());
   conn->attachOutputData( inputData );
   conn->toggleInputOverflow(hasInputOverflow);
 
   TRG_MSG_DEBUG("  ... executing input connector '" << conn->name() << "' -> attaching '" << inputData->name() << "' of size " << inputData->size());
 
   return sc;
}

executeSortingAlgorithm()

TCS::StatusCode TopoSteering::executeSortingAlgorithm ( TCS::SortingAlg *  alg, TCS::InputConnector *  inputConnector, TCS::TOBArray *&  sortedOutput  )

private

Definition at line 368 of file TopoSteering.cxx.

                                                                    {
                                           
    TRG_MSG_DEBUG("  ... executing sorting alg '" << alg->fullname() << "'"
                  <<(m_useBitwise?" (bitwise)":""));
 
   const InputTOBArray * input = inputConnector->outputData();
 
   if(m_useBitwise) alg->sortBitCorrect(*input, *sortedOutput);
   else alg->sort(*input, *sortedOutput);
 
   return TCS::StatusCode::SUCCESS;
}

executeSortingConnector()

TCS::StatusCode TopoSteering::executeSortingConnector ( TCS::SortingConnector *  conn )

private

Definition at line 246 of file TopoSteering.cxx.

                                                               {
 
   if (conn == NULL) {
     return StatusCode::FAILURE;
   }
 
   TCS::StatusCode sc = TCS::StatusCode::SUCCESS;
  
   // execute all the prior connectors
   for( TCS::Connector* inputConn: conn->inputConnectors() ){
      sc &= executeConnector(inputConn);
      conn->toggleInputOverflow(conn->hasInputOverflow() ||
                                inputConn->hasInputOverflow());
   }
   TCS::SortingAlg* alg = conn->sortingAlgorithm();
 
   TOBArray * sortedOutput = new TOBArray(conn->outputName());
 
   sc &= executeSortingAlgorithm(alg, conn->inputConnector(), sortedOutput);
 
   conn->toggleAmbiguity(sortedOutput->ambiguityFlag());
 
   TRG_MSG_DEBUG("  ... executing sorting connector '" << conn->name() << "' -> attaching '" << sortedOutput->name() << "' of size " << sortedOutput->size());
 
   conn->attachOutputData(sortedOutput);
 
   return sc;
}

executeTrigger()

TCS::StatusCode TopoSteering::executeTrigger

(

const std::string &

triggerName

)

Definition at line 170 of file TopoSteering.cxx.

                                                       {
   if( ! structure().isConfigured() )
      TCS_EXCEPTION("TopoSteering has not been configured, can't run");
   
   DecisionConnector * outConn = m_structure.outputConnector(TrigName);
 
   TCS::StatusCode sc = executeConnector(outConn);
 
   m_simulationResult.collectResult(outConn);
 
   return sc;
}

initializeAlgorithms()

TCS::StatusCode TopoSteering::initializeAlgorithms

(

)

Definition at line 89 of file TopoSteering.cxx.

                                   {
   TRG_MSG_INFO("initializing algorithms");
   if( ! structure().isConfigured() ) {
      TCS_EXCEPTION("L1Topo Steering has not been configured, can't run")
   }
 
   for(auto conn: m_structure.connectors()) {
      TCS::ConfigurableAlg * alg = conn->algorithm();
      if(alg) {
         TRG_MSG_INFO("initializing algorithm " << alg->name());
         if(m_histSvc) {
            alg->setL1TopoHistSvc(m_histSvc);
         }
     alg->setLegacyMode(m_isLegacyTopo);
         alg->initialize();
      }
 
   }
 
   return TCS::StatusCode::SUCCESS;
}

inputEvent()

TopoInputEvent& TCS::TopoSteering::inputEvent ( )

inline

Definition at line 54 of file TopoSteering.h.

{ return m_inputEvent; }

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

parameters()

const TCS::ParameterSpace& TCS::TopoSteering::parameters

(

const std::string &

algName

)

const

printConfiguration()

void TopoSteering::printConfiguration

(

std::ostream &

o

)

const

Definition at line 456 of file TopoSteering.cxx.

                                                     {
   o << "==========================" << endl
     << "TopoSteering configuration" << endl
     << "--------------------------" << endl;
   structure().print(o);
   o << "==========================" << endl;
}

printDebugInfo()

void TopoSteering::printDebugInfo

(

)

Definition at line 442 of file TopoSteering.cxx.

                             {
   TRG_MSG_INFO("Number of ClusterTOB  : " << ClusterTOB::heap().size());
   TRG_MSG_INFO("Number of eEmTOB      : " << eEmTOB::heap().size());
   TRG_MSG_INFO("Number of JetTOB      : " << JetTOB::heap().size());
   TRG_MSG_INFO("Number of jJetTOB     : " << jJetTOB::heap().size());
   TRG_MSG_INFO("Number of GenericTOB  : " << GenericTOB::heap().size());
   TRG_MSG_INFO("Number of CompositeTOB: " << CompositeTOB::heap().size());
   TRG_MSG_INFO("Number of MuonTOB     : " << MuonTOB::heap().size());
   TRG_MSG_INFO("Number of LateMuonTOB : " << LateMuonTOB::heap().size());
}

propagateHardwareBitsToAlgos()

void TopoSteering::propagateHardwareBitsToAlgos

(

)

propagate the bits from hardware to each simulated decision algo.

They will then be used to fill the accept/reject monitoring histograms.

Definition at line 498 of file TopoSteering.cxx.

{
   for(auto connector : m_structure.outputConnectors()) {
       const string &connectorName = connector.first;
       TCS::DecisionConnector *outCon = connector.second;
        outCon->decisionAlgorithm()->resetHardwareBits();
        unsigned int pos = 0; // for multi-output algorithms pos is the output index
        for(const TrigConf::TriggerLine &trigger : outCon->triggers()){
        unsigned int bitNumber = trigger.flatindex();
            outCon->decisionAlgorithm()->setHardwareBits(pos,
                                                         m_triggerHdwBits[bitNumber],
                                                         m_ovrflowHdwBits[bitNumber]);
            pos++;
            TRG_MSG_DEBUG("propagating hardware bit (dec/ovr) "<<bitNumber
                          <<" to algo "<<connectorName<<"["<<pos<<"]"
                          <<" "<<m_triggerHdwBits[bitNumber]<<" /"
                          <<" "<<m_ovrflowHdwBits[bitNumber]);
 
        }
   }
}

reset()

TCS::StatusCode TopoSteering::reset

(

)

Definition at line 54 of file TopoSteering.cxx.

                    {
 
   ClusterTOB::clearHeap();
   eEmTOB::clearHeap();
   eTauTOB::clearHeap();
   jEmTOB::clearHeap();
   jTauTOB::clearHeap();
   cTauTOB::clearHeap();
   JetTOB::clearHeap();
   jJetTOB::clearHeap();
   jLJetTOB::clearHeap();
   gJetTOB::clearHeap();
   gLJetTOB::clearHeap();
   MuonTOB::clearHeap();
   LateMuonTOB::clearHeap();
   MuonNextBCTOB::clearHeap();
   MetTOB::clearHeap();
   jXETOB::clearHeap();
   jTETOB::clearHeap();
   gXETOB::clearHeap();
   gTETOB::clearHeap();
   GenericTOB::clearHeap();
   CompositeTOB::clearHeap();
 
   inputEvent().clear();
 
   m_structure.reset();
 
   m_simulationResult.reset();
   
   return TCS::StatusCode::SUCCESS;
}

saveHist()

TCS::StatusCode TopoSteering::saveHist

(

)

Definition at line 121 of file TopoSteering.cxx.

                       {
   if(m_histSvc) {
      m_histSvc->save();
   } else {
      TRG_MSG_WARNING("saveHist called without an L1TopoHistSvc being available");
   }
   return TCS::StatusCode::SUCCESS;
}

setAlgMsgLevel()

void TopoSteering::setAlgMsgLevel

(

TrigConf::MSGTC::Level

lvl

)

Definition at line 479 of file TopoSteering.cxx.

                                                     {
 
   m_AlgMsgLvl = lvl;
 
   for( Connector * conn : m_structure.connectors() ) {
      const ConfigurableAlg * alg = conn->algorithm();
      if(alg==nullptr) continue;
      alg->msg().setLevel(lvl);
   }
}

setHardwareBits()

void TopoSteering::setHardwareBits	(	const std::bitset< numberOfL1TopoBits > &	triggerBits,
		const std::bitset< numberOfL1TopoBits > &	ovrflowBits
	)

cache the decision/overflow bits from hardware These bits are propagated to the algorithms with propagateHardwareBitsToAlgos.

Definition at line 491 of file TopoSteering.cxx.

{
    m_triggerHdwBits = triggerBits;
    m_ovrflowHdwBits = ovrflowBits;
}

setHistSvc()

TCS::StatusCode TopoSteering::setHistSvc

(

std::shared_ptr< IL1TopoHistSvc >

histSvc

)

enables the histogramming service

Definition at line 113 of file TopoSteering.cxx.

                                                              {
   TRG_MSG_INFO("setting L1TopoHistSvc ");
   m_histSvc = histSvc;
   return TCS::StatusCode::SUCCESS;
}

setLegacyMode()

void TCS::TopoSteering::setLegacyMode ( bool  isLegacyTopo )

inline

Definition at line 91 of file TopoSteering.h.

{m_isLegacyTopo=isLegacyTopo;}

setMsgLevel()

void TopoSteering::setMsgLevel

(

TrigConf::MSGTC::Level

lvl

)

Definition at line 467 of file TopoSteering.cxx.

                                                  {
 
   //const char* levelNames[TrigConf::MSGTC::NUM_LEVELS] = {"NIL","VERBOSE","DEBUG","INFO",
   //                                                       "WARNING","ERROR","FATAL","ALWAYS"};
   msg().setLevel( lvl );
 
   inputEvent().msg().setLevel(lvl);
 
   m_simulationResult.setMsgLevel( lvl );
}

setOutputAlgosFillBasedOnHardware()

void TopoSteering::setOutputAlgosFillBasedOnHardware

(

const bool &

value

)

tell output algos to fill accept/reject histos based on hdw decision.

In this case you will need to call setHardwareBits + propagateHardwareBitsToAlgos at each event.

Definition at line 520 of file TopoSteering.cxx.

{
   for(auto connector : m_structure.outputConnectors()) {
       const string &connectorName = connector.first;
       TCS::DecisionConnector *outCon = connector.second;
       if(outCon) {
           outCon->decisionAlgorithm()->setFillHistosBasedOnHardware(value);
       } else {
           TRG_MSG_DEBUG("skipping invalid DecisionConnector '"<<connectorName<<"'");
       }
   }
}

setOutputAlgosSkipHistograms()

void TopoSteering::setOutputAlgosSkipHistograms

(

const bool &

value

)

skip filling the histos

When filling the histograms based on the hdw decision we want to skip filling them if we didn't fetch the hdw bits from the ROS. The flag is then toggled on/off depending on the prescaler.

Definition at line 533 of file TopoSteering.cxx.

{
   for(auto connector : m_structure.outputConnectors()) {
       const string &connectorName = connector.first;
       TCS::DecisionConnector *outCon = connector.second;
       if(outCon) {
           outCon->decisionAlgorithm()->setSkipHistos(value);
       } else {
           TRG_MSG_DEBUG("skipping invalid DecisionConnector '"<<connectorName<<"'");
       }
   }
}

setUseBitwise()

void TCS::TopoSteering::setUseBitwise ( bool  useBitwise )

inline

Definition at line 63 of file TopoSteering.h.

{ m_useBitwise = useBitwise; }

simulationResult()

const TopoCoreSimResult& TCS::TopoSteering::simulationResult ( ) const

inline

Definition at line 56 of file TopoSteering.h.

{ return m_simulationResult; }

structure()

const TopoSteeringStructure& TCS::TopoSteering::structure ( ) const

inline

Definition at line 52 of file TopoSteering.h.

{ return m_structure; }

Member Data Documentation

m_AlgMsgLvl

TrigConf::MSGTC::Level TCS::TopoSteering::m_AlgMsgLvl { TrigConf::MSGTC::WARNING }

private

Definition at line 163 of file TopoSteering.h.

m_evtCounter

unsigned int TCS::TopoSteering::m_evtCounter {1}

private

Definition at line 161 of file TopoSteering.h.

m_histSvc

std::shared_ptr<IL1TopoHistSvc> TCS::TopoSteering::m_histSvc

private

Definition at line 165 of file TopoSteering.h.

m_inputEvent

TopoInputEvent TCS::TopoSteering::m_inputEvent

private

Definition at line 155 of file TopoSteering.h.

m_isLegacyTopo

bool TCS::TopoSteering::m_isLegacyTopo {false}

private

Definition at line 153 of file TopoSteering.h.

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_ovrflowHdwBits

std::bitset<numberOfL1TopoBits> TCS::TopoSteering::m_ovrflowHdwBits

private

Definition at line 168 of file TopoSteering.h.

m_simulationResult

TopoCoreSimResult TCS::TopoSteering::m_simulationResult

private

Definition at line 157 of file TopoSteering.h.

m_structure

TopoSteeringStructure TCS::TopoSteering::m_structure

private

Definition at line 159 of file TopoSteering.h.

m_triggerHdwBits

std::bitset<numberOfL1TopoBits> TCS::TopoSteering::m_triggerHdwBits

private

Definition at line 167 of file TopoSteering.h.

m_useBitwise

bool TCS::TopoSteering::m_useBitwise {false}

private

Definition at line 151 of file TopoSteering.h.

numberOfL1TopoBits

const unsigned int TCS::TopoSteering::numberOfL1TopoBits = 128

static

Definition at line 100 of file TopoSteering.h.

---

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

• TopoSteering.h
• TopoSteering.cxx