def test_reader_order(self):
# Check that we get the same output indepenently of reader order
o = OceanDrift(loglevel=50)
norkyst = reader_netCDF_CF_generic.Reader(o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
arome = reader_netCDF_CF_generic.Reader(o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/arome_subset_16Nov2015.nc')
landmask = reader_global_landmask.Reader(extent = [2, 59.8, 6, 61])
lon=4.; lat=60.
# First run
o.add_reader([landmask, norkyst, arome])
o.seed_elements(lon, lat, time=norkyst.start_time)
o.run(steps=30)
# Second run
# Check that we get almost identical results with other projection
o1 = OceanDrift(loglevel=50)
o1.add_reader([norkyst, arome, landmask])
o1.seed_elements(lon, lat, time=norkyst.start_time)
o1.run(steps=30)
np.testing.assert_array_almost_equal(
o.elements.lon, o1.elements.lon, 2)
np.testing.assert_array_almost_equal(
o.elements.lat, o1.elements.lat, 2)
# Third run
# Check that this is identical to run 1 if projection set equal
o2 = OceanDrift(loglevel=50)
o2.add_reader([norkyst, arome, landmask])
o2.seed_elements(lon, lat, time=norkyst.start_time)
o2.set_projection(landmask.proj4)
o2.run(steps=30)
np.testing.assert_array_almost_equal(
o.elements.lon, o2.elements.lon, decimal=3)
def test_stranding_options(self):
reader_osc = reader_oscillating.Reader('x_sea_water_velocity',
amplitude=1,
zero_time=datetime.now())
reader_global = reader_global_landmask.Reader()
# Three different stranding options, with
# expected final status and position
options = ['stranding', 'previous', 'none']
status = ['stranded', 'active', 'active']
lons = [12.930, 13.348, 12.444]
for i, option in enumerate(options):
o = OceanDrift(loglevel=00)
o.set_config('general:coastline_action', option)
o.add_reader([reader_osc, reader_global])
# Adding northwards drift
o.fallback_values['y_sea_water_velocity'] = .2
o.seed_elements(lon=12.2,
lat=67.7,
radius=0,
time=reader_osc.zero_time)
o.run(steps=28, time_step=3600 * 2)
#o.plot()
print('Testing stranding: %s' % option)
if len(o.elements) == 1:
el = o.elements
else:
el = o.elements_deactivated
# o.plot ()
self.assertEqual(o.status_categories[int(el.status)], status[i])
self.assertIsNone(
np.testing.assert_array_almost_equal(el.lon, lons[i], 2))
def test_openberg(self):
"""Check if weighting array is set correctly
and if model returns expected positions"""
o = OpenBerg()
o.set_config('drift:current_uncertainty', 0)
o.set_config('drift:wind_uncertainty', 0)
reader_current = reader_netCDF_CF_generic.Reader(
o.test_data_folder() +
'14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc')
reader_landmask = reader_global_landmask.Reader()
o.add_reader([reader_current, reader_landmask])
o.seed_elements(4., 62., time=reader_current.start_time)
o.run(steps=1)
arr = [
0.16072658, 0.16466097, 0.17384121, 0.17325179, 0.1715925,
0.15592695
]
for indx in range(len(arr)):
self.assertAlmostEqual(o.uw_weighting[indx], arr[indx], 8)
self.assertAlmostEqual(o.history['lon'].data[0][1], 3.9921231, 3)
self.assertAlmostEqual(o.history['lat'].data[0][1], 62.0108299, 3)
def test_buffer_length_stranding(self):
o1 = OceanDrift(loglevel=30)
norkyst = reader_netCDF_CF_generic.Reader(o1.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
landmask = reader_global_landmask.Reader(
llcrnrlon=4.5, llcrnrlat=60.1,
urcrnrlon=6.0, urcrnrlat=60.4)
o1.add_reader([landmask])
o1.fallback_values['x_sea_water_velocity'] = 0.8 # onshore drift
o1.seed_elements(4.8, 60.2, radius=5000, number=100,
time=norkyst.start_time)
o1.run(steps=100,
time_step=900,
time_step_output=3600,
export_buffer_length=10)
# Without buffer
o2 = OceanDrift(loglevel=30)
o2.add_reader([landmask])
o2.fallback_values['x_sea_water_velocity'] = 0.8 # onshore drift
o2.seed_elements(4.8, 60.2, radius=5000, number=100,
time=norkyst.start_time)
o2.run(steps=100,
time_step=900,
time_step_output=3600,
outfile='test_buffer_length_stranding.nc')
self.assertIsNone(np.testing.assert_array_equal(
o1.history['lon'].compressed(),
o2.history['lon'].compressed()))
self.assertIsNone(np.testing.assert_array_almost_equal(
o1.history['status'].compressed(),
o2.history['status'].compressed()))
os.remove('test_buffer_length_stranding.nc')
def test_plot(tmpdir):
print("setting up global landmask")
reader_global = reader_global_landmask.Reader(llcrnrlon=18.64,
llcrnrlat=69.537,
urcrnrlon=19.37,
urcrnrlat=69.81)
x = np.linspace(18.641, 19.369, 10)
y = np.linspace(69.538, 69.80, 10)
xx, yy = np.meshgrid(x, y)
shp = xx.shape
xx = xx.ravel()
yy = yy.ravel()
print("points:", len(xx))
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import cartopy
reader = cartopy.feature.GSHHSFeature(scale='f')
plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
c = reader_global.__on_land__(xx, yy).reshape(shp)
# c = reader_basemap.__on_land__(xx,yy).reshape(shp)
print(c)
ex = [18.641, 19.369, 69.538, 69.80]
plt.imshow(c, extent=ex, transform=ccrs.PlateCarree())
ax.coastlines()
# ax.set_global()
# plt.show()
plt.savefig('%s/cartplot.png' % tmpdir)
def test_leewayrun(self):
"""Test the expected Leeway left/right split."""
self.lee = Leeway(loglevel=30)
self.objectType = 50 # FISHING-VESSEL-1
self.reader_landmask = reader_global_landmask.Reader(llcrnrlon=3,
llcrnrlat=59.8,
urcrnrlon=6,
urcrnrlat=60.5)
self.lee.add_reader([self.reader_landmask])
self.lee.seed_elements(lon=4.5,
lat=60,
number=100,
objectType=self.objectType,
time=datetime(2015, 1, 1))
self.lee.fallback_values['x_wind'] = 0
self.lee.fallback_values['y_wind'] = 10
self.lee.fallback_values['x_sea_water_velocity'] = 0
self.lee.fallback_values['y_sea_water_velocity'] = 0
# Check that 7 out of 100 elements strand towards coast
self.lee.run(steps=24, time_step=3600)
self.assertEqual(self.lee.num_elements_scheduled(), 0)
self.assertEqual(self.lee.num_elements_active(), 96)
self.assertEqual(self.lee.num_elements_deactivated(), 4) # stranded
self.lee.export_ascii('leeway_ascii.txt')
os.remove('leeway_ascii.txt')
def make_OceanDrift_object(self):
self.o = OceanDrift(loglevel=30)
self.fake_eddy = reader_ArtificialOceanEddy.Reader(2, 62)
self.o.use_block = False
self.reader_landmask = reader_global_landmask.Reader(
extent=[-1.5, 59, 7, 64])
self.o.add_reader([self.fake_eddy, self.reader_landmask])
def test_adding_readers(self):
o = OceanDrift()
landmask = reader_global_landmask.Reader(
extent=[-1.5, 7, 59, 64])
r = reader_ROMS_native.Reader(o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
o.add_reader([r, landmask])
self.assertEqual(o.priority_list['land_binary_mask'],
['roms native', 'global_landmask'])
self.assertEqual(o.priority_list['x_sea_water_velocity'],
['roms native'])
# Switch order
o = OceanDrift()
o.add_reader([landmask, r])
self.assertEqual(o.priority_list['land_binary_mask'],
['global_landmask', 'roms native'])
self.assertEqual(o.priority_list['x_sea_water_velocity'],
['roms native'])
# Test add_readers_from_list
o = OceanDrift()
o.add_readers_from_list(reader_list, lazy=False)
self.assertEqual(o.priority_list['x_sea_water_velocity'],
['roms native'])
self.assertEqual(o.priority_list['x_wind'],
[o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/AROME_MetCoOp_00_DEF.nc_20160202_subset'])
def test_output_time_step(self):
o1 = OceanDrift(loglevel=30)
norkyst = reader_netCDF_CF_generic.Reader(o1.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
landmask = reader_global_landmask.Reader(
llcrnrlon=4.5, llcrnrlat=60.0,
urcrnrlon=5.2, urcrnrlat=60.5)
o1.add_reader([landmask, norkyst])
o1.seed_elements(4.96, 60.1, radius=3000, number=100,
time=norkyst.start_time)
o1.run(duration=timedelta(hours=12),
time_step=timedelta(minutes=30),
time_step_output=timedelta(minutes=30),
outfile='test_time_step30.nc')
# Check length of time array and output array
time = o1.get_time_array()[0]
self.assertEqual(o1.history.shape[1], len(time))
self.assertEqual(o1.start_time, time[0])
self.assertEqual(o1.time, time[-1])
# Second run, with larger output time step
o2 = OceanDrift(loglevel=30)
o2.add_reader([landmask, norkyst])
o2.seed_elements(4.96, 60.1, radius=3000, number=100,
time=norkyst.start_time)
o2.run(duration=timedelta(hours=12),
time_step=timedelta(minutes=30),
time_step_output=timedelta(minutes=60),
outfile='test_time_step60.nc')
self.assertEqual(o1.history.shape, (100,25))
self.assertEqual(o2.history.shape, (100,13))
# Check that start and end conditions (longitudes) are idential
self.assertIsNone(np.testing.assert_array_equal(
o1.history['lon'][:,24].compressed(),
o2.history['lon'][:,12].compressed()))
self.assertIsNone(np.testing.assert_array_equal(
o1.history['lon'][:,0].compressed(),
o2.history['lon'][:,0].compressed()))
# Check that also run imported from file is identical
o1i = OceanDrift(loglevel=20)
o1i.io_import_file('test_time_step30.nc')
o2i = OceanDrift(loglevel=20)
o2i.io_import_file('test_time_step60.nc')
os.remove('test_time_step30.nc')
os.remove('test_time_step60.nc')
self.assertIsNone(np.testing.assert_array_equal(
o2i.history['lon'][:,12].compressed(),
o2.history['lon'][:,12].compressed()))
# Check number of activated elements
self.assertEqual(o1.num_elements_total(), o2.num_elements_total())
self.assertEqual(o1.num_elements_total(), o1i.num_elements_total())
self.assertEqual(o1.num_elements_total(), o2i.num_elements_total())
# Check number of deactivated elements
self.assertEqual(o1.num_elements_deactivated(),
o2.num_elements_deactivated())
self.assertEqual(o1.num_elements_deactivated(),
o1i.num_elements_deactivated())
self.assertEqual(o1.num_elements_deactivated(),
o2i.num_elements_deactivated())
def test_reader_landmask_generate_extent():
import os, tempfile
tmpdir = os.path.join(tempfile.gettempdir(), 'landmask')
mmapf = os.path.join(tmpdir, 'mask.dat')
if os.path.exists(mmapf): os.unlink(mmapf)
reader_global_landmask.Reader(extent=[4, 55, 11, 65])
assert os.path.exists(mmapf)
def test_reader_landmask_generate():
import os, tempfile
tmpdir = os.path.join(tempfile.gettempdir(), 'landmask')
mmapf = os.path.join(tmpdir, 'mask.dat')
if os.path.exists(mmapf): os.unlink(mmapf)
r = reader_global_landmask.Reader()
if r.mask_type == 0:
assert os.path.exists(mmapf)
def test_basemap_global_matches(test_data):
reader_global = reader_global_landmask.Reader()
reader_basemap = reader_basemap_landmask.Reader(llcrnrlon=4,
llcrnrlat=59,
urcrnrlon=18,
urcrnrlat=68.1,
resolution='i',
projection='merc')
reader_nordic = reader_ROMS_native.Reader(
test_data +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
land = (np.array([15.]), np.array([65.6]))
ocean = (np.array([5.]), np.array([65.6]))
# basemap
ob = OceanDrift(loglevel=00)
ob.add_reader([reader_nordic, reader_basemap])
en, en_prof, missing = ob.get_environment(['land_binary_mask'],
reader_nordic.start_time,
land[0], land[1], np.array([0]),
None)
assert en.land_binary_mask == np.array([True])
en, en_prof, missing = ob.get_environment(['land_binary_mask'],
reader_nordic.start_time,
ocean[0], ocean[1],
np.array([0]), None)
assert en.land_binary_mask == np.array([False])
assert len(ob.readers) == 2
# global landmask
oc = OceanDrift(loglevel=00)
oc.add_reader([reader_nordic, reader_global])
en, en_prof, missing = oc.get_environment(['land_binary_mask'],
reader_nordic.start_time,
land[0], land[1], np.array([0]),
None)
assert en.land_binary_mask == np.array([True])
en, en_prof, missing = oc.get_environment(['land_binary_mask'],
reader_nordic.start_time,
ocean[0], ocean[1],
np.array([0]), None)
assert en.land_binary_mask == np.array([False])
assert len(
oc.readers) == 2 # make sure opendrift doesn't add default basemap
def test_interact_coastline_global(self):
reader_global = reader_global_landmask.Reader()
o = OceanDrift(loglevel=00)
o.add_reader(reader_global)
o.set_config('general:coastline_action', 'previous')
o.set_config('general:use_basemap_landmask', False)
o.fallback_values['x_sea_water_velocity'] = .7
o.seed_elements(lon=5, lat=60.49, time=datetime.now())
o.run(time_step=3600, steps=30)
lons = o.history['lon'][0]
self.assertAlmostEqual(lons[0], 5, 2)
self.assertAlmostEqual(lons[-2], 5.092, 2)
self.assertAlmostEqual(lons[-1], 5.092, 2)
def test_MFDataset():
reader_landmask = reader_global_landmask.Reader(llcrnrlon=13.5,
llcrnrlat=67.1,
urcrnrlon=14.6,
urcrnrlat=67.7)
o = OceanDrift3D(loglevel=0)
nordicMF = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic_subset_day*.nc')
nordicMF_all = reader_ROMS_native.Reader(
o.test_data_folder() + '2Feb2016_Nordic_sigma_3d/Nordic_subset.nc')
lon = 14.0
lat = 67.3
#nordic3d = reader_ROMS_native.Reader(o.test_data_folder() +
# '2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
#o.add_reader(nordic3d) # Slightly different results
# Subset is made with ncks, and should give identical result
# e0=0, e1=20, x0=40, x1=70
# ncks -d eta_rho,0,$e1 -d eta_psi,0,$e1 -d eta_v,0,$e1 -d eta_u,0,$e1 -d xi_rho,$x0,$x1 -d xi_psi,$x0,$x1 -d xi_v,$x0,$x1 -d xi_u,$x0,$x1 Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc Nordic_subset.nc -O --fl_fmt=netcdf4_classic
# ncks -O -d ocean_time,0 Nordic_subset.nc Nordic_subset_day1.nc
o.add_reader([reader_landmask, nordicMF_all])
o.seed_elements(lon,
lat,
number=100,
radius=5000,
time=nordicMF_all.start_time)
o.run(steps=48, time_step=3600)
# Same run, with multi-file dataset
o2 = OceanDrift3D(loglevel=30)
o2.add_reader([reader_landmask, nordicMF])
o2.seed_elements(lon,
lat,
number=100,
radius=5000,
time=nordicMF_all.start_time)
o2.run(steps=48, time_step=3600)
#o.plot(filename='o1.png', background='sea_floor_depth_below_sea_level')
#o2.plot(filename='o2.png', background='sea_floor_depth_below_sea_level')
assert o.num_elements_active() == 33
assert o2.num_elements_active() == 33
assert o.num_elements_deactivated() == 67
assert o2.num_elements_deactivated() == 67
assert o.elements.lon[0] == o2.elements.lon[0]
def test_seed_outside_coverage(self):
"""Test seeding"""
o = OpenOil3D(loglevel=0)
norkyst = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc')
landmask = reader_global_landmask.Reader(
llcrnrlon=4, llcrnrlat=60, urcrnrlon=6, urcrnrlat=64)
o.add_reader([landmask, norkyst])
o.fallback_values['x_wind'] = 0
o.fallback_values['y_wind'] = 0
o.set_config('seed:oil_type', 'SNORRE B')
o.seed_elements(5, 63, number=5,
time=norkyst.start_time - 24*timedelta(hours=24))
# Check that the oiltype is taken from config
self.assertEqual(o.oil_name, o.get_config('seed:oil_type'))
self.assertEqual(o.oil_name, 'SNORRE B')
with self.assertRaises(ValueError):
o.run(steps=3, time_step=timedelta(minutes=15))
def test_stranding_options(self):
reader_osc = reader_oscillating.Reader('x_sea_water_velocity',
amplitude=.5,
period_seconds=3600 * 6,
zero_time=datetime.now())
reader_global = reader_global_landmask.Reader()
# Three different stranding options, with
# expected final status and position
options = ['stranding', 'previous', 'none']
status = ['stranded', 'active', 'active']
lons_backward = [16.157, 16.087, 16.167]
lons_forward = [16.198, 16.115, 16.167]
for i, option in enumerate(options):
for direction in ['forward', 'backward']:
if direction == 'forward':
lons = lons_forward
time_step = 900
else:
lons = lons_backward
time_step = -900
o = OceanDrift(loglevel=50)
o.set_config('general:coastline_action', option)
o.add_reader([reader_osc, reader_global])
# Adding northwards drift
o.set_config('environment:constant:y_sea_water_velocity', .1)
#o.seed_elements(lon=13.35, lat=68.0, radius=0,
o.seed_elements(lon=16.12,
lat=68.5,
radius=0,
time=reader_osc.zero_time)
o.run(duration=timedelta(hours=22), time_step=time_step)
#o.animation()
#o.plot ()
print('Testing stranding: %s, %s' % (option, direction))
if len(o.elements) == 1:
el = o.elements
else:
el = o.elements_deactivated
self.assertEqual(o.status_categories[int(el.status)],
status[i])
self.assertIsNone(
np.testing.assert_array_almost_equal(el.lon, lons[i], 3))
def test_performance_global(benchmark):
print("setting up global landmask")
reader_global = reader_global_landmask.Reader(
extent=[18.64, 69.537, 19.37, 69.81])
x = np.linspace(18.641, 19.369, 100)
y = np.linspace(69.538, 69.80, 100)
xx, yy = np.meshgrid(x, y)
xx = xx.ravel()
yy = yy.ravel()
print("points:", len(xx))
# warmup
reader_global.__on_land__(xx, yy)
benchmark(reader_global.__on_land__, xx, yy)
def test_global_array(test_data):
reader_global = reader_global_landmask.Reader()
reader_nordic = reader_ROMS_native.Reader(test_data +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
lon = np.array([15., 5.])
lat = np.array([65.6, 65.6])
# global
oc = OceanDrift(loglevel = 00)
oc.add_reader ([reader_nordic, reader_global])
en, en_prof, missing = oc.get_environment (['land_binary_mask'],
reader_nordic.start_time,
lon, lat, np.array([0, 0]), None)
np.testing.assert_array_equal(en.land_binary_mask, np.array([True, False]))
assert len(oc.readers) == 2 # make sure opendrift doesn't add default basemap
def test_leewayrun(tmpdir):
"""Test the expected Leeway left/right split."""
lee = Leeway(loglevel=30)
objectType = 50 # FISHING-VESSEL-1
reader_landmask = reader_global_landmask.Reader(extent=[ 3, 59.8, 6, 60.5 ])
lee.add_reader([reader_landmask])
lee.seed_elements(lon=4.5, lat=60, number=100,
objectType=objectType,
time=datetime(2015, 1, 1))
lee.fallback_values['x_wind'] = 0
lee.fallback_values['y_wind'] = 10
lee.fallback_values['x_sea_water_velocity'] = 0
lee.fallback_values['y_sea_water_velocity'] = 0
# Check that 7 out of 100 elements strand towards coast
lee.run(steps=24, time_step=3600)
assert lee.num_elements_scheduled() == 0
assert lee.num_elements_active() == 96
assert lee.num_elements_deactivated() == 4 # stranded
lee.export_ascii(tmpdir + '/leeway_ascii.txt')
def test_dateline():
mask = reader_global_landmask.Reader()
x = np.linspace(-180, 180, 100)
y = np.linspace(-90, 90, 100)
xx, yy = np.meshgrid(x, y)
xx, yy = xx.ravel(), yy.ravel()
mm = mask.__on_land__(xx, yy)
# Offset
x2 = np.linspace(180, 540, 100)
y2 = np.linspace(-90, 90, 100)
xx, yy = np.meshgrid(x2, y2)
xx, yy = xx.ravel(), yy.ravel()
MM = mask.__on_land__(xx, yy)
np.testing.assert_array_equal(mm, MM)
def test_leewayrun(tmpdir, test_data):
"""Test the expected Leeway left/right split."""
lee = Leeway(loglevel=20)
object_type = 50 # FISHING-VESSEL-1
reader_landmask = reader_global_landmask.Reader(extent=[ 3, 59.8, 6, 60.5 ])
lee.add_reader([reader_landmask])
lee.seed_cone(lon=[4.5, 4.7], lat=[60.1, 60], number=100,
object_type=object_type,
time=[datetime(2015, 1, 1, 0), datetime(2015, 1, 1, 6)])
lee.set_config('environment:fallback:x_wind', 0)
lee.set_config('environment:fallback:y_wind', 10)
lee.set_config('environment:fallback:x_sea_water_velocity', 0)
lee.set_config('environment:fallback:y_sea_water_velocity', 0)
# Check that 10 out of 100 elements strand towards coast
lee.run(steps=24, time_step=3600)
assert lee.num_elements_scheduled() == 0
assert lee.num_elements_active() == 88
assert lee.num_elements_deactivated() == 12 # stranded
asciif = tmpdir + '/leeway_ascii.txt'
lee.export_ascii(asciif)
asciitarget = test_data + "/generated/test_leewayrun_export_ascii.txt"
import filecmp
assert filecmp.cmp(asciif, asciitarget)
o = Leeway(loglevel=20) # Set loglevel to 0 for debug information
#%%
# Arome
reader_arome = reader_netCDF_CF_generic.Reader(o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/arome_subset_16Nov2015.nc')
#%%
# Norkyst
reader_norkyst = reader_netCDF_CF_generic.Reader(o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
#%%
# Making customised, full resolution landmask
reader_landmask = reader_global_landmask.Reader(
extent=[5.5, 6.65, 61.05, 61.21])
o.add_reader([reader_landmask, reader_norkyst, reader_arome])
#%%
# Seed elements
lat = 61.117594; lon = 6.55
#time = [reader_arome.start_time,
# reader_arome.start_time + timedelta(hours=5)]
time = reader_arome.start_time
objType = 1 # 1: Person-in-water (PIW), unknown state (mean values)
o.seed_elements(lon, lat, radius=50, number=5000, time=time, objectType=objType)
#%%
# Running model for 66 hours, using small time step due to high resolution coastline
o.run(duration=timedelta(hours=12), time_step=300, time_step_output=3600)
def test_landmask_global():
reader_global = reader_global_landmask.Reader(extent=[4, 55, 11, 65])
assert reader_global.__on_land__(np.array([10]), np.array([60])) == [True]
assert reader_global.__on_land__(np.array([5]), np.array([60])) == [False]
# Arome
#reader_arome = reader_netCDF_CF_generic.Reader('http://thredds.met.no/thredds/dodsC/meps25files/meps_det_extracted_2_5km_latest.nc')
reader_arome = reader_netCDF_CF_generic.Reader(
lw.test_data_folder() +
'16Nov2015_NorKyst_z_surface/arome_subset_16Nov2015.nc')
# Norkyst
#reader_norkyst = reader_netCDF_CF_generic.Reader('http://thredds.met.no/thredds/dodsC/sea/norkyst800m/1h/aggregate_be')
reader_norkyst = reader_netCDF_CF_generic.Reader(
lw.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
# Landmask
reader_landmask = reader_global_landmask.Reader(llcrnrlon=3.3,
llcrnrlat=59.5,
urcrnrlon=5.5,
urcrnrlat=62.5)
#lw.add_reader([reader_norkyst, reader_arome, reader_landmask])
# Adding readers succesively, and specifying which variables they
# shall provide. This way, order of adding readers does not matter,
# except for small rounding differences due to different projection
lw.add_reader(reader_norkyst,
variables=['x_sea_water_velocity', 'y_sea_water_velocity'])
lw.add_reader(reader_arome, variables=['x_wind', 'y_wind'])
lw.add_reader(reader_landmask, variables=['land_binary_mask'])
lw.fallback_values['x_sea_water_velocity'] = 0
lw.fallback_values['y_sea_water_velocity'] = 0
# Seeding some particles
lon = 4.5
from opendrift.readers import reader_global_landmask
from opendrift.readers import reader_landmask_custom
from opendrift.models.oceandrift import OceanDrift
###############################
# MODEL
###############################
o = OceanDrift(loglevel=0) # Set loglevel to 0 for debug information
###############################
# READERS
###############################
# Creating and adding reader using a native SCHISM netcdf output file
# SCHISM reader
# Landmask - (uses cartopy+rasterized GHSS shorelines)
reader_landmask = reader_global_landmask.Reader(llcrnrlon=171.5,
llcrnrlat=-43.5,
urcrnrlon=177.0,
urcrnrlat=-38.0)
reader_custom = reader_landmask_custom.Reader(
polygon_file=
'/home/simon/Documents/GitHub/opendrift/examples/schism_marl_edit.shore')
# reader_custom.plot() # check reader was correctly loaded, close figure to continue
# NZTM proj4 string found at https://spatialreference.org/ref/epsg/nzgd2000-new-zealand-transverse-mercator-2000/
proj4str_nztm = '+proj=tmerc +lat_0=0 +lon_0=173 +k=0.9996 +x_0=1600000 +y_0=10000000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs'
schism_native = reader_schism_native.Reader(
filename=
'https://thredds.met.no/thredds/dodsC/metusers/knutfd/thredds/netcdf_unstructured_samples/schism_marl20080101_00z_3D.nc',
proj4=proj4str_nztm,
use_3d=True)
o = OpenBerg() # Basic drift model suitable for icebergs
############################################
# Preparing Readers
############################################
reader_current = reader_netCDF_CF_generic.Reader(
o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
reader_wind = reader_netCDF_CF_generic.Reader(
o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/arome_subset_16Nov2015.nc')
reader_landmask = reader_global_landmask.Reader(llcrnrlon=2.9,
llcrnrlat=59.7,
urcrnrlon=4.9,
urcrnrlat=61.5)
o.add_reader([reader_current, reader_wind, reader_landmask])
#######################
# Seeding elements
#######################
# Icebergs are moved with the ocean current as per Barker et al (2004),
# in addition to a fraction of the wind speed (wind_drift_factor).
# This factor depends on the properties of the elements.
# Default empirical values are:
# - Wind drift fraction: 0.018 (1.8 %) (Garret 1985)
# - Iceberg size: Keel dept = 60m
# Waterline length = 90.5m
from opendrift.readers import reader_netCDF_CF_generic
from opendrift.models.leeway import Leeway
o = Leeway(loglevel=0) # Set loglevel to 0 for debug information
# Arome
reader_arome = reader_netCDF_CF_generic.Reader(o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/arome_subset_16Nov2015.nc')
# Norkyst
reader_norkyst = reader_netCDF_CF_generic.Reader(o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
# Making customised, full resolution landmask
reader_landmask = reader_global_landmask.Reader(
llcrnrlon=5.5, llcrnrlat=61.05,
urcrnrlon=6.65, urcrnrlat=61.21)
o.add_reader([reader_landmask, reader_norkyst, reader_arome])
# Seed elements
lat = 61.117594; lon = 6.55
#time = [reader_arome.start_time,
# reader_arome.start_time + timedelta(hours=5)]
time = reader_arome.start_time
objType = 1 # 1: Person-in-water (PIW), unknown state (mean values)
o.seed_elements(lon, lat, radius=50, number=5000, time=time, objectType=objType)
# Running model for 66 hours
o.run(steps=66*12, time_step=300)
import os
from opendrift.readers import reader_global_landmask
from opendrift.readers import reader_netCDF_CF_generic
from opendrift.models.oceandrift import OceanDrift
ncfile = 'backandforth.nc'
o = OceanDrift(loglevel=0) # Set loglevel to 0 for debug information
reader_norkyst = reader_netCDF_CF_generic.Reader(o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
#reader_norkyst = reader_netCDF_CF_generic.Reader('http://thredds.met.no/thredds/dodsC/sea/norkyst800m/1h/aggregate_be')
reader_landmask = reader_global_landmask.Reader(llcrnrlon=3, llcrnrlat=59,
urcrnrlon=6, urcrnrlat=62)
o.add_reader([reader_norkyst, reader_landmask])
################
# Forward run
################
# Seeding some particles
lon = 4.2; lat = 60.1;
time = reader_norkyst.start_time
o.seed_elements(lon, lat, radius=1000, number=100, time=time)
o.run(steps=50*4, time_step=900, outfile=ncfile)
# Print and plot results
print(o)
"""
import numpy as np
from datetime import datetime, timedelta
from opendrift.readers import reader_global_landmask
from opendrift.readers import reader_double_gyre
from opendrift.readers import reader_ArtificialOceanEddy
from opendrift.models.oceandrift import OceanDrift
o = OceanDrift(loglevel=0) # Set loglevel to 0 for debug information
fake_eddy = reader_ArtificialOceanEddy.Reader(2, 62)
reader_landmask = reader_global_landmask.Reader(llcrnrlon=-1.5,
llcrnrlat=59,
urcrnrlon=7,
urcrnrlat=64)
lon = 2.0
lat = 63.0
# Close to Station M
runs = []
leg = []
i = 0
for scheme in ['euler', 'runge-kutta', 'runge-kutta4']:
for time_step in [1800, 3600 * 3]:
leg.append(scheme + ', T=%.1fh' % (time_step / 3600.))
print(leg[-1])
o = OceanDrift(loglevel=50)
o.fallback_values['land_binary_mask'] = 0
"""
from opendrift.readers import reader_global_landmask
from opendrift.readers import reader_netCDF_CF_generic
from opendrift.models.oceandrift import OceanDrift
o = OceanDrift(loglevel=20) # Set loglevel to 0 for debug information
reader_norkyst = reader_netCDF_CF_generic.Reader(
o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
time = reader_norkyst.start_time
reader_norkyst.interpolation = 'linearND'
reader_landmask = reader_global_landmask.Reader(llcrnrlon=4,
llcrnrlat=59.9,
urcrnrlon=5.5,
urcrnrlat=61.5)
o.add_reader([reader_norkyst, reader_landmask])
lon = 4.5
lat = 60.0
#%%
# First run, with Euler scheme:
o.set_config('drift:scheme', 'euler')
o.seed_elements(lon, lat, radius=0, number=1, time=time)
o.run(steps=66 * 2, time_step=1800)
#%%
# Second run, with Runge-Kutta scheme:
o2 = OceanDrift(loglevel=20) # Set loglevel to 0 for debug information
