#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 25 of file TTUEmulator.cc.

References gen::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 37 of file TTUEmulator.cc.

References gen::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 49 of file TTUEmulator.cc.

References gen::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 268 of file TTUEmulator.cc.

References m_triggerBxVec.

Referenced by TTUEmulator().

 {
    m_triggerBxVec.clear();
 }

void TTUEmulator::emulate ( )

Definition at line 100 of file TTUEmulator.cc.

References gen::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 79 of file TTUEmulator.cc.

References gather_cfg::cout, gen::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 72 of file TTUEmulator.h.

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

Referenced by SetLineId().

                    {
     return m_line;
   };

int TTUEmulator::mode ( void ) const

inline

Definition at line 64 of file TTUEmulator.h.

References m_mode.

Referenced by setmode().

                    {
     return m_mode;
   };

void TTUEmulator::printinfo ( ) const

Definition at line 275 of file TTUEmulator.cc.

References gather_cfg::cout, gen::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 108 of file TTUEmulator.cc.

References gather_cfg::cout, createfilelist::int, gen::k, m_debug, m_id, m_maxWheels, m_trigger, m_triggerBx, m_triggerBxVec, m_ttuconf, m_ttuin, m_Wheels, LaserDQM_cfg::process, generateDummyData::trg(), 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 189 of file TTUEmulator.cc.

References gather_cfg::cout, createfilelist::int, gen::k, m_debug, m_id, m_maxWheels, m_trigger, m_triggerBx, m_triggerBxVec, m_ttuconf, m_ttuin, m_Wheels, LaserDQM_cfg::process, generateDummyData::trg(), 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 95 of file TTUEmulator.cc.

References line(), and m_line.

Referenced by line().

 {
   m_line = line;
 }

void TTUEmulator::setmode ( int mode )

inline

Definition at line 68 of file TTUEmulator.h.

References m_mode, and mode().

                          {
     m_mode = mode;
   };

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

Definition at line 64 of file TTUEmulator.cc.

References gen::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;
   
 }