def set_stokes(fieldset):
data_dir = '/projects/0/topios/hydrodynamic_data/WWIII/'
fnames = []
years = range(2000, 2005)
for y in years:
basepath = data_dir + str(y) + '/ww3.*_uss.nc'
fnames += sorted(glob(str(basepath)))
dimensionsU = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time'}
dimensionsV = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time'}
Uuss = Field.from_netcdf(fnames, ('Uuss', 'uuss'),
dimensionsU,
fieldtype='U',
allow_time_extrapolation=False)
Vuss = Field.from_netcdf(fnames, ('Vuss', 'vuss'),
dimensionsV,
fieldtype='V',
allow_time_extrapolation=False,
grid=Uuss.grid,
dataFiles=Uuss.dataFiles)
fieldset.add_field(Uuss)
fieldset.add_field(Vuss)
fieldset.Uuss.vmax = 5
fieldset.Vuss.vmax = 5
uv_uss = VectorField('UVuss', fieldset.Uuss, fieldset.Vuss)
fieldset.add_vector_field(uv_uss)
def Ratio_Test(dfile):
Field.from_netcdf(dfile,
dimensions={
'lon': 'nav_lon',
'lat': 'nav_lat',
'time': 'time_counter',
'data': 'TagDensity'
},
filenames=[dfile])
def simulate_parcels(source_url,
output_filename,
lat,
lon,
wind_drift_factor=0.0,
velocity_average=True,
duration=23):
"""
source_url: local file or list of local files with fielddata in NetCDF-format
output_filename: name of file in which to save calculated trajectory
lat, lon: initial coordinates of single drifter or lists with coordinates for multiple drifters
wind_drift_factor: fraction of wind-speed at which objects will be advected. Default is 0 (no direct wind-drift)
velocity_average: Boolean variable deciding whether averaged horisontal velocities or surface velocities will be used.
Default is average which is consistent with GPU Ocean
duration: duration of the simulation in hours. Default is 24 hours.
TODO: Add functionality to start drifters at a later time in the simulation like in GPU Ocean.
"""
filenames = {'U': source_url, 'V': source_url}
dimensions = {'lat': 'lat', 'lon': 'lon', 'time': 'time'}
if velocity_average:
variables = {'U': 'ubar', 'V': 'vbar'}
else:
variables = {'U': 'u', 'V': 'v'}
fieldset = FieldSet.from_netcdf(filenames,
variables,
dimensions,
interp_method='cgrid_velocity')
if wind_drift_factor:
Uwind = Field.from_netcdf(source_url, ('U', 'Uwind'),
dimensions,
field_chunksize='auto',
interp_method='cgrid_velocity')
Vwind = Field.from_netcdf(source_url, ('V', 'Vwind'),
dimensions,
field_chunksize='auto',
interp_method='cgrid_velocity')
Uwind.set_scaling_factor(wind_drift_factor)
Vwind.set_scaling_factor(wind_drift_factor)
fieldset = FieldSet(U=fieldset.U + Uwind, V=fieldset.V + Vwind)
pset = ParticleSet.from_list(fieldset=fieldset,
pclass=JITParticle,
lon=lon,
lat=lat)
output_file = pset.ParticleFile(name=output_filename,
outputdt=timedelta(minutes=5))
pset.execute(AdvectionRK4,
runtime=timedelta(hours=duration),
dt=timedelta(minutes=5),
output_file=output_file)
output_file.export()
def set_skimulator_fieldset():
filenames = '/projects/0/topios/hydrodynamic_data/SKIMulator/scisoc_trpac?.nc'
variables = {'U': 'Ux_skim', 'V': 'Uy_skim'}
dimensions = {'lat': 'lat', 'lon': 'lon', 'time': 'time'}
fset = FieldSet.from_netcdf(filenames, variables, dimensions)
fset.add_field(Field.from_netcdf('skimulator_boundaryvelocities.nc', 'MaskUvel',
{'lon': 'Longitude', 'lat': 'Latitude'}, fieldtype='U'))
fset.add_field(Field.from_netcdf('skimulator_boundaryvelocities.nc', 'MaskVvel',
{'lon': 'Longitude', 'lat': 'Latitude'}, fieldtype='V'))
return fset
def set_cmems_surface_fieldset():
fnames = '/projects/0/topios/hydrodynamic_data/GLOBAL_ANALYSIS_FORECAST_PHY_001_024/cmems*'
filenames = {'U': fnames + 'uo.nc', 'V': fnames + 'vo.nc'}
variables = {'U': 'uo', 'V': 'vo'}
dimensions = {'lat': 'latitude', 'lon': 'longitude', 'time': 'time'}
fset = FieldSet.from_netcdf(filenames, variables, dimensions)
fset.add_field(Field.from_netcdf('cmems_boundaryvelocities.nc', 'MaskUvel',
{'lon': 'Longitude', 'lat': 'Latitude'}, fieldtype='U'))
fset.add_field(Field.from_netcdf('cmems_boundaryvelocities.nc', 'MaskVvel',
{'lon': 'Longitude', 'lat': 'Latitude'}, fieldtype='V'))
return fset
def get_wind_MERCATOR(fieldset,
path,
start_date=0,
finish_date=-1,
chunksize=False):
fdir = sorted(glob(path + '*.nc'))
len_path = len(path)
if type(start_date) == datetime:
start_date = start_date.strftime("%Y%m%d")
finish_date = finish_date.strftime("%Y%m%d")
for i, e in enumerate(fdir):
if e.find(str(start_date), len_path) > 0:
start_index = i
elif e.find(str(finish_date), len_path) > 0:
finish_index = i
if start_date > finish_date:
filenames = {
'uwnd': fdir[finish_index:start_index + 1],
'vwnd': fdir[finish_index:start_index + 1]
}
else:
filenames = {
'uwnd': fdir[start_index:finish_index + 1],
'vwnd': fdir[start_index:finish_index + 1]
}
variables = {'uwnd': 'uwnd', 'vwnd': 'vwnd'}
dimensions = {'time': 'time', 'lat': 'latitude', 'lon': 'longitude'}
Uwnd = Field.from_netcdf(filenames['uwnd'],
variables['uwnd'],
dimensions,
fieldtype='U',
vmax=150,
vmin=-150,
allow_time_extrapolation=False,
field_chunksize=chunksize)
Vwnd = Field.from_netcdf(filenames['vwnd'],
variables['vwnd'],
dimensions,
fieldtype='V',
vmax=150,
vmin=-150,
grid=Uwnd.grid,
dataFiles=Uwnd.dataFiles,
allow_time_extrapolation=False,
field_chunksize=chunksize)
fieldset.add_field(Uwnd, 'uwnd')
fieldset.add_field(Vwnd, 'vwnd')
UV_wnd = VectorField('UV_wnd', fieldset.uwnd, fieldset.vwnd)
fieldset.add_vector_field(UV_wnd)
return fieldset
def get_stokes_MERCATOR(fieldset,
path,
start_date=0,
finish_date=-1,
chunksize=False):
fdir = sorted(glob(path + '*.nc'))
len_path = len(path)
if type(start_date) == datetime:
start_date = start_date.strftime("%Y%m%d")
finish_date = finish_date.strftime("%Y%m%d")
for i, e in enumerate(fdir):
if e.find(str(start_date), len_path) > 0:
start_index = i
elif e.find(str(finish_date), len_path) > 0:
finish_index = i
if start_date > finish_date:
filenames = {
'U': fdir[finish_index:start_index + 1],
'V': fdir[finish_index:start_index + 1]
}
else:
filenames = {
'U': fdir[start_index:finish_index + 1],
'V': fdir[start_index:finish_index + 1]
}
variables = {'U': 'uuss', 'V': 'vuss'}
dimensions = {'lat': 'latitude', 'lon': 'longitude', 'time': 'time'}
Ustokes = Field.from_netcdf(filenames['U'],
variables['U'],
dimensions,
fieldtype='U',
vmax=2,
vmin=-2,
allow_time_extrapolation=False,
field_chunksize=chunksize)
Vstokes = Field.from_netcdf(filenames['V'],
variables['V'],
dimensions,
fieldtype='V',
vmax=2,
vmin=-2,
grid=Ustokes.grid,
dataFiles=Ustokes.dataFiles,
allow_time_extrapolation=False,
field_chunksize=chunksize)
fieldset.add_field(Ustokes, 'uuss')
fieldset.add_field(Vstokes, 'vuss')
UV_Stokes = VectorField('UV_Stokes', fieldset.uuss, fieldset.vuss)
fieldset.add_vector_field(UV_Stokes)
return fieldset
def set_cmems(fieldset):
data_dir = '/projects/0/topios/hydrodynamic_data/CMEMS/NORTHWESTSHELF_REANALYSIS_PHYS_004_009/MetO-NWS-REAN-PHYS-daily-CUR/'
fnames = []
years = range(2000, 2005)
for y in years:
basepath = data_dir + str(
y) + '/*/' + 'metoffice_foam1_amm7_NWS_RFVL_dm*.nc'
fnames += sorted(glob(str(basepath)))
dimensionsU = {'lon': 'lon', 'lat': 'lat', 'time': 'time'}
dimensionsV = {'lon': 'lon', 'lat': 'lat', 'time': 'time'}
indices = {
'lon': range(1, 296),
'lat': range(1, 374)
} # cmems puts nan values at its borders
Ucmems = Field.from_netcdf(fnames, ('Ucmems', 'vozocrtx'),
dimensionsU,
fieldtype='U',
indices=indices,
allow_time_extrapolation=False)
Vcmems = Field.from_netcdf(fnames, ('Vcmems', 'vomecrty'),
dimensionsV,
fieldtype='V',
indices=indices,
allow_time_extrapolation=False,
grid=Ucmems.grid,
dataFiles=Ucmems.dataFiles)
fieldset.add_field(Ucmems)
fieldset.add_field(Vcmems)
fieldset.Ucmems.vmax = 5
fieldset.Vcmems.vmax = 5
fieldset.Unemo = fieldset.U
fieldset.Unemo.name = 'Unemo'
fieldset.Vnemo = fieldset.V
fieldset.Vnemo.name = 'Vnemo'
U = NestedField('U', [fieldset.Ucmems, fieldset.Unemo])
V = NestedField('V', [fieldset.Vcmems, fieldset.Vnemo])
fieldset.U = U
fieldset.V = V
fieldset.cmems = True
def set_unbeaching(fieldset):
files = '/home/philippe/data/ORCA%s-N06_unbeaching_vel.nc' % fieldset.nemo_res
filenames = files
variables = {'Unemo_unbeach': 'unBeachU', 'Vnemo_unbeach': 'unBeachV'}
dimensions = {'lon': 'glamf', 'lat': 'gphif'}
fieldsetUnBeach = FieldSet.from_nemo(filenames,
variables,
dimensions,
tracer_interp_method='cgrid_velocity')
fieldset.add_field(fieldsetUnBeach.Unemo_unbeach)
fieldset.add_field(fieldsetUnBeach.Vnemo_unbeach)
if fieldset.cmems:
fname = '/home/philippe/data/cmems_NWS_rean_004_009_unbeaching_vel.nc'
dimensionsU = {'lon': 'lon', 'lat': 'lat'}
Ucmems_unbeach = Field.from_netcdf(fname,
('Ucmems_unbeach', 'unBeachU'),
dimensionsU,
fieldtype='U')
dimensionsV = {'lon': 'lon', 'lat': 'lat'}
Vcmems_unbeach = Field.from_netcdf(fname,
('Vcmems_unbeach', 'unBeachV'),
dimensionsV,
fieldtype='V')
fieldset.add_field(Ucmems_unbeach)
fieldset.add_field(Vcmems_unbeach)
UVnemo_unbeach = VectorField('UVnemo_unbeach', fieldset.Unemo_unbeach,
fieldset.Vnemo_unbeach)
UVcmems_unbeach = VectorField('UVcmems_unbeach',
fieldset.Ucmems_unbeach,
fieldset.Vcmems_unbeach)
UVunbeach = NestedField('UVunbeach', [UVcmems_unbeach, UVnemo_unbeach])
fieldset.add_vector_field(UVunbeach)
else:
UVunbeach = VectorField('UVunbeach', fieldset.Unemo_unbeach,
fieldset.Vnemo_unbeach)
fieldset.add_vector_field(UVunbeach)
def calculateDensityRatio(dfiles, output):
Fields = []
for dfile in dfiles:
print("Loading %s" % dfile)
Fields.append(Field.from_netcdf(dfile,
dimensions={'lon': 'nav_lon', 'lat': 'nav_lat', 'time': 'time_counter', 'data': 'TagDensity'},
filenames=[dfile]))
limits = [0, 0, 0, 0]
limits[0] = np.max([field.lon[0] for field in Fields])
limits[1] = np.min([field.lon[-1] for field in Fields])
limits[2] = np.max([field.lat[0] for field in Fields])
limits[3] = np.min([field.lat[-1] for field in Fields])
#limits[1] = (np.min(field.lon[-1]) for field in Fields)
#limits[2] = (np.max(field.lat[0]) for field in Fields)
#limits[3] = (np.min(field.lat[-1]) for field in Fields)
time_lim = [np.max([field.time[0] for field in Fields]), np.min([field.time[-1] for field in Fields])]
#time_lim = [Fields[0].time[0], Fields[0].time[-1]]
lon = np.arange(start=limits[0], stop=limits[1]+1, dtype=np.float32)
lat = np.arange(start=limits[2], stop=limits[3]+1, dtype=np.float32)
time = np.arange(time_lim[0], time_lim[1]+1, 30*24*60*60, dtype=np.float32)
Ratio = np.zeros([len(time), len(lat), len(lon)], dtype=np.float32)
print(limits)
print(Fields[0].lon)
print(Fields[1].lon)
print(lon)
print(Fields[0].lat)
print(Fields[1].lat)
print(lat)
print(Fields[0].time)
print(Fields[1].time)
print(time)
for t in range(len(time)):
for x in range(len(lon)):
for y in range(len(lat)):
tagged = Fields[0].data[np.where(Fields[0].time == time[t])[0][0],
np.where(Fields[0].lat == lat[y])[0][0],
np.where(Fields[0].lon == lon[x])[0][0]]
pop = Fields[1].data[np.where(Fields[1].time == time[t])[0][0],
np.where(Fields[1].lat == lat[y])[0][0],
np.where(Fields[1].lon == lon[x])[0][0]]
#print('%s - %s' % (tagged, pop))
if pop == 0:
Ratio[t, y, x] = 0
else:
Ratio[t, y, x] = tagged/pop
Ratios = Field('DensityRatio', Ratio, lon, lat, time=time)
Ratios.write(filename=output)
def run_particles(fieldsetname):
if fieldsetname == 'cmems_surface':
fieldset = set_cmems_surface_fieldset()
elif fieldsetname == 'cmems_50m':
fieldset = set_cmems_50m_fieldset()
dz = np.gradient(fieldset.U.depth)
DZ = np.moveaxis(np.tile(dz, (fieldset.U.grid.ydim, fieldset.U.grid.xdim+10, 1)), [0, 1, 2], [1, 2, 0])
def compute(fieldset):
# Calculating vertical weighted average
for f in [fieldset.U, fieldset.V]:
for tind in f.loaded_time_indices:
f.data[tind, :] = np.sum(f.data[tind, :] * DZ, axis=0) / sum(dz)
fieldset.compute_on_defer = compute
elif fieldsetname == 'skimulator':
# requires ncatted -a units,time,o,c,"days since 2016-01-01 00:00:00" scisoc_trpac_compressed.nc for decode_cf
fieldset = set_skimulator_fieldset()
else:
raise NotImplementedError('FieldSet %s not implemented')
fieldset.add_constant('max_drift_time', delta(days=180).total_seconds())
size2D = (fieldset.U.grid.ydim, fieldset.U.grid.xdim)
fieldset.add_field(Field('Kh_zonal', data=10*np.ones(size2D),
lon=fieldset.U.grid.lon, lat=fieldset.U.grid.lat,
mesh='spherical', allow_time_extrapolation=True))
fieldset.add_field(Field('Kh_meridional', data=10*np.ones(size2D),
lon=fieldset.U.grid.lon, lat=fieldset.U.grid.lat,
mesh='spherical', allow_time_extrapolation=True))
fieldset.add_periodic_halo(zonal=True, meridional=False, halosize=5)
fieldset.add_field(Field.from_netcdf('EEZ_Field.nc', 'EEZ',
{'lon': 'lon', 'lat': 'lat'},
allow_time_extrapolation=True))
pset = createFADset(fieldset, 'dFADsets.txt', nperid=10)
pset.execute(SampleEEZ, dt=-1, runtime=0) # setting the EEZ
ofile = pset.ParticleFile(name='fadtracks_antibeaching_%s' % fieldsetname,
outputdt=delta(days=5))
kernels = WrapLon + pset.Kernel(AdvectionRK4) + BrownianMotion2D + AntiBeaching + \
SampleEEZ + DriftTime
pset.execute(kernels, dt=delta(minutes=-10), output_file=ofile,
recovery={ErrorCode.ErrorOutOfBounds: OutOfBounds})
def set_diffusion(fieldset, diffusivity):
fname = '/home/philippe/data/ORCA0083-N06_meshSize.nc'
dimensions = {'lon': 'glamt', 'lat': 'gphit'}
meshSize = Field.from_netcdf(fname,
'meshSize',
dimensions,
interp_method='nearest')
fieldset.add_field(meshSize)
fieldset.add_field(
Field('Kh_zonal',
data=diffusivity * np.ones(meshSize.data.shape),
grid=meshSize.grid,
mesh='spherical'))
fieldset.add_field(
Field('Kh_meridional',
data=diffusivity * np.ones(meshSize.data.shape),
grid=meshSize.grid,
mesh='spherical'))
def set_fields():
datestr = '201[0-2]'
hycomfiles = sorted(
glob(
'/Volumes/data01/HYCOMdata/GLBu0.08_expt_19.1_surf/hycom_GLBu0.08_191_%s*'
% datestr))
dimensions = {'lat': 'lat', 'lon': 'lon', 'time': 'time'}
uhycom = Field.from_netcdf(hycomfiles,
'water_u',
dimensions,
fieldtype='U')
vhycom = Field.from_netcdf(hycomfiles,
'water_v',
dimensions,
fieldtype='V',
grid=uhycom.grid,
dataFiles=uhycom.dataFiles)
uhycom.vmin = -99.
uhycom.set_scaling_factor(0.001)
vhycom.set_scaling_factor(0.001)
vhycom.vmin = -99.
stokesfiles = sorted(
glob('/Volumes/data01/WaveWatch3data/WW3-GLOB-30M_%s*' % datestr))
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,
dataFiles=uuss.dataFiles)
windfiles = sorted(
glob('/Users/erik/Desktop/WaveWatchWind/WaveWatchWind*.nc'))
dimensions = {'lat': 'latitude', 'lon': 'longitude', 'time': 'time'}
uwnd = Field.from_netcdf(windfiles, 'uwnd', dimensions, fieldtype='U')
vwnd = Field.from_netcdf(windfiles,
'vwnd',
dimensions,
fieldtype='V',
grid=uwnd.grid,
dataFiles=uwnd.dataFiles)
uwnd.set_scaling_factor(0.01)
vwnd.set_scaling_factor(0.01)
fieldset = FieldSet(U=uhycom + uuss + uwnd, V=vhycom + vuss + vwnd)
fieldset.add_periodic_halo(zonal=True, meridional=False, halosize=5)
return fieldset
def test_globcurrent_startparticles_between_time_arrays(
mode, dt, with_starttime):
fieldset = set_globcurrent_fieldset()
fnamesFeb = sorted(
glob(
path.join(path.dirname(__file__), 'GlobCurrent_example_data',
'200202*.nc')))
fieldset.add_field(
Field.from_netcdf(fnamesFeb,
('P', 'eastward_eulerian_current_velocity'), {
'lat': 'lat',
'lon': 'lon',
'time': 'time'
}))
class MyParticle(ptype[mode]):
sample_var = Variable('sample_var', initial=0.)
def SampleP(particle, fieldset, time):
particle.sample_var += fieldset.P[time, particle.depth, particle.lat,
particle.lon]
if with_starttime:
time = fieldset.U.grid.time[0] if dt > 0 else fieldset.U.grid.time[-1]
pset = ParticleSet(fieldset,
pclass=MyParticle,
lon=[25],
lat=[-35],
time=time)
else:
pset = ParticleSet(fieldset, pclass=MyParticle, lon=[25], lat=[-35])
if with_starttime:
with pytest.raises(TimeExtrapolationError):
pset.execute(pset.Kernel(AdvectionRK4) + SampleP,
runtime=delta(days=1),
dt=dt)
else:
pset.execute(pset.Kernel(AdvectionRK4) + SampleP,
runtime=delta(days=1),
dt=dt)
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
if param['windage']:
fieldset = FieldSet(U=fieldset_ocean.U + fieldset_windwave.U,
V=fieldset_ocean.V + fieldset_windwave.V)
elif param['stokes']:
fieldset = FieldSet(U=fieldset_ocean.U + fieldset_wave.U,
V=fieldset_ocean.V + fieldset_wave.V)
else:
fieldset = fieldset_ocean
# ADD ADDITIONAL FIELDS
# Country identifier grid (on psi grid, nearest)
iso_psi_all = Field.from_netcdf(fh['grid'],
variable='iso_psi_all',
dimensions={
'lon': 'lon_psi',
'lat': 'lat_psi'
},
interp_method='nearest',
allow_time_extrapolation=True)
# Source cell ID (on psi grid, nearest)
source_id_psi = Field.from_netcdf(fh['grid'],
variable='source_id_psi',
dimensions={
'lon': 'lon_psi',
'lat': 'lat_psi'
},
interp_method='nearest',
allow_time_extrapolation=True)
# Sink cell ID (on psi grid, nearest)
@author: nooteboom
"""
import numpy as np
import matplotlib.pylab as plt
import matplotlib
from netCDF4 import Dataset
import math
from parcels import Field
filename = 'bathymetry_ORCA12_V3.3.nc'
Bath = Field.from_netcdf(filename,
variable='Bathymetry',
dimensions={
'lon': 'nav_lon',
'lat': 'nav_lat'
})
#Bath.grid.check_zonal_periodic()
# True if surface instead of amount of surface grid boxes
surfacebool = True
ddeg = 2 # resolution of the binning
sp = 6
dd = 10
res = 1
tmdir = '/Users/nooteboom/Documents/PhD/parcels/NEMO/atsf/Transition_matrices/'
data = np.load(tmdir + 'output/box-box/TMglobal_bin' + str(ddeg) + '_dd' +
def Ratio_Test(dfile):
Field.from_netcdf(dfile, dimensions={'lon': 'nav_lon', 'lat': 'nav_lat', 'time': 'time_counter', 'data': 'TagDensity'},
filenames=[dfile])
def calculateDensityRatio(dfiles, output):
Fields = []
for dfile in dfiles:
print("Loading %s" % dfile)
Fields.append(
Field.from_netcdf(dfile,
dimensions={
'lon': 'nav_lon',
'lat': 'nav_lat',
'time': 'time_counter',
'data': 'TagDensity'
},
filenames=[dfile]))
limits = [0, 0, 0, 0]
limits[0] = np.max([field.lon[0] for field in Fields])
limits[1] = np.min([field.lon[-1] for field in Fields])
limits[2] = np.max([field.lat[0] for field in Fields])
limits[3] = np.min([field.lat[-1] for field in Fields])
#limits[1] = (np.min(field.lon[-1]) for field in Fields)
#limits[2] = (np.max(field.lat[0]) for field in Fields)
#limits[3] = (np.min(field.lat[-1]) for field in Fields)
time_lim = [
np.max([field.time[0] for field in Fields]),
np.min([field.time[-1] for field in Fields])
]
#time_lim = [Fields[0].time[0], Fields[0].time[-1]]
lon = np.arange(start=limits[0], stop=limits[1] + 1, dtype=np.float32)
lat = np.arange(start=limits[2], stop=limits[3] + 1, dtype=np.float32)
time = np.arange(time_lim[0],
time_lim[1] + 1,
30 * 24 * 60 * 60,
dtype=np.float32)
Ratio = np.zeros([len(time), len(lat), len(lon)], dtype=np.float32)
print(limits)
print(Fields[0].lon)
print(Fields[1].lon)
print(lon)
print(Fields[0].lat)
print(Fields[1].lat)
print(lat)
print(Fields[0].time)
print(Fields[1].time)
print(time)
for t in range(len(time)):
for x in range(len(lon)):
for y in range(len(lat)):
tagged = Fields[0].data[np.where(
Fields[0].time == time[t])[0][0],
np.where(
Fields[0].lat == lat[y])[0][0],
np.where(
Fields[0].lon == lon[x])[0][0]]
pop = Fields[1].data[np.where(Fields[1].time == time[t])[0][0],
np.where(Fields[1].lat == lat[y])[0][0],
np.where(Fields[1].lon == lon[x])[0][0]]
#print('%s - %s' % (tagged, pop))
if pop == 0:
Ratio[t, y, x] = 0
else:
Ratio[t, y, x] = tagged / pop
Ratios = Field('DensityRatio', Ratio, lon, lat, time=time)
Ratios.write(filename=output)
def create(startDate,
days,
lonRange=(-180, 180),
latRange=(55, 90),
antiBeach=True,
halo=False,
**kwargs):
"""
Creates a parcels.FieldSet object from hydrodynamic data in a netCDF file.
Parameters
----------
startDate : str, int
String or int indicating the first date to load (YYYYMMDD)
days : int
Number of days to load
antiBeach : bool
Load anti-beach field
halo : bool
Add a periodic halo
Returns
----------
parcels.FieldSet
"""
readDir = "/data/oceanparcels/input_data/CMEMS/GLOBAL_REANALYSIS_PHY_001_030/"
fieldFiles = sorted(glob(readDir + "mercatorglorys12v1_gl12_mean_*.nc"))
unBeachFile = "mercatorglorys12v1_gl12_unbeaching_vel.nc"
startFile = glob(readDir +
f"mercatorglorys12v1_gl12_mean_{startDate}_*.nc")
assert len(startFile) == 1, "No file found for this `start_date`."
startFileIndex = fieldFiles.index(startFile[0])
endFileIndex = startFileIndex + days
if endFileIndex >= len(fieldFiles) - 1:
days = len(fieldFiles) - startFileIndex - 1
endFileIndex = len(fieldFiles) - 1
warnings.warn("\n Timespan of simulation exceeds the amount of data that is available. " \
+"Reducing the amount of `days` to " + str(days) +".")
selectedFiles = fieldFiles[startFileIndex:endFileIndex]
variables = {'U': 'uo', 'V': 'vo'}
dimensions = {
'U': {
'time': 'time',
'lat': 'latitude',
'lon': 'longitude'
},
'V': {
'time': 'time',
'lat': 'latitude',
'lon': 'longitude'
}
}
mesh = fieldFiles[0]
filenames = {
'U': {
'lon': mesh,
'lat': mesh,
'data': selectedFiles
},
'V': {
'lon': mesh,
'lat': mesh,
'data': selectedFiles
}
}
ds = xr.open_dataset(fieldFiles[0])
minLonIdx = np.searchsorted(ds.longitude, lonRange[0])
maxLonIdx = np.searchsorted(ds.longitude, lonRange[1])
minLatIdx = np.searchsorted(ds.latitude, latRange[0])
maxLatIdx = np.searchsorted(ds.latitude, latRange[1])
indices = {
'lon': range(minLonIdx, maxLonIdx),
'lat': range(minLatIdx, maxLatIdx)
}
fieldset = FieldSet.from_netcdf(
selectedFiles,
variables,
dimensions,
indices=indices,
allow_time_extrapolation=False,
)
if antiBeach:
dimensions = {'lon': 'longitude', 'lat': 'latitude'}
U_unbeach = Field.from_netcdf(readDir + unBeachFile,
('U_unbeach', 'unBeachU'),
dimensions,
fieldtype='U')
V_unbeach = Field.from_netcdf(readDir + unBeachFile,
('V_unbeach', 'unBeachV'),
dimensions,
fieldtype='V')
fieldset.add_field(U_unbeach)
fieldset.add_field(V_unbeach)
UVunbeach = VectorField('UVunbeach', fieldset.U_unbeach,
fieldset.V_unbeach)
fieldset.add_vector_field(UVunbeach)
if halo:
fieldset.add_periodic_halo(zonal=True)
fieldset.computeTimeChunk(fieldset.U.grid.time[0], 1)
fieldset.landMask = np.isnan(ds.uo[0, 0, minLatIdx:maxLatIdx,
minLonIdx:maxLonIdx].data)
ds.close()
return fieldset
def create_fieldset(param, ndays_simu, t_init):
"""
Build fieldset from data files, dimensions and variables.
"""
print('****************************************************')
print("Building FieldSet...")
print('****************************************************')
t0 = time.time()
key_alltracers = param['key_alltracers']
mesh_phy = param['mesh_phy']
mesh_food = param['mesh_food']
#Forcings
last_date = IO.find_last_date(param)
date_start, date_end, time_periodic = IO.define_start_end(
ndays_simu, param, t_init, last_date)
ufiles = IO.forcing_list(param['U_dir'], param['U_suffix'], date_start,
date_end)
vfiles = IO.forcing_list(param['V_dir'], param['V_suffix'], date_start,
date_end)
#Filenames
filenames = {
'U': {
'lon': mesh_phy,
'lat': mesh_phy,
'data': ufiles
},
'V': {
'lon': mesh_phy,
'lat': mesh_phy,
'data': vfiles
}
}
#Variables
variables = {'U': param['U_var'], 'V': param['V_var']}
#Dimensions: Caution, C-grids need f nodes
dimensions = {
'U': {
'lon': param['lon_phy'],
'lat': param['lat_phy'],
'time': param['time_var_phy']
},
'V': {
'lon': param['lon_phy'],
'lat': param['lat_phy'],
'time': param['time_var_phy']
}
}
if time_periodic:
time_periodic *= 86400 #days to seconds
#Fieldset creation
chs = define_chunksize(ufiles[0], param['U_var'])
if param['grid_phy'] == 'A':
fieldset = FieldSet.from_netcdf(filenames,
variables,
dimensions,
time_periodic=time_periodic,
field_chunksize=chs)
else:
fieldset = FieldSet.from_c_grid_dataset(filenames,
variables,
dimensions,
time_periodic=time_periodic,
field_chunksize=chs)
if key_alltracers:
tfiles = IO.forcing_list(param['T_dir'], param['T_suffix'], date_start,
date_end)
ffiles = IO.forcing_list(param['food_dir'], param['food_suffix'],
date_start, date_end)
# Filenames
Tfiles = {'lon': mesh_phy, 'lat': mesh_phy, 'data': tfiles}
NPPfiles = {'lon': mesh_food, 'lat': mesh_food, 'data': ffiles}
# Dimensions
if param['grid_phy'] == 'A':
Tdim = {
'lon': param['lon_phy'],
'lat': param['lat_phy'],
'time': param['time_var_phy']
}
else:
Tdim = {
'lon': param['lon_T'],
'lat': param['lat_T'],
'time': param['time_var_phy']
}
NPPdim = {
'lon': param['lon_food'],
'lat': param['lat_food'],
'time': param['time_var_food']
}
# Field creation
T = Field.from_netcdf(Tfiles, ('T', param['T_var']),
Tdim,
interp_method='linear_invdist_land_tracer',
time_periodic=time_periodic,
field_chunksize=chs)
NPP = Field.from_netcdf(NPPfiles, ('NPP', param['food_var']),
NPPdim,
interp_method='linear_invdist_land_tracer',
time_periodic=time_periodic,
field_chunksize='auto')
# Waves: physical grid, A-grid
if param['wave_swim']:
st_files = IO.forcing_list(param['wave_dir'], param['wave_suffix'],
date_start, date_end)
Stokes_files = {'lon': mesh_phy, 'lat': mesh_phy, 'data': st_files}
Stokes_dim = {
'lon': param['lon_phy'],
'lat': param['lat_phy'],
'time': param['time_var_phy']
}
Ustokes = Field.from_netcdf(
Stokes_files, ('Ustokes', param['Ust_var']),
Stokes_dim,
interp_method='linear_invdist_land_tracer',
time_periodic=time_periodic,
field_chunksize=chs)
Vstokes = Field.from_netcdf(
Stokes_files, ('Vstokes', param['Vst_var']),
Stokes_dim,
interp_method='linear_invdist_land_tracer',
time_periodic=time_periodic,
field_chunksize=chs)
fieldset.add_field(Ustokes)
fieldset.add_field(Vstokes)
# Add to fieldset
fieldset.add_field(T)
fieldset.add_field(NPP)
# East/West periodicity
if param['periodicBC'] and not param['halo']:
add_halo(fieldset)
# Time
tt = time.time() - t0
print('\n')
print(' => FieldSet created in: ' + str(timedelta(seconds=int(tt))))
print('\n')
return fieldset
files_eastward = "/science/projects/oceanparcels/input_data/DataPlasticTides/FES/eastward_velocity/"
files_northward = "/science/projects/oceanparcels/input_data/DataPlasticTides/FES/northward_velocity/"
dimensions_Ua = {'data': 'Ua', 'lat': 'lat', 'lon': 'lon'}
dimensions_Ug = {'data': 'Ug', 'lat': 'lat', 'lon': 'lon'}
dimensions_Va = {'data': 'Va', 'lat': 'lat', 'lon': 'lon'}
dimensions_Vg = {'data': 'Vg', 'lat': 'lat', 'lon': 'lon'}
deg2rad = math.pi / 180.0 # factor to convert degrees to radians
""" --- M2 component --- """
filename_UM2 = files_eastward + 'm2.nc'
filename_VM2 = files_northward + 'm2.nc'
UaM2 = Field.from_netcdf(filename_UM2, 'UaM2', dimensions_Ua, fieldtype='U')
UaM2.set_scaling_factor(1e-2) # convert from cm/s to m/s
UgM2 = Field.from_netcdf(filename_UM2, 'UgM2', dimensions_Ug)
UgM2.set_scaling_factor(deg2rad) # convert from degrees to radians
VaM2 = Field.from_netcdf(filename_VM2, 'VaM2', dimensions_Va, fieldtype='V')
VaM2.set_scaling_factor(1e-2)
VgM2 = Field.from_netcdf(filename_VM2, 'VgM2', dimensions_Vg)
VgM2.set_scaling_factor(deg2rad)
fieldset.add_field(UaM2)
fieldset.add_field(UgM2)
fieldset.add_field(VaM2)
fieldset.add_field(VgM2)
omega_M2 = 28.9841042 # angular frequency of M2 in degrees per hour
fieldset.add_constant('omegaM2', (omega_M2 * deg2rad) /
def plotTrajectoriesFile(filename,
mode='2d',
tracerfile=None,
tracerfield='P',
tracerlon='x',
tracerlat='y',
recordedvar=None,
movie_forward=True,
bins=20,
show_plt=True,
central_longitude=0):
"""Quick and simple plotting of Parcels trajectories
:param filename: Name of Parcels-generated NetCDF file with particle positions
:param mode: Type of plot to show. Supported are '2d', '3d', 'hist2d',
'movie2d' and 'movie2d_notebook'. The latter two give animations,
with 'movie2d_notebook' specifically designed for jupyter notebooks
:param tracerfile: Name of NetCDF file to show as background
:param tracerfield: Name of variable to show as background
:param tracerlon: Name of longitude dimension of variable to show as background
:param tracerlat: Name of latitude dimension of variable to show as background
:param recordedvar: Name of variable used to color particles in scatter-plot.
Only works in 'movie2d' or 'movie2d_notebook' mode.
:param movie_forward: Boolean whether to show movie in forward or backward mode (default True)
:param bins: Number of bins to use in `hist2d` mode. See also https://matplotlib.org/api/_as_gen/matplotlib.pyplot.hist2d.html
:param show_plt: Boolean whether plot should directly be show (for py.test)
:param central_longitude: Degrees East at which to center the plot
"""
environ["HDF5_USE_FILE_LOCKING"] = "FALSE"
try:
pfile = xr.open_dataset(str(filename), decode_cf=True)
except:
pfile = xr.open_dataset(str(filename), decode_cf=False)
lon = np.ma.filled(pfile.variables['lon'], np.nan)
lat = np.ma.filled(pfile.variables['lat'], np.nan)
time = np.ma.filled(pfile.variables['time'], np.nan)
z = np.ma.filled(pfile.variables['z'], np.nan)
mesh = pfile.attrs[
'parcels_mesh'] if 'parcels_mesh' in pfile.attrs else 'spherical'
if (recordedvar is not None):
record = np.ma.filled(pfile.variables[recordedvar], np.nan)
pfile.close()
if tracerfile is not None and mode != 'hist2d':
tracerfld = Field.from_netcdf(tracerfile, tracerfield, {
'lon': tracerlon,
'lat': tracerlat
})
plt, fig, ax, cartopy = plotfield(tracerfld)
if plt is None:
return # creating axes was not possible
titlestr = ' and ' + tracerfield
else:
spherical = False if mode == '3d' or mesh == 'flat' else True
plt, fig, ax, cartopy = create_parcelsfig_axis(
spherical=spherical, central_longitude=central_longitude)
if plt is None:
return # creating axes was not possible
titlestr = ''
if cartopy:
for p in range(lon.shape[1]):
lon[:, p] = [ln if ln < 180 else ln - 360 for ln in lon[:, p]]
if mode == '3d':
from mpl_toolkits.mplot3d import Axes3D # noqa
plt.clf() # clear the figure
ax = fig.gca(projection='3d')
for p in range(len(lon)):
ax.plot(lon[p, :], lat[p, :], z[p, :], '.-')
ax.set_xlabel('Longitude')
ax.set_ylabel('Latitude')
ax.set_zlabel('Depth')
ax.set_title('Particle trajectories')
elif mode == '2d':
if cartopy:
ax.plot(np.transpose(lon),
np.transpose(lat),
'.-',
transform=cartopy.crs.Geodetic())
else:
ax.plot(np.transpose(lon), np.transpose(lat), '.-')
ax.set_title('Particle trajectories' + titlestr)
elif mode == 'hist2d':
_, _, _, cs = plt.hist2d(lon[~np.isnan(lon)],
lat[~np.isnan(lat)],
bins=bins)
cartopy_colorbar(cs, plt, fig, ax)
ax.set_title('Particle histogram')
elif mode in ('movie2d', 'movie2d_notebook'):
if mesh == 'flat':
ax.set_xlim(np.nanmin(lon), np.nanmax(lon))
else:
ax.set_xlim(np.nanmin((lon + central_longitude + 180) % 360 - 180),
np.nanmax((lon + central_longitude + 180) % 360 - 180))
ax.set_ylim(np.nanmin(lat), np.nanmax(lat))
plottimes = np.unique(time)
if not movie_forward:
plottimes = np.flip(plottimes, 0)
if isinstance(plottimes[0], (np.datetime64, np.timedelta64)):
plottimes = plottimes[~np.isnat(plottimes)]
else:
try:
plottimes = plottimes[~np.isnan(plottimes)]
except:
pass
b = time == plottimes[0]
def timestr(plottimes, index):
if isinstance(plottimes[index], np.timedelta64):
if plottimes[-1] > np.timedelta64(1, 'h'):
return str(plottimes[index].astype('timedelta64[h]'))
elif plottimes[-1] > np.timedelta64(1, 's'):
return str(plottimes[index].astype('timedelta64[s]'))
else:
return str(plottimes[index])
if cartopy:
scat = ax.scatter(lon[b],
lat[b],
s=20,
color='k',
transform=cartopy.crs.Geodetic())
else:
scat = ax.scatter(lon[b], lat[b], s=20, color='k')
ttl = ax.set_title('Particles' + titlestr + ' at time ' +
timestr(plottimes, 0))
frames = np.arange(0, len(plottimes))
def animate(t):
b = time == plottimes[t]
scat.set_offsets(np.vstack((lon[b], lat[b])).transpose())
ttl.set_text('Particle' + titlestr + ' at time ' +
timestr(plottimes, t))
if recordedvar is not None:
scat.set_array(record[b])
return scat,
rc('animation', html='html5')
anim = animation.FuncAnimation(fig,
animate,
frames=frames,
interval=100,
blit=False)
else:
raise RuntimeError('mode %s not known' % mode)
if mode == 'movie2d_notebook':
plt.close()
return anim
else:
if show_plt:
plt.show()
return plt
lons, lats = np.meshgrid(np.arange(0,360)+0.5,np.arange(27, 45)+0.5)
ind = {'lat':range(220, 350)}
elif(posidx==8):
lons, lats = np.meshgrid(np.arange(0,360)+0.5,np.arange(45, 62)+0.5)
ind = {'lat':range(270, 384)}
elif(posidx==9):
lons, lats = np.meshgrid(np.arange(0,360)+0.5,np.arange(62, 71)+0.5)
ind = {'lat':range(300, 384)}
# reshape longitudes and latitudes
lons = lons.flatten(); lats = lats.flatten();
lonsz = []; latsz = [];
lons[lons>320.01] -= 360
# Delete the particles on land
bathy = Field.from_netcdf([dirread_pop+'bathymetry_POP_lowres_320t384.nc'], 'Bathymetry',
{'lon':'ULONG','lat':'ULAT'}, interp_method='bgrid_tracer')
grid = bathy.grid
grid.add_periodic_halo(zonal=True, meridional=False, halosize=20)
bathy.grid = grid
bathy.add_periodic_halo(zonal=True, meridional=False, halosize=20)
for i in range(lons.shape[0]):
if(bathy[0,0,lats[i], lons[i]]>0):
lonsz.append(lons[i])
latsz.append(lats[i])
# The boundary of the grid is at 320 degrees
lonsz = np.array(lonsz); latsz = np.array(latsz);
lonsz[lonsz>320.01] -= 360
