DCCDataUnpacker.h

Go to the documentation of this file.

#ifndef DCCDATAUNPACKER_HH
#define DCCDATAUNPACKER_HH

/*
 *\ Class DCCDataUnpacker
 *
 * This class takes care of unpacking ECAL's raw data info.
 * A gateway for all blocks unpackers and committing collections to the Event
 * DCCEBEventBlock and DCCEEEventBlock are used here
 *
 * \file DCCDataUnpacker.h
 *
 * \author N. Almeida
 * \author G. Franzoni
 *
*/
//C++
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <cstdio>
#include <cstdint>
#include <atomic>

//DATA DECODER

#include "DCCEventBlock.h"

#include <DataFormats/EcalDigi/interface/EcalDigiCollections.h>
#include <DataFormats/EcalDigi/interface/EcalPnDiodeDigi.h>

#include <DataFormats/EcalDetId/interface/EcalDetIdCollections.h>
#include <DataFormats/EcalRawData/interface/EcalRawDataCollections.h>

#include <DataFormats/FEDRawData/interface/FEDRawData.h>
#include <DataFormats/FEDRawData/interface/FEDNumbering.h>
#include <DataFormats/FEDRawData/interface/FEDRawDataCollection.h>

#include "CondFormats/EcalObjects/interface/EcalChannelStatus.h"

class EcalElectronicsMapper;
class DCCEventBlock;
class DCCEBEventBlock;
class DCCEEEventBlock;
class EcalRawToDigi;

class DCCDataUnpacker {
public:
  DCCDataUnpacker(EcalElectronicsMapper*,
                  bool hU,
                  bool srpU,
                  bool tccU,
                  bool feU,
                  bool memU,
                  bool syncCheck,
                  bool feIdCheck,
                  bool forceToKeepFRdata);
  ~DCCDataUnpacker();
  void unpack(const uint64_t* buffer, size_t bufferSize, unsigned int smId, unsigned int fedId);

  void setEBDigisCollection(std::unique_ptr<EBDigiCollection>* x) { ebDigis_ = x; }

  void setEEDigisCollection(std::unique_ptr<EEDigiCollection>* x) { eeDigis_ = x; }

  void setDccHeadersCollection(std::unique_ptr<EcalRawDataCollection>* x) { dccHeaders_ = x; }

  void setEBSrFlagsCollection(std::unique_ptr<EBSrFlagCollection>* x) { ebSrFlags_ = x; }

  void setEESrFlagsCollection(std::unique_ptr<EESrFlagCollection>* x) { eeSrFlags_ = x; }

  void setEcalTpsCollection(std::unique_ptr<EcalTrigPrimDigiCollection>* x) { ecalTps_ = x; }

  void setEcalPSsCollection(std::unique_ptr<EcalPSInputDigiCollection>* x) { ecalPSs_ = x; }

  void setInvalidGainsCollection(std::unique_ptr<EBDetIdCollection>* x) { invalidGains_ = x; }

  void setInvalidGainsSwitchCollection(std::unique_ptr<EBDetIdCollection>* x) { invalidGainsSwitch_ = x; }

  void setInvalidChIdsCollection(std::unique_ptr<EBDetIdCollection>* x) { invalidChIds_ = x; }

  // EE
  void setInvalidEEGainsCollection(std::unique_ptr<EEDetIdCollection>* x) { invalidEEGains_ = x; }

  void setInvalidEEGainsSwitchCollection(std::unique_ptr<EEDetIdCollection>* x) { invalidEEGainsSwitch_ = x; }

  void setInvalidEEChIdsCollection(std::unique_ptr<EEDetIdCollection>* x) { invalidEEChIds_ = x; }
  // EE

  void setInvalidTTIdsCollection(std::unique_ptr<EcalElectronicsIdCollection>* x) { invalidTTIds_ = x; }

  void setInvalidZSXtalIdsCollection(std::unique_ptr<EcalElectronicsIdCollection>* x) { invalidZSXtalIds_ = x; }

  void setInvalidBlockLengthsCollection(std::unique_ptr<EcalElectronicsIdCollection>* x) { invalidBlockLengths_ = x; }

  void setPnDiodeDigisCollection(std::unique_ptr<EcalPnDiodeDigiCollection>* x) { pnDiodeDigis_ = x; }

  void setInvalidMemTtIdsCollection(std::unique_ptr<EcalElectronicsIdCollection>* x) { invalidMemTtIds_ = x; }

  void setInvalidMemBlockSizesCollection(std::unique_ptr<EcalElectronicsIdCollection>* x) { invalidMemBlockSizes_ = x; }

  void setInvalidMemChIdsCollection(std::unique_ptr<EcalElectronicsIdCollection>* x) { invalidMemChIds_ = x; }

  void setInvalidMemGainsCollection(std::unique_ptr<EcalElectronicsIdCollection>* x) { invalidMemGains_ = x; }

  std::unique_ptr<EBDigiCollection>* ebDigisCollection() { return ebDigis_; }

  std::unique_ptr<EEDigiCollection>* eeDigisCollection() { return eeDigis_; }

  std::unique_ptr<EcalTrigPrimDigiCollection>* ecalTpsCollection() { return ecalTps_; }

  std::unique_ptr<EcalPSInputDigiCollection>* ecalPSsCollection() { return ecalPSs_; }

  std::unique_ptr<EBSrFlagCollection>* ebSrFlagsCollection() { return ebSrFlags_; }

  std::unique_ptr<EESrFlagCollection>* eeSrFlagsCollection() { return eeSrFlags_; }

  std::unique_ptr<EcalRawDataCollection>* dccHeadersCollection() { return dccHeaders_; }

  std::unique_ptr<EBDetIdCollection>* invalidGainsCollection() { return invalidGains_; }

  std::unique_ptr<EBDetIdCollection>* invalidGainsSwitchCollection() { return invalidGainsSwitch_; }

  std::unique_ptr<EBDetIdCollection>* invalidChIdsCollection() { return invalidChIds_; }

  //EE
  std::unique_ptr<EEDetIdCollection>* invalidEEGainsCollection() { return invalidEEGains_; }

  std::unique_ptr<EEDetIdCollection>* invalidEEGainsSwitchCollection() { return invalidEEGainsSwitch_; }

  std::unique_ptr<EEDetIdCollection>* invalidEEChIdsCollection() { return invalidEEChIds_; }
  //EE

  std::unique_ptr<EcalElectronicsIdCollection>* invalidTTIdsCollection() { return invalidTTIds_; }

  std::unique_ptr<EcalElectronicsIdCollection>* invalidZSXtalIdsCollection() { return invalidZSXtalIds_; }

  std::unique_ptr<EcalElectronicsIdCollection>* invalidBlockLengthsCollection() { return invalidBlockLengths_; }

  std::unique_ptr<EcalElectronicsIdCollection>* invalidMemTtIdsCollection() { return invalidMemTtIds_; }

  std::unique_ptr<EcalElectronicsIdCollection>* invalidMemBlockSizesCollection() { return invalidMemBlockSizes_; }

  std::unique_ptr<EcalElectronicsIdCollection>* invalidMemChIdsCollection() { return invalidMemChIds_; }

  std::unique_ptr<EcalElectronicsIdCollection>* invalidMemGainsCollection() { return invalidMemGains_; }

  std::unique_ptr<EcalPnDiodeDigiCollection>* pnDiodeDigisCollection() { return pnDiodeDigis_; }

  const EcalElectronicsMapper* electronicsMapper() const { return electronicsMapper_; }

  void setChannelStatusDB(const EcalChannelStatusMap* chdb) { chdb_ = chdb; }
  // return status of given crystal
  // https://twiki.cern.ch/twiki/bin/view/CMS/EcalChannelStatus#Assigning_Channel_status
  uint16_t getChannelStatus(const DetId& id) const;
  // return low 5 bits of status word
  uint16_t getChannelValue(const DetId& id) const;
  uint16_t getChannelValue(const int fed, const int ccu, const int strip, const int xtal) const;
  // return status of given CCU
  uint16_t getCCUValue(const int fed, const int ccu) const;

  DCCEventBlock* currentEvent() { return currentEvent_; }

  static std::atomic<bool> silentMode_;

protected:
  // Data collections pointers
  std::unique_ptr<EBDigiCollection>* ebDigis_;
  std::unique_ptr<EEDigiCollection>* eeDigis_;
  std::unique_ptr<EcalTrigPrimDigiCollection>* ecalTps_;
  std::unique_ptr<EcalPSInputDigiCollection>* ecalPSs_;
  std::unique_ptr<EcalRawDataCollection>* dccHeaders_;
  std::unique_ptr<EBDetIdCollection>* invalidGains_;
  std::unique_ptr<EBDetIdCollection>* invalidGainsSwitch_;
  std::unique_ptr<EBDetIdCollection>* invalidChIds_;
  //EE
  std::unique_ptr<EEDetIdCollection>* invalidEEGains_;
  std::unique_ptr<EEDetIdCollection>* invalidEEGainsSwitch_;
  std::unique_ptr<EEDetIdCollection>* invalidEEChIds_;
  //EE
  std::unique_ptr<EBSrFlagCollection>* ebSrFlags_;
  std::unique_ptr<EESrFlagCollection>* eeSrFlags_;
  std::unique_ptr<EcalElectronicsIdCollection>* invalidTTIds_;
  std::unique_ptr<EcalElectronicsIdCollection>* invalidZSXtalIds_;
  std::unique_ptr<EcalElectronicsIdCollection>* invalidBlockLengths_;

  std::unique_ptr<EcalElectronicsIdCollection>* invalidMemTtIds_;
  std::unique_ptr<EcalElectronicsIdCollection>* invalidMemBlockSizes_;
  std::unique_ptr<EcalElectronicsIdCollection>* invalidMemChIds_;
  std::unique_ptr<EcalElectronicsIdCollection>* invalidMemGains_;
  std::unique_ptr<EcalPnDiodeDigiCollection>* pnDiodeDigis_;

  EcalElectronicsMapper* electronicsMapper_;
  const EcalChannelStatusMap* chdb_;
  DCCEventBlock* currentEvent_;
  DCCEBEventBlock* ebEventBlock_;
  DCCEEEventBlock* eeEventBlock_;
};

#endif