def test_readingAndWritingDifferentDataEncodings(self): """ Writes and reads different data encodings and checks if the data remains the same. """ # The file uses IBM data encoding. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st = _read_segy(file) data = st[0].data # All working encodings with corresponding dtypes. encodings = {1: np.float32, 2: np.int32, 3: np.int16, 5: np.float32} with NamedTemporaryFile() as tf: out_file = tf.name # Loop over all encodings. for data_encoding, dtype in encodings.items(): this_data = np.require(data.copy(), dtype) st[0].data = this_data _write_segy(st, out_file, data_encoding=data_encoding) # Read again and compare data. this_stream = _read_segy(out_file) # Both should now be equal. Usually converting from IBM to IEEE # floating point numbers might result in small rounding errors # but in this case it seems to work. Might be different on # different computers. np.testing.assert_array_equal(this_data, this_stream[0].data)
def test_reading_and_writing_different_data_encodings(self): """ Writes and reads different data encodings and checks if the data remains the same. """ # The file uses IBM data encoding. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st = _read_segy(file) data = st[0].data # All working encodings with corresponding dtypes. encodings = {1: np.float32, 2: np.int32, 3: np.int16, 5: np.float32} with NamedTemporaryFile() as tf: out_file = tf.name # Loop over all encodings. for data_encoding, dtype in encodings.items(): this_data = np.require(data.copy(), dtype) st[0].data = this_data _write_segy(st, out_file, data_encoding=data_encoding) # Read again and compare data. this_stream = _read_segy(out_file) # Both should now be equal. Usually converting from IBM to IEEE # floating point numbers might result in small rounding errors # but in this case it seems to work. Might be different on # different computers. np.testing.assert_array_equal(this_data, this_stream[0].data)
def test_enforcing_textual_header_encoding_while_reading(self): """ Tests whether or not the enforcing of the encoding of the textual file header actually works. """ # File ld0042_file_00018.sgy_first_trace has an EBCDIC encoding. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') # Read once with EBCDIC encoding and check if it is correct. st1 = _read_segy(file, textual_header_encoding='EBCDIC') self.assertEqual(st1.stats.textual_file_header[3:21], b'CLIENT: LITHOPROBE') # This should also be written the stats dictionary. self.assertEqual(st1.stats.textual_file_header_encoding, 'EBCDIC') # Reading again with ASCII should yield bad results. Lowercase keyword # argument should also work. st2 = _read_segy(file, textual_header_encoding='ascii') self.assertFalse(st2.stats.textual_file_header[3:21] == b'CLIENT: LITHOPROBE') self.assertEqual(st2.stats.textual_file_header_encoding, 'ASCII') # Autodetection should also write the textual file header encoding to # the stats dictionary. st3 = _read_segy(file) self.assertEqual(st3.stats.textual_file_header_encoding, 'EBCDIC')
def test_enforcingTextualHeaderEncodingWhileReading(self): """ Tests whether or not the enforcing of the encoding of the textual file header actually works. """ # File ld0042_file_00018.sgy_first_trace has an EBCDIC encoding. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') # Read once with EBCDIC encoding and check if it is correct. st1 = _read_segy(file, textual_header_encoding='EBCDIC') self.assertTrue(st1.stats.textual_file_header[3:21] == b'CLIENT: LITHOPROBE') # This should also be written the stats dictionary. self.assertEqual(st1.stats.textual_file_header_encoding, 'EBCDIC') # Reading again with ASCII should yield bad results. Lowercase keyword # argument should also work. st2 = _read_segy(file, textual_header_encoding='ascii') self.assertFalse(st2.stats.textual_file_header[3:21] == b'CLIENT: LITHOPROBE') self.assertEqual(st2.stats.textual_file_header_encoding, 'ASCII') # Autodetection should also write the textual file header encoding to # the stats dictionary. st3 = _read_segy(file) self.assertEqual(st3.stats.textual_file_header_encoding, 'EBCDIC')
def test_enforcing_textual_header_encoding_while_writing(self): """ Tests whether or not the enforcing of the endianness while writing works. """ # File ld0042_file_00018.sgy_first_trace has an EBCDIC encoding. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st1 = _read_segy(file) # Save the header to compare it later on. with open(file, 'rb') as f: header = f.read(3200) # All newly written header will have the file revision number and # the end header mark set - just also set them in the old header. header = _patch_header(header, ebcdic=True) # First write should remain EBCDIC. with NamedTemporaryFile() as tf: out_file = tf.name _write_segy(st1, out_file) st2 = _read_segy(out_file) # Compare header. with open(out_file, 'rb') as f: new_header = f.read(3200) # re-encode both to ASCII to easily compare them. self.assertEqual( header.decode("EBCDIC-CP-BE").encode("ASCII"), new_header.decode("EBCDIC-CP-BE").encode("ASCII")) self.assertEqual(st2.stats.textual_file_header_encoding, 'EBCDIC') # Do once again to enforce EBCDIC. _write_segy(st1, out_file, textual_header_encoding='EBCDIC') st3 = _read_segy(out_file) # Compare header. with open(out_file, 'rb') as f: new_header = f.read(3200) self.assertEqual(header, new_header) os.remove(out_file) self.assertEqual(st3.stats.textual_file_header_encoding, 'EBCDIC') # Enforce ASCII _write_segy(st1, out_file, textual_header_encoding='ASCII') st4 = _read_segy(out_file) # Compare header. Should not be equal this time. with open(out_file, 'rb') as f: new_header = f.read(3200) self.assertFalse(header == new_header) os.remove(out_file) self.assertEqual(st4.stats.textual_file_header_encoding, 'ASCII')
def test_writingNewSamplingRate(self): """ Setting a new sample rate works. """ file = os.path.join(self.path, '1.sgy_first_trace') segy = _read_segy(file) segy[0].stats.sampling_rate = 20 with NamedTemporaryFile() as tf: outfile = tf.name _write_segy(segy, outfile) new_segy = _read_segy(outfile) self.assertEqual(new_segy[0].stats.sampling_rate, 20) # The same with the Seismic Unix file. file = os.path.join(self.path, '1.su_first_trace') _read_su(file)
def test_TwoDigitYearsSEGY(self): """ Even tough not specified in the 1975 SEG Y rev 1 standard, 2 digit years should be read correctly. Some programs produce them. Every two digit year < 30 will be mapped to 2000-2029 and every two digit year >=30 <100 will be mapped to 1930-1999. """ # Read two artificial test files and check the years. filename = os.path.join(self.path, 'one_trace_year_11.sgy') st = _read_segy(filename) self.assertEqual(2011, st[0].stats.starttime.year) filename = os.path.join(self.path, 'one_trace_year_99.sgy') st = _read_segy(filename) self.assertEqual(1999, st[0].stats.starttime.year)
def test_two_digit_years_segy(self): """ Even tough not specified in the 1975 SEG Y rev 1 standard, 2 digit years should be read correctly. Some programs produce them. Every two digit year < 30 will be mapped to 2000-2029 and every two digit year >=30 <100 will be mapped to 1930-1999. """ # Read two artificial test files and check the years. filename = os.path.join(self.path, 'one_trace_year_11.sgy') st = _read_segy(filename) self.assertEqual(2011, st[0].stats.starttime.year) filename = os.path.join(self.path, 'one_trace_year_99.sgy') st = _read_segy(filename) self.assertEqual(1999, st[0].stats.starttime.year)
def read_model(fname): """ Reads a model in segy format and returns it as an array.""" # data = segy.readSEGY(fname) data = segy._read_segy(fname) return np.array([tr.data for tr in data.traces])
def test_readingUsingCore(self): """ This tests checks whether or not all necessary information is read during reading with core. It actually just assumes the internal SEGYFile object, which is thoroughly tested in obspy.io.segy.tests.test_segy, is correct and compared all values to it. This seems to be the easiest way to test everything. """ for file, _ in self.files.items(): file = os.path.join(self.path, file) # Read the file with the internal SEGY representation. segy_file = _read_segyInternal(file) # Read again using core. st = _read_segy(file) # They all should have length one because all additional traces # have been removed. self.assertEqual(len(st), 1) # Assert the data is the same. np.testing.assert_array_equal(segy_file.traces[0].data, st[0].data) # Textual header. self.assertEqual(segy_file.textual_file_header, st.stats.textual_file_header) # Textual_header_encoding. self.assertEqual(segy_file.textual_header_encoding, st.stats.textual_file_header_encoding) # Endianness. self.assertEqual(segy_file.endian, st.stats.endian) # Data encoding. self.assertEqual(segy_file.data_encoding, st.stats.data_encoding) # Test the file and trace binary headers. for key, value in segy_file.binary_file_header.__dict__.items(): self.assertEqual(getattr(st.stats.binary_file_header, key), value) for key, value in segy_file.traces[0].header.__dict__.items(): self.assertEqual(getattr(st[0].stats.segy.trace_header, key), value)
def __init__(self, dataset_path): super().__init__() self.dataset_path = dataset_path self.fs = 250 traces = [] # For every file in the dataset folder for dataset in os.listdir(self.dataset_path): if dataset.split('.')[-1] == 'segy': # Read dataset data = _read_segy(f'{self.dataset_path}/{dataset}') # For every trace in the dataset for wave in data: # To ndarray trace = wave.data # Append to traces list traces.append(trace) self.traces = np.asarray(traces) # Preprocess self.traces = self.preprocess(self.traces, self.fs) # Normalize self.traces = self.normalize(self.traces)
def test_writing_text_and_binary_textual_file_headers(self): """ Make sure the textual file header can be written if has been passed either as text or as a bytestring. """ # Loop over bytes/text and the textual header encoding. for textual_file_header in [b"12345", "12345"]: for encoding in ["ASCII", "EBCDIC"]: st = read() for tr in st: tr.data = np.require(tr.data, dtype=np.float32) st.stats = AttribDict() st.stats.textual_file_header = textual_file_header with io.BytesIO() as buf: # Warning raised to create a complete header. with warnings.catch_warnings(record=True): st.write(buf, format="SEGY", data_encoding=5, textual_header_encoding=encoding) buf.seek(0, 0) # Read with SEG-Y to preserve the textual file header. st2 = _read_segy(buf) self.assertEqual( # Ignore the auto-generated parts of the header. st2.stats.textual_file_header.decode().split()[0], "12345")
def test_writingUsingCore(self): """ Tests the writing of SEGY rev1 files using obspy.core. It just compares the output of writing using obspy.core with the output of writing the files using the internal SEGY object which is thoroughly tested in obspy.io.segy.tests.test_segy. """ for file, _ in self.files.items(): file = os.path.join(self.path, file) # Read the file with the internal SEGY representation. segy_file = _read_segyInternal(file) # Read again using core. st = _read_segy(file) # Create two temporary files to write to. with NamedTemporaryFile() as tf1: out_file1 = tf1.name with NamedTemporaryFile() as tf2: out_file2 = tf2.name # Write twice. segy_file.write(out_file1) _write_segy(st, out_file2) # Read and delete files. with open(out_file1, 'rb') as f1: data1 = f1.read() with open(out_file2, 'rb') as f2: data2 = f2.read() # Test if they are equal. self.assertEqual(data1[3200:3600], data2[3200:3600])
def test_setting_data_encoding_works(self): """ Test whether or not the enforcing the data encoding works. """ # File ld0042_file_00018.sgy_first_trace uses IBM floating point # representation. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st = _read_segy(file) # First test if it even works. with NamedTemporaryFile() as tf: out_file = tf.name _write_segy(st, out_file) with open(out_file, 'rb') as f: data1 = f.read() # Write again and enforce encoding one which should yield the same # result. _write_segy(st, out_file, data_encoding=1) with open(out_file, 'rb') as f: data2 = f.read() self.assertEqual(data1, data2) # Writing IEEE floats which should not require any dtype changes. _write_segy(st, out_file, data_encoding=5) with open(out_file, 'rb') as f: data3 = f.read() self.assertFalse(data1 == data3)
def test_settingDataEncodingWorks(self): """ Test whether or not the enforcing the data encoding works. """ # File ld0042_file_00018.sgy_first_trace uses IBM floating point # representation. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st = _read_segy(file) # First test if it even works. with NamedTemporaryFile() as tf: out_file = tf.name _write_segy(st, out_file) with open(out_file, 'rb') as f: data1 = f.read() # Write again and enforce encoding one which should yield the same # result. _write_segy(st, out_file, data_encoding=1) with open(out_file, 'rb') as f: data2 = f.read() self.assertTrue(data1 == data2) # Writing IEEE floats which should not require any dtype changes. _write_segy(st, out_file, data_encoding=5) with open(out_file, 'rb') as f: data3 = f.read() self.assertFalse(data1 == data3)
def test_largeSampleRateIntervalRaises(self): """ SEG Y supports a sample interval from 1 to 65535 microseconds in steps of 1 microsecond. Larger intervals cannot be supported due to the definition of the SEG Y format. Therefore the smallest possible sampling rate is ~ 15.26 Hz. """ with NamedTemporaryFile() as tf: outfile = tf.name # Test for SEG Y. file = os.path.join(self.path, '1.sgy_first_trace') segy = _read_segy(file) # Set the largest possible delta value which should just work. segy[0].stats.delta = 0.065535 _write_segy(segy, outfile) # Slightly larger should raise. segy[0].stats.delta = 0.065536 self.assertRaises(SEGYSampleIntervalError, _write_segy, segy, outfile) # Same for SU. file = os.path.join(self.path, '1.su_first_trace') su = _read_su(file) # Set the largest possible delta value which should just work. su[0].stats.delta = 0.065535 _write_su(su, outfile) # Slightly larger should raise. su[0].stats.delta = 0.065536 self.assertRaises(SEGYSampleIntervalError, _write_su, su, outfile)
def test_large_sample_rate_interval_raises(self): """ SEG Y supports a sample interval from 1 to 65535 microseconds in steps of 1 microsecond. Larger intervals cannot be supported due to the definition of the SEG Y format. Therefore the smallest possible sampling rate is ~ 15.26 Hz. """ with NamedTemporaryFile() as tf: outfile = tf.name # Test for SEG Y. file = os.path.join(self.path, '1.sgy_first_trace') segy = _read_segy(file) segy.stats.textual_file_header = \ _patch_header(segy.stats.textual_file_header) # Set the largest possible delta value which should just work. segy[0].stats.delta = 0.065535 _write_segy(segy, outfile) # Slightly larger should raise. segy[0].stats.delta = 0.065536 self.assertRaises(SEGYSampleIntervalError, _write_segy, segy, outfile) # Same for SU. file = os.path.join(self.path, '1.su_first_trace') su = _read_su(file) # Set the largest possible delta value which should just work. su[0].stats.delta = 0.065535 _write_su(su, outfile) # Slightly larger should raise. su[0].stats.delta = 0.065536 self.assertRaises(SEGYSampleIntervalError, _write_su, su, outfile)
def test_writing_using_core(self): """ Tests the writing of SEGY rev1 files using obspy.core. It just compares the output of writing using obspy.core with the output of writing the files using the internal SEGY object which is thoroughly tested in obspy.io.segy.tests.test_segy. """ for file, _ in self.files.items(): file = os.path.join(self.path, file) # Read the file with the internal SEGY representation. segy_file = _read_segy_internal(file) # Read again using core. st = _read_segy(file) # Create two temporary files to write to. with NamedTemporaryFile() as tf1: out_file1 = tf1.name with NamedTemporaryFile() as tf2: out_file2 = tf2.name # Write twice and catch header warnings with WarningsCapture(): warnings.simplefilter("ignore") segy_file.write(out_file1) _write_segy(st, out_file2) # Read and delete files. with open(out_file1, 'rb') as f1: data1 = f1.read() with open(out_file2, 'rb') as f2: data2 = f2.read() # Test if they are equal. self.assertEqual(data1[3200:3600], data2[3200:3600])
def read_lesser_antilles_airgun(): dataset_folder = "../Data/Lesser_Antilles" # Sampling frequency pre-read from file fs = 250 # Preallocate traces = [] # For every file in the dataset folder for dataset in os.listdir(dataset_folder): # Read dataset data = _read_segy(f'{dataset_folder}/{dataset}') # For every trace in the dataset for wave in data: # To ndarray trace = wave.data # New amount of samples to resample new_samples = int(len(trace) * 100 / fs) # New samples = 6000 so no need to do anything else trace = signal.resample(trace, new_samples) # Append to traces list traces.append(trace) traces = np.array(traces) print(f"Lesser Antilles traces shape: {traces.shape}") return traces
def test_writing_text_and_binary_textual_file_headers(self): """ Make sure the textual file header can be written if has been passed either as text or as a bytestring. """ # Loop over bytes/text and the textual header encoding. for textual_file_header in [b"12345", "12345"]: for encoding in ["ASCII", "EBCDIC"]: st = read() for tr in st: tr.data = np.require(tr.data, dtype=np.float32) st.stats = AttribDict() st.stats.textual_file_header = textual_file_header with io.BytesIO() as buf: # Warning raised to create a complete header. with pytest.warns(UserWarning): st.write(buf, format="SEGY", data_encoding=5, textual_header_encoding=encoding) buf.seek(0, 0) # Read with SEG-Y to preserve the textual file header. st2 = _read_segy(buf) self.assertEqual( # Ignore the auto-generated parts of the header. st2.stats.textual_file_header.decode().split()[0], "12345")
def main(): # Create images and animations folders Path("Imgs").mkdir(exist_ok=True) # Init rng rng = default_rng() # Datos dataset = 'ar56.7984.mgl1408.mcs002.bbobs-a01_geo.segy' data = _read_segy(dataset) # Sampling frequency fs = 100 # Number of traces to plot n = 100 traces = [] for wave in data: traces.append(wave.data) traces = np.array(traces) print(traces.shape)
def __init__(self, dataset_path, savepath): super(DatasetNCAirgun, self).__init__() self.savepath = savepath self.dataset_path = dataset_path self.fs = 100 print(f"Reading dataset from path: {self.dataset_path}") data = _read_segy(self.dataset_path) traces = [] for wave in data: traces.append(wave.data) self.traces = np.array(traces) print("Preprocessing dataset") self.traces = self.preprocess(self.traces, self.fs) print("Normalizing dataset") # self.traces = self.normalize(self.traces) self.traces = self.normalize(self.traces) print(f"Saving npy format dataset in {self.savepath}") if not os.path.exists(f'{self.savepath}/NCAirgun.npy'): self.save_dataset(self.traces[:18000, :], self.savepath, 'NCAirgun')
def read_segy_file_obspy(filename): """ Read segy with obspy :param filename: :return: """ segy = _read_segy(filename) return np.array([x.data for x in segy], ndmin=2, dtype=np.float32)
def get_segy_details(filename): st = _read_segy(filename, unpack_trace_headers=True) trace_cnt = len(st) tr = st[0] sampling_rate = tr.stats.sampling_rate npts = tr.stats.npts return trace_cnt, sampling_rate, npts
def test_enforcing_endianness_while_reading(self): """ Tests whether or not enforcing the endianness while reading a file works. It will actually just deactivate the autodetection in case it produced a wrong result. Using a wrong endianness while reading a file will still produce an error because the data format will most likely be wrong and therefore obspy.io.segy cannot unpack the data. """ # File ld0042_file_00018.sgy_first_trace is in big endian. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') # This should work and write big endian to the stats dictionary. st1 = _read_segy(file) self.assertEqual(st1.stats.endian, '>') # Doing the same with the right endianness should still work. st2 = _read_segy(file, byteorder='>') self.assertEqual(st2.stats.endian, '>') # The wrong endianness should yield an key error because the routine to # unpack the wrong data format code cannot be found. self.assertRaises(KeyError, _read_segy, file, byteorder='<')
def test_invalidDataEncodingRaises(self): """ Using an invalid data encoding raises an error. """ file = os.path.join(self.path, "ld0042_file_00018.sgy_first_trace") st = _read_segy(file) with NamedTemporaryFile() as tf: out_file = tf.name self.assertRaises(SEGYCoreWritingError, _write_segy, st, out_file, data_encoding=0) self.assertRaises(SEGYCoreWritingError, _write_segy, st, out_file, data_encoding="")
def test_enforcingEndiannessWhileReading(self): """ Tests whether or not enforcing the endianness while reading a file works. It will actually just deactivate the autodetection in case it produced a wrong result. Using a wrong endianness while reading a file will still produce an error because the data format will most likely be wrong and therefore obspy.io.segy cannot unpack the data. """ # File ld0042_file_00018.sgy_first_trace is in big endian. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') # This should work and write big endian to the stats dictionary. st1 = _read_segy(file) self.assertEqual(st1.stats.endian, '>') # Doing the same with the right endianness should still work. st2 = _read_segy(file, byteorder='>') self.assertEqual(st2.stats.endian, '>') # The wrong endianness should yield an key error because the routine to # unpack the wrong data format code cannot be found. self.assertRaises(KeyError, _read_segy, file, byteorder='<')
def test_enforcingTextualHeaderEncodingWhileWriting(self): """ Tests whether or not the enforcing of the endianness while writing works. """ # File ld0042_file_00018.sgy_first_trace has an EBCDIC encoding. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st1 = _read_segy(file) # Save the header to compare it later on. with open(file, 'rb') as f: header = f.read(3200) # First write should remain EBCDIC. with NamedTemporaryFile() as tf: out_file = tf.name _write_segy(st1, out_file) st2 = _read_segy(out_file) # Compare header. with open(out_file, 'rb') as f: new_header = f.read(3200) self.assertTrue(header == new_header) self.assertEqual(st2.stats.textual_file_header_encoding, 'EBCDIC') # Do once again to enforce EBCDIC. _write_segy(st1, out_file, textual_header_encoding='EBCDIC') st3 = _read_segy(out_file) # Compare header. with open(out_file, 'rb') as f: new_header = f.read(3200) self.assertTrue(header == new_header) os.remove(out_file) self.assertEqual(st3.stats.textual_file_header_encoding, 'EBCDIC') # Enforce ASCII _write_segy(st1, out_file, textual_header_encoding='ASCII') st4 = _read_segy(out_file) # Compare header. Should not be equal this time. with open(out_file, 'rb') as f: new_header = f.read(3200) self.assertFalse(header == new_header) os.remove(out_file) self.assertEqual(st4.stats.textual_file_header_encoding, 'ASCII')
def test_enforcing_textual_header_encoding_while_writing(self): """ Tests whether or not the enforcing of the endianness while writing works. """ # File ld0042_file_00018.sgy_first_trace has an EBCDIC encoding. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st1 = _read_segy(file) # Save the header to compare it later on. with open(file, 'rb') as f: header = f.read(3200) # First write should remain EBCDIC. with NamedTemporaryFile() as tf: out_file = tf.name _write_segy(st1, out_file) st2 = _read_segy(out_file) # Compare header. with open(out_file, 'rb') as f: new_header = f.read(3200) self.assertEqual(header, new_header) self.assertEqual(st2.stats.textual_file_header_encoding, 'EBCDIC') # Do once again to enforce EBCDIC. _write_segy(st1, out_file, textual_header_encoding='EBCDIC') st3 = _read_segy(out_file) # Compare header. with open(out_file, 'rb') as f: new_header = f.read(3200) self.assertEqual(header, new_header) os.remove(out_file) self.assertEqual(st3.stats.textual_file_header_encoding, 'EBCDIC') # Enforce ASCII _write_segy(st1, out_file, textual_header_encoding='ASCII') st4 = _read_segy(out_file) # Compare header. Should not be equal this time. with open(out_file, 'rb') as f: new_header = f.read(3200) self.assertFalse(header == new_header) os.remove(out_file) self.assertEqual(st4.stats.textual_file_header_encoding, 'ASCII')
def test_issue377(self): """ Tests that _read_segy() and stream.write() should handle negative trace header values. """ filename = os.path.join(self.path, 'one_trace_year_11.sgy') st = _read_segy(filename) st[0].stats.segy.trace_header['source_coordinate_x'] = -1 with NamedTemporaryFile() as tf: outfile = tf.name st.write(outfile, format='SEGY')
def test_writing_starttime_timestamp_0(self): """ If the starttime of the Trace is UTCDateTime(0) it will be interpreted as a missing starttime is not written. Test if this holds True. """ file = os.path.join(self.path, '1.sgy_first_trace') # This file has a set date! with open(file, 'rb') as f: f.seek(3600 + 156, 0) date_time = f.read(10) year, julday, hour, minute, second = unpack(b'>5h', date_time) self.assertEqual([ year == 2005, julday == 353, hour == 15, minute == 7, second == 54 ], 5 * [True]) # Read and set zero time. segy = _read_segy(file) segy.stats.textual_file_header = \ _patch_header(segy.stats.textual_file_header) segy[0].stats.starttime = UTCDateTime(0) with NamedTemporaryFile() as tf: outfile = tf.name _write_segy(segy, outfile) # Check the new date. with open(outfile, 'rb') as f: f.seek(3600 + 156, 0) date_time = f.read(10) year, julday, hour, minute, second = unpack(b'>5h', date_time) self.assertEqual( [year == 0, julday == 0, hour == 0, minute == 0, second == 0], 5 * [True]) # The same for SU. file = os.path.join(self.path, '1.su_first_trace') # This file has a set date! with open(file, 'rb') as f: f.seek(156, 0) date_time = f.read(10) year, julday, hour, minute, second = unpack(b'<5h', date_time) self.assertEqual([ year == 2005, julday == 353, hour == 15, minute == 7, second == 54 ], 5 * [True]) # Read and set zero time. su = _read_su(file) su[0].stats.starttime = UTCDateTime(0) with NamedTemporaryFile() as tf: outfile = tf.name _write_su(su, outfile) # Check the new date. with open(outfile, 'rb') as f: f.seek(156, 0) date_time = f.read(10) year, julday, hour, minute, second = unpack(b'<5h', date_time) self.assertEqual( [year == 0, julday == 0, hour == 0, minute == 0, second == 0], 5 * [True])
def test_invalid_data_encoding_raises(self): """ Using an invalid data encoding raises an error. """ file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st = _read_segy(file) with NamedTemporaryFile() as tf: out_file = tf.name self.assertRaises(SEGYCoreWritingError, _write_segy, st, out_file, data_encoding=0) self.assertRaises(SEGYCoreWritingError, _write_segy, st, out_file, data_encoding='')
def __init__(self, dataset_path): super().__init__() self.dataset_path = dataset_path data = _read_segy(self.dataset_path) traces = [] for wave in data: traces.append(wave.data) self.traces = np.array(traces)
def test_enforcingEndiannessWhileWriting(self): """ Tests whether or not the enforcing of the endianness while writing works. """ # File ld0042_file_00018.sgy_first_trace is in big endian. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st1 = _read_segy(file) # First write should be big endian. with NamedTemporaryFile() as tf: out_file = tf.name _write_segy(st1, out_file) st2 = _read_segy(out_file) self.assertEqual(st2.stats.endian, '>') # Do once again to enforce big endian. _write_segy(st1, out_file, byteorder='>') st3 = _read_segy(out_file) self.assertEqual(st3.stats.endian, '>') # Enforce little endian. _write_segy(st1, out_file, byteorder='<') st4 = _read_segy(out_file) self.assertEqual(st4.stats.endian, '<')
def test_enforcing_endianness_while_writing(self): """ Tests whether or not the enforcing of the endianness while writing works. """ # File ld0042_file_00018.sgy_first_trace is in big endian. file = os.path.join(self.path, 'ld0042_file_00018.sgy_first_trace') st1 = _read_segy(file) # First write should be big endian. with NamedTemporaryFile() as tf: out_file = tf.name _write_segy(st1, out_file) st2 = _read_segy(out_file) self.assertEqual(st2.stats.endian, '>') # Do once again to enforce big endian. _write_segy(st1, out_file, byteorder='>') st3 = _read_segy(out_file) self.assertEqual(st3.stats.endian, '>') # Enforce little endian. _write_segy(st1, out_file, byteorder='<') st4 = _read_segy(out_file) self.assertEqual(st4.stats.endian, '<')
def load(self, segyfile): """Load seg-y and add hard coded header information to trace """ gaugelength = 10.0 dx_in_m = 1.02 das_units = 'n$\epsilon$/s' fo_start_ch = 197 #end channel 1280 stream = obspy.Stream() dd = _read_segy(segyfile, unpack_trace_headers=True) stream += utils.populate_das_segy_trace_headers( dd, dx_in_m=dx_in_m, fo_start_ch=fo_start_ch, units=das_units) self.st = stream
def test_reading_date(self): """ Reads one file with a set date. The date has been read with SeisView 2 by the DMNG. """ # Date as read by SeisView 2. date = UTCDateTime(year=2005, julday=353, hour=15, minute=7, second=54) file = os.path.join(self.path, '1.sgy_first_trace') segy = _read_segy(file) self.assertEqual(date, segy[0].stats.starttime) # The same with the Seismic Unix file. file = os.path.join(self.path, '1.su_first_trace') su = _read_su(file) self.assertEqual(date, su[0].stats.starttime)
def test_setting_delta_and_sampling_rate_in_stats(self): """ Just checks if the delta and sampling rate attributes are correctly set. Testing the delta value is enough because the stats attribute takes care that delta/sampling rate always match. """ file = os.path.join(self.path, '1.sgy_first_trace') segy = _read_segy(file) self.assertEqual(segy[0].stats.delta, 250E-6) # The same with the Seismic Unix file. file = os.path.join(self.path, '1.su_first_trace') su = _read_su(file) self.assertEqual(su[0].stats.delta, 250E-6)
def test_readHeadOnly(self): """ Tests headonly flag on _read_segy and _read_su functions. """ # _read_segy file = os.path.join(self.path, '1.sgy_first_trace') st = _read_segy(file, headonly=True) self.assertEqual(st[0].stats.npts, 8000) self.assertEqual(len(st[0].data), 0) # _read_su file = os.path.join(self.path, '1.su_first_trace') st = _read_su(file, headonly=True) self.assertEqual(st[0].stats.npts, 8000) self.assertEqual(len(st[0].data), 0)
def test_settingDeltaandSamplingRateinStats(self): """ Just checks if the delta and sampling rate attributes are correctly set. Testing the delta value is enough because the stats attribute takes care that delta/sampling rate always match. """ file = os.path.join(self.path, '1.sgy_first_trace') segy = _read_segy(file) self.assertEqual(segy[0].stats.delta, 250E-6) # The same with the Seismic Unix file. file = os.path.join(self.path, '1.su_first_trace') su = _read_su(file) self.assertEqual(su[0].stats.delta, 250E-6)
def test_readingDate(self): """ Reads one file with a set date. The date has been read with SeisView 2 by the DMNG. """ # Date as read by SeisView 2. date = UTCDateTime(year=2005, julday=353, hour=15, minute=7, second=54) file = os.path.join(self.path, '1.sgy_first_trace') segy = _read_segy(file) self.assertEqual(date, segy[0].stats.starttime) # The same with the Seismic Unix file. file = os.path.join(self.path, '1.su_first_trace') su = _read_su(file) self.assertEqual(date, su[0].stats.starttime)
def test_writingModifiedDate(self): """ Tests if the date in Trace.stats.starttime is correctly written in SU and SEGY files. """ # Define new date! new_date = UTCDateTime(2010, 7, 7, 2, 2, 2) with NamedTemporaryFile() as tf: outfile = tf.name # Test for SEGY. file = os.path.join(self.path, 'example.y_first_trace') segy = _read_segy(file) segy[0].stats.starttime = new_date _write_segy(segy, outfile) segy_new = _read_segy(outfile) self.assertEqual(new_date, segy_new[0].stats.starttime) # Test for SU. file = os.path.join(self.path, '1.su_first_trace') su = _read_su(file) su[0].stats.starttime = new_date _write_su(su, outfile) su_new = _read_su(outfile) self.assertEqual(new_date, su_new[0].stats.starttime)
def test_writing_modified_date(self): """ Tests if the date in Trace.stats.starttime is correctly written in SU and SEGY files. """ # Define new date! new_date = UTCDateTime(2010, 7, 7, 2, 2, 2) with NamedTemporaryFile() as tf: outfile = tf.name # Test for SEGY. file = os.path.join(self.path, 'example.y_first_trace') segy = _read_segy(file) segy[0].stats.starttime = new_date _write_segy(segy, outfile) segy_new = _read_segy(outfile) self.assertEqual(new_date, segy_new[0].stats.starttime) # Test for SU. file = os.path.join(self.path, '1.su_first_trace') su = _read_su(file) su[0].stats.starttime = new_date _write_su(su, outfile) su_new = _read_su(outfile) self.assertEqual(new_date, su_new[0].stats.starttime)
def test_read_head_only(self): """ Tests headonly flag on _read_segy and _read_su functions. """ # _read_segy file = os.path.join(self.path, '1.sgy_first_trace') st = _read_segy(file, headonly=True) self.assertEqual(st[0].stats.npts, 8000) self.assertEqual(len(st[0].data), 0) # _read_su file = os.path.join(self.path, '1.su_first_trace') st = _read_su(file, headonly=True) self.assertEqual(st[0].stats.npts, 8000) self.assertEqual(len(st[0].data), 0)
def test_writing_starttime_timestamp_0(self): """ If the starttime of the Trace is UTCDateTime(0) it will be interpreted as a missing starttime is not written. Test if this holds True. """ file = os.path.join(self.path, '1.sgy_first_trace') # This file has a set date! with open(file, 'rb') as f: f.seek(3600 + 156, 0) date_time = f.read(10) year, julday, hour, minute, second = unpack(b'>5h', date_time) self.assertEqual([year == 2005, julday == 353, hour == 15, minute == 7, second == 54], 5 * [True]) # Read and set zero time. segy = _read_segy(file) segy.stats.textual_file_header = \ _patch_header(segy.stats.textual_file_header) segy[0].stats.starttime = UTCDateTime(0) with NamedTemporaryFile() as tf: outfile = tf.name _write_segy(segy, outfile) # Check the new date. with open(outfile, 'rb') as f: f.seek(3600 + 156, 0) date_time = f.read(10) year, julday, hour, minute, second = unpack(b'>5h', date_time) self.assertEqual([year == 0, julday == 0, hour == 0, minute == 0, second == 0], 5 * [True]) # The same for SU. file = os.path.join(self.path, '1.su_first_trace') # This file has a set date! with open(file, 'rb') as f: f.seek(156, 0) date_time = f.read(10) year, julday, hour, minute, second = unpack(b'<5h', date_time) self.assertEqual([year == 2005, julday == 353, hour == 15, minute == 7, second == 54], 5 * [True]) # Read and set zero time. su = _read_su(file) su[0].stats.starttime = UTCDateTime(0) with NamedTemporaryFile() as tf: outfile = tf.name _write_su(su, outfile) # Check the new date. with open(outfile, 'rb') as f: f.seek(156, 0) date_time = f.read(10) year, julday, hour, minute, second = unpack(b'<5h', date_time) self.assertEqual([year == 0, julday == 0, hour == 0, minute == 0, second == 0], 5 * [True])
def load(self, segyfile): """ Load seg-y file """ print('loading ', segyfile) if DEBUG: start_time = time.time() self.st = _read_segy(segyfile) if DEBUG: print('loading data took ', time.time() - start_time) self.nTrace = len(self.st) if DEBUG: print('number of traces is ', self.nTrace) print('data in each trace is', len(self.st[0].data))
def test_notMatchingDataEncodingAndDtypeRaises(self): """ obspy.io.segy does not automatically convert to the corresponding dtype. """ encodings = [1, 2, 3, 5] # The file uses IBM data encoding. file = os.path.join(self.path, "ld0042_file_00018.sgy_first_trace") st = _read_segy(file) # Use float64 as the wrong encoding in every case. st[0].data = np.require(st[0].data, np.float64) with NamedTemporaryFile() as tf: out_file = tf.name # Loop over all encodings. for data_encoding in encodings: self.assertRaises(SEGYCoreWritingError, _write_segy, st, out_file, data_encoding=data_encoding)
def read_north_carolina_airgun(): dataset = "../Data/NC_Airgun/ar56.7984.mgl1408.mcs002.bbobs-a01_geo.segy" data = _read_segy(dataset) fs = 100 traces = [] for wave in data: traces.append(wave.data) traces = np.array(traces) print(f"North Carolina Airgun traces shape: {traces.shape}") return traces