def event_based(job_id, units, containers, params):
"""
Celery task for the event based risk calculator.
:param job_id: the id of the current
:class:`openquake.engine.db.models.OqJob`
:param dict units:
A list of :class:`openquake.risklib.workflows.CalculationUnit` instances
:param containers:
An instance of :class:`..writers.OutputDict` containing
output container instances (e.g. a LossCurve)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
def profile(name):
return EnginePerformanceMonitor(
name, job_id, event_based, tracing=True)
# Do the job in other functions, such that they can be unit tested
# without the celery machinery
event_loss_tables = dict()
with db.transaction.commit_on_success(using='reslt_writer'):
for unit in units:
event_loss_tables[unit.loss_type] = do_event_based(
unit,
containers.with_args(loss_type=unit.loss_type),
params, profile)
num_items = base.get_num_items(units)
signal_task_complete(job_id=job_id,
num_items=num_items,
event_loss_tables=event_loss_tables)
def scenario(job_id, units, containers, _params):
"""
Celery task for the scenario risk calculator.
:param int job_id:
ID of the currently running job
:param list units:
A list of :class:`openquake.risklib.workflows.CalculationUnit` instances
:param containers:
An instance of :class:`..writers.OutputDict` containing
output container instances (in this case only `LossMap`)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
def profile(name):
return EnginePerformanceMonitor(name, job_id, scenario, tracing=True)
agg = dict()
insured = dict()
with db.transaction.commit_on_success(using='reslt_writer'):
for unit in units:
agg[unit.loss_type], insured[unit.loss_type] = do_scenario(
unit,
containers.with_args(
loss_type=unit.loss_type,
output_type="loss_map"),
profile)
num_items = base.get_num_items(units)
signal_task_complete(
job_id=job_id, num_items=num_items,
aggregate_losses=agg, insured_losses=insured)
def scenario_damage(job_id, units, containers, params):
"""
Celery task for the scenario damage risk calculator.
:param int job_id:
ID of the currently running job
:param list units:
:param containers:
An instance of :class:`..writers.OutputDict` containing
output container instances (in this case only `LossMap`)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
def profile(name):
return EnginePerformanceMonitor(name,
job_id,
scenario_damage,
tracing=True)
# in scenario damage calculation we have only ONE calculation unit
unit = units[0]
# and NO containes
assert len(containers) == 0
with db.transaction.commit_on_success(using='reslt_writer'):
fractions, taxonomy = do_scenario_damage(unit, params, profile)
num_items = base.get_num_items(units)
signal_task_complete(job_id=job_id,
num_items=num_items,
fractions=fractions,
taxonomy=taxonomy)
def event_based(job_id, units, containers, params):
"""
Celery task for the event based risk calculator.
:param job_id: the id of the current
:class:`openquake.engine.db.models.OqJob`
:param dict units:
A list of :class:`openquake.risklib.workflows.CalculationUnit` instances
:param containers:
An instance of :class:`..writers.OutputDict` containing
output container instances (e.g. a LossCurve)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
def profile(name):
return EnginePerformanceMonitor(name,
job_id,
event_based,
tracing=True)
# Do the job in other functions, such that they can be unit tested
# without the celery machinery
event_loss_tables = dict()
with db.transaction.commit_on_success(using='reslt_writer'):
for unit in units:
event_loss_tables[unit.loss_type] = do_event_based(
unit, containers.with_args(loss_type=unit.loss_type), params,
profile)
num_items = base.get_num_items(units)
signal_task_complete(job_id=job_id,
num_items=num_items,
event_loss_tables=event_loss_tables)
def scenario(job_id, units, containers, _params):
"""
Celery task for the scenario risk calculator.
:param int job_id:
ID of the currently running job
:param list units:
A list of :class:`openquake.risklib.workflows.CalculationUnit` instances
:param containers:
An instance of :class:`..writers.OutputDict` containing
output container instances (in this case only `LossMap`)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
def profile(name):
return EnginePerformanceMonitor(name, job_id, scenario, tracing=True)
agg = dict()
insured = dict()
with db.transaction.commit_on_success(using='reslt_writer'):
for unit in units:
agg[unit.loss_type], insured[unit.loss_type] = do_scenario(
unit,
containers.with_args(loss_type=unit.loss_type,
output_type="loss_map"), profile)
num_items = base.get_num_items(units)
signal_task_complete(job_id=job_id,
num_items=num_items,
aggregate_losses=agg,
insured_losses=insured)
def scenario(job_id, units, containers, params):
"""
Celery task for the scenario risk calculator.
:param int job_id:
ID of the currently running job
:param dict units:
A dict of :class:`..base.CalculationUnit` instances keyed by
loss type string
:param containers:
An instance of :class:`..writers.OutputDict` containing
output container instances (in this case only `LossMap`)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
def profile(name):
return EnginePerformanceMonitor(name, job_id, scenario, tracing=True)
agg = dict()
insured = dict()
with db.transaction.commit_on_success(using='reslt_writer'):
for loss_type in units:
# in scenario calculation we have only ONE calculation unit
unit = units[loss_type][0]
agg[loss_type], insured[loss_type] = do_scenario(
loss_type, unit, containers, params, profile)
num_items = base.get_num_items(units)
signal_task_complete(
job_id=job_id, num_items=num_items,
aggregate_losses=agg, insured_losses=insured)
def scenario_damage(job_id, units, containers, params):
"""
Celery task for the scenario damage risk calculator.
:param int job_id:
ID of the currently running job
:param list units:
:param containers:
An instance of :class:`..writers.OutputDict` containing
output container instances (in this case only `LossMap`)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
def profile(name):
return EnginePerformanceMonitor(
name, job_id, scenario_damage, tracing=True)
# in scenario damage calculation we have only ONE calculation unit
unit = units[0]
# and NO containes
assert len(containers) == 0
with db.transaction.commit_on_success(using='reslt_writer'):
fractions, taxonomy = do_scenario_damage(unit, params, profile)
num_items = base.get_num_items(units)
signal_task_complete(
job_id=job_id, num_items=num_items,
fractions=fractions, taxonomy=taxonomy)
def event_based_bcr(job_id, units, containers, params):
"""
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 units:
A dict of :class:`..base.CalculationUnit` instances keyed by
loss type string
:param containers:
An instance of :class:`..writers.OutputDict` containing
output container instances (in this case only `BCRDistribution`)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
def profile(name):
return EnginePerformanceMonitor(name, job_id, event_based_bcr, tracing=True)
# Do the job in other functions, such that it can be unit tested
# without the celery machinery
with transaction.commit_on_success(using="reslt_writer"):
for loss_type in units:
do_event_based_bcr(loss_type, units[loss_type], containers, params, profile)
num_items = base.get_num_items(units)
signal_task_complete(job_id=job_id, num_items=num_items)
def classical(job_id, units, containers, params):
"""
Celery task for the classical risk calculator.
:param int job_id:
ID of the currently running job
:param dict units:
A dict of :class:`..base.CalculationUnit` instances keyed by
loss type string
:param containers:
An instance of :class:`..writers.OutputDict` containing
output container instances (e.g. a LossCurve)
:param params:
An instance of :class:`..base.CalcParams` used to compute
derived outputs
"""
def profile(name):
return EnginePerformanceMonitor(name, job_id, classical, tracing=True)
# Do the job in other functions, such that they can be unit tested
# without the celery machinery
with transaction.commit_on_success(using='reslt_writer'):
for loss_type in units:
do_classical(
loss_type, units[loss_type], containers, params, profile)
num_items = base.get_num_items(units)
signal_task_complete(job_id=job_id, num_items=num_items)
