#include <DTUnpackingModule.h>

Inheritance diagram for DTUnpackingModule:

Public Member Functions
	DTUnpackingModule (const edm::ParameterSet &pset)
	Constructor. More...

void	produce (edm::Event &e, const edm::EventSetup &c) override
	Call the Unpackers and create the digis. More...

	~DTUnpackingModule () override
	Destructor. More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
std::string	dataType

bool	dqmOnly

edm::EDGetTokenT< FEDRawDataCollection >	inputLabel
	if not you need the label More...

int	maxFEDid_

int	minFEDid_
	if not you need to set the range by hand More...

bool	performDataIntegrityMonitor

DTUnpacker *	unpacker

bool	useStandardFEDid_
	do you want to use the standard DT FED ID's, i.e. [770-775]? (why the hell 6??) More...

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

The unpacking module for DTs.

Author: N. Amapane - S. Argiro' - M. Zanetti

Definition at line 18 of file DTUnpackingModule.h.

Constructor & Destructor Documentation

◆ DTUnpackingModule()

DTUnpackingModule::DTUnpackingModule ( const edm::ParameterSet & pset )

Constructor.

Definition at line 36 of file DTUnpackingModule.cc.

                                                               : 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>>>();
   }
 }

References dataType, dqmOnly, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), inputLabel, maxFEDid_, minFEDid_, performDataIntegrityMonitor, unpacker, and useStandardFEDid_.

◆ ~DTUnpackingModule()

DTUnpackingModule::~DTUnpackingModule ( )

override

Destructor.

Definition at line 69 of file DTUnpackingModule.cc.

69 { delete unpacker; }

References unpacker.

Member Function Documentation

◆ fillDescriptions()

void DTUnpackingModule::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 71 of file DTUnpackingModule.cc.

                                                                                    {
   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);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addUntracked(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produce()

void DTUnpackingModule::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Call the Unpackers and create the digis.

Definition at line 100 of file DTUnpackingModule.cc.

                                                                    {
   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));
   }
 }