23910205296

Committed 02 Apr 2026 04:14PM UTC coverage: 81.224% (-0.3%) from 81.567%

Build # 23910205296

Build Type

Pull #3766

github

Committed by

web-flow

Commit Message

Merge 264dcb1ef into 8223099ed

Pull Request Pull Request #3766: Approximate multigroup velocity

Run Details

17579 of 25426 branches covered (69.14%)

Branch coverage included in aggregate %.

24 of 25 new or added lines in 4 files covered. (96.0%)

710 existing lines in 29 files now uncovered.

58015 of 67642 relevant lines covered (85.77%)

31291841.44 hits per line

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

80.0

/src/distribution_angle.cpp

#include "openmc/distribution_angle.h"

#include <cmath> // for abs, copysign

#include "openmc/tensor.h"

#include "openmc/endf.h"
#include "openmc/hdf5_interface.h"
#include "openmc/math_functions.h"
#include "openmc/random_lcg.h"
#include "openmc/search.h"
#include "openmc/vector.h" // for vector

namespace openmc {

//==============================================================================
// AngleDistribution implementation
//==============================================================================

AngleDistribution::AngleDistribution(hid_t group)
{
  // Get incoming energies
  read_dataset(group, "energy", energy_);
  int n_energy = energy_.size();

  // Get outgoing energy distribution data
  vector<int> offsets;
  vector<int> interp;
  hid_t dset = open_dataset(group, "mu");
  read_attribute(dset, "offsets", offsets);
  read_attribute(dset, "interpolation", interp);
  tensor::Tensor<double> temp;
  read_dataset(dset, temp);
  close_dataset(dset);

  for (int i = 0; i < n_energy; ++i) {
    // Determine number of outgoing energies
    int j = offsets[i];
    int n;
    if (i < n_energy - 1) {
      n = offsets[i + 1] - j;
    } else {
      n = temp.shape(1) - j;
    }

    // Create and initialize tabular distribution
    tensor::View<double> xs = temp.slice(0, tensor::range(j, j + n));
    tensor::View<double> ps = temp.slice(1, tensor::range(j, j + n));
    tensor::View<double> cs = temp.slice(2, tensor::range(j, j + n));
    vector<double> x {xs.begin(), xs.end()};
    vector<double> p {ps.begin(), ps.end()};
    vector<double> c {cs.begin(), cs.end()};

    // To get answers that match ACE data, for now we still use the tabulated
    // CDF values that were passed through to the HDF5 library. At a later
    // time, we can remove the CDF values from the HDF5 library and
    // reconstruct them using the PDF
    Tabular* mudist =
      new Tabular {x.data(), p.data(), n, int2interp(interp[i]), c.data()};

    distribution_.emplace_back(mudist);
  }
}

double AngleDistribution::sample(double E, uint64_t* seed) const
{
  // Find energy bin and calculate interpolation factor
  int i;
  double r;
  get_energy_index(energy_, E, i, r);

  // Sample between the ith and (i+1)th bin
  if (r > prn(seed))
    ++i;

  // Sample i-th distribution
  double mu = distribution_[i]->sample(seed).first;

  // Make sure mu is in range [-1,1] and return
  if (std::abs(mu) > 1.0)
    mu = std::copysign(1.0, mu);
  return mu;
}

double AngleDistribution::evaluate(double E, double mu) const
{
  // Find energy bin and calculate interpolation factor
  int i;
  double r;
  get_energy_index(energy_, E, i, r);

  double pdf = 0.0;
  if (r > 0.0)
    pdf += r * distribution_[i + 1]->evaluate(mu);
  if (r < 1.0)
    pdf += (1.0 - r) * distribution_[i]->evaluate(mu);
  return pdf;
}

} // namespace openmc

1	#include "openmc/distribution_angle.h"
2
3	#include <cmath> // for abs, copysign
4
5	#include "openmc/tensor.h"
6
7	#include "openmc/endf.h"
8	#include "openmc/hdf5_interface.h"
9	#include "openmc/math_functions.h"
10	#include "openmc/random_lcg.h"
11	#include "openmc/search.h"
12	#include "openmc/vector.h" // for vector
13
14	namespace openmc {
15
16	//==============================================================================
17	// AngleDistribution implementation
18	//==============================================================================
19
20	AngleDistribution::AngleDistribution(hid_t group)	1,711,985✔
21	{
22	// Get incoming energies
23	read_dataset(group, "energy", energy_);	1,711,985✔
24	int n_energy = energy_.size();	1,711,985✔
25
26	// Get outgoing energy distribution data
27	vector<int> offsets;	1,711,985✔
28	vector<int> interp;	1,711,985✔
29	hid_t dset = open_dataset(group, "mu");	1,711,985✔
30	read_attribute(dset, "offsets", offsets);	1,711,985✔
31	read_attribute(dset, "interpolation", interp);	1,711,985✔
32	tensor::Tensor<double> temp;	1,711,985✔
33	read_dataset(dset, temp);	1,711,985✔
34	close_dataset(dset);	1,711,985✔
35
36	for (int i = 0; i < n_energy; ++i) {	16,532,356✔
37	// Determine number of outgoing energies
38	int j = offsets[i];	14,820,371✔
39	int n;	14,820,371✔
40	if (i < n_energy - 1) {	14,820,371✔
41	n = offsets[i + 1] - j;	13,108,386✔
42	} else {
43	n = temp.shape(1) - j;	3,423,970!
44	}
45
46	// Create and initialize tabular distribution
47	tensor::View<double> xs = temp.slice(0, tensor::range(j, j + n));	14,820,371✔
48	tensor::View<double> ps = temp.slice(1, tensor::range(j, j + n));	14,820,371✔
49	tensor::View<double> cs = temp.slice(2, tensor::range(j, j + n));	14,820,371✔
50	vector<double> x {xs.begin(), xs.end()};	14,820,371✔
51	vector<double> p {ps.begin(), ps.end()};	14,820,371✔
52	vector<double> c {cs.begin(), cs.end()};	14,820,371✔
53
54	// To get answers that match ACE data, for now we still use the tabulated
55	// CDF values that were passed through to the HDF5 library. At a later
56	// time, we can remove the CDF values from the HDF5 library and
57	// reconstruct them using the PDF
58	Tabular* mudist =	14,820,371✔
59	new Tabular {x.data(), p.data(), n, int2interp(interp[i]), c.data()};	14,820,371✔
60
61	distribution_.emplace_back(mudist);	14,820,371✔
62	}	59,281,484✔
63	}	1,711,985✔
64
65	double AngleDistribution::sample(double E, uint64_t* seed) const	464,208,621✔
66	{
67	// Find energy bin and calculate interpolation factor
68	int i;	464,208,621✔
69	double r;	464,208,621✔
70	get_energy_index(energy_, E, i, r);	464,208,621✔
71
72	// Sample between the ith and (i+1)th bin
73	if (r > prn(seed))	464,208,621✔
74	++i;	191,468,086✔
75
76	// Sample i-th distribution
77	double mu = distribution_[i]->sample(seed).first;	464,208,621✔
78
79	// Make sure mu is in range [-1,1] and return
80	if (std::abs(mu) > 1.0)	464,208,621!
81	mu = std::copysign(1.0, mu);	×
82	return mu;	464,208,621✔
83	}
84
UNCOV 85	double AngleDistribution::evaluate(double E, double mu) const	×
86	{
87	// Find energy bin and calculate interpolation factor
UNCOV 88	int i;	×
UNCOV 89	double r;	×
UNCOV 90	get_energy_index(energy_, E, i, r);	×
91
UNCOV 92	double pdf = 0.0;	×
UNCOV 93	if (r > 0.0)	×
UNCOV 94	pdf += r * distribution_[i + 1]->evaluate(mu);	×
UNCOV 95	if (r < 1.0)	×
UNCOV 96	pdf += (1.0 - r) * distribution_[i]->evaluate(mu);	×
UNCOV 97	return pdf;	×
98	}
99
100	} // namespace openmc

openmc-dev / openmc / 23910205296

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