Fitting kind of works

analysis.py

@@ -81,8 +81,12 @@ class Analysis:
         y = B[1] + np.sqrt(B[0]**2 - (z-B[2])**2)
         return y
 
+
+    def pol(self, B, x):
+        return B[0] + B[1]*x + B[2]*(x**2) + B[3]*(x**3)
+
     def xFit(self):
-        xModel  = odr.Model(self.xEOM)
+        xModel  = odr.Model(self.pol)#self.xEOM)
         xData   = odr.RealData(self.xPoints['Mean'],
                                self.zPoints['Mean'],
                                sx = self.xPoints['Error'],
@@ -90,6 +94,10 @@ class Analysis:
         xODR = odr.ODR(xData, xModel, beta0=[1, 100, 100, 100])
         xOUT = xODR.run()
         xOUT.pprint()
+        print(xOUT.beta)
+        plt.plot(self.pol(xOUT.beta, self.xPoints['Mean']), self.xPoints['Mean'])
+        plt.plot(self.zPoints['Mean']+5, self.xPoints['Mean'])
+        plt.show()
         """
         xPopt, xPcov = curve_fit(self.xEOM,
                                  self.xPoints['Mean'],
@@ -127,6 +135,9 @@ class Analysis:
         yODR = odr.ODR(yData, yModel, beta0=[1e3, 100, 100])
         yOUT = yODR.run()
         yOUT.pprint()
+        plt.plot(self.zPoints['Mean'], self.yEOM(yOUT.beta, self.zPoints['Mean']))
+        plt.plot(self.zPoints['Mean'], self.yPoints['Mean'])
+        plt.show()
         """
         self.results['R'][0] = yPopt[0]
         self.results['R'][1] = yPerr[0]

testAnalysis.py

@@ -7,30 +7,30 @@ class testAnalysis(unittest.TestCase):
     """
     A simple test to check the angle means ans error computation.
     """
+
     def testxFit(self):
         #ang = np.array([6,5,6,5,8,4,8,4,7,1,7,1,10,3,10,3,None,None,None,None])
         #ang = np.reshape(ang, (5,2,2))
         A = Analysis()
         #self.assertEqual(A.results['Mean'][0], 5.5)
         #self.assertEqual(A.results['Error'][0], 0.5)
-        
 
-        z = np.arange(0, 30)
-        y = A.yEOM([1000,1,1], z)
-        #plt.plot(z,y)
+        x = np.arange(0, 6)
+        z = A.xEOM([1,20,10,100], x)
+        #plt.plot(z,x)
         #plt.show()
         
         Data = []
         for i in range(0,len(z)):
             err =0.01* np.random.random(size=(4))
             #print(err)
-            Data.append([[0,0], [y[i]+err[0],y[i]-err[1]], [z[i]+err[2], z[i]-err[3]]])
+            Data.append([[x[i]+err[0],x[i]-err[1]], [0,0], [z[i]+err[2], z[i]-err[3]]])
             #np.concatenate((Data,
             #        [[0,0], [y[i]+0.1,y[i]-0.1], [z[i]+0.1, z[i]-0.1]]), axis=0)
         Data = np.array(Data)
 
         A.fill(Data)
-        A.yFit()
+        A.xFit()
         #print(y)
         #print(z)
         #print(Data)
@@ -43,22 +43,22 @@ class testAnalysis(unittest.TestCase):
         #self.assertEqual(A.results['Error'][0], 0.5)
         
 
-        x = np.arange(0, 10, 0.1)
-        z = A.xEOM([1,10,10,100], x)
-        #plt.plot(z,x)
+        z = np.arange(0, 6)
+        y = A.yEOM([1000,100,100], z)
+        #plt.plot(z,y)
         #plt.show()
         
         Data = []
         for i in range(0,len(z)):
-            err =0.01* np.random.random(size=(4))
+            err =0.001* np.random.random(size=(4))
             #print(err)
-            Data.append([[x[i]+err[0],x[i]-err[1]], [0,0], [z[i]+err[2], z[i]-err[3]]])
+            Data.append([[0,0], [y[i]+err[0],y[i]-err[1]], [z[i]+err[2], z[i]-err[3]]])
             #np.concatenate((Data,
             #        [[0,0], [y[i]+0.1,y[i]-0.1], [z[i]+0.1, z[i]-0.1]]), axis=0)
         Data = np.array(Data)
 
         A.fill(Data)
-        A.xFit()
+        A.yFit()
         #print(y)
         #print(z)
         #print(Data)