if type(self.sizevar) != list: print('sizevar has to be a list') print('Abort!!!') exit(0) self.sizestate = [self.nvar] + self.sizevar self.state = np.zeros(self.sizestate) def get(self, name): """ extract variable 'name' from the stack """ k = self.varname_list.index(name) return self.state[k] if __name__ == "__main__": param = Param() param.varname_list = ['vort', 'psi', 'u'] param.sizevar = [4, 2] var = Var(param) print(np.shape(var.state)) vor = var.get('vort') vor[:, 0] = 1. print(np.shape(vor)) print(var.state)
from param2d import Param from grid import Grid from fluid2d import Fluid2d import numpy as np from restart import Restart from island import Island param = Param('default.xml') param.modelname = 'euler' param.expname = 'karman_0' # domain and resolution ratio = 2 param.ny = 64 * 2 param.nx = param.ny * ratio param.Ly = 1. param.Lx = param.Ly * ratio param.npx = 1 param.npy = 1 param.geometry = 'xchannel' # time param.tend = 600 param.cfl = 1.2 param.adaptable_dt = True param.dt = 1e-2 param.dtmax = 1. # discretization param.order = 3 param.timestepping = 'RK3_SSP'
from grid import Grid from fluid2d import Fluid2d import numpy as np import ana_profiles as ap # If the code immediately stops with # Traceback (most recent call last): # File "vortex.py", line 1, in <module> # from param import Param # ImportError: No module named param # it means that you forgot to do # source activate.sh in your terminal param = Param('default.xml') param.modelname = 'euler' param.expname = 'vortex_08' # domain and resolution param.nx = 64 * 2 param.ny = param.nx param.Ly = param.Lx param.npx = 1 param.npy = 1 param.geometry = 'closed' # time param.tend = 10 param.cfl = 1. param.adaptable_dt = True
else: cst_glo = np.array(MPI.COMM_WORLD.allgather(cst)) for k in range(nb): ope = list_scalars[k][1] if ope == 'max': cst[k] = np.max(cst_glo[:, k]) elif ope == 'sum': cst[k] = np.sum(cst_glo[:, k]) return cst if __name__ == "__main__": p = Param() p.npx = 2 p.npy = 2 rank = MPI.COMM_WORLD.Get_rank() p.myrank = rank d = [(rank, 'max'), (1, 'sum'), (rank, 'sum')] tool = Mpitools(p) r = tool.local_to_global(d) if rank == 0: print('max(rank)=', r[0]) print('sum(1) =', r[1])
from param2d import Param from grid import Grid from fluid2d import Fluid2d import numpy as np param = Param('default.xml') param.modelname = 'boussinesq' param.expname = 'khi_0' # domain and resolution ratio = 2 param.ny = 64*2 param.nx = param.ny*ratio param.Ly = 1. param.Lx = 1*ratio param.npx = 1 param.npy = 1 param.geometry = 'xchannel' # time param.tend = 5. param.cfl = 1.5 param.adaptable_dt = True param.dt = 0.01 param.dtmax = 0.02 # discretization param.order = 5 param.timestepping = 'RK3_SSP' # output
from param2d import Param from grid import Grid from fluid2d import Fluid2d import numpy as np param = Param('default.xml') param.modelname = 'boussinesq' param.expname = 'taylorinst_00' # domain and resolution param.nx = 64 * 2 param.ny = param.nx param.npx = 1 param.npy = 1 param.Lx = 1. param.Ly = param.Lx param.geometry = 'xperio' # time param.tend = 10. param.cfl = 1.5 param.adaptable_dt = True param.dt = 0.004 param.dtmax = 1e-2 # discretization param.order = 5 # output param.plot_var = 'buoyancy'
from param2d import Param from grid import Grid from fluid2d import Fluid2d import numpy as np """ Reentrant channel with prescribed transport through the channel. The transport is controlled via psi0, the streamfunction at the North Wall -- psi=0 on the South Wall. An island with psi=psi0/2 is also set in the middle of the channel. Even though there is no explicit forcing, this setup creates an island wake. Control parameters include: - Rd/L, relative size of the deformation radius beta Rd^2 L / psi0, - relative importance of the jet speed vs Rossby wave speed """ param = Param('default.xml') param.modelname = 'quasigeostrophic' param.expname = 'channel' # domain and resolution param.nx = 64 * 4 param.ny = param.nx / 4 param.npy = 1 param.Lx = 4. param.Ly = param.Lx / 4 param.geometry = 'xchannel' # time param.tend = 5000. param.cfl = 1.2 param.adaptable_dt = True param.dt = 1.
self.kstage = 0 self.rhs(x, t, self.dx0) self.x = x + (0.25*dt) * self.dx0 self.kstage = 1 self.rhs(self.x, t+dt*0.25, self.dx0) self.x = x + (dt/3.)*self.dx0 self.kstage = 2 self.rhs(self.x, t+dt/3., self.dx0) self.x = x + (dt/2.)*self.dx0 self.kstage = 3 self.rhs(self.x, t+0.5*dt, self.dx0) x += dt*self.dx0 if __name__ == "__main__": param = Param() param.timestepping = 'AB2' param.varname_list = ['vort', 'psi', 'u'] param.sizevar = [4, 2] var = Var(param) tscheme = Timescheme(param, var.state) print(tscheme.x) tscheme.forward()
from param2d import Param from grid import Grid from fluid2d import Fluid2d import numpy as np param = Param('default.xml') param.modelname = 'quasigeostrophic' param.expname = 'topo_test' # domain and resolution ratio = 2 param.nx = 64*4 param.ny = param.nx//ratio param.npx = 1 param.npy = 1 param.Lx = 2. param.Ly = param.Lx/ratio param.geometry = 'xchannel' # time param.tend = 500. param.cfl = 1.2 param.adaptable_dt = False param.dt = 0.3 param.dtmax = 100. # discretization param.order = 5 # param.flux_splitting_method = 'minmax' # output
""" add the forcing term on x[0]=the vorticity """ dt = t - self.t self.t = t # Define the forcing as the sum of the forcing in the last step and # a new random forcing self.forc = ( (1 - dt * self.gamma) * self.forc + dt * self.gamma * np.random.normal(size=self.sizevar) * self.msk) self.fill_halo(self.forc) dxdt[0] += self.intensity * self.forc param = Param('default.xml') param.modelname = 'euler' param.expname = 'twodimturb_00' # domain and resolution param.nx = 64 * 2 param.ny = param.nx param.Ly = param.Lx param.npx = 1 param.npy = 1 param.geometry = 'closed' # time param.tend = 100. param.cfl = 1.2 param.adaptable_dt = True
# choice A/ jet-like forcing (localized in y) # self.forc = tau0 * (yr/sigma)*np.exp(-yr**2/(2*sigma**2)) * grid.msk # choice B/ basin-scale forcing: double gyre configuration self.forc = tau0 * np.sin(yr * np.pi) * grid.msk total = grid.domain_integration(self.forc) self.forc -= (total / grid.area) * grid.msk def add_forcing(self, x, t, dxdt): """ add the forcing term on x[0]=the vorticity """ dxdt[0] += self.forc param = Param('default.xml') param.modelname = 'quasigeostrophic' param.expname = 'dbl_gyre_00' # domain and resolution param.nx = 64 * 2 param.ny = 64 param.npy = 1 param.Lx = 2. param.Ly = param.Lx / 2 param.geometry = 'closed' # time param.tend = 2000. param.cfl = 1.5 param.adaptable_dt = True
from param2d import Param from grid import Grid from fluid2d import Fluid2d import numpy as np param = Param('default.xml') param.modelname = 'boussinesq' param.expname = 'gravcurr_00' # domain and resolution param.ny = 128 param.nx = param.ny * 2 param.npx = 1 param.npy = 1 param.Lx = 2. param.Ly = 1. param.geometry = 'closed' # time param.tend = 5. param.cfl = 1.2 param.adaptable_dt = True param.dt = .1 param.dtmax = .1 # discretization param.order = 5 # output param.plot_var = 'buoyancy'
self.r2 = self.xr0**2 + self.yr0**2 def domain_integration(self, z2d): """Define the domain integral function on grid cells""" nh = self.nh integral = np.sum(z2d[nh:-nh, nh:-nh]) * 1. integral = self.mpitools.local_to_global([(integral, 'sum')]) return integral if __name__ == "__main__": param = Param() param.myrank = 0 param.npx = 2 param.npy = 2 param.nx = 10 param.ny = 10 param.geometry = 'closed' grid = Grid(param) print("myrank is :", param.myrank) print(grid.xr[0, :]) print(grid.yr[:, 0]) print(grid.msk) print('my coordinates in the subdomains matrix (%i,%i)' % (grid.j0, grid.i0)) print('global domain area =%f' % grid.area)