Issue 115 raise an error if input parameter has a wrong numerical value

smoderp2d/exceptions.py

@@ -42,6 +42,28 @@ def __init__(self):
 class ConfigError(Exception):
     pass
 
+class SmallParameterValue(ConfigError):
+    """ Exception raised if a parameter reaches a wrong numeric value
+    """
+    def __init__(self,param,value,limit):
+        self.msg = "Parameter '{}' has low value ({} < {}).".format(
+                param,value,limit)
+        super().__init__(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+class LargeParameterValue(ConfigError):
+    """ Exception raised if a parameter reaches a wrong numeric value
+    """
+    def __init__(self,param,value,limit):
+        self.msg = "Parameter '{}' has a wrong value ({} > {}).".format(
+                param,value,limit)
+        super().__init__(self.msg)
+
+    def __str__(self):
+        return self.msg
+
 class WrongParameterValue(ConfigError):
     """ Exception raised if a parameter reaches a wrong numeric value
     """

smoderp2d/providers/base/data_preparation.py

@@ -5,6 +5,8 @@
 import smoderp2d.processes.rainfall as rainfall
 
 from smoderp2d.providers.base import Logger
+from smoderp2d.exceptions import SmallParameterValue
+from smoderp2d.exceptions import LargeParameterValue
 
 class PrepareDataBase(object):
     def __init__(self, writter):
@@ -92,17 +94,34 @@ def run(self):
 
         # build numpy array from selected attributes
         all_attrib = self._get_attrib(sfield, intersect)
+
+        # check Ks and S for infiltraiton
+        self._check_parameter_value('Ks', all_attrib[0], [0,1])
+        self._check_parameter_value('S', all_attrib[1], [0,1])
+
         self.data['mat_inf_index'], self.data['combinatIndex'] = \
             self._get_inf_combinat_index(self.data['r'], self.data['c'],
                                          all_attrib[0], all_attrib[1])
         #Logger.progress(30)
 
         self.data['mat_n'] = all_attrib[2]
+        self._check_parameter_value('n', self.data['mat_n'], [0,10])
+
         self.data['mat_pi'] = all_attrib[3]
+        self._check_parameter_value('pi', self.data['mat_pi'], [0,10])
+
         self.data['mat_ppl'] = all_attrib[4]
+        self._check_parameter_value('ppl', self.data['mat_ppl'], [0,1])
+
         self.data['mat_reten'] = all_attrib[5]
+        # TODO check extremely low valus in testing dataset
+        # self._check_parameter_value('reten', self.data['mat_reten'], [0,50])
+
         self.data['mat_b'] = all_attrib[6]
+        self._check_parameter_value('b', self.data['mat_b'], [1,2.5])
+
 
+
         self.data['mat_nan'], self.data['mat_slope'], self.data['mat_dem'] = \
             self._get_mat_nan(self.data['r'], self.data['c'],
                               self.data['NoDataValue'], self.data['mat_slope'],
@@ -113,13 +132,21 @@ def run(self):
         self._get_array_points()
 
         # build a/aa arrays
+        self._check_parameter_value('X', all_attrib[7], [1,200])
+        self._check_parameter_value('Y', all_attrib[8], [0.01,1])
+
         self.data['mat_a'], self.data['mat_aa'] = self._get_a(
             all_attrib[2], all_attrib[7], all_attrib[8], self.data['r'],
             self.data['c'], self.data['NoDataValue'], self.data['mat_slope']
         )
         #Logger.progress(40)
 
         Logger.info("Computing critical level...")
+
+        # check the critical tension and celocity TODO
+        # self._check_parameter_value('xxx', all_attrib[9], [1,200])
+        # self._check_parameter_value('xxx', all_attrib[10], [0.01,1])
+
         self.data['mat_hcrit'] = self._get_crit_water(
             self.data['mat_b'], all_attrib[9], all_attrib[10], self.data['r'],
             self.data['c'], self.data['mat_slope'],
@@ -155,6 +182,12 @@ def run(self):
 
         return self.data
 
+    def _check_parameter_value(self, name, arr, range_):
+        min_ = (np.nanmin(arr))
+        max_ = (np.nanmax(arr))
+        if (range_[0] > min_) : raise SmallParameterValue(name, min_, range_[0])
+        if (range_[1] < max_) : raise LargeParameterValue(name, max_, range_[1])
+
     def _set_output_data(self):
         """
         Creates dictionary to which model parameters are computed.