CbmTofUnpackAlgo.h

Go to the documentation of this file.

/* Copyright (C) 2021 Goethe-University Frankfurt, Frankfurt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau, Pascal Raisig [committer] */

 
#ifndef CbmTofUnpackAlgo_H
#define CbmTofUnpackAlgo_H
 
#include "CbmErrorMessage.h"
#include "CbmMcbm2018TofPar.h"
#include "CbmRecoUnpackAlgo.tmpl"
#include "CbmTofDigi.h"
#include "CbmTofUnpackMonitor.h"
#include "CriGet4Mess001.h"
#include "Timeslice.hpp"  // timeslice
 
#include <Rtypes.h>  // for types
#include <RtypesCore.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
 
class CbmTofUnpackAlgo : public CbmRecoUnpackAlgo<CbmTofDigi, CbmErrorMessage> {
 public:
  CbmTofUnpackAlgo();

  virtual ~CbmTofUnpackAlgo();

  CbmTofUnpackAlgo(const CbmTofUnpackAlgo&) = delete;

  CbmTofUnpackAlgo& operator=(const CbmTofUnpackAlgo&) = delete;

  virtual std::vector<std::pair<std::string, std::shared_ptr<FairParGenericSet>>>*
  GetParContainerRequest(std::string geoTag, uint32_t runId);

  void SetFlagEpochCountHack2021(bool bFlagin = true) { fbEpochCountHack2021 = bFlagin; }

  void SetFlagBmonParMode(bool bFlagin = true) { fbBmonParMode = bFlagin; }

  void SetParFileName(std::string sNewName) { fParFileName = sNewName; }

  void SetMonitor(std::shared_ptr<CbmTofUnpackMonitor> monitor) { fMonitor = monitor; }

  std::vector<CbmTofDigi>& GetOutputVec() { return fOutputVec; }
 
 public:

  void finish()
  {
    finishDerived();
    // Finish the monitor if we have one
    if (fMonitor) {
      std::cout << "Finish Monitor" << std::endl;
      fMonitor->Finish();
    }
  }

  void finishDerived();

  Bool_t init();

  Bool_t initParSet(FairParGenericSet* parset);

  Bool_t initParSet(CbmMcbm2018TofPar* parset);

  bool setDerivedTsParameters(size_t /*itimeslice*/) { return true; }

  bool unpack(const fles::Timeslice* ts, uint16_t icomp, UInt_t imslice);
 
 private:
  void ProcessEpSupprBuffer();

  void ExtractTsStartEpoch(const uint64_t& ulTsStart);
  void ProcessEpoch(const critof001::Message& mess, uint32_t uMesgIdx);
  void ProcessEndOfMsEpoch();
  void ProcessHit(const critof001::Message& mess);
 
  inline Int_t GetArrayIndex(Int_t gdpbId, Int_t get4Id) { return gdpbId * fuNrOfGet4PerGdpb + get4Id; }
 

  std::string fParFileName      = "mTofCriPar.par";
  CbmMcbm2018TofPar* fUnpackPar = nullptr;  

  UInt_t fuNrOfGdpbs                       = 0;   
  std::map<UInt_t, UInt_t> fGdpbIdIndexMap = {};  
  UInt_t fuNrOfFeePerGdpb                  = 0;   
  UInt_t fuNrOfGet4PerFee                  = 0;   
  UInt_t fuNrOfChannelsPerGet4             = 0;   
  UInt_t fuNrOfChannelsPerFee              = 0;   
  UInt_t fuNrOfGet4                        = 0;   
  UInt_t fuNrOfGet4PerGdpb                 = 0;   
  UInt_t fuNrOfChannelsPerGdpb             = 0;   

  UInt_t fuNrOfGbtx              = 0;
  UInt_t fuNrOfModules           = 0;
  std::vector<Int_t> fviRpcChUId = {};

  UInt_t fuMapWarnToPrint     = 100;
  ULong64_t fulCurrentTsIdx   = 0;    
  ULong64_t fulCurrentMsIdx   = 0;    
  double fdCurrentMsTime      = 0.0;  
  size_t fuCurrentMsSysId     = 0;    
  UInt_t fuCurrentEquipmentId = 0;    
  UInt_t fuCurrDpbId          = 0;    
  UInt_t fuCurrDpbIdx         = 0;    
  UInt_t fuGet4Id =
    0;  
  UInt_t fuGet4Nr = 0;  
  ULong64_t fulCurrentEpoch = 0;  

  bool fbEpochCountHack2021             = false;
  bool fbBmonParMode                    = false;
  std::vector<bool> fvbMaskedComponents = {};
  bool fbLastEpochGood                  = false;
  uint64_t fulBadEpochNb                = 0;
  uint64_t fulBadEpochHitNb             = 0;

  uint32_t fuProcEpochUntilError = 0;
  uint64_t fulTsStartInEpoch     = 0;
  uint64_t fulEpochIndexInTs     = 0;

  std::shared_ptr<CbmTofUnpackMonitor> fMonitor = nullptr;
 
  ClassDef(CbmTofUnpackAlgo, 2)
};
 
#endif  // CbmTofUnpackAlgo_H