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)[source]

Bases: Interface

A general abstract interface for global flux-calculating modules.

Should be subclassed by more specific implementations.

name: Optional[str] = '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()[source]: Return parameters that will be added to assembly versus time history printouts.

interactBOC(cycle=None)[source]

interactEveryNode(cycle, node)[source]

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)[source]: Runs during a tightly-coupled physics iteration to updated the flux and power.

checkEnergyBalance()[source]: Check that there is energy balance between the power generated and the specified power.

getIOFileNames(cycle, node, coupledIter=None, additionalLabel='')[source]

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')[source]

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)[source]

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)[source]

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)[source]: Runs during a tightly-coupled physics iteration to updated the flux and power.

getTightCouplingValue()[source]: Return the parameter value.

static getOptionsCls()[source]

Get a blank options object.

Subclass this to allow generic updating of options.

static getExecuterCls()[source]

getExecuterOptions(label=None)[source]

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)[source]

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')[source]

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)[source]

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: Optional[str] = None)[source]

Bases: ExecutionOptions

Data structure representing common options in Global Flux Solvers.

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)[source]

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)[source]

class armi.physics.neutronics.globalFlux.globalFluxInterface.GlobalFluxExecuter(options: GlobalFluxOptions, reactor)[source]

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.

edgeAssembliesAreNeeded() → bool[source]

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)[source]

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()[source]

clearFlux()[source]: Delete flux on all blocks. Needed to prevent stale flux when partially reloading.

getDpaXs(b: Block)[source]

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)[source]

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)[source]

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