armi.utils.mathematics module
Various math utilities.
- armi.utils.mathematics.average1DWithinTolerance(vals, tolerance=0.2)[source]
Compute the average of a series of arrays with a tolerance.
Tuned for averaging assembly meshes or block heights.
- Parameters:
vals (2D np.array) – could be assembly x axial mesh tops or heights
- armi.utils.mathematics.convertToSlice(x, increment=False)[source]
Convert a int, float, list of ints or floats, None, or slice to a slice. Also optionally increments that slice to make it easy to line up lists that don’t start with 0.
Use this with np.array (np.ndarray) types to easily get selections of it’s elements.
- Parameters:
x (multiple types allowed.) – int: select one index. list of int: select these index numbers. None: select all indices. slice: select this slice
- Returns:
slice – Returns a slice object that can be used in an array like a[x] to select from its members. Also, the slice has its index numbers decremented by 1. It can also return a numpy array, which can be used to slice other numpy arrays in the same way as a slice.
- Return type:
Examples
a = np.array([10, 11, 12, 13])
>>> convertToSlice(2) slice(2, 3, None) >>> a[convertToSlice(2)] array([12])
>>> convertToSlice(2, increment=-1) slice(1, 2, None) >>> a[convertToSlice(2, increment=-1)] array([11])
>>> a[convertToSlice(None)] array([10, 11, 12, 13])
>>> a[utils.convertToSlice([1, 3])] array([11, 13])
>>> a[utils.convertToSlice([1, 3], increment=-1)] array([10, 12])
>>> a[utils.convertToSlice(slice(2, 3, None), increment=-1)] array([11])
- armi.utils.mathematics.efmt(a: str) str[source]
Converts string exponential number to another string with just 2 digits in the exponent.
- armi.utils.mathematics.expandRepeatedFloats(repeatedList)[source]
Return an expanded repeat list.
Notes
R char is valid for showing the number of repeats in MCNP. For examples the list: [150, 200, ‘9R’] indicates a 150 day cycle followed by 10 200 day cycles.
- armi.utils.mathematics.findClosest(listToSearch, val, indx=False)[source]
Find closest item in a list.
- Parameters:
- Returns:
minVal (float) – The item in the listToSearch that is closest to val
minI (int) – The index of the item in listToSearch that is closest to val. Returned if indx=True.
- armi.utils.mathematics.findNearestValue(searchList, searchValue)[source]
Search a given list for the value that is closest to the given search value.
- armi.utils.mathematics.findNearestValueAndIndex(searchList, searchValue)[source]
Search a given list for the value that is closest to the given search value. Return a tuple containing the value and its index in the list.
- armi.utils.mathematics.fixThreeDigitExp(strToFloat: str) float[source]
Convert FORTRAN numbers that cannot be converted into floats.
Notes
Converts a number line “9.03231714805651-101” (no e or E) to “9.03231714805651e-101”. Some external depletion kernels currently need this fix. From contact with developer: The notation like 1.0-101 is a FORTRAN thing, with history going back to the 60’s. They will only put E before an exponent 99 and below. Fortran will also read these guys just fine, and they are valid floating point numbers. It would not be a useful effort, in terms of time, trying to get FORTRAN to behave differently. The approach has been to write a routine in the reading code which will interpret these.
This helps when the scientific number exponent does not fit.
- armi.utils.mathematics.getFloat(val)[source]
Returns float version of val, or None if it’s impossible. Useful for converting user-input into floats when ‘’ might be possible.
- armi.utils.mathematics.getStepsFromValues(values, prevValue=0.0)[source]
Convert list of floats to list of steps between each float.
- armi.utils.mathematics.isMonotonic(inputIter, relation)[source]
Checks if an iterable contains elements that are monotonically increasing or decreasing, whatever that might mean for the specific types of the elements.
- armi.utils.mathematics.linearInterpolation(x0, y0, x1, y1, targetX=None, targetY=None)[source]
Does a linear interpolation (or extrapolation) for y=f(x).
- Parameters:
x0 (float) – Coordinates of two points to interpolate between
y0 (float) – Coordinates of two points to interpolate between
x1 (float) – Coordinates of two points to interpolate between
y1 (float) – Coordinates of two points to interpolate between
targetX (float, optional) – X value to evaluate the line at
targetY (float, optional) – Y value we want to find the x value for (inverse interpolation)
- Returns:
interpY (float) – The value of y(targetX), if targetX is not None
interpX (float) – The value of x where y(x) = targetY (if targetY is not None)
y = m(x-x0) + b
x = (y-b)/m
- armi.utils.mathematics.minimizeScalarFunc(func, goal, guess, maxIterations=None, cs=None, positiveGuesses=False, method=None, tol=0.001)[source]
Use scipy minimize with the given function, goal value, and first guess.
- Parameters:
func (function) – The function that guess will be changed to try to make it return the goal value.
goal (float) – The function will be changed until it’s return equals this value.
guess (float) – The first guess value to do Newton’s method on the func.
maxIterations (int) – The maximum number of iterations that the Newton’s method will be allowed to perform.
- Returns:
ans – The guess that when input to the func returns the goal.
- Return type:
- armi.utils.mathematics.newtonsMethod(func, goal, guess, maxIterations=None, cs=None, positiveGuesses=False)[source]
Solves a Newton’s method with the given function, goal value, and first guess.
- Parameters:
func (function) – The function that guess will be changed to try to make it return the goal value.
goal (float) – The function will be changed until it’s return equals this value.
guess (float) – The first guess value to do Newton’s method on the func.
maxIterations (int) – The maximum number of iterations that the Newton’s method will be allowed to perform.
- Returns:
ans – The guess that when input to the func returns the goal.
- Return type:
- armi.utils.mathematics.parabolaFromPoints(p1, p2, p3)[source]
Find the parabola that passes through three points.
We solve a simultaneous equation with three points.
- A = x1**2 x1 1
x2**2 x2 1 x3**2 x3 1
- b = y1
y2 y3
find coefficients Ax=b
- armi.utils.mathematics.parabolicInterpolation(ap, bp, cp, targetY)[source]
Given parabola coefficients, this interpolates the time that would give k=targetK.
keff = at^2+bt+c We want to solve a*t^2+bt+c-targetK = 0.0 for time. if there are real roots, we should probably take the smallest one because the larger one might be at very high burnup. If there are no real roots, just take the point where the deriv ==0, or 2at+b=0, so t = -b/2a The slope of the curve is the solution to 2at+b at whatever t has been determined
- Parameters:
ap (floats) – coefficients of a parabola y = ap*x^2 + bp*x + cp
bp (floats) – coefficients of a parabola y = ap*x^2 + bp*x + cp
cp (floats) – coefficients of a parabola y = ap*x^2 + bp*x + cp
targetK (float) – The keff to find the cycle length of
- Returns:
realRoots – (root, slope) The best guess of the cycle length that will give k=targetK If no positive root was found, this is the maximum of the curve. In that case, it will be a negative number. If there are two positive roots, there will be two entries.
- slopefloat
The slope of the keff vs. time curve at t=newTime
- Return type:
list of tuples
- armi.utils.mathematics.relErr(v1: float, v2: float) float[source]
Find the relative error between to numbers.
- armi.utils.mathematics.resampleStepwise(xin, yin, xout, avg=True)[source]
Resample a piecewise-defined step function from one set of mesh points to another. This is useful for reallocating values along a given axial mesh (or assembly of blocks).
- Parameters:
xin (list) – interval points / mesh points
yin (list) – interval values / inter-mesh values
xout (list) – new interval points / new mesh points
avg (bool) – By default, this is set to True, forcing the resampling to be done by averaging. But if this is False, the resmampling will be done by summation, to try and preserve the totals after resampling.