def ReIter(self): [a, b] = ipVar.poptDir(self.RePath) z = np.where(np.diff(np.sign(a)))[0] i = z[0] r1 = b[i] r2 = b[i + 1] print(r1) print(r2) print("the value of the ") while (abs(r1 - r2) > 20): self.ReList = [] ReCr = funcs.calcReC(a, b) self.ReList.append(ReCr + 0.3 * abs(r1 - r2)) self.ReList.append(ReCr - 0.3 * abs(r1 - r2)) self.CritRe() print(r1) print(r2) [a, b] = ipVar.poptDir(self.RePath) z = np.where(np.diff(np.sign(a)))[0] r1 = b[z[0]] r2 = b[z[0] + 1] [a, b] = ipVar.poptDir(self.RePath) if (len(a) > 3): func = InterpolatedUnivariateSpline(b, a, k=3) ReC = func.roots() return ReC
def attenuation_dead_zone(f, s1, s2): DZ = [] pat1 = re.compile(s1 + '(.*?)' + s2, re.S) ### used for otdr 1 for element in f: filename = element.split('/')[-1].split('.')[0] cond = filename.split('_')[2] if float(cond) != 8: data = open(element) lines = data.read() new_data = pat1.findall(lines) x = [] y = [] for line in new_data: line = line.split() n = len(line) for i in range(1, int(n * 0.5), 1): newline = line[i].split(',') x.append(float(newline[0])) y.append(float(newline[1])) spl = InterpolatedUnivariateSpline(x, y) x_new_1 = np.linspace(0.15, 0.25, 100) y_new_1 = spl(x_new_1) left = np.average(abs(y_new_1)) n = len(y) y_new = [] for i in range(n): y_new.append(float(y[i]) - left) spl1 = InterpolatedUnivariateSpline(x, y_new) root = InterpolatedUnivariateSpline.roots(spl1) error = (abs(root[-1] - root[-2])) * 500 DZ.append(error) else: DZ.append(0) return DZ
def find_cell_interceps(u_par_grid, u_perp_grid, cur_BDOP, irhop): u_par_interceps = u_par_grid[np.logical_and( u_par_grid > np.min(cur_BDOP.u_par[irhop]), u_par_grid < np.max(cur_BDOP.u_par[irhop]))] u_perp_spl = InterpolatedUnivariateSpline(cur_BDOP.u_par[irhop], cur_BDOP.u_perp[irhop]) u_perp_at_u_par_interceps = u_perp_spl(u_par_interceps) u_perp_interceps = [] u_par_at_u_perp_inteceps = [] for u_perp_intercep in u_perp_grid: u_perp_interceps_spl = InterpolatedUnivariateSpline( cur_BDOP.u_par[irhop], cur_BDOP.u_perp[irhop] - u_perp_intercep) roots = u_perp_interceps_spl.roots() if (len(roots) > 0): for root in roots: if (root >= np.min(u_par_grid) and root <= np.max(u_par_grid)): u_perp_interceps.append(u_perp_intercep) u_par_at_u_perp_inteceps.append(root) # Now create list of all intercep points (u_par, u_perp) sorted by ascending u_par intercep_list = np.array([ np.concatenate([u_par_interceps, u_par_at_u_perp_inteceps]), np.concatenate([u_perp_at_u_par_interceps, u_perp_interceps]) ]) sortarray = np.argsort(intercep_list[0]) return intercep_list.T[sortarray]
def ReIter2(self, FT): [a, b] = ipVar.poptDir(self.RePath) z = np.where(np.diff(np.sign(a)))[0] r1 = b[z[0]] r2 = b[z[0] + 1] while (abs(r1 - r2) > 11): [a, b] = ipVar.poptDir(self.RePath) ReCr = funcs.calcReC(a, b) self.ReList.append(ReCr + 5) self.ReList.append(ReCr - 5) self.CritRe(FT) [a, b] = ipVar.poptDir(self.RePath) ReCr = funcs.calcReC(a, b) z = np.where(np.diff(np.sign(a)))[0] r1 = b[z[0]] r2 = b[z[0] + 1] if (abs(r1 - r2) < 11): [a, b] = ipVar.poptDir(self.RePath) ReCr = funcs.calcReC(a, b) self.ReList.append(ReCr) self.CritRe(FT) [a, b] = ipVar.poptDir(self.RePath) if (len(a) > 3): func = InterpolatedUnivariateSpline(b, a, k=3) ReC = func.roots() return ReC
def ReIter2(self,FT): [a,b]=ipVar.poptDir(self.RePath); z=np.where(np.diff(np.sign(a)))[0]; r1=b[z[0]];r2=b[z[0]+1]; while(abs(r1-r2)>11): [a,b]=ipVar.poptDir(self.RePath); ReCr=funcs.calcReC(a,b); self.ReList.append(ReCr+5); self.ReList.append(ReCr-5); self.CritRe(FT); [a,b]=ipVar.poptDir(self.RePath); ReCr=funcs.calcReC(a,b); z=np.where(np.diff(np.sign(a)))[0]; r1=b[z[0]];r2=b[z[0]+1]; if(abs(r1-r2)< 11): [a,b]=ipVar.poptDir(self.RePath); ReCr=funcs.calcReC(a,b); self.ReList.append(ReCr); self.CritRe(FT); [a,b]=ipVar.poptDir(self.RePath); if(len(a)>3):func=InterpolatedUnivariateSpline(b,a,k=3); ReC=func.roots(); return ReC;
def get_key_points(t, x): """ Basic function used in ZeroKeypointsGenerator finding t: x(t)=0 and filtering the outliers """ spl = InterpolatedUnivariateSpline(t, x) roots = spl.roots() key_points = roots[1::2] if len(key_points) < 3: return key_points, np.zeros_like(key_points) outlier_scores = np.abs( (key_points[2:] + key_points[:-2] - 2 * key_points[1:-1]) / key_points[1:-1]) np.pad(np.abs((key_points[2:] + key_points[:-2] - 2 * key_points[1:-1]) / key_points[1:-1]), (2, 2), mode='constant', constant_values=1) threshold = 3 * np.percentile(outlier_scores, 75) - 2 * np.percentile( outlier_scores, 25) outliers = (np.convolve( np.pad(outlier_scores > threshold, (2, 2), mode='constant', constant_values=1), [1, 1, 1]) == 3)[2:-2] return key_points, outliers
def parsec_locus_jhjk(x0, y0, cer, feh, age, isochrones): ''' Find the where a star would be located on the stellar locus in (J - K)-(J - H) color space. (J - K) is the abscissa and (J - H) is the ordinate. Inputs: ------ x0: J - K color of star y0: J - H color of star cer: color excess ratio [E(J - H)/E(J - K)] feh: metallicity of star age: age in Gyr isochrones: set of parsec isochrones Outputs: ------- jk_cross: J - K of intersection point jh_cross: J - H of intersection point ''' single = isochrones[np.where((isochrones['logAge'] == closest( np.log10(age * 10**9), isochrones['logAge'])) & ( isochrones['MH'] == closest(feh, isochrones['MH'])))] xs = (single['Jmag'] - single['Ksmag']) ys = (single['Jmag'] - single['Hmag']) bins = np.arange(np.min(xs), np.max(xs), 0.005) binned_color = binned_statistic(xs, ys, statistic='median', bins=bins).statistic fin = np.where((np.isfinite(bins[:-1]) == True) & (np.isfinite(binned_color) == True)) bins = bins[:-1][fin] binned_color = binned_color[fin] # Interpolate Isochrone spline = InterpolatedUnivariateSpline(bins, binned_color, ext=0) y_spl = spline(bins) # Find the crossing point if y0 - spline(x0) > 0: # what to do if star is above isochrone in color-color space return np.squeeze([-9999.0, -9999.0]) else: # Find roots in difference between the ccline and isochrone func = y_spl - ccline(bins, cer, x0, y0) func_spl = InterpolatedUnivariateSpline(bins, func, ext=0) jk_cross = func_spl.roots() jh_cross = spline(jk_cross) if len(jk_cross) == 0: # If cross12 is empty return np.squeeze([-9999.0, -9999.0]) else: # Return Cartesian coordinates of crossing point in color-color space return np.squeeze(list(zip(jk_cross, jh_cross)))
def crossings(series, value): """Find the labels where the series passes through value. The labels in series must be increasing numerical values. series: Series value: number returns: sequence of labels """ interp = InterpolatedUnivariateSpline(series.index, series-value) return interp.roots()
def find_FWHM(x, y): """ Find FWHM (full width at half maximum) of the waveform. """ xmax = x[np.argmax(y)] yn = y/np.max(y) spl = InterpolatedUnivariateSpline(x=x, y=yn-0.5) roots = spl.roots() x1 = roots[roots<xmax][-1] x2 = roots[roots>xmax][0] return x2-x1
def fwhm(x, y): """Calculate the FWHM and peak height of a vector y with corresponding coordinates x.""" i_max_y = np.argmax(y) y_norm = y - y[i_max_y] / 2 max_x = x[i_max_y] spline = InterpolatedUnivariateSpline(x, y_norm, k=3, ext='raise') # FWHM r = spline.roots() if len(r) < 2: return np.nan center = r[np.argsort(np.abs(r - max_x))[0:2]] fwhm = np.abs(center[1] - center[0]) return fwhm
def CalculateHWHM(GF_A): ''' calculates the half-width at half-maximum of the Kondo resonance and the maximum of the spectral function ''' N = len(En_A) IntMin = int((N+1)/2-int(0.5/dE)) IntMax = int((N+1)/2+int(0.5/dE)) DOSmaxPos = sp.argmax(-sp.imag(GF_A[IntMin:IntMax])/sp.pi) DOSmax = -sp.imag(GF_A[IntMin+DOSmaxPos])/sp.pi # maximum of DoS wmax = En_A[IntMin+DOSmaxPos] # position of the maximum at energy axis DOS = InterpolatedUnivariateSpline(En_A-1e-12,-sp.imag(GF_A)/sp.pi-DOSmax/2.0) ## 1e-12 breaks symmetry for half-filling, otherway DOS.roots() loses one solution. DOSroots_A = sp.sort(sp.fabs(DOS.roots())) try: HWHM = (DOSroots_A[0] + DOSroots_A[1])/2.0 except IndexError: HWHM = 0.0 return [HWHM,DOSmax,wmax]
def retreat_terminus(profile, verbose=False): """ Retreats terminus position with interpolation to satisfy height above flotation criterion. Parameters ---------- profile: Profile Profile to advance. verobse: bool, optional Print out diagnostic messages. Default: False. Returns ------- new_profile: Profile New Profile instance. """ # Create spline representation of HAF spline = InterpolatedUnivariateSpline(profile.x, profile.HAF) # Find roots roots = spline.roots() if len(roots) > 1: raise ValueError('Found multiple zero crossings of HAF') x_zero = roots[0] # Compute rough number of grid points to remove n_remove = int(np.round((profile.x[-1] - x_zero) / profile.dx)) if verbose: print('Retreating %d cells' % n_remove) # Create new grid of x points x_new = np.linspace(profile.x[0], x_zero, profile.N - n_remove) # Check if we need to remove an extra point dx_thresh = profile.dx - 0.05 * profile.dx if (x_new[1] - x_new[0]) < dx_thresh: x_new = np.linspace(profile.x[0], x_zero, profile.N - n_remove - 1) # Create new profile new_profile = profile.update_coordinates(x_new, extrapolate=False) new_profile.t = profile.t if verbose: print('New spacing:', new_profile.dx) return new_profile
def ReIter(self, FT): [a, b] = ipVar.poptDir(self.RePath) while (all(i > 0 for i in a)): self.ReList = [] ReNew = float(b[0]) - 0.2 * float(b[0]) self.ReList.append(ReNew) self.CritRe(FT) [a, b] = ipVar.poptDir(self.RePath) while (all(i < 0 for i in a)): self.ReList = [] ReNew = float(b[-1]) + 0.3 * float(b[-1]) self.ReList.append(ReNew) self.CritRe(FT) [a, b] = ipVar.poptDir(self.RePath) [a, b] = ipVar.poptDir(self.RePath) z = np.where(np.diff(np.sign(a)))[0] i = z[0] r1 = b[i] r2 = b[i + 1] print(r1) print(r2) print("the value of the ") temp = [0] ReCr = funcs.calcReC(a, b) temp.append(ReCr) while (abs(temp[-1] - temp[-2]) > 1): self.ReList = [] ReCr = funcs.calcReC(a, b) self.ReList.append(ReCr + 0.1 * abs(r1 - r2)) self.ReList.append(ReCr - 0.1 * abs(r1 - r2)) self.CritRe(FT) print(r1) print(r2) ReCr = funcs.calcReC(a, b) temp.append(ReCr) [a, b] = ipVar.poptDir(self.RePath) z = np.where(np.diff(np.sign(a)))[0] r1 = b[z[0]] r2 = b[z[0] + 1] [a, b] = ipVar.poptDir(self.RePath) if (len(a) > 3): func = InterpolatedUnivariateSpline(b, a, k=3) ReC = func.roots() return ReC
def score_from_efficiency_array(y_truth, y_score, efficiency_selected, keep_lower=False): """ Return the score array corresponding to an external fixed efficiency array. Parameters ----------------------------------------------- y_truth: array Training or test set labels. The candidates for each class should be labeled with 0, ..., N. In case of binary classification, 0 should correspond to the background while 1 to the signal y_score: array Estimated probabilities or decision function. keep_lower: bool If True compute the efficiency using the candidates with score lower than the score threshold; otherwise using the candidates with score higher than the score threshold. efficiency_selected: list or array Efficiency array along which calculate the corresponding score array Returns ----------------------------------------------- out: numpy array Score array corresponding to efficiency_selected """ score_list = [] eff, score = bdt_efficiency_array(y_truth, y_score, n_points=1000, keep_lower=keep_lower) for eff_val in efficiency_selected: interp = InterpolatedUnivariateSpline(score, eff - eff_val) score_list.append(interp.roots()[0]) score_array = np.array(score_list) return score_array
def FindABS(Det_A): """ determines ABS energies as zeroes of GF determinant """ DetG = InterpolatedUnivariateSpline(En_A[EdgePos1+1:EdgePos2],sp.real(Det_A[:])) RootsG_A = DetG.roots() NABS = len(RootsG_A) ABSpos_A = sp.zeros(2) Diff_A = sp.zeros(2) if NABS == 0: ## assumes ABS states too close to gap edges ## this also happens when using brentq to calculate densities and ## it starts from wrong initial guess print("# - Warning: FindABS: no ABS found: Probably too close to band edges.") ABS_A = sp.array([-Delta+2.0*dE,Delta-2.0*dE]) ABSpos_A = sp.array([EdgePos1+1,EdgePos2-1]) Diff_A = sp.array([DetG.derivatives(ABS_A[0])[1],DetG.derivatives(ABS_A[1])[1]]) elif NABS == 1: ## ABS too close to each other? print("# - Warning: FindABS: only one ABS found: {0: .6e}".format(RootsG_A[0])) print("# - Assuming they are too close to Fermi energy.") print("# - Using mirroring to get the other ABS, please check the result.") ABS_A = [-sp.fabs(RootsG_A[0]),sp.fabs(RootsG_A[0])] for i in range(2): ABSpos_A[i] = FindInEnergies(ABS_A[i],En_A) Diff_A[i] = DetG.derivatives(ABS_A[i])[1] elif NABS == 2: ## two ABS states, ideal case ABS_A = sp.copy(RootsG_A) for i in range(2): ABSpos_A[i] = FindInEnergies(RootsG_A[i],En_A) Diff_A[i] = DetG.derivatives(RootsG_A[i])[1] else: print("# - Error: FindABS: Too many zeroes of the determinant.") exit() if sp.fabs(ABS_A[0]+ABS_A[1]) > 1e-6: print("# - Warning: FindABS: positive and negative ABS energies don't match, diff = {0: .6e}"\ .format(sp.fabs(ABS_A[0]-ABS_A[1]))) if sp.fabs(ABS_A[0])<dE: ## ABS energy smaller than the energy resolution print("# - Warning: FindABS: ABS energies smaller than energy resolution") print("# - We put the poles to lowest possible energies.") ABSpos_A = [Nhalf-1,Nhalf+1] return [ABS_A,Diff_A,ABSpos_A]
def filter_fwhm(self): """ Returns ------- float Filter full width at half maximum (micron). """ data = self.get_filter() spline = InterpolatedUnivariateSpline( data[0, :], data[1, :] - np.max(data[1, :]) / 2.) root = spline.roots() diff = root - self.mean_wavelength() root1 = np.amax(diff[diff < 0.]) root2 = np.amin(diff[diff > 0.]) return root2 - root1
def ReIter(self,FT): [a,b]=ipVar.poptDir(self.RePath); while(all(i > 0 for i in a)): self.ReList=[]; ReNew=float(b[0])- 0.2*float(b[0]); self.ReList.append(ReNew); self.CritRe(FT); [a,b]=ipVar.poptDir(self.RePath); while(all(i < 0 for i in a)): self.ReList=[]; ReNew=float(b[-1])+0.3*float(b[-1]); self.ReList.append(ReNew); self.CritRe(FT); [a,b]=ipVar.poptDir(self.RePath); [a,b]=ipVar.poptDir(self.RePath); z=np.where(np.diff(np.sign(a)))[0]; i=z[0]; r1=b[i];r2=b[i+1]; print(r1);print(r2); print("the value of the "); temp=[0]; ReCr=funcs.calcReC(a,b); temp.append(ReCr); while(abs(temp[-1]-temp[-2])>1): self.ReList=[]; ReCr=funcs.calcReC(a,b); self.ReList.append(ReCr+0.1*abs(r1-r2)); self.ReList.append(ReCr-0.1*abs(r1-r2)); self.CritRe(FT); print(r1);print(r2); ReCr=funcs.calcReC(a,b); temp.append(ReCr); [a,b]=ipVar.poptDir(self.RePath); z=np.where(np.diff(np.sign(a)))[0]; r1=b[z[0]];r2=b[z[0]+1]; [a,b]=ipVar.poptDir(self.RePath); if(len(a)>3):func=InterpolatedUnivariateSpline(b,a,k=3); ReC=func.roots(); return ReC;
def ReIter(self): [a,b]=ipVar.poptDir(self.RePath); z=np.where(np.diff(np.sign(a)))[0]; i=z[0]; r1=b[i];r2=b[i+1]; print(r1);print(r2); print("the value of the "); while(abs(r1-r2)>20): self.ReList=[]; ReCr=funcs.calcReC(a,b); self.ReList.append(ReCr+0.3*abs(r1-r2)); self.ReList.append(ReCr-0.3*abs(r1-r2)); self.CritRe(); print(r1);print(r2); [a,b]=ipVar.poptDir(self.RePath); z=np.where(np.diff(np.sign(a)))[0]; r1=b[z[0]];r2=b[z[0]+1]; [a,b]=ipVar.poptDir(self.RePath); if(len(a)>3):func=InterpolatedUnivariateSpline(b,a,k=3); ReC=func.roots(); return ReC;
def filter_fwhm(self) -> float: """ Calculate the full width at half maximum (FWHM) of the filter profile. Returns ------- float Filter full width at half maximum (um). """ data = self.get_filter() spline = InterpolatedUnivariateSpline( data[:, 0], data[:, 1] - np.max(data[:, 1]) / 2.) root = spline.roots() diff = root - self.mean_wavelength() root1 = np.amax(diff[diff < 0.]) root2 = np.amin(diff[diff > 0.]) return root2 - root1
def refl_dead_zone(f, s1, s2): DZ = [] pat1 = re.compile(s1 + '(.*?)' + s2, re.S) ### used for otdr 1 for element in f: filename = element.split('/')[-1].split('.')[0] cond = filename.split('_')[2] if float(cond) != 8: data = open(element) lines = data.read() new_data = pat1.findall(lines) x = [] y = [] for line in new_data: line = line.split() n = len(line) for i in range(1, n, 1): newline = line[i].split(',') x.append(float(newline[0])) y.append(float(newline[1])) refl_peak = max(y) refl_under_peak_1 = refl_peak - 1.5 index = y.index(refl_peak) index_low = index - 50 index_high = index + 20 x_new = [] y_new = [] for i in range(index_low, index_high, 1): x_new.append(float(x[i])) y_new.append(float(y[i]) - refl_under_peak_1) spl = InterpolatedUnivariateSpline(x_new, y_new) root = InterpolatedUnivariateSpline.roots(spl) pos_gap = (abs(root[0] - root[1])) * 1000 DZ.append(pos_gap) else: DZ.append(0) return DZ
def find_contours(self, h): # Contour for single level # Sign changes of Z-h are recoreded in pen_points # The recorded points are always above or left the penetration point # Negative indices indicate a horizontal sign change self.pen_points = [] #horizontal # The zeroth x entry can never be a horizontal penetration point for i in range(1, self.nx-1): for j in range(0, self.ny): if((self.Z[i,j] -h) * (self.Z[i + 1,j] - h) < 0.0): self.pen_points.append(-np.array([i,j])) # Edge for i in range(self.nx-1, self.nx): for j in range(0, self.ny): if((self.Z[i,j] -h) * (self.Z[i - 1,j] - h) < 0.0): if(np.all(np.sum(np.abs(self.pen_points - (-np.array([i - 1,j]))),axis=1) > 0)): self.pen_points.append(-np.array([i - 1,j])) #Vertical for i in range(0, self.nx): # The zeroth xy entry can never be a vertical penetration point for j in range(1, self.ny-1): if((self.Z[i,j] - h) * (self.Z[i,j + 1] - h) < 0.0): self.pen_points.append(np.array([i,j])) #Edge for i in range(0, self.nx): for j in range(self.ny-1, self.ny): if((self.Z[i,j] - h) * (self.Z[i,j - 1] - h) < 0.0): if(np.all(np.sum(np.abs(self.pen_points - (-np.array([i,j-1]))),axis=1) > 0)): self.pen_points.append(np.array([i,j-1])) if(len(self.pen_points) == 0): self.contours_found = False return # Convert the pen_points to complex values which makes the index search much faster # Also remove any duplicates we might have picked up self.pen_points = list(np.unique(np.array(self.pen_points).T[0] + 1.j * np.array(self.pen_points).T[1])) self.contours_found = True self.finished_points = [] self.contour_lines = [[]] self.contour_indices = [[]] self.contour_closed = [] next_point = self.pen_points.pop(0) Z_spl = RectBivariateSpline(self.x, self.y, self.Z - h) N_int = 10 x_int = np.zeros(N_int) y_int = np.zeros(N_int) # Open contourlines are reversed to avoid bad starting points contour_reversed = False # Assemble contours while True: i_next = int(np.real(next_point)) j_next = int(np.imag(next_point)) if(i_next < 0 or j_next < 0): # Horiontal penetration point x_int[:] = np.linspace(self.x[-i_next], self.x[-i_next + 1], N_int) y_int[:] = self.y[-j_next] Z_int = Z_spl(x_int, y_int, grid=False) root_spl = InterpolatedUnivariateSpline(x_int, Z_int) roots = root_spl.roots() if(len(roots) == 0): print("Found no roots for this penetration point") fig = plt.figure() ax = fig.add_subplot(111) ax.contour(self.x, self.y, self.Z.T - h, levels=[0.0]) ax.vlines(self.x, np.min(self.y), np.max(self.y), linewidths=0.2) ax.hlines(self.y, np.min(self.x), np.max(self.x), linewidths=0.2) ax.plot(x_int, y_int, "r--", linewidth=4) fig2 = plt.figure() ax2 = fig2.add_subplot(111) ax2.plot(x_int, Z_int) plt.show() raise ValueError("Found no roots for this penetration point") for root in roots: self.contour_lines[-1].append([root, y_int[0]]) else: # Horiontal penetration point x_int[:] = self.x[i_next] y_int[:] = np.linspace(self.y[j_next], self.y[j_next + 1], N_int) Z_int = Z_spl(x_int, y_int, grid=False) root_spl = InterpolatedUnivariateSpline(y_int, Z_int) roots = root_spl.roots() if(len(roots) == 0): print("Found no roots for this penetration point") fig = plt.figure() ax = fig.add_subplot(111) ax.contour(self.x, self.y, self.Z.T - h, levels=[0.0]) ax.vlines(self.x, np.min(self.y), np.max(self.y), linewidths=0.2) ax.hlines(self.y, np.min(self.x), np.max(self.x), linewidths=0.2) ax.plot(x_int, y_int, "r--", linewidth=4) fig2 = plt.figure() ax2 = fig2.add_subplot(111) ax2.plot(y_int, Z_int) plt.show() raise ValueError("Found no roots for this penetration point") for root in roots: self.contour_lines[-1].append([x_int[0], root]) self.contour_indices[-1].append(next_point) self.finished_points.append(next_point) # Find the next point found_next, isclosed, next_point = self._find_next(next_point) if(not found_next): if(isclosed and len(self.contour_lines[-1]) > 2): # Close the contour self.contour_lines[-1].append(self.contour_lines[-1][0]) self.contour_indices[-1].append(self.contour_indices[-1][0]) elif(not contour_reversed): self.contour_lines[-1] = self.contour_lines[-1][::-1] self.contour_indices[-1] = self.contour_indices[-1][::-1] contour_reversed = True found_next, isclosed, next_point = self._find_next(self.contour_indices[-1][-1]) if(not found_next): contour_reversed = False self.contour_closed.append(isclosed) self.contour_lines[-1] = np.array(self.contour_lines[-1]) self.contour_indices[-1] = np.array(self.contour_indices[-1]) if(len(self.pen_points) == 0): break next_point = self.pen_points.pop(0) self.contour_lines.append([]) self.contour_indices.append([])
def integrate_flux( self, wavel_int: Tuple[float, float], interp_kind: str = "linear", plot_filename: Optional[str] = "int_line.pdf", ) -> Union[np.float64, np.float64]: """ Method for calculating the integrated line flux and error. The spectrum is first interpolated to :math:`R = 100000` and then integrated across the specified wavelength range with the composite trapezoidal rule of ``np.trapz``. The error is estimated with a Monte Carlo approach from 1000 samples. Parameters ---------- wavel_int : tuple(float, float) Wavelength range (um) across which the flux will be integrated. interp_kind : str Kind of interpolation kind for ``scipy.interpolate.interp1d`` (default: 'linear'). plot_filename : str, None Filename for the plot with the interpolated line profile. The plot is shown in an interface window if the argument is set to ``None``. Returns ------- float Integrated line flux (W m-2). float Flux error (W m-2). """ if plot_filename is None: print("Plotting integrated line...", end="", flush=True) else: print(f"Plotting integrated line: {plot_filename}...", end="", flush=True) n_samples = 1000 wavel_high_res = read_util.create_wavelengths(wavel_int, 1e5) # Creating plot mpl.rcParams["font.serif"] = ["Bitstream Vera Serif"] mpl.rcParams["font.family"] = "serif" plt.rc("axes", edgecolor="black", linewidth=2) plt.rcParams["axes.axisbelow"] = False plt.figure(1, figsize=(6, 3)) gs = mpl.gridspec.GridSpec(1, 1) gs.update(wspace=0, hspace=0, left=0, right=1, bottom=0, top=1) ax1 = plt.subplot(gs[0, 0]) ax2 = ax1.twiny() ax1.tick_params( axis="both", which="major", colors="black", labelcolor="black", direction="in", width=1, length=5, labelsize=12, top=False, bottom=True, left=True, right=True, ) ax1.tick_params( axis="both", which="minor", colors="black", labelcolor="black", direction="in", width=1, length=3, labelsize=12, top=False, bottom=True, left=True, right=True, ) ax2.tick_params( axis="both", which="major", colors="black", labelcolor="black", direction="in", width=1, length=5, labelsize=12, top=True, bottom=False, left=False, right=True, ) ax2.tick_params( axis="both", which="minor", colors="black", labelcolor="black", direction="in", width=1, length=3, labelsize=12, top=True, bottom=False, left=False, right=True, ) ax1.set_xlabel("Wavelength (µm)", fontsize=16) ax1.set_ylabel("Flux (W m$^{-2}$ µm$^{-1}$)", fontsize=16) ax2.set_xlabel("Velocity (km s$^{-1}$)", fontsize=16) ax1.get_xaxis().set_label_coords(0.5, -0.12) ax1.get_yaxis().set_label_coords(-0.1, 0.5) ax2.get_xaxis().set_label_coords(0.5, 1.12) ax1.plot( self.spectrum[:, 0], self.spectrum[:, 1], color="black", label=self.spec_name, ) ax2.plot(self.spec_vrad, self.spectrum[:, 1], ls="-", lw=0.0) flux_sample = np.zeros(n_samples) fwhm_sample = np.zeros(n_samples) mean_sample = np.zeros(n_samples) vrad_sample = np.zeros(n_samples) lum_sample = np.zeros(n_samples) for i in range(n_samples): # Sample fluxes from random errors spec_rand = np.random.normal(self.spectrum[:, 1], self.spectrum[:, 2]) # Interpolate sampled spectrum spec_interp = interp1d( self.spectrum[:, 0], spec_rand, kind=interp_kind, bounds_error=False ) # Resample to high-resolution wavelengths flux_rand = spec_interp(wavel_high_res) # Integrate line flux (W m-2) flux_sample[i] = np.trapz(flux_rand, wavel_high_res) # Line luminosity (Lsun) lum_sample[i] = ( 4.0 * np.pi * (1e3 * constants.PARSEC / self.parallax) ** 2 * flux_sample[i] ) lum_sample[i] /= constants.L_SUN # (Lsun) # Weighted (with flux) mean wavelength (um) mean_sample[i] = np.trapz( wavel_high_res * flux_rand, wavel_high_res ) / np.trapz(flux_rand, wavel_high_res) # Radial velocity (km s-1) vrad_sample[i] = ( 1e-3 * constants.LIGHT * (mean_sample[i] - self.lambda_rest) / self.lambda_rest ) # Find full width at half maximum spline = InterpolatedUnivariateSpline( wavel_high_res, flux_rand - np.max(flux_rand) / 2.0 ) root = spline.roots() diff = root - mean_sample[i] root1 = np.amax(diff[diff < 0.0]) root2 = np.amin(diff[diff > 0.0]) fwhm_sample[i] = 1e-3 * constants.LIGHT * (root2 - root1) / mean_sample[i] # Add 30 samples to the plot if i == 0: ax1.plot( wavel_high_res, flux_rand, ls="-", lw=0.5, color="gray", alpha=0.4, label="Random samples", ) elif i < 30: ax1.plot( wavel_high_res, flux_rand, ls="-", lw=0.5, color="gray", alpha=0.4 ) # Line flux from original, interpolated spectrum spec_interp = interp1d( self.spectrum[:, 0], self.spectrum[:, 1], kind=interp_kind, bounds_error=False, ) flux_high_res = spec_interp(wavel_high_res) line_flux = np.trapz(flux_high_res, wavel_high_res) ax1.plot( wavel_high_res, flux_high_res, color="tab:blue", label="High resolution" ) ax1.legend(loc="upper right", frameon=False, fontsize=12.0) print(" [DONE]") if plot_filename is None: plt.show() else: plt.savefig(plot_filename, bbox_inches="tight") plt.clf() plt.close() wavel_mean, wavel_std = np.mean(mean_sample), np.std(mean_sample) print(f"Mean wavelength (nm): {1e3*wavel_mean:.2f} +/- {1e3*wavel_std:.2f}") fwhm_mean, fwhm_std = np.mean(fwhm_sample), np.std(fwhm_sample) print(f"FWHM (km s-1): {fwhm_mean:.2f} +/- {fwhm_std:.2f}") vrad_mean, vrad_std = np.mean(vrad_sample), np.std(vrad_sample) print(f"Radial velocity (km s-1): {vrad_mean:.1f} +/- {vrad_std:.1f}") line_error = np.std(flux_sample) print(f"Line flux (W m-2): {line_flux:.2e} +/- {line_error:.2e}") lum_mean, lum_std = np.mean(lum_sample), np.std(lum_sample) print(f"Line luminosity (Lsun): {lum_mean:.2e} +/- {lum_std:.2e}") return line_flux, line_error
def SpecHWHM(GFint_A): ''' Half-width at half-maximum of the spectral function ''' N = len(En_A) DOSF = -sp.imag(GFint_A[N/2])/sp.pi # value at Fermi energy DOS = InterpolatedUnivariateSpline(En_A,-sp.imag(GFint_A)/sp.pi-DOSF/2.0) return sp.amin(sp.fabs(DOS.roots()))
def calc_fwhm(x, y): """Return FWHM calculated by fitting a spline to y vs. x""" y = N.array(y) sp = InterpolatedUnivariateSpline(x, y - y.max() / 2) lo, hi = sp.roots() return hi - lo
x0 = [seed[0], seed[1], seed[2], seed[4]] res = optimize.minimize(chi2_rel, x0, method='Nelder-Mead') chi2vals.append(res.fun) fig = plt.figure(figsize=(7, 6), dpi=200) ax = plt.axes() ax.plot(means, chi2vals, "k-") ax.set_ylabel('$\\Delta\\chi^2$', position=(0., 1.), va='top', ha='right') ax.set_xlabel('mean [keV]', position=(1., 0.), va='bottom', ha='right') ax.yaxis.set_label_coords(-0.12, 1.) ax.xaxis.set_label_coords(1.0, -0.1) plt.savefig("chi2.png") # find roots numerically via interpolation from scipy.interpolate import InterpolatedUnivariateSpline spline = InterpolatedUnivariateSpline(means, numpy.asarray(chi2vals)-1.) roots = spline.roots() print "best fit:", result.x[3], "+", roots[1]-result.x[3], "-", result.x[3]-roots[0]
def parsec_locus(x0, y0, mag1, mag2, mag3, mag4, cer, feh, age, parsec): ''' Find the where a star would be located on the stellar locus in (1 - 2)-(3 - 4) color space. (1 - 2) is the abscissa and (3 - 4) is the ordinate. Inputs: ------ x0: (1 - 2) color of star off locus y0: (3 - 4) color of star off locus mag1: [str] first magnitude in (1 - 2) color mag2: [str] second magnitude in (1 - 2) color mag3: [str] first magnitude in (3 - 4) color mag4: [str] second magnitude in (3 - 4) color cer: color excess ratio [E(3 - 4)/E(1 - 2)] feh: metallicity of star age: age in Gyr parsec: set of parsec isochrones Outputs: ------- cross12: (1 - 2) of intersection point cross34: (3 - 4) of intersection point ''' single = parsec[np.where( (parsec['logAge'] == closest(np.log10(age * 10**9), parsec['logAge'])) & (parsec['MH'] == closest(feh, parsec['MH'])))] xs = (single[mag1] - single[mag2]) ys = (single[mag3] - single[mag4]) bins = np.arange(np.min(xs), np.max(xs), 0.005) binned_color = binned_statistic(xs, ys, statistic='median', bins=bins).statistic fin = np.where((np.isfinite(bins[:-1]) == True) & (np.isfinite(binned_color) == True)) bins = bins[:-1][fin] binned_color = binned_color[fin] # Interpolate Isochrone spline = InterpolatedUnivariateSpline(bins, binned_color, ext=0) y_spl = spline(bins) # Find the crossing point if y0 - spline(x0) > 0: # what to do if star is above isochrone in color-color space return np.squeeze([-9999.0, -9999.0]) else: # Find roots in difference between the ccline and isochrone func = y_spl - ccline(bins, cer, x0, y0) func_spl = InterpolatedUnivariateSpline(bins, func, ext=0) cross12 = func_spl.roots() cross34 = spline(cross12) if len(cross12) == 0: # If cross12 is empty return np.squeeze([-9999.0, -9999.0]) else: # Return Cartesian coordinates of crossing point in color-color space return np.squeeze(list(zip(cross12, cross34)))
def upperlimit(self, printlevel=1): """ Returns the upper limit of the parameter of interest. """ pvalues = self.pvalues() poinull = self.poinull poivalues = poinull.value poiname = poinull.name poiparam = poinull.parameter bestfitpoi = self.calculator.config.bestfit.params[poiparam]["value"] sel = poivalues > bestfitpoi if self.CLs: k = "cls" else: k = "clsb" values = {} if isinstance(self.calculator, AsymptoticCalculator): keys = [k] else: keys = [k, "exp", "exp_p1", "exp_m1", "exp_p2", "exp_m2"] for k_ in keys: p_ = pvalues[k_] pvals = poivalues if k_ not in ["exp_m1", "exp_m2"]: p_ = p_[sel] pvals = pvals[sel] p_ = p_ - self.alpha s = InterpolatedUnivariateSpline(pvals, p_) val = s.roots() if len(val) > 0: poiul = val[0] else: poiul = None if k_ == k: k_ = "observed" values[k_] = poiul if isinstance(self.calculator, AsymptoticCalculator): poiul = POI(poiparam, poiul) exp_poi = self.calculator.expected_poi sigmas = [0.0, 1.0, 2.0, -1.0, -2.0] kwargs = dict(poinull=poiul, poialt=self.poialt, nsigma=sigmas, alpha=self.alpha, CLs=self.CLs) results = exp_poi(**kwargs) keys = ["exp", "exp_p1", "exp_p2", "exp_m1", "exp_m2"] for r, k_ in zip(results, keys): values[k_] = r if printlevel > 0: msg = "\nObserved upper limit: {0} = {1}" print(msg.format(poiname, values["observed"])) msg = "Expected upper limit: {0} = {1}" print(msg.format(poiname, values["exp"])) msg = "Expected upper limit +1 sigma: {0} = {1}" print(msg.format(poiname, values["exp_p1"])) msg = "Expected upper limit -1 sigma: {0} = {1}" print(msg.format(poiname, values["exp_m1"])) msg = "Expected upper limit +2 sigma: {0} = {1}" print(msg.format(poiname, values["exp_p2"])) msg = "Expected upper limit -2 sigma: {0} = {1}" print(msg.format(poiname, values["exp_m2"])) return values
def get_half_energy(p_spectrum, f, idx, prev_idx, next_idx): a_spectrum = np.sqrt(p_spectrum) p_value = a_spectrum[idx] q_value = p_value / 2 ius = InterpolatedUnivariateSpline(f, a_spectrum - q_value) p_ius = InterpolatedUnivariateSpline(f, p_spectrum) roots = ius.roots() if len(roots) == 0: l_limit = find_minima(p_spectrum, f, prev_idx, idx, idx) r_limit = find_minima(p_spectrum, f, idx, next_idx, idx) elif len(roots) == 1: #check the root if it lies on the left side or the right side if roots[0] < f[prev_idx]: l_limit = find_minima(p_spectrum, f, prev_idx, idx, idx) r_limit = find_minima(p_spectrum, f, idx, next_idx, idx) elif roots[0] >= f[prev_idx] and roots[0] < f[idx]: l_limit = roots[0] #find minina on the right side r_limit = find_minima(p_spectrum, f, idx, next_idx, idx) elif roots[0] >= f[idx] and roots[0] <= f[next_idx]: r_limit = roots[0] l_limit = find_minima(p_spectrum, f, prev_idx, idx, idx) else: l_limit = find_minima(p_spectrum, f, prev_idx, idx, idx) r_limit = find_minima(p_spectrum, f, idx, next_idx, idx) elif len(roots) >= 2: #find left-closest root t = [(f[idx] - root, root) for root in roots if root < f[idx]] if len(t) == 0: l_limit = find_minima(p_spectrum, f, prev_idx, idx, idx) else: (d, l_limit) = min(t) if l_limit <= f[prev_idx]: l_limit = find_minima(p_spectrum, f, prev_idx, idx, idx) #find right-closest root t = [(root - f[idx], root) for root in roots if root > f[idx]] if len(t) == 0: r_limit = find_minima(p_spectrum, f, idx, next_idx, idx) else: d, r_limit = min(t) if r_limit >= f[next_idx]: r_limit = find_minima(p_spectrum, f, idx, next_idx, idx) '''diff = np.array([abs(root - f[idx]) for root in roots]) sorted_indices = np.argsort(diff) i1,i2 = sorted_indices[0],sorted_indices[1] if f[i1] >= f[i2]: r_limit = roots[i1] l_limit = roots[i2] else: r_limit = roots[i2] l_limit = roots[i1]''' assert r_limit > l_limit if r_limit is None: print "r_limit is None" sys.exit() if l_limit is None: print "l_limit is None" sys.exit() num = int((r_limit - l_limit) * StepStrideFrequencyModuleConstants.sample_points / (Constants.sampling_frequency / 2)) x = np.linspace(l_limit, r_limit, num=num) return np.trapz(p_ius(x), x)
U = get_vec(res_AF, 'U') m_AF = get_vec(res_AF, 'm_AF') chi_AF = get_vec(res_AF, 'chi') assert( np.array_equal(np.abs(m_AF) < 1e-6, chi_AF.real > 0.) ), \ "Error: The AF susceptibility and order parameter do not agree." m_FM = get_vec(res_FM, 'm_FM') chi_FM = get_vec(res_FM, 'chi') assert( np.array_equal(np.abs(m_FM) < 1e-6, chi_FM.real > 0.) ), \ "Error: The AF susceptibility and order parameter do not agree." spl_chi_AF = InterpolatedUnivariateSpline(U[::-1], 1./chi_AF[::-1]) U_AF = spl_chi_AF.roots()[0] print 'U_AF =', U_AF spl_chi_FM = InterpolatedUnivariateSpline(U[::-1], 1./chi_FM[::-1]) U_FM = spl_chi_FM.roots()[0] print 'U_FM =', U_FM # -- Compare divergencies of chi with the chi_m = get_vec(res_FM, 'chi_m') e_AF = chi_m[:, -1] # AF is triply degenerate [spin-SU(2)] e_FM = chi_m[:, -4] # FM is the 4th eigen mode spl_e_AF = InterpolatedUnivariateSpline(U[::-1], 1./e_AF[::-1]) U_AF_ref = spl_e_AF.roots()[0]
def generate_interpolators(self, tablefile): """Generates the interpolators from the full hdf5 file. """ f = h5py.File(tablefile, 'r') self.ye_grid = f['ye'][:] self.rho_grid = f['logrho'][:] + np.log10(self.scaling['rho']) self.energy_shift = f['energy_shift'][0] * self.scaling['eps'] rho_grid, ye_grid = np.meshgrid(self.rho_grid, self.ye_grid) pres_values = f['logpress'][:, 0, :] + np.log10(self.scaling['pres']) munu_values = f['munu'][:, 0, :] # * self.scaling['energy'] energy_values = f['logenergy'][:, 0, :] + np.log10(self.scaling['eps']) f.close() self.ye_bounds = (np.min(self.ye_grid), np.max(self.ye_grid)) self.rho_bounds = (np.min(self.rho_grid), np.max(self.rho_grid)) self.pres_bounds = (np.min(pres_values), np.max(pres_values)) self.energy_arr = np.zeros_like(self.rho_grid) self.pres_arr = np.zeros_like(self.rho_grid) self.ye_arr = np.zeros_like(self.rho_grid) prev_root = 0 # for each rho, extract the values given ye such that munu = 0 for i, rho in enumerate(self.rho_grid): munu_func = InterpolatedUnivariateSpline(self.ye_grid, munu_values[:, i]) pres_func = interp1d(self.ye_grid, pres_values[:, i]) energy_func = interp1d(self.ye_grid, energy_values[:, i]) ye_roots = munu_func.roots() if len(ye_roots) > 1: # in case several roots, we pick the closest one import warnings warnings.warn( 'Error, more than one root in munu! Using closest to previous' ) ye_root = ye_roots[np.argmin( np.abs(np.array(ye_roots) - prev_root))] elif len(ye_roots) == 0: # in case of no roots, we chose the previous value ye_root = prev_root else: ye_root = ye_roots[0] prev_root = ye_root self.ye_arr[i] = ye_root self.pres_arr[i] = pres_func(ye_root) self.energy_arr[i] = energy_func(ye_root) # generate interpolators self.rho_interp = interp1d(self.pres_arr, self.rho_grid, fill_value='extrapolate') self.eps_interp = interp1d(self.rho_grid, self.energy_arr, fill_value='extrapolate') self.pres_interp = interp1d(self.rho_grid, self.pres_arr, fill_value='extrapolate') self.ye_interp = interp1d(self.rho_grid, self.ye_arr, fill_value='extrapolate')