def test_write_map_data_to_db_results_with_loss_map(self):
"""
The write_map_data_to_db() return values are correct for loss maps.
"""
expected_loss_data = [([-118.229726, 34.050622], 16.04934554846202),
([-118.241243, 34.061557], 629.323267954),
([-118.245388, 34.055984], 245.9928520658)]
def coords(idx):
"""Access the point coordinates."""
return tuple(expected_loss_data[idx][0])
def value(idx):
"""Access the loss value."""
return view_utils.round_float(expected_loss_data[idx][1])
loss_map = self.setup_output(output_type="loss_map")
self.job_to_tear_down = loss_map.oq_job
config = {
"key": "%s" % loss_map.id,
"layer": "77-lossmap-0.01-quantile-0.25",
"output": "tests/77",
"path": "tests/data/loss-map-0fcfdbc7.xml",
"type": "loss"
}
db_key, minimum, maximum = write_map_data_to_db(config)
self.assertEqual(config["key"], db_key)
self.assertEqual(
min(value(idx) for idx in range(len(expected_loss_data))),
view_utils.round_float(minimum))
self.assertEqual(
max(value(idx) for idx in range(len(expected_loss_data))),
view_utils.round_float(maximum))
def prepare_map_result(output):
"""Prepare a json fragment for a single hazard/loss map.
The desired json fragment should look as follows:
{"id": 77, "name": "loss-map-0fcfdbc7.xml", "type": "loss map",
"min": 2.718281, "max": 3.141593,
"layer": {
"ows": "http://gemsun02.ethz.ch/geoserver-geonode-dev/ows"
"layer": "geonode:77-loss-map-0fcfdbc7"}}
:param output: the :py:class:`geonode.mtapi.models.Output` instance
in question
:returns: a dictionary with data needed to produce the json above.
"""
map_type = dict(output.OUTPUT_TYPE_CHOICES)[output.output_type].lower()
if output.output_type == "hazard_map":
layer_name = "hazard_map_data"
else:
layer_name = "loss_map_data"
ows = urljoin(settings.GEOSERVER_BASE_URL, "ows")
result = dict(
name="%s-%s" % (output.oq_job.id, output.display_name),
type=map_type, min=view_utils.round_float(output.min_value),
id=output.id, max=view_utils.round_float(output.max_value),
layer=dict(ows=ows, layer="geonode:%s" % layer_name,
filter="output_id=%s" % output.id))
return result
def test_write_map_data_to_db_results_with_loss_map(self):
"""
The write_map_data_to_db() return values are correct for loss maps.
"""
expected_loss_data = [
([-118.229726, 34.050622], 16.04934554846202),
([-118.241243, 34.061557], 629.323267954),
([-118.245388, 34.055984], 245.9928520658)]
def coords(idx):
"""Access the point coordinates."""
return tuple(expected_loss_data[idx][0])
def value(idx):
"""Access the loss value."""
return view_utils.round_float(expected_loss_data[idx][1])
loss_map = self.setup_output(output_type="loss_map")
self.job_to_tear_down = loss_map.oq_job
config = {
"key": "%s" % loss_map.id,
"layer": "77-lossmap-0.01-quantile-0.25",
"output": "tests/77", "path": "tests/data/loss-map-0fcfdbc7.xml",
"type": "loss"}
db_key, minimum, maximum = write_map_data_to_db(config)
self.assertEqual(config["key"], db_key)
self.assertEqual(
min(value(idx) for idx in range(len(expected_loss_data))),
view_utils.round_float(minimum))
self.assertEqual(
max(value(idx) for idx in range(len(expected_loss_data))),
view_utils.round_float(maximum))
def test_write_map_data_to_db_results_with_hazard_map(self):
"""
The write_map_data_to_db() return values are correct for hazard maps.
"""
expected_hazard_data = [([-121.8, 37.9], 1.23518683436),
([-122.0, 37.5], 1.19244541041),
([-122.1, 38.0], 1.1905288226)]
def coords(idx):
"""Access the point coordinates."""
return tuple(expected_hazard_data[idx][0])
def value(idx):
"""Access the hazard value."""
return view_utils.round_float(expected_hazard_data[idx][1])
hazard_map = self.setup_output(output_type="hazard_map")
self.job_to_tear_down = hazard_map.oq_job
config = {
"key": "%s" % hazard_map.id,
"layer": "78-hazardmap-0.01-quantile-0.25",
"output": "tests/78",
"path": "tests/data/hazardmap-0.1-quantile-0.25.xml",
"type": "hazard"
}
db_key, minimum, maximum = write_map_data_to_db(config)
self.assertEqual(config["key"], db_key)
self.assertEqual(
min(value(idx) for idx in range(len(expected_hazard_data))),
view_utils.round_float(minimum))
self.assertEqual(
max(value(idx) for idx in range(len(expected_hazard_data))),
view_utils.round_float(maximum))
def test_write_map_data_to_db_results_with_hazard_map(self):
"""
The write_map_data_to_db() return values are correct for hazard maps.
"""
expected_hazard_data = [
([-121.8, 37.9], 1.23518683436),
([-122.0, 37.5], 1.19244541041),
([-122.1, 38.0], 1.1905288226)]
def coords(idx):
"""Access the point coordinates."""
return tuple(expected_hazard_data[idx][0])
def value(idx):
"""Access the hazard value."""
return view_utils.round_float(expected_hazard_data[idx][1])
hazard_map = self.setup_output(output_type="hazard_map")
self.job_to_tear_down = hazard_map.oq_job
config = {
"key": "%s" % hazard_map.id,
"layer": "78-hazardmap-0.01-quantile-0.25",
"output": "tests/78",
"path": "tests/data/hazardmap-0.1-quantile-0.25.xml",
"type": "hazard"}
db_key, minimum, maximum = write_map_data_to_db(config)
self.assertEqual(config["key"], db_key)
self.assertEqual(
min(value(idx) for idx in range(len(expected_hazard_data))),
view_utils.round_float(minimum))
self.assertEqual(
max(value(idx) for idx in range(len(expected_hazard_data))),
view_utils.round_float(maximum))
def test_write_map_data_to_db_with_hazard_map(self):
"""
Writing hazard map data works.
"""
expected_hazard_data = [([-122.1, 38.0], 1.1905288226),
([-122.0, 37.5], 1.19244541041),
([-121.8, 37.9], 1.23518683436)]
def coords(idx):
"""Access the point coordinates."""
return tuple(expected_hazard_data[idx][0])
def value(idx):
"""Access the hazard value."""
return view_utils.round_float(expected_hazard_data[idx][1])
hazard_map = self.setup_output(output_type="hazard_map")
self.job_to_tear_down = hazard_map.oq_job
config = {
"key": "%s" % hazard_map.id,
"layer": "78-hazardmap-0.01-quantile-0.25",
"output": "tests/78",
"path": "tests/data/hazardmap-0.1-quantile-0.25.xml",
"type": "hazard"
}
write_map_data_to_db(config)
self.assertEqual(0, len(hazard_map.lossmapdata_set.all()))
self.assertEqual(3, len(hazard_map.hazardmapdata_set.all()))
# don't depend on sort order
all_hazard = sorted([(h.location.coords, h.value)
for h in hazard_map.hazardmapdata_set.all()])
for idx, hazard in enumerate(all_hazard):
self.assertEqual(coords(idx), hazard[0])
self.assertEqual(value(idx), view_utils.round_float(hazard[1]))
def test_write_map_data_to_db_with_hazard_map(self):
"""
Writing hazard map data works.
"""
expected_hazard_data = [
([-121.8, 37.9], 1.23518683436),
([-122.0, 37.5], 1.19244541041),
([-122.1, 38.0], 1.1905288226)]
def coords(idx):
"""Access the point coordinates."""
return tuple(expected_hazard_data[idx][0])
def value(idx):
"""Access the hazard value."""
return view_utils.round_float(expected_hazard_data[idx][1])
hazard_map = self.setup_output(output_type="hazard_map")
self.job_to_tear_down = hazard_map.oq_job
config = {
"key": "%s" % hazard_map.id,
"layer": "78-hazardmap-0.01-quantile-0.25",
"output": "tests/78",
"path": "tests/data/hazardmap-0.1-quantile-0.25.xml",
"type": "hazard"}
write_map_data_to_db(config)
self.assertEqual(0, len(hazard_map.lossmapdata_set.all()))
self.assertEqual(3, len(hazard_map.hazardmapdata_set.all()))
for idx, hazard in enumerate(hazard_map.hazardmapdata_set.all()):
self.assertEqual(coords(idx), hazard.location.coords)
self.assertEqual(value(idx), view_utils.round_float(hazard.value))
def test_write_map_data_to_db_with_loss_map(self):
"""
Writing hazard loss data works.
"""
expected_loss_data = [([-118.229726, 34.050622], 16.04934554846202),
([-118.241243, 34.061557], 629.323267954),
([-118.245388, 34.055984], 245.9928520658)]
def coords(idx):
"""Access the point coordinates."""
return tuple(expected_loss_data[idx][0])
def value(idx):
"""Access the loss value."""
return view_utils.round_float(expected_loss_data[idx][1])
loss_map = self.setup_output(output_type="loss_map")
self.job_to_tear_down = loss_map.oq_job
config = {
"key": "%s" % loss_map.id,
"layer": "77-lossmap-0.01-quantile-0.25",
"output": "tests/77",
"path": "tests/data/loss-map-0fcfdbc7.xml",
"type": "loss"
}
write_map_data_to_db(config)
self.assertEqual(0, len(loss_map.hazardmapdata_set.all()))
self.assertEqual(3, len(loss_map.lossmapdata_set.all()))
for idx, loss in enumerate(loss_map.lossmapdata_set.all()):
self.assertEqual(coords(idx), loss.location.coords)
self.assertEqual(value(idx), view_utils.round_float(loss.value))
def test_write_map_data_to_db_with_loss_map(self):
"""
Writing hazard loss data works.
"""
expected_loss_data = [
([-118.229726, 34.050622], 16.04934554846202),
([-118.241243, 34.061557], 629.323267954),
([-118.245388, 34.055984], 245.9928520658)]
def coords(idx):
"""Access the point coordinates."""
return tuple(expected_loss_data[idx][0])
def value(idx):
"""Access the loss value."""
return view_utils.round_float(expected_loss_data[idx][1])
loss_map = self.setup_output(output_type="loss_map")
self.job_to_tear_down = loss_map.oq_job
config = {
"key": "%s" % loss_map.id,
"layer": "77-lossmap-0.01-quantile-0.25",
"output": "tests/77", "path": "tests/data/loss-map-0fcfdbc7.xml",
"type": "loss"}
write_map_data_to_db(config)
self.assertEqual(0, len(loss_map.hazardmapdata_set.all()))
self.assertEqual(3, len(loss_map.lossmapdata_set.all()))
for idx, loss in enumerate(loss_map.lossmapdata_set.all()):
self.assertEqual(coords(idx), loss.location.coords)
self.assertEqual(value(idx), view_utils.round_float(loss.value))
def test_prepare_job_result_with_succeeded_and_maps(self):
"""
The result dictionary for succeeded OpenQuake jobs (w/o hazard/loss
maps) is prepared correctly.
"""
hazard_map = self.setup_output()
self.job_to_teardown = job = hazard_map.oq_job
self.add_shapefile_data(hazard_map)
hazard_layer, _ = os.path.splitext(
os.path.basename(hazard_map.shapefile_path))
hazard_file = os.path.basename(hazard_map.path)
loss_map = self.setup_output(job_to_use=job, output_type="loss_map")
self.add_shapefile_data(loss_map)
loss_layer, _ = os.path.splitext(
os.path.basename(loss_map.shapefile_path))
loss_file = os.path.basename(loss_map.path)
job.status = "succeeded"
expected = {
"id": job.id,
"msg": "Calculation succeeded",
"status": "success",
"files": [
{"id": hazard_map.id,
"layer": {
"layer": "geonode:hazard_map_data",
"filter": "output_id=%s" % hazard_map.id,
"ows": "http://gemsun02.ethz.ch/geoserver-geonode-dev/ows"},
"min": view_utils.round_float(hazard_map.min_value),
"max": view_utils.round_float(hazard_map.max_value),
"name": "%s-%s" % (job.id, hazard_file),
"type": "hazard map"},
{"id": loss_map.id,
"layer": {
"layer": "geonode:loss_map_data",
"filter": "output_id=%s" % loss_map.id,
"ows": "http://gemsun02.ethz.ch/geoserver-geonode-dev/ows"},
"min": view_utils.round_float(loss_map.min_value),
"max": view_utils.round_float(loss_map.max_value),
"name": "%s-%s" % (job.id, loss_file),
"type": "loss map"}]}
actual = prepare_job_result(job)
self.assertEqual(expected, actual)
def test_prepare_map_result_with_loss(self):
"""
prepare_map_result() returns a correct result dictionary for a
hazard map.
"""
self.output = self.setup_output(output_type="loss_map")
self.output.min_value, self.output.max_value = (30.0, 40.0)
name = os.path.basename(self.output.path)
map_type = ("loss map" if self.output.output_type == "loss_map"
else "loss map")
expected = {
"layer": {
"layer": "geonode:loss_map_data",
"filter": "output_id=%s" % self.output.id,
"ows": "http://gemsun02.ethz.ch/geoserver-geonode-dev/ows"},
"name": "%s-%s" % (self.output.oq_job.id, name),
"min": view_utils.round_float(self.output.min_value),
"max": view_utils.round_float(self.output.max_value),
"type": map_type,
"id": self.output.id}
actual = prepare_map_result(self.output)
self.assertEqual(expected, actual)
def _upper_bound(iml_n, iml_n_1):
"""
Calculate an upper bound given the last (n) and second-to-last (n-1) values
in a vulnerability IML set.
:type iml_n: float
:type iml_n_1: float
:py:function:`view_utils.round_float` is used with the calculated bound
values to maintain reasonable limits on precision.
"""
upper_bound = view_utils.round_float(iml_n + ((iml_n - iml_n_1) / 2))
assert upper_bound > 0.0, \
"Invalid upper bound '%s': must be > 0.0" % upper_bound
return upper_bound
def _lower_bound(iml_1, iml_2):
"""
Calculate a lower bound given the first and second values in a
vulnerability IML set.
:type iml_1: float
:type iml_2: float
:py:function:`view_utils.round_float` is used with the calculated bound
values to maintain reasonable limits on precision.
"""
lower_bound = view_utils.round_float(iml_1 - ((iml_2 - iml_1) / 2))
assert lower_bound > 0.0, \
"Invalid lower bound '%s': must be > 0.0" % lower_bound
return lower_bound
def _upper_bound(iml_n, iml_n_1):
"""
Calculate an upper bound given the last (n) and second-to-last (n-1) values
in a vulnerability IML set.
:type iml_n: float
:type iml_n_1: float
:py:function:`view_utils.round_float` is used with the calculated bound
values to maintain reasonable limits on precision.
"""
upper_bound = view_utils.round_float(iml_n + ((iml_n - iml_n_1) / 2))
assert upper_bound > 0.0, \
"Invalid upper bound '%s': must be > 0.0" % upper_bound
return upper_bound
def _lower_bound(iml_1, iml_2):
"""
Calculate a lower bound given the first and second values in a
vulnerability IML set.
:type iml_1: float
:type iml_2: float
:py:function:`view_utils.round_float` is used with the calculated bound
values to maintain reasonable limits on precision.
"""
lower_bound = view_utils.round_float(iml_1 - ((iml_2 - iml_1) / 2))
assert lower_bound > 0.0, \
"Invalid lower bound '%s': must be > 0.0" % lower_bound
return lower_bound
def value(idx):
"""Access the hazard value."""
return view_utils.round_float(expected_hazard_data[idx][1])
def value(idx):
"""Access the loss value."""
return view_utils.round_float(expected_loss_data[idx][1])
def value(idx):
"""Access the loss value."""
return view_utils.round_float(expected_loss_data[idx][1])
def value(idx):
"""Access the hazard value."""
return view_utils.round_float(expected_hazard_data[idx][1])
