22313563243

Committed 23 Feb 2026 03:48PM UTC coverage: 81.668% (-0.02%) from 81.688%

Build # 22313563243

Build Type

Pull #3817

github

Committed by

web-flow

Commit Message

Merge 57700522b into 83a30f686

Pull Request Pull Request #3817: Fix MeshFilter.get_pandas_dataframe to handle all mesh types

Run Details

16814 of 23454 branches covered (71.69%)

Branch coverage included in aggregate %.

23 of 25 new or added lines in 4 files covered. (92.0%)

744 existing lines in 15 files now uncovered.

56855 of 66751 relevant lines covered (85.17%)

43165405.27 hits per line

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

59.45

/src/distribution_spatial.cpp

#include "openmc/distribution_spatial.h"

#include "openmc/error.h"
#include "openmc/mesh.h"
#include "openmc/random_lcg.h"
#include "openmc/search.h"
#include "openmc/xml_interface.h"

namespace openmc {

//==============================================================================
// SpatialDistribution implementation
//==============================================================================

unique_ptr<SpatialDistribution> SpatialDistribution::create(pugi::xml_node node)
{
  // Check for type of spatial distribution and read
  std::string type;
  if (check_for_node(node, "type"))
    type = get_node_value(node, "type", true, true);
  if (type == "cartesian") {
    return UPtrSpace {new CartesianIndependent(node)};
  } else if (type == "cylindrical") {
    return UPtrSpace {new CylindricalIndependent(node)};
  } else if (type == "spherical") {
    return UPtrSpace {new SphericalIndependent(node)};
  } else if (type == "mesh") {
    return UPtrSpace {new MeshSpatial(node)};
  } else if (type == "cloud") {
    return UPtrSpace {new PointCloud(node)};
  } else if (type == "box") {
    return UPtrSpace {new SpatialBox(node)};
  } else if (type == "fission") {
    return UPtrSpace {new SpatialBox(node, true)};
  } else if (type == "point") {
    return UPtrSpace {new SpatialPoint(node)};
  } else {
    fatal_error(fmt::format(
      "Invalid spatial distribution for external source: {}", type));
  }
}

//==============================================================================
// CartesianIndependent implementation
//==============================================================================

CartesianIndependent::CartesianIndependent(pugi::xml_node node)
{
  // Read distribution for x coordinate
  if (check_for_node(node, "x")) {
    pugi::xml_node node_dist = node.child("x");
    x_ = distribution_from_xml(node_dist);
  } else {
    // If no distribution was specified, default to a single point at x=0
    double x[] {0.0};
    double p[] {1.0};
    x_ = UPtrDist {new Discrete {x, p, 1}};
  }

  // Read distribution for y coordinate
  if (check_for_node(node, "y")) {
    pugi::xml_node node_dist = node.child("y");
    y_ = distribution_from_xml(node_dist);
  } else {
    // If no distribution was specified, default to a single point at y=0
    double x[] {0.0};
    double p[] {1.0};
    y_ = UPtrDist {new Discrete {x, p, 1}};
  }

  // Read distribution for z coordinate
  if (check_for_node(node, "z")) {
    pugi::xml_node node_dist = node.child("z");
    z_ = distribution_from_xml(node_dist);
  } else {
    // If no distribution was specified, default to a single point at z=0
    double x[] {0.0};
    double p[] {1.0};
    z_ = UPtrDist {new Discrete {x, p, 1}};
  }
}

std::pair<Position, double> CartesianIndependent::sample(uint64_t* seed) const
{
  auto [x_val, x_wgt] = x_->sample(seed);
  auto [y_val, y_wgt] = y_->sample(seed);
  auto [z_val, z_wgt] = z_->sample(seed);
  Position xi {x_val, y_val, z_val};
  return {xi, x_wgt * y_wgt * z_wgt};
}

//==============================================================================
// CylindricalIndependent implementation
//==============================================================================

CylindricalIndependent::CylindricalIndependent(pugi::xml_node node)
{
  // Read distribution for r-coordinate
  if (check_for_node(node, "r")) {
    pugi::xml_node node_dist = node.child("r");
    r_ = distribution_from_xml(node_dist);
  } else {
    // If no distribution was specified, default to a single point at r=0
    double x[] {0.0};
    double p[] {1.0};
    r_ = make_unique<Discrete>(x, p, 1);
  }

  // Read distribution for phi-coordinate
  if (check_for_node(node, "phi")) {
    pugi::xml_node node_dist = node.child("phi");
    phi_ = distribution_from_xml(node_dist);
  } else {
    // If no distribution was specified, default to a single point at phi=0
    double x[] {0.0};
    double p[] {1.0};
    phi_ = make_unique<Discrete>(x, p, 1);
  }

  // Read distribution for z-coordinate
  if (check_for_node(node, "z")) {
    pugi::xml_node node_dist = node.child("z");
    z_ = distribution_from_xml(node_dist);
  } else {
    // If no distribution was specified, default to a single point at z=0
    double x[] {0.0};
    double p[] {1.0};
    z_ = make_unique<Discrete>(x, p, 1);
  }

  // Read cylinder center coordinates
  if (check_for_node(node, "origin")) {
    auto origin = get_node_array<double>(node, "origin");
    if (origin.size() == 3) {
      origin_ = origin;
    } else {
      fatal_error(
        "Origin for cylindrical source distribution must be length 3");
    }
  } else {
    // If no coordinates were specified, default to (0, 0, 0)
    origin_ = {0.0, 0.0, 0.0};
  }

  // Read cylinder z_dir
  if (check_for_node(node, "z_dir")) {
    auto z_dir = get_node_array<double>(node, "z_dir");
    if (z_dir.size() == 3) {
      z_dir_ = z_dir;
      z_dir_ /= z_dir_.norm();
    } else {
      fatal_error("z_dir for cylindrical source distribution must be length 3");
    }
  } else {
    // If no z_dir was specified, default to (0, 0, 1)
    z_dir_ = {0.0, 0.0, 1.0};
  }

  // Read cylinder r_dir
  if (check_for_node(node, "r_dir")) {
    auto r_dir = get_node_array<double>(node, "r_dir");
    if (r_dir.size() == 3) {
      r_dir_ = r_dir;
      r_dir_ /= r_dir_.norm();
    } else {
      fatal_error("r_dir for cylindrical source distribution must be length 3");
    }
  } else {
    // If no r_dir was specified, default to (1, 0, 0)
    r_dir_ = {1.0, 0.0, 0.0};
  }

  if (r_dir_.dot(z_dir_) > 1e-12)
    fatal_error("r_dir must be perpendicular to z_dir");

  auto phi_dir = z_dir_.cross(r_dir_);
  phi_dir /= phi_dir.norm();
  phi_dir_ = phi_dir;
}

std::pair<Position, double> CylindricalIndependent::sample(uint64_t* seed) const
{
  auto [r, r_wgt] = r_->sample(seed);
  auto [phi, phi_wgt] = phi_->sample(seed);
  auto [z, z_wgt] = z_->sample(seed);
  Position xi =
    r * (cos(phi) * r_dir_ + sin(phi) * phi_dir_) + z * z_dir_ + origin_;
  return {xi, r_wgt * phi_wgt * z_wgt};
}

//==============================================================================
// SphericalIndependent implementation
//==============================================================================

SphericalIndependent::SphericalIndependent(pugi::xml_node node)
{
  // Read distribution for r-coordinate
  if (check_for_node(node, "r")) {
    pugi::xml_node node_dist = node.child("r");
    r_ = distribution_from_xml(node_dist);
  } else {
    // If no distribution was specified, default to a single point at r=0
    double x[] {0.0};
    double p[] {1.0};
    r_ = make_unique<Discrete>(x, p, 1);
  }

  // Read distribution for cos_theta-coordinate
  if (check_for_node(node, "cos_theta")) {
    pugi::xml_node node_dist = node.child("cos_theta");
    cos_theta_ = distribution_from_xml(node_dist);
  } else {
    // If no distribution was specified, default to a single point at
    // cos_theta=0
    double x[] {0.0};
    double p[] {1.0};
    cos_theta_ = make_unique<Discrete>(x, p, 1);
  }

  // Read distribution for phi-coordinate
  if (check_for_node(node, "phi")) {
    pugi::xml_node node_dist = node.child("phi");
    phi_ = distribution_from_xml(node_dist);
  } else {
    // If no distribution was specified, default to a single point at phi=0
    double x[] {0.0};
    double p[] {1.0};
    phi_ = make_unique<Discrete>(x, p, 1);
  }

  // Read sphere center coordinates
  if (check_for_node(node, "origin")) {
    auto origin = get_node_array<double>(node, "origin");
    if (origin.size() == 3) {
      origin_ = origin;
    } else {
      fatal_error("Origin for spherical source distribution must be length 3");
    }
  } else {
    // If no coordinates were specified, default to (0, 0, 0)
    origin_ = {0.0, 0.0, 0.0};
  }
}

std::pair<Position, double> SphericalIndependent::sample(uint64_t* seed) const
{
  auto [r, r_wgt] = r_->sample(seed);
  auto [cos_theta, cos_theta_wgt] = cos_theta_->sample(seed);
  auto [phi, phi_wgt] = phi_->sample(seed);
  // sin(theta) by sin**2 + cos**2 = 1
  double x = r * std::sqrt(1 - cos_theta * cos_theta) * cos(phi) + origin_.x;
  double y = r * std::sqrt(1 - cos_theta * cos_theta) * sin(phi) + origin_.y;
  double z = r * cos_theta + origin_.z;
  Position xi {x, y, z};
  return {xi, r_wgt * cos_theta_wgt * phi_wgt};
}

//==============================================================================
// MeshSpatial implementation
//==============================================================================

MeshSpatial::MeshSpatial(pugi::xml_node node)
{

  if (get_node_value(node, "type", true, true) != "mesh") {
    fatal_error(fmt::format(
      "Incorrect spatial type '{}' for a MeshSpatial distribution"));
  }

  // No in-tet distributions implemented, could include distributions for the
  // barycentric coords Read in unstructured mesh from mesh_id value
  int32_t mesh_id = std::stoi(get_node_value(node, "mesh_id"));
  // Get pointer to spatial distribution
  mesh_idx_ = model::mesh_map.at(mesh_id);

  const auto mesh_ptr = model::meshes.at(mesh_idx_).get();

  check_element_types();

  size_t n_bins = this->n_sources();
  std::vector<double> strengths(n_bins, 1.0);

  // Create cdfs for sampling for an element over a mesh
  // Volume scheme is weighted by the volume of each tet
  // File scheme is weighted by an array given in the xml file
  if (check_for_node(node, "strengths")) {
    strengths = get_node_array<double>(node, "strengths");
    if (strengths.size() != n_bins) {
      fatal_error(
        fmt::format("Number of entries in the source strengths array {} does "
                    "not match the number of entities in mesh {} ({}).",
          strengths.size(), mesh_id, n_bins));
    }
  }

  if (get_node_value_bool(node, "volume_normalized")) {
    for (int i = 0; i < n_bins; i++) {
      strengths[i] *= this->mesh()->volume(i);
    }
  }

  elem_idx_dist_.assign(strengths);

  if (check_for_node(node, "bias")) {
    pugi::xml_node bias_node = node.child("bias");

    if (check_for_node(bias_node, "strengths")) {
      std::vector<double> bias_strengths(n_bins, 1.0);
      bias_strengths = get_node_array<double>(node, "strengths");

      if (bias_strengths.size() != n_bins) {
        fatal_error(
          fmt::format("Number of entries in the bias strengths array {} does "
                      "not match the number of entities in mesh {} ({}).",
            bias_strengths.size(), mesh_id, n_bins));
      }

      if (get_node_value_bool(node, "volume_normalized")) {
        for (int i = 0; i < n_bins; i++) {
          bias_strengths[i] *= this->mesh()->volume(i);
        }
      }

      // Compute importance weights
      weight_ = compute_importance_weights(strengths, bias_strengths);

      // Re-initialize DiscreteIndex with bias strengths for sampling
      elem_idx_dist_.assign(bias_strengths);
    } else {
      fatal_error(fmt::format(
        "Bias node for mesh {} found without strengths array.", mesh_id));
    }
  }
}

MeshSpatial::MeshSpatial(int32_t mesh_idx, span<const double> strengths)
  : mesh_idx_(mesh_idx)
{
  check_element_types();
  elem_idx_dist_.assign(strengths);
}

void MeshSpatial::check_element_types() const
{
  const auto umesh_ptr = dynamic_cast<const UnstructuredMesh*>(this->mesh());
  if (umesh_ptr) {
    // ensure that the unstructured mesh contains only linear tets
    for (int bin = 0; bin < umesh_ptr->n_bins(); bin++) {
      if (umesh_ptr->element_type(bin) != ElementType::LINEAR_TET) {
        fatal_error(
          "Mesh specified for source must contain only linear tetrahedra.");
      }
    }
  }
}

int32_t MeshSpatial::sample_element_index(uint64_t* seed) const
{
  return elem_idx_dist_.sample(seed);
}

std::pair<int32_t, Position> MeshSpatial::sample_mesh(uint64_t* seed) const
{
  // Sample the CDF defined in initialization above
  int32_t elem_idx = this->sample_element_index(seed);
  return {elem_idx, mesh()->sample_element(elem_idx, seed)};
}

std::pair<Position, double> MeshSpatial::sample(uint64_t* seed) const
{
  auto [elem_idx, u] = this->sample_mesh(seed);
  double wgt = weight_.empty() ? 1.0 : weight_[elem_idx];
  return {u, wgt};
}

//==============================================================================
// PointCloud implementation
//==============================================================================

PointCloud::PointCloud(pugi::xml_node node)
{
  if (check_for_node(node, "coords")) {
    point_cloud_ = get_node_position_array(node, "coords");
  } else {
    fatal_error("No coordinates were provided for the PointCloud "
                "spatial distribution");
  }

  std::vector<double> strengths;

  if (check_for_node(node, "strengths"))
    strengths = get_node_array<double>(node, "strengths");
  else
    strengths.resize(point_cloud_.size(), 1.0);

  if (strengths.size() != point_cloud_.size()) {
    fatal_error(
      fmt::format("Number of entries for the strengths array {} does "
                  "not match the number of spatial points provided {}.",
        strengths.size(), point_cloud_.size()));
  }

  point_idx_dist_.assign(strengths);

  if (check_for_node(node, "bias")) {
    pugi::xml_node bias_node = node.child("bias");

    if (check_for_node(bias_node, "strengths")) {
      std::vector<double> bias_strengths(point_cloud_.size(), 1.0);
      bias_strengths = get_node_array<double>(node, "strengths");

      if (bias_strengths.size() != point_cloud_.size()) {
        fatal_error(
          fmt::format("Number of entries in the bias strengths array {} does "
                      "not match the number of spatial points provided {}.",
            bias_strengths.size(), point_cloud_.size()));
      }

      // Compute importance weights
      weight_ = compute_importance_weights(strengths, bias_strengths);

      // Re-initialize DiscreteIndex with bias strengths for sampling
      point_idx_dist_.assign(bias_strengths);
    } else {
      fatal_error(
        fmt::format("Bias node for PointCloud found without strengths array."));
    }
  }
}

PointCloud::PointCloud(
  std::vector<Position> point_cloud, span<const double> strengths)
{
  point_cloud_.assign(point_cloud.begin(), point_cloud.end());
  point_idx_dist_.assign(strengths);
}

std::pair<Position, double> PointCloud::sample(uint64_t* seed) const
{
  int32_t index = point_idx_dist_.sample(seed);
  double wgt = weight_.empty() ? 1.0 : weight_[index];
  return {point_cloud_[index], wgt};
}

//==============================================================================
// SpatialBox implementation
//==============================================================================

SpatialBox::SpatialBox(pugi::xml_node node, bool fission)
  : only_fissionable_ {fission}
{
  // Read lower-right/upper-left coordinates
  auto params = get_node_array<double>(node, "parameters");
  if (params.size() != 6)
    openmc::fatal_error("Box/fission spatial source must have six "
                        "parameters specified.");

  lower_left_ = Position {params[0], params[1], params[2]};
  upper_right_ = Position {params[3], params[4], params[5]};
}

SpatialBox::SpatialBox(Position lower_left, Position upper_right, bool fission)
  : lower_left_(lower_left), upper_right_(upper_right),
    only_fissionable_(fission)
{}

std::pair<Position, double> SpatialBox::sample(uint64_t* seed) const
{
  Position xi {prn(seed), prn(seed), prn(seed)};
  return {lower_left_ + xi * (upper_right_ - lower_left_), 1.0};
}

//==============================================================================
// SpatialPoint implementation
//==============================================================================

SpatialPoint::SpatialPoint(pugi::xml_node node)
{
  // Read location of point source
  auto params = get_node_array<double>(node, "parameters");
  if (params.size() != 3)
    openmc::fatal_error("Point spatial source must have three "
                        "parameters specified.");

  // Set position
  r_ = Position {params.data()};
}

std::pair<Position, double> SpatialPoint::sample(uint64_t* seed) const
{
  return {r_, 1.0};
}

} // namespace openmc

1	#include "openmc/distribution_spatial.h"
2
3	#include "openmc/error.h"
4	#include "openmc/mesh.h"
5	#include "openmc/random_lcg.h"
6	#include "openmc/search.h"
7	#include "openmc/xml_interface.h"
8
9	namespace openmc {
10
11	//==============================================================================
12	// SpatialDistribution implementation
13	//==============================================================================
14
15	unique_ptr<SpatialDistribution> SpatialDistribution::create(pugi::xml_node node)	5,970✔
16	{
17	// Check for type of spatial distribution and read
18	std::string type;	5,970✔
19	if (check_for_node(node, "type"))	5,970!
20	type = get_node_value(node, "type", true, true);	5,970✔
21	if (type == "cartesian") {	5,970✔
22	return UPtrSpace {new CartesianIndependent(node)};	12✔
23	} else if (type == "cylindrical") {	5,958✔
24	return UPtrSpace {new CylindricalIndependent(node)};	36✔
25	} else if (type == "spherical") {	5,922✔
26	return UPtrSpace {new SphericalIndependent(node)};	39✔
27	} else if (type == "mesh") {	5,883✔
28	return UPtrSpace {new MeshSpatial(node)};	31✔
29	} else if (type == "cloud") {	5,852✔
30	return UPtrSpace {new PointCloud(node)};	9✔
31	} else if (type == "box") {	5,843✔
32	return UPtrSpace {new SpatialBox(node)};	3,188✔
33	} else if (type == "fission") {	2,655✔
34	return UPtrSpace {new SpatialBox(node, true)};	18✔
35	} else if (type == "point") {	2,637!
36	return UPtrSpace {new SpatialPoint(node)};	2,637✔
37	} else {
38	fatal_error(fmt::format(	×
39	"Invalid spatial distribution for external source: {}", type));
40	}
41	}	5,970✔
42
43	//==============================================================================
44	// CartesianIndependent implementation
45	//==============================================================================
46
47	CartesianIndependent::CartesianIndependent(pugi::xml_node node)	12✔
48	{
49	// Read distribution for x coordinate
50	if (check_for_node(node, "x")) {	12!
51	pugi::xml_node node_dist = node.child("x");	12✔
52	x_ = distribution_from_xml(node_dist);	12✔
53	} else {
54	// If no distribution was specified, default to a single point at x=0
55	double x[] {0.0};	×
56	double p[] {1.0};	×
57	x_ = UPtrDist {new Discrete {x, p, 1}};	×
58	}
59
60	// Read distribution for y coordinate
61	if (check_for_node(node, "y")) {	12!
62	pugi::xml_node node_dist = node.child("y");	12✔
63	y_ = distribution_from_xml(node_dist);	12✔
64	} else {
65	// If no distribution was specified, default to a single point at y=0
66	double x[] {0.0};	×
67	double p[] {1.0};	×
68	y_ = UPtrDist {new Discrete {x, p, 1}};	×
69	}
70
71	// Read distribution for z coordinate
72	if (check_for_node(node, "z")) {	12!
73	pugi::xml_node node_dist = node.child("z");	12✔
74	z_ = distribution_from_xml(node_dist);	12✔
75	} else {
76	// If no distribution was specified, default to a single point at z=0
77	double x[] {0.0};	×
78	double p[] {1.0};	×
79	z_ = UPtrDist {new Discrete {x, p, 1}};	×
80	}
81	}	12✔
82
83	std::pair<Position, double> CartesianIndependent::sample(uint64_t* seed) const	2,610✔
84	{
85	auto [x_val, x_wgt] = x_->sample(seed);	2,610✔
86	auto [y_val, y_wgt] = y_->sample(seed);	2,610✔
87	auto [z_val, z_wgt] = z_->sample(seed);	2,610✔
88	Position xi {x_val, y_val, z_val};	2,610✔
89	return {xi, x_wgt * y_wgt * z_wgt};	2,610✔
90	}
91
92	//==============================================================================
93	// CylindricalIndependent implementation
94	//==============================================================================
95
96	CylindricalIndependent::CylindricalIndependent(pugi::xml_node node)	36✔
97	{
98	// Read distribution for r-coordinate
99	if (check_for_node(node, "r")) {	36!
100	pugi::xml_node node_dist = node.child("r");	36✔
101	r_ = distribution_from_xml(node_dist);	36✔
102	} else {
103	// If no distribution was specified, default to a single point at r=0
104	double x[] {0.0};	×
105	double p[] {1.0};	×
106	r_ = make_unique<Discrete>(x, p, 1);	×
107	}
108
109	// Read distribution for phi-coordinate
110	if (check_for_node(node, "phi")) {	36!
111	pugi::xml_node node_dist = node.child("phi");	36✔
112	phi_ = distribution_from_xml(node_dist);	36✔
113	} else {
114	// If no distribution was specified, default to a single point at phi=0
115	double x[] {0.0};	×
116	double p[] {1.0};	×
117	phi_ = make_unique<Discrete>(x, p, 1);	×
118	}
119
120	// Read distribution for z-coordinate
121	if (check_for_node(node, "z")) {	36!
122	pugi::xml_node node_dist = node.child("z");	36✔
123	z_ = distribution_from_xml(node_dist);	36✔
124	} else {
125	// If no distribution was specified, default to a single point at z=0
126	double x[] {0.0};	×
127	double p[] {1.0};	×
128	z_ = make_unique<Discrete>(x, p, 1);	×
129	}
130
131	// Read cylinder center coordinates
132	if (check_for_node(node, "origin")) {	36!
133	auto origin = get_node_array<double>(node, "origin");	36✔
134	if (origin.size() == 3) {	36!
135	origin_ = origin;	36✔
136	} else {
137	fatal_error(	×
138	"Origin for cylindrical source distribution must be length 3");
139	}
140	} else {	36✔
141	// If no coordinates were specified, default to (0, 0, 0)
142	origin_ = {0.0, 0.0, 0.0};	×
143	}
144
145	// Read cylinder z_dir
146	if (check_for_node(node, "z_dir")) {	36!
UNCOV 147	auto z_dir = get_node_array<double>(node, "z_dir");	×
UNCOV 148	if (z_dir.size() == 3) {	×
UNCOV 149	z_dir_ = z_dir;	×
UNCOV 150	z_dir_ /= z_dir_.norm();	×
151	} else {
UNCOV 152	fatal_error("z_dir for cylindrical source distribution must be length 3");	×
153	}
UNCOV 154	} else {	×
155	// If no z_dir was specified, default to (0, 0, 1)
156	z_dir_ = {0.0, 0.0, 1.0};	36✔
157	}
158
159	// Read cylinder r_dir
160	if (check_for_node(node, "r_dir")) {	36!
UNCOV 161	auto r_dir = get_node_array<double>(node, "r_dir");	×
UNCOV 162	if (r_dir.size() == 3) {	×
UNCOV 163	r_dir_ = r_dir;	×
UNCOV 164	r_dir_ /= r_dir_.norm();	×
165	} else {
UNCOV 166	fatal_error("r_dir for cylindrical source distribution must be length 3");	×
167	}
UNCOV 168	} else {	×
169	// If no r_dir was specified, default to (1, 0, 0)
170	r_dir_ = {1.0, 0.0, 0.0};	36✔
171	}
172
173	if (r_dir_.dot(z_dir_) > 1e-12)	36!
UNCOV 174	fatal_error("r_dir must be perpendicular to z_dir");	×
175
176	auto phi_dir = z_dir_.cross(r_dir_);	36✔
177	phi_dir /= phi_dir.norm();	36✔
178	phi_dir_ = phi_dir;	36✔
179	}	36✔
180
181	std::pair<Position, double> CylindricalIndependent::sample(uint64_t* seed) const	2,898✔
182	{
183	auto [r, r_wgt] = r_->sample(seed);	2,898✔
184	auto [phi, phi_wgt] = phi_->sample(seed);	2,898✔
185	auto [z, z_wgt] = z_->sample(seed);	2,898✔
186	Position xi =
187	r * (cos(phi) * r_dir_ + sin(phi) * phi_dir_) + z * z_dir_ + origin_;	2,898✔
188	return {xi, r_wgt * phi_wgt * z_wgt};	2,898✔
189	}
190
191	//==============================================================================
192	// SphericalIndependent implementation
193	//==============================================================================
194
195	SphericalIndependent::SphericalIndependent(pugi::xml_node node)	39✔
196	{
197	// Read distribution for r-coordinate
198	if (check_for_node(node, "r")) {	39!
199	pugi::xml_node node_dist = node.child("r");	39✔
200	r_ = distribution_from_xml(node_dist);	39✔
201	} else {
202	// If no distribution was specified, default to a single point at r=0
UNCOV 203	double x[] {0.0};	×
204	double p[] {1.0};	×
UNCOV 205	r_ = make_unique<Discrete>(x, p, 1);	×
206	}
207
208	// Read distribution for cos_theta-coordinate
209	if (check_for_node(node, "cos_theta")) {	39!
210	pugi::xml_node node_dist = node.child("cos_theta");	39✔
211	cos_theta_ = distribution_from_xml(node_dist);	39✔
212	} else {
213	// If no distribution was specified, default to a single point at
214	// cos_theta=0
UNCOV 215	double x[] {0.0};	×
UNCOV 216	double p[] {1.0};	×
UNCOV 217	cos_theta_ = make_unique<Discrete>(x, p, 1);	×
218	}
219
220	// Read distribution for phi-coordinate
221	if (check_for_node(node, "phi")) {	39!
222	pugi::xml_node node_dist = node.child("phi");	39✔
223	phi_ = distribution_from_xml(node_dist);	39✔
224	} else {
225	// If no distribution was specified, default to a single point at phi=0
UNCOV 226	double x[] {0.0};	×
UNCOV 227	double p[] {1.0};	×
UNCOV 228	phi_ = make_unique<Discrete>(x, p, 1);	×
229	}
230
231	// Read sphere center coordinates
232	if (check_for_node(node, "origin")) {	39!
233	auto origin = get_node_array<double>(node, "origin");	39✔
234	if (origin.size() == 3) {	39!
235	origin_ = origin;	39✔
236	} else {
UNCOV 237	fatal_error("Origin for spherical source distribution must be length 3");	×
238	}
239	} else {	39✔
240	// If no coordinates were specified, default to (0, 0, 0)
UNCOV 241	origin_ = {0.0, 0.0, 0.0};	×
242	}
243	}	39✔
244
245	std::pair<Position, double> SphericalIndependent::sample(uint64_t* seed) const	101,872✔
246	{
247	auto [r, r_wgt] = r_->sample(seed);	101,872✔
248	auto [cos_theta, cos_theta_wgt] = cos_theta_->sample(seed);	101,872✔
249	auto [phi, phi_wgt] = phi_->sample(seed);	101,872✔
250	// sin(theta) by sin2 + cos2 = 1
251	double x = r * std::sqrt(1 - cos_theta * cos_theta) * cos(phi) + origin_.x;	101,872✔
252	double y = r * std::sqrt(1 - cos_theta * cos_theta) * sin(phi) + origin_.y;	101,872✔
253	double z = r * cos_theta + origin_.z;	101,872✔
254	Position xi {x, y, z};	101,872✔
255	return {xi, r_wgt * cos_theta_wgt * phi_wgt};	101,872✔
256	}
257
258	//==============================================================================
259	// MeshSpatial implementation
260	//==============================================================================
261
262	MeshSpatial::MeshSpatial(pugi::xml_node node)	31✔
263	{
264
265	if (get_node_value(node, "type", true, true) != "mesh") {	31!
UNCOV 266	fatal_error(fmt::format(	×
267	"Incorrect spatial type '{}' for a MeshSpatial distribution"));
268	}
269
270	// No in-tet distributions implemented, could include distributions for the
271	// barycentric coords Read in unstructured mesh from mesh_id value
272	int32_t mesh_id = std::stoi(get_node_value(node, "mesh_id"));	31✔
273	// Get pointer to spatial distribution
274	mesh_idx_ = model::mesh_map.at(mesh_id);	31✔
275
276	const auto mesh_ptr = model::meshes.at(mesh_idx_).get();	31✔
277
278	check_element_types();	31✔
279
280	size_t n_bins = this->n_sources();	31✔
281	std::vector<double> strengths(n_bins, 1.0);	31✔
282
283	// Create cdfs for sampling for an element over a mesh
284	// Volume scheme is weighted by the volume of each tet
285	// File scheme is weighted by an array given in the xml file
286	if (check_for_node(node, "strengths")) {	31✔
287	strengths = get_node_array<double>(node, "strengths");	29✔
288	if (strengths.size() != n_bins) {	29!
UNCOV 289	fatal_error(	×
UNCOV 290	fmt::format("Number of entries in the source strengths array {} does "	×
291	"not match the number of entities in mesh {} ({}).",
292	strengths.size(), mesh_id, n_bins));	×
293	}
294	}
295
296	if (get_node_value_bool(node, "volume_normalized")) {	31✔
297	for (int i = 0; i < n_bins; i++) {	25,109✔
298	strengths[i] *= this->mesh()->volume(i);	25,080✔
299	}
300	}
301
302	elem_idx_dist_.assign(strengths);	31✔
303
304	if (check_for_node(node, "bias")) {	31!
UNCOV 305	pugi::xml_node bias_node = node.child("bias");	×
306
UNCOV 307	if (check_for_node(bias_node, "strengths")) {	×
UNCOV 308	std::vector<double> bias_strengths(n_bins, 1.0);	×
UNCOV 309	bias_strengths = get_node_array<double>(node, "strengths");	×
310
UNCOV 311	if (bias_strengths.size() != n_bins) {	×
UNCOV 312	fatal_error(	×
UNCOV 313	fmt::format("Number of entries in the bias strengths array {} does "	×
314	"not match the number of entities in mesh {} ({}).",
UNCOV 315	bias_strengths.size(), mesh_id, n_bins));	×
316	}
317
UNCOV 318	if (get_node_value_bool(node, "volume_normalized")) {	×
UNCOV 319	for (int i = 0; i < n_bins; i++) {	×
UNCOV 320	bias_strengths[i] *= this->mesh()->volume(i);	×
321	}
322	}
323
324	// Compute importance weights
UNCOV 325	weight_ = compute_importance_weights(strengths, bias_strengths);	×
326
327	// Re-initialize DiscreteIndex with bias strengths for sampling
UNCOV 328	elem_idx_dist_.assign(bias_strengths);	×
UNCOV 329	} else {	×
UNCOV 330	fatal_error(fmt::format(	×
331	"Bias node for mesh {} found without strengths array.", mesh_id));
332	}
333	}
334	}	31✔
335
336	MeshSpatial::MeshSpatial(int32_t mesh_idx, span<const double> strengths)	164✔
337	: mesh_idx_(mesh_idx)	164✔
338	{
339	check_element_types();	164✔
340	elem_idx_dist_.assign(strengths);	164✔
341	}	164✔
342
343	void MeshSpatial::check_element_types() const	195✔
344	{
345	const auto umesh_ptr = dynamic_cast<const UnstructuredMesh*>(this->mesh());	195!
346	if (umesh_ptr) {	195✔
347	// ensure that the unstructured mesh contains only linear tets
348	for (int bin = 0; bin < umesh_ptr->n_bins(); bin++) {	72,006✔
349	if (umesh_ptr->element_type(bin) != ElementType::LINEAR_TET) {	72,000!
UNCOV 350	fatal_error(	×
351	"Mesh specified for source must contain only linear tetrahedra.");
352	}
353	}
354	}
355	}	195✔
356
357	int32_t MeshSpatial::sample_element_index(uint64_t* seed) const	1,607,627✔
358	{
359	return elem_idx_dist_.sample(seed);	1,607,627✔
360	}
361
362	std::pair<int32_t, Position> MeshSpatial::sample_mesh(uint64_t* seed) const	401,070✔
363	{
364	// Sample the CDF defined in initialization above
365	int32_t elem_idx = this->sample_element_index(seed);	401,070✔
366	return {elem_idx, mesh()->sample_element(elem_idx, seed)};	401,070✔
367	}
368
369	std::pair<Position, double> MeshSpatial::sample(uint64_t* seed) const	401,070✔
370	{
371	auto [elem_idx, u] = this->sample_mesh(seed);	401,070✔
372	double wgt = weight_.empty() ? 1.0 : weight_[elem_idx];	401,070!
373	return {u, wgt};	802,140✔
374	}
375
376	//==============================================================================
377	// PointCloud implementation
378	//==============================================================================
379
380	PointCloud::PointCloud(pugi::xml_node node)	9✔
381	{
382	if (check_for_node(node, "coords")) {	9!
383	point_cloud_ = get_node_position_array(node, "coords");	9✔
384	} else {
UNCOV 385	fatal_error("No coordinates were provided for the PointCloud "	×
386	"spatial distribution");
387	}
388
389	std::vector<double> strengths;	9✔
390
391	if (check_for_node(node, "strengths"))	9!
392	strengths = get_node_array<double>(node, "strengths");	9✔
393	else
UNCOV 394	strengths.resize(point_cloud_.size(), 1.0);	×
395
396	if (strengths.size() != point_cloud_.size()) {	9!
UNCOV 397	fatal_error(	×
398	fmt::format("Number of entries for the strengths array {} does "	×
399	"not match the number of spatial points provided {}.",
UNCOV 400	strengths.size(), point_cloud_.size()));	×
401	}
402
403	point_idx_dist_.assign(strengths);	9✔
404
405	if (check_for_node(node, "bias")) {	9!
UNCOV 406	pugi::xml_node bias_node = node.child("bias");	×
407
UNCOV 408	if (check_for_node(bias_node, "strengths")) {	×
UNCOV 409	std::vector<double> bias_strengths(point_cloud_.size(), 1.0);	×
UNCOV 410	bias_strengths = get_node_array<double>(node, "strengths");	×
411
UNCOV 412	if (bias_strengths.size() != point_cloud_.size()) {	×
UNCOV 413	fatal_error(	×
UNCOV 414	fmt::format("Number of entries in the bias strengths array {} does "	×
415	"not match the number of spatial points provided {}.",
UNCOV 416	bias_strengths.size(), point_cloud_.size()));	×
417	}
418
419	// Compute importance weights
UNCOV 420	weight_ = compute_importance_weights(strengths, bias_strengths);	×
421
422	// Re-initialize DiscreteIndex with bias strengths for sampling
UNCOV 423	point_idx_dist_.assign(bias_strengths);	×
UNCOV 424	} else {	×
UNCOV 425	fatal_error(	×
UNCOV 426	fmt::format("Bias node for PointCloud found without strengths array."));	×
427	}
428	}
429	}	9✔
430
UNCOV 431	PointCloud::PointCloud(	×
UNCOV 432	std::vector<Position> point_cloud, span<const double> strengths)	×
433	{
UNCOV 434	point_cloud_.assign(point_cloud.begin(), point_cloud.end());	×
UNCOV 435	point_idx_dist_.assign(strengths);	×
UNCOV 436	}	×
437
438	std::pair<Position, double> PointCloud::sample(uint64_t* seed) const	450,000✔
439	{
440	int32_t index = point_idx_dist_.sample(seed);	450,000✔
441	double wgt = weight_.empty() ? 1.0 : weight_[index];	450,000!
442	return {point_cloud_[index], wgt};	900,000✔
443	}
444
445	//==============================================================================
446	// SpatialBox implementation
447	//==============================================================================
448
449	SpatialBox::SpatialBox(pugi::xml_node node, bool fission)	3,206✔
450	: only_fissionable_ {fission}	3,206✔
451	{
452	// Read lower-right/upper-left coordinates
453	auto params = get_node_array<double>(node, "parameters");	3,206✔
454	if (params.size() != 6)	3,206!
UNCOV 455	openmc::fatal_error("Box/fission spatial source must have six "	×
456	"parameters specified.");
457
458	lower_left_ = Position {params[0], params[1], params[2]};	3,206✔
459	upper_right_ = Position {params[3], params[4], params[5]};	3,206✔
460	}	3,206✔
461
462	SpatialBox::SpatialBox(Position lower_left, Position upper_right, bool fission)	9✔
463	: lower_left_(lower_left), upper_right_(upper_right),	9✔
464	only_fissionable_(fission)	9✔
465	{}	9✔
466
467	std::pair<Position, double> SpatialBox::sample(uint64_t* seed) const	5,852,083✔
468	{
469	Position xi {prn(seed), prn(seed), prn(seed)};	5,852,083✔
470	return {lower_left_ + xi * (upper_right_ - lower_left_), 1.0};	5,852,083✔
471	}
472
473	//==============================================================================
474	// SpatialPoint implementation
475	//==============================================================================
476
477	SpatialPoint::SpatialPoint(pugi::xml_node node)	2,637✔
478	{
479	// Read location of point source
480	auto params = get_node_array<double>(node, "parameters");	2,637✔
481	if (params.size() != 3)	2,637!
UNCOV 482	openmc::fatal_error("Point spatial source must have three "	×
483	"parameters specified.");
484
485	// Set position
486	r_ = Position {params.data()};	2,637✔
487	}	2,637✔
488
489	std::pair<Position, double> SpatialPoint::sample(uint64_t* seed) const	22,233,114✔
490	{
491	return {r_, 1.0};	22,233,114✔
492	}
493
494	} // namespace openmc

openmc-dev / openmc / 22313563243

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