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}
-    {
-      fChannelsToSend.resize(fAllowedChannels.size());
-      for(auto &entry : fChannelsToSend) {
-	entry.push_back("");
-      }
-      fComponentsToSend.resize(fAllowedChannels.size());	
-    }
-	
+CbmMQChannels::CbmMQChannels(std::vector<std::string> allowedChannels) : fAllowedChannels {allowedChannels}
+{
+  fChannelsToSend.resize(fAllowedChannels.size());
+  for (auto& entry : fChannelsToSend) {
+    entry.push_back("");
+  }
+  fComponentsToSend.resize(fAllowedChannels.size());
+}
+
 bool CbmMQChannels::IsChannelNameAllowed(std::string channelName)
 {
-  for(auto const &entry : fAllowedChannels) {
+  for (auto const& entry : fAllowedChannels) {
     std::size_t pos1 = channelName.find(entry);
-    if (pos1!=std::string::npos) {
+    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();
+        std::find(fAllowedChannels.begin(), fAllowedChannels.end(), entry);
+      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()) {
-	fChannelsToSend[idx].at(0) = channelName;
-      } else {
-	fChannelsToSend[idx].push_back(channelName);
+        fChannelsToSend[idx].at(0) = channelName;
+      }
+      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;
+  for (auto const& entry : fAllowedChannels) {
+    LOG(info) << entry;
   }
   LOG(error) << "Stop device.";
   return false;
@@ -55,7 +58,7 @@ bool CbmMQChannels::CheckChannels(FairMQDevice* device)
   // data on this channel.
   int noChannel = device->fChannels.size();
   LOG(info) << "Number of defined output channels: " << noChannel;
-  for(auto const &entry : device->fChannels) {
+  for (auto const& entry : device->fChannels) {
     LOG(info) << "Channel name: " << entry.first;
     if (!IsChannelNameAllowed(entry.first)) return false;
   }

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 <vector>
+#include "FairMQDevice.h"
+
 #include <string>
+#include <vector>
 
-class FairMQDevice;
 
-class CbmMQChannels
-{
- public:
+class CbmMQChannels {
+public:
   CbmMQChannels(std::vector<std::string>);
-  
+
   bool IsChannelNameAllowed(std::string channelName);
   bool CheckChannels(FairMQDevice* device);
-  
+
   std::vector<int> GetComponentsToSend() { return fComponentsToSend; }
   std::vector<std::vector<std::string>> GetChannelsToSend() { return fChannelsToSend; }
-  
- private:      
-  
+
+private:
   std::vector<std::string> fAllowedChannels {};
   std::vector<int> fComponentsToSend {};
-  std::vector<std::vector<std::string>> fChannelsToSend { {} };
-  
+  std::vector<std::vector<std::string>> fChannelsToSend {{}};
 };
 
 #endif

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,72 +18,45 @@ namespace cbm {
       ErrorFound
     };
 
-    enum class State : int {
+    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 {
-        LOG(fatal) <<  "State Change not yet implemented";
-        device->ChangeState(fair::mq::Transition::ErrorFound);                      
       }
-#endif
+      else {
+        LOG(fatal) << "State Change not yet implemented";
+        device->ChangeState(fair::mq::Transition::ErrorFound);
+      }
     }
 
-    void LogState(FairMQDevice* device) {
- #ifdef HAVE_FAIRMQSTATEMACHINE
-//      LOG(info) << "Current State: " <<  FairMQStateMachine::GetCurrentStateName();
-      LOG(info) << "Current State: " <<  device->GetCurrentStateName();
-#else
-      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 {
-         LOG(fatal) <<  "State not yet implemented";
-         device->ChangeState(fair::mq::Transition::ErrorFound);
-         return 0;
-       }
-#endif           
+    void LogState(FairMQDevice* device)
+    {
+      LOG(info) << "Current State: " << device->GetCurrentStateName();
     }
-  }
-}
 
+    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;
+      }
+    }
+  }  // 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,93 +10,82 @@
 #ifndef CBMDEVICEEVENTBUILDERETOFSTAR2019_H_
 #define CBMDEVICEEVENTBUILDERETOFSTAR2019_H_
 
-#include "FairMQDevice.h"
+#include "CbmMqTMessage.h"
 
 #include "Timeslice.hpp"
-#include "TMessage.h"
 
+#include "FairMQDevice.h"
+
+#include "TMessage.h"
 #include "TStopwatch.h"
 
 class CbmStar2019EventBuilderEtofAlgo;
 class CbmStar2019TofPar;
 
-class CbmDeviceEventBuilderEtofStar2019: public FairMQDevice
-{
-  public:
-      CbmDeviceEventBuilderEtofStar2019();
-      virtual ~CbmDeviceEventBuilderEtofStar2019();
+class CbmDeviceEventBuilderEtofStar2019 : public FairMQDevice {
+public:
+  CbmDeviceEventBuilderEtofStar2019();
+  virtual ~CbmDeviceEventBuilderEtofStar2019();
 
-      virtual Bool_t DoUnpack(const fles::Timeslice& ts, size_t component);
-      virtual void Reset();
-      virtual void Finish();
+  virtual Bool_t DoUnpack(const fles::Timeslice& ts, size_t component);
+  virtual void Reset();
+  virtual void Finish();
 
-      void SetParContainers();
+  void SetParContainers();
 
-      Bool_t InitContainers();
+  Bool_t InitContainers();
 
-      Bool_t ReInitContainers();
+  Bool_t ReInitContainers();
 
-      void SetSandboxMode( Bool_t bSandboxMode = kTRUE ){ fbSandboxMode = bSandboxMode; }
-      void SetEventDumpEnable( Bool_t bDumpEna = kTRUE );
+  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*/ ){};
+  /// 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();
-      bool HandleData(FairMQMessagePtr&, int);
-      bool HandleParts(FairMQParts&, int);
-      bool HandleMessage(FairMQMessagePtr&, int);
-      virtual bool SendEvent(std::vector<Int_t>, int);
-      virtual bool SendSubevent(uint,char*,int, int); 
+protected:
+  virtual void InitTask();
+  bool HandleData(FairMQMessagePtr&, int);
+  bool HandleParts(FairMQParts&, int);
+  bool HandleMessage(FairMQMessagePtr&, int);
+  virtual bool SendEvent(std::vector<Int_t>, int);
+  virtual bool SendSubevent(uint, char*, int, int);
 
- 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
+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
 
-      /// Parameters management
-      TList* fParCList;
+  /// Parameters management
+  TList* fParCList;
 
-      /// Statistics & first TS rejection
-      uint64_t fulTsCounter;
-      uint64_t fNumEvt;
+  /// Statistics & first TS rejection
+  uint64_t fulTsCounter;
+  uint64_t fNumEvt;
 
-      bool CheckTimeslice(const fles::Timeslice& ts);
-      bool IsChannelNameAllowed(std::string channelName);
+  bool CheckTimeslice(const fles::Timeslice& ts);
+  bool IsChannelNameAllowed(std::string channelName);
 
-      std::vector<std::string> fAllowedChannels
-	= {"tofcomponent","parameters","etofevts","syscmd"};
-      std::vector<std::vector<std::string>> fChannelsToSend = { {},{},{} };
+  std::vector<std::string> fAllowedChannels             = {"tofcomponent", "parameters", "etofevts", "syscmd"};
+  std::vector<std::vector<std::string>> fChannelsToSend = {{}, {}, {}};
 
-      /// Processing algo
-      CbmStar2019EventBuilderEtofAlgo * fEventBuilderAlgo;
-      TStopwatch fTimer;
+  /// Processing algo
+  CbmStar2019EventBuilderEtofAlgo* fEventBuilderAlgo;
+  TStopwatch fTimer;
 
-      CbmStar2019TofPar* fUnpackPar;      //!
-
-      /// Event dump to binary file
-      std::fstream * fpBinDumpFile;
-      const UInt_t   kuBinDumpBegWord = 0xFEEDBEAF;
-      const UInt_t   kuBinDumpEndWord = 0xFAEBDEEF;
-};
+  CbmStar2019TofPar* fUnpackPar;  //!
 
-// special class to expose protected TMessage constructor
-class CbmMQTMessage : public TMessage
-{
-  public:
-    CbmMQTMessage(void* buf, Int_t len)
-        : TMessage(buf, len)
-    {
-        ResetBit(kIsOwner);
-    }
+  /// Event dump to binary file
+  std::fstream* fpBinDumpFile;
+  const UInt_t kuBinDumpBegWord = 0xFEEDBEAF;
+  const UInt_t kuBinDumpEndWord = 0xFAEBDEEF;
 };
 
 #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,92 +10,91 @@
  */
 
 #include "CbmDeviceTriggerHandlerEtof.h"
+
 #include "CbmMQDefs.h"
 
-#include "FairMQLogger.h"
 #include "FairEventHeader.h"
-#include "FairMQProgOptions.h" // device->fConfig
-#include "FairRuntimeDb.h"
+#include "FairFileHeader.h"
 #include "FairGeoParSet.h"
-#include "FairRootManager.h"
+#include "FairMQLogger.h"
+#include "FairMQProgOptions.h"  // device->fConfig
 #include "FairRootFileSink.h"
+#include "FairRootManager.h"
 #include "FairRunOnline.h"
-#include "FairFileHeader.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 <string>
-#include <iomanip>
-#include <thread> // this_thread::sleep_for
 #include <chrono>
-
+#include <iomanip>
 #include <stdexcept>
-struct InitTaskError : std::runtime_error { using std::runtime_error::runtime_error; };
+#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;
 
 CbmDeviceTriggerHandlerEtof::CbmDeviceTriggerHandlerEtof()
   : fNumMessages(0)
   , fiMsgCnt(0)
-  ,  fbMonitorMode( kFALSE )
-  ,  fbDebugMonitorMode( kFALSE )
-  ,  fbSandboxMode( kFALSE )
-  ,  fbEventDumpEna( kFALSE )
-  ,  fdEvent(0.)
+  , fbMonitorMode(kFALSE)
+  , fbDebugMonitorMode(kFALSE)
+  , fbSandboxMode(kFALSE)
+  , fbEventDumpEna(kFALSE)
+  , fdEvent(0.)
 {
 }
 
-CbmDeviceTriggerHandlerEtof::~CbmDeviceTriggerHandlerEtof()
-{
-
-}
+CbmDeviceTriggerHandlerEtof::~CbmDeviceTriggerHandlerEtof() {}
 
 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
-    // 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.
-    int noChannel = fChannels.size();
-    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);
-      else                      OnData(entry.first, &CbmDeviceTriggerHandlerEtof::HandleMessage);
-    }
-    InitWorkspace();
-} catch (InitTaskError& e) {
- LOG(error) << e.what();
- cbm::mq::ChangeState(this,cbm::mq::Transition::ErrorFound);
+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
+  // 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.
+  int noChannel = fChannels.size();
+  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);
+    else
+      OnData(entry.first, &CbmDeviceTriggerHandlerEtof::HandleMessage);
+  }
+  InitWorkspace();
+}
+catch (InitTaskError& e) {
+  LOG(error) << e.what();
+  cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
 }
 
 bool CbmDeviceTriggerHandlerEtof::IsChannelNameAllowed(std::string channelName)
 {
-  for(auto const &entry : fAllowedChannels) {
+  for (auto const& entry : fAllowedChannels) {
     std::size_t pos1 = channelName.find(entry);
-    if (pos1!=std::string::npos) {
+    if (pos1 != std::string::npos) {
       const vector<std::string>::const_iterator pos =
-         std::find(fAllowedChannels.begin(), fAllowedChannels.end(), entry);
-      const vector<std::string>::size_type idx = pos-fAllowedChannels.begin();
+        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;
 }
@@ -110,52 +113,49 @@ Bool_t CbmDeviceTriggerHandlerEtof::InitWorkspace()
 //bool CbmDeviceTriggerHandlerEtof::HandleData(FairMQMessagePtr& msg, 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
+  // 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" << ", size0: " << parts.At(0)->GetSize();
+  LOG(debug) << "Received message " << fNumMessages << " with " << parts.Size() << " parts"
+             << ", size0: " << parts.At(0)->GetSize();
 
-  uint TrigWord{0}; 
+  uint TrigWord {0};
   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;
+  inputArchiveE >> TrigWord;
 
-  char* pDataBuff = static_cast < char* >(parts.At(1)->GetData());
-  int   iBuffSzByte = parts.At(1)->GetSize();
+  char* pDataBuff = static_cast<char*>(parts.At(1)->GetData());
+  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()
-	      << ", rate: " << dSize*1.E-6/deltatime.count() << "MB/s";
-    dctime=std::chrono::steady_clock::now();
-    dSize=0.;
+  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()
+              << ", rate: " << dSize * 1.E-6 / deltatime.count() << "MB/s";
+    dctime = std::chrono::steady_clock::now();
+    dSize  = 0.;
   }
   fdEvent++;
-  
+
   return kTRUE;
 }
- 
+
 /************************************************************************************/
 
 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];
+  const char* cmd    = (char*) (msg->GetData());
+  const char cmda[4] = {*cmd};
+  LOG(info) << "Handle message " << cmd << ", " << cmd[0];
 
   // only one implemented so far "Stop"
-  if( strcmp(cmda,"STOP") ) {
+  if (strcmp(cmda, "STOP")) {
     cbm::mq::ChangeState(this, cbm::mq::Transition::Ready);
     cbm::mq::LogState(this);
     cbm::mq::ChangeState(this, cbm::mq::Transition::DeviceReady);
@@ -164,11 +164,9 @@ bool CbmDeviceTriggerHandlerEtof::HandleMessage(FairMQMessagePtr& msg, int /*ind
     cbm::mq::LogState(this);
     cbm::mq::ChangeState(this, cbm::mq::Transition::End);
     cbm::mq::LogState(this);
-    //    ChangeState(fair::mq::Transition(STOP)); 
+    //    ChangeState(fair::mq::Transition(STOP));
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-  } 
+  }
 
   return true;
-
 }
-

MQ/eTOF/CbmDeviceTriggerHandlerEtof.h

+/* Copyright (C) 2019 PI-UHd, GSI
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Norbert Herrmann [committer] */
+
 /**
  * CbmDeviceTriggerHandlerStar2019.h
  *
@@ -8,84 +12,69 @@
 #ifndef CBMDEVICETRIGGERHANDLERETOF_H_
 #define CBMDEVICETRIGGERHANDLERETOF_H_
 
-#include "FairMQDevice.h"
+#include "CbmMqTMessage.h"
+#include "CbmTofStarData2019.h"
 
-#include "Timeslice.hpp"
 #include "MicrosliceDescriptor.hpp"
+#include "Timeslice.hpp"
 
-#include "CbmTofStarData2019.h"
+#include "FairMQDevice.h"
 
-#include "TMessage.h"
 #include "Rtypes.h"
 
-#include <vector>
 #include <map>
+#include <vector>
 
-class CbmMQTMessage;
-// Relevant TOF classes  
+// Relevant TOF classes
 
-extern "C" int star_rhicf_write(unsigned int trg_word, void *dta, int bytes);
+extern "C" int star_rhicf_write(unsigned int trg_word, void* dta, int bytes);
 
 // ROOT Classes and includes
 class TString;
 
 // C++ Classes and includes
-#include <vector>
-#include <map>
 #include <list>
+#include <map>
+#include <vector>
 
-class CbmDeviceTriggerHandlerEtof: public FairMQDevice
-{
-  public:
-    CbmDeviceTriggerHandlerEtof();
-    virtual ~CbmDeviceTriggerHandlerEtof();
-
-  protected:
-    virtual void InitTask();
-    bool HandleData(FairMQParts&, int);
-    bool HandleMessage(FairMQMessagePtr&, int);
-
-  private:
+class CbmDeviceTriggerHandlerEtof : public FairMQDevice {
+public:
+  CbmDeviceTriggerHandlerEtof();
+  virtual ~CbmDeviceTriggerHandlerEtof();
 
-   // Variables used for histo filling
+protected:
+  virtual void InitTask();
+  bool HandleData(FairMQParts&, int);
+  bool HandleMessage(FairMQMessagePtr&, int);
 
-   Bool_t IsChannelNameAllowed(std::string channelName);
+private:
+  // Variables used for histo filling
 
-   Bool_t InitWorkspace();
-   Bool_t InitContainers();
+  Bool_t IsChannelNameAllowed(std::string channelName);
 
-   Bool_t ReInitContainers();
+  Bool_t InitWorkspace();
+  Bool_t InitContainers();
 
-   uint64_t fNumMessages;
-   std::vector<std::string> fAllowedChannels = {"tofcomponent","parameters","etofevts","tofhits","syscmd"};
+  Bool_t ReInitContainers();
 
-   // Input variables 
+  uint64_t fNumMessages;
+  std::vector<std::string> fAllowedChannels = {"tofcomponent", "parameters", "etofevts", "tofhits", "syscmd"};
 
-   // Output variables
+  // Input variables
 
-   // 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
-      
-   Double_t fdEvent;
+  // Output variables
 
-   // histograms
+  // 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
 
-};
+  Double_t fdEvent;
 
-// special class to expose protected TMessage constructor
-class CbmMQTMessage : public TMessage
-{
-  public:
-    CbmMQTMessage(void* buf, Int_t len)
-        : TMessage(buf, len)
-    {
-        ResetBit(kIsOwner);
-    }
+  // histograms
 };
 
 #endif /* CBMDEVICETRIGGERHANDLERETOF_H_ */

MQ/eTOF/runEventBuilderEtofStar2019.cxx

-#include "runFairMQDevice.h"
+/* Copyright (C) 2019 PI-UHd, GSI
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Norbert Herrmann [committer] */
+
 #include "CbmDeviceEventBuilderEtofStar2019.h"
 
-#include <string>
 #include <iomanip>
+#include <string>
+
+#include "runFairMQDevice.h"
 
 namespace bpo = boost::program_options;
 using namespace std;
 
-void addCustomOptions(bpo::options_description& options)
-{
-  ;
-}
+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

-#include "runFairMQDevice.h"
+/* Copyright (C) 2019 PI-UHd, GSI
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Norbert Herrmann [committer] */
+
 #include "CbmDeviceTriggerHandlerEtof.h"
 
-#include <string>
 #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");
+  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()