def fit_repumping(g_a, g_A, g_tau, g_tau2, g_offs_x, *arg): """ fitfunction for an exponential decay, y(x) = A * exp(-x/tau)+ A2 * exp(-x/tau2) + a Initial guesses (in this order): g_a : offset g_A : initial Amplitude g_tau : decay constant g_tau2 : decay constant 2 g_offs_x : x offset """ fitfunc_str = 'A * exp(-(x-offs_x)/tau)+ A2 * exp(-(x-offs_x)/tau2) + a' a = fit.Parameter(g_a, 'a') A = fit.Parameter(g_A, 'A') tau = fit.Parameter(g_tau, 'tau') tau2 = fit.Parameter(g_tau2, 'tau2') offs_x = fit.Parameter(g_offs_x, 'offs_x') p0 = [a, A, tau, tau2, offs_x] def fitfunc(x): return a() + A() * np.exp( -(x-offs_x()) / tau()) + (1-A()) * np.exp(-(x-offs_x())/tau2()) return p0, fitfunc, fitfunc_str
def fit_double_exp_decay_with_offset(g_a, g_A, g_tau, g_A2, g_tau2, *arg): """ fitfunction for an exponential decay, y(x) = A * exp(-x/tau)+ A2 * exp(-x/tau2) + a Initial guesses (in this order): g_a : offset g_A : initial Amplitude g_tau : decay constant g_A2 : initial Amplitude 2 g_tau2 : decay constant 2 """ fitfunc_str = 'A * exp(-x/tau)+ A2 * exp(-x/tau2) + a' a = fit.Parameter(g_a, 'a') A = fit.Parameter(g_A, 'A') tau = fit.Parameter(g_tau, 'tau') A2 = fit.Parameter(g_A2, 'A2') tau2 = fit.Parameter(g_tau2, 'tau2') p0 = [a, A, tau, A2, tau2] def fitfunc(x): return a() + A() * np.exp(-x/tau()) + A2() * np.exp(-x/tau2()) return p0, fitfunc, fitfunc_str
def fit_clipping_losses_hybrid(g_d, g_ROC,g_Dia,g_L_init, *arg): """ fitting the clipping loss as a function of length. use the analytic solution for the beam diameter on the mirror (see mathematica notebook gaussian_beams_in_hybrid_cavity) """ fitfunc_str = '2pi/(Lclip+Linit); Lclip = e^(-2(D/2)^2/wm^2; wm^2 = lambda/(nd*pi) * nd*(x + d/nd^2) *sqrt(ROC/(x+d/nd^2) -1 ) ' wavelength = 637e-9 nd = 2.41 d = fit.Parameter(g_d,'d') ROC = fit.Parameter(g_ROC, 'ROC') Dia = fit.Parameter(g_Dia, 'Dia') L_init = fit.Parameter(g_L_init, 'L_init') p0 = [d,ROC,Dia,L_init] def fitfunc(x): z0a = ( x + d()/nd**2 ) * np.sqrt( ( ROC()/(x + (d()/nd**2) ) ) -1 ) delta_za = d()*(nd**2-1)/nd**2 w0asquared = wavelength/(np.pi) * z0a wmsquared = w0asquared* (1 + ( (x + d() - delta_za ) / z0a )**2 ) #wavelength/(nd*np.pi) * ( x + d()/nd**2 )) * np.sqrt( ROC()/(x + d()/nd**2 ) -1 ) Lclip = np.exp(-2*((Dia()/2)**2/wmsquared)) return 2*np.pi/(Lclip+L_init()) # return 2*np.pi/(np.exp(-2*(Dia()/2)**2/(wavelength/(nd*np.pi) * (nd*( x + d()/nd**2 )) * np.sqrt( ROC()/(x + d()/nd**2 ) -1 ) ))+L_init()) return p0, fitfunc, fitfunc_str
def setcoef(self, x=1): self.coef = [] for i in range(self.order): try: self.coef.append(ft.Parameter(x[i])) except TypeError: self.coef.append(ft.Parameter(x))
def fit_5lorentz_symmetric_sym_A(g_a1, g_A1, g_x01, g_gamma1, g_dx, g_A2,g_A3, g_A4,g_A5): # fit for 3 lorentzians for EOM drive, symmetric around middle peak fitfunc_str = 'a1 + 2*A1/np.pi*gamma1/(4*(x-x01)**2+gamma1**2) \ + 2*A2/np.pi*gamma2/(4*(x-x01-dx)**2+gamma1**2) + 2*A3/np.pi*gamma2/(4*(x-x01+dx)**2+gamma1**2)\ + 2*A4/np.pi*gamma2/(4*(x-x01-2dx)**2+gamma1**2) + 2*A5/np.pi*gamma2/(4*(x-x01+2dx)**2+gamma1**2)' a1 = fit.Parameter(g_a1, 'a1') A1 = fit.Parameter(g_A1, 'A1') x01 = fit.Parameter(g_x01, 'x01') gamma1 = fit.Parameter(g_gamma1, 'gamma1') dx = fit.Parameter(g_dx,'dx') A2 = fit.Parameter(g_A2, 'A2') A3 = fit.Parameter(g_A3, 'A3') A4 = fit.Parameter(g_A4, 'A4') A5 = fit.Parameter(g_A5, 'A5') p0 = [a1, A1, x01, gamma1, dx, A2,A3,A4,A5] #p0 = [a1, A1, x01, gamma1, A2, x02, gamma2, A3, x03, gamma3] def fitfunc(x): return a1()+2*A1()/np.pi*gamma1()/(4*(x-x01())**2+gamma1()**2)+\ 2*A2()/np.pi*gamma1()/(4*(x-x01()-dx())**2+gamma1()**2) + 2*A3()/np.pi*gamma1()/(4*(x-x01()+dx())**2+gamma1()**2) +\ 2*A4()/np.pi*gamma1()/(4*(x-x01()-(2*dx()) )**2+gamma1()**2) + 2*A5()/np.pi*gamma1()/(4*(x-x01()+(2*dx()) )**2+gamma1()**2) return p0, fitfunc, fitfunc_str
def fit_double_decaying_cos(g_f1, g_A1, g_phi1, g_t1, g_f2, g_A2, g_phi2, g_t2, g_o ,*arg): ''' quite a specific function, for electron nuclear control, maybe place somewhere else ''' fitfunc_str = '''(A1 *exp(-x/t1) cos(2pi * (f1*x + phi1/360) ) + a1)* (A2 *exp(-x/t2) cos(2pi * (f2*x + phi2/360) ) + a2)/2+ o ''' f1 = fit.Parameter(g_f1, 'f1') #a1 = fit.Parameter(g_a1, 'a1') A1 = fit.Parameter(g_A1, 'A1') phi1 = fit.Parameter(g_phi1, 'phi1') t1 = fit.Parameter(g_t1, 't1') f2 = fit.Parameter(g_f2, 'f2') #a2 = fit.Parameter(g_a2, 'a2') A2 = fit.Parameter(g_A2, 'A2') phi2 = fit.Parameter(g_phi2, 'phi2') t2 = fit.Parameter(g_t2, 't2') o = fit.Parameter(g_o, 'o') #p0 = [f1, a1, A1, phi1, t1, f2, a2, A2, phi2, t2] p0 = [f1, A1, phi1, t1, f2, A2, phi2, t2,o] def fitfunc(x): return ( 1 - A1() + A1()*np.exp(-x/t1()) * np.cos(2*np.pi*( f1()*x + phi1()/360.)))*(1-A2() + A2()*np.exp(-x/t2()) * np.cos(2*np.pi*( f2()*x + phi2()/360.)))/2+o() return p0, fitfunc, fitfunc_str
def fit_gaussian_decaying_2cos(g_avg, g_C, g_t, g_A, g_f_a, g_phi_a, g_B, g_f_b, g_phi_b, *arg): """ Fits Gaussian decaying sum of two cosines. To be used for e.g. dynamicaldecoupling.Carbon_Ramsey_noDD""" fitfunc_str = 'avg + C * exp(-(x/t)**2) [ A*cos(2pi * (fa*x + phi_a/360) )+ B*cos(2pi * (f_b*x + phi_b/360)))/2 ]' avg = fit.Parameter(g_avg, 'avg') C = fit.Parameter(g_C, 'C') t = fit.Parameter(g_t, 't') A = fit.Parameter(g_A, 'A') f_a = fit.Parameter(g_f_a, 'f_a') phi_a = fit.Parameter(g_phi_a, 'phi_a') B = fit.Parameter(g_B, 'B') f_b = fit.Parameter(g_f_b, 'f_b') phi_b = fit.Parameter(g_phi_b, 'phi_b') p0 = [avg,C, t, A,f_a,phi_a,B,f_b,phi_b] #Note: If you do not want to use a fit argument set fixed when using in fit1d def fitfunc(x): return avg() + C() * np.exp(-(x/t())**2) * ( A()*np.cos(2*np.pi*( f_a()*x + phi_a()/360.)) + B() * np.cos(2*np.pi*( f_b()*x + phi_b()/360.)) )/2.0 return p0, fitfunc, fitfunc_str
def fit_hyperbola(g_a,g_n,g_o): fitfunc_str = 'a/(x**n)=o' a = fit.Parameter(g_a, 'a') n = fit.Parameter(g_n, 'n') o = fit.Parameter(g_o, 'o') p0 = [a,n,o] def fitfunc(x): return a()/(x**n())+o() return p0, fitfunc, fitfunc_str
def fit_dephasing_tau(g_a,g_coup,g_tau_offs): fitfunc_str = '-a/(ln2-ln(1+e**(-0.5* (2*pi*coup*(tau+tau_offs))**2)))' a = fit.Parameter(g_a, 'a') coup = fit.Parameter(g_coup, 'coup') tau_offs = fit.Parameter(g_tau_offs, 'tau_offs') p0 = [a,coup,tau_offs] def fitfunc(tau): return a()/(np.log(2)-np.log(1+np.exp(-0.5*(2 *np.pi*coup()*(tau+tau_offs()))**2.))) return p0, fitfunc, fitfunc_str
def fit_dephasing_constant_offset(g_a,g_coup,g_offs): fitfunc_str = '-a/(ln2-ln(1+e**(-0.5* (2*pi*coup*tau+offs)**2)))' a = fit.Parameter(g_a, 'a') coup = fit.Parameter(g_coup, 'coup') offs = fit.Parameter(g_offs, 'offs') p0 = [a, coup, offs] def fitfunc(x): return a()/(np.log(2.)-np.log(1.+np.exp(- 0.5*( offs() + x*2*np.pi*coup() )**2.))) return p0, fitfunc, fitfunc_str
def fit_parabole(g_o, g_A, g_c, *arg): fitfunc_str = 'o + A * (x-c)**2' o = fit.Parameter(g_o, 'o') A = fit.Parameter(g_A, 'A') c = fit.Parameter(g_c, 'c') p0 = [o, A, c] def fitfunc(x): return o() + A() * (x-c())**2 return p0, fitfunc, fitfunc_str
def fit_dephasing_coupl(g_a,g_tau,g_coup_offs): fitfunc_str = '-a/(ln2-ln(1+e**(-0.5* (2*pi*(x+coup_off)*tau)**2)))' a = fit.Parameter(g_a, 'a') tau = fit.Parameter(g_tau, 'tau') coup_offs = fit.Parameter(g_coup_offs, 'coup_offs') p0 = [a,tau,coup_offs] def fitfunc(coup): #return o()-a()/np.log((1.+np.exp(-0.5*(2*np.pi*x*tau())**2.))/2.) return a()/(np.log(2)-np.log(1+np.exp(-0.5*(2 *np.pi*(coup_offs()+coup)*tau())**2))) return p0, fitfunc, fitfunc_str
def fit_AOM_powerdependence(g_a, g_xc, g_k, *arg): fitfunc_str = 'a * exp(-exp(-k*(x-xc)))' a = fit.Parameter(g_a, 'a') xc = fit.Parameter(g_xc, 'xc') k = fit.Parameter(g_k, 'k') p0 = [a, xc, k] def fitfunc(x): return a() * np.exp(-np.exp(-k()*(x-xc()))) return p0, fitfunc, fitfunc_str
def fit_Rabi(g_f, g_A, *arg): fitfunc_str = 'A * cos(2pi * (f*x + phi/360) ) + a' Rabifreq = fit.Parameter(g_f, 'f') scale = fit.Parameter(g_A, 'A') p0 = [Rabifreq, scale] #Note: If you do not want to use a fit argument set fixed when using in fit1d def fitfunc(x): return 1 - 0.5*(1 - scale()*np.cos(2*np.pi*Rabifreq()*x)) return p0, fitfunc, fitfunc_str
def fit_general_exponential_fixed_offset(f_a, g_A, g_x0, g_T, g_n): fitfunc_str = 'a + A * exp(-((x-x0)/T )**n)' A = fit.Parameter(g_A, 'A') x0 = fit.Parameter(g_x0, 'x0') T = fit.Parameter(g_T, 'T') n = fit.Parameter(g_n, 'n') p0 = [A, x0, T, n] def fitfunc(x): return f_a + A() * np.exp(-(x-x0())**n()/(T()**n())) return p0, fitfunc, fitfunc_str
def fit_phase_sweep(g_phi0, g_A, *arg): fitfunc_str = '1- (0.5 - 0.5*scale + scale*cos(phi0 - x)**2)' phi0 = fit.Parameter(g_phi0, 'Phase offset') scale = fit.Parameter(g_A, 'Scale factor') p0 = [phi0, scale] #Note: If you do not want to use a fit argument set fixed when using in fit1d def fitfunc(x): return 1 - (0.5 - 0.5*scale() + scale()*np.cos(phi0() - x*(np.pi)/360)**2) return p0, fitfunc, fitfunc_str
def fit_cos(g_f, g_a, g_A, g_phi, *arg): fitfunc_str = 'A * cos(2pi * (f*x + phi/360) ) + a' f = fit.Parameter(g_f, 'f') a = fit.Parameter(g_a, 'a') A = fit.Parameter(g_A, 'A') phi = fit.Parameter(g_phi, 'phi') p0 = [f, a, A,phi] #Note: If you do not want to use a fit argument set fixed when using in fit1d def fitfunc(x): return a() + A() * np.cos(2*np.pi*( f()*x + phi()/360.)) return p0, fitfunc, fitfunc_str
def fit_AOM_powerdependence_diode(g_a,g_c, *arg): fitfunc_str = 'a * x + c' a = fit.Parameter(g_a, 'a') c = fit.Parameter(g_c, 'k') p0 = [a,c] def fitfunc(x): y = 0.5 * (np.sign((a()*x+c())) + 1)* (a()*x+c())* abs(np.sign((a()*x+c()))) return y return p0, fitfunc, fitfunc_str
def fit_gauss_pos(g_a, g_A, g_x0, g_sigma): ### i think there should be a factor 2 infront of the sigma fitfunc_str = 'a + |A| * exp(-(x-x0)**2/(2*sigma**2))' a = fit.Parameter(g_a, 'a') x0 = fit.Parameter(g_x0, 'x0') A = fit.Parameter(g_A, 'A') sigma = fit.Parameter(g_sigma, 'sigma') p0 = [a, x0, A, sigma] def fitfunc(x): return a() + np.abs(A()) * np.exp(-(x-x0())**2/(2*sigma()**2)) return p0, fitfunc, fitfunc_str
def fit_lorentz(g_a, g_A, g_x0, g_gamma): fitfunc_str = 'a + 2*A/np.pi*gamma/(4*(x-x0)**2+gamma**2)' a = fit.Parameter(g_a, 'a') A = fit.Parameter(g_A, 'A') x0 = fit.Parameter(g_x0, 'x0') gamma = fit.Parameter(g_gamma, 'gamma') p0 = [a, A, x0, gamma] def fitfunc(x): return a() + 2*A()/np.pi*gamma()/(4*(x-x0())**2+gamma()**2) return p0, fitfunc, fitfunc_str
def fit_general_exponential(g_a, g_A, g_x0, g_T, g_n): fitfunc_str = 'a + A * exp(-((x-x0)/T )**n)' a = fit.Parameter(g_a, 'a') A = fit.Parameter(g_A, 'A') x0 = fit.Parameter(g_x0, 'x0') T = fit.Parameter(g_T, 'T') n = fit.Parameter(g_n, 'n') p0 = [a, A, x0, T, n] def fitfunc(x): return a() + A() * np.exp(-(x-x0())**n()/(T()**n())) return p0, fitfunc, fitfunc_str
def fit_3level_autocorrelation(g_x0,g_A,g_a, g_tau1, g_tau2): fitfunc_str = 'scale()*(1-(2*np.pi*Rabifreq()/2) * (1 - np.cos(2*np.pi*Rabifreq()*x)))' x0 = fit.Parameter(g_x0,'x0') A = fit.Parameter(g_A,'A') a = fit.Parameter(g_a,'a') tau1 = fit.Parameter(g_tau1,'tau1') tau2 = fit.Parameter(g_tau2,'tau2') p0 = [x0,A,a,tau1,tau2] def fitfunc(x): return A()*(1-(1+a())*np.exp(-np.abs(x-x0())/tau1())+a()*np.exp(-(np.abs(x-x0())/tau2()))) return p0, fitfunc, fitfunc_str
def fit_decaying_cos_with_phase_errors(g_f, g_a, g_A, g_phi,g_t,phase_errors): fitfunc_str = 'A *exp(-x/t) cos(2pi * (f*x + (phi + phi_err/360) ) + a' f = fit.Parameter(g_f, 'f') a = fit.Parameter(g_a, 'a') A = fit.Parameter(g_A, 'A') phi = fit.Parameter(g_phi, 'phi') t = fit.Parameter(g_t, 't') # print 'guessed frequency is '+str(g_f) p0 = [f, a, A,phi,t] def fitfunc(x, phi_err=phase_errors): return a() + A()*np.exp(-x/t()) * np.cos(2*np.pi*( f()*x + (phi()+phi_err)/360.)) return p0, fitfunc, fitfunc_str
def fit_clipping_radius(g_ROC,g_rclip,g_Transmission,g_Loss, *arg): fitfunc_str = '2*np.pi/(Transmission+Loss+exp(-2rclip**2/(wavelength/np.pi*(L*ROC)**0.5)))' wavelength = 637e-9 ROC = fit.Parameter(g_ROC, 'ROC') rclip = fit.Parameter(g_rclip, 'rclip') Transmission = fit.Parameter(g_Transmission, 'Transmission') Loss = fit.Parameter(g_Loss, 'Loss') p0 = [ROC,rclip,Transmission,Loss] def fitfunc(x): return 2*np.pi/(Transmission()+Loss())+np.exp(-2*rclip()**2/(wavelength**2/np.pi**2*wavelength*x/2*(ROC()-wavelength*x/2))) return p0, fitfunc, fitfunc_str
def fit_gaussian_decaying_cos(g_f, g_a, g_A, g_phi,g_t, *arg): fitfunc_str = 'A *exp(-(x/t)**2) cos(2pi * (f*x + phi/360) ) + a' f = fit.Parameter(g_f, 'f') a = fit.Parameter(g_a, 'a') A = fit.Parameter(g_A, 'A') phi = fit.Parameter(g_phi, 'phi') t = fit.Parameter(g_t, 't') print 'guessed frequency is '+str(g_f) p0 = [f, a, A,phi,t] def fitfunc(x): retval = a() + A()*np.exp(-(x/t())**2) * np.cos(2*np.pi*( f()*x + phi()/360.)) return retval return p0, fitfunc, fitfunc_str
def fit_inverse_NMR_spectrum(g_f, g_A, g_x0,g_t,g_o, *arg): fitfunc_str = '((Rabifreq)**2/2*sqrt(Rabifreq**2+x**2)) * (1-scale*cos(sqrt((2*pi*Rabifreq)**2 + (2*pi*x)**2)*pulse_t' Rabifreq = fit.Parameter(g_f, 'Rabi frequency') scale = fit.Parameter(g_A, 'Scale factor') x0 = fit.Parameter(g_x0, 'Centre frequency') pulse_t = fit.Parameter(g_t,'pulse_t') offset = fit.Parameter(g_o, 'offset') p0 = [Rabifreq, scale, x0, pulse_t, offset] #Note: If you do not want to use a fit argument set fixed when using in fit1d def fitfunc(x): return offset() + (0.5 - 0.5*scale() + scale()*Rabifreq()**2/(2*(Rabifreq()**2 + (x-x0())**2))*(1-np.cos(np.sqrt((2*np.pi*Rabifreq())**2 + (2*np.pi*x-2*np.pi*x0())**2)*pulse_t()))) return p0, fitfunc, fitfunc_str
def fit_poly_shifted(g_x0,*arg): fitfunc_str = 'sum_n ( a[n] * (x-x0)**n )' idx = 0 p0 = [] x0 = fit.Parameter(g_x0, 'x0') p0.append(x0) for i,a in enumerate(arg): p0.append(fit.Parameter(a, 'a%d'%i)) idx = i def fitfunc(x): val=0 for i in range(idx+1): val += p0[i+1]() * (x-x0())**i return val return p0, fitfunc, fitfunc_str
def fit_2lorentz_symmetric(g_a, g_A, g_x0, g_gamma, dx): fitfunc_str = 'a + 2*A/np.pi*gamma/(4*(x-x01)**2+gamma**2) \ + 2*A/np.pi*gamma/(4*(x-x02)**2+gamma**2)' a = fit.Parameter(g_a, 'a') A = fit.Parameter(g_A, 'A') x0 = fit.Parameter(g_x0, 'x0') gamma = fit.Parameter(g_gamma, 'gamma') dx = fit.Parameter(dx, 'dx') p0 = [a, A, x0, gamma, dx] def fitfunc(x): return a()+2*A()/np.pi*gamma()/(4*(x-x0()-(dx()/2))**2+gamma()**2)+\ 2*A()/np.pi*gamma()/(4*(x-x0()+(dx()/2))**2+gamma()**2) return p0, fitfunc, fitfunc_str
def fit_2d_gaussian(g_offset,g_A, g_x0, g_y0, g_sigmax, g_sigmay, g_theta, *arg): """ fitfunction for a 2d gaussian have to transform this to a 1d array in the fit2d function """ fitfunc_str = 'offset + A * ( a * exp(-(x-x0)**2) + b *(x-x0)(y-y0) +c *exp(-(y-y0)**2) ' A = fit.Parameter(g_A, 'A') offset = fit.Parameter(g_offset, 'a') x0 = fit.Parameter(g_x0, 'x0') y0 = fit.Parameter(g_y0, 'y0') sigmax = fit.Parameter(g_sigmax, 'sigmax') sigmay = fit.Parameter(g_sigmay, 'sigmay') theta = fit.Parameter(g_theta, 'theta') p0 = [offset, A, x0,y0,sigmax,sigmay,theta] def fitfunc(x,y): a = np.cos(theta())**2/(2*sigmax()**2) + np.sin(theta())**2/(2*sigmay()**2) b = -np.sin(2*theta())/(4*sigmax()**2) + np.sin(2*theta())/(4*sigmay()**2) c = np.sin(theta())**2/(2*sigmax()**2) + np.cos(theta())**2/(2*sigmay()**2) z = offset()+A()*np.exp( - (a*(x-x0())**2 - 2*b*(x-x0())*(y-y0()) + c*(y-y0())**2)) return z return p0, fitfunc, fitfunc_str
def fit_esr(g_a,g_A1,g_A2,g_x0,g_dx,g_gamma,g_dxN): fitfunc_str = 'a1 + 2*A1/np.pi*gamma1/(4*(x-x01-dx/2-dxN)**2+gamma**2) \ +2*A1/np.pi*gamma1/(4*(x-x01-dx/2)**2+gamma**2) \ 2*A1/np.pi*gamma1/(4*(x-x01-dx/2+dxN)**2+gamma**2) \ 2*A2/np.pi*gamma1/(4*(x-x01+dx/2-dxN)**2+gamma**2) \ 2*A2/np.pi*gamma1/(4*(x-x01+dx/2)**2+gamma**2) \ 2*A2/np.pi*gamma1/(4*(x-x01+dx/2+dxN)**2+gamma**2) ' a = fit.Parameter(g_a, 'a') A1 = fit.Parameter(g_A1, 'A1') A2 = fit.Parameter(g_A2, 'A2') x0 = fit.Parameter(g_x0, 'x0') dx = fit.Parameter(g_dx, 'dx') gamma = fit.Parameter(g_gamma, 'gamma') dxN = fit.Parameter(g_dxN, 'dxN') p0 = [a, A1, A2, x0, dx, gamma, dxN] def fitfunc(x): return a()+2*A1()/np.pi*gamma()/(4*(x-x0()-dx()/2-dxN())**2+gamma()**2)+\ 2*A1()/np.pi*gamma()/(4*(x-x0()-dx()/2)**2+gamma()**2)+\ 2*A1()/np.pi*gamma()/(4*(x-x0()-dx()/2+dxN())**2+gamma()**2)+\ 2*A2()/np.pi*gamma()/(4*(x-x0()+dx()/2-dxN())**2+gamma()**2)+\ 2*A2()/np.pi*gamma()/(4*(x-x0()+dx()/2)**2+gamma()**2)+\ 2*A2()/np.pi*gamma()/(4*(x-x0()+dx()/2+dxN())**2+gamma()**2) return p0, fitfunc, fitfunc_str