def test_multiple_assets_per_site(self):
site = shapes.Site(1.0, 2.0)
assets = BaseRiskCalculator.assets_at(self.job.id, site)
self.assertEqual(2, len(assets))
self.assertEqual("ASSET_1", assets[0].asset_ref)
self.assertEqual("ASSET_2", assets[1].asset_ref)
def test_multiple_assets_per_site(self):
site = shapes.Site(1.0, 2.0)
assets = BaseRiskCalculator.assets_at(self.job.id, site)
self.assertEqual(2, len(assets))
self.assertEqual("ASSET_1", assets[0].asset_ref)
self.assertEqual("ASSET_2", assets[1].asset_ref)
def _compute_loss(self, block_id):
"""
Calculate and store in the kvs the loss data.
"""
block = Block.from_kvs(self.job_ctxt.job_id, block_id)
vuln_curves = vulnerability.load_vuln_model_from_kvs(self.job_ctxt.job_id)
lrem_steps = self.job_ctxt.oq_job_profile.lrem_steps_per_interval
loss_poes = conditional_loss_poes(self.job_ctxt.params)
assets_getter = lambda site: BaseRiskCalculator.assets_at(self.job_ctxt.job_id, site)
hazard_getter = lambda site: (
self.job_ctxt.region.grid.point_at(site),
self._get_db_curve(hazard_input_site(self.job_ctxt, site)),
)
def on_asset_complete(asset, point, loss_ratio_curve, loss_curve, loss_conditionals):
loss_key = kvs.tokens.loss_curve_key(self.job_ctxt.job_id, point.row, point.column, asset.asset_ref)
kvs.get_client().set(loss_key, loss_curve.to_json())
for poe, loss in loss_conditionals.items():
key = kvs.tokens.loss_key(self.job_ctxt.job_id, point.row, point.column, asset.asset_ref, poe)
kvs.get_client().set(key, loss)
loss_ratio_key = kvs.tokens.loss_ratio_key(self.job_ctxt.job_id, point.row, point.column, asset.asset_ref)
kvs.get_client().set(loss_ratio_key, loss_ratio_curve.to_json())
classical.compute(
block.sites, assets_getter, vuln_curves, hazard_getter, lrem_steps, loss_poes, on_asset_complete
)
def _compute_bcr(self, block_id):
"""
Calculate and store in the kvs the benefit-cost ratio data for block.
A value is stored with key :func:`openquake.kvs.tokens.bcr_block_key`.
See :func:`openquake.risk.job.general.compute_bcr_for_block` for result
data structure spec.
"""
result = defaultdict(list)
block = Block.from_kvs(self.job_ctxt.job_id, block_id)
vulnerability_model_original = vulnerability.load_vuln_model_from_kvs(
self.job_ctxt.job_id)
vulnerability_model_retrofitted = (
vulnerability.load_vuln_model_from_kvs(
self.job_ctxt.job_id, retrofitted=True))
steps = self.job_ctxt.oq_job_profile.lrem_steps_per_interval
assets_getter = lambda site: BaseRiskCalculator.assets_at(
self.job_ctxt.job_id, site)
hazard_getter = lambda site: (
self._get_db_curve(hazard_input_site(self.job_ctxt, site)))
bcr = api.bcr(api.classical(vulnerability_model_original, steps=steps),
api.classical(vulnerability_model_retrofitted, steps=steps),
float(self.job_ctxt.params["INTEREST_RATE"]),
float(self.job_ctxt.params["ASSET_LIFE_EXPECTANCY"]))
for asset_output in api.compute_on_sites(
block.sites, assets_getter, hazard_getter, bcr):
asset = asset_output.asset
result[(asset.site.x, asset.site.y)].append(({
"bcr": asset_output.bcr,
"eal_original": asset_output.eal_original,
"eal_retrofitted": asset_output.eal_retrofitted},
asset.asset_ref))
bcr = result.items()
bcr_block_key = kvs.tokens.bcr_block_key(
self.job_ctxt.job_id, block_id)
kvs.set_value_json_encoded(bcr_block_key, bcr)
LOGGER.debug("bcr result for block %s: %r", block_id, bcr)
return True
def _compute_loss(self, block_id):
"""
Calculate and store in the kvs the loss data.
"""
block = Block.from_kvs(self.job_ctxt.job_id, block_id)
vulnerability_model = vulnerability.load_vuln_model_from_kvs(
self.job_ctxt.job_id)
steps = self.job_ctxt.oq_job_profile.lrem_steps_per_interval
assets_getter = lambda site: BaseRiskCalculator.assets_at(
self.job_ctxt.job_id, site)
hazard_getter = lambda site: (
self._get_db_curve(hazard_input_site(self.job_ctxt, site)))
calculator = api.conditional_losses(
conditional_loss_poes(self.job_ctxt.params),
api.classical(vulnerability_model, steps=steps))
for asset_output in api.compute_on_sites(block.sites,
assets_getter, hazard_getter, calculator):
location = asset_output.asset.site
point = self.job_ctxt.region.grid.point_at(
shapes.Site(location.x, location.y))
loss_key = kvs.tokens.loss_curve_key(
self.job_ctxt.job_id, point.row,
point.column, asset_output.asset.asset_ref)
kvs.get_client().set(loss_key, asset_output.loss_curve.to_json())
loss_ratio_key = kvs.tokens.loss_ratio_key(self.job_ctxt.job_id,
point.row, point.column, asset_output.asset.asset_ref)
kvs.get_client().set(loss_ratio_key,
asset_output.loss_ratio_curve.to_json())
for poe, loss in asset_output.conditional_losses.items():
key = kvs.tokens.loss_key(
self.job_ctxt.job_id, point.row, point.column,
asset_output.asset.asset_ref, poe)
kvs.get_client().set(key, loss)
def _compute_bcr(self, block_id):
"""
Calculate and store in the kvs the benefit-cost ratio data for block.
A value is stored with key :func:`openquake.kvs.tokens.bcr_block_key`.
See :func:`openquake.risk.job.general.compute_bcr_for_block` for result
data structure spec.
"""
job_ctxt = self.job_ctxt
job_id = job_ctxt.job_id
block = Block.from_kvs(job_id, block_id)
result = defaultdict(list)
def on_asset_complete(asset, bcr, eal_original, eal_retrofitted):
result[(asset.site.x, asset.site.y)].append(
({"bcr": bcr, "eal_original": eal_original, "eal_retrofitted": eal_retrofitted}, asset.asset_ref)
)
benefit_cost_ratio.compute(
block.sites,
lambda site: BaseRiskCalculator.assets_at(job_id, site),
vulnerability.load_vuln_model_from_kvs(job_id),
vulnerability.load_vuln_model_from_kvs(job_id, retrofitted=True),
lambda site: self._get_db_curve(hazard_input_site(self.job_ctxt, site)),
self.job_ctxt.oq_job_profile.lrem_steps_per_interval,
float(job_ctxt.params["INTEREST_RATE"]),
float(job_ctxt.params["ASSET_LIFE_EXPECTANCY"]),
on_asset_complete,
)
bcr = result.items()
bcr_block_key = kvs.tokens.bcr_block_key(job_ctxt.job_id, block_id)
kvs.set_value_json_encoded(bcr_block_key, bcr)
LOGGER.debug("bcr result for block %s: %r", block_id, bcr)
return True
def test_no_assets_at_site(self):
# nothing is stored at this location
site = shapes.Site(10.0, 10.0)
self.assertEqual([], BaseRiskCalculator.assets_at(self.job.id, site))
def test_one_asset_per_site(self):
site = shapes.Site(2.0, 2.0)
assets = BaseRiskCalculator.assets_at(self.job.id, site)
self.assertEqual(1, len(assets))
self.assertEqual("ASSET_3", assets[0].asset_ref)
def test_no_assets_at_site(self):
# nothing is stored at this location
site = shapes.Site(10.0, 10.0)
self.assertEqual([], BaseRiskCalculator.assets_at(self.job.id, site))
def test_one_asset_per_site(self):
site = shapes.Site(2.0, 2.0)
assets = BaseRiskCalculator.assets_at(self.job.id, site)
self.assertEqual(1, len(assets))
self.assertEqual("ASSET_3", assets[0].asset_ref)
