25507206839

Committed 07 May 2026 04:00PM UTC coverage: 80.951% (-0.4%) from 81.374%

Build # 25507206839

Build Type

Pull #3757

github

Committed by

web-flow

Commit Message

Merge 6236a6a96 into e542b2f03

Pull Request Pull Request #3757: Testing point detectors

Coverage Stats

17723 of 25786 branches covered (68.73%)

Branch coverage included in aggregate %.

44 of 385 new or added lines in 25 files covered. (11.43%)

80 existing lines in 2 files now uncovered.

58571 of 68461 relevant lines covered (85.55%)

47134468.44 hits per line

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

62.14

/src/thermal.cpp

#include "openmc/thermal.h"

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

#include "openmc/tensor.h"
#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 = tensor::Tensor<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 = tensor::abs(temps_available - T).argmin();
      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);
}

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

void ThermalData::sample(const NuclideMicroXS& micro_xs, double E,
  double* E_out, double* mu, uint64_t* seed) const
{
  sample_dist(micro_xs, E, seed).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, bool is_com,
  double awr) const
{
  return sample_dist(micro_xs, E_in, seed)
    .sample_energy_and_pdf(E_in, mu, E_out, seed, is_com, awr);
}

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

openmc-dev / openmc / 25507206839

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