#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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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...

edm::ESGetToken < DTReadOutMapping, DTReadOutMappingRcd >	mappingToken_

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<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

The unpacking module for DTs.

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

Definition at line 21 of file DTUnpackingModule.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 34 of file DTUnpackingModule.cc.

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

                                                               : 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
   mappingToken_ = esConsumes<DTReadOutMapping, DTReadOutMappingRcd>();
   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 ( )

override

Destructor.

Definition at line 68 of file DTUnpackingModule.cc.

References unpacker.

68 { delete unpacker; }

DTUnpackingModule::unpacker

DTUnpacker * unpacker

Definition: DTUnpackingModule.h:35

Member Function Documentation

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

static

Definition at line 70 of file DTUnpackingModule.cc.

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

                                                                                    {
   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	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Call the Unpackers and create the digis.

Definition at line 99 of file DTUnpackingModule.cc.

References FEDRawData::data(), dataType, dqmOnly, edm::Event::getByToken(), edm::EventSetup::getHandle(), gpuClustering::id, inputLabel, DTUnpacker::interpretRawData(), edm::HandleBase::isValid(), mappingToken_, FEDNumbering::MAXDTFEDID, maxFEDid_, FEDNumbering::MINDTFEDID, minFEDid_, eostools::move(), performDataIntegrityMonitor, edm::Event::put(), FEDRawData::size(), unpacker, and useStandardFEDid_.

                                                                    {
   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.getHandle(mappingToken_);
 
   // 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));
   }
 }