TTUEmulator.cc

Go to the documentation of this file.

// Include files
 
#include <cmath>
#include <algorithm>
// local
#include "L1Trigger/RPCTechnicalTrigger/interface/TTUEmulator.h"
#include "L1Trigger/RPCTechnicalTrigger/interface/TTUBasicConfig.h"
#include "L1Trigger/RPCTechnicalTrigger/interface/RBCLinkBoardGLSignal.h"
#include "L1Trigger/RPCTechnicalTrigger/interface/TTUGlobalSignal.h"
 
//-----------------------------------------------------------------------------
// Implementation file for class : TTUEmulator
//
// 2008-10-15 : Andres Osorio
//-----------------------------------------------------------------------------
 
namespace {
  constexpr std::array<int, 6> wheelIds = {{1, 2, 0, 0, -1, -2}};
}
 
//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
TTUEmulator::TTUEmulator(int id, int mxw) : 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)
    : 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)
    : 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);
}
 
//=============================================================================
void TTUEmulator::setSpecifications(const TTUBoardSpecs* ttuspecs, const RBCBoardSpecs* rbcspecs) {
  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;
}
 
bool TTUEmulator::initialise() {
  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;
}
 
void TTUEmulator::SetLineId(int line) { m_line = line; }
 
void TTUEmulator::emulate() {
  //... only for testing
  for (int k = 0; k < m_maxWheels; ++k)
    m_Wheels[k].emulate();
}
 
void TTUEmulator::processTtu(RPCInputSignal* signal) {
  //.
  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) {
  //.
  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::clearTriggerResponse() { m_triggerBxVec.clear(); }
 
//.................................................................
 
void TTUEmulator::printinfo() const {
  std::cout << "TTUEmulator: " << m_id << '\n';
  for (int k = 0; k < m_maxWheels; ++k)
    m_Wheels[k].printinfo();
}