self.mst.contents.datasamples = clibmseed.allocate_bytes(bytecount)
C.memmove(self.mst.contents.datasamples, data.ctypes.get_data(),
bytecount)
def __del__(self):
"""
Frees all allocated memory.
"""
# This also frees the data of the associated datasamples pointer.
clibmseed.mst_free(C.pointer(self.mst))
del self.mst
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'isMSEED': 'obspy.io.mseed.core._is_mseed',
'readMSEED': 'obspy.io.mseed.core._read_mseed',
'writeMSEED': 'obspy.io.mseed.core._write_mseed'
})
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
endian = b'>'
else:
return False
except:
return False
# Check the revision number.
revision_number = unpack(endian + b'H', file_descriptor_block[2:4])[0]
if revision_number != 1:
return False
return True
def _read_seg2(filename, **kwargs): # @UnusedVariable
seg2 = SEG2()
st = seg2.read_file(filename)
warnings.warn(WARNING_HEADER)
return st
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
"isSEG2": "obspy.io.seg2.seg2._is_seg2",
"readSEG2": "obspy.io.seg2.seg2._read_seg2"
})
"with the next ObsPy version. Please import module "
"'%s' instead." % (name, new_name),
ObsPyDeprecationWarning)
sys.modules[new_name] = module
sys.modules[name] = module
return module
# Install meta path handler.
sys.meta_path.append(ObsPyRestructureMetaPathFinderAndLoader())
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__, doc=__doc__, locs=locals(),
original_module=sys.modules[__name__],
import_map={key.split(".")[1]: value for key, value in
_import_map.items() if len(key.split(".")) == 2},
function_map=_function_map)
# insert supported read/write format plugin lists dynamically in docstrings
from obspy.core.util.base import make_format_plugin_table
read.__doc__ = \
read.__doc__ % make_format_plugin_table("waveform", "read", numspaces=4)
read_events.__doc__ = \
read_events.__doc__ % make_format_plugin_table("event", "read",
numspaces=4)
if PY2:
Stream.write.im_func.func_doc = \
:class:`~obspy.core.utcdatetime.UTCDateTime` object, stripping away
trailing decimal-second zeros.
>>> from obspy import UTCDateTime
>>> print(_timestring(UTCDateTime("2012-04-05T12:12:12.123456Z")))
2012-04-05T12:12:12.123456
>>> print(_timestring(UTCDateTime("2012-04-05T12:12:12.120000Z")))
2012-04-05T12:12:12.12
>>> print(_timestring(UTCDateTime("2012-04-05T12:12:12.000000Z")))
2012-04-05T12:12:12
>>> print(_timestring(UTCDateTime("2012-04-05T12:12:00.000000Z")))
2012-04-05T12:12:00
>>> print(_timestring(UTCDateTime("2012-04-05T12:12:00.120000Z")))
2012-04-05T12:12:00.12
"""
return str(t).rstrip("Z0").rstrip(".")
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={'_ID_key': 'obspy.imaging.util._id_key'})
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
constant /= (2. * np.pi) ** 3
# fill up ObsPy Poles and Zeros AttribDict
# In SAC pole-zero files CONSTANT is defined as:
# digitizer_gain*seismometer_gain*A0
tr.stats.paz = AttribDict()
tr.stats.paz.seismometer_gain = sens
tr.stats.paz.digitizer_gain = 1.0
tr.stats.paz.poles = poles
tr.stats.paz.zeros = zeros
# taken from obspy.io.gse2.paz:145
tr.stats.paz.sensitivity = tr.stats.paz.digitizer_gain * \
tr.stats.paz.seismometer_gain
tr.stats.paz.gain = constant
tr.stats.paz.t_shift = t_shift
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__, doc=__doc__, locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'write_SACPZ': 'obspy.io.sac.sacpz._write_sacpz'})
if __name__ == "__main__":
import doctest
doctest.testmod()
line = fh.readline()
header['calib'] = float(line[0:10])
header['gse1']['units'] = float(line[10:17])
header['gse1']['cperiod'] = float(line[18:27])
header['gse1']['lat'] = float(line[28:37])
header['gse1']['lon'] = float(line[38:47])
header['gse1']['alt'] = float(line[48:57])
header['gse1']['unknown1'] = float(line[58:65])
header['gse1']['unknown2'] = float(line[66:73])
header['gse1']['unknown3'] = float(line[74:81])
header['gse1']['unknown4'] = float(line[74:80])
# Py3k: convert to unicode
header['gse1'] = dict((k, v.decode()) if isinstance(v, bytes) else (k, v)
for k, v in header['gse1'].items())
return dict((k, v.decode()) if isinstance(v, bytes) else (k, v)
for k, v in header.items())
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__, doc=__doc__, locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'readHeader': 'obspy.io.gse2.libgse1.read_header',
'readIntegerData': 'obspy.io.gse2.libgse1.read_integer_data'})
if __name__ == '__main__':
doctest.testmod(exclude_empty=True)
from obspy.core.util.attribdict import AttribDict
from obspy.core.util.base import (ALL_MODULES, DEFAULT_MODULES,
NATIVE_BYTEORDER, NETWORK_MODULES,
NamedTemporaryFile, _read_from_plugin,
create_empty_data_chunk, get_example_file,
get_matplotlib_version, get_script_dir_name)
from obspy.core.util.deprecation_helpers import \
DynamicAttributeImportRerouteModule
from obspy.core.util.misc import (BAND_CODE, CatchOutput, complexify_string,
guess_delta, loadtxt, score_at_percentile,
to_int_or_zero)
from obspy.core.util.obspy_types import (ComplexWithUncertainties, Enum,
FloatWithUncertainties)
from obspy.core.util.testing import add_doctests, add_unittests
from obspy.core.util.version import get_git_version as _get_version_string
# Remove once 0.11 has been released!
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__, doc=__doc__, locs=locals(),
import_map={"geodetics": "obspy.geodetics"},
function_map={
"FlinnEngdahl": "obspy.geodetics.FlinnEngdahl",
"calcVincentyInverse": "obspy.geodetics.calc_vincenty_inverse",
"degrees2kilometers": "obspy.geodetics.degrees2kilometers",
"gps2DistAzimuth": "obspy.geodetics.gps2dist_azimuth",
"kilometer2degrees": "obspy.geodetics.kilometer2degrees",
"locations2degrees": "obspy.geodetics.locations2degrees",
"getMatplotlibVersion": "obspy.core.util.get_matplotlib_version",
})
GNU Lesser General Public License, Version 3
(http://www.gnu.org/copyleft/lesser.html)
"""
from __future__ import (absolute_import, division, print_function,
unicode_literals)
from future.builtins import * # NOQA
import sys
from obspy.core.util.deprecation_helpers import \
DynamicAttributeImportRerouteModule
from .base import (calc_vincenty_inverse, degrees2kilometers, gps2dist_azimuth,
kilometer2degrees, locations2degrees)
from .flinnengdahl import FlinnEngdahl
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
import_map={},
function_map={
"calcVincentyInverse": "obspy.geodetics.base.calc_vincenty_inverse",
"gps2DistAzimuth": "obspy.geodetics.base.gps2dist_azimuth"
})
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
@property
def yy(self):
return self.mt[1][1]
@property
def zz(self):
return self.mt[2][2]
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'MT2Axes': 'obspy.imaging.beachball.mt2axes',
'MT2Plane': 'obspy.imaging.beachball.mt2plane',
'Pol2Cart': 'obspy.imaging.beachball.pol2cart',
'StrikeDip': 'obspy.imaging.beachball.strike_dip',
'TDL': 'obspy.imaging.beachball.tdl',
'plotDC': 'obspy.imaging.beachball.plot_dc',
'plotMT': 'obspy.imaging.beachball.plot_mt'
})
if __name__ == '__main__':
import doctest
doctest.testmod()
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
# Monkey patch the __str__ method for the all Trace instances used in the
# following.
# XXX: Check if this is not messing anything up. Patching every single
# instance did not reliably work.
setattr(Trace, '__original_str__', Trace.__str__)
setattr(Trace, '__str__', _segy_trace_str_)
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'isSEGY': 'obspy.io.segy.core._is_segy',
'isSU': 'obspy.io.segy.core._is_su',
'readSEGY': 'obspy.io.segy.core._read_segy',
'readSEGYrev1': 'obspy.io.segy.segy._read_segy',
'readSU': 'obspy.io.segy.core._read_su',
'readSUFile': 'obspy.io.segy.core._read_su',
'writeSEGY': 'obspy.io.segy.core._write_segy',
'writeSU': 'obspy.io.segy.core._write_su'
})
except EOFError:
break
if magic != 1100:
raise Exception('Not a AH v2 file')
try:
# get record length
length = data.unpack_uint()
# read rest of record into XDR unpacker
data = xdrlib.Unpacker(fh.read(length))
tr = _unpack_trace(data)
st.append(tr)
except EOFError:
break
return st
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'is_AH': 'obspy.io.ah.core._is_ah',
'read_AH': 'obspy.io.ah.core._read_ah',
'read_AH1': 'obspy.io.ah.core._read_ah1',
'read_AH2': 'obspy.io.ah.core._read_ah2',
'_get_AH_version': 'obspy.io.ah.core._get_ah_version'
})
>>> round_away(-2.5)
-3
>>> round_away(10.5)
11
>>> round_away(-10.5)
-11
>>> round_away(11.0)
11
>>> round_away(-11.0)
-11
"""
floor = np.floor(number)
ceil = np.ceil(number)
if (floor != ceil) and (abs(number - floor) == abs(ceil - number)):
return int(int(number) + int(np.sign(number)))
else:
return int(np.round(number))
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={'frombuffer': 'obspy.core.compatibility.from_buffer'})
coincidence_triggers.append(event)
last_off_time = off
return coincidence_triggers
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
"arPick": "obspy.signal.trigger.ar_pick",
"carlSTATrig": "obspy.signal.trigger.carl_sta_trig",
"classicSTALTA": "obspy.signal.trigger.classic_sta_lta",
"classicSTALTAPy": "obspy.signal.trigger.classic_sta_lta_py",
"coincidenceTrigger": "obspy.signal.trigger.coincidence_trigger",
"delayedSTALTA": "obspy.signal.trigger.delayed_sta_lta",
"pkBaer": "obspy.signal.trigger.pk_baer",
"plotTrigger": "obspy.signal.trigger.plot_trigger",
"recSTALTA": "obspy.signal.trigger.recursive_sta_lta",
"recSTALTAPy": "obspy.signal.trigger.recursive_sta_lta_py",
"triggerOnset": "obspy.signal.trigger.trigger_onset",
"zDetect": "obspy.signal.trigger.z_detect"
})
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
th_is_y = window_vals * th_is_y
fy = np.fft.fft(th_is_y, n=pad_to)
p_xy[:, i] = np.conjugate(fx[:num_freqs]) * fy[:num_freqs]
# Scale the spectrum by the norm of the window to compensate for
# windowing loss; see Bendat & Piersol Sec 11.5.2. Also include
# scaling factors for one-sided densities and dividing by the sampling
# frequency, if desired.
p_xy *= scaling_factor / (np.abs(window_vals) ** 2).sum()
t = 1. / Fs * (ind + NFFT / 2.)
freqs = float(Fs) / pad_to * np.arange(num_freqs)
if (np.iscomplexobj(x) and sides == 'default') or sides == 'twosided':
# center the frequency range at zero
freqs = np.concatenate((freqs[num_freqs // 2:] - Fs,
freqs[:num_freqs // 2]))
p_xy = np.concatenate((p_xy[num_freqs // 2:, :],
p_xy[:num_freqs // 2, :]), 0)
return p_xy, freqs, t
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__, doc=__doc__, locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
"relcalstack": "obspy.signal.calibration.rel_calib_stack",
"_calcresp": "obspy.signal.calibration._calc_resp"})
np.seterr(**temp)
# Eventually apply more than once.
while count > 1:
new_spec = konno_ohmachi_smoothing(new_spec,
frequencies,
bandwidth,
enforce_no_matrix=True,
normalize=normalize)
count -= 1
return new_spec
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
"calculateSmoothingMatrix":
"obspy.signal.konnoohmachismoothing."
"calculate_smoothing_matrix",
"konnoOhmachiSmoothing":
"obspy.signal.konnoohmachismoothing."
"konno_ohmachi_smoothing",
"konnoOhmachiSmoothingWindow":
"obspy.signal.konnoohmachismoothing."
"konno_ohmachi_smoothing_window"
})
# -*- coding: utf-8 -*-
from __future__ import (absolute_import, division, print_function,
unicode_literals)
from future.builtins import * # NOQA
import sys
from obspy.core.util.deprecation_helpers import \
DynamicAttributeImportRerouteModule
# Remove once 0.11 has been released!
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__, doc=__doc__, locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
"_validate": "obspy.io.quakeml.core._validate"})
result['preview'] = trace.data.dumps()
except ValueError:
pass
except Exception as e:
msg = '[Creating preview] %s: %s'
log_queue.append(msg % (filepath, e))
# update dataset
dataset.append(result)
del stream
# return results to main loop
try:
output_queue.append(dataset)
except:
pass
try:
work_queue.remove(filepath)
except:
pass
except KeyboardInterrupt:
return
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={'createPreview': 'obspy.db.indexer.create_preview'})
# we expect 10 (standard) or 13 columns (extended)
columns = first_line.split('\t')
if len(columns) not in [10, 13]:
return False
# only numerical values are allowed (including NaN)
try:
[float(col) for col in columns]
return True
except ValueError:
return False
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'isZmap': 'obspy.io.zmap.core._is_zmap',
'readZmap': 'obspy.io.zmap.core._read_zmap',
'writeZmap': 'obspy.io.zmap.core._write_zmap'
})
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
"""
Given a timedelta object compute it as double seconds.
"""
d = dt.days * 86400.
d = d + dt.seconds
d = d + dt.microseconds / 1000000.0
return d
def get_property(filename, key):
"""
Given a property filename get the value of the given key
"""
with open(filename, 'r') as fh:
lines = fh.readlines()
for line in lines:
line = line.strip()
if line.startswith(key):
ans = line[len(key) + 1:]
return ans
return ""
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__, doc=__doc__, locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'getProperty': 'obspy.clients.neic.util.get_property'})
>>> dt = UTCDateTime(2008, 1, 2, 3, 4, 5, 123456)
>>> print(from_utcdatetime(dt))
2-JAN-2008_03:04:05.123
"""
pattern = "%2d-%3s-%4d_%02d:%02d:%02d.%03d"
return pattern % (dt.day, MONTHS[dt.month - 1], dt.year, dt.hour,
dt.minute, dt.second, dt.microsecond / 1000)
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'fromUTCDateTime': 'obspy.io.sh.core.from_utcdatetime',
'isASC': 'obspy.io.sh.core._is_asc',
'isQ': 'obspy.io.sh.core._is_q',
'readASC': 'obspy.io.sh.core._read_asc',
'readQ': 'obspy.io.sh.core._read_q',
'writeASC': 'obspy.io.sh.core._write_asc',
'writeQ': 'obspy.io.sh.core._write_q'
})
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
human-readable data interchange. The JSON format is often used for serializing
and transmitting structured data over a network connection. It is used
primarily to transmit data between a server and web application, serving as an
alternative to XML.
See the module :mod:`obspy.io.json.default` for documentation on the class.
A write function for files and a utility for compact string serialization using
the Default class are located in :mod:`obspy.io.json.core`.
"""
from __future__ import (absolute_import, division, print_function,
unicode_literals)
from future.builtins import * # NOQA
import sys
from obspy.core.util.deprecation_helpers import \
DynamicAttributeImportRerouteModule
from .default import Default
from .core import get_dump_kwargs, _write_json
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={'writeJSON': 'obspy.io.json._write_json'})
if len('%5.3f' % stats['gse2'][key]) > 5:
msg = ("Bad value in GSE2 '%s' header field detected. "
"The last two header fields of the STA2 line in the "
"output file will deviate from the official fixed "
"column format description (because they can not be "
"represented as '%%f5.3' properly).") % key
warnings.warn(msg)
return line.encode('ascii', 'strict')
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'isGse2': 'obspy.io.gse2.libgse2.is_gse2',
'readHeader': 'obspy.io.gse2.libgse2.read_header',
'verifyChecksum': 'obspy.io.gse2.libgse2.verify_checksum',
'writeHeader': 'obspy.io.gse2.libgse2.write_header',
'compile_STA2': 'obspy.io.gse2.libgse2.compile_sta2',
'compress_CM6': 'obspy.io.gse2.libgse2.compress_cm6',
'parse_STA2': 'obspy.io.gse2.libgse2.parse_sta2',
'uncompress_CM6': 'obspy.io.gse2.libgse2.uncompress_cm6'
})
if __name__ == '__main__':
doctest.testmod(exclude_empty=True)
})
nodal_planes = map(float, line5[57:].strip().split())
rec["nodal_plane_1"] = {
"strike": next(nodal_planes),
"dip": next(nodal_planes),
"rake": next(nodal_planes)
}
rec["nodal_plane_2"] = {
"strike": next(nodal_planes),
"dip": next(nodal_planes),
"rake": next(nodal_planes)
}
return rec
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__, doc=__doc__, locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'is_ndk': 'obspy.io.ndk.core._is_ndk',
'read_ndk': 'obspy.io.ndk.core._read_ndk'})
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
"""
# Check the dtype and raise exception otherwise!
if data.dtype != np.float32:
raise WrongDtypeException
# Swap the byte order if necessary.
if BYTEORDER != endian:
data = data.byteswap()
# Write the file.
file.write(data.tostring())
def pack_1byte_integer(file, data, endian='>'):
raise NotImplementedError
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'pack_1byte_Integer': 'obspy.io.segy.pack.pack_1byte_integer',
'pack_2byte_Integer': 'obspy.io.segy.pack.pack_2byte_integer',
'pack_4byte_Integer': 'obspy.io.segy.pack.pack_4byte_integer',
'pack_4byte_IBM': 'obspy.io.segy.pack.pack_4byte_ibm',
'pack_4byte_IEEE': 'obspy.io.segy.pack.pack_4byte_ieee',
'pack_4byte_Fixed_point': 'obspy.io.segy.pack.pack_4byte_fixed_point'
})
continue
col = getattr(WaveformChannel, key)
if '*' in value or '?' in value:
value = value.replace('?', '_')
value = value.replace('*', '%')
query = query.filter(col.like(value))
else:
query = query.filter(col == value)
# execute query
results = query.all()
session.close()
# create Stream
st = Stream()
for result in results:
preview = result.get_preview()
st.append(preview)
# merge and trim
st = merge_previews(st)
st.trim(starttime, endtime, pad=pad)
return st
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={'mergePreviews': 'obspy.db.client.merge_previews'})
try:
temp['starttime'] = UTCDateTime(data[2])
except:
msg += "starttime '%s' is not a time format"
raise Exception(msg % data[2])
else:
temp['starttime'] = None
if len(data) > 3:
try:
temp['endtime'] = UTCDateTime(data[3])
except:
msg += "endtime '%s' is not a time format"
raise Exception(msg % data[3])
if temp['endtime'] < temp['starttime']:
msg += "endtime '%s' should be after starttime"
raise Exception(msg % data[3])
else:
temp['endtime'] = None
results.setdefault(old_id, [])
results.get(old_id).append(temp)
return results
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__, doc=__doc__, locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
"parseMappingData": "obspy.db.util.parse_mapping_data"})
dsigma = signal.lfilter(fk, 1, sigma_add)
# dsigma = dsigma[np.size(fk) // 2:
# (np.size(dsigma) - np.size(fk) // 2)]
# correct start and end values
dsigma = dsigma[np.size(fk) - 1:np.size(dsigma)]
return sigma, dsigma
else:
row = x[1]
# faster alternative to calculate A_win_add
a_win_add = np.hstack(([row[0]] * (np.size(fk) // 2), row,
[row[np.size(row) - 1]] * (np.size(fk) // 2)))
t = signal.lfilter(fk, 1, a_win_add)
# correct start and end values
t = t[np.size(fk) - 1:np.size(t)]
sigma = abs((t * fs) / (x[1] * 2 * np.pi))
return sigma
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
"instBwith": "obspy.signal.cpxtrace.instantaneous_bandwidth",
"instFreq": "obspy.signal.cpxtrace.instantaneous_frequency",
"normEnvelope": "obspy.signal.cpxtrace.normalized_envelope"
})
read_fmt = np.dtype(dtype)
fmt = read_fmt
with open(filename, "rb") as fh:
fh.seek(offset)
data = fh.read(read_fmt.itemsize * npts)
data = from_buffer(data, dtype=read_fmt)
data = np.require(data, dtype=fmt)
header = {}
header['station'] = line[0:6].strip().decode()
header['channel'] = line[7:15].strip().decode()
header['starttime'] = UTCDateTime(float(line[16:33]))
header['sampling_rate'] = float(line[88:99])
header['calib'] = float(line[100:116])
header['calper'] = float(line[117:133])
tr = Trace(data, header=header)
traces.append(tr)
return Stream(traces=traces)
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
"isCSS": "obspy.io.css.core._is_css",
"readCSS": "obspy.io.css.core._read_css"
})
if smart and nfft > 5000 and not _good_factorization(nfft):
# try a few numbers slightly larger for a suitable factorization
# in most cases after less than 10 tries a suitable nfft number with
# good factorization is found
for i_ in range(1, 11):
trial = int(nfft + 2 * i_)
if _good_factorization(trial):
nfft = trial
break
else:
nfft = next_pow_2(nfft)
return nfft
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
"nearestPow2": "obspy.signal.util.nearest_pow_2",
"prevpow2": "obspy.signal.util.prev_pow_2"
})
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
:param filename: mchedr file to be read.
:rtype: :class:`~obspy.core.event.Catalog`
:return: An ObsPy Catalog object.
.. rubric:: Example
>>> from obspy.core.event import read_events
>>> cat = read_events('/path/to/mchedr.dat')
>>> print(cat)
1 Event(s) in Catalog:
2012-01-01T05:27:55.980000Z | +31.456, +138.072 | 6.2 Mb
"""
return Unpickler().load(filename)
# Remove once 0.11 has been released.
sys.modules[__name__] = DynamicAttributeImportRerouteModule(
name=__name__,
doc=__doc__,
locs=locals(),
original_module=sys.modules[__name__],
import_map={},
function_map={
'isMchedr': 'obspy.io.pde.mchedr._is_mchedr',
'readMchedr': 'obspy.io.pde.mchedr._read_mchedr'
})
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)
