def JONSWAP(self,x,t): """Sets a wave field according to JONSWAP ocean wave spectrum.""" from spectrum import jonswap from potential import velocityPotential modes_x = np.fft.fftfreq(self.Nx) # Fourier mode alignments modes_y = np.fft.fftfreq(self.Ny) kx = self.kc_x_modes * modes_x ky = self.kc_y_modes * modes_y # Generating mesh grid for 2D spectrum [kxx, kyy] = np.meshgrid(kx,ky) # Call jonswap() in spectrum.py module *** Send 1D vectors kx and ky (not kxx or kyy)! spectrum = jonswap(self.Nx, self.Ny, JS.Hs, JS.gamma, JS.fp, JS.nspread, JS.thetam, JS.gv, kx, ky) # (DISREGARD FOR NOW) - Imposing iniitial circular zero-pad filter if JS.filter == 1: spectrum[ 2*floor(self.kp/self.kc_x)+1 : (self.Nx-1)-2*floor(self.kp/self.kc_x), \ 2*floor(selfkp/kc_x)+1 : (self.Ny-1)-2*floor(self.kp/self.kc_x) ] = 0.0 + 0.0j else: pass # Compute the surface elvation via iFFT2D of the spectrum --> take REAL part # just in case we have some left over (nonzero) imaginary part of 'spectrum' self.surface = self.h + np.real(np.fft.ifft2(spectrum)) # Compute the velocity potential from linear theory and horizontal velocity [self.velPotential, self.u, self.v, self.w] = velocityPotential(spectrum, JS.gv, kx, ky)
def JONSWAP(self, x, t): """Sets a wave field according to JONSWAP ocean wave spectrum.""" from spectrum import jonswap from potential import velocityPotential modes_x = np.fft.fftfreq(self.Nx) # Fourier mode alignments modes_y = np.fft.fftfreq(self.Ny) kx = self.kc_x_modes * modes_x ky = self.kc_y_modes * modes_y # Generating mesh grid for 2D spectrum [kxx, kyy] = np.meshgrid(kx, ky) # Call jonswap() in spectrum.py module *** Send 1D vectors kx and ky (not kxx or kyy)! spectrum = jonswap(self.Nx, self.Ny, JS.Hs, JS.gamma, JS.fp, JS.nspread, JS.thetam, JS.gv, kx, ky) # (DISREGARD FOR NOW) - Imposing iniitial circular zero-pad filter if JS.filter == 1: spectrum[ 2*floor(self.kp/self.kc_x)+1 : (self.Nx-1)-2*floor(self.kp/self.kc_x), \ 2*floor(selfkp/kc_x)+1 : (self.Ny-1)-2*floor(self.kp/self.kc_x) ] = 0.0 + 0.0j else: pass # Compute the surface elvation via iFFT2D of the spectrum --> take REAL part # just in case we have some left over (nonzero) imaginary part of 'spectrum' self.surface = np.real(np.fft.ifft2(spectrum)) # Compute the velocity potential from linear theory and horizontal velocity [self.velPotential, self.u, self.v, self.w] = velocityPotential(spectrum, JS.gv, kx, ky)
def JONSWAP(): """Sets a wave field according to JONSWAP ocean wave spectrum. A script for initializing data files of a Quasi-3D wave simulation via the JONSWAP spectrum and directional distribution. GENERAL NOTES ============= MODULE: JONSWAP.py (Python Script File) AUTHOR: Matt Malej ([email protected]) PURPOSE: This Python script is designed to set up and initalize the wave field via a JONSWAP spectrum and for both directionally confined and and directional varied distribution. Will serve as input for simulating linear and eventually weakly nonlinear random surface water waves in realistic settings. The module imports JONSWAP_p.py (p = physics), where all the input parameters are specified. INPUT: Phyical parameters from JONSWAP_p.py Self NOTE: for FFT your transforming function needs to be periodic on your domain and do NOT make your first and final point in the domain equal! ... i.e. for sin(x) do NOT make x=[0,2*pi], but instead x=[dx,2*pi]! LAST UPDATE: January 14, 2014 """ # Some Global Variables omega_peak = 2.0 * pi * JS.fp # peak angular frequency # peak wavenumber (determinied from disper. rel. with h-->infty) kp = (2.0 * pi * JS.fp)**2 / JS.gv neqs = 2 # number of equations # Discretization Nx = 2**JS.npw1 # number of Fourier modes Ny = 2**JS.npw2 Lx = abs(JS.x1e - JS.x1b) # domain length Ly = abs(JS.y1e - JS.y1b) kc_x = 2 * pi / Lx kc_y = 2 * pi / Ly # std. wave factors if modes would be integers kc_x_modes = Nx * kc_x kc_y_modes = Ny * kc_y # wave factors for modes obtained from fftfreq() modes_x = np.fft.fftfreq(Nx) # Fourier mode alignments modes_y = np.fft.fftfreq(Ny) kx = kc_x_modes * modes_x ky = kc_y_modes * modes_y # Generating mesh grid for 2D spectrum [kxx, kyy] = np.meshgrid(kx, ky) # ~ Call jonswap() in spectrum.py module *** Send 1D vectors kx and ky (not kxx nor kyy)! spectrum = jonswap(Nx, Ny, JS.Hs, JS.gamma, JS.fp, JS.nspread, JS.thetam, JS.gv, kx, ky) # (DISREGARD FOR NOW) - Imposing iniitial circular zero-pad filter if JS.filter == 1: spectrum[2 * floor(kp / kc_x) + 1: (Nx - 1) - 2 * floor(kp / kc_x), 2 * floor(kp / kc_x) + 1: (Ny - 1) - 2 * floor(kp / kc_x)] = 0.0 + 0.0j else: pass # *** Compute the surface elvation via iFFT2D of the spectrum --> take REAL part # just in case we have some left over (nonzero) imaginary part of 'spectrum' surface = np.real(np.fft.ifft2(spectrum)) # *** Compute the velocity potential from linear theory and horizontal velocity velPotential, velocity_u, velocity_v = velocityPotential( spectrum, JS.gv, kx, ky) try: #fig1 = plt.figure() # plt.clf() #plt.plot(kx[0:Nx/2-1,], abs(spectrum[0:Nx/2-1,0]), 'b', linewidth=2) # plt.show() # Attaching 3D axis to the figure fig = plt.figure() ax = p3.Axes3D(fig) x = np.linspace(JS.x1b, JS.x1e, Nx) y = np.linspace(JS.y1b, JS.y1e, Ny) [xx, yy] = np.meshgrid(x, y) # surf = ax.plot_surface(xx,yy,surface,rstride=2,cstride=2, cmap=cm.jet, # linewidth=0.5, antialiased=False) ax.plot_wireframe(xx, yy, surface, rstride=4, cstride=4) plt.show() except: pass # Returning surface elvation along the line of wavemakers [x,y] loc = 10 return surface # [loc,:]
def JONSWAP(): """Sets a wave field according to JONSWAP ocean wave spectrum.""" from spectrum import jonswap from potential import velocityPotential # Some Global Variables omega_peak = 2.0 * pi * JS.fp # peak angular frequency kp = ( 2.0 * pi * JS.fp )**2 / JS.gv # peak wavenumber (determinied from disper. rel. with h-->infty) neqs = 2 # number of equations # Discretization Nx = 2**JS.npw1 # number of Fourier modes Ny = 2**JS.npw2 Lx = abs(JS.x1e - JS.x1b) # domain length Ly = abs(JS.y1e - JS.y1b) kc_x = 2 * pi / Lx kc_y = 2 * pi / Ly # std. wave factors if modes would be integers kc_x_modes = Nx * kc_x kc_y_modes = Ny * kc_y # wave factors for modes obtained from fftfreq() modes_x = np.fft.fftfreq(Nx) # Fourier mode alignments modes_y = np.fft.fftfreq(Ny) kx = kc_x_modes * modes_x ky = kc_y_modes * modes_y # Generating mesh grid for 2D spectrum [kxx, kyy] = np.meshgrid(kx, ky) # ~ Call jonswap() in spectrum.py module *** Send 1D vectors kx and ky (not kxx nor kyy)! spectrum = jonswap(Nx, Ny, JS.Hs, JS.gamma, JS.fp, JS.nspread, JS.thetam, JS.gv, kx, ky) # (DISREGARD FOR NOW) - Imposing iniitial circular zero-pad filter if JS.filter == 1: spectrum[2 * floor(kp / kc_x) + 1:(Nx - 1) - 2 * floor(kp / kc_x), 2 * floor(kp / kc_x) + 1:(Ny - 1) - 2 * floor(kp / kc_x)] = 0.0 + 0.0j else: pass # *** Compute the surface elvation via iFFT2D of the spectrum --> take REAL part # just in case we have some left over (nonzero) imaginary part of 'spectrum' surface = np.real(np.fft.ifft2(spectrum)) # *** Compute the velocity potential from linear theory and horizontal velocity velPotential, velocity_u, velocity_v = velocityPotential( spectrum, JS.gv, kx, ky) try: #fig1 = plt.figure() #plt.clf() #plt.plot(kx[0:Nx/2-1,], abs(spectrum[0:Nx/2-1,0]), 'b', linewidth=2) #plt.show() # Attaching 3D axis to the figure fig = plt.figure() ax = p3.Axes3D(fig) x = np.linspace(JS.x1b, JS.x1e, Nx) y = np.linspace(JS.y1b, JS.y1e, Ny) [xx, yy] = np.meshgrid(x, y) #surf = ax.plot_surface(xx,yy,surface,rstride=2,cstride=2, cmap=cm.jet, # linewidth=0.5, antialiased=False) ax.plot_wireframe(xx, yy, surface, rstride=4, cstride=4) plt.show() except: pass # Returning surface elvation along the line of wavemakers [x,y] loc = 10 return surface #[loc,:]
def JONSWAP(): """Sets a wave field according to JONSWAP ocean wave spectrum. A script for initializing data files of a Quasi-3D wave simulation via the JONSWAP spectrum and directional distribution. GENERAL NOTES ============= MODULE: JONSWAP.py (Python Script File) AUTHOR: Matt Malej ([email protected]) PURPOSE: This Python script is designed to set up and initalize the wave field via a JONSWAP spectrum and for both directionally confined and and directional varied distribution. Will serve as input for simulating linear and eventually weakly nonlinear random surface water waves in realistic settings. The module imports JONSWAP_p.py (p = physics), where all the input parameters are specified. INPUT: Phyical parameters from JONSWAP_p.py Self NOTE: for FFT your transforming function needs to be periodic on your domain and do NOT make your first and final point in the domain equal! ... i.e. for sin(x) do NOT make x=[0,2*pi], but instead x=[dx,2*pi]! LAST UPDATE: January 14, 2014 """ # Some Global Variables omega_peak = 2.0*pi*JS.fp # peak angular frequency kp = (2.0*pi*JS.fp)**2 / JS.gv # peak wavenumber (determinied from disper. rel. with h-->infty) neqs = 2 # number of equations # Discretization Nx = 2**JS.npw1 # number of Fourier modes Ny = 2**JS.npw2 Lx = abs(JS.x1e - JS.x1b) # domain length Ly = abs(JS.y1e - JS.y1b) kc_x = 2*pi/Lx kc_y = 2*pi/Ly # std. wave factors if modes would be integers kc_x_modes = Nx*kc_x kc_y_modes = Ny*kc_y # wave factors for modes obtained from fftfreq() modes_x = np.fft.fftfreq(Nx) # Fourier mode alignments modes_y = np.fft.fftfreq(Ny) kx = kc_x_modes * modes_x ky = kc_y_modes * modes_y # Generating mesh grid for 2D spectrum [kxx, kyy] = np.meshgrid(kx,ky) # ~ Call jonswap() in spectrum.py module *** Send 1D vectors kx and ky (not kxx nor kyy)! spectrum = jonswap(Nx, Ny, JS.Hs, JS.gamma, JS.fp, JS.nspread, JS.thetam, JS.gv, kx, ky) # (DISREGARD FOR NOW) - Imposing iniitial circular zero-pad filter if JS.filter == 1: spectrum[ 2*floor(kp/kc_x)+1 : (Nx-1)-2*floor(kp/kc_x), 2*floor(kp/kc_x)+1 : (Ny-1)-2*floor(kp/kc_x) ] = 0.0 + 0.0j else: pass # *** Compute the surface elvation via iFFT2D of the spectrum --> take REAL part # just in case we have some left over (nonzero) imaginary part of 'spectrum' surface = np.real(np.fft.ifft2(spectrum) ) # *** Compute the velocity potential from linear theory and horizontal velocity velPotential, velocity_u, velocity_v = velocityPotential(spectrum, JS.gv, kx, ky) try: #fig1 = plt.figure() #plt.clf() #plt.plot(kx[0:Nx/2-1,], abs(spectrum[0:Nx/2-1,0]), 'b', linewidth=2) #plt.show() # Attaching 3D axis to the figure fig = plt.figure() ax = p3.Axes3D(fig) x = np.linspace(JS.x1b, JS.x1e, Nx) y = np.linspace(JS.y1b,JS.y1e, Ny) [xx, yy] = np.meshgrid(x, y) #surf = ax.plot_surface(xx,yy,surface,rstride=2,cstride=2, cmap=cm.jet, # linewidth=0.5, antialiased=False) ax.plot_wireframe(xx,yy,surface, rstride=4, cstride=4) plt.show() except: pass # Returning surface elvation along the line of wavemakers [x,y] loc = 10 return surface #[loc,:]
def JONSWAP(): """Sets a wave field according to JONSWAP ocean wave spectrum.""" from spectrum import jonswap from potential import velocityPotential # Some Global Variables omega_peak = 2.0*pi*JS.fp # peak angular frequency kp = (2.0*pi*JS.fp)**2 / JS.gv # peak wavenumber (determinied from disper. rel. with h-->infty) neqs = 2 # number of equations # Discretization Nx = 2**JS.npw1 # number of Fourier modes Ny = 2**JS.npw2 Lx = abs(JS.x1e - JS.x1b) # domain length Ly = abs(JS.y1e - JS.y1b) kc_x = 2*pi/Lx kc_y = 2*pi/Ly # std. wave factors if modes would be integers kc_x_modes = Nx*kc_x kc_y_modes = Ny*kc_y # wave factors for modes obtained from fftfreq() modes_x = np.fft.fftfreq(Nx) # Fourier mode alignments modes_y = np.fft.fftfreq(Ny) kx = kc_x_modes * modes_x ky = kc_y_modes * modes_y # Generating mesh grid for 2D spectrum [kxx, kyy] = np.meshgrid(kx,ky) # ~ Call jonswap() in spectrum.py module *** Send 1D vectors kx and ky (not kxx nor kyy)! spectrum = jonswap(Nx, Ny, JS.Hs, JS.gamma, JS.fp, JS.nspread, JS.thetam, JS.gv, kx, ky) # (DISREGARD FOR NOW) - Imposing iniitial circular zero-pad filter if JS.filter == 1: spectrum[ 2*floor(kp/kc_x)+1 : (Nx-1)-2*floor(kp/kc_x), 2*floor(kp/kc_x)+1 : (Ny-1)-2*floor(kp/kc_x) ] = 0.0 + 0.0j else: pass # *** Compute the surface elvation via iFFT2D of the spectrum --> take REAL part # just in case we have some left over (nonzero) imaginary part of 'spectrum' surface = np.real(np.fft.ifft2(spectrum) ) # *** Compute the velocity potential from linear theory and horizontal velocity velPotential, velocity_u, velocity_v = velocityPotential(spectrum, JS.gv, kx, ky) try: #fig1 = plt.figure() #plt.clf() #plt.plot(kx[0:Nx/2-1,], abs(spectrum[0:Nx/2-1,0]), 'b', linewidth=2) #plt.show() # Attaching 3D axis to the figure fig = plt.figure() ax = p3.Axes3D(fig) x = np.linspace(JS.x1b, JS.x1e, Nx) y = np.linspace(JS.y1b,JS.y1e, Ny) [xx, yy] = np.meshgrid(x, y) #surf = ax.plot_surface(xx,yy,surface,rstride=2,cstride=2, cmap=cm.jet, # linewidth=0.5, antialiased=False) ax.plot_wireframe(xx,yy,surface, rstride=4, cstride=4) plt.show() except: pass # Returning surface elvation along the line of wavemakers [x,y] loc = 10 return surface #[loc,:]