• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

openmc-dev / openmc / 21900555805

11 Feb 2026 09:59AM UTC coverage: 81.845% (-0.06%) from 81.905%
21900555805

Pull #3795

github

web-flow
Merge 3de2714af into 3f20a5e22
Pull Request #3795: Source activity

17367 of 24339 branches covered (71.35%)

Branch coverage included in aggregate %.

27 of 59 new or added lines in 3 files covered. (45.76%)

281 existing lines in 6 files now uncovered.

56211 of 65560 relevant lines covered (85.74%)

46868719.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.08
/src/settings.cpp
1
#include "openmc/settings.h"
2
#include "openmc/random_ray/flat_source_domain.h"
3

4
#include <cmath>  // for ceil, pow
5
#include <limits> // for numeric_limits
6
#include <string>
7

8
#include <fmt/core.h>
9
#ifdef _OPENMP
10
#include <omp.h>
11
#endif
12

13
#include "openmc/capi.h"
14
#include "openmc/collision_track.h"
15
#include "openmc/constants.h"
16
#include "openmc/container_util.h"
17
#include "openmc/distribution.h"
18
#include "openmc/distribution_multi.h"
19
#include "openmc/distribution_spatial.h"
20
#include "openmc/eigenvalue.h"
21
#include "openmc/error.h"
22
#include "openmc/file_utils.h"
23
#include "openmc/mcpl_interface.h"
24
#include "openmc/mesh.h"
25
#include "openmc/message_passing.h"
26
#include "openmc/output.h"
27
#include "openmc/plot.h"
28
#include "openmc/random_lcg.h"
29
#include "openmc/random_ray/random_ray.h"
30
#include "openmc/reaction.h"
31
#include "openmc/simulation.h"
32
#include "openmc/source.h"
33
#include "openmc/string_utils.h"
34
#include "openmc/tallies/trigger.h"
35
#include "openmc/volume_calc.h"
36
#include "openmc/weight_windows.h"
37
#include "openmc/xml_interface.h"
38

39
namespace openmc {
40

41
//==============================================================================
42
// Global variables
43
//==============================================================================
44

45
namespace settings {
46

47
// Default values for boolean flags
48
bool assume_separate {false};
49
bool check_overlaps {false};
50
bool collision_track {false};
51
bool cmfd_run {false};
52
bool confidence_intervals {false};
53
bool create_delayed_neutrons {true};
54
bool create_fission_neutrons {true};
55
bool delayed_photon_scaling {true};
56
bool entropy_on {false};
57
bool event_based {false};
58
bool ifp_on {false};
59
bool legendre_to_tabular {true};
60
bool material_cell_offsets {true};
61
bool output_summary {true};
62
bool output_tallies {true};
63
bool particle_restart_run {false};
64
bool photon_transport {false};
65
bool reduce_tallies {true};
66
bool res_scat_on {false};
67
bool restart_run {false};
68
bool run_CE {true};
69
bool source_latest {false};
70
bool source_separate {false};
71
bool source_write {true};
72
bool source_mcpl_write {false};
73
bool surf_source_write {false};
74
bool surf_mcpl_write {false};
75
bool surf_source_read {false};
76
bool survival_biasing {false};
77
bool survival_normalization {false};
78
bool temperature_multipole {false};
79
bool trigger_on {false};
80
bool trigger_predict {false};
81
bool uniform_source_sampling {false};
82
bool ufs_on {false};
83
bool urr_ptables_on {true};
84
bool use_decay_photons {false};
85
bool weight_windows_on {false};
86
bool weight_window_checkpoint_surface {false};
87
bool weight_window_checkpoint_collision {true};
88
bool write_all_tracks {false};
89
bool write_initial_source {false};
90
bool activity_based_timing {false};
91

92
std::string path_cross_sections;
93
std::string path_input;
94
std::string path_output;
95
std::string path_particle_restart;
96
std::string path_sourcepoint;
97
std::string path_statepoint;
98
const char* path_statepoint_c {path_statepoint.c_str()};
99
std::string weight_windows_file;
100

101
int32_t n_inactive {0};
102
int32_t max_lost_particles {10};
103
double rel_max_lost_particles {1.0e-6};
104
int32_t max_write_lost_particles {-1};
105
int32_t gen_per_batch {1};
106
int64_t n_particles {-1};
107

108
int64_t max_particles_in_flight {100000};
109
int max_particle_events {1000000};
110

111
ElectronTreatment electron_treatment {ElectronTreatment::TTB};
112
array<double, 4> energy_cutoff {0.0, 1000.0, 0.0, 0.0};
113
array<double, 4> time_cutoff {INFTY, INFTY, INFTY, INFTY};
114
int ifp_n_generation {-1};
115
IFPParameter ifp_parameter {IFPParameter::None};
116
int legendre_to_tabular_points {C_NONE};
117
int max_order {0};
118
int n_log_bins {8000};
119
int n_batches;
120
int n_max_batches;
121
int max_secondaries {10000};
122
int max_history_splits {10'000'000};
123
int max_tracks {1000};
124
ResScatMethod res_scat_method {ResScatMethod::rvs};
125
double res_scat_energy_min {0.01};
126
double res_scat_energy_max {1000.0};
127
vector<std::string> res_scat_nuclides;
128
RunMode run_mode {RunMode::UNSET};
129
SolverType solver_type {SolverType::MONTE_CARLO};
130
std::unordered_set<int> sourcepoint_batch;
131
std::unordered_set<int> statepoint_batch;
132
double source_rejection_fraction {0.05};
133
double free_gas_threshold {400.0};
134
std::unordered_set<int> source_write_surf_id;
135
CollisionTrackConfig collision_track_config {};
136
int64_t ssw_max_particles;
137
int64_t ssw_max_files;
138
int64_t ssw_cell_id {C_NONE};
139
SSWCellType ssw_cell_type {SSWCellType::None};
140
TemperatureMethod temperature_method {TemperatureMethod::NEAREST};
141
double temperature_tolerance {10.0};
142
double temperature_default {293.6};
143
array<double, 2> temperature_range {0.0, 0.0};
144
int trace_batch;
145
int trace_gen;
146
int64_t trace_particle;
147
vector<array<int, 3>> track_identifiers;
148
int trigger_batch_interval {1};
149
int verbosity {-1};
150
double weight_cutoff {0.25};
151
double weight_survive {1.0};
152

153
} // namespace settings
154

155
//==============================================================================
156
// Functions
157
//==============================================================================
158

159
void get_run_parameters(pugi::xml_node node_base)
7,487✔
160
{
161
  using namespace settings;
162
  using namespace pugi;
163

164
  // Check number of particles
165
  if (!check_for_node(node_base, "particles")) {
7,487!
UNCOV
166
    fatal_error("Need to specify number of particles.");
×
167
  }
168

169
  // Get number of particles if it wasn't specified as a command-line argument
170
  if (n_particles == -1) {
7,487!
171
    n_particles = std::stoll(get_node_value(node_base, "particles"));
7,487✔
172
  }
173

174
  // Get maximum number of in flight particles for event-based mode
175
  if (check_for_node(node_base, "max_particles_in_flight")) {
7,487!
176
    max_particles_in_flight =
×
UNCOV
177
      std::stoll(get_node_value(node_base, "max_particles_in_flight"));
×
178
  }
179

180
  // Get maximum number of events allowed per particle
181
  if (check_for_node(node_base, "max_particle_events")) {
7,487!
182
    max_particle_events =
×
UNCOV
183
      std::stoll(get_node_value(node_base, "max_particle_events"));
×
184
  }
185

186
  // Get number of basic batches
187
  if (check_for_node(node_base, "batches")) {
7,487!
188
    n_batches = std::stoi(get_node_value(node_base, "batches"));
7,487✔
189
  }
190
  if (!trigger_on)
7,487✔
191
    n_max_batches = n_batches;
7,341✔
192

193
  // Get max number of lost particles
194
  if (check_for_node(node_base, "max_lost_particles")) {
7,487✔
195
    max_lost_particles =
49✔
196
      std::stoi(get_node_value(node_base, "max_lost_particles"));
49✔
197
  }
198

199
  // Get relative number of lost particles
200
  if (check_for_node(node_base, "rel_max_lost_particles")) {
7,487!
201
    rel_max_lost_particles =
×
UNCOV
202
      std::stod(get_node_value(node_base, "rel_max_lost_particles"));
×
203
  }
204

205
  // Get relative number of lost particles
206
  if (check_for_node(node_base, "max_write_lost_particles")) {
7,487✔
207
    max_write_lost_particles =
16✔
208
      std::stoi(get_node_value(node_base, "max_write_lost_particles"));
16✔
209
  }
210

211
  // Get number of inactive batches
212
  if (run_mode == RunMode::EIGENVALUE ||
7,487✔
213
      solver_type == SolverType::RANDOM_RAY) {
2,808✔
214
    if (check_for_node(node_base, "inactive")) {
5,096✔
215
      n_inactive = std::stoi(get_node_value(node_base, "inactive"));
4,911✔
216
    }
217
    if (check_for_node(node_base, "generations_per_batch")) {
5,096✔
218
      gen_per_batch =
16✔
219
        std::stoi(get_node_value(node_base, "generations_per_batch"));
16✔
220
    }
221

222
    // Preallocate space for keff and entropy by generation
223
    int m = settings::n_max_batches * settings::gen_per_batch;
5,096✔
224
    simulation::k_generation.reserve(m);
5,096✔
225
    simulation::entropy.reserve(m);
5,096✔
226

227
    // Get the trigger information for keff
228
    if (check_for_node(node_base, "keff_trigger")) {
5,096✔
229
      xml_node node_keff_trigger = node_base.child("keff_trigger");
107✔
230

231
      if (check_for_node(node_keff_trigger, "type")) {
107!
232
        auto temp = get_node_value(node_keff_trigger, "type", true, true);
107✔
233
        if (temp == "std_dev") {
107!
234
          keff_trigger.metric = TriggerMetric::standard_deviation;
107✔
235
        } else if (temp == "variance") {
×
236
          keff_trigger.metric = TriggerMetric::variance;
×
237
        } else if (temp == "rel_err") {
×
UNCOV
238
          keff_trigger.metric = TriggerMetric::relative_error;
×
239
        } else {
UNCOV
240
          fatal_error("Unrecognized keff trigger type " + temp);
×
241
        }
242
      } else {
107✔
UNCOV
243
        fatal_error("Specify keff trigger type in settings XML");
×
244
      }
245

246
      if (check_for_node(node_keff_trigger, "threshold")) {
107!
247
        keff_trigger.threshold =
107✔
248
          std::stod(get_node_value(node_keff_trigger, "threshold"));
107✔
249
        if (keff_trigger.threshold <= 0) {
107!
UNCOV
250
          fatal_error("keff trigger threshold must be positive");
×
251
        }
252
      } else {
UNCOV
253
        fatal_error("Specify keff trigger threshold in settings XML");
×
254
      }
255
    }
256
  }
257

258
  // Random ray variables
259
  if (solver_type == SolverType::RANDOM_RAY) {
7,487✔
260
    xml_node random_ray_node = node_base.child("random_ray");
796✔
261
    if (check_for_node(random_ray_node, "distance_active")) {
796!
262
      RandomRay::distance_active_ =
796✔
263
        std::stod(get_node_value(random_ray_node, "distance_active"));
796✔
264
      if (RandomRay::distance_active_ <= 0.0) {
796!
UNCOV
265
        fatal_error("Random ray active distance must be greater than 0");
×
266
      }
267
    } else {
UNCOV
268
      fatal_error("Specify random ray active distance in settings XML");
×
269
    }
270
    if (check_for_node(random_ray_node, "distance_inactive")) {
796!
271
      RandomRay::distance_inactive_ =
796✔
272
        std::stod(get_node_value(random_ray_node, "distance_inactive"));
796✔
273
      if (RandomRay::distance_inactive_ < 0) {
796!
UNCOV
274
        fatal_error(
×
275
          "Random ray inactive distance must be greater than or equal to 0");
276
      }
277
    } else {
UNCOV
278
      fatal_error("Specify random ray inactive distance in settings XML");
×
279
    }
280
    if (check_for_node(random_ray_node, "source")) {
796!
281
      xml_node source_node = random_ray_node.child("source");
796✔
282
      // Get point to list of <source> elements and make sure there is at least
283
      // one
284
      RandomRay::ray_source_ = Source::create(source_node);
796✔
285
    } else {
UNCOV
286
      fatal_error("Specify random ray source in settings XML");
×
287
    }
288
    if (check_for_node(random_ray_node, "volume_estimator")) {
796✔
289
      std::string temp_str =
290
        get_node_value(random_ray_node, "volume_estimator", true, true);
129✔
291
      if (temp_str == "simulation_averaged") {
129✔
292
        FlatSourceDomain::volume_estimator_ =
32✔
293
          RandomRayVolumeEstimator::SIMULATION_AVERAGED;
294
      } else if (temp_str == "naive") {
97✔
295
        FlatSourceDomain::volume_estimator_ = RandomRayVolumeEstimator::NAIVE;
65✔
296
      } else if (temp_str == "hybrid") {
32!
297
        FlatSourceDomain::volume_estimator_ = RandomRayVolumeEstimator::HYBRID;
32✔
298
      } else {
UNCOV
299
        fatal_error("Unrecognized volume estimator: " + temp_str);
×
300
      }
301
    }
129✔
302
    if (check_for_node(random_ray_node, "source_shape")) {
796✔
303
      std::string temp_str =
304
        get_node_value(random_ray_node, "source_shape", true, true);
464✔
305
      if (temp_str == "flat") {
464✔
306
        RandomRay::source_shape_ = RandomRaySourceShape::FLAT;
64✔
307
      } else if (temp_str == "linear") {
400✔
308
        RandomRay::source_shape_ = RandomRaySourceShape::LINEAR;
352✔
309
      } else if (temp_str == "linear_xy") {
48!
310
        RandomRay::source_shape_ = RandomRaySourceShape::LINEAR_XY;
48✔
311
      } else {
UNCOV
312
        fatal_error("Unrecognized source shape: " + temp_str);
×
313
      }
314
    }
464✔
315
    if (check_for_node(random_ray_node, "volume_normalized_flux_tallies")) {
796✔
316
      FlatSourceDomain::volume_normalized_flux_tallies_ =
555✔
317
        get_node_value_bool(random_ray_node, "volume_normalized_flux_tallies");
555✔
318
    }
319
    if (check_for_node(random_ray_node, "adjoint")) {
796✔
320
      FlatSourceDomain::adjoint_ =
32✔
321
        get_node_value_bool(random_ray_node, "adjoint");
32✔
322
    }
323
    if (check_for_node(random_ray_node, "sample_method")) {
796✔
324
      std::string temp_str =
325
        get_node_value(random_ray_node, "sample_method", true, true);
16✔
326
      if (temp_str == "prng") {
16!
UNCOV
327
        RandomRay::sample_method_ = RandomRaySampleMethod::PRNG;
×
328
      } else if (temp_str == "halton") {
16!
329
        RandomRay::sample_method_ = RandomRaySampleMethod::HALTON;
16✔
330
      } else {
UNCOV
331
        fatal_error("Unrecognized sample method: " + temp_str);
×
332
      }
333
    }
16✔
334
    if (check_for_node(random_ray_node, "source_region_meshes")) {
796✔
335
      pugi::xml_node node_source_region_meshes =
336
        random_ray_node.child("source_region_meshes");
321✔
337
      for (pugi::xml_node node_mesh :
321✔
338
        node_source_region_meshes.children("mesh")) {
1,027✔
339
        int mesh_id = std::stoi(node_mesh.attribute("id").value());
385✔
340
        for (pugi::xml_node node_domain : node_mesh.children("domain")) {
770✔
341
          int domain_id = std::stoi(node_domain.attribute("id").value());
385✔
342
          std::string domain_type = node_domain.attribute("type").value();
385✔
343
          Source::DomainType type;
344
          if (domain_type == "material") {
385✔
345
            type = Source::DomainType::MATERIAL;
32✔
346
          } else if (domain_type == "cell") {
353✔
347
            type = Source::DomainType::CELL;
32✔
348
          } else if (domain_type == "universe") {
321!
349
            type = Source::DomainType::UNIVERSE;
321✔
350
          } else {
UNCOV
351
            throw std::runtime_error("Unknown domain type: " + domain_type);
×
352
          }
353
          FlatSourceDomain::mesh_domain_map_[mesh_id].emplace_back(
385✔
354
            type, domain_id);
355
        }
385✔
356
      }
357
    }
358
    if (check_for_node(random_ray_node, "diagonal_stabilization_rho")) {
796✔
359
      FlatSourceDomain::diagonal_stabilization_rho_ = std::stod(
16✔
360
        get_node_value(random_ray_node, "diagonal_stabilization_rho"));
32✔
361
      if (FlatSourceDomain::diagonal_stabilization_rho_ < 0.0 ||
16!
362
          FlatSourceDomain::diagonal_stabilization_rho_ > 1.0) {
16!
UNCOV
363
        fatal_error("Random ray diagonal stabilization rho factor must be "
×
364
                    "between 0 and 1");
365
      }
366
    }
367
  }
368
}
7,487✔
369

370
void read_settings_xml()
1,392✔
371
{
372
  using namespace settings;
373
  using namespace pugi;
374
  // Check if settings.xml exists
375
  std::string filename = settings::path_input + "settings.xml";
1,392✔
376
  if (!file_exists(filename)) {
1,392✔
377
    if (run_mode != RunMode::PLOTTING) {
22!
UNCOV
378
      fatal_error("Could not find any XML input files! In order to run OpenMC, "
×
379
                  "you first need a set of input files; at a minimum, this "
380
                  "includes settings.xml, geometry.xml, and materials.xml or a "
381
                  "single model XML file. Please consult the user's guide at "
382
                  "https://docs.openmc.org for further information.");
383
    } else {
384
      // The settings.xml file is optional if we just want to make a plot.
385
      return;
22✔
386
    }
387
  }
388

389
  // Parse settings.xml file
390
  xml_document doc;
1,370✔
391
  auto result = doc.load_file(filename.c_str());
1,370✔
392
  if (!result) {
1,370!
UNCOV
393
    fatal_error("Error processing settings.xml file.");
×
394
  }
395

396
  // Get root element
397
  xml_node root = doc.document_element();
1,370✔
398

399
  // Verbosity
400
  if (check_for_node(root, "verbosity") && verbosity == -1) {
1,370!
401
    verbosity = std::stoi(get_node_value(root, "verbosity"));
182✔
402
  } else if (verbosity == -1) {
1,188!
403
    verbosity = 7;
1,188✔
404
  }
405

406
  // To this point, we haven't displayed any output since we didn't know what
407
  // the verbosity is. Now that we checked for it, show the title if necessary
408
  if (mpi::master) {
1,370✔
409
    if (verbosity >= 2)
1,145✔
410
      title();
973✔
411
  }
412

413
  write_message("Reading settings XML file...", 5);
1,370✔
414

415
  read_settings_xml(root);
1,370✔
416
}
1,382✔
417

418
void read_settings_xml(pugi::xml_node root)
8,295✔
419
{
420
  using namespace settings;
421
  using namespace pugi;
422

423
  // Find if a multi-group or continuous-energy simulation is desired
424
  if (check_for_node(root, "energy_mode")) {
8,295✔
425
    std::string temp_str = get_node_value(root, "energy_mode", true, true);
1,352✔
426
    if (temp_str == "mg" || temp_str == "multi-group") {
1,352!
427
      run_CE = false;
1,352✔
428
    } else if (temp_str == "ce" || temp_str == "continuous-energy") {
×
UNCOV
429
      run_CE = true;
×
430
    }
431
  }
1,352✔
432

433
  // Check for user meshes and allocate
434
  read_meshes(root);
8,295✔
435

436
  // Look for deprecated cross_sections.xml file in settings.xml
437
  if (check_for_node(root, "cross_sections")) {
8,295!
UNCOV
438
    warning(
×
439
      "Setting cross_sections in settings.xml has been deprecated."
440
      " The cross_sections are now set in materials.xml and the "
441
      "cross_sections input to materials.xml and the OPENMC_CROSS_SECTIONS"
442
      " environment variable will take precendent over setting "
443
      "cross_sections in settings.xml.");
UNCOV
444
    path_cross_sections = get_node_value(root, "cross_sections");
×
445
  }
446

447
  if (!run_CE) {
8,295✔
448
    // Scattering Treatments
449
    if (check_for_node(root, "max_order")) {
1,352✔
450
      max_order = std::stoi(get_node_value(root, "max_order"));
16✔
451
    } else {
452
      // Set to default of largest int - 1, which means to use whatever is
453
      // contained in library. This is largest int - 1 because for legendre
454
      // scattering, a value of 1 is added to the order; adding 1 to the largest
455
      // int gets you the largest negative integer, which is not what we want.
456
      max_order = std::numeric_limits<int>::max() - 1;
1,336✔
457
    }
458
  }
459

460
  // Check for a trigger node and get trigger information
461
  if (check_for_node(root, "trigger")) {
8,295✔
462
    xml_node node_trigger = root.child("trigger");
162✔
463

464
    // Check if trigger(s) are to be turned on
465
    trigger_on = get_node_value_bool(node_trigger, "active");
162✔
466

467
    if (trigger_on) {
162✔
468
      if (check_for_node(node_trigger, "max_batches")) {
146!
469
        n_max_batches = std::stoi(get_node_value(node_trigger, "max_batches"));
146✔
470
      } else {
UNCOV
471
        fatal_error("<max_batches> must be specified with triggers");
×
472
      }
473

474
      // Get the batch interval to check triggers
475
      if (!check_for_node(node_trigger, "batch_interval")) {
146✔
476
        trigger_predict = true;
16✔
477
      } else {
478
        trigger_batch_interval =
130✔
479
          std::stoi(get_node_value(node_trigger, "batch_interval"));
130✔
480
        if (trigger_batch_interval <= 0) {
130!
UNCOV
481
          fatal_error("Trigger batch interval must be greater than zero");
×
482
        }
483
      }
484
    }
485
  }
486

487
  // Check run mode if it hasn't been set from the command line
488
  xml_node node_mode;
8,295✔
489
  if (run_mode == RunMode::UNSET) {
8,295✔
490
    if (check_for_node(root, "run_mode")) {
7,519✔
491
      std::string temp_str = get_node_value(root, "run_mode", true, true);
7,487✔
492
      if (temp_str == "eigenvalue") {
7,487✔
493
        run_mode = RunMode::EIGENVALUE;
4,647✔
494
      } else if (temp_str == "fixed source") {
2,840✔
495
        run_mode = RunMode::FIXED_SOURCE;
2,808✔
496
      } else if (temp_str == "plot") {
32!
UNCOV
497
        run_mode = RunMode::PLOTTING;
×
498
      } else if (temp_str == "particle restart") {
32!
UNCOV
499
        run_mode = RunMode::PARTICLE;
×
500
      } else if (temp_str == "volume") {
32!
501
        run_mode = RunMode::VOLUME;
32✔
502
      } else {
UNCOV
503
        fatal_error("Unrecognized run mode: " + temp_str);
×
504
      }
505

506
      // Assume XML specifies <particles>, <batches>, etc. directly
507
      node_mode = root;
7,487✔
508
    } else {
7,487✔
509
      warning("<run_mode> should be specified.");
32✔
510

511
      // Make sure that either eigenvalue or fixed source was specified
512
      node_mode = root.child("eigenvalue");
32✔
513
      if (node_mode) {
32!
514
        run_mode = RunMode::EIGENVALUE;
32✔
515
      } else {
516
        node_mode = root.child("fixed_source");
×
517
        if (node_mode) {
×
UNCOV
518
          run_mode = RunMode::FIXED_SOURCE;
×
519
        } else {
UNCOV
520
          fatal_error("<eigenvalue> or <fixed_source> not specified.");
×
521
        }
522
      }
523
    }
524
  }
525

526
  // Check solver type
527
  if (check_for_node(root, "random_ray")) {
8,295✔
528
    solver_type = SolverType::RANDOM_RAY;
796✔
529
    if (run_CE)
796!
UNCOV
530
      fatal_error("multi-group energy mode must be specified in settings XML "
×
531
                  "when using the random ray solver.");
532
  }
533

534
  if (run_mode == RunMode::EIGENVALUE || run_mode == RunMode::FIXED_SOURCE) {
8,295✔
535
    // Read run parameters
536
    get_run_parameters(node_mode);
7,487✔
537

538
    // Check number of active batches, inactive batches, max lost particles and
539
    // particles
540
    if (n_batches <= n_inactive) {
7,487!
UNCOV
541
      fatal_error("Number of active batches must be greater than zero.");
×
542
    } else if (n_inactive < 0) {
7,487!
UNCOV
543
      fatal_error("Number of inactive batches must be non-negative.");
×
544
    } else if (n_particles <= 0) {
7,487!
UNCOV
545
      fatal_error("Number of particles must be greater than zero.");
×
546
    } else if (max_lost_particles <= 0) {
7,487!
UNCOV
547
      fatal_error("Number of max lost particles must be greater than zero.");
×
548
    } else if (rel_max_lost_particles <= 0.0 || rel_max_lost_particles >= 1.0) {
7,487!
UNCOV
549
      fatal_error("Relative max lost particles must be between zero and one.");
×
550
    }
551

552
    // Check for user value for the number of generation of the Iterated Fission
553
    // Probability (IFP) method
554
    if (check_for_node(root, "ifp_n_generation")) {
7,487✔
555
      ifp_n_generation = std::stoi(get_node_value(root, "ifp_n_generation"));
85✔
556
      if (ifp_n_generation <= 0) {
85!
UNCOV
557
        fatal_error("'ifp_n_generation' must be greater than 0.");
×
558
      }
559
      // Avoid tallying 0 if IFP logs are not complete when active cycles start
560
      if (ifp_n_generation > n_inactive) {
85✔
561
        fatal_error("'ifp_n_generation' must be lower than or equal to the "
9✔
562
                    "number of inactive cycles.");
563
      }
564
    }
565
  }
566

567
  // Copy plotting random number seed if specified
568
  if (check_for_node(root, "plot_seed")) {
8,286!
569
    auto seed = std::stoll(get_node_value(root, "plot_seed"));
×
UNCOV
570
    model::plotter_seed = seed;
×
571
  }
572

573
  // Copy random number seed if specified
574
  if (check_for_node(root, "seed")) {
8,286✔
575
    auto seed = std::stoll(get_node_value(root, "seed"));
589✔
576
    openmc_set_seed(seed);
589✔
577
  }
578

579
  // Copy random number stride if specified
580
  if (check_for_node(root, "stride")) {
8,286✔
581
    auto stride = std::stoull(get_node_value(root, "stride"));
16✔
582
    openmc_set_stride(stride);
16✔
583
  }
584

585
  // Check for electron treatment
586
  if (check_for_node(root, "electron_treatment")) {
8,286✔
587
    auto temp_str = get_node_value(root, "electron_treatment", true, true);
70✔
588
    if (temp_str == "led") {
70✔
589
      electron_treatment = ElectronTreatment::LED;
11✔
590
    } else if (temp_str == "ttb") {
59!
591
      electron_treatment = ElectronTreatment::TTB;
59✔
592
    } else {
UNCOV
593
      fatal_error("Unrecognized electron treatment: " + temp_str + ".");
×
594
    }
595
  }
70✔
596

597
  // Check for photon transport
598
  if (check_for_node(root, "photon_transport")) {
8,286✔
599
    photon_transport = get_node_value_bool(root, "photon_transport");
199✔
600

601
    if (!run_CE && photon_transport) {
199!
UNCOV
602
      fatal_error("Photon transport is not currently supported in "
×
603
                  "multigroup mode");
604
    }
605
  }
606

607
  // Number of bins for logarithmic grid
608
  if (check_for_node(root, "log_grid_bins")) {
8,286✔
609
    n_log_bins = std::stoi(get_node_value(root, "log_grid_bins"));
16✔
610
    if (n_log_bins < 1) {
16!
UNCOV
611
      fatal_error("Number of bins for logarithmic grid must be greater "
×
612
                  "than zero.");
613
    }
614
  }
615

616
  // Number of OpenMP threads
617
  if (check_for_node(root, "threads")) {
8,286!
618
    if (mpi::master)
×
UNCOV
619
      warning("The <threads> element has been deprecated. Use "
×
620
              "the OMP_NUM_THREADS environment variable to set the number of "
621
              "threads.");
622
  }
623

624
  // ==========================================================================
625
  // EXTERNAL SOURCE
626

627
  // Get point to list of <source> elements and make sure there is at least one
628
  for (pugi::xml_node node : root.children("source")) {
16,055✔
629
    model::external_sources.push_back(Source::create(node));
7,779✔
630
  }
631

632
  // Check if the user has specified to read surface source
633
  if (check_for_node(root, "surf_source_read")) {
8,276✔
634
    surf_source_read = true;
32✔
635
    // Get surface source read node
636
    xml_node node_ssr = root.child("surf_source_read");
32✔
637

638
    std::string path = "surface_source.h5";
32✔
639
    // Check if the user has specified different file for surface source reading
640
    if (check_for_node(node_ssr, "path")) {
32!
641
      path = get_node_value(node_ssr, "path", false, true);
32✔
642
    }
643
    model::external_sources.push_back(make_unique<FileSource>(path));
32✔
644
  }
32✔
645

646
  // If no source specified, default to isotropic point source at origin with
647
  // Watt spectrum. No default source is needed in random ray mode.
648
  if (model::external_sources.empty() &&
10,481✔
649
      settings::solver_type != SolverType::RANDOM_RAY) {
2,205✔
650
    double T[] {0.0};
2,050✔
651
    double p[] {1.0};
2,050✔
652
    model::external_sources.push_back(make_unique<IndependentSource>(
2,050✔
653
      UPtrSpace {new SpatialPoint({0.0, 0.0, 0.0})},
4,100✔
654
      UPtrAngle {new Isotropic()}, UPtrDist {new Watt(0.988e6, 2.249e-6)},
4,100✔
655
      UPtrDist {new Discrete(T, p, 1)}));
4,100✔
656
  }
657

658
  // Build probability mass function for sampling external sources
659
  vector<double> source_strengths;
8,276✔
660
  for (auto& s : model::external_sources) {
18,127✔
661
    source_strengths.push_back(s->strength());
9,851✔
662
  }
663
  model::external_sources_probability.assign(source_strengths);
8,276✔
664

665
  // Check if we want to write out source
666
  if (check_for_node(root, "write_initial_source")) {
8,276!
UNCOV
667
    write_initial_source = get_node_value_bool(root, "write_initial_source");
×
668
  }
669

670
  // Get relative number of lost particles
671
  if (check_for_node(root, "source_rejection_fraction")) {
8,276✔
672
    source_rejection_fraction =
6✔
673
      std::stod(get_node_value(root, "source_rejection_fraction"));
6!
674
  }
675

676
  if (check_for_node(root, "free_gas_threshold")) {
8,276!
UNCOV
677
    free_gas_threshold = std::stod(get_node_value(root, "free_gas_threshold"));
×
678
  }
679

680
  // Survival biasing
681
  if (check_for_node(root, "survival_biasing")) {
8,276✔
682
    survival_biasing = get_node_value_bool(root, "survival_biasing");
177✔
683
  }
684

685
  // Probability tables
686
  if (check_for_node(root, "ptables")) {
8,276✔
687
    urr_ptables_on = get_node_value_bool(root, "ptables");
16✔
688
  }
689

690
  // Cutoffs
691
  if (check_for_node(root, "cutoff")) {
8,276✔
692
    xml_node node_cutoff = root.child("cutoff");
145✔
693
    if (check_for_node(node_cutoff, "weight")) {
145✔
694
      weight_cutoff = std::stod(get_node_value(node_cutoff, "weight"));
16✔
695
    }
696
    if (check_for_node(node_cutoff, "weight_avg")) {
145✔
697
      weight_survive = std::stod(get_node_value(node_cutoff, "weight_avg"));
16✔
698
    }
699
    if (check_for_node(node_cutoff, "survival_normalization")) {
145!
700
      survival_normalization =
×
UNCOV
701
        get_node_value_bool(node_cutoff, "survival_normalization");
×
702
    }
703
    if (check_for_node(node_cutoff, "energy_neutron")) {
145✔
704
      energy_cutoff[0] =
32✔
705
        std::stod(get_node_value(node_cutoff, "energy_neutron"));
16✔
706
    } else if (check_for_node(node_cutoff, "energy")) {
129!
UNCOV
707
      warning("The use of an <energy> cutoff is deprecated and should "
×
708
              "be replaced by <energy_neutron>.");
UNCOV
709
      energy_cutoff[0] = std::stod(get_node_value(node_cutoff, "energy"));
×
710
    }
711
    if (check_for_node(node_cutoff, "energy_photon")) {
145✔
712
      energy_cutoff[1] =
172✔
713
        std::stod(get_node_value(node_cutoff, "energy_photon"));
86✔
714
    }
715
    if (check_for_node(node_cutoff, "energy_electron")) {
145!
716
      energy_cutoff[2] =
×
UNCOV
717
        std::stof(get_node_value(node_cutoff, "energy_electron"));
×
718
    }
719
    if (check_for_node(node_cutoff, "energy_positron")) {
145!
720
      energy_cutoff[3] =
×
UNCOV
721
        std::stod(get_node_value(node_cutoff, "energy_positron"));
×
722
    }
723
    if (check_for_node(node_cutoff, "time_neutron")) {
145✔
724
      time_cutoff[0] = std::stod(get_node_value(node_cutoff, "time_neutron"));
27✔
725
    }
726
    if (check_for_node(node_cutoff, "time_photon")) {
145!
UNCOV
727
      time_cutoff[1] = std::stod(get_node_value(node_cutoff, "time_photon"));
×
728
    }
729
    if (check_for_node(node_cutoff, "time_electron")) {
145!
UNCOV
730
      time_cutoff[2] = std::stod(get_node_value(node_cutoff, "time_electron"));
×
731
    }
732
    if (check_for_node(node_cutoff, "time_positron")) {
145!
UNCOV
733
      time_cutoff[3] = std::stod(get_node_value(node_cutoff, "time_positron"));
×
734
    }
735
  }
736

737
  // Particle trace
738
  if (check_for_node(root, "trace")) {
8,276✔
739
    auto temp = get_node_array<int64_t>(root, "trace");
16✔
740
    if (temp.size() != 3) {
16!
UNCOV
741
      fatal_error("Must provide 3 integers for <trace> that specify the "
×
742
                  "batch, generation, and particle number.");
743
    }
744
    trace_batch = temp.at(0);
16✔
745
    trace_gen = temp.at(1);
16✔
746
    trace_particle = temp.at(2);
16✔
747
  }
16✔
748

749
  // Particle tracks
750
  if (check_for_node(root, "track")) {
8,276✔
751
    // Get values and make sure there are three per particle
752
    auto temp = get_node_array<int>(root, "track");
48✔
753
    if (temp.size() % 3 != 0) {
48!
UNCOV
754
      fatal_error(
×
755
        "Number of integers specified in 'track' is not "
756
        "divisible by 3.  Please provide 3 integers per particle to be "
757
        "tracked.");
758
    }
759

760
    // Reshape into track_identifiers
761
    int n_tracks = temp.size() / 3;
48✔
762
    for (int i = 0; i < n_tracks; ++i) {
192✔
763
      track_identifiers.push_back(
144✔
764
        {temp[3 * i], temp[3 * i + 1], temp[3 * i + 2]});
144✔
765
    }
766
  }
48✔
767

768
  // Shannon entropy
769
  if (solver_type == SolverType::RANDOM_RAY) {
8,276✔
770
    if (check_for_node(root, "entropy_mesh")) {
796!
UNCOV
771
      fatal_error("Random ray uses FSRs to compute the Shannon entropy. "
×
772
                  "No user-defined entropy mesh is supported.");
773
    }
774
    entropy_on = true;
796✔
775
  } else if (solver_type == SolverType::MONTE_CARLO) {
7,480!
776
    if (check_for_node(root, "entropy_mesh")) {
7,480✔
777
      int temp = std::stoi(get_node_value(root, "entropy_mesh"));
335✔
778
      if (model::mesh_map.find(temp) == model::mesh_map.end()) {
335!
UNCOV
779
        fatal_error(fmt::format(
×
780
          "Mesh {} specified for Shannon entropy does not exist.", temp));
781
      }
782

783
      auto* m = dynamic_cast<RegularMesh*>(
335!
784
        model::meshes[model::mesh_map.at(temp)].get());
335✔
785
      if (!m)
335!
UNCOV
786
        fatal_error("Only regular meshes can be used as an entropy mesh");
×
787
      simulation::entropy_mesh = m;
335✔
788

789
      // Turn on Shannon entropy calculation
790
      entropy_on = true;
335✔
791

792
    } else if (check_for_node(root, "entropy")) {
7,145!
UNCOV
793
      fatal_error(
×
794
        "Specifying a Shannon entropy mesh via the <entropy> element "
795
        "is deprecated. Please create a mesh using <mesh> and then reference "
796
        "it by specifying its ID in an <entropy_mesh> element.");
797
    }
798
  }
799
  // Uniform fission source weighting mesh
800
  if (check_for_node(root, "ufs_mesh")) {
8,276✔
801
    auto temp = std::stoi(get_node_value(root, "ufs_mesh"));
16✔
802
    if (model::mesh_map.find(temp) == model::mesh_map.end()) {
16!
UNCOV
803
      fatal_error(fmt::format("Mesh {} specified for uniform fission site "
×
804
                              "method does not exist.",
805
        temp));
806
    }
807

808
    auto* m =
809
      dynamic_cast<RegularMesh*>(model::meshes[model::mesh_map.at(temp)].get());
16!
810
    if (!m)
16!
UNCOV
811
      fatal_error("Only regular meshes can be used as a UFS mesh");
×
812
    simulation::ufs_mesh = m;
16✔
813

814
    // Turn on uniform fission source weighting
815
    ufs_on = true;
16✔
816

817
  } else if (check_for_node(root, "uniform_fs")) {
8,260!
UNCOV
818
    fatal_error(
×
819
      "Specifying a UFS mesh via the <uniform_fs> element "
820
      "is deprecated. Please create a mesh using <mesh> and then reference "
821
      "it by specifying its ID in a <ufs_mesh> element.");
822
  }
823

824
  // Check if the user has specified to write state points
825
  if (check_for_node(root, "state_point")) {
8,276✔
826

827
    // Get pointer to state_point node
828
    auto node_sp = root.child("state_point");
167✔
829

830
    // Determine number of batches at which to store state points
831
    if (check_for_node(node_sp, "batches")) {
167!
832
      // User gave specific batches to write state points
833
      auto temp = get_node_array<int>(node_sp, "batches");
167✔
834
      for (const auto& b : temp) {
512✔
835
        statepoint_batch.insert(b);
345✔
836
      }
837
    } else {
167✔
838
      // If neither were specified, write state point at last batch
UNCOV
839
      statepoint_batch.insert(n_batches);
×
840
    }
841
  } else {
842
    // If no <state_point> tag was present, by default write state point at
843
    // last batch only
844
    statepoint_batch.insert(n_batches);
8,109✔
845
  }
846

847
  // Check if the user has specified to write source points
848
  if (check_for_node(root, "source_point")) {
8,276✔
849
    // Get source_point node
850
    xml_node node_sp = root.child("source_point");
107✔
851

852
    // Determine batches at which to store source points
853
    if (check_for_node(node_sp, "batches")) {
107✔
854
      // User gave specific batches to write source points
855
      auto temp = get_node_array<int>(node_sp, "batches");
48✔
856
      for (const auto& b : temp) {
128✔
857
        sourcepoint_batch.insert(b);
80✔
858
      }
859
    } else {
48✔
860
      // If neither were specified, write source points with state points
861
      sourcepoint_batch = statepoint_batch;
59✔
862
    }
863

864
    // Check if the user has specified to write binary source file
865
    if (check_for_node(node_sp, "separate")) {
107✔
866
      source_separate = get_node_value_bool(node_sp, "separate");
75✔
867
    }
868
    if (check_for_node(node_sp, "write")) {
107!
UNCOV
869
      source_write = get_node_value_bool(node_sp, "write");
×
870
    }
871
    if (check_for_node(node_sp, "mcpl")) {
107✔
872
      source_mcpl_write = get_node_value_bool(node_sp, "mcpl");
27✔
873
    }
874
    if (check_for_node(node_sp, "overwrite_latest")) {
107✔
875
      source_latest = get_node_value_bool(node_sp, "overwrite_latest");
16✔
876
      source_separate = source_latest;
16✔
877
    }
878
  } else {
879
    // If no <source_point> tag was present, by default we keep source bank in
880
    // statepoint file and write it out at statepoints intervals
881
    source_separate = false;
8,169✔
882
    sourcepoint_batch = statepoint_batch;
8,169✔
883
  }
884

885
  // Check is the user specified to convert strength to statistical weight
886
  if (check_for_node(root, "uniform_source_sampling")) {
8,276✔
887
    uniform_source_sampling =
55✔
888
      get_node_value_bool(root, "uniform_source_sampling");
55✔
889
  }
890

891
  // Check if the user wants activity-based timing (per-source Poisson
892
  // timestamps using strength as activity rate in Bq)
893
  if (check_for_node(root, "activity_based_timing")) {
8,276!
NEW
UNCOV
894
    activity_based_timing = get_node_value_bool(root, "activity_based_timing");
×
895
  }
896

897
  // Check if the user has specified to write surface source
898
  if (check_for_node(root, "surf_source_write")) {
8,276✔
899
    surf_source_write = true;
412✔
900
    // Get surface source write node
901
    xml_node node_ssw = root.child("surf_source_write");
412✔
902

903
    // Determine surface ids at which crossing particles are to be banked.
904
    // If no surfaces are specified, all surfaces in the model will be used
905
    // to bank source points.
906
    if (check_for_node(node_ssw, "surface_ids")) {
412✔
907
      auto temp = get_node_array<int>(node_ssw, "surface_ids");
202✔
908
      for (const auto& b : temp) {
994✔
909
        source_write_surf_id.insert(b);
792✔
910
      }
911
    }
202✔
912

913
    // Get maximum number of particles to be banked per surface
914
    if (check_for_node(node_ssw, "max_particles")) {
412✔
915
      ssw_max_particles = std::stoll(get_node_value(node_ssw, "max_particles"));
403✔
916
    } else {
917
      fatal_error("A maximum number of particles needs to be specified "
9✔
918
                  "using the 'max_particles' parameter to store surface "
919
                  "source points.");
920
    }
921

922
    // Get maximum number of surface source files to be created
923
    if (check_for_node(node_ssw, "max_source_files")) {
403✔
924
      ssw_max_files = std::stoll(get_node_value(node_ssw, "max_source_files"));
33✔
925
    } else {
926
      ssw_max_files = 1;
370✔
927
    }
928

929
    if (check_for_node(node_ssw, "mcpl")) {
403✔
930
      surf_mcpl_write = get_node_value_bool(node_ssw, "mcpl");
11✔
931
    }
932
    // Get cell information
933
    if (check_for_node(node_ssw, "cell")) {
403✔
934
      ssw_cell_id = std::stoll(get_node_value(node_ssw, "cell"));
104✔
935
      ssw_cell_type = SSWCellType::Both;
104✔
936
    }
937
    if (check_for_node(node_ssw, "cellfrom")) {
403✔
938
      if (ssw_cell_id != C_NONE) {
90✔
939
        fatal_error(
18✔
940
          "'cell', 'cellfrom' and 'cellto' cannot be used at the same time.");
941
      }
942
      ssw_cell_id = std::stoll(get_node_value(node_ssw, "cellfrom"));
72✔
943
      ssw_cell_type = SSWCellType::From;
72✔
944
    }
945
    if (check_for_node(node_ssw, "cellto")) {
385✔
946
      if (ssw_cell_id != C_NONE) {
71✔
947
        fatal_error(
18✔
948
          "'cell', 'cellfrom' and 'cellto' cannot be used at the same time.");
949
      }
950
      ssw_cell_id = std::stoll(get_node_value(node_ssw, "cellto"));
53✔
951
      ssw_cell_type = SSWCellType::To;
53✔
952
    }
953
  }
954

955
  // Check if the user has specified to write specific collisions
956
  if (check_for_node(root, "collision_track")) {
8,231✔
957
    settings::collision_track = true;
155✔
958
    // Get collision track node
959
    xml_node node_ct = root.child("collision_track");
155✔
960
    collision_track_config = CollisionTrackConfig {};
155✔
961

962
    // Determine cell ids at which crossing particles are to be banked
963
    if (check_for_node(node_ct, "cell_ids")) {
155✔
964
      auto temp = get_node_array<int>(node_ct, "cell_ids");
81✔
965
      for (const auto& b : temp) {
211✔
966
        collision_track_config.cell_ids.insert(b);
130✔
967
      }
968
    }
81✔
969
    if (check_for_node(node_ct, "reactions")) {
155✔
970
      auto temp = get_node_array<std::string>(node_ct, "reactions");
65✔
971
      for (const auto& b : temp) {
178✔
972
        int reaction_int = reaction_type(b);
113✔
973
        if (reaction_int > 0) {
113!
974
          collision_track_config.mt_numbers.insert(reaction_int);
113✔
975
        }
976
      }
977
    }
65✔
978
    if (check_for_node(node_ct, "universe_ids")) {
155✔
979
      auto temp = get_node_array<int>(node_ct, "universe_ids");
32✔
980
      for (const auto& b : temp) {
64✔
981
        collision_track_config.universe_ids.insert(b);
32✔
982
      }
983
    }
32✔
984
    if (check_for_node(node_ct, "material_ids")) {
155✔
985
      auto temp = get_node_array<int>(node_ct, "material_ids");
32✔
986
      for (const auto& b : temp) {
80✔
987
        collision_track_config.material_ids.insert(b);
48✔
988
      }
989
    }
32✔
990
    if (check_for_node(node_ct, "nuclides")) {
155✔
991
      auto temp = get_node_array<std::string>(node_ct, "nuclides");
32✔
992
      for (const auto& b : temp) {
128✔
993
        collision_track_config.nuclides.insert(b);
96✔
994
      }
995
    }
32✔
996
    if (check_for_node(node_ct, "deposited_E_threshold")) {
155✔
997
      collision_track_config.deposited_energy_threshold =
32✔
998
        std::stod(get_node_value(node_ct, "deposited_E_threshold"));
32✔
999
    }
1000
    // Get maximum number of particles to be banked per collision
1001
    if (check_for_node(node_ct, "max_collisions")) {
155!
1002
      collision_track_config.max_collisions =
155✔
1003
        std::stoll(get_node_value(node_ct, "max_collisions"));
155✔
1004
    } else {
1005
      warning("A maximum number of collisions needs to be specified. "
×
1006
              "By default the code sets 'max_collisions' parameter equals to "
1007
              "1000.");
1008
    }
1009
    // Get maximum number of collision_track files to be created
1010
    if (check_for_node(node_ct, "max_collision_track_files")) {
155!
UNCOV
1011
      collision_track_config.max_files =
×
UNCOV
1012
        std::stoll(get_node_value(node_ct, "max_collision_track_files"));
×
1013
    }
1014
    if (check_for_node(node_ct, "mcpl")) {
155✔
1015
      collision_track_config.mcpl_write = get_node_value_bool(node_ct, "mcpl");
22✔
1016
    }
1017
  }
1018

1019
  // If source is not separate and is to be written out in the statepoint
1020
  // file, make sure that the sourcepoint batch numbers are contained in the
1021
  // statepoint list
1022
  if (!source_separate) {
8,231✔
1023
    for (const auto& b : sourcepoint_batch) {
16,410✔
1024
      if (!contains(statepoint_batch, b)) {
8,270!
UNCOV
1025
        fatal_error(
×
1026
          "Sourcepoint batches are not a subset of statepoint batches.");
1027
      }
1028
    }
1029
  }
1030

1031
  // Check if the user has specified to not reduce tallies at the end of every
1032
  // batch
1033
  if (check_for_node(root, "no_reduce")) {
8,231✔
1034
    reduce_tallies = !get_node_value_bool(root, "no_reduce");
32✔
1035
  }
1036

1037
  // Check if the user has specified to use confidence intervals for
1038
  // uncertainties rather than standard deviations
1039
  if (check_for_node(root, "confidence_intervals")) {
8,231✔
1040
    confidence_intervals = get_node_value_bool(root, "confidence_intervals");
16✔
1041
  }
1042

1043
  // Check for output options
1044
  if (check_for_node(root, "output")) {
8,231✔
1045
    // Get pointer to output node
1046
    pugi::xml_node node_output = root.child("output");
771✔
1047

1048
    // Check for summary option
1049
    if (check_for_node(node_output, "summary")) {
771✔
1050
      output_summary = get_node_value_bool(node_output, "summary");
744✔
1051
    }
1052

1053
    // Check for ASCII tallies output option
1054
    if (check_for_node(node_output, "tallies")) {
771✔
1055
      output_tallies = get_node_value_bool(node_output, "tallies");
349✔
1056
    }
1057

1058
    // Set output directory if a path has been specified
1059
    if (check_for_node(node_output, "path")) {
771!
UNCOV
1060
      path_output = get_node_value(node_output, "path");
×
UNCOV
1061
      if (!ends_with(path_output, "/")) {
×
UNCOV
1062
        path_output += "/";
×
1063
      }
1064
    }
1065
  }
1066

1067
  // Resonance scattering parameters
1068
  if (check_for_node(root, "resonance_scattering")) {
8,231✔
1069
    xml_node node_res_scat = root.child("resonance_scattering");
16✔
1070

1071
    // See if resonance scattering is enabled
1072
    if (check_for_node(node_res_scat, "enable")) {
16!
1073
      res_scat_on = get_node_value_bool(node_res_scat, "enable");
16✔
1074
    } else {
UNCOV
1075
      res_scat_on = true;
×
1076
    }
1077

1078
    // Determine what method is used
1079
    if (check_for_node(node_res_scat, "method")) {
16!
1080
      auto temp = get_node_value(node_res_scat, "method", true, true);
16✔
1081
      if (temp == "rvs") {
16!
1082
        res_scat_method = ResScatMethod::rvs;
16✔
UNCOV
1083
      } else if (temp == "dbrc") {
×
UNCOV
1084
        res_scat_method = ResScatMethod::dbrc;
×
1085
      } else {
UNCOV
1086
        fatal_error(
×
UNCOV
1087
          "Unrecognized resonance elastic scattering method: " + temp + ".");
×
1088
      }
1089
    }
16✔
1090

1091
    // Minimum energy for resonance scattering
1092
    if (check_for_node(node_res_scat, "energy_min")) {
16!
1093
      res_scat_energy_min =
16✔
1094
        std::stod(get_node_value(node_res_scat, "energy_min"));
16✔
1095
    }
1096
    if (res_scat_energy_min < 0.0) {
16!
UNCOV
1097
      fatal_error("Lower resonance scattering energy bound is negative");
×
1098
    }
1099

1100
    // Maximum energy for resonance scattering
1101
    if (check_for_node(node_res_scat, "energy_max")) {
16!
1102
      res_scat_energy_max =
16✔
1103
        std::stod(get_node_value(node_res_scat, "energy_max"));
16✔
1104
    }
1105
    if (res_scat_energy_max < res_scat_energy_min) {
16!
UNCOV
1106
      fatal_error("Upper resonance scattering energy bound is below the "
×
1107
                  "lower resonance scattering energy bound.");
1108
    }
1109

1110
    // Get resonance scattering nuclides
1111
    if (check_for_node(node_res_scat, "nuclides")) {
16!
1112
      res_scat_nuclides =
1113
        get_node_array<std::string>(node_res_scat, "nuclides");
16✔
1114
    }
1115
  }
1116

1117
  // Get volume calculations
1118
  for (pugi::xml_node node_vol : root.children("volume_calc")) {
8,557✔
1119
    model::volume_calcs.emplace_back(node_vol);
326✔
1120
  }
1121

1122
  // Get temperature settings
1123
  if (check_for_node(root, "temperature_default")) {
8,231✔
1124
    temperature_default =
172✔
1125
      std::stod(get_node_value(root, "temperature_default"));
172✔
1126
  }
1127
  if (check_for_node(root, "temperature_method")) {
8,231✔
1128
    auto temp = get_node_value(root, "temperature_method", true, true);
499✔
1129
    if (temp == "nearest") {
499✔
1130
      temperature_method = TemperatureMethod::NEAREST;
314✔
1131
    } else if (temp == "interpolation") {
185!
1132
      temperature_method = TemperatureMethod::INTERPOLATION;
185✔
1133
    } else {
UNCOV
1134
      fatal_error("Unknown temperature method: " + temp);
×
1135
    }
1136
  }
499✔
1137
  if (check_for_node(root, "temperature_tolerance")) {
8,231✔
1138
    temperature_tolerance =
345✔
1139
      std::stod(get_node_value(root, "temperature_tolerance"));
345✔
1140
  }
1141
  if (check_for_node(root, "temperature_multipole")) {
8,231✔
1142
    temperature_multipole = get_node_value_bool(root, "temperature_multipole");
190✔
1143

1144
    // Multipole currently doesn't work with photon transport
1145
    if (temperature_multipole && photon_transport) {
190!
UNCOV
1146
      fatal_error("Multipole data cannot currently be used in conjunction with "
×
1147
                  "photon transport.");
1148
    }
1149
  }
1150
  if (check_for_node(root, "temperature_range")) {
8,231✔
1151
    auto range = get_node_array<double>(root, "temperature_range");
174✔
1152
    temperature_range[0] = range.at(0);
174✔
1153
    temperature_range[1] = range.at(1);
174✔
1154
  }
174✔
1155

1156
  // Check for tabular_legendre options
1157
  if (check_for_node(root, "tabular_legendre")) {
8,231✔
1158
    // Get pointer to tabular_legendre node
1159
    xml_node node_tab_leg = root.child("tabular_legendre");
96✔
1160

1161
    // Check for enable option
1162
    if (check_for_node(node_tab_leg, "enable")) {
96!
1163
      legendre_to_tabular = get_node_value_bool(node_tab_leg, "enable");
96✔
1164
    }
1165

1166
    // Check for the number of points
1167
    if (check_for_node(node_tab_leg, "num_points")) {
96!
UNCOV
1168
      legendre_to_tabular_points =
×
UNCOV
1169
        std::stoi(get_node_value(node_tab_leg, "num_points"));
×
UNCOV
1170
      if (legendre_to_tabular_points <= 1 && !run_CE) {
×
UNCOV
1171
        fatal_error(
×
1172
          "The 'num_points' subelement/attribute of the "
1173
          "<tabular_legendre> element must contain a value greater than 1");
1174
      }
1175
    }
1176
  }
1177

1178
  // Check whether create delayed neutrons in fission
1179
  if (check_for_node(root, "create_delayed_neutrons")) {
8,231!
UNCOV
1180
    create_delayed_neutrons =
×
UNCOV
1181
      get_node_value_bool(root, "create_delayed_neutrons");
×
1182
  }
1183

1184
  // Check whether create fission sites
1185
  if (run_mode == RunMode::FIXED_SOURCE) {
8,231✔
1186
    if (check_for_node(root, "create_fission_neutrons")) {
2,762✔
1187
      create_fission_neutrons =
281✔
1188
        get_node_value_bool(root, "create_fission_neutrons");
281✔
1189
    }
1190
  }
1191

1192
  // Check whether to scale fission photon yields
1193
  if (check_for_node(root, "delayed_photon_scaling")) {
8,231!
UNCOV
1194
    delayed_photon_scaling =
×
UNCOV
1195
      get_node_value_bool(root, "delayed_photon_scaling");
×
1196
  }
1197

1198
  // Check whether to use event-based parallelism
1199
  if (check_for_node(root, "event_based")) {
8,231!
UNCOV
1200
    event_based = get_node_value_bool(root, "event_based");
×
1201
  }
1202

1203
  // Check whether material cell offsets should be generated
1204
  if (check_for_node(root, "material_cell_offsets")) {
8,231!
UNCOV
1205
    material_cell_offsets = get_node_value_bool(root, "material_cell_offsets");
×
1206
  }
1207

1208
  // Weight window information
1209
  for (pugi::xml_node node_ww : root.children("weight_windows")) {
8,323✔
1210
    variance_reduction::weight_windows.emplace_back(
92✔
1211
      std::make_unique<WeightWindows>(node_ww));
184✔
1212
  }
1213

1214
  // Enable weight windows by default if one or more are present
1215
  if (variance_reduction::weight_windows.size() > 0)
8,231✔
1216
    settings::weight_windows_on = true;
65✔
1217

1218
  // read weight windows from file
1219
  if (check_for_node(root, "weight_windows_file")) {
8,231!
UNCOV
1220
    weight_windows_file = get_node_value(root, "weight_windows_file");
×
1221
  }
1222

1223
  // read settings for weight windows value, this will override
1224
  // the automatic setting even if weight windows are present
1225
  if (check_for_node(root, "weight_windows_on")) {
8,231✔
1226
    weight_windows_on = get_node_value_bool(root, "weight_windows_on");
38✔
1227
  }
1228

1229
  if (check_for_node(root, "max_secondaries")) {
8,231!
UNCOV
1230
    settings::max_secondaries =
×
UNCOV
1231
      std::stoi(get_node_value(root, "max_secondaries"));
×
1232
  }
1233

1234
  if (check_for_node(root, "max_history_splits")) {
8,231✔
1235
    settings::max_history_splits =
215✔
1236
      std::stoi(get_node_value(root, "max_history_splits"));
215✔
1237
  }
1238

1239
  if (check_for_node(root, "max_tracks")) {
8,231✔
1240
    settings::max_tracks = std::stoi(get_node_value(root, "max_tracks"));
48✔
1241
  }
1242

1243
  // Create weight window generator objects
1244
  if (check_for_node(root, "weight_window_generators")) {
8,231✔
1245
    auto wwgs_node = root.child("weight_window_generators");
82✔
1246
    for (pugi::xml_node node_wwg :
82✔
1247
      wwgs_node.children("weight_windows_generator")) {
246✔
1248
      variance_reduction::weight_windows_generators.emplace_back(
82✔
1249
        std::make_unique<WeightWindowsGenerator>(node_wwg));
164✔
1250
    }
1251
    // if any of the weight windows are intended to be generated otf, make
1252
    // sure they're applied
1253
    for (const auto& wwg : variance_reduction::weight_windows_generators) {
82!
1254
      if (wwg->on_the_fly_) {
82!
1255
        settings::weight_windows_on = true;
82✔
1256
        break;
82✔
1257
      }
1258
    }
1259
  }
1260

1261
  // Set up weight window checkpoints
1262
  if (check_for_node(root, "weight_window_checkpoints")) {
8,231✔
1263
    xml_node ww_checkpoints = root.child("weight_window_checkpoints");
2!
1264
    if (check_for_node(ww_checkpoints, "collision")) {
2!
1265
      weight_window_checkpoint_collision =
2✔
1266
        get_node_value_bool(ww_checkpoints, "collision");
2!
1267
    }
1268
    if (check_for_node(ww_checkpoints, "surface")) {
2!
1269
      weight_window_checkpoint_surface =
2✔
1270
        get_node_value_bool(ww_checkpoints, "surface");
2!
1271
    }
1272
  }
1273

1274
  if (check_for_node(root, "use_decay_photons")) {
8,231✔
1275
    settings::use_decay_photons =
11✔
1276
      get_node_value_bool(root, "use_decay_photons");
11✔
1277
  }
1278
}
8,231✔
1279

1280
void free_memory_settings()
8,382✔
1281
{
1282
  settings::statepoint_batch.clear();
8,382✔
1283
  settings::sourcepoint_batch.clear();
8,382✔
1284
  settings::source_write_surf_id.clear();
8,382✔
1285
  settings::res_scat_nuclides.clear();
8,382✔
1286
}
8,382✔
1287

1288
//==============================================================================
1289
// C API functions
1290
//==============================================================================
1291

1292
extern "C" int openmc_set_n_batches(
44✔
1293
  int32_t n_batches, bool set_max_batches, bool add_statepoint_batch)
1294
{
1295
  if (settings::n_inactive >= n_batches) {
44✔
1296
    set_errmsg("Number of active batches must be greater than zero.");
11✔
1297
    return OPENMC_E_INVALID_ARGUMENT;
11✔
1298
  }
1299

1300
  if (!settings::trigger_on) {
33✔
1301
    // Set n_batches and n_max_batches to same value
1302
    settings::n_batches = n_batches;
11✔
1303
    settings::n_max_batches = n_batches;
11✔
1304
  } else {
1305
    // Set n_batches and n_max_batches based on value of set_max_batches
1306
    if (set_max_batches) {
22✔
1307
      settings::n_max_batches = n_batches;
11✔
1308
    } else {
1309
      settings::n_batches = n_batches;
11✔
1310
    }
1311
  }
1312

1313
  // Update size of k_generation and entropy
1314
  int m = settings::n_max_batches * settings::gen_per_batch;
33✔
1315
  simulation::k_generation.reserve(m);
33✔
1316
  simulation::entropy.reserve(m);
33✔
1317

1318
  // Add value of n_batches to statepoint_batch
1319
  if (add_statepoint_batch &&
55✔
1320
      !(contains(settings::statepoint_batch, n_batches)))
22!
1321
    settings::statepoint_batch.insert(n_batches);
22✔
1322

1323
  return 0;
33✔
1324
}
1325

1326
extern "C" int openmc_get_n_batches(int* n_batches, bool get_max_batches)
2,530✔
1327
{
1328
  *n_batches = get_max_batches ? settings::n_max_batches : settings::n_batches;
2,530✔
1329

1330
  return 0;
2,530✔
1331
}
1332

1333
} // namespace openmc
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc