TTUEmulator Class Reference

#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, const char *, const char *, const char *, int)
	TTUEmulator (int, const char *, const char *, int)
	TTUEmulator (int, 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() [1/4]

TTUEmulator::TTUEmulator ( )

inline

Standard constructor.

Definition at line 42 of file TTUEmulator.h.

{};

TTUEmulator() [2/4]

TTUEmulator::TTUEmulator	(	int	id,
		int	mxw
	)

Definition at line 24 of file TTUEmulator.cc.

                                        : 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() [3/4]

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

Definition at line 29 of file TTUEmulator.cc.

    : 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() [4/4]

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.

    : 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

clearTriggerResponse()

void TTUEmulator::clearTriggerResponse

(

)

Definition at line 228 of file TTUEmulator.cc.

{ m_triggerBxVec.clear(); }

References m_triggerBxVec.

emulate()

void TTUEmulator::emulate

(

)

Definition at line 82 of file TTUEmulator.cc.

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

References dqmdumpme::k, m_maxWheels, and m_Wheels.

initialise()

bool TTUEmulator::initialise

(

)

Definition at line 64 of file TTUEmulator.cc.

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

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

line()

int TTUEmulator::line ( ) const

inline

Definition at line 68 of file TTUEmulator.h.

{ return m_line; };

References m_line.

Referenced by SetLineId().

mode()

int TTUEmulator::mode ( void  ) const

inline

Definition at line 64 of file TTUEmulator.h.

{ return m_mode; };

References m_mode.

Referenced by setmode().

printinfo()

void TTUEmulator::printinfo

(

)

const

Definition at line 232 of file TTUEmulator.cc.

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

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

processTtu() [1/2]

void TTUEmulator::processTtu

(

RPCInputSignal *

signal

)

Definition at line 88 of file TTUEmulator.cc.

                                                   {
  //.
  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';
}

References simKBmtfDigis_cfi::bx, reco::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().

processTtu() [2/2]

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

Definition at line 157 of file TTUEmulator.cc.

                                                                {
  //.
  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';
}

References simKBmtfDigis_cfi::bx, reco::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().

SetLineId()

void TTUEmulator::SetLineId

(

int

line

)

Definition at line 80 of file TTUEmulator.cc.

{ m_line = line; }

References line(), and m_line.

setmode()

void TTUEmulator::setmode ( int  mode )

inline

Definition at line 66 of file TTUEmulator.h.

{ m_mode = mode; };

References m_mode, and mode().

setSpecifications()

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

Definition at line 52 of file TTUEmulator.cc.

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

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

setSpecs()

void TTUEmulator::setSpecs

(

)

Member Data Documentation

m_bx

int TTUEmulator::m_bx

private

Definition at line 110 of file TTUEmulator.h.

m_debug

bool TTUEmulator::m_debug

private

Definition at line 122 of file TTUEmulator.h.

Referenced by initialise(), and processTtu().

m_id

int TTUEmulator::m_id

private

Definition at line 109 of file TTUEmulator.h.

Referenced by initialise(), printinfo(), and processTtu().

m_line

int TTUEmulator::m_line

private

Definition at line 112 of file TTUEmulator.h.

Referenced by initialise(), line(), and SetLineId().

m_logtype

std::string TTUEmulator::m_logtype

private

Definition at line 116 of file TTUEmulator.h.

m_maxWheels

int TTUEmulator::m_maxWheels

Definition at line 74 of file TTUEmulator.h.

Referenced by emulate(), initialise(), printinfo(), processTtu(), and setSpecifications().

m_mode

int TTUEmulator::m_mode

private

Definition at line 111 of file TTUEmulator.h.

Referenced by mode(), setmode(), and setSpecifications().

m_trigger

std::bitset<2> TTUEmulator::m_trigger

Definition at line 77 of file TTUEmulator.h.

Referenced by processTtu().

m_triggerBx

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

Definition at line 78 of file TTUEmulator.h.

Referenced by processTtu().

m_triggerBxVec

std::vector<TriggerResponse> TTUEmulator::m_triggerBxVec

Definition at line 105 of file TTUEmulator.h.

Referenced by clearTriggerResponse(), and processTtu().

m_ttuconf

std::unique_ptr<TTUConfiguration> TTUEmulator::m_ttuconf

private

Definition at line 120 of file TTUEmulator.h.

Referenced by initialise(), processTtu(), and setSpecifications().

m_ttuin

std::array<TTUInput, 2> TTUEmulator::m_ttuin

private

Definition at line 118 of file TTUEmulator.h.

Referenced by processTtu().

m_wheelIds

std::array<int, 6> TTUEmulator::m_wheelIds

private

Definition at line 114 of file TTUEmulator.h.

m_Wheels

std::array<RPCWheel, 2> TTUEmulator::m_Wheels

Definition at line 76 of file TTUEmulator.h.

Referenced by emulate(), initialise(), printinfo(), processTtu(), and setSpecifications().