def main(): obj=plt.imread('jerichoObject.bmp') ref=plt.imread('jerichoRef.bmp') holo=obj-ref Kreal=np.empty(holo.shape)+0j Kimag=np.empty(holo.shape)+0j temp=np.empty(holo.shape)+0j wavelength=405e-9 k=2*np.pi/(wavelength) z=250e-6 #z=13e-3-250e-6 distX=6e-6 distY=6e-6 n=float(holo.shape[0]) m=float(holo.shape[1]) a = np.arange(0,n) b = np.arange(0,m) '''create all r vectors''' R = np.empty((holo.shape[0], holo.shape[1], 3)) R[:,:,0] = np.repeat(np.arange(holo.shape[0]), holo.shape[1]).reshape(holo.shape) * distX R[:,:,1] = np.arange(holo.shape[1]) * distY R[:,:,2] = z '''create all ksi vectors''' KSI = np.empty((holo.shape[0], holo.shape[1], 3)) KSI[:,:,0] = np.repeat(np.arange(holo.shape[0]), holo.shape[1]).reshape(holo.shape) * distX KSI[:,:,1] = np.arange(holo.shape[1]) * distY KSI[:,:,2] = z # vectorized 2-norm; see http://stackoverflow.com/a/7741976/4323 KSInorm = np.sum(np.abs(KSI)**2,axis=-1)**(1./2) # loop over entire holo which is same shape as holo, rows first # this loop populates holo one pixel at a time (so can be parallelized) for x in xrange(holo.shape[0]): for y in xrange(holo.shape[1]): print(x, y) KSIdotR = np.dot(KSI, R[x,y]) temp = holo * np.exp(1j * k * KSIdotR / KSInorm) '''interpolate so that we can do the integral and take the integral''' temp2 = rbs(a, b, temp.real) Kreal[x,y] = temp2.integral(0, n, 0, m) temp3 = rbs(a, b, temp.imag) Kimag[x,y] = temp3.integral(0, n, 0, m) Kreal.dump('Kreal.dat') Kimag.dump('Kimag.dat')
def func(smallX,smallY): ''' Function used to calculate the integral ''' print(smallX,smallY) temp2=ne.evaluate('temp*exp((1j*k*(smallX*Xprime+smallY*Yprime))/L)') temp3=rbs(i,j,temp2.real) Kreal[smallX,smallY]=temp3.integral(0,kx,0,ky) temp4=rbs(i,j,temp2.imag) Kimag[smallX,smallY]=temp4.integral(0,kx,0,ky)
def __init__(self, theGrid, phiGrid, tauth, tauph): self.theGrid = theGrid self.phiGrid = phiGrid self.tauTheFuncs = [ rbs(theGrid, phiGrid, tauth[..., i]) for i in [0, 1, 2] ] self.tauPhiFuncs = [ rbs(theGrid, phiGrid, tauph[..., i]) for i in [0, 1, 2] ]
def get(self, rs, redshift, logdens): xic = np.array([ rbs(-self.logdens_list, -self.redshift_list, self.pred_table[:, :, i])(-logdens, -redshift) for i in range(66) ]) return np.exp(ius(self.logrscale, xic, ext=3)(np.log(rs)))
def line_sample2d(x,y,z,x1,y1): """sample z along a path [x,y] x,y in pixel coordinates""" from scipy.interpolate import RectBivariateSpline as rbs # Extract the values along the line, using cubic interpolation f = rbs(x,y,z.T) return f.ev(x1,y1)
def getNoInterpol(self, redshift, logdens): xic = np.array([ rbs(-self.logdens_list, -self.redshift_list, self.pred_table[:, :, i])(-logdens, -redshift, grid=False) for i in range(66) ]) return np.exp(xic)
def main(): '''Using numba to try and make this as fast as possible, still very slow. ''' obj=plt.imread('jerichoObject.bmp') ref=plt.imread('jerichoRef.bmp') img=obj-ref K=np.empty(img.shape)+0j temp=np.empty(img.shape)+0j wavelength=405e-9 k=2*np.pi/(wavelength) z=250e-6 #z=13e-3-250e-6 distX=6e-6 distY=6e-6 n=float(img.shape[0]) m=float(img.shape[1]) a = np.arange(0,n) b = np.arange(0,m) first=time.time() for i in xrange(K.shape[0]): for j in xrange(K.shape[1]): print(i,j) '''create an r vector ''' r=(i*distX,j*distY,z) for x in xrange(img.shape[0]): for y in xrange(img.shape[1]): '''create an ksi vector, then calculate it's norm, and the dot product of r and ksi''' ksi=(x*distX,y*distY,z) ksiNorm=np.linalg.norm(ksi) ksiDotR=float(np.dot(ksi,r)) '''calculate the integrand''' temp[x,y]=img[x,y]*np.exp(1j*k*ksiDotR/ksiNorm) '''interpolate so that we can do the integral and take the integral''' temp2=rbs(a,b,temp.real) K[i,j]=temp2.integral(0,n,0,m) timeTook=time.time()-first print(timeTook) K.dump('K.dat') kInt=K.real*K.real+K.imag*K.imag plt.imshow(kInt,cmap=plt.cm.Greys_r)
def __init__(self, phase, pix=True): self.data0 = phase sz = phase.shape[0] x = np.arange(sz) - (sz - 1) / 2 if not pix: x = x / (sz - 1) * 2 self.fun = rbs(x, x, phase)
def set_cosmology(self, cosmo): coeff_rec = np.dot(self.gps.predict(np.atleast_2d( cosmo.get_cosmology())), self.eigdata).reshape(21, 41) #pred_table = [] # for i in range(21): # self.spl[1][:-4] = coeff_rec[i,] # pred_table.append(interpolate.splev(self.logxscale, self.s1pl)) self.xinl = rbs(-self.redshift_list, self.logxscale, coeff_rec)
def interpolate(array, Nx, Ny, Lx, Ly, newNx, newNy, xmin=0, ymin=0): from scipy.interpolate import RectBivariateSpline as rbs x = np.linspace(xmin, Lx, Nx) y = np.linspace(ymin, Ly, Ny) newx = np.linspace(xmin, Lx, newNx) newy = np.linspace(ymin, Ly, newNy) interpolatedobject = rbs(x, y, array) # evaluate interpolatedobject at newx, newy points return interpolatedobject.__call__(newx, newy)
def set_cosmology(self, cosmo): self.cosmo_now = cosmo cpara = cosmo.get_cosmology() self.coeff_rec = np.dot(self.gps.predict(np.atleast_2d(cpara)), self.eigdata).reshape(21, 13, 3) self.coeff_rec_dm = np.dot(self.gps_dm.predict(np.atleast_2d(cpara)), self.eigdata_dm).reshape(21, 2) self.sd0 = self.sd.get(cosmo) # self.D0s = np.array([cosmo.Dgrowth_from_z(z) for z in self.redshift_list]) self.coeff1_spline = rbs(-self.redshift_list, -self.logdens_list, self.coeff_rec[:, :, 0]) self.coeff2_spline = rbs(-self.redshift_list, -self.logdens_list, self.coeff_rec[:, :, 1]) self.coeff3_spline = rbs(-self.redshift_list, -self.logdens_list, self.coeff_rec[:, :, 2]) self.coeff2_spline_dm = ius(-self.redshift_list, self.coeff_rec_dm[:, 0]) self.coeff3_spline_dm = ius(-self.redshift_list, self.coeff_rec_dm[:, 1])
def getNoInterpol(self, redshift, logdens1, logdens2): sindex = self.redshift_to_index(redshift) # dindex1 = self.logdens_to_index(logdens1) # dindex2 = self.logdens_to_index(logdens2) # ins = [dindex1*np.ones(21),dindex2*np.ones(21),sindex*np.ones(21),range(21)] if sindex <= 0: s0 = 0 xia0 = np.array([ rbs(-self.logdens_list, -self.logdens_list, self.xih_mat[:, :, s0, i])(-logdens1, -logdens2, grid=False) for i in range(21) ]) return xia0 elif sindex >= 20: s0 = 20 xia0 = np.array([ rbs(-self.logdens_list, -self.logdens_list, self.xih_mat[:, :, s0, i])(-logdens1, -logdens2, grid=False) for i in range(21) ]) return xia0 else: s0 = int(sindex) s1 = s0 + 1 u = sindex - s0 xia0 = np.array([ rbs(-self.logdens_list, -self.logdens_list, self.xih_mat[:, :, s0, i])(-logdens1, -logdens2, grid=False) for i in range(21) ]) xia1 = np.array([ rbs(-self.logdens_list, -self.logdens_list, self.xih_mat[:, :, s1, i])(-logdens1, -logdens2, grid=False) for i in range(21) ]) xia = (1 - u) * xia0 + u * xia1 return xia
def get_xiauto_mass_avg(emu, rs, M1min, M1max, M2min, M2max, z): ''' Averages the halo-halo correlation function over mass ranges to return the weighted-by-mass-function mean version ''' from scipy.interpolate import InterpolatedUnivariateSpline as ius from scipy.interpolate import RectBivariateSpline as rbs from scipy.integrate import dblquad # Parameters epsabs = 1e-3 # Integration accuracy nM = 6 # Number of halo-mass bins in each of M1 and M2 directions # Calculations nr = len(rs) # Number densities of haloes in each sample n1 = ndenshalo(emu, M1min, M1max, z) n2 = ndenshalo(emu, M2min, M2max, z) # Arrays for halo masses M1s = mead.logspace(M1min, M1max, nM) M2s = mead.logspace(M2min, M2max, nM) # Get mass function interpolation Ms = emu.massfunc.Mlist dndM = emu.massfunc.get_dndM(z) log_dndM_interp = ius(np.log(Ms), np.log(dndM)) # Loop over radii xiauto_avg = np.zeros((nr)) for ir, r in enumerate(rs): # Get correlation function interpolation # Note that this is not necessarily symmetric because M1, M2 run over different ranges xiauto_mass = np.zeros((nM, nM)) for iM1, M1 in enumerate(M1s): for iM2, M2 in enumerate(M2s): xiauto_mass[iM1, iM2] = emu.get_xiauto_mass(r, M1, M2, z) xiauto_interp = rbs(np.log(M1s), np.log(M2s), xiauto_mass) # Integrate interpolated functions xiauto_avg[ir], _ = dblquad( lambda M1, M2: xiauto_interp(np.log(M1), np.log(M2)) * np.exp( log_dndM_interp(np.log(M1)) + log_dndM_interp(np.log(M2))), M1min, M1max, lambda M1: M2min, lambda M1: M2max, epsabs=epsabs) return xiauto_avg / (n1 * n2)
def upsample(self, sample): if sample > 1: ''' EQ(self,n=sample*self.n) self.space() ''' from scipy.interpolate import RectBivariateSpline as rbs sample = np.int(np.float(sample)) interp_psi = rbs(self.r, self.z, self.psi) self.nr, self.nz = sample * self.nr, sample * self.nz self.r = np.linspace(self.r[0], self.r[-1], self.nr) self.z = np.linspace(self.z[0], self.z[-1], self.nz) self.psi = interp_psi(self.r, self.z, dx=0, dy=0) self.space()
def get(self, rs, redshift, logdens1, logdens2): sindex = self.redshift_to_index(redshift) # dindex1 = self.logdens_to_index(logdens1) # dindex2 = self.logdens_to_index(logdens2) # ins = [dindex1*np.ones(21),dindex2*np.ones(21),sindex*np.ones(21),range(21)] if sindex <= 0: s0 = 0 xia0 = np.array([ rbs(-self.logdens_list, -self.logdens_list, self.xih_mat[:, :, s0, i])(-logdens1, -logdens2) for i in range(21) ]) return ius(self.logrscale, xia0, ext=3)(np.log(rs)) elif sindex >= 20: s0 = 20 xia0 = np.array([ rbs(-self.logdens_list, -self.logdens_list, self.xih_mat[:, :, s0, i])(-logdens1, -logdens2) for i in range(21) ]) return ius(self.logrscale, xia0, ext=3)(np.log(rs)) else: s0 = int(sindex) s1 = s0 + 1 u = sindex - s0 xia0 = np.array([ rbs(-self.logdens_list, -self.logdens_list, self.xih_mat[:, :, s0, i])(-logdens1, -logdens2) for i in range(21) ]) xia1 = np.array([ rbs(-self.logdens_list, -self.logdens_list, self.xih_mat[:, :, s1, i])(-logdens1, -logdens2) for i in range(21) ]) xia = (1 - u) * xia0 + u * xia1 return ius(self.logrscale, xia, ext=3)(np.log(rs))
def rectGridInt(data, grid1Col, grid2Col, newGrid1, newGrid2): g1 = np.unique(data[:,grid1Col]) g2 = np.unique(data[:,grid2Col]) c1 = g1.shape[0] c2 = g2.shape[0] ng1 = np.linspace(g1.min(),g1.max(),newGrid1) ng2 = np.linspace(g2.min(),g2.max(),newGrid2) ng1m, ng2m = np.meshgrid(ng1, ng2, indexing='ij') result = [] for i in range(data.shape[1]): if i==grid1Col: res = ng1m.reshape(-1) elif i==grid2Col: res = ng2m.reshape(-1) else: res = rbs(g1,g2,data[:,i].reshape(c1,c2))(ng1, ng2).reshape(-1) result.append(res) return np.column_stack(result)
def __init__(self, Om0=0.315, H0=67.7, zmin=0.5, zmax=7.0, ninterp=100): """ Initializer Parameters ---------- Om0: float Matter density parameter H0: float Hubble constant, in km / s / Mpc zmin: float Minimum redshift supported. zmax: float Maximum redshift supported. ninterp: int Number of interpolation points for luminosity distance. """ from astropy.cosmology import FlatLambdaCDM from astropy.units import Quantity import astropy.io.fits as fits from pkg_resources import resource_filename from scipy.interpolate import RectBivariateSpline as rbs from scipy.interpolate import interp1d self._zmin = float(zmin) self._zmax = float(zmax) self._Om0 = float(Om0) self._H0 = float(H0) self._ninterp = int(ninterp) if self._zmin == self._zmax: raise ValueError("No range between zmin and zmax") if self._zmin > self._zmax: self._zmin, self._zmax = self._zmax, self._zmin if self._zmin < 0.0: raise ValueError("zmin must be >= 0: {:f}".format(self._zmin)) if self._Om0 <= 0.0: raise ValueError("Om0 must be positive: {:f}".format(self._Om0)) if self._H0 <= 0.0: raise ValueError("H0 must be positive: {:f}".format(self._H0)) if self._ninterp <= 0: raise ValueError("Ninterp must be > 0: {:d}".format(self._ninterp)) # Set up luminosity distance interpolant. We actually # interpolate log((1+z) / (4 pi d_L^2)) in log(1+z) cos = FlatLambdaCDM(H0=self._H0, Om0=self._Om0, Tcmb0=0.0, Neff=0.0) zrange = np.linspace(self._zmin, self._zmax, self._ninterp) mpc_in_cm = 3.0857e24 prefac = 1.0 / (4 * math.pi * mpc_in_cm**2) lumdist = cos.luminosity_distance(zrange) if isinstance(lumdist, Quantity): lumdist = lumdist.value dlval = prefac * (1.0 + zrange) / lumdist**2 self._dlfac = interp1d(np.log(1 + zrange), np.log(dlval)) # Read in the data products, and set up interpolations on them sb_tpl = resource_filename(__name__, 'resources/SED_sb.fits') hdu = fits.open(sb_tpl) dat = hdu['SEDS'].data hdu.close() self._sblam = dat['LAMBDA'][0] self._sbumean = dat['UMEAN'][0] arg = np.argsort(self._sbumean) self._sbumean = self._sbumean[arg] self._sbrange = np.array([self._sbumean[0], self._sbumean[-1]]) self._sbseds = dat['SEDS'][0, :, :].transpose()[arg, :] self._sbinterp = rbs(self._sbumean, self._sblam, self._sbseds, kx=1, ky=1) ms_tpl = resource_filename(__name__, 'resources/SED_ms.fits') hdu = fits.open(ms_tpl) dat = hdu['SEDS'].data hdu.close() self._mslam = dat['LAMBDA'][0] self._msumean = dat['UMEAN'][0] arg = np.argsort(self._msumean) self._msumean = self._msumean[arg] self._msrange = np.array([self._msumean[0], self._msumean[-1]]) self._msseds = dat['SEDS'][0, :, :].transpose()[arg, :] self._msinterp = [] self._msinterp = rbs(self._msumean, self._mslam, self._msseds, kx=1, ky=1)
def get_sp_he(self, lgp, lgt): return rbs(self.logpvals, self.logtvals, self.data['he']['sp'], **self.spline_kwargs)(lgp, lgt, grid=False)
def metastable_config(b, a, xsi, Ke, Ks, taup, disl_type, wpfunc=None, wmin=5, wmax=1000, tau_frac_min=0.05, tau_frac_max=0.3, ntau=20, in_GPa=True, nh=100, nw=200, fit_kocks=True): '''Finds the kink-pair geometry (h, w) at which the kink-pair energy is at a critical point, ie dH/dw = dH/dh = 0 <xsi>: dislocation width (float) <wmin>: minimum kink-pair separation, in angstroms <wmax>: maximum kink-pair separation <a>: dislocation spacing, in angstroms. If <None>, use the Burgers vector <tau_frac_min>: smallest stress at which to calculate metastable shape, as a fraction of <taup> <tau_frac_max>: largest stress, as fraction of <taup> <ntau>; <nh>; <nw>: number of stress, height, and width increments to use ''' if wpfunc is None: # construct a simple sine potential using the Peierls stress and # dislocation geometry wpmax = taup * b**2 / np.pi if in_GPa: wpmax /= 160.2 wpfunc = simple_wp(wpmax, a) # calculate the core size parameter if disl_type == 'edge': rho = self_consistent_rho(Ke, Ks, b, a, taup) elif disl_type == 'screw': rho = self_consistent_rho(Ks, Ke, b, a, taup) # create kink-pair energy function kp_func = DH_kink_pair_mappable(disl_type, Ke, Ks, b, a, rho, wpfunc, taup) # calculate critical shape in specified range of stresses critical_values = [] stresses = np.linspace(tau_frac_min * taup, tau_frac_max * taup, ntau) w = np.linspace(wmin, wmax, nw) h = np.linspace(0.1, a, nh) for s in stresses: # calculate kink-pair energies at stress <s> for all kink-pair widths # and heights Ekp = np.zeros((len(w), len(h))) for i, wi in enumerate(w): for j, hj in enumerate(h): Ekp[i, j] = kp_func(hj, wi, s) # calculate width and height derivates of kink-pair energy dEdw, dEdh = np.gradient(Ekp) # construct spline-fits for derivative functions and find saddle point fw = rbs(w, h, dEdw) fh = rbs(w, h, dEdh) fwi = lambda x: abs(fw(*x)[0, 0]) fhi = lambda x: abs(fh(*x)[0, 0]) fci = lambda x: fhi(x) + fwi(x) optvals = opt.brute(fci, [[2 * wmin, wmax], [0.2 * a, a]]) critical_values.append([s] + list(optvals) + [kp_func(optvals[1], optvals[0], s)]) critical_values = np.array(critical_values) # fit the shape of the activation enthalpy, if specified by user if fit_kocks: par, err = kocks_fit(critical_values[:, 0], critical_values[:, -1], taup) return critical_values, par, err else: return critical_values, None, None
def __init__(self, x, y, k=2): self.kx0, self.kx1 = k, k self.rbs = rbs(x[0], x[1], y, kx=k, ky=k)
def get_st_h(self, lgp, lgt): return rbs(self.logpvals, self.logtvals, self.data['h']['st'], **self.spline_kwargs)(lgp, lgt, grid=False)
#temp[xx,yy]=img[xx,yy]*(L/Rprime)**4*np.exp((1j*k*z*Rprime)/L) kx,ky=K.shape i=np.arange(0,kx) j=np.arange(0,ky) smallX,smallY=np.mgrid[0:kx,0:ky] #temp2=temp[xx,yy]*np.exp((1j*k*(smallX*Xprime+smallY*Yprime))/L) temp2=ne.evaluate('temp*exp((1j*k*(smallX*Xprime+smallY*Yprime))/L)') temp3=rbs(i,j,temp2.real) Kreal[smallX,smallY]=temp3.integral(0,kx,0,ky) temp4=rbs(i,j,temp2.imag) Kimag[smallX,smallY]+=temp4.integral(0,kx,0,ky) Kreal=Kreal.real Kimag=Kimag.real*1j K=Kreal+Kimag Kint=ne.evaluate('K.real*K.real+K.imag*K.imag') print(K) print(Kint) K.dump('K.dat') print(time.time()-first)
work_dir = os.getcwd() dirs = pd.read_excel(work_dir + "\\ModelData.xlsx", sheetname='Dir') dirs = dirs.set_index('Variable').T grid_dir = grid_3D_path = dirs['grid_3D_path'].values[0] data_dir = data_dir = dirs['data_dir'].values[0] elevation_data = data_dir + '\\Mt. Apo Elevations\\Elevations.xyz' data = pd.read_csv(elevation_data, names=['x', 'y', 'z'], header=None, sep=' ') x = data['x'].unique() y = data['y'].unique() z = data['z'].values.reshape(len(x), len(y), order='F') rbsf = rbs(x, y, z) dat = fdata() dat.grid.read(grid_dir) node_array = [(n.index, n.position[0], n.position[1], n.position[2]) for n in dat.grid.nodelist] node_df = pd.DataFrame(node_array, columns=['ni', 'x', 'y', 'z']) #find inactive blocks node_df['active'] = node_df.apply(lambda i: i['z'] < rbsf.ev(i['x'], i['y']), axis=1) x_columns = node_df['x'].unique() node_df['is_top'] = False
def affine_lk_tracker(img, tmp, rect, warp_prev): """ Method to track a template frame in a new image frame using lucas kanade tracking algorithm :param img: current image frame to track template :param tmp: template image frame :param rect: bonding box coordinates marking the template region in template image frame :param warp_prev: warping parameters from warping of previous image frame :return: warping parameters of current image frame """ # Get start and end point of the bounding rectangle in the template image start_point = rect[0], rect[1] opp_corner_point = rect[0] + rect[2], rect[1] + rect[3] # Define initial error and convergence threshold error = 1 convergence_threshold = 0.001 # Get x and y values x = np.arange(0, tmp.shape[0], 1) y = np.arange(0, tmp.shape[1], 1) # Interpolate points from top-left to bottom-right corner of the bounding box a = np.linspace(start_point[0], opp_corner_point[0], 87) b = np.linspace(start_point[1], opp_corner_point[1], 36) # Get a mesh grid from these interpolated points mesh_a, mesh_b = np.meshgrid(a, b) # Get bivariate spline of template image and evaluate intensities over interpolated points spline_tmp = rbs(x, y, tmp) intensities_tmp = spline_tmp.ev(mesh_b, mesh_a) # Adjust brightness scale # Uncomment to scale brightness in the roi region # img[rect[1]:rect[1] + rect[3], rect[0]:rect[0] + rect[2]] = adjust_brightness(img, tmp, rect) # Get bivariate spline and gradient of current image frame spline_img = rbs(x, y, img) grad_y, grad_x = np.gradient(img) # Get bivariate spine of gradient spline_grad_x = rbs(x, y, grad_x) spline_grad_y = rbs(x, y, grad_y) # Define a 4x4 jacobian jacobian = np.array([[1, 0], [0, 1]]) count = 0 # Iterate until convergence while np.linalg.norm(error) > convergence_threshold: # Interpolate warping points from top-left to bottom-right corner warp_a = np.linspace(start_point[0] + warp_prev[0], opp_corner_point[0] + warp_prev[0], 87) warp_b = np.linspace(start_point[1] + warp_prev[1], opp_corner_point[1] + warp_prev[1], 36) # Get mesh from these interpolated points mesh_warp_a, mesh_warp_b = np.meshgrid(warp_a, warp_b) # Evaluate intensities over interpolated points in x,y direction for gradients intensities_grad_x = spline_grad_x.ev(mesh_warp_b, mesh_warp_a) intensities_grad_y = spline_grad_y.ev(mesh_warp_b, mesh_warp_a) # Stack the intensities from both the gradients intensities_grad = np.vstack( (intensities_grad_x.ravel(), intensities_grad_y.ravel())).T # Evaluate intensities over the interpolated points for current image frame intensities_img = spline_img.ev(mesh_warp_b, mesh_warp_a) # Calculate the hessian matrix hessian = intensities_grad @ jacobian hess = hessian.T @ hessian # Calculate the change in intensities from the template image to the current image frame change = (intensities_tmp - intensities_img).reshape(-1, 1) # Uncomment to add huber loss implementation change = get_huber_loss(change) # Evaluate errors try: error = np.linalg.inv(hess) @ hessian.T @ change warp_prev[0] += error[0, 0] warp_prev[1] += error[1, 0] except np.linalg.LinAlgError: break # Increment iteration count count += 1 # Terminate convergence after 200 iterations if count > 200: break return warp_prev
r=(i*distX,j*distY,z) for (x,y),value in np.ndenumerate(img): ksi=(x*distX,y*distY,z) ksiNorm=np.linalg.norm(ksi) ksiDotR=np.dot(ksi,r) temp[x,y]=img[x,y]*np.exp(1j*k*ksiDotR/ksiNorm) temp.dump('temp.dat') #tempRavel=temp.ravel() #surf=interpol(pts,tempRavel) #func=lambda y,x: surf([[x,y]]) #K[i,j]=dblquad(func,0.0,m,lambda x:0.0, lambda x:n)[0] temp2=rbs(a,b,temp.real) K[i,j]=temp2.integral(0,n,0,m) timeTook=time.time()-first print(timeTook) K.dump('K.dat') kInt=K.real*K.real+K.imag*K.imag plt.imshow(kInt,cmap=plt.cm.Greys_r) plt.imsave(kInt,cmap=plt.cm.Greys_r) #a=np.arange(0,n) #b=np.arange(0,m)
def main(slice,comm,rank,size): if rank==0: first=time.time() obj=plt.imread('jerichoObject.bmp') ref=plt.imread('jerichoRef.bmp') img=obj-ref temp=np.empty(img.shape)+0j K=np.empty(img.shape)+0j Kreal=np.empty(img.shape)+0j Kimag=np.empty(img.shape)+0j wavelength=405e-9 k=2*np.pi/(wavelength) ''' L is the distance from the source to the screen ''' L=13e-3 n,m=img.shape a,b=np.mgrid[0:n,0:m] r=ne.evaluate('sqrt(L*L+a*a+b*b)') Xprime=ne.evaluate('(a*L)/r') Yprime=ne.evaluate('(b*L)/r') Rprime=ne.evaluate('(L*L)/r') xx=ne.evaluate('(Xprime*L)/Rprime') yy=ne.evaluate('(Yprime*L)/Rprime') xx=xx.astype(int) yy=yy.astype(int) ''' z is the slice we want to look at ''' #z=250e-6 #z=13e-3-250e-6 #z=13e-3 z=slice print('Distance: {0}'.format(z)) temp[xx,yy]=ne.evaluate('img*(L/Rprime)**4*exp((1j*k*z*Rprime)/L)') kx,ky=K.shape ii=np.arange(kx) jj=np.arange(ky) print('Total number of Processors in use: {0}'.format(comm.size)) else: kx=None ky=None L=None Xprime=None Yprime=None temp=None Kreal=None Kimag=None ii=None jj=None k=None comm.Barrier() #print('rank:{0} size:{1} \n'.format(comm.rank,comm.size)) comm.Barrier() if rank==0: print('Broadcasting') kx=comm.bcast(kx,root=0) ky=comm.bcast(ky,root=0) L=comm.bcast(L,root=0) Xprime=comm.bcast(Xprime,root=0) Yprime=comm.bcast(Yprime,root=0) temp=comm.bcast(temp,root=0) Kreal=comm.bcast(Kreal,root=0) Kimag=comm.bcast(Kimag,root=0) ii=comm.bcast(ii,root=0) jj=comm.bcast(jj,root=0) k=comm.bcast(k,root=0) if rank==0: print('Done broadcasting') comm.Barrier() rows = [comm.rank + comm.size * aa for aa in range(int(kx/comm.size)+1) if comm.rank + comm.size*aa < kx] rows2 = [comm.rank + comm.size * bb for bb in range(int(ky/comm.size)+1) if comm.rank + comm.size*bb < ky] comm.Barrier() count=0 countTot=[] for smallX in rows: for smallY in rows2: #print(smallX,smallY) temp2=ne.evaluate('temp*exp((1j*k*(smallX*Xprime+smallY*Yprime))/L)') temp3=rbs(ii,jj,temp2.real) Kreal[smallX,smallY]=temp3.integral(0,kx,0,ky) temp4=rbs(ii,jj,temp2.imag) Kimag[smallX,smallY]=temp4.integral(0,kx,0,ky) count+=1 countTot=comm.gather(count) try: print('Done with: {0} elements'.format(sum(countTot))) except: pass comm.Barrier() if rank==0: Kreal.dump('Kreal{}.dat'.format(slice)) Kimag.dump('Kimag{}.dat'.format(slice)) print(time.time()-first)
def get_st_h(self, lgp, lgt): return rbs(self.logpvals, self.logtvals, self.logs, **self.spline_kwargs)(lgp, lgt, dy=1, grid=False)
def get_logrho_h(self, lgp, lgt): return rbs(self.logpvals, self.logtvals, self.logrho, **self.spline_kwargs)(lgp, lgt, grid=False)
def RayTracingPropagatorParax2V(x, y, z, Dx, Dy, Dz, zinit, zend, RayMatrix, n): """ This function evaluates the ray tracing of the photons of class 'photon' contained in RayMatrix propagating in a medium whose refractive index is in matrix n. The rays propagates in the paraxial approximation along the z axis NB z is the light propagation axis x, y, z the coordinates of the the matrix n along which the light is propagating zinit is the integration start zend is the integration end RayMatrix is the matrix of ray elements of class 'photon' described in Classes.py n is the refractive index matrix THIS VERSION USE THE SPLINE INTERPOLATION TO EVALUATE THE DERIVATIVES """ import numpy as np from scipy.interpolate import RectBivariateSpline as rbs init = np.argmin(np.abs(z - zinit)) stop = np.argmin(np.abs(z - zend)) for i in range(len(RayMatrix)): for j in range(len(RayMatrix[0])): print('Ray Tracing') print(((len(RayMatrix) - i) / len(RayMatrix)) * 100, '%') print('\n') for zcount in range(init, stop): ycount = np.amin(RayMatrix[i][j].y[zcount] - y) ni = rbs(x, y, n[:, :, zcount]) niz = rbs(x, z, n[:, ycount, :]) x0 = [RayMatrix[i][j].x[zcount], RayMatrix[i][j].dx[zcount]] #initial conditions x and x' y0 = [RayMatrix[i][j].y[zcount], RayMatrix[i][j].dy[zcount]] #initial conditions y and y' dndx_local = ni(x0[0], y0[0], dx=1) dndy_local = ni(x0[0], y0[0], dy=1) dndz_local = niz(x0[0], z[zcount], dy=1) n_local = ni(x0[0], y0[0]) xsol = odeint(Fx, x0, z[range(zcount, zcount + 2)], args=(dndz_local / n_local, -dndx_local / n_local), mxstep=5000000) #,mxstep=5000000 ysol = odeint(Fy, y0, z[range(zcount, zcount + 2)], args=(dndz_local / n_local, -dndy_local / n_local), mxstep=5000000) # if dndx_local!=0: # print(dndx_local, dndy_local, dndz_local, n_local, xsol[1,:], ysol[1,:], z[zcount]) RayMatrix[i][j].x[zcount + 1] = xsol[1, 0] RayMatrix[i][j].y[zcount + 1] = ysol[1, 0] RayMatrix[i][j].z[zcount + 1] = z[zcount + 1] RayMatrix[i][j].dx[zcount + 1] = xsol[1, 1] RayMatrix[i][j].dy[zcount + 1] = ysol[1, 1] return RayMatrix