repository_name stringlengths 7 55 | func_path_in_repository stringlengths 4 223 | func_name stringlengths 1 134 | whole_func_string stringlengths 75 104k | language stringclasses 1
value | func_code_string stringlengths 75 104k | func_code_tokens listlengths 19 28.4k | func_documentation_string stringlengths 1 46.9k | func_documentation_tokens listlengths 1 1.97k | split_name stringclasses 1
value | func_code_url stringlengths 87 315 |
|---|---|---|---|---|---|---|---|---|---|---|
gem/oq-engine | openquake/hazardlib/gsim/tavakoli_pezeshk_2005.py | TavakoliPezeshk2005._compute_anelastic_attenuation_term | def _compute_anelastic_attenuation_term(self, C, rrup, mag):
"""
Compute magnitude-distance scaling term as defined in equation 21,
page 2291 (Tavakoli and Pezeshk, 2005)
"""
r = (rrup**2. + (C['c5'] * np.exp(C['c6'] * mag +
C['c7'] * (8.... | python | def _compute_anelastic_attenuation_term(self, C, rrup, mag):
"""
Compute magnitude-distance scaling term as defined in equation 21,
page 2291 (Tavakoli and Pezeshk, 2005)
"""
r = (rrup**2. + (C['c5'] * np.exp(C['c6'] * mag +
C['c7'] * (8.... | [
"def",
"_compute_anelastic_attenuation_term",
"(",
"self",
",",
"C",
",",
"rrup",
",",
"mag",
")",
":",
"r",
"=",
"(",
"rrup",
"**",
"2.",
"+",
"(",
"C",
"[",
"'c5'",
"]",
"*",
"np",
".",
"exp",
"(",
"C",
"[",
"'c6'",
"]",
"*",
"mag",
"+",
"C",... | Compute magnitude-distance scaling term as defined in equation 21,
page 2291 (Tavakoli and Pezeshk, 2005) | [
"Compute",
"magnitude",
"-",
"distance",
"scaling",
"term",
"as",
"defined",
"in",
"equation",
"21",
"page",
"2291",
"(",
"Tavakoli",
"and",
"Pezeshk",
"2005",
")"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/gsim/tavakoli_pezeshk_2005.py#L157-L166 |
gem/oq-engine | openquake/hazardlib/geo/surface/complex_fault.py | edge_node | def edge_node(name, points):
"""
:param name: 'faultTopEdge', 'intermediateEdge' or 'faultBottomEdge'
:param points: a list of Point objects
:returns: a Node of kind faultTopEdge, intermediateEdge or faultBottomEdge
"""
line = []
for point in points:
line.append(point.longitude)
... | python | def edge_node(name, points):
"""
:param name: 'faultTopEdge', 'intermediateEdge' or 'faultBottomEdge'
:param points: a list of Point objects
:returns: a Node of kind faultTopEdge, intermediateEdge or faultBottomEdge
"""
line = []
for point in points:
line.append(point.longitude)
... | [
"def",
"edge_node",
"(",
"name",
",",
"points",
")",
":",
"line",
"=",
"[",
"]",
"for",
"point",
"in",
"points",
":",
"line",
".",
"append",
"(",
"point",
".",
"longitude",
")",
"line",
".",
"append",
"(",
"point",
".",
"latitude",
")",
"line",
"."... | :param name: 'faultTopEdge', 'intermediateEdge' or 'faultBottomEdge'
:param points: a list of Point objects
:returns: a Node of kind faultTopEdge, intermediateEdge or faultBottomEdge | [
":",
"param",
"name",
":",
"faultTopEdge",
"intermediateEdge",
"or",
"faultBottomEdge",
":",
"param",
"points",
":",
"a",
"list",
"of",
"Point",
"objects",
":",
"returns",
":",
"a",
"Node",
"of",
"kind",
"faultTopEdge",
"intermediateEdge",
"or",
"faultBottomEdge... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L36-L49 |
gem/oq-engine | openquake/hazardlib/geo/surface/complex_fault.py | complex_fault_node | def complex_fault_node(edges):
"""
:param edges: a list of lists of points
:returns: a Node of kind complexFaultGeometry
"""
node = Node('complexFaultGeometry')
node.append(edge_node('faultTopEdge', edges[0]))
for edge in edges[1:-1]:
node.append(edge_node('intermediateEdge', edge))
... | python | def complex_fault_node(edges):
"""
:param edges: a list of lists of points
:returns: a Node of kind complexFaultGeometry
"""
node = Node('complexFaultGeometry')
node.append(edge_node('faultTopEdge', edges[0]))
for edge in edges[1:-1]:
node.append(edge_node('intermediateEdge', edge))
... | [
"def",
"complex_fault_node",
"(",
"edges",
")",
":",
"node",
"=",
"Node",
"(",
"'complexFaultGeometry'",
")",
"node",
".",
"append",
"(",
"edge_node",
"(",
"'faultTopEdge'",
",",
"edges",
"[",
"0",
"]",
")",
")",
"for",
"edge",
"in",
"edges",
"[",
"1",
... | :param edges: a list of lists of points
:returns: a Node of kind complexFaultGeometry | [
":",
"param",
"edges",
":",
"a",
"list",
"of",
"lists",
"of",
"points",
":",
"returns",
":",
"a",
"Node",
"of",
"kind",
"complexFaultGeometry"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L52-L62 |
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:
... | 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:
... | [
"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_inclina... | 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",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L96-L111 |
gem/oq-engine | openquake/hazardlib/geo/surface/complex_fault.py | ComplexFaultSurface.check_aki_richards_convention | def check_aki_richards_convention(cls, edges):
"""
Verify that surface (as defined by corner points) conforms with Aki and
Richard convention (i.e. surface dips right of surface strike)
This method doesn't have to be called by hands before creating the
surface object, because it... | python | def check_aki_richards_convention(cls, edges):
"""
Verify that surface (as defined by corner points) conforms with Aki and
Richard convention (i.e. surface dips right of surface strike)
This method doesn't have to be called by hands before creating the
surface object, because it... | [
"def",
"check_aki_richards_convention",
"(",
"cls",
",",
"edges",
")",
":",
"# 1) extract 4 corner points of surface mesh",
"# 2) compute cross products between left and right edges and top edge",
"# (these define vectors normal to the surface)",
"# 3) compute dot products between cross produc... | Verify that surface (as defined by corner points) conforms with Aki and
Richard convention (i.e. surface dips right of surface strike)
This method doesn't have to be called by hands before creating the
surface object, because it is called from :meth:`from_fault_data`. | [
"Verify",
"that",
"surface",
"(",
"as",
"defined",
"by",
"corner",
"points",
")",
"conforms",
"with",
"Aki",
"and",
"Richard",
"convention",
"(",
"i",
".",
"e",
".",
"surface",
"dips",
"right",
"of",
"surface",
"strike",
")"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L129-L179 |
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... | 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... | [
"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",
"(",... | 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 i... | [
"Check",
"validity",
"of",
"the",
"surface",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L182-L230 |
gem/oq-engine | openquake/hazardlib/geo/surface/complex_fault.py | ComplexFaultSurface.check_fault_data | def check_fault_data(cls, edges, mesh_spacing):
"""
Verify the fault data and raise ``ValueError`` if anything is wrong.
This method doesn't have to be called by hands before creating the
surface object, because it is called from :meth:`from_fault_data`.
"""
if not len(e... | python | def check_fault_data(cls, edges, mesh_spacing):
"""
Verify the fault data and raise ``ValueError`` if anything is wrong.
This method doesn't have to be called by hands before creating the
surface object, because it is called from :meth:`from_fault_data`.
"""
if not len(e... | [
"def",
"check_fault_data",
"(",
"cls",
",",
"edges",
",",
"mesh_spacing",
")",
":",
"if",
"not",
"len",
"(",
"edges",
")",
">=",
"2",
":",
"raise",
"ValueError",
"(",
"\"at least two edges are required\"",
")",
"if",
"not",
"all",
"(",
"len",
"(",
"edge",
... | Verify the fault data and raise ``ValueError`` if anything is wrong.
This method doesn't have to be called by hands before creating the
surface object, because it is called from :meth:`from_fault_data`. | [
"Verify",
"the",
"fault",
"data",
"and",
"raise",
"ValueError",
"if",
"anything",
"is",
"wrong",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L233-L249 |
gem/oq-engine | openquake/hazardlib/geo/surface/complex_fault.py | ComplexFaultSurface.from_fault_data | def from_fault_data(cls, edges, mesh_spacing):
"""
Create and return a fault surface using fault source data.
:param edges:
A list of at least two horizontal edges of the surface
as instances of :class:`openquake.hazardlib.geo.line.Line`. The
list should be i... | python | def from_fault_data(cls, edges, mesh_spacing):
"""
Create and return a fault surface using fault source data.
:param edges:
A list of at least two horizontal edges of the surface
as instances of :class:`openquake.hazardlib.geo.line.Line`. The
list should be i... | [
"def",
"from_fault_data",
"(",
"cls",
",",
"edges",
",",
"mesh_spacing",
")",
":",
"cls",
".",
"check_fault_data",
"(",
"edges",
",",
"mesh_spacing",
")",
"surface_nodes",
"=",
"[",
"complex_fault_node",
"(",
"edges",
")",
"]",
"mean_length",
"=",
"numpy",
"... | Create and return a fault surface using fault source data.
:param edges:
A list of at least two horizontal edges of the surface
as instances of :class:`openquake.hazardlib.geo.line.Line`. The
list should be in top-to-bottom order (the shallowest edge first).
:param m... | [
"Create",
"and",
"return",
"a",
"fault",
"surface",
"using",
"fault",
"source",
"data",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L252-L299 |
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 :c... | 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 :c... | [
"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",
":",
"... | 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 t... | [
"Get",
"a",
"surface",
"projection",
"of",
"the",
"complex",
"fault",
"surface",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/surface/complex_fault.py#L302-L323 |
gem/oq-engine | openquake/calculators/base.py | fix_ones | def fix_ones(pmap):
"""
Physically, an extremely small intensity measure level can have an
extremely large probability of exceedence, however that probability
cannot be exactly 1 unless the level is exactly 0. Numerically, the
PoE can be 1 and this give issues when calculating the damage (there
... | python | def fix_ones(pmap):
"""
Physically, an extremely small intensity measure level can have an
extremely large probability of exceedence, however that probability
cannot be exactly 1 unless the level is exactly 0. Numerically, the
PoE can be 1 and this give issues when calculating the damage (there
... | [
"def",
"fix_ones",
"(",
"pmap",
")",
":",
"for",
"sid",
"in",
"pmap",
":",
"array",
"=",
"pmap",
"[",
"sid",
"]",
".",
"array",
"array",
"[",
"array",
"==",
"1.",
"]",
"=",
".9999999999999999",
"return",
"pmap"
] | Physically, an extremely small intensity measure level can have an
extremely large probability of exceedence, however that probability
cannot be exactly 1 unless the level is exactly 0. Numerically, the
PoE can be 1 and this give issues when calculating the damage (there
is a log(0) in
:class:`openq... | [
"Physically",
"an",
"extremely",
"small",
"intensity",
"measure",
"level",
"can",
"have",
"an",
"extremely",
"large",
"probability",
"of",
"exceedence",
"however",
"that",
"probability",
"cannot",
"be",
"exactly",
"1",
"unless",
"the",
"level",
"is",
"exactly",
... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L65-L79 |
gem/oq-engine | openquake/calculators/base.py | build_weights | def build_weights(realizations, imt_dt):
"""
:returns: an array with the realization weights of shape (R, M)
"""
arr = numpy.zeros((len(realizations), len(imt_dt.names)))
for m, imt in enumerate(imt_dt.names):
arr[:, m] = [rlz.weight[imt] for rlz in realizations]
return arr | python | def build_weights(realizations, imt_dt):
"""
:returns: an array with the realization weights of shape (R, M)
"""
arr = numpy.zeros((len(realizations), len(imt_dt.names)))
for m, imt in enumerate(imt_dt.names):
arr[:, m] = [rlz.weight[imt] for rlz in realizations]
return arr | [
"def",
"build_weights",
"(",
"realizations",
",",
"imt_dt",
")",
":",
"arr",
"=",
"numpy",
".",
"zeros",
"(",
"(",
"len",
"(",
"realizations",
")",
",",
"len",
"(",
"imt_dt",
".",
"names",
")",
")",
")",
"for",
"m",
",",
"imt",
"in",
"enumerate",
"... | :returns: an array with the realization weights of shape (R, M) | [
":",
"returns",
":",
"an",
"array",
"with",
"the",
"realization",
"weights",
"of",
"shape",
"(",
"R",
"M",
")"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L82-L89 |
gem/oq-engine | openquake/calculators/base.py | set_array | def set_array(longarray, shortarray):
"""
:param longarray: a numpy array of floats of length L >= l
:param shortarray: a numpy array of floats of length l
Fill `longarray` with the values of `shortarray`, starting from the left.
If `shortarry` is shorter than `longarray`, then the remaining elemen... | python | def set_array(longarray, shortarray):
"""
:param longarray: a numpy array of floats of length L >= l
:param shortarray: a numpy array of floats of length l
Fill `longarray` with the values of `shortarray`, starting from the left.
If `shortarry` is shorter than `longarray`, then the remaining elemen... | [
"def",
"set_array",
"(",
"longarray",
",",
"shortarray",
")",
":",
"longarray",
"[",
":",
"len",
"(",
"shortarray",
")",
"]",
"=",
"shortarray",
"longarray",
"[",
"len",
"(",
"shortarray",
")",
":",
"]",
"=",
"numpy",
".",
"nan"
] | :param longarray: a numpy array of floats of length L >= l
:param shortarray: a numpy array of floats of length l
Fill `longarray` with the values of `shortarray`, starting from the left.
If `shortarry` is shorter than `longarray`, then the remaining elements on
the right are filled with `numpy.nan` va... | [
":",
"param",
"longarray",
":",
"a",
"numpy",
"array",
"of",
"floats",
"of",
"length",
"L",
">",
"=",
"l",
":",
"param",
"shortarray",
":",
"a",
"numpy",
"array",
"of",
"floats",
"of",
"length",
"l"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L92-L102 |
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_eve... | 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_eve... | [
"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 th... | 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",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L321-L331 |
gem/oq-engine | openquake/calculators/base.py | build_hmaps | def build_hmaps(hcurves_by_kind, slice_, imtls, poes, monitor):
"""
Build hazard maps from a slice of hazard curves.
:returns: a pair ({kind: hmaps}, slice)
"""
dic = {}
for kind, hcurves in hcurves_by_kind.items():
dic[kind] = calc.make_hmap_array(hcurves, imtls, poes, len(hcurves))
... | python | def build_hmaps(hcurves_by_kind, slice_, imtls, poes, monitor):
"""
Build hazard maps from a slice of hazard curves.
:returns: a pair ({kind: hmaps}, slice)
"""
dic = {}
for kind, hcurves in hcurves_by_kind.items():
dic[kind] = calc.make_hmap_array(hcurves, imtls, poes, len(hcurves))
... | [
"def",
"build_hmaps",
"(",
"hcurves_by_kind",
",",
"slice_",
",",
"imtls",
",",
"poes",
",",
"monitor",
")",
":",
"dic",
"=",
"{",
"}",
"for",
"kind",
",",
"hcurves",
"in",
"hcurves_by_kind",
".",
"items",
"(",
")",
":",
"dic",
"[",
"kind",
"]",
"=",... | Build hazard maps from a slice of hazard curves.
:returns: a pair ({kind: hmaps}, slice) | [
"Build",
"hazard",
"maps",
"from",
"a",
"slice",
"of",
"hazard",
"curves",
".",
":",
"returns",
":",
"a",
"pair",
"(",
"{",
"kind",
":",
"hmaps",
"}",
"slice",
")"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L749-L757 |
gem/oq-engine | openquake/calculators/base.py | get_gmv_data | def get_gmv_data(sids, gmfs, events):
"""
Convert an array of shape (N, E, M) into an array of type gmv_data_dt
"""
N, E, M = gmfs.shape
gmv_data_dt = numpy.dtype(
[('rlzi', U16), ('sid', U32), ('eid', U64), ('gmv', (F32, (M,)))])
# NB: ordering of the loops: first site, then event
l... | python | def get_gmv_data(sids, gmfs, events):
"""
Convert an array of shape (N, E, M) into an array of type gmv_data_dt
"""
N, E, M = gmfs.shape
gmv_data_dt = numpy.dtype(
[('rlzi', U16), ('sid', U32), ('eid', U64), ('gmv', (F32, (M,)))])
# NB: ordering of the loops: first site, then event
l... | [
"def",
"get_gmv_data",
"(",
"sids",
",",
"gmfs",
",",
"events",
")",
":",
"N",
",",
"E",
",",
"M",
"=",
"gmfs",
".",
"shape",
"gmv_data_dt",
"=",
"numpy",
".",
"dtype",
"(",
"[",
"(",
"'rlzi'",
",",
"U16",
")",
",",
"(",
"'sid'",
",",
"U32",
")... | Convert an array of shape (N, E, M) into an array of type gmv_data_dt | [
"Convert",
"an",
"array",
"of",
"shape",
"(",
"N",
"E",
"M",
")",
"into",
"an",
"array",
"of",
"type",
"gmv_data_dt"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L884-L895 |
gem/oq-engine | openquake/calculators/base.py | save_gmfs | def save_gmfs(calculator):
"""
:param calculator: a scenario_risk/damage or event_based_risk calculator
:returns: a pair (eids, R) where R is the number of realizations
"""
dstore = calculator.datastore
oq = calculator.oqparam
logging.info('Reading gmfs from file')
if oq.inputs['gmfs'].e... | python | def save_gmfs(calculator):
"""
:param calculator: a scenario_risk/damage or event_based_risk calculator
:returns: a pair (eids, R) where R is the number of realizations
"""
dstore = calculator.datastore
oq = calculator.oqparam
logging.info('Reading gmfs from file')
if oq.inputs['gmfs'].e... | [
"def",
"save_gmfs",
"(",
"calculator",
")",
":",
"dstore",
"=",
"calculator",
".",
"datastore",
"oq",
"=",
"calculator",
".",
"oqparam",
"logging",
".",
"info",
"(",
"'Reading gmfs from file'",
")",
"if",
"oq",
".",
"inputs",
"[",
"'gmfs'",
"]",
".",
"ends... | :param calculator: a scenario_risk/damage or event_based_risk calculator
:returns: a pair (eids, R) where R is the number of realizations | [
":",
"param",
"calculator",
":",
"a",
"scenario_risk",
"/",
"damage",
"or",
"event_based_risk",
"calculator",
":",
"returns",
":",
"a",
"pair",
"(",
"eids",
"R",
")",
"where",
"R",
"is",
"the",
"number",
"of",
"realizations"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L898-L928 |
gem/oq-engine | openquake/calculators/base.py | save_gmf_data | def save_gmf_data(dstore, sitecol, gmfs, imts, events=()):
"""
:param dstore: a :class:`openquake.baselib.datastore.DataStore` instance
:param sitecol: a :class:`openquake.hazardlib.site.SiteCollection` instance
:param gmfs: an array of shape (N, E, M)
:param imts: a list of IMT strings
:param e... | python | def save_gmf_data(dstore, sitecol, gmfs, imts, events=()):
"""
:param dstore: a :class:`openquake.baselib.datastore.DataStore` instance
:param sitecol: a :class:`openquake.hazardlib.site.SiteCollection` instance
:param gmfs: an array of shape (N, E, M)
:param imts: a list of IMT strings
:param e... | [
"def",
"save_gmf_data",
"(",
"dstore",
",",
"sitecol",
",",
"gmfs",
",",
"imts",
",",
"events",
"=",
"(",
")",
")",
":",
"if",
"len",
"(",
"events",
")",
"==",
"0",
":",
"E",
"=",
"gmfs",
".",
"shape",
"[",
"1",
"]",
"events",
"=",
"numpy",
"."... | :param dstore: a :class:`openquake.baselib.datastore.DataStore` instance
:param sitecol: a :class:`openquake.hazardlib.site.SiteCollection` instance
:param gmfs: an array of shape (N, E, M)
:param imts: a list of IMT strings
:param events: E event IDs or the empty tuple | [
":",
"param",
"dstore",
":",
"a",
":",
"class",
":",
"openquake",
".",
"baselib",
".",
"datastore",
".",
"DataStore",
"instance",
":",
"param",
"sitecol",
":",
"a",
":",
"class",
":",
"openquake",
".",
"hazardlib",
".",
"site",
".",
"SiteCollection",
"in... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L931-L956 |
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] f... | 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] f... | [
"def",
"get_idxs",
"(",
"data",
",",
"eid2idx",
")",
":",
"uniq",
",",
"inv",
"=",
"numpy",
".",
"unique",
"(",
"data",
"[",
"'eid'",
"]",
",",
"return_inverse",
"=",
"True",
")",
"idxs",
"=",
"numpy",
".",
"array",
"(",
"[",
"eid2idx",
"[",
"eid",... | 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",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L959-L969 |
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 he... | 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 he... | [
"def",
"import_gmfs",
"(",
"dstore",
",",
"fname",
",",
"sids",
")",
":",
"array",
"=",
"writers",
".",
"read_composite_array",
"(",
"fname",
")",
".",
"array",
"# has header rlzi, sid, eid, gmv_PGA, ...",
"imts",
"=",
"[",
"name",
"[",
"4",
":",
"]",
"for",... | 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",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L972-L1013 |
gem/oq-engine | openquake/calculators/base.py | BaseCalculator.monitor | def monitor(self, operation='', **kw):
"""
:returns: a new Monitor instance
"""
mon = self._monitor(operation, hdf5=self.datastore.hdf5)
self._monitor.calc_id = mon.calc_id = self.datastore.calc_id
vars(mon).update(kw)
return mon | python | def monitor(self, operation='', **kw):
"""
:returns: a new Monitor instance
"""
mon = self._monitor(operation, hdf5=self.datastore.hdf5)
self._monitor.calc_id = mon.calc_id = self.datastore.calc_id
vars(mon).update(kw)
return mon | [
"def",
"monitor",
"(",
"self",
",",
"operation",
"=",
"''",
",",
"*",
"*",
"kw",
")",
":",
"mon",
"=",
"self",
".",
"_monitor",
"(",
"operation",
",",
"hdf5",
"=",
"self",
".",
"datastore",
".",
"hdf5",
")",
"self",
".",
"_monitor",
".",
"calc_id",... | :returns: a new Monitor instance | [
":",
"returns",
":",
"a",
"new",
"Monitor",
"instance"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L133-L140 |
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)
s... | 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)
s... | [
"def",
"save_params",
"(",
"self",
",",
"*",
"*",
"kw",
")",
":",
"if",
"(",
"'hazard_calculation_id'",
"in",
"kw",
"and",
"kw",
"[",
"'hazard_calculation_id'",
"]",
"is",
"None",
")",
":",
"del",
"kw",
"[",
"'hazard_calculation_id'",
"]",
"vars",
"(",
"... | Update the current calculation parameters and save engine_version | [
"Update",
"the",
"current",
"calculation",
"parameters",
"and",
"save",
"engine_version"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L142-L156 |
gem/oq-engine | openquake/calculators/base.py | BaseCalculator.check_precalc | def check_precalc(self, precalc_mode):
"""
Defensive programming against users providing an incorrect
pre-calculation ID (with ``--hazard-calculation-id``).
:param precalc_mode:
calculation_mode of the previous calculation
"""
calc_mode = self.oqparam.calcula... | python | def check_precalc(self, precalc_mode):
"""
Defensive programming against users providing an incorrect
pre-calculation ID (with ``--hazard-calculation-id``).
:param precalc_mode:
calculation_mode of the previous calculation
"""
calc_mode = self.oqparam.calcula... | [
"def",
"check_precalc",
"(",
"self",
",",
"precalc_mode",
")",
":",
"calc_mode",
"=",
"self",
".",
"oqparam",
".",
"calculation_mode",
"ok_mode",
"=",
"self",
".",
"accept_precalc",
"if",
"calc_mode",
"!=",
"precalc_mode",
"and",
"precalc_mode",
"not",
"in",
"... | Defensive programming against users providing an incorrect
pre-calculation ID (with ``--hazard-calculation-id``).
:param precalc_mode:
calculation_mode of the previous calculation | [
"Defensive",
"programming",
"against",
"users",
"providing",
"an",
"incorrect",
"pre",
"-",
"calculation",
"ID",
"(",
"with",
"--",
"hazard",
"-",
"calculation",
"-",
"id",
")",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L158-L173 |
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 concu... | 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 concu... | [
"def",
"run",
"(",
"self",
",",
"pre_execute",
"=",
"True",
",",
"concurrent_tasks",
"=",
"None",
",",
"close",
"=",
"True",
",",
"*",
"*",
"kw",
")",
":",
"with",
"self",
".",
"_monitor",
":",
"self",
".",
"_monitor",
".",
"username",
"=",
"kw",
"... | Run the calculation and return the exported outputs. | [
"Run",
"the",
"calculation",
"and",
"return",
"the",
"exported",
"outputs",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L175-L231 |
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):
... | 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):
... | [
"def",
"export",
"(",
"self",
",",
"exports",
"=",
"None",
")",
":",
"self",
".",
"exported",
"=",
"getattr",
"(",
"self",
".",
"precalc",
",",
"'exported'",
",",
"{",
"}",
")",
"if",
"isinstance",
"(",
"exports",
",",
"tuple",
")",
":",
"fmts",
"=... | 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",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L260-L289 |
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... | 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... | [
"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",
"["... | Set the attributes nbytes | [
"Set",
"the",
"attributes",
"nbytes"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L303-L318 |
gem/oq-engine | openquake/calculators/base.py | HazardCalculator.block_splitter | def block_splitter(self, sources, weight=get_weight, key=lambda src: 1):
"""
:param sources: a list of sources
:param weight: a weight function (default .weight)
:param key: None or 'src_group_id'
:returns: an iterator over blocks of sources
"""
ct = self.oqparam.... | python | def block_splitter(self, sources, weight=get_weight, key=lambda src: 1):
"""
:param sources: a list of sources
:param weight: a weight function (default .weight)
:param key: None or 'src_group_id'
:returns: an iterator over blocks of sources
"""
ct = self.oqparam.... | [
"def",
"block_splitter",
"(",
"self",
",",
"sources",
",",
"weight",
"=",
"get_weight",
",",
"key",
"=",
"lambda",
"src",
":",
"1",
")",
":",
"ct",
"=",
"self",
".",
"oqparam",
".",
"concurrent_tasks",
"or",
"1",
"maxweight",
"=",
"self",
".",
"csm",
... | :param sources: a list of sources
:param weight: a weight function (default .weight)
:param key: None or 'src_group_id'
:returns: an iterator over blocks of sources | [
":",
"param",
"sources",
":",
"a",
"list",
"of",
"sources",
":",
"param",
"weight",
":",
"a",
"weight",
"function",
"(",
"default",
".",
"weight",
")",
":",
"param",
"key",
":",
"None",
"or",
"src_group_id",
":",
"returns",
":",
"an",
"iterator",
"over... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L338-L353 |
gem/oq-engine | openquake/calculators/base.py | HazardCalculator.src_filter | def src_filter(self):
"""
:returns: a SourceFilter/UcerfFilter
"""
oq = self.oqparam
self.hdf5cache = self.datastore.hdf5cache()
sitecol = self.sitecol.complete if self.sitecol else None
if 'ucerf' in oq.calculation_mode:
return UcerfFilter(sitecol, oq... | python | def src_filter(self):
"""
:returns: a SourceFilter/UcerfFilter
"""
oq = self.oqparam
self.hdf5cache = self.datastore.hdf5cache()
sitecol = self.sitecol.complete if self.sitecol else None
if 'ucerf' in oq.calculation_mode:
return UcerfFilter(sitecol, oq... | [
"def",
"src_filter",
"(",
"self",
")",
":",
"oq",
"=",
"self",
".",
"oqparam",
"self",
".",
"hdf5cache",
"=",
"self",
".",
"datastore",
".",
"hdf5cache",
"(",
")",
"sitecol",
"=",
"self",
".",
"sitecol",
".",
"complete",
"if",
"self",
".",
"sitecol",
... | :returns: a SourceFilter/UcerfFilter | [
":",
"returns",
":",
"a",
"SourceFilter",
"/",
"UcerfFilter"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L356-L365 |
gem/oq-engine | openquake/calculators/base.py | HazardCalculator.rtree_filter | def rtree_filter(self):
"""
:returns: an RtreeFilter
"""
return RtreeFilter(self.src_filter.sitecol,
self.oqparam.maximum_distance,
self.src_filter.filename) | python | def rtree_filter(self):
"""
:returns: an RtreeFilter
"""
return RtreeFilter(self.src_filter.sitecol,
self.oqparam.maximum_distance,
self.src_filter.filename) | [
"def",
"rtree_filter",
"(",
"self",
")",
":",
"return",
"RtreeFilter",
"(",
"self",
".",
"src_filter",
".",
"sitecol",
",",
"self",
".",
"oqparam",
".",
"maximum_distance",
",",
"self",
".",
"src_filter",
".",
"filename",
")"
] | :returns: an RtreeFilter | [
":",
"returns",
":",
"an",
"RtreeFilter"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L368-L374 |
gem/oq-engine | openquake/calculators/base.py | HazardCalculator.N | def N(self):
"""
:returns: the total number of sites
"""
if hasattr(self, 'sitecol'):
return len(self.sitecol.complete) if self.sitecol else None
return len(self.datastore['sitecol/array']) | python | def N(self):
"""
:returns: the total number of sites
"""
if hasattr(self, 'sitecol'):
return len(self.sitecol.complete) if self.sitecol else None
return len(self.datastore['sitecol/array']) | [
"def",
"N",
"(",
"self",
")",
":",
"if",
"hasattr",
"(",
"self",
",",
"'sitecol'",
")",
":",
"return",
"len",
"(",
"self",
".",
"sitecol",
".",
"complete",
")",
"if",
"self",
".",
"sitecol",
"else",
"None",
"return",
"len",
"(",
"self",
".",
"datas... | :returns: the total number of sites | [
":",
"returns",
":",
"the",
"total",
"number",
"of",
"sites"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L387-L393 |
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):
... | 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):
... | [
"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",
".",
... | Read risk data and sources if any | [
"Read",
"risk",
"data",
"and",
"sources",
"if",
"any"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L406-L417 |
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... | 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... | [
"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",... | 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",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L422-L496 |
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)
i... | 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)
i... | [
"def",
"init",
"(",
"self",
")",
":",
"oq",
"=",
"self",
".",
"oqparam",
"if",
"not",
"oq",
".",
"risk_imtls",
":",
"if",
"self",
".",
"datastore",
".",
"parent",
":",
"oq",
".",
"risk_imtls",
"=",
"(",
"self",
".",
"datastore",
".",
"parent",
"[",... | To be overridden to initialize the datasets needed by the calculation | [
"To",
"be",
"overridden",
"to",
"initialize",
"the",
"datasets",
"needed",
"by",
"the",
"calculation"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L498-L522 |
gem/oq-engine | openquake/calculators/base.py | HazardCalculator.R | def R(self):
"""
:returns: the number of realizations
"""
try:
return self.csm.info.get_num_rlzs()
except AttributeError: # no self.csm
return self.datastore['csm_info'].get_num_rlzs() | python | def R(self):
"""
:returns: the number of realizations
"""
try:
return self.csm.info.get_num_rlzs()
except AttributeError: # no self.csm
return self.datastore['csm_info'].get_num_rlzs() | [
"def",
"R",
"(",
"self",
")",
":",
"try",
":",
"return",
"self",
".",
"csm",
".",
"info",
".",
"get_num_rlzs",
"(",
")",
"except",
"AttributeError",
":",
"# no self.csm",
"return",
"self",
".",
"datastore",
"[",
"'csm_info'",
"]",
".",
"get_num_rlzs",
"(... | :returns: the number of realizations | [
":",
"returns",
":",
"the",
"number",
"of",
"realizations"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L525-L532 |
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 = (
... | 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 = (
... | [
"def",
"read_exposure",
"(",
"self",
",",
"haz_sitecol",
"=",
"None",
")",
":",
"# after load_risk_model",
"with",
"self",
".",
"monitor",
"(",
"'reading exposure'",
",",
"autoflush",
"=",
"True",
")",
":",
"self",
".",
"sitecol",
",",
"self",
".",
"assetcol... | Read the exposure, the riskmodel and update the attributes
.sitecol, .assetcol | [
"Read",
"the",
"exposure",
"the",
"riskmodel",
"and",
"update",
"the",
"attributes",
".",
"sitecol",
".",
"assetcol"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L534-L566 |
gem/oq-engine | openquake/calculators/base.py | HazardCalculator.load_riskmodel | def load_riskmodel(self):
# to be called before read_exposure
# NB: this is called even if there is no risk model
"""
Read the risk model and set the attribute .riskmodel.
The riskmodel can be empty for hazard calculations.
Save the loss ratios (if any) in the datastore.
... | python | def load_riskmodel(self):
# to be called before read_exposure
# NB: this is called even if there is no risk model
"""
Read the risk model and set the attribute .riskmodel.
The riskmodel can be empty for hazard calculations.
Save the loss ratios (if any) in the datastore.
... | [
"def",
"load_riskmodel",
"(",
"self",
")",
":",
"# to be called before read_exposure",
"# NB: this is called even if there is no risk model",
"logging",
".",
"info",
"(",
"'Reading the risk model if present'",
")",
"self",
".",
"riskmodel",
"=",
"readinput",
".",
"get_risk_mo... | Read the risk model and set the attribute .riskmodel.
The riskmodel can be empty for hazard calculations.
Save the loss ratios (if any) in the datastore. | [
"Read",
"the",
"risk",
"model",
"and",
"set",
"the",
"attribute",
".",
"riskmodel",
".",
"The",
"riskmodel",
"can",
"be",
"empty",
"for",
"hazard",
"calculations",
".",
"Save",
"the",
"loss",
"ratios",
"(",
"if",
"any",
")",
"in",
"the",
"datastore",
"."... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L568-L586 |
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_... | 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_... | [
"def",
"save_riskmodel",
"(",
"self",
")",
":",
"self",
".",
"datastore",
"[",
"'risk_model'",
"]",
"=",
"rm",
"=",
"self",
".",
"riskmodel",
"self",
".",
"datastore",
"[",
"'taxonomy_mapping'",
"]",
"=",
"self",
".",
"riskmodel",
".",
"tmap",
"attrs",
"... | Save the risk models in the datastore | [
"Save",
"the",
"risk",
"models",
"in",
"the",
"datastore"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L588-L596 |
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(
... | 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(
... | [
"def",
"store_rlz_info",
"(",
"self",
",",
"eff_ruptures",
"=",
"None",
")",
":",
"if",
"hasattr",
"(",
"self",
",",
"'csm'",
")",
":",
"# no scenario",
"self",
".",
"csm",
".",
"info",
".",
"update_eff_ruptures",
"(",
"eff_ruptures",
")",
"self",
".",
"... | Save info about the composite source model inside the csm_info dataset | [
"Save",
"info",
"about",
"the",
"composite",
"source",
"model",
"inside",
"the",
"csm_info",
"dataset"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L701-L730 |
gem/oq-engine | openquake/calculators/base.py | HazardCalculator.store_source_info | def store_source_info(self, calc_times):
"""
Save (weight, num_sites, calc_time) inside the source_info dataset
"""
if calc_times:
source_info = self.datastore['source_info']
arr = numpy.zeros((len(source_info), 3), F32)
ids, vals = zip(*sorted(calc_ti... | python | def store_source_info(self, calc_times):
"""
Save (weight, num_sites, calc_time) inside the source_info dataset
"""
if calc_times:
source_info = self.datastore['source_info']
arr = numpy.zeros((len(source_info), 3), F32)
ids, vals = zip(*sorted(calc_ti... | [
"def",
"store_source_info",
"(",
"self",
",",
"calc_times",
")",
":",
"if",
"calc_times",
":",
"source_info",
"=",
"self",
".",
"datastore",
"[",
"'source_info'",
"]",
"arr",
"=",
"numpy",
".",
"zeros",
"(",
"(",
"len",
"(",
"source_info",
")",
",",
"3",... | Save (weight, num_sites, calc_time) inside the source_info dataset | [
"Save",
"(",
"weight",
"num_sites",
"calc_time",
")",
"inside",
"the",
"source_info",
"dataset"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L732-L743 |
gem/oq-engine | openquake/calculators/base.py | RiskCalculator.read_shakemap | def read_shakemap(self, haz_sitecol, assetcol):
"""
Enabled only if there is a shakemap_id parameter in the job.ini.
Download, unzip, parse USGS shakemap files and build a corresponding
set of GMFs which are then filtered with the hazard site collection
and stored in the datastor... | python | def read_shakemap(self, haz_sitecol, assetcol):
"""
Enabled only if there is a shakemap_id parameter in the job.ini.
Download, unzip, parse USGS shakemap files and build a corresponding
set of GMFs which are then filtered with the hazard site collection
and stored in the datastor... | [
"def",
"read_shakemap",
"(",
"self",
",",
"haz_sitecol",
",",
"assetcol",
")",
":",
"oq",
"=",
"self",
".",
"oqparam",
"E",
"=",
"oq",
".",
"number_of_ground_motion_fields",
"oq",
".",
"risk_imtls",
"=",
"oq",
".",
"imtls",
"or",
"self",
".",
"datastore",
... | Enabled only if there is a shakemap_id parameter in the job.ini.
Download, unzip, parse USGS shakemap files and build a corresponding
set of GMFs which are then filtered with the hazard site collection
and stored in the datastore. | [
"Enabled",
"only",
"if",
"there",
"is",
"a",
"shakemap_id",
"parameter",
"in",
"the",
"job",
".",
"ini",
".",
"Download",
"unzip",
"parse",
"USGS",
"shakemap",
"files",
"and",
"build",
"a",
"corresponding",
"set",
"of",
"GMFs",
"which",
"are",
"then",
"fil... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L766-L800 |
gem/oq-engine | openquake/calculators/base.py | RiskCalculator.build_riskinputs | def build_riskinputs(self, kind):
"""
:param kind:
kind of hazard getter, can be 'poe' or 'gmf'
:returns:
a list of RiskInputs objects, sorted by IMT.
"""
logging.info('Building risk inputs from %d realization(s)', self.R)
imtls = self.oqparam.imtl... | python | def build_riskinputs(self, kind):
"""
:param kind:
kind of hazard getter, can be 'poe' or 'gmf'
:returns:
a list of RiskInputs objects, sorted by IMT.
"""
logging.info('Building risk inputs from %d realization(s)', self.R)
imtls = self.oqparam.imtl... | [
"def",
"build_riskinputs",
"(",
"self",
",",
"kind",
")",
":",
"logging",
".",
"info",
"(",
"'Building risk inputs from %d realization(s)'",
",",
"self",
".",
"R",
")",
"imtls",
"=",
"self",
".",
"oqparam",
".",
"imtls",
"if",
"not",
"set",
"(",
"self",
".... | :param kind:
kind of hazard getter, can be 'poe' or 'gmf'
:returns:
a list of RiskInputs objects, sorted by IMT. | [
":",
"param",
"kind",
":",
"kind",
"of",
"hazard",
"getter",
"can",
"be",
"poe",
"or",
"gmf",
":",
"returns",
":",
"a",
"list",
"of",
"RiskInputs",
"objects",
"sorted",
"by",
"IMT",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L802-L821 |
gem/oq-engine | openquake/calculators/base.py | RiskCalculator.get_getter | def get_getter(self, kind, sid):
"""
:param kind: 'poe' or 'gmf'
:param sid: a site ID
:returns: a PmapGetter or GmfDataGetter
"""
hdf5cache = getattr(self, 'hdf5cache', None)
if hdf5cache:
dstore = hdf5cache
elif (self.oqparam.hazard_calculati... | python | def get_getter(self, kind, sid):
"""
:param kind: 'poe' or 'gmf'
:param sid: a site ID
:returns: a PmapGetter or GmfDataGetter
"""
hdf5cache = getattr(self, 'hdf5cache', None)
if hdf5cache:
dstore = hdf5cache
elif (self.oqparam.hazard_calculati... | [
"def",
"get_getter",
"(",
"self",
",",
"kind",
",",
"sid",
")",
":",
"hdf5cache",
"=",
"getattr",
"(",
"self",
",",
"'hdf5cache'",
",",
"None",
")",
"if",
"hdf5cache",
":",
"dstore",
"=",
"hdf5cache",
"elif",
"(",
"self",
".",
"oqparam",
".",
"hazard_c... | :param kind: 'poe' or 'gmf'
:param sid: a site ID
:returns: a PmapGetter or GmfDataGetter | [
":",
"param",
"kind",
":",
"poe",
"or",
"gmf",
":",
"param",
"sid",
":",
"a",
"site",
"ID",
":",
"returns",
":",
"a",
"PmapGetter",
"or",
"GmfDataGetter"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L823-L845 |
gem/oq-engine | openquake/calculators/base.py | RiskCalculator.execute | def execute(self):
"""
Parallelize on the riskinputs and returns a dictionary of results.
Require a `.core_task` to be defined with signature
(riskinputs, riskmodel, rlzs_assoc, monitor).
"""
if not hasattr(self, 'riskinputs'): # in the reportwriter
return
... | python | def execute(self):
"""
Parallelize on the riskinputs and returns a dictionary of results.
Require a `.core_task` to be defined with signature
(riskinputs, riskmodel, rlzs_assoc, monitor).
"""
if not hasattr(self, 'riskinputs'): # in the reportwriter
return
... | [
"def",
"execute",
"(",
"self",
")",
":",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'riskinputs'",
")",
":",
"# in the reportwriter",
"return",
"res",
"=",
"Starmap",
".",
"apply",
"(",
"self",
".",
"core_task",
".",
"__func__",
",",
"(",
"self",
".",
... | Parallelize on the riskinputs and returns a dictionary of results.
Require a `.core_task` to be defined with signature
(riskinputs, riskmodel, rlzs_assoc, monitor). | [
"Parallelize",
"on",
"the",
"riskinputs",
"and",
"returns",
"a",
"dictionary",
"of",
"results",
".",
"Require",
"a",
".",
"core_task",
"to",
"be",
"defined",
"with",
"signature",
"(",
"riskinputs",
"riskmodel",
"rlzs_assoc",
"monitor",
")",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/base.py#L864-L878 |
gem/oq-engine | openquake/baselib/zeromq.py | bind | def bind(end_point, socket_type):
"""
Bind to a zmq URL; raise a proper error if the URL is invalid; return
a zmq socket.
"""
sock = context.socket(socket_type)
try:
sock.bind(end_point)
except zmq.error.ZMQError as exc:
sock.close()
raise exc.__class__('%s: %s' % (ex... | python | def bind(end_point, socket_type):
"""
Bind to a zmq URL; raise a proper error if the URL is invalid; return
a zmq socket.
"""
sock = context.socket(socket_type)
try:
sock.bind(end_point)
except zmq.error.ZMQError as exc:
sock.close()
raise exc.__class__('%s: %s' % (ex... | [
"def",
"bind",
"(",
"end_point",
",",
"socket_type",
")",
":",
"sock",
"=",
"context",
".",
"socket",
"(",
"socket_type",
")",
"try",
":",
"sock",
".",
"bind",
"(",
"end_point",
")",
"except",
"zmq",
".",
"error",
".",
"ZMQError",
"as",
"exc",
":",
"... | Bind to a zmq URL; raise a proper error if the URL is invalid; return
a zmq socket. | [
"Bind",
"to",
"a",
"zmq",
"URL",
";",
"raise",
"a",
"proper",
"error",
"if",
"the",
"URL",
"is",
"invalid",
";",
"return",
"a",
"zmq",
"socket",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/baselib/zeromq.py#L30-L41 |
gem/oq-engine | openquake/baselib/zeromq.py | Socket.send | def send(self, obj):
"""
Send an object to the remote server; block and return the reply
if the socket type is REQ.
:param obj:
the Python object to send
"""
self.zsocket.send_pyobj(obj)
self.num_sent += 1
if self.socket_type == zmq.REQ:
... | python | def send(self, obj):
"""
Send an object to the remote server; block and return the reply
if the socket type is REQ.
:param obj:
the Python object to send
"""
self.zsocket.send_pyobj(obj)
self.num_sent += 1
if self.socket_type == zmq.REQ:
... | [
"def",
"send",
"(",
"self",
",",
"obj",
")",
":",
"self",
".",
"zsocket",
".",
"send_pyobj",
"(",
"obj",
")",
"self",
".",
"num_sent",
"+=",
"1",
"if",
"self",
".",
"socket_type",
"==",
"zmq",
".",
"REQ",
":",
"return",
"self",
".",
"zsocket",
".",... | Send an object to the remote server; block and return the reply
if the socket type is REQ.
:param obj:
the Python object to send | [
"Send",
"an",
"object",
"to",
"the",
"remote",
"server",
";",
"block",
"and",
"return",
"the",
"reply",
"if",
"the",
"socket",
"type",
"is",
"REQ",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/baselib/zeromq.py#L139-L150 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | angular_distance | def angular_distance(km, lat, lat2=None):
"""
Return the angular distance of two points at the given latitude.
>>> '%.3f' % angular_distance(100, lat=40)
'1.174'
>>> '%.3f' % angular_distance(100, lat=80)
'5.179'
"""
if lat2 is not None:
# use the largest latitude to compute the... | python | def angular_distance(km, lat, lat2=None):
"""
Return the angular distance of two points at the given latitude.
>>> '%.3f' % angular_distance(100, lat=40)
'1.174'
>>> '%.3f' % angular_distance(100, lat=80)
'5.179'
"""
if lat2 is not None:
# use the largest latitude to compute the... | [
"def",
"angular_distance",
"(",
"km",
",",
"lat",
",",
"lat2",
"=",
"None",
")",
":",
"if",
"lat2",
"is",
"not",
"None",
":",
"# use the largest latitude to compute the angular distance",
"lat",
"=",
"max",
"(",
"abs",
"(",
"lat",
")",
",",
"abs",
"(",
"la... | Return the angular distance of two points at the given latitude.
>>> '%.3f' % angular_distance(100, lat=40)
'1.174'
>>> '%.3f' % angular_distance(100, lat=80)
'5.179' | [
"Return",
"the",
"angular",
"distance",
"of",
"two",
"points",
"at",
"the",
"given",
"latitude",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L45-L57 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | assoc | def assoc(objects, sitecol, assoc_dist, mode, asset_refs=()):
"""
Associate geographic objects to a site collection.
:param objects:
something with .lons, .lats or ['lon'] ['lat'], or a list of lists
of objects with a .location attribute (i.e. assets_by_site)
:param assoc_dist:
... | python | def assoc(objects, sitecol, assoc_dist, mode, asset_refs=()):
"""
Associate geographic objects to a site collection.
:param objects:
something with .lons, .lats or ['lon'] ['lat'], or a list of lists
of objects with a .location attribute (i.e. assets_by_site)
:param assoc_dist:
... | [
"def",
"assoc",
"(",
"objects",
",",
"sitecol",
",",
"assoc_dist",
",",
"mode",
",",
"asset_refs",
"=",
"(",
")",
")",
":",
"if",
"isinstance",
"(",
"objects",
",",
"numpy",
".",
"ndarray",
")",
"or",
"hasattr",
"(",
"objects",
",",
"'lons'",
")",
":... | Associate geographic objects to a site collection.
:param objects:
something with .lons, .lats or ['lon'] ['lat'], or a list of lists
of objects with a .location attribute (i.e. assets_by_site)
:param assoc_dist:
the maximum distance for association
:param mode:
if 'strict' ... | [
"Associate",
"geographic",
"objects",
"to",
"a",
"site",
"collection",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L177-L196 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | clean_points | def clean_points(points):
"""
Given a list of :class:`~openquake.hazardlib.geo.point.Point` objects,
return a new list with adjacent duplicate points removed.
"""
if not points:
return points
result = [points[0]]
for point in points:
if point != result[-1]:
resul... | python | def clean_points(points):
"""
Given a list of :class:`~openquake.hazardlib.geo.point.Point` objects,
return a new list with adjacent duplicate points removed.
"""
if not points:
return points
result = [points[0]]
for point in points:
if point != result[-1]:
resul... | [
"def",
"clean_points",
"(",
"points",
")",
":",
"if",
"not",
"points",
":",
"return",
"points",
"result",
"=",
"[",
"points",
"[",
"0",
"]",
"]",
"for",
"point",
"in",
"points",
":",
"if",
"point",
"!=",
"result",
"[",
"-",
"1",
"]",
":",
"result",... | Given a list of :class:`~openquake.hazardlib.geo.point.Point` objects,
return a new list with adjacent duplicate points removed. | [
"Given",
"a",
"list",
"of",
":",
"class",
":",
"~openquake",
".",
"hazardlib",
".",
"geo",
".",
"point",
".",
"Point",
"objects",
"return",
"a",
"new",
"list",
"with",
"adjacent",
"duplicate",
"points",
"removed",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L199-L211 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | line_intersects_itself | def line_intersects_itself(lons, lats, closed_shape=False):
"""
Return ``True`` if line of points intersects itself.
Line with the last point repeating the first one considered
intersecting itself.
The line is defined by lists (or numpy arrays) of points'
longitudes and latitudes (depth is not ... | python | def line_intersects_itself(lons, lats, closed_shape=False):
"""
Return ``True`` if line of points intersects itself.
Line with the last point repeating the first one considered
intersecting itself.
The line is defined by lists (or numpy arrays) of points'
longitudes and latitudes (depth is not ... | [
"def",
"line_intersects_itself",
"(",
"lons",
",",
"lats",
",",
"closed_shape",
"=",
"False",
")",
":",
"assert",
"len",
"(",
"lons",
")",
"==",
"len",
"(",
"lats",
")",
"if",
"len",
"(",
"lons",
")",
"<=",
"3",
":",
"# line can not intersect itself unless... | Return ``True`` if line of points intersects itself.
Line with the last point repeating the first one considered
intersecting itself.
The line is defined by lists (or numpy arrays) of points'
longitudes and latitudes (depth is not taken into account).
:param closed_shape:
If ``True`` the l... | [
"Return",
"True",
"if",
"line",
"of",
"points",
"intersects",
"itself",
".",
"Line",
"with",
"the",
"last",
"point",
"repeating",
"the",
"first",
"one",
"considered",
"intersecting",
"itself",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L214-L250 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | get_bounding_box | def get_bounding_box(obj, maxdist):
"""
Return the dilated bounding box of a geometric object.
:param obj:
an object with method .get_bounding_box, or with an attribute .polygon
or a list of locations
:param maxdist: maximum distance in km
"""
if hasattr(obj, 'get_bounding_box')... | python | def get_bounding_box(obj, maxdist):
"""
Return the dilated bounding box of a geometric object.
:param obj:
an object with method .get_bounding_box, or with an attribute .polygon
or a list of locations
:param maxdist: maximum distance in km
"""
if hasattr(obj, 'get_bounding_box')... | [
"def",
"get_bounding_box",
"(",
"obj",
",",
"maxdist",
")",
":",
"if",
"hasattr",
"(",
"obj",
",",
"'get_bounding_box'",
")",
":",
"return",
"obj",
".",
"get_bounding_box",
"(",
"maxdist",
")",
"elif",
"hasattr",
"(",
"obj",
",",
"'polygon'",
")",
":",
"... | Return the dilated bounding box of a geometric object.
:param obj:
an object with method .get_bounding_box, or with an attribute .polygon
or a list of locations
:param maxdist: maximum distance in km | [
"Return",
"the",
"dilated",
"bounding",
"box",
"of",
"a",
"geometric",
"object",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L267-L292 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | get_spherical_bounding_box | def get_spherical_bounding_box(lons, lats):
"""
Given a collection of points find and return the bounding box,
as a pair of longitudes and a pair of latitudes.
Parameters define longitudes and latitudes of a point collection
respectively in a form of lists or numpy arrays.
:return:
A t... | python | def get_spherical_bounding_box(lons, lats):
"""
Given a collection of points find and return the bounding box,
as a pair of longitudes and a pair of latitudes.
Parameters define longitudes and latitudes of a point collection
respectively in a form of lists or numpy arrays.
:return:
A t... | [
"def",
"get_spherical_bounding_box",
"(",
"lons",
",",
"lats",
")",
":",
"north",
",",
"south",
"=",
"numpy",
".",
"max",
"(",
"lats",
")",
",",
"numpy",
".",
"min",
"(",
"lats",
")",
"west",
",",
"east",
"=",
"numpy",
".",
"min",
"(",
"lons",
")",... | Given a collection of points find and return the bounding box,
as a pair of longitudes and a pair of latitudes.
Parameters define longitudes and latitudes of a point collection
respectively in a form of lists or numpy arrays.
:return:
A tuple of four items. These items represent western, easte... | [
"Given",
"a",
"collection",
"of",
"points",
"find",
"and",
"return",
"the",
"bounding",
"box",
"as",
"a",
"pair",
"of",
"longitudes",
"and",
"a",
"pair",
"of",
"latitudes",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L295-L329 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | get_middle_point | def get_middle_point(lon1, lat1, lon2, lat2):
"""
Given two points return the point exactly in the middle lying on the same
great circle arc.
Parameters are point coordinates in degrees.
:returns:
Tuple of longitude and latitude of the point in the middle.
"""
if lon1 == lon2 and l... | python | def get_middle_point(lon1, lat1, lon2, lat2):
"""
Given two points return the point exactly in the middle lying on the same
great circle arc.
Parameters are point coordinates in degrees.
:returns:
Tuple of longitude and latitude of the point in the middle.
"""
if lon1 == lon2 and l... | [
"def",
"get_middle_point",
"(",
"lon1",
",",
"lat1",
",",
"lon2",
",",
"lat2",
")",
":",
"if",
"lon1",
"==",
"lon2",
"and",
"lat1",
"==",
"lat2",
":",
"return",
"lon1",
",",
"lat1",
"dist",
"=",
"geodetic",
".",
"geodetic_distance",
"(",
"lon1",
",",
... | Given two points return the point exactly in the middle lying on the same
great circle arc.
Parameters are point coordinates in degrees.
:returns:
Tuple of longitude and latitude of the point in the middle. | [
"Given",
"two",
"points",
"return",
"the",
"point",
"exactly",
"in",
"the",
"middle",
"lying",
"on",
"the",
"same",
"great",
"circle",
"arc",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L428-L442 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | cartesian_to_spherical | def cartesian_to_spherical(vectors):
"""
Return the spherical coordinates for coordinates in Cartesian space.
This function does an opposite to :func:`spherical_to_cartesian`.
:param vectors:
Array of 3d vectors in Cartesian space of shape (..., 3)
:returns:
Tuple of three arrays o... | python | def cartesian_to_spherical(vectors):
"""
Return the spherical coordinates for coordinates in Cartesian space.
This function does an opposite to :func:`spherical_to_cartesian`.
:param vectors:
Array of 3d vectors in Cartesian space of shape (..., 3)
:returns:
Tuple of three arrays o... | [
"def",
"cartesian_to_spherical",
"(",
"vectors",
")",
":",
"rr",
"=",
"numpy",
".",
"sqrt",
"(",
"numpy",
".",
"sum",
"(",
"vectors",
"*",
"vectors",
",",
"axis",
"=",
"-",
"1",
")",
")",
"xx",
",",
"yy",
",",
"zz",
"=",
"vectors",
".",
"T",
"lat... | Return the spherical coordinates for coordinates in Cartesian space.
This function does an opposite to :func:`spherical_to_cartesian`.
:param vectors:
Array of 3d vectors in Cartesian space of shape (..., 3)
:returns:
Tuple of three arrays of the same shape as ``vectors`` representing
... | [
"Return",
"the",
"spherical",
"coordinates",
"for",
"coordinates",
"in",
"Cartesian",
"space",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L445-L463 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | triangle_area | def triangle_area(e1, e2, e3):
"""
Get the area of triangle formed by three vectors.
Parameters are three three-dimensional numpy arrays representing
vectors of triangle's edges in Cartesian space.
:returns:
Float number, the area of the triangle in squared units of coordinates,
or... | python | def triangle_area(e1, e2, e3):
"""
Get the area of triangle formed by three vectors.
Parameters are three three-dimensional numpy arrays representing
vectors of triangle's edges in Cartesian space.
:returns:
Float number, the area of the triangle in squared units of coordinates,
or... | [
"def",
"triangle_area",
"(",
"e1",
",",
"e2",
",",
"e3",
")",
":",
"# calculating edges length",
"e1_length",
"=",
"numpy",
".",
"sqrt",
"(",
"numpy",
".",
"sum",
"(",
"e1",
"*",
"e1",
",",
"axis",
"=",
"-",
"1",
")",
")",
"e2_length",
"=",
"numpy",
... | Get the area of triangle formed by three vectors.
Parameters are three three-dimensional numpy arrays representing
vectors of triangle's edges in Cartesian space.
:returns:
Float number, the area of the triangle in squared units of coordinates,
or numpy array of shape of edges with one dim... | [
"Get",
"the",
"area",
"of",
"triangle",
"formed",
"by",
"three",
"vectors",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L466-L486 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | normalized | def normalized(vector):
"""
Get unit vector for a given one.
:param vector:
Numpy vector as coordinates in Cartesian space, or an array of such.
:returns:
Numpy array of the same shape and structure where all vectors are
normalized. That is, each coordinate component is divided ... | python | def normalized(vector):
"""
Get unit vector for a given one.
:param vector:
Numpy vector as coordinates in Cartesian space, or an array of such.
:returns:
Numpy array of the same shape and structure where all vectors are
normalized. That is, each coordinate component is divided ... | [
"def",
"normalized",
"(",
"vector",
")",
":",
"length",
"=",
"numpy",
".",
"sum",
"(",
"vector",
"*",
"vector",
",",
"axis",
"=",
"-",
"1",
")",
"length",
"=",
"numpy",
".",
"sqrt",
"(",
"length",
".",
"reshape",
"(",
"length",
".",
"shape",
"+",
... | Get unit vector for a given one.
:param vector:
Numpy vector as coordinates in Cartesian space, or an array of such.
:returns:
Numpy array of the same shape and structure where all vectors are
normalized. That is, each coordinate component is divided by its
vector's length. | [
"Get",
"unit",
"vector",
"for",
"a",
"given",
"one",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L489-L502 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | point_to_polygon_distance | def point_to_polygon_distance(polygon, pxx, pyy):
"""
Calculate the distance to polygon for each point of the collection
on the 2d Cartesian plane.
:param polygon:
Shapely "Polygon" geometry object.
:param pxx:
List or numpy array of abscissae values of points to calculate
t... | python | def point_to_polygon_distance(polygon, pxx, pyy):
"""
Calculate the distance to polygon for each point of the collection
on the 2d Cartesian plane.
:param polygon:
Shapely "Polygon" geometry object.
:param pxx:
List or numpy array of abscissae values of points to calculate
t... | [
"def",
"point_to_polygon_distance",
"(",
"polygon",
",",
"pxx",
",",
"pyy",
")",
":",
"pxx",
"=",
"numpy",
".",
"array",
"(",
"pxx",
")",
"pyy",
"=",
"numpy",
".",
"array",
"(",
"pyy",
")",
"assert",
"pxx",
".",
"shape",
"==",
"pyy",
".",
"shape",
... | Calculate the distance to polygon for each point of the collection
on the 2d Cartesian plane.
:param polygon:
Shapely "Polygon" geometry object.
:param pxx:
List or numpy array of abscissae values of points to calculate
the distance from.
:param pyy:
Same structure as ``... | [
"Calculate",
"the",
"distance",
"to",
"polygon",
"for",
"each",
"point",
"of",
"the",
"collection",
"on",
"the",
"2d",
"Cartesian",
"plane",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L505-L531 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | cross_idl | def cross_idl(lon1, lon2, *lons):
"""
Return True if two longitude values define line crossing international date
line.
>>> cross_idl(-45, 45)
False
>>> cross_idl(-180, -179)
False
>>> cross_idl(180, 179)
False
>>> cross_idl(45, -45)
False
>>> cross_idl(0, 0)
False
... | python | def cross_idl(lon1, lon2, *lons):
"""
Return True if two longitude values define line crossing international date
line.
>>> cross_idl(-45, 45)
False
>>> cross_idl(-180, -179)
False
>>> cross_idl(180, 179)
False
>>> cross_idl(45, -45)
False
>>> cross_idl(0, 0)
False
... | [
"def",
"cross_idl",
"(",
"lon1",
",",
"lon2",
",",
"*",
"lons",
")",
":",
"lons",
"=",
"(",
"lon1",
",",
"lon2",
")",
"+",
"lons",
"l1",
",",
"l2",
"=",
"min",
"(",
"lons",
")",
",",
"max",
"(",
"lons",
")",
"# a line crosses the international date l... | Return True if two longitude values define line crossing international date
line.
>>> cross_idl(-45, 45)
False
>>> cross_idl(-180, -179)
False
>>> cross_idl(180, 179)
False
>>> cross_idl(45, -45)
False
>>> cross_idl(0, 0)
False
>>> cross_idl(-170, 170)
True
>>> c... | [
"Return",
"True",
"if",
"two",
"longitude",
"values",
"define",
"line",
"crossing",
"international",
"date",
"line",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L548-L574 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | normalize_lons | def normalize_lons(l1, l2):
"""
An international date line safe way of returning a range of longitudes.
>>> normalize_lons(20, 30) # no IDL within the range
[(20, 30)]
>>> normalize_lons(-17, +17) # no IDL within the range
[(-17, 17)]
>>> normalize_lons(-178, +179)
[(-180, -178), (179... | python | def normalize_lons(l1, l2):
"""
An international date line safe way of returning a range of longitudes.
>>> normalize_lons(20, 30) # no IDL within the range
[(20, 30)]
>>> normalize_lons(-17, +17) # no IDL within the range
[(-17, 17)]
>>> normalize_lons(-178, +179)
[(-180, -178), (179... | [
"def",
"normalize_lons",
"(",
"l1",
",",
"l2",
")",
":",
"if",
"l1",
">",
"l2",
":",
"# exchange lons",
"l1",
",",
"l2",
"=",
"l2",
",",
"l1",
"delta",
"=",
"l2",
"-",
"l1",
"if",
"l1",
"<",
"0",
"and",
"l2",
">",
"0",
"and",
"delta",
">",
"1... | An international date line safe way of returning a range of longitudes.
>>> normalize_lons(20, 30) # no IDL within the range
[(20, 30)]
>>> normalize_lons(-17, +17) # no IDL within the range
[(-17, 17)]
>>> normalize_lons(-178, +179)
[(-180, -178), (179, 180)]
>>> normalize_lons(178, -179... | [
"An",
"international",
"date",
"line",
"safe",
"way",
"of",
"returning",
"a",
"range",
"of",
"longitudes",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L577-L603 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | within | def within(bbox, lonlat_index):
"""
:param bbox: a bounding box in lon, lat
:param lonlat_index: an rtree index in lon, lat
:returns: array of indices within the bounding box
"""
lon1, lat1, lon2, lat2 = bbox
set_ = set()
for l1, l2 in normalize_lons(lon1, lon2):
box = (l1, lat1,... | python | def within(bbox, lonlat_index):
"""
:param bbox: a bounding box in lon, lat
:param lonlat_index: an rtree index in lon, lat
:returns: array of indices within the bounding box
"""
lon1, lat1, lon2, lat2 = bbox
set_ = set()
for l1, l2 in normalize_lons(lon1, lon2):
box = (l1, lat1,... | [
"def",
"within",
"(",
"bbox",
",",
"lonlat_index",
")",
":",
"lon1",
",",
"lat1",
",",
"lon2",
",",
"lat2",
"=",
"bbox",
"set_",
"=",
"set",
"(",
")",
"for",
"l1",
",",
"l2",
"in",
"normalize_lons",
"(",
"lon1",
",",
"lon2",
")",
":",
"box",
"=",... | :param bbox: a bounding box in lon, lat
:param lonlat_index: an rtree index in lon, lat
:returns: array of indices within the bounding box | [
":",
"param",
"bbox",
":",
"a",
"bounding",
"box",
"in",
"lon",
"lat",
":",
"param",
"lonlat_index",
":",
"an",
"rtree",
"index",
"in",
"lon",
"lat",
":",
"returns",
":",
"array",
"of",
"indices",
"within",
"the",
"bounding",
"box"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L606-L617 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | plane_fit | def plane_fit(points):
"""
This fits an n-dimensional plane to a set of points. See
http://stackoverflow.com/questions/12299540/plane-fitting-to-4-or-more-xyz-points
:parameter points:
An instance of :class:~numpy.ndarray. The number of columns must be
equal to three.
:return:
... | python | def plane_fit(points):
"""
This fits an n-dimensional plane to a set of points. See
http://stackoverflow.com/questions/12299540/plane-fitting-to-4-or-more-xyz-points
:parameter points:
An instance of :class:~numpy.ndarray. The number of columns must be
equal to three.
:return:
... | [
"def",
"plane_fit",
"(",
"points",
")",
":",
"points",
"=",
"numpy",
".",
"transpose",
"(",
"points",
")",
"points",
"=",
"numpy",
".",
"reshape",
"(",
"points",
",",
"(",
"numpy",
".",
"shape",
"(",
"points",
")",
"[",
"0",
"]",
",",
"-",
"1",
"... | This fits an n-dimensional plane to a set of points. See
http://stackoverflow.com/questions/12299540/plane-fitting-to-4-or-more-xyz-points
:parameter points:
An instance of :class:~numpy.ndarray. The number of columns must be
equal to three.
:return:
A point on the plane and the no... | [
"This",
"fits",
"an",
"n",
"-",
"dimensional",
"plane",
"to",
"a",
"set",
"of",
"points",
".",
"See",
"http",
":",
"//",
"stackoverflow",
".",
"com",
"/",
"questions",
"/",
"12299540",
"/",
"plane",
"-",
"fitting",
"-",
"to",
"-",
"4",
"-",
"or",
"... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L620-L637 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | _GeographicObjects.get_closest | def get_closest(self, lon, lat, depth=0):
"""
Get the closest object to the given longitude and latitude
and its distance.
:param lon: longitude in degrees
:param lat: latitude in degrees
:param depth: depth in km (default 0)
:returns: (object, distance)
... | python | def get_closest(self, lon, lat, depth=0):
"""
Get the closest object to the given longitude and latitude
and its distance.
:param lon: longitude in degrees
:param lat: latitude in degrees
:param depth: depth in km (default 0)
:returns: (object, distance)
... | [
"def",
"get_closest",
"(",
"self",
",",
"lon",
",",
"lat",
",",
"depth",
"=",
"0",
")",
":",
"xyz",
"=",
"spherical_to_cartesian",
"(",
"lon",
",",
"lat",
",",
"depth",
")",
"min_dist",
",",
"idx",
"=",
"self",
".",
"kdtree",
".",
"query",
"(",
"xy... | Get the closest object to the given longitude and latitude
and its distance.
:param lon: longitude in degrees
:param lat: latitude in degrees
:param depth: depth in km (default 0)
:returns: (object, distance) | [
"Get",
"the",
"closest",
"object",
"to",
"the",
"given",
"longitude",
"and",
"latitude",
"and",
"its",
"distance",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L85-L97 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | _GeographicObjects.assoc | def assoc(self, sitecol, assoc_dist, mode):
"""
:param sitecol: a (filtered) site collection
:param assoc_dist: the maximum distance for association
:param mode: 'strict', 'warn' or 'filter'
:returns: filtered site collection, filtered objects, discarded
"""
asser... | python | def assoc(self, sitecol, assoc_dist, mode):
"""
:param sitecol: a (filtered) site collection
:param assoc_dist: the maximum distance for association
:param mode: 'strict', 'warn' or 'filter'
:returns: filtered site collection, filtered objects, discarded
"""
asser... | [
"def",
"assoc",
"(",
"self",
",",
"sitecol",
",",
"assoc_dist",
",",
"mode",
")",
":",
"assert",
"mode",
"in",
"'strict warn filter'",
",",
"mode",
"dic",
"=",
"{",
"}",
"discarded",
"=",
"[",
"]",
"for",
"sid",
",",
"lon",
",",
"lat",
"in",
"zip",
... | :param sitecol: a (filtered) site collection
:param assoc_dist: the maximum distance for association
:param mode: 'strict', 'warn' or 'filter'
:returns: filtered site collection, filtered objects, discarded | [
":",
"param",
"sitecol",
":",
"a",
"(",
"filtered",
")",
"site",
"collection",
":",
"param",
"assoc_dist",
":",
"the",
"maximum",
"distance",
"for",
"association",
":",
"param",
"mode",
":",
"strict",
"warn",
"or",
"filter",
":",
"returns",
":",
"filtered"... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L99-L132 |
gem/oq-engine | openquake/hazardlib/geo/utils.py | _GeographicObjects.assoc2 | def assoc2(self, assets_by_site, assoc_dist, mode, asset_refs):
"""
Associated a list of assets by site to the site collection used
to instantiate GeographicObjects.
:param assets_by_sites: a list of lists of assets
:param assoc_dist: the maximum distance for association
... | python | def assoc2(self, assets_by_site, assoc_dist, mode, asset_refs):
"""
Associated a list of assets by site to the site collection used
to instantiate GeographicObjects.
:param assets_by_sites: a list of lists of assets
:param assoc_dist: the maximum distance for association
... | [
"def",
"assoc2",
"(",
"self",
",",
"assets_by_site",
",",
"assoc_dist",
",",
"mode",
",",
"asset_refs",
")",
":",
"assert",
"mode",
"in",
"'strict filter'",
",",
"mode",
"self",
".",
"objects",
".",
"filtered",
"# self.objects must be a SiteCollection",
"asset_dt"... | Associated a list of assets by site to the site collection used
to instantiate GeographicObjects.
:param assets_by_sites: a list of lists of assets
:param assoc_dist: the maximum distance for association
:param mode: 'strict', 'warn' or 'filter'
:param asset_ref: ID of the asset... | [
"Associated",
"a",
"list",
"of",
"assets",
"by",
"site",
"to",
"the",
"site",
"collection",
"used",
"to",
"instantiate",
"GeographicObjects",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/hazardlib/geo/utils.py#L134-L174 |
gem/oq-engine | openquake/risklib/read_nrml.py | get_vulnerability_functions_04 | def get_vulnerability_functions_04(node, fname):
"""
:param node:
a vulnerabilityModel node
:param fname:
path to the vulnerability file
:returns:
a dictionary imt, vf_id -> vulnerability function
"""
logging.warning('Please upgrade %s to NRML 0.5', fname)
# NB: the I... | python | def get_vulnerability_functions_04(node, fname):
"""
:param node:
a vulnerabilityModel node
:param fname:
path to the vulnerability file
:returns:
a dictionary imt, vf_id -> vulnerability function
"""
logging.warning('Please upgrade %s to NRML 0.5', fname)
# NB: the I... | [
"def",
"get_vulnerability_functions_04",
"(",
"node",
",",
"fname",
")",
":",
"logging",
".",
"warning",
"(",
"'Please upgrade %s to NRML 0.5'",
",",
"fname",
")",
"# NB: the IMTs can be duplicated and with different levels, each",
"# vulnerability function in a set will get its ow... | :param node:
a vulnerabilityModel node
:param fname:
path to the vulnerability file
:returns:
a dictionary imt, vf_id -> vulnerability function | [
":",
"param",
"node",
":",
"a",
"vulnerabilityModel",
"node",
":",
"param",
"fname",
":",
"path",
"to",
"the",
"vulnerability",
"file",
":",
"returns",
":",
"a",
"dictionary",
"imt",
"vf_id",
"-",
">",
"vulnerability",
"function"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/read_nrml.py#L34-L78 |
gem/oq-engine | openquake/risklib/read_nrml.py | get_vulnerability_functions_05 | def get_vulnerability_functions_05(node, fname):
"""
:param node:
a vulnerabilityModel node
:param fname:
path of the vulnerability filter
:returns:
a dictionary imt, vf_id -> vulnerability function
"""
# NB: the IMTs can be duplicated and with different levels, each
... | python | def get_vulnerability_functions_05(node, fname):
"""
:param node:
a vulnerabilityModel node
:param fname:
path of the vulnerability filter
:returns:
a dictionary imt, vf_id -> vulnerability function
"""
# NB: the IMTs can be duplicated and with different levels, each
... | [
"def",
"get_vulnerability_functions_05",
"(",
"node",
",",
"fname",
")",
":",
"# NB: the IMTs can be duplicated and with different levels, each",
"# vulnerability function in a set will get its own levels",
"vf_ids",
"=",
"set",
"(",
")",
"vmodel",
"=",
"scientific",
".",
"Vuln... | :param node:
a vulnerabilityModel node
:param fname:
path of the vulnerability filter
:returns:
a dictionary imt, vf_id -> vulnerability function | [
":",
"param",
"node",
":",
"a",
"vulnerabilityModel",
"node",
":",
"param",
"fname",
":",
"path",
"of",
"the",
"vulnerability",
"filter",
":",
"returns",
":",
"a",
"dictionary",
"imt",
"vf_id",
"-",
">",
"vulnerability",
"function"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/read_nrml.py#L82-L146 |
gem/oq-engine | openquake/risklib/read_nrml.py | ffconvert | def ffconvert(fname, limit_states, ff, min_iml=1E-10):
"""
Convert a fragility function into a numpy array plus a bunch
of attributes.
:param fname: path to the fragility model file
:param limit_states: expected limit states
:param ff: fragility function node
:returns: a pair (array, dictio... | python | def ffconvert(fname, limit_states, ff, min_iml=1E-10):
"""
Convert a fragility function into a numpy array plus a bunch
of attributes.
:param fname: path to the fragility model file
:param limit_states: expected limit states
:param ff: fragility function node
:returns: a pair (array, dictio... | [
"def",
"ffconvert",
"(",
"fname",
",",
"limit_states",
",",
"ff",
",",
"min_iml",
"=",
"1E-10",
")",
":",
"with",
"context",
"(",
"fname",
",",
"ff",
")",
":",
"ffs",
"=",
"ff",
"[",
"1",
":",
"]",
"imls",
"=",
"ff",
".",
"imls",
"nodamage",
"=",... | Convert a fragility function into a numpy array plus a bunch
of attributes.
:param fname: path to the fragility model file
:param limit_states: expected limit states
:param ff: fragility function node
:returns: a pair (array, dictionary) | [
"Convert",
"a",
"fragility",
"function",
"into",
"a",
"numpy",
"array",
"plus",
"a",
"bunch",
"of",
"attributes",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/read_nrml.py#L152-L217 |
gem/oq-engine | openquake/risklib/read_nrml.py | get_fragility_model | def get_fragility_model(node, fname):
"""
:param node:
a vulnerabilityModel node
:param fname:
path to the vulnerability file
:returns:
a dictionary imt, ff_id -> fragility function list
"""
with context(fname, node):
fid = node['id']
asset_category = node... | python | def get_fragility_model(node, fname):
"""
:param node:
a vulnerabilityModel node
:param fname:
path to the vulnerability file
:returns:
a dictionary imt, ff_id -> fragility function list
"""
with context(fname, node):
fid = node['id']
asset_category = node... | [
"def",
"get_fragility_model",
"(",
"node",
",",
"fname",
")",
":",
"with",
"context",
"(",
"fname",
",",
"node",
")",
":",
"fid",
"=",
"node",
"[",
"'id'",
"]",
"asset_category",
"=",
"node",
"[",
"'assetCategory'",
"]",
"loss_type",
"=",
"node",
"[",
... | :param node:
a vulnerabilityModel node
:param fname:
path to the vulnerability file
:returns:
a dictionary imt, ff_id -> fragility function list | [
":",
"param",
"node",
":",
"a",
"vulnerabilityModel",
"node",
":",
"param",
"fname",
":",
"path",
"to",
"the",
"vulnerability",
"file",
":",
"returns",
":",
"a",
"dictionary",
"imt",
"ff_id",
"-",
">",
"fragility",
"function",
"list"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/read_nrml.py#L221-L244 |
gem/oq-engine | openquake/risklib/read_nrml.py | convert_fragility_model_04 | def convert_fragility_model_04(node, fname, fmcounter=itertools.count(1)):
"""
:param node:
an :class:`openquake.commonib.node.Node` in NRML 0.4
:param fname:
path of the fragility file
:returns:
an :class:`openquake.commonib.node.Node` in NRML 0.5
"""
convert_type = {"lo... | python | def convert_fragility_model_04(node, fname, fmcounter=itertools.count(1)):
"""
:param node:
an :class:`openquake.commonib.node.Node` in NRML 0.4
:param fname:
path of the fragility file
:returns:
an :class:`openquake.commonib.node.Node` in NRML 0.5
"""
convert_type = {"lo... | [
"def",
"convert_fragility_model_04",
"(",
"node",
",",
"fname",
",",
"fmcounter",
"=",
"itertools",
".",
"count",
"(",
"1",
")",
")",
":",
"convert_type",
"=",
"{",
"\"lognormal\"",
":",
"\"logncdf\"",
"}",
"new",
"=",
"Node",
"(",
"'fragilityModel'",
",",
... | :param node:
an :class:`openquake.commonib.node.Node` in NRML 0.4
:param fname:
path of the fragility file
:returns:
an :class:`openquake.commonib.node.Node` in NRML 0.5 | [
":",
"param",
"node",
":",
"an",
":",
"class",
":",
"openquake",
".",
"commonib",
".",
"node",
".",
"Node",
"in",
"NRML",
"0",
".",
"4",
":",
"param",
"fname",
":",
"path",
"of",
"the",
"fragility",
"file",
":",
"returns",
":",
"an",
":",
"class",
... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/read_nrml.py#L282-L338 |
gem/oq-engine | openquake/risklib/read_nrml.py | get_fragility_model_04 | def get_fragility_model_04(fmodel, fname):
"""
:param fmodel:
a fragilityModel node
:param fname:
path of the fragility file
:returns:
an :class:`openquake.risklib.scientific.FragilityModel` instance
"""
logging.warning('Please upgrade %s to NRML 0.5', fname)
node05 =... | python | def get_fragility_model_04(fmodel, fname):
"""
:param fmodel:
a fragilityModel node
:param fname:
path of the fragility file
:returns:
an :class:`openquake.risklib.scientific.FragilityModel` instance
"""
logging.warning('Please upgrade %s to NRML 0.5', fname)
node05 =... | [
"def",
"get_fragility_model_04",
"(",
"fmodel",
",",
"fname",
")",
":",
"logging",
".",
"warning",
"(",
"'Please upgrade %s to NRML 0.5'",
",",
"fname",
")",
"node05",
"=",
"convert_fragility_model_04",
"(",
"fmodel",
",",
"fname",
")",
"node05",
".",
"limitStates... | :param fmodel:
a fragilityModel node
:param fname:
path of the fragility file
:returns:
an :class:`openquake.risklib.scientific.FragilityModel` instance | [
":",
"param",
"fmodel",
":",
"a",
"fragilityModel",
"node",
":",
"param",
"fname",
":",
"path",
"of",
"the",
"fragility",
"file",
":",
"returns",
":",
"an",
":",
"class",
":",
"openquake",
".",
"risklib",
".",
"scientific",
".",
"FragilityModel",
"instance... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/read_nrml.py#L342-L354 |
gem/oq-engine | openquake/risklib/read_nrml.py | taxonomy | def taxonomy(value):
"""
Any ASCII character goes into a taxonomy, except spaces.
"""
try:
value.encode('ascii')
except UnicodeEncodeError:
raise ValueError('tag %r is not ASCII' % value)
if re.search(r'\s', value):
raise ValueError('The taxonomy %r contains whitespace ch... | python | def taxonomy(value):
"""
Any ASCII character goes into a taxonomy, except spaces.
"""
try:
value.encode('ascii')
except UnicodeEncodeError:
raise ValueError('tag %r is not ASCII' % value)
if re.search(r'\s', value):
raise ValueError('The taxonomy %r contains whitespace ch... | [
"def",
"taxonomy",
"(",
"value",
")",
":",
"try",
":",
"value",
".",
"encode",
"(",
"'ascii'",
")",
"except",
"UnicodeEncodeError",
":",
"raise",
"ValueError",
"(",
"'tag %r is not ASCII'",
"%",
"value",
")",
"if",
"re",
".",
"search",
"(",
"r'\\s'",
",",
... | Any ASCII character goes into a taxonomy, except spaces. | [
"Any",
"ASCII",
"character",
"goes",
"into",
"a",
"taxonomy",
"except",
"spaces",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/read_nrml.py#L371-L381 |
gem/oq-engine | openquake/risklib/read_nrml.py | update_validators | def update_validators():
"""
Call this to updade the global nrml.validators
"""
validators.update({
'fragilityFunction.id': valid.utf8, # taxonomy
'vulnerabilityFunction.id': valid.utf8, # taxonomy
'consequenceFunction.id': valid.utf8, # taxonomy
'asset.id': valid.asse... | python | def update_validators():
"""
Call this to updade the global nrml.validators
"""
validators.update({
'fragilityFunction.id': valid.utf8, # taxonomy
'vulnerabilityFunction.id': valid.utf8, # taxonomy
'consequenceFunction.id': valid.utf8, # taxonomy
'asset.id': valid.asse... | [
"def",
"update_validators",
"(",
")",
":",
"validators",
".",
"update",
"(",
"{",
"'fragilityFunction.id'",
":",
"valid",
".",
"utf8",
",",
"# taxonomy",
"'vulnerabilityFunction.id'",
":",
"valid",
".",
"utf8",
",",
"# taxonomy",
"'consequenceFunction.id'",
":",
"... | Call this to updade the global nrml.validators | [
"Call",
"this",
"to",
"updade",
"the",
"global",
"nrml",
".",
"validators"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/risklib/read_nrml.py#L384-L437 |
gem/oq-engine | openquake/calculators/extract.py | get_info | def get_info(dstore):
"""
:returns: {'stats': dic, 'loss_types': dic, 'num_rlzs': R}
"""
oq = dstore['oqparam']
stats = {stat: s for s, stat in enumerate(oq.hazard_stats())}
loss_types = {lt: l for l, lt in enumerate(oq.loss_dt().names)}
imt = {imt: i for i, imt in enumerate(oq.imtls)}
n... | python | def get_info(dstore):
"""
:returns: {'stats': dic, 'loss_types': dic, 'num_rlzs': R}
"""
oq = dstore['oqparam']
stats = {stat: s for s, stat in enumerate(oq.hazard_stats())}
loss_types = {lt: l for l, lt in enumerate(oq.loss_dt().names)}
imt = {imt: i for i, imt in enumerate(oq.imtls)}
n... | [
"def",
"get_info",
"(",
"dstore",
")",
":",
"oq",
"=",
"dstore",
"[",
"'oqparam'",
"]",
"stats",
"=",
"{",
"stat",
":",
"s",
"for",
"s",
",",
"stat",
"in",
"enumerate",
"(",
"oq",
".",
"hazard_stats",
"(",
")",
")",
"}",
"loss_types",
"=",
"{",
"... | :returns: {'stats': dic, 'loss_types': dic, 'num_rlzs': R} | [
":",
"returns",
":",
"{",
"stats",
":",
"dic",
"loss_types",
":",
"dic",
"num_rlzs",
":",
"R",
"}"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L56-L67 |
gem/oq-engine | openquake/calculators/extract.py | parse | def parse(query_string, info={}):
"""
:returns: a normalized query_dict as in the following examples:
>>> parse('kind=stats', {'stats': {'mean': 0, 'max': 1}})
{'kind': ['mean', 'max'], 'k': [0, 1], 'rlzs': False}
>>> parse('kind=rlzs', {'stats': {}, 'num_rlzs': 3})
{'kind': ['rlz-000', 'rlz-00... | python | def parse(query_string, info={}):
"""
:returns: a normalized query_dict as in the following examples:
>>> parse('kind=stats', {'stats': {'mean': 0, 'max': 1}})
{'kind': ['mean', 'max'], 'k': [0, 1], 'rlzs': False}
>>> parse('kind=rlzs', {'stats': {}, 'num_rlzs': 3})
{'kind': ['rlz-000', 'rlz-00... | [
"def",
"parse",
"(",
"query_string",
",",
"info",
"=",
"{",
"}",
")",
":",
"qdic",
"=",
"parse_qs",
"(",
"query_string",
")",
"loss_types",
"=",
"info",
".",
"get",
"(",
"'loss_types'",
",",
"[",
"]",
")",
"for",
"key",
",",
"val",
"in",
"qdic",
".... | :returns: a normalized query_dict as in the following examples:
>>> parse('kind=stats', {'stats': {'mean': 0, 'max': 1}})
{'kind': ['mean', 'max'], 'k': [0, 1], 'rlzs': False}
>>> parse('kind=rlzs', {'stats': {}, 'num_rlzs': 3})
{'kind': ['rlz-000', 'rlz-001', 'rlz-002'], 'k': [0, 1, 2], 'rlzs': True}
... | [
":",
"returns",
":",
"a",
"normalized",
"query_dict",
"as",
"in",
"the",
"following",
"examples",
":"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L93-L115 |
gem/oq-engine | openquake/calculators/extract.py | barray | def barray(iterlines):
"""
Array of bytes
"""
lst = [line.encode('utf-8') for line in iterlines]
arr = numpy.array(lst)
return arr | python | def barray(iterlines):
"""
Array of bytes
"""
lst = [line.encode('utf-8') for line in iterlines]
arr = numpy.array(lst)
return arr | [
"def",
"barray",
"(",
"iterlines",
")",
":",
"lst",
"=",
"[",
"line",
".",
"encode",
"(",
"'utf-8'",
")",
"for",
"line",
"in",
"iterlines",
"]",
"arr",
"=",
"numpy",
".",
"array",
"(",
"lst",
")",
"return",
"arr"
] | Array of bytes | [
"Array",
"of",
"bytes"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L130-L136 |
gem/oq-engine | openquake/calculators/extract.py | extract_ | def extract_(dstore, dspath):
"""
Extracts an HDF5 path object from the datastore, for instance
extract(dstore, 'sitecol').
"""
obj = dstore[dspath]
if isinstance(obj, Dataset):
return ArrayWrapper(obj.value, obj.attrs)
elif isinstance(obj, Group):
return ArrayWrapper(numpy.a... | python | def extract_(dstore, dspath):
"""
Extracts an HDF5 path object from the datastore, for instance
extract(dstore, 'sitecol').
"""
obj = dstore[dspath]
if isinstance(obj, Dataset):
return ArrayWrapper(obj.value, obj.attrs)
elif isinstance(obj, Group):
return ArrayWrapper(numpy.a... | [
"def",
"extract_",
"(",
"dstore",
",",
"dspath",
")",
":",
"obj",
"=",
"dstore",
"[",
"dspath",
"]",
"if",
"isinstance",
"(",
"obj",
",",
"Dataset",
")",
":",
"return",
"ArrayWrapper",
"(",
"obj",
".",
"value",
",",
"obj",
".",
"attrs",
")",
"elif",
... | Extracts an HDF5 path object from the datastore, for instance
extract(dstore, 'sitecol'). | [
"Extracts",
"an",
"HDF5",
"path",
"object",
"from",
"the",
"datastore",
"for",
"instance",
"extract",
"(",
"dstore",
"sitecol",
")",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L139-L150 |
gem/oq-engine | openquake/calculators/extract.py | extract_realizations | def extract_realizations(dstore, dummy):
"""
Extract an array of realizations. Use it as /extract/realizations
"""
rlzs = dstore['csm_info'].rlzs
dt = [('ordinal', U32), ('weight', F32), ('gsims', '<S64')]
arr = numpy.zeros(len(rlzs), dt)
arr['ordinal'] = rlzs['ordinal']
arr['weight'] = ... | python | def extract_realizations(dstore, dummy):
"""
Extract an array of realizations. Use it as /extract/realizations
"""
rlzs = dstore['csm_info'].rlzs
dt = [('ordinal', U32), ('weight', F32), ('gsims', '<S64')]
arr = numpy.zeros(len(rlzs), dt)
arr['ordinal'] = rlzs['ordinal']
arr['weight'] = ... | [
"def",
"extract_realizations",
"(",
"dstore",
",",
"dummy",
")",
":",
"rlzs",
"=",
"dstore",
"[",
"'csm_info'",
"]",
".",
"rlzs",
"dt",
"=",
"[",
"(",
"'ordinal'",
",",
"U32",
")",
",",
"(",
"'weight'",
",",
"F32",
")",
",",
"(",
"'gsims'",
",",
"'... | Extract an array of realizations. Use it as /extract/realizations | [
"Extract",
"an",
"array",
"of",
"realizations",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"realizations"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L188-L198 |
gem/oq-engine | openquake/calculators/extract.py | extract_exposure_metadata | def extract_exposure_metadata(dstore, what):
"""
Extract the loss categories and the tags of the exposure.
Use it as /extract/exposure_metadata
"""
dic = {}
dic1, dic2 = dstore['assetcol/tagcol'].__toh5__()
dic.update(dic1)
dic.update(dic2)
if 'asset_risk' in dstore:
dic['mul... | python | def extract_exposure_metadata(dstore, what):
"""
Extract the loss categories and the tags of the exposure.
Use it as /extract/exposure_metadata
"""
dic = {}
dic1, dic2 = dstore['assetcol/tagcol'].__toh5__()
dic.update(dic1)
dic.update(dic2)
if 'asset_risk' in dstore:
dic['mul... | [
"def",
"extract_exposure_metadata",
"(",
"dstore",
",",
"what",
")",
":",
"dic",
"=",
"{",
"}",
"dic1",
",",
"dic2",
"=",
"dstore",
"[",
"'assetcol/tagcol'",
"]",
".",
"__toh5__",
"(",
")",
"dic",
".",
"update",
"(",
"dic1",
")",
"dic",
".",
"update",
... | Extract the loss categories and the tags of the exposure.
Use it as /extract/exposure_metadata | [
"Extract",
"the",
"loss",
"categories",
"and",
"the",
"tags",
"of",
"the",
"exposure",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"exposure_metadata"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L202-L218 |
gem/oq-engine | openquake/calculators/extract.py | extract_assets | def extract_assets(dstore, what):
"""
Extract an array of assets, optionally filtered by tag.
Use it as /extract/assets?taxonomy=RC&taxonomy=MSBC&occupancy=RES
"""
qdict = parse(what)
dic = {}
dic1, dic2 = dstore['assetcol/tagcol'].__toh5__()
dic.update(dic1)
dic.update(dic2)
arr... | python | def extract_assets(dstore, what):
"""
Extract an array of assets, optionally filtered by tag.
Use it as /extract/assets?taxonomy=RC&taxonomy=MSBC&occupancy=RES
"""
qdict = parse(what)
dic = {}
dic1, dic2 = dstore['assetcol/tagcol'].__toh5__()
dic.update(dic1)
dic.update(dic2)
arr... | [
"def",
"extract_assets",
"(",
"dstore",
",",
"what",
")",
":",
"qdict",
"=",
"parse",
"(",
"what",
")",
"dic",
"=",
"{",
"}",
"dic1",
",",
"dic2",
"=",
"dstore",
"[",
"'assetcol/tagcol'",
"]",
".",
"__toh5__",
"(",
")",
"dic",
".",
"update",
"(",
"... | Extract an array of assets, optionally filtered by tag.
Use it as /extract/assets?taxonomy=RC&taxonomy=MSBC&occupancy=RES | [
"Extract",
"an",
"array",
"of",
"assets",
"optionally",
"filtered",
"by",
"tag",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"assets?taxonomy",
"=",
"RC&taxonomy",
"=",
"MSBC&occupancy",
"=",
"RES"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L222-L239 |
gem/oq-engine | openquake/calculators/extract.py | extract_asset_values | def extract_asset_values(dstore, sid):
"""
Extract an array of asset values for the given sid. Use it as
/extract/asset_values/0
:returns:
(aid, loss_type1, ..., loss_typeN) composite array
"""
if sid:
return extract(dstore, 'asset_values')[int(sid)]
assetcol = extract(dstor... | python | def extract_asset_values(dstore, sid):
"""
Extract an array of asset values for the given sid. Use it as
/extract/asset_values/0
:returns:
(aid, loss_type1, ..., loss_typeN) composite array
"""
if sid:
return extract(dstore, 'asset_values')[int(sid)]
assetcol = extract(dstor... | [
"def",
"extract_asset_values",
"(",
"dstore",
",",
"sid",
")",
":",
"if",
"sid",
":",
"return",
"extract",
"(",
"dstore",
",",
"'asset_values'",
")",
"[",
"int",
"(",
"sid",
")",
"]",
"assetcol",
"=",
"extract",
"(",
"dstore",
",",
"'assetcol'",
")",
"... | Extract an array of asset values for the given sid. Use it as
/extract/asset_values/0
:returns:
(aid, loss_type1, ..., loss_typeN) composite array | [
"Extract",
"an",
"array",
"of",
"asset",
"values",
"for",
"the",
"given",
"sid",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"asset_values",
"/",
"0"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L264-L289 |
gem/oq-engine | openquake/calculators/extract.py | extract_asset_tags | def extract_asset_tags(dstore, tagname):
"""
Extract an array of asset tags for the given tagname. Use it as
/extract/asset_tags or /extract/asset_tags/taxonomy
"""
tagcol = dstore['assetcol/tagcol']
if tagname:
yield tagname, barray(tagcol.gen_tags(tagname))
for tagname in tagcol.ta... | python | def extract_asset_tags(dstore, tagname):
"""
Extract an array of asset tags for the given tagname. Use it as
/extract/asset_tags or /extract/asset_tags/taxonomy
"""
tagcol = dstore['assetcol/tagcol']
if tagname:
yield tagname, barray(tagcol.gen_tags(tagname))
for tagname in tagcol.ta... | [
"def",
"extract_asset_tags",
"(",
"dstore",
",",
"tagname",
")",
":",
"tagcol",
"=",
"dstore",
"[",
"'assetcol/tagcol'",
"]",
"if",
"tagname",
":",
"yield",
"tagname",
",",
"barray",
"(",
"tagcol",
".",
"gen_tags",
"(",
"tagname",
")",
")",
"for",
"tagname... | Extract an array of asset tags for the given tagname. Use it as
/extract/asset_tags or /extract/asset_tags/taxonomy | [
"Extract",
"an",
"array",
"of",
"asset",
"tags",
"for",
"the",
"given",
"tagname",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"asset_tags",
"or",
"/",
"extract",
"/",
"asset_tags",
"/",
"taxonomy"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L293-L302 |
gem/oq-engine | openquake/calculators/extract.py | get_mesh | def get_mesh(sitecol, complete=True):
"""
:returns:
a lon-lat or lon-lat-depth array depending if the site collection
is at sea level or not
"""
sc = sitecol.complete if complete else sitecol
if sc.at_sea_level():
mesh = numpy.zeros(len(sc), [('lon', F64), ('lat', F64)])
... | python | def get_mesh(sitecol, complete=True):
"""
:returns:
a lon-lat or lon-lat-depth array depending if the site collection
is at sea level or not
"""
sc = sitecol.complete if complete else sitecol
if sc.at_sea_level():
mesh = numpy.zeros(len(sc), [('lon', F64), ('lat', F64)])
... | [
"def",
"get_mesh",
"(",
"sitecol",
",",
"complete",
"=",
"True",
")",
":",
"sc",
"=",
"sitecol",
".",
"complete",
"if",
"complete",
"else",
"sitecol",
"if",
"sc",
".",
"at_sea_level",
"(",
")",
":",
"mesh",
"=",
"numpy",
".",
"zeros",
"(",
"len",
"("... | :returns:
a lon-lat or lon-lat-depth array depending if the site collection
is at sea level or not | [
":",
"returns",
":",
"a",
"lon",
"-",
"lat",
"or",
"lon",
"-",
"lat",
"-",
"depth",
"array",
"depending",
"if",
"the",
"site",
"collection",
"is",
"at",
"sea",
"level",
"or",
"not"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L305-L322 |
gem/oq-engine | openquake/calculators/extract.py | hazard_items | def hazard_items(dic, mesh, *extras, **kw):
"""
:param dic: dictionary of arrays of the same shape
:param mesh: a mesh array with lon, lat fields of the same length
:param extras: optional triples (field, dtype, values)
:param kw: dictionary of parameters (like investigation_time)
:returns: a li... | python | def hazard_items(dic, mesh, *extras, **kw):
"""
:param dic: dictionary of arrays of the same shape
:param mesh: a mesh array with lon, lat fields of the same length
:param extras: optional triples (field, dtype, values)
:param kw: dictionary of parameters (like investigation_time)
:returns: a li... | [
"def",
"hazard_items",
"(",
"dic",
",",
"mesh",
",",
"*",
"extras",
",",
"*",
"*",
"kw",
")",
":",
"for",
"item",
"in",
"kw",
".",
"items",
"(",
")",
":",
"yield",
"item",
"arr",
"=",
"dic",
"[",
"next",
"(",
"iter",
"(",
"dic",
")",
")",
"]"... | :param dic: dictionary of arrays of the same shape
:param mesh: a mesh array with lon, lat fields of the same length
:param extras: optional triples (field, dtype, values)
:param kw: dictionary of parameters (like investigation_time)
:returns: a list of pairs (key, value) suitable for storage in .npz fo... | [
":",
"param",
"dic",
":",
"dictionary",
"of",
"arrays",
"of",
"the",
"same",
"shape",
":",
"param",
"mesh",
":",
"a",
"mesh",
"array",
"with",
"lon",
"lat",
"fields",
"of",
"the",
"same",
"length",
":",
"param",
"extras",
":",
"optional",
"triples",
"(... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L325-L344 |
gem/oq-engine | openquake/calculators/extract.py | extract_hcurves | def extract_hcurves(dstore, what):
"""
Extracts hazard curves. Use it as /extract/hcurves?kind=mean or
/extract/hcurves?kind=rlz-0, /extract/hcurves?kind=stats,
/extract/hcurves?kind=rlzs etc
"""
info = get_info(dstore)
if what == '': # npz exports for QGIS
sitecol = dstore['sitecol... | python | def extract_hcurves(dstore, what):
"""
Extracts hazard curves. Use it as /extract/hcurves?kind=mean or
/extract/hcurves?kind=rlz-0, /extract/hcurves?kind=stats,
/extract/hcurves?kind=rlzs etc
"""
info = get_info(dstore)
if what == '': # npz exports for QGIS
sitecol = dstore['sitecol... | [
"def",
"extract_hcurves",
"(",
"dstore",
",",
"what",
")",
":",
"info",
"=",
"get_info",
"(",
"dstore",
")",
"if",
"what",
"==",
"''",
":",
"# npz exports for QGIS",
"sitecol",
"=",
"dstore",
"[",
"'sitecol'",
"]",
"mesh",
"=",
"get_mesh",
"(",
"sitecol",
... | Extracts hazard curves. Use it as /extract/hcurves?kind=mean or
/extract/hcurves?kind=rlz-0, /extract/hcurves?kind=stats,
/extract/hcurves?kind=rlzs etc | [
"Extracts",
"hazard",
"curves",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"hcurves?kind",
"=",
"mean",
"or",
"/",
"extract",
"/",
"hcurves?kind",
"=",
"rlz",
"-",
"0",
"/",
"extract",
"/",
"hcurves?kind",
"=",
"stats",
"/",
"extract",
"/",
"hcurves?ki... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L359-L389 |
gem/oq-engine | openquake/calculators/extract.py | extract_hmaps | def extract_hmaps(dstore, what):
"""
Extracts hazard maps. Use it as /extract/hmaps?imt=PGA
"""
info = get_info(dstore)
if what == '': # npz exports for QGIS
sitecol = dstore['sitecol']
mesh = get_mesh(sitecol, complete=False)
dic = _get_dict(dstore, 'hmaps-stats',
... | python | def extract_hmaps(dstore, what):
"""
Extracts hazard maps. Use it as /extract/hmaps?imt=PGA
"""
info = get_info(dstore)
if what == '': # npz exports for QGIS
sitecol = dstore['sitecol']
mesh = get_mesh(sitecol, complete=False)
dic = _get_dict(dstore, 'hmaps-stats',
... | [
"def",
"extract_hmaps",
"(",
"dstore",
",",
"what",
")",
":",
"info",
"=",
"get_info",
"(",
"dstore",
")",
"if",
"what",
"==",
"''",
":",
"# npz exports for QGIS",
"sitecol",
"=",
"dstore",
"[",
"'sitecol'",
"]",
"mesh",
"=",
"get_mesh",
"(",
"sitecol",
... | Extracts hazard maps. Use it as /extract/hmaps?imt=PGA | [
"Extracts",
"hazard",
"maps",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"hmaps?imt",
"=",
"PGA"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L393-L423 |
gem/oq-engine | openquake/calculators/extract.py | extract_uhs | def extract_uhs(dstore, what):
"""
Extracts uniform hazard spectra. Use it as /extract/uhs?kind=mean or
/extract/uhs?kind=rlz-0, etc
"""
info = get_info(dstore)
if what == '': # npz exports for QGIS
sitecol = dstore['sitecol']
mesh = get_mesh(sitecol, complete=False)
dic... | python | def extract_uhs(dstore, what):
"""
Extracts uniform hazard spectra. Use it as /extract/uhs?kind=mean or
/extract/uhs?kind=rlz-0, etc
"""
info = get_info(dstore)
if what == '': # npz exports for QGIS
sitecol = dstore['sitecol']
mesh = get_mesh(sitecol, complete=False)
dic... | [
"def",
"extract_uhs",
"(",
"dstore",
",",
"what",
")",
":",
"info",
"=",
"get_info",
"(",
"dstore",
")",
"if",
"what",
"==",
"''",
":",
"# npz exports for QGIS",
"sitecol",
"=",
"dstore",
"[",
"'sitecol'",
"]",
"mesh",
"=",
"get_mesh",
"(",
"sitecol",
",... | Extracts uniform hazard spectra. Use it as /extract/uhs?kind=mean or
/extract/uhs?kind=rlz-0, etc | [
"Extracts",
"uniform",
"hazard",
"spectra",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"uhs?kind",
"=",
"mean",
"or",
"/",
"extract",
"/",
"uhs?kind",
"=",
"rlz",
"-",
"0",
"etc"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L427-L462 |
gem/oq-engine | openquake/calculators/extract.py | extract_agg_curves | def extract_agg_curves(dstore, what):
"""
Aggregate loss curves of the given loss type and tags for
event based risk calculations. Use it as
/extract/agg_curves/structural?taxonomy=RC&zipcode=20126
:returns:
array of shape (S, P), being P the number of return periods
and S the number... | python | def extract_agg_curves(dstore, what):
"""
Aggregate loss curves of the given loss type and tags for
event based risk calculations. Use it as
/extract/agg_curves/structural?taxonomy=RC&zipcode=20126
:returns:
array of shape (S, P), being P the number of return periods
and S the number... | [
"def",
"extract_agg_curves",
"(",
"dstore",
",",
"what",
")",
":",
"from",
"openquake",
".",
"calculators",
".",
"export",
".",
"loss_curves",
"import",
"get_loss_builder",
"oq",
"=",
"dstore",
"[",
"'oqparam'",
"]",
"loss_type",
",",
"tags",
"=",
"get_loss_ty... | Aggregate loss curves of the given loss type and tags for
event based risk calculations. Use it as
/extract/agg_curves/structural?taxonomy=RC&zipcode=20126
:returns:
array of shape (S, P), being P the number of return periods
and S the number of statistics | [
"Aggregate",
"loss",
"curves",
"of",
"the",
"given",
"loss",
"type",
"and",
"tags",
"for",
"event",
"based",
"risk",
"calculations",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"agg_curves",
"/",
"structural?taxonomy",
"=",
"RC&zipcode",
"=",
"20126",
":",
... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L522-L547 |
gem/oq-engine | openquake/calculators/extract.py | extract_agg_losses | def extract_agg_losses(dstore, what):
"""
Aggregate losses of the given loss type and tags. Use it as
/extract/agg_losses/structural?taxonomy=RC&zipcode=20126
/extract/agg_losses/structural?taxonomy=RC&zipcode=*
:returns:
an array of shape (T, R) if one of the tag names has a `*` value
... | python | def extract_agg_losses(dstore, what):
"""
Aggregate losses of the given loss type and tags. Use it as
/extract/agg_losses/structural?taxonomy=RC&zipcode=20126
/extract/agg_losses/structural?taxonomy=RC&zipcode=*
:returns:
an array of shape (T, R) if one of the tag names has a `*` value
... | [
"def",
"extract_agg_losses",
"(",
"dstore",
",",
"what",
")",
":",
"loss_type",
",",
"tags",
"=",
"get_loss_type_tags",
"(",
"what",
")",
"if",
"not",
"loss_type",
":",
"raise",
"ValueError",
"(",
"'loss_type not passed in agg_losses/<loss_type>'",
")",
"l",
"=",
... | Aggregate losses of the given loss type and tags. Use it as
/extract/agg_losses/structural?taxonomy=RC&zipcode=20126
/extract/agg_losses/structural?taxonomy=RC&zipcode=*
:returns:
an array of shape (T, R) if one of the tag names has a `*` value
an array of shape (R,), being R the number of ... | [
"Aggregate",
"losses",
"of",
"the",
"given",
"loss",
"type",
"and",
"tags",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"agg_losses",
"/",
"structural?taxonomy",
"=",
"RC&zipcode",
"=",
"20126",
"/",
"extract",
"/",
"agg_losses",
"/",
"structural?taxonomy",
... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L551-L577 |
gem/oq-engine | openquake/calculators/extract.py | extract_agg_damages | def extract_agg_damages(dstore, what):
"""
Aggregate damages of the given loss type and tags. Use it as
/extract/agg_damages/structural?taxonomy=RC&zipcode=20126
:returns:
array of shape (R, D), being R the number of realizations and D the
number of damage states, or an array of length ... | python | def extract_agg_damages(dstore, what):
"""
Aggregate damages of the given loss type and tags. Use it as
/extract/agg_damages/structural?taxonomy=RC&zipcode=20126
:returns:
array of shape (R, D), being R the number of realizations and D the
number of damage states, or an array of length ... | [
"def",
"extract_agg_damages",
"(",
"dstore",
",",
"what",
")",
":",
"loss_type",
",",
"tags",
"=",
"get_loss_type_tags",
"(",
"what",
")",
"if",
"'dmg_by_asset'",
"in",
"dstore",
":",
"# scenario_damage",
"lti",
"=",
"dstore",
"[",
"'oqparam'",
"]",
".",
"lt... | Aggregate damages of the given loss type and tags. Use it as
/extract/agg_damages/structural?taxonomy=RC&zipcode=20126
:returns:
array of shape (R, D), being R the number of realizations and D the
number of damage states, or an array of length 0 if there is no data
for the given tags | [
"Aggregate",
"damages",
"of",
"the",
"given",
"loss",
"type",
"and",
"tags",
".",
"Use",
"it",
"as",
"/",
"extract",
"/",
"agg_damages",
"/",
"structural?taxonomy",
"=",
"RC&zipcode",
"=",
"20126"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L581-L597 |
gem/oq-engine | openquake/calculators/extract.py | extract_aggregate | def extract_aggregate(dstore, what):
"""
/extract/aggregate/avg_losses?
kind=mean&loss_type=structural&tag=taxonomy&tag=occupancy
"""
name, qstring = what.split('?', 1)
info = get_info(dstore)
qdic = parse(qstring, info)
suffix = '-rlzs' if qdic['rlzs'] else '-stats'
tagnames = qdic.... | python | def extract_aggregate(dstore, what):
"""
/extract/aggregate/avg_losses?
kind=mean&loss_type=structural&tag=taxonomy&tag=occupancy
"""
name, qstring = what.split('?', 1)
info = get_info(dstore)
qdic = parse(qstring, info)
suffix = '-rlzs' if qdic['rlzs'] else '-stats'
tagnames = qdic.... | [
"def",
"extract_aggregate",
"(",
"dstore",
",",
"what",
")",
":",
"name",
",",
"qstring",
"=",
"what",
".",
"split",
"(",
"'?'",
",",
"1",
")",
"info",
"=",
"get_info",
"(",
"dstore",
")",
"qdic",
"=",
"parse",
"(",
"qstring",
",",
"info",
")",
"su... | /extract/aggregate/avg_losses?
kind=mean&loss_type=structural&tag=taxonomy&tag=occupancy | [
"/",
"extract",
"/",
"aggregate",
"/",
"avg_losses?",
"kind",
"=",
"mean&loss_type",
"=",
"structural&tag",
"=",
"taxonomy&tag",
"=",
"occupancy"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L601-L623 |
gem/oq-engine | openquake/calculators/extract.py | build_damage_dt | def build_damage_dt(dstore, mean_std=True):
"""
:param dstore: a datastore instance
:param mean_std: a flag (default True)
:returns:
a composite dtype loss_type -> (mean_ds1, stdv_ds1, ...) or
loss_type -> (ds1, ds2, ...) depending on the flag mean_std
"""
oq = dstore['oqparam']
... | python | def build_damage_dt(dstore, mean_std=True):
"""
:param dstore: a datastore instance
:param mean_std: a flag (default True)
:returns:
a composite dtype loss_type -> (mean_ds1, stdv_ds1, ...) or
loss_type -> (ds1, ds2, ...) depending on the flag mean_std
"""
oq = dstore['oqparam']
... | [
"def",
"build_damage_dt",
"(",
"dstore",
",",
"mean_std",
"=",
"True",
")",
":",
"oq",
"=",
"dstore",
"[",
"'oqparam'",
"]",
"damage_states",
"=",
"[",
"'no_damage'",
"]",
"+",
"list",
"(",
"dstore",
".",
"get_attr",
"(",
"'risk_model'",
",",
"'limit_state... | :param dstore: a datastore instance
:param mean_std: a flag (default True)
:returns:
a composite dtype loss_type -> (mean_ds1, stdv_ds1, ...) or
loss_type -> (ds1, ds2, ...) depending on the flag mean_std | [
":",
"param",
"dstore",
":",
"a",
"datastore",
"instance",
":",
"param",
"mean_std",
":",
"a",
"flag",
"(",
"default",
"True",
")",
":",
"returns",
":",
"a",
"composite",
"dtype",
"loss_type",
"-",
">",
"(",
"mean_ds1",
"stdv_ds1",
"...",
")",
"or",
"l... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L686-L707 |
gem/oq-engine | openquake/calculators/extract.py | build_damage_array | def build_damage_array(data, damage_dt):
"""
:param data: an array of shape (A, L, 1, D) or (A, L, 2, D)
:param damage_dt: a damage composite data type loss_type -> states
:returns: a composite array of length N and dtype damage_dt
"""
A, L, MS, D = data.shape
dmg = numpy.zeros(A, damage_dt)... | python | def build_damage_array(data, damage_dt):
"""
:param data: an array of shape (A, L, 1, D) or (A, L, 2, D)
:param damage_dt: a damage composite data type loss_type -> states
:returns: a composite array of length N and dtype damage_dt
"""
A, L, MS, D = data.shape
dmg = numpy.zeros(A, damage_dt)... | [
"def",
"build_damage_array",
"(",
"data",
",",
"damage_dt",
")",
":",
"A",
",",
"L",
",",
"MS",
",",
"D",
"=",
"data",
".",
"shape",
"dmg",
"=",
"numpy",
".",
"zeros",
"(",
"A",
",",
"damage_dt",
")",
"for",
"a",
"in",
"range",
"(",
"A",
")",
"... | :param data: an array of shape (A, L, 1, D) or (A, L, 2, D)
:param damage_dt: a damage composite data type loss_type -> states
:returns: a composite array of length N and dtype damage_dt | [
":",
"param",
"data",
":",
"an",
"array",
"of",
"shape",
"(",
"A",
"L",
"1",
"D",
")",
"or",
"(",
"A",
"L",
"2",
"D",
")",
":",
"param",
"damage_dt",
":",
"a",
"damage",
"composite",
"data",
"type",
"loss_type",
"-",
">",
"states",
":",
"returns"... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L710-L726 |
gem/oq-engine | openquake/calculators/extract.py | extract_mfd | def extract_mfd(dstore, what):
"""
Display num_ruptures by magnitude for event based calculations.
Example: http://127.0.0.1:8800/v1/calc/30/extract/event_based_mfd
"""
dd = collections.defaultdict(int)
for rup in dstore['ruptures'].value:
dd[rup['mag']] += 1
dt = numpy.dtype([('mag'... | python | def extract_mfd(dstore, what):
"""
Display num_ruptures by magnitude for event based calculations.
Example: http://127.0.0.1:8800/v1/calc/30/extract/event_based_mfd
"""
dd = collections.defaultdict(int)
for rup in dstore['ruptures'].value:
dd[rup['mag']] += 1
dt = numpy.dtype([('mag'... | [
"def",
"extract_mfd",
"(",
"dstore",
",",
"what",
")",
":",
"dd",
"=",
"collections",
".",
"defaultdict",
"(",
"int",
")",
"for",
"rup",
"in",
"dstore",
"[",
"'ruptures'",
"]",
".",
"value",
":",
"dd",
"[",
"rup",
"[",
"'mag'",
"]",
"]",
"+=",
"1",... | Display num_ruptures by magnitude for event based calculations.
Example: http://127.0.0.1:8800/v1/calc/30/extract/event_based_mfd | [
"Display",
"num_ruptures",
"by",
"magnitude",
"for",
"event",
"based",
"calculations",
".",
"Example",
":",
"http",
":",
"//",
"127",
".",
"0",
".",
"0",
".",
"1",
":",
"8800",
"/",
"v1",
"/",
"calc",
"/",
"30",
"/",
"extract",
"/",
"event_based_mfd"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L742-L752 |
gem/oq-engine | openquake/calculators/extract.py | extract_src_loss_table | def extract_src_loss_table(dstore, loss_type):
"""
Extract the source loss table for a give loss type, ordered in decreasing
order. Example:
http://127.0.0.1:8800/v1/calc/30/extract/src_loss_table/structural
"""
oq = dstore['oqparam']
li = oq.lti[loss_type]
source_ids = dstore['source_in... | python | def extract_src_loss_table(dstore, loss_type):
"""
Extract the source loss table for a give loss type, ordered in decreasing
order. Example:
http://127.0.0.1:8800/v1/calc/30/extract/src_loss_table/structural
"""
oq = dstore['oqparam']
li = oq.lti[loss_type]
source_ids = dstore['source_in... | [
"def",
"extract_src_loss_table",
"(",
"dstore",
",",
"loss_type",
")",
":",
"oq",
"=",
"dstore",
"[",
"'oqparam'",
"]",
"li",
"=",
"oq",
".",
"lti",
"[",
"loss_type",
"]",
"source_ids",
"=",
"dstore",
"[",
"'source_info'",
"]",
"[",
"'source_id'",
"]",
"... | Extract the source loss table for a give loss type, ordered in decreasing
order. Example:
http://127.0.0.1:8800/v1/calc/30/extract/src_loss_table/structural | [
"Extract",
"the",
"source",
"loss",
"table",
"for",
"a",
"give",
"loss",
"type",
"ordered",
"in",
"decreasing",
"order",
".",
"Example",
":",
"http",
":",
"//",
"127",
".",
"0",
".",
"0",
".",
"1",
":",
"8800",
"/",
"v1",
"/",
"calc",
"/",
"30",
... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L756-L773 |
gem/oq-engine | openquake/calculators/extract.py | extract_mean_std_curves | def extract_mean_std_curves(dstore, what):
"""
Yield imls/IMT and poes/IMT containg mean and stddev for all sites
"""
getter = getters.PmapGetter(dstore)
arr = getter.get_mean().array
for imt in getter.imtls:
yield 'imls/' + imt, getter.imtls[imt]
yield 'poes/' + imt, arr[:, gett... | python | def extract_mean_std_curves(dstore, what):
"""
Yield imls/IMT and poes/IMT containg mean and stddev for all sites
"""
getter = getters.PmapGetter(dstore)
arr = getter.get_mean().array
for imt in getter.imtls:
yield 'imls/' + imt, getter.imtls[imt]
yield 'poes/' + imt, arr[:, gett... | [
"def",
"extract_mean_std_curves",
"(",
"dstore",
",",
"what",
")",
":",
"getter",
"=",
"getters",
".",
"PmapGetter",
"(",
"dstore",
")",
"arr",
"=",
"getter",
".",
"get_mean",
"(",
")",
".",
"array",
"for",
"imt",
"in",
"getter",
".",
"imtls",
":",
"yi... | Yield imls/IMT and poes/IMT containg mean and stddev for all sites | [
"Yield",
"imls",
"/",
"IMT",
"and",
"poes",
"/",
"IMT",
"containg",
"mean",
"and",
"stddev",
"for",
"all",
"sites"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L777-L785 |
gem/oq-engine | openquake/calculators/extract.py | losses_by_tag | def losses_by_tag(dstore, tag):
"""
Statistical average losses by tag. For instance call
$ oq extract losses_by_tag/occupancy
"""
dt = [(tag, vstr)] + dstore['oqparam'].loss_dt_list()
aids = dstore['assetcol/array'][tag]
dset, stats = _get(dstore, 'avg_losses')
arr = dset.value
tagv... | python | def losses_by_tag(dstore, tag):
"""
Statistical average losses by tag. For instance call
$ oq extract losses_by_tag/occupancy
"""
dt = [(tag, vstr)] + dstore['oqparam'].loss_dt_list()
aids = dstore['assetcol/array'][tag]
dset, stats = _get(dstore, 'avg_losses')
arr = dset.value
tagv... | [
"def",
"losses_by_tag",
"(",
"dstore",
",",
"tag",
")",
":",
"dt",
"=",
"[",
"(",
"tag",
",",
"vstr",
")",
"]",
"+",
"dstore",
"[",
"'oqparam'",
"]",
".",
"loss_dt_list",
"(",
")",
"aids",
"=",
"dstore",
"[",
"'assetcol/array'",
"]",
"[",
"tag",
"]... | Statistical average losses by tag. For instance call
$ oq extract losses_by_tag/occupancy | [
"Statistical",
"average",
"losses",
"by",
"tag",
".",
"For",
"instance",
"call"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L808-L827 |
gem/oq-engine | openquake/calculators/extract.py | extract_rupture | def extract_rupture(dstore, serial):
"""
Extract information about the given event index.
Example:
http://127.0.0.1:8800/v1/calc/30/extract/rupture/1066
"""
ridx = list(dstore['ruptures']['serial']).index(int(serial))
[getter] = getters.gen_rupture_getters(dstore, slice(ridx, ridx + 1))
... | python | def extract_rupture(dstore, serial):
"""
Extract information about the given event index.
Example:
http://127.0.0.1:8800/v1/calc/30/extract/rupture/1066
"""
ridx = list(dstore['ruptures']['serial']).index(int(serial))
[getter] = getters.gen_rupture_getters(dstore, slice(ridx, ridx + 1))
... | [
"def",
"extract_rupture",
"(",
"dstore",
",",
"serial",
")",
":",
"ridx",
"=",
"list",
"(",
"dstore",
"[",
"'ruptures'",
"]",
"[",
"'serial'",
"]",
")",
".",
"index",
"(",
"int",
"(",
"serial",
")",
")",
"[",
"getter",
"]",
"=",
"getters",
".",
"ge... | Extract information about the given event index.
Example:
http://127.0.0.1:8800/v1/calc/30/extract/rupture/1066 | [
"Extract",
"information",
"about",
"the",
"given",
"event",
"index",
".",
"Example",
":",
"http",
":",
"//",
"127",
".",
"0",
".",
"0",
".",
"1",
":",
"8800",
"/",
"v1",
"/",
"calc",
"/",
"30",
"/",
"extract",
"/",
"rupture",
"/",
"1066"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L831-L839 |
gem/oq-engine | openquake/calculators/extract.py | extract_event_info | def extract_event_info(dstore, eidx):
"""
Extract information about the given event index.
Example:
http://127.0.0.1:8800/v1/calc/30/extract/event_info/0
"""
event = dstore['events'][int(eidx)]
serial = int(event['eid'] // TWO32)
ridx = list(dstore['ruptures']['serial']).index(serial)
... | python | def extract_event_info(dstore, eidx):
"""
Extract information about the given event index.
Example:
http://127.0.0.1:8800/v1/calc/30/extract/event_info/0
"""
event = dstore['events'][int(eidx)]
serial = int(event['eid'] // TWO32)
ridx = list(dstore['ruptures']['serial']).index(serial)
... | [
"def",
"extract_event_info",
"(",
"dstore",
",",
"eidx",
")",
":",
"event",
"=",
"dstore",
"[",
"'events'",
"]",
"[",
"int",
"(",
"eidx",
")",
"]",
"serial",
"=",
"int",
"(",
"event",
"[",
"'eid'",
"]",
"//",
"TWO32",
")",
"ridx",
"=",
"list",
"(",... | Extract information about the given event index.
Example:
http://127.0.0.1:8800/v1/calc/30/extract/event_info/0 | [
"Extract",
"information",
"about",
"the",
"given",
"event",
"index",
".",
"Example",
":",
"http",
":",
"//",
"127",
".",
"0",
".",
"0",
".",
"1",
":",
"8800",
"/",
"v1",
"/",
"calc",
"/",
"30",
"/",
"extract",
"/",
"event_info",
"/",
"0"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L843-L860 |
gem/oq-engine | openquake/calculators/extract.py | get_ruptures_within | def get_ruptures_within(dstore, bbox):
"""
Extract the ruptures within the given bounding box, a string
minlon,minlat,maxlon,maxlat.
Example:
http://127.0.0.1:8800/v1/calc/30/extract/ruptures_with/8,44,10,46
"""
minlon, minlat, maxlon, maxlat = map(float, bbox.split(','))
hypo = dstore['... | python | def get_ruptures_within(dstore, bbox):
"""
Extract the ruptures within the given bounding box, a string
minlon,minlat,maxlon,maxlat.
Example:
http://127.0.0.1:8800/v1/calc/30/extract/ruptures_with/8,44,10,46
"""
minlon, minlat, maxlon, maxlat = map(float, bbox.split(','))
hypo = dstore['... | [
"def",
"get_ruptures_within",
"(",
"dstore",
",",
"bbox",
")",
":",
"minlon",
",",
"minlat",
",",
"maxlon",
",",
"maxlat",
"=",
"map",
"(",
"float",
",",
"bbox",
".",
"split",
"(",
"','",
")",
")",
"hypo",
"=",
"dstore",
"[",
"'ruptures'",
"]",
"[",
... | Extract the ruptures within the given bounding box, a string
minlon,minlat,maxlon,maxlat.
Example:
http://127.0.0.1:8800/v1/calc/30/extract/ruptures_with/8,44,10,46 | [
"Extract",
"the",
"ruptures",
"within",
"the",
"given",
"bounding",
"box",
"a",
"string",
"minlon",
"minlat",
"maxlon",
"maxlat",
".",
"Example",
":",
"http",
":",
"//",
"127",
".",
"0",
".",
"0",
".",
"1",
":",
"8800",
"/",
"v1",
"/",
"calc",
"/",
... | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L864-L875 |
gem/oq-engine | openquake/calculators/extract.py | extract_source_geom | def extract_source_geom(dstore, srcidxs):
"""
Extract the geometry of a given sources
Example:
http://127.0.0.1:8800/v1/calc/30/extract/source_geom/1,2,3
"""
for i in srcidxs.split(','):
rec = dstore['source_info'][int(i)]
geom = dstore['source_geom'][rec['gidx1']:rec['gidx2']]
... | python | def extract_source_geom(dstore, srcidxs):
"""
Extract the geometry of a given sources
Example:
http://127.0.0.1:8800/v1/calc/30/extract/source_geom/1,2,3
"""
for i in srcidxs.split(','):
rec = dstore['source_info'][int(i)]
geom = dstore['source_geom'][rec['gidx1']:rec['gidx2']]
... | [
"def",
"extract_source_geom",
"(",
"dstore",
",",
"srcidxs",
")",
":",
"for",
"i",
"in",
"srcidxs",
".",
"split",
"(",
"','",
")",
":",
"rec",
"=",
"dstore",
"[",
"'source_info'",
"]",
"[",
"int",
"(",
"i",
")",
"]",
"geom",
"=",
"dstore",
"[",
"'s... | Extract the geometry of a given sources
Example:
http://127.0.0.1:8800/v1/calc/30/extract/source_geom/1,2,3 | [
"Extract",
"the",
"geometry",
"of",
"a",
"given",
"sources",
"Example",
":",
"http",
":",
"//",
"127",
".",
"0",
".",
"0",
".",
"1",
":",
"8800",
"/",
"v1",
"/",
"calc",
"/",
"30",
"/",
"extract",
"/",
"source_geom",
"/",
"1",
"2",
"3"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L879-L888 |
gem/oq-engine | openquake/calculators/extract.py | WebExtractor.get | def get(self, what):
"""
:param what: what to extract
:returns: an ArrayWrapper instance
"""
url = '%s/v1/calc/%d/extract/%s' % (self.server, self.calc_id, what)
logging.info('GET %s', url)
resp = self.sess.get(url)
if resp.status_code != 200:
... | python | def get(self, what):
"""
:param what: what to extract
:returns: an ArrayWrapper instance
"""
url = '%s/v1/calc/%d/extract/%s' % (self.server, self.calc_id, what)
logging.info('GET %s', url)
resp = self.sess.get(url)
if resp.status_code != 200:
... | [
"def",
"get",
"(",
"self",
",",
"what",
")",
":",
"url",
"=",
"'%s/v1/calc/%d/extract/%s'",
"%",
"(",
"self",
".",
"server",
",",
"self",
".",
"calc_id",
",",
"what",
")",
"logging",
".",
"info",
"(",
"'GET %s'",
",",
"url",
")",
"resp",
"=",
"self",... | :param what: what to extract
:returns: an ArrayWrapper instance | [
":",
"param",
"what",
":",
"what",
"to",
"extract",
":",
"returns",
":",
"an",
"ArrayWrapper",
"instance"
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L970-L986 |
gem/oq-engine | openquake/calculators/extract.py | WebExtractor.dump | def dump(self, fname):
"""
Dump the remote datastore on a local path.
"""
url = '%s/v1/calc/%d/datastore' % (self.server, self.calc_id)
resp = self.sess.get(url, stream=True)
down = 0
with open(fname, 'wb') as f:
logging.info('Saving %s', fname)
... | python | def dump(self, fname):
"""
Dump the remote datastore on a local path.
"""
url = '%s/v1/calc/%d/datastore' % (self.server, self.calc_id)
resp = self.sess.get(url, stream=True)
down = 0
with open(fname, 'wb') as f:
logging.info('Saving %s', fname)
... | [
"def",
"dump",
"(",
"self",
",",
"fname",
")",
":",
"url",
"=",
"'%s/v1/calc/%d/datastore'",
"%",
"(",
"self",
".",
"server",
",",
"self",
".",
"calc_id",
")",
"resp",
"=",
"self",
".",
"sess",
".",
"get",
"(",
"url",
",",
"stream",
"=",
"True",
")... | Dump the remote datastore on a local path. | [
"Dump",
"the",
"remote",
"datastore",
"on",
"a",
"local",
"path",
"."
] | train | https://github.com/gem/oq-engine/blob/8294553a0b8aba33fd96437a35065d03547d0040/openquake/calculators/extract.py#L988-L1001 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.