Rod Calibration Calculations

Application mode used to calculate differential and integral control rod worth as a function of insertion depth.

Typical Use Cases

This application mode is used to:

Simulate a rod worth experiment, using experimentally measured data.

Calculate the integral worth of a control rod as a function of its position (see rod_cal.auto_sequence()).

Creating an Input Module

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

oscar5 MY_REACTOR.manager rod_calibration 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.rod_calibration as app
from ..configurations.my_conf import model
from core import *

# Create parameter set
rod_cal = app.parameters()

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

# Set and modify the model
rod_cal.model = model
# etc

# Application specific input
rod_cal.rod_steps.base_power = 1 * units.kW         # Reactor power level at which calibrations were performed
rod_cal.rod_steps.xenon_mode = 'equilibrium'        # Calculate equilibrium xenon mode at above power level

rod_cal.rod_steps.add_step(critical_banks={'r1': control.percentage_extracted(50),
                                           'r2': control.percentage_extracted(45)},
                           perturbed_banks={'r2': control.percentage_extracted(50)})

rod_cal.rod_steps.add_step(critical_banks={'r1': control.percentage_extracted(55),
                                           'r2': control.percentage_extracted(50)},
                           perturbed_banks={'r2': control.percentage_extracted(55)})
# etc

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

Additional Input Parameters

In the following rod_cal denotes a rod_calibrations parameter set, created as follows:

import applications.rod_calibration as app

rod_cal = app.parameters()

This application supports all the general parameters. The rod calibration sequence is specified by adding rod position at various critical and perturbed positions. The rod_cal.rod_steps parameter is used for this purpose. Calculation of differential and integral reactivities are handled by the rod_cal.results_viewer.

rod_cal.rod_steps

This parameter is used to specify the calibration sequence. Steps in the sequence are added using the following function:

rod_steps.add_step(critical_banks, perturbed_banks, critical_state=None)

Adds a step to the calibration sequence.

Parameters:

critical_banks – The positions of all the banks at the critical set point for this step. Can also be set to None if a new critical position is not required.
perturbed_banks – The positions of all the banks for the perturbed (non critical) state of this step. Can be set to None if no perturbation occurred in this step (only set point correction).
critical_state – The model state at the critical set point for this step. If not specified, it is assumed that the state did not change.

Bank positions are specified as a dict option, mapping bank names, to travel instances.

Note

Although all bank/rod positions must be specified for the first critical_banks point, subsequent steps only need to specify the perturbed bank(s) position (that is, the bank(s) that changed from the previous point.

Attention

Since certain target codes, or the templates generating input for them, can remove redundant steps, make sure that each position (either critical or perturbed), differs from the previous point in the sequence.

Note

The rod_cal.rod_steps is just a special kind of irradiation history container, so many of the parameters are applicable for this container as well. In particular, consider setting irr.base_power and irr.xenon_mode to ‘equilibrium’ if the power level is high enough that xenon will affect tha accuracy of your critical estimates.

rod_cal.results_viewer

Object used to customize how reactivities are calculated, define reference results (if available).

rod_cal.results_viewer.target : string : The name of the bank or rod that is being calibrated.

rod_cal.results_viewer.axial_scale : list 

Manually specify the rod position scale, which is used on the independent axis of the reactivity curve plots. If not specified, it will be deduced automatically based on the rod_cal.rod_steps values.

The number of entries must be one more than the number of reactivity insertion/removals present in rod_cal.rod_steps.

Note

This only affects the post processing of results, and not the simulation itself.

rod_cal.results_viewer.measured_differential_worth : list : Specify the measured (or reference) reactivities. The number of entries must be equal to the number of reactivity insertion/removals present in rod_cal.rod_steps.

rod_cal.results_viewer.beta_eff : float : Manually specify a \(\beta_{eff}\) value, which can be used to scale the reactivities.

rod_cal.results_viewer.scale

Specify how raw calculated reactivities are scaled. The raw reactivities are calculated as:

\[\frac{k_{eff}^p - k_{eff}^b}{k_{eff}^p k_{eff}^b},\]

where \(k_{eff}^b\), \(k_{eff}^p\) is the base and perturbed reactivities respectively. There are a number of built-in scaling routines, which are summarized below

Option	Final results
‘to_dollar’	\(\frac{k_{eff}^p - k_{eff}^b}{k_{eff}^p k_{eff}^b \beta_{eff}}\)
‘to_pcm’	\(\frac{k_{eff}^p - k_{eff}^b}{k_{eff}^p k_{eff}^b} * 100000\)
‘to_mk’	\(\frac{k_{eff}^p - k_{eff}^b}{k_{eff}^p k_{eff}^b} * 1000\)

Alternatively, a custom scale function can be specified. This function, must take two arguments, the first being the raw reactivity value, and the second a pointer to the rod_cal.results_viewer object. For example, to extract reactivities in cents:

def to_cents(raw, res):
    return raw / res.beta_eff * 100.0

rod_cal.results_viewer.scale = to_cents

rod_cal.auto_sequence(target, positions, critical=control.search(), target_keff=1.0)

Create a basic rod_cal.rod_steps sequence, using fixed, or searched bank positions.

Parameters:

target (string) – The name of the bank/rod worth calculations should be performed for.
positions (list [travel]) – Sequence of positions for the target bank/rod.
critical – How the critical set points are defined. Either a single travel value, in which case it will be applied to all banks/rods (except target), or a dict, explicitly specifying how each bank will be treated. If None, no critical correction will be performed.
target_keff (float) – Target \(k_{eff}\), which is used if critical contains banks whose position should be searched.

For example, if the model has three rods (called ‘R1’, ‘R2’ and ‘R3’ respectively), then

>>> rod_param.auto_sequence('R1', [control.percentage_extracted(x) for x in range(0, 110, 10)])

would calculate reactivities for rod ‘R1’ at 10% intervals, and search new critical positions with ‘R2’ and ‘R3’ to compensate for the reactivity insertion. In this case, the first critical position (with ‘R1’ at 100% inserted) will also be searched.

In order to keep ‘R2’ fixed, and only compensate with ‘R3’, use:

>>> rod_param.auto_sequence('R1', [control.percentage_extracted(x) for x in range(0, 110, 10)],
>>>                         critical={'R2': control.percentage_extracted(100), 'R3': control.search()})

Finally, if a new critical set point should not be calculated, use

>>> rod_param.auto_sequence('R1', [control.percentage_extracted(x) for x in range(0, 110, 10)], critical=None)

Note

The option not to search for new critical positions should only be used if the target rod is fairly light, as moving too far away from a critical position might skew the delta reactivities.

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.calibration.my_rod --target-mode MY_TARGET --config-file MY_CONFIG run --force
oscar5 MY_REACTOR.calibration.my_rod --target-mode MY_TARGET --config-file MY_CONFIG post --show

Output Tokens

This application provides the following output variables:

rod_calibration.differential_curve(transform_scale=None, transform_values=None, **kwargs)

Retrieve the calculated differential reactivity values.

Parameters:

transform_scale – Optional transformation function that will be applied to the independent variable (rod movement scale).
transform_values – Optional transformation that will be applied to the reactivities.

This token (via its get method), returns two lists, the first being the rod movement scale, and the second the reactivities (as calculated by the rod_cal.results_viewer object).

Note

The returned value can be used directly as the data attribute of a line in the plot_lines documentation directive.

rod_calibration.s_curve(transform_scale=None, transform_values=None, **kwargs)

Retrieve the calculated cumulative reactivity over the specified rod movement.

Parameters:

transform_scale – Optional transformation function that will be applied to the independent variable (rod movement scale).
transform_values – Optional transformation that will be applied to the reactivities.

This token (via its get method), returns two lists, the first being the rod movement scale, and the second the integral worth (as calculated by the rod_cal.results_viewer object).

rod_calibration.total_worth(**kwargs): Retrieve the calculated total worth.

rod_calibration.measured_differential_curve(transform_scale=None, transform_values=None, **kwargs): Same as rod_calibration.differential_curve(), but returns the reference reactivities.

rod_calibration.measured_s_curve(transform_scale=None, transform_values=None, **kwargs): Same as rod_calibration.s_curve(), but returns the reference reactivities.

rod_calibration.critical_multiplication_factors(transform_scale=None, **kwargs)

Retrieve the effective multiplication factor (\(k_{eff}\)) at the critical set points.

Parameters:: transform_scale – Optional transformation function that will be applied to the independent variable (rod movement scale).

This token (via its get method), returns two lists, the first being the positions of the rod_cal.results_viewer.target at each critical set point, and the second the \(k_{eff}\) values.

Note

These values only make sense if experimental set points were provided.

Rod Calibration Calculations

Typical Use Cases

Creating an Input Module

Additional Input Parameters

Command Line Usage

Typical command line usage

Output Tokens

Examples