def fit_it(params, args, method='nelder', kwargs=None): """ Carries out the fit. Parameters ---------- params : lmfit.Parameters() instance Call load_params to generate. args : tuple Arguments to pass to the function to minimize. Must contain a wavelength array as first argument, optional second and third argument will be interpreted as data and errors, respectively. arrays are optional. kwargs : tuple keyword arguments, will be passed directly to the lmfit.minimize() function. See lmfit docs for options. Returns ------- result : lmfit.Minimizer() object """ # For testing: x = args[0] data = args[1] errs = args[2] earlymodel = build_model(params, x) # Now: fitting. print params try: result = lf.minimize(build_model, params, args=args, method=method) result = lf.minimize(build_model, params, args=args, method=method) result = lf.minimize(build_model, params, args=args, method='lestsq') except: result = lf.minimize(build_model, params, args=args, method=method) result = lf.minimize(build_model, params, args=args, method='leastsq') lf.report_errors(params) # Now: moar plots latemodel = build_model(result.params, x) #import matplotlib.pyplot as plt #plt.clf() #plt.errorbar(x, data, yerr=errs, color='black', label='Data', lw=2.) #plt.axhline(y=0., color='black') #plt.plot(x, earlymodel, lw=1.6, label='Guess', color='green') #plt.plot(x, latemodel, lw=1.6, label='Fit', color='orange') #plt.legend(fancybox=True, shadow=True) #plt.grid() #plt.title('Plot of initial guess and LMfit best fit.') #plt.xlabel(u'Wavelegth') #plt.ylabel('Flux') #plt.show() return result
def test_ci(): np.random.seed(1) p_true = Parameters() p_true.add('amp', value=14.0) p_true.add('period', value=5.33) p_true.add('shift', value=0.123) p_true.add('decay', value=0.010) def residual(pars, x, data=None): amp = pars['amp'] per = pars['period'] shift = pars['shift'] decay = pars['decay'] if abs(shift) > pi / 2: shift = shift - np.sign(shift) * pi model = amp * np.sin(shift + x / per) * np.exp(-x * x * decay * decay) if data is None: return model return model - data n = 2500 xmin = 0. xmax = 250.0 noise = np.random.normal(scale=0.7215, size=n) x = np.linspace(xmin, xmax, n) data = residual(p_true, x) + noise fit_params = Parameters() fit_params.add('amp', value=13.0) fit_params.add('period', value=4) fit_params.add('shift', value=0.1) fit_params.add('decay', value=0.02) out = minimize(residual, fit_params, args=(x,), kws={'data': data}) fit = residual(fit_params, x) print( ' N fev = ', out.nfev) print( out.chisqr, out.redchi, out.nfree) report_errors(fit_params) ci, tr = conf_interval(out, sigmas=[0.674], trace=True) report_ci(ci) for p in out.params: diff1 = ci[p][1][1] - ci[p][0][1] diff2 = ci[p][2][1] - ci[p][1][1] stderr = out.params[p].stderr assert(abs(diff1 - stderr) / stderr < 0.05) assert(abs(diff2 - stderr) / stderr < 0.05)
def fit_rayl_sky_filter(all_data, in_params, filter_name, rayl_angle): params = Parameters() params.add('k', value=in_params['k'].value, min=0.0, max=5.0, vary=False) params.add('m_inf', value=in_params['m_inf'].value, min=15.0, max=30.0, vary=False) params.add('m_zen', value=in_params['m_zen'].value, min=15.0, max=30.0, vary=False) params.add('h', value=in_params['h'].value, min=60, max=3000, vary=False) params.add('g', value=in_params['g'].value, min=0.0, max=1.0, vary=False) params.add('mie_m', value=in_params['mie_m'].value, min=10.0, max=30.0, vary=False) params.add('rayl_m', in_params['rayl_m'].value, min=10.0, max=30.0, vary=True) params.add('sun_dm', in_params['sun_dm'].value, min=-20.0, max=-10.0, vary=False) params.add('twi1', value=in_params['twi1'], min=-100.0, max=100.0, vary=False) params.add('twi2', value=in_params['twi2'], min=-100.0, max=100.0, vary=False) data = all_data.query( "band == '%s' and airmass<2.0 and moon_brightness>0.0 and moon_angle>%f and moon_zd<80.0 and sun_zd>108.0" % (filter_name, rayl_angle)) print "Fitting to %d points" % len(data) fit = minimize(residuals, params, args=(data, )) report_errors(fit.params) return fit.params
def fit_twilight(all_data, in_params, filter_name): params = Parameters() params.add('k', value=in_params['k'].value, min=0.0, max=5.0, vary=False) params.add('m_inf', value=in_params['m_inf'].value, min=15.0, max=30.0, vary=False) params.add('m_zen', value=in_params['m_zen'].value, min=15.0, max=30.0, vary=False) params.add('h', value=in_params['h'].value, min=80, max=3000, vary=False) params.add('g', value=in_params['g'].value, min=0.0, max=1.0, vary=False) params.add('mie_m', value=in_params['mie_m'].value, min=10.0, max=30.0, vary=False) params.add('rayl_m', in_params['rayl_m'].value, min=10.0, max=30.0, vary=False) params.add('sun_dm', in_params['sun_dm'].value, min=-20.0, max=-10.0, vary=True) params.add('twi1', value=in_params['twi1'], min=-100.0, max=100.0, vary=True) params.add('twi2', value=in_params['twi2'], min=-100.0, max=100.0, vary=True) data = all_data.query( "band == '%s' and airmass < 2.0 and moon_zd > 108.0 and sun_zd < 106.0" % filter_name) fit = minimize(residuals, params, args=(data, )) report_errors(fit.params) return fit.params
def fit_hi_vel_range(guesses=None, av_image=None, av_image_error=None, hi_cube=None, hi_velocity_axis=None, hi_noise_cube=None, dgr=None): from scipy.optimize import curve_fit from scipy import stats from lmfit import minimize, Parameters, report_fit, report_errors from pprint import pprint params = Parameters() params.add('low_vel', value=guesses[0], min=-100, max=100, vary=True) params.add('high_vel', value=guesses[1], min=-100, max=100, vary=True) result = minimize( calc_model_chisq, params, kws={ 'av_image': av_image, 'av_image_error': av_image_error, 'hi_cube': hi_cube, 'hi_velocity_axis': hi_velocity_axis, 'hi_noise_cube': hi_noise_cube, 'dgr': dgr }, #method='BFGS', method='anneal', #method='powell', #method='SLSQP', options={ 'gtol': 1e-6, 'disp': True, 'maxiter': 1e9 }) report_fit(params) report_errors(params) print result.values print result.errorbars #print(result.__dict__) #print(dir(result)) #print result.vars #print help(result) print result.view_items() print result.Bopt
def fit_circle(x, y, xc=0.0, yc=0.0): """ Fit a circle to the shape of an arc with coordinates x, y Optionally provide initial guesses for the circle parameters: xc, yc, Rc """ params = lmfit.Parameters() params.add("xc", value=xc) params.add("yc", value=yc) lmfit.minimize(model_minus_data, params, args=(x, y)) lmfit.report_errors(params) xc = params["xc"].value yc = params["yc"].value Rc = Rc_from_data(x, y, xc, yc) return Rc, xc, yc
def fit_hi_vel_range(guesses=None, av_image=None, av_image_error=None, hi_cube=None, hi_velocity_axis=None, hi_noise_cube=None, dgr=None): from scipy.optimize import curve_fit from scipy import stats from lmfit import minimize, Parameters, report_fit, report_errors from pprint import pprint params = Parameters() params.add('low_vel', value=guesses[0], min=-100, max=100, vary=True) params.add('high_vel', value=guesses[1], min=-100, max=100, vary=True) result = minimize(calc_model_chisq, params, kws={'av_image': av_image, 'av_image_error': av_image_error, 'hi_cube': hi_cube, 'hi_velocity_axis': hi_velocity_axis, 'hi_noise_cube': hi_noise_cube, 'dgr': dgr}, #method='BFGS', method='anneal', #method='powell', #method='SLSQP', options={'gtol': 1e-6, 'disp': True, 'maxiter' : 1e9} ) report_fit(params) report_errors(params) print result.values print result.errorbars #print(result.__dict__) #print(dir(result)) #print result.vars #print help(result) print result.view_items() print result.Bopt
def fit_hi_vel_range( guesses=None, av_image=None, av_image_error=None, hi_cube=None, hi_velocity_axis=None, hi_noise_cube=None, dgr=None ): from scipy.optimize import curve_fit from scipy import stats from lmfit import minimize, Parameters, report_fit, report_errors from pprint import pprint params = Parameters() params.add("low_vel", value=guesses[0], min=-100, max=100, vary=True) params.add("high_vel", value=guesses[1], min=-100, max=100, vary=True) result = minimize( calc_model_chisq, params, kws={ "av_image": av_image, "av_image_error": av_image_error, "hi_cube": hi_cube, "hi_velocity_axis": hi_velocity_axis, "hi_noise_cube": hi_noise_cube, "dgr": dgr, }, # method='BFGS', method="anneal", # method='powell', # method='SLSQP', options={"gtol": 1e-6, "disp": True, "maxiter": 1e9}, ) report_fit(params) report_errors(params) print result.values print result.errorbars # print(result.__dict__) # print(dir(result)) # print result.vars # print help(result) print result.view_items() print result.Bopt
print 'SNR (weighted) for this flux: ', wsnr fig=pl.figure() ax = fig.add_subplot(121) im = ax.imshow(mask) ax2 =fig.add_subplot(122) im2 = ax2.imshow(mixImNoSky.array) pl.show() #Minimize residual of mixture and fit with params if PSF==True: out = lm.minimize(lib.residualPSF, params, args=[mixIm]) else: out = lm.minimize(lib.residual, params, args=[mixIm]) print 'The minimum least squares is:', out.chisqr lm.report_errors(params) #Draw best fit fitIm = lib.drawFit(params) #Plot mixture, best fit, and residual fig = pl.figure() domStr = 'Dominant Galaxy: (' + str(domParams['centX'].value) + ', ' + str(domParams['centY'].value) + '), ' + str(DOMINANT_FLUX) + ', ' + str(DOMINANT_HALF_LIGHT_RADIUS) + ', ' + str(DOMINANT_FLUX_FRACTION) + ', 0, 0' contStr = 'Contaminant Galaxy: (' + str(dx) + ', ' + str(dy) + '), ' + str(CONTAMINANT_FLUX) + ', ' + str(CONTAMINANT_HALF_LIGHT_RADIUS) + ', ' + str(CONTAMINANT_FLUX_FRACTION) + ', 0, 0' fitStr = 'Fit: (' + str(np.around(params['fitCentX'].value, decimals=2)) + ', ' + str(np.around(params['fitCentY'].value, decimals=2)) + '), ' + str(np.around(params['fitDiskFlux'].value, decimals=2)) + ', ' + str(np.around(params['fitDiskHLR'].value, decimals=2)) + ', ' + str(np.around(params['fite1'].value, decimals=2)) + ', ' + str(np.around(params['fite2'].value, decimals=2)) titleStr = 'Parameters (centroid, flux, hlr, flux fraction, e1, e2)\n' + domStr + '\n' + contStr + '\n' + fitStr + '\nPixel Scale: ' + str(PIXEL_SCALE) + ' arcsec/pixel' fig.suptitle(titleStr, fontsize=18) ax11 = fig.add_subplot(131) c11 = ax11.imshow(mixIm.array, origin='lower') ax11.set_title('Sersic Mixture')
params = lmfit.Parameters() params.add('A', value=0, vary=True) ##cos ### -3 cXZ sin 2 chi: 7 +- 23 mHz params.add('B', value=0, vary=True) ##sin ### -3 cYZ sin 2 chi: 32 +- 56 mHz params.add('C', value=0, vary=True) ##cos2 ### -1.5 (cXX-cYY) sin^2 chi: 15 +- 22 mHz params.add('D', value=0, vary=True) ##sin2 ### -3 cXY sin^2 chi: 8 +- 20 mHz #params.add('offset', value = 0.0) result = lmfit.minimize(cosine_fit, params, args=(x, y, yerr)) residual_array = result.residual * yerr #fit_values = y + result.residual lmfit.report_errors(params, min_correl=0) print "Reduced chi-squared = ", result.redchi #print result.redchi #print 1/params['freq'].value/3600 x_plot = np.linspace(x.min(), x.max(), 1000) figure = pyplot.figure(i + 1) figure.clf() pyplot.plot(x, y, '-') pyplot.plot(x_plot, cosine_model(params, x_plot), linewidth=3.0) #pyplot.errorbar(time_array,freq_array,width_array, linestyle='None',markersize = 4.0,fmt='o',color='black')
def loop(variable, initial, delta, num): import param as op reload(op) runner = initial + np.arange(num) * delta chisqr = [] for kk in runner: if os.path.isfile(op.file) == False: print('Error: No input file') print('Check that file is in current folder') sys.exit() data = np.loadtxt(op.file, usecols=(0, 1)) hjd, vel, err = [], [], [] if len(data[0]) == 3: for i in data: hjd.append(i[0]), vel.append(i[1]), err.append(i[2]) if len(data[0]) == 2: for i in data: hjd.append(i[0]), vel.append(i[1]) hjd, vel = np.array(hjd), np.array(vel) # %%%%%%%%%%%%%%%%%%%%%%%% ORBIT PARAMETERS params = lm.Parameters() if variable == 'porb': params.add('porb', value=kk, vary=False) var_label = 'P$_{orb}$ / d' else: params.add('porb', value=op.porb, vary=op.fix_porb) if variable == 'hjd0': params.add('hjd0', value=kk, vary=False) var_label = 'HJD$_{0}$ / d' else: params.add('hjd0', value=op.hjd0, vary=op.fix_hjd0) if variable == 'gama': params.add('gama', value=kk, vary=False) var_label = '$\gamma$ / km s$^{-1}$' else: params.add('gama', value=op.gama, vary=op.fix_gama) if variable == 'k1': params.add('k1', value=kk, vary=False) var_label = 'K$_{1}$ / km s$^{-1}$' else: params.add('k1', value=op.k1, vary=op.fix_k1) if op.errors: err = np.loadtxt(op.file)[:, 2] else: err = op.sigma + np.zeros(len(hjd)) def res_sin3(pars, x, data=None, sigma=err): porb = pars['porb'].value hjd0 = pars['hjd0'].value gama = pars['gama'].value k1 = pars['k1'].value model = gama + k1 * np.sin(2 * np.pi * ((x - hjd0) / porb)) if data is None: return model if sigma is None: return (model - data) return (model - data) / sigma results = lm.minimize(res_sin3, params, args=(hjd, vel)) print('Looping ' + str(variable) + ': ' + str(kk) + '\n') lm.report_errors(params, show_correl=False) print('DoF = ', results.nfree) print('Chi-squared = ', results.chisqr) print('--------------') chisqr.append(results.chisqr) chisqr = np.array(chisqr) print('%%%%%%%%%%%%%%%%%%%5%%%') print("Minimum Chi^2: ", runner[chisqr == np.min(chisqr)][0]) print("Porb_min = {:.8f}".format(runner[chisqr == np.min(chisqr)][0])) print('%%%%%%%%%%%%%%%%%%%5%%%') plt.figure(num='Loop', facecolor='w') plt.clf() plt.plot(runner, chisqr / results.nfree, 'rs', markersize=6) plt.plot(runner, chisqr / results.nfree, 'k-') plt.axvline(x=runner[chisqr == np.min(chisqr)][0], ls='--', color='b', alpha=0.4) plt.xlabel(var_label) plt.ylabel('$\chi^2$ / ' + str(results.nfree) + ' dof') plt.show() plt.tight_layout()
def main(): #---------------------------------------------------------------------- # import data #---------------------------------------------------------------------- data = genfromtxt(sys.argv[1]) t_c = data[2:, 0] #time y_c = data[2:, 1] #measured decay curve y(t) g_c = data[2:, 2] #impulse g(t) #---------------------------------------------------------------------- # lmfit section #---------------------------------------------------------------------- params = Parameters() params.add('I_0', value=1.0) params.add('time0', value=1.0) # minimize residuals using lmfit # with Levenberg-Marquardt method, # the first, "signal" fitting procedure rezult = minimize(Conv_residuals, params, args=(t_c, y_c, g_c), method='leastsq') #-------------------------------------------------------------------- # leastsq, nelder, lbfgsb, anneal, powell, cg, newton, cobyla, slsqp provisional_parameters = rezult #will be printed at the end of the code residuals = Conv_residuals(rezult.params, t_c, y_c, g_c) #residuals y_lmfit = y_c + residuals #fitted line #---------------------------------------------------------------------- # bootstrapping section #---------------------------------------------------------------------- I_0 = [] # arrays of calculated parameters t_0 = [] # during bootstrapping iteration = int(input('How many bootstrapping iterations? ')) # number of boostrap procedures for i in range(iteration): params = Parameters() # repeat lmfit minimize using params.add('I_0', value=10.0) # Levenberg-Marquardt method params.add('time0', value=1.0) # with # y(t) + randomly sampled residuals rezult = minimize(Conv_residuals, params, args=(t_c, bootstrap(y_c, residuals), g_c), method='leastsq') I_0.append(rezult.params['I_0'].value) t_0.append(rezult.params['time0'].value) #---------------------------------------------------------------------- # quantiles/errors and means #---------------------------------------------------------------------- err_I_0 = stats.mstats.mquantiles(I_0, [0.0, 1.0]) err_t_0 = stats.mstats.mquantiles(t_0, [0.0, 1.0]) # 0.25, 0.75 -quantiles may be used instead of the full span #---------------------------------------------------------------------- # runs test #---------------------------------------------------------------------- np = nm = 0 # number of positive and negative residuals, respectively nR = 1 # observed number of runs (changes of sign) if residuals[0] < 0: nm += 1 for i in range(1, len(residuals)): # loop for calculating # nm and nR if residuals[i] < 0: nm += 1 if residuals[i - 1] > 0: nR += 1 elif residuals[i - 1] < 0: nR += 1 np = len(residuals) - nm # np - number of positive residuals R = 1 + (2 * np * nm) / (np + nm) #expected number of runs sigma_R = sqrt(2 * nm * np * (2 * nm * np - np - nm) / ((np + nm - 1) * (np + nm)**2)) #variance of the expected number of runs if nR <= R: Z = (nR - R + 0.5) / sigma_R else: # estimated standard normal Z = (nR - R - 0.5) / sigma_R # distribution (Z-score) #---------------------------------------------------------------------- #report results of calculations #---------------------------------------------------------------------- print('\nLMFIT report:\n') # results from the 'signal' fit report_errors(provisional_parameters) print('\nBootstrapping report:\n\nI_0 =', "%.4f" % median(I_0), '\t(-', "%.4f" % (100 * ((median(I_0) - err_I_0[0]) / median(I_0))), '% / +', "%.4f" % (100 * ((err_I_0[1] - median(I_0)) / median(I_0))), '%)') # NOTE! since the statistical approach # has been used, medians are more relevant # instead of means print('t_0 =', "%.4f" % median(t_0), '\t(-', "%.4f" % (100 * ((median(t_0) - err_t_0[0]) / median(t_0))), '% / +', "%.4f" % (100 * ((err_t_0[1] - median(t_0)) / median(t_0))), '%)\n') print('Runs test:\n\n Numbers of points:\n n_m =', nm, '\n n_p =', np, '\n\n' 'Observed number of runs n_R =', nR, '\n' 'Expected number of runs R =', "%.4f" % R, '+/-', "%.4f" % sigma_R, '\n' 'The standard normal distribution score Z =', "%.4f" % Z) #---------------------------------------------------------------------- # plot section #---------------------------------------------------------------------- f_c = [] # luminescence decay as exp-model for i in range(len(t_c)): f_c.append(median(I_0) * exp(-(t_c[i]) / median(t_0))) suptitle(r'Decay kinetics of BaF$_2$ 78 nm nanoparticles', fontsize=18) subplot(211) plot(t_c, y_c / max(y_c), 'bo', label=r'$y(t)$') # all graphs are normalized plot(t_c, g_c / max(g_c), 'ro', label=r'$g(t)$') plot(t_c, y_lmfit / max(y_lmfit), 'm-', label='fitting curve') plot(t_c, f_c / max(f_c), 'g.--', label=r'$f(t)$') xlabel('Time (ns)', fontsize=15) ylabel('Intensity (a.u.)', fontsize=16) legend(loc=1) subplot(212) stem(t_c, residuals, linefmt='g--', markerfmt='bs', basefmt='r-') xlabel('Time (ns)', fontsize=15) ylabel(r'Residuals $y - y_{model}$', fontsize=16) subplots_adjust(hspace=0.3, wspace=0.3, right=0.95, top=0.92) show() #------------Histograms---------------------------- suptitle(r'Decay kinetics of BaF$_2$ 78 nm nanoparticles', fontsize=18) subplot(121) hist(I_0, color='green') xlabel(r'$I_0$ (a.u.)', fontsize=16) ylabel(r'Frequency', fontsize=16) subplot(122) hist(t_0, color='green') xlabel(r'$t_0$ (ns)', fontsize=16) ylabel('Frequency', fontsize=16) subplots_adjust(hspace=0.4, left=0.1, right=0.95, top=0.92) show()
def report(self, params): lmfit.report_errors(params)
def test_report_errors_deprecated(fitresult): """Verify that a DeprecationWarning is shown when calling report_errors.""" with pytest.deprecated_call(): report_errors(params=fitresult.params)
omegataus.pop(i) masterchi.pop(i) mastererr.pop(i) params["beta"].vary = True params["logK_dd"].value = 0 params["logK_dd"].min = -2 params["logK_dd"].max = 2 params["logtau"].value = 0 params["logtau"].min = -3 params["logtau"].max = 3 omegataus = np.array(omegataus) out = minimize(residual, params, args=(omegataus, masterchi, mastererr)) result = omegataus + out.residual fit = residual(params, omegataus) print "beta " + str(params["beta"].value) report_errors(params) ####parameter updaten und ausgabe anpassen while True: tauout = open("tau.dat", "w") for i in range(0, taus.__len__()): taus[i] = taus[i] + params["logtau"].value tauout.write(str(temps[i]) + " " + str(taus[i]) + "\n") break omegataus = [] masterchi = [] ax.cla() ax.set_xscale("log") ax.set_yscale("log") ax.set_title("Masterkurve")
def extractfeatures_inside(self, DICOMImages, image_pos_pat, image_ori_pat, series_path, phases_series, VOI_mesh): """ Start pixVals for collection pixel values at VOI """ pixVals = [] deltaS = {} # necessary to read point coords VOIPnt = [0, 0, 0] ijk = [0, 0, 0] pco = [0, 0, 0] for i in range(len(DICOMImages)): abspath_PhaseID = series_path + os.sep + str(phases_series[i]) print phases_series[i] # Get total number of files load = Inputs_init() [len_listSeries_files, FileNms_slices_sorted_stack] = load.ReadDicomfiles(abspath_PhaseID) mostleft_slice = FileNms_slices_sorted_stack.slices[0] # Get dicom header, retrieve dicomInfo_series = dicom.read_file(abspath_PhaseID + os.sep + str(mostleft_slice)) # (0008,0031) AT S Series Time # hh.mm.ss.frac seriesTime = str(dicomInfo_series[0x0008, 0x0031].value) # (0008,0033) AT S Image Time # hh.mm.ss.frac imageTime = str(dicomInfo_series[0x0008, 0x0033].value) # (0008,0032) AT S Acquisition Time # hh.mm.ss.frac ti = str(dicomInfo_series[0x0008, 0x0032].value) acquisitionTimepoint = datetime.time(hour=int(ti[0:2]), minute=int(ti[2:4]), second=int(ti[4:6])) self.timepoints.append(datetime.datetime.combine(datetime.date.today(), acquisitionTimepoint)) # find mapping to Dicom space [transformed_image, transform_cube] = Display().dicomTransform(DICOMImages[i], image_pos_pat, image_ori_pat) ### Get inside of VOI [VOI_scalars, VOIdims] = self.createMaskfromMesh(VOI_mesh, transformed_image) print "\n VOIdims" print VOIdims # get non zero elements image_scalars = transformed_image.GetPointData().GetScalars() numpy_VOI_imagedata = vtk_to_numpy(image_scalars) numpy_VOI_imagedata = numpy_VOI_imagedata.reshape(VOIdims[2], VOIdims[1], VOIdims[0]) numpy_VOI_imagedata = numpy_VOI_imagedata.transpose(2, 1, 0) print "Shape of VOI_imagedata: " print numpy_VOI_imagedata.shape #################### HERE GET IT AND MASK IT OUT self.nonzeroVOIextracted = nonzero(VOI_scalars) print self.nonzeroVOIextracted VOI_imagedata = numpy_VOI_imagedata[self.nonzeroVOIextracted] print "shape of VOI_imagedata Clipped:" print VOI_imagedata.shape for j in range(len(VOI_imagedata)): pixValx = VOI_imagedata[j] pixVals.append(pixValx) # Now collect pixVals print "Saving %s" % "delta" + str(i) deltaS["delta" + str(i)] = pixVals pixVals = [] print self.timepoints # Collecting timepoints in proper format t_delta = [] t_delta.append(0) total_time = 0 for i in range(len(DICOMImages) - 1): current_time = self.timepoints[i + 1] previous_time = self.timepoints[i] difference_time = current_time - previous_time timestop = divmod(difference_time.total_seconds(), 60) t_delta.append(t_delta[i] + timestop[0] + timestop[1] * (1.0 / 60)) total_time = total_time + timestop[0] + timestop[1] * (1.0 / 60) # finally print t_delta print t_delta t = array(t_delta) print "total_time" print total_time ############################################################## # Finished sampling deltaS # APply lmfit to deltaS # first sample the mean data_deltaS = [] t_deltaS = [] mean_deltaS = [] sd_deltaS = [] se_deltaS = [] n_deltaS = [] # append So and to data_deltaS.append(0) t_deltaS.append(0) mean_deltaS.append(mean(deltaS["delta0"])) sd_deltaS.append(0) se_deltaS.append(0) n_deltaS.append(len(deltaS["delta0"])) for k in range(1, len(DICOMImages)): deltaS_i = (mean(array(deltaS["delta" + str(k)]).astype(float)) - mean(deltaS["delta0"])) / mean( deltaS["delta0"] ) data_deltaS.append(deltaS_i) t_deltaS.append(k) print "delta" + str(k) print data_deltaS[k] ############################################################## # Calculate data_error # estimate the population mean and SD from our samples to find SE # SE tells us the distribution of individual scores around the sampled mean. mean_deltaS_i = mean(array(deltaS["delta" + str(k)])) std_deltaS_i = std(array(deltaS["delta" + str(k)])) n_deltaS_i = len(array(deltaS["delta" + str(k)])) sd_deltaS.append(std_deltaS_i) mean_deltaS.append(mean_deltaS_i) # Standard Error of the mean SE # the smaller the variability in the data, the more confident we are that one value (the mean) accurately reflects them. se_deltaS.append(std_deltaS_i / sqrt(n_deltaS_i)) n_deltaS.append(n_deltaS_i) # make array for data_deltaS data = array(data_deltaS) print "\n================\nMean and SE (i.e VOI sample data)" print mean_deltaS print se_deltaS # create a set of Parameters params = Parameters() params.add("amp", value=10, min=0) params.add("alpha", value=1, min=0) params.add("beta", value=0.05, min=0.0001, max=0.9) # do fit, here with leastsq model # define objective function: returns the array to be minimized def fcn2min(params, t, data): global model, model_res, x """ model EMM for Bilateral DCE-MRI, subtract data""" # unpack parameters: # extract .value attribute for each parameter amp = params["amp"].value # Upper limit of deltaS alpha = params["alpha"].value # rate of signal increase min-1 beta = params["beta"].value # rate of signal decrease min-1 model = amp * (1 - exp(-alpha * t)) * exp(-beta * t) x = linspace(0, t[4], 101) model_res = amp * (1 - exp(-alpha * x)) * exp(-beta * x) return model - data ##### myfit = Minimizer(fcn2min, params, fcn_args=(t,), fcn_kws={"data": data}) myfit.prepare_fit() myfit.leastsq() # On a successful fit using the leastsq method, several goodness-of-fit statistics # and values related to the uncertainty in the fitted variables will be calculated print "myfit.success" print myfit.success print "myfit.residual" print myfit.residual print "myfit.chisqr" print myfit.chisqr print "myfit.redchi" print myfit.redchi # calculate final result final = data + myfit.residual # write error report report_errors(params) # Calculate R-square # R_square = sum( y_fitted - y_mean)/ sum(y_data - y_mean) R_square = sum((model - mean(data)) ** 2) / sum((data - mean(data)) ** 2) print "R^2" print R_square self.amp = params["amp"].value self.alpha = params["alpha"].value self.beta = params["beta"].value ################################################## # Now Calculate Extract parameters from model self.iAUC1 = params["amp"].value * ( ((1 - exp(-params["beta"].value * t[1])) / params["beta"].value) + (exp((-params["alpha"].value + params["beta"].value) * t[1]) - 1) / (params["alpha"].value + params["beta"].value) ) print "iAUC1" print self.iAUC1 self.Slope_ini = params["amp"].value * params["alpha"].value print "Slope_ini" print self.Slope_ini self.Tpeak = (1 / params["alpha"].value) * log(1 + (params["alpha"].value / params["beta"].value)) print "Tpeak" print self.Tpeak self.Kpeak = -params["amp"].value * params["alpha"].value * params["beta"].value print "Kpeak" print self.Kpeak self.SER = exp((t[4] - t[1]) * params["beta"].value) * ( (1 - exp(-params["alpha"].value * t[1])) / (1 - exp(-params["alpha"].value * t[4])) ) print "SER" print self.SER ################################################## # Now Calculate enhancement Kinetic based features # Based on the course of signal intensity within the lesion print "\n Saving %s" % "Crk" So = array(deltaS["delta0"]).astype(float) Crk = {"Cr0": mean(So)} C = {} Carray = [] for k in range(1, len(DICOMImages)): Sk = array(deltaS["delta" + str(k)]).astype(float) Cr = 0 for j in range(len(So)): # extract average enhancement over the lesion at each time point Cr = Cr + (Sk[j] - So[j]) / So[j] Carray.append((Sk[j] - So[j]) / So[j]) # compile C["C" + str(k)] = Carray Crk["Cr" + str(k)] = Cr / len(Sk) # Extract Fii_1 for k in range(1, 5): currentCr = array(Crk["Cr" + str(k)]).astype(float) print currentCr if self.maxCr < currentCr: self.maxCr = float(currentCr) self.peakCr = int(k) print "Maximum Upate (Fii_1) = %d " % self.maxCr print "Peak Cr (Fii_2) = %d " % self.peakCr # Uptake rate self.UptakeRate = float(self.maxCr / self.peakCr) print "Uptake rate (Fii_3) " print self.UptakeRate # WashOut Rate if self.peakCr == 4: self.washoutRate = 0 else: self.washoutRate = float((self.maxCr - array(Crk["Cr" + str(4)]).astype(float)) / (4 - self.peakCr)) print "WashOut rate (Fii_4) " print self.washoutRate ################################################## # Now Calculate enhancement-variance Kinetic based features # Based on Crk['Cr'+str(k)] = Cr/len(Sk) print "\n Saving %s" % "Vrk" Vrk = {} for k in range(1, 5): Ci = array(C["C" + str(k)]).astype(float) Cri = array(Crk["Cr" + str(k)]).astype(float) Vr = 0 for j in range(len(Ci)): # extract average enhancement over the lesion at each time point Vr = Vr + (Ci[j] - Cri) ** 2 # compile Vrk["Vr" + str(k)] = Vr / (len(Ci) - 1) # Extract Fiii_1 for k in range(1, 5): currentVr = array(Vrk["Vr" + str(k)]).astype(float) if self.maxVr < currentVr: print currentVr self.maxVr = float(currentVr) self.peakVr = int(k) print "Maximum Variation of enhan (Fiii_1) = %d " % self.maxVr print "Peak Vr (Fii_2) = %d " % self.peakVr # Vr_increasingRate self.Vr_increasingRate = self.maxVr / self.peakVr print "Vr_increasingRate (Fiii_3)" print self.Vr_increasingRate # Vr_decreasingRate if self.peakVr == 4: self.Vr_decreasingRate = 0 else: self.Vr_decreasingRate = float((self.maxVr - array(Vrk["Vr" + str(4)]).astype(float)) / (4 - self.peakVr)) print "Vr_decreasingRate (Fiii_4) " print self.Vr_decreasingRate # Vr_post_1 self.Vr_post_1 = float(array(Vrk["Vr" + str(1)]).astype(float)) print "Vr_post_1 (Fiii_5)" print self.Vr_post_1 ################################################## # orgamize into dataframe self.dynamicEMM_inside = DataFrame( data=array( [ [ self.amp, self.alpha, self.beta, self.iAUC1, self.Slope_ini, self.Tpeak, self.Kpeak, self.SER, self.maxCr, self.peakCr, self.UptakeRate, self.washoutRate, self.maxVr, self.peakVr, self.Vr_increasingRate, self.Vr_decreasingRate, self.Vr_post_1, ] ] ), columns=[ "A.inside", "alpha.inside", "beta.inside", "iAUC1.inside", "Slope_ini.inside", "Tpeak.inside", "Kpeak.inside", "SER.inside", "maxCr.inside", "peakCr.inside", "UptakeRate.inside", "washoutRate.inside", "maxVr.inside", "peakVr.inside", "Vr_increasingRate.inside", "Vr_decreasingRate.inside", "Vr_post_1.inside", ], ) ############################################################# # try to plot results pylab.figure() pylab.errorbar(t, data, yerr=se_deltaS, fmt="ro", label="data+SE") # data 'ro' red dots as markers pylab.plot(t, final, "b+", label="data+residuals") # data+residuals 'b+' blue pluses pylab.plot(t, model, "b", label="model") # model fit 'b' blue pylab.plot(x, model_res, "k", label="model fit") # model fit 'k' blakc pylab.xlabel(" post-contrast time (min)") pylab.ylabel("delta S(t)") pylab.legend() return self.dynamicEMM_inside
def extractfeatures_contour(self, DICOMImages, image_pos_pat, image_ori_pat, series_path, phases_series, VOI_mesh): """ Start pixVals for collection pixel values at VOI """ pixVals = [] deltaS = {} # necessary to read point coords VOIPnt = [0,0,0] ijk = [0,0,0] pco = [0,0,0] for i in range(len(DICOMImages)): abspath_PhaseID = series_path+os.sep+str(phases_series[i]) print phases_series[i] # Get total number of files [len_listSeries_files, FileNms_slices_sorted_stack] = processDicoms.ReadDicomfiles(abspath_PhaseID) mostleft_slice = FileNms_slices_sorted_stack.slices[0] # Get dicom header, retrieve dicomInfo_series = dicom.read_file(abspath_PhaseID+os.sep+str(mostleft_slice)) # (0008,0031) AT S Series Time # hh.mm.ss.frac seriesTime = str(dicomInfo_series[0x0008,0x0031].value) # (0008,0033) AT S Image Time # hh.mm.ss.frac imageTime = str(dicomInfo_series[0x0008,0x0033].value) # (0008,0032) AT S Acquisition Time # hh.mm.ss.frac ti = str(dicomInfo_series[0x0008,0x0032].value) acquisitionTimepoint = datetime.time(hour=int(ti[0:2]), minute=int(ti[2:4]), second=int(ti[4:6])) self.timepoints.append( datetime.datetime.combine(datetime.date.today(), acquisitionTimepoint) ) # find mapping to Dicom space [transformed_image, transform_cube] = Display().dicomTransform(DICOMImages[i], image_pos_pat, image_ori_pat) for j in range( VOI_mesh.GetNumberOfPoints() ): VOI_mesh.GetPoint(j, VOIPnt) # extract pixID at location VOIPnt pixId = transformed_image.FindPoint(VOIPnt[0], VOIPnt[1], VOIPnt[2]) im_pt = [0,0,0] transformed_image.GetPoint(pixId,im_pt) inorout = transformed_image.ComputeStructuredCoordinates( im_pt, ijk, pco) if(inorout == 0): pass else: pixValx = transformed_image.GetScalarComponentAsFloat( ijk[0], ijk[1], ijk[2], 0) pixVals.append(pixValx) # Now collect pixVals print "Saving %s" % 'delta'+str(i) deltaS['delta'+str(i)] = pixVals pixVals = [] print self.timepoints # Collecting timepoints in proper format t_delta = [] t_delta.append(0) total_time = 0 for i in range(len(DICOMImages)-1): current_time = self.timepoints[i+1] previous_time = self.timepoints[i] difference_time =current_time - previous_time timestop = divmod(difference_time.total_seconds(), 60) t_delta.append( t_delta[i] + timestop[0]+timestop[1]*(1./60)) total_time = total_time+timestop[0]+timestop[1]*(1./60) # finally print t_delta print t_delta t = array(t_delta) print "total_time" print total_time ############################################################## # Finished sampling deltaS # APply lmfit to deltaS # first sample the mean data_deltaS = []; t_deltaS = []; mean_deltaS = []; sd_deltaS = []; se_deltaS = []; n_deltaS = [] # append So and to data_deltaS.append( 0 ) t_deltaS.append(0) mean_deltaS.append( mean(deltaS['delta0']) ) sd_deltaS.append(0) se_deltaS.append(0) n_deltaS.append( len(deltaS['delta0']) ) for k in range(1,len(DICOMImages)): deltaS_i = ( mean(array(deltaS['delta'+str(k)]).astype(float)) - mean(deltaS['delta0']) )/ mean(deltaS['delta0']) data_deltaS.append( deltaS_i ) t_deltaS.append(k) print 'delta'+str(k) print data_deltaS[k] ############################################################## # Calculate data_error # estimate the population mean and SD from our samples to find SE # SE tells us the distribution of individual scores around the sampled mean. mean_deltaS_i = mean(array(deltaS['delta'+str(k)])) std_deltaS_i = std(array(deltaS['delta'+str(k)])) n_deltaS_i = len(array(deltaS['delta'+str(k)])) sd_deltaS.append( std_deltaS_i ) mean_deltaS.append( mean_deltaS_i ) # Standard Error of the mean SE # the smaller the variability in the data, the more confident we are that one value (the mean) accurately reflects them. se_deltaS.append(std_deltaS_i/sqrt(n_deltaS_i)) n_deltaS.append(n_deltaS_i) # make array for data_deltaS data = array(data_deltaS) print "\n================\nMean and SE (i.e VOI sample data)" print mean_deltaS print se_deltaS # create a set of Parameters params = Parameters() params.add('amp', value= 10, min=0) params.add('alpha', value= 1, min=0) params.add('beta', value= 0.05, min=0.0001, max=0.9) # do fit, here with leastsq model # define objective function: returns the array to be minimized def fcn2min(params, t, data): global model, model_res, x """ model EMM for Bilateral DCE-MRI, subtract data""" # unpack parameters: # extract .value attribute for each parameter amp = params['amp'].value # Upper limit of deltaS alpha = params['alpha'].value # rate of signal increase min-1 beta = params['beta'].value # rate of signal decrease min-1 model = amp * (1- exp(-alpha*t)) * exp(-beta*t) x = linspace(0, t[4], 101) model_res = amp * (1- exp(-alpha*x)) * exp(-beta*x) return model - data ##### myfit = Minimizer(fcn2min, params, fcn_args=(t,), fcn_kws={'data':data}) myfit.prepare_fit() myfit.leastsq() # On a successful fit using the leastsq method, several goodness-of-fit statistics # and values related to the uncertainty in the fitted variables will be calculated print "myfit.success" print myfit.success print "myfit.residual" print myfit.residual print "myfit.chisqr" print myfit.chisqr print "myfit.redchi" print myfit.redchi # calculate final result #final = data + myfit.residual # write error report report_errors(params) # Calculate R-square # R_square = sum( y_fitted - y_mean)/ sum(y_data - y_mean) R_square = sum( (model - mean(data))**2 )/ sum( (data - mean(data))**2 ) print "R^2" print R_square self.amp = params['amp'].value self.alpha = params['alpha'].value self.beta = params['beta'].value ################################################## # Now Calculate Extract parameters from model self.iAUC1 = params['amp'].value *( ((1-exp(-params['beta'].value*t[1]))/params['beta'].value) + (exp((-params['alpha'].value+params['beta'].value)*t[1])-1)/(params['alpha'].value+params['beta'].value) ) print "iAUC1" print self.iAUC1 self.Slope_ini = params['amp'].value*params['alpha'].value print "Slope_ini" print self.Slope_ini self.Tpeak = (1/params['alpha'].value)*log(1+(params['alpha'].value/params['beta'].value)) print "Tpeak" print self.Tpeak self.Kpeak = -params['amp'].value * params['alpha'].value * params['beta'].value print "Kpeak" print self.Kpeak self.SER = exp( (t[4]-t[1])*params['beta'].value) * ( (1-exp(-params['alpha'].value*t[1]))/(1-exp(-params['alpha'].value*t[4])) ) print "SER" print self.SER ################################################## # Now Calculate enhancement Kinetic based features # Based on the course of signal intensity within the lesion print "\n Saving %s" % 'Crk' So = array(deltaS['delta0']).astype(float) Crk = {'Cr0': mean(So)} C = {} for k in range(1,len(DICOMImages)): Sk = array(deltaS['delta'+str(k)]).astype(float) print Sk Cr = 0 Carray = [] for j in range( len(So) ): # extract average enhancement over the lesion at each time point Cr = Cr + (Sk[j] - So[j])/So[j] Carray.append((Sk[j] - So[j])/So[j]) # compile C['C'+str(k)] = Carray Crk['Cr'+str(k)] = float(Cr/len(Sk)) # Extract Fii_1 for k in range(1,5): currentCr = array(Crk['Cr'+str(k)]).astype(float) print currentCr if( self.maxCr < currentCr): self.maxCr = float(currentCr) self.peakCr = int(k) print "Maximum Upate (Fii_1) = %d " % self.maxCr print "Peak Cr (Fii_2) = %d " % self.peakCr # Uptake rate self.UptakeRate = float(self.maxCr/self.peakCr) print "Uptake rate (Fii_3) " print self.UptakeRate # WashOut Rate if( self.peakCr == 4): self.washoutRate = 0 else: self.washoutRate = float( (self.maxCr - array(Crk['Cr'+str(4)]).astype(float))/(4-self.peakCr) ) print "WashOut rate (Fii_4) " print self.washoutRate ################################################## # Now Calculate enhancement-variance Kinetic based features # Based on Crk['Cr'+str(k)] = Cr/len(Sk) print "\n Saving %s" % 'Vrk' Vrk = {} for k in range(1,5): Ci = array(C['C'+str(k)]).astype(float) Cri = array(Crk['Cr'+str(k)]).astype(float) Vr = 0 for j in range( len(Ci) ): # extract average enhancement over the lesion at each time point Vr = Vr + (Ci[j] - Cri)**2 # compile Vrk['Vr'+str(k)] = Vr/(len(Ci)-1) # Extract Fiii_1 for k in range(1,5): currentVr = array(Vrk['Vr'+str(k)]).astype(float) if( self.maxVr < currentVr): print currentVr self.maxVr = float(currentVr) self.peakVr = int(k) print "Maximum Variation of enhan (Fiii_1) = %d " % self.maxVr print "Peak Vr (Fii_2) = %d " % self.peakVr # Vr_increasingRate self.Vr_increasingRate = self.maxVr/self.peakVr print "Vr_increasingRate (Fiii_3)" print self.Vr_increasingRate # Vr_decreasingRate if( self.peakVr == 4): self.Vr_decreasingRate = 0 else: self.Vr_decreasingRate = float((self.maxVr - array(Vrk['Vr'+str(4)]).astype(float))/(4-self.peakVr)) print "Vr_decreasingRate (Fiii_4) " print self.Vr_decreasingRate # Vr_post_1 self.Vr_post_1 = float( array(Vrk['Vr'+str(1)]).astype(float)) print "Vr_post_1 (Fiii_5)" print self.Vr_post_1 ################################################## # orgamize into dataframe self.dynamicEMM_contour = DataFrame( data=array([[ self.amp, self.alpha, self.beta, self.iAUC1, self.Slope_ini, self.Tpeak, self.Kpeak, self.SER, self.maxCr, self.peakCr, self.UptakeRate, self.washoutRate, self.maxVr, self.peakVr, self.Vr_increasingRate, self.Vr_decreasingRate, self.Vr_post_1]]), columns=['A.contour', 'alpha.contour', 'beta.contour', 'iAUC1.contour', 'Slope_ini.contour', 'Tpeak.contour', 'Kpeak.contour', 'SER.contour', 'maxCr.contour', 'peakCr.contour', 'UptakeRate.contour', 'washoutRate.contour', 'maxVr.contour', 'peakVr.contour','Vr_increasingRate.contour', 'Vr_decreasingRate.contour', 'Vr_post_1.contour']) ############################################################# # try to plot results pylab.figure() pylab.errorbar(t, data, yerr=se_deltaS, fmt='ro', label='data+SE') # data 'ro' red dots as markers pylab.plot(t, model, 'b', label='model') # model fit 'b' blue pylab.plot(x, model_res, 'k', label='model fit') # model fit 'k' blakc pylab.xlabel(" post-contrast time (min)") pylab.ylabel("delta S(t)") pylab.legend() return self.dynamicEMM_contour
#print phase if np.size(hjd) == 1: if phase < 0.0: return phase + 1.0 else: return phase else: ss = phase < 0.0 phase[ss] = phase[ss] + 1.0 return phase results = lm.minimize(res_sin3, params, args=(hjd - int(op.hjd0), vel)) print('Best fit for ' + op.object) print('--------------') lm.report_errors(results.params, show_correl=False) print('--------------') print('DoF = ', results.nfree) print('Chi-squared = ', results.chisqr) print('Red_chi^2 = ', results.redchi) print('RMS of resiudals = ', np.std(results.residual)) print('--------------') if op.scale_errors: rescale = np.sqrt(results.chisqr / results.nfree) else: rescale = 1.0 print('Rescale factor of errorbars = ', rescale) phase1 = [] phase = phaser(hjd, results.params['hjd0'].value + int(op.hjd0),
porb = pars['porb'].value hjd0 = pars['hjd0'].value gama = pars['gama'].value k1 = pars['k1'].value phaseoff=pars['phaseoff'].value model=gama+k1*n.sin(2*n.pi*((x-hjd0)/porb+phaseoff)) if data is None: return model if sigma is None: return (model - data) return (model - data)/sigma results=lm.minimize(res_sin3,params, args=(hjd,vel)) print 'Best fit for '+op.object print '--------------' lm.report_errors(params,show_correl=False) print '--------------' print 'DoF = ',results.nfree print 'Chi-squared = ',results.chisqr phase1=[] for i in hjd: tmp=(i-params['hjd0'].value)/params['porb'].value-n.fix((i-params['hjd0'].value)/params['porb'].value) if tmp < 0.0: tmp = tmp+1. phase1.append(tmp) phase=n.array(phase1) fig=plt.figure(1,facecolor='w') plt.clf() ax1=plt.subplot2grid((4, 1), (0, 0),rowspan=3) #ffpar=cv.orbital(phase,vel,[70.0,30.0,saved[3][0],porb])
def extractfeatures_inside(self, DICOMImages, image_pos_pat, image_ori_pat, series_path, phases_series, VOI_mesh): """ Start pixVals for collection pixel values at VOI """ pixVals = [] deltaS = {} # necessary to read point coords VOIPnt = [0,0,0] ijk = [0,0,0] pco = [0,0,0] for i in range(len(DICOMImages)): abspath_PhaseID = series_path+os.sep+str(phases_series[i]) print phases_series[i] # Get total number of files load = Inputs_init() [len_listSeries_files, FileNms_slices_sorted_stack] = load.ReadDicomfiles(abspath_PhaseID) mostleft_slice = FileNms_slices_sorted_stack.slices[0] # Get dicom header, retrieve dicomInfo_series = dicom.read_file(abspath_PhaseID+os.sep+str(mostleft_slice)) # (0008,0031) AT S Series Time # hh.mm.ss.frac seriesTime = str(dicomInfo_series[0x0008,0x0031].value) # (0008,0033) AT S Image Time # hh.mm.ss.frac imageTime = str(dicomInfo_series[0x0008,0x0033].value) # (0008,0032) AT S Acquisition Time # hh.mm.ss.frac ti = str(dicomInfo_series[0x0008,0x0032].value) acquisitionTimepoint = datetime.time(hour=int(ti[0:2]), minute=int(ti[2:4]), second=int(ti[4:6])) self.timepoints.append( datetime.datetime.combine(datetime.date.today(), acquisitionTimepoint) ) # find mapping to Dicom space [transformed_image, transform_cube] = Display().dicomTransform(DICOMImages[i], image_pos_pat, image_ori_pat) ### Get inside of VOI [VOI_scalars, VOIdims] = self.createMaskfromMesh(VOI_mesh, transformed_image) print "\n VOIdims" print VOIdims # get non zero elements image_scalars = transformed_image.GetPointData().GetScalars() numpy_VOI_imagedata = vtk_to_numpy(image_scalars) numpy_VOI_imagedata = numpy_VOI_imagedata.reshape(VOIdims[2], VOIdims[1], VOIdims[0]) numpy_VOI_imagedata = numpy_VOI_imagedata.transpose(2,1,0) print "Shape of VOI_imagedata: " print numpy_VOI_imagedata.shape #################### HERE GET IT AND MASK IT OUT self.nonzeroVOIextracted = nonzero(VOI_scalars) print self.nonzeroVOIextracted VOI_imagedata = numpy_VOI_imagedata[self.nonzeroVOIextracted] print "shape of VOI_imagedata Clipped:" print VOI_imagedata.shape for j in range( len(VOI_imagedata) ): pixValx = VOI_imagedata[j] pixVals.append(pixValx) # Now collect pixVals print "Saving %s" % 'delta'+str(i) deltaS['delta'+str(i)] = pixVals pixVals = [] print self.timepoints # Collecting timepoints in proper format t_delta = [] t_delta.append(0) total_time = 0 for i in range(len(DICOMImages)-1): current_time = self.timepoints[i+1] previous_time = self.timepoints[i] difference_time =current_time - previous_time timestop = divmod(difference_time.total_seconds(), 60) t_delta.append( t_delta[i] + timestop[0]+timestop[1]*(1./60)) total_time = total_time+timestop[0]+timestop[1]*(1./60) # finally print t_delta print t_delta t = array(t_delta) print "total_time" print total_time ############################################################## # Finished sampling deltaS # APply lmfit to deltaS # first sample the mean data_deltaS = []; t_deltaS = []; mean_deltaS = []; sd_deltaS = []; se_deltaS = []; n_deltaS = [] # append So and to data_deltaS.append( 0 ) t_deltaS.append(0) mean_deltaS.append( mean(deltaS['delta0']) ) sd_deltaS.append(0) se_deltaS.append(0) n_deltaS.append( len(deltaS['delta0']) ) for k in range(1,len(DICOMImages)): deltaS_i = ( mean(array(deltaS['delta'+str(k)]).astype(float)) - mean(deltaS['delta0']) )/ mean(deltaS['delta0']) data_deltaS.append( deltaS_i ) t_deltaS.append(k) print 'delta'+str(k) print data_deltaS[k] ############################################################## # Calculate data_error # estimate the population mean and SD from our samples to find SE # SE tells us the distribution of individual scores around the sampled mean. mean_deltaS_i = mean(array(deltaS['delta'+str(k)])) std_deltaS_i = std(array(deltaS['delta'+str(k)])) n_deltaS_i = len(array(deltaS['delta'+str(k)])) sd_deltaS.append( std_deltaS_i ) mean_deltaS.append( mean_deltaS_i ) # Standard Error of the mean SE # the smaller the variability in the data, the more confident we are that one value (the mean) accurately reflects them. se_deltaS.append(std_deltaS_i/sqrt(n_deltaS_i)) n_deltaS.append(n_deltaS_i) # make array for data_deltaS data = array(data_deltaS) print "\n================\nMean and SE (i.e VOI sample data)" print mean_deltaS print se_deltaS # create a set of Parameters params = Parameters() params.add('amp', value= 10, min=0) params.add('alpha', value= 1, min=0) params.add('beta', value= 0.05, min=0.0001, max=0.9) # do fit, here with leastsq model # define objective function: returns the array to be minimized def fcn2min(params, t, data): global model, model_res, x """ model EMM for Bilateral DCE-MRI, subtract data""" # unpack parameters: # extract .value attribute for each parameter amp = params['amp'].value # Upper limit of deltaS alpha = params['alpha'].value # rate of signal increase min-1 beta = params['beta'].value # rate of signal decrease min-1 model = amp * (1- exp(-alpha*t)) * exp(-beta*t) x = linspace(0, t[4], 101) model_res = amp * (1- exp(-alpha*x)) * exp(-beta*x) return model - data ##### myfit = Minimizer(fcn2min, params, fcn_args=(t,), fcn_kws={'data':data}) myfit.prepare_fit() myfit.leastsq() # On a successful fit using the leastsq method, several goodness-of-fit statistics # and values related to the uncertainty in the fitted variables will be calculated print "myfit.success" print myfit.success print "myfit.residual" print myfit.residual print "myfit.chisqr" print myfit.chisqr print "myfit.redchi" print myfit.redchi # calculate final result final = data + myfit.residual # write error report report_errors(params) # Calculate R-square # R_square = sum( y_fitted - y_mean)/ sum(y_data - y_mean) R_square = sum( (model - mean(data))**2 )/ sum( (data - mean(data))**2 ) print "R^2" print R_square self.amp = params['amp'].value self.alpha = params['alpha'].value self.beta = params['beta'].value ################################################## # Now Calculate Extract parameters from model self.iAUC1 = params['amp'].value *( ((1-exp(-params['beta'].value*t[1]))/params['beta'].value) + (exp((-params['alpha'].value+params['beta'].value)*t[1])-1)/(params['alpha'].value+params['beta'].value) ) print "iAUC1" print self.iAUC1 self.Slope_ini = params['amp'].value*params['alpha'].value print "Slope_ini" print self.Slope_ini self.Tpeak = (1/params['alpha'].value)*log(1+(params['alpha'].value/params['beta'].value)) print "Tpeak" print self.Tpeak self.Kpeak = -params['amp'].value * params['alpha'].value * params['beta'].value print "Kpeak" print self.Kpeak self.SER = exp( (t[4]-t[1])*params['beta'].value) * ( (1-exp(-params['alpha'].value*t[1]))/(1-exp(-params['alpha'].value*t[4])) ) print "SER" print self.SER ################################################## # Now Calculate enhancement Kinetic based features # Based on the course of signal intensity within the lesion print "\n Saving %s" % 'Crk' So = array(deltaS['delta0']).astype(float) Crk = {'Cr0': mean(So)} C = {} Carray = [] for k in range(1,len(DICOMImages)): Sk = array(deltaS['delta'+str(k)]).astype(float) Cr = 0 for j in range( len(So) ): # extract average enhancement over the lesion at each time point Cr = Cr + (Sk[j] - So[j])/So[j] Carray.append((Sk[j] - So[j])/So[j]) # compile C['C'+str(k)] = Carray Crk['Cr'+str(k)] = Cr/len(Sk) # Extract Fii_1 for k in range(1,5): currentCr = array(Crk['Cr'+str(k)]).astype(float) print currentCr if( self.maxCr < currentCr): self.maxCr = float(currentCr) self.peakCr = int(k) print "Maximum Upate (Fii_1) = %d " % self.maxCr print "Peak Cr (Fii_2) = %d " % self.peakCr # Uptake rate self.UptakeRate = float(self.maxCr/self.peakCr) print "Uptake rate (Fii_3) " print self.UptakeRate # WashOut Rate if( self.peakCr == 4): self.washoutRate = 0 else: self.washoutRate = float( (self.maxCr - array(Crk['Cr'+str(4)]).astype(float))/(4-self.peakCr) ) print "WashOut rate (Fii_4) " print self.washoutRate ################################################## # Now Calculate enhancement-variance Kinetic based features # Based on Crk['Cr'+str(k)] = Cr/len(Sk) print "\n Saving %s" % 'Vrk' Vrk = {} for k in range(1,5): Ci = array(C['C'+str(k)]).astype(float) Cri = array(Crk['Cr'+str(k)]).astype(float) Vr = 0 for j in range( len(Ci) ): # extract average enhancement over the lesion at each time point Vr = Vr + (Ci[j] - Cri)**2 # compile Vrk['Vr'+str(k)] = Vr/(len(Ci)-1) # Extract Fiii_1 for k in range(1,5): currentVr = array(Vrk['Vr'+str(k)]).astype(float) if( self.maxVr < currentVr): print currentVr self.maxVr = float(currentVr) self.peakVr = int(k) print "Maximum Variation of enhan (Fiii_1) = %d " % self.maxVr print "Peak Vr (Fii_2) = %d " % self.peakVr # Vr_increasingRate self.Vr_increasingRate = self.maxVr/self.peakVr print "Vr_increasingRate (Fiii_3)" print self.Vr_increasingRate # Vr_decreasingRate if( self.peakVr == 4): Vr_decreasingRate = 0 else: Vr_decreasingRate = float((self.maxVr - array(Vrk['Vr'+str(4)]).astype(float))/(4-self.peakVr)) print "Vr_decreasingRate (Fiii_4) " print Vr_decreasingRate # Vr_post_1 self.Vr_post_1 = float( array(Vrk['Vr'+str(1)]).astype(float)) print "Vr_post_1 (Fiii_5)" print self.Vr_post_1 ################################################## # orgamize into dataframe self.dynamicEMM_inside = DataFrame( data=array([[ self.amp, self.alpha, self.beta, self.iAUC1, self.Slope_ini, self.Tpeak, self.Kpeak, self.SER, self.maxCr, self.peakCr, self.UptakeRate, self.washoutRate, self.maxVr, self.peakVr, self.Vr_increasingRate, self.Vr_post_1]]), columns=['A.inside', 'alpha.inside', 'beta.inside', 'iAUC1.inside', 'Slope_ini.inside', 'Tpeak.inside', 'Kpeak.inside', 'SER.inside', 'maxCr.inside', 'peakCr.inside', 'UptakeRate.inside', 'washoutRate.inside', 'maxVr.inside', 'peakVr.inside','Vr_increasingRate.inside', 'Vr_post_1.inside']) ############################################################# # try to plot results pylab.figure() pylab.errorbar(t, data, yerr=se_deltaS, fmt='ro', label='data+SE') # data 'ro' red dots as markers pylab.plot(t, final, 'b+', label='data+residuals') # data+residuals 'b+' blue pluses pylab.plot(t, model, 'b', label='model') # model fit 'b' blue pylab.plot(x, model_res, 'k', label='model fit') # model fit 'k' blakc pylab.xlabel(" post-contrast time (min)") pylab.ylabel("delta S(t)") pylab.legend() return self.dynamicEMM_inside
def _findDB_old(self,directions=[45,135,-45,-135]): '''Function determining the direct beam position on the given scattering image. **Arguments:** *xi*,*yi*: float tupile Initial estimates of the direct beam position. *img*: 2D array Detector image. *dchi*: float Azimuthal angle in deg used for averaging. *pix_size* float Pixel size in [m]. Required by the pyFAI integrator function. *wavelength* float X-ray wavelength in [m] *dist* float sample-detector distance in [mm] *rmin* int lower bound for the fitted ROI (in pixels) *rmax* upper bound for the fitted ROI (in pixels) *directions* 4 or 3 element list list of angles used for azimuthal integration and fitting Returns: *[xm,ym]*: float list Direct beam position ''' xi = self.Parameters['cenx'] yi = self.Parameters['ceny'] img = self.static mask = self.mask if self.Parameters['oldInputFormat']: mask = (mask + 1) % 2 dchi = self.Parameters['dchi'] pixSize = self.Parameters['pixSize'] * 1e-3 sdDist = self.Parameters['sdDist'] * 1e-3 rmin = self.Parameters['rmin'] rmax = self.Parameters['rmax'] wavelength = self.Parameters['wavelength'] * 1e-10 params = lmfit.Parameters() params.add('xi', value = xi, vary = True) params.add('yi', value = yi, vary = True) fitOut = lmfit.minimize(resid_db,params,\ args=(img,mask,dchi,pixSize,wavelength,sdDist,rmin,rmax,directions),full_output=1) fitOut.leastsq() lmfit.report_errors(fitOut.params) # Updating parameters: self.Parameters['cenx'] = round(fitOut.params['xi'].value, 2) self.Parameters['ceny'] = round(fitOut.params['yi'].value, 2) # Adding the new direct beam position to the input file: try: self.config.set('Main','cenx',value = '%.2f' % fitOut.params['xi'].value) self.config.set('Main','ceny',value = '%.2f' % fitOut.params['yi'].value) except: self.config.set('Beam','cenx',value = '%.2f' % fitOut.params['xi'].value) self.config.set('Beam','ceny',value = '%.2f' % fitOut.params['yi'].value) f = open(self.inputFileName,'w') self.config.write(f) f.close()
params = lmfit.Parameters() params.add('A', value = 0, vary = True) ##cos ### -3 cXZ sin 2 chi: 7 +- 23 mHz params.add('B', value = 0, vary = True) ##sin ### -3 cYZ sin 2 chi: 32 +- 56 mHz params.add('C', value = 0, vary = True) ##cos2 ### -1.5 (cXX-cYY) sin^2 chi: 15 +- 22 mHz params.add('D', value = 0, vary = True) ##sin2 ### -3 cXY sin^2 chi: 8 +- 20 mHz #params.add('offset', value = 0.0) result = lmfit.minimize(cosine_fit, params, args = (x, y, yerr)) residual_array = result.residual*yerr #fit_values = y + result.residual lmfit.report_errors(params, min_correl=0) print "Reduced chi-squared = ", result.redchi #print result.redchi #print 1/params['freq'].value/3600 x_plot = np.linspace(x.min(),x.max(),1000) pyplot.plot(x,y,'-') #pyplot.plot(x_plot,cosine_model(params,x_plot),linewidth = 3.0) #pyplot.errorbar(time_array,freq_array,width_array, linestyle='None',markersize = 4.0,fmt='o',color='black')
def main(): # ---------------------------------------------------------------------- # import data # ---------------------------------------------------------------------- data = genfromtxt(sys.argv[1]) t_c = data[2:, 0] # time y_c = data[2:, 1] # measured decay curve y(t) g_c = data[2:, 2] # impulse g(t) # ---------------------------------------------------------------------- # lmfit section # ---------------------------------------------------------------------- params = Parameters() params.add("I_0", value=1.0) params.add("time0", value=1.0) # minimize residuals using lmfit # with Levenberg-Marquardt method, # the first, "signal" fitting procedure rezult = minimize(Conv_residuals, params, args=(t_c, y_c, g_c), method="leastsq") # -------------------------------------------------------------------- # leastsq, nelder, lbfgsb, anneal, powell, cg, newton, cobyla, slsqp provisional_parameters = rezult # will be printed at the end of the code residuals = Conv_residuals(rezult.params, t_c, y_c, g_c) # residuals y_lmfit = y_c + residuals # fitted line # ---------------------------------------------------------------------- # bootstrapping section # ---------------------------------------------------------------------- I_0 = [] # arrays of calculated parameters t_0 = [] # during bootstrapping iteration = int(input("How many bootstrapping iterations? ")) # number of boostrap procedures for i in range(iteration): params = Parameters() # repeat lmfit minimize using params.add("I_0", value=10.0) # Levenberg-Marquardt method params.add("time0", value=1.0) # with # y(t) + randomly sampled residuals rezult = minimize(Conv_residuals, params, args=(t_c, bootstrap(y_c, residuals), g_c), method="leastsq") I_0.append(rezult.params["I_0"].value) t_0.append(rezult.params["time0"].value) # ---------------------------------------------------------------------- # quantiles/errors and means # ---------------------------------------------------------------------- err_I_0 = stats.mstats.mquantiles(I_0, [0.0, 1.0]) err_t_0 = stats.mstats.mquantiles(t_0, [0.0, 1.0]) # 0.25, 0.75 -quantiles may be used instead of the full span # ---------------------------------------------------------------------- # runs test # ---------------------------------------------------------------------- np = nm = 0 # number of positive and negative residuals, respectively nR = 1 # observed number of runs (changes of sign) if residuals[0] < 0: nm += 1 for i in range(1, len(residuals)): # loop for calculating # nm and nR if residuals[i] < 0: nm += 1 if residuals[i - 1] > 0: nR += 1 elif residuals[i - 1] < 0: nR += 1 np = len(residuals) - nm # np - number of positive residuals R = 1 + (2 * np * nm) / (np + nm) # expected number of runs sigma_R = sqrt(2 * nm * np * (2 * nm * np - np - nm) / ((np + nm - 1) * (np + nm) ** 2)) # variance of the expected number of runs if nR <= R: Z = (nR - R + 0.5) / sigma_R else: # estimated standard normal Z = (nR - R - 0.5) / sigma_R # distribution (Z-score) # ---------------------------------------------------------------------- # report results of calculations # ---------------------------------------------------------------------- print("\nLMFIT report:\n") # results from the 'signal' fit report_errors(provisional_parameters) print( "\nBootstrapping report:\n\nI_0 =", "%.4f" % median(I_0), "\t(-", "%.4f" % (100 * ((median(I_0) - err_I_0[0]) / median(I_0))), "% / +", "%.4f" % (100 * ((err_I_0[1] - median(I_0)) / median(I_0))), "%)", ) # NOTE! since the statistical approach # has been used, medians are more relevant # instead of means print( "t_0 =", "%.4f" % median(t_0), "\t(-", "%.4f" % (100 * ((median(t_0) - err_t_0[0]) / median(t_0))), "% / +", "%.4f" % (100 * ((err_t_0[1] - median(t_0)) / median(t_0))), "%)\n", ) print( "Runs test:\n\n Numbers of points:\n n_m =", nm, "\n n_p =", np, "\n\n" "Observed number of runs n_R =", nR, "\n" "Expected number of runs R =", "%.4f" % R, "+/-", "%.4f" % sigma_R, "\n" "The standard normal distribution score Z =", "%.4f" % Z, ) # ---------------------------------------------------------------------- # plot section # ---------------------------------------------------------------------- f_c = [] # luminescence decay as exp-model for i in range(len(t_c)): f_c.append(median(I_0) * exp(-(t_c[i]) / median(t_0))) suptitle(r"Decay kinetics of BaF$_2$ 78 nm nanoparticles", fontsize=18) subplot(211) plot(t_c, y_c / max(y_c), "bo", label=r"$y(t)$") # all graphs are normalized plot(t_c, g_c / max(g_c), "ro", label=r"$g(t)$") plot(t_c, y_lmfit / max(y_lmfit), "m-", label="fitting curve") plot(t_c, f_c / max(f_c), "g.--", label=r"$f(t)$") xlabel("Time (ns)", fontsize=15) ylabel("Intensity (a.u.)", fontsize=16) legend(loc=1) subplot(212) stem(t_c, residuals, linefmt="g--", markerfmt="bs", basefmt="r-") xlabel("Time (ns)", fontsize=15) ylabel(r"Residuals $y - y_{model}$", fontsize=16) subplots_adjust(hspace=0.3, wspace=0.3, right=0.95, top=0.92) show() # ------------Histograms---------------------------- suptitle(r"Decay kinetics of BaF$_2$ 78 nm nanoparticles", fontsize=18) subplot(121) hist(I_0, color="green") xlabel(r"$I_0$ (a.u.)", fontsize=16) ylabel(r"Frequency", fontsize=16) subplot(122) hist(t_0, color="green") xlabel(r"$t_0$ (ns)", fontsize=16) ylabel("Frequency", fontsize=16) subplots_adjust(hspace=0.4, left=0.1, right=0.95, top=0.92) show()
]) x = time y = v_rms yerr = y*0.02 params = lmfit.Parameters() params.add('A', value = 9.0) params.add('B', value = 0.65) result = lmfit.minimize(fit_fit, params, args = (x, y, yerr)) fit_values = y + result.residual lmfit.report_errors(result.params) x_plot = np.linspace(x.min(),x.max(),200) figure = pyplot.figure(0) #print x_plot #print fit_model(result.params,x_plot) pyplot.errorbar(x,y,yerr, linestyle='None',markersize = 4.0,fmt='o',color='black') pyplot.plot(x_plot,fit_model(result.params,x_plot),linewidth = 3.0) #pyplot.xscale('log') pyplot.yscale('log',basey = 10,subsy=[2, 3, 4, 5, 6, 7, 8, 9]) pyplot.show()
width[t_selection])) params2 = start_params(time_w_pct[t_selection], width[t_selection]) lmfit.minimize(residuals, params2, args=(time_w_pct[t_selection], width[t_selection])) params_center = start_params(time_w_pct[t_selection], center[t_selection]) params_center['background'].value = np.nanmean(width) params_center['background'].min = 0 params_center['background'].max = 110 params_center['slope'].value = 0 lmfit.minimize(residuals, params_center, args=(time_w_pct[t_selection], center[t_selection])) print '\nparams1:' lmfit.report_errors(params1) print '\nparams2:' lmfit.report_errors(params2) print '\nparams_center:' lmfit.report_errors(params_center) img1 = aolPyModules.plotting.center_histogram_2d(time_w_dither, width, time_ax, width_ax) img2 = aolPyModules.plotting.center_histogram_2d(time_w_pct, width, time_ax, width_ax) img_center = aolPyModules.plotting.center_histogram_2d(time_w_pct, center, time_ax, center_ax) mean1 = img1.T.dot(width_ax) / img1.sum(0) mean2 = img2.T.dot(width_ax) / img2.sum(0) mean_center = img_center.T.dot(center_ax) / img_center.sum(0)
#print omegataus #print masterchi params['beta'].vary=True params['logK_dd'].value=0 params['logK_dd'].min=-2 params['logK_dd'].max=2 params['logtau'].value=0 params['logtau'].min=-3 params['logtau'].max=3 omegataus=np.array(omegataus) out=minimize(residual,params,args=(omegataus,masterchi)) result=omegataus+out.residual fit=residual(params,omegataus) print 'beta '+str(params['beta'].value) report_errors(params) ####parameter updaten und ausgabe anpassen while True: tauout=open('tau.dat','w') for i in range(0,taus.__len__()): taus[i]=taus[i]+params['logtau'].value tauout.write(str(temps[i])+' '+str(taus[i])+'\n') break omegataus=[] masterchi=[] ax.cla() ax.set_xscale('log') ax.set_yscale('log') ax.set_title('Masterkurve')
params.add('x0_b',value=p0[4]) params.add('y0_b',value=p0[5]) galtype = galsim.Gaussian imsize = 49 pixel_scale = 0.2 print " ************** About to fit" result = lmfit.minimize(mssg_drawLibrary.resid_2obj, params, args=(blend, imsize,imsize,pixel_scale, galtype, galtype )) ipdb.set_trace() # Report the parameters to the interpreter screen lmfit.report_errors(result.params) sys.exit() ######################################################### Deblend # Use deblending code to separate them # templates = for each img
define how to compare data to the function ''' def hanle_fit(params , x, data, err): model = hanle_model(params, x) return (model - data)/err params = lmfit.Parameters() params.add('amplitude', value = 172764) params.add('gamma', value = 10) params.add('offset', value = 8264) x_data = (np.array([12.00,10.97,10.03,9.29,8.29,7.10,6.09,5.10,4.05]))+0.825 #11.1 y_err = np.array([434,442,435,434,439,429,438,437,435]) y_data = np.array([30917,30590,31248,31314,31346,32141,31766,32516,33161]) #4120 result = lmfit.minimize(hanle_fit, params, args = (x_data, y_data, y_err)) fit_values = y_data + result.residual lmfit.report_errors(params) contrast = params['amplitude'].value/params['offset'].value/params['gamma'].value/2 print 'contrast = ',contrast #lmfit.report_errors(params) pyplot.errorbar(x_data,y_data,y_err,ls='None',markersize = 3.0,fmt='o') pyplot.plot(np.arange(-40,40,0.1),hanle_model(params,np.arange(-40,40,0.1))) pyplot.show()
def fit_conic(xx, yy, Rh, thh, PAh, xxh, yyh, symmetrical=True, freeze_theta=False, full=False, Rmin=0.0): """Fit conic section to the data xx, yy The hyperbola is described by 5 parameters: Rh : radius of curvature on the axis thh: asymptotic angle of wings from axis PAh: Position Angle of axis (pegged to xhh, yhh if symmetrical=True) xxh: xx position of center-of-curvature yyh: yy position of center-of-curvature If symmetrical=True, then the axis must pass through the star (origin of xx, yy frame) => tan(PAh) = xxh/yyh The hyperbola is given as y(x), where y goes along the hyperbola axis and x is perpendicular to the hyperbola axis. The origin of the xy frame (x = y = 0) is the "nose" of the hyperbola, with coordinates in the xx-yy frame of xx0 = xxh + Rh sin(PAh) yy0 = yyh + Rh cos(PAh) The y-axis is along the [xx, yy] unit vector: yhat = [-sin(PAh), -cos(PAh)] The x-axis is along the [xx, yy] unit vector: xhat = [-cos(PAh), -sin(PAh)] Unit distance in the xy frame corresponds to Rh in the xx-yy frame So that x = ((xx - xx0) (-cos(PAh)) + (yy - yy0) (-sin(PAh)))/Rh y = ((xx - xx0) (-sin(PAh)) + (yy - yy0) (-cos(PAh)))/Rh """ def model_minus_data(params, xx, yy, full=False): """Function to minimize - gives equal weight to all points and is in units of arcsec""" # Unpack parameters PAh = params["PA"].value Rh = params["R"].value xxh = params["xx"].value yyh = params["yy"].value thh = params["th"].value # Transform from (xx,yy) to (x,y) frame sPA, cPA = np.sin(np.radians(PAh)), np.cos(np.radians(PAh)) xx0, yy0 = xxh + Rh*sPA, yyh + Rh*cPA x = (-(xx0 - xx)*cPA + (yy0 - yy)*sPA)/Rh y = ((xx0 - xx)*sPA + (yy0 - yy)*cPA)/Rh residual = Rh*(yconic_th(x, thh) - y) if full: return {"residual": residual, "x": x, "y": y} else: return residual approx_scale = abs(xx[0]) + abs(xx[-1]) + abs(yy[0]) + abs(yy[-1]) # Pack arguments into parameters for the fit params = lmfit.Parameters() params.add("PA", value=PAh) params.add("R", value=Rh, min=Rmin, max=2*approx_scale) params.add("xx", value=xxh) params.add("yy", value=yyh) params.add("th", value=thh, min=-90.0, max=90.0, vary=not freeze_theta) if symmetrical: params["xx"].expr = "yy * tan(PA*pi/180.0)" lmfit.minimize(model_minus_data, params, args=(xx, yy)) lmfit.report_errors(params) # Unpack parameters again for results to return results = [params[k].value for k in "R", "th", "PA", "xx", "yy"] if full: return tuple(results + [model_minus_data(params, xx, yy, True)]) else: return tuple(results)
def grid_fit(nparray, params, barr, plotflag = True): """ Fit a grid to a 2D data set """ def grid(ov, oh, s, h, w, a): """ Return a 2d grid h = height of image w = width of image ov = origin vertical oh = origin horizontal s = spacing a = amplitude """ g = np.zeros((h,w)) #nparray full of zeros nv = int(w/s +2) #+2 just to make sure nh = int(h/s+2) #calculate grid origin offset _hp = ov while _hp >= s: _hp = _hp - s #print _hp for _nv in xrange(nv): # for every vertical line #calculate horizontal position _pos = _nv * s + _hp #print _pos for _h in xrange(h): #for every height try: g[_h, int(_pos)] = (1-(_pos - int(_pos))) *a g[_h, int(_pos+1)] = (1-(int(_pos+1)-_pos)) *a except IndexError: pass _vp = oh while _vp >= s: _vp = _vp -s for _nh in xrange(nh): _pos = _nh * s + _vp for _v in xrange(w): try: g[int(_pos), _v] = (1-(_pos - int(_pos))) *a g[int(_pos+1), _v] = (1-(int(_pos+1)-_pos)) *a except IndexError: pass return g def res(params, nparray): s = params['s'].value ov = params['ov'].value oh = params['oh'].value a = params['a'].value h = nparray.shape[0] w = nparray.shape[1] #b = params['b'].value #barr = np.ones((h,w))*b model = grid(ov, oh, s, h, w, a) err = nparray - (barr-model) err = err.flatten() return err #do fit minimize(res, params, args=(nparray,)) #komma ist wichtig, da tupel erwartet! report_errors(params) if plotflag == True: s = params['s'].value ov = params['ov'].value oh = params['oh'].value a = params['a'].value h = nparray.shape[0] w = nparray.shape[1] #b = params['b'].value #barr = np.ones((h,w))*b g = grid(ov, oh, s, h, w, a) #sp.misc.imsave('grid.jpg', g) #fit = nparray+g-barr plt.cla() plt.clf() plt.imshow(img) #plt.hold(True) plt.imshow(g, alpha=0.5) #plt.colorbar() plt.savefig('gridfit.jpg') sp.misc.imsave('grid.jpg', g) plt.show() return params
# do fit, here with leastsq model result1 = minimize(quarterPowerFunction, params1, args=(x, data)) params2 = Parameters() params2.add('alpha', value= 1, min=0) params2.add('power', value= 1) result2 = minimize(fcn2min, params2, args=(x, data)) # calculate final result final1 = data + result1.residual final2 = data + result2.residual # write error report report_errors(params1) pp = pprint.PrettyPrinter(indent=4) pp.pprint(params1) print params1.get('alpha') p=params1.get('alpha') print "standard error ", p.stderr total= np.sum(result1.residual) print "sum of residuals: ", total #print "xtol: ", result1.xtol print "reduced chi-square: ", result1.redchi #print "asteval", result1.asteval print "message:", result1.message print "ier:", result1.ier
mcmc_fit.flatchain, axis=0) mcmc_model = generate_spiderman_model(times, planet_info, nrg_ratio, temp_night, delta_T, T_star, spider_params) plot_now = True if plot_now: ax = plot_model(times, data, fpfs, label='STARRY', ax=None) ax = plot_model(times, init_model, fpfs, label='Init Model', ax=ax) ax = plot_model(times, fit_model, fpfs, label='MLE Model', ax=ax) ax = plot_model(times, mcmc_model, fpfs, label='MCMC Model', ax=ax) corner_plot = False if corner_plot: report_errors(mcmc_fit.params) res = mcmc_fit res_var_names = np.array(res.var_names) res_flatchain = np.array(res.flatchain) res_df = DataFrame(res_flatchain.copy(), columns=res_var_names) res_df = DataFrame(res_flatchain.copy(), columns=res_var_names) res_df.sort_index('columns', inplace=True) def add_newline(label): return label + '\n' color = 'indigo' n_sigma = 3 levels = [
ind_kdtree=ind_kdtree, pld_intensities=pld_intensities, method=method.lower(), gw_kdtree=gw_kdtree, transit_indices=transit_indices, x_bin_size=x_bin_size, y_bin_size=y_bin_size) print('Fitting the Model') # Setup up the call to minimize the residuals (i.e. ChiSq) mle0 = Minimizer(partial_residuals, initialParams) start = time() fitResult = mle0.leastsq() # Go-Go Gadget Fitting Routine print("LMFIT operation took {} seconds".format(time() - start)) report_errors(fitResult.params) print('Establishing the Best Fit Solution') bf_model_set = skywalker.generate_best_fit_solution( fitResult.params, times=times, xcenters=xcenters, ycenters=ycenters, fluxes=fluxes, knots=knots, keep_inds=keep_inds, method=method, nearIndices=nearIndices, ind_kdtree=ind_kdtree, gw_kdtree=gw_kdtree,
def test_report_errors_deprecated(fitresult): """Verify that a FutureWarning is shown when calling report_errors.""" with pytest.warns(FutureWarning): report_errors(params=fitresult.params)
amp = pars['amp'].value per = pars['period'].value shift = pars['shift'].value decay = pars['decay'].value if abs(shift) > np.pi/2: shift = shift - np.sign(shift)*np.pi model = amp*np.sin(shift + x/per) * np.exp(-x*x*decay*decay) if data is None: return model return (model - data) n = 20 xmin = 10. xmax = 250.0 noise = np.random.normal(scale=0.7215, size=n) x = np.linspace(xmin, xmax, n) data = residual(p_true, x) + noise fit_params = Parameters() fit_params.add('amp', value=13.0) fit_params.add('period', value=2) fit_params.add('shift', value=0.0) fit_params.add('decay', value=0.02) out = minimize(residual, fit_params, args=(x,), kws={'data':data}) fit = residual(fit_params, x) report_errors(fit_params) plt.plot(x,fit) plt.plot(x,data,linestyle='None',marker='o') plt.show()
#pyplot.plot(data_x,data_y) params = lmfit.Parameters() params.add('amplitude', value=33453, min=0) params.add('gamma', value=24.0) params.add('offset', value=0.05) params.add('beta', value=1.60, min=0) params.add('Omega', value=30.704) params.add('B', value=1.20) params.add('center', value=227) result = lmfit.minimize(micro_fit, params, args=(data_x, data_y, y_err)) fit_values = data_y + result.residual lmfit.report_errors(params) normalization = params['amplitude'] / (params['gamma'] / 2.0)**2 pyplot.plot(np.arange(120, 340, 0.1) - params['center'], micro_model(params, np.arange(120, 340, 0.1)) / normalization, linewidth=1.5) pyplot.errorbar(data_x - params['center'], data_y / normalization, data_yerr / normalization, linestyle='None', markersize=4.0, fmt='o', color='black') pyplot.axis([-110, 110, 0.04, 0.95])
data = residual(p_true, x) + noise fit_params = Parameters() fit_params.add('amp', value=13.0) fit_params.add('period', value=2) fit_params.add('shift', value=0.0) fit_params.add('decay', value=0.02) out = minimize(residual, fit_params, args=(x, ), kws={'data': data}) fit = residual(fit_params, x) print(' N fev = ', out.nfev) print(out.chisqr, out.redchi, out.nfree) report_errors(fit_params) #ci=calc_ci(out) ci, tr = conf_interval(out, trace=True) report_ci(ci) if HASPYLAB: names = fit_params.keys() i = 0 gs = pylab.GridSpec(4, 4) sx = {} sy = {} for fixed in names: j = 0 for free in names: if j in sx and i in sy: ax = pylab.subplot(gs[i, j], sharex=sx[j], sharey=sy[i])