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: Interface

A general abstract interface for global flux-calculating modules.

Should be subclassed by more specific implementations.

name: str | None = 'GlobalFlux'

The name of the interface. This is undefined for the base class, and must be overridden by any concrete class that extends this one.

function = 'globalFlux'

The function performed by an Interface. This is not required be be defined by implementations of Interface, but is used to form categories of interfaces.

static getHistoryParams()

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

interactBOC(cycle=None)

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.

checkEnergyBalance()

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

Implementation: Validate the energy generation matches user specifications. I_ARMI_FLUX_CHECK_POWER

signature: checkEnergyBalance requirements: R_ARMI_FLUX_CHECK_POWER

This method checks that the global power computed from flux evaluation matches the global power specified from the user within a tolerance; if it does not, a ValueError is raised. The global power from the flux solve is computed by summing the block-wise power in the core. This value is then compared to the user-specified power and raises an error if relative difference is above \(10^{-5}\).

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: 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.

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.

getTightCouplingValue()

Return the parameter value.

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.

static getLabel(caseTitle, cycle, node, iteration=None)

Make a label (input/output file name) for the executer based on cycle, node, iteration.

Parameters:

• caseTitle (str, required) – The caseTitle for the ARMI run

• cycle (int, required) – The cycle number

• node (int, required) – The time node index

• iteration (int, optional) – The coupled iteration index

class armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxOptions(label: str | None = None)

Bases: ExecutionOptions

Data structure representing common options in Global Flux Solvers.

Implementation: Options for neutronics solvers. I_ARMI_FLUX_OPTIONS

signature: GlobalFluxOptions requirements: R_ARMI_FLUX_OPTIONS

This class functions as a data structure for setting and retrieving execution options for performing flux evaluations, these options involve: What sort of problem is to be solved, i.e. real/adjoint, eigenvalue/fixed-source, neutron/gamma, boundary conditions Convergence criteria for iterative algorithms Geometry type and mesh conversion details Specific parameters to be calculated after flux has been evaluated These options can be retrieved by directly accessing class members. The options are set by specifying a Settings object and optionally specifying a Reactor object.

Variables:

• adjoint (bool) – True if the CONF_NEUTRONICS_TYPE setting is set to adjoint or real.

• calcReactionRatesOnMeshConversion (bool) – This option is used to recalculate reaction rates after a mesh conversion and remapping of neutron flux. This can be disabled in certain global flux implementations if reaction rates are not required, but by default it is enabled.

• eigenvalueProblem (bool) – Whether this is a eigenvalue problem or a fixed source problem

• includeFixedSource (bool) – This can happen in eig if Fredholm Alternative satisfied.

• photons (bool) – Run the photon/gamma uniform mesh converter?

• real (bool) – True if CONF_NEUTRONICS_TYPE setting is set to real.

• aclpDoseLimit (float) – Dose limit in dpa used to position the above-core load pad (if one exists)

• boundaries (str) – External Neutronic Boundary Conditions. Reflective does not include axial.

• cs (Settings) – Settings for this run

• detailedAxialExpansion (bool) – Turn on detailed axial expansion? from settings

• dpaPerFluence (float) – A quick and dirty conversion that is used to get dpaPeak by multiplying the factor and fastFluencePeak

• energyDepoCalcMethodStep (str) – For gamma transport/normalization

• epsEigenvalue (float) – Convergence criteria for calculating the eigenvalue in the global flux solver

• epsFissionSourceAvg (float) – Convergence criteria for average fission source, from settings

• epsFissionSourcePoint (float) – Convergence criteria for point fission source, from settings

• geomType (geometry.GeomType) – Reactor Core geometry type (HEX, RZ, RZT, etc)

• hasNonUniformAssems (bool) – Has any non-uniform assembly flags, from settings

• isRestart (bool) – Restart global flux case using outputs from last time as a guess

• kernelName (str) – The neutronics / depletion solver for global flux solve.

• loadPadElevation (float) – The elevation of the bottom of the above-core load pad (ACLP) from the bottom of the upper grid plate (in cm).

• loadPadLength (float) – The length of the load pad. Used to compute average and peak dose.

• maxOuters (int) – XY and Axial partial current sweep max outer iterations.

• savePhysicsFilesList (bool) – Is this timestamp in the list of savePhysicsFiles in the settings?

• symmetry (str) – Reactor symmetry: full core, third-core, etc

• xsKernel (str) – Lattice Physics Kernel, from settings

fromUserSettings(cs: Settings)

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: Reactor)

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

Bases: 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.

Implementation: Ensure the mesh in the reactor model is appropriate for neutronics solver execution. I_ARMI_FLUX_GEOM_TRANSFORM

signature: GlobalFluxExecuter requirements: R_ARMI_FLUX_GEOM_TRANSFORM

The primary purpose of this class is perform geometric and mesh transformations on the reactor model to ensure a flux evaluation can properly perform. This includes: Applying a uniform axial mesh for the 3D flux solve Expanding symmetrical geometries to full-core if necessary Adding/removing edge assemblies if necessary Undoing any transformations that might affect downstream calculations

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, cs=None)

Bases: 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.

getDpaXs(b: Block)

Determine which cross sections should be used to compute dpa for a block.

Parameters:

b (Block) – The block we want the cross sections for

Returns:

list

Return type:

cross section values

getBurnupPeakingFactor(b: Block)

Get the radial peaking factor to be applied to burnup and DPA for a Block.

This may be informed by previous runs which used detailed pin reconstruction and rotation. In that case, it should be set on the cs setting burnupPeakingFactor.

Otherwise, it just takes the current flux peaking, which is typically conservatively high.

Parameters:

b (Block) – The block we want the peaking factor for

Returns:

burnupPeakingFactor – The peak/avg factor for burnup and DPA.

Return type:

float

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.

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

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

Implementation: Compute DPA rates. I_ARMI_FLUX_DPA

signature: computeDpaRate requirements: R_ARMI_FLUX_DPA

This method calculates DPA rates using the inputted multigroup flux and DPA cross sections. Displacements calculated by displacement cross-section: \begin{aligned} \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{aligned} 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 cross-section and in the original number of atoms.

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

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).

Implementation: Return the reaction rates for a given ArmiObject I_ARMI_FLUX_RX_RATES

signature: calcReactionRates requirements: R_ARMI_FLUX_RX_RATES

This method computes 1-group reaction rates for the inputted ArmiObject These reaction rates 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}\]

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.