armi.physics.executers module

Executors are useful for having a standard way to run physics calculations.

They may involve external codes (with inputs/execution/output) or in-memory data pathways.

class armi.physics.executers.ExecutionOptions(label=None)

Bases: object

A data structure representing all options needed for a physics kernel.

inputFile

Name of main input file. Often passed to stdin of external code.

Type

str

outputFile

Name of main output file. Often the stdout of external code.

Type

str

extraInputFiles

(sourceName, destName) pairs of file names that will be brought from the working dir into the runDir. Allows renames while in transit.

Type

list of tuples

extraOutputFiles

(sourceName, destName) pairs of file names that will be extracted from the runDir to the working dir

Type

list of tuples

executablePath

Path to external executable to run (if external code is used)

Type

str

runDir

Path on running system where the run will take place. This is often used to ensure external codes that use hard-drive disk space run on a local disk rather than a shared network drive

Type

str

workingDir

Path on system where results will be placed after the run. This is often a shared network location. Auto-applied during execution by default.

Type

str

label

A name for the run that may be used as a prefix for input/output files generated.

Type

str

applyResultsToReactor

Update the in-memory reactor model with results upon completion. Set to False when information from a run is needed for auxiliary purposes rather than progressing the reactor model.

Type

bool

fromUserSettings(cs)

Set options from a particular CaseSettings object.

fromReactor(reactor)

Set options from a particular reactor object.

resolveDerivedOptions()

Called by executers right before executing.

setRunDirFromCaseTitle(caseTitle)

Set run directory derived from case title and label.

This is optional (you can set runDir to whatever you want). If you use this, you will get a relatively consistent naming convention for your fast-past folders.

describe()

Make a string summary of all options.

class armi.physics.executers.Executer(options, reactor)

Bases: object

Short-lived object that coordinates a calculation step and updates a reactor.

Notes

This is deliberately not a MpiAction. Thus, Executers can run as potentially multiple steps in a parent (parallelizable ) MpiAction or in other flexible ways. This is intended to maximize reusability.

run()

Run the executer steps.

This should use the current state of the reactor as input, perform some kind of calculation, and update the reactor with the output.

class armi.physics.executers.DefaultExecuter(options, reactor)

Bases: armi.physics.executers.Executer

An Executer that uses a common run sequence.

This sequence has been found to be relatively common in many externally-executed physics codes. It is here for convenience but is not required. The sequence look like:

• Choose modeling options (either from the global run settings input or dictated programmatically)

• Apply geometry transformations to the ARMI Reactor as needed

• Build run-specific working directory

• Write input file(s)

• Put specific input files and libs in run directory

• Run the analysis (external execution, or not)

• Process output while still in run directory

• Check error conditions

• Move desired output files back to main working directory

• Clean up run directory

• Un-apply geometry transformations as needed

• Update ARMI data model as desired

run()

Run the executer steps.

Warning

If a calculation requires anything different from what this method does, do not update this method with new complexity! Instead, simply make your own run sequence and/or class. This pattern is useful only in that it is fairly simple. By all means, do use DirectoryChanger and ExecuterOptions and other utilities.

_collectInputsAndOutputs()

Get total lists of input and output files.

_execute()

writeInput()

_readOutput()

_applyOutputToDataModel(output)

_performGeometryTransformations()

_undoGeometryTransformations()