def rebin_data(self, grid, use_psf=True): """Calculates the center of mass of the grid and then rebins so that the center pixel really is the center of the array For this we do a 2-d interpolation on the grid """ a = psf_fitter.psffit(abs(grid), circle=False, rotate=1) xcen = a[2] ycen = a[2] xlen, ylen = grid.shape xval = arange(xlen) yval = arange(ylen) xint = interp1d(xval, self.xpos_abs) yint = interp1d(yval, self.ypos_abs) xintcen = self.xmax_pos-xint(xcen) yintcen = self.ymax_pos-yint(ycen) print self.xmax_pos, xintcen, self.ymax_pos, yintcen f_real = interp2d(self.xpos_rel, self.ypos_rel, real(grid)) f_imag = interp2d(self.xpos_rel, self.ypos_rel, imag(grid)) xnew = self.xpos_rel - xintcen ynew = self.ypos_rel - yintcen recen_grid = f_real(xnew, ynew) + 1j*f_imag(xnew, ynew) print nd.center_of_mass(abs(recen_grid)) return recen_grid
def ijcoast(coast, grd): if type(grd).__name__ == "ROMS_Grid": lon = grd.hgrid.lon_vert lat = grd.hgrid.lat_vert if type(grd).__name__ == "CGrid_geo": lon = grd.lon_vert lat = grd.lat_vert ijcoast = [] for k in range(coast.shape[0]): if np.isnan(coast[k, 0]): ijcoast.append([np.nan, np.nan]) else: iindex, jindex = find_nearestgridpoints(coast[k, 0], coast[k, 1], grd, Cpos="vert") if iindex: i, j = np.meshgrid(iindex, jindex) x = lon[j, i] y = lat[j, i] funct_i = interpolate.interp2d(x.flatten(), y.flatten(), i.flatten()) funct_j = interpolate.interp2d(x.flatten(), y.flatten(), j.flatten()) i_coast = funct_i(coast[k, 0], coast[k, 1])[0] j_coast = funct_j(coast[k, 0], coast[k, 1])[0] ijcoast.append([i_coast, j_coast]) return np.array(ijcoast)
def __init__(self, textureData): cols = len(textureData[0]) rows = len(textureData) self.cols = cols self.rows = rows indicators = np.empty_like(textureData) for i in range(rows): for j in range(cols): if textureData[i][j] == -1: indicators[i][j] = 1.0 else: indicators[i][j] = 0.0 marginX = 1.0/(2.0 * cols) marginY = 1.0/(2.0 * rows) x = np.linspace(marginX, 1.0-marginX, cols) y = np.linspace(marginY, 1.0-marginY, rows) self.indicator = interpolate.interp2d(x, y, indicators, kind='linear') data = textureData data = np.vstack((data[0], data)) data = np.vstack((data, data[-1])) data = np.column_stack((data[:,0],data)) data = np.column_stack((data, data[:,-1])) self.textureData = data x = np.linspace(-marginX, 1.0+marginX, cols+2) y = np.linspace(-marginY, 1.0+marginY, rows+2) self.f = interpolate.interp2d(x, y, data, kind='linear')
def applyInterpolatedNoise(image, targets, noise_factor=10, stride=64): size = image.shape[0] x = np.arange(0, size, stride) y = np.arange(0, size, stride) interp_size = x.shape[0] delta_x = np.random.normal(scale=noise_factor, size=(interp_size, interp_size)) delta_y = np.random.normal(scale=noise_factor, size=(interp_size, interp_size)) f_x = interpolate.interp2d(x, y, delta_x, kind='cubic') f_y = interpolate.interp2d(x, y, delta_y, kind='cubic') noise_x = f_x(np.arange(0, size), np.arange(0, size)) noise_y = f_y(np.arange(0, size), np.arange(0, size)) grid_x = np.asarray([range(size)]*size) grid_y = np.asarray([size*[i] for i in range(size)]) x_jitter = grid_x + noise_x y_jitter = grid_y + noise_y labels = [None for t in range(targets.shape[0])] for t in range(targets.shape[0]): labels[t] = lookupNearest(targets[t, :, :], x_jitter, y_jitter) return bilinear_interpolate(image, x_jitter, y_jitter), labels
def refine_data(lon, lat, f, refine): lon = lon[0, :] lat = lat[:, 0] dlon = lon[1] - lon[0] dlat = lat[1] - lat[0] lat_hi = np.arange(lat[0],lat[-1],dlat/refine) lon_hi = np.arange(lon[0],lon[-1],dlon/refine) nx = len(lon_hi) ny = len(lat_hi) a = np.array(f.mask).astype(int) f[np.isnan(f)] = 100000 ipol = interp2d(lon, lat, f) apol = interp2d(lon, lat, a) f = ipol(lon_hi, lat_hi) a = apol(lon_hi, lat_hi) f = np.ma.masked_where(a>.2, f) lon_hi, lat_hi = np.meshgrid(lon_hi, lat_hi) return lon_hi, lat_hi, f
def interpolate_isentropic_T_rho_Vp_Vs(T_ref, filename): pressures, temperatures, property_array = table_from_tab(filename) s, rho, vp, vs = property_array entropy = interpolate.interp2d(pressures, temperatures, s, kind='linear') density = interpolate.interp2d(pressures, temperatures, rho, kind='linear') v_p = interpolate.interp2d(pressures, temperatures, vp, kind='linear') v_s = interpolate.interp2d(pressures, temperatures, vs, kind='linear') S_ref = entropy(pressures.min(), T_ref) if isnan(S_ref): print('Oh no! For some reason the entropy interpolation on your perplex file returns NaN at the minimum pressure.') print('Conditions: P='+str(pressures.min()/1.e5)+' bar, T='+str(T_ref)+' K.') exit() adiabatic_temperatures = np.empty_like(pressures) adiabatic_densities = np.empty_like(pressures) adiabatic_Vps = np.empty_like(pressures) adiabatic_Vss = np.empty_like(pressures) for i, s_p in enumerate(zip(*s)): entropy_slice = interpolate.interp1d(s_p, temperatures, kind='linear') adiabatic_temperatures[i] = entropy_slice(S_ref) adiabatic_densities[i] = density(pressures[i], adiabatic_temperatures[i]) adiabatic_Vps[i] = v_p(pressures[i], adiabatic_temperatures[i]) adiabatic_Vss[i] = v_s(pressures[i], adiabatic_temperatures[i]) adiabat_density = interpolate.interp1d(pressures, adiabatic_densities, kind='linear') adiabat_Vp = interpolate.interp1d(pressures, adiabatic_Vps, kind='linear') adiabat_Vs = interpolate.interp1d(pressures, adiabatic_Vss, kind='linear') adiabat_temperature = interpolate.interp1d(pressures, adiabatic_temperatures, kind='linear') return adiabat_temperature, adiabat_density, adiabat_Vp, adiabat_Vs
def get_translate(workdir=None): filename = os.path.join(workdir, "Vicalloy/Fe-Co-V_140922a_META_DATA.csv") compdata_f = pd.read_csv(filename, sep='\t').dropna() print compdata_f.head() x = compdata_f["Xnom (mm)"].values y = compdata_f["Ynom (mm)"].values Co_concentration = compdata_f["Co (at%)"].values Fe_concentration = compdata_f["Fe (at%)"].values V_concentration = compdata_f["V (at%)"].values method = 'linear' # method = 'nearest' with warnings.catch_warnings(): warnings.simplefilter("ignore") Co_concI = interp2d(x,y,Co_concentration, kind = method) Fe_concI = interp2d(x,y,Fe_concentration, kind = method) V_concI = interp2d(x,y,V_concentration , kind = method) def translate(key): manip_z, manip_y = key sample_y = manip_z - 69.5 sample_x = (manip_y +8) *2 Co = Co_concI(sample_x,sample_y)[0]/100. Fe = Fe_concI(sample_x,sample_y)[0]/100. V = V_concI(sample_x,sample_y)[0]/100. return ( "Fe{:.2f}Co{:.2f}V{:.2f}".format(Fe,Co,V), sample_x, sample_y ) return translate
def cdcl(v, nrpm): """Gives the value of the drag and lift coefficients as function of velocity and spin. Is only valid for velocities between 13.7 and 88.1 m/s, and spins between 2000 and 6000 rpm. The value is determined with linear interpolation of the data given by Bearman and Harvey, Golf Ball Aerodynamics, volume 27, Aeronautival Quarterly, 1976.""" from numpy import array, linspace from scipy.interpolate import interp2d import sys if (v<13.7 or v>88.1): sys.exit('v is out of bounds. Must be between 13.7 and 88.41 m/s.') return if (nrpm<2000 or nrpm>6000): sys.exit('nrpm is out of bounds. Must be between 2000 and 6000 rpm.') return v0 = array([13.7, 21.6, 29.9, 38.4, 46.9, 55.2, 63.1, 71.9, 80.2, 88.1]) nrpm0 = linspace(2000,6000,21) CD = array([[0.3624,0.2885,0.2765,0.2529,0.2472,0.2481,0.2467,0.2470,0.2470,0.2470],[0.3806,0.3102,0.2853,0.2590,0.2507,0.2498,0.2485,0.2486,0.2484,0.2484],[0.3954,0.3288,0.2937,0.2649,0.2543,0.2516,0.2504,0.2502,0.2497,0.2497],[0.4070,0.3443,0.3018,0.2708,0.2580,0.2535,0.2522,0.2518,0.2511,0.2511],[0.4153,0.3566,0.3095,0.2765,0.2617,0.2556,0.2541,0.2534,0.2524,0.2524],[0.4203,0.3658,0.3169,0.2822,0.2655,0.2578,0.2560,0.2550,0.2538,0.2538],[0.4120,0.3719,0.3240,0.2876,0.2693,0.2602,0.2579,0.2566,0.2551,0.2551],[0.3960,0.3749,0.3308,0.2930,0.2732,0.2627,0.2599,0.2582,0.2565,0.2565],[0.3876,0.3766,0.3372,0.2983,0.2772,0.2653,0.2619,0.2598,0.2578,0.2578],[0.4100,0.3854,0.3433,0.3034,0.2811,0.2681,0.2639,0.2614,0.2592,0.2592],[0.4288,0.4003,0.3490,0.3084,0.2852,0.2710,0.2659,0.2630,0.2605,0.2605],[0.4445,0.4082,0.3544,0.3133,0.2893,0.2741,0.2680,0.2646,0.2619,0.2619],[0.4575,0.4153,0.3595,0.3180,0.2934,0.2772,0.2701,0.2662,0.2632,0.2632],[0.4682,0.4215,0.3643,0.3227,0.2976,0.2806,0.2722,0.2678,0.2646,0.2646],[0.4772,0.4269,0.3687,0.3272,0.3019,0.2840,0.2743,0.2694,0.2659,0.2659],[0.4848,0.4314,0.3728,0.3316,0.3062,0.2876,0.2765,0.2710,0.2673,0.2673],[0.4914,0.4350,0.3765,0.3358,0.3105,0.2913,0.2787,0.2726,0.2686,0.2686],[0.4976,0.4377,0.3799,0.3400,0.3149,0.2952,0.2809,0.2742,0.2700,0.2700],[0.5039,0.4395,0.3830,0.3440,0.3194,0.2992,0.2831,0.2758,0.2713,0.2713],[0.5105,0.4405,0.3858,0.3479,0.3239,0.3034,0.2854,0.2774,0.2727,0.2727],[0.5180,0.4406,0.3882,0.3517,0.3285,0.3076,0.2877,0.2790,0.2740,0.2740]]) CL = array([[0.1040,0.1846,0.2460,0.1984,0.1762,0.1538,0.1418,0.1360,0.1280,0.1276],[0.1936,0.2318,0.2590,0.2089,0.1824,0.1603,0.1476,0.1405,0.1321,0.1324],[0.2608,0.2694,0.2715,0.2191,0.1886,0.1668,0.1533,0.1450,0.1362,0.1367],[0.3090,0.2986,0.2835,0.2289,0.1949,0.1731,0.1589,0.1494,0.1403,0.1404],[0.3418,0.3205,0.2947,0.2384,0.2011,0.1794,0.1646,0.1539,0.1444,0.1436],[0.3624,0.3362,0.3049,0.2475,0.2073,0.1856,0.1702,0.1584,0.1485,0.1464],[0.3743,0.3470,0.3140,0.2562,0.2135,0.1916,0.1757,0.1629,0.1526,0.1488],[0.3808,0.3541,0.3217,0.2644,0.2197,0.1976,0.1813,0.1673,0.1567,0.1508],[0.3854,0.3584,0.3280,0.2722,0.2259,0.2035,0.1868,0.1718,0.1608,0.1524],[0.3915,0.3614,0.3325,0.2795,0.2322,0.2092,0.1923,0.1763,0.1649,0.1539],[0.4005,0.3640,0.3347,0.2862,0.2384,0.2149,0.1977,0.1807,0.1690,0.1582],[0.4010,0.3696,0.3380,0.2925,0.2446,0.2205,0.2032,0.1852,0.1731,0.1624],[0.4026,0.3748,0.3412,0.2982,0.2508,0.2259,0.2086,0.1897,0.1772,0.1666],[0.4050,0.3797,0.3440,0.3033,0.2570,0.2313,0.2139,0.1941,0.1813,0.1707],[0.4084,0.3845,0.3468,0.3078,0.2632,0.2366,0.2193,0.1986,0.1854,0.1749],[0.4130,0.3894,0.3496,0.3119,0.2695,0.2418,0.2246,0.2031,0.1895,0.1791],[0.4192,0.3947,0.3527,0.3149,0.2757,0.2469,0.2298,0.2076,0.1936,0.1833],[0.4271,0.4004,0.3563,0.3184,0.2819,0.2518,0.2351,0.2120,0.1977,0.1875],[0.4371,0.4069,0.3607,0.3233,0.2881,0.2567,0.2403,0.2165,0.2018,0.1916],[0.4494,0.4143,0.3660,0.3300,0.2943,0.2615,0.2455,0.2210,0.2059,0.1958],[0.4644,0.4227,0.3724,0.3393,0.3005,0.2662,0.2507,0.2254,0.2100,0.2000]]) cd = interp2d(v0, nrpm0, CD, kind='linear') cl = interp2d(v0, nrpm0, CL, kind='linear') return cd(v, nrpm), cl(v, nrpm)
def __init__(self,folder,T_unit='C',S_unit = 'kg/kg'): self.name = 'Liu' self.folder = folder self.T_unit = T_unit self.S_unit = S_unit #Simple dictionary for converting units of temperature and salinity #Pressure will always be in MPa self.S_multiply = {'kg/kg': 1.0, 'ppt': 0.001, 'wt. %': 0.01}#Liu calculation is in kg/kg self.T_add = {'K': -273.15, 'C': 0.0, 'F': 32}#Liu calculation is in C self.T_multiply = {'K': 1.0, 'C': 1.0, 'F': 5.0/9.0}#Liu calculation is in C #Load calculated dissociation pressure from file P_file = self.folder + 'Liu_method_Pmat.csv' A = np.loadtxt(P_file,delimiter=',') Temp = A[1:,0]#Celsius Sal = A[0,1:]#kg/kg Peq = A[1:,1:]#MPa self.P_func = interpolate.interp2d(Sal,Temp,Peq,kind='cubic') #Load calculated dissociation salinity from file S_file = self.folder + 'Liu_method_Smat.csv' B = np.loadtxt(S_file,delimiter=',') Pres = B[1:,0]#Celsius Temp2 = B[0,1:]#MPa Seq = B[1:,1:]*self.S_multiply[self.S_unit]#kg/kg Seq[Seq<1e-3]=0 self.S_func = interpolate.interp2d(Temp2,Pres,Seq,kind='cubic')
def driftcorr(A, ux, uy, interpolation='cubic'): ''' drift correction on 2D image or 3D DOS map, use ux, uy calculated by driftmap. Crop edges of A_corr if needed. interpolation: 'linear', 'cubic' or 'quintic'. Default is 'cubic' ''' A_corr = np.zeros_like(A) s = A.shape[-1] t = np.arange(s, dtype='float') x, y = np.meshgrid(t, t) xnew = (x - ux).ravel() ynew = (y - uy).ravel() tmp = np.zeros(s**2) if len(A.shape) is 2: tmp_f = interp2d(t, t, A, kind=interpolation) for ix in range(tmp.size): tmp[ix] = tmp_f(xnew[ix], ynew[ix]) A_corr = tmp.reshape(s, s) return A_corr elif len(A.shape) is 3: for iz, layer in enumerate(A): tmp_f = interp2d(t, t, layer, kind=interpolation) for ix in range(tmp.size): tmp[ix] = tmp_f(xnew[ix], ynew[ix]) A_corr[iz] = tmp.reshape(s, s) print('Processing slice %d/%d...'%(iz+1, A.shape[0]), end='\r') return A_corr else: print('ERR: Input must be 2D or 3D numpy array!')
def __init__(self, filename): nc = Dataset(filename) self.debug_mode = 1. print self.debug_mode self.dt = nc.variables["time"][1]-nc.variables["time"][0] self.xlon = nc.variables["xlon"][:] self.xlat = nc.variables["xlat"][:] N_lon = self.xlon.shape[1] N_lat = self.xlat.shape[0] #self.idx_to_lon = interp1d(numpy.arange(N_lon), self.xlon[0,:]) #self.idx_to_lat = interp1d(numpy.arange(N_lat), self.xlat[:,0]) self.idx_to_lon = interp2d(numpy.arange(N_lon), numpy.arange(N_lat), self.xlon) self.idx_to_lat = interp2d(numpy.arange(N_lon), numpy.arange(N_lat), self.xlat) self.left = self.xlon.min() self.right = self.xlon.max() self.bottom = self.xlat.min()+18 self.top = self.xlat.max()-8 self.m = Basemap(llcrnrlon=self.left, llcrnrlat=self.bottom, urcrnrlon=self.right, urcrnrlat=self.top, projection='cyl', resolution='l') self.ocean_mask = maskoceans(self.xlon, self.xlat, self.xlon).mask self.time_min = 0. self.time_max = 0. self.no_ingested = 0 self.masks = numpy.empty((0,)+self.ocean_mask.shape) self.tc_table = numpy.empty((0,5)) self.time = numpy.empty((0,))
def default_absorbers(Tatm, ozone_file = 'apeozone_cam3_5_54.nc'): '''Initialize a dictionary of well-mixed radiatively active gases All values are volumetric mixing ratios. Ozone is set to a climatology. All other gases are assumed well-mixed: - CO2 - CH4 - N2O - O2 - CFC11 - CFC12 - CFC22 - CCL4 Specific values are based on the AquaPlanet Experiment protocols, except for O2 which is set the realistic value 0.21 (affects the RRTMG scheme). ''' absorber_vmr = {} absorber_vmr['CO2'] = 348. / 1E6 absorber_vmr['CH4'] = 1650. / 1E9 absorber_vmr['N2O'] = 306. / 1E9 absorber_vmr['O2'] = 0.21 absorber_vmr['CFC11'] = 0. absorber_vmr['CFC12'] = 0. absorber_vmr['CFC22'] = 0. absorber_vmr['CCL4'] = 0. datadir = os.path.join(os.path.dirname(__file__), 'data', 'ozone') ozonefilepath = os.path.join(datadir, ozone_file) # Open the ozone data file print 'Getting ozone data from', ozonefilepath ozonedata = nc.Dataset(ozonefilepath) ozone_lev = ozonedata.variables['lev'][:] ozone_lat = ozonedata.variables['lat'][:] # zonal and time average ozone_zon = np.mean(ozonedata.variables['OZONE'], axis=(0,3)) ozone_global = np.average(ozone_zon, weights=np.cos(np.deg2rad(ozone_lat)), axis=1) lev = Tatm.domain.axes['lev'].points if Tatm.shape == lev.shape: # 1D interpolation on pressure levels using global average data f = interp1d(ozone_lev, ozone_global) # interpolate data to model levels absorber_vmr['O3'] = f(lev) else: # Attempt 2D interpolation in pressure and latitude f2d = interp2d(ozone_lat, ozone_lev, ozone_zon) try: lat = Tatm.domain.axes['lat'].points f2d = interp2d(ozone_lat, ozone_lev, ozone_zon) absorber_vmr['O3'] = f2d(lat, lev).transpose() except: print 'Interpolation of ozone data failed.' print 'Reverting to default O3.' absorber_vmr['O3'] = np.zeros_like(Tatm) return absorber_vmr
def streamline(u1,u2,d,x1_0,x2_0,dl=1.,fig=None,nmax=600): if fig==None: ax=plt.gca() else: ax=fig.figure.gca() xrange=[ax.get_xlim()[0],ax.get_xlim()[1]] yrange=[ax.get_ylim()[0],ax.get_ylim()[1]] if nmax == 600 and fig != None: nmax = fig.dpi * max([fig.fig_w,fig.fig_h]) # Aspect ratio: r=(xrange[1]-xrange[0])/(yrange[1]-yrange[0]) if r<1: ny=nmax nx=int(r*nmax) else: nx=nmax ny=int(nmax/r) nregrid = [nx,ny] CC=d.getCenterPoints() tmp0=np.complex(0,nregrid[0]) tmp1=np.complex(0,nregrid[1]) x=np.linspace(xrange[0],xrange[1],nregrid[0]) y=np.linspace(yrange[0],yrange[1],nregrid[1]) grid_x, grid_y = np.mgrid[xrange[0]:xrange[1]:tmp0, yrange[0]:yrange[1]:tmp1] u = griddata(CC, u1, (grid_x, grid_y), method='linear') v = griddata(CC, u2, (grid_x, grid_y), method='linear') uisnan=np.isnan(u) visnan=np.isnan(v) un = np.empty(np.shape(u)) vn = np.empty(np.shape(v)) un[uisnan] = griddata(CC, u1, (grid_x[uisnan], grid_y[uisnan]), method='nearest') vn[visnan] = griddata(CC, u2, (grid_x[visnan], grid_y[visnan]), method='nearest') u[uisnan]=un[uisnan] v[visnan]=vn[visnan] # Normalize: mag=np.sqrt(u**2+v**2) u=u/mag v=v/mag fu = interpolate.interp2d(grid_x, grid_y, u, kind='cubic') fv = interpolate.interp2d(grid_x, grid_y, v, kind='cubic') x1=[x1_0] x2=[x2_0] while(x1[-1] >= xrange[0] and x1[-1] <= xrange[1] and x2[-1] >= yrange[0] and x2[-1] <= yrange[1]): dt=dl x1.append(x1[-1]+fu(x1[-1],x2[-1])*dt) x2.append(x2[-1]+fv(x1[-1],x2[-1])*dt) return [np.array(x1),np.array(x2)]
def bad_make_star(mass, age, model='Burrows97'): ''' Calculates stellar properties such as Teff, radii, logg and logL using evolutionary models ''' if np.min(mass) < 0.0005: raise NameError('Mass below minimum mass of 0.0005Msun') if np.max(mass) > 0.1 and model=='Baraffe03': warnings.warn('Mass above maximum mass of 0.1Msun for Baraffe 2003. Using Burrows 1997 instead.') model = 'Burrows97' if np.min(mass) > 0.2: raise NameError('Mass above maximum mass of 0.2Msun for Burrows 1997') if model == 'Burrows97': #0.0005 - 0.2 Msun burrows = pd.read_pickle("burrows97.pickle") allages = burrows["Age (Gyr)"] allmasses = burrows["M/Ms"] teff = burrows["Teff"] radius = burrows["R/Rs"] logg = burrows["logg(cgs)"] logL = burrows["logL/Ls"] if model == 'Baraffe03': #0.0005 - 0.1 Msun baraffe = pd.read_pickle("baraffe03.pickle") allages = baraffe["Age (Gyr)"] allmasses = baraffe["M/Ms"] teff = baraffe["Teff"] radius = baraffe["R/Rs"] logg = baraffe["logg(cgs)"] logL = baraffe["logL/Ls"] interpteff = interpolate.interp2d(allages,allmasses,teff,kind='linear') interprad = interpolate.interp2d(allages,allmasses,radius,kind='linear') interplogg = interpolate.interp2d(allages,allmasses,logg,kind='linear') interplogL = interpolate.interp2d(allages,allmasses,logL,kind='linear') mass = np.array(mass).flatten() age = np.array(age).flatten() newteff = np.array([interpteff(i,j) for i,j in zip(age,mass)]) newrad = np.array([interprad(i,j) for i,j in zip(age,mass)]) newlogg = np.array([interplogg(i,j) for i,j in zip(age,mass)]) newlogL = np.array([interplogL(i,j) for i,j in zip(age,mass)]) stardict = {'Teff (K)':newteff,'Radius (Rs)':newrad, 'log g':newlogg, 'log L':newlogL} starTable = Table(stardict) return starTable
def interp(iqehist, newE): """compute a new IQE histogram using the new energy array * iqehist: input IQE histogram * newE: new energy centers array """ from scipy import interpolate mask = iqehist.I != iqehist.I # find energy boundaries of dynamic range for each Q def get_boundary_indexes(a): nz = np.nonzero(a)[0] if nz.size: return nz[0], nz[-1] else: return 0, 0 boundary_indexes = [get_boundary_indexes(row) for row in np.logical_not(mask)] try: E = iqehist.energy except: E = iqehist.E Eranges = [(E[ind1], E[ind2]) for ind1, ind2 in boundary_indexes] # iqehist.I[mask] = 0 iqehist.E2[mask] = 0 Q = iqehist.Q f = interpolate.interp2d(E, Q, iqehist.I, kind="linear") E2f = interpolate.interp2d(E, Q, iqehist.E2, kind="linear") dE = E[1] - E[0] Emin = E[0] // dE * dE Emax = E[-1] // dE * dE # Enew = np.arange(Emin, Emax+dE/2, dE) newS = f(newE, Q) newS_E2 = E2f(newE, Q) # create new histogram Eaxis = H.axis("E", newE, unit="meV") Qaxis = H.axis("Q", Q, unit="1./angstrom") newHist = H.histogram("IQE", [Qaxis, Eaxis], data=newS, errors=newS_E2) # for Erange, q in zip(Eranges, Q): Emin, Emax = Erange if Emin > newE[0]: Emin = min(Emin, newE[-1]) newHist[q, (None, Emin)].I[:] = np.nan newHist[q, (None, Emin)].E2[:] = np.nan if Emax < newE[-1]: Emax = max(Emax, newE[0]) newHist[q, (Emax, None)].I[:] = np.nan newHist[q, (Emax, None)].E2[:] = np.nan continue return newHist
def __init__(self,**kwargs): fieldlineTracer.__init__(self,**kwargs) from scipy.interpolate import interp2d if 'interp' not in kwargs or kwargs['interp'] is None: interp = 'linear' else: interp = kwargs['interp'] if self.eq.B is None: self.eq.calc_bfield() self._bR = interp2d(self.eq.R,self.eq.Z,self.eq.BR/self.eq.B,kind=interp) self._bZ = interp2d(self.eq.R,self.eq.Z,self.eq.BZ/self.eq.B,kind=interp) self._bt = interp2d(self.eq.R,self.eq.Z,self.eq.Bt/self.eq.B,kind=interp)
def GetAllAlignment(self,e): #Get Alignment data for the entire 2D data range, interpolate results global AllAlignmentFxn, AllERotFxn, AlignmentProgPath, AllERotData, AllAlignmentData, alignment_params, inputfile,Nx,Ny alignment_params['FDTDField']['File'] = os.path.abspath(inputfile) #Change json input file to full 2D file WriteJSON() #Write json WriteRunFile(AlignmentProgPath,os.path.abspath('inputs_mod.json')) #write temp bash script os.system("chmod +x temp_script.sh") #make executable subprocess.call("./temp_script.sh", shell=True) #run script os.system("rm temp_script.sh") #remove temp #Import the calculated data and make global interpolations AllAlignmentData = np.genfromtxt("output_data/AlignmentData.txt", usecols=(3), dtype=float).reshape(Ny,Nx) AllAlignmentFxn = interpolate.interp2d(self.panel1.X,self.panel1.Y,AllAlignmentData,kind='cubic') AllERotData = np.genfromtxt("output_data/AlignmentData.txt", usecols=(4), dtype=float).reshape(Ny,Nx) AllERotFxn = interpolate.interp2d(self.panel1.X,self.panel1.Y,AllERotData,kind='cubic')
def __init__(self,**kwargs): fieldlineTracer.__init__(self,**kwargs) if self.eq.B is None: self.eq.calc_bfield() if 'interp' not in kwargs: interp = 'linear' else: interp = kwargs['interp'] self._bR = interp2d(self.eq.R,self.eq.Z,self.eq.BR/self.eq.B,kind=interp) self._bZ = interp2d(self.eq.R,self.eq.Z,self.eq.BZ/self.eq.B,kind=interp) self._bt = interp2d(self.eq.R,self.eq.Z,self.eq.Bt/self.eq.B,kind=interp)
def zoom(array, newSize, order=3): """ A Class to zoom 2-dimensional arrays using interpolation Uses the scipy `Interp2d` interpolation routine to zoom into an array. Can cope with real of complex data. Parameters: array (ndarray): 2-dimensional array to zoom newSize (tuple): the new size of the required array order (int, optional): Order of interpolation to use. default is 3 Returns: ndarray : zoom array of new size. """ if order not in INTERP_KIND: raise ValueError("Order can either be 1, 3, or 5 only") try: xSize = newSize[0] ySize = newSize[1] except (IndexError, TypeError): xSize = ySize = newSize coordsX = numpy.linspace(0, array.shape[0]-1, xSize) coordsY = numpy.linspace(0, array.shape[1]-1, ySize) #If array is complex must do 2 interpolations if array.dtype==numpy.complex64 or array.dtype==numpy.complex128: realInterpObj = interp2d( numpy.arange(array.shape[0]), numpy.arange(array.shape[1]), array.real, copy=False, kind=INTERP_KIND[order]) imagInterpObj = interp2d( numpy.arange(array.shape[0]), numpy.arange(array.shape[1]), array.imag, copy=False, kind=INTERP_KIND[order]) return (realInterpObj(coordsY,coordsX) + 1j*imagInterpObj(coordsY,coordsX)) else: interpObj = interp2d( numpy.arange(array.shape[0]), numpy.arange(array.shape[1]), array, copy=False, kind=INTERP_KIND[order]) #return numpy.flipud(numpy.rot90(interpObj(coordsY,coordsX))) return interpObj(coordsY,coordsX)
def __init__(self,obsBand,restBand,datFile=None): super(EmissionLineKCorr,self).__init__(obsBand,restBand) if not obsBand.startswith('SDSS'): raise ValueError if datFile is None: datFile = os.path.join(datadir,'bossdr9kcorr_ugriz.npz') self.data = np.load(datFile) b_j = 'ugriz'.find(obsBand[-1]) self.kcorr = self.data['kcorr'][...,b_j] self.mbins = self.data['mbins'][...,b_j] self.Mbins = self.data['Mbins'] self.zbins = self.data['zbins'] self.zz = np.tile(self.zbins,(len(self.Mbins),1)) self.K_M = interp2d(self.Mbins,self.zbins,self.kcorr.transpose()) self.K_m = interp2d(self.mbins,self.zz,self.kcorr)
def crop_to_bbox(lon, lat, data, bbox, nx=200, ny=200): # lati = np.where(np.logical_and(lat>=bbox[0]-1, lat<=bbox[2]+1))[0] # loni = np.where(np.logical_and(lon>=bbox[1]-1, lon<=bbox[3]+1))[0] # lon = lon[loni[0]:loni[-1]] # lat = lat[lati[0]:lati[-1]] # data = data[lati[0]:lati[-1], loni[0]:loni[-1]] # return lon, lat, data def __fill(data): invalid = np.isnan(data) ind = nd.distance_transform_edt(invalid, return_distances=False, return_indices=True) return data[tuple(ind)] lat_min = bbox[0] lat_max = bbox[2] lon_min = bbox[1] lon_max = bbox[3] a = np.array(data.mask).astype(int) print a a[:, 0] = 1 a[-1, :] = 1 print(a) data = __fill(data) # data[np.isnan(data)] = 9e99 dlat = (lat_max - lat_min) / ny dlon = (lon_max - lon_min) / nx lat_hi = np.arange(lat_min, lat_max + dlat, dlat) lon_hi = np.arange(lon_min, lon_max + dlon, dlon) ipol = interp2d(lon, lat, data) apol = interp2d(lon, lat, a) data_hi = ipol(lon_hi, lat_hi) mask_hi = apol(lon_hi, lat_hi) data_hi = np.ma.masked_where(mask_hi>.2, data_hi) return lon_hi, lat_hi, data_hi
def make_let_im(let_file, dim = 16, y_lo = 70, y_hi = 220, x_lo = 10, x_hi = 200, edge_pix = 150, plot_let = False): letter = mpimg.imread(let_file) letter = letter[y_lo:y_hi, x_lo:x_hi, 0] for i in range(letter.shape[1]): if letter[0:edge_pix, i].any() == 0: # here is to remove the edge letter[0:edge_pix, i] = 1 plt.imshow(letter, cmap='gray') plt.grid('off') plt.show() x = np.arange(letter.shape[1]) y = np.arange(letter.shape[0]) f2d = interp2d(x, y, letter) x_new = np.linspace(0, letter.shape[1], dim) # dim = 16 y_new = np.linspace(0, letter.shape[0], dim) letter_new = f2d(x_new, y_new) letter_new -= np.mean(letter_new) if plot_let: plt.imshow(letter_new, cmap = 'gray') plt.grid('off') plt.show() letter_flat = letter_new.flatten() # letter_flat is a 1-dimensional array containing 256 elements return letter_new, letter_flat
def remove_unresponsive_and_fluctuating_stripe(self, sinogram, snr, size): """ Algorithm 6 in the paper. Remove unresponsive or fluctuating stripes. --------- Parameters: - sinogram: 2D array. - snr: ratio used to discriminate between useful information and noise - size: window size of the median filter. --------- Return: - stripe-removed sinogram. """ (nrow, _) = sinogram.shape sinosmoothed = np.apply_along_axis(uniform_filter1d, 0, sinogram, 10) listdiff = np.sum(np.abs(sinogram - sinosmoothed), axis=0) nmean = np.mean(listdiff) listdiffbck = median_filter(listdiff, size) listdiffbck[listdiffbck == 0.0] = nmean listfact = listdiff / listdiffbck listmask = self.detect_stripe(listfact, snr) listmask = binary_dilation(listmask, iterations=1).astype(listmask.dtype) listmask[0:2] = 0.0 listmask[-2:] = 0.0 listx = np.where(listmask < 1.0)[0] listy = np.arange(nrow) matz = sinogram[:, listx] finter = interpolate.interp2d(listx, listy, matz, kind='linear') listxmiss = np.where(listmask > 0.0)[0] if len(listxmiss) > 0: matzmiss = finter(listxmiss, listy) sinogram[:, listxmiss] = matzmiss return sinogram
def evalDiff(self, x, y, diff): imin = int(x) - 5 imax = imin + 10 jmin = int(y) - 5 jmax = jmin + 10 if jmin < 0: return 0 if jmax > len(diff[1,:]): return 0 xticks = np.arange(0,len(diff[:,1])) yticks = np.arange(0,len(diff[1,:])) ygrid, xgrid = np.meshgrid(yticks,xticks) xgrid = xgrid[imin:imax,jmin:jmax] ygrid = ygrid[imin:imax,jmin:jmax] diff = diff[imin:imax,jmin:jmax] print xgrid.shape print ygrid.shape print diff.shape diffAt = sp.interp2d(xgrid, ygrid, diff, kind='linear') return diffAt(x,y)
def interpolarMapa(probeMap): # Obtener la lista de valores x,y,z xm, ym, zm = probeMapToList(probeMap) # Interpolar la funcion f = interpolate.interp2d(xm, ym, zm, kind='cubic') # Devuelve el objeto de funcion return f
def evalStrainY(self, x, y, diff): imin = int(x) - 5 imax = imin + 10 jmin = int(y) - 5 jmax = jmin + 10 if jmin < 0: return 0 if jmax > len(diff[1,:]): return 0 xticks = np.arange(0,len(diff[:,1])) yticks = np.arange(0,len(diff[1,:])) yticks = yticks[self.lag:] ygrid, xgrid = np.meshgrid(yticks,xticks) strainY = (diff[:,self.lag:] - diff[:,:-self.lag])/(self.lag*self.stepy) xgrid = xgrid[imin:imax,jmin:jmax] ygrid = ygrid[imin:imax,jmin:jmax] strainY = strainY[imin:imax,jmin:jmax] strainAt = sp.interp2d(xgrid, ygrid, strainY, kind='linear') return strainAt(x,y)
def plotSurf(): from scipy import interpolate a=pd.read_pickle(utl.outpath+'real/real.maxLikelihoods.df') idx=(a.s.abs()*a.h.abs()*(a.alt-a.null)).sort_values().index[-1] R=pd.DataFrame(pd.read_pickle(utl.outpath+'real/real.replicates.df').loc[idx]).T SH=dta.getSH() ARGS=[(R,)+sh for sh in SH] likelihoods=pd.concat(map(mkv.computeLikelihoodReal,ARGS),axis=1);likelihoods.columns.names=['s','h'] fig = plt.figure() ax = fig.gca(projection='3d') df=pd.concat([pd.Series(z[1].loc[z[0]].values,index=z[1].loc[z[0]].index,name=z[0]) for z in b.groupby(level=0)],axis=1) Z=df.values # Z[Z==Z.min()]=-1e3 X=np.tile(df.index.values[:,None],Z.shape[1]) Y=np.tile(df.columns.values[:,None],Z.shape[0]).T Z.min() Z.max() nn = 401; xi = np.linspace(-1.0, 2.0, 10); yi = np.linspace(-0.5, 0.5, nn); f = interpolate.interp2d(X,Y,Z,kind='cubic') zi = f(xi, yi) [xi, yi] = np.meshgrid(xi, yi); # surf = ax.plot_surface(X, Y, Z, cmap=mpl.cm.autumn) surf = ax.plot_surface(xi, yi, zi, cmap=mpl.cm.autumn) fig.colorbar(surf, shrink=0.5, aspect=5) # surf(xi, yi, zi, 'LineStyle', 'none', 'FaceColor', 'interp') plt.show()
def _rs_dead(sinogram, snr, size, matindex): """ Remove unresponsive and fluctuating stripes. """ sinogram = np.copy(sinogram) # Make it mutable (nrow, _) = sinogram.shape sinosmoothed = np.apply_along_axis(uniform_filter1d, 0, sinogram, 10) listdiff = np.sum(np.abs(sinogram - sinosmoothed), axis=0) nmean = np.mean(listdiff) listdiffbck = median_filter(listdiff, size) listdiffbck[listdiffbck == 0.0] = nmean listfact = listdiff / listdiffbck listmask = _detect_stripe(listfact, snr) listmask = binary_dilation(listmask, iterations=1).astype(listmask.dtype) listmask[0:2] = 0.0 listmask[-2:] = 0.0 listx = np.where(listmask < 1.0)[0] listy = np.arange(nrow) matz = sinogram[:, listx] finter = interpolate.interp2d(listx, listy, matz, kind='linear') listxmiss = np.where(listmask > 0.0)[0] if len(listxmiss) > 0: matzmiss = finter(listxmiss, listy) sinogram[:, listxmiss] = matzmiss # Use algorithm 5 to remove residual stripes sinogram = _rs_large(sinogram, snr, size, matindex) return sinogram
def __init__(self, pupil_diameter=0.003, focal_length=0.017, dist=1.0, wave=None): """ Constructor for Optics Class Initialize parameters for human ocular system Args: pupil_diameter (float): pupil diameter in meters, usually human pupil diameter should be between 2 and 8 focal_length (float): focal length of human, usually this is around 17 mm dist (float): object distance in meters, will be overrrided by scene.dist in compute method Note: To alter lens and macular pigment transmittance, we need to create a default optics instance first and then set the corresponding parameters Examples: >>> oi = Optics(pupil_diameter=0.5) >>> oi.macular_transmittance[:] = 1 """ # check inputs if wave is None: wave = np.arange(400.0, 710.0, 10) # turn off numpy warning for invalid input np.seterr(invalid='ignore') # initialize instance attribute to default values self.name = "Human Optics" # name of the class instance self._wave = wave.astype(float) # wavelength samples in nm self.photons = np.array([]) # irradiance image self.pupil_diameter = pupil_diameter # pupil diameter in meters self.dist = dist # Object distance in meters self.fov = 1.0 # field of view of the optical image in degree self.focal_length = focal_length # focal lens of optics in meters self._otf = None # optical transfer function # set lens quanta transmittance self.lens_transmittance = 10**(-spectra_read("lensDensity.mat", wave)) # set macular pigment quanta transmittance self.macular_transmittance = 10**(-spectra_read("macularPigment.mat", wave)) # compute human optical transfer function # Reference: Marimont & Wandell, J. Opt. Soc. Amer. A, v. 11, p. 3113-3122 (1994) max_freq = 90 defocus = 1.7312 - (0.63346 / (wave*1e-3 - 0.2141)) # defocus as function of wavelength w20 = pupil_diameter**2 / 8 * (1/focal_length * defocus) / (1/focal_length + defocus) # Hopkins w20 parameter sample_sf = np.arange(max_freq) achromatic_mtf = 0.3481 + 0.6519 * np.exp(-0.1212 * sample_sf) # compute otf at each wavelength otf = np.zeros([sample_sf.size, wave.size]) for ii in range(wave.size): s = 1 / tan(deg_to_rad(1)) * wave[ii] * 2e-9 / pupil_diameter * sample_sf # reduced spatial frequency alpha = 4*pi / (wave[ii] * 1e-9) * w20[ii] * s otf[:, ii] = self.optics_defocus_mtf(s, alpha) * achromatic_mtf # set otf as 2d interpolation function to object # To get otf at given wavelength and frequency, use object.otf() method self._otf = interp2d(self.wave, sample_sf, otf, bounds_error=False, fill_value=0)
def pair_fin(clos_app,dt, aa, src, freq,fbmamp,multweight=True,noiseweight=True,ovlpweight=True,cutoff=9000.*0.005*0.005,puv=False): final = [] cnt, N = 0,len(clos_app) bm_intpl = export_beam.beam_interpol(freq,fbmamp,'cubic') if ovlpweight: #rbm2interp: FT of sq of beam fbm2 = n.multiply(fbmamp,fbmamp) #element wise square for power beam rbm2 = n.fft.fft2(fbm2); rbm2 = n.fft.fftshift(rbm2) freqlm = n.fft.fftfreq(len(freq),d=(freq[1]-freq[0])); freqlm = n.fft.fftshift(freqlm) print "###small imaginary components are error, nothing to worry about" rbm2interp = interpolate.interp2d(freqlm, freqlm, rbm2, kind='cubic') for key in clos_app: cnt = cnt+1 if (cnt/1000)*1000 == cnt: print 'Calculating baseline pair %d out of %d:' % (cnt,N) bl1,bl2 = key[0],key[1] t1,t2 = clos_app[key][1],clos_app[key][2] correlation,(uvw1,uvw2) = get_corr(aa, src, bm_intpl, t1,t2, bl1, bl2) if correlation == 0: continue if ovlpweight: ovlp = get_ovlp(aa,t1,t2,rbm2interp) else: ovlp = 1. weight = get_weight(aa,bl1,bl2,uvw1,multweight,noiseweight,ovlp) #while correlation > cutoff: if puv: final.append((weight*correlation,correlation,(bl1,t1,uvw1),(bl2,t2,uvw2))) else: final.append((weight*correlation,correlation,(bl1,t1),(bl2,t2))) #t1,t2 = t1+dt,t2+dt try: correlation,(uvw1,uvw2) = get_corr(aa, src,bm_intpl, t1,t2, bl1, bl2) except(TypeError): correlation = 0. else: if ovlpweight: ovlp = get_ovlp(aa,t1,t2,rbm2interp) else: ovlp = 1. weight = get_weight(aa,bl1,bl2,uvw1,multweight,noiseweight,ovlp) quick_sort.quick_sort(final,0,len(final)-1) return final
def compute(myVelfield, MyParams): interp_kind = 'quintic' # Scipy returns a function that you can use on a new set of x,y pairs. f_east = interpolate.interp2d(myVelfield.elon, myVelfield.nlat, myVelfield.e, kind=interp_kind) f_north = interpolate.interp2d(myVelfield.elon, myVelfield.nlat, myVelfield.n, kind=interp_kind) # The new interpolation grid: a new set of points with some chosen spacing xarray = np.arange(MyParams.coord_box[0], MyParams.coord_box[1], MyParams.grid_inc) yarray = np.arange(MyParams.coord_box[2], MyParams.coord_box[3], MyParams.grid_inc) [X, Y] = np.meshgrid(xarray, yarray) # Evaluate the linear or cubic interpolation function at new points new_east = np.zeros(np.shape(X)) new_north = np.zeros(np.shape(X)) for i in range(len(yarray)): for j in range(len(xarray)): new_east[i][j] = f_east(xarray[j], yarray[i]) # only want to give the functions one point at a time. new_north[i][j] = f_north(xarray[j], yarray[i]) # Grid increments typical_lat = float(MyParams.map_range[2]) xinc = MyParams.grid_inc * 111.000 * np.cos(np.deg2rad(typical_lat)) # in km (not degrees) yinc = MyParams.grid_inc * 111.000 # in km (not degrees) # Computing the elements of the strain tensor from the rot = np.zeros(np.shape(X)) # 2nd invariant of rotation rate tensor I2nd = np.zeros(np.shape(X)) # 2nd invariant of strain rate tensor max_shear = np.zeros(np.shape(X)) # max shear of strain rate tensor e1 = np.zeros(np.shape(X)) # maximum principal strain (array of float) e2 = np.zeros(np.shape(X)) # minimum principal strain (array of float) v00 = np.zeros(np.shape(X)) # more complicated: eigenvectors (array of matrix 2x2) v01 = np.zeros(np.shape(X)) # more complicated: eigenvectors (array of matrix 2x2) v10 = np.zeros(np.shape(X)) # more complicated: eigenvectors (array of matrix 2x2) v11 = np.zeros(np.shape(X)) # more complicated: eigenvectors (array of matrix 2x2) dilatation = np.zeros(np.shape(X)) # the strain calculation for j in range(len(yarray) - 1): for i in range(len(xarray) - 1): up = new_east[j][i] vp = new_north[j][i] uq = new_east[j][i + 1] vq = new_north[j][i + 1] ur = new_east[j + 1][i] vr = new_north[j + 1][i] [dudx, dvdx, dudy, dvdy] = strain_tensor_toolbox.compute_displacement_gradients( up, vp, ur, vr, uq, vq, xinc, yinc) # The components that are easily computed # Units: nanostrain per year. [exx, exy, eyy, rotation ] = strain_tensor_toolbox.compute_strain_components_from_dx( dudx, dvdx, dudy, dvdy) rot[j][i] = abs(rotation) # Compute a number of values based on tensor properties. I2nd[j][i] = np.log10( np.abs(strain_tensor_toolbox.second_invariant(exx, exy, eyy))) [e11, e22, v1] = strain_tensor_toolbox.eigenvector_eigenvalue(exx, exy, eyy) e1[j][i] = e11 e2[j][i] = e22 v00[j][i] = v1[0][0] v10[j][i] = v1[1][0] v01[j][i] = v1[0][1] v11[j][i] = v1[1][1] max_shear[j][i] = (e11 - e22) / 2 dilatation[j][i] = e11 + e22 return [ xarray, yarray, I2nd, max_shear, rot, e1, e2, v00, v01, v10, v11, dilatation ]
def at_val(self, new_in_eng, new_eng, interp_type='val', log_interp=False, bounds_error=None, fill_value=np.nan): """2D interpolation at specified abscissa. Interpolation is logarithmic. 2D interpolation should be preferred over 1D interpolation over each abscissa in the interest of accuracy. Parameters ---------- new_in_eng : ndarray The injection energy abscissa or injection energy bin indices at which to interpolate. new_eng : ndarray The energy abscissa or energy abscissa bin indices at which to interpolate. interp_type : {'val', 'bin'} The type of interpolation. 'bin' uses bin index, while 'val' uses the actual injection energies. log_interp : bool, optional Whether to perform an interpolation over log of the grid values. Default is False. bounds_error : bool, optional See scipy.interpolate.interp1d. fill_value : array-like or (array-like, array-like) or "extrapolate", optional See scipy.interpolate.interp1d. Returns ------- TransFuncAtRedshift New transfer function at the new abscissa. """ # 2D interpolation, specified by vectors of length eng, in_eng, # and grid dimensions in_eng x eng. # interp_func takes (eng, in_eng) as argument. non_zero_grid = self.grid_vals non_zero_N_und = self.N_underflow non_zero_eng_und = self.eng_underflow # set zero values to some small value for log interp. non_zero_grid[np.abs(non_zero_grid) < 1e-100] = 1e-200 non_zero_N_und[np.abs(non_zero_N_und) < 1e-100] = 1e-200 non_zero_eng_und[np.abs(non_zero_eng_und) < 1e-100] = 1e-200 if interp_type == 'val': if log_interp: interp_grid = np.log(non_zero_grid) N_und_grid = np.log(non_zero_N_und) eng_und_grid = np.log(non_zero_eng_und) else: interp_grid = non_zero_grid N_und_grid = non_zero_N_und eng_und_grid = non_zero_eng_und interp_func = interpolate.interp2d(np.log(self.eng), np.log(self.in_eng), interp_grid, bounds_error=bounds_error, fill_value=np.log(fill_value)) interp_func_N_und = interpolate.interp1d(np.log(self.in_eng), N_und_grid, bounds_error=False, fill_value=0) interp_func_eng_und = interpolate.interp1d(np.log(self.in_eng), eng_und_grid, bounds_error=False, fill_value=0) new_tf = TransFuncAtRedshift([]) new_tf._spec_type = self.spec_type if log_interp: new_tf._grid_vals = np.atleast_2d( np.exp(interp_func(np.log(new_eng), np.log(new_in_eng)))) interp_vals_N_und = np.exp( interp_func_N_und(np.log(new_in_eng))) interp_vals_eng_und = np.exp( interp_func_eng_und(np.log(new_in_eng))) else: new_tf._grid_vals = np.atleast_2d( interp_func(np.log(new_eng), np.log(new_in_eng))) interp_vals_N_und = interp_func_N_und(np.log(new_in_eng)) interp_vals_eng_und = interp_func_eng_und(np.log(new_in_eng)) # Re-zero small values. new_tf._grid_vals[new_tf.grid_vals < 1e-100] = 0 interp_vals_N_und[interp_vals_N_und < 1e-100] = 0 interp_vals_eng_und[interp_vals_eng_und < 1e-100] = 0 new_tf._eng = new_eng new_tf._in_eng = new_in_eng new_tf._rs = self.rs new_tf._N_underflow = interp_vals_N_und new_tf._eng_underflow = interp_vals_eng_und return new_tf elif interp_type == 'bin': if issubclass(new_eng.dtype.type, np.integer): return self.at_in_eng(new_in_eng, interp_type='bin', log_interp=log_interp).at_eng( new_eng, interp_type='bin') log_new_in_eng = np.interp(np.log(new_in_eng), np.arange(self.in_eng.size), np.log(self.in_eng)) log_new_eng = np.interp(np.log(new_eng), np.arange(self.eng.size), np.log(self.eng)) return self.at_val(np.exp(log_new_in_eng), np.exp(log_new_eng), interp_type='val', log_interp=log_interp, bounds_error=bounds_error, fill_value=fill_value)
def interp_image(self, x, y, z): if isMPL2: return x, y, z else: axes = self.get_container() atrans = axes.transAxes.transform idtrans = axes.transData.inverted().transform p0, p1 = atrans([(0, 0), (1, 1)]) dx = np.floor(p1[0]-p0[0])+2 dy = np.floor(p1[1]-p0[1])+2 xp = idtrans( np.transpose( np.vstack((np.floor(p0[0])+np.arange(int(dx)), np.linspace(p0[0], p1[0], dx)))))[:, 0] yp = idtrans( np.transpose( np.vstack((np.floor(p0[1])-1+np.zeros(int(dy)), np.linspace(p0[1], p1[1], dy)))))[:, 1] # eliminate points outside the data range #xp = np.array([tmp for tmp in xp if (tmp > np.min(x) and tmp < np.max(x))]) #yp = np.array([tmp for tmp in yp if (tmp > np.min(y) and tmp < np.max(y))]) interp = self.getp("interp") from scipy.interpolate import RegularGridInterpolator if ((x.size*y.size == z.size and interp == 'nearest') or (x.size*y.size == z.size and interp == 'linear')): f = RegularGridInterpolator((y, x), z, method=interp, bounds_error=False, fill_value=np.nan) XP, YP = np.meshgrid(xp, yp) p1 = np.transpose(np.vstack((YP.flatten(), XP.flatten()))) zp = f(p1) zp = zp.reshape((len(yp), len(xp))).astype(float) elif (x.size*y.size != z.size or interp == 'nearest' or np.any(np.isnan(z))): if interp == 'quintic': interp = 'cubic' X, Y = np.meshgrid(x, y) p1 = np.transpose(np.vstack((X.flatten(), Y.flatten()))) XP, YP = np.meshgrid(xp, yp) interp = self.getp("interp") # print 'griddata', interp zp = griddata(p1, z.flatten(), (XP.flatten(), YP.flatten()), method=str(interp)) zp = zp.reshape((len(yp), len(xp))).astype(float) else: f = interp2d(x, y, z, kind=interp) zp = f(xp, yp) # print(zp) # if interp == 'nearest': # this hide the outside of image when even 'nearest' is # used zp[:, xp < np.min(x)] = np.nan zp[:, xp > np.max(x)] = np.nan zp[yp < np.min(y), :] = np.nan zp[yp > np.max(y), :] = np.nan return xp, yp, zp
def grib2csv(file_dict): r"""Convert a dict of grib files to a CSV.""" pass import numpy as np from collections import defaultdict import pandas as pd from scipy.interpolate import interp2d from functools import reduce # Resolution of lat and lon on the uniformly interpolated grid. lat_uniform = np.arange(30, 35, 0.125) lon_uniform = np.arange(110, 123, 0.125) pivoted_dataframes = defaultdict( dict) # Dimensions: (Time, Model, (Lat, Lon)) unpivoted_dataframes = dict( ) # Dimensions: (Time, DataFrame: (Model, lat, lon)) for model, model_file_list in file_dict.items(): for model_file in model_file_list: # Open and read file grbmsg = pygrib.open(model_file)[1] lat, lon, values = read_from_single_grbmsg(grbmsg) # Unit conversion units_grbmsg = grbmsg['parameterUnits'] short_name = 'PRCP' if units_grbmsg == 'm': values = values * 1000. elif units_grbmsg != 'kg m-2': print('Other kinds of precipitation units detected: {}'.format( units_grbmsg)) # Get validity datetime initial_datetime = "{:08d}{:02d}".format(grbmsg['validityDate'], grbmsg['validityTime']) validity_datetime = "{:08d}{:02d}".format(grbmsg['dataDate'], grbmsg['dataTime']) # Do 2d-interpolation on all data to uniform grids. f = interp2d(lon, lat, values) # TODO: May modify parameter 'kind' later values_uniform = f(lon_uniform, lat_uniform) values_uniform[values_uniform < 0.1] = 0.0 # TODO: # Dimensions: (Time, Model, (Lat, Lon)) # 1. Put (lat, lon) data into DataFrames with lat, lon axes. pivoted_dataframes[validity_datetime][model] = pd.DataFrame( values_uniform, lat_uniform, lon_uniform) # 2. Do melting ("Unpivoting") to the DataFrames. pivoted_dataframes[validity_datetime][model][ 'lat'] = pivoted_dataframes[validity_datetime][model].index pivoted_dataframes[validity_datetime][model] = pd.melt( pivoted_dataframes[validity_datetime][model], id_vars=['lat'], var_name='lon', value_name='prcp.{}'.format(model)) # Test # 3. Merge them together as one DataFrame for key_date in pivoted_dataframes.keys(): unpivoted_dataframes[key_date] = reduce( lambda left, right: pd.merge(left, right, on=['lat', 'lon']), pivoted_dataframes[key_date].values()) unpivoted_dataframes[key_date]['time'] = key_date unpivoted_dataframes = pd.concat( [value for value in unpivoted_dataframes.values()]) return unpivoted_dataframes
def begin(index): #i = int(index) i = int(index.split('-')[0]) mgi = int(index.split('-')[1]) color = index.split('-')[2] #try: print(index) #filename = 'Test Data Extract/' + str(i) + '.fit' #filename = str(i) + '-g.fit' try: # Open the Experiment Absorber's data qlist = fits.open('/data/marvels/billzhu/Experiment Absorbers/' + color + '/' + str(index) + '_EA.fit') abs_data = qlist[0].data.astype(float) # Open a reference QSO's data qsofile = fits.open( '/data/marvels/billzhu/2175 Reference Quasar Cut/' + color + '/' + str(index) + '_REF.fit') qsodata = qsofile[0].data.astype(float) # Open the reference QSO's field image scifile = fits.open('/data/marvels/billzhu/2175 Reference Dataset/' + color + '/' + str(index) + '.fit') scidata = scifile[0].data.astype(float) # Open the object binary table obj_table = Table.read('/data/marvels/billzhu/2175 Reference Obj/' + str(i) + '-' + str(mgi) + '.fit', hdu=1) except: return pointer = 0 if color == 'g': pointer = 1 if color == 'r': pointer = 2 if color == 'i': pointer = 3 if color == 'z': pointer = 4 if color == 'u': pointer = 0 #line_data = linecache.getline('Full Data.txt', i).split() #line_data = linecache.getline('DR12 QSO.txt', i).split() #print(len(line_data)) #obj_id = int(line_data[52]) # Recalculate the sigma stats after background subtraction #mean, median, std = sigma_clipped_stats(scidata, sigma=3.0, iters=5) #print("%f, %f, %f" % (mean, median, std)) largearr = [] stars = [] chunk_size = 50 qx = qsofile[0].header['XCOORD'] qy = qsofile[0].header['YCOORD'] obj_id = qsofile[0].header['ID'] for j in range(len(obj_table)): sx = obj_table['COLC'][j][pointer] sy = obj_table['ROWC'][j][pointer] flags1 = detflags(obj_table['OBJC_FLAGS'][j]) flags2 = detflags(obj_table['OBJC_FLAGS2'][j]) #try: if obj_table['OBJC_TYPE'][j] == 6 and flags1[12] == False and flags1[ 17] == False and flags1[18] == False and flags2[ 27] == False and distance(sx, sy, qx, qy) > 5 and inbounds( sx + chunk_size + 6, sy + chunk_size + 6 ) and inbounds( sx - chunk_size - 5, sy - chunk_size - 5 ) and obj_table['PSFMAG'][j][pointer] < 18 and obj_table[ 'M_RR_CC'][j][pointer] > 0 and abs( obj_table['M_RR_CC'][j][pointer] - obj_table['M_RR_CC'][obj_id - 1][pointer] ) < 0.1 * obj_table['M_RR_CC'][obj_id - 1][pointer]: #try: """ preshift = scidata[int(sy - 10) : int(sy + 11), int(sx - 10) : int(sx + 11)] xc, yc = centroid_2dg(preshift, mask = None) xc += quasar['COLC'][pointer] - 10 yc += quasar['ROWC'][pointer] - 10 """ xc = obj_table['COLC'][j][pointer] yc = obj_table['ROWC'][j][pointer] preshift = scidata[int(yc - chunk_size - 5):int(yc + chunk_size + 6), int(xc - chunk_size - 5):int(xc + chunk_size + 6)] spline = interpolate.interp2d( np.arange(int(xc - chunk_size - 5), int(xc + chunk_size + 6)), np.arange(int(yc - chunk_size - 5), int(yc + chunk_size + 6)), preshift) xrang = np.arange(xc - chunk_size, xc + chunk_size + 1) yrang = np.arange(yc - chunk_size, yc + chunk_size + 1) if len(xrang) > 2 * chunk_size + 1: xrang = xrang[:-1] if len(yrang) > 2 * chunk_size + 1: yrang = yrang[:-1] shifted1 = spline(xrang, yrang) # Subtract off accurate local sky background shifted1 -= sigma_clipped_stats(shifted1, sigma=3.0, iters=5)[1] """ background = [] for r in range(len(shifted1)): for c in range(len(shifted1)): if distance(r, c, 150, 150) > 150: background.append(shifted1[r, c]) true_bkg = sigma_clipped_stats(background, sigma=3.0, iters=5)[1] shifted1 -= true_bkg """ # Take out the PSF star's image, and any absorbers associated with it if very close mean, median, std = sigma_clipped_stats(shifted1, sigma=3.0, iters=5) visited = connected( shifted1, chunk_size, chunk_size, mean + std / 4, np.zeros((2 * chunk_size + 1, 2 * chunk_size + 1), dtype=bool), obj_table['PETROTHETA'][j][pointer] / 0.396 * 1.2 + 3) """ poststamp = np.zeros((2 * chunk_size + 1, 2 * chunk_size + 1)) for r in range(len(shifted1)): for c in range(len(shifted1)): if visited[c][r] == True: poststamp[c][r] = shifted1[c][r] shifted1 -= poststamp """ """ mag22 = 0 if color == 'g': mag22 = 2500 if color == 'r': mag22 = 1900 if color == 'i': mag22 = 1400 if color == 'z': mag22 = 300 """ #print("%f, %f" % (xc, yc)) shifted1 = checkInner(shifted1, obj_table, xc, yc, mean, std, pointer) shifted1 = perimeter(shifted1, mean, std) #shifted1 += poststamp #gauss1 = photutils.fit_2dgaussian(shifted1[40 : 61, 40 : 61], mask = None) #fit_fwhm_x = 2*np.sqrt(2*np.log(2))*np.sqrt(abs(gauss1.x_stddev.value)) #fit_fwhm_y = 2*np.sqrt(2*np.log(2))*np.sqrt(abs(gauss1.y_stddev.value)) #print("%f, %f, %f, %f" % (fit_fwhm_x, fit_fwhm_y, fwhm_x, fwhm_y)) #if abs(fit_fwhm_x - fwhm_x) < 0.25 and abs(fit_fwhm_y - fwhm_y) < 0.25: #print(shifted1[50][50]) if shifted1[50][50] > 0.05: #shifted1 = normalize(shifted1, 50, 50, np.max(shifted1), np.max(qsodata), mean1 + 5 * std1, np.zeros((101, 101), dtype=bool)) #visited = connected(shifted1, 50, 50, mean + 1 * std, np.zeros((101, 101), dtype=bool)) #shifted1 = gaussian_filter(shifted1, sigma=std) #smax = np.max(shifted1) for r in range(len(visited)): for c in range(len(visited)): #if distance(r, c, 50, 50) < 1.2 * obj_table['iso_a'][obj_id - 1][pointer]/2 + 3: shifted1[c][r] /= obj_table['PSFFLUX'][j][pointer] shifted1[c][r] *= obj_table['PSFFLUX'][obj_id - 1][pointer] #shifted1 /= obj_table['PSFFLUX'][j][pointer] #shifted1 *= obj_table['PSFFLUX'][obj_id - 1][pointer] largearr.append(np.reshape(shifted1, 10201)) stars.append(j) #print(True) #stars.append(shifted1) #except: #continue largearr = np.array(largearr) #largearr *= 1 + 10**((obj_table['PSFMAG'][obj_id - 1][pointer] - 24.5) / 2.5) #largearr /= photonCount(50, 50, obj_table['PETROTHETA'][obj_id - 1][pointer] / 0.396 , qsodata) #largearr *= photonCount(50, 50, obj_table['PETROTHETA'][obj_id - 1][pointer] / 0.396 , qsodata_copy) print(np.shape(largearr)) # Set number of components in PCA, use Incremental PCA (IPCA) due to high efficiency and speed numcomp = len(largearr) # Need a healthy number of sources to make the PSF fitting in order to decrease noise, setting at 5% threshold #if len(largearr) < 10: # print('No Sources') # return print(numcomp) mean_vector = [] #print(np.shape(largearr)) try: for j in range(0, 10201): mean_vector.append(np.mean(largearr[:, j])) except: print("NO SOURCE FOUND") return largearr -= mean_vector ipca = IncrementalPCA(n_components=numcomp) ipca.fit(largearr) ipca_comp = ipca.components_ #print(np.shape(ipca_comp)) # Only use the components of the central portion of the quasar, since there may be overfitting due to strength of ipca new_comp = [] for j in range(len(largearr)): temp = np.reshape(ipca_comp[j, :], (2 * chunk_size + 1, 2 * chunk_size + 1)) new_comp.append(np.reshape(temp[47:54, 47:54], 49)) new_comp = np.array(new_comp) new_comp = new_comp.T print(np.shape(new_comp)) ipca_comp = ipca_comp.T #print(ipca_comp) take_final = numcomp # Calculate the residues with offsets from 1 to 8 pixels pixel = np.arange(0, 8) for offset in pixel: qsodata_copy = np.array(qsodata) abs_data_copy = np.array(abs_data) print(qlist[0].header['PSFMAG']) factor = 10**(qlist[0].header['PSFMAG'] / -2.5 - 19.5 / -2.5) abs_data_copy /= (factor * 10) qsodata_copy[:, offset:101] += abs_data_copy[:, 0:101 - offset] # Final fitting of the first n components, as determined by take_final, into the quasar to build a PSF fit #print(np.shape(ipca_comp)) qsodata_copy = np.reshape(qsodata_copy, (2 * chunk_size + 1)**2) qsodata_copy -= mean_vector qsodata_copy = np.reshape(qsodata_copy, (2 * chunk_size + 1, 2 * chunk_size + 1)) coeff = np.dot(np.reshape(qsodata_copy[47:54, 47:54], 49), new_comp) #coeff = np.dot(qsodata, ipca_comp) final_fit = np.dot(ipca_comp[:, 0:take_final], coeff[0:take_final]) final_fit += mean_vector final_fit = np.reshape(final_fit, (2 * chunk_size + 1, 2 * chunk_size + 1)) #final_fit /= len(largearr) qsodata_copy = np.reshape(qsodata_copy, (2 * chunk_size + 1)**2) qsodata_copy += mean_vector qsodata_copy = np.reshape(qsodata_copy, (2 * chunk_size + 1, 2 * chunk_size + 1)) """ background = [] for r in range(len(final_fit)): for c in range(len(final_fit)): if distance(r, c, 50, 50) > 50: background.append(final_fit[r, c]) """ mean, median, stddev = sigma_clipped_stats(final_fit) final_fit -= median #final_fit /= final_fit[50, 50] #final_fit *= qsodata_copy[50, 50] final_fit /= photonCount( 50, 50, 2 * obj_table['PSF_FWHM'][obj_id - 1][pointer], final_fit) final_fit *= photonCount( 50, 50, 2 * obj_table['PSF_FWHM'][obj_id - 1][pointer], qsodata_copy) print("%f, %f" % (np.max(qsodata_copy), np.max(final_fit))) # Final residue from subtraction of PSF from QSO residue = qsodata_copy - final_fit mean, median, stddev = sigma_clipped_stats(residue, sigma=3.0, iters=5) residue -= median try: fits.writeto('/data/marvels/billzhu/Experiment PSF Subtract/' + color + '/' + str(index) + '-' + str(offset) + '_SUB.fit', residue, qlist[0].header, clobber=True) fits.writeto('/data/marvels/billzhu/Experiment PSF Cut/' + color + '/' + str(index) + '-' + str(offset) + '_PSF.fit', final_fit, qlist[0].header, clobber=True) print('\n') print("DONE TO BOTTOM") except: print('HEADER IS CORRUPT')
# =============================================================== layermodel = None surfacemodel = None # Option 1: Use 1 V/km field: N1Vkm = True E1Vkm = True if testfield: en, ee = np.zeros((len(lat), len(lon)), dtype=npf), np.zeros( (len(lat), len(lon)), dtype=npf) if N1Vkm: en.fill(1.) if E1Vkm: ee.fill(1.) en_int = interpolate.interp2d(lon, lat, en) ee_int = interpolate.interp2d(lon, lat, ee) # Option 2 (-e): Use external field file: else: darray = np.loadtxt(efilepath, skiprows=0) # Reshape into usable array: nlat, nlon = len(lat), len(lon) ien, iee = 2, 5 # Indices of N and E field component (real parts only here) endata = np.reshape(darray[:, ien], (nlat, nlon), order='F') eedata = np.reshape(darray[:, iee], (nlat, nlon), order='F') # Interpolate E-field onto these points: en_int = interpolate.interp2d(lon, lat, endata) ee_int = interpolate.interp2d(lon, lat, eedata)
x = np.linspace(-6, 6, 11) y = np.linspace(-6, 6, 11) xx, yy = np.meshgrid(x, y) z = f(xx, yy) x_new = np.linspace(-6, 6, 20) y_new = np.linspace(-6, 6, 20) xx_new, yy_new = np.meshgrid(x_new, y_new) z_true = f(xx_new, yy_new) f_scipy = interpolate.interp2d(x, y, z, kind='cubic') z_scipy = f_scipy(x_new, y_new) bicubic_interpolation2(x, y, z,"my_interp") import my_interp z_new = np.zeros((x_new.size, y_new.size)) for my_n, my_x in enumerate(x_new): for my_m, my_y in enumerate(y_new): z_new[my_n,my_m] = my_interp.my_interp(my_x, my_y) fig, ax = plt.subplots(2, 2, sharey=True, figsize=(16,12)) img0 = ax[0, 0].scatter(xx, yy, c=z, s=100) ax[0, 0].set_title('original points') fig.colorbar(img0, ax=ax[0, 0], orientation='vertical', shrink=1, pad=0.01)
def add_velocity_vectors(ax, ds, fn, v_scl=3, v_leglen=0.5, nngrid=80, zlev='top', center=(.8, .05)): # v_scl: scale velocity vector (smaller to get longer arrows) # v_leglen: m/s for velocity vector legend xc = center[0] yc = center[1] # GET DATA G = zrfun.get_basic_info(fn, only_G=True) if zlev == 'top': u = ds['u'][0, -1, :, :].squeeze() v = ds['v'][0, -1, :, :].squeeze() elif zlev == 'bot': u = ds['u'][0, 0, :, :].squeeze() v = ds['v'][0, 0, :, :].squeeze() else: zfull_u = get_zfull(ds, fn, 'u') zfull_v = get_zfull(ds, fn, 'v') u = get_laym(ds, zfull_u, ds['mask_u'][:], 'u', zlev).squeeze() v = get_laym(ds, zfull_v, ds['mask_v'][:], 'v', zlev).squeeze() # ADD VELOCITY VECTORS # set masked values to 0 ud = u.data ud[u.mask] = 0 vd = v.data vd[v.mask] = 0 # create interpolant import scipy.interpolate as intp ui = intp.interp2d(G['lon_u'][0, :], G['lat_u'][:, 0], ud) vi = intp.interp2d(G['lon_v'][0, :], G['lat_v'][:, 0], vd) # create regular grid aaa = ax.axis() daax = aaa[1] - aaa[0] daay = aaa[3] - aaa[2] axrat = np.cos(np.deg2rad(aaa[2])) * daax / daay x = np.linspace(aaa[0], aaa[1], int(round(nngrid * axrat))) y = np.linspace(aaa[2], aaa[3], int(nngrid)) xx, yy = np.meshgrid(x, y) # interpolate to regular grid uu = ui(x, y) vv = vi(x, y) mask = uu != 0 # plot velocity vectors ax.quiver(xx[mask], yy[mask], uu[mask], vv[mask], units='y', scale=v_scl, scale_units='y', color='k') ax.quiver([xc, xc], [yc, yc], [v_leglen, v_leglen], [v_leglen, v_leglen], units='y', scale=v_scl, scale_units='y', color='k', transform=ax.transAxes) ax.text(xc + .05, yc, str(v_leglen) + ' m/s', horizontalalignment='left', transform=ax.transAxes)
def load_data(stamp, burst, loc, meta, swath): ''' This script calibrates and loads input SLC images. ''' print('Reading...') time_1 = datetime.datetime.utcnow() if swath == 'IW1': str2 = '-004.xml' datastr = '-004.tiff' elif swath == 'IW2': str2 = '-005.xml' datastr = '-005.tiff' elif swath == 'IW3': str2 = '-006.xml' datastr = '-006.tiff' dataloc = glob.glob(loc + r'\measurement\*' + datastr) dataloc = dataloc[0] name = glob.glob(loc + r'\annotation\*' + str2) name = name[0] # Open element tree and retrieve parameters tree = ElementTree.parse(name) olp = tree.findall(".//imageAnnotation/imageInformation/numberOfSamples") mylist = [t.text for t in olp] no_pixels = int(mylist[0]) olp = tree.findall(".//imageAnnotation/imageInformation/numberOfLines") mylist = [t.text for t in olp] no_lines = int(mylist[0]) name = glob.glob(loc + r'\annotation\calibration\calibration*' + str2) name = name[0] # Open element tree and retrieve parameters tree = ElementTree.parse(name) # Load meta data in dictionary meta line = [] olp = tree.findall(".//calibrationVectorList/calibrationVector") for ele in olp: i = ele.findall('line') linei = [t.text for t in i] line.append(int(linei[0])) y = np.asarray(line) olp = tree.findall(".//calibrationVectorList/calibrationVector/pixel") for t in olp: t3 = t.text t1 = t3.split() t2 = [float(t) for t in t1] x = np.asarray(t2) olp = tree.findall(".//calibrationVectorList/calibrationVector/sigmaNought") for i,t in enumerate(olp): t3 = t.text t1 = t3.split() t2 = [float(t) for t in t1] if i ==0: t_arr = np.asarray(t2) else: t_arr0 = t_arr t_arr1 = np.asarray(t2) t_arr = np.vstack([t_arr0,t_arr1]) f = interpolate.interp2d(x, y, t_arr, kind='linear') xnew = np.arange(0, no_pixels, 1) ynew = np.arange(0, no_lines, 1) znew = f(xnew, ynew) ds = gdal.Open(dataloc) slc = np.array(ds.GetRasterBand(1).ReadAsArray()) ints = np.abs(slc) phase = np.angle(slc) s0 = np.sqrt(ints**2 / (znew**2)) #https://sentinel.esa.int/web/sentinel/radiometric-calibration-of-level-1-products slc_new = s0 * np.exp(1j * phase) print('Saving.....') # ~~~~Save data~~~~~ np.save(os.path.join(stamp, 'data_' + swath + '_slc.npy'), slc_new) time_2 = datetime.datetime.utcnow() diff_t = round((time_2 - time_1).total_seconds()) print('Calibration is finished in ' + str(diff_t) + ' seconds.') print('------------------------------------------------------------')
a_p = float(sys.arg[1]) m_p = float(sys.arg[2]) m_star = float(sys.arg[3]) R_H = a_p * (m_p / 3. * m_star)**{1 / 3.} e_p = float(sys.arg[4]) e_sat = float(sys.arg[5]) sub = int(sys.arg[6]) # 0 = moon, 1 = submoon if sub == 0: data = np.genfromtxt("Contour_moon.txt", delimiter=',', comments='#') else: data = np.genfromtxt("Contour_submoon.txt", delimiter=',', comments='#') X = data[:, 0] Y = data[:, 1] Z = data[:, 2] xi = np.arange(0.0, 0.51, 0.01) yi = np.arange(0.0, 0.51, 0.01) zi = griddata((X, Y), Z, (xi[None, :], yi[:, None]), method='linear', fill_value=0) f = interp2d(xi, yi, zi, kind='linear') print("a_c = %1.3f AU" % (f(e_p, e_sat)[0] * R_H))
def beddata(DEM, thicknessmap, bedsmoothing=300): """Function to read in datasets provided by Huss and solve for bed topography Inputs: 'DEM' and 'thicknessmap' should be filenames, 'bedsmoothing' should be the radius (in m) of smoothing to apply to bed. Default is 300m Outputs: xx, yy, zz arrays; bedinterp, thickinterp, seinterp 2d functions; xbounds, ybounds values """ SE = [] H = [] Z = [] hdrs_s = [] # Read and interpolate DEM with open(DEM, 'r') as f: #headarray = [ncols, nrows, xll, yll, cellsize, nodata_val] print 'Currently reading DEM' for num in xrange(0, 6, 1): headern = f.readline().split() #read info in header headerval = float(headern[1]) hdrs_s.append(headerval) ncols_s = int(hdrs_s[0]) nrows_s = int(hdrs_s[1]) xll_s = hdrs_s[2] yll_s = hdrs_s[3] delta_s = hdrs_s[4] lines = f.read().split( '\r\n') #lines in Huss files end with \r\n rather than \n alone for n in xrange( 0, (len(lines) - 1), 1 ): #leconte_dem file reads with empty line at end, need to ignore line = lines[n] splitup = line.split( ) #no splitter defined--will automatically see whitespace for ent in xrange( 0, len(splitup), 1 ): #every entry of DEM is surface elevation, first entry is tabbed SEval = float(splitup[ent]) SE.append(SEval) SE = np.array(SE) se = np.reshape(SE, (-1, ncols_s)) xs = [] ys = [] for i in xrange(0, ncols_s, 1): #x values change by column xs.append(xll_s + i * delta_s) for j in xrange(0, nrows_s, 1): #y values change by row ys.append(yll_s + j * delta_s) #ys = ys[::-1] seinterp = interpolate.interp2d(xs, ys, se, kind='linear', copy=True, bounds_error=False) #interpolated DEM # Read and interpolate thickness map hdrs_h = [] with open(thicknessmap, 'r') as f: print 'Currently reading ice thickness map' for num in xrange(0, 6, 1): headern = f.readline().split() #read info in header headerval = float(headern[1]) hdrs_h.append(headerval) ncols_h = int(hdrs_h[0]) nrows_h = int(hdrs_h[1]) xll_h = hdrs_h[2] if xll_h != xll_s: print 'Warning: DEM and thickness map grids start in different locations' yll_h = hdrs_h[3] delta_h = hdrs_h[4] lines = f.read().split( '\r\n') #lines in Huss files end with \r\n rather than \n alone for n in xrange( 0, (len(lines) - 1), 1 ): #leconte_thick file reads with empty line at end, need to ignore line = lines[n] splitup = line.split( ) #no splitter defined--will automatically see whitespace for ent in xrange(0, len(splitup), 1): Hval = float(splitup[ent]) H.append(Hval) H = np.array(H) hh = np.reshape(H, (-1, ncols_h)) xh = [] yh = [] for i in xrange(0, ncols_h, 1): #x values change by column xh.append(xll_h + i * delta_h) for j in xrange(0, nrows_h, 1): #y values change by row yh.append(yll_h + j * delta_h) #xh = xh[::-1] #yh = yh[::-1] thickinterp = interpolate.interp2d(xh, yh, hh, kind='linear', copy=True, bounds_error=False) #Find appropriate grid for interpolation; get bed xx = [] yy = [] ncols = max(ncols_s, ncols_h) nrows = max(nrows_s, nrows_h) if ncols == ncols_s: if nrows == nrows_s: print 'Finer grid is DEM' delta = delta_s xx = np.array(xs) yy = np.array(ys) yy = yy[::-1] hnew = thickinterp(xs, ys) zz = np.array(se) - np.array(hnew) else: print 'Error 1: grid sizes too different' if ncols == ncols_h: if nrows == nrows_h: print 'Finer grid is ice thickness' delta = delta_h xx = np.array(xh) yy = np.array(yh) #yy = yy[::-1] senew = seinterp(xh, yh) zz = np.array(senew) - np.array(hh) else: print 'Error 2: grid sizes too different' #print 'Reshaping y. REMEMBER to check output graphically!' #yy = yy[::-1] #not sure why this should be...surely for positive yll, y should be increasing? This makes the picture of Chenega correct...may need to check again #Smoothing bed if bedsmoothing == None: unsmoothZ = zz #just return zz unsmoothed else: dsmooth = ceil(bedsmoothing / delta) #smoothing zz = gaussian_filter(zz, dsmooth) #smoothing the bed bedinterp = interpolate.interp2d( xx, yy, zz, kind='linear', copy=True, bounds_error=True) #might need to do transpose of Z as in Columbia? #finding bounds xbounds = (min(xx), max(xx)) ybounds = (min(yy), max(yy)) return (xx, yy, zz, bedinterp, thickinterp, seinterp, xbounds, ybounds)
q = np.zeros((TP, TP)) # q=np.ones((TP,TP)) Sol_N_next = ADI(Sol_N, x, dx, right_um, bottom_um, top_um, mu, a, b, c, d, TP, q) #for 2N N = N + N Sol_2N, x_ex, dx_ex, right_um_ex, bottom_um_ex, top_um_ex, mu_ex, a_ex, b_ex, c_ex, d_ex, TP_ex = Set_up( N, dt) q = np.zeros((TP_ex, TP_ex)) # q=np.ones((TP_ex,TP_ex)) Sol_2N_next = ADI(Sol_2N, x_ex, dx_ex, right_um_ex, bottom_um_ex, top_um_ex, mu_ex, a_ex, b_ex, c_ex, d_ex, TP_ex, q) # Interpolate the values from the 2N grid so the points match up to the same physical location #Interpolate the finer grid values to the coarser grid the_interloper = interpolate.interp2d(x_ex, x_ex, Sol_2N_next, kind='cubic') Sol_int = the_interloper(x, x) #find the biggest difference between the solutions Diff_Matrix = abs(Sol_N_next[1:-1, 1:-1] - Sol_int[1:-1, 1:-1]) max_diff = Diff_Matrix.max() #Doubling the number of grid points resulted in less than "CLOSE ENOUGH' maximum difference between the two solutions #We will call this convereged and go back to the previous N value for the steady state solution #The 2N grid will serve as our "Exact'" Solution #So that the steady state solution will have N grid points, and the "Exact" solution will have 2N grid points. #N-final is just for reference, N_final = round(N / 2) N_ex = N # =============================================================================
def __init__(self): self._atlas501 = interp2d(_vinfs_A5, _decls_A5, _data_A5, kind='linear', fill_value=0.1, copy=False) self._soyuzf = interp2d(_vinfs_SF, _decls_SF, _data_SF, kind='linear', fill_value=1e-3, copy=False)
def merge_and_cut(filename_low, filename_height, output_dir, start_zoom, end_zoom): if not os.path.exists(filename_low) or not os.path.exists(filename_height): return None data_set_low = gdal.Open(filename_low) if data_set_low is None: print('Read %s failed' % filename_low) return None data_set_height = gdal.Open(filename_height) if data_set_height is None: print('Read %s failed' % filename_height) return None band_low = data_set_low.GetRasterBand(1) if band_low is None: print('Read %s band failed' % filename_low) return None x_size_low, y_size_low = data_set_low.RasterXSize, data_set_low.RasterYSize x0_low, dx_low, _, y0_low, _, dy_low = data_set_low.GetGeoTransform() band_height = data_set_height.GetRasterBand(1) if band_height is None: print('Read %s band failed' % filename_height) return None x_size_height, y_size_height = data_set_height.RasterXSize, data_set_height.RasterYSize x0_height, dx_height, _, y0_height, _, dy_height = data_set_height.GetGeoTransform() min_lng_height = x0_height min_lat_height = y0_height max_lng_height = x0_height + x_size_height * dx_height max_lat_height = y0_height + y_size_height * dy_height min_lng_low = x0_low min_lat_low = y0_low max_lng_low = x0_low + x_size_low * dx_low max_lat_low = y0_low + y_size_low * dy_low x_offset = round((min_lng_height - min_lng_low) / dx_low) y_offset = round((min_lat_height - min_lat_low) / dy_low) x_size = round((max_lng_height - min_lng_height) / dx_low) y_size = round((max_lat_height - min_lat_height) / dy_low) bounds = get_tif_tile_bounds(filename_height, output_dir, start_zoom) if bounds == {}: return _, value = next(iter(bounds.items())) _zoom_size_low = round((value[2] - value[0]) / dx_low) buf_size = _zoom_size_low + 128 # 设置 buf 大小大于一块地形的 size,保证按块取数据时,块是完整的 z_low_with_buf = band_low.ReadAsArray(x_offset - buf_size, y_offset - buf_size, x_size + buf_size * 2, y_size + buf_size * 2).astype('f4') # z_height = band_height.ReadAsArray(0, 0, x_size_height, y_size_height).astype('f4') for zoom in range(start_zoom, end_zoom + 1): ratio = 2 ** (zoom - start_zoom) dsize_low = ((x_size + buf_size * 2) * ratio, (y_size + buf_size * 2) * ratio) _z_low_with_buf = cv2.resize(src=z_low_with_buf, dsize=dsize_low, interpolation=cv2.INTER_LINEAR) dsize_height = (x_size * ratio, y_size * ratio) _z_height = cv2.resize(src=z_height, dsize=dsize_height, interpolation=cv2.INTER_CUBIC) z_height = band_height.ReadAsArray(0, 0, x_size_height, y_size_height, x_size * ratio, y_size * ratio).\ astype('f4') _z_height = z_height bound_yx = get_data_bound(_z_height, 0.8) # 如果没有边界 则,不融合,直接采用低精度数据 cut if bound_yx.shape[0] != 0: bound_yx = bound_yx.astype('i4') _x = np.zeros(shape=(0, 1)) # x y z 添加边界值 _y = np.zeros(shape=(0, 1)) _z = np.zeros(shape=(0, 1)) for _bound_yx in bound_yx: _bound_y_height = _bound_yx[0] _bound_x_height = _bound_yx[1] _bound_z_height = _z_height[_bound_y_height, _bound_x_height] _bound_y_low = _bound_yx[0] + buf_size * ratio _bound_x_low = _bound_yx[1] + buf_size * ratio _bound_z_low = _z_low_with_buf[_bound_y_low, _bound_x_low] _z_d = _bound_z_height - _bound_z_low _x = np.vstack((_x, _bound_x_low)) _y = np.vstack((_y, _bound_y_low)) _z = np.vstack((_z, _z_d)) # x y z 添加边界值缓冲边界 0 值 _xy = np.hstack((_x, _y)) _m_point = MultiPoint(_xy) _zero_bound = _m_point.buffer(50) _zero_bound_xy = _zero_bound.exterior.coords.xy _zero_bound_x = np.around(np.array(_zero_bound_xy[0])).reshape(len(_zero_bound_xy[0]), -1) _zero_bound_y = np.around(np.array(_zero_bound_xy[1])).reshape(len(_zero_bound_xy[1]), -1) _zero_bound_z = np.zeros(shape=(_zero_bound_x.shape)) _x = np.vstack((_x, _zero_bound_x)) _y = np.vstack((_y, _zero_bound_y)) _z = np.vstack((_z, _zero_bound_z)) # x y z 添加数据边界 0 值 for _x_edge in range(0, (x_size + buf_size * 2) * ratio): _x = np.vstack((_x, [_x_edge])) _y = np.vstack((_y, [0])) _x = np.vstack((_x, [_x_edge])) _y = np.vstack((_y, [(y_size + buf_size * 2) * ratio])) _z = np.vstack((_z, [[0], [0]])) for _y_edge in range(0, (y_size + buf_size * 2) * ratio): _y = np.vstack((_y, [_y_edge])) _x = np.vstack((_x, [0])) _y = np.vstack((_y, [_y_edge])) _x = np.vstack((_x, [(x_size + buf_size * 2) * ratio])) _z = np.vstack((_z, [[0], [0]])) # _xy = np.hstack((_x, _y)) # grid = np.mgrid[0:(x_size + buf_size * 2) * ratio, 0:(y_size + buf_size * 2) * ratio] # _z_d_new = interpolate.griddata(_xy, _z, grid, method='linear') func = interpolate.interp2d(_x, _y, _z, kind='linear') _x_new = np.arange(0, (x_size + buf_size * 2) * ratio) _y_new = np.arange(0, (y_size + buf_size * 2) * ratio) _z_d_new = func(_x_new, _y_new) _z_low_with_buf = _z_low_with_buf + _z_d_new for y in range(y_size * ratio): for x in range(x_size * ratio): _z_height_v = _z_height[y][x] y_low = y + buf_size * ratio x_low = x + buf_size * ratio _z_low_v = _z_low_with_buf[y_low][x_low] if abs(_z_height_v - 0) > 0.001 and abs(_z_height_v - _z_low_v) > 0.001: _z_low_with_buf[y_low][x_low] = _z_height_v # cut z_merged = _z_low_with_buf blc_bounds = get_tif_tile_bounds(filename_height, output_dir, zoom) for fname in blc_bounds: blc_bound = blc_bounds[fname] blc_x_min_low = round((blc_bound[0] - min_lng_low) / dx_low) blc_y_min_low = round((blc_bound[3] - min_lat_low) / dy_low) blc_x_max_low = round((blc_bound[2] - min_lng_low) / dx_low) blc_y_max_low = round((blc_bound[1] - min_lat_low) / dy_low) blc_x_offset_low = (blc_x_min_low - x_offset + buf_size) * ratio blc_y_offset_low = (blc_y_min_low - y_offset + buf_size) * ratio blc_x_size_low = (blc_x_max_low - blc_x_min_low) * ratio blc_y_size_low = (blc_y_max_low - blc_y_min_low) * ratio blc_z_low = z_merged[blc_y_offset_low:blc_y_offset_low + blc_y_size_low, blc_x_offset_low:blc_x_offset_low + blc_x_size_low] points_xyz = [] z_low = np.array(blc_z_low) for x in range(blc_z_low.shape[1]): for y in range(blc_z_low.shape[0]): point_xyz = [x, y, blc_z_low[y, x]] points_xyz.append(point_xyz) points_xyz = np.array(points_xyz) points_xy = points_xyz[:, 0:2] tri = Delaunay(points_xy) index = tri.simplices points_xyz = (points_xyz + (blc_x_min_low, blc_y_min_low, 0)) * (dx_low, dy_low, 1) + (x0_low, y0_low, 0) write_terrain(fname, points_xyz, index)
newC = math.floor(ratioC * oldC) # newImg = np.zeros((newR,newC)) stepR = (newR - 1) / oldR startR = stepR / 2 stepC = (newC - 1) / oldC startC = stepC / 2 # gridX, gridY = np.meshgrid(range(newR),range(newC)) meshVecR = np.arange(startR, newR, stepR)[:oldR] meshVecC = np.arange(startC, newC, stepC)[:oldC] # gridR, gridC = np.meshgrid(meshVecR, meshVecC) # newImg = griddata(gridR, gridC, (gridX, gridY), method='cubic') linImgFunc = interp2d(meshVecC, meshVecR, img, kind='linear') linNewImg = linImgFunc(range(newC), range(newR)) cubImgFunc = interp2d(meshVecC, meshVecR, img, kind='cubic') cubNewImg = cubImgFunc(range(newC), range(newR)) plt.figure() plt.imshow(linNewImg, cmap="gray") plt.figure() plt.imshow(cubNewImg, cmap="gray") plt.figure() plt.imshow(np.abs(linNewImg - cubNewImg), cmap='gray')
def velocity_conversion(self, two_dimensional=True): from scipy.interpolate import interp2d #create interpolant vp_interpolator = interp2d(self.P_table_axis, self.T_table_axis, self.vp_table) vs_interpolator = interp2d(self.P_table_axis, self.T_table_axis, self.vs_table) rho_interpolator = interp2d(self.P_table_axis, self.T_table_axis, self.rho_table) def get_vals_1d(self, gravity='constant'): ''' get 1d profiles of pressure, Vp, Vs, and density ''' self.P1d = np.zeros((self.npts_rad)) self.vp1d = np.zeros((self.npts_rad)) self.vs1d = np.zeros((self.npts_rad)) self.rho1d = np.zeros((self.npts_rad)) if gravity == 'constant': g = 9.8 else: print "only constant gravity is currently implemented" for i in range(0, self.npts_rad): if self.T_adiabat[i] < 300: T_here = 300.0 else: T_here = self.T_adiabat[i] self.vp1d[i] = vp_interpolator(self.P1d[i], T_here) self.vs1d[i] = vs_interpolator(self.P1d[i], T_here) self.rho1d[i] = rho_interpolator(self.P1d[i], T_here) weight_of_layer = self.rho1d[i] * g * self.dpr_km * 1000.0 weight_of_layer *= 1e-5 #convert form Pa to bar if i + 1 < self.npts_rad: self.P1d[i + 1] = self.P1d[i] + weight_of_layer def get_vals_2d(self): #initialize arrays self.vp_array = np.zeros((self.npts_rad, self.npts_theta)) self.vs_array = np.zeros((self.npts_rad, self.npts_theta)) self.rho_array = np.zeros((self.npts_rad, self.npts_theta)) self.dvp_abs = np.zeros((self.npts_rad, self.npts_theta)) self.dvs_abs = np.zeros((self.npts_rad, self.npts_theta)) self.drho_abs = np.zeros((self.npts_rad, self.npts_theta)) self.dvp_rel = np.zeros((self.npts_rad, self.npts_theta)) self.dvs_rel = np.zeros((self.npts_rad, self.npts_theta)) self.drho_rel = np.zeros((self.npts_rad, self.npts_theta)) for i in range(0, self.npts_rad): for j in range(0, self.npts_theta): #absolute values self.vp_array[i, j] = vp_interpolator(self.P1d[i], self.T[i, j]) self.vs_array[i, j] = vs_interpolator(self.P1d[i], self.T[i, j]) self.rho_array[i, j] = rho_interpolator( self.P1d[i], self.T[i, j]) #absolute perturbations self.dvp_abs[i, j] = self.vp_array[i, j] - self.vp1d[i] self.dvs_abs[i, j] = self.vs_array[i, j] - self.vs1d[i] self.drho_abs[i, j] = self.rho_array[i, j] - self.rho1d[i] self.drho_abs[i, j] /= 1000.0 #convert from kg/m3 to g/cm3 #percent perturbations self.dvp_rel[i, j] = ((self.vp_array[i, j] - self.vp1d[i]) / self.vp1d[i]) * 100.0 self.dvs_rel[i, j] = ((self.vs_array[i, j] - self.vs1d[i]) / self.vs1d[i]) * 100.0 self.drho_rel[i, j] = ( (self.rho_array[i, j] - self.rho1d[i]) / self.rho1d[i]) * 100.0 def main(self, two_dimensional): get_vals_1d(self, gravity='constant') if two_dimensional == True: get_vals_2d(self) main(self, two_dimensional)
def make_dataset(play, event_frame, metrica_attack, metrica_defence, bokeh_attack, bokeh_defence, field_dimen=( 106., 68., ), new_grid_size=500): params = mpc.default_model_params(3) event = events_df.loc[[(play, int(event_frame))]] tracking_frame = event['Start Frame'][0] att_frame = bokeh_attack.loc[(play, tracking_frame)] att_player_frame = att_frame[att_frame['player'] != "ball"] att_player_frame['Shirt Number'] = att_player_frame['player'].map( int).map(shirt_mapping[play]).fillna("") def_frame = bokeh_defence.loc[(play, tracking_frame)] def_player_frame = def_frame[def_frame['player'] != "ball"] def_player_frame['Shirt Number'] = def_player_frame['player'].map( int).map(shirt_mapping[play]).fillna("") ball_frame = att_frame[att_frame['player'] == "ball"] PPCF, xgrid, ygrid = pvm.lastrow_generate_pitch_control_for_event( play, event_frame, events_df, metrica_attack, metrica_defence, params, field_dimen=( 106., 68., ), n_grid_cells_x=50) PT = pvm.generate_relevance_at_event(play, event_frame, events_df, PPCF, params) PS = pvm.generate_scoring_opportunity(field_dimen=( 106., 68., ), n_grid_cells_x=50) PPV = pvm.generate_pitch_value(PPCF, PT, PS, field_dimen=( 106., 68., ), n_grid_cells_x=50) RPPV = pvm.generate_relative_pitch_value(play, event_frame, events_df, metrica_attack, PPV, xgrid, ygrid) xgrid_new = np.linspace(-field_dimen[0] / 2., field_dimen[0] / 2., new_grid_size) ygrid_new = np.linspace(-field_dimen[1] / 2., field_dimen[1] / 2., new_grid_size) PPCF_int = interpolate.interp2d(xgrid, ygrid, PPCF, kind='cubic') PPCF_new = PPCF_int(xgrid_new, ygrid_new) PPCF_dict = dict(image=[PPCF_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) PT_int = interpolate.interp2d(xgrid, ygrid, PT, kind='cubic') PT_new = PT_int(xgrid_new, ygrid_new) PT_dict = dict(image=[PT_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) PS_int = interpolate.interp2d(xgrid, ygrid, PS, kind='cubic') PS_new = PS_int(xgrid_new, ygrid_new) PS_dict = dict(image=[PS_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) PPV_int = interpolate.interp2d(xgrid, ygrid, PPV, kind='cubic') PPV_new = PPV_int(xgrid_new, ygrid_new) PPV_dict = dict(image=[PPV_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) RPPV_int = interpolate.interp2d(xgrid, ygrid, RPPV, kind='cubic') RPPV_new = RPPV_int(xgrid_new, ygrid_new) RPPV_dict = dict(image=[RPPV_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) event_src = ColumnDataSource(event) att_src = ColumnDataSource(att_player_frame) def_src = ColumnDataSource(def_player_frame) ball_src = ColumnDataSource(ball_frame) PPCF_src = ColumnDataSource(PPCF_dict) PT_src = ColumnDataSource(PT_dict) PS_src = ColumnDataSource(PS_dict) PPV_src = ColumnDataSource(PPV_dict) RPPV_src = ColumnDataSource(RPPV_dict) return event_src, att_src, def_src, ball_src, PPCF_src, PT_src, PS_src, PPV_src, RPPV_src, xgrid, ygrid
ylabels = [r"$\beta$", r"$\delta_{p}$", r"$\delta_{m}$", r"$\delta_{p}$"] ind = np.random.choice(range(results_rep_space.shape[0]), 10000) heatAxes = [(0,3),(0,5), (3,4), (3,5)] k = 1 for heatAxis in heatAxes: i = heatAxis[0] j = heatAxis[1] x = results_rep_space[:, i] y = results_rep_space[:, j] z = results_rep_cost x = x[ind] y = y[ind] z = z[ind] #interpolates the data on a grid f = interp2d(x,y,z, kind='linear') xi = np.linspace(min(x), max(x), 150) yi = np.linspace(min(y), max(y), 150) ZI = f(xi,yi) plt.subplot(2,2,k) plt.xlabel(xlabels[k - 1]) plt.ylabel(ylabels[k - 1]) XI, YI = np.meshgrid(xi, yi) plt.pcolor(XI, YI, ZI, cmap=cm.jet_r, vmax=0, rasterized=True) plt.xlim(min(xi), max(xi)) plt.ylim(min(yi), max(yi)) plt.colorbar() k += 1
def tableLookUpTwoImplicit(x_ave, x_var, p0, p1, filename='flameletTable.h5', p0_name='ProgressVariable', p1_name='ProgressVariableVariance'): with h5py.File(filename, 'r') as f: table = f['flameletTable'] variable = list(f['variable']) x_ave_axis = np.array(f[table.dims[1].label]) x_var_axis = np.array(f[table.dims[2].label]) param_axis_0 = np.array(f[table.dims[3].label]) param_axis_1 = np.array(f[table.dims[4].label]) data = np.array(table) idx_p0 = variable.index(p0_name) idx_p1 = variable.index(p1_name) param_table = np.empty((2, ) + data.shape[3:]) # interpolate with explicit index for i in range(param_axis_0.size): for j in range(param_axis_1.size): f = interpolate.interp2d(x_var_axis, x_ave_axis, data[idx_p0, :, :, i, j]) param_table[0, i, j] = f(x_var, x_ave) f = interpolate.interp2d(x_var_axis, x_ave_axis, data[idx_p1, :, :, i, j]) param_table[1, i, j] = f(x_var, x_ave) # interpolate with implicit index # inverse table table_inverse = np.empty((2, param_axis_0.size)) for i in range(param_axis_0.size): f = interpolate.interp1d(param_table[1, i, :], param_table[0, i, :], bounds_error=False, fill_value=(param_table[0, i, 0], param_table[0, i, -1])) table_inverse[0, i] = f(p1) f = interpolate.interp1d(param_table[1, i, :], param_axis_1, bounds_error=False, fill_value=(param_axis_1[0], param_axis_1[-1])) table_inverse[1, i] = f(p1) f = interpolate.interp1d(table_inverse[0, :], table_inverse[1, :], bounds_error=False, fill_value=(table_inverse[1, 0], table_inverse[1, -1])) param_1 = f(p0) f = interpolate.interp1d(table_inverse[0, :], param_axis_0, bounds_error=False, fill_value=(param_axis_0[0], param_axis_0[-1])) param_0 = f(p0) # interpolate all variables var_table = np.empty((data.shape[0], ) + data.shape[3:]) for k in range(data.shape[0]): for i in range(param_axis_0.size): for j in range(param_axis_1.size): f = interpolate.interp2d(x_var_axis, x_ave_axis, data[k, :, :, i, j]) var_table[k, i, j] = f(x_var, x_ave) phi = np.zeros(var_table.shape[0]) for k in range(var_table.shape[0]): f = interpolate.interp2d(param_axis_1, param_axis_0, var_table[k, :, :]) phi[k] = f(param_0, param_1) return phi
def test_reconstruct_phase_nonstandard(lazy): """Testing reconstruction with non-standard output size for stacked images""" if lazy == True: pytest.skip("Dask array flags not supported") gc.collect() x2, z2, y2 = np.meshgrid(LS, np.array([0, 1]), LS) phase_ref2 = calc_phaseref(x2, y2, z2, img_size / 2.2, img_size / 2.2) holo2 = calc_holo(x2, y2, phase_ref2, FRINGE_SPACING, FRINGE_DIRECTION) ref2 = calc_holo(x2, y2, 0, FRINGE_SPACING, FRINGE_DIRECTION) holo_image2 = hs.signals.HologramImage(holo2) ref_image2 = hs.signals.HologramImage(ref2) del x2, z2, y2 gc.collect() if lazy: ref_image2 = ref_image2.as_lazy() holo_image2 = holo_image2.as_lazy() sb_position2 = ref_image2.estimate_sideband_position(sb="upper") sb_position2_lower = ref_image2.estimate_sideband_position(sb="lower", ) sb_position2_left = ref_image2.estimate_sideband_position(sb="left", ) sb_position2_right = ref_image2.estimate_sideband_position(sb="right", ) np.testing.assert_allclose(sb_position2, sb_position2_left) np.testing.assert_allclose(sb_position2_lower, sb_position2_right) sb_size2 = ref_image2.estimate_sideband_size(sb_position2) output_shape = ( int(sb_size2.inav[0].data * 2), int(sb_size2.inav[0].data * 2), ) wave_image2 = holo_image2.reconstruct_phase( reference=ref_image2, sb_position=sb_position2, sb_size=sb_size2, sb_smoothness=sb_size2 * 0.05, output_shape=output_shape, ) # a. Reconstruction with parameters provided as ndarrays should be # identical to above: wave_image2a = holo_image2.reconstruct_phase( reference=ref_image2.data, sb_position=sb_position2.data, sb_size=sb_size2.data, sb_smoothness=sb_size2.data * 0.05, output_shape=output_shape, ) np.testing.assert_allclose(wave_image2, wave_image2a) del wave_image2a gc.collect() # interpolate reconstructed phase to compare with the input (reference # phase): interp_x = np.arange(output_shape[0]) phase_interp0 = interp2d( interp_x, interp_x, wave_image2.inav[0].unwrapped_phase().data, kind="cubic", ) phase_new0 = phase_interp0( np.linspace(0, output_shape[0], img_size), np.linspace(0, output_shape[0], img_size), ) phase_interp1 = interp2d( interp_x, interp_x, wave_image2.inav[1].unwrapped_phase().data, kind="cubic", ) phase_new1 = phase_interp1( np.linspace(0, output_shape[0], img_size), np.linspace(0, output_shape[0], img_size), ) X_START = int(img_size / 10) X_STOP = img_size - 1 - int(img_size / 10) phase_new_crop0 = phase_new0[X_START:X_STOP, X_START:X_STOP] phase_new_crop1 = phase_new1[X_START:X_STOP, X_START:X_STOP] phase_ref_crop0 = phase_ref2[0, X_START:X_STOP, X_START:X_STOP] phase_ref_crop1 = phase_ref2[1, X_START:X_STOP, X_START:X_STOP] np.testing.assert_allclose(phase_new_crop0, phase_ref_crop0, atol=0.05) np.testing.assert_allclose(phase_new_crop1, phase_ref_crop1, atol=0.04)
def plot_results(self, file_name): import matplotlib.pyplot as plt ribs, shell_thick, max_stress, max_disp, weight = self.read_data_file( file_name, use_abaqus=True) # max_stress = max_stress_fixed n_rib = len(ribs) n_thick = len(shell_thick) opti_ribs = [] opti_shell = [] opti_weight = [] rib_mat, shell_mat = np.meshgrid(ribs, shell_thick) # interpol weight f_weight = interpolate.interp2d(rib_mat, shell_mat, weight, kind='linear') plot1 = PlotHelper(['ribs', 'max stress']) for i in range(0, len(shell_thick)): stress = max_stress[i] # if np.min(stress) < max_shear_strength and np.max(stress) > max_shear_strength: # optRibs = np.interp(max_shear_strength, stress, ribs) # f = interp1d(stress, ribs, kind='linear') # plot1.ax.plot([f(max_shear_strength)], [max_shear_strength], 'go') # opti_ribs.append(f(max_shear_strength)) # opti_shell.append(shellThick[i]) plot1.ax.plot(ribs, max_stress[i], label='shell= {:03f}'.format(shell_thick[i])) plot1.ax.plot(ribs, np.full((len(ribs), 1), max_shear_strength), 'r--', label='Limit-Load') plot1.finalize(legendNcol=2, tighten_layout=False) # plot1.show() plot2 = PlotHelper(['shellthickness in mm', 'max stress']) for i in range(0, len(ribs)): stress = max_stress[:, i] plot2.ax.plot(shell_thick, stress, label='ribs= {:f}'.format(ribs[i])) if np.min(stress) < max_shear_strength and np.max( stress) > max_shear_strength: # optRibs = np.interp(max_shear_strength, stress, ribs) f = interp1d(stress, shell_thick, kind='linear') plot2.ax.plot([f(max_shear_strength)], [max_shear_strength], 'go') opti_ribs.append(ribs[i]) opti_shell.append(f(max_shear_strength)) opti_weight.append(f_weight(ribs[i], f(max_shear_strength))[0]) plot2.ax.plot(shell_thick, np.full((len(shell_thick), 1), max_shear_strength), 'r--', label='Limit-Load') # plot2.ax.set_xlim((min([x * 1000 for x in shellThick]), max([x * 1000 for x in shellThick]))) plot2.finalize(legendNcol=2) plot2.show() opti_min_index = opti_weight.index(min(opti_weight)) print('opt wight {:03f}'.format(opti_weight[opti_min_index])) print('@ {:00f} ribs'.format(opti_ribs[opti_min_index])) print('@ {:05f} shell-thickness'.format(opti_shell[opti_min_index])) plot3d = PlotHelper(['ribs', 'shell thickness in m', 'mises stress']) max_stress[max_stress > 1.2 * max_shear_strength] = np.nan color_map = plt.cm.jet(weight / np.max(weight)) surf = plot3d.ax.plot_surface(rib_mat, shell_mat, max_stress, facecolors=color_map, cstride=1, rstride=1) optiLine = plot3d.ax.plot(opti_ribs, opti_shell, max_shear_strength, 'k--', label='Limit-Load') optiPoint = plot3d.ax.plot([opti_ribs[opti_min_index]], [opti_shell[opti_min_index]], max_shear_strength, 'ro', label='glob. optimum') m = cm.ScalarMappable(cmap=cm.jet) m.set_array(weight) cbar = plt.colorbar(m) cbar.set_label('structure weight in kg', rotation=270) limit = np.full((n_thick, n_rib), max_shear_strength) plot3d.ax.plot_wireframe(rib_mat, shell_mat, limit, color='r', alpha=0.1) plot3d.ax.set_zlim3d(0, max_shear_strength) plot3d.finalize() plot3d.show()
def preprocesser(vals, refine=2, Rm_Outliers=False, Filter=True, Median=False, Mean=True): # Determine spatial resolution resolution = vals.shape[0] if Rm_Outliers: # Identify and remove outliers outlier_buffer = 5 vals_list = vals.reshape((resolution * resolution, )) vals_mins = heapq.nsmallest(outlier_buffer, vals_list) vals_maxes = heapq.nlargest(outlier_buffer, vals_list) # Cap max and min vals_min = np.max(vals_mins) vals_max = np.min(vals_maxes) # Trim outliers over = (vals > vals_max) under = (vals < vals_min) # Remove outliers vals[over] = vals_max vals[under] = vals_min else: vals_min = np.max(vals) vals_max = np.min(vals) if Filter: # Apply median/mean filter if Median: vals = median_filter(vals) if Mean: vals = mean_filter(vals) # Create grid start = 0.0 end = 1.0 x = np.linspace(start, end, resolution) y = np.linspace(start, end, resolution) [X, Y] = np.meshgrid(x, y) interp_vals = interp2d(x, y, vals, kind='cubic') # Create refined grid plot_start = 0.0 plot_end = 1.0 plot_x = np.linspace(plot_start, plot_end, refine * resolution) plot_y = np.linspace(plot_start, plot_end, refine * resolution) [plot_X, plot_Y] = np.meshgrid(plot_x, plot_y) vals_int_values = interp_vals(plot_x, plot_y) return vals_int_values, plot_X, plot_Y
v=[] error = data['spd'] #error = data['ame'] for mem in ['10']: for loc in error[mem].keys(): # print('mem/loc',mem,loc,error[mem][loc]) z = [] for i,value in enumerate(error[mem][loc]): z.append(value) v.append(z) mem = '10' x = np.asarray([1.0, 1.01, 1.03, 1.05, 1.07, 1.09, 1.11, 1.13, 1.15, 1.17, 1.19]) y = np.arange(5,40.1,5) f = interpolate.interp2d(x, y, v, kind='cubic') xx = np.arange(1.0,1.191,0.01) yy = np.arange(5,40.1,0.5) xx = x yy = y X, Y = np.meshgrid(xx, yy) Z = f(xx,yy) #print(type(Z),type(X),type(Y)) fig, ax = plt.subplots() SD = ax.contourf(X, Y, Z, 100, zorder=0, cmap='jet') plt.colorbar(SD) CS = ax.contour(X, Y, Z, 20, colors='black', zorder=1)
def __init__(self): # paramsmeters of car self.Wheel_R = 0.287 self.mass = 1449 self.C_roll = 0.013 self.density_air = 1.2 self.area_frontal = 2.23 self.G = 9.81 self.C_d = 0.26 # the factor of F_roll self.T_factor = 1 # paramsmeters of transmission system # number of teeth self.Pgs_R = 78 self.Pgs_S = 30 # speed ratio from ring gear to wheel self.Pgs_K = 3.93 # The optimal curve of engine self.Eng_pwr_opt_list = np.arange(0, 57, 1) * 1000 #T_list = [0.0, 11.93662073189215, 23.8732414637843, 35.80986219567645, 47.7464829275686, 59.68310365946075, 71.6197243913529, 78.64126599834829, 84.88263631567752, 76.73541899073525, 82.3215222889114, 82.71044286665428, 84.25849928394459, 89.30996806595566, 83.03736161316279, 87.87696244337779, 88.31719385446216, 92.7645954021333, 98.22133630814113, 98.6068669156308, 97.94150344116636, 99.768770296412, 101.98277906859313, 104.09185851507847, 96.70173757482249, 105.16846459816874, 101.75479968170357, 103.54658948147409, 105.683914780389, 107.75470855248945, 109.34309067382122, 110.04765581818786, 110.7164821508837, 112.14476417151343, 113.92143294998826, 116.05047933784036, 117.73105379400477, 119.36620731892151, 120.95775674984046, 121.70672118791997, 121.64709026132127, 121.96920872463008, 121.90591385762197, 121.84562408815725, 121.7881303659721, 121.73324259153468, 121.68078751624131, 121.96112486933283, 121.58255599593066, 121.85300330473238, 121.80225236624644, 121.75353146529994, 121.70672118791995, 121.36995660245255, 121.90591385762195, 121.85877313300573, 121.81335052135952] self.W_list = [ 91.106186954104, 83.77580409572782, 83.77580409572782, 83.77580409572782, 83.77580409572782, 83.77580409572782, 83.77580409572782, 89.0117918517108, 94.24777960769379, 117.28612573401894, 121.47491593880532, 132.9940890019679, 142.4188669627373, 145.56045961632708, 168.59880574265222, 170.69320084504542, 181.1651763570114, 183.25957145940458, 183.25957145940458, 192.684349420174, 204.20352248333657, 210.48670779051614, 215.72269554649912, 220.95868330248211, 248.18581963359367, 237.71384412162766, 255.51620249196986, 260.7521902479528, 264.9409804527392, 269.1297706575256, 274.3657584135086, 281.69614127188476, 289.026524130261, 294.262511886244, 298.4513020910303, 301.59289474462014, 305.78168494940655, 309.9704751541929, 314.1592653589793, 320.4424506661589, 328.8200310757317, 336.15041393410786, 344.52799434368063, 352.90557475325346, 361.2831551628262, 369.660735572399, 378.0383159819718, 385.368698840348, 394.7934768011173, 402.12385965949346, 410.5014400690663, 418.87902047863906, 427.2566008882119, 436.6813788489813, 442.96456415616086, 451.3421445657336, 459.7197249753064 ] self.Eng_pwr_func = interp1d(self.Eng_pwr_opt_list, self.W_list) Eng_spd_list = np.arange(0, 4501, 125) * (2 * math.pi) / 60 Eng_spd_list = Eng_spd_list[np.newaxis, :] Eng_trq_list = np.arange(0, 111, 5) * (121 / 110) Eng_trq_list = Eng_trq_list[np.newaxis, :] data_path = 'Eng_bsfc_map.mat' data = scio.loadmat(data_path) Eng_bsfc_map = data['Eng_bsfc_map'] self.Eng_trq_maxP = [ -4.1757e-009, 6.2173e-006, -3.4870e-003, 9.1743e-001, 2.0158e+001 ] Eng_fuel_map = Eng_bsfc_map * (Eng_spd_list.T * Eng_trq_list) / 3600 / 1000 # fuel consumption (g) self.Eng_fuel_func = interp2d(Eng_trq_list, Eng_spd_list, Eng_fuel_map) # Motor 1 # motor speed list (rad/s) Mot_spd_list = np.arange(-6000, 6001, 200) * (2 * math.pi) / 60 # motor torque list (Nm) Mot_trq_list = np.arange(-400, 401, 10) # motor efficiency map data_path1 = 'Mot_eta_quarter.mat' data1 = scio.loadmat(data_path1) Mot_eta_quarter = data1['Mot_eta_quarter'] Mot_eta_alltrqs = np.concatenate( ([np.fliplr(Mot_eta_quarter[:, 1:]), Mot_eta_quarter]), axis=1) Mot_eta_map = np.concatenate( ([np.flipud(Mot_eta_alltrqs[1:, :]), Mot_eta_alltrqs])) # motor efficiency self.Mot_eta_map_func = interp2d(Mot_trq_list, Mot_spd_list, Mot_eta_map) # motor maximum torque Mot_trq_max_quarter = np.array([ 400, 400, 400, 400, 400, 400, 400, 347.200000000000, 297.800000000000, 269.400000000000, 241, 221.800000000000, 202.600000000000, 186.400000000000, 173.200000000000, 160, 148, 136, 126.200000000000, 118.600000000000, 111, 105.800000000000, 100.600000000000, 96.2000000000000, 92.6000000000000, 89, 87.4000000000000, 85.8000000000000, 83.2000000000000, 79.6000000000000, 76 ]) Mot_trq_max_quarter = Mot_trq_max_quarter[np.newaxis, :] Mot_trq_max_list = np.concatenate( (np.fliplr(Mot_trq_max_quarter[:, 1:]), Mot_trq_max_quarter), axis=1) # motor minimum torque Mot_trq_min_list = -Mot_trq_max_list self.Mot_trq_min_func = interp1d(Mot_spd_list, Mot_trq_min_list, kind='linear', fill_value='extrapolate') self.Mot_trq_max_func = interp1d(Mot_spd_list, Mot_trq_max_list, kind='linear', fill_value='extrapolate') # Generator (Motor 2) # generator speed list (rad/s) Gen_spd_list = np.arange(-10e3, 11e3, 1e3) * (2 * math.pi) / 60 Gen_trq_list = np.arange(-75, 76, 5) # motor efficiency map Gen_eta_quarter = np.array( [[ 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000, 0.570000000000000 ], [ 0.570000000000000, 0.701190476190476, 0.832380952380952, 0.845500000000000, 0.845500000000000, 0.845500000000000, 0.845500000000000, 0.841181818181818, 0.832545454545455, 0.825204545454546, 0.820886363636364, 0.816136363636364, 0.807500000000000, 0.798863636363636, 0.794113636363636, 0.789795454545455 ], [ 0.570000000000000, 0.710238095238095, 0.850476190476190, 0.872272727272727, 0.880909090909091, 0.883500000000000, 0.883500000000000, 0.879181818181818, 0.870545454545455, 0.864500000000000, 0.864500000000000, 0.863636363636364, 0.855000000000000, 0.846363636363636, 0.841613636363636, 0.837295454545455 ], [ 0.570000000000000, 0.710238095238095, 0.850476190476190, 0.872272727272727, 0.880909090909091, 0.883500000000000, 0.883500000000000, 0.883500000000000, 0.883500000000000, 0.883500000000000, 0.883500000000000, 0.883500000000000, 0.883500000000000, 0.883500000000000, 0.875727272727273, 0.867090909090909 ], [ 0.570000000000000, 0.710238095238095, 0.850476190476190, 0.876159090909091, 0.889113636363636, 0.896022727272727, 0.900340909090909, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.901636363636364, 0.893000000000000, 0.884363636363636, 0.883500000000000, 0.883500000000000 ], [ 0.570000000000000, 0.714761904761905, 0.859523809523810, 0.885659090909091, 0.898613636363636, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.894727272727273, 0.886090909090909 ], [ 0.570000000000000, 0.714761904761905, 0.859523809523810, 0.885659090909091, 0.898613636363636, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.901636363636364, 0.893000000000000, 0.884363636363636, 0.883500000000000, 0.883500000000000 ], [ 0.570000000000000, 0.714761904761905, 0.859523809523810, 0.885659090909091, 0.898613636363636, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.901636363636364, 0.893000000000000, 0.884363636363636, 0.883500000000000, 0.883500000000000 ], [ 0.570000000000000, 0.714761904761905, 0.859523809523810, 0.885659090909091, 0.898613636363636, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.902500000000000, 0.901636363636364, 0.893000000000000, 0.884363636363636, 0.883500000000000, 0.883500000000000 ], [ 0.570000000000000, 0.714761904761905, 0.859523809523810, 0.885659090909091, 0.898613636363636, 0.902500000000000, 0.902500000000000, 0.898181818181818, 0.889545454545454, 0.886090909090909, 0.894727272727273, 0.901636363636364, 0.893000000000000, 0.884363636363636, 0.883500000000000, 0.883500000000000 ], [ 0.570000000000000, 0.710238095238095, 0.850476190476190, 0.872272727272727, 0.880909090909091, 0.883500000000000, 0.883500000000000, 0.883500000000000, 0.883500000000000, 0.886090909090909, 0.894727272727273, 0.901636363636364, 0.893000000000000, 0.884363636363636, 0.883500000000000, 0.883500000000000 ]]) Gen_eta_alltrqs = np.concatenate( (Gen_eta_quarter[:, 1:], Gen_eta_quarter), axis=1) Gen_eta_map = np.concatenate( ([np.flipud(Gen_eta_alltrqs[1:, :]), Gen_eta_alltrqs])) # efficiency of the electric generator self.Gen_eta_map_func = interp2d(Gen_trq_list, Gen_spd_list, Gen_eta_map) # generator maxmium torque Gen_trq_max_half = np.array([ 76.7000000000000, 76.7000000000000, 70.6160000000000, 46.0160000000000, 34.7320000000000, 26.6400000000000, 21.2000000000000, 18.1160000000000, 16.2800000000000, 13.4000000000000, 0 ]) Gen_trq_max_half = Gen_trq_max_half[np.newaxis, :] Gen_trq_max_list = np.concatenate( (np.fliplr(Gen_trq_max_half[:, 1:]), Gen_trq_max_half), axis=1) # generator minimum torque Gen_trq_min_list = -Gen_trq_max_list self.Gen_trq_min_func = interp1d(Gen_spd_list, Gen_trq_min_list, kind='linear', fill_value='extrapolate') self.Gen_trq_max_func = interp1d(Gen_spd_list, Gen_trq_max_list, kind='linear', fill_value='extrapolate') # Battery # published capacity of one battery cell Batt_Q_cell = 6.5 # coulombs, battery package capacity self.Batt_Q = Batt_Q_cell * 3600 # resistance and OCV list Batt_rint_dis_list = [ 0.7, 0.619244814, 0.443380117, 0.396994948, 0.370210379, 0.359869599, 0.364414573, 0.357095093, 0.363394618, 0.386654377, 0.4 ] # ohm Batt_rint_chg_list = [ 0.7, 0.623009741, 0.477267027, 0.404193372, 0.37640518, 0.391748667, 0.365290105, 0.375071555, 0.382795632, 0.371566564, 0.36 ] # ohm Batt_vol_list = [ 202, 209.3825073, 213.471405, 216.2673035, 218.9015961, 220.4855042, 221.616806, 222.360199, 224.2510986, 227.8065948, 237.293396 ] # V # resistance and OCV SOC_list = np.arange(0, 1.01, 0.1) self.Batt_vol_func = interp1d(SOC_list, Batt_vol_list, kind='linear', fill_value='extrapolate') self.Batt_rint_dis_list_func = interp1d(SOC_list, Batt_rint_dis_list, kind='linear', fill_value='extrapolate') self.Batt_rint_chg_list_func = interp1d(SOC_list, Batt_rint_chg_list, kind='linear', fill_value='extrapolate') #Battery current limitations self.Batt_I_max_dis = 196 self.Batt_I_max_chg = 120
def initialise_2D_scikit_fem(self): y_sol = self.mesh.edges["y"] len_y = len(y_sol) z_sol = self.mesh.edges["z"] len_z = len(z_sol) entries = np.empty((len_y, len_z, len(self.t_sol))) # Evaluate the base_variable index-by-index for idx in range(len(self.t_sol)): t = self.t_sol[idx] u = self.u_sol[:, idx] inputs = {name: inp[:, idx] for name, inp in self.inputs.items()} if self.known_evals: eval_and_known_evals = self.base_variable.evaluate( t, u, inputs=inputs, known_evals=self.known_evals[t]) entries[:, :, idx] = np.reshape(eval_and_known_evals[0], [len_y, len_z], order="F") self.known_evals[t] = eval_and_known_evals[1] else: entries[:, :, idx] = np.reshape( self.base_variable.evaluate(t, u, inputs=inputs), [len_y, len_z], order="F", ) # assign attributes for reference self.entries = entries self.dimensions = 2 self.y_sol = y_sol self.z_sol = z_sol self.first_dimension = "y" self.second_dimension = "z" self.first_dim_pts = y_sol * self.get_spatial_scale( "y", "current collector") self.second_dim_pts = z_sol * self.get_spatial_scale( "z", "current collector") # set up interpolation if len(self.t_sol) == 1: # function of space only. Note the order of the points is the reverse # of what you'd expect interpolant = interp.interp2d( self.second_dim_pts, self.first_dim_pts, entries, kind="linear", fill_value=np.nan, bounds_error=False, ) def interp_fun(input): return make_interp2D_fun(input, interpolant) self._interpolation_function = interp_fun else: # function of space and time. self._interpolation_function = interp.RegularGridInterpolator( (self.first_dim_pts, self.second_dim_pts, self.t_pts), entries, method="linear", fill_value=np.nan, bounds_error=False, )
plt.plot((a.grid.x - rin) / au, a.dusttemp[:, imid, 0, 0], label='RADMC-3D') plt.plot(pinte_r - rin / au, pinte_mid_temp, label='MCFOST') plt.xscale('log') plt.yscale('log') plt.xlabel(r'$r-r_{\mathrm{in}}$ [au]') plt.ylabel(r'$T_d$ [K]') plt.axis([0.00001, 400., 10, 2000.]) plt.legend(loc='lower left') #plt.savefig('compare_tdust_midplane.png') plt.show() f = interpolate.interp1d(rc / au, np.linspace(0, nnr - 1, nnr)) ir02 = int(f([0.2])[0]) + 1 ir200 = int(f([200])[0]) f = interpolate.interp2d(thetac, rc / au, a.dusttemp[:, :, 0, 0]) rcyl02 = 0.2 zcyl02 = (math.pi / 2 - thetac) * rcyl02 rsph = np.sqrt(rcyl02**2 + zcyl02**2) tsph = math.pi / 2 - np.arctan(zcyl02 / rcyl02) tdust02 = np.zeros(nnt) for iz in range(nnt): tdust02[iz] = f(tsph[iz], rsph[iz]) rcyl200 = 200 zcyl200 = (math.pi / 2 - thetac) * rcyl200 rsph = np.sqrt(rcyl200**2 + zcyl200**2) tsph = math.pi / 2 - np.arctan(zcyl200 / rcyl200) tdust200 = np.zeros(nnt) for iz in range(nnt): tdust200[iz] = f(tsph[iz], rsph[iz])
def initialise_2D(self): """ Initialise a 2D object that depends on x and r, or x and z. """ first_dim_nodes = self.mesh.nodes first_dim_edges = self.mesh.edges second_dim_nodes = self.base_variable.secondary_mesh.nodes second_dim_edges = self.base_variable.secondary_mesh.edges if self.base_eval.size // len(second_dim_nodes) == len( first_dim_nodes): first_dim_pts = first_dim_nodes elif self.base_eval.size // len(second_dim_nodes) == len( first_dim_edges): first_dim_pts = first_dim_edges second_dim_pts = second_dim_nodes first_dim_size = len(first_dim_pts) second_dim_size = len(second_dim_pts) entries = np.empty((first_dim_size, second_dim_size, len(self.t_sol))) # Evaluate the base_variable index-by-index for idx in range(len(self.t_sol)): t = self.t_sol[idx] u = self.u_sol[:, idx] inputs = {name: inp[:, idx] for name, inp in self.inputs.items()} if self.known_evals: eval_and_known_evals = self.base_variable.evaluate( t, u, inputs=inputs, known_evals=self.known_evals[t]) entries[:, :, idx] = np.reshape( eval_and_known_evals[0], [first_dim_size, second_dim_size], order="F", ) self.known_evals[t] = eval_and_known_evals[1] else: entries[:, :, idx] = np.reshape( self.base_variable.evaluate(t, u, inputs=inputs), [first_dim_size, second_dim_size], order="F", ) # add points outside first dimension domain for extrapolation to # boundaries extrap_space_first_dim_left = np.array( [2 * first_dim_pts[0] - first_dim_pts[1]]) extrap_space_first_dim_right = np.array( [2 * first_dim_pts[-1] - first_dim_pts[-2]]) first_dim_pts = np.concatenate([ extrap_space_first_dim_left, first_dim_pts, extrap_space_first_dim_right ]) extrap_entries_left = np.expand_dims(2 * entries[0] - entries[1], axis=0) extrap_entries_right = np.expand_dims(2 * entries[-1] - entries[-2], axis=0) entries_for_interp = np.concatenate( [extrap_entries_left, entries, extrap_entries_right], axis=0) # add points outside second dimension domain for extrapolation to # boundaries extrap_space_second_dim_left = np.array( [2 * second_dim_pts[0] - second_dim_pts[1]]) extrap_space_second_dim_right = np.array( [2 * second_dim_pts[-1] - second_dim_pts[-2]]) second_dim_pts = np.concatenate([ extrap_space_second_dim_left, second_dim_pts, extrap_space_second_dim_right, ]) extrap_entries_second_dim_left = np.expand_dims( 2 * entries_for_interp[:, 0, :] - entries_for_interp[:, 1, :], axis=1) extrap_entries_second_dim_right = np.expand_dims( 2 * entries_for_interp[:, -1, :] - entries_for_interp[:, -2, :], axis=1) entries_for_interp = np.concatenate( [ extrap_entries_second_dim_left, entries_for_interp, extrap_entries_second_dim_right, ], axis=1, ) # Process r-x or x-z if self.domain[0] in [ "negative particle", "positive particle", ] and self.auxiliary_domains["secondary"][0] in [ "negative electrode", "positive electrode", ]: self.first_dimension = "r" self.second_dimension = "x" self.r_sol = first_dim_pts self.x_sol = second_dim_pts elif (self.domain[0] in [ "negative electrode", "separator", "positive electrode", ] and self.auxiliary_domains["secondary"] == ["current collector"]): self.first_dimension = "x" self.second_dimension = "z" self.x_sol = first_dim_pts self.z_sol = second_dim_pts else: raise pybamm.DomainError( "Cannot process 3D object with domain '{}' " "and auxiliary_domains '{}'".format(self.domain, self.auxiliary_domains)) # assign attributes for reference self.entries = entries self.dimensions = 2 first_length_scale = self.get_spatial_scale(self.first_dimension, self.domain[0]) first_dim_pts_for_interp = first_dim_pts * first_length_scale second_length_scale = self.get_spatial_scale( self.second_dimension, self.auxiliary_domains["secondary"][0]) second_dim_pts_for_interp = second_dim_pts * second_length_scale # Set pts to edges for nicer plotting self.first_dim_pts = first_dim_edges * first_length_scale self.second_dim_pts = second_dim_edges * second_length_scale # set up interpolation if len(self.t_sol) == 1: # function of space only. Note the order of the points is the reverse # of what you'd expect interpolant = interp.interp2d( second_dim_pts_for_interp, first_dim_pts_for_interp, entries_for_interp[:, :, 0], kind="linear", fill_value=np.nan, bounds_error=False, ) def interp_fun(input): return make_interp2D_fun(input, interpolant) self._interpolation_function = interp_fun else: # function of space and time. self._interpolation_function = interp.RegularGridInterpolator( (first_dim_pts_for_interp, second_dim_pts_for_interp, self.t_pts), entries_for_interp, method="linear", fill_value=np.nan, bounds_error=False, )
def initialise_1D(self, fixed_t=False): len_space = self.base_eval.shape[0] entries = np.empty((len_space, len(self.t_sol))) # Evaluate the base_variable index-by-index for idx in range(len(self.t_sol)): t = self.t_sol[idx] u = self.u_sol[:, idx] inputs = {name: inp[:, idx] for name, inp in self.inputs.items()} if self.known_evals: eval_and_known_evals = self.base_variable.evaluate( t, u, inputs=inputs, known_evals=self.known_evals[t]) entries[:, idx] = eval_and_known_evals[0][:, 0] self.known_evals[t] = eval_and_known_evals[1] else: entries[:, idx] = self.base_variable.evaluate(t, u, inputs=inputs)[:, 0] # Get node and edge values nodes = self.mesh.nodes edges = self.mesh.edges if entries.shape[0] == len(nodes): space = nodes elif entries.shape[0] == len(edges): space = edges # add points outside domain for extrapolation to boundaries extrap_space_left = np.array([2 * space[0] - space[1]]) extrap_space_right = np.array([2 * space[-1] - space[-2]]) space = np.concatenate([extrap_space_left, space, extrap_space_right]) extrap_entries_left = 2 * entries[0] - entries[1] extrap_entries_right = 2 * entries[-1] - entries[-2] entries_for_interp = np.vstack( [extrap_entries_left, entries, extrap_entries_right]) # assign attributes for reference (either x_sol or r_sol) self.entries = entries self.dimensions = 1 if self.domain[0] in ["negative particle", "positive particle"]: self.first_dimension = "r" self.r_sol = space elif self.domain[0] in [ "negative electrode", "separator", "positive electrode", ]: self.first_dimension = "x" self.x_sol = space elif self.domain == ["current collector"]: self.first_dimension = "z" self.z_sol = space else: self.first_dimension = "x" self.x_sol = space # assign attributes for reference length_scale = self.get_spatial_scale(self.first_dimension, self.domain[0]) pts_for_interp = space * length_scale self.internal_boundaries = [ bnd * length_scale for bnd in self.mesh.internal_boundaries ] # Set first_dim_pts to edges for nicer plotting self.first_dim_pts = edges * length_scale # set up interpolation if len(self.t_sol) == 1: # function of space only interpolant = interp.interp1d( pts_for_interp, entries_for_interp[:, 0], kind="linear", fill_value=np.nan, bounds_error=False, ) def interp_fun(t, z): if isinstance(z, np.ndarray): return interpolant(z)[:, np.newaxis] else: return interpolant(z) self._interpolation_function = interp_fun else: # function of space and time. Note that the order of 't' and 'space' # is the reverse of what you'd expect self._interpolation_function = interp.interp2d( self.t_pts, pts_for_interp, entries_for_interp, kind="linear", fill_value=np.nan, bounds_error=False, )
def stn_interpolate(model_file_dic, df_stns): """Interpolate model forecast to stations. @Variables: model_file_list -- A list of model data. df_stns -- A pandas.DataFrame of national stations.""" from scipy.interpolate import interp2d import numpy as np import pandas as pd from functools import reduce from collections import defaultdict # Get latlon from stations lats = df_stns['latitude'] lons = df_stns['longitude'] # Spelling mistake ids = df_stns['id'] stn_ids = df_stns['stationId'] interp_results = defaultdict(lambda: list()) df_results = dict() assert len(lats) == len(lons) # Loop over the file list, for each file, loop over a list of # **shortName, perturbationNumber** and do interpolation to each station. # short_name_list = ['tp', '2t', '2d'] for model, model_file_list in model_file_dic.items(): for model_file in model_file_list: grbmsg = pygrib.open(model_file)[1] # Unit conversion units_grbmsg = grbmsg['parameterUnits'] short_name = 'PRCP' lat, lon, values = read_from_single_grbmsg(grbmsg) if units_grbmsg == 'm': values = values * 1000. elif units_grbmsg != 'kg m-2': print('Other kinds of precipitation units detected: {}'.format( units_grbmsg)) # Get validity datetime validity_datetime = "{:08d}{:02d}".format(grbmsg['validityDate'], grbmsg['validityTime']) initial_datetime = "{:08d}{:02d}".format(grbmsg['dataDate'], grbmsg['dataTime']) f = interp2d(lon, lat, values) # bounds_error=True var_name = "".join([short_name, '.', model]) # Do interpolation temp_interp_result = np.asarray( [f(lo, la)[0] for lo, la in zip(lons, lats)]) temp_interp_result[temp_interp_result < 0.1] = 0.0 interp_results[validity_datetime].append( pd.DataFrame({ var_name: temp_interp_result, 'stn_id': stn_ids })) for key_date in interp_results.keys(): df_results[key_date] = reduce( lambda left, right: pd.merge(left, right, on='stn_id'), interp_results[key_date]) # Add observation data to df_results according to key_date df_obs = get_station_data(key_date) df_results[key_date] = df_results[key_date].merge( df_obs[['datetime', 'stationId', 'PRE_24h']], left_on='stn_id', right_on='stationId') df_results[key_date] = df_results[key_date].merge( df_stns[['stationId', 'latitude', 'longitude']], left_on='stn_id', right_on='stationId', how='left') df_results[key_date]['time'] = key_date df_results = pd.concat([value for value in df_results.values()]) df_results.merge(df_stns[['id', 'stationId']], left_on='stn_id', right_on='stationId') return df_results
class EVeh_model(): Mass = 2.2135e+3 Fterms = np.array([162.4046, 4.8429, 0.4936]) _Spd_rpm = np.array([ 0, 500, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000, 11900, 12400 ]) _Spd_radps = _Spd_rpm * np.pi / 30 _Tq_Nm = np.array([ -415.7, -405.0, -400, -350, -300, -250, -233, -225, -200, -175, -150, -125, -100, -75, -50, -25, -10, 0, 10, 25, 50, 75, 100, 125, 150, 175, 200, 225, 233, 250, 300, 350, 400, 405.0, 415.7 ]) _Pw_W = np.array([[ 14351.2843432000, 14091.1418970700, 14587.1574276255, 15837.8561117835, 16391.8315070421, 13341.4903214869, 12845.7226528034, 12930.9894360770, 13286.9938053932, 16960.8265302376, 20637.3428820956, 24316.0446000527, 27996.4335487945, 31309.8143708543, 33150.8639615047 ], [ 13874.3406600000, 13608.9069996700, 14096.8387444255, 15319.9055559835, 15876.4913018421, 12980.5593338869, 12512.7762740034, 12604.2043740770, 12958.9388459932, 16534.9430116376, 20113.6307828956, 23694.5039416527, 27277.0643097945, 30502.3994328543, 32294.5347462824 ], [ 13651.4697800000, 13383.5635896700, 13867.7178644255, 15077.8725859835, 15635.6781218421, 12811.8999938869, 12357.1938540034, 12451.5010740770, 12805.6421359932, 16335.9320216376, 19868.9055028956, 23404.0643816527, 26940.9104597945, 30125.1027328543, 31894.3809073935 ], [ 11422.7609900000, 11130.1295296700, 11576.5090744255, 12657.5429159835, 13227.5462518421, 11125.3065838869, 10801.3696840034, 10924.4681140770, 11272.6751059932, 14345.8221316376, 17421.6527628956, 20499.6687816527, 23579.3719997945, 26352.1356928543, 27892.8424340602 ], [ 9194.05219800000, 8876.69546266998, 9285.30028242546, 10237.2132459835, 10819.4143818421, 9438.71317788691, 9245.54550600336, 9397.43514507695, 9739.70807199319, 12355.7122416376, 14974.4000128956, 17595.2731716527, 20217.8335397945, 22579.1686628543, 23891.3039762824 ], [ 6965.34340700000, 6623.26139666999, 6994.09149142546, 7816.88357698345, 8411.28251284211, 7752.11977188691, 7689.72133000336, 7870.40217807695, 8206.74103899319, 10365.6023516376, 12527.1472628956, 14690.8775716527, 16856.2950797945, 18806.2016328543, 19889.7655185047 ], [ 6207.58241800000, 5857.09381366999, 6215.08050242546, 6993.97148898345, 7592.51767784210, 7178.67801388691, 7160.74111100336, 7351.21096907695, 7685.53224799319, 9688.96499063756, 11695.0813328956, 13703.3830616527, 15713.3719997945, 17523.3928428543, 18529.2424451713 ], [ 5850.98901100000, 5496.54436366999, 5848.48709542546, 6606.71874198345, 7207.21657884210, 6908.82306888691, 6911.80924200336, 7106.88569407695, 7440.25752299319, 9370.54740863756, 11303.5208928956, 13238.6797716527, 15175.5258497945, 16919.7181128543, 17888.9962818380 ], [ 4599.89011000000, 4471.59930866999, 4796.94863442546, 5477.92753298345, 6003.15064484210, 6065.52636488691, 6133.89715500336, 6343.36921107695, 6673.77400599319, 8375.49246363756, 10079.8945168956, 11786.4819716527, 13494.7566197945, 15033.2345928543, 15888.2270451713 ], [ 3637.58241800000, 3588.74216566999, 3884.20138142546, 4495.40006098345, 4963.37042484210, 5222.22966188691, 5355.98506700336, 5579.85272707695, 5907.29048999319, 7380.43751863756, 8856.26814289557, 10334.2841616527, 11813.9873897945, 13146.7510828543, 13887.4578240602 ], [ 2933.07692300000, 2834.89601166999, 3096.72885342546, 3636.05940098345, 4053.59020584210, 4378.93295888691, 4578.07297900336, 4816.33624407695, 5140.80697299319, 6385.38257363756, 7632.64176889557, 8882.08636265270, 10133.2181547945, 11260.2675628543, 11886.6885901713 ], [ 2208.35164800000, 2177.31359466999, 2404.75083142546, 2876.71874198345, 3245.56822784210, 3535.63625488691, 3800.16089100336, 4052.81976007695, 4374.32345699319, 5390.32762863756, 6409.01539589557, 7429.88856065270, 8452.44892479447, 9373.78404685427, 9885.91935972688 ], [ 1618.90109900000, 1606.43447366999, 1793.54204042546, 2194.52093998345, 2517.10668884210, 2782.11977188691, 3022.24880300336, 3289.30327707695, 3607.83993999319, 4395.27268363756, 5185.38902189557, 5977.69075765270, 6771.67969379447, 7487.30052985427, 7885.15012828243 ], [ 1117.36263700000, 1112.47842966999, 1257.60797442546, 1581.33412698345, 1852.05174384210, 2094.09779388691, 2321.58946200336, 2525.78679307695, 2841.35642399319, 3400.21773863756, 3961.76264789557, 4525.49295565270, 5090.91046279447, 5600.81701385427, 5884.38089839354 ], [ 668.901098900000, 681.379528269985, 788.816765925456, 1036.93852198345, 1254.24954584210, 1460.69119988691, 1671.80924200336, 1858.42415607695, 2074.87290699319, 2405.16279363756, 2738.13627489557, 3073.29515365270, 3410.14123179447, 3714.33349785427, 3883.61166850466 ], [ 296.923076900000, 312.588319469985, 379.805776925455, 544.740719983452, 703.809985642103, 865.856035386906, 1055.21583590336, 1227.65492507695, 1408.05972099319, 1627.36059563756, 1849.34506589557, 2073.51493365270, 2299.37200179447, 2503.67415685427, 2617.45782139354 ], [ 107.252747300000, 129.621286469985, 180.245337425455, 307.268192483452, 433.040754942103, 573.108782686906, 746.094956703356, 908.314265876951, 1052.67510519319, 1266.70125463756, 1483.41099989557, 1702.30614265270, 1922.88848479447, 2122.44338785427, 2233.58969017132 ], [ 0, 57.4234842899851, 97.0585242054554, 224.191269383452, 336.667128542103, 467.504387086906, 645.655396303356, 803.588991076951, 997.290489793187, 1160.87707903756, 1327.14726389557, 1495.60284565270, 1665.74562779447, 1819.90492585427, 1905.83144761577 ], [ 107.252747300000, 147.643264469985, 197.827754925455, 326.169291383452, 462.601194442103, 602.339551886906, 789.721330403356, 940.182397676951, 1117.51027009319, 1289.99795763756, 1465.16924189557, 1642.52592265270, 1821.56980379447, 1983.74009085427, 2074.11716206021 ], [ 296.923076900000, 336.764143669985, 406.728853925455, 571.883577083452, 736.996798842103, 904.317573886906, 1086.97407760336, 1240.62195807695, 1423.33444599319, 1609.66828763756, 1798.68572489557, 1989.88856065270, 2182.77859479447, 2357.41042085427, 2454.71056928243 ], [ 668.901098900000, 716.324583169985, 827.058524225456, 1067.92753298345, 1278.31547984210, 1465.74614488691, 1652.02902300336, 1800.18239807695, 1986.30147899319, 2297.25070563756, 2610.88352789557, 2926.70174665270, 3244.20716579447, 3530.99283785427, 3690.60067850466 ], [ 1117.36263700000, 1157.75315466999, 1306.28929342546, 1618.47698398345, 1858.09569984210, 2054.53735388691, 2233.23781400336, 2375.23734307695, 2654.32345699319, 3215.05290363756, 3778.46594489557, 4344.06438465270, 4911.35002379447, 5422.93789285427, 5707.43584294910 ], [ 1618.90109900000, 1667.42348466999, 1858.04753542546, 2233.64181898345, 2499.96383184210, 2691.35054088691, 2866.42462700336, 3041.94063907695, 3557.73004999319, 4526.59136463756, 5498.13627489557, 6471.86658265270, 7447.28408879447, 8326.19063985427, 8814.75452439354 ], [ 2208.35164800000, 2258.30260466999, 2484.86072242546, 2921.11434598345, 3209.96383184210, 3405.85603588691, 3583.67737400336, 3708.64393607695, 4461.13664399319, 5838.12982663756, 7217.80660489557, 8599.66877965270, 9983.21815479447, 11229.4433828543, 11922.0731990602 ], [ 2933.07692300000, 2929.84106666999, 3193.21237042546, 3679.02643398345, 3990.84295284210, 4208.93295888691, 4399.06199000336, 4375.34723307695, 5364.54323699319, 7149.66828763756, 8937.47693389557, 10727.4709816527, 12519.1522197945, 14132.6961328543, 15029.3918851713 ], [ 3637.58241800000, 3708.96194566999, 4005.30028242546, 4532.43302798345, 4880.51328284210, 5127.28460688691, 5214.44660500336, 5042.05052907695, 6267.94983099319, 8461.20674963756, 10657.1472628956, 12855.2731716527, 15055.0862897945, 17035.9488828543, 18136.7105685047 ], [ 4599.89011000000, 4623.35755066999, 4949.58599642546, 5512.98247798345, 5897.76602984210, 6188.27361788691, 6029.83122000336, 5708.75382607695, 7171.35642399319, 9772.74521063756, 12376.8175928956, 14983.0753716527, 17591.0203497945, 19939.2016328543, 21244.0292573935 ], [ 5850.98901100000, 5661.92897866999, 6007.82775542546, 6596.16929098345, 7025.01877684210, 7249.26262888691, 6845.21583600336, 6375.45712307695, 8074.76301699319, 11084.2836716376, 14096.4879228956, 17110.8775716527, 20126.9544197945, 22842.4543728543, 24351.3479251713 ], [ 6207.58241800000, 6017.75315466999, 6368.04753542546, 6957.15830198345, 7399.52427184210, 7588.77911188691, 7106.13891300336, 6588.80217807695, 8363.85312699319, 11503.9759816376, 14646.7824328956, 17791.7742716527, 20938.4533197945, 23771.4952528543, 25345.6899051713 ], [ 6965.34340700000, 6773.87952866999, 7133.51456842546, 7724.25995098345, 8195.34844684210, 8310.25163988691, 7660.60045100336, 7042.16042007695, 8978.16961099319, 12395.8221316376, 15816.1582528956, 19238.6797716527, 22662.8884897945, 25745.7071228543, 27458.6666085047 ], [ 9194.05219800000, 8997.78062666998, 9384.88819442546, 9980.44126898345, 10536.0077918421, 10432.2296638869, 9291.36968200336, 8375.56701307695, 10784.9827959932, 15018.8990616376, 19255.4989128956, 23494.2841616527, 27734.7566197945, 31552.2126228543, 33673.3039807269 ], [ 11422.7609900000, 11221.6817296700, 11636.2618244255, 12236.6225859835, 12876.6671318421, 12554.2076838869, 10922.1389140034, 9708.97360607695, 12591.7959859932, 17641.9759816376, 22694.8395728956, 27749.8885616527, 32806.6247497945, 37358.7181128543, 39887.9413373935 ], [ 13651.4697800000, 13445.5828296700, 13887.6354444255, 14492.8039059835, 15217.3264718421, 14676.1857038869, 12552.9081440034, 11042.3802040770, 14398.6091759932, 20265.0529016376, 26134.1802328956, 32005.4929516527, 37878.4928797945, 43165.2236028543, 46102.5786940602 ], [ 13874.3406600000, 13667.9729396700, 14112.7728144255, 14718.4220359835, 15451.3924018421, 14888.3835038869, 12715.9850640034, 11175.7208640770, 14579.2904859932, 20527.3605916376, 26478.1142928956, 32431.0533916527, 38385.6796897945, 43745.8741528543, 46724.0424329491 ], [ 14351.2843432000, 14143.8877750700, 14594.5667862255, 15201.2448341835, 15952.2934920421, 15342.4867958869, 13064.9696728034, 11461.0698764770, 14965.9484893932, 21088.6990482376, 27214.1331812956, 33341.7527332527, 39471.0594631945, 44988.4663298543, 48053.9748341713 ]]) PwLossAtVolt = interp2d(_Spd_radps, _Tq_Nm, _Pw_W) _Spd_rpm_mot = np.array([ 0, 510, 1020, 1530, 2040, 2550, 3060, 3570, 4080, 4467, 4591, 5101, 5611, 6121, 6631, 7141, 7651, 8161, 8671, 9182, 9692, 10202, 10712, 11222, 11732, 12140, 12400, 12500 ]) _Spd_radps_mot = _Spd_rpm_mot * np.pi / 30 _Tq_Nm_mot = np.array([ 413.126736111111, 414.711805555556, 414.783854166667, 415, 415.144097222222, 415.072048611111, 415, 414.783854166667, 409.668402777778, 400.518229166667, 396.555555555556, 370.401909722222, 340.429687500000, 312.402777777778, 287.113715277778, 264.418402777778, 243.668402777778, 225.151909722222, 208.220486111111, 193.810763888889, 180.914062500000, 170.034722222222, 160.164062500000, 151.518229166667, 143.520833333333, 137.540798611111, 133.866319444444, 0 ]) MotTqLimAtVolt = interp1d(_Spd_radps_mot, _Tq_Nm_mot) Inertia = 16.4161 M2WRatio = 9.4876 WheelRadius = 0.3522 Aux_load = 2000 Rin_norm = 0.0872279723055434 VOC_norm = 3.507459685926577e+02