Rod Calibration Calculations for Multiple Rods

Application mode used to calculate differential and integral control rod worth as a function of insertion depth for multiple rods. It simply collects a number Rod Calibration Calculations application cases into a single input script.

Typical Use Cases

This application mode is used to:

  1. Simulate multiple rod worth experiments, using experimentally measured data.

  2. Calculate the integral worth of control rods as a function of their position.

Creating an Input Module

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

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

# Create parameter set
rods_cal = app.parameters()

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

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

# Add a rod
r1 = rods_cal.add_rod('R1', description='First rod')

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

# Add next rod
r2 = rods_cal.add_rod('R2', description='Second rod')

# etc

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

Additional Input Parameters

In the following rods_cal denotes a multi_rod_calibrations parameter set, created as follows:

import applications.multi_rod_calibration as app

rods_cal = app.parameters()

This application supports all the general parameters. These parameters are propagated to the individual rod (or bank) calculations, which are added using:

rods_cal.add_rod(tag, description=None)

Adds a new rod (or bank) for which reactivity worth calculations should be performed.

Parameters:

  • tag (str) – How this case will be identified. It is recommended that the name of the target rod or bank be used.

  • description (str) – Optional description of the case.

Returns:

An rod_cal parameter set, which is used to further specify input for this case.

Command Line Usage

This application supports all the standard application modes and options as described in General Application Command Line Interface (CLI). In addition to the standard modes, the rod_calibration application for each rod added with rods_cal.add_rod() is available as a sub mode.

Typical command line usage

Runs the calibration simulations for all rods:

oscar5 MY_REACTOR.calibration.my_rods --target-mode MY_TARGET --config-file MY_CONFIG run --force

View the results for a specific rod

oscar5 MY_REACTOR.calibration.my_rods R1 --target-mode MY_TARGET post --show

Output Tokens

This application provides the following output variables:

multi_rod_calibration.differential_curve(rod, **kwargs)

Retrieve the calculated differential reactivity values.

Parameters:

This token (via its get method), returns two lists, the first being the rod movement scale, and the second the reactivities (see rod_calibration.differential_curve()).

multi_rod_calibration.s_curve(rod, **kwargs)

Retrieve the calculated cumulative reactivity over the specified rod movement.

Parameters:

This token (via its get method), returns two lists, the first being the rod movement scale, and the second the integral worth (see rod_calibration.s_curve()).

multi_rod_calibration.total_worth(rod, **kwargs)

Retrieve the calculated total worth.

Parameters:

rod (str) – The target rod.

multi_rod_calibration.measured_differential_curve(rod, **kwargs)

Same as multi_rod_calibration.differential_curve(), but returns the reference reactivities.

multi_rod_calibration.measured_s_curve(rod, **kwargs)

Same as multi_rod_calibration.s_curve(), but returns the reference reactivities.

multi_rod_calibration.rod_critical_multiplication_factors(rod, **kwargs)

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

Parameters:

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

multi_rod_calibration.critical_multiplication_factors(*rods, **kwargs)

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

Parameters:

rods – Sequence of target rod names. If not specified, results for all rods will be extracted.

This token (via its get method), returns two lists, the first is simply a range of indices which over all critical positions, and the second the \(k_{eff}\) values.

Examples