EcalRawToDigi Class Reference

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

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

Detailed Description

Definition at line 41 of file EcalRawToDigi.h.

Constructor & Destructor Documentation

EcalRawToDigi()

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

explicit

Class constructor

Definition at line 18 of file EcalRawToDigi.cc.

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

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

~EcalRawToDigi()

EcalRawToDigi::~EcalRawToDigi ( )

override

Class destructor

Definition at line 500 of file EcalRawToDigi.cc.

                              {
  //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_;
}

References myMap_, and theUnpacker_.

Member Function Documentation

beginRun()

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

override

Definition at line 276 of file EcalRawToDigi.cc.

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

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

fillDescriptions()

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

static

Definition at line 232 of file EcalRawToDigi.cc.

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

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

produce()

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

override

Functions that are called by framework at each event

Definition at line 289 of file EcalRawToDigi.cc.

                                                                {
  //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
  //}
}

References edm::ESWatcher< T >::check(), FEDRawData::data(), data, dataToken_, EcalElectronicsMapper::deletePointers(), MillePedeFileConverter_cfg::e, EMPTYEVENTSIZE, FEDRawDataCollection::FEDData(), fedsToken_, fedUnpackList_, feUnpacking_, spr::find(), first_, edm::EventSetup::get(), get, EcalElectronicsMapper::getActiveSM(), EcalListOfFEDS::GetList(), headerUnpacking_, mps_fire::i, LogDebug, memUnpacking_, eostools::move(), myMap_, edm::ESHandle< T >::product(), put_, REGIONAL_, EcalElectronicsMapper::resetPointers(), EcalElectronicsMapper::setActiveDCC(), DCCDataUnpacker::setDccHeadersCollection(), DCCDataUnpacker::setEBDigisCollection(), DCCDataUnpacker::setEBSrFlagsCollection(), EcalElectronicsMapper::setEcalElectronicsMapping(), DCCDataUnpacker::setEcalPSsCollection(), DCCDataUnpacker::setEcalTpsCollection(), DCCDataUnpacker::setEEDigisCollection(), DCCDataUnpacker::setEESrFlagsCollection(), DCCDataUnpacker::setInvalidBlockLengthsCollection(), DCCDataUnpacker::setInvalidChIdsCollection(), DCCDataUnpacker::setInvalidEEChIdsCollection(), DCCDataUnpacker::setInvalidEEGainsCollection(), DCCDataUnpacker::setInvalidEEGainsSwitchCollection(), DCCDataUnpacker::setInvalidGainsCollection(), DCCDataUnpacker::setInvalidGainsSwitchCollection(), DCCDataUnpacker::setInvalidMemBlockSizesCollection(), DCCDataUnpacker::setInvalidMemChIdsCollection(), DCCDataUnpacker::setInvalidMemGainsCollection(), DCCDataUnpacker::setInvalidMemTtIdsCollection(), DCCDataUnpacker::setInvalidTTIdsCollection(), DCCDataUnpacker::setInvalidZSXtalIdsCollection(), DCCDataUnpacker::setPnDiodeDigisCollection(), FEDRawData::size(), srpUnpacking_, tccUnpacking_, theUnpacker_, DCCDataUnpacker::unpack(), and watcher_.

Member Data Documentation

dataToken_

edm::EDGetTokenT<FEDRawDataCollection> EcalRawToDigi::dataToken_

private

Definition at line 85 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

fedsToken_

edm::EDGetTokenT<EcalListOfFEDS> EcalRawToDigi::fedsToken_

private

Definition at line 86 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

fedUnpackList_

std::vector<int> EcalRawToDigi::fedUnpackList_

private

Definition at line 66 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

feIdCheck_

bool EcalRawToDigi::feIdCheck_

private

Definition at line 80 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi().

feUnpacking_

bool EcalRawToDigi::feUnpacking_

private

Definition at line 77 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

first_

bool EcalRawToDigi::first_

private

Definition at line 82 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

forceToKeepFRdata_

bool EcalRawToDigi::forceToKeepFRdata_

private

Definition at line 81 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi().

headerUnpacking_

bool EcalRawToDigi::headerUnpacking_

private

Definition at line 74 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

memUnpacking_

bool EcalRawToDigi::memUnpacking_

private

Definition at line 78 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

myMap_

EcalElectronicsMapper* EcalRawToDigi::myMap_

private

Definition at line 92 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), produce(), and ~EcalRawToDigi().

nevts_

unsigned int EcalRawToDigi::nevts_

private

Definition at line 97 of file EcalRawToDigi.h.

numbTriggerTSamples_

unsigned int EcalRawToDigi::numbTriggerTSamples_

private

Definition at line 72 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi().

numbXtalTSamples_

unsigned int EcalRawToDigi::numbXtalTSamples_

private

Definition at line 71 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi().

orderedDCCIdList_

std::vector<int> EcalRawToDigi::orderedDCCIdList_

private

Definition at line 69 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi().

orderedFedUnpackList_

std::vector<int> EcalRawToDigi::orderedFedUnpackList_

private

Definition at line 68 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi().

put_

bool EcalRawToDigi::put_

private

Definition at line 83 of file EcalRawToDigi.h.

Referenced by produce().

REGIONAL_

bool EcalRawToDigi::REGIONAL_

private

Definition at line 89 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

RUNNING_TIME_

double EcalRawToDigi::RUNNING_TIME_

private

Definition at line 98 of file EcalRawToDigi.h.

SETUP_TIME_

double EcalRawToDigi::SETUP_TIME_

private

Definition at line 98 of file EcalRawToDigi.h.

srpUnpacking_

bool EcalRawToDigi::srpUnpacking_

private

Definition at line 75 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

syncCheck_

bool EcalRawToDigi::syncCheck_

private

Definition at line 79 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi().

tccUnpacking_

bool EcalRawToDigi::tccUnpacking_

private

Definition at line 76 of file EcalRawToDigi.h.

Referenced by EcalRawToDigi(), and produce().

theUnpacker_

DCCDataUnpacker* EcalRawToDigi::theUnpacker_

private

Definition at line 95 of file EcalRawToDigi.h.

Referenced by beginRun(), EcalRawToDigi(), produce(), and ~EcalRawToDigi().

watcher_

edm::ESWatcher<EcalMappingRcd> EcalRawToDigi::watcher_

Definition at line 62 of file EcalRawToDigi.h.

Referenced by produce().