BmnMetadataDecoder.h

Go to the documentation of this file.

#ifndef BMNMETADATADECODER_H
#define BMNMETADATADECODER_H 1
 
#include <fstream>
#include <map>
#include <vector>
// Boost
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
// ROOT
#include <TChain.h>
#include <TClonesArray.h>
#include <TFile.h>
#include <TPRegexp.h>
#include <TString.h>
#include <TTimeStamp.h>
#include <TTree.h>
// BmnRoot
#include "BmnEventHeader.h"
#include "BmnMSCMatrix.h"
#include "BmnMetadataRaw.h"
#include "BmnSpillHeader.h"
#include "BmnT0Raw.h"
#include "BmnTrigRaw2Digit.h"
#include "DigiRunHeader.h"
 
using std::map;
using std::unique_ptr;
using std::vector;
namespace pt = boost::property_tree;
 
class BmnMetadataDecoder : public TObject
{
  public:
    BmnMetadataDecoder(vector<string> file = {}, string outfile = "", ULong_t period = 8, BmnSetup setup = kBMNSETUP);
    virtual ~BmnMetadataDecoder();
 
    void ClearDigiArrays();
    void ClearSpillDigiArrays();
    BmnStatus ProcessStatusBlocks();
    BmnStatus ProcessSpillTree();
    void GatherStatusBlocksFromDigis();
    void GatherStatusBlocksFromTars();
    BmnStatus InitDecoder();
    BmnStatus SaveData();
    BmnStatus DisposeDecoder();
 
    void SetRawTree(TTree* tree) { fRawTree = tree; }
 
    TTree* GetDigiTree() { return fDigiTree; }
 
    void SetRunId(UInt_t v) { fRunId = v; }
 
    void SetPeriodId(UInt_t v) { fPeriodId = v; }
 
    UInt_t GetRunId() const { return fRunId; }
 
    UInt_t GetPeriodId() const { return fPeriodId; }
 
    void SetBmnSetup(BmnSetup v) { fBmnSetup = v; }
 
    BmnSetup GetBmnSetup() const { return fBmnSetup; }
 
    void SetMSCMapping(TString map) { fMSCMapFileName = map; }
 
    void SetOutFileName(string filename) { fOutFileName = filename; }
 
    void SetDecoderConfigFileName(string FileName) { fDecoderConfigFileName = FileName; }
 
    void SetT0RawStorageFileName(string FileName) { fT0RawStorageFileName = FileName; }
 
    BmnStatus SetDigiDirectory(string fDigiDir);
 
    BmnStatus SetTarDirectory(string DirName);
 
    void SetTarFileNames(vector<string> FileNames) { fTarFileNames = FileNames; }
 
    TString GetSubNameAfterRunId(TString name);
 
    static BmnStatus ReadSpillStat(const string& FileName,
                                   const vector<string>& EvtTrNames = {// "BT", "MBT", "CCT1", "CCT2"};
                                                                       "BT'", "MBT", "CCT1", "nFD"});
 
  private:
    const TTimeStamp TimeZero = TTimeStamp(time_t(0), 0);
    Double_t workTime_cpu = 0.0;
    Double_t workTime_real = 0.0;
    bool get_run_interval_from_file = true;
    bool get_filenames_from_db = false;
 
    pt::ptree conf;
 
    UInt_t fRunId;
    UInt_t fPeriodId;
    // for event
    Long64_t fTime_s;
    Long64_t fTime_ns;
    // for run
    SysPoint fRunStartTime;
    SysPoint fRunEndTime;
 
    TTree* fRawTree;
    //    TTree* fRawTreeSpills;
    TTree* fRawTreeSpillsT0;
    TTree* fDigiTree;
    TTree* fDigiTreeSpills;
    string fDecoderConfigFileName;
    string fT0RawStorageFileName;
    string fDigiDir;
    vector<string> fDigiFileNames;
    vector<string> fRawMetaFileNames;
    string fTarDir;
    vector<string> fTarFileNames;
    TString fMSCMapFileName;
    string fOutFileName;
    TString fDigiRunHdrName;
    TString fSubName;
    TString fRawRunHdrName;
    TString fMetadataName;
 
    TFile* fDigiFileOut;
    TFile* fCalibFile;
 
    unique_ptr<DigiRunHeader> digiRunHeader;
    //    BmnMetadataRaw* metadata;
    // Spill tree arrays
    TClonesArray* msc;
    TClonesArray* t0raw;
 
    // Digi arrays
    TClonesArray* msc_copy;
    TClonesArray* t0_copy;
 
    // header array
    BmnEventHeader* inEventHeader;
    BmnSpillHeader* spillHeader;
 
    /** TRC bit map */
    NameChMap fTrcBitMap;
    /** MSC map */
    Name2SerCh fScalersMap;
    /** Raw T0 module map (from Sergeev txt) */
    T0ChMap fRawT0Map;
    BmnMetadataRaw metadata;
 
    BmnSetup fBmnSetup;
    TString fPeriodSetupExt;
    unique_ptr<BmnTrigRaw2Digit> fTrigMapper;
 
    map<SysPoint, BmnSpillInfo> fSpillMap;
 
    SerCh2Name scalers2name_map;
    // map: <serial, channel> -> index in the list (inside spillHeader->ScalersVec(), and MSC matrix)
    map<std::pair<uint32_t, uint16_t>, uint16_t> scalers2index_map;
    map<uint16_t, uint16_t> trcIdx2scalerIdx;
    // map: name -> index in the list
    NameChMap scalers_name2index_map;
    vector<string> scalers_index2name_map;
 
    unique_ptr<TFile> fT0RawStorageFile;
    unique_ptr<TTree> fT0RawStorageTree;
    unique_ptr<std::map<TTimeStamp, int64_t>> fT0RawStorageTsMap;   // T0 storage (ts->i_entry) map
    TClonesArray* fT0RawStorageArr;
 
    void AddT0Raw2Headers(BmnT0Raw* el);
    void GenerateBusyRanges(BmnMSCMatrix<uint8_t>* matrix,
                            boost::dynamic_bitset<>& bitVecSpill,
                            boost::dynamic_bitset<>& bitVecBusy);
 
    BmnStatus LoadConfig();
    BmnStatus LoadT0Storage();
 
    ClassDef(BmnMetadataDecoder, 1);
};
 
#endif