GEMDigiToRawModule.cc

Go to the documentation of this file.

 
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/Run.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "DataFormats/FEDRawData/interface/FEDHeader.h"
#include "DataFormats/FEDRawData/interface/FEDTrailer.h"
#include "DataFormats/FEDRawData/interface/FEDRawData.h"
#include "DataFormats/FEDRawData/interface/FEDNumbering.h"
 
#include "EventFilter/GEMRawToDigi/plugins/GEMDigiToRawModule.h"
 
using namespace gem;
 
GEMDigiToRawModule::GEMDigiToRawModule(const edm::ParameterSet& pset)
    : event_type_(pset.getParameter<int>("eventType")),
      digi_token(consumes<GEMDigiCollection>(pset.getParameter<edm::InputTag>("gemDigi"))),
      useDBEMap_(pset.getParameter<bool>("useDBEMap")) {
  produces<FEDRawDataCollection>();
}
 
void GEMDigiToRawModule::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("gemDigi", edm::InputTag("simMuonGEMDigis"));
  desc.add<int>("eventType", 0);
  desc.add<bool>("useDBEMap", false);
  descriptions.add("gemPackerDefault", desc);
}
 
std::shared_ptr<GEMROMapping> GEMDigiToRawModule::globalBeginRun(edm::Run const&, edm::EventSetup const& iSetup) const {
  auto gemROmap = std::make_shared<GEMROMapping>();
  if (useDBEMap_) {
    edm::ESHandle<GEMeMap> gemEMapRcd;
    iSetup.get<GEMeMapRcd>().get(gemEMapRcd);
    auto gemEMap = std::make_unique<GEMeMap>(*(gemEMapRcd.product()));
    gemEMap->convert(*gemROmap);
    gemEMap.reset();
  } else {
    // no EMap in DB, using dummy
    auto gemEMap = std::make_unique<GEMeMap>();
    gemEMap->convertDummy(*gemROmap);
    gemEMap.reset();
  }
  return gemROmap;
}
 
void GEMDigiToRawModule::produce(edm::StreamID iID, edm::Event& iEvent, edm::EventSetup const&) const {
  auto fedRawDataCol = std::make_unique<FEDRawDataCollection>();
 
  edm::Handle<GEMDigiCollection> gemDigis;
  iEvent.getByToken(digi_token, gemDigis);
  if (!gemDigis.isValid()) {
    iEvent.put(std::move(fedRawDataCol));
    return;
  }
 
  auto gemROMap = runCache(iEvent.getRun().index());
 
  std::vector<std::unique_ptr<AMC13Event>> amc13Events;
  amc13Events.reserve(FEDNumbering::MAXGEMFEDID - FEDNumbering::MINGEMFEDID + 1);
 
  for (unsigned int fedId = FEDNumbering::MINGEMFEDID; fedId <= FEDNumbering::MAXGEMFEDID; ++fedId) {
    std::unique_ptr<AMC13Event> amc13Event = std::make_unique<AMC13Event>();
 
    for (uint8_t amcNum = 0; amcNum < GEMeMap::maxAMCs_; ++amcNum) {
      std::unique_ptr<AMCdata> amcData = std::make_unique<AMCdata>();
 
      for (uint8_t gebId = 0; gebId < GEMeMap::maxGEBs_; ++gebId) {
        std::unique_ptr<GEBdata> gebData = std::make_unique<GEBdata>();
        GEMROMapping::chamEC geb_ec{fedId, amcNum, gebId};
 
        if (!gemROMap->isValidChamber(geb_ec))
          continue;
        GEMROMapping::chamDC geb_dc = gemROMap->chamberPos(geb_ec);
 
        auto vfats = gemROMap->getVfats(geb_dc.detId);
        for (auto vfat_ec : vfats) {
          GEMROMapping::vfatDC vfat_dc = gemROMap->vfatPos(vfat_ec);
          GEMDetId gemId = vfat_dc.detId;
          uint16_t vfatId = vfat_ec.vfatAdd;
 
          for (uint16_t bc = 0; bc < 2 * GEMeMap::amcBX_; ++bc) {
            bool hasDigi = false;
 
            uint64_t lsData = 0;  
            uint64_t msData = 0;  
 
            GEMDigiCollection::Range range = gemDigis->get(gemId);
            for (GEMDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
              const GEMDigi& digi = (*digiIt);
              if (digi.bx() != bc - GEMeMap::amcBX_)
                continue;
 
              int localStrip = digi.strip() - vfat_dc.localPhi * GEMeMap::maxChan_;
 
              // skip strips not in current vFat
              if (localStrip < 0 || localStrip > GEMeMap::maxChan_ - 1)
                continue;
 
              hasDigi = true;
              GEMROMapping::stripNum stMap = {vfat_dc.vfatType, localStrip};
              GEMROMapping::channelNum chMap = gemROMap->hitPos(stMap);
 
              if (chMap.chNum < 64)
                lsData |= 1UL << chMap.chNum;
              else
                msData |= 1UL << (chMap.chNum - 64);
 
              LogDebug("GEMDigiToRawModule")
                  << " fed: " << fedId << " amc:" << int(amcNum) << " geb:" << int(gebId)
                  << " vfat:" << vfat_dc.localPhi << ",type: " << vfat_dc.vfatType << " id:" << gemId
                  << " ch:" << chMap.chNum << " st:" << digi.strip() << " bx:" << digi.bx();
            }
 
            if (!hasDigi)
              continue;
            // only make vfat with hits
            auto vfatData = std::make_unique<VFATdata>(geb_dc.vfatVer, bc, 0, vfatId, lsData, msData);
            gebData->addVFAT(*vfatData);
          }
 
        }  // end of vfats in GEB
 
        if (!gebData->vFATs()->empty()) {
          gebData->setChamberHeader(gebData->vFATs()->size() * 3, gebId);
          gebData->setChamberTrailer(0, 0, gebData->vFATs()->size() * 3);
          amcData->addGEB(*gebData);
        }
 
      }  // end of GEB loop
 
      if (!amcData->gebs()->empty()) {
        amcData->setAMCheader1(0, GEMeMap::amcBX_, 0, amcNum);
        amcData->setAMCheader2(amcNum, 0, 1);
        amcData->setGEMeventHeader(amcData->gebs()->size(), 0);
        amc13Event->addAMCpayload(*amcData);
      }
 
    }  // end of AMC loop
 
    if (!amc13Event->getAMCpayloads()->empty()) {
      // CDFHeader
      uint32_t LV1_id = iEvent.id().event();
      uint16_t BX_id = iEvent.bunchCrossing();
      amc13Event->setCDFHeader(event_type_, LV1_id, BX_id, fedId);
 
      // AMC13header
      uint8_t CalTyp = 1;
      uint8_t nAMC = amc13Event->getAMCpayloads()->size();
      uint32_t OrN = 2;
      amc13Event->setAMC13Header(CalTyp, nAMC, OrN);
 
      for (unsigned short i = 0; i < amc13Event->nAMC(); ++i) {
        uint32_t AMC_size = 0;
        uint8_t Blk_No = 0;
        uint8_t AMC_No = 0;
        uint16_t BoardID = 0;
        amc13Event->addAMCheader(AMC_size, Blk_No, AMC_No, BoardID);
      }
 
      //AMC13 trailer
      uint8_t Blk_NoT = 0;
      uint8_t LV1_idT = 0;
      uint16_t BX_idT = BX_id;
      amc13Event->setAMC13Trailer(Blk_NoT, LV1_idT, BX_idT);
      //CDF trailer
      uint32_t EvtLength = 0;
      amc13Event->setCDFTrailer(EvtLength);
      amc13Events.emplace_back(std::move(amc13Event));
    }  // finished making amc13Event data
 
  }  // end of FED loop
 
  // read out amc13Events into fedRawData
  for (const auto& amc13e : amc13Events) {
    std::vector<uint64_t> words;
    words.emplace_back(amc13e->getCDFHeader());
    words.emplace_back(amc13e->getAMC13Header());
 
    for (const auto& w : *amc13e->getAMCheaders())
      words.emplace_back(w);
 
    for (const auto& amc : *amc13e->getAMCpayloads()) {
      words.emplace_back(amc.getAMCheader1());
      words.emplace_back(amc.getAMCheader2());
      words.emplace_back(amc.getGEMeventHeader());
 
      for (const auto& geb : *amc.gebs()) {
        words.emplace_back(geb.getChamberHeader());
 
        for (const auto& vfat : *geb.vFATs()) {
          words.emplace_back(vfat.get_fw());
          words.emplace_back(vfat.get_sw());
          words.emplace_back(vfat.get_tw());
        }
 
        words.emplace_back(geb.getChamberTrailer());
      }
 
      words.emplace_back(amc.getGEMeventTrailer());
      words.emplace_back(amc.getAMCTrailer());
    }
 
    words.emplace_back(amc13e->getAMC13Trailer());
    words.emplace_back(amc13e->getCDFTrailer());
 
    FEDRawData& fedRawData = fedRawDataCol->FEDData(amc13e->sourceId());
 
    int dataSize = (words.size()) * sizeof(uint64_t);
    fedRawData.resize(dataSize);
 
    uint64_t* w = reinterpret_cast<uint64_t*>(fedRawData.data());
    for (const auto& word : words)
      *(w++) = word;
 
    LogDebug("GEMDigiToRawModule") << " words " << words.size();
  }
 
  iEvent.put(std::move(fedRawDataCol));
}