L1GtPatternGenerator.cc

Go to the documentation of this file.

// this class header
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtPatternGenerator.h"

// system include files
#include <memory>
#include <iomanip>
#include <fstream>

// user include files
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctCollections.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctHtMiss.h"
#include "DataFormats/L1GlobalMuonTrigger/interface/L1MuGMTCand.h"
#include "DataFormats/L1GlobalMuonTrigger/interface/L1MuRegionalCand.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GtFdlWord.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtUtils.h"
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtPatternMap.h"
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtPatternWriter.h"

// constructor
L1GtPatternGenerator::L1GtPatternGenerator(const edm::ParameterSet& parSet) {
  // input tags for trigger records
  m_gctTag = parSet.getParameter<edm::InputTag>("GctInputTag");
  m_gmtTag = parSet.getParameter<edm::InputTag>("GmtInputTag");
  m_gtTag = parSet.getParameter<edm::InputTag>("GtInputTag");
  m_dtTag = parSet.getParameter<edm::InputTag>("DtInputTag");
  m_cscTag = parSet.getParameter<edm::InputTag>("CscInputTag");
  m_rpcbTag = parSet.getParameter<edm::InputTag>("RpcbInputTag");
  m_rpcfTag = parSet.getParameter<edm::InputTag>("RpcfInputTag");

  // output formatting stuff
  m_header = parSet.getParameter<std::string>("PatternFileHeader");
  m_footer = parSet.getParameter<std::string>("PatternFileFooter");
  m_columnNames = parSet.getParameter<std::vector<std::string> >("PatternFileColumns");
  m_columnLengths = parSet.getParameter<std::vector<uint32_t> >("PatternFileLengths");
  m_columnDefaults = parSet.getParameter<std::vector<uint32_t> >("PatternFileDefaultValues");
  m_fileName = parSet.getParameter<std::string>("PatternFileName");
  m_bx = parSet.getParameter<std::vector<int> >("bx");
  m_debug = parSet.getParameter<bool>("DebugOutput");

  if (m_columnLengths.size() != m_columnNames.size()) {
    edm::LogWarning("L1GtPatternGenerator")
        << "Length of PatternFileColumns does not match length of PatternFileLenghts, " << m_columnNames.size()
        << " vs " << m_columnLengths.size() << std::endl;
  }

  LogDebug("L1GtPatternGenerator") << "\nL1 GCT  record:            " << m_gctTag
                                   << "\nL1 GMT record:             " << m_gmtTag
                                   << "\nL1 GT record:              " << m_gtTag << std::endl;
}

// destructor
L1GtPatternGenerator::~L1GtPatternGenerator() {}

// local helper functions

template <class TRecord, typename TResult>
static void extractRecordData(const edm::Event& iEvent,
                              L1GtPatternMap& allPatterns,
                              const std::string& label,
                              const std::string& instance,
                              TResult (TRecord::*rawFunctionPtr)() const,
                              const std::string& prefix,
                              uint32_t (*packingFunction)(uint32_t) = nullptr) {
  // Extract record from event.
  edm::Handle<std::vector<TRecord> > handle;
  iEvent.getByLabel(label, instance, handle);

  if (!handle.isValid()) {
    throw cms::Exception(__func__) << "Failed to extract record of type " << typeid(TRecord).name() << " labeled "
                                   << label << ", instance " << instance;
  }

  edm::EventNumber_t eventNr = iEvent.id().event();

  // Then loop over collection and add each event to the map.
  for (typename std::vector<TRecord>::const_iterator it = handle->begin(); it != handle->end(); ++it) {
    int bx = it->bx();
    L1GtPatternLine& line = allPatterns.getLine(eventNr, bx);
    uint32_t value = ((*it).*rawFunctionPtr)();
    if (packingFunction != nullptr) {
      value = packingFunction(value);
    }

    line.push(prefix, value);
  }
}

/*** Convert a vector of bools into a vector of uint32_ts. Probably
     optimizable, but let's just trust that it doesn't matter... */
static std::vector<uint32_t> chopWords(const std::vector<bool>& aWord) {
  std::vector<uint32_t> result;

  result.resize((aWord.size() + 31) / 32, 0);

  for (unsigned i = 0; i < aWord.size(); ++i) {
    result[i / 32] |= aWord[i] << (i % 32);
  }

  return result;
}

static void extractGlobalTriggerWord(const std::vector<bool> input, L1GtPatternLine& line, const std::string& prefix) {
  std::vector<uint32_t> resultWords = chopWords(input);

  // add in reverse order, so that higher-order words have lower indices
  // (like in "natural" number representation) (10 -> digit1=1 digit2=0)
  for (unsigned i = resultWords.size(); i > 0; --i) {
    line.push(prefix, resultWords[i - 1]);
  }
}

uint32_t L1GtPatternGenerator::packRegionalMuons(uint32_t rawData) {
  uint32_t invertMask = 0x0000FF00;
  uint32_t toKeep = rawData & (~invertMask);
  return toKeep | (~rawData & invertMask);
}

// member functions
void L1GtPatternGenerator::extractGlobalTriggerData(const edm::Event& iEvent, L1GtPatternMap& patterns) {
  // extract global trigger readout record
  edm::Handle<L1GlobalTriggerReadoutRecord> handle;
  iEvent.getByLabel(m_gtTag, handle);

  // continue if it's present
  if (!handle.isValid()) {
    throw cms::Exception(__func__) << "Failed to extract GT readout record labeled " << m_gtTag.label() << ", instance "
                                   << m_gtTag.instance();
  }

  edm::EventNumber_t eventNr = iEvent.id().event();

  // for each FDL word...
  const std::vector<L1GtFdlWord>& fdlWords = handle->gtFdlVector();
  for (std::vector<L1GtFdlWord>::const_iterator it = fdlWords.begin(); it != fdlWords.end(); ++it) {
    // extract relevant data
    int bx = it->bxInEvent();

    // find matching pattern file line
    L1GtPatternLine& line = patterns.getLine(eventNr, bx);

    extractGlobalTriggerWord(it->gtDecisionWord(), line, "gtDecision");
    extractGlobalTriggerWord(it->gtDecisionWordExtended(), line, "gtDecisionExt");
    extractGlobalTriggerWord(it->gtTechnicalTriggerWord(), line, "gtTechTrigger");

    line.push("gtFinalOr", it->finalOR());
  }
}

void L1GtPatternGenerator::packHfRecords(const std::string& resultName, L1GtPatternMap& allPatterns) {
  // iterate over each pattern line
  for (L1GtPatternMap::LineMap::iterator it = allPatterns.begin(); it != allPatterns.end(); ++it) {
    // Get the HF bit counts and ring sums
    uint32_t counts = it->second.get("hfBitCounts1");
    uint32_t sums = it->second.get("hfRingEtSums1");

    // Bits 0..11 -> 4 bit counts
    uint32_t hfPsbValue = (counts & 0xFFF) |
                          // Bit 12..14 ring 1 pos. rap. HF Et sum
                          (sums & 0x7) << 12 |
                          // Bits 16.. rest of the ET sums
                          (sums >> 3) << 16;
    // TODO: Spec states non-data values for Bits 15, 31, 47 and 63.

    // Export computed value to pattern writer. */
    it->second.push(resultName, hfPsbValue);
  }
}

void L1GtPatternGenerator::analyze(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
  // debug information
  const unsigned int runNumber = iEvent.run();
  const unsigned int lsNumber = iEvent.luminosityBlock();
  const unsigned int eventNumber = iEvent.id().event();

  LogTrace("L1GtPatternGenerator") << "\n\nL1GtPatternGenerator::analyze: Run: " << runNumber << " LS: " << lsNumber
                                   << " Event: " << eventNumber << "\n\n"
                                   << std::endl;

  L1GtPatternMap allPatterns;

  // GMT muon candidates
  extractRecordData(iEvent, allPatterns, m_gmtTag.label(), m_gmtTag.instance(), &L1MuGMTCand::getDataWord, "gmtMuon");

  // regional muon candidates
  extractRecordData(iEvent,
                    allPatterns,
                    m_cscTag.label(),
                    m_cscTag.instance(),
                    &L1MuRegionalCand::getDataWord,
                    "cscMuon",
                    packRegionalMuons);
  extractRecordData(iEvent,
                    allPatterns,
                    m_dtTag.label(),
                    m_dtTag.instance(),
                    &L1MuRegionalCand::getDataWord,
                    "dtMuon",
                    packRegionalMuons);
  extractRecordData(iEvent,
                    allPatterns,
                    m_rpcfTag.label(),
                    m_rpcfTag.instance(),
                    &L1MuRegionalCand::getDataWord,
                    "fwdMuon",
                    packRegionalMuons);
  extractRecordData(iEvent,
                    allPatterns,
                    m_rpcbTag.label(),
                    m_rpcbTag.instance(),
                    &L1MuRegionalCand::getDataWord,
                    "brlMuon",
                    packRegionalMuons);

  // GCT objects
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "nonIsoEm", &L1GctEmCand::raw, "gctEm");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "isoEm", &L1GctEmCand::raw, "gctIsoEm");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "", &L1GctEtMiss::et, "etMiss");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "", &L1GctEtMiss::phi, "etMissPhi");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "", &L1GctHtMiss::raw, "htMiss");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "", &L1GctEtHad::raw, "etHad");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "", &L1GctEtTotal::raw, "etTotal");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "cenJets", &L1GctJetCand::raw, "cenJet");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "forJets", &L1GctJetCand::raw, "forJet");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "tauJets", &L1GctJetCand::raw, "tauJet");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "", &L1GctHFBitCounts::raw, "hfBitCounts");
  extractRecordData(iEvent, allPatterns, m_gctTag.label(), "", &L1GctHFRingEtSums::raw, "hfRingEtSums");

  // Post processing:
  // HFBitCounts/HFRingEtSums need to be mangled to PSB values
  packHfRecords("hfPsbValue", allPatterns);

  // GT objects
  extractGlobalTriggerData(iEvent, allPatterns);

  // Output
  m_writer->writePatterns(allPatterns);
}

void L1GtPatternGenerator::beginJob() {
  m_fileStream.open(m_fileName.c_str());

  if (!m_fileStream) {
    edm::LogError("L1GtPatternGenerator") << "Failed to open output file " << m_fileName;
  }

  m_writer = std::make_unique<L1GtPatternWriter>(
      m_fileStream, m_header, m_footer, m_columnNames, m_columnLengths, m_columnDefaults, m_bx, m_debug);
}

void L1GtPatternGenerator::endJob() {
  m_writer->close();
  m_fileStream.close();
}