Split off legacy reader

e4hsource/CMakeLists.txt

@@ -25,3 +25,33 @@ install(FILES "${PROJECT_BINARY_DIR}/e4hsource/libe4hsource.rootmap"
 install(FILES "${PROJECT_BINARY_DIR}/e4hsource/libe4hsource_rdict.pcm"
         DESTINATION "${CMAKE_INSTALL_LIBDIR}"
 )
+
+
+# Legacy
+add_library(e4hlegacysource SHARED src/EDM4hepLegacySource.cxx)
+target_include_directories(e4hlegacysource PUBLIC include)
+target_link_libraries(e4hlegacysource PUBLIC ROOT::RIO
+                                             ROOT::ROOTDataFrame
+                                             podio::podioRootIO
+                                             EDM4HEP::edm4hep
+                                             EDM4HEP::edm4hepDict
+)
+
+ROOT_GENERATE_DICTIONARY(G__FCCAnalyses_EDM4hepLegacySource
+                         include/EDM4hepSource/EDM4hepLegacySource.hxx
+                         MODULE e4hlegacysource
+                         LINKDEF include/EDM4hepSource/Legacy_LinkDef.h
+)
+
+install(TARGETS e4hlegacysource
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(FILES "${PROJECT_BINARY_DIR}/e4hsource/libe4hlegacysource.rootmap"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+)
+
+install(FILES "${PROJECT_BINARY_DIR}/e4hsource/libe4hlegacysource_rdict.pcm"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+)

e4hsource/include/EDM4hepSource/EDM4hepLegacySource.hxx

@@ -0,0 +1,107 @@
+#ifndef EDM4HEP_LEGACY_SOURCE_H__
+#define EDM4HEP_LEGACY_SOURCE_H__
+
+// STL
+#include <vector>
+#include <string>
+#include <functional>
+#include <shared_mutex>
+
+// ROOT
+#include <ROOT/RDataFrame.hxx>
+#include <ROOT/RDataSource.hxx>
+
+// Podio
+#include <podio/Frame.h>
+#include <podio/ROOTLegacyReader.h>
+#include <podio/CollectionBase.h>
+
+bool loadEDM4hepLegacySource();
+
+namespace FCCAnalyses {
+  using Record_t = std::vector<void*>;
+
+  class EDM4hepLegacySource final : public ROOT::RDF::RDataSource {
+    public:
+      EDM4hepLegacySource(const std::string& filePath, int nEvents = -1);
+      EDM4hepLegacySource(const std::vector<std::string>& filePathList,
+                          int nEvents = -1);
+
+      void SetNSlots(unsigned int nSlots);
+
+      template<typename T>
+      std::vector<T**> GetColumnReaders(std::string_view columnName);
+
+      void Initialize();
+
+      std::vector<std::pair<ULong64_t, ULong64_t>> GetEntryRanges();
+
+      void InitSlot(unsigned int slot, ULong64_t firstEntry);
+
+      bool SetEntry(unsigned int slot, ULong64_t entry);
+
+      void FinalizeSlot(unsigned int slot);
+
+      void Finalize();
+
+      const std::vector<std::string>& GetColumnNames() const;
+
+      bool HasColumn(std::string_view columnName) const;
+
+      std::string GetTypeName(std::string_view columnName) const;
+
+    protected:
+      Record_t GetColumnReadersImpl (std::string_view name,
+                                     const std::type_info& typeInfo);
+
+      std::string AsString() { return "Edm4hep data source"; };
+
+    private:
+      /// Number of slots/threads
+      unsigned int m_nSlots;
+      /// Input filename
+      std::vector<std::string> m_filePathList;
+      /// Total number of events
+      unsigned int m_nEvents;
+      /// Ranges of events available to be processed
+      std::vector<std::pair<ULong64_t, ULong64_t>> m_rangesAvailable;
+      /// Ranges of events available ever created
+      std::vector<std::pair<ULong64_t, ULong64_t>> m_rangesAll;
+      /// Column names
+      std::vector<std::string> m_columnNames;
+      /// Column types
+      std::vector<std::string> m_columnTypes;
+      /// Collections, m_Collections[columnIndex][slotIndex]
+      std::vector<std::vector<const podio::CollectionBase*>> m_Collections;
+      /// Active collections
+      std::vector<unsigned int> m_activeCollections;
+      /// Root legacy podio reader
+      std::map<int, podio::ROOTLegacyReader> m_podioReaders;
+      /// Podio frames
+      std::map<int, podio::Frame> m_frames;
+      /// Mutex to protect frame map
+      mutable std::shared_mutex m_frames_mutex;
+      /// Setup input
+      void SetupInput(int nEvents);
+  };
+
+
+  /**
+   * \brief Retrieve from EDM4hepLegacySource per-thread readers for the
+   *        desired columns.
+   */
+  template<typename T>
+  std::vector<T**>
+  EDM4hepLegacySource::GetColumnReaders(std::string_view columnName) {
+    std::cout << "EDM4hepLegacySource: Getting column readers for column: "
+              << columnName << std::endl;
+
+    std::vector<T**> readers;
+
+    return readers;
+  }
+
+  ROOT::RDataFrame FromEDM4hepLegacy(const std::vector<std::string>& filePathList);
+}
+
+#endif /* EDM4HEP_LEGACY_SOURCE_H__ */

e4hsource/include/EDM4hepSource/EDM4hepSource.hxx

@@ -6,7 +6,6 @@
 #include <vector>
 #include <string>
 #include <functional>
-#include <mutex>
 
 // ROOT
 #include <ROOT/RDataFrame.hxx>
@@ -87,8 +86,6 @@ namespace FCCAnalyses {
       bool m_useLegacyReaders;
       /// Setup input
       void SetupInput(int nEvents);
-
-      std::map<int, std::mutex> m_mutex;
   };
 
 

e4hsource/include/EDM4hepSource/Legacy_LinkDef.h

@@ -0,0 +1,16 @@
+#ifdef __CINT__
+
+//Globals
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+#pragma link C++ nestedclasses;
+
+// Load function
+#pragma link C++ function loadEDM4hepLegacySource;
+
+// Source
+#pragma link C++ class FCCAnalyses::EDM4hepLegacySource;
+#pragma link C++ function FCCAnalyses::FromEDM4hepLegacy;
+
+#endif