GEMRawToDigiModule.cc

Go to the documentation of this file.

 
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/Run.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Utilities/interface/Transition.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/FEDRawData/interface/FEDNumbering.h"
 
#include "EventFilter/GEMRawToDigi/plugins/GEMRawToDigiModule.h"
 
using namespace gem;
 
GEMRawToDigiModule::GEMRawToDigiModule(const edm::ParameterSet& pset)
    : fed_token(consumes<FEDRawDataCollection>(pset.getParameter<edm::InputTag>("InputLabel"))),
      useDBEMap_(pset.getParameter<bool>("useDBEMap")),
      unPackStatusDigis_(pset.getParameter<bool>("unPackStatusDigis")) {
  if (useDBEMap_) {
    gemEMapToken_ = esConsumes<GEMeMap, GEMeMapRcd, edm::Transition::BeginRun>();
  }
  produces<GEMDigiCollection>();
  if (unPackStatusDigis_) {
    produces<GEMVfatStatusDigiCollection>("vfatStatus");
    produces<GEMGEBdataCollection>("gebStatus");
    produces<GEMAMCdataCollection>("AMCdata");
    produces<GEMAMC13EventCollection>("AMC13Event");
  }
}
 
void GEMRawToDigiModule::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
  desc.add<bool>("useDBEMap", false);
  desc.add<bool>("unPackStatusDigis", false);
  descriptions.add("muonGEMDigisDefault", desc);
}
 
std::shared_ptr<GEMROMapping> GEMRawToDigiModule::globalBeginRun(edm::Run const&, edm::EventSetup const& iSetup) const {
  auto gemROmap = std::make_shared<GEMROMapping>();
  if (useDBEMap_) {
    GEMeMap const& eMap = iSetup.getData(gemEMapToken_);
    auto gemEMap = std::make_unique<GEMeMap>(eMap);
    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 GEMRawToDigiModule::produce(edm::StreamID iID, edm::Event& iEvent, edm::EventSetup const&) const {
  auto outGEMDigis = std::make_unique<GEMDigiCollection>();
  auto outVFATStatus = std::make_unique<GEMVfatStatusDigiCollection>();
  auto outGEBStatus = std::make_unique<GEMGEBdataCollection>();
  auto outAMCdata = std::make_unique<GEMAMCdataCollection>();
  auto outAMC13Event = std::make_unique<GEMAMC13EventCollection>();
 
  // Take raw from the event
  edm::Handle<FEDRawDataCollection> fed_buffers;
  iEvent.getByToken(fed_token, fed_buffers);
 
  auto gemROMap = runCache(iEvent.getRun().index());
 
  for (unsigned int fedId = FEDNumbering::MINGEMFEDID; fedId <= FEDNumbering::MAXGEMFEDID; ++fedId) {
    const FEDRawData& fedData = fed_buffers->FEDData(fedId);
 
    int nWords = fedData.size() / sizeof(uint64_t);
    LogDebug("GEMRawToDigiModule") << " words " << nWords;
 
    if (nWords < 5)
      continue;
    const unsigned char* data = fedData.data();
 
    auto amc13Event = std::make_unique<AMC13Event>();
 
    const uint64_t* word = reinterpret_cast<const uint64_t*>(data);
 
    amc13Event->setCDFHeader(*word);
    amc13Event->setAMC13Header(*(++word));
 
    // Readout out AMC headers
    for (uint8_t i = 0; i < amc13Event->nAMC(); ++i)
      amc13Event->addAMCheader(*(++word));
 
    // Readout out AMC payloads
    for (uint8_t i = 0; i < amc13Event->nAMC(); ++i) {
      auto amcData = std::make_unique<AMCdata>();
      amcData->setAMCheader1(*(++word));
      amcData->setAMCheader2(*(++word));
      amcData->setGEMeventHeader(*(++word));
      uint16_t amcBx = amcData->bx();
      uint8_t amcNum = amcData->amcNum();
 
      // Fill GEB
      for (uint8_t j = 0; j < amcData->davCnt(); ++j) {
        auto gebData = std::make_unique<GEBdata>();
        gebData->setChamberHeader(*(++word));
 
        uint8_t gebId = gebData->inputID();
        GEMROMapping::chamEC geb_ec = {fedId, amcNum, gebId};
        GEMROMapping::chamDC geb_dc = gemROMap->chamberPos(geb_ec);
        GEMDetId gemChId = geb_dc.detId;
 
        for (uint16_t k = 0; k < gebData->vfatWordCnt() / 3; k++) {
          auto vfatData = std::make_unique<VFATdata>();
          vfatData->read_fw(*(++word));
          vfatData->read_sw(*(++word));
          vfatData->read_tw(*(++word));
 
          vfatData->setVersion(geb_dc.vfatVer);
          uint16_t vfatId = vfatData->vfatId();
          GEMROMapping::vfatEC vfat_ec = {vfatId, gemChId};
 
          // check if ChipID exists.
          if (!gemROMap->isValidChipID(vfat_ec)) {
            edm::LogWarning("GEMRawToDigiModule")
                << "InValid: amcNum " << int(amcNum) << " gebId " << int(gebId) << " vfatId " << int(vfatId)
                << " vfat Pos " << int(vfatData->position());
            continue;
          }
          // check vfat data
          if (vfatData->quality()) {
            edm::LogWarning("GEMRawToDigiModule")
                << "Quality " << int(vfatData->quality()) << " b1010 " << int(vfatData->b1010()) << " b1100 "
                << int(vfatData->b1100()) << " b1110 " << int(vfatData->b1110());
            if (vfatData->crc() != vfatData->checkCRC()) {
              edm::LogWarning("GEMRawToDigiModule")
                  << "DIFFERENT CRC :" << vfatData->crc() << "   " << vfatData->checkCRC();
            }
          }
 
          GEMROMapping::vfatDC vfat_dc = gemROMap->vfatPos(vfat_ec);
 
          vfatData->setPhi(vfat_dc.localPhi);
          GEMDetId gemId = vfat_dc.detId;
          uint16_t bc = vfatData->bc();
          // strip bx = vfat bx - amc bx
          int bx = bc - amcBx;
 
          for (int chan = 0; chan < VFATdata::nChannels; ++chan) {
            uint8_t chan0xf = 0;
            if (chan < 64)
              chan0xf = ((vfatData->lsData() >> chan) & 0x1);
            else
              chan0xf = ((vfatData->msData() >> (chan - 64)) & 0x1);
 
            // no hits
            if (chan0xf == 0)
              continue;
 
            GEMROMapping::channelNum chMap = {vfat_dc.vfatType, chan};
            GEMROMapping::stripNum stMap = gemROMap->hitPos(chMap);
 
            int stripId = stMap.stNum + vfatData->phi() * GEMeMap::maxChan_;
 
            GEMDigi digi(stripId, bx);
 
            LogDebug("GEMRawToDigiModule")
                << " 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();
 
            outGEMDigis.get()->insertDigi(gemId, digi);
 
          }  // end of channel loop
 
          if (unPackStatusDigis_) {
            outVFATStatus.get()->insertDigi(gemId, GEMVfatStatusDigi(*vfatData));
          }
 
        }  // end of vfat loop
 
        gebData->setChamberTrailer(*(++word));
 
        if (unPackStatusDigis_) {
          outGEBStatus.get()->insertDigi(gemChId.chamberId(), (*gebData));
        }
 
      }  // end of geb loop
 
      amcData->setGEMeventTrailer(*(++word));
      amcData->setAMCTrailer(*(++word));
 
      if (unPackStatusDigis_) {
        outAMCdata.get()->insertDigi(amcData->boardId(), (*amcData));
      }
 
    }  // end of amc loop
 
    amc13Event->setAMC13Trailer(*(++word));
    amc13Event->setCDFTrailer(*(++word));
 
    if (unPackStatusDigis_) {
      outAMC13Event.get()->insertDigi(amc13Event->bxId(), AMC13Event(*amc13Event));
    }
 
  }  // end of amc13Event
 
  iEvent.put(std::move(outGEMDigis));
 
  if (unPackStatusDigis_) {
    iEvent.put(std::move(outVFATStatus), "vfatStatus");
    iEvent.put(std::move(outGEBStatus), "gebStatus");
    iEvent.put(std::move(outAMCdata), "AMCdata");
    iEvent.put(std::move(outAMC13Event), "AMC13Event");
  }
}