26956743031

Committed 04 Jun 2026 02:03PM UTC coverage: 80.614% (-0.7%) from 81.356%

Build # 26956743031

Build Type

Pull #3958

github

Committed by

web-flow

Commit Message

Merge 36f98e9b2 into 111eb7706

Pull Request Pull Request #3958: Preserve collision count when splitting particles

Coverage Stats

16584 of 23953 branches covered (69.24%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

790 existing lines in 49 files now uncovered.

57226 of 67607 relevant lines covered (84.65%)

23420517.73 hits per line

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

0.0

/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)	×
33	{
UNCOV 34	simulation::calculate_fuel_xs_queue.reserve(n_particles);	×
UNCOV 35	simulation::calculate_nonfuel_xs_queue.reserve(n_particles);	×
UNCOV 36	simulation::advance_particle_queue.reserve(n_particles);	×
UNCOV 37	simulation::surface_crossing_queue.reserve(n_particles);	×
UNCOV 38	simulation::collision_queue.reserve(n_particles);	×
39
UNCOV 40	simulation::particles.resize(n_particles);	×
UNCOV 41	}	×
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)	×
55	{
UNCOV 56	Particle& p = simulation::particles[buffer_idx];	×
UNCOV 57	if (p.material() == MATERIAL_VOID \|\|	×
UNCOV 58	!model::materials[p.material()]->fissionable()) {	×
UNCOV 59	simulation::calculate_nonfuel_xs_queue.thread_safe_append({p, buffer_idx});	×
60	} else {
UNCOV 61	simulation::calculate_fuel_xs_queue.thread_safe_append({p, buffer_idx});	×
62	}
UNCOV 63	}	×
64
UNCOV 65	void process_init_events(int64_t n_particles, int64_t source_offset)	×
66	{
UNCOV 67	simulation::time_event_init.start();	×
68	#pragma omp parallel for schedule(runtime)
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();	×
UNCOV 75	}	×
76
UNCOV 77	void process_calculate_xs_events(SharedArray<EventQueueItem>& queue)	×
78	{
UNCOV 79	simulation::time_event_calculate_xs.start();	×
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();	×
92
93	#pragma omp parallel for schedule(runtime)
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());	×
105
UNCOV 106	queue.resize(0);	×
107
UNCOV 108	simulation::time_event_calculate_xs.stop();	×
UNCOV 109	}	×
110
UNCOV 111	void process_advance_particle_events()	×
112	{
UNCOV 113	simulation::time_event_advance_particle.start();	×
114
115	#pragma omp parallel for schedule(runtime)
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);	×
130
UNCOV 131	simulation::time_event_advance_particle.stop();	×
UNCOV 132	}	×
133
UNCOV 134	void process_surface_crossing_events()	×
135	{
UNCOV 136	simulation::time_event_surface_crossing.start();	×
137
138	#pragma omp parallel for schedule(runtime)
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);	×
149
UNCOV 150	simulation::time_event_surface_crossing.stop();	×
UNCOV 151	}	×
152
UNCOV 153	void process_collision_events()	×
154	{
UNCOV 155	simulation::time_event_collision.start();	×
156
157	#pragma omp parallel for schedule(runtime)
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);	×
168
UNCOV 169	simulation::time_event_collision.stop();	×
UNCOV 170	}	×
171
UNCOV 172	void process_death_events(int64_t n_particles)	×
173	{
UNCOV 174	simulation::time_event_death.start();	×
175	#pragma omp parallel for schedule(runtime)
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();	×
UNCOV 181	}	×
182
UNCOV 183	void process_transport_events()	×
184	{
UNCOV 185	while (true) {	×
UNCOV 186	int64_t max = std::max({simulation::calculate_fuel_xs_queue.size(),	×
UNCOV 187	simulation::calculate_nonfuel_xs_queue.size(),	×
UNCOV 188	simulation::advance_particle_queue.size(),	×
UNCOV 189	simulation::surface_crossing_queue.size(),	×
UNCOV 190	simulation::collision_queue.size()});	×
191
UNCOV 192	if (max == 0) {	×
193	break;
UNCOV 194	} else if (max == simulation::calculate_fuel_xs_queue.size()) {	×
UNCOV 195	process_calculate_xs_events(simulation::calculate_fuel_xs_queue);	×
UNCOV 196	} else if (max == simulation::calculate_nonfuel_xs_queue.size()) {	×
UNCOV 197	process_calculate_xs_events(simulation::calculate_nonfuel_xs_queue);	×
UNCOV 198	} else if (max == simulation::advance_particle_queue.size()) {	×
UNCOV 199	process_advance_particle_events();	×
UNCOV 200	} else if (max == simulation::surface_crossing_queue.size()) {	×
UNCOV 201	process_surface_crossing_events();	×
UNCOV 202	} else if (max == simulation::collision_queue.size()) {	×
UNCOV 203	process_collision_events();	×
204	}
205	}
UNCOV 206	}	×
207
UNCOV 208	void process_init_secondary_events(int64_t n_particles, int64_t offset,	×
209	const SharedArray<SourceSite>& shared_secondary_bank)
210	{
UNCOV 211	simulation::time_event_init.start();	×
212	#pragma omp parallel for schedule(runtime)
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();	×
UNCOV 222	}	×
223
224	} // namespace openmc

openmc-dev / openmc / 26956743031

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