Discussion: OpenMC state point file support

[yardasol]

Serpent stores its results in plain text files, formatted to be read into Matlab or Octave. OpenMC stores simulation information and results in HDF5 state point files. The best way to process the information in these files is through the OpenMC Python API.

This issue can be closed when functions exists within the Depcode class that utilize the OpenMC Python API to reproduce the behavior of the following functions:

• Depcode
• • read_dep_comp
• • read_depcode_step_param
• • read_depcode_info
• • get_tra_or_dec

[yardasol]

Depcode discussion

read_dep_comp

This function reads the _dep.m file produced from a deleption run in Serpent, and puts the following material data in a dictionary called mats:

• volume
• density
• mass
• burnup
  The function also reads the following values from the

In OpenMC, most of the equivalent depletion run information is stored in a file called depletion_results.h5. There are a few datapoints that don't exist in this file that we would need to create the dicitonary of Materialflow objects.

1. Mass density of each nuclide
2. Total material density

Fortunately, utilzing pyne libraries and information that should be availbile in OpenMC already, we should be able to calculate and/or find these quantities.

Below is an example of what the DepcodeOpenMC version of the function could look like. Note that not all lines are filled in due to the increasing implementational sprawl.

import openmc
import pyne

def read_dep_comp(self, input_file, moment):
        """Reads the OpenMC `depletion_results.h5` file and returns dictionary with
        `Materialflow` object for each burnable material.
        Parameters
        ----------
        input_file : str
            Path to OpenMC `depeltion_results.h5` file.
        moment : int
            Indicates at which moment in the depletion step read the data. `0`
            refers the beginning, `1` refers the end of depletion step.
        Returns
        -------
        mats : dict
            Dictionary that contains `Materialflow` objects.
            ``key``
                Name of burnable material.
            ``value``
                `Materialflow` object holding composition and properties.
        """
        dep = openmc.deplete.ResultsList.from_hdf5(input_file)[moment]
        self.days = dep.time[0]
        # Read material IDs from file
        mat_id = list(dep.mat_to_ind.keys())
        mats = {}
        
        # Make mapped-index-sorted list of nuclide names
        xa = dep.nuc_to_ind.keys()
        i = dep.nuc_to_ind.values()
        iax = dict(zip(i,xa))
        xa_sorted = []
        for j in range(0,dep.n_nuc):
            xa_sorted.append(iax[j])

        for m in mat_id:
            volume = dep.volume[m]
            number_dens = dep.data[0, m] / volume

            # Get the masses of the respective nuclides
            masses = pyne.data.atomic_mass(xa_sorted)
            mass_dens = number_dens * masses

            nucvec = dict(zip(xai, mass_dens))
            mats[m] = Materialflow(nucvec)

            #calculate or get total material density
            mats[m].density =... 
            mats[m].vol = volume

            #calculate or get burnup
            mats[m].burnup =...
        self.get_tra_or_dec(...)

read_depcode_info

This method stores simulation metadata in the sim_info attribute of the Depcode object. The metadata stored and the OpenMC equivalents are the following:

• VERSION : The OpenMC verison is available in summary.h5 or statepoint<n>.h5 output file as a triple of ints.
• TITLE : does not exist in OpenMC at all
• INPUT_FILE_NAME : does not exist in OpenMC. The input filenames in OpenMC are fixed as geometry.xml, settings.xml, and materials.xml. OpenMC runs with the values inside these named files, however the paths they are read from can be specified by the user,
• WORKING_DIRECTORY : The equivalent in OpenMC is the cwd parameter in openmc.run method, however this parameter is not written to any output files, so we would need to track it externally.
• XS_DATA_FILE_PATH : Specified by the OPENMC_CROSS_SECTIONS environment variable OR the <cross_sections> element in materials.xml
• OMP_THREADS : does not exist in OpenMC, may have to obtain from OpenMP directly.
• MPI_TASKS : does not exist in OpenMC, may have to be obtained from MPI directly.
• OPTIMIZATION_MODE : does not exist in OpenMC at all
• BURN_DAYS : I believe the closest thing to this is the time[][2] dataset in the depletion_results.h5 output file.

None of the metadata that OpenMC is missing are necessary per se for the code, however the original author (@andrewryh I believe) must have had good reason to include each of these parameters, so I think that their equivalents should be found and/or calculated to the fullest extent possible. We should specifically discuss how to handle working around metadata that does not exist for OpenMC at all.

read_depcode_step_param

This method stores data from Serpent output for each depletion step and stores in the param attributes of the Depcode object. The Serpent parameters stored and their OpenMC equivalents are the following:

• IMP_KEFF : keff calculated using Serpent's implicit estimator. This does not exist in OpenMC to my knowledge, so we'd have to use one of the keff estimates available in OpenMC.
• CONVERSION_RATIO : does not exist in OpenMC to my knowledge, but we can in theory calculate it using the results in the depletion output files.
• RUNNING_TIME : Not one-to-one available in OpenMC, but similar parameters are written in the statepoint<n>.h5 output file, under runtime
• BURN_DAYS : I believe the closest thing to this is the time[][2] dataset in the depletion_results.h5 output file.
• TOT_POWER : Total neutron fission power. I have not been able to find an equivalent parameter in OpenMC, we may be able to calculate it though.
• MEMSIZE : not available in OpenMC at all
• FWD_ANA_BETA_ZERO : Analog estimate of physical delayed neutron fractions. Not available in OpenMC at all
• FWD_ANA_LAMBDA : Analog estimate of delayed neutron precursor decay constants. Not available in OpenMC at all
• INI_FMASS : Initial fissile mass. Not available in OpenMC, but could be calculated using material + volume data from inputs.
• TOT_FMASS : Total fissile mass. Not available in OpenMC, but could be calculated using material + volume data, along with depletion results.

get_tra_or_dec

[gwenchee]

BTW for a depletion simulation, besides outputting depletion_results.h5, OpenMC also outputs state point h5 files for each depletion step. Depending on what output parameters you need, you might have to take them from those state point files. I suggest setting up a simple experiment for yourself to figure out how to get what outputs you want from an OpenMC depletion simulation. OpenMC's results analysis can get pretty hairy.

[LukeSeifert]

I'm not too familiar with OpenMC or HDF5 files, but since OpenMC gives output in HDF5 format, it may be more convenient to directly save the output data from HDF5 to SaltProc's HDF5 output instead of putting the output into a dictionary. I'm not sure if it would be overall easier that way, but I figure it might save you having to go from HDF5 -> dictionary -> HDF5