openquake.risklib package

openquake.risklib.riskinput module

class openquake.risklib.riskinput.AssetCollection(assets_by_site, cost_calculator, time_event, time_events='')

Bases: object

D = 11

I = 16

R = 12

assets_by_site()

Returns:numpy array of lists with the assets by each site

static build_asset_collection(assets_by_site, time_event=None)

Parameters:

• assets_by_site – a list of lists of assets
• time_event – a time event string (or None)

Returns:

two arrays assetcol and taxonomies

values()

Returns:a composite array of asset values by loss type

class openquake.risklib.riskinput.CompositeRiskModel(oqparam, rmdict, retrodict)

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

gen_outputs(riskinput, monitor, assetcol=None)

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

get_loss_ratios()

Returns:a 1-dimensional composite array with loss ratios by loss type

get_min_iml()

init(oqparam)

make_curve_builder(oqparam)

class openquake.risklib.riskinput.GmfDataGetter(gmf_data, grp_id, rlzs_by_gsim, start=0, stop=None)

Bases: openquake.risklib.riskinput.GmfGetter

Extracts a dictionary of GMVs from the datastore

classmethod gen_gmfs(gmf_data, rlzs_assoc, eid=None)

Yield GMF records

gen_gmv(gsim)

Yield gmv records from the datastore, if present

init()

class openquake.risklib.riskinput.GmfGetter(grp_id, rlzs_by_gsim, ebruptures, sitecol, imts, min_iml, truncation_level, correlation_model, samples)

Bases: object

An hazard getter with methods .gen_gmv and .get_hazard returning ground motion values.

gen_gmv(gsim)

Compute the GMFs for the given realization and populate the .gmdata array. Yields tuples of the form (sid, eid, imti, gmv).

get_hazard(gsim, data=None)

Parameters:

• gsim – a GSIM instance
• data – if given, an iterator of records of dtype gmf_data_dt

Returns:

an array (rlzi, sid, imti) -> array(gmv, eid)

init()

Initialize the computers. Should be called on the workers

class openquake.risklib.riskinput.HazardGetter(kind, grp_id, rlzs_by_gsim, hazards_by_rlz, sids, imts)

Bases: object

Parameters:

• kind – kind of HazardGetter; can be ‘poe’ or ‘gmf’
• grp_id – source group ID
• rlzs_by_gsim – a dictionary gsim -> realizations for that GSIM
• hazards_by_rlz – a nested dictionary rlz -> imt -> PoE array or a flat dictionary rlz -> GMF array of shape (N, I, E)
• imts – a list of IMT strings

Params sids:

array of site IDs of interest

get_hazard(gsim)

Parameters:gsim – a GSIM instance Returns:a list of dictionaries (num_sites, num_imts)

init()

class openquake.risklib.riskinput.LossRatiosGetter(dstore)

Bases: object

Read loss ratios from the datastore for all realizations or for a specific realization.

Parameters:dstore – a DataStore instance

get(aids, rlzi)

Parameters:

• aids – a list of A asset ordinals
• rlzi – a realization ordinal

Returns:

a dictionary aid -> list of loss ratios

get_all(aids)

Parameters:aids – a list of A asset ordinals Returns:a list of A composite arrays of dtype lrs_dt

class openquake.risklib.riskinput.Output(loss_types, assets, values, sid, rlzi)

Bases: object

A container for the losses of the assets on the given site ID for the given realization ordinal.

class openquake.risklib.riskinput.RiskInput(hazard_getter, assets_by_site, eps_dict)

Bases: object

Contains all the assets and hazard values associated to a given imt and site.

Parameters:

• hazard_getter – a callable returning the hazard data for a given realization
• assets_by_site – array of assets, one per site
• eps_dict – dictionary of epsilons

epsilon_getter(asset_ordinals)

Parameters:asset_ordinals – list of ordinals of the assets Returns:a closure returning an array of epsilons from the event IDs

imt_taxonomies

Return a list of pairs (imt, taxonomies) with a single element

rlzs

Returns the realizations contained in the riskinput object.

class openquake.risklib.riskinput.RiskInputFromRuptures(hazard_getter, epsilons=None)

Bases: object

Contains all the assets associated to the given IMT and a subsets of the ruptures for a given calculation.

Parameters:hazard_getter – a callable returning the hazard data for a given realization Params epsilons:  a matrix of epsilons (or None)

epsilon_getter(asset_ordinals)

Parameters:asset_ordinals – ordinals of the assets Returns:a closure returning an array of epsilons from the event IDs

rlzs

Returns the realizations contained in the riskinput object.

exception openquake.risklib.riskinput.ValidationError

Bases: exceptions.Exception

openquake.risklib.riskinput.get_refs(assets, hdf5path)

Debugging method returning the string IDs of the assets from the datastore

openquake.risklib.riskinput.get_rlzs(riskinput)

Returns the realizations contained in the riskinput object.

openquake.risklib.riskinput.make_eps(assetcol, num_samples, seed, correlation)

Parameters:

• assetcol – an AssetCollection instance
• 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)

Parameters:dstore – a DataStore instance Returns:a CompositeRiskModel instance

openquake.risklib.riskinput.rsi2str(rlzi, sid, imt)

Convert a triple (XXXX, YYYY, ZZZ) into a string of the form ‘rlz-XXXX/sid-YYYY/ZZZ’

openquake.risklib.riskinput.str2rsi(key)

Convert a string of the form ‘rlz-XXXX/sid-YYYY/ZZZ’ into a triple (XXXX, YYYY, ZZZ)

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)

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.

deductible(loss_type)

Returns:the deductible fraction of the asset cost for loss_type

insurance_limit(loss_type)

Returns:the limit fraction of the asset cost for loss_type

retrofitted(loss_type, time_event=None)

Returns:the asset retrofitted value for loss_type

value(loss_type, time_event=None)

Returns:the total asset value for loss_type

class openquake.risklib.riskmodels.Classical(taxonomy, vulnerability_functions, hazard_imtls, lrem_steps_per_interval, conditional_loss_poes, poes_disagg, insured_losses=False)

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)

Bases: openquake.risklib.riskmodels.RiskModel

kind = 'vulnerability'

class openquake.risklib.riskmodels.ClassicalDamage(taxonomy, fragility_functions, hazard_imtls, investigation_time, risk_investigation_time)

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)

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)

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)

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)

Bases: object

Base class. Can be used in the tests as a mock.

compositemodel = None

get_loss_types(imt)

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)

Bases: openquake.risklib.riskmodels.RiskModel

Implements the Scenario riskmodel. Computes the loss matrix.

kind = 'vulnerability'

openquake.risklib.riskmodels.get_riskmodel(taxonomy, oqparam, **extra)

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.riskmodels.get_values(loss_type, assets, time_event=None)

Returns:a numpy array with the values for the given assets, depending on the loss_type.

openquake.risklib.riskmodels.rescale(curves, values)

Multiply the losses in each curve of kind (losses, poes) by the corresponding value.

openquake.risklib.scientific module

This module includes the scientific API of the oq-risklib

class openquake.risklib.scientific.BetaDistribution

Bases: openquake.risklib.scientific.Distribution

sample(means, _covs, stddevs, _idxs=None)

survival(loss_ratio, mean, stddev)

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)

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(cbs, insured_losses, conditional_loss_poes=())

Bases: object

Build curves for all loss types at the same time.

Parameters:

• cbs – a list of LossTypeCurveBuilder instances
• insured_losses – insured losses flag from the job.ini
• conditional_loss_poes – list of PoEs from the job.ini

build_all_poes(aids, loss_ratios, rlzs)

Parameters:

• aids – a list of asset IDs
• loss_ratios – a list of loss ratios
• rlzs – a list of realizations

Yields:

a matrix of shape (A, R) of PoEs

build_curves(assets, loss_ratios)

Parameters:

• assets – a list of assets
• loss_ratios – a list of dictionaries aid -> loss ratios

Returns:

A curves of dtype loss_curve_dt

build_maps(assets, getter, rlzs, stats, mon)

Parameters:

• assets – a list of assets
• getter – a openquake.risklib.riskinput.LossRatiosGetter instance
• rlzs – a list of realizations
• stats – a record of statistic functions
• mon – a openquake.baselib.performance.Monitor instance

Returns:

aids, loss_maps, loss_maps_stats

class openquake.risklib.scientific.DegenerateDistribution

Bases: openquake.risklib.scientific.Distribution

The degenerate distribution. E.g. a distribution with a delta corresponding to the mean.

sample(means, _covs, _stddev, _idxs)

survival(loss_ratio, mean, _stddev)

class openquake.risklib.scientific.DiscreteDistribution

Bases: openquake.risklib.scientific.Distribution

sample(loss_ratios, probs)

seed = None

survival(loss_ratios, probs)

Required for the Classical Risk and BCR Calculators. Currently left unimplemented as the PMF format is used only for the Scenario and Event Based Risk Calculators.

Parameters:steps (int) – number of steps between loss ratios.

class openquake.risklib.scientific.Distribution

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

sample(means, covs, stddevs, idxs)

Returns:

sample a set of losses

Parameters:

• means – an array of mean losses
• covs – an array of covariances
• stddevs – an array of stddevs

survival(loss_ratio, mean, stddev)

Return the survival function of the distribution with mean and stddev applied to loss_ratio

class openquake.risklib.scientific.FragilityFunctionContinuous(limit_state, mean, stddev)

Bases: object

class openquake.risklib.scientific.FragilityFunctionDiscrete(limit_state, imls, poes, no_damage_limit=None)

Bases: object

interp

class openquake.risklib.scientific.FragilityFunctionList(array, **attrs)

Bases: list

A list of fragility functions with common attributes; there is a function for each limit state.

mean_loss_ratios_with_steps(steps)

For compatibility with vulnerability functions

class openquake.risklib.scientific.FragilityModel(id, assetCategory, lossCategory, description, limitStates)

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)

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)

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

sample(means, covs, _stddevs, idxs)

survival(loss_ratio, mean, stddev)

class openquake.risklib.scientific.LossTypeCurveBuilder(loss_type, curve_resolution, loss_ratios, ses_ratio, user_provided, conditional_loss_poes=(), insured_losses=False)

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 = LossTypeCurveBuilder(loss_type, loss_ratios, ses_ratio,
                               user_provided=True)
counts = builder.build_counts(loss_matrix)

calc_agg_curve(losses)

Parameters:losses – array of length E Returns:curve of dtype agg_curve_dt

class openquake.risklib.scientific.VulnerabilityFunction(vf_id, imt, imls, mean_loss_ratios, covs=None, distribution='LN')

Bases: object

dtype = dtype([('iml', '<f4'), ('loss_ratio', '<f4'), ('cov', '<f4')])

init()

interpolate(gmvs)

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)

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)

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

set_distribution(epsilons=None)

strictly_increasing()

Returns:a new vulnerability function that is strictly increasing. It is built by removing piece of the function where the mean loss ratio is constant.

class openquake.risklib.scientific.VulnerabilityFunctionWithPMF(vf_id, imt, imls, loss_ratios, probs, seed=42)

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)

init()

interpolate(gmvs)

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)

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

set_distribution(epsilons=None)

class openquake.risklib.scientific.VulnerabilityModel(id=None, assetCategory=None, lossCategory=None)

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)

Parameters:

• poe – hazard probability of exceedence
• t_haz – hazard investigation time

openquake.risklib.scientific.average_loss(losses_poes)

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)

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)

Broadcast an array function over a composite array

openquake.risklib.scientific.build_dtypes(curve_resolution, conditional_loss_poes, insured=False)

Returns loss_curve_dt and loss_maps_dt

openquake.risklib.scientific.build_imls(ff, continuous_fragility_discretization, steps_per_interval=0)

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)

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)

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)

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.

openquake.risklib.scientific.classical_damage(fragility_functions, hazard_imls, hazard_poes, investigation_time, risk_investigation_time)

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)

Return the loss ratio corresponding to the given PoE (Probability of Exceendance). We can have four cases:

1. If probability is in poes it takes the bigger corresponding loss_ratios.
2. If it is in (poe1, poe2) where both poe1 and poe2 are in poes, then we perform a linear interpolation on the corresponding losses
3. if the given probability is smaller than the lowest PoE defined, it returns the max loss ratio .
4. 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)

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)

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)

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_maps(curves, conditional_loss_poes)

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)

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)

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)

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)

Differences between a value and the next value in a sequence

openquake.risklib.scientific.pairwise_mean(values)

Averages between a value and the next value in a sequence

openquake.risklib.scientific.scenario_damage(fragility_functions, gmv)

Compute the damage state fractions for the given ground motion value. Return am array of M values where M is the numbers of damage states.

openquake.risklib.utils module

class openquake.risklib.utils.memoized(func)

Bases: object

Minimalistic memoizer decorator

openquake.risklib.utils.numpy_map(f, *args)

openquake.risklib.utils.pairwise(iterable)

s -> (s0,s1), (s1,s2), (s2, s3), ...

Module contents