BmnRawSource.h

Go to the documentation of this file.

#ifndef BMNRAWSOURCE_H
#define BMNRAWSOURCE_H 1
 
// #define MULTITHREAD true
//  STL
#include <bitset>
#include <fstream>
#include <map>
#include <vector>
 
#pragma GCC system_header
// Boost
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
// nlohmann
#include <nlohmann/json.hpp>
// ROOT
#include "TClonesArray.h"
#include "TFile.h"
#include "TPRegexp.h"
#include "TString.h"
#include "TTimeStamp.h"
#include "TTree.h"
// FairRoot
#include "FairRootManager.h"
#include "FairSource.h"
// BmnRoot
#include "BmnDetectorList.h"
#include "BmnEventHeader.h"
#include "BmnMath.h"
#include "BmnMetadataRaw.h"
#include "BmnSpillHeader.h"
#include "BmnT0Raw.h"
#include "BmnThreadManager.h"
#include "BmnTrigConfig.h"
#include "DigiRunHeader.h"
#include "RawTypes.h"
 
/********************************************************/
// wait limit for input data (ms)
#define WAIT_LIMIT 40000000
 
class BmnIFileReader;
 
using std::map;
using std::vector;
namespace pt = boost::property_tree;
 
using json = nlohmann::json;
 
class BmnRawSource : public FairSource
{
  public:
    BmnRawSource(vector<TString> files, uint32_t period = 8);
    BmnRawSource(TString file = "", TString outfile = "", uint32_t nEvents = 0, uint32_t period = 8, bool save = false);
    virtual ~BmnRawSource() override;
 
    virtual bool Init() override;
    virtual Int_t ReadEvent(uint32_t i = 0) override;
    virtual bool SpecifyRunId() override { return kTRUE; }
    virtual void Close() override;
    virtual void Reset() override;
 
    virtual Source_Type GetSourceType() override { return kFILE; }
 
    virtual void SetParUnpackers() override { LOGF(debug, "%s", __func__); }
 
    virtual bool InitUnpackers() override
    {
        LOGF(debug, "%s", __func__);
        return kTRUE;
    }
 
    virtual bool ReInitUnpackers() override
    {
        LOGF(debug, "%s", __func__);
        return kTRUE;
    }
 
    virtual void FillEventHeader(FairEventHeader* feh) override
    {
        LOGF(debug1, "FillEventHeader does nothing");
        return;
    }
 
    BmnStatus ParseJsonTLV(const uint32_t* buf, uint32_t& len);
    BmnStatus ConvertStatEvent(const uint32_t* buf, uint32_t& len);
    BmnStatus ConvertRawToRoot();
    BmnStatus ConvertRawToRootIterate(const uint32_t* buf, uint32_t len);
    BmnStatus ConvertRawToRootIterateFile(uint32_t limit = WAIT_LIMIT);
    BmnStatus ConvertRawToRootIterateFileRead();
    void ClearRawArrays();
    void ClearRawSpillArrays();
    BmnStatus FinishRun();
    BmnStatus InitConverter(TString FileName);
    BmnStatus InitConverter();
 
    void SetRunId(uint32_t v) { fRunId = v; }
 
    void SetPeriodId(uint32_t v) { fPeriodId = v; }
 
    uint32_t GetRunId() const { return fRunId; }
 
    uint32_t GetPeriodId() const { return fPeriodId; }
 
    uint32_t GetNevents() const { return fNTotalEvents; }
 
    uint32_t GetEventId() const { return fEventId; }
 
    TTimeStamp GetRunStartTime() const { return fRunStartTime; }
 
    TTimeStamp GetRunEndTime() const { return fRunEndTime; }
 
    TString GetRootFileName() { return fRootFileName; }
 
    void SetVerbose(Int_t v) { fVerbose = v; }
 
    Int_t GetVerbose() const { return fVerbose; }
 
    uint32_t GetBoundaryRun(uint32_t nSmpl)
    {
        // format for SILICON data was changed during March 2017 seance (run 1542)
        // format for GEM was changed after March 2017 seance (run 1992)
        // so we have to use this crutch.
        return (nSmpl == 128) ? 1542 : 1992;
    }
 
    void SetRawRootFile(TString filename) { fRootFileName = filename; }
 
    void SetRawEventStat()
    {
        fCurEvType = kBMNSTAT;
        eventHeaderDAQ->SetEventType(fCurEvType);
    }
 
    void SetDecoderConfigFileName(string FileName)
    {
        fDecoderConfigFileName = FileName;
        LoadConfig();
    }
 
    TTree* GetRawTree() { return fRawTree; }
 
    TTree* GetRawTreeSpills() { return fRawTreeSpills; }
 
    Int_t GetRunIdFromFile(TString name);
 
    void SetSaveOutput(bool v) { fSaveOutput = v; }
 
    bool GetSaveOutput() const { return fSaveOutput; }
 
    void SetTaskMode(bool v = true) { isTaskMode = v; }
 
    bool GetTaskMode() const { return isTaskMode; }
 
    void SetForwardMode(bool v = true) { isForwardMode = v; }
 
    bool GetForwardMode() const { return isForwardMode; }
 
  private:
    //    static const Int_t T0_bin_block_words = 256;//BmnT0Raw::CountersCount();
    BmnThreadManager<BmnConverterThread>* fThreads;
    const TTimeStamp TimeZero = TTimeStamp(time_t(0), 0);
    Double_t workTime_cpu = 0.0;
    Double_t workTime_real = 0.0;
 
    pt::ptree conf;
    bool isSpillStart;
    bool isTaskMode;
    bool isForwardMode;
    uint32_t fSpillCntr;
    BmnEventType fCurEvType = kBMNPAYLOAD;    // for converter
    BmnEventType fPrevEvType = kBMNPAYLOAD;   // for converter
    bool isRawRootInputFile;
 
    // @todo check this fRunId exists in FairSource as well! Collision while types are different - int32_t and uint32_t
    uint32_t fRunId;
    uint32_t fPeriodId;
    uint32_t fEventId;
    uint32_t fNTotalEvents;
    uint32_t fNSignalEvents;
    uint32_t fStartEventId;
    // for event
    int64_t fTime_s;
    int64_t fTime_ns;
    // for run
    TTimeStamp fRunStartTime;
    TTimeStamp fRunEndTime;
 
    int64_t fLengthRawFile;
    int64_t fCurentPositionRawFile;
 
    TTree* fRawTree;
    TTree* fRawTreeSpills;
    string fDecoderConfigFileName;
    TString fRootFileName;
    TString fRawFileName;
    TString fSubName;
    TString fRawRunHdrName;
    TString fMetadataName;
 
    TFile* fRootFileOut;
    BmnIFileReader* fFileReader;
 
    // DAQ arrays
    TClonesArray* sync;
    TClonesArray* adc32;    // gem
    TClonesArray* adc64;    // SiBT
    TClonesArray* adc128;   // FSD
    TClonesArray* adc;      // zdc & ecal & scwall & fhcal
    TClonesArray* vsp;
    TClonesArray* hrb;
    TClonesArray* tdc;
    TClonesArray* tqdc_tdc;
    TClonesArray* tqdc_adc;
    TClonesArray* tdc_hgnd;   // hgnd
    // Spill tree arrays
    TClonesArray* msc;
    TClonesArray* t0raw;
    BmnEventHeader* eventHeaderDAQ;
 
    // header array
    BmnSpillHeader* spillHeader;
    // Raw run header
    unique_ptr<DigiRunHeader> runHeader;
 
    unique_ptr<BmnMetadataRaw> metadata;
 
    uint32_t data[10000000];
    uint32_t fMaxEvent;
 
    uint32_t fDat;   // current 32-bits word
    uint32_t syncCounter;
 
    uint32_t nSpillEvents;
    Bool_t fExportJsonBlocks;
    Bool_t fExportExternalSpillStat;
 
    uint32_t n_msc_spill = 0;
    uint32_t n_msc_spill_ar[16] = {};
 
    std::map<uint8_t, const uint32_t*> time_slice_map;
 
    map<TTimeStamp, Int_t> leaps;
    TTimeStamp utc_valid;
    Int_t tai_utc_dif;
    Int_t fVerbose;
    map<SysPoint, BmnSpillInfo> fSpillMap;
    //    map<TTimeStamp, BmnSpillInfo> fSpillMap;
    Bool_t fSaveOutput;
 
    template<typename BrType>
    void BranchRegFun(TString name, BrType** ar, TTree* tree = nullptr)
    {
        if (isTaskMode) {
            FairRootManager* frm = FairRootManager::Instance();
            frm->Register(name, name + "_dir", (*ar), fSaveOutput);
        } else {
            TBranch* b = tree->Branch(name, ar);
            LOGF(debug, "Register branch %p for obj %p : %s", (void*)b, (void*)ar, name.Data());
        }
        return;
    }
 
    BmnStatus InitUTCShift();
    Int_t GetUTCShift(TTimeStamp t);
    BmnStatus GetT0Info(Double_t& t0time, Double_t& t0width);
    BmnStatus ProcessEvent(const uint32_t* data, uint32_t len);
    void QuickProcessEvent(const uint32_t* d, uint32_t len);
    /**
     * Finishes the spill during raw conversion
     */
    void FinalizeStat();
 
    BmnStatus Process_FVME(const uint32_t* data, uint32_t len, uint32_t serial, BmnTrigInfo& spillInfo);
    BmnStatus Process_HRB(const uint32_t* data, uint32_t len, uint32_t serial);
    BmnStatus FillU40VE(const uint32_t* d, uint32_t slot, uint32_t& idx, BmnTrigInfo& spillInfo);
    BmnStatus FillBlockTDC(const uint32_t* d, uint32_t serial, uint16_t& len, TClonesArray* ar, uint32_t modid);
    BmnStatus FillBlockADC(const uint32_t* d, uint32_t serial, uint8_t channel, uint16_t& len, TClonesArray* ar);
    BmnStatus FillTDC(const uint32_t* d, uint32_t serial, uint32_t slot, uint32_t modId, uint32_t& idx);
    BmnStatus FillTQDC(const uint32_t* d, uint32_t serial, uint32_t slot, uint32_t modId, uint32_t& idx);
    /**
     * Parse TQDC16VS-E MStream data block
     * https://afi.jinr.ru/DataFormatTQDC16VSE
     * @param d data pointer
     * @param serial device serial
     * @param len payload length
     * @return operation success
     */
    BmnStatus FillTQDC_E(const uint32_t* d, uint32_t serial, uint32_t& len);
    /**
     * Parse MSC16VE-E MStream data block
     * https://afi.jinr.ru/DataFormatMSC_ETH
     * https://afi.jinr.ru/DataFormatMSC_ETH_V2
     * @param d data pointer
     * @param dev_hdr device header (serial, payload length, device ID)
     * @return operation success
     */
    BmnStatus FillMSC16VE_E(const uint32_t* d, const DeviceHeader* dev_hdr);
    /**
     * https://afi.jinr.ru/TDC72VXS_DataFormat
     */
    BmnStatus FillTDC72VXS(const uint32_t* d, uint32_t serial, uint32_t& len, uint32_t modid);
    /**
     * https://afi.jinr.ru/TTVXS_DataFormat
     */
    BmnStatus FillTTVXS(const uint32_t* d, uint32_t serial, uint32_t& len);
    BmnStatus ProcessGenericDevice(const uint32_t* d, const DeviceHeader* dev_hdr);
    /**
     * Parse custom HGND TDC data block
     */
    BmnStatus FillTDC250HGND(const uint32_t* d, uint32_t serial, uint32_t len);
    /**
     * Parse VSP data block
     */
    BmnStatus MapVSP(const uint32_t* d, const DeviceHeader* dev_hdr);
    BmnStatus FillVSP(TClonesArray* ar);
    /**
     * Parse UT24VE-TRC MStream data block
     * https://afi.jinr.ru/DataFormatUT24VE-TRC
     * @param d data pointer
     * @param serial device serial
     * @param len payload length
     * @return operation success
     */
    BmnStatus FillUT24VE_TRC(const uint32_t* d, uint32_t& serial, uint32_t& len);
    BmnStatus FillVirtualDevice(const uint32_t* d, const DeviceHeader* dh);
    BmnStatus FillFVME2TMWR(const uint32_t* d, uint32_t serial, uint32_t& idx, uint32_t& len);
    inline BmnSyncDigit* FillWR(uint32_t iSerial, uint64_t iEvent, int64_t t_sec, int64_t t_ns);
 
    /**
     * Old MSC format (periodId < 8, one record for spill)
     */
    BmnStatus FillMSC(const uint32_t* d, uint32_t serial, uint32_t slot, uint32_t& idx);
    BmnStatus LoadConfig();
    void RegisterBranches();
    void RegisterSpillBranches();
 
    ClassDef(BmnRawSource, 1);
};
 
#endif