示例#1
0
 def testConstantRegion(self):
     """A constant region does not have any local extrema and NaN values should be returned."""
     y = numpy.array([2,2,2],'f')
     result =  EF.estimateExtremumPosition(y,self.x)
     self.assertEqual(result,(numpy.NaN,numpy.NaN,numpy.NaN))
     result =  EF.estimateExtremumPosition(y,self.x,sigmaY=self.zeros)
     self.assertEqual(result,(numpy.NaN,numpy.NaN,numpy.NaN))
示例#2
0
 def testExactGeneric(self):
     result =  EF.estimateExtremumPosition(self.y,self.x)
     self.assertEqual(result,(2.5+1/1.5,numpy.NaN,1.0))
     result =  EF.estimateExtremumPosition(self.y,self.x,sigmaY=self.zeros)
     self.assertEqual(result,(2.5+1/1.5,0.0,1.0))
     result =  EF.estimateExtremumPosition(self.y,self.x,sigmaY=self.error)
     numpy.testing.assert_almost_equal(numpy.array(result),
                                       numpy.array((2.5+1/1.5,0.02/1.5**2,1.0)))
示例#3
0
 def testSymmetricMaximum(self):
     y = numpy.array([2,2,1],'f')
     result =  EF.estimateExtremumPosition(y,self.x)
     self.assertEqual(result,(2.5,numpy.NaN,-1.0))
     result =  EF.estimateExtremumPosition(y,self.x,sigmaY=self.zeros)
     self.assertEqual(result,(2.5,0.0,-1.0))
     result =  EF.estimateExtremumPosition(y,self.x,sigmaY=self.error)
     numpy.testing.assert_almost_equal(numpy.array(result),
                                       numpy.array((2.5,0.02,-1.0)))
示例#4
0
 def testExactMaximum(self):
     y = numpy.array([2,3,2],'f')
     result =  EF.estimateExtremumPosition(y,self.x)
     self.assertEqual(result,(3.0,numpy.NaN,-1.0))
     result =  EF.estimateExtremumPosition(y,self.x,sigmaY=self.zeros)
     self.assertEqual(result,(3.0,0.0,-1.0))
     result =  EF.estimateExtremumPosition(y,self.x,sigmaY=self.error)
     numpy.testing.assert_almost_equal(numpy.array(result),
                                       numpy.array((3.0,0.005,-1.0)))
示例#5
0
 def testParabelArray(self):
     x = numpy.array([-2,-1,0,1,2],'float')
     field = numpy.array([(x-0.2)**2-0.5,(x+0.1)**2])
     inputField = DC.FieldContainer(field,
                                    error=numpy.resize(numpy.repeat(0.1,len(field)),field.shape),
                                    dimensions=[DC.FieldContainer(numpy.array([1,2]),
                                                                  longname='type',shortname=r'\theta'),
                                                DC.FieldContainer(x,longname='position',shortname='x')],
                                    longname='parabel',
                                    shortname='f')
     def error(y):
         error  = inputField.error[0,0] / (y[1]-2*y[2]+y[3])**2
         error *= numpy.abs(y[2]-y[3]) + numpy.abs(y[1]-y[3]) + numpy.abs(y[1]-y[2])
         return error
     expectedResult = DC.FieldContainer(numpy.array([[0.2,-0.1]]),
                                        longname = 'position of the local minima of parabel',
                                        shortname = 'x_0',
                                        error = numpy.array([[error(field[0]),error(field[1])]]))
     expectedResult.dimensions[-1] = DC.FieldContainer(numpy.array([1,2]),
                                                       longname='type',
                                                       shortname=r'\theta')
     w = EF.ExtremumFinder(None)
     w.paramExtremum.value=u'minima'
     #Retrieve result from worker
     result = w.locate(inputField)
     DC.assertEqual(result,expectedResult)
示例#6
0
 def testParabel(self):
     x = numpy.array([-2, -1, 0, 1, 2], 'float') + 0.1
     y = x**2
     inputField = DC.FieldContainer(y,
                                    error=numpy.repeat(0.1, len(y)),
                                    dimensions=[
                                        DC.FieldContainer(
                                            x,
                                            longname='abscissae',
                                            shortname='x')
                                    ],
                                    longname='parabel',
                                    shortname='f')
     error = inputField.error[slice(0, 1)] / (y[1] - 2 * y[2] + y[3])**2
     error *= numpy.abs(y[2] - y[3]) + numpy.abs(y[1] -
                                                 y[3]) + numpy.abs(y[1] -
                                                                   y[2])
     expectedResult = DC.FieldContainer(
         numpy.array([0.0]),
         longname='position of the local minimum of parabel',
         shortname='x_0',
         error=error)
     w = EF.ExtremumFinder(None)
     w.paramExtremum.value = u'minima'
     #Retrieve result from worker
     result = w.locate(inputField)
     DC.assertEqual(result, expectedResult)
示例#7
0
 def testMinima(self):
     """Test the correct computation of all local minima for a bistable potential."""
     #Predict result
     x0,curv,mask = fixedPoints(numpy.array([self.LAMBDA]),kappa1=self.kappa1)
     expectedResult = DC.FieldContainer(numpy.extract(curv[0]>0,x0[0]),
                                        unit = self.xField.unit,
                                        longname = 'position of the local minima of electric potential',
                                        shortname = 'x_0')
     #Retrieve result from worker
     w = EF.ExtremumFinder(None)
     w.paramExtremum.value=u'minima'
     result = w.locate(self.V)
     #Testing
     DC.assertEqual(result,expectedResult)
示例#8
0
 def testParabelSymmetricallyBoxedMinimum(self):
     x = numpy.array([-2,-1,0,1,2],'float')-0.5
     y = x**2
     inputField = DC.FieldContainer(y,
                                    error=numpy.repeat(0.1,len(y)),
                                    dimensions=[DC.FieldContainer(x,longname='abscissae',shortname='x')],
                                    longname='parabel',
                                    shortname='f'
                                    )
     expectedResult = DC.FieldContainer(numpy.array([0.0]),
                                        longname = 'position of the local minimum of parabel',
                                        shortname = 'x_0',
                                        error = numpy.array([0.1])
                                        )
     w = EF.ExtremumFinder(None)
     w.paramExtremum.value=u'minima'
     #Retrieve result from worker
     result = w.locate(inputField)
     DC.assertEqual(result,expectedResult)
示例#9
0
 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)