SiStripRawToDigiUnpacker.h

Go to the documentation of this file.

#ifndef EventFilter_SiStripRawToDigi_SiStripRawToDigiUnpacker_H
#define EventFilter_SiStripRawToDigi_SiStripRawToDigiUnpacker_H

#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/DetId/interface/DetIdCollection.h"
#include "DataFormats/SiStripCommon/interface/SiStripConstants.h"
#include "EventFilter/SiStripRawToDigi/interface/SiStripFEDBuffer.h"
#include "boost/cstdint.hpp"
#include <iostream>
#include <string>
#include <vector>
 
namespace sistrip { class RawToClustersLazyUnpacker; }
namespace sistrip { class RawToDigiUnpacker; }

class FEDRawDataCollection;
class FEDRawData;
class SiStripDigi;
class SiStripRawDigi;
class SiStripEventSummary;
class SiStripFedCabling;

namespace sistrip {
  
  class dso_hidden RawToDigiUnpacker {
    
    friend class RawToClustersLazyUnpacker;
    
  public:
    
    typedef edm::DetSetVector<SiStripDigi> Digis;
    typedef edm::DetSetVector<SiStripRawDigi> RawDigis;
    
    RawToDigiUnpacker( int16_t appended_bytes, int16_t fed_buffer_dump_freq, int16_t fed_event_dump_freq, int16_t trigger_fed_id, bool using_fed_key,
                       bool unpack_bad_channels, bool mark_missing_feds, const uint32_t errorThreshold ); 
    
    ~RawToDigiUnpacker();
    
    void createDigis( const SiStripFedCabling&, const FEDRawDataCollection&, SiStripEventSummary&, RawDigis& scope_mode, RawDigis& virgin_raw, RawDigis& proc_raw, Digis& zero_suppr, DetIdCollection&, RawDigis& common_mode );
    
    void triggerFed( const FEDRawDataCollection&, SiStripEventSummary&, const uint32_t& event );
    
    void locateStartOfFedBuffer( const uint16_t& fed_id, const FEDRawData& input, FEDRawData& output );
    
    inline void quiet( bool );
    
    inline void useDaqRegister( bool );

    inline void extractCm( bool );
    
    inline void doFullCorruptBufferChecks( bool );

    inline void doAPVEmulatorCheck( bool );

    inline void legacy( bool );

  private:
    
    void update( RawDigis& scope_mode, RawDigis& virgin_raw, RawDigis& proc_raw, Digis& zero_suppr, RawDigis& common_mode );
    
    RawToDigiUnpacker();
    
    void updateEventSummary( const sistrip::FEDBuffer&, SiStripEventSummary& );
    
    inline void readoutOrder( uint16_t& physical_order, uint16_t& readout_order );
    
    inline void physicalOrder( uint16_t& readout_order, uint16_t& physical_order ); 
    
    inline sistrip::FedBufferFormat fedBufferFormat( const uint16_t& register_value );
    
    inline sistrip::FedReadoutMode fedReadoutMode( const uint16_t& register_value );
    
    static void dumpRawData( uint16_t fed_id, const FEDRawData&, std::stringstream& );
    
    void handleException( std::string method_name, std::string extra_info = "" );
    
    void cleanupWorkVectors();
    
    class Registry {
    public:
      Registry(uint32_t aDetid, uint16_t firstStrip, size_t indexInVector, uint16_t numberOfDigis) : 
    detid(aDetid), first(firstStrip), index(indexInVector), length(numberOfDigis) {}
      bool operator<(const Registry &other) const {return (detid != other.detid ? detid < other.detid : first < other.first);}
      uint32_t detid;
      uint16_t first;
      size_t index;
      uint16_t length;
    };
    
    int16_t headerBytes_;
    int16_t fedBufferDumpFreq_;
    int16_t fedEventDumpFreq_;
    int16_t triggerFedId_;
    bool useFedKey_;
    bool unpackBadChannels_;
    bool markMissingFeds_;
    
    uint32_t event_;
    bool once_;
    bool first_;
    bool useDaqRegister_;
    bool quiet_;
    bool extractCm_;    
    bool doFullCorruptBufferChecks_;
    bool doAPVEmulatorCheck_;
    bool legacy_;
    uint32_t errorThreshold_;
    
    std::vector<Registry> zs_work_registry_;
    std::vector<Registry> virgin_work_registry_;
    std::vector<Registry> scope_work_registry_;
    std::vector<Registry> proc_work_registry_;
    std::vector<Registry> cm_work_registry_;
    
    std::vector<SiStripDigi> zs_work_digis_;
    std::vector<SiStripRawDigi> virgin_work_digis_; 
    std::vector<SiStripRawDigi> scope_work_digis_; 
    std::vector<SiStripRawDigi> proc_work_digis_;
    std::vector<SiStripRawDigi> cm_work_digis_;
  };
  
}

void sistrip::RawToDigiUnpacker::readoutOrder( uint16_t& physical_order, uint16_t& readout_order ) 
{
  readout_order = ( 4*((static_cast<uint16_t>((static_cast<float>(physical_order)/8.0)))%4) + static_cast<uint16_t>(static_cast<float>(physical_order)/32.0) + 16*(physical_order%8) );
}

void sistrip::RawToDigiUnpacker::physicalOrder( uint16_t& readout_order, uint16_t& physical_order ) 
{
  physical_order = ( (32 * (readout_order%4)) + (8 * static_cast<uint16_t>(static_cast<float>(readout_order)/4.0)) - (31 * static_cast<uint16_t>(static_cast<float>(readout_order)/16.0)) );
}

sistrip::FedBufferFormat sistrip::RawToDigiUnpacker::fedBufferFormat( const uint16_t& register_value ) 
{
  if ( (register_value&0xF) == 0x1 ) { return sistrip::FULL_DEBUG_FORMAT; }
  else if ( (register_value&0xF) == 0x2 ) { return sistrip::APV_ERROR_FORMAT; }
  else if ( (register_value&0xF) == 0x0 ) { return sistrip::UNDEFINED_FED_BUFFER_FORMAT; }
  else { return sistrip::UNKNOWN_FED_BUFFER_FORMAT; }
}

sistrip::FedReadoutMode sistrip::RawToDigiUnpacker::fedReadoutMode( const uint16_t& register_value ) 
{
  return static_cast<sistrip::FedReadoutMode>(register_value&0xF);
}

void sistrip::RawToDigiUnpacker::quiet( bool quiet ) { quiet_ = quiet; }

void sistrip::RawToDigiUnpacker::useDaqRegister( bool use ) { useDaqRegister_ =  use; }

void sistrip::RawToDigiUnpacker::extractCm( bool extract_cm ) { extractCm_ = extract_cm; }

void sistrip::RawToDigiUnpacker::doFullCorruptBufferChecks( bool do_full_corrupt_buffer_checks ) { doFullCorruptBufferChecks_ = do_full_corrupt_buffer_checks; }

void sistrip::RawToDigiUnpacker::doAPVEmulatorCheck( bool do_APVEmulator_check) { doAPVEmulatorCheck_ = do_APVEmulator_check; }

void sistrip::RawToDigiUnpacker::legacy( bool legacy ) { legacy_ = legacy; }

#endif // EventFilter_SiStripRawToDigi_SiStripRawToDigiUnpacker_H