def detect_format(filename):
try:
f = open(filename, 'r')
data = f.read(512)
f.close()
except OSError, e:
raise FileLoadError(e)
def iload(filename, load_data):
try:
kanf = KanFile(filename, load_data=load_data)
tr = kanf.to_trace()
yield tr
except (OSError, KanError), e:
raise FileLoadError(e)
def iload(filename, load_data=True):
try:
sacf = SacFile(filename, load_data=load_data)
tr = sacf.to_trace()
yield tr
except (OSError, SacError), e:
raise FileLoadError(e)
def iload(filename, load_data=True):
try:
f = open(filename, 'r')
tf = TracesFileIO(f)
for tr in tf.load(load_data=load_data):
yield tr
except (OSError, FileError), e:
raise FileLoadError(e)
def iload(filename, load_data=True):
from pyrocko import ims
try:
with open(filename, 'r') as f:
r = ims.Reader(f, load_data=load_data, version='GSE2.0',
dialect=None)
for sec in r:
if isinstance(sec, ims.WID2Section):
tr = sec.pyrocko_trace(checksum_error='warn')
yield tr
except (OSError, ims.DeserializeError), e:
fle = FileLoadError(e)
fle.set_context('filename', filename)
raise fle
def iload(filename, load_data=True):
from pyrocko import ims
try:
with open(filename, 'r') as f:
r = ims.Reader(f,
load_data=load_data,
version='GSE2.0',
dialect=None)
for sec in r:
if isinstance(sec, ims.WID2Section):
tr = sec.pyrocko_trace(checksum_error='warn')
yield tr
except (OSError, ims.DeserializeError), e:
fle = FileLoadError(e)
fle.set_context('filename', filename)
raise fle
def iload(filename, format='mseed', getdata=True, substitutions=None):
'''Load traces from file (iterator version).
This function works like :py:func:`load`, but returns an iterator which yields the loaded traces.
'''
load_data = getdata
toks = format.split('.', 1)
if len(toks) == 2:
format, subformat = toks
else:
subformat = None
try:
mtime = os.stat(filename)[8]
except OSError, e:
raise FileLoadError(e)
def _iload(filename, load_data=True, want=('traces', 'stations')):
try:
f = open(filename, 'rb')
while True:
tag = read_suds_struct(f, SudsStructtag, end_ok=True)
if tag is None:
break
if tag.struct_type in struct_classes:
cls = struct_classes[tag.struct_type]
if tag.struct_length != struct.calcsize(cls.fmt):
raise SudsError(
'expected and reported struct lengths differ')
s = read_suds_struct(f, cls)
if isinstance(s, SudsStationcomp) and 'stations' in want:
station = s.to_station()
yield station
if tag.data_length > 0:
if isinstance(s, SudsDescriptrace) and 'traces' in want:
if load_data:
data = f.read(tag.data_length)
if tag.data_length != len(data):
raise SudsError('premature end of file')
tr = s.to_trace(data)
else:
f.seek(tag.data_length, 1)
tr = s.to_trace(None)
yield tr
else:
f.seek(tag.data_length, 1)
else:
logger.warn('skipping unsupported SUDS struct type %s (%s)' % (
tag.struct_type, struct_names.get(tag.struct_type, '?')))
f.seek(tag.struct_length, 1)
if tag.data_length > 0:
f.seek(tag.data_length, 1)
except (OSError, SudsError) as e:
raise FileLoadError(e)
def detect_format(filename):
try:
f = open(filename, 'r')
data = f.read(512)
f.close()
except OSError, e:
raise FileLoadError(e)
format = None
for mod, fmt in ((yaff, 'yaff'), (mseed, 'mseed'), (sac, 'sac'),
(gse1, 'gse1'), (gse2_io_wrap, 'gse2'), (datacube,
'datacube')):
if mod.detect(data):
return fmt
raise FileLoadError(UnknownFormat(filename))
def iload(filename, format='mseed', getdata=True, substitutions=None):
'''Load traces from file (iterator version).
This function works like :py:func:`load`, but returns an iterator which yields the loaded traces.
'''
load_data = getdata
toks = format.split('.', 1)
if len(toks) == 2:
format, subformat = toks
else:
subformat = None
deltat = reuse(float(1.0) / float(tr[7]))
except ZeroDivisionError, e:
have_zero_rate_traces = True
continue
ydata = tr[8]
traces.append(
trace.Trace(network, station, location, channel, tmin, tmax,
deltat, ydata))
for tr in traces:
yield tr
except (OSError, mseed_ext.MSeedError), e:
raise FileLoadError(str(e) + ' (file: %s)' % filename)
if have_zero_rate_traces:
logger.warn('Ignoring traces with sampling rate of zero in file %s '
'(maybe LOG traces)' % filename)
def as_tuple(tr):
from pyrocko import mseed_ext
itmin = int(round(tr.tmin * mseed_ext.HPTMODULUS))
itmax = int(round(tr.tmax * mseed_ext.HPTMODULUS))
srate = 1.0 / tr.deltat
return (tr.network, tr.station, tr.location, tr.channel, itmin, itmax,
srate, tr.get_ydata())
def iload(filename, load_data, endianness='>'):
'''Read SEGY file.
filename -- Name of SEGY file.
load_data -- If True, the data is read, otherwise only read headers.
'''
endianness = endianness
nbth = 3200
nbbh = 400
nbthx = 3200
nbtrh = 240
try:
f = open(filename, 'rb')
textual_file_header = f.read(nbth)
if len(textual_file_header) != nbth:
raise SEGYError('incomplete textual file header')
binary_file_header = f.read(nbbh)
if len(binary_file_header) != nbbh:
raise SEGYError('incomplete binary file header')
line_number = struct.unpack(endianness+'1I', binary_file_header[4:8])
hvals = struct.unpack(endianness+'24H', binary_file_header[12:12+24*2])
(ntraces, nauxtraces, deltat_us, deltat_us_orig, nsamples,
nsamples_orig, format, ensemble_fold) = hvals[0:8]
(segy_revision, fixed_length_traces, nextended_headers) = \
struct.unpack(endianness+'3H', binary_file_header[100:100+3*2])
formats = {
1: (unpack_ibm_f4, 4, "4-byte IBM floating-point"),
2: (endianness+'i4', 4, "4-byte, two's complement integer"),
3: (endianness+'i4', 2, "2-byte, two's complement integer"),
4: (None, 4, "4-byte fixed-point with gain (obolete)"),
5: ('f4', 4, "4-byte IEEE floating-point"),
6: (None, 0, "not currently used"),
7: (None, 0, "not currently used"),
8: ('i1', 1, "1-byte, two's complement integer")}
dtype = formats[format][0]
sample_size = formats[format][1]
if dtype is None:
raise SEGYError('unsupported sample data format %i: %s' % (
format, formats[format][2]))
for ihead in xrange(nextended_headers):
f.read(nbthx)
atend = False
while not atend:
for itrace in xrange((ntraces+nauxtraces)):
trace_header = f.read(nbtrh)
if len(trace_header) == 0:
atend = True
break
if len(trace_header) != nbtrh:
raise SEGYError('incomplete trace header')
(scoordx, scoordy, gcoordx, gcoordy) = \
struct.unpack(endianness+'4f4', trace_header[72:72+4*4])
(ensemblex, ensembley) = \
struct.unpack(endianness+'2f4', trace_header[180:180+2*4])
(ensemble_num,) = \
struct.unpack(endianness+'1I', trace_header[20:24])
(trensemble_num,) = \
struct.unpack(endianness+'1I', trace_header[24:28])
(trace_number,) = \
struct.unpack(endianness+'1I', trace_header[0:4])
(trace_numbersegy,) = \
struct.unpack(endianness+'1I', trace_header[4:8])
(orfield_num,) = \
struct.unpack(endianness+'1I', trace_header[8:12])
(ortrace_num,) = \
struct.unpack(endianness+'1I', trace_header[12:16])
tvals = struct.unpack(
endianness+'12H', trace_header[94:94+12*2])
(nsamples_this, deltat_us_this) = tvals[-2:]
tscalar = struct.unpack(
endianness+'1H', trace_header[214:216])[0]
if tscalar == 0:
tscalar = 1.
elif tscalar < 0:
tscalar = 1.0 / tscalar
else:
tscalar = float(tscalar)
tvals = [x * tscalar for x in tvals[:-2]]
(year, doy, hour, minute, second) = \
struct.unpack(endianness+'5H', trace_header[156:156+2*5])
try:
if year < 100:
year += 2000
tmin = calendar.timegm(
(year, 1, doy, hour, minute, second))
except:
raise SEGYError('invalid start date/time')
if fixed_length_traces:
if (nsamples_this, deltat_us_this) \
!= (nsamples, deltat_us):
raise SEGYError(
'trace of incorrect length or sampling '
'rate (trace=%i)' % itrace+1)
if load_data:
datablock = f.read(nsamples_this*sample_size)
if len(datablock) != nsamples_this*sample_size:
raise SEGYError('incomplete trace data')
if isinstance(dtype, basestring):
data = num.fromstring(datablock, dtype=dtype)
else:
data = dtype(datablock)
tmax = None
else:
f.seek(nsamples_this*sample_size, 1)
tmax = tmin + deltat_us_this/1000000.*(nsamples_this-1)
data = None
tr = trace.Trace(
'',
'%05i' % (line_number),
'%02i' % (ensemble_num),
'%03i' % (ortrace_num),
tmin=tmin,
tmax=tmax,
deltat=deltat_us_this/1000000.,
ydata=data,
meta=dict(orfield_num=orfield_num))
yield tr
f.close()
except (OSError, SEGYError), e:
raise FileLoadError(e)
def read_header(f, endianness='>'):
e = endianness
data = read(f, 16, eof_ok=True)
isystem_id, istream_id = struct.unpack(e + 'II', data[:8])
ex = isystem_id & 0x80000000
if ex:
ex2 = isystem_id & (1 << 30)
if ex2:
system_id = util.base36encode(isystem_id & (2**21 - 1))
else:
system_id = util.base36encode(isystem_id & (2**26 - 1))
instrument_type = (isystem_id >> 26) & 0b1
gain = [None, 1, 2, 4, 8, 16, 32, 64][(isystem_id >> 27) & 0b111]
else:
system_id = util.base36encode(isystem_id)
instrument_type = None
gain = None
stream_id = util.base36encode(istream_id)
i_day_second = struct.unpack(e + 'I', data[8:12])[0]
iday = i_day_second >> 17
isecond = i_day_second & 0x1ffff
time = (iday * 24 * 60 * 60) + guralp_zero + isecond
ittl, israte, compression, nrecords = struct.unpack(e + 'BBBB', data[12:])
if nrecords > 250:
raise FileLoadError('Header indicates too many records in block.')
if israte == 0:
if compression == 4 and stream_id[-2:] == '00':
block_type = 'status_block'
elif compression == 4 and stream_id[-2:] == '01':
block_type = 'unified_status_block'
elif compression == 4 and stream_id[-2:] == 'SM':
block_type = 'strong_motion_block'
elif stream_id[-2:] == 'CD':
block_type = 'cd_status_block'
elif compression == 4 and stream_id[-2:] == 'BP':
block_type = 'byte_pipe_block'
elif stream_id[-2:] == 'IB':
block_type = 'information_block'
else:
raise FileLoadError('Unexpected block type found.')
return Header(block_type, system_id, stream_id, instrument_type, time,
gain, ittl, 0.0, compression, nrecords)
else:
block_type = 'data_block'
if not re.match(r'^([ZNEXC][0-9A-CG-S]|M[0-9A-F])$', stream_id[-2:]):
raise FileLoadError('Unexpected data stream ID')
sample_rate_tab = {
157: (0.1, None),
161: (0.125, None),
162: (0.2, None),
164: (0.25, None),
167: (0.5, None),
171: (400., 8),
174: (500., 2),
176: (1000., 4),
179: (2000., 8),
181: (4000., 16)
}
if israte in sample_rate_tab:
sample_rate, tfod = sample_rate_tab[israte]
else:
sample_rate = float(israte)
tfod = None
if tfod is not None:
toff = (compression >> 4) / tfod
compression = compression & 0b1111
time += toff
if compression not in (1, 2, 4):
raise GCFLoadError('Unsupported compression code: %i' %
compression)
return Header(block_type, system_id, stream_id, instrument_type, time,
gain, ittl, sample_rate, compression, nrecords)
deltat = reuse(float(1.0) / float(tr[7]))
except ZeroDivisionError, e:
have_zero_rate_traces = True
continue
ydata = tr[8]
traces.append(
trace.Trace(network, station, location, channel, tmin, tmax,
deltat, ydata))
for tr in traces:
yield tr
except (OSError, mseed_ext.MSeedError), e:
raise FileLoadError(str(e))
if have_zero_rate_traces:
logger.warn(
'Ignoring traces with sampling rate of zero in file %s (maybe LOG traces)'
% filename)
def as_tuple(tr):
from pyrocko import mseed_ext
itmin = int(round(tr.tmin * mseed_ext.HPTMODULUS))
itmax = int(round(tr.tmax * mseed_ext.HPTMODULUS))
srate = 1.0 / tr.deltat
return (tr.network, tr.station, tr.location, tr.channel, itmin, itmax,
srate, tr.get_ydata())
loc,
cha,
tmin=tmin,
tmax=tmax,
deltat=deltat,
ydata=data)
yield t
except util.UnpackError, e:
raise SeisanFileError(
'Error loading trace %i from file %s: %s' %
(itrace, filename, str(e)))
itrace += 1
except EOF:
pass
except (OSError, SeisanFileError), e:
raise FileLoadError(e)
finally:
f.close()
if __name__ == '__main__':
fn = sys.argv[1]
for tr in iload(fn):
print tr