def test_assets_for_cell_with_one(self): # A single asset in the risk cell is found. site = shapes.Site(10.15, 46.15) self.job_ctxt.oq_job_profile.region_grid_spacing = 0.3 self.job_ctxt.oq_job_profile.save() [asset] = BaseRiskCalculator.assets_for_cell(self.job.id, site) self.assertEqual(self.sites[1], self._to_site(asset.site))
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 test_assets_for_cell_with_no_assets_matching(self): # An empty list is returned when no assets exist for a given # risk cell. site = shapes.Site(99.15000, 15.16667) self.job_ctxt.oq_job_profile.region_grid_spacing = 0.05 self.job_ctxt.oq_job_profile.save() self.assertEqual([], BaseRiskCalculator.assets_for_cell(self.job.id, site))
def test_assets_for_cell_with_more_than_one(self): # All assets in the risk cell are found. site = shapes.Site(10.3, 46.3) self.job_ctxt.oq_job_profile.region_grid_spacing = 0.6 self.job_ctxt.oq_job_profile.save() assets = BaseRiskCalculator.assets_for_cell(self.job.id, site) self.assertEqual(3, len(assets)) # Make sure the assets associated with the first 3 added sites were # selected. for s, a in zip(self.sites, sorted(assets, key=lambda a: a.site.x)): self.assertEqual(s, self._to_site(a.site))
def test_asset_bcr_per_site(self): self._make_job({}) self._prepare_bcr_result() job = BaseRiskCalculator(self.job) bcr_per_site = job.asset_bcr_per_site() self.assertEqual(bcr_per_site, [ (shapes.Site(-1.1, 19.0), [ [{u'bcr': 35.1, 'eal_original': 12.34, 'eal_retrofitted': 4}, u'assetID-191'], [{u'bcr': 35.2, 'eal_original': 2.5, 'eal_retrofitted': 2.2}, u'assetID-192'] ]), (shapes.Site(2.3, 20.0), [ [{u'bcr': 35.1, 'eal_original': 1.23, 'eal_retrofitted': 0.3}, u'assetID-201'], [{u'bcr': 35.2, 'eal_original': 4, 'eal_retrofitted': 0.4}, u'assetID-202'] ]) ])
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 test_compute_risk_in_the_classical_psha_calculator(self): """ tests ClassicalRiskCalculator.compute_risk by retrieving all the loss curves in the kvs and checks their presence """ helpers.delete_profile(self.job) cls_risk_cfg = helpers.demo_file( 'classical_psha_based_risk/config.gem') job_profile, params, sections = engine.import_job_profile( cls_risk_cfg, self.job) # We need to adjust a few of the parameters for this test: params['REGION_VERTEX'] = '0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0' job_profile.region = GEOSGeometry(shapes.polygon_ewkt_from_coords( params['REGION_VERTEX'])) job_profile.save() job_ctxt = engine.JobContext( params, self.job_id, sections=sections, oq_job_profile=job_profile) self._compute_risk_classical_psha_setup() calculator = classical_core.ClassicalRiskCalculator(job_ctxt) calculator.vuln_curves = {"ID": self.vuln_function} block = Block.from_kvs(self.job_id, self.block_id) # computes the loss curves and puts them in kvs calculator.compute_risk(self.block_id) for point in block.grid(job_ctxt.region): assets = BaseRiskCalculator.assets_for_cell( self.job_id, point.site) for asset in assets: loss_ratio_key = kvs.tokens.loss_ratio_key( self.job_id, point.row, point.column, asset.asset_ref) self.assertTrue(kvs.get_client().get(loss_ratio_key)) loss_key = kvs.tokens.loss_curve_key( self.job_id, point.row, point.column, asset.asset_ref) self.assertTrue(kvs.get_client().get(loss_key))
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_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))