algo: Add archive class for reconstruction results.

algo/CMakeLists.txt

@@ -37,6 +37,8 @@ set(SRCS
   detectors/trd2d/UnpackTrd2d.cxx
   detectors/rich/RichReadoutConfig.cxx
   detectors/rich/UnpackRich.cxx
+  global/Archive.cxx
+  global/RecoIO.cxx
   global/Reco.cxx
   qa/DigiEventQa.cxx
   qa/Histo1D.cxx

algo/global/Archive.cxx

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#include "Archive.h"
+
+#include "CbmStsDigi.h"
+
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/serialization/vector.hpp>
+
+#include <fstream>
+
+#include "log.hpp"
+
+using namespace cbm::algo;
+
+namespace ba = boost::archive;
+
+Archive::Archive(fs::path file)
+{
+  L_(info) << "Reading archive from " << file;
+  std::ifstream ifs(file.string(), std::ios::binary);
+  ba::binary_iarchive ia(ifs);
+  ia >> *this;
+}
+
+void Archive::Store(fs::path file) const
+{
+  L_(info) << "Writing archive to " << file;
+  std::ofstream ofs(file.string(), std::ios::binary);
+  ba::binary_oarchive oa(ofs);
+  oa << *this;
+}

algo/global/Archive.h

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#ifndef CBM_ALGO_GLOBAL_ARCHIVE_H
+#define CBM_ALGO_GLOBAL_ARCHIVE_H
+
+#include "MicrosliceDescriptor.hpp"
+
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/version.hpp>
+
+#include <vector>
+
+#include "RecoIO.h"
+#include "compat/Filesystem.h"
+
+namespace cbm::algo
+{
+  class Archive {
+  public:
+    /**
+     * @brief Read Archive object from file.
+    */
+    Archive(fs::path file);
+
+    /**
+     * @brief Construct empty archive.
+    */
+    Archive(const std::vector<fles::SubsystemIdentifier>& detectors) : fDetectors(detectors) {}
+    ~Archive() = default;
+
+    /**
+     * @brief Store Archive object to file.
+    */
+    void Store(fs::path file) const;
+
+    const std::vector<fles::SubsystemIdentifier>& Detectors() const { return fDetectors; }
+
+    std::vector<RecoIO>& TimesliceResults() { return fTimesliceResults; }
+    const std::vector<RecoIO>& TimesliceResults() const { return fTimesliceResults; }
+
+  private:
+    std::vector<fles::SubsystemIdentifier> fDetectors;
+
+    std::vector<RecoIO> fTimesliceResults;
+
+    friend class boost::serialization::access;
+    template<class Archive>
+    void serialize(Archive& ar, const unsigned int /*version*/)
+    {
+      ar& fDetectors;
+      ar& fTimesliceResults;
+    }
+  };
+}  // namespace cbm::algo
+
+BOOST_CLASS_VERSION(cbm::algo::Archive, 1)
+
+#endif

algo/global/Reco.cxx

@@ -72,7 +72,8 @@ void Reco::Init(const Options& opts)
   xpu::push_timer("Reco");
 }
 
-void Reco::Run(const fles::Timeslice& ts)
+
+RecoIO Reco::Run(const fles::Timeslice& ts)
 {
   if (!fInitialized) { throw std::runtime_error("Chain not initialized"); }
 
@@ -108,6 +109,11 @@ void Reco::Run(const fles::Timeslice& ts)
 
 
   PrintTimings(ts_times);
+
+  RecoIO results;
+  results.StsDigis() = std::move(digis);
+
+  return results;
 }
 
 void Reco::Finalize()

algo/global/Reco.h

@@ -6,6 +6,7 @@
 
 #include <xpu/host.h>
 
+#include "RecoIO.h"
 #include "SubChain.h"
 #include "UnpackChain.h"
 #include "sts/StsHitfinderChain.h"
@@ -24,13 +25,13 @@ namespace cbm::algo
     Reco();
     ~Reco();
 
-    Reco(const Reco&) = delete;
+    Reco(const Reco&)            = delete;
     Reco& operator=(const Reco&) = delete;
     Reco(Reco&&)                 = delete;
-    Reco& operator=(Reco&&) = delete;
+    Reco& operator=(Reco&&)      = delete;
 
     void Init(const Options&);
-    void Run(const fles::Timeslice&);
+    RecoIO Run(const fles::Timeslice&);
     void Finalize();
     void PrintTimings(xpu::timings&);
 

algo/global/RecoIO.cxx

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#include "RecoIO.h"
+
+#include "CbmStsDigi.h"
+
+using namespace cbm::algo;
+
+RecoIO::RecoIO() {}
+RecoIO::~RecoIO() {}

algo/global/RecoIO.h

+/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Felix Weiglhofer [committer] */
+#ifndef CBM_ALGO_GLOBAL_RECOIO_H
+#define CBM_ALGO_GLOBAL_RECOIO_H
+
+#include <boost/serialization/access.hpp>
+
+#include <vector>
+
+class CbmStsDigi;
+namespace cbm::algo::sts
+{
+  using Digi = CbmStsDigi;
+}
+
+namespace cbm::algo
+{
+  class RecoIO {
+
+  public:
+    // Place ctor / dtor in cxx, so that we can forward-declare the data classes and keep this header small.
+    RecoIO();
+    ~RecoIO();
+
+    std::vector<sts::Digi>& StsDigis() { return fStsDigis; }
+    const std::vector<sts::Digi>& StsDigis() const { return fStsDigis; }
+
+  private:
+    std::vector<sts::Digi> fStsDigis;
+
+    friend class boost::serialization::access;
+    template<class Archive>
+    void serialize(Archive& ar, const unsigned int /*version*/)
+    {
+      ar& fStsDigis;
+    }
+  };
+}  // namespace cbm::algo
+
+#endif

reco/app/cbmreco/main.cxx

@@ -8,6 +8,7 @@
 
 #include <xpu/host.h>
 
+#include "Archive.h"
 #include "BuildInfo.h"
 #include "Options.h"
 #include "Reco.h"
@@ -44,6 +45,8 @@ int main(int argc, char** argv)
   Reco reco;
   reco.Init(opts);
 
+
+  Archive archive(opts.Detectors());
   fles::TimesliceAutoSource source {opts.InputLocator()};
   int tsIdx  = 0;
   int num_ts = opts.NumTimeslices();
@@ -53,7 +56,8 @@ int main(int argc, char** argv)
       tsIdx++;
       continue;
     }
-    reco.Run(*ts);
+    auto result = reco.Run(*ts);
+    archive.TimesliceResults().push_back(result);
     tsIdx++;
 
     if (num_ts > 0 && tsIdx >= num_ts) { break; }