Add global Celeritas input definition

app/celer-g4/RunInput.cc

@@ -6,7 +6,12 @@
 //---------------------------------------------------------------------------//
 #include "RunInput.hh"
 
+#include <fstream>
+
 #include "corecel/io/EnumStringMapper.hh"
+#include "corecel/io/Logger.hh"
+#include "corecel/math/ArrayUtils.hh"
+#include "celeritas/inp/Input.hh"
 #include "accel/SharedParams.hh"
 
 namespace celeritas
@@ -57,6 +62,143 @@ RunInput::operator bool() const
            && (step_diagnostic_bins > 0 || !step_diagnostic);
 }
 
+//---------------------------------------------------------------------------//
+inp::Input to_input(RunInput const& run_input)
+{
+    using namespace celeritas;
+
+    inp::Input result;
+
+    result.tuning.environ
+        = {run_input.environ.begin(), run_input.environ.end()};
+
+    // TODO: add option to enable/disable rather than checking device/env
+    if (celeritas::device())
+    {
+        inp::Device device;
+        device.stack_size = run_input.cuda_stack_size;
+        device.heap_size = run_input.cuda_heap_size;
+        device.default_stream = run_input.default_stream;
+        result.tuning.device = std::move(device);
+    }
+
+    // Problem definition
+    result.geometry_file = run_input.geometry_file;
+
+    if (!run_input.event_file.empty())
+    {
+        inp::ReadFileEvents events;
+        events.event_file = run_input.event_file;
+        result.events = std::move(events);
+    }
+    else if (run_input.primary_options)
+    {
+        inp::PrimaryGenerator generator;
+        generator = run_input.primary_options;
+        result.events = std::move(generator);
+    }
+
+    // Control options
+    {
+        inp::StateCapacity capacity;
+        capacity.tracks = run_input.num_track_slots;
+        capacity.initializers = run_input.initializer_capacity;
+        capacity.secondaries = static_cast<size_type>(
+            run_input.secondary_stack_factor * run_input.num_track_slots);
+        capacity.primaries = run_input.auto_flush;
+        result.tuning.capacity = std::move(capacity);
+    }
+
+    {
+        inp::TrackingLimits limits;
+        limits.steps = run_input.max_steps;
+        result.tracking.limits = std::move(limits);
+    }
+
+    result.tuning.track_order = [&] {
+        auto track_order = run_input.track_order;
+        if (track_order != TrackOrder::size_)
+            return track_order;
+
+        if (result.tuning.device)
+        {
+            // Device is activated: initializing by charge is more performant
+            return TrackOrder::init_charge;
+        }
+
+        // Device is not active: don't ort
+        return TrackOrder::none;
+    }();
+
+    // Field setup
+    if (run_input.field_type == "rzmap")
+    {
+        CELER_LOG_LOCAL(info)
+            << "Loading RZMapField from " << run_input.field_file;
+        std::ifstream inp(run_input.field_file);
+        CELER_VALIDATE(inp,
+                       << "failed to open field map file at '"
+                       << run_input.field_file << "'");
+
+        // Read RZ map from file
+        RZMapFieldInput rzmap;
+        inp >> rzmap;
+
+        // Replace driver options with user options
+        rzmap.driver_options = run_input.field_options;
+
+        result.field = std::move(rzmap);
+    }
+    else if (run_input.field_type == "uniform")
+    {
+        inp::UniformField field;
+        field.strength = run_input.field;
+
+        auto field_val = norm(field.strength);
+        CELER_LOG_LOCAL(info)
+            << "Using a uniform field " << field_val << " [T]";
+        if (field_val > 0)
+        {
+            field.driver_options = run_input.field_options;
+            result.field = std::move(field);
+        }
+    }
+    else
+    {
+        CELER_VALIDATE(
+            false, << "invalid field type '" << run_input.field_type << "'");
+    }
+
+    if (run_input.sd_type != SensitiveDetectorType::none)
+    {
+        // Activate Geant4 SD callbacks
+        result.scoring.sd.emplace();
+    }
+
+    // Diagnostics
+    auto& d = result.diagnostics;
+    d.output_file = run_input.output_file;
+    d.export_files.physics = run_input.physics_output_file;
+    d.export_files.offload = run_input.offload_output_file;
+    d.timers.action = run_input.action_times;
+
+    if (!run_input.slot_diagnostic_prefix.empty())
+    {
+        inp::SlotDiagnostic slot_diag;
+        slot_diag.basename = run_input.slot_diagnostic_prefix;
+        d.slot = std::move(slot_diag);
+    }
+
+    if (run_input.step_diagnostic)
+    {
+        inp::StepDiagnostic step;
+        step.bins = run_input.step_diagnostic_bins;
+        d.step = std::move(step);
+    }
+
+    return result;
+}
+
 //---------------------------------------------------------------------------//
 }  // namespace app
 }  // namespace celeritas

app/celer-g4/RunInput.hh

@@ -25,6 +25,12 @@
 
 namespace celeritas
 {
+//---------------------------------------------------------------------------//
+namespace inp
+{
+struct Input;
+}
+
 namespace app
 {
 //---------------------------------------------------------------------------//
@@ -121,6 +127,8 @@ struct RunInput
 char const* to_cstring(PhysicsListSelection value);
 char const* to_cstring(SensitiveDetectorType value);
 
+inp::Input to_input(RunInput const& run_input);
+
 //---------------------------------------------------------------------------//
 }  // namespace app
 }  // namespace celeritas

app/celer-sim/RunnerInput.cc

@@ -0,0 +1,166 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file celer-sim/RunnerInput.cc
+//---------------------------------------------------------------------------//
+#include "RunnerInput.hh"
+
+#include <limits>
+
+#include "celeritas/field/FieldDriverOptions.hh"
+#include "celeritas/inp/Input.hh"
+
+#include "PrimaryGeneratorOptions.hh"
+
+namespace celeritas
+{
+namespace app
+{
+//---------------------------------------------------------------------------//
+inp::Input to_input(RunnerInput const& r)
+{
+    inp::Input result;
+
+    // Geometry and event configurations
+    result.geometry_file = r.geometry_file;
+
+    if (!run_input.event_file.empty())
+    {
+        if (r.file_sampling_options)
+        {
+            inp::SampleFileEvents sfe;
+            sfe.num_events = r.file_sampling_options.num_events;
+            sfe.num_merged = r.file_sampling_options.num_merged;
+            sfe.event_file = r.event_file;
+            result.events = std::move(sfe);
+        }
+        else
+        {
+            inp::ReadFileEvents rfe;
+            rfe.event_file = r.event_file;
+            result.events = std::move(rfe);
+        }
+    }
+    else if (run_input.primary_options)
+    {
+        inp::PrimaryGenerator generator;
+        result.events = to_input(r.primary_options);
+    }
+
+    // Magnetic field
+    if (r.field == RunnerInput::no_field())
+    {
+        result.field = inp::NoField{};
+    }
+    else
+    {
+        inp::UniformField field;
+        field.strength = r.field;
+        field.driver_options = r.field_options;
+        result.field = field;
+    }
+
+    // Diagnostics
+    auto& d = result.diagnostics;
+    if (!r.mctruth_file.empty())
+    {
+        inp::McTruth mct;
+        mct.output_file = r.mctruth_file;
+        mct.filter = r.mctruth_filter;
+        d.mctruth = std::move(mct);
+    }
+    d.perfetto_file = r.tracing_file;
+    d.timers.action = r.action_times;
+    d.timers.step = r.write_step_times;
+    d.action = r.action_diagnostic;
+    if (!r.slot_diagnostic_prefix.empty())
+    {
+        inp::SlotDiagnostic slot_diag;
+        slot_diag.basename = r.slot_diagnostic_prefix;
+        d.slot = std::move(slot_diag);
+    }
+    if (r.step_diagnostic)
+    {
+        inp::StepDiagnostic step_diag;
+        step_diag.bins = r.step_diagnostic_bins;
+        d.step = std::move(step_diag);
+    }
+    d.step_counters = r.write_track_counts;
+
+    // Tuning
+    {
+        inp::StateCapacity capacity;
+        capacity.tracks = r.num_track_slots;
+        capacity.initializers = r.initializer_capacity;
+        capacity.secondaries = r.secondary_stack_factor * r.num_track_slots;
+
+        // TODO: replace "max" with # events during construction?
+        constexpr auto LimitsT
+            = numeric_limits<decltype(capacity.events)> capacity.events
+            = r.merge_events ? LimitsT::max() : 0;
+
+        result.tuning.capacity = capacity;
+    }
+
+    if (r.use_device)
+    {
+        inp::Device device;
+        device.stack_size = r.cuda_stack_size;
+        device.heap_size = r.cuda_heap_size;
+        device.default_stream = r.default_stream;
+        result.tuning.device = std::move(device);
+    }
+
+    result.tuning.warm_up = r.warm_up;
+
+    // Environment
+    result.tuning.environ = {r.environ.begin(), r.environ.end()};
+
+    // Physics
+    {
+        inp::EmPhysicsOptions em_options;
+        em_options.brem_combined = r.brem_combined;
+
+        // Spline energy loss order
+        CELER_VALIDATE(r.spline_eloss_order > 0 && r.spline_eloss_order <= 2,
+                       "unsupported energy loss spline order "
+                           << r.spline_eloss_order);
+        em_options.eloss_spline = (r.spline_eloss_order == 2);
+
+        // Step limiter for charged particles
+        em_options.step_limit = r.step_limiter;
+
+        result.physics.em_options = std::move(em_options);
+        result.physics.physics_file = r.physics_file;
+    }
+
+    // Tracking
+    inp::TrackingLimits tracking_limits;
+    tracking_limits.steps = r.max_steps;
+    result.tracking.limits = tracking_limits;
+
+    // Optical options
+    if (r.optical)
+    {
+        inp::StateCapacity optical_capacity;
+        optical_capacity.tracks = r.optical.num_track_slots;
+        optical_capacity.initializers = r.optical.initializer_capacity;
+        optical_capacity.primaries = r.optical.auto_flush;
+        result.tuning.optical_capacity = std::move(optical_capacity);
+    }
+
+    // Simple calorimeter scoring
+    if (!r.simple_calo.empty())
+    {
+        inp::SimpleCalo calo;
+        calo.volumes = r.simple_calo;
+        result.scoring.simple_calo = std::move(calo);
+    }
+
+    return result;
+}
+
+//---------------------------------------------------------------------------//
+}  // namespace app
+}  // namespace celeritas

app/celer-sim/RunnerInput.hh

@@ -35,9 +35,7 @@ namespace app
 /*!
  * Input for a single run.
  *
- * TODO for v1.0: unify these names, combine with celer-g4, separate into
- * schemas for individual classes, ... ? and decide whether max_steps should be
- * per track or total step iterations.
+ * DEPRECATED: `RunInput` will be used instead.
  */
 struct RunnerInput
 {
@@ -49,7 +47,7 @@ struct RunnerInput
         explicit operator bool() const
         {
             return num_events > 0 && num_merged > 0;
-        };
+        }
     };
 
     struct OpticalOptions
@@ -65,7 +63,7 @@ struct RunnerInput
         {
             return num_track_slots > 0 && buffer_capacity > 0
                    && initializer_capacity > 0 && auto_flush > 0;
-        };
+        }
     };
     static constexpr Real3 no_field() { return Real3{0, 0, 0}; }
     static constexpr size_type unspecified{0};