def longname2unit(name):
reg = re.compile(r"\[([^]]*)\]")
m = reg.search(name)
if not m or m.group(1) == "counts" or m.group(1) == "":
return 1.0
else:
return quantities.Quantity('1 ' + str(m.group(1)))
def createFieldContainer(key, array):
def longname2unit(name):
reg = re.compile(r"\[([^]]*)\]")
m = reg.search(name)
if not m or m.group(1) == "counts" or m.group(1) == "":
return 1.0
else:
return quantities.Quantity('1 ' + str(m.group(1)))
fieldUnit = longname2unit(key)
if quantities.isQuantity(fieldUnit):
fieldContainer = DataContainer.FieldContainer(numpy.array(array),
unit=fieldUnit,
longname=key)
else:
try:
quantities = [
quantities.Quantity(string.encode('latin-1'))
for string in array
]
firstUnit = quantities[0].unit
scaledArray = [
quant.inUnitsOf(firstUnit).value for quant in quantities
]
fieldContainer = DataContainer.FieldContainer(
numpy.array(scaledArray),
unit='1. %s' % firstUnit.name(),
longname=key)
except:
fieldContainer = DataContainer.FieldContainer(numpy.array(array),
unit=fieldUnit,
longname=key)
return fieldContainer
def testSimpleYScale(self):
"""Check for correct handling of yScale."""
unit = "57 m"
punit = pq.Quantity(unit)
self.worker.paramYScale.value = unit
gs = self.worker.plugLoadImageAsGreyScale.getResult()
self.assertEqual(gs.dimensions[-2].unit.unit, punit.unit)
self.assertEqual(gs.dimensions[-2].unit.value, 1)
self.assertAlmostEqual(gs.dimensions[-2].data.max(), punit.value)
def testLink2X(self):
"""Check for correct inferrence of yScale from set xScale."""
unit = "32 m"
punit = pq.Quantity(unit)
self.worker.paramXScale.value = unit
self.worker.paramYScale.value = "link2X"
gs = self.worker.plugLoadImageAsGreyScale.getResult()
self.assertEqual(gs.dimensions[-2].unit.unit, punit.unit)
self.assertEqual(gs.dimensions[-2].unit.value, 1)
self.assertAlmostEqual(gs.dimensions[-1].data.max(), punit.value)
self.assertEqual(gs.dimensions[-1].unit.unit, punit.unit)
self.assertEqual(gs.dimensions[-1].unit.value, 1)
ny, nx = gs.data.shape
self.assertAlmostEqual(gs.dimensions[-2].data.max(), punit.value*ny/nx)
def calcCurrentDensity(self, osc, model, subscriber=0):
#Compute conversion factor between units
#{u'\\Psi_{1}': Quantity(1.0,'mA/cm**2'),
# u'\\Psi_{2}': 1.0, u'\\Psi_{3}': Quantity(1.0,'nm'),
# u'\\Psi_{4}': 1.0, u'\\Psi_{0}': 1.0}
unit = model._units[u'\\Psi_{3}']
inputUnit = osc.unit
assert inputUnit.isCompatible(
unit.unit), 'Units of input and output data are not compatible.'
factor = inputUnit.inUnitsOf(unit.unit).value
#Get model
modelOperator = createModel(model)
#Apply model
inputData = factor * osc.data
resultData = modelOperator(inputData)
if resultData.min() == 0 and resultData.max() == 0:
_logger.warning("The model does not describe the considered data.")
#Incorporate area of probe
if self.paramDiameter.value == 'unknown':
factor = 1.0
else:
diameter = quantities.Quantity(
self.paramDiameter.value.encode('latin-1'))
factor = 0.25 * numpy.pi * diameter**2
scaledUnit = factor * model._units[u'\\Psi_{1}']
#Build Fieldcontainer
result = DataContainer.FieldContainer(
resultData,
mask=osc.mask,
longname=u'maximal short current density',
shortname=u'\sigma',
unit=scaledUnit,
rescale=True,
dimensions=copy.deepcopy(osc.dimensions))
result.seal()
return result
def mra(self, field, subscriber=0):
dim = field.dimensions[-1]
try:
scale = quantities.Quantity(self.paramScale.value.encode('utf-8'))
except:
scale = float(self.paramScale.value)
numb_edge = 100.0 / self.paramNumb_edge.value
d = scipy.diff(dim.data)
numpy.testing.assert_array_almost_equal(d.min(), d.max(), 4)
sigmaMax = scale / (d[0] * dim.unit)
if len(field.data.shape) > 1:
p_e = []
inc = 100. / len(field.data)
acc = 0.
for field1d in field:
try:
p_e.append(mra1d(dim, field1d, sigmaMax, numb_edge))
except MraError:
p_e.append((([], []), ([], [])))
acc += inc
subscriber %= acc
minima, maxima = zip(*p_e)
n_min, pos_min, err_min = pos_error_to_data_container(minima)
n_max, pos_max, err_max = pos_error_to_data_container(maxima)
dims_min = [
DataContainer.generateIndex(0, n_min), field.dimensions[0]
]
dims_max = [
DataContainer.generateIndex(0, n_max), field.dimensions[0]
]
else:
(pos_min, err_min), (pos_max,
err_max) = mra1d(dim, field, sigmaMax,
numb_edge)
dims_min = [DataContainer.generateIndex(0, len(pos_min))]
dims_max = [DataContainer.generateIndex(0, len(pos_max))]
subscriber %= 100.
minima = DataContainer.FieldContainer(
pos_min.transpose(),
error=err_min.transpose(),
unit=dim.unit,
dimensions=dims_min,
mask=numpy.isnan(pos_min).transpose(),
longname="%s of the local %s of %s" %
(dim.longname, "minima", field.longname),
shortname="%s_{min}" % dim.shortname)
maxima = DataContainer.FieldContainer(
pos_max.transpose(),
error=err_max.transpose(),
unit=dim.unit,
dimensions=dims_max,
mask=numpy.isnan(pos_max).transpose(),
longname="%s of the local %s of %s" %
(dim.longname, "maxima", field.longname),
shortname="%s_{max}" % dim.shortname)
roots = DataContainer.SampleContainer(
[minima, maxima],
longname="%s of the local %s of %s" %
(dim.longname, "extrema", field.longname),
shortname="%s_{extrem}" % dim.shortname)
if self.paramLongname.value != 'default':
roots.longname = self.paramLongname.value
if self.paramSymbol.value != 'default':
roots.shortname = self.paramSymbol.value
roots.seal()
return roots
def testArbitraryFieldUnit(self):
"""Check for correct setting of field unit in an arbitrary case."""
unit = "2345 V/m"
self.worker.paramFieldUnit.value = unit
gs = self.worker.plugLoadImageAsGreyScale.getResult()
self.assertEqual(gs.unit, pq.Quantity(unit))
