23045204575

Committed 13 Mar 2026 09:45AM UTC coverage: 81.584% (-0.5%) from 82.058%

Build # 23045204575

Build Type

Pull #2693

github

Committed by

web-flow

Commit Message

Merge 058e99556 into 4bda85f17

Pull Request Pull Request #2693: Add reactivity control to coupled transport-depletion analyses

Run Details

17557 of 25264 branches covered (69.49%)

Branch coverage included in aggregate %.

74 of 85 new or added lines in 4 files covered. (87.06%)

3737 existing lines in 99 files now uncovered.

58052 of 67412 relevant lines covered (86.12%)

47329450.91 hits per line

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

78.51

/src/cross_sections.cpp

#include "openmc/cross_sections.h"

#include "openmc/capi.h"
#include "openmc/constants.h"
#include "openmc/container_util.h"
#include "openmc/error.h"
#include "openmc/file_utils.h"
#include "openmc/geometry_aux.h"
#include "openmc/hdf5_interface.h"
#include "openmc/material.h"
#include "openmc/message_passing.h"
#include "openmc/mgxs_interface.h"
#include "openmc/nuclide.h"
#include "openmc/photon.h"
#include "openmc/settings.h"
#include "openmc/simulation.h"
#include "openmc/string_utils.h"
#include "openmc/thermal.h"
#include "openmc/timer.h"
#include "openmc/wmp.h"
#include "openmc/xml_interface.h"

#include "pugixml.hpp"

#include <cstdlib> // for getenv
#include <filesystem>
#include <unordered_set>

namespace openmc {

//==============================================================================
// Global variable declarations
//==============================================================================

namespace data {

std::map<LibraryKey, std::size_t> library_map;
vector<Library> libraries;
} // namespace data

//==============================================================================
// Library methods
//==============================================================================

Library::Library(pugi::xml_node node, const std::string& directory)
{
  // Get type of library
  if (check_for_node(node, "type")) {
    auto type = get_node_value(node, "type");
    if (type == "neutron") {
      type_ = Type::neutron;
    } else if (type == "thermal") {
      type_ = Type::thermal;
    } else if (type == "photon") {
      type_ = Type::photon;
    } else if (type == "wmp") {
      type_ = Type::wmp;
    } else {
      fatal_error("Unrecognized library type: " + type);
    }
  } else {
    fatal_error("Missing library type");
  }

  // Get list of materials
  if (check_for_node(node, "materials")) {
    materials_ = get_node_array<std::string>(node, "materials");
  }

  // determine path of cross section table
  if (!check_for_node(node, "path")) {
    fatal_error("Missing library path");
  }
  std::string path = get_node_value(node, "path");

  if (starts_with(path, "/")) {
    path_ = path;
  } else if (ends_with(directory, "/")) {
    path_ = directory + path;
  } else if (!directory.empty()) {
    path_ = directory + "/" + path;
  } else {
    path_ = path;
  }

  if (!file_exists(path_)) {
    warning("Cross section library " + path_ + " does not exist.");
  }
}

//==============================================================================
// Non-member functions
//==============================================================================

void read_cross_sections_xml()
{
  pugi::xml_document doc;
  std::string filename = settings::path_input + "materials.xml";
  // Check if materials.xml exists
  if (!file_exists(filename)) {
    fatal_error("Material XML file '" + filename + "' does not exist.");
  }
  // Parse materials.xml file
  doc.load_file(filename.c_str());

  auto root = doc.document_element();

  read_cross_sections_xml(root);
}

void read_cross_sections_xml(pugi::xml_node root)
{
  // Find cross_sections.xml file -- the first place to look is the
  // materials.xml file. If no file is found there, then we check the
  // OPENMC_CROSS_SECTIONS environment variable
  if (!check_for_node(root, "cross_sections")) {
    // No cross_sections.xml file specified in settings.xml, check
    // environment variable
    if (settings::run_CE) {
      char* envvar = std::getenv("OPENMC_CROSS_SECTIONS");
      if (!envvar) {
        fatal_error(
          "No cross_sections.xml file was specified in "
          "materials.xml or in the OPENMC_CROSS_SECTIONS"
          " environment variable. OpenMC needs such a file to identify "
          "where to find data libraries. Please consult the"
          " user's guide at https://docs.openmc.org/ for "
          "information on how to set up data libraries.");
      }
      settings::path_cross_sections = envvar;
    } else {
      char* envvar = std::getenv("OPENMC_MG_CROSS_SECTIONS");
      if (!envvar) {
        fatal_error(
          "No mgxs.h5 file was specified in "
          "materials.xml or in the OPENMC_MG_CROSS_SECTIONS environment "
          "variable. OpenMC needs such a file to identify where to "
          "find MG cross section libraries. Please consult the user's "
          "guide at https://docs.openmc.org for information on "
          "how to set up MG cross section libraries.");
      }
      settings::path_cross_sections = envvar;
    }
  } else {
    settings::path_cross_sections = get_node_value(root, "cross_sections");

    // If no '/' found, the file is probably in the input directory
    auto pos = settings::path_cross_sections.rfind("/");
    if (pos == std::string::npos && !settings::path_input.empty()) {
      settings::path_cross_sections =
        settings::path_input + "/" + settings::path_cross_sections;
    }
  }

  // Now that the cross_sections.xml or mgxs.h5 has been located, read it in
  if (settings::run_CE) {
    read_ce_cross_sections_xml();
  } else {
    data::mg.read_header(settings::path_cross_sections);
    put_mgxs_header_data_to_globals();
  }

  // Establish mapping between (type, material) and index in libraries
  int i = 0;
  for (const auto& lib : data::libraries) {
    for (const auto& name : lib.materials_) {
      LibraryKey key {lib.type_, name};
      data::library_map.insert({key, i});
    }
    ++i;
  }

  // Check that 0K nuclides are listed in the cross_sections.xml file
  for (const auto& name : settings::res_scat_nuclides) {
    LibraryKey key {Library::Type::neutron, name};
    if (data::library_map.find(key) == data::library_map.end()) {
      fatal_error("Could not find resonant scatterer " + name +
                  " in cross_sections.xml file!");
    }
  }
}

void read_ce_cross_sections(const vector<vector<double>>& nuc_temps,
  const vector<vector<double>>& thermal_temps)
{
  std::unordered_set<std::string> already_read;

  // Construct a vector of nuclide names because we haven't loaded nuclide data
  // yet, but we need to know the name of the i-th nuclide
  vector<std::string> nuclide_names(data::nuclide_map.size());
  vector<std::string> thermal_names(data::thermal_scatt_map.size());
  for (const auto& kv : data::nuclide_map) {
    nuclide_names[kv.second] = kv.first;
  }
  for (const auto& kv : data::thermal_scatt_map) {
    thermal_names[kv.second] = kv.first;
  }

  // Read cross sections
  for (const auto& mat : model::materials) {
    for (int i_nuc : mat->nuclide_) {
      // Find name of corresponding nuclide. Because we haven't actually loaded
      // data, we don't have the name available, so instead we search through
      // all key/value pairs in nuclide_map
      std::string& name = nuclide_names[i_nuc];

      // If we've already read this nuclide, skip it
      if (already_read.find(name) != already_read.end())
        continue;

      const auto& temps = nuc_temps[i_nuc];
      int err = openmc_load_nuclide(name.c_str(), temps.data(), temps.size());
      if (err < 0)
        throw std::runtime_error {openmc_err_msg};

      already_read.insert(name);
    }
  }

  // Perform final tasks -- reading S(a,b) tables, normalizing densities
  for (auto& mat : model::materials) {
    for (const auto& table : mat->thermal_tables_) {
      // Get name of S(a,b) table
      int i_table = table.index_table;
      std::string& name = thermal_names[i_table];

      if (already_read.find(name) == already_read.end()) {
        LibraryKey key {Library::Type::thermal, name};
        int idx = data::library_map[key];
        std::string& filename = data::libraries[idx].path_;

        write_message(6, "Reading {} from {}", name, filename);

        // Open file and make sure version matches
        hid_t file_id = file_open(filename, 'r');
        check_data_version(file_id);

        // Read thermal scattering data from HDF5
        hid_t group = open_group(file_id, name.c_str());
        data::thermal_scatt.push_back(
          make_unique<ThermalScattering>(group, thermal_temps[i_table]));
        close_group(group);
        file_close(file_id);

        // Add name to dictionary
        already_read.insert(name);
      }
    } // thermal_tables_

    // Finish setting up materials (normalizing densities, etc.)
    mat->finalize();
  } // materials

  if (settings::photon_transport &&
      settings::electron_treatment == ElectronTreatment::TTB) {
    // Take logarithm of energies since they are log-log interpolated
    data::ttb_e_grid = tensor::log(data::ttb_e_grid);
  }

  // Show minimum/maximum temperature
  write_message(
    4, "Minimum neutron data temperature: {} K", data::temperature_min);
  write_message(
    4, "Maximum neutron data temperature: {} K", data::temperature_max);

  // If the user wants multipole, make sure we found a multipole library.
  if (settings::temperature_multipole) {
    bool mp_found = false;
    for (const auto& nuc : data::nuclides) {
      if (nuc->multipole_) {
        mp_found = true;
        break;
      }
    }
    if (mpi::master && !mp_found) {
      warning("Windowed multipole functionality is turned on, but no multipole "
              "libraries were found. Make sure that windowed multipole data is "
              "present in your cross_sections.xml file.");
    }
  }
}

void read_ce_cross_sections_xml()
{
  // Check if cross_sections.xml exists
  std::filesystem::path filename(settings::path_cross_sections);
  if (!std::filesystem::exists(filename)) {
    fatal_error(
      "Cross sections XML file '" + filename.string() + "' does not exist.");
  }

  if (std::filesystem::is_directory(filename)) {
    fatal_error("OPENMC_CROSS_SECTIONS is set to a directory. "
                "It should be set to an XML file.");
  }

  write_message("Reading cross sections XML file...", 5);

  // Parse cross_sections.xml file
  pugi::xml_document doc;
  auto result = doc.load_file(filename.c_str());
  if (!result) {
    fatal_error("Error processing cross_sections.xml file.");
  }
  auto root = doc.document_element();

  std::string directory;
  if (check_for_node(root, "directory")) {
    // Copy directory information if present
    directory = get_node_value(root, "directory");
  } else {
    // If no directory is listed in cross_sections.xml, by default select the
    // directory in which the cross_sections.xml file resides
    if (filename.has_parent_path()) {
      directory = filename.parent_path().string();
    } else {
      directory = settings::path_input;
    }
  }

  for (const auto& node_library : root.children("library")) {
    data::libraries.emplace_back(node_library, directory);
  }

  // Make sure file was not empty
  if (data::libraries.empty()) {
    fatal_error(
      "No cross section libraries present in cross_sections.xml file.");
  }
}

void finalize_cross_sections()
{
  if (settings::run_mode != RunMode::PLOTTING) {
    simulation::time_read_xs.start();
    if (settings::run_CE) {
      // Determine desired temperatures for each nuclide and S(a,b) table
      double_2dvec nuc_temps(data::nuclide_map.size());
      double_2dvec thermal_temps(data::thermal_scatt_map.size());
      get_temperatures(nuc_temps, thermal_temps);

      // Read continuous-energy cross sections from HDF5
      read_ce_cross_sections(nuc_temps, thermal_temps);
    } else {
      // Create material macroscopic data for MGXS
      set_mg_interface_nuclides_and_temps();
      data::mg.init();
      mark_fissionable_mgxs_materials();
    }
    simulation::time_read_xs.stop();
  }
}

void library_clear()
{
  data::libraries.clear();
  data::library_map.clear();
}

} // namespace openmc

1	#include "openmc/cross_sections.h"
2
3	#include "openmc/capi.h"
4	#include "openmc/constants.h"
5	#include "openmc/container_util.h"
6	#include "openmc/error.h"
7	#include "openmc/file_utils.h"
8	#include "openmc/geometry_aux.h"
9	#include "openmc/hdf5_interface.h"
10	#include "openmc/material.h"
11	#include "openmc/message_passing.h"
12	#include "openmc/mgxs_interface.h"
13	#include "openmc/nuclide.h"
14	#include "openmc/photon.h"
15	#include "openmc/settings.h"
16	#include "openmc/simulation.h"
17	#include "openmc/string_utils.h"
18	#include "openmc/thermal.h"
19	#include "openmc/timer.h"
20	#include "openmc/wmp.h"
21	#include "openmc/xml_interface.h"
22
23	#include "pugixml.hpp"
24
25	#include <cstdlib> // for getenv
26	#include <filesystem>
27	#include <unordered_set>
28
29	namespace openmc {
30
31	//==============================================================================
32	// Global variable declarations
33	//==============================================================================
34
35	namespace data {
36
37	std::map<LibraryKey, std::size_t> library_map;
38	vector<Library> libraries;
39	} // namespace data
40
41	//==============================================================================
42	// Library methods
43	//==============================================================================
44
45	Library::Library(pugi::xml_node node, const std::string& directory)	6,396,227✔
46	{
47	// Get type of library
48	if (check_for_node(node, "type")) {	6,396,227!
49	auto type = get_node_value(node, "type");	6,396,227✔
50	if (type == "neutron") {	6,396,227✔
51	type_ = Type::neutron;	2,800,848✔
52	} else if (type == "thermal") {	3,595,379✔
53	type_ = Type::thermal;	132,596✔
54	} else if (type == "photon") {	3,462,783✔
55	type_ = Type::photon;	662,100✔
56	} else if (type == "wmp") {	2,800,683!
57	type_ = Type::wmp;	2,800,683✔
58	} else {
59	fatal_error("Unrecognized library type: " + type);	×
60	}
UNCOV 61	} else {	×
62	fatal_error("Missing library type");	×
63	}
64
65	// Get list of materials
66	if (check_for_node(node, "materials")) {	6,396,227!
67	materials_ = get_node_array<std::string>(node, "materials");	6,396,227✔
68	}
69
70	// determine path of cross section table
71	if (!check_for_node(node, "path")) {	6,396,227!
72	fatal_error("Missing library path");	×
73	}
74	std::string path = get_node_value(node, "path");	6,396,227✔
75
76	if (starts_with(path, "/")) {	6,396,227!
77	path_ = path;	×
78	} else if (ends_with(directory, "/")) {	6,396,227!
79	path_ = directory + path;	×
80	} else if (!directory.empty()) {	6,396,227✔
81	path_ = directory + "/" + path;	6,385,260✔
82	} else {
83	path_ = path;	10,967✔
84	}
85
86	if (!file_exists(path_)) {	6,396,227!
87	warning("Cross section library " + path_ + " does not exist.");	×
88	}
89	}	2,736,802✔
90
91	//==============================================================================
92	// Non-member functions
93	//==============================================================================
94
95	void read_cross_sections_xml()	1,339✔
96	{
97	pugi::xml_document doc;	1,339✔
98	std::string filename = settings::path_input + "materials.xml";	1,339✔
99	// Check if materials.xml exists
100	if (!file_exists(filename)) {	1,339!
101	fatal_error("Material XML file '" + filename + "' does not exist.");	×
102	}
103	// Parse materials.xml file
104	doc.load_file(filename.c_str());	1,339✔
105
106	auto root = doc.document_element();	1,339✔
107
108	read_cross_sections_xml(root);	1,339✔
109	}	1,339✔
110
111	void read_cross_sections_xml(pugi::xml_node root)	8,072✔
112	{
113	// Find cross_sections.xml file -- the first place to look is the
114	// materials.xml file. If no file is found there, then we check the
115	// OPENMC_CROSS_SECTIONS environment variable
116	if (!check_for_node(root, "cross_sections")) {	8,072✔
117	// No cross_sections.xml file specified in settings.xml, check
118	// environment variable
119	if (settings::run_CE) {	6,632✔
120	char* envvar = std::getenv("OPENMC_CROSS_SECTIONS");	6,610✔
121	if (!envvar) {	6,610!
122	fatal_error(	×
123	"No cross_sections.xml file was specified in "
124	"materials.xml or in the OPENMC_CROSS_SECTIONS"
125	" environment variable. OpenMC needs such a file to identify "
126	"where to find data libraries. Please consult the"
127	" user's guide at https://docs.openmc.org/ for "
128	"information on how to set up data libraries.");
129	}
130	settings::path_cross_sections = envvar;	6,610✔
131	} else {
132	char* envvar = std::getenv("OPENMC_MG_CROSS_SECTIONS");	22✔
133	if (!envvar) {	22!
134	fatal_error(	×
135	"No mgxs.h5 file was specified in "
136	"materials.xml or in the OPENMC_MG_CROSS_SECTIONS environment "
137	"variable. OpenMC needs such a file to identify where to "
138	"find MG cross section libraries. Please consult the user's "
139	"guide at https://docs.openmc.org for information on "
140	"how to set up MG cross section libraries.");
141	}
142	settings::path_cross_sections = envvar;	22✔
143	}
144	} else {
145	settings::path_cross_sections = get_node_value(root, "cross_sections");	1,440✔
146
147	// If no '/' found, the file is probably in the input directory
148	auto pos = settings::path_cross_sections.rfind("/");	1,440✔
149	if (pos == std::string::npos && !settings::path_input.empty()) {	1,440!
UNCOV 150	settings::path_cross_sections =	×
151	settings::path_input + "/" + settings::path_cross_sections;	×
152	}
153	}
154
155	// Now that the cross_sections.xml or mgxs.h5 has been located, read it in
156	if (settings::run_CE) {	8,072✔
157	read_ce_cross_sections_xml();	6,786✔
158	} else {
159	data::mg.read_header(settings::path_cross_sections);	1,286✔
160	put_mgxs_header_data_to_globals();	1,286✔
161	}
162
163	// Establish mapping between (type, material) and index in libraries
164	int i = 0;	8,072✔
165	for (const auto& lib : data::libraries) {	6,407,665✔
166	for (const auto& name : lib.materials_) {	12,799,186✔
167	LibraryKey key {lib.type_, name};	6,399,593✔
168	data::library_map.insert({key, i});	6,399,593✔
169	}	6,399,593✔
170	++i;	6,399,593✔
171	}
172
173	// Check that 0K nuclides are listed in the cross_sections.xml file
174	for (const auto& name : settings::res_scat_nuclides) {	8,117✔
175	LibraryKey key {Library::Type::neutron, name};	45✔
176	if (data::library_map.find(key) == data::library_map.end()) {	45!
177	fatal_error("Could not find resonant scatterer " + name +	×
178	" in cross_sections.xml file!");
179	}
180	}	45✔
181	}	8,072✔
182
183	void read_ce_cross_sections(const vector<vector<double>>& nuc_temps,	6,786✔
184	const vector<vector<double>>& thermal_temps)
185	{
186	std::unordered_set<std::string> already_read;	6,786✔
187
188	// Construct a vector of nuclide names because we haven't loaded nuclide data
189	// yet, but we need to know the name of the i-th nuclide
190	vector<std::string> nuclide_names(data::nuclide_map.size());	6,786✔
191	vector<std::string> thermal_names(data::thermal_scatt_map.size());	6,786✔
192	for (const auto& kv : data::nuclide_map) {	34,487✔
193	nuclide_names[kv.second] = kv.first;	55,402✔
194	}
195	for (const auto& kv : data::thermal_scatt_map) {	8,070✔
196	thermal_names[kv.second] = kv.first;	2,568✔
197	}
198
199	// Read cross sections
200	for (const auto& mat : model::materials) {	19,217✔
201	for (int i_nuc : mat->nuclide_) {	60,758✔
202	// Find name of corresponding nuclide. Because we haven't actually loaded
203	// data, we don't have the name available, so instead we search through
204	// all key/value pairs in nuclide_map
205	std::string& name = nuclide_names[i_nuc];	48,327✔
206
207	// If we've already read this nuclide, skip it
208	if (already_read.find(name) != already_read.end())	48,327✔
209	continue;	20,626✔
210
211	const auto& temps = nuc_temps[i_nuc];	27,701✔
212	int err = openmc_load_nuclide(name.c_str(), temps.data(), temps.size());	27,701✔
213	if (err < 0)	27,701!
214	throw std::runtime_error {openmc_err_msg};	×
215
216	already_read.insert(name);	27,701✔
217	}
218	}
219
220	// Perform final tasks -- reading S(a,b) tables, normalizing densities
221	for (auto& mat : model::materials) {	19,217✔
222	for (const auto& table : mat->thermal_tables_) {	14,426✔
223	// Get name of S(a,b) table
224	int i_table = table.index_table;	1,995✔
225	std::string& name = thermal_names[i_table];	1,995✔
226
227	if (already_read.find(name) == already_read.end()) {	1,995✔
228	LibraryKey key {Library::Type::thermal, name};	1,284✔
229	int idx = data::library_map[key];	1,284✔
230	std::string& filename = data::libraries[idx].path_;	1,284✔
231
232	write_message(6, "Reading {} from {}", name, filename);	1,284✔
233
234	// Open file and make sure version matches
235	hid_t file_id = file_open(filename, 'r');	1,284✔
236	check_data_version(file_id);	1,284✔
237
238	// Read thermal scattering data from HDF5
239	hid_t group = open_group(file_id, name.c_str());	1,284✔
240	data::thermal_scatt.push_back(	2,568✔
241	make_unique<ThermalScattering>(group, thermal_temps[i_table]));	2,568✔
242	close_group(group);	1,284✔
243	file_close(file_id);	1,284✔
244
245	// Add name to dictionary
246	already_read.insert(name);	1,284✔
247	}	1,284✔
248	} // thermal_tables_
249
250	// Finish setting up materials (normalizing densities, etc.)
251	mat->finalize();	12,431✔
252	} // materials
253
254	if (settings::photon_transport &&	6,786✔
255	settings::electron_treatment == ElectronTreatment::TTB) {	312✔
256	// Take logarithm of energies since they are log-log interpolated
257	data::ttb_e_grid = tensor::log(data::ttb_e_grid);	528✔
258	}
259
260	// Show minimum/maximum temperature
261	write_message(	6,786✔
262	4, "Minimum neutron data temperature: {} K", data::temperature_min);
263	write_message(	6,786✔
264	4, "Maximum neutron data temperature: {} K", data::temperature_max);
265
266	// If the user wants multipole, make sure we found a multipole library.
267	if (settings::temperature_multipole) {	6,786✔
268	bool mp_found = false;	140✔
269	for (const auto& nuc : data::nuclides) {	140!
270	if (nuc->multipole_) {	140!
271	mp_found = true;
272	break;
273	}
274	}
275	if (mpi::master && !mp_found) {	140!
276	warning("Windowed multipole functionality is turned on, but no multipole "	×
277	"libraries were found. Make sure that windowed multipole data is "
278	"present in your cross_sections.xml file.");
279	}
280	}
281	}	13,572✔
282
283	void read_ce_cross_sections_xml()	6,786✔
284	{
285	// Check if cross_sections.xml exists
286	std::filesystem::path filename(settings::path_cross_sections);	6,786✔
287	if (!std::filesystem::exists(filename)) {	6,786!
288	fatal_error(	×
289	"Cross sections XML file '" + filename.string() + "' does not exist.");	×
290	}
291
292	if (std::filesystem::is_directory(filename)) {	6,786!
293	fatal_error("OPENMC_CROSS_SECTIONS is set to a directory. "	×
294	"It should be set to an XML file.");
295	}
296
297	write_message("Reading cross sections XML file...", 5);	6,786✔
298
299	// Parse cross_sections.xml file
300	pugi::xml_document doc;	6,786✔
301	auto result = doc.load_file(filename.c_str());	6,786✔
302	if (!result) {	6,786!
303	fatal_error("Error processing cross_sections.xml file.");	×
304	}
305	auto root = doc.document_element();	6,786✔
306
307	std::string directory;	6,786✔
308	if (check_for_node(root, "directory")) {	6,786!
309	// Copy directory information if present
310	directory = get_node_value(root, "directory");	×
311	} else {
312	// If no directory is listed in cross_sections.xml, by default select the
313	// directory in which the cross_sections.xml file resides
314	if (filename.has_parent_path()) {	6,786✔
315	directory = filename.parent_path().string();	13,220✔
316	} else {
317	directory = settings::path_input;	176✔
318	}
319	}
320
321	for (const auto& node_library : root.children("library")) {	12,799,240✔
322	data::libraries.emplace_back(node_library, directory);	6,396,227✔
323	}
324
325	// Make sure file was not empty
326	if (data::libraries.empty()) {	6,786!
327	fatal_error(	×
328	"No cross section libraries present in cross_sections.xml file.");
329	}
330	}	13,572✔
331
332	void finalize_cross_sections()	8,191✔
333	{
334	if (settings::run_mode != RunMode::PLOTTING) {	8,191✔
335	simulation::time_read_xs.start();	8,072✔
336	if (settings::run_CE) {	8,072✔
337	// Determine desired temperatures for each nuclide and S(a,b) table
338	double_2dvec nuc_temps(data::nuclide_map.size());	6,786✔
339	double_2dvec thermal_temps(data::thermal_scatt_map.size());	6,786✔
340	get_temperatures(nuc_temps, thermal_temps);	6,786✔
341
342	// Read continuous-energy cross sections from HDF5
343	read_ce_cross_sections(nuc_temps, thermal_temps);	6,786✔
344	} else {	6,786✔
345	// Create material macroscopic data for MGXS
346	set_mg_interface_nuclides_and_temps();	1,286✔
347	data::mg.init();	1,286✔
348	mark_fissionable_mgxs_materials();	1,286✔
349	}
350	simulation::time_read_xs.stop();	8,072✔
351	}
352	}	8,191✔
353
354	void library_clear()	8,320✔
355	{
356	data::libraries.clear();	8,320✔
357	data::library_map.clear();	8,320✔
358	}	8,320✔
359
360	} // namespace openmc

openmc-dev / openmc / 23045204575

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