Rename modules. Implement proper measures.

Author: gabrielaznar

climada/entity/measures/base.py

@@ -1,245 +1,127 @@
 """
-Define MeasureSet class.
+Define Measure class.
 """
 
-__all__ = ['MeasureSet',
-           'FILE_EXT']
+__all__ = ['Measure']
 
-import os
 import copy
 import logging
+import numpy as np
 
-from climada.entity.measures.measure import Measure
-from climada.entity.measures.source import READ_SET
-from climada.util.files_handler import to_list, get_file_names
-from climada.entity.tag import Tag
+from climada.entity.impact_funcs.impact_func_set import ImpactFuncSet
+import climada.util.checker as check
 
 LOGGER = logging.getLogger(__name__)
 
-FILE_EXT = {'.mat':  'MAT',
-            '.xls':  'XLS',
-            '.xlsx': 'XLS'
-           }
-""" Supported files format to read from """
-
-class MeasureSet(object):
-    """Contains measures of type Measure. Loads from
-    files with format defined in FILE_EXT.
+class Measure():
+    """Contains the definition of one measure.
 
     Attributes:
-        tag (Tag): information about the source data
-        _data (dict): cotains Measure classes. It's not suppossed to be
-            directly accessed. Use the class methods instead.
+        name (str): name of the action
+        color_rgb (np.array): integer array of size 3. Gives color code of
+            this measure in RGB
+        cost (float): cost
+        hazard_freq_cutoff (float): hazard frequency cutoff
+        hazard_intensity (tuple): parameter a and b
+        mdd_impact (tuple): parameter a and b of the impact over the mean
+            damage (impact) degree
+        paa_impact (tuple): parameter a and b of the impact over the
+            percentage of affected assets (exposures)
+        risk_transf_attach (float): risk transfer attach
+        risk_transf_cover (float): risk transfer cover
     """
 
-    def __init__(self, file_name='', description=''):
-        """Fill values from file, if provided.
-
-        Parameters:
-            file_name (str or list(str), optional): absolute file name(s) or
-                folder name containing the files to read
-            description (str or list(str), optional): one description of the
-                data or a description of each data file
-
-        Raises:
-            ValueError
-
-        Examples:
-            Fill MeasureSet with values and check consistency data:
-
-            >>> act_1 = Measure()
-            >>> act_1.name = 'Seawall'
-            >>> act_1.color_rgb = np.array([0.1529, 0.2510, 0.5451])
-            >>> act_1.hazard_intensity = (1, 0)
-            >>> act_1.mdd_impact = (1, 0)
-            >>> act_1.paa_impact = (1, 0)
-            >>> meas = MeasureSet()
-            >>> meas.add_Measure(act_1)
-            >>> meas.tag.description = "my dummy MeasureSet."
-            >>> meas.check()
-
-            Read measures from file and checks consistency data:
-
-            >>> meas = MeasureSet(ENT_TEMPLATE_XLS)
-        """
-        self.clear()
-        if file_name != '':
-            self.read(file_name, description)
-
-    def clear(self):
-        """Reinitialize attributes."""
-        self.tag = Tag()
-        self._data = dict() # {name: Measure()}
+    def __init__(self):
+        """ Empty initialization."""
+        self.name = ''
+        self.haz_type = ''
+        self.color_rgb = np.array([0, 0, 0])
+        self.cost = 0
 
-    def add_measure(self, meas):
-        """Add an Measure.
-
-        Parameters:
-            meas (Measure): Measure instance
-
-        Raises:
-            ValueError
-        """
-        if not isinstance(meas, Measure):
-            LOGGER.error("Input value is not of type Measure.")
-            raise ValueError
-        if meas.name == 'NA':
-            LOGGER.error("Input Measure's name not set.")
-            raise ValueError
-        self._data[meas.name] = meas
-
-    def remove_measure(self, name=None):
-        """Remove Measure with provided name. Delete all Measures if no input
-        name
-
-        Parameters:
-            name (str, optional): measure name
-
-        Raises:
-            ValueError
-        """
-        if name is not None:
-            try:
-                del self._data[name]
-            except KeyError:
-                LOGGER.warning('No Measure with name %s.', name)
-        else:
-            self._data = dict()
+        # related to change in hazard
+        self.hazard_set = ''
+        self.hazard_freq_cutoff = 0
 
-    def get_measure(self, name=None):
-        """Get Measure with input name. Get all if no name provided.
+        # related to change in exposures
+        self.exposures_set = ''
+        self.exp_region_id = -1
 
-        Parameters:
-            name (str, optional): measure name
+        # related to change in impact functions
+        self.hazard_inten_imp = () # parameter a and b
+        self.mdd_impact = () # parameter a and b
+        self.paa_impact = () # parameter a and b
+        self.imp_fun_map = ''
 
-        Returns:
-            list(Measure)
-        """
-        if name is not None:
-            try:
-                return self._data[name]
-            except KeyError:
-                return list()
-        else:
-            return list(self._data.values())
-
-    def get_names(self):
-        """Get all Measure names"""
-        return list(self._data.keys())
-
-    def num_measures(self):
-        """Get number of measures contained """
-        return len(self._data.keys())
+        # risk transfer
+        self.risk_transf_attach = 0
+        self.risk_transf_cover = 0
 
     def check(self):
-        """Check instance attributes.
+        """ Check consistent instance data.
 
         Raises:
             ValueError
         """
-        for act_name, act in self._data.items():
-            if (act_name != act.name) | (act.name == 'NA'):
-                raise ValueError('Wrong Measure.name: %s != %s' %\
-                                (act_name, act.name))
-            act.check()
-
-    def read(self, files, descriptions='', var_names=None):
-        """Read and check MeasureSet.
+        check.size(3, self.color_rgb, 'Measure.color_rgb')
+        check.size(2, self.hazard_inten_imp, 'Measure.hazard_inten_imp')
+        check.size(2, self.mdd_impact, 'Measure.mdd_impact')
+        check.size(2, self.paa_impact, 'Measure.paa_impact')
 
-        Parameters:
-            files (str or list(str)): absolute file name(s) or folder name
-                containing the files to read
-            descriptions (str or list(str), optional): one description of the
-                data or a description of each data file
-            var_names (dict or list(dict), default): name of the variables in
-                the file (default: DEF_VAR_NAME defined in the source modules)
+    def implement(self, exposures, imp_fun_set, hazard):
+        """Implement measure with all its defined parameters."""
+        new_haz = self.change_hazard(hazard)
+        new_exp = self.change_exposures(exposures)
+        new_ifs = self.change_imp_func(imp_fun_set)
 
-        Raises:
-            ValueError
-        """
-        all_files = get_file_names(files)
-        desc_list = to_list(len(all_files), descriptions, 'descriptions')
-        var_list = to_list(len(all_files), var_names, 'var_names')
-        self.clear()
-        for file, desc, var in zip(all_files, desc_list, var_list):
-            self.append(self._read_one(file, desc, var))
+        return new_exp, new_ifs, new_haz
 
-    def append(self, meas):
-        """Check and append measures of input MeasureSet to current MeasureSet.
-        Overwrite Measure if same name.
+    def change_hazard(self, hazard):
+        """Apply measure to hazard of the same type.
 
         Parameters:
-            meas (MeasureSet): MeasureSet instance to append
-
-        Raises:
-            ValueError
-        """
-        meas.check()
-        if self.num_measures() == 0:
-            self.__dict__ = meas.__dict__.copy()
-            return
-
-        self.tag.append(meas.tag)
-        for measure in meas.get_measure():
-            self.add_measure(measure)
-
-    @staticmethod
-    def get_sup_file_format():
-        """ Get supported file extensions that can be read.
+            hazard (Hazard): hazard instance
 
         Returns:
-            list(str)
+            Hazard
         """
-        return list(FILE_EXT.keys())
+        # TODO: implement
+        return hazard
 
-    @staticmethod
-    def get_def_file_var_names(src_format):
-        """Get default variable names for given file format.
+    def change_exposures(self, exposures):
+        """Apply measure to exposures.
 
         Parameters:
-            src_format (str): extension of the file, e.g. '.xls', '.mat'.
+            exposures (Exposures): exposures instance
 
         Returns:
-            dict: dictionary with variable names
+            Exposures
         """
-        try:
-            if '.' not in src_format:
-                src_format = '.' + src_format
-            return copy.deepcopy(READ_SET[FILE_EXT[src_format]][0])
-        except KeyError:
-            LOGGER.error('File extension not supported: %s.', src_format)
-            raise ValueError
-
-    @staticmethod
-    def _read_one(file_name, description='', var_names=None):
-        """Read input file.
+        # TODO: implement
+        return exposures
 
-        Parameters:
-            file_name (str): name of the source file
-            description (str, optional): description of the source data
-            var_names (dict), optional): name of the variables in the file
+    def change_imp_func(self, imp_set):
+        """Apply measure to impact functions of the same hazard type.
 
-        Raises:
-            ValueError
+        Parameters:
+            imp_set (ImpactFuncSet): impact functions to be modified
 
         Returns:
-            MeasureSet
+            ImpactFuncSet
         """
-        LOGGER.info('Reading file: %s', file_name)
-        new_meas = MeasureSet()
-        new_meas.tag = Tag(file_name, description)
-
-        extension = os.path.splitext(file_name)[1]
-        try:
-            reader = READ_SET[FILE_EXT[extension]][1]
-        except KeyError:
-            LOGGER.error('Input file extension not supported: %s.', extension)
-            raise ValueError
-        reader(new_meas, file_name, var_names)
-
-        return new_meas
-
-    def __str__(self):
-        return self.tag.__str__()
-
-    __repr__ = __str__
+        # all impact functions of one hazard??
+        new_imp_set = ImpactFuncSet()
+
+        for imp_fun in imp_set.get_func(self.haz_type):
+            new_if = copy.copy(imp_fun)
+            new_if.intensity = np.maximum(new_if.intensity * \
+                self.hazard_inten_imp[0] - self.hazard_inten_imp[1], 0.0)
+            new_if.mdd = np.maximum(new_if.mdd * self.mdd_impact[0] - \
+                self.mdd_impact[1], 0.0)
+            new_if.paa = np.maximum(new_if.paa * self.paa_impact[0] - \
+                self.paa_impact[1], 0.0)
+            new_imp_set.add_func(new_if)
+
+        if not new_imp_set.size():
+            LOGGER.info('No impact function of hazard %s found.', self.haz_type)
+
+        return new_imp_set