Added Seth's changes

Author: Hollenbeck-Hayden

src/celeritas/optical/CoreTrackView.hh

@@ -75,10 +75,6 @@ class CoreTrackView
     // Return a surface physics view
     inline CELER_FUNCTION SurfacePhysicsView surface_physics() const;
 
-    // Return a surface model view for the given step
-    inline CELER_FUNCTION
-        SurfaceModelView surface_model(SurfacePhysicsOrder) const;
-
     // Return an RNG engine
     inline CELER_FUNCTION RngEngine rng() const;
 
@@ -234,20 +230,6 @@ CELER_FUNCTION auto CoreTrackView::surface_physics() const -> SurfacePhysicsView
                               this->track_slot_id()};
 }
 
-//---------------------------------------------------------------------------//
-/*!
- * Return a surface model view for the given step.
- */
-CELER_FUNCTION auto CoreTrackView::surface_model(SurfacePhysicsOrder step) const
-    -> SurfaceModelView
-{
-    auto s_physics = this->surface_physics();
-    CELER_EXPECT(s_physics.is_crossing_boundary());
-
-    return s_physics.surface_model(
-        s_physics.traversal_direction(this->geometry().dir()), step);
-}
-
 //---------------------------------------------------------------------------//
 /*!
  * Return the RNG engine.

src/celeritas/optical/action/ActionLauncher.device.hh

@@ -44,24 +44,25 @@ namespace optical
  }
  * \endcode
  */
-template<class F, class StepActionT = OpticalStepActionInterface>
+template<class F>
 class ActionLauncher : public KernelLauncher<F>
 {
     static_assert(
         (std::is_trivially_copyable_v<F> || CELERITAS_USE_HIP
          || CELER_COMPILER == CELER_COMPILER_CLANG)
             && !std::is_pointer_v<F> && !std::is_reference_v<F>,
         R"(Launched action must be a trivially copyable function object)");
-    // using StepActionT = OpticalStepActionInterface;
 
   public:
     // Create a launcher from a string
     using KernelLauncher<F>::KernelLauncher;
 
     // Create a launcher from an action
+    template<class StepActionT>
     explicit ActionLauncher(StepActionT const& action);
 
     // Create a launcher with a string extension
+    template<class StepActionT>
     ActionLauncher(StepActionT const& action, std::string_view ext);
 
     // Launch a kernel for a thread range or number of threads
@@ -76,30 +77,32 @@ class ActionLauncher : public KernelLauncher<F>
 /*!
  * Create a launcher from an action.
  */
-template<class F, class StepActionT>
-ActionLauncher<F, StepActionT>::ActionLauncher(StepActionT const& action)
-    : ActionLauncher{action.label()}
+template<class F>
+template<class StepActionT>
+ActionLauncher<F>::ActionLauncher(StepActionT const& action)
+    : KernelLauncher<F>{action.label()}
 {
 }
 
 //---------------------------------------------------------------------------//
 /*!
  * Create a launcher with a string extension.
  */
-template<class F, class StepActionT>
-ActionLauncher<F, StepActionT>::ActionLauncher(StepActionT const& action,
-                                               std::string_view ext)
-    : ActionLauncher{std::string(action.label()) + "-" + std::string(ext)}
+template<class F>
+template<class StepActionT>
+ActionLauncher<F>::ActionLauncher(StepActionT const& action,
+                                  std::string_view ext)
+    : KernelLauncher<F>{std::string(action.label()) + "-" + std::string(ext)}
 {
 }
 
 //---------------------------------------------------------------------------//
 /*!
  * Launch a kernel for the wrapped executor.
  */
-template<class F, class StepActionT>
-void ActionLauncher<F, StepActionT>::operator()(
-    CoreState<MemSpace::device> const& state, F const& call_thread) const
+template<class F>
+void ActionLauncher<F>::operator()(CoreState<MemSpace::device> const& state,
+                                   F const& call_thread) const
 {
     return (*this)(
         range(ThreadId{state.size()}), state.stream_id(), call_thread);

src/celeritas/optical/surface/SurfacePhysicsParams.cc

@@ -11,11 +11,12 @@
 #include "celeritas/inp/SurfacePhysics.hh"
 #include "celeritas/phys/SurfacePhysicsMapBuilder.hh"
 
-#include "BuiltinSurfaceModelBuilder.hh"
 #include "model/GaussianRoughnessModel.hh"
 #include "model/PolishedRoughnessModel.hh"
 #include "model/SmearRoughnessModel.hh"
 
+#include "detail/BuiltinSurfaceModelBuilder.hh"
+
 namespace celeritas
 {
 namespace optical
@@ -133,7 +134,7 @@ auto SurfacePhysicsParams::build_models(
     for (auto step : range(SurfacePhysicsOrder::size_))
     {
         // Build fake models
-        BuiltinSurfaceModelBuilder build_model{step_models[step]};
+        detail::BuiltinSurfaceModelBuilder build_model{step_models[step]};
         switch (step)
         {
             case SurfacePhysicsOrder::roughness:

src/celeritas/optical/surface/SurfacePhysicsView.hh

@@ -123,6 +123,10 @@ class SurfacePhysicsView
         SurfaceModelView surface_model(SubsurfaceDirection,
                                        SurfacePhysicsOrder) const;
 
+    // Get surface model for the given step
+    inline CELER_FUNCTION SurfaceModelView
+    surface_model(Real3 const&, SurfacePhysicsOrder) const;
+
     // Get local facet normal
     inline CELER_FUNCTION Real3 const& facet_normal() const;
 
@@ -375,6 +379,21 @@ CELER_FUNCTION SurfaceModelView SurfacePhysicsView::surface_model(
         this->subsurface_material(this->subsurface_position() + dir)};
 }
 
+//---------------------------------------------------------------------------//
+/*!
+ * Get surface model view of the given step for a track moving in the given
+ * direction.
+ *
+ * Helper function that determines the traversal direction from the track
+ * direction and constructs a surface model from it.
+ */
+CELER_FUNCTION SurfaceModelView SurfacePhysicsView::surface_model(
+    Real3 const& dir, SurfacePhysicsOrder step) const
+{
+    CELER_EXPECT(this->is_crossing_boundary());
+    return this->surface_model(this->traversal_direction(dir), step);
+}
+
 //---------------------------------------------------------------------------//
 /*!
  * Get local facet normal after roughness sampling.

src/celeritas/optical/surface/TrackSlotExecutor.hh

@@ -27,7 +27,10 @@ struct IsSurfaceModelEqual
     CELER_FUNCTION bool operator()(CoreTrackView const& track) const
     {
         return track.surface_physics().is_crossing_boundary()
-               && track.surface_model(step).surface_model() == model;
+               && track.surface_physics()
+                          .surface_model(track.geometry().dir(), step)
+                          .surface_model()
+                      == model;
     }
 };
 

src/celeritas/optical/surface/BuiltinSurfaceModelBuilder.hh renamed to src/celeritas/optical/surface/detail/BuiltinSurfaceModelBuilder.hh

@@ -2,21 +2,18 @@
 // Copyright Celeritas contributors: see top-level COPYRIGHT file for details
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 //---------------------------------------------------------------------------//
-//! \file celeritas/optical/surface/BuiltinSurfaceModelBuilder.hh
+//! \file celeritas/optical/surface/detail/BuiltinSurfaceModelBuilder.hh
 //---------------------------------------------------------------------------//
 #pragma once
 
 #include <memory>
 
-#include "SurfaceModel.hh"
-#include "model/BuiltinSurfaceModel.hh"
+#include "celeritas/optical/surface/model/BuiltinSurfaceModel.hh"
 
 namespace celeritas
 {
 namespace optical
 {
-namespace
-{
 //---------------------------------------------------------------------------//
 template<>
 struct BuiltinApplier<SurfacePhysicsOrder::size_>
@@ -25,6 +22,10 @@ struct BuiltinApplier<SurfacePhysicsOrder::size_>
     using Applier = TrivialApplier<T>;
 };
 
+namespace detail
+{
+namespace
+{
 //---------------------------------------------------------------------------//
 /*!
  * Fake model as a placeholder for surface models yet to be implemented.
@@ -88,7 +89,7 @@ class BuiltinSurfaceModelBuilder
 
   public:
     // Construct with storage to fill
-    inline BuiltinSurfaceModelBuilder(std::vector<SPModel>& models);
+    explicit inline BuiltinSurfaceModelBuilder(std::vector<SPModel>& models);
 
     // Construct a fake surface model
     template<class T>
@@ -190,5 +191,6 @@ std::shared_ptr<M> BuiltinSurfaceModelBuilder::builtin_model_from_input(
 }
 
 //---------------------------------------------------------------------------//
+}  // namespace detail
 }  // namespace optical
 }  // namespace celeritas

src/celeritas/optical/surface/detail/InitBoundaryExecutor.hh

@@ -90,10 +90,18 @@ CELER_FUNCTION void InitBoundaryExecutor::operator()(CoreTrackView& track) const
         oriented_surface.orientation = SubsurfaceDirection::forward;
     }
 
+    // Enforce surface normal convention, swapping normal if geometry returns
+    // one not entering the surface
+    Real3 global_normal = geo.normal();
+    if (!is_entering_surface(geo.dir(), global_normal))
+    {
+        global_normal = -global_normal;
+    }
+
     surface_physics
         = SurfacePhysicsView::Initializer{oriented_surface.surface,
                                           oriented_surface.orientation,
-                                          geo.normal(),
+                                          global_normal,
                                           pre_volume_material,
                                           post_volume_material};
 

src/celeritas/optical/surface/model/BuiltinSurfaceModel.hh

@@ -17,8 +17,6 @@ namespace celeritas
 {
 namespace optical
 {
-namespace
-{
 //---------------------------------------------------------------------------//
 /*!
  * Trivial applier which just forwards the track to the executor.
@@ -62,8 +60,6 @@ struct BuiltinApplier<SurfacePhysicsOrder::interaction>
     using Applier = TrivialApplier<T>;
 };
 
-}  // namespace
-
 //---------------------------------------------------------------------------//
 /*!
  * Templated base class for built-in optical surface physics models.
@@ -80,7 +76,7 @@ class BuiltinSurfaceModel : public SurfaceModel
     //!@{
     //! \name Type aliases
     template<class T>
-    using Applier = typename BuiltinApplier<S>::Applier<T>;
+    using Applier = typename BuiltinApplier<S>::template Applier<T>;
     //!@}
 
   public:

src/celeritas/optical/surface/model/GaussianRoughnessModel.cu

@@ -27,8 +27,7 @@ void GaussianRoughnessModel::step(CoreParams const& params,
     auto execute = this->make_executor(
         params, state, GaussianRoughnessExecutor{data_.device_ref()});
 
-    static ActionLauncher<decltype(execute), SurfaceModel> const launch_kernel(
-        *this);
+    static ActionLauncher<decltype(execute)> const launch_kernel(*this);
     launch_kernel(state, execute);
 }
 

src/celeritas/optical/surface/model/PolishedRoughnessModel.cu

@@ -27,8 +27,7 @@ void PolishedRoughnessModel::step(CoreParams const& params,
     auto execute
         = this->make_executor(params, state, PolishedRoughnessExecutor{});
 
-    static ActionLauncher<decltype(execute), SurfaceModel> const launch_kernel(
-        *this);
+    static ActionLauncher<decltype(execute)> const launch_kernel(*this);
     launch_kernel(state, execute);
 }