RPCTechnicalTrigger.cc

Go to the documentation of this file.

// $Id:
 
//-----------------------------------------------------------------------------
// Implementation file for class : RPCTechnicalTrigger
//
// 2008-10-15 : Andres Osorio
//-----------------------------------------------------------------------------
 
//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
 
// Include files
 
// local
#include "L1Trigger/RPCTechnicalTrigger/interface/RPCTechnicalTrigger.h"
#include "L1Trigger/RPCTechnicalTrigger/interface/ProcessTestSignal.h"
#include "L1Trigger/RPCTechnicalTrigger/interface/RBCProcessRPCDigis.h"
#include "L1Trigger/RPCTechnicalTrigger/interface/RBCProcessRPCSimDigis.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/MessageLogger/interface/MessageDrop.h"
 
//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
 
namespace {
  //...........................................................................
  //For the pointing Logic: declare here the first sector of each quadrant
  //
  constexpr std::array<int, 10> s_quadrants = {{2, 3, 4, 5, 6, 7, 8, 9, 10, 11}};
 
  //The wheelTtu is addressed using -2, -1, 0, 1, 2
  constexpr unsigned int kWheelOffset = 2;
  constexpr std::array<int, 5> wheelTtu = {{3, 3, 2, 1, 1}};
}  // namespace
 
RPCTechnicalTrigger::RPCTechnicalTrigger(const edm::ParameterSet& iConfig)
    : 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() {}
 
//=============================================================================
void RPCTechnicalTrigger::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  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;
}
// ------------ method called once each job just before starting event loop  ------------
void RPCTechnicalTrigger::beginRun(edm::Run const& iRun, const edm::EventSetup& evtSetup) {
  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 {
  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;
}
 
//...RBC pointing logic to tracker bit 25: hardwired
bool RPCTechnicalTrigger::searchCoincidence(int wheel1,
                                            int wheel2,
                                            std::map<int, TTUResults*> const& ttuResultsByQuadrant) const {
  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;
}
 
// ------------ method called once each job just after ending the event loop  ------------
 
void RPCTechnicalTrigger::printinfo() const {
  LogDebug("RPCTechnicalTrigger") << "RPCTechnicalTrigger::Printing TTU emulators info>" << std::endl;
 
  for (int k = 0; k < kMaxTtuBoards; ++k) {
    m_ttu[k].printinfo();
    m_ttuRbcLine[k].printinfo();
  }
}
 
//define this as a plug-in
DEFINE_FWK_MODULE(RPCTechnicalTrigger);