armi.bookkeeping.historyTracker module

The History Tracker is a bookkeeping interface that accesses and reports time-dependent state information from the database.

At the end of a run, these write text files to show the histories for various follow-on mechanical analysis, fuel performance analysis, etc.

Other interfaces may find this useful as well, to get an assembly history for fuel performance analysis, etc. This is particularly useful in equilibrium runs, where the EqHistoryTrackerInterface will unravel the full history from a single equilibrium cycle.

Getting history information

Loop over blocks, keys, and timesteps of interest and use commands like this:

history.getBlockHistoryVal(armiBlock.getName(), key, ts)

Using the database-based history trackers

You can pre-load information before gathering it to get much better performance:

history.preloadBlockHistoryVals(blockNames, historyKeys, timeSteps)

This is essential for performance when history information is going to be accessed in loops over assemblies or blocks. Reading each param directly from the database individually in loops is paralyzingly slow.

Specifying parameters to add to the EOL history report

To add state parameters to the list of things that get their history reported, you need to define an interface method called getHistoryParams. It should return a list of block parameters that will become available. For example:

def getHistoryParams(self):
    return ['flux', 'percentBu']

When you’d like to access history information, you need to grab the history interface. The history interfaces is present by default in your interface stack. To get it, just call:

history = self.getInterface('history')

Now you can do a few things, such as:

# get some info about what's stored in the history
assemsWithHistory = history.getDetailAssemblies()
timeStepsAvailable = history.getTimeIndices()

# now go out and get some time-dependent block params:
fluxAtTimeStep3 = history.getBlockHistoryVal('B1003A', 'flux', 3)

Specifying blocks and assemblies to track

See Detail assemblies.

armi.bookkeeping.historyTracker.describeInterfaces(cs)[source]: Function for exposing interface(s) to other code.

class armi.bookkeeping.historyTracker.HistoryTrackerInterface(r, cs)[source]

Bases: Interface

Makes reports of the state that individual assemblies encounter.

Notes

This pre-dates the ARMI database system, and we would like to stop supporting this. Please don’t find new uses for this; use the databases.

Variables:

detailAssemblyNames (list) – List of detail assembly names in the reactor
time (list) – list of reactor time in years

HistoryTracker that uses the database to look up parameter history rather than storing them in memory.

Warning

If the current timestep history is requested and the database has not yet been written this timestep, the current value of the requested parameter is provided. It is possible that this is not the value that will be written to the database during this time step since many interfaces that change parameters may interact between this call and the database write.

name: Optional[str] = 'history': The name of the interface. This is undefined for the base class, and must be overridden by any concrete class that extends this one.

DETAILED_ASSEMBLY_FLAGS = [<Flags.FUEL: 8192>, <Flags.CONTROL: 32768>]

interactBOL()[source]

interactBOC(cycle=None)[source]: Look for any new assemblies that are asked for and add them to tracking.

interactEOL()[source]: Generate the history reports.

addDetailAssembliesBOL()[source]: Find and activate assemblies that the user requested detailed treatment of.

addAllDetailedAssems()[source]: Add all assems who have the DETAILED_ASSEMBLY_FLAGS as detail assems.

addDetailAssemsByAssemNums()[source]

Activate detail assemblies from input based on assembly number.

This is used to activate detail assembly tracking on assemblies that are not present in the core at BOL.