def parse(self):
'''
Returns the catalogue as an instance of an ISFCatalogue
An ISF catalogue will have two origins: The hypocentre solution and
the centroid
'''
isf_cat = ISFCatalogue('GCMT', 'GCMT')
n_cmts = self.catalogue.number_events()
base_id = 'GCMT_'
counter = 1
for gcmt in self.catalogue.gcmts:
# Get IDs
event_id = base_id + ("%06d" % counter)
counter += 1
origin_id = gcmt.identifier.strip(' ')
# Two origins - 1 hypocentre (mb, Ms, Mw), 2 - centroid (Mw)
origin_mags = []
if gcmt.hypocentre.m_b:
origin_mags.append(Magnitude(event_id,
origin_id,
gcmt.hypocentre.m_b,
gcmt.hypocentre.source,
scale='mb'))
if gcmt.hypocentre.m_s:
origin_mags.append(Magnitude(event_id,
origin_id,
gcmt.hypocentre.m_s,
gcmt.hypocentre.source,
scale='Ms'))
m_w = Magnitude(event_id,
gcmt.centroid.centroid_id, gcmt.magnitude, 'GCMT',
scale='Mw')
origin_mags.append(m_w)
# Get locations
hypo_loc = Location(origin_id,
gcmt.hypocentre.longitude,
gcmt.hypocentre.latitude,
gcmt.hypocentre.depth)
centroid_loc = Location(origin_id + "-C",
gcmt.centroid.longitude,
gcmt.centroid.latitude,
gcmt.centroid.depth,
depth_error=gcmt.centroid.depth_error)
# Get origins
hypo = Origin(origin_id,
gcmt.hypocentre.date,
gcmt.hypocentre.time,
hypo_loc,
gcmt.hypocentre.source,
is_prime=True)
hypo.magnitudes = origin_mags
# Get centroids
centroid = Origin(origin_id + "-C",
gcmt.centroid.date,
gcmt.centroid.time,
centroid_loc,
'GCMT',
is_centroid=True,
time_error=gcmt.centroid.time_error)
centroid.magnitudes = [m_w]
event = Event(event_id, [hypo, centroid], origin_mags,
gcmt.hypocentre.location)
setattr(event, 'tensor', gcmt.moment_tensor)
isf_cat.events.append(event)
return isf_cat
def parse(self):
'''
Returns the catalogue as an instance of an ISFCatalogue
An ISF catalogue will have two origins: The hypocentre solution and
the centroid
'''
isf_cat = ISFCatalogue('GCMT', 'GCMT')
n_cmts = self.catalogue.number_events()
base_id = 'GCMT_'
counter = 1
for gcmt in self.catalogue.gcmts:
# Get IDs
event_id = base_id + ("%06d" % counter)
counter += 1
origin_id = gcmt.identifier.strip(' ')
# Two origins - 1 hypocentre (mb, Ms, Mw), 2 - centroid (Mw)
origin_mags = []
if gcmt.hypocentre.m_b:
origin_mags.append(Magnitude(event_id,
origin_id,
gcmt.hypocentre.m_b,
gcmt.hypocentre.source,
scale='mb'))
if gcmt.hypocentre.m_s:
origin_mags.append(Magnitude(event_id,
origin_id,
gcmt.hypocentre.m_s,
gcmt.hypocentre.source,
scale='Ms'))
m_w = Magnitude(event_id,
gcmt.centroid.centroid_id, gcmt.magnitude, 'GCMT',
scale='Mw')
origin_mags.append(m_w)
# Get locations
hypo_loc = Location(origin_id,
gcmt.hypocentre.longitude,
gcmt.hypocentre.latitude,
gcmt.hypocentre.depth)
centroid_loc = Location(gcmt.centroid.centroid_id,
gcmt.centroid.longitude,
gcmt.centroid.latitude,
gcmt.centroid.depth,
depth_error=gcmt.centroid.depth_error)
# Get origins
hypo = Origin(origin_id,
gcmt.hypocentre.date,
gcmt.hypocentre.time,
hypo_loc,
gcmt.hypocentre.source,
is_prime=True)
hypo.magnitudes = origin_mags
# Get centroids
centroid = Origin(gcmt.centroid.centroid_id,
gcmt.centroid.date,
gcmt.centroid.time,
centroid_loc,
'GCMT',
is_centroid=True,
time_error=gcmt.centroid.time_error)
centroid.magnitudes = [m_w]
event = Event(event_id, [hypo, centroid], origin_mags,
gcmt.hypocentre.location)
setattr(event, 'tensor', gcmt.moment_tensor)
isf_cat.events.append(event)
return isf_cat
def write_to_isf_catalogue(self, catalogue_id, name):
"""
Exports the catalogue to an instance of the :class:
eqcat.isf_catalogue.ISFCatalogue
"""
isf_cat = ISFCatalogue(catalogue_id, name)
for iloc in range(0, self.get_number_events()):
# Origin ID
event_id = str(self.data['eventID'][iloc])
origin_id = event_id
# Create Magnitude
mag = [Magnitude(event_id,
origin_id,
self.data['magnitude'][iloc],
catalogue_id,
scale='Mw',
sigma=self.data['sigmaMagnitude'][iloc])]
# Create Moment
if not np.isnan(self.data['moment'][iloc]):
moment = self.data['moment'][iloc] *\
(10. ** self.data['scaling'][iloc])
mag.append(Magnitude(event_id,
origin_id,
moment,
catalogue_id,
scale='Mo'))
# Create Location
semimajor90 = self.data['SemiMajor90'][iloc]
semiminor90 = self.data['SemiMinor90'][iloc]
error_strike = self.data['ErrorStrike'][iloc]
if np.isnan(semimajor90):
semimajor90 = None
if np.isnan(semiminor90):
semiminor90 = None
if np.isnan(error_strike):
error_strike = None
depth_error = self.data['depthError'][iloc]
if np.isnan(depth_error):
depth_error = None
locn = Location(origin_id,
self.data['longitude'][iloc],
self.data['latitude'][iloc],
self.data['depth'][iloc],
semimajor90,
semiminor90,
error_strike,
depth_error)
# Create Origin
# Date
eq_date = datetime.date(self.data['year'][iloc],
self.data['month'][iloc],
self.data['day'][iloc])
# Time
secs = self.data['second'][iloc]
microsecs = int((secs - floor(secs)) * 1E6)
eq_time = datetime.time(self.data['hour'][iloc],
self.data['minute'][iloc],
int(secs),
microsecs)
origin = Origin(origin_id, eq_date, eq_time, locn, catalogue_id,
is_prime=True)
origin.magnitudes = mag
event = Event(event_id, [origin], origin.magnitudes)
if self._check_moment_tensor_components(iloc):
# If a moment tensor is found then add it to the event
moment_tensor = GCMTMomentTensor()
scaling = 10. ** self.data['scaling'][iloc]
moment_tensor.tensor = scaling * utils.COORD_SYSTEM['USE'](
self.data['mrr'][iloc],
self.data['mtt'][iloc],
self.data['mpp'][iloc],
self.data['mrt'][iloc],
self.data['mpr'][iloc],
self.data['mtp'][iloc])
moment_tensor.exponent = self.data['scaling'][iloc]
setattr(event, 'tensor', moment_tensor)
isf_cat.events.append(event)
return isf_cat
def write_to_isf_catalogue(self, catalogue_id, name):
"""
Exports the catalogue to an instance of the :class:
eqcat.isf_catalogue.ISFCatalogue
"""
isf_cat = ISFCatalogue(catalogue_id, name)
for iloc in range(0, self.get_number_events()):
# Origin ID
event_id = str(self.data['eventID'][iloc])
origin_id = event_id
# Create Magnitude
mag = self.data["magnitude"][iloc]
if not mag or np.isnan(mag):
# No magnitude - not useful
continue
mag = [Magnitude(event_id,
origin_id,
mag,
catalogue_id,
scale=self.data["magnitudeType"][iloc],
sigma=self.data['sigmaMagnitude'][iloc])]
# Create Location
semimajor90 = self.data['SemiMajor90'][iloc]
semiminor90 = self.data['SemiMinor90'][iloc]
error_strike = self.data['ErrorStrike'][iloc]
if np.isnan(semimajor90):
semimajor90 = None
if np.isnan(semiminor90):
semiminor90 = None
if np.isnan(error_strike):
error_strike = None
depth_error = self.data['depthError'][iloc]
if np.isnan(depth_error):
depth_error = None
locn = Location(origin_id,
self.data['longitude'][iloc],
self.data['latitude'][iloc],
self.data['depth'][iloc],
semimajor90,
semiminor90,
error_strike,
depth_error)
# Create Origin
# Date
eq_date = datetime.date(self.data['year'][iloc],
self.data['month'][iloc],
self.data['day'][iloc])
# Time
secs = self.data['second'][iloc]
microsecs = int((secs - floor(secs)) * 1E6)
eq_time = datetime.time(self.data['hour'][iloc],
self.data['minute'][iloc],
int(secs),
microsecs)
origin = Origin(origin_id, eq_date, eq_time, locn, catalogue_id,
is_prime=True)
origin.magnitudes = mag
event = Event(event_id, [origin], origin.magnitudes)
isf_cat.events.append(event)
return isf_cat
def write_to_isf_catalogue(self, catalogue_id, name):
"""
Exports the catalogue to an instance of the :class:
eqcat.isf_catalogue.ISFCatalogue
"""
isf_cat = ISFCatalogue(catalogue_id, name)
for iloc in range(0, self.get_number_events()):
# Origin ID
event_id = str(self.data['eventID'][iloc])
origin_id = event_id
# Create Magnitude
mag = [Magnitude(event_id,
origin_id,
self.data['magnitude'][iloc],
name,
scale='Mw',
sigma=self.data['sigmaMagnitude'][iloc])]
# Create Moment
if not np.isnan(self.data['moment'][iloc]):
moment = self.data['moment'][iloc] *\
(10. ** self.data['scaling'][iloc])
mag.append(Magnitude(event_id,
origin_id,
moment,
name,
scale='Mo'))
# Create Location
semimajor90 = self.data['SemiMajor90'][iloc]
semiminor90 = self.data['SemiMinor90'][iloc]
error_strike = self.data['ErrorStrike'][iloc]
if np.isnan(semimajor90):
semimajor90 = None
if np.isnan(semiminor90):
semiminor90 = None
if np.isnan(error_strike):
error_strike = None
depth_error = self.data['depthError'][iloc]
if np.isnan(depth_error):
depth_error = None
locn = Location(origin_id,
self.data['longitude'][iloc],
self.data['latitude'][iloc],
self.data['depth'][iloc],
semimajor90,
semiminor90,
error_strike,
depth_error)
# Create Origin
# Date
eq_date = datetime.date(self.data['year'][iloc],
self.data['month'][iloc],
self.data['day'][iloc])
# Time
secs = self.data['second'][iloc]
microsecs = int((secs - floor(secs)) * 1E6)
eq_time = datetime.time(self.data['hour'][iloc],
self.data['minute'][iloc],
int(secs),
microsecs)
origin = Origin(origin_id, eq_date, eq_time, locn, name,
is_prime=True)
origin.magnitudes = mag
event = Event(event_id, [origin], origin.magnitudes)
if self._check_moment_tensor_components(iloc):
# If a moment tensor is found then add it to the event
moment_tensor = GCMTMomentTensor()
scaling = 10. ** self.data['scaling'][iloc]
moment_tensor.tensor = scaling * utils.COORD_SYSTEM['USE'](
self.data['mrr'][iloc],
self.data['mtt'][iloc],
self.data['mpp'][iloc],
self.data['mrt'][iloc],
self.data['mpr'][iloc],
self.data['mtp'][iloc])
moment_tensor.exponent = self.data['scaling'][iloc]
setattr(event, 'tensor', moment_tensor)
isf_cat.events.append(event)
return isf_cat
