def test_population_rounding(self):
"""Test for population_rounding_full function."""
# rounding up
for _ in range(100):
# After choosing some random numbers the sum of the randomly
# selected and one greater than that should be less than the
# population rounded versions of these.
n = random.randint(1, 1000000)
n_pop, dummy = population_rounding_full(n)
n1 = n + 1
n1_pop, dummy = population_rounding_full(n1)
self.assertGreater(n_pop + n1_pop, n + n1)
self.assertEqual(population_rounding_full(989)[0], 990)
self.assertEqual(population_rounding_full(991)[0], 1000)
self.assertEqual(population_rounding_full(8888)[0], 8900)
self.assertEqual(population_rounding_full(9888888)[0], 9889000)
for _ in range(100):
n = random.randint(1, 1000000)
self.assertEqual(population_rounding(n),
population_rounding_full(n)[0])
def test_population_rounding(self):
"""Test for population_rounding_full function."""
# rounding up
for _ in range(100):
# After choosing some random numbers the sum of the randomly
# selected and one greater than that should be less than the
# population rounded versions of these.
n = random.randint(1, 1000000)
n_pop, dummy = population_rounding_full(n)
n1 = n + 1
n1_pop, dummy = population_rounding_full(n1)
self.assertGreater(n_pop + n1_pop, n + n1)
self.assertEqual(population_rounding_full(989)[0], 990)
self.assertEqual(population_rounding_full(991)[0], 1000)
self.assertEqual(population_rounding_full(8888)[0], 8900)
self.assertEqual(population_rounding_full(9888888)[0], 9889000)
for _ in range(100):
n = random.randint(1, 1000000)
self.assertEqual(
population_rounding(n),
population_rounding_full(n)[0])
def run(self, layers):
"""Risk plugin for flood population evacuation.
:param layers: List of layers expected to contain
* hazard_layer : Vector polygon layer of flood depth
* exposure_layer : Raster layer of population data on the same grid
as hazard_layer
Counts number of people exposed to areas identified as flood prone
:returns: Map of population exposed to flooding Table with number of
people evacuated and supplies required.
:rtype: tuple
"""
# Identify hazard and exposure layers
hazard_layer = get_hazard_layer(layers) # Flood inundation
exposure_layer = get_exposure_layer(layers)
question = get_question(hazard_layer.get_name(),
exposure_layer.get_name(), self)
# Check that hazard is polygon type
if not hazard_layer.is_vector:
message = ('Input hazard %s was not a vector layer as expected ' %
hazard_layer.get_name())
raise Exception(message)
message = (
'Input hazard must be a polygon layer. I got %s with layer type '
'%s' % (hazard_layer.get_name(), hazard_layer.get_geometry_name()))
if not hazard_layer.is_polygon_data:
raise Exception(message)
# Run interpolation function for polygon2raster
P = assign_hazard_values_to_exposure_data(hazard_layer,
exposure_layer,
attribute_name='population')
# Initialise attributes of output dataset with all attributes
# from input polygon and a population count of zero
new_attributes = hazard_layer.get_data()
category_title = 'affected' # FIXME: Should come from keywords
deprecated_category_title = 'FLOODPRONE'
categories = {}
for attr in new_attributes:
attr[self.target_field] = 0
try:
cat = attr[category_title]
except KeyError:
try:
cat = attr['FLOODPRONE']
categories[cat] = 0
except KeyError:
pass
# Count affected population per polygon, per category and total
affected_population = 0
for attr in P.get_data():
affected = False
if 'affected' in attr:
res = attr['affected']
if res is None:
x = False
else:
x = bool(res)
affected = x
elif 'FLOODPRONE' in attr:
# If there isn't an 'affected' attribute,
res = attr['FLOODPRONE']
if res is not None:
affected = res.lower() == 'yes'
elif 'Affected' in attr:
# Check the default attribute assigned for points
# covered by a polygon
res = attr['Affected']
if res is None:
x = False
else:
x = res
affected = x
else:
# assume that every polygon is affected (see #816)
affected = True
# there is no flood related attribute
# message = ('No flood related attribute found in %s. '
# 'I was looking for either "Flooded", "FLOODPRONE" '
# 'or "Affected". The latter should have been '
# 'automatically set by call to '
# 'assign_hazard_values_to_exposure_data(). '
# 'Sorry I can\'t help more.')
# raise Exception(message)
if affected:
# Get population at this location
pop = float(attr['population'])
# Update population count for associated polygon
poly_id = attr['polygon_id']
new_attributes[poly_id][self.target_field] += pop
# Update population count for each category
if len(categories) > 0:
try:
cat = new_attributes[poly_id][category_title]
except KeyError:
cat = new_attributes[poly_id][
deprecated_category_title]
categories[cat] += pop
# Update total
affected_population += pop
# Estimate number of people in need of evacuation
evacuated = (affected_population *
self.parameters['evacuation_percentage'] / 100.0)
affected_population, rounding = population_rounding_full(
affected_population)
total = int(numpy.sum(exposure_layer.get_data(nan=0, scaling=False)))
# Don't show digits less than a 1000
total = population_rounding(total)
evacuated, rounding_evacuated = population_rounding_full(evacuated)
minimum_needs = [
parameter.serialize()
for parameter in self.parameters['minimum needs']
]
# Generate impact report for the pdf map
table_body = [
question,
TableRow([
tr('People affected'),
'%s*' % (format_int(int(affected_population)))
],
header=True),
TableRow([
TableCell(tr('* Number is rounded up to the nearest %s') %
(rounding),
col_span=2)
]),
TableRow([
tr('People needing evacuation'),
'%s*' % (format_int(int(evacuated)))
],
header=True),
TableRow([
TableCell(tr('* Number is rounded up to the nearest %s') %
(rounding_evacuated),
col_span=2)
]),
TableRow([
tr('Evacuation threshold'),
'%s%%' % format_int(self.parameters['evacuation_percentage'])
],
header=True),
TableRow(
tr('Map shows the number of people affected in each flood prone '
'area')),
TableRow(
tr('Table below shows the weekly minimum needs for all '
'evacuated people'))
]
total_needs = evacuated_population_needs(evacuated, minimum_needs)
for frequency, needs in total_needs.items():
table_body.append(
TableRow([
tr('Needs should be provided %s' % frequency),
tr('Total')
],
header=True))
for resource in needs:
table_body.append(
TableRow([
tr(resource['table name']),
format_int(resource['amount'])
]))
impact_table = Table(table_body).toNewlineFreeString()
table_body.append(TableRow(tr('Action Checklist:'), header=True))
table_body.append(TableRow(tr('How will warnings be disseminated?')))
table_body.append(TableRow(tr('How will we reach stranded people?')))
table_body.append(TableRow(tr('Do we have enough relief items?')))
table_body.append(
TableRow(
tr('If yes, where are they located and how will we distribute '
'them?')))
table_body.append(
TableRow(
tr('If no, where can we obtain additional relief items from and '
'how will we transport them to here?')))
# Extend impact report for on-screen display
table_body.extend([
TableRow(tr('Notes'), header=True),
tr('Total population: %s') % format_int(total),
tr('People need evacuation if in the area identified as '
'"Flood Prone"'),
tr('Minimum needs are defined in BNPB regulation 7/2008')
])
impact_summary = Table(table_body).toNewlineFreeString()
# Create style
# Define classes for legend for flooded population counts
colours = [
'#FFFFFF', '#38A800', '#79C900', '#CEED00', '#FFCC00', '#FF6600',
'#FF0000', '#7A0000'
]
population_counts = [x['population'] for x in new_attributes]
classes = create_classes(population_counts, len(colours))
interval_classes = humanize_class(classes)
# Define style info for output polygons showing population counts
style_classes = []
for i in xrange(len(colours)):
style_class = dict()
style_class['label'] = create_label(interval_classes[i])
if i == 0:
transparency = 0
style_class['min'] = 0
else:
transparency = 0
style_class['min'] = classes[i - 1]
style_class['transparency'] = transparency
style_class['colour'] = colours[i]
style_class['max'] = classes[i]
style_classes.append(style_class)
# Override style info with new classes and name
style_info = dict(target_field=self.target_field,
style_classes=style_classes,
style_type='graduatedSymbol')
# For printing map purpose
map_title = tr('People affected by flood prone areas')
legend_notes = tr('Thousand separator is represented by \'.\'')
legend_units = tr('(people per polygon)')
legend_title = tr('Population Count')
# Create vector layer and return
vector_layer = Vector(data=new_attributes,
projection=hazard_layer.get_projection(),
geometry=hazard_layer.get_geometry(),
name=tr('People affected by flood prone areas'),
keywords={
'impact_summary': impact_summary,
'impact_table': impact_table,
'target_field': self.target_field,
'map_title': map_title,
'legend_notes': legend_notes,
'legend_units': legend_units,
'legend_title': legend_title,
'affected_population': affected_population,
'total_population': total,
'total_needs': total_needs
},
style_info=style_info)
return vector_layer
class ITBFatalityFunction(ImpactFunction):
# noinspection PyUnresolvedReferences
"""Indonesian Earthquake Fatality Model.
This model was developed by Institut Teknologi Bandung (ITB) and
implemented by Dr. Hadi Ghasemi, Geoscience Australia.
Reference:
Indonesian Earthquake Building-Damage and Fatality Models and
Post Disaster Survey Guidelines Development,
Bali, 27-28 February 2012, 54pp.
Algorithm:
In this study, the same functional form as Allen (2009) is adopted
to express fatality rate as a function of intensity (see Eq. 10 in the
report). The Matlab built-in function (fminsearch) for Nelder-Mead
algorithm was used to estimate the model parameters. The objective
function (L2G norm) that is minimised during the optimisation is the
same as the one used by Jaiswal et al. (2010).
The coefficients used in the indonesian model are
x=0.62275231, y=8.03314466, zeta=2.15
Allen, T. I., Wald, D. J., Earle, P. S., Marano, K. D., Hotovec, A. J.,
Lin, K., and Hearne, M., 2009. An Atlas of ShakeMaps and population
exposure catalog for earthquake loss modeling, Bull. Earthq. Eng. 7,
701-718.
Jaiswal, K., and Wald, D., 2010. An empirical model for global earthquake
fatality estimation, Earthq. Spectra 26, 1017-1037.
Caveats and limitations:
The current model is the result of the above mentioned workshop and
reflects the best available information. However, the current model
has a number of issues listed below and is expected to evolve further
over time.
1 - The model is based on limited number of observed fatality
rates during 4 past fatal events.
2 - The model clearly over-predicts the fatality rates at
intensities higher than VIII.
3 - The model only estimates the expected fatality rate for a given
intensity level; however the associated uncertainty for the proposed
model is not addressed.
4 - There are few known mistakes in developing the current model:
- rounding MMI values to the nearest 0.5,
- Implementing Finite-Fault models of candidate events, and
- consistency between selected GMPEs with those in use by BMKG.
These issues will be addressed by ITB team in the final report.
Note: Because of these caveats, decisions should not be made solely on
the information presented here and should always be verified by ground
truthing and other reliable information sources.
"""
_metadata = ITBFatalityMetadata()
def __init__(self):
super(ITBFatalityFunction, self).__init__()
# AG: Use the proper minimum needs, update the parameters
self.parameters = add_needs_parameters(self.parameters)
self.hardcoded_parameters = OrderedDict([
('x', 0.62275231), ('y', 8.03314466), # Model coefficients
# Rates of people displaced for each MMI level
('displacement_rate', {
1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 1.0,
7: 1.0, 8: 1.0, 9: 1.0, 10: 1.0
}),
('mmi_range', range(2, 10)),
('step', 0.5),
# Threshold below which layer should be transparent
('tolerance', 0.01),
('calculate_displaced_people', True)
])
def fatality_rate(self, mmi):
"""ITB method to compute fatality rate.
:param mmi:
"""
# As per email discussion with Ole, Trevor, Hadi, mmi < 4 will have
# a fatality rate of 0 - Tim
if mmi < 4:
return 0
x = self.hardcoded_parameters['x']
y = self.hardcoded_parameters['y']
# noinspection PyUnresolvedReferences
return numpy.power(10.0, x * mmi - y)
def run(self, layers=None):
"""Indonesian Earthquake Fatality Model.
Input:
:param layers: List of layers expected to contain,
hazard: Raster layer of MMI ground shaking
exposure: Raster layer of population count
"""
self.validate()
self.prepare(layers)
displacement_rate = self.hardcoded_parameters['displacement_rate']
# Tolerance for transparency
tolerance = self.hardcoded_parameters['tolerance']
# Extract input layers
intensity = self.hazard
population = self.exposure
# Extract data grids
hazard = intensity.get_data() # Ground Shaking
exposure = population.get_data(scaling=True) # Population Density
# Calculate people affected by each MMI level
# FIXME (Ole): this range is 2-9. Should 10 be included?
mmi_range = self.hardcoded_parameters['mmi_range']
number_of_exposed = {}
number_of_displaced = {}
number_of_fatalities = {}
# Calculate fatality rates for observed Intensity values (hazard
# based on ITB power model
mask = numpy.zeros(hazard.shape)
for mmi in mmi_range:
# Identify cells where MMI is in class i and
# count people affected by this shake level
mmi_matches = numpy.where(
(hazard > mmi - self.hardcoded_parameters['step']) * (
hazard <= mmi + self.hardcoded_parameters['step']),
exposure, 0)
# Calculate expected number of fatalities per level
fatality_rate = self.fatality_rate(mmi)
fatalities = fatality_rate * mmi_matches
# Calculate expected number of displaced people per level
try:
displacements = displacement_rate[mmi] * mmi_matches
except KeyError, e:
msg = 'mmi = %i, mmi_matches = %s, Error msg: %s' % (
mmi, str(mmi_matches), str(e))
# noinspection PyExceptionInherit
raise InaSAFEError(msg)
# Adjust displaced people to disregard fatalities.
# Set to zero if there are more fatalities than displaced.
displacements = numpy.where(
displacements > fatalities, displacements - fatalities, 0)
# Sum up numbers for map
mask += displacements # Displaced
# Generate text with result for this study
# This is what is used in the real time system exposure table
number_of_exposed[mmi] = numpy.nansum(mmi_matches.flat)
number_of_displaced[mmi] = numpy.nansum(displacements.flat)
# noinspection PyUnresolvedReferences
number_of_fatalities[mmi] = numpy.nansum(fatalities.flat)
# Set resulting layer to NaN when less than a threshold. This is to
# achieve transparency (see issue #126).
mask[mask < tolerance] = numpy.nan
# Total statistics
total, rounding = population_rounding_full(numpy.nansum(exposure.flat))
# Compute number of fatalities
fatalities = population_rounding(numpy.nansum(
number_of_fatalities.values()))
# As per email discussion with Ole, Trevor, Hadi, total fatalities < 50
# will be rounded down to 0 - Tim
if fatalities < 50:
fatalities = 0
# Compute number of people displaced due to building collapse
displaced = population_rounding(numpy.nansum(
number_of_displaced.values()))
# Generate impact report
table_body = [self.question]
# Add total fatality estimate
s = format_int(fatalities)
table_body.append(TableRow([tr('Number of fatalities'), s],
header=True))
if self.hardcoded_parameters['calculate_displaced_people']:
# Add total estimate of people displaced
s = format_int(displaced)
table_body.append(TableRow([tr('Number of people displaced'), s],
header=True))
else:
displaced = 0
# Add estimate of total population in area
s = format_int(int(total))
table_body.append(TableRow([tr('Total number of people'), s],
header=True))
minimum_needs = [
parameter.serialize() for parameter in
self.parameters['minimum needs']
]
# Generate impact report for the pdf map
table_body = [
self.question, TableRow(
[tr('Fatalities'), '%s' % format_int(fatalities)],
header=True),
TableRow(
[tr('People displaced'), '%s' % format_int(displaced)],
header=True),
TableRow(tr('Map shows the estimation of displaced population'))]
total_needs = evacuated_population_needs(
displaced, minimum_needs)
for frequency, needs in total_needs.items():
table_body.append(TableRow(
[
tr('Needs should be provided %s' % frequency),
tr('Total')
],
header=True))
for resource in needs:
table_body.append(TableRow([
tr(resource['table name']),
format_int(resource['amount'])]))
table_body.append(TableRow(tr('Provenance'), header=True))
table_body.append(TableRow(self.parameters['provenance']))
table_body.append(TableRow(tr('Action Checklist:'), header=True))
if fatalities > 0:
table_body.append(tr('Are there enough victim identification '
'units available for %s people?') %
format_int(fatalities))
if displaced > 0:
table_body.append(tr('Are there enough shelters and relief items '
'available for %s people?')
% format_int(displaced))
table_body.append(TableRow(tr('If yes, where are they located and '
'how will we distribute them?')))
table_body.append(TableRow(tr('If no, where can we obtain '
'additional relief items from and '
'how will we transport them?')))
# Extend impact report for on-screen display
table_body.extend([TableRow(tr('Notes'), header=True),
tr('Total population: %s') % format_int(total),
tr('People are considered to be displaced if '
'they experience and survive a shake level'
'of more than 5 on the MMI scale '),
tr('Minimum needs are defined in BNPB '
'regulation 7/2008'),
tr('The fatality calculation assumes that '
'no fatalities occur for shake levels below 4 '
'and fatality counts of less than 50 are '
'disregarded.'),
tr('All values are rounded up to the nearest '
'integer in order to avoid representing human '
'lives as fractions.')])
table_body.append(TableRow(tr('Notes'), header=True))
table_body.append(tr('Fatality model is from '
'Institute of Teknologi Bandung 2012.'))
table_body.append(
tr('Population numbers rounded up to the nearest %s.') % rounding)
# Result
impact_summary = Table(table_body).toNewlineFreeString()
impact_table = impact_summary
# check for zero impact
if numpy.nanmax(mask) == 0 == numpy.nanmin(mask):
table_body = [
self.question,
TableRow([tr('Fatalities'), '%s' % format_int(fatalities)],
header=True)]
my_message = Table(table_body).toNewlineFreeString()
raise ZeroImpactException(my_message)
# Create style
colours = ['#EEFFEE', '#FFFF7F', '#E15500', '#E4001B', '#730000']
classes = create_classes(mask.flat[:], len(colours))
interval_classes = humanize_class(classes)
style_classes = []
for i in xrange(len(colours)):
style_class = dict()
style_class['label'] = create_label(interval_classes[i])
style_class['quantity'] = classes[i]
if i == 0:
transparency = 100
else:
transparency = 30
style_class['transparency'] = transparency
style_class['colour'] = colours[i]
style_classes.append(style_class)
style_info = dict(target_field=None,
style_classes=style_classes,
style_type='rasterStyle')
# For printing map purpose
map_title = tr('Earthquake impact to population')
legend_notes = tr('Thousand separator is represented by %s' %
get_thousand_separator())
legend_units = tr('(people per cell)')
legend_title = tr('Population Count')
# Create raster object and return
raster = Raster(
mask,
projection=population.get_projection(),
geotransform=population.get_geotransform(),
keywords={
'impact_summary': impact_summary,
'total_population': total,
'total_fatalities': fatalities,
'fatalities_per_mmi': number_of_fatalities,
'exposed_per_mmi': number_of_exposed,
'displaced_per_mmi': number_of_displaced,
'impact_table': impact_table,
'map_title': map_title,
'legend_notes': legend_notes,
'legend_units': legend_units,
'legend_title': legend_title,
'total_needs': total_needs},
name=tr('Estimated displaced population per cell'),
style_info=style_info)
self._impact = raster
return raster
def run(self, layers):
"""Risk plugin for tsunami population evacuation.
:param layers: List of layers expected to contain
hazard_layer: Raster layer of tsunami depth
exposure_layer: Raster layer of population data on the same grid
as hazard_layer
Counts number of people exposed to tsunami levels exceeding
specified threshold.
:returns: Map of population exposed to tsunami levels exceeding the
threshold. Table with number of people evacuated and supplies
required.
:rtype: tuple
"""
# Identify hazard and exposure layers
hazard_layer = get_hazard_layer(layers) # Tsunami inundation [m]
exposure_layer = get_exposure_layer(layers)
question = get_question(hazard_layer.get_name(),
exposure_layer.get_name(), self)
# Determine depths above which people are regarded affected [m]
# Use thresholds from inundation layer if specified
thresholds = self.parameters['thresholds [m]']
verify(isinstance(thresholds, list),
'Expected thresholds to be a list. Got %s' % str(thresholds))
# Extract data as numeric arrays
data = hazard_layer.get_data(nan=0.0) # Depth
# Calculate impact as population exposed to depths > max threshold
population = exposure_layer.get_data(nan=0.0, scaling=True)
# Calculate impact to intermediate thresholds
counts = []
# merely initialize
impact = None
for i, lo in enumerate(thresholds):
if i == len(thresholds) - 1:
# The last threshold
impact = medium = numpy.where(data >= lo, population, 0)
else:
# Intermediate thresholds
hi = thresholds[i + 1]
medium = numpy.where((data >= lo) * (data < hi), population, 0)
# Count
val = int(numpy.sum(medium))
# Sensible rounding
val, rounding = population_rounding_full(val)
counts.append([val, rounding])
# Count totals
evacuated, rounding = counts[-1]
total = int(numpy.sum(population))
# Don't show digits less than a 1000
total = population_rounding(total)
minimum_needs = [
parameter.serialize()
for parameter in self.parameters['minimum needs']
]
# Generate impact report for the pdf map
# noinspection PyListCreation
table_body = [
question,
TableRow([(tr('People in %.1f m of water') % thresholds[-1]),
'%s*' % format_int(evacuated)],
header=True),
TableRow(
tr('* Number is rounded up to the nearest %s') % rounding),
TableRow(tr('Map shows the numbers of people needing evacuation'))
]
total_needs = evacuated_population_needs(evacuated, minimum_needs)
for frequency, needs in total_needs.items():
table_body.append(
TableRow([
tr('Needs should be provided %s' % frequency),
tr('Total')
],
header=True))
for resource in needs:
table_body.append(
TableRow([
tr(resource['table name']),
format_int(resource['amount'])
]))
table_body.append(TableRow(tr('Action Checklist:'), header=True))
table_body.append(TableRow(tr('How will warnings be disseminated?')))
table_body.append(TableRow(tr('How will we reach stranded people?')))
table_body.append(TableRow(tr('Do we have enough relief items?')))
table_body.append(
TableRow(
tr('If yes, where are they located and how '
'will we distribute them?')))
table_body.append(
TableRow(
tr('If no, where can we obtain additional relief items from and how '
'will we transport them to here?')))
# Extend impact report for on-screen display
table_body.extend([
TableRow(tr('Notes'), header=True),
tr('Total population: %s') % format_int(total),
tr('People need evacuation if tsunami levels exceed %(eps).1f m') %
{
'eps': thresholds[-1]
},
tr('Minimum needs are defined in BNPB regulation 7/2008'),
tr('All values are rounded up to the nearest integer in order to '
'avoid representing human lives as fractions.')
])
if len(counts) > 1:
table_body.append(TableRow(tr('Detailed breakdown'), header=True))
for i, val in enumerate(counts[:-1]):
s = (tr('People in %(lo).1f m to %(hi).1f m of water: %(val)i')
% {
'lo': thresholds[i],
'hi': thresholds[i + 1],
'val': format_int(val[0])
})
table_body.append(TableRow(s))
# Result
impact_summary = Table(table_body).toNewlineFreeString()
impact_table = impact_summary
# check for zero impact
if numpy.nanmax(impact) == 0 == numpy.nanmin(impact):
table_body = [
question,
TableRow([(tr('People in %.1f m of water') % thresholds[-1]),
'%s' % format_int(evacuated)],
header=True)
]
my_message = Table(table_body).toNewlineFreeString()
raise ZeroImpactException(my_message)
# Create style
colours = [
'#FFFFFF', '#38A800', '#79C900', '#CEED00', '#FFCC00', '#FF6600',
'#FF0000', '#7A0000'
]
classes = create_classes(impact.flat[:], len(colours))
interval_classes = humanize_class(classes)
style_classes = []
for i in xrange(len(colours)):
style_class = dict()
if i == 1:
label = create_label(interval_classes[i], 'Low')
elif i == 4:
label = create_label(interval_classes[i], 'Medium')
elif i == 7:
label = create_label(interval_classes[i], 'High')
else:
label = create_label(interval_classes[i])
style_class['label'] = label
style_class['quantity'] = classes[i]
if i == 0:
transparency = 100
else:
transparency = 0
style_class['transparency'] = transparency
style_class['colour'] = colours[i]
style_classes.append(style_class)
style_info = dict(target_field=None,
style_classes=style_classes,
style_type='rasterStyle')
# For printing map purpose
map_title = tr('People in need of evacuation')
legend_notes = tr('Thousand separator is represented by %s' %
get_thousand_separator())
legend_units = tr('(people per cell)')
legend_title = tr('Population')
# Create raster object and return
raster = Raster(impact,
projection=hazard_layer.get_projection(),
geotransform=hazard_layer.get_geotransform(),
name=tr('Population which %s') %
(get_function_title(self).lower()),
keywords={
'impact_summary': impact_summary,
'impact_table': impact_table,
'map_title': map_title,
'legend_notes': legend_notes,
'legend_units': legend_units,
'legend_title': legend_title,
'evacuated': evacuated,
'total_needs': total_needs
},
style_info=style_info)
return raster
def run(self, layers=None):
"""Risk plugin for flood population evacuation.
:param layers: List of layers expected to contain
* hazard_layer : Vector polygon layer of flood depth
* exposure_layer : Raster layer of population data on the same grid
as hazard_layer
Counts number of people exposed to areas identified as flood prone
:returns: Map of population exposed to flooding Table with number of
people evacuated and supplies required.
:rtype: tuple
"""
self.validate()
self.prepare(layers)
# Get the IF parameters
affected_field = self.parameters['affected_field']
affected_value = self.parameters['affected_value']
evacuation_percentage = self.parameters['evacuation_percentage']
# Identify hazard and exposure layers
hazard_layer = self.hazard
exposure_layer = self.exposure
# Check that hazard is polygon type
if not hazard_layer.is_polygon_data:
message = (
'Input hazard must be a polygon layer. I got %s with layer '
'type %s' % (
hazard_layer.get_name(),
hazard_layer.get_geometry_name()))
raise Exception(message)
nan_warning = False
if has_no_data(exposure_layer.get_data(nan=True)):
nan_warning = True
# Check that affected field exists in hazard layer
if affected_field in hazard_layer.get_attribute_names():
self.use_affected_field = True
# Run interpolation function for polygon2raster
interpolated_layer, covered_exposure = \
assign_hazard_values_to_exposure_data(
hazard_layer,
exposure_layer,
attribute_name=self.target_field)
# Data for manipulating the covered_exposure layer
new_covered_exposure_data = covered_exposure.get_data()
covered_exposure_top_left = numpy.array([
covered_exposure.get_geotransform()[0],
covered_exposure.get_geotransform()[3]])
covered_exposure_dimension = numpy.array([
covered_exposure.get_geotransform()[1],
covered_exposure.get_geotransform()[5]])
# Count affected population per polygon, per category and total
total_affected_population = 0
for attr in interpolated_layer.get_data():
affected = False
if self.use_affected_field:
row_affected_value = attr[affected_field]
if row_affected_value is not None:
if isinstance(row_affected_value, Number):
type_func = type(row_affected_value)
affected = row_affected_value == type_func(
affected_value)
else:
affected =\
get_unicode(affected_value).lower() == \
get_unicode(row_affected_value).lower()
else:
# assume that every polygon is affected (see #816)
affected = True
if affected:
# Get population at this location
population = attr[self.target_field]
if not numpy.isnan(population):
population = float(population)
total_affected_population += population
else:
# If it's not affected, set the value of the impact layer to 0
grid_point = attr['grid_point']
index = numpy.floor(
(grid_point - covered_exposure_top_left) / (
covered_exposure_dimension)).astype(int)
new_covered_exposure_data[index[1]][index[0]] = 0
# Estimate number of people in need of evacuation
evacuated = (
total_affected_population * evacuation_percentage / 100.0)
total_population = int(
numpy.nansum(exposure_layer.get_data(scaling=False)))
minimum_needs = [
parameter.serialize() for parameter in
self.parameters['minimum needs']
]
# Rounding
total_affected_population, rounding = population_rounding_full(
total_affected_population)
total_population = population_rounding(total_population)
evacuated, rounding_evacuated = population_rounding_full(evacuated)
# Generate impact report for the pdf map
table_body, total_needs = self._tabulate(
total_affected_population,
evacuated,
minimum_needs,
self.question,
rounding,
rounding_evacuated)
impact_table = Table(table_body).toNewlineFreeString()
self._tabulate_action_checklist(
table_body,
total_population,
nan_warning)
impact_summary = Table(table_body).toNewlineFreeString()
# Create style
colours = ['#FFFFFF', '#38A800', '#79C900', '#CEED00',
'#FFCC00', '#FF6600', '#FF0000', '#7A0000']
classes = create_classes(
new_covered_exposure_data.flat[:], len(colours))
# check for zero impact
if min(classes) == 0 == max(classes):
table_body = [
self.question,
TableRow(
[tr('People affected'),
'%s' % format_int(total_affected_population)],
header=True)]
message = Table(table_body).toNewlineFreeString()
raise ZeroImpactException(message)
interval_classes = humanize_class(classes)
# Define style info for output polygons showing population counts
style_classes = []
for i in xrange(len(colours)):
style_class = dict()
style_class['label'] = create_label(interval_classes[i])
if i == 1:
label = create_label(
interval_classes[i],
tr('Low Population [%i people/cell]' % classes[i]))
elif i == 4:
label = create_label(
interval_classes[i],
tr('Medium Population [%i people/cell]' % classes[i]))
elif i == 7:
label = create_label(
interval_classes[i],
tr('High Population [%i people/cell]' % classes[i]))
else:
label = create_label(interval_classes[i])
if i == 0:
transparency = 100
else:
transparency = 0
style_class['label'] = label
style_class['quantity'] = classes[i]
style_class['colour'] = colours[i]
style_class['transparency'] = transparency
style_classes.append(style_class)
# Override style info with new classes and name
style_info = dict(
target_field=None,
style_classes=style_classes,
style_type='rasterStyle')
# For printing map purpose
map_title = tr('People affected by flood prone areas')
legend_notes = tr('Thousand separator is represented by \'.\'')
legend_units = tr('(people per polygon)')
legend_title = tr('Population Count')
# Create vector layer and return
impact_layer = Raster(
data=new_covered_exposure_data,
projection=covered_exposure.get_projection(),
geotransform=covered_exposure.get_geotransform(),
name=tr('People affected by flood prone areas'),
keywords={
'impact_summary': impact_summary,
'impact_table': impact_table,
'target_field': self.target_field,
'map_title': map_title,
'legend_notes': legend_notes,
'legend_units': legend_units,
'legend_title': legend_title,
'affected_population': total_affected_population,
'total_population': total_population,
'total_needs': total_needs},
style_info=style_info)
self._impact = impact_layer
return impact_layer
def run(self, layers):
"""Risk plugin for tsunami population evacuation.
:param layers: List of layers expected to contain
hazard_layer: Raster layer of tsunami depth
exposure_layer: Raster layer of population data on the same grid
as hazard_layer
Counts number of people exposed to tsunami levels exceeding
specified threshold.
:returns: Map of population exposed to tsunami levels exceeding the
threshold. Table with number of people evacuated and supplies
required.
:rtype: tuple
"""
# Identify hazard and exposure layers
hazard_layer = get_hazard_layer(layers) # Tsunami inundation [m]
exposure_layer = get_exposure_layer(layers)
question = get_question(
hazard_layer.get_name(), exposure_layer.get_name(), self)
# Determine depths above which people are regarded affected [m]
# Use thresholds from inundation layer if specified
thresholds = self.parameters['thresholds [m]']
verify(
isinstance(thresholds, list),
'Expected thresholds to be a list. Got %s' % str(thresholds))
# Extract data as numeric arrays
data = hazard_layer.get_data(nan=0.0) # Depth
# Calculate impact as population exposed to depths > max threshold
population = exposure_layer.get_data(nan=0.0, scaling=True)
# Calculate impact to intermediate thresholds
counts = []
# merely initialize
impact = None
for i, lo in enumerate(thresholds):
if i == len(thresholds) - 1:
# The last threshold
impact = medium = numpy.where(data >= lo, population, 0)
else:
# Intermediate thresholds
hi = thresholds[i + 1]
medium = numpy.where((data >= lo) * (data < hi), population, 0)
# Count
val = int(numpy.sum(medium))
# Sensible rounding
val, rounding = population_rounding_full(val)
counts.append([val, rounding])
# Count totals
evacuated, rounding = counts[-1]
total = int(numpy.sum(population))
# Don't show digits less than a 1000
total = population_rounding(total)
minimum_needs = [
parameter.serialize() for parameter in
self.parameters['minimum needs']
]
# Generate impact report for the pdf map
# noinspection PyListCreation
table_body = [
question,
TableRow([(tr('People in %.1f m of water') % thresholds[-1]),
'%s*' % format_int(evacuated)],
header=True),
TableRow(
tr('* Number is rounded up to the nearest %s') % rounding),
TableRow(tr('Map shows the numbers of people needing evacuation'))]
total_needs = evacuated_population_needs(
evacuated, minimum_needs)
for frequency, needs in total_needs.items():
table_body.append(TableRow(
[
tr('Needs should be provided %s' % frequency),
tr('Total')
],
header=True))
for resource in needs:
table_body.append(TableRow([
tr(resource['table name']),
format_int(resource['amount'])]))
table_body.append(TableRow(tr('Action Checklist:'), header=True))
table_body.append(TableRow(tr('How will warnings be disseminated?')))
table_body.append(TableRow(tr('How will we reach stranded people?')))
table_body.append(TableRow(tr('Do we have enough relief items?')))
table_body.append(TableRow(tr('If yes, where are they located and how '
'will we distribute them?')))
table_body.append(TableRow(tr(
'If no, where can we obtain additional relief items from and how '
'will we transport them to here?')))
# Extend impact report for on-screen display
table_body.extend([
TableRow(tr('Notes'), header=True),
tr('Total population: %s') % format_int(total),
tr('People need evacuation if tsunami levels exceed %(eps).1f m') %
{'eps': thresholds[-1]},
tr('Minimum needs are defined in BNPB regulation 7/2008'),
tr('All values are rounded up to the nearest integer in order to '
'avoid representing human lives as fractions.')])
if len(counts) > 1:
table_body.append(TableRow(tr('Detailed breakdown'), header=True))
for i, val in enumerate(counts[:-1]):
s = (tr('People in %(lo).1f m to %(hi).1f m of water: %(val)i')
% {'lo': thresholds[i],
'hi': thresholds[i + 1],
'val': format_int(val[0])})
table_body.append(TableRow(s))
# Result
impact_summary = Table(table_body).toNewlineFreeString()
impact_table = impact_summary
# check for zero impact
if numpy.nanmax(impact) == 0 == numpy.nanmin(impact):
table_body = [
question,
TableRow([(tr('People in %.1f m of water') % thresholds[-1]),
'%s' % format_int(evacuated)],
header=True)]
my_message = Table(table_body).toNewlineFreeString()
raise ZeroImpactException(my_message)
# Create style
colours = [
'#FFFFFF', '#38A800', '#79C900', '#CEED00',
'#FFCC00', '#FF6600', '#FF0000', '#7A0000']
classes = create_classes(impact.flat[:], len(colours))
interval_classes = humanize_class(classes)
style_classes = []
for i in xrange(len(colours)):
style_class = dict()
if i == 1:
label = create_label(interval_classes[i], 'Low')
elif i == 4:
label = create_label(interval_classes[i], 'Medium')
elif i == 7:
label = create_label(interval_classes[i], 'High')
else:
label = create_label(interval_classes[i])
style_class['label'] = label
style_class['quantity'] = classes[i]
if i == 0:
transparency = 100
else:
transparency = 0
style_class['transparency'] = transparency
style_class['colour'] = colours[i]
style_classes.append(style_class)
style_info = dict(
target_field=None,
style_classes=style_classes,
style_type='rasterStyle')
# For printing map purpose
map_title = tr('People in need of evacuation')
legend_notes = tr(
'Thousand separator is represented by %s' %
get_thousand_separator())
legend_units = tr('(people per cell)')
legend_title = tr('Population')
# Create raster object and return
raster = Raster(
impact,
projection=hazard_layer.get_projection(),
geotransform=hazard_layer.get_geotransform(),
name=tr('Population which %s') % (
get_function_title(self).lower()),
keywords={
'impact_summary': impact_summary,
'impact_table': impact_table,
'map_title': map_title,
'legend_notes': legend_notes,
'legend_units': legend_units,
'legend_title': legend_title,
'evacuated': evacuated,
'total_needs': total_needs},
style_info=style_info)
return raster
def run(self, layers=None):
"""Risk plugin for flood population evacuation.
:param layers: List of layers expected to contain
* hazard_layer : Vector polygon layer of flood depth
* exposure_layer : Raster layer of population data on the same grid
as hazard_layer
Counts number of people exposed to areas identified as flood prone
:returns: Map of population exposed to flooding Table with number of
people evacuated and supplies required.
:rtype: tuple
"""
self.validate()
self.prepare(layers)
# Get the IF parameters
affected_field = self.parameters['affected_field']
affected_value = self.parameters['affected_value']
evacuation_percentage = self.parameters['evacuation_percentage']
# Identify hazard and exposure layers
hazard_layer = self.hazard
exposure_layer = self.exposure
# Check that hazard is polygon type
if not hazard_layer.is_polygon_data:
message = (
'Input hazard must be a polygon layer. I got %s with layer '
'type %s' %
(hazard_layer.get_name(), hazard_layer.get_geometry_name()))
raise Exception(message)
nan_warning = False
if has_no_data(exposure_layer.get_data(nan=True)):
nan_warning = True
# Check that affected field exists in hazard layer
if affected_field in hazard_layer.get_attribute_names():
self.use_affected_field = True
# Run interpolation function for polygon2raster
interpolated_layer, covered_exposure = \
assign_hazard_values_to_exposure_data(
hazard_layer,
exposure_layer,
attribute_name=self.target_field)
# Data for manipulating the covered_exposure layer
new_covered_exposure_data = covered_exposure.get_data()
covered_exposure_top_left = numpy.array([
covered_exposure.get_geotransform()[0],
covered_exposure.get_geotransform()[3]
])
covered_exposure_dimension = numpy.array([
covered_exposure.get_geotransform()[1],
covered_exposure.get_geotransform()[5]
])
# Count affected population per polygon, per category and total
total_affected_population = 0
for attr in interpolated_layer.get_data():
affected = False
if self.use_affected_field:
row_affected_value = attr[affected_field]
if row_affected_value is not None:
if isinstance(row_affected_value, Number):
type_func = type(row_affected_value)
affected = row_affected_value == type_func(
affected_value)
else:
affected =\
get_unicode(affected_value).lower() == \
get_unicode(row_affected_value).lower()
else:
# assume that every polygon is affected (see #816)
affected = True
if affected:
# Get population at this location
population = attr[self.target_field]
if not numpy.isnan(population):
population = float(population)
total_affected_population += population
else:
# If it's not affected, set the value of the impact layer to 0
grid_point = attr['grid_point']
index = numpy.floor((grid_point - covered_exposure_top_left) /
(covered_exposure_dimension)).astype(int)
new_covered_exposure_data[index[1]][index[0]] = 0
# Estimate number of people in need of evacuation
evacuated = (total_affected_population * evacuation_percentage / 100.0)
total_population = int(
numpy.nansum(exposure_layer.get_data(scaling=False)))
minimum_needs = [
parameter.serialize()
for parameter in self.parameters['minimum needs']
]
# Rounding
total_affected_population, rounding = population_rounding_full(
total_affected_population)
total_population = population_rounding(total_population)
evacuated, rounding_evacuated = population_rounding_full(evacuated)
# Generate impact report for the pdf map
table_body, total_needs = self._tabulate(total_affected_population,
evacuated, minimum_needs,
self.question, rounding,
rounding_evacuated)
impact_table = Table(table_body).toNewlineFreeString()
self._tabulate_action_checklist(table_body, total_population,
nan_warning)
impact_summary = Table(table_body).toNewlineFreeString()
# Create style
colours = [
'#FFFFFF', '#38A800', '#79C900', '#CEED00', '#FFCC00', '#FF6600',
'#FF0000', '#7A0000'
]
classes = create_classes(new_covered_exposure_data.flat[:],
len(colours))
# check for zero impact
if min(classes) == 0 == max(classes):
table_body = [
self.question,
TableRow([
tr('People affected'),
'%s' % format_int(total_affected_population)
],
header=True)
]
message = Table(table_body).toNewlineFreeString()
raise ZeroImpactException(message)
interval_classes = humanize_class(classes)
# Define style info for output polygons showing population counts
style_classes = []
for i in xrange(len(colours)):
style_class = dict()
style_class['label'] = create_label(interval_classes[i])
if i == 1:
label = create_label(
interval_classes[i],
tr('Low Population [%i people/cell]' % classes[i]))
elif i == 4:
label = create_label(
interval_classes[i],
tr('Medium Population [%i people/cell]' % classes[i]))
elif i == 7:
label = create_label(
interval_classes[i],
tr('High Population [%i people/cell]' % classes[i]))
else:
label = create_label(interval_classes[i])
if i == 0:
transparency = 100
else:
transparency = 0
style_class['label'] = label
style_class['quantity'] = classes[i]
style_class['colour'] = colours[i]
style_class['transparency'] = transparency
style_classes.append(style_class)
# Override style info with new classes and name
style_info = dict(target_field=None,
style_classes=style_classes,
style_type='rasterStyle')
# For printing map purpose
map_title = tr('People affected by flood prone areas')
legend_notes = tr('Thousand separator is represented by \'.\'')
legend_units = tr('(people per polygon)')
legend_title = tr('Population Count')
# Create vector layer and return
impact_layer = Raster(data=new_covered_exposure_data,
projection=covered_exposure.get_projection(),
geotransform=covered_exposure.get_geotransform(),
name=tr('People affected by flood prone areas'),
keywords={
'impact_summary': impact_summary,
'impact_table': impact_table,
'target_field': self.target_field,
'map_title': map_title,
'legend_notes': legend_notes,
'legend_units': legend_units,
'legend_title': legend_title,
'affected_population':
total_affected_population,
'total_population': total_population,
'total_needs': total_needs
},
style_info=style_info)
self._impact = impact_layer
return impact_layer
def run(self, layers):
"""Risk plugin for flood population evacuation.
:param layers: List of layers expected to contain
* hazard_layer : Vector polygon layer of flood depth
* exposure_layer : Raster layer of population data on the same grid
as hazard_layer
Counts number of people exposed to areas identified as flood prone
:returns: Map of population exposed to flooding Table with number of
people evacuated and supplies required.
:rtype: tuple
"""
# Identify hazard and exposure layers
hazard_layer = get_hazard_layer(layers) # Flood inundation
exposure_layer = get_exposure_layer(layers)
question = get_question(
hazard_layer.get_name(), exposure_layer.get_name(), self)
# Check that hazard is polygon type
if not hazard_layer.is_vector:
message = (
'Input hazard %s was not a vector layer as expected ' %
hazard_layer.get_name())
raise Exception(message)
message = (
'Input hazard must be a polygon layer. I got %s with layer type '
'%s' % (hazard_layer.get_name(), hazard_layer.get_geometry_name()))
if not hazard_layer.is_polygon_data:
raise Exception(message)
# Run interpolation function for polygon2raster
combined = assign_hazard_values_to_exposure_data(
hazard_layer, exposure_layer, attribute_name='population')
# Initialise attributes of output dataset with all attributes
# from input polygon and a population count of zero
new_attributes = hazard_layer.get_data()
category_title = 'affected' # FIXME: Should come from keywords
deprecated_category_title = 'FLOODPRONE'
categories = {}
for attr in new_attributes:
attr[self.target_field] = 0
try:
title = attr[category_title]
except KeyError:
try:
title = attr['FLOODPRONE']
categories[title] = 0
except KeyError:
pass
# Count affected population per polygon, per category and total
affected_population = 0
for attr in combined.get_data():
affected = False
if 'affected' in attr:
res = attr['affected']
if res is None:
x = False
else:
x = bool(res)
affected = x
elif 'FLOODPRONE' in attr:
# If there isn't an 'affected' attribute,
res = attr['FLOODPRONE']
if res is not None:
affected = res.lower() == 'yes'
elif 'Affected' in attr:
# Check the default attribute assigned for points
# covered by a polygon
res = attr['Affected']
if res is None:
x = False
else:
x = res
affected = x
else:
# assume that every polygon is affected (see #816)
affected = True
# there is no flood related attribute
# message = ('No flood related attribute found in %s. '
# 'I was looking for either "Flooded", "FLOODPRONE" '
# 'or "Affected". The latter should have been '
# 'automatically set by call to '
# 'assign_hazard_values_to_exposure_data(). '
# 'Sorry I can\'t help more.')
# raise Exception(message)
if affected:
# Get population at this location
pop = float(attr['population'])
# Update population count for associated polygon
poly_id = attr['polygon_id']
new_attributes[poly_id][self.target_field] += pop
# Update population count for each category
if len(categories) > 0:
try:
title = new_attributes[poly_id][category_title]
except KeyError:
title = new_attributes[poly_id][
deprecated_category_title]
categories[title] += pop
# Update total
affected_population += pop
# Estimate number of people in need of evacuation
evacuated = (
affected_population *
self.parameters['evacuation_percentage'] /
100.0)
affected_population, rounding = population_rounding_full(
affected_population)
total = int(numpy.sum(exposure_layer.get_data(nan=0, scaling=False)))
# Don't show digits less than a 1000
total = population_rounding(total)
evacuated, rounding_evacuated = population_rounding_full(evacuated)
minimum_needs = [
parameter.serialize() for parameter in
self.parameters['minimum needs']
]
# Generate impact report for the pdf map
table_body = [
question,
TableRow(
[tr('People affected'), '%s*' % (
format_int(int(affected_population)))],
header=True),
TableRow(
[TableCell(
tr('* Number is rounded up to the nearest %s') % (
rounding),
col_span=2)]),
TableRow([tr('People needing evacuation'), '%s*' % (
format_int(int(evacuated)))], header=True),
TableRow(
[TableCell(
tr('* Number is rounded up to the nearest %s') % (
rounding_evacuated),
col_span=2)]),
TableRow([tr('Evacuation threshold'), '%s%%' % format_int(
self.parameters['evacuation_percentage'])], header=True),
TableRow(tr(
'Map shows the number of people affected in each flood prone '
'area')),
TableRow(tr(
'Table below shows the weekly minimum needs for all '
'evacuated people'))]
total_needs = evacuated_population_needs(
evacuated, minimum_needs)
for frequency, needs in total_needs.items():
table_body.append(TableRow(
[
tr('Needs should be provided %s' % frequency),
tr('Total')
],
header=True))
for resource in needs:
table_body.append(TableRow([
tr(resource['table name']),
format_int(resource['amount'])]))
impact_table = Table(table_body).toNewlineFreeString()
table_body.append(TableRow(tr('Action Checklist:'), header=True))
table_body.append(TableRow(tr('How will warnings be disseminated?')))
table_body.append(TableRow(tr('How will we reach stranded people?')))
table_body.append(TableRow(tr('Do we have enough relief items?')))
table_body.append(TableRow(
'If yes, where are they located and how will we distribute '
'them?'))
table_body.append(TableRow(
'If no, where can we obtain additional relief items from and '
'how will we transport them to here?'))
# Extend impact report for on-screen display
table_body.extend([
TableRow(tr('Notes'), header=True),
tr('Total population: %s') % format_int(total),
tr('People need evacuation if in the area identified as '
'"Flood Prone"'),
tr('Minimum needs are defined in BNPB regulation 7/2008')])
impact_summary = Table(table_body).toNewlineFreeString()
# Create style
# Define classes for legend for flooded population counts
colours = ['#FFFFFF', '#38A800', '#79C900', '#CEED00',
'#FFCC00', '#FF6600', '#FF0000', '#7A0000']
population_counts = [x['population'] for x in new_attributes]
classes = create_classes(population_counts, len(colours))
interval_classes = humanize_class(classes)
# Define style info for output polygons showing population counts
style_classes = []
for i in xrange(len(colours)):
style_class = dict()
style_class['label'] = create_label(interval_classes[i])
if i == 0:
transparency = 0
style_class['min'] = 0
else:
transparency = 0
style_class['min'] = classes[i - 1]
style_class['transparency'] = transparency
style_class['colour'] = colours[i]
style_class['max'] = classes[i]
style_classes.append(style_class)
# Override style info with new classes and name
style_info = dict(target_field=self.target_field,
style_classes=style_classes,
style_type='graduatedSymbol')
# For printing map purpose
map_title = tr('People affected by flood prone areas')
legend_notes = tr('Thousand separator is represented by \'.\'')
legend_units = tr('(people per polygon)')
legend_title = tr('Population Count')
# Create vector layer and return
vector_layer = Vector(
data=new_attributes,
projection=hazard_layer.get_projection(),
geometry=hazard_layer.get_geometry(),
name=tr('People affected by flood prone areas'),
keywords={
'impact_summary': impact_summary,
'impact_table': impact_table,
'target_field': self.target_field,
'map_title': map_title,
'legend_notes': legend_notes,
'legend_units': legend_units,
'legend_title': legend_title,
'affected_population': affected_population,
'total_population': total,
'total_needs': total_needs},
style_info=style_info)
return vector_layer
def run(self, layers=None):
"""Risk plugin for tsunami population evacuation.
:param layers: List of layers expected to contain
hazard_layer: Raster layer of tsunami depth
exposure_layer: Raster layer of population data on the same grid
as hazard_layer
Counts number of people exposed to tsunami levels exceeding
specified threshold.
:returns: Map of population exposed to tsunami levels exceeding the
threshold. Table with number of people evacuated and supplies
required.
:rtype: tuple
"""
self.validate()
self.prepare(layers)
# Identify hazard and exposure layers
hazard_layer = self.hazard # Tsunami inundation [m]
exposure_layer = self.exposure
# Determine depths above which people are regarded affected [m]
# Use thresholds from inundation layer if specified
thresholds = self.parameters['thresholds [m]']
verify(isinstance(thresholds, list),
'Expected thresholds to be a list. Got %s' % str(thresholds))
# Extract data as numeric arrays
data = hazard_layer.get_data(nan=True) # Depth
no_data_warning = False
if has_no_data(data):
no_data_warning = True
# Calculate impact as population exposed to depths > max threshold
population = exposure_layer.get_data(nan=True, scaling=True)
if has_no_data(population):
no_data_warning = True
# Calculate impact to intermediate thresholds
counts = []
# merely initialize
impact = None
for i, lo in enumerate(thresholds):
if i == len(thresholds) - 1:
# The last threshold
impact = medium = numpy.where(data >= lo, population, 0)
else:
# Intermediate thresholds
hi = thresholds[i + 1]
medium = numpy.where((data >= lo) * (data < hi), population, 0)
# Count
val = int(numpy.nansum(medium))
# Sensible rounding
val, rounding = population_rounding_full(val)
counts.append([val, rounding])
# Carry the no data values forward to the impact layer.
impact = numpy.where(numpy.isnan(population), numpy.nan, impact)
impact = numpy.where(numpy.isnan(data), numpy.nan, impact)
# Count totals
evacuated, rounding = counts[-1]
total = int(numpy.nansum(population))
# Don't show digits less than a 1000
total = population_rounding(total)
minimum_needs = [
parameter.serialize()
for parameter in self.parameters['minimum needs']
]
# Generate impact report for the pdf map
table_body, total_needs = self._tabulate(counts, evacuated,
minimum_needs, self.question,
rounding, thresholds, total,
no_data_warning)
# Result
impact_summary = Table(table_body).toNewlineFreeString()
impact_table = impact_summary
# check for zero impact
if numpy.nanmax(impact) == 0 == numpy.nanmin(impact):
table_body = [
self.question,
TableRow([(tr('People in %.1f m of water') % thresholds[-1]),
'%s' % format_int(evacuated)],
header=True)
]
my_message = Table(table_body).toNewlineFreeString()
raise ZeroImpactException(my_message)
# Create style
colours = [
'#FFFFFF', '#38A800', '#79C900', '#CEED00', '#FFCC00', '#FF6600',
'#FF0000', '#7A0000'
]
classes = create_classes(impact.flat[:], len(colours))
interval_classes = humanize_class(classes)
style_classes = []
for i in xrange(len(colours)):
style_class = dict()
if i == 1:
label = create_label(interval_classes[i], 'Low')
elif i == 4:
label = create_label(interval_classes[i], 'Medium')
elif i == 7:
label = create_label(interval_classes[i], 'High')
else:
label = create_label(interval_classes[i])
style_class['label'] = label
style_class['quantity'] = classes[i]
if i == 0:
transparency = 100
else:
transparency = 0
style_class['transparency'] = transparency
style_class['colour'] = colours[i]
style_classes.append(style_class)
style_info = dict(target_field=None,
style_classes=style_classes,
style_type='rasterStyle')
# For printing map purpose
map_title = tr('People in need of evacuation')
legend_notes = tr('Thousand separator is represented by %s' %
get_thousand_separator())
legend_units = tr('(people per cell)')
legend_title = tr('Population')
# Create raster object and return
raster = Raster(
impact,
projection=hazard_layer.get_projection(),
geotransform=hazard_layer.get_geotransform(),
name=tr('Population which %s') %
(self.impact_function_manager.get_function_title(self).lower()),
keywords={
'impact_summary': impact_summary,
'impact_table': impact_table,
'map_title': map_title,
'legend_notes': legend_notes,
'legend_units': legend_units,
'legend_title': legend_title,
'evacuated': evacuated,
'total_needs': total_needs
},
style_info=style_info)
self._impact = raster
return raster
def run(self, layers=None):
"""Risk plugin for tsunami population evacuation.
:param layers: List of layers expected to contain
hazard_layer: Raster layer of tsunami depth
exposure_layer: Raster layer of population data on the same grid
as hazard_layer
Counts number of people exposed to tsunami levels exceeding
specified threshold.
:returns: Map of population exposed to tsunami levels exceeding the
threshold. Table with number of people evacuated and supplies
required.
:rtype: tuple
"""
self.validate()
self.prepare(layers)
# Identify hazard and exposure layers
hazard_layer = self.hazard # Tsunami inundation [m]
exposure_layer = self.exposure
# Determine depths above which people are regarded affected [m]
# Use thresholds from inundation layer if specified
thresholds = self.parameters['thresholds [m]']
verify(
isinstance(thresholds, list),
'Expected thresholds to be a list. Got %s' % str(thresholds))
# Extract data as numeric arrays
data = hazard_layer.get_data(nan=True) # Depth
no_data_warning = False
if has_no_data(data):
no_data_warning = True
# Calculate impact as population exposed to depths > max threshold
population = exposure_layer.get_data(nan=True, scaling=True)
if has_no_data(population):
no_data_warning = True
# Calculate impact to intermediate thresholds
counts = []
# merely initialize
impact = None
for i, lo in enumerate(thresholds):
if i == len(thresholds) - 1:
# The last threshold
impact = medium = numpy.where(data >= lo, population, 0)
else:
# Intermediate thresholds
hi = thresholds[i + 1]
medium = numpy.where((data >= lo) * (data < hi), population, 0)
# Count
val = int(numpy.nansum(medium))
# Sensible rounding
val, rounding = population_rounding_full(val)
counts.append([val, rounding])
# Carry the no data values forward to the impact layer.
impact = numpy.where(numpy.isnan(population), numpy.nan, impact)
impact = numpy.where(numpy.isnan(data), numpy.nan, impact)
# Count totals
evacuated, rounding = counts[-1]
total = int(numpy.nansum(population))
# Don't show digits less than a 1000
total = population_rounding(total)
minimum_needs = [
parameter.serialize() for parameter in
self.parameters['minimum needs']
]
# Generate impact report for the pdf map
table_body, total_needs = self._tabulate(
counts,
evacuated,
minimum_needs,
self.question,
rounding,
thresholds,
total,
no_data_warning)
# Result
impact_summary = Table(table_body).toNewlineFreeString()
impact_table = impact_summary
# check for zero impact
if numpy.nanmax(impact) == 0 == numpy.nanmin(impact):
table_body = [
self.question,
TableRow([(tr('People in %.1f m of water') % thresholds[-1]),
'%s' % format_int(evacuated)],
header=True)]
my_message = Table(table_body).toNewlineFreeString()
raise ZeroImpactException(my_message)
# Create style
colours = [
'#FFFFFF', '#38A800', '#79C900', '#CEED00',
'#FFCC00', '#FF6600', '#FF0000', '#7A0000']
classes = create_classes(impact.flat[:], len(colours))
interval_classes = humanize_class(classes)
style_classes = []
for i in xrange(len(colours)):
style_class = dict()
if i == 1:
label = create_label(interval_classes[i], 'Low')
elif i == 4:
label = create_label(interval_classes[i], 'Medium')
elif i == 7:
label = create_label(interval_classes[i], 'High')
else:
label = create_label(interval_classes[i])
style_class['label'] = label
style_class['quantity'] = classes[i]
if i == 0:
transparency = 100
else:
transparency = 0
style_class['transparency'] = transparency
style_class['colour'] = colours[i]
style_classes.append(style_class)
style_info = dict(
target_field=None,
style_classes=style_classes,
style_type='rasterStyle')
# For printing map purpose
map_title = tr('People in need of evacuation')
legend_notes = tr(
'Thousand separator is represented by %s' %
get_thousand_separator())
legend_units = tr('(people per cell)')
legend_title = tr('Population')
# Create raster object and return
raster = Raster(
impact,
projection=hazard_layer.get_projection(),
geotransform=hazard_layer.get_geotransform(),
name=tr('Population which %s') % (
self.impact_function_manager.get_function_title(self).lower()),
keywords={
'impact_summary': impact_summary,
'impact_table': impact_table,
'map_title': map_title,
'legend_notes': legend_notes,
'legend_units': legend_units,
'legend_title': legend_title,
'evacuated': evacuated,
'total_needs': total_needs},
style_info=style_info)
self._impact = raster
return raster