SiStripFEDSpyBuffer.h

Go to the documentation of this file.

#ifndef DQM_SiStripMonitorHardware_SiStripFEDSpyBuffer_H
#define DQM_SiStripMonitorHardware_SiStripFEDSpyBuffer_H

#include "boost/cstdint.hpp"
#include <string>
#include <ostream>
#include "EventFilter/SiStripRawToDigi/interface/SiStripFEDBufferComponents.h"

namespace sistrip {

  //
  // Constants
  //
  
  static const uint16_t FEDCH_PER_DELAY_CHIP = 4;
  static const uint16_t DELAY_CHIPS_PER_FED = FEDCH_PER_FED/FEDCH_PER_DELAY_CHIP;
  static const uint16_t SPY_DELAY_CHIP_PAYLOAD_SIZE_IN_BYTES = 376*4;                                               // 376 32bit words
  static const uint16_t SPY_DELAY_CHIP_BUFFER_SIZE_IN_BYTES = SPY_DELAY_CHIP_PAYLOAD_SIZE_IN_BYTES+8;               // Extra 8 bytes for counters
  static const uint16_t SPY_DELAYCHIP_DATA_OFFSET_IN_BITS = 44;                                                     // Offset to start of data
  //static const uint16_t SPY_SAMPLES_PER_CHANNEL = ( (SPY_DELAY_CHIP_BUFFER_SIZE_IN_BYTES * 8) - SPY_DELAYCHIP_DATA_OFFSET_IN_BITS ) / 10 / FEDCH_PER_DELAY_CHIP;
  // TW Dirty hack to lose the 3 samples from the end that screw things up...
  static const uint16_t SPY_SAMPLES_PER_CHANNEL = 298;
  static const uint16_t SPY_BUFFER_SIZE_IN_BYTES = SPY_DELAY_CHIP_BUFFER_SIZE_IN_BYTES * DELAY_CHIPS_PER_FED + 40;
  // Delaychip data + 8 bytes header for counters + 8 bytes for word with delay chip enable bits
  // + 16 bytes for DAQ header and trailer
  
  //
  // Class definitions
  //

  //class representing spy channel buffers
  class FEDSpyBuffer : public FEDBufferBase
  {
  public:
    //construct from buffer
    FEDSpyBuffer(const uint8_t* fedBuffer, const size_t fedBufferSize);
    virtual ~FEDSpyBuffer();
    virtual void print(std::ostream& os) const;
      
    //get the run number from the corresponding global run
    uint32_t globalRunNumber() const;
    //get the L1 ID stored in the spy header
    uint32_t spyHeaderL1ID() const;
    //get the total frame count stored in the spy header
    uint32_t spyHeaderTotalEventCount() const;
    //get the L1 ID after reading a given delay chip
    uint32_t delayChipL1ID(const uint8_t delayChip) const;
    //get the total event count after reading a given delay chip
    uint32_t delayChipTotalEventCount(const uint8_t delayChip) const;
      
    //checks that a delay chip is complete i.e. that it all came from the same event
    bool delayChipGood(const uint8_t delayChip) const;
    //checks that a channel is usable (i.e. that the delay chip it is on is good)
    virtual bool channelGood(const uint8_t internalFEDannelNum) const;
  private:
    //mapping of channel index to position in data
    static const uint8_t channelPositionsInData_[FEDCH_PER_DELAY_CHIP];
      
    //setup the channel objects
    void findChannels();
      
    const uint8_t* payloadPointer_;
    uint16_t payloadLength_;
    uint8_t versionId_;
  };

  class FEDSpyChannelUnpacker
  {
  public:
    explicit FEDSpyChannelUnpacker(const FEDChannel& channel);
    uint16_t sampleNumber() const;
    uint16_t adc() const;
    bool hasData() const;
    FEDSpyChannelUnpacker& operator ++ ();
    FEDSpyChannelUnpacker& operator ++ (int);
  private:
    const uint32_t* data_;
    size_t currentOffset_;
    uint16_t currentSample_;
    uint16_t valuesLeft_;
  };

  //
  // Inline function definitions
  //

  //FEDSpyChannelUnpacker

  inline FEDSpyChannelUnpacker::FEDSpyChannelUnpacker(const FEDChannel& channel)
    : data_(reinterpret_cast<const uint32_t*>(channel.data())),
      currentOffset_(channel.offset()),
      currentSample_(0),
      valuesLeft_(channel.length())
  {
  }

  inline uint16_t FEDSpyChannelUnpacker::sampleNumber() const
  {
    return currentSample_;
  }

  inline bool FEDSpyChannelUnpacker::hasData() const
  {
    return (valuesLeft_ != 0);
  }

  inline FEDSpyChannelUnpacker& FEDSpyChannelUnpacker::operator ++ ()
  {
    currentOffset_ += FEDCH_PER_DELAY_CHIP*10;
    currentSample_++;
    valuesLeft_--;
    return (*this);
  }
  
  inline FEDSpyChannelUnpacker& FEDSpyChannelUnpacker::operator ++ (int)
  {
    ++(*this); return *this;
  }

}

#endif //ndef DQM_SiStripMonitorHardware_SiStripFEDSpyBuffer_H