Search is not available for this dataset
text stringlengths 75 104k |
|---|
def export_ruptures_csv(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
oq = dstore['oqparam']
if 'scenario' in oq.calculation_mode:
return []
dest = dstore.export_path('ruptures.csv')
header = ('rupid multiplicity ... |
def export_hmaps_csv(key, dest, sitemesh, array, comment):
"""
Export the hazard maps of the given realization into CSV.
:param key: output_type and export_type
:param dest: name of the exported file
:param sitemesh: site collection
:param array: a composite array of dtype hmap_dt
:param co... |
def add_imt(fname, imt):
"""
>>> add_imt('/path/to/hcurve_23.csv', 'SA(0.1)')
'/path/to/hcurve-SA(0.1)_23.csv'
"""
name = os.path.basename(fname)
newname = re.sub(r'(_\d+\.)', '-%s\\1' % imt, name)
return os.path.join(os.path.dirname(fname), newname) |
def export_hcurves_by_imt_csv(
key, kind, rlzs_assoc, fname, sitecol, array, oq, checksum):
"""
Export the curves of the given realization into CSV.
:param key: output_type and export_type
:param kind: a string with the kind of output (realization or statistics)
:param rlzs_assoc: a :class:... |
def hazard_curve_name(dstore, ekey, kind, rlzs_assoc):
"""
:param calc_id: the calculation ID
:param ekey: the export key
:param kind: the kind of key
:param rlzs_assoc: a RlzsAssoc instance
"""
key, fmt = ekey
prefix = {'hcurves': 'hazard_curve', 'hmaps': 'hazard_map',
'uh... |
def get_kkf(ekey):
"""
:param ekey: export key, for instance ('uhs/rlz-1', 'xml')
:returns: key, kind and fmt from the export key, i.e. 'uhs', 'rlz-1', 'xml'
"""
key, fmt = ekey
if '/' in key:
key, kind = key.split('/', 1)
else:
kind = ''
return key, kind, fmt |
def export_hcurves_csv(ekey, dstore):
"""
Exports the hazard curves into several .csv files
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
oq = dstore['oqparam']
info = get_info(dstore)
rlzs_assoc = dstore['csm_info'].get_rlzs_assoc()
R... |
def get_metadata(realizations, kind):
"""
:param list realizations:
realization objects
:param str kind:
kind of data, i.e. a key in the datastore
:returns:
a dictionary with smlt_path, gsimlt_path, statistics, quantile_value
"""
metadata = {}
if kind.startswith('rlz-... |
def export_gmf(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
oq = dstore['oqparam']
if not oq.calculation_mode.startswith('scenario'):
return []
sitecol = dstore['sitecol']
investigation_time = (None if oq.calcula... |
def save_disagg_to_csv(metadata, matrices):
"""
Save disaggregation matrices to multiple .csv files.
"""
skip_keys = ('Mag', 'Dist', 'Lon', 'Lat', 'Eps', 'TRT')
base_header = ','.join(
'%s=%s' % (key, value) for key, value in metadata.items()
if value is not None and key not in skip_... |
def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):
"""
See :meth:`superclass method
<.base.GroundShakingIntensityModel.get_mean_and_stddevs>`
for spec of input and result values.
"""
# extracting dictionary of coefficients specific to required
#... |
def _interp_function(self, y_ip1, y_i, t_ip1, t_i, imt_per):
"""
Generic interpolation function used in equation 19 of 2013 report.
"""
return y_i + (y_ip1 - y_i) / (t_ip1 - t_i) * (imt_per - t_i) |
def _get_SRF_tau(self, imt_per):
"""
Table 6 and equation 19 of 2013 report.
"""
if imt_per < 1:
srf = 0.87
elif 1 <= imt_per < 5:
srf = self._interp_function(0.58, 0.87, 5, 1, imt_per)
elif 5 <= imt_per <= 10:
srf = 0.58
else:
... |
def _get_SRF_phi(self, imt_per):
"""
Table 7 and equation 19 of 2013 report. NB change in notation,
2013 report calls this term 'sigma' but it is referred to here
as phi.
"""
if imt_per < 0.6:
srf = 0.8
elif 0.6 <= imt_per < 1:
srf = self._... |
def _get_SRF_sigma(self, imt_per):
"""
Table 8 and equation 19 of 2013 report. NB change in notation,
2013 report calls this term 'sigma_t' but it is referred to
here as sigma. Note that Table 8 is identical to Table 7 in
the 2013 report.
"""
if imt_per < 0.6:
... |
def _get_dL2L(self, imt_per):
"""
Table 3 and equation 19 of 2013 report.
"""
if imt_per < 0.18:
dL2L = -0.06
elif 0.18 <= imt_per < 0.35:
dL2L = self._interp_function(0.12, -0.06, 0.35, 0.18, imt_per)
elif 0.35 <= imt_per <= 10:
dL2L =... |
def _get_dS2S(self, imt_per):
"""
Table 4 of 2013 report
"""
if imt_per == 0:
dS2S = 0.05
elif 0 < imt_per < 0.15:
dS2S = self._interp_function(-0.15, 0.05, 0.15, 0, imt_per)
elif 0.15 <= imt_per < 0.45:
dS2S = self._interp_function(0.4... |
def context(src):
"""
Used to add the source_id to the error message. To be used as
with context(src):
operation_with(src)
Typically the operation is filtering a source, that can fail for
tricky geometries.
"""
try:
yield
except Exception:
etype, err, tb = sys.e... |
def split_sources(srcs):
"""
:param srcs: sources
:returns: a pair (split sources, split time) or just the split_sources
"""
from openquake.hazardlib.source import splittable
sources = []
split_time = {} # src.id -> time
for src in srcs:
t0 = time.time()
mag_a, mag_b = s... |
def get_bounding_box(self, lon, lat, trt=None, mag=None):
"""
Build a bounding box around the given lon, lat by computing the
maximum_distance at the given tectonic region type and magnitude.
:param lon: longitude
:param lat: latitude
:param trt: tectonic region type, po... |
def get_affected_box(self, src):
"""
Get the enlarged bounding box of a source.
:param src: a source object
:returns: a bounding box (min_lon, min_lat, max_lon, max_lat)
"""
mag = src.get_min_max_mag()[1]
maxdist = self(src.tectonic_region_type, mag)
bbox... |
def sitecol(self):
"""
Read the site collection from .filename and cache it
"""
if 'sitecol' in vars(self):
return self.__dict__['sitecol']
if self.filename is None or not os.path.exists(self.filename):
# case of nofilter/None sitecol
return
... |
def get_rectangle(self, src):
"""
:param src: a source object
:returns: ((min_lon, min_lat), width, height), useful for plotting
"""
min_lon, min_lat, max_lon, max_lat = (
self.integration_distance.get_affected_box(src))
return (min_lon, min_lat), (max_lon - m... |
def get_bounding_boxes(self, trt=None, mag=None):
"""
:param trt: a tectonic region type (used for the integration distance)
:param mag: a magnitude (used for the integration distance)
:returns: a list of bounding boxes, one per site
"""
bbs = []
for site in self.... |
def close_sids(self, rec, trt, mag):
"""
:param rec:
a record with fields minlon, minlat, maxlon, maxlat
:param trt:
tectonic region type string
:param mag:
magnitude
:returns:
the site indices within the bounding box enlarged by the in... |
def filter(self, sources):
"""
:param sources: a sequence of sources
:yields: sources with .indices
"""
for src in sources:
if hasattr(src, 'indices'): # already filtered
yield src
continue
box = self.integration_distance.... |
def filter(self, sources):
"""
:param sources: a sequence of sources
:yields: rtree-filtered sources
"""
if self.sitecol is None: # do not filter
yield from sources
return
for src in sources:
box = self.integration_distance.get_affecte... |
def to_shapefile(output, input_nrml_file, validate):
"""
Convert a NRML source model file to ESRI Shapefile(s).
For each type of source geometry defined in the NRML file (point, area,
simple fault, complex fault, planar) a separate shapefile is created. Each
shapefile is differentiated by a specifi... |
def simple_fault_node(fault_trace, dip, upper_depth, lower_depth):
"""
:param fault_trace: an object with an attribute .points
:param dip: dip parameter
:param upper_depth: upper seismogenic depth
:param lower_depth: lower seismogenic depth
:returns: a Node of kind simpleFaultGeometry
"""
... |
def check_fault_data(cls, fault_trace, upper_seismogenic_depth,
lower_seismogenic_depth, dip, mesh_spacing):
"""
Verify the fault data and raise ``ValueError`` if anything is wrong.
This method doesn't have to be called by hands before creating the
surface objec... |
def from_fault_data(cls, fault_trace, upper_seismogenic_depth,
lower_seismogenic_depth, dip, mesh_spacing):
"""
Create and return a fault surface using fault source data.
:param openquake.hazardlib.geo.line.Line fault_trace:
Geographical line representing the... |
def get_fault_patch_vertices(cls, rupture_top_edge,
upper_seismogenic_depth,
lower_seismogenic_depth, dip, index_patch=1):
"""
Get surface main vertices.
Parameters are the same as for :meth:`from_fault_data`, excluding
fa... |
def hypocentre_patch_index(cls, hypocentre, rupture_top_edge,
upper_seismogenic_depth,
lower_seismogenic_depth, dip):
"""
This methods finds the index of the fault patch including
the hypocentre.
:param hypocentre:
... |
def get_surface_vertexes(cls, fault_trace,
upper_seismogenic_depth,
lower_seismogenic_depth, dip):
"""
Get surface main vertexes.
Parameters are the same as for :meth:`from_fault_data`, excluding
mesh spacing.
:returns:
... |
def surface_projection_from_fault_data(cls, fault_trace,
upper_seismogenic_depth,
lower_seismogenic_depth, dip):
"""
Get a surface projection of the simple fault surface.
Parameters are the same as for :meth:`... |
def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):
"""
See :meth:`superclass method
<.base.GroundShakingIntensityModel.get_mean_and_stddevs>`
for spec of input and result values.
"""
# extracting dictionary of coefficients specific to required
#... |
def _compute_distance_term(self, C, mag, rrup):
"""
Compute second and third terms in equation 1, p. 901.
"""
term1 = C['b'] * rrup
term2 = - np.log(rrup + C['c'] * np.exp(C['d'] * mag))
return term1 + term2 |
def _compute_focal_depth_term(self, C, hypo_depth):
"""
Compute fourth term in equation 1, p. 901.
"""
# p. 901. "(i.e, depth is capped at 125 km)".
focal_depth = hypo_depth
if focal_depth > 125.0:
focal_depth = 125.0
# p. 902. "We used the value of 1... |
def _compute_site_class_term(self, C, vs30):
"""
Compute nine-th term in equation 1, p. 901.
"""
# map vs30 value to site class, see table 2, p. 901.
site_term = np.zeros(len(vs30))
# hard rock
site_term[vs30 > 1100.0] = C['CH']
# rock
site_term[... |
def _compute_magnitude_squared_term(self, P, M, Q, W, mag):
"""
Compute magnitude squared term, equation 5, p. 909.
"""
return P * (mag - M) + Q * (mag - M) ** 2 + W |
def _compute_slab_correction_term(self, C, rrup):
"""
Compute path modification term for slab events, that is
the 8-th term in equation 1, p. 901.
"""
slab_term = C['SSL'] * np.log(rrup)
return slab_term |
def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):
"""
Using a minimum distance of 5km for the calculation.
"""
dists_mod = copy.deepcopy(dists)
dists_mod.rrup[dists.rrup <= 5.] = 5.
return super().get_mean_and_stddevs(
sites, rup, dists_m... |
def confirm(prompt):
"""
Ask for confirmation, given a ``prompt`` and return a boolean value.
"""
while True:
try:
answer = input(prompt)
except KeyboardInterrupt:
# the user presses ctrl+c, just say 'no'
return False
answer = answer.strip().lo... |
def build_asset_array(assets_by_site, tagnames=(), time_event=None):
"""
:param assets_by_site: a list of lists of assets
:param tagnames: a list of tag names
:returns: an array `assetcol`
"""
for assets in assets_by_site:
if len(assets):
first_asset = assets[0]
b... |
def _get_exposure(fname, stop=None):
"""
:param fname:
path of the XML file containing the exposure
:param stop:
node at which to stop parsing (or None)
:returns:
a pair (Exposure instance, list of asset nodes)
"""
[exposure] = nrml.read(fname, stop=stop)
if not expos... |
def get_units(self, loss_types):
"""
:param: a list of loss types
:returns: an array of units as byte strings, suitable for HDF5
"""
lst = []
for lt in loss_types:
if lt.endswith('_ins'):
lt = lt[:-4]
if lt == 'occupants':
... |
def value(self, loss_type, time_event=None):
"""
:returns: the total asset value for `loss_type`
"""
if loss_type == 'occupants':
return self.values['occupants_' + str(time_event)]
try: # extract from the cache
val = self._cost[loss_type]
except K... |
def deductible(self, loss_type, dummy=None):
"""
:returns: the deductible fraction of the asset cost for `loss_type`
"""
val = self.calc(loss_type, self.deductibles, self.area, self.number)
if self.calc.deduct_abs: # convert to relative value
return val / self.calc(l... |
def insurance_limit(self, loss_type, dummy=None):
"""
:returns: the limit fraction of the asset cost for `loss_type`
"""
val = self.calc(loss_type, self.insurance_limits, self.area,
self.number)
if self.calc.limit_abs: # convert to relative value
... |
def retrofitted(self):
"""
:returns: the asset retrofitted value
"""
return self.calc('structural', {'structural': self._retrofitted},
self.area, self.number) |
def tagmask(self, tags):
"""
:returns: a boolean array with True where the assets has tags
"""
mask = numpy.zeros(len(tags), bool)
for t, tag in enumerate(tags):
tagname, tagvalue = tag.split('=')
mask[t] = self.tagvalue(tagname) == tagvalue
return... |
def add(self, tagname, tagvalue):
"""
:returns: numeric index associated to the tag
"""
dic = getattr(self, tagname + '_idx')
try:
return dic[tagvalue]
except KeyError:
dic[tagvalue] = idx = len(dic)
getattr(self, tagname).append(tagval... |
def add_tags(self, dic, prefix):
"""
:param dic: a dictionary tagname -> tagvalue
:returns: a list of tag indices, one per tagname
"""
# fill missing tagvalues with "?", raise an error for unknown tagnames
idxs = []
for tagname in self.tagnames:
if tag... |
def get_tag(self, tagname, tagidx):
"""
:returns: the tag associated to the given tagname and tag index
"""
return '%s=%s' % (tagname, decode(getattr(self, tagname)[tagidx])) |
def get_tagvalues(self, tagnames, tagidxs):
"""
:returns: the tag associated to the given tagname and tag index
"""
values = tuple(getattr(self, tagname)[tagidx + 1]
for tagidx, tagname in zip(tagidxs, tagnames))
return values |
def gen_tags(self, tagname):
"""
:yields: the tags associated to the given tagname
"""
for tagvalue in getattr(self, tagname):
yield '%s=%s' % (tagname, decode(tagvalue)) |
def agg_shape(self, shp, aggregate_by):
"""
:returns: a shape shp + (T, ...) depending on the tagnames
"""
return shp + tuple(
len(getattr(self, tagname)) - 1 for tagname in aggregate_by) |
def num_taxonomies_by_site(self):
"""
:returns: an array with the number of assets per each site
"""
dic = general.group_array(self.array, 'site_id')
num_taxonomies = numpy.zeros(self.tot_sites, U32)
for sid, arr in dic.items():
num_taxonomies[sid] = len(numpy... |
def get_aids_by_tag(self):
"""
:returns: dict tag -> asset ordinals
"""
aids_by_tag = general.AccumDict(accum=set())
for aid, ass in enumerate(self):
for tagname in self.tagnames:
tag = self.tagcol.get_tag(tagname, ass[tagname])
aids_by... |
def assets_by_site(self):
"""
:returns: numpy array of lists with the assets by each site
"""
assets_by_site = [[] for sid in range(self.tot_sites)]
for i, ass in enumerate(self.array):
assets_by_site[ass['site_id']].append(self[i])
return numpy.array(assets_b... |
def aggregate_by(self, tagnames, array):
"""
:param tagnames: a list of valid tag names
:param array: an array with the same length as the asset collection
:returns: an array of aggregate values with the proper shape
"""
missing = set(tagnames) - set(self.tagcol.tagnames)... |
def agg_value(self, *tagnames):
"""
:param tagnames:
tagnames of lengths T1, T2, ... respectively
:returns:
the values of the exposure aggregated by tagnames as an array
of shape (T1, T2, ..., L)
"""
aval = numpy.zeros((len(self), len(self.loss... |
def reduce(self, sitecol):
"""
:returns: a reduced AssetCollection on the given sitecol
"""
ok_indices = numpy.sum(
[self.array['site_id'] == sid for sid in sitecol.sids],
axis=0, dtype=bool)
new = object.__new__(self.__class__)
vars(new).update(va... |
def reduce_also(self, sitecol):
"""
:returns: a reduced AssetCollection on the given sitecol
NB: diffently from .reduce, also the SiteCollection is reduced
and turned into a complete site collection.
"""
array = []
asset_refs = []
for idx, sid in enumerate... |
def read(fnames, calculation_mode='', region_constraint='',
ignore_missing_costs=(), asset_nodes=False, check_dupl=True,
tagcol=None, by_country=False):
"""
Call `Exposure.read(fname)` to get an :class:`Exposure` instance
keeping all the assets in memory or
`Exp... |
def _csv_header(self):
"""
Extract the expected CSV header from the exposure metadata
"""
fields = ['id', 'number', 'taxonomy', 'lon', 'lat']
for name in self.cost_types['name']:
fields.append(name)
if 'per_area' in self.cost_types['type']:
fields.... |
def _read_csv(self):
"""
:yields: asset nodes
"""
expected_header = self._csv_header()
for fname in self.datafiles:
with open(fname, encoding='utf-8') as f:
fields = next(csv.reader(f))
header = set(fields)
if len(header... |
def get_mesh_assets_by_site(self):
"""
:returns: (Mesh instance, assets_by_site list)
"""
assets_by_loc = general.groupby(self, key=lambda a: a.location)
mesh = geo.Mesh.from_coords(list(assets_by_loc))
assets_by_site = [
assets_by_loc[lonlat] for lonlat in zi... |
def get_risk_files(inputs):
"""
:param inputs: a dictionary key -> path name
:returns: a pair (file_type, {risk_type: path})
"""
rfs = {}
job_ini = inputs['job_ini']
for key in inputs:
if key == 'fragility':
# backward compatibily for .ini files with key fragility_file
... |
def build_vf_node(vf):
"""
Convert a VulnerabilityFunction object into a Node suitable
for XML conversion.
"""
nodes = [Node('imls', {'imt': vf.imt}, vf.imls),
Node('meanLRs', {}, vf.mean_loss_ratios),
Node('covLRs', {}, vf.covs)]
return Node(
'vulnerabilityFunc... |
def get_risk_models(oqparam, kind='vulnerability vulnerability_retrofitted '
'fragility consequence'):
"""
:param oqparam:
an OqParam instance
:param kind:
a space-separated string with the kinds of risk models to read
:returns:
a dictionary riskid -> loss_typ... |
def rescale(curves, values):
"""
Multiply the losses in each curve of kind (losses, poes) by the
corresponding value.
:param curves: an array of shape (A, 2, C)
:param values: an array of shape (A,)
"""
A, _, C = curves.shape
assert A == len(values), (A, len(values))
array = numpy.z... |
def get_riskmodel(taxonomy, oqparam, **extra):
"""
Return an instance of the correct riskmodel class, depending on the
attribute `calculation_mode` of the object `oqparam`.
:param taxonomy:
a taxonomy string
:param oqparam:
an object containing the parameters needed by the riskmodel... |
def get_loss_types(self, imt):
"""
:param imt: Intensity Measure Type string
:returns: loss types with risk functions of the given imt
"""
return [lt for lt in self.loss_types
if self.risk_functions[lt].imt == imt] |
def Beach(fm, linewidth=2, facecolor='b', bgcolor='w', edgecolor='k',
alpha=1.0, xy=(0, 0), width=200, size=100, nofill=False,
zorder=100, axes=None):
"""
Return a beach ball as a collection which can be connected to an
current matplotlib axes instance (ax.add_collection).
S1, D1, a... |
def Beachball(fm, linewidth=2, facecolor='b', bgcolor='w', edgecolor='k',
alpha=1.0, xy=(0, 0), width=200, size=100, nofill=False,
zorder=100, outfile=None, format=None, fig=None):
"""
Draws a beach ball diagram of an earthquake focal mechanism.
S1, D1, and R1, the strike, dip a... |
def plotMT(T, N, P, size=200, plot_zerotrace=True,
x0=0, y0=0, xy=(0, 0), width=200):
"""
Uses a principal axis T, N and P to draw a beach ball plot.
:param ax: axis object of a matplotlib figure
:param T: :class:`~PrincipalAxis`
:param N: :class:`~PrincipalAxis`
:param P: :class:`~P... |
def plotDC(np1, size=200, xy=(0, 0), width=200):
"""
Uses one nodal plane of a double couple to draw a beach ball plot.
:param ax: axis object of a matplotlib figure
:param np1: :class:`~NodalPlane`
Adapted from MATLAB script
`bb.m <http://www.ceri.memphis.edu/people/olboyd/Software/Software.h... |
def StrikeDip(n, e, u):
"""
Finds strike and dip of plane given normal vector having components n, e,
and u.
Adapted from MATLAB script
`bb.m <http://www.ceri.memphis.edu/people/olboyd/Software/Software.html>`_
written by Andy Michael and Oliver Boyd.
"""
r2d = 180 / np.pi
if u < 0:... |
def AuxPlane(s1, d1, r1):
"""
Get Strike and dip of second plane.
Adapted from MATLAB script
`bb.m <http://www.ceri.memphis.edu/people/olboyd/Software/Software.html>`_
written by Andy Michael and Oliver Boyd.
"""
r2d = 180 / np.pi
z = (s1 + 90) / r2d
z2 = d1 / r2d
z3 = r1 / r2d... |
def MT2Plane(mt):
"""
Calculates a nodal plane of a given moment tensor.
:param mt: :class:`~MomentTensor`
:return: :class:`~NodalPlane`
Adapted from MATLAB script
`bb.m <http://www.ceri.memphis.edu/people/olboyd/Software/Software.html>`_
written by Andy Michael and Oliver Boyd.
"""
... |
def TDL(AN, BN):
"""
Helper function for MT2Plane.
Adapted from MATLAB script
`bb.m <http://www.ceri.memphis.edu/people/olboyd/Software/Software.html>`_
written by Andy Michael and Oliver Boyd.
"""
XN = AN[0]
YN = AN[1]
ZN = AN[2]
XE = BN[0]
YE = BN[1]
ZE = BN[2]
AAA... |
def MT2Axes(mt):
"""
Calculates the principal axes of a given moment tensor.
:param mt: :class:`~MomentTensor`
:return: tuple of :class:`~PrincipalAxis` T, N and P
Adapted from ps_tensor / utilmeca.c /
`Generic Mapping Tools (GMT) <http://gmt.soest.hawaii.edu>`_.
"""
(D, V) = np.linalg... |
def calculate_taper_function(obs_threshold_moment, sel_threshold_moment,
corner_moment, beta):
'''
Calculates the tapering function of the tapered Gutenberg & Richter model:
as described in Bird & Liu (2007)::
taper_function = (M_0(M_T) / M_0(M_T^{CMT}))^-beta x exp((M_0(m... |
def tapered_gutenberg_richter_cdf(moment, moment_threshold, beta,
corner_moment):
'''
Tapered Gutenberg Richter Cumulative Density Function
:param float or numpy.ndarray moment:
Moment for calculation of rate
:param float or numpy.ndarray moment_threshold:
... |
def tapered_gutenberg_richter_pdf(moment, moment_threshold, beta,
corner_moment):
'''
Tapered Gutenberg-Richter Probability Density Function
:param float or numpy.ndarray moment:
Moment for calculation of rate
:param float or numpy.ndarray moment_threshold:
... |
def check_version(dstore):
"""
:param dstore: a DataStore instance
:returns:
a message if the stored version is different from the current version
"""
ds_version = dstore.hdf5.attrs['engine_version']
if ds_version != __version__:
return (': the datastore is at version %s, but the... |
def export_from_db(output_key, calc_id, datadir, target):
"""
:param output_key: a pair (ds_key, fmt)
:param calc_id: calculation ID
:param datadir: directory containing the datastore
:param target: directory, temporary when called from the engine server
:returns: the list of exported path names... |
def makedirs(path):
"""
Make all of the directories in the ``path`` using `os.makedirs`.
"""
if os.path.exists(path):
if not os.path.isdir(path):
# If it's not a directory, we can't do anything.
# This is a problem
raise RuntimeError('%s already exists and is ... |
def get_outkey(dskey, export_types):
"""
Extract the first pair (dskey, exptype) found in export
"""
for exptype in export_types:
if (dskey, exptype) in export:
return (dskey, exptype) |
def export_output(dskey, calc_id, datadir, target_dir, export_types):
"""
Simple UI wrapper around
:func:`openquake.engine.export.core.export_from_db` yielding
a summary of files exported, if any.
"""
outkey = get_outkey(dskey, export_types.split(','))
if export_types and not outkey:
... |
def _get_observed_mmax(catalogue, config):
'''Check see if observed mmax values are input, if not then take
from the catalogue'''
if config['input_mmax']:
obsmax = config['input_mmax']
if config['input_mmax_uncertainty']:
return config['input_mmax'], config['input_mmax_uncertaint... |
def _get_magnitude_vector_properties(catalogue, config):
'''If an input minimum magnitude is given then consider catalogue
only above the minimum magnitude - returns corresponding properties'''
mmin = config.get('input_mmin', np.min(catalogue['magnitude']))
neq = np.float(np.sum(catalogue['magnitude'] ... |
def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):
"""
See :meth:`superclass method
<.base.GroundShakingIntensityModel.get_mean_and_stddevs>`
for spec of input and result values.
"""
R = (dists.rrup)
M = rup.mag
# get constants
S... |
def get_fault_term(self, rake):
"""
Returns coefficient for faulting style (pg 156)
"""
rake = rake + 360 if rake < 0 else rake
if (rake >= 45) & (rake <= 135):
f = 1.
elif (rake >= 225) & (rake <= 315):
f = 0.5
else:
f = 0.
... |
def get_stddevs(self, mean, stddev_types):
"""
Returns the standard deviations from mean (pg 164; more robust than
estimate using magnitude)
"""
mean = np.exp(mean)
sigma = 0.39 + np.zeros(mean.shape)
sigma[mean < 0.068] = 0.55
idx = np.logical_and(mean >=... |
def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):
"""
See :meth:`superclass method
<.base.GroundShakingIntensityModel.get_mean_and_stddevs>`
for spec of input and result values.
"""
# extracting dictionary of coefficients
C = self.COEFFS[imt]
... |
def _get_stddevs(self, C, stddev_types, num_sites, mag):
"""
Returns standard deviation as defined in equation 23, page 2291
(Tavakoli and Pezeshk, 2005)
"""
stddevs = []
sigma = (C['c14'] + C['c15'] * mag) if mag < 7.2 else C['c16']
vals = sigma * np.ones((num_si... |
def _compute_magnitude_scaling_term(self, C, mag):
"""
Compute magnitude scaling term as defined in equation 19, page 2291
(Tavakoli and Pezeshk, 2005)
"""
assert mag <= 8.5
return C['c1'] + C['c2'] * mag + C['c3'] * (8.5 - mag) ** 2.5 |
def _compute_geometrical_spreading_term(self, C, rrup):
"""
Compute magnitude scaling term as defined in equation 19, page 2291
(Tavakoli and Pezeshk, 2005)
"""
f2 = np.ones_like(rrup)
idx1 = np.nonzero(rrup <= 70.)
idx2 = np.nonzero((rrup > 70.) & (rrup <= 130.))... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.