def _compareMetadata(self, other, lower, upper, _sigma):
"""Private method for comparing metadata"""
similar = logDirectCompare(self.names, other.names, 0, 0, 'names')
similar &= logDirectCompare(self.zais, other.zais, 0, 0, 'zai')
similar &= logDirectCompare(self.days, other.days, lower, upper,
'days')
similar &= logDirectCompare(self.burnup, other.burnup, lower, upper,
'burnup')
return similar
def _compareMetadata(self, other, lower, upper, _sigma):
"""Private method for comparing metadata"""
similar = logDirectCompare(self.metadata['names'],
other.metadata['names'], 0, 0, 'names')
similar &= logDirectCompare(self.metadata['zai'],
other.metadata['zai'], 0, 0, 'zai')
similar &= logDirectCompare(self.metadata['days'],
other.metadata['days'], lower, upper,
'days')
similar &= logDirectCompare(self.metadata['burnup'],
other.metadata['burnup'], lower, upper,
'burnup')
return similar
def compareResults(self,
other,
lower=DEF_COMP_LOWER,
upper=DEF_COMP_UPPER,
sigma=DEF_COMP_SIGMA,
header=False):
"""
Compare the contents of the results dictionary
Parameters
----------
other: :class:`ResultsReader`
Class against which to compare
{compLimits}
{sigma}
{header}
Returns
-------
bool:
If the results data agree to given tolerances
Raises
------
{compTypeErr}
"""
self._checkCompareObj(other)
if header:
self._compareLogPreMsg(other, lower, upper, sigma, 'results')
myRes = self.resdata
otherR = other.resdata
commonTypeKeys = getKeyMatchingShapes(myRes, otherR, 'results')
similar = len(commonTypeKeys) == len(myRes) == len(otherR)
for key in sorted(commonTypeKeys):
mine = myRes[key]
theirs = otherR[key]
if key in RES_DATA_NO_UNCS:
similar &= logDirectCompare(mine, theirs, lower, upper, key)
continue
myVals, myUncs = splitValsUncs(mine)
theirVals, theirUncs = splitValsUncs(theirs)
similar &= getLogOverlaps(key,
myVals,
theirVals,
myUncs,
theirUncs,
sigma,
relative=True)
return similar
def compareAttributes(self,
other,
lower=DEF_COMP_LOWER,
upper=DEF_COMP_UPPER,
sigma=DEF_COMP_SIGMA):
"""
Compare attributes like group structure and burnup. Return the result
Parameters
----------
other: :class:`HomogUniv`
Universe against which to compare
{compLimits}
{sigma}
Returns
-------
bools:
``True`` if the attributes agree within specifications
Raises
------
{compTypeErr}
"""
self._checkCompareObj(other)
myMeta = {}
otherMeta = {}
for key in {'bu', 'step', 'groups', 'microGroups', 'reshaped'}:
for meta, obj in zip((myMeta, otherMeta), (self, other)):
try:
meta[key] = getattr(obj, key)
except AttributeError:
meta[key] = None
matchingKeys = getKeyMatchingShapes(myMeta, otherMeta, 'metadata')
similar = len(matchingKeys) == len(myMeta)
for key in sorted(matchingKeys):
similar &= logDirectCompare(myMeta[key], otherMeta[key], lower,
upper, key)
return similar
def compareMetadata(self, other, header=False):
"""
Return True if the metadata (settings) are identical.
Parameters
----------
other: :class:`ResultsReader`
Class against which to compare
{header}
Returns
-------
bool:
If the metadata are identical
Raises
------
{compTypeErr}
"""
self._checkCompareObj(other)
if header:
self._compareLogPreMsg(other, quantity='metadata')
myKeys = set(self.metadata.keys())
otherKeys = set(other.metadata.keys())
similar = not any(myKeys.symmetric_difference(otherKeys))
commonKeys = getCommonKeys(myKeys, otherKeys, 'metadata')
skips = commonKeys.intersection(self.__METADATA_COMP_SKIPS)
if any(skips):
info("The following items will be skipped in the comparison\n\t{}".
format(', '.join(sorted(skips))))
for key in sorted(commonKeys):
if key in self.__METADATA_COMP_SKIPS:
continue
selfV = self.metadata[key]
otherV = other.metadata[key]
similar &= logDirectCompare(selfV, otherV, 0., 0., key)
return similar