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

virtual	~DTUnpackingModule ()
	Destructor. More...

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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(0),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 ( )

virtual

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(), HLT_25ns10e33_v2_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
	)

overridevirtual

Call the Unpackers and create the digis.

Implements edm::stream::EDProducerBase.

Definition at line 110 of file DTUnpackingModule.cc.

References FEDRawData::data(), dataType, dqmOnly, edm::EventSetup::get(), edm::Event::getByToken(), inputLabel, DTUnpacker::interpretRawData(), edm::HandleBase::isValid(), FEDNumbering::MAXDTFEDID, maxFEDid_, FEDNumbering::MINDTFEDID, minFEDid_, performDataIntegrityMonitor, edm::Event::put(), lumiPlot::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_ptr<DTDigiCollection> detectorProduct(new DTDigiCollection);
   auto_ptr<DTLocalTriggerCollection> triggerProduct(new DTLocalTriggerCollection);
 
   auto_ptr<std::vector<DTDDUData> > dduProduct(new std::vector<DTDDUData>);
   auto_ptr<DTROS25Collection> ros25Product(new 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(detectorProduct);
     e.put(triggerProduct);
   }
   if(performDataIntegrityMonitor) {
     e.put(dduProduct);
     e.put(ros25Product);
   }
 }