def classical_damage(self,
loss_type,
assets,
hazard_curve,
col=None,
rng=None):
"""
:param loss_type: the loss type
:param assets: a list of N assets of the same taxonomy
:param hazard_curve: a dictionary col -> hazard curve
:returns: an array of N x D elements
where N is the number of points and D the number of damage states.
"""
ffl = self.risk_functions[loss_type, 'fragility']
hazard_imls = self.hazard_imtls[ffl.imt]
rtime = self.risk_investigation_time or self.investigation_time
damage = scientific.classical_damage(
ffl,
hazard_imls,
hazard_curve,
investigation_time=self.investigation_time,
risk_investigation_time=rtime,
steps_per_interval=self.steps_per_interval)
res = numpy.array(
[a['value-number'] * damage for a in assets.to_records()])
return res
def test_discrete(self):
hazard_imls = [0.05, 0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4]
fragility_functions = scientific.FragilityFunctionList(
[], imls=hazard_imls, steps_per_interval=None, format='discrete')
fragility_functions.extend([
scientific.FragilityFunctionDiscrete(
'slight', hazard_imls,
[0.0, 0.771, 0.95, 0.989, 0.997, 0.999, 1., 1.]),
scientific.FragilityFunctionDiscrete(
'moderate', hazard_imls,
[0, 0.5, 0.861, 0.957, 0.985, 0.994, 0.997, 0.999]),
scientific.FragilityFunctionDiscrete(
'extreme', hazard_imls,
[0.0, 0.231, 0.636, 0.837, 0.924, 0.962, .981, .989]),
scientific.FragilityFunctionDiscrete(
'complete', hazard_imls,
[0, 0.097, 0.414, 0.661, 0.806, 0.887, 0.933, 0.959]),
])
hazard_poes = numpy.array([
0.999999999997518,
0.077404949,
0.015530587,
0.004201327,
0.001284191,
0.000389925,
0.000127992,
0.000030350,
])
investigation_time = 50.
risk_investigation_time = 100.
poos = scientific.classical_damage(
fragility_functions, hazard_imls, hazard_poes,
investigation_time, risk_investigation_time)
aaae(poos, [1.0415184E-09, 1.4577245E-06, 1.9585762E-03, 6.9677521E-02,
9.2836244E-01])
def classical_damage(self,
loss_type,
assets,
hazard_curve,
eids=None,
eps=None):
"""
:param loss_type: the loss type
:param assets: a list of N assets of the same taxonomy
:param hazard_curve: an hazard curve array
:returns: an array of N x D elements
where N is the number of points and D the number of damage states.
"""
ffl = self.risk_functions[loss_type, 'fragility']
hazard_imls = self.hazard_imtls[ffl.imt]
debug = False # assets['id'] == b'a5' to debug case_master
damage = scientific.classical_damage(
ffl,
hazard_imls,
hazard_curve,
investigation_time=self.investigation_time,
risk_investigation_time=self.risk_investigation_time,
steps_per_interval=self.steps_per_interval,
debug=debug)
res = numpy.array([a['number'] * damage for a in assets])
return res
def test_discrete(self):
hazard_imls = [0.05, 0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4]
fragility_functions = scientific.FragilityFunctionList(
[], imls=hazard_imls, format='discrete')
fragility_functions.extend([
scientific.FragilityFunctionDiscrete(
'slight', hazard_imls,
[0.0, 0.771, 0.95, 0.989, 0.997, 0.999, 1., 1.]),
scientific.FragilityFunctionDiscrete(
'moderate', hazard_imls,
[0, 0.5, 0.861, 0.957, 0.985, 0.994, 0.997, 0.999]),
scientific.FragilityFunctionDiscrete(
'extreme', hazard_imls,
[0.0, 0.231, 0.636, 0.837, 0.924, 0.962, .981, .989]),
scientific.FragilityFunctionDiscrete(
'complete', hazard_imls,
[0, 0.097, 0.414, 0.661, 0.806, 0.887, 0.933, 0.959]),
])
hazard_poes = numpy.array([
0.999999999997518,
0.077404949,
0.015530587,
0.004201327,
0.001284191,
0.000389925,
0.000127992,
0.000030350,
])
investigation_time = 50.
risk_investigation_time = 100.
poos = scientific.classical_damage(
fragility_functions, hazard_imls, hazard_poes,
investigation_time, risk_investigation_time)
aaae(poos, [1.0415184E-09, 1.4577245E-06, 1.9585762E-03, 6.9677521E-02,
9.2836244E-01])
def __call__(self,
loss_type,
assets,
hazard_curve,
_epsilons=None,
_eids=None):
"""
:param loss_type: the loss type
:param assets: a list of N assets of the same taxonomy
:param hazard_curve: an hazard curve array
:returns: an array of N assets and an array of N x D elements
where N is the number of points and D the number of damage states.
"""
ffl = self.risk_functions[loss_type]
hazard_imls = self.hazard_imtls[ffl.imt]
damage = scientific.classical_damage(
ffl,
hazard_imls,
hazard_curve,
investigation_time=self.investigation_time,
risk_investigation_time=self.risk_investigation_time)
return scientific.Output(assets,
loss_type,
damages=[a.number * damage for a in assets])
def test_continuous(self):
hazard_imls = numpy.array([
0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6,
0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1, 1.05, 1.1, 1.15, 1.2,
1.25, 1.3, 1.35, 1.4
])
fragility_functions = scientific.FragilityFunctionList(
[
scientific.FragilityFunctionContinuous('slight', 0.160, 0.104),
scientific.FragilityFunctionContinuous('moderate', 0.225,
0.158),
scientific.FragilityFunctionContinuous('extreme', 0.400,
0.300),
scientific.FragilityFunctionContinuous('complete', 0.600,
0.480),
],
imls=hazard_imls,
steps_per_interval=None)
hazard_poes = numpy.array([
0.5917765421,
0.2482053921,
0.1298604374,
0.07718928965,
0.04912904516,
0.03262871528,
0.02226628376,
0.01553639696,
0.01101802934,
0.007905366815,
0.005741833876,
0.004199803178,
0.003088785556,
0.00229291494,
0.001716474683,
0.001284555773,
0.0009583846496,
0.0007102377096,
0.0005201223961,
0.0003899464723,
0.0002997724582,
0.0002287788496,
0.0001726083994,
0.0001279544769,
0.00009229282594,
0.00006368651249,
0.00004249201524,
0.00003033694903,
])
investigation_time = 50.
risk_investigation_time = 100.
poos = scientific.classical_damage(fragility_functions, hazard_imls,
hazard_poes, investigation_time,
risk_investigation_time)
aaae(poos, [0.56652127, 0.12513401, 0.1709355, 0.06555033, 0.07185889])
def test_continuous(self):
hazard_imls = numpy.array(
[0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6,
0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1, 1.05, 1.1, 1.15, 1.2,
1.25, 1.3, 1.35, 1.4])
fragility_functions = scientific.FragilityFunctionList(
[], imls=hazard_imls, steps_per_interval=None, format='continuous')
fragility_functions.extend([
scientific.FragilityFunctionContinuous(
'slight', 0.160, 0.104),
scientific.FragilityFunctionContinuous(
'moderate', 0.225, 0.158),
scientific.FragilityFunctionContinuous(
'extreme', 0.400, 0.300),
scientific.FragilityFunctionContinuous(
'complete', 0.600, 0.480),
])
hazard_poes = numpy.array([
0.5917765421,
0.2482053921,
0.1298604374,
0.07718928965,
0.04912904516,
0.03262871528,
0.02226628376,
0.01553639696,
0.01101802934,
0.007905366815,
0.005741833876,
0.004199803178,
0.003088785556,
0.00229291494,
0.001716474683,
0.001284555773,
0.0009583846496,
0.0007102377096,
0.0005201223961,
0.0003899464723,
0.0002997724582,
0.0002287788496,
0.0001726083994,
0.0001279544769,
0.00009229282594,
0.00006368651249,
0.00004249201524,
0.00003033694903,
])
investigation_time = 50.
risk_investigation_time = 100.
poos = scientific.classical_damage(
fragility_functions, hazard_imls, hazard_poes,
investigation_time, risk_investigation_time)
aaae(poos, [0.56652127, 0.12513401, 0.1709355, 0.06555033, 0.07185889])
def __call__(self, loss_type, assets, hazard_curve, eids=None, eps=None):
"""
:param loss_type: the loss type
:param assets: a list of N assets of the same taxonomy
:param hazard_curve: an hazard curve array
:returns: an array of N assets and an array of N x D elements
where N is the number of points and D the number of damage states.
"""
ffl = self.fragility_functions[loss_type, self.kind]
hazard_imls = self.hazard_imtls[ffl.imt]
damage = scientific.classical_damage(
ffl, hazard_imls, hazard_curve,
investigation_time=self.investigation_time,
risk_investigation_time=self.risk_investigation_time)
return [a['number'] * damage for a in assets]
def classical_damage(
self, loss_type, assets, hazard_curve, eids=None, eps=None):
"""
:param loss_type: the loss type
:param assets: a list of N assets of the same taxonomy
:param hazard_curve: an hazard curve array
:returns: an array of N assets and an array of N x D elements
where N is the number of points and D the number of damage states.
"""
ffl = self.risk_functions[loss_type, 'fragility']
hazard_imls = self.hazard_imtls[ffl.imt]
damage = scientific.classical_damage(
ffl, hazard_imls, hazard_curve,
investigation_time=self.investigation_time,
risk_investigation_time=self.risk_investigation_time)
return [a['number'] * damage for a in assets]
def __call__(self, loss_type, assets, hazard_curves, _epsilons=None,
_tags=None):
"""
:param loss_type: the loss type
:param assets: a list of N assets of the same taxonomy
:param hazard_curves: an array of N x E elements
:returns: an array of N assets and an array of N x D elements
where N is the number of points and D the number of damage states.
"""
damages = [
asset.number * scientific.classical_damage(
self.risk_functions[loss_type], self.hazard_imls, curve,
investigation_time=self.investigation_time,
risk_investigation_time=self.risk_investigation_time)
for asset, curve in zip(assets, hazard_curves)]
return scientific.Output(assets, loss_type, damages=damages)
def __call__(self,
loss_type,
assets,
hazard_curves,
_epsilons=None,
_tags=None):
"""
:param loss_type: the loss type
:param assets: a list of N assets of the same taxonomy
:param hazard_curves: an array of N x E elements
:returns: an array of N assets and an array of N x D elements
where N is the number of points and D the number of damage states.
"""
damages = [
asset.number * scientific.classical_damage(
self.risk_functions[loss_type],
self.hazard_imls,
curve,
investigation_time=self.investigation_time,
risk_investigation_time=self.risk_investigation_time)
for asset, curve in zip(assets, hazard_curves)
]
return scientific.Output(assets, loss_type, damages=damages)
