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 <stdio.h>                     
#include <stdint.h>
#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