TOPUnpackerModule.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#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);
    }
 
    std::string getFrontEndName(RawTOP& raw, int finesse) const;
 
    bool printTheError();
 
    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);
 
    // module steering parameters
 
    std::string m_inputRawDataName;  
    std::string m_outputDigitsName;  
    std::string m_outputRawDigitsName;  
    std::string m_outputWaveformsName;  
    std::string m_templateFitResultName; 
    bool m_swapBytes;  
    int m_dataFormat;  
    bool m_addRelations;  
    unsigned m_errorSuppressFactor; 
    // 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;   
    // other
 
    unsigned m_eventCount = 0;    
    unsigned m_errorCount = 0;    
    bool m_resetEventCount = false; 
    unsigned m_numErrors = 0; 
    TOP::TOPGeometryPar* m_topgp = TOP::TOPGeometryPar::Instance(); 
    std::map<int, int> m_channelStatistics; 
  };
 
} // Belle2 namespace