MQ/mcbm/CbmDeviceBuildRawEvents.cxx

+/* Copyright (C) 2020-2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau, Dominik Smith [committer] */
+
+/**
+ * CbmDeviceBuildRawEvents.cxx
+ *
+ * @since 2020-05-24
+ * @author P.-A. Loizeau
+ */
+
+#include "CbmDeviceBuildRawEvents.h"
+
+/// CBM headers
+#include "CbmEvent.h"
+#include "CbmFlesCanvasTools.h"
+#include "CbmMQDefs.h"
+#include "CbmMatch.h"
+#include "CbmMvdDigi.h"
+
+#include "TimesliceMetaData.h"
+
+/// FAIRROOT headers
+#include "FairMQLogger.h"
+#include "FairMQProgOptions.h"  // device->fConfig
+#include "FairParGenericSet.h"
+#include "FairRunOnline.h"
+
+#include "BoostSerializer.h"
+
+#include "RootSerializer.h"
+
+/// FAIRSOFT headers (geant, boost, ...)
+#include "TCanvas.h"
+#include "TFile.h"
+#include "TH1.h"
+#include "TList.h"
+#include "TNamed.h"
+
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/serialization/utility.hpp>
+
+/// C/C++ headers
+#include <array>
+#include <iomanip>
+#include <stdexcept>
+#include <string>
+struct InitTaskError : std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+using namespace std;
+
+CbmDeviceBuildRawEvents::CbmDeviceBuildRawEvents() { fpAlgo = new CbmAlgoBuildRawEvents(); }
+
+void CbmDeviceBuildRawEvents::InitTask()
+try {
+  /// Read options from executable
+  LOG(info) << "Init options for CbmDeviceBuildRawEvents.";
+  fbFillHistos      = fConfig->GetValue<bool>("FillHistos");
+  fbIgnoreTsOverlap = fConfig->GetValue<bool>("IgnOverMs");
+
+  fsEvtOverMode   = fConfig->GetValue<std::string>("EvtOverMode");
+  fsRefDet        = fConfig->GetValue<std::string>("RefDet");
+  fvsAddDet       = fConfig->GetValue<std::vector<std::string>>("AddDet");
+  fvsDelDet       = fConfig->GetValue<std::vector<std::string>>("DelDet");
+  fvsSetTrigWin   = fConfig->GetValue<std::vector<std::string>>("SetTrigWin");
+  fvsSetTrigMinNb = fConfig->GetValue<std::vector<std::string>>("SetTrigMinNb");
+
+  fsChannelNameDataInput    = fConfig->GetValue<std::string>("TsNameIn");
+  fsChannelNameDataOutput   = fConfig->GetValue<std::string>("EvtNameOut");
+  fsChannelNameHistosInput  = fConfig->GetValue<std::string>("ChNameIn");
+  fsChannelNameHistosConfig = fConfig->GetValue<std::string>("ChNameHistCfg");
+  fsChannelNameCanvasConfig = fConfig->GetValue<std::string>("ChNameCanvCfg");
+  fsAllowedChannels[0]      = fsChannelNameDataInput;
+
+  fuPublishFreqTs  = fConfig->GetValue<uint32_t>("PubFreqTs");
+  fdMinPublishTime = fConfig->GetValue<double_t>("PubTimeMin");
+  fdMaxPublishTime = fConfig->GetValue<double_t>("PubTimeMax");
+
+  // Get the information about created channels from the device
+  // Check if the defined channels from the topology (by name)
+  // are in the list of channels which are possible/allowed
+  // for the device
+  // The idea is to check at initilization if the devices are
+  // properly connected. For the time beeing this is done with a
+  // nameing convention. It is not avoided that someone sends other
+  // data on this channel.
+  //logger::SetLogLevel("INFO");
+  int noChannel = fChannels.size();
+  LOG(info) << "Number of defined channels: " << noChannel;
+  for (auto const& entry : fChannels) {
+    LOG(info) << "Channel name: " << entry.first;
+    if (std::string::npos != entry.first.find(fsChannelNameDataInput)) {
+      if (!IsChannelNameAllowed(entry.first)) throw InitTaskError("Channel name does not match.");
+      OnData(entry.first, &CbmDeviceBuildRawEvents::HandleData);
+    }
+  }
+
+  /// FIXME: Disable clang formatting for now as it corrupts all alignment
+  /* clang-format off */
+
+  /// Initialize the Algorithm parameters
+  fpAlgo->SetFillHistos(fbFillHistos);
+  fpAlgo->SetIgnoreTsOverlap(fbIgnoreTsOverlap);
+  /// Extract Event Overlap Mode
+  EOverlapModeRaw mode =
+     ("NoOverlap"    == fsEvtOverMode ? EOverlapModeRaw::NoOverlap
+   : ("MergeOverlap" == fsEvtOverMode ? EOverlapModeRaw::MergeOverlap
+   : ("AllowOverlap" == fsEvtOverMode ? EOverlapModeRaw::AllowOverlap
+                                      : EOverlapModeRaw::NoOverlap)));
+  fpAlgo->SetEventOverlapMode(mode);
+  /// Extract refdet
+  RawEventBuilderDetector refDet = ("kBmon"   == fsRefDet ? kRawEventBuilderDetBmon
+                              : ("kSts"  == fsRefDet ? kRawEventBuilderDetSts
+                              : ("kMuch" == fsRefDet ? kRawEventBuilderDetMuch
+                              : ("kTrd"  == fsRefDet ? kRawEventBuilderDetTrd
+                              : ("kTof"  == fsRefDet ? kRawEventBuilderDetTof
+                              : ("kRich" == fsRefDet ? kRawEventBuilderDetRich
+                              : ("kPsd"  == fsRefDet ? kRawEventBuilderDetPsd
+                                                     : kRawEventBuilderDetUndef)))))));
+  if (kRawEventBuilderDetUndef != refDet) {
+    fpAlgo->SetReferenceDetector(refDet);
+  }
+  else {
+    LOG(info) << "CbmDeviceBuildRawEvents::InitTask => Trying to change "
+                 "reference to unsupported detector, ignored! "
+              << fsRefDet;
+  }
+
+  /// Extract detector to add if any
+  for (std::vector<std::string>::iterator itStrAdd = fvsAddDet.begin();
+       itStrAdd != fvsAddDet.end();
+       ++itStrAdd) {
+    RawEventBuilderDetector addDet = ("kBmon"   == *itStrAdd ? kRawEventBuilderDetBmon
+                                : ("kSts"  == *itStrAdd ? kRawEventBuilderDetSts
+                                : ("kMuch" == *itStrAdd ? kRawEventBuilderDetMuch
+                                : ("kTrd"  == *itStrAdd ? kRawEventBuilderDetTrd
+                                : ("kTof"  == *itStrAdd ? kRawEventBuilderDetTof
+                                : ("kRich" == *itStrAdd ? kRawEventBuilderDetRich
+                                : ("kPsd"  == *itStrAdd ? kRawEventBuilderDetPsd
+                                                        : kRawEventBuilderDetUndef)))))));
+    if (kRawEventBuilderDetUndef != addDet) {
+      fpAlgo->AddDetector(addDet);
+    }
+    else {
+      LOG(info) << "CbmDeviceBuildRawEvents::InitTask => Trying to add "
+                   "unsupported detector, ignored! "
+                << (*itStrAdd);
+      continue;
+    }
+  }
+
+     /// Extract detector to remove if any
+  for (std::vector<std::string>::iterator itStrRem = fvsDelDet.begin();
+       itStrRem != fvsDelDet.end();
+       ++itStrRem) {
+    RawEventBuilderDetector remDet = ("kBmon"   == *itStrRem ? kRawEventBuilderDetBmon
+                                : ("kSts"  == *itStrRem ? kRawEventBuilderDetSts
+                                : ("kMuch" == *itStrRem ? kRawEventBuilderDetMuch
+                                : ("kTrd"  == *itStrRem ? kRawEventBuilderDetTrd
+                                : ("kTof"  == *itStrRem ? kRawEventBuilderDetTof
+                                : ("kRich" == *itStrRem ? kRawEventBuilderDetRich
+                                : ("kPsd"  == *itStrRem ? kRawEventBuilderDetPsd
+                                                        : kRawEventBuilderDetUndef)))))));
+    if (kRawEventBuilderDetUndef != remDet) {
+      fpAlgo->RemoveDetector(remDet);
+    }
+    else {
+      LOG(info) << "CbmDeviceBuildRawEvents::InitTask => Trying to remove "
+                   "unsupported detector, ignored! "
+                << (*itStrRem);
+      continue;
+    }
+  }
+     /// Extract Trigger window to add if any
+  for (std::vector<std::string>::iterator itStrTrigWin = fvsSetTrigWin.begin();
+       itStrTrigWin != fvsSetTrigWin.end();
+       ++itStrTrigWin) {
+    size_t charPosDel = (*itStrTrigWin).find(',');
+    if (std::string::npos == charPosDel) {
+      LOG(info)
+        << "CbmDeviceBuildRawEvents::InitTask => "
+        << "Trying to set trigger window with invalid option pattern, ignored! "
+        << " (Should be ECbmModuleId,dWinBeg,dWinEnd but instead found "
+        << (*itStrTrigWin) << " )";
+      continue;
+    }
+
+    /// Detector Enum Tag
+    std::string sSelDet = (*itStrTrigWin).substr(0, charPosDel);
+    ECbmModuleId selDet = ("kBmon"   == sSelDet ? ECbmModuleId::kBmon
+                        : ("kSts"  == sSelDet ? ECbmModuleId::kSts
+                        : ("kMuch" == sSelDet ? ECbmModuleId::kMuch
+                        : ("kTrd"  == sSelDet ? ECbmModuleId::kTrd
+                        : ("kTof"  == sSelDet ? ECbmModuleId::kTof
+                        : ("kRich" == sSelDet ? ECbmModuleId::kRich
+                        : ("kPsd"  == sSelDet ? ECbmModuleId::kPsd
+                                              : ECbmModuleId::kNotExist)))))));
+    if (ECbmModuleId::kNotExist == selDet) {
+      LOG(info)
+        << "CbmDeviceBuildRawEvents::InitTask => "
+        << "Trying to set trigger window for unsupported detector, ignored! "
+        << sSelDet;
+      continue;
+    }
+
+    /// Window beginning
+    charPosDel++;
+    std::string sNext = (*itStrTrigWin).substr(charPosDel);
+    charPosDel        = sNext.find(',');
+    if (std::string::npos == charPosDel) {
+      LOG(info)
+        << "CbmDeviceBuildRawEvents::InitTask => "
+        << "Trying to set trigger window with invalid option pattern, ignored! "
+        << " (Should be ECbmModuleId,dWinBeg,dWinEnd but instead found "
+        << (*itStrTrigWin) << " )";
+      continue;
+    }
+    Double_t dWinBeg = std::stod(sNext.substr(0, charPosDel));
+
+    /// Window end
+    charPosDel++;
+    Double_t dWinEnd = std::stod(sNext.substr(charPosDel));
+
+    fpAlgo->SetTriggerWindow(selDet, dWinBeg, dWinEnd);
+  }
+     /// Extract MinNb for trigger if any
+  for (std::vector<std::string>::iterator itStrMinNb = fvsSetTrigMinNb.begin();
+       itStrMinNb != fvsSetTrigMinNb.end();
+       ++itStrMinNb) {
+    size_t charPosDel = (*itStrMinNb).find(',');
+    if (std::string::npos == charPosDel) {
+      LOG(info)
+        << "CbmDeviceBuildRawEvents::InitTask => "
+        << "Trying to set trigger min Nb with invalid option pattern, ignored! "
+        << " (Should be ECbmModuleId,uMinNb but instead found " << (*itStrMinNb)
+        << " )";
+      continue;
+    }
+
+    /// Detector Enum Tag
+    std::string sSelDet = (*itStrMinNb).substr(0, charPosDel);
+    ECbmModuleId selDet = ("kBmon"   == sSelDet ? ECbmModuleId::kBmon
+                        : ("kSts"  == sSelDet ? ECbmModuleId::kSts
+                        : ("kMuch" == sSelDet ? ECbmModuleId::kMuch
+                        : ("kTrd"  == sSelDet ? ECbmModuleId::kTrd
+                        : ("kTof"  == sSelDet ? ECbmModuleId::kTof
+                        : ("kRich" == sSelDet ? ECbmModuleId::kRich
+                        : ("kPsd"  == sSelDet ? ECbmModuleId::kPsd
+                                              : ECbmModuleId::kNotExist)))))));
+    if (ECbmModuleId::kNotExist == selDet) {
+      LOG(info)
+        << "CbmDeviceBuildRawEvents::InitTask => "
+        << "Trying to set trigger min Nb for unsupported detector, ignored! "
+        << sSelDet;
+      continue;
+    }
+
+    /// Min number
+    charPosDel++;
+    UInt_t uMinNb = std::stoul((*itStrMinNb).substr(charPosDel));
+
+    fpAlgo->SetTriggerMinNumber(selDet, uMinNb);
+  }
+
+  /// FIXME: Re-enable clang formatting after formatted lines
+  /* clang-format on */
+
+  /// Create input vectors
+  fvDigiBmon = new std::vector<CbmBmonDigi>();
+  fvDigiSts  = new std::vector<CbmStsDigi>();
+  fvDigiMuch = new std::vector<CbmMuchBeamTimeDigi>();
+  fvDigiTrd  = new std::vector<CbmTrdDigi>();
+  fvDigiTof  = new std::vector<CbmTofDigi>();
+  fvDigiRich = new std::vector<CbmRichDigi>();
+  fvDigiPsd  = new std::vector<CbmPsdDigi>();
+
+  fTimeSliceMetaDataArray = new TClonesArray("TimesliceMetaData", 1);
+  if (NULL == fTimeSliceMetaDataArray) { throw InitTaskError("Failed creating the TS meta data TClonesarray "); }
+  fpAlgo->SetTimeSliceMetaDataArray(fTimeSliceMetaDataArray);
+
+  /// Digis storage
+  fpAlgo->SetDigis(fvDigiBmon);
+  fpAlgo->SetDigis(fvDigiSts);
+  fpAlgo->SetDigis(fvDigiMuch);
+  fpAlgo->SetDigis(fvDigiTrd);
+  fpAlgo->SetDigis(fvDigiTof);
+  fpAlgo->SetDigis(fvDigiRich);
+  fpAlgo->SetDigis(fvDigiPsd);
+
+  // Mvd currently not implemented in event builder
+  //std::vector<CbmMvdDigi>* pMvdDigi = new std::vector<CbmMvdDigi>();
+
+  /// Create output TClonesArray
+  fEvents = new TClonesArray("CbmEvent", 500);
+
+  /// Now that everything is set, initialize the Algorithm
+  if (kFALSE == fpAlgo->InitAlgo()) { throw InitTaskError("Failed to initilize the algorithm class."); }
+
+  /// Histograms management
+  if (kTRUE == fbFillHistos) {
+    /// Obtain vector of pointers on each histo from the algo (+ optionally desired folder)
+    std::vector<std::pair<TNamed*, std::string>> vHistos = fpAlgo->GetHistoVector();
+    /// Obtain vector of pointers on each canvas from the algo (+ optionally desired folder)
+    std::vector<std::pair<TCanvas*, std::string>> vCanvases = fpAlgo->GetCanvasVector();
+
+    /// Add pointers to each histo in the histo array
+    /// Create histo config vector
+    /// ===> Use an std::vector< std::pair< std::string, std::string > > with < Histo name, Folder >
+    ///      and send it through a separate channel using the BoostSerializer
+    for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto) {
+      //         LOG(info) << "Registering  " << vHistos[ uHisto ].first->GetName()
+      //                   << " in " << vHistos[ uHisto ].second.data()
+      //                   ;
+      fArrayHisto.Add(vHistos[uHisto].first);
+      std::pair<std::string, std::string> psHistoConfig(vHistos[uHisto].first->GetName(), vHistos[uHisto].second);
+      fvpsHistosFolder.push_back(psHistoConfig);
+
+      /// Serialize the vector of histo config into a single MQ message
+      FairMQMessagePtr messageHist(NewMessage());
+      //      Serialize<BoostSerializer<std::pair<std::string, std::string>>>(*messageHist, psHistoConfig);
+      BoostSerializer<std::pair<std::string, std::string>>().Serialize(*messageHist, psHistoConfig);
+
+      /// Send message to the common histogram config messages queue
+      if (Send(messageHist, fsChannelNameHistosConfig) < 0) { throw InitTaskError("Problem sending histo config"); }
+      LOG(info) << "Config of hist  " << psHistoConfig.first.data() << " in folder " << psHistoConfig.second.data();
+    }
+
+    /// Create canvas config vector
+    /// ===> Use an std::vector< std::pair< std::string, std::string > > with < Canvas name, config >
+    ///      and send it through a separate channel using the BoostSerializer
+    for (UInt_t uCanv = 0; uCanv < vCanvases.size(); ++uCanv) {
+      //         LOG(info) << "Registering  " << vCanvases[ uCanv ].first->GetName()
+      //                   << " in " << vCanvases[ uCanv ].second.data();
+      std::string sCanvName = (vCanvases[uCanv].first)->GetName();
+      std::string sCanvConf = GenerateCanvasConfigString(vCanvases[uCanv].first);
+
+      std::pair<std::string, std::string> psCanvConfig(sCanvName, sCanvConf);
+
+      fvpsCanvasConfig.push_back(psCanvConfig);
+
+      /// Serialize the vector of canvas config into a single MQ message
+      FairMQMessagePtr messageCan(NewMessage());
+      //      Serialize<BoostSerializer<std::pair<std::string, std::string>>>(*messageCan, psCanvConfig);
+      BoostSerializer<std::pair<std::string, std::string>>().Serialize(*messageCan, psCanvConfig);
+
+      /// Send message to the common canvas config messages queue
+      if (Send(messageCan, fsChannelNameCanvasConfig) < 0) { throw InitTaskError("Problem sending canvas config"); }
+
+      LOG(info) << "Config string of Canvas  " << psCanvConfig.first.data() << " is " << psCanvConfig.second.data();
+    }
+  }
+}
+catch (InitTaskError& e) {
+  LOG(error) << e.what();
+  // Wrapper defined in CbmMQDefs.h to support different FairMQ versions
+  cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
+}
+
+bool CbmDeviceBuildRawEvents::IsChannelNameAllowed(std::string channelName)
+{
+  for (auto const& entry : fsAllowedChannels) {
+    std::size_t pos1 = channelName.find(entry);
+    if (pos1 != std::string::npos) {
+      const vector<std::string>::const_iterator pos =
+        std::find(fsAllowedChannels.begin(), fsAllowedChannels.end(), entry);
+      const vector<std::string>::size_type idx = pos - fsAllowedChannels.begin();
+      LOG(info) << "Found " << entry << " in " << channelName;
+      LOG(info) << "Channel name " << channelName << " found in list of allowed channel names at position " << idx;
+      return true;
+    }
+  }
+  LOG(info) << "Channel name " << channelName << " not found in list of allowed channel names.";
+  LOG(error) << "Stop device.";
+  return false;
+}
+
+// handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)
+bool CbmDeviceBuildRawEvents::HandleData(FairMQParts& parts, int /*index*/)
+{
+  fulNumMessages++;
+  LOG(debug) << "Received message number " << fulNumMessages << " with " << parts.Size() << " parts"
+             << ", size0: " << parts.At(0)->GetSize();
+
+  if (0 == fulNumMessages % 10000) LOG(info) << "Received " << fulNumMessages << " messages";
+
+  /// Extract unpacked data from input message
+  uint32_t uPartIdx = 0;
+
+  /// TS metadata
+  //  Deserialize<RootSerializer>(*parts.At(uPartIdx), fTsMetaData);
+  RootSerializer().Deserialize(*parts.At(uPartIdx), fTsMetaData);
+  new ((*fTimeSliceMetaDataArray)[fTimeSliceMetaDataArray->GetEntriesFast()])
+    TimesliceMetaData(std::move(*fTsMetaData));
+  ++uPartIdx;
+
+  /// Bmon
+  std::string msgStrBmon(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issBmon(msgStrBmon);
+  boost::archive::binary_iarchive inputArchiveBmon(issBmon);
+  inputArchiveBmon >> *fvDigiBmon;
+  ++uPartIdx;
+
+  /// STS
+  std::string msgStrSts(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issSts(msgStrSts);
+  boost::archive::binary_iarchive inputArchiveSts(issSts);
+  inputArchiveSts >> *fvDigiSts;
+  ++uPartIdx;
+
+  /// MUCH
+  std::string msgStrMuch(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issMuch(msgStrMuch);
+  boost::archive::binary_iarchive inputArchiveMuch(issMuch);
+  inputArchiveMuch >> *fvDigiMuch;
+  ++uPartIdx;
+
+  /// TRD
+  std::string msgStrTrd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issTrd(msgStrTrd);
+  boost::archive::binary_iarchive inputArchiveTrd(issTrd);
+  inputArchiveTrd >> *fvDigiTrd;
+  ++uPartIdx;
+
+  /// BmonF
+  std::string msgStrTof(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issTof(msgStrTof);
+  boost::archive::binary_iarchive inputArchiveTof(issTof);
+  inputArchiveTof >> *fvDigiTof;
+  ++uPartIdx;
+
+  /// RICH
+  std::string msgStrRich(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issRich(msgStrRich);
+  boost::archive::binary_iarchive inputArchiveRich(issRich);
+  inputArchiveRich >> *fvDigiRich;
+  ++uPartIdx;
+
+  /// PSD
+  std::string msgStrPsd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issPsd(msgStrPsd);
+  boost::archive::binary_iarchive inputArchivePsd(issPsd);
+  inputArchivePsd >> *fvDigiPsd;
+  ++uPartIdx;
+
+  /// Call Algo ProcessTs method
+  fpAlgo->ProcessTs();
+
+  /// Send events vector to ouput
+  if (!SendEvents(parts)) return false;
+
+  /// Clear metadata
+  fTimeSliceMetaDataArray->Clear();
+
+  /// Clear vectors
+  fvDigiBmon->clear();
+  fvDigiSts->clear();
+  fvDigiMuch->clear();
+  fvDigiTrd->clear();
+  fvDigiTof->clear();
+  fvDigiRich->clear();
+  fvDigiPsd->clear();
+
+  /// Clear event vector after usage
+  fpAlgo->ClearEventVector();
+  fEvents->Clear("C");
+
+  /// Histograms management
+  if (kTRUE == fbFillHistos) {
+    /// Send histograms each 100 time slices. Should be each ~1s
+    /// Use also runtime checker to trigger sending after M s if
+    /// processing too slow or delay sending if processing too fast
+    std::chrono::system_clock::time_point currentTime = std::chrono::system_clock::now();
+    std::chrono::duration<double_t> elapsedSeconds    = currentTime - fLastPublishTime;
+    if ((fdMaxPublishTime < elapsedSeconds.count())
+        || (0 == fulNumMessages % fuPublishFreqTs && fdMinPublishTime < elapsedSeconds.count())) {
+      SendHistograms();
+      fLastPublishTime = std::chrono::system_clock::now();
+    }
+  }
+
+  return true;
+}
+
+bool CbmDeviceBuildRawEvents::SendEvents(FairMQParts& partsIn)
+{
+  /// Clear events TClonesArray before usage.
+  fEvents->Delete();
+
+  /// Get vector reference from algo
+  std::vector<CbmEvent*> vEvents = fpAlgo->GetEventVector();
+
+  /// Move CbmEvent from temporary vector to TClonesArray
+  for (CbmEvent* event : vEvents) {
+    LOG(debug) << "Vector: " << event->ToString();
+    new ((*fEvents)[fEvents->GetEntriesFast()]) CbmEvent(std::move(*event));
+    LOG(debug) << "TClonesArray: " << static_cast<CbmEvent*>(fEvents->At(fEvents->GetEntriesFast() - 1))->ToString();
+  }
+
+  /// Serialize the array of events into a single MQ message
+  FairMQMessagePtr message(NewMessage());
+  //  Serialize<RootSerializer>(*message, fEvents);
+  RootSerializer().Serialize(*message, fEvents);
+
+  /// Add it at the end of the input composed message
+  FairMQParts partsOut(std::move(partsIn));
+  partsOut.AddPart(std::move(message));
+
+  if (Send(partsOut, fsChannelNameDataOutput) < 0) {
+    LOG(error) << "Problem sending data to " << fsChannelNameDataOutput;
+    return false;
+  }
+
+  return true;
+}
+
+bool CbmDeviceBuildRawEvents::SendHistograms()
+{
+  /// Serialize the array of histos into a single MQ message
+  FairMQMessagePtr message(NewMessage());
+  //  Serialize<RootSerializer>(*message, &fArrayHisto);
+  RootSerializer().Serialize(*message, &fArrayHisto);
+
+  /// Send message to the common histogram messages queue
+  if (Send(message, fsChannelNameHistosInput) < 0) {
+    LOG(error) << "Problem sending data";
+    return false;
+  }
+
+  /// Reset the histograms after sending them (but do not reset the time)
+  fpAlgo->ResetHistograms(kFALSE);
+
+  return true;
+}
+
+CbmDeviceBuildRawEvents::~CbmDeviceBuildRawEvents()
+{
+  /// Clear metadata
+  fTimeSliceMetaDataArray->Clear();
+  delete fTsMetaData;
+
+  /// Clear vectors
+  fvDigiBmon->clear();
+  fvDigiSts->clear();
+  fvDigiMuch->clear();
+  fvDigiTrd->clear();
+  fvDigiTof->clear();
+  fvDigiRich->clear();
+  fvDigiPsd->clear();
+
+  /// Clear events TClonesArray
+  fEvents->Delete();
+
+  delete fpRun;
+  delete fTimeSliceMetaDataArray;
+  delete fEvents;
+  delete fpAlgo;
+}
+
+void CbmDeviceBuildRawEvents::Finish() {}

MQ/mcbm/CbmDeviceBuildRawEvents.h

+/* Copyright (C) 2020-2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau, Dominik Smith [committer] */
+
+/**
+ * CbmDeviceBuildRawEvents.h
+ *
+ * @since 2020-05-24
+ * @author P.-A. Loizeau
+ */
+
+#ifndef CBMDEVICEBUILDRAWEVENTS_H_
+#define CBMDEVICEBUILDRAWEVENTS_H_
+
+/// CBM headers
+#include "CbmAlgoBuildRawEvents.h"
+#include "CbmBmonDigi.h"
+#include "CbmMuchBeamTimeDigi.h"
+#include "CbmPsdDigi.h"
+#include "CbmRichDigi.h"
+#include "CbmStsDigi.h"
+#include "CbmTofDigi.h"
+#include "CbmTrdDigi.h"
+
+/// FAIRROOT headers
+#include "FairMQDevice.h"
+
+/// FAIRSOFT headers (geant, boost, ...)
+#include "Rtypes.h"
+#include "TObjArray.h"
+
+/// C/C++ headers
+#include <chrono>
+#include <map>
+#include <vector>
+
+class TList;
+class TClonesArray;
+class FairRunOnline;
+class TimesliceMetaData;
+
+class CbmDeviceBuildRawEvents : public FairMQDevice {
+public:
+  CbmDeviceBuildRawEvents();
+  virtual ~CbmDeviceBuildRawEvents();
+
+protected:
+  virtual void InitTask();
+  bool HandleData(FairMQParts&, int);
+  bool HandleCommand(FairMQMessagePtr&, int);
+
+private:
+  /// Constants
+
+  /// Control flags
+  Bool_t fbIgnoreTsOverlap = kFALSE;  //! Ignore data in Overlap part of the TS
+  Bool_t fbFillHistos      = kTRUE;   //! Switch ON/OFF filling of histograms
+
+  /// User settings parameters
+  /// Algo enum settings
+  std::string fsEvtOverMode                = "NoOverlap";
+  std::string fsRefDet                     = "kBmon";
+  std::vector<std::string> fvsAddDet       = {};
+  std::vector<std::string> fvsDelDet       = {};
+  std::vector<std::string> fvsSetTrigWin   = {};
+  std::vector<std::string> fvsSetTrigMinNb = {};
+  /// message queues
+  std::string fsChannelNameDataInput    = "unpts_0";
+  std::string fsChannelNameDataOutput   = "events";
+  std::string fsChannelNameCommands     = "commands";
+  std::string fsChannelNameHistosInput  = "histogram-in";
+  std::string fsChannelNameHistosConfig = "histo-conf";
+  std::string fsChannelNameCanvasConfig = "canvas-conf";
+  /// Histograms management
+  uint32_t fuPublishFreqTs  = 100;
+  double_t fdMinPublishTime = 0.5;
+  double_t fdMaxPublishTime = 5.0;
+
+  /// List of MQ channels names
+  std::vector<std::string> fsAllowedChannels = {fsChannelNameDataInput};
+
+  /// Statistics & first TS rejection
+  uint64_t fulNumMessages                                = 0;
+  uint64_t fulTsCounter                                  = 0;
+  std::chrono::system_clock::time_point fLastPublishTime = std::chrono::system_clock::now();
+
+  /// Processing algos
+  CbmAlgoBuildRawEvents* fpAlgo = nullptr;
+
+  /// TS MetaData stable values storage
+  size_t fuNbCoreMsPerTs    = 0;        //!
+  size_t fuNbOverMsPerTs    = 0;        //!
+  Double_t fdMsSizeInNs     = 1280000;  //! Size of a single MS, [nanoseconds]
+  Double_t fdTsCoreSizeInNs = -1.0;     //! Total size of the core MS in a TS, [nanoseconds]
+  Double_t fdTsOverSizeInNs = -1.0;     //! Total size of the overlap MS in a TS, [nanoseconds]
+  Double_t fdTsFullSizeInNs = -1.0;     //! Total size of all MS in a TS, [nanoseconds]
+
+  /// Data reception
+  /// TS MetaData storage
+  TClonesArray* fTimeSliceMetaDataArray = nullptr;  //!
+  TimesliceMetaData* fTsMetaData        = nullptr;
+  /// Digis storage
+  std::vector<CbmBmonDigi>* fvDigiBmon         = nullptr;
+  std::vector<CbmStsDigi>* fvDigiSts           = nullptr;
+  std::vector<CbmMuchBeamTimeDigi>* fvDigiMuch = nullptr;
+  std::vector<CbmTrdDigi>* fvDigiTrd           = nullptr;
+  std::vector<CbmTofDigi>* fvDigiTof           = nullptr;
+  std::vector<CbmRichDigi>* fvDigiRich         = nullptr;
+  std::vector<CbmPsdDigi>* fvDigiPsd           = nullptr;
+  /// Data emission
+  TClonesArray* fEvents = nullptr;  //! output container of CbmEvents
+  //      std::vector< CbmEvent * > &        fEventVector;    //! vector with all created events
+
+  /// Internal data registration (for FairRootManager -> DigiManager links)
+  FairRunOnline* fpRun = nullptr;
+
+  /// Array of histograms to send to the histogram server
+  TObjArray fArrayHisto = {};
+  /// Vector of string pairs with ( HistoName, FolderPath ) to send to the histogram server
+  std::vector<std::pair<std::string, std::string>> fvpsHistosFolder = {};
+  /// Vector of string pairs with ( CanvasName, CanvasConfig ) to send to the histogram server
+  /// Format of Can config is "NbPadX(U);NbPadY(U);ConfigPad1(s);....;ConfigPadXY(s)"
+  /// Format of Pad config is "GrixX(b),GridY(b),LogX(b),LogY(b),LogZ(b),HistoName(s),DrawOptions(s)"
+  std::vector<std::pair<std::string, std::string>> fvpsCanvasConfig = {};
+
+  bool IsChannelNameAllowed(std::string channelName);
+  void Finish();
+  bool SendEvents(FairMQParts& partsIn);
+  bool SendHistograms();
+};
+
+#endif /* CBMDEVICEBUILDRAWEVENTS_H_ */

MQ/mcbm/CbmDeviceDigiEventSink.cxx

+/* Copyright (C) 2020-2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
+/**
+ * CbmDeviceDigiEventSink.cxx
+ *
+ * @since 2020-05-24
+ * @author P.-A. Loizeau
+ */
+
+#include "CbmDeviceDigiEventSink.h"
+
+
+/// CBM headers
+#include "CbmEvent.h"
+#include "CbmFlesCanvasTools.h"
+#include "CbmMQDefs.h"
+
+#include "TimesliceMetaData.h"
+
+/// FAIRROOT headers
+#include "FairMQLogger.h"
+#include "FairMQProgOptions.h"  // device->fConfig
+#include "FairParGenericSet.h"
+#include "FairRootFileSink.h"
+#include "FairRootManager.h"
+#include "FairRunOnline.h"
+#include "FairSource.h"
+
+#include "BoostSerializer.h"
+
+#include "RootSerializer.h"
+
+/// FAIRSOFT headers (geant, boost, ...)
+#include "TCanvas.h"
+#include "TFile.h"
+#include "TH1.h"
+#include "TList.h"
+#include "TNamed.h"
+#include "TProfile.h"
+
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/serialization/utility.hpp>
+
+/// C/C++ headers
+#include <array>
+#include <iomanip>
+#include <stdexcept>
+#include <string>
+#include <thread>  // this_thread::sleep_for
+struct InitTaskError : std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+using namespace std;
+
+//Bool_t bMcbm2018MonitorTaskBmonResetHistos = kFALSE;
+
+CbmDeviceDigiEventSink::CbmDeviceDigiEventSink() {}
+
+void CbmDeviceDigiEventSink::InitTask()
+try {
+  /// Read options from executable
+  LOG(info) << "Init options for CbmDeviceDigiEventSink.";
+
+  fbStoreFullTs    = fConfig->GetValue<bool>("StoreFullTs");
+  fsOutputFileName = fConfig->GetValue<std::string>("OutFileName");
+
+  fsChannelNameDataInput = fConfig->GetValue<std::string>("EvtNameIn");
+  fsAllowedChannels[0]   = fsChannelNameDataInput;
+
+  fbBypassConsecutiveTs = fConfig->GetValue<bool>("BypassConsecutiveTs");
+  fbWriteMissingTs      = fConfig->GetValue<bool>("WriteMissingTs");
+  fbDisableCompression  = fConfig->GetValue<bool>("DisableCompression");
+  fiTreeFileMaxSize     = fConfig->GetValue<int64_t>("TreeFileMaxSize");
+  fbDigiEventInput      = fConfig->GetValue<bool>("DigiEventInput");
+  fbExclusiveTrdExtract = fConfig->GetValue<bool>("ExclusiveTrdExtract");
+
+  fbFillHistos             = fConfig->GetValue<bool>("FillHistos");
+  fuPublishFreqTs          = fConfig->GetValue<uint32_t>("PubFreqTs");
+  fdMinPublishTime         = fConfig->GetValue<double_t>("PubTimeMin");
+  fdMaxPublishTime         = fConfig->GetValue<double_t>("PubTimeMax");
+  fsHistosSuffix           = fConfig->GetValue<std::string>("HistosSuffix");
+  fsChannelNameHistosInput = fConfig->GetValue<std::string>("ChNameIn");
+
+  /// Associate the MissedTs Channel to the corresponding handler
+  OnData(fsChannelNameMissedTs, &CbmDeviceDigiEventSink::HandleMissTsData);
+
+  /// Associate the command Channel to the corresponding handler
+  OnData(fsChannelNameCommands, &CbmDeviceDigiEventSink::HandleCommand);
+
+  /// Associate the Event + Unp data Channel to the corresponding handler
+  // Get the information about created channels from the device
+  // Check if the defined channels from the topology (by name)
+  // are in the list of channels which are possible/allowed
+  // for the device
+  // The idea is to check at initilization if the devices are
+  // properly connected. For the time beeing this is done with a
+  // nameing convention. It is not avoided that someone sends other
+  // data on this channel.
+  //logger::SetLogLevel("INFO");
+  int noChannel = fChannels.size();
+  LOG(info) << "Number of defined channels: " << noChannel;
+  for (auto const& entry : fChannels) {
+    LOG(info) << "Channel name: " << entry.first;
+    if (std::string::npos != entry.first.find(fsChannelNameDataInput)) {
+      if (!IsChannelNameAllowed(entry.first)) throw InitTaskError("Channel name does not match.");
+      OnData(entry.first, &CbmDeviceDigiEventSink::HandleData);
+    }  // if( entry.first.find( "ts" )
+  }    // for( auto const &entry : fChannels )
+
+  //   InitContainers();
+
+  /// Prepare storage TClonesArrays
+  /// TS MetaData storage
+  fTimeSliceMetaDataArray = new TClonesArray("TimesliceMetaData", 1);
+  if (NULL == fTimeSliceMetaDataArray) {
+    throw InitTaskError("Failed creating the TS meta data TClonesarray ");
+  }  // if( NULL == fTimeSliceMetaDataArray )
+     /// Events storage
+  /// TODO: remove TObject from CbmEvent and switch to vectors!
+  fEventsSel = new std::vector<CbmDigiEvent>();
+
+  /// Prepare root output
+  if ("" != fsOutputFileName) {
+    fpRun                   = new FairRunOnline();
+    FairRootFileSink* pSink = new FairRootFileSink(fsOutputFileName);
+    fpFairRootMgr           = FairRootManager::Instance();
+    fpFairRootMgr->SetSink(pSink);
+    if (nullptr == fpFairRootMgr->GetOutFile()) {
+      throw InitTaskError("Could not open root file");
+    }  // if( nullptr == fpFairRootMgr->GetOutFile() )
+    if (fbDisableCompression) {
+      /// Completely disable the root file compression
+      pSink->GetRootFile()->SetCompressionLevel(0);
+    }
+    /// Set global size limit for all TTree in this process/Root instance
+    TTree::SetMaxTreeSize(fiTreeFileMaxSize);
+  }  // if( "" != fsOutputFileName )
+  else {
+    throw InitTaskError("Empty output filename!");
+  }  // else of if( "" != fsOutputFileName )
+
+  LOG(info) << "Init Root Output to " << fsOutputFileName;
+
+  fpFairRootMgr->InitSink();
+  fEvtHeader = new CbmTsEventHeader();
+  fpFairRootMgr->Register("EventHeader.", "Event", fEvtHeader, kTRUE);
+
+  /// Register all input data members with the FairRoot manager
+  /// TS MetaData
+  fpFairRootMgr->Register("TimesliceMetaData", "TS Meta Data", fTimeSliceMetaDataArray, kTRUE);
+  /// CbmEvent
+  fpFairRootMgr->RegisterAny("DigiEvent", fEventsSel, kTRUE);
+
+  /// Full TS Digis storage (optional usage, controlled by fbStoreFullTs!)
+  if (fbStoreFullTs) {
+    fvDigiBmon = new std::vector<CbmBmonDigi>();
+    fvDigiSts  = new std::vector<CbmStsDigi>();
+    fvDigiMuch = new std::vector<CbmMuchDigi>();
+    fvDigiTrd  = new std::vector<CbmTrdDigi>();
+    fvDigiTof  = new std::vector<CbmTofDigi>();
+    fvDigiRich = new std::vector<CbmRichDigi>();
+    fvDigiPsd  = new std::vector<CbmPsdDigi>();
+
+    fpFairRootMgr->RegisterAny(CbmBmonDigi::GetBranchName(), fvDigiBmon, kTRUE);
+    fpFairRootMgr->RegisterAny(CbmStsDigi::GetBranchName(), fvDigiSts, kTRUE);
+    fpFairRootMgr->RegisterAny(CbmMuchDigi::GetBranchName(), fvDigiMuch, kTRUE);
+    fpFairRootMgr->RegisterAny(CbmTrdDigi::GetBranchName(), fvDigiTrd, kTRUE);
+    fpFairRootMgr->RegisterAny(CbmTofDigi::GetBranchName(), fvDigiTof, kTRUE);
+    fpFairRootMgr->RegisterAny(CbmRichDigi::GetBranchName(), fvDigiRich, kTRUE);
+    fpFairRootMgr->RegisterAny(CbmPsdDigi::GetBranchName(), fvDigiPsd, kTRUE);
+  }
+
+  fpFairRootMgr->WriteFolder();
+
+  LOG(info) << "Initialized outTree with rootMgr at " << fpFairRootMgr;
+
+  /// Histograms management
+  if (kTRUE == fbFillHistos) {
+    /// Comment to prevent clang format single lining
+    if (kFALSE == InitHistograms()) { throw InitTaskError("Failed to initialize the histograms."); }
+  }  // if( kTRUE == fbFillHistos )
+  fbInitDone = true;
+}
+catch (InitTaskError& e) {
+  LOG(error) << e.what();
+  // Wrapper defined in CbmMQDefs.h to support different FairMQ versions
+  cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
+}
+
+bool CbmDeviceDigiEventSink::IsChannelNameAllowed(std::string channelName)
+{
+  for (auto const& entry : fsAllowedChannels) {
+    std::size_t pos1 = channelName.find(entry);
+    if (pos1 != std::string::npos) {
+      const vector<std::string>::const_iterator pos =
+        std::find(fsAllowedChannels.begin(), fsAllowedChannels.end(), entry);
+      const vector<std::string>::size_type idx = pos - fsAllowedChannels.begin();
+      LOG(info) << "Found " << entry << " in " << channelName;
+      LOG(info) << "Channel name " << channelName << " found in list of allowed channel names at position " << idx;
+      return true;
+    }  // if (pos1!=std::string::npos)
+  }    // for(auto const &entry : fsAllowedChannels)
+  LOG(info) << "Channel name " << channelName << " not found in list of allowed channel names.";
+  LOG(error) << "Stop device.";
+  return false;
+}
+
+bool CbmDeviceDigiEventSink::InitHistograms()
+{
+  /// Histos creation and obtain pointer on them
+  /// Trigger histo creation, filling vHistos and vCanvases
+  // bool initOK =CreateHistograms();
+  bool initOK = true;
+
+  /// Obtain vector of pointers on each histo from the algo (+ optionally desired folder) or create them locally
+  // ALGO: std::vector<std::pair<TNamed*, std::string>> vHistos = fMonitorAlgo->GetHistoVector();
+  std::vector<std::pair<TNamed*, std::string>> vHistos = {};
+
+  /* clang-format off */
+  fhFullTsBuffSizeEvo = new TProfile(Form("hFullTsBuffSizeEvo%s", fsHistosSuffix.data()),
+                                     "Evo. of the full TS buffer size; Time in run [s]; Size []",
+                                     720, 0, 7200);
+  fhMissTsBuffSizeEvo = new TProfile(Form("hMissTsBuffSizeEvo%s", fsHistosSuffix.data()),
+                                     "Evo. of the missed TS buffer size; Time in run [s]; Size []",
+                                     720, 0, 7200);
+  fhFullTsProcEvo  = new TH1I(Form("hFullTsProcEvo%s", fsHistosSuffix.data()),
+                              "Processed full TS; Time in run [s]; # []",
+                              720, 0, 7200);
+  fhMissTsProcEvo  = new TH1I(Form("hMissTsProcEvo%s", fsHistosSuffix.data()),
+                              "Processed missing TS; Time in run [s]; # []",
+                              720, 0, 7200);
+  fhTotalTsProcEvo = new TH1I(Form("hTotalTsProcEvo%s", fsHistosSuffix.data()),
+                              "Total processed TS; Time in run [s]; # []",
+                              720, 0, 7200);
+  fhTotalEventsEvo = new TH1I(Form("hTotalEventsEvo%s", fsHistosSuffix.data()),
+                              "Processed events; Time in run [s]; # []",
+                              720, 0, 7200);
+  /* clang-format on */
+
+  std::string sFolder = std::string("EvtSink") + fsHistosSuffix;
+  vHistos.push_back(std::pair<TNamed*, std::string>(fhFullTsBuffSizeEvo, sFolder));
+  vHistos.push_back(std::pair<TNamed*, std::string>(fhMissTsBuffSizeEvo, sFolder));
+  vHistos.push_back(std::pair<TNamed*, std::string>(fhFullTsProcEvo, sFolder));
+  vHistos.push_back(std::pair<TNamed*, std::string>(fhMissTsProcEvo, sFolder));
+  vHistos.push_back(std::pair<TNamed*, std::string>(fhTotalTsProcEvo, sFolder));
+  vHistos.push_back(std::pair<TNamed*, std::string>(fhTotalEventsEvo, sFolder));
+
+  /// Obtain vector of pointers on each canvas from the algo (+ optionally desired folder) or create them locally
+  // ALGO: std::vector<std::pair<TCanvas*, std::string>> vCanvases = fMonitorAlgo->GetCanvasVector();
+  std::vector<std::pair<TCanvas*, std::string>> vCanvases = {};
+
+  fcEventSinkAllHist = new TCanvas(Form("cEventSinkAllHist%s", fsHistosSuffix.data()), "Event Sink Monitoring");
+  fcEventSinkAllHist->Divide(3, 2);
+
+  fcEventSinkAllHist->cd(1);
+  gPad->SetGridx();
+  gPad->SetGridy();
+  fhFullTsBuffSizeEvo->Draw("hist");
+
+  fcEventSinkAllHist->cd(2);
+  gPad->SetGridx();
+  gPad->SetGridy();
+  fhMissTsBuffSizeEvo->Draw("hist");
+
+  fcEventSinkAllHist->cd(3);
+  gPad->SetGridx();
+  gPad->SetGridy();
+  fhFullTsProcEvo->Draw("hist");
+
+  fcEventSinkAllHist->cd(4);
+  gPad->SetGridx();
+  gPad->SetGridy();
+  fhMissTsProcEvo->Draw("hist");
+
+  fcEventSinkAllHist->cd(5);
+  gPad->SetGridx();
+  gPad->SetGridy();
+  fhTotalTsProcEvo->Draw("hist");
+
+  fcEventSinkAllHist->cd(6);
+  gPad->SetGridx();
+  gPad->SetGridy();
+  gPad->SetLogy();
+  fhTotalEventsEvo->Draw("hist");
+
+  vCanvases.push_back(std::pair<TCanvas*, std::string>(fcEventSinkAllHist, std::string("canvases") + fsHistosSuffix));
+
+  /// Add pointers to each histo in the histo array
+  /// Create histo config vector
+  /// ===> Use an std::vector< std::pair< std::string, std::string > > with < Histo name, Folder >
+  ///      and send it through a separate channel using the BoostSerializer
+  for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto) {
+    //         LOG(info) << "Registering  " << vHistos[ uHisto ].first->GetName()
+    //                   << " in " << vHistos[ uHisto ].second.data()
+    //                   ;
+    fArrayHisto.Add(vHistos[uHisto].first);
+    std::pair<std::string, std::string> psHistoConfig(vHistos[uHisto].first->GetName(), vHistos[uHisto].second);
+    fvpsHistosFolder.push_back(psHistoConfig);
+
+    LOG(info) << "Config of hist  " << psHistoConfig.first.data() << " in folder " << psHistoConfig.second.data();
+  }  // for( UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto )
+
+  /// Create canvas config vector
+  /// ===> Use an std::vector< std::pair< std::string, std::string > > with < Canvas name, config >
+  ///      and send it through a separate channel using the BoostSerializer
+  for (UInt_t uCanv = 0; uCanv < vCanvases.size(); ++uCanv) {
+    //         LOG(info) << "Registering  " << vCanvases[ uCanv ].first->GetName()
+    //                   << " in " << vCanvases[ uCanv ].second.data();
+    std::string sCanvName = (vCanvases[uCanv].first)->GetName();
+    std::string sCanvConf = GenerateCanvasConfigString(vCanvases[uCanv].first);
+
+    std::pair<std::string, std::string> psCanvConfig(sCanvName, sCanvConf);
+
+    fvpsCanvasConfig.push_back(psCanvConfig);
+
+    LOG(info) << "Config string of Canvas  " << psCanvConfig.first.data() << " is " << psCanvConfig.second.data();
+  }  //  for( UInt_t uCanv = 0; uCanv < vCanvases.size(); ++uCanv )
+
+  return initOK;
+}
+bool CbmDeviceDigiEventSink::ResetHistograms(bool bResetStartTime)
+{
+  fhFullTsBuffSizeEvo->Reset();
+  fhMissTsBuffSizeEvo->Reset();
+  fhFullTsProcEvo->Reset();
+  fhMissTsProcEvo->Reset();
+  fhTotalTsProcEvo->Reset();
+  fhTotalEventsEvo->Reset();
+  if (bResetStartTime) {
+    /// Reset the start time of the time evolution histograms
+    fStartTime = std::chrono::system_clock::now();
+  }
+  return true;
+}
+
+//--------------------------------------------------------------------//
+// handler is called whenever a message arrives on fsChannelNameMissedTs, with a reference to the message and a sub-channel index (here 0)
+bool CbmDeviceDigiEventSink::HandleMissTsData(FairMQMessagePtr& msg, int /*index*/)
+{
+  std::vector<uint64_t> vIndices;
+  std::string msgStrMissTs(static_cast<char*>(msg->GetData()), msg->GetSize());
+  std::istringstream issMissTs(msgStrMissTs);
+  boost::archive::binary_iarchive inputArchiveMissTs(issMissTs);
+  inputArchiveMissTs >> vIndices;
+
+  fvulMissedTsIndices.insert(fvulMissedTsIndices.end(), vIndices.begin(), vIndices.end());
+
+  /// Check TS queue and process it if needed (in case it filled a hole!)
+  if (!fbBypassConsecutiveTs) {
+    /// But only if Consecutive TS check is not disabled explicitly by user
+    CheckTsQueues();
+  }
+
+  return true;
+}
+//--------------------------------------------------------------------//
+// handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)
+bool CbmDeviceDigiEventSink::HandleData(FairMQParts& parts, int /*index*/)
+{
+  fulNumMessages++;
+  LOG(debug) << "Received message number " << fulNumMessages << " with " << parts.Size() << " parts"
+             << ", size0: " << parts.At(0)->GetSize();
+
+  if (0 == fulNumMessages % 10000) LOG(info) << "Received " << fulNumMessages << " messages";
+
+  /// Unpack the message
+  CbmEventTimeslice unpTs(parts, fbDigiEventInput);
+
+  /// FIXME: Need to check if TS arrived in order (probably not!!!) + buffer!!!
+  LOG(debug) << "Next TS check " << fuPrevTsIndex << " " << fulTsCounter << " " << unpTs.fTsMetaData.GetIndex()
+             << " Storage size: " << fmFullTsStorage.size();
+  if (fbBypassConsecutiveTs || (fuPrevTsIndex + 1 == unpTs.fTsMetaData.GetIndex())
+      || (0 == fuPrevTsIndex && 0 == fulTsCounter && 0 == unpTs.fTsMetaData.GetIndex())) {
+    LOG(debug) << "TS direct to dump";
+    /// Fill all storage variables registers for data output
+    PrepareTreeEntry(unpTs);
+    /// Trigger FairRoot manager to dump Tree entry
+    DumpTreeEntry();
+    /// Update counters
+    fuPrevTsIndex = unpTs.fTsMetaData.GetIndex();
+    fulTsCounter++;
+  }
+  else {
+    LOG(debug) << "TS direct to storage";
+    /// If not consecutive to last TS sent,
+    fmFullTsStorage.emplace_hint(fmFullTsStorage.end(),
+                                 std::pair<uint64_t, CbmEventTimeslice>(unpTs.fTsMetaData.GetIndex(), unpTs));
+  }
+  LOG(debug) << "TS metadata checked";
+
+  /// Clear metadata => crashes, maybe not needed as due to move the pointer is invalidated?
+  //   delete fTsMetaData;
+
+  if (fbBypassConsecutiveTs) {
+    /// Skip checking the TS buffer as writing straight to file
+    /// => Just check if we are done and can close the file or not
+    if (fbReceivedEof) {
+      /// In this case we cannot check if the last TS received/processed is the final one due to lack of order
+      /// => use instead the fact that we received all expected TS
+      if ((fulTsCounter + fvulMissedTsIndices.size()) == fuTotalTsCount) {
+        LOG(info) << "CbmDeviceDigiEventSink::HandleData => "
+                  << "Found all expected TS (" << fulTsCounter << ") and total nb of TS " << fuTotalTsCount
+                  << " after accounting for the ones reported as missing by the source (" << fvulMissedTsIndices.size()
+                  << ")";
+        Finish();
+      }  // if ((fulTsCounter + fvulMissedTsIndices.size()) == fuTotalTsCount)
+    }
+  }
+  else {
+    /// Check TS queue and process it if needed (in case it filled a hole!)
+    CheckTsQueues();
+    LOG(debug) << "TS queues checked";
+  }
+
+  /// Histograms management
+  if (kTRUE == fbFillHistos) {
+    std::chrono::system_clock::time_point currentTime = std::chrono::system_clock::now();
+
+    /// Fill histograms every 5 or more seconds
+    /// TODO: make it a parameter
+    std::chrono::duration<double_t> elapsedSecondsFill = currentTime - fLastFillTime;
+    if (1.0 < elapsedSecondsFill.count()) {
+      std::chrono::duration<double_t> secInRun = currentTime - fStartTime;
+
+      /// Rely on the fact that all histos have same X axis to avoid multiple "current bin" search
+      /*
+      int32_t iBinIndex = fhFullTsBuffSizeEvo->FindBin(secInRun.count());
+      fhFullTsBuffSizeEvo->SetBinContent(iBinIndex, fmFullTsStorage.size());
+      fhMissTsBuffSizeEvo->SetBinContent(iBinIndex, fvulMissedTsIndices.size());
+      fhFullTsProcEvo->SetBinContent(iBinIndex, fulTsCounter);
+      fhMissTsProcEvo->SetBinContent(iBinIndex, fulMissedTsCounter);
+      fhTotalTsProcEvo->SetBinContent(iBinIndex, (fulTsCounter + fulMissedTsCounter));
+      fhTotalEventsEvo->SetBinContent(iBinIndex, fulProcessedEvents);
+      */
+      fhFullTsBuffSizeEvo->Fill(secInRun.count(), fmFullTsStorage.size());
+      fhMissTsBuffSizeEvo->Fill(secInRun.count(), fvulMissedTsIndices.size());
+      fhFullTsProcEvo->Fill(secInRun.count(), (fulTsCounter - fulLastFullTsCounter));
+      fhMissTsProcEvo->Fill(secInRun.count(), (fulMissedTsCounter - fulLastMissTsCounter));
+      fhTotalTsProcEvo->Fill(secInRun.count(),
+                             (fulTsCounter - fulLastFullTsCounter + fulMissedTsCounter - fulLastMissTsCounter));
+      fhTotalEventsEvo->Fill(secInRun.count(), fulProcessedEvents - fulLastProcessedEvents);
+
+      fLastFillTime          = currentTime;
+      fulLastFullTsCounter   = fulTsCounter;
+      fulLastMissTsCounter   = fulMissedTsCounter;
+      fulLastProcessedEvents = fulProcessedEvents;
+    }
+
+    /// Send histograms each N timeslices.
+    /// Use also runtime checker to trigger sending after M s if
+    /// processing too slow or delay sending if processing too fast
+    std::chrono::duration<double_t> elapsedSeconds = currentTime - fLastPublishTime;
+    if ((fdMaxPublishTime < elapsedSeconds.count())
+        || (0 == fulNumMessages % fuPublishFreqTs && fdMinPublishTime < elapsedSeconds.count())) {
+      if (!fbConfigSent) {
+        // Send the configuration only once per run!
+        fbConfigSent = SendHistoConfAndData();
+      }  // if( !fbConfigSent )
+      else
+        SendHistograms();
+
+      fLastPublishTime = currentTime;
+    }  // if( ( fdMaxPublishTime < elapsedSeconds.count() ) || ( 0 == fulNumMessages % fuPublishFreqTs && fdMinPublishTime < elapsedSeconds.count() ) )
+  }    // if( kTRUE == fbFillHistos )
+
+  LOG(debug) << "Processed TS with saving " << (fulTsCounter + fulMissedTsCounter) << " TS (" << fulTsCounter
+             << " full ones and " << fulMissedTsCounter << " missed/empty ones)";
+  LOG(debug) << "Buffers are " << fmFullTsStorage.size() << " full TS and " << fvulMissedTsIndices.size()
+             << " missed/empty ones)";
+
+  return true;
+}
+//--------------------------------------------------------------------//
+bool CbmDeviceDigiEventSink::HandleCommand(FairMQMessagePtr& msg, int /*index*/)
+{
+  /*
+   std::string sCommand( static_cast< char * >( msg->GetData() ),
+                          msg->GetSize() );
+*/
+  std::string sCommand;
+  std::string msgStrCmd(static_cast<char*>(msg->GetData()), msg->GetSize());
+  std::istringstream issCmd(msgStrCmd);
+  boost::archive::binary_iarchive inputArchiveCmd(issCmd);
+  inputArchiveCmd >> sCommand;
+
+  std::string sCmdTag = sCommand;
+  size_t charPosDel   = sCommand.find(' ');
+  if (std::string::npos != charPosDel) {
+    sCmdTag = sCommand.substr(0, charPosDel);
+  }  // if( std::string::npos != charPosDel )
+
+  if ("EOF" == sCmdTag) {
+    fbReceivedEof = true;
+
+    /// Extract the last TS index and global full TS count
+    if (std::string::npos == charPosDel) {
+      LOG(fatal) << "CbmDeviceDigiEventSink::HandleCommand => "
+                 << "Incomplete EOF command received: " << sCommand;
+      return false;
+    }  // if( std::string::npos == charPosDel )
+       /// Last TS index
+    charPosDel++;
+    std::string sNext = sCommand.substr(charPosDel);
+    charPosDel        = sNext.find(' ');
+
+    if (std::string::npos == charPosDel) {
+      LOG(fatal) << "CbmDeviceDigiEventSink::HandleCommand => "
+                 << "Incomplete EOF command received: " << sCommand;
+      return false;
+    }  // if( std::string::npos == charPosDel )
+    fuLastTsIndex = std::stoul(sNext.substr(0, charPosDel));
+    /// Total TS count
+    charPosDel++;
+    fuTotalTsCount = std::stoul(sNext.substr(charPosDel));
+
+    LOG(info) << "CbmDeviceDigiEventSink::HandleCommand => "
+              << "Received EOF command with final TS index " << fuLastTsIndex << " and total nb TS " << fuTotalTsCount;
+    /// End of data: clean save of data + close file + send last state of histos if enabled
+    if (fuPrevTsIndex == fuLastTsIndex && fulTsCounter == fuTotalTsCount) {
+      LOG(info) << "CbmDeviceDigiEventSink::HandleCommand => "
+                << "Found final TS index " << fuLastTsIndex << " and total nb TS " << fuTotalTsCount;
+      Finish();
+    }  // if( fuPrevTsIndex == fuLastTsIndex && fulTsCounter == fuTotalTsCount )
+  }    // if( "EOF" == sCmdTag )
+  else if ("STOP" == sCmdTag) {
+    /// TODO: different treatment in case of "BAD" ending compared to EOF?
+    /// Source failure: clean save of received data + close file + send last state of histos if enabled
+    Finish();
+  }  // else if( "STOP" == sCmdTag )
+  else {
+    LOG(warning) << "Unknown command received: " << sCmdTag << " => will be ignored!";
+  }  // else if command not recognized
+
+  return true;
+}
+//--------------------------------------------------------------------//
+void CbmDeviceDigiEventSink::CheckTsQueues()
+{
+  bool bHoleFoundInBothQueues = false;
+
+  std::map<uint64_t, CbmEventTimeslice>::iterator itFullTs = fmFullTsStorage.begin();
+  std::vector<uint64_t>::iterator itMissTs                 = fvulMissedTsIndices.begin();
+
+  while (!bHoleFoundInBothQueues) {
+    /// Check if the first TS in the full TS queue is the next one
+    if (fmFullTsStorage.end() != itFullTs && fuPrevTsIndex + 1 == (*itFullTs).first) {
+      /// Fill all storage variables registers for data output
+      PrepareTreeEntry((*itFullTs).second);
+      /// Trigger FairRoot manager to dump Tree entry
+      DumpTreeEntry();
+
+      /// Update counters
+      fuPrevTsIndex = (*itFullTs).first;
+      fulTsCounter++;
+
+      /// Increment iterator
+      ++itFullTs;
+      continue;
+    }  // if( fmFullTsStorage.end() != itFullTs && fuPrevTsIndex + 1 == (*itFullTs).first() )
+    if (fmFullTsStorage.end() != itFullTs)
+      LOG(debug) << "CbmDeviceDigiEventSink::CheckTsQueues => Full TS " << (*itFullTs).first << " VS "
+                 << (fuPrevTsIndex + 1);
+    /// Check if the first TS in the missed TS queue is the next one
+    if (fvulMissedTsIndices.end() != itMissTs
+        && ((0 == fuPrevTsIndex && fuPrevTsIndex == (*itMissTs))
+            || ((0 < fulTsCounter || 0 < fulMissedTsCounter) && fuPrevTsIndex + 1 == (*itMissTs)))) {
+
+      if (fbWriteMissingTs) {
+        /// Prepare entry with only dummy TS metadata and empty storage variables
+        new ((*fTimeSliceMetaDataArray)[fTimeSliceMetaDataArray->GetEntriesFast()])
+          TimesliceMetaData(0, 0, 0, (*itMissTs));
+
+        /// Trigger FairRoot manager to dump Tree entry
+        DumpTreeEntry();
+      }
+
+      /// Update counters
+      fuPrevTsIndex = (*itMissTs);
+      fulMissedTsCounter++;
+
+      /// Increment iterator
+      ++itMissTs;
+      continue;
+    }  // if( fvulMissedTsIndices.end() != itMissTs && fuPrevTsIndex + 1 == (*itMissTs ) )
+    if (fvulMissedTsIndices.end() != itMissTs)
+      LOG(debug) << "CbmDeviceDigiEventSink::CheckTsQueues => Empty TS " << (*itMissTs) << " VS "
+                 << (fuPrevTsIndex + 1);
+
+    /// Should be reached only if both queues at the end or hole found in both
+    bHoleFoundInBothQueues = true;
+  }  // while( !bHoleFoundInBothQueues )
+
+  LOG(debug) << "CbmDeviceDigiEventSink::CheckTsQueues => buffered TS " << fmFullTsStorage.size()
+             << " buffered empties " << fvulMissedTsIndices.size();
+  for (auto it = fmFullTsStorage.begin(); it != fmFullTsStorage.end(); ++it) {
+    LOG(debug) << "CbmDeviceDigiEventSink::CheckTsQueues => buffered TS index " << (*it).first;
+  }
+
+  /// Delete the processed entries
+  fmFullTsStorage.erase(fmFullTsStorage.begin(), itFullTs);
+  fvulMissedTsIndices.erase(fvulMissedTsIndices.begin(), itMissTs);
+
+  /// End of data: clean save of data + close file + send last state of histos if enabled
+  if (fbReceivedEof && fuPrevTsIndex == fuLastTsIndex && fulTsCounter == fuTotalTsCount) {
+    LOG(info) << "CbmDeviceDigiEventSink::CheckTsQueues => "
+              << "Found final TS index " << fuLastTsIndex << " and total nb TS " << fuTotalTsCount;
+    Finish();
+  }  // if( fbReceivedEof && fuPrevTsIndex == fuLastTsIndex && fulTsCounter == fuTotalTsCount )
+}
+//--------------------------------------------------------------------//
+void CbmDeviceDigiEventSink::PrepareTreeEntry(CbmEventTimeslice unpTs)
+{
+  /// FIXME: poor man solution with lots of data copy until we undertsnad how to properly deal
+  /// with FairMq messages ownership and memory managment
+
+  (*fEvtHeader) = std::move(unpTs.fCbmTsEventHeader);
+
+  /// FIXME: Not sure if this is the proper way to insert the data
+  new ((*fTimeSliceMetaDataArray)[fTimeSliceMetaDataArray->GetEntriesFast()])
+    TimesliceMetaData(std::move(unpTs.fTsMetaData));
+
+  /// Extract CbmEvent vector from input message
+  // FU, 29.06.22 Remove std::move to allow copy ellision
+  (*fEventsSel) = unpTs.GetSelectedData(fbExclusiveTrdExtract);
+  if (kTRUE == fbFillHistos) {
+    /// Accumulated counts, will show rise + plateau pattern in spill
+    fulProcessedEvents += fEventsSel->size();
+  }
+
+  /// Full TS Digis storage (optional usage, controlled by fbStoreFullTs!)
+  if (fbStoreFullTs) {
+    if (0 < unpTs.fvDigiBmon.size()) fvDigiBmon->assign(unpTs.fvDigiBmon.begin(), unpTs.fvDigiBmon.end());
+    if (0 < unpTs.fvDigiSts.size()) fvDigiSts->assign(unpTs.fvDigiSts.begin(), unpTs.fvDigiSts.end());
+    if (0 < unpTs.fvDigiMuch.size()) fvDigiMuch->assign(unpTs.fvDigiMuch.begin(), unpTs.fvDigiMuch.end());
+    if (0 < unpTs.fvDigiTrd.size()) fvDigiTrd->assign(unpTs.fvDigiTrd.begin(), unpTs.fvDigiTrd.end());
+    if (0 < unpTs.fvDigiTof.size()) fvDigiTof->assign(unpTs.fvDigiTof.begin(), unpTs.fvDigiTof.end());
+    if (0 < unpTs.fvDigiRich.size()) fvDigiRich->assign(unpTs.fvDigiRich.begin(), unpTs.fvDigiRich.end());
+    if (0 < unpTs.fvDigiPsd.size()) fvDigiPsd->assign(unpTs.fvDigiPsd.begin(), unpTs.fvDigiPsd.end());
+  }
+}
+void CbmDeviceDigiEventSink::DumpTreeEntry()
+{
+  // Unpacked digis + CbmEvent output to root file
+  /*
+ * NH style
+//      fpFairRootMgr->FillEventHeader(fEvtHeader);
+//      LOG(info) << "Fill WriteOutBuffer with FairRootManager at " << fpFairRootMgr;
+//      fpOutRootFile->cd();
+      fpFairRootMgr->Fill();
+      fpFairRootMgr->StoreWriteoutBufferData( fpFairRootMgr->GetEventTime() );
+      //fpFairRootMgr->StoreAllWriteoutBufferData();
+      fpFairRootMgr->DeleteOldWriteoutBufferData();
+*/
+  /// FairRunOnline style
+  fpFairRootMgr->StoreWriteoutBufferData(fpFairRootMgr->GetEventTime());
+  auto source = fpFairRootMgr->GetSource();
+  if (source) { source->FillEventHeader(fEvtHeader); }
+  fpFairRootMgr->Fill();
+  fpFairRootMgr->DeleteOldWriteoutBufferData();
+  //  fpFairRootMgr->Write();
+
+  /// Clear metadata array
+  fTimeSliceMetaDataArray->Clear();
+
+  /// Clear event vector
+  fEventsSel->clear();
+  /// Full TS Digis storage (optional usage, controlled by fbStoreFullTs!)
+  if (fbStoreFullTs) {
+    fvDigiBmon->clear();
+    fvDigiSts->clear();
+    fvDigiMuch->clear();
+    fvDigiTrd->clear();
+    fvDigiTof->clear();
+    fvDigiRich->clear();
+    fvDigiPsd->clear();
+  }
+}
+
+//--------------------------------------------------------------------//
+
+bool CbmDeviceDigiEventSink::SendHistoConfAndData()
+{
+  /// Prepare multiparts message and header
+  std::pair<uint32_t, uint32_t> pairHeader(fvpsHistosFolder.size(), fvpsCanvasConfig.size());
+  FairMQMessagePtr messageHeader(NewMessage());
+  //  Serialize<BoostSerializer<std::pair<uint32_t, uint32_t>>>(*messageHeader, pairHeader);
+  BoostSerializer<std::pair<uint32_t, uint32_t>>().Serialize(*messageHeader, pairHeader);
+
+  FairMQParts partsOut;
+  partsOut.AddPart(std::move(messageHeader));
+
+  for (UInt_t uHisto = 0; uHisto < fvpsHistosFolder.size(); ++uHisto) {
+    /// Serialize the vector of histo config into a single MQ message
+    FairMQMessagePtr messageHist(NewMessage());
+    //    Serialize<BoostSerializer<std::pair<std::string, std::string>>>(*messageHist, fvpsHistosFolder[uHisto]);
+    BoostSerializer<std::pair<std::string, std::string>>().Serialize(*messageHist, fvpsHistosFolder[uHisto]);
+
+    partsOut.AddPart(std::move(messageHist));
+  }  // for (UInt_t uHisto = 0; uHisto < fvpsHistosFolder.size(); ++uHisto)
+
+  /// Catch case where no histos are registered!
+  /// => Add empty message
+  if (0 == fvpsHistosFolder.size()) {
+    FairMQMessagePtr messageHist(NewMessage());
+    partsOut.AddPart(std::move(messageHist));
+  }
+
+  for (UInt_t uCanv = 0; uCanv < fvpsCanvasConfig.size(); ++uCanv) {
+    /// Serialize the vector of canvas config into a single MQ message
+    FairMQMessagePtr messageCan(NewMessage());
+    //    Serialize<BoostSerializer<std::pair<std::string, std::string>>>(*messageCan, fvpsCanvasConfig[uCanv]);
+    BoostSerializer<std::pair<std::string, std::string>>().Serialize(*messageCan, fvpsCanvasConfig[uCanv]);
+
+    partsOut.AddPart(std::move(messageCan));
+  }  // for (UInt_t uCanv = 0; uCanv < fvpsCanvasConfig.size(); ++uCanv)
+
+  /// Catch case where no Canvases are registered!
+  /// => Add empty message
+  if (0 == fvpsCanvasConfig.size()) {
+    FairMQMessagePtr messageHist(NewMessage());
+    partsOut.AddPart(std::move(messageHist));
+  }
+
+  /// Serialize the array of histos into a single MQ message
+  FairMQMessagePtr msgHistos(NewMessage());
+  RootSerializer().Serialize(*msgHistos, &fArrayHisto);
+
+  partsOut.AddPart(std::move(msgHistos));
+
+  /// Send the multi-parts message to the common histogram messages queue
+  if (Send(partsOut, fsChannelNameHistosInput) < 0) {
+    LOG(error) << "CbmTsConsumerReqDevExample::SendHistoConfAndData => Problem sending data";
+    return false;
+  }  // if( Send( partsOut, fsChannelNameHistosInput ) < 0 )
+
+  /// Reset the histograms after sending them (but do not reset the time)
+  ResetHistograms(false);
+
+  return true;
+}
+
+bool CbmDeviceDigiEventSink::SendHistograms()
+{
+  /// Serialize the array of histos into a single MQ message
+  FairMQMessagePtr message(NewMessage());
+  RootSerializer().Serialize(*message, &fArrayHisto);
+
+  /// Send message to the common histogram messages queue
+  if (Send(message, fsChannelNameHistosInput) < 0) {
+    LOG(error) << "Problem sending data";
+    return false;
+  }  // if( Send( message, fsChannelNameHistosInput ) < 0 )
+
+  /// Reset the histograms after sending them (but do not reset the time)
+  ResetHistograms(false);
+
+  return true;
+}
+
+//--------------------------------------------------------------------//
+void CbmDeviceDigiEventSink::PostRun()
+{
+  // Needed to avoid due to other end of ZMQ channel being already gone if called during Finish/destructor
+  if (kTRUE == fbFillHistos) {
+    SendHistograms();
+    fLastPublishTime = std::chrono::system_clock::now();
+  }  // if( kTRUE == fbFillHistos )
+}
+
+//--------------------------------------------------------------------//
+CbmDeviceDigiEventSink::~CbmDeviceDigiEventSink()
+{
+  /// FIXME: Add pointers check before delete
+
+  /// Close things properly if not already done
+  if (fbInitDone && !fbFinishDone) Finish();
+
+  /// Clear events vector
+  if (fbInitDone) {
+    fEventsSel->clear();
+    delete fEventsSel;
+  }
+
+  delete fpRun;
+}
+
+void CbmDeviceDigiEventSink::Finish()
+{
+  LOG(info) << "Performing clean close of the file";
+  // Clean closure of output to root file
+  fpFairRootMgr->Write();  // Broken due to FileMaxSize?!?
+  fpFairRootMgr->CloseSink();
+  LOG(info) << "File closed after saving " << (fulTsCounter + fulMissedTsCounter) << " TS (" << fulTsCounter
+            << " full ones and " << fulMissedTsCounter << " missed/empty ones)";
+  LOG(info) << "Still buffered TS " << fmFullTsStorage.size() << " and still buffered empties "
+            << fvulMissedTsIndices.size();
+
+  if (fair::mq::State::Running == GetCurrentState()) {
+    /// Force state transitions only if not already done by ODC/DDS!
+    ChangeState(fair::mq::Transition::Stop);
+    std::this_thread::sleep_for(std::chrono::milliseconds(3000));
+    ChangeState(fair::mq::Transition::End);
+  }
+
+  fbFinishDone = kTRUE;
+}
+
+
+CbmEventTimeslice::CbmEventTimeslice(FairMQParts& parts, bool bDigiEvtInput)
+{
+  fbDigiEvtInput = bDigiEvtInput;
+
+  uint32_t uPartIdx = 0;
+
+  if (fbDigiEvtInput) {
+    /// Digi events => Extract selected data from input message
+    if (3 != parts.Size()) {
+      LOG(error) << "CbmEventTimeslice::CbmEventTimeslice => Wrong number of parts to deserialize DigiEvents: "
+                 << parts.Size() << " VS 3!";
+      LOG(fatal) << "Probably the wrong value was used for the option DigiEventInput of the Sink or DigiEventOutput of "
+                 << "the event builder";
+    }
+
+    /// (1) TS header
+    TObject* tempObjectPointer = nullptr;
+    RootSerializer().Deserialize(*parts.At(uPartIdx), tempObjectPointer);
+    if (tempObjectPointer && TString(tempObjectPointer->ClassName()).EqualTo("CbmTsEventHeader")) {
+      fCbmTsEventHeader = *(static_cast<CbmTsEventHeader*>(tempObjectPointer));
+    }
+    else {
+      LOG(fatal) << "Failed to deserialize the TS header";
+    }
+    ++uPartIdx;
+
+    /// (2) TS metadata
+    tempObjectPointer = nullptr;
+    RootSerializer().Deserialize(*parts.At(uPartIdx), tempObjectPointer);
+
+    if (tempObjectPointer && TString(tempObjectPointer->ClassName()).EqualTo("TimesliceMetaData")) {
+      fTsMetaData = *(static_cast<TimesliceMetaData*>(tempObjectPointer));
+    }
+    else {
+      LOG(fatal) << "Failed to deserialize the TS metadata";
+    }
+    ++uPartIdx;
+
+    /// (3) Events
+    std::string msgStrEvt(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+    std::istringstream issEvt(msgStrEvt);
+    boost::archive::binary_iarchive inputArchiveEvt(issEvt);
+    inputArchiveEvt >> fvDigiEvents;
+    ++uPartIdx;
+
+    LOG(debug) << "Input event array " << fvDigiEvents.size();
+  }
+  else {
+    /// Raw data + raw events => Extract unpacked data from input message
+    if (10 != parts.Size()) {
+      LOG(error) << "CbmEventTimeslice::CbmEventTimeslice => Wrong number of parts to deserialize raw data + events: "
+                 << parts.Size() << " VS 10!";
+      LOG(fatal) << "Probably the wrong value was used for the option DigiEventInput of the Sink or DigiEventOutput of "
+                 << "the event builder";
+    }
+
+    /// (1) TS header
+    TObject* tempObjectPointer = nullptr;
+    RootSerializer().Deserialize(*parts.At(uPartIdx), tempObjectPointer);
+    if (tempObjectPointer && TString(tempObjectPointer->ClassName()).EqualTo("CbmTsEventHeader")) {
+      fCbmTsEventHeader = *(static_cast<CbmTsEventHeader*>(tempObjectPointer));
+    }
+    else {
+      LOG(fatal) << "Failed to deserialize the TS header";
+    }
+    ++uPartIdx;
+
+    /// (2) Bmon
+    std::string msgStrBmon(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+    std::istringstream issBmon(msgStrBmon);
+    boost::archive::binary_iarchive inputArchiveBmon(issBmon);
+    inputArchiveBmon >> fvDigiBmon;
+    ++uPartIdx;
+
+    /// (3) STS
+    std::string msgStrSts(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+    std::istringstream issSts(msgStrSts);
+    boost::archive::binary_iarchive inputArchiveSts(issSts);
+    inputArchiveSts >> fvDigiSts;
+    ++uPartIdx;
+
+    /// (4) MUCH
+    std::string msgStrMuch(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+    std::istringstream issMuch(msgStrMuch);
+    boost::archive::binary_iarchive inputArchiveMuch(issMuch);
+    inputArchiveMuch >> fvDigiMuch;
+    ++uPartIdx;
+
+    /// (5) TRD
+    std::string msgStrTrd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+    std::istringstream issTrd(msgStrTrd);
+    boost::archive::binary_iarchive inputArchiveTrd(issTrd);
+    inputArchiveTrd >> fvDigiTrd;
+    ++uPartIdx;
+
+    /// (6) BmonF
+    std::string msgStrTof(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+    std::istringstream issTof(msgStrTof);
+    boost::archive::binary_iarchive inputArchiveTof(issTof);
+    inputArchiveTof >> fvDigiTof;
+    ++uPartIdx;
+
+    /// (7) RICH
+    std::string msgStrRich(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+    std::istringstream issRich(msgStrRich);
+    boost::archive::binary_iarchive inputArchiveRich(issRich);
+    inputArchiveRich >> fvDigiRich;
+    ++uPartIdx;
+
+    /// (8) PSD
+    std::string msgStrPsd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+    std::istringstream issPsd(msgStrPsd);
+    boost::archive::binary_iarchive inputArchivePsd(issPsd);
+    inputArchivePsd >> fvDigiPsd;
+    ++uPartIdx;
+
+    /// (9) TS metadata
+    tempObjectPointer = nullptr;
+    RootSerializer().Deserialize(*parts.At(uPartIdx), tempObjectPointer);
+
+    if (tempObjectPointer && TString(tempObjectPointer->ClassName()).EqualTo("TimesliceMetaData")) {
+      fTsMetaData = *(static_cast<TimesliceMetaData*>(tempObjectPointer));
+    }
+    else {
+      LOG(fatal) << "Failed to deserialize the TS metadata";
+    }
+    ++uPartIdx;
+
+    /// (10) Events
+    /// FIXME: Find out if possible to use only the boost serializer/deserializer
+    /*
+    std::string msgStrEvt(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+    std::istringstream issEvt(msgStrEvt);
+    boost::archive::binary_iarchive inputArchiveEvt(issEvt);
+    inputArchiveEvt >> fvEvents;
+    ++uPartIdx;
+    LOG(info) << "Input event array " << fvEvents.size();
+    */
+    std::vector<CbmEvent>* pvOutEvents = nullptr;
+    RootSerializer().Deserialize(*parts.At(uPartIdx), pvOutEvents);
+    fvEvents = std::move(*pvOutEvents);
+    LOG(debug) << "Input event array " << fvEvents.size();
+  }
+}
+
+CbmEventTimeslice::~CbmEventTimeslice()
+{
+  fvDigiBmon.clear();
+  fvDigiSts.clear();
+  fvDigiMuch.clear();
+  fvDigiTrd.clear();
+  fvDigiTof.clear();
+  fvDigiRich.clear();
+  fvDigiPsd.clear();
+  fvEvents.clear();
+  fvDigiEvents.clear();
+}
+
+void CbmEventTimeslice::ExtractSelectedData(bool bExclusiveTrdExtract)
+{
+  fvDigiEvents.reserve(fvEvents.size());
+
+  /// Loop on events in input vector
+  for (CbmEvent event : fvEvents) {
+    CbmDigiEvent selEvent;
+    selEvent.fTime   = event.GetStartTime();
+    selEvent.fNumber = event.GetNumber();
+
+    /// For pure digi based event, we select "continuous slices of digis"
+    ///        => Copy block of [First Digi index, last digi index] with assign(it_start, it_stop)
+    ///        => No data increase for most detectors as we use time window selection
+    /// Keep TRD1D + TRD2D support as single det, otherwise may lead to holes in the digi sequence!
+    ///        => Need option to keep the loop to avoid adding extra digis if comparison to CbmEvents wanted
+
+    /// Get the proper order for block selection as TRD1D and TRD2D may insert indices in separate loops
+    /// => Needed to ensure that the start and stop of the block copy do not trigger a vector size exception
+    event.SortIndices();
+
+    /// for each detector, find the data in the Digi vectors and copy them
+    /// TODO: Template + loop on list of data types?
+    /// ==> Bmon
+    uint32_t uNbDigis = (0 < event.GetNofData(ECbmDataType::kBmonDigi) ? event.GetNofData(ECbmDataType::kBmonDigi) : 0);
+    if (uNbDigis) {
+      auto startIt = fvDigiBmon.begin() + event.GetIndex(ECbmDataType::kBmonDigi, 0);
+      auto stopIt  = fvDigiBmon.begin() + event.GetIndex(ECbmDataType::kBmonDigi, uNbDigis - 1);
+      ++stopIt;
+      selEvent.fData.fBmon.fDigis.assign(startIt, stopIt);
+    }
+
+    /// ==> STS
+    uNbDigis = (0 < event.GetNofData(ECbmDataType::kStsDigi) ? event.GetNofData(ECbmDataType::kStsDigi) : 0);
+    if (uNbDigis) {
+      auto startIt = fvDigiSts.begin() + event.GetIndex(ECbmDataType::kStsDigi, 0);
+      auto stopIt  = fvDigiSts.begin() + event.GetIndex(ECbmDataType::kStsDigi, uNbDigis - 1);
+      ++stopIt;
+      selEvent.fData.fSts.fDigis.assign(startIt, stopIt);
+    }
+
+    /// ==> MUCH
+    uNbDigis = (0 < event.GetNofData(ECbmDataType::kMuchDigi) ? event.GetNofData(ECbmDataType::kMuchDigi) : 0);
+    if (uNbDigis) {
+      auto startIt = fvDigiMuch.begin() + event.GetIndex(ECbmDataType::kMuchDigi, 0);
+      auto stopIt  = fvDigiMuch.begin() + event.GetIndex(ECbmDataType::kMuchDigi, uNbDigis - 1);
+      ++stopIt;
+      selEvent.fData.fMuch.fDigis.assign(startIt, stopIt);
+    }
+
+    /// ==> TRD + TRD2D
+    uNbDigis = (0 < event.GetNofData(ECbmDataType::kTrdDigi) ? event.GetNofData(ECbmDataType::kTrdDigi) : 0);
+    if (uNbDigis) {
+      if (bExclusiveTrdExtract) {
+        for (uint32_t uDigiInEvt = 0; uDigiInEvt < uNbDigis; ++uDigiInEvt) {
+          /// Copy each digi in the event by itself to make sure we skip ones outside their own selection window but
+          /// inside the selection window of the other TRD subsystem, effectively enforcing differetn windows:
+          /// [t, t+dt](TRD) = [t, t+dt](TRD1D) + [t, t+dt](TRD2D)
+          /// => Exclusive but slower
+          selEvent.fData.fTrd.fDigis.push_back(fvDigiTrd[event.GetIndex(ECbmDataType::kTrdDigi, uDigiInEvt)]);
+        }
+      }
+      else {
+        /// Block copy of all TRD digis, has feature that it may include digis which are not matching the selection
+        /// window of a given TRD subsystem, effectively making a larger selection window:
+        /// [t, t+dt](TRD) = [t, t+dt](TRD1D) U [t, t+dt](TRD2D)
+        /// => Faster but inclusive, will lead to more TRD hits and tracks than expected
+        auto startIt = fvDigiTrd.begin() + event.GetIndex(ECbmDataType::kTrdDigi, 0);
+        auto stopIt  = fvDigiTrd.begin() + event.GetIndex(ECbmDataType::kTrdDigi, uNbDigis - 1);
+        ++stopIt;
+        selEvent.fData.fTrd.fDigis.assign(startIt, stopIt);
+      }
+    }
+
+    /// ==> TOF
+    uNbDigis = (0 < event.GetNofData(ECbmDataType::kTofDigi) ? event.GetNofData(ECbmDataType::kTofDigi) : 0);
+    if (uNbDigis) {
+      auto startIt = fvDigiTof.begin() + event.GetIndex(ECbmDataType::kTofDigi, 0);
+      auto stopIt  = fvDigiTof.begin() + event.GetIndex(ECbmDataType::kTofDigi, uNbDigis - 1);
+      ++stopIt;
+      selEvent.fData.fTof.fDigis.assign(startIt, stopIt);
+    }
+
+    /// ==> RICH
+    uNbDigis = (0 < event.GetNofData(ECbmDataType::kRichDigi) ? event.GetNofData(ECbmDataType::kRichDigi) : 0);
+    if (uNbDigis) {
+      auto startIt = fvDigiRich.begin() + event.GetIndex(ECbmDataType::kRichDigi, 0);
+      auto stopIt  = fvDigiRich.begin() + event.GetIndex(ECbmDataType::kRichDigi, uNbDigis - 1);
+      ++stopIt;
+      selEvent.fData.fRich.fDigis.assign(startIt, stopIt);
+    }
+
+    /// ==> PSD
+    uNbDigis = (0 < event.GetNofData(ECbmDataType::kPsdDigi) ? event.GetNofData(ECbmDataType::kPsdDigi) : 0);
+    if (uNbDigis) {
+      auto startIt = fvDigiPsd.begin() + event.GetIndex(ECbmDataType::kPsdDigi, 0);
+      auto stopIt  = fvDigiPsd.begin() + event.GetIndex(ECbmDataType::kPsdDigi, uNbDigis - 1);
+      ++stopIt;
+      selEvent.fData.fPsd.fDigis.assign(startIt, stopIt);
+    }
+
+    fvDigiEvents.push_back(selEvent);
+  }
+}

MQ/mcbm/CbmDeviceDigiEventSink.h

+/* Copyright (C) 2020-2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
+/**
+ * CbmDeviceDigiEventSink.h
+ *
+ * @since 2020-05-04
+ * @author P.-A. Loizeau
+ */
+
+#ifndef CBMDEVICEDIGIEVTSINK_H_
+#define CBMDEVICEDIGIEVTSINK_H_
+
+/// CBM headers
+#include "CbmBmonDigi.h"
+#include "CbmDigiEvent.h"
+#include "CbmEvent.h"
+#include "CbmMqTMessage.h"
+#include "CbmMuchDigi.h"
+#include "CbmPsdDigi.h"
+#include "CbmRichDigi.h"
+#include "CbmStsDigi.h"
+#include "CbmTofDigi.h"
+#include "CbmTrdDigi.h"
+#include "CbmTsEventHeader.h"
+
+#include "TimesliceMetaData.h"
+
+/// FAIRROOT headers
+#include "FairMQDevice.h"
+
+/// FAIRSOFT headers (geant, boost, ...)
+#include "Rtypes.h"
+#include "TClonesArray.h"
+#include "TObjArray.h"
+
+/// C/C++ headers
+#include <chrono>
+#include <map>
+#include <vector>
+
+class TCanvas;
+class TFile;
+class TH1;
+class TProfile;
+class TList;
+class TClonesArray;
+//class TimesliceMetaData;
+class FairRunOnline;
+class FairRootManager;
+
+class CbmEventTimeslice {
+  /// TODO: rename to CbmTsWithEvents
+public:
+  CbmEventTimeslice(FairMQParts& parts, bool bDigiEvtInput = false);
+  ~CbmEventTimeslice();
+
+  void ExtractSelectedData(bool bExclusiveTrdExtract = true);
+  std::vector<CbmDigiEvent>& GetSelectedData(bool bExclusiveTrdExtract = true)
+  {
+    if (!fbDigiEvtInput) ExtractSelectedData(bExclusiveTrdExtract);
+    return fvDigiEvents;
+  }
+
+  /// Input Type
+  bool fbDigiEvtInput = false;
+  /// TS information in header
+  CbmTsEventHeader fCbmTsEventHeader;
+  /// Raw data
+  std::vector<CbmBmonDigi> fvDigiBmon;
+  std::vector<CbmStsDigi> fvDigiSts;
+  std::vector<CbmMuchDigi> fvDigiMuch;
+  std::vector<CbmTrdDigi> fvDigiTrd;
+  std::vector<CbmTofDigi> fvDigiTof;
+  std::vector<CbmRichDigi> fvDigiRich;
+  std::vector<CbmPsdDigi> fvDigiPsd;
+  /// extra Metadata
+  TimesliceMetaData fTsMetaData;
+  /// Raw events
+  std::vector<CbmEvent> fvEvents;
+  /// Digi events
+  std::vector<CbmDigiEvent> fvDigiEvents;
+};
+
+class CbmDeviceDigiEventSink : public FairMQDevice {
+public:
+  CbmDeviceDigiEventSink();
+  virtual ~CbmDeviceDigiEventSink();
+
+protected:
+  virtual void InitTask();
+  bool HandleMissTsData(FairMQMessagePtr&, int);
+  bool HandleData(FairMQParts&, int);
+  bool HandleCommand(FairMQMessagePtr&, int);
+  virtual void PostRun();
+
+private:
+  /// Constants
+
+  /// Control flags
+  bool fbStoreFullTs         = false;  //! If true, store digis vectors with full TS in addition to selected events
+  bool fbBypassConsecutiveTs = false;  //! Switch ON/OFF the bypass of the consecutive TS buffer before writing to file
+  bool fbWriteMissingTs      = false;  //! Switch ON/OFF writing of empty TS to file for the missing ones (if no bypass)
+  bool fbDisableCompression  = false;  //! Switch ON/OFF the ROOT file compression
+  bool fbDigiEventInput      = false;  //! Switch ON/OFF the input of CbmDigiEvents instead of raw data + CbmEvents
+  bool fbExclusiveTrdExtract = true;   //! Switch ON/OFF loop based extraction of TRD digis due to 1D/2D
+  bool fbFillHistos          = false;  //! Switch ON/OFF filling of histograms
+  bool fbInitDone            = false;  //! Keep track of whether the Init was already fully completed
+  bool fbFinishDone          = false;  //! Keep track of whether the Finish was already called
+
+  /// User settings parameters
+  /// Algo enum settings
+  std::string fsOutputFileName = "mcbm_digis_events.root";
+  /// message queues
+  std::string fsChannelNameMissedTs    = "missedts";
+  std::string fsChannelNameDataInput   = "events";
+  std::string fsChannelNameCommands    = "commands";
+  std::string fsChannelNameHistosInput = "histogram-in";
+  /// Output file/tree management
+  int64_t fiTreeFileMaxSize = 10000000000LL;  //! Default value: ~10 GB
+  /// Histograms management
+  uint32_t fuPublishFreqTs   = 100;
+  double_t fdMinPublishTime  = 0.5;
+  double_t fdMaxPublishTime  = 5.0;
+  std::string fsHistosSuffix = "";
+
+  /// List of MQ channels names
+  std::vector<std::string> fsAllowedChannels = {fsChannelNameDataInput};
+
+  /// Parameters management
+  //      TList* fParCList = nullptr;
+  //      Bool_t InitParameters( TList* fParCList );
+
+  /// Statistics & missed TS detection
+  uint64_t fuPrevTsIndex                                 = 0;
+  uint64_t fulNumMessages                                = 0;
+  uint64_t fulTsCounter                                  = 0;
+  uint64_t fulMissedTsCounter                            = 0;
+  uint64_t fulProcessedEvents                            = 0;
+  uint64_t fulLastFullTsCounter                          = 0;
+  uint64_t fulLastMissTsCounter                          = 0;
+  uint64_t fulLastProcessedEvents                        = 0;
+  std::chrono::system_clock::time_point fLastPublishTime = std::chrono::system_clock::now();
+  std::chrono::system_clock::time_point fLastFillTime    = std::chrono::system_clock::now();
+  std::chrono::system_clock::time_point fStartTime       = std::chrono::system_clock::now();
+
+  /// Control Commands reception
+  bool fbReceivedEof      = false;
+  uint64_t fuLastTsIndex  = 0;
+  uint64_t fuTotalTsCount = 0;
+
+  /// Data reception
+  /// Event (TS) header
+  CbmTsEventHeader* fEvtHeader = nullptr;
+  /// TS MetaData storage
+  TClonesArray* fTimeSliceMetaDataArray = nullptr;  //!
+                                                    //  TimesliceMetaData* fTsMetaData        = nullptr;
+  /// CbmEvents
+  std::vector<CbmDigiEvent>* fEventsSel = nullptr;  //! output container of CbmEvents
+  /// Full TS Digis storage (optional usage, controlled by fbStoreFullTs!)
+  std::vector<CbmBmonDigi>* fvDigiBmon = nullptr;
+  std::vector<CbmStsDigi>* fvDigiSts   = nullptr;
+  std::vector<CbmMuchDigi>* fvDigiMuch = nullptr;
+  std::vector<CbmTrdDigi>* fvDigiTrd   = nullptr;
+  std::vector<CbmTofDigi>* fvDigiTof   = nullptr;
+  std::vector<CbmRichDigi>* fvDigiRich = nullptr;
+  std::vector<CbmPsdDigi>* fvDigiPsd   = nullptr;
+
+  /// Storage for re-ordering
+  /// Missed TS vector
+  std::vector<uint64_t> fvulMissedTsIndices = {};
+  /// Buffered TS
+  std::map<uint64_t, CbmEventTimeslice> fmFullTsStorage = {};
+
+  /// Data storage
+  FairRunOnline* fpRun           = nullptr;
+  FairRootManager* fpFairRootMgr = nullptr;
+
+  /// Array of histograms to send to the histogram server
+  TObjArray fArrayHisto = {};
+  /// Vector of string pairs with ( HistoName, FolderPath ) to send to the histogram server
+  std::vector<std::pair<std::string, std::string>> fvpsHistosFolder = {};
+  /// Vector of string pairs with ( CanvasName, CanvasConfig ) to send to the histogram server
+  /// Format of Can config is "NbPadX(U);NbPadY(U);ConfigPad1(s);....;ConfigPadXY(s)"
+  /// Format of Pad config is "GrixX(b),GridY(b),LogX(b),LogY(b),LogZ(b),HistoName(s),DrawOptions(s)"
+  std::vector<std::pair<std::string, std::string>> fvpsCanvasConfig = {};
+  /// Flag indicating whether the histograms and canvases configurations were already published
+  bool fbConfigSent = false;
+
+  TProfile* fhFullTsBuffSizeEvo;
+  TProfile* fhMissTsBuffSizeEvo;
+  TH1* fhFullTsProcEvo;
+  TH1* fhMissTsProcEvo;
+  TH1* fhTotalTsProcEvo;
+  TH1* fhTotalEventsEvo;
+  TCanvas* fcEventSinkAllHist;
+
+  /// Internal methods
+  bool IsChannelNameAllowed(std::string channelName);
+  bool InitHistograms();
+  bool ResetHistograms(bool bResetStartTime = false);
+  void CheckTsQueues();
+  void PrepareTreeEntry(CbmEventTimeslice unpTs);
+  void DumpTreeEntry();
+  bool SendHistoConfAndData();
+  bool SendHistograms();
+  void Finish();
+};
+
+#endif /* CBMDEVICEDIGIEVTSINK_H_ */

MQ/mcbm/CbmDeviceMcbmEventBuilderWin.cxx

+/* Copyright (C) 2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
 /**
  * CbmDeviceMcbmEventBuilderWin.cxx
  *
@@ -9,20 +13,22 @@
 
 
 /// CBM headers
-#include "CbmMQDefs.h"
-
 #include "CbmEvent.h"
 #include "CbmFlesCanvasTools.h"
+#include "CbmMQDefs.h"
 #include "CbmMatch.h"
 #include "CbmMvdDigi.h"
+
 #include "TimesliceMetaData.h"
 
 /// FAIRROOT headers
-#include "BoostSerializer.h"
 #include "FairMQLogger.h"
 #include "FairMQProgOptions.h"  // device->fConfig
 #include "FairParGenericSet.h"
 #include "FairRunOnline.h"
+
+#include "BoostSerializer.h"
+
 #include "RootSerializer.h"
 
 /// FAIRSOFT headers (geant, boost, ...)
@@ -31,28 +37,27 @@
 #include "TH1.h"
 #include "TList.h"
 #include "TNamed.h"
+
 #include <boost/archive/binary_iarchive.hpp>
 #include <boost/serialization/utility.hpp>
 
 /// C/C++ headers
 #include <array>
 #include <iomanip>
-#include <string>
-
 #include <stdexcept>
+#include <string>
 struct InitTaskError : std::runtime_error {
   using std::runtime_error::runtime_error;
 };
 
 using namespace std;
 
-//Bool_t bMcbm2018MonitorTaskT0ResetHistos = kFALSE;
+//Bool_t bMcbm2018MonitorTaskBmonResetHistos = kFALSE;
 
-CbmDeviceMcbmEventBuilderWin::CbmDeviceMcbmEventBuilderWin() {
-  fpAlgo = new CbmMcbm2019TimeWinEventBuilderAlgo();
-}
+CbmDeviceMcbmEventBuilderWin::CbmDeviceMcbmEventBuilderWin() { fpAlgo = new CbmMcbm2019TimeWinEventBuilderAlgo(); }
 
-void CbmDeviceMcbmEventBuilderWin::InitTask() try {
+void CbmDeviceMcbmEventBuilderWin::InitTask()
+try {
   /// Read options from executable
   LOG(info) << "Init options for CbmDeviceMcbmEventBuilderWin.";
   fbFillHistos      = fConfig->GetValue<bool>("FillHistos");
@@ -90,104 +95,88 @@ void CbmDeviceMcbmEventBuilderWin::InitTask() try {
   for (auto const& entry : fChannels) {
     LOG(info) << "Channel name: " << entry.first;
     if (std::string::npos != entry.first.find(fsChannelNameDataInput)) {
-      if (!IsChannelNameAllowed(entry.first))
-        throw InitTaskError("Channel name does not match.");
+      if (!IsChannelNameAllowed(entry.first)) throw InitTaskError("Channel name does not match.");
       OnData(entry.first, &CbmDeviceMcbmEventBuilderWin::HandleData);
     }  // if( entry.first.find( "ts" )
   }    // for( auto const &entry : fChannels )
 
   //   InitContainers();
 
+  /// FIXME: Disable clang formatting for now as it corrupts all alignment
+  /* clang-format off */
+
   /// Initialize the Algorithm parameters
   fpAlgo->SetFillHistos(fbFillHistos);
   fpAlgo->SetIgnoreTsOverlap(fbIgnoreTsOverlap);
   /// Extract Event Overlap Mode
   EOverlapMode mode =
-    ("NoOverlap" == fsEvtOverMode
-       ? EOverlapMode::NoOverlap
-       : ("MergeOverlap" == fsEvtOverMode
-            ? EOverlapMode::MergeOverlap
-            : ("AllowOverlap" == fsEvtOverMode ? EOverlapMode::AllowOverlap
-                                               : EOverlapMode::NoOverlap)));
+     ("NoOverlap"    == fsEvtOverMode ? EOverlapMode::NoOverlap
+   : ("MergeOverlap" == fsEvtOverMode ? EOverlapMode::MergeOverlap
+   : ("AllowOverlap" == fsEvtOverMode ? EOverlapMode::AllowOverlap
+                                      : EOverlapMode::NoOverlap)));
   fpAlgo->SetEventOverlapMode(mode);
   /// Extract refdet
-  ECbmModuleId refDet =
-    ("kT0" == fsRefDet
-       ? ECbmModuleId::kT0
-       : ("kSts" == fsRefDet
-            ? ECbmModuleId::kSts
-            : ("kMuch" == fsRefDet
-                 ? ECbmModuleId::kMuch
-                 : ("kTrd" == fsRefDet
-                      ? ECbmModuleId::kTrd
-                      : ("kTof" == fsRefDet
-                           ? ECbmModuleId::kTof
-                           : ("kRich" == fsRefDet
-                                ? ECbmModuleId::kRich
-                                : ("kPsd" == fsRefDet
-                                     ? ECbmModuleId::kPsd
-                                     : ECbmModuleId::kNotExist)))))));
-
-  fpAlgo->SetReferenceDetector(refDet);
+  EventBuilderDetector refDet = ("kBmon"   == fsRefDet ? kEventBuilderDetBmon
+                              : ("kSts"  == fsRefDet ? kEventBuilderDetSts
+                              : ("kMuch" == fsRefDet ? kEventBuilderDetMuch
+                              : ("kTrd"  == fsRefDet ? kEventBuilderDetTrd
+                              : ("kTof"  == fsRefDet ? kEventBuilderDetTof
+                              : ("kRich" == fsRefDet ? kEventBuilderDetRich
+                              : ("kPsd"  == fsRefDet ? kEventBuilderDetPsd
+                                                     : kEventBuilderDetUndef)))))));
+  if (kEventBuilderDetUndef != refDet) {
+    fpAlgo->SetReferenceDetector(refDet);
+  }  // if( kEventBuilderDetUndef != refDet )
+  else {
+    LOG(info) << "CbmDeviceMcbmEventBuilderWin::InitTask => Trying to change "
+                 "reference to unsupported detector, ignored! "
+              << fsRefDet;
+  }  // else of if( kEventBuilderDetUndef != refDet
+
   /// Extract detector to add if any
   for (std::vector<std::string>::iterator itStrAdd = fvsAddDet.begin();
        itStrAdd != fvsAddDet.end();
        ++itStrAdd) {
-    ECbmModuleId addDet =
-      ("kT0" == *itStrAdd
-         ? ECbmModuleId::kT0
-         : ("kSts" == *itStrAdd
-              ? ECbmModuleId::kSts
-              : ("kMuch" == *itStrAdd
-                   ? ECbmModuleId::kMuch
-                   : ("kTrd" == *itStrAdd
-                        ? ECbmModuleId::kTrd
-                        : ("kTof" == *itStrAdd
-                             ? ECbmModuleId::kTof
-                             : ("kRich" == *itStrAdd
-                                  ? ECbmModuleId::kRich
-                                  : ("kPsd" == *itStrAdd
-                                       ? ECbmModuleId::kPsd
-                                       : ECbmModuleId::kNotExist)))))));
-    if (ECbmModuleId::kNotExist != addDet) {
+    EventBuilderDetector addDet = ("kBmon"   == *itStrAdd ? kEventBuilderDetBmon
+                                : ("kSts"  == *itStrAdd ? kEventBuilderDetSts
+                                : ("kMuch" == *itStrAdd ? kEventBuilderDetMuch
+                                : ("kTrd"  == *itStrAdd ? kEventBuilderDetTrd
+                                : ("kTof"  == *itStrAdd ? kEventBuilderDetTof
+                                : ("kRich" == *itStrAdd ? kEventBuilderDetRich
+                                : ("kPsd"  == *itStrAdd ? kEventBuilderDetPsd
+                                                        : kEventBuilderDetUndef)))))));
+    if (kEventBuilderDetUndef != addDet) {
       fpAlgo->AddDetector(addDet);
-    }  // if(  ECbmModuleId::kNotExist != addDet )
+    }  // if( kEventBuilderDetUndef != addDet )
     else {
       LOG(info) << "CbmDeviceMcbmEventBuilderWin::InitTask => Trying to add "
                    "unsupported detector, ignored! "
                 << (*itStrAdd);
       continue;
-    }  // else of if(  ECbmModuleId::kNotExist != addDet
+    }  // else of if( kEventBuilderDetUndef != addDet )
   }  // for( std::vector< std::string >::iterator itStrAdd = fvsAddDet.begin(); itStrAdd != fvsAddDet.end(); ++itStrAdd )
-     /// Extract detector to add if any
+
+     /// Extract detector to remove if any
   for (std::vector<std::string>::iterator itStrRem = fvsDelDet.begin();
        itStrRem != fvsDelDet.end();
        ++itStrRem) {
-    ECbmModuleId remDet =
-      ("kT0" == *itStrRem
-         ? ECbmModuleId::kT0
-         : ("kSts" == *itStrRem
-              ? ECbmModuleId::kSts
-              : ("kMuch" == *itStrRem
-                   ? ECbmModuleId::kMuch
-                   : ("kTrd" == *itStrRem
-                        ? ECbmModuleId::kTrd
-                        : ("kTof" == *itStrRem
-                             ? ECbmModuleId::kTof
-                             : ("kRich" == *itStrRem
-                                  ? ECbmModuleId::kRich
-                                  : ("kPsd" == *itStrRem
-                                       ? ECbmModuleId::kPsd
-                                       : ECbmModuleId::kNotExist)))))));
-    if (ECbmModuleId::kNotExist != remDet) {
+    EventBuilderDetector remDet = ("kBmon"   == *itStrRem ? kEventBuilderDetBmon
+                                : ("kSts"  == *itStrRem ? kEventBuilderDetSts
+                                : ("kMuch" == *itStrRem ? kEventBuilderDetMuch
+                                : ("kTrd"  == *itStrRem ? kEventBuilderDetTrd
+                                : ("kTof"  == *itStrRem ? kEventBuilderDetTof
+                                : ("kRich" == *itStrRem ? kEventBuilderDetRich
+                                : ("kPsd"  == *itStrRem ? kEventBuilderDetPsd
+                                                        : kEventBuilderDetUndef)))))));
+    if (kEventBuilderDetUndef != remDet) {
       fpAlgo->RemoveDetector(remDet);
-    }  // if(  ECbmModuleId::kNotExist != remDet )
+    }  // if( kEventBuilderDetUndef != remDet )
     else {
       LOG(info) << "CbmDeviceMcbmEventBuilderWin::InitTask => Trying to remove "
                    "unsupported detector, ignored! "
                 << (*itStrRem);
       continue;
-    }  // else of if(  ECbmModuleId::kNotExist != remDet )
+    }  // else of if( kEventBuilderDetUndef != remDet )
   }  // for( std::vector< std::string >::iterator itStrAdd = fvsAddDet.begin(); itStrAdd != fvsAddDet.end(); ++itStrAdd )
      /// Extract Trigger window to add if any
   for (std::vector<std::string>::iterator itStrTrigWin = fvsSetTrigWin.begin();
@@ -205,22 +194,14 @@ void CbmDeviceMcbmEventBuilderWin::InitTask() try {
 
     /// Detector Enum Tag
     std::string sSelDet = (*itStrTrigWin).substr(0, charPosDel);
-    ECbmModuleId selDet =
-      ("kT0" == sSelDet
-         ? ECbmModuleId::kT0
-         : ("kSts" == sSelDet
-              ? ECbmModuleId::kSts
-              : ("kMuch" == sSelDet
-                   ? ECbmModuleId::kMuch
-                   : ("kTrd" == sSelDet
-                        ? ECbmModuleId::kTrd
-                        : ("kTof" == sSelDet
-                             ? ECbmModuleId::kTof
-                             : ("kRich" == sSelDet
-                                  ? ECbmModuleId::kRich
-                                  : ("kPsd" == sSelDet
-                                       ? ECbmModuleId::kPsd
-                                       : ECbmModuleId::kNotExist)))))));
+    ECbmModuleId selDet = ("kBmon"   == sSelDet ? ECbmModuleId::kBmon
+                        : ("kSts"  == sSelDet ? ECbmModuleId::kSts
+                        : ("kMuch" == sSelDet ? ECbmModuleId::kMuch
+                        : ("kTrd"  == sSelDet ? ECbmModuleId::kTrd
+                        : ("kTof"  == sSelDet ? ECbmModuleId::kTof
+                        : ("kRich" == sSelDet ? ECbmModuleId::kRich
+                        : ("kPsd"  == sSelDet ? ECbmModuleId::kPsd
+                                              : ECbmModuleId::kNotExist)))))));
     if (ECbmModuleId::kNotExist == selDet) {
       LOG(info)
         << "CbmDeviceMcbmEventBuilderWin::InitTask => "
@@ -265,22 +246,14 @@ void CbmDeviceMcbmEventBuilderWin::InitTask() try {
 
     /// Detector Enum Tag
     std::string sSelDet = (*itStrMinNb).substr(0, charPosDel);
-    ECbmModuleId selDet =
-      ("kT0" == sSelDet
-         ? ECbmModuleId::kT0
-         : ("kSts" == sSelDet
-              ? ECbmModuleId::kSts
-              : ("kMuch" == sSelDet
-                   ? ECbmModuleId::kMuch
-                   : ("kTrd" == sSelDet
-                        ? ECbmModuleId::kTrd
-                        : ("kTof" == sSelDet
-                             ? ECbmModuleId::kTof
-                             : ("kRich" == sSelDet
-                                  ? ECbmModuleId::kRich
-                                  : ("kPsd" == sSelDet
-                                       ? ECbmModuleId::kPsd
-                                       : ECbmModuleId::kNotExist)))))));
+    ECbmModuleId selDet = ("kBmon"   == sSelDet ? ECbmModuleId::kBmon
+                        : ("kSts"  == sSelDet ? ECbmModuleId::kSts
+                        : ("kMuch" == sSelDet ? ECbmModuleId::kMuch
+                        : ("kTrd"  == sSelDet ? ECbmModuleId::kTrd
+                        : ("kTof"  == sSelDet ? ECbmModuleId::kTof
+                        : ("kRich" == sSelDet ? ECbmModuleId::kRich
+                        : ("kPsd"  == sSelDet ? ECbmModuleId::kPsd
+                                              : ECbmModuleId::kNotExist)))))));
     if (ECbmModuleId::kNotExist == selDet) {
       LOG(info)
         << "CbmDeviceMcbmEventBuilderWin::InitTask => "
@@ -296,8 +269,11 @@ void CbmDeviceMcbmEventBuilderWin::InitTask() try {
     fpAlgo->SetTriggerMinNumber(selDet, uMinNb);
   }  //    for( std::vector< std::string >::iterator itStrMinNb = fvsSetTrigMinNb.begin(); itStrMinNb != fvsSetTrigMinNb.end(); ++itStrMinNb )
 
+  /// FIXME: Re-enable clang formatting after formatted lines
+  /* clang-format on */
+
   /// Create input vectors
-  fvDigiT0   = new std::vector<CbmTofDigi>();
+  fvDigiBmon = new std::vector<CbmTofDigi>();
   fvDigiSts  = new std::vector<CbmStsDigi>();
   fvDigiMuch = new std::vector<CbmMuchBeamTimeDigi>();
   fvDigiTrd  = new std::vector<CbmTrdDigi>();
@@ -311,13 +287,10 @@ void CbmDeviceMcbmEventBuilderWin::InitTask() try {
   ioman                  = FairRootManager::Instance();
   if (NULL == ioman) { throw InitTaskError("No FairRootManager instance"); }
   fTimeSliceMetaDataArray = new TClonesArray("TimesliceMetaData", 1);
-  if (NULL == fTimeSliceMetaDataArray) {
-    throw InitTaskError("Failed creating the TS meta data TClonesarray ");
-  }
-  ioman->Register(
-    "TimesliceMetaData", "TS Meta Data", fTimeSliceMetaDataArray, kFALSE);
+  if (NULL == fTimeSliceMetaDataArray) { throw InitTaskError("Failed creating the TS meta data TClonesarray "); }
+  ioman->Register("TimesliceMetaData", "TS Meta Data", fTimeSliceMetaDataArray, kFALSE);
   /// Digis storage
-  ioman->RegisterAny("T0Digi", fvDigiT0, kFALSE);
+  ioman->RegisterAny("BmonDigi", fvDigiBmon, kFALSE);
   ioman->RegisterAny("StsDigi", fvDigiSts, kFALSE);
   ioman->RegisterAny("MuchBeamTimeDigi", fvDigiMuch, kFALSE);
   ioman->RegisterAny("TrdDigi", fvDigiTrd, kFALSE);
@@ -349,11 +322,9 @@ void CbmDeviceMcbmEventBuilderWin::InitTask() try {
   /// Histograms management
   if (kTRUE == fbFillHistos) {
     /// Obtain vector of pointers on each histo from the algo (+ optionally desired folder)
-    std::vector<std::pair<TNamed*, std::string>> vHistos =
-      fpAlgo->GetHistoVector();
+    std::vector<std::pair<TNamed*, std::string>> vHistos = fpAlgo->GetHistoVector();
     /// Obtain vector of pointers on each canvas from the algo (+ optionally desired folder)
-    std::vector<std::pair<TCanvas*, std::string>> vCanvases =
-      fpAlgo->GetCanvasVector();
+    std::vector<std::pair<TCanvas*, std::string>> vCanvases = fpAlgo->GetCanvasVector();
 
     /// Add pointers to each histo in the histo array
     /// Create histo config vector
@@ -364,22 +335,20 @@ void CbmDeviceMcbmEventBuilderWin::InitTask() try {
       //                   << " in " << vHistos[ uHisto ].second.data()
       //                   ;
       fArrayHisto.Add(vHistos[uHisto].first);
-      std::pair<std::string, std::string> psHistoConfig(
-        vHistos[uHisto].first->GetName(), vHistos[uHisto].second);
+      std::pair<std::string, std::string> psHistoConfig(vHistos[uHisto].first->GetName(), vHistos[uHisto].second);
       fvpsHistosFolder.push_back(psHistoConfig);
 
       /// Serialize the vector of histo config into a single MQ message
       FairMQMessagePtr messageHist(NewMessage());
-      Serialize<BoostSerializer<std::pair<std::string, std::string>>>(
-        *messageHist, psHistoConfig);
+      //      Serialize<BoostSerializer<std::pair<std::string, std::string>>>(*messageHist, psHistoConfig);
+      BoostSerializer<std::pair<std::string, std::string>>().Serialize(*messageHist, psHistoConfig);
 
       /// Send message to the common histogram config messages queue
       if (Send(messageHist, fsChannelNameHistosConfig) < 0) {
         throw InitTaskError("Problem sending histo config");
       }  // if( Send( messageHist, fsChannelNameHistosConfig ) < 0 )
 
-      LOG(info) << "Config of hist  " << psHistoConfig.first.data()
-                << " in folder " << psHistoConfig.second.data();
+      LOG(info) << "Config of hist  " << psHistoConfig.first.data() << " in folder " << psHistoConfig.second.data();
     }  // for( UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto )
 
     /// Create canvas config vector
@@ -389,8 +358,7 @@ void CbmDeviceMcbmEventBuilderWin::InitTask() try {
       //         LOG(info) << "Registering  " << vCanvases[ uCanv ].first->GetName()
       //                   << " in " << vCanvases[ uCanv ].second.data();
       std::string sCanvName = (vCanvases[uCanv].first)->GetName();
-      std::string sCanvConf =
-        GenerateCanvasConfigString(vCanvases[uCanv].first);
+      std::string sCanvConf = GenerateCanvasConfigString(vCanvases[uCanv].first);
 
       std::pair<std::string, std::string> psCanvConfig(sCanvName, sCanvConf);
 
@@ -398,43 +366,38 @@ void CbmDeviceMcbmEventBuilderWin::InitTask() try {
 
       /// Serialize the vector of canvas config into a single MQ message
       FairMQMessagePtr messageCan(NewMessage());
-      Serialize<BoostSerializer<std::pair<std::string, std::string>>>(
-        *messageCan, psCanvConfig);
+      //      Serialize<BoostSerializer<std::pair<std::string, std::string>>>(*messageCan, psCanvConfig);
+      BoostSerializer<std::pair<std::string, std::string>>().Serialize(*messageCan, psCanvConfig);
 
       /// Send message to the common canvas config messages queue
       if (Send(messageCan, fsChannelNameCanvasConfig) < 0) {
         throw InitTaskError("Problem sending canvas config");
       }  // if( Send( messageCan, fsChannelNameCanvasConfig ) < 0 )
 
-      LOG(info) << "Config string of Canvas  " << psCanvConfig.first.data()
-                << " is " << psCanvConfig.second.data();
+      LOG(info) << "Config string of Canvas  " << psCanvConfig.first.data() << " is " << psCanvConfig.second.data();
     }  //  for( UInt_t uCanv = 0; uCanv < vCanvases.size(); ++uCanv )
   }    // if( kTRUE == fbFillHistos )
-
-} catch (InitTaskError& e) {
+}
+catch (InitTaskError& e) {
   LOG(error) << e.what();
   // Wrapper defined in CbmMQDefs.h to support different FairMQ versions
   cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
 }
 
-bool CbmDeviceMcbmEventBuilderWin::IsChannelNameAllowed(
-  std::string channelName) {
+bool CbmDeviceMcbmEventBuilderWin::IsChannelNameAllowed(std::string channelName)
+{
   for (auto const& entry : fsAllowedChannels) {
     std::size_t pos1 = channelName.find(entry);
     if (pos1 != std::string::npos) {
       const vector<std::string>::const_iterator pos =
         std::find(fsAllowedChannels.begin(), fsAllowedChannels.end(), entry);
-      const vector<std::string>::size_type idx =
-        pos - fsAllowedChannels.begin();
+      const vector<std::string>::size_type idx = pos - fsAllowedChannels.begin();
       LOG(info) << "Found " << entry << " in " << channelName;
-      LOG(info) << "Channel name " << channelName
-                << " found in list of allowed channel names at position "
-                << idx;
+      LOG(info) << "Channel name " << channelName << " found in list of allowed channel names at position " << idx;
       return true;
     }  // if (pos1!=std::string::npos)
   }    // for(auto const &entry : fsAllowedChannels)
-  LOG(info) << "Channel name " << channelName
-            << " not found in list of allowed channel names.";
+  LOG(info) << "Channel name " << channelName << " not found in list of allowed channel names.";
   LOG(error) << "Stop device.";
   return false;
 }
@@ -481,7 +444,7 @@ Bool_t CbmDeviceMcbmEventBuilderWin::InitParameters( TList* fParCList )
          {
             if( 0 !=  rep->GetSize() )
             {
-               CbmMQTMessage tmsg( rep->GetData(), rep->GetSize() );
+               CbmMqTMessage tmsg( rep->GetData(), rep->GetSize() );
                newObj = static_cast< FairParGenericSet* >( tmsg.ReadObject( tmsg.GetClass() ) );
                LOG( info ) << "Received unpack parameter from the server:";
                newObj->print();
@@ -501,15 +464,13 @@ Bool_t CbmDeviceMcbmEventBuilderWin::InitParameters( TList* fParCList )
 }
 */
 // handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)
-bool CbmDeviceMcbmEventBuilderWin::HandleData(FairMQParts& parts,
-                                              int /*index*/) {
+bool CbmDeviceMcbmEventBuilderWin::HandleData(FairMQParts& parts, int /*index*/)
+{
   fulNumMessages++;
-  LOG(debug) << "Received message number " << fulNumMessages << " with "
-             << parts.Size() << " parts"
+  LOG(debug) << "Received message number " << fulNumMessages << " with " << parts.Size() << " parts"
              << ", size0: " << parts.At(0)->GetSize();
 
-  if (0 == fulNumMessages % 10000)
-    LOG(info) << "Received " << fulNumMessages << " messages";
+  if (0 == fulNumMessages % 10000) LOG(info) << "Received " << fulNumMessages << " messages";
 
   /// Extract unpacked data from input message
   uint32_t uPartIdx = 0;
@@ -523,66 +484,58 @@ bool CbmDeviceMcbmEventBuilderWin::HandleData(FairMQParts& parts,
   inputArchiveTsMeta >> (*fTsMetaData);
   ++uPartIdx;
 */
-  Deserialize<RootSerializer>(*parts.At(uPartIdx), fTsMetaData);
+  //  Deserialize<RootSerializer>(*parts.At(uPartIdx), fTsMetaData);
+  RootSerializer().Deserialize(*parts.At(uPartIdx), fTsMetaData);
   /// FIXME: Not if this is the proper way to insert the data
-  new (
-    (*fTimeSliceMetaDataArray)
-      [fTimeSliceMetaDataArray->GetEntriesFast()
-       //                                    ] ) TimesliceMetaData( *fTsMetaData ) ;
+  new ((*fTimeSliceMetaDataArray)[fTimeSliceMetaDataArray->GetEntriesFast()
+                                  //                                    ] ) TimesliceMetaData( *fTsMetaData ) ;
   ]) TimesliceMetaData(std::move(*fTsMetaData));
   ++uPartIdx;
 
-  /// T0
-  std::string msgStrT0(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                       (parts.At(uPartIdx))->GetSize());
-  std::istringstream issT0(msgStrT0);
-  boost::archive::binary_iarchive inputArchiveT0(issT0);
-  inputArchiveT0 >> *fvDigiT0;
+  /// BMON
+  std::string msgStrBmon(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issBmon(msgStrBmon);
+  boost::archive::binary_iarchive inputArchiveBmon(issBmon);
+  inputArchiveBmon >> *fvDigiBmon;
   ++uPartIdx;
 
   /// STS
-  std::string msgStrSts(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrSts(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issSts(msgStrSts);
   boost::archive::binary_iarchive inputArchiveSts(issSts);
   inputArchiveSts >> *fvDigiSts;
   ++uPartIdx;
 
   /// MUCH
-  std::string msgStrMuch(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                         (parts.At(uPartIdx))->GetSize());
+  std::string msgStrMuch(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issMuch(msgStrMuch);
   boost::archive::binary_iarchive inputArchiveMuch(issMuch);
   inputArchiveMuch >> *fvDigiMuch;
   ++uPartIdx;
 
   /// TRD
-  std::string msgStrTrd(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrTrd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issTrd(msgStrTrd);
   boost::archive::binary_iarchive inputArchiveTrd(issTrd);
   inputArchiveTrd >> *fvDigiTrd;
   ++uPartIdx;
 
-  /// T0F
-  std::string msgStrTof(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  /// TOF
+  std::string msgStrTof(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issTof(msgStrTof);
   boost::archive::binary_iarchive inputArchiveTof(issTof);
   inputArchiveTof >> *fvDigiTof;
   ++uPartIdx;
 
   /// RICH
-  std::string msgStrRich(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                         (parts.At(uPartIdx))->GetSize());
+  std::string msgStrRich(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issRich(msgStrRich);
   boost::archive::binary_iarchive inputArchiveRich(issRich);
   inputArchiveRich >> *fvDigiRich;
   ++uPartIdx;
 
   /// PSD
-  std::string msgStrPsd(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrPsd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issPsd(msgStrPsd);
   boost::archive::binary_iarchive inputArchivePsd(issPsd);
   inputArchivePsd >> *fvDigiPsd;
@@ -599,7 +552,7 @@ bool CbmDeviceMcbmEventBuilderWin::HandleData(FairMQParts& parts,
   //   delete fTsMetaData;
 
   /// Clear vectors
-  fvDigiT0->clear();
+  fvDigiBmon->clear();
   fvDigiSts->clear();
   fvDigiMuch->clear();
   fvDigiTrd->clear();
@@ -617,13 +570,10 @@ bool CbmDeviceMcbmEventBuilderWin::HandleData(FairMQParts& parts,
     /// Send histograms each 100 time slices. Should be each ~1s
     /// Use also runtime checker to trigger sending after M s if
     /// processing too slow or delay sending if processing too fast
-    std::chrono::system_clock::time_point currentTime =
-      std::chrono::system_clock::now();
-    std::chrono::duration<double_t> elapsedSeconds =
-      currentTime - fLastPublishTime;
+    std::chrono::system_clock::time_point currentTime = std::chrono::system_clock::now();
+    std::chrono::duration<double_t> elapsedSeconds    = currentTime - fLastPublishTime;
     if ((fdMaxPublishTime < elapsedSeconds.count())
-        || (0 == fulNumMessages % fuPublishFreqTs
-            && fdMinPublishTime < elapsedSeconds.count())) {
+        || (0 == fulNumMessages % fuPublishFreqTs && fdMinPublishTime < elapsedSeconds.count())) {
       SendHistograms();
       fLastPublishTime = std::chrono::system_clock::now();
     }  // if( ( fdMaxPublishTime < elapsedSeconds.count() ) || ( 0 == fulNumMessages % fuPublishFreqTs && fdMinPublishTime < elapsedSeconds.count() ) )
@@ -632,7 +582,8 @@ bool CbmDeviceMcbmEventBuilderWin::HandleData(FairMQParts& parts,
   return true;
 }
 
-bool CbmDeviceMcbmEventBuilderWin::SendEvents(FairMQParts& partsIn) {
+bool CbmDeviceMcbmEventBuilderWin::SendEvents(FairMQParts& partsIn)
+{
   /// Clear events TClonesArray before usage.
   fEvents->Delete();
   //   fEvents->Clear();
@@ -645,15 +596,13 @@ bool CbmDeviceMcbmEventBuilderWin::SendEvents(FairMQParts& partsIn) {
     LOG(debug) << "Vector: " << event->ToString();
     new ((*fEvents)[fEvents->GetEntriesFast()]) CbmEvent(std::move(*event));
     //      new ( (*fEvents)[fEvents->GetEntriesFast()] ) CbmEvent( *event );
-    LOG(debug) << "TClonesArray: "
-               << static_cast<CbmEvent*>(
-                    fEvents->At(fEvents->GetEntriesFast() - 1))
-                    ->ToString();
+    LOG(debug) << "TClonesArray: " << static_cast<CbmEvent*>(fEvents->At(fEvents->GetEntriesFast() - 1))->ToString();
   }  // for( CbmEvent* event: vEvents )
 
   /// Serialize the array of events into a single MQ message
   FairMQMessagePtr message(NewMessage());
-  Serialize<RootSerializer>(*message, fEvents);
+  //  Serialize<RootSerializer>(*message, fEvents);
+  RootSerializer().Serialize(*message, fEvents);
 
   /// Add it at the end of the input composed message
   /// FIXME: use move or fix addition of new part to avoid full message copy
@@ -685,10 +634,12 @@ bool CbmDeviceMcbmEventBuilderWin::SendEvents(FairMQParts& partsIn) {
   return true;
 }
 
-bool CbmDeviceMcbmEventBuilderWin::SendHistograms() {
+bool CbmDeviceMcbmEventBuilderWin::SendHistograms()
+{
   /// Serialize the array of histos into a single MQ message
   FairMQMessagePtr message(NewMessage());
-  Serialize<RootSerializer>(*message, &fArrayHisto);
+  //  Serialize<RootSerializer>(*message, &fArrayHisto);
+  RootSerializer().Serialize(*message, &fArrayHisto);
 
   /// Send message to the common histogram messages queue
   if (Send(message, fsChannelNameHistosInput) < 0) {
@@ -702,13 +653,14 @@ bool CbmDeviceMcbmEventBuilderWin::SendHistograms() {
   return true;
 }
 
-CbmDeviceMcbmEventBuilderWin::~CbmDeviceMcbmEventBuilderWin() {
+CbmDeviceMcbmEventBuilderWin::~CbmDeviceMcbmEventBuilderWin()
+{
   /// Clear metadata
   fTimeSliceMetaDataArray->Clear();
   delete fTsMetaData;
 
   /// Clear vectors
-  fvDigiT0->clear();
+  fvDigiBmon->clear();
   fvDigiSts->clear();
   fvDigiMuch->clear();
   fvDigiTrd->clear();

MQ/mcbm/CbmDeviceMcbmEventBuilderWin.h

+/* Copyright (C) 2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
 /**
  * CbmDeviceMcbmEventBuilderWin.h
  *
@@ -10,6 +14,7 @@
 
 /// CBM headers
 #include "CbmMcbm2019TimeWinEventBuilderAlgo.h"
+#include "CbmMqTMessage.h"
 #include "CbmMuchBeamTimeDigi.h"
 #include "CbmPsdDigi.h"
 #include "CbmRichDigi.h"
@@ -22,7 +27,6 @@
 
 /// FAIRSOFT headers (geant, boost, ...)
 #include "Rtypes.h"
-#include "TMessage.h"
 #include "TObjArray.h"
 
 /// C/C++ headers
@@ -55,7 +59,7 @@ private:
   /// User settings parameters
   /// Algo enum settings
   std::string fsEvtOverMode                = "NoOverlap";
-  std::string fsRefDet                     = "kT0";
+  std::string fsRefDet                     = "kBmon";
   std::vector<std::string> fvsAddDet       = {};
   std::vector<std::string> fvsDelDet       = {};
   std::vector<std::string> fvsSetTrigWin   = {};
@@ -80,31 +84,27 @@ private:
   //      Bool_t InitParameters( TList* fParCList );
 
   /// Statistics & first TS rejection
-  uint64_t fulNumMessages = 0;
-  uint64_t fulTsCounter   = 0;
-  std::chrono::system_clock::time_point fLastPublishTime =
-    std::chrono::system_clock::now();
+  uint64_t fulNumMessages                                = 0;
+  uint64_t fulTsCounter                                  = 0;
+  std::chrono::system_clock::time_point fLastPublishTime = std::chrono::system_clock::now();
 
   /// Processing algos
   CbmMcbm2019TimeWinEventBuilderAlgo* fpAlgo = nullptr;
 
   /// TS MetaData stable values storage
-  size_t fuNbCoreMsPerTs = 0;        //!
-  size_t fuNbOverMsPerTs = 0;        //!
-  Double_t fdMsSizeInNs  = 1280000;  //! Size of a single MS, [nanoseconds]
-  Double_t fdTsCoreSizeInNs =
-    -1.0;  //! Total size of the core MS in a TS, [nanoseconds]
-  Double_t fdTsOverSizeInNs =
-    -1.0;  //! Total size of the overlap MS in a TS, [nanoseconds]
-  Double_t fdTsFullSizeInNs =
-    -1.0;  //! Total size of all MS in a TS, [nanoseconds]
+  size_t fuNbCoreMsPerTs    = 0;        //!
+  size_t fuNbOverMsPerTs    = 0;        //!
+  Double_t fdMsSizeInNs     = 1280000;  //! Size of a single MS, [nanoseconds]
+  Double_t fdTsCoreSizeInNs = -1.0;     //! Total size of the core MS in a TS, [nanoseconds]
+  Double_t fdTsOverSizeInNs = -1.0;     //! Total size of the overlap MS in a TS, [nanoseconds]
+  Double_t fdTsFullSizeInNs = -1.0;     //! Total size of all MS in a TS, [nanoseconds]
 
   /// Data reception
   /// TS MetaData storage
   TClonesArray* fTimeSliceMetaDataArray = nullptr;  //!
   TimesliceMetaData* fTsMetaData        = nullptr;
   /// Digis storage
-  std::vector<CbmTofDigi>* fvDigiT0            = nullptr;
+  std::vector<CbmTofDigi>* fvDigiBmon          = nullptr;
   std::vector<CbmStsDigi>* fvDigiSts           = nullptr;
   std::vector<CbmMuchBeamTimeDigi>* fvDigiMuch = nullptr;
   std::vector<CbmTrdDigi>* fvDigiTrd           = nullptr;
@@ -134,13 +134,4 @@ private:
   bool SendHistograms();
 };
 
-// special class to expose protected TMessage constructor
-class CbmMQTMessage : public TMessage {
-public:
-  CbmMQTMessage(void* buf, Int_t len) : TMessage(buf, len) {
-    ResetBit(kIsOwner);
-  }
-};
-
-
 #endif /* CBMDEVICEMCBMEVTBUILDERWIN_H_ */

MQ/mcbm/CbmDeviceMcbmEventSink.cxx

+/* Copyright (C) 2020-2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
 /**
  * CbmDeviceMcbmEventSink.cxx
  *
@@ -9,20 +13,22 @@
 
 
 /// CBM headers
-#include "CbmMQDefs.h"
-
 #include "CbmEvent.h"
 #include "CbmFlesCanvasTools.h"
+#include "CbmMQDefs.h"
+
 #include "TimesliceMetaData.h"
 
 /// FAIRROOT headers
-#include "BoostSerializer.h"
 #include "FairMQLogger.h"
 #include "FairMQProgOptions.h"  // device->fConfig
 #include "FairParGenericSet.h"
 #include "FairRootFileSink.h"
 #include "FairRootManager.h"
 #include "FairRunOnline.h"
+
+#include "BoostSerializer.h"
+
 #include "RootSerializer.h"
 
 /// FAIRSOFT headers (geant, boost, ...)
@@ -31,27 +37,29 @@
 #include "TH1.h"
 #include "TList.h"
 #include "TNamed.h"
+
 #include <boost/archive/binary_iarchive.hpp>
 #include <boost/serialization/utility.hpp>
 
 /// C/C++ headers
-#include <array>
-#include <iomanip>
-#include <string>
 #include <thread>  // this_thread::sleep_for
 
+#include <array>
+#include <iomanip>
 #include <stdexcept>
+#include <string>
 struct InitTaskError : std::runtime_error {
   using std::runtime_error::runtime_error;
 };
 
 using namespace std;
 
-//Bool_t bMcbm2018MonitorTaskT0ResetHistos = kFALSE;
+//Bool_t bMcbm2018MonitorTaskBmonResetHistos = kFALSE;
 
 CbmDeviceMcbmEventSink::CbmDeviceMcbmEventSink() {}
 
-void CbmDeviceMcbmEventSink::InitTask() try {
+void CbmDeviceMcbmEventSink::InitTask()
+try {
   /// Read options from executable
   LOG(info) << "Init options for CbmDeviceMcbmEventSink.";
 
@@ -89,8 +97,7 @@ void CbmDeviceMcbmEventSink::InitTask() try {
   for (auto const& entry : fChannels) {
     LOG(info) << "Channel name: " << entry.first;
     if (std::string::npos != entry.first.find(fsChannelNameDataInput)) {
-      if (!IsChannelNameAllowed(entry.first))
-        throw InitTaskError("Channel name does not match.");
+      if (!IsChannelNameAllowed(entry.first)) throw InitTaskError("Channel name does not match.");
       OnData(entry.first, &CbmDeviceMcbmEventSink::HandleData);
     }  // if( entry.first.find( "ts" )
   }    // for( auto const &entry : fChannels )
@@ -98,7 +105,7 @@ void CbmDeviceMcbmEventSink::InitTask() try {
   //   InitContainers();
 
   /// Create input vectors
-  fvDigiT0   = new std::vector<CbmTofDigi>();
+  fvDigiBmon = new std::vector<CbmTofDigi>();
   fvDigiSts  = new std::vector<CbmStsDigi>();
   fvDigiMuch = new std::vector<CbmMuchBeamTimeDigi>();
   fvDigiTrd  = new std::vector<CbmTrdDigi>();
@@ -142,10 +149,9 @@ void CbmDeviceMcbmEventSink::InitTask() try {
 
   /// Register all input data members with the FairRoot manager
   /// TS MetaData
-  fpFairRootMgr->Register(
-    "TimesliceMetaData", "TS Meta Data", fTimeSliceMetaDataArray, kTRUE);
+  fpFairRootMgr->Register("TimesliceMetaData", "TS Meta Data", fTimeSliceMetaDataArray, kTRUE);
   /// Digis storage
-  fpFairRootMgr->RegisterAny("T0Digi", fvDigiT0, kTRUE);
+  fpFairRootMgr->RegisterAny("BmonDigi", fvDigiBmon, kTRUE);
   fpFairRootMgr->RegisterAny("StsDigi", fvDigiSts, kTRUE);
   fpFairRootMgr->RegisterAny("MuchBeamTimeDigi", fvDigiMuch, kTRUE);
   fpFairRootMgr->RegisterAny("TrdDigi", fvDigiTrd, kTRUE);
@@ -188,7 +194,8 @@ void CbmDeviceMcbmEventSink::InitTask() try {
 
          /// Serialize the vector of histo config into a single MQ message
          FairMQMessagePtr messageHist( NewMessage() );
-         Serialize< BoostSerializer < std::pair< std::string, std::string > > >( *messageHist, psHistoConfig );
+//         Serialize< BoostSerializer < std::pair< std::string, std::string > > >( *messageHist, psHistoConfig );
+         BoostSerializer < std::pair< std::string, std::string > >.Serialize( *messageHist, psHistoConfig );
 
          /// Send message to the common histogram config messages queue
          if( Send( messageHist, fsChannelNameHistosConfig ) < 0 )
@@ -216,7 +223,8 @@ void CbmDeviceMcbmEventSink::InitTask() try {
 
          /// Serialize the vector of canvas config into a single MQ message
          FairMQMessagePtr messageCan( NewMessage() );
-         Serialize< BoostSerializer < std::pair< std::string, std::string > > >( *messageCan, psCanvConfig );
+//         Serialize< BoostSerializer < std::pair< std::string, std::string > > >( *messageCan, psCanvConfig );
+         BoostSerializer < std::pair< std::string, std::string > >.Serialize( *messageCan, psCanvConfig );
 
          /// Send message to the common canvas config messages queue
          if( Send( messageCan, fsChannelNameCanvasConfig ) < 0 )
@@ -229,30 +237,27 @@ void CbmDeviceMcbmEventSink::InitTask() try {
       } //  for( UInt_t uCanv = 0; uCanv < vCanvases.size(); ++uCanv )
 */
   }  // if( kTRUE == fbFillHistos )
-
-} catch (InitTaskError& e) {
+}
+catch (InitTaskError& e) {
   LOG(error) << e.what();
   // Wrapper defined in CbmMQDefs.h to support different FairMQ versions
   cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
 }
 
-bool CbmDeviceMcbmEventSink::IsChannelNameAllowed(std::string channelName) {
+bool CbmDeviceMcbmEventSink::IsChannelNameAllowed(std::string channelName)
+{
   for (auto const& entry : fsAllowedChannels) {
     std::size_t pos1 = channelName.find(entry);
     if (pos1 != std::string::npos) {
       const vector<std::string>::const_iterator pos =
         std::find(fsAllowedChannels.begin(), fsAllowedChannels.end(), entry);
-      const vector<std::string>::size_type idx =
-        pos - fsAllowedChannels.begin();
+      const vector<std::string>::size_type idx = pos - fsAllowedChannels.begin();
       LOG(info) << "Found " << entry << " in " << channelName;
-      LOG(info) << "Channel name " << channelName
-                << " found in list of allowed channel names at position "
-                << idx;
+      LOG(info) << "Channel name " << channelName << " found in list of allowed channel names at position " << idx;
       return true;
     }  // if (pos1!=std::string::npos)
   }    // for(auto const &entry : fsAllowedChannels)
-  LOG(info) << "Channel name " << channelName
-            << " not found in list of allowed channel names.";
+  LOG(info) << "Channel name " << channelName << " not found in list of allowed channel names.";
   LOG(error) << "Stop device.";
   return false;
 }
@@ -299,7 +304,7 @@ Bool_t CbmDeviceMcbmEventSink::InitParameters( TList* fParCList )
          {
             if( 0 !=  rep->GetSize() )
             {
-               CbmMQTMessage tmsg( rep->GetData(), rep->GetSize() );
+               CbmMqTMessage tmsg( rep->GetData(), rep->GetSize() );
                newObj = static_cast< FairParGenericSet* >( tmsg.ReadObject( tmsg.GetClass() ) );
                LOG( info ) << "Received unpack parameter from the server:";
                newObj->print();
@@ -320,16 +325,15 @@ Bool_t CbmDeviceMcbmEventSink::InitParameters( TList* fParCList )
 */
 //--------------------------------------------------------------------//
 // handler is called whenever a message arrives on fsChannelNameMissedTs, with a reference to the message and a sub-channel index (here 0)
-bool CbmDeviceMcbmEventSink::HandleMissTsData(FairMQMessagePtr& msg,
-                                              int /*index*/) {
+bool CbmDeviceMcbmEventSink::HandleMissTsData(FairMQMessagePtr& msg, int /*index*/)
+{
   std::vector<uint64_t> vIndices;
   std::string msgStrMissTs(static_cast<char*>(msg->GetData()), msg->GetSize());
   std::istringstream issMissTs(msgStrMissTs);
   boost::archive::binary_iarchive inputArchiveMissTs(issMissTs);
   inputArchiveMissTs >> vIndices;
 
-  fvulMissedTsIndices.insert(
-    fvulMissedTsIndices.end(), vIndices.begin(), vIndices.end());
+  fvulMissedTsIndices.insert(fvulMissedTsIndices.end(), vIndices.begin(), vIndices.end());
 
   /// Check TS queue and process it if needed (in case it filled a hole!)
   CheckTsQueues();
@@ -338,14 +342,13 @@ bool CbmDeviceMcbmEventSink::HandleMissTsData(FairMQMessagePtr& msg,
 }
 //--------------------------------------------------------------------//
 // handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)
-bool CbmDeviceMcbmEventSink::HandleData(FairMQParts& parts, int /*index*/) {
+bool CbmDeviceMcbmEventSink::HandleData(FairMQParts& parts, int /*index*/)
+{
   fulNumMessages++;
-  LOG(debug) << "Received message number " << fulNumMessages << " with "
-             << parts.Size() << " parts"
+  LOG(debug) << "Received message number " << fulNumMessages << " with " << parts.Size() << " parts"
              << ", size0: " << parts.At(0)->GetSize();
 
-  if (0 == fulNumMessages % 10000)
-    LOG(info) << "Received " << fulNumMessages << " messages";
+  if (0 == fulNumMessages % 10000) LOG(info) << "Received " << fulNumMessages << " messages";
 
   /// Extract unpacked data from input message
   uint32_t uPartIdx = 0;
@@ -359,13 +362,13 @@ bool CbmDeviceMcbmEventSink::HandleData(FairMQParts& parts, int /*index*/) {
   inputArchiveTsMeta >> (*fTsMetaData);
   ++uPartIdx;
 */
-  Deserialize<RootSerializer>(*parts.At(uPartIdx), fTsMetaData);
+  //  Deserialize<RootSerializer>(*parts.At(uPartIdx), fTsMetaData);
+  RootSerializer().Deserialize(*parts.At(uPartIdx), fTsMetaData);
   LOG(debug) << "TS metadata extracted";
 
   /// FIXME: Need to check if TS arrived in order (probably not!!!) + buffer!!!
   if (fuPrevTsIndex + 1 == fTsMetaData->GetIndex()
-      || (0 == fuPrevTsIndex && 0 == fulTsCounter
-          && 0 == fTsMetaData->GetIndex())) {
+      || (0 == fuPrevTsIndex && 0 == fulTsCounter && 0 == fTsMetaData->GetIndex())) {
     LOG(debug) << "TS direct to dump";
     /// Fill all storage variables registers for data output
     PrepareTreeEntry(parts);
@@ -378,10 +381,8 @@ bool CbmDeviceMcbmEventSink::HandleData(FairMQParts& parts, int /*index*/) {
   else {
     LOG(debug) << "TS direct to storage";
     /// If not consecutive to last TS sent,
-    fmFullTsStorage.emplace_hint(
-      fmFullTsStorage.end(),
-      std::pair<uint64_t, CbmUnpackedTimeslice>(
-        fTsMetaData->GetIndex(), std::move(CbmUnpackedTimeslice(parts))));
+    fmFullTsStorage.emplace_hint(fmFullTsStorage.end(), std::pair<uint64_t, CbmUnpackedTimeslice>(
+                                                          fTsMetaData->GetIndex(), CbmUnpackedTimeslice(parts)));
   }  // else of if( fuPrevTsIndex + 1 == fTsMetaData->GetIndex() ||  ( 0 == fuPrevTsIndex && 0 == fulTsCounter && 0 == fTsMetaData->GetIndex() )
   LOG(debug) << "TS metadata checked";
 
@@ -397,13 +398,10 @@ bool CbmDeviceMcbmEventSink::HandleData(FairMQParts& parts, int /*index*/) {
     /// Send histograms each 100 time slices. Should be each ~1s
     /// Use also runtime checker to trigger sending after M s if
     /// processing too slow or delay sending if processing too fast
-    std::chrono::system_clock::time_point currentTime =
-      std::chrono::system_clock::now();
-    std::chrono::duration<double_t> elapsedSeconds =
-      currentTime - fLastPublishTime;
+    std::chrono::system_clock::time_point currentTime = std::chrono::system_clock::now();
+    std::chrono::duration<double_t> elapsedSeconds    = currentTime - fLastPublishTime;
     if ((fdMaxPublishTime < elapsedSeconds.count())
-        || (0 == fulNumMessages % fuPublishFreqTs
-            && fdMinPublishTime < elapsedSeconds.count())) {
+        || (0 == fulNumMessages % fuPublishFreqTs && fdMinPublishTime < elapsedSeconds.count())) {
       SendHistograms();
       fLastPublishTime = std::chrono::system_clock::now();
     }  // if( ( fdMaxPublishTime < elapsedSeconds.count() ) || ( 0 == fulNumMessages % fuPublishFreqTs && fdMinPublishTime < elapsedSeconds.count() ) )
@@ -412,8 +410,8 @@ bool CbmDeviceMcbmEventSink::HandleData(FairMQParts& parts, int /*index*/) {
   return true;
 }
 //--------------------------------------------------------------------//
-bool CbmDeviceMcbmEventSink::HandleCommand(FairMQMessagePtr& msg,
-                                           int /*index*/) {
+bool CbmDeviceMcbmEventSink::HandleCommand(FairMQMessagePtr& msg, int /*index*/)
+{
   /*
    std::string sCommand( static_cast< char * >( msg->GetData() ),
                           msg->GetSize() );
@@ -455,13 +453,11 @@ bool CbmDeviceMcbmEventSink::HandleCommand(FairMQMessagePtr& msg,
     fuTotalTsCount = std::stoul(sNext.substr(charPosDel));
 
     LOG(info) << "CbmDeviceMcbmEventSink::HandleCommand => "
-              << "Received EOF command with final TS index " << fuLastTsIndex
-              << " and total nb TS " << fuTotalTsCount;
+              << "Received EOF command with final TS index " << fuLastTsIndex << " and total nb TS " << fuTotalTsCount;
     /// End of data: clean save of data + close file + send last state of histos if enabled
     if (fuPrevTsIndex == fuLastTsIndex && fulTsCounter == fuTotalTsCount) {
       LOG(info) << "CbmDeviceMcbmEventSink::HandleCommand => "
-                << "Found final TS index " << fuLastTsIndex
-                << " and total nb TS " << fuTotalTsCount;
+                << "Found final TS index " << fuLastTsIndex << " and total nb TS " << fuTotalTsCount;
       Finish();
     }  // if( fuPrevTsIndex == fuLastTsIndex && fulTsCounter == fuTotalTsCount )
   }    // if( "EOF" == sCmdTag )
@@ -471,24 +467,22 @@ bool CbmDeviceMcbmEventSink::HandleCommand(FairMQMessagePtr& msg,
     Finish();
   }  // else if( "STOP" == sCmdTag )
   else {
-    LOG(warning) << "Unknown command received: " << sCmdTag
-                 << " => will be ignored!";
+    LOG(warning) << "Unknown command received: " << sCmdTag << " => will be ignored!";
   }  // else if command not recognized
 
   return true;
 }
 //--------------------------------------------------------------------//
-void CbmDeviceMcbmEventSink::CheckTsQueues() {
+void CbmDeviceMcbmEventSink::CheckTsQueues()
+{
   bool bHoleFoundInBothQueues = false;
 
-  std::map<uint64_t, CbmUnpackedTimeslice>::iterator itFullTs =
-    fmFullTsStorage.begin();
-  std::vector<uint64_t>::iterator itMissTs = fvulMissedTsIndices.begin();
+  std::map<uint64_t, CbmUnpackedTimeslice>::iterator itFullTs = fmFullTsStorage.begin();
+  std::vector<uint64_t>::iterator itMissTs                    = fvulMissedTsIndices.begin();
 
   while (!bHoleFoundInBothQueues) {
     /// Check if the first TS in the full TS queue is the next one
-    if (fmFullTsStorage.end() != itFullTs
-        && fuPrevTsIndex + 1 == (*itFullTs).first) {
+    if (fmFullTsStorage.end() != itFullTs && fuPrevTsIndex + 1 == (*itFullTs).first) {
       /// Fill all storage variables registers for data output
       PrepareTreeEntry((*itFullTs).second);
       /// Trigger FairRoot manager to dump Tree entry
@@ -503,11 +497,9 @@ void CbmDeviceMcbmEventSink::CheckTsQueues() {
       continue;
     }  // if( fmFullTsStorage.end() != itFullTs && fuPrevTsIndex + 1 == (*itFullTs).first() )
     /// Check if the first TS in the missed TS queue is the next one
-    if (fvulMissedTsIndices.end() != itMissTs
-        && fuPrevTsIndex + 1 == (*itMissTs)) {
+    if (fvulMissedTsIndices.end() != itMissTs && fuPrevTsIndex + 1 == (*itMissTs)) {
       /// Prepare entry with only dummy TS metadata and empty storage variables
-      new (
-        (*fTimeSliceMetaDataArray)[fTimeSliceMetaDataArray->GetEntriesFast()])
+      new ((*fTimeSliceMetaDataArray)[fTimeSliceMetaDataArray->GetEntriesFast()])
         TimesliceMetaData(0, 0, 0, (*itMissTs));
 
       /// Trigger FairRoot manager to dump Tree entry
@@ -531,16 +523,15 @@ void CbmDeviceMcbmEventSink::CheckTsQueues() {
   fvulMissedTsIndices.erase(fvulMissedTsIndices.begin(), itMissTs);
 
   /// End of data: clean save of data + close file + send last state of histos if enabled
-  if (fbReceivedEof && fuPrevTsIndex == fuLastTsIndex
-      && fulTsCounter == fuTotalTsCount) {
+  if (fbReceivedEof && fuPrevTsIndex == fuLastTsIndex && fulTsCounter == fuTotalTsCount) {
     LOG(info) << "CbmDeviceMcbmEventSink::CheckTsQueues => "
-              << "Found final TS index " << fuLastTsIndex << " and total nb TS "
-              << fuTotalTsCount;
+              << "Found final TS index " << fuLastTsIndex << " and total nb TS " << fuTotalTsCount;
     Finish();
   }  // if( fbReceivedEof && fuPrevTsIndex == fuLastTsIndex && fulTsCounter == fuTotalTsCount )
 }
 //--------------------------------------------------------------------//
-void CbmDeviceMcbmEventSink::PrepareTreeEntry(CbmUnpackedTimeslice unpTs) {
+void CbmDeviceMcbmEventSink::PrepareTreeEntry(CbmUnpackedTimeslice unpTs)
+{
   /// FIXME: poor man solution with lots of data copy until we undertsnad how to properly deal
   /// with FairMq messages ownership and memory managment
 
@@ -550,15 +541,15 @@ void CbmDeviceMcbmEventSink::PrepareTreeEntry(CbmUnpackedTimeslice unpTs) {
 
   /*
    /// Explicit copy version: safe but slow
-      /// T0
-   fvDigiT0->insert( fvDigiT0->end(), unpTs.fvDigiT0.begin(), unpTs.fvDigiT0.end() );
+      /// Bmon
+   fvDigiBmon->insert( fvDigiBmon->end(), unpTs.fvDigiBmon.begin(), unpTs.fvDigiBmon.end() );
       /// STS
    fvDigiSts->insert( fvDigiSts->end(), unpTs.fvDigiSts.begin(), unpTs.fvDigiSts.end() );
       /// MUCH
    fvDigiMuch->insert( fvDigiMuch->end(), unpTs.fvDigiMuch.begin(), unpTs.fvDigiMuch.end() );
       /// TRD
    fvDigiTrd->insert( fvDigiTrd->end(), unpTs.fvDigiTrd.begin(), unpTs.fvDigiTrd.end() );
-      /// T0F
+      /// BmonF
    fvDigiTof->insert( fvDigiTof->end(), unpTs.fvDigiTof.begin(), unpTs.fvDigiTof.end() );
       /// RICH
    fvDigiRich->insert( fvDigiRich->end(), unpTs.fvDigiRich.begin(), unpTs.fvDigiRich.end() );
@@ -566,15 +557,15 @@ void CbmDeviceMcbmEventSink::PrepareTreeEntry(CbmUnpackedTimeslice unpTs) {
    fvDigiPsd->insert( fvDigiPsd->end(), unpTs.fvDigiPsd.begin(), unpTs.fvDigiPsd.end() );
 */
   /// move version: safe but slow
-  /// T0
-  (*fvDigiT0) = std::move(unpTs.fvDigiT0);
+  /// Bmon
+  (*fvDigiBmon) = std::move(unpTs.fvDigiBmon);
   /// STS
   (*fvDigiSts) = std::move(unpTs.fvDigiSts);
   /// MUCH
   (*fvDigiMuch) = std::move(unpTs.fvDigiMuch);
   /// TRD
   (*fvDigiTrd) = std::move(unpTs.fvDigiTrd);
-  /// T0F
+  /// BmonF
   (*fvDigiTof) = std::move(unpTs.fvDigiTof);
   /// RICH
   (*fvDigiRich) = std::move(unpTs.fvDigiRich);
@@ -584,7 +575,8 @@ void CbmDeviceMcbmEventSink::PrepareTreeEntry(CbmUnpackedTimeslice unpTs) {
   /// Extract CbmEvent TClonesArray from input message
   fEventsArray->AbsorbObjects(&(unpTs.fEventsArray));
 }
-void CbmDeviceMcbmEventSink::DumpTreeEntry() {
+void CbmDeviceMcbmEventSink::DumpTreeEntry()
+{
   // Unpacked digis + CbmEvent output to root file
   /*
  * NH style
@@ -605,7 +597,7 @@ void CbmDeviceMcbmEventSink::DumpTreeEntry() {
   fTimeSliceMetaDataArray->Clear();
 
   /// Clear vectors
-  fvDigiT0->clear();
+  fvDigiBmon->clear();
   fvDigiSts->clear();
   fvDigiMuch->clear();
   fvDigiTrd->clear();
@@ -620,10 +612,12 @@ void CbmDeviceMcbmEventSink::DumpTreeEntry() {
 }
 
 //--------------------------------------------------------------------//
-bool CbmDeviceMcbmEventSink::SendHistograms() {
+bool CbmDeviceMcbmEventSink::SendHistograms()
+{
   /// Serialize the array of histos into a single MQ message
   FairMQMessagePtr message(NewMessage());
-  Serialize<RootSerializer>(*message, &fArrayHisto);
+  //  Serialize<RootSerializer>(*message, &fArrayHisto);
+  RootSerializer().Serialize(*message, &fArrayHisto);
 
   /// Send message to the common histogram messages queue
   if (Send(message, fsChannelNameHistosInput) < 0) {
@@ -638,7 +632,8 @@ bool CbmDeviceMcbmEventSink::SendHistograms() {
 }
 
 //--------------------------------------------------------------------//
-CbmDeviceMcbmEventSink::~CbmDeviceMcbmEventSink() {
+CbmDeviceMcbmEventSink::~CbmDeviceMcbmEventSink()
+{
   /// FIXME: Add pointers check before delete
 
   /// Close things properly if not alredy done
@@ -650,7 +645,7 @@ CbmDeviceMcbmEventSink::~CbmDeviceMcbmEventSink() {
   delete fTsMetaData;
 
   /// Clear vectors
-  fvDigiT0->clear();
+  fvDigiBmon->clear();
   fvDigiSts->clear();
   fvDigiMuch->clear();
   fvDigiTrd->clear();
@@ -665,13 +660,13 @@ CbmDeviceMcbmEventSink::~CbmDeviceMcbmEventSink() {
   delete fpRun;
 }
 
-void CbmDeviceMcbmEventSink::Finish() {
+void CbmDeviceMcbmEventSink::Finish()
+{
   // Clean closure of output to root file
   fpFairRootMgr->Write();
   //   fpFairRootMgr->GetSource()->Close();
   fpFairRootMgr->CloseSink();
-  LOG(info) << "File closed after saving "
-            << (fulTsCounter + fulMissedTsCounter) << " TS (" << fulTsCounter
+  LOG(info) << "File closed after saving " << (fulTsCounter + fulMissedTsCounter) << " TS (" << fulTsCounter
             << " full ones and " << fulMissedTsCounter << " missed/empty ones)";
 
   if (kTRUE == fbFillHistos) {
@@ -686,8 +681,8 @@ void CbmDeviceMcbmEventSink::Finish() {
   fbFinishDone = kTRUE;
 }
 
-CbmUnpackedTimeslice::CbmUnpackedTimeslice(FairMQParts& parts)
-  : fEventsArray("CbmEvent", 500) {
+CbmUnpackedTimeslice::CbmUnpackedTimeslice(FairMQParts& parts) : fEventsArray("CbmEvent", 500)
+{
   /// Extract unpacked data from input message
   uint32_t uPartIdx = 0;
   /// TS metadata
@@ -708,57 +703,50 @@ CbmUnpackedTimeslice::CbmUnpackedTimeslice(FairMQParts& parts)
     fTsMetaData = *(static_cast<TimesliceMetaData*>(tempObjectMeta));
   }  // if( TString( tempObject->ClassName() ).EqualTo( "TClonesArray") )
 
-  /// T0
-  std::string msgStrT0(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                       (parts.At(uPartIdx))->GetSize());
-  std::istringstream issT0(msgStrT0);
-  boost::archive::binary_iarchive inputArchiveT0(issT0);
-  inputArchiveT0 >> fvDigiT0;
+  /// Bmon
+  std::string msgStrBmon(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issBmon(msgStrBmon);
+  boost::archive::binary_iarchive inputArchiveBmon(issBmon);
+  inputArchiveBmon >> fvDigiBmon;
   ++uPartIdx;
 
   /// STS
-  std::string msgStrSts(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrSts(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issSts(msgStrSts);
   boost::archive::binary_iarchive inputArchiveSts(issSts);
   inputArchiveSts >> fvDigiSts;
   ++uPartIdx;
 
   /// MUCH
-  std::string msgStrMuch(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                         (parts.At(uPartIdx))->GetSize());
+  std::string msgStrMuch(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issMuch(msgStrMuch);
   boost::archive::binary_iarchive inputArchiveMuch(issMuch);
   inputArchiveMuch >> fvDigiMuch;
   ++uPartIdx;
 
   /// TRD
-  std::string msgStrTrd(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrTrd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issTrd(msgStrTrd);
   boost::archive::binary_iarchive inputArchiveTrd(issTrd);
   inputArchiveTrd >> fvDigiTrd;
   ++uPartIdx;
 
-  /// T0F
-  std::string msgStrTof(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  /// BmonF
+  std::string msgStrTof(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issTof(msgStrTof);
   boost::archive::binary_iarchive inputArchiveTof(issTof);
   inputArchiveTof >> fvDigiTof;
   ++uPartIdx;
 
   /// RICH
-  std::string msgStrRich(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                         (parts.At(uPartIdx))->GetSize());
+  std::string msgStrRich(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issRich(msgStrRich);
   boost::archive::binary_iarchive inputArchiveRich(issRich);
   inputArchiveRich >> fvDigiRich;
   ++uPartIdx;
 
   /// PSD
-  std::string msgStrPsd(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrPsd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issPsd(msgStrPsd);
   boost::archive::binary_iarchive inputArchivePsd(issPsd);
   inputArchivePsd >> fvDigiPsd;
@@ -776,3 +764,16 @@ CbmUnpackedTimeslice::CbmUnpackedTimeslice(FairMQParts& parts)
     fEventsArray.AbsorbObjects(arrayEventsIn);
   }  // if( TString( tempObject->ClassName() ).EqualTo( "TClonesArray") )
 }
+
+CbmUnpackedTimeslice::~CbmUnpackedTimeslice()
+{
+  fvDigiBmon.clear();
+  fvDigiSts.clear();
+  fvDigiMuch.clear();
+  fvDigiTrd.clear();
+  fvDigiTof.clear();
+  fvDigiRich.clear();
+  fvDigiPsd.clear();
+  //  fEventsArray.Clear("C");
+  fEventsArray.Delete();
+}

MQ/mcbm/CbmDeviceMcbmEventSink.h

+/* Copyright (C) 2020-2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
 /**
  * CbmDeviceMcbmEventSink.h
  *
@@ -10,12 +14,14 @@
 
 /// CBM headers
 #include "CbmEvent.h"
+#include "CbmMqTMessage.h"
 #include "CbmMuchBeamTimeDigi.h"
 #include "CbmPsdDigi.h"
 #include "CbmRichDigi.h"
 #include "CbmStsDigi.h"
 #include "CbmTofDigi.h"
 #include "CbmTrdDigi.h"
+
 #include "TimesliceMetaData.h"
 
 /// FAIRROOT headers
@@ -24,7 +30,6 @@
 /// FAIRSOFT headers (geant, boost, ...)
 #include "Rtypes.h"
 #include "TClonesArray.h"
-#include "TMessage.h"
 #include "TObjArray.h"
 
 /// C/C++ headers
@@ -43,9 +48,10 @@ class CbmUnpackedTimeslice {
   /// TODO: rename to CbmTsWithEvents
 public:
   CbmUnpackedTimeslice(FairMQParts& parts);
+  ~CbmUnpackedTimeslice();
 
   TimesliceMetaData fTsMetaData;
-  std::vector<CbmTofDigi> fvDigiT0;
+  std::vector<CbmTofDigi> fvDigiBmon;
   std::vector<CbmStsDigi> fvDigiSts;
   std::vector<CbmMuchBeamTimeDigi> fvDigiMuch;
   std::vector<CbmTrdDigi> fvDigiTrd;
@@ -71,8 +77,7 @@ private:
 
   /// Control flags
   Bool_t fbFillHistos = kFALSE;  //! Switch ON/OFF filling of histograms
-  Bool_t fbFinishDone =
-    kFALSE;  //! Keep track of whether the Finish was already called
+  Bool_t fbFinishDone = kFALSE;  //! Keep track of whether the Finish was already called
 
   /// User settings parameters
   /// Algo enum settings
@@ -97,12 +102,11 @@ private:
   //      Bool_t InitParameters( TList* fParCList );
 
   /// Statistics & missed TS detection
-  uint64_t fuPrevTsIndex      = 0;
-  uint64_t fulNumMessages     = 0;
-  uint64_t fulTsCounter       = 0;
-  uint64_t fulMissedTsCounter = 0;
-  std::chrono::system_clock::time_point fLastPublishTime =
-    std::chrono::system_clock::now();
+  uint64_t fuPrevTsIndex                                 = 0;
+  uint64_t fulNumMessages                                = 0;
+  uint64_t fulTsCounter                                  = 0;
+  uint64_t fulMissedTsCounter                            = 0;
+  std::chrono::system_clock::time_point fLastPublishTime = std::chrono::system_clock::now();
 
   /// Control Commands reception
   bool fbReceivedEof      = false;
@@ -116,7 +120,7 @@ private:
   TClonesArray* fTimeSliceMetaDataArray = nullptr;  //!
   TimesliceMetaData* fTsMetaData        = nullptr;
   /// Digis storage
-  std::vector<CbmTofDigi>* fvDigiT0            = nullptr;
+  std::vector<CbmTofDigi>* fvDigiBmon          = nullptr;
   std::vector<CbmStsDigi>* fvDigiSts           = nullptr;
   std::vector<CbmMuchBeamTimeDigi>* fvDigiMuch = nullptr;
   std::vector<CbmTrdDigi>* fvDigiTrd           = nullptr;
@@ -136,7 +140,6 @@ private:
   /// Data storage
   FairRunOnline* fpRun           = nullptr;
   FairRootManager* fpFairRootMgr = nullptr;
-  TFile* fpOutRootFile           = nullptr;
 
   /// Array of histograms to send to the histogram server
   TObjArray fArrayHisto = {};
@@ -157,13 +160,4 @@ private:
   void Finish();
 };
 
-// special class to expose protected TMessage constructor
-class CbmMQTMessage : public TMessage {
-public:
-  CbmMQTMessage(void* buf, Int_t len) : TMessage(buf, len) {
-    ResetBit(kIsOwner);
-  }
-};
-
-
 #endif /* CBMDEVICEMCBMEVTSINK_H_ */

MQ/mcbm/CbmDeviceMcbmMonitorPulser.cxx

+/* Copyright (C) 2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
 /**
  * CbmDeviceMcbmMonitorPulser.cxx
  *
@@ -8,6 +12,7 @@
 #include "CbmDeviceMcbmMonitorPulser.h"
 
 #include "CbmMQDefs.h"
+
 #include "TimesliceMetaData.h"
 
 //#include "CbmMcbm2018MonitorAlgoTof.h"
@@ -15,11 +20,9 @@
 
 #include "StorableTimeslice.hpp"
 
-#include "BoostSerializer.h"
 #include "FairMQLogger.h"
 #include "FairMQProgOptions.h"  // device->fConfig
 #include "FairParGenericSet.h"
-#include "RootSerializer.h"
 
 #include "TCanvas.h"
 #include "TFile.h"
@@ -27,14 +30,16 @@
 #include "TList.h"
 #include "TNamed.h"
 
-#include <array>
-#include <iomanip>
-#include <string>
-
+#include "BoostSerializer.h"
 #include <boost/archive/binary_iarchive.hpp>
 #include <boost/serialization/utility.hpp>
 
+#include <array>
+#include <iomanip>
 #include <stdexcept>
+#include <string>
+
+#include "RootSerializer.h"
 struct InitTaskError : std::runtime_error {
   using std::runtime_error::runtime_error;
 };
@@ -45,9 +50,11 @@ using namespace std;
 
 CbmDeviceMcbmMonitorPulser::CbmDeviceMcbmMonitorPulser()
 //   : fMonitorAlgo{ new CbmMcbm2018MonitorAlgoTof() }
-{}
+{
+}
 
-void CbmDeviceMcbmMonitorPulser::InitTask() try {
+void CbmDeviceMcbmMonitorPulser::InitTask()
+try {
   /// Read options from executable
   LOG(info) << "Init options for CbmMqStarHistoServer.";
 
@@ -66,10 +73,8 @@ void CbmDeviceMcbmMonitorPulser::InitTask() try {
   fsAllowedChannels[0]      = fsChannelNameDataInput;
 
   LOG(info) << "Histograms publication frequency in TS:    " << fuPublishFreqTs;
-  LOG(info) << "Histograms publication min. interval in s: "
-            << fdMinPublishTime;
-  LOG(info) << "Histograms publication max. interval in s: "
-            << fdMaxPublishTime;
+  LOG(info) << "Histograms publication min. interval in s: " << fdMinPublishTime;
+  LOG(info) << "Histograms publication max. interval in s: " << fdMaxPublishTime;
 
   /// Set the Monitor Algo in Absolute time scale
   //   fMonitorAlgo->UseAbsoluteTime();
@@ -89,40 +94,38 @@ void CbmDeviceMcbmMonitorPulser::InitTask() try {
   for (auto const& entry : fChannels) {
     LOG(info) << "Channel name: " << entry.first;
     if (std::string::npos != entry.first.find(fsChannelNameDataInput)) {
-      if (!IsChannelNameAllowed(entry.first))
-        throw InitTaskError("Channel name does not match.");
+      if (!IsChannelNameAllowed(entry.first)) throw InitTaskError("Channel name does not match.");
       OnData(entry.first, &CbmDeviceMcbmMonitorPulser::HandleData);
     }  // if( std::string::npos != entry.first.find( fsChannelNameDataInput ) )
   }    // for( auto const &entry : fChannels )
   InitContainers();
-} catch (InitTaskError& e) {
+}
+catch (InitTaskError& e) {
   LOG(error) << e.what();
   // Wrapper defined in CbmMQDefs.h to support different FairMQ versions
   cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
 }
 
-bool CbmDeviceMcbmMonitorPulser::IsChannelNameAllowed(std::string channelName) {
+bool CbmDeviceMcbmMonitorPulser::IsChannelNameAllowed(std::string channelName)
+{
   for (auto const& entry : fsAllowedChannels) {
     std::size_t pos1 = channelName.find(entry);
     if (pos1 != std::string::npos) {
       const vector<std::string>::const_iterator pos =
         std::find(fsAllowedChannels.begin(), fsAllowedChannels.end(), entry);
-      const vector<std::string>::size_type idx =
-        pos - fsAllowedChannels.begin();
+      const vector<std::string>::size_type idx = pos - fsAllowedChannels.begin();
       LOG(info) << "Found " << entry << " in " << channelName;
-      LOG(info) << "Channel name " << channelName
-                << " found in list of allowed channel names at position "
-                << idx;
+      LOG(info) << "Channel name " << channelName << " found in list of allowed channel names at position " << idx;
       return true;
     }  // if (pos1!=std::string::npos)
   }    // for(auto const &entry : fsAllowedChannels)
-  LOG(info) << "Channel name " << channelName
-            << " not found in list of allowed channel names.";
+  LOG(info) << "Channel name " << channelName << " not found in list of allowed channel names.";
   LOG(error) << "Stop device.";
   return false;
 }
 
-Bool_t CbmDeviceMcbmMonitorPulser::InitContainers() {
+Bool_t CbmDeviceMcbmMonitorPulser::InitContainers()
+{
   LOG(info) << "Init parameter containers for CbmDeviceMcbmMonitorPulser.";
   Bool_t initOK = kTRUE;
   /*
@@ -147,7 +150,7 @@ Bool_t CbmDeviceMcbmMonitorPulser::InitContainers() {
       if ( Send(req, "parameters") > 0 ) {
          if ( Receive( rep, "parameters" ) >= 0) {
             if ( rep->GetSize() != 0 ) {
-               CbmMQTMessage tmsg( rep->GetData(), rep->GetSize() );
+               CbmMqTMessage tmsg( rep->GetData(), rep->GetSize() );
                newObj = static_cast< FairParGenericSet* >( tmsg.ReadObject( tmsg.GetClass() ) );
                LOG( info ) << "Received unpack parameter from the server:";
                newObj->print();
@@ -198,7 +201,8 @@ Bool_t CbmDeviceMcbmMonitorPulser::InitContainers() {
 
       /// Serialize the vector of histo config into a single MQ message
       FairMQMessagePtr messageHist( NewMessage() );
-      Serialize< BoostSerializer < std::pair< std::string, std::string > > >( *messageHist, psHistoConfig );
+//      Serialize< BoostSerializer < std::pair< std::string, std::string > > >( *messageHist, psHistoConfig );
+      BoostSerializer<std::pair<std::string, std::string>>().Serialize(*messageHist,psHistoConfig);
 
       /// Send message to the common histogram config messages queue
       if( Send( messageHist, fsChannelNameHistosConfig ) < 0 )
@@ -227,7 +231,8 @@ Bool_t CbmDeviceMcbmMonitorPulser::InitContainers() {
 
       /// Serialize the vector of canvas config into a single MQ message
       FairMQMessagePtr messageCan( NewMessage() );
-      Serialize< BoostSerializer < std::pair< std::string, std::string > > >( *messageCan, psCanvConfig );
+//      Serialize< BoostSerializer < std::pair< std::string, std::string > > >( *messageCan, psCanvConfig );
+      BoostSerializer < std::pair< std::string, std::string > >().Serialize( *messageCan, psCanvConfig );
 
       /// Send message to the common canvas config messages queue
       if( Send( messageCan, fsChannelNameCanvasConfig ) < 0 )
@@ -245,11 +250,11 @@ Bool_t CbmDeviceMcbmMonitorPulser::InitContainers() {
 
 
 // handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)
-bool CbmDeviceMcbmMonitorPulser::HandleData(FairMQParts& parts, int /*index*/) {
+bool CbmDeviceMcbmMonitorPulser::HandleData(FairMQParts& parts, int /*index*/)
+{
   fulNumMessages++;
 
-  LOG(debug) << "Received message " << fulNumMessages << " with "
-             << parts.Size() << " parts"
+  LOG(debug) << "Received message " << fulNumMessages << " with " << parts.Size() << " parts"
              << ", size0: " << parts.At(0)->GetSize();
 
   uint32_t uPartIdx = 0;
@@ -263,53 +268,47 @@ bool CbmDeviceMcbmMonitorPulser::HandleData(FairMQParts& parts, int /*index*/) {
   inputArchiveTsMeta >> (*fTsMetaData);
   ++uPartIdx;
 */
-  Deserialize<RootSerializer>(*parts.At(uPartIdx), fTsMetaData);
+  //  Deserialize<RootSerializer>(*parts.At(uPartIdx), fTsMetaData);
+  RootSerializer().Deserialize(*parts.At(uPartIdx), fTsMetaData);
   ++uPartIdx;
 
-  std::string msgStrT0(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                       (parts.At(uPartIdx))->GetSize());
-  std::istringstream issT0(msgStrT0);
-  boost::archive::binary_iarchive inputArchiveT0(issT0);
-  inputArchiveT0 >> fvDigiT0;
+  std::string msgStrBmon(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
+  std::istringstream issBmon(msgStrBmon);
+  boost::archive::binary_iarchive inputArchiveBmon(issBmon);
+  inputArchiveBmon >> fvDigiBmon;
   ++uPartIdx;
 
-  std::string msgStrSts(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrSts(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issSts(msgStrSts);
   boost::archive::binary_iarchive inputArchiveSts(issSts);
   inputArchiveSts >> fvDigiSts;
   ++uPartIdx;
 
-  std::string msgStrMuch(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                         (parts.At(uPartIdx))->GetSize());
+  std::string msgStrMuch(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issMuch(msgStrMuch);
   boost::archive::binary_iarchive inputArchiveMuch(issMuch);
   inputArchiveMuch >> fvDigiMuch;
   ++uPartIdx;
 
-  std::string msgStrTrd(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrTrd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issTrd(msgStrTrd);
   boost::archive::binary_iarchive inputArchiveTrd(issTrd);
   inputArchiveTrd >> fvDigiTrd;
   ++uPartIdx;
 
-  std::string msgStrTof(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrTof(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issTof(msgStrTof);
   boost::archive::binary_iarchive inputArchiveTof(issTof);
   inputArchiveTof >> fvDigiTof;
   ++uPartIdx;
 
-  std::string msgStrRich(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                         (parts.At(uPartIdx))->GetSize());
+  std::string msgStrRich(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issRich(msgStrRich);
   boost::archive::binary_iarchive inputArchiveRich(issRich);
   inputArchiveRich >> fvDigiRich;
   ++uPartIdx;
 
-  std::string msgStrPsd(static_cast<char*>(parts.At(uPartIdx)->GetData()),
-                        (parts.At(uPartIdx))->GetSize());
+  std::string msgStrPsd(static_cast<char*>(parts.At(uPartIdx)->GetData()), (parts.At(uPartIdx))->GetSize());
   std::istringstream issPsd(msgStrPsd);
   boost::archive::binary_iarchive inputArchivePsd(issPsd);
   inputArchivePsd >> fvDigiPsd;
@@ -319,7 +318,7 @@ bool CbmDeviceMcbmMonitorPulser::HandleData(FairMQParts& parts, int /*index*/) {
 
   /// Clear vectors
   delete fTsMetaData;
-  fvDigiT0.clear();
+  fvDigiBmon.clear();
   fvDigiSts.clear();
   fvDigiMuch.clear();
   fvDigiTrd.clear();
@@ -360,15 +359,18 @@ bool CbmDeviceMcbmMonitorPulser::HandleData(FairMQParts& parts, int /*index*/) {
   return true;
 }
 
-bool CbmDeviceMcbmMonitorPulser::SendHistograms() {
+bool CbmDeviceMcbmMonitorPulser::SendHistograms()
+{
   /// Serialize the array of histos into a single MQ message
   FairMQMessagePtr message(NewMessage());
-  Serialize<RootSerializer>(*message, &fArrayHisto);
+  //  Serialize<RootSerializer>(*message, &fArrayHisto);
+  RootSerializer().Serialize(*message, &fArrayHisto);
 
   // test code to check if deserialization works
   /*
   TObject* tempObject = nullptr;
-  Deserialize<RootDeserializer>(*message, tempObject);
+//  Deserialize<RootDeserializer>(*message, tempObject);
+  RootDeserializer().Deserialize(*message, tempObject);
 
   if (TString(tempObject->ClassName()).EqualTo("TObjArray")) {
    TObjArray* arrayHisto = static_cast<TObjArray*>(tempObject);

MQ/mcbm/CbmDeviceMcbmMonitorPulser.h

+/* Copyright (C) 2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
 /**
  * CbmDeviceMcbmMonitorPulser.h
  *
@@ -8,6 +12,7 @@
 #ifndef CBMDEVICEMCBMMONITORPULSER_H_
 #define CBMDEVICEMCBMMONITORPULSER_H_
 
+#include "CbmMqTMessage.h"
 #include "CbmMuchBeamTimeDigi.h"
 #include "CbmPsdDigi.h"
 #include "CbmRichDigi.h"
@@ -18,7 +23,6 @@
 #include "FairMQDevice.h"
 
 #include "Rtypes.h"
-#include "TMessage.h"
 #include "TObjArray.h"
 
 #include <chrono>
@@ -53,10 +57,8 @@ private:
   /*********************** SHOULD GO IN ALGO ****************************/
 
   /// Control flags
-  Bool_t fbDebugMonitorMode =
-    kFALSE;  //! Switch ON the filling of a additional set of histograms
-  Bool_t fbIgnoreCriticalErrors =
-    kTRUE;  //! If ON not printout at all for critical errors
+  Bool_t fbDebugMonitorMode      = kFALSE;  //! Switch ON the filling of a additional set of histograms
+  Bool_t fbIgnoreCriticalErrors  = kTRUE;   //! If ON not printout at all for critical errors
   Bool_t fbComponentsAddedToList = kFALSE;
 
   /// User settings parameters
@@ -81,16 +83,15 @@ private:
 */
 
   /// Statistics & first TS rejection
-  uint64_t fulNumMessages = 0;
-  uint64_t fulTsCounter   = 0;
-  std::chrono::system_clock::time_point fLastPublishTime =
-    std::chrono::system_clock::now();
+  uint64_t fulNumMessages                                = 0;
+  uint64_t fulTsCounter                                  = 0;
+  std::chrono::system_clock::time_point fLastPublishTime = std::chrono::system_clock::now();
 
   /// Data reception
   /// TS MetaData storage
   TimesliceMetaData* fTsMetaData = nullptr;
   /// Digis storage
-  std::vector<CbmTofDigi> fvDigiT0            = {};
+  std::vector<CbmTofDigi> fvDigiBmon          = {};
   std::vector<CbmStsDigi> fvDigiSts           = {};
   std::vector<CbmMuchBeamTimeDigi> fvDigiMuch = {};
   std::vector<CbmTrdDigi> fvDigiTrd           = {};
@@ -119,21 +120,15 @@ private:
   void CheckInterSystemOffset();
 
   template<class Digi>
-  Int_t FillSystemOffsetHistos(TH1* histo,
-                               TH2* histoEvo,
-                               TH2* histoEvoLong,
-                               TProfile* profMeanEvo,
-                               TH2* histoAFCK,
-                               const Double_t T0Time,
-                               const Int_t offsetRange,
-                               Int_t iStartDigi,
+  Int_t FillSystemOffsetHistos(TH1* histo, TH2* histoEvo, TH2* histoEvoLong, TProfile* profMeanEvo, TH2* histoAFCK,
+                               const Double_t T0Time, const Int_t offsetRange, Int_t iStartDigi,
                                ECbmModuleId iDetId = ECbmModuleId::kLastModule);
 
   Int_t CalcNrBins(Int_t);
   void CreateHistos();
 
   /// Variables to store the previous digi time
-  Double_t fPrevTimeT0   = 0.;
+  Double_t fPrevTimeBmon = 0.;
   Double_t fPrevTimeSts  = 0.;
   Double_t fPrevTimeMuch = 0.;
   Double_t fPrevTimeTrd  = 0.;
@@ -141,19 +136,19 @@ private:
   Double_t fPrevTimeRich = 0.;
   Double_t fPrevTimePsd  = 0.;
 
-  /// Variables to store the first digi fitting the previous T0 hits
+  /// Variables to store the first digi fitting the previous Bmon hits
   /// => Time-order means the time window for following one can only be in a later digi
-  Int_t fPrevT0FirstDigiSts  = 0;
-  Int_t fPrevT0FirstDigiMuch = 0;
-  Int_t fPrevT0FirstDigiTrd  = 0;
-  Int_t fPrevT0FirstDigiTof  = 0;
-  Int_t fPrevT0FirstDigiRich = 0;
-  Int_t fPrevT0FirstDigiPsd  = 0;
+  Int_t fPrevBmonFirstDigiSts  = 0;
+  Int_t fPrevBmonFirstDigiMuch = 0;
+  Int_t fPrevBmonFirstDigiTrd  = 0;
+  Int_t fPrevBmonFirstDigiTof  = 0;
+  Int_t fPrevBmonFirstDigiRich = 0;
+  Int_t fPrevBmonFirstDigiPsd  = 0;
 
   /// User settings: Data correction parameters
   /// Charge cut
-  UInt_t fuMinTotPulserT0     = 182;
-  UInt_t fuMaxTotPulserT0     = 190;
+  UInt_t fuMinTotPulserBmon   = 182;
+  UInt_t fuMaxTotPulserBmon   = 190;
   UInt_t fuMinAdcPulserSts    = 90;
   UInt_t fuMaxAdcPulserSts    = 100;
   UInt_t fuMinAdcPulserMuch   = 5;
@@ -189,37 +184,37 @@ private:
 
   Int_t fBinWidth = 1;
 
-  TH1* fT0StsDiff       = nullptr;
-  TH1* fT0MuchDiff      = nullptr;
-  TH1* fT0TrdDiff       = nullptr;
-  TH1* fT0TofDiff       = nullptr;
-  TH1* fT0RichDiff      = nullptr;
-  TH1* fT0PsdDiff       = nullptr;
-  TH2* fT0PsdDiffCharge = nullptr;
-
-  TH2* fT0StsDiffEvo  = nullptr;
-  TH2* fT0MuchDiffEvo = nullptr;
-  TH2* fT0TrdDiffEvo  = nullptr;
-  TH2* fT0TofDiffEvo  = nullptr;
-  TH2* fT0RichDiffEvo = nullptr;
-  TH2* fT0PsdDiffEvo  = nullptr;
-
-  TH2* fT0StsDiffEvoLong  = nullptr;
-  TH2* fT0MuchDiffEvoLong = nullptr;
-  TH2* fT0TrdDiffEvoLong  = nullptr;
-  TH2* fT0TofDiffEvoLong  = nullptr;
-  TH2* fT0RichDiffEvoLong = nullptr;
-  TH2* fT0PsdDiffEvoLong  = nullptr;
+  TH1* fBmonStsDiff       = nullptr;
+  TH1* fBmonMuchDiff      = nullptr;
+  TH1* fBmonTrdDiff       = nullptr;
+  TH1* fBmonTofDiff       = nullptr;
+  TH1* fBmonRichDiff      = nullptr;
+  TH1* fBmonPsdDiff       = nullptr;
+  TH2* fBmonPsdDiffCharge = nullptr;
+
+  TH2* fBmonStsDiffEvo  = nullptr;
+  TH2* fBmonMuchDiffEvo = nullptr;
+  TH2* fBmonTrdDiffEvo  = nullptr;
+  TH2* fBmonTofDiffEvo  = nullptr;
+  TH2* fBmonRichDiffEvo = nullptr;
+  TH2* fBmonPsdDiffEvo  = nullptr;
+
+  TH2* fBmonStsDiffEvoLong  = nullptr;
+  TH2* fBmonMuchDiffEvoLong = nullptr;
+  TH2* fBmonTrdDiffEvoLong  = nullptr;
+  TH2* fBmonTofDiffEvoLong  = nullptr;
+  TH2* fBmonRichDiffEvoLong = nullptr;
+  TH2* fBmonPsdDiffEvoLong  = nullptr;
 
   Double_t fdStartTime     = -1;
-  TProfile* fT0StsMeanEvo  = nullptr;
-  TProfile* fT0MuchMeanEvo = nullptr;
-  TProfile* fT0TrdMeanEvo  = nullptr;
-  TProfile* fT0TofMeanEvo  = nullptr;
-  TProfile* fT0RichMeanEvo = nullptr;
-  TProfile* fT0PsdMeanEvo  = nullptr;
-
-  TH1* fT0T0Diff     = nullptr;
+  TProfile* fBmonStsMeanEvo  = nullptr;
+  TProfile* fBmonMuchMeanEvo = nullptr;
+  TProfile* fBmonTrdMeanEvo  = nullptr;
+  TProfile* fBmonTofMeanEvo  = nullptr;
+  TProfile* fBmonRichMeanEvo = nullptr;
+  TProfile* fBmonPsdMeanEvo  = nullptr;
+
+  TH1* fBmonBmonDiff = nullptr;
   TH1* fStsStsDiff   = nullptr;
   TH1* fMuchMuchDiff = nullptr;
   TH1* fTrdTrdDiff   = nullptr;
@@ -227,14 +222,14 @@ private:
   TH1* fRichRichDiff = nullptr;
   TH1* fPsdPsdDiff   = nullptr;
 
-  TH2* fT0StsNb  = nullptr;
-  TH2* fT0MuchNb = nullptr;
-  TH2* fT0TrdNb  = nullptr;
-  TH2* fT0TofNb  = nullptr;
-  TH2* fT0RichNb = nullptr;
-  TH2* fT0PsdNb  = nullptr;
+  TH2* fBmonStsNb  = nullptr;
+  TH2* fBmonMuchNb = nullptr;
+  TH2* fBmonTrdNb  = nullptr;
+  TH2* fBmonTofNb  = nullptr;
+  TH2* fBmonRichNb = nullptr;
+  TH2* fBmonPsdNb  = nullptr;
 
-  Int_t fiT0Nb   = 0;
+  Int_t fiBmonNb = 0;
   Int_t fiStsNb  = 0;
   Int_t fiMuchNb = 0;
   Int_t fiTrdNb  = 0;
@@ -242,38 +237,29 @@ private:
   Int_t fiRichNb = 0;
   Int_t fiPsdNb  = 0;
 
-  TH1* fT0Address = nullptr;
-  TH1* fT0Channel = nullptr;
+  TH1* fBmonAddress = nullptr;
+  TH1* fBmonChannel = nullptr;
 
-  TH2* fT0StsDpbDiff = nullptr;
-  TH2* fT0StsDpbDiffEvo[kuMaxNbStsDpbs];
+  TH2* fBmonStsDpbDiff = nullptr;
+  TH2* fBmonStsDpbDiffEvo[kuMaxNbStsDpbs];
   TH1* fStsDpbCntsEvo[kuMaxNbStsDpbs];
 
-  TH2* fT0MuchRocDiff  = nullptr;
-  TH2* fT0MuchAsicDiff = nullptr;
-  TH2* fT0MuchAsicDiffEvo[kuMaxNbMuchAsics];
+  TH2* fBmonMuchRocDiff  = nullptr;
+  TH2* fBmonMuchAsicDiff = nullptr;
+  TH2* fBmonMuchAsicDiffEvo[kuMaxNbMuchAsics];
 
   TH2* fDigisPerAsicEvo = nullptr;
   Double_t fdLastMuchDigi[kuMaxNbMuchAsics][kuNbChanSMX];
   Double_t fdLastMuchDigiPulser[kuMaxNbMuchAsics][kuNbChanSMX];
   TH2* fSameChanDigisDistEvo = nullptr;
 
-  Double_t fdLastT0DigiPulser = 0;
+  Double_t fdLastBmonDigiPulser = 0;
 
-  TH2* fDigiTimeEvoT0   = nullptr;
+  TH2* fDigiTimeEvoBmon = nullptr;
   TH2* fDigiTimeEvoSts  = nullptr;
   TH2* fDigiTimeEvoMuch = nullptr;
   TH2* fDigiTimeEvoTof  = nullptr;
   /*********************** SHOULD GO IN ALGO ****************************/
 };
 
-// special class to expose protected TMessage constructor
-class CbmMQTMessage : public TMessage {
-public:
-  CbmMQTMessage(void* buf, Int_t len) : TMessage(buf, len) {
-    ResetBit(kIsOwner);
-  }
-};
-
-
 #endif /* CBMDEVICEMCBMMONITORPULSER_H_ */

MQ/mcbm/CbmDeviceMcbmUnpack.cxx

+/* Copyright (C) 2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
 /**
  * CbmDeviceMcbmUnpack.cxx
  *
@@ -6,24 +10,22 @@
  */
 
 #include "CbmDeviceMcbmUnpack.h"
-#include "CbmMQDefs.h"
 
 #include "CbmFlesCanvasTools.h"
+#include "CbmMQDefs.h"
 #include "CbmMcbm2018UnpackerAlgoMuch.h"
 #include "CbmMcbm2018UnpackerAlgoPsd.h"
 #include "CbmMcbm2018UnpackerAlgoRich.h"
 #include "CbmMcbm2018UnpackerAlgoSts.h"
 #include "CbmMcbm2018UnpackerAlgoTof.h"
 #include "CbmMcbm2018UnpackerAlgoTrdR.h"
-#include "TimesliceMetaData.h"
 
 #include "StorableTimeslice.hpp"
+#include "TimesliceMetaData.h"
 
-#include "BoostSerializer.h"
 #include "FairMQLogger.h"
 #include "FairMQProgOptions.h"  // device->fConfig
 #include "FairParGenericSet.h"
-#include "RootSerializer.h"
 
 #include "TCanvas.h"
 #include "TFile.h"
@@ -31,23 +33,26 @@
 #include "TList.h"
 #include "TNamed.h"
 
-#include <array>
-#include <iomanip>
-#include <string>
-
+#include "BoostSerializer.h"
 #include <boost/archive/binary_iarchive.hpp>
 #include <boost/serialization/utility.hpp>
 
+#include <array>
+#include <iomanip>
 #include <stdexcept>
+#include <string>
+
+#include "RootSerializer.h"
 struct InitTaskError : std::runtime_error {
   using std::runtime_error::runtime_error;
 };
 
 using namespace std;
 
-Bool_t bMcbm2018MonitorTaskT0ResetHistos = kFALSE;
+Bool_t bMcbm2018MonitorTaskBmonResetHistos = kFALSE;
 
-CbmDeviceMcbmUnpack::CbmDeviceMcbmUnpack() {
+CbmDeviceMcbmUnpack::CbmDeviceMcbmUnpack()
+{
   fUnpAlgoSts  = new CbmMcbm2018UnpackerAlgoSts();
   fUnpAlgoMuch = new CbmMcbm2018UnpackerAlgoMuch();
   fUnpAlgoTrd  = new CbmMcbm2018UnpackerAlgoTrdR();
@@ -56,14 +61,15 @@ CbmDeviceMcbmUnpack::CbmDeviceMcbmUnpack() {
   fUnpAlgoPsd  = new CbmMcbm2018UnpackerAlgoPsd();
 }
 
-void CbmDeviceMcbmUnpack::InitTask() try {
+void CbmDeviceMcbmUnpack::InitTask()
+try {
   /// Read options from executable
   LOG(info) << "Init options for CbmDeviceMcbmUnpack.";
-  fbIgnoreOverlapMs = fConfig->GetValue<bool>("IgnOverMs");
-  fvsSetTimeOffs    = fConfig->GetValue<std::vector<std::string>>("SetTrigWin");
+  fbIgnoreOverlapMs       = fConfig->GetValue<bool>("IgnOverMs");
+  fvsSetTimeOffs          = fConfig->GetValue<std::vector<std::string>>("SetTrigWin");
   fsChannelNameDataInput  = fConfig->GetValue<std::string>("TsNameIn");
   fsChannelNameDataOutput = fConfig->GetValue<std::string>("TsNameOut");
-  /// TODO: option to set fuDigiMaskedIdT0 !!!!
+  /// TODO: option to set fuDigiMaskedIdBmon !!!!
   fsAllowedChannels[0] = fsChannelNameDataInput;
 
   // Get the information about created channels from the device
@@ -81,40 +87,38 @@ void CbmDeviceMcbmUnpack::InitTask() try {
   for (auto const& entry : fChannels) {
     LOG(info) << "Channel name: " << entry.first;
     if (std::string::npos != entry.first.find(fsChannelNameDataInput)) {
-      if (!IsChannelNameAllowed(entry.first))
-        throw InitTaskError("Channel name does not match.");
+      if (!IsChannelNameAllowed(entry.first)) throw InitTaskError("Channel name does not match.");
       OnData(entry.first, &CbmDeviceMcbmUnpack::HandleData);
     }  // if( entry.first.find( "ts" )
   }    // for( auto const &entry : fChannels )
   InitContainers();
-} catch (InitTaskError& e) {
+}
+catch (InitTaskError& e) {
   LOG(error) << e.what();
   // Wrapper defined in CbmMQDefs.h to support different FairMQ versions
   cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
 }
 
-bool CbmDeviceMcbmUnpack::IsChannelNameAllowed(std::string channelName) {
+bool CbmDeviceMcbmUnpack::IsChannelNameAllowed(std::string channelName)
+{
   for (auto const& entry : fsAllowedChannels) {
     std::size_t pos1 = channelName.find(entry);
     if (pos1 != std::string::npos) {
       const vector<std::string>::const_iterator pos =
         std::find(fsAllowedChannels.begin(), fsAllowedChannels.end(), entry);
-      const vector<std::string>::size_type idx =
-        pos - fsAllowedChannels.begin();
+      const vector<std::string>::size_type idx = pos - fsAllowedChannels.begin();
       LOG(info) << "Found " << entry << " in " << channelName;
-      LOG(info) << "Channel name " << channelName
-                << " found in list of allowed channel names at position "
-                << idx;
+      LOG(info) << "Channel name " << channelName << " found in list of allowed channel names at position " << idx;
       return true;
     }  // if (pos1!=std::string::npos)
   }    // for(auto const &entry : fsAllowedChannels)
-  LOG(info) << "Channel name " << channelName
-            << " not found in list of allowed channel names.";
+  LOG(info) << "Channel name " << channelName << " not found in list of allowed channel names.";
   LOG(error) << "Stop device.";
   return false;
 }
 
-Bool_t CbmDeviceMcbmUnpack::InitContainers() {
+Bool_t CbmDeviceMcbmUnpack::InitContainers()
+{
   LOG(info) << "Init parameter containers for CbmDeviceMcbmUnpack.";
 
   if (kFALSE == InitParameters(fUnpAlgoSts->GetParList())) return kFALSE;
@@ -133,16 +137,13 @@ Bool_t CbmDeviceMcbmUnpack::InitContainers() {
   fUnpAlgoPsd->SetIgnoreOverlapMs(fbIgnoreOverlapMs);
 
   /// Load time offsets
-  for (std::vector<std::string>::iterator itStrOffs = fvsSetTimeOffs.begin();
-       itStrOffs != fvsSetTimeOffs.end();
+  for (std::vector<std::string>::iterator itStrOffs = fvsSetTimeOffs.begin(); itStrOffs != fvsSetTimeOffs.end();
        ++itStrOffs) {
     size_t charPosDel = (*itStrOffs).find(',');
     if (std::string::npos == charPosDel) {
-      LOG(info)
-        << "CbmDeviceMcbmUnpack::InitContainers => "
-        << "Trying to set trigger window with invalid option pattern, ignored! "
-        << " (Should be ECbmModuleId,dWinBeg,dWinEnd but instead found "
-        << (*itStrOffs) << " )";
+      LOG(info) << "CbmDeviceMcbmUnpack::InitContainers => "
+                << "Trying to set trigger window with invalid option pattern, ignored! "
+                << " (Should be ECbmModuleId,dWinBeg,dWinEnd but instead found " << (*itStrOffs) << " )";
     }  // if( std::string::npos == charPosDel )
 
     /// Detector Enum Tag
@@ -151,9 +152,7 @@ Bool_t CbmDeviceMcbmUnpack::InitContainers() {
     charPosDel++;
     Double_t dOffset = std::stod((*itStrOffs).substr(charPosDel));
 
-    if ("kSTS" == sSelDet) {
-      fUnpAlgoSts->SetTimeOffsetNs(dOffset);
-    }  // if( "kSTS"  == sSelDet )
+    if ("kSTS" == sSelDet) { fUnpAlgoSts->SetTimeOffsetNs(dOffset); }  // if( "kSTS"  == sSelDet )
     else if ("kMUCH" == sSelDet) {
       fUnpAlgoMuch->SetTimeOffsetNs(dOffset);
     }  // else if( "kMUCH" == sSelDet )
@@ -199,7 +198,8 @@ Bool_t CbmDeviceMcbmUnpack::InitContainers() {
   return initOK;
 }
 
-Bool_t CbmDeviceMcbmUnpack::InitParameters(TList* fParCList) {
+Bool_t CbmDeviceMcbmUnpack::InitParameters(TList* fParCList)
+{
   for (int iparC = 0; iparC < fParCList->GetEntries(); iparC++) {
     FairParGenericSet* tempObj = (FairParGenericSet*) (fParCList->At(iparC));
     fParCList->Remove(tempObj);
@@ -209,8 +209,7 @@ Bool_t CbmDeviceMcbmUnpack::InitParameters(TList* fParCList) {
 
     // Her must come the proper Runid
     std::string message = paramName + ",111";
-    LOG(info) << "Requesting parameter container " << paramName
-              << ", sending message: " << message;
+    LOG(info) << "Requesting parameter container " << paramName << ", sending message: " << message;
 
     FairMQMessagePtr req(NewSimpleMessage(message));
     FairMQMessagePtr rep(NewMessage());
@@ -220,9 +219,8 @@ Bool_t CbmDeviceMcbmUnpack::InitParameters(TList* fParCList) {
     if (Send(req, "parameters") > 0) {
       if (Receive(rep, "parameters") >= 0) {
         if (0 != rep->GetSize()) {
-          CbmMQTMessage tmsg(rep->GetData(), rep->GetSize());
-          newObj =
-            static_cast<FairParGenericSet*>(tmsg.ReadObject(tmsg.GetClass()));
+          CbmMqTMessage tmsg(rep->GetData(), rep->GetSize());
+          newObj = static_cast<FairParGenericSet*>(tmsg.ReadObject(tmsg.GetClass()));
           LOG(info) << "Received unpack parameter from the server:";
           newObj->print();
         }  // if( 0 !=  rep->GetSize() )
@@ -240,13 +238,12 @@ Bool_t CbmDeviceMcbmUnpack::InitParameters(TList* fParCList) {
 }
 
 // handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)
-bool CbmDeviceMcbmUnpack::HandleData(FairMQMessagePtr& msg, int /*index*/) {
+bool CbmDeviceMcbmUnpack::HandleData(FairMQMessagePtr& msg, int /*index*/)
+{
   fulNumMessages++;
-  LOG(debug) << "Received message number " << fulNumMessages << " with size "
-             << msg->GetSize();
+  LOG(debug) << "Received message number " << fulNumMessages << " with size " << msg->GetSize();
 
-  if (0 == fulNumMessages % 10000)
-    LOG(info) << "Received " << fulNumMessages << " messages";
+  if (0 == fulNumMessages % 10000) LOG(info) << "Received " << fulNumMessages << " messages";
 
   std::string msgStr(static_cast<char*>(msg->GetData()), msg->GetSize());
   std::istringstream iss(msgStr);
@@ -263,14 +260,12 @@ bool CbmDeviceMcbmUnpack::HandleData(FairMQMessagePtr& msg, int /*index*/) {
     fdTsCoreSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs);
     fdTsOverSizeInNs = fdMsSizeInNs * (fuNbOverMsPerTs);
     fdTsFullSizeInNs = fdTsCoreSizeInNs + fdTsOverSizeInNs;
-    LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs
-              << " Core MS and " << fuNbOverMsPerTs
-              << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs
-              << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
+    LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs << " Core MS and " << fuNbOverMsPerTs
+              << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs << " ns and a full duration of "
+              << fdTsFullSizeInNs << " ns";
   }  // if( -1.0 == fdTsCoreSizeInNs )
 
-  fTsMetaData = new TimesliceMetaData(
-    ts.descriptor(0, 0).idx, fdTsCoreSizeInNs, fdTsOverSizeInNs, ts.index());
+  fTsMetaData = new TimesliceMetaData(ts.descriptor(0, 0).idx, fdTsCoreSizeInNs, fdTsOverSizeInNs, ts.index());
 
   /// Process the Timeslice
   DoUnpack(ts, 0);
@@ -299,7 +294,8 @@ bool CbmDeviceMcbmUnpack::HandleData(FairMQMessagePtr& msg, int /*index*/) {
   return true;
 }
 
-bool CbmDeviceMcbmUnpack::SendUnpData() {
+bool CbmDeviceMcbmUnpack::SendUnpData()
+{
 
   /// Prepare serialized versions of the TS Meta
   /*
@@ -309,7 +305,8 @@ bool CbmDeviceMcbmUnpack::SendUnpData() {
    std::string* strMsgTsMetaE = new std::string(ossTsMeta.str());
 */
   FairMQMessagePtr messTsMeta(NewMessage());
-  Serialize<RootSerializer>(*messTsMeta, fTsMetaData);
+  //  Serialize<RootSerializer>(*messTsMeta, fTsMetaData);
+  RootSerializer().Serialize(*messTsMeta, fTsMetaData);
 
   std::stringstream ossSts;
   boost::archive::binary_oarchive oaSts(ossSts);
@@ -326,20 +323,20 @@ bool CbmDeviceMcbmUnpack::SendUnpData() {
   oaTrd << fUnpAlgoTrd->GetVector();
   std::string* strMsgTrd = new std::string(ossTrd.str());
 
-  /// Split TOF vector in TOF and T0
-  std::vector<CbmTofDigi>& vDigiTofT0 = fUnpAlgoTof->GetVector();
+  /// Split TOF vector in TOF and Bmon
+  std::vector<CbmTofDigi>& vDigiTofBmon = fUnpAlgoTof->GetVector();
   std::vector<CbmTofDigi> vDigiTof    = {};
-  std::vector<CbmTofDigi> vDigiT0     = {};
+  std::vector<CbmTofDigi> vDigiBmon     = {};
 
-  for (auto digi : vDigiTofT0) {
-    if (fuDigiMaskedIdT0 == (digi.GetAddress() & fuDigiMaskId)) {
-      /// Insert data in T0 output container
-      vDigiT0.emplace_back(digi);
-    }  // if( fuDigiMaskedIdT0 == ( digi.GetAddress() & fuDigiMaskId ) )
+  for (auto digi : vDigiTofBmon) {
+    if (fuDigiMaskedIdBmon == (digi.GetAddress() & fuDigiMaskId)) {
+      /// Insert data in Bmon output container
+      vDigiBmon.emplace_back(digi);
+    }  // if( fuDigiMaskedIdBmon == ( digi.GetAddress() & fuDigiMaskId ) )
     else {
       /// Insert data in TOF output container
       vDigiTof.emplace_back(digi);
-    }  // else of if( fuDigiMaskedIdT0 == ( digi.GetAddress() & fuDigiMaskId ) )
+    }  // else of if( fuDigiMaskedIdBmon == ( digi.GetAddress() & fuDigiMaskId ) )
   }    // for( auto digi: vDigi )
 
   std::stringstream ossTof;
@@ -347,10 +344,10 @@ bool CbmDeviceMcbmUnpack::SendUnpData() {
   oaTof << vDigiTof;
   std::string* strMsgTof = new std::string(ossTof.str());
 
-  std::stringstream ossT0;
-  boost::archive::binary_oarchive oaT0(ossT0);
-  oaT0 << vDigiT0;
-  std::string* strMsgT0 = new std::string(ossT0.str());
+  std::stringstream ossBmon;
+  boost::archive::binary_oarchive oaBmon(ossBmon);
+  oaBmon << vDigiBmon;
+  std::string* strMsgBmon = new std::string(ossBmon.str());
 
   std::stringstream ossRich;
   boost::archive::binary_oarchive oaRich(ossRich);
@@ -375,10 +372,10 @@ bool CbmDeviceMcbmUnpack::SendUnpData() {
 */
 
   parts.AddPart(NewMessage(
-    const_cast<char*>(strMsgT0->c_str()),  // data
-    strMsgT0->length(),                    // size
+    const_cast<char*>(strMsgBmon->c_str()),  // data
+    strMsgBmon->length(),                    // size
     [](void*, void* object) { delete static_cast<std::string*>(object); },
-    strMsgT0));  // object that manages the data
+    strMsgBmon));  // object that manages the data
 
   parts.AddPart(NewMessage(
     const_cast<char*>(strMsgSts->c_str()),  // data
@@ -425,7 +422,8 @@ bool CbmDeviceMcbmUnpack::SendUnpData() {
 }
 
 
-CbmDeviceMcbmUnpack::~CbmDeviceMcbmUnpack() {
+CbmDeviceMcbmUnpack::~CbmDeviceMcbmUnpack()
+{
   if (nullptr != fUnpAlgoSts) delete fUnpAlgoSts;
   if (nullptr != fUnpAlgoMuch) delete fUnpAlgoMuch;
   if (nullptr != fUnpAlgoTrd) delete fUnpAlgoTrd;
@@ -435,8 +433,8 @@ CbmDeviceMcbmUnpack::~CbmDeviceMcbmUnpack() {
 }
 
 
-Bool_t CbmDeviceMcbmUnpack::DoUnpack(const fles::Timeslice& ts,
-                                     size_t /*component*/) {
+Bool_t CbmDeviceMcbmUnpack::DoUnpack(const fles::Timeslice& ts, size_t /*component*/)
+{
   fulTsCounter++;
 
   if (kFALSE == fbComponentsAddedToList) {
@@ -458,10 +456,10 @@ Bool_t CbmDeviceMcbmUnpack::DoUnpack(const fles::Timeslice& ts,
           fUnpAlgoTof->AddMsComponentToList(uCompIdx, kusSysIdTof);
           break;
         }  // case kusSysIdTof
-        case kusSysIdT0: {
-          fUnpAlgoTof->AddMsComponentToList(uCompIdx, kusSysIdT0);
+        case kusSysIdBmon: {
+          fUnpAlgoTof->AddMsComponentToList(uCompIdx, kusSysIdBmon);
           break;
-        }  // case kusSysIdT0
+        }  // case kusSysIdBmon
         case kusSysIdRich: {
           fUnpAlgoRich->AddMsComponentToList(uCompIdx, kusSysIdRich);
           break;
@@ -477,44 +475,37 @@ Bool_t CbmDeviceMcbmUnpack::DoUnpack(const fles::Timeslice& ts,
   }  // if( kFALSE == fbComponentsAddedToList )
 
   if (kFALSE == fUnpAlgoSts->ProcessTs(ts)) {
-    LOG(error) << "Failed processing TS " << ts.index()
-               << " in STS unpacker algorithm class";
-    return kTRUE;
+    LOG(error) << "Failed processing TS " << ts.index() << " in STS unpacker algorithm class";
+    return kFALSE;
   }  // if( kFALSE == fUnpAlgoSts->ProcessTs( ts ) )
 
   if (kFALSE == fUnpAlgoMuch->ProcessTs(ts)) {
-    LOG(error) << "Failed processing TS " << ts.index()
-               << " in MUCH unpacker algorithm class";
-    return kTRUE;
+    LOG(error) << "Failed processing TS " << ts.index() << " in MUCH unpacker algorithm class";
+    return kFALSE;
   }  // if( kFALSE == fUnpAlgoMuch->ProcessTs( ts ) )
 
   if (kFALSE == fUnpAlgoTrd->ProcessTs(ts)) {
-    LOG(error) << "Failed processing TS " << ts.index()
-               << " in TRD unpacker algorithm class";
-    return kTRUE;
+    LOG(error) << "Failed processing TS " << ts.index() << " in TRD unpacker algorithm class";
+    return kFALSE;
   }  // if( kFALSE == fUnpAlgoTrd->ProcessTs( ts ) )
 
   if (kFALSE == fUnpAlgoTof->ProcessTs(ts)) {
-    LOG(error) << "Failed processing TS " << ts.index()
-               << " in TOF unpacker algorithm class";
-    return kTRUE;
+    LOG(error) << "Failed processing TS " << ts.index() << " in TOF unpacker algorithm class";
+    return kFALSE;
   }  // if( kFALSE == fUnpAlgoTof->ProcessTs( ts ) )
 
   if (kFALSE == fUnpAlgoRich->ProcessTs(ts)) {
-    LOG(error) << "Failed processing TS " << ts.index()
-               << " in RICH unpacker algorithm class";
-    return kTRUE;
+    LOG(error) << "Failed processing TS " << ts.index() << " in RICH unpacker algorithm class";
+    return kFALSE;
   }  // if( kFALSE == fUnpAlgoRich->ProcessTs( ts ) )
 
   if (kFALSE == fUnpAlgoPsd->ProcessTs(ts)) {
-    LOG(error) << "Failed processing TS " << ts.index()
-               << " in PSD unpacker algorithm class";
-    return kTRUE;
+    LOG(error) << "Failed processing TS " << ts.index() << " in PSD unpacker algorithm class";
+    return kFALSE;
   }  // if( kFALSE == fUnpAlgoPsd->ProcessTs( ts ) )
 
 
-  if (0 == fulTsCounter % 10000)
-    LOG(info) << "Processed " << fulTsCounter << " time slices";
+  if (0 == fulTsCounter % 10000) LOG(info) << "Processed " << fulTsCounter << " time slices";
 
   return kTRUE;
 }

MQ/mcbm/CbmDeviceMcbmUnpack.h

+/* Copyright (C) 2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
 /**
  * CbmDeviceMcbmUnpack.h
  *
@@ -8,12 +12,13 @@
 #ifndef CBMDEVICEMCBMUNPACK_H_
 #define CBMDEVICEMCBMUNPACK_H_
 
-#include "FairMQDevice.h"
+#include "CbmMqTMessage.h"
 
 #include "Timeslice.hpp"
 
+#include "FairMQDevice.h"
+
 #include "Rtypes.h"
-#include "TMessage.h"
 #include "TObjArray.h"
 
 #include <map>
@@ -44,20 +49,19 @@ private:
   static const uint16_t kusSysIdMuch = 0x50;
   static const uint16_t kusSysIdTrd  = 0x40;
   static const uint16_t kusSysIdTof  = 0x60;
-  static const uint16_t kusSysIdT0   = 0x90;
+  static const uint16_t kusSysIdBmon = 0x90;
   static const uint16_t kusSysIdRich = 0x30;
   static const uint16_t kusSysIdPsd  = 0x80;
 
   /// Control flags
-  Bool_t fbIgnoreOverlapMs =
-    false;  //! Ignore Overlap Ms: all fuOverlapMsNb MS at the end of timeslice
+  Bool_t fbIgnoreOverlapMs       = false;  //! Ignore Overlap Ms: all fuOverlapMsNb MS at the end of timeslice
   Bool_t fbComponentsAddedToList = kFALSE;
 
   /// User settings parameters
   std::string fsChannelNameDataInput  = "fullts";
   std::string fsChannelNameDataOutput = "unpts_0";
   std::string fsChannelNameCommands   = "commands";
-  UInt_t fuDigiMaskedIdT0             = 0x00005006;
+  UInt_t fuDigiMaskedIdBmon           = 0x00005006;
   UInt_t fuDigiMaskId                 = 0x0001FFFF;
 
   /// List of MQ channels names
@@ -83,15 +87,12 @@ private:
   std::vector<std::string> fvsSetTimeOffs = {};
 
   /// TS MetaData storage
-  size_t fuNbCoreMsPerTs = 0;        //!
-  size_t fuNbOverMsPerTs = 0;        //!
-  Double_t fdMsSizeInNs  = 1280000;  //! Size of a single MS, [nanoseconds]
-  Double_t fdTsCoreSizeInNs =
-    -1.0;  //! Total size of the core MS in a TS, [nanoseconds]
-  Double_t fdTsOverSizeInNs =
-    -1.0;  //! Total size of the overlap MS in a TS, [nanoseconds]
-  Double_t fdTsFullSizeInNs =
-    -1.0;  //! Total size of all MS in a TS, [nanoseconds]
+  size_t fuNbCoreMsPerTs    = 0;        //!
+  size_t fuNbOverMsPerTs    = 0;        //!
+  Double_t fdMsSizeInNs     = 1280000;  //! Size of a single MS, [nanoseconds]
+  Double_t fdTsCoreSizeInNs = -1.0;     //! Total size of the core MS in a TS, [nanoseconds]
+  Double_t fdTsOverSizeInNs = -1.0;     //! Total size of the overlap MS in a TS, [nanoseconds]
+  Double_t fdTsFullSizeInNs = -1.0;     //! Total size of all MS in a TS, [nanoseconds]
   TimesliceMetaData* fTsMetaData;
 
   bool IsChannelNameAllowed(std::string channelName);
@@ -101,13 +102,4 @@ private:
   bool SendUnpData();
 };
 
-// special class to expose protected TMessage constructor
-class CbmMQTMessage : public TMessage {
-public:
-  CbmMQTMessage(void* buf, Int_t len) : TMessage(buf, len) {
-    ResetBit(kIsOwner);
-  }
-};
-
-
 #endif /* CBMDEVICEMCBMUNPACK_H_ */

MQ/mcbm/CbmDeviceUnpack.cxx

+/* Copyright (C) 2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
+/**
+ * CbmDeviceUnpack.cxx
+ *
+ * @since 2020-05-04
+ * @author P.-A. Loizeau
+ */
+
+#include "CbmDeviceUnpack.h"
+
+#include "CbmBmonUnpackConfig.h"
+#include "CbmFlesCanvasTools.h"
+#include "CbmMQDefs.h"
+#include "CbmMuchUnpackConfig.h"
+#include "CbmPsdUnpackConfig.h"
+#include "CbmRichUnpackConfig.h"
+#include "CbmSetup.h"
+#include "CbmStsUnpackConfig.h"
+#include "CbmTofUnpackConfig.h"
+#include "CbmTrdUnpackConfig.h"
+#include "CbmTrdUnpackFaspConfig.h"
+
+#include "StorableTimeslice.hpp"
+#include "TimesliceMetaData.h"
+
+#include "FairMQLogger.h"
+#include "FairMQProgOptions.h"  // device->fConfig
+#include "FairParGenericSet.h"
+
+#include "TCanvas.h"
+#include "TFile.h"
+#include "TH1.h"
+#include "TList.h"
+#include "TNamed.h"
+
+#include "BoostSerializer.h"
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/serialization/utility.hpp>
+
+#include <array>
+#include <iomanip>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include "RootSerializer.h"
+struct InitTaskError : std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+using namespace std;
+
+//Bool_t bMcbm2018MonitorTaskBmonResetHistos = kFALSE;
+
+CbmDeviceUnpack::CbmDeviceUnpack() {}
+
+void CbmDeviceUnpack::InitTask()
+try {
+  /// Read options from executable
+  LOG(info) << "Init options for CbmDeviceUnpack.";
+  fsSetupName              = fConfig->GetValue<std::string>("Setup");
+  fuRunId                  = fConfig->GetValue<uint32_t>("RunId");
+  fbUnpBmon                = fConfig->GetValue<bool>("UnpBmon");
+  fbUnpSts                 = fConfig->GetValue<bool>("UnpSts");
+  fbUnpMuch                = fConfig->GetValue<bool>("UnpMuch");
+  fbUnpTrd1D               = fConfig->GetValue<bool>("UnpTrd1d");
+  fbUnpTrd2D               = fConfig->GetValue<bool>("UnpTrd2d");
+  fbUnpTof                 = fConfig->GetValue<bool>("UnpTof");
+  fbUnpRich                = fConfig->GetValue<bool>("UnpRich");
+  fbUnpPsd                 = fConfig->GetValue<bool>("UnpPsd");
+  fbIgnoreOverlapMs        = fConfig->GetValue<bool>("IgnOverMs");
+  fbOutputFullTimeSorting  = fConfig->GetValue<bool>("FullTimeSort");
+  fvsSetTimeOffs           = fConfig->GetValue<std::vector<std::string>>("SetTimeOffs");
+  fsChannelNameDataInput   = fConfig->GetValue<std::string>("TsNameIn");
+  fsChannelNameDataOutput  = fConfig->GetValue<std::string>("TsNameOut");
+  fuPublishFreqTs          = fConfig->GetValue<uint32_t>("PubFreqTs");
+  fdMinPublishTime         = fConfig->GetValue<double_t>("PubTimeMin");
+  fdMaxPublishTime         = fConfig->GetValue<double_t>("PubTimeMax");
+  fsChannelNameHistosInput = fConfig->GetValue<std::string>("ChNameIn");
+}
+catch (InitTaskError& e) {
+  LOG(error) << e.what();
+  // Wrapper defined in CbmMQDefs.h to support different FairMQ versions
+  cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
+}
+
+Bool_t CbmDeviceUnpack::InitContainers()
+{
+  LOG(info) << "Init parameter containers for CbmDeviceUnpack.";
+
+  // ----- FIXME: Environment settings? or binary option?
+  TString srcDir = std::getenv("VMCWORKDIR");  // top source directory, standard C++ library
+  //  TString srcDir = gSystem->Getenv("VMCWORKDIR");  // top source directory
+
+  // -----   CbmSetup   -----------------------------------------------------
+  // TODO: support for multiple setups on Par Server? with request containing setup name?
+  CbmSetup* cbmsetup = CbmSetup::Instance();
+  FairMQMessagePtr req(NewSimpleMessage("setup"));
+  FairMQMessagePtr rep(NewMessage());
+
+  if (Send(req, "parameters") > 0) {
+    if (Receive(rep, "parameters") >= 0) {
+      if (0 != rep->GetSize()) {
+        CbmSetupStorable* exchangableSetup;
+
+        CbmMqTMessage tmsg(rep->GetData(), rep->GetSize());
+        exchangableSetup = dynamic_cast<CbmSetupStorable*>(tmsg.ReadObject(tmsg.GetClass()));
+
+        if (nullptr != exchangableSetup) {
+          /// Prevent clang format single line if
+          cbmsetup->LoadStoredSetup(exchangableSetup);
+        }
+        else {
+          LOG(error) << "Received corrupt reply. Setup not available";
+          throw InitTaskError("Setup not received from par-server.");
+        }
+      }  // if( 0 !=  rep->GetSize() )
+      else {
+        LOG(error) << "Received empty reply. Setup not available";
+        throw InitTaskError("Setup not received from par-server.");
+      }  // else of if( 0 !=  rep->GetSize() )
+    }    // if( Receive( rep, "parameters" ) >= 0)
+  }      // if( Send(req, "parameters") > 0 )
+  // ------------------------------------------------------------------------
+
+  /// Initialize the UnpackerConfigs objects and their "user options"
+  // ---- BMON ----
+  std::shared_ptr<CbmBmonUnpackConfig> bmonconfig = nullptr;
+  if (fbUnpBmon) {
+    bmonconfig = std::make_shared<CbmBmonUnpackConfig>("", fuRunId);
+    if (bmonconfig) {
+      // bmonconfig->SetDebugState();
+      bmonconfig->SetDoWriteOutput();
+      // bmonconfig->SetDoWriteOptOutA("CbmBmonErrors");
+      std::string parfilesbasepathBmon = Form("%s/macro/beamtime/mcbm2022/", srcDir.Data());
+      bmonconfig->SetParFilesBasePath(parfilesbasepathBmon);
+      bmonconfig->SetParFileName("mBmonCriPar.par");
+      bmonconfig->SetSystemTimeOffset(-1220);  // [ns] value to be updated
+      if (2160 <= fuRunId) {
+        bmonconfig->SetSystemTimeOffset(-80);  // [ns] value to be updated
+      }
+      if (2350 <= fuRunId) {
+        bmonconfig->SetSystemTimeOffset(0);  // [ns] value to be updated
+      }
+      /// Enable Monitor plots
+      // bmonconfig->SetMonitor(GetTofMonitor(outfilename, true));  // FIXME: Unsupported for now
+    }
+  }
+  // -------------
+  // ---- STS ----
+  std::shared_ptr<CbmStsUnpackConfig> stsconfig = nullptr;
+  TString stsSetupTag                           = "";
+  cbmsetup->GetGeoTag(ECbmModuleId::kSts, stsSetupTag);
+  if ("" != stsSetupTag && fbUnpSts) {
+    LOG(info) << "From received setup, using STS tag: " << stsSetupTag;
+    stsconfig = std::make_shared<CbmStsUnpackConfig>(std::string(fsSetupName), fuRunId);
+    if (stsconfig) {
+      // stsconfig->SetDebugState();
+      stsconfig->SetDoWriteOutput();
+      stsconfig->SetDoWriteOptOutA("StsDigiPulser");
+      std::string parfilesbasepathSts = Form("%s/macro/beamtime/mcbm2021/", srcDir.Data());
+      if (2060 <= fuRunId) {
+        /// Starting to readout the U3 since 10/03/2022 Carbon run
+        parfilesbasepathSts = Form("%s/macro/beamtime/mcbm2022/", srcDir.Data());
+      }
+      stsconfig->SetParFilesBasePath(parfilesbasepathSts);
+      /// Enable duplicates rejection, Ignores the ADC for duplicates check
+      stsconfig->SetDuplicatesRejection(true, true);
+      /// Enable Monitor plots
+      //      stsconfig->SetMonitor(GetStsMonitor(outfilename, true)); // FIXME: Unsupported for now
+      stsconfig->SetSystemTimeOffset(-2221);  // [ns] value to be updated
+      if (2160 <= fuRunId) {
+        stsconfig->SetSystemTimeOffset(-1075);  // [ns] value to be updated
+      }
+      if (2350 <= fuRunId) {
+        stsconfig->SetSystemTimeOffset(-970);  // [ns] value to be updated
+      }
+
+      stsconfig->SetMinAdcCut(1, 1);
+      stsconfig->SetMinAdcCut(2, 1);
+      stsconfig->SetMinAdcCut(3, 1);
+      stsconfig->SetMinAdcCut(4, 1);
+
+      stsconfig->MaskNoisyChannel(3, 56);
+      stsconfig->MaskNoisyChannel(3, 75);
+      stsconfig->MaskNoisyChannel(3, 79);
+      stsconfig->MaskNoisyChannel(3, 85);
+      stsconfig->MaskNoisyChannel(7, 123);
+      stsconfig->MaskNoisyChannel(7, 124);
+      stsconfig->MaskNoisyChannel(7, 125);
+      stsconfig->MaskNoisyChannel(7, 158);
+      stsconfig->MaskNoisyChannel(7, 159);
+      stsconfig->MaskNoisyChannel(7, 162);
+      stsconfig->MaskNoisyChannel(7, 715);
+      stsconfig->MaskNoisyChannel(9, 709);
+      stsconfig->MaskNoisyChannel(12, 119);
+
+      // Time Walk correction
+      std::map<uint32_t, CbmStsParModule> walkMap;
+      auto parAsic = new CbmStsParAsic(128, 31, 31., 1., 5., 800., 1000., 3.9789e-3);
+
+      // Module params: number of channels, number of channels per ASIC
+      auto parMod = new CbmStsParModule(2048, 128);
+
+      // default
+      double p0 = 0, p1 = 0, p2 = 0, p3 = 0;
+      parAsic->SetWalkCoef({p0, p1, p2, p3});
+      parMod->SetAllAsics(*parAsic);
+
+      walkMap[0x10107C02] = CbmStsParModule(*parMod);  // Make a copy for storage
+      walkMap[0x101FFC02] = CbmStsParModule(*parMod);  // Make a copy for storage
+
+      /// To be replaced by a storage in a new parameter class later
+      int sensor, asic;
+      std::ifstream asicTimeWalk_par(Form("%s/mStsAsicTimeWalk.par", parfilesbasepathSts.data()));
+      while (asicTimeWalk_par >> std::hex >> sensor >> std::dec >> asic >> p0 >> p1 >> p2 >> p3) {
+        std::cout << Form("Setting time-walk parametersfor: module %x, ASIC %u\n", sensor, asic);
+        parAsic->SetWalkCoef({p0, p1, p2, p3});
+
+        if (walkMap.find(sensor) == walkMap.end()) { walkMap[sensor] = CbmStsParModule(*parMod); }
+        walkMap[sensor].SetAsic(asic, *parAsic);
+      }
+
+      stsconfig->SetWalkMap(walkMap);
+    }
+  }  // if ("" != stsSetupTag)
+  // -------------
+  // ---- MUCH ----
+  std::shared_ptr<CbmMuchUnpackConfig> muchconfig = nullptr;
+  TString muchSetupTag                            = "";
+  cbmsetup->GetGeoTag(ECbmModuleId::kMuch, muchSetupTag);
+  if ("" != muchSetupTag && fbUnpMuch) {
+    LOG(info) << "From received setup, using MUCH tag: " << muchSetupTag;
+
+    muchconfig = std::make_shared<CbmMuchUnpackConfig>(std::string(fsSetupName), fuRunId);
+    if (muchconfig) {
+      // muchconfig->SetDebugState();
+      muchconfig->SetDoWriteOutput();
+      muchconfig->SetDoWriteOptOutA("MuchDigiPulser");
+      std::string parfilesbasepathMuch = Form("%s/macro/beamtime/mcbm2022/", srcDir.Data());
+      muchconfig->SetParFilesBasePath(parfilesbasepathMuch);
+      if (2060 <= fuRunId && fuRunId <= 2162) {
+        /// Starting to use CRI Based MUCH setup with 2GEM and 1 RPC since 09/03/2022 Carbon run
+        muchconfig->SetParFileName("mMuchParUpto26032022.par");
+      }
+      else if (2163 <= fuRunId && fuRunId <= 2291) {
+        /// First nickel runs
+        muchconfig->SetParFileName("mMuchParUpto03042022.par");
+      }
+      else if (2311 <= fuRunId && fuRunId <= 2315) {
+        ///
+        muchconfig->SetParFileName("mMuchParUpto10042022.par");
+      }
+      else if (2316 <= fuRunId && fuRunId <= 2366) {
+        ///
+        muchconfig->SetParFileName("mMuchParUpto23052022.par");
+      }
+      else if (2367 <= fuRunId && fuRunId <= 2397) {
+        /// Starting to use GEM 2 moved to CRI 0 on 24/05/2022
+        muchconfig->SetParFileName("mMuchParUpto26052022.par");
+      }
+
+      /// Enable duplicates rejection, Ignores the ADC for duplicates check
+      muchconfig->SetDuplicatesRejection(true, true);
+      /// Enable Monitor plots
+      //muchconfig->SetMonitor(GetMuchMonitor(outfilename, true));
+      muchconfig->SetSystemTimeOffset(-2221);  // [ns] value to be updated
+      if (2160 <= fuRunId) {
+        muchconfig->SetSystemTimeOffset(-1020);  // [ns] value to be updated
+      }
+      if (2350 <= fuRunId) {
+        muchconfig->SetSystemTimeOffset(-980);  // [ns] value to be updated
+      }
+
+      // muchconfig->SetMinAdcCut(1, 1);
+
+      // muchconfig->MaskNoisyChannel(3, 56);
+    }
+  }
+  // -------------
+  // ---- TRD ----
+  std::shared_ptr<CbmTrdUnpackConfig> trd1Dconfig = nullptr;
+  TString trdsetuptag                             = "";
+  cbmsetup->GetGeoTag(ECbmModuleId::kTrd, trdsetuptag);
+  if ("" != trdsetuptag && fbUnpTrd1D) {
+    LOG(info) << "From received setup, using TRD tag: " << trdsetuptag;
+    // trd1Dconfig = std::make_shared<CbmTrdUnpackConfig>(trdsetuptag.Data(), fuRunId);
+    trd1Dconfig = std::make_shared<CbmTrdUnpackConfig>(trdsetuptag.Data(), 3);
+    if (trd1Dconfig) {
+      trd1Dconfig->SetDoWriteOutput();
+      // Activate the line below to write Trd1D digis to a separate "TrdSpadicDigi" branch. Can be used to separate between Fasp and Spadic digis
+      // trd1Dconfig->SetOutputBranchName("TrdSpadicDigi");
+      // trd1Dconfig->SetDoWriteOptOutA(CbmTrdRawMessageSpadic::GetBranchName());
+      // trd1Dconfig->SetDoWriteOptOutB("SpadicInfoMessages"); // SpadicInfoMessages
+
+      std::string parfilesbasepathTrd = Form("%s/parameters/trd", srcDir.Data());
+      trd1Dconfig->SetParFilesBasePath(parfilesbasepathTrd);
+      // trd1Dconfig->SetMonitor(GetTrdMonitor(outfilename));  // FIXME: Unsupported for now
+      // Get the spadic configuration true = avg baseline active / false plain sample 0
+      trd1Dconfig->SetSpadicObject(GetTrdSpadic(true));
+      trd1Dconfig->SetSystemTimeOffset(0);  // [ns] value to be updated
+      if (2160 <= fuRunId) {
+        trd1Dconfig->SetSystemTimeOffset(1140);  // [ns] value to be updated
+      }
+      if (2350 <= fuRunId) {
+        trd1Dconfig->SetSystemTimeOffset(1300);  // [ns] value to be updated
+      }
+    }
+  }  // if ("" != trdsetuptag)
+  // -------------
+  // ---- TRDFASP2D ----
+  std::shared_ptr<CbmTrdUnpackFaspConfig> trdfasp2dconfig = nullptr;
+  if ("" != trdsetuptag && fbUnpTrd2D) {
+    trdfasp2dconfig = std::make_shared<CbmTrdUnpackFaspConfig>(trdsetuptag.Data());
+    if (trdfasp2dconfig) {
+      // trdfasp2dconfig->SetDebugState();
+      trdfasp2dconfig->SetDoWriteOutput();
+      // Activate the line below to write Trd1D digis to a separate "TrdFaspDigi" branch. Can be used to separate between Fasp and Spadic digis
+      //trdfasp2dconfig->SetOutputBranchName("TrdFaspDigi");
+      //   uint16_t crob_map[NCROBMOD];
+      //   if (fuRunId <= 1588) {
+      //     uint16_t crob_map21[] = {0x00f0, 0, 0, 0, 0};
+      //     for (uint32_t i(0); i < NCROBMOD; i++)
+      //       crob_map[i] = crob_map21[i];
+      //   }
+      //   else if (fuRunId >= 2335) {
+      //     uint16_t crob_map22[] = {0xffc2, 0xffc5, 0xffc1, 0, 0};
+      //     for (uint32_t i(0); i < NCROBMOD; i++)
+      //       crob_map[i] = crob_map22[i];
+      //   }
+      //   trdfasp2dconfig->SetCrobMapping(5, crob_map);
+      std::string parfilesbasepathTrdfasp2d = Form("%s/parameters/trd", srcDir.Data());
+      trdfasp2dconfig->SetParFilesBasePath(parfilesbasepathTrdfasp2d);
+      trdfasp2dconfig->SetSystemTimeOffset(-1800);  // [ns] value to be updated
+      if (2160 <= fuRunId) {
+        trdfasp2dconfig->SetSystemTimeOffset(-570);  // [ns] value to be updated
+      }
+      if (2350 <= fuRunId) {
+        trdfasp2dconfig->SetSystemTimeOffset(-510);  // [ns] value to be updated
+      }
+    }
+  }  // if ("" != trdsetuptag)
+  // -------------
+  // ---- TOF ----
+  std::shared_ptr<CbmTofUnpackConfig> tofconfig = nullptr;
+  TString tofSetupTag                           = "";
+  cbmsetup->GetGeoTag(ECbmModuleId::kTof, tofSetupTag);
+  if ("" != tofSetupTag && fbUnpTof) {
+    LOG(info) << "From received setup, using TOF tag: " << tofSetupTag;
+    tofconfig = std::make_shared<CbmTofUnpackConfig>("", fuRunId);
+    if (tofconfig) {
+      // tofconfig->SetDebugState();
+      tofconfig->SetDoWriteOutput();
+      // tofconfig->SetDoWriteOptOutA("CbmTofErrors");
+      std::string parfilesbasepathTof = Form("%s/macro/beamtime/mcbm2021/", srcDir.Data());
+      std::string parFileNameTof      = "mTofCriPar.par";
+      if (2060 <= fuRunId) {
+        /// Additional modules added just before the 10/03/2022 Carbon run
+        parfilesbasepathTof = Form("%s/macro/beamtime/mcbm2022/", srcDir.Data());
+        /// Setup changed multiple times between the 2022 carbon and uranium runs
+        if (fuRunId <= 2065) {
+          /// Carbon runs: 2060 - 2065
+          parFileNameTof = "mTofCriParCarbon.par";
+        }
+        else if (2150 <= fuRunId && fuRunId <= 2160) {
+          /// Iron runs: 2150 - 2160
+          parFileNameTof = "mTofCriParIron.par";
+        }
+        else if (2176 <= fuRunId && fuRunId <= 2310) {
+          /// Uranium runs: 2176 - 2310
+          parFileNameTof = "mTofCriParUranium.par";
+        }
+        else if (2335 <= fuRunId && fuRunId <= 2497) {
+          /// Nickel runs: 2335 - 2397
+          /// Gold runs: 2400 - 2497
+          parFileNameTof = "mTofCriParNickel.par";
+        }
+        else {
+          parFileNameTof = "mTofCriPar.par";
+        }
+      }
+      tofconfig->SetParFilesBasePath(parfilesbasepathTof);
+      tofconfig->SetParFileName(parFileNameTof);
+      tofconfig->SetSystemTimeOffset(-1220);  // [ns] value to be updated
+      if (2160 <= fuRunId) {
+        tofconfig->SetSystemTimeOffset(0);  // [ns] value to be updated
+      }
+      if (2350 <= fuRunId) {
+        tofconfig->SetSystemTimeOffset(45);  // [ns] value to be updated
+      }
+      if (fuRunId <= 1659) {
+        /// Switch ON the -4 offset in epoch count (hack for Spring-Summer 2021)
+        tofconfig->SetFlagEpochCountHack2021();
+      }
+    }
+  }  // if ("" != tofSetupTag)
+  // -------------
+  // ---- RICH ----
+  std::shared_ptr<CbmRichUnpackConfig> richconfig = nullptr;
+  TString richSetupTag                            = "";
+  cbmsetup->GetGeoTag(ECbmModuleId::kRich, richSetupTag);
+  if ("" != richSetupTag && fbUnpRich) {
+    LOG(info) << "From received setup, using RICH tag: " << richSetupTag;
+    richconfig = std::make_shared<CbmRichUnpackConfig>("", fuRunId);
+    if (richconfig) {
+      if (1904 < fuRunId) {
+        /// Switch to new unpacking algo starting from first combined cosmics run in 2022
+        richconfig->SetUnpackerVersion(CbmRichUnpackerVersion::v03);
+      }
+      richconfig->DoTotOffsetCorrection();  // correct ToT offset
+      richconfig->SetDebugState();
+      richconfig->SetDoWriteOutput();
+      std::string parfilesbasepathRich = Form("%s/macro/beamtime/mcbm2024/", srcDir.Data());
+      richconfig->SetParFilesBasePath(parfilesbasepathRich);
+      richconfig->SetSystemTimeOffset(256000 - 1200);  // [ns] 1 MS and additional correction
+      if (1904 < fuRunId) richconfig->SetSystemTimeOffset(-1200);
+      if (2160 <= fuRunId) {
+        richconfig->SetSystemTimeOffset(50);  // [ns] value to be updated
+      }
+      if (2350 <= fuRunId) {
+        richconfig->SetSystemTimeOffset(100);  // [ns] value to be updated
+      }
+      if (1588 == fuRunId) richconfig->MaskDiRICH(0x7150);
+    }
+  }  // if ("" != richSetupTag)
+  // -------------
+  // ---- PSD ----
+  std::shared_ptr<CbmPsdUnpackConfig> psdconfig = nullptr;
+  TString psdSetupTag                           = "";
+  cbmsetup->GetGeoTag(ECbmModuleId::kPsd, psdSetupTag);
+  if ("" != psdSetupTag && fbUnpPsd) {
+    LOG(info) << "From received setup, using PSD tag: " << psdSetupTag;
+    psdconfig = std::make_shared<CbmPsdUnpackConfig>("", fuRunId);
+    if (psdconfig) {
+      // psdconfig->SetDebugState();
+      psdconfig->SetDoWriteOutput();
+      // psdconfig->SetDoWriteOptOutA("CbmPsdDsp");
+      std::string parfilesbasepathPsd = Form("%s/macro/beamtime/mcbm2021/", srcDir.Data());
+      psdconfig->SetParFilesBasePath(parfilesbasepathPsd);
+      psdconfig->SetSystemTimeOffset(0);  // [ns] value to be updated
+    }
+  }  // if ("" != psdSetupTag)
+  // -------------
+
+  /// Enable full time sorting instead of time sorting per FLIM link
+  if (stsconfig) SetUnpackConfig(stsconfig);
+  if (muchconfig) SetUnpackConfig(muchconfig);
+  if (trd1Dconfig) SetUnpackConfig(trd1Dconfig);
+  if (trdfasp2dconfig) SetUnpackConfig(trdfasp2dconfig);
+  if (tofconfig) SetUnpackConfig(tofconfig);
+  if (bmonconfig) SetUnpackConfig(bmonconfig);
+  if (richconfig) SetUnpackConfig(richconfig);
+  if (psdconfig) SetUnpackConfig(psdconfig);
+
+  /// Load time offsets
+  for (std::vector<std::string>::iterator itStrOffs = fvsSetTimeOffs.begin(); itStrOffs != fvsSetTimeOffs.end();
+       ++itStrOffs) {
+    size_t charPosDel = (*itStrOffs).find(',');
+    if (std::string::npos == charPosDel) {
+      LOG(info) << "CbmDeviceUnpack::InitContainers => "
+                << "Trying to set trigger window with invalid option pattern, ignored! "
+                << " (Should be ECbmModuleId,dWinBeg,dWinEnd but instead found " << (*itStrOffs) << " )";
+    }  // if( std::string::npos == charPosDel )
+
+    /// Detector Enum Tag
+    std::string sSelDet = (*itStrOffs).substr(0, charPosDel);
+    /// Min number
+    charPosDel++;
+    int32_t iOffset = std::stoi((*itStrOffs).substr(charPosDel));
+
+    if ("kBmon" == sSelDet && fBmonConfig) {  //
+      fBmonConfig->SetSystemTimeOffset(iOffset);
+    }                                            // else if( "kBmon" == sSelDet )
+    else if ("kSTS" == sSelDet && fStsConfig) {  //
+      fStsConfig->SetSystemTimeOffset(iOffset);
+    }  // if( "kSTS"  == sSelDet && fStsConfig)
+    else if ("kMUCH" == sSelDet && fMuchConfig) {
+      fMuchConfig->SetSystemTimeOffset(iOffset);
+    }  // else if( "kMUCH" == sSelDet )
+    else if ("kTRD" == sSelDet && fTrd1DConfig) {
+      fTrd1DConfig->SetSystemTimeOffset(iOffset);
+    }  // else if( "kTRD"  == sSelDet && fTrd2DConfig )
+    else if ("kTRD2D" == sSelDet && fTrd2DConfig) {
+      fTrd2DConfig->SetSystemTimeOffset(iOffset);
+    }  // else if( "kTRD"  == sSelDet && fTrd2DConfig )
+    else if ("kTOF" == sSelDet && fTofConfig) {
+      fTofConfig->SetSystemTimeOffset(iOffset);
+    }  // else if( "kTOF"  == sSelDet && fTofConfig)
+    else if ("kRICH" == sSelDet && fRichConfig) {
+      fRichConfig->SetSystemTimeOffset(iOffset);
+    }  // else if( "kRICH" == sSelDet && fRichConfig)
+    else if ("kPSD" == sSelDet && fPsdConfig) {
+      fPsdConfig->SetSystemTimeOffset(iOffset);
+    }  // else if( "kPSD"  == sSelDet )
+    else {
+      LOG(info) << "CbmDeviceUnpack::InitContainers => Trying to set time "
+                   "offset for unsupported detector, ignored! "
+                << (sSelDet);
+      continue;
+    }  // else of detector enum detection
+  }  // for( std::vector< std::string >::iterator itStrAdd = fvsAddDet.begin(); itStrAdd != fvsAddDet.end(); ++itStrAdd )
+
+  Bool_t initOK = kTRUE;
+  // --- Sts
+  if (fStsConfig) {
+    fStsConfig->InitOutput();
+    //    RegisterOutputs( ioman, fStsConfig ); /// Framework bound work = kept in this Task
+    fStsConfig->SetDoIgnoreOverlappMs(fbIgnoreOverlapMs);
+    fStsConfig->SetAlgo();
+    initOK &= InitParameters(fStsConfig->GetParContainerRequest());  /// Framework bound work = kept in this Device
+    fStsConfig->InitAlgo();
+    //    initPerformanceMaps(fkFlesSts, "STS");
+  }
+  // --- Much
+  if (fMuchConfig) {
+    fMuchConfig->InitOutput();
+    //    RegisterOutputs(ioman, fMuchConfig);  /// Framework bound work = kept in this Task
+    fMuchConfig->SetAlgo();
+    initOK &= InitParameters(fMuchConfig->GetParContainerRequest());  /// Framework bound work = kept in this Device
+    fMuchConfig->InitAlgo();
+    // initPerformanceMaps(fkFlesMuch, "MUCH");
+  }
+  // --- Trd
+  if (fTrd1DConfig) {
+    fTrd1DConfig->InitOutput();
+    //    RegisterOutputs( ioman, fTrd1DConfig ); /// Framework bound work = kept in this Task
+    fTrd1DConfig->SetDoIgnoreOverlappMs(fbIgnoreOverlapMs);
+    fTrd1DConfig->SetAlgo();
+    initOK &= InitParameters(fTrd1DConfig->GetParContainerRequest());  /// Framework bound work = kept in this Device
+    fTrd1DConfig->InitAlgo();
+    //    initPerformanceMaps(fkFlesTrd, "TRD1D");
+  }
+  // --- TRD2D
+  if (fTrd2DConfig) {
+    if (fTrd1DConfig && (fTrd2DConfig->GetOutputBranchName() == fTrd1DConfig->GetOutputBranchName())) {
+      LOG(info) << fTrd2DConfig->GetName() << "::Init() ---------------------------------";
+      fTrd2DConfig->SetOutputVec(fTrd1DConfig->GetOutputVec());
+    }
+    else {
+      fTrd2DConfig->InitOutput();
+      //      RegisterOutputs( ioman, fTrd2DConfig ); /// Framework bound work = kept in this Task
+    }
+    fTrd2DConfig->SetDoIgnoreOverlappMs(fbIgnoreOverlapMs);
+    fTrd2DConfig->SetAlgo();
+    initOK &= InitParameters(fTrd2DConfig->GetParContainerRequest());  /// Framework bound work = kept in this Device
+    fTrd2DConfig->InitAlgo();
+    //    initPerformanceMaps(fkFlesTrd2D, "TRD2D");
+  }
+  // This is an ugly work around, because the TRD and TRD2D want to access the same vector and there is no
+  // function to retrieve a writeable vector<obj> from the FairRootManager, especially before the branches
+  // are created, as far as I am aware.
+  // The second option workaround is in in Init() to look for the fasp config and create a separate branch
+  // for fasp created CbmTrdDigis PR 072021
+  // --- Tof
+  if (fTofConfig) {
+    fTofConfig->InitOutput();
+    //    RegisterOutputs( ioman, fTofConfig ); /// Framework bound work = kept in this Task
+    fTofConfig->SetDoIgnoreOverlappMs(fbIgnoreOverlapMs);
+    fTofConfig->SetAlgo();
+    initOK &= InitParameters(fTofConfig->GetParContainerRequest());  /// Framework bound work = kept in this Device
+    LOG(info) << "TOF call InitAlgo()";
+    fTofConfig->InitAlgo();
+    //    initPerformanceMaps(fkFlesTof, "TOF");
+  }
+  // --- Bmon
+  if (fBmonConfig) {
+    fBmonConfig->InitOutput();
+    //    RegisterOutputs(ioman, fBmonConfig);  /// Framework bound work = kept in this Task
+    fBmonConfig->SetAlgo();
+    fBmonConfig->LoadParFileName();  /// Needed to change the Parameter file name before it is used!!!
+    initOK &= InitParameters(fBmonConfig->GetParContainerRequest());  /// Framework bound work = kept in this Device
+    fBmonConfig->InitAlgo();
+    // initPerformanceMaps(fkFlesBmon, "Bmon");
+  }
+  // --- Rich
+  if (fRichConfig) {
+    fRichConfig->InitOutput();
+    //    RegisterOutputs( ioman, fRichConfig ); /// Framework bound work = kept in this Task
+    fRichConfig->SetDoIgnoreOverlappMs(fbIgnoreOverlapMs);
+    fRichConfig->SetAlgo();
+    initOK &= InitParameters(fRichConfig->GetParContainerRequest());  /// Framework bound work = kept in this Device
+    fRichConfig->InitAlgo();
+    //    initPerformanceMaps(fkFlesRich, "RICH");
+  }
+  // --- Psd
+  if (fPsdConfig) {
+    fPsdConfig->InitOutput();
+    //    RegisterOutputs( ioman, fPsdConfig ); /// Framework bound work = kept in this Task
+    fPsdConfig->SetDoIgnoreOverlappMs(fbIgnoreOverlapMs);
+    fPsdConfig->SetAlgo();
+    initOK &= InitParameters(fPsdConfig->GetParContainerRequest());  /// Framework bound work = kept in this Device
+    fPsdConfig->InitAlgo();
+    //    initPerformanceMaps(fkFlesPsd, "PSD");
+  }
+
+  /// Event header object
+  fCbmTsEventHeader = new CbmTsEventHeader();
+
+  return initOK;
+}
+
+Bool_t
+CbmDeviceUnpack::InitParameters(std::vector<std::pair<std::string, std::shared_ptr<FairParGenericSet>>>* reqparvec)
+{
+  LOG(info) << "CbmDeviceUnpack::InitParameters";
+  if (!reqparvec) {
+    LOG(info) << "CbmDeviceUnpack::InitParameters - empty requirements vector no parameters initialized.";
+    return kTRUE;
+  }
+
+  // Now get the actual ascii files and init the containers with the asciiIo
+  for (auto& pair : *reqparvec) {
+    /*
+    auto filepath = pair.first;
+    auto parset   = pair.second;
+    FairParAsciiFileIo asciiInput;
+    if (!filepath.empty()) {
+      if (asciiInput.open(filepath.data())) { parset->init(&asciiInput); }
+    }
+    * */
+    std::string paramName {pair.second->GetName()};
+    // NewSimpleMessage creates a copy of the data and takes care of its destruction (after the transfer takes place).
+    // Should only be used for small data because of the cost of an additional copy
+
+    // Here must come the proper Runid
+    std::string message = paramName + ",111";
+    LOG(info) << "Requesting parameter container " << paramName << ", sending message: " << message;
+
+    FairMQMessagePtr req(NewSimpleMessage(message));
+    FairMQMessagePtr rep(NewMessage());
+
+    FairParGenericSet* newObj = nullptr;
+
+    if (Send(req, "parameters") > 0) {
+      if (Receive(rep, "parameters") >= 0) {
+        if (0 != rep->GetSize()) {
+          CbmMqTMessage tmsg(rep->GetData(), rep->GetSize());
+          newObj = static_cast<FairParGenericSet*>(tmsg.ReadObject(tmsg.GetClass()));
+          LOG(info) << "Received unpack parameter from the server: " << newObj->GetName();
+          newObj->print();
+        }  // if( 0 !=  rep->GetSize() )
+        else {
+          LOG(error) << "Received empty reply. Parameter not available";
+          return kFALSE;
+        }                       // else of if( 0 !=  rep->GetSize() )
+      }                         // if( Receive( rep, "parameters" ) >= 0)
+    }                           // if( Send(req, "parameters") > 0 )
+    pair.second.reset(newObj);  /// Potentially unsafe reasignment of raw pointer to the shared pointer?
+    //delete newObj;
+  }
+  return kTRUE;
+}
+
+bool CbmDeviceUnpack::InitHistograms()
+{
+  /// Histos creation and obtain pointer on them
+  /// Trigger histo creation on all associated algos
+  // ALGO: bool initOK = fMonitorAlgo->CreateHistograms();
+  bool initOK = true;
+
+  /// Obtain vector of pointers on each histo from the algo (+ optionally desired folder)
+  // ALGO: std::vector<std::pair<TNamed*, std::string>> vHistos = fMonitorAlgo->GetHistoVector();
+  std::vector<std::pair<TNamed*, std::string>> vHistos = {};
+  /// Obtain vector of pointers on each canvas from the algo (+ optionally desired folder)
+  // ALGO: std::vector<std::pair<TCanvas*, std::string>> vCanvases = fMonitorAlgo->GetCanvasVector();
+  std::vector<std::pair<TCanvas*, std::string>> vCanvases = {};
+
+  /// Add pointers to each histo in the histo array
+  /// Create histo config vector
+  /// ===> Use an std::vector< std::pair< std::string, std::string > > with < Histo name, Folder >
+  ///      and send it through a separate channel using the BoostSerializer
+  for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto) {
+    //         LOG(info) << "Registering  " << vHistos[ uHisto ].first->GetName()
+    //                   << " in " << vHistos[ uHisto ].second.data()
+    //                   ;
+    fArrayHisto.Add(vHistos[uHisto].first);
+    std::pair<std::string, std::string> psHistoConfig(vHistos[uHisto].first->GetName(), vHistos[uHisto].second);
+    fvpsHistosFolder.push_back(psHistoConfig);
+
+    LOG(info) << "Config of hist  " << psHistoConfig.first.data() << " in folder " << psHistoConfig.second.data();
+  }  // for( UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto )
+
+  /// Create canvas config vector
+  /// ===> Use an std::vector< std::pair< std::string, std::string > > with < Canvas name, config >
+  ///      and send it through a separate channel using the BoostSerializer
+  for (UInt_t uCanv = 0; uCanv < vCanvases.size(); ++uCanv) {
+    //         LOG(info) << "Registering  " << vCanvases[ uCanv ].first->GetName()
+    //                   << " in " << vCanvases[ uCanv ].second.data();
+    std::string sCanvName = (vCanvases[uCanv].first)->GetName();
+    std::string sCanvConf = GenerateCanvasConfigString(vCanvases[uCanv].first);
+
+    std::pair<std::string, std::string> psCanvConfig(sCanvName, sCanvConf);
+
+    fvpsCanvasConfig.push_back(psCanvConfig);
+
+    LOG(info) << "Config string of Canvas  " << psCanvConfig.first.data() << " is " << psCanvConfig.second.data();
+  }  //  for( UInt_t uCanv = 0; uCanv < vCanvases.size(); ++uCanv )
+
+  return initOK;
+}
+
+// Method called by run loop and requesting new data from the TS source whenever
+bool CbmDeviceUnpack::ConditionalRun()
+{
+  /// First do Algo related Initialization steps if needed
+  if (0 == fulNumMessages) {
+    try {
+      InitContainers();
+    }
+    catch (InitTaskError& e) {
+      LOG(error) << e.what();
+      ChangeState(fair::mq::Transition::ErrorFound);
+    }
+  }  // if( 0 == fulNumMessages)
+
+  if (0 == fulNumMessages) InitHistograms();
+
+  /// First request a new TS (full one)
+  std::string message = "full";
+  LOG(debug) << "Requesting new TS by sending message: full" << message;
+  FairMQMessagePtr req(NewSimpleMessage(message));
+  FairMQMessagePtr rep(NewMessage());
+
+  if (Send(req, fsChannelNameDataInput) <= 0) {
+    LOG(error) << "Failed to send the request! message was " << message;
+    return false;
+  }  // if (Send(req, fsChannelNameDataInput) <= 0)
+  else if (Receive(rep, fsChannelNameDataInput) < 0) {
+    LOG(error) << "Failed to receive a reply to the request! message was " << message;
+    return false;
+  }  // else if (Receive(rep, fsChannelNameDataInput) < 0)
+  else if (rep->GetSize() == 0) {
+    LOG(error) << "Received empty reply. Something went wrong with the timeslice generation! message was " << message;
+    return false;
+  }  // else if (rep->GetSize() == 0)
+
+  fulNumMessages++;
+  LOG(debug) << "Received message number " << fulNumMessages << " with size " << rep->GetSize();
+
+  if (0 == fulNumMessages % 10000) LOG(info) << "Received " << fulNumMessages << " messages";
+
+  std::string msgStr(static_cast<char*>(rep->GetData()), rep->GetSize());
+  std::istringstream iss(msgStr);
+  boost::archive::binary_iarchive inputArchive(iss);
+
+  /// Create an empty TS and fill it with the incoming message
+  fles::StorableTimeslice ts {0};
+  inputArchive >> ts;
+
+  /// On first TS, extract the TS parameters from header (by definition stable over time)
+  if (-1.0 == fdTsCoreSizeInNs) {
+    fuNbCoreMsPerTs  = ts.num_core_microslices();
+    fuNbOverMsPerTs  = ts.num_microslices(0) - ts.num_core_microslices();
+    fdMsSizeInNs     = (ts.descriptor(0, fuNbCoreMsPerTs).idx - ts.descriptor(0, 0).idx) / fuNbCoreMsPerTs;
+    fdTsCoreSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs);
+    fdTsOverSizeInNs = fdMsSizeInNs * (fuNbOverMsPerTs);
+    fdTsFullSizeInNs = fdTsCoreSizeInNs + fdTsOverSizeInNs;
+    LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs << " Core MS and " << fuNbOverMsPerTs
+              << " Overlap MS, for a MS duration of " << fdMsSizeInNs << " ns, a core duration of " << fdTsCoreSizeInNs
+              << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
+    fTsMetaData = new TimesliceMetaData(ts.descriptor(0, 0).idx, fdTsCoreSizeInNs, fdTsOverSizeInNs, ts.index());
+  }  // if( -1.0 == fdTsCoreSizeInNs )
+  else {
+    /// Update only the fields changing from TS to TS
+    fTsMetaData->SetStartTime(ts.descriptor(0, 0).idx);
+    fTsMetaData->SetIndex(ts.index());
+  }
+
+  /// Process the Timeslice
+  DoUnpack(ts, 0);
+
+  LOG(debug) << "Unpack: Sending TS index " << ts.index();
+  /// Send digi vectors to ouput
+  if (!SendUnpData()) return false;
+  LOG(debug) << "Unpack: Sent TS index " << ts.index();
+
+  // Reset the event header for a new timeslice
+  fCbmTsEventHeader->Reset();
+
+  // Reset the unpackers for a new timeslice, e.g. clear the output vectors
+  // ---- Bmon ----
+  if (fBmonConfig) fBmonConfig->Reset();
+  // ---- Sts ----
+  if (fStsConfig) fStsConfig->Reset();
+  // ----Much ----
+  if (fMuchConfig) fMuchConfig->Reset();
+  // ---- Trd ----
+  if (fTrd1DConfig) fTrd1DConfig->Reset();
+  // ---- Trd2D ----
+  if (fTrd2DConfig) fTrd2DConfig->Reset();
+  // ---- Tof ----
+  if (fTofConfig) fTofConfig->Reset();
+  // ---- Rich ----
+  if (fRichConfig) fRichConfig->Reset();
+  // ---- Psd ----
+  if (fPsdConfig) fPsdConfig->Reset();
+
+  /// Send histograms each 100 time slices. Should be each ~1s
+  /// Use also runtime checker to trigger sending after M s if
+  /// processing too slow or delay sending if processing too fast
+  std::chrono::system_clock::time_point currentTime = std::chrono::system_clock::now();
+  std::chrono::duration<double_t> elapsedSeconds    = currentTime - fLastPublishTime;
+  if ((fdMaxPublishTime < elapsedSeconds.count())
+      || (0 == fulNumMessages % fuPublishFreqTs && fdMinPublishTime < elapsedSeconds.count())) {
+    if (!fbConfigSent) {
+      // Send the configuration only once per run!
+      fbConfigSent = SendHistoConfAndData();
+    }  // if( !fbConfigSent )
+    else
+      SendHistograms();
+
+    fLastPublishTime = std::chrono::system_clock::now();
+  }  // if( ( fdMaxPublishTime < elapsedSeconds.count() ) || ( 0 == fulNumMessages % fuPublishFreqTs && fdMinPublishTime < elapsedSeconds.count() ) )
+
+  return true;
+}
+
+bool CbmDeviceUnpack::SendUnpData()
+{
+  FairMQParts parts;
+
+  /// Prepare serialized versions of the TS Event header
+  FairMQMessagePtr messTsHeader(NewMessage());
+  //  Serialize<RootSerializer>(*messTsHeader, fCbmTsEventHeader);
+  RootSerializer().Serialize(*messTsHeader, fCbmTsEventHeader);
+
+  parts.AddPart(std::move(messTsHeader));
+
+  // ---- Bmon ----
+  std::stringstream ossBmon;
+  boost::archive::binary_oarchive oaBmon(ossBmon);
+  if (fBmonConfig) {  //
+    oaBmon << *(fBmonConfig->GetOutputVec());
+  }
+  else {
+    oaBmon << (std::vector<CbmBmonDigi>());
+  }
+  std::string* strMsgBmon = new std::string(ossBmon.str());
+
+  parts.AddPart(NewMessage(
+    const_cast<char*>(strMsgBmon->c_str()),  // data
+    strMsgBmon->length(),                    // size
+    [](void*, void* object) { delete static_cast<std::string*>(object); },
+    strMsgBmon));  // object that manages the data
+
+  // ---- Sts ----
+  std::stringstream ossSts;
+  boost::archive::binary_oarchive oaSts(ossSts);
+  if (fStsConfig) {  //
+    oaSts << *(fStsConfig->GetOutputVec());
+  }
+  else {
+    oaSts << (std::vector<CbmStsDigi>());
+  }
+  std::string* strMsgSts = new std::string(ossSts.str());
+
+  parts.AddPart(NewMessage(
+    const_cast<char*>(strMsgSts->c_str()),  // data
+    strMsgSts->length(),                    // size
+    [](void*, void* object) { delete static_cast<std::string*>(object); },
+    strMsgSts));  // object that manages the data
+
+  // ---- Much ----
+  std::stringstream ossMuch;
+  boost::archive::binary_oarchive oaMuch(ossMuch);
+  if (fMuchConfig) {  //
+    oaMuch << *(fMuchConfig->GetOutputVec());
+  }
+  else {
+    oaMuch << (std::vector<CbmMuchDigi>());
+  }
+  std::string* strMsgMuch = new std::string(ossMuch.str());
+
+  parts.AddPart(NewMessage(
+    const_cast<char*>(strMsgMuch->c_str()),  // data
+    strMsgMuch->length(),                    // size
+    [](void*, void* object) { delete static_cast<std::string*>(object); },
+    strMsgMuch));  // object that manages the data
+
+
+  // ---- Trd ----
+  std::stringstream ossTrd;
+  boost::archive::binary_oarchive oaTrd(ossTrd);
+  if (fTrd1DConfig || fTrd2DConfig) {  //
+    oaTrd << *(fTrd1DConfig ? fTrd1DConfig->GetOutputVec() : fTrd2DConfig->GetOutputVec());
+  }
+  else {
+    oaTrd << (std::vector<CbmTrdDigi>());
+  }
+  std::string* strMsgTrd = new std::string(ossTrd.str());
+
+  parts.AddPart(NewMessage(
+    const_cast<char*>(strMsgTrd->c_str()),  // data
+    strMsgTrd->length(),                    // size
+    [](void*, void* object) { delete static_cast<std::string*>(object); },
+    strMsgTrd));  // object that manages the data
+
+  // ---- Tof ----
+  std::stringstream ossTof;
+  boost::archive::binary_oarchive oaTof(ossTof);
+  if (fTofConfig) {  //
+    oaTof << *(fTofConfig->GetOutputVec());
+  }
+  else {
+    oaTof << (std::vector<CbmTofDigi>());
+  }
+  std::string* strMsgTof = new std::string(ossTof.str());
+
+  parts.AddPart(NewMessage(
+    const_cast<char*>(strMsgTof->c_str()),  // data
+    strMsgTof->length(),                    // size
+    [](void*, void* object) { delete static_cast<std::string*>(object); },
+    strMsgTof));  // object that manages the data
+
+  // ---- Rich ----
+  std::stringstream ossRich;
+  boost::archive::binary_oarchive oaRich(ossRich);
+  if (fRichConfig) {  //
+    oaRich << *(fRichConfig->GetOutputVec());
+  }
+  else {
+    oaRich << (std::vector<CbmRichDigi>());
+  }
+  std::string* strMsgRich = new std::string(ossRich.str());
+
+  parts.AddPart(NewMessage(
+    const_cast<char*>(strMsgRich->c_str()),  // data
+    strMsgRich->length(),                    // size
+    [](void*, void* object) { delete static_cast<std::string*>(object); },
+    strMsgRich));  // object that manages the data
+
+  // ---- Psd ----
+  std::stringstream ossPsd;
+  boost::archive::binary_oarchive oaPsd(ossPsd);
+  if (fPsdConfig) {  //
+    oaPsd << *(fPsdConfig->GetOutputVec());
+  }
+  else {
+    oaPsd << (std::vector<CbmPsdDigi>());
+  }
+  std::string* strMsgPsd = new std::string(ossPsd.str());
+
+  parts.AddPart(NewMessage(
+    const_cast<char*>(strMsgPsd->c_str()),  // data
+    strMsgPsd->length(),                    // size
+    [](void*, void* object) { delete static_cast<std::string*>(object); },
+    strMsgPsd));  // object that manages the data
+
+  /// Prepare serialized versions of the TS Meta
+  /// FIXME: only for TS duration and overlap, should be sent to parameter service instead as stable values in run
+  ///        Index and start time are already included in the TsHeader object!
+  FairMQMessagePtr messTsMeta(NewMessage());
+  //  Serialize<RootSerializer>(*messTsMeta, fTsMetaData);
+  RootSerializer().Serialize(*messTsMeta, fTsMetaData);
+  parts.AddPart(std::move(messTsMeta));
+
+  if (Send(parts, fsChannelNameDataOutput) < 0) {
+    LOG(error) << "Problem sending data to " << fsChannelNameDataOutput;
+    return false;
+  }
+
+  return true;
+}
+
+
+bool CbmDeviceUnpack::SendHistoConfAndData()
+{
+  /// Prepare multiparts message and header
+  std::pair<uint32_t, uint32_t> pairHeader(fvpsHistosFolder.size(), fvpsCanvasConfig.size());
+  FairMQMessagePtr messageHeader(NewMessage());
+  //  Serialize<BoostSerializer<std::pair<uint32_t, uint32_t>>>(*messageHeader, pairHeader);
+  BoostSerializer<std::pair<uint32_t, uint32_t>>().Serialize(*messageHeader, pairHeader);
+  FairMQParts partsOut;
+  partsOut.AddPart(std::move(messageHeader));
+
+  for (UInt_t uHisto = 0; uHisto < fvpsHistosFolder.size(); ++uHisto) {
+    /// Serialize the vector of histo config into a single MQ message
+    FairMQMessagePtr messageHist(NewMessage());
+    //    Serialize<BoostSerializer<std::pair<std::string, std::string>>>(*messageHist, fvpsHistosFolder[uHisto]);
+    BoostSerializer<std::pair<std::string, std::string>>().Serialize(*messageHist, fvpsHistosFolder[uHisto]);
+
+    partsOut.AddPart(std::move(messageHist));
+  }  // for (UInt_t uHisto = 0; uHisto < fvpsHistosFolder.size(); ++uHisto)
+
+  /// Catch case where no histos are registered!
+  /// => Add empty message
+  if (0 == fvpsHistosFolder.size()) {
+    FairMQMessagePtr messageHist(NewMessage());
+    partsOut.AddPart(std::move(messageHist));
+  }
+
+  for (UInt_t uCanv = 0; uCanv < fvpsCanvasConfig.size(); ++uCanv) {
+    /// Serialize the vector of canvas config into a single MQ message
+    FairMQMessagePtr messageCan(NewMessage());
+    //    Serialize<BoostSerializer<std::pair<std::string, std::string>>>(*messageCan, fvpsCanvasConfig[uCanv]);
+    BoostSerializer<std::pair<std::string, std::string>>().Serialize(*messageCan, fvpsCanvasConfig[uCanv]);
+
+    partsOut.AddPart(std::move(messageCan));
+  }  // for (UInt_t uCanv = 0; uCanv < fvpsCanvasConfig.size(); ++uCanv)
+
+  /// Catch case where no Canvases are registered!
+  /// => Add empty message
+  if (0 == fvpsCanvasConfig.size()) {
+    FairMQMessagePtr messageHist(NewMessage());
+    partsOut.AddPart(std::move(messageHist));
+  }
+
+  /// Serialize the array of histos into a single MQ message
+  FairMQMessagePtr msgHistos(NewMessage());
+  //  Serialize<RootSerializer>(*msgHistos, &fArrayHisto);
+  RootSerializer().Serialize(*msgHistos, &fArrayHisto);
+  partsOut.AddPart(std::move(msgHistos));
+
+  /// Send the multi-parts message to the common histogram messages queue
+  if (Send(partsOut, fsChannelNameHistosInput) < 0) {
+    LOG(error) << "CbmTsConsumerReqDevExample::SendHistoConfAndData => Problem sending data";
+    return false;
+  }  // if( Send( partsOut, fsChannelNameHistosInput ) < 0 )
+
+  /// Reset the histograms after sending them (but do not reset the time)
+  // ALGO: fMonitorAlgo->ResetHistograms(kFALSE);
+
+  return true;
+}
+
+bool CbmDeviceUnpack::SendHistograms()
+{
+  /// Serialize the array of histos into a single MQ message
+  FairMQMessagePtr message(NewMessage());
+  //  Serialize<RootSerializer>(*message, &fArrayHisto);
+  RootSerializer().Serialize(*message, &fArrayHisto);
+
+  /// Send message to the common histogram messages queue
+  if (Send(message, fsChannelNameHistosInput) < 0) {
+    LOG(error) << "Problem sending data";
+    return false;
+  }  // if( Send( message, fsChannelNameHistosInput ) < 0 )
+
+  /// Reset the histograms after sending them (but do not reset the time)
+  // ALGO: fMonitorAlgo->ResetHistograms(kFALSE);
+
+  return true;
+}
+
+
+CbmDeviceUnpack::~CbmDeviceUnpack()
+{
+  if (fBmonConfig) fBmonConfig->GetUnpacker()->Finish();
+  if (fStsConfig) fStsConfig->GetUnpacker()->Finish();
+  if (fMuchConfig) fMuchConfig->GetUnpacker()->Finish();
+  if (fTrd1DConfig) fTrd1DConfig->GetUnpacker()->Finish();
+  if (fTrd2DConfig) fTrd2DConfig->GetUnpacker()->Finish();
+  if (fTofConfig) fTofConfig->GetUnpacker()->Finish();
+  if (fRichConfig) fRichConfig->GetUnpacker()->Finish();
+  if (fPsdConfig) fPsdConfig->GetUnpacker()->Finish();
+}
+
+Bool_t CbmDeviceUnpack::DoUnpack(const fles::Timeslice& ts, size_t /*component*/)
+{
+  fulTsCounter++;
+  // Prepare timeslice
+  //  const fles::Timeslice& timeslice = *ts;
+
+  fCbmTsEventHeader->SetTsIndex(ts.index());
+  fCbmTsEventHeader->SetTsStartTime(ts.start_time());
+
+  uint64_t nComponents = ts.num_components();
+  // if (fDoDebugPrints) LOG(info) << "Unpack: TS index " << ts.index() << " components " << nComponents;
+  LOG(debug) << "Unpack: TS index " << ts.index() << " components " << nComponents;
+
+  for (uint64_t component = 0; component < nComponents; component++) {
+    auto systemId = static_cast<std::uint16_t>(ts.descriptor(component, 0).sys_id);
+
+    switch (systemId) {
+      case fkFlesBmon: {
+        if (fBmonConfig) {
+          fCbmTsEventHeader->AddNDigisBmon(
+            unpack(systemId, &ts, component, fBmonConfig, fBmonConfig->GetOptOutAVec(), fBmonConfig->GetOptOutBVec()));
+        }
+        break;
+      }
+      case fkFlesSts: {
+        if (fStsConfig) {
+          fCbmTsEventHeader->AddNDigisSts(
+            unpack(systemId, &ts, component, fStsConfig, fStsConfig->GetOptOutAVec(), fStsConfig->GetOptOutBVec()));
+        }
+        break;
+      }
+      case fkFlesMuch: {
+        if (fMuchConfig) {
+          fCbmTsEventHeader->AddNDigisMuch(
+            unpack(systemId, &ts, component, fMuchConfig, fMuchConfig->GetOptOutAVec(), fMuchConfig->GetOptOutBVec()));
+        }
+        break;
+      }
+      case fkFlesTrd: {
+        if (fTrd1DConfig) {
+          fCbmTsEventHeader->AddNDigisTrd1D(unpack(systemId, &ts, component, fTrd1DConfig,
+                                                   fTrd1DConfig->GetOptOutAVec(), fTrd1DConfig->GetOptOutBVec()));
+        }
+        break;
+      }
+      case fkFlesTrd2D: {
+        if (fTrd2DConfig) {
+          fCbmTsEventHeader->AddNDigisTrd2D(unpack(systemId, &ts, component, fTrd2DConfig,
+                                                   fTrd2DConfig->GetOptOutAVec(), fTrd2DConfig->GetOptOutBVec()));
+        }
+        break;
+      }
+      case fkFlesTof: {
+        if (fTofConfig) {
+          fCbmTsEventHeader->AddNDigisTof(
+            unpack(systemId, &ts, component, fTofConfig, fTofConfig->GetOptOutAVec(), fTofConfig->GetOptOutBVec()));
+        }
+        break;
+      }
+      case fkFlesRich: {
+        if (fRichConfig) {
+          fCbmTsEventHeader->AddNDigisRich(
+            unpack(systemId, &ts, component, fRichConfig, fRichConfig->GetOptOutAVec(), fRichConfig->GetOptOutBVec()));
+        }
+        break;
+      }
+      case fkFlesPsd: {
+        if (fPsdConfig) {
+          fCbmTsEventHeader->AddNDigisPsd(
+            unpack(systemId, &ts, component, fPsdConfig, fPsdConfig->GetOptOutAVec(), fPsdConfig->GetOptOutBVec()));
+        }
+        break;
+      }
+      default: {
+        if (fDoDebugPrints) LOG(error) << "Unpack: Unknown system ID " << systemId << " for component " << component;
+        break;
+      }
+    }
+  }
+
+  if (fbOutputFullTimeSorting) {
+    /// Time sort the output vectors of all unpackers present
+    if (fBmonConfig && fBmonConfig->GetOutputVec()) { timesort(fBmonConfig->GetOutputVec()); }
+    if (fStsConfig && fStsConfig->GetOutputVec()) { timesort(fStsConfig->GetOutputVec()); }
+    if (fMuchConfig && fMuchConfig->GetOutputVec()) { timesort(fMuchConfig->GetOutputVec()); }
+    if (fTrd1DConfig && fTrd1DConfig->GetOutputVec()) { timesort(fTrd1DConfig->GetOutputVec()); }
+    if (fTrd2DConfig && fTrd2DConfig->GetOutputVec()) { timesort(fTrd2DConfig->GetOutputVec()); }
+    if (fTofConfig && fTofConfig->GetOutputVec()) { timesort(fTofConfig->GetOutputVec()); }
+    if (fRichConfig && fRichConfig->GetOutputVec()) { timesort(fRichConfig->GetOutputVec()); }
+    if (fPsdConfig && fPsdConfig->GetOutputVec()) { timesort(fPsdConfig->GetOutputVec()); }
+
+    /// Time sort the output vectors of all unpackers present
+    if (fBmonConfig && fBmonConfig->GetOptOutAVec()) { timesort(fBmonConfig->GetOptOutAVec()); }
+    if (fStsConfig && fStsConfig->GetOptOutAVec()) { timesort(fStsConfig->GetOptOutAVec()); }
+    if (fMuchConfig && fMuchConfig->GetOptOutAVec()) { timesort(fMuchConfig->GetOptOutAVec()); }
+    if (fTrd1DConfig && fTrd1DConfig->GetOptOutAVec()) { timesort(fTrd1DConfig->GetOptOutAVec()); }
+    if (fTrd2DConfig && fTrd2DConfig->GetOptOutAVec()) { timesort(fTrd2DConfig->GetOptOutAVec()); }
+    if (fTofConfig && fTofConfig->GetOptOutAVec()) { timesort(fTofConfig->GetOptOutAVec()); }
+    if (fRichConfig && fRichConfig->GetOptOutAVec()) { timesort(fRichConfig->GetOptOutAVec()); }
+    if (fPsdConfig && fPsdConfig->GetOptOutAVec()) { timesort(fPsdConfig->GetOptOutAVec()); }
+  }
+
+  if (0 == fulTsCounter % 10000) LOG(info) << "Processed " << fulTsCounter << " time slices";
+
+  return kTRUE;
+}
+/**
+ * @brief Get the Trd Spadic
+ * @return std::shared_ptr<CbmTrdSpadic>
+*/
+std::shared_ptr<CbmTrdSpadic> CbmDeviceUnpack::GetTrdSpadic(bool useAvgBaseline)
+{
+  auto spadic = std::make_shared<CbmTrdSpadic>();
+  spadic->SetUseBaselineAverage(useAvgBaseline);
+  spadic->SetMaxAdcToEnergyCal(1.0);
+
+  return spadic;
+}
+
+void CbmDeviceUnpack::Finish() {}

MQ/mcbm/CbmDeviceUnpack.h

+/* Copyright (C) 2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
+/**
+ * CbmDeviceUnpack.h
+ *
+ * @since 2020-05-04
+ * @author P.-A. Loizeau
+ */
+
+#ifndef CBMDEVICEUNPACK_H_
+#define CBMDEVICEUNPACK_H_
+
+#include "CbmMqTMessage.h"
+#include "CbmTsEventHeader.h"
+
+#include "Timeslice.hpp"
+
+#include "FairMQDevice.h"
+#include "FairParGenericSet.h"
+
+#include "Rtypes.h"
+#include "TObjArray.h"
+
+#include <chrono>
+#include <map>
+#include <vector>
+
+class TList;
+class CbmBmonUnpackConfig;
+class CbmStsUnpackConfig;
+class CbmMuchUnpackConfig;
+class CbmTrdUnpackFaspConfig;
+class CbmTrdUnpackConfig;
+class CbmTofUnpackConfig;
+class CbmRichUnpackConfig;
+class CbmPsdUnpackConfig;
+
+class TimesliceMetaData;
+
+class CbmTrdSpadic;
+
+class CbmDeviceUnpack : public FairMQDevice {
+public:
+  CbmDeviceUnpack();
+  virtual ~CbmDeviceUnpack();
+
+protected:
+  virtual void InitTask();
+  bool ConditionalRun();
+  bool HandleCommand(FairMQMessagePtr&, int);
+
+  /** @brief Set the Bmon Unpack Config @param config */
+  void SetUnpackConfig(std::shared_ptr<CbmBmonUnpackConfig> config) { fBmonConfig = config; }
+
+  /** @brief Set the Sts Unpack Config @param config */
+  void SetUnpackConfig(std::shared_ptr<CbmStsUnpackConfig> config) { fStsConfig = config; }
+
+  /** @brief Set the Much Unpack Config @param config */
+  void SetUnpackConfig(std::shared_ptr<CbmMuchUnpackConfig> config) { fMuchConfig = config; }
+
+  /** @brief Set the Trd Unpack Config @param config */
+  void SetUnpackConfig(std::shared_ptr<CbmTrdUnpackConfig> config) { fTrd1DConfig = config; }
+
+  /** @brief Set the Trd2D Unpack Config @param config */
+  void SetUnpackConfig(std::shared_ptr<CbmTrdUnpackFaspConfig> config) { fTrd2DConfig = config; }
+
+  /** @brief Set the Tof Unpack Config @param config */
+  void SetUnpackConfig(std::shared_ptr<CbmTofUnpackConfig> config) { fTofConfig = config; }
+
+  /** @brief Set the Rich Unpack Config @param config */
+  void SetUnpackConfig(std::shared_ptr<CbmRichUnpackConfig> config) { fRichConfig = config; }
+
+  /** @brief Set the Psd Unpack Config @param config */
+  void SetUnpackConfig(std::shared_ptr<CbmPsdUnpackConfig> config) { fPsdConfig = config; }
+
+private:
+  /// Constants
+  static constexpr std::uint16_t fkFlesBmon  = static_cast<std::uint16_t>(fles::Subsystem::BMON);
+  static constexpr std::uint16_t fkFlesMvd   = static_cast<std::uint16_t>(fles::Subsystem::MVD);
+  static constexpr std::uint16_t fkFlesSts   = static_cast<std::uint16_t>(fles::Subsystem::STS);
+  static constexpr std::uint16_t fkFlesMuch  = static_cast<std::uint16_t>(fles::Subsystem::MUCH);
+  static constexpr std::uint16_t fkFlesTrd   = static_cast<std::uint16_t>(fles::Subsystem::TRD);
+  static constexpr std::uint16_t fkFlesTrd2D = static_cast<std::uint16_t>(fles::Subsystem::TRD2D);
+  static constexpr std::uint16_t fkFlesTof   = static_cast<std::uint16_t>(fles::Subsystem::TOF);
+  static constexpr std::uint16_t fkFlesRich  = static_cast<std::uint16_t>(fles::Subsystem::RICH);
+  static constexpr std::uint16_t fkFlesPsd   = static_cast<std::uint16_t>(fles::Subsystem::PSD);
+
+
+  /// Control flags
+  Bool_t fbIgnoreOverlapMs       = false;  //! Ignore Overlap Ms: all fuOverlapMsNb MS at the end of timeslice
+  Bool_t fbComponentsAddedToList = kFALSE;
+
+  /** @brief Flag if extended debug output is to be printed or not*/
+  bool fDoDebugPrints = false;  //!
+  /** @brief Flag if performance profiling should be activated or not.*/
+  bool fDoPerfProf = false;  //!
+  /** @brief Flag to Enable/disable a full time sorting. If off, time sorting happens per link/FLIM source */
+  bool fbOutputFullTimeSorting = false;
+
+  /// User settings parameters
+  std::string fsSetupName = "mcbm_beam_2021_07_surveyed";
+  uint32_t fuRunId        = 1588;
+  /// ---> for selective unpacking
+  bool fbUnpBmon  = false;
+  bool fbUnpSts   = true;
+  bool fbUnpMuch  = false;
+  bool fbUnpTrd1D = true;
+  bool fbUnpTrd2D = true;
+  bool fbUnpTof   = true;
+  bool fbUnpRich  = true;
+  bool fbUnpPsd   = true;
+  /// message queues
+  std::string fsChannelNameDataInput   = "ts-request";
+  std::string fsChannelNameDataOutput  = "unpts_0";
+  std::string fsChannelNameCommands    = "commands";
+  std::string fsChannelNameHistosInput = "histogram-in";
+  /// Histograms management
+  uint32_t fuPublishFreqTs  = 100;
+  double_t fdMinPublishTime = 0.5;
+  double_t fdMaxPublishTime = 5.0;
+
+  /// Parameters management
+  //      TList* fParCList = nullptr;
+  Bool_t InitParameters(std::vector<std::pair<std::string, std::shared_ptr<FairParGenericSet>>>* reqparvec);
+
+  /// Statistics & first TS rejection
+  uint64_t fulNumMessages                                = 0;
+  uint64_t fulTsCounter                                  = 0;
+  std::chrono::system_clock::time_point fLastPublishTime = std::chrono::system_clock::now();
+  /** @brief Map to store a name for the unpackers and the processed amount of digis, key = fkFlesId*/
+  std::map<std::uint16_t, std::pair<std::string, size_t>> fNameMap = {};  //!
+  /** @brief Map to store the cpu and wall time, key = fkFlesId*/
+  std::map<std::uint16_t, std::pair<double, double>> fTimeMap = {};  //!
+  /** @brief Map to store the in and out data amount, key = fkFlesId*/
+  std::map<std::uint16_t, std::pair<double, double>> fDataSizeMap = {};  //!
+
+  /// Configuration of the unpackers. Provides the configured algorithm
+  std::shared_ptr<CbmBmonUnpackConfig> fBmonConfig     = nullptr;
+  std::shared_ptr<CbmStsUnpackConfig> fStsConfig       = nullptr;
+  std::shared_ptr<CbmMuchUnpackConfig> fMuchConfig     = nullptr;
+  std::shared_ptr<CbmTrdUnpackFaspConfig> fTrd2DConfig = nullptr;
+  std::shared_ptr<CbmTrdUnpackConfig> fTrd1DConfig     = nullptr;
+  std::shared_ptr<CbmTofUnpackConfig> fTofConfig       = nullptr;
+  std::shared_ptr<CbmRichUnpackConfig> fRichConfig     = nullptr;
+  std::shared_ptr<CbmPsdUnpackConfig> fPsdConfig       = nullptr;
+
+  /// Pointer to the Timeslice header conatining start time and index
+  CbmTsEventHeader* fCbmTsEventHeader = nullptr;
+
+  /// Time offsets
+  std::vector<std::string> fvsSetTimeOffs = {};
+
+  /// TS MetaData storage: stable so should be moved somehow to parameters handling (not transmitted with each TS
+  size_t fuNbCoreMsPerTs    = 0;     //!
+  size_t fuNbOverMsPerTs    = 0;     //!
+  Double_t fdMsSizeInNs     = 0;     //! Size of a single MS, [nanoseconds]
+  Double_t fdTsCoreSizeInNs = -1.0;  //! Total size of the core MS in a TS, [nanoseconds]
+  Double_t fdTsOverSizeInNs = -1.0;  //! Total size of the overlap MS in a TS, [nanoseconds]
+  Double_t fdTsFullSizeInNs = -1.0;  //! Total size of all MS in a TS, [nanoseconds]
+  TimesliceMetaData* fTsMetaData;
+
+  /// Array of histograms to send to the histogram server
+  TObjArray fArrayHisto = {};
+  /// Vector of string pairs with ( HistoName, FolderPath ) to send to the histogram server
+  std::vector<std::pair<std::string, std::string>> fvpsHistosFolder = {};
+  /// Vector of string pairs with ( CanvasName, CanvasConfig ) to send to the histogram server
+  /// Format of Can config is "NbPadX(U);NbPadY(U);ConfigPad1(s);....;ConfigPadXY(s)"
+  /// Format of Pad config is "GrixX(b),GridY(b),LogX(b),LogY(b),LogZ(b),HistoName(s),DrawOptions(s)"
+  std::vector<std::pair<std::string, std::string>> fvpsCanvasConfig = {};
+  /// Flag indicating whether the histograms and canvases configurations were already published
+  bool fbConfigSent = false;
+
+  Bool_t InitContainers();
+  bool InitHistograms();
+  Bool_t DoUnpack(const fles::Timeslice& ts, size_t component);
+  void Finish();
+  bool SendUnpData();
+  bool SendHistoConfAndData();
+  bool SendHistograms();
+
+  std::shared_ptr<CbmTrdSpadic> GetTrdSpadic(bool useAvgBaseline);
+
+  /** @brief Sort a vector timewise vector type has to provide GetTime() */
+  template<typename TVecobj>
+  typename std::enable_if<std::is_same<TVecobj, std::nullptr_t>::value == true, void>::type
+  timesort(std::vector<TVecobj>* /*vec = nullptr*/)
+  {
+    LOG(debug) << "CbmDeviceUnpack::timesort() got an object that has no member function GetTime(). Hence, we can and "
+                  "will not timesort it!";
+  }
+
+  template<typename TVecobj>
+  typename std::enable_if<!std::is_member_function_pointer<decltype(&TVecobj::GetTime)>::value, void>::type
+  timesort(std::vector<TVecobj>* /*vec = nullptr*/)
+  {
+    LOG(debug) << "CbmDeviceUnpack::timesort() " << TVecobj::Class_Name()
+               << "is  an object that has no member function GetTime(). Hence, we can and "
+                  "will not timesort it!";
+  }
+
+  template<typename TVecobj>
+  typename std::enable_if<std::is_member_function_pointer<decltype(&TVecobj::GetTime)>::value, void>::type
+  timesort(std::vector<TVecobj>* vec = nullptr)
+  {
+    if (vec == nullptr) return;
+    std::sort(vec->begin(), vec->end(),
+              [](const TVecobj& a, const TVecobj& b) -> bool { return a.GetTime() < b.GetTime(); });
+  }
+
+  /**
+   * @brief Template for the unpacking call of a given algorithm.
+   *
+   * @tparam TAlgo Algorithm to be called
+   * @tparam TOutput Output element types
+   * @tparam TOptoutputs Optional output element types
+   * @param ts Timeslice
+   * @param icomp Component number
+   * @param algo Algorithm to be used for this component
+   * @param outtargetvec Target vector for the output elements
+   * @param optoutputvecs Target vectors for optional outputs
+   * @return std::pair<ndigis, std::pair<cputime, walltime>>
+  */
+  template<class TConfig, class TOptOutA = std::nullptr_t, class TOptOutB = std::nullptr_t>
+  size_t unpack(const std::uint16_t subsysid, const fles::Timeslice* ts, std::uint16_t icomp, TConfig config,
+                std::vector<TOptOutA>* optouttargetvecA = nullptr, std::vector<TOptOutB>* optouttargetvecB = nullptr)
+  {
+
+    auto wallstarttime        = std::chrono::high_resolution_clock::now();
+    std::clock_t cpustarttime = std::clock();
+
+    auto algo                        = config->GetUnpacker();
+    std::vector<TOptOutA> optoutAvec = {};
+    std::vector<TOptOutB> optoutBvec = {};
+    if (optouttargetvecA) { algo->SetOptOutAVec(&optoutAvec); }
+    if (optouttargetvecB) { algo->SetOptOutBVec(&optoutBvec); }
+
+    // Set the start time of the current TS for this algorithm
+    algo->SetTsStartTime(ts->start_time());
+
+    // Run the actual unpacking
+    auto digivec = algo->Unpack(ts, icomp);
+
+    // Check if we want to write the output to somewhere (in pure online monitoring mode for example this can/would/should be skipped)
+    if (config->GetOutputVec()) {
+      // Lets do some time-sorting if we are not doing it later
+      if (!fbOutputFullTimeSorting) timesort(&digivec);
+
+      // Transfer the data from the timeslice vector to the target branch vector
+      // Digis/default output retrieved as offered by the algorithm
+      for (auto digi : digivec)
+        config->GetOutputVec()->emplace_back(digi);
+    }
+    if (optouttargetvecA) {
+      // Lets do some timesorting
+      if (!fbOutputFullTimeSorting) timesort(&optoutAvec);
+      // Transfer the data from the timeslice vector to the target branch vector
+      for (auto optoutA : optoutAvec)
+        optouttargetvecA->emplace_back(optoutA);
+    }
+    if (optouttargetvecB) {
+      // Second opt output is not time sorted to allow non GetTime data container.
+      // Lets do some timesorting
+      timesort(&optoutAvec);
+      // Transfer the data from the timeslice vector to the target branch vector
+      for (auto optoutB : optoutBvec)
+        optouttargetvecB->emplace_back(optoutB);
+    }
+
+    std::clock_t cpuendtime = std::clock();
+    auto wallendtime        = std::chrono::high_resolution_clock::now();
+
+    // Cpu time in [mus]
+    auto cputime = 1e6 * (cpuendtime - cpustarttime) / CLOCKS_PER_SEC;
+    algo->AddCpuTime(cputime);
+    // Real time in [mus]
+    auto walltime = std::chrono::duration<double, std::micro>(wallendtime - wallstarttime).count();
+    algo->AddWallTime(walltime);
+
+
+    // Check some numbers from this timeslice
+    size_t nDigis = digivec.size();
+    LOG(debug) << "Component " << icomp << " connected to config " << config->GetName() << "   n-Digis " << nDigis
+               << " processed in walltime(cputime) = " << walltime << "(" << cputime << cputime << ") micro s"
+               << "this timeslice.";
+
+    if (fDoPerfProf) {
+      auto timeit = fTimeMap.find(subsysid);
+      timeit->second.first += cputime;
+      timeit->second.second += walltime;
+
+      auto datait = fDataSizeMap.find(subsysid);
+      datait->second.first += ts->size_component(icomp) / 1.0e6;
+      datait->second.second += nDigis * algo->GetOutputObjSize() / 1.0e6;
+
+      fNameMap.find(subsysid)->second.second += nDigis;
+    }
+
+    return nDigis;
+  }
+};
+
+#endif /* CBMDEVICEMCBMUNPACK_H_ */

MQ/mcbm/UnpBuildSink_missing_features.txt

+Low priority
+- Pub-Sub Queue from Sink to intermediate devices (unpackers, Event builders, ?calibrators?, ...) to signal that last TS was received and dumped and Transition
+  `Active -> Ready -> Stop -> End` can be done (e.g. through a Finish method)
+- Empty/custom TsEventHeader and event vector when dumping missing TS in Sink (vector maybe already OK)

MQ/mcbm/runBmonMonitor.cxx

+/* Copyright (C) 2022 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
+#include "CbmDeviceBmonMonitor.h"
+
+#include <iomanip>
+#include <string>
+
+#include "runFairMQDevice.h"
+
+namespace bpo = boost::program_options;
+using namespace std;
+
+void addCustomOptions(bpo::options_description& options)
+{
+  options.add_options()("Setup", bpo::value<std::string>()->default_value("mcbm_beam_2021_07_surveyed"),
+                        "Name/tag of the geomatry setup");
+  options.add_options()("RunId", bpo::value<uint32_t>()->default_value(1588), "Run ID");
+  options.add_options()("UnpBmon", bpo::value<bool>()->default_value(false), "Enable Bmon unpacking if true");
+  options.add_options()("IgnOverMs", bpo::value<bool>()->default_value(true), "Ignore overlap MS if true");
+  options.add_options()("FullTimeSort", bpo::value<bool>()->default_value(true),
+                        "Full time sorting per detector before sending output array");
+  options.add_options()("SetTimeOffs", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Set time offset in ns for selected detector, use string matching "
+                        "ECbmModuleId,dOffs e.g. kTof,-35.2");
+  options.add_options()("TsNameIn", bpo::value<std::string>()->default_value("ts-request"),
+                        "MQ channel name for raw TS data");
+  options.add_options()("TsNameOut", bpo::value<std::string>()->default_value("unpts_0"),
+                        "MQ channel name for unpacked TS data");
+
+  options.add_options()("PubFreqTs", bpo::value<uint32_t>()->default_value(0), "Histo publishing frequency in TS");
+  options.add_options()("PubTimeMin", bpo::value<double_t>()->default_value(1.0),
+                        "Minimal time between two publishing");
+  options.add_options()("PubTimeMax", bpo::value<double_t>()->default_value(10.0),
+                        "Maximal time between two publishing");
+  options.add_options()("ChNameIn", bpo::value<std::string>()->default_value("histogram-in"),
+                        "MQ channel name for histos");
+}
+
+FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) { return new CbmDeviceBmonMonitor(); }

MQ/mcbm/runBuildDigiEvents.cxx

+/* Copyright (C) 2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Dominik Smith [committer] */
+
+#include "CbmDeviceBuildDigiEvents.h"
+
+#include <iomanip>
+#include <string>
+
+#include "runFairMQDevice.h"
+
+namespace bpo = boost::program_options;
+using namespace std;
+
+void addCustomOptions(bpo::options_description& options)
+{
+  options.add_options()("FillHistos", bpo::value<bool>()->default_value(true),
+                        "Fill histograms and send them to histo server if true");
+  options.add_options()("IgnTsOver", bpo::value<bool>()->default_value(false), "Ignore TS overlap if true");
+  options.add_options()("EvtOverMode", bpo::value<std::string>()->default_value("NoOverlap"),
+                        "Set the event overlap mode, use string matching an EOverlapMode ");
+  options.add_options()("RefDet", bpo::value<std::string>()->default_value("kBmon"),
+                        "Set the reference (seed) detector, use string matching an ECbmModuleId ");
+  options.add_options()("AddDet", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Add a detector for digis selection, use string matching an ECbmModuleId ");
+  options.add_options()("DelDet", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Remove a detector for digis selection, use string matching an "
+                        "ECbmModuleId ");
+  options.add_options()("SetTrigWin", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Set trigger window for selected detector, use string matching "
+                        "ECbmModuleId,dWinBeg,dWinEnd e.g. kSts,-10.5,100.0");
+  options.add_options()("SetTrigMinNb", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Set minimum number of digis for selected detector, use string matching "
+                        "ECbmModuleId,uMinNb e.g. kTof,10");
+  options.add_options()("SetTrigMaxNb", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Set maximum number of digis for selected detector, use string matching "
+                        "ECbmModuleId,uMaxNb e.g. kTof,10");
+  options.add_options()("SetTrigMinLayersNb", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Set minimum number of fired layers for selected detector, use string matching "
+                        "ECbmModuleId,uMinLayersNb e.g. kTof,3");
+  options.add_options()("SetHistMaxDigiNb", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Set max nb of digi in histograms for selected detector, use string matching "
+                        "ECbmModuleId,dMaxDigiNb e.g. kTof,1000");
+  options.add_options()("DoNotSend", bpo::value<bool>()->default_value(false), "Disable the sending of data if true");
+  options.add_options()("DigiEventOutput", bpo::value<bool>()->default_value(false),
+                        "Enable output of CbmDigiEvents instead of raw data + CbmEvents if true");
+  options.add_options()("TsNameIn", bpo::value<std::string>()->default_value("unpts_0"),
+                        "MQ channel name for unpacked TS data");
+  options.add_options()("EvtNameOut", bpo::value<std::string>()->default_value("events"),
+                        "MQ channel name for built events");
+  options.add_options()("ChNameIn", bpo::value<std::string>()->default_value("histogram-in"),
+                        "MQ channel name for histos");
+  options.add_options()("ChNameHistCfg", bpo::value<std::string>()->default_value("histo-conf"),
+                        "MQ channel name for histos config");
+  options.add_options()("ChNameCanvCfg", bpo::value<std::string>()->default_value("canvas-conf"),
+                        "MQ channel name for canvases config");
+  options.add_options()("PubFreqTs", bpo::value<uint32_t>()->default_value(100), "Histo publishing frequency in TS");
+  options.add_options()("PubTimeMin", bpo::value<double_t>()->default_value(1.0),
+                        "Minimal time between two publishing");
+  options.add_options()("PubTimeMax", bpo::value<double_t>()->default_value(10.0),
+                        "Maximal time between two publishing");
+}
+
+FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) { return new CbmDeviceBuildDigiEvents(); }

MQ/mcbm/runBuildRawEvents.cxx

+/* Copyright (C) 2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Dominik Smith [committer] */
+
+#include "CbmDeviceBuildRawEvents.h"
+
+#include <iomanip>
+#include <string>
+
+#include "runFairMQDevice.h"
+
+namespace bpo = boost::program_options;
+using namespace std;
+
+void addCustomOptions(bpo::options_description& options)
+{
+  options.add_options()("FillHistos", bpo::value<bool>()->default_value(true),
+                        "Fill histograms and send them to histo server if true");
+  options.add_options()("IgnTsOver", bpo::value<bool>()->default_value(false), "Ignore TS overlap if true");
+  options.add_options()("EvtOverMode", bpo::value<std::string>()->default_value("NoOverlap"),
+                        "Set the event overlap mode, use string matching an EOverlapMode ");
+  options.add_options()("RefDet", bpo::value<std::string>()->default_value("kBmon"),
+                        "Set the reference (seed) detector, use string matching an ECbmModuleId ");
+  options.add_options()("AddDet", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Add a detector for digis selection, use string matching an ECbmModuleId ");
+  options.add_options()("DelDet", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Remove a detector for digis selection, use string matching an "
+                        "ECbmModuleId ");
+  options.add_options()("SetTrigWin", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Set trigger window for selected detector, use string matching "
+                        "ECbmModuleId,dWinBeg,dWinEnd e.g. kSts,-10.5,100.0");
+  options.add_options()("SetTrigMinNb", bpo::value<std::vector<std::string>>()->multitoken()->composing(),
+                        "Set minimum number of digis for selected detector, use string matching "
+                        "ECbmModuleId,uMinNb e.g. kTof,10");
+  options.add_options()("TsNameIn", bpo::value<std::string>()->default_value("unpts_0"),
+                        "MQ channel name for unpacked TS data");
+  options.add_options()("EvtNameOut", bpo::value<std::string>()->default_value("events"),
+                        "MQ channel name for built events");
+  options.add_options()("ChNameIn", bpo::value<std::string>()->default_value("histogram-in"),
+                        "MQ channel name for histos");
+  options.add_options()("ChNameHistCfg", bpo::value<std::string>()->default_value("histo-conf"),
+                        "MQ channel name for histos config");
+  options.add_options()("ChNameCanvCfg", bpo::value<std::string>()->default_value("canvas-conf"),
+                        "MQ channel name for canvases config");
+  options.add_options()("PubFreqTs", bpo::value<uint32_t>()->default_value(100), "Histo publishing frequency in TS");
+  options.add_options()("PubTimeMin", bpo::value<double_t>()->default_value(1.0),
+                        "Minimal time between two publishing");
+  options.add_options()("PubTimeMax", bpo::value<double_t>()->default_value(10.0),
+                        "Maximal time between two publishing");
+}
+
+FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) { return new CbmDeviceBuildRawEvents(); }

MQ/mcbm/runDigiEventSink.cxx

+/* Copyright (C) 2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
+#include "CbmDeviceDigiEventSink.h"
+
+#include <iomanip>
+#include <string>
+
+#include "runFairMQDevice.h"
+
+namespace bpo = boost::program_options;
+using namespace std;
+
+void addCustomOptions(bpo::options_description& options)
+{
+  options.add_options()("StoreFullTs", bpo::value<bool>()->default_value(false),
+                        "Store digis vectors with full TS in addition to selected events if true");
+  options.add_options()("OutFileName", bpo::value<std::string>()->default_value("mcbm_digis_events.root"),
+                        "Name (full or relative path) of the output .root file ");
+  options.add_options()("EvtNameIn", bpo::value<std::string>()->default_value("events"),
+                        "MQ channel name for built events");
+
+  options.add_options()("BypassConsecutiveTs", bpo::value<bool>()->default_value(false),
+                        "Do not wait for having consecutive TS in buffer before writing to file if true");
+  options.add_options()("WriteMissingTs", bpo::value<bool>()->default_value(false),
+                        "Write empty TS to file for the missing ones if true (irrelevant if bypass ON)");
+
+  options.add_options()("DisableCompression", bpo::value<bool>()->default_value(false),
+                        "Disable the root file compression if true");
+  options.add_options()("TreeFileMaxSize", bpo::value<int64_t>()->default_value(10000000000LL),
+                        "Set the maximum output tree size (~file size) in bytes");
+
+  options.add_options()("DigiEventInput", bpo::value<bool>()->default_value(false),
+                        "Enable the input of CbmDigiEvents instead of raw data + CbmEvents if true");
+  options.add_options()("ExclusiveTrdExtract", bpo::value<bool>()->default_value(true),
+                        "Enable loop based extraction of TRD digis to handle different 1D/2D sel windows if true");
+
+  options.add_options()("FillHistos", bpo::value<bool>()->default_value(false),
+                        "Fill histograms and send them to histo server if true");
+
+  options.add_options()("PubFreqTs", bpo::value<uint32_t>()->default_value(100), "Histo publishing frequency in TS");
+  options.add_options()("PubTimeMin", bpo::value<double_t>()->default_value(1.0),
+                        "Minimal time between two publishing");
+  options.add_options()("PubTimeMax", bpo::value<double_t>()->default_value(10.0),
+                        "Maximal time between two publishing");
+  options.add_options()("HistosSuffix", bpo::value<std::string>()->default_value(""),
+                        "Suffix added to folders, histos and canvases names, e.g. for multiple nodes usages");
+  options.add_options()("ChNameIn", bpo::value<std::string>()->default_value("histogram-in"),
+                        "MQ channel name for histos");
+}
+
+FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) { return new CbmDeviceDigiEventSink(); }

MQ/mcbm/runMcbmEventSink.cxx

+/* Copyright (C) 2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Pierre-Alain Loizeau [committer] */
+
 #include "CbmDeviceMcbmEventSink.h"
-#include "runFairMQDevice.h"
 
 #include <iomanip>
 #include <string>
 
+#include "runFairMQDevice.h"
+
 namespace bpo = boost::program_options;
 using namespace std;
 
-void addCustomOptions(bpo::options_description& options) {
-  options.add_options()(
-    "OutFileName",
-    bpo::value<std::string>()->default_value("mcbm_digis_events.root"),
-    "Name (full or relative path) of the output .root file ");
-  options.add_options()("EvtNameIn",
-                        bpo::value<std::string>()->default_value("events"),
+void addCustomOptions(bpo::options_description& options)
+{
+  options.add_options()("OutFileName", bpo::value<std::string>()->default_value("mcbm_digis_events.root"),
+                        "Name (full or relative path) of the output .root file ");
+  options.add_options()("EvtNameIn", bpo::value<std::string>()->default_value("events"),
                         "MQ channel name for built events");
-  options.add_options()(
-    "FillHistos",
-    bpo::value<bool>()->default_value(false),
-    "Fill histograms and send them to histo server if true");
-  options.add_options()(
-    "ChNameIn",
-    bpo::value<std::string>()->default_value("histogram-in"),
-    "MQ channel name for histos");
-  options.add_options()("ChNameHistCfg",
-                        bpo::value<std::string>()->default_value("histo-conf"),
+  options.add_options()("FillHistos", bpo::value<bool>()->default_value(false),
+                        "Fill histograms and send them to histo server if true");
+  options.add_options()("ChNameIn", bpo::value<std::string>()->default_value("histogram-in"),
+                        "MQ channel name for histos");
+  options.add_options()("ChNameHistCfg", bpo::value<std::string>()->default_value("histo-conf"),
                         "MQ channel name for histos config");
-  options.add_options()("ChNameCanvCfg",
-                        bpo::value<std::string>()->default_value("canvas-conf"),
+  options.add_options()("ChNameCanvCfg", bpo::value<std::string>()->default_value("canvas-conf"),
                         "MQ channel name for canvases config");
-  options.add_options()("PubFreqTs",
-                        bpo::value<uint32_t>()->default_value(100),
-                        "Histo publishing frequency in TS");
-  options.add_options()("PubTimeMin",
-                        bpo::value<double_t>()->default_value(1.0),
+  options.add_options()("PubFreqTs", bpo::value<uint32_t>()->default_value(100), "Histo publishing frequency in TS");
+  options.add_options()("PubTimeMin", bpo::value<double_t>()->default_value(1.0),
                         "Minimal time between two publishing");
-  options.add_options()("PubTimeMax",
-                        bpo::value<double_t>()->default_value(10.0),
+  options.add_options()("PubTimeMax", bpo::value<double_t>()->default_value(10.0),
                         "Maximal time between two publishing");
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) {
-  return new CbmDeviceMcbmEventSink();
-}
+FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) { return new CbmDeviceMcbmEventSink(); }