Steady State Neutron Flux Calculations

This application mode is used for calculating the equilibrium fission source distribution (and related output values), at a fixed model state.

Note

The name of the application is a bit misleading, as it is not intended only to be used for models in a critical state. In fact, it is frequently used to calculate \(k_{eff}\) for sub- and super critical configurations. However, most of the other outputs (such as power and flux distributions), only make sense for a critical state.

Typical Use Cases

1. Calculate the effective multiplication factor \(k_{eff}\).

2. Compute the equilibrium power distribution, and maximum power density (peaking factor).

3. Compute various flux distributions (and other responses).

4. Calculate kinetics data (e.g. \(\beta_{eff}\)).

Creating an Input Module

An empty input module can be created using the manager utility:

oscar5 MY_REACTOR.manager critical_case MODULE_NAME [options]

This command the following optional arguments:

--package <str>

The subpackage to which this module should be added. The default value is ‘projects’.

--description <str>

A short description of the input module.

--configuration <str>

The configuration module that contains the model used in this script.

--mco <str>

Name (or path) of the model configuration archive that should be used in this script.

Attention

This option can not be specified when --configuration is also specified.

--time-stamp <str>

Time point at which facility state should be recovered (see app_param.time_stamp). Must be a valid datetime.

A typical input module has the following form:

import applications.critical_case as app
from ..configurations.my_conf import model
from core import *

# Create parameter set
ccp = app.parameters()

# Set some base application parameters
cpp.time_stamp = '01-01-2020 00:00:00'

# Set and modify the model
cpp.model = model
cpp.model.set_banks(control.percent_extracted(50))
# etc

# Application specific
cpp.power = 1 * units.MW
# etc

if __name__ == '__main__':
 app.main(parameters=cpp)

Additional Input Parameters

In the following ccp denotes a critical_case parameter set, created as follows:

import applications.critical_cases as app

cpp = app.parameters()

This application supports all the general parameters, as well as the following:

cpp.power

: power

= 1 W

The power used to normalize flux levels.

cpp.power_maps

: bool

= True

Flag indicating that channel power distributions should be calculated.

cpp.mass_map

: bool

= False

If the flag is set, a summary of the current core loading will be written (as a comment block) to the input file.

cpp.kinetics_parameters

: bool

= False

Flag indicating that kinetics parameters should be calculated.

cpp.model.fueled_primitive_powers

: bool or tuple

Set the mesh for detailed power distribution calculations. If set to True, the default mesh (if available) will be used. Otherwise two integers can be specified, with the values denoting the number of radial and axial meshes each fueled primitive will be subdivided by.

How these numbers are interpreted depends on the fuel type present. For example, if the model contains plate assemblies

>>> cpp.model.fueled_primitive_powers = 6, 8

will de divide each plate length into 6 equal pieces and 8 axial pieces. Thus, power will be estimated at 48 positions in each plate. When pin or dispersed fuel type assemblies are used, the radial subdivision is ignored, and pins or compacts are only subdivided axially.

To calculate only the average power in each primitive (plate, pin or compact), use

>>> cpp.model.fueled_primitive_powers = 0, 0

Note

For nodal codes, which typically rely on pre-tabulated data for power reconstruction, the subdivision data is ignored, and the system only checks if this flag was set.

cpp.add_response(r, tag=None)

Adds a response that should be calculated based on the equilibrium flux distribution.

Parameters:

• r – The target response object.

• tag (string) – Re-specify the response tag.

Command Line Usage

This application supports all the standard application modes and options as described in General Application Command Line Interface (CLI).

Typical command line usage

oscar5 MY_REACTOR.projects.my_case --target-mode <MODE> --config-file <CONFIG> run --threads 24

Output Tokens

This application mode hase an extensive set of output tokens, which are grouped by topic in the following sections. See also Using output tokens for general guidelines on using these tokens.

General output tokens

critical_case.multiplication_factor(**kwargs)

Extract the effective multiplication factor \(k_{eff}\).

critical_case.critical_position(bank_names=None, **kwargs)

Extract the bank position(s) used in the calculation.

Parameters:

bank_names (string or list [string]) – Specify which bank position(s) should be extracted. If not specified, the positions of all the banks will be retrieved. These names must correspond to the model bank names, as defined in model.banks.

The return type depends on the value of bank_names:

1. If a single string value, a single travel value, given that bank’s position.

2. If it is a list of bank names, a dict mapping these names to their travel values.

3. If None (the default), a dict mapping all model.banks to their travel values.

Note

If app_param.bank_search was not set, this will simply return the input bank positions, as defined using model.set_banks().

Output tokens related to power distribution

critical_case.power_distribution(**kwargs)

Extracts the power fraction map. Will return a labeledgrid or hexagonal grid, depending on the core configuration. Entries are fractions in percentages.

Note

The following parameters are only available if cpp.model.fueled_primitive_powers was set.

critical_case.average_power_density(**kwargs)

The average power density over all fueled regions, with the size of the volumes determined by the model.fueled_primitive_powers parameter.

critical_case.average_heat_flux(**kwargs)

The average heat flux over all fueled regions, with the size of the areas determined by the model.fueled_primitive_powers parameter.

critical_case.maximum_power_density(**kwargs)

The maximum power density over all fueled regions, with the size of the volumes determined by the model.fueled_primitive_powers parameter.

critical_case.maximum_power_density_channel(**kwargs)

The core channel (or position) where the maximum power density occurred.

critical_case.maximum_heat_flux(**kwargs)

The maximum heat flux over all fueled regions, with the size of the areas determined by the model.fueled_primitive_powers parameter.

critical_case.maximum_heat_flux_channel(**kwargs)

The core channel (or position) where the maximum heat flux occurred.

critical_case.maximum_primitive_power(**kwargs)

The maximum fueled primitive (plate, pin or fueled compact) power.

critical_case.maximum_primitive_power_channel(**kwargs)

The core channel (or position) where the maximum primitive power occurred.

critical_case.maximum_primitive_power_index(**kwargs)

The index of the primitive with maximum power. See the assembly type documentation on how primitives are indexed.

critical_case.primitive_power_shape(position, slice='z', metric='total', total=None, **kwargs)

Create a one dimensional slice through a calculated power distribution.

Parameters:

• position – The core channel from which the distribution should be extracted.

• slice – The coordinate along which the slice should be taken. Must be one of the standard cartesian coordinates \(x,y,z\). For hexagonal grid layouts, the \(x, y\) coordinates are interpreted as the continuous versions of \(q, r\) indices in the axial coordinate system.

• metric –

  How values in the coordinate plane perpendicular to slice should be treated. The following options are allowed:

  Slice accumulation options.

  Option	Description
  ’total’	Sum over all values in the perpendicular plane.
  ’average’	Average over all values in the perpendicular plane.
  ’max_density’	At the position with maximum power density.
  ’max_flux’	At the position with maximum heat flux.

• total – Use this parameter to indicate that a summation should be performed along a certain dimension. It can be any of the two coordinate values spanning the plane perpendicular to slice.

This will return two values, the first is a list of length values denoting the coordinate positions along which the slice is taken, and the second a list of power values.

For example, to extract the total axial shape, use

>>> data = critical_case.primitive_power_shape('A1', slice='z', metric='total')

Or, to get the axial shape along the hottest pin

>>> data = critical_case.primitive_power_shape('A1', slice='z', metric='max_density')

Note

Since plates are usually segmented, the total parameter must be used to extract axial power shapes. For example, to get the total axial power shape in the hottest plate, assuming the plate extends along the \(x\)-axis,

>>> data = critical_case.primitive_power_shape('A1', slice='z', metric='max_density', total='x')

Output tokens related to flux distribution

critical_case.average_channel_thermal_flux(flt=None, **kwargs)

Extract the average thermal (\(<0.625\) eV) flux distribution in the core.

Parameters:

flt (labeledgrid or hexagonal grid) –

Limit the extraction to certain positions. Specified as a grid, with non-empty positions indicating core channels for which values are required. For example,

flt = \
 [[_, 'A', 'B', 'C'],
  [1,   _,  1,    _],
  [2,   1,  _,    _],
  [3,   _,  _,    1]]

will only extract fluxes in positions ‘1A’, ‘2B’ and ‘3C’.

Returns a labeledgrid or hexagonal grid containing the average flux in each channel.

critical_case.average_channel_fast_flux(flt=None, **kwargs)

Similar to critical_case.average_channel_thermal_flux(), except that the fast flux (\(> 0.82085\) MeV) is extracted.

critical_case.core_flux_map(**query, **kwargs)

Extract core flux distributions. Similar to critical_case.average_channel_thermal_flux() and critical_case.average_channel_fast_flux(), but with more control over the range of flux values extracted.

Parameters:

**query –

Sequence of distribution query values, which are used to specify exactly which flux values are extracted.

Returns a labeledgrid or hexagonal grid with the queried flux values in each channel.

For example, to extract flux in a specify energy and axial range:

>>> epi=critical_case.core_flux_map(e_min=0.625 * units.eV, e_max=0.82085 * units.MeV, z_min=-30 * units.cm, z_max=30 * units.cm)

critical_case.core_flux_distribution(channel, **query, **kwargs)

Extract detailed flux distribution within a core channel.

Parameters:

• channel – Core position.

• **query –

  Sequence of distribution query values, which are used to specify exactly which flux values are extracted.

The returned value depends on the **query: If a list of values is requested, a list is returned. Otherwise a singe flux value is returned.

For example, to extract axial thermal flux shape at specified points:

>>> th = core_flux_distribution(channel='A1', e_max=0.625 * units.eV, z=[-15 * units.cm, -10 * units.cm, -5 * units.cm])

Kinetics parameter related output tokens

Note

The following output parameters are only available if the cpp.kinetics_parameters flag was set.

critical_case.beta_effective(**kwargs)

Extract the calculated \(\beta_{eff}\) value.

critical_case.delayed_fractions(**kwargs)

Extract the \(\beta\) for each delayed precursor group. Returns a list of values, with length equal to the number of delayed group.

Attention

Currently, the returned values will sum to \(\beta_{eff}\), that is, they are not normalized.

critical_case.generation_time(**kwargs)

Extract the average neutron generation time \(\Lambda\). Returned value has time dimensions.

critical_case.decay_constants(**kwargs)

Extract the decay constant (\(\lambda\)) for each delayed precursor group.

Examples