# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>.
import logging
import numpy
from openquake.baselib.general import CallableDict
from openquake.hazardlib import geo, site
from openquake.hazardlib.shakemap.parsers import get_array
F32 = numpy.float32
get_sitecol_shakemap = CallableDict()
@get_sitecol_shakemap.add('shapefile')
def get_sitecol_shapefile(kind,
uridict,
required_imts,
sitecol=None,
assoc_dist=None,
mode='filter'):
"""
:param uridict: a dictionary specifying the ShakeMap resource
:param imts: required IMTs as a list of strings
:param sitecol: SiteCollection used to reduce the shakemap
:param assoc_dist: unused for shapefiles
:param mode: 'strict', 'warn' or 'filter'
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>.
"""
Source model XML Writer
"""
import os
import operator
from openquake.baselib.general import CallableDict, groupby
from openquake.baselib.node import Node, node_to_dict
from openquake.hazardlib import nrml, sourceconverter
obj_to_node = CallableDict(lambda obj: obj.__class__.__name__)
def build_area_source_geometry(area_source):
"""
Returns the area source geometry as a Node
:param area_source:
Area source model as an instance of the :class:
`openquake.hazardlib.source.area.AreaSource`
:returns:
Instance of :class:`openquake.baselib.node.Node`
"""
geom = []
for lon_lat in zip(area_source.polygon.lons, area_source.polygon.lats):
geom.extend(lon_lat)
from openquake.baselib.hdf5 import FLOAT, INT, get_shape_descr
from openquake.baselib.performance import performance_view
from openquake.baselib.python3compat import encode, decode
from openquake.hazardlib.gsim.base import ContextMaker
from openquake.commonlib import util
from openquake.risklib.scientific import losses_by_period, return_periods
from openquake.baselib.writers import build_header, scientificformat
from openquake.calculators.getters import get_rupture_getters
from openquake.calculators.extract import extract
F32 = numpy.float32
U32 = numpy.uint32
U8 = numpy.uint8
# a dictionary of views datastore -> array
view = CallableDict(keyfunc=lambda s: s.split(':', 1)[0])
# ########################## utility functions ############################## #
def form(value):
"""
Format numbers in a nice way.
>>> form(0)
'0'
>>> form(0.0)
'0.0'
>>> form(0.0001)
'1.000E-04'
>>> form(1003.4)
Module exports :class:`SilvaEtAl2002MblgAB1987NSHMP2008`,
:class:`SilvaEtAl2002MblgJ1996NSHMP2008`, :class:`SilvaEtAl2002MwNSHMP2008`,
:class:`SilvaEtAl2002SingleCornerSaturation`,
:class:`SilvaEtAl2002DoubleCornerSaturation`.
"""
import numpy as np
from openquake.hazardlib.gsim.base import CoeffsTable, GMPE
from openquake.hazardlib.gsim.utils import (mblg_to_mw_atkinson_boore_87,
mblg_to_mw_johnston_96, clip_mean)
from openquake.hazardlib import const
from openquake.hazardlib.imt import PGA, SA
from openquake.baselib.general import CallableDict
_convert_magnitude = CallableDict()
@_convert_magnitude.add("Mblg87")
def _convert_magnitude87(kind, mag):
"""
Convert magnitude from Mblg to Mw using Atkinson and Boore 1987
equation
"""
return mblg_to_mw_atkinson_boore_87(mag)
@_convert_magnitude.add("Mblg96")
def _convert_magnitude96(kind, mag):
"""
Convert magnitude from Mblg to Mw using Johnston 1996 equation
import numpy
try:
import h5py
except ImportError:
# there is no need of h5py in the workers
class mock_h5py(object):
def __getattr__(self, name):
raise ImportError('Could not import h5py.%s' % name)
h5py = mock_h5py()
from openquake.baselib.general import CallableDict
from openquake.commonlib.writers import write_csv
# a dictionary of views datastore -> array
view = CallableDict()
DATADIR = os.environ.get('OQ_DATADIR', os.path.expanduser('~/oqdata'))
def get_nbytes(dset):
"""
If the dataset has an attribute 'nbytes', return it. Otherwise get the size
of the underlying array. Returns None if the dataset is actually a group.
"""
if 'nbytes' in dset.attrs:
# look if the dataset has an attribute nbytes
return dset.attrs['nbytes']
elif hasattr(dset, 'value'):
# else extract nbytes from the underlying array
return dset.value.nbytes
the pair ('fragilityModel', 'nrml/0.4').
"""
version, tag = re.search(r'(nrml/[\d\.]+)\}(\w+)', nrml_node.tag).groups()
return tag, version
def to_python(fname, *args):
"""
Parse a NRML file and return an associated Python object. It works by
calling nrml.read() and node_to_obj() in sequence.
"""
[node] = read(fname)
return node_to_obj(node, fname, *args)
node_to_obj = CallableDict(keyfunc=get_tag_version, keymissing=lambda n, f: n)
# dictionary of functions with at least two arguments, node and fname
default = sourceconverter.SourceConverter(area_source_discretization=10,
rupture_mesh_spacing=10)
@node_to_obj.add(('ruptureCollection', 'nrml/0.5'))
def get_rupture_collection(node, fname, converter):
return converter.convert_node(node)
@node_to_obj.add(('geometryModel', 'nrml/0.5'))
def get_geometry_model(node, fname, converter):
return GeometryModel(converter.convert_node(node))
def path2url(url):
"""
If a relative path is given for the file, parse it so it can be
read with 'urlopen'.
:param url: path/url to be parsed
"""
if not url.startswith('file:') and not url.startswith('http'):
file = pathlib.Path(url)
if file.is_file():
return 'file:{}'.format(pathname2url(str(file.absolute())))
raise FileNotFoundError('The following path could not be found: %s' %
url)
return url
get_array = CallableDict()
@get_array.add('shapefile')
def get_array_shapefile(kind, fname):
"""
Download and parse data saved as a shapefile.
:param fname: url or filepath for the shapefiles,
either a zip or the location of one of the files,
*.shp and *.dbf are necessary, *.prj and *.shx optional
"""
fname = path2url(fname)
extensions = ['shp', 'dbf', 'prj', 'shx']
f_dict = {}
# Copyright (c) 2010-2015, GEM Foundation.
#
# OpenQuake is free software: you can redistribute it and/or modify it
# under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# OpenQuake is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>.
"""This package contains Hazard and Risk calculator classes."""
from openquake.baselib.general import CallableDict, import_all
# an ordered dictionary of calculator classes
calculators = CallableDict(lambda job: job.get_param('calculation_mode'))
import_all('openquake.engine.calculators')
return C['pd'] * np.log10(np.maximum(tmp, z1pt4) / d0)
def _get_intensity_correction_term(C, region, xvf, focal_depth):
if region == 'NE':
gamma = C['gNE']
elif region == 'SW':
gamma = C['gEW']
elif region is None:
gamma = 0.
else:
raise ValueError('Unsupported region')
return (gamma * np.minimum(xvf, 75.0) * np.maximum(focal_depth - 30., 0.))
_get_magnitude_term = CallableDict()
@_get_magnitude_term.add(const.TRT.ACTIVE_SHALLOW_CRUST)
def _get_magnitude_term_1(trt, region, C, rrup, mw1prime, mw1, rhypo):
return (C['a'] * (mw1prime - mw1)**2 + C['b1'] * rrup + C['c1'] -
np.log10(rrup + C['d'] * 10.**(CONSTS['e'] * mw1prime)))
@_get_magnitude_term.add(const.TRT.SUBDUCTION_INTERFACE)
def _get_magnitude_term_2(trt, region, C, rrup, mw1prime, mw1, rhypo):
return (C['a'] * (mw1prime - mw1)**2 + C['b2'] * rrup + C['c2'] -
np.log10(rrup + C['d'] * 10.**(CONSTS['e'] * mw1prime)))
@_get_magnitude_term.add(const.TRT.SUBDUCTION_INTRASLAB)
"""
Table 3 and equation 19 of 2013 report.
"""
if imt_per < 0.18:
dL2L = -0.06
elif 0.18 <= imt_per < 0.35:
dL2L = _interp_function(0.12, -0.06, 0.35, 0.18, imt_per)
elif 0.35 <= imt_per <= 10:
dL2L = _interp_function(0.65, 0.12, 10, 0.35, imt_per)
else:
dL2L = 0
return dL2L
_get_dS2S = CallableDict()
@_get_dS2S.add("CBD")
def _get_dS2S_1(region, imt_per):
"""
Table 4 of 2013 report
"""
if imt_per == 0:
dS2S = 0.05
elif 0 < imt_per < 0.15:
dS2S = _interp_function(-0.15, 0.05, 0.15, 0, imt_per)
elif 0.15 <= imt_per < 0.45:
dS2S = _interp_function(0.4, -0.15, 0.45, 0.15, imt_per)
elif 0.45 <= imt_per < 3.2:
dS2S = 0.4
from openquake.baselib.general import CallableDict
from openquake.hazardlib import const
from openquake.hazardlib.gsim.base import GMPE, CoeffsTable, add_alias
from openquake.hazardlib.imt import PGA, SA, PGV
CONSTANTS = {
"b4": 0.1,
"f3": 0.05,
"Vb": 200,
"vref_fnl": 760,
"V1": 270,
"vref": 760
}
_a0 = CallableDict()
@_a0.add(const.TRT.SUBDUCTION_INTERFACE)
def _a0_1(trt, region, basin, C, C_PGA):
"""
Regional anelastic coefficient, a0
"""
if region is None or region == "Cascadia":
a0 = C["a0"]
a0_pga = C_PGA["a0"]
else:
a0 = C[region + "_a0"]
a0_pga = C_PGA[region + "_a0"]
return a0, a0_pga
returns lnSA_ABCD
"""
# Stage 1: compute PGA_ABCD and PGA'_ABCD which are then used in
# equation 6
# Equation 1 PGA unprimed version
lnSA_AB = _compute_mean_on_rock(kind, C, mag, rrup, rvol, hypo_depth,
CN, CR, f4HW)
# Equation 4 PGA unprimed version
lnSA_ABCD = lnSA_AB + S * _compute_nonlinear_soil_term(
C, lnSA_AB, delta_C, delta_D)
return lnSA_ABCD
_compute_mean_on_rock = CallableDict()
@_compute_mean_on_rock.add("asc", "asc_sc", "vol", "vol_sc", "chch", "drop")
def _compute_mean_on_rock_1(kind, C, mag, rrup, rvol, hypo_depth, CN, CR,
f4HW):
"""
Compute mean value on site class A/B (equation 1 on page 22)
"""
lnSA_AB = (
# line 1 of equation 1
C['c1'] + C['c4as'] * (mag - 6) +
# line 2
C['c3as'] * (8.5 - mag) ** 2 +
# line 3
C['c5'] * rrup +
return C["e1"] + (C["b1"] * dmag) + (C["b2"] * (dmag ** 2.0))
else:
return C["e1"] + (C["b3"] * dmag)
def _get_mean(kind, sof, C, ctx, dists):
"""
Returns the mean ground motion
"""
sof_term = _get_style_of_faulting_term(C, ctx) if sof else 0.
return (_get_magnitude_scaling_term(C, ctx.mag) +
_get_distance_scaling_term(C, dists, ctx.mag) +
_get_site_amplification_term(kind, C, ctx.vs30) + sof_term)
_get_site_amplification_term = CallableDict()
@_get_site_amplification_term.add("base")
def _get_site_amplification_term_1(kind, C, vs30):
"""
Returns the site amplification term for the case in which Vs30
is used directly
"""
return C["gamma"] * np.log10(vs30 / CONSTS["Vref"])
@_get_site_amplification_term.add("EC8")
def _get_site_amplification_term_2(kind, C, vs30):
"""
Returns the site amplification given Eurocode 8 site classification
def _fc(C, imt, vs30, sa1180):
"""
C value factor [23].
"""
s = CONSTANTS
if imt.string in ["PGD", "PGV"]:
c = 2400
else:
c = 2.4
return (-1.5 * np.log(vs30 / s['vs30_ref']) - np.log(sa1180 + c)
+ np.log(sa1180 + c * (vs30 / s['vs30_ref']) ** 1.5)) \
* np.heaviside(s['vs30_ref'] - vs30, 0.5) * C['c23']
_ffault = CallableDict()
@_ffault.add(const.TRT.SUBDUCTION_INTERFACE, const.TRT.SUBDUCTION_INTRASLAB)
def _ffault_1(trt, MC, SUFFIX, C, mag):
"""
Other fault specific factors.
"""
return (6 - mag) * np.heaviside(6 - mag, 0.5) * C['c13'] \
+ (mag - MC) * np.heaviside(mag - MC, 0.5) \
* C['c29' + SUFFIX]
@_ffault.add(const.TRT.ACTIVE_SHALLOW_CRUST)
def _ffault_2(trt, MC, SUFFIX, C, mag):
"""
# You should have received a copy of the GNU Affero General Public License
# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>.
"""
Module exports :class:'AllenEtAl2012',
'AllenEtAl2012Rhypo'
"""
import numpy as np
from openquake.hazardlib.gsim.base import GMPE, CoeffsTable
from openquake.hazardlib import const
from openquake.hazardlib.imt import MMI
from openquake.baselib.general import CallableDict
_compute_distance_term = CallableDict()
@_compute_distance_term.add('rrup')
def _compute_distance_term_rrup(kind, C, rrup, mag):
"""
Returns the distance scaling term
"""
exponent_term = (1.0 + C["c3"] * np.exp(mag - 5.)) ** 2.
return C["c2"] * np.log(np.sqrt(rrup ** 2. + exponent_term))
@_compute_distance_term.add('rhypo')
def _compute_distance_term_rhypo(kind, C, rhypo, mag):
"""
Returns the distance scaling term
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>.
"""Functions for getting information about completed jobs and
calculation outputs, as well as exporting outputs from the database to various
file formats."""
import os
from openquake.engine.db import models
from openquake.engine.logs import LOG
from openquake.baselib.general import CallableDict
export_output = CallableDict()
def export(output_id, target, export_type='xml,geojson,csv'):
"""
Export the given calculation `output_id` from the database to the
specified `target` directory in the specified `export_type`.
"""
output = models.Output.objects.get(id=output_id)
if isinstance(target, basestring): # create target directory
makedirs(target)
for exptype in export_type.split(','):
key = (output.output_type, exptype)
if key in export_output:
return export_output(key, output, target)
LOG.warn('No "%(fmt)s" exporter is available for "%(output_type)s"'
version, tag = re.search(r'(nrml/[\d\.]+)\}(\w+)', nrml_node.tag).groups()
return tag, version
def parse(fname, *args):
"""
Parse a NRML file and return an associated Python object. It works by
calling nrml.read() and build() in sequence.
"""
[node] = read(fname)
return build(node, fname, *args)
# ######################### build definitions ############################ #
build = CallableDict(keyfunc=get_tag_version)
# dictionary of functions with at least two arguments, node and fname
# TODO: add proper validation for exposureModel; this requires knowledge
# of the job.ini files
@build.add(('exposureModel', 'nrml/0.4'), ('exposureModel', 'nrml/0.5'),
('siteModel', 'nrml/0.4'), ('siteModel', 'nrml/0.5'),)
def build_exposure(node, fname):
return node
@build.add(('vulnerabilityModel', 'nrml/0.4'))
def get_vulnerability_functions_04(node, fname):
"""
:param node:
# Pitilakis GMPE Wrapper
uppernames = '''
DEFINED_FOR_INTENSITY_MEASURE_TYPES
DEFINED_FOR_STANDARD_DEVIATION_TYPES
REQUIRES_SITES_PARAMETERS
REQUIRES_RUPTURE_PARAMETERS
REQUIRES_DISTANCES
'''.split()
CONSTANTS = {"F0": 2.5, "kappa": 5.0, "TA": 0.03}
IMLS = [0., 0.25, 0.5, 0.75, 1., 1.25]
MEAN, SIGMA, INTER, INTRA = 0, 1, 2, 3
get_amplification_factor = CallableDict()
@get_amplification_factor.add("base")
def get_amplification_factor_1(kind, F1, FS, s_s, s_1, sctx, ec8=None):
"""
Returns the short and long-period amplification factors given the
input Pitilakis et al. (2018) site class and the short and long-period
input accelerations
"""
f_s = np.ones(sctx.ec8_p18.shape, dtype=float)
f_l = np.ones(sctx.ec8_p18.shape, dtype=float)
for ec8b in np.unique(sctx.ec8_p18):
ec8 = ec8b.decode('ascii')
if ec8 == "A":
# Amplification factors are 1
# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>.
"""
Module exports :class:`ToroEtAl1997MblgNSHMP2008`,
:class:`ToroEtAl1997MwNSHMP2008`
"""
import numpy as np
from openquake.hazardlib.gsim.base import CoeffsTable, GMPE
from openquake.hazardlib.gsim.utils import (
mblg_to_mw_johnston_96, mblg_to_mw_atkinson_boore_87, clip_mean)
from openquake.hazardlib import const
from openquake.hazardlib.imt import PGA, SA
from openquake.baselib.general import CallableDict
_compute_finite_fault_correction = CallableDict()
@_compute_finite_fault_correction.add("Mblg")
def _compute_finite_fault_correction_Mblg(kind, mag):
"""
Compute finite fault correction term as geometric mean of correction
terms obtained from Mw values calculated with Johnston 1996 and
Atkinson and Boore 1987 conversion equations.
Implement equations as in lines 1653 - 1658 in hazgridXnga2.f
"""
mw_j96 = mblg_to_mw_johnston_96(mag)
mw_ab87 = mblg_to_mw_atkinson_boore_87(mag)
t1 = np.exp(-1.25 + 0.227 * mw_j96)
def __str__(self):
return "filename '%s', line %s: %s" % (self.filename, self.lineno,
self.message)
# parse_uncertainty #
def unknown(utype, node, filename):
try:
return float(node.text)
except (TypeError, ValueError):
raise LogicTreeError(node, filename, 'expected single float value')
parse_uncertainty = CallableDict(keymissing=unknown)
@parse_uncertainty.add('sourceModel', 'extendModel')
def smodel(utype, node, filename):
return node.text.strip()
@parse_uncertainty.add('abGRAbsolute')
def abGR(utype, node, filename):
try:
[a, b] = node.text.split()
return float(a), float(b)
except ValueError:
raise LogicTreeError(node, filename,
'expected a pair of floats separated by space')
array = dstore[ekey[0]].value
except AttributeError:
# this happens if the key correspond to a HDF5 group
return [] # write a custom exporter in this case
if len(array.shape) == 1: # vector
array = array.reshape((len(array), 1))
return [write_csv(dstore.export_path(name), array)]
def dispatch_on_colon(ekey, dstore):
"""
If the datastore key contains a colon, i.e. it is of the form
dskey:spec, then call `export(('<dskey>:', fmt), dstore, spec)`.
:param ekey:
export key of the form (k0, ext) with k0 of the form <dskey>:<spec>
:param dstore:
datastore instance
This function is called only for ekey not present in the datastore.
"""
if ':' not in ekey[0]:
raise MissingExporter(ekey)
dkey, spec = ekey[0].split(':', 1)
return export((dkey + ':', ekey[1]), dstore, spec)
export = CallableDict(keymissing=dispatch_on_colon)
import_all('openquake.commonlib.export')
Decompose the spatial covariance and cross correlation matrices.
:param spatial_cov: array of shape (M, N, N)
:param cross_corr: array of shape (M, M)
:returns: a triangular matrix of shape (M * N, M * N)
"""
M, N = spatial_cov.shape[:2]
L = numpy.array([numpy.linalg.cholesky(spatial_cov[i]) for i in range(M)])
LLT = []
for i in range(M):
row = [L[i] @ L[j].T * cross_corr[i, j] for j in range(M)]
LLT.extend(numpy.array(row).transpose(1, 0, 2).reshape(N, M * N))
return numpy.linalg.cholesky(numpy.array(LLT))
calculate_gmfs = CallableDict()
CORRELATION_MATRIX_TOO_LARGE = '''\
You have a correlation matrix which is too large: %s > %d.
To avoid that, set a proper `region_grid_spacing` so that your exposure
involves less sites.'''
@calculate_gmfs.add('Silva&Horspool')
def calculate_gmfs_sh(kind, shakemap, imts, Z, mu, spatialcorr, crosscorr,
cholesky_limit):
"""
Implementation of paper by Silva and Horspool 2019
https://onlinelibrary.wiley.com/doi/abs/10.1002/eqe.3154?af=R
:param shakemap: site coordinates with shakemap values
# You should have received a copy of the GNU Affero General Public
# License along with OpenQuake Risklib. If not, see
# <http://www.gnu.org/licenses/>.
from __future__ import division
import sys
import inspect
import functools
import collections
import mock
import numpy
from openquake.baselib.general import CallableDict
from openquake.commonlib import valid
from openquake.risklib import utils, scientific
registry = CallableDict()
class CostCalculator(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
from scipy.constants import g
from openquake.baselib.general import CallableDict
from openquake.hazardlib.gsim.base import GMPE, CoeffsTable
from openquake.hazardlib import const
from openquake.hazardlib.imt import PGA, PGV
def _compute_distance_term(C, rhypo):
"""
Returns the distance scaling term
"""
return (C["c2"] * rhypo) + (C["c3"] * np.log10(rhypo))
_compute_magnitude_term = CallableDict()
@_compute_magnitude_term.add("base")
def _compute_magnitude_term_1(kind, C, mag):
"""
Returns the magnitude scaling term
"""
return C["c0"] + (C["c1"] * mag)
@_compute_magnitude_term.add("bommer")
def _compute_magnitude_term_2(kind, C, mag):
"""
Returns the magnitude scaling term
"""
mean = (
# 1st term
C['c1'] + C['c2'] * mag +
# 2nd term
C['c3'] * hypo_depth +
# 3rd term
C['c4'] * R -
# 4th term
g * np.log10(R) +
# 5th, 6th and 7th terms
s_amp)
return mean
_compute_site_class_dummy_variables = CallableDict()
@_compute_site_class_dummy_variables.add('SInter')
def _compute_site_class_dummy_variables_SInter(kind, vs30):
"""
Compute site class dummy variables as explained in paragraph
'Functional Form', page 1706.
"""
Sc = np.zeros_like(vs30)
Sd = np.zeros_like(vs30)
Se = np.zeros_like(vs30)
Sc[(vs30 > 360) & (vs30 <= 760)] = 1
Sd[(vs30 >= 180) & (vs30 <= 360)] = 1
Se[vs30 < 180] = 1
def keyfunc(ekey):
"""
Extract the name before the colons:
>>> keyfunc(('agg_loss_table', 'csv'))
('agg_loss_table', 'csv')
>>> keyfunc(('agg_loss_table/1', 'csv'))
('agg_loss_table', 'csv')
>>> keyfunc(('agg_loss_table/1/0', 'csv'))
('agg_loss_table', 'csv')
"""
fullname, ext = ekey
return (fullname.split('/', 1)[0], ext)
export = CallableDict(keyfunc)
export.from_db = False # overridden when exporting from db
import_all('openquake.calculators.export')
@export.add(('input_zip', 'zip'))
def export_input_zip(ekey, dstore):
"""
Export the data in the `input_zip` dataset as a .zip file
"""
dest = dstore.export_path('input.zip')
nbytes = dstore.get_attr('input_zip', 'nbytes')
zbytes = dstore['input_zip'].value
# when reading input_zip some terminating null bytes are truncated (for
"""
Module exports :class:`TusaLanger2016RepiBA08SE`,
:class:`TusaLanger2016RepiBA08DE`,
:class:`TusaLanger2016RepiSP87SE`,
:class:`TusaLanger2016RepiSP87DE`,
:class:`TusaLanger2016Rhypo`
"""
import numpy as np
from scipy.constants import g
from openquake.hazardlib.gsim.base import GMPE, CoeffsTable
from openquake.hazardlib import const
from openquake.hazardlib.imt import PGA, SA
from openquake.baselib.general import CallableDict
_compute_distance = CallableDict()
@_compute_distance.add("BA08SE", "BA08DE")
def _compute_distance1(kind, ctx, C):
"""
Compute the distance function, equation (9):
"""
mref = 3.6
rref = 1.0
rval = np.sqrt(ctx.repi ** 2 + C['h'] ** 2)
return (C['c1'] + C['c2'] * (ctx.mag - mref)) *\
np.log10(rval / rref) + C['c3'] * (rval - rref)
@_compute_distance.add("SP87SE", "SP87DE")
def keyfunc(ekey):
"""
Extract the name before the slash:
>>> keyfunc(('risk_by_event', 'csv'))
('risk_by_event', 'csv')
>>> keyfunc(('risk_by_event/1', 'csv'))
('risk_by_event', 'csv')
>>> keyfunc(('risk_by_event/1/0', 'csv'))
('risk_by_event', 'csv')
"""
fullname, ext = ekey
return (fullname.split('/', 1)[0], ext)
export = CallableDict(keyfunc)
export.sanity_check = False # overridden in the tests
export.from_db = False # overridden when exporting from db
@export.add(('input', 'zip'))
def export_input_zip(ekey, dstore):
"""
Export the data in the `input` datagroup as a .zip file
"""
dest = dstore.export_path('input.zip')
with zipfile.ZipFile(
dest, 'w', zipfile.ZIP_DEFLATED, allowZip64=True) as z:
for k, data in dstore.retrieve_files():
logging.info('Archiving %s' % k)
z.writestr(k, data)
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# for more details.
#
# The GEM Foundation, and the authors of the software, assume no
# liability for use of the software.
# -*- coding: utf-8 -*-
"""
"""
import abc
import numpy as np
from openquake.baselib.general import CallableDict
TIME_DISTANCE_WINDOW_FUNCTIONS = CallableDict()
class BaseDistanceTimeWindow(object):
"""
Defines the space and time windows, within which an event is identified
as a cluster.
"""
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def calc(self, magnitude):
"""
Allows to calculate distance and time windows (sw_space, sw_time)
see reference: `Van Stiphout et al (2011)`.
mean = (C['A1'] +
(C['A2'] + C['A2R'] * delta_R + C['A2V'] * delta_V) * mag +
(C['A3'] + C['A3S'] * delta_S + C['A3V'] * delta_V) *
np.log10(np.power((rrup**3 + C['d']**3), 1.0 / 3.0)) +
C['A4'] * hypo_depth + C['A5'] * delta_I)
# Get S site class term
S = _get_site_class(vs30, mean)
# Add S amplification term to mean value
mean = mean + S
return mean
_get_deltas = CallableDict()
@_get_deltas.add(const.TRT.ACTIVE_SHALLOW_CRUST)
def _get_deltas_1(trt, rake):
"""
Return the value of deltas (delta_R, delta_S, delta_V, delta_I),
as defined in "Table 5: Model 1" pag 198
"""
# delta_R = 1 for reverse focal mechanism (45<rake<135)
# and for interface events, 0 for all other events
# delta_S = 1 for Strike-slip focal mechanisms (0<=rake<=45) or
# (135<=rake<=180) or (-45<=rake<=0), 0 for all other events
# delta_V = 1 for TVZ events, 0 for all other events
# delta_I = 1 for interface events, 0 for all other events
