From 3e0c79521f6b86e58cca2b8b9a14960acf992a5c Mon Sep 17 00:00:00 2001
From: Julian <julian.myrcha@cern.ch>
Date: Wed, 28 Jul 2021 16:26:33 +0200
Subject: [PATCH 1/5] add parameters to eve workflow

---
 EventVisualisation/Workflow/CMakeLists.txt    |  37 +++-
 .../include/EveWorkflow/EveConfiguration.h    |  95 ++++++++
 .../include/EveWorkflow/EveWorkflowHelper.h   |  42 ++++
 .../include/EveWorkflow/FileProducer.h        |  18 +-
 .../include/EveWorkflow/O2DPLDisplay.h        |  39 +++-
 .../Workflow/src/EveConfiguration.cxx         |  21 ++
 .../Workflow/src/EveWorkflowHelper.cxx        | 209 ++++++++++++++++++
 .../Workflow/src/FileProducer.cxx             |   6 +-
 .../Workflow/src/O2DPLDisplay.cxx             |  86 +++----
 9 files changed, 484 insertions(+), 69 deletions(-)
 create mode 100644 EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
 create mode 100644 EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
 create mode 100644 EventVisualisation/Workflow/src/EveConfiguration.cxx
 create mode 100644 EventVisualisation/Workflow/src/EveWorkflowHelper.cxx

diff --git a/EventVisualisation/Workflow/CMakeLists.txt b/EventVisualisation/Workflow/CMakeLists.txt
index 635b1ad82e047..0d8da50f6cec9 100644
--- a/EventVisualisation/Workflow/CMakeLists.txt
+++ b/EventVisualisation/Workflow/CMakeLists.txt
@@ -21,18 +21,31 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2"
           COMPONENT_NAME eve
           TARGETVARNAME targetName
           SOURCES
-                                src/O2DPLDisplay.cxx
-                                src/FileProducer.cxx
+                src/O2DPLDisplay.cxx
+                src/FileProducer.cxx
+                src/EveWorkflowHelper.cxx
+                src/EveConfiguration.cxx
           PUBLIC_LINK_LIBRARIES
-                                O2::EventVisualisationBase
-                                O2::EventVisualisationDetectors
-                                O2::GPUO2Interface
-                                O2::GPUWorkflowHelper
-                                O2::DataFormatsGlobalTracking
-                                O2::TPCFastTransformation
-                                O2::TRDBase
-                                O2::TOFBase
-                                O2::TPCReconstruction
-                                O2::GlobalTrackingWorkflowHelpers)
+                O2::DataFormatsGlobalTracking
+                O2::DetectorsRaw
+                O2::DetectorsVertexing
+                O2::EventVisualisationBase
+                O2::EventVisualisationDetectors
+                O2::FrameworkFoundation
+                O2::FT0Workflow
+                O2::GlobalTrackingWorkflowHelpers
+                O2::GlobalTrackingWorkflowReaders
+                O2::GPUO2Interface
+                O2::GPUWorkflowHelper
+                O2::ITSMFTWorkflow
+                O2::MFTWorkflow
+                O2::TOFBase
+                O2::TOFWorkflowIO
+                O2::TPCFastTransformation
+                O2::TPCReconstruction
+                O2::TPCWorkflow
+                O2::TRDBase
+                O2::TRDWorkflowIO
+          )
   target_include_directories(${targetName} PUBLIC "include")
 endif()
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h b/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
new file mode 100644
index 0000000000000..0271dd2040efc
--- /dev/null
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
@@ -0,0 +1,95 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file
+/// \author David Rohr (as O2DPLConfiguration.h)
+/// \author Julian Myrcha
+
+#ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVECONFIGURATION_H
+#define ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVECONFIGURATION_H
+
+// Some defines denoting that we are compiling for O2
+#ifndef GPUCA_HAVE_O2HEADERS
+#define GPUCA_HAVE_O2HEADERS
+#endif
+#ifndef GPUCA_TPC_GEOMETRY_O2
+#define GPUCA_TPC_GEOMETRY_O2
+#endif
+#ifndef GPUCA_O2_INTERFACE
+#define GPUCA_O2_INTERFACE
+#endif
+
+#include <memory>
+#include <array>
+#include <vector>
+#include <functional>
+#include <gsl/gsl>
+#include <GPUO2Interface.h>
+#include "GPUSettings.h"
+#include "DataFormatsTPC/Constants.h"
+
+class TH1F;
+
+namespace o2
+{
+namespace event_visualisation
+{
+template <class T>
+struct DefaultPtr {
+  typedef T type;
+};
+template <class T>
+struct ConstPtr {
+  typedef const T type;
+};
+
+template <template <typename T> class S>
+struct CalibObjectsTemplate {
+  //typename S<TPCFastTransform>::type* fastTransform = nullptr;
+  typename S<o2::base::MatLayerCylSet>::type* matLUT = nullptr;
+  typename S<o2::trd::GeometryFlat>::type* trdGeometry = nullptr;
+  //typename S<TPCdEdxCalibrationSplines>::type* dEdxSplines = nullptr;
+  //typename S<TPCPadGainCalib>::type* tpcPadGain = nullptr;
+  typename S<o2::base::PropagatorImpl<float>>::type* o2Propagator = nullptr;
+  typename S<o2::itsmft::TopologyDictionary>::type* itsPatternDict = nullptr;
+};
+
+typedef CalibObjectsTemplate<DefaultPtr> CalibObjects; // NOTE: These 2 must have identical layout since they are memcopied
+typedef CalibObjectsTemplate<ConstPtr> CalibObjectsConst;
+
+struct SettingsGRP {
+  // All new members must be sizeof(int) resp. sizeof(float) for alignment reasons!
+  float solenoidBz = -5.00668;  // solenoid field strength
+  int constBz = 0;              // for test-MC events with constant Bz
+  int homemadeEvents = 0;       // Toy-MC events
+  int continuousMaxTimeBin = 0; // 0 for triggered events, -1 for default of 23ms
+  int needsClusterer = 0;       // Set to true if the data requires the clusterizer
+};
+
+struct SettingsProcessing {
+  bool runMC;
+};
+
+// Full configuration structure with all available settings of GPU...
+struct EveConfiguration {
+  EveConfiguration() = default;
+  ~EveConfiguration() = default;
+  EveConfiguration(const EveConfiguration&) = default;
+  SettingsGRP configGRP;
+  CalibObjectsConst configCalib;
+  SettingsProcessing configProcessing;
+  void ReadConfigurableParam();
+};
+
+} // namespace event_visualisation
+} // namespace o2
+
+#endif
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
new file mode 100644
index 0000000000000..58fc2f3115b2a
--- /dev/null
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
@@ -0,0 +1,42 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file   EveWorkflowHelper.h
+/// \author julian.myrcha@cern.ch
+
+#ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVEWORKFLOWHELPER_H
+#define ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVEWORKFLOWHELPER_H
+
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "DataFormatsGlobalTracking/RecoContainer.h"
+#include "GPUDataTypes.h"
+//#include "GPUCommonMath.h"
+#include "EveWorkflow/EveConfiguration.h"
+
+namespace o2::event_visualisation
+{
+class EveWorkflowHelper
+{
+  using GID = o2::dataformats::GlobalTrackID;
+
+ public:
+  struct tmpDataContainer {
+    std::vector<o2::BaseCluster<float>> ITSClustersArray;
+    std::vector<int> tpcLinkITS, tpcLinkTRD, tpcLinkTOF;
+    std::vector<const o2::track::TrackParCov*> globalTracks;
+    std::vector<float> globalTrackTimes;
+  };
+  static std::shared_ptr<const tmpDataContainer> fillIOPtr(gpu::GPUTrackingInOutPointers& ioPtr, const o2::globaltracking::RecoContainer& recoCont, bool useMC, const CalibObjectsConst* calib = nullptr, GID::mask_t maskCl = GID::MASK_ALL, GID::mask_t maskTrk = GID::MASK_ALL, GID::mask_t maskMatch = GID::MASK_ALL);
+};
+} // namespace o2::event_visualisation
+
+#endif //ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVEWORKFLOWHELPER_H
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h b/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h
index 50cf537d1f1cf..71b2ee4d51a42 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h
@@ -13,23 +13,33 @@
 /// \file    FileProducer.h
 /// \author julian.myrcha@cern.ch
 
-#ifndef FILEPRODUCER_FILEPRODUCER_H
-#define FILEPRODUCER_FILEPRODUCER_H
+#ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_FILEPRODUCER_H
+#define ALICE_O2_EVENTVISUALISATION_WORKFLOW_FILEPRODUCER_H
 
 #include <string>
 #include <deque>
 
+namespace o2
+{
+namespace event_visualisation
+{
 class FileProducer
 {
  private:
   static std::deque<std::string> load(const std::string& path);
+
   size_t mFilesInFolder;
   std::string mPath;
   std::string mName;
 
  public:
-  explicit FileProducer(const std::string& path, const std::string& name = "tracks{}.json", int filesInFolder = 10);
+  explicit FileProducer(const std::string& path, int filesInFolder = 10,
+                        const std::string& name = "tracks{}.json");
+
   [[nodiscard]] std::string newFileName() const;
 };
 
-#endif //FILEPRODUCER_FILEPRODUCER_H
+} // namespace event_visualisation
+} // namespace o2
+
+#endif //ALICE_O2_EVENTVISUALISATION_WORKFLOW_FILEPRODUCER_H
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
index fadc7db6b4d8b..d642fd1accf2f 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
@@ -9,10 +9,15 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#ifndef O2_GPU_DPL_DISPLAY_H
-#define O2_GPU_DPL_DISPLAY_H
+///
+/// \file   EveWorkflowHelper.h
+/// \author julian.myrcha@cern.ch
+
+#ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_O2DPLDISPLAY_H
+#define ALICE_O2_EVENTVISUALISATION_WORKFLOW_O2DPLDISPLAY_H
 
 #include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "EveWorkflow/EveConfiguration.h"
 #include "Framework/Task.h"
 #include <memory>
 
@@ -20,42 +25,52 @@ namespace o2::trd
 {
 class GeometryFlat;
 }
+
 namespace o2::globaltracking
 {
 struct DataRequest;
 }
+
 namespace o2::itsmft
 {
 class TopologyDictionary;
 }
 
-namespace o2::gpu
+namespace o2::event_visualisation
 {
-class GPUO2InterfaceDisplay;
-struct GPUO2InterfaceConfiguration;
 class TPCFastTransform;
 
-class O2GPUDPLDisplaySpec : public o2::framework::Task
+class O2DPLDisplaySpec : public o2::framework::Task
 {
  public:
-  O2GPUDPLDisplaySpec(bool useMC, o2::dataformats::GlobalTrackID::mask_t trkMask, o2::dataformats::GlobalTrackID::mask_t clMask, std::shared_ptr<o2::globaltracking::DataRequest> dataRequest) : mUseMC(useMC), mTrkMask(trkMask), mClMask(clMask), mDataRequest(dataRequest) {}
-  ~O2GPUDPLDisplaySpec() override = default;
+  O2DPLDisplaySpec(bool useMC, o2::dataformats::GlobalTrackID::mask_t trkMask,
+                   o2::dataformats::GlobalTrackID::mask_t clMask,
+                   std::shared_ptr<o2::globaltracking::DataRequest> dataRequest, std::string jsonPath,
+                   std::chrono::milliseconds timeInterval, int numberOfFiles)
+    : mUseMC(useMC), mTrkMask(trkMask), mClMask(clMask), mDataRequest(dataRequest), mJsonPath(jsonPath), mTimeInteval(timeInterval), mNumberOfFiles(numberOfFiles)
+  {
+    this->mTimeStamp = std::chrono::high_resolution_clock::now() - timeInterval; // first run meets condition
+  }
+  ~O2DPLDisplaySpec() override = default;
   void init(o2::framework::InitContext& ic) final;
   void run(o2::framework::ProcessingContext& pc) final;
   void endOfStream(o2::framework::EndOfStreamContext& ec) final;
 
  private:
   bool mUseMC = false;
+  std::string mJsonPath;                  // folder where files are stored
+  std::chrono::milliseconds mTimeInteval; // minimal interval between files in miliseconds
+  int mNumberOfFiles;
+  std::chrono::time_point<std::chrono::high_resolution_clock> mTimeStamp;
+
   o2::dataformats::GlobalTrackID::mask_t mTrkMask;
   o2::dataformats::GlobalTrackID::mask_t mClMask;
-  //std::unique_ptr<GPUO2InterfaceDisplay> mDisplay;
-  std::unique_ptr<GPUO2InterfaceConfiguration> mConfig;
-  std::unique_ptr<TPCFastTransform> mFastTransform;
+  std::unique_ptr<EveConfiguration> mConfig;
   std::unique_ptr<o2::trd::GeometryFlat> mTrdGeo;
   std::unique_ptr<o2::itsmft::TopologyDictionary> mITSDict;
   std::shared_ptr<o2::globaltracking::DataRequest> mDataRequest;
 };
 
-} // namespace o2::gpu
+} // namespace o2::event_visualisation
 
 #endif
diff --git a/EventVisualisation/Workflow/src/EveConfiguration.cxx b/EventVisualisation/Workflow/src/EveConfiguration.cxx
new file mode 100644
index 0000000000000..259009503cc75
--- /dev/null
+++ b/EventVisualisation/Workflow/src/EveConfiguration.cxx
@@ -0,0 +1,21 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file EveConfiguration.cxx
+/// \author julian.myrcha@cern.ch
+
+#include "EveWorkflow/EveConfiguration.h"
+
+using namespace o2::event_visualisation;
+
+void EveConfiguration::ReadConfigurableParam()
+{
+}
diff --git a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
new file mode 100644
index 0000000000000..3a620016a93a3
--- /dev/null
+++ b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
@@ -0,0 +1,209 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file EveWorkflowHelper.cxx
+/// \author David Rohr
+/// \author julian.myrcha@cern.ch
+
+#include <EveWorkflow/EveWorkflowHelper.h>
+#include "DataFormatsTRD/TrackTRD.h"
+#include "ITStracking/IOUtils.h"
+#include "DataFormatsGlobalTracking/RecoContainerCreateTracksVariadic.h"
+#include <type_traits>
+
+using namespace o2::event_visualisation;
+
+std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContainer>
+  o2::event_visualisation::EveWorkflowHelper::fillIOPtr(gpu::GPUTrackingInOutPointers& ioPtr,
+                                                        const o2::globaltracking::RecoContainer& recoCont, bool useMC,
+                                                        const CalibObjectsConst* calib, GID::mask_t maskCl,
+                                                        GID::mask_t maskTrk, GID::mask_t maskMatch)
+{
+  auto retVal = std::make_shared<tmpDataContainer>();
+
+  if (maskCl[GID::ITS] && ioPtr.nItsClusters == 0) {
+    const auto& ITSClusterROFRec = recoCont.getITSClustersROFRecords();
+    const auto& clusITS = recoCont.getITSClusters();
+    if (clusITS.size() && ITSClusterROFRec.size()) {
+      if (calib && calib->itsPatternDict) {
+        const auto& patterns = recoCont.getITSClustersPatterns();
+        auto pattIt = patterns.begin();
+        retVal->ITSClustersArray.reserve(clusITS.size());
+        o2::its::ioutils::convertCompactClusters(clusITS, pattIt, retVal->ITSClustersArray, *calib->itsPatternDict);
+        ioPtr.itsClusters = retVal->ITSClustersArray.data();
+      }
+      ioPtr.nItsClusters = clusITS.size();
+      ioPtr.itsCompClusters = clusITS.data();
+      ioPtr.nItsClusterROF = ITSClusterROFRec.size();
+      ioPtr.itsClusterROF = ITSClusterROFRec.data();
+      if (useMC) {
+        const auto& ITSClsLabels = recoCont.mcITSClusters.get();
+        ioPtr.itsClusterMC = ITSClsLabels;
+      }
+    }
+    //LOG(info) << "Got " << ioPtr.nItsClusters << " ITS Clusters";
+  }
+  if (maskTrk[GID::ITS] && ioPtr.nItsTracks == 0) {
+    const auto& ITSTracksArray = recoCont.getITSTracks();
+    const auto& ITSTrackROFRec = recoCont.getITSTracksROFRecords();
+    if (ITSTracksArray.size() && ITSTrackROFRec.size()) {
+      const auto& ITSTrackClusIdx = recoCont.getITSTracksClusterRefs();
+      ioPtr.nItsTracks = ITSTracksArray.size();
+      ioPtr.itsTracks = ITSTracksArray.data();
+      ioPtr.itsTrackClusIdx = ITSTrackClusIdx.data();
+      ioPtr.nItsTrackROF = ITSTrackROFRec.size();
+      ioPtr.itsTrackROF = ITSTrackROFRec.data();
+      if (useMC) {
+        const auto& ITSTrkLabels = recoCont.getITSTracksMCLabels();
+        ioPtr.itsTrackMC = ITSTrkLabels.data();
+      }
+    }
+    //LOG(info) << "Got " << ioPtr.nItsTracks << " ITS Tracks";
+  }
+
+  if (maskTrk[GID::ITSTPC] && ioPtr.nTracksTPCITSO2 == 0) {
+    const auto& trkITSTPC = recoCont.getTPCITSTracks();
+    if (trkITSTPC.size()) {
+      ioPtr.nTracksTPCITSO2 = trkITSTPC.size();
+      ioPtr.tracksTPCITSO2 = trkITSTPC.data();
+    }
+    //LOG(info) << "Got " << ioPtr.nTracksTPCITSO2 << " ITS-TPC Tracks";
+  }
+
+  if (maskCl[GID::TOF] && ioPtr.nTOFClusters == 0) {
+    const auto& tofClusters = recoCont.getTOFClusters();
+    if (tofClusters.size()) {
+      ioPtr.nTOFClusters = tofClusters.size();
+      ioPtr.tofClusters = tofClusters.data();
+    }
+    //LOG(info) << "Got " << ioPtr.nTOFClusters << " TOF Clusters";
+  }
+
+  if ((maskMatch[GID::TOF] || maskMatch[GID::ITSTPCTOF] || maskMatch[GID::ITSTPCTRDTOF]) && ioPtr.nTOFMatches == 0) {
+    const auto& tofMatches = recoCont.getTOFMatches();
+    if (tofMatches.size()) {
+      ioPtr.nTOFMatches = tofMatches.size();
+      ioPtr.tofMatches = tofMatches.data();
+    }
+    //LOG(info) << "Got " << ioPtr.nTOFMatches << " TOF Matches";
+  }
+
+  if (maskMatch[GID::TPCTOF] && ioPtr.nTPCTOFMatches == 0) {
+    const auto& tpctofMatches = recoCont.getTPCTOFMatches();
+    if (tpctofMatches.size()) {
+      ioPtr.nTPCTOFMatches = tpctofMatches.size();
+      ioPtr.tpctofMatches = tpctofMatches.data();
+    }
+    //LOG(info) << "Got " << ioPtr.nTPCTOFMatches << " TPC-TOF Matches";
+  }
+
+  if (maskCl[GID::TRD]) {
+    recoCont.inputsTRD->fillGPUIOPtr(&ioPtr);
+    //LOG(info) << "Got " << ioPtr.nTRDTracklets << " TRD Tracklets";
+  }
+
+  if (maskTrk[GID::ITSTPCTRD] && ioPtr.nTRDTracksITSTPCTRD == 0) {
+    const auto& trdTracks = recoCont.getITSTPCTRDTracks<o2::trd::TrackTRD>();
+    if (trdTracks.size()) {
+      ioPtr.nTRDTracksITSTPCTRD = trdTracks.size();
+      ioPtr.trdTracksITSTPCTRD = trdTracks.data();
+    }
+    //LOG(info) << "Got " << ioPtr.nTRDTracksITSTPCTRD << " ITS-TPC-TRD Tracks";
+  }
+
+  if (maskTrk[GID::TPCTRD] && ioPtr.nTRDTracksTPCTRD == 0) {
+    const auto& trdTracks = recoCont.getTPCTRDTracks<o2::trd::TrackTRD>();
+    if (trdTracks.size()) {
+      ioPtr.nTRDTracksTPCTRD = trdTracks.size();
+      ioPtr.trdTracksTPCTRD = trdTracks.data();
+    }
+    //LOG(info) << "Got " << ioPtr.nTRDTracksTPCTRD << " TPC-TRD Tracks";
+  }
+
+  if (maskCl[GID::TPC] && ioPtr.clustersNative == nullptr) {
+    ioPtr.clustersNative = &recoCont.getTPCClusters();
+    //LOG(info) << "Got " << ioPtr.clustersNative->nClustersTotal << " TPC Clusters";
+  }
+
+  if (maskTrk[GID::TPC] && ioPtr.nOutputTracksTPCO2 == 0) {
+    const auto& tpcTracks = recoCont.getTPCTracks();
+    const auto& tpcClusRefs = recoCont.getTPCTracksClusterRefs();
+    ioPtr.outputTracksTPCO2 = tpcTracks.data();
+    ioPtr.nOutputTracksTPCO2 = tpcTracks.size();
+    ioPtr.outputClusRefsTPCO2 = tpcClusRefs.data();
+    ioPtr.nOutputClusRefsTPCO2 = tpcClusRefs.size();
+    if (useMC) {
+      const auto& tpcTracksMC = recoCont.getTPCTracksMCLabels();
+      ioPtr.outputTracksTPCO2MC = tpcTracksMC.data();
+    }
+    if (ioPtr.nTracksTPCITSO2) {
+      retVal->tpcLinkITS.resize(ioPtr.nOutputTracksTPCO2, -1);
+      ioPtr.tpcLinkITS = retVal->tpcLinkITS.data();
+    }
+    if (ioPtr.nTOFMatches || ioPtr.nTPCTOFMatches) {
+      retVal->tpcLinkTOF.resize(ioPtr.nOutputTracksTPCO2, -1);
+      ioPtr.tpcLinkTOF = retVal->tpcLinkTOF.data();
+    }
+    if (ioPtr.nTRDTracksITSTPCTRD || ioPtr.nTRDTracksTPCTRD) {
+      retVal->tpcLinkTRD.resize(ioPtr.nOutputTracksTPCO2, -1);
+      ioPtr.tpcLinkTRD = retVal->tpcLinkTRD.data();
+    }
+    //LOG(info) << "Got " << ioPtr.nOutputTracksTPCO2 << " TPC Tracks";
+  }
+
+  auto creator = [maskTrk, &ioPtr, &recoCont, &retVal](auto& trk, GID gid, float time, float) {
+    if (gid.getSource() == GID::ITSTPCTOF) {
+      if (maskTrk[GID::TPC] && ioPtr.nTracksTPCITSO2) {
+        const auto& match = recoCont.getTOFMatch(gid);
+        const auto& trkItsTPC = ioPtr.tracksTPCITSO2[match.getTrackIndex()];
+        if (retVal->tpcLinkTOF.size()) {
+          retVal->tpcLinkTOF[trkItsTPC.getRefTPC().getIndex()] = match.getTOFClIndex();
+        }
+        if (retVal->tpcLinkITS.size()) {
+          retVal->tpcLinkITS[trkItsTPC.getRefTPC().getIndex()] = trkItsTPC.getRefITS().getIndex();
+        }
+      }
+    } else if constexpr (isTPCTrack<decltype(trk)>()) {
+      time = trk.getTime0();
+    } else if constexpr (isTPCITSTrack<decltype(trk)>()) {
+      if (maskTrk[GID::TPC] && retVal->tpcLinkITS.size()) {
+        retVal->tpcLinkITS[trk.getRefTPC().getIndex()] = trk.getRefITS().getIndex();
+      }
+    } else if constexpr (isTPCTOFTrack<decltype(trk)>()) {
+      if (maskTrk[GID::TPC] && ioPtr.nTPCTOFMatches && retVal->tpcLinkTOF.size()) {
+        const auto& match = ioPtr.tpctofMatches[trk.getRefMatch()];
+        retVal->tpcLinkTOF[match.getTrackIndex()] = match.getTOFClIndex();
+      }
+    }
+    if constexpr (std::is_base_of_v<o2::track::TrackParCov, std::decay_t<decltype(trk)>>) {
+      retVal->globalTracks.emplace_back(&trk);
+      retVal->globalTrackTimes.emplace_back(time);
+      return true;
+    } else {
+      return false;
+    }
+  };
+  recoCont.createTracksVariadic(creator);
+  if (maskTrk[GID::TPC] && retVal->tpcLinkTRD.size()) {
+    for (unsigned int i = 0; i < ioPtr.nTRDTracksTPCTRD; i++) { // TODO: This should be handled by the createTracks logic, but so far it lacks the TRD tracks
+      retVal->tpcLinkTRD[ioPtr.trdTracksTPCTRD[i].getRefGlobalTrackId().getIndex()] = i;
+    }
+    if (ioPtr.nTracksTPCITSO2) {
+      for (unsigned int i = 0; i < ioPtr.nTRDTracksITSTPCTRD; i++) {
+        retVal->tpcLinkTRD[ioPtr.tracksTPCITSO2[ioPtr.trdTracksITSTPCTRD[i].getRefGlobalTrackId().getIndex()].getRefTPC().getIndex()] = i | 0x40000000;
+      }
+    }
+  }
+  ioPtr.globalTracks = retVal->globalTracks.data();
+  ioPtr.globalTrackTimes = retVal->globalTrackTimes.data();
+
+  return std::move(retVal);
+}
diff --git a/EventVisualisation/Workflow/src/FileProducer.cxx b/EventVisualisation/Workflow/src/FileProducer.cxx
index f957dc0635877..c14a382b1ca55 100644
--- a/EventVisualisation/Workflow/src/FileProducer.cxx
+++ b/EventVisualisation/Workflow/src/FileProducer.cxx
@@ -14,6 +14,7 @@
 /// \author julian.myrcha@cern.ch
 
 #include "EveWorkflow/FileProducer.h"
+
 #include <deque>
 #include <iostream>
 #include <chrono>
@@ -22,6 +23,8 @@
 #include <algorithm>
 
 using namespace std;
+using namespace o2::event_visualisation;
+
 using std::cout;
 using std::endl;
 using std::chrono::duration_cast;
@@ -41,11 +44,12 @@ std::deque<std::string> FileProducer::load(const std::string& path)
   return result;
 }
 
-FileProducer::FileProducer(const std::string& path, const std::string& name, int filesInFolder)
+FileProducer::FileProducer(const std::string& path, int filesInFolder, const std::string& name)
 {
   this->mFilesInFolder = filesInFolder;
   this->mPath = path;
   this->mName = name;
+  std::filesystem::create_directories(this->mPath); // create folder if not exists (fails if no rights)
 }
 
 std::string FileProducer::newFileName() const
diff --git a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
index da5da2f63e504..c70a0d82c7f6c 100644
--- a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
+++ b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
@@ -9,40 +9,45 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+/// \file
+/// \author David Rohr (as O2DPLConfiguration.h)
+/// \author Julian Myrcha
+
 #include "EveWorkflow/O2DPLDisplay.h"
+#include "EveWorkflow/EveConfiguration.h"
 #include "EveWorkflow/FileProducer.h"
+#include "EveWorkflow/EveWorkflowHelper.h"
 #include "EventVisualisationDataConverter/VisualisationTrack.h"
 #include "EventVisualisationDataConverter/VisualisationEvent.h"
-#include "Framework/ConfigParamSpec.h"
+
+#include "DetectorsBase/GeometryManager.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
+#include "DataFormatsTPC/WorkflowHelper.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "DetectorsCommonDataFormats/NameConf.h"
-#include "DetectorsBase/GeometryManager.h"
+#include "DetectorsBase/Propagator.h"
+#include "Framework/ConfigParamSpec.h"
+#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
+#include "ITSBase/GeometryTGeo.h"
 #include "TRDBase/GeometryFlat.h"
-#include "TRDBase/Geometry.h"
 #include "TOFBase/Geo.h"
-#include "ITSBase/GeometryTGeo.h"
-#include "DetectorsBase/Propagator.h"
-#include "GPUO2InterfaceDisplay.h"
-#include "GPUO2InterfaceConfiguration.h"
 #include "TPCFastTransform.h"
-#include "TPCReconstruction/TPCFastTransformHelperO2.h"
-#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
-#include "DataFormatsTPC/WorkflowHelper.h"
-#include "DataFormatsTRD/RecoInputContainer.h"
-#include "GPUWorkflowHelper/GPUWorkflowHelper.h"
-#include "DataFormatsITSMFT/TopologyDictionary.h"
+#include "TRDBase/Geometry.h"
 
+using namespace o2::event_visualisation;
 using namespace o2::framework;
 using namespace o2::dataformats;
 using namespace o2::globaltracking;
-using namespace o2::gpu;
 using namespace o2::tpc;
 using namespace o2::trd;
 
 void customize(std::vector<ConfigParamSpec>& workflowOptions)
 {
   std::vector<o2::framework::ConfigParamSpec> options{
+    {"jsons-folder", VariantType::String, "jsons", {"name of the folder to store json files"}},
+    {"number-of_files", VariantType::Int, 300, {"maximum number of json files in folder"}},
+    {"time-interval", VariantType::Int, 5000, {"time interval in milliseconds between stored files"}},
     {"enable-mc", o2::framework::VariantType::Bool, false, {"enable visualization of MC data"}},
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable visualization of MC data"}}, // for compatibility, overrides enable-mc
     {"display-clusters", VariantType::String, "ITS,TPC,TRD,TOF", {"comma-separated list of clusters to display"}},
@@ -53,22 +58,18 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 
   std::swap(workflowOptions, options);
 }
-
 #include "Framework/runDataProcessing.h"
 
-void O2GPUDPLDisplaySpec::init(InitContext& ic)
+void O2DPLDisplaySpec::init(InitContext& ic)
 {
   const auto grp = o2::parameters::GRPObject::loadFrom();
   o2::base::GeometryManager::loadGeometry();
   o2::base::Propagator::initFieldFromGRP();
-  mConfig.reset(new GPUO2InterfaceConfiguration);
+  mConfig.reset(new EveConfiguration);
   mConfig->configGRP.solenoidBz = 5.00668f * grp->getL3Current() / 30000.;
   mConfig->configGRP.continuousMaxTimeBin = grp->isDetContinuousReadOut(o2::detectors::DetID::TPC) ? -1 : 0; // Number of timebins in timeframe if continuous, 0 otherwise
   mConfig->ReadConfigurableParam();
 
-  mFastTransform = std::move(TPCFastTransformHelperO2::instance()->create(0));
-  mConfig->configCalib.fastTransform = mFastTransform.get();
-
   auto gm = o2::trd::Geometry::instance();
   gm->createPadPlaneArray();
   gm->createClusterMatrixArray();
@@ -77,26 +78,19 @@ void O2GPUDPLDisplaySpec::init(InitContext& ic)
 
   mITSDict = std::make_unique<o2::itsmft::TopologyDictionary>();
   mConfig->configCalib.itsPatternDict = mITSDict.get();
-
   mConfig->configProcessing.runMC = mUseMC;
 
   o2::tof::Geo::Init();
 
-  o2::its::GeometryTGeo::Instance()->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G, o2::math_utils::TransformType::L2G, o2::math_utils::TransformType::T2L));
-
-  //mDisplay.reset(new GPUO2InterfaceDisplay(mConfig.get()));
+  o2::its::GeometryTGeo::Instance()->fillMatrixCache(
+    o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2GRot,
+                             o2::math_utils::TransformType::T2G,
+                             o2::math_utils::TransformType::L2G,
+                             o2::math_utils::TransformType::T2L));
 }
 
-struct GPUWorkflowHelper::tmpDataContainer {
-  std::vector<o2::BaseCluster<float>> ITSClustersArray;
-  std::vector<int> tpcLinkITS, tpcLinkTRD, tpcLinkTOF;
-  std::vector<const o2::track::TrackParCov*> globalTracks;
-  std::vector<float> globalTrackTimes;
-};
-
 using GID = o2::dataformats::GlobalTrackID;
 using PNT = std::array<float, 3>;
-
 std::vector<PNT> getTrackPoints(const o2::track::TrackPar& trc, float minR, float maxR, float maxStep)
 
 {
@@ -132,17 +126,25 @@ std::vector<PNT> getTrackPoints(const o2::track::TrackPar& trc, float minR, floa
   return pnts;
 }
 
-void O2GPUDPLDisplaySpec::run(ProcessingContext& pc)
+void O2DPLDisplaySpec::run(ProcessingContext& pc)
 {
+  // filtering out any run which occur before reaching next time interval
+  std::chrono::time_point<std::chrono::high_resolution_clock> currentTime = std::chrono::high_resolution_clock::now();
+  std::chrono::duration<double> elapsed = currentTime - this->mTimeStamp;
+  if (elapsed < this->mTimeInteval) {
+    return; // skip this run - it is too often
+  }
+  this->mTimeStamp = currentTime;
+
   o2::globaltracking::RecoContainer recoData;
   recoData.collectData(pc, *mDataRequest);
-  GPUTrackingInOutPointers ptrs;
-  auto cnt = GPUWorkflowHelper::fillIOPtr(ptrs, recoData, mUseMC, &(mConfig->configCalib), mClMask, mTrkMask, mTrkMask);
+  gpu::GPUTrackingInOutPointers ptrs;
+  auto cnt = EveWorkflowHelper::fillIOPtr(ptrs, recoData, mUseMC, &(mConfig->configCalib), mClMask, mTrkMask, mTrkMask);
 
   std::cout << cnt->globalTracks.size() << std::endl;
   o2::event_visualisation::VisualisationEvent vEvent;
 
-  for (int i = 0; i < cnt->globalTracks.size(); i++) {
+  for (unsigned int i = 0; i < cnt->globalTracks.size(); i++) {
     auto tr = cnt->globalTracks[i];
     std::cout << tr->getX() << std::endl;
     float rMax = 385;
@@ -170,11 +172,11 @@ void O2GPUDPLDisplaySpec::run(ProcessingContext& pc)
     }
   }
 
-  FileProducer producer("./jsons");
+  FileProducer producer(this->mJsonPath, this->mNumberOfFiles);
   vEvent.toFile(producer.newFileName());
 }
 
-void O2GPUDPLDisplaySpec::endOfStream(EndOfStreamContext& ec)
+void O2DPLDisplaySpec::endOfStream(EndOfStreamContext& ec)
 {
 }
 
@@ -185,6 +187,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
 
   bool useMC = cfgc.options().get<bool>("enable-mc") && !cfgc.options().get<bool>("disable-mc");
+  std::string jsonFolder = cfgc.options().get<std::string>("jsons-folder");
+  std::chrono::milliseconds timeInterval(cfgc.options().get<int>("time-interval"));
+  int numberOfFiles = cfgc.options().get<int>("number-of_files");
+
   GlobalTrackID::mask_t srcTrk = GlobalTrackID::getSourcesMask(cfgc.options().get<std::string>("display-tracks"));
   GlobalTrackID::mask_t srcCl = GlobalTrackID::getSourcesMask(cfgc.options().get<std::string>("display-clusters"));
   if (!srcTrk.any() && !srcCl.any()) {
@@ -199,10 +205,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   }
 
   specs.emplace_back(DataProcessorSpec{
-    "o2-gpu-display",
+    "o2-eve-display",
     dataRequest->inputs,
     {},
-    AlgorithmSpec{adaptFromTask<O2GPUDPLDisplaySpec>(useMC, srcTrk, srcCl, dataRequest)}});
+    AlgorithmSpec{adaptFromTask<O2DPLDisplaySpec>(useMC, srcTrk, srcCl, dataRequest, jsonFolder, timeInterval, numberOfFiles)}});
 
   return std::move(specs);
 }

From 6aec890a248d53b1f2974ca87681063b17371023 Mon Sep 17 00:00:00 2001
From: Julian <julian.myrcha@cern.ch>
Date: Thu, 29 Jul 2021 19:45:28 +0200
Subject: [PATCH 2/5] removed dependency from gpu added parameters for maximum
 number of tracks and host filtering

---
 EventVisualisation/Workflow/CMakeLists.txt    |   2 -
 .../include/EveWorkflow/EveConfiguration.h    |  21 +--
 .../include/EveWorkflow/EveWorkflowHelper.h   |   5 +-
 .../include/EveWorkflow/O2DPLDisplay.h        |   8 +-
 .../Workflow/src/EveWorkflowHelper.cxx        | 153 +++++++-----------
 .../Workflow/src/O2DPLDisplay.cxx             |  28 +++-
 6 files changed, 88 insertions(+), 129 deletions(-)

diff --git a/EventVisualisation/Workflow/CMakeLists.txt b/EventVisualisation/Workflow/CMakeLists.txt
index 0d8da50f6cec9..cd894edb6cd9e 100644
--- a/EventVisualisation/Workflow/CMakeLists.txt
+++ b/EventVisualisation/Workflow/CMakeLists.txt
@@ -35,8 +35,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2"
                 O2::FT0Workflow
                 O2::GlobalTrackingWorkflowHelpers
                 O2::GlobalTrackingWorkflowReaders
-                O2::GPUO2Interface
-                O2::GPUWorkflowHelper
                 O2::ITSMFTWorkflow
                 O2::MFTWorkflow
                 O2::TOFBase
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h b/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
index 0271dd2040efc..8ee4fc74c0cd0 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
@@ -16,25 +16,15 @@
 #ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVECONFIGURATION_H
 #define ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVECONFIGURATION_H
 
-// Some defines denoting that we are compiling for O2
-#ifndef GPUCA_HAVE_O2HEADERS
-#define GPUCA_HAVE_O2HEADERS
-#endif
-#ifndef GPUCA_TPC_GEOMETRY_O2
-#define GPUCA_TPC_GEOMETRY_O2
-#endif
-#ifndef GPUCA_O2_INTERFACE
-#define GPUCA_O2_INTERFACE
-#endif
+#include "DataFormatsTPC/Constants.h"
+#include "TRDBase/GeometryFlat.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
 
 #include <memory>
 #include <array>
 #include <vector>
 #include <functional>
 #include <gsl/gsl>
-#include <GPUO2Interface.h>
-#include "GPUSettings.h"
-#include "DataFormatsTPC/Constants.h"
 
 class TH1F;
 
@@ -53,12 +43,7 @@ struct ConstPtr {
 
 template <template <typename T> class S>
 struct CalibObjectsTemplate {
-  //typename S<TPCFastTransform>::type* fastTransform = nullptr;
-  typename S<o2::base::MatLayerCylSet>::type* matLUT = nullptr;
   typename S<o2::trd::GeometryFlat>::type* trdGeometry = nullptr;
-  //typename S<TPCdEdxCalibrationSplines>::type* dEdxSplines = nullptr;
-  //typename S<TPCPadGainCalib>::type* tpcPadGain = nullptr;
-  typename S<o2::base::PropagatorImpl<float>>::type* o2Propagator = nullptr;
   typename S<o2::itsmft::TopologyDictionary>::type* itsPatternDict = nullptr;
 };
 
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
index 58fc2f3115b2a..50686f45b5971 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
@@ -11,6 +11,7 @@
 
 ///
 /// \file   EveWorkflowHelper.h
+/// \author David Rohr (as GPUWorkflowHelper.h)
 /// \author julian.myrcha@cern.ch
 
 #ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVEWORKFLOWHELPER_H
@@ -18,8 +19,6 @@
 
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
-#include "GPUDataTypes.h"
-//#include "GPUCommonMath.h"
 #include "EveWorkflow/EveConfiguration.h"
 
 namespace o2::event_visualisation
@@ -35,7 +34,7 @@ class EveWorkflowHelper
     std::vector<const o2::track::TrackParCov*> globalTracks;
     std::vector<float> globalTrackTimes;
   };
-  static std::shared_ptr<const tmpDataContainer> fillIOPtr(gpu::GPUTrackingInOutPointers& ioPtr, const o2::globaltracking::RecoContainer& recoCont, bool useMC, const CalibObjectsConst* calib = nullptr, GID::mask_t maskCl = GID::MASK_ALL, GID::mask_t maskTrk = GID::MASK_ALL, GID::mask_t maskMatch = GID::MASK_ALL);
+  static std::shared_ptr<const tmpDataContainer> compute(const o2::globaltracking::RecoContainer& recoCont,  const CalibObjectsConst* calib = nullptr, GID::mask_t maskCl = GID::MASK_ALL, GID::mask_t maskTrk = GID::MASK_ALL, GID::mask_t maskMatch = GID::MASK_ALL);
 };
 } // namespace o2::event_visualisation
 
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
index d642fd1accf2f..7eca857ecdd0a 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
@@ -46,8 +46,8 @@ class O2DPLDisplaySpec : public o2::framework::Task
   O2DPLDisplaySpec(bool useMC, o2::dataformats::GlobalTrackID::mask_t trkMask,
                    o2::dataformats::GlobalTrackID::mask_t clMask,
                    std::shared_ptr<o2::globaltracking::DataRequest> dataRequest, std::string jsonPath,
-                   std::chrono::milliseconds timeInterval, int numberOfFiles)
-    : mUseMC(useMC), mTrkMask(trkMask), mClMask(clMask), mDataRequest(dataRequest), mJsonPath(jsonPath), mTimeInteval(timeInterval), mNumberOfFiles(numberOfFiles)
+                   std::chrono::milliseconds timeInterval, int numberOfFiles, int numberOfTracks, bool eveHostNameMatch)
+                   : mUseMC(useMC), mTrkMask(trkMask), mClMask(clMask), mDataRequest(dataRequest), mJsonPath(jsonPath), mTimeInteval(timeInterval), mNumberOfFiles(numberOfFiles), mNumberOfTracks(numberOfTracks), mEveHostNameMatch(eveHostNameMatch)
   {
     this->mTimeStamp = std::chrono::high_resolution_clock::now() - timeInterval; // first run meets condition
   }
@@ -58,9 +58,11 @@ class O2DPLDisplaySpec : public o2::framework::Task
 
  private:
   bool mUseMC = false;
+  bool mEveHostNameMatch;                 // empty or correct hostname
   std::string mJsonPath;                  // folder where files are stored
   std::chrono::milliseconds mTimeInteval; // minimal interval between files in miliseconds
-  int mNumberOfFiles;
+  int mNumberOfFiles;                     // maximun number of files in folder - newer replaces older
+  int mNumberOfTracks;                    // maximun number of track in single file (0 means no limit)
   std::chrono::time_point<std::chrono::high_resolution_clock> mTimeStamp;
 
   o2::dataformats::GlobalTrackID::mask_t mTrkMask;
diff --git a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
index 3a620016a93a3..f20cec3e82816 100644
--- a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
+++ b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
@@ -22,14 +22,19 @@
 using namespace o2::event_visualisation;
 
 std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContainer>
-  o2::event_visualisation::EveWorkflowHelper::fillIOPtr(gpu::GPUTrackingInOutPointers& ioPtr,
-                                                        const o2::globaltracking::RecoContainer& recoCont, bool useMC,
+  o2::event_visualisation::EveWorkflowHelper::compute(const o2::globaltracking::RecoContainer& recoCont,
                                                         const CalibObjectsConst* calib, GID::mask_t maskCl,
                                                         GID::mask_t maskTrk, GID::mask_t maskMatch)
 {
+  unsigned int nTracksTPCITSO2 = 0;
+  unsigned int nTOFMatches = 0;
+  unsigned int nTRDTracksITSTPCTRD = 0;
+  unsigned int nTRDTracksTPCTRD = 0;
+  unsigned int nTPCTOFMatches = 0;
+
   auto retVal = std::make_shared<tmpDataContainer>();
 
-  if (maskCl[GID::ITS] && ioPtr.nItsClusters == 0) {
+  if (maskCl[GID::ITS]) {
     const auto& ITSClusterROFRec = recoCont.getITSClustersROFRecords();
     const auto& clusITS = recoCont.getITSClusters();
     if (clusITS.size() && ITSClusterROFRec.size()) {
@@ -38,132 +43,73 @@ std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContain
         auto pattIt = patterns.begin();
         retVal->ITSClustersArray.reserve(clusITS.size());
         o2::its::ioutils::convertCompactClusters(clusITS, pattIt, retVal->ITSClustersArray, *calib->itsPatternDict);
-        ioPtr.itsClusters = retVal->ITSClustersArray.data();
-      }
-      ioPtr.nItsClusters = clusITS.size();
-      ioPtr.itsCompClusters = clusITS.data();
-      ioPtr.nItsClusterROF = ITSClusterROFRec.size();
-      ioPtr.itsClusterROF = ITSClusterROFRec.data();
-      if (useMC) {
-        const auto& ITSClsLabels = recoCont.mcITSClusters.get();
-        ioPtr.itsClusterMC = ITSClsLabels;
-      }
-    }
-    //LOG(info) << "Got " << ioPtr.nItsClusters << " ITS Clusters";
-  }
-  if (maskTrk[GID::ITS] && ioPtr.nItsTracks == 0) {
-    const auto& ITSTracksArray = recoCont.getITSTracks();
-    const auto& ITSTrackROFRec = recoCont.getITSTracksROFRecords();
-    if (ITSTracksArray.size() && ITSTrackROFRec.size()) {
-      const auto& ITSTrackClusIdx = recoCont.getITSTracksClusterRefs();
-      ioPtr.nItsTracks = ITSTracksArray.size();
-      ioPtr.itsTracks = ITSTracksArray.data();
-      ioPtr.itsTrackClusIdx = ITSTrackClusIdx.data();
-      ioPtr.nItsTrackROF = ITSTrackROFRec.size();
-      ioPtr.itsTrackROF = ITSTrackROFRec.data();
-      if (useMC) {
-        const auto& ITSTrkLabels = recoCont.getITSTracksMCLabels();
-        ioPtr.itsTrackMC = ITSTrkLabels.data();
       }
     }
-    //LOG(info) << "Got " << ioPtr.nItsTracks << " ITS Tracks";
   }
 
-  if (maskTrk[GID::ITSTPC] && ioPtr.nTracksTPCITSO2 == 0) {
+  if (maskTrk[GID::ITSTPC] && nTracksTPCITSO2 == 0) {
     const auto& trkITSTPC = recoCont.getTPCITSTracks();
     if (trkITSTPC.size()) {
-      ioPtr.nTracksTPCITSO2 = trkITSTPC.size();
-      ioPtr.tracksTPCITSO2 = trkITSTPC.data();
+      nTracksTPCITSO2 = trkITSTPC.size();
     }
-    //LOG(info) << "Got " << ioPtr.nTracksTPCITSO2 << " ITS-TPC Tracks";
+    LOG(info) << "Got " << nTracksTPCITSO2 << " ITS-TPC Tracks";
   }
 
-  if (maskCl[GID::TOF] && ioPtr.nTOFClusters == 0) {
-    const auto& tofClusters = recoCont.getTOFClusters();
-    if (tofClusters.size()) {
-      ioPtr.nTOFClusters = tofClusters.size();
-      ioPtr.tofClusters = tofClusters.data();
-    }
-    //LOG(info) << "Got " << ioPtr.nTOFClusters << " TOF Clusters";
-  }
 
-  if ((maskMatch[GID::TOF] || maskMatch[GID::ITSTPCTOF] || maskMatch[GID::ITSTPCTRDTOF]) && ioPtr.nTOFMatches == 0) {
+  if ((maskMatch[GID::TOF] || maskMatch[GID::ITSTPCTOF] || maskMatch[GID::ITSTPCTRDTOF])) {
     const auto& tofMatches = recoCont.getTOFMatches();
     if (tofMatches.size()) {
-      ioPtr.nTOFMatches = tofMatches.size();
-      ioPtr.tofMatches = tofMatches.data();
+      nTOFMatches = tofMatches.size();
     }
-    //LOG(info) << "Got " << ioPtr.nTOFMatches << " TOF Matches";
   }
 
-  if (maskMatch[GID::TPCTOF] && ioPtr.nTPCTOFMatches == 0) {
+  if (maskMatch[GID::TPCTOF] && nTPCTOFMatches == 0) {
     const auto& tpctofMatches = recoCont.getTPCTOFMatches();
     if (tpctofMatches.size()) {
-      ioPtr.nTPCTOFMatches = tpctofMatches.size();
-      ioPtr.tpctofMatches = tpctofMatches.data();
+      nTPCTOFMatches = tpctofMatches.size();
     }
-    //LOG(info) << "Got " << ioPtr.nTPCTOFMatches << " TPC-TOF Matches";
+    LOG(info) << "Got " << nTPCTOFMatches << " TPC-TOF Matches";
   }
 
-  if (maskCl[GID::TRD]) {
-    recoCont.inputsTRD->fillGPUIOPtr(&ioPtr);
-    //LOG(info) << "Got " << ioPtr.nTRDTracklets << " TRD Tracklets";
-  }
 
-  if (maskTrk[GID::ITSTPCTRD] && ioPtr.nTRDTracksITSTPCTRD == 0) {
+  if (maskTrk[GID::ITSTPCTRD] ) {
     const auto& trdTracks = recoCont.getITSTPCTRDTracks<o2::trd::TrackTRD>();
     if (trdTracks.size()) {
-      ioPtr.nTRDTracksITSTPCTRD = trdTracks.size();
-      ioPtr.trdTracksITSTPCTRD = trdTracks.data();
+      nTRDTracksITSTPCTRD = trdTracks.size();
     }
-    //LOG(info) << "Got " << ioPtr.nTRDTracksITSTPCTRD << " ITS-TPC-TRD Tracks";
+    LOG(info) << "Got " << nTRDTracksITSTPCTRD << " ITS-TPC-TRD Tracks";
   }
 
-  if (maskTrk[GID::TPCTRD] && ioPtr.nTRDTracksTPCTRD == 0) {
+  if (maskTrk[GID::TPCTRD] && nTRDTracksTPCTRD == 0) {
     const auto& trdTracks = recoCont.getTPCTRDTracks<o2::trd::TrackTRD>();
     if (trdTracks.size()) {
-      ioPtr.nTRDTracksTPCTRD = trdTracks.size();
-      ioPtr.trdTracksTPCTRD = trdTracks.data();
+      nTRDTracksTPCTRD = trdTracks.size();
     }
-    //LOG(info) << "Got " << ioPtr.nTRDTracksTPCTRD << " TPC-TRD Tracks";
+    LOG(info) << "Got " << nTRDTracksTPCTRD << " TPC-TRD Tracks";
   }
 
-  if (maskCl[GID::TPC] && ioPtr.clustersNative == nullptr) {
-    ioPtr.clustersNative = &recoCont.getTPCClusters();
-    //LOG(info) << "Got " << ioPtr.clustersNative->nClustersTotal << " TPC Clusters";
-  }
-
-  if (maskTrk[GID::TPC] && ioPtr.nOutputTracksTPCO2 == 0) {
+  if (maskTrk[GID::TPC]) {
     const auto& tpcTracks = recoCont.getTPCTracks();
     const auto& tpcClusRefs = recoCont.getTPCTracksClusterRefs();
-    ioPtr.outputTracksTPCO2 = tpcTracks.data();
-    ioPtr.nOutputTracksTPCO2 = tpcTracks.size();
-    ioPtr.outputClusRefsTPCO2 = tpcClusRefs.data();
-    ioPtr.nOutputClusRefsTPCO2 = tpcClusRefs.size();
-    if (useMC) {
-      const auto& tpcTracksMC = recoCont.getTPCTracksMCLabels();
-      ioPtr.outputTracksTPCO2MC = tpcTracksMC.data();
+    if (nTracksTPCITSO2) {
+      retVal->tpcLinkITS.resize(tpcTracks.size(), -1);
     }
-    if (ioPtr.nTracksTPCITSO2) {
-      retVal->tpcLinkITS.resize(ioPtr.nOutputTracksTPCO2, -1);
-      ioPtr.tpcLinkITS = retVal->tpcLinkITS.data();
+    if (nTOFMatches || nTPCTOFMatches) {
+      retVal->tpcLinkTOF.resize(tpcTracks.size(), -1);
     }
-    if (ioPtr.nTOFMatches || ioPtr.nTPCTOFMatches) {
-      retVal->tpcLinkTOF.resize(ioPtr.nOutputTracksTPCO2, -1);
-      ioPtr.tpcLinkTOF = retVal->tpcLinkTOF.data();
+    if (nTRDTracksITSTPCTRD || nTRDTracksTPCTRD) {
+      retVal->tpcLinkTRD.resize(tpcTracks.size(), -1);
     }
-    if (ioPtr.nTRDTracksITSTPCTRD || ioPtr.nTRDTracksTPCTRD) {
-      retVal->tpcLinkTRD.resize(ioPtr.nOutputTracksTPCO2, -1);
-      ioPtr.tpcLinkTRD = retVal->tpcLinkTRD.data();
-    }
-    //LOG(info) << "Got " << ioPtr.nOutputTracksTPCO2 << " TPC Tracks";
+    LOG(info) << "Got " << tpcTracks.size() << " TPC Tracks";
   }
 
-  auto creator = [maskTrk, &ioPtr, &recoCont, &retVal](auto& trk, GID gid, float time, float) {
+  auto creator = [maskTrk, &recoCont, &retVal, nTracksTPCITSO2,nTPCTOFMatches](auto& trk, GID gid, float time, float) {
     if (gid.getSource() == GID::ITSTPCTOF) {
-      if (maskTrk[GID::TPC] && ioPtr.nTracksTPCITSO2) {
+      if (maskTrk[GID::TPC] && nTracksTPCITSO2) {
         const auto& match = recoCont.getTOFMatch(gid);
-        const auto& trkItsTPC = ioPtr.tracksTPCITSO2[match.getTrackIndex()];
+        const auto& trkITSTPC = recoCont.getTPCITSTracks();
+        const auto tracksTPCITSO2 = trkITSTPC.data();
+        const auto& trkItsTPC = tracksTPCITSO2[match.getTrackIndex()];
         if (retVal->tpcLinkTOF.size()) {
           retVal->tpcLinkTOF[trkItsTPC.getRefTPC().getIndex()] = match.getTOFClIndex();
         }
@@ -178,8 +124,10 @@ std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContain
         retVal->tpcLinkITS[trk.getRefTPC().getIndex()] = trk.getRefITS().getIndex();
       }
     } else if constexpr (isTPCTOFTrack<decltype(trk)>()) {
-      if (maskTrk[GID::TPC] && ioPtr.nTPCTOFMatches && retVal->tpcLinkTOF.size()) {
-        const auto& match = ioPtr.tpctofMatches[trk.getRefMatch()];
+      if (maskTrk[GID::TPC] && nTPCTOFMatches && retVal->tpcLinkTOF.size()) {
+        const auto& tpctofMatches = recoCont.getTPCTOFMatches();
+        const auto tpctofMatchesData = tpctofMatches.data();
+        const auto& match = tpctofMatchesData[trk.getRefMatch()];
         retVal->tpcLinkTOF[match.getTrackIndex()] = match.getTOFClIndex();
       }
     }
@@ -191,19 +139,28 @@ std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContain
       return false;
     }
   };
+
   recoCont.createTracksVariadic(creator);
+
   if (maskTrk[GID::TPC] && retVal->tpcLinkTRD.size()) {
-    for (unsigned int i = 0; i < ioPtr.nTRDTracksTPCTRD; i++) { // TODO: This should be handled by the createTracks logic, but so far it lacks the TRD tracks
-      retVal->tpcLinkTRD[ioPtr.trdTracksTPCTRD[i].getRefGlobalTrackId().getIndex()] = i;
+    const auto& trdTracks = recoCont.getTPCTRDTracks<o2::trd::TrackTRD>();
+    const auto trdTracksTPCTRD = trdTracks.data();
+    const auto nTRDTracksTPCTRD = trdTracks.size();
+    for (unsigned int i = 0; i < nTRDTracksTPCTRD; i++) { // TODO: This should be handled by the createTracks logic, but so far it lacks the TRD tracks
+      retVal->tpcLinkTRD[trdTracksTPCTRD[i].getRefGlobalTrackId().getIndex()] = i;
     }
-    if (ioPtr.nTracksTPCITSO2) {
-      for (unsigned int i = 0; i < ioPtr.nTRDTracksITSTPCTRD; i++) {
-        retVal->tpcLinkTRD[ioPtr.tracksTPCITSO2[ioPtr.trdTracksITSTPCTRD[i].getRefGlobalTrackId().getIndex()].getRefTPC().getIndex()] = i | 0x40000000;
+    if (nTracksTPCITSO2) {
+      const auto& trdTracks = recoCont.getITSTPCTRDTracks<o2::trd::TrackTRD>();
+      const auto trdTracksITSTPCTRD = trdTracks.data();
+
+      const auto& trkITSTPC = recoCont.getTPCITSTracks();
+      const auto tracksTPCITSO2 = trkITSTPC.data();
+
+      for (unsigned int i = 0; i < nTRDTracksITSTPCTRD; i++) {
+        retVal->tpcLinkTRD[tracksTPCITSO2[trdTracksITSTPCTRD[i].getRefGlobalTrackId().getIndex()].getRefTPC().getIndex()] = i | 0x40000000;
       }
     }
   }
-  ioPtr.globalTracks = retVal->globalTracks.data();
-  ioPtr.globalTrackTimes = retVal->globalTrackTimes.data();
 
   return std::move(retVal);
 }
diff --git a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
index c70a0d82c7f6c..35369a31e7600 100644
--- a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
+++ b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
@@ -35,6 +35,10 @@
 #include "TPCFastTransform.h"
 #include "TRDBase/Geometry.h"
 
+#include <unistd.h>
+#include <limits.h>
+
+
 using namespace o2::event_visualisation;
 using namespace o2::framework;
 using namespace o2::dataformats;
@@ -46,7 +50,9 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 {
   std::vector<o2::framework::ConfigParamSpec> options{
     {"jsons-folder", VariantType::String, "jsons", {"name of the folder to store json files"}},
+    {"eve-hostname", VariantType::String, "", {"name of the host allowed to produce files (empty means no limit)"}},
     {"number-of_files", VariantType::Int, 300, {"maximum number of json files in folder"}},
+    {"number-of_tracks", VariantType::Int, -1, {"maximum number of track stored in json file (-1 means no limit)"}},
     {"time-interval", VariantType::Int, 5000, {"time interval in milliseconds between stored files"}},
     {"enable-mc", o2::framework::VariantType::Bool, false, {"enable visualization of MC data"}},
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable visualization of MC data"}}, // for compatibility, overrides enable-mc
@@ -128,6 +134,10 @@ std::vector<PNT> getTrackPoints(const o2::track::TrackPar& trc, float minR, floa
 
 void O2DPLDisplaySpec::run(ProcessingContext& pc)
 {
+  if(!this->mEveHostNameMatch) {
+    return;
+  }
+
   // filtering out any run which occur before reaching next time interval
   std::chrono::time_point<std::chrono::high_resolution_clock> currentTime = std::chrono::high_resolution_clock::now();
   std::chrono::duration<double> elapsed = currentTime - this->mTimeStamp;
@@ -138,13 +148,16 @@ void O2DPLDisplaySpec::run(ProcessingContext& pc)
 
   o2::globaltracking::RecoContainer recoData;
   recoData.collectData(pc, *mDataRequest);
-  gpu::GPUTrackingInOutPointers ptrs;
-  auto cnt = EveWorkflowHelper::fillIOPtr(ptrs, recoData, mUseMC, &(mConfig->configCalib), mClMask, mTrkMask, mTrkMask);
+  auto cnt = EveWorkflowHelper::compute(recoData, &(mConfig->configCalib), mClMask, mTrkMask, mTrkMask);
 
   std::cout << cnt->globalTracks.size() << std::endl;
   o2::event_visualisation::VisualisationEvent vEvent;
+  int trackCount = cnt->globalTracks.size();      // how many tracks should be stored
+  if(this->mNumberOfTracks != -1 && this->mNumberOfTracks < trackCount) {
+    trackCount = this->mNumberOfTracks;           // less than available
+  }
 
-  for (unsigned int i = 0; i < cnt->globalTracks.size(); i++) {
+  for (unsigned int i = 0; i < trackCount; i++) {
     auto tr = cnt->globalTracks[i];
     std::cout << tr->getX() << std::endl;
     float rMax = 385;
@@ -185,11 +198,16 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec specs;
 
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-
   bool useMC = cfgc.options().get<bool>("enable-mc") && !cfgc.options().get<bool>("disable-mc");
   std::string jsonFolder = cfgc.options().get<std::string>("jsons-folder");
+  std::string eveHostName = cfgc.options().get<std::string>("eve-hostname");
+  char hostname[HOST_NAME_MAX];
+  gethostname(hostname, HOST_NAME_MAX);
+  bool eveHostNameMatch = eveHostName.empty() || eveHostName == hostname ;
+
   std::chrono::milliseconds timeInterval(cfgc.options().get<int>("time-interval"));
   int numberOfFiles = cfgc.options().get<int>("number-of_files");
+  int numberOfTracks = cfgc.options().get<int>("number-of_tracks");
 
   GlobalTrackID::mask_t srcTrk = GlobalTrackID::getSourcesMask(cfgc.options().get<std::string>("display-tracks"));
   GlobalTrackID::mask_t srcCl = GlobalTrackID::getSourcesMask(cfgc.options().get<std::string>("display-clusters"));
@@ -208,7 +226,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
     "o2-eve-display",
     dataRequest->inputs,
     {},
-    AlgorithmSpec{adaptFromTask<O2DPLDisplaySpec>(useMC, srcTrk, srcCl, dataRequest, jsonFolder, timeInterval, numberOfFiles)}});
+    AlgorithmSpec{adaptFromTask<O2DPLDisplaySpec>(useMC, srcTrk, srcCl, dataRequest, jsonFolder, timeInterval, numberOfFiles, numberOfTracks, eveHostNameMatch)}});
 
   return std::move(specs);
 }

From 8636c198cfef26f1cb5377d0a4e58384b3210494 Mon Sep 17 00:00:00 2001
From: Julian <julian.myrcha@cern.ch>
Date: Thu, 29 Jul 2021 19:48:35 +0200
Subject: [PATCH 3/5] reformating

---
 .../Workflow/include/EveWorkflow/EveWorkflowHelper.h  |  2 +-
 .../Workflow/include/EveWorkflow/O2DPLDisplay.h       |  2 +-
 EventVisualisation/Workflow/src/EveWorkflowHelper.cxx | 10 ++++------
 EventVisualisation/Workflow/src/O2DPLDisplay.cxx      | 11 +++++------
 4 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
index 50686f45b5971..3f0071b77816f 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
@@ -34,7 +34,7 @@ class EveWorkflowHelper
     std::vector<const o2::track::TrackParCov*> globalTracks;
     std::vector<float> globalTrackTimes;
   };
-  static std::shared_ptr<const tmpDataContainer> compute(const o2::globaltracking::RecoContainer& recoCont,  const CalibObjectsConst* calib = nullptr, GID::mask_t maskCl = GID::MASK_ALL, GID::mask_t maskTrk = GID::MASK_ALL, GID::mask_t maskMatch = GID::MASK_ALL);
+  static std::shared_ptr<const tmpDataContainer> compute(const o2::globaltracking::RecoContainer& recoCont, const CalibObjectsConst* calib = nullptr, GID::mask_t maskCl = GID::MASK_ALL, GID::mask_t maskTrk = GID::MASK_ALL, GID::mask_t maskMatch = GID::MASK_ALL);
 };
 } // namespace o2::event_visualisation
 
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
index 7eca857ecdd0a..1368be8ae9af0 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
@@ -47,7 +47,7 @@ class O2DPLDisplaySpec : public o2::framework::Task
                    o2::dataformats::GlobalTrackID::mask_t clMask,
                    std::shared_ptr<o2::globaltracking::DataRequest> dataRequest, std::string jsonPath,
                    std::chrono::milliseconds timeInterval, int numberOfFiles, int numberOfTracks, bool eveHostNameMatch)
-                   : mUseMC(useMC), mTrkMask(trkMask), mClMask(clMask), mDataRequest(dataRequest), mJsonPath(jsonPath), mTimeInteval(timeInterval), mNumberOfFiles(numberOfFiles), mNumberOfTracks(numberOfTracks), mEveHostNameMatch(eveHostNameMatch)
+    : mUseMC(useMC), mTrkMask(trkMask), mClMask(clMask), mDataRequest(dataRequest), mJsonPath(jsonPath), mTimeInteval(timeInterval), mNumberOfFiles(numberOfFiles), mNumberOfTracks(numberOfTracks), mEveHostNameMatch(eveHostNameMatch)
   {
     this->mTimeStamp = std::chrono::high_resolution_clock::now() - timeInterval; // first run meets condition
   }
diff --git a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
index f20cec3e82816..80de7e347c52a 100644
--- a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
+++ b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
@@ -23,8 +23,8 @@ using namespace o2::event_visualisation;
 
 std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContainer>
   o2::event_visualisation::EveWorkflowHelper::compute(const o2::globaltracking::RecoContainer& recoCont,
-                                                        const CalibObjectsConst* calib, GID::mask_t maskCl,
-                                                        GID::mask_t maskTrk, GID::mask_t maskMatch)
+                                                      const CalibObjectsConst* calib, GID::mask_t maskCl,
+                                                      GID::mask_t maskTrk, GID::mask_t maskMatch)
 {
   unsigned int nTracksTPCITSO2 = 0;
   unsigned int nTOFMatches = 0;
@@ -55,7 +55,6 @@ std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContain
     LOG(info) << "Got " << nTracksTPCITSO2 << " ITS-TPC Tracks";
   }
 
-
   if ((maskMatch[GID::TOF] || maskMatch[GID::ITSTPCTOF] || maskMatch[GID::ITSTPCTRDTOF])) {
     const auto& tofMatches = recoCont.getTOFMatches();
     if (tofMatches.size()) {
@@ -71,8 +70,7 @@ std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContain
     LOG(info) << "Got " << nTPCTOFMatches << " TPC-TOF Matches";
   }
 
-
-  if (maskTrk[GID::ITSTPCTRD] ) {
+  if (maskTrk[GID::ITSTPCTRD]) {
     const auto& trdTracks = recoCont.getITSTPCTRDTracks<o2::trd::TrackTRD>();
     if (trdTracks.size()) {
       nTRDTracksITSTPCTRD = trdTracks.size();
@@ -103,7 +101,7 @@ std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContain
     LOG(info) << "Got " << tpcTracks.size() << " TPC Tracks";
   }
 
-  auto creator = [maskTrk, &recoCont, &retVal, nTracksTPCITSO2,nTPCTOFMatches](auto& trk, GID gid, float time, float) {
+  auto creator = [maskTrk, &recoCont, &retVal, nTracksTPCITSO2, nTPCTOFMatches](auto& trk, GID gid, float time, float) {
     if (gid.getSource() == GID::ITSTPCTOF) {
       if (maskTrk[GID::TPC] && nTracksTPCITSO2) {
         const auto& match = recoCont.getTOFMatch(gid);
diff --git a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
index 35369a31e7600..d22b869cb1bdc 100644
--- a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
+++ b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
@@ -38,7 +38,6 @@
 #include <unistd.h>
 #include <limits.h>
 
-
 using namespace o2::event_visualisation;
 using namespace o2::framework;
 using namespace o2::dataformats;
@@ -134,7 +133,7 @@ std::vector<PNT> getTrackPoints(const o2::track::TrackPar& trc, float minR, floa
 
 void O2DPLDisplaySpec::run(ProcessingContext& pc)
 {
-  if(!this->mEveHostNameMatch) {
+  if (!this->mEveHostNameMatch) {
     return;
   }
 
@@ -152,9 +151,9 @@ void O2DPLDisplaySpec::run(ProcessingContext& pc)
 
   std::cout << cnt->globalTracks.size() << std::endl;
   o2::event_visualisation::VisualisationEvent vEvent;
-  int trackCount = cnt->globalTracks.size();      // how many tracks should be stored
-  if(this->mNumberOfTracks != -1 && this->mNumberOfTracks < trackCount) {
-    trackCount = this->mNumberOfTracks;           // less than available
+  int trackCount = cnt->globalTracks.size(); // how many tracks should be stored
+  if (this->mNumberOfTracks != -1 && this->mNumberOfTracks < trackCount) {
+    trackCount = this->mNumberOfTracks; // less than available
   }
 
   for (unsigned int i = 0; i < trackCount; i++) {
@@ -203,7 +202,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   std::string eveHostName = cfgc.options().get<std::string>("eve-hostname");
   char hostname[HOST_NAME_MAX];
   gethostname(hostname, HOST_NAME_MAX);
-  bool eveHostNameMatch = eveHostName.empty() || eveHostName == hostname ;
+  bool eveHostNameMatch = eveHostName.empty() || eveHostName == hostname;
 
   std::chrono::milliseconds timeInterval(cfgc.options().get<int>("time-interval"));
   int numberOfFiles = cfgc.options().get<int>("number-of_files");

From 4375320cd42aad543ff341939b497981f871693e Mon Sep 17 00:00:00 2001
From: Julian <julian.myrcha@cern.ch>
Date: Thu, 29 Jul 2021 20:23:42 +0200
Subject: [PATCH 4/5] reformating

---
 EventVisualisation/Workflow/CMakeLists.txt                      | 1 -
 .../Workflow/include/EveWorkflow/EveConfiguration.h             | 2 --
 .../Workflow/include/EveWorkflow/EveWorkflowHelper.h            | 1 -
 EventVisualisation/Workflow/src/EveWorkflowHelper.cxx           | 1 -
 EventVisualisation/Workflow/src/O2DPLDisplay.cxx                | 1 -
 5 files changed, 6 deletions(-)

diff --git a/EventVisualisation/Workflow/CMakeLists.txt b/EventVisualisation/Workflow/CMakeLists.txt
index cd894edb6cd9e..36f12dc61652f 100644
--- a/EventVisualisation/Workflow/CMakeLists.txt
+++ b/EventVisualisation/Workflow/CMakeLists.txt
@@ -39,7 +39,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2"
                 O2::MFTWorkflow
                 O2::TOFBase
                 O2::TOFWorkflowIO
-                O2::TPCFastTransformation
                 O2::TPCReconstruction
                 O2::TPCWorkflow
                 O2::TRDBase
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h b/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
index 8ee4fc74c0cd0..d7657e4f13f6a 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 
 /// \file
-/// \author David Rohr (as O2DPLConfiguration.h)
 /// \author Julian Myrcha
 
 #ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVECONFIGURATION_H
@@ -63,7 +62,6 @@ struct SettingsProcessing {
   bool runMC;
 };
 
-// Full configuration structure with all available settings of GPU...
 struct EveConfiguration {
   EveConfiguration() = default;
   ~EveConfiguration() = default;
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
index 3f0071b77816f..6d41b5459f098 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
@@ -11,7 +11,6 @@
 
 ///
 /// \file   EveWorkflowHelper.h
-/// \author David Rohr (as GPUWorkflowHelper.h)
 /// \author julian.myrcha@cern.ch
 
 #ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVEWORKFLOWHELPER_H
diff --git a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
index 80de7e347c52a..1e82f3dbaea84 100644
--- a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
+++ b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 
 /// \file EveWorkflowHelper.cxx
-/// \author David Rohr
 /// \author julian.myrcha@cern.ch
 
 #include <EveWorkflow/EveWorkflowHelper.h>
diff --git a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
index d22b869cb1bdc..57aca244d531d 100644
--- a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
+++ b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 
 /// \file
-/// \author David Rohr (as O2DPLConfiguration.h)
 /// \author Julian Myrcha
 
 #include "EveWorkflow/O2DPLDisplay.h"

From 384292d5bae17cba8b280b60fbbb4576e1d4886d Mon Sep 17 00:00:00 2001
From: Julian <julian.myrcha@cern.ch>
Date: Fri, 30 Jul 2021 10:34:39 +0200
Subject: [PATCH 5/5] fixed fullCl warning

---
 EventVisualisation/Workflow/src/O2DPLDisplay.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
index 57aca244d531d..13443f21a8963 100644
--- a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
+++ b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
@@ -35,7 +35,7 @@
 #include "TRDBase/Geometry.h"
 
 #include <unistd.h>
-#include <limits.h>
+#include <climits>
 
 using namespace o2::event_visualisation;
 using namespace o2::framework;