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)