def test_fit_eval_func1(self): """NonLinearLeastSquaresFit: Basic function fitting and evaluation using data from a known function.""" interp = NonLinearLeastSquaresFit(self.vFunc, self.init_params) interp.fit(self.x, self.y) y = interp(self.x) assert_almost_equal(interp.params, self.true_params, decimal=7) assert_almost_equal(y, self.y, decimal=5)
def test_fit_eval_gauss(self): """NonLinearLeastSquaresFit: Check fit on a 2-D log Gaussian function.""" interp2 = NonLinearLeastSquaresFit(self.func2, self.init_params2) interp2.fit(self.x2, self.y2) y2 = interp2(self.x2) assert_almost_equal(interp2.params, self.true_params2, decimal=10) assert_almost_equal(y2, self.y2, decimal=10)
def test_fit_eval_linear(self): """NonLinearLeastSquaresFit: Do linear problem and check Jacobian.""" lin = LinearLeastSquaresFit() lin.fit(self.x3, self.y3, std_y=2.0) nonlin = NonLinearLeastSquaresFit(self.func3, self.init_params3, func_jacobian=self.jac3) nonlin.fit(self.x3, self.y3, std_y=2.0) # A correct Jacobian helps a lot... assert_almost_equal(nonlin.params, self.true_params3, decimal=11) assert_almost_equal(nonlin.cov_params, lin.cov_params, decimal=11) nonlin_nojac = NonLinearLeastSquaresFit(self.func3, self.init_params3) nonlin_nojac.fit(self.x3, self.y3, std_y=0.1) assert_almost_equal(nonlin_nojac.params, self.true_params3, decimal=5)
def test_enabled_params(self): """NonLinearLeastSquaresFit: Check whether subset of parameters can be optimised.""" lin = LinearLeastSquaresFit() lin.fit(self.x3[self.enabled_params_int, :], self.y3, std_y=2.0) lin_cov_params = np.zeros( (len(self.true_params3), len(self.true_params3))) lin_cov_params[np.ix_(self.enabled_params_int, self.enabled_params_int)] = lin.cov_params nonlin = NonLinearLeastSquaresFit(self.func3, self.init_params3, self.enabled_params_int, self.jac3) nonlin.fit(self.x3, self.y3, std_y=2.0) assert_almost_equal(nonlin.params, self.true_params3, decimal=11) assert_almost_equal(nonlin.cov_params, lin_cov_params, decimal=11) nonlin = NonLinearLeastSquaresFit(self.func3, self.init_params3, self.enabled_params_bool, self.jac3) nonlin.fit(self.x3, self.y3, std_y=2.0) assert_almost_equal(nonlin.params, self.true_params3, decimal=11) assert_almost_equal(nonlin.cov_params, lin_cov_params, decimal=11)
def test_fit_eval_linear(self): """NonLinearLeastSquaresFit: Compare to LinearLeastSquaresFit on a linear problem (and check use of Jacobian).""" lin = LinearLeastSquaresFit() lin.fit(self.x3, self.y3, std_y=2.0) nonlin = NonLinearLeastSquaresFit(self.func3, self.init_params3, func_jacobian=self.jac3) nonlin.fit(self.x3, self.y3, std_y=2.0) # A correct Jacobian helps a lot... assert_almost_equal(nonlin.params, self.true_params3, decimal=11) assert_almost_equal(nonlin.cov_params, lin.cov_params, decimal=11) nonlin_nojac = NonLinearLeastSquaresFit(self.func3, self.init_params3) nonlin_nojac.fit(self.x3, self.y3, std_y=0.1) assert_almost_equal(nonlin_nojac.params, self.true_params3, decimal=6)
def test_enabled_params(self): """NonLinearLeastSquaresFit: Check whether subset of parameters can be optimised.""" lin = LinearLeastSquaresFit() lin.fit(self.x3[self.enabled_params_int, :], self.y3, std_y=2.0) lin_cov_params = np.zeros((len(self.true_params3), len(self.true_params3))) lin_cov_params[np.ix_(self.enabled_params_int, self.enabled_params_int)] = lin.cov_params nonlin = NonLinearLeastSquaresFit(self.func3, self.init_params3, self.enabled_params_int, self.jac3) nonlin.fit(self.x3, self.y3, std_y=2.0) assert_almost_equal(nonlin.params, self.true_params3, decimal=11) assert_almost_equal(nonlin.cov_params, lin_cov_params, decimal=11) nonlin = NonLinearLeastSquaresFit(self.func3, self.init_params3, self.enabled_params_bool, self.jac3) nonlin.fit(self.x3, self.y3, std_y=2.0) assert_almost_equal(nonlin.params, self.true_params3, decimal=11) assert_almost_equal(nonlin.cov_params, lin_cov_params, decimal=11)
def generatespiral(totextent, tottime, tracktime=1, sampletime=1, kind='uniform', mirrorx=False): totextent = np.float(totextent) tottime = np.float(tottime) sampletime = np.float(sampletime) nextrazeros = int(np.float(tracktime) / sampletime) print 'nextrazeros', nextrazeros tracktime = nextrazeros * sampletime radextent = np.float(totextent) / 2.0 if (kind == 'dense-core'): c = np.sqrt(2) * 180.0 / (16.0 * np.pi) narms = 2 * int( np.sqrt(tottime / c + (tracktime / c)**2) - tracktime / c ) #ensures even number of arms - then scan pattern ends on target (if odd it will not) ntime = int((tottime - tracktime * narms) / (sampletime * narms)) armrad = radextent * (np.linspace(0, 1, ntime)) armtheta = np.linspace(0, np.pi, ntime) armx = armrad * np.cos(armtheta) army = armrad * np.sin(armtheta) elif (kind == 'approx'): c = 180.0 / (16.0 * np.pi) narms = 2 * int( np.sqrt(tottime / c + (tracktime / c)**2) - tracktime / c ) #ensures even number of arms - then scan pattern ends on target (if odd it will not) ntime = int((tottime - tracktime * narms) / (sampletime * narms)) armrad = radextent * (np.linspace(0, 1, ntime)) armtheta = np.linspace(0, np.pi, ntime) armx = armrad * np.cos(armtheta) army = armrad * np.sin(armtheta) dist = np.sqrt((armx[:-1] - armx[1:])**2 + (army[:-1] - army[1:])**2) narmrad = np.cumsum(np.concatenate([np.array([0]), 1.0 / dist])) narmrad *= radextent / max(narmrad) narmtheta = narmrad / radextent * np.pi armx = narmrad * np.cos(narmtheta) army = narmrad * np.sin(narmtheta) else: #'uniform' c = 180.0 / (16.0 * np.pi) narms = 2 * int( np.sqrt(tottime / c + (tracktime / c)**2) - tracktime / c ) #ensures even number of arms - then scan pattern ends on target (if odd it will not) ntime = int((tottime - tracktime * narms) / (sampletime * narms)) armx = np.zeros(ntime) army = np.zeros(ntime) #must be on curve x=t*cos(np.pi*t),y=t*sin(np.pi*t) #intersect (x-x0)**2+(y-y0)**2=1/ntime**2 with spiral lastr = 0.0 for it in range(1, ntime): data = np.array([1.0 / ntime]) indep = np.array([armx[it - 1], army[it - 1] ]) #last calculated coordinate in arm, is x0,y0 initialparams = np.array([lastr + 1.0 / ntime]) fitter = NonLinearLeastSquaresFit(spiral, initialparams) fitter.fit(indep, data) lastr = fitter.params[0] armx[it] = lastr * np.cos(2.0 * np.pi * lastr) army[it] = lastr * np.sin(2.0 * np.pi * lastr) maxrad = np.sqrt(armx[it]**2 + army[it]**2) armx = armx * radextent / maxrad army = army * radextent / maxrad # ndist=sqrt((armx[:-1]-armx[1:])**2+(army[:-1]-army[1:])**2) # print ndist compositex = [[] for ia in range(narms)] compositey = [[] for ia in range(narms)] ncompositex = [[] for ia in range(narms)] ncompositey = [[] for ia in range(narms)] reverse = False for ia in range(narms): rot = -ia * np.pi * 2.0 / narms x = armx * np.cos(rot) - army * np.sin(rot) y = armx * np.sin(rot) + army * np.cos(rot) nrot = ia * np.pi * 2.0 / narms nx = armx * np.cos(nrot) - army * np.sin(nrot) ny = armx * np.sin(nrot) + army * np.cos(nrot) if (nextrazeros > 0): x = np.r_[np.repeat(0.0, nextrazeros), x] y = np.r_[np.repeat(0.0, nextrazeros), y] nx = np.r_[np.repeat(0.0, nextrazeros), nx] ny = np.r_[np.repeat(0.0, nextrazeros), ny] if reverse: reverse = False x = x[::-1] y = y[::-1] nx = nx[::-1] ny = ny[::-1] else: reverse = True if (mirrorx): compositex[ia] = -x compositey[ia] = y ncompositex[ia] = -nx ncompositey[ia] = ny else: compositex[ia] = x compositey[ia] = y ncompositex[ia] = nx ncompositey[ia] = ny return compositex, compositey, ncompositex, ncompositey