def draw_spectra(self): ''' Draw nearest spectra ''' if self.picked is None: return print "Drawing spectra" #xl = self.ax_spec.get_xlim() #yl = self.ax_spec.get_ylim() self.ax_spec.cla() #self.ax_spec.set_xlim(xl) #self.ax_spec.set_ylim(yl) x,y = self.X2[self.picked], self.Y1[self.picked] objs = self.KT.query_ball_point((x,y), 70) print "Query around %s found: %s" % ((x,y), objs) spec = self.cube[self.picked] ix = np.arange(*spec.xrange) fiducial_ll = chebval(ix, spec.lamcoeff) #self.ax_spec.plot(ix-spec.xrange[0], fiducial_ll, linewidth=3) self.ax_spec.step(fiducial_ll, spec.spec, linewidth=3) for spec in self.good_cube[objs]: try: ix = np.arange(*spec.xrange) ll = chebval(ix, spec.lamcoeff) #self.ax_spec.plot(ix-spec.xrange[0], ll-fiducial_ll) self.ax_spec.step(ll, spec.spec) except: pass #self.ax_spec.set_ylim(-30,30) self.ax_spec.set_xlim(370,700) self.fig.show()
def __init__(self, cube=None, figure=None, pointsize=65, bgd_sub=False, radius_as=3): ''' Create spectum picking gui. Args: cube: Data cube list figure: Figure to draw to [default is None or open a new figure window ''' self.actions = {"m": self.mode_switch} self.cube = cube self.pointsize = pointsize for ix, s in enumerate(self.cube): if s.xrange is None: continue xs = np.arange(s.xrange[0], s.xrange[1], .1) if s.lamcoeff is not None: lls = chebval(xs, s.lamcoeff) ha1 = np.argmin(np.abs(lls - 656.3))/10.0 + s.xrange[0] if s.mdn_coeff is not None: lls = chebval(xs, s.mdn_coeff) ha2 = np.argmin(np.abs(lls - 656.3))/10.0 + s.xrange[0] self.X1.append(ha1) self.X2.append(ha2) self.Y1.append(s.yrange[0]) self.X1, self.X2, self.Y1 = map(np.array, [self.X1, self.X2, self.Y1]) OK = (np.abs(self.X1 - self.X2) < 2) & np.isfinite(self.X2) & \ np.isfinite(self.Y1) self.good_cube = self.cube[OK] locs = np.array([self.X2[OK], self.Y1[OK]]).T self.KT = scipy.spatial.KDTree(locs) assert(len(locs) == len(self.good_cube)) # Setup drawing gs = gridspec.GridSpec(1,2, width_ratios=[1,2.5]) self.fig = pl.figure(1, figsize=(22,5.5)) self.ax_cube = pl.subplot(gs[0]) self.ax_spec = pl.subplot(gs[1]) self.ax_cube.set_xlim(-100, 2200) self.ax_cube.set_ylim(-100, 2200) pl.ion() self.draw_cube() print "Registering events" self.fig.canvas.mpl_connect("button_press_event", self) self.fig.canvas.mpl_connect("key_press_event", self) pl.show()
def referenceFunc_i(point): """Reference inverse implementation; point must be in range [-1, 1] """ c1 = np.array([0, 0, 0, 1.6], dtype=float) c2 = np.array([0, -3.6], dtype=float) x1 = point return ( chebval(x1, c1), chebval(x1, c2), )
def get_lambda_nm(self): """Returns lambda spectrum in nm""" xs = np.arange(*self.xrange) if self.lamcoeff is not None: lam = chebval(xs, self.lamcoeff) else: lam = chebval(xs, self.mdn_coeff) return lam
def test_chebval(self) : def f(x) : return x*(x**2 - 1) #check empty input assert_equal(ch.chebval([], 1).size, 0) #check normal input) for i in range(5) : tgt = 1 res = ch.chebval(1, [0]*i + [1]) assert_almost_equal(res, tgt) tgt = (-1)**i res = ch.chebval(-1, [0]*i + [1]) assert_almost_equal(res, tgt) zeros = np.cos(np.linspace(-np.pi, 0, 2*i + 1)[1::2]) tgt = 0 res = ch.chebval(zeros, [0]*i + [1]) assert_almost_equal(res, tgt) x = np.linspace(-1,1) tgt = f(x) res = ch.chebval(x, [0, -.25, 0, .25]) assert_almost_equal(res, tgt) #check that shape is preserved for i in range(3) : dims = [2]*i x = np.zeros(dims) assert_equal(ch.chebval(x, [1]).shape, dims) assert_equal(ch.chebval(x, [1,0]).shape, dims) assert_equal(ch.chebval(x, [1,0,0]).shape, dims)
def test_chebvander(self) : # check for 1d x x = np.arange(3) v = ch.chebvander(x, 3) assert_(v.shape == (3,4)) for i in range(4) : coef = [0]*i + [1] assert_almost_equal(v[...,i], ch.chebval(x, coef)) # check for 2d x x = np.array([[1,2],[3,4],[5,6]]) v = ch.chebvander(x, 3) assert_(v.shape == (3,2,4)) for i in range(4) : coef = [0]*i + [1] assert_almost_equal(v[...,i], ch.chebval(x, coef))
def single_pawley(detector, q, I, back, p_fw=None): """ Full pawley fitting for a specific q, I combination. Option to use different initial parameters for FWHM fit. This allows a lower order polynomial to be specified. Args: detector: pyxpb detector object q (ndarray): Reciprocal lattice I (ndarray): Intensity values az_idx (int): Azimuthal slice index p_fw (list, tuple): New initial estimate """ nmat, nf = len(detector.materials), len(detector._fwhm) background = chebval(q, back) q_lim = [np.min(q), np.max(q)] p0 = extract_parameters(detector, q_lim, np.nanmax(I)) if p_fw is not None: p_fw0_idx = range(nmat, nmat + nf) p0_new = [i for idx, i in enumerate(p0) if idx not in p_fw0_idx] for idx, i in enumerate(p_fw): p0_new.insert(nmat + idx, i) nf = len(p_fw) else: p0_new = p0 pawley = pawley_hkl(detector, background, nf - 1) return curve_fit(pawley, q, I, p0=p0_new)
def spec_calibration(self, theta=None, obs=None, **kwargs): """Implements a Chebyshev polynomial calibration model. If ``"pivot_wave"`` is not present in ``obs`` then 1.0 is returned. :returns cal: If ``params["cal_type"]`` is ``"poly"``, a polynomial given by 'spec_norm' * (1 + \Sum_{m=1}^M 'poly_coeffs'[m-1] T_n(x)). Otherwise, the exponential of a Chebyshev polynomial. """ if theta is not None: self.set_parameters(theta) if ('pivot_wave' in obs) and ('poly_coeffs' in self.params): # map wavelengths to the interval -1, 1 x = obs['wavelength'] - obs['wavelength'].min() x = 2.0 * (x / x.max()) - 1.0 # get coefficients. Here we are setting the first term to 0 so we # can deal with it separately for the exponential and regular # multiplicative cases c = np.insert(self.params['poly_coeffs'], 0, 0) poly = chebval(x, c) #switch to have spec_norm be multiplicative or additive #depending on whether the calibration model is #multiplicative in exp^poly or just poly if self.params.get('cal_type', 'exp_poly') is 'poly': return (1.0 + poly) * self.params['spec_norm'] else: return np.exp(self.params['spec_norm'] + poly) else: return 1.0
def chebinterp(x,f,y): """ Interpolate a function f on a set of points x onto a set of points y x and y should must be in [-1,1]""" n = len(x) Tx = chebvander(x,n-1) a = solve(Tx,f) p = chebval(y,a) return p
def Poly(pars, middle, low, high, x): """ Generates a polynomial with the given parameters for all of the x-values. x is assumed to be a np.ndarray! Not meant to be called directly by the user! """ xgrid = (x - middle) / (high - low) # re-scale return chebyshev.chebval(xgrid, pars)
def plot_result(): n = [2**x for x in range(1,8)] for j in n: x = np.linspace(-1,1,num=100,endpoint=True) y = np.array([f(i) for i in x]) chebpoly = chebval(x,cheb_interp(f,j)) plt.plot(x,y) plt.plot(x,chebpoly) plt.show()
def initModel(self,): HtIndx=min(max(int(self.zjet_max-50)/20-1,0),20) scoef=spd_coefs[HtIndx] dcoef=dir_coefs[HtIndx] prms=np.array([0,self.Ri,self.UStar,1]) if self.zjet_max==self.RefHt: prms[0]=self.URef else: utmp1=chebval(self.RefHt,np.dot(scoef[:,1:],prms[1:][:,None])) utmp2=chebval(self.RefHt,scoef[:,0]) prms[0]=(self.URef-utmp1)/utmp2 scoef=np.dot(scoef,prms[:,None]) # These are now vectors dcoef=np.dot(dcoef,prms[:,None]) # These are now vectors ang=chebval(self.grid.z,dcoef) ang-=ang[self.grid.ihub[0]] # The hub-height angle should be zero. ang[ang<-45.],ang[ang>45.]=-45.,45. # No angle should be more than 45 degrees. tmpdat=chebval(self.grid.z,scoef)*np.exp(1j*np.pi/180.*ang)[:,None] self._u[:1]=tmpdat.real,tmpdat.imag
def test_approximation(self): def powx(x, p): return x**p x = np.linspace(-1, 1, 10) for deg in range(0, 10): for p in range(0, deg + 1): c = cheb.chebinterpolate(powx, deg, (p,)) assert_almost_equal(cheb.chebval(x, c), powx(x, p), decimal=12)
def pawley_plot(q, I, detector, az_idx, ax): """ Plots q against measured intensity overlaid with Pawley fit. Includes highlighting of anticipated Bragg peak locations and difference between measured intensity and Pawley fit. Args: q (ndarray): Reciprocal lattice I (ndarray): Intensity detector: pyxpb detector instance az_idx (int): Azimuthal slice index ax: Axis to apply plot to """ background = chebval(q, detector._back[az_idx]) q_lim = [np.min(q), np.max(q)] p0 = extract_parameters(detector, q_lim, np.nanmax(I)) pawley = pawley_hkl(detector, background) coeff, var_mat = curve_fit(pawley, q, I, p0=p0) I_pawley = pawley(q, *coeff) # Plot raw data and Pawley fit to data ax.plot(q, I, 'o', markeredgecolor='0.3', markersize=4, markerfacecolor='none', label=r'$\mathregular{I_{obs}}$') ax.plot(q, I_pawley, 'r-', linewidth=0.75, label=r'$\mathregular{I_{calc}}$') # Plot Bragg positions - locate relative to max intensity ymin = -ax.get_ylim()[1] / 10 materials = detector.materials for idx, mat in enumerate(materials): offset = (1 + idx) * ymin / 2 for q0 in detector.q0[mat]: bragg_line = [offset + ymin / 8, offset - ymin / 8] ax.plot([q0, q0], bragg_line, 'g-', linewidth=2) # Use error bars to fudge vertical lines in legend ax.errorbar(0, 0, yerr=1, fmt='none', capsize=0, ecolor='g', elinewidth=1.5, label=r'Bragg ({})'.format(mat)) # Plot difference between raw and Pawley fit (shifted below Bragg) I_diff = I - I_pawley max_diff = np.max(I_diff) shifted_error = I - I_pawley + (idx + 2) * ymin / 2 - max_diff ax.plot(q, shifted_error, 'b-', linewidth=0.75, label=r'$\mathregular{I_{diff}}$') # Remove ticks below 0 intensity ylocs = ax.yaxis.get_majorticklocs() yticks = ax.yaxis.get_major_ticks() for idx, yloc in enumerate(ylocs): if yloc < 0: yticks[idx].set_visible(False) legend = ax.legend(numpoints=1) frame = legend.get_frame() frame.set_facecolor('w')
def define_background(self, seg=50, k=12, pnt=None, fwhm=None, plot=True, az_idx=0, auto=True, x=None, y=None): """ Background profile fitting - segment data and auto find points. Fits a Chebyshev polynomial (of order k) to automatically acquired q, I points. These points are selected wrt. the materials present (defined via add_materials), with the Bragg peaks being avoided. If auto is False, q v I points can be manually specified. Args: seg (int): Number of points to split data into/extract k (int): Order for Chebyshev polynomial pnt (tuple): Point co_ords or None for averaged data fwhm (float): Peak fwhm (to exclude more data around peaks) plot (bool): True/False az_idx (int): Azimuthal slice to plot auto (bool): Automatically extract q v I data x (ndarray): If not auto maunally defined q values y (ndarray): If not auto maunally defined I values """ # Automatically averages over all points unless point is specified if pnt is None: I = np.mean(self.I, tuple(range(self.I.ndim - 2))) else: I = self.I[pnt] if auto: az = self.q.shape[0] x, y = np.zeros((az, seg)), np.zeros((az, seg)) for a in range(az): split_q = np.array_split(self.q[a], seg) split_I = np.array_split(I[a], seg) for idx, q in enumerate(split_q): q_min, q_max = np.min(q), np.max(q) for mat in self.detector.materials: q0 = self.detector.q0[mat] fw = self.detector.fwhm[mat] if fwhm is None else fwhm clash = np.any(np.logical_and(q0 > q_min - 2 * fw, q0 < q_max + 2 * fw)) x[a, idx] = np.nan if clash else np.mean(split_q[idx]) y[a, idx] = np.nan if clash else np.mean(split_I[idx]) self.detector.define_background(x, y, k) f = self.detector._back if plot: plt.plot(self.q[az_idx], I[az_idx], 'k') plt.plot(self.q[az_idx], chebval(self.q[az_idx], f[az_idx]), 'r-') plt.plot(x[az_idx], y[az_idx], 'r+') plt.ylim([0, np.nanmax(y) * 1.5]) plt.xlabel(r'$\mathregular{q (A^{-1})}$') plt.ylabel(r'Intensity')
def test_chebfit(self) : def f(x) : return x*(x - 1)*(x - 2) # Test exceptions assert_raises(ValueError, cheb.chebfit, [1], [1], -1) assert_raises(TypeError, cheb.chebfit, [[1]], [1], 0) assert_raises(TypeError, cheb.chebfit, [], [1], 0) assert_raises(TypeError, cheb.chebfit, [1], [[[1]]], 0) assert_raises(TypeError, cheb.chebfit, [1, 2], [1], 0) assert_raises(TypeError, cheb.chebfit, [1], [1, 2], 0) assert_raises(TypeError, cheb.chebfit, [1], [1], 0, w=[[1]]) assert_raises(TypeError, cheb.chebfit, [1], [1], 0, w=[1,1]) # Test fit x = np.linspace(0,2) y = f(x) # coef3 = cheb.chebfit(x, y, 3) assert_equal(len(coef3), 4) assert_almost_equal(cheb.chebval(x, coef3), y) # coef4 = cheb.chebfit(x, y, 4) assert_equal(len(coef4), 5) assert_almost_equal(cheb.chebval(x, coef4), y) # coef2d = cheb.chebfit(x, np.array([y,y]).T, 3) assert_almost_equal(coef2d, np.array([coef3,coef3]).T) # test weighting w = np.zeros_like(x) yw = y.copy() w[1::2] = 1 y[0::2] = 0 wcoef3 = cheb.chebfit(x, yw, 3, w=w) assert_almost_equal(wcoef3, coef3) # wcoef2d = cheb.chebfit(x, np.array([yw,yw]).T, 3, w=w) assert_almost_equal(wcoef2d, np.array([coef3,coef3]).T) # test scaling with complex values x points whose square # is zero when summed. x = [1, 1j, -1, -1j] assert_almost_equal(cheb.chebfit(x, x, 1), [0, 1])
def test_chebval(self) : #check empty input assert_equal(cheb.chebval([], [1]).size, 0) #check normal input) x = np.linspace(-1,1) y = [polyval(x, c) for c in Tlist] for i in range(10) : msg = "At i=%d" % i tgt = y[i] res = cheb.chebval(x, [0]*i + [1]) assert_almost_equal(res, tgt, err_msg=msg) #check that shape is preserved for i in range(3) : dims = [2]*i x = np.zeros(dims) assert_equal(cheb.chebval(x, [1]).shape, dims) assert_equal(cheb.chebval(x, [1,0]).shape, dims) assert_equal(cheb.chebval(x, [1,0,0]).shape, dims)
def spline_interpolation(pointx, pointy, wave, wave_temp, flux, flux_temp, axis, leg_instance, con_instance, linewidth= 2.0, endpoints = 'y', endpoint_order = 4): """Sort spline points and interpolate between marked continuum points""" from numpy.polynomial import chebyshev from scipy.interpolate import splrep,splev #Insert endpoints if endpoints == 'y': sort_array = np.argsort(pointx) x = np.array(pointx)[sort_array] y = np.array(pointy)[sort_array] chebfit = chebyshev.chebfit(x, y, deg = endpoint_order) chebfitval = chebyshev.chebval(wave, chebfit) i =wave[150], wave[-150] window1, window2 = ((i[0]-70)<=wave) & (wave<=(i[0]+70)), ((i[1]-70)<=wave) & (wave<=(i[1]+70)) y_val = np.median(chebfitval[window1]).astype(np.float64),np.median(chebfitval[window2]).astype(np.float64) pointx = np.concatenate([pointx,i]) pointy = np.concatenate([pointy,y_val]) ind_uni = f8(pointx) pointx = np.array(pointx)[ind_uni] pointy = np.array(pointy)[ind_uni] try: leg_instance.remove() except AttributeError: pass finally: leg_instance, = axis.plot(wave, chebfitval, color='black', lw = linewidth, label = 'legendre fit', zorder = 10) # print(pointx,pointy) #Sort numerically sort_array = np.argsort(pointx) x = np.array(pointx)[sort_array] y = np.array(pointy)[sort_array] from gen_methods import smooth #Interpolate spline = splrep(x,y, k=3) continuum = splev(wave,spline) continuum = smooth(continuum, window_len=1, window='hanning') #Plot try: con_instance.remove() except AttributeError: pass finally: con_instance, = axis.plot(wave,continuum, color='red', lw = linewidth, label = 'continuum', zorder = 10) return continuum, leg_instance, con_instance
def get_dlambda(self): """Returns dlambda spectrum """ # Note the +1 below to handle the eating of an element # by diff xs = np.arange(self.xrange[0], self.xrange[1] + 1) lam = chebval(xs, self.lamcoeff) dlam = np.abs(np.diff(lam)) return dlam
def Strength(x): if x.xrange is None: return None if x.lamcoeff is None: return None if x.specw is None: return None ix = np.arange(*x.xrange) ll = chebval(ix, x.lamcoeff) OK = (ll > 450) & (ll < 700) if OK.any(): return np.sum(x.specw[OK]) else: return None
def test_chebfit(self) : def f(x) : return x*(x - 1)*(x - 2) # Test exceptions assert_raises(ValueError, ch.chebfit, [1], [1], -1) assert_raises(TypeError, ch.chebfit, [[1]], [1], 0) assert_raises(TypeError, ch.chebfit, [], [1], 0) assert_raises(TypeError, ch.chebfit, [1], [[[1]]], 0) assert_raises(TypeError, ch.chebfit, [1, 2], [1], 0) assert_raises(TypeError, ch.chebfit, [1], [1, 2], 0) # Test fit x = np.linspace(0,2) y = f(x) coef = ch.chebfit(x, y, 3) assert_equal(len(coef), 4) assert_almost_equal(ch.chebval(x, coef), y) coef = ch.chebfit(x, y, 4) assert_equal(len(coef), 5) assert_almost_equal(ch.chebval(x, coef), y) coef2d = ch.chebfit(x, np.array([y,y]).T, 4) assert_almost_equal(coef2d, np.array([coef,coef]).T)
def interpolate(self, z, f): from numpy.polynomial.chebyshev import chebval import numpy as np msg = "Can't interpolate outside grid domain" assert np.array([z]).min() >= self.zmin, msg assert np.array([z]).max() <= self.zmax, msg c = self.to_coefficients(f) # Convert z-values to standard xg = [-1, 1] x = (z - self.zmin) / self.L * 2. - 1. return chebval(x, c)
def fit_func(dummy_variable, *labels): nn_spec = self.network.get_spectrum_scaled( scaled_labels=labels[:nnl]) nn_spec = doppler_shift(self.network.wave, nn_spec, labels[nnl]) if hasattr(self, 'lsf'): nn_resampl = self.lsf.apply(nn_spec) else: nn_resampl = np.interp(wavelength, self.network.wave, nn_spec) Cheb_coefs = labels[nnl + 1:nnl + 1 + self.Cheb_order] Cheb_x = np.linspace(-1, 1, len(nn_resampl)) Cheb_poly = chebval(Cheb_x, Cheb_coefs) spec_with_resp = nn_resampl * Cheb_poly return spec_with_resp
def eval(nr, a, b, r): # evaluates the projection matrix matrix for the chebyshev basis xx = (np.array(r)-b)/a coeffs = np.eye(nr)*2 #coeffs = np.eye(nr) coeffs[0,0]=1. # return the coo type matrix, because it is needed for integration (evaluation of antiderivative) purposes #return spsp.lil_matrix(cheb.chebval(xx, coeffs).transpose()) return np.mat(cheb.chebval(xx, coeffs).transpose())
def __call__(self, point): ''' Evaluate the polynomial at 'point'. Parameters ---------- point : array-like point at which to evaluate the polynomial Returns ------- c : complex value of the polynomial at the given point ''' super(MultiCheb, self).__call__(point) c = self.coeff n = len(c.shape) c = cheb.chebval(point[0], c) for i in range(1, n): c = cheb.chebval(point[i], c, tensor=False) return c
def bit_to_float(matrica_bit): matrica_bit, fitness = np.split(matrica_bit, [-1], axis=1) days_bit, brod_bit, koeficijenti_bit, snaga = np.split(matrica_bit, 64*np.array((1, 3, 4+podaci.chebdeg)), axis=1) days = np.packbits(days_bit.astype(bool), axis=1).view(np.float64) # date = np.empty(broj_jedinki) # for i in range(broj_jedinki): # date[i] = datetime.timedelta(days=days[i]) + podaci.beg_of_time brod = np.packbits(brod_bit.astype(bool), axis=1).view(np.float64) koeficijenti = np.packbits(koeficijenti_bit.astype(bool), axis=1).view(np.float64) uglovi = chebval(x_osa(broj_segmenata), koeficijenti) return days, brod, uglovi, snaga, fitness
def test_cheb_poly_single(): deg = 21 npts = 100 pts = np.linspace(0, 1, npts, dtype=np.float32) out = np.zeros((deg + 1) * npts, dtype=np.float32) cheb_utils.cheb_poly_float(deg, pts, npts, out) out = out.reshape([deg + 1, npts]) cheb_coefs = np.zeros(deg + 1) for m in range(deg + 1): cheb_coefs.fill(0) cheb_coefs[m] = 1 cheb_vals_np = chebval(pts, cheb_coefs) assert np.allclose(out[m], cheb_vals_np, rtol=1e-6, atol=1e-6)
def find_func(x, yreal): import numpy as np from numpy.polynomial.chebyshev import chebfit, chebval f = np.polyfit(x, yreal, len(yreal)) c = chebfit(x, yreal, len(yreal)) ytest_poly = [round(np.polyval(f, xi), 3) for xi in x] ytest_cheb = [round(chebval(xi, c), 3) for xi in x] ytest = ytest_poly function_coeff = f return ytest, function_coeff
def bit_to_float(matrica_bit): warnings.filterwarnings("error", category=RuntimeWarning) days_bit, fuel_bit, koeficijenti_bit, snaga = np.split(matrica_bit, np.array((16, 24, (1+podaci.chebdeg)*64 + 24)), axis=1) days = np.packbits(days_bit.astype(bool), axis=1).view(np.uint16) brod = np.packbits(fuel_bit.astype(bool), axis=1).view(np.uint8) koeficijenti = np.packbits(koeficijenti_bit.astype(bool), axis=1).view(np.float64) try: uglovi = chebval(x_osa(broj_segmenata), koeficijenti.T) uglovi = np.mod(uglovi, 2*pi) except RuntimeWarning: uglovi = np.random.random_sample(size=(broj_jedinki, broj_segmenata)) * 2*pi print(days.shape, brod.shape, uglovi.shape, snaga.shape) return days[:, 0], brod[:, 0], uglovi, snaga
def cheb_fitcurve( x,y,order ): x = cheb.chebpts2(len(x)) order = 64 coef = legend.legfit(x, y, order); assert_equal(len(coef), order+1) y1 = legend.legval(x, coef) err_1 = np.linalg.norm(y1-y) / np.linalg.norm(y) coef = cheb.chebfit(x, y, order); assert_equal(len(coef), order + 1) thrsh = abs(coef[0]/1000) for i in range(len(coef)): if abs(coef[i])<thrsh: coef = coef[0:i+1] break y2 = cheb.chebval(x, coef) err_2 = np.linalg.norm(y2 - y) / np.linalg.norm(y) plt.plot(x, y2, '.') plt.plot(x, y, '-') plt.title("nPt={} order={} err_cheby={:.6g} err_legend={:.6g}".format(len(x),order,err_2,err_1)) plt.show() assert_almost_equal(cheb.chebval(x, coef), y) # return coef
def measure_flexure(sky): ''' Measure expected (589.3 nm) - measured emission line in nm''' ll, ss = sky['nm'], sky['ph_10m_nm'] pl.figure() pl.step(ll, ss) pix = SG.argrelmax(ss, order=20)[0] skynms = chebval(pix, sky['coefficients']) for s in skynms: pl.axvline(s) ixmin = np.argmin(np.abs(skynms - 589.3)) dnm = 589.3 - skynms[ixmin] return dnm
def _get_temperature(self, R): """Return temperature from input resistance or voltage based on calibration""" # Find the right resistance range for n in range(len(self.fitdata)): Z = log10(R) ZL = self.fitdata[n]["Zlower for fit range"] ZU = self.fitdata[n]["Zupper for fit range"] if Z > ZL and Z < ZU: # Apply the formula k = ((Z - ZL) - (ZU - Z)) / (ZU - ZL) T = chebval(k, self.fitdata[n]["coef"]) return T print("Temperature out of calibration range.")
def continuum_fit(wl, flux, fluxerr, edge_mask_len=50): """ Small function to estimate continuum. Takes spectrum and uses only the edges, as specified by edge_mask_len, fits a polynomial and returns the fit. :param wl: Wavelenght array in which to estimate continuum :param flux: Corresponding flux array :param fluxerr: Corresponding array containing flux errors :param edge_mask_len: Size of edges to use to interpolate continuum :return: Interpolated continuum """ from numpy.polynomial import chebyshev wl_chebfit = np.hstack((wl[:edge_mask_len],wl[-edge_mask_len:])) mask_cont = np.array([i for i,n in enumerate(wl) if n in wl_chebfit]) chebfit = chebyshev.chebfit(wl_chebfit, flux[mask_cont], deg = 1, w=1/fluxerr[mask_cont]**2) chebfitval = chebyshev.chebval(wl, chebfit) return chebfitval, chebfit
def proj_radial(nr, a, b, x = None): # evaluate the radial basis functions of degree <nr # to the projection of the poloidal field in r direction (Q-part of a qst decomposition if x is None: xx,ww = cheb.chebgauss(nr) else: xx = np.array(x) # use chebyshev polynomials normalized for FCT coeffs = np.eye(nr)*2 #coeffs = np.eye(nr) coeffs[0,0]=1. #return spsp.lil_matrix((cheb.chebval(xx,coeffs)).transpose()) return np.mat((cheb.chebval(xx,coeffs)).transpose())
def chebfit2(x, y, deg, alpha=1e-4): """ This is a reimplementaion of a subset of chebyshev.chebfit https://numpy.org/doc/stable/reference/generated/numpy.polynomial.chebyshev.chebfit.html using Tichnov regularization (Ridge regression) """ cheb_values = [] for pos in range(deg + 1): coefs = np.zeros(deg + 1) coefs[pos] = 1 vals = cheb.chebval(x, coefs) cheb_values.append(vals) cheb_values = np.array(cheb_values) regr = Ridge(alpha=alpha, fit_intercept=False) _ = regr.fit(cheb_values.T, y) return regr.coef_
def ifct(f): # ============================================================================= # INPUT: Chebyshev coefficients # OUTPUT: Inverse discrete cosine tranform of f (f is in spectral space). This function takes f from spectral space to physical space #============================================================================== # ##Calculate chebyshev coefficients with DCT N = 1001 n = np.arange(0, N, 1) theta = np.pi * (2 * n + 1) / ((2 * (N))) x = np.cos(theta) #Correct to coincide with Moore 2017 #f[0] = f[0]*2 #F = idct(f)*len(f) F = chebval(x, f) return F
def chebstate_to_forwards(state, do_normalize=False): """ we return fwd values that correspond to scaled state (= coefs starting from the 2nd one, first two assume to be zero) Let n=len(state). We set coefs = [0,0,state/norm(state)] and fv = chebval(range(n+2), coefs) If we want len(fv) = nf then we need len(state) = nf-2 details https://numpy.org/doc/stable/reference/generated/numpy.polynomial.chebyshev.chebfit.html """ nf = len(state) + 2 xs = cheb_fwd_xs(nf) state_norm = np.linalg.norm(state) if do_normalize: state = state / state_norm return cheb.chebval(xs, c=[0, 0, *state]), state_norm
def th_plot(data, tt): fields = 'concurence', 'iops_mediana', 'lat_mediana' conc_4k = filter_data('concurrence_test_' + tt, fields, blocksize='4k') filtered_data = sorted(list(conc_4k(data))) x, iops, lat = zip(*filtered_data) _, ax1 = plt.subplots() xnew = np.linspace(min(x), max(x), 50) # plt.plot(xnew, power_smooth, 'b-', label='iops') ax1.plot(x, iops, 'b*') for degree in (3, ): c = chebfit(x, iops, degree) vals = chebval(xnew, c) ax1.plot(xnew, vals, 'g--')
def interpolate(self, z, f): """See equations 17.37 and 17.38 in Boyd""" from numpy.polynomial.chebyshev import chebval import numpy as np msg = "Can't interpolate outside grid domain" assert np.array([z]).min() >= self.zmin, msg assert np.array([z]).max() <= self.zmax, msg # Get coefficients for standard Chebyshev polynomials c = self.to_coefficients(f) # Convert infinite grid to xg = [-1, 1] x = z / np.sqrt(self.C ** 2 + z ** 2) # Evaluate the Chebyshev polynomial return chebval(x, c)
def th_plot(data, tt): fields = 'concurence', 'iops_mediana', 'lat_mediana' conc_4k = filter_data('concurrence_test_' + tt, fields, blocksize='4k') filtered_data = sorted(list(conc_4k(data))) x, iops, lat = zip(*filtered_data) _, ax1 = plt.subplots() xnew = np.linspace(min(x), max(x), 50) # plt.plot(xnew, power_smooth, 'b-', label='iops') ax1.plot(x, iops, 'b*') for degree in (3,): c = chebfit(x, iops, degree) vals = chebval(xnew, c) ax1.plot(xnew, vals, 'g--')
def stationarityTest(x): windowSize = 10 xStats = movingWindowStats(x, windowSize, arange(1, 5)) nSamples = min(128, x.shape[0] // windowSize) t = linspace(-1, 1, nSamples) i = array(linspace(0, xStats.shape[0] - 1, nSamples), int) ct = chebval(t, eye(2)).T minPvalues = 1 for j in range(xStats.shape[1]): for k in range(xStats.shape[2]): est = sm.OLS(xStats[i, j, k], ct) est2 = est.fit() print(j, k, est2.pvalues[1:]) minPvalues = min(minPvalues, est2.pvalues[1:].min()) # cla() # plot(t, xStats[i,j,k], '.-') # stop return minPvalues
def proj_radial_r2(nr, a, b, x = None): # evaluate the radial basis functions of degree <nr over r # this projection operator includes the 1/r**2 part and corresponds # to the a projection from spectral to physical for the toroidal field (T-part of a qst decomposition) if x is None: xx,ww = cheb.chebgauss(nr) else: xx = np.array(x) # use chebyshev polynomials normalized for FCT coeffs = np.eye(nr)*2 #coeffs = np.eye(nr) coeffs[0,0]=1. temp = (cheb.chebval(xx,coeffs)/(a*xx+b)**2).transpose() #return spsp.coo_matrix(temp) return np.mat(temp)
def object_func(*params): params = params[0] J = 0 fit = chebval(Q, params[:4]) E = params[4] fit = fit + E / Q for i in range(len(intensity)): if Q[i] < 1: if intensity[i] < fit[i]: J = J + (intensity[i] - fit[i])**4 elif intensity[i] >= fit[i]: J = J + (intensity[i] - fit[i])**4 else: if intensity[i] < fit[i]: J = J + (intensity[i] - fit[i])**4 elif intensity[i] >= fit[i]: J = J + (intensity[i] - fit[i])**2 return J
def evaluate_at(self, point): super(MultiCheb, self).evaluate_at(point) poly_value = complex(0) for mon in self.monomialList(): mon_value = 1 for i in range(len(point)): cheb_deg = mon[i] cheb_coeff = [0. for i in range(cheb_deg)] cheb_coeff.append(1.) cheb_val = cheb.chebval([point[i]], cheb_coeff)[0] mon_value *= cheb_val mon_value *= self.coeff[mon] poly_value += mon_value if abs(poly_value) < 1.e-10: return 0 else: return poly_value
def GaussHermiteIntegrate(degree, A, c, k): """This returns the integral of the expected Value function when s is a log-normal distribution.""" # Note that f(x) = V( (s**rho)*exp(sigma*x*sqrt(2))*k**alpha - c, (s**rho) * # exp( sigma*x*sqrt(2))) * 1/sqrt(pi) integral = 0 for i in range(degree): # Traditonally we used: V( k^alpha - c) # Now it has taken the form of: V( s*k^alpha - c, s) sNew = np.exp(mu + np.sqrt(2) * sigma * x[i]) #xPos = np.clip(sNew * k**alpha - c, a, b) xPos = sNew * k**alpha - c if (xPos < a): print(xPos) if (xPos > b): print(xPos) chebValue = cheb.chebval(xPos, A) integral += y[i] * chebValue return integral * (1. / np.sqrt(math.pi))
def cheb_eval(nr, a, b, r): # INPUT: # nr: int, number of radial functions # a: double, stretch factor for the mapping to shells # b: double, shift factor for the mapping to shells # r: np.array or list, list of collocation points # evaluates the projection matrix for the chebyshev basis xx = (np.array(r) - b) / a coeffs = np.eye(nr) * 2 coeffs[0, 0] = 1. # set 1 on the first diag entry because of DCT # proptierties # return the dense matrix, because it is needed for integration # (evaluation of antiderivative) purposes mat = np.mat(cheb.chebval(xx, coeffs).transpose()) return mat
def find_ha(cc): """Find out where in X position Halpha falls Args: cc (float vector): coefficients of fit giving wavelength versus spatial position Returns: float: spatial position corresponding to Halpha Note: assumes spatial position falls between 30 and 100 arcsec and has an accuracy limit of 0.1 arcsec """ ix = np.arange(30, 100, .1) haix = np.argmin(np.abs(chebval(ix, cc) - 656.3)) return ix[haix]
def spec_calibration(self, theta=None, obs=None, **kwargs): """Implements a Chebyshev polynomial calibration model. This only occurs if ``"poly_coeffs"`` is present in the :py:attr:`params` dictionary, otherwise the value of ``params["spec_norm"]`` is returned. :param theta: (optional) If given, set :py:attr:`params` using this vector before calculating the calibration polynomial. ndarray of shape ``(ndim,)`` :param obs: A dictionary of observational data, must contain the key ``"wavelength"`` :returns cal: If ``params["cal_type"]`` is ``"poly"``, a polynomial given by ``'spec_norm'`` :math:`\times (1 + \Sum_{m=1}^M```'poly_coeffs'[m-1]``:math:` \times T_n(x))`. Otherwise, the exponential of a Chebyshev polynomial. """ if theta is not None: self.set_parameters(theta) if ('poly_coeffs' in self.params): mask = obs.get('mask', slice(None)) # map unmasked wavelengths to the interval -1, 1 # masked wavelengths may have x>1, x<-1 x = self.wave_to_x(obs["wavelength"], mask) # get coefficients. Here we are setting the first term to 0 so we # can deal with it separately for the exponential and regular # multiplicative cases c = np.insert(self.params['poly_coeffs'], 0, 0) poly = chebval(x, c) # switch to have spec_norm be multiplicative or additive depending # on whether the calibration model is multiplicative in exp^poly or # just poly if self.params.get('cal_type', 'exp_poly') is 'poly': return (1.0 + poly) * self.params.get('spec_norm', 1.0) else: return np.exp(self.params.get('spec_norm', 0) + poly) else: return 1.0 * self.params.get('spec_norm', 1.0)
def convert_spectra_to_img(spectra, CRVAL1, CRPIX1): lfid = exp_fid_wave(CRVAL1=CRVAL1, CRPIX1=CRPIX1) img = np.zeros((len(spectra), len(lfid))) img2 = np.zeros((len(spectra), len(lfid))) img[:] = np.nan img2[:] = np.nan for ix, spectrum in enumerate(spectra): spec = spectrum.specw if spec is None: continue img[ix, 0:len(spec)] = spec try: lam = chebval(np.arange(*spectrum.xrange), spectrum.lamcoeff) except: continue IF = interp1d(lam, spec, bounds_error=False, fill_value=np.nan) img2[ix, :] = IF(lfid) return img, img2
def power_monitor_calibration(wavelength, voltage): ps = [ -1.954872514465467656097352744382078527e-02, -9.858164527032511337267806084128096700e-01, -9.030551056544730559316747076081810519e-02, -1.176690008380113228181329532162635587e-01, -7.280035069541325454256508464823127724e-02, -3.945345662306017076037534252463956363e-02, -3.615273166450208575106728403625311330e-02, 9.788152479007751483042198969997116365e-03, -1.456367977705685066991403431302387617e-02, -1.786831712872795699387218348874739604e-02, 2.597734938056468420586320178244932322e-02, -2.107763828923307075635662499735190067e-03, 7.008138732863849161558444933461942128e-03, 2.152771594326421261689219477375445422e-02, -1.331119139869020931432608279010310071e-02, -1.377397203478183430880310567090418772e-02, 5.892610556615005337754986669551726663e-03, 4.013333930879096900223856891898321919e-03, -1.388605295508058999273681699548887991e-03, -6.461661481385170711574938984256277763e-04, 1.965802838584800071083241723712831117e-04, 5.949925144541367866713593715033425724e-05, -1.676361665718153744295687568310881943e-05, -2.944515435510320108369441277629263709e-06, 7.941387605415402886735497592352039931e-07, 6.088879431605282524011537540614691366e-08, -1.605397480549405216611181363393912047e-08] #The values below are determined from the dataset associated with the coefficients #The fitting is scaled for numerical stability w_std = 20.579900281127852 w_mean = 763.93403214285706 r_std = 2.9169654028890814e-05 r_mean = 0.00048691497166276345 scale_wavelength = (float(wavelength) - w_mean)/w_std conversion = chebval(scale_wavelength, ps) unscale_r = conversion*r_std + r_mean return str(unscale_r*float(voltage))
def test_chebint(self) : # check exceptions assert_raises(ValueError, cheb.chebint, [0], .5) assert_raises(ValueError, cheb.chebint, [0], -1) assert_raises(ValueError, cheb.chebint, [0], 1, [0,0]) # test integration of zero polynomial for i in range(2, 5): k = [0]*(i - 2) + [1] res = cheb.chebint([0], m=i, k=k) assert_almost_equal(res, [0, 1]) # check single integration with integration constant for i in range(5) : scl = i + 1 pol = [0]*i + [1] tgt = [i] + [0]*i + [1/scl] chebpol = cheb.poly2cheb(pol) chebint = cheb.chebint(chebpol, m=1, k=[i]) res = cheb.cheb2poly(chebint) assert_almost_equal(trim(res), trim(tgt)) # check single integration with integration constant and lbnd for i in range(5) : scl = i + 1 pol = [0]*i + [1] chebpol = cheb.poly2cheb(pol) chebint = cheb.chebint(chebpol, m=1, k=[i], lbnd=-1) assert_almost_equal(cheb.chebval(-1, chebint), i) # check single integration with integration constant and scaling for i in range(5) : scl = i + 1 pol = [0]*i + [1] tgt = [i] + [0]*i + [2/scl] chebpol = cheb.poly2cheb(pol) chebint = cheb.chebint(chebpol, m=1, k=[i], scl=2) res = cheb.cheb2poly(chebint) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with default k for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = cheb.chebint(tgt, m=1) res = cheb.chebint(pol, m=j) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with defined k for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = cheb.chebint(tgt, m=1, k=[k]) res = cheb.chebint(pol, m=j, k=list(range(j))) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with lbnd for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = cheb.chebint(tgt, m=1, k=[k], lbnd=-1) res = cheb.chebint(pol, m=j, k=list(range(j)), lbnd=-1) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with scaling for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = cheb.chebint(tgt, m=1, k=[k], scl=2) res = cheb.chebint(pol, m=j, k=list(range(j)), scl=2) assert_almost_equal(trim(res), trim(tgt))
# to the outside and then back to centre and the other side. Hence the need for # sorting the same. sortind = np.argsort( rotcurve["Row"] ) fig1 = plt.figure(1) xs = np.linspace( np.min(rotcurve["Row"]), np.max(rotcurve["Row"]), 1000) residuals = [] change=0.0 for i in range(15): interp_coeff = chebfit( rotcurve["Row"], rotcurve["lambda"], w=1/rotcurve["lambda_err"], deg=i) interp_coeff_z = chebfit( rotcurve["Row"], rotcurve["z"], w=1/rotcurve["z_err"], deg=i) # Below, we are just generating a sample curve for the user to visualize the fit. ys = chebval(xs, interp_coeff) # Residual calculation in redshift space. predicted = chebval( rotcurve["Row"], interp_coeff_z ) rms = np.sqrt( np.sum( (predicted - rotcurve["z"])**2 ) / len(predicted) ) print rms residuals.append(rms) # Now, present the plot to the user. plt.errorbar( rotcurve["Row"], rotcurve["lambda"], rotcurve["lambda_err"], fmt="o" ) plt.plot(xs, ys) plt.xlabel("Row Number", fontsize=18) plt.ylabel("Wavelength Center", fontsize=18) if i!=0: change = (residuals[i] - residuals[i-1])/residuals[i-1] metric = residuals[i]/residuals[i-1] - 1 print('Metric of Change = ',metric)