Source code for siria.dataset.faults
# GPLv3
#
# The Developers, 21st Century
import logging
import numpy as num
from pyrocko import orthodrome as pod
logger = logging.getLogger('siria.dataset.faults')
[docs]def load_diss(*args, **kwargs):
'''
Wrapper for DISS database loading.
'''
from .fault_loader import diss
logger.info('Load faults from DISS ...')
return diss.load_faults_from_shp(*args, **kwargs)
[docs]def load_edsf(*args, **kwargs):
'''
Wrapper for EDSF13 database loading.
'''
from .fault_loader import edsf
logger.info('Load faults from EDSF13 ...')
return edsf.load_faults_from_shp(*args, **kwargs)
[docs]def load_gem(*args, **kwargs):
'''
Wrapper for OpenGEM database loading.
'''
from .fault_loader import active_faults
logger.info('Load faults from GEM ...')
return active_faults.ActiveFaults().active_faults
[docs]def load_noafaults(*args, **kwargs):
'''
Wrapper for NOAFault database loading.
'''
from .fault_loader import noafaults
logger.info('Load faults from NOAfaults ...')
return noafaults.load_faults_from_json(*args, **kwargs)
def load_efsm(*args, **kwargs):
from .fault_loader import efsm
logger.info('Load faults from EFSM20 ...')
return efsm.load_faults_from_shp(*args, **kwargs)
[docs]def extract_faults(
faults,
wesn=(),
lat=None,
lon=None,
radius=None,
strike=None,
dip=None,
rake=None,
restrict_to_radius=False):
'''
Select faults matching given geographical or geometric criteria.
Criteria might be combined.
:param faults:
Faults to be scanned.
:type faults:
list of
:py:class:`siria.dataset.faults.fault_loader.active_faults.ActiveFault`
:param wesn:
Bounding box in geographical coordinates. Faults (partially) within the
box are returned. Give it as ``(West, East, South, North)``.
:type wesn:
(float, float, float, float)
:param lat:
Latitude in [deg] of the center point of the search area. ``lon`` and
``radius`` need to be given as well.
:type lat:
optional, float
:param lon:
Longitude in [deg] of the center point of the search area. ``lat`` and
``radius`` need to be given as well.
:type lon:
optional, float
:param radius:
Search radius in [m] around ``lat, lon``.
:type radius:
optional, float
:param strike:
Faults with a :math:`strike_{min} < strike`` and
:math:`strike_{max} > strike`` are selected.
:type strike:
optional, float
:param dip:
Faults with a :math:`dip_{min} < dip`` and
:math:`dip_{max} > dip`` are selected.
:type dip:
optional, float
:param rake:
Faults with a :math:`rake_{min} < rake`` and
:math:`rake_{max} > rake`` are selected.
:type rake:
optional, float
:returns:
Selected faults.
:rtype:
list of
:py:class:`siria.dataset.faults.fault_loader.active_faults.ActiveFault`
'''
if not wesn:
if lat is not None and lon is not None and radius is not None:
wesn = pod.radius_to_region(lat, lon, radius)
if wesn:
faults_old = [f for f in faults]
faults = []
for i, f in enumerate(faults_old):
mask = pod.points_in_region(num.vstack((f.lat, f.lon)).T, wesn)
if not mask.any():
continue
if restrict_to_radius:
idx = num.arange(mask.shape[0])[mask]
f.lat = [f.lat[i] for i in idx]
f.lon = [f.lon[i] for i in idx]
faults.append(f)
if strike:
faults = [
f for f in faults
if hasattr(f, 'strike_min') and hasattr(f, 'strike_max')
if f.strike_min % 360. <= strike and f.strike_max % 360. >= strike]
if dip:
faults = [
f for f in faults
if hasattr(f, 'dip_min') and hasattr(f, 'dip_max')
if f.dip_min % 90. <= dip and f.dip_max % 90. >= dip]
if rake:
faults = [
f for f in faults
if hasattr(f, 'rake_min') and hasattr(f, 'rake_max')
if f.rake_min % 360. <= rake and f.rake_max % 360. >= rake]
return faults
[docs]def load_faults_from_database(
database='GEM',
exclude_depthcontours=True,
wesn=(),
lat=None,
lon=None,
radius=None,
strike=None,
dip=None,
rake=None,
restrict_to_radius=False,
**kwargs):
'''
Retrieve fault data in unique format from given database.
Arguments and keyword arguments for the specific database reader might
be necessary. Faults can also be preselected when giving arguments for
:py:meth:`~siria.dataset.faults.extract_faults`.
:param database:
Fault database if choice. Choose between ``DISS``, ``EDSF`` (EDSF13),
``GEM`` (OpenGEM) or ``NOA`` (NOAFaults).
:type database:
string
:param exclude_depthcontours:
``EDSF`` database ships also depth contours of the subduction zone. Set
``True`` to exclude them.
:type exclude_depthcontours:
optional, bool
:returns:
Faults to be considered.
:rtype:
list of
:py:class:`siria.dataset.faults.fault_loader.active_faults.ActiveFault`
'''
kwargs_extract = {
k: v for k, v in kwargs.items()
if k in extract_faults.__code__.co_varnames}
kwargs = {k: v for k, v in kwargs.items() if k not in kwargs_extract}
database = database.upper()
if database == 'DISS':
faults = load_diss(**kwargs)
elif database == 'EDSF':
faults = load_edsf(**kwargs)
if exclude_depthcontours:
faults = [f for f in faults if f.IDSOURCE not in [
'ITSD001', 'GRSD001', 'CYSD001']]
elif database == 'GEM':
faults = load_gem(**kwargs)
elif database == 'NOA':
faults = load_noafaults(**kwargs)
elif database == 'EFSM':
faults = load_efsm(**kwargs)
else:
raise ValueError(
'No fault database {} found. Feel free to implement it'.format(
database))
faults = extract_faults(
faults,
wesn=wesn,
lat=lat,
lon=lon,
radius=radius,
strike=strike,
dip=dip,
rake=rake,
restrict_to_radius=restrict_to_radius)
return faults
__all__ = [
'load_diss',
'load_edsf',
'load_gem',
'load_noafaults',
'load_efsm',
'extract_faults',
'load_faults_from_database']