Merge pull request #1616 from knutfrode/dev

[run-ex] Further cleaning, and removing obsolete methods sea_floor_de…

Author: knutfrode

examples/example_current_from_drifter.py

@@ -41,15 +41,14 @@
 # Finally running simulation
 o.run(end_time=r.end_time, time_step=r.time_step)
 
-o.animation(buffer=.01, fast=True, drifter={'time': driftertimes, 'lon': drifterlons, 'lat': drifterlats,
-    'label': 'CODE Drifter', 'color': 'b', 'linewidth': 2, 'markersize': 40})
+drifter={'time': driftertimes, 'lon': drifterlons, 'lat': drifterlats,
+         'label': 'CODE Drifter', 'color': 'b', 'linewidth': 2, 'markersize': 40}
+o.animation(buffer=.01, fast=True, drifter=drifter)
 
 #%%
 # .. image:: /gallery/animations/example_current_from_drifter_0.gif
 
 #%%
 # Drifter track is shown in red, and simulated trajectories are shown in gray. Oil spill is displaced relative to drifter, but drifter current is assumed to be spatially homogeneous.
-o.plot(buffer=.01, fast=True, drifter={
-        'lon': drifterlons, 'lat': drifterlats,
-        'time': driftertimes, 'linewidth': 2, 'color': 'r'})
+o.plot(buffer=.01, fast=True, drifter=drifter)
 

opendrift/models/basemodel/__init__.py

@@ -621,15 +621,18 @@ def store_previous_variables(self):
 
     def interact_with_coastline(self, final=False):
         """Coastline interaction according to configuration setting"""
+
         if self.num_elements_active() == 0:
             return
-        i = self.get_config('general:coastline_action')
-        coastline_approximation_precision = self.get_config('general:coastline_approximation_precision')
-        if not hasattr(self, 'environment') or not hasattr(
-                self.environment, 'land_binary_mask'):
+        if not hasattr(self, 'environment') or not hasattr(self.environment, 'land_binary_mask'):
             return
+
+        i = self.get_config('general:coastline_action')
         if i == 'none':  # Do nothing
             return
+
+        coastline_approximation_precision = self.get_config('general:coastline_approximation_precision')
+
         if final is True:  # Get land_binary_mask for final location
             en, en_prof, missing = \
                 self.env.get_environment(['land_binary_mask'],
@@ -706,15 +709,17 @@ def interact_with_coastline(self, final=False):
 
     def interact_with_seafloor(self):
         """Seafloor interaction according to configuration setting"""
+
         if self.num_elements_active() == 0:
             return
         if 'sea_floor_depth_below_sea_level' not in self.env.priority_list:
             return
 
-        # The shape of these is different than the original arrays
-        # because it is for active drifters
-        sea_floor_depth = self.sea_floor_depth()
-        sea_surface_height = self.sea_surface_height()
+        sea_floor_depth = self.environment.sea_floor_depth_below_sea_level
+        if 'sea_surface_height' in self.required_variables:
+            sea_surface_height = self.environment.sea_surface_height
+        else:
+            sea_surface_height = 0
 
         # Check if any elements are below sea floor
         # But remember that the water column is the sea floor depth + sea surface height
@@ -2756,9 +2761,9 @@ def plot_timestep(i):
 
             if drifter is not None:
                 for drnum, dr in enumerate(drifter):
-                    drifter_pos[drnum].set_offsets(np.c_[dr['x'][i],
-                                                         dr['y'][i]])
-                    drifter_line[drnum].set_data(dr['x'][0:i+1], dr['y'][0:i+1])
+                    drifter_pos[drnum].set_offsets(np.c_[dr['lon'][i],
+                                                         dr['lat'][i]])
+                    drifter_line[drnum].set_data(dr['lon'][0:i+1], dr['lat'][0:i+1])
                     ret.append(drifter_line[drnum])
                     ret.append(drifter_pos[drnum])
 
@@ -2982,12 +2987,12 @@ def plot_timestep(i):
                 sts = (self.result.time - self.result.time[0]) / np.timedelta64(1, 's')
                 dr_times = np.array(dr['time'], dtype=self.result.time.dtype)
                 dts = (dr_times-dr_times[0]) / np.timedelta64(1, 's')
-                dr['x'] = np.interp(sts, dts, dr['lon'])
-                dr['y'] = np.interp(sts, dts, dr['lat'])
-                dr['x'][sts < dts[0]] = np.nan
-                dr['x'][sts > dts[-1]] = np.nan
-                dr['y'][sts < dts[0]] = np.nan
-                dr['y'][sts > dts[-1]] = np.nan
+                dr['lon'] = np.interp(sts, dts, dr['lon'])
+                dr['lat'] = np.interp(sts, dts, dr['lat'])
+                dr['lon'][sts < dts[0]] = np.nan
+                dr['lon'][sts > dts[-1]] = np.nan
+                dr['lat'][sts < dts[0]] = np.nan
+                dr['lat'][sts > dts[-1]] = np.nan
                 dlabel = dr['label'] if 'label' in dr else 'Drifter'
                 dcolor = dr['color'] if 'color' in dr else 'r'
                 dlinewidth = dr['linewidth'] if 'linewidth' in dr else 2
@@ -3764,22 +3769,22 @@ def _plot_drifter(self, ax, gcrs, drifter):
         '''Plot provided trajectory along with simulated'''
         time = np.array(drifter['time'], dtype=self.result.time.dtype)
         i = np.where((time >= self.result.time[0].values) & (time <= self.result.time[-1].values))[0]
-        x, y = (np.atleast_1d(drifter['lon'])[i],
+        lon, lat = (np.atleast_1d(drifter['lon'])[i],
                 np.atleast_1d(drifter['lat'])[i])
         dlabel = drifter['label'] if 'label' in drifter else 'Drifter'
         dcolor = drifter['color'] if 'color' in drifter else 'r'
         dlinewidth = drifter['linewidth'] if 'linewidth' in drifter else 2
         dzorder = drifter['zorder'] if 'zorder' in drifter else 10
 
-        ax.plot(x,
-                y,
+        ax.plot(lon,
+                lat,
                 linewidth=dlinewidth,
                 color=dcolor,
                 transform=self.crs_lonlat,
                 label=dlabel,
                 zorder=dzorder)
-        ax.plot(x[0], y[0], 'ok', transform=self.crs_lonlat)
-        ax.plot(x[-1], y[-1], 'xk', transform=self.crs_lonlat)
+        ax.plot(lon[0], lat[0], 'ok', transform=self.crs_lonlat)
+        ax.plot(lon[-1], lat[-1], 'xk', transform=self.crs_lonlat)
 
     def get_map_background(self, ax, background, crs, time=None):
         # Get background field for plotting on map or animation

opendrift/models/physics_methods.py

@@ -954,47 +954,6 @@ def solar_elevation(self):
         '''Solar elevation at present time and position of active elements.'''
         return solar_elevation(self.time, self.elements.lon, self.elements.lat)
 
-    def sea_floor_depth(self):
-        '''Sea floor depth (positive) for presently active elements'''
-
-        if hasattr(self, 'environment') and \
-                hasattr(self.environment, 'sea_floor_depth_below_sea_level'):
-            if len(self.environment.sea_floor_depth_below_sea_level) == \
-                    self.num_elements_active():
-                sea_floor_depth = \
-                    self.environment.sea_floor_depth_below_sea_level
-        if 'sea_floor_depth' not in locals():
-            env, env_profiles, missing = \
-                self.env.get_environment(['sea_floor_depth_below_sea_level'],
-                                     time=self.time, lon=self.elements.lon,
-                                     lat=self.elements.lat,
-                                     z=self.elements.z, profiles=None)
-            sea_floor_depth = \
-                env['sea_floor_depth_below_sea_level'].astype('float32')
-        return sea_floor_depth
-
-    def sea_surface_height(self):
-        '''Sea surface height (positive/negative) for presently active elements'''
-
-        if 'sea_surface_height' not in self.required_variables:
-            return 0
-        if hasattr(self, 'environment') and \
-                hasattr(self.environment, 'sea_surface_height'):
-            if len(self.environment.sea_surface_height) == \
-                    self.num_elements_active():
-                sea_surface_height = \
-                    self.environment.sea_surface_height
-        if 'sea_surface_height' not in locals():
-            env, env_profiles, missing = \
-                self.env.get_environment(['sea_surface_height'],
-                                     time=self.time, lon=self.elements.lon,
-                                     lat=self.elements.lat,
-                                     z=self.elements.z, profiles=None)
-            sea_surface_height = \
-                env['sea_surface_height'].astype('float32')
-        return sea_surface_height
-
-
 def wind_drag_coefficient(windspeed):
     '''Large and Pond (1981), J. Phys. Oceanog., 11, 324-336.'''
     Cd = 0.0012*np.ones(len(windspeed))
@@ -1011,7 +970,7 @@ def windspeed_from_stress_polyfit(wind_stress):
     return p(wind_stress)
 
 
-def declination(time):
+def solar_declination(time):
     '''Solar declination in degrees.'''
     try:
         day_of_year = time.timetuple().tm_yday
@@ -1052,7 +1011,7 @@ def hour_angle(time, longitude):
 
 def solar_elevation(time, longitude, latitude):
     '''Solar elevation in degrees.'''
-    d_rad = np.deg2rad(declination(time))
+    d_rad = np.deg2rad(solar_declination(time))
     h = hour_angle(time, longitude)
     solar_elevation = np.rad2deg(np.arcsin(
         np.sin(np.deg2rad(latitude))*np.sin(d_rad) +