def _refine_pass(self, ascending_date, descending_date) -> BasicPassInfo: tca_dt = self._find_tca(ascending_date, descending_date) elevation = self._elevation_at(tca_dt) if elevation > self.max_elevation_gt: aos_dt = self._find_aos(tca_dt) los_dt = self._find_los(tca_dt) else: aos_dt = los_dt = None return BasicPassInfo(aos_dt, tca_dt, los_dt, elevation) # Find visual pass details # First, get endpoints of when location is not sunlit # Use cubic splines to find sun elevation jd0 = sum(julian_date_from_datetime(aos_dt)) jdf = sum(julian_date_from_datetime(los_dt)) jd = np.linspace(jd0, jdf, 5) # use 5 points for spline sun_el_fn = lambda j: self.location.sun_elevation_jd(j) + 6 el = np.array([sun_el_fn(j) for j in jd]) if np.min(el) > 0: # entire pass in sunlit return BasicPassInfo(aos_dt, tca_dt, los_dt, elevation, type_=PassType.daylight) tol = 1/86400 # one second # part of the pass is in darkness. Find new jd0, jdf sun_el = CubicSpline(jd, el, bc_type='natural') for root in sun_el.roots(extrapolate=False): tmp1 = sun_el(root - tol) tmp2 = sun_el(root + tol) if tmp1 < tmp2: # sun elevation is decreasing jd0 = root else: jdf = root # Now use jd0 and jdf to find when satellite is illuminated by sun jd = np.linspace(jd0, jdf, 5) # use 10 points for spline illum_fn = lambda j: self.satellite.illumination_distance_jd(j) - R_EARTH illum_pts = np.array([illum_fn(j) for j in jd]) if np.max(illum_pts) < 0: # entire pass is in shadow return BasicPassInfo(aos_dt, tca_dt, los_dt, elevation, type_=PassType.unlit) # part of the pass is visible illum = CubicSpline(jd, illum_pts, bc_type='natural') for root in illum.roots(extrapolate=False): tmp1 = illum(root - tol) tmp2 = illum(root + tol) if tmp1 < tmp2: # satellite is going into shadow jdf = root else: # satellite is coming out of shadow jd0 = root # Set visible start and end points for Pass vis_begin_dt = jday2datetime(jd0) vis_end_dt = jday2datetime(jdf) return BasicPassInfo( aos_dt, tca_dt, los_dt, elevation, type_=PassType.visible, vis_begin_dt=vis_begin_dt, vis_end_dt=vis_end_dt, )
def FWHM(wavelength, flux, eflux, lambda_m, flux_m, cont): '''compute FWHM from normalized feature''' fc_m, _, _, e_fc_m = cont(lambda_m) # continuum flux and uncertainty at minimum fc, _, _, e_fc = cont(wavelength) # continuum flux and uncertainty # half maximum normalized flux occurs is mean of extreme (normalized) flux and continuum flux (normalize = 1) hm = np.mean([flux_m / fc_m, 1]) # solve for intersection points with cubic spline results = [] for factor in [0, eflux, -1*eflux]: cs = CubicSpline(wavelength, ((flux + factor) / fc) - hm, extrapolate = False) roots = cs.roots() if len(roots[roots - lambda_m < 0]) == 0: low = np.nan else: low = roots[roots - lambda_m < 0].max() if len(roots[roots - lambda_m > 0]) == 0: high = np.nan else: high = roots[roots - lambda_m > 0].min() results.append(high - low) fwhm = results[0] e_fwhm = np.mean(np.abs([results[1] - fwhm, results[1] - fwhm])) if np.isnan(fwhm) or np.isnan(e_fwhm): fwhm, e_fwhm = np.nan, np.nan return fwhm, e_fwhm
def points(x, y, energy_diff, xlim=None, ylim=None): eqy = [] #plt.scatter(x.reshape(-1),y.reshape(-1),c=energy_diff.reshape(-1)) #plt.colorbar() #plt.show() test = np.linspace(0, 20, 500) if xlim is None: xlim = np.array([x.min(), x.max()] * x.shape[0]).reshape(2, -1) ylim = np.array([y.min(), y.max()] * y.shape[1]).reshape(2, -1) print(xlim.shape) print(x.shape[0]) print(ylim.shape) print(y.shape[1]) for idx, row in enumerate(energy_diff.T): #plt.plot(y[:,idx], row) #plt.show() c = CubicSpline(y[:, idx], row) roots = c.roots() for root in roots: if root > ylim[0][idx] and root <= ylim[1][idx]: #plt.plot(test, c(test)) #plt.title('{}{}'.format(x[0,idx],roots)) #plt.show() eqy.append([x[0, idx], root]) eqx = [] test = np.linspace(-3, 0, 100) for idx, column in enumerate(energy_diff): #plt.plot(x[idx,:], column) #plt.show() c = CubicSpline(x[idx, :], column) roots = c.roots() for root in roots: if root > xlim[0][idx] and root <= xlim[1][idx]: eqx.append([root, y[idx, 0]]) #plt.plot(test, c(test)) #plt.title('{}{}'.format(y[idx,0], roots)) #plt.show() return np.array(eqx), np.array(eqy), energy_diff > 0, energy_diff <= 0
def get_zperiod(s): xz = s[int(s.shape[0] / 2), int(s.shape[1] / 2), :, 0, 0] sp_qm = CubicSpline(range(len(xz)), xz) roots= np.array(sorted(sp_qm.roots().tolist())) roots=roots[np.logical_and(roots>=0,roots<= len(xz))] if len(roots)>1: dr=np.diff(roots) dr=dr[dr>2] print(f'{dr = }') if len(dr)>0: print(f'{100/np.mean(dr) = }') return np.mean(dr) else: return s.shape[2] else: return s.shape[2]
def funkcja(x, y): spline = CubicSpline(x, y) y_x = np.arange(1.0, 3, 0.01) x_root = spline.roots()[1:-1] y_root = np.zeros(len(x_root)) print('y\'(2.1) = ', spline(2.1, 1)) print('Miejsca zerowe:', x_root) plt.plot(y_x, spline(y_x)) plt.plot(x, y, 'oy') plt.plot(x_root, y_root, 'xk') plt.grid() plt.legend(['dane', 'spline_func_3'], loc='best') plt.show()
def get_density_profiles(mainpath, desired_list): #determine the location of the period datalist = [] path_maindensity = os.path.join(mainpath, 'density.dat') data = np.loadtxt(path_maindensity) fAmin = np.min(data[:, 1]) cs = CubicSpline(data[:, 0], data[:, 1] - fAmin) x = np.linspace(np.min(data[:, 0]), np.max(data[:, 0]), 1000) roots = cs.roots() loc = np.where((roots > np.min(data[:, 0])) & (roots < np.max(data[:, 0])))[0] domain_min = np.min(roots[loc[1]]) domain_max = np.max(roots[loc[3]]) loc = np.where((data[:, 0] > domain_min) & (data[:, 0] < domain_max))[0] data_domain = data[loc, :] data_domain[:, 0] = data_domain[:, 0] - np.min(data_domain[:, 0]) cs = CubicSpline(data_domain[:, 0] / np.max(data_domain[:, 0]), data_domain[:, 1]) integral = 1 #cs.integrate(0,1) x = np.linspace(0, 1, 10000) y = cs(x) / integral datalist.append(np.vstack((x, y)).transpose()) path_data = os.path.join(mainpath, 'density_chain0.dat') all_data = np.loadtxt(path_data) loc = np.where((all_data[:, 0] > domain_min) & (all_data[:, 0] < domain_max))[0] data = all_data[loc, :] data[:, 0] = data[:, 0] - np.min(data[:, 0]) shape = np.shape(data) for i in range(1, shape[1]): if i in desired_list: cs = CubicSpline(data[:, 0] / np.max(data[:, 0]), data[:, i]) integral = cs.integrate(0, 1) x = np.linspace(0, 1, 10000) y = cs(x) / integral datalist.append(np.vstack((x, y)).transpose()) return datalist
import matplotlib.pyplot as plt import numpy as np from scipy.interpolate import CubicSpline from scipy.misc import derivative x = np.array([1, 1.25, 1.5, 1.75, 2., 2.25, 2.5, 2.75, 3.]) y = np.array([ -0.5403, -0.0104, 0.9423, 0.17445, 1.3073, -0.7718, -2.4986, -0.7903, 2.7334 ]) cubspli = CubicSpline(x, y) #interpoluje pierwiastki = cubspli.roots(-2, 5) for a in pierwiastki: print("%12.8f %12.8e" % (a, cubspli(a))) print('\n', " dla x=2.1 f'(x)= ", (derivative(cubspli, 2.1))) plt.plot(x, y, 'x') plt.plot(np.arange(0.8, 3.1, 0.05), cubspli(np.arange(0.8, 3.1, 0.05)), '-') plt.show()
def calc_A(G, K, m, als=np.logspace(9, 1, 1 + 20 * (9 - 1)), plot=False, useBT=False): """ solve G = K*A for A, where A is normalized to A.sum() ~ 1 G: binned data with shape (nbin, ntau) K: kernel with shape (ntau, nw) m: default model function. shape is (nw,) als: list of alphas plot: loglog plot of chi2 vs. alpha """ # miscellaneous settings W_ratio_max = 1e8 svd_threshold = 1e-12 # drop singular vals if < max singular val * this # estimate parameters of multivariate Gaussian distribution from G nbin = G.shape[0] Gavg = G.mean(0) # calculate unitary matrix for diagonalizing covariance matrix # sigma2, Uc = np.linalg.eigh(np.cov(G.T) / nbin) # Uc = Uc.T # W = 1.0/sigma2 # equivalent to above, using svd sigma, Uc = np.linalg.svd(G - Gavg, False)[1:] W = (nbin * (nbin - 1)) / (sigma * sigma) # cap W in case covariance matrix is nearly singular W_cap = W_ratio_max * W.min() n_large = np.sum(W.max() > W_cap) if W.max() > W_cap: print(f"clipping {n_large} W values to W.min()*{W_ratio_max}") W[W > W_cap] = W_cap # rotate K and Gavg Kp = np.dot(Uc, K) Gavgp = np.dot(Uc, Gavg) # svd of kernel: K = V Sigma U.T V, Sigma, U = np.linalg.svd(Kp, False) # drop singular values less than threshold mask = (Sigma / Sigma.max() >= svd_threshold) # pre-calculate some stuff U = U.T[:, mask] SigmaVT = (V[:, mask] * Sigma[mask]).T M = np.dot(SigmaVT * W, SigmaVT.T) precalc = (U, SigmaVT, M) # if specified alpha if np.isscalar(als): return calc_A_al(Gavgp, W, Kp, m, als, precalc)[0] us = np.zeros((als.shape[0], M.shape[0])) chi2s = np.zeros_like(als) lnPs = np.zeros_like(als) dlnPs = np.zeros_like(als) for i, al in enumerate(als): us[i], chi2s[i], lnPs[i], dlnPs[i] = calc_A_al(Gavgp, W, Kp, m, al, precalc, us[i - 1])[1:] order = als.argsort() #BT fit = CubicSpline(np.log(als[order]), np.log(chi2s[order])) k = fit(np.log(als), 2) / (1 + fit(np.log(als), 1)**2)**1.5 i = k.argmax() # A = m * np.exp(np.dot(U, us[i, :])) #classic fit = CubicSpline(np.log(als[order]), dlnPs[order]) roots = fit.roots(extrapolate=False) if useBT or len(roots) == 0: if not useBT: print("maximum of P(alpha) outside range. defaulting to BT.") al = als[i] chi2 = chi2s[i] A = m * np.exp(np.dot(U, us[i, :])) else: al = np.exp(fit.roots(extrapolate=False)[0]) A, _unused, chi2 = calc_A_al(Gavgp, W, Kp, m, al, precalc)[:3] dof = len(W) - n_large print(f"alpha={al:.3f}\tchi2/dof={chi2/dof:.3f}\tA.sum()={A.sum():6f}") if plot: c2lo, c2hi = scipy.stats.chi2.interval(0.95, dof) f, ax1 = plt.subplots() ax1.plot([als[i], als[i]], [chi2s.min(), chi2s.max()], 'b', lw=1) ax1.plot([als.min(), als.max()], [dof, dof], 'k', lw=1) ax1.plot([als.min(), als.max()], [c2lo, c2lo], 'k--', lw=1) ax1.plot([als.min(), als.max()], [c2hi, c2hi], 'k--', lw=1) ax1.plot(als, chi2s, 'b.', ms=3) ax1.set_xscale("log") ax1.set_yscale("log") ax1.set_xlabel(r"$\alpha$") ax1.set_ylabel(r"$\chi^2$") ax2 = ax1.twinx() ax2.plot(als, np.exp(lnPs), 'g.', ms=3) ax2.plot([al, al], [0, np.exp(lnPs.max())], 'g', lw=1) ax2.set_ylabel(r"$P(\alpha)$") plt.show() return A
from os.path import join from scipy.interpolate import CubicSpline import matplotlib.pyplot as plt #------------------------------------------------------------------------------- #INPUT dirbatch = 'results' fnout = 'thaw_times.csv' #------------------------------------------------------------------------------- #MAIN #read the trials csv trials = read_csv(join(dirbatch, fntrials), index_col=0) #find thaw times trials['t'] = nan for idx in trials.index: t = fromfile(join(dirbatch, str(idx) + '_t')) minT = fromfile(join(dirbatch, str(idx) + '_minT')) s = CubicSpline(t, minT - 273) try: trials.at[idx, 't'] = s.roots()[0] except IndexError: print(idx) #write to file trials.to_csv(fnout)
def splinesolver(spline, xmin, xmax, y): xspace = np.linspace(xmin, xmax, 100) yspace = spline(xspace) - y cs = CubicSpline(xspace, yspace) return cs.roots()[0]