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())