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 testTableIncludingNanAndErrors(self):
X,LAMB = numpy.meshgrid(numpy.linspace(-1.5,1.5,self.n),
numpy.linspace(-1.0,1.0,self.m))
self.lambDim = LAMB[:,0]
self.xDim = numpy.linspace(-1.5,1.5,self.n)
lambField = DC.FieldContainer(self.lambDim,
unit = '1 V / m**3',
longname='parameter',
shortname=r'\lambda')
xField = DC.FieldContainer(self.xDim,
unit = '1 m',
longname = 'position',
shortname = 'x')
x0,curv,mask = Helpers.fixedPoints(lambField.data,kappa1=self.kappa1)
fixedPoints = DC.FieldContainer(numpy.array(x0).transpose(),
unit = xField.unit,
dimensions=[DC.generateIndex(0,3), lambField],
longname = 'position of the local extrema of electric potential',
shortname = 'x_0',
attributes={'title':'testTableIncludingNanAndErrors'})
fixedPoints.error = 0.1 * fixedPoints.data
fixedPoints.seal()
visualizer = self.visualizer(fixedPoints,show=False)
filename = os.path.join(self.tmpdir,'pyphant-'+DC.parseId(fixedPoints.id)[0]+'%s.%s' % (visualizer.name,outputFormat))
visualizer.figure.savefig(filename.replace(' ',''))
def testTableIncludingNanAndErrors(self):
X, LAMB = numpy.meshgrid(numpy.linspace(-1.5, 1.5, self.n),
numpy.linspace(-1.0, 1.0, self.m))
self.lambDim = LAMB[:, 0]
self.xDim = numpy.linspace(-1.5, 1.5, self.n)
lambField = DC.FieldContainer(self.lambDim,
unit='1 V / m**3',
longname='parameter',
shortname=r'\lambda')
xField = DC.FieldContainer(self.xDim,
unit='1 m',
longname='position',
shortname='x')
x0, curv, mask = Helpers.fixedPoints(lambField.data,
kappa1=self.kappa1)
fixedPoints = DC.FieldContainer(
numpy.array(x0).transpose(),
unit=xField.unit,
dimensions=[DC.generateIndex(0, 3), lambField],
longname='position of the local extrema of electric potential',
shortname='x_0',
attributes={'title': 'testTableIncludingNanAndErrors'})
fixedPoints.error = 0.1 * fixedPoints.data
fixedPoints.seal()
visualizer = self.visualizer(fixedPoints, show=False)
filename = os.path.join(
self.tmpdir, 'pyphant-' + DC.parseId(fixedPoints.id)[0] + '%s.%s' %
(visualizer.name, outputFormat))
visualizer.figure.savefig(filename.replace(' ', ''))
def testRoots(self):
"""
Test the correct computation of all local extrema
for a bistable potential.
"""
#Prepare dimensions
self.prepareDimensions()
lambField = DC.FieldContainer(
self.lambDim,
unit='1 V / m**3',
longname='parameter',
shortname='\lambda'
)
xField = DC.FieldContainer(
self.xDim[0],
unit='1 m',
longname='position',
shortname='x'
)
#Prepare potential
V = []
for i in xrange(len(lambField.data)):
u = xField.data
V.append(
-lambField.data[i] / 2 * u ** 2 + u ** 4 / 4 - u * self.kappa1
)
self.V = DC.FieldContainer(
numpy.array(V), unit='1 V', dimensions=[lambField, xField],
longname = 'electric potential',
shortname = r'\varphi'
)
#Predict result
x0, curv, mask = fixedPoints(lambField.data, kappa1=self.kappa1)
x0 = numpy.where(curv > 0, x0, numpy.NaN)
data = x0[:, ::2]
dims = [DC.generateIndex(0, 2), lambField]
expectedResult = DC.FieldContainer(
data.transpose(),
unit=xField.unit,
mask=numpy.isnan(data).transpose(),
dimensions=dims,
longname='position of the local extrema of electric potential',
shortname='x_0'
)
#Configure worker
w = MRA.MRA(None)
w.paramScale.value = "1.0m"
#Retrieve result from worker
result = copy.deepcopy(w.mra(self.V))['x_{min}']
result.error=None
self.test(result,expectedResult,1e-2,1e-2)
def testRoots(self):
"""
Test the correct computation of all local extrema
for a bistable potential.
"""
#Prepare dimensions
self.prepareDimensions()
lambField = DC.FieldContainer(
self.lambDim,
unit='1 V / m**3',
longname='parameter',
shortname='\lambda'
)
xField = DC.FieldContainer(
self.xDim[0],
unit='1 m',
longname='position',
shortname='x'
)
#Prepare potential
V = []
for i in xrange(len(lambField.data)):
u = xField.data
V.append(
-lambField.data[i] / 2 * u ** 2 + u ** 4 / 4 - u * self.kappa1
)
self.V = DC.FieldContainer(
numpy.array(V), unit='1 V', dimensions=[lambField, xField],
longname = 'electric potential',
shortname = r'\varphi'
)
#Predict result
x0, curv, mask = fixedPoints(lambField.data, kappa1=self.kappa1)
x0 = numpy.where(curv > 0, x0, numpy.NaN)
data = x0[:, ::2]
dims = [DC.generateIndex(0, 2), lambField]
expectedResult = DC.FieldContainer(
data.transpose(),
unit=xField.unit,
mask=numpy.isnan(data).transpose(),
dimensions=dims,
longname='position of the local extrema of electric potential',
shortname='x_0'
)
#Configure worker
w = MRA.MRA(None)
w.paramScale.value = "1.0m"
#Retrieve result from worker
result = copy.deepcopy(w.mra(self.V))['x_{min}']
result.error=None
self.test(result,expectedResult,1e-2,1e-2)
def testNegligibleNoise(self):
"""Tests the merging of abscissae data in case of negliglible deviation."""
worker = OA.OscAbsorptionCalculator()
worker.paramClipping.value = 0
self.sampleC['I'].dimensions[-1].data += 1e-8*numpy.random.randn(self.n)
self.sampleC.seal()
result = worker.calcAbsorption(self.sampleC)
expectedDim = [DC.generateIndex(1,self.m),
DC.FieldContainer(self.x,longname='position',shortname='x',unit='1m')]
expectedResult = DC.FieldContainer(numpy.ones((self.m,self.n),'float')-self.I.data,
dimensions=expectedDim,
longname=u'absorption',
shortname=ur'\tilde{A}')
self.assertEqual(result,expectedResult)
def testCalculation(self):
"""Tests the correct calculation of absorption without clipping.
It is assumed, that the dark reference intensity is equal to zero,
while white reference intensity is equal to one."""
worker = OA.OscAbsorptionCalculator()
worker.paramClipping.value = 0
self.sampleC.seal()
result = worker.calcAbsorption(self.sampleC)
expectedDim = [DC.generateIndex(1,self.m),
DC.FieldContainer(self.x,longname='position',shortname='x',unit='1m')]
expectedResult = DC.FieldContainer(numpy.ones((self.m,self.n),'float')-self.I.data,
dimensions=expectedDim,
longname=u'absorption',
shortname=ur'\tilde{A}')
self.assertEqual(result,expectedResult)
def testRoots(self):
"""Test the correct computation of all local extrema for a bistable potential."""
#Prepare dimensions
self.prepareDimensions()
lambField = DC.FieldContainer(self.lambDim,
unit='1 V / m**3',
longname='parameter',
shortname='\lambda')
xField = DC.FieldContainer(self.xDim[0],
unit='1 m',
longname='position',
shortname='x')
#Prepare potential
V = []
for i in xrange(len(lambField.data)):
u = xField.data
V.append(-lambField.data[i] / 2 * u**2 + u**4 / 4 -
u * self.kappa1)
self.V = DC.FieldContainer(numpy.array(V),
unit='1 V',
dimensions=[lambField, xField],
longname='electric potential',
shortname=r'\varphi')
#Predict result
x0, curv, mask = fixedPoints(lambField.data, kappa1=self.kappa1)
error = 1.0 / curv.transpose()
error[:] = numpy.nan
data = x0.transpose()
expectedResult = DC.FieldContainer(
data,
unit=xField.unit,
mask=numpy.isnan(data),
dimensions=[DC.generateIndex(0, 3), lambField],
longname='position of the local extrema of electric potential',
shortname='x_0')
#Configure worker
w = EF.ExtremumFinder(None)
w.paramExtremum.value = u'both'
#Retrieve result from worker
result = w.locate(self.V)
self.test(result, expectedResult)
def testCalculation(self):
"""Tests the correct calculation of absorption without clipping.
It is assumed, that the dark reference intensity is equal to zero,
while white reference intensity is equal to one."""
worker = OA.OscAbsorptionCalculator()
worker.paramClipping.value = 0
self.sampleC.seal()
result = worker.calcAbsorption(self.sampleC)
expectedDim = [
DC.generateIndex(1, self.m),
DC.FieldContainer(self.x,
longname='position',
shortname='x',
unit='1m')
]
expectedResult = DC.FieldContainer(numpy.ones(
(self.m, self.n), 'float') - self.I.data,
dimensions=expectedDim,
longname=u'absorption',
shortname=ur'\tilde{A}')
self.assertEqual(result, expectedResult)
def testNegligibleNoise(self):
"""Tests the merging of abscissae data in case of negliglible deviation."""
worker = OA.OscAbsorptionCalculator()
worker.paramClipping.value = 0
self.sampleC['I'].dimensions[-1].data += 1e-8 * numpy.random.randn(
self.n)
self.sampleC.seal()
result = worker.calcAbsorption(self.sampleC)
expectedDim = [
DC.generateIndex(1, self.m),
DC.FieldContainer(self.x,
longname='position',
shortname='x',
unit='1m')
]
expectedResult = DC.FieldContainer(numpy.ones(
(self.m, self.n), 'float') - self.I.data,
dimensions=expectedDim,
longname=u'absorption',
shortname=ur'\tilde{A}')
self.assertEqual(result, expectedResult)
def testRoots(self):
"""Test the correct computation of all local extrema for a bistable potential."""
#Prepare dimensions
self.prepareDimensions()
lambField = DC.FieldContainer(self.lambDim,
unit = '1 V / m**3',
longname='parameter',
shortname='\lambda')
xField = DC.FieldContainer(self.xDim[0],
unit = '1 m',
longname = 'position',
shortname = 'x')
#Prepare potential
V = []
for i in xrange(len(lambField.data)):
u = xField.data
V.append(-lambField.data[i]/2* u**2 + u**4/4-u*self.kappa1)
self.V = DC.FieldContainer(numpy.array(V),unit='1 V',dimensions=[lambField,xField],
longname = 'electric potential',
shortname=r'\varphi')
#Predict result
x0,curv,mask = fixedPoints(lambField.data,kappa1=self.kappa1)
error = 1.0/curv.transpose()
error[:] =numpy.nan
data = x0.transpose()
expectedResult = DC.FieldContainer(data,
unit = xField.unit,
mask = numpy.isnan(data),
dimensions=[DC.generateIndex(0,3),lambField],
longname = 'position of the local extrema of electric potential',
shortname = 'x_0')
#Configure worker
w = EF.ExtremumFinder(None)
w.paramExtremum.value=u'both'
#Retrieve result from worker
result = w.locate(self.V)
self.test(result,expectedResult)
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
