def export_to_xml(self, filename='mgxs.xml'):
"""Create an mgxs.xml file that can be used for a
simulation.
Parameters
----------
filename : str, optional
filename of file, default is mgxs.xml
"""
# Reset xml element tree
self._cross_sections_file.clear()
self._create_groups_subelement()
self._create_group_structure_subelement()
self._create_inverse_velocities_subelement()
self._create_xsdata_subelements()
# Clean the indentation in the file to be user-readable
sort_xml_elements(self._cross_sections_file)
clean_xml_indentation(self._cross_sections_file)
# Write the XML Tree to the xsdatas.xml file
tree = ET.ElementTree(self._cross_sections_file)
tree.write(filename, xml_declaration=True,
encoding='utf-8', method='xml')
def export_to_xml(self):
"""Create a cmfd.xml file using the class data that can be used for an OpenMC
simulation.
"""
self._create_begin_subelement()
self._create_dhat_reset_subelement()
self._create_display_subelement()
self._create_downscatter_subelement()
self._create_feedback_subelement()
self._create_gauss_seidel_tolerance_subelement()
self._create_ktol_subelement()
self._create_mesh_subelement()
self._create_norm_subelement()
self._create_power_monitor_subelement()
self._create_run_adjoint_subelement()
self._create_shift_subelement()
self._create_spectral_subelement()
self._create_stol_subelement()
self._create_tally_reset_subelement()
self._create_write_matrices_subelement()
# Clean the indentation in the file to be user-readable
clean_xml_indentation(self._cmfd_file)
# Write the XML Tree to the cmfd.xml file
tree = ET.ElementTree(self._cmfd_file)
tree.write("cmfd.xml", xml_declaration=True,
encoding='utf-8', method="xml")
def export_to_xml(self, path='cross_sections.xml'):
"""Export cross section data library to an XML file.
Parameters
----------
path : str
Path to file to write. Defaults to 'cross_sections.xml'.
"""
root = ET.Element('cross_sections')
# Determine common directory for library paths
common_dir = os.path.dirname(
os.path.commonprefix([lib['path'] for lib in self.libraries]))
if common_dir == '':
common_dir = '.'
directory = os.path.relpath(common_dir, os.path.dirname(path))
if directory != '.':
dir_element = ET.SubElement(root, "directory")
dir_element.text = directory
for library in self.libraries:
lib_element = ET.SubElement(root, "library")
lib_element.set('materials', ' '.join(library['materials']))
lib_element.set('path', os.path.relpath(library['path'],
common_dir))
lib_element.set('type', library['type'])
# Clean the indentation to be user-readable
clean_xml_indentation(root)
# Write XML file
tree = ET.ElementTree(root)
tree.write(path, xml_declaration=True, encoding='utf-8', method='xml')
def export_to_xml(self):
"""Create a cmfd.xml file using the class data that can be used for an OpenMC
simulation.
"""
self._create_begin_subelement()
self._create_dhat_reset_subelement()
self._create_display_subelement()
self._create_downscatter_subelement()
self._create_feedback_subelement()
self._create_gauss_seidel_tolerance_subelement()
self._create_ktol_subelement()
self._create_mesh_subelement()
self._create_norm_subelement()
self._create_power_monitor_subelement()
self._create_run_adjoint_subelement()
self._create_shift_subelement()
self._create_spectral_subelement()
self._create_stol_subelement()
self._create_tally_reset_subelement()
self._create_write_matrices_subelement()
# Clean the indentation in the file to be user-readable
clean_xml_indentation(self._cmfd_file)
# Write the XML Tree to the cmfd.xml file
tree = ET.ElementTree(self._cmfd_file)
tree.write("cmfd.xml",
xml_declaration=True,
encoding='utf-8',
method="xml")
def export_to_xml(self, path='cross_sections.xml'):
"""Export cross section data library to an XML file.
Parameters
----------
path : str
Path to file to write. Defaults to 'cross_sections.xml'.
"""
root = ET.Element('cross_sections')
# Determine common directory for library paths
common_dir = os.path.dirname(os.path.commonprefix(
[lib['path'] for lib in self.libraries]))
if common_dir == '':
common_dir = '.'
directory = os.path.relpath(common_dir, os.path.dirname(path))
if directory != '.':
dir_element = ET.SubElement(root, "directory")
dir_element.text = directory
for library in self.libraries:
lib_element = ET.SubElement(root, "library")
lib_element.set('materials', ' '.join(library['materials']))
lib_element.set('path', os.path.relpath(library['path'], common_dir))
lib_element.set('type', library['type'])
# Clean the indentation to be user-readable
clean_xml_indentation(root)
# Write XML file
tree = ET.ElementTree(root)
tree.write(path, xml_declaration=True, encoding='utf-8',
method='xml')
def export_to_xml(self, path='settings.xml'):
"""Export simulation settings to an XML file.
Parameters
----------
path : str
Path to file to write. Defaults to 'settings.xml'.
"""
# Reset xml element tree
root_element = ET.Element("settings")
self._create_run_mode_subelement(root_element)
self._create_particles_subelement(root_element)
self._create_batches_subelement(root_element)
self._create_inactive_subelement(root_element)
self._create_generations_per_batch_subelement(root_element)
self._create_keff_trigger_subelement(root_element)
self._create_source_subelement(root_element)
self._create_output_subelement(root_element)
self._create_statepoint_subelement(root_element)
self._create_sourcepoint_subelement(root_element)
self._create_confidence_intervals(root_element)
self._create_cross_sections_subelement(root_element)
self._create_multipole_library_subelement(root_element)
self._create_energy_mode_subelement(root_element)
self._create_max_order_subelement(root_element)
self._create_ptables_subelement(root_element)
self._create_run_cmfd_subelement(root_element)
self._create_seed_subelement(root_element)
self._create_survival_biasing_subelement(root_element)
self._create_cutoff_subelement(root_element)
self._create_entropy_subelement(root_element)
self._create_trigger_subelement(root_element)
self._create_no_reduce_subelement(root_element)
self._create_threads_subelement(root_element)
self._create_verbosity_subelement(root_element)
self._create_tabular_legendre_subelements(root_element)
self._create_temperature_subelements(root_element)
self._create_trace_subelement(root_element)
self._create_track_subelement(root_element)
self._create_ufs_subelement(root_element)
self._create_dd_subelement(root_element)
self._create_resonance_scattering_subelement(root_element)
self._create_volume_calcs_subelement(root_element)
self._create_create_fission_neutrons_subelement(root_element)
# Clean the indentation in the file to be user-readable
clean_xml_indentation(root_element)
# Write the XML Tree to the settings.xml file
tree = ET.ElementTree(root_element)
tree.write(path, xml_declaration=True, encoding='utf-8', method="xml")
def export_to_xml(self, path='settings.xml'):
"""Export simulation settings to an XML file.
Parameters
----------
path : str
Path to file to write. Defaults to 'settings.xml'.
"""
# Reset xml element tree
root_element = ET.Element("settings")
self._create_run_mode_subelement(root_element)
self._create_particles_subelement(root_element)
self._create_batches_subelement(root_element)
self._create_inactive_subelement(root_element)
self._create_generations_per_batch_subelement(root_element)
self._create_keff_trigger_subelement(root_element)
self._create_source_subelement(root_element)
self._create_output_subelement(root_element)
self._create_statepoint_subelement(root_element)
self._create_sourcepoint_subelement(root_element)
self._create_confidence_intervals(root_element)
self._create_cross_sections_subelement(root_element)
self._create_multipole_library_subelement(root_element)
self._create_energy_mode_subelement(root_element)
self._create_max_order_subelement(root_element)
self._create_ptables_subelement(root_element)
self._create_run_cmfd_subelement(root_element)
self._create_seed_subelement(root_element)
self._create_survival_biasing_subelement(root_element)
self._create_cutoff_subelement(root_element)
self._create_entropy_subelement(root_element)
self._create_trigger_subelement(root_element)
self._create_no_reduce_subelement(root_element)
self._create_threads_subelement(root_element)
self._create_verbosity_subelement(root_element)
self._create_tabular_legendre_subelements(root_element)
self._create_temperature_subelements(root_element)
self._create_trace_subelement(root_element)
self._create_track_subelement(root_element)
self._create_ufs_subelement(root_element)
self._create_dd_subelement(root_element)
self._create_resonance_scattering_subelement(root_element)
self._create_volume_calcs_subelement(root_element)
self._create_create_fission_neutrons_subelement(root_element)
# Clean the indentation in the file to be user-readable
clean_xml_indentation(root_element)
# Write the XML Tree to the settings.xml file
tree = ET.ElementTree(root_element)
tree.write(path, xml_declaration=True, encoding='utf-8', method="xml")
def export_to_xml(self):
"""Create a settings.xml file that can be used for a simulation.
"""
# Reset xml element tree
self._settings_file.clear()
self._source_subelement = None
self._trigger_subelement = None
self._run_mode_subelement = None
self._source_element = None
self._create_run_mode_subelement()
self._create_source_subelement()
self._create_output_subelement()
self._create_statepoint_subelement()
self._create_sourcepoint_subelement()
self._create_confidence_intervals()
self._create_cross_sections_subelement()
self._create_multipole_library_subelement()
self._create_energy_grid_subelement()
self._create_energy_mode_subelement()
self._create_max_order_subelement()
self._create_ptables_subelement()
self._create_run_cmfd_subelement()
self._create_seed_subelement()
self._create_survival_biasing_subelement()
self._create_cutoff_subelement()
self._create_entropy_subelement()
self._create_trigger_subelement()
self._create_no_reduce_subelement()
self._create_threads_subelement()
self._create_verbosity_subelement()
self._create_trace_subelement()
self._create_track_subelement()
self._create_ufs_subelement()
self._create_dd_subelement()
self._create_use_multipole_subelement()
self._create_resonance_scattering_element()
# Clean the indentation in the file to be user-readable
clean_xml_indentation(self._settings_file)
# Write the XML Tree to the settings.xml file
tree = ET.ElementTree(self._settings_file)
tree.write("settings.xml",
xml_declaration=True,
encoding='utf-8',
method="xml")
def export_to_xml(self):
"""Create a settings.xml file that can be used for a simulation.
"""
# Reset xml element tree
self._settings_file.clear()
self._source_subelement = None
self._trigger_subelement = None
self._run_mode_subelement = None
self._source_element = None
self._create_run_mode_subelement()
self._create_source_subelement()
self._create_output_subelement()
self._create_statepoint_subelement()
self._create_sourcepoint_subelement()
self._create_confidence_intervals()
self._create_cross_sections_subelement()
self._create_multipole_library_subelement()
self._create_energy_grid_subelement()
self._create_energy_mode_subelement()
self._create_max_order_subelement()
self._create_ptables_subelement()
self._create_run_cmfd_subelement()
self._create_seed_subelement()
self._create_survival_biasing_subelement()
self._create_cutoff_subelement()
self._create_entropy_subelement()
self._create_trigger_subelement()
self._create_no_reduce_subelement()
self._create_threads_subelement()
self._create_verbosity_subelement()
self._create_trace_subelement()
self._create_track_subelement()
self._create_ufs_subelement()
self._create_dd_subelement()
self._create_use_multipole_subelement()
self._create_resonance_scattering_element()
# Clean the indentation in the file to be user-readable
clean_xml_indentation(self._settings_file)
# Write the XML Tree to the settings.xml file
tree = ET.ElementTree(self._settings_file)
tree.write("settings.xml", xml_declaration=True,
encoding='utf-8', method="xml")
def export_to_xml(self):
"""Create a plots.xml file that can be used by OpenMC.
"""
# Reset xml element tree
self._plots_file.clear()
self._create_plot_subelements()
# Clean the indentation in the file to be user-readable
clean_xml_indentation(self._plots_file)
# Write the XML Tree to the plots.xml file
tree = ET.ElementTree(self._plots_file)
tree.write("plots.xml", xml_declaration=True,
encoding='utf-8', method="xml")
def export_to_xml(self):
"""Create a materials.xml file that can be used for a simulation.
"""
# Reset xml element tree
self._materials_file.clear()
self._create_material_subelements()
# Clean the indentation in the file to be user-readable
sort_xml_elements(self._materials_file)
clean_xml_indentation(self._materials_file)
# Write the XML Tree to the materials.xml file
tree = ET.ElementTree(self._materials_file)
tree.write("materials.xml", xml_declaration=True,
encoding='utf-8', method="xml")
def export_to_xml(self):
"""Create a plots.xml file that can be used by OpenMC.
"""
# Reset xml element tree
self._plots_file.clear()
self._create_plot_subelements()
# Clean the indentation in the file to be user-readable
clean_xml_indentation(self._plots_file)
# Write the XML Tree to the plots.xml file
tree = ET.ElementTree(self._plots_file)
tree.write("plots.xml",
xml_declaration=True,
encoding='utf-8',
method="xml")
def xml_write(self, filename):
"""Writes a depletion chain XML file.
Parameters
----------
filename : str
The path to the depletion chain XML file.
"""
root_elem = ET.Element('depletion')
for nuclide in self.nuclides:
root_elem.append(nuclide.xml_write())
tree = ET.ElementTree(root_elem)
if _have_lxml:
tree.write(filename, encoding='utf-8', pretty_print=True)
else:
clean_xml_indentation(root_elem, spaces_per_level=2)
tree.write(filename, encoding='utf-8')
def export_to_xml(self, path='geometry.xml'):
"""Export geometry to an XML file.
Parameters
----------
path : str
Path to file to write. Defaults to 'geometry.xml'.
"""
# Create XML representation
root_element = ET.Element("geometry")
self.root_universe.create_xml_subelement(root_element)
# Clean the indentation in the file to be user-readable
sort_xml_elements(root_element)
clean_xml_indentation(root_element)
# Write the XML Tree to the geometry.xml file
tree = ET.ElementTree(root_element)
tree.write(path, xml_declaration=True, encoding='utf-8', method="xml")
def export_to_xml(self, path='plots.xml'):
"""Export plot specifications to an XML file.
Parameters
----------
path : str
Path to file to write. Defaults to 'plots.xml'.
"""
# Reset xml element tree
self._plots_file.clear()
self._create_plot_subelements()
# Clean the indentation in the file to be user-readable
clean_xml_indentation(self._plots_file)
# Write the XML Tree to the plots.xml file
tree = ET.ElementTree(self._plots_file)
tree.write(path, xml_declaration=True, encoding='utf-8', method="xml")
def export_to_xml(self, path='materials.xml'):
"""Export material collection to an XML file.
Parameters
----------
path : str
Path to file to write. Defaults to 'materials.xml'.
"""
root_element = ET.Element("materials")
self._create_cross_sections_subelement(root_element)
self._create_multipole_library_subelement(root_element)
self._create_material_subelements(root_element)
# Clean the indentation in the file to be user-readable
clean_xml_indentation(root_element)
# Write the XML Tree to the materials.xml file
tree = ET.ElementTree(root_element)
tree.write(path, xml_declaration=True, encoding='utf-8')
def export_to_xml(self):
"""Create a geometry.xml file that can be used for a simulation.
"""
# Clear OpenMC written IDs used to optimize XML generation
openmc.universe.WRITTEN_IDS = {}
# Create XML representation
geometry_file = ET.Element("geometry")
self.root_universe.create_xml_subelement(geometry_file)
# Clean the indentation in the file to be user-readable
sort_xml_elements(geometry_file)
clean_xml_indentation(geometry_file)
# Write the XML Tree to the geometry.xml file
tree = ET.ElementTree(geometry_file)
tree.write("geometry.xml",
xml_declaration=True,
encoding='utf-8',
method="xml")
def export_to_xml(self, path='geometry.xml'):
"""Export geometry to an XML file.
Parameters
----------
path : str
Path to file to write. Defaults to 'geometry.xml'.
"""
# Create XML representation
root_element = ET.Element("geometry")
self.root_universe.create_xml_subelement(root_element)
# Sort the elements in the file
root_element[:] = sorted(root_element, key=lambda x: (
x.tag, int(x.get('id'))))
# Clean the indentation in the file to be user-readable
clean_xml_indentation(root_element)
# Write the XML Tree to the geometry.xml file
tree = ET.ElementTree(root_element)
tree.write(path, xml_declaration=True, encoding='utf-8')
def generate_materials_xml(self):
""" Creates materials.xml from self.number.
Due to uncertainty with how MPI interacts with OpenMC API, this
constructs the XML manually. The long term goal is to do this
either through PHDF5 or direct memory writing.
"""
xml_strings = []
for mat in self.number.mat_to_ind:
root = ET.Element("material")
root.set("id", mat)
density = ET.SubElement(root, "density")
density.set("units", "sum")
temperature = ET.SubElement(root, "temperature")
mat_id = self.number.mat_to_ind[mat]
temperature.text = str(self.materials[mat_id].temperature)
for nuc in self.number.nuc_to_ind:
if nuc in self.participating_nuclides:
val = 1.0e-24 * self.number.get_atom_density(mat, nuc)
# If nuclide is zero, do not add to the problem.
if val > 0.0:
if self.settings.round_number:
val_magnitude = np.floor(np.log10(val))
val_scaled = val / 10**val_magnitude
val_round = round(val_scaled, 8)
val = val_round * 10**val_magnitude
nuc_element = ET.SubElement(root, "nuclide")
nuc_element.set("ao", str(val))
nuc_element.set("name", nuc)
else:
# Only output warnings if values are significantly
# negative. CRAM does not guarantee positive values.
if val < -1.0e-21:
print("WARNING: nuclide ", nuc, " in material ",
mat, " is negative (density = ", val,
" at/barn-cm)")
self.number[mat, nuc] = 0.0
for sab in self.materials[mat_id].sab:
sab_el = ET.SubElement(root, "sab")
sab_el.set("name", sab)
if _have_lxml:
fragment = ET.tostring(root,
encoding="unicode",
pretty_print="true")
xml_strings.append(fragment)
else:
clean_xml_indentation(root, spaces_per_level=2)
fragment = ET.tostring(root,
encoding="unicode",
pretty_print="true")
xml_strings.append(fragment)
xml_string = "".join(xml_strings)
# Append beginning, end text.
if self.rank == 0:
xml_string = "<?xml version='1.0' encoding='utf-8'?>\n<materials>\n" + xml_string
if self.rank == self.size:
xml_string += "\n</materials>"
xml_bytes = np.fromstring(xml_string, dtype=np.uint8)
# Use MPI-IO to write to disk.
# First, communicate to all nodes the length of their string.
str_len = np.zeros(self.size, np.int32)
str_my_len = np.zeros(1, np.int32)
str_my_len[0] = len(xml_string)
self.comm.Allgather([str_my_len, MPI.INT], [str_len, MPI.INT])
# Compute index start.
start_ind = np.sum(str_len[0:self.rank])
# Open/create file
handle = MPI.File.Open(self.comm, "materials.xml",
MPI.MODE_WRONLY | MPI.MODE_CREATE)
handle.Seek(start_ind, MPI.SEEK_SET)
handle.Write(xml_bytes)
handle.Close()
self.comm.barrier()
def generate_tallies_xml(self, filename_string, default_group_struc=False):
"""Generate tallies.xml with hybrid tallies by using the energy group structure
as a filter together with the material filter of an original tallies.xml.
Parameters
----------
filename_string : string
string with the path to a tallies.xml file that contains
the reaction rate tally of a given geometry. This method will
expand on this by adding the extra flux tally method and by
reducing the number of scores in the original reaction-rate tally
from 7 to 2.
SHEM361_only : bool
In case the user wants to use only the SHEM361 library.
"""
#reads a tallies.xml file with a reaction rate tally and uses the
#material filter to build a new tallies.xml with hybrid tallies using
#the energy filter.
tree = ET.parse(filename_string)
root = tree.getroot()
mat_filter = root[0][0].text
energy_filter = self.gen_energy_struc(default_group_struc)
new_data = ET.Element('tallies')
#attributes for hybrid tally.
attrib_mat = {'id': '1', 'type': 'material'}
attrib_energy = {'id': '2', 'type': 'energy'}
empty_attrib = {}
filter_mat = ET.SubElement(new_data, 'filter', attrib_mat)
filter_ene = ET.SubElement(new_data, 'filter', attrib_energy)
ET.SubElement(filter_mat, 'bins', empty_attrib)
ET.SubElement(filter_ene, 'bins', empty_attrib)
new_data[0][0].text = mat_filter
new_data[1][0].text = ' '.join(str(i) for i in energy_filter)
#writing '<tally>' object
for key, value in enumerate(self.tallies_dict.items()):
tally_id = value[1]['id']
tally_name = value[1]['name']
attrib_tallies = {'id': tally_id, 'name': tally_name}
tally_level = ET.SubElement(new_data, 'tally', attrib_tallies)
ET.SubElement(tally_level, 'filters', empty_attrib)
if (value[1]['nuclides'] != ''):
ET.SubElement(tally_level, 'nuclides', empty_attrib)
ET.SubElement(tally_level, 'scores', empty_attrib)
#last_index could be either a 1 or a 2, depending on
#whether we are doing a reaction rate tally (i.e, last_index=1) or
#a flux tally (i.e., last_index = 2)
last_index = 1
filter_list = value[1]['filter']
score_list = value[1]['scores']
#offset by '2' indicates we are writing the tally objects below
#the material and energy filters
new_data[key + 2][0].text = ' '.join(i for i in filter_list)
if (value[1]['nuclides'] != ''):
nuclide_list = value[1]['nuclides']
new_data[key + 2][1].text = ' '.join(nuc
for nuc in nuclide_list)
last_index = 2
new_data[key + 2][last_index].text = ' '.join(i
for i in score_list)
if (old is True):
clean_xml_indentation(new_data)
else:
clean_indentation(new_data)
#renaming original 'tallies.xml' to 'tallies-original.xml'
#to distinguish it from the new hybrid 'tally.xml' file.
tree = ET.ElementTree(new_data)
#os.rename(filename_string,'tallies-original.xml')
tree.write('./tallies-hybrid-tally.xml',
xml_declaration=True,
encoding='utf-8',
method="xml")
