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)