#include <TTUEmulator.h>

Classes
class	TriggerResponse

Public Member Functions
void	clearTriggerResponse ()

void	emulate ()

bool	initialise ()

int	line () const

int	mode () const

void	printinfo () const

void	processTtu (RPCInputSignal *)

void	processTtu (RPCInputSignal *, int)

void	SetLineId (int)

void	setmode (int mode)

void	setSpecifications (const TTUBoardSpecs , const RBCBoardSpecs )

void	setSpecs ()

	TTUEmulator ()
	Standard constructor. More...

	TTUEmulator (int, int)

	TTUEmulator (int, const char , const char , int)

	TTUEmulator (int, const char , const char , const char *, int)

Public Attributes
int	m_maxWheels

std::bitset< 2 >	m_trigger

std::map< int, std::bitset< 2 > >	m_triggerBx

std::vector< TriggerResponse >	m_triggerBxVec

std::array< RPCWheel, 2 >	m_Wheels

Private Attributes
int	m_bx

bool	m_debug

int	m_id

int	m_line

std::string	m_logtype

int	m_mode

std::unique_ptr< TTUConfiguration >	m_ttuconf

std::array< TTUInput, 2 >	m_ttuin

std::array< int, 6 >	m_wheelIds

Detailed Description

This class performs the following tasks [ref 2]:

find a single or multiple muon tracks
find length of each track
produce a wheel level trigger

The default algorithm is implemented is TrackingAlg [ref 2].

ref 2: "A configurable Tracking Algorithm to detect cosmic muon tracks for the CMS-RPC based Technical Trigger", R.T.Rajan et al

Author: Andres Osorio

email: aosor.nosp@m.io@u.nosp@m.niand.nosp@m.es.e.nosp@m.du.co

Date: 2008-10-15

Definition at line 39 of file TTUEmulator.h.

Constructor & Destructor Documentation

TTUEmulator::TTUEmulator ( )

inline

Standard constructor.

Definition at line 42 of file TTUEmulator.h.

References clearTriggerResponse(), emulate(), initialise(), printinfo(), processTtu(), and setSpecifications().

42 {};

TTUEmulator::TTUEmulator	(	int	id,
		int	mxw
	)

Definition at line 24 of file TTUEmulator.cc.

References dqmdumpme::k, m_debug, m_id, m_line, m_maxWheels, m_mode, and m_Wheels.

                                         : m_maxWheels{mxw}, m_id{id}, m_mode{1}, m_line{1}, m_debug{false} {
   for (int k = 0; k < m_maxWheels; ++k)
     m_Wheels[k].setProperties(wheelIds[(id * 2) + (k - 2)]);
 }

TTUEmulator::TTUEmulator	(	int	id,
		const char *	rbclogic_type,
		const char *	ttulogic_type,
		int	mxw
	)

Definition at line 29 of file TTUEmulator.cc.

References dqmdumpme::k, m_debug, m_id, m_line, m_maxWheels, m_mode, m_ttuconf, and m_Wheels.

     : m_maxWheels{mxw},
       m_id{id},
       m_mode{1},
       m_line{1},
       m_ttuconf{std::make_unique<TTUBasicConfig>(ttulogic_type)},
       m_debug{false} {
   for (int k = 0; k < m_maxWheels; ++k)
     m_Wheels[k].setProperties(wheelIds[(id * 2) + (k - 2)], rbclogic_type);
 }

TTUEmulator::TTUEmulator	(	int	id,
		const char *	f_name,
		const char *	rbclogic_type,
		const char *	ttulogic_type,
		int	mxw
	)

Definition at line 40 of file TTUEmulator.cc.

References dqmdumpme::k, m_debug, m_id, m_line, m_maxWheels, m_mode, m_ttuconf, and m_Wheels.

     : m_maxWheels{mxw},
       m_id{id},
       m_mode{1},
       m_line{1},
       m_ttuconf{std::make_unique<TTUBasicConfig>(ttulogic_type)},
       m_debug{false} {
   for (int k = 0; k < m_maxWheels; ++k)
     m_Wheels[k].setProperties(wheelIds[(id * 2) + (k - 2)], f_name, rbclogic_type);
 }

Member Function Documentation

void TTUEmulator::clearTriggerResponse ( )

Definition at line 228 of file TTUEmulator.cc.

References m_triggerBxVec.

Referenced by TTUEmulator().

228 { m_triggerBxVec.clear(); }

TTUEmulator::m_triggerBxVec

std::vector< TriggerResponse > m_triggerBxVec

Definition: TTUEmulator.h:105

void TTUEmulator::emulate ( )

Definition at line 82 of file TTUEmulator.cc.

References dqmdumpme::k, m_maxWheels, and m_Wheels.

Referenced by TTUEmulator().

                           {
   //... only for testing
   for (int k = 0; k < m_maxWheels; ++k)
     m_Wheels[k].emulate();
 }

bool TTUEmulator::initialise ( )

Definition at line 64 of file TTUEmulator.cc.

References gather_cfg::cout, dqmdumpme::k, m_debug, m_id, m_line, m_maxWheels, m_ttuconf, m_Wheels, and mps_update::status.

Referenced by TTUEmulator().

                              {
   bool status(false);
   for (int k = 0; k < m_maxWheels; ++k)
     status = m_Wheels[k].initialise();
 
   status = m_ttuconf->initialise(m_line, m_id);
 
   if (!status) {
     if (m_debug)
       std::cout << "TTUEmulator> Problem initialising the Configuration \n";
     return false;
   };
 
   return status;
 }

int TTUEmulator::line ( ) const

inline

Definition at line 68 of file TTUEmulator.h.

References m_line, SetLineId(), and setSpecs().

Referenced by SetLineId().

68 { return m_line; };

TTUEmulator::m_line

int m_line

Definition: TTUEmulator.h:112

int TTUEmulator::mode ( void ) const

inline

Definition at line 64 of file TTUEmulator.h.

References m_mode.

Referenced by setmode().

64 { return m_mode; };

TTUEmulator::m_mode

int m_mode

Definition: TTUEmulator.h:111

void TTUEmulator::printinfo ( ) const

Definition at line 232 of file TTUEmulator.cc.

References gather_cfg::cout, dqmdumpme::k, m_id, m_maxWheels, and m_Wheels.

Referenced by TTUEmulator().

                                   {
   std::cout << "TTUEmulator: " << m_id << '\n';
   for (int k = 0; k < m_maxWheels; ++k)
     m_Wheels[k].printinfo();
 }

void TTUEmulator::processTtu ( RPCInputSignal * signal )

Definition at line 88 of file TTUEmulator.cc.

References l1GtPatternGenerator_cfi::bx, hgcaltilesconstants::ceil(), gather_cfg::cout, createfilelist::int, dqmdumpme::k, m_debug, m_id, m_maxWheels, m_trigger, m_triggerBx, m_triggerBxVec, m_ttuconf, m_ttuin, m_Wheels, LaserDQM_cfg::process, and tier0::unique().

Referenced by TTUEmulator().

                                                    {
   //.
   int bx(0);
   bool trg(false);
 
   if (m_debug)
     std::cout << "TTUEmulator::processTtu starts" << '\n';
 
   m_trigger.reset();
   m_triggerBx.clear();
 
   std::vector<int> bxVec;
   std::vector<int>::iterator bxItr;
   std::map<int, RBCInput*>* linkboardin;
   std::map<int, RBCInput*>::iterator inItr;
 
   linkboardin = dynamic_cast<RBCLinkBoardGLSignal*>(signal)->m_linkboardin;
 
   for (inItr = (*linkboardin).begin(); inItr != (*linkboardin).end(); ++inItr) {
     if ((*inItr).first < 0)
       bx = (int)ceil((*inItr).first / 1000000.0);
     else
       bx = (int)floor((*inItr).first / 1000000.0);
     bxVec.push_back(bx);
   }
 
   bxItr = unique(bxVec.begin(), bxVec.end());
   bxVec.resize(bxItr - bxVec.begin());
 
   m_triggerBxVec.reserve(m_triggerBxVec.size() + bxVec.size());
   for (bxItr = bxVec.begin(); bxItr != bxVec.end(); ++bxItr) {
     for (int k = 0; k < m_maxWheels; ++k) {
       if (m_Wheels[k].process((*bxItr), (*linkboardin))) {
         m_Wheels[k].createWheelMap();
 
         m_Wheels[k].retrieveWheelMap((m_ttuin[k]));
 
         //.. execute selected logic at Ttu level
         m_ttuconf->ttulogic()->run((m_ttuin[k]));
 
         //... and produce a Wheel level trigger
         trg = m_ttuconf->ttulogic()->isTriggered();
 
         m_trigger.set(k, trg);
 
         if (m_debug)
           std::cout << "TTUEmulator::processTtu ttuid: " << m_id << " bx: " << (*bxItr)
                     << " wheel: " << m_Wheels[k].getid() << " response: " << trg << std::endl;
       }
     }
 
     auto& triggerResponse = m_triggerBxVec.emplace_back();
 
     triggerResponse.setTriggerBits((*bxItr), m_trigger);
     m_triggerBx[(*bxItr)] = m_trigger;
   }
 
   if (m_debug)
     std::cout << "TTUEmulator::processTtu> size of trigger map " << m_triggerBx.size() << std::endl;
 
   if (m_debug)
     std::cout << "TTUEmulator::processTtu> done with this TTU: " << m_id << std::endl;
 
   bxVec.clear();
 
   if (m_debug)
     std::cout << "TTUEmulator::processTtu ends" << '\n';
 }

void TTUEmulator::processTtu	(	RPCInputSignal *	signal,
		int	wedgeId
	)

Definition at line 157 of file TTUEmulator.cc.

References l1GtPatternGenerator_cfi::bx, hgcaltilesconstants::ceil(), gather_cfg::cout, createfilelist::int, dqmdumpme::k, m_debug, m_id, m_maxWheels, m_trigger, m_triggerBx, m_triggerBxVec, m_ttuconf, m_ttuin, m_Wheels, LaserDQM_cfg::process, and tier0::unique().

                                                                 {
   //.
   int bx(0);
   bool trg(false);
 
   if (m_debug)
     std::cout << "TTUEmulator::processTtu( Pointing ) starts " << '\n';
 
   m_trigger.reset();
   m_triggerBx.clear();
 
   std::vector<int> bxVec;
   std::vector<int>::iterator bxItr;
   std::map<int, RBCInput*>* linkboardin;
   std::map<int, RBCInput*>::iterator inItr;
 
   linkboardin = dynamic_cast<RBCLinkBoardGLSignal*>(signal)->m_linkboardin;
 
   for (inItr = (*linkboardin).begin(); inItr != (*linkboardin).end(); ++inItr) {
     if ((*inItr).first < 0)
       bx = (int)ceil((*inItr).first / 1000000.0);
     else
       bx = (int)floor((*inItr).first / 1000000.0);
     bxVec.push_back(bx);
   }
 
   bxItr = unique(bxVec.begin(), bxVec.end());
   bxVec.resize(bxItr - bxVec.begin());
 
   m_triggerBxVec.reserve(m_triggerBxVec.size() + bxVec.size());
 
   for (bxItr = bxVec.begin(); bxItr != bxVec.end(); ++bxItr) {
     for (int k = 0; k < m_maxWheels; ++k) {
       if (m_Wheels[k].process(
               (*bxItr), (*linkboardin))) {  // <- this process uses the default RBC emulation but need a different logic
 
         m_Wheels[k].createWheelMap();
 
         m_Wheels[k].retrieveWheelMap((m_ttuin[k]));
 
         //.. execute selected logic at Ttu level
         m_ttuconf->ttulogic()->run((m_ttuin[k]), wedgeId);
 
         //... and produce a Wheel-Wedge level trigger
         trg = m_ttuconf->ttulogic()->isTriggered();
 
         m_trigger.set(k, trg);
 
         if (m_debug)
           std::cout << "TTUEmulator::processTtu( Pointing ) ttuid: " << m_id << " bx: " << (*bxItr)
                     << " wheel: " << m_Wheels[k].getid() << " response: " << trg << std::endl;
       }
     }
 
     auto& triggerResponse = m_triggerBxVec.emplace_back();
     triggerResponse.setTriggerBits((*bxItr), wedgeId, m_trigger);
     m_triggerBx[(*bxItr)] = m_trigger;
   }
 
   if (m_debug)
     std::cout << "TTUEmulator::processTtu (Pointing) > size of trigger map " << m_triggerBx.size() << std::endl;
 
   if (m_debug)
     std::cout << "TTUEmulator::processTtu (Pointing) > done with this TTU: " << m_id << std::endl;
 
   bxVec.clear();
 
   if (m_debug)
     std::cout << "TTUEmulator::processTtu( Pointing ) end" << '\n';
 }

void TTUEmulator::SetLineId ( int line )

Definition at line 80 of file TTUEmulator.cc.

References line(), and m_line.

Referenced by line().

80 { m_line = line; }

TTUEmulator::m_line

int m_line

Definition: TTUEmulator.h:112

TTUEmulator::line

int line() const

Definition: TTUEmulator.h:68

void TTUEmulator::setmode ( int mode )

inline

Definition at line 66 of file TTUEmulator.h.

References m_mode, and mode().

66 { m_mode = mode; };

TTUEmulator::m_mode

int m_mode

Definition: TTUEmulator.h:111

TTUEmulator::mode

int mode() const

Definition: TTUEmulator.h:64

void TTUEmulator::setSpecifications	(	const TTUBoardSpecs *	ttuspecs,
		const RBCBoardSpecs *	rbcspecs
	)

Definition at line 52 of file TTUEmulator.cc.

References dqmdumpme::k, m_maxWheels, m_mode, m_ttuconf, and m_Wheels.

Referenced by TTUEmulator().

                                                                                                 {
   m_ttuconf = std::make_unique<TTUBasicConfig>(ttuspecs);
 
   for (int k = 0; k < m_maxWheels; ++k)
     m_Wheels[k].setSpecifications(rbcspecs);
 
   std::vector<TTUBoardSpecs::TTUBoardConfig>::const_iterator itr;
   itr = m_ttuconf->m_ttuboardspecs->m_boardspecs.begin();
 
   m_mode = (*itr).m_triggerMode;
 }