armi.physics.neutronics.globalFlux.globalFluxInterface module

The Global flux interface provide a base class for all neutronics tools that compute the neutron and/or photon flux.

class armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxInterface(r, cs)

Bases: armi.interfaces.Interface

A general abstract interface for global flux-calculating modules.

Should be subclassed by more specific implementations.

Construct an interface.

The r and cs arguments are required, but may be None, where appropriate for the specific Interface implementation.

Parameters

• r (Reactor) – A reactor to attach to

• cs (Settings) – Settings object to use

Raises

RuntimeError – Interfaces derived from Interface must define their name

name = 'GlobalFlux'

function = 'globalFlux'

_ENERGY_BALANCE_REL_TOL = 1e-05

getHistoryParams()

Return parameters that will be added to assembly versus time history printouts.

interactBOC(cycle=None)

Called at the beginning of each cycle.

interactEveryNode(cycle, node)

Calculate flux, power, and keff for this cycle and node.

Flux, power, and keff are generally calculated at every timestep to ensure flux is up to date with the reactor state.

interactCoupled(iteration)

Runs during a tightly-coupled physics iteration to updated the flux and power.

interactEOC(cycle=None)

Called at the end of each cycle.

_checkEnergyBalance()

Check that there is energy balance between the power generated and the specified power is the system.

getIOFileNames(cycle, node, coupledIter=None, additionalLabel='')

Return the input and output file names for this run.

Parameters

• cycle (int) – The cycle number

• node (int) – The burn node number (e.g. 0 for BOC, 1 for MOC, etc.)

• coupledIter (int, optional) – Coupled iteration number (for tightly-coupled cases)

• additionalLabel (str, optional) – An optional tag to the file names to differentiate them from another case.

Returns

• inName (str) – Input file name

• outName (str) – Output file name

• stdName (str) – Standard output file name

calculateKeff(label='keff')

Runs neutronics tool and returns keff without applying it to the reactor

Used for things like direct-eigenvalue reactivity coefficients and CR worth iterations. For anything more complicated than getting keff, clients should call getExecuter to build their case.

class armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxInterfaceUsingExecuters(r, cs)

Bases: armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxInterface

A global flux interface that makes use of the ARMI Executer system to run.

Using Executers is optional but seems to allow easy interoperability between the myriad global flux solvers in the world.

If a new global flux solver does not fit easily into the Executer pattern, then it will be best to just start from the base GlobalFluxInterface rather than trying to adjust the Executer pattern to fit.

Notes

This points library users to the Executer object, which is intended to provide commonly-used structure useful for many global flux plugins.

Construct an interface.

The r and cs arguments are required, but may be None, where appropriate for the specific Interface implementation.

Parameters

• r (Reactor) – A reactor to attach to

• cs (Settings) – Settings object to use

Raises

RuntimeError – Interfaces derived from Interface must define their name

interactEveryNode(cycle, node)

Calculate flux, power, and keff for this cycle and node.

Flux, power, and keff are generally calculated at every timestep to ensure flux is up to date with the reactor state.

interactCoupled(iteration)

Runs during a tightly-coupled physics iteration to updated the flux and power.

static getOptionsCls()

Get a blank options object.

Subclass this to allow generic updating of options.

static getExecuterCls()

getExecuterOptions(label=None)

Get an executer options object populated from current user settings and reactor.

If you want to set settings more deliberately (e.g. to specify a cross section library rather than use an auto-derived name), use getOptionsCls and build your own.

getExecuter(options=None, label=None)

Get executer object for performing custom client calcs

This allows plugins to update options in a somewhat generic way. For example, reactivity coefficients plugin may want to request adjoint flux.

calculateKeff(label='keff')

Run global flux with current user options and just return keff without applying it.

Used for things like direct-eigenvalue reactivity coefficients and CR worth iterations.

class armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxOptions(label: Optional[str] = None)

Bases: armi.physics.executers.ExecutionOptions

Data structure representing common options in Global Flux Solvers

fromUserSettings(cs)

Map user input settings from cs to a set of specific global flux options.

This is not required; these options can alternatively be set programmatically.

fromReactor(reactor: armi.reactor.reactors.Reactor)

Set options from a particular reactor object.

class armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxExecuter(options: armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxOptions, reactor)

Bases: armi.physics.executers.DefaultExecuter

A short-lived object that coordinates the prep, execution, and processing of a flux solve.

There are many forms of global flux solves:

• Eigenvalue/Fixed source

• Adjoint/real

• Diffusion/PN/SN/MC

• Finite difference/nodal

There are also many reasons someone might need a flux solve:

• Update multigroup flux and power on reactor and compute keff

• Just compute keff in a temporary perturbed state

• Just compute flux and adjoint flux on a state to

There may also be some required transformations when a flux solve is done:

• Add/remove edge assemblies

• Apply a uniform axial mesh

There are also I/O performance complexities, including running on fast local paths and copying certain user-defined files back to the working directory on error or completion. Given all these options and possible needs for information from global flux, this class provides a unified interface to everything.

_performGeometryTransformations(**kwargs)

_undoGeometryTransformations(**kwargs)

edgeAssembliesAreNeeded() → bool

True if edge assemblies are needed in this calculation

We only need them in finite difference cases that are not full core.

class armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxResultMapper(r=None, externalCodeInterface=None, fName=None)

Bases: armi.interfaces.OutputReader

A short-lived class that maps neutronics output data to a reactor mode.

Neutronics results can come from a file or a pipe or in memory. This is always subclassed for specific neutronics runs but contains some generic methods that are universally useful for any global flux calculation. These are mostly along the lines of information that can be derived from other information, like dpa rate coming from dpa deltas and cycle length.

getKeff()

clearFlux()

Delete flux on all blocks. Needed to prevent stale flux when partially reloading.

_renormalizeNeutronFluxByBlock(renormalizationCorePower)

Normalize the neutron flux within each block to meet the renormalization power.

Parameters

renormalizationCorePower (float) – Specified power to renormalize the neutron flux for using the isotopic energy generation rates on the cross section libraries (in Watts)

See also

getTotalEnergyGenerationConstants()

_updateDerivedParams()

Computes some params that are derived directly from flux and power parameters.

updateDpaRate(blockList=None)

Update state parameters that can be known right after the flux is computed

See also

updateFluenceAndDpa()

uses values computed here to update cumulative dpa

updateMaxDpaParams()

Update params that track the peak dpa.

Only consider fuel because CRs, etc. aren’t always reset.

_updateAssemblyLevelParams()

class armi.physics.neutronics.globalFlux.globalFluxInterface.DoseResultsMapper(depletionSeconds, options)

Bases: armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxResultMapper

Updates fluence and dpa when time shifts.

Often called after a depletion step.

Notes

We attempted to make this a set of stateless functions but the requirement of various options made it more of a data passing task than we liked. So it’s just a lightweight and ephemeral results mapper.

apply(reactor)

Apply the output back to a reactor state.

This provides a generic interface for the output data of anything to be applied to a reactor state. The application could involve reading text or binary output or simply parameters to appropriate values in some other data structure.

updateFluenceAndDpa(stepTimeInSeconds, blockList=None)

updates the fast fluence and the DPA of the blocklist

The dpa rate from the previous timestep is used to compute the dpa here.

There are several items of interest computed here, including:

• detailedDpa: The average DPA of a block

• detailedDpaPeak: The peak dpa of a block, considering axial and radial peaking

  The peaking is based either on a user-provided peaking factor (computed in a pin reconstructed rotation study) or the nodal flux peaking factors

• dpaPeakFromFluence: fast fluence * fluence conversion factor (old and inaccurate). Used to be dpaPeak

Parameters

• stepTimeInSeconds (float) – Time in seconds that the cycle ran at the current mgFlux

• blockList (list, optional) – blocks to be updated. Defaults to all blocks in core

See also

updateDpaRate()

updates the DPA rate used here to compute actual dpa

updateCycleDoseParams()

Updates reactor params based on the amount of dose (detailedDpa) accrued this cycle Params updated include:

maxDetailedDpaThisCycle dpaFullWidthHalfMax elevationOfACLP3Cycles elevationOfACLP7Cycles

These parameters are left as zeroes at BOC because no dose has been accumulated yet.

updateLoadpadDose()

Summarize the dose in DPA of the above-core load pad.

This sets the following reactor params:

• loadPadDpaPeak : the peak dpa in any load pad

• loadPadDpaAvg : the highest average dpa in any load pad

Warning

This only makes sense for cores with load pads on their assemblies.

See also

_calcLoadPadDose()

computes the load pad dose

_calcLoadPadDose()

Determines some dose information on the load pads if they exist.

Expects a few settings to be present in cs

loadPadElevationfloat

The bottom of the load pad’s elevation in cm above the bottom of the (upper) grid plate.

loadPadLengthfloat

The axial length of the load pad to average over

This builds axial splines over the assemblies and then integrates them over the load pad.

The assumptions are that detailedDpa is the average, defined in the center and detailedDpaPeak is the peak, also defined in the center of blocks.

Parameters

• core (armi.reactor.reactors.Core) –

• cs (armi.settings.caseSettings.Settings) –

Returns

• peakPeak (tuple) – A (peakValue, peakAssem) tuple

• peakAvg (tuple) – a (avgValue, avgAssem) tuple

See also

writeLoadPadDoseSummary()

prints out the dose

Assembly.getParamValuesAtZ()

gets the parameters at any arbitrary z point

armi.physics.neutronics.globalFlux.globalFluxInterface.computeDpaRate(mgFlux, dpaXs)

Compute the DPA rate incurred by exposure of a certain flux spectrum

Parameters

• mgFlux (list) – multigroup neutron flux in #/cm^2/s

• dpaXs (list) – DPA cross section in barns to convolute with flux to determine DPA rate

Returns

dpaPerSecond – The dpa/s in this material due to this flux

Return type

float

Notes

Displacements calculated by displacement XS

\[\begin{split}\text{Displacement rate} &= \phi N_{\text{HT9}} \sigma \\ &= (\#/\text{cm}^2/s) \cdot (1/cm^3) \cdot (\text{barn})\\ &= (\#/\text{cm}^5/s) \cdot \text{(barn)} * 10^{-24} \text{cm}^2/\text{barn} \\ &= \#/\text{cm}^3/s\end{split}\]

DPA rate = displacement density rate / (number of atoms/cc)
         = dr [#/cm^3/s] / (nHT9)  [1/cm^3]
         = flux * barn * 1e-24

\[\frac{\text{dpa}}{s} = \frac{\phi N \sigma}{N} = \phi * \sigma\]

the Number density of the structural material cancels out. It’s in the macroscopic XS and in the original number of atoms.

Raises

RuntimeError – Negative dpa rate.

armi.physics.neutronics.globalFlux.globalFluxInterface.calcReactionRates(obj, keff, lib)

Compute 1-group reaction rates for this object (usually a block.)

Parameters

• obj (Block) – The object to compute reaction rates on. Notionally this could be upgraded to be any kind of ArmiObject but with params defined as they are it currently is only implemented for a block.

• keff (float) – The keff of the core. This is required to get the neutron production rate correct via the neutron balance statement (since nuSigF has a 1/keff term).

• lib (XSLibrary) – Microscopic cross sections to use in computing the reaction rates.

Notes

Values include:

• Fission

• nufission

• n2n

• absorption

Scatter could be added as well. This function is quite slow so it is skipped for now as it is uncommonly needed.

Reaction rates are:

\[\Sigma \phi = \sum_{\text{nuclides}} \sum_{\text{energy}} \Sigma \phi\]

The units of \(N \sigma \phi\) are:

[#/bn-cm] * [bn] * [#/cm^2/s] = [#/cm^3/s]

The group-averaged microscopic cross section is:

\[\sigma_g = \frac{\int_{E g}^{E_{g+1}} \phi(E) \sigma(E) dE}{\int_{E_g}^{E_{g+1}} \phi(E) dE}\]