diff --git a/models/fng_str/openmc_model.py b/models/fng_str/openmc_model.py index 52a05635..b5a20651 100644 --- a/models/fng_str/openmc_model.py +++ b/models/fng_str/openmc_model.py @@ -9,16 +9,19 @@ def _parse_args(): """Parse and return commandline arguments""" parser = argparse.ArgumentParser() - parser.add_argument("-b", "--batches", type=int, default=100) - parser.add_argument("-p", "--particles", type=int, default=int(1e8)) - parser.add_argument("-s", "--threads", type=int) + parser.add_argument("-b", "--batches", type=int, default=100, + help='Number of batches to simulate (int)') + parser.add_argument("-p", "--particles", type=int, + default=int(1e8), help='Number of particles per batch (int)') + parser.add_argument("-s", "--threads", type=int, + help='Number of threads to use in the simulation (int)') group = parser.add_argument_group("tallies") group.add_argument("-r", "--reaction_rates_onaxis", action='store_true', - default=False) + default=False, help='Calculate the reaction rates on-axis case') group.add_argument("-o", "--reaction_rates_offaxis", action='store_true', - default=False) + default=False, help='Calculate the reaction rates off-axis case') group.add_argument("-d", "--heating", action='store_true', - default=False) + default=False, help='Calculate the nuclear heating case') args = parser.parse_args() @@ -2177,13 +2180,11 @@ def main(): settings.batches = args.batches settings.particles = args.particles settings.source = source + settings.weight_windows = openmc.wwinp_to_wws("weight_windows.cadis.wwinp") if args.heating: settings.survival_biasing = True settings.photon_transport = True settings.electron_treatment = 'ttb' - settings.weight_windows = openmc.wwinp_to_wws("ww_heating.cadis.wwinp") - else: - settings.weight_windows = openmc.wwinp_to_wws("ww_rr.cadis.wwinp") settings.output = {'tallies': False} ############################################################################ diff --git a/models/fng_str/postprocessing.ipynb b/models/fng_str/postprocessing.ipynb index 9226bf83..876b24d1 100644 --- a/models/fng_str/postprocessing.ipynb +++ b/models/fng_str/postprocessing.ipynb @@ -39,10 +39,10 @@ "outputs": [], "source": [ "# read sinbad data\n", - "experiment_file = ofb.ResultsFromDatabase('experiment.h5', path='results_database')\n", - "mcnp_eff3_file = ofb.ResultsFromDatabase('mcnp-4a-b_eff3.h5', path='results_database')\n", - "mcnp_fendl1_file = ofb.ResultsFromDatabase('mcnp-4a-b_fendl1.h5', path='results_database')\n", - "mcnp_fendl2_file = ofb.ResultsFromDatabase('mcnp-4a-b_fendl2.h5', path='results_database')" + "experiment_file = ofb.ResultsFromDatabase('results_database/experiment.h5')\n", + "mcnp_eff3_file = ofb.ResultsFromDatabase('results_database/mcnp-4a-b_eff3.h5')\n", + "mcnp_fendl1_file = ofb.ResultsFromDatabase('results_database/mcnp-4a-b_fendl1.h5')\n", + "mcnp_fendl2_file = ofb.ResultsFromDatabase('results_database/mcnp-4a-b_fendl2.h5')" ] }, { @@ -52,9 +52,9 @@ "outputs": [], "source": [ "# read openmc results in results_database/\n", - "openmc_fendl3_file = ofb.ResultsFromDatabase('openmc-0-14-0_fendl32b.h5', path='results_database')\n", - "openmc_endfb8_file = ofb.ResultsFromDatabase('openmc-0-14-0_endfb80.h5', path='results_database')\n", - "openmc_jeff3_file = ofb.ResultsFromDatabase('openmc-0-14-0_jeff33.h5', path='results_database')" + "openmc_fendl3_file = ofb.ResultsFromDatabase('results_database/openmc-0-14-0_fendl32b.h5')\n", + "openmc_endfb8_file = ofb.ResultsFromDatabase('results_database/openmc-0-14-0_endfb80.h5')\n", + "openmc_jeff3_file = ofb.ResultsFromDatabase('results_database/openmc-0-14-0_jeff33.h5')" ] }, { diff --git a/models/fng_str/run_and_store.py b/models/fng_str/run_and_store.py index 65c6071b..4d4f3313 100644 --- a/models/fng_str/run_and_store.py +++ b/models/fng_str/run_and_store.py @@ -6,7 +6,6 @@ import numpy as np import pandas as pd from pathlib import Path -import h5py # ignore NaturalNameWarnings import warnings @@ -17,9 +16,12 @@ def _parse_args(): """Parse and return commandline arguments""" parser = argparse.ArgumentParser() - parser.add_argument("-x", "--xslib", type=str) - parser.add_argument("-t", "--when", type=str, default='n/a') - parser.add_argument("-w", "--where", type=str, default='n/a') + parser.add_argument("-x", "--xslib", type=str, + help="Strign with Cross section library name and version (e.g. 'FENDL-2.3')") + parser.add_argument("-t", "--when", type=str, default='n/a', + help="String with the month and year the simulation is run as (e.g. 'June 2021')") + parser.add_argument("-w", "--where", type=str, default='n/a', + help="String with the place/institution where the simulation is run (e.g. 'MIT-PSFC')") args = parser.parse_args() @@ -60,10 +62,10 @@ def main(): # read statepoint file onaxis_file = ofb.ResultsFromOpenmc( - 'statepoint.100.h5', 'reaction_rates_onaxis') + 'reaction_rates_onaxis/statepoint.100.h5') offaxis_file = ofb.ResultsFromOpenmc( - 'statepoint.100.h5', 'reaction_rates_offaxis') - heating_file = ofb.ResultsFromOpenmc('statepoint.100.h5', 'heating') + 'reaction_rates_offaxis/statepoint.100.h5') + heating_file = ofb.ResultsFromOpenmc('heating/statepoint.100.h5') # openmc hdf file filename = ofb.build_hdf_filename( @@ -132,22 +134,13 @@ def main(): tally_df = pd.DataFrame(d) path_to_file = Path('results_database') / filename - - # write the tally in the hdf file - tally_df.to_hdf(path_to_file, tally_name, mode='a', - format='table', data_columns=True, index=False) code_version = 'openmc-' + \ '.'.join(map(str, heating_file.get_openmc_version)) - # write attributes to the hdf file - with h5py.File(path_to_file, 'a') as f: - f[tally_name + '/table'].attrs['x_axis'] = xaxis_name - f.attrs['code_version'] = code_version - f.attrs['xs_library'] = args.xslib.strip().replace(' ', '') - f.attrs['batches'] = heating_file.get_batches - f.attrs['particles_per_batch'] = heating_file.get_particles_per_batch - f.attrs['when'] = args.when - f.attrs['where'] = args.where + xs_library = args.xslib.strip().replace(' ', '') + ofb.to_hdf(tally_df, path_to_file, tally_name, xs_library, xaxis_name, + args.when, args.where, code_version, + heating_file.get_batches, heating_file.get_particles_per_batch) if __name__ == "__main__": diff --git a/models/fng_w/openmc_model.py b/models/fng_w/openmc_model.py index b55ee2f2..24ac4cbc 100644 --- a/models/fng_w/openmc_model.py +++ b/models/fng_w/openmc_model.py @@ -9,14 +9,17 @@ def _parse_args(): """Parse and return commandline arguments""" parser = argparse.ArgumentParser() - parser.add_argument("-b", "--batches", type=int, default=100) - parser.add_argument("-p", "--particles", type=int, default=int(1e7)) - parser.add_argument("-s", "--threads", type=int) + parser.add_argument("-b", "--batches", type=int, default=100, + help='Number of batches to simulate (int)') + parser.add_argument("-p", "--particles", type=int, + default=int(1e7), help='Number of particles per batch (int)') + parser.add_argument("-s", "--threads", type=int, + help='Number of threads to use in the simulation (int)') group = parser.add_argument_group("tallies") group.add_argument("-r", "--reaction_rates", action='store_true', - default=False) + default=False, help='Calculate the reaction rates case') group.add_argument("-d", "--heating", action='store_true', - default=False) + default=False, help='Calculate the nuclear heating case') args = parser.parse_args() diff --git a/models/fng_w/postprocessing.ipynb b/models/fng_w/postprocessing.ipynb index 0bee8413..4228427e 100644 --- a/models/fng_w/postprocessing.ipynb +++ b/models/fng_w/postprocessing.ipynb @@ -39,9 +39,9 @@ "outputs": [], "source": [ "# read sinbad data\n", - "experiment_file = ofb.ResultsFromDatabase('experiment.h5', path='results_database')\n", - "mcnp_eff2_file = ofb.ResultsFromDatabase('mcnp-4c_eff24.h5', path='results_database')\n", - "mcnp_fendl2_file = ofb.ResultsFromDatabase('mcnp-4c_fendl2.h5', path='results_database')" + "experiment_file = ofb.ResultsFromDatabase('results_database/experiment.h5')\n", + "mcnp_eff2_file = ofb.ResultsFromDatabase('results_database/mcnp-4c_eff24.h5')\n", + "mcnp_fendl2_file = ofb.ResultsFromDatabase('results_database/mcnp-4c_fendl2.h5')" ] }, { @@ -51,8 +51,8 @@ "outputs": [], "source": [ "# get openmc results\n", - "openmc_fendl3_file = ofb.ResultsFromDatabase('openmc-0-14-0_fendl32b.h5', path='results_database')\n", - "openmc_endfb8_file = ofb.ResultsFromDatabase('openmc-0-14-0_endfb80.h5', path='results_database')" + "openmc_fendl3_file = ofb.ResultsFromDatabase('results_database/openmc-0-14-0_fendl32b.h5')\n", + "openmc_endfb8_file = ofb.ResultsFromDatabase('results_database/openmc-0-14-0_endfb80.h5')" ] }, { @@ -248,7 +248,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -270,10 +270,9 @@ "\n", "# plot\n", "# preprocessing\n", - "dtype_label = reaction_labels[i]\n", "xaxis = experiment_file.get_tally_xaxis('nuclear_heating')\n", "\n", - "plot = ofb.PlotNuclearHeating(xaxis=xaxis, ylabel=ylabel, dtype_label=dtype_label)\n", + "plot = ofb.PlotNuclearHeating(xaxis=xaxis, ylabel=ylabel)\n", "plot.add_reference_results(reference_data=measured, label='Experiment')\n", "plot.add_computed_results(computed_data=mcnp_eff2, marker='d', color='tab:orange', alpha=.5, label='mcnp-eff2')\n", "plot.add_computed_results(computed_data=mcnp_fendl2, marker='^', color='tab:green', alpha=.5, label='mcnp-fendl2')\n", diff --git a/models/fng_w/results_database/openmc-0-14-0_jeff33.h5 b/models/fng_w/results_database/openmc-0-14-0_jeff33.h5 new file mode 100644 index 00000000..c5cc0ca8 Binary files /dev/null and b/models/fng_w/results_database/openmc-0-14-0_jeff33.h5 differ diff --git a/models/fng_w/run_and_store.py b/models/fng_w/run_and_store.py index 1133d6f1..0167c613 100644 --- a/models/fng_w/run_and_store.py +++ b/models/fng_w/run_and_store.py @@ -3,10 +3,8 @@ import subprocess import openmc_fusion_benchmarks as ofb import helpers -import numpy as np import pandas as pd from pathlib import Path -import h5py # ignore NaturalNameWarnings import warnings @@ -17,9 +15,12 @@ def _parse_args(): """Parse and return commandline arguments""" parser = argparse.ArgumentParser() - parser.add_argument("-x", "--xslib", type=str) - parser.add_argument("-t", "--when", type=str, default='n/a') - parser.add_argument("-w", "--where", type=str, default='n/a') + parser.add_argument("-x", "--xslib", type=str, + help="Strign with Cross section library name and version (e.g. 'FENDL-2.3')") + parser.add_argument("-t", "--when", type=str, default='n/a', + help="String with the month and year the simulation is run as (e.g. 'June 2021')") + parser.add_argument("-w", "--where", type=str, default='n/a', + help="String with the place/institution where the simulation is run (e.g. 'MIT-PSFC')") args = parser.parse_args() @@ -50,8 +51,8 @@ def main(): # read statepoint file reaction_rates_file = ofb.ResultsFromOpenmc( - 'statepoint.100.h5', 'reaction_rates') - heating_file = ofb.ResultsFromOpenmc('statepoint.100.h5', 'heating') + 'reaction_rates/statepoint.100.h5') + heating_file = ofb.ResultsFromOpenmc('heating/statepoint.100.h5') # generate openmc hdf file filename = ofb.build_hdf_filename( @@ -79,22 +80,13 @@ def main(): tally_df = pd.DataFrame(d) path_to_file = Path('results_database') / filename - - # write the tally in the hdf file - tally_df.to_hdf(path_to_file, tally_name, mode='a', - format='table', data_columns=True, index=False) code_version = 'openmc-' + \ '.'.join(map(str, heating_file.get_openmc_version)) - # write attributes to the hdf file - with h5py.File(path_to_file, 'a') as f: - f[tally_name + '/table'].attrs['x_axis'] = xaxis_name - f.attrs['code_version'] = code_version - f.attrs['xs_library'] = args.xslib.strip().replace(' ', '') - f.attrs['batches'] = heating_file.get_batches - f.attrs['particles_per_batch'] = heating_file.get_particles_per_batch - f.attrs['when'] = args.when - f.attrs['where'] = args.where + xs_library = args.xslib.strip().replace(' ', '') + ofb.to_hdf(tally_df, path_to_file, tally_name, xs_library, xaxis_name, + args.when, args.where, code_version, + heating_file.get_batches, heating_file.get_particles_per_batch) if __name__ == "__main__": diff --git a/models/fns_clean_w/openmc_model.py b/models/fns_clean_w/openmc_model.py index 74ebee9f..5c025a4d 100644 --- a/models/fns_clean_w/openmc_model.py +++ b/models/fns_clean_w/openmc_model.py @@ -10,9 +10,12 @@ def _parse_args(): """Parse and return commandline arguments""" parser = argparse.ArgumentParser() - parser.add_argument("-b", "--batches", type=int, default=100) - parser.add_argument("-p", "--particles", type=int, default=int(1e7)) - parser.add_argument("-s", "--threads", type=int) + parser.add_argument("-b", "--batches", type=int, default=100, + help='Number of batches to simulate (int)') + parser.add_argument("-p", "--particles", type=int, + default=int(1e7), help='Number of particles per batch (int)') + parser.add_argument("-s", "--threads", type=int, + help='Number of threads to use in the simulation (int)') args = parser.parse_args() diff --git a/models/fns_clean_w/postprocessing.ipynb b/models/fns_clean_w/postprocessing.ipynb index ce530b07..9dcff49b 100644 --- a/models/fns_clean_w/postprocessing.ipynb +++ b/models/fns_clean_w/postprocessing.ipynb @@ -44,7 +44,7 @@ "outputs": [], "source": [ "# read sinbad data\n", - "experiment_file = ofb.ResultsFromDatabase('experiment.h5', path='results_database')" + "experiment_file = ofb.ResultsFromDatabase('results_database/experiment.h5')" ] }, { @@ -54,7 +54,7 @@ "outputs": [], "source": [ "# read openmc results in results_database/\n", - "openmc_fendl3_file = ofb.ResultsFromDatabase('openmc-0-14-0_fendl32b.h5', path='results_database')" + "openmc_fendl3_file = ofb.ResultsFromDatabase('results_database/openmc-0-14-0_fendl32b.h5')" ] }, { diff --git a/models/fns_clean_w/results_database/openmc-0-14-0_jeff33.h5 b/models/fns_clean_w/results_database/openmc-0-14-0_jeff33.h5 new file mode 100644 index 00000000..8b9d431d Binary files /dev/null and b/models/fns_clean_w/results_database/openmc-0-14-0_jeff33.h5 differ diff --git a/models/fns_clean_w/run_and_store.py b/models/fns_clean_w/run_and_store.py index 298bb614..02cc166b 100644 --- a/models/fns_clean_w/run_and_store.py +++ b/models/fns_clean_w/run_and_store.py @@ -17,9 +17,12 @@ def _parse_args(): """Parse and return commandline arguments""" parser = argparse.ArgumentParser() - parser.add_argument("-x", "--xslib", type=str) - parser.add_argument("-t", "--when", type=str, default='n/a') - parser.add_argument("-w", "--where", type=str, default='n/a') + parser.add_argument("-x", "--xslib", type=str, + help="Strign with Cross section library name and version (e.g. 'FENDL-2.3')") + parser.add_argument("-t", "--when", type=str, default='n/a', + help="String with the month and year the simulation is run as (e.g. 'June 2021')") + parser.add_argument("-w", "--where", type=str, default='n/a', + help="String with the place/institution where the simulation is run (e.g. 'MIT-PSFC')") args = parser.parse_args() @@ -45,7 +48,7 @@ def main(): p.wait() # read statepoint file - openmc_file = ofb.ResultsFromOpenmc('statepoint.100.h5', 'results') + openmc_file = ofb.ResultsFromOpenmc('results/statepoint.100.h5') # openmc hdf file filename = ofb.build_hdf_filename( diff --git a/models/fns_duct/openmc_model.py b/models/fns_duct/openmc_model.py index 9b24f646..6d359372 100644 --- a/models/fns_duct/openmc_model.py +++ b/models/fns_duct/openmc_model.py @@ -10,10 +10,12 @@ def _parse_args(): """Parse and return commandline arguments""" parser = argparse.ArgumentParser() - parser.add_argument("-b", "--batches", type=int, default=100) - parser.add_argument("-p", "--particles", type=int, default=int(1e9)) - parser.add_argument("-s", "--threads", type=int) - parser.add_argument("-c", "--cwd", type=str) + parser.add_argument("-b", "--batches", type=int, default=100, + help='Number of batches to simulate (int)') + parser.add_argument("-p", "--particles", type=int, + default=int(1e9), help='Number of particles per batch (int)') + parser.add_argument("-s", "--threads", type=int, + help='Number of threads to use in the simulation (int)') args = parser.parse_args() diff --git a/models/fns_duct/postprocessing.ipynb b/models/fns_duct/postprocessing.ipynb index ebc4c7e8..7fdb1525 100644 --- a/models/fns_duct/postprocessing.ipynb +++ b/models/fns_duct/postprocessing.ipynb @@ -41,9 +41,9 @@ "outputs": [], "source": [ "# read sinbad data\n", - "experiment_file = ofb.ResultsFromDatabase('experiment.h5', path='results_database')\n", - "mcnp_jendl33_file = ofb.ResultsFromDatabase('mcnp-4b-c_jendl33.h5', path='results_database')\n", - "mcnp_fendl2_file = ofb.ResultsFromDatabase('mcnp-4b-c_fendl2.h5', path='results_database')" + "experiment_file = ofb.ResultsFromDatabase('results_database/experiment.h5')\n", + "mcnp_jendl33_file = ofb.ResultsFromDatabase('results_database/mcnp-4b-c_jendl33.h5')\n", + "mcnp_fendl2_file = ofb.ResultsFromDatabase('results_database/mcnp-4b-c_fendl2.h5')" ] }, { @@ -53,8 +53,8 @@ "outputs": [], "source": [ "# read openmc results in results_database/\n", - "openmc_fendl3_file = ofb.ResultsFromDatabase('openmc-0-14-0_fendl32b.h5', path='results_database')\n", - "openmc_endfb8_file = ofb.ResultsFromDatabase('openmc-0-14-0_endfb80.h5', path='results_database')" + "openmc_fendl3_file = ofb.ResultsFromDatabase('results_database/openmc-0-14-0_fendl32b.h5')\n", + "openmc_endfb8_file = ofb.ResultsFromDatabase('results_database/openmc-0-14-0_endfb80.h5')" ] }, { diff --git a/models/fns_duct/run_and_store.py b/models/fns_duct/run_and_store.py index bdf9e229..06cfc8ab 100644 --- a/models/fns_duct/run_and_store.py +++ b/models/fns_duct/run_and_store.py @@ -13,9 +13,12 @@ def _parse_args(): """Parse and return commandline arguments""" parser = argparse.ArgumentParser() - parser.add_argument("-x", "--xslib", type=str) - parser.add_argument("-t", "--when", type=str, default='n/a') - parser.add_argument("-w", "--where", type=str, default='n/a') + parser.add_argument("-x", "--xslib", type=str, + help="Strign with Cross section library name and version (e.g. 'FENDL-2.3')") + parser.add_argument("-t", "--when", type=str, default='n/a', + help="String with the month and year the simulation is run as (e.g. 'June 2021')") + parser.add_argument("-w", "--where", type=str, default='n/a', + help="String with the place/institution where the simulation is run (e.g. 'MIT-PSFC')") args = parser.parse_args() @@ -41,7 +44,7 @@ def main(): p.wait() # read statepoint file - openmc_file = ofb.ResultsFromOpenmc('statepoint.100.h5', 'results') + openmc_file = ofb.ResultsFromOpenmc('results/statepoint.100.h5') # store activation foil results xaxis_name = 'Detector No.' diff --git a/notebooks/plotting_results.ipynb b/notebooks/plotting_results.ipynb index fcf9af8e..8343ebe7 100644 --- a/notebooks/plotting_results.ipynb +++ b/notebooks/plotting_results.ipynb @@ -33,10 +33,10 @@ "outputs": [], "source": [ "# experimental results\n", - "experiment_file = ofb.ResultsFromDatabase(filename='experiment.h5', path='example_database')\n", + "experiment_file = ofb.ResultsFromDatabase(file='example_database/experiment.h5')\n", "experiment_results = experiment_file.get_tally_dataframe(tally_name='rr_nb93')\n", "# mcnp results \n", - "mcnp_file = ofb.ResultsFromDatabase('mcnp-4b-c_fendl2.h5', path='example_database')\n", + "mcnp_file = ofb.ResultsFromDatabase(file='example_database/mcnp-4b-c_fendl2.h5')\n", "mcnp_results = mcnp_file.get_tally_dataframe(tally_name='rr_nb93')" ] }, diff --git a/notebooks/push_openmc_to_database.ipynb b/notebooks/push_openmc_to_database.ipynb index c505af41..c3d370c8 100644 --- a/notebooks/push_openmc_to_database.ipynb +++ b/notebooks/push_openmc_to_database.ipynb @@ -31,7 +31,7 @@ "metadata": {}, "outputs": [], "source": [ - "openmc_results = ofb.ResultsFromOpenmc(statepoint_file='example_statepoint.100.h5', path='example_results')" + "openmc_results = ofb.ResultsFromOpenmc(file='example_results/example_statepoint.100.h5')" ] }, { @@ -472,7 +472,7 @@ } ], "source": [ - "openmc_file = ofb.ResultsFromDatabase(filename='openmc-0-13-3_fendl32b.h5', path='example_database')\n", + "openmc_file = ofb.ResultsFromDatabase(file='example_database/openmc-0-13-3_fendl32b.h5')\n", "openmc_file.get_tally_dataframe(tally_name='rr_onaxis1_nb93')" ] }, diff --git a/notebooks/read_database_hdf.ipynb b/notebooks/read_database_hdf.ipynb index 0a4e1ff8..eff54a48 100644 --- a/notebooks/read_database_hdf.ipynb +++ b/notebooks/read_database_hdf.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -23,17 +23,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "First we need to instantiate a `ResultsFromDatabase` object by providing the name of the file to read (`filename`) and its path (`path`)." + "First we need to instantiate a `ResultsFromDatabase` object by providing the path to the file, including the name (`file`)." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "experiment_file = ofb.ResultsFromDatabase(filename='experiment.h5', path='example_database')\n", - "mcnp_fendl2_file = ofb.ResultsFromDatabase(filename='mcnp-4b-c_fendl2.h5', path='example_database')" + "experiment_file = ofb.ResultsFromDatabase(file='example_database/experiment.h5')\n", + "mcnp_fendl2_file = ofb.ResultsFromDatabase(file='example_database/mcnp-4b-c_fendl2.h5')" ] }, { @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -97,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -161,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -194,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -218,7 +218,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -333,7 +333,7 @@ "10 11 NaN NaN" ] }, - "execution_count": 13, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -353,7 +353,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 9, "metadata": {}, "outputs": [ { diff --git a/notebooks/read_openmc_statepoints.ipynb b/notebooks/read_openmc_statepoints.ipynb index 9d2a062a..af3b0b06 100644 --- a/notebooks/read_openmc_statepoints.ipynb +++ b/notebooks/read_openmc_statepoints.ipynb @@ -38,7 +38,7 @@ "metadata": {}, "outputs": [], "source": [ - "statepoint = ofb.ResultsFromOpenmc(statepoint_file='example_statepoint.100.h5', path='example_results')" + "statepoint = ofb.ResultsFromOpenmc(file='example_results/example_statepoint.100.h5')" ] }, { diff --git a/src/openmc_fusion_benchmarks/__init__.py b/src/openmc_fusion_benchmarks/__init__.py index 6d655ed6..730167ef 100644 --- a/src/openmc_fusion_benchmarks/__init__.py +++ b/src/openmc_fusion_benchmarks/__init__.py @@ -3,3 +3,4 @@ from openmc_fusion_benchmarks.read_results import * from openmc_fusion_benchmarks.visualize import * from openmc_fusion_benchmarks.utils import * +import openmc_fusion_benchmarks.data diff --git a/src/openmc_fusion_benchmarks/data/__init__.py b/src/openmc_fusion_benchmarks/data/__init__.py new file mode 100644 index 00000000..cd8ca009 --- /dev/null +++ b/src/openmc_fusion_benchmarks/data/__init__.py @@ -0,0 +1,6 @@ +from .data_conventions import * +from .sandy_wrapper import * +from .modify_xs_xml import * +from .tmc_engine import * +from .stats_analysis import * +from .jade_sphere import jade_sphere diff --git a/src/openmc_fusion_benchmarks/data/data_conventions.py b/src/openmc_fusion_benchmarks/data/data_conventions.py new file mode 100644 index 00000000..8fb1a551 --- /dev/null +++ b/src/openmc_fusion_benchmarks/data/data_conventions.py @@ -0,0 +1,98 @@ +import openmc.data +from typing import Union + + +def zaid_to_zam(zaid: int) -> tuple: + """Converts a ZAID to Z, A, and M. + + Parameters + ---------- + zaid : int + nuclide ZAID + + Returns + ------- + tuple + Z, A, and M values + """ + zaid_str = str(zaid) + + # Extract Z, A, and M based on ZAID length + if len(zaid_str) == 4: # Handles cases like H-1 (1001) + Z = int(zaid_str[0]) # First digit for Z + A = int(zaid_str[1:]) # Last 3 digits for A + M = 0 # Assuming ground state if no additional digit + elif len(zaid_str) == 5: # Typical ZAID with 5 digits + Z = int(zaid_str[:2]) # First 2 digits for Z + A = int(zaid_str[2:]) # Last 3 digits for A + M = 0 # Assuming ground state + elif len(zaid_str) == 6: # ZAID with 6 digits, includes isomeric state + Z = int(zaid_str[:3]) # First 3 digits for Z + A = int(zaid_str[3:5]) # Next 2 digits for A + M = int(zaid_str[5]) # Last digit represents isomeric state + + return (Z, A, M) + + +def get_nuclide_zaid(nuclide): + """Gets the ZAID of a nuclide from its name as a GNDS string (e.g. 'H1', + 'U238) or as a ZAM tuple (e.g. (1, 1, 0)). + See openmc.data.zam() for more details. + + Parameters + ---------- + nuclide : int or str or tuple + The nuclide identifier or name + + Returns + ------- + int + The ZAID of the nuclide + """ + if type(nuclide) == int: + return nuclide + elif type(nuclide) == str: + return openmc.data.zam(nuclide)[0]*1000 + openmc.data.zam(nuclide)[1] + elif type(nuclide) == tuple: + return nuclide[0]*1000 + nuclide[1] + + +def get_nuclide_gnds(nuclide: Union[str, int]) -> str: + """Gets the GNDS name from a nuclide ZAID + + Parameters + ---------- + nuclide : str or int + The nuclide ZAID or GNDS name + + Returns + ------- + str + The GNDS name of the nuclide + """ + if type(nuclide) == str: + return nuclide + elif type(nuclide) == int: + zam = zaid_to_zam(nuclide) + return openmc.data.gnds_name(zam[0], zam[1], zam[2]) + + +def get_reaction_mt(reaction: Union[str, int]) -> int: + """Gets the MT value from a reaction name + + Parameters + ---------- + reaction : str or int + The reaction name or MT value + + Returns + ------- + int + The MT value of the reaction + """ + try: + mt = openmc.data.REACTION_MT[reaction] + except KeyError: + mt = reaction + + return mt diff --git a/src/openmc_fusion_benchmarks/data/jade_sphere.py b/src/openmc_fusion_benchmarks/data/jade_sphere.py new file mode 100644 index 00000000..21959eeb --- /dev/null +++ b/src/openmc_fusion_benchmarks/data/jade_sphere.py @@ -0,0 +1,79 @@ +import openmc + + +def jade_sphere(material: openmc.Material, particles: int = int(1e5), + photon_transport: bool = False, nreactions=None, + greactions=None) -> openmc.model.Model: + + materials = openmc.Materials([material]) + + # geometry + s1 = openmc.Sphere(r=5.) + s2 = openmc.Sphere(r=50.) + s3 = openmc.Sphere(r=60.0, boundary_type='vacuum') + + region1 = -s1 + region2 = +s1 & -s2 + region3 = +s2 & -s3 + + cell1 = openmc.Cell(region=region1, fill=None) + cell2 = openmc.Cell(region=region2, fill=material) + cell3 = openmc.Cell(region=region3, fill=None) + + geometry = openmc.Geometry([cell1, cell2, cell3]) + + # settings + space = openmc.stats.Point() + angle = openmc.stats.Isotropic() + energy = openmc.stats.Discrete([14.1e6], [1]) + source = openmc.IndependentSource(space=space, angle=angle, energy=energy) + + settings = openmc.Settings(run_mode='fixed source') + settings.particles = particles + settings.source = source + settings.batches = 100 + settings.output = {'tallies': False} + + tallies_file = openmc.Tallies() + # tallies + cell2_filter = openmc.CellFilter(cell2) + s2_filter = openmc.SurfaceFilter(s2) + neutron_filter = openmc.ParticleFilter(['neutron']) + + # neutron tallies + t = openmc.Tally(name='n_flux') + t.filters = [cell2_filter, neutron_filter] + t.scores = ['flux'] + tallies_file.append(t) + + t = openmc.Tally(name='n_leakage') + t.filters = [s2_filter, neutron_filter] + t.scores = ['current'] + tallies_file.append(t) + + if nreactions is not None: + for reaction in nreactions: + t = openmc.Tally(name=f'n_{reaction}') + t.filters = [cell2_filter, neutron_filter] + t.scores = [reaction] + tallies_file.append(t) + + if photon_transport is True: + settings.photon_transport = True + photon_filter = openmc.ParticleFilter(['photon']) + t = openmc.Tally(name='g_flux') + t.filters = [cell2_filter, photon_filter] + t.scores = ['flux'] + tallies_file.append(t) + t = openmc.Tally(name='g_leakage') + t.filters = [s2_filter, photon_filter] + t.scores = ['current'] + tallies_file.append(t) + if nreactions is not None: + for reaction in greactions: + t = openmc.Tally(name=f'g_{reaction}') + t.filters = [cell2_filter, photon_filter] + t.scores = [reaction] + tallies_file.append(t) + + return openmc.model.Model(geometry, materials, settings, tallies_file) diff --git a/src/openmc_fusion_benchmarks/data/modify_xs_xml.py b/src/openmc_fusion_benchmarks/data/modify_xs_xml.py new file mode 100644 index 00000000..aeefb3ed --- /dev/null +++ b/src/openmc_fusion_benchmarks/data/modify_xs_xml.py @@ -0,0 +1,86 @@ +import openmc +import os + + +_this_script_dir = os.path.dirname(os.path.abspath(__file__)) + + +def get_env_variable(var_name: str) -> str: + """Get the value of an environment variable. + + Parameters + ---------- + var_name : str + The name of the environment variable. + + Returns + ------- + str + The value of the environment variable. + """ + value = os.getenv(var_name) + if value is None: + return f"Environment variable '{var_name}' is not set." + return value + + +def rewrite_xs_xml(new_xs_file: str = 'cross_sections_mod.xml'): + """Rewrite the cross_sections.xml file locally, in order not to modify the + original file. + + Parameters + ---------- + new_xs_file : str, optional + Name of the new xs file to be created, + by default 'cross_sections_mod.xml' + """ + # read xs file + model_xs_file = get_env_variable('OPENMC_CROSS_SECTIONS') + myxs = openmc.data.DataLibrary.from_xml(model_xs_file) + myxs.export_to_xml(new_xs_file) + + +def create_xs_dict(xs_h5_file: str, nuclide: str, type: str = 'neutron') -> dict: + """Create a dictionary with the correct format for an cross_sections.xml file + for a given target nuclide and the path to its corresponding h5 xs file. + + + Parameters + ---------- + xs_h5_file : str + Path to the target nuclide h5 xs file + nuclide : str + Nuclide name in gnds format + type : str, optional + Type of incident particle (i.e. neutron, photon), by default 'neutron' + + Returns + ------- + dict + Dictionary with the path to the h5 xs file, the type of incident + particle and the target nuclide + """ + return {'path': xs_h5_file, 'type': type, 'materials': [nuclide]} + + +def perturb_xs_xml(xs_file: str, xs_h5_file: str, nuclide: str): + """Perturb the cross_sections.xml file by replacing the original path of a + nuclide xs with a new path to a new (perturbed) h5 xs file. + + Parameters + ---------- + xs_file : str + Name of the xs xml file to perturb + xs_h5_file : str + Path to the new (perturbed) h5 xs file + nuclide : str + Nuclide name in gnds format + """ + # read xs file + myxs = openmc.data.DataLibrary.from_xml(xs_file) + try: + myxs.libraries.get_by_material(nuclide)['path'] = xs_h5_file + except TypeError: + myxs.append(create_xs_dict(xs_h5_file, nuclide)) + # export to modified cross_sections xml file + myxs.export_to_xml(xs_file) diff --git a/src/openmc_fusion_benchmarks/data/sandy_wrapper.py b/src/openmc_fusion_benchmarks/data/sandy_wrapper.py new file mode 100644 index 00000000..209e3e98 --- /dev/null +++ b/src/openmc_fusion_benchmarks/data/sandy_wrapper.py @@ -0,0 +1,200 @@ +from .data_conventions import get_nuclide_zaid, get_nuclide_gnds, get_reaction_mt +import os +import glob +import argparse +import sandy +import openmc +import openmc.data +from typing import Union + + +def remove_ace_files(directory: str, lib_name: str): + """Remove ACE files generated by sandy from a given directory. + + Parameters + ---------- + directory : str + Path to the directory where the ACE files are located + lib_name : str + Name of the nuclear data library used to generate the ACE files + """ + # List of extensions to remove + extensions = ['03c', '03c.xsd', lib_name] + + # Loop through each extension and remove matching files + for ext in extensions: + files_to_remove = glob.glob(os.path.join(directory, f'*.{ext}')) + for file_path in files_to_remove: + try: + os.remove(file_path) + print(f"Removed {file_path}") + except Exception as e: + print(f"Error removing {file_path}: {e}") + + +def get_ace_files(nsamples: int, lib_name: str, nuclide: Union[str, int], + reaction: Union[str, int], nprocesses: int, error: float): + """Generate ACE files for a given nuclide and reaction from a defined + nuclear data library using sandy. + + Parameters + ---------- + nsamples : int + Number of perturbed cross section samples to generate + lib_name : str + Name of the nuclear data library to generate the ACE files from + nuclide : str or int + Identifier of the nuclide for which the cross section is perturbed + (GNDS, ZAID) + reaction : str or int + String name or MT value for the specific reaction to perturb + nprocesses : int + Number of processes for parallel processing + error : float + Error tolerance for processing in sandy + + Returns + ------- + list + List of ACE files generated + """ + # convert nuclide to ZAID + nuclide_zaid = get_nuclide_zaid(nuclide) + reaction_mt = get_reaction_mt(reaction) + tape = sandy.get_endf6_file(lib_name, "xs", nuclide_zaid*10, to_file=True) + + # Generate perturbations + perturbations = tape.get_perturbations( + nsamples, + njoy_kws=dict( + err=error, + chi=False, + mubar=False, + xs=True, + nubar=False, + verbose=True, + errorr33_kws=dict(mt=reaction_mt) + ), + ) + + # Apply perturbations and generate ACE files + ace_files = tape.apply_perturbations( + perturbations, + processes=nprocesses, + njoy_kws=dict(err=error), + to_ace=True, + to_file=True, + ace_kws=dict( + err=error, + temperature=294, + verbose=True, + purr=True, + heatr=True, + thermr=True, + gaspr=True, + groupr=True, + errorr=True, + heatr_kws={'local': True} + ), + verbose=True, + ) + + # Optionally return or process 'outs' if needed + return ace_files + + +def ace_to_hdf5(nsamples: int, lib_name: str, nuclide: Union[str, int], + remove_ace: bool = True): + """Convert ACE files to HDF5 using OpenMC. + + Parameters + ---------- + nsamples : int + Number of perturbed cross section samples to convert + lib_name : str + Name of the nuclear data library used to generate the ACE files + nuclide : str or int + Identifier of the nuclide for which the cross section is perturbed + (GNDS, ZAID) + remove_ace : bool, optional + removes the original ACE files, by default True + """ + # convert nuclide to gnds and ZAID + nuclide_gnds = get_nuclide_gnds(nuclide) + nuclide_zaid = get_nuclide_zaid(nuclide) + + directory = f"{nuclide_gnds}_{lib_name}" + if not os.path.exists(directory): + os.makedirs(directory) + + for n in range(0, nsamples): + acefile = f"{nuclide_zaid}_{n}.03c" + h5file = f"{directory}/{nuclide_gnds}_{n}_{lib_name}.h5" + + # Convert ACE to HDF5 using OpenMC + try: + nuc_data = openmc.data.IncidentNeutron.from_ace(acefile) + print(f'Writing to {os.getcwd()}/{h5file}') + nuc_data.export_to_hdf5(h5file) + except FileNotFoundError: + print(f'Error: ACE file {acefile} not found.') + except Exception as e: + print(f'Error processing {acefile}: {e}') + + if remove_ace: + remove_ace_files('', lib_name) + + +def perturb_to_hdf5(nsamples: int, lib_name: str, nuclide: Union[str, int], + reaction: Union[str, int], nprocesses: int = 1, + error: float = .001): + """Perturb nuclear data and convert to HDF5 format. + + Parameters + ---------- + nsamples : int + Number of perturbed cross section samples to generate + lib_name : str + Name of the nuclear data library to generate the ACE files from + nuclide : int or str + Identifier of the nuclide for which the cross section is perturbed + (GNDS, ZAID) + reaction : str or int + Str name or MT value for the specific reaction to perturb + nprocesses : int, optional + Number of processes for parallel processing, by default 1 + error : float, optional + Error tolerance for processing in sandy, by default .001 + """ + get_ace_files(nsamples, lib_name, nuclide, reaction, nprocesses, error) + ace_to_hdf5(nsamples, lib_name, nuclide, remove_ace=True) + + +def main(): + """Main function to run the perturbation and conversion to HDF5 + via command line. + """ + parser = argparse.ArgumentParser( + description="Generate ACE files with perturbed nuclear data.") + parser.add_argument("-n", "--nuclide", required=True, + help="Nuclide identifier (ZA number)") + parser.add_argument("-xs", "--lib_name", type=str, default=1, + help="Cross section choice ['JEFF_32', 'JEFF_33', 'ENDFB_71', 'ENDFB_80', 'JENDL_40U', 'IRDFF_2']") + parser.add_argument("-r", "--reaction", type=Union[str, int], + nargs='+', help="MT value for specific reaction") + parser.add_argument("-e", "--error", type=float, + default=0.001, help="Error tolerance for processing") + parser.add_argument("-p", "--nprocesses", type=int, default=1, + help="Number of processes for parallel processing") + parser.add_argument("-ns", "--nsamples", type=int, + default=1, help="Number of perturbations") + + args = parser.parse_args() + + # Call function with arguments from command line + perturb_to_hdf5(args.nsamples, args.lib_name, args.nuclide, args.reaction, + args.nprocesses) + + +if __name__ == "__main__": + main() diff --git a/src/openmc_fusion_benchmarks/data/stats_analysis.py b/src/openmc_fusion_benchmarks/data/stats_analysis.py new file mode 100644 index 00000000..1ec08755 --- /dev/null +++ b/src/openmc_fusion_benchmarks/data/stats_analysis.py @@ -0,0 +1,10 @@ +import numpy as np +from scipy.stats import norm + + +def get_gauss(mu, sigma): + x = np.linspace(mu - 4*sigma, mu + 4*sigma, 1000) + y = norm.pdf(x, mu, sigma) + y = y / max(y) + + return x, y diff --git a/src/openmc_fusion_benchmarks/data/tmc_engine.py b/src/openmc_fusion_benchmarks/data/tmc_engine.py new file mode 100644 index 00000000..9728655b --- /dev/null +++ b/src/openmc_fusion_benchmarks/data/tmc_engine.py @@ -0,0 +1,73 @@ +from .sandy_wrapper import perturb_to_hdf5 +from .data_conventions import get_nuclide_gnds +from .modify_xs_xml import rewrite_xs_xml, perturb_xs_xml +import os +import openmc +import numpy as np + + +def tmc_engine(model: openmc.Model, nsamples: int, lib_name: str, nuclide, + reaction: int = None, perturb_xs: bool = True): + """Runs a TMC simulation on a given OpenMC model object. + With perturb_xs=True it is possible to perturb the cross sections of a + specific nuclide and reaction from a given nuclear data library + automatically before the starting of the actual TMC simulation. + The results of the TMC simulation are stored in a .h5 file as OpenMC + tallies in PandasDataFrame format. + + Parameters + ---------- + model : openmc.Model + OpenMC model object to run TMC simulations on + nsamples : int + Number of samples to run in the TMC simulation + (i.e. number of times the xs is perturbed) + lib_name : str + Name of the nuclear data library to perturb the xs from + (e.g. 'ENDF/B-VIII.0') + nuclide : str or int + Identifier of the nuclide for which the cross section is perturbed + (GNDS, ZAID or ZAM) + reaction : int, optional + MT value for the specific reaction to perturb, by default None + perturb_xs : bool, optional + Flag for the automatic generation of perturbed .h5 xs files right + before running the TMC simulation. Set to False if the use has already + a set of perturbed xs in .h5 format + to point to, by default True + """ + + # convert nuclide to gnds name + nuclide = get_nuclide_gnds(nuclide) + xs_file = f'cross_sections_mod.xml' + path_to_file = f'tmc_results_{nuclide}.h5' + + # runs sandy and generates perturbed xs only if perturb_xs is True + if perturb_xs: + perturb_to_hdf5(nsamples, lib_name, nuclide, reaction, nprocesses=1, + error=.001) + + for n in np.arange(nsamples): + + rewrite_xs_xml(new_xs_file=xs_file) + + directory = f"{nuclide}_{lib_name}" + xs_h5_file = f"{directory}/{nuclide}_{n}_{lib_name}.h5" + perturb_xs_xml(xs_file, xs_h5_file, nuclide) + openmc.config['cross_sections'] = xs_file + + # run simulation + model.run() + + # postprocess result + sp_name = f'statepoint.{model.settings.batches}.h5' + sp = openmc.StatePoint(sp_name) + # open tally and push to hdf5 + for t in sp.tallies: + tally = sp.get_tally(id=t) + tally_df = tally.get_pandas_dataframe() + tally_df.to_hdf(path_to_file, tally.name+f'_{n}', mode='a', + format='table', data_columns=True, index=False) + + os.remove('summary.h5') + os.remove(sp_name) diff --git a/src/openmc_fusion_benchmarks/read_results.py b/src/openmc_fusion_benchmarks/read_results.py index 81d4d66f..5d516867 100644 --- a/src/openmc_fusion_benchmarks/read_results.py +++ b/src/openmc_fusion_benchmarks/read_results.py @@ -2,13 +2,15 @@ import openmc from pathlib import Path from typing import Iterable +import numpy as np import pandas as pd +import re _del_columns = ['cell', 'particle', 'nuclide', 'score', 'energyfunction'] -def to_hdf(df: pd.DataFrame, hdf_file: str, tally_name: str, xs_library: str = None, - xaxis_name: str = None, path_to_folder: str = '', +def to_hdf(df: pd.DataFrame, file: str, tally_name: str, xs_library: str = None, + xaxis_name: str = None, when: str = 'n/a', where: str = 'n/a', code_version: str = None, batches: int = None, particles_per_batch: int = None, literature: int = 'n/a'): """Stores a DataFrame to a given hdf5 file. Useful function to generate new @@ -18,8 +20,8 @@ def to_hdf(df: pd.DataFrame, hdf_file: str, tally_name: str, xs_library: str = N ---------- df : pd.DataFrame DataFrame of results to store in the hdf5 file - hdf_file : str - name of the hdf5 file of results + file : str + name of the hdf5 file of results. Can include the path to the file tally_name : str name of the tally to store xs_library : str, optional @@ -28,9 +30,6 @@ def to_hdf(df: pd.DataFrame, hdf_file: str, tally_name: str, xs_library: str = N xaxis_name : str, optional name of the x_axis to store in order to be retrieved with the ResultsFromDatabase.get_tally_xaxis method, by default None - path_to_folder : str, optional - path to the folder where the hdf5 file is/has to be stored, - by default '' when : str, optional Can be the year(s) (YYYY-YYYY) or the month and year (Month, YYYY) of the model run, by default 'n/a' @@ -50,15 +49,13 @@ def to_hdf(df: pd.DataFrame, hdf_file: str, tally_name: str, xs_library: str = N by default None """ - path = Path(path_to_folder) - # merge path to hdf file - path_to_file = path / hdf_file + filepath = Path(file) # write the tally in the hdf file - df.to_hdf(path_to_file, tally_name, mode='a', + df.to_hdf(filepath, tally_name, mode='a', format='table', data_columns=True, index=False) # write attributes to the hdf file - with h5py.File(path_to_file, 'a') as f: + with h5py.File(filepath, 'a') as f: f[tally_name + '/table'].attrs['x_axis'] = xaxis_name f.attrs['when'] = str(when) f.attrs['where'] = where @@ -102,6 +99,53 @@ def build_hdf_filename(code_name: str, code_version: Iterable, xs_library: str) return filename +# class ResultsFrom(ABC): +# def __init__(self, file: str): +# """ResultsFrom class constructor + +# Parameters +# ---------- +# file : str +# Name of the hdf file present in the results_database folder. +# Can include the path to the file +# """ + +# self.filename = file.strip().split('/') +# self.filepath = Path(file) + +# def list_tallies(self): +# """Prints the names of all the tallies available in the hdf file +# """ +# with h5py.File(self.filepath) as f: +# print(f.keys()) + +# def get_tally_dataframe(self, tally_name: str) -> pd.DataFrame: +# """Retrieves the results of a given tally in a Pandas DataFrame format. +# It relies on the openmc.Statepoint().get_tally().get_pandas_dataframe() +# method + +# Parameters +# ---------- +# tally_name : str +# Exact name of the tally in the hdf file + +# Returns +# ------- +# pd.DataFrame +# DataFrame with tally results +# """ +# with h5py.File(self.filepath) as f: +# df = pd.DataFrame(f[tally_name+'/table'][()]).drop(columns='index') +# # decode hdf5 strings to strings if necessary +# try: +# df[self.get_tally_xaxis(tally_name)] = [el.decode() +# for el in df[self.get_tally_xaxis(tally_name)]] +# except: +# pass + +# return df + + class ResultsFromDatabase: """This class takes in a hdf file and its path and generates a generic object by reading it. It is specifically designed for hdf files present @@ -110,27 +154,23 @@ class ResultsFromDatabase: that have been stored there. """ - def __init__(self, filename: str, path: str = ''): + def __init__(self, file: str): """ResultsFromDatabase class constructor Parameters ---------- - filename : str - Name of the hdf file present in the results_database folder - path : str, optional - path to the hdf file, by default 'results_database' + file : str + Name of the hdf file present in the results_database folder. + Can include the path to the file """ - self.filename = filename - source_folder = Path(path) - - # merge path to the file - self._myfile = source_folder / filename + self.filename = file.strip().split('/') + self.filepath = Path(file) def list_tallies(self): """Prints the names of all the tallies available in the hdf file """ - with h5py.File(self._myfile) as f: + with h5py.File(self.filepath) as f: print(f.keys()) def get_tally_dataframe(self, tally_name: str) -> pd.DataFrame: @@ -148,7 +188,7 @@ def get_tally_dataframe(self, tally_name: str) -> pd.DataFrame: pd.DataFrame DataFrame with tally results """ - with h5py.File(self._myfile) as f: + with h5py.File(self.filepath) as f: df = pd.DataFrame(f[tally_name+'/table'][()]).drop(columns='index') # decode hdf5 strings to strings if necessary try: @@ -177,7 +217,7 @@ def get_tally_xaxis(self, tally_name: str) -> str: str Name used for the dataframe column with the x-axis info """ - with h5py.File(self._myfile) as f: + with h5py.File(self.filepath) as f: return f[tally_name+'/table'].attrs['x_axis'] @property @@ -190,7 +230,7 @@ def literature_info(self) -> str: str DOI or link to the publication """ - with h5py.File(self._myfile) as f: + with h5py.File(self.filepath) as f: try: return f.attrs['literature'] except KeyError: @@ -205,7 +245,7 @@ def when(self) -> str: str Experiment or simulation execution year """ - with h5py.File(self._myfile) as f: + with h5py.File(self.filepath) as f: try: return f.attrs['when'] except KeyError: @@ -220,7 +260,7 @@ def where(self) -> str: str Experiment or simulation execution place """ - with h5py.File(self._myfile) as f: + with h5py.File(self.filepath) as f: try: return f.attrs['where'] except KeyError: @@ -236,7 +276,7 @@ def code_version(self) -> str: str Code version """ - with h5py.File(self._myfile) as f: + with h5py.File(self.filepath) as f: try: return f.attrs['code_version'] except KeyError: @@ -252,7 +292,7 @@ def xs_library(self) -> str: str Nuclear data library name """ - with h5py.File(self._myfile) as f: + with h5py.File(self.filepath) as f: try: return f.attrs['xs_library'] except KeyError: @@ -283,29 +323,25 @@ class ResultsFromOpenmc: results_database folder it is necessary to use ResultsFromDatabase class. """ - def __init__(self, statepoint_file: str = 'statepoint.100.h5', path: str = 'results'): + def __init__(self, file: str = 'statepoint.100.h5'): """ResultsFromOpenmc class constructor. Parameters ---------- - statepoint_file : str, optional - name of the statepoint.h5 file, by default 'statepoint.100.h5' - path : str, optional - path to the hdf file, by default 'results' + file : str, optional + name of the statepoint.h5 file. Can include the path to the file, + by default 'statepoint.100.h5' """ - self.statepoint_file = statepoint_file - source_folder = Path(path) - # merge path to statepoint file - self._myfile = source_folder / statepoint_file + self.filename = file.strip().split('/') + self.filepath = Path(file) # open statepoint file with openmc - self.statepoint = openmc.StatePoint(self._myfile) + self.statepoint = openmc.StatePoint(self.filepath) def list_tallies(self): """Prints the names of all the tallies available in the statepoint.h5 """ - sp = self.statepoint - for k in sp.tallies.keys(): - print(sp.tallies[k].name) + for k in self.statepoint.tallies.keys(): + print(self.statepoint.tallies[k].name) def get_tally_dataframe(self, tally_name: str, normalize_over: Iterable = None) -> pd.DataFrame: """Retrieves the results of a given tally in a Pandas DataFrame format. @@ -399,8 +435,9 @@ def tally_to_hdf(self, tally_name: str, normalize_over: Iterable, xs_library: st Name of the institution that run the simulation """ - hdf_file = build_hdf_filename( + filename = build_hdf_filename( 'openmc', self.get_openmc_version, xs_library) + file = path_to_database + '/' + filename # extract tally in dataframe format from statepoint file tally_df = self.get_tally_dataframe( @@ -417,6 +454,77 @@ def tally_to_hdf(self, tally_name: str, normalize_over: Iterable, xs_library: st code_version = 'openmc-' + '.'.join(map(str, self.get_openmc_version)) - to_hdf(tally_df, hdf_file, tally_name, xs_library, xaxis_name, - path_to_database, when, where, code_version, self.get_batches, - self.get_particles_per_batch, literature) + to_hdf(tally_df, file, tally_name, xs_library, xaxis_name, when, where, + code_version, self.get_batches, self.get_particles_per_batch, literature) + + +class ResultsFromTMC(ResultsFromDatabase): + def __init__(self, file): + super().__init__(file) + + def list_tally_names(self): + # Create a set to store unique base names + base_names = set() + + # Regular expression to capture the pattern 'name_N' + pattern = re.compile(r"(.+?)_(\d+)$") + + # Open the HDF5 file + with h5py.File(self.filepath, 'r') as hdf: + # List all datasets in the HDF5 file + dataset_names = list(hdf.keys()) + + # Loop through the dataset names + for name in dataset_names: + match = pattern.match(name) + if match: + # Capture the base name + base_name = match.group(1) + # Add to the set of unique base names + base_names.add(base_name) + + print(list(base_names)) + + def find_nsamples(self, tally): + + # Open the HDF5 file + with h5py.File(self.filepath, 'r') as hdf: + # List all datasets in the HDF5 file + dataset_names = list(hdf.keys()) + # Initialize to track the highest N + max_n = -1 + # Loop through the datasets to find the ones that match the pattern base_name_N + for name in dataset_names: + if name.startswith(tally + '_'): + # Extract N and update max_n if N is larger + n = int(name.split('_')[-1]) + if n > max_n: + max_n = n + + if max_n == -1: + msg = f"No datasets found with base name '{tally}' in the HDF5 file." + raise ValueError(msg) + else: + return max_n + + def get_means(self, tally): + mean = [] + nsamples = self.find_nsamples(tally) + with h5py.File(self.filepath, 'r') as f: + for n in range(nsamples): + df = pd.DataFrame( + f[tally+f'_{n}'+'/table'][()]).drop(columns='index') + mean.append(np.array(df['mean'])) + + return np.array(mean) + + def get_stds(self, tally): + stds = [] + nsamples = self.find_nsamples(tally) + with h5py.File(self.filepath, 'r') as f: + for n in range(nsamples): + df = pd.DataFrame( + f[tally+f'_{n}'+'/table'][()]).drop(columns='index') + stds.append(np.array(df['std. dev.'])) + + return np.array(stds)