Skip to content

Add optical problem input and setup #2189

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
amandalund merged 6 commits into from
Jan 13, 2026
Merged

Add optical problem input and setup #2189

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
4fdcd38
Store aux registry in optical core params
amandalund Dec 18, 2025
c22e26d
Refactor input and setup to support optical-only celeritas simulation
amandalund Jan 5, 2026
f344b6f
Fix mismatched tags
amandalund Jan 10, 2026
b7da7e5
clang-tidy
amandalund Jan 11, 2026
f24191b
Address feedback
amandalund Jan 12, 2026
ba8021c
Merge branch 'develop' into optical-problem
amandalund Jan 12, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 6 additions & 6 deletions src/accel/LocalOpticalOffload.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -44,16 +44,16 @@ LocalOpticalOffload::LocalOpticalOffload(SetupOptions const& options,
<< "invalid optical photon generation mechanism for local "
"optical offload");

// Check the thread ID and MT model
validate_geant_threading(params.Params()->max_streams());

// Save a pointer to the optical transporter
transport_ = params.optical_transporter();
transport_ = params.optical_problem_loaded().transporter;
CELER_ASSERT(transport_);

CELER_ASSERT(transport_->params());
auto const& optical_params = *transport_->params();

// Check the thread ID and MT model
validate_geant_threading(optical_params.max_streams());

// Save a pointer to the generator action
auto const& gen_reg = *optical_params.gen_reg();
for (auto gen_id : range(GeneratorId(gen_reg.size())))
Expand Down Expand Up @@ -88,10 +88,10 @@ LocalOpticalOffload::LocalOpticalOffload(SetupOptions const& options,
}

// Allocate auxiliary data
if (params.Params()->aux_reg())
if (optical_params.aux_reg())
{
state_->aux() = std::make_shared<AuxStateVec>(
*params.Params()->aux_reg(), memspace, stream_id, capacity.tracks);
*optical_params.aux_reg(), memspace, stream_id, capacity.tracks);
}

CELER_ENSURE(*this);
Expand Down
5 changes: 2 additions & 3 deletions src/accel/LocalTransporter.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -43,6 +43,7 @@
#include "celeritas/inp/Control.hh"
#include "celeritas/io/EventWriter.hh"
#include "celeritas/io/JsonEventWriter.hh"
#include "celeritas/io/OffloadWriter.hh"
#include "celeritas/io/RootEventWriter.hh"
#include "celeritas/optical/CoreState.hh"
#include "celeritas/optical/OpticalCollector.hh"
Expand All @@ -52,8 +53,6 @@
#include "SetupOptions.hh"
#include "SharedParams.hh"

#include "detail/OffloadWriter.hh"

namespace celeritas
{
namespace
Expand Down Expand Up @@ -209,7 +208,7 @@ LocalTransporter::LocalTransporter(SetupOptions const& options,
params.set_state(stream_id.get(), step_->sp_state());

// Save optical pointers if available, for diagnostics
optical_ = params.optical_collector();
optical_ = params.problem_loaded().optical_collector;

CELER_ENSURE(*this);
}
Expand Down
4 changes: 2 additions & 2 deletions src/accel/LocalTransporter.hh
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,11 +26,11 @@ namespace celeritas
namespace detail
{
class HitProcessor;
class OffloadWriter;
} // namespace detail

struct SetupOptions;
class CoreStateInterface;
class OffloadWriter;
class OpticalCollector;
class ParticleParams;
class SharedParams;
Expand Down Expand Up @@ -102,7 +102,7 @@ class LocalTransporter final : public LocalOffloadInterface
private:
//// TYPES ////

using SPOffloadWriter = std::shared_ptr<detail::OffloadWriter>;
using SPOffloadWriter = std::shared_ptr<OffloadWriter>;
using BBox = BoundingBox<double>;

struct BufferAccum
Expand Down
56 changes: 52 additions & 4 deletions src/accel/SetupOptions.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -126,9 +126,7 @@ void ProblemSetup::operator()(inp::Problem& p) const
if (so.optical)
{
p.control.optical_capacity = so.optical->capacity;
p.physics.optical_generator = so.optical->generator;
p.tracking.optical_limits.steps = so.optical->max_steps;
p.tracking.optical_limits.step_iters = so.optical->max_step_iters;
p.tracking.optical_limits = so.optical->limits;
}

if (so.track_order != TrackOrder::size_)
Expand Down Expand Up @@ -218,6 +216,45 @@ void ProblemSetup::operator()(inp::Problem& p) const
p.diagnostics.add_user_actions = so.add_user_actions;
}

//---------------------------------------------------------------------------//
/*!
* FrameworkInput adapter function for optical-only offload.
*/
struct OpticalProblemSetup
{
SetupOptions const& so;

void operator()(inp::OpticalProblem&) const;
};

//---------------------------------------------------------------------------//
/*!
* Set a Celeritas optical problem input definition.
*/
void OpticalProblemSetup::operator()(inp::OpticalProblem& p) const
{
if (!so.geometry_file.empty())
{
p.model.geometry = so.geometry_file;
}

p.num_streams = [&so = this->so] {
if (so.get_num_streams)
{
return so.get_num_streams();
}
return celeritas::get_geant_num_threads();
}();

CELER_ASSERT(so.optical);
p.generator = so.optical->generator;
p.capacity = so.optical->capacity;
p.limits = so.optical->limits;
p.seed = CLHEP::HepRandom::getTheSeed();
p.timers.action = so.action_times;
p.output_file = so.output_file;
}

//---------------------------------------------------------------------------//
} // namespace

Expand Down Expand Up @@ -296,7 +333,18 @@ inp::FrameworkInput to_inp(SetupOptions const& so)
result.physics_import.data_selection.particles = selection;
result.physics_import.data_selection.processes = selection;

result.adjust = ProblemSetup{so};
if (!so.optical
|| std::holds_alternative<inp::OpticalEmGenerator>(
so.optical->generator))
{
result.adjust = ProblemSetup{so};
}
else
{
// Optical-only offload
result.adjust_optical = OpticalProblemSetup{so};
}

return result;
}

Expand Down
6 changes: 2 additions & 4 deletions src/accel/SetupOptions.hh
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -125,10 +125,8 @@ struct OpticalSetupOptions
inp::OpticalStateCapacity capacity;
//! Optical photon generation mechanism
inp::OpticalGenerator generator;
//! Limit on number of steps per track before killing
size_type max_steps{inp::TrackingLimits::unlimited};
//! Limit on number of optical step iterations before aborting
size_type max_step_iters{inp::TrackingLimits::unlimited};
//! Limits for the optical stepping loop
inp::OpticalTrackingLimits limits;
};

//---------------------------------------------------------------------------//
Expand Down
126 changes: 32 additions & 94 deletions src/accel/SharedParams.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,21 +29,16 @@

#include "corecel/Assert.hh"
#include "corecel/cont/ArrayIO.hh"
#include "corecel/cont/VariantUtils.hh"
#include "corecel/io/BuildOutput.hh"
#include "corecel/io/Join.hh"
#include "corecel/io/Logger.hh"
#include "corecel/io/OutputInterfaceAdapter.hh"
#include "corecel/io/OutputRegistry.hh"
#include "corecel/io/ScopedTimeLog.hh"
#include "corecel/io/StringUtils.hh"
#include "corecel/random/params/RngParams.hh"
#include "corecel/sys/ActionRegistry.hh"
#include "corecel/sys/Device.hh"
#include "corecel/sys/Environment.hh"
#include "corecel/sys/EnvironmentIO.json.hh"
#include "corecel/sys/KernelRegistry.hh"
#include "corecel/sys/MemRegistry.hh"
#include "corecel/sys/MemRegistryIO.json.hh"
#include "corecel/sys/ScopedMem.hh"
#include "corecel/sys/ScopedProfiling.hh"
#include "corecel/sys/ThreadId.hh"
Expand All @@ -60,12 +55,10 @@
#include "celeritas/global/CoreParams.hh"
#include "celeritas/inp/FrameworkInput.hh"
#include "celeritas/inp/Scoring.hh"
#include "celeritas/io/EventWriter.hh"
#include "celeritas/io/ImportData.hh"
#include "celeritas/io/JsonEventWriter.hh"
#include "celeritas/io/RootEventWriter.hh"
#include "celeritas/mat/MaterialParams.hh"
#include "celeritas/optical/CoreParams.hh"
#include "celeritas/optical/Transporter.hh"
#include "celeritas/phys/CutoffParams.hh"
#include "celeritas/phys/ParticleParams.hh"
#include "celeritas/phys/PhysicsParams.hh"
Expand All @@ -82,7 +75,6 @@
#include "TimeOutput.hh"

#include "detail/IntegrationSingleton.hh"
#include "detail/OffloadWriter.hh"

namespace celeritas
{
Expand Down Expand Up @@ -282,35 +274,24 @@ SharedParams::SharedParams(SetupOptions const& options)
? *options.offload_particles
: default_offload_particles();
}

if (mode_ != Mode::enabled)
{
// Stop initializing but create output registry for diagnostics
output_reg_ = std::make_shared<OutputRegistry>();
output_filename_ = options.output_file;
loaded_.output_file = options.output_file;

// Create the timing output
timer_
= std::make_shared<TimeOutput>(celeritas::get_geant_num_threads());

if (!output_filename_.empty())
if (!loaded_.output_file.empty())
{
CELER_LOG(debug)
<< R"(Constructing output registry for no-offload run)";

// Celeritas core params didn't add system metadata: do it
// ourselves to save system diagnostic information
output_reg_->insert(
OutputInterfaceAdapter<MemRegistry>::from_const_ref(
OutputInterface::Category::system,
"memory",
celeritas::mem_registry()));
output_reg_->insert(
OutputInterfaceAdapter<Environment>::from_const_ref(
OutputInterface::Category::system,
"environ",
celeritas::environment()));
output_reg_->insert(std::make_shared<BuildOutput>());
insert_system_diagnostics(*output_reg_);
output_reg_->insert(timer_);
}

Expand All @@ -319,60 +300,40 @@ SharedParams::SharedParams(SetupOptions const& options)

// Construct input and then build the problem setup
auto framework_inp = to_inp(options);
auto loaded = setup::framework_input(framework_inp);
params_ = std::move(loaded.problem.core_params);
CELER_ASSERT(params_);
output_filename_ = loaded.problem.output_file;

if (auto const& opt = options.optical)
{
if (std::holds_alternative<inp::OpticalOffloadGenerator>(opt->generator))
{
optical_transporter_
= std::move(loaded.problem.optical_transporter);
CELER_ASSERT(optical_transporter_);
}
else if (std::holds_alternative<inp::OpticalEmGenerator>(opt->generator))
{
optical_collector_ = std::move(loaded.problem.optical_collector);
CELER_ASSERT(optical_collector_);
}
else
{
CELER_VALIDATE(false,
<< "invalid optical photon generation mechanism");
}
}

// Save action sequence
actions_ = std::move(loaded.problem.actions);
CELER_ASSERT(actions_);
loaded_ = setup::framework_input(framework_inp);

// Load geant4 geometry adapter and save as "global"
CELER_ASSERT(loaded.geo);
geant_geo_ = std::move(loaded.geo);
celeritas::global_geant_geo(geant_geo_);

// Save built attributes
output_reg_ = params_->output_reg();
geant_sd_ = std::move(loaded.problem.geant_sd);
step_collector_ = std::move(loaded.problem.step_collector);

// Translate supported particles
verify_offload(
offload_particles_, *params_->particle(), *params_->physics());
CELER_ASSERT(loaded_.geo);
celeritas::global_geant_geo(loaded_.geo);

// Create bounding box from navigator geometry
bbox_ = geant_geo_->get_clhep_bbox();

// Create streams
this->set_num_streams(params_->max_streams());
bbox_ = loaded_.geo->get_clhep_bbox();

std::visit(
Overload{
[&](setup::ProblemLoaded const& p) {
// Translate supported particles
verify_offload(offload_particles_,
*p.core_params->particle(),
*p.core_params->physics());

// Set streams and output registry from core params
output_reg_ = p.core_params->output_reg();
this->set_num_streams(p.core_params->max_streams());
},
[&](setup::OpticalProblemLoaded const& p) {
// Set streams and output registry from optical params
output_reg_ = p.transporter->params()->output_reg();
this->set_num_streams(p.transporter->params()->max_streams());
},
},
loaded_.problem);

// Add timing output
timer_ = std::make_shared<TimeOutput>(params_->max_streams());
timer_ = std::make_shared<TimeOutput>(this->num_streams());
output_reg_->insert(timer_);

if (output_filename_ != "-")
if (loaded_.output_file != "-")
{
// Write output after params are constructed before anything can go
// wrong
Expand All @@ -384,29 +345,6 @@ SharedParams::SharedParams(SetupOptions const& options)
<< R"(Skipping 'startup' JSON output since writing to stdout)";
}

if (auto const& offload_file = loaded.problem.offload_file;
!offload_file.empty())
{
std::unique_ptr<EventWriterInterface> writer;
if (ends_with(offload_file, ".jsonl"))
{
writer.reset(
new JsonEventWriter(offload_file, params_->particle()));
}
else if (ends_with(offload_file, ".root"))
{
writer.reset(new RootEventWriter(
std::make_shared<RootFileManager>(offload_file.c_str()),
params_->particle()));
}
else
{
writer.reset(new EventWriter(offload_file, params_->particle()));
}
offload_writer_
= std::make_shared<detail::OffloadWriter>(std::move(writer));
}

CELER_ENSURE(*this);
}

Expand Down Expand Up @@ -526,7 +464,7 @@ void SharedParams::set_num_streams(unsigned int num_streams)
*/
void SharedParams::try_output() const
{
std::string filename = output_filename_;
std::string filename = loaded_.output_file;
if (filename.empty())
{
CELER_LOG(debug) << "Skipping output: SetupOptions::output_file is "
Expand Down
Loading
Loading