def test_clip_domain(self):
o = OceanDrift(loglevel=50)
r1 = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
r1.clip_boundary_pixels(20)
r2 = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
self.assertEqual(r2.shape, (151, 81))
self.assertEqual(r1.shape, (111, 41))
self.assertEqual(r1.xmin, 20)
o1 = OceanDrift(loglevel=50)
del o1.fallback_values['x_sea_water_velocity']
o1.add_reader(r1)
o1.seed_elements(lon=15, lat=70.1, time=r1.start_time)
o1.fallback_values['land_binary_mask'] = 0
o1.run(time_step=3600 * 3, duration=timedelta(hours=48))
o2 = OceanDrift(loglevel=50)
del o2.fallback_values['x_sea_water_velocity']
o2.add_reader(r2)
o2.seed_elements(lon=15, lat=70.1, time=r1.start_time)
o2.fallback_values['land_binary_mask'] = 0
o2.run(time_step=3600 * 3, duration=timedelta(hours=48))
# Compare
lat1 = o1.get_property('lat')[0]
lat2 = o2.get_property('lat')[0]
self.assertEqual(len(lat1), 14)
self.assertEqual(len(lat2), 17)
self.assertIsNone(np.testing.assert_allclose(lat1[0:13], lat2[0:13]))
# Test reader netCDF_CF_generic
r = reader_netCDF_CF_generic.Reader(
o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
self.assertEqual(r.shape, (301, 201))
o3 = OceanDrift(loglevel=50)
del o3.fallback_values['x_sea_water_velocity']
o3.fallback_values['land_binary_mask'] = 0
o3.add_reader(r)
o3.seed_elements(lon=4.36, lat=61.7, time=r.start_time)
o3.run(steps=24)
r.clip_boundary_pixels(10)
self.assertEqual(r.shape, (281, 181))
o4 = OceanDrift(loglevel=50)
del o4.fallback_values['x_sea_water_velocity']
o4.fallback_values['land_binary_mask'] = 0
o4.add_reader(r)
o4.seed_elements(lon=4.36, lat=61.7, time=r.start_time)
o4.run(steps=24)
# Compare
lat3 = o3.get_property('lat')[0]
lat4 = o4.get_property('lat')[0]
self.assertEqual(len(lat3), 25)
self.assertEqual(len(lat4), 13)
self.assertIsNone(np.testing.assert_allclose(lat3[0:12], lat4[0:12]))
def test_MFDataset(self):
reader_basemap = reader_basemap_landmask.Reader(llcrnrlon=13.5,
llcrnrlat=67.1,
urcrnrlon=14.6,
urcrnrlat=67.7,
resolution='i',
projection='merc')
o = OceanDrift3D(loglevel=0)
o.set_config('general:basemap_resolution', 'i')
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_basemap, 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.set_config('general:basemap_resolution', 'i')
o2.add_reader([reader_basemap, 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')
self.assertEqual(o.num_elements_active(), 67)
self.assertEqual(o2.num_elements_active(), 67)
self.assertEqual(o.num_elements_deactivated(), 33)
self.assertEqual(o2.num_elements_deactivated(), 33)
self.assertEqual(o.elements.lon[0], o2.elements.lon[0])
def test_adding_readers(self):
o = OceanDrift()
basemap = reader_basemap_landmask.Reader(llcrnrlon=-1.5,
llcrnrlat=59,
urcrnrlon=7,
urcrnrlat=64,
resolution='c')
r = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
o.add_reader([r, basemap])
self.assertEqual(o.priority_list['land_binary_mask'],
['roms native', 'basemap_landmask'])
self.assertEqual(o.priority_list['x_sea_water_velocity'],
['roms native'])
# Switch order
o = OceanDrift()
o.add_reader([basemap, r])
self.assertEqual(o.priority_list['land_binary_mask'],
['basemap_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_vertical_interpolation_sigma(self):
nordic3d = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
lon = np.array([12.46, 12.46, 12.46])
lat = np.array([68.21, 69.31, 69.31])
z = np.array([-33, 0, -2500])
x, y = nordic3d.lonlat2xy(lon, lat)
variables = [
'x_sea_water_velocity', 'y_sea_water_velocity',
'sea_water_temperature'
]
# Call get_variables_interpolated which interpolates both in
data = nordic3d.get_variables(variables,
time=nordic3d.start_time +
timedelta(seconds=900),
x=x,
y=y,
z=z,
block=True)
self.assertAlmostEqual(data['sea_water_temperature'][0, 60, 60], 3.447,
2)
#3.59, 2)
self.assertAlmostEqual(data['sea_water_temperature'][-1, 60, 60],
-0.783, 2)
def test_stranding_roms(self):
o = PelagicEggDrift(loglevel=0)
reader_arctic = reader_netCDF_CF_generic.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Arctic20_1to5Feb_2016.nc')
reader_nordic = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
o.add_reader(reader_arctic)
o.add_reader(reader_nordic)
o.fallback_values['x_sea_water_velocity'] = 1
o.seed_elements(
lon=13.0,
lat=68.0,
radius=20000,
number=100,
time=[reader_arctic.start_time, reader_nordic.end_time],
z=-30)
o.set_config('general:coastline_action', 'previous')
o.set_config('processes:turbulentmixing', False)
o.max_speed = 1
o.run(end_time=reader_nordic.end_time, time_step=3600 * 36)
self.assertEqual(o.num_elements_scheduled(), 0)
self.assertEqual(o.num_elements_active(), 100)
self.assertEqual(o.num_elements_activated(), 100)
self.assertEqual(o.num_elements_deactivated(), 0)
self.assertEqual(o.num_elements_total(), 100)
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_reader_boundary(self):
o = PelagicEggDrift(loglevel=0)
reader_nordic = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
reader_arctic = reader_netCDF_CF_generic.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Arctic20_1to5Feb_2016.nc')
######################################################
# Vertical interpolation is another issue to be fixed:
reader_nordic.zlevels = reader_arctic.z
######################################################
o.add_reader([reader_nordic, reader_arctic])
o.fallback_values['land_binary_mask'] = 0
o.fallback_values['x_wind'] = 10 # Some wind for mixing
# Seed close to Nordic boundary
o.seed_elements(lon=14.9,
lat=71.1,
radius=2000,
number=100,
time=reader_nordic.start_time,
z=0)
o.set_config('turbulentmixing:timestep', 20)
o.set_config('drift:scheme', 'runge-kutta')
o.run(steps=5, time_step=3600, time_step_output=3600)
self.assertEqual(o.num_elements_active(), 100)
self.assertEqual(o.num_elements_deactivated(), 0)
self.assertAlmostEqual(o.elements.lat[0], 71.16, 1)
#self.assertAlmostEqual(o.elements.z.min(), -41.92, 1) # With past ROMS-masking
self.assertAlmostEqual(o.elements.z.min(), -40.1, 1)
self.assertAlmostEqual(o.elements.z.max(), -0.01, 1)
#self.assertAlmostEqual(o.elements.lon.max(), 14.949, 2)
self.assertAlmostEqual(o.elements.lon.max(), 14.87, 2)
def test_interpolation_missing(self):
"""Test interpolation."""
reader = reader_ROMS_native.Reader(o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
num_points = 50
np.random.seed(0) # To get the same random numbers each time
lons = np.random.uniform(10, 11, num_points)
lats = np.random.uniform(66, 67.0, num_points)
z = np.random.uniform(-200, 0, num_points)
x, y = reader.lonlat2xy(lons, lats)
variables = ['x_sea_water_velocity', 'y_sea_water_velocity',
'sea_water_temperature']
# Read a block of data covering the points
data = reader.get_variables(variables, time=reader.start_time,
x=x, y=y, z=z, block=True)
# Introduce missing values
data['x_sea_water_velocity'] = np.ma.masked_where(
data['x_sea_water_velocity']>.08,
data['x_sea_water_velocity'])
b = ReaderBlock(data, interpolation_horizontal='linearND')
env, prof = b.interpolate(x, y, z, variables,
profiles=['x_sea_water_velocity'],
profiles_depth=[-30, 0])
self.assertAlmostEqual(env['x_sea_water_velocity'][10],
0.074, 2)
self.assertAlmostEqual(prof['x_sea_water_velocity'][5,48],
-0.090, 2)
def import_from_ladim(ladimfile, romsfile):
"""Import Ladim output file as OpenDrift simulation obejct"""
from models.oceandrift3D import OceanDrift3D
o = OceanDrift3D()
from netCDF4 import Dataset, date2num, num2date
if isinstance(romsfile, basestring):
from opendrift.readers import reader_ROMS_native
romsfile = reader_ROMS_native.Reader(romsfile)
l = Dataset(ladimfile, 'r')
pid = l.variables['pid'][:]
particle_count = l.variables['particle_count'][:]
end_index = np.cumsum(particle_count)
start_index = np.concatenate(([0], end_index[:-1]))
x = l.variables['X'][:]
y = l.variables['Y'][:]
lon, lat = romsfile.xy2lonlat(x, y)
time = num2date(l.variables['time'][:], l.variables['time'].units)
history_dtype_fields = [(name, o.ElementType.variables[name]['dtype'])
for name in o.ElementType.variables]
# Add environment variables
o.history_metadata = o.ElementType.variables.copy()
history_dtype = np.dtype(history_dtype_fields)
num_timesteps = len(time)
num_elements = len(l.dimensions['particle'])
o.history = np.ma.array(np.zeros([num_elements, num_timesteps]),
dtype=history_dtype,
mask=[True])
for n in range(num_timesteps):
start = start_index[n]
active = pid[start:start + particle_count[n]]
o.history['lon'][active, n] = \
lon[start:start+particle_count[n]]
o.history['lat'][active, n] = \
lat[start:start+particle_count[n]]
o.history['status'][active, n] = 0
o.status_categories = ['active', 'missing_data']
firstlast = np.ma.notmasked_edges(o.history['status'], axis=1)
index_of_last = firstlast[1][1]
o.history['status'][np.arange(len(index_of_last)), index_of_last] = 1
kwargs = {}
for var in ['lon', 'lat', 'status']:
kwargs[var] = o.history[var][np.arange(len(index_of_last)),
index_of_last]
kwargs['ID'] = range(num_elements)
o.elements = o.ElementType(**kwargs)
o.elements_deactivated = o.ElementType()
o.remove_deactivated_elements()
# Import time steps from metadata
o.time_step = time[1] - time[0]
o.time_step_output = o.time_step
o.start_time = time[0]
o.time = time[-1]
o.steps_output = num_timesteps
return o
def test_expand_array(self):
reader = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
reader.buffer = 1
num_points = 50
np.random.seed(0) # To get the same random numbers each time
lons = np.random.uniform(14, 15, num_points)
lats = np.random.uniform(68, 68.4, num_points)
x, y = reader.lonlat2xy(lons, lats)
variables = ['x_sea_water_velocity']
# Read a block of data covering the points
data = reader.get_variables(variables,
time=reader.start_time,
x=x,
y=y,
z=0)
data = np.ma.filled(data['x_sea_water_velocity'], fill_value=np.nan)
self.assertTrue(np.isnan(data.max()))
self.assertEqual(sum(~np.isfinite(data.ravel())), 80)
expand_numpy_array(data)
self.assertEqual(sum(~np.isfinite(data.ravel())), 40)
expand_numpy_array(data)
self.assertEqual(sum(~np.isfinite(data.ravel())), 9)
expand_numpy_array(data)
self.assertEqual(sum(~np.isfinite(data.ravel())), 0)
self.assertFalse(np.isnan(data.max()))
def test_stranding_3d(self):
o = PelagicEggDrift(loglevel=30)
reader_nordic = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
o.add_reader(reader_nordic)
o.set_config('environment:fallback:y_wind', 10) # Some wind for mixing
o.seed_elements(
lon=14.0,
lat=68.15,
radius=2000,
number=100,
time=[reader_nordic.start_time, reader_nordic.end_time],
z=0)
o.set_config('general:coastline_action', 'stranding')
o.set_config('vertical_mixing:timestep', 120)
o.max_speed = .1
o.run(end_time=reader_nordic.end_time, time_step=3600 * 6)
self.assertEqual(o.status_categories[1], 'stranded')
self.assertEqual(o.elements_deactivated.status.min(), 1)
self.assertEqual(o.elements_deactivated.status.max(), 1)
self.assertEqual(o.num_elements_scheduled(), 0)
self.assertEqual(o.num_elements_active(), 81)
self.assertEqual(o.num_elements_activated(), 100)
self.assertEqual(o.num_elements_deactivated(), 19)
self.assertEqual(o.num_elements_total(), 100)
# Check calculated trajectory lengths and speeds
total_length, distances, speeds = o.get_trajectory_lengths()
self.assertAlmostEqual(total_length.max(), 14978.3, 1)
self.assertAlmostEqual(total_length.min(), 1225.2, 1)
self.assertAlmostEqual(speeds.max(), 0.127, 1)
self.assertAlmostEqual(distances.max(), 2859.0, 1)
def test_reader_boundary(self):
# Check that the element outside reader coverage is
# not deactivated if fallback value exist
o = OceanDrift()
nordic3d = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
lon = [12.0, 12.0]
lat = [70.0, 70.5]
o.add_reader(nordic3d)
o.fallback_values['land_binary_mask'] = 0
o.seed_elements(lon, lat, number=2, radius=0, time=nordic3d.start_time)
o.run(steps=2, time_step=3600)
self.assertEqual(o.num_elements_active(), 2)
self.assertEqual(o.num_elements_deactivated(), 0)
# Check that the outside element is deactivated,
# if no fallback value exists
o = OceanDrift()
del o.fallback_values['x_sea_water_velocity']
o.add_reader(nordic3d)
o.fallback_values['land_binary_mask'] = 0
o.seed_elements(lon, lat, number=2, radius=0, time=nordic3d.start_time)
o.run(steps=2, time_step=3600)
self.assertEqual(o.num_elements_active(), 1)
self.assertEqual(o.num_elements_deactivated(), 1)
def test_stranding_3d(self):
o = PelagicEggDrift(loglevel=30)
reader_nordic = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
o.add_reader(reader_nordic)
o.fallback_values['y_wind'] = 10 # Some wind for mixing
o.seed_elements(
lon=14.0,
lat=68.15,
radius=2000,
number=100,
time=[reader_nordic.start_time, reader_nordic.end_time],
z=0)
o.set_config('general:coastline_action', 'stranding')
o.set_config('turbulentmixing:timestep', 120)
o.max_speed = .1
o.run(end_time=reader_nordic.end_time, time_step=3600 * 6)
self.assertEqual(o.status_categories[1], 'stranded')
self.assertEqual(o.elements_deactivated.status.min(), 1)
self.assertEqual(o.elements_deactivated.status.max(), 1)
self.assertEqual(o.num_elements_scheduled(), 0)
self.assertEqual(o.num_elements_active(), 79)
self.assertEqual(o.num_elements_activated(), 100)
self.assertEqual(o.num_elements_deactivated(), 21)
self.assertEqual(o.num_elements_total(), 100)
def test_lazy_reader(self):
o = OceanDrift(loglevel=20)
lr = reader_lazy.Reader(o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
self.assertFalse(lr.initialised)
self.assertEqual(len(lr.covers_positions([15], [69])[0]), 1)
self.assertEqual(len(lr.covers_positions([0], [0])[0]), 0)
self.assertTrue(lr.initialised)
# Make a corresponding, unlazy reader
rr = reader_ROMS_native.Reader(o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
self.assertEqual(len(rr.covers_positions([15], [69])[0]), 1)
self.assertEqual(len(rr.covers_positions([0], [0])[0]), 0)
# Check that both readers provide the same attributes
for att in rr.__dict__:
self.assertEqual(type(lr.__getattr__(att)),
type(getattr(rr, att)))
if type(getattr(rr, att)) in [float, int, dict, str, list,
datetime, timedelta, bool,
np.float64]:
self.assertEqual(lr.__getattr__(att),
getattr(rr, att))
elif type(getattr(rr, att)) in [np.ndarray]:
self.assertIsNone(np.testing.assert_array_equal(
lr.__getattr__(att),
getattr(rr, att)))
else:
print('Skipping: ' + att + ' ' +
str(type(getattr(rr, att))))
def test_MFDataset(self):
reader_landmask = reader_global_landmask.Reader(
extent=[13.5, 14.6, 67.1, 67.7])
o = OceanDrift(loglevel=30)
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)
print('=' * 99)
# Same run, with multi-file dataset
o2 = OceanDrift(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
self.assertAlmostEqual(o.elements.lon[0], o2.elements.lon[0], 5)
def test_linearNDFast(self):
"""Test interpolation."""
reader = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
reader.buffer = 3
num_points = 50
np.random.seed(0) # To get the same random numbers each time
lons = np.random.uniform(14, 15, num_points)
lats = np.random.uniform(68, 68.4, num_points)
z = np.random.uniform(-20, 0, num_points)
x, y = reader.lonlat2xy(lons, lats)
#z=None
variables = ['x_sea_water_velocity']
# Read a block of data covering the points
data = reader.get_variables(variables,
time=reader.start_time,
x=x,
y=y,
z=z,
block=True)
b = ReaderBlock(data.copy(), interpolation_horizontal='linearNDFast')
x2 = np.random.uniform(x.min(), x.max(), num_points)
y2 = np.random.uniform(y.min(), y.max(), num_points)
z2 = np.random.uniform(-20, 0, num_points)
self.assertTrue(b.covers_positions(x, y, z))
self.assertTrue(b.covers_positions(x2, y2, z2))
# Check that there are holes in the arrays of the ReaderBlock
self.assertEqual(
np.sum(~np.isfinite(b.data_dict['x_sea_water_velocity'])), 1001)
# Check that LinearNDFast interpolation gives a real value
env, prof = b.interpolate(x2,
y2,
z2,
variables,
profiles=variables,
profiles_depth=[-30, 0])
self.assertEqual(np.sum(~np.isfinite(env['x_sea_water_velocity'])), 0)
# Check that the arrays of the ReaderBlock have been filled in
self.assertEqual(
np.sum(~np.isfinite(b.data_dict['x_sea_water_velocity'])), 0)
# Check that nearest interpolation contains some NaN values
b2 = ReaderBlock(data.copy(), interpolation_horizontal='nearest')
env, prof = b2.interpolate(x2,
y2,
z2,
variables,
profiles=variables,
profiles_depth=[-30, 0])
self.assertEqual(np.sum(~np.isfinite(env['x_sea_water_velocity'])), 31)
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_lonlat2xy_sequential(test_data, benchmark):
reader = reader_ROMS_native.Reader(test_data + '2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
assert not reader.projected
reader.__disable_parallel__ = True
lon = np.arange(10., 15., .01)
lat = np.arange(67.8, 69.8, .01)
lon, lat = np.meshgrid(lon, lat)
lon, lat = lon.ravel(), lat.ravel()
print("coords: %d" % len(lon))
_, _ = benchmark(reader.lonlat2xy, lon, lat)
assert reader.__lonlat2xy_parallel__ == False
def test_lonlat2xy_sequential_big(test_data, benchmark):
reader = reader_ROMS_native.Reader('https://thredds.met.no/thredds/dodsC/nansen-legacy-ocean/SVIM/2020/ocean_avg_20200601.nc4')
assert not reader.projected
reader.__disable_parallel__ = True
lon = np.arange(-10., 15., .01)
lat = np.arange(56., 69.8, .01)
lon, lat = np.meshgrid(lon, lat)
lon, lat = lon.ravel(), lat.ravel()
print("coords: %d" % len(lon))
_, _ = benchmark(reader.lonlat2xy, lon, lat)
assert reader.__lonlat2xy_parallel__ == False
def test_ROMS_native_stranding(self):
o = OceanDrift(loglevel=0)
r = reader_ROMS_native.Reader(o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
o.add_reader(r)
o.set_config('general:use_auto_landmask', False)
o.set_config('drift:vertical_mixing', False)
o.set_config('environment:fallback:x_wind', 0)
o.set_config('environment:fallback:y_wind', 10)
o.seed_elements(lon=15.2, lat=68.3, time=r.start_time,
wind_drift_factor=.02,
number=10, radius=1000)
o.run(steps=8)
self.assertEqual(o.num_elements_deactivated(), 4)
def test_truncate_ocean_model(self):
o = OceanDrift3D(loglevel=30)
reader_nordic = reader_ROMS_native.Reader(o.test_data_folder() + \
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
o.add_reader(reader_nordic)
o.seed_elements(lon=15.0,
lat=71.1,
radius=0,
number=10,
z=np.linspace(-90, 0, 10),
time=reader_nordic.start_time)
o.set_config('general:use_basemap_landmask', False)
o.run(steps=5)
o2 = OceanDrift3D(loglevel=30)
o2.add_reader(reader_nordic)
o2.set_config('drift:truncate_ocean_model_below_m', 50)
o2.seed_elements(lon=15.0,
lat=71.1,
radius=0,
number=10,
z=np.linspace(-90, 0, 10),
time=reader_nordic.start_time)
o2.set_config('general:use_basemap_landmask', False)
o2.run(steps=5)
o3 = OceanDrift3D(loglevel=30)
o3.add_reader(reader_nordic)
o3.set_config('drift:truncate_ocean_model_below_m', 50)
o3.seed_elements(lon=15.0,
lat=71.1,
radius=0,
number=10,
z=np.linspace(-90, 0, 10),
time=reader_nordic.start_time)
o3.set_config('general:use_basemap_landmask', False)
o3.run(steps=5)
# Final depths should not be affected
self.assertIsNone(
np.testing.assert_array_almost_equal(o.elements.z, o3.elements.z))
# Surface elements should not be affected
self.assertEqual(o.elements.lat[-1], o3.elements.lat[-1])
# Elements at 90m depth should be somewht affected
self.assertNotEqual(o.elements.lat[0], o3.elements.lat[0])
# For second run, only elements below 50m should be equal
self.assertEqual(o2.elements.lat[1], o2.elements.lat[2])
self.assertNotEqual(o2.elements.lat[8], o2.elements.lat[9])
def test_reader_netcdf(self):
"""Check reader functionality."""
reader1 = reader_netCDF_CF_generic.Reader(
o.test_data_folder() +
'16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc')
reader2 = reader_ROMS_native.Reader(
o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc'
)
readers = [reader1, reader2]
for r in readers:
print(r)
# Make four points:
# 1) outside lower left, 2) lower left, 3) center of domain
# 4) outside upper right
# and assure that only 2) and 3) are marked as covered
# Upper right is skipped, as lonlat2xy may lie slightly outside
x = np.array([
r.xmin - r.delta_x, r.xmin, (r.xmin + r.xmax) / 2,
r.xmax + r.delta_x
])
y = np.array([
r.ymin - r.delta_y, r.ymin, (r.ymin + r.ymax) / 2,
r.ymax + r.delta_y
])
lons, lats = r.xy2lonlat(x, y)
covered = r.covers_positions(lons, lats, 0)[0]
if len(covered) != 1:
self.assertEqual(covered.tolist(), [1, 2])
else:
if covered == [2]:
print('#' * 60)
print('#' * 60)
print('WARNING: A point on the boundary is considered ' \
'outside after conversion x,y -> lon,lat -> x,y. ' \
'This is different from "standard", but is due to ' \
'rounding differences and not considered to be an ' \
'error. Numpy version is %s' % (np.__version__))
print('#' * 60)
print('#' * 60)
else:
self.assertTrue(False) # Should never happen!
self.assertTrue(r.covers_time(r.start_time))
self.assertFalse(r.covers_time(r.start_time - r.time_step))
self.assertFalse(r.proj.crs.is_geographic)
def test_adding_readers(self):
o = OceanDrift()
r = reader_ROMS_native.Reader(o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
o.add_reader([r, basemap])
self.assertEqual(o.priority_list['land_binary_mask'],
['roms native', 'basemap_landmask'])
self.assertEqual(o.priority_list['x_sea_water_velocity'],
['roms native'])
# Switch order
o = OceanDrift()
o.add_reader([basemap, r])
self.assertEqual(o.priority_list['land_binary_mask'],
['basemap_landmask', 'roms native'])
self.assertEqual(o.priority_list['x_sea_water_velocity'],
['roms native'])
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_lonlat2xy_parallel(test_data, benchmark):
reader = reader_ROMS_native.Reader(test_data + '2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
assert not reader.projected
lon = np.arange(10., 15., .01)
lat = np.arange(67.8, 69.8, .01)
lon, lat = np.meshgrid(lon, lat)
lon, lat = lon.ravel(), lat.ravel()
reader.__disable_parallel__ = True
xs, ys = reader.lonlat2xy(lon, lat)
assert reader.__lonlat2xy_parallel__ == False
reader.__disable_parallel__ = False
x, y = benchmark(reader.lonlat2xy, lon, lat)
assert reader.__lonlat2xy_parallel__ == True
np.testing.assert_equal(x, xs)
np.testing.assert_equal(y, ys)
def test_global_array(test_data):
shpfilename = shpreader.natural_earth(resolution='110m',
category='cultural',
name='admin_0_countries')
reader_landmask = reader_shape.Reader.from_shpfiles(shpfilename)
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_landmask])
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_lonlat2xy_parallel_big(test_data, benchmark):
reader = reader_ROMS_native.Reader('https://thredds.met.no/thredds/dodsC/nansen-legacy-ocean/SVIM/2020/ocean_avg_20200601.nc4')
assert not reader.projected
lon = np.arange(-10., 15., .01)
lat = np.arange(56., 69.8, .01)
lon, lat = np.meshgrid(lon, lat)
lon, lat = lon.ravel(), lat.ravel()
reader.__disable_parallel__ = True
xs, ys = reader.lonlat2xy(lon, lat)
assert reader.__lonlat2xy_parallel__ == False
print(xs, ys)
reader.__disable_parallel__ = False
x, y = benchmark(reader.lonlat2xy, lon, lat)
assert reader.__lonlat2xy_parallel__ == True
np.testing.assert_equal(x, xs)
np.testing.assert_equal(y, ys)
def test_get_environment(self):
o = PelagicEggDrift(loglevel=0)
reader_nordic = reader_ROMS_native.Reader(o.test_data_folder() + '2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc', name='Nordic')
reader_arctic = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '2Feb2016_Nordic_sigma_3d/Arctic20_1to5Feb_2016.nc', name='Arctic')
######################################################
# Vertical interpolation is another issue to be fixed:
reader_nordic.zlevels = reader_arctic.z
######################################################
o.add_reader([reader_nordic, reader_arctic])
# One point covered only by Nordic, two points coverd
# by both readers, and two points covered by none of the readers
testlon = np.array((14.0, 20.0, 20.1, 4, 5))
testlat = np.array((70.1, 76.0, 76.1, 60, 60))
testz = np.random.uniform(0, 0, len(testlon))
self.assertItemsEqual([0], reader_nordic.covers_positions(
testlon, testlat, testz))
self.assertItemsEqual([0, 1, 2], reader_arctic.covers_positions(
testlon, testlat, testz))
o.seed_elements(testlon, testlat, testz, time=reader_nordic.start_time)
o.fallback_values['land_binary_mask'] = 0
env, env_profiles, missing = \
o.get_environment(o.required_variables,
reader_nordic.start_time,
testlon, testlat, testz,
o.required_profiles)
self.assertAlmostEqual(env['sea_water_temperature'][0], 4.338, 2)
self.assertAlmostEqual(env['sea_water_temperature'][1], 0.6282, 3)
self.assertAlmostEqual(env['sea_water_temperature'][4], 10.0)
self.assertItemsEqual(missing, [False,False,False,False,False])
self.assertAlmostEqual(env_profiles['sea_water_temperature'][0,0],
4.338, 2)
self.assertAlmostEqual(env_profiles['sea_water_temperature'][0,4], 10)
self.assertAlmostEqual(env_profiles['sea_water_temperature'][8,2], 10)
self.assertAlmostEqual(env_profiles['sea_water_temperature'][7,2],
2.252265, 3)
# Get separate data
env2, env_profiles2, missing2 = \
o.get_environment(['x_sea_water_velocity', 'y_sea_water_velocity',
'sea_water_temperature'],
reader_nordic.start_time,
testlon, testlat, testz,
['sea_water_temperature'])
self.assertTrue(env_profiles2 is not None)
self.assertEqual(env_profiles2.keys(), ['z', 'sea_water_temperature'])
# Get separate data, without profile
env3, env_profiles3, missing3 = \
o.get_environment(['x_sea_water_velocity', 'y_sea_water_velocity',
'sea_water_temperature'],
reader_nordic.start_time,
testlon, testlat, testz,
profiles=None)
self.assertTrue(env_profiles3 is None)
# Get separate data
env4, env_profiles4, missing4 = \
o.get_environment(['x_sea_water_velocity', 'y_sea_water_velocity',
'sea_water_temperature'],
reader_nordic.start_time,
testlon, testlat, testz,
['sea_water_temperature'])
self.assertItemsEqual(env['x_sea_water_velocity'],
env2['x_sea_water_velocity'])
#print env_profiles['sea_water_temperature'], '1'*50
#print env_profiles2['sea_water_temperature'], '2'*50
#print env_profiles4['sea_water_temperature'], '4'*50
# Test below should also pass, To be fixed
#self.assertItemsEqual(env_profiles['sea_water_temperature'].ravel(),
# env_profiles2['sea_water_temperature'].ravel())
self.assertItemsEqual(env_profiles2['sea_water_temperature'].ravel(),
env_profiles4['sea_water_temperature'].ravel())
del o.fallback_values['x_sea_water_velocity']
del o.fallback_values['y_sea_water_velocity']
del o.fallback_values['x_wind']
del o.fallback_values['y_wind']
# Forcing data
if forcing == 'norshelf':
# NB: waves only for 5 months of 2011
#waves = '/lustre/storeA/project/fou/om/retrospect/retrospect_data/waves/ECwave_%Y.nc'
current = 'http://thredds.met.no/thredds/dodsC/retrospect/qck/control_qck_%Y%m.ncml'
readerURL = time[0].strftime(current)
readerURLnext = (time[0] +
timedelta(days=30)).strftime(current)
reader = reader_ROMS_native.Reader(readerURL)
readerNext = reader_ROMS_native.Reader(readerURLnext)
readers = [readerNext, reader]
o.add_reader(readers)
elif forcing == 'globcur':
current = 'http://tds0.ifremer.fr/thredds/dodsC/CLS-L4-CUREUL_HS-ALT_SUM-V02.0_FULL_TIME_SERIE'
o.add_readers_from_list([current])
else:
unknown_current
#elif forcing == 'globcur-total15m':
# current = 'http://tds0.ifremer.fr/thredds/dodsC/CLS-L4-CUREUL_15M-ALT_SUM-V02.0_FULL_TIME_SERIE'
# Adding readers
if with_stokes is True:
stokes = time[0].strftime('stokes_year/stokes_%Y.nc')
o.add_readers_from_list([stokes])
Comparing two simulation runs, with and without wind
"""
#!/usr/bin/env python
# Comparing two simulation runs, with and without wind
from datetime import timedelta
from opendrift.readers import reader_ROMS_native
from opendrift.models.oceandrift import OceanDrift
lon = 14.75; lat = 68.1
o = OceanDrift(loglevel=0)
reader_nordic = reader_ROMS_native.Reader(o.test_data_folder() +
'2Feb2016_Nordic_sigma_3d/Nordic-4km_SLEVELS_avg_00_subset2Feb2016.nc')
# First run, with landmask
o.add_reader([reader_nordic])
time = reader_nordic.start_time
o.seed_elements(lon, lat, radius=3000, number=1000, time=time)
o.set_config('general:use_auto_landmask', True)
o.run(end_time=reader_nordic.end_time, time_step=1800)
# Second run, with landmask from ocean model
o2 = OceanDrift(loglevel=0)
o2.add_reader([reader_nordic])
lon = 14.75; lat = 68.1
o2.seed_elements(lon, lat, radius=3000, number=1000, time=time)
o2.set_config('general:use_auto_landmask', False)
o2.run(end_time=reader_nordic.end_time, time_step=1800)