L1TGlobalPrescaler.cc

Go to the documentation of this file.

#include <vector>
#include <array>
#include <memory>
#include <cassert>
#include <string>
#include <stdexcept>
#include <cstring>

#include <boost/format.hpp>

template <class T, std::size_t N>
std::array<T, N> make_array(std::vector<T> const & values) {
  assert(N == values.size());
  std::array<T, N> ret;
  std::copy(values.begin(), values.end(), ret.begin());
  return ret;
}

template <class T>
bool empty(T const& container) {
  return container.empty();
}

bool empty(const char * container) {
  return container != nullptr;
}


using namespace std::literals;

namespace {

  template <class T>
  struct Entry {
    T            value;
    const char * tag;
    const char * description;
  };

  template <typename S, typename T, unsigned int N>
  std::string build_comment_from_entries(S pre, const Entry<T> (&entries)[N]) {
    std::string comment{ pre };
    size_t length = 0;
    for (auto entry: entries)
      if (entry.tag)
        length = std::max(std::strlen(entry.tag), length);
    for (auto entry: entries)
      if (entry.tag) {
        comment.reserve(comment.size() + length + std::strlen(entry.description) + 8);
        comment += "\n  \"";
        comment += entry.tag;
        comment += "\": ";
        for (unsigned int i = 0; i < length-std::strlen(entry.tag); ++i) comment += ' ';
        comment += entry.description;
      }
    return comment;
  }

  template <typename S1, typename S2, typename T, unsigned int N>
  std::string build_comment_from_entries(S1 pre, const Entry<T> (&entries)[N], S2 post) {
    std::string comment = build_comment_from_entries(pre, entries);
    comment += '\n';
    comment += post;
    return comment;
  }


  template <class T>
#if __cplusplus > 201400
  // extended constexpr support in C++14 and later
  constexpr
#endif
  T get_enum_value(Entry<T> const * entries, const char * tag) {
      for (; entries->tag; ++entries)
        if (std::strcmp(entries->tag, tag) == 0)
          return entries->value;
      throw std::logic_error("invalid tag "s + tag);
  }

  template <class T>
#if __cplusplus > 201400
  // extended constexpr support in C++14 and later
  constexpr
#endif
  T get_enum_value(Entry<T> const * entries, const char * tag, T default_value) {
      for (; entries->tag; ++entries)
        if (std::strcmp(entries->tag, tag) == 0)
          return entries->value;
      return default_value;
  }

} // anonymous

// ############################################################################


#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/one/EDFilter.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include "CondFormats/DataRecord/interface/L1TGlobalPrescalesVetosRcd.h"
#include "CondFormats/L1TObjects/interface/L1TGlobalPrescalesVetos.h"
#include "DataFormats/L1TGlobal/interface/GlobalAlgBlk.h"


namespace {

  template <typename T, std::size_t N, typename S>
  std::array<T, N>
  getParameterArray(edm::ParameterSet const & config, S const & name)
  {
    std::vector<T> values = config.getParameter<std::vector<T>>(name);
    if (values.size() != N)
      throw edm::Exception(edm::errors::Configuration)
        << "Parameter \"" << name << "\" should have " << N << " elements.\n"
        << "The number of elements in the configuration is incorrect.";
    std::array<T, N> ret;
    std::copy(values.begin(), values.end(), ret.begin());
    return ret;
  }

} // anonymous

class L1TGlobalPrescaler : public edm::one::EDFilter<> {
public:
  L1TGlobalPrescaler(edm::ParameterSet const& config);

  bool filter(edm::Event& event, edm::EventSetup const& setup) override;

  static  void fillDescriptions(edm::ConfigurationDescriptions & descriptions);

private:
  enum class Mode {
    ApplyPrescaleValues,    // apply the given prescale values
    ApplyPrescaleRatios,    // apply prescales equal to ratio between the given values and the ones read from the EventSetup
    ApplyColumnValues,      // apply the prescale values from the EventSetup corresponding to the given column index
    ApplyColumnRatios,      // apply prescales equal to ratio between the values corresponsing to the given column index, and the ones read from the EventSetup
    ForcePrescaleValues,    // apply the given prescale values, ignoring the prescales and masks already applied
    ForceColumnValues,      // apply the prescale values from the EventSetup corresponding to the given column index, ignoring the prescales and masks already applied
    Invalid = -1
  };

  static const
  constexpr Entry<Mode> s_modes[] {
    { Mode::ApplyPrescaleValues, "applyPrescaleValues", "apply the given prescale values" },
    { Mode::ApplyPrescaleRatios, "applyPrescaleRatios", "apply prescales equal to ratio between the given values and the ones read from the EventSetup" },
    { Mode::ApplyColumnValues,   "applyColumnValues",   "apply the prescale values from the EventSetup corresponding to the given column index" },
    { Mode::ApplyColumnRatios,   "applyColumnRatios",   "apply prescales equal to ratio between the values corresponsing to the given column index, and the ones read from the EventSetup" },
    { Mode::ForcePrescaleValues, "forcePrescaleValues", "apply the given prescale values, ignoring the prescales and masks already applied" },
    { Mode::ForceColumnValues,   "forceColumnValues",   "apply the prescale values from the EventSetup corresponding to the given column index, ignoring the prescales and masks already applied" },
    { Mode::Invalid,             nullptr,               nullptr }
  };

  const Mode m_mode;
  const edm::EDGetTokenT<GlobalAlgBlkBxCollection>           m_l1tResultsToken;
  const std::array<double, GlobalAlgBlk::maxPhysicsTriggers> m_l1tPrescales;
  std::array<double, GlobalAlgBlk::maxPhysicsTriggers>       m_prescales;
  std::array<unsigned int, GlobalAlgBlk::maxPhysicsTriggers> m_counters;
  const int m_l1tPrescaleColumn;
  int m_oldIndex;

};

const
constexpr Entry<L1TGlobalPrescaler::Mode> L1TGlobalPrescaler::s_modes[];


L1TGlobalPrescaler::L1TGlobalPrescaler(edm::ParameterSet const& config) :
  m_mode( get_enum_value(s_modes, config.getParameter<std::string>("mode").c_str(), Mode::Invalid) ),
  m_l1tResultsToken( consumes<GlobalAlgBlkBxCollection>(config.getParameter<edm::InputTag>("l1tResults")) ),
  m_l1tPrescales( m_mode == Mode::ApplyPrescaleValues or m_mode == Mode::ApplyPrescaleRatios or m_mode == Mode::ForcePrescaleValues ?
      getParameterArray<double, GlobalAlgBlk::maxPhysicsTriggers>(config, "l1tPrescales") :
      std::array<double, GlobalAlgBlk::maxPhysicsTriggers>() ),
  m_l1tPrescaleColumn( m_mode == Mode::ApplyColumnValues or m_mode == Mode::ApplyColumnRatios or m_mode == Mode::ForceColumnValues ?
      config.getParameter<uint32_t>("l1tPrescaleColumn") : 0 ),
  m_oldIndex(-1)
{
  switch (m_mode) {
    // if the mode is "applyPrescaleValues", use the given values
    case Mode::ApplyPrescaleValues:
    case Mode::ForcePrescaleValues:
      m_prescales = m_l1tPrescales;
      break;

    // otherwise we need to read the prescale values from the EventSetup
    case Mode::ApplyColumnValues:
    case Mode::ApplyPrescaleRatios:
    case Mode::ApplyColumnRatios:
    case Mode::ForceColumnValues:
      break;

    // this should never happen
    case Mode::Invalid:
      throw edm::Exception(edm::errors::Configuration) << "invalid mode \"" << config.getParameter<std::string>("mode") << "\"";
  }

  m_counters.fill(0);
  produces<GlobalAlgBlkBxCollection>();
}

bool L1TGlobalPrescaler::filter(edm::Event& event, edm::EventSetup const& setup) {
  edm::Handle<GlobalAlgBlkBxCollection> handle;
  event.getByToken(m_l1tResultsToken, handle);

  // if the input collection does not have any information for bx 0,
  // produce an empty collection, and fail
  if (handle->isEmpty(0)) {
    std::unique_ptr<GlobalAlgBlkBxCollection> result(new GlobalAlgBlkBxCollection());
    event.put(std::move(result));
    return false;
  }

  // read the prescale index
  int index = handle->at(0,0).getPreScColumn();
  assert(index >= 0);

  // Mode::ApplyPrescaleRatios
  // apply prescales equal to ratio between the given values and the ones read from the EventSetup
  if (m_mode == Mode::ApplyPrescaleRatios and m_oldIndex != index) {
    edm::ESHandle<L1TGlobalPrescalesVetos> h;
    setup.get<L1TGlobalPrescalesVetosRcd>().get(h);
    auto const & prescaleTable = h->prescale_table_;
    if (index >= (int) prescaleTable.size())
      throw edm::Exception(edm::errors::LogicError) << boost::format("The prescale index %d is invalid, it should be smaller than the prescale table size %d.") % index % prescaleTable.size();
    auto const & prescales = prescaleTable[index];
    unsigned long i = 0;
    for (; i < std::min(prescales.size(), (unsigned long) GlobalAlgBlk::maxPhysicsTriggers); ++i)
      if (m_l1tPrescales[i] == 0) {
        // if the trigger is requested to be disabled, just do it
        m_prescales[i] = 0.;
      } else if (prescales[i] == 0) {
        // othersie, if the trigger was originally disabled, warn the user and keep it that way
        m_prescales[i] = 0.;
        edm::LogWarning("L1TGlobalPrescaler") << "Request to enable the trigger " << i << " which was originally disabled\nIt will be kept disabled.";
      } else if (m_l1tPrescales[i] < prescales[i]) {
        // if the target prescale is lower than the original prescale, keep the trigger unprescaled
        m_prescales[i] = 1.;
        edm::LogWarning("L1TGlobalPrescaler") << "Request to prescale the trigger " << i << " less than it was originally prescaled\nNo further prescale will be applied.";
      } else {
        // apply the ratio of the new and old prescales
        m_prescales[i] = (double) m_l1tPrescales[i] / prescales[i];
      }
    for (; i < (unsigned long) GlobalAlgBlk::maxPhysicsTriggers; ++i)
      // disable the triggers not included in the prescale table
      m_prescales[i] = 0.;
    // reset the prescales
    m_counters.fill(0);
    m_oldIndex = index;
  }

  // Mode::ApplyColumnValues and Mode::ForceColumnValues
  // apply the prescale values from the EventSetup corresponding to the given column index
  if ((m_mode == Mode::ApplyColumnValues or m_mode == Mode::ForceColumnValues) and m_oldIndex != m_l1tPrescaleColumn) {
    edm::ESHandle<L1TGlobalPrescalesVetos> h;
    setup.get<L1TGlobalPrescalesVetosRcd>().get(h);
    auto const & prescaleTable = h->prescale_table_;
    if (m_l1tPrescaleColumn >= (int) prescaleTable.size())
      throw edm::Exception(edm::errors::Configuration) << boost::format("The prescale index %d is invalid, it should be smaller than the prescale table size %d.") % m_l1tPrescaleColumn % prescaleTable.size();
    auto const & targets = prescaleTable[m_l1tPrescaleColumn];
    unsigned long i = 0;
    for (; i < std::min(targets.size(), (unsigned long) GlobalAlgBlk::maxPhysicsTriggers); ++i)
      // read the prescales from the EventSetup
      m_prescales[i] = targets[i];
    for (; i < (unsigned long) GlobalAlgBlk::maxPhysicsTriggers; ++i)
      // disable the triggers not included in the prescale table
      m_prescales[i] = 0.;
    // reset the prescales
    m_counters.fill(0);
    m_oldIndex = m_l1tPrescaleColumn;
  }

  // Mode::ApplyColumnRatios
  // apply prescales equal to ratio between the values corresponsing to the given column index, and the ones read from the EventSetup
  if (m_mode == Mode::ApplyColumnRatios and m_oldIndex != index) {
    edm::ESHandle<L1TGlobalPrescalesVetos> h;
    setup.get<L1TGlobalPrescalesVetosRcd>().get(h);
    auto const & prescaleTable = h->prescale_table_;
    if (index >= (int) prescaleTable.size())
      throw edm::Exception(edm::errors::LogicError) << boost::format("The prescale index %d is invalid, it should be smaller than the prescale table size %d.") % index % prescaleTable.size();
    if (m_l1tPrescaleColumn >= (int) prescaleTable.size())
      throw edm::Exception(edm::errors::Configuration) << boost::format("The prescale index %d is invalid, it should be smaller than the prescale table size %d.") % m_l1tPrescaleColumn % prescaleTable.size();
    auto const & prescales = prescaleTable[index];
    auto const & targets = prescaleTable[m_l1tPrescaleColumn];
    unsigned long i = 0;
    for (; i < std::min({prescales.size(), targets.size(), (unsigned long) GlobalAlgBlk::maxPhysicsTriggers}); ++i)
      if (prescales[i] == 0)
        // if the trigger was disabled, keep it disabled
        m_prescales[i] = 0.;
      else
        // if the target prescale is lower than the original prescale, keep the trigger unprescaled
        m_prescales[i] = targets[i] < prescales[i] ? 1. : (double) targets[i] / prescales[i];
    for (; i < (unsigned long) GlobalAlgBlk::maxPhysicsTriggers; ++i)
      // disable the triggers not included in the prescale table
      m_prescales[i] = 0.;
    // reset the prescales
    m_counters.fill(0);
    m_oldIndex = index;
  }

  // make a copy of the GlobalAlgBlk for bx 0
  GlobalAlgBlk algoBlock = handle->at(0,0);

  bool finalOr = false;
  std::vector<bool> const& decision = (m_mode == Mode::ForceColumnValues or m_mode == Mode::ForcePrescaleValues) ?
    algoBlock.getAlgoDecisionInitial() :
    algoBlock.getAlgoDecisionFinal();

  for (unsigned int i = 0; i < GlobalAlgBlk::maxPhysicsTriggers; ++i) {
    if (m_prescales[i] == 0) {
      // mask this trigger: reset the bit
      algoBlock.setAlgoDecisionFinal(i, false);
    } else if (decision[i]) {
      // prescale this trigger
      ++m_counters[i];
      if (std::fmod(m_counters[i], m_prescales[i]) < 1) {
        // the prescale is successful, set the bit
        algoBlock.setAlgoDecisionFinal(i, true);
        finalOr = true;
      } else {
        // the prescale failed, reset the bit
        algoBlock.setAlgoDecisionFinal(i, false);
      }
    }
  }

  // set the final OR
  algoBlock.setFinalORPreVeto(finalOr);
  if (algoBlock.getFinalORVeto())
    finalOr = false;
  algoBlock.setFinalOR(finalOr);

  // set the new prescale column
  if (m_mode == Mode::ApplyColumnValues or m_mode == Mode::ApplyColumnRatios or m_mode == Mode::ForceColumnValues)
    algoBlock.setPreScColumn(m_l1tPrescaleColumn);

  // create a new GlobalAlgBlkBxCollection, and set the new prescaled decisions for bx 0
  std::unique_ptr<GlobalAlgBlkBxCollection> result(new GlobalAlgBlkBxCollection());
  result->push_back(0, algoBlock);
  event.put(std::move(result));

  return finalOr;
}


void L1TGlobalPrescaler::fillDescriptions(edm::ConfigurationDescriptions & descriptions) {
  // collection with the original uGT results
  edm::ParameterDescription<edm::InputTag> l1tResults("l1tResults", edm::InputTag("gtStage2Digis"), true);
  l1tResults.setComment("Collection with the original uGT results");

  // define how to apply the prescale values
  edm::ParameterDescription<std::string> mode("mode", "applyPrescaleValues", true);
  mode.setComment(build_comment_from_entries("Define how to apply the prescale values:", s_modes));

  // target prescale values (for modes "applyPrescaleValues" or "applyPrescaleRatios")
  edm::ParameterDescription<std::vector<double>> l1tPrescales("l1tPrescales", std::vector<double>(GlobalAlgBlk::maxPhysicsTriggers, 1.), true);
  l1tPrescales.setComment("Target prescale values (for modes \"applyPrescaleValues\", \"applyPrescaleRatios\" or \"forcePrescaleValues\")");

  // target prescale column (for modes "applyColumnValues" or "applyColumnRatios")
  edm::ParameterDescription<uint32_t> l1tPrescaleColumn("l1tPrescaleColumn", 0, true);
  l1tPrescaleColumn.setComment("Target prescale column (for modes \"applyColumnValues\", \"applyColumnRatios\" or \"forceColumnValues\")");

  // validaton of all possible configurations and applyPrescaleValues example
  {
    edm::ParameterSetDescription desc;
    desc.addNode(l1tResults);
    desc.ifValue(mode,
      // if mode is "applyPrescaleValues", "applyPrescaleRatios" or "forcePrescaleValues", read the target prescales
      "applyPrescaleValues" >> l1tPrescales or
      "applyPrescaleRatios" >> l1tPrescales or
      "forcePrescaleValues" >> l1tPrescales or
      // if mode is "applyColumnValues", "applyColumnRatios" or "forceColumnValues", read the target column
      "applyColumnValues"   >> l1tPrescaleColumn or
      "applyColumnRatios"   >> l1tPrescaleColumn or
      "forceColumnValues"   >> l1tPrescaleColumn );
    descriptions.add("l1tGlobalPrescaler", desc);
  }

  // applyColumnRatios example
  {
    edm::ParameterSetDescription desc;
    desc.addNode(l1tResults);
    desc.add<std::string>("mode", "applyColumnRatios")->setComment("apply prescales equal to ratio between the values corresponsing to the given column index, and the ones read from the EventSetup");
    desc.addNode(l1tPrescaleColumn);
    descriptions.add("l1tGlobalPrescalerTargetColumn", desc);
  }
}


// register as a framework plugin
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(L1TGlobalPrescaler);