def test_valid_minmax(self): """Check that invalid values are replaced with fallback.""" o = OceanDrift(loglevel=20) from opendrift.readers.basereader import variables minval = variables.standard_names['x_wind']['valid_min'] # Setting valid_min to -5, to check that replacement works variables.standard_names['x_wind']['valid_min'] = -5 reader_wind = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '16Nov2015_NorKyst_z_surface/arome_subset_16Nov2015.nc') o.add_reader(reader_wind) o.set_config('environment:fallback:x_sea_water_velocity', 0) o.set_config('environment:fallback:x_wind', 2.0) o.set_config('environment:fallback:y_sea_water_velocity', 0) o.set_config('environment:fallback:land_binary_mask', 0) o.seed_elements(lon=4, lat=60, time=reader_wind.start_time) o.run(steps=1) variables.standard_names['x_wind']['valid_min'] = minval # reset w = o.get_property('x_wind')[0][0] self.assertAlmostEqual(w, 2.0, 1)
def test_no_active_but_still_unseeded_elements(self): o = OceanDrift(loglevel=20) # deactivate elements after 3 hours o.set_config('drift:max_age_seconds', 3600 * 3) norkyst = reader_netCDF_CF_generic.Reader( o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') o.add_reader(norkyst) # seed two elements at 6 hour interval o.seed_elements( number=2, lon=4, lat=62, time=[norkyst.start_time, norkyst.start_time + timedelta(hours=6)]) o.set_config('environment:fallback:land_binary_mask', 0) o.run(duration=timedelta(hours=8), outfile='test.nc') os.remove('test.nc') # Check that simulations has run until scheduled end self.assertEqual(o.steps_calculation, 8)
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') basemap = reader_basemap_landmask.Reader(llcrnrlon=4.5, llcrnrlat=60.1, urcrnrlon=6.0, urcrnrlat=60.4, resolution='c', projection='merc') o1.add_reader([basemap]) 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([basemap]) 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_reader_coverage(self): r = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc') # Element outside reader domain self.assertEqual(len(r.covers_positions(5, 80)[0]), 0) x, y = r.lonlat2xy(5, 80) self.assertRaises(ValueError, r.check_arguments, 'y_sea_water_velocity', r.start_time, x, y, 0) # Element inside reader domain self.assertEqual(len(r.covers_positions(5, 60)[0]), 1) x, y = r.lonlat2xy(5, 60) var, time, x2, y2, z2, outside = \ r.check_arguments('y_sea_water_velocity', r.start_time, x, y, 0) self.assertEqual(var, ['y_sea_water_velocity']) self.assertEqual(time, r.start_time) self.assertEqual(x, x2) self.assertEqual(y, y2) self.assertEqual(0, z2) self.assertEqual(len(outside), 0)
def test_lonlat(test_data): # Only used for projection reader_current = reader_netCDF_CF_generic.Reader( test_data + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') # Simulation SRS p = OpenDriftSimulation.SRS() lon, lat = 4., 62. x, y = reader_current.lonlat2xy(lon, lat) # Single value u = [0.26724684, 0.2784934] ru, rv = reader_current.rotate_vectors(x, y, u[0], u[1], reader_current.proj, p) np.testing.assert_almost_equal(-0.14591436614546296, ru, decimal=3) np.testing.assert_almost_equal(0.3573351998976778, rv, decimal=2) # Profile (array of vectors) u = np.array([ 0.26724684, 0.26311329, 0.25992924, 0.25909173, 0.25849965, 0.24982239, 0.25549856, 0.30730924, 0.29996288, 0.23423982, 0.23423982 ]) v = np.array([ 0.2784934, 0.26522627, 0.25113547, 0.2446443, 0.23454225, 0.16889542, 0.18744907, 0.13027644, 0.09087397, 0.19704318, 0.19704318 ]) ru, rv = reader_current.rotate_vectors(x, y, u, v, reader_current.proj, p) nu = [ -0.14591437, -0.13547045, -0.12388817, -0.11829696, -0.10930654, -0.05284545, -0.06749336, 0.00579645, 0.0388169, -0.08489617, -0.08489617 ] nv = [ 0.3573352, 0.34816854, 0.33953491, 0.33613269, 0.33148788, 0.29689097, 0.30961478, 0.33373241, 0.31101295, 0.29408664, 0.29408664 ] np.testing.assert_array_almost_equal(nu, ru, decimal=3) np.testing.assert_array_almost_equal(nv, rv, decimal=3)
def test_valid_minmax_nanvalues(self): from opendrift.readers.basereader import variables # Reducing max current speed to test masking maxval = variables.standard_names['x_sea_water_velocity']['valid_max'] variables.standard_names['x_sea_water_velocity']['valid_max'] = .1 o = OceanDrift(loglevel=20) o.set_config('environment:fallback:land_binary_mask', 0) norkyst = reader_netCDF_CF_generic.Reader( o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') o.add_reader(norkyst) o.seed_elements(lon=4.95, lat=62, number=10, time=norkyst.start_time) o.run(steps=2) variables.standard_names['x_sea_water_velocity'][ 'valid_max'] = maxval # reset u = o.get_property('x_sea_water_velocity')[0] self.assertAlmostEqual(u.max(), -.069, 3) # Some numerical error allowed
def test_seed_below_reader_coverage(self): o = OpenOil(loglevel=20) reader_norkyst = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') o.set_config('environment:fallback:land_binary_mask', 0) o.set_config('environment:fallback:x_wind', 0) o.set_config('environment:fallback:y_wind', 0) o.add_reader([reader_norkyst]) lon = 5.0; lat = 64.0 o.set_config('seed:droplet_diameter_min_subsea', 0.0005) o.set_config('seed:droplet_diameter_max_subsea', 0.005) o.seed_elements(lon, lat, z=-350, time=reader_norkyst.start_time, density=1000) #o.set_config('vertical_mixing:TSprofiles', True) o.set_config('drift:vertical_mixing', True) o.set_config('vertical_mixing:timestep', 1) # s o.run(steps=3, time_step=300, time_step_output=300) z, status = o.get_property('z') self.assertAlmostEqual(z[-1,0], -134.27, 1) # After some rising
def test_seed_seafloor(self): o = OpenOil3D(loglevel=30) reader_norkyst = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') o.fallback_values['land_binary_mask'] = 0 o.fallback_values['x_wind'] = 0 o.fallback_values['y_wind'] = 0 o.fallback_values['x_sea_water_velocity'] = 0 o.fallback_values['y_sea_water_velocity'] = 0 o.add_reader([reader_norkyst]) lon = 4.5; lat = 62.0 o.seed_elements(lon, lat, z='seafloor', time=reader_norkyst.start_time, density=1000) o.set_config('processes:turbulentmixing', True) o.set_config('turbulentmixing:verticalresolution', 1) # m o.set_config('turbulentmixing:timestep', 1) # s o.run(steps=3, time_step=300, time_step_output=300) #o.plot_property('z') z, status = o.get_property('z') self.assertAlmostEqual(z[0,0], -151.7, 1) # Seeded at seafloor depth self.assertAlmostEqual(z[-1,0], -91.3, 1) # After some rising
def test_seed_outside_coverage(self): """Test seeding""" o = OpenOil(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(extent=[4, 6, 60, 64]) o.add_reader([landmask, norkyst]) o.set_config('environment:fallback:x_wind', 0) o.set_config('environment:fallback:y_wind', 0) o.set_config('seed:oil_type', 'SNORRE B 2004') 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 2004') with self.assertRaises(ValueError): o.run(steps=3, time_step=timedelta(minutes=15))
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) 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.is_latlong())
def test_vertical_profiles(self): norkyst3d = reader_netCDF_CF_generic.Reader( o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') lon = np.array([4.73]) lat = np.array([62.35]) variables = [ 'x_sea_water_velocity', 'x_sea_water_velocity', 'sea_water_temperature' ] x, y = norkyst3d.lonlat2xy(lon, lat) data = norkyst3d.get_variables(variables, time=norkyst3d.start_time, x=x, y=y, z=[0, -100]) self.assertEqual(data['z'][4], -25) self.assertEqual(data['z'][4], -25) self.assertAlmostEqual(data['sea_water_temperature'][:, 0, 0][7], 9.220000267028809)
def test_seed_below_seafloor(self): o = OpenOil(loglevel=20) reader_norkyst = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') o.add_reader([reader_norkyst]) o.set_config('environment:fallback:land_binary_mask', 0) o.set_config('environment:fallback:x_wind', 0) o.set_config('environment:fallback:y_wind', 0) o.set_config('environment:fallback:x_sea_water_velocity', 0) o.set_config('environment:fallback:y_sea_water_velocity', 0) lon = 4.5; lat = 62.0 o.set_config('seed:droplet_diameter_min_subsea', 0.0005) o.set_config('seed:droplet_diameter_max_subsea', 0.001) o.seed_elements(lon, lat, z=-5000, time=reader_norkyst.start_time, density=1000, oiltype='GENERIC BUNKER C') o.set_config('drift:vertical_mixing', True) o.set_config('vertical_mixing:timestep', 1) # s o.run(steps=3, time_step=300, time_step_output=300) z, status = o.get_property('z') self.assertAlmostEqual(z[0,0], -147.3, 1) # Seeded at seafloor depth self.assertAlmostEqual(z[-1,0], -132.5, 1) # After some rising
def test_stranding_roms(self): o = PelagicEggDrift(loglevel=20) 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.set_config('environment:fallback: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('drift:vertical_mixing', 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_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') basemap = reader_basemap_landmask.Reader(llcrnrlon=4, llcrnrlat=60, urcrnrlon=6, urcrnrlat=64, resolution='c', projection='merc') o.add_reader([basemap, norkyst]) o.fallback_values['x_wind'] = 0 o.fallback_values['y_wind'] = 0 o.seed_elements(5, 63, number=5, time=norkyst.start_time - 24 * timedelta(hours=24)) with self.assertRaises(ValueError): o.run(steps=3, time_step=timedelta(minutes=15))
def test_vertical_interpolation(self): norkyst3d = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') lon = np.array([4.73, 4.75]) lat = np.array([62.35, 62.30]) z = np.array([0, -33]) variables = ['x_sea_water_velocity', 'x_sea_water_velocity', 'sea_water_temperature'] # Call get_variables_interpolated which interpolates both in # space (horizontally, vertically) and then in time data, profiles = norkyst3d.get_variables_interpolated( variables, profiles=['sea_water_temperature'], profiles_depth = [-100, 0], time = norkyst3d.start_time + timedelta(seconds=900), lon=lon, lat=lat, z=z, block=True) # Check surface value self.assertEqual(data['sea_water_temperature'][0], profiles['sea_water_temperature'][0,0]) # Check interpolated temperature at 33 m depth self.assertAlmostEqual(data['sea_water_temperature'][1], 8.2648999309539786)
def test_reader_current_from_track(self): """Check if extrapolated currents are of expected value""" obslon = [3.1, 3.123456] obslat = [61.1, 61.132198] obstime = [datetime(2015, 11, 16, 0), datetime(2015, 11, 16, 6)] o = OceanDrift(loglevel=50) reader_wind = reader_netCDF_CF_generic.Reader( o.test_data_folder() + '16Nov2015_NorKyst_z_surface/arome_subset_16Nov2015.nc') reader_current = reader_current_from_track.Reader( obslon, obslat, obstime, wind_east=0, wind_north=0, windreader=reader_wind, wind_factor=0.018) self.assertAlmostEqual(reader_current.x_sea_water_velocity.data[0], 0.22070706, 8)
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(extent=[4.5, 6.0, 60.1, 60.4]) o1.add_reader([landmask]) o1.set_config('environment:fallback: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.set_config('environment:fallback: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_export_step_interval(self): # Export to file only at end o1 = OceanDrift(loglevel=20) norkyst = reader_netCDF_CF_generic.Reader(o1.test_data_folder() + '16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc') o1.add_reader(norkyst) o1.fallback_values['land_binary_mask'] = 0 o1.seed_elements(4.25, 60.2, radius=1000, number=10, time=norkyst.start_time) o1.run(steps=40) # Export to file during simulation o2 = OceanDrift(loglevel=20) o2.add_reader(norkyst) o2.fallback_values['land_binary_mask'] = 0 o2.seed_elements(4.25, 60.2, radius=1000, number=10, time=norkyst.start_time) o2.run(steps=40, export_buffer_length=6, outfile='export_step_interval.nc') self.assertIsNone(np.testing.assert_array_equal( o1.history['lon'].compressed(), o2.history['lon'].compressed())) # Finally check when steps is multiple of export_buffer_length o3 = OceanDrift(loglevel=20) o3.add_reader(norkyst) o3.fallback_values['land_binary_mask'] = 0 o3.seed_elements(4.25, 60.2, radius=1000, number=10, time=norkyst.start_time) o3.run(steps=42) # Export to file during simulation o4 = OceanDrift(loglevel=20) o4.add_reader(norkyst) o4.fallback_values['land_binary_mask'] = 0 o4.seed_elements(4.25, 60.2, radius=1000, number=10, time=norkyst.start_time) o4.run(steps=42, export_buffer_length=6, outfile='export_step_interval.nc') self.assertIsNone(np.testing.assert_array_equal( o3.history['lon'].compressed(), o4.history['lon'].compressed())) os.remove('export_step_interval.nc')
def test_openberg(self): """Check if weighting array is set correctly and if model returns expected positions""" o = OpenBerg(loglevel=50) 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(llcrnrlon=3., llcrnrlat=60., urcrnrlon=5., urcrnrlat=63.5) 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_seed_below_seafloor(self): o = OpenOil3D(loglevel=0) reader_norkyst = reader_netCDF_CF_generic.Reader( o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') o.add_reader([reader_norkyst]) o.fallback_values['land_binary_mask'] = 0 lon = 4.5 lat = 62.0 o.seed_elements(lon, lat, z=-5000, time=reader_norkyst.start_time, density=1000) o.set_config('processes:turbulentmixing', True) o.set_config('turbulentmixing:verticalresolution', 1) # m o.set_config('turbulentmixing:timestep', 1) # s o.set_config('input:spill:droplet_diameter_min_subsea', 0.005) o.set_config('input:spill:droplet_diameter_max_subsea', 0.005) o.run(steps=3, time_step=300, time_step_output=300) z, status = o.get_property('z') self.assertAlmostEqual(z[0, 0], -151.2, 1) # Seeded at seafloor depth self.assertAlmostEqual(z[-1, 0], -108.0, 2) # After some rising
def test_equiv_proj(test_data): """ These two projections are almost equivalent """ # Only used for projection reader_current = reader_netCDF_CF_generic.Reader( test_data + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') # Simulation SRS p = pyproj.Proj( '+proj=stere +lat_0=90 +lat_ts=60 +lon_0=70 +x_0=0 +y_0=0 +a=6371000 +rf=298.257223563 +units=m +no_defs' ) lon, lat = 4., 62. x, y = reader_current.lonlat2xy(lon, lat) # Single value u = [0.26724684, 0.2784934] ru, rv = reader_current.rotate_vectors(x, y, u[0], u[1], reader_current.proj, p) np.testing.assert_almost_equal(u[0], ru, decimal=3) np.testing.assert_almost_equal(u[1], rv, decimal=2) # Profile (array of vectors) u = np.array([ 0.26724684, 0.26311329, 0.25992924, 0.25909173, 0.25849965, 0.24982239, 0.25549856, 0.30730924, 0.29996288, 0.23423982, 0.23423982 ]) v = np.array([ 0.2784934, 0.26522627, 0.25113547, 0.2446443, 0.23454225, 0.16889542, 0.18744907, 0.13027644, 0.09087397, 0.19704318, 0.19704318 ]) ru, rv = reader_current.rotate_vectors(x, y, u, v, reader_current.proj, p) np.testing.assert_array_almost_equal(u, ru, decimal=3) np.testing.assert_array_almost_equal(v, rv, decimal=3)
def test_interpolation_3dArrays(self): """Test interpolation.""" reader = reader_netCDF_CF_generic.Reader( o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') # 100000 points within 50x50 pixels over sea (corner of domain) num_points = 1000 np.random.seed(0) # To get the same random numbers each time x = np.random.uniform(reader.xmin, reader.xmin + 800 * 50, num_points) y = np.random.uniform(reader.ymax - 800 * 50, reader.ymax, num_points) z = np.random.uniform(-200, 0, num_points) 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) b = ReaderBlock(data, interpolation_horizontal='nearest') env, prof = b.interpolate(x, y, z, variables, profiles=['sea_water_temperature'], profiles_depth=[-30, 0]) self.assertAlmostEqual(env['x_sea_water_velocity'][100], 0.075019, 3) self.assertAlmostEqual(prof['sea_water_temperature'][0, 11], 7.549999, 3) self.assertAlmostEqual(prof['sea_water_temperature'][-1, 11], 8.389999, 3) self.assertEqual(prof['z'][-1], b.z[-1])
def test_repeated(self): """Check that block can be used for interpolation to several sets of positions""" reader = reader_netCDF_CF_generic.Reader( o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') # 100 points within 50x50 pixels over sea (corner of domain) num_points = 100 np.random.seed(0) # To get the same random numbers each time x = np.random.uniform(reader.xmin, reader.xmin + 800 * 50, num_points) y = np.random.uniform(reader.ymax - 800 * 50, reader.ymax, num_points) z = np.random.uniform(-200, 0, num_points) 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) b = ReaderBlock(data, interpolation_horizontal='nearest') env, prof = b.interpolate(x, y, z, 'sea_water_temperature') x2 = x[20:30] y2 = y[20:30] z2 = z[20:30] env2, prof2 = b.interpolate(x2, y2, z2, 'sea_water_temperature') env3, prof3 = b.interpolate(x, y, z, 'sea_water_temperature') self.assertEqual(env['sea_water_temperature'][0], env3['sea_water_temperature'][0]) self.assertEqual(env['sea_water_temperature'][20], env2['sea_water_temperature'][0])
def test_environment_mapping(test_data): # Wind from NE r = reader_constant.Reader({ 'wind_speed': 5, 'wind_from_direction': 45, 'land_binary_mask': 0 }) o = OceanDrift(loglevel=50) o.set_config('general:use_auto_landmask', False) o.add_reader(r) o.seed_elements(lon=4, lat=60, time=datetime.now()) o.run(steps=15) np.testing.assert_almost_equal(o.elements.lon, 3.932, 3) np.testing.assert_almost_equal(o.elements.lat, 59.966, 3) # Wind from SW r = reader_constant.Reader({ 'wind_speed': 5, 'wind_from_direction': 225, 'land_binary_mask': 0 }) o = OceanDrift(loglevel=50) o.set_config('general:use_auto_landmask', False) o.add_reader(r) o.seed_elements(lon=4, lat=60, time=datetime.now()) o.run(steps=15) np.testing.assert_almost_equal(o.elements.lon, 4.068, 3) np.testing.assert_almost_equal(o.elements.lat, 60.034, 3) # land_binary_mask mapped from sea_floor_depth_below_sea_level r = reader_netCDF_CF_generic.Reader( o.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') assert 'land_binary_mask' not in r.derived_variables # Disabled by default r.activate_environment_mapping('land_binary_mask_from_ocean_depth') assert 'land_binary_mask' in r.derived_variables
def test_vertical_mixing(self): # Export to file only at end o1 = PelagicEggDrift(loglevel=20) # Profiles and vertical mixing norkyst = reader_netCDF_CF_generic.Reader( o1.test_data_folder() + '14Jan2016_NorKyst_z_3d/NorKyst-800m_ZDEPTHS_his_00_3Dsubset.nc') o1.add_reader([norkyst]) o1.fallback_values['x_wind'] = 8 o1.fallback_values['land_binary_mask'] = 0 o1.seed_elements(4.1, 63.3, radius=1000, number=100, time=norkyst.start_time) o1.set_config('turbulentmixing:timestep', 20.) # seconds o1.set_config('turbulentmixing:verticalresolution', 1.) # m o1.run(steps=20, time_step=300, time_step_output=1800, export_buffer_length=10, outfile='verticalmixing.nc') self.assertAlmostEqual(o1.history['z'].min(), -31.9, 1) self.assertAlmostEqual(o1.history['z'].max(), 0.0, 1) os.remove('verticalmixing.nc')
""" Openoil ================================== """ from datetime import datetime, timedelta from opendrift.readers import reader_netCDF_CF_generic from opendrift.models.openoil import OpenOil o = OpenOil(loglevel=20, weathering_model='noaa') print(o.oiltypes) # Print available oil types #%% Add forcing date # Arome atmospheric model reader_arome = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '16Nov2015_NorKyst_z_surface/arome_subset_16Nov2015.nc') # Norkyst ocean model reader_norkyst = reader_netCDF_CF_generic.Reader(o.test_data_folder() + '16Nov2015_NorKyst_z_surface/norkyst800_subset_16Nov2015.nc') o.add_reader([reader_norkyst, reader_arome]) #%% # Seeding some particles time = reader_arome.start_time oil_type = 'GULLFAKS, EXXON' oil_type = 'ARABIAN MEDIUM, API' oil_type = 'ALGERIAN CONDENSATE' o.seed_elements(lon=4.9, lat=60.1, radius=3000, number=2000, time=time, z=0, oil_type=oil_type) #%%
""" Wind blow model ================================== """ from opendrift.readers import reader_netCDF_CF_generic from opendrift.models.windblow import WindBlow o = WindBlow(loglevel=20) # Set loglevel to 0 for debug information #%% # Example of elements blowing with the wind, also over land #reader_arome = reader_netCDF_CF_generic.Reader('https://thredds.met.no/thredds/dodsC/mepslatest/meps_lagged_6_h_latest_2_5km_latest.nc') reader_arome = reader_netCDF_CF_generic.Reader( o.test_data_folder() + '2Feb2016_Nordic_sigma_3d/AROME_MetCoOp_00_DEF.nc_20160202_subset') o.add_reader([reader_arome]) #%% # Seeding some particles lat = 68.5 lon = 16.0 # Lofoten o.seed_elements(lon, lat, radius=5000, number=1000, time=reader_arome.start_time) #%%
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') basemap = reader_basemap_landmask.Reader(llcrnrlon=4.5, llcrnrlat=60.0, urcrnrlon=5.2, urcrnrlat=60.5, resolution='i', projection='merc') o1.add_reader([basemap, 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([basemap, 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.assertItemsEqual(o1.history['lon'][:, 24].compressed(), o2.history['lon'][:, 12].compressed()) self.assertItemsEqual(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.assertItemsEqual(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_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())
import numpy as np import matplotlib.pyplot as plt import cartopy.crs as ccrs import cartopy.feature as cfeature from opendrift.readers import reader_netCDF_CF_generic from opendrift.readers import reader_ROMS_native from opendrift.readers import reader_shape from opendrift.models.oceandrift import OceanDrift o = OceanDrift(loglevel=20) # Set loglevel to 0 for debug information o.max_speed = 3 # This example works better using hourly input from Thredds than the daily data from test folder reader_nordic = reader_netCDF_CF_generic.Reader( 'https://thredds.met.no/thredds/dodsC/sea/nordic4km/zdepths1h/aggregate_be' ) #%% # Use shapes from Cartopy for tests. These shapefiles are less acurate than those # provided by the GSHHS dataset (available though the reader_global_landmask reader). import cartopy.io.shapereader as shpreader shpfilename = shpreader.natural_earth(resolution='110m', category='cultural', name='admin_0_countries') reader_natural = reader_shape.Reader.from_shpfiles(shpfilename) #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_natural, reader_nordic]) o.set_config('general:use_auto_landmask', False)