MQ/base/CbmMQChannels.cxx

+/* Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Florian Uhlig [committer] */
+
 #include "CbmMQChannels.h"
+
 #include "FairMQDevice.h"
 
-CbmMQChannels::CbmMQChannels(std::vector<std::string> allowedChannels)
-  : fAllowedChannels {allowedChannels} {
+CbmMQChannels::CbmMQChannels(std::vector<std::string> allowedChannels) : fAllowedChannels {allowedChannels}
+{
   fChannelsToSend.resize(fAllowedChannels.size());
   for (auto& entry : fChannelsToSend) {
     entry.push_back("");
@@ -10,32 +15,29 @@ CbmMQChannels::CbmMQChannels(std::vector<std::string> allowedChannels)
   fComponentsToSend.resize(fAllowedChannels.size());
 }
 
-bool CbmMQChannels::IsChannelNameAllowed(std::string channelName) {
+bool CbmMQChannels::IsChannelNameAllowed(std::string channelName)
+{
   for (auto const& entry : fAllowedChannels) {
     std::size_t pos1 = channelName.find(entry);
     if (pos1 != std::string::npos) {
       const std::vector<std::string>::const_iterator pos =
         std::find(fAllowedChannels.begin(), fAllowedChannels.end(), entry);
-      const std::vector<std::string>::size_type idx =
-        pos - fAllowedChannels.begin();
+      const std::vector<std::string>::size_type idx = pos - fAllowedChannels.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;
       fComponentsToSend[idx]++;
       // The array is initialized with one empty string. If the string has still teh value from initialization
       // exchnge the value by the new channel name. In any other case add one more entry to the vector
-      if (fChannelsToSend[idx].size() == 1
-          && fChannelsToSend[idx].at(0).empty()) {
+      if (fChannelsToSend[idx].size() == 1 && fChannelsToSend[idx].at(0).empty()) {
         fChannelsToSend[idx].at(0) = channelName;
-      } else {
+      }
+      else {
         fChannelsToSend[idx].push_back(channelName);
       }
       return true;
     }
   }
-  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(info) << "The allowed channels are: ";
   for (auto const& entry : fAllowedChannels) {
     LOG(info) << entry;
@@ -44,7 +46,8 @@ bool CbmMQChannels::IsChannelNameAllowed(std::string channelName) {
   return false;
 }
 
-bool CbmMQChannels::CheckChannels(FairMQDevice* device) {
+bool CbmMQChannels::CheckChannels(FairMQDevice* device)
+{
   // 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

MQ/base/CbmMQChannels.h

+/* Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Florian Uhlig [committer] */
+
 #ifndef CBMMQCHANNELS_H_
 #define CBMMQCHANNELS_H_
 
+#include "FairMQDevice.h"
+
 #include <string>
 #include <vector>
 
-class FairMQDevice;
 
 class CbmMQChannels {
 public:
@@ -14,9 +19,7 @@ public:
   bool CheckChannels(FairMQDevice* device);
 
   std::vector<int> GetComponentsToSend() { return fComponentsToSend; }
-  std::vector<std::vector<std::string>> GetChannelsToSend() {
-    return fChannelsToSend;
-  }
+  std::vector<std::vector<std::string>> GetChannelsToSend() { return fChannelsToSend; }
 
 private:
   std::vector<std::string> fAllowedChannels {};

MQ/base/CbmMQDefs.h

-//#ifdef HAVE_FAIRMQSTATEMACHINE
-//#include "FairMQStateMachine.h"
-//#endif
+/* Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Florian Uhlig [committer] */
+
 #include "FairMQDevice.h"
 
-namespace cbm {
-  namespace mq {
-    enum class Transition : int {
+namespace cbm
+{
+  namespace mq
+  {
+    enum class Transition : int
+    {
       Idle,
       DeviceReady,
       Ready,
@@ -14,69 +18,45 @@ namespace cbm {
       ErrorFound
     };
 
-    enum class State : int { Running };
+    enum class State : int
+    {
+      Running
+    };
 
-    void ChangeState(FairMQDevice* device, cbm::mq::Transition transition) {
-#ifdef HAVE_FAIRMQSTATEMACHINE
-      if (transition == cbm::mq::Transition::ErrorFound) {
-        device->ChangeState(FairMQStateMachine::Event::ERROR_FOUND);
-      } else if (transition == cbm::mq::Transition::End) {
-        device->ChangeState(FairMQStateMachine::Event::END);
-      } else if (transition == cbm::mq::Transition::Ready) {
-        device->ChangeState(FairMQStateMachine::Event::internal_READY);
-      } else if (transition == cbm::mq::Transition::DeviceReady) {
-        device->ChangeState(FairMQStateMachine::Event::internal_DEVICE_READY);
-      } else if (transition == cbm::mq::Transition::Idle) {
-        device->ChangeState(FairMQStateMachine::Event::internal_IDLE);
-      } else {
-        LOG(fatal) << "State Change not yet implemented";
-        device->ChangeState(FairMQStateMachine::Event::ERROR_FOUND);
-      }
-#else
-      if (transition == cbm::mq::Transition::ErrorFound) {
-        device->ChangeState(fair::mq::Transition::ErrorFound);
-      } else if (transition == cbm::mq::Transition::End) {
+    void ChangeState(FairMQDevice* device, cbm::mq::Transition transition)
+    {
+      if (transition == cbm::mq::Transition::ErrorFound) { device->ChangeState(fair::mq::Transition::ErrorFound); }
+      else if (transition == cbm::mq::Transition::End) {
         device->ChangeState(fair::mq::Transition::End);
-      } else if (transition == cbm::mq::Transition::Ready) {
+      }
+      else if (transition == cbm::mq::Transition::Ready) {
         device->ChangeState(fair::mq::Transition::ResetTask);
-      } else if (transition == cbm::mq::Transition::DeviceReady) {
+      }
+      else if (transition == cbm::mq::Transition::DeviceReady) {
         device->ChangeState(fair::mq::Transition::ResetDevice);
-      } else if (transition == cbm::mq::Transition::Idle) {
+      }
+      else if (transition == cbm::mq::Transition::Idle) {
         device->ChangeState(fair::mq::Transition::Stop);
-      } else {
+      }
+      else {
         LOG(fatal) << "State Change not yet implemented";
         device->ChangeState(fair::mq::Transition::ErrorFound);
       }
-#endif
     }
 
-    void LogState(FairMQDevice* device) {
-#ifdef HAVE_FAIRMQSTATEMACHINE
-      //      LOG(info) << "Current State: " <<  FairMQStateMachine::GetCurrentStateName();
-      LOG(info) << "Current State: " << device->GetCurrentStateName();
-#else
+    void LogState(FairMQDevice* device)
+    {
       LOG(info) << "Current State: " << device->GetCurrentStateName();
-#endif
     }
 
-    bool CheckCurrentState(FairMQDevice* device, cbm::mq::State state) {
-#ifdef HAVE_FAIRMQSTATEMACHINE
-      if (state == cbm::mq::State::Running) {
-        return device->CheckCurrentState(FairMQStateMachine::State::RUNNING);
-      } else {
-        LOG(fatal) << "State not yet implemented";
-        device->ChangeState(FairMQStateMachine::Event::ERROR_FOUND);
-        return 0;
-      }
-#else
-      if (state == cbm::mq::State::Running) {
-        return !(device->NewStatePending());
-      } else {
+    bool CheckCurrentState(FairMQDevice* device, cbm::mq::State state)
+    {
+      if (state == cbm::mq::State::Running) { return !(device->NewStatePending()); }
+      else {
         LOG(fatal) << "State not yet implemented";
         device->ChangeState(fair::mq::Transition::ErrorFound);
         return 0;
       }
-#endif
     }
   }  // namespace mq
 }  // namespace cbm

MQ/base/CbmMqTMessage.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] */
+
+#ifndef CBMMQTMESSAGE_H_
+#define CBMMQTMESSAGE_H_
+
+#include "TMessage.h"
+
+// special class to expose protected TMessage constructor
+class CbmMqTMessage : public TMessage {
+public:
+  CbmMqTMessage(void* buf, Int_t len) : TMessage(buf, len) { ResetBit(kIsOwner); }
+};
+
+#endif /* CBMMQTMESSAGE_H_ */

MQ/eTOF/CMakeLists.txt

@@ -26,7 +26,7 @@ Set(SYSTEM_INCLUDE_DIRECTORIES
     ${FAIRMQ_INCLUDE_DIR}
     ${FAIRMQ_INCLUDE_DIR}/options
 
-    ${IPC_INCLUDE_DIRECTORY}
+    ${FLES_IPC_INCLUDE_DIRECTORY}
     ${CBMROOT_SOURCE_DIR}/external/cppzmq
 )
 
@@ -66,13 +66,18 @@ If(FAIRLOGGER_FOUND)
      )
 EndIf()
 
-set(EXE_NAME EventBuilderEtofStar2019)
-set(SRCS CbmDeviceEventBuilderEtofStar2019.cxx runEventBuilderEtofStar2019.cxx)
-set(DEPENDENCIES
+# Dependencies common to all executables
+set(DEPENDENCIES_ALL
   ${DEPENDENCIES}
   ${FAIR_LIBS}
   ${BOOST_LIBS}
-  fles_ipc
+)
+
+set(EXE_NAME EventBuilderEtofStar2019)
+set(SRCS CbmDeviceEventBuilderEtofStar2019.cxx runEventBuilderEtofStar2019.cxx)
+set(DEPENDENCIES
+  ${DEPENDENCIES_ALL}
+  external::fles_ipc
   CbmFlibStar2019
   CbmFlibMcbm2018
   CbmBase
@@ -94,10 +99,8 @@ Set(NO_DICT_SRCS
 # Mask warning from file provided by STAR
 SET_SOURCE_FILES_PROPERTIES(${CBMROOT_SOURCE_DIR}/fles/star2017/unpacker/star_rhicf.c PROPERTIES COMPILE_FLAGS -Wno-pointer-sign)
 set(DEPENDENCIES
-  ${DEPENDENCIES}
-  ${FAIR_LIBS}
-  ${BOOST_LIBS}
-  fles_ipc
+  ${DEPENDENCIES_ALL}
+  external::fles_ipc
   CbmFlibStar2019
   CbmFlibMcbm2018
   CbmBase

MQ/eTOF/CbmDeviceEventBuilderEtofStar2019.h

+/* Copyright (C) 2019 PI-UHd, GSI
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Norbert Herrmann [committer] */
+
 /**
  * CbmDeviceEventBuilderEtofStar2019.h
  *
@@ -6,11 +10,13 @@
 #ifndef CBMDEVICEEVENTBUILDERETOFSTAR2019_H_
 #define CBMDEVICEEVENTBUILDERETOFSTAR2019_H_
 
-#include "FairMQDevice.h"
+#include "CbmMqTMessage.h"
 
-#include "TMessage.h"
 #include "Timeslice.hpp"
 
+#include "FairMQDevice.h"
+
+#include "TMessage.h"
 #include "TStopwatch.h"
 
 class CbmStar2019EventBuilderEtofAlgo;
@@ -31,19 +37,15 @@ public:
 
   Bool_t ReInitContainers();
 
-  void SetSandboxMode(Bool_t bSandboxMode = kTRUE) {
-    fbSandboxMode = bSandboxMode;
-  }
+  void SetSandboxMode(Bool_t bSandboxMode = kTRUE) { fbSandboxMode = bSandboxMode; }
   void SetEventDumpEnable(Bool_t bDumpEna = kTRUE);
 
   /// Temp until we change from CbmMcbmUnpack to something else
   void AddMsComponentToList(size_t component, UShort_t usDetectorId);
   void SetNbMsInTs(size_t /*uCoreMsNb*/, size_t /*uOverlapMsNb*/) {};
 
-  CbmDeviceEventBuilderEtofStar2019(const CbmDeviceEventBuilderEtofStar2019&) =
-    delete;
-  CbmDeviceEventBuilderEtofStar2019
-  operator=(const CbmDeviceEventBuilderEtofStar2019&) = delete;
+  CbmDeviceEventBuilderEtofStar2019(const CbmDeviceEventBuilderEtofStar2019&) = delete;
+  CbmDeviceEventBuilderEtofStar2019 operator=(const CbmDeviceEventBuilderEtofStar2019&) = delete;
 
 protected:
   virtual void InitTask();
@@ -56,13 +58,10 @@ protected:
 private:
   uint64_t fNumMessages;
   /// Control flags
-  Bool_t
-    fbMonitorMode;  //! Switch ON the filling of a minimal set of histograms
-  Bool_t
-    fbDebugMonitorMode;  //! Switch ON the filling of a additional set of histograms
-  Bool_t fbSandboxMode;  //! Switch OFF the emission of data toward the STAR DAQ
-  Bool_t
-    fbEventDumpEna;  //! Switch ON the dumping of the events to a binary file
+  Bool_t fbMonitorMode;       //! Switch ON the filling of a minimal set of histograms
+  Bool_t fbDebugMonitorMode;  //! Switch ON the filling of a additional set of histograms
+  Bool_t fbSandboxMode;       //! Switch OFF the emission of data toward the STAR DAQ
+  Bool_t fbEventDumpEna;      //! Switch ON the dumping of the events to a binary file
 
   /// Parameters management
   TList* fParCList;
@@ -74,10 +73,7 @@ private:
   bool CheckTimeslice(const fles::Timeslice& ts);
   bool IsChannelNameAllowed(std::string channelName);
 
-  std::vector<std::string> fAllowedChannels             = {"tofcomponent",
-                                               "parameters",
-                                               "etofevts",
-                                               "syscmd"};
+  std::vector<std::string> fAllowedChannels             = {"tofcomponent", "parameters", "etofevts", "syscmd"};
   std::vector<std::vector<std::string>> fChannelsToSend = {{}, {}, {}};
 
   /// Processing algo
@@ -92,12 +88,4 @@ private:
   const UInt_t kuBinDumpEndWord = 0xFAEBDEEF;
 };
 
-// special class to expose protected TMessage constructor
-class CbmMQTMessage : public TMessage {
-public:
-  CbmMQTMessage(void* buf, Int_t len) : TMessage(buf, len) {
-    ResetBit(kIsOwner);
-  }
-};
-
 #endif /* CBMDEVICEEVENTBUILDERETOFSTAR2019_H_ */

MQ/eTOF/CbmDeviceTriggerHandlerEtof.cxx

+/* Copyright (C) 2019 PI-UHd, GSI
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Norbert Herrmann [committer] */
+
 /**
  * CbmDeviceTriggerHandlerEtof.cxx
  *
@@ -6,6 +10,7 @@
  */
 
 #include "CbmDeviceTriggerHandlerEtof.h"
+
 #include "CbmMQDefs.h"
 
 #include "FairEventHeader.h"
@@ -18,23 +23,22 @@
 #include "FairRunOnline.h"
 #include "FairRuntimeDb.h"
 
+#include <thread>  // this_thread::sleep_for
+
 #include <boost/archive/binary_iarchive.hpp>
 #include <boost/archive/binary_oarchive.hpp>
 #include <boost/serialization/vector.hpp>
 
 #include <chrono>
 #include <iomanip>
-#include <string>
-#include <thread>  // this_thread::sleep_for
-
 #include <stdexcept>
+#include <string>
 struct InitTaskError : std::runtime_error {
   using std::runtime_error::runtime_error;
 };
 
-static std::chrono::steady_clock::time_point dctime =
-  std::chrono::steady_clock::now();
-static double dSize = 0.;
+static std::chrono::steady_clock::time_point dctime = std::chrono::steady_clock::now();
+static double dSize                                 = 0.;
 
 using namespace std;
 
@@ -45,11 +49,14 @@ CbmDeviceTriggerHandlerEtof::CbmDeviceTriggerHandlerEtof()
   , fbDebugMonitorMode(kFALSE)
   , fbSandboxMode(kFALSE)
   , fbEventDumpEna(kFALSE)
-  , fdEvent(0.) {}
+  , fdEvent(0.)
+{
+}
 
 CbmDeviceTriggerHandlerEtof::~CbmDeviceTriggerHandlerEtof() {}
 
-void CbmDeviceTriggerHandlerEtof::InitTask() try {
+void CbmDeviceTriggerHandlerEtof::InitTask()
+try {
   // 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
@@ -62,21 +69,20 @@ void CbmDeviceTriggerHandlerEtof::InitTask() try {
   LOG(info) << "Number of defined input channels: " << noChannel;
   for (auto const& entry : fChannels) {
     LOG(info) << "Channel name: " << entry.first;
-    if (!IsChannelNameAllowed(entry.first))
-      throw InitTaskError("Channel name does not match.");
-    if (entry.first != "syscmd")
-      OnData(entry.first, &CbmDeviceTriggerHandlerEtof::HandleData);
+    if (!IsChannelNameAllowed(entry.first)) throw InitTaskError("Channel name does not match.");
+    if (entry.first != "syscmd") OnData(entry.first, &CbmDeviceTriggerHandlerEtof::HandleData);
     else
       OnData(entry.first, &CbmDeviceTriggerHandlerEtof::HandleMessage);
   }
   InitWorkspace();
-} catch (InitTaskError& e) {
+}
+catch (InitTaskError& e) {
   LOG(error) << e.what();
   cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
 }
 
-bool CbmDeviceTriggerHandlerEtof::IsChannelNameAllowed(
-  std::string channelName) {
+bool CbmDeviceTriggerHandlerEtof::IsChannelNameAllowed(std::string channelName)
+{
   for (auto const& entry : fAllowedChannels) {
     std::size_t pos1 = channelName.find(entry);
     if (pos1 != std::string::npos) {
@@ -84,19 +90,17 @@ bool CbmDeviceTriggerHandlerEtof::IsChannelNameAllowed(
         std::find(fAllowedChannels.begin(), fAllowedChannels.end(), entry);
       const vector<std::string>::size_type idx = pos - fAllowedChannels.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;
     }
   }
-  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 CbmDeviceTriggerHandlerEtof::InitWorkspace() {
+Bool_t CbmDeviceTriggerHandlerEtof::InitWorkspace()
+{
   LOG(info) << "Init work space for CbmDeviceTriggerHandlerEtof.";
 
   // steering variables
@@ -107,19 +111,17 @@ Bool_t CbmDeviceTriggerHandlerEtof::InitWorkspace() {
 
 // handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)
 //bool CbmDeviceTriggerHandlerEtof::HandleData(FairMQMessagePtr& msg, int /*index*/)
-bool CbmDeviceTriggerHandlerEtof::HandleData(FairMQParts& parts,
-                                             int /*index*/) {
+bool CbmDeviceTriggerHandlerEtof::HandleData(FairMQParts& parts, int /*index*/)
+{
   // Don't do anything with the data
   // Maybe add an message counter which counts the incomming messages and add
   // an output
   fNumMessages++;
-  LOG(debug) << "Received message " << fNumMessages << " with " << parts.Size()
-             << " parts"
+  LOG(debug) << "Received message " << fNumMessages << " with " << parts.Size() << " parts"
              << ", size0: " << parts.At(0)->GetSize();
 
   uint TrigWord {0};
-  std::string msgStrE(static_cast<char*>(parts.At(0)->GetData()),
-                      (parts.At(0))->GetSize());
+  std::string msgStrE(static_cast<char*>(parts.At(0)->GetData()), (parts.At(0))->GetSize());
   std::istringstream issE(msgStrE);
   boost::archive::binary_iarchive inputArchiveE(issE);
   inputArchiveE >> TrigWord;
@@ -128,17 +130,13 @@ bool CbmDeviceTriggerHandlerEtof::HandleData(FairMQParts& parts,
   int iBuffSzByte = parts.At(1)->GetSize();
 
   // Send Subevent to STAR
-  LOG(debug) << "Send Data for event " << fdEvent << ", TrigWord " << TrigWord
-             << " with size " << iBuffSzByte << Form(" at %p ", pDataBuff);
-  if (kFALSE == fbSandboxMode) {
-    star_rhicf_write(TrigWord, pDataBuff, iBuffSzByte);
-  }
+  LOG(debug) << "Send Data for event " << fdEvent << ", TrigWord " << TrigWord << " with size " << iBuffSzByte
+             << Form(" at %p ", pDataBuff);
+  if (kFALSE == fbSandboxMode) { star_rhicf_write(TrigWord, pDataBuff, iBuffSzByte); }
   dSize += iBuffSzByte;
   if (0 == (int) fdEvent % 10000) {
-    std::chrono::duration<double> deltatime =
-      std::chrono::steady_clock::now() - dctime;
-    LOG(info) << "Processed " << fdEvent
-              << " events,  delta-time: " << deltatime.count()
+    std::chrono::duration<double> deltatime = std::chrono::steady_clock::now() - dctime;
+    LOG(info) << "Processed " << fdEvent << " events,  delta-time: " << deltatime.count()
               << ", rate: " << dSize * 1.E-6 / deltatime.count() << "MB/s";
     dctime = std::chrono::steady_clock::now();
     dSize  = 0.;
@@ -150,8 +148,8 @@ bool CbmDeviceTriggerHandlerEtof::HandleData(FairMQParts& parts,
 
 /************************************************************************************/
 
-bool CbmDeviceTriggerHandlerEtof::HandleMessage(FairMQMessagePtr& msg,
-                                                int /*index*/) {
+bool CbmDeviceTriggerHandlerEtof::HandleMessage(FairMQMessagePtr& msg, int /*index*/)
+{
   const char* cmd    = (char*) (msg->GetData());
   const char cmda[4] = {*cmd};
   LOG(info) << "Handle message " << cmd << ", " << cmd[0];

MQ/eTOF/CbmDeviceTriggerHandlerEtof.h

+/* Copyright (C) 2019 PI-UHd, GSI
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Norbert Herrmann [committer] */
+
 /**
  * CbmDeviceTriggerHandlerStar2019.h
  *
@@ -8,20 +12,19 @@
 #ifndef CBMDEVICETRIGGERHANDLERETOF_H_
 #define CBMDEVICETRIGGERHANDLERETOF_H_
 
-#include "FairMQDevice.h"
+#include "CbmMqTMessage.h"
+#include "CbmTofStarData2019.h"
 
 #include "MicrosliceDescriptor.hpp"
 #include "Timeslice.hpp"
 
-#include "CbmTofStarData2019.h"
+#include "FairMQDevice.h"
 
 #include "Rtypes.h"
-#include "TMessage.h"
 
 #include <map>
 #include <vector>
 
-class CbmMQTMessage;
 // Relevant TOF classes
 
 extern "C" int star_rhicf_write(unsigned int trg_word, void* dta, int bytes);
@@ -55,11 +58,7 @@ private:
   Bool_t ReInitContainers();
 
   uint64_t fNumMessages;
-  std::vector<std::string> fAllowedChannels = {"tofcomponent",
-                                               "parameters",
-                                               "etofevts",
-                                               "tofhits",
-                                               "syscmd"};
+  std::vector<std::string> fAllowedChannels = {"tofcomponent", "parameters", "etofevts", "tofhits", "syscmd"};
 
   // Input variables
 
@@ -68,25 +67,14 @@ private:
   // Constants or setting parameters
   Int_t fiMsgCnt;
   /// Control flags
-  Bool_t
-    fbMonitorMode;  //! Switch ON the filling of a minimal set of histograms
-  Bool_t
-    fbDebugMonitorMode;  //! Switch ON the filling of a additional set of histograms
-  Bool_t fbSandboxMode;  //! Switch OFF the emission of data toward the STAR DAQ
-  Bool_t
-    fbEventDumpEna;  //! Switch ON the dumping of the events to a binary file
+  Bool_t fbMonitorMode;       //! Switch ON the filling of a minimal set of histograms
+  Bool_t fbDebugMonitorMode;  //! Switch ON the filling of a additional set of histograms
+  Bool_t fbSandboxMode;       //! Switch OFF the emission of data toward the STAR DAQ
+  Bool_t fbEventDumpEna;      //! Switch ON the dumping of the events to a binary file
 
   Double_t fdEvent;
 
   // histograms
 };
 
-// special class to expose protected TMessage constructor
-class CbmMQTMessage : public TMessage {
-public:
-  CbmMQTMessage(void* buf, Int_t len) : TMessage(buf, len) {
-    ResetBit(kIsOwner);
-  }
-};
-
 #endif /* CBMDEVICETRIGGERHANDLERETOF_H_ */

MQ/eTOF/runEventBuilderEtofStar2019.cxx

+/* Copyright (C) 2019 PI-UHd, GSI
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Norbert Herrmann [committer] */
+
 #include "CbmDeviceEventBuilderEtofStar2019.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) { ; }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) {
-  return new CbmDeviceEventBuilderEtofStar2019();
-}
+FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) { return new CbmDeviceEventBuilderEtofStar2019(); }

MQ/eTOF/runTriggerHandlerEtof.cxx

+/* Copyright (C) 2019 PI-UHd, GSI
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Norbert Herrmann [committer] */
+
 #include "CbmDeviceTriggerHandlerEtof.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()(
-    "SandboxMode", bpo::value<bool>()->default_value(1), "Test mode switch");
+void addCustomOptions(bpo::options_description& options)
+{
+  options.add_options()("SandboxMode", bpo::value<bool>()->default_value(1), "Test mode switch");
   ;
 }
 
-FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) {
-  return new CbmDeviceTriggerHandlerEtof();
-}
+FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/) { return new CbmDeviceTriggerHandlerEtof(); }

MQ/eTOF/startMQ_EBStar2020.sh

 #!/bin/bash
+# Copyright (C) 2019 PI-UHd,GSI
+# SPDX-License-Identifier: GPL-3.0-only
+# First commited by Norbert Herrmann
+
 # script to write cosmic data to file  
 $FAIRROOTPATH/bin/shmmonitor --cleanup
 

MQ/histoServer/CMakeLists.txt

@@ -6,88 +6,49 @@
  #                  copied verbatim in the file "LICENSE"                       #
  ################################################################################
 
-Set(INCLUDE_DIRECTORIES
+set(INCLUDE_DIRECTORIES
   ${CMAKE_CURRENT_SOURCE_DIR}
-  ${CBMROOT_SOURCE_DIR}/fles/flestools
 )
 
-Set(SYSTEM_INCLUDE_DIRECTORIES
-    ${SYSTEM_INCLUDE_DIRECTORIES}
-    ${Boost_INCLUDE_DIR}
-    ${FAIRROOT_INCLUDE_DIR}
-    ${FAIRMQ_INCLUDE_DIR}
-    ${FAIRMQ_INCLUDE_DIR}/options
-)
-
-Include_Directories(${INCLUDE_DIRECTORIES})
-Include_Directories(SYSTEM ${SYSTEM_INCLUDE_DIRECTORIES})
-
-Set(LINK_DIRECTORIES
-  ${Boost_LIBRARY_DIRS}
-  ${FAIRROOT_LIBRARY_DIR}
-  ${ROOT_LIBRARY_DIR}
-)
-
-Link_Directories(${LINK_DIRECTORIES})
-
-set(FAIR_LIBS
-  FairMQ
-)
-
-If(FAIRLOGGER_FOUND)
-  set(FAIR_LIBS
-    ${FAIR_LIBS}
-    FairLogger
-  )
-EndIf()
-
-
-Set(BOOST_LIBS
-  ${Boost_SYSTEM_LIBRARY}
-  ${Boost_PROGRAM_OPTIONS_LIBRARY}
-)
 If(UNIX AND NOT APPLE)
   List(APPEND BOOST_LIBS pthread)
 EndIf()
 
-If(FairRoot_VERSION VERSION_LESS 18.2.0)
-  Add_Definitions(-DHAVE_RootDeserializer)
-EndIf()
+# Set the install path within the build directory
+set(EXECUTABLE_OUTPUT_PATH "${EXECUTABLE_OUTPUT_PATH}/MQ/histogramServer")
+# Set the install path within the installation directory
+set(BIN_DESTINATION bin/MQ/histogramServer)
 
 
-set(DEPENDENCIES_ALL
-  ${DEPENDENCIES}
-  ${FAIR_LIBS}
-  ${BOOST_LIBS}
-)
+set(PUBLIC_DEPS
+  ROOT::Core
+  ROOT::RHTTP
+  )
 
+set(PRIVATE_DEPS
+  CbmFlibFlesTools
+  FairRoot::Base
+  FairMQ::FairMQ
+  ROOT::Gpad
+  ROOT::Hist
+  ROOT::Net
+  ROOT::RIO
+  )
+    
 set(EXE_NAME HistoServer)
 set(SRCS CbmHistoServer.cxx runCbmHistoServer.cxx)
-set(DEPENDENCIES
-  ${DEPENDENCIES_ALL}
-  ${FAIR_LIBS}
-  fles_ipc
-  Core
-  RIO
-  Net
-  Hist
-  RHTTP
-)
-GENERATE_EXECUTABLE()
 
-set(EXECUTABLE_OUTPUT_PATH "${EXECUTABLE_OUTPUT_PATH}/MQ/histogramServer")
+set(PUBLIC_DEPENDENCIES ${PUBLIC_DEPS}) 
+set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPS}) 
+set(INTERFACE_DEPENDENCIES ${INTERFACE_DEPS})
+
+generate_cbm_executable()
 
 set(EXE_NAME MqHistoServer)
 set(SRCS CbmMqHistoServer.cxx runCbmMqHistoServer.cxx)
-set(DEPENDENCIES
-  ${DEPENDENCIES_ALL}
-  ${FAIR_LIBS}
-  CbmFlibFlesTools
-  Core
-  RIO
-  Net
-  Hist
-  Gpad
-  RHTTP
-)
-GENERATE_EXECUTABLE()
+
+set(PUBLIC_DEPENDENCIES ${PUBLIC_DEPS}) 
+set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPS}) 
+set(INTERFACE_DEPENDENCIES ${INTERFACE_DEPS})
+
+generate_cbm_executable()

MQ/histoServer/CbmHistoServer.cxx

-/********************************************************************************
- *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
- *                                                                              *
- *              This software is distributed under the terms of the             *
- *              GNU Lesser General Public Licence (LGPL) version 3,             *
- *                  copied verbatim in the file "LICENSE"                       *
- ********************************************************************************/
-#include <mutex>
+/* Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Florian Uhlig [committer] */
 
 #include "CbmHistoServer.h"
+
+#include <mutex>
 //#include "CbmHistoCanvasDrawer.h"
-#include "FairLogger.h"
-#include "RootSerializer.h"
+#include <Logger.h>
 
 #include "TH1.h"
 #include "THttpServer.h"
 #include "TMessage.h"
 #include "TObjArray.h"
 
+#include "RootSerializer.h"
+
 std::mutex mtx;
 
 CbmHistoServer::CbmHistoServer()
@@ -26,11 +24,14 @@ CbmHistoServer::CbmHistoServer()
   , fNMessages(0)
   , fServer("http:8088")
   //    , fCanvasDrawer(nullptr)
-  , fStopThread(false) {}
+  , fStopThread(false)
+{
+}
 
 CbmHistoServer::~CbmHistoServer() {}
 
-void CbmHistoServer::InitTask() {
+void CbmHistoServer::InitTask()
+{
   OnData(fInputChannelName, &CbmHistoServer::ReceiveData);
 
   /*
@@ -41,13 +42,10 @@ void CbmHistoServer::InitTask() {
 */
 }
 
-bool CbmHistoServer::ReceiveData(FairMQMessagePtr& msg, int /*index*/) {
+bool CbmHistoServer::ReceiveData(FairMQMessagePtr& msg, int /*index*/)
+{
   TObject* tempObject = nullptr;
-#ifdef HAVE_RootDeserializer
-  Deserialize<RootDeserializer>(*msg, tempObject);
-#else
-  Deserialize<RootSerializer>(*msg, tempObject);
-#endif
+  RootSerializer().Deserialize(*msg, tempObject);
 
   if (TString(tempObject->ClassName()).EqualTo("TObjArray")) {
     std::lock_guard<std::mutex> lk(mtx);
@@ -62,7 +60,8 @@ bool CbmHistoServer::ReceiveData(FairMQMessagePtr& msg, int /*index*/) {
         histogram_new = static_cast<TH1*>(histogram->Clone());
         fArrayHisto.Add(histogram_new);
         fServer.Register("Histograms", histogram_new);
-      } else {
+      }
+      else {
         histogram_existing = static_cast<TH1*>(fArrayHisto.At(index1));
         histogram_existing->Add(histogram);
       }
@@ -78,12 +77,14 @@ bool CbmHistoServer::ReceiveData(FairMQMessagePtr& msg, int /*index*/) {
   return true;
 }
 
-void CbmHistoServer::PreRun() {
+void CbmHistoServer::PreRun()
+{
   fStopThread = false;
   fThread     = std::thread(&CbmHistoServer::UpdateHttpServer, this);
 }
 
-void CbmHistoServer::UpdateHttpServer() {
+void CbmHistoServer::UpdateHttpServer()
+{
   while (!fStopThread) {
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
     std::lock_guard<std::mutex> lk(mtx);
@@ -99,12 +100,14 @@ void CbmHistoServer::UpdateHttpServer() {
   }
 }
 
-void CbmHistoServer::PostRun() {
+void CbmHistoServer::PostRun()
+{
   fStopThread = true;
   fThread.join();
 }
 
-int CbmHistoServer::FindHistogram(const std::string& name) {
+int CbmHistoServer::FindHistogram(const std::string& name)
+{
   for (int i = 0; i < fArrayHisto.GetEntriesFast(); i++) {
     TObject* obj = fArrayHisto.At(i);
     if (TString(obj->GetName()).EqualTo(name)) { return i; }

MQ/histoServer/CbmHistoServer.h

-/********************************************************************************
- *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
- *                                                                              *
- *              This software is distributed under the terms of the             *
- *              GNU Lesser General Public Licence (LGPL) version 3,             *
- *                  copied verbatim in the file "LICENSE"                       *
- ********************************************************************************/
+/* Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Florian Uhlig [committer] */
+
 #ifndef FAIRMQEXHISTOSERVER
 #define FAIRMQEXHISTOSERVER
 
@@ -12,10 +9,10 @@
 
 #include "THttpServer.h"
 #include "TObjArray.h"
+#include <thread>
 
 #include <memory>
 #include <string>
-#include <thread>
 
 //class FairMQExHistoCanvasDrawer;