Source code for obspy.io.rg16.core
"""
Receiver Gather (version 1.6-1) bindings to ObsPy core module.
"""
from __future__ import (absolute_import, division, print_function,
unicode_literals)
from future.builtins import * # NOQA
from collections import namedtuple
import numpy as np
from obspy.core import Stream, Trace, Stats, UTCDateTime
from obspy.io.rg16.util import _read, _open_file, _quick_merge
HeaderCount = namedtuple('HeaderCount', 'channel_set extended external')
@_open_file
[docs]def _read_rg16(filename, headonly=False, starttime=None, endtime=None,
merge=False, contacts_north=False, details=False, **kwargs):
"""
Read Fairfield Nodal's Receiver Gather File Format version 1.6-1.
.. warning::
This function should NOT be called directly, it registers via the
ObsPy :func:`~obspy.core.stream.read` function, call this instead.
:param filename: path to the rg16 file or a file object.
:type filename: str, buffer
:param headonly: If True don't read data, only main information
contained in the headers of the trace block is read.
:type headonly: optional, bool
:param starttime: If not None dont read traces that start before starttime.
:type starttime: optional, :class:`~obspy.core.utcdatetime.UTCDateTime`
:param endtime: If not None dont read traces that start after endtime.
:type endtime: optional, :class:`~obspy.core.utcdatetime.UTCDateTime`
:param merge: If True merge contiguous data blocks as they are found. For
continuous data files having 100,000+ traces this will create
more manageable streams.
:type merge: bool
:param contacts_north: If this parameter is set to True, it will map the
components to Z (1C, 3C), N (3C), and E (3C) as well as correct
the polarity for the vertical component.
:type contacts_north: bool
:param details: If True, all the information contained in the headers
is read).
:type details: bool
:return: An ObsPy :class:`~obspy.core.stream.Stream` object.
Frequencies are expressed in hertz and time is expressed in second
(except for date).
"""
starttime = starttime or UTCDateTime(1970, 1, 1)
endtime = endtime or UTCDateTime()
# get the number of headers/records, position of trace data
# and record length.
header_count = _cmp_nbr_headers(filename)
record_count = _cmp_nbr_records(filename)
trace_block_start = 32 * (2 + sum(header_count))
record_length = _cmp_record_length(filename)
# create trace data
traces = []
for i in range(0, record_count):
nbr_bytes_trace_block = _cmp_jump(filename, trace_block_start)
trace_starttime = _read(filename, trace_block_start + 20 + 2 * 32, 8,
'binary') / 1e6
trace_endtime = trace_starttime + record_length
con1 = starttime.timestamp > trace_endtime
con2 = endtime.timestamp < trace_starttime
# determine if this block is excluded based in starttime/endtime params
if con1 or con2:
# the block has to be excluded, increment trace_block_start
# and continue
trace_block_start += nbr_bytes_trace_block
continue
trace = _make_trace(filename, trace_block_start, headonly,
contacts_north, details)
traces.append(trace)
trace_block_start += nbr_bytes_trace_block
if merge:
traces = _quick_merge(traces)
return Stream(traces=traces)
[docs]def _cmp_nbr_headers(fi):
"""
Return a tuple containing the number of channel set headers,
the number of extended headers and the number of external headers
in the file.
"""
header_count = HeaderCount(
channel_set=_read(fi, 28, 1, 'bcd'),
extended=_read(fi, 37, 2, 'binary'),
external=_read(fi, 39, 3, 'binary'),
)
return header_count
[docs]def _cmp_nbr_records(fi):
"""
Return the number of records in the file (ie number of time slices
multiplied by the number of components).
"""
initial_header = _read_initial_headers(fi)
channel_sets_descriptor = initial_header['channel_sets_descriptor']
channels_number = set()
for _, val in channel_sets_descriptor.items():
channels_number.add(val['RU_channel_number'])
nbr_component = len(channels_number)
extended_header_2 = initial_header['extended_headers']['2']
nbr_time_slices = extended_header_2['nbr_time_slices']
nbr_records = nbr_time_slices * nbr_component
return nbr_records
[docs]def _cmp_record_length(fi):
"""
Return the record length.
"""
base_scan_interval = _read(fi, 22, 1, 'binary')
sampling_rate = int(1000 / (base_scan_interval / 16))
gen_head_2 = _read_initial_headers(fi)['general_header_2']
record_length = gen_head_2['extended_record_length'] - 1 / sampling_rate
return record_length
[docs]def _cmp_jump(fi, trace_block_start):
"""
Return the number of bytes in a trace block.
"""
nbr_trace_extension_block = _read(fi, trace_block_start + 9, 1, 'binary')
nbr_bytes_header_trace = 20 + 32 * nbr_trace_extension_block
nbr_sample_trace = _read(fi, trace_block_start + 27, 3, 'binary')
nbr_bytes_trace_data = nbr_sample_trace * 4
nbr_bytes_trace_block = nbr_bytes_trace_data + nbr_bytes_header_trace
return nbr_bytes_trace_block
[docs]def _make_trace(fi, trace_block_start, headonly, standard_orientation,
details):
"""
Make obspy trace from a trace block (header + trace).
"""
stats = _make_stats(fi, trace_block_start, standard_orientation, details)
if headonly:
data = np.array([])
else: # read trace
nbr_trace_extension_block = _read(fi, trace_block_start + 9,
1, 'binary')
trace_start = trace_block_start + 20 + nbr_trace_extension_block * 32
nbr_sample_trace = _read(fi, trace_block_start + 27, 3, 'binary')
nbr_bytes_trace = 4 * nbr_sample_trace
data = _read(fi, trace_start, nbr_bytes_trace, 'IEEE')
if stats.channel[-1] == 'Z':
data = -data
data = data.astype('>f4')
return Trace(data=data, header=stats)
[docs]def _make_stats(fi, tr_block_start, standard_orientation, details):
"""
Make Stats object from information contained in the header of the trace.
"""
base_scan_interval = _read(fi, 22, 1, 'binary')
sampling_rate = int(1000 / (base_scan_interval / 16))
# map sampling rate to band code according to seed standard
band_map = {2000: 'G', 1000: 'G', 500: 'D', 250: 'D'}
# geophone instrument code
instrument_code = 'P'
# mapping for "standard_orientation"
standard_component_map = {'2': 'Z', '3': 'N', '4': 'E'}
component = str(_read(fi, tr_block_start + 40, 1, 'binary'))
if standard_orientation:
component = standard_component_map[component]
chan = band_map[sampling_rate] + instrument_code + component
npts = _read(fi, tr_block_start + 27, 3, 'binary')
start_time = _read(fi, tr_block_start + 20 + 2 * 32, 8, 'binary') / 1e6
end_time = start_time + (npts - 1) * (1 / sampling_rate)
network = _read(fi, tr_block_start + 20, 3, 'binary')
station = _read(fi, tr_block_start + 23, 3, 'binary')
location = _read(fi, tr_block_start + 26, 1, 'binary')
statsdict = dict(starttime=UTCDateTime(start_time),
endtime=UTCDateTime(end_time),
sampling_rate=sampling_rate,
npts=npts,
network=str(network),
station=str(station),
location=str(location),
channel=chan)
if details:
statsdict['rg16'] = {}
statsdict['rg16']['initial_headers'] = {}
stats_initial_headers = statsdict['rg16']['initial_headers']
stats_initial_headers.update(_read_initial_headers(fi))
statsdict['rg16']['trace_headers'] = {}
stats_tr_headers = statsdict['rg16']['trace_headers']
stats_tr_headers.update(_read_trace_header(fi, tr_block_start))
nbr_tr_header_block = _read(fi, tr_block_start + 9,
1, 'binary')
if nbr_tr_header_block > 0:
stats_tr_headers.update(
_read_trace_headers(fi, tr_block_start, nbr_tr_header_block))
return Stats(statsdict)
[docs]def _read_trace_headers(fi, trace_block_start, nbr_trace_header):
"""
Read headers in the trace block.
"""
trace_headers = {}
dict_func = {'1': _read_trace_header_1, '2': _read_trace_header_2,
'3': _read_trace_header_3, '4': _read_trace_header_4,
'5': _read_trace_header_5, '6': _read_trace_header_6,
'7': _read_trace_header_7, '8': _read_trace_header_8,
'9': _read_trace_header_9, '10': _read_trace_header_10}
for i in range(1, nbr_trace_header + 1):
trace_headers.update(dict_func[str(i)](fi, trace_block_start))
return trace_headers
[docs]def _read_trace_header(fi, trace_block_start):
"""
Read the 20 bytes trace header (first header in the trace block).
"""
trace_number = _read(fi, trace_block_start + 4, 2, 'bcd')
trace_edit_code = _read(fi, trace_block_start + 11, 1, 'binary')
return {'trace_number': trace_number, 'trace_edit_code': trace_edit_code}
[docs]def _read_trace_header_1(fi, trace_block_start):
"""
Read trace header 1
"""
pos = trace_block_start + 20
dict_header_1 = dict(
extended_receiver_line_nbr=_read(fi, pos + 10, 5, 'binary'),
extended_receiver_point_nbr=_read(fi, pos + 15, 5, 'binary'),
sensor_type=_read(fi, pos + 20, 1, 'binary'),
trace_count_file=_read(fi, pos + 21, 4, 'binary'),
)
return dict_header_1
[docs]def _read_trace_header_2(fi, trace_block_start):
"""
Read trace header 2
"""
pos = trace_block_start + 20 + 32
leg_source_info = {'0': 'undefined', '1': 'preplan', '2': 'as shot',
'3': 'post processed'}
source_key = str(_read(fi, pos + 29, 1, 'binary'))
leg_energy_source = {'0': 'undefined', '1': 'vibroseis', '2': 'dynamite',
'3': 'air gun'}
energy_source_key = str(_read(fi, pos + 30, 1, 'binary'))
dict_header_2 = dict(
shot_line_nbr=_read(fi, pos, 4, 'binary'),
shot_point=_read(fi, pos + 4, 4, 'binary'),
shot_point_index=_read(fi, pos + 8, 1, 'binary'),
shot_point_pre_plan_x=_read(fi, pos + 9, 4, 'binary') / 10,
shot_point_pre_plan_y=_read(fi, pos + 13, 4, 'binary') / 10,
shot_point_final_x=_read(fi, pos + 17, 4, 'binary') / 10,
shot_point_final_y=_read(fi, pos + 21, 4, 'binary') / 10,
shot_point_final_depth=_read(fi, pos + 25, 4, 'binary') / 10,
source_of_final_shot_info=leg_source_info[source_key],
energy_source_type=leg_energy_source[energy_source_key],
)
return dict_header_2
[docs]def _read_trace_header_3(fi, trace_block_start):
"""
Read trace header 3
"""
pos = trace_block_start + 20 + 32 * 2
dict_header_3 = dict(
epoch_time=UTCDateTime(_read(fi, pos, 8, 'binary') / 1e6),
# shot skew time in second
shot_skew_time=_read(fi, pos + 8, 8, 'binary') / 1e6,
# time shift clock correction in second
time_shift_clock_correction=_read(fi, pos + 16, 8, 'binary') / 1e9,
# remaining clock correction in second
remaining_clock_correction=_read(fi, pos + 24, 8, 'binary') / 1e9,
)
return dict_header_3
[docs]def _read_trace_header_4(fi, trace_block_start):
"""
Read trace header 4
"""
pos = trace_block_start + 20 + 32 * 3
leg_trace_clipped = {'0': 'not clipped', '1': 'digital clip detected',
'2': 'analog clip detected'}
clipped_code = str(_read(fi, pos + 9, 1, 'binary'))
leg_record_type = {'2': 'test data record',
'8': 'normal seismic data record'}
record_type_code = str(_read(fi, pos + 10, 1, 'binary'))
leg_shot_flag = {'0': 'normal', '1': 'bad-operator specified',
'2': 'bad-failed to QC test'}
shot_code = str(_read(fi, pos + 11, 1, 'binary'))
dict_header_4 = dict(
# pre shot guard band in second
pre_shot_guard_band=_read(fi, pos, 4, 'binary') / 1e3,
# post shot guard band in second
post_shot_guard_band=_read(fi, pos + 4, 4, 'binary') / 1e3,
# preamp gain in dB
preamp_gain=_read(fi, pos + 8, 1, 'binary'),
trace_clipped_flag=leg_trace_clipped[clipped_code],
record_type_code=leg_record_type[record_type_code],
shot_status_flag=leg_shot_flag[shot_code],
external_shot_id=_read(fi, pos + 12, 4, 'binary'),
post_processed_first_break_pick_time=_read(fi, pos + 24, 4, 'IEEE'),
post_processed_rms_noise=_read(fi, pos + 28, 4, 'IEEE'),
)
return dict_header_4
[docs]def _read_trace_header_5(fi, trace_block_start):
"""
Read trace header 5
"""
pos = trace_block_start + 20 + 32 * 4
leg_source_receiver_info = {
'1': 'preplan',
'2': 'as laid (no navigation sensor)',
'3': 'as laid (HiPAP only)',
'4': 'as laid (HiPAP and INS)',
'5': 'as laid (HiPAP and DVL)',
'6': 'as laid (HiPAP, DVL and INS)',
'7': 'post processed (HiPAP only)',
'8': 'post processed (HiPAP and INS)',
'9': 'post processed (HiPAP and DVL)',
'10': 'post processed (HiPAP, DVL ans INS)',
'11': 'first break analysis',
}
source_key = str(_read(fi, pos + 29, 1, 'binary'))
dict_header_5 = dict(
receiver_point_pre_plan_x=_read(fi, pos + 9, 4, 'binary') / 10,
receiver_point_pre_plan_y=_read(fi, pos + 13, 4, 'binary') / 10,
receiver_point_final_x=_read(fi, pos + 17, 4, 'binary') / 10,
receiver_point_final_y=_read(fi, pos + 21, 4, 'binary') / 10,
receiver_point_final_depth=_read(fi, pos + 25, 4, 'binary') / 10,
source_of_final_receiver_info=leg_source_receiver_info[source_key],
)
return dict_header_5
[docs]def _read_trace_header_6(fi, trace_block_start):
"""
Read trace header 6
"""
pos = trace_block_start + 20 + 32 * 5
dict_header_6 = dict(
tilt_matrix_h1x=_read(fi, pos, 4, 'IEEE'),
tilt_matrix_h2x=_read(fi, pos + 4, 4, 'IEEE'),
tilt_matrix_vx=_read(fi, pos + 8, 4, 'IEEE'),
tilt_matrix_h1y=_read(fi, pos + 12, 4, 'IEEE'),
tilt_matrix_h2y=_read(fi, pos + 16, 4, 'IEEE'),
tilt_matrix_vy=_read(fi, pos + 20, 4, 'IEEE'),
tilt_matrix_h1z=_read(fi, pos + 24, 4, 'IEEE'),
tilt_matrix_h2z=_read(fi, pos + 28, 4, 'IEEE'),
)
return dict_header_6
[docs]def _read_trace_header_7(fi, trace_block_start):
"""
Read trace header 7
"""
pos = trace_block_start + 20 + 32 * 6
dict_header_7 = dict(
tilt_matrix_vz=_read(fi, pos, 4, 'IEEE'),
azimuth_degree=_read(fi, pos + 4, 4, 'IEEE'),
pitch_degree=_read(fi, pos + 8, 4, 'IEEE'),
roll_degree=_read(fi, pos + 12, 4, 'IEEE'),
remote_unit_temp=_read(fi, pos + 16, 4, 'IEEE'),
remote_unit_humidity=_read(fi, pos + 20, 4, 'IEEE'),
orientation_matrix_version_nbr=_read(fi, pos + 24, 4, 'binary'),
gimbal_corrections=_read(fi, pos + 28, 1, 'binary'))
return dict_header_7
[docs]def _read_trace_header_8(fi, trace_block_start):
"""
Read trace header 8
"""
pos = trace_block_start + 20 + 32 * 7
leg_preamp_path = {
'0': 'external input selected',
'1': 'simulated data selected',
'2': 'pre-amp input shorted to ground',
'3': 'test oscillator with sensors',
'4': 'test oscillator without sensors',
'5': 'common mode test oscillator with sensors',
'6': 'common mode test oscillator without sensors',
'7': 'test oscillator on positive sensors with neg sensor grounded',
'8': 'test oscillator on negative sensors with pos sensor grounded',
'9': 'test oscillator on positive PA input with neg PA input ground',
'10': 'test oscillator on negative PA input with pos PA input ground',
'11': 'test oscillator on positive PA input with neg\
PA input ground, no sensors',
'12': 'test oscillator on negative PA input with pos\
PA input ground, no sensors'}
preamp_path_code = str(_read(fi, pos + 24, 4, 'binary'))
leg_test_oscillator = {'0': 'test oscillator path open',
'1': 'test signal selected',
'2': 'DC reference selected',
'3': 'test oscillator path grounded',
'4': 'DC reference toggle selected'}
oscillator_code = str(_read(fi, pos + 28, 4, 'binary'))
dict_header_8 = dict(
fairfield_test_analysis_code=_read(fi, pos, 4, 'binary'),
first_test_oscillator_attenuation=_read(fi, pos + 4, 4, 'binary'),
second_test_oscillator_attenuation=_read(fi, pos + 8, 4, 'binary'),
# start delay in second
start_delay=_read(fi, pos + 12, 4, 'binary') / 1e6,
dc_filter_flag=_read(fi, pos + 16, 4, 'binary'),
dc_filter_frequency=_read(fi, pos + 20, 4, 'IEEE'),
preamp_path=leg_preamp_path[preamp_path_code],
test_oscillator_signal_type=leg_test_oscillator[oscillator_code],
)
return dict_header_8
[docs]def _read_trace_header_9(fi, trace_block_start):
"""
Read trace header 9
"""
pos = trace_block_start + 20 + 32 * 8
leg_signal_type = {'0': 'pattern is address ramp',
'1': 'pattern is RU address ramp',
'2': 'pattern is built from provided values',
'3': 'pattern is random numbers',
'4': 'pattern is a walking 1s',
'5': 'pattern is a walking 0s',
'6': 'test signal is a specified DC value',
'7': 'test signal is a pulse train with\
specified duty cycle',
'8': 'test signal is a sine wave',
'9': 'test signal is a dual tone sine',
'10': 'test signal is an impulse',
'11': 'test signal is a step function'}
type_code = str(_read(fi, pos, 4, 'binary'))
# test signal generator frequency 1 in hertz
test_signal_freq_1 = _read(fi, pos + 4, 4, 'binary') / 1e3
# test signal generator frequency 2 in hertz
test_signal_freq_2 = _read(fi, pos + 8, 4, 'binary') / 1e3
# test signal generator amplitude 1 in dB down from full scale -120 to 120
test_signal_amp_1 = _read(fi, pos + 12, 4, 'binary')
# test signal generator amplitude 2 in dB down from full scale -120 to 120
test_signal_amp_2 = _read(fi, pos + 16, 4, 'binary')
# test signal generator duty cycle in percentage
duty_cycle = _read(fi, pos + 20, 4, 'IEEE')
# test signal generator active duration in second
active_duration = _read(fi, pos + 24, 4, 'binary') / 1e6
# test signal generator activation time in second
activation_time = _read(fi, pos + 28, 4, 'binary') / 1e6
dict_header_9 = dict(
test_signal_generator_signal_type=leg_signal_type[type_code],
test_signal_generator_frequency_1=test_signal_freq_1,
test_signal_generator_frequency_2=test_signal_freq_2,
test_signal_generator_amplitude_1=test_signal_amp_1,
test_signal_generator_amplitude_2=test_signal_amp_2,
test_signal_generator_duty_cycle_percentage=duty_cycle,
test_signal_generator_active_duration=active_duration,
test_signal_generator_activation_time=activation_time,
)
return dict_header_9
[docs]def _read_trace_header_10(fi, trace_block_start):
"""
Read trace header 10
"""
pos = trace_block_start + 20 + 32 * 9
dict_header_10 = dict(
test_signal_generator_idle_level=_read(fi, pos, 4, 'binary'),
test_signal_generator_active_level=_read(fi, pos + 4, 4, 'binary'),
test_signal_generator_pattern_1=_read(fi, pos + 8, 4, 'binary'),
test_signal_generator_pattern_2=_read(fi, pos + 12, 4, 'binary'),
)
return dict_header_10
@_open_file
[docs]def _is_rg16(filename, **kwargs):
"""
Determine if a file is a rg16 file.
:param filename: a path to a file or a file object
:type filename: str, buffer
:rtype: bool
:return: True if the file object is a rg16 file.
"""
try:
sample_format = _read(filename, 2, 2, 'bcd')
manufacturer_code = _read(filename, 16, 1, 'bcd')
version = _read(filename, 42, 2, 'binary')
except ValueError: # if file too small
return False
con1 = version == 262 and sample_format == 8058
return con1 and manufacturer_code == 20
@_open_file
[docs]def _read_initial_headers(filename):
"""
Extract all the information contained in the headers located before data,
at the beginning of the rg16 file object.
:param filename : a path to a rg16 file or a rg16 file object.
:type filename: str, buffer
:return: a dictionnary containing all the information of the initial
headers
Frequencies are expressed in hertz and time is expressed in second
(except for the date).
"""
headers_content = dict(
general_header_1=_read_general_header_1(filename),
general_header_2=_read_general_header_2(filename),
channel_sets_descriptor=_read_channel_sets(filename),
extended_headers=_read_extended_headers(filename),
)
return headers_content
[docs]def _read_general_header_1(fi):
"""
Extract information contained in the general header block 1
"""
gen_head_1 = dict(
file_number=_read(fi, 0, 2, 'bcd'),
sample_format_code=_read(fi, 2, 2, 'bcd'),
general_constant=_read(fi, 4, 6, 'bcd'),
time_slice_year=_read(fi, 10, 1, 'bcd'),
nbr_add_general_header=_read(fi, 11, 0.5, 'bcd'),
julian_day=_read(fi, 11, 1.5, 'bcd', False),
time_slice=_read(fi, 13, 3, 'bcd'),
manufacturer_code=_read(fi, 16, 1, 'bcd'),
manufacturer_serial_number=_read(fi, 17, 2, 'bcd'),
base_scan_interval=_read(fi, 22, 1, 'binary'),
polarity_code=_read(fi, 23, 0.5, 'binary'),
record_type=_read(fi, 25, 0.5, 'binary'),
scan_type_per_record=_read(fi, 27, 1, 'bcd'),
nbr_channel_set=_read(fi, 28, 1, 'bcd'),
nbr_skew_block=_read(fi, 29, 1, 'bcd'),
)
return gen_head_1
[docs]def _read_general_header_2(fi):
"""
Extract information contained in the general header block 2
"""
gen_head_2 = dict(
extended_file_number=_read(fi, 32, 3, 'binary'),
extended_channel_sets_per_scan_type=_read(fi, 35, 2, 'binary'),
extended_header_blocks=_read(fi, 37, 2, 'binary'),
external_header_blocks=_read(fi, 39, 3, 'binary'),
version_number=_read(fi, 42, 2, 'binary'),
# extended record length in second
extended_record_length=_read(fi, 46, 3, 'binary') / 1e3,
general_header_block_number=_read(fi, 50, 1, 'binary'),
)
return gen_head_2
[docs]def _read_channel_sets(fi):
"""
Extract information of all channel set descriptor blocks.
"""
channel_sets = {}
nbr_channel_set = _read(fi, 28, 1, 'bcd')
start_byte = 64
for i in range(0, nbr_channel_set):
channel_set_name = str(i + 1)
channel_sets[channel_set_name] = _read_channel_set(fi, start_byte)
start_byte += 32
return channel_sets
[docs]def _read_channel_set(fi, start_byte):
"""
Extract information contained in the ith channel set descriptor.
"""
nbr_32_ext = _read(fi, start_byte + 28, 0.5, 'binary', False)
channel_set = dict(
scan_type_number=_read(fi, start_byte, 1, 'bcd'),
channel_set_number=_read(fi, start_byte + 1, 1, 'bcd'),
channel_set_start_time=_read(fi, start_byte + 2, 2, 'binary') * 2e-3,
channel_set_end_time=_read(fi, start_byte + 4, 2, 'binary') * 2e-3,
optionnal_MP_factor=_read(fi, start_byte + 6, 1, 'binary'),
mp_factor_descaler_multiplier=_read(fi, start_byte + 7, 1, 'binary'),
nbr_channels_in_channel_set=_read(fi, start_byte + 8, 2, 'bcd'),
channel_type_code=_read(fi, start_byte + 10, 0.5, 'binary'),
nbr_sub_scans=_read(fi, start_byte + 11, 0.5, 'bcd'),
gain_control_type=_read(fi, start_byte + 11, 0.5, 'bcd', False),
alias_filter_frequency=_read(fi, start_byte + 12, 2, 'bcd'),
alias_filter_slope=_read(fi, start_byte + 14, 2, 'bcd'),
low_cut_filter_freq=_read(fi, start_byte + 16, 2, 'bcd'),
low_cut_filter_slope=_read(fi, start_byte + 18, 2, 'bcd'),
notch_filter_freq=_read(fi, start_byte + 20, 2, 'bcd') / 10,
notch_2_filter_freq=_read(fi, start_byte + 22, 2, 'bcd') / 10,
notch_3_filter_freq=_read(fi, start_byte + 24, 2, 'bcd') / 10,
extended_channel_set_number=_read(fi, start_byte + 26, 2, 'binary'),
extended_header_flag=_read(fi, start_byte + 28, 0.5, 'binary'),
nbr_32_byte_trace_header_extension=nbr_32_ext,
vertical_stack_size=_read(fi, start_byte + 29, 1, 'binary'),
RU_channel_number=_read(fi, start_byte + 30, 1, 'binary'),
array_forming=_read(fi, start_byte + 31, 1, 'binary'),
)
return channel_set
[docs]def _read_extended_headers(fi):
"""
Extract information from the extended headers.
"""
extended_headers = {}
nbr_channel_set = _read(fi, 28, 1, 'bcd')
start_byte = 32 + 32 + 32 * nbr_channel_set
extended_headers['1'] = _read_extended_header_1(fi, start_byte)
start_byte += 32
extended_headers['2'] = _read_extended_header_2(fi, start_byte)
start_byte += 32
extended_headers['3'] = _read_extended_header_3(fi, start_byte)
nbr_extended_headers = _read(fi, 37, 2, 'binary', True)
if nbr_extended_headers > 3:
coeffs = extended_headers['2']['number_decimation_filter_coefficient']
nbr_coeff_remain = coeffs % 8
for i in range(3, nbr_extended_headers):
start_byte += 32
extended_header_name = str(i + 1)
if i == nbr_extended_headers - 1:
header = _read_extended_header(fi, start_byte, i + 1,
nbr_coeff_remain)
extended_headers[extended_header_name] = header
else:
header = _read_extended_header(fi, start_byte, i + 1, 8)
extended_headers[extended_header_name] = header
return extended_headers
[docs]def _read_extended_header_1(fi, start_byte):
"""
Extract information contained in the extended header block number 1.
"""
deployment_time = _read(fi, start_byte + 8, 8, 'binary') / 1e6
pick_up_time = _read(fi, start_byte + 16, 8, 'binary') / 1e6
start_time_ru = _read(fi, start_byte + 24, 8, 'binary') / 1e6
extended_header_1 = dict(
id_ru=_read(fi, start_byte, 8, 'binary'),
deployment_time=UTCDateTime(deployment_time),
pick_up_time=UTCDateTime(pick_up_time),
start_time_ru=UTCDateTime(start_time_ru),
)
return extended_header_1
[docs]def _read_extended_header_2(fi, start_byte):
"""
Extract information contained in the extended header block number 2.
"""
# code mappings to meaning
leg_clock_stop = {'0': 'normal', '1': 'storage full', '2': 'power loss',
'3': 'reboot'}
stop_code = str(_read(fi, start_byte + 12, 1, 'binary'))
leg_freq_drift = {'0': 'not within specification',
'1': 'within specification'}
drift_code = str(_read(fi, start_byte + 13, 1, 'binary'))
leg_oscillator_type = {'0': 'control board', '1': 'atomic',
'2': 'ovenized', '3': 'double ovenized',
'4': 'disciplined'}
oscillator_code = str(_read(fi, start_byte + 14, 1, 'binary'))
leg_data_collection = {'0': 'normal', '1': 'continuous',
'2': 'shot sliced with guard band'}
data_collection_code = str(_read(fi, start_byte + 15, 1, 'binary'))
leg_data_decimation = {'0': 'not decimated', '1': 'decimated data'}
decimation_code = str(_read(fi, start_byte + 28, 1, 'binary'))
extended_header_2 = dict(
acquisition_drift_window=_read(fi, start_byte, 4, 'IEEE') * 1e-6,
clock_drift=_read(fi, start_byte + 4, 8, 'binary') * 1e-9,
clock_stop_method=leg_clock_stop[stop_code],
frequency_drift=leg_freq_drift[drift_code],
oscillator_type=leg_oscillator_type[oscillator_code],
data_collection_method=leg_data_collection[data_collection_code],
nbr_time_slices=_read(fi, start_byte + 16, 4, 'binary'),
nbr_files=_read(fi, start_byte + 20, 4, 'binary'),
file_number=_read(fi, start_byte + 24, 4, 'binary'),
data_decimation=leg_data_decimation[decimation_code],
original_base_scan_interval=_read(fi, start_byte + 29, 1, 'binary'),
nbr_decimation_filter_coef=_read(fi, start_byte + 30, 2, 'binary'),
)
return extended_header_2
[docs]def _read_extended_header_3(fi, start_byte):
"""
Extract information contained in the extended header block number 3.
"""
extended_header_3 = dict(
receiver_line_number=_read(fi, start_byte, 4, 'binary'),
receiver_point=_read(fi, start_byte + 4, 4, 'binary'),
receiver_point_index=_read(fi, start_byte + 8, 1, 'binary'),
first_shot_line=_read(fi, start_byte + 9, 4, 'binary'),
first_shot_point=_read(fi, start_byte + 13, 4, 'binary'),
first_shot_point_index=_read(fi, start_byte + 17, 1, 'binary'),
last_shot_line=_read(fi, start_byte + 18, 4, 'binary'),
last_shot_point=_read(fi, start_byte + 22, 4, 'binary'),
last_shot_point_index=_read(fi, start_byte + 26, 1, 'binary'),
)
return extended_header_3
[docs]def _read_extended_header(fi, start_byte, block_number, nbr_coeff):
"""
Extract information contained in the ith extended header block (i>3).
"""
extended_header = {}
for i in range(0, nbr_coeff):
key = 'coeff_' + str(i + 1)
extended_header[key] = _read(fi, start_byte, 4, 'IEEE')
start_byte += 4
return extended_header
if __name__ == '__main__':
import doctest
doctest.testmod(exclude_empty=True)