def test_L(ncores_x=2, ncores_y=4, ping_mpi_cfg=False):
if ping_mpi_cfg:
# escape before computing
return ncores_x, ncores_y
else:
# proceeds with computations
start_time = time.time()
cur_time = start_time
# hgrid = {'Lx':(512-1)*2.e3, 'Ly':(1440-1)*2.e3, 'H':4.e3, \
# 'Nx':512, 'Ny':1440, 'Nz':100}
hgrid = {
'Lx': (256 - 1) * 4.e3,
'Ly': (720 - 1) * 4.e3,
'H': 4.e3,
'Nx': 256,
'Ny': 720,
'Nz': 50
}
# vgrid = 'data/jet_cfg1_wp5_2km_k1e7_TSUP5_2000a3000j_zlvl_pv.nc'
vgrid = 'data/jet_cfg1_wp5_4km_k3.2e8_0a1500j_zlvl_pv.nc'
qg = qg_model(hgrid=hgrid,
vgrid=vgrid,
f0N2_file=vgrid,
K=1.e0,
dt=0.5 * 86400.e0)
qg.case = 'roms'
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for qg_model ', str(time.time() - cur_time)
cur_time = time.time()
qg.set_psi(file_psi=vgrid)
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for set_psi ', str(time.time() - cur_time)
cur_time = time.time()
qg.pvinv.L.mult(qg.PSI, qg.Q)
qg.invert_pv()
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for invert_pv ', str(time.time() - cur_time)
write_nc([qg.PSI, qg.Q], ['psi', 'q'], 'data/Lpsi_invPV.nc', qg)
def pvinv_solver(qg, fpsi_bg, fpsi_ot):
# ONE = qg.set_identity()
# qg.pvinv.L.mult(ONE,self._RHS)
# write_nc([self._RHS], ['id'], 'data/identity.nc', qg)
# qg.PSI.set(0)
# compute L*PSI and store in self._RHS
qg.pvinv.L.mult(qg.PSI, qg.pvinv._RHS)
# store L*PSI in netcdf file lpsi.nc
write_nc([qg.pvinv._RHS], ['rhs'], 'data/lpsiin.nc', qg)
# copy Q into RHS
qg.Q.copy(qg.pvinv._RHS)
if qg.pvinv._substract_fprime:
# substract f-f0 from PV
qg.pvinv.substract_fprime_from_rhs(qg)
if qg.pvinv._verbose > 0:
print 'Substract fprime from pv prior to inversion'
# fix boundaries
#self.set_rhs_bdy(qg)
set_rhs_bdy(qg, fpsi_bg, fpsi_ot)
# mask rhs
set_rhs_mask(qg)
# store RHS in netcdf file rhs.nc
write_nc([qg.pvinv._RHS], ['rhs'], 'data/rhs.nc', qg)
# actually solves the pb
qg.pvinv.ksp.solve(qg.pvinv._RHS, qg.PSI)
# compute L*PSI and store in self._RHS
qg.pvinv.L.mult(qg.PSI, qg.pvinv._RHS)
# store L*PSI in netcdf file lpsi.nc
write_nc([qg.pvinv._RHS], ['Lpsi'], 'data/lpsiout.nc', qg)
def curvilinear_runs(ncores_x=8, ncores_y=8, ping_mpi_cfg=False):
''' Tests with curvilinear grid
'''
if ping_mpi_cfg:
# escape before computing
return ncores_x, ncores_y
else:
# proceeds with computations
qg = qg_model(hgrid = 'curv_metrics.nc', vgrid = 'curv_metrics.nc',
f0N2_file = 'curv_pv.nc',
K = 1.e3, dt = 0.5*86400.e0)
qg.case='curv'
#
qg.set_q(file_q='curv_pv.nc')
qg.invert_pv()
write_nc([qg.PSI, qg.Q], ['psi', 'q'], 'data/output.nc', qg)
test=1
if test==0:
# one time step and store
qg.tstep(1)
write_nc([qg.PSI, qg.Q], ['psi', 'q'], 'data/output.nc', qg, create=False)
elif test==1:
while qg.tstepper.t/86400. < 200 :
qg.tstep(1)
write_nc([qg.PSI, qg.Q], ['psi', 'q'], 'data/output.nc', qg, create=False)
return qg
def nemo_input_runs(ncores_x=ncores_x, ncores_y=ncores_y, ping_mpi_cfg=False):
""" Set up processing parameters and run qg solver.
"""
# activate bg or other field
fpsi_bg = False
fpsi_ot = False
for key, value in bdy_type.items():
if value in ['NBG', 'DBG']:
fpsi_bg = True
if value in ['NOT', 'DOT']:
fpsi_ot = True
if ping_mpi_cfg:
# escape before computing
return ncores_x, ncores_y
else:
# proceeds with computations
start_time = time.time()
cur_time = start_time
# MPI decomposition of the domain
# case must be defined before ncores for run_caparmor.py
casename = 'nemo'
hgrid = datapath + 'nemo_metrics.nc'
vgrid = datapath + 'nemo_metrics.nc'
# equivalent boundary condition (to initialize qg solver)
bdy_type_tmp = copy.copy(bdy_type)
for key, value in bdy_type_tmp.items():
if value in ['N', 'NBG', 'NOT']:
bdy_type_tmp[key] = 'N'
if value in ['D', 'DBG', 'DOT']:
bdy_type_tmp[key] = 'D'
qg = qg_model(hgrid=hgrid,
vgrid=vgrid,
f0N2_file=file_q,
K=1.e0,
dt=0.5 * 86400.e0,
vdom=vdom,
hdom=hdom,
ncores_x=ncores_x,
ncores_y=ncores_y,
bdy_type_in=bdy_type_tmp,
substract_fprime=True)
# reset boundary condition to prescribed value
qg.bdy_type.update(bdy_type)
qg.case = casename
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for qg_model ', str(time.time() - cur_time)
cur_time = time.time()
# # read 3D variables (variable is set to None if optional and non-existing)
# read_nc_3D(qg, ['PSI', 'PSI_BG', 'PSI_OT', 'Q', 'RHO'],
# [file_psi, file_psi_bg, file_psi_ot, file_q, file_rho])
# initialize 3D-variables
# set analytically
# qg.set_q_analytically()
# qg.set_rho_analytically()
# qg.set_psi_analytically()
read_petsc(qg, fpsi_bg, fpsi_ot, file_q, file_rho, file_psi,
file_psi_bg, file_psi_ot)
# build the list of variables to write in input.nc
if not fpsi_bg and not fpsi_ot:
petsc_writein = [qg.PSI, qg.Q]
vname_writein = ['psi', 'q']
elif fpsi_bg and not fpsi_ot:
petsc_writein = [qg.PSI, qg.PSI_BG, qg.Q]
vname_writein = ['psi', 'psi_bg', 'q']
elif not fpsi_bg and fpsi_ot:
petsc_writein = [qg.PSI, qg.PSI_OT, qg.Q]
vname_writein = ['psi', 'psi_ot', 'q']
elif fpsi_bg and fpsi_ot:
petsc_writein = [qg.PSI, qg.PSI_BG, qg.PSI_OT, qg.Q]
vname_writein = ['psi', 'psi_bg', 'psi_ot', 'q']
write_nc(petsc_writein, vname_writein, 'data/input.nc', qg)
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for write_nc ', str(time.time() - cur_time)
cur_time = time.time()
if qg._verbose > 1:
print 'Inversion done'
#qg.pvinv.solve(qg)
pvinv_solver(qg, fpsi_bg, fpsi_ot)
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for invert_pv ', str(time.time() - cur_time)
cur_time = time.time()
write_nc([qg.PSI, qg.Q], ['psi', 'q'], 'data/output.nc', qg)
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for write_nc ', str(time.time() - cur_time)
cur_time = time.time()
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0: print 'Elapsed time ', str(cur_time - start_time)
return qg
def uniform_grid_runs(ncores_x=16, ncores_y=16, ping_mpi_cfg=False):
"""
Tests with uniform grid, closed domains
"""
start_time = time.time()
cur_time = start_time
# MPI decomposition of the domain
# case must be defined before ncores for run_caparmor.py
casename = 'uniform'
# grid
# nhoes: 512³, 512 procs, 1000³, 4096 procs
# LMX case: Nx=1032=2³x3x43, Ny=756=2²x3³x7, Nz=300
#hgrid = {'Nx':1032, 'Ny':756}
#vgrid = {'Nz':300}
#
#
#ncores_x=8; ncores_y=2
#hgrid = {'Nx':256, 'Ny':256}
#vgrid = {'Nz':50}
# :
ncores_x = 16
ncores_y = 16
hgrid = {'Nx': 512, 'Ny': 512}
#vgrid = {'Nz':100}
vgrid = {'Nz': 200}
# requires 16x8:
#ncores_x=16; ncores_y=8
#hgrid = {'Nx':512, 'Ny':512}
#vgrid = {'Nz':300}
# requires 16x16
#ncores_x=16; ncores_y=16
#hgrid = {'Nx':1024, 'Ny':512}
#vgrid = {'Nz':300}
# crashes with io
# no io
# 512 x 512 x 100 on 8x8: 160 s, 136 iter
# 512 x 512 x 300 on 8x8: crash, out of memory
# ------- on 16x8: 237 s, 144 iter
# 1024 x 512 x 300 on 16 x 8: crash, out of memory
# ------- on 16x16: 379s s, 236 iter
if ping_mpi_cfg:
# escape before computing
return ncores_x, ncores_y
else:
# proceeds with computations
qg = qg_model(hgrid=hgrid,
vgrid=vgrid,
K=0.e0,
dt=0.5 * 86400.e0,
ncores_x=ncores_x,
ncores_y=ncores_y)
qg.case = 'uniform'
#
qg.set_q()
qg.set_rho()
qg.set_psi()
qg.invert_pv()
write_nc([qg.PSI, qg.Q], ['psi', 'q'], 'data/output.nc', qg)
if qg._verbose > 0:
print '----------------------------------------------------'
print 'Elapsed time for all ', str(time.time() - cur_time)
#
test = -1
if test == 0:
# one time step and store
qg.tstep(1)
write_nc([qg.PSI, qg.Q], ['psi', 'q'],
'data/output.nc',
qg,
create=False)
elif test == 1:
# write/read/write
qg.tstep(1)
write_nc([qg.PSI, qg.Q], ['psi', 'q'],
'data/output1.nc',
qg,
create=True)
qg.set_q(file_q='data/output.nc')
qg.tstep(1)
write_nc([qg.PSI, qg.Q], ['psi', 'q'],
'data/output1.nc',
qg,
create=False)
elif test == 2:
while qg.tstepper.t / 86400. < 200:
qg.tstep(1)
write_nc([qg.PSI, qg.Q], ['psi', 'q'],
'data/output.nc',
qg,
create=False)
return qg
def roms_input_runs(ncores_x=2, ncores_y=4, ping_mpi_cfg=False):
''' Tests with roms configuration (spatially uniform, vertically stretched)
'''
if ping_mpi_cfg:
# escape before computing
return ncores_x, ncores_y
else:
# proceeds with computations
start_time = time.time()
cur_time = start_time
# MPI decomposition of the domain
# case must be defined before ncores for run_caparmor.py
casename = 'roms'
# vertical subdomain
# vdom = {'kdown': 0, 'kup': 49, 'k0': 0 }
vdom = {'kdown': 25, 'kup': 35, 'k0': 15}
# horizontal subdomain
# hdom = {'istart': 0, 'iend': 255, 'i0': 0, 'jstart':0, 'jend':721, 'j0': 0}
hdom = {
'istart': 50,
'iend': 200,
'i0': 40,
'jstart': 100,
'jend': 600,
'j0': 90
}
# hgrid = {'Lx':(512-1)*2.e3, 'Ly':(1440-1)*2.e3, 'H':4.e3, \
# 'Nx':512, 'Ny':1440, 'Nz':100}
hgrid = {
'Lx': (256 - 1) * 4.e3,
'Ly': (720 - 1) * 4.e3,
'Nx0': 256,
'Ny0': 722
}
# vgrid = 'data/jet_cfg1_wp5_2km_k1e7_TSUP5_2000a3000j_zlvl_pv.nc'
vgrid = 'data/jet_cfg1_wp5_4km_k3.2e8_0a1500j_zlvl_pv.nc'
qg = qg_model(hgrid=hgrid,
vgrid=vgrid,
f0N2_file=vgrid,
K=1.e0,
dt=0.5 * 86400.e0,
vdom=vdom,
hdom=hdom,
ncores_x=ncores_x,
ncores_y=ncores_y)
qg.case = casename
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for qg_model ', str(time.time() - cur_time)
cur_time = time.time()
qg.set_q(file_q=vgrid)
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for set_q ', str(time.time() - cur_time)
cur_time = time.time()
qg.set_psi(file_psi=vgrid)
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for set_psi ', str(time.time() - cur_time)
cur_time = time.time()
qg.set_rho(file_rho=vgrid)
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for set_rho ', str(time.time() - cur_time)
cur_time = time.time()
qg.invert_pv()
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for invert_pv ', str(time.time() - cur_time)
cur_time = time.time()
write_nc([qg.PSI, qg.Q], ['psi', 'q'], 'data/output.nc', qg)
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0:
print 'Elapsed time for write_nc ', str(time.time() - cur_time)
cur_time = time.time()
if qg.rank == 0:
print '----------------------------------------------------'
if qg.rank == 0: print 'Elapsed time ', str(cur_time - start_time)
return qg
