Merge pull request #1637 from knutfrode/dev

[run-ex] Conditional mechanism now also used to decide if previous va…

Author: knutfrode

opendrift/elements/elements.py

@@ -73,12 +73,18 @@ class LagrangianArray:
                  'standard_name': 'longitude',
                  'long_name': 'longitude',
                  'seed': False,
+                 'store_previous_if': (
+                    ('general:coastline_action', 'in', ['stranding', 'previous']), 'or',
+                    ('general:seafloor_action', 'in', ['previous'])),
                  'axis': 'X'}),
         ('lat', {'dtype': np.float32,
                  'units': 'degrees_north',
                  'standard_name': 'latitude',
                  'long_name': 'latitude',
                  'seed': False,
+                 'store_previous_if': (
+                    ('general:coastline_action', 'in', ['stranding', 'previous']), 'or',
+                    ('general:seafloor_action', 'in', ['previous'])),
                  'axis': 'Y'}),
         ('z', {'dtype': np.float32,
                    'units': 'm',

opendrift/models/basemodel/__init__.py

@@ -472,8 +472,8 @@ def __init__(self,
 
         # Add default element properties to config
         c = {}
-        for p in self.ElementType.variables:
-            v = self.ElementType.variables[p]
+        for p in self.elements.variables:
+            v = self.elements.variables[p]
             if 'seed' in v and v['seed'] is False:
                 continue  # Properties which may not be provided by user
             c['seed:%s' % p] = {
@@ -1717,11 +1717,22 @@ def run(self,
         ###################################################################################
         for vn, var in self.required_variables.copy().items():
             if 'skip_if' in var:
-                skip = self.evaluate_conditional(*var['skip_if'])
+                skip = evaluate_conditional(*var['skip_if'], self)
                 if skip is True:
                     logger.info(f'Skipping environment variable {vn} because of condition {var["skip_if"]}')
                     self.required_variables.pop(vn)
 
+        ####################################################################################
+        # Evaluate conditionals to determine if previous element properties shall be stored
+        ####################################################################################
+        for en, prop in self.elements.variables.copy().items():
+            if 'store_previous_if' in prop:
+                store = evaluate_conditional(*prop['store_previous_if'], self)
+                if store is True:
+                    logger.info(f'Storing previous values of element property {en} because of condition {prop["store_previous_if"]}')
+                    self.elements.variables[en]['store_previous'] = True
+                del self.elements.variables[en]['store_previous_if']  # To avoid writing this to netCDF metadata
+
         ########################
         # Simulation time step
         ########################
@@ -1878,7 +1889,7 @@ def run(self,
 
         element_vars = {}
         default_dtype = np.float32  # Allows NaN (in contrast to np.int)
-        for varname, attrs in self.ElementType.variables.items():
+        for varname, attrs in self.elements.variables.items():
             if varname == 'ID' or (self.export_variables is not None and
                                    varname not in self.export_variables):
                 continue
@@ -1923,7 +1934,7 @@ def run(self,
 
         if self.origin_marker is not None and 'origin_marker' in self.result.data_vars:
             self.result['origin_marker'] = self.result.origin_marker.assign_attrs(
-                {'flag_values': np.arange(len(self.origin_marker)).astype(self.ElementType.variables['origin_marker']['dtype']),
+                {'flag_values': np.arange(len(self.origin_marker)).astype(self.elements.variables['origin_marker']['dtype']),
                  'flag_meanings': " ".join(self.origin_marker.values())
                 })
 
@@ -1943,11 +1954,6 @@ def run(self,
                                           self.elements_scheduled.lat)
             self.timer_end('preparing main loop:moving elements to ocean')
 
-        # TODO: adjust store_previous according to config, later with upcming conditional mechanism
-        if self.get_config('general:coastline_action', None) in ['stranding', 'previous']:
-            logger.info('Storing previous position of elements for coastline interaction')
-            self.elements.variables['lon']['store_previous'] = True
-            self.elements.variables['lat']['store_previous'] = True
 
         # Make Xarray datasets to store environment variables and element properties from previous time step
         environment_previous = [vn for vn, v in self.required_variables.items()
@@ -2211,7 +2217,7 @@ def state_to_buffer(self, final=False):
                 logger.debug(f'Truncating buffer from {numtimes_before} to {numtimes_after} times')
 
             # Final update some variable attributes
-            status_dtype = self.ElementType.variables['status']['dtype']
+            status_dtype = self.elements.variables['status']['dtype']
             self.result['status'] = self.result.status.assign_attrs(
                 {'valid_range': np.array((0, len(self.status_categories) - 1)).astype(status_dtype),
                  'flag_values': np.array(np.arange(len(self.status_categories))).astype(status_dtype),
@@ -4676,33 +4682,47 @@ def gui_postproc(self):
         '''To be overloaded by subclasses'''
         pass
 
-    def evaluate_conditional(self, key, operator, value):
-        """Evaluate a condition as True or False
+    def _evaluate_key(self, key):
+        # Presently assuming that key is a config key
+        return self.get_config(key, 'not_implemented')
 
-        This can be used to:
-        - skip required_variables that are not required, based on config setting
-        - store previous value of element property or environment variable, based on config setting
-        - disable a config setting based on another setting (for dynamic menus)
+def evaluate_conditional(key, operator, value, self=None):
+    """Evaluate a condition as True or False
 
-        key: config key string
-        operator: one from operator_map below
-        value: the provided value to be matched with operator against actual config setting
+    This can be used to:
+    - skip required_variables that are not required, based on config setting
+    - store previous value of element property or environment variable, based on config setting
+    - disable a config setting based on another setting (for dynamic menus)
 
-        Returns: True or False
-        """
+    key: e.g. config key/setting as string
+    operator: relation between key and value, one from operator_map below
+    value: the provided value to be matched with operator against actual key
 
-        operator_map = { 
-            '==': lambda x, y: x == y,
-            '!=': lambda x, y: x != y,
-            '<': lambda x, y: x < y,
-            '<=': lambda x, y: x <= y,
-            '>': lambda x, y: x > y,
-            '>=': lambda x, y: x >= y,
-            'is': lambda x, y: x is y,
-            'is not': lambda x, y: x is not y,
-        }
-        
-        # Presently assuming that key is a config key
-        key = self.get_config(key)
+    Returns: True or False
+    """
 
-        return operator_map[operator](key, value)
+    operator_map = { 
+        '==': lambda x, y: x == y,
+        '!=': lambda x, y: x != y,
+        '<': lambda x, y: x < y,
+        '<=': lambda x, y: x <= y,
+        '>': lambda x, y: x > y,
+        '>=': lambda x, y: x >= y,
+        'in': lambda x, y: x in y,
+        'is': lambda x, y: x is y,
+        'is not': lambda x, y: x is not y,
+        'or': lambda x, y: x or y,
+        'and': lambda x, y: x and y,
+    }
+    
+    if isinstance(key, tuple):
+        key = evaluate_conditional(key[0], key[1], key[2], self)
+
+    if self is not None and not isinstance(key, bool):
+        # If a OpenDrift instance is provided, this will evaluate the key, e.g. with get_config
+        key = self._evaluate_key(key)
+    
+    if isinstance(value, tuple):
+        value = evaluate_conditional(value[0], value[1], value[2], self)
+
+    return operator_map[operator](key, value)

tests/models/test_basemodel.py

@@ -10,7 +10,7 @@
 def test_logging(tmpdir, capsys):
     # Accepting small variations in log output,
     # depending on machine, and from which folder test is run
-    accepted = (219, 222)
+    accepted = (220, 223)
 
     # Logging to console
     logfile = None
@@ -171,3 +171,62 @@ def test_clone():
                             time=datetime(2015, 1, 1))
     c.run(steps=2, time_step=-10*3600, time_step_output=-10*3600)
 
+def test_conditionals():
+    from opendrift.models.basemodel import evaluate_conditional
+    assert evaluate_conditional(True, 'is', True) is True
+    assert evaluate_conditional(1, '==', 1) is True
+    assert evaluate_conditional(1, '==', 2) is False
+    assert evaluate_conditional('previous', '==', 'previous') is True
+    assert evaluate_conditional('previous', '==', 'stranding') is False
+    assert evaluate_conditional(1, '>', 0) is True
+    assert evaluate_conditional(1, '<', 0) is False
+    # Nested conditionals
+    assert evaluate_conditional((1, '==', 1), 'is', True) is True
+    assert evaluate_conditional((1, '==', 1), 'is', False) is False
+    assert evaluate_conditional((1, '==', 0), 'is', False) is True
+    assert evaluate_conditional((1, '==', 1), 'and', (1, '==', 1)) is True
+    assert evaluate_conditional((1, '==', 1), 'and', (0, '==', 1)) is False
+    assert evaluate_conditional((1, '==', 1), 'or', (0, '==', 1)) is True
+    # Double nesting
+    assert evaluate_conditional((1, '==', 1), 'or', ((1, '==', 1), 'is', (0, '==', 0))) is True
+
+    # Testing with a model instance
+    o = OceanDrift(loglevel=50)
+    o.set_config('general:coastline_action', 'stranding')
+    o.set_config('general:seafloor_action', 'previous')
+    assert evaluate_conditional('general:coastline_action', '==', 'stranding', o) is True
+    assert evaluate_conditional('general:coastline_action', '==', 'previous', o) is False
+    assert evaluate_conditional(('general:coastline_action', '==', 'stranding'), 'and',
+                                ('general:seafloor_action', '==', 'previous'), o) is True
+    assert evaluate_conditional(('general:coastline_action', '==', 'stranding'), 'and',
+                                ('general:seafloor_action', '==', 'wrong'), o) is False
+    assert evaluate_conditional(('general:coastline_action', '==', 'stranding'), 'or',
+                                ('general:seafloor_action', '==', 'wrong'), o) is True
+    assert evaluate_conditional(('general:coastline_action', '==', 'wrong'), 'or',
+                                ('general:seafloor_action', '==', 'wrong'), o) is False
+    
+    # Perform a simulation, to check if previous position is stored, based on given conditionals
+    o = OceanDrift(loglevel=50)
+    o.set_config('general:coastline_action', 'stranding')
+    o.set_config('general:seafloor_action', 'previous')
+    o.set_config('environment:constant:land_binary_mask', 0)
+    o.seed_elements(lon=4, lat=60, number=5, time=datetime.now())
+    o.run(steps=1)
+    assert 'lon' in o.elements_previous
+
+    # Check that either coastline or seafloor actions require storing previous positions
+    o = OceanDrift(loglevel=50)
+    o.set_config('general:coastline_action', 'none')     # does not require storing previous positions
+    o.set_config('general:seafloor_action', 'previous')  # requires storing previous positions
+    o.set_config('environment:constant:land_binary_mask', 0)
+    o.seed_elements(lon=4, lat=60, number=5, time=datetime.now())
+    o.run(steps=1)
+    assert 'lon' in o.elements_previous
+
+    o = OceanDrift(loglevel=50)
+    o.set_config('general:coastline_action', 'none')
+    o.set_config('general:seafloor_action', 'deactivate')
+    o.set_config('environment:constant:land_binary_mask', 0)
+    o.seed_elements(lon=4, lat=60, number=5, time=datetime.now())
+    o.run(steps=1)
+    assert o.elements_previous is None