DTUnpackingModule.cc

Go to the documentation of this file.

#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include <FWCore/Framework/interface/Event.h>
#include <DataFormats/Common/interface/Handle.h>
#include <FWCore/Framework/interface/ESHandle.h>
#include <FWCore/Framework/interface/EventSetup.h>
#include <FWCore/ParameterSet/interface/ParameterSet.h>
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"

#include <EventFilter/DTRawToDigi/plugins/DTUnpackingModule.h>
#include <DataFormats/DTDigi/interface/DTControlData.h>

#include <DataFormats/FEDRawData/interface/FEDRawData.h>
#include <DataFormats/FEDRawData/interface/FEDNumbering.h>
#include <DataFormats/DTDigi/interface/DTDigiCollection.h>
#include <DataFormats/DTDigi/interface/DTLocalTriggerCollection.h>

#include <CondFormats/DataRecord/interface/DTReadOutMappingRcd.h>

#include <EventFilter/DTRawToDigi/plugins/DTDDUUnpacker.h>
#include <EventFilter/DTRawToDigi/plugins/DTROS25Unpacker.h>
#include <EventFilter/DTRawToDigi/plugins/DTROS8Unpacker.h>


using namespace edm;
using namespace std;



#define SLINK_WORD_SIZE 8 


DTUnpackingModule::DTUnpackingModule(const edm::ParameterSet& ps) : unpacker(nullptr),dataType("") {

  dataType = ps.getParameter<string>("dataType");

  ParameterSet unpackerParameters = ps.getParameter<ParameterSet>("readOutParameters");
  
  if (dataType == "DDU") {
    unpacker = new DTDDUUnpacker(unpackerParameters);
  } 
  else if (dataType == "ROS25") {
    unpacker = new DTROS25Unpacker(unpackerParameters.getParameter<ParameterSet>("rosParameters"));
  } 
  else if (dataType == "ROS8") {
    unpacker = new DTROS8Unpacker(unpackerParameters);
  } 
  else {
    throw cms::Exception("InvalidParameter") << "DTUnpackingModule: dataType "
                         << dataType << " is unknown";
  }

  inputLabel = consumes<FEDRawDataCollection>(ps.getParameter<InputTag>("inputLabel")); // default was: source
  useStandardFEDid_ = ps.getParameter<bool>("useStandardFEDid"); // default was: true
  minFEDid_ = ps.getUntrackedParameter<int>("minFEDid",770); // default: 770
  maxFEDid_ = ps.getUntrackedParameter<int>("maxFEDid",779); // default 779
  dqmOnly = ps.getParameter<bool>("dqmOnly"); // default: false
  performDataIntegrityMonitor = unpackerParameters.getUntrackedParameter<bool>("performDataIntegrityMonitor",false); // default: false
  
  if(!dqmOnly) {
    produces<DTDigiCollection>();
    produces<DTLocalTriggerCollection>();
  }
  if(performDataIntegrityMonitor) {
    produces<std::vector<DTDDUData> >();
    produces<std::vector<std::vector<DTROS25Data> > >();
  }
}

DTUnpackingModule::~DTUnpackingModule(){
  delete unpacker;
}

void DTUnpackingModule::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<std::string>("dataType","DDU");
  desc.add<edm::InputTag>("inputLabel",edm::InputTag("rawDataCollector"));
  desc.add<bool>("useStandardFEDid",true);
  desc.addUntracked<int>("minFEDid",770);
  desc.addUntracked<int>("maxFEDid",779);
  desc.addOptional<bool>("fedbyType");  // never used, only kept here for back-compatibility
  {
    edm::ParameterSetDescription psd0;
    psd0.addUntracked<bool>("debug",false);
    {
      edm::ParameterSetDescription psd1;
      psd1.addUntracked<bool>("writeSC",true);
      psd1.addUntracked<bool>("readingDDU",true);
      psd1.addUntracked<bool>("performDataIntegrityMonitor",false);
      psd1.addUntracked<bool>("readDDUIDfromDDU",true);
      psd1.addUntracked<bool>("debug",false);
      psd1.addUntracked<bool>("localDAQ",false);
      psd0.add<edm::ParameterSetDescription>("rosParameters",psd1);
    }
    psd0.addUntracked<bool>("performDataIntegrityMonitor",false);
    psd0.addUntracked<bool>("localDAQ",false);
    desc.add<edm::ParameterSetDescription>("readOutParameters",psd0);
  }
  desc.add<bool>("dqmOnly",false);
  descriptions.add("dtUnpackingModule",desc);
}

void DTUnpackingModule::produce(Event & e, const EventSetup& context){

  Handle<FEDRawDataCollection> rawdata;
  e.getByToken(inputLabel, rawdata);

  if(!rawdata.isValid()){
    LogError("DTUnpackingModule::produce") << " unable to get raw data from the event" << endl;
    return;
  }

  // Get the mapping from the setup
  ESHandle<DTReadOutMapping> mapping;
  context.get<DTReadOutMappingRcd>().get(mapping);
  
  // Create the result i.e. the collections of MB Digis and SC local triggers
  auto detectorProduct = std::make_unique<DTDigiCollection>();
  auto triggerProduct = std::make_unique<DTLocalTriggerCollection>();

  auto dduProduct = std::make_unique<std::vector<DTDDUData>>();
  auto ros25Product = std::make_unique<DTROS25Collection>();
  
  // Loop over the DT FEDs
  int FEDIDmin = 0, FEDIDMax = 0;
  if (useStandardFEDid_){
    FEDIDmin = FEDNumbering::MINDTFEDID;
    FEDIDMax = FEDNumbering::MAXDTFEDID;
  }
  else {
    FEDIDmin = minFEDid_;
    FEDIDMax = maxFEDid_;
  }
  
  for (int id=FEDIDmin; id<=FEDIDMax; ++id){ 
    const FEDRawData& feddata = rawdata->FEDData(id);
    
    if (feddata.size()){
      // Unpack the data
      unpacker->interpretRawData(reinterpret_cast<const unsigned int*>(feddata.data()), 
                 feddata.size(), id, mapping, detectorProduct, triggerProduct);
      if(performDataIntegrityMonitor) {
        if(dataType == "DDU") {
          dduProduct->push_back(dynamic_cast<DTDDUUnpacker*>(unpacker)->getDDUControlData());
          ros25Product->push_back(dynamic_cast<DTDDUUnpacker*>(unpacker)->getROSsControlData());
        }
        else if(dataType == "ROS25") {
          ros25Product->push_back(dynamic_cast<DTROS25Unpacker*>(unpacker)->getROSsControlData());
        }
      }
    }
  }

  // commit to the event  
  if(!dqmOnly) {
    e.put(std::move(detectorProduct));
    e.put(std::move(triggerProduct));
  }
  if(performDataIntegrityMonitor) {
    e.put(std::move(dduProduct));
    e.put(std::move(ros25Product));
  }
}