code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
'''
Select events within a Joyner-Boore distance of a fault
:param surface:
Fault surface as instance of
nhlib.geo.surface.base.SimpleFaultSurface or as instance of
nhlib.geo.surface.ComplexFaultSurface
:param float distance:
Rupture dis... | def within_joyner_boore_distance(self, surface, distance, **kwargs) | Select events within a Joyner-Boore distance of a fault
:param surface:
Fault surface as instance of
nhlib.geo.surface.base.SimpleFaultSurface or as instance of
nhlib.geo.surface.ComplexFaultSurface
:param float distance:
Rupture distance (km)
... | 4.965473 | 2.377896 | 2.088179 |
'''
Select events within a rupture distance from a fault surface
:param surface:
Fault surface as instance of nhlib.geo.surface.base.BaseSurface
:param float distance:
Rupture distance (km)
:returns:
Instance of :class:`openquake.hmtk.seismi... | def within_rupture_distance(self, surface, distance, **kwargs) | Select events within a rupture distance from a fault surface
:param surface:
Fault surface as instance of nhlib.geo.surface.base.BaseSurface
:param float distance:
Rupture distance (km)
:returns:
Instance of :class:`openquake.hmtk.seismicity.catalogue.Catal... | 4.708744 | 2.81672 | 1.671711 |
'''
Select earthquakes occurring within a given time period
:param start_time:
Earliest time (as datetime.datetime object)
:param end_time:
Latest time (as datetime.datetime object)
:returns:
Instance of :class:`openquake.hmtk.seismicity.cat... | def within_time_period(self, start_time=None, end_time=None) | Select earthquakes occurring within a given time period
:param start_time:
Earliest time (as datetime.datetime object)
:param end_time:
Latest time (as datetime.datetime object)
:returns:
Instance of :class:`openquake.hmtk.seismicity.catalogue.Catalogue`
... | 2.93198 | 2.222681 | 1.319119 |
'''
Selects events within a specified depth range
:param float lower_depth:
Lower depth for consideration
:param float upper_depth:
Upper depth for consideration
:returns:
Instance of :class:`openquake.hmtk.seismicity.catalogue.Catalogue`
... | def within_depth_range(self, lower_depth=None, upper_depth=None) | Selects events within a specified depth range
:param float lower_depth:
Lower depth for consideration
:param float upper_depth:
Upper depth for consideration
:returns:
Instance of :class:`openquake.hmtk.seismicity.catalogue.Catalogue`
containing... | 3.272588 | 2.316366 | 1.412811 |
'''
:param float lower_mag:
Lower magnitude for consideration
:param float upper_mag:
Upper magnitude for consideration
:returns:
Instance of openquake.hmtk.seismicity.catalogue.Catalogue class containing
only selected events
'''
... | def within_magnitude_range(self, lower_mag=None, upper_mag=None) | :param float lower_mag:
Lower magnitude for consideration
:param float upper_mag:
Upper magnitude for consideration
:returns:
Instance of openquake.hmtk.seismicity.catalogue.Catalogue class containing
only selected events | 3.196357 | 2.201318 | 1.452019 |
num_clust = np.max(vcl)
cluster_set = []
for clid in range(0, num_clust + 1):
idx = np.where(vcl == clid)[0]
cluster_cat = deepcopy(self.catalogue)
cluster_cat.select_catalogue_events(idx)
cluster_set.append((clid, cluster_cat))
re... | def create_cluster_set(self, vcl) | For a given catalogue and list of cluster IDs this function splits
the catalogue into a dictionary containing an individual catalogue
of events within each cluster
:param numpy.ndarray vcl:
Cluster ID list
:returns:
Dictionary of instances of the :class:
... | 3.304651 | 3.114629 | 1.06101 |
is_valid = np.logical_and(
self.catalogue.data['longitude'] >= limits[0],
np.logical_and(self.catalogue.data['longitude'] <= limits[2],
np.logical_and(
self.catalogue.data['latitude'] >= limits[1],
... | def within_bounding_box(self, limits) | Selects the earthquakes within a bounding box.
:parameter limits:
A list or a numpy array with four elements in the following order:
- min x (longitude)
- min y (latitude)
- max x (longitude)
- max y (latitude)
:returns:
... | 2.53593 | 2.302256 | 1.101498 |
datadir = os.environ.get('OQ_DATADIR')
if not datadir:
shared_dir = config.directory.shared_dir
if shared_dir:
datadir = os.path.join(shared_dir, getpass.getuser(), 'oqdata')
else: # use the home of the user
datadir = os.path.join(os.path.expanduser('~'), 'o... | def get_datadir() | Extracts the path of the directory where the openquake data are stored
from the environment ($OQ_DATADIR) or from the shared_dir in the
configuration file. | 3.116903 | 2.418192 | 1.288939 |
datadir = datadir or get_datadir()
if not os.path.exists(datadir):
return []
calc_ids = set()
for f in os.listdir(datadir):
mo = re.match(CALC_REGEX, f)
if mo:
calc_ids.add(int(mo.group(2)))
return sorted(calc_ids) | def get_calc_ids(datadir=None) | Extract the available calculation IDs from the datadir, in order. | 2.152604 | 1.982213 | 1.08596 |
datadir = datadir or get_datadir()
calcs = get_calc_ids(datadir)
if not calcs:
return 0
return calcs[-1] | def get_last_calc_id(datadir=None) | Extract the latest calculation ID from the given directory.
If none is found, return 0. | 2.949256 | 2.708882 | 1.088735 |
datadir = datadir or get_datadir()
calc_id = get_last_calc_id(datadir) + 1
fname = os.path.join(datadir, 'calc_%d.hdf5' % calc_id)
new = hdf5.File(fname, 'w')
new.path = fname
return new | def hdf5new(datadir=None) | Return a new `hdf5.File by` instance with name determined by the last
calculation in the datadir (plus one). Set the .path attribute to the
generated filename. | 3.084782 | 2.552432 | 1.208566 |
datadir = datadir or get_datadir()
try:
calc_id = int(filename)
except ValueError:
filename = os.path.abspath(filename)
datadir = os.path.dirname(filename)
mo = re.match(CALC_REGEX, os.path.basename(filename))
if mo is None:
raise ValueError('Cannot e... | def extract_calc_id_datadir(filename, datadir=None) | Extract the calculation ID from the given filename or integer:
>>> extract_calc_id_datadir('/mnt/ssd/oqdata/calc_25.hdf5')
(25, '/mnt/ssd/oqdata')
>>> extract_calc_id_datadir('/mnt/ssd/oqdata/wrong_name.hdf5')
Traceback (most recent call last):
...
ValueError: Cannot extract calc_id from /mn... | 2.209175 | 2.469721 | 0.894504 |
datadir = datadir or get_datadir()
dstore = DataStore(calc_id, datadir, mode=mode)
try:
hc_id = dstore['oqparam'].hazard_calculation_id
except KeyError: # no oqparam
hc_id = None
if hc_id:
dstore.parent = read(hc_id, datadir=os.path.dirname(dstore.filename))
return ... | def read(calc_id, mode='r', datadir=None) | :param calc_id: calculation ID or filename
:param mode: 'r' or 'w'
:param datadir: the directory where to look
:returns: the corresponding DataStore instance
Read the datastore, if it exists and it is accessible. | 4.606495 | 4.504827 | 1.022569 |
if self.hdf5 == (): # not already open
kw = dict(mode=mode, libver='latest')
if mode == 'r':
kw['swmr'] = True
try:
self.hdf5 = hdf5.File(self.filename, **kw)
except OSError as exc:
raise OSError('%s in %s'... | def open(self, mode) | Open the underlying .hdf5 file and the parent, if any | 3.674115 | 3.342254 | 1.099293 |
try:
obj = h5py.File.__getitem__(self.hdf5, key)
except KeyError:
if self.parent != ():
return self.parent.get_attr(key, name, default)
else:
raise
try:
return obj.attrs[name]
except KeyError:
... | def get_attr(self, key, name, default=None) | :param key: dataset path
:param name: name of the attribute
:param default: value to return if the attribute is missing | 3.284578 | 3.21676 | 1.021083 |
try:
dset = h5py.File.__getitem__(self.hdf5, key)
except KeyError:
if self.parent != ():
dset = h5py.File.__getitem__(self.parent.hdf5, key)
else:
raise
return dict(dset.attrs) | def get_attrs(self, key) | :param key: dataset path
:returns: dictionary of attributes for that path | 3.850148 | 3.535444 | 1.089014 |
return hdf5.create(
self.hdf5, key, dtype, shape, compression, fillvalue, attrs) | def create_dset(self, key, dtype, shape=(None,), compression=None,
fillvalue=0, attrs=None) | Create a one-dimensional HDF5 dataset.
:param key: name of the dataset
:param dtype: dtype of the dataset (usually composite)
:param shape: shape of the dataset, possibly extendable
:param compression: the kind of HDF5 compression to use
:param attrs: dictionary of attributes of... | 4.431398 | 6.953101 | 0.637327 |
try:
dset = self.hdf5[key]
except KeyError:
dset = hdf5.create(self.hdf5, key, array.dtype,
shape=(None,) + array.shape[1:])
hdf5.extend(dset, array)
for k, v in attrs.items():
dset.attrs[k] = v
return ds... | def extend(self, key, array, **attrs) | Extend the dataset associated to the given key; create it if needed
:param key: name of the dataset
:param array: array to store
:param attrs: a dictionary of attributes | 2.628594 | 2.99429 | 0.877869 |
if key not in self:
obj = hdf5.LiteralAttrs()
else:
obj = self[key]
vars(obj).update(kw)
self[key] = obj
self.flush() | def save(self, key, kw) | Update the object associated to `key` with the `kw` dictionary;
works for LiteralAttrs objects and automatically flushes. | 5.745552 | 3.495337 | 1.643776 |
# removing inner slashed to avoid creating intermediate directories
name, ext = relname.replace('/', '-').rsplit('.', 1)
newname = '%s_%s.%s' % (name, self.calc_id, ext)
if export_dir is None:
export_dir = self.export_dir
return os.path.join(export_dir, newna... | def export_path(self, relname, export_dir=None) | Return the path of the exported file by adding the export_dir in
front, the calculation ID at the end.
:param relname: relative file name
:param export_dir: export directory (if None use .export_dir) | 4.189471 | 4.043695 | 1.03605 |
if hasattr(postfix, 'sm_lt_path'): # is a realization
fname = '%s-rlz-%03d.%s' % (prefix, postfix.ordinal, fmt)
else:
fname = prefix + ('-%s' % postfix if postfix else '') + '.' + fmt
return self.export_path(fname, export_dir) | def build_fname(self, prefix, postfix, fmt, export_dir=None) | Build a file name from a realization, by using prefix and extension.
:param prefix: the prefix to use
:param postfix: the postfix to use (can be a realization object)
:param fmt: the extension ('csv', 'xml', etc)
:param export_dir: export directory (if None use .export_dir)
:ret... | 7.166985 | 5.939987 | 1.206566 |
if self.parent != ():
self.parent.flush()
if self.hdf5: # is open
self.hdf5.flush() | def flush(self) | Flush the underlying hdf5 file | 10.432878 | 7.916738 | 1.317825 |
if self.parent != ():
self.parent.flush()
self.parent.close()
if self.hdf5: # is open
self.hdf5.flush()
self.hdf5.close()
self.hdf5 = () | def close(self) | Close the underlying hdf5 file | 5.442894 | 4.5593 | 1.1938 |
if key is None:
return os.path.getsize(self.filename)
return hdf5.ByteCounter.get_nbytes(
h5py.File.__getitem__(self.hdf5, key)) | def getsize(self, key=None) | Return the size in byte of the output associated to the given key.
If no key is given, returns the total size of all files. | 6.509826 | 6.258111 | 1.040222 |
if isinstance(value, (list, tuple)) and isinstance(value[0], str):
return encode(value)
return value | def maybe_encode(value) | If value is a sequence of strings, encode it | 3.715611 | 3.071349 | 1.209765 |
if shape[0] is None: # extendable dataset
dset = hdf5.create_dataset(
name, (0,) + shape[1:], dtype, chunks=True, maxshape=shape,
compression=compression)
else: # fixed-shape dataset
dset = hdf5.create_dataset(name, shape, dtype, fillvalue=fillvalue,
... | def create(hdf5, name, dtype, shape=(None,), compression=None,
fillvalue=0, attrs=None) | :param hdf5: a h5py.File object
:param name: an hdf5 key string
:param dtype: dtype of the dataset (usually composite)
:param shape: shape of the dataset (can be extendable)
:param compression: None or 'gzip' are recommended
:param attrs: dictionary of attributes of the dataset
:returns: a HDF5 ... | 2.360765 | 2.4301 | 0.971468 |
length = len(dset)
if len(array) == 0:
return length
newlength = length + len(array)
if array.dtype.name == 'object': # vlen array
shape = (newlength,) + preshape(array[0])
else:
shape = (newlength,) + array.shape[1:]
dset.resize(shape)
dset[length:newlength] = ... | def extend(dset, array, **attrs) | Extend an extensible dataset with an array of a compatible dtype.
:param dset: an h5py dataset
:param array: an array of length L
:returns: the total length of the dataset (i.e. initial length + L) | 3.025543 | 3.139657 | 0.963654 |
with h5py.File(filename) as h5:
try:
dset = h5[key]
except KeyError:
if array.dtype.name == 'object': # vlen array
shape = (None,) + preshape(array[0])
else:
shape = (None,) + array.shape[1:]
dset = create(h5, key,... | def extend3(filename, key, array, **attrs) | Extend an HDF5 file dataset with the given array | 3.122638 | 3.164783 | 0.986683 |
modname, clsname = dotname.rsplit('.', 1)
return getattr(importlib.import_module(modname), clsname) | def dotname2cls(dotname) | The class associated to the given dotname (i.e. `pkg.subpkg.mod.cls`) | 2.29221 | 2.597623 | 0.882426 |
if 'nbytes' in dset.attrs:
# look if the dataset has an attribute nbytes
return dset.attrs['nbytes']
elif hasattr(dset, 'dtype'):
# else extract nbytes from the underlying array
return dset.size * numpy.zeros(1, dset.dtype).nbytes | def get_nbytes(dset) | If the dataset has an attribute 'nbytes', return it. Otherwise get the size
of the underlying array. Returns None if the dataset is actually a group. | 4.564229 | 3.868791 | 1.179756 |
ls = []
for el in lst:
try:
ls.append(el.encode('utf-8'))
except AttributeError:
ls.append(el)
return numpy.array(ls, vstr) | def array_of_vstr(lst) | :param lst: a list of strings or bytes
:returns: an array of variable length ASCII strings | 3.12429 | 3.443279 | 0.907359 |
out = []
for val in values:
try:
out.append(val.decode('utf8'))
except AttributeError:
out.append(val)
return out | def decode_array(values) | Decode the values which are bytestrings. | 2.48258 | 2.258223 | 1.099351 |
shp = list(dset.shape)
if len(shp) != len(d_slices):
raise ValueError('Array with %d dimensions but %d slices' %
(len(shp), len(d_slices)))
sizes = []
slices = []
for i, slc in enumerate(d_slices):
if slc == slice(None):
size = shp[i]
... | def extract(dset, *d_slices) | :param dset: a D-dimensional dataset or array
:param d_slices: D slice objects (or similar)
:returns: a reduced D-dimensional array
>>> a = numpy.array([[1, 2, 3], [4, 5, 6]]) # shape (2, 3)
>>> extract(a, slice(None), 1)
array([[2],
[5]])
>>> extract(a, [0, 1], slice(1, 3))
arr... | 2.133955 | 2.219102 | 0.96163 |
fh, path = tempfile.mkstemp(suffix='.hdf5')
os.close(fh)
self = cls(path, 'w')
self.path = path
return self | def temporary(cls) | Returns a temporary hdf5 file, open for writing.
The temporary name is stored in the .path attribute.
It is the user responsability to remove the file when closed. | 4.040938 | 2.973662 | 1.35891 |
shape = (None,) + data[0].shape[:-1]
try:
dset = self[key]
except KeyError:
vdt = h5py.special_dtype(vlen=data[0].dtype)
dset = create(self, key, vdt, shape, fillvalue=None)
nbytes = dset.attrs.get('nbytes', 0)
totlen = dset.attrs.get(... | def save_vlen(self, key, data) | Save a sequence of variable-length arrays
:param key: name of the dataset
:param data: data to store as a list of arrays | 2.467288 | 2.645107 | 0.932775 |
obj = super().__getitem__(key)
if nbytes is not None: # size set from outside
obj.attrs['nbytes'] = nbytes
else: # recursively determine the size of the datagroup
obj.attrs['nbytes'] = nbytes = ByteCounter.get_nbytes(obj)
return nbytes | def set_nbytes(self, key, nbytes=None) | Set the `nbytes` attribute on the HDF5 object identified by `key`. | 6.245479 | 5.526163 | 1.130165 |
setitem = super().__setitem__
getitem = super().__getitem__
tag = nodedict['tag']
text = nodedict.get('text', None)
if hasattr(text, 'strip'):
text = text.strip()
attrib = nodedict.get('attrib', {})
path = '/'.join([root, tag])
nodes =... | def save(self, nodedict, root='') | Save a node dictionary in the .hdf5 file, starting from the root
dataset. A common application is to convert XML files into .hdf5
files, see the usage in :mod:`openquake.commands.to_hdf5`.
:param nodedict:
a dictionary with keys 'tag', 'attrib', 'text', 'nodes' | 3.69443 | 3.534039 | 1.045384 |
with File(path, 'w') as f:
for key, val in vars(self).items():
assert val is not None, key # sanity check
try:
f[key] = maybe_encode(val)
except ValueError as err:
if 'Object header message is too large... | def save(self, path, **extra) | :param path: an .hdf5 pathname
:param extra: extra attributes to be saved in the file | 4.254668 | 3.874105 | 1.098232 |
shape = self.shape
# the tagnames are bytestrings so they must be decoded
tagnames = decode_array(self.tagnames)
if len(shape) == len(tagnames):
return [tagnames + ['value']] + self._to_table()
elif len(shape) == len(tagnames) + 1: # there is an extra field
... | def to_table(self) | Convert an ArrayWrapper with shape (D1, ..., DN) and attributes
T1, ..., TN which are list of tags of lenghts D1, ... DN into
a table with rows (tag1, ... tagN, value) of maximum length
D1 * ... * DN. Zero values are discarded.
>>> from pprint import pprint
>>> dic = dict(tagnam... | 4.447888 | 4.515378 | 0.985053 |
mean, stds = self._get_mean_and_stddevs(sites, rup, dists, imt,
stddev_types)
stddevs = [np.ones(len(dists.repi))*get_sigma(imt)]
return mean, stddevs | def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types) | See documentation for method `GroundShakingIntensityModel` in
:class:~`openquake.hazardlib.gsim.base.GSIM` | 3.979118 | 3.851596 | 1.033109 |
delta = np.maximum((0.1-0.001*dists.repi), np.zeros_like(dists.repi))
return delta | def _get_delta(self, stds, dists) | Computes the additional delta to be used for the computation of the
upp and low models | 10.067355 | 8.98277 | 1.120741 |
# distances
distsl = copy.copy(dists)
distsl.rjb, distsl.rrup = \
utils.get_equivalent_distances_east(rup.mag, dists.repi)
#
# Pezeshk et al. 2011 - Rrup
mean1, stds1 = super().get_mean_and_stddevs(sites, rup, distsl, imt,
... | def _get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types) | Returns only the mean values.
See documentation for method `GroundShakingIntensityModel` in
:class:~`openquake.hazardlib.gsim.base.GSIM` | 2.643734 | 2.648829 | 0.998077 |
# This is just used for testing purposes
if len(stddev_types) == 0:
stddev_types = [StdDev.TOTAL]
mean, stds = self._get_mean_and_stddevs(sites, rup, dists, imt,
stddev_types)
stddevs = [np.ones(len(dists.repi))*get_sig... | def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types) | See documentation for method `GroundShakingIntensityModel` in
:class:~`openquake.hazardlib.gsim.base.GSIM` | 4.185468 | 4.152385 | 1.007967 |
fmt = ekey[-1]
oq = dstore['oqparam']
num_ses = oq.ses_per_logic_tree_path
mesh = get_mesh(dstore['sitecol'])
ruptures_by_grp = {}
for rgetter in gen_rupture_getters(dstore):
ebrs = [ebr.export(mesh, rgetter.rlzs_by_gsim, num_ses)
for ebr in rgetter.get_ruptures()]
... | def export_ruptures_xml(ekey, dstore) | :param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object | 7.417582 | 7.761577 | 0.95568 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.