def fitLorentz(self, x, y): if x[0] / 1e9 > 1: raise 'I hate the large number, please divided by 1e9, processing x in GHz' para = self.guessLorentz(x, y) res = ls(self.errLorentz, para, args=(x, y)) a, b, c, d = res.x return a, b, c, d, np.sqrt(np.abs(1 / c)) * 2e3, res
def fitCos(self, volt, s): x, y = volt, s if x[0] / 1e9 > 1: raise 'I hate the large number, please divided by 1e9, processing x in GHz' Ag, Cg, Wg, phig = self.guessCos(x, y) print(Ag, Cg, Wg, phig) res = ls(self.errCos, [Ag, Cg, Wg, phig], args=(x, y)) A, C, W, phi = res.x return A, C, W, phi
def estimate_pose(self, X_gcp, u_gcp, p): """ This function adjusts the pose vector such that the difference between the observed pixel coordinates u_gcp and the projected pixels coordinates of X_gcp is minimized. """ p_opt = ls(self.residual, p, method='lm', args=(X_gcp, u_gcp))['x'] return p_opt
def circleLeastFit(x, y): def circle_err(params, x, y): xc, yc, R = params return (x - xc)**2 + (y - yc)**2 - R**2 p0 = [ x.mean(), y.mean(), np.sqrt(((x - x.mean())**2 + (y - y.mean())**2).mean()) ] res = ls(circle_err, p0, args=(x, y)) return res.x
def find_accuracy(true_labels, pred_labels): # Implement. # Return a number corresponding to the accuracy of the two sets of labels. m = len(true_labels) matrix = build_matrix(true_labels, pred_labels) cluster_num, class_num = matrix.shape rows, cols = ls(-1 * matrix) correct = 0 for row, col in zip(rows, cols): correct += matrix[row][col] return correct / m
def optimize(vector, beta_ideal, n_steps, precision, opt_type): print('Start optimization') arg = read_twiss('twiss.txt', SP2) beat_initial = (np.array(arg[0]) - np.array(beta_ideal)) / np.array(beta_ideal) arg += (beat_initial, ) if opt_type == 0: metric0 = np.std(beat_initial) print('Start from metric {}'.format(metric0)) print('Try to make zero deviation of beta from ideal') vec = ls(first_assumption, vector, args=arg, max_nfev=n_steps, ftol=precision, xtol=precision) else: beat_periodic = np.transpose(np.reshape(beat_initial, (6, 14))) metric0 = np.mean([np.std(b) for b in beat_periodic]) print('Start from metric {}'.format(metric0)) print('Make beta-function periodic again!') vec = ls(metric_counter, vector, args=arg, max_nfev=n_steps, ftol=precision) metric = np.mean(vec.fun) print('Optimum {}found'.format('' if vec.success == True else 'not')) print('Final metric is {}'.format(metric)) print('Optimization rate is {}'.format(metric0 / metric)) set_quads(vec.x, 1, R) return vec.x
def fitRabi(self, x, y): if self.envelopemethod == 'hilbert': out = self.envelope_Hilbert(y) else: out = self.envelope(y) A, B, T1, w, phi = self.guessRabi(x, out, y) amp = (np.max(y) - np.min(y)) / 2 A = A if np.abs(A - amp) < 0.1 * amp else amp B = B if np.abs(B - np.mean(y)) < 0.1 * np.mean(y) else np.mean(y) p0 = A, B, T1, w, self.phi print(p0) res = ls(self.errRabi, p0, args=(np.array(x), np.array(y))) A, B, T1, w, phi = res.x return A, B, T1, w, phi
def fit_eTofts(T10, cp, signal): ''' Implementation of nonlinear-least-square :param T10: :param cp: :param signal: :return: ''' k_trans0 = 0.01 vb0 = 0.02 vo0 = 0.2 x0 = (k_trans0, vb0, vo0) bounds = [(1e-5, 0.0005, 0.04), (0.2, 0.1, 0.6)] result = ls(target_func, x0, bounds=bounds, args=(T10, cp, signal)) return result.x
def find_opt_h(x_list, eps): N = len(x_list) X = x_list shift = min(X) X_shifted = [x - shift for x in X] scale = 1 / max(X_shifted) X_shifted_scale = [x * scale for x in X_shifted] sigma = stdev(X_shifted_scale) phi6 = (-15 / (16 * math.sqrt(math.pi))) * math.pow(sigma, -7) phi8 = (105 / (32 * math.sqrt(math.pi))) * math.pow(sigma, -9) g1 = (-6 / (math.sqrt(2 * math.pi) * phi6 * N))**(1 / 7) g2 = (30 / (math.sqrt(2 * math.pi) * phi8 * N))**(1 / 9) D4 = FUDD(N, N, X_shifted_scale, X_shifted_scale, g1, 4, eps) D4.evaluate() phi4 = sum(D4.pD) / (N - 1) D6 = FUDD(N, N, X_shifted_scale, X_shifted_scale, g2, 6, eps) D6.evaluate() phi6 = sum(D6.pD) / (N - 1) constant1 = (1 / (2 * math.sqrt(math.pi) * N))**(1 / 5) constant2 = (-6 * math.sqrt(2) * phi4 / phi6)**(1 / 7) h_initial = constant1 * phi4**(-1 / 5) h = ls( fast_h_fun, h_initial, bounds=(0, np.inf), ftol=1e-14, xtol=1e-14, verbose=1, args=(N, X_shifted_scale, constant1, constant2, eps), ) h = float(h.x) / scale print(h) sortX = sorted(X_shifted_scale) D0 = FUDD(N, N, sortX, sortX, h, 0, eps) D0.evaluate() return h, D0.pD
def find_accuracy(true_labels, pred_labels): # Implement. # Return a number corresponding to the accuracy of the two sets of labels. m = len(true_labels) matrix = build_matrix(true_labels, pred_labels) cluster_num, class_num = matrix.shape # cluster_sum = matrix.sum(axis=1, dtype=float).reshape((cluster_num,1)) # class_sum = matrix.sum(axis=0, dtype=float).reshape((1,class_num)) # p_matrix = matrix/cluster_sum # probability pij # recall_matrix = matrix/ class_sum # f_matrix = (2 * p_matrix * recall_matrix) /(p_matrix + recall_matrix) rows, cols = ls(-1 * matrix) correct = 0 for row, col in zip(rows, cols): correct += matrix[row][col] return correct / m
def _fair_t1_fit(s0, ti, t1_guess): """ Fit the perfusion FAIR equation: signal = bias + abs(M0 * (1 - 2 * (exp(-TI/T1)))) using scipy.optimize.least_squares (default Trust Region Reflective algorithm). Bias, M0 and T1 are all estimated with a zero lower bound. Starting values for bias (zero) and M0 (mean of input signals) are calculated automatically; T1 has to be supplied, with the mean of TIs being a good guess. Parameters ---------- s0 : numpy array of int or float The aquired signals. ti : list of int or float The inversion times. Must have the same length as s0. t1_guess : int or float An initial starting value for T1. The mean of TIs is a good guess. Returns ------- class scipy.optimize.OptimizeResult Notes ----- Levenberg-Marquardt (method='lm'), the usual literature algorithm, cannot be used here as the implementation in scipy does not accept bounds. From experience with the R MINPACK implementation (minpack.lm function nlsLM), these bounds are necessary to assure good fitting. The lmfit python package does implement bounds for MINPACK Levenberg-Marquardt (method=leastsq; default), though the results appear to be worse than for TRR (method=least_squares), whose results bizarrely look closer to those of R minpack.lm nlsLM (to confirm), and are of course identical to scipy.optimize.least_squares with method='trf' (default). """ return ls(_fair_t1_func, np.array([0, np.mean(s0), t1_guess]), bounds=([0, 0, 0], np.inf), args=(s0, np.array(ti)))
def fitT2(self, x, y): ''' 几个参数的限制范围还需要考究,A,T1,T2 ''' d = self.space(y) if self.envelopemethod == 'hilbert': out = self.envelope_Hilbert(y) else: out = self.envelope(y) A, B, T1, T2, w, phi = self.guessT2(x, out, y) if T2 > 0.8 * x[d - 1] and d < 0.8 * len(y): T2 = 0.37 * x[d - 1] amp = (np.max(y) - np.min(y)) / 2 A = A if np.abs(A - amp) < 0.1 * amp else amp p0 = A, B, T1, T2, w, self.phi print(p0) res = ls(self.errT2, p0, args=(x, y)) A, B, T1, T2, w, phi = res.x return A, B, T1, T2, w, phi
def simple_fit(objective_func, guess_params, xdata, ydata, verbose=True, bounds=(-np.inf, np.inf)): """ Wrapper for SciPy's scipy.optimize.least_squares Parameters ---------- objective_func : function function to fit to with syntax of f(x, p1, p2, ...,) or f(x, params) guess_params : array_like with shape (n,) Initial guess on independent variables. xdata : array_like with shape (m,) Independent data. ydata : array_like with shape (m,) Dependent data. verbose : bool, optional Toggle printing of fitting time, cost, and parameters. The default is True. bounds : 2-tuple of array_like, optional Lower and upper bounds on independent variables. Defaults to no bounds. Each array must match the size of guess_params or be a scalar, in the latter case a bound will be the same for all variables. Use np.inf with an appropriate sign to disable bounds on all or some variables. The default is (-np.inf, np.inf). Returns ------- params : array_like with shape (n,) """ def cost_func(params): # simple, linear cost function. # One can make more nuanced cost functions if needed. cost = ydata - objective_func(xdata, params) return cost t0 = time.time() out = ls(cost_func, guess_params, bounds=bounds) t1 = time.time() if verbose: print('Fit done in {0} s with cost of {1}.'.format(str(round(t1-t0,2)), str(out.cost))) print(out.x) return out.x
def gaussNewton(f, df, jac, r, x, niter=10): """Solve a nonlinear least squares problem with Gauss-Newton method. Parameters: f (function): The objective function. df (function): The gradient of f. jac (function): The jacobian of the residual vector. r (function): The residual vector. x (ndarray of shape (n,)): The initial point. niter (int): The number of iterations. Returns: (ndarray of shape (n,)) The minimizer. """ for i in xrange(niter): try: p = la.solve(np.dot(jac(x).T, jac(x)), np.dot(-jac(x).T, r(x))) a = ls(f, df, x, p)[0] x = x + a * p except: true return x
def fit(x, s, params=None, with_delay=False, with_high_order=False): def err(params, f, s21, with_delay=with_delay, with_high_order=with_high_order): f0, Qi, Qe, phi, A, Aphi, delay, a, b = params background = A * (with_high_order * (a * (f - f0)**2 + b * (f - f0)) + 1) * np.exp(1j * (with_delay * delay * (f - f0) + Aphi)) y = 1 / s21 - invS21(f, f0, Qi, Qe, phi) / background return np.abs(y) if params is None: f0, Qi, Qe, QL, phi, A, Aphi, delay, a, b = guessParams(x, s) else: f0, Qi, Qe, QL, phi, A, Aphi, delay, a, b = params res = ls(err, [f0, Qi, Qe, phi, A, Aphi, delay, a, b], args=(x, s)) f0, Qi, Qe, phi, A, Aphi, delay, a, b = res.x QL = 1 / (1 / Qi + 1 / Qe) return f0, Qi, Qe, QL, phi, A, Aphi, delay, a, b
def fitSpec2d(self,v,f,s=None,classify=False): if s is not None: v,f = self.profile(v,f,s,classify) paras, func = self.fitCos(v,f) A, C, W, phi = paras.x voffset, vperiod, ec, d = self.firstMax(v,f,num=0), 1/W, 0.2, 0 ejs = (np.max(f)+ec)**2/8/ec p0 = [voffset, vperiod,ejs,ec,d] while 1: # print(p0) mybounds = MyBounds(xmin=[0.5*voffset,0,0,0,0],xmax=[1.5*voffset,1.5*vperiod,2*ejs,2*ec,10]) res = bh(self.err,p0,niter = 200,minimizer_kwargs={"method":"Nelder-Mead","args":(v, f)},accept_test=mybounds) res = ls(self.err,res.x,args=(v, f)) voffset, vperiod, ejs, ec, d = res.x space = self.errspace(self.f01,res.x,{'x':v,'y':f}) if np.max(space) > 0.001: v = v[space<0.001] f = f[space<0.001] p0 = res.x # print(len(v),(space<0.001)) else: return f, v, voffset, vperiod, ejs, ec, d
def _get_opt_h(x_list, eps): N = len(x_list) X_shifted_scale, scale = _get_scale_list(x_list) sigma = std(X_shifted_scale) phi6 = (-15 / (16 * sqrt(pi))) * power(sigma, -7) phi8 = (105 / (32 * sqrt(pi))) * power(sigma, -9) g1 = (-6 / (sqrt(2 * pi) * phi6 * N))**(1 / 7) g2 = (30 / (sqrt(2 * pi) * phi8 * N))**(1 / 9) D4 = FUDD(N, N, X_shifted_scale, X_shifted_scale, g1, 4, eps) D6 = FUDD(N, N, X_shifted_scale, X_shifted_scale, g2, 6, eps) D4.evaluate() D6.evaluate() phi4 = sum(D4.pD) / (N - 1) phi6 = sum(D6.pD) / (N - 1) constant1 = (1 / (2 * sqrt(pi) * N))**(1 / 5) constant2 = (-6 * sqrt(2) * phi4 / phi6)**(1 / 7) h_initial = constant1 * phi4**(-1 / 5) h = ls( _fast_h_fun, h_initial, bounds=(0, inf), ftol=1e-14, xtol=1e-14, verbose=0, args=(N, X_shifted_scale, constant1, constant2, eps), ) h = float(h.x) / scale return h
def fitExp(self, x, s): y = np.abs(s) p0 = self.guessExp(x, y) res = ls(self.errExp, p0, args=(x, y)) return res.x
betaxbpm, betaybpm = read_twiss('twiss.txt', SP2) metric_x = (np.array(measured_x / np.mean(measured_x)) - np.array(betaxbpm / np.mean(betaxbpm))) metric_y = (np.array(measured_y / np.mean(measured_y)) - np.array(betaybpm / np.mean(betaybpm))) # metric_orb = [np.std(orbit_x),np.std(orbit_y)] print("metric is {}".format(np.mean(metric_x) + np.mean(metric_y))) return list(metric_x) + list(metric_y) # return list(metric_x)+list(metric_y)+metric_orb ls(metric_counter, theta0) #metric_counter(theta0) SP2 = 48 # header of twiss file betaxbpm, betaybpm = read_twiss('twiss.txt', SP2) plt.figure() plt.plot(betaxbpm / np.mean(betaxbpm), color="red", ls="--") plt.plot(measured_x / np.mean(measured_x), marker="^", color="red") plt.plot(betaybpm / np.mean(betaybpm), color="blue", ls="--") plt.plot(measured_y / np.mean(measured_y), marker="^", color="blue") plt.grid(True)
def _get_array_bounds(kernel, low_bound, high_bound): low = ls(_ls_get_value, 0, args=(kernel, low_bound)) high = ls(_ls_get_value, 0, args=(kernel, high_bound)) return float(low.x), float(high.x)
phi4 = sum(D4.pD) / (N - 1) D6 = FUDD(N, N, X_shifted_scale, X_shifted_scale, g2, 6, eps) D6.evaluate() phi6 = sum(D6.pD) / (N - 1) constant1 = (1 / (2 * math.sqrt(math.pi) * N))**(1 / 5) constant2 = (-6 * math.sqrt(2) * phi4 / phi6)**(1 / 7) h_initial = constant1 * phi4**(-1 / 5) h = ls( fast_h_fun, h_initial, bounds=(0, np.inf), ftol=1e-14, xtol=1e-14, verbose=2, args=(N, X_shifted_scale, constant1, constant2, eps), ) h = float(h.x) / scale print(f"BANDWIDTH (h): {h:.5f}") inf = float("inf") fim = [] for i in range(0, len(X_shifted_scale) - 36, 1): fim.append(ker(X[i + 36], X[i:i + 36], h) / 36) plt.plot(fim) plt.show()
# misfit equation def pers(var_m, x_inp, y): return forward(var_m, x_inp) - y # initial model x0 = 20 # m alpha = 300 * (np.pi / 180) h = 40 # m K = 94500 m0 = np.array([x0, alpha, h, K]) # Levenberg Marquardt (LM) algorithm # Ref: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.least_squares.html result = ls(pers, m0, method='lm', args=(position, SPData_syntethic)) x0 = result.x[0] alpha = result.x[1] h = result.x[2] K = result.x[3] m = np.array([x0, alpha, h, K]) SPData_calculation = forward(m, position) # real data without noise x0_real = 77.07 # m alpha_real = 309.37 * (np.pi / 180) h_real = 41.81 # m K_real = 94686 m_real = np.array([x0_real, alpha_real, h_real, K_real]) SPData_real = forward(m_real, position)
def plot_gradients(source_param, jet_param): d43 = get_data(43, source_param) d15 = get_data(15, source_param) fitfunc = lambda p, x: p[0] + p[1] * x errfunc = lambda p, x, y, err: (y - fitfunc(p, x)) / err if jet_param == 'l': x43 = d43[0] y43 = d43[1] x15 = d15[0] y15 = d15[1] pinit = [1.0, 1.0] mask15 = np.where(x15 <= np.max(x43))[0] mask43 = np.where(x43 >= np.min(x15))[0] err43 = d43[5] err15 = d15[5] jp = 'l' ylab = r'$d_j/\mathrm{mas}$' xlab = r'$d_c/\mathrm{mas}$' if jet_param == 's': x43 = d43[0] y43 = d43[2] x15 = d15[0] y15 = d15[2] pinit = [1.0, -1.0] mask15 = np.where(x15 <= np.max(x43))[0] mask43 = np.where(x43 >= np.min(x15))[0] err43 = d43[4] err15 = d15[4] jp = 's' ylab = r'$t_b/\mathrm{K}$' xlab = r'$d_c/\mathrm{mas}$' if jet_param == 'sd': x43 = d43[1] y43 = d43[2] x15 = d15[1] y15 = d15[2] pinit = [1.0, -1.0] mask15 = np.where(x15 <= np.max(x43))[0] mask43 = np.where(x43 >= np.min(x15))[0] err43 = d43[4] err15 = d15[4] jp = r'$s_d$' ylab = r'$t_b/\mathrm{K}$' xlab = r'$d_j/\mathrm{mas}$' epoch15 = d15[3] epoch43 = d43[3] #fit 15 logx15 = np.log10(x15) logy15 = np.log10(y15) logyerr15 = err15 / y15 out15 = ls(errfunc, pinit, args=(logx15, logy15, logyerr15), loss='cauchy', verbose=0) pfinal15 = out15.x index15 = pfinal15[1] amp15 = 10.0**pfinal15[0] x0_15 = np.linspace(np.min(x15), np.max(x15), x15.shape[0]) residual15 = np.log10(y15) - np.log10(amp15 * x15**index15) #rel_residual15 = (np.log10(y15)-np.log10(amp15*x15**index15))/(np.log10(y15)+np.log10(amp15*x15**index15)) residual_stderror15 = np.sqrt(np.sum(residual15**2) / x15.shape[0]) chi_temp15 = np.sum( Dchisquared(logy15, np.log10(amp15 * x15**index15), logyerr15)) chisq_red15 = chi_temp15 / (x15.shape[0] - 2) #(out15.nfev-3) error15 = np.sqrt(np.sum(residual15**2) / x15.shape[0]) # * chisq_red15) error15_slope = error15 fit15 = amp15 * x0_15**index15 amp15_p = 10.0**(pfinal15[0] + 2 * error15) amp15_m = 10.0**(pfinal15[0] - 2 * error15) schlauch15_p = amp15_p * x0_15**(index15) schlauch15_m = amp15_m * x0_15**(index15) fit15_p = amp15 * x0_15**(index15 + error15_slope) fit15_m = amp15 * x0_15**(index15 - error15_slope) #fit 15overlap logx15_ol = np.log10(x15[mask15]) logy15_ol = np.log10(y15[mask15]) logyerr15_ol = err15[mask15] / y15[mask15] out15_ol = ls(errfunc, pinit, args=(logx15_ol, logy15_ol, logyerr15_ol), loss='cauchy', verbose=0) pfinal15_ol = out15_ol.x index15_ol = pfinal15_ol[1] amp15_ol = 10.0**pfinal15_ol[0] x0_15_ol = np.linspace(np.min(x15[mask15]), np.max(x15[mask15]), x15[mask15].shape[0]) residual15_ol = np.log10(y15[mask15]) - np.log10( amp15_ol * x15[mask15]**index15_ol) residual_stderror15_ol = np.sqrt( np.sum(residual15_ol**2) / x15[mask15].shape[0]) chi_temp15_ol = np.sum( Dchisquared(logy15_ol, np.log10(amp15_ol * x15[mask15]**index15_ol), logyerr15_ol)) chisq_red15_ol = chi_temp15_ol / (x15[mask15].shape[0] - 2 ) #(out15_ol.nfev-3) error15_ol = np.sqrt(np.sum(residual15_ol**2) / x15[mask15].shape[0]) # * chisq_red15_ol) error15_slope_ol = error15_ol fit15_ol = amp15_ol * x0_15_ol**index15_ol fit15_ol_p = amp15_ol * x0_15_ol**(index15_ol + error15_ol) fit15_ol_m = amp15_ol * x0_15_ol**(index15_ol - error15_ol) #fit 43 logx43 = np.log10(x43) logy43 = np.log10(y43) logyerr43 = err43 / y43 out43 = ls(errfunc, pinit, args=(logx43, logy43, logyerr43), loss='cauchy', verbose=0) pfinal43 = out43.x index43 = pfinal43[1] amp43 = 10.0**pfinal43[0] x0_43 = np.linspace(np.min(x43), np.max(x43), x43.shape[0]) residual43 = np.log10(y43) - np.log10(amp43 * x43**index43) #rel_residual43 = (np.log10(y43)-np.log10(amp43*x43**index43))/(np.log10(y43)+np.log10(amp43*x43**index43)) residual_stderror43 = np.sqrt(np.sum(residual43**2) / x43.shape[0]) chi_temp43 = np.sum( Dchisquared(logy43, np.log10(amp43 * x43**index43), logyerr43)) chisq_red43 = chi_temp43 / (x43.shape[0] - 2) #(out43.nfev-3) error43 = np.sqrt(np.sum(residual43**2) / x43.shape[0]) # * chisq_red43) error43_slope = error43 fit43 = amp43 * x0_43**index43 fit43_p = amp43 * x0_43**(index43 + error43_slope) fit43_m = amp43 * x0_43**(index43 - error43_slope) amp43_p = 10.0**(pfinal43[0] + 2 * error43) amp43_m = 10.0**(pfinal43[0] - 2 * error43) schlauch43_p = amp43_p * x0_43**(index43) schlauch43_m = amp43_m * x0_43**(index43) #fit 43 overlap logx43_ol = np.log10(x43[mask43]) logy43_ol = np.log10(y43[mask43]) logyerr43_ol = err43[mask43] / y43[mask43] out43_ol = ls(errfunc, pinit, args=(logx43_ol, logy43_ol, logyerr43_ol), loss='cauchy', verbose=0) pfinal43_ol = out43_ol.x index43_ol = pfinal43_ol[1] amp43_ol = 10.0**pfinal43_ol[0] x0_43_ol = np.linspace(np.min(x43[mask43]), np.max(x43[mask43]), x43[mask43].shape[0]) residual43_ol = np.log10(y43[mask43]) - np.log10( amp43_ol * x43[mask43]**index43_ol) residual_stderror43_ol = np.sqrt( np.sum(residual43_ol**2) / x43[mask43].shape[0]) chi_temp43_ol = np.sum( Dchisquared(logy43_ol, np.log10(amp43_ol * x43[mask43]**index43_ol), logyerr43_ol)) chisq_red43_ol = chi_temp43_ol / (x43[mask43].shape[0] - 2 ) #(out43_ol.nfev-3) error43_ol = np.sqrt(np.sum(residual43_ol**2) / x43[mask43].shape[0]) # * chisq_red43_ol error43_slope_ol = error43_ol fit43_ol = amp43_ol * x0_43_ol**index43_ol fit43_ol_p = amp43_ol * x0_43_ol**(index43_ol + error43_ol) fit43_ol_m = amp43_ol * x0_43_ol**(index43_ol - error43_ol) label0_43 = str( Name[source_param]) + ', ' + str(43) + ' GHz' + ', ' + 'DOF: ' + str( x43.shape[0]) + ', ' + 'Epochs: ' + str( np.unique(d43[3]).shape[0]) + ', ' label1_43 = jp + ' =' + str(np.round(index43, 2)) + str(r'$\pm$') + str( np.round(error43_slope, 2)) + ', ' + r'$\chi ^2 $=' + str( np.round(chi_temp43, 3)) + ', ' + r'$\chi ^2 _{red}$=' + str( np.round(chisq_red43, 3)) label2_43 = jp + r'$_{overlap} =$' + str( np.round(index43_ol, 2)) + str(r'$\pm$') + str( np.round(error43_slope_ol, 2)) + ', ' + r'$\chi ^2 $=' + str( np.round(chi_temp43_ol, 3)) + ', ' + r'$\chi ^2 _{red}$=' + str( np.round(chisq_red43_ol, 3)) label0_15 = str( Name[source_param]) + ', ' + str(15) + ' GHz' + ', ' + 'DOF: ' + str( x15.shape[0]) + ', ' + 'Epochs: ' + str( np.unique(d15[3]).shape[0]) + ', ' label1_15 = jp + ' =' + str(np.round(index15, 2)) + str(r'$\pm$') + str( np.round(error15_slope, 2)) + ', ' + r'$\chi ^2$=' + str( np.round(chi_temp15, 3)) + ', ' + r'$\chi ^2 _{red}$=' + str( np.round(chisq_red15, 3)) label2_15 = jp + r'$_{overlap} =$' + str( np.round(index15_ol, 2)) + str(r'$\pm$') + str( np.round(error15_slope_ol, 2)) + ', ' + r'$\chi ^2$=' + str( np.round(chi_temp15_ol, 3)) + ', ' + r'$\chi ^2 _{red}$=' + str( np.round(chisq_red15_ol, 3)) fig, axs = plt.subplots(2, 2, sharex=True) axs[0, 0].axvspan(np.min(x43[mask43]), np.max(x43), alpha=0.5, color='grey', label='overlap region') ## plot 43 l and fit #axs[0,0].errorbar(x43,y43,yerr=err*y43,linewidth=0,elinewidth=0.2,marker='+',c='B',markersize=0.5,label = label0_43) norm43 = matplotlib.colors.Normalize(vmin=min(epoch43), vmax=max(epoch43), clip=True) mapper43 = cm.ScalarMappable(norm=norm43, cmap='viridis') ep_color43 = np.array([(mapper43.to_rgba(v)) for v in epoch43]) for x, y, e, color in zip(x43, y43, err43, ep_color43): #axs[0,0].plot(x, y, 'o', color=color) axs[0, 0].errorbar(x, y, e, marker='+', elinewidth=0.2, markersize=0.5, color=color) axs[0, 0].loglog(x0_43, fit43, linestyle='--', color='k', linewidth=0.5, label=label0_43 + label1_43) axs[0, 0].loglog(x0_43_ol, fit43_ol, linestyle=':', color='grey', label=label2_43) axs[0, 0].loglog(x0_43, fit43_p, linestyle='--', color='k', linewidth=0.5) axs[0, 0].loglog(x0_43, fit43_m, linestyle='--', color='k', linewidth=0.5) #axs[0,0].loglog(x0_43,schlauch43_p,linestyle=':',color='k',linewidth=0.5) #axs[0,0].loglog(x0_43,schlauch43_m,linestyle=':',color='k',linewidth=0.5) axs[0, 0].fill_between(x0_43, fit43_p, fit43_m, color='gainsboro') #axs[0,0].fill_between(x0_43,schlauch43_p,schlauch43_m,color = 'aquamarine') axs[0, 0].set_xlim(10**(-2), 30) axs[0, 0].set_ylim(np.min(y43) * (1 - 0.1), np.max(y15) + 1) axs[0, 0].set_yscale('log') axs[0, 0].set_xscale('log') axs[0, 0].set_ylabel(ylab) axs[0, 0].legend(loc=2, prop={'size': 3}) ## plot 43 dispersion axs[1, 0].axvspan(np.min(x43[mask43]), np.max(x43), alpha=0.5, color='grey') for x, y, color in zip( x43, Dchisquared(logy43, np.log10(amp43 * x43**index43), logyerr43), ep_color43): #axs[0,0].plot(x, y, 'o', color=color) #axs[1,0].errorbar(x, y, e, marker='+',elinewidth=0.2,markersize=0.5, color=color) axs[1, 0].loglog(x, y, marker='+', linewidth=0, color=color, markersize=2) #axs[1,0].loglog(x43,Dchisquared(logy43,np.log10(amp43*x43**index43),logyerr43),marker='+',linewidth=0,color = 'B',markersize=2) #axs[1,0].set_ylim(-1,1) axs[1, 0].set_xscale('log') axs[1, 0].set_xlim(10**(-2), 30) axs[1, 0].set_ylabel(r'$\Delta \chi ^2$') ##overlapregion 15 axs[0, 1].axvspan(np.min(x15), np.max(x15[mask15]), alpha=0.5, color='grey', label='overlap region') ## plot 15 l and fit #axs[0,1].errorbar(x15,y15,yerr=err*y15,elinewidth=0.2,linewidth=0,marker='+',c='R',markersize=0.5,label = label0_15) norm15 = matplotlib.colors.Normalize(vmin=min(epoch15), vmax=max(epoch15), clip=True) mapper15 = cm.ScalarMappable(norm=norm43, cmap='plasma') ep_color15 = np.array([(mapper15.to_rgba(v)) for v in epoch15]) for x, y, e, color in zip(x15, y15, err15, ep_color15): #axs[0,0].plot(x, y, 'o', color=color) axs[0, 1].errorbar(x, y, e, marker='+', elinewidth=0.2, markersize=0.5, color=color) axs[0, 1].loglog(x0_15, fit15, linestyle='--', color='k', linewidth=0.5, label=label0_15 + label1_15) axs[0, 1].loglog(x0_15_ol, fit15_ol, linestyle=':', color='grey', label=label2_15) axs[0, 1].loglog(x0_15, fit15_p, linestyle='--', color='k', linewidth=0.5) axs[0, 1].loglog(x0_15, fit15_m, linestyle='--', color='k', linewidth=0.5) #axs[0,1].loglog(x0_15,schlauch15_p,linestyle=':',color='k',linewidth=0.5) #axs[0,1].loglog(x0_15,schlauch15_m,linestyle=':',color='k',linewidth=0.5) axs[0, 1].fill_between(x0_15, fit15_p, fit15_m, color='gainsboro') #axs[0,1].fill_between(x0_15,schlauch15_p,schlauch15_m,color = 'lightpink') axs[0, 1].set_xlim(10**(-2), 30) axs[0, 1].yaxis.tick_right() axs[0, 1].set_ylim(np.min(y43) * (1 - 0.1), np.max(y15) + 1) axs[0, 1].legend(loc=2, prop={'size': 3}) axs[0, 0].set_yscale('log') axs[0, 0].set_xscale('log') ## plot 15 dispersion axs[1, 1].axvspan(np.min(x15), np.max(x15[mask15]), alpha=0.5, color='grey') for x, y, color in zip( x15, Dchisquared(logy15, np.log10(amp15 * x15**index15), logyerr15), ep_color15): #axs[0,0].plot(x, y, 'o', color=color) #axs[1,0].errorbar(x, y, e, marker='+',elinewidth=0.2,markersize=0.5, color=color) axs[1, 1].loglog(x, y, marker='+', linewidth=0, color=color, markersize=2) #axs[1,1].loglog(x15,Dchisquared(logy15,np.log10(amp15*x15**index15),logyerr15),marker='+',linewidth=0,color='R',markersize=2) axs[1, 1].set_xscale('log') axs[1, 1].set_xlim(10**(-2), 30) axs[1, 1].yaxis.tick_right() fig.tight_layout() plt.subplots_adjust(hspace=0) plt.subplots_adjust(wspace=0.02) fig.add_subplot(111, frameon=False) plt.tick_params(labelcolor='none', top=False, bottom=False, left=False, right=False) plt.xlabel(xlab) plt.savefig(f'./paper_plots_test/{Name[source_param]}+_{jet_param}.pdf', dpi=500) plt.close() #0 index15,1 amp15,2 error15,3 chisq_red15,4 residual15,5 index43,6 amp43, #7 error43,8 chisq_red43,9 residual43,10 index15_ol,11 amp15_ol,12 error15_ol, #13 chisq_red15_ol,14 residual15_ol,15 index43_ol,16 amp43_ol,17 error43_ol,18 chisq_red43_ol,19 residual43_ol return (index15, amp15, error15, chisq_red15, residual15, index43, amp43, error43, chisq_red43, residual43, index15_ol, amp15_ol, error15_ol, chisq_red15_ol, residual15_ol, index43_ol, amp43_ol, error43_ol, chisq_red43_ol, residual43_ol)
def fitRB(self, x, y): p0 = self.guess(x, y) res = ls(self.err, p0, args=(x, y)) A, B, p = res.x return A, B, p
def fit(self, func):#expects a mfit.function residual = func.residual() p0 = func.p0 xmin, xmax = np.where(self.x>=func.xmin)[0][0], np.where(self.x<=func.xmax)[0][-1] fitout = ls(residual, p0, args=(self.x[xmin:(xmax+1)], self.y[xmin:(xmax+1)])) func.p0, func.covariance = fitout[0], fitout[1]
if 'kqdl' in line[0]: kqdl = float(line[1]) g.write('{} := {};\n'.format(line[0], line[1])) for i, v in enumerate(theta): if 'qf' in corr[i]: g.write('{} := {};\n'.format(corr[i], kqfl + v)) else: g.write('{} := {};\n'.format(corr[i], kqdl + v)) f.close() g.close() os.system("/home/laptop/cryring/madx < cryring.madx > ./out.dat") SP2 = 48 # header of twiss file betabpm = read_twiss('twiss.txt', SP2) index = [0, 2, 4, 5, 7] beta = [x for i, x in enumerate(betabpm) if i in index] metric = np.std(beta) / np.mean(beta) print('periodic beta is {}'.format(beta)) print('set of parameters is {}'.format(theta)) print('metric is {}'.format(metric)) return metric**2 ls(metric_counter, theta0, xtol=10**(-5))