id
int32 0
252k
| repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
sequence | docstring
stringlengths 3
17.3k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 87
242
|
|---|---|---|---|---|---|---|---|---|---|---|---|
0 | gem/oq-engine | openquake/calculators/export/hazard.py | export_hmaps_csv | 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 comment: comment to use as header of the exported CSV file
"""
curves = util.compose_arrays(sitemesh, array)
writers.write_csv(dest, curves, comment=comment)
return [dest] | python | 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 comment: comment to use as header of the exported CSV file
"""
curves = util.compose_arrays(sitemesh, array)
writers.write_csv(dest, curves, comment=comment)
return [dest] | [
"def",
"export_hmaps_csv",
"(",
"key",
",",
"dest",
",",
"sitemesh",
",",
"array",
",",
"comment",
")",
":",
"curves",
"=",
"util",
".",
"compose_arrays",
"(",
"sitemesh",
",",
"array",
")",
"writers",
".",
"write_csv",
"(",
"dest",
",",
"curves",
",",
"comment",
"=",
"comment",
")",
"return",
"[",
"dest",
"]"
] | 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 comment: comment to use as header of the exported CSV file | [
"Export",
"the",
"hazard",
"maps",
"of",
"the",
"given",
"realization",
"into",
"CSV",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/export/hazard.py#L223-L235 |
1 | gem/oq-engine | openquake/calculators/export/hazard.py | export_hcurves_by_imt_csv | 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:`openquake.commonlib.source.RlzsAssoc` instance
:param fname: name of the exported file
:param sitecol: site collection
:param array: an array of shape (N, L) and dtype numpy.float32
:param oq: job.ini parameters
"""
nsites = len(sitecol)
fnames = []
for imt, imls in oq.imtls.items():
slc = oq.imtls(imt)
dest = add_imt(fname, imt)
lst = [('lon', F32), ('lat', F32), ('depth', F32)]
for iml in imls:
lst.append(('poe-%s' % iml, F32))
hcurves = numpy.zeros(nsites, lst)
for sid, lon, lat, dep in zip(
range(nsites), sitecol.lons, sitecol.lats, sitecol.depths):
hcurves[sid] = (lon, lat, dep) + tuple(array[sid, slc])
fnames.append(writers.write_csv(dest, hcurves, comment=_comment(
rlzs_assoc, kind, oq.investigation_time) + (
', imt="%s", checksum=%d' % (imt, checksum)
), header=[name for (name, dt) in lst]))
return fnames | python | 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:`openquake.commonlib.source.RlzsAssoc` instance
:param fname: name of the exported file
:param sitecol: site collection
:param array: an array of shape (N, L) and dtype numpy.float32
:param oq: job.ini parameters
"""
nsites = len(sitecol)
fnames = []
for imt, imls in oq.imtls.items():
slc = oq.imtls(imt)
dest = add_imt(fname, imt)
lst = [('lon', F32), ('lat', F32), ('depth', F32)]
for iml in imls:
lst.append(('poe-%s' % iml, F32))
hcurves = numpy.zeros(nsites, lst)
for sid, lon, lat, dep in zip(
range(nsites), sitecol.lons, sitecol.lats, sitecol.depths):
hcurves[sid] = (lon, lat, dep) + tuple(array[sid, slc])
fnames.append(writers.write_csv(dest, hcurves, comment=_comment(
rlzs_assoc, kind, oq.investigation_time) + (
', imt="%s", checksum=%d' % (imt, checksum)
), header=[name for (name, dt) in lst]))
return fnames | [
"def",
"export_hcurves_by_imt_csv",
"(",
"key",
",",
"kind",
",",
"rlzs_assoc",
",",
"fname",
",",
"sitecol",
",",
"array",
",",
"oq",
",",
"checksum",
")",
":",
"nsites",
"=",
"len",
"(",
"sitecol",
")",
"fnames",
"=",
"[",
"]",
"for",
"imt",
",",
"imls",
"in",
"oq",
".",
"imtls",
".",
"items",
"(",
")",
":",
"slc",
"=",
"oq",
".",
"imtls",
"(",
"imt",
")",
"dest",
"=",
"add_imt",
"(",
"fname",
",",
"imt",
")",
"lst",
"=",
"[",
"(",
"'lon'",
",",
"F32",
")",
",",
"(",
"'lat'",
",",
"F32",
")",
",",
"(",
"'depth'",
",",
"F32",
")",
"]",
"for",
"iml",
"in",
"imls",
":",
"lst",
".",
"append",
"(",
"(",
"'poe-%s'",
"%",
"iml",
",",
"F32",
")",
")",
"hcurves",
"=",
"numpy",
".",
"zeros",
"(",
"nsites",
",",
"lst",
")",
"for",
"sid",
",",
"lon",
",",
"lat",
",",
"dep",
"in",
"zip",
"(",
"range",
"(",
"nsites",
")",
",",
"sitecol",
".",
"lons",
",",
"sitecol",
".",
"lats",
",",
"sitecol",
".",
"depths",
")",
":",
"hcurves",
"[",
"sid",
"]",
"=",
"(",
"lon",
",",
"lat",
",",
"dep",
")",
"+",
"tuple",
"(",
"array",
"[",
"sid",
",",
"slc",
"]",
")",
"fnames",
".",
"append",
"(",
"writers",
".",
"write_csv",
"(",
"dest",
",",
"hcurves",
",",
"comment",
"=",
"_comment",
"(",
"rlzs_assoc",
",",
"kind",
",",
"oq",
".",
"investigation_time",
")",
"+",
"(",
"', imt=\"%s\", checksum=%d'",
"%",
"(",
"imt",
",",
"checksum",
")",
")",
",",
"header",
"=",
"[",
"name",
"for",
"(",
"name",
",",
"dt",
")",
"in",
"lst",
"]",
")",
")",
"return",
"fnames"
] | 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:`openquake.commonlib.source.RlzsAssoc` instance
:param fname: name of the exported file
:param sitecol: site collection
:param array: an array of shape (N, L) and dtype numpy.float32
:param oq: job.ini parameters | [
"Export",
"the",
"curves",
"of",
"the",
"given",
"realization",
"into",
"CSV",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/export/hazard.py#L248-L277 |
2 | gem/oq-engine | openquake/calculators/export/hazard.py | export_hcurves_csv | 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 = len(rlzs_assoc.realizations)
sitecol = dstore['sitecol']
sitemesh = get_mesh(sitecol)
key, kind, fmt = get_kkf(ekey)
fnames = []
checksum = dstore.get_attr('/', 'checksum32')
hmap_dt = oq.hmap_dt()
for kind in oq.get_kinds(kind, R):
fname = hazard_curve_name(dstore, (key, fmt), kind, rlzs_assoc)
comment = _comment(rlzs_assoc, kind, oq.investigation_time)
if (key in ('hmaps', 'uhs') and oq.uniform_hazard_spectra or
oq.hazard_maps):
hmap = extract(dstore, 'hmaps?kind=' + kind)[kind]
if key == 'uhs' and oq.poes and oq.uniform_hazard_spectra:
uhs_curves = calc.make_uhs(hmap, info)
writers.write_csv(
fname, util.compose_arrays(sitemesh, uhs_curves),
comment=comment + ', checksum=%d' % checksum)
fnames.append(fname)
elif key == 'hmaps' and oq.poes and oq.hazard_maps:
fnames.extend(
export_hmaps_csv(ekey, fname, sitemesh,
hmap.flatten().view(hmap_dt),
comment + ', checksum=%d' % checksum))
elif key == 'hcurves':
hcurves = extract(dstore, 'hcurves?kind=' + kind)[kind]
fnames.extend(
export_hcurves_by_imt_csv(
ekey, kind, rlzs_assoc, fname, sitecol, hcurves, oq,
checksum))
return sorted(fnames) | python | 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 = len(rlzs_assoc.realizations)
sitecol = dstore['sitecol']
sitemesh = get_mesh(sitecol)
key, kind, fmt = get_kkf(ekey)
fnames = []
checksum = dstore.get_attr('/', 'checksum32')
hmap_dt = oq.hmap_dt()
for kind in oq.get_kinds(kind, R):
fname = hazard_curve_name(dstore, (key, fmt), kind, rlzs_assoc)
comment = _comment(rlzs_assoc, kind, oq.investigation_time)
if (key in ('hmaps', 'uhs') and oq.uniform_hazard_spectra or
oq.hazard_maps):
hmap = extract(dstore, 'hmaps?kind=' + kind)[kind]
if key == 'uhs' and oq.poes and oq.uniform_hazard_spectra:
uhs_curves = calc.make_uhs(hmap, info)
writers.write_csv(
fname, util.compose_arrays(sitemesh, uhs_curves),
comment=comment + ', checksum=%d' % checksum)
fnames.append(fname)
elif key == 'hmaps' and oq.poes and oq.hazard_maps:
fnames.extend(
export_hmaps_csv(ekey, fname, sitemesh,
hmap.flatten().view(hmap_dt),
comment + ', checksum=%d' % checksum))
elif key == 'hcurves':
hcurves = extract(dstore, 'hcurves?kind=' + kind)[kind]
fnames.extend(
export_hcurves_by_imt_csv(
ekey, kind, rlzs_assoc, fname, sitecol, hcurves, oq,
checksum))
return sorted(fnames) | [
"def",
"export_hcurves_csv",
"(",
"ekey",
",",
"dstore",
")",
":",
"oq",
"=",
"dstore",
"[",
"'oqparam'",
"]",
"info",
"=",
"get_info",
"(",
"dstore",
")",
"rlzs_assoc",
"=",
"dstore",
"[",
"'csm_info'",
"]",
".",
"get_rlzs_assoc",
"(",
")",
"R",
"=",
"len",
"(",
"rlzs_assoc",
".",
"realizations",
")",
"sitecol",
"=",
"dstore",
"[",
"'sitecol'",
"]",
"sitemesh",
"=",
"get_mesh",
"(",
"sitecol",
")",
"key",
",",
"kind",
",",
"fmt",
"=",
"get_kkf",
"(",
"ekey",
")",
"fnames",
"=",
"[",
"]",
"checksum",
"=",
"dstore",
".",
"get_attr",
"(",
"'/'",
",",
"'checksum32'",
")",
"hmap_dt",
"=",
"oq",
".",
"hmap_dt",
"(",
")",
"for",
"kind",
"in",
"oq",
".",
"get_kinds",
"(",
"kind",
",",
"R",
")",
":",
"fname",
"=",
"hazard_curve_name",
"(",
"dstore",
",",
"(",
"key",
",",
"fmt",
")",
",",
"kind",
",",
"rlzs_assoc",
")",
"comment",
"=",
"_comment",
"(",
"rlzs_assoc",
",",
"kind",
",",
"oq",
".",
"investigation_time",
")",
"if",
"(",
"key",
"in",
"(",
"'hmaps'",
",",
"'uhs'",
")",
"and",
"oq",
".",
"uniform_hazard_spectra",
"or",
"oq",
".",
"hazard_maps",
")",
":",
"hmap",
"=",
"extract",
"(",
"dstore",
",",
"'hmaps?kind='",
"+",
"kind",
")",
"[",
"kind",
"]",
"if",
"key",
"==",
"'uhs'",
"and",
"oq",
".",
"poes",
"and",
"oq",
".",
"uniform_hazard_spectra",
":",
"uhs_curves",
"=",
"calc",
".",
"make_uhs",
"(",
"hmap",
",",
"info",
")",
"writers",
".",
"write_csv",
"(",
"fname",
",",
"util",
".",
"compose_arrays",
"(",
"sitemesh",
",",
"uhs_curves",
")",
",",
"comment",
"=",
"comment",
"+",
"', checksum=%d'",
"%",
"checksum",
")",
"fnames",
".",
"append",
"(",
"fname",
")",
"elif",
"key",
"==",
"'hmaps'",
"and",
"oq",
".",
"poes",
"and",
"oq",
".",
"hazard_maps",
":",
"fnames",
".",
"extend",
"(",
"export_hmaps_csv",
"(",
"ekey",
",",
"fname",
",",
"sitemesh",
",",
"hmap",
".",
"flatten",
"(",
")",
".",
"view",
"(",
"hmap_dt",
")",
",",
"comment",
"+",
"', checksum=%d'",
"%",
"checksum",
")",
")",
"elif",
"key",
"==",
"'hcurves'",
":",
"hcurves",
"=",
"extract",
"(",
"dstore",
",",
"'hcurves?kind='",
"+",
"kind",
")",
"[",
"kind",
"]",
"fnames",
".",
"extend",
"(",
"export_hcurves_by_imt_csv",
"(",
"ekey",
",",
"kind",
",",
"rlzs_assoc",
",",
"fname",
",",
"sitecol",
",",
"hcurves",
",",
"oq",
",",
"checksum",
")",
")",
"return",
"sorted",
"(",
"fnames",
")"
] | Exports the hazard curves into several .csv files
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object | [
"Exports",
"the",
"hazard",
"curves",
"into",
"several",
".",
"csv",
"files"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/export/hazard.py#L333-L373 |
3 | gem/oq-engine | openquake/calculators/export/hazard.py | save_disagg_to_csv | 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_keys)
for disag_tup, (poe, iml, matrix, fname) in matrices.items():
header = '%s,poe=%.7f,iml=%.7e\n' % (base_header, poe, iml)
if disag_tup == ('Mag', 'Lon', 'Lat'):
matrix = numpy.swapaxes(matrix, 0, 1)
matrix = numpy.swapaxes(matrix, 1, 2)
disag_tup = ('Lon', 'Lat', 'Mag')
axis = [metadata[v] for v in disag_tup]
header += ','.join(v for v in disag_tup)
header += ',poe'
# compute axis mid points
axis = [(ax[: -1] + ax[1:]) / 2. if ax.dtype == float
else ax for ax in axis]
values = None
if len(axis) == 1:
values = numpy.array([axis[0], matrix.flatten()]).T
else:
grids = numpy.meshgrid(*axis, indexing='ij')
values = [g.flatten() for g in grids]
values.append(matrix.flatten())
values = numpy.array(values).T
writers.write_csv(fname, values, comment=header, fmt='%.5E') | python | 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_keys)
for disag_tup, (poe, iml, matrix, fname) in matrices.items():
header = '%s,poe=%.7f,iml=%.7e\n' % (base_header, poe, iml)
if disag_tup == ('Mag', 'Lon', 'Lat'):
matrix = numpy.swapaxes(matrix, 0, 1)
matrix = numpy.swapaxes(matrix, 1, 2)
disag_tup = ('Lon', 'Lat', 'Mag')
axis = [metadata[v] for v in disag_tup]
header += ','.join(v for v in disag_tup)
header += ',poe'
# compute axis mid points
axis = [(ax[: -1] + ax[1:]) / 2. if ax.dtype == float
else ax for ax in axis]
values = None
if len(axis) == 1:
values = numpy.array([axis[0], matrix.flatten()]).T
else:
grids = numpy.meshgrid(*axis, indexing='ij')
values = [g.flatten() for g in grids]
values.append(matrix.flatten())
values = numpy.array(values).T
writers.write_csv(fname, values, comment=header, fmt='%.5E') | [
"def",
"save_disagg_to_csv",
"(",
"metadata",
",",
"matrices",
")",
":",
"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_keys",
")",
"for",
"disag_tup",
",",
"(",
"poe",
",",
"iml",
",",
"matrix",
",",
"fname",
")",
"in",
"matrices",
".",
"items",
"(",
")",
":",
"header",
"=",
"'%s,poe=%.7f,iml=%.7e\\n'",
"%",
"(",
"base_header",
",",
"poe",
",",
"iml",
")",
"if",
"disag_tup",
"==",
"(",
"'Mag'",
",",
"'Lon'",
",",
"'Lat'",
")",
":",
"matrix",
"=",
"numpy",
".",
"swapaxes",
"(",
"matrix",
",",
"0",
",",
"1",
")",
"matrix",
"=",
"numpy",
".",
"swapaxes",
"(",
"matrix",
",",
"1",
",",
"2",
")",
"disag_tup",
"=",
"(",
"'Lon'",
",",
"'Lat'",
",",
"'Mag'",
")",
"axis",
"=",
"[",
"metadata",
"[",
"v",
"]",
"for",
"v",
"in",
"disag_tup",
"]",
"header",
"+=",
"','",
".",
"join",
"(",
"v",
"for",
"v",
"in",
"disag_tup",
")",
"header",
"+=",
"',poe'",
"# compute axis mid points",
"axis",
"=",
"[",
"(",
"ax",
"[",
":",
"-",
"1",
"]",
"+",
"ax",
"[",
"1",
":",
"]",
")",
"/",
"2.",
"if",
"ax",
".",
"dtype",
"==",
"float",
"else",
"ax",
"for",
"ax",
"in",
"axis",
"]",
"values",
"=",
"None",
"if",
"len",
"(",
"axis",
")",
"==",
"1",
":",
"values",
"=",
"numpy",
".",
"array",
"(",
"[",
"axis",
"[",
"0",
"]",
",",
"matrix",
".",
"flatten",
"(",
")",
"]",
")",
".",
"T",
"else",
":",
"grids",
"=",
"numpy",
".",
"meshgrid",
"(",
"*",
"axis",
",",
"indexing",
"=",
"'ij'",
")",
"values",
"=",
"[",
"g",
".",
"flatten",
"(",
")",
"for",
"g",
"in",
"grids",
"]",
"values",
".",
"append",
"(",
"matrix",
".",
"flatten",
"(",
")",
")",
"values",
"=",
"numpy",
".",
"array",
"(",
"values",
")",
".",
"T",
"writers",
".",
"write_csv",
"(",
"fname",
",",
"values",
",",
"comment",
"=",
"header",
",",
"fmt",
"=",
"'%.5E'",
")"
] | Save disaggregation matrices to multiple .csv files. | [
"Save",
"disaggregation",
"matrices",
"to",
"multiple",
".",
"csv",
"files",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/export/hazard.py#L743-L776 |
4 | gem/oq-engine | openquake/hazardlib/gsim/bradley_2013b.py | Bradley2013bChchCBD._interp_function | 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) | python | 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",
"_interp_function",
"(",
"self",
",",
"y_ip1",
",",
"y_i",
",",
"t_ip1",
",",
"t_i",
",",
"imt_per",
")",
":",
"return",
"y_i",
"+",
"(",
"y_ip1",
"-",
"y_i",
")",
"/",
"(",
"t_ip1",
"-",
"t_i",
")",
"*",
"(",
"imt_per",
"-",
"t_i",
")"
] | Generic interpolation function used in equation 19 of 2013 report. | [
"Generic",
"interpolation",
"function",
"used",
"in",
"equation",
"19",
"of",
"2013",
"report",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/bradley_2013b.py#L154-L158 |
5 | gem/oq-engine | openquake/hazardlib/gsim/bradley_2013b.py | Bradley2013bChchCBD._get_SRF_tau | 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:
srf = 1
return srf | python | 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:
srf = 1
return srf | [
"def",
"_get_SRF_tau",
"(",
"self",
",",
"imt_per",
")",
":",
"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",
":",
"srf",
"=",
"1",
"return",
"srf"
] | Table 6 and equation 19 of 2013 report. | [
"Table",
"6",
"and",
"equation",
"19",
"of",
"2013",
"report",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/bradley_2013b.py#L160-L173 |
6 | gem/oq-engine | openquake/hazardlib/gsim/bradley_2013b.py | Bradley2013bChchCBD._get_SRF_phi | 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._interp_function(0.7, 0.8, 1, 0.6, imt_per)
elif 1 <= imt_per <= 10:
srf = self._interp_function(0.6, 0.7, 10, 1, imt_per)
else:
srf = 1
return srf | python | 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._interp_function(0.7, 0.8, 1, 0.6, imt_per)
elif 1 <= imt_per <= 10:
srf = self._interp_function(0.6, 0.7, 10, 1, imt_per)
else:
srf = 1
return srf | [
"def",
"_get_SRF_phi",
"(",
"self",
",",
"imt_per",
")",
":",
"if",
"imt_per",
"<",
"0.6",
":",
"srf",
"=",
"0.8",
"elif",
"0.6",
"<=",
"imt_per",
"<",
"1",
":",
"srf",
"=",
"self",
".",
"_interp_function",
"(",
"0.7",
",",
"0.8",
",",
"1",
",",
"0.6",
",",
"imt_per",
")",
"elif",
"1",
"<=",
"imt_per",
"<=",
"10",
":",
"srf",
"=",
"self",
".",
"_interp_function",
"(",
"0.6",
",",
"0.7",
",",
"10",
",",
"1",
",",
"imt_per",
")",
"else",
":",
"srf",
"=",
"1",
"return",
"srf"
] | 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. | [
"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",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/bradley_2013b.py#L175-L190 |
7 | gem/oq-engine | openquake/hazardlib/gsim/bradley_2013b.py | Bradley2013bChchCBD._get_SRF_sigma | 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:
srf = 0.8
elif 0.6 <= imt_per < 1:
srf = self._interp_function(0.7, 0.8, 1, 0.6, imt_per)
elif 1 <= imt_per <= 10:
srf = self._interp_function(0.6, 0.7, 10, 1, imt_per)
else:
srf = 1
return srf | python | 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:
srf = 0.8
elif 0.6 <= imt_per < 1:
srf = self._interp_function(0.7, 0.8, 1, 0.6, imt_per)
elif 1 <= imt_per <= 10:
srf = self._interp_function(0.6, 0.7, 10, 1, imt_per)
else:
srf = 1
return srf | [
"def",
"_get_SRF_sigma",
"(",
"self",
",",
"imt_per",
")",
":",
"if",
"imt_per",
"<",
"0.6",
":",
"srf",
"=",
"0.8",
"elif",
"0.6",
"<=",
"imt_per",
"<",
"1",
":",
"srf",
"=",
"self",
".",
"_interp_function",
"(",
"0.7",
",",
"0.8",
",",
"1",
",",
"0.6",
",",
"imt_per",
")",
"elif",
"1",
"<=",
"imt_per",
"<=",
"10",
":",
"srf",
"=",
"self",
".",
"_interp_function",
"(",
"0.6",
",",
"0.7",
",",
"10",
",",
"1",
",",
"imt_per",
")",
"else",
":",
"srf",
"=",
"1",
"return",
"srf"
] | 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. | [
"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",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/bradley_2013b.py#L192-L208 |
8 | gem/oq-engine | openquake/hazardlib/gsim/bradley_2013b.py | Bradley2013bChchCBD._get_dL2L | 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 = self._interp_function(0.65, 0.12, 10, 0.35, imt_per)
else:
dL2L = 0
return dL2L | python | 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 = self._interp_function(0.65, 0.12, 10, 0.35, imt_per)
else:
dL2L = 0
return dL2L | [
"def",
"_get_dL2L",
"(",
"self",
",",
"imt_per",
")",
":",
"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",
"=",
"self",
".",
"_interp_function",
"(",
"0.65",
",",
"0.12",
",",
"10",
",",
"0.35",
",",
"imt_per",
")",
"else",
":",
"dL2L",
"=",
"0",
"return",
"dL2L"
] | Table 3 and equation 19 of 2013 report. | [
"Table",
"3",
"and",
"equation",
"19",
"of",
"2013",
"report",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/bradley_2013b.py#L210-L223 |
9 | gem/oq-engine | openquake/hazardlib/gsim/bradley_2013b.py | Bradley2013bChchCBD._get_dS2S | 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, -0.15, 0.45, 0.15, imt_per)
elif 0.45 <= imt_per < 3.2:
dS2S = 0.4
elif 3.2 <= imt_per < 5:
dS2S = self._interp_function(0.08, 0.4, 5, 3.2, imt_per)
elif 5 <= imt_per <= 10:
dS2S = 0.08
else:
dS2S = 0
return dS2S | python | 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, -0.15, 0.45, 0.15, imt_per)
elif 0.45 <= imt_per < 3.2:
dS2S = 0.4
elif 3.2 <= imt_per < 5:
dS2S = self._interp_function(0.08, 0.4, 5, 3.2, imt_per)
elif 5 <= imt_per <= 10:
dS2S = 0.08
else:
dS2S = 0
return dS2S | [
"def",
"_get_dS2S",
"(",
"self",
",",
"imt_per",
")",
":",
"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",
",",
"-",
"0.15",
",",
"0.45",
",",
"0.15",
",",
"imt_per",
")",
"elif",
"0.45",
"<=",
"imt_per",
"<",
"3.2",
":",
"dS2S",
"=",
"0.4",
"elif",
"3.2",
"<=",
"imt_per",
"<",
"5",
":",
"dS2S",
"=",
"self",
".",
"_interp_function",
"(",
"0.08",
",",
"0.4",
",",
"5",
",",
"3.2",
",",
"imt_per",
")",
"elif",
"5",
"<=",
"imt_per",
"<=",
"10",
":",
"dS2S",
"=",
"0.08",
"else",
":",
"dS2S",
"=",
"0",
"return",
"dS2S"
] | Table 4 of 2013 report | [
"Table",
"4",
"of",
"2013",
"report"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/bradley_2013b.py#L225-L244 |
10 | gem/oq-engine | openquake/hazardlib/calc/filters.py | context | 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.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (src.source_id, err)
raise_(etype, msg, tb) | python | 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.exc_info()
msg = 'An error occurred with source id=%s. Error: %s'
msg %= (src.source_id, err)
raise_(etype, msg, tb) | [
"def",
"context",
"(",
"src",
")",
":",
"try",
":",
"yield",
"except",
"Exception",
":",
"etype",
",",
"err",
",",
"tb",
"=",
"sys",
".",
"exc_info",
"(",
")",
"msg",
"=",
"'An error occurred with source id=%s. Error: %s'",
"msg",
"%=",
"(",
"src",
".",
"source_id",
",",
"err",
")",
"raise_",
"(",
"etype",
",",
"msg",
",",
"tb",
")"
] | 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. | [
"Used",
"to",
"add",
"the",
"source_id",
"to",
"the",
"error",
"message",
".",
"To",
"be",
"used",
"as"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/calc/filters.py#L39-L55 |
11 | gem/oq-engine | openquake/hazardlib/calc/filters.py | IntegrationDistance.get_bounding_box | 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, possibly None
:param mag: magnitude, possibly None
:returns: min_lon, min_lat, max_lon, max_lat
"""
if trt is None: # take the greatest integration distance
maxdist = max(self(trt, mag) for trt in self.dic)
else: # get the integration distance for the given TRT
maxdist = self(trt, mag)
a1 = min(maxdist * KM_TO_DEGREES, 90)
a2 = min(angular_distance(maxdist, lat), 180)
return lon - a2, lat - a1, lon + a2, lat + a1 | python | 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, possibly None
:param mag: magnitude, possibly None
:returns: min_lon, min_lat, max_lon, max_lat
"""
if trt is None: # take the greatest integration distance
maxdist = max(self(trt, mag) for trt in self.dic)
else: # get the integration distance for the given TRT
maxdist = self(trt, mag)
a1 = min(maxdist * KM_TO_DEGREES, 90)
a2 = min(angular_distance(maxdist, lat), 180)
return lon - a2, lat - a1, lon + a2, lat + a1 | [
"def",
"get_bounding_box",
"(",
"self",
",",
"lon",
",",
"lat",
",",
"trt",
"=",
"None",
",",
"mag",
"=",
"None",
")",
":",
"if",
"trt",
"is",
"None",
":",
"# take the greatest integration distance",
"maxdist",
"=",
"max",
"(",
"self",
"(",
"trt",
",",
"mag",
")",
"for",
"trt",
"in",
"self",
".",
"dic",
")",
"else",
":",
"# get the integration distance for the given TRT",
"maxdist",
"=",
"self",
"(",
"trt",
",",
"mag",
")",
"a1",
"=",
"min",
"(",
"maxdist",
"*",
"KM_TO_DEGREES",
",",
"90",
")",
"a2",
"=",
"min",
"(",
"angular_distance",
"(",
"maxdist",
",",
"lat",
")",
",",
"180",
")",
"return",
"lon",
"-",
"a2",
",",
"lat",
"-",
"a1",
",",
"lon",
"+",
"a2",
",",
"lat",
"+",
"a1"
] | 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, possibly None
:param mag: magnitude, possibly None
:returns: min_lon, min_lat, max_lon, max_lat | [
"Build",
"a",
"bounding",
"box",
"around",
"the",
"given",
"lon",
"lat",
"by",
"computing",
"the",
"maximum_distance",
"at",
"the",
"given",
"tectonic",
"region",
"type",
"and",
"magnitude",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/calc/filters.py#L138-L155 |
12 | gem/oq-engine | openquake/hazardlib/calc/filters.py | IntegrationDistance.get_affected_box | 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 = get_bounding_box(src, maxdist)
return (fix_lon(bbox[0]), bbox[1], fix_lon(bbox[2]), bbox[3]) | python | 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 = get_bounding_box(src, maxdist)
return (fix_lon(bbox[0]), bbox[1], fix_lon(bbox[2]), bbox[3]) | [
"def",
"get_affected_box",
"(",
"self",
",",
"src",
")",
":",
"mag",
"=",
"src",
".",
"get_min_max_mag",
"(",
")",
"[",
"1",
"]",
"maxdist",
"=",
"self",
"(",
"src",
".",
"tectonic_region_type",
",",
"mag",
")",
"bbox",
"=",
"get_bounding_box",
"(",
"src",
",",
"maxdist",
")",
"return",
"(",
"fix_lon",
"(",
"bbox",
"[",
"0",
"]",
")",
",",
"bbox",
"[",
"1",
"]",
",",
"fix_lon",
"(",
"bbox",
"[",
"2",
"]",
")",
",",
"bbox",
"[",
"3",
"]",
")"
] | 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) | [
"Get",
"the",
"enlarged",
"bounding",
"box",
"of",
"a",
"source",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/calc/filters.py#L157-L167 |
13 | gem/oq-engine | openquake/hazardlib/calc/filters.py | SourceFilter.sitecol | 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
with hdf5.File(self.filename, 'r') as h5:
self.__dict__['sitecol'] = sc = h5.get('sitecol')
return sc | python | 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
with hdf5.File(self.filename, 'r') as h5:
self.__dict__['sitecol'] = sc = h5.get('sitecol')
return sc | [
"def",
"sitecol",
"(",
"self",
")",
":",
"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",
"with",
"hdf5",
".",
"File",
"(",
"self",
".",
"filename",
",",
"'r'",
")",
"as",
"h5",
":",
"self",
".",
"__dict__",
"[",
"'sitecol'",
"]",
"=",
"sc",
"=",
"h5",
".",
"get",
"(",
"'sitecol'",
")",
"return",
"sc"
] | Read the site collection from .filename and cache it | [
"Read",
"the",
"site",
"collection",
"from",
".",
"filename",
"and",
"cache",
"it"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/calc/filters.py#L276-L287 |
14 | gem/oq-engine | openquake/hazardlib/geo/surface/simple_fault.py | SimpleFaultSurface.hypocentre_patch_index | 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:
:class:`~openquake.hazardlib.geo.point.Point` object
representing the location of hypocentre.
:param rupture_top_edge:
A instances of :class:`openquake.hazardlib.geo.line.Line`
representing the rupture surface's top edge.
:param upper_seismo_depth:
Minimum depth ruptures can reach, in km (i.e. depth
to fault's top edge).
:param lower_seismo_depth:
Maximum depth ruptures can reach, in km (i.e. depth
to fault's bottom edge).
:param dip:
Dip angle (i.e. angle between fault surface
and earth surface), in degrees.
:return:
An integer corresponding to the index of the fault patch which
contains the hypocentre.
"""
totaln_patch = len(rupture_top_edge)
indexlist = []
dist_list = []
for i, index in enumerate(range(1, totaln_patch)):
p0, p1, p2, p3 = cls.get_fault_patch_vertices(
rupture_top_edge, upper_seismogenic_depth,
lower_seismogenic_depth, dip, index_patch=index)
[normal, dist_to_plane] = get_plane_equation(p0, p1, p2,
hypocentre)
indexlist.append(index)
dist_list.append(dist_to_plane)
if numpy.allclose(dist_to_plane, 0., atol=25., rtol=0.):
return index
break
index = indexlist[numpy.argmin(dist_list)]
return index | python | 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:
:class:`~openquake.hazardlib.geo.point.Point` object
representing the location of hypocentre.
:param rupture_top_edge:
A instances of :class:`openquake.hazardlib.geo.line.Line`
representing the rupture surface's top edge.
:param upper_seismo_depth:
Minimum depth ruptures can reach, in km (i.e. depth
to fault's top edge).
:param lower_seismo_depth:
Maximum depth ruptures can reach, in km (i.e. depth
to fault's bottom edge).
:param dip:
Dip angle (i.e. angle between fault surface
and earth surface), in degrees.
:return:
An integer corresponding to the index of the fault patch which
contains the hypocentre.
"""
totaln_patch = len(rupture_top_edge)
indexlist = []
dist_list = []
for i, index in enumerate(range(1, totaln_patch)):
p0, p1, p2, p3 = cls.get_fault_patch_vertices(
rupture_top_edge, upper_seismogenic_depth,
lower_seismogenic_depth, dip, index_patch=index)
[normal, dist_to_plane] = get_plane_equation(p0, p1, p2,
hypocentre)
indexlist.append(index)
dist_list.append(dist_to_plane)
if numpy.allclose(dist_to_plane, 0., atol=25., rtol=0.):
return index
break
index = indexlist[numpy.argmin(dist_list)]
return index | [
"def",
"hypocentre_patch_index",
"(",
"cls",
",",
"hypocentre",
",",
"rupture_top_edge",
",",
"upper_seismogenic_depth",
",",
"lower_seismogenic_depth",
",",
"dip",
")",
":",
"totaln_patch",
"=",
"len",
"(",
"rupture_top_edge",
")",
"indexlist",
"=",
"[",
"]",
"dist_list",
"=",
"[",
"]",
"for",
"i",
",",
"index",
"in",
"enumerate",
"(",
"range",
"(",
"1",
",",
"totaln_patch",
")",
")",
":",
"p0",
",",
"p1",
",",
"p2",
",",
"p3",
"=",
"cls",
".",
"get_fault_patch_vertices",
"(",
"rupture_top_edge",
",",
"upper_seismogenic_depth",
",",
"lower_seismogenic_depth",
",",
"dip",
",",
"index_patch",
"=",
"index",
")",
"[",
"normal",
",",
"dist_to_plane",
"]",
"=",
"get_plane_equation",
"(",
"p0",
",",
"p1",
",",
"p2",
",",
"hypocentre",
")",
"indexlist",
".",
"append",
"(",
"index",
")",
"dist_list",
".",
"append",
"(",
"dist_to_plane",
")",
"if",
"numpy",
".",
"allclose",
"(",
"dist_to_plane",
",",
"0.",
",",
"atol",
"=",
"25.",
",",
"rtol",
"=",
"0.",
")",
":",
"return",
"index",
"break",
"index",
"=",
"indexlist",
"[",
"numpy",
".",
"argmin",
"(",
"dist_list",
")",
"]",
"return",
"index"
] | This methods finds the index of the fault patch including
the hypocentre.
:param hypocentre:
:class:`~openquake.hazardlib.geo.point.Point` object
representing the location of hypocentre.
:param rupture_top_edge:
A instances of :class:`openquake.hazardlib.geo.line.Line`
representing the rupture surface's top edge.
:param upper_seismo_depth:
Minimum depth ruptures can reach, in km (i.e. depth
to fault's top edge).
:param lower_seismo_depth:
Maximum depth ruptures can reach, in km (i.e. depth
to fault's bottom edge).
:param dip:
Dip angle (i.e. angle between fault surface
and earth surface), in degrees.
:return:
An integer corresponding to the index of the fault patch which
contains the hypocentre. | [
"This",
"methods",
"finds",
"the",
"index",
"of",
"the",
"fault",
"patch",
"including",
"the",
"hypocentre",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/simple_fault.py#L256-L298 |
15 | gem/oq-engine | openquake/hazardlib/geo/surface/simple_fault.py | SimpleFaultSurface.get_surface_vertexes | 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:
Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon`
describing the surface projection of the simple fault with
specified parameters.
"""
# Similar to :meth:`from_fault_data`, we just don't resample edges
dip_tan = math.tan(math.radians(dip))
hdist_top = upper_seismogenic_depth / dip_tan
hdist_bottom = lower_seismogenic_depth / dip_tan
strike = fault_trace[0].azimuth(fault_trace[-1])
azimuth = (strike + 90.0) % 360
# Collect coordinates of vertices on the top and bottom edge
lons = []
lats = []
for point in fault_trace.points:
top_edge_point = point.point_at(hdist_top, 0, azimuth)
bottom_edge_point = point.point_at(hdist_bottom, 0, azimuth)
lons.append(top_edge_point.longitude)
lats.append(top_edge_point.latitude)
lons.append(bottom_edge_point.longitude)
lats.append(bottom_edge_point.latitude)
lons = numpy.array(lons, float)
lats = numpy.array(lats, float)
return lons, lats | python | 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:
Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon`
describing the surface projection of the simple fault with
specified parameters.
"""
# Similar to :meth:`from_fault_data`, we just don't resample edges
dip_tan = math.tan(math.radians(dip))
hdist_top = upper_seismogenic_depth / dip_tan
hdist_bottom = lower_seismogenic_depth / dip_tan
strike = fault_trace[0].azimuth(fault_trace[-1])
azimuth = (strike + 90.0) % 360
# Collect coordinates of vertices on the top and bottom edge
lons = []
lats = []
for point in fault_trace.points:
top_edge_point = point.point_at(hdist_top, 0, azimuth)
bottom_edge_point = point.point_at(hdist_bottom, 0, azimuth)
lons.append(top_edge_point.longitude)
lats.append(top_edge_point.latitude)
lons.append(bottom_edge_point.longitude)
lats.append(bottom_edge_point.latitude)
lons = numpy.array(lons, float)
lats = numpy.array(lats, float)
return lons, lats | [
"def",
"get_surface_vertexes",
"(",
"cls",
",",
"fault_trace",
",",
"upper_seismogenic_depth",
",",
"lower_seismogenic_depth",
",",
"dip",
")",
":",
"# Similar to :meth:`from_fault_data`, we just don't resample edges",
"dip_tan",
"=",
"math",
".",
"tan",
"(",
"math",
".",
"radians",
"(",
"dip",
")",
")",
"hdist_top",
"=",
"upper_seismogenic_depth",
"/",
"dip_tan",
"hdist_bottom",
"=",
"lower_seismogenic_depth",
"/",
"dip_tan",
"strike",
"=",
"fault_trace",
"[",
"0",
"]",
".",
"azimuth",
"(",
"fault_trace",
"[",
"-",
"1",
"]",
")",
"azimuth",
"=",
"(",
"strike",
"+",
"90.0",
")",
"%",
"360",
"# Collect coordinates of vertices on the top and bottom edge",
"lons",
"=",
"[",
"]",
"lats",
"=",
"[",
"]",
"for",
"point",
"in",
"fault_trace",
".",
"points",
":",
"top_edge_point",
"=",
"point",
".",
"point_at",
"(",
"hdist_top",
",",
"0",
",",
"azimuth",
")",
"bottom_edge_point",
"=",
"point",
".",
"point_at",
"(",
"hdist_bottom",
",",
"0",
",",
"azimuth",
")",
"lons",
".",
"append",
"(",
"top_edge_point",
".",
"longitude",
")",
"lats",
".",
"append",
"(",
"top_edge_point",
".",
"latitude",
")",
"lons",
".",
"append",
"(",
"bottom_edge_point",
".",
"longitude",
")",
"lats",
".",
"append",
"(",
"bottom_edge_point",
".",
"latitude",
")",
"lons",
"=",
"numpy",
".",
"array",
"(",
"lons",
",",
"float",
")",
"lats",
"=",
"numpy",
".",
"array",
"(",
"lats",
",",
"float",
")",
"return",
"lons",
",",
"lats"
] | Get surface main vertexes.
Parameters are the same as for :meth:`from_fault_data`, excluding
mesh spacing.
:returns:
Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon`
describing the surface projection of the simple fault with
specified parameters. | [
"Get",
"surface",
"main",
"vertexes",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/simple_fault.py#L301-L336 |
16 | gem/oq-engine | openquake/hazardlib/geo/surface/simple_fault.py | SimpleFaultSurface.surface_projection_from_fault_data | 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:`from_fault_data`, excluding
mesh spacing.
:returns:
Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon`
describing the surface projection of the simple fault with
specified parameters.
"""
lons, lats = cls.get_surface_vertexes(fault_trace,
upper_seismogenic_depth,
lower_seismogenic_depth, dip)
return Mesh(lons, lats, depths=None).get_convex_hull() | python | 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:`from_fault_data`, excluding
mesh spacing.
:returns:
Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon`
describing the surface projection of the simple fault with
specified parameters.
"""
lons, lats = cls.get_surface_vertexes(fault_trace,
upper_seismogenic_depth,
lower_seismogenic_depth, dip)
return Mesh(lons, lats, depths=None).get_convex_hull() | [
"def",
"surface_projection_from_fault_data",
"(",
"cls",
",",
"fault_trace",
",",
"upper_seismogenic_depth",
",",
"lower_seismogenic_depth",
",",
"dip",
")",
":",
"lons",
",",
"lats",
"=",
"cls",
".",
"get_surface_vertexes",
"(",
"fault_trace",
",",
"upper_seismogenic_depth",
",",
"lower_seismogenic_depth",
",",
"dip",
")",
"return",
"Mesh",
"(",
"lons",
",",
"lats",
",",
"depths",
"=",
"None",
")",
".",
"get_convex_hull",
"(",
")"
] | Get a surface projection of the simple fault surface.
Parameters are the same as for :meth:`from_fault_data`, excluding
mesh spacing.
:returns:
Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon`
describing the surface projection of the simple fault with
specified parameters. | [
"Get",
"a",
"surface",
"projection",
"of",
"the",
"simple",
"fault",
"surface",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/simple_fault.py#L339-L356 |
17 | gem/oq-engine | openquake/hazardlib/gsim/zhao_2006.py | ZhaoEtAl2006Asc._compute_distance_term | 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 | python | 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_distance_term",
"(",
"self",
",",
"C",
",",
"mag",
",",
"rrup",
")",
":",
"term1",
"=",
"C",
"[",
"'b'",
"]",
"*",
"rrup",
"term2",
"=",
"-",
"np",
".",
"log",
"(",
"rrup",
"+",
"C",
"[",
"'c'",
"]",
"*",
"np",
".",
"exp",
"(",
"C",
"[",
"'d'",
"]",
"*",
"mag",
")",
")",
"return",
"term1",
"+",
"term2"
] | Compute second and third terms in equation 1, p. 901. | [
"Compute",
"second",
"and",
"third",
"terms",
"in",
"equation",
"1",
"p",
".",
"901",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/zhao_2006.py#L133-L140 |
18 | gem/oq-engine | openquake/hazardlib/gsim/zhao_2006.py | ZhaoEtAl2006Asc._compute_focal_depth_term | 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 15 km for the
# depth coefficient hc ...".
hc = 15.0
# p. 901. "When h is larger than hc, the depth terms takes
# effect ...". The next sentence specifies h>=hc.
return float(focal_depth >= hc) * C['e'] * (focal_depth - hc) | python | 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 15 km for the
# depth coefficient hc ...".
hc = 15.0
# p. 901. "When h is larger than hc, the depth terms takes
# effect ...". The next sentence specifies h>=hc.
return float(focal_depth >= hc) * C['e'] * (focal_depth - hc) | [
"def",
"_compute_focal_depth_term",
"(",
"self",
",",
"C",
",",
"hypo_depth",
")",
":",
"# 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 15 km for the",
"# depth coefficient hc ...\".",
"hc",
"=",
"15.0",
"# p. 901. \"When h is larger than hc, the depth terms takes",
"# effect ...\". The next sentence specifies h>=hc.",
"return",
"float",
"(",
"focal_depth",
">=",
"hc",
")",
"*",
"C",
"[",
"'e'",
"]",
"*",
"(",
"focal_depth",
"-",
"hc",
")"
] | Compute fourth term in equation 1, p. 901. | [
"Compute",
"fourth",
"term",
"in",
"equation",
"1",
"p",
".",
"901",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/zhao_2006.py#L142-L157 |
19 | gem/oq-engine | openquake/hazardlib/gsim/zhao_2006.py | ZhaoEtAl2006Asc._compute_site_class_term | 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[(vs30 > 600) & (vs30 <= 1100)] = C['C1']
# hard soil
site_term[(vs30 > 300) & (vs30 <= 600)] = C['C2']
# medium soil
site_term[(vs30 > 200) & (vs30 <= 300)] = C['C3']
# soft soil
site_term[vs30 <= 200] = C['C4']
return site_term | python | 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[(vs30 > 600) & (vs30 <= 1100)] = C['C1']
# hard soil
site_term[(vs30 > 300) & (vs30 <= 600)] = C['C2']
# medium soil
site_term[(vs30 > 200) & (vs30 <= 300)] = C['C3']
# soft soil
site_term[vs30 <= 200] = C['C4']
return site_term | [
"def",
"_compute_site_class_term",
"(",
"self",
",",
"C",
",",
"vs30",
")",
":",
"# 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",
"[",
"(",
"vs30",
">",
"600",
")",
"&",
"(",
"vs30",
"<=",
"1100",
")",
"]",
"=",
"C",
"[",
"'C1'",
"]",
"# hard soil",
"site_term",
"[",
"(",
"vs30",
">",
"300",
")",
"&",
"(",
"vs30",
"<=",
"600",
")",
"]",
"=",
"C",
"[",
"'C2'",
"]",
"# medium soil",
"site_term",
"[",
"(",
"vs30",
">",
"200",
")",
"&",
"(",
"vs30",
"<=",
"300",
")",
"]",
"=",
"C",
"[",
"'C3'",
"]",
"# soft soil",
"site_term",
"[",
"vs30",
"<=",
"200",
"]",
"=",
"C",
"[",
"'C4'",
"]",
"return",
"site_term"
] | Compute nine-th term in equation 1, p. 901. | [
"Compute",
"nine",
"-",
"th",
"term",
"in",
"equation",
"1",
"p",
".",
"901",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/zhao_2006.py#L168-L190 |
20 | gem/oq-engine | openquake/hazardlib/gsim/zhao_2006.py | ZhaoEtAl2006Asc._compute_magnitude_squared_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 | python | 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_magnitude_squared_term",
"(",
"self",
",",
"P",
",",
"M",
",",
"Q",
",",
"W",
",",
"mag",
")",
":",
"return",
"P",
"*",
"(",
"mag",
"-",
"M",
")",
"+",
"Q",
"*",
"(",
"mag",
"-",
"M",
")",
"**",
"2",
"+",
"W"
] | Compute magnitude squared term, equation 5, p. 909. | [
"Compute",
"magnitude",
"squared",
"term",
"equation",
"5",
"p",
".",
"909",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/zhao_2006.py#L192-L196 |
21 | gem/oq-engine | openquake/hazardlib/gsim/zhao_2006.py | ZhaoEtAl2006SSlab._compute_slab_correction_term | 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 | python | 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",
"_compute_slab_correction_term",
"(",
"self",
",",
"C",
",",
"rrup",
")",
":",
"slab_term",
"=",
"C",
"[",
"'SSL'",
"]",
"*",
"np",
".",
"log",
"(",
"rrup",
")",
"return",
"slab_term"
] | Compute path modification term for slab events, that is
the 8-th term in equation 1, p. 901. | [
"Compute",
"path",
"modification",
"term",
"for",
"slab",
"events",
"that",
"is",
"the",
"8",
"-",
"th",
"term",
"in",
"equation",
"1",
"p",
".",
"901",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/zhao_2006.py#L369-L376 |
22 | gem/oq-engine | openquake/hazardlib/gsim/zhao_2006.py | ZhaoEtAl2006AscSGS.get_mean_and_stddevs | 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_mod, imt, stddev_types) | python | 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_mod, imt, stddev_types) | [
"def",
"get_mean_and_stddevs",
"(",
"self",
",",
"sites",
",",
"rup",
",",
"dists",
",",
"imt",
",",
"stddev_types",
")",
":",
"dists_mod",
"=",
"copy",
".",
"deepcopy",
"(",
"dists",
")",
"dists_mod",
".",
"rrup",
"[",
"dists",
".",
"rrup",
"<=",
"5.",
"]",
"=",
"5.",
"return",
"super",
"(",
")",
".",
"get_mean_and_stddevs",
"(",
"sites",
",",
"rup",
",",
"dists_mod",
",",
"imt",
",",
"stddev_types",
")"
] | Using a minimum distance of 5km for the calculation. | [
"Using",
"a",
"minimum",
"distance",
"of",
"5km",
"for",
"the",
"calculation",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/zhao_2006.py#L654-L663 |
23 | gem/oq-engine | openquake/engine/utils/__init__.py | confirm | 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().lower()
if answer not in ('y', 'n'):
print('Please enter y or n')
continue
return answer == 'y' | python | 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().lower()
if answer not in ('y', 'n'):
print('Please enter y or n')
continue
return answer == 'y' | [
"def",
"confirm",
"(",
"prompt",
")",
":",
"while",
"True",
":",
"try",
":",
"answer",
"=",
"input",
"(",
"prompt",
")",
"except",
"KeyboardInterrupt",
":",
"# the user presses ctrl+c, just say 'no'",
"return",
"False",
"answer",
"=",
"answer",
".",
"strip",
"(",
")",
".",
"lower",
"(",
")",
"if",
"answer",
"not",
"in",
"(",
"'y'",
",",
"'n'",
")",
":",
"print",
"(",
"'Please enter y or n'",
")",
"continue",
"return",
"answer",
"==",
"'y'"
] | Ask for confirmation, given a ``prompt`` and return a boolean value. | [
"Ask",
"for",
"confirmation",
"given",
"a",
"prompt",
"and",
"return",
"a",
"boolean",
"value",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/engine/utils/__init__.py#L20-L34 |
24 | gem/oq-engine | openquake/risklib/asset.py | Exposure._csv_header | 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.append('area')
if self.occupancy_periods:
fields.extend(self.occupancy_periods.split())
fields.extend(self.tagcol.tagnames)
return set(fields) | python | 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.append('area')
if self.occupancy_periods:
fields.extend(self.occupancy_periods.split())
fields.extend(self.tagcol.tagnames)
return set(fields) | [
"def",
"_csv_header",
"(",
"self",
")",
":",
"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",
".",
"append",
"(",
"'area'",
")",
"if",
"self",
".",
"occupancy_periods",
":",
"fields",
".",
"extend",
"(",
"self",
".",
"occupancy_periods",
".",
"split",
"(",
")",
")",
"fields",
".",
"extend",
"(",
"self",
".",
"tagcol",
".",
"tagnames",
")",
"return",
"set",
"(",
"fields",
")"
] | Extract the expected CSV header from the exposure metadata | [
"Extract",
"the",
"expected",
"CSV",
"header",
"from",
"the",
"exposure",
"metadata"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/asset.py#L885-L897 |
25 | gem/oq-engine | openquake/risklib/riskmodels.py | build_vf_node | 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(
'vulnerabilityFunction',
{'id': vf.id, 'dist': vf.distribution_name}, nodes=nodes) | python | 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(
'vulnerabilityFunction',
{'id': vf.id, 'dist': vf.distribution_name}, nodes=nodes) | [
"def",
"build_vf_node",
"(",
"vf",
")",
":",
"nodes",
"=",
"[",
"Node",
"(",
"'imls'",
",",
"{",
"'imt'",
":",
"vf",
".",
"imt",
"}",
",",
"vf",
".",
"imls",
")",
",",
"Node",
"(",
"'meanLRs'",
",",
"{",
"}",
",",
"vf",
".",
"mean_loss_ratios",
")",
",",
"Node",
"(",
"'covLRs'",
",",
"{",
"}",
",",
"vf",
".",
"covs",
")",
"]",
"return",
"Node",
"(",
"'vulnerabilityFunction'",
",",
"{",
"'id'",
":",
"vf",
".",
"id",
",",
"'dist'",
":",
"vf",
".",
"distribution_name",
"}",
",",
"nodes",
"=",
"nodes",
")"
] | Convert a VulnerabilityFunction object into a Node suitable
for XML conversion. | [
"Convert",
"a",
"VulnerabilityFunction",
"object",
"into",
"a",
"Node",
"suitable",
"for",
"XML",
"conversion",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/riskmodels.py#L69-L79 |
26 | gem/oq-engine | openquake/risklib/riskmodels.py | get_riskmodel | 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 class
:param extra:
extra parameters to pass to the riskmodel class
"""
riskmodel_class = registry[oqparam.calculation_mode]
# arguments needed to instantiate the riskmodel class
argnames = inspect.getfullargspec(riskmodel_class.__init__).args[3:]
# arguments extracted from oqparam
known_args = set(name for name, value in
inspect.getmembers(oqparam.__class__)
if isinstance(value, valid.Param))
all_args = {}
for argname in argnames:
if argname in known_args:
all_args[argname] = getattr(oqparam, argname)
if 'hazard_imtls' in argnames: # special case
all_args['hazard_imtls'] = oqparam.imtls
all_args.update(extra)
missing = set(argnames) - set(all_args)
if missing:
raise TypeError('Missing parameter: %s' % ', '.join(missing))
return riskmodel_class(taxonomy, **all_args) | python | 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 class
:param extra:
extra parameters to pass to the riskmodel class
"""
riskmodel_class = registry[oqparam.calculation_mode]
# arguments needed to instantiate the riskmodel class
argnames = inspect.getfullargspec(riskmodel_class.__init__).args[3:]
# arguments extracted from oqparam
known_args = set(name for name, value in
inspect.getmembers(oqparam.__class__)
if isinstance(value, valid.Param))
all_args = {}
for argname in argnames:
if argname in known_args:
all_args[argname] = getattr(oqparam, argname)
if 'hazard_imtls' in argnames: # special case
all_args['hazard_imtls'] = oqparam.imtls
all_args.update(extra)
missing = set(argnames) - set(all_args)
if missing:
raise TypeError('Missing parameter: %s' % ', '.join(missing))
return riskmodel_class(taxonomy, **all_args) | [
"def",
"get_riskmodel",
"(",
"taxonomy",
",",
"oqparam",
",",
"*",
"*",
"extra",
")",
":",
"riskmodel_class",
"=",
"registry",
"[",
"oqparam",
".",
"calculation_mode",
"]",
"# arguments needed to instantiate the riskmodel class",
"argnames",
"=",
"inspect",
".",
"getfullargspec",
"(",
"riskmodel_class",
".",
"__init__",
")",
".",
"args",
"[",
"3",
":",
"]",
"# arguments extracted from oqparam",
"known_args",
"=",
"set",
"(",
"name",
"for",
"name",
",",
"value",
"in",
"inspect",
".",
"getmembers",
"(",
"oqparam",
".",
"__class__",
")",
"if",
"isinstance",
"(",
"value",
",",
"valid",
".",
"Param",
")",
")",
"all_args",
"=",
"{",
"}",
"for",
"argname",
"in",
"argnames",
":",
"if",
"argname",
"in",
"known_args",
":",
"all_args",
"[",
"argname",
"]",
"=",
"getattr",
"(",
"oqparam",
",",
"argname",
")",
"if",
"'hazard_imtls'",
"in",
"argnames",
":",
"# special case",
"all_args",
"[",
"'hazard_imtls'",
"]",
"=",
"oqparam",
".",
"imtls",
"all_args",
".",
"update",
"(",
"extra",
")",
"missing",
"=",
"set",
"(",
"argnames",
")",
"-",
"set",
"(",
"all_args",
")",
"if",
"missing",
":",
"raise",
"TypeError",
"(",
"'Missing parameter: %s'",
"%",
"', '",
".",
"join",
"(",
"missing",
")",
")",
"return",
"riskmodel_class",
"(",
"taxonomy",
",",
"*",
"*",
"all_args",
")"
] | 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 class
:param extra:
extra parameters to pass to the riskmodel class | [
"Return",
"an",
"instance",
"of",
"the",
"correct",
"riskmodel",
"class",
"depending",
"on",
"the",
"attribute",
"calculation_mode",
"of",
"the",
"object",
"oqparam",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/riskmodels.py#L548-L580 |
27 | gem/oq-engine | openquake/hmtk/plotting/beachball.py | Beachball | 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 and rake of one of the focal planes, can
be vectors of multiple focal mechanisms.
:param fm: Focal mechanism that is either number of mechanisms (NM) by 3
(strike, dip, and rake) or NM x 6 (M11, M22, M33, M12, M13, M23 - the
six independent components of the moment tensor, where the coordinate
system is 1,2,3 = Up,South,East which equals r,theta,phi). The strike
is of the first plane, clockwise relative to north.
The dip is of the first plane, defined clockwise and perpendicular to
strike, relative to horizontal such that 0 is horizontal and 90 is
vertical. The rake is of the first focal plane solution. 90 moves the
hanging wall up-dip (thrust), 0 moves it in the strike direction
(left-lateral), -90 moves it down-dip (normal), and 180 moves it
opposite to strike (right-lateral).
:param facecolor: Color to use for quadrants of tension; can be a string,
e.g. ``'r'``, ``'b'`` or three component color vector, [R G B].
Defaults to ``'b'`` (blue).
:param bgcolor: The background color. Defaults to ``'w'`` (white).
:param edgecolor: Color of the edges. Defaults to ``'k'`` (black).
:param alpha: The alpha level of the beach ball. Defaults to ``1.0``
(opaque).
:param xy: Origin position of the beach ball as tuple. Defaults to
``(0, 0)``.
:type width: int
:param width: Symbol size of beach ball. Defaults to ``200``.
:param size: Controls the number of interpolation points for the
curves. Minimum is automatically set to ``100``.
:param nofill: Do not fill the beach ball, but only plot the planes.
:param zorder: Set zorder. Artists with lower zorder values are drawn
first.
:param outfile: Output file string. Also used to automatically
determine the output format. Supported file formats depend on your
matplotlib backend. Most backends support png, pdf, ps, eps and
svg. Defaults to ``None``.
:param format: Format of the graph picture. If no format is given the
outfile parameter will be used to try to automatically determine
the output format. If no format is found it defaults to png output.
If no outfile is specified but a format is, than a binary
imagestring will be returned.
Defaults to ``None``.
:param fig: Give an existing figure instance to plot into. New Figure if
set to ``None``.
"""
plot_width = width * 0.95
# plot the figure
if not fig:
fig = plt.figure(figsize=(3, 3), dpi=100)
fig.subplots_adjust(left=0, bottom=0, right=1, top=1)
fig.set_figheight(width // 100)
fig.set_figwidth(width // 100)
ax = fig.add_subplot(111, aspect='equal')
# hide axes + ticks
ax.axison = False
# plot the collection
collection = Beach(fm, linewidth=linewidth, facecolor=facecolor,
edgecolor=edgecolor, bgcolor=bgcolor,
alpha=alpha, nofill=nofill, xy=xy,
width=plot_width, size=size, zorder=zorder)
ax.add_collection(collection)
ax.autoscale_view(tight=False, scalex=True, scaley=True)
# export
if outfile:
if format:
fig.savefig(outfile, dpi=100, transparent=True, format=format)
else:
fig.savefig(outfile, dpi=100, transparent=True)
elif format and not outfile:
imgdata = compatibility.BytesIO()
fig.savefig(imgdata, format=format, dpi=100, transparent=True)
imgdata.seek(0)
return imgdata.read()
else:
plt.show()
return fig | python | 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 and rake of one of the focal planes, can
be vectors of multiple focal mechanisms.
:param fm: Focal mechanism that is either number of mechanisms (NM) by 3
(strike, dip, and rake) or NM x 6 (M11, M22, M33, M12, M13, M23 - the
six independent components of the moment tensor, where the coordinate
system is 1,2,3 = Up,South,East which equals r,theta,phi). The strike
is of the first plane, clockwise relative to north.
The dip is of the first plane, defined clockwise and perpendicular to
strike, relative to horizontal such that 0 is horizontal and 90 is
vertical. The rake is of the first focal plane solution. 90 moves the
hanging wall up-dip (thrust), 0 moves it in the strike direction
(left-lateral), -90 moves it down-dip (normal), and 180 moves it
opposite to strike (right-lateral).
:param facecolor: Color to use for quadrants of tension; can be a string,
e.g. ``'r'``, ``'b'`` or three component color vector, [R G B].
Defaults to ``'b'`` (blue).
:param bgcolor: The background color. Defaults to ``'w'`` (white).
:param edgecolor: Color of the edges. Defaults to ``'k'`` (black).
:param alpha: The alpha level of the beach ball. Defaults to ``1.0``
(opaque).
:param xy: Origin position of the beach ball as tuple. Defaults to
``(0, 0)``.
:type width: int
:param width: Symbol size of beach ball. Defaults to ``200``.
:param size: Controls the number of interpolation points for the
curves. Minimum is automatically set to ``100``.
:param nofill: Do not fill the beach ball, but only plot the planes.
:param zorder: Set zorder. Artists with lower zorder values are drawn
first.
:param outfile: Output file string. Also used to automatically
determine the output format. Supported file formats depend on your
matplotlib backend. Most backends support png, pdf, ps, eps and
svg. Defaults to ``None``.
:param format: Format of the graph picture. If no format is given the
outfile parameter will be used to try to automatically determine
the output format. If no format is found it defaults to png output.
If no outfile is specified but a format is, than a binary
imagestring will be returned.
Defaults to ``None``.
:param fig: Give an existing figure instance to plot into. New Figure if
set to ``None``.
"""
plot_width = width * 0.95
# plot the figure
if not fig:
fig = plt.figure(figsize=(3, 3), dpi=100)
fig.subplots_adjust(left=0, bottom=0, right=1, top=1)
fig.set_figheight(width // 100)
fig.set_figwidth(width // 100)
ax = fig.add_subplot(111, aspect='equal')
# hide axes + ticks
ax.axison = False
# plot the collection
collection = Beach(fm, linewidth=linewidth, facecolor=facecolor,
edgecolor=edgecolor, bgcolor=bgcolor,
alpha=alpha, nofill=nofill, xy=xy,
width=plot_width, size=size, zorder=zorder)
ax.add_collection(collection)
ax.autoscale_view(tight=False, scalex=True, scaley=True)
# export
if outfile:
if format:
fig.savefig(outfile, dpi=100, transparent=True, format=format)
else:
fig.savefig(outfile, dpi=100, transparent=True)
elif format and not outfile:
imgdata = compatibility.BytesIO()
fig.savefig(imgdata, format=format, dpi=100, transparent=True)
imgdata.seek(0)
return imgdata.read()
else:
plt.show()
return fig | [
"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",
")",
":",
"plot_width",
"=",
"width",
"*",
"0.95",
"# plot the figure",
"if",
"not",
"fig",
":",
"fig",
"=",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"3",
",",
"3",
")",
",",
"dpi",
"=",
"100",
")",
"fig",
".",
"subplots_adjust",
"(",
"left",
"=",
"0",
",",
"bottom",
"=",
"0",
",",
"right",
"=",
"1",
",",
"top",
"=",
"1",
")",
"fig",
".",
"set_figheight",
"(",
"width",
"//",
"100",
")",
"fig",
".",
"set_figwidth",
"(",
"width",
"//",
"100",
")",
"ax",
"=",
"fig",
".",
"add_subplot",
"(",
"111",
",",
"aspect",
"=",
"'equal'",
")",
"# hide axes + ticks",
"ax",
".",
"axison",
"=",
"False",
"# plot the collection",
"collection",
"=",
"Beach",
"(",
"fm",
",",
"linewidth",
"=",
"linewidth",
",",
"facecolor",
"=",
"facecolor",
",",
"edgecolor",
"=",
"edgecolor",
",",
"bgcolor",
"=",
"bgcolor",
",",
"alpha",
"=",
"alpha",
",",
"nofill",
"=",
"nofill",
",",
"xy",
"=",
"xy",
",",
"width",
"=",
"plot_width",
",",
"size",
"=",
"size",
",",
"zorder",
"=",
"zorder",
")",
"ax",
".",
"add_collection",
"(",
"collection",
")",
"ax",
".",
"autoscale_view",
"(",
"tight",
"=",
"False",
",",
"scalex",
"=",
"True",
",",
"scaley",
"=",
"True",
")",
"# export",
"if",
"outfile",
":",
"if",
"format",
":",
"fig",
".",
"savefig",
"(",
"outfile",
",",
"dpi",
"=",
"100",
",",
"transparent",
"=",
"True",
",",
"format",
"=",
"format",
")",
"else",
":",
"fig",
".",
"savefig",
"(",
"outfile",
",",
"dpi",
"=",
"100",
",",
"transparent",
"=",
"True",
")",
"elif",
"format",
"and",
"not",
"outfile",
":",
"imgdata",
"=",
"compatibility",
".",
"BytesIO",
"(",
")",
"fig",
".",
"savefig",
"(",
"imgdata",
",",
"format",
"=",
"format",
",",
"dpi",
"=",
"100",
",",
"transparent",
"=",
"True",
")",
"imgdata",
".",
"seek",
"(",
"0",
")",
"return",
"imgdata",
".",
"read",
"(",
")",
"else",
":",
"plt",
".",
"show",
"(",
")",
"return",
"fig"
] | Draws a beach ball diagram of an earthquake focal mechanism.
S1, D1, and R1, the strike, dip and rake of one of the focal planes, can
be vectors of multiple focal mechanisms.
:param fm: Focal mechanism that is either number of mechanisms (NM) by 3
(strike, dip, and rake) or NM x 6 (M11, M22, M33, M12, M13, M23 - the
six independent components of the moment tensor, where the coordinate
system is 1,2,3 = Up,South,East which equals r,theta,phi). The strike
is of the first plane, clockwise relative to north.
The dip is of the first plane, defined clockwise and perpendicular to
strike, relative to horizontal such that 0 is horizontal and 90 is
vertical. The rake is of the first focal plane solution. 90 moves the
hanging wall up-dip (thrust), 0 moves it in the strike direction
(left-lateral), -90 moves it down-dip (normal), and 180 moves it
opposite to strike (right-lateral).
:param facecolor: Color to use for quadrants of tension; can be a string,
e.g. ``'r'``, ``'b'`` or three component color vector, [R G B].
Defaults to ``'b'`` (blue).
:param bgcolor: The background color. Defaults to ``'w'`` (white).
:param edgecolor: Color of the edges. Defaults to ``'k'`` (black).
:param alpha: The alpha level of the beach ball. Defaults to ``1.0``
(opaque).
:param xy: Origin position of the beach ball as tuple. Defaults to
``(0, 0)``.
:type width: int
:param width: Symbol size of beach ball. Defaults to ``200``.
:param size: Controls the number of interpolation points for the
curves. Minimum is automatically set to ``100``.
:param nofill: Do not fill the beach ball, but only plot the planes.
:param zorder: Set zorder. Artists with lower zorder values are drawn
first.
:param outfile: Output file string. Also used to automatically
determine the output format. Supported file formats depend on your
matplotlib backend. Most backends support png, pdf, ps, eps and
svg. Defaults to ``None``.
:param format: Format of the graph picture. If no format is given the
outfile parameter will be used to try to automatically determine
the output format. If no format is found it defaults to png output.
If no outfile is specified but a format is, than a binary
imagestring will be returned.
Defaults to ``None``.
:param fig: Give an existing figure instance to plot into. New Figure if
set to ``None``. | [
"Draws",
"a",
"beach",
"ball",
"diagram",
"of",
"an",
"earthquake",
"focal",
"mechanism",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/plotting/beachball.py#L147-L230 |
28 | gem/oq-engine | openquake/hmtk/plotting/beachball.py | StrikeDip | 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:
n = -n
e = -e
u = -u
strike = np.arctan2(e, n) * r2d
strike = strike - 90
while strike >= 360:
strike = strike - 360
while strike < 0:
strike = strike + 360
x = np.sqrt(np.power(n, 2) + np.power(e, 2))
dip = np.arctan2(x, u) * r2d
return (strike, dip) | python | 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:
n = -n
e = -e
u = -u
strike = np.arctan2(e, n) * r2d
strike = strike - 90
while strike >= 360:
strike = strike - 360
while strike < 0:
strike = strike + 360
x = np.sqrt(np.power(n, 2) + np.power(e, 2))
dip = np.arctan2(x, u) * r2d
return (strike, dip) | [
"def",
"StrikeDip",
"(",
"n",
",",
"e",
",",
"u",
")",
":",
"r2d",
"=",
"180",
"/",
"np",
".",
"pi",
"if",
"u",
"<",
"0",
":",
"n",
"=",
"-",
"n",
"e",
"=",
"-",
"e",
"u",
"=",
"-",
"u",
"strike",
"=",
"np",
".",
"arctan2",
"(",
"e",
",",
"n",
")",
"*",
"r2d",
"strike",
"=",
"strike",
"-",
"90",
"while",
"strike",
">=",
"360",
":",
"strike",
"=",
"strike",
"-",
"360",
"while",
"strike",
"<",
"0",
":",
"strike",
"=",
"strike",
"+",
"360",
"x",
"=",
"np",
".",
"sqrt",
"(",
"np",
".",
"power",
"(",
"n",
",",
"2",
")",
"+",
"np",
".",
"power",
"(",
"e",
",",
"2",
")",
")",
"dip",
"=",
"np",
".",
"arctan2",
"(",
"x",
",",
"u",
")",
"*",
"r2d",
"return",
"(",
"strike",
",",
"dip",
")"
] | 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. | [
"Finds",
"strike",
"and",
"dip",
"of",
"plane",
"given",
"normal",
"vector",
"having",
"components",
"n",
"e",
"and",
"u",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/plotting/beachball.py#L669-L692 |
29 | gem/oq-engine | openquake/hmtk/plotting/beachball.py | AuxPlane | 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
# slick vector in plane 1
sl1 = -np.cos(z3) * np.cos(z) - np.sin(z3) * np.sin(z) * np.cos(z2)
sl2 = np.cos(z3) * np.sin(z) - np.sin(z3) * np.cos(z) * np.cos(z2)
sl3 = np.sin(z3) * np.sin(z2)
(strike, dip) = StrikeDip(sl2, sl1, sl3)
n1 = np.sin(z) * np.sin(z2) # normal vector to plane 1
n2 = np.cos(z) * np.sin(z2)
h1 = -sl2 # strike vector of plane 2
h2 = sl1
# note h3=0 always so we leave it out
# n3 = np.cos(z2)
z = h1 * n1 + h2 * n2
z = z / np.sqrt(h1 * h1 + h2 * h2)
z = np.arccos(z)
rake = 0
if sl3 > 0:
rake = z * r2d
if sl3 <= 0:
rake = -z * r2d
return (strike, dip, rake) | python | 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
# slick vector in plane 1
sl1 = -np.cos(z3) * np.cos(z) - np.sin(z3) * np.sin(z) * np.cos(z2)
sl2 = np.cos(z3) * np.sin(z) - np.sin(z3) * np.cos(z) * np.cos(z2)
sl3 = np.sin(z3) * np.sin(z2)
(strike, dip) = StrikeDip(sl2, sl1, sl3)
n1 = np.sin(z) * np.sin(z2) # normal vector to plane 1
n2 = np.cos(z) * np.sin(z2)
h1 = -sl2 # strike vector of plane 2
h2 = sl1
# note h3=0 always so we leave it out
# n3 = np.cos(z2)
z = h1 * n1 + h2 * n2
z = z / np.sqrt(h1 * h1 + h2 * h2)
z = np.arccos(z)
rake = 0
if sl3 > 0:
rake = z * r2d
if sl3 <= 0:
rake = -z * r2d
return (strike, dip, rake) | [
"def",
"AuxPlane",
"(",
"s1",
",",
"d1",
",",
"r1",
")",
":",
"r2d",
"=",
"180",
"/",
"np",
".",
"pi",
"z",
"=",
"(",
"s1",
"+",
"90",
")",
"/",
"r2d",
"z2",
"=",
"d1",
"/",
"r2d",
"z3",
"=",
"r1",
"/",
"r2d",
"# slick vector in plane 1",
"sl1",
"=",
"-",
"np",
".",
"cos",
"(",
"z3",
")",
"*",
"np",
".",
"cos",
"(",
"z",
")",
"-",
"np",
".",
"sin",
"(",
"z3",
")",
"*",
"np",
".",
"sin",
"(",
"z",
")",
"*",
"np",
".",
"cos",
"(",
"z2",
")",
"sl2",
"=",
"np",
".",
"cos",
"(",
"z3",
")",
"*",
"np",
".",
"sin",
"(",
"z",
")",
"-",
"np",
".",
"sin",
"(",
"z3",
")",
"*",
"np",
".",
"cos",
"(",
"z",
")",
"*",
"np",
".",
"cos",
"(",
"z2",
")",
"sl3",
"=",
"np",
".",
"sin",
"(",
"z3",
")",
"*",
"np",
".",
"sin",
"(",
"z2",
")",
"(",
"strike",
",",
"dip",
")",
"=",
"StrikeDip",
"(",
"sl2",
",",
"sl1",
",",
"sl3",
")",
"n1",
"=",
"np",
".",
"sin",
"(",
"z",
")",
"*",
"np",
".",
"sin",
"(",
"z2",
")",
"# normal vector to plane 1",
"n2",
"=",
"np",
".",
"cos",
"(",
"z",
")",
"*",
"np",
".",
"sin",
"(",
"z2",
")",
"h1",
"=",
"-",
"sl2",
"# strike vector of plane 2",
"h2",
"=",
"sl1",
"# note h3=0 always so we leave it out",
"# n3 = np.cos(z2)",
"z",
"=",
"h1",
"*",
"n1",
"+",
"h2",
"*",
"n2",
"z",
"=",
"z",
"/",
"np",
".",
"sqrt",
"(",
"h1",
"*",
"h1",
"+",
"h2",
"*",
"h2",
")",
"z",
"=",
"np",
".",
"arccos",
"(",
"z",
")",
"rake",
"=",
"0",
"if",
"sl3",
">",
"0",
":",
"rake",
"=",
"z",
"*",
"r2d",
"if",
"sl3",
"<=",
"0",
":",
"rake",
"=",
"-",
"z",
"*",
"r2d",
"return",
"(",
"strike",
",",
"dip",
",",
"rake",
")"
] | 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. | [
"Get",
"Strike",
"and",
"dip",
"of",
"second",
"plane",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/plotting/beachball.py#L695-L729 |
30 | gem/oq-engine | openquake/hmtk/plotting/beachball.py | MT2Plane | 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.
"""
(d, v) = np.linalg.eig(mt.mt)
D = np.array([d[1], d[0], d[2]])
V = np.array([[v[1, 1], -v[1, 0], -v[1, 2]],
[v[2, 1], -v[2, 0], -v[2, 2]],
[-v[0, 1], v[0, 0], v[0, 2]]])
IMAX = D.argmax()
IMIN = D.argmin()
AE = (V[:, IMAX] + V[:, IMIN]) / np.sqrt(2.0)
AN = (V[:, IMAX] - V[:, IMIN]) / np.sqrt(2.0)
AER = np.sqrt(np.power(AE[0], 2) + np.power(AE[1], 2) + np.power(AE[2], 2))
ANR = np.sqrt(np.power(AN[0], 2) + np.power(AN[1], 2) + np.power(AN[2], 2))
AE = AE / AER
if not ANR:
AN = np.array([np.nan, np.nan, np.nan])
else:
AN = AN / ANR
if AN[2] <= 0.:
AN1 = AN
AE1 = AE
else:
AN1 = -AN
AE1 = -AE
(ft, fd, fl) = TDL(AN1, AE1)
return NodalPlane(360 - ft, fd, 180 - fl) | python | 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.
"""
(d, v) = np.linalg.eig(mt.mt)
D = np.array([d[1], d[0], d[2]])
V = np.array([[v[1, 1], -v[1, 0], -v[1, 2]],
[v[2, 1], -v[2, 0], -v[2, 2]],
[-v[0, 1], v[0, 0], v[0, 2]]])
IMAX = D.argmax()
IMIN = D.argmin()
AE = (V[:, IMAX] + V[:, IMIN]) / np.sqrt(2.0)
AN = (V[:, IMAX] - V[:, IMIN]) / np.sqrt(2.0)
AER = np.sqrt(np.power(AE[0], 2) + np.power(AE[1], 2) + np.power(AE[2], 2))
ANR = np.sqrt(np.power(AN[0], 2) + np.power(AN[1], 2) + np.power(AN[2], 2))
AE = AE / AER
if not ANR:
AN = np.array([np.nan, np.nan, np.nan])
else:
AN = AN / ANR
if AN[2] <= 0.:
AN1 = AN
AE1 = AE
else:
AN1 = -AN
AE1 = -AE
(ft, fd, fl) = TDL(AN1, AE1)
return NodalPlane(360 - ft, fd, 180 - fl) | [
"def",
"MT2Plane",
"(",
"mt",
")",
":",
"(",
"d",
",",
"v",
")",
"=",
"np",
".",
"linalg",
".",
"eig",
"(",
"mt",
".",
"mt",
")",
"D",
"=",
"np",
".",
"array",
"(",
"[",
"d",
"[",
"1",
"]",
",",
"d",
"[",
"0",
"]",
",",
"d",
"[",
"2",
"]",
"]",
")",
"V",
"=",
"np",
".",
"array",
"(",
"[",
"[",
"v",
"[",
"1",
",",
"1",
"]",
",",
"-",
"v",
"[",
"1",
",",
"0",
"]",
",",
"-",
"v",
"[",
"1",
",",
"2",
"]",
"]",
",",
"[",
"v",
"[",
"2",
",",
"1",
"]",
",",
"-",
"v",
"[",
"2",
",",
"0",
"]",
",",
"-",
"v",
"[",
"2",
",",
"2",
"]",
"]",
",",
"[",
"-",
"v",
"[",
"0",
",",
"1",
"]",
",",
"v",
"[",
"0",
",",
"0",
"]",
",",
"v",
"[",
"0",
",",
"2",
"]",
"]",
"]",
")",
"IMAX",
"=",
"D",
".",
"argmax",
"(",
")",
"IMIN",
"=",
"D",
".",
"argmin",
"(",
")",
"AE",
"=",
"(",
"V",
"[",
":",
",",
"IMAX",
"]",
"+",
"V",
"[",
":",
",",
"IMIN",
"]",
")",
"/",
"np",
".",
"sqrt",
"(",
"2.0",
")",
"AN",
"=",
"(",
"V",
"[",
":",
",",
"IMAX",
"]",
"-",
"V",
"[",
":",
",",
"IMIN",
"]",
")",
"/",
"np",
".",
"sqrt",
"(",
"2.0",
")",
"AER",
"=",
"np",
".",
"sqrt",
"(",
"np",
".",
"power",
"(",
"AE",
"[",
"0",
"]",
",",
"2",
")",
"+",
"np",
".",
"power",
"(",
"AE",
"[",
"1",
"]",
",",
"2",
")",
"+",
"np",
".",
"power",
"(",
"AE",
"[",
"2",
"]",
",",
"2",
")",
")",
"ANR",
"=",
"np",
".",
"sqrt",
"(",
"np",
".",
"power",
"(",
"AN",
"[",
"0",
"]",
",",
"2",
")",
"+",
"np",
".",
"power",
"(",
"AN",
"[",
"1",
"]",
",",
"2",
")",
"+",
"np",
".",
"power",
"(",
"AN",
"[",
"2",
"]",
",",
"2",
")",
")",
"AE",
"=",
"AE",
"/",
"AER",
"if",
"not",
"ANR",
":",
"AN",
"=",
"np",
".",
"array",
"(",
"[",
"np",
".",
"nan",
",",
"np",
".",
"nan",
",",
"np",
".",
"nan",
"]",
")",
"else",
":",
"AN",
"=",
"AN",
"/",
"ANR",
"if",
"AN",
"[",
"2",
"]",
"<=",
"0.",
":",
"AN1",
"=",
"AN",
"AE1",
"=",
"AE",
"else",
":",
"AN1",
"=",
"-",
"AN",
"AE1",
"=",
"-",
"AE",
"(",
"ft",
",",
"fd",
",",
"fl",
")",
"=",
"TDL",
"(",
"AN1",
",",
"AE1",
")",
"return",
"NodalPlane",
"(",
"360",
"-",
"ft",
",",
"fd",
",",
"180",
"-",
"fl",
")"
] | 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. | [
"Calculates",
"a",
"nodal",
"plane",
"of",
"a",
"given",
"moment",
"tensor",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/plotting/beachball.py#L732-L766 |
31 | gem/oq-engine | openquake/hmtk/plotting/beachball.py | TDL | 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 = 1.0 / (1000000)
CON = 57.2957795
if np.fabs(ZN) < AAA:
FD = 90.
AXN = np.fabs(XN)
if AXN > 1.0:
AXN = 1.0
FT = np.arcsin(AXN) * CON
ST = -XN
CT = YN
if ST >= 0. and CT < 0:
FT = 180. - FT
if ST < 0. and CT <= 0:
FT = 180. + FT
if ST < 0. and CT > 0:
FT = 360. - FT
FL = np.arcsin(abs(ZE)) * CON
SL = -ZE
if np.fabs(XN) < AAA:
CL = XE / YN
else:
CL = -YE / XN
if SL >= 0. and CL < 0:
FL = 180. - FL
if SL < 0. and CL <= 0:
FL = FL - 180.
if SL < 0. and CL > 0:
FL = -FL
else:
if - ZN > 1.0:
ZN = -1.0
FDH = np.arccos(-ZN)
FD = FDH * CON
SD = np.sin(FDH)
if SD == 0:
return
ST = -XN / SD
CT = YN / SD
SX = np.fabs(ST)
if SX > 1.0:
SX = 1.0
FT = np.arcsin(SX) * CON
if ST >= 0. and CT < 0:
FT = 180. - FT
if ST < 0. and CT <= 0:
FT = 180. + FT
if ST < 0. and CT > 0:
FT = 360. - FT
SL = -ZE / SD
SX = np.fabs(SL)
if SX > 1.0:
SX = 1.0
FL = np.arcsin(SX) * CON
if ST == 0:
CL = XE / CT
else:
XXX = YN * ZN * ZE / SD / SD + YE
CL = -SD * XXX / XN
if CT == 0:
CL = YE / ST
if SL >= 0. and CL < 0:
FL = 180. - FL
if SL < 0. and CL <= 0:
FL = FL - 180.
if SL < 0. and CL > 0:
FL = -FL
return (FT, FD, FL) | python | 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 = 1.0 / (1000000)
CON = 57.2957795
if np.fabs(ZN) < AAA:
FD = 90.
AXN = np.fabs(XN)
if AXN > 1.0:
AXN = 1.0
FT = np.arcsin(AXN) * CON
ST = -XN
CT = YN
if ST >= 0. and CT < 0:
FT = 180. - FT
if ST < 0. and CT <= 0:
FT = 180. + FT
if ST < 0. and CT > 0:
FT = 360. - FT
FL = np.arcsin(abs(ZE)) * CON
SL = -ZE
if np.fabs(XN) < AAA:
CL = XE / YN
else:
CL = -YE / XN
if SL >= 0. and CL < 0:
FL = 180. - FL
if SL < 0. and CL <= 0:
FL = FL - 180.
if SL < 0. and CL > 0:
FL = -FL
else:
if - ZN > 1.0:
ZN = -1.0
FDH = np.arccos(-ZN)
FD = FDH * CON
SD = np.sin(FDH)
if SD == 0:
return
ST = -XN / SD
CT = YN / SD
SX = np.fabs(ST)
if SX > 1.0:
SX = 1.0
FT = np.arcsin(SX) * CON
if ST >= 0. and CT < 0:
FT = 180. - FT
if ST < 0. and CT <= 0:
FT = 180. + FT
if ST < 0. and CT > 0:
FT = 360. - FT
SL = -ZE / SD
SX = np.fabs(SL)
if SX > 1.0:
SX = 1.0
FL = np.arcsin(SX) * CON
if ST == 0:
CL = XE / CT
else:
XXX = YN * ZN * ZE / SD / SD + YE
CL = -SD * XXX / XN
if CT == 0:
CL = YE / ST
if SL >= 0. and CL < 0:
FL = 180. - FL
if SL < 0. and CL <= 0:
FL = FL - 180.
if SL < 0. and CL > 0:
FL = -FL
return (FT, FD, FL) | [
"def",
"TDL",
"(",
"AN",
",",
"BN",
")",
":",
"XN",
"=",
"AN",
"[",
"0",
"]",
"YN",
"=",
"AN",
"[",
"1",
"]",
"ZN",
"=",
"AN",
"[",
"2",
"]",
"XE",
"=",
"BN",
"[",
"0",
"]",
"YE",
"=",
"BN",
"[",
"1",
"]",
"ZE",
"=",
"BN",
"[",
"2",
"]",
"AAA",
"=",
"1.0",
"/",
"(",
"1000000",
")",
"CON",
"=",
"57.2957795",
"if",
"np",
".",
"fabs",
"(",
"ZN",
")",
"<",
"AAA",
":",
"FD",
"=",
"90.",
"AXN",
"=",
"np",
".",
"fabs",
"(",
"XN",
")",
"if",
"AXN",
">",
"1.0",
":",
"AXN",
"=",
"1.0",
"FT",
"=",
"np",
".",
"arcsin",
"(",
"AXN",
")",
"*",
"CON",
"ST",
"=",
"-",
"XN",
"CT",
"=",
"YN",
"if",
"ST",
">=",
"0.",
"and",
"CT",
"<",
"0",
":",
"FT",
"=",
"180.",
"-",
"FT",
"if",
"ST",
"<",
"0.",
"and",
"CT",
"<=",
"0",
":",
"FT",
"=",
"180.",
"+",
"FT",
"if",
"ST",
"<",
"0.",
"and",
"CT",
">",
"0",
":",
"FT",
"=",
"360.",
"-",
"FT",
"FL",
"=",
"np",
".",
"arcsin",
"(",
"abs",
"(",
"ZE",
")",
")",
"*",
"CON",
"SL",
"=",
"-",
"ZE",
"if",
"np",
".",
"fabs",
"(",
"XN",
")",
"<",
"AAA",
":",
"CL",
"=",
"XE",
"/",
"YN",
"else",
":",
"CL",
"=",
"-",
"YE",
"/",
"XN",
"if",
"SL",
">=",
"0.",
"and",
"CL",
"<",
"0",
":",
"FL",
"=",
"180.",
"-",
"FL",
"if",
"SL",
"<",
"0.",
"and",
"CL",
"<=",
"0",
":",
"FL",
"=",
"FL",
"-",
"180.",
"if",
"SL",
"<",
"0.",
"and",
"CL",
">",
"0",
":",
"FL",
"=",
"-",
"FL",
"else",
":",
"if",
"-",
"ZN",
">",
"1.0",
":",
"ZN",
"=",
"-",
"1.0",
"FDH",
"=",
"np",
".",
"arccos",
"(",
"-",
"ZN",
")",
"FD",
"=",
"FDH",
"*",
"CON",
"SD",
"=",
"np",
".",
"sin",
"(",
"FDH",
")",
"if",
"SD",
"==",
"0",
":",
"return",
"ST",
"=",
"-",
"XN",
"/",
"SD",
"CT",
"=",
"YN",
"/",
"SD",
"SX",
"=",
"np",
".",
"fabs",
"(",
"ST",
")",
"if",
"SX",
">",
"1.0",
":",
"SX",
"=",
"1.0",
"FT",
"=",
"np",
".",
"arcsin",
"(",
"SX",
")",
"*",
"CON",
"if",
"ST",
">=",
"0.",
"and",
"CT",
"<",
"0",
":",
"FT",
"=",
"180.",
"-",
"FT",
"if",
"ST",
"<",
"0.",
"and",
"CT",
"<=",
"0",
":",
"FT",
"=",
"180.",
"+",
"FT",
"if",
"ST",
"<",
"0.",
"and",
"CT",
">",
"0",
":",
"FT",
"=",
"360.",
"-",
"FT",
"SL",
"=",
"-",
"ZE",
"/",
"SD",
"SX",
"=",
"np",
".",
"fabs",
"(",
"SL",
")",
"if",
"SX",
">",
"1.0",
":",
"SX",
"=",
"1.0",
"FL",
"=",
"np",
".",
"arcsin",
"(",
"SX",
")",
"*",
"CON",
"if",
"ST",
"==",
"0",
":",
"CL",
"=",
"XE",
"/",
"CT",
"else",
":",
"XXX",
"=",
"YN",
"*",
"ZN",
"*",
"ZE",
"/",
"SD",
"/",
"SD",
"+",
"YE",
"CL",
"=",
"-",
"SD",
"*",
"XXX",
"/",
"XN",
"if",
"CT",
"==",
"0",
":",
"CL",
"=",
"YE",
"/",
"ST",
"if",
"SL",
">=",
"0.",
"and",
"CL",
"<",
"0",
":",
"FL",
"=",
"180.",
"-",
"FL",
"if",
"SL",
"<",
"0.",
"and",
"CL",
"<=",
"0",
":",
"FL",
"=",
"FL",
"-",
"180.",
"if",
"SL",
"<",
"0.",
"and",
"CL",
">",
"0",
":",
"FL",
"=",
"-",
"FL",
"return",
"(",
"FT",
",",
"FD",
",",
"FL",
")"
] | 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. | [
"Helper",
"function",
"for",
"MT2Plane",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/plotting/beachball.py#L769-L849 |
32 | gem/oq-engine | openquake/hmtk/plotting/beachball.py | MT2Axes | 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.eigh(mt.mt)
pl = np.arcsin(-V[0])
az = np.arctan2(V[2], -V[1])
for i in range(0, 3):
if pl[i] <= 0:
pl[i] = -pl[i]
az[i] += np.pi
if az[i] < 0:
az[i] += 2 * np.pi
if az[i] > 2 * np.pi:
az[i] -= 2 * np.pi
pl *= R2D
az *= R2D
T = PrincipalAxis(D[2], az[2], pl[2])
N = PrincipalAxis(D[1], az[1], pl[1])
P = PrincipalAxis(D[0], az[0], pl[0])
return (T, N, P) | python | 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.eigh(mt.mt)
pl = np.arcsin(-V[0])
az = np.arctan2(V[2], -V[1])
for i in range(0, 3):
if pl[i] <= 0:
pl[i] = -pl[i]
az[i] += np.pi
if az[i] < 0:
az[i] += 2 * np.pi
if az[i] > 2 * np.pi:
az[i] -= 2 * np.pi
pl *= R2D
az *= R2D
T = PrincipalAxis(D[2], az[2], pl[2])
N = PrincipalAxis(D[1], az[1], pl[1])
P = PrincipalAxis(D[0], az[0], pl[0])
return (T, N, P) | [
"def",
"MT2Axes",
"(",
"mt",
")",
":",
"(",
"D",
",",
"V",
")",
"=",
"np",
".",
"linalg",
".",
"eigh",
"(",
"mt",
".",
"mt",
")",
"pl",
"=",
"np",
".",
"arcsin",
"(",
"-",
"V",
"[",
"0",
"]",
")",
"az",
"=",
"np",
".",
"arctan2",
"(",
"V",
"[",
"2",
"]",
",",
"-",
"V",
"[",
"1",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"3",
")",
":",
"if",
"pl",
"[",
"i",
"]",
"<=",
"0",
":",
"pl",
"[",
"i",
"]",
"=",
"-",
"pl",
"[",
"i",
"]",
"az",
"[",
"i",
"]",
"+=",
"np",
".",
"pi",
"if",
"az",
"[",
"i",
"]",
"<",
"0",
":",
"az",
"[",
"i",
"]",
"+=",
"2",
"*",
"np",
".",
"pi",
"if",
"az",
"[",
"i",
"]",
">",
"2",
"*",
"np",
".",
"pi",
":",
"az",
"[",
"i",
"]",
"-=",
"2",
"*",
"np",
".",
"pi",
"pl",
"*=",
"R2D",
"az",
"*=",
"R2D",
"T",
"=",
"PrincipalAxis",
"(",
"D",
"[",
"2",
"]",
",",
"az",
"[",
"2",
"]",
",",
"pl",
"[",
"2",
"]",
")",
"N",
"=",
"PrincipalAxis",
"(",
"D",
"[",
"1",
"]",
",",
"az",
"[",
"1",
"]",
",",
"pl",
"[",
"1",
"]",
")",
"P",
"=",
"PrincipalAxis",
"(",
"D",
"[",
"0",
"]",
",",
"az",
"[",
"0",
"]",
",",
"pl",
"[",
"0",
"]",
")",
"return",
"(",
"T",
",",
"N",
",",
"P",
")"
] | 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>`_. | [
"Calculates",
"the",
"principal",
"axes",
"of",
"a",
"given",
"moment",
"tensor",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/plotting/beachball.py#L852-L879 |
33 | gem/oq-engine | openquake/hmtk/strain/strain_utils.py | tapered_gutenberg_richter_cdf | 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:
Threshold Moment of the distribution (moment rate essentially!)
:param float beta:
Beta value (b * ln(10.)) of the Tapered Gutenberg-Richter Function
:param float corner_momnet:
Corner moment of the Tapered Gutenberg-Richter Function
:returns:
Cumulative probability of moment release > moment
'''
cdf = np.exp((moment_threshold - moment) / corner_moment)
return ((moment / moment_threshold) ** (-beta)) * cdf | python | 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:
Threshold Moment of the distribution (moment rate essentially!)
:param float beta:
Beta value (b * ln(10.)) of the Tapered Gutenberg-Richter Function
:param float corner_momnet:
Corner moment of the Tapered Gutenberg-Richter Function
:returns:
Cumulative probability of moment release > moment
'''
cdf = np.exp((moment_threshold - moment) / corner_moment)
return ((moment / moment_threshold) ** (-beta)) * cdf | [
"def",
"tapered_gutenberg_richter_cdf",
"(",
"moment",
",",
"moment_threshold",
",",
"beta",
",",
"corner_moment",
")",
":",
"cdf",
"=",
"np",
".",
"exp",
"(",
"(",
"moment_threshold",
"-",
"moment",
")",
"/",
"corner_moment",
")",
"return",
"(",
"(",
"moment",
"/",
"moment_threshold",
")",
"**",
"(",
"-",
"beta",
")",
")",
"*",
"cdf"
] | Tapered Gutenberg Richter Cumulative Density Function
:param float or numpy.ndarray moment:
Moment for calculation of rate
:param float or numpy.ndarray moment_threshold:
Threshold Moment of the distribution (moment rate essentially!)
:param float beta:
Beta value (b * ln(10.)) of the Tapered Gutenberg-Richter Function
:param float corner_momnet:
Corner moment of the Tapered Gutenberg-Richter Function
:returns:
Cumulative probability of moment release > moment | [
"Tapered",
"Gutenberg",
"Richter",
"Cumulative",
"Density",
"Function"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/strain/strain_utils.py#L111-L134 |
34 | gem/oq-engine | openquake/hmtk/strain/strain_utils.py | tapered_gutenberg_richter_pdf | 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:
Threshold Moment of the distribution (moment rate essentially!)
:param float beta:
Beta value (b * ln(10.)) of the Tapered Gutenberg-Richter Function
:param float corner_momnet:
Corner moment of the Tapered Gutenberg-Richter Function
:returns:
Absolute probability of moment release > moment
'''
return ((beta / moment + 1. / corner_moment) *
tapered_gutenberg_richter_cdf(moment, moment_threshold, beta,
corner_moment)) | python | 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:
Threshold Moment of the distribution (moment rate essentially!)
:param float beta:
Beta value (b * ln(10.)) of the Tapered Gutenberg-Richter Function
:param float corner_momnet:
Corner moment of the Tapered Gutenberg-Richter Function
:returns:
Absolute probability of moment release > moment
'''
return ((beta / moment + 1. / corner_moment) *
tapered_gutenberg_richter_cdf(moment, moment_threshold, beta,
corner_moment)) | [
"def",
"tapered_gutenberg_richter_pdf",
"(",
"moment",
",",
"moment_threshold",
",",
"beta",
",",
"corner_moment",
")",
":",
"return",
"(",
"(",
"beta",
"/",
"moment",
"+",
"1.",
"/",
"corner_moment",
")",
"*",
"tapered_gutenberg_richter_cdf",
"(",
"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:
Threshold Moment of the distribution (moment rate essentially!)
:param float beta:
Beta value (b * ln(10.)) of the Tapered Gutenberg-Richter Function
:param float corner_momnet:
Corner moment of the Tapered Gutenberg-Richter Function
:returns:
Absolute probability of moment release > moment | [
"Tapered",
"Gutenberg",
"-",
"Richter",
"Probability",
"Density",
"Function"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/strain/strain_utils.py#L137-L159 |
35 | gem/oq-engine | openquake/engine/export/core.py | makedirs | 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 not a directory.'
% path)
else:
os.makedirs(path) | python | 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 not a directory.'
% path)
else:
os.makedirs(path) | [
"def",
"makedirs",
"(",
"path",
")",
":",
"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 not a directory.'",
"%",
"path",
")",
"else",
":",
"os",
".",
"makedirs",
"(",
"path",
")"
] | Make all of the directories in the ``path`` using `os.makedirs`. | [
"Make",
"all",
"of",
"the",
"directories",
"in",
"the",
"path",
"using",
"os",
".",
"makedirs",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/engine/export/core.py#L80-L91 |
36 | gem/oq-engine | openquake/hmtk/seismicity/max_magnitude/base.py | _get_observed_mmax | 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_uncertainty']
else:
raise ValueError('Input mmax uncertainty must be specified!')
max_location = np.argmax(catalogue['magnitude'])
obsmax = catalogue['magnitude'][max_location]
cond = isinstance(catalogue['sigmaMagnitude'], np.ndarray) and \
len(catalogue['sigmaMagnitude']) > 0 and not \
np.all(np.isnan(catalogue['sigmaMagnitude']))
if cond:
if not np.isnan(catalogue['sigmaMagnitude'][max_location]):
return obsmax, catalogue['sigmaMagnitude'][max_location]
else:
print('Uncertainty not given on observed Mmax\n'
'Taking largest magnitude uncertainty found in catalogue')
return obsmax, np.nanmax(catalogue['sigmaMagnitude'])
elif config['input_mmax_uncertainty']:
return obsmax, config['input_mmax_uncertainty']
else:
raise ValueError('Input mmax uncertainty must be specified!') | python | 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_uncertainty']
else:
raise ValueError('Input mmax uncertainty must be specified!')
max_location = np.argmax(catalogue['magnitude'])
obsmax = catalogue['magnitude'][max_location]
cond = isinstance(catalogue['sigmaMagnitude'], np.ndarray) and \
len(catalogue['sigmaMagnitude']) > 0 and not \
np.all(np.isnan(catalogue['sigmaMagnitude']))
if cond:
if not np.isnan(catalogue['sigmaMagnitude'][max_location]):
return obsmax, catalogue['sigmaMagnitude'][max_location]
else:
print('Uncertainty not given on observed Mmax\n'
'Taking largest magnitude uncertainty found in catalogue')
return obsmax, np.nanmax(catalogue['sigmaMagnitude'])
elif config['input_mmax_uncertainty']:
return obsmax, config['input_mmax_uncertainty']
else:
raise ValueError('Input mmax uncertainty must be specified!') | [
"def",
"_get_observed_mmax",
"(",
"catalogue",
",",
"config",
")",
":",
"if",
"config",
"[",
"'input_mmax'",
"]",
":",
"obsmax",
"=",
"config",
"[",
"'input_mmax'",
"]",
"if",
"config",
"[",
"'input_mmax_uncertainty'",
"]",
":",
"return",
"config",
"[",
"'input_mmax'",
"]",
",",
"config",
"[",
"'input_mmax_uncertainty'",
"]",
"else",
":",
"raise",
"ValueError",
"(",
"'Input mmax uncertainty must be specified!'",
")",
"max_location",
"=",
"np",
".",
"argmax",
"(",
"catalogue",
"[",
"'magnitude'",
"]",
")",
"obsmax",
"=",
"catalogue",
"[",
"'magnitude'",
"]",
"[",
"max_location",
"]",
"cond",
"=",
"isinstance",
"(",
"catalogue",
"[",
"'sigmaMagnitude'",
"]",
",",
"np",
".",
"ndarray",
")",
"and",
"len",
"(",
"catalogue",
"[",
"'sigmaMagnitude'",
"]",
")",
">",
"0",
"and",
"not",
"np",
".",
"all",
"(",
"np",
".",
"isnan",
"(",
"catalogue",
"[",
"'sigmaMagnitude'",
"]",
")",
")",
"if",
"cond",
":",
"if",
"not",
"np",
".",
"isnan",
"(",
"catalogue",
"[",
"'sigmaMagnitude'",
"]",
"[",
"max_location",
"]",
")",
":",
"return",
"obsmax",
",",
"catalogue",
"[",
"'sigmaMagnitude'",
"]",
"[",
"max_location",
"]",
"else",
":",
"print",
"(",
"'Uncertainty not given on observed Mmax\\n'",
"'Taking largest magnitude uncertainty found in catalogue'",
")",
"return",
"obsmax",
",",
"np",
".",
"nanmax",
"(",
"catalogue",
"[",
"'sigmaMagnitude'",
"]",
")",
"elif",
"config",
"[",
"'input_mmax_uncertainty'",
"]",
":",
"return",
"obsmax",
",",
"config",
"[",
"'input_mmax_uncertainty'",
"]",
"else",
":",
"raise",
"ValueError",
"(",
"'Input mmax uncertainty must be specified!'",
")"
] | Check see if observed mmax values are input, if not then take
from the catalogue | [
"Check",
"see",
"if",
"observed",
"mmax",
"values",
"are",
"input",
"if",
"not",
"then",
"take",
"from",
"the",
"catalogue"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/seismicity/max_magnitude/base.py#L57-L83 |
37 | gem/oq-engine | openquake/hmtk/seismicity/max_magnitude/base.py | _get_magnitude_vector_properties | 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'] >= mmin - 1.E-7))
return neq, mmin | python | 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'] >= mmin - 1.E-7))
return neq, mmin | [
"def",
"_get_magnitude_vector_properties",
"(",
"catalogue",
",",
"config",
")",
":",
"mmin",
"=",
"config",
".",
"get",
"(",
"'input_mmin'",
",",
"np",
".",
"min",
"(",
"catalogue",
"[",
"'magnitude'",
"]",
")",
")",
"neq",
"=",
"np",
".",
"float",
"(",
"np",
".",
"sum",
"(",
"catalogue",
"[",
"'magnitude'",
"]",
">=",
"mmin",
"-",
"1.E-7",
")",
")",
"return",
"neq",
",",
"mmin"
] | If an input minimum magnitude is given then consider catalogue
only above the minimum magnitude - returns corresponding properties | [
"If",
"an",
"input",
"minimum",
"magnitude",
"is",
"given",
"then",
"consider",
"catalogue",
"only",
"above",
"the",
"minimum",
"magnitude",
"-",
"returns",
"corresponding",
"properties"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hmtk/seismicity/max_magnitude/base.py#L104-L110 |
38 | gem/oq-engine | openquake/hazardlib/geo/surface/complex_fault.py | ComplexFaultSurface.get_dip | def get_dip(self):
"""
Return the fault dip as the average dip over the mesh.
The average dip is defined as the weighted mean inclination
of all the mesh cells. See
:meth:`openquake.hazardlib.geo.mesh.RectangularMesh.get_mean_inclination_and_azimuth`
:returns:
The average dip, in decimal degrees.
"""
# uses the same approach as in simple fault surface
if self.dip is None:
mesh = self.mesh
self.dip, self.strike = mesh.get_mean_inclination_and_azimuth()
return self.dip | python | def get_dip(self):
"""
Return the fault dip as the average dip over the mesh.
The average dip is defined as the weighted mean inclination
of all the mesh cells. See
:meth:`openquake.hazardlib.geo.mesh.RectangularMesh.get_mean_inclination_and_azimuth`
:returns:
The average dip, in decimal degrees.
"""
# uses the same approach as in simple fault surface
if self.dip is None:
mesh = self.mesh
self.dip, self.strike = mesh.get_mean_inclination_and_azimuth()
return self.dip | [
"def",
"get_dip",
"(",
"self",
")",
":",
"# uses the same approach as in simple fault surface",
"if",
"self",
".",
"dip",
"is",
"None",
":",
"mesh",
"=",
"self",
".",
"mesh",
"self",
".",
"dip",
",",
"self",
".",
"strike",
"=",
"mesh",
".",
"get_mean_inclination_and_azimuth",
"(",
")",
"return",
"self",
".",
"dip"
] | Return the fault dip as the average dip over the mesh.
The average dip is defined as the weighted mean inclination
of all the mesh cells. See
:meth:`openquake.hazardlib.geo.mesh.RectangularMesh.get_mean_inclination_and_azimuth`
:returns:
The average dip, in decimal degrees. | [
"Return",
"the",
"fault",
"dip",
"as",
"the",
"average",
"dip",
"over",
"the",
"mesh",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L96-L111 |
39 | gem/oq-engine | openquake/hazardlib/geo/surface/complex_fault.py | ComplexFaultSurface.check_surface_validity | def check_surface_validity(cls, edges):
"""
Check validity of the surface.
Project edge points to vertical plane anchored to surface upper left
edge and with strike equal to top edge strike. Check that resulting
polygon is valid.
This method doesn't have to be called by hands before creating the
surface object, because it is called from :meth:`from_fault_data`.
"""
# extract coordinates of surface boundary (as defined from edges)
full_boundary = []
left_boundary = []
right_boundary = []
for i in range(1, len(edges) - 1):
left_boundary.append(edges[i].points[0])
right_boundary.append(edges[i].points[-1])
full_boundary.extend(edges[0].points)
full_boundary.extend(right_boundary)
full_boundary.extend(edges[-1].points[::-1])
full_boundary.extend(left_boundary[::-1])
lons = [p.longitude for p in full_boundary]
lats = [p.latitude for p in full_boundary]
depths = [p.depth for p in full_boundary]
# define reference plane. Corner points are separated by an arbitrary
# distance of 10 km. The mesh spacing is set to 2 km. Both corner
# distance and mesh spacing values do not affect the algorithm results.
ul = edges[0].points[0]
strike = ul.azimuth(edges[0].points[-1])
dist = 10.
ur = ul.point_at(dist, 0, strike)
bl = Point(ul.longitude, ul.latitude, ul.depth + dist)
br = bl.point_at(dist, 0, strike)
# project surface boundary to reference plane and check for
# validity.
ref_plane = PlanarSurface.from_corner_points(ul, ur, br, bl)
_, xx, yy = ref_plane._project(
spherical_to_cartesian(lons, lats, depths))
coords = [(x, y) for x, y in zip(xx, yy)]
p = shapely.geometry.Polygon(coords)
if not p.is_valid:
raise ValueError('Edges points are not in the right order') | python | def check_surface_validity(cls, edges):
"""
Check validity of the surface.
Project edge points to vertical plane anchored to surface upper left
edge and with strike equal to top edge strike. Check that resulting
polygon is valid.
This method doesn't have to be called by hands before creating the
surface object, because it is called from :meth:`from_fault_data`.
"""
# extract coordinates of surface boundary (as defined from edges)
full_boundary = []
left_boundary = []
right_boundary = []
for i in range(1, len(edges) - 1):
left_boundary.append(edges[i].points[0])
right_boundary.append(edges[i].points[-1])
full_boundary.extend(edges[0].points)
full_boundary.extend(right_boundary)
full_boundary.extend(edges[-1].points[::-1])
full_boundary.extend(left_boundary[::-1])
lons = [p.longitude for p in full_boundary]
lats = [p.latitude for p in full_boundary]
depths = [p.depth for p in full_boundary]
# define reference plane. Corner points are separated by an arbitrary
# distance of 10 km. The mesh spacing is set to 2 km. Both corner
# distance and mesh spacing values do not affect the algorithm results.
ul = edges[0].points[0]
strike = ul.azimuth(edges[0].points[-1])
dist = 10.
ur = ul.point_at(dist, 0, strike)
bl = Point(ul.longitude, ul.latitude, ul.depth + dist)
br = bl.point_at(dist, 0, strike)
# project surface boundary to reference plane and check for
# validity.
ref_plane = PlanarSurface.from_corner_points(ul, ur, br, bl)
_, xx, yy = ref_plane._project(
spherical_to_cartesian(lons, lats, depths))
coords = [(x, y) for x, y in zip(xx, yy)]
p = shapely.geometry.Polygon(coords)
if not p.is_valid:
raise ValueError('Edges points are not in the right order') | [
"def",
"check_surface_validity",
"(",
"cls",
",",
"edges",
")",
":",
"# extract coordinates of surface boundary (as defined from edges)",
"full_boundary",
"=",
"[",
"]",
"left_boundary",
"=",
"[",
"]",
"right_boundary",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"edges",
")",
"-",
"1",
")",
":",
"left_boundary",
".",
"append",
"(",
"edges",
"[",
"i",
"]",
".",
"points",
"[",
"0",
"]",
")",
"right_boundary",
".",
"append",
"(",
"edges",
"[",
"i",
"]",
".",
"points",
"[",
"-",
"1",
"]",
")",
"full_boundary",
".",
"extend",
"(",
"edges",
"[",
"0",
"]",
".",
"points",
")",
"full_boundary",
".",
"extend",
"(",
"right_boundary",
")",
"full_boundary",
".",
"extend",
"(",
"edges",
"[",
"-",
"1",
"]",
".",
"points",
"[",
":",
":",
"-",
"1",
"]",
")",
"full_boundary",
".",
"extend",
"(",
"left_boundary",
"[",
":",
":",
"-",
"1",
"]",
")",
"lons",
"=",
"[",
"p",
".",
"longitude",
"for",
"p",
"in",
"full_boundary",
"]",
"lats",
"=",
"[",
"p",
".",
"latitude",
"for",
"p",
"in",
"full_boundary",
"]",
"depths",
"=",
"[",
"p",
".",
"depth",
"for",
"p",
"in",
"full_boundary",
"]",
"# define reference plane. Corner points are separated by an arbitrary",
"# distance of 10 km. The mesh spacing is set to 2 km. Both corner",
"# distance and mesh spacing values do not affect the algorithm results.",
"ul",
"=",
"edges",
"[",
"0",
"]",
".",
"points",
"[",
"0",
"]",
"strike",
"=",
"ul",
".",
"azimuth",
"(",
"edges",
"[",
"0",
"]",
".",
"points",
"[",
"-",
"1",
"]",
")",
"dist",
"=",
"10.",
"ur",
"=",
"ul",
".",
"point_at",
"(",
"dist",
",",
"0",
",",
"strike",
")",
"bl",
"=",
"Point",
"(",
"ul",
".",
"longitude",
",",
"ul",
".",
"latitude",
",",
"ul",
".",
"depth",
"+",
"dist",
")",
"br",
"=",
"bl",
".",
"point_at",
"(",
"dist",
",",
"0",
",",
"strike",
")",
"# project surface boundary to reference plane and check for",
"# validity.",
"ref_plane",
"=",
"PlanarSurface",
".",
"from_corner_points",
"(",
"ul",
",",
"ur",
",",
"br",
",",
"bl",
")",
"_",
",",
"xx",
",",
"yy",
"=",
"ref_plane",
".",
"_project",
"(",
"spherical_to_cartesian",
"(",
"lons",
",",
"lats",
",",
"depths",
")",
")",
"coords",
"=",
"[",
"(",
"x",
",",
"y",
")",
"for",
"x",
",",
"y",
"in",
"zip",
"(",
"xx",
",",
"yy",
")",
"]",
"p",
"=",
"shapely",
".",
"geometry",
".",
"Polygon",
"(",
"coords",
")",
"if",
"not",
"p",
".",
"is_valid",
":",
"raise",
"ValueError",
"(",
"'Edges points are not in the right order'",
")"
] | Check validity of the surface.
Project edge points to vertical plane anchored to surface upper left
edge and with strike equal to top edge strike. Check that resulting
polygon is valid.
This method doesn't have to be called by hands before creating the
surface object, because it is called from :meth:`from_fault_data`. | [
"Check",
"validity",
"of",
"the",
"surface",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L182-L230 |
40 | gem/oq-engine | openquake/hazardlib/geo/surface/complex_fault.py | ComplexFaultSurface.surface_projection_from_fault_data | def surface_projection_from_fault_data(cls, edges):
"""
Get a surface projection of the complex fault surface.
:param edges:
A list of horizontal edges of the surface as instances
of :class:`openquake.hazardlib.geo.line.Line`.
:returns:
Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon`
describing the surface projection of the complex fault.
"""
# collect lons and lats of all the vertices of all the edges
lons = []
lats = []
for edge in edges:
for point in edge:
lons.append(point.longitude)
lats.append(point.latitude)
lons = numpy.array(lons, dtype=float)
lats = numpy.array(lats, dtype=float)
return Mesh(lons, lats, depths=None).get_convex_hull() | python | def surface_projection_from_fault_data(cls, edges):
"""
Get a surface projection of the complex fault surface.
:param edges:
A list of horizontal edges of the surface as instances
of :class:`openquake.hazardlib.geo.line.Line`.
:returns:
Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon`
describing the surface projection of the complex fault.
"""
# collect lons and lats of all the vertices of all the edges
lons = []
lats = []
for edge in edges:
for point in edge:
lons.append(point.longitude)
lats.append(point.latitude)
lons = numpy.array(lons, dtype=float)
lats = numpy.array(lats, dtype=float)
return Mesh(lons, lats, depths=None).get_convex_hull() | [
"def",
"surface_projection_from_fault_data",
"(",
"cls",
",",
"edges",
")",
":",
"# collect lons and lats of all the vertices of all the edges",
"lons",
"=",
"[",
"]",
"lats",
"=",
"[",
"]",
"for",
"edge",
"in",
"edges",
":",
"for",
"point",
"in",
"edge",
":",
"lons",
".",
"append",
"(",
"point",
".",
"longitude",
")",
"lats",
".",
"append",
"(",
"point",
".",
"latitude",
")",
"lons",
"=",
"numpy",
".",
"array",
"(",
"lons",
",",
"dtype",
"=",
"float",
")",
"lats",
"=",
"numpy",
".",
"array",
"(",
"lats",
",",
"dtype",
"=",
"float",
")",
"return",
"Mesh",
"(",
"lons",
",",
"lats",
",",
"depths",
"=",
"None",
")",
".",
"get_convex_hull",
"(",
")"
] | Get a surface projection of the complex fault surface.
:param edges:
A list of horizontal edges of the surface as instances
of :class:`openquake.hazardlib.geo.line.Line`.
:returns:
Instance of :class:`~openquake.hazardlib.geo.polygon.Polygon`
describing the surface projection of the complex fault. | [
"Get",
"a",
"surface",
"projection",
"of",
"the",
"complex",
"fault",
"surface",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L302-L323 |
41 | gem/oq-engine | openquake/calculators/base.py | check_time_event | def check_time_event(oqparam, occupancy_periods):
"""
Check the `time_event` parameter in the datastore, by comparing
with the periods found in the exposure.
"""
time_event = oqparam.time_event
if time_event and time_event not in occupancy_periods:
raise ValueError(
'time_event is %s in %s, but the exposure contains %s' %
(time_event, oqparam.inputs['job_ini'],
', '.join(occupancy_periods))) | python | def check_time_event(oqparam, occupancy_periods):
"""
Check the `time_event` parameter in the datastore, by comparing
with the periods found in the exposure.
"""
time_event = oqparam.time_event
if time_event and time_event not in occupancy_periods:
raise ValueError(
'time_event is %s in %s, but the exposure contains %s' %
(time_event, oqparam.inputs['job_ini'],
', '.join(occupancy_periods))) | [
"def",
"check_time_event",
"(",
"oqparam",
",",
"occupancy_periods",
")",
":",
"time_event",
"=",
"oqparam",
".",
"time_event",
"if",
"time_event",
"and",
"time_event",
"not",
"in",
"occupancy_periods",
":",
"raise",
"ValueError",
"(",
"'time_event is %s in %s, but the exposure contains %s'",
"%",
"(",
"time_event",
",",
"oqparam",
".",
"inputs",
"[",
"'job_ini'",
"]",
",",
"', '",
".",
"join",
"(",
"occupancy_periods",
")",
")",
")"
] | Check the `time_event` parameter in the datastore, by comparing
with the periods found in the exposure. | [
"Check",
"the",
"time_event",
"parameter",
"in",
"the",
"datastore",
"by",
"comparing",
"with",
"the",
"periods",
"found",
"in",
"the",
"exposure",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L321-L331 |
42 | gem/oq-engine | openquake/calculators/base.py | get_idxs | def get_idxs(data, eid2idx):
"""
Convert from event IDs to event indices.
:param data: an array with a field eid
:param eid2idx: a dictionary eid -> idx
:returns: the array of event indices
"""
uniq, inv = numpy.unique(data['eid'], return_inverse=True)
idxs = numpy.array([eid2idx[eid] for eid in uniq])[inv]
return idxs | python | def get_idxs(data, eid2idx):
"""
Convert from event IDs to event indices.
:param data: an array with a field eid
:param eid2idx: a dictionary eid -> idx
:returns: the array of event indices
"""
uniq, inv = numpy.unique(data['eid'], return_inverse=True)
idxs = numpy.array([eid2idx[eid] for eid in uniq])[inv]
return idxs | [
"def",
"get_idxs",
"(",
"data",
",",
"eid2idx",
")",
":",
"uniq",
",",
"inv",
"=",
"numpy",
".",
"unique",
"(",
"data",
"[",
"'eid'",
"]",
",",
"return_inverse",
"=",
"True",
")",
"idxs",
"=",
"numpy",
".",
"array",
"(",
"[",
"eid2idx",
"[",
"eid",
"]",
"for",
"eid",
"in",
"uniq",
"]",
")",
"[",
"inv",
"]",
"return",
"idxs"
] | Convert from event IDs to event indices.
:param data: an array with a field eid
:param eid2idx: a dictionary eid -> idx
:returns: the array of event indices | [
"Convert",
"from",
"event",
"IDs",
"to",
"event",
"indices",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L959-L969 |
43 | gem/oq-engine | openquake/calculators/base.py | import_gmfs | def import_gmfs(dstore, fname, sids):
"""
Import in the datastore a ground motion field CSV file.
:param dstore: the datastore
:param fname: the CSV file
:param sids: the site IDs (complete)
:returns: event_ids, num_rlzs
"""
array = writers.read_composite_array(fname).array
# has header rlzi, sid, eid, gmv_PGA, ...
imts = [name[4:] for name in array.dtype.names[3:]]
n_imts = len(imts)
gmf_data_dt = numpy.dtype(
[('rlzi', U16), ('sid', U32), ('eid', U64), ('gmv', (F32, (n_imts,)))])
# store the events
eids = numpy.unique(array['eid'])
eids.sort()
E = len(eids)
eid2idx = dict(zip(eids, range(E)))
events = numpy.zeros(E, rupture.events_dt)
events['eid'] = eids
dstore['events'] = events
# store the GMFs
dic = general.group_array(array.view(gmf_data_dt), 'sid')
lst = []
offset = 0
for sid in sids:
n = len(dic.get(sid, []))
lst.append((offset, offset + n))
if n:
offset += n
gmvs = dic[sid]
gmvs['eid'] = get_idxs(gmvs, eid2idx)
gmvs['rlzi'] = 0 # effectively there is only 1 realization
dstore.extend('gmf_data/data', gmvs)
dstore['gmf_data/indices'] = numpy.array(lst, U32)
dstore['gmf_data/imts'] = ' '.join(imts)
sig_eps_dt = [('eid', U64), ('sig', (F32, n_imts)), ('eps', (F32, n_imts))]
dstore['gmf_data/sigma_epsilon'] = numpy.zeros(0, sig_eps_dt)
dstore['weights'] = numpy.ones((1, n_imts))
return eids | python | def import_gmfs(dstore, fname, sids):
"""
Import in the datastore a ground motion field CSV file.
:param dstore: the datastore
:param fname: the CSV file
:param sids: the site IDs (complete)
:returns: event_ids, num_rlzs
"""
array = writers.read_composite_array(fname).array
# has header rlzi, sid, eid, gmv_PGA, ...
imts = [name[4:] for name in array.dtype.names[3:]]
n_imts = len(imts)
gmf_data_dt = numpy.dtype(
[('rlzi', U16), ('sid', U32), ('eid', U64), ('gmv', (F32, (n_imts,)))])
# store the events
eids = numpy.unique(array['eid'])
eids.sort()
E = len(eids)
eid2idx = dict(zip(eids, range(E)))
events = numpy.zeros(E, rupture.events_dt)
events['eid'] = eids
dstore['events'] = events
# store the GMFs
dic = general.group_array(array.view(gmf_data_dt), 'sid')
lst = []
offset = 0
for sid in sids:
n = len(dic.get(sid, []))
lst.append((offset, offset + n))
if n:
offset += n
gmvs = dic[sid]
gmvs['eid'] = get_idxs(gmvs, eid2idx)
gmvs['rlzi'] = 0 # effectively there is only 1 realization
dstore.extend('gmf_data/data', gmvs)
dstore['gmf_data/indices'] = numpy.array(lst, U32)
dstore['gmf_data/imts'] = ' '.join(imts)
sig_eps_dt = [('eid', U64), ('sig', (F32, n_imts)), ('eps', (F32, n_imts))]
dstore['gmf_data/sigma_epsilon'] = numpy.zeros(0, sig_eps_dt)
dstore['weights'] = numpy.ones((1, n_imts))
return eids | [
"def",
"import_gmfs",
"(",
"dstore",
",",
"fname",
",",
"sids",
")",
":",
"array",
"=",
"writers",
".",
"read_composite_array",
"(",
"fname",
")",
".",
"array",
"# has header rlzi, sid, eid, gmv_PGA, ...",
"imts",
"=",
"[",
"name",
"[",
"4",
":",
"]",
"for",
"name",
"in",
"array",
".",
"dtype",
".",
"names",
"[",
"3",
":",
"]",
"]",
"n_imts",
"=",
"len",
"(",
"imts",
")",
"gmf_data_dt",
"=",
"numpy",
".",
"dtype",
"(",
"[",
"(",
"'rlzi'",
",",
"U16",
")",
",",
"(",
"'sid'",
",",
"U32",
")",
",",
"(",
"'eid'",
",",
"U64",
")",
",",
"(",
"'gmv'",
",",
"(",
"F32",
",",
"(",
"n_imts",
",",
")",
")",
")",
"]",
")",
"# store the events",
"eids",
"=",
"numpy",
".",
"unique",
"(",
"array",
"[",
"'eid'",
"]",
")",
"eids",
".",
"sort",
"(",
")",
"E",
"=",
"len",
"(",
"eids",
")",
"eid2idx",
"=",
"dict",
"(",
"zip",
"(",
"eids",
",",
"range",
"(",
"E",
")",
")",
")",
"events",
"=",
"numpy",
".",
"zeros",
"(",
"E",
",",
"rupture",
".",
"events_dt",
")",
"events",
"[",
"'eid'",
"]",
"=",
"eids",
"dstore",
"[",
"'events'",
"]",
"=",
"events",
"# store the GMFs",
"dic",
"=",
"general",
".",
"group_array",
"(",
"array",
".",
"view",
"(",
"gmf_data_dt",
")",
",",
"'sid'",
")",
"lst",
"=",
"[",
"]",
"offset",
"=",
"0",
"for",
"sid",
"in",
"sids",
":",
"n",
"=",
"len",
"(",
"dic",
".",
"get",
"(",
"sid",
",",
"[",
"]",
")",
")",
"lst",
".",
"append",
"(",
"(",
"offset",
",",
"offset",
"+",
"n",
")",
")",
"if",
"n",
":",
"offset",
"+=",
"n",
"gmvs",
"=",
"dic",
"[",
"sid",
"]",
"gmvs",
"[",
"'eid'",
"]",
"=",
"get_idxs",
"(",
"gmvs",
",",
"eid2idx",
")",
"gmvs",
"[",
"'rlzi'",
"]",
"=",
"0",
"# effectively there is only 1 realization",
"dstore",
".",
"extend",
"(",
"'gmf_data/data'",
",",
"gmvs",
")",
"dstore",
"[",
"'gmf_data/indices'",
"]",
"=",
"numpy",
".",
"array",
"(",
"lst",
",",
"U32",
")",
"dstore",
"[",
"'gmf_data/imts'",
"]",
"=",
"' '",
".",
"join",
"(",
"imts",
")",
"sig_eps_dt",
"=",
"[",
"(",
"'eid'",
",",
"U64",
")",
",",
"(",
"'sig'",
",",
"(",
"F32",
",",
"n_imts",
")",
")",
",",
"(",
"'eps'",
",",
"(",
"F32",
",",
"n_imts",
")",
")",
"]",
"dstore",
"[",
"'gmf_data/sigma_epsilon'",
"]",
"=",
"numpy",
".",
"zeros",
"(",
"0",
",",
"sig_eps_dt",
")",
"dstore",
"[",
"'weights'",
"]",
"=",
"numpy",
".",
"ones",
"(",
"(",
"1",
",",
"n_imts",
")",
")",
"return",
"eids"
] | Import in the datastore a ground motion field CSV file.
:param dstore: the datastore
:param fname: the CSV file
:param sids: the site IDs (complete)
:returns: event_ids, num_rlzs | [
"Import",
"in",
"the",
"datastore",
"a",
"ground",
"motion",
"field",
"CSV",
"file",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L972-L1013 |
44 | gem/oq-engine | openquake/calculators/base.py | BaseCalculator.save_params | def save_params(self, **kw):
"""
Update the current calculation parameters and save engine_version
"""
if ('hazard_calculation_id' in kw and
kw['hazard_calculation_id'] is None):
del kw['hazard_calculation_id']
vars(self.oqparam).update(**kw)
self.datastore['oqparam'] = self.oqparam # save the updated oqparam
attrs = self.datastore['/'].attrs
attrs['engine_version'] = engine_version
attrs['date'] = datetime.now().isoformat()[:19]
if 'checksum32' not in attrs:
attrs['checksum32'] = readinput.get_checksum32(self.oqparam)
self.datastore.flush() | python | def save_params(self, **kw):
"""
Update the current calculation parameters and save engine_version
"""
if ('hazard_calculation_id' in kw and
kw['hazard_calculation_id'] is None):
del kw['hazard_calculation_id']
vars(self.oqparam).update(**kw)
self.datastore['oqparam'] = self.oqparam # save the updated oqparam
attrs = self.datastore['/'].attrs
attrs['engine_version'] = engine_version
attrs['date'] = datetime.now().isoformat()[:19]
if 'checksum32' not in attrs:
attrs['checksum32'] = readinput.get_checksum32(self.oqparam)
self.datastore.flush() | [
"def",
"save_params",
"(",
"self",
",",
"*",
"*",
"kw",
")",
":",
"if",
"(",
"'hazard_calculation_id'",
"in",
"kw",
"and",
"kw",
"[",
"'hazard_calculation_id'",
"]",
"is",
"None",
")",
":",
"del",
"kw",
"[",
"'hazard_calculation_id'",
"]",
"vars",
"(",
"self",
".",
"oqparam",
")",
".",
"update",
"(",
"*",
"*",
"kw",
")",
"self",
".",
"datastore",
"[",
"'oqparam'",
"]",
"=",
"self",
".",
"oqparam",
"# save the updated oqparam",
"attrs",
"=",
"self",
".",
"datastore",
"[",
"'/'",
"]",
".",
"attrs",
"attrs",
"[",
"'engine_version'",
"]",
"=",
"engine_version",
"attrs",
"[",
"'date'",
"]",
"=",
"datetime",
".",
"now",
"(",
")",
".",
"isoformat",
"(",
")",
"[",
":",
"19",
"]",
"if",
"'checksum32'",
"not",
"in",
"attrs",
":",
"attrs",
"[",
"'checksum32'",
"]",
"=",
"readinput",
".",
"get_checksum32",
"(",
"self",
".",
"oqparam",
")",
"self",
".",
"datastore",
".",
"flush",
"(",
")"
] | Update the current calculation parameters and save engine_version | [
"Update",
"the",
"current",
"calculation",
"parameters",
"and",
"save",
"engine_version"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L142-L156 |
45 | gem/oq-engine | openquake/calculators/base.py | BaseCalculator.run | def run(self, pre_execute=True, concurrent_tasks=None, close=True, **kw):
"""
Run the calculation and return the exported outputs.
"""
with self._monitor:
self._monitor.username = kw.get('username', '')
self._monitor.hdf5 = self.datastore.hdf5
if concurrent_tasks is None: # use the job.ini parameter
ct = self.oqparam.concurrent_tasks
else: # used the parameter passed in the command-line
ct = concurrent_tasks
if ct == 0: # disable distribution temporarily
oq_distribute = os.environ.get('OQ_DISTRIBUTE')
os.environ['OQ_DISTRIBUTE'] = 'no'
if ct != self.oqparam.concurrent_tasks:
# save the used concurrent_tasks
self.oqparam.concurrent_tasks = ct
self.save_params(**kw)
try:
if pre_execute:
self.pre_execute()
self.result = self.execute()
if self.result is not None:
self.post_execute(self.result)
self.before_export()
self.export(kw.get('exports', ''))
except Exception:
if kw.get('pdb'): # post-mortem debug
tb = sys.exc_info()[2]
traceback.print_tb(tb)
pdb.post_mortem(tb)
else:
logging.critical('', exc_info=True)
raise
finally:
# cleanup globals
if ct == 0: # restore OQ_DISTRIBUTE
if oq_distribute is None: # was not set
del os.environ['OQ_DISTRIBUTE']
else:
os.environ['OQ_DISTRIBUTE'] = oq_distribute
readinput.pmap = None
readinput.exposure = None
readinput.gmfs = None
readinput.eids = None
self._monitor.flush()
if close: # in the engine we close later
self.result = None
try:
self.datastore.close()
except (RuntimeError, ValueError):
# sometimes produces errors but they are difficult to
# reproduce
logging.warning('', exc_info=True)
return getattr(self, 'exported', {}) | python | def run(self, pre_execute=True, concurrent_tasks=None, close=True, **kw):
"""
Run the calculation and return the exported outputs.
"""
with self._monitor:
self._monitor.username = kw.get('username', '')
self._monitor.hdf5 = self.datastore.hdf5
if concurrent_tasks is None: # use the job.ini parameter
ct = self.oqparam.concurrent_tasks
else: # used the parameter passed in the command-line
ct = concurrent_tasks
if ct == 0: # disable distribution temporarily
oq_distribute = os.environ.get('OQ_DISTRIBUTE')
os.environ['OQ_DISTRIBUTE'] = 'no'
if ct != self.oqparam.concurrent_tasks:
# save the used concurrent_tasks
self.oqparam.concurrent_tasks = ct
self.save_params(**kw)
try:
if pre_execute:
self.pre_execute()
self.result = self.execute()
if self.result is not None:
self.post_execute(self.result)
self.before_export()
self.export(kw.get('exports', ''))
except Exception:
if kw.get('pdb'): # post-mortem debug
tb = sys.exc_info()[2]
traceback.print_tb(tb)
pdb.post_mortem(tb)
else:
logging.critical('', exc_info=True)
raise
finally:
# cleanup globals
if ct == 0: # restore OQ_DISTRIBUTE
if oq_distribute is None: # was not set
del os.environ['OQ_DISTRIBUTE']
else:
os.environ['OQ_DISTRIBUTE'] = oq_distribute
readinput.pmap = None
readinput.exposure = None
readinput.gmfs = None
readinput.eids = None
self._monitor.flush()
if close: # in the engine we close later
self.result = None
try:
self.datastore.close()
except (RuntimeError, ValueError):
# sometimes produces errors but they are difficult to
# reproduce
logging.warning('', exc_info=True)
return getattr(self, 'exported', {}) | [
"def",
"run",
"(",
"self",
",",
"pre_execute",
"=",
"True",
",",
"concurrent_tasks",
"=",
"None",
",",
"close",
"=",
"True",
",",
"*",
"*",
"kw",
")",
":",
"with",
"self",
".",
"_monitor",
":",
"self",
".",
"_monitor",
".",
"username",
"=",
"kw",
".",
"get",
"(",
"'username'",
",",
"''",
")",
"self",
".",
"_monitor",
".",
"hdf5",
"=",
"self",
".",
"datastore",
".",
"hdf5",
"if",
"concurrent_tasks",
"is",
"None",
":",
"# use the job.ini parameter",
"ct",
"=",
"self",
".",
"oqparam",
".",
"concurrent_tasks",
"else",
":",
"# used the parameter passed in the command-line",
"ct",
"=",
"concurrent_tasks",
"if",
"ct",
"==",
"0",
":",
"# disable distribution temporarily",
"oq_distribute",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"'OQ_DISTRIBUTE'",
")",
"os",
".",
"environ",
"[",
"'OQ_DISTRIBUTE'",
"]",
"=",
"'no'",
"if",
"ct",
"!=",
"self",
".",
"oqparam",
".",
"concurrent_tasks",
":",
"# save the used concurrent_tasks",
"self",
".",
"oqparam",
".",
"concurrent_tasks",
"=",
"ct",
"self",
".",
"save_params",
"(",
"*",
"*",
"kw",
")",
"try",
":",
"if",
"pre_execute",
":",
"self",
".",
"pre_execute",
"(",
")",
"self",
".",
"result",
"=",
"self",
".",
"execute",
"(",
")",
"if",
"self",
".",
"result",
"is",
"not",
"None",
":",
"self",
".",
"post_execute",
"(",
"self",
".",
"result",
")",
"self",
".",
"before_export",
"(",
")",
"self",
".",
"export",
"(",
"kw",
".",
"get",
"(",
"'exports'",
",",
"''",
")",
")",
"except",
"Exception",
":",
"if",
"kw",
".",
"get",
"(",
"'pdb'",
")",
":",
"# post-mortem debug",
"tb",
"=",
"sys",
".",
"exc_info",
"(",
")",
"[",
"2",
"]",
"traceback",
".",
"print_tb",
"(",
"tb",
")",
"pdb",
".",
"post_mortem",
"(",
"tb",
")",
"else",
":",
"logging",
".",
"critical",
"(",
"''",
",",
"exc_info",
"=",
"True",
")",
"raise",
"finally",
":",
"# cleanup globals",
"if",
"ct",
"==",
"0",
":",
"# restore OQ_DISTRIBUTE",
"if",
"oq_distribute",
"is",
"None",
":",
"# was not set",
"del",
"os",
".",
"environ",
"[",
"'OQ_DISTRIBUTE'",
"]",
"else",
":",
"os",
".",
"environ",
"[",
"'OQ_DISTRIBUTE'",
"]",
"=",
"oq_distribute",
"readinput",
".",
"pmap",
"=",
"None",
"readinput",
".",
"exposure",
"=",
"None",
"readinput",
".",
"gmfs",
"=",
"None",
"readinput",
".",
"eids",
"=",
"None",
"self",
".",
"_monitor",
".",
"flush",
"(",
")",
"if",
"close",
":",
"# in the engine we close later",
"self",
".",
"result",
"=",
"None",
"try",
":",
"self",
".",
"datastore",
".",
"close",
"(",
")",
"except",
"(",
"RuntimeError",
",",
"ValueError",
")",
":",
"# sometimes produces errors but they are difficult to",
"# reproduce",
"logging",
".",
"warning",
"(",
"''",
",",
"exc_info",
"=",
"True",
")",
"return",
"getattr",
"(",
"self",
",",
"'exported'",
",",
"{",
"}",
")"
] | Run the calculation and return the exported outputs. | [
"Run",
"the",
"calculation",
"and",
"return",
"the",
"exported",
"outputs",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L175-L231 |
46 | gem/oq-engine | openquake/calculators/base.py | BaseCalculator.export | def export(self, exports=None):
"""
Export all the outputs in the datastore in the given export formats.
Individual outputs are not exported if there are multiple realizations.
"""
self.exported = getattr(self.precalc, 'exported', {})
if isinstance(exports, tuple):
fmts = exports
elif exports: # is a string
fmts = exports.split(',')
elif isinstance(self.oqparam.exports, tuple):
fmts = self.oqparam.exports
else: # is a string
fmts = self.oqparam.exports.split(',')
keys = set(self.datastore)
has_hcurves = ('hcurves-stats' in self.datastore or
'hcurves-rlzs' in self.datastore)
if has_hcurves:
keys.add('hcurves')
for fmt in fmts:
if not fmt:
continue
for key in sorted(keys): # top level keys
if 'rlzs' in key and self.R > 1:
continue # skip individual curves
self._export((key, fmt))
if has_hcurves and self.oqparam.hazard_maps:
self._export(('hmaps', fmt))
if has_hcurves and self.oqparam.uniform_hazard_spectra:
self._export(('uhs', fmt)) | python | def export(self, exports=None):
"""
Export all the outputs in the datastore in the given export formats.
Individual outputs are not exported if there are multiple realizations.
"""
self.exported = getattr(self.precalc, 'exported', {})
if isinstance(exports, tuple):
fmts = exports
elif exports: # is a string
fmts = exports.split(',')
elif isinstance(self.oqparam.exports, tuple):
fmts = self.oqparam.exports
else: # is a string
fmts = self.oqparam.exports.split(',')
keys = set(self.datastore)
has_hcurves = ('hcurves-stats' in self.datastore or
'hcurves-rlzs' in self.datastore)
if has_hcurves:
keys.add('hcurves')
for fmt in fmts:
if not fmt:
continue
for key in sorted(keys): # top level keys
if 'rlzs' in key and self.R > 1:
continue # skip individual curves
self._export((key, fmt))
if has_hcurves and self.oqparam.hazard_maps:
self._export(('hmaps', fmt))
if has_hcurves and self.oqparam.uniform_hazard_spectra:
self._export(('uhs', fmt)) | [
"def",
"export",
"(",
"self",
",",
"exports",
"=",
"None",
")",
":",
"self",
".",
"exported",
"=",
"getattr",
"(",
"self",
".",
"precalc",
",",
"'exported'",
",",
"{",
"}",
")",
"if",
"isinstance",
"(",
"exports",
",",
"tuple",
")",
":",
"fmts",
"=",
"exports",
"elif",
"exports",
":",
"# is a string",
"fmts",
"=",
"exports",
".",
"split",
"(",
"','",
")",
"elif",
"isinstance",
"(",
"self",
".",
"oqparam",
".",
"exports",
",",
"tuple",
")",
":",
"fmts",
"=",
"self",
".",
"oqparam",
".",
"exports",
"else",
":",
"# is a string",
"fmts",
"=",
"self",
".",
"oqparam",
".",
"exports",
".",
"split",
"(",
"','",
")",
"keys",
"=",
"set",
"(",
"self",
".",
"datastore",
")",
"has_hcurves",
"=",
"(",
"'hcurves-stats'",
"in",
"self",
".",
"datastore",
"or",
"'hcurves-rlzs'",
"in",
"self",
".",
"datastore",
")",
"if",
"has_hcurves",
":",
"keys",
".",
"add",
"(",
"'hcurves'",
")",
"for",
"fmt",
"in",
"fmts",
":",
"if",
"not",
"fmt",
":",
"continue",
"for",
"key",
"in",
"sorted",
"(",
"keys",
")",
":",
"# top level keys",
"if",
"'rlzs'",
"in",
"key",
"and",
"self",
".",
"R",
">",
"1",
":",
"continue",
"# skip individual curves",
"self",
".",
"_export",
"(",
"(",
"key",
",",
"fmt",
")",
")",
"if",
"has_hcurves",
"and",
"self",
".",
"oqparam",
".",
"hazard_maps",
":",
"self",
".",
"_export",
"(",
"(",
"'hmaps'",
",",
"fmt",
")",
")",
"if",
"has_hcurves",
"and",
"self",
".",
"oqparam",
".",
"uniform_hazard_spectra",
":",
"self",
".",
"_export",
"(",
"(",
"'uhs'",
",",
"fmt",
")",
")"
] | Export all the outputs in the datastore in the given export formats.
Individual outputs are not exported if there are multiple realizations. | [
"Export",
"all",
"the",
"outputs",
"in",
"the",
"datastore",
"in",
"the",
"given",
"export",
"formats",
".",
"Individual",
"outputs",
"are",
"not",
"exported",
"if",
"there",
"are",
"multiple",
"realizations",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L260-L289 |
47 | gem/oq-engine | openquake/calculators/base.py | BaseCalculator.before_export | def before_export(self):
"""
Set the attributes nbytes
"""
# sanity check that eff_ruptures have been set, i.e. are not -1
try:
csm_info = self.datastore['csm_info']
except KeyError:
csm_info = self.datastore['csm_info'] = self.csm.info
for sm in csm_info.source_models:
for sg in sm.src_groups:
assert sg.eff_ruptures != -1, sg
for key in self.datastore:
self.datastore.set_nbytes(key)
self.datastore.flush() | python | def before_export(self):
"""
Set the attributes nbytes
"""
# sanity check that eff_ruptures have been set, i.e. are not -1
try:
csm_info = self.datastore['csm_info']
except KeyError:
csm_info = self.datastore['csm_info'] = self.csm.info
for sm in csm_info.source_models:
for sg in sm.src_groups:
assert sg.eff_ruptures != -1, sg
for key in self.datastore:
self.datastore.set_nbytes(key)
self.datastore.flush() | [
"def",
"before_export",
"(",
"self",
")",
":",
"# sanity check that eff_ruptures have been set, i.e. are not -1",
"try",
":",
"csm_info",
"=",
"self",
".",
"datastore",
"[",
"'csm_info'",
"]",
"except",
"KeyError",
":",
"csm_info",
"=",
"self",
".",
"datastore",
"[",
"'csm_info'",
"]",
"=",
"self",
".",
"csm",
".",
"info",
"for",
"sm",
"in",
"csm_info",
".",
"source_models",
":",
"for",
"sg",
"in",
"sm",
".",
"src_groups",
":",
"assert",
"sg",
".",
"eff_ruptures",
"!=",
"-",
"1",
",",
"sg",
"for",
"key",
"in",
"self",
".",
"datastore",
":",
"self",
".",
"datastore",
".",
"set_nbytes",
"(",
"key",
")",
"self",
".",
"datastore",
".",
"flush",
"(",
")"
] | Set the attributes nbytes | [
"Set",
"the",
"attributes",
"nbytes"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L303-L318 |
48 | gem/oq-engine | openquake/calculators/base.py | HazardCalculator.read_inputs | def read_inputs(self):
"""
Read risk data and sources if any
"""
oq = self.oqparam
self._read_risk_data()
self.check_overflow() # check if self.sitecol is too large
if ('source_model_logic_tree' in oq.inputs and
oq.hazard_calculation_id is None):
self.csm = readinput.get_composite_source_model(
oq, self.monitor(), srcfilter=self.src_filter)
self.init() | python | def read_inputs(self):
"""
Read risk data and sources if any
"""
oq = self.oqparam
self._read_risk_data()
self.check_overflow() # check if self.sitecol is too large
if ('source_model_logic_tree' in oq.inputs and
oq.hazard_calculation_id is None):
self.csm = readinput.get_composite_source_model(
oq, self.monitor(), srcfilter=self.src_filter)
self.init() | [
"def",
"read_inputs",
"(",
"self",
")",
":",
"oq",
"=",
"self",
".",
"oqparam",
"self",
".",
"_read_risk_data",
"(",
")",
"self",
".",
"check_overflow",
"(",
")",
"# check if self.sitecol is too large",
"if",
"(",
"'source_model_logic_tree'",
"in",
"oq",
".",
"inputs",
"and",
"oq",
".",
"hazard_calculation_id",
"is",
"None",
")",
":",
"self",
".",
"csm",
"=",
"readinput",
".",
"get_composite_source_model",
"(",
"oq",
",",
"self",
".",
"monitor",
"(",
")",
",",
"srcfilter",
"=",
"self",
".",
"src_filter",
")",
"self",
".",
"init",
"(",
")"
] | Read risk data and sources if any | [
"Read",
"risk",
"data",
"and",
"sources",
"if",
"any"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L406-L417 |
49 | gem/oq-engine | openquake/calculators/base.py | HazardCalculator.pre_execute | def pre_execute(self):
"""
Check if there is a previous calculation ID.
If yes, read the inputs by retrieving the previous calculation;
if not, read the inputs directly.
"""
oq = self.oqparam
if 'gmfs' in oq.inputs or 'multi_peril' in oq.inputs:
# read hazard from files
assert not oq.hazard_calculation_id, (
'You cannot use --hc together with gmfs_file')
self.read_inputs()
if 'gmfs' in oq.inputs:
save_gmfs(self)
else:
self.save_multi_peril()
elif 'hazard_curves' in oq.inputs: # read hazard from file
assert not oq.hazard_calculation_id, (
'You cannot use --hc together with hazard_curves')
haz_sitecol = readinput.get_site_collection(oq)
# NB: horrible: get_site_collection calls get_pmap_from_nrml
# that sets oq.investigation_time, so it must be called first
self.load_riskmodel() # must be after get_site_collection
self.read_exposure(haz_sitecol) # define .assets_by_site
self.datastore['poes/grp-00'] = fix_ones(readinput.pmap)
self.datastore['sitecol'] = self.sitecol
self.datastore['assetcol'] = self.assetcol
self.datastore['csm_info'] = fake = source.CompositionInfo.fake()
self.rlzs_assoc = fake.get_rlzs_assoc()
elif oq.hazard_calculation_id:
parent = util.read(oq.hazard_calculation_id)
self.check_precalc(parent['oqparam'].calculation_mode)
self.datastore.parent = parent
# copy missing parameters from the parent
params = {name: value for name, value in
vars(parent['oqparam']).items()
if name not in vars(self.oqparam)}
self.save_params(**params)
self.read_inputs()
oqp = parent['oqparam']
if oqp.investigation_time != oq.investigation_time:
raise ValueError(
'The parent calculation was using investigation_time=%s'
' != %s' % (oqp.investigation_time, oq.investigation_time))
if oqp.minimum_intensity != oq.minimum_intensity:
raise ValueError(
'The parent calculation was using minimum_intensity=%s'
' != %s' % (oqp.minimum_intensity, oq.minimum_intensity))
missing_imts = set(oq.risk_imtls) - set(oqp.imtls)
if missing_imts:
raise ValueError(
'The parent calculation is missing the IMT(s) %s' %
', '.join(missing_imts))
elif self.__class__.precalc:
calc = calculators[self.__class__.precalc](
self.oqparam, self.datastore.calc_id)
calc.run()
self.param = calc.param
self.sitecol = calc.sitecol
self.assetcol = calc.assetcol
self.riskmodel = calc.riskmodel
if hasattr(calc, 'rlzs_assoc'):
self.rlzs_assoc = calc.rlzs_assoc
else:
# this happens for instance for a scenario_damage without
# rupture, gmfs, multi_peril
raise InvalidFile(
'%(job_ini)s: missing gmfs_csv, multi_peril_csv' %
oq.inputs)
if hasattr(calc, 'csm'): # no scenario
self.csm = calc.csm
else:
self.read_inputs()
if self.riskmodel:
self.save_riskmodel() | python | def pre_execute(self):
"""
Check if there is a previous calculation ID.
If yes, read the inputs by retrieving the previous calculation;
if not, read the inputs directly.
"""
oq = self.oqparam
if 'gmfs' in oq.inputs or 'multi_peril' in oq.inputs:
# read hazard from files
assert not oq.hazard_calculation_id, (
'You cannot use --hc together with gmfs_file')
self.read_inputs()
if 'gmfs' in oq.inputs:
save_gmfs(self)
else:
self.save_multi_peril()
elif 'hazard_curves' in oq.inputs: # read hazard from file
assert not oq.hazard_calculation_id, (
'You cannot use --hc together with hazard_curves')
haz_sitecol = readinput.get_site_collection(oq)
# NB: horrible: get_site_collection calls get_pmap_from_nrml
# that sets oq.investigation_time, so it must be called first
self.load_riskmodel() # must be after get_site_collection
self.read_exposure(haz_sitecol) # define .assets_by_site
self.datastore['poes/grp-00'] = fix_ones(readinput.pmap)
self.datastore['sitecol'] = self.sitecol
self.datastore['assetcol'] = self.assetcol
self.datastore['csm_info'] = fake = source.CompositionInfo.fake()
self.rlzs_assoc = fake.get_rlzs_assoc()
elif oq.hazard_calculation_id:
parent = util.read(oq.hazard_calculation_id)
self.check_precalc(parent['oqparam'].calculation_mode)
self.datastore.parent = parent
# copy missing parameters from the parent
params = {name: value for name, value in
vars(parent['oqparam']).items()
if name not in vars(self.oqparam)}
self.save_params(**params)
self.read_inputs()
oqp = parent['oqparam']
if oqp.investigation_time != oq.investigation_time:
raise ValueError(
'The parent calculation was using investigation_time=%s'
' != %s' % (oqp.investigation_time, oq.investigation_time))
if oqp.minimum_intensity != oq.minimum_intensity:
raise ValueError(
'The parent calculation was using minimum_intensity=%s'
' != %s' % (oqp.minimum_intensity, oq.minimum_intensity))
missing_imts = set(oq.risk_imtls) - set(oqp.imtls)
if missing_imts:
raise ValueError(
'The parent calculation is missing the IMT(s) %s' %
', '.join(missing_imts))
elif self.__class__.precalc:
calc = calculators[self.__class__.precalc](
self.oqparam, self.datastore.calc_id)
calc.run()
self.param = calc.param
self.sitecol = calc.sitecol
self.assetcol = calc.assetcol
self.riskmodel = calc.riskmodel
if hasattr(calc, 'rlzs_assoc'):
self.rlzs_assoc = calc.rlzs_assoc
else:
# this happens for instance for a scenario_damage without
# rupture, gmfs, multi_peril
raise InvalidFile(
'%(job_ini)s: missing gmfs_csv, multi_peril_csv' %
oq.inputs)
if hasattr(calc, 'csm'): # no scenario
self.csm = calc.csm
else:
self.read_inputs()
if self.riskmodel:
self.save_riskmodel() | [
"def",
"pre_execute",
"(",
"self",
")",
":",
"oq",
"=",
"self",
".",
"oqparam",
"if",
"'gmfs'",
"in",
"oq",
".",
"inputs",
"or",
"'multi_peril'",
"in",
"oq",
".",
"inputs",
":",
"# read hazard from files",
"assert",
"not",
"oq",
".",
"hazard_calculation_id",
",",
"(",
"'You cannot use --hc together with gmfs_file'",
")",
"self",
".",
"read_inputs",
"(",
")",
"if",
"'gmfs'",
"in",
"oq",
".",
"inputs",
":",
"save_gmfs",
"(",
"self",
")",
"else",
":",
"self",
".",
"save_multi_peril",
"(",
")",
"elif",
"'hazard_curves'",
"in",
"oq",
".",
"inputs",
":",
"# read hazard from file",
"assert",
"not",
"oq",
".",
"hazard_calculation_id",
",",
"(",
"'You cannot use --hc together with hazard_curves'",
")",
"haz_sitecol",
"=",
"readinput",
".",
"get_site_collection",
"(",
"oq",
")",
"# NB: horrible: get_site_collection calls get_pmap_from_nrml",
"# that sets oq.investigation_time, so it must be called first",
"self",
".",
"load_riskmodel",
"(",
")",
"# must be after get_site_collection",
"self",
".",
"read_exposure",
"(",
"haz_sitecol",
")",
"# define .assets_by_site",
"self",
".",
"datastore",
"[",
"'poes/grp-00'",
"]",
"=",
"fix_ones",
"(",
"readinput",
".",
"pmap",
")",
"self",
".",
"datastore",
"[",
"'sitecol'",
"]",
"=",
"self",
".",
"sitecol",
"self",
".",
"datastore",
"[",
"'assetcol'",
"]",
"=",
"self",
".",
"assetcol",
"self",
".",
"datastore",
"[",
"'csm_info'",
"]",
"=",
"fake",
"=",
"source",
".",
"CompositionInfo",
".",
"fake",
"(",
")",
"self",
".",
"rlzs_assoc",
"=",
"fake",
".",
"get_rlzs_assoc",
"(",
")",
"elif",
"oq",
".",
"hazard_calculation_id",
":",
"parent",
"=",
"util",
".",
"read",
"(",
"oq",
".",
"hazard_calculation_id",
")",
"self",
".",
"check_precalc",
"(",
"parent",
"[",
"'oqparam'",
"]",
".",
"calculation_mode",
")",
"self",
".",
"datastore",
".",
"parent",
"=",
"parent",
"# copy missing parameters from the parent",
"params",
"=",
"{",
"name",
":",
"value",
"for",
"name",
",",
"value",
"in",
"vars",
"(",
"parent",
"[",
"'oqparam'",
"]",
")",
".",
"items",
"(",
")",
"if",
"name",
"not",
"in",
"vars",
"(",
"self",
".",
"oqparam",
")",
"}",
"self",
".",
"save_params",
"(",
"*",
"*",
"params",
")",
"self",
".",
"read_inputs",
"(",
")",
"oqp",
"=",
"parent",
"[",
"'oqparam'",
"]",
"if",
"oqp",
".",
"investigation_time",
"!=",
"oq",
".",
"investigation_time",
":",
"raise",
"ValueError",
"(",
"'The parent calculation was using investigation_time=%s'",
"' != %s'",
"%",
"(",
"oqp",
".",
"investigation_time",
",",
"oq",
".",
"investigation_time",
")",
")",
"if",
"oqp",
".",
"minimum_intensity",
"!=",
"oq",
".",
"minimum_intensity",
":",
"raise",
"ValueError",
"(",
"'The parent calculation was using minimum_intensity=%s'",
"' != %s'",
"%",
"(",
"oqp",
".",
"minimum_intensity",
",",
"oq",
".",
"minimum_intensity",
")",
")",
"missing_imts",
"=",
"set",
"(",
"oq",
".",
"risk_imtls",
")",
"-",
"set",
"(",
"oqp",
".",
"imtls",
")",
"if",
"missing_imts",
":",
"raise",
"ValueError",
"(",
"'The parent calculation is missing the IMT(s) %s'",
"%",
"', '",
".",
"join",
"(",
"missing_imts",
")",
")",
"elif",
"self",
".",
"__class__",
".",
"precalc",
":",
"calc",
"=",
"calculators",
"[",
"self",
".",
"__class__",
".",
"precalc",
"]",
"(",
"self",
".",
"oqparam",
",",
"self",
".",
"datastore",
".",
"calc_id",
")",
"calc",
".",
"run",
"(",
")",
"self",
".",
"param",
"=",
"calc",
".",
"param",
"self",
".",
"sitecol",
"=",
"calc",
".",
"sitecol",
"self",
".",
"assetcol",
"=",
"calc",
".",
"assetcol",
"self",
".",
"riskmodel",
"=",
"calc",
".",
"riskmodel",
"if",
"hasattr",
"(",
"calc",
",",
"'rlzs_assoc'",
")",
":",
"self",
".",
"rlzs_assoc",
"=",
"calc",
".",
"rlzs_assoc",
"else",
":",
"# this happens for instance for a scenario_damage without",
"# rupture, gmfs, multi_peril",
"raise",
"InvalidFile",
"(",
"'%(job_ini)s: missing gmfs_csv, multi_peril_csv'",
"%",
"oq",
".",
"inputs",
")",
"if",
"hasattr",
"(",
"calc",
",",
"'csm'",
")",
":",
"# no scenario",
"self",
".",
"csm",
"=",
"calc",
".",
"csm",
"else",
":",
"self",
".",
"read_inputs",
"(",
")",
"if",
"self",
".",
"riskmodel",
":",
"self",
".",
"save_riskmodel",
"(",
")"
] | Check if there is a previous calculation ID.
If yes, read the inputs by retrieving the previous calculation;
if not, read the inputs directly. | [
"Check",
"if",
"there",
"is",
"a",
"previous",
"calculation",
"ID",
".",
"If",
"yes",
"read",
"the",
"inputs",
"by",
"retrieving",
"the",
"previous",
"calculation",
";",
"if",
"not",
"read",
"the",
"inputs",
"directly",
"."
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L422-L496 |
50 | gem/oq-engine | openquake/calculators/base.py | HazardCalculator.init | def init(self):
"""
To be overridden to initialize the datasets needed by the calculation
"""
oq = self.oqparam
if not oq.risk_imtls:
if self.datastore.parent:
oq.risk_imtls = (
self.datastore.parent['oqparam'].risk_imtls)
if 'precalc' in vars(self):
self.rlzs_assoc = self.precalc.rlzs_assoc
elif 'csm_info' in self.datastore:
csm_info = self.datastore['csm_info']
if oq.hazard_calculation_id and 'gsim_logic_tree' in oq.inputs:
# redefine the realizations by reading the weights from the
# gsim_logic_tree_file that could be different from the parent
csm_info.gsim_lt = logictree.GsimLogicTree(
oq.inputs['gsim_logic_tree'], set(csm_info.trts))
self.rlzs_assoc = csm_info.get_rlzs_assoc()
elif hasattr(self, 'csm'):
self.check_floating_spinning()
self.rlzs_assoc = self.csm.info.get_rlzs_assoc()
else: # build a fake; used by risk-from-file calculators
self.datastore['csm_info'] = fake = source.CompositionInfo.fake()
self.rlzs_assoc = fake.get_rlzs_assoc() | python | def init(self):
"""
To be overridden to initialize the datasets needed by the calculation
"""
oq = self.oqparam
if not oq.risk_imtls:
if self.datastore.parent:
oq.risk_imtls = (
self.datastore.parent['oqparam'].risk_imtls)
if 'precalc' in vars(self):
self.rlzs_assoc = self.precalc.rlzs_assoc
elif 'csm_info' in self.datastore:
csm_info = self.datastore['csm_info']
if oq.hazard_calculation_id and 'gsim_logic_tree' in oq.inputs:
# redefine the realizations by reading the weights from the
# gsim_logic_tree_file that could be different from the parent
csm_info.gsim_lt = logictree.GsimLogicTree(
oq.inputs['gsim_logic_tree'], set(csm_info.trts))
self.rlzs_assoc = csm_info.get_rlzs_assoc()
elif hasattr(self, 'csm'):
self.check_floating_spinning()
self.rlzs_assoc = self.csm.info.get_rlzs_assoc()
else: # build a fake; used by risk-from-file calculators
self.datastore['csm_info'] = fake = source.CompositionInfo.fake()
self.rlzs_assoc = fake.get_rlzs_assoc() | [
"def",
"init",
"(",
"self",
")",
":",
"oq",
"=",
"self",
".",
"oqparam",
"if",
"not",
"oq",
".",
"risk_imtls",
":",
"if",
"self",
".",
"datastore",
".",
"parent",
":",
"oq",
".",
"risk_imtls",
"=",
"(",
"self",
".",
"datastore",
".",
"parent",
"[",
"'oqparam'",
"]",
".",
"risk_imtls",
")",
"if",
"'precalc'",
"in",
"vars",
"(",
"self",
")",
":",
"self",
".",
"rlzs_assoc",
"=",
"self",
".",
"precalc",
".",
"rlzs_assoc",
"elif",
"'csm_info'",
"in",
"self",
".",
"datastore",
":",
"csm_info",
"=",
"self",
".",
"datastore",
"[",
"'csm_info'",
"]",
"if",
"oq",
".",
"hazard_calculation_id",
"and",
"'gsim_logic_tree'",
"in",
"oq",
".",
"inputs",
":",
"# redefine the realizations by reading the weights from the",
"# gsim_logic_tree_file that could be different from the parent",
"csm_info",
".",
"gsim_lt",
"=",
"logictree",
".",
"GsimLogicTree",
"(",
"oq",
".",
"inputs",
"[",
"'gsim_logic_tree'",
"]",
",",
"set",
"(",
"csm_info",
".",
"trts",
")",
")",
"self",
".",
"rlzs_assoc",
"=",
"csm_info",
".",
"get_rlzs_assoc",
"(",
")",
"elif",
"hasattr",
"(",
"self",
",",
"'csm'",
")",
":",
"self",
".",
"check_floating_spinning",
"(",
")",
"self",
".",
"rlzs_assoc",
"=",
"self",
".",
"csm",
".",
"info",
".",
"get_rlzs_assoc",
"(",
")",
"else",
":",
"# build a fake; used by risk-from-file calculators",
"self",
".",
"datastore",
"[",
"'csm_info'",
"]",
"=",
"fake",
"=",
"source",
".",
"CompositionInfo",
".",
"fake",
"(",
")",
"self",
".",
"rlzs_assoc",
"=",
"fake",
".",
"get_rlzs_assoc",
"(",
")"
] | To be overridden to initialize the datasets needed by the calculation | [
"To",
"be",
"overridden",
"to",
"initialize",
"the",
"datasets",
"needed",
"by",
"the",
"calculation"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L498-L522 |
51 | gem/oq-engine | openquake/calculators/base.py | HazardCalculator.read_exposure | def read_exposure(self, haz_sitecol=None): # after load_risk_model
"""
Read the exposure, the riskmodel and update the attributes
.sitecol, .assetcol
"""
with self.monitor('reading exposure', autoflush=True):
self.sitecol, self.assetcol, discarded = (
readinput.get_sitecol_assetcol(
self.oqparam, haz_sitecol, self.riskmodel.loss_types))
if len(discarded):
self.datastore['discarded'] = discarded
if hasattr(self, 'rup'):
# this is normal for the case of scenario from rupture
logging.info('%d assets were discarded because too far '
'from the rupture; use `oq show discarded` '
'to show them and `oq plot_assets` to plot '
'them' % len(discarded))
elif not self.oqparam.discard_assets: # raise an error
self.datastore['sitecol'] = self.sitecol
self.datastore['assetcol'] = self.assetcol
raise RuntimeError(
'%d assets were discarded; use `oq show discarded` to'
' show them and `oq plot_assets` to plot them' %
len(discarded))
# reduce the riskmodel to the relevant taxonomies
taxonomies = set(taxo for taxo in self.assetcol.tagcol.taxonomy
if taxo != '?')
if len(self.riskmodel.taxonomies) > len(taxonomies):
logging.info('Reducing risk model from %d to %d taxonomies',
len(self.riskmodel.taxonomies), len(taxonomies))
self.riskmodel = self.riskmodel.reduce(taxonomies)
return readinput.exposure | python | def read_exposure(self, haz_sitecol=None): # after load_risk_model
"""
Read the exposure, the riskmodel and update the attributes
.sitecol, .assetcol
"""
with self.monitor('reading exposure', autoflush=True):
self.sitecol, self.assetcol, discarded = (
readinput.get_sitecol_assetcol(
self.oqparam, haz_sitecol, self.riskmodel.loss_types))
if len(discarded):
self.datastore['discarded'] = discarded
if hasattr(self, 'rup'):
# this is normal for the case of scenario from rupture
logging.info('%d assets were discarded because too far '
'from the rupture; use `oq show discarded` '
'to show them and `oq plot_assets` to plot '
'them' % len(discarded))
elif not self.oqparam.discard_assets: # raise an error
self.datastore['sitecol'] = self.sitecol
self.datastore['assetcol'] = self.assetcol
raise RuntimeError(
'%d assets were discarded; use `oq show discarded` to'
' show them and `oq plot_assets` to plot them' %
len(discarded))
# reduce the riskmodel to the relevant taxonomies
taxonomies = set(taxo for taxo in self.assetcol.tagcol.taxonomy
if taxo != '?')
if len(self.riskmodel.taxonomies) > len(taxonomies):
logging.info('Reducing risk model from %d to %d taxonomies',
len(self.riskmodel.taxonomies), len(taxonomies))
self.riskmodel = self.riskmodel.reduce(taxonomies)
return readinput.exposure | [
"def",
"read_exposure",
"(",
"self",
",",
"haz_sitecol",
"=",
"None",
")",
":",
"# after load_risk_model",
"with",
"self",
".",
"monitor",
"(",
"'reading exposure'",
",",
"autoflush",
"=",
"True",
")",
":",
"self",
".",
"sitecol",
",",
"self",
".",
"assetcol",
",",
"discarded",
"=",
"(",
"readinput",
".",
"get_sitecol_assetcol",
"(",
"self",
".",
"oqparam",
",",
"haz_sitecol",
",",
"self",
".",
"riskmodel",
".",
"loss_types",
")",
")",
"if",
"len",
"(",
"discarded",
")",
":",
"self",
".",
"datastore",
"[",
"'discarded'",
"]",
"=",
"discarded",
"if",
"hasattr",
"(",
"self",
",",
"'rup'",
")",
":",
"# this is normal for the case of scenario from rupture",
"logging",
".",
"info",
"(",
"'%d assets were discarded because too far '",
"'from the rupture; use `oq show discarded` '",
"'to show them and `oq plot_assets` to plot '",
"'them'",
"%",
"len",
"(",
"discarded",
")",
")",
"elif",
"not",
"self",
".",
"oqparam",
".",
"discard_assets",
":",
"# raise an error",
"self",
".",
"datastore",
"[",
"'sitecol'",
"]",
"=",
"self",
".",
"sitecol",
"self",
".",
"datastore",
"[",
"'assetcol'",
"]",
"=",
"self",
".",
"assetcol",
"raise",
"RuntimeError",
"(",
"'%d assets were discarded; use `oq show discarded` to'",
"' show them and `oq plot_assets` to plot them'",
"%",
"len",
"(",
"discarded",
")",
")",
"# reduce the riskmodel to the relevant taxonomies",
"taxonomies",
"=",
"set",
"(",
"taxo",
"for",
"taxo",
"in",
"self",
".",
"assetcol",
".",
"tagcol",
".",
"taxonomy",
"if",
"taxo",
"!=",
"'?'",
")",
"if",
"len",
"(",
"self",
".",
"riskmodel",
".",
"taxonomies",
")",
">",
"len",
"(",
"taxonomies",
")",
":",
"logging",
".",
"info",
"(",
"'Reducing risk model from %d to %d taxonomies'",
",",
"len",
"(",
"self",
".",
"riskmodel",
".",
"taxonomies",
")",
",",
"len",
"(",
"taxonomies",
")",
")",
"self",
".",
"riskmodel",
"=",
"self",
".",
"riskmodel",
".",
"reduce",
"(",
"taxonomies",
")",
"return",
"readinput",
".",
"exposure"
] | Read the exposure, the riskmodel and update the attributes
.sitecol, .assetcol | [
"Read",
"the",
"exposure",
"the",
"riskmodel",
"and",
"update",
"the",
"attributes",
".",
"sitecol",
".",
"assetcol"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L534-L566 |
52 | gem/oq-engine | openquake/calculators/base.py | HazardCalculator.save_riskmodel | def save_riskmodel(self):
"""
Save the risk models in the datastore
"""
self.datastore['risk_model'] = rm = self.riskmodel
self.datastore['taxonomy_mapping'] = self.riskmodel.tmap
attrs = self.datastore.getitem('risk_model').attrs
attrs['min_iml'] = hdf5.array_of_vstr(sorted(rm.min_iml.items()))
self.datastore.set_nbytes('risk_model') | python | def save_riskmodel(self):
"""
Save the risk models in the datastore
"""
self.datastore['risk_model'] = rm = self.riskmodel
self.datastore['taxonomy_mapping'] = self.riskmodel.tmap
attrs = self.datastore.getitem('risk_model').attrs
attrs['min_iml'] = hdf5.array_of_vstr(sorted(rm.min_iml.items()))
self.datastore.set_nbytes('risk_model') | [
"def",
"save_riskmodel",
"(",
"self",
")",
":",
"self",
".",
"datastore",
"[",
"'risk_model'",
"]",
"=",
"rm",
"=",
"self",
".",
"riskmodel",
"self",
".",
"datastore",
"[",
"'taxonomy_mapping'",
"]",
"=",
"self",
".",
"riskmodel",
".",
"tmap",
"attrs",
"=",
"self",
".",
"datastore",
".",
"getitem",
"(",
"'risk_model'",
")",
".",
"attrs",
"attrs",
"[",
"'min_iml'",
"]",
"=",
"hdf5",
".",
"array_of_vstr",
"(",
"sorted",
"(",
"rm",
".",
"min_iml",
".",
"items",
"(",
")",
")",
")",
"self",
".",
"datastore",
".",
"set_nbytes",
"(",
"'risk_model'",
")"
] | Save the risk models in the datastore | [
"Save",
"the",
"risk",
"models",
"in",
"the",
"datastore"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L588-L596 |
53 | gem/oq-engine | openquake/calculators/base.py | HazardCalculator.store_rlz_info | def store_rlz_info(self, eff_ruptures=None):
"""
Save info about the composite source model inside the csm_info dataset
"""
if hasattr(self, 'csm'): # no scenario
self.csm.info.update_eff_ruptures(eff_ruptures)
self.rlzs_assoc = self.csm.info.get_rlzs_assoc(
self.oqparam.sm_lt_path)
if not self.rlzs_assoc:
raise RuntimeError('Empty logic tree: too much filtering?')
self.datastore['csm_info'] = self.csm.info
R = len(self.rlzs_assoc.realizations)
logging.info('There are %d realization(s)', R)
if self.oqparam.imtls:
self.datastore['weights'] = arr = build_weights(
self.rlzs_assoc.realizations, self.oqparam.imt_dt())
self.datastore.set_attrs('weights', nbytes=arr.nbytes)
if hasattr(self, 'hdf5cache'): # no scenario
with hdf5.File(self.hdf5cache, 'r+') as cache:
cache['weights'] = arr
if 'event_based' in self.oqparam.calculation_mode and R >= TWO16:
# rlzi is 16 bit integer in the GMFs, so there is hard limit or R
raise ValueError(
'The logic tree has %d realizations, the maximum '
'is %d' % (R, TWO16))
elif R > 10000:
logging.warning(
'The logic tree has %d realizations(!), please consider '
'sampling it', R)
self.datastore.flush() | python | def store_rlz_info(self, eff_ruptures=None):
"""
Save info about the composite source model inside the csm_info dataset
"""
if hasattr(self, 'csm'): # no scenario
self.csm.info.update_eff_ruptures(eff_ruptures)
self.rlzs_assoc = self.csm.info.get_rlzs_assoc(
self.oqparam.sm_lt_path)
if not self.rlzs_assoc:
raise RuntimeError('Empty logic tree: too much filtering?')
self.datastore['csm_info'] = self.csm.info
R = len(self.rlzs_assoc.realizations)
logging.info('There are %d realization(s)', R)
if self.oqparam.imtls:
self.datastore['weights'] = arr = build_weights(
self.rlzs_assoc.realizations, self.oqparam.imt_dt())
self.datastore.set_attrs('weights', nbytes=arr.nbytes)
if hasattr(self, 'hdf5cache'): # no scenario
with hdf5.File(self.hdf5cache, 'r+') as cache:
cache['weights'] = arr
if 'event_based' in self.oqparam.calculation_mode and R >= TWO16:
# rlzi is 16 bit integer in the GMFs, so there is hard limit or R
raise ValueError(
'The logic tree has %d realizations, the maximum '
'is %d' % (R, TWO16))
elif R > 10000:
logging.warning(
'The logic tree has %d realizations(!), please consider '
'sampling it', R)
self.datastore.flush() | [
"def",
"store_rlz_info",
"(",
"self",
",",
"eff_ruptures",
"=",
"None",
")",
":",
"if",
"hasattr",
"(",
"self",
",",
"'csm'",
")",
":",
"# no scenario",
"self",
".",
"csm",
".",
"info",
".",
"update_eff_ruptures",
"(",
"eff_ruptures",
")",
"self",
".",
"rlzs_assoc",
"=",
"self",
".",
"csm",
".",
"info",
".",
"get_rlzs_assoc",
"(",
"self",
".",
"oqparam",
".",
"sm_lt_path",
")",
"if",
"not",
"self",
".",
"rlzs_assoc",
":",
"raise",
"RuntimeError",
"(",
"'Empty logic tree: too much filtering?'",
")",
"self",
".",
"datastore",
"[",
"'csm_info'",
"]",
"=",
"self",
".",
"csm",
".",
"info",
"R",
"=",
"len",
"(",
"self",
".",
"rlzs_assoc",
".",
"realizations",
")",
"logging",
".",
"info",
"(",
"'There are %d realization(s)'",
",",
"R",
")",
"if",
"self",
".",
"oqparam",
".",
"imtls",
":",
"self",
".",
"datastore",
"[",
"'weights'",
"]",
"=",
"arr",
"=",
"build_weights",
"(",
"self",
".",
"rlzs_assoc",
".",
"realizations",
",",
"self",
".",
"oqparam",
".",
"imt_dt",
"(",
")",
")",
"self",
".",
"datastore",
".",
"set_attrs",
"(",
"'weights'",
",",
"nbytes",
"=",
"arr",
".",
"nbytes",
")",
"if",
"hasattr",
"(",
"self",
",",
"'hdf5cache'",
")",
":",
"# no scenario",
"with",
"hdf5",
".",
"File",
"(",
"self",
".",
"hdf5cache",
",",
"'r+'",
")",
"as",
"cache",
":",
"cache",
"[",
"'weights'",
"]",
"=",
"arr",
"if",
"'event_based'",
"in",
"self",
".",
"oqparam",
".",
"calculation_mode",
"and",
"R",
">=",
"TWO16",
":",
"# rlzi is 16 bit integer in the GMFs, so there is hard limit or R",
"raise",
"ValueError",
"(",
"'The logic tree has %d realizations, the maximum '",
"'is %d'",
"%",
"(",
"R",
",",
"TWO16",
")",
")",
"elif",
"R",
">",
"10000",
":",
"logging",
".",
"warning",
"(",
"'The logic tree has %d realizations(!), please consider '",
"'sampling it'",
",",
"R",
")",
"self",
".",
"datastore",
".",
"flush",
"(",
")"
] | Save info about the composite source model inside the csm_info dataset | [
"Save",
"info",
"about",
"the",
"composite",
"source",
"model",
"inside",
"the",
"csm_info",
"dataset"
] | 8294553a0b8aba33fd96437a35065d03547d0040 | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L701-L730 |
End of preview. Expand
in Dataset Viewer.
- Downloads last month
- 556