def makeLSQspline(xl, yl, xr, yr): """docstring for makespline""" xmin = xr.min() - 1 xmax = xr.max() + 1 ymin = yr.min() - 1 ymax = yr.max() + 1 n = len(xl) print "xrange: ", xmin, xmax, '\t', "yrange: ", ymin, ymax s = 1.1 yknots, xknots = np.mgrid[ ymin + s:ymax - s:10j, xmin + s:xmax - s:10j] # Makes an 11x11 regular grid of knot locations yknots = np.linspace(ymin + s, ymax - s, 10) xknots = np.linspace(xmin + s, xmax - s, 10) xspline = interpolate.LSQBivariateSpline(xr, yr, xl, xknots.flat, yknots.flat) yspline = interpolate.LSQBivariateSpline(xr, yr, yl, xknots.flat, yknots.flat) def mapping(xr, yr): xl = xspline.ev(xr, yr) yl = yspline.ev(xr, yr) return xl, yl return mapping, xspline, yspline
def interp_beta(): """ We will interpolate based on reasonable values of the mean and std dev. For beta, -8 is pretty small on the log scale and 8 is quite large. Similarly, 0.001 is a very small std dev and 4 is a pretty big spread (on the log scale). :return: a stand in fn for interpolating the conjugate map """ # get the grid we will search ft_lb, ft_ub, qt_lb, qt_ub = -8, 8, 0.0001, 4 ft, qt = _get_grid(ft_lb, ft_ub, qt_lb, qt_ub) # do a bunch of solves z = np.empty((len(ft), 2)) for i in range(len(ft)): z[i, :] = np.log( bern_conjugate_params(ft[i], qt[i]**2, alpha=1, beta=1, interp=False)) # ft and qt knots num_knots = 75 ftv, qtv = np.sort(np.unique(ft)), np.sort(np.unique(qt)) # make sure there are a few points outside the knots ft_knots = np.linspace(ftv[3], ftv[-3], num_knots) qt_knots = np.exp(np.linspace(np.log(qtv[3]), np.log(qtv[-3]), num_knots)) bbox = [ft_lb - 2, ft_ub + 2, 0., qt_ub + 2] _interp_fn_log_alpha = interpolate.LSQBivariateSpline(ft, qt, z[:, 0], ft_knots, qt_knots, bbox=bbox, kx=1, ky=1) _interp_fn_log_beta = interpolate.LSQBivariateSpline(ft, qt, z[:, 1], ft_knots, qt_knots, bbox=bbox, kx=1, ky=1) # transform to original scale and variance instead of std dev fn = partial(transformer, fn1=_interp_fn_log_alpha, fn2=_interp_fn_log_beta) fn.ft_lb, fn.ft_ub, fn.qt_lb, fn.qt_ub = bbox return fn
def test_2d_make_lsq(ndspline): N = 500 sample_x = get_query_points(ndspline, n=N).squeeze() sample_y = ndspline(sample_x) for kx in range(2, 4): knots_x = np.r_[(0.0, ) * (kx + 1), 0.25, 0.5, 0.75, (1.0, ) * (kx + 1)] for ky in range(2, 4): knots_y = np.r_[(0.0, ) * (ky + 1), 0.25, 0.5, 0.75, (1.0, ) * (ky + 1)] knots = [knots_x, knots_y] # unweighted nspl = ndsplines.make_lsq_spline(sample_x, sample_y, knots, [kx, ky]) ispl = interpolate.LSQBivariateSpline(sample_x[:, 0], sample_x[:, 1], sample_y, knots_x[kx + 1:-kx - 1], knots_y[ky + 1:-ky - 1], bbox=[0., 1., 0., 1.], kx=kx, ky=ky) assert_allclose(ispl.get_knots()[0], nspl.knots[0]) assert_allclose(ispl.get_knots()[1], nspl.knots[1]) assert_allclose(nspl.coefficients.reshape(-1), ispl.get_coeffs().reshape(-1)) # random weights w = np.random.random(N) nspl = ndsplines.make_lsq_spline(sample_x, sample_y, knots, [kx, ky], w) ispl = interpolate.LSQBivariateSpline( sample_x[:, 0], sample_x[:, 1], sample_y, knots_x[kx + 1:-kx - 1], knots_y[ky + 1:-ky - 1], w=w, bbox=[0., 1., 0., 1.], kx=kx, ky=ky, ) assert_allclose(ispl.get_knots()[0], nspl.knots[0]) assert_allclose(ispl.get_knots()[1], nspl.knots[1]) assert_allclose(nspl.coefficients.reshape(-1), ispl.get_coeffs().reshape(-1))
def _spline_psf_model(paras): psfs, xs, ys, xvec, yvec = paras normalized_psfs_func_list = [] for wv_index in range(psfs.shape[-1]): # if 1:#np.isnan(psf_func(0,0)[0,0]): # model_psf = psfs[:,:, :, wv_index] # import matplotlib.pyplot as plt # from mpl_toolkits.mplot3d import Axes3D # fig = plt.figure(1) # ax = fig.add_subplot(111,projection="3d") # for k,color in zip(range(model_psf.shape[0]),["pink","blue","green","purple","orange"]): # ax.scatter(xs[k].ravel(),ys[k].ravel(),model_psf[k].ravel(),c=color) model_psf = psfs[:, :, :, wv_index].ravel() where_nans = np.where(np.isfinite(model_psf)) psf_func = interpolate.LSQBivariateSpline(xs.ravel()[where_nans], ys.ravel()[where_nans], model_psf[where_nans], xvec, yvec) # if 1: # print(psf_func(0,0)) # x_psf_vec, y_psf_vec = np.arange(2*nx_psf * 1.)/2.-nx_psf//2, np.arange(2*ny_psf* 1.)/2.-ny_psf//2 # x_psf_grid, y_psf_grid = np.meshgrid(x_psf_vec, y_psf_vec) # ax.scatter(x_psf_grid.ravel(),y_psf_grid.ravel(),psf_func(x_psf_vec,y_psf_vec).transpose().ravel(),c="red") # plt.show() normalized_psfs_func_list.append(psf_func) # print(len(normalized_psfs_func_list)) return normalized_psfs_func_list
def fit_spline( x, y, x_ref, knot_x=None, knot_y=None, num_knots=5, smooth=False, smooth_fac=None, weights=None, order=3): ''' performs spline fit of the form dx = f(x,y) knot_x/knot_y are 1-d arrays that are the x and y coordinates of knot locations ''' if knot_x == None: knot_x = np.linspace(np.min(x), np.max(x), num=num_knots) if knot_y == None: knot_y = np.linspace(np.min(y), np.max(y), num=num_knots) if not smooth: if smooth_fac == None: spline = interpolate.LSQBivariateSpline(x, y, x_ref, knot_x, knot_y, kx=order, ky=order, w=weights) x_new = spline.ev(x, y) else: spline = interpolate.LSQBivariateSpline(x, y, x_ref, knot_x, knot_y, kx=order, ky=order,w=weights, s=smooth_fac) x_new = spline.ev(x, y) else: spline = interpolate.SmoothBivariateSpline(x, y, x_ref, w=weights) x_new = spline.ev(x, y) return x_new, spline
nl_psf, ny_psf, nx_psf = psfs.shape x_psf_grid, y_psf_grid = np.meshgrid( np.arange(nx_psf * 1.) - nx_psf // 2, np.arange(ny_psf * 1.) - ny_psf // 2) psfs_func_list = [] psfs[np.where(np.isnan(psfs))] = 0 import warnings from scipy import interpolate with warnings.catch_warnings(): warnings.simplefilter("ignore") for wv_index in range(nl_psf): print(wv_index) model_psf = psfs[wv_index, :, :] psf_func = interpolate.LSQBivariateSpline( x_psf_grid.ravel(), y_psf_grid.ravel(), model_psf.ravel(), x_psf_grid[0, 0:nx_psf - 1] + 0.5, y_psf_grid[0:ny_psf - 1, 0] + 0.5) psfs_func_list.append(psf_func) ccmap = np.zeros((30, 10)) nycc, nxcc = ccmap.shape for k in range(nxcc): for l in range(nycc): print(k, l) #build model psf_model = np.zeros(nphpfinputs.shape) for z in range(nlall): center = centers[z // nl_psf] # x_grid, y_grid = np.meshgrid(np.arange(nxall * 1.)-center[0],np.arange(nyall* 1.)-center[1]) x_vec_centered = np.arange( nxall * 1.) - (center[0] + k - nxcc // 2)
def time_lsq_bivariate_spline(self, n_samples): interpolate.LSQBivariateSpline(self.x, self.y, self.z, self.xknots.flat, self.yknots.flat)
def __init__(self, inputs_shape, numbasis, sep, pa, dflux, input_psfs, input_wvs, flux_conversion=None, spectrallib=None, spectrallib_units="flux", star_spt=None, refine_fit=False): """ Defining the planet to characterizae Args: inputs_shape: shape of the inputs numpy array. Typically (N, y, x) numbasis: 1d numpy array consisting of the number of basis vectors to use sep: separation of the planet pa: position angle of the planet dflux: guess for contrast of planet averaged across band w.r.t star input_psfs: the psf of the image. A numpy array with shape (wv, y, x) input_wvs: the wavelegnths that correspond to the input psfs (doesn't need to be tiled to match the dimension of the input data of the instrument class) flux_conversion: an array of length N to convert from contrast to DN for each frame. Units of DN/contrast. If None, assumes dflux is the ratio between the planet flux and tthe input_psfs flux spectrallib: if not None, a list of spectra based on input_wvs spectrallib_units: can be either "flux"" or "contrast". Flux units requires dividing by the flux of the star to get contrast star_spt: star spectral type, if None default to some random one refine_fit: (NOT implemented) refine the separation and pa supplied """ # allocate super class super(FMPlanetPSF, self).__init__(inputs_shape, numbasis) self.inputs_shape = inputs_shape self.numbasis = numbasis self.sep = sep self.pa = pa self.dflux = dflux if spectrallib_units.lower() != "flux" and spectrallib_units.lower( ) != "contrast": raise ValueError( "spectrallib_units needs to be either 'flux' or 'contrast', not {0}" .format(spectrallib_units)) # only need spectral info if not broadband numwvs = np.size(input_wvs) if numwvs > 1: if spectrallib is not None: self.spectrallib = spectrallib else: spectra_folder = os.path.dirname(os.path.abspath( spec.__file__)) + os.sep + "spectra" + os.sep spectra_files = [spectra_folder + "t650g18nc.flx"] self.spectrallib = [ spec.get_planet_spectrum(filename, input_wvs)[1] for filename in spectra_files ] # TODO: calibrate to contrast units # calibrate spectra to DN if spectrallib_units.lower() == "flux": # need to divide by flux of the star to get contrast units self.spectrallib = [ spectrum / (spec.get_star_spectrum(input_wvs, star_type=star_spt)[1]) for spectrum in self.spectrallib ] self.spectrallib = [ spectrum / np.mean(spectrum) for spectrum in self.spectrallib ] else: self.spectrallib = [np.array([1])] self.input_psfs = input_psfs self.input_psfs_wvs = input_wvs if flux_conversion is None: flux_conversion = np.ones(inputs_shape[0]) self.flux_conversion = flux_conversion self.psf_centx_notscaled = {} self.psf_centy_notscaled = {} numwv, ny_psf, nx_psf = self.input_psfs.shape x_psf_grid, y_psf_grid = np.meshgrid( np.arange(nx_psf * 1.) - nx_psf // 2, np.arange(ny_psf * 1.) - ny_psf // 2) psfs_func_list = [] for wv_index in range(numwv): model_psf = self.input_psfs[ wv_index, :, :] #* self.flux_conversion * self.spectrallib[0][wv_index] * self.dflux #psfs_interp_model_list.append(interpolate.bisplrep(x_psf_grid,y_psf_grid,model_psf)) #psfs_interp_model_list.append(interpolate.SmoothBivariateSpline(x_psf_grid.ravel(),y_psf_grid.ravel(),model_psf.ravel())) psfs_func_list.append( interpolate.LSQBivariateSpline( x_psf_grid.ravel(), y_psf_grid.ravel(), model_psf.ravel(), x_psf_grid[0, 0:nx_psf - 1] + 0.5, y_psf_grid[0:ny_psf - 1, 0] + 0.5)) #psfs_interp_model_list.append(interpolate.interp2d(x_psf_grid,y_psf_grid,model_psf,kind="cubic",bounds_error=False,fill_value=0.0)) #psfs_interp_model_list.append(interpolate.Rbf(x_psf_grid,y_psf_grid,model_psf,function="gaussian")) if 0: import matplotlib.pylab as plt #print(x_psf_grid.shape) #print(psfs_interp_model_list[wv_index](x_psf_grid.ravel(),y_psf_grid.ravel()).shape) a = psfs_func_list[wv_index](x_psf_grid[0, :], y_psf_grid[:, 0]).transpose() plt.figure() plt.subplot(1, 3, 1) plt.imshow(a, interpolation="nearest") plt.colorbar() ##plt.imshow(psfs_interp_model_list[wv_index](np.linspace(-10,10,500),np.linspace(-10,10,500)),interpolation="nearest") plt.subplot(1, 3, 2) plt.imshow(self.input_psfs[wv_index, :, :], interpolation="nearest") plt.colorbar() plt.subplot(1, 3, 3) plt.imshow(abs(self.input_psfs[wv_index, :, :] - a), interpolation="nearest") plt.colorbar() plt.show() self.psfs_func_list = psfs_func_list
def plot_integral(values, start_date, end_date, smooth=True, smooth_type='LSQ-bspline'): """ Plot cumulative net worth values over time inputs ------- values : (np.array) of cumulative net worth over time. See calculate_gradients() start_date : (datetime.date) Start date of plotting This MUST be the same start_date used to calculate values end_date : (datetime.date) end date of plotting This MUST be the same end_date used to calculate values smooth : (bool) Apply smoothing to the 3D graph surface smooth_type : (str) one of ['bv-bspline','LSQ-bspline','Smooth-bspline', 'wiener']. The smoothing method to apply to the 3-d surface outputs ------- None """ msg = 'values should be numpy array, got {}' assert isinstance(values, np.ndarray), msg.format(type(values)) msg = 'date must be datetime.date, got {}' assert isinstance(start_date, datetime.date), msg.format(type(start_date)) assert isinstance(end_date, datetime.date), msg.format(type(end_date)) # Dates for labeling x axis delta = end_date - start_date dates = [(start_date + datetime.timedelta(days=i)) for i in range(delta.days)] #Apply b-spline fit to surface if smooth: if smooth_type == 'bv-bspline': x = np.arange(values.shape[0]) # Dates y = np.arange(values.shape[2]) # Probability xy, yx = np.meshgrid(x, y) xs = np.ravel(xy) ys = np.ravel(yx) # # Unpack in row-major order :) z = values[:, 0, :] zs = np.ravel(values[:, 0, :], order='F') """A sequence of length 5 returned by bisplrep containing the knot locations, the coefficients, and the degree of the spline: [tx, ty, c, kx, ky].""" s = sum(spline_smoothing_factor(xs.shape[0])) / 2 tck = interpolate.bisplrep(xs, ys, zs, s=s * 100, eps=1e-12) z3d = interpolate.bisplev(x, y, tck) elif smooth_type == 'LSQ-bspline': # Least squares bivariate spline approximation x = np.arange(values.shape[0]) # Dates y = np.arange(values.shape[2]) # Probability xy, yx = np.meshgrid(x, y) xs = np.ravel(xy) ys = np.ravel(yx) # # Unpack in row-major order :) z = values[:, 0, :] zs = np.ravel(values[:, 0, :], order='F') """Weighted least-squares bivariate spline approximation https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.LSQBivariateSpline.html""" # Find knots # Knots are the intervals polynomials are broken into. More knots # Mean a more precise spline # knots = np.linspace(start, end, n_knots) tx = np.linspace(0, x.shape[0], int(np.sqrt(2 * x.shape[0]))) ty = np.linspace(0, y.shape[0], int(np.sqrt(2 * x.shape[0]))) # Evaluate spline LSQBSpline = interpolate.LSQBivariateSpline(xs, ys, zs, tx, ty) z3d = LSQBSpline(x, y, grid=True) elif smooth_type == 'Smooth-bspline': # Smooth bivariate spline approximation x = np.arange(values.shape[0]) # Dates y = np.arange(values.shape[2]) # Probability xy, yx = np.meshgrid(x, y) xs = np.ravel(xy) ys = np.ravel(yx) # # Unpack in row-major order :) z = values[:, 0, :] zs = np.ravel(values[:, 0, :], order='F') """Smooth bivariate spline approximation see https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.SmoothBivariateSpline.html""" # s = sum(spline_smoothing_factor(xs.shape[0])) / 2 SmoothBSpline = interpolate.SmoothBivariateSpline(xs, ys, zs) z3d = SmoothBSpline(x, y, grid=True) elif smooth_type == 'wiener': # Smooth bivariate spline approximation x = np.arange(values.shape[0]) # Dates y = np.arange(values.shape[2]) # Probability xy, yx = np.meshgrid(x, y) z = values[:, 0, :] z3d = signal.wiener(z, mysize=(25, 1)) else: x = np.arange(values.shape[0]) y = np.arange(values.shape[2]) xy, yx = np.meshgrid(x, y) z3d = values[:, 0, :] # X labels - dates num_ticks = 4 tick_index = np.linspace(min(x), max(x), num=num_ticks, dtype=np.int16) xticks = x[tick_index] xlabel_index = tick_index xlabel_date = [dates[idx] for idx in xlabel_index] xlabels = [x.isoformat() for x in xlabel_date] # Y labels yticks = [int(y.shape[0] / 2)] ylabels = ['Worst → Best Case'] """2-dimensional plotting""" fig2d = plt.figure(1) ax2d = fig2d.add_subplot(111) z2d = values.mean(axis=2) line = ax2d.plot(x, z2d, label='Bank Value', linewidth=2) ax2d.set_title('Mean Value Non-smoothed') ax2d.set_xlabel('Date') ax2d.set_ylabel('Total Value [$]') ax2d.set_xticks(xticks) ax2d.set_xticklabels(xlabels) """3-dimensional plotting""" fig3d = plt.figure(2) ax3d = fig3d.add_subplot(111, projection='3d') surf = ax3d.plot_surface(xy, yx, z3d.transpose(), cmap='summer', linewidth=0, antialiased=False) # Label date axis ax3d.set_xticks(xticks) ax3d.set_xticklabels(xlabels) # Label probability axis ax3d.set_yticks(yticks) ax3d.set_yticklabels(ylabels) # Connect event to rotate probability axsi label rotateTickLabel = RotateTickLabel(ax3d.yaxis, ax3d) fig3d.canvas.mpl_connect('draw_event', rotateTickLabel) # Label value axis formatter = FuncFormatter(value_label_formatter) ax3d.zaxis.set_major_formatter(formatter) # ax3d.tick_params(pad=10) # Label axis fig3d.colorbar(surf, shrink=0.5, aspect=10) ax3d.set_title('Value, Time, Risk') ax3d.set_xlabel('Date', labelpad=15) ax3d.set_zlabel('Total Value [$]', labelpad=10) # Elev is in z plane, azim is in x,y plane ax3d.view_init(elev=20, azim=125) for angle in range(100, 125): ax3d.view_init(elev=20, azim=angle) plt.draw() plt.pause(0.003) plt.show() return None
z_hst_lngth = np.max(XZarr[:, 1]) - np.min(XZarr[:, 1]) # Calculate knots (t) needed for LSQBivariateSpline t_XZ = np.linspace( np.min(XZarr[:, 0]) + 0.1 * x_hst_lngth, np.max(XZarr[:, 0]) - 0.1 * x_hst_lngth, 11) t_YZ = np.linspace( np.min(YZarr[:, 0]) + 0.1 * y_hst_lngth, np.max(YZarr[:, 0]) - 0.1 * y_hst_lngth, 11) t_ZZ = np.linspace( np.min(XZarr[:, 1]) + 0.1 * z_hst_lngth, np.max(XZarr[:, 1]) - 0.1 * z_hst_lngth, 11) # Interpolate using LSQBivariateSpline, hash if want to use Interp2D f_Dens_XZ = interpolate.LSQBivariateSpline(XZarr[:, 0].ravel(), XZarr[:, 1].ravel(), XZarr[:, 2].ravel(), t_XZ, t_ZZ) f_Dens_YZ = interpolate.LSQBivariateSpline(YZarr[:, 0].ravel(), YZarr[:, 1].ravel(), YZarr[:, 2].ravel(), t_YZ, t_ZZ) # Interpolate using Interp2D - unhash if want to use instead of LSQ #f_Dens_XZ=interpolate.interp2d(XZarr[:,0].ravel(), XZarr[:,1].ravel(),XZarr[:,2].ravel()) #f_Dens_YZ=interpolate.interp2d(YZarr[:,0].ravel(), YZarr[:,1].ravel(),YZarr[:,2].ravel()) #*****Plot the density profile XZ,YZ # Create data for plot PLT_X = np.linspace( min(mA_X) - S_factor * size_x, max(mA_X) + S_factor * size_x, 100) PLT_Y = np.linspace(
from scipy import interpolate # Load data from 'HeVexpEHe.dat' # x = col[0], y = col[1], z = col[2] x, y, z = loadtxt('HeVexpEHe.dat', usecols = (0,1,2) , unpack=True) # Smooth bivariate spline approximation # kx, ky are the degrees of the bivariate spline in the x and y direction respectively zsfit5 = interpolate.SmoothBivariateSpline(x,y,z,kx=5,ky=5) # Spline approximation evaluated at x,y speval5 = zsfit5.ev(x,y) # Least-squares bivariate spline approximation with specified 1D sequences of knot coordinates xknots1 = array([0,1,240,249,250]) yknots1 = array([0,1,40,49,50]) lsqzs1fit5 = interpolate.LSQBivariateSpline(x,y,z,xknots1.flat,yknots1.flat,kx=5,ky=5) lsqev1 = lsqzs1fit5.ev(x,y) xknots2 = array([0,1,40,75,183,194,222,231,250]) yknots2 = array([0,1,5,11,43,45,46,47,50]) lsqzs2fit5 = interpolate.LSQBivariateSpline(x,y,z,xknots2.flat,yknots2.flat,kx=5,ky=5) lsqev2 = lsqzs2fit5.ev(x,y) xknots3 = array([0,1,14,125,165,184,219,220,223,225,231,232,239,241,250]) yknots3 = array([0,1,11,24,25,30,43,45,46,47,48,49,50]) lsqzs3fit5 = interpolate.LSQBivariateSpline(x,y,z,xknots3.flat,yknots3.flat,kx=5,ky=5) lsqev3 = lsqzs3fit5.ev(x,y) #PLOT 3D FIGURE fig = plt.figure() rect = fig.add_subplot(2,2,1).get_position()
#print smap(xr, yr) plt.plot(xl) plt.plot(xr) #plt.show() xsp = interpolate.SmoothBivariateSpline(xr, yr, xl, kx=2, ky=2) print xsp.get_knots() #example from tests, testfitpack.py x = [1, 1, 1, 2, 2, 2, 3, 3, 3] y = [1, 2, 3, 1, 2, 3, 1, 2, 3] z = [3, 3, 4, 4, 5, 6, 3, 3, 3] s = 0.1 tx = [1 + s, 3 - s] ty = [1 + s, 3 - s] lut = interpolate.LSQBivariateSpline(x, y, z, tx, ty, kx=1, ky=1) import numpy as np from scipy import interpolate import matplotlib.pyplot as plt #2d spline interpolation example from the tutorial #------------------------------------------------- # Define function over sparse 20x20 grid x, y = np.mgrid[-1:1:20j, -1:1:20j] z = (x + y) * np.exp(-6.0 * (x * x + y * y)) plt.figure() plt.pcolor(x, y, z)
def __init__(self, inputs_shape, numbasis, sep, pa, input_psfs, input_psfs_wvs, datatype="float", stamp_size=None): """ Defining the planet to characterizae Args: inputs_shape: shape of the inputs numpy array. Typically (N, y, x) numbasis: 1d numpy array consisting of the number of basis vectors to use sep: separation of the planet pa: position angle of the planet input_psfs: the psf of the image. A numpy array with shape (wv, y, x) input_psfs_wvs: the wavelegnths that correspond to the input psfs flux_conversion: an array of length N to convert from contrast to DN for each frame. Units of DN/contrast wavelengths: wavelengths of data. Can just be a string like 'H' for H-band spectrallib: if not None, a list of spectra star_spt: star spectral type, if None default to some random one refine_fit: refine the separation and pa supplied """ # allocate super class super(ExtractSpec, self).__init__(inputs_shape, np.array(numbasis)) if stamp_size is None: self.stamp_size = 10 else: self.stamp_size = stamp_size if datatype == "double": self.data_type = ctypes.c_double elif datatype == "float": self.data_type = ctypes.c_float self.N_numbasis = np.size(numbasis) self.ny = self.inputs_shape[1] self.nx = self.inputs_shape[2] self.N_frames = self.inputs_shape[0] self.inputs_shape = inputs_shape self.numbasis = numbasis self.sep = sep self.pa = pa self.input_psfs = input_psfs self.input_psfs_wvs = list( np.array(input_psfs_wvs, dtype=self.data_type)) self.nl = np.size(input_psfs_wvs) #self.flux_conversion = flux_conversion # Make sure the peak value is unity for all wavelengths self.sat_spot_spec = np.nanmax(self.input_psfs, axis=(1, 2)) self.aper_over_peak_ratio = np.zeros(np.size(self.input_psfs_wvs)) for l_id in range(self.input_psfs.shape[0]): self.aper_over_peak_ratio[l_id] = np.nansum( self.input_psfs[l_id, :, :]) / self.sat_spot_spec[l_id] self.input_psfs[l_id, :, :] = self.input_psfs[ l_id, :, :] / np.nansum(self.input_psfs[l_id, :, :]) self.nl, self.ny_psf, self.nx_psf = self.input_psfs.shape self.psf_centx_notscaled = {} self.psf_centy_notscaled = {} numwv, ny_psf, nx_psf = self.input_psfs.shape x_psf_grid, y_psf_grid = np.meshgrid( np.arange(nx_psf * 1.) - nx_psf / 2, np.arange(ny_psf * 1.) - ny_psf / 2) psfs_func_list = [] for wv_index in range(numwv): model_psf = self.input_psfs[ wv_index, :, :] #* self.flux_conversion * self.spectrallib[0][wv_index] * self.dflux psfs_func_list.append( interpolate.LSQBivariateSpline( x_psf_grid.ravel(), y_psf_grid.ravel(), model_psf.ravel(), x_psf_grid[0, 0:nx_psf - 1] + 0.5, y_psf_grid[0:ny_psf - 1, 0] + 0.5)) self.psfs_func_list = psfs_func_list
def flux_model(raw_tar_catalogue, filtered_ref_catalogue, options): """ Take the raw target and reference catalogue, do a quick and dirty cross match of the two with only high snr (10) target sources. Construct a 2D polynomial model of the flux correction factor across the field of sources. :param raw_tar_catalogue: the target catalogue :param filtered_ref_catalogue: the reference catalogue filtered for sources within the RA and DEC range of the target catalogue :return: flux correction factor model to apply to target catalogue """ #filter for snr>10 sources snr_filter = np.where((raw_tar_catalogue['peak_flux'] / raw_tar_catalogue['local_rms']) >= 10) tar_catalogue = raw_tar_catalogue[snr_filter] #we want quite a tight match limiting_res = 118.0 / 3600.0 * u.degree ref_cat = SkyCoord(filtered_ref_catalogue['ra'], filtered_ref_catalogue['dec'], unit=u.degree, frame='icrs') tar_cat = SkyCoord(tar_catalogue['ra'], tar_catalogue['dec'], unit=u.degree, frame='icrs') gross_matched_idx, gross_matched_sep, dum = tar_cat.match_to_catalog_sky( ref_cat) tar_cat_matched_within_resolution = tar_catalogue[np.where( gross_matched_sep <= limiting_res)] ref_cat_matched_within_resolution = filtered_ref_catalogue[ gross_matched_idx][np.where(gross_matched_sep <= limiting_res)] #get our fluxes and ratios for the target and reference catalogues reference_flux = ref_cat_matched_within_resolution['peak_flux'] flux_ratio = tar_cat_matched_within_resolution['peak_flux'] / reference_flux #use a polynomial 2D model for the field of sources resulting_model = interpolate.LSQBivariateSpline( tar_cat_matched_within_resolution['ra'], tar_cat_matched_within_resolution['dec'], flux_ratio, [ min(tar_cat_matched_within_resolution['ra']), max(tar_cat_matched_within_resolution['ra']) ], [ min(tar_cat_matched_within_resolution['dec']), max(tar_cat_matched_within_resolution['dec']) ], kx=options.flux_model_deg, ky=options.flux_model_deg) if options.plotting == True: #plot resulting model for user x = tar_cat_matched_within_resolution['ra'] y = tar_cat_matched_within_resolution['dec'] xi = np.linspace(min(x), max(x), 100) yi = np.linspace(min(y), max(y), 100) zi = interpolate.griddata((x, y), flux_ratio, (xi[None, :], yi[:, None]), method='cubic') x = np.linspace(min(tar_catalogue['ra']), max(tar_catalogue['ra']), 100) y = np.linspace(min(tar_catalogue['dec']), max(tar_catalogue['dec']), 100) X, Y = np.meshgrid(x, y) solution = resulting_model.ev(X, Y) solution_masked = np.ma.masked_array(solution, mask=np.isnan(zi)) plot = plt.imshow(solution_masked) plt.colorbar(plot) plt.savefig('Flux_correction_model' + options.save_file_suffix + '.png') plt.close() return resulting_model
# remove nan - Fluxes BFullFs_rm = np.copy(BFullFs) # print('... remove isolated points (3 sided)') # skip_inds3a = remove_indexes(BFullFs_rm, ygrid, xgrid, FullYs, FullXs, size, 3) # BFullFs_rm[skip_inds3a] = np.nan # print('... remove isolated points (4 sided)') # skip_inds4a = remove_indexes(BFullFs_rm, ygrid, xgrid, FullYs, FullXs, size, 4) # BFullFs_rm[skip_inds4a] = np.nan nan_inds = np.where(np.isfinite(BFullFs_rm))[0] print(len(nan_inds)) print('... running spline fit') time1 = datetime.now() SplineFit = interpolate.LSQBivariateSpline(xfull[nan_inds], yfull[nan_inds], BFullFs_rm[nan_inds], knot_grid, knot_grid, kx=3, ky=3 ) time2 = datetime.now() print(' spline time: ', time2 - time1) #### ## fill in gaps #round 1 print('~~ finding gaps, round 1') interp_addi = interp_indexes(BFullFs_rm, ygrid, xgrid, FullYs, FullXs, size, gap,frac) interp_inds = np.sort(np.append(nan_inds, interp_addi)) TempGrid = SplineFit.ev(xfull[interp_inds],yfull[interp_inds]) TempFull = np.empty([size*size])*np.nan TempFull[interp_inds] = TempGrid
def interpolate_g(xi, yi, zi, xx, yy, knots=10, error=False, mask=None): """Create a grid of zi values interpolating the values from xi,yi,zi **ARGUMENTS** ========= ================================================================== xi,yi,zi 1D Lists or arrays containing the values to use as base for the interpolation xx,yy 1D vectors or lists containing the output coordinates samples tuple containing the shape of the output array. knots number of knots to be used in each direction error if set to true, half of the points (x, y, z) are used to create the interpolation, and half are used to evaluate the interpolation error ========= ================================================================== """ xi = array(xi) yi = array(yi) zi = array(zi) #print xi #print yi #print zi assert xi.ndim == 1, "xi must ba a 1D array or list" assert yi.ndim == 1, "yi must ba a 1D array or list" assert zi.ndim == 1, "zi must ba a 1D array or list" assert xx.ndim == 1, "xx must ba a 1D array or list" assert yy.ndim == 1, "yy must ba a 1D array or list" assert len(xi) == len(yi) and len(xi) == len( zi), "xi, yi, zi must have the same number of items" if error == True: # Create a list of indexes to be able to select the points that are going # to be used as spline generators, and as control points idx = where(arange(len(xi)) % 2 == 0, False, True) # Use only half of the samples to create the Spline, if error == True: isp = argwhere(idx == True) ich = argwhere(idx == False) xsp = xi[isp] ysp = yi[isp] zsp = zi[isp] xch = xi[ich] ych = yi[ich] zch = zi[ich] else: xsp = xi ysp = yi zsp = zi #Distribute homogeneously the knots xk = linspace(xsp.min(), xsp.max(), knots) yk = linspace(ysp.min(), ysp.max(), knots) # LSQBivariateSpline using some knots gives smaller error than # SmoothBivariateSpline di = interpolate.LSQBivariateSpline(xsp, ysp, zsp, xk[1:-1], yk[1:-1]) #print xsp,ysp,zsp #di=interpolate.SmoothBivariateSpline(xsp, ysp, zsp) # Evaluate error if error == True: zch1 = di.ev(xch, ych) er = (zch.flatten() - zch1).std() if mask == None: #d=griddata(xi, yi, zi, xx, yy) # d = di(xx, yy).transpose() else: d = ma_array(di(xx, yy).transpose(), mask=mask) if error == True: return d, er else: return d
def upsample2DDens(x, y, wghts, bnx0, bny0, S_factor, plotbasename=False): # Merge XZ and YZ into common array to allow creation of 2D histogram data for XZ and YZ planes xy = np.vstack((x.flat, y.flat)).T lenx = np.amax(x) - np.amin(x) leny = np.amax(y) - np.amin(y) #HxHz,edges_XZ = np.histogramdd(m_Xm_Z, bins = (binnumber_X,binnumber_Z),range=((min(mA_X)-S_factor*size_x,max(mA_X)+S_factor*size_x),(min(mA_Z)-S_factor*size_z,max(mA_Z)+S_factor*size_z)),normed=False,weights=m_WGHT) # Crate histogram for XZ and YZ planes and stretch it using S_factor variable HxHy, edges_XY = np.histogramdd(xy, bins=(bnx0, bny0), range=((min(x) - S_factor * lenx, max(x) + S_factor * lenx), (min(y) - S_factor * leny, max(y) + S_factor * leny)), normed=False, weights=wghts) # HxHz = ndimage.gaussian_filter(HxHz,1.50) if (not plotbasename): qplots = False else: qplots = True if (qplots): XL, YL = np.meshgrid(edges_XY[0], edges_XY[1]) zyplot = plt.subplot(111) zyplot.pcolormesh(XL, YL, HxHy) #plt.show() plt.savefig(plotbasename + '-ORIG.png') plt.clf() lexz = len(edges_XY[0]) - 1 lexz2 = len(edges_XY[1]) - 1 XYarr = np.zeros((lexz * lexz2, 3)) # Convert XZ/YZ density histograms to XZ_Density/YZ_Density arrays (move the histogram to array like: Value,X,Y,Z) for zz in range(1, len(edges_XY[1])): for xx in range(1, len(edges_XY[0])): XYarr[(xx - 1) + (zz - 1) * lexz, 0] = (edges_XY[0][xx] + edges_XY[0][xx - 1]) * 0.5 XYarr[(xx - 1) + (zz - 1) * lexz, 1] = (edges_XY[1][zz] + edges_XY[1][zz - 1]) * 0.5 XYarr[(xx - 1) + (zz - 1) * lexz, 2] = HxHy[xx - 1, zz - 1] #*** INTERPOLATE XZ AND YZ PLANES USING 2D FUNCTION # Calculate the length of X,Y,Z histogram for fitting x_hst_lngth = np.max(XYarr[:, 0]) - np.min(XYarr[:, 0]) y_hst_lngth = np.max(XYarr[:, 1]) - np.min(XYarr[:, 1]) # Calculate knots (t) needed for LSQBivariateSpline t_XY = np.linspace( np.min(XYarr[:, 0]) + 0.1 * x_hst_lngth, np.max(XYarr[:, 0]) - 0.1 * x_hst_lngth, 25) t_YY = np.linspace( np.min(XYarr[:, 1]) + 0.1 * y_hst_lngth, np.max(XYarr[:, 1]) - 0.1 * y_hst_lngth, 25) # Interpolate using LSQBivariateSpline, hash if want to use Interp2D f_Dens_XY = interpolate.LSQBivariateSpline(XYarr[:, 0].ravel(), XYarr[:, 1].ravel(), XYarr[:, 2].ravel(), t_XY, t_YY) if (qplots): PLT_X = np.linspace( min(x) - S_factor * lenx, max(x) + S_factor * lenx, 2500) PLT_Y = np.linspace( min(y) - S_factor * leny, max(y) + S_factor * leny, 2500) zxplot = plt.subplot(111) zxplot.pcolormesh(PLT_Y, PLT_X, f_Dens_XY(PLT_X, PLT_Y)) #plt.show() plt.savefig(plotbasename + '-UPSAMPLED.png') plt.clf() return f_Dens_XY