#include <EcalRawToDigi.h>

Inheritance diagram for EcalRawToDigi:

Public Member Functions
void	beginRun (const edm::Run &run, const edm::EventSetup &es) override

	EcalRawToDigi (const edm::ParameterSet &ps)

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

	~EcalRawToDigi () override

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

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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)

Public Attributes
edm::ESWatcher< EcalMappingRcd >	watcher_

Private Attributes
edm::EDGetTokenT< FEDRawDataCollection >	dataToken_

edm::EDGetTokenT< EcalListOfFEDS >	fedsToken_

std::vector< int >	fedUnpackList_

bool	feIdCheck_

bool	feUnpacking_

bool	first_

bool	forceToKeepFRdata_

bool	headerUnpacking_

bool	memUnpacking_

EcalElectronicsMapper *	myMap_

unsigned int	nevts_

unsigned int	numbTriggerTSamples_

unsigned int	numbXtalTSamples_

std::vector< int >	orderedDCCIdList_

std::vector< int >	orderedFedUnpackList_

bool	put_

bool	REGIONAL_

double	RUNNING_TIME_

double	SETUP_TIME_

bool	srpUnpacking_

bool	syncCheck_

bool	tccUnpacking_

DCCDataUnpacker *	theUnpacker_

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
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

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

Definition at line 41 of file EcalRawToDigi.h.

Constructor & Destructor Documentation

EcalRawToDigi::EcalRawToDigi ( const edm::ParameterSet & ps )

explicit

Class constructor

Definition at line 18 of file EcalRawToDigi.cc.

References dataToken_, fedsToken_, fedUnpackList_, feIdCheck_, feUnpacking_, first_, forceToKeepFRdata_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), headerUnpacking_, mps_fire::i, LogDebug, FEDNumbering::MAXECALFEDID, memUnpacking_, FEDNumbering::MINECALFEDID, myMap_, numbTriggerTSamples_, numbXtalTSamples_, orderedDCCIdList_, orderedFedUnpackList_, convertSQLitetoXML_cfg::output, REGIONAL_, DCCDataUnpacker::silentMode_, srpUnpacking_, syncCheck_, tccUnpacking_, and theUnpacker_.

                                                        :
   
   //define the list of FED to be unpacked
   fedUnpackList_(conf.getParameter<std::vector<int> >("FEDs")),
 
   //define the ordered FED list
   orderedFedUnpackList_(conf.getParameter<std::vector<int> >("orderedFedList")),
 
   //define the ordered DCCId list
   orderedDCCIdList_(conf.getParameter<std::vector<int> >("orderedDCCIdList")),
 
   //get number of Xtal Time Samples
   numbXtalTSamples_(conf.getParameter<int>("numbXtalTSamples")),
 
   //Get number of Trigger Time Samples
   numbTriggerTSamples_(conf.getParameter<int>("numbTriggerTSamples")),
   
   //See if header unpacking is enabled
   headerUnpacking_(conf.getParameter<bool>("headerUnpacking")),
  
   //See if srp unpacking is enabled
   srpUnpacking_(conf.getParameter<bool>("srpUnpacking")),
   
   //See if tcc unpacking is enabled
   tccUnpacking_(conf.getParameter<bool>("tccUnpacking")),
   
   //See if fe unpacking is enabled
   feUnpacking_(conf.getParameter<bool>("feUnpacking")),
   
   //See if fe unpacking is enabled for mem box
   memUnpacking_(conf.getParameter<bool>("memUnpacking")), 
 
   //See if syncCheck is enabled
   syncCheck_(conf.getParameter<bool>("syncCheck")), 
 
   //See if feIdCheck is enabled
   feIdCheck_(conf.getParameter<bool>("feIdCheck")),
 
   // See if we want to keep data even if we have a mismatch between SR decision and block length
   forceToKeepFRdata_(conf.getParameter<bool>("forceToKeepFRData")),
 
   
   put_(conf.getParameter<bool>("eventPut")),
   
 
 
   REGIONAL_(conf.getParameter<bool>("DoRegional")),
 
 
 
   myMap_(nullptr),
   
   theUnpacker_(nullptr)
 
 {
   
   first_ = true;
   DCCDataUnpacker::silentMode_ = conf.getUntrackedParameter<bool>("silentMode",false) ;
   
   if( numbXtalTSamples_ <6 || numbXtalTSamples_>64 || (numbXtalTSamples_-2)%4 ){
     std::ostringstream output;
     output      <<"\n Unsuported number of xtal time samples : "<<numbXtalTSamples_
                 <<"\n Valid Number of xtal time samples are : 6,10,14,18,...,62"; 
     edm::LogError("IncorrectConfiguration")<< output.str();
     // todo : throw an execption
   }
   
   if( numbTriggerTSamples_ !=1 && numbTriggerTSamples_ !=4 && numbTriggerTSamples_ !=8  ){
     std::ostringstream output;
     output      <<"\n Unsuported number of trigger time samples : "<<numbTriggerTSamples_
                 <<"\n Valid number of trigger time samples are :  1, 4 or 8"; 
     edm::LogError("IncorrectConfiguration")<< output.str();
     // todo : throw an execption
   }
   
   //NA : testing
   //nevts_=0;
   //RUNNING_TIME_=0;
 
   // if there are FEDs specified to unpack fill the vector of the fedUnpackList_
   // else fill with the entire ECAL fed range (600-670)
   if (fedUnpackList_.empty()) 
     for (int i=FEDNumbering::MINECALFEDID; i<=FEDNumbering::MAXECALFEDID; i++)
       fedUnpackList_.push_back(i);
 
   //print the FEDs to unpack to the logger
   std::ostringstream loggerOutput_;
   if(!fedUnpackList_.empty()){
     for (unsigned int i=0; i<fedUnpackList_.size(); i++) 
       loggerOutput_ << fedUnpackList_[i] << " ";
     edm::LogInfo("EcalRawToDigi") << "EcalRawToDigi will unpack FEDs ( " << loggerOutput_.str() << ")";
     LogDebug("EcalRawToDigi") << "EcalRawToDigi will unpack FEDs ( " << loggerOutput_.str() << ")";
   }
   
   edm::LogInfo("EcalRawToDigi")
     <<"\n ECAL RawToDigi configuration:"
     <<"\n Header  unpacking is "<<headerUnpacking_
     <<"\n SRP Bl. unpacking is "<<srpUnpacking_
     <<"\n TCC Bl. unpacking is "<<tccUnpacking_  
     <<"\n FE  Bl. unpacking is "<<feUnpacking_
     <<"\n MEM Bl. unpacking is "<<memUnpacking_
     <<"\n sync check is "<<syncCheck_
     <<"\n feID check is "<<feIdCheck_
     <<"\n force keep FR data is "<<forceToKeepFRdata_
     <<"\n";
 
   edm::InputTag dataLabel = conf.getParameter<edm::InputTag>("InputLabel");
   edm::InputTag fedsLabel = conf.getParameter<edm::InputTag>("FedLabel");
 
   // Producer products :
   produces<EBDigiCollection>("ebDigis"); 
   produces<EEDigiCollection>("eeDigis");
   produces<EBSrFlagCollection>();
   produces<EESrFlagCollection>();
   produces<EcalRawDataCollection>();
   produces<EcalPnDiodeDigiCollection>();
   produces<EcalTrigPrimDigiCollection>("EcalTriggerPrimitives");
   produces<EcalPSInputDigiCollection>("EcalPseudoStripInputs");
   
   // Integrity for xtal data
   produces<EBDetIdCollection>("EcalIntegrityGainErrors");
   produces<EBDetIdCollection>("EcalIntegrityGainSwitchErrors");
   produces<EBDetIdCollection>("EcalIntegrityChIdErrors");
 
   // Integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
   produces<EEDetIdCollection>("EcalIntegrityGainErrors");
   produces<EEDetIdCollection>("EcalIntegrityGainSwitchErrors");
   produces<EEDetIdCollection>("EcalIntegrityChIdErrors");
 
   // Integrity Errors
   produces<EcalElectronicsIdCollection>("EcalIntegrityTTIdErrors");
   produces<EcalElectronicsIdCollection>("EcalIntegrityZSXtalIdErrors");
   produces<EcalElectronicsIdCollection>("EcalIntegrityBlockSizeErrors");
  
   // Mem channels' integrity
   produces<EcalElectronicsIdCollection>("EcalIntegrityMemTtIdErrors");
   produces<EcalElectronicsIdCollection>("EcalIntegrityMemBlockSizeErrors");
   produces<EcalElectronicsIdCollection>("EcalIntegrityMemChIdErrors");
   produces<EcalElectronicsIdCollection>("EcalIntegrityMemGainErrors");
 
   dataToken_=consumes<FEDRawDataCollection>(dataLabel);
   if (REGIONAL_){
       fedsToken_=consumes<EcalListOfFEDS>(fedsLabel);
   }
 
   // Build a new Electronics mapper and parse default map file
   myMap_ = new EcalElectronicsMapper(numbXtalTSamples_,numbTriggerTSamples_);
 
   // in case of external  tsext file (deprecated by HLT environment) 
   //  bool readResult = myMap_->readDCCMapFile(conf.getParameter<std::string>("DCCMapFile",""));
 
   // use two arrays from cfg to establish DCCId:FedId. If they are empy, than use hard coded correspondence 
   bool readResult = myMap_->makeMapFromVectors(orderedFedUnpackList_, orderedDCCIdList_);
   // myMap::makeMapFromVectors() returns "true" always
   // need to be fixed?
 
   if(!readResult){
     edm::LogWarning("IncorrectConfiguration")
       << "Arrays orderedFedList and orderedDCCIdList are emply. "
          "Hard coded correspondence for DCCId:FedId will be used.";
     // edm::LogError("EcalRawToDigi")<<"\n unable to read file : "
     //   <<conf.getParameter<std::string>("DCCMapFile");
   }
   
   // Build a new ECAL DCC data unpacker
   theUnpacker_ = new DCCDataUnpacker(myMap_,headerUnpacking_,srpUnpacking_,tccUnpacking_,feUnpacking_,memUnpacking_,syncCheck_,feIdCheck_,forceToKeepFRdata_);
    
 }

EcalRawToDigi::~EcalRawToDigi ( )

override

Class destructor

Definition at line 528 of file EcalRawToDigi.cc.

References myMap_, and theUnpacker_.

 {
   
   //cout << "EcalDCCUnpackingModule  " << "N events        " << (nevts_-1)<<endl;
   //cout << "EcalDCCUnpackingModule  " << " --- SETUP time " << endl;
   //cout << "EcalDCCUnpackingModule  " << "Time (sys)      " << SETUP_TIME_ << endl;
   //cout << "EcalDCCUnpackingModule  " << "Time in sec.    " << SETUP_TIME_/ CLOCKS_PER_SEC  << endl;
   //cout << "EcalDCCUnpackingModule  " << " --- Per event  " << endl;
   
   //RUNNING_TIME_ = RUNNING_TIME_ / (nevts_-1);
   
   //cout << "EcalDCCUnpackingModule  "<< "Time (sys)      " << RUNNING_TIME_  << endl;
   //cout << "EcalDCCUnpackingModule  "<< "Time in sec.    " << RUNNING_TIME_ / CLOCKS_PER_SEC  << endl;
   
   
   
   if(myMap_      ) delete myMap_;
   if(theUnpacker_) delete theUnpacker_;
   
 }

Member Function Documentation

void EcalRawToDigi::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	es
	)

override

Definition at line 285 of file EcalRawToDigi.cc.

References edm::EventSetup::get(), edm::ESHandle< T >::product(), DCCDataUnpacker::setChannelStatusDB(), and theUnpacker_.

 {
   // channel status database
   edm::ESHandle<EcalChannelStatusMap> pChStatus;
   es.get<EcalChannelStatusRcd>().get(pChStatus);
   theUnpacker_->setChannelStatusDB(pChStatus.product());
   
   // uncomment following line to print list of crystals with bad status
   //edm::ESHandle<EcalElectronicsMapping> pEcalMapping;
   //es.get<EcalMappingRcd>().get(pEcalMapping);
   //const EcalElectronicsMapping* mapping = pEcalMapping.product();
   //printStatusRecords(theUnpacker_, mapping);
 }

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

static

Definition at line 243 of file EcalRawToDigi.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), and mps_fire::i.

                                                                                {
   edm::ParameterSetDescription desc;
   desc.add<bool>("tccUnpacking",true);
   desc.add<edm::InputTag>("FedLabel",edm::InputTag("listfeds"));
   desc.add<bool>("srpUnpacking",true);
   desc.add<bool>("syncCheck",true);
   desc.add<bool>("feIdCheck",true);
   desc.addUntracked<bool>("silentMode",true);
   desc.add<edm::InputTag>("InputLabel",edm::InputTag("rawDataCollector"));
   {
     std::vector<int> temp1;
     unsigned int nvec = 54;
     temp1.reserve(nvec);
     for (unsigned int i=0; i<nvec; i++) temp1.push_back(601+i);
     desc.add<std::vector<int> >("orderedFedList",temp1);
   }
   desc.add<bool>("eventPut",true);
   desc.add<int>("numbTriggerTSamples",1);
   desc.add<int>("numbXtalTSamples",10);
   {
     std::vector<int> temp1;
     unsigned int nvec = 54;
     temp1.reserve(nvec);
     for (unsigned int i=0; i<nvec; i++) temp1.push_back(1+i);
     desc.add<std::vector<int> >("orderedDCCIdList",temp1);
   }
   {
     std::vector<int> temp1;
     unsigned int nvec = 54;
     temp1.reserve(nvec);
     for (unsigned int i=0; i<nvec; i++) temp1.push_back(601+i);
     desc.add<std::vector<int> >("FEDs",temp1);
   }
   desc.add<bool>("DoRegional",false);
   desc.add<bool>("feUnpacking",true);
   desc.add<bool>("forceToKeepFRData",false);
   desc.add<bool>("headerUnpacking",true);
   desc.add<bool>("memUnpacking",true);
   descriptions.add("ecalRawToDigi",desc);
 }

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

override

Functions that are called by framework at each event

Definition at line 300 of file EcalRawToDigi.cc.

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

 {
   
   //double TIME_START = clock();
   //nevts_++; //NUNO
 
 
   if (first_) {
    watcher_.check(es);
    edm::ESHandle< EcalElectronicsMapping > ecalmapping;
    es.get< EcalMappingRcd >().get(ecalmapping);
    myMap_ -> setEcalElectronicsMapping(ecalmapping.product());
    
    first_ = false;
 
   }else{
 
     if ( watcher_.check(es) ) {    
       edm::ESHandle< EcalElectronicsMapping > ecalmapping;
       es.get< EcalMappingRcd >().get(ecalmapping);
       myMap_ -> deletePointers();
       myMap_ -> resetPointers();
       myMap_ -> setEcalElectronicsMapping(ecalmapping.product());
     }
 
   }
 
   // Get list of FEDS :
   std::vector<int> FEDS_to_unpack;
   if (REGIONAL_) {
         edm::Handle<EcalListOfFEDS> listoffeds;
         e.getByToken(fedsToken_, listoffeds);
         FEDS_to_unpack = listoffeds -> GetList();
   }
 
 
 
   // Step A: Get Inputs    
 
   edm::Handle<FEDRawDataCollection> rawdata;  
   e.getByToken(dataToken_,rawdata);
 
 
   // Step B: encapsulate vectors in actual collections and set unpacker pointers
 
   // create the collection of Ecal Digis
   auto productDigisEB = std::make_unique<EBDigiCollection>();
   productDigisEB->reserve(1700);
   theUnpacker_->setEBDigisCollection(&productDigisEB);
   
   // create the collection of Ecal Digis
   auto productDigisEE = std::make_unique<EEDigiCollection>();
   theUnpacker_->setEEDigisCollection(&productDigisEE);
   
   // create the collection for headers
   auto productDccHeaders = std::make_unique<EcalRawDataCollection>();
   theUnpacker_->setDccHeadersCollection(&productDccHeaders); 
 
   // create the collection for invalid gains
   auto productInvalidGains = std::make_unique<EBDetIdCollection>();
   theUnpacker_->setInvalidGainsCollection(&productInvalidGains); 
 
   // create the collection for invalid gain Switch
   auto productInvalidGainsSwitch = std::make_unique<EBDetIdCollection>();
   theUnpacker_->setInvalidGainsSwitchCollection(&productInvalidGainsSwitch);
    
   // create the collection for invalid chids
   auto productInvalidChIds = std::make_unique<EBDetIdCollection>();
   theUnpacker_->setInvalidChIdsCollection(&productInvalidChIds);
   
     
   // create the collection for invalid gains
   auto productInvalidEEGains = std::make_unique<EEDetIdCollection>();
   theUnpacker_->setInvalidEEGainsCollection(&productInvalidEEGains); 
     
   // create the collection for invalid gain Switch
   auto productInvalidEEGainsSwitch = std::make_unique<EEDetIdCollection>();
   theUnpacker_->setInvalidEEGainsSwitchCollection(&productInvalidEEGainsSwitch);
     
   // create the collection for invalid chids
   auto productInvalidEEChIds = std::make_unique<EEDetIdCollection>();
   theUnpacker_->setInvalidEEChIdsCollection(&productInvalidEEChIds);
 
 
   // create the collection for EB srflags       
   auto productEBSrFlags = std::make_unique<EBSrFlagCollection>();
   theUnpacker_->setEBSrFlagsCollection(&productEBSrFlags);
   
   // create the collection for EB srflags       
   auto productEESrFlags = std::make_unique<EESrFlagCollection>();
   theUnpacker_->setEESrFlagsCollection(&productEESrFlags);
 
   // create the collection for ecal trigger primitives
   auto productEcalTps = std::make_unique<EcalTrigPrimDigiCollection>();
   theUnpacker_->setEcalTpsCollection(&productEcalTps);
 
   // create the collection for ecal trigger primitives
   auto productEcalPSs = std::make_unique<EcalPSInputDigiCollection>();
   theUnpacker_->setEcalPSsCollection(&productEcalPSs);
 
   // create the collection for invalid TTIds
   auto productInvalidTTIds = std::make_unique<EcalElectronicsIdCollection>();
   theUnpacker_->setInvalidTTIdsCollection(&productInvalidTTIds);
  
    // create the collection for invalid TTIds
   auto productInvalidZSXtalIds = std::make_unique<EcalElectronicsIdCollection>();
   theUnpacker_->setInvalidZSXtalIdsCollection(&productInvalidZSXtalIds);
 
 
  
   // create the collection for invalid BlockLengths
   auto productInvalidBlockLengths = std::make_unique<EcalElectronicsIdCollection>();
   theUnpacker_->setInvalidBlockLengthsCollection(&productInvalidBlockLengths);
 
   // MEMs Collections
   // create the collection for the Pn Diode Digis
   auto productPnDiodeDigis = std::make_unique<EcalPnDiodeDigiCollection>();
   theUnpacker_->setPnDiodeDigisCollection(&productPnDiodeDigis);
 
   // create the collection for invalid Mem Tt id 
   auto productInvalidMemTtIds = std::make_unique<EcalElectronicsIdCollection>();
   theUnpacker_->setInvalidMemTtIdsCollection(& productInvalidMemTtIds);
   
   // create the collection for invalid Mem Block Size 
   auto productInvalidMemBlockSizes = std::make_unique<EcalElectronicsIdCollection>();
   theUnpacker_->setInvalidMemBlockSizesCollection(& productInvalidMemBlockSizes);
   
   // create the collection for invalid Mem Block Size 
   auto productInvalidMemChIds = std::make_unique<EcalElectronicsIdCollection>();
   theUnpacker_->setInvalidMemChIdsCollection(& productInvalidMemChIds);
  
   // create the collection for invalid Mem Gain Errors 
   auto productInvalidMemGains = std::make_unique<EcalElectronicsIdCollection>();
   theUnpacker_->setInvalidMemGainsCollection(& productInvalidMemGains); 
   //  double TIME_START = clock(); 
   
 
   // Step C: unpack all requested FEDs    
   for (std::vector<int>::const_iterator i=fedUnpackList_.begin(); i!=fedUnpackList_.end(); i++) {
 
     if (REGIONAL_) {
       std::vector<int>::const_iterator fed_it = find(FEDS_to_unpack.begin(), FEDS_to_unpack.end(), *i);
       if (fed_it == FEDS_to_unpack.end()) continue;
     }
 
   
     // get fed raw data and SM id
     const FEDRawData& fedData = rawdata->FEDData(*i);
     const size_t length = fedData.size();
 
     LogDebug("EcalRawToDigi") << "raw data length: " << length ;
     //if data size is not null interpret data
     if ( length >= EMPTYEVENTSIZE ){
       
       if(myMap_->setActiveDCC(*i)){
 
         const int smId = myMap_->getActiveSM();
         LogDebug("EcalRawToDigi") << "Getting FED = " << *i <<"(SM = "<<smId<<")"<<" data size is: " << length;
 
         const uint64_t* data = (uint64_t*) fedData.data();
         theUnpacker_->unpack(data, length, smId, *i);
 
         LogDebug("EcalRawToDigi") <<" in EE :"<<productDigisEE->size()
                                   <<" in EB :"<<productDigisEB->size();
       }
     }
     
   }// loop on FEDs
   
   //if(nevts_>1){   //NUNO
   //  double TIME_END = clock(); //NUNO
   //  RUNNING_TIME_ += TIME_END-TIME_START; //NUNO
   // }
   
   
   // Add collections to the event 
   
   if(put_){
     
     if( headerUnpacking_){ 
       e.put(std::move(productDccHeaders));
     }
     
     if(feUnpacking_){
       productDigisEB->sort();
       e.put(std::move(productDigisEB),"ebDigis");
       productDigisEE->sort();
       e.put(std::move(productDigisEE),"eeDigis");
       e.put(std::move(productInvalidGains),"EcalIntegrityGainErrors");
       e.put(std::move(productInvalidGainsSwitch), "EcalIntegrityGainSwitchErrors");
       e.put(std::move(productInvalidChIds), "EcalIntegrityChIdErrors");
       // EE (leaving for now the same names as in EB)
       e.put(std::move(productInvalidEEGains),"EcalIntegrityGainErrors");
       e.put(std::move(productInvalidEEGainsSwitch), "EcalIntegrityGainSwitchErrors");
       e.put(std::move(productInvalidEEChIds), "EcalIntegrityChIdErrors");
       // EE
       e.put(std::move(productInvalidTTIds),"EcalIntegrityTTIdErrors");
       e.put(std::move(productInvalidZSXtalIds),"EcalIntegrityZSXtalIdErrors");
       e.put(std::move(productInvalidBlockLengths),"EcalIntegrityBlockSizeErrors");
       e.put(std::move(productPnDiodeDigis));
     }
     if(memUnpacking_){
       e.put(std::move(productInvalidMemTtIds),"EcalIntegrityMemTtIdErrors");
       e.put(std::move(productInvalidMemBlockSizes),"EcalIntegrityMemBlockSizeErrors");
       e.put(std::move(productInvalidMemChIds),"EcalIntegrityMemChIdErrors");
       e.put(std::move(productInvalidMemGains),"EcalIntegrityMemGainErrors");
     }
     if(srpUnpacking_){
       e.put(std::move(productEBSrFlags));
       e.put(std::move(productEESrFlags));
     }
     if(tccUnpacking_){
       e.put(std::move(productEcalTps),"EcalTriggerPrimitives");
       e.put(std::move(productEcalPSs),"EcalPseudoStripInputs");
     }
   }
   
 //if(nevts_>1){   //NUNO
 //  double TIME_END = clock(); //NUNO 
 //  RUNNING_TIME_ += TIME_END-TIME_START; //NUNO
 //}
   
 }