TOPUnpackerModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - 2018 - Belle II Collaboration                      *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Marko Staric,  Oskar Hartbrich                           *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/Module.h>
#include <top/geometry/TOPGeometryPar.h>
#include <framework/datastore/StoreArray.h>
#include <rawdata/dataobjects/RawTOP.h>
#include <top/RawDataTypes.h>
#include <top/dataobjects/TOPDigit.h>
#include <top/dataobjects/TOPRawWaveform.h>
#include <top/dataobjects/TOPRawDigit.h>
#include <top/dataobjects/TOPSlowData.h>
#include <top/dataobjects/TOPInterimFEInfo.h>
#include <top/dataobjects/TOPTemplateFitResult.h>
#include <top/dataobjects/TOPProductionEventDebug.h>
#include <top/dataobjects/TOPProductionHitDebug.h>
#include <string>
 
namespace Belle2 {
  namespace TOP {
 
    class DataArray {
 
    public:
 
      DataArray(const int* data, int size, bool swap = false)
      {
        m_data = data;
        m_size = size;
        m_i = -1;
        m_swap = swap;
        m_checksumCounter = 0;
      }
 
      int getWord()
      {
        m_i++;
        if (m_i < m_size) {
          m_checksumCounter += (m_data[m_i] & 0xFFFF) + ((m_data[m_i] >> 16) & 0xFFFF);
          if (m_swap) return swap32(m_data[m_i]);
          return m_data[m_i];
        }
        B2ERROR("Bug in data format: DataArray - index out of range");
        return 0;
      }
 
      int peekWord()
      {
        if (m_i + 1 < m_size) {
          if (m_swap) return swap32(m_data[m_i + 1]);
          return m_data[m_i + 1];
        }
 
        return 0;
      }
 
      int getLastWord()
      {
        if (m_size <= 0) return 0;
        if (m_swap) return swap32(m_data[m_size - 1]);
        return m_data[m_size - 1];
      }
 
      unsigned int getIndex() const {return m_i;}
 
      int getRemainingWords() const {return m_size - m_i - 1;}
 
      void resetChecksum() {m_checksumCounter = 0;}
 
      unsigned int foldChecksum()
      {
        unsigned int chk = m_checksumCounter;
        while ((chk >> 16) > 0) {
          chk = (chk & 0xFFFF) + (chk >> 16);
        }
        return chk;
      };
 
      bool validateChecksum()
      {
        return (foldChecksum() == 0xFFFF);
      }
 
    private:
 
      int swap32(int x)
      {
        return (((x << 24) & 0xFF000000) |
                ((x <<  8) & 0x00FF0000) |
                ((x >>  8) & 0x0000FF00) |
                ((x >> 24) & 0x000000FF));
      }
 
      int m_size = 0;        
      const int* m_data = 0; 
      int m_i = 0;           
      bool m_swap = false;   
      unsigned int m_checksumCounter; 
    };
 
  } // TOP namespace
 
 
  class TOPUnpackerModule : public Module {
 
  public:
 
    TOPUnpackerModule();
 
    virtual ~TOPUnpackerModule();
 
    virtual void initialize() override;
 
    virtual void beginRun() override;
 
    virtual void event() override;
 
    virtual void endRun() override;
 
    virtual void terminate() override;
 
  private:
 
    short expand13to16bits(unsigned short x) const
    {
      unsigned short signBit = x & 0x1000;
      return ((x & 0x1FFF) | signBit << 1 | signBit << 2 | signBit << 3);
    }
 
 
    unsigned short sumShorts(unsigned int x) const
    {
      return x + (x >> 16);
    }
 
 
    void unpackProductionDraft(const int* buffer, int bufferSize);
 
    void unpackType0Ver16(const int* buffer, int bufferSize);
 
    int unpackInterimFEVer01(const int* buffer, int bufferSize, bool pedestalSubtracted);
 
    bool unpackHeadersInterimFEVer01(const int* buffer, int bufferSize, bool swapBytes);
 
    int unpackProdDebug(const int* buffer, int bufferSize, TOP::RawDataType dataFormat, bool pedestalSubtracted);
 
    std::string m_inputRawDataName;  
    std::string m_outputDigitsName;  
    std::string m_outputRawDigitsName;  
    std::string m_outputWaveformsName;  
    std::string m_templateFitResultName; 
    std::map<int, int> m_channelStatistics; 
    bool m_swapBytes = false;     
    int m_dataFormat = 0;         
    TOP::TOPGeometryPar* m_topgp = TOP::TOPGeometryPar::Instance(); 
    // collections
    StoreArray<RawTOP> m_rawData;  
    StoreArray<TOPDigit> m_digits;   
    StoreArray<TOPRawDigit> m_rawDigits;   
    StoreArray<TOPSlowData> m_slowData;   
    StoreArray<TOPRawWaveform> m_waveforms;   
    StoreArray<TOPInterimFEInfo> m_interimFEInfos;   
    StoreArray<TOPProductionEventDebug> m_productionEventDebugs;   
    StoreArray<TOPProductionHitDebug> m_productionHitDebugs;   
    StoreArray<TOPTemplateFitResult> m_templateFitResults;   
  };
 
} // Belle2 namespace