openquake.risklib package¶
openquake.risklib.riskinput module¶
-
class
openquake.risklib.riskinput.
AssetCollection
(assets_by_site, cost_calculator, time_event, time_events='')[source]¶ Bases:
object
-
D
= 11¶
-
I
= 16¶
-
R
= 12¶
-
-
class
openquake.risklib.riskinput.
CompositeRiskModel
(oqparam, rmdict, retrodict)[source]¶ Bases:
_abcoll.Mapping
A container (imt, taxonomy) -> riskmodel
Parameters: - oqparam – an
openquake.commonlib.oqvalidation.OqParam
instance - rmdict – a dictionary (imt, taxonomy) -> loss_type -> risk_function
-
build_input
(rlzs, hazards_by_site, assetcol, eps_dict)[source]¶ Parameters: - rlzs – a list of realizations
- hazards_by_site – an array of hazards per each site
- assetcol – AssetCollection instance
- eps_dict – a dictionary of epsilons
Returns: a
RiskInput
instance
-
gen_outputs
(riskinput, monitor, assetcol=None)[source]¶ Group the assets per taxonomy and compute the outputs by using the underlying riskmodels. Yield the outputs generated as dictionaries out_by_lr.
Parameters: - riskinput – a RiskInput instance
- monitor – a monitor object used to measure the performance
- assetcol – not None only for event based risk
- oqparam – an
-
class
openquake.risklib.riskinput.
GmfGetter
(gsims, ebruptures, sitecol, imts, min_iml, truncation_level, correlation_model, samples)[source]¶ Bases:
object
Callable returning a list of N dictionaries imt -> array(gmv, eid). when called on a realization.
-
dt
= dtype([('gmv', '<f4'), ('eid', '<u4')])¶
-
-
class
openquake.risklib.riskinput.
Gmvset
[source]¶ Bases:
object
Emulate a dataset containing ground motion values per event ID, realization ordinal and IMT index.
-
dt
= dtype([('gmv', '<f4'), ('eid', '<u4'), ('rlzi', '<u2'), ('imti', 'u1')])¶
-
value
¶
-
-
class
openquake.risklib.riskinput.
PoeGetter
(hazard_by_site)[source]¶ Bases:
object
Callable returning a list of N dictionaries imt -> curve when called on a realization.
-
class
openquake.risklib.riskinput.
RiskInput
(rlzs, hazard_by_site, assets_by_site, eps_dict)[source]¶ Bases:
object
Contains all the assets and hazard values associated to a given imt and site.
Parameters: - rlzs – the realizations
- imt_taxonomies – a pair (IMT, taxonomies)
- hazard_by_site – array of hazards, one per site
- assets_by_site – array of assets, one per site
- eps_dict – dictionary of epsilons
-
epsilon_getter
(asset_ordinals)[source]¶ Parameters: asset_ordinals – list of ordinals of the assets Returns: a closure returning an array of epsilons from the event IDs
-
hazard_getter
(monitor=<Monitor dummy>)[source]¶ Parameters: monitor – a openquake.baselib.performance.Monitor
instanceReturns: list of hazard dictionaries imt -> rlz -> haz per each site
-
imt_taxonomies
¶ Return a list of pairs (imt, taxonomies) with a single element
-
class
openquake.risklib.riskinput.
RiskInputFromRuptures
(trt, rlzs_assoc, imts, sitecol, ses_ruptures, trunc_level, correl_model, min_iml, epsilons=None)[source]¶ Bases:
object
Contains all the assets associated to the given IMT and a subsets of the ruptures for a given calculation.
Parameters: - trt – a tectonic region type string
- rlzs_assoc – a RlzsAssoc instance
- imts – a list of intensity measure type strings
- sitecol – SiteCollection instance
- ses_ruptures – ordered array of EBRuptures
- trunc_level – truncation level for the GSIMs
- correl_model – correlation model for the GSIMs
- min_iml – an array with the minimum intensity per IMT
Params epsilons: a matrix of epsilons (or None)
-
openquake.risklib.riskinput.
make_eps
(assets_by_site, num_samples, seed, correlation)[source]¶ Parameters: - assets_by_site – a list of lists of assets
- num_samples (int) – the number of ruptures
- seed (int) – a random seed
- correlation (float) – the correlation coefficient
Returns: epsilons matrix of shape (num_assets, num_samples)
-
openquake.risklib.riskinput.
read_composite_risk_model
(dstore)[source]¶ Parameters: dstore – a DataStore instance Returns: a CompositeRiskModel
instance
openquake.risklib.riskmodels module¶
-
class
openquake.risklib.riskmodels.
Asset
(asset_id, taxonomy, number, location, values, area=1, deductibles=None, insurance_limits=None, retrofitteds=None, calc=<CostCalculator {'units': {'structural': 'EUR'}, 'deduct_abs': True, 'area_types': {'structural': 'per_asset'}, 'limit_abs': True, 'cost_types': {'structural': 'per_area'}}>, ordinal=None)[source]¶ Bases:
object
Describe an Asset as a collection of several values. A value can represent a replacement cost (e.g. structural cost, business interruption cost) or another quantity that can be considered for a risk analysis (e.g. occupants).
Optionally, a Asset instance can hold also a collection of deductible values and insured limits considered for insured losses calculations.
-
class
openquake.risklib.riskmodels.
Classical
(taxonomy, vulnerability_functions, hazard_imtls, lrem_steps_per_interval, conditional_loss_poes, poes_disagg, insured_losses=False)[source]¶ Bases:
openquake.risklib.riskmodels.RiskModel
Classical PSHA-Based RiskModel. Computes loss curves and insured curves.
-
kind
= 'vulnerability'¶
-
-
class
openquake.risklib.riskmodels.
ClassicalBCR
(taxonomy, vulnerability_functions_orig, vulnerability_functions_retro, hazard_imtls, lrem_steps_per_interval, interest_rate, asset_life_expectancy)[source]¶ Bases:
openquake.risklib.riskmodels.RiskModel
-
kind
= 'vulnerability'¶
-
-
class
openquake.risklib.riskmodels.
ClassicalDamage
(taxonomy, fragility_functions, hazard_imtls, investigation_time, risk_investigation_time)[source]¶ Bases:
openquake.risklib.riskmodels.Damage
Implements the ClassicalDamage riskmodel. Computes the damages.
-
kind
= 'fragility'¶
-
-
class
openquake.risklib.riskmodels.
CostCalculator
(cost_types, area_types, units, deduct_abs=True, limit_abs=True)[source]¶ Bases:
object
Return the value of an asset for the given loss type depending on the cost types declared in the exposure, as follows:
- case 1: cost type: aggregated:
- cost = economic value
- case 2: cost type: per asset:
- cost * number (of assets) = economic value
- case 3: cost type: per area and area type: aggregated:
- cost * area = economic value
- case 4: cost type: per area and area type: per asset:
- cost * area * number = economic value
The same “formula” applies to retrofitting cost.
-
class
openquake.risklib.riskmodels.
Damage
(taxonomy, fragility_functions)[source]¶ Bases:
openquake.risklib.riskmodels.RiskModel
Implements the ScenarioDamage riskmodel. Computes the damages.
-
kind
= 'fragility'¶
-
-
class
openquake.risklib.riskmodels.
ProbabilisticEventBased
(taxonomy, vulnerability_functions, loss_curve_resolution, conditional_loss_poes, insured_losses=False)[source]¶ Bases:
openquake.risklib.riskmodels.RiskModel
Implements the Probabilistic Event Based riskmodel. Computes loss ratios and event IDs.
-
kind
= 'vulnerability'¶
-
-
class
openquake.risklib.riskmodels.
RiskModel
(taxonomy, risk_functions)[source]¶ Bases:
object
Base class. Can be used in the tests as a mock.
-
compositemodel
= None¶
-
get_loss_types
(imt)[source]¶ Parameters: imt – Intensity Measure Type string Returns: loss types with risk functions of the given imt
-
kind
= None¶
-
loss_types
¶ The list of loss types in the underlying vulnerability functions, in lexicographic order
-
time_event
= None¶
-
-
class
openquake.risklib.riskmodels.
Scenario
(taxonomy, vulnerability_functions, insured_losses, time_event=None)[source]¶ Bases:
openquake.risklib.riskmodels.RiskModel
Implements the Scenario riskmodel. Computes the loss matrix.
-
kind
= 'vulnerability'¶
-
-
openquake.risklib.riskmodels.
get_riskmodel
(taxonomy, oqparam, **extra)[source]¶ Return an instance of the correct riskmodel class, depending on the attribute calculation_mode of the object oqparam.
Parameters: - taxonomy – a taxonomy string
- oqparam – an object containing the parameters needed by the riskmodel class
- extra – extra parameters to pass to the riskmodel class
openquake.risklib.scientific module¶
This module includes the scientific API of the oq-risklib
-
class
openquake.risklib.scientific.
ConsequenceFunction
(id, dist, params)¶ Bases:
tuple
-
dist
¶ Alias for field number 1
-
id
¶ Alias for field number 0
-
params
¶ Alias for field number 2
-
-
class
openquake.risklib.scientific.
ConsequenceModel
(id, assetCategory, lossCategory, description, limitStates)[source]¶ Bases:
dict
Container for a set of consequence functions. You can access each function given its name with the square bracket notation.
Parameters: - id (str) – ID of the model
- assetCategory (str) – asset category (i.e. buildings, population)
- lossCategory (str) – loss type (i.e. structural, contents, ...)
- description (str) – description of the model
- limitStates – a list of limit state strings
- consequence_functions – a dictionary name -> ConsequenceFunction
-
class
openquake.risklib.scientific.
CurveBuilder
(loss_type, curve_resolution, loss_ratios, ses_ratio, user_provided, conditional_loss_poes=(), insured_losses=False)[source]¶ Bases:
object
Build loss ratio curves. The loss ratios can be provided by the user or automatically generated (user_provided=False). The usage is something like this:
builder = CurveBuilder(loss_type, loss_ratios, ses_ratio, user_provided=True) counts = builder.build_counts(loss_matrix)
-
class
openquake.risklib.scientific.
DegenerateDistribution
[source]¶ Bases:
openquake.risklib.scientific.Distribution
The degenerate distribution. E.g. a distribution with a delta corresponding to the mean.
-
class
openquake.risklib.scientific.
DiscreteDistribution
[source]¶ Bases:
openquake.risklib.scientific.Distribution
-
seed
= None¶
-
-
class
openquake.risklib.scientific.
Distribution
[source]¶ Bases:
object
A Distribution class models continuous probability distribution of random variables used to sample losses of a set of assets. It is usually registered with a name (e.g. LN, BT, PM) by using
openquake.baselib.general.CallableDict
-
class
openquake.risklib.scientific.
FragilityFunctionContinuous
(limit_state, mean, stddev)[source]¶ Bases:
object
-
class
openquake.risklib.scientific.
FragilityFunctionDiscrete
(limit_state, imls, poes, no_damage_limit=None)[source]¶ Bases:
object
-
interp
¶
-
-
class
openquake.risklib.scientific.
FragilityFunctionList
(array, **attrs)[source]¶ Bases:
list
A list of fragility functions with common attributes; there is a function for each limit state.
-
class
openquake.risklib.scientific.
FragilityModel
(id, assetCategory, lossCategory, description, limitStates)[source]¶ Bases:
dict
Container for a set of fragility functions. You can access each function given the IMT and taxonomy with the square bracket notation.
Parameters: - id (str) – ID of the model
- assetCategory (str) – asset category (i.e. buildings, population)
- lossCategory (str) – loss type (i.e. structural, contents, ...)
- description (str) – description of the model
- limitStates – a list of limit state strings
-
build
(continuous_fragility_discretization, steps_per_interval)[source]¶ Return a new FragilityModel instance, in which the values have been replaced with FragilityFunctionList instances.
Parameters: - continuous_fragility_discretization – configuration parameter
- steps_per_interval – configuration parameter
-
class
openquake.risklib.scientific.
LogNormalDistribution
(epsilons=None)[source]¶ Bases:
openquake.risklib.scientific.Distribution
Model a distribution of a random variable whoose logarithm are normally distributed.
Attr epsilons: An array of random numbers generated with numpy.random.multivariate_normal()
with size E
-
class
openquake.risklib.scientific.
VulnerabilityFunction
(vf_id, imt, imls, mean_loss_ratios, covs=None, distribution='LN')[source]¶ Bases:
object
-
dtype
= dtype([('iml', '<f4'), ('loss_ratio', '<f4'), ('cov', '<f4')])¶
-
interpolate
(gmvs)[source]¶ Parameters: gmvs – array of intensity measure levels Returns: (interpolated loss ratios, interpolated covs, indices > min)
-
loss_ratio_exceedance_matrix
= <functools.partial object>¶
-
mean_imls
= <functools.partial object>¶
-
mean_loss_ratios_with_steps
(steps)[source]¶ Split the mean loss ratios, producing a new set of loss ratios. The new set of loss ratios always includes 0.0 and 1.0
Parameters: steps (int) – the number of steps we make to go from one loss ratio to the next. For example, if we have [0.5, 0.7]:
steps = 1 produces [0.0, 0.5, 0.7, 1] steps = 2 produces [0.0, 0.25, 0.5, 0.6, 0.7, 0.85, 1] steps = 3 produces [0.0, 0.17, 0.33, 0.5, 0.57, 0.63, 0.7, 0.8, 0.9, 1]
-
sample
(means, covs, idxs, epsilons)[source]¶ Sample the epsilons and apply the corrections to the means. This method is called only if there are nonzero covs.
Parameters: - means – array of E’ loss ratios
- covs – array of E’ floats
- idxs – array of E booleans with E >= E’
- epsilons – array of E floats
Returns: array of E’ loss ratios
-
-
class
openquake.risklib.scientific.
VulnerabilityFunctionWithPMF
(vf_id, imt, imls, loss_ratios, probs, seed=42)[source]¶ Bases:
openquake.risklib.scientific.VulnerabilityFunction
Vulnerability function with an explicit distribution of probabilities
Parameters: - vf_id (str) – vulnerability function ID
- imt (str) – Intensity Measure Type
- imls – intensity measure levels (L)
- ratios – an array of mean ratios (M)
- probs – a matrix of probabilities of shape (M, L)
-
interpolate
(gmvs)[source]¶ Parameters: gmvs – array of intensity measure levels Returns: (interpolated probabilities, None, indices > min)
-
loss_ratio_exceedance_matrix
= <functools.partial object>¶
-
sample
(probs, _covs, idxs, epsilons)[source]¶ Sample the epsilons and applies the corrections to the probabilities. This method is called only if there are epsilons.
Parameters: - probs – array of E’ floats
- _covs – ignored, it is there only for API consistency
- idxs – array of E booleans with E >= E’
- epsilons – array of E floats
Returns: array of E’ probabilities
-
class
openquake.risklib.scientific.
VulnerabilityModel
(id=None, assetCategory=None, lossCategory=None)[source]¶ Bases:
dict
Container for a set of vulnerability functions. You can access each function given the IMT and taxonomy with the square bracket notation.
Parameters: - id (str) – ID of the model
- assetCategory (str) – asset category (i.e. buildings, population)
- lossCategory (str) – loss type (i.e. structural, contents, ...)
All such attributes are None for a vulnerability model coming from a NRML 0.4 file.
-
openquake.risklib.scientific.
annual_frequency_of_exceedence
(poe, t_haz)[source]¶ Parameters: - poe – hazard probability of exceedence
- t_haz – hazard investigation time
-
openquake.risklib.scientific.
average_loss
(losses_poes)[source]¶ Given a loss curve with poes over losses defined on a given time span it computes the average loss on this period of time.
Note: As the loss curve is supposed to be piecewise linear as it is a result of a linear interpolation, we compute an exact integral by using the trapeizodal rule with the width given by the loss bin width.
-
openquake.risklib.scientific.
bcr
(eal_original, eal_retrofitted, interest_rate, asset_life_expectancy, asset_value, retrofitting_cost)[source]¶ Compute the Benefit-Cost Ratio.
BCR = (EALo - EALr)(1-exp(-r*t))/(r*C)
Where:
- BCR – Benefit cost ratio
- EALo – Expected annual loss for original asset
- EALr – Expected annual loss for retrofitted asset
- r – Interest rate
- t – Life expectancy of the asset
- C – Retrofitting cost
-
openquake.risklib.scientific.
broadcast
(func, composite_array, *args)[source]¶ Broadcast an array function over a composite array
-
openquake.risklib.scientific.
build_dtypes
(curve_resolution, conditional_loss_poes, insured=False)[source]¶ Returns loss_curve_dt and loss_maps_dt
-
openquake.risklib.scientific.
build_imls
(ff, continuous_fragility_discretization, steps_per_interval=0)[source]¶ Build intensity measure levels from a fragility function. If the function is continuous, they are produced simply as a linear space between minIML and maxIML. If the function is discrete, they are generated with a complex logic depending on the noDamageLimit and the parameter steps per interval.
Parameters: - ff – a fragility function object
- continuous_fragility_discretization – .ini file parameter
- steps_per_interval – .ini file parameter
Returns: generated imls
-
openquake.risklib.scientific.
build_loss_dtypes
(curve_resolution, conditional_loss_poes, insured_losses=False)[source]¶ Parameters: - curve_resolution – dictionary loss_type -> curve_resolution
- conditional_loss_poes – configuration parameter
- insured_losses – configuration parameter
Returns: loss_curve_dt and loss_maps_dt
-
openquake.risklib.scientific.
build_poes
(counts, nses)[source]¶ Parameters: - counts – an array of counts of exceedence for the bins
- nses – number of stochastic event sets
Returns: an array of PoEs
-
openquake.risklib.scientific.
classical
(vulnerability_function, hazard_imls, hazard_poes, steps=10)[source]¶ Parameters: - vulnerability_function – an instance of
openquake.risklib.scientific.VulnerabilityFunction
representing the vulnerability function used to compute the curve. - hazard_imls – the hazard intensity measure type and levels
- steps (int) – Number of steps between loss ratios.
- vulnerability_function – an instance of
-
openquake.risklib.scientific.
classical_damage
(fragility_functions, hazard_imls, hazard_poes, investigation_time, risk_investigation_time)[source]¶ Parameters: - fragility_functions – a list of fragility functions for each damage state
- hazard_imls – Intensity Measure Levels
- hazard_poes – hazard curve
- investigation_time – hazard investigation time
- risk_investigation_time – risk investigation time
Returns: an array of M probabilities of occurrence where M is the numbers of damage states.
-
openquake.risklib.scientific.
conditional_loss_ratio
(loss_ratios, poes, probability)[source]¶ Return the loss ratio corresponding to the given PoE (Probability of Exceendance). We can have four cases:
- If probability is in poes it takes the bigger corresponding loss_ratios.
- If it is in (poe1, poe2) where both poe1 and poe2 are in poes, then we perform a linear interpolation on the corresponding losses
- if the given probability is smaller than the lowest PoE defined, it returns the max loss ratio .
- if the given probability is greater than the highest PoE defined it returns zero.
Parameters: - loss_ratios – an iterable over non-decreasing loss ratio values (float)
- poes – an iterable over non-increasing probability of exceedance values (float)
- probability (float) – the probability value used to interpolate the loss curve
-
openquake.risklib.scientific.
fine_graining
(points, steps)[source]¶ Parameters: - points – a list of floats
- steps (int) – expansion steps (>= 2)
>>> fine_graining([0, 1], steps=0) [0, 1] >>> fine_graining([0, 1], steps=1) [0, 1] >>> fine_graining([0, 1], steps=2) array([ 0. , 0.5, 1. ]) >>> fine_graining([0, 1], steps=3) array([ 0. , 0.33333333, 0.66666667, 1. ]) >>> fine_graining([0, 0.5, 0.7, 1], steps=2) array([ 0. , 0.25, 0.5 , 0.6 , 0.7 , 0.85, 1. ])
N points become S * (N - 1) + 1 points with S > 0
-
openquake.risklib.scientific.
insured_loss_curve
(curve, deductible, insured_limit)[source]¶ Compute an insured loss ratio curve given a loss ratio curve
Parameters: - curve – an array 2 x R (where R is the curve resolution)
- deductible (float) – the deductible limit in fraction form
- insured_limit (float) – the insured limit in fraction form
>>> losses = numpy.array([3, 20, 101]) >>> poes = numpy.array([0.9, 0.5, 0.1]) >>> insured_loss_curve(numpy.array([losses, poes]), 5, 100) array([[ 3. , 20. ], [ 0.85294118, 0.5 ]])
-
openquake.risklib.scientific.
insured_losses
(losses, deductible, insured_limit)[source]¶ Parameters: - losses – an array of ground-up loss ratios
- deductible (float) – the deductible limit in fraction form
- insured_limit (float) – the insured limit in fraction form
Compute insured losses for the given asset and losses, from the point of view of the insurance company. For instance:
>>> insured_losses(numpy.array([3, 20, 101]), 5, 100) array([ 0, 15, 95])
- if the loss is 3 (< 5) the company does not pay anything
- if the loss is 20 the company pays 20 - 5 = 15
- if the loss is 101 the company pays 100 - 5 = 95
-
openquake.risklib.scientific.
loss_map_matrix
(poes, curves)[source]¶ Wrapper around
openquake.risklib.scientific.conditional_loss_ratio()
. Return a matrix of shape (num-poes, num-curves). The curves are lists of pairs (loss_ratios, poes).
-
openquake.risklib.scientific.
loss_maps
(curves, conditional_loss_poes)[source]¶ Parameters: - curves – an array of loss curves
- conditional_loss_poes – a list of conditional loss poes
Returns: a composite array of loss maps with the same shape
-
openquake.risklib.scientific.
make_epsilons
(matrix, seed, correlation)[source]¶ Given a matrix N * R returns a matrix of the same shape N * R obtained by applying the multivariate_normal distribution to N points and R samples, by starting from the given seed and correlation.
-
openquake.risklib.scientific.
mean_std
(fractions)[source]¶ Given an N x M matrix, returns mean and std computed on the rows, i.e. two M-dimensional vectors.
-
openquake.risklib.scientific.
normalize_curves_eb
(curves)[source]¶ A more sophisticated version of normalize_curves, used in the event based calculator.
Parameters: curves – a list of pairs (losses, poes) Returns: first losses, all_poes
-
openquake.risklib.scientific.
pairwise_diff
(values)[source]¶ Differences between a value and the next value in a sequence