def varsToBullets(incomingVars):
lines = "\n"
for item in sorted(incomingVars):
lines += VAR_FMTR.format(
original=item,
converted=convertVariableName(item))
return lines + '\n'
def _read(self):
curKey = None
scratch = ScratchStorage()
cycles = None
indx = 0
with open(self.filePath) as out:
for lineNo, line in enumerate(out):
if not line.strip():
continue
if '=' in line:
serpentN = line.split()[0].replace('HIS_', '')
curKey = convertVariableName(serpentN)
continue
if 'active' in line:
if self.numInactive is None:
self.numInactive = indx
continue
if line[0] == ']':
data = asfortranarray(scratch.data)
self.arrays[curKey] = data
cycles = data.shape[0]
indx = 0
continue
values = line.split()[1:] # skip indexing term
indx += 1
values = [float(xx) for xx in values]
if cycles and indx == 1:
scratch.allocate((cycles, len(values)))
scratch[indx - 1] = values
def _getBUstate(self):
"""Define unique branch state"""
days = self._counter['meta']
burnup = self._counter['meta']
burnIdx = self._counter['rslt'] # assign indices
varPyDays = convertVariableName(self._keysVersion['days']) # Py style
varPyBU = convertVariableName(self._keysVersion['burn'])
if varPyDays in self.resdata.keys():
if burnIdx > 1:
days = self.resdata[varPyDays][-1, 0]
else:
days = self.resdata[varPyDays][-1]
if varPyBU in self.resdata.keys():
if burnIdx > 1:
burnup = self.resdata[varPyBU][-1, 0]
else:
burnup = self.resdata[varPyBU][-1]
return self._univlist[-1], burnup, burnIdx, days
def test_variableConversion(self):
""" Verify the variable name conversion function."""
testCases = {
"VERSION": "version",
"INF_KINF": "infKinf",
"ADJ_PERT_KEFF_SENS": "adjPertKeffSens",
}
for serpentStyle, expected in iteritems(testCases):
actual = convertVariableName(serpentStyle)
self.assertEqual(expected, actual, msg=serpentStyle)
def __addSens(self, varName, vec, isEnergyIntegrated):
dest = (self.energyIntegratedSens
if isEnergyIntegrated else self.sensitivities)
newShape = [2, self.nPert, self.nZai, self.nMat]
if not isEnergyIntegrated:
newShape.insert(1, self.nEne)
try:
newName = convertVariableName(varName)
dest[newName] = reshapePermuteSensMat(vec, newShape)
except Exception as ee:
critical("The following error was raised attempting to "
"reshape matrix {}".format(varName))
raise ee
def addData(self, variableName, variableValue, uncertainty=False):
r"""
Sets the value of the variable and, optionally, the associate s.d.
.. versionadded:: 0.5.0
Reshapes scattering matrices according to setting
``xs.reshapeScatter``. Matrices are of the form
:math:`S[i, j]=\Sigma_{s,i\rightarrow j}`
.. warning::
This method will overwrite data for variables that already exist
Parameters
----------
variableName: str
Variable Name
variableValue:
Variable Value
uncertainty: bool
Set to ``True`` if this data is an uncertainty
Raises
------
TypeError
If the uncertainty flag is not boolean
"""
if not isinstance(uncertainty, bool):
raise TypeError('The variable uncertainty has type {}, '
'should be boolean.'.format(type(uncertainty)))
value = self._cleanData(variableName, variableValue)
if variableName in HOMOG_VAR_TO_ATTR:
value = value if variableValue.size > 1 else value[0]
setattr(self, HOMOG_VAR_TO_ATTR[variableName], value)
return
name = convertVariableName(variableName)
# 2. Pointer to the proper dictionary
setter = self._lookup(name, uncertainty)
# 3. Check if variable is already present. Then set the variable.
if name in setter:
warning("The variable {} will be overwritten".format(name))
setter[name] = value
def _addMetadata(self, chunk):
for varName in METADATA_KEYS:
if varName not in chunk[0]:
continue
if varName in ['ZAI', 'NAMES']:
cleaned = [line.strip() for line in chunk[1:]]
if varName == 'NAMES':
values = [item[1:item.find(" ")] for item in cleaned]
else:
values = str2vec(cleaned, int, list)
else:
line = self._cleanSingleLine(chunk)
values = str2vec(line)
self.metadata[convertVariableName(varName)] = values
return
warning("Unsure about how to process metadata chunk {}"
.format(chunk[0]))
def _precheck(self):
"""do a quick scan to ensure this looks like a results file."""
serpentV = rc['serpentVersion']
keys = MapStrVersions.get(serpentV)
if keys is None:
warning("SERPENT {} is not supported by the "
"ResultsReader".format(serpentV))
warning(" Attempting to read anyway. Please report strange "
"behaviors/failures to developers.")
keys = MapStrVersions[max(MapStrVersions)]
self._keysVersion = keys
self._burnupKeys = {
k: convertVariableName(keys[k])
for k in {"days", "burnup"}
}
univSet = set()
verWarning = True
with open(self.filePath) as fid:
if fid is None:
raise IOError("Attempting to read on a closed file.\n"
"Parser: {}\nFile: {}".format(
self, self.filePath))
for tline in fid:
if verWarning and self._keysVersion['meta'] in tline:
verWarning = False
varType, varVals = self._getVarValues(tline) # version
if serpentV not in varVals:
warning("SERPENT {} found in {}, but version {} is "
"defined in settings".format(
varVals, self.filePath, serpentV))
warning(" Attemping to read anyway. Please report "
"strange behaviors/failures to developers.")
if self._keysVersion['univ'] in tline:
varType, varVals = self._getVarValues(tline) # universe
if varVals in univSet:
break
univSet.add(varVals) # add the new universe
self._numUniv = len(univSet)
def addData(self, variable, rawData):
"""
Add data straight from the file onto a variable.
Parameters
----------
variable: str
Name of the variable directly from ``SERPENT``
rawData: list
List of strings corresponding to the raw data from the file
"""
newName = convertVariableName(variable)
debug('Adding {} data to {}'.format(newName, self.name))
if isinstance(rawData, str):
scratch = [float(item) for item in rawData.split()]
else:
scratch = []
for line in rawData:
if line:
scratch.append([float(item) for item in line.split()])
self.data[newName] = numpy.array(scratch)
def _getVarName(self, tline):
"""Obtains the variable name and converts it to a python-style name."""
currVar = FIRST_WORD_REGEX.search(tline)
if currVar is not None:
# return serpent-style and python-style names
return currVar.group(), convertVariableName(currVar.group())
