def main(): with open('../Data/calibration.txt') as f: #calibration readings file x0 = [ 0, 0, 0, 1, 1, 1, 0, 0, 0 ] #% Structure of vector: x0 = [ALFAxy, ALFAzx, ALFAzy, Sx, Sy, Sz, bx, by, bz] accelData = [] for row in f: vector = row.split(',') vector[0] = float(vector[0]) vector[1] = float(vector[1]) vector[2] = float(vector[2]) accelData.append(vector) x = opt((lambda x: minimize(x, accelData)), x0, method='BFGS').x N = [[1, 0, 0], [x[0], 1, 0], [x[1], x[2], 1]] S = [[x[3], 0, 0], [0, x[4], 0], [0, 0, x[5]]] b = [x[6], x[7], x[8]] print("\nN =\n" + str(np.array(N))) print("\nS =\n" + str(np.array(S))) print("\nb = " + str(np.array(b))) print("\nRMSE before calibration: " + '{:5f}'.format(rmse(accelData) * gval) + " m/s^2") print("RMSE after calibration: " + '{:5f}'.format(rmse(correction(accelData, N, S, b)) * gval) + " m/s^2")
def _optimization(self, max_scf=100, log=True, scf=True, readguess=None, argnum=[0], taskname='Output', method='BFGS', penalize=None, **otherargs): print readguess print max_scf if self.verbose: t0 = time.clock() self._print_head_optimization(taskname, max_scf, readguess, **otherargs) name = taskname rguess = None ### If initial guess if readguess: pguess = name + '.npy' out = False ene = self._singlepoint(max_scf, max_d, printcoef=pguess, name=name, output=False) if ene == 99999: raise NameError('SCF did not converved') rguess = pguess pguess = None record = False args = self._energy_args(max_scf=max_scf, max_d=max_scf, log=log, printguess=pguess, readguess=rguess, name=name, write=record) ene_function = rhfenergy grad_fun = function_grads_algopy( ene_function, argnum) ## This defines de gradient function of autograd opt = self.select_method.get( method, lambda: self._BFGS) ## This selects the opt method res = opt(ene_function, grad_fun, args, argnum, log, name, **otherargs) if self.verbose: timer = time.clock() - t0 self._print_tail_optimization(res, timer) self.status = bool(res.status == 0 or res.status == 1) self._optupdateparam(argnum, res.x) return res, timer
def data_fit(spectre): mu1 = np.argmax(spectre[0:int(np.argmax(spectre) * 0.9)]) mu2 = int(np.argmax(spectre) * 1.2) + np.argmax( spectre[int(np.argmax(spectre) * 1.1):len(spectre) - 1]) if spectre[mu1] > spectre[mu2]: pars = [ np.max(spectre) * 5., 1., 1., np.argmax(spectre) * 1., 0.1, spectre[mu1] * 5., 1., 1., mu1 * 1. ] else: pars = [ np.max(spectre) * 5., 1., 1., np.argmax(spectre) * 1., 0.1, spectre[mu2] * 5., 1., 1., mu2 * 1. ] print('') print('Parameters acquisition...') print('') out = opt(errfunc_voigt, pars, args=(np.arange(len(spectre)), spectre))[0] out1 = out[0:4].tolist() out2 = out[5:].tolist() dist = int((abs(out2[3] - out1[3]) / 2.) * 0.8) print('') print('Plotting spectre...') print('') plt.figure(100) plt.plot(spectre) plt.plot(V(np.arange(len(spectre)), *out1) + out[4]) plt.plot(V(np.arange(len(spectre)), *out2) + out[4]) plt.plot(Vbis(np.arange(len(spectre)), *out)) integral1 = sum(spectre[int(out1[3] - dist) + 1:int(out1[3] + dist)]) + ( spectre[int(out1[3]) - dist] + spectre[int(out1[3]) + dist]) * 0.5 integral2 = sum(spectre[int(out2[3] - dist) + 1:int(out2[3] + dist)]) + ( spectre[int(out2[3]) - dist] + spectre[int(out2[3]) + dist]) * 0.5 return (integral1, out[3], integral2, out2[3])
def get_m_exponent(m, Tc, start_temp, end_temp, num_temp): """ Takes in Cv array and underlying temps params and returns critical exponent and error """ # temps temps = linspace(start_temp, end_temp, num=num_temp) # trim the function to only T < Tc crit_temp_idx = argmin(abs(temps - Tc)) m_trimmed = m[:crit_temp_idx] temps_trimmed = temps[:crit_temp_idx] # fit the function m_best_params, m_cov = opt(lambda t, b, c, d: tc_fit(t, Tc, b, c, d), xdata=temps_trimmed, ydata=m_trimmed, p0=[1 / 8, 0, 0]) # get best params and errors (best_beta, best_c, best_d) = m_best_params err_params = sqrt(diag(m_cov)) best_beta_err = err_params[0] # print out best params estimated with this method print("Estimated critical exponent = {:.3} +/- {:.1}".format( best_beta, best_beta_err)) # make best fit array with best_fit = tc_fit(temps_trimmed, Tc, best_beta, best_c, best_d) # plot results fig = plt.figure(figsize=(16, 8)) plt.title("Magnetization fit with " + "$(T_c - T)^{beta}$" + " and $beta =$ {:.3} $+/-$ {:.1}".format( abs(best_beta), best_beta_err)) plt.scatter(temps_trimmed, m_trimmed, c='k') plt.plot(temps_trimmed, best_fit, c='darkcyan', label="Best fit") plt.ylabel("Magnetization") plt.xlabel("Temperature in units of $J/k_b$") plt.legend() plt.show() return best_beta, best_beta_err, best_fit
def refine(self, idx, fun=None, yvec=None): """use quadratic interpolation to locate a fine maximum of the peak position and value Arguments: idx: index of the peak to interpolate """ pos = self._idx[idx] if yvec is not None: y = yvec else: y = self.y if fun: from scipy.optimize import broyden1 as opt # val = fun(self.val[idx]) sur = fun(y[pos-1:pos+2]) else: # val = self.val[idx] sur = y[pos-1:pos+2] if sur[1] > sur[0] and sur[1] >= sur[2]: c = sur[1] b = (sur[2] - sur[0])/2 a = (sur[2] + sur[0])/2 - c lpos = - b/2/a fpos = float(pos) + lpos if fun: ival = a*lpos*lpos + b*lpos + c # print "rpos = %d; rf(val) = %f; f(val) = %f; dpos = %f;"%(pos, sur[1], ival, lpos) fval = opt(lambda x: fun(x)-ival, self.val[idx]/2) else: fval = a*lpos*lpos + b*lpos + c # print "rpos = %d; rval = %f; val = %f; dpos = %f; pos = %f"%(pos, sur[1], fval, lpos, fpos) else: fpos = pos fval = sur[1] return np.interp(fpos, np.arange(len(self.x)), self.x), fval.tolist()
def refine(self, idx, fun=None, xvec=None): """use quadratic interpolation to locate a fine maximum of the peak position and value Arguments: idx: index of the peak to interpolate """ pos = self.pos[idx] if xvec is not None: x = xvec else: x = self.x if fun: from scipy.optimize import broyden1 as opt #val = fun(self.val[idx]) sur = fun(x[pos - 1:pos + 2]) else: #val = self.val[idx] sur = x[pos - 1:pos + 2] if sur[1] > sur[0] and sur[1] > sur[2]: c = sur[1] b = (sur[2] - sur[0]) / 2 a = (sur[2] + sur[0]) / 2 - c lpos = -b / 2 / a fpos = float(pos) + lpos if fun: ival = a * lpos * lpos + b * lpos + c #print "rpos = %d; rf(val) = %f; f(val) = %f; dpos = %f;"%(pos,sur[1],ival, lpos) fval = opt(lambda x: fun(x) - ival, self.val[idx] / 2) else: fval = a * lpos * lpos + b * lpos + c #print "rpos = %d; rval = %f; val = %f; dpos = %f; pos = %f"%(pos,sur[1],fval, lpos, fpos) else: fpos = pos fval = sur[1] return fpos, fval.tolist()
def fitLeastSq(fn, p0, xs, ys, yerrs=None, log_fit=0): """ Example fitting a parabola: fn = lambda p,xs: p[0]+p[1]*xs**2 xs,ys=np.arange(-10,10),fn((1,2),xs) plt.plot(xs,ys,lw=3) pars = fitLeastSq(fn,[15,2],xs,ys) plt.plot(xs,fn(pars,xs),'r--',lw=3)""" if yerrs is not None: if log_fit: fit_func = lambda p: np.log10(ys) - np.log10(fn(p, xs)) else: fit_func = lambda p: (ys - fn(p, xs)) / yerrs else: if log_fit: fit_func = lambda p: np.log10(ys) - np.log10(fn(p, xs)) else: fit_func = lambda p: (ys - fn(p, xs)) pars, res = opt(fit_func, p0) return pars
def get_cv_exponent(Cv, Tc, start_temp, end_temp, num_temp): """ Takes in Cv array and underlying temps params and returns critical exponent and error """ # temps temps = linspace(start_temp, end_temp, num=num_temp) # fit the function # split it in two cv_best_params, cv_cov = opt(lambda t, a, c: tc_fit_abs(t, Tc, a, c), xdata=temps, ydata=Cv, p0=[0.1, 0]) # get best params and errors (best_alpha, best_c) = cv_best_params err_params = sqrt(diag(cv_cov)) best_alpha_err = err_params[0] # print out best params estimated with this method print("Estimated critical exponent = {:.3} +/- {:.1}".format( best_alpha, best_alpha_err)) # make best fit array with best_fit = tc_fit_abs(temps, Tc, best_alpha, best_c) # plot results fig = plt.figure(figsize=(16, 8)) plt.title( "Heat capacity fit with " + "$|T_c - T|^{-alpha}$" + " and $alpha =$ {:.3} $+/-$ {:.1}".format(best_alpha, best_alpha_err)) plt.scatter(temps, Cv, c='k') plt.plot(temps, best_fit, c='darkcyan', label="Best fit") plt.ylabel("Heat capacity") plt.xlabel("Temperature in units of $J/k_b$") plt.legend() plt.show() return best_alpha, best_alpha_err, best_fit
def _optimization(self,max_scf=100,log=True,scf=True,readguess=None,argnum=[0],taskname='Output', method='BFGS',penalize=None,**otherargs): name=taskname record = False maxsteps = 100 rhf_old = 1000 grad_fun = [] lbda = 1.0 rguess = None if readguess: pguess = name +'.npy' out = False ene = self._singlepoint(maxsteps,maxsteps,pguess,name,False) if ene == 99999: raise NameError('SCF did not converved') rguess= pguess if self.verbose: self.tape.write(' \n Optimization ...\n') self.tape.write(' ---Start--- \n') self._optprintparam(max_scf,rguess) ene_function = rhfenergy pguess = None record = False args=[np.log(self.sys.alpha),self.sys.coef,self.sys.xyz,self.sys.l,self.sys.charges,self.sys.atom,self.sys.natoms,self.sys.nbasis, self.sys.list_contr,self.sys.ne, max_scf,max_scf,log,True,pguess,rguess, name,record,self.sys.alpha] # Last term is only used for Algopy grad_fun = self._algo_gradfun(ene_function,args,argnum) ## This defines de gradient function of autograd opt = self.select_method.get(method,lambda: self._BFGS) ## This selects the opt method t0 = time.clock() res = opt(ene_function,grad_fun,args,argnum,log,name,**otherargs) timer = time.clock()-t0 self._optupdateparam(argnum,res.x) self.status = bool(res.status == 0 or res.status==1) return res,timer
for i in range(len(rho)): rho[i] = l/Ts[i] + (betas/(1 + lambdas*Ts[i])).sum() rho_norm = rho/beta rho_norm_error = np.ones_like(rho_norm) for i in range(len(rho_norm_error)): x = ((betas*lambdas)/((1+lambdas*Ts[i])**2)).sum() x = x*Ts_error[i]/beta x = x + (l*Ts_error[i])/(beta*Ts[i]**2) rho_norm_error[i] = x Text1 = "Fitansatz: " Text1 = Text1 + r"$y = a\cdot\sin^2\left(\frac{\pi\cdot x}{b}\right)$" p_opt,kov = opt(differentieller_Fit,z1/np.amax(z1),rho_norm/np.amax(rho_norm))#,sigma=rho_norm_error) z1_fit = np.linspace(np.amin(z1/np.amax(z1)),np.amax(z1/np.amax(z1)),1000) rho1_fit = differentieller_Fit(z1_fit,*p_opt) x = np.linspace(0,4000) diff1 = differentieller_Fit(x,0.120,5440) int1 = integrate.cumtrapz(diff1, x, initial=0) # kumulierte Intergralwerte #int1 = integrale_Kennlinie(x,0.120,5440) Text2 = r"$a = ($" Text2 = Text2 + "{0:.2f}".format(p_opt[0]) Text2 = Text2 + r"$\pm$" Text2 = Text2 + "{0:.2f}".format(np.sqrt(kov[0][0])) Text2 = Text2 + r"$)$" Text3 = r"$b = ($"
random.shuffle(mm) m = mm[0] # m is the index of largest projection axis ####### U construction ####### def unitary(x0): for i in range(m): M[m][i] = x0[i] M[i][m] = -x0[i] for i in range(m + 1, n): M[m][i] = x0[i - 1] M[i][m] = -x0[i - 1] U = LA.expm(M) return U def Energy(x0): U = unitary(x0) dQ = (U - I).dot(P) E = E0 + g0.T.dot(dQ) + 0.5 * dQ.T.dot(H0).dot(dQ) return E ####### optimization ####### res = opt(Energy, x0, approx_grad=1) x = res[0] # optimized parameters Q = unitary(x).dot(P) + C ####### output result ####### print np.reshape(Q, (n / 3, 3))
row_alpha = [] row_beta = [] row_alpha_err = [] row_beta_err = [] for y in range(64): points = (tools.get_points(paths=paths, coords=(x, y), freqs=freqs, directory=pathcore, extension=extension)) frequencies, svalues = zip(*points) svalues = np.array(svalues) try: popt, pcov = opt(tools.lit_fit, frequencies, svalues, p0=[2800, 30e-6], bounds=([1e-8, 1e-8], [np.inf, np.inf]), method='trf') perr = np.sqrt(np.diag(pcov)) row_alpha.append(popt[1]) row_beta.append(popt[0]) row_alpha_err.append(perr[1]) row_beta_err.append(perr[0]) except: row_alpha.append(0) row_beta.append(0) row_alpha_err.append(0) row_beta_err.append(0) z_alpha.append(row_alpha) z_beta.append(row_beta) z_alpha_err.append(row_alpha_err)
Q=np.empty((n,3)) sample=open('GeomO','r') for i in range(n): line=sample.readline() word=line.split() Q[i,0]=float(word[2]) Q[i,1]=float(word[3]) Q[i,2]=float(word[4]) sample.close() # reading geometry def Energy(Q): f=open('Geom_tmp','w') f.write(str(np.reshape(Q,(n,3)))) f.close() result=os.popen('Cal_Energy.sh','r') E=result.read() if (len(E)!=0): E=float(E) f=open('Geom_app','a') f.write('\n\n'+str(np.reshape(Q,(n,3)))) f.write('\n\n'+str(E)) f.close() return E else: return 0 res=opt(Energy,Q,approx_grad=1) x=res[0] #optimized parameters print np.reshape(x,(n,3)) print Energy(x)
def data_analisys(file): f = h5py.File(file, 'r') max_y = 0 max_x = 0 events = f['Events'] for label in np.arange(len(events)): mix = np.max(events[str(label + 1)]['spots_x'][...]) if max_x < mix: max_x = mix miy = np.max(events[str(label + 1)]['spots_y'][...]) if max_y < miy: max_y = miy [max_y, max_x] = [max_y + 1, max_x + 1] tot_img = np.zeros([max_y, max_x]) print('') print('Creating total image...') print('') xcms = [] ycms = [] for label in np.arange(len(events)): xs = events[str(label + 1)]['spots_x'][...] ys = events[str(label + 1)]['spots_y'][...] zs = events[str(label + 1)]['spots_z'][...] max_val = np.max(zs) k = np.log(max_val) / max_val pounds = np.exp(zs * k) xcms.append(sum(pounds * xs) / sum(pounds)) ycms.append(sum(pounds * ys) / sum(pounds)) for ind in np.arange(len(xs)): tot_img[ys[ind], xs[ind]] += zs[ind] print('') print('Shifting data...') print('') [py, px] = np.unravel_index(tot_img.argmax(), [max_y, max_x]) pars = [py, 0., 0.] maxs = [] for col in np.arange(max_x): maxs.append(np.argmax(tot_img[:, col])) out = opt(errfunc, pars, args=(np.arange(len(maxs)), maxs))[0] truemaxs = [] trueargs = [] for col in np.arange(len(maxs)): if (maxs[col] - parabola(col, *out))**2 / parabola(col, *out) < 1.: truemaxs.append(maxs[col]) trueargs.append(col) out = opt(errfunc, pars, args=(np.asarray(trueargs) * 1.0, np.asarray(truemaxs) * 1.0))[0] x_0_pol = parabola(np.arange(max_x), *out) shift_0 = max(x_0_pol) shape_row = max_y + int(max(x_0_pol)) - int(min(x_0_pol)) print('') print('Creating spectrum...') print('') spectre = np.zeros(shape_row) for label in np.arange(len(xcms)): delta = shift_0 - parabola(xcms[label], *out) spectre[int(round(ycms[label] + delta))] += 1 return (spectre)