Add optical step gather action

src/celeritas/CMakeLists.txt

@@ -131,7 +131,9 @@ list(APPEND SOURCES
   optical/Types.cc
   optical/action/ActionGroups.cc
   optical/action/LocateVacanciesAction.cc
+  optical/action/OpticalStepGatherAction.cc
   optical/detail/OpticalLaunchAction.cc
+  optical/detail/OpticalStepParams.cc
   optical/surface/SurfacePhysicsParams.cc
   optical/surface/SurfaceSteppingAction.cc
   phys/CutoffParams.cc

src/celeritas/optical/CoreParams.cc

@@ -20,11 +20,16 @@
 #include "celeritas/geo/CoreGeoParams.hh"
 #include "celeritas/mat/MaterialParams.hh"
 #include "celeritas/optical/OpticalSizes.json.hh"
+#include "celeritas/optical/action/OpticalStepGatherAction.hh"
+#include "celeritas/optical/detail/OpticalStepData.hh"
+#include "celeritas/optical/detail/OpticalStepParams.hh"
 #include "celeritas/phys/GeneratorRegistry.hh"
 #include "celeritas/track/SimParams.hh"
+#include "celeritas/user/detail/StepGatherAction.hh"
 
 #include "CoreState.hh"
 #include "MaterialParams.hh"
+#include "OpticalStepInterface.hh"
 #include "PhysicsParams.hh"
 #include "SimParams.hh"
 #include "action/AlongStepAction.hh"
@@ -35,7 +40,6 @@
 #include "gen/CherenkovParams.hh"
 #include "gen/ScintillationParams.hh"
 #include "surface/SurfacePhysicsParams.hh"
-
 namespace celeritas
 {
 namespace optical
@@ -141,6 +145,10 @@ CoreParams::CoreParams(Input&& input) : input_(std::move(input))
     {
         input_.aux_reg = std::make_shared<AuxParamsRegistry>();
     }
+    if (std::getenv("CELER_OPTICAL_STEP"))
+    {
+        enable_optical_step_ = true;
+    }
     if (!input_.output_reg)
     {
         input_.output_reg = std::make_shared<OutputRegistry>();
@@ -175,6 +183,29 @@ CoreParams::CoreParams(Input&& input) : input_(std::move(input))
             input_.action_reg->next_id(), input_.optical_detector.callback));
     }
 
+    if (enable_optical_step_)
+    {
+        CELER_LOG(info) << "==== Optical Action Registry ====";
+
+        auto const& reg = input_.action_reg;
+        for (auto id : range(ActionId{reg->num_actions()}))
+        {
+            auto const& act = reg->id_to_label(id);
+            CELER_LOG(info) << id.get() << " -> " << act;
+        }
+        step_params_ = std::make_shared<optical::detail::OpticalStepParams>(
+            "optical-step", input_.aux_reg->next_id());
+        input_.aux_reg->insert(step_params_);
+
+        CELER_LOG(info) << "Optical step params registered with aux id "
+                        << step_params_->aux_id().get();
+
+        auto gather_id = input_.action_reg->next_id();
+
+        input_.action_reg->insert(
+            std::make_shared<optical::OpticalStepGatherAction>(gather_id,
+                                                               step_params_));
+    }
     // Save maximum number of streams
     scalars.max_streams = input_.max_streams;
 

src/celeritas/optical/CoreParams.hh

@@ -14,6 +14,8 @@
 #include "celeritas/geo/GeoFwd.hh"
 #include "celeritas/inp/Control.hh"
 #include "celeritas/inp/Scoring.hh"
+#include "celeritas/optical/detail/OpticalStepParams.hh"
+#include "celeritas/user/detail/StepParams.hh"
 
 #include "CoreTrackData.hh"
 
@@ -147,6 +149,13 @@ class CoreParams final : public ParamsDataInterface<CoreParamsData>
     }
     //!@}
 
+    //! Access optical step aux params
+    std::shared_ptr<optical::detail::OpticalStepParams> const&
+    step_params() const
+    {
+        return step_params_;
+    }
+
     // Access host pointers to core data
     using ParamsDataInterface<CoreParamsData>::ref;
 
@@ -164,6 +173,8 @@ class CoreParams final : public ParamsDataInterface<CoreParamsData>
 
     // Copy of DeviceRef in device memory
     DeviceVector<DeviceRef> device_ref_vec_;
+    bool enable_optical_step_{false};
+    std::shared_ptr<optical::detail::OpticalStepParams> step_params_;
 };
 
 //---------------------------------------------------------------------------//

src/celeritas/optical/OpticalStepInterface.hh

@@ -0,0 +1,52 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file celeritas/optical/OpticalStepInterface.hh
+//---------------------------------------------------------------------------//
+#pragma once
+#include "celeritas/user/StepData.hh"
+#include "celeritas/user/StepInterface.hh"
+
+namespace celeritas
+{
+
+namespace optical
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Minimal step interface for optical post-step gather.
+ *
+ * Internal-only: used to activate StepParams allocation
+ * for optical step data when enabled via environment variable.
+ */
+class OpticalStepInterface final : public StepInterface
+{
+  public:
+    //! Return reduced selection (post-step only)
+    StepSelection selection() const final
+    {
+        StepSelection sel;
+        sel.points[StepPoint::post].pos = true;
+        sel.points[StepPoint::post].volume_id = true;
+        return sel;
+    }
+
+    //! No detector filters
+    Filters filters() const final { return {}; }
+
+    //! No callback processing
+    void process_steps(HostStepState) final
+    {
+        // No-op: optical gather only
+    }
+    //! Device callback (no-op)
+    void process_steps(DeviceStepState) final
+    {
+        // No-op
+    }
+};
+
+//---------------------------------------------------------------------------//
+}  // namespace optical
+}  // namespace celeritas

src/celeritas/optical/action/OpticalStepGatherAction.cc

@@ -0,0 +1,63 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file celeritas/optical/action/OpticalStepGatherAction.cc
+//---------------------------------------------------------------------------//
+#include "OpticalStepGatherAction.hh"
+
+#include "corecel/data/AuxState.hh"
+#include "corecel/data/AuxStateVec.hh"
+
+#include "ActionLauncher.hh"
+#include "TrackSlotExecutor.hh"
+#include "../detail/OpticalStepGatherExecutor.hh"
+namespace celeritas
+{
+namespace optical
+{
+
+//---------------------------------------------------------------------------//
+OpticalStepGatherAction::OpticalStepGatherAction(ActionId id, SPParams params)
+    : StaticConcreteAction(
+          id, "optical-step-gather", "gather optical post-step data")
+    , step_params_(std::move(params))
+{
+    CELER_EXPECT(step_params_);
+}
+void OpticalStepGatherAction::step(CoreParams const& params,
+                                   CoreStateHost& state) const
+{
+    auto const& core_params = params.ref<MemSpace::native>();
+    auto& core_state = state.ref();
+
+    auto& step_state = step_params_->state_ref<MemSpace::native>(*state.aux());
+
+    // Launch pre-step executor
+    auto execute_pre
+        = TrackSlotExecutor(params.ptr<MemSpace::native>(),
+                            state.ptr(),
+                            detail::OpticalStepGatherExecutor<StepPoint::pre>{
+                                core_params, core_state, step_state});
+    launch_action(state, execute_pre);
+
+    // Launch post-step executor
+    auto execute_post
+        = TrackSlotExecutor(params.ptr<MemSpace::native>(),
+                            state.ptr(),
+                            detail::OpticalStepGatherExecutor<StepPoint::post>{
+                                core_params, core_state, step_state});
+    CELER_LOG(info) << "OpticalStepGatherAction::step State size "
+                    << state.size();
+    launch_action(state, execute_post);
+}
+#if !CELER_USE_DEVICE
+void OpticalStepGatherAction::step(CoreParams const&, CoreStateDevice&) const
+{
+    CELER_NOT_CONFIGURED("CUDA OR HIP");
+}
+#endif
+
+//---------------------------------------------------------------------------//
+}  // namespace optical
+}  // namespace celeritas

src/celeritas/optical/action/OpticalStepGatherAction.hh

@@ -0,0 +1,52 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file celeritas/optical/action/OpticalStepGatherAction.hh
+//---------------------------------------------------------------------------//
+#pragma once
+
+#include "corecel/sys/ThreadId.hh"
+#include "celeritas/optical/CoreParams.hh"
+#include "celeritas/optical/CoreState.hh"
+#include "celeritas/optical/detail/OpticalStepParams.hh"
+
+#include "ActionInterface.hh"
+
+namespace celeritas
+{
+namespace optical
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Brief class description.
+ *
+ * Optional detailed class description, and possibly example usage:
+ * \code
+    OpticalStepGatherAction ...;
+   \endcode
+ */
+class OpticalStepGatherAction : public StaticConcreteAction,
+                                public OpticalStepActionInterface
+{
+  public:
+    //!@{
+    //! \name Type aliases
+    using SPParams = std::shared_ptr<optical::detail::OpticalStepParams>;  //!@}
+
+    // Construct with defaults
+    OpticalStepGatherAction(ActionId, SPParams);
+    StepActionOrder order() const final { return StepActionOrder::post; }
+    void step(CoreParams const&, CoreStateHost&) const final;
+
+#if !CELER_USE_DEVICE
+    void step(CoreParams const&, CoreStateDevice&) const final;
+#endif
+
+  private:
+    SPParams step_params_;
+};
+
+//---------------------------------------------------------------------------//
+}  // namespace optical
+}  // namespace celeritas

src/celeritas/optical/detail/OpticalStepData.hh

@@ -0,0 +1,118 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file celeritas/optical/detail/OpticalStepData.hh
+//---------------------------------------------------------------------------//
+#pragma once
+
+#include "corecel/data/Collection.hh"
+#include "corecel/data/CollectionBuilder.hh"
+#include "corecel/data/CollectionMirror.hh"
+#include "corecel/io/JsonUtils.json.hh"
+#include "corecel/io/Logger.hh"
+#include "celeritas/Types.hh"
+
+namespace celeritas
+{
+namespace optical
+{
+namespace detail
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Brief class description.
+ *
+ * Optional detailed class description, and possibly example usage:
+ * \code
+    OpticalStepData ...;
+   \endcode
+ */
+
+//---------------------------------------------
+// PARAM DATA
+//---------------------------------------------
+template<Ownership W, MemSpace M>
+struct OpticalStepParamsData
+{
+    explicit CELER_FUNCTION operator bool() const { return true; }
+
+    template<Ownership W2, MemSpace M2>
+    OpticalStepParamsData& operator=(OpticalStepParamsData<W2, M2> const&)
+    {
+        return *this;
+    }
+};
+
+//---------------------------------------------
+// STATE DATA
+//---------------------------------------------
+template<Ownership W, MemSpace M>
+struct OpticalStepStateData
+{
+    template<class T>
+    using StateItems = StateCollection<T, W, M>;
+
+    StreamId stream;
+
+    StateItems<TrackSlotId> track_slot;
+    StateItems<Real3> pos;
+    StateItems<VolumeId> volume_id;
+
+    CELER_FUNCTION size_type size() const { return track_slot.size(); }
+
+    explicit CELER_FUNCTION operator bool() const
+    {
+        return stream && !track_slot.empty();
+    }
+
+    template<Ownership W2, MemSpace M2>
+    OpticalStepStateData& operator=(OpticalStepStateData<W2, M2>& other)
+    {
+        stream = other.stream;
+        track_slot = other.track_slot;
+        pos = other.pos;
+        volume_id = other.volume_id;
+        return *this;
+    }
+};
+
+template<MemSpace M>
+inline void resize(OpticalStepStateData<Ownership::value, M>* state,
+                   HostCRef<OpticalStepParamsData> const&,
+                   StreamId sid,
+                   size_type count)
+{
+    //  CELER_LOG(info) << "Optical step state" << count;
+    CELER_LOG(info) << "Resizing OpticalStepState to " << count;
+    state->stream = sid;
+
+    resize(&state->track_slot, count);
+    resize(&state->pos, count);
+    resize(&state->volume_id, count);
+}
+
+struct OpticalStepRecord
+{
+    unsigned int slot{};
+    unsigned int volume{};
+    unsigned int material{};
+    unsigned int action{};
+    double energy{};
+    double pos[3]{};
+};
+
+inline void to_json(nlohmann::json& j, OpticalStepRecord const& r)
+{
+    j = {{"slot", r.slot},
+         {"volume", r.volume},
+         {"material", r.material},
+         {"action", r.action},
+         {"energy", r.energy},
+         {"pos", {r.pos[0], r.pos[1], r.pos[2]}}};
+}
+
+//---------------------------------------------------------------------------//
+}  // namespace detail
+}  // namespace optical
+}  // namespace celeritas