19041149218

Committed 03 Nov 2025 04:12PM UTC coverage: 81.294% (-0.6%) from 81.872%

Build # 19041149218

Build Type

Pull #3550

github

Committed by

web-flow

Commit Message

Merge cc7c3a5ec into fd964bc9b

Pull Request Pull Request #3550: [Point Detector] Add distribution get_pdf functionality

Run Details

16664 of 23490 branches covered (70.94%)

Branch coverage included in aggregate %.

2 of 387 new or added lines in 13 files covered. (0.52%)

3 existing lines in 1 file now uncovered.

54148 of 63616 relevant lines covered (85.12%)

43073383.89 hits per line

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

54.39

/src/thermal.cpp

#include "openmc/thermal.h"

#include <algorithm> // for sort, move, min, max, find
#include <cmath>     // for round, sqrt, abs

#include "xtensor/xarray.hpp"
#include "xtensor/xbuilder.hpp"
#include "xtensor/xmath.hpp"
#include "xtensor/xsort.hpp"
#include "xtensor/xtensor.hpp"
#include "xtensor/xview.hpp"
#include <fmt/core.h>

#include "openmc/constants.h"
#include "openmc/endf.h"
#include "openmc/error.h"
#include "openmc/random_lcg.h"
#include "openmc/search.h"
#include "openmc/secondary_correlated.h"
#include "openmc/secondary_thermal.h"
#include "openmc/settings.h"
#include "openmc/string_utils.h"

namespace openmc {

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

namespace data {
std::unordered_map<std::string, int> thermal_scatt_map;
vector<unique_ptr<ThermalScattering>> thermal_scatt;
} // namespace data

//==============================================================================
// ThermalScattering implementation
//==============================================================================

ThermalScattering::ThermalScattering(
  hid_t group, const vector<double>& temperature)
{
  // Get name of table from group
  name_ = object_name(group);

  // Get rid of leading '/'
  name_ = name_.substr(1);

  read_attribute(group, "atomic_weight_ratio", awr_);
  read_attribute(group, "energy_max", energy_max_);
  read_attribute(group, "nuclides", nuclides_);

  // Read temperatures
  hid_t kT_group = open_group(group, "kTs");

  // Determine temperatures available
  auto dset_names = dataset_names(kT_group);
  auto n = dset_names.size();
  auto temps_available = xt::empty<double>({n});
  for (int i = 0; i < dset_names.size(); ++i) {
    // Read temperature value
    double T;
    read_dataset(kT_group, dset_names[i].data(), T);
    temps_available[i] = std::round(T / K_BOLTZMANN);
  }
  std::sort(temps_available.begin(), temps_available.end());

  // Determine actual temperatures to read -- start by checking whether a
  // temperature range was given, in which case all temperatures in the range
  // are loaded irrespective of what temperatures actually appear in the model
  vector<int> temps_to_read;
  if (settings::temperature_range[1] > 0.0) {
    for (const auto& T : temps_available) {
      if (settings::temperature_range[0] <= T &&
          T <= settings::temperature_range[1]) {
        temps_to_read.push_back(std::round(T));
      }
    }
  }

  switch (settings::temperature_method) {
  case TemperatureMethod::NEAREST:
    // Determine actual temperatures to read
    for (const auto& T : temperature) {

      auto i_closest = xt::argmin(xt::abs(temps_available - T))[0];
      auto temp_actual = temps_available[i_closest];
      if (std::abs(temp_actual - T) < settings::temperature_tolerance) {
        if (std::find(temps_to_read.begin(), temps_to_read.end(),
              std::round(temp_actual)) == temps_to_read.end()) {
          temps_to_read.push_back(std::round(temp_actual));
        }
      } else {
        fatal_error(fmt::format(
          "Nuclear data library does not contain cross sections "
          "for {}  at or near {} K. Available temperatures "
          "are {} K. Consider making use of openmc.Settings.temperature "
          "to specify how intermediate temperatures are treated.",
          name_, std::round(T), concatenate(temps_available)));
      }
    }
    break;

  case TemperatureMethod::INTERPOLATION:
    // If temperature interpolation or multipole is selected, get a list of
    // bounding temperatures for each actual temperature present in the model
    for (const auto& T : temperature) {
      bool found = false;
      for (int j = 0; j < temps_available.size() - 1; ++j) {
        if (temps_available[j] <= T && T < temps_available[j + 1]) {
          int T_j = temps_available[j];
          int T_j1 = temps_available[j + 1];
          if (std::find(temps_to_read.begin(), temps_to_read.end(), T_j) ==
              temps_to_read.end()) {
            temps_to_read.push_back(T_j);
          }
          if (std::find(temps_to_read.begin(), temps_to_read.end(), T_j1) ==
              temps_to_read.end()) {
            temps_to_read.push_back(T_j1);
          }
          found = true;
        }
      }
      if (!found) {
        // If no pairs found, check if the desired temperature falls within
        // bounds' tolerance
        if (std::abs(T - temps_available[0]) <=
            settings::temperature_tolerance) {
          if (std::find(temps_to_read.begin(), temps_to_read.end(),
                temps_available[0]) == temps_to_read.end()) {
            temps_to_read.push_back(temps_available[0]);
          }
        } else if (std::abs(T - temps_available[n - 1]) <=
                   settings::temperature_tolerance) {
          if (std::find(temps_to_read.begin(), temps_to_read.end(),
                temps_available[n - 1]) == temps_to_read.end()) {
            temps_to_read.push_back(temps_available[n - 1]);
          }
        } else {
          fatal_error(
            fmt::format("Nuclear data library does not contain cross "
                        "sections for {} at temperatures that bound {} K.",
              name_, std::round(T)));
        }
      }
    }
  }

  // Sort temperatures to read
  std::sort(temps_to_read.begin(), temps_to_read.end());

  auto n_temperature = temps_to_read.size();
  kTs_.reserve(n_temperature);
  data_.reserve(n_temperature);

  for (auto T : temps_to_read) {
    // Get temperature as a string
    std::string temp_str = fmt::format("{}K", T);

    // Read exact temperature value
    double kT;
    read_dataset(kT_group, temp_str.data(), kT);
    kTs_.push_back(kT);

    // Open group for this temperature
    hid_t T_group = open_group(group, temp_str.data());
    data_.emplace_back(T_group);
    close_group(T_group);
  }

  close_group(kT_group);
}

void ThermalScattering::calculate_xs(double E, double sqrtkT, int* i_temp,
  double* elastic, double* inelastic, uint64_t* seed) const
{
  // Determine temperature for S(a,b) table
  double kT = sqrtkT * sqrtkT;
  int i = 0;

  auto n = kTs_.size();
  if (n > 1) {
    if (settings::temperature_method == TemperatureMethod::NEAREST) {
      while (kTs_[i + 1] < kT && i + 1 < n - 1)
        ++i;
      // Pick closer of two bounding temperatures
      if (kT - kTs_[i] > kTs_[i + 1] - kT)
        ++i;
    } else {
      // If current kT outside of the bounds of available, snap to the bound
      if (kT < kTs_.front()) {
        i = 0;
      } else if (kT > kTs_.back()) {
        i = kTs_.size() - 1;
      } else {
        // Find temperatures that bound the actual temperature
        while (kTs_[i + 1] < kT && i + 1 < n - 1)
          ++i;
        // Randomly sample between temperature i and i+1
        double f = (kT - kTs_[i]) / (kTs_[i + 1] - kTs_[i]);
        if (f > prn(seed))
          ++i;
      }
    }
  }

  // Set temperature index
  *i_temp = i;

  // Calculate cross sections for ith temperature
  data_[i].calculate_xs(E, elastic, inelastic);
}

bool ThermalScattering::has_nuclide(const char* name) const
{
  std::string nuc {name};
  return std::find(nuclides_.begin(), nuclides_.end(), nuc) != nuclides_.end();
}

//==============================================================================
// ThermalData implementation
//==============================================================================

ThermalData::ThermalData(hid_t group)
{
  // Coherent/incoherent elastic data
  if (object_exists(group, "elastic")) {
    // Read cross section data
    hid_t elastic_group = open_group(group, "elastic");

    // Read elastic cross section
    elastic_.xs = read_function(elastic_group, "xs");

    // Read angle-energy distribution
    hid_t dgroup = open_group(elastic_group, "distribution");
    std::string temp;
    read_attribute(dgroup, "type", temp);
    if (temp == "coherent_elastic") {
      auto xs = dynamic_cast<CoherentElasticXS*>(elastic_.xs.get());
      elastic_.distribution = make_unique<CoherentElasticAE>(*xs);
    } else if (temp == "incoherent_elastic") {
      elastic_.distribution = make_unique<IncoherentElasticAE>(dgroup);
    } else if (temp == "incoherent_elastic_discrete") {
      auto xs = dynamic_cast<Tabulated1D*>(elastic_.xs.get());
      elastic_.distribution =
        make_unique<IncoherentElasticAEDiscrete>(dgroup, xs->x());
    } else if (temp == "mixed_elastic") {
      // Get coherent/incoherent cross sections
      auto mixed_xs = dynamic_cast<Sum1D*>(elastic_.xs.get());
      const auto& coh_xs =
        dynamic_cast<const CoherentElasticXS*>(mixed_xs->functions(0).get());
      const auto& incoh_xs = mixed_xs->functions(1).get();

      // Create mixed elastic distribution
      elastic_.distribution =
        make_unique<MixedElasticAE>(dgroup, *coh_xs, *incoh_xs);
    }

    close_group(elastic_group);
  }

  // Inelastic data
  if (object_exists(group, "inelastic")) {
    // Read type of inelastic data
    hid_t inelastic_group = open_group(group, "inelastic");

    // Read inelastic cross section
    inelastic_.xs = read_function(inelastic_group, "xs");

    // Read angle-energy distribution
    hid_t dgroup = open_group(inelastic_group, "distribution");
    std::string temp;
    read_attribute(dgroup, "type", temp);
    if (temp == "incoherent_inelastic") {
      inelastic_.distribution = make_unique<IncoherentInelasticAE>(dgroup);
    } else if (temp == "incoherent_inelastic_discrete") {
      auto xs = dynamic_cast<Tabulated1D*>(inelastic_.xs.get());
      inelastic_.distribution =
        make_unique<IncoherentInelasticAEDiscrete>(dgroup, xs->x());
    }

    close_group(inelastic_group);
  }
}

void ThermalData::calculate_xs(
  double E, double* elastic, double* inelastic) const
{
  // Calculate thermal elastic scattering cross section
  if (elastic_.xs) {
    *elastic = (*elastic_.xs)(E);
  } else {
    *elastic = 0.0;
  }

  // Calculate thermal inelastic scattering cross section
  *inelastic = (*inelastic_.xs)(E);
}

void ThermalData::sample(const NuclideMicroXS& micro_xs, double E,
  double* E_out, double* mu, uint64_t* seed)
{
  // Determine whether inelastic or elastic scattering will occur
  if (prn(seed) < micro_xs.thermal_elastic / micro_xs.thermal) {
    elastic_.distribution->sample(E, *E_out, *mu, seed);
  } else {
    inelastic_.distribution->sample(E, *E_out, *mu, seed);
  }

  // Because of floating-point roundoff, it may be possible for mu to be
  // outside of the range [-1,1). In these cases, we just set mu to exactly
  // -1 or 1
  if (std::abs(*mu) > 1.0)
    *mu = std::copysign(1.0, *mu);
}

double ThermalData::sample_energy_and_pdf(const NuclideMicroXS& micro_xs,
  double E_in, double mu, double& E_out, uint64_t* seed) const
{
  AngleEnergy* angleEnergyPtr;

  if (prn(seed) < micro_xs.thermal_elastic / micro_xs.thermal) {
    angleEnergyPtr = elastic_.distribution.get();
  } else {
    angleEnergyPtr = inelastic_.distribution.get();
  }

  return angleEnergyPtr->sample_energy_and_pdf(E_in, mu, E_out, seed);
}

void free_memory_thermal()
{
  data::thermal_scatt.clear();
  data::thermal_scatt_map.clear();
}

} // namespace openmc

1	#include "openmc/thermal.h"
2
3	#include <algorithm> // for sort, move, min, max, find
4	#include <cmath> // for round, sqrt, abs
5
6	#include "xtensor/xarray.hpp"
7	#include "xtensor/xbuilder.hpp"
8	#include "xtensor/xmath.hpp"
9	#include "xtensor/xsort.hpp"
10	#include "xtensor/xtensor.hpp"
11	#include "xtensor/xview.hpp"
12	#include <fmt/core.h>
13
14	#include "openmc/constants.h"
15	#include "openmc/endf.h"
16	#include "openmc/error.h"
17	#include "openmc/random_lcg.h"
18	#include "openmc/search.h"
19	#include "openmc/secondary_correlated.h"
20	#include "openmc/secondary_thermal.h"
21	#include "openmc/settings.h"
22	#include "openmc/string_utils.h"
23
24	namespace openmc {
25
26	//==============================================================================
27	// Global variables
28	//==============================================================================
29
30	namespace data {
31	std::unordered_map<std::string, int> thermal_scatt_map;
32	vector<unique_ptr<ThermalScattering>> thermal_scatt;
33	} // namespace data
34
35	//==============================================================================
36	// ThermalScattering implementation
37	//==============================================================================
38
39	ThermalScattering::ThermalScattering(	1,245✔
40	hid_t group, const vector<double>& temperature)	1,245✔
41	{
42	// Get name of table from group
43	name_ = object_name(group);	1,245✔
44
45	// Get rid of leading '/'
46	name_ = name_.substr(1);	1,245✔
47
48	read_attribute(group, "atomic_weight_ratio", awr_);	1,245✔
49	read_attribute(group, "energy_max", energy_max_);	1,245✔
50	read_attribute(group, "nuclides", nuclides_);	1,245✔
51
52	// Read temperatures
53	hid_t kT_group = open_group(group, "kTs");	1,245✔
54
55	// Determine temperatures available
56	auto dset_names = dataset_names(kT_group);	1,245✔
57	auto n = dset_names.size();	1,245✔
58	auto temps_available = xt::empty<double>({n});	1,245✔
59	for (int i = 0; i < dset_names.size(); ++i) {	2,490✔
60	// Read temperature value
61	double T;
62	read_dataset(kT_group, dset_names[i].data(), T);	1,245✔
63	temps_available[i] = std::round(T / K_BOLTZMANN);	1,245✔
64	}
65	std::sort(temps_available.begin(), temps_available.end());	1,245✔
66
67	// Determine actual temperatures to read -- start by checking whether a
68	// temperature range was given, in which case all temperatures in the range
69	// are loaded irrespective of what temperatures actually appear in the model
70	vector<int> temps_to_read;	1,245✔
71	if (settings::temperature_range[1] > 0.0) {	1,245!
72	for (const auto& T : temps_available) {	×
73	if (settings::temperature_range[0] <= T &&	×
74	T <= settings::temperature_range[1]) {	×
75	temps_to_read.push_back(std::round(T));	×
76	}
77	}
78	}
79
80	switch (settings::temperature_method) {	1,245!
81	case TemperatureMethod::NEAREST:	1,223✔
82	// Determine actual temperatures to read
83	for (const auto& T : temperature) {	2,446✔
84
85	auto i_closest = xt::argmin(xt::abs(temps_available - T))[0];	1,223✔
86	auto temp_actual = temps_available[i_closest];	1,223✔
87	if (std::abs(temp_actual - T) < settings::temperature_tolerance) {	1,223!
88	if (std::find(temps_to_read.begin(), temps_to_read.end(),	1,223✔
89	std::round(temp_actual)) == temps_to_read.end()) {	2,446!
90	temps_to_read.push_back(std::round(temp_actual));	1,223✔
91	}
92	} else {
93	fatal_error(fmt::format(	×
94	"Nuclear data library does not contain cross sections "
95	"for {} at or near {} K. Available temperatures "
96	"are {} K. Consider making use of openmc.Settings.temperature "
97	"to specify how intermediate temperatures are treated.",
98	name_, std::round(T), concatenate(temps_available)));	×
99	}
100	}
101	break;	1,223✔
102
103	case TemperatureMethod::INTERPOLATION:	22✔
104	// If temperature interpolation or multipole is selected, get a list of
105	// bounding temperatures for each actual temperature present in the model
106	for (const auto& T : temperature) {	44✔
107	bool found = false;	22✔
108	for (int j = 0; j < temps_available.size() - 1; ++j) {	22!
109	if (temps_available[j] <= T && T < temps_available[j + 1]) {	×
110	int T_j = temps_available[j];	×
111	int T_j1 = temps_available[j + 1];	×
112	if (std::find(temps_to_read.begin(), temps_to_read.end(), T_j) ==	×
113	temps_to_read.end()) {	×
114	temps_to_read.push_back(T_j);	×
115	}
116	if (std::find(temps_to_read.begin(), temps_to_read.end(), T_j1) ==	×
117	temps_to_read.end()) {	×
118	temps_to_read.push_back(T_j1);	×
119	}
120	found = true;	×
121	}
122	}
123	if (!found) {	22!
124	// If no pairs found, check if the desired temperature falls within
125	// bounds' tolerance
126	if (std::abs(T - temps_available[0]) <=	22!
127	settings::temperature_tolerance) {
128	if (std::find(temps_to_read.begin(), temps_to_read.end(),	22✔
129	temps_available[0]) == temps_to_read.end()) {	44!
130	temps_to_read.push_back(temps_available[0]);	22✔
131	}
132	} else if (std::abs(T - temps_available[n - 1]) <=	×
133	settings::temperature_tolerance) {
134	if (std::find(temps_to_read.begin(), temps_to_read.end(),	×
135	temps_available[n - 1]) == temps_to_read.end()) {	×
136	temps_to_read.push_back(temps_available[n - 1]);	×
137	}
138	} else {
139	fatal_error(	×
140	fmt::format("Nuclear data library does not contain cross "	×
141	"sections for {} at temperatures that bound {} K.",
142	name_, std::round(T)));	×
143	}
144	}
145	}
146	}
147
148	// Sort temperatures to read
149	std::sort(temps_to_read.begin(), temps_to_read.end());	1,245✔
150
151	auto n_temperature = temps_to_read.size();	1,245✔
152	kTs_.reserve(n_temperature);	1,245✔
153	data_.reserve(n_temperature);	1,245✔
154
155	for (auto T : temps_to_read) {	2,490✔
156	// Get temperature as a string
157	std::string temp_str = fmt::format("{}K", T);	1,036✔
158
159	// Read exact temperature value
160	double kT;
161	read_dataset(kT_group, temp_str.data(), kT);	1,245✔
162	kTs_.push_back(kT);	1,245✔
163
164	// Open group for this temperature
165	hid_t T_group = open_group(group, temp_str.data());	1,245✔
166	data_.emplace_back(T_group);	1,245✔
167	close_group(T_group);	1,245✔
168	}	1,245✔
169
170	close_group(kT_group);	1,245✔
171	}	1,245✔
172
173	void ThermalScattering::calculate_xs(double E, double sqrtkT, int* i_temp,	93,588,335✔
174	double* elastic, double* inelastic, uint64_t* seed) const
175	{
176	// Determine temperature for S(a,b) table
177	double kT = sqrtkT * sqrtkT;	93,588,335✔
178	int i = 0;	93,588,335✔
179
180	auto n = kTs_.size();	93,588,335✔
181	if (n > 1) {	93,588,335!
182	if (settings::temperature_method == TemperatureMethod::NEAREST) {	×
183	while (kTs_[i + 1] < kT && i + 1 < n - 1)	×
184	++i;	×
185	// Pick closer of two bounding temperatures
186	if (kT - kTs_[i] > kTs_[i + 1] - kT)	×
187	++i;	×
188	} else {
189	// If current kT outside of the bounds of available, snap to the bound
190	if (kT < kTs_.front()) {	×
191	i = 0;	×
192	} else if (kT > kTs_.back()) {	×
193	i = kTs_.size() - 1;	×
194	} else {
195	// Find temperatures that bound the actual temperature
196	while (kTs_[i + 1] < kT && i + 1 < n - 1)	×
197	++i;	×
198	// Randomly sample between temperature i and i+1
199	double f = (kT - kTs_[i]) / (kTs_[i + 1] - kTs_[i]);	×
200	if (f > prn(seed))	×
201	++i;	×
202	}
203	}
204	}
205
206	// Set temperature index
207	*i_temp = i;	93,588,335✔
208
209	// Calculate cross sections for ith temperature
210	data_[i].calculate_xs(E, elastic, inelastic);	93,588,335✔
211	}	93,588,335✔
212
213	bool ThermalScattering::has_nuclide(const char* name) const	×
214	{
215	std::string nuc {name};	×
216	return std::find(nuclides_.begin(), nuclides_.end(), nuc) != nuclides_.end();	×
217	}	×
218
219	//==============================================================================
220	// ThermalData implementation
221	//==============================================================================
222
223	ThermalData::ThermalData(hid_t group)	1,245✔
224	{
225	// Coherent/incoherent elastic data
226	if (object_exists(group, "elastic")) {	1,245✔
227	// Read cross section data
228	hid_t elastic_group = open_group(group, "elastic");	140✔
229
230	// Read elastic cross section
231	elastic_.xs = read_function(elastic_group, "xs");	140✔
232
233	// Read angle-energy distribution
234	hid_t dgroup = open_group(elastic_group, "distribution");	140✔
235	std::string temp;	140✔
236	read_attribute(dgroup, "type", temp);	140✔
237	if (temp == "coherent_elastic") {	140✔
238	auto xs = dynamic_cast<CoherentElasticXS*>(elastic_.xs.get());	96!
239	elastic_.distribution = make_unique<CoherentElasticAE>(*xs);	96✔
240	} else if (temp == "incoherent_elastic") {	44!
241	elastic_.distribution = make_unique<IncoherentElasticAE>(dgroup);	×
242	} else if (temp == "incoherent_elastic_discrete") {	44!
243	auto xs = dynamic_cast<Tabulated1D*>(elastic_.xs.get());	×
244	elastic_.distribution =
245	make_unique<IncoherentElasticAEDiscrete>(dgroup, xs->x());	×
246	} else if (temp == "mixed_elastic") {	44!
247	// Get coherent/incoherent cross sections
248	auto mixed_xs = dynamic_cast<Sum1D*>(elastic_.xs.get());	44!
249	const auto& coh_xs =
250	dynamic_cast<const CoherentElasticXS*>(mixed_xs->functions(0).get());	44!
251	const auto& incoh_xs = mixed_xs->functions(1).get();	44✔
252
253	// Create mixed elastic distribution
254	elastic_.distribution =
255	make_unique<MixedElasticAE>(dgroup, coh_xs, incoh_xs);	44✔
256	}
257
258	close_group(elastic_group);	140✔
259	}	140✔
260
261	// Inelastic data
262	if (object_exists(group, "inelastic")) {	1,245!
263	// Read type of inelastic data
264	hid_t inelastic_group = open_group(group, "inelastic");	1,245✔
265
266	// Read inelastic cross section
267	inelastic_.xs = read_function(inelastic_group, "xs");	1,245✔
268
269	// Read angle-energy distribution
270	hid_t dgroup = open_group(inelastic_group, "distribution");	1,245✔
271	std::string temp;	1,245✔
272	read_attribute(dgroup, "type", temp);	1,245✔
273	if (temp == "incoherent_inelastic") {	1,245✔
274	inelastic_.distribution = make_unique<IncoherentInelasticAE>(dgroup);	44✔
275	} else if (temp == "incoherent_inelastic_discrete") {	1,201!
276	auto xs = dynamic_cast<Tabulated1D*>(inelastic_.xs.get());	1,201!
277	inelastic_.distribution =
278	make_unique<IncoherentInelasticAEDiscrete>(dgroup, xs->x());	1,201✔
279	}
280
281	close_group(inelastic_group);	1,245✔
282	}	1,245✔
283	}	1,245✔
284
285	void ThermalData::calculate_xs(	93,588,335✔
286	double E, double* elastic, double* inelastic) const
287	{
288	// Calculate thermal elastic scattering cross section
289	if (elastic_.xs) {	93,588,335✔
290	elastic = (elastic_.xs)(E);	4,893,471✔
291	} else {
292	*elastic = 0.0;	88,694,864✔
293	}
294
295	// Calculate thermal inelastic scattering cross section
296	inelastic = (inelastic_.xs)(E);	93,588,335✔
297	}	93,588,335✔
298
299	void ThermalData::sample(const NuclideMicroXS& micro_xs, double E,	77,147,777✔
300	double* E_out, double* mu, uint64_t* seed)
301	{
302	// Determine whether inelastic or elastic scattering will occur
303	if (prn(seed) < micro_xs.thermal_elastic / micro_xs.thermal) {	77,147,777✔
304	elastic_.distribution->sample(E, E_out, mu, seed);	179,355✔
305	} else {
306	inelastic_.distribution->sample(E, E_out, mu, seed);	76,968,422✔
307	}
308
309	// Because of floating-point roundoff, it may be possible for mu to be
310	// outside of the range [-1,1). In these cases, we just set mu to exactly
311	// -1 or 1
312	if (std::abs(*mu) > 1.0)	77,147,777!
313	mu = std::copysign(1.0, mu);	×
314	}	77,147,777✔
315
NEW 316	double ThermalData::sample_energy_and_pdf(const NuclideMicroXS& micro_xs,	×
317	double E_in, double mu, double& E_out, uint64_t* seed) const
318	{
319	AngleEnergy* angleEnergyPtr;
320
NEW 321	if (prn(seed) < micro_xs.thermal_elastic / micro_xs.thermal) {	×
NEW 322	angleEnergyPtr = elastic_.distribution.get();	×
323	} else {
NEW 324	angleEnergyPtr = inelastic_.distribution.get();	×
325	}
326
NEW 327	return angleEnergyPtr->sample_energy_and_pdf(E_in, mu, E_out, seed);	×
328	}
329
330	void free_memory_thermal()	8,209✔
331	{
332	data::thermal_scatt.clear();	8,209✔
333	data::thermal_scatt_map.clear();	8,209✔
334	}	8,209✔
335
336	} // namespace openmc

openmc-dev / openmc / 19041149218

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