SVDUnpackerModule.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 <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
#include <framework/database/DBObjPtr.h>
#include <framework/database/PayloadFile.h>
#include <framework/dbobjects/HardwareClockSettings.h>
 
#include <svd/geometry/SensorInfo.h>
#include <vxd/dataobjects/VxdID.h>
#include <rawdata/dataobjects/RawSVD.h>
#include <svd/dataobjects/SVDShaperDigit.h>
#include <svd/dataobjects/SVDTransparentDigit.h>
#include <svd/dataobjects/SVDDAQDiagnostic.h>
#include <svd/dataobjects/SVDEventInfo.h>
#include <svd/dataobjects/SVDTriggerType.h>
#include <svd/dbobjects/SVDGlobalConfigParameters.h>
#include <svd/online/SVDOnlineToOfflineMap.h>
#include <svd/online/SVDStripNoiseMap.h>
#include <framework/dataobjects/EventMetaData.h>
 
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>
 
namespace Belle2::SVD {

  class SVDUnpackerModule : public Module {
 
  public:
    SVDUnpackerModule();

    virtual ~SVDUnpackerModule();

    virtual void initialize() override; 
    virtual void beginRun() override; 
    virtual void event() override; 
    virtual void endRun() override; 
 
  private:

    std::string m_rawSVDListName;

    std::string m_svdShaperDigitListName;

    std::string m_svdDAQDiagnosticsListName;

    std::string m_svdEventInfoName;
 
    int m_wrongFTBcrc; 

    unsigned short nFADCboards;

    std::unordered_multimap<unsigned char, unsigned char>* APVmap;

    std::unique_ptr<SVDOnlineToOfflineMap> m_map;

    static std::string m_xmlFileName;

    DBObjPtr<PayloadFile> m_mapping;

    SVDModeByte m_SVDModeByte;

    DBObjPtr<HardwareClockSettings> m_hwClock;

    void printB2Debug(uint32_t* data32, uint32_t* data32_min, uint32_t* data32_max, int nWords);
 
    // The following assumes i386 byte order: MSB comes last!

    struct FTBHeader {
      unsigned int errorsField : 8;  
      unsigned int eventNumber : 24; 
    };

    struct MainHeader {
      unsigned int trgNumber : 8; 
      unsigned int trgType   : 4; 
      unsigned int trgTiming : 2; 
      unsigned int xTalk     : 2; 
      unsigned int FADCnum   : 8; 
      unsigned int DAQType   : 1; 
      unsigned int DAQMode   : 2; 
      unsigned int runType   : 2; 
      unsigned int check     : 3; 
    };

    struct APVHeader {
      unsigned int CMC1      : 8; 
      unsigned int CMC2      : 4; 
      unsigned int apvErr    : 4; 
      unsigned int pipelineAddr : 8; 
      unsigned int APVnum : 6; 
      unsigned int check : 2; 
    };

    struct data_A {
      unsigned int sample1 : 8; 
      unsigned int sample2 : 8; 
      unsigned int sample3 : 8; 
      unsigned int stripNum : 7; 
      unsigned int check : 1; 
    };

    struct data_B {
      unsigned int sample4 : 8; 
      unsigned int sample5 : 8; 
      unsigned int sample6 : 8; 
      unsigned int stripNum : 7; 
      unsigned int check : 1; 
    };

    struct FADCTrailer {
      unsigned int FTBFlags: 16; 
      unsigned int APVdataSizeCut: 1; 
      unsigned int FADCdataSizeCut: 1; 
      unsigned int DummyAPVHeader: 1; 
      unsigned int PiplAddrMismatch: 1; 
      unsigned int nullDigits: 4; 
      unsigned int apvErrOR  : 4; 
      unsigned int check : 4; 
    };

    struct FTBTrailer {
      unsigned int crc16 : 16; 
      unsigned int controlWord : 16; 
    };
 
    union {  // The 4 byte words of the stream can be interpreted as:
      uint32_t m_data32; 
      FTBHeader m_FTBHeader; 
      MainHeader m_MainHeader;  
      APVHeader m_APVHeader;  
      data_A  m_data_A; 
      data_B  m_data_B; 
      FADCTrailer m_FADCTrailer;  
      FTBTrailer m_FTBTrailer; 
    };
 
    StoreObjPtr<EventMetaData> m_eventMetaDataPtr;   
    StoreObjPtr<SVDEventInfo> m_svdEventInfoPtr;  
    SVDTriggerType m_SVDTriggerType;  
 
    StoreArray<RawSVD> m_rawSVD;   
    StoreArray<SVDDAQDiagnostic> m_storeDAQDiagnostics; 
    StoreArray<SVDShaperDigit> m_storeShaperDigits; 
 
    int m_shutUpFTBError; 
    int m_FADCTriggerNumberOffset; 

    bool m_emulatePipelineAddress = false;

    bool m_killUpsetDigits = false;

    bool m_silentAppend = false;

    bool m_badMappingFatal = false;

    bool m_printRaw;

    int m_errorRate{1000};

    unsigned short seenHeadersAndTrailers: 4;

    int nTriggerMatchErrors; 
    int nEventMatchErrors; 
    int nUpsetAPVsErrors; 
    int nSEURecoveryCase; 
    int nErrorFieldErrors; 
    int nMissingAPVsErrors; 
    int nFADCMatchErrors; 
    int nAPVErrors; 
    int nFTBFlagsErrors; 
    int nEventInfoMatchErrors; 

    std::map<std::pair<unsigned short, unsigned short>, std::pair<std::size_t, std::size_t> > m_missingAPVs;

    std::map<std::pair<unsigned short, unsigned short>, std::pair<std::size_t, std::size_t> > m_upsetAPVs;
    std::map<std::pair<unsigned short, unsigned short>, std::pair<std::size_t, std::size_t> > m_seuRecMap;

    std::vector<SVDDAQDiagnostic> m_diagnostics;

    std::vector<std::pair<SVDShaperDigit, std::size_t> > m_digitsWithDiag;

    std::vector<uint64_t> m_digitSortKeys;

    std::vector<uint32_t> m_apvsByPipeline;
 
    int m_relativeTimeShift; 
 
    DBObjPtr<SVDGlobalConfigParameters> m_svdGlobalConfig;  
 
  };//end class declaration
 
}