#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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 ( const edm::ParameterSet & pset )

Constructor.

Definition at line 40 of file DTUnpackingModule.cc.

References dataType, dqmOnly, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), inputLabel, 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
   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 77 of file DTUnpackingModule.cc.

References unpacker.

                                      {
   delete unpacker;
 }

Member Function Documentation

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

static

Definition at line 81 of file DTUnpackingModule.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addUntracked(), 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 110 of file DTUnpackingModule.cc.

References FEDRawData::data(), dataType, dqmOnly, FEDRawDataCollection::FEDData(), edm::EventSetup::get(), edm::Event::getByToken(), triggerObjects_cff::id, inputLabel, DTUnpacker::interpretRawData(), edm::HandleBase::isValid(), taus_updatedMVAIds_cff::mapping, FEDNumbering::MAXDTFEDID, maxFEDid_, FEDNumbering::MINDTFEDID, minFEDid_, eostools::move(), performDataIntegrityMonitor, edm::Event::put(), matplotRender::rawdata, FEDRawData::size(), unpacker, and useStandardFEDid_.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

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