示例#1
0
 def testSetProfile(self):
     fc = self.fitcontribution
     profile = self.profile
     fc.setProfile(self.profile)
     # verify standard profile setup
     self.assertTrue(fc.profile is profile)
     self.assertTrue(fc.x.par is profile.xpar)
     self.assertTrue(fc.y.par is profile.ypar)
     self.assertTrue(fc.dy.par is profile.dypar)
     self.assertTrue(fc._eq is None)
     self.assertTrue(fc._reseq is None)
     # check type checking
     fc1 = FitContribution('test1')
     self.assertRaises(TypeError, fc1.setProfile, 'invalid')
     # check if residual equation is set up when possible
     fc2 = FitContribution('test2')
     fc2.setEquation('A * x')
     fc2.setProfile(profile)
     self.assertFalse(fc2._reseq is None)
     return
示例#2
0
    def setUp(self):
        self.recipe = FitRecipe("recipe")
        self.recipe.fithooks[0].verbose = 0

        # Set up the Profile
        self.profile = Profile()
        x = linspace(0, pi, 10)
        y = sin(x)
        self.profile.setObservedProfile(x, y)

        # Set up the FitContribution
        self.fitcontribution = FitContribution("cont")
        self.fitcontribution.setProfile(self.profile)
        self.fitcontribution.setEquation("A*sin(k*x + c)")
        self.fitcontribution.A.setValue(1)
        self.fitcontribution.k.setValue(1)
        self.fitcontribution.c.setValue(0)

        self.recipe.addContribution(self.fitcontribution)
        return
示例#3
0
 def setUp(self):
     self.gen = ProfileGenerator("test")
     self.profile = Profile()
     self.fitcontribution = FitContribution("test")
     return
示例#4
0
    def testResidual(self):
        """Test the residual, which requires all other methods."""
        fc = self.fitcontribution
        profile = self.profile
        gen = self.gen

        # Add the calculator and profile
        fc.setProfile(profile)
        self.assertTrue(fc.profile is profile)
        fc.addProfileGenerator(gen, "I")
        self.assertTrue(fc._eq._value is None)
        self.assertTrue(fc._reseq._value is None)
        self.assertEqual(1, len(fc._generators))
        self.assertTrue(gen.name in fc._generators)

        # Let's create some data
        xobs = arange(0, 10, 0.5)
        yobs = xobs
        profile.setObservedProfile(xobs, yobs)

        # Check our fitting equation.
        self.assertTrue(array_equal(fc._eq(), gen(xobs)))

        # Now calculate the residual
        chiv = fc.residual()
        self.assertAlmostEqual(0, dot(chiv, chiv))

        # Now change the equation
        fc.setEquation("2*I")
        self.assertTrue(fc._eq._value is None)
        self.assertTrue(fc._reseq._value is None)
        chiv = fc.residual()
        self.assertAlmostEqual(dot(yobs, yobs), dot(chiv, chiv))

        # Try to add a parameter
        c = Parameter("c", 2)
        fc._addParameter(c)
        fc.setEquation("c*I")
        self.assertTrue(fc._eq._value is None)
        self.assertTrue(fc._reseq._value is None)
        chiv = fc.residual()
        self.assertAlmostEqual(dot(yobs, yobs), dot(chiv, chiv))

        # Try something more complex
        c.setValue(3)
        fc.setEquation("c**2*sin(I)")
        self.assertTrue(fc._eq._value is None)
        self.assertTrue(fc._reseq._value is None)
        xobs = arange(0, 10, 0.5)
        yobs = 9 * sin(xobs)
        profile.setObservedProfile(xobs, yobs)
        self.assertTrue(fc._eq._value is None)
        self.assertTrue(fc._reseq._value is None)

        chiv = fc.residual()
        self.assertAlmostEqual(0, dot(chiv, chiv))

        # Choose a new residual.
        fc.setEquation("2*I")
        fc.setResidualEquation("resv")
        chiv = fc.residual()
        self.assertAlmostEqual(
            sum((2 * xobs - yobs)**2) / sum(yobs**2), dot(chiv, chiv))

        # Make a custom residual.
        fc.setResidualEquation("abs(eq-y)**0.5")
        chiv = fc.residual()
        self.assertAlmostEqual(sum(abs(2 * xobs - yobs)), dot(chiv, chiv))

        # Test configuration checks
        fc1 = FitContribution('test1')
        self.assertRaises(SrFitError, fc1.setResidualEquation, 'chiv')
        fc1.setProfile(self.profile)
        self.assertRaises(SrFitError, fc1.setResidualEquation, 'chiv')
        fc1.setEquation('A * x')
        fc1.setResidualEquation('chiv')
        self.assertTrue(noObserversInGlobalBuilders())
        return