def classical_bcr(job_id, hazard, vulnerability_function, vulnerability_function_retrofitted, output_containers, lrem_steps_per_interval, asset_life_expectancy, interest_rate): """ Celery task for the BCR risk calculator based on the classical calculator. Instantiates risklib calculators, computes BCR and stores the results to db in a single transaction. :param int job_id: ID of the currently running job :param dict hazard: A dictionary mapping IDs of :class:`openquake.engine.db.models.Output` (with output_type set to 'hazard_curve') to a tuple where the first element is an instance of :class:`..hazard_getters.HazardCurveGetter, and the second element is the corresponding weight. :param output_containers: A dictionary mapping hazard Output ID to a tuple with only the ID of the :class:`openquake.engine.db.models.BCRDistribution` output container used to store the computed bcr distribution :param int lrem_steps_per_interval Steps per interval used to compute the Loss Ratio Exceedance matrix :param float interest_rate The interest rate used in the Cost Benefit Analysis :param float asset_life_expectancy The life expectancy used for every asset """ calc_original = api.Classical( vulnerability_function, lrem_steps_per_interval) calc_retrofitted = api.Classical( vulnerability_function_retrofitted, lrem_steps_per_interval) for hazard_output_id, hazard_data in hazard.items(): hazard_getter, _ = hazard_data (bcr_distribution_id,) = output_containers[hazard_output_id] calculator = api.BCR( calc_original, calc_retrofitted, interest_rate, asset_life_expectancy) with logs.tracing('getting hazard'): assets, hazard_curves, missings = hazard_getter() with logs.tracing('computing risk over %d assets' % len(assets)): asset_outputs = calculator(assets, hazard_curves) with logs.tracing('writing results'): with transaction.commit_on_success(using='reslt_writer'): for i, asset_output in enumerate(asset_outputs): general.write_bcr_distribution( bcr_distribution_id, assets[i], asset_output) base.signal_task_complete(job_id=job_id, num_items=len(assets) + len(missings))
def classical_bcr(job_id, assets, hazard_getter_name, hazard, vulnerability_function, vulnerability_function_retrofitted, output_containers, lrem_steps_per_interval, asset_life_expectancy, interest_rate): """ Celery task for the BCR risk calculator based on the classical calculator. Instantiates risklib calculators, computes BCR and stores the results to db in a single transaction. :param int job_id: ID of the currently running job :param assets: list of Assets to take into account :param str hazard_getter_name: class name of a class defined in the :mod:`openquake.engine.calculators.risk.hazard_getters` to be instantiated to get the hazard curves :param dict hazard: A dictionary mapping hazard Output ID to HazardCurve ID :param output_containers: A dictionary mapping hazard Output ID to a tuple with only the ID of the :class:`openquake.engine.db.models.BCRDistribution` output container used to store the computed bcr distribution :param int lrem_steps_per_interval Steps per interval used to compute the Loss Ratio Exceedance matrix :param float interest_rate The interest rate used in the Cost Benefit Analysis :param float asset_life_expectancy The life expectancy used for every asset """ for hazard_output_id, hazard_data in hazard.items(): hazard_id, _ = hazard_data (bcr_distribution_id,) = output_containers[hazard_output_id] hazard_getter = general.hazard_getter(hazard_getter_name, hazard_id) calculator = api.BCR( api.Classical(vulnerability_function, lrem_steps_per_interval), api.Classical(vulnerability_function_retrofitted, lrem_steps_per_interval), interest_rate, asset_life_expectancy) with logs.tracing('getting hazard'): hazard_curves = [hazard_getter(asset.site) for asset in assets] with logs.tracing('computing risk over %d assets' % len(assets)): asset_outputs = calculator(assets, hazard_curves) with logs.tracing('writing results'): with transaction.commit_on_success(using='reslt_writer'): for i, asset_output in enumerate(asset_outputs): general.write_bcr_distribution( bcr_distribution_id, assets[i], asset_output) base.signal_task_complete(job_id=job_id, num_items=len(assets))
def event_based_bcr(job_id, hazard, seed, vulnerability_function, vulnerability_function_retrofitted, output_containers, time_span, tses, loss_curve_resolution, asset_correlation, asset_life_expectancy, interest_rate): """ Celery task for the BCR risk calculator based on the event based calculator. Instantiates risklib calculators, computes bcr and stores results to db in a single transaction. :param int job_id: ID of the currently running job. :param dict hazard: A dictionary mapping IDs of :class:`openquake.engine.db.models.Output` (with output_type set to 'gmf_collection') to a tuple where the first element is a list of list (one for each asset) with the ground motion values used by the calculation, and the second element is the corresponding weight. :param output_containers: A dictionary mapping hazard Output ID to a tuple with only the ID of the :class:`openquake.engine.db.models.BCRDistribution` output container used to store the computed bcr distribution :param float time_span: Time Span of the hazard calculation. :param float tses: Time of the Stochastic Event Set. :param int loss_curve_resolution: Resolution of the computed loss curves (number of points). :param int seed: Seed used to generate random values. :param float asset_correlation: asset correlation (0 uncorrelated, 1 perfectly correlated). :param float interest_rate The interest rate used in the Cost Benefit Analysis. :param float asset_life_expectancy The life expectancy used for every asset. """ for hazard_output_id, hazard_data in hazard.items(): hazard_getter, _ = hazard_data (bcr_distribution_id,) = output_containers[hazard_output_id] # FIXME(lp). We should not pass the exact same seed for # different hazard calculator = api.ProbabilisticEventBased( vulnerability_function, curve_resolution=loss_curve_resolution, time_span=time_span, tses=tses, seed=seed, correlation=asset_correlation) calculator_retrofitted = api.ProbabilisticEventBased( vulnerability_function_retrofitted, curve_resolution=loss_curve_resolution, time_span=time_span, tses=tses, seed=seed, correlation=asset_correlation) bcr_calculator = api.BCR(calculator, calculator_retrofitted, interest_rate, asset_life_expectancy) with logs.tracing('getting hazard'): assets, ground_motion_fields, missings = hazard_getter() with logs.tracing('computing risk over %d assets' % len(assets)): asset_outputs = bcr_calculator(assets, ground_motion_fields) with logs.tracing('writing results'): with transaction.commit_on_success(using='reslt_writer'): for i, asset_output in enumerate(asset_outputs): general.write_bcr_distribution( bcr_distribution_id, assets[i], asset_output) base.signal_task_complete(job_id=job_id, num_items=len(assets) + len(missings))
def event_based_bcr(job_id, hazard, seed, vulnerability_function, vulnerability_function_retrofitted, output_containers, time_span, tses, loss_curve_resolution, asset_correlation, asset_life_expectancy, interest_rate): """ Celery task for the BCR risk calculator based on the event based calculator. Instantiates risklib calculators, computes bcr and stores results to db in a single transaction. :param int job_id: ID of the currently running job. :param dict hazard: A dictionary mapping IDs of :class:`openquake.engine.db.models.Output` (with output_type set to 'gmf_collection') to a tuple where the first element is a list of list (one for each asset) with the ground motion values used by the calculation, and the second element is the corresponding weight. :param output_containers: A dictionary mapping hazard Output ID to a tuple with only the ID of the :class:`openquake.engine.db.models.BCRDistribution` output container used to store the computed bcr distribution :param float time_span: Time Span of the hazard calculation. :param float tses: Time of the Stochastic Event Set. :param int loss_curve_resolution: Resolution of the computed loss curves (number of points). :param int seed: Seed used to generate random values. :param float asset_correlation: asset correlation (0 uncorrelated, 1 perfectly correlated). :param float interest_rate The interest rate used in the Cost Benefit Analysis. :param float asset_life_expectancy The life expectancy used for every asset. """ for hazard_output_id, hazard_data in hazard.items(): hazard_getter, _ = hazard_data (bcr_distribution_id,) = output_containers[hazard_output_id] # FIXME(lp). We should not pass the exact same seed for # different hazard calc_original = api.ProbabilisticEventBased( vulnerability_function, curve_resolution=loss_curve_resolution, time_span=time_span, tses=tses, seed=seed, correlation=asset_correlation) calc_retrofitted = api.ProbabilisticEventBased( vulnerability_function_retrofitted, curve_resolution=loss_curve_resolution, time_span=time_span, tses=tses, seed=seed, correlation=asset_correlation) with logs.tracing('getting hazard'): assets, gmvs_ruptures, missings = hazard_getter() if len(assets): ground_motion_values = numpy.array(gmvs_ruptures)[:, 0] else: # we are relying on the fact that if all the # hazard_getter in this task will either return some # results or they all return an empty result set. logs.LOG.info("Exit from task as no asset could be processed") base.signal_task_complete(job_id=job_id, num_items=len(missings)) return with logs.tracing('computing risk'): _, original_loss_curves = calc_original(ground_motion_values) _, retrofitted_loss_curves = calc_retrofitted(ground_motion_values) eal_original = [ scientific.mean_loss(*original_loss_curves[i].xy) for i in range(len(assets))] eal_retrofitted = [ scientific.mean_loss(*retrofitted_loss_curves[i].xy) for i in range(len(assets))] bcr_results = [ scientific.bcr( eal_original[i], eal_retrofitted[i], interest_rate, asset_life_expectancy, asset.value, asset.retrofitting_cost) for i, asset in enumerate(assets)] with logs.tracing('writing results'): with transaction.commit_on_success(using='reslt_writer'): for i, asset in enumerate(assets): general.write_bcr_distribution( bcr_distribution_id, asset, eal_original[i], eal_retrofitted[i], bcr_results[i]) base.signal_task_complete(job_id=job_id, num_items=len(assets) + len(missings))
def event_based_bcr(job_id, assets, hazard_getter_name, hazard, seed, vulnerability_function, vulnerability_function_retrofitted, output_containers, imt, time_span, tses, loss_curve_resolution, asset_correlation, asset_life_expectancy, interest_rate): """ Celery task for the BCR risk calculator based on the event based calculator. Instantiates risklib calculators, computes bcr and stores results to db in a single transaction. :param int job_id: ID of the currently running job. :param assets: list of assets to compute. :param str hazard_getter_name: class name of a class defined in the :mod:`openquake.engine.calculators.risk.hazard_getters` to be instantiated to get the hazard curves :param dict hazard: A dictionary mapping hazard Output ID to GmfCollection ID :param output_containers: A dictionary mapping hazard Output ID to a tuple with only the ID of the :class:`openquake.engine.db.models.BCRDistribution` output container used to store the computed bcr distribution :param float imt: Intensity Measure Type to take into account. :param float time_span: Time Span of the hazard calculation. :param float tses: Time of the Stochastic Event Set. :param int loss_curve_resolution: Resolution of the computed loss curves (number of points). :param int seed: Seed used to generate random values. :param float asset_correlation: asset correlation (0 uncorrelated, 1 perfectly correlated). :param float interest_rate The interest rate used in the Cost Benefit Analysis. :param float asset_life_expectancy The life expectancy used for every asset. """ for hazard_output_id, hazard_data in hazard.items(): hazard_id, _ = hazard_data (bcr_distribution_id,) = output_containers[hazard_output_id] hazard_getter = general.hazard_getter( hazard_getter_name, hazard_id, imt) calculator = api.ProbabilisticEventBased( vulnerability_function, curve_resolution=loss_curve_resolution, time_span=time_span, tses=tses, seed=seed, correlation=asset_correlation) calculator_retrofitted = api.ProbabilisticEventBased( vulnerability_function_retrofitted, curve_resolution=loss_curve_resolution, time_span=time_span, tses=tses, seed=seed, correlation=asset_correlation) bcr_calculator = api.BCR(calculator, calculator_retrofitted, interest_rate, asset_life_expectancy) with logs.tracing('getting hazard'): ground_motion_fields = [hazard_getter(asset.site) for asset in assets] with logs.tracing('computing risk over %d assets' % len(assets)): asset_outputs = bcr_calculator(assets, ground_motion_fields) with logs.tracing('writing results'): with transaction.commit_on_success(using='reslt_writer'): for i, asset_output in enumerate(asset_outputs): general.write_bcr_distribution( bcr_distribution_id, assets[i], asset_output) base.signal_task_complete(job_id=job_id, num_items=len(assets))