From 803dd92968502a4ce7bceb4bfd9d18dd17c6ea9b Mon Sep 17 00:00:00 2001
From: Oliver Lantwin <oliver.lantwin@cern.ch>
Date: Thu, 9 Jul 2026 13:41:41 +0200
Subject: [PATCH 1/2] feat: add canonical unit vocabulary via mp-units

Introduce SHiP/Units.hpp (canonical quantity types: mm, ns, GeV, GeV/c,
tesla, with momentum and time-of-flight units derived from the exact
speed of light) and SHiP/QuantityView.hpp (free-function views that
convert the plain-double data classes to and from quantities), exported
as the headers-only SHiP::SHiPUnits target.

The persisted structs are unchanged: ROOT cannot stream mp-units
quantity members (TStreamerInfo::Build fails and the member is silently
zeroed on readback), so quantities stop at the I/O boundary by design.
Computation code works in quantity types; conversions to and from
storage are bitwise because the storage unit is the quantity unit.
---
 CMakeLists.txt                     |  18 ++++
 cmake/SHiPDataModelConfig.cmake.in |   1 +
 include/SHiP/QuantityView.hpp      | 131 +++++++++++++++++++++++++++++
 include/SHiP/Units.hpp             |  92 ++++++++++++++++++++
 pixi.lock                          |  31 +++++++
 pixi.toml                          |   2 +
 tests/CMakeLists.txt               |   5 ++
 tests/test_units.cpp               | 106 +++++++++++++++++++++++
 8 files changed, 386 insertions(+)
 create mode 100644 include/SHiP/QuantityView.hpp
 create mode 100644 include/SHiP/Units.hpp
 create mode 100644 tests/test_units.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2f7e526..e17692d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,6 +6,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 find_package(ROOT REQUIRED COMPONENTS Core RIO)
+find_package(mp-units 2.5 CONFIG REQUIRED)
 
 add_library(SHiPDataModel SHARED)
 target_sources(
@@ -24,6 +25,22 @@ target_sources(
 target_link_libraries(SHiPDataModel PUBLIC ROOT::Core)
 set_target_properties(SHiPDataModel PROPERTIES LINKER_LANGUAGE CXX)
 
+# Canonical unit vocabulary (mp-units quantity types + views over the data
+# classes). Headers-only and deliberately separate from SHiPDataModel: the
+# quantity types must never enter the ROOT dictionary (ROOT cannot stream
+# them), and units-only consumers must not pay for a ROOT linkage.
+add_library(SHiPUnits INTERFACE)
+add_library(SHiP::SHiPUnits ALIAS SHiPUnits)
+target_sources(
+    SHiPUnits
+    INTERFACE
+        FILE_SET headers
+            TYPE HEADERS
+            BASE_DIRS include
+            FILES include/SHiP/Units.hpp include/SHiP/QuantityView.hpp
+)
+target_link_libraries(SHiPUnits INTERFACE mp-units::mp-units)
+
 root_generate_dictionary(
   G__SHiPDataModel
   SHiP/MCParticle.hpp
@@ -45,6 +62,7 @@ install(
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     FILE_SET headers
 )
+install(TARGETS SHiPUnits EXPORT SHiPDataModelTargets FILE_SET headers)
 install(
     FILES
         ${CMAKE_CURRENT_BINARY_DIR}/libSHiPDataModel_rdict.pcm
diff --git a/cmake/SHiPDataModelConfig.cmake.in b/cmake/SHiPDataModelConfig.cmake.in
index aaccb62..93945ee 100644
--- a/cmake/SHiPDataModelConfig.cmake.in
+++ b/cmake/SHiPDataModelConfig.cmake.in
@@ -2,6 +2,7 @@
 
 include(CMakeFindDependencyMacro)
 find_dependency(ROOT COMPONENTS Core RIO)
+find_dependency(mp-units 2.5 CONFIG)
 
 include("${CMAKE_CURRENT_LIST_DIR}/SHiPDataModelTargets.cmake")
 
diff --git a/include/SHiP/QuantityView.hpp b/include/SHiP/QuantityView.hpp
new file mode 100644
index 0000000..b063d79
--- /dev/null
+++ b/include/SHiP/QuantityView.hpp
@@ -0,0 +1,131 @@
+#pragma once
+
+#include "SHiP/MCParticle.hpp"
+#include "SHiP/RecParticle.hpp"
+#include "SHiP/SimHit.hpp"
+#include "SHiP/SimParticle.hpp"
+#include "SHiP/Units.hpp"
+
+/// Quantity views over the persisted data classes.
+///
+/// The data classes stay plain-double PODs (ROOT streaming cannot handle
+/// mp-units members); these free functions convert to and from the canonical
+/// quantity types so computation code never touches an implicit unit. All
+/// conversions are bitwise (the storage unit is the quantity's unit).
+namespace ship::view {
+
+// --- MCParticle -----------------------------------------------------------
+[[nodiscard]] inline Vec3<Length> vertex(SHiP::MCParticle const& p) {
+  return vecOf<Length>(p.vertex);
+}
+[[nodiscard]] inline Vec3<Momentum> momentum(SHiP::MCParticle const& p) {
+  return vecOf<Momentum>(p.momentum);
+}
+/// Total energy.
+[[nodiscard]] inline Energy energy(SHiP::MCParticle const& p) {
+  return quantityOf<Energy>(p.energy);
+}
+[[nodiscard]] inline Time time(SHiP::MCParticle const& p) {
+  return quantityOf<Time>(p.time);
+}
+inline void setVertex(SHiP::MCParticle& p, Vec3<Length> const& v) {
+  p.vertex = raw(v);
+}
+inline void setMomentum(SHiP::MCParticle& p, Vec3<Momentum> const& v) {
+  p.momentum = raw(v);
+}
+inline void setEnergy(SHiP::MCParticle& p, Energy e) { p.energy = raw(e); }
+inline void setTime(SHiP::MCParticle& p, Time t) { p.time = raw(t); }
+
+// --- SimHit ---------------------------------------------------------------
+[[nodiscard]] inline Vec3<Length> position(SHiP::SimHit const& h) {
+  return vecOf<Length>(h.position);
+}
+[[nodiscard]] inline Vec3<Momentum> momentum(SHiP::SimHit const& h) {
+  return vecOf<Momentum>(h.momentum);
+}
+[[nodiscard]] inline Energy energyDeposit(SHiP::SimHit const& h) {
+  return quantityOf<Energy>(h.energyDeposit);
+}
+[[nodiscard]] inline Time time(SHiP::SimHit const& h) {
+  return quantityOf<Time>(h.time);
+}
+[[nodiscard]] inline Length pathLength(SHiP::SimHit const& h) {
+  return quantityOf<Length>(h.pathLength);
+}
+inline void setPosition(SHiP::SimHit& h, Vec3<Length> const& v) {
+  h.position = raw(v);
+}
+inline void setMomentum(SHiP::SimHit& h, Vec3<Momentum> const& v) {
+  h.momentum = raw(v);
+}
+inline void setEnergyDeposit(SHiP::SimHit& h, Energy e) {
+  h.energyDeposit = raw(e);
+}
+inline void setTime(SHiP::SimHit& h, Time t) { h.time = raw(t); }
+inline void setPathLength(SHiP::SimHit& h, Length l) { h.pathLength = raw(l); }
+
+// --- SimParticle ----------------------------------------------------------
+[[nodiscard]] inline Vec3<Length> vertex(SHiP::SimParticle const& p) {
+  return vecOf<Length>(p.vertex);
+}
+[[nodiscard]] inline Vec3<Length> endpoint(SHiP::SimParticle const& p) {
+  return vecOf<Length>(p.endpoint);
+}
+[[nodiscard]] inline Vec3<Momentum> momentum(SHiP::SimParticle const& p) {
+  return vecOf<Momentum>(p.momentum);
+}
+/// Initial kinetic energy.
+[[nodiscard]] inline Energy energy(SHiP::SimParticle const& p) {
+  return quantityOf<Energy>(p.energy);
+}
+[[nodiscard]] inline Time time(SHiP::SimParticle const& p) {
+  return quantityOf<Time>(p.time);
+}
+inline void setVertex(SHiP::SimParticle& p, Vec3<Length> const& v) {
+  p.vertex = raw(v);
+}
+inline void setEndpoint(SHiP::SimParticle& p, Vec3<Length> const& v) {
+  p.endpoint = raw(v);
+}
+inline void setMomentum(SHiP::SimParticle& p, Vec3<Momentum> const& v) {
+  p.momentum = raw(v);
+}
+inline void setEnergy(SHiP::SimParticle& p, Energy e) { p.energy = raw(e); }
+inline void setTime(SHiP::SimParticle& p, Time t) { p.time = raw(t); }
+
+// --- RecParticle ----------------------------------------------------------
+[[nodiscard]] inline Vec3<Length> vertex(SHiP::RecParticle const& p) {
+  return vecOf<Length>(p.vertex);
+}
+[[nodiscard]] inline Vec3<Length> endpoint(SHiP::RecParticle const& p) {
+  return vecOf<Length>(p.endpoint);
+}
+[[nodiscard]] inline Vec3<Momentum> momentum(SHiP::RecParticle const& p) {
+  return vecOf<Momentum>(p.momentum);
+}
+/// Initial kinetic energy.
+[[nodiscard]] inline Energy energy(SHiP::RecParticle const& p) {
+  return quantityOf<Energy>(p.energy);
+}
+[[nodiscard]] inline Time time(SHiP::RecParticle const& p) {
+  return quantityOf<Time>(p.time);
+}
+/// Impact parameter wrt the primary vertex.
+[[nodiscard]] inline Length ipPV(SHiP::RecParticle const& p) {
+  return quantityOf<Length>(p.ipPV);
+}
+inline void setVertex(SHiP::RecParticle& p, Vec3<Length> const& v) {
+  p.vertex = raw(v);
+}
+inline void setEndpoint(SHiP::RecParticle& p, Vec3<Length> const& v) {
+  p.endpoint = raw(v);
+}
+inline void setMomentum(SHiP::RecParticle& p, Vec3<Momentum> const& v) {
+  p.momentum = raw(v);
+}
+inline void setEnergy(SHiP::RecParticle& p, Energy e) { p.energy = raw(e); }
+inline void setTime(SHiP::RecParticle& p, Time t) { p.time = raw(t); }
+inline void setIpPV(SHiP::RecParticle& p, Length l) { p.ipPV = raw(l); }
+
+}  // namespace ship::view
diff --git a/include/SHiP/Units.hpp b/include/SHiP/Units.hpp
new file mode 100644
index 0000000..a8ca843
--- /dev/null
+++ b/include/SHiP/Units.hpp
@@ -0,0 +1,92 @@
+#pragma once
+
+#include <mp-units/systems/hep.h>  // exports framework.h; includes systems/si.h
+
+#include <array>
+
+/// Canonical ShipSoft unit vocabulary.
+///
+/// Storage convention (matches the data-class doxygen contracts and Key4hep):
+/// positions and lengths [mm], momenta [GeV/c], energies [GeV], times [ns].
+/// Persisted classes keep plain doubles in these units; computation code
+/// works with the quantity types below and converts at the boundaries (see
+/// SHiP/QuantityView.hpp).
+///
+/// NEVER `using namespace ship::units` in a translation unit that includes
+/// CLHEP or Geant4 headers: G4SystemOfUnits.hh injects global `mm`, `GeV`,
+/// `tesla`, ... that collide with these names. Always qualify.
+namespace ship {
+
+namespace units {
+
+// Length
+inline constexpr auto mm = mp_units::si::milli<mp_units::si::metre>;
+inline constexpr auto cm = mp_units::si::centi<mp_units::si::metre>;
+inline constexpr auto m = mp_units::si::metre;
+
+// Time
+inline constexpr auto ns = mp_units::si::nano<mp_units::si::second>;
+inline constexpr auto s = mp_units::si::second;
+
+// Angle
+inline constexpr auto rad = mp_units::si::radian;
+
+// Energy
+inline constexpr auto MeV = mp_units::hep::unit_symbols::MeV;
+inline constexpr auto GeV = mp_units::hep::unit_symbols::GeV;
+
+// Speed of light as a named unit ("c", exact by SI definition). Building
+// momentum, mass and time-of-flight units from it keeps every conversion
+// factor derived rather than hand-typed.
+inline constexpr auto c = mp_units::hep::speed_of_light;
+
+// Momentum and mass
+inline constexpr auto GeV_per_c = GeV / c;
+inline constexpr auto GeV_per_c2 = GeV / mp_units::square(c);
+
+// Time of flight per unit length (Pythia8 production time, lifetime cuts)
+inline constexpr auto mm_per_c = mm / c;
+
+// Magnetic flux density
+inline constexpr auto tesla = mp_units::si::tesla;
+
+}  // namespace units
+
+/// Canonical quantity types: double representation, storage unit baked in.
+using Length = mp_units::quantity<units::mm, double>;
+using Time = mp_units::quantity<units::ns, double>;
+using Energy = mp_units::quantity<units::GeV, double>;
+using Momentum = mp_units::quantity<units::GeV_per_c, double>;
+using Mass = mp_units::quantity<units::GeV_per_c2, double>;
+using Angle = mp_units::quantity<units::rad, double>;
+using MagneticField = mp_units::quantity<units::tesla, double>;
+
+template <typename Q>
+using Vec3 = std::array<Q, 3>;
+
+/// Wrap a raw scalar, interpreting it in Q's canonical unit (bitwise).
+template <typename Q>
+[[nodiscard]] constexpr Q quantityOf(double v) {
+  return v * Q::reference;
+}
+
+/// Unwrap a scalar quantity to a raw double in Q's canonical unit (bitwise).
+template <typename Q>
+[[nodiscard]] constexpr double raw(Q q) {
+  return q.numerical_value_in(Q::unit);
+}
+
+/// Wrap a raw 3-vector, interpreting it in Q's canonical unit (bitwise).
+template <typename Q>
+[[nodiscard]] constexpr Vec3<Q> vecOf(std::array<double, 3> const& v) {
+  return {v[0] * Q::reference, v[1] * Q::reference, v[2] * Q::reference};
+}
+
+/// Unwrap a quantity 3-vector to raw doubles in Q's canonical unit (bitwise).
+template <typename Q>
+[[nodiscard]] constexpr std::array<double, 3> raw(Vec3<Q> const& v) {
+  return {v[0].numerical_value_in(Q::unit), v[1].numerical_value_in(Q::unit),
+          v[2].numerical_value_in(Q::unit)};
+}
+
+}  // namespace ship
diff --git a/pixi.lock b/pixi.lock
index 282a60b..8972c4e 100644
--- a/pixi.lock
+++ b/pixi.lock
@@ -49,6 +49,7 @@ environments:
       - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.15-hecca717_0.conda
       - conda: https://conda.anaconda.org/conda-forge/linux-64/graphviz-14.1.2-h8b86629_0.conda
       - conda: https://conda.anaconda.org/conda-forge/linux-64/gsl-2.7-he838d99_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gsl-lite-1.1.0-h80b0018_0.conda
       - conda: https://conda.anaconda.org/conda-forge/linux-64/gsoap-2.8.123-h8dc497d_0.tar.bz2
       - conda: https://conda.anaconda.org/conda-forge/linux-64/gtest-1.17.0-h84d6215_1.conda
       - conda: https://conda.anaconda.org/conda-forge/linux-64/gtk3-3.24.52-ha5ea40c_0.conda
@@ -311,6 +312,7 @@ environments:
       - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda
       - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.9.0-pyhd8ed1ab_0.conda
       - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://prefix.dev/ship/linux-64/mp-units-2.5.0-hb0f4dca_5.conda
   lint:
     channels:
     - url: https://prefix.dev/ship/
@@ -368,6 +370,7 @@ environments:
       - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.15-hecca717_0.conda
       - conda: https://conda.anaconda.org/conda-forge/linux-64/graphviz-14.1.2-h8b86629_0.conda
       - conda: https://conda.anaconda.org/conda-forge/linux-64/gsl-2.7-he838d99_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gsl-lite-1.1.0-h80b0018_0.conda
       - conda: https://conda.anaconda.org/conda-forge/linux-64/gsoap-2.8.123-h8dc497d_0.tar.bz2
       - conda: https://conda.anaconda.org/conda-forge/linux-64/gtest-1.17.0-h84d6215_1.conda
       - conda: https://conda.anaconda.org/conda-forge/linux-64/gtk3-3.24.52-ha5ea40c_0.conda
@@ -639,6 +642,7 @@ environments:
       - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda
       - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.9.0-pyhd8ed1ab_0.conda
       - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://prefix.dev/ship/linux-64/mp-units-2.5.0-hb0f4dca_5.conda
       - pypi: https://files.pythonhosted.org/packages/1f/24/d78b534075bfc9cf51b555c7d180ff516636b83e42565263dc84b8f4b794/gersemi-0.27.7-cp314-cp314-manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/49/14/32e3a2c4313367a38b9c8b564785444bb3ed31317386fb81efd80496a5af/ignore_python-0.3.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/66/65/08d3a5039b565231c501b31d1a973d4222e9803c03b2c31a9c08bdec3e30/cpplint-2.0.2-py3-none-any.whl
@@ -1480,6 +1484,19 @@ packages:
     - gsl >=2.7,<2.8.0a0
   size: 3376423
   timestamp: 1626369596591
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gsl-lite-1.1.0-h80b0018_0.conda
+  sha256: 92ef3199c72033cc9fc6602bce79525c9c94891ca33e9aa1aa37bcf7ebbef9db
+  md5: 6b9d1a46dffecb2f742b735b48f1ea3d
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 48264
+  timestamp: 1781272988265
 - conda: https://conda.anaconda.org/conda-forge/linux-64/gsoap-2.8.123-h8dc497d_0.tar.bz2
   sha256: c6a16f2b36a6a653d399cc542214b3601c54097dd5f6c4b96a0f3302d3d6480d
   md5: e539f696d01d28dc42313a2ce66c0627
@@ -6152,6 +6169,20 @@ packages:
   run_exports: {}
   size: 24190
   timestamp: 1779159948016
+- conda: https://prefix.dev/ship/linux-64/mp-units-2.5.0-hb0f4dca_5.conda
+  sha256: 98eb61e874a65c8172a6dc7ed7a111f68934c563955ff4448f14b681e8686dca
+  md5: d32935557c13c811d14f573bf78c4490
+  depends:
+  - gsl-lite
+  - libstdcxx >=15
+  - libgcc >=15
+  - __glibc >=2.17,<3.0.a0
+  license: MIT
+  run_exports:
+    weak:
+    - mp-units >=2.5.0,<2.6.0a0
+  size: 110217
+  timestamp: 1781445240307
 - pypi: https://files.pythonhosted.org/packages/1f/24/d78b534075bfc9cf51b555c7d180ff516636b83e42565263dc84b8f4b794/gersemi-0.27.7-cp314-cp314-manylinux_2_28_x86_64.whl
   name: gersemi
   version: 0.27.7
diff --git a/pixi.toml b/pixi.toml
index 6968005..12c0515 100644
--- a/pixi.toml
+++ b/pixi.toml
@@ -16,6 +16,8 @@ ninja = "*"
 git = "*"
 root = ">=6.40"
 root_cxx_standard = "==23"
+# Required by the SHiP::SHiPUnits target (find_package(mp-units CONFIG)).
+mp-units = ">=2.5"
 
 [tasks]
 configure = "cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=RelWithDebInfo"
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 2d66ee0..5d8e416 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -18,3 +18,8 @@ target_link_libraries(
     PRIVATE ${link_dictionary} ROOT::Core ROOT::RIO ROOT::ROOTNTuple
 )
 add_test(NAME rntuple_io COMMAND test_rntuple_io)
+
+# Units and quantity views are headers-only: no dictionary, no ROOT.
+add_executable(test_units test_units.cpp)
+target_link_libraries(test_units PRIVATE SHiP::SHiPUnits)
+add_test(NAME units COMMAND test_units)
diff --git a/tests/test_units.cpp b/tests/test_units.cpp
new file mode 100644
index 0000000..da38b82
--- /dev/null
+++ b/tests/test_units.cpp
@@ -0,0 +1,106 @@
+/// Tests for the canonical unit vocabulary: exact conversion factors, bitwise
+/// POD round-trips through the quantity views, and compile-time dimension
+/// safety. Returns non-zero on failure.
+
+#include <array>
+#include <cmath>
+#include <cstdio>
+#include <string>
+
+#include "SHiP/MCParticle.hpp"
+#include "SHiP/QuantityView.hpp"
+#include "SHiP/SimHit.hpp"
+#include "SHiP/Units.hpp"
+
+namespace su = ship::units;
+
+namespace {
+
+int failures = 0;
+
+void expect(bool ok, std::string const& what) {
+  if (!ok) {
+    std::printf("FAIL: %s\n", what.c_str());
+    ++failures;
+  }
+}
+
+// Energy and momentum have different dimensions: mixing them must not compile.
+template <typename E, typename P>
+concept AddsWithMomentum = requires(E e, P p) { e + p; };
+static_assert(!AddsWithMomentum<ship::Energy, ship::Momentum>,
+              "energy + momentum must be a compile error");
+static_assert(AddsWithMomentum<ship::Energy, ship::Energy>);
+
+// Canonical types store in the canonical units (no hidden conversion).
+static_assert(ship::Length::unit == su::mm);
+static_assert(ship::Time::unit == su::ns);
+static_assert(ship::Energy::unit == su::GeV);
+
+}  // namespace
+
+int main() {
+  // mm/c -> ns uses the exact SI definition of c; compare against the
+  // hand-derived factor 1 / 299.792458 (the constant FairShip hardcoded).
+  double const mm_per_c_in_ns = (1.0 * su::mm_per_c).numerical_value_in(su::ns);
+  double const reference = 1.0 / 299.792458;
+  expect(std::abs(mm_per_c_in_ns - reference) <= 1e-16,
+         "1 mm/c in ns matches 1/299.792458");
+
+  // Exact power-of-ten factors.
+  expect((1.0 * su::GeV).numerical_value_in(su::MeV) == 1000.0,
+         "GeV -> MeV is exactly 1000");
+  expect((1.0 * su::m).numerical_value_in(su::mm) == 1000.0,
+         "m -> mm is exactly 1000");
+  expect((1.0 * su::s).numerical_value_in(su::ns) == 1e9,
+         "s -> ns is exactly 1e9");
+
+  // vecOf/raw round-trip must be bitwise (storage unit == quantity unit).
+  std::array<double, 3> const v{1.0000000000000002, -2.5e-17, 3.9e12};
+  expect(ship::raw(ship::vecOf<ship::Length>(v)) == v,
+         "Length vecOf/raw round-trip is bitwise");
+  expect(ship::raw(ship::vecOf<ship::Momentum>(v)) == v,
+         "Momentum vecOf/raw round-trip is bitwise");
+
+  // Quantity views round-trip the PODs bitwise.
+  SHiP::MCParticle mc;
+  mc.vertex = {1.1, 2.2, 3.3};
+  mc.momentum = {0.1, 0.2, 40.0};
+  mc.energy = 40.001;
+  mc.time = 5.5;
+  SHiP::MCParticle copy;
+  ship::view::setVertex(copy, ship::view::vertex(mc));
+  ship::view::setMomentum(copy, ship::view::momentum(mc));
+  ship::view::setEnergy(copy, ship::view::energy(mc));
+  ship::view::setTime(copy, ship::view::time(mc));
+  expect(copy.vertex == mc.vertex && copy.momentum == mc.momentum &&
+             copy.energy == mc.energy && copy.time == mc.time,
+         "MCParticle view round-trip is bitwise");
+
+  SHiP::SimHit hit;
+  hit.position = {-0.5, 0.0, 12000.0};
+  hit.momentum = {0.01, -0.02, 3.0};
+  hit.energyDeposit = 0.00123;
+  hit.time = 7.25;
+  hit.pathLength = 0.3;
+  SHiP::SimHit hitCopy;
+  ship::view::setPosition(hitCopy, ship::view::position(hit));
+  ship::view::setMomentum(hitCopy, ship::view::momentum(hit));
+  ship::view::setEnergyDeposit(hitCopy, ship::view::energyDeposit(hit));
+  ship::view::setTime(hitCopy, ship::view::time(hit));
+  ship::view::setPathLength(hitCopy, ship::view::pathLength(hit));
+  expect(hitCopy.position == hit.position && hitCopy.momentum == hit.momentum &&
+             hitCopy.energyDeposit == hit.energyDeposit &&
+             hitCopy.time == hit.time && hitCopy.pathLength == hit.pathLength,
+         "SimHit view round-trip is bitwise");
+
+  // A deliberately non-canonical input converts, rather than reinterprets.
+  auto const z = 1.5 * su::m;
+  expect(ship::Length{z}.numerical_value_in(su::mm) == 1500.0,
+         "1.5 m stored as Length is 1500 mm");
+
+  if (failures == 0) {
+    std::printf("all unit tests passed\n");
+  }
+  return failures;
+}

From 516ef8829f5ac2761ac6533de62008b7cb4aa1f7 Mon Sep 17 00:00:00 2001
From: Oliver Lantwin <oliver.lantwin@cern.ch>
Date: Tue, 14 Jul 2026 12:07:54 +0200
Subject: [PATCH 2/2] test: add SimParticle and RecParticle view round-trips

---
 tests/test_units.cpp | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/tests/test_units.cpp b/tests/test_units.cpp
index da38b82..b544dab 100644
--- a/tests/test_units.cpp
+++ b/tests/test_units.cpp
@@ -9,7 +9,9 @@
 
 #include "SHiP/MCParticle.hpp"
 #include "SHiP/QuantityView.hpp"
+#include "SHiP/RecParticle.hpp"
 #include "SHiP/SimHit.hpp"
+#include "SHiP/SimParticle.hpp"
 #include "SHiP/Units.hpp"
 
 namespace su = ship::units;
@@ -94,6 +96,42 @@ int main() {
              hitCopy.time == hit.time && hitCopy.pathLength == hit.pathLength,
          "SimHit view round-trip is bitwise");
 
+  SHiP::SimParticle sp;
+  sp.vertex = {0.0, 0.0, -100.0};
+  sp.endpoint = {1.0, 0.5, 500.0};
+  sp.momentum = {0.0, 0.0, 50.0};
+  sp.energy = 49.9;
+  sp.time = 0.0;
+  SHiP::SimParticle spCopy;
+  ship::view::setVertex(spCopy, ship::view::vertex(sp));
+  ship::view::setEndpoint(spCopy, ship::view::endpoint(sp));
+  ship::view::setMomentum(spCopy, ship::view::momentum(sp));
+  ship::view::setEnergy(spCopy, ship::view::energy(sp));
+  ship::view::setTime(spCopy, ship::view::time(sp));
+  expect(spCopy.vertex == sp.vertex && spCopy.endpoint == sp.endpoint &&
+             spCopy.momentum == sp.momentum && spCopy.energy == sp.energy &&
+             spCopy.time == sp.time,
+         "SimParticle view round-trip is bitwise");
+
+  SHiP::RecParticle rp;
+  rp.vertex = {0.1, 0.2, 0.3};
+  rp.endpoint = {1.0, 2.0, 3.0};
+  rp.momentum = {0.5, -0.3, 10.0};
+  rp.energy = 9.8;
+  rp.time = 1.1;
+  rp.ipPV = 0.012;
+  SHiP::RecParticle rpCopy;
+  ship::view::setVertex(rpCopy, ship::view::vertex(rp));
+  ship::view::setEndpoint(rpCopy, ship::view::endpoint(rp));
+  ship::view::setMomentum(rpCopy, ship::view::momentum(rp));
+  ship::view::setEnergy(rpCopy, ship::view::energy(rp));
+  ship::view::setTime(rpCopy, ship::view::time(rp));
+  ship::view::setIpPV(rpCopy, ship::view::ipPV(rp));
+  expect(rpCopy.vertex == rp.vertex && rpCopy.endpoint == rp.endpoint &&
+             rpCopy.momentum == rp.momentum && rpCopy.energy == rp.energy &&
+             rpCopy.time == rp.time && rpCopy.ipPV == rp.ipPV,
+         "RecParticle view round-trip is bitwise");
+
   // A deliberately non-canonical input converts, rather than reinterprets.
   auto const z = 1.5 * su::m;
   expect(ship::Length{z}.numerical_value_in(su::mm) == 1500.0,