CbmBmonUnpackAlgo.h

Go to the documentation of this file.

/* Copyright (C) 2022 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer]  */
 
#ifndef CbmBmonUnpackAlgo_H
#define CbmBmonUnpackAlgo_H
 
#include "CbmBmonDigi.h"
#include "CbmErrorMessage.h"
#include "CbmMcbm2018TofPar.h"
#include "CbmRecoUnpackAlgo.tmpl"
#include "CbmTofDigi.h"
#include "CbmTofUnpackAlgo.h"
#include "CbmTofUnpackMonitor.h"
#include "Timeslice.hpp"  // timeslice
 
#include <Logger.h>
 
#include <Rtypes.h>  // for types
#include <RtypesCore.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
 
class CbmBmonUnpackAlgo : public CbmRecoUnpackAlgo<CbmBmonDigi, CbmErrorMessage> {
 public:
  CbmBmonUnpackAlgo();

  virtual ~CbmBmonUnpackAlgo();

  CbmBmonUnpackAlgo(const CbmBmonUnpackAlgo&) = delete;

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

  Bool_t Init()
  {
    LOG(info) << fName << "::Init()";
 
    return fTofAlgo.Init();
  }

  std::vector<CbmBmonDigi> Unpack(const fles::Timeslice* ts, uint16_t icomp)
  {
 
    bool unpackOk = true;
 
    // Clear the default return vector
    fOutputVec.clear();
    fTofAlgo.GetOutputVec().clear();

    if (fIsFirstTs) getTimesliceParams(ts);
 
    // Get the index of the current timeslice
    fTsIndex = ts->index();
 
    // Get the number of the current timeslice (the index increases currently via nthTimeslice* fNrCoreMsPerTs)
    size_t itimeslice = fTsIndex / fNrCoreMsPerTs;
 
    // Set further parameters required by the explicit algorithm
    setDerivedTsParameters(itimeslice);
 
    auto nrMsToLoop = fDoIgnoreOverlappMs ? fNrCoreMsPerTs : fNrMsPerTs;
    LOG(debug) << fName << "::Unpack: nb MS used is " << nrMsToLoop;

    for (UInt_t imslice = 0; imslice < nrMsToLoop; imslice++) {
      unpackOk &= fTofAlgo.unpack(ts, icomp, imslice);
      if (!unpackOk) {
        continue;
      }
    }

    FinalizeComponent();
 
    auto ndigis = fOutputVec.size();
    fNrCreatedDigis += ndigis;
 
    // Get the input(output) data sizes
    fSumInDataSize += ts->size_component(icomp) / 1.0e6;
    fSumOutDataSize += ndigis * GetOutputObjSize() / 1.0e6;
 
    ++fNrProcessedTs;
    return fOutputVec;
  }
 
  // Getters
  virtual std::vector<std::pair<std::string, std::shared_ptr<FairParGenericSet>>>*
  GetParContainerRequest(std::string geoTag, uint32_t runId)
  {
    return fTofAlgo.GetParContainerRequest(geoTag, runId);
  };

  std::vector<CbmErrorMessage>* GetOptOutAVec() { return fTofAlgo.GetOptOutAVec(); }

  std::vector<std::nullptr_t>* GetOptOutBVec() { return fTofAlgo.GetOptOutBVec(); }

  static size_t GetOutputObjSize() { return sizeof(CbmBmonDigi); }

  int32_t GetSystemTimeOffset() { return fTofAlgo.GetSystemTimeOffset(); }
 
  // Setters
  void SetDoIgnoreOverlappMs(bool value = false)
  {
    fDoIgnoreOverlappMs = value;
    fTofAlgo.SetDoIgnoreOverlappMs(value);
  }

  void SetOptOutAVec(std::vector<CbmErrorMessage>* vec) { fTofAlgo.SetOptOutAVec(vec); }

  void SetOptOutBVec(std::vector<std::nullptr_t>* vec) { fTofAlgo.SetOptOutBVec(vec); }

  void SetParFilesBasePath(std::string value) { fTofAlgo.SetParFilesBasePath(value); }

  void SetSystemTimeOffset(int32_t value) { fTofAlgo.SetSystemTimeOffset(value); }

  void SetTsStartTime(size_t value) { fTofAlgo.SetTsStartTime(value); }

  void SetFlagEpochCountHack2021(bool bFlagin = true) { fTofAlgo.SetFlagEpochCountHack2021(bFlagin); }

  void SetFlagBmonParMode(bool bFlagin = true) { fTofAlgo.SetFlagBmonParMode(bFlagin); }

  void SetParFileName(std::string sNewName) { fTofAlgo.SetParFileName(sNewName); }

  void SetMonitor(std::shared_ptr<CbmTofUnpackMonitor> monitor) { fTofAlgo.SetMonitor(monitor); }
 
 protected:
  void finish() { fTofAlgo.finish(); }

  void finishDerived() { fTofAlgo.finishDerived(); }

  Bool_t init() { return fTofAlgo.init(); }

  Bool_t initParSet(FairParGenericSet* parset) { return fTofAlgo.initParSet(parset); }

  Bool_t initParSet(CbmMcbm2018TofPar* parset) { return fTofAlgo.initParSet(parset); }
 

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

  virtual void FinalizeComponent()
  {
    fOutputVec.reserve(fTofAlgo.GetOutputVec().size());
    for (CbmTofDigi internalDigi : fTofAlgo.GetOutputVec()) {
      fOutputVec.push_back(CbmBmonDigi(internalDigi));
    }
    return;
  }

  virtual bool unpack(const fles::Timeslice* /*ts*/, uint16_t /*icomp*/, UInt_t /*imslice*/) { return true; }
 
 private:
  CbmTofUnpackAlgo fTofAlgo;
 
  ClassDef(CbmBmonUnpackAlgo, 1)
};
 
#endif  // CbmBmonUnpackAlgo_H