def test_fread_trace0(self, mmap=False):
f = _segyio.open(self.filename, "r")
if mmap: _segyio.mmap(f)
binary_header = _segyio.read_binaryheader(f)
ilb = 189
xlb = 193
metrics = _segyio.init_metrics(f, binary_header)
metrics.update(
_segyio.init_cube_metrics(f, ilb, xlb, metrics['trace_count'],
metrics['trace0'],
metrics['trace_bsize']))
sorting = metrics['sorting']
trace_count = metrics['trace_count']
inline_count = metrics['iline_count']
crossline_count = metrics['xline_count']
offset_count = metrics['offset_count']
line_metrics = _segyio.init_line_metrics(sorting, trace_count,
inline_count, crossline_count,
offset_count)
iline_indexes = numpy.zeros(metrics['iline_count'], dtype=numpy.intc)
xline_indexes = numpy.zeros(metrics['xline_count'], dtype=numpy.intc)
offsets = numpy.zeros(metrics['offset_count'], dtype=numpy.intc)
_segyio.init_indices(f, metrics, iline_indexes, xline_indexes, offsets)
with self.assertRaises(KeyError):
_segyio.fread_trace0(0, len(xline_indexes),
line_metrics['iline_stride'], offset_count,
iline_indexes, "inline")
with self.assertRaises(KeyError):
_segyio.fread_trace0(2, len(iline_indexes),
line_metrics['xline_stride'], offset_count,
xline_indexes, "crossline")
value = _segyio.fread_trace0(1, len(xline_indexes),
line_metrics['iline_stride'],
offset_count, iline_indexes, "inline")
self.assertEqual(value, 0)
value = _segyio.fread_trace0(2, len(xline_indexes),
line_metrics['iline_stride'],
offset_count, iline_indexes, "inline")
self.assertEqual(value, 5)
value = _segyio.fread_trace0(21, len(iline_indexes),
line_metrics['xline_stride'],
offset_count, xline_indexes, "crossline")
self.assertEqual(value, 1)
value = _segyio.fread_trace0(22, len(iline_indexes),
line_metrics['xline_stride'],
offset_count, xline_indexes, "crossline")
self.assertEqual(value, 2)
_segyio.close(f)
def read_small(self, mmap=False):
f = _segyio.open(self.filename, "r")
if mmap: _segyio.mmap(f)
binary_header = _segyio.read_binaryheader(f)
ilb = 189
xlb = 193
metrics = _segyio.init_metrics(f, binary_header)
metrics.update(
_segyio.init_cube_metrics(f, ilb, xlb, metrics['trace_count'],
metrics['trace0'],
metrics['trace_bsize']))
sorting = metrics['sorting']
trace_count = metrics['trace_count']
inline_count = metrics['iline_count']
crossline_count = metrics['xline_count']
offset_count = metrics['offset_count']
line_metrics = _segyio.init_line_metrics(sorting, trace_count,
inline_count, crossline_count,
offset_count)
metrics.update(line_metrics)
iline_indexes = numpy.zeros(metrics['iline_count'], dtype=numpy.intc)
xline_indexes = numpy.zeros(metrics['xline_count'], dtype=numpy.intc)
offsets = numpy.zeros(metrics['offset_count'], dtype=numpy.intc)
_segyio.init_indices(f, metrics, iline_indexes, xline_indexes, offsets)
return f, metrics, iline_indexes, xline_indexes
def test_read_and_write_trace(self, mmap=False):
with TestContext("read_and_write_trace") as context:
f = _segyio.open("trace-wrt.sgy", "w+")
if mmap: _segyio.mmap(f)
buf = numpy.ones(25, dtype=numpy.single)
buf[11] = 3.1415
_segyio.write_trace(f, 0, buf, 0, 100, 1, 25)
buf[:] = 42.0
_segyio.write_trace(f, 1, buf, 0, 100, 1, 25)
_segyio.flush(f)
buf = numpy.zeros(25, dtype=numpy.single)
_segyio.read_trace(f, buf, 0, 1, 1, 1, 25, 0, 100)
self.assertAlmostEqual(buf[10], 1.0, places=4)
self.assertAlmostEqual(buf[11], 3.1415, places=4)
_segyio.read_trace(f, buf, 1, 1, 1, 1, 25, 0, 100)
self.assertAlmostEqual(sum(buf), 42.0 * 25, places=4)
_segyio.close(f)
def test_indices(self, mmap=False):
f = _segyio.open(self.filename, "r")
if mmap: _segyio.mmap(f)
binary_header = _segyio.read_binaryheader(f)
ilb = 189
xlb = 193
metrics = _segyio.init_metrics(f, binary_header)
dmy = numpy.zeros(2, dtype=numpy.intc)
dummy_metrics = {'xline_count': 2, 'iline_count': 2, 'offset_count': 1}
with self.assertRaises(TypeError):
_segyio.init_indices(".", {}, dmy, dmy, dmy)
with self.assertRaises(TypeError):
_segyio.init_indices(f, "-", dmy, dmy, dmy)
# with self.assertRaises(KeyError):
# _segyio.init_indices(f, {}, dmy, dmy, dmy)
with self.assertRaises(TypeError):
_segyio.init_indices(f, dummy_metrics, 1, dmy, dmy)
with self.assertRaises(TypeError):
_segyio.init_indices(f, dummy_metrics, dmy, 2, dmy)
with self.assertRaises(TypeError):
_segyio.init_indices(f, dummy_metrics, dmy, dmy, 2)
with self.assertRaises(TypeError):
fdmy = numpy.zeros(1, dtype=numpy.single)
_segyio.init_indices(f, dummy_metrics, fdmy, dmy, dmy)
one = numpy.zeros(1, dtype=numpy.intc)
two = numpy.zeros(2, dtype=numpy.intc)
off = numpy.zeros(1, dtype=numpy.intc)
with self.assertRaises(ValueError):
_segyio.init_indices(f, dummy_metrics, one, two, off)
with self.assertRaises(ValueError):
_segyio.init_indices(f, dummy_metrics, two, one, off)
metrics.update(
_segyio.init_cube_metrics(f, ilb, xlb, metrics['trace_count'],
metrics['trace0'],
metrics['trace_bsize']))
# Happy Path
iline_indexes = numpy.zeros(metrics['iline_count'], dtype=numpy.intc)
xline_indexes = numpy.zeros(metrics['xline_count'], dtype=numpy.intc)
offsets = numpy.zeros(metrics['offset_count'], dtype=numpy.intc)
_segyio.init_indices(f, metrics, iline_indexes, xline_indexes, offsets)
self.assertListEqual([1, 2, 3, 4, 5], list(iline_indexes))
self.assertListEqual([20, 21, 22, 23, 24], list(xline_indexes))
self.assertListEqual([1], list(offsets))
_segyio.close(f)
def test_read_text_header(self, mmap=False):
f = _segyio.open(self.filename, "r")
if mmap: _segyio.mmap(f)
self.assertEqual(_segyio.read_textheader(f, 0),
self.ACTUAL_TEXT_HEADER)
with self.assertRaises(Exception):
_segyio.read_texthdr(None, 0)
_segyio.close(f)
def test_read_and_write_traceheader(self, mmap=False):
with TestContext("read_and_write_trace_header") as context:
context.copy_file(self.filename)
f = _segyio.open("small.sgy", "r+")
if mmap: _segyio.mmap(f)
binary_header = _segyio.read_binaryheader(f)
ilb = 189
xlb = 193
metrics = _segyio.init_metrics(f, binary_header)
empty = _segyio.empty_traceheader()
with self.assertRaises(TypeError):
trace_header = _segyio.read_traceheader("+", )
with self.assertRaises(TypeError):
trace_header = _segyio.read_traceheader(f, 0, None)
trace_header = _segyio.read_traceheader(
f, 0, _segyio.empty_traceheader(), metrics['trace0'],
metrics['trace_bsize'])
self.assertEqual(_segyio.get_field(trace_header, ilb), 1)
self.assertEqual(_segyio.get_field(trace_header, xlb), 20)
trace_header = _segyio.read_traceheader(
f, 1, _segyio.empty_traceheader(), metrics['trace0'],
metrics['trace_bsize'])
self.assertEqual(_segyio.get_field(trace_header, ilb), 1)
self.assertEqual(_segyio.get_field(trace_header, xlb), 21)
_segyio.set_field(trace_header, ilb, 99)
_segyio.set_field(trace_header, xlb, 42)
_segyio.write_traceheader(f, 0, trace_header, metrics['trace0'],
metrics['trace_bsize'])
trace_header = _segyio.read_traceheader(
f, 0, _segyio.empty_traceheader(), metrics['trace0'],
metrics['trace_bsize'])
self.assertEqual(_segyio.get_field(trace_header, ilb), 99)
self.assertEqual(_segyio.get_field(trace_header, xlb), 42)
_segyio.close(f)
def mmap(self):
"""Memory map the file
:rtype: bool
Since v1.1
Memory map the file. This is an advanced feature for speed and
optimization; however, it is no silver bullet. If your file is smaller
than the memory available on your system this will likely result in
faster reads and writes, especially for line modes. However, if the
file is very large, or memory is very pressured, this optimization
might cause overall system slowdowns. However, if you're opening the
same file from many different instances of segyio then memory mapping
may significantly reduce the memory pressure.
If this call returns true, the file is memory mapped. If memory mapping
was build-time disabled or is not available for your platform this call
always return false. If the memory mapping is unsuccessful you can keep
using segyio - reading and writing falls back on non-memory mapped
features.
Examples:
Memory map::
>>> mapped = f.mmap()
>>> if mapped: print( "File is memory mapped!" )
>>> # keep using segyio as per usual
>>> print( f.trace[10] )
"""
return _segyio.mmap(self.xfd)
def test_read_binary_header_fields(self, mmap=False):
f = _segyio.open(self.filename, "r")
if mmap: _segyio.mmap(f)
binary_header = _segyio.read_binaryheader(f)
with self.assertRaises(TypeError):
value = _segyio.get_field("s", 0)
with self.assertRaises(IndexError):
value = _segyio.get_field(binary_header, -1)
self.assertEqual(_segyio.get_field(binary_header, 3225), 1)
self.assertEqual(_segyio.get_field(binary_header, 3221), 50)
_segyio.close(f)
def test_metrics(self, mmap=False):
f = _segyio.open(self.filename, "r")
if mmap: _segyio.mmap(f)
binary_header = _segyio.read_binaryheader(f)
ilb = 189
xlb = 193
with self.assertRaises(TypeError):
metrics = _segyio.init_metrics("?", binary_header)
with self.assertRaises(TypeError):
metrics = _segyio.init_metrics(f, "?")
with self.assertRaises(IndexError):
metrics = _segyio.init_metrics(f, binary_header)
metrics.update(
_segyio.init_cube_metrics(f, ilb + 1, xlb,
metrics['trace_count'],
metrics['trace0'],
metrics['trace_bsize']))
metrics = _segyio.init_metrics(f, binary_header)
metrics.update(
_segyio.init_cube_metrics(f, ilb, xlb, metrics['trace_count'],
metrics['trace0'],
metrics['trace_bsize']))
self.assertEqual(metrics['trace0'],
_segyio.textheader_size() + _segyio.binheader_size())
self.assertEqual(metrics['sample_count'], 50)
self.assertEqual(metrics['format'], 1)
self.assertEqual(metrics['trace_bsize'], 200)
self.assertEqual(metrics['sorting'],
2) # inline sorting = 2, crossline sorting = 1
self.assertEqual(metrics['trace_count'], 25)
self.assertEqual(metrics['offset_count'], 1)
self.assertEqual(metrics['iline_count'], 5)
self.assertEqual(metrics['xline_count'], 5)
_segyio.close(f)
with self.assertRaises(IOError):
metrics = _segyio.init_metrics(f, binary_header)
def test_line_metrics(self, mmap=False):
f = _segyio.open(self.filename, "r")
if mmap: _segyio.mmap(f)
binary_header = _segyio.read_binaryheader(f)
ilb = 189
xlb = 193
metrics = _segyio.init_metrics(f, binary_header)
metrics.update(
_segyio.init_cube_metrics(f, ilb, xlb, metrics['trace_count'],
metrics['trace0'],
metrics['trace_bsize']))
_segyio.close(f)
sorting = metrics['sorting']
trace_count = metrics['trace_count']
inline_count = metrics['iline_count']
crossline_count = metrics['xline_count']
offset_count = metrics['offset_count']
metrics = _segyio.init_line_metrics(sorting, trace_count, inline_count,
crossline_count, offset_count)
self.assertEqual(metrics['xline_length'], 5)
self.assertEqual(metrics['xline_stride'], 5)
self.assertEqual(metrics['iline_length'], 5)
self.assertEqual(metrics['iline_stride'], 1)
# (sorting, trace_count, inline_count, crossline_count, offset_count)
metrics = _segyio.init_line_metrics(1, 15, 3, 5, 1)
self.assertEqual(metrics['xline_length'], 3)
self.assertEqual(metrics['xline_stride'], 1)
self.assertEqual(metrics['iline_length'], 5)
self.assertEqual(metrics['iline_stride'], 3)
metrics = _segyio.init_line_metrics(2, 15, 3, 5, 1)
self.assertEqual(metrics['xline_length'], 3)
self.assertEqual(metrics['xline_stride'], 5)
self.assertEqual(metrics['iline_length'], 5)
self.assertEqual(metrics['iline_stride'], 1)
def test_read_and_write_binary_header(self, mmap=False):
with self.assertRaises(Exception):
hdr = _segyio.read_binaryheader(None)
with self.assertRaises(Exception):
_segyio.write_binaryheader(None, None)
with TestContext("read_and_write_bin_header") as context:
context.copy_file(self.filename)
f = _segyio.open("small.sgy", "r+")
if mmap: _segyio.mmap(f)
binary_header = _segyio.read_binaryheader(f)
with self.assertRaises(Exception):
_segyio.write_binaryheader(f, "Not the correct type")
_segyio.write_binaryheader(f, binary_header)
_segyio.close(f)
def test_write_text_header(self, mmap=False):
with TestContext("write_text_header") as context:
context.copy_file(self.filename)
f = _segyio.open("small.sgy", "r+")
if mmap: _segyio.mmap(f)
_segyio.write_textheader(f, 0, "")
textheader = _segyio.read_textheader(f, 0)
textheader = textheader.decode('ascii')
self.assertEqual(textheader, "" * 3200)
_segyio.write_textheader(f, 0, "yolo" * 800)
textheader = _segyio.read_textheader(f, 0)
textheader = textheader.decode(
'ascii'
) # Because in Python 3.5 bytes are not comparable to strings
self.assertEqual(textheader, "yolo" * 800)
_segyio.close(f)
