def clear(self):
        """Clear the parameters.

        """
        AbstractPostprocessor.clear(self)
        self.impact_total = None
        self.female_ratio = None

 def __init__(self):
     """
     Constructor for AgePostprocessor postprocessor class,
     It takes care of defining self.impact_total
     """
     AbstractPostprocessor.__init__(self)
     self.impact_total = None

 def __init__(self):
     """
     Constructor for postprocessor class,
     It takes care of defining self.impact_total
     """
     AbstractPostprocessor.__init__(self)
     self.impact_total = None
     self.impact_attrs = None
     self.target_field = None
     self.no_features = None
     self.fields_values = {
         'Medical': ['Clinic/Doctor', 'Hospital'],
         'Schools': ['School', 'University/College', ],
         'Places of worship': ['Place of Worship - Unitarian',
                               'Place of Worship - Islam',
                               'Place of Worship - Buddhist',
                               'Place of Worship'],
         'Residential': ['Residential'],
         'Government': ['Government'],
         'Public Building': ['Public Building'],
         'Fire Station': ['Fire Station'],
         'Police Station': ['Police Station'],
         'Supermarket': ['Supermarket'],
         'Commercial': ['Commercial'],
         'Industrial': ['Industrial'],
         'Utility': ['Utility'],
         'Sports Facility': ['Sports Facility'], }
     self.type_fields = None
     self.valid_type_fields = ['type']

 def clear(self):
     """concrete implementation it takes care of the needed parameters being
      properly cleared
     """
     AbstractPostprocessor.clear(self)
     self.impact_total = None
     self.minimum_needs = None

    def __init__(self):
        """
        Constructor for postprocessor class,
        It takes care of defining self.impact_total
        """
        AbstractPostprocessor.__init__(self)

        # Integer with total number of features/meters affected.
        self.impact_total = None

        # List of features
        self.impact_attrs = None

        # Name the field in the impact layer for the result.
        self.target_field = None

        # The name of field in the exposure layer.
        self.valid_type_fields = None

        # The value mapping for the exposure layer.
        self.value_mapping = None

        # Bool to know if there are some features. We will be computed later.
        self.no_features = None

        # Find which attribute field has to be used
        self.type_fields = None

        # Dictionary key - display name for the mapping.
        self._labels = {}

        # The categories order.
        self._order = None

    def setup(self, params):
        """concrete implementation it takes care of the needed parameters being
         initialized

        Args:
            params: dict of parameters to pass to the post processor
        Returns:
            None
        Raises:
            None
        """
        AbstractPostprocessor.setup(self, None)
        if self.impact_total is not None:
            self._raise_error('clear needs to be called before setup')

        self.impact_total = params['impact_total']
        try:
            #either all 3 ratio are custom set or we use defaults
            self.youth_ratio = params['youth_ratio']
            self.adult_ratio = params['adult_ratio']
            self.elder_ratio = params['elder_ratio']
        except KeyError:
            self._log_message('either all 3 age ratio are custom set or we'
                              ' use defaults')
            defaults = get_defaults()
            self.youth_ratio = defaults['YOUTH_RATIO']
            self.adult_ratio = defaults['ADULT_RATIO']
            self.elder_ratio = defaults['ELDER_RATIO']

 def clear(self):
     """Clear properly parameters.
     """
     AbstractPostprocessor.clear(self)
     self.impact_classes = None
     self.impact_attrs = None
     self.target_field = None

    def __init__(self):
        """
        Constructor for postprocessor class,
        It takes care of defining self.impact_total
        """
        AbstractPostprocessor.__init__(self)
        self.impact_total = None
        self.impact_attrs = None
        self.target_field = None
        self.no_features = None
        self.type_fields = None
        self.valid_type_fields = None
        self.fields_values = OrderedDict([
            ('Medical', ['Clinic/Doctor', 'Hospital']),
            ('Schools', ['School', 'University/College', ]),
            ('Places of worship', ['Place of Worship - Unitarian',
                                   'Place of Worship - Islam',
                                   'Place of Worship - Buddhist',
                                   'Place of Worship']),
            ('Residential', ['Residential']),
            ('Government', ['Government']),
            ('Public Building', ['Public Building']),
            ('Fire Station', ['Fire Station']),
            ('Police Station', ['Police Station']),
            ('Supermarket', ['Supermarket']),
            ('Commercial', ['Commercial']),
            ('Industrial', ['Industrial']),
            ('Utility', ['Utility']),
            ('Sports Facility', ['Sports Facility']),
            ('Other', [])])

        self.known_types = []
        self._update_known_types()

    def setup(self, params):
        """concrete implementation it takes care of the needed parameters being
         initialized

        :param params: Parameters to pass to the post processor.
        :type params: dict
        """
        AbstractPostprocessor.setup(self, None)
        if self.impact_total is not None or self.minimum_needs is not None:
            self._raise_error('clear needs to be called before setup')

        try:
            evacuation_percentage = 1
            if 'function_params' in params.keys():
                function_params = params['function_params']
                if 'evacuation_percentage' in function_params.keys():
                    evacuation_percentage = function_params[
                        'evacuation_percentage']
                    evacuation_percentage /= 100.0  # make it decimal

            self.impact_total = int(round(params['impact_total'] *
                                          evacuation_percentage))
        except (ValueError, TypeError):
            self.impact_total = self.NO_DATA_TEXT
        self.minimum_needs = params['function_params']['minimum needs']

    def setup(self, params):
        """concrete implementation it takes care of the needed parameters being
         initialized

        :param params: dict of parameters to pass to the post processor
        """
        AbstractPostprocessor.setup(self, None)
        if (self.impact_total is not None or
                self.impact_attrs is not None or
                self.target_field is not None or
                self.valid_type_fields is not None or
                self.type_fields is not None):
            self._raise_error('clear needs to be called before setup')

        self.impact_total = params['impact_total']
        self.impact_attrs = params['impact_attrs']
        self.target_field = params['target_field']
        self.valid_type_fields = params['key_attribute']

        # find which attribute field has to be used
        self.type_fields = []
        try:
            for key in self.impact_attrs[0].iterkeys():
                if key.lower() in self.valid_type_fields:
                    self.type_fields.append(key)
        except IndexError:
            pass

        if len(self.type_fields) == 0:
            self.type_fields = None

        self.no_features = False
        # there are no features in this postprocessing polygon
        if self.impact_attrs == []:
            self.no_features = True

 def __init__(self):
     """
     Constructor for MinimumNeedsPostprocessor postprocessor class,
     It takes care of defining self.impact_total
     """
     AbstractPostprocessor.__init__(self)
     self.impact_total = None
     self.minimum_needs = None

 def __init__(self):
     """
     Constructor for postprocessor class,
     It takes care of defining self.impact_classes
     """
     AbstractPostprocessor.__init__(self)
     self.impact_classes = None
     self.impact_attrs = None
     self.target_field = None

 def clear(self):
     """concrete implementation that ensures needed parameters are cleared.
     """
     AbstractPostprocessor.clear(self)
     self.impact_total = None
     self.impact_attrs = None
     self.target_field = None
     self.type_fields = None
     self.valid_type_fields = None

    def __init__(self):
        """
        Constructor for AgePostprocessor postprocessor class.

        It takes care of defining self.impact_total
        """
        AbstractPostprocessor.__init__(self)
        self.youth_ratio = None
        self.adult_ratio = None
        self.elderly_ratio = None
        self.impact_total = None

 def process(self):
     """concrete implementation it takes care of the needed parameters being
      available and performs all the indicators calculations
     """
     AbstractPostprocessor.process(self)
     if self.impact_total is None or self.minimum_needs is None:
         self._log_message('%s not all params have been correctly '
                           'initialized, setup needs to be called before '
                           'process. Skipping this postprocessor'
                           % self.__class__.__name__)
     else:
         self._calculate_needs()

    def setup(self, params):
        """Initialise parameters.

        """
        AbstractPostprocessor.setup(self, None)
        if self.impact_total is not None or self.female_ratio is not None:
            self._raise_error('clear needs to be called before setup')
        self.impact_total = params['impact_total']
        self.female_ratio = params['female_ratio']
        if self.female_ratio > 1:
            self._raise_error('Female ratio should be lower max 1. Found: '
                              '%s ' % self.female_ratio)

    def setup(self, params):
        """concrete implementation it takes care of the needed parameters being
         initialized

        :param params: Parameters to pass to the post processor.
        :type params: dict
        """
        AbstractPostprocessor.setup(self, None)
        if self.impact_total is not None or self.minimum_needs is not None:
            self._raise_error('clear needs to be called before setup')

        self.impact_total = int(round(params['impact_total']))
        self.minimum_needs = params['function_params']['minimum needs']

    def clear(self):
        """concrete implementation it takes care of the needed parameters being
         properly cleared

        Args:
            None
        Returns:
            None
        Raises:
            None
        """
        AbstractPostprocessor.clear(self)
        self.impact_total = None

    def setup(self, params):
        """Initialise needed parameters.
        """
        AbstractPostprocessor.setup(self, None)
        if (self.impact_classes is not None or
            self.impact_attrs is not None or
            self.target_field is not None):
            self._raise_error('clear needs to be called before setup')

        self.impact_classes = params['impact_classes']
        self.impact_attrs = params['impact_attrs']
        self.target_field = params['target_field']
        self._log_message(self.impact_attrs)

 def process(self):
     """Performs all the indicators calculations.
     """
     AbstractPostprocessor.process(self)
     if (self.impact_classes is None or
         self.impact_attrs is None or
         self.target_field is None):
         self._log_message(
             '%s not all params have been correctly '
             'initialized, setup needs to be called before '
             'process. Skipping this postprocessor'
              % self.__class__.__name__)
     else:
         self._calculate_categories()