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 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: 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'].value
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 = filter_needs_parameters(
params['function_params']['minimum needs'])
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 or self.impact_attrs is not None
or self.target_field is not None
or self.type_field 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']
#find which attribute field has to be used
try:
for key in self.impact_attrs[0].iterkeys():
if key in self.valid_type_fields:
self.type_field = key
break
except IndexError:
pass
#there are no features in this postprocessing polygon
if self.impact_attrs == []:
self.noFeatures = True
else:
self.noFeatures = False
def setup(self, params):
"""Concrete implementation to ensure needed parameters are initialized.
:param params: Dict of parameters to pass to the post processor.
:type params: dict
"""
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.elderly_ratio = params['elderly_ratio']
ratios_total = (self.youth_ratio + self.adult_ratio +
self.elderly_ratio)
if ratios_total > 1:
self._raise_error('Age ratios should sum up to 1. Found: '
'%s + %s + %s = %s ' %
(self.youth_ratio, self.adult_ratio,
self.elderly_ratio, ratios_total))
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.elderly_ratio = defaults['ELDERLY_RATIO']
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 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 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):
"""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 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 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 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 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']
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 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']
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 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: 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.value_mapping 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.value_mapping = reorder_dictionary(
params['value_mapping'], self._order)
self.valid_type_fields = params['key_attribute']
self.type_fields = []
try:
for key in self.impact_attrs[0].iterkeys():
if key in self.valid_type_fields:
self.type_fields.append(key)
except IndexError:
pass
if len(self.type_fields) == 0:
self.type_fields = None
# there are no features in this postprocessing polygon
self.no_features = None
if len(self.impact_attrs):
self.no_features = True
if 'other' not in self.value_mapping.keys():
self.value_mapping['other'] = []
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._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.impact_total = params['impact_total']
self.target_field = params['target_field']
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_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 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.value_mapping 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.value_mapping = reorder_dictionary(params['value_mapping'],
self._order)
self.valid_type_fields = params['key_attribute']
self.type_fields = []
try:
for key in self.impact_attrs[0].iterkeys():
if key in self.valid_type_fields:
self.type_fields.append(key)
except IndexError:
pass
if len(self.type_fields) == 0:
self.type_fields = None
# there are no features in this postprocessing polygon
self.no_features = None
if len(self.impact_attrs):
self.no_features = True
if 'other' not in self.value_mapping.keys():
self.value_mapping['other'] = []
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_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 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 or
self.impact_attrs is not None or
self.target_field is not None or
self.type_field 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']
#find which attribute field has to be used
try:
for key in self.impact_attrs[0].iterkeys():
if key in self.valid_type_fields:
self.type_field = key
break
except IndexError:
pass
#there are no features in this postprocessing polygon
if self.impact_attrs == []:
self.noFeatures = True
else:
self.noFeatures = False
def setup(self, params):
"""Concrete implementation to ensure needed parameters are initialized.
:param params: Dict of parameters to pass to the post processor.
:type params: dict
"""
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.elderly_ratio = params['elderly_ratio']
ratios_total = (self.youth_ratio +
self.adult_ratio +
self.elderly_ratio)
if ratios_total > 1:
self._raise_error(
'Age ratios should sum up to 1. Found: '
'%s + %s + %s = %s ' % (
self.youth_ratio,
self.adult_ratio,
self.elderly_ratio,
ratios_total))
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.elderly_ratio = defaults['ELDERLY_RATIO']
