def smooth_data(self, data, config, is_3d=False):
'''
Applies the smoothing kernel to the data
:param np.ndarray data:
Raw earthquake count in the form [Longitude, Latitude, Depth,
Count]
:param dict config:
Configuration parameters must contain:
* BandWidth: The bandwidth of the kernel (in km) (float)
* Length_Limit: Maximum number of standard deviations
:returns:
* smoothed_value: np.ndarray vector of smoothed values
* Total (summed) rate of the original values
* Total (summed) rate of the smoothed values
'''
max_dist = config['Length_Limit'] * config['BandWidth']
smoothed_value = np.zeros(len(data), dtype=float)
for iloc in range(0, len(data)):
dist_val = haversine(data[:, 0], data[:, 1],
data[iloc, 0], data[iloc, 1])
if is_3d:
dist_val = np.sqrt(dist_val.flatten() ** 2.0 +
(data[:, 2] - data[iloc, 2]) ** 2.0)
id0 = np.where(dist_val <= max_dist)[0]
w_val = (np.exp(-(dist_val[id0] ** 2.0) /
(config['BandWidth'] ** 2.))).flatten()
smoothed_value[iloc] = np.sum(w_val * data[id0, 3]) / np.sum(w_val)
return smoothed_value, np.sum(data[:, -1]), np.sum(smoothed_value)
def smooth_data(self, data, config, is_3d=False):
'''
Applies the smoothing kernel to the data
:param np.ndarray data:
Raw earthquake count in the form [Longitude, Latitude, Depth,
Count]
:param dict config:
Configuration parameters must contain:
* BandWidth: The bandwidth of the kernel (in km) (float)
* Length_Limit: Maximum number of standard deviations
:returns:
* smoothed_value: np.ndarray vector of smoothed values
* Total (summed) rate of the original values
* Total (summed) rate of the smoothed values
'''
max_dist = config['Length_Limit'] * config['BandWidth']
smoothed_value = np.zeros(len(data), dtype=float)
for iloc in range(0, len(data)):
dist_val = haversine(data[:, 0], data[:, 1],
data[iloc, 0], data[iloc, 1])
if is_3d:
dist_val = np.sqrt(dist_val.flatten() ** 2.0 +
(data[:, 2] - data[iloc, 2]) ** 2.0)
id0 = np.where(dist_val <= max_dist)[0]
w_val = (np.exp(-(dist_val[id0] ** 2.0) /
(config['BandWidth'] ** 2.))).flatten()
smoothed_value[iloc] = np.sum(w_val * data[id0, 3]) / np.sum(w_val)
return smoothed_value, np.sum(data[:, -1]), np.sum(smoothed_value)
def test_haversine(self):
'''Tests the function utils.haversine
Distances tested against i) Matlab implementation of the haversine
formula
ii) Matlab "distance" function (also based on
the haversine formula (assumes
Earth Radius = 6371.0 not 6371.227 as
assumed here!)
'''
# Simple test
self.longitude = np.arange(30., 40., 1.)
self.latitude = np.arange(30., 40., 1.)
distance = utils.haversine(self.longitude, self.latitude, 35.0, 35.0)
expected_distance = np.array([[727.09474718],
[580.39194024],
[434.3102452],
[288.87035021],
[144.09319874],
[0.],
[143.38776088],
[286.04831311],
[427.95959077],
[569.09922383]])
np.testing.assert_allclose(distance, expected_distance)
# 2-D test
self.longitude = np.array([30., 35., 40.])
self.latitude = np.array([30., 35., 40.])
distance = utils.haversine(self.longitude, self.latitude,
self.longitude, self.latitude)
expected_distance = np.array([[0., 727.09474718, 1435.38402047],
[727.09474718, 0., 709.44452948],
[1435.38402047, 709.44452948, 0.]])
self.assertTrue(np.allclose(distance, expected_distance))
# Crossing International Dateline
self.longitude = np.array([179.5, 180.0, -179.5])
self.latitude = np.array([45., 45., 45.])
distance = utils.haversine(self.longitude, self.latitude, 179.9, 45.)
expected_distance = np.array([[31.45176332],
[7.86294832],
[47.1775851]])
np.testing.assert_allclose(distance, expected_distance)
def decluster(self, catalogue, config):
"""
The configuration of this declustering algorithm requires two
objects:
- A time-distance window object (key is 'time_distance_window')
- A value in the interval [0,1] expressing the fraction of the
time window used for aftershocks (key is 'fs_time_prop')
:param catalogue:
Catalogue of earthquakes
:type catalogue: Dictionary
:param config:
Configuration parameters
:type config: Dictionary
:returns:
**vcl vector** indicating cluster number,
**flagvector** indicating which eq events belong to a cluster
:rtype: numpy.ndarray
"""
# Get relevant parameters
neq = len(catalogue.data['magnitude']) # Number of earthquakes
# Get decimal year (needed for time windows)
year_dec = decimal_year(catalogue.data['year'],
catalogue.data['month'], catalogue.data['day'])
# Get space and time windows corresponding to each event
# Initial Position Identifier
sw_space, sw_time = (config['time_distance_window'].calc(
catalogue.data['magnitude'], config.get('time_cutoff')))
eqid = np.arange(0, neq, 1)
# Pre-allocate cluster index vectors
vcl = np.zeros(neq, dtype=int)
# Sort magnitudes into descending order
id0 = np.flipud(
np.argsort(catalogue.data['magnitude'], kind='heapsort'))
longitude = catalogue.data['longitude'][id0]
latitude = catalogue.data['latitude'][id0]
sw_space = sw_space[id0]
sw_time = sw_time[id0]
year_dec = year_dec[id0]
eqid = eqid[id0]
flagvector = np.zeros(neq, dtype=int)
# Begin cluster identification
clust_index = 0
for i in range(0, neq - 1):
if vcl[i] == 0:
# Find Events inside both fore- and aftershock time windows
dt = year_dec - year_dec[i]
vsel = np.logical_and(
vcl == 0,
np.logical_and(
dt >= (-sw_time[i] * config['fs_time_prop']),
dt <= sw_time[i]))
# Of those events inside time window,
# find those inside distance window
vsel1 = haversine(longitude[vsel], latitude[vsel],
longitude[i], latitude[i]) <= sw_space[i]
vsel[vsel] = vsel1[:, 0]
temp_vsel = np.copy(vsel)
temp_vsel[i] = False
if any(temp_vsel):
# Allocate a cluster number
vcl[vsel] = clust_index + 1
flagvector[vsel] = 1
# For those events in the cluster before the main event,
# flagvector is equal to -1
temp_vsel[dt >= 0.0] = False
flagvector[temp_vsel] = -1
flagvector[i] = 0
clust_index += 1
# Re-sort the catalog_matrix into original order
id1 = np.argsort(eqid, kind='heapsort')
eqid = eqid[id1]
vcl = vcl[id1]
flagvector = flagvector[id1]
return vcl, flagvector
def decluster(self, catalogue, config):
"""
catalogue_matrix, window_opt=TDW_GARDNERKNOPOFF, time_window=60.):
:param catalogue: a catalogue object
:type catalogue: Instance of the openquake.hmtk.seismicity.catalogue.Catalogue()
class
:keyword window_opt: method used in calculating distance and time
windows
:type window_opt: string
:keyword time_window: Length (in days) of moving time window
:type time_window: positive float
:returns: **vcl vector** indicating cluster number,
**flagvector** indicating which earthquakes belong to a
cluster
:rtype: numpy.ndarray
"""
# Convert time window from days to decimal years
time_window = config['time_window'] / 365.
# Pre-processing steps are the same as for Gardner & Knopoff
# Get relevent parameters
mag = catalogue.data['magnitude']
neq = np.shape(mag)[0] # Number of earthquakes
# Get decimal year (needed for time windows)
year_dec = decimal_year(catalogue.data['year'],
catalogue.data['month'], catalogue.data['day'])
# Get space windows corresponding to each event
sw_space, _ = (config['time_distance_window'].calc(
catalogue.data['magnitude']))
# Pre-allocate cluster index vectors
vcl = np.zeros(neq, dtype=int)
flagvector = np.zeros(neq, dtype=int)
# Rank magnitudes into descending order
id0 = np.flipud(np.argsort(mag, kind='heapsort'))
clust_index = 0
for imarker in id0:
# Earthquake not allocated to cluster - perform calculation
if vcl[imarker] == 0:
# Perform distance calculation
mdist = haversine(
catalogue.data['longitude'], catalogue.data['latitude'],
catalogue.data['longitude'][imarker],
catalogue.data['latitude'][imarker]).flatten()
# Select earthquakes inside distance window, later than
# mainshock and not already assigned to a cluster
vsel1 = np.where(
np.logical_and(
vcl == 0,
np.logical_and(mdist <= sw_space[imarker],
year_dec > year_dec[imarker])))[0]
has_aftershocks = False
if len(vsel1) > 0:
# Earthquakes after event inside distance window
temp_vsel1, has_aftershocks = self._find_aftershocks(
vsel1, year_dec, time_window, imarker, neq)
if has_aftershocks:
flagvector[temp_vsel1] = 1
vcl[temp_vsel1] = clust_index + 1
# Select earthquakes inside distance window, earlier than
# mainshock and not already assigned to a cluster
has_foreshocks = False
vsel2 = np.where(
np.logical_and(
vcl == 0,
np.logical_and(mdist <= sw_space[imarker],
year_dec < year_dec[imarker])))[0]
if len(vsel2) > 0:
# Earthquakes before event inside distance window
temp_vsel2, has_foreshocks = self._find_foreshocks(
vsel2, year_dec, time_window, imarker, neq)
if has_foreshocks:
flagvector[temp_vsel2] = -1
vcl[temp_vsel2] = clust_index + 1
if has_aftershocks or has_foreshocks:
# Assign mainshock to cluster
vcl[imarker] = clust_index + 1
clust_index += 1
return vcl, flagvector
def decluster(self, catalogue, config):
"""
The configuration of this declustering algorithm requires two
objects:
- A time-distance window object (key is 'time_distance_window')
- A value in the interval [0,1] expressing the fraction of the
time window used for aftershocks (key is 'fs_time_prop')
:param catalogue:
Catalogue of earthquakes
:type catalogue: Dictionary
:param config:
Configuration parameters
:type config: Dictionary
:returns:
**vcl vector** indicating cluster number,
**flagvector** indicating which eq events belong to a cluster
:rtype: numpy.ndarray
"""
# Get relevant parameters
neq = len(catalogue.data['magnitude']) # Number of earthquakes
# Get decimal year (needed for time windows)
year_dec = decimal_year(
catalogue.data['year'], catalogue.data['month'],
catalogue.data['day'])
# Get space and time windows corresponding to each event
# Initial Position Identifier
sw_space, sw_time = (
config['time_distance_window'].calc(
catalogue.data['magnitude'], config.get('time_cutoff')))
eqid = np.arange(0, neq, 1)
# Pre-allocate cluster index vectors
vcl = np.zeros(neq, dtype=int)
# Sort magnitudes into descending order
id0 = np.flipud(np.argsort(catalogue.data['magnitude'],
kind='heapsort'))
longitude = catalogue.data['longitude'][id0]
latitude = catalogue.data['latitude'][id0]
sw_space = sw_space[id0]
sw_time = sw_time[id0]
year_dec = year_dec[id0]
eqid = eqid[id0]
flagvector = np.zeros(neq, dtype=int)
# Begin cluster identification
clust_index = 0
for i in range(0, neq - 1):
if vcl[i] == 0:
# Find Events inside both fore- and aftershock time windows
dt = year_dec - year_dec[i]
vsel = np.logical_and(
vcl == 0,
np.logical_and(
dt >= (-sw_time[i] * config['fs_time_prop']),
dt <= sw_time[i]))
# Of those events inside time window,
# find those inside distance window
vsel1 = haversine(longitude[vsel],
latitude[vsel],
longitude[i],
latitude[i]) <= sw_space[i]
vsel[vsel] = vsel1[:, 0]
temp_vsel = np.copy(vsel)
temp_vsel[i] = False
if any(temp_vsel):
# Allocate a cluster number
vcl[vsel] = clust_index + 1
flagvector[vsel] = 1
# For those events in the cluster before the main event,
# flagvector is equal to -1
temp_vsel[dt >= 0.0] = False
flagvector[temp_vsel] = -1
flagvector[i] = 0
clust_index += 1
# Re-sort the catalog_matrix into original order
id1 = np.argsort(eqid, kind='heapsort')
eqid = eqid[id1]
vcl = vcl[id1]
flagvector = flagvector[id1]
return vcl, flagvector
def decluster(self, catalogue, config):
"""
catalogue_matrix, window_opt=TDW_GARDNERKNOPOFF, time_window=60.):
:param catalogue: a catalogue object
:type catalogue: Instance of the openquake.hmtk.seismicity.catalogue.Catalogue()
class
:keyword window_opt: method used in calculating distance and time
windows
:type window_opt: string
:keyword time_window: Length (in days) of moving time window
:type time_window: positive float
:returns: **vcl vector** indicating cluster number,
**flagvector** indicating which earthquakes belong to a
cluster
:rtype: numpy.ndarray
"""
# Convert time window from days to decimal years
time_window = config['time_window'] / 365.
# Pre-processing steps are the same as for Gardner & Knopoff
# Get relevent parameters
mag = catalogue.data['magnitude']
neq = np.shape(mag)[0] # Number of earthquakes
# Get decimal year (needed for time windows)
year_dec = decimal_year(catalogue.data['year'],
catalogue.data['month'],
catalogue.data['day'])
# Get space windows corresponding to each event
sw_space, _ = (
config['time_distance_window'].calc(catalogue.data['magnitude']))
# Pre-allocate cluster index vectors
vcl = np.zeros(neq, dtype=int)
flagvector = np.zeros(neq, dtype=int)
# Rank magnitudes into descending order
id0 = np.flipud(np.argsort(mag, kind='heapsort'))
clust_index = 0
for imarker in id0:
# Earthquake not allocated to cluster - perform calculation
if vcl[imarker] == 0:
# Perform distance calculation
mdist = haversine(
catalogue.data['longitude'],
catalogue.data['latitude'],
catalogue.data['longitude'][imarker],
catalogue.data['latitude'][imarker]).flatten()
# Select earthquakes inside distance window, later than
# mainshock and not already assigned to a cluster
vsel1 = np.where(
np.logical_and(vcl == 0,
np.logical_and(
mdist <= sw_space[imarker],
year_dec > year_dec[imarker])))[0]
has_aftershocks = False
if len(vsel1) > 0:
# Earthquakes after event inside distance window
temp_vsel1, has_aftershocks = self._find_aftershocks(
vsel1,
year_dec,
time_window,
imarker,
neq)
if has_aftershocks:
flagvector[temp_vsel1] = 1
vcl[temp_vsel1] = clust_index + 1
# Select earthquakes inside distance window, earlier than
# mainshock and not already assigned to a cluster
has_foreshocks = False
vsel2 = np.where(
np.logical_and(
vcl == 0,
np.logical_and(mdist <= sw_space[imarker],
year_dec < year_dec[imarker])))[0]
if len(vsel2) > 0:
# Earthquakes before event inside distance window
temp_vsel2, has_foreshocks = self._find_foreshocks(
vsel2,
year_dec,
time_window,
imarker,
neq)
if has_foreshocks:
flagvector[temp_vsel2] = -1
vcl[temp_vsel2] = clust_index + 1
if has_aftershocks or has_foreshocks:
# Assign mainshock to cluster
vcl[imarker] = clust_index + 1
clust_index += 1
return vcl, flagvector
