SiStripDigiToRawModule.cc

Go to the documentation of this file.

#include "SiStripDigiToRawModule.h"
#include "SiStripDigiToRaw.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "CondFormats/DataRecord/interface/SiStripFedCablingRcd.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
#include <cstdlib>

namespace sistrip {

  //fill Descriptions needed to define default parameters
  void DigiToRawModule::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
    edm::ParameterSetDescription desc;
    desc.add<std::string>("FedReadoutMode", "ZERO_SUPPRESSED");
    desc.add<std::string>("PacketCode", "ZERO_SUPPRESSED");
    desc.add<bool>("UseFedKey", false);
    desc.add<bool>("UseWrongDigiType", false);
    desc.add<bool>("CopyBufferHeader", false);
    desc.add<edm::InputTag>("InputDigis", edm::InputTag("simSiStripDigis", "ZeroSuppressed"));
    desc.add<edm::InputTag>("RawDataTag", edm::InputTag("rawDataCollector"));
    descriptions.add("SiStripDigiToRawModule", desc);
  }

  // -----------------------------------------------------------------------------
  DigiToRawModule::DigiToRawModule(const edm::ParameterSet& pset)
      : copyBufferHeader_(pset.getParameter<bool>("CopyBufferHeader")),
        mode_(fedReadoutModeFromString(pset.getParameter<std::string>("FedReadoutMode"))),
        packetCode_(packetCodeFromString(pset.getParameter<std::string>("PacketCode"), mode_)),
        rawdigi_(false),
        digiToRaw_(nullptr),
        eventCounter_(0),
        inputDigiTag_(pset.getParameter<edm::InputTag>("InputDigis")),
        rawDataTag_(pset.getParameter<edm::InputTag>("RawDataTag")) {
    if (edm::isDebugEnabled()) {
      LogDebug("DigiToRawModule") << "[sistrip::DigiToRawModule::DigiToRawModule]"
                                  << " Constructing object...";
    }

    switch (mode_) {
      case READOUT_MODE_ZERO_SUPPRESSED:
        rawdigi_ = false;
        break;
      case READOUT_MODE_ZERO_SUPPRESSED_FAKE:
        rawdigi_ = false;
        break;
      case READOUT_MODE_ZERO_SUPPRESSED_LITE10:
        rawdigi_ = false;
        break;
      case READOUT_MODE_ZERO_SUPPRESSED_LITE10_CMOVERRIDE:
        rawdigi_ = false;
        break;
      case READOUT_MODE_ZERO_SUPPRESSED_LITE8:
        rawdigi_ = false;
        break;
      case READOUT_MODE_ZERO_SUPPRESSED_LITE8_CMOVERRIDE:
        rawdigi_ = false;
        break;
      case READOUT_MODE_ZERO_SUPPRESSED_LITE8_TOPBOT:
        rawdigi_ = false;
        break;
      case READOUT_MODE_ZERO_SUPPRESSED_LITE8_TOPBOT_CMOVERRIDE:
        rawdigi_ = false;
        break;
      case READOUT_MODE_ZERO_SUPPRESSED_LITE8_BOTBOT:
        rawdigi_ = false;
        break;
      case READOUT_MODE_ZERO_SUPPRESSED_LITE8_BOTBOT_CMOVERRIDE:
        rawdigi_ = false;
        break;
      case READOUT_MODE_PREMIX_RAW:
        rawdigi_ = false;
        break;
      case READOUT_MODE_VIRGIN_RAW:
        rawdigi_ = true;
        break;
      case READOUT_MODE_PROC_RAW:
        rawdigi_ = true;
        break;
      case READOUT_MODE_SCOPE:
        rawdigi_ = true;
        break;
      case READOUT_MODE_INVALID: {
        if (edm::isDebugEnabled()) {
          edm::LogWarning("DigiToRawModule")
              << "[sistrip::DigiToRawModule::DigiToRawModule]"
              << " UNKNOWN readout mode: " << pset.getParameter<std::string>("FedReadoutMode");
        }
      } break;
      case READOUT_MODE_SPY: {
        if (edm::isDebugEnabled()) {
          edm::LogWarning("DigiToRawModule") << "[sistrip::DigiToRawModule::DigiToRawModule]"
                                             << " Digi to raw is not supported for spy channel data";
        }
      } break;
    }
    if (pset.getParameter<bool>("UseWrongDigiType")) {
      rawdigi_ = !rawdigi_;
      if (edm::isDebugEnabled()) {
        edm::LogWarning("DigiToRawModule") << "[sistrip::DigiToRawModule::DigiToRawModule]"
                                           << " You are using the wrong type of digis!";
      }
    }

    // Create instance of DigiToRaw formatter
    digiToRaw_ = new DigiToRaw(mode_, packetCode_, pset.getParameter<bool>("UseFedKey"));

    if (rawdigi_) {
      tokenRawDigi = consumes<edm::DetSetVector<SiStripRawDigi> >(inputDigiTag_);
    } else {
      tokenDigi = consumes<edm::DetSetVector<SiStripDigi> >(inputDigiTag_);
    }
    if (copyBufferHeader_) {
      //CAMM input raw module label or same as digi ????
      if (edm::isDebugEnabled()) {
        edm::LogWarning("DigiToRawModule") << "[sistrip::DigiToRawModule::DigiToRawModule]"
                                           << "Copying buffer header from collection " << rawDataTag_;
      }
      tokenRawBuffer = consumes<FEDRawDataCollection>(rawDataTag_);
    }

    produces<FEDRawDataCollection>();
  }

  // -----------------------------------------------------------------------------
  DigiToRawModule::~DigiToRawModule() {
    if (edm::isDebugEnabled()) {
      LogDebug("DigiToRaw") << "[sistrip::DigiToRawModule::~DigiToRawModule]"
                            << " Destructing object...";
    }
    if (digiToRaw_)
      delete digiToRaw_;
  }

  // -----------------------------------------------------------------------------
  void DigiToRawModule::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
    eventCounter_++;

    auto buffers = std::make_unique<FEDRawDataCollection>();

    edm::ESHandle<SiStripFedCabling> cabling;
    iSetup.get<SiStripFedCablingRcd>().get(cabling);

    //get buffer header from original rawdata
    edm::Handle<FEDRawDataCollection> rawbuffers;
    if (copyBufferHeader_) {
      if (edm::isDebugEnabled()) {
        edm::LogWarning("DigiToRawModule") << "[sistrip::DigiToRawModule::DigiToRawModule]"
                                           << "Getting raw buffer: ";
      }
      try {
        iEvent.getByToken(tokenRawBuffer, rawbuffers);
      } catch (const cms::Exception& e) {
        if (edm::isDebugEnabled()) {
          edm::LogWarning("DigiToRawModule") << "[sistrip::DigiToRawModule::DigiToRawModule]"
                                             << " Failed to get collection " << rawDataTag_;
        }
      }
    }

    if (rawdigi_) {
      edm::Handle<edm::DetSetVector<SiStripRawDigi> > rawdigis;
      iEvent.getByToken(tokenRawDigi, rawdigis);
      if (copyBufferHeader_)
        digiToRaw_->createFedBuffers(iEvent, cabling, rawbuffers, rawdigis, buffers);
      else
        digiToRaw_->createFedBuffers(iEvent, cabling, rawdigis, buffers);
    } else {
      edm::Handle<edm::DetSetVector<SiStripDigi> > digis;
      iEvent.getByToken(tokenDigi, digis);
      if (copyBufferHeader_)
        digiToRaw_->createFedBuffers(iEvent, cabling, rawbuffers, digis, buffers);
      else
        digiToRaw_->createFedBuffers(iEvent, cabling, digis, buffers);
    }

    iEvent.put(std::move(buffers));
  }

  void DigiToRawModule::endStream() { digiToRaw_->printWarningSummary(); }
}  // namespace sistrip