feat: ColliderML reader

CI/check_unused_files.py

@@ -131,6 +131,7 @@
     ".yml",
     ".xml",
     ".sh",
+    ".parquet",
 )
 
 

Examples/Io/Parquet/CMakeLists.txt

@@ -78,3 +78,58 @@ target_link_libraries(
 )
 
 acts_compile_headers(ExamplesIoParquet GLOB include/ActsExamples/**/*.hpp)
+
+# ColliderML input converter — absorbed into libActsPluginArrow like the
+# other Parquet TUs. It needs ExamplesDigitization (for createMeasurement and
+# smearing types), so we add that as a PRIVATE link to ActsPluginArrow and
+# include its headers via genex (not a link-level dep on the OBJECT target).
+add_library(
+    ActsExamplesIoColliderML_obj
+    OBJECT
+    src/ColliderMLInputConverter.cpp
+)
+target_include_directories(
+    ActsExamplesIoColliderML_obj
+    PRIVATE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<TARGET_PROPERTY:Acts::PluginArrow,INTERFACE_INCLUDE_DIRECTORIES>
+        $<TARGET_PROPERTY:Acts::ExamplesDigitization,INTERFACE_INCLUDE_DIRECTORIES>
+)
+target_link_libraries(
+    ActsExamplesIoColliderML_obj
+    PRIVATE Acts::ExamplesFramework Acts::ArrowLinkage
+)
+set_target_properties(
+    ActsExamplesIoColliderML_obj
+    PROPERTIES POSITION_INDEPENDENT_CODE ON
+)
+if(ACTS_ARROW_ISOLATED)
+    set_target_properties(
+        ActsExamplesIoColliderML_obj
+        PROPERTIES CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN YES
+    )
+endif()
+
+target_sources(
+    ActsPluginArrow
+    PRIVATE $<TARGET_OBJECTS:ActsExamplesIoColliderML_obj>
+)
+target_link_libraries(ActsPluginArrow PRIVATE Acts::ExamplesDigitization)
+# ExamplesDigitization is PRIVATE-linked by ActsPluginArrow; add it to the
+# export set for the same reason ExamplesFramework is exported above.
+install(TARGETS ActsExamplesDigitization EXPORT ActsPluginArrowTargets)
+
+# INTERFACE alias so downstream code using Acts::ExamplesIoColliderML still
+# resolves to libActsPluginArrow (no separate .so produced).
+acts_add_library(ExamplesIoColliderML INTERFACE)
+target_include_directories(
+    ActsExamplesIoColliderML
+    INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+)
+target_link_libraries(
+    ActsExamplesIoColliderML
+    INTERFACE
+        Acts::PluginArrow
+        Acts::ExamplesFramework
+        Acts::ExamplesDigitization
+)

Examples/Io/Parquet/include/ActsExamples/Io/Parquet/ColliderMLInputConverter.hpp

@@ -0,0 +1,148 @@
+// This file is part of the ACTS project.
+//
+// Copyright (C) 2016 CERN for the benefit of the ACTS project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include "Acts/Geometry/GeometryIdentifier.hpp"
+#include "Acts/Utilities/Logger.hpp"
+#include "ActsExamples/Digitization/DigitizationConfig.hpp"
+#include "ActsExamples/EventData/Measurement.hpp"
+#include "ActsExamples/EventData/SimHit.hpp"
+#include "ActsExamples/EventData/SimParticle.hpp"
+#include "ActsExamples/EventData/TruthMatching.hpp"
+#include "ActsExamples/Framework/DataHandle.hpp"
+#include "ActsExamples/Framework/IAlgorithm.hpp"
+#include "ActsPlugins/Arrow/ArrowUtil.hpp"
+
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace Acts {
+class TrackingGeometry;
+}
+
+namespace ActsExamples {
+
+/// Packed ColliderML geometry key: det(8b)|vol(8b)|layer(16b)|surface(32b).
+inline std::uint64_t colliderMLGeoKey(std::uint8_t detector,
+                                      std::uint8_t volume, std::uint16_t layer,
+                                      std::uint32_t surface) {
+  return (static_cast<std::uint64_t>(detector) << 40) |
+         (static_cast<std::uint64_t>(volume) << 32) |
+         (static_cast<std::uint64_t>(layer) << 16) |
+         static_cast<std::uint64_t>(surface);
+}
+
+/// Load a ColliderML geometry ID map from a CSV file.
+///
+/// Expected columns (with header): detector, volume, layer, surface,
+/// acts_geo_id. The @c acts_geo_id value is parsed as a hex or decimal
+/// unsigned 64-bit integer (e.g. @c 0x1000000000010001).
+///
+/// @param path  Path to the CSV file.
+/// @return Map from packed ColliderML key to @c Acts::GeometryIdentifier.
+std::unordered_map<std::uint64_t, Acts::GeometryIdentifier>
+loadColliderMLGeoIdMap(const std::filesystem::path& path);
+
+/// Convert ColliderML Arrow tables to ACTS EDM types.
+///
+/// Reads two Arrow tables placed on the whiteboard by @c ParquetReader —
+/// one for particles and one for tracker hits — and emits any combination
+/// of @c SimParticleContainer, @c SimHitContainer, and
+/// @c MeasurementContainer depending on which output keys are non-empty.
+///
+/// Modes (controlled by which output keys are set in the config):
+///   - Particles only:  set @c outputParticles, leave hits keys empty.
+///   - + SimHits:       also set @c outputSimHits.
+///   - + Measurements:  also set @c outputMeasurements; requires
+///                      @c trackingGeometry and @c digiConfig.
+///
+/// @note SimHit momentum fields are zero-filled; ColliderML does not
+///       record per-hit momentum.
+class ColliderMLInputConverter : public IAlgorithm {
+ public:
+  struct Config {
+    /// Whiteboard key for the particles Arrow table (from ParquetReader).
+    std::string inputParticlesTable;
+    /// Whiteboard key for the tracker-hits Arrow table (from ParquetReader).
+    std::string inputHitsTable;
+
+    /// Output key for @c SimParticleContainer. Empty = skip.
+    std::string outputParticles;
+    /// Output key for @c SimHitContainer. Empty = skip.
+    std::string outputSimHits;
+    /// Output key for @c MeasurementContainer. Empty = skip.
+    std::string outputMeasurements;
+    /// Output key for @c MeasurementSubset covering all measurements (required
+    /// by CKF / SpacePointMaker). Empty = skip.
+    std::string outputMeasurementSubset;
+    /// Output key for @c MeasurementSimHitsMap. Empty = skip.
+    std::string outputMeasSimHitsMap;
+    /// Output key for @c MeasurementParticlesMap (measurement→particle).
+    /// Empty = skip.
+    std::string outputMeasParticlesMap;
+    /// Output key for @c ParticleMeasurementsMap (particle→measurements).
+    /// Required by TruthTrackFinder / TruthSeeding. Empty = skip.
+    std::string outputParticleMeasurementsMap;
+
+    /// Required when @c outputMeasurements is non-empty.
+    std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry;
+
+    /// Digitisation config used to determine subspace and covariance per
+    /// surface. Required when @c outputMeasurements is non-empty.
+    /// Load with @c readDigiConfigFromJson (acts.examples.json module).
+    /// The hierarchy map is queried per hit with full fallback
+    /// (sensitive → layer → volume).
+    DigiConfigContainer digiConfig;
+
+    /// ColliderML (det, vol, layer, surf) → ACTS GeometryIdentifier.
+    /// Optional. When empty, geometry IDs are constructed directly from the
+    /// ColliderML (volume, layer, surface) fields — only correct when the data
+    /// was produced from a geometry whose ID scheme matches the current build.
+    /// Load with @c loadColliderMLGeoIdMap().
+    std::unordered_map<std::uint64_t, Acts::GeometryIdentifier> geoIdMap;
+  };
+
+  ColliderMLInputConverter(const Config& cfg,
+                           std::unique_ptr<const Acts::Logger> logger);
+
+  ColliderMLInputConverter(const Config& cfg, Acts::Logging::Level level);
+
+  ~ColliderMLInputConverter() override;
+
+  ProcessCode execute(const AlgorithmContext& ctx) const final;
+
+  const Config& config() const { return m_cfg; }
+
+ private:
+  Config m_cfg;
+
+  ReadDataHandle<ActsPlugins::ArrowUtil::ArrowTable> m_inputParticles{
+      this, "InputParticles"};
+  ReadDataHandle<ActsPlugins::ArrowUtil::ArrowTable> m_inputHits{this,
+                                                                 "InputHits"};
+
+  WriteDataHandle<SimParticleContainer> m_outputParticles{this,
+                                                          "OutputParticles"};
+  WriteDataHandle<SimHitContainer> m_outputSimHits{this, "OutputSimHits"};
+  WriteDataHandle<MeasurementContainer> m_outputMeasurements{
+      this, "OutputMeasurements"};
+  WriteDataHandle<MeasurementSubset> m_outputMeasurementSubset{
+      this, "OutputMeasurementSubset"};
+  WriteDataHandle<MeasurementSimHitsMap> m_outputMeasSimHitsMap{
+      this, "OutputMeasSimHitsMap"};
+  WriteDataHandle<MeasurementParticlesMap> m_outputMeasParticlesMap{
+      this, "OutputMeasParticlesMap"};
+  WriteDataHandle<ParticleMeasurementsMap> m_outputParticleMeasurementsMap{
+      this, "OutputParticleMeasurementsMap"};
+};
+
+}  // namespace ActsExamples