27291281945

Committed 10 Jun 2026 04:44PM UTC coverage: 81.338% (+0.06%) from 81.281%

Build # 27291281945

Build Type

Pull #3965

github

Committed by

web-flow

Commit Message

Merge 0ec75ce2d into 02eb999af

Pull Request Pull Request #3965: MGXS Bootstrapping

Coverage Stats

18167 of 26320 branches covered (69.02%)

Branch coverage included in aggregate %.

68 of 68 new or added lines in 4 files covered. (100.0%)

787 existing lines in 47 files now uncovered.

59351 of 68984 relevant lines covered (86.04%)

67755206.51 hits per line

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

74.42

/src/event.cpp

#include "openmc/event.h"

#include "openmc/bank.h"
#include "openmc/error.h"
#include "openmc/material.h"
#include "openmc/settings.h"
#include "openmc/simulation.h"
#include "openmc/timer.h"

namespace openmc {

//==============================================================================
// Global variables
//==============================================================================

namespace simulation {

SharedArray<EventQueueItem> calculate_fuel_xs_queue;
SharedArray<EventQueueItem> calculate_nonfuel_xs_queue;
SharedArray<EventQueueItem> advance_particle_queue;
SharedArray<EventQueueItem> surface_crossing_queue;
SharedArray<EventQueueItem> collision_queue;

vector<Particle> particles;

} // namespace simulation

//==============================================================================
// Non-member functions
//==============================================================================

void init_event_queues(int64_t n_particles)
{
  simulation::calculate_fuel_xs_queue.reserve(n_particles);
  simulation::calculate_nonfuel_xs_queue.reserve(n_particles);
  simulation::advance_particle_queue.reserve(n_particles);
  simulation::surface_crossing_queue.reserve(n_particles);
  simulation::collision_queue.reserve(n_particles);

  simulation::particles.resize(n_particles);
}

void free_event_queues(void)
{
  simulation::calculate_fuel_xs_queue.clear();
  simulation::calculate_nonfuel_xs_queue.clear();
  simulation::advance_particle_queue.clear();
  simulation::surface_crossing_queue.clear();
  simulation::collision_queue.clear();

  simulation::particles.clear();
}

void dispatch_xs_event(int64_t buffer_idx)
{
  Particle& p = simulation::particles[buffer_idx];
  if (p.material() == MATERIAL_VOID ||
      !model::materials[p.material()]->fissionable()) {
    simulation::calculate_nonfuel_xs_queue.thread_safe_append({p, buffer_idx});
  } else {
    simulation::calculate_fuel_xs_queue.thread_safe_append({p, buffer_idx});
  }
}

void process_init_events(int64_t n_particles, int64_t source_offset)
{
  simulation::time_event_init.start();
#pragma omp parallel for schedule(runtime)
  for (int64_t i = 0; i < n_particles; i++) {
    initialize_particle_track(
      simulation::particles[i], source_offset + i + 1, false);
    dispatch_xs_event(i);
  }
  simulation::time_event_init.stop();
}

void process_calculate_xs_events(SharedArray<EventQueueItem>& queue)
{
  simulation::time_event_calculate_xs.start();

  // TODO: If using C++17, we could perform a parallel sort of the queue by
  // particle type, material type, and then energy, in order to improve cache
  // locality and reduce thread divergence on GPU. However, the parallel
  // algorithms typically require linking against an additional library (Intel
  // TBB). Prior to C++17, std::sort is a serial only operation, which in this
  // case makes it too slow to be practical for most test problems.
  //
  // std::sort(std::execution::par_unseq, queue.data(), queue.data() +
  // queue.size());

  int64_t offset = simulation::advance_particle_queue.size();

#pragma omp parallel for schedule(runtime)
  for (int64_t i = 0; i < queue.size(); i++) {
    Particle* p = &simulation::particles[queue[i].idx];
    p->event_calculate_xs();

    // After executing a calculate_xs event, particles will
    // always require an advance event. Therefore, we don't need to use
    // the protected enqueuing function.
    simulation::advance_particle_queue[offset + i] = queue[i];
  }

  simulation::advance_particle_queue.resize(offset + queue.size());

  queue.resize(0);

  simulation::time_event_calculate_xs.stop();
}

void process_advance_particle_events()
{
  simulation::time_event_advance_particle.start();

#pragma omp parallel for schedule(runtime)
  for (int64_t i = 0; i < simulation::advance_particle_queue.size(); i++) {
    int64_t buffer_idx = simulation::advance_particle_queue[i].idx;
    Particle& p = simulation::particles[buffer_idx];
    p.event_advance();
    if (!p.alive())
      continue;
    if (p.collision_distance() > p.boundary().distance()) {
      simulation::surface_crossing_queue.thread_safe_append({p, buffer_idx});
    } else {
      simulation::collision_queue.thread_safe_append({p, buffer_idx});
    }
  }

  simulation::advance_particle_queue.resize(0);

  simulation::time_event_advance_particle.stop();
}

void process_surface_crossing_events()
{
  simulation::time_event_surface_crossing.start();

#pragma omp parallel for schedule(runtime)
  for (int64_t i = 0; i < simulation::surface_crossing_queue.size(); i++) {
    int64_t buffer_idx = simulation::surface_crossing_queue[i].idx;
    Particle& p = simulation::particles[buffer_idx];
    p.event_cross_surface();
    p.event_check_limit_and_revive();
    if (p.alive())
      dispatch_xs_event(buffer_idx);
  }

  simulation::surface_crossing_queue.resize(0);

  simulation::time_event_surface_crossing.stop();
}

void process_collision_events()
{
  simulation::time_event_collision.start();

#pragma omp parallel for schedule(runtime)
  for (int64_t i = 0; i < simulation::collision_queue.size(); i++) {
    int64_t buffer_idx = simulation::collision_queue[i].idx;
    Particle& p = simulation::particles[buffer_idx];
    p.event_collide();
    p.event_check_limit_and_revive();
    if (p.alive())
      dispatch_xs_event(buffer_idx);
  }

  simulation::collision_queue.resize(0);

  simulation::time_event_collision.stop();
}

void process_death_events(int64_t n_particles)
{
  simulation::time_event_death.start();
#pragma omp parallel for schedule(runtime)
  for (int64_t i = 0; i < n_particles; i++) {
    Particle& p = simulation::particles[i];
    p.event_death();
  }
  simulation::time_event_death.stop();
}

void process_transport_events()
{
  while (true) {
    int64_t max = std::max({simulation::calculate_fuel_xs_queue.size(),
      simulation::calculate_nonfuel_xs_queue.size(),
      simulation::advance_particle_queue.size(),
      simulation::surface_crossing_queue.size(),
      simulation::collision_queue.size()});

    if (max == 0) {
      break;
    } else if (max == simulation::calculate_fuel_xs_queue.size()) {
      process_calculate_xs_events(simulation::calculate_fuel_xs_queue);
    } else if (max == simulation::calculate_nonfuel_xs_queue.size()) {
      process_calculate_xs_events(simulation::calculate_nonfuel_xs_queue);
    } else if (max == simulation::advance_particle_queue.size()) {
      process_advance_particle_events();
    } else if (max == simulation::surface_crossing_queue.size()) {
      process_surface_crossing_events();
    } else if (max == simulation::collision_queue.size()) {
      process_collision_events();
    }
  }
}

void process_init_secondary_events(int64_t n_particles, int64_t offset,
  const SharedArray<SourceSite>& shared_secondary_bank)
{
  simulation::time_event_init.start();
#pragma omp parallel for schedule(runtime)
  for (int64_t i = 0; i < n_particles; i++) {
    initialize_particle_track(simulation::particles[i], offset + i + 1, true);
    const SourceSite& site = shared_secondary_bank[offset + i];
    simulation::particles[i].event_revive_from_secondary(site);
    if (simulation::particles[i].alive()) {
      dispatch_xs_event(i);
    }
  }
  simulation::time_event_init.stop();
}

} // namespace openmc

1	#include "openmc/event.h"
2
3	#include "openmc/bank.h"
4	#include "openmc/error.h"
5	#include "openmc/material.h"
6	#include "openmc/settings.h"
7	#include "openmc/simulation.h"
8	#include "openmc/timer.h"
9
10	namespace openmc {
11
12	//==============================================================================
13	// Global variables
14	//==============================================================================
15
16	namespace simulation {
17
18	SharedArray<EventQueueItem> calculate_fuel_xs_queue;
19	SharedArray<EventQueueItem> calculate_nonfuel_xs_queue;
20	SharedArray<EventQueueItem> advance_particle_queue;
21	SharedArray<EventQueueItem> surface_crossing_queue;
22	SharedArray<EventQueueItem> collision_queue;
23
24	vector<Particle> particles;
25
26	} // namespace simulation
27
28	//==============================================================================
29	// Non-member functions
30	//==============================================================================
31
UNCOV 32	void init_event_queues(int64_t n_particles)	271✔
33	{
UNCOV 34	simulation::calculate_fuel_xs_queue.reserve(n_particles);	271✔
UNCOV 35	simulation::calculate_nonfuel_xs_queue.reserve(n_particles);	271✔
UNCOV 36	simulation::advance_particle_queue.reserve(n_particles);	271✔
UNCOV 37	simulation::surface_crossing_queue.reserve(n_particles);	271✔
UNCOV 38	simulation::collision_queue.reserve(n_particles);	271✔
39
UNCOV 40	simulation::particles.resize(n_particles);	271✔
UNCOV 41	}	271✔
42
43	void free_event_queues(void)	×
44	{
45	simulation::calculate_fuel_xs_queue.clear();	×
46	simulation::calculate_nonfuel_xs_queue.clear();	×
47	simulation::advance_particle_queue.clear();	×
48	simulation::surface_crossing_queue.clear();	×
49	simulation::collision_queue.clear();	×
50
51	simulation::particles.clear();	×
52	}	×
53
UNCOV 54	void dispatch_xs_event(int64_t buffer_idx)	236,168,971✔
55	{
UNCOV 56	Particle& p = simulation::particles[buffer_idx];	236,168,971✔
UNCOV 57	if (p.material() == MATERIAL_VOID \|\|	236,168,971✔
UNCOV 58	!model::materials[p.material()]->fissionable()) {	218,223,648✔
UNCOV 59	simulation::calculate_nonfuel_xs_queue.thread_safe_append({p, buffer_idx});	57,202,217✔
60	} else {
UNCOV 61	simulation::calculate_fuel_xs_queue.thread_safe_append({p, buffer_idx});	178,966,754✔
62	}
UNCOV 63	}	236,168,971✔
64
UNCOV 65	void process_init_events(int64_t n_particles, int64_t source_offset)	3,231✔
66	{
UNCOV 67	simulation::time_event_init.start();	3,231✔
68	#pragma omp parallel for schedule(runtime)	3,231✔
UNCOV 69	for (int64_t i = 0; i < n_particles; i++) {	×
UNCOV 70	initialize_particle_track(
UNCOV 71	simulation::particles[i], source_offset + i + 1, false);
UNCOV 72	dispatch_xs_event(i);
73	}
UNCOV 74	simulation::time_event_init.stop();	3,231✔
UNCOV 75	}	3,231✔
76
UNCOV 77	void process_calculate_xs_events(SharedArray<EventQueueItem>& queue)	1,326,868✔
78	{
UNCOV 79	simulation::time_event_calculate_xs.start();	1,326,868✔
80
81	// TODO: If using C++17, we could perform a parallel sort of the queue by
82	// particle type, material type, and then energy, in order to improve cache
83	// locality and reduce thread divergence on GPU. However, the parallel
84	// algorithms typically require linking against an additional library (Intel
85	// TBB). Prior to C++17, std::sort is a serial only operation, which in this
86	// case makes it too slow to be practical for most test problems.
87	//
88	// std::sort(std::execution::par_unseq, queue.data(), queue.data() +
89	// queue.size());
90
UNCOV 91	int64_t offset = simulation::advance_particle_queue.size();	1,326,868✔
92
93	#pragma omp parallel for schedule(runtime)	1,326,868✔
UNCOV 94	for (int64_t i = 0; i < queue.size(); i++) {	×
UNCOV 95	Particle* p = &simulation::particles[queue[i].idx];
UNCOV 96	p->event_calculate_xs();
97
98	// After executing a calculate_xs event, particles will
99	// always require an advance event. Therefore, we don't need to use
100	// the protected enqueuing function.
UNCOV 101	simulation::advance_particle_queue[offset + i] = queue[i];
102	}
103
UNCOV 104	simulation::advance_particle_queue.resize(offset + queue.size());	1,326,868✔
105
UNCOV 106	queue.resize(0);	1,326,868✔
107
UNCOV 108	simulation::time_event_calculate_xs.stop();	1,326,868✔
UNCOV 109	}	1,326,868✔
110
UNCOV 111	void process_advance_particle_events()	1,321,578✔
112	{
UNCOV 113	simulation::time_event_advance_particle.start();	1,321,578✔
114
115	#pragma omp parallel for schedule(runtime)	1,321,578✔
UNCOV 116	for (int64_t i = 0; i < simulation::advance_particle_queue.size(); i++) {	×
UNCOV 117	int64_t buffer_idx = simulation::advance_particle_queue[i].idx;
UNCOV 118	Particle& p = simulation::particles[buffer_idx];
UNCOV 119	p.event_advance();
UNCOV 120	if (!p.alive())	×
UNCOV 121	continue;
UNCOV 122	if (p.collision_distance() > p.boundary().distance()) {	×
UNCOV 123	simulation::surface_crossing_queue.thread_safe_append({p, buffer_idx});
124	} else {
UNCOV 125	simulation::collision_queue.thread_safe_append({p, buffer_idx});
126	}
127	}
128
UNCOV 129	simulation::advance_particle_queue.resize(0);	1,321,578✔
130
UNCOV 131	simulation::time_event_advance_particle.stop();	1,321,578✔
UNCOV 132	}	1,321,578✔
133
UNCOV 134	void process_surface_crossing_events()	274,979✔
135	{
UNCOV 136	simulation::time_event_surface_crossing.start();	274,979✔
137
138	#pragma omp parallel for schedule(runtime)	274,979✔
UNCOV 139	for (int64_t i = 0; i < simulation::surface_crossing_queue.size(); i++) {	×
UNCOV 140	int64_t buffer_idx = simulation::surface_crossing_queue[i].idx;
UNCOV 141	Particle& p = simulation::particles[buffer_idx];
UNCOV 142	p.event_cross_surface();
UNCOV 143	p.event_check_limit_and_revive();
UNCOV 144	if (p.alive())	×
UNCOV 145	dispatch_xs_event(buffer_idx);
146	}
147
UNCOV 148	simulation::surface_crossing_queue.resize(0);	274,979✔
149
UNCOV 150	simulation::time_event_surface_crossing.stop();	274,979✔
UNCOV 151	}	274,979✔
152
UNCOV 153	void process_collision_events()	1,067,871✔
154	{
UNCOV 155	simulation::time_event_collision.start();	1,067,871✔
156
157	#pragma omp parallel for schedule(runtime)	1,067,871✔
UNCOV 158	for (int64_t i = 0; i < simulation::collision_queue.size(); i++) {	×
UNCOV 159	int64_t buffer_idx = simulation::collision_queue[i].idx;
UNCOV 160	Particle& p = simulation::particles[buffer_idx];
UNCOV 161	p.event_collide();
UNCOV 162	p.event_check_limit_and_revive();
UNCOV 163	if (p.alive())	×
UNCOV 164	dispatch_xs_event(buffer_idx);
165	}
166
UNCOV 167	simulation::collision_queue.resize(0);	1,067,871✔
168
UNCOV 169	simulation::time_event_collision.stop();	1,067,871✔
UNCOV 170	}	1,067,871✔
171
UNCOV 172	void process_death_events(int64_t n_particles)	3,915✔
173	{
UNCOV 174	simulation::time_event_death.start();	3,915✔
175	#pragma omp parallel for schedule(runtime)	3,915✔
UNCOV 176	for (int64_t i = 0; i < n_particles; i++) {	×
UNCOV 177	Particle& p = simulation::particles[i];
UNCOV 178	p.event_death();
179	}
UNCOV 180	simulation::time_event_death.stop();	3,915✔
UNCOV 181	}	3,915✔
182
UNCOV 183	void process_transport_events()	3,915✔
184	{
UNCOV 185	while (true) {	3,995,211✔
UNCOV 186	int64_t max = std::max({simulation::calculate_fuel_xs_queue.size(),	3,995,211✔
UNCOV 187	simulation::calculate_nonfuel_xs_queue.size(),	3,995,211✔
UNCOV 188	simulation::advance_particle_queue.size(),	3,995,211✔
UNCOV 189	simulation::surface_crossing_queue.size(),	3,995,211✔
UNCOV 190	simulation::collision_queue.size()});	3,995,211✔
191
UNCOV 192	if (max == 0) {	3,995,211✔
193	break;
UNCOV 194	} else if (max == simulation::calculate_fuel_xs_queue.size()) {	3,991,296✔
UNCOV 195	process_calculate_xs_events(simulation::calculate_fuel_xs_queue);	466,126✔
UNCOV 196	} else if (max == simulation::calculate_nonfuel_xs_queue.size()) {	3,525,170✔
UNCOV 197	process_calculate_xs_events(simulation::calculate_nonfuel_xs_queue);	860,742✔
UNCOV 198	} else if (max == simulation::advance_particle_queue.size()) {	2,664,428✔
UNCOV 199	process_advance_particle_events();	1,321,578✔
UNCOV 200	} else if (max == simulation::surface_crossing_queue.size()) {	1,342,850✔
UNCOV 201	process_surface_crossing_events();	274,979✔
UNCOV 202	} else if (max == simulation::collision_queue.size()) {	1,067,871!
UNCOV 203	process_collision_events();	1,067,871✔
204	}
205	}
UNCOV 206	}	3,915✔
207
UNCOV 208	void process_init_secondary_events(int64_t n_particles, int64_t offset,	684✔
209	const SharedArray<SourceSite>& shared_secondary_bank)
210	{
UNCOV 211	simulation::time_event_init.start();	684✔
212	#pragma omp parallel for schedule(runtime)	684✔
UNCOV 213	for (int64_t i = 0; i < n_particles; i++) {	×
UNCOV 214	initialize_particle_track(simulation::particles[i], offset + i + 1, true);
UNCOV 215	const SourceSite& site = shared_secondary_bank[offset + i];
UNCOV 216	simulation::particles[i].event_revive_from_secondary(site);
UNCOV 217	if (simulation::particles[i].alive()) {	×
UNCOV 218	dispatch_xs_event(i);
219	}
220	}
UNCOV 221	simulation::time_event_init.stop();	684✔
UNCOV 222	}	684✔
223
224	} // namespace openmc

openmc-dev / openmc / 27291281945

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

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