#include <L1Trigger/RPCTechnicalTrigger/interface/RPCTechnicalTrigger.cc>

Inheritance diagram for RPCTechnicalTrigger:

Classes
class	TTUResults

Public Member Functions
	RPCTechnicalTrigger (const edm::ParameterSet &)

	~RPCTechnicalTrigger () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
void	beginRun (edm::Run const &, const edm::EventSetup &) final

std::map< int, TTUResults * >	convertToMap (const std::vector< std::unique_ptr< TTUResults >> &) const

void	printinfo () const

void	produce (edm::Event &, const edm::EventSetup &) override

bool	searchCoincidence (int, int, std::map< int, TTUResults * > const &ttuResultsByQuandrant) const

Private Attributes
std::string	m_configFile

bool	m_hasConfig

const RBCBoardSpecs *	m_rbcspecs

std::unique_ptr< TTUConfigurator >	m_readConfig

const edm::InputTag	m_rpcDigiLabel

const edm::EDGetTokenT< RPCDigiCollection >	m_rpcDigiToken

const std::vector< unsigned >	m_ttBits

const std::vector< std::string >	m_ttNames

std::array< TTUEmulator, kMaxTtuBoards >	m_ttu

std::array< TTUEmulator, kMaxTtuBoards >	m_ttuRbcLine

const TTUBoardSpecs *	m_ttuspecs

const int	m_useEventSetup

const int	m_useRPCSimLink

const int	m_verbosity

Static Private Attributes
static int	kMaxTtuBoards = 3

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Description: Implementation of the RPC Technical Trigger Emulator

Implementation:

Definition at line 68 of file RPCTechnicalTrigger.h.

Constructor & Destructor Documentation

RPCTechnicalTrigger::RPCTechnicalTrigger ( const edm::ParameterSet & iConfig )

explicit

Definition at line 39 of file RPCTechnicalTrigger.cc.

References constexpr, DeadROC_duringRun::f1, edm::ParameterSet::getUntrackedParameter(), HLT_2018_cff::InputTag, LogTrace, m_configFile, m_hasConfig, m_rpcDigiLabel, m_rpcDigiToken, m_ttBits, m_ttNames, m_ttu, m_ttuRbcLine, m_useEventSetup, m_useRPCSimLink, m_verbosity, and AlCaHLTBitMon_QueryRunRegistry::string.

     : m_verbosity{iConfig.getUntrackedParameter<int>("Verbosity", 0)},
       m_useEventSetup{iConfig.getUntrackedParameter<int>("UseEventSetup", 0)},
       m_ttBits{iConfig.getParameter<std::vector<unsigned>>("BitNumbers")},
       m_ttNames{iConfig.getParameter<std::vector<std::string>>("BitNames")},
       m_rpcDigiLabel{iConfig.getParameter<edm::InputTag>("RPCDigiLabel")},
       m_rpcDigiToken{consumes<RPCDigiCollection>(m_rpcDigiLabel)},
       m_useRPCSimLink{iConfig.getUntrackedParameter<int>("UseRPCSimLink", 0)} {
   //...........................................................................
 
   std::string configFile = iConfig.getParameter<std::string>("ConfigFile");
 
   edm::FileInPath f1("L1Trigger/RPCTechnicalTrigger/data/" + configFile);
   m_configFile = f1.fullPath();
 
   if (m_verbosity) {
     LogTrace("RPCTechnicalTrigger") << m_rpcDigiLabel << '\n' << std::endl;
 
     LogTrace("RPCTechnicalTrigger") << "\nConfiguration file used for UseEventSetup = 0 \n"
                                     << m_configFile << '\n'
                                     << std::endl;
   }
 
   //...........................................................................
   //... There are three Technical Trigger Units Boards: 1 can handle 2 Wheels
   //... n_Wheels sets the number of wheels attached to board with index boardIndex
 
   constexpr std::array<int, 3> boardIndex = {{1, 2, 3}};
   constexpr std::array<int, 3> nWheels = {{2, 1, 2}};
 
   m_ttu[0] = TTUEmulator(boardIndex[0], nWheels[0]);
   m_ttu[1] = TTUEmulator(boardIndex[1], nWheels[1]);
   m_ttu[2] = TTUEmulator(boardIndex[2], nWheels[2]);
 
   //... This is second line that delivers in parallel a second trigger
   m_ttuRbcLine[0] = TTUEmulator(boardIndex[0], nWheels[0]);
   m_ttuRbcLine[1] = TTUEmulator(boardIndex[1], nWheels[1]);
   m_ttuRbcLine[2] = TTUEmulator(boardIndex[2], nWheels[2]);
 
   //...........................................................................
 
   m_hasConfig = false;
   produces<L1GtTechnicalTriggerRecord>();
   consumes<edm::DetSetVector<RPCDigiSimLink>>(edm::InputTag("simMuonRPCDigis", "RPCDigiSimLink", ""));
 }

RPCTechnicalTrigger::~RPCTechnicalTrigger ( )

override

Definition at line 85 of file RPCTechnicalTrigger.cc.

85 {}

Member Function Documentation

void RPCTechnicalTrigger::beginRun	(	edm::Run const &	iRun,
		const edm::EventSetup &	evtSetup
	)

finalprivate

Definition at line 292 of file RPCTechnicalTrigger.cc.

References edm::EventSetup::get(), edm::ESHandleBase::isValid(), dqmdumpme::k, kMaxTtuBoards, LogDebug, m_configFile, m_hasConfig, m_rbcspecs, m_readConfig, m_ttu, m_ttuRbcLine, m_ttuspecs, m_useEventSetup, and edm::ESHandle< T >::product().

                                                                                     {
   LogDebug("RPCTechnicalTrigger") << "RPCTechnicalTrigger::beginRun> starts" << std::endl;
 
   //..  Get Board Specifications (hardware configuration)
 
   if (m_useEventSetup >= 1) {
     edm::ESHandle<RBCBoardSpecs> pRBCSpecs;
     evtSetup.get<RBCBoardSpecsRcd>().get(pRBCSpecs);
 
     edm::ESHandle<TTUBoardSpecs> pTTUSpecs;
     evtSetup.get<TTUBoardSpecsRcd>().get(pTTUSpecs);
 
     if (!pRBCSpecs.isValid() || !pTTUSpecs.isValid()) {
       edm::LogError("RPCTechnicalTrigger") << "can't find RBC/TTU BoardSpecsRcd" << '\n';
       m_hasConfig = false;
     } else {
       m_rbcspecs = pRBCSpecs.product();
       m_ttuspecs = pTTUSpecs.product();
       m_hasConfig = true;
     }
 
   } else {
     // read hardware configuration from file
     m_readConfig = std::make_unique<TTUConfigurator>(m_configFile);
 
     if (m_readConfig->m_hasConfig) {
       m_readConfig->process();
       m_rbcspecs = m_readConfig->getRbcSpecs();
       m_ttuspecs = m_readConfig->getTtuSpecs();
       m_hasConfig = true;
     }
 
     else
       m_hasConfig = false;
   }
 
   if (m_hasConfig) {
     //... Initialize all
 
     for (int k = 0; k < kMaxTtuBoards; ++k) {
       m_ttu[k].SetLineId(1);
       m_ttuRbcLine[k].SetLineId(2);
 
       m_ttu[k].setSpecifications(m_ttuspecs, m_rbcspecs);
       m_ttuRbcLine[k].setSpecifications(m_ttuspecs, m_rbcspecs);
 
       m_ttu[k].initialise();
       m_ttuRbcLine[k].initialise();
     }
   }
 }

std::map< int, RPCTechnicalTrigger::TTUResults * > RPCTechnicalTrigger::convertToMap ( const std::vector< std::unique_ptr< TTUResults >> & ttuResults ) const

private

Definition at line 345 of file RPCTechnicalTrigger.cc.

References crabWrapper::key.

Referenced by RPCTechnicalTrigger::TTUResults::getTriggerForWheel(), and produce().

                                                                   {
   std::map<int, TTUResults*> returnValue;
   auto itr = ttuResults.begin();
 
   while (itr != ttuResults.end()) {
     if ((*itr)->m_bx != 0) {
       ++itr;
       continue;
     }
 
     int key(0);
     key = 1000 * ((*itr)->m_ttuidx + 1) + 1 * (*itr)->m_wedge;
     returnValue[key] = itr->get();
     ++itr;
   }
 
   return returnValue;
 }

void RPCTechnicalTrigger::printinfo ( ) const

private

Definition at line 444 of file RPCTechnicalTrigger.cc.

References DEFINE_FWK_MODULE, dqmdumpme::k, kMaxTtuBoards, LogDebug, m_ttu, and m_ttuRbcLine.

                                           {
   LogDebug("RPCTechnicalTrigger") << "RPCTechnicalTrigger::Printing TTU emulators info>" << std::endl;
 
   for (int k = 0; k < kMaxTtuBoards; ++k) {
     m_ttu[k].printinfo();
     m_ttuRbcLine[k].printinfo();
   }
 }

void RPCTechnicalTrigger::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 88 of file RPCTechnicalTrigger.cc.

References funct::abs(), l1GtPatternGenerator_cfi::bx, convertToMap(), gather_cfg::cout, edm::EventSetup::get(), edm::Event::getByLabel(), edm::Event::getByToken(), input, edm::HandleBase::isValid(), dqmdumpme::k, kMaxTtuBoards, LogDebug, m_hasConfig, m_rpcDigiLabel, m_rpcDigiToken, m_ttBits, m_ttNames, m_ttu, m_ttuRbcLine, m_useRPCSimLink, m_verbosity, eostools::move(), MillePedeFileConverter_cfg::out, convertSQLitetoXML_cfg::output, edm::Event::put(), mps_fire::result, searchCoincidence(), and mps_update::status.

                                                                                {
   bool status(false);
 
   edm::Handle<RPCDigiCollection> pIn;
 
   edm::Handle<edm::DetSetVector<RPCDigiSimLink>> simIn;
 
   std::unique_ptr<L1GtTechnicalTriggerRecord> output(new L1GtTechnicalTriggerRecord());
 
   //.   Set up RPC geometry
   edm::ESHandle<RPCGeometry> rpcGeometry;
   iSetup.get<MuonGeometryRecord>().get(rpcGeometry);
 
   std::unique_ptr<ProcessInputSignal> signal;
   if (m_useRPCSimLink == 0) {
     iEvent.getByToken(m_rpcDigiToken, pIn);
     if (!pIn.isValid()) {
       edm::LogError("RPCTechnicalTrigger") << "can't find RPCDigiCollection with label: " << m_rpcDigiLabel << '\n';
       iEvent.put(std::move(output));
       return;
     }
 
     signal = std::make_unique<RBCProcessRPCDigis>(rpcGeometry, pIn);
 
   } else {
     iEvent.getByLabel("simMuonRPCDigis", "RPCDigiSimLink", simIn);
 
     if (!simIn.isValid()) {
       edm::LogError("RPCTechnicalTrigger") << "can't find RPCDigiCollection with label: " << m_rpcDigiLabel << '\n';
       iEvent.put(std::move(output));
       return;
     }
     signal = std::make_unique<RBCProcessRPCSimDigis>(rpcGeometry, simIn);
   }
 
   LogDebug("RPCTechnicalTrigger") << "signal object created" << '\n';
 
   if (!m_hasConfig) {
     edm::LogError("RPCTechnicalTrigger") << "cannot read hardware configuration \n";
     iEvent.put(std::move(output));
     return;
   }
 
   status = signal->next();
 
   if (!status) {
     iEvent.put(std::move(output));
     return;
   }
 
   auto* input = signal->retrievedata();
 
   std::vector<L1GtTechnicalTrigger> ttVec(m_ttBits.size());
 
   //. distribute data to different TTU emulator instances and process it
   std::bitset<5> triggerbits;
 
   std::vector<std::unique_ptr<TTUResults>> serializedInfoLine1;
   std::vector<std::unique_ptr<TTUResults>> serializedInfoLine2;
 
   for (int k = 0; k < kMaxTtuBoards; ++k) {
     m_ttu[k].processTtu(input);
 
     //work out Pointing Logic to Tracker
     for (auto firstSector : s_quadrants)
       m_ttuRbcLine[k].processTtu(input, firstSector);
 
     //...for trigger 1
     for (auto const& out : m_ttu[k].m_triggerBxVec)
       serializedInfoLine1.emplace_back(std::make_unique<TTUResults>(k, out.m_bx, out.m_trigger[0], out.m_trigger[1]));
     m_ttu[k].clearTriggerResponse();
 
     //...for trigger 2
     for (auto const& out : m_ttuRbcLine[k].m_triggerBxVec)
       serializedInfoLine2.push_back(
           std::make_unique<TTUResults>(k, out.m_bx, out.m_trigger[0], out.m_trigger[1], out.m_wedge));
 
     m_ttuRbcLine[k].clearTriggerResponse();
   }
 
   //.. write results to technical trigger bits
   int bx(0);
   int infoSize(0);
 
   infoSize = serializedInfoLine1.size();
 
   auto sortByBx = [](auto& iLHS, auto& iRHS) { return iLHS->m_bx < iRHS->m_bx; };
   std::sort(serializedInfoLine1.begin(), serializedInfoLine1.end(), sortByBx);
 
   if (m_verbosity) {
     for (auto& ttu : serializedInfoLine1) {
       if (abs(ttu->m_bx) <= 1)
         std::cout << "RPCTechnicalTrigger> " << ttu->m_ttuidx << '\t' << ttu->m_bx << '\t' << ttu->m_trigWheel1 << '\t'
                   << ttu->m_trigWheel2 << '\n';
     }
   }
 
   bool has_bx0 = false;
 
   for (int k = 0; k < infoSize; k += kMaxTtuBoards) {
     bx = serializedInfoLine1[k]->m_bx;
 
     if (bx == 0) {
       triggerbits.set(0, serializedInfoLine1[k]->m_trigWheel2);
       triggerbits.set(1, serializedInfoLine1[k]->m_trigWheel1);
       triggerbits.set(2, serializedInfoLine1[k + 1]->m_trigWheel1);
       triggerbits.set(3, serializedInfoLine1[k + 2]->m_trigWheel1);
       triggerbits.set(4, serializedInfoLine1[k + 2]->m_trigWheel2);
 
       bool five_wheels_OR = triggerbits.any();
 
       ttVec.at(0) = L1GtTechnicalTrigger(
           m_ttNames.at(0), m_ttBits.at(0), bx, five_wheels_OR);  // bit 24 = Or 5 wheels in TTU mode
       ttVec.at(2) = L1GtTechnicalTrigger(m_ttNames.at(2), m_ttBits.at(2), bx, triggerbits[0]);  // bit 26
       ttVec.at(3) = L1GtTechnicalTrigger(m_ttNames.at(3), m_ttBits.at(3), bx, triggerbits[1]);  // bit 27
       ttVec.at(4) = L1GtTechnicalTrigger(m_ttNames.at(4), m_ttBits.at(4), bx, triggerbits[2]);  // bit 28
       ttVec.at(5) = L1GtTechnicalTrigger(m_ttNames.at(5), m_ttBits.at(5), bx, triggerbits[3]);  // bit 29
       ttVec.at(6) = L1GtTechnicalTrigger(m_ttNames.at(6), m_ttBits.at(6), bx, triggerbits[4]);  // bit 30
 
       triggerbits.reset();
 
       has_bx0 = true;
 
       break;
 
     } else
       continue;
   }
 
   infoSize = serializedInfoLine2.size();
 
   std::sort(serializedInfoLine2.begin(), serializedInfoLine2.end(), sortByBx);
 
   if (m_verbosity) {
     for (auto& ttu : serializedInfoLine2) {
       if (abs(ttu->m_bx) <= 1)
         std::cout << "RPCTechnicalTrigger> " << ttu->m_ttuidx << '\t' << ttu->m_bx << '\t' << ttu->m_trigWheel1 << '\t'
                   << ttu->m_trigWheel2 << '\t' << ttu->m_wedge << '\n';
     }
   }
 
   auto ttuResultsByQuadrant = convertToMap(serializedInfoLine2);
 
   std::bitset<8> triggerCoincidence;
   triggerCoincidence.reset();
 
   // searchCoincidence( W-2 , W0 )
   bool result = searchCoincidence(-2, 0, ttuResultsByQuadrant);
   triggerCoincidence.set(0, result);
 
   // searchCoincidence( W-2 , W+1 )
   result = searchCoincidence(-2, 1, ttuResultsByQuadrant);
   triggerCoincidence.set(1, result);
 
   // searchCoincidence( W-1 , W0  )
   result = searchCoincidence(-1, 0, ttuResultsByQuadrant);
   triggerCoincidence.set(2, result);
 
   // searchCoincidence( W-1 , W+1 )
   result = searchCoincidence(-1, 1, ttuResultsByQuadrant);
   triggerCoincidence.set(3, result);
 
   // searchCoincidence( W-1 , W+2 )
   result = searchCoincidence(-1, 2, ttuResultsByQuadrant);
   triggerCoincidence.set(4, result);
 
   // searchCoincidence( W0  , W0  )
   result = searchCoincidence(0, 0, ttuResultsByQuadrant);
   triggerCoincidence.set(5, result);
 
   // searchCoincidence( W+1 , W0  )
   result = searchCoincidence(1, 0, ttuResultsByQuadrant);
   triggerCoincidence.set(6, result);
 
   // searchCoincidence( W+2 , W0  )
   result = searchCoincidence(2, 0, ttuResultsByQuadrant);
   triggerCoincidence.set(7, result);
 
   bool five_wheels_OR = triggerCoincidence.any();
 
   if (m_verbosity)
     std::cout << "RPCTechnicalTrigger> pointing trigger: " << five_wheels_OR << '\n';
 
   ttVec.at(1) =
       L1GtTechnicalTrigger(m_ttNames.at(1), m_ttBits.at(1), bx, five_wheels_OR);  // bit 25 = Or 5 wheels in RBC mode
 
   triggerCoincidence.reset();
 
   //...check that data appeared at bx=0
 
   if (!has_bx0) {
     iEvent.put(std::move(output));
     LogDebug("RPCTechnicalTrigger") << "RPCTechnicalTrigger> end of event loop" << std::endl;
     return;
   }
 
   output->setGtTechnicalTrigger(ttVec);
   iEvent.put(std::move(output));
 
   //.... all done
 
   LogDebug("RPCTechnicalTrigger") << "RPCTechnicalTrigger> end of event loop" << std::endl;
 }

bool RPCTechnicalTrigger::searchCoincidence	(	int	wheel1,
		int	wheel2,
		std::map< int, TTUResults * > const &	ttuResultsByQuandrant
	)		const

private

Definition at line 366 of file RPCTechnicalTrigger.cc.

References dqmdumpme::k, and crabWrapper::key.

Referenced by RPCTechnicalTrigger::TTUResults::getTriggerForWheel(), and produce().

                                                                                                         {
   std::map<int, TTUResults*>::const_iterator itr;
   bool topRight(false);
   bool botLeft(false);
 
   int indxW1 = wheelTtu[wheel1 + kWheelOffset];
   int indxW2 = wheelTtu[wheel2 + kWheelOffset];
 
   int k(0);
   int key(0);
   bool finalTrigger(false);
   int maxTopQuadrants = 4;
 
   //work out Pointing Logic to Tracker
 
   for (auto firstSector : s_quadrants) {
     key = 1000 * (indxW1) + firstSector;
 
     itr = ttuResultsByQuadrant.find(key);
     if (itr != ttuResultsByQuadrant.end())
       topRight = (*itr).second->getTriggerForWheel(wheel1);
 
     //std::cout << "W1: " << wheel1 << " " << "sec: " << firstSector << " dec: " << topRight << '\n';
 
     key = 1000 * (indxW2) + firstSector + 5;
 
     itr = ttuResultsByQuadrant.find(key);
 
     if (itr != ttuResultsByQuadrant.end())
       botLeft = (*itr).second->getTriggerForWheel(wheel2);
 
     //std::cout << "W2: " << wheel2 << " " << "sec: " << firstSector + 5 << " dec: " << botLeft << '\n';
 
     finalTrigger |= (topRight && botLeft);
 
     ++k;
 
     if (k > maxTopQuadrants)
       break;
   }
 
   //Try the opposite now
 
   k = 0;
 
   for (auto firstSector : s_quadrants) {
     key = 1000 * (indxW2) + firstSector;
 
     itr = ttuResultsByQuadrant.find(key);
     if (itr != ttuResultsByQuadrant.end())
       topRight = (*itr).second->getTriggerForWheel(wheel1);
 
     //std::cout << "W1: " << wheel1 << " " << "sec: " << firstSector << " dec: " << topRight << '\n';
 
     key = 1000 * (indxW1) + firstSector + 5;
 
     itr = ttuResultsByQuadrant.find(key);
 
     if (itr != ttuResultsByQuadrant.end())
       botLeft = (*itr).second->getTriggerForWheel(wheel2);
 
     //std::cout << "W2: " << wheel2 << " " << "sec: " << firstSector + 5 << " dec: " << botLeft << '\n';
 
     finalTrigger |= (topRight && botLeft);
 
     ++k;
 
     if (k > maxTopQuadrants)
       break;
   }
 
   return finalTrigger;
 }