RPCTechnicalTrigger Class Reference

#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	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () 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
edm::ESGetToken< RBCBoardSpecs, RBCBoardSpecsRcd >	m_pRBCSpecsToken
edm::ESGetToken< TTUBoardSpecs, TTUBoardSpecsRcd >	m_pTTUSpecsToken
const RBCBoardSpecs *	m_rbcspecs
std::unique_ptr< TTUConfigurator >	m_readConfig
const edm::InputTag	m_rpcDigiLabel
const edm::EDGetTokenT< RPCDigiCollection >	m_rpcDigiToken
edm::ESGetToken< RPCGeometry, MuonGeometryRecord >	m_rpcGeometryToken
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 constexpr 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 69 of file RPCTechnicalTrigger.h.

Constructor & Destructor Documentation

RPCTechnicalTrigger()

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

explicit

Definition at line 39 of file RPCTechnicalTrigger.cc.

    : 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)},
      m_rpcGeometryToken(esConsumes<RPCGeometry, MuonGeometryRecord>()) {
  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", ""));
  if (m_useEventSetup >= 1) {
    m_pRBCSpecsToken = esConsumes<RBCBoardSpecs, RBCBoardSpecsRcd, edm::Transition::BeginRun>();
    m_pTTUSpecsToken = esConsumes<TTUBoardSpecs, TTUBoardSpecsRcd, edm::Transition::BeginRun>();
  }
}

References edm::ParameterSet::getUntrackedParameter().

~RPCTechnicalTrigger()

RPCTechnicalTrigger::~RPCTechnicalTrigger ( )

override

Definition at line 88 of file RPCTechnicalTrigger.cc.

{}

Member Function Documentation

beginRun()

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

finalprivate

Definition at line 294 of file RPCTechnicalTrigger.cc.

                                                                                    {
  LogDebug("RPCTechnicalTrigger") << "RPCTechnicalTrigger::beginRun> starts" << std::endl;
 
  //..  Get Board Specifications (hardware configuration)
 
  if (m_useEventSetup >= 1) {
    edm::ESHandle<RBCBoardSpecs> pRBCSpecs = evtSetup.getHandle(m_pRBCSpecsToken);
    evtSetup.get<RBCBoardSpecsRcd>().get(pRBCSpecs);
 
    edm::ESHandle<TTUBoardSpecs> pTTUSpecs = evtSetup.getHandle(m_pTTUSpecsToken);
 
    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();
    }
  }
}

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

convertToMap()

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

private

Definition at line 346 of file RPCTechnicalTrigger.cc.

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

References crabWrapper::key.

Referenced by produce().

printinfo()

void RPCTechnicalTrigger::printinfo ( ) const

private

Definition at line 445 of file RPCTechnicalTrigger.cc.

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

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

produce()

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

overrideprivate

Definition at line 91 of file RPCTechnicalTrigger.cc.

                                                                               {
  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.getHandle(m_rpcGeometryToken);
 
  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;
}

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

searchCoincidence()

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

private

Definition at line 367 of file RPCTechnicalTrigger.cc.

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

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

Referenced by produce().

Member Data Documentation

kMaxTtuBoards

constexpr int RPCTechnicalTrigger::kMaxTtuBoards = 3

staticconstexprprivate

Definition at line 83 of file RPCTechnicalTrigger.h.

Referenced by beginRun(), printinfo(), and produce().

m_configFile

std::string RPCTechnicalTrigger::m_configFile

private

Definition at line 90 of file RPCTechnicalTrigger.h.

Referenced by beginRun().

m_hasConfig

bool RPCTechnicalTrigger::m_hasConfig

private

Definition at line 102 of file RPCTechnicalTrigger.h.

Referenced by beginRun(), and produce().

m_pRBCSpecsToken

edm::ESGetToken<RBCBoardSpecs, RBCBoardSpecsRcd> RPCTechnicalTrigger::m_pRBCSpecsToken

private

Definition at line 138 of file RPCTechnicalTrigger.h.

Referenced by beginRun().

m_pTTUSpecsToken

edm::ESGetToken<TTUBoardSpecs, TTUBoardSpecsRcd> RPCTechnicalTrigger::m_pTTUSpecsToken

private

Definition at line 139 of file RPCTechnicalTrigger.h.

Referenced by beginRun().

m_rbcspecs

const RBCBoardSpecs* RPCTechnicalTrigger::m_rbcspecs

private

Definition at line 100 of file RPCTechnicalTrigger.h.

Referenced by beginRun().

m_readConfig

std::unique_ptr<TTUConfigurator> RPCTechnicalTrigger::m_readConfig

private

Definition at line 98 of file RPCTechnicalTrigger.h.

Referenced by beginRun().

m_rpcDigiLabel

const edm::InputTag RPCTechnicalTrigger::m_rpcDigiLabel

private

Definition at line 93 of file RPCTechnicalTrigger.h.

Referenced by produce().

m_rpcDigiToken

const edm::EDGetTokenT<RPCDigiCollection> RPCTechnicalTrigger::m_rpcDigiToken

private

Definition at line 94 of file RPCTechnicalTrigger.h.

Referenced by produce().

m_rpcGeometryToken

edm::ESGetToken<RPCGeometry, MuonGeometryRecord> RPCTechnicalTrigger::m_rpcGeometryToken

private

Definition at line 137 of file RPCTechnicalTrigger.h.

Referenced by produce().

m_ttBits

const std::vector<unsigned> RPCTechnicalTrigger::m_ttBits

private

Definition at line 91 of file RPCTechnicalTrigger.h.

Referenced by produce().

m_ttNames

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

private

Definition at line 92 of file RPCTechnicalTrigger.h.

Referenced by produce().

m_ttu

std::array<TTUEmulator, kMaxTtuBoards> RPCTechnicalTrigger::m_ttu

private

Definition at line 84 of file RPCTechnicalTrigger.h.

Referenced by beginRun(), printinfo(), and produce().

m_ttuRbcLine

std::array<TTUEmulator, kMaxTtuBoards> RPCTechnicalTrigger::m_ttuRbcLine

private

Definition at line 86 of file RPCTechnicalTrigger.h.

Referenced by beginRun(), printinfo(), and produce().

m_ttuspecs

const TTUBoardSpecs* RPCTechnicalTrigger::m_ttuspecs

private

Definition at line 99 of file RPCTechnicalTrigger.h.

Referenced by beginRun().

m_useEventSetup

const int RPCTechnicalTrigger::m_useEventSetup

private

Definition at line 89 of file RPCTechnicalTrigger.h.

Referenced by beginRun().

m_useRPCSimLink

const int RPCTechnicalTrigger::m_useRPCSimLink

private

Definition at line 96 of file RPCTechnicalTrigger.h.

Referenced by produce().

m_verbosity

const int RPCTechnicalTrigger::m_verbosity

private

Definition at line 88 of file RPCTechnicalTrigger.h.

Referenced by produce().