def test_multiple_grid_addlater_error():
xdim, ydim = 10, 20
U = Field('U',
np.zeros((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
V = Field('V',
np.zeros((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
fieldset = FieldSet(U, V)
pset = pset_type['soa']['pset'](
fieldset, pclass=pclass('jit'), lon=[0.8],
lat=[0.9]) # noqa ; to trigger fieldset.check_complete
P = Field('P',
np.zeros((ydim * 10, xdim * 10), dtype=np.float32),
lon=np.linspace(0., 1., xdim * 10, dtype=np.float32),
lat=np.linspace(0., 1., ydim * 10, dtype=np.float32))
fail = False
try:
fieldset.add_field(P)
except RuntimeError:
fail = True
assert fail
def test_multiple_grid_addlater_error():
xdim, ydim = 10, 20
U = Field('U',
np.zeros((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
V = Field('V',
np.zeros((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
fieldset = FieldSet(U, V)
pset = ParticleSet(fieldset, pclass=pclass('jit'), lon=[0.8], lat=[0.9])
P = Field('P',
np.zeros((ydim * 10, xdim * 10), dtype=np.float32),
lon=np.linspace(0., 1., xdim * 10, dtype=np.float32),
lat=np.linspace(0., 1., ydim * 10, dtype=np.float32))
fieldset.add_field(P)
fail = False
try:
pset.execute(AdvectionRK4, runtime=10, dt=1)
except:
fail = True
assert fail
def test_nestedfields(mode, k_sample_p):
xdim = 10
ydim = 20
U1 = Field('U1',
0.1 * np.ones((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
V1 = Field('V1',
0.2 * np.ones((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
U2 = Field('U2',
0.3 * np.ones((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 2., xdim, dtype=np.float32),
lat=np.linspace(0., 2., ydim, dtype=np.float32))
V2 = Field('V2',
0.4 * np.ones((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 2., xdim, dtype=np.float32),
lat=np.linspace(0., 2., ydim, dtype=np.float32))
U = NestedField('U', [U1, U2])
V = NestedField('V', [V1, V2])
fieldset = FieldSet(U, V)
P1 = Field('P1',
0.1 * np.ones((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
P2 = Field('P2',
0.2 * np.ones((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 2., xdim, dtype=np.float32),
lat=np.linspace(0., 2., ydim, dtype=np.float32))
P = NestedField('P', [P1, P2])
fieldset.add_field(P)
def Recover(particle, fieldset, time):
particle.lon = -1
particle.lat = -1
particle.p = 999
particle.time = particle.time + particle.dt
pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0], lat=[.3])
pset.execute(AdvectionRK4 + pset.Kernel(k_sample_p), runtime=1, dt=1)
assert np.isclose(pset.lat[0], .5)
assert np.isclose(pset.p[0], .1)
pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0], lat=[1.3])
pset.execute(AdvectionRK4 + pset.Kernel(k_sample_p), runtime=1, dt=1)
assert np.isclose(pset.lat[0], 1.7)
assert np.isclose(pset.p[0], .2)
pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0], lat=[2.3])
pset.execute(AdvectionRK4 + pset.Kernel(k_sample_p),
runtime=1,
dt=1,
recovery={ErrorCode.ErrorOutOfBounds: Recover})
assert np.isclose(pset.lat[0], -1)
assert np.isclose(pset.p[0], 999)
assert np.allclose(fieldset.UV[0][0, 0, 0, 0], [.1, .2])
def test_sampling_multigrids_non_vectorfield(pset_mode, mode, npart):
xdim, ydim = 100, 200
U = Field('U', np.zeros((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
V = Field('V', np.zeros((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
B = Field('B', np.ones((3*ydim, 4*xdim), dtype=np.float32),
lon=np.linspace(0., 1., 4*xdim, dtype=np.float32),
lat=np.linspace(0., 1., 3*ydim, dtype=np.float32))
fieldset = FieldSet(U, V)
fieldset.add_field(B, 'B')
fieldset.add_constant('sample_depth', 2.5)
assert fieldset.U.grid is fieldset.V.grid
assert fieldset.U.grid is not fieldset.B.grid
class TestParticle(ptype[mode]):
sample_var = Variable('sample_var', initial=0.)
pset = pset_type[pset_mode]['pset'].from_line(fieldset, pclass=TestParticle, start=[0.3, 0.3], finish=[0.7, 0.7],
size=npart)
def test_sample(particle, fieldset, time):
particle.sample_var += fieldset.B[time, fieldset.sample_depth, particle.lat, particle.lon]
kernels = pset.Kernel(AdvectionRK4) + pset.Kernel(test_sample)
pset.execute(kernels, runtime=10, dt=1)
assert np.allclose(pset.sample_var, 10.0)
if mode == 'jit':
if pset_mode == 'soa':
assert len(pset.xi.shape) == 2
assert pset.xi.shape[0] == len(pset.lon)
assert pset.xi.shape[1] == fieldset.gridset.size
assert np.all(pset.xi >= 0)
assert np.all(pset.xi[:, fieldset.B.igrid] < xdim * 4)
assert np.all(pset.xi[:, 0] < xdim)
assert pset.yi.shape[0] == len(pset.lon)
assert pset.yi.shape[1] == fieldset.gridset.size
assert np.all(pset.yi >= 0)
assert np.all(pset.yi[:, fieldset.B.igrid] < ydim * 3)
assert np.all(pset.yi[:, 0] < ydim)
elif pset_mode == 'aos':
assert np.alltrue([[pxi > 0 for pxi in p.xi] for p in pset])
assert np.alltrue([len(p.xi) == fieldset.gridset.size for p in pset])
assert np.alltrue([p.xi[fieldset.B.igrid] < xdim * 4 for p in pset])
assert np.alltrue([p.xi[0] < xdim for p in pset])
assert np.alltrue([[pyi > 0 for pyi in p.yi] for p in pset])
assert np.alltrue([len(p.yi) == fieldset.gridset.size for p in pset])
assert np.alltrue([p.yi[fieldset.B.igrid] < ydim * 3 for p in pset])
assert np.alltrue([p.yi[0] < ydim for p in pset])
def test_summedfields(mode, with_W, k_sample_p, mesh):
xdim = 10
ydim = 20
zdim = 4
gf = 10 # factor by which the resolution of grid1 is higher than of grid2
U1 = Field('U', 0.2*np.ones((zdim*gf, ydim*gf, xdim*gf), dtype=np.float32),
lon=np.linspace(0., 1., xdim*gf, dtype=np.float32),
lat=np.linspace(0., 1., ydim*gf, dtype=np.float32),
depth=np.linspace(0., 20., zdim*gf, dtype=np.float32),
mesh=mesh)
U2 = Field('U', 0.1*np.ones((zdim, ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32),
depth=np.linspace(0., 20., zdim, dtype=np.float32),
mesh=mesh)
V1 = Field('V', np.zeros((zdim*gf, ydim*gf, xdim*gf), dtype=np.float32), grid=U1.grid, fieldtype='V')
V2 = Field('V', np.zeros((zdim, ydim, xdim), dtype=np.float32), grid=U2.grid, fieldtype='V')
fieldsetS = FieldSet(U1+U2, V1+V2)
conv = 1852*60 if mesh == 'spherical' else 1.
assert np.allclose(fieldsetS.U[0, 0, 0, 0]*conv, 0.3)
P1 = Field('P', 30*np.ones((zdim*gf, ydim*gf, xdim*gf), dtype=np.float32), grid=U1.grid)
P2 = Field('P', 20*np.ones((zdim, ydim, xdim), dtype=np.float32), grid=U2.grid)
P3 = Field('P', 10*np.ones((zdim, ydim, xdim), dtype=np.float32), grid=U2.grid)
P4 = Field('P', 0*np.ones((zdim, ydim, xdim), dtype=np.float32), grid=U2.grid)
fieldsetS.add_field((P1+P4)+(P2+P3), name='P')
assert np.allclose(fieldsetS.P[0, 0, 0, 0], 60)
if with_W:
W1 = Field('W', 2*np.ones((zdim * gf, ydim * gf, xdim * gf), dtype=np.float32), grid=U1.grid)
W2 = Field('W', np.ones((zdim, ydim, xdim), dtype=np.float32), grid=U2.grid)
fieldsetS.add_field(W1+W2, name='W')
pset = ParticleSet(fieldsetS, pclass=pclass(mode), lon=[0], lat=[0.9])
pset.execute(AdvectionRK4_3D+pset.Kernel(k_sample_p), runtime=2, dt=1)
assert np.isclose(pset[0].depth, 6)
else:
pset = ParticleSet(fieldsetS, pclass=pclass(mode), lon=[0], lat=[0.9])
pset.execute(AdvectionRK4+pset.Kernel(k_sample_p), runtime=2, dt=1)
assert np.isclose(pset[0].p, 60)
assert np.isclose(pset[0].lon*conv, 0.6, atol=1e-3)
assert np.isclose(pset[0].lat, 0.9)
assert np.allclose(fieldsetS.UV[0][0, 0, 0, 0], [.2/conv, 0])
def set_fields(hycomfiles, stokesfiles):
dimensions = {
'lat': 'Latitude',
'lon': 'Longitude',
'time': 'MT',
'depth': 'Depth'
}
bvelfile = '/Users/erik/Codes/ParcelsRuns/Hydrodynamics_AuxiliaryFiles/Hycom/boundary_velocities.nc'
MaskUvel = Field.from_netcdf(bvelfile, 'MaskUvel', dimensions)
MaskVvel = Field.from_netcdf(bvelfile, 'MaskVvel', dimensions)
uhycom = Field.from_netcdf(hycomfiles, 'u', dimensions, fieldtype='U')
vhycom = Field.from_netcdf(hycomfiles,
'v',
dimensions,
fieldtype='V',
grid=uhycom.grid,
timeFiles=uhycom.timeFiles)
dimensions = {'lat': 'latitude', 'lon': 'longitude', 'time': 'time'}
uuss = Field.from_netcdf(stokesfiles, 'uuss', dimensions, fieldtype='U')
vuss = Field.from_netcdf(stokesfiles,
'vuss',
dimensions,
fieldtype='V',
grid=uuss.grid,
timeFiles=uuss.timeFiles)
fieldset = FieldSet(U=uhycom + uuss, V=vhycom + vuss)
fieldset.add_field(MaskUvel)
fieldset.add_field(MaskVvel)
fieldset.MaskUvel.units = fieldset.U[0].units
fieldset.MaskVvel.units = fieldset.V[0].units
fieldset.add_periodic_halo(zonal=True, meridional=False, halosize=5)
return fieldset
def test_sampling_multigrids_non_vectorfield_from_file(mode,
npart,
tmpdir,
chs,
filename='test_subsets'
):
xdim, ydim = 100, 200
filepath = tmpdir.join(filename)
U = Field('U',
np.zeros((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
V = Field('V',
np.zeros((ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32))
B = Field('B',
np.ones((3 * ydim, 4 * xdim), dtype=np.float32),
lon=np.linspace(0., 1., 4 * xdim, dtype=np.float32),
lat=np.linspace(0., 1., 3 * ydim, dtype=np.float32))
fieldset = FieldSet(U, V)
fieldset.add_field(B, 'B')
fieldset.write(filepath)
fieldset = None
ufiles = [
filepath + 'U.nc',
] * 4
vfiles = [
filepath + 'V.nc',
] * 4
bfiles = [
filepath + 'B.nc',
] * 4
timestamps = np.arange(0, 4, 1) * 86400.0
timestamps = np.expand_dims(timestamps, 1)
files = {'U': ufiles, 'V': vfiles, 'B': bfiles}
variables = {'U': 'vozocrtx', 'V': 'vomecrty', 'B': 'B'}
dimensions = {'lon': 'nav_lon', 'lat': 'nav_lat'}
fieldset = FieldSet.from_netcdf(files,
variables,
dimensions,
timestamps=timestamps,
allow_time_extrapolation=True,
field_chunksize=chs)
fieldset.add_constant('sample_depth', 2.5)
assert fieldset.U.grid is fieldset.V.grid
assert fieldset.U.grid is not fieldset.B.grid
class TestParticle(ptype[mode]):
sample_var = Variable('sample_var', initial=0.)
pset = ParticleSet.from_line(fieldset,
pclass=TestParticle,
start=[0.3, 0.3],
finish=[0.7, 0.7],
size=npart)
def test_sample(particle, fieldset, time):
particle.sample_var += fieldset.B[time, fieldset.sample_depth,
particle.lat, particle.lon]
kernels = pset.Kernel(AdvectionRK4) + pset.Kernel(test_sample)
pset.execute(kernels, runtime=10, dt=1)
assert np.allclose(pset.sample_var, 10.0)
if mode == 'jit':
assert len(pset.xi.shape) == 2
assert pset.xi.shape[0] == len(pset.lon)
assert pset.xi.shape[1] == fieldset.gridset.size
assert np.all(pset.xi >= 0)
assert np.all(pset.xi[:, fieldset.B.igrid] < xdim * 4)
assert np.all(pset.xi[:, 0] < xdim)
assert pset.yi.shape[0] == len(pset.lon)
assert pset.yi.shape[1] == fieldset.gridset.size
assert np.all(pset.yi >= 0)
assert np.all(pset.yi[:, fieldset.B.igrid] < ydim * 3)
assert np.all(pset.yi[:, 0] < ydim)
galapagosmask[y, x] = 2
if (fU.grid.lon[x] >= extent3[0] and
fU.grid.lon[x] < extent3[1] and
fU.grid.lat[y] >= extent3[2] and
fU.grid.lat[y] < extent3[3]):
galapagosmask[y, x] = 3
if (fU.grid.lon[x] >= extent4[0] and
fU.grid.lon[x] < extent4[1] and
fU.grid.lat[y] >= extent4[2] and
fU.grid.lat[y] < extent4[3]):
galapagosmask[y, x] = 4
lon = fU.grid.lon
lat = fU.grid.lat
depth = 0
fieldset.add_field(Field('galapagosmask', galapagosmask,
lon=lon,lat=lat,depth=depth,
mesh='spherical', interp_method='nearest',
allow_time_extrapolation=True))
#functions to add to the kernel
def Age(fieldset, particle, time):
particle.age = particle.age + math.fabs(particle.dt)
if particle.age > 180*86400:
particle.delete()
def DeleteParticle(particle, fieldset, time):
particle.delete()
def SampleGalapagos(fieldset, particle, time):
if fieldset.galapagosmask[time, particle.depth, particle.lat, particle.lon] == 1:
particle.visitedgalapagos = 1
interp_method='linear',
mesh='spherical',
allow_time_extrapolation=True)
# Normal away from coast (y component)
cnormy = Field.from_netcdf(fh['grid'],
variable='cnormy_rho',
dimensions={
'lon': 'lon_rho',
'lat': 'lat_rho'
},
interp_method='linear',
mesh='spherical',
allow_time_extrapolation=True)
fieldset.add_field(iso_psi_all)
fieldset.add_field(source_id_psi)
fieldset.add_field(sink_id_psi)
fieldset.add_field(cdist)
fieldset.add_field(cnormx)
fieldset.add_field(cnormy)
fieldset.cnormx_rho.units = GeographicPolar()
fieldset.cnormy_rho.units = Geographic()
# ADD THE PERIODIC BOUNDARY
fieldset.add_constant('halo_west', -180.)
fieldset.add_constant('halo_east', 180.)
fieldset.add_periodic_halo(zonal=True)
# ADD DIFFUSION
###############################################################################
# Adding the border current, which applies for all scenarios except for 0 #
###############################################################################
datasetBor = Dataset(dataInputdirec + 'boundary_velocities_HYCOM.nc')
borU = datasetBor.variables['MaskUvel'][:]
borU[borU != 0] = borU[borU != 0] / abs(borU[borU != 0])
borV = datasetBor.variables['MaskVvel'][:]
borV[borV != 0] = borV[borV != 0] / abs(borV[borV != 0])
borMag = np.sqrt(np.square(borU) + np.square(borV))
nonzeroMag = borMag > 0
borMag[borMag == 0] = 1
borU = np.divide(borU, borMag)
borV = np.divide(borV, borMag)
lonBor, latBor = datasetBor.variables['lon'][:], datasetBor.variables['lat'][:]
fieldset.add_field(
Field('borU', borU, lon=lonBor, lat=latBor, mesh='spherical'))
fieldset.add_field(
Field('borV', borV, lon=lonBor, lat=latBor, mesh='spherical'))
fieldset.borU.units = GeographicPolar()
fieldset.borV.units = Geographic()
###############################################################################
# Adding the horizontal diffusion #
###############################################################################
kh = 10 #m^2 s^-1, following Lacerda et al. (2019) and Liubertseva et al. (2018)
dataset = Dataset(datadirec + 'HYCOM/HYCOM_Surface_3h_2000-01-01.nc')
uo = dataset.variables['water_u'][0, 0, :, :]
lat_kh = dataset.variables['lat'][:]
lon_kh = dataset.variables['lon'][:]
kh_f = kh * np.ones(uo.shape)
kh_f[uo.mask == True] = 0
V=fset_currents.V + fset_stokes.V + fset_wind.V)
elif withstokes:
fieldset = FieldSet(U=fset_currents.U + fset_stokes.U,
V=fset_currents.V + fset_stokes.V)
elif withwind:
fieldset = FieldSet(U=fset_currents.U + fset_wind.U,
V=fset_currents.V + fset_wind.V)
else:
fieldset = FieldSet(U=fset_currents.U, V=fset_currents.V)
if withwind: # for sampling
for var, name in zip((fset_wind.U, fset_wind.V), ('uwind', 'vwind')):
fld = copy.deepcopy(var)
fld.name = name
fld.units = UnitConverter() # to sample in m/s
fieldset.add_field(fld)
fieldset.add_field(
Field('Kh_zonal',
data=10 * np.ones(size2D),
lon=fset_currents.U.grid.lon,
lat=fset_currents.U.grid.lat,
mesh='spherical',
allow_time_extrapolation=True))
fieldset.add_field(
Field('Kh_meridional',
data=10 * np.ones(size2D),
lon=fset_currents.U.grid.lon,
lat=fset_currents.U.grid.lat,
mesh='spherical',
allow_time_extrapolation=True))
def test_list_of_fields(mode, with_W, k_sample_p, mesh):
xdim = 10
ydim = 20
zdim = 4
gf = 10 # factor by which the resolution of grid1 is higher than of grid2
U1 = Field('U1',
0.2 * np.ones(
(zdim * gf, ydim * gf, xdim * gf), dtype=np.float32),
lon=np.linspace(0., 1., xdim * gf, dtype=np.float32),
lat=np.linspace(0., 1., ydim * gf, dtype=np.float32),
depth=np.linspace(0., 20., zdim * gf, dtype=np.float32),
mesh=mesh,
fieldtype='U')
U2 = Field('U2',
0.1 * np.ones((zdim, ydim, xdim), dtype=np.float32),
lon=np.linspace(0., 1., xdim, dtype=np.float32),
lat=np.linspace(0., 1., ydim, dtype=np.float32),
depth=np.linspace(0., 20., zdim, dtype=np.float32),
mesh=mesh,
fieldtype='U')
V1 = Field('V1',
np.zeros((zdim * gf, ydim * gf, xdim * gf), dtype=np.float32),
grid=U1.grid,
fieldtype='V')
V2 = Field('V2',
np.zeros((zdim, ydim, xdim), dtype=np.float32),
grid=U2.grid,
fieldtype='V')
fieldset = FieldSet([U1, U2], [V1, V2])
conv = 1852 * 60 if mesh == 'spherical' else 1.
assert np.allclose(fieldset.U.eval(0, 0, 0, 0) * conv, 0.3)
assert np.allclose(fieldset.U[0, 0, 0, 0] * conv, 0.3)
P1 = Field('P1',
30 * np.ones(
(zdim * gf, ydim * gf, xdim * gf), dtype=np.float32),
grid=U1.grid)
P2 = Field('P2',
20 * np.ones((zdim, ydim, xdim), dtype=np.float32),
grid=U2.grid)
fieldset.add_field([P1, P2], name='P')
assert np.allclose(fieldset.P[0, 0, 0, 0], 50)
if with_W:
W1 = Field('W1',
2 * np.ones(
(zdim * gf, ydim * gf, xdim * gf), dtype=np.float32),
grid=U1.grid)
W2 = Field('W2',
np.ones((zdim, ydim, xdim), dtype=np.float32),
grid=U2.grid)
fieldset.add_field([W1, W2], name='W')
pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0], lat=[0.9])
pset.execute(AdvectionRK4_3D + pset.Kernel(k_sample_p),
runtime=2,
dt=1)
assert np.isclose(pset[0].depth, 6)
else:
pset = ParticleSet(fieldset, pclass=pclass(mode), lon=[0], lat=[0.9])
pset.execute(AdvectionRK4 + pset.Kernel(k_sample_p), runtime=2, dt=1)
assert np.isclose(pset[0].p, 50)
assert np.isclose(pset[0].lon * conv, 0.6, atol=1e-3)
assert np.isclose(pset[0].lat, 0.9)
def run_hycom_cfsr_subset_monthly_release(
output_dir,
output_name,
time0,
lon0,
lat0,
start_date,
end_date,
windage=0.03,
input_dir_hycom=get_dir('hycom_input'),
input_dir_cfsr=get_dir('cfsr_input'),
indices_hycom=_get_io_indices_from_netcdf(),
indices_cfsr=_get_io_indices_from_netcdf(
input_path=get_dir('cfsr_indices_input')),
kh=10.,
interp_method='linear'):
# get paths
ncfiles_hycom = get_daily_ncfiles_in_time_range(input_dir_hycom,
start_date, end_date)
ncfiles_cfsr = get_daily_ncfiles_in_time_range(input_dir_cfsr, start_date,
end_date)
output_path = output_dir + output_name
# create fieldset
filenames_hycom = [input_dir_hycom + ncfile for ncfile in ncfiles_hycom]
filenames_cfsr = [input_dir_cfsr + ncfile for ncfile in ncfiles_cfsr]
variables_hycom = {'U': 'u', 'V': 'v'}
variables_cfsr = {'U': 'u', 'V': 'v'}
dimensions_hycom = {'lat': 'lat', 'lon': 'lon', 'time': 'time'}
dimensions_cfsr = {'lat': 'lat', 'lon': 'lon', 'time': 'time'}
fset_hycom = FieldSet.from_netcdf(filenames_hycom,
variables_hycom,
dimensions_hycom,
indices=indices_hycom)
fset_cfsr = FieldSet.from_netcdf(filenames_cfsr,
variables_cfsr,
dimensions_cfsr,
indices=indices_cfsr)
fset_cfsr.U.set_scaling_factor(windage)
fset_cfsr.V.set_scaling_factor(windage)
fset = FieldSet(U=fset_hycom.U + fset_cfsr.U, V=fset_hycom.V + fset_cfsr.V)
# add constant horizontal diffusivity (zero on land)
lm = LandMask.read_from_netcdf()
kh2D = kh * np.ones(lm.mask.shape)
kh2D[lm.mask.astype('bool')] = 0.0 # diffusion zero on land
kh2D_subset = kh2D[indices_hycom['lat'], :][:, indices_hycom['lon']]
fset.add_field(
Field('Kh_zonal',
data=kh2D_subset,
lon=fset_hycom.U.grid.lon,
lat=fset_hycom.U.grid.lat,
mesh='spherical',
interp_method=interp_method))
fset.add_field(
Field('Kh_meridional',
data=kh2D_subset,
lon=fset_hycom.U.grid.lon,
lat=fset_hycom.U.grid.lat,
mesh='spherical',
interp_method=interp_method))
# monthly release
pset = ParticleSet(fieldset=fset,
pclass=JITParticle,
lon=lon0,
lat=lat0,
time=time0)
# execute
run_time = timedelta(days=(end_date - start_date).days)
dt = timedelta(hours=1)
output_interval = 24
kernel = pset.Kernel(AdvectionRK4) + pset.Kernel(DiffusionUniformKh)
output_file = pset.ParticleFile(name=output_path,
outputdt=dt * output_interval)
pset.execute(kernel,
runtime=run_time,
dt=dt,
output_file=output_file,
verbose_progress=True,
recovery={ErrorCode.ErrorOutOfBounds: delete_particle})
interp_method='linear',
mesh='spherical',
allow_time_extrapolation=True)
# Normal away from coast (y component)
cnormy = Field.from_netcdf(fh['grid'],
variable='cnormy_rho',
dimensions={
'lon': 'lon_rho',
'lat': 'lat_rho'
},
interp_method='linear',
mesh='spherical',
allow_time_extrapolation=True)
fieldset.add_field(iso_psi)
fieldset.add_field(cdist)
fieldset.add_field(cnormx)
fieldset.add_field(cnormy)
fieldset.cnormx_rho.units = GeographicPolar()
fieldset.cnormy_rho.units = Geographic()
# ADD THE PERIODIC BOUNDARY
fieldset.add_constant('halo_west', -180.)
fieldset.add_constant('halo_east', 180.)
fieldset.add_periodic_halo(zonal=True)
# ADD MAXIMUM PARTICLE AGE (IF LIMITED AGE)
if param['max_age']:
fieldset.add_constant('max_age', param['max_age'] * 3600 * 24 * 365.25)
