def test_ppsd_w_iris_against_obspy_results(self): """ Test against results obtained after merging of #1108. """ # Read in ANMO data for one day st = read(os.path.join(self.path, "IUANMO.seed")) # Read in metadata in various different formats paz = { "gain": 86298.5, "zeros": [0, 0], "poles": [-59.4313, -22.7121 + 27.1065j, -22.7121 + 27.1065j, -0.0048004, -0.073199], "sensitivity": 3.3554 * 10 ** 9, } resp = os.path.join(self.path, "IUANMO.resp") parser = Parser(os.path.join(self.path, "IUANMO.dataless")) inv = read_inventory(os.path.join(self.path, "IUANMO.xml")) # load expected results, for both only PAZ and full response filename_paz = os.path.join(self.path, "IUANMO_ppsd_paz.npz") results_paz = PPSD.load_npz(filename_paz, metadata=None) filename_full = os.path.join(self.path, "IUANMO_ppsd_fullresponse.npz") results_full = PPSD.load_npz(filename_full, metadata=None) # Calculate the PPSDs and test against expected results # first: only PAZ ppsd = PPSD(st[0].stats, paz) ppsd.add(st) # commented code to generate the test data: # ## np.savez(filename_paz, # ## **dict([(k, getattr(ppsd, k)) # ## for k in PPSD.NPZ_STORE_KEYS])) for key in PPSD.NPZ_STORE_KEYS_ARRAY_TYPES: np.testing.assert_allclose(getattr(ppsd, key), getattr(results_paz, key), rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_LIST_TYPES: for got, expected in zip(getattr(ppsd, key), getattr(results_paz, key)): np.testing.assert_allclose(got, expected, rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_SIMPLE_TYPES: if key in ["obspy_version", "numpy_version", "matplotlib_version"]: continue self.assertEqual(getattr(ppsd, key), getattr(results_paz, key)) # second: various methods for full response for metadata in [parser, inv, resp]: ppsd = PPSD(st[0].stats, metadata) ppsd.add(st) # commented code to generate the test data: # ## np.savez(filename_full, # ## **dict([(k, getattr(ppsd, k)) # ## for k in PPSD.NPZ_STORE_KEYS])) for key in PPSD.NPZ_STORE_KEYS_ARRAY_TYPES: np.testing.assert_allclose(getattr(ppsd, key), getattr(results_full, key), rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_LIST_TYPES: for got, expected in zip(getattr(ppsd, key), getattr(results_full, key)): np.testing.assert_allclose(got, expected, rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_SIMPLE_TYPES: if key in ["obspy_version", "numpy_version", "matplotlib_version"]: continue self.assertEqual(getattr(ppsd, key), getattr(results_full, key))
def test_ppsd_temporal_plot(self): """ Test plot of several period bins over time """ ppsd = PPSD.load_npz(self.example_ppsd_npz) restrictions = { 'starttime': UTCDateTime(2011, 2, 6, 1, 1), 'endtime': UTCDateTime(2011, 2, 7, 21, 12), 'year': [2011], 'time_of_weekday': [(-1, 2, 23)] } # add some gaps in the middle for i in sorted(list(range(30, 40)) + list(range(8, 18)) + [4])[::-1]: ppsd._times_processed.pop(i) ppsd._binned_psds.pop(i) with ImageComparison(self.path_images, 'ppsd_temporal.png', reltol=1.5) as ic: fig = ppsd.plot_temporal([0.1, 1, 10], filename=None, show=False, **restrictions) fig.savefig(ic.name) with ImageComparison(self.path_images, 'ppsd_temporal.png', reltol=1.5) as ic: ppsd.plot_temporal([0.1, 1, 10], filename=ic.name, show=False, **restrictions)
def test_ppsd_temporal_plot(self): """ Test plot of several period bins over time """ ppsd = PPSD.load_npz(self.example_ppsd_npz) restrictions = {'starttime': UTCDateTime(2011, 2, 6, 1, 1), 'endtime': UTCDateTime(2011, 2, 7, 21, 12), 'year': [2011], 'time_of_weekday': [(-1, 2, 23)]} # add some gaps in the middle for i in sorted(list(range(30, 40)) + list(range(8, 18)) + [4])[::-1]: ppsd._times_processed.pop(i) ppsd._binned_psds.pop(i) with ImageComparison(self.path_images, 'ppsd_temporal.png', reltol=1.5) as ic: fig = ppsd.plot_temporal([0.1, 1, 10], filename=None, show=False, **restrictions) fig.savefig(ic.name) with ImageComparison(self.path_images, 'ppsd_temporal.png', reltol=1.5) as ic: ppsd.plot_temporal([0.1, 1, 10], filename=ic.name, show=False, **restrictions)
def test_ppsd(self): """ Test PPSD routine with some real data. """ # paths of the expected result data file_histogram = os.path.join( self.path, 'BW.KW1._.EHZ.D.2011.090_downsampled__ppsd_hist_stack.npy') file_binning = os.path.join( self.path, 'BW.KW1._.EHZ.D.2011.090_downsampled__ppsd_mixed.npz') file_mode_mean = os.path.join( self.path, 'BW.KW1._.EHZ.D.2011.090_downsampled__ppsd_mode_mean.npz') tr, _paz = _get_sample_data() st = Stream([tr]) ppsd = _get_ppsd() # read results and compare result_hist = np.load(file_histogram) self.assertEqual(len(ppsd.times_processed), 4) self.assertEqual(ppsd.nfft, 65536) self.assertEqual(ppsd.nlap, 49152) np.testing.assert_array_equal(ppsd.current_histogram, result_hist) # add the same data a second time (which should do nothing at all) and # test again - but it will raise UserWarnings, which we omit for now with warnings.catch_warnings(record=True): warnings.simplefilter('ignore', UserWarning) ppsd.add(st) np.testing.assert_array_equal(ppsd.current_histogram, result_hist) # test the binning arrays binning = np.load(file_binning) np.testing.assert_array_equal(ppsd.db_bin_edges, binning['spec_bins']) np.testing.assert_array_equal(ppsd.period_bin_centers, binning['period_bins']) # test the mode/mean getter functions per_mode, mode = ppsd.get_mode() per_mean, mean = ppsd.get_mean() result_mode_mean = np.load(file_mode_mean) np.testing.assert_array_equal(per_mode, result_mode_mean['per_mode']) np.testing.assert_array_equal(mode, result_mode_mean['mode']) np.testing.assert_array_equal(per_mean, result_mode_mean['per_mean']) np.testing.assert_array_equal(mean, result_mode_mean['mean']) # test saving and loading of the PPSD (using a temporary file) with NamedTemporaryFile(suffix=".npz") as tf: filename = tf.name # test saving and loading to npz ppsd.save_npz(filename) ppsd_loaded = PPSD.load_npz(filename) ppsd_loaded.calculate_histogram() self.assertEqual(len(ppsd_loaded.times_processed), 4) self.assertEqual(ppsd_loaded.nfft, 65536) self.assertEqual(ppsd_loaded.nlap, 49152) np.testing.assert_array_equal(ppsd_loaded.current_histogram, result_hist) np.testing.assert_array_equal(ppsd_loaded.db_bin_edges, binning['spec_bins']) np.testing.assert_array_equal(ppsd_loaded.period_bin_centers, binning['period_bins'])
def test_can_read_npz_without_pickle(self, state): """ Ensures that a default PPSD can be written and read without having to allow np.load the use of pickle, or that a helpful error message is raised if allow_pickle is required. See #2409. """ # Init a test PPSD and empty byte stream. ppsd = PPSD.load_npz(state.example_ppsd_npz, allow_pickle=True) byte_me = io.BytesIO() # Save PPSD to byte stream and rewind to 0. ppsd.save_npz(byte_me) byte_me.seek(0) # Load dict, will raise an exception if pickle is needed. loaded_dict = dict(np.load(byte_me, allow_pickle=False)) assert isinstance(loaded_dict, dict) # A helpful error message is issued when allow_pickle is needed. with pytest.raises(ValueError, match='Loading PPSD results'): PPSD.load_npz(state.example_ppsd_npz) ppsd = _internal_get_ppsd() # save PPSD in such a way to mock old versions. with NamedTemporaryFile(suffix='.npz') as ntemp: temp_path = ntemp.name self._save_npz_require_pickle(temp_path, ppsd) # We should be able to load the files when allowing pickle. PPSD.load_npz(temp_path, allow_pickle=True) # If not allow_pickle, a helpful error msg should be raised. with pytest.raises(ValueError, match='Loading PPSD results'): PPSD.load_npz(temp_path)
def test_can_read_npz_without_pickle(self): """ Ensures that a default PPSD can be written and read without having to allow np.load the use of pickle, or that a helpful error message is raised if allow_pickle is required. See #2409. """ # Init a test PPSD and empty byte stream. ppsd = PPSD.load_npz(self.example_ppsd_npz, allow_pickle=True) byte_me = io.BytesIO() # Save PPSD to byte stream and rewind to 0. ppsd.save_npz(byte_me) byte_me.seek(0) # Load dict, will raise an exception if pickle is needed. loaded_dict = dict(np.load(byte_me, allow_pickle=False)) self.assertIsInstance(loaded_dict, dict) # A helpful error message is issued when allow_pickle is needed. with self.assertRaises(ValueError) as context: PPSD.load_npz(self.example_ppsd_npz) self.assertIn('Loading PPSD results', str(context.exception))
def test_ppsd_add_npz(self): """ Test PPSD.add_npz(). """ # set up a bogus PPSD, with fixed random psds but with real start times # of psd pieces, to facilitate testing the stack selection. ppsd = PPSD(stats=Stats(dict(sampling_rate=150)), metadata=None, db_bins=(-200, -50, 20.), period_step_octaves=1.4) _times_processed = np.load( os.path.join(self.path, "ppsd_times_processed.npy")).tolist() # change data to nowadays used nanoseconds POSIX timestamp _times_processed = [UTCDateTime(t)._ns for t in _times_processed] np.random.seed(1234) _binned_psds = [ arr for arr in np.random.uniform(-200, -50, ( len(_times_processed), len(ppsd.period_bin_centers))) ] with NamedTemporaryFile(suffix=".npz") as tf1, \ NamedTemporaryFile(suffix=".npz") as tf2, \ NamedTemporaryFile(suffix=".npz") as tf3: # save data split up over three separate temporary files ppsd._times_processed = _times_processed[:200] ppsd._binned_psds = _binned_psds[:200] ppsd.save_npz(tf1.name) ppsd._times_processed = _times_processed[200:400] ppsd._binned_psds = _binned_psds[200:400] ppsd.save_npz(tf2.name) ppsd._times_processed = _times_processed[400:] ppsd._binned_psds = _binned_psds[400:] ppsd.matplotlib_version = "X.X.X" ppsd.save_npz(tf3.name) # now load these saved npz files and check if all data is present ppsd = PPSD.load_npz(tf1.name, metadata=None) ppsd.add_npz(tf2.name) # we changed a version number so this should emit a warning with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') ppsd.add_npz(tf3.name) self.assertEqual(len(w), 1) np.testing.assert_array_equal(_binned_psds, ppsd._binned_psds) np.testing.assert_array_equal(_times_processed, ppsd._times_processed) # adding data already present should also emit a warning and the # PPSD should not be changed with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') ppsd.add_npz(tf2.name) self.assertEqual(len(w), 1) np.testing.assert_array_equal(_binned_psds, ppsd._binned_psds) np.testing.assert_array_equal(_times_processed, ppsd._times_processed)
def test_ppsd_spectrogram_plot(self, state, image_path): """ Test spectrogram type plot of PPSD """ ppsd = PPSD.load_npz(state.example_ppsd_npz, allow_pickle=True) # add some gaps in the middle for i in sorted(list(range(30, 40)) + list(range(8, 18)) + [4])[::-1]: ppsd._times_processed.pop(i) ppsd._binned_psds.pop(i) ppsd.plot_spectrogram(filename=image_path, show=False)
def test_ppsd_add_npz(self): """ Test PPSD.add_npz(). """ # set up a bogus PPSD, with fixed random psds but with real start times # of psd pieces, to facilitate testing the stack selection. ppsd = PPSD(stats=Stats(dict(sampling_rate=150)), metadata=None, db_bins=(-200, -50, 20.), period_step_octaves=1.4) _times_processed = np.load( os.path.join(self.path, "ppsd_times_processed.npy")).tolist() # change data to nowadays used nanoseconds POSIX timestamp _times_processed = [UTCDateTime(t)._ns for t in _times_processed] np.random.seed(1234) _binned_psds = [ arr for arr in np.random.uniform( -200, -50, (len(_times_processed), len(ppsd.period_bin_centers)))] with NamedTemporaryFile(suffix=".npz") as tf1, \ NamedTemporaryFile(suffix=".npz") as tf2, \ NamedTemporaryFile(suffix=".npz") as tf3: # save data split up over three separate temporary files ppsd._times_processed = _times_processed[:200] ppsd._binned_psds = _binned_psds[:200] ppsd.save_npz(tf1.name) ppsd._times_processed = _times_processed[200:400] ppsd._binned_psds = _binned_psds[200:400] ppsd.save_npz(tf2.name) ppsd._times_processed = _times_processed[400:] ppsd._binned_psds = _binned_psds[400:] ppsd.matplotlib_version = "X.X.X" ppsd.save_npz(tf3.name) # now load these saved npz files and check if all data is present ppsd = PPSD.load_npz(tf1.name, metadata=None) ppsd.add_npz(tf2.name) # we changed a version number so this should emit a warning with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') ppsd.add_npz(tf3.name) self.assertEqual(len(w), 1) np.testing.assert_array_equal(_binned_psds, ppsd._binned_psds) np.testing.assert_array_equal(_times_processed, ppsd._times_processed) # adding data already present should also emit a warning and the # PPSD should not be changed with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') ppsd.add_npz(tf2.name) self.assertEqual(len(w), 1) np.testing.assert_array_equal(_binned_psds, ppsd._binned_psds) np.testing.assert_array_equal(_times_processed, ppsd._times_processed)
def test_exception_reading_newer_npz(self): """ Checks that an exception is properly raised when trying to read a npz that was written on a more recent ObsPy version (specifically that has a higher 'ppsd_version' number which is used to keep track of changes in PPSD and the npz file used for serialization). """ msg = ("Trying to read/add a PPSD npz with 'ppsd_version=100'. This " "file was written on a more recent ObsPy version that very " "likely has incompatible changes in PPSD internal structure " "and npz serialization. It can not safely be read with this " "ObsPy version (current 'ppsd_version' is {!s}). Please " "consider updating your ObsPy installation.".format( PPSD(stats=Stats(), metadata=None).ppsd_version)) # 1 - loading a npz data = np.load(self.example_ppsd_npz) # we have to load, modify 'ppsd_version' and save the npz file for the # test.. items = {key: data[key] for key in data.files} # deliberately set a higher ppsd_version number items['ppsd_version'] = items['ppsd_version'].copy() items['ppsd_version'].fill(100) with NamedTemporaryFile() as tf: filename = tf.name with open(filename, 'wb') as fh: np.savez(fh, **items) with self.assertRaises(ObsPyException) as e: PPSD.load_npz(filename) self.assertEqual(str(e.exception), msg) # 2 - adding a npz ppsd = PPSD.load_npz(self.example_ppsd_npz) for method in (ppsd.add_npz, ppsd._add_npz): with NamedTemporaryFile() as tf: filename = tf.name with open(filename, 'wb') as fh: np.savez(fh, **items) with self.assertRaises(ObsPyException) as e: method(filename) self.assertEqual(str(e.exception), msg)
def test_can_read_npz_without_pickle(self): """ Ensures that a default PPSD can be written and read without having to allow np.load the use of pickle. See #2409. """ # Init a test PPSD and empty byte stream. ppsd = PPSD.load_npz(self.example_ppsd_npz) byte_me = io.BytesIO() # Save PPSD to byte stream and rewind to 0. ppsd.save_npz(byte_me) byte_me.seek(0) # Load dict, will raise an exception if pickle is needed. loaded_dict = dict(np.load(byte_me, allow_pickle=False)) self.assertIsInstance(loaded_dict, dict)
def test_can_read_npz_without_pickle(self): """ Ensures that a default PPSD can be written and read without having to allow np.load the use of pickle, or that a helpful error message is raised if allow_pickle is required. See #2409. """ # Init a test PPSD and empty byte stream. ppsd = PPSD.load_npz(self.example_ppsd_npz, allow_pickle=True) byte_me = io.BytesIO() # Save PPSD to byte stream and rewind to 0. ppsd.save_npz(byte_me) byte_me.seek(0) # Load dict, will raise an exception if pickle is needed. loaded_dict = dict(np.load(byte_me, **allow_pickle_false)) self.assertIsInstance(loaded_dict, dict) # the rest of the test is only relevant on numpy versions that have # allow_pickle kwarg (starting with version 1.10.0), older versions # will always allow pickle and thus reading works if NUMPY_VERSION < [1, 10]: return # A helpful error message is issued when allow_pickle is needed. with self.assertRaises(ValueError) as context: PPSD.load_npz(self.example_ppsd_npz) self.assertIn('Loading PPSD results', str(context.exception))
def test_PPSD_save_and_load_npz(self): """ Test PPSD.load_npz() and PPSD.save_npz() """ _, paz = _get_sample_data() ppsd = _get_ppsd() # save results to npz file with NamedTemporaryFile(suffix=".npz") as tf: filename = tf.name # test saving and loading an uncompressed file ppsd.save_npz(filename) ppsd_loaded = PPSD.load_npz(filename, metadata=paz) for key in NPZ_STORE_KEYS: np.testing.assert_equal(getattr(ppsd, key), getattr(ppsd_loaded, key))
def test_ppsd_spectrogram_plot(self): """ Test spectrogram type plot of PPSD """ ppsd = PPSD.load_npz(self.example_ppsd_npz) # add some gaps in the middle for i in sorted(list(range(30, 40)) + list(range(8, 18)) + [4])[::-1]: ppsd._times_processed.pop(i) ppsd._binned_psds.pop(i) with ImageComparison(self.path_images, 'ppsd_spectrogram.png', reltol=1.5) as ic: fig = ppsd.plot_spectrogram(filename=None, show=False) fig.savefig(ic.name) with ImageComparison(self.path_images, 'ppsd_spectrogram.png', reltol=1.5) as ic: ppsd.plot_spectrogram(filename=ic.name, show=False)
def test_ppsd_save_and_load_npz(self): """ Test PPSD.load_npz() and PPSD.save_npz() """ _, paz = _get_sample_data() ppsd = _get_ppsd() # save results to npz file with NamedTemporaryFile(suffix=".npz") as tf: filename = tf.name # test saving and loading an uncompressed file ppsd.save_npz(filename) ppsd_loaded = PPSD.load_npz(filename, metadata=paz) for key in PPSD.NPZ_STORE_KEYS: if isinstance(getattr(ppsd, key), np.ndarray) or key == "_binned_psds": np.testing.assert_equal(getattr(ppsd, key), getattr(ppsd_loaded, key)) else: self.assertEqual(getattr(ppsd, key), getattr(ppsd_loaded, key))
def test_ppsd_spectrogram_plot(self): """ Test spectrogram type plot of PPSD Matplotlib version 3 shifts the x-axis labels but everything else looks the same. Skipping test for matplotlib >= 3 on 05/12/2018. """ ppsd = PPSD.load_npz(self.example_ppsd_npz, allow_pickle=True) # add some gaps in the middle for i in sorted(list(range(30, 40)) + list(range(8, 18)) + [4])[::-1]: ppsd._times_processed.pop(i) ppsd._binned_psds.pop(i) with ImageComparison(self.path_images, 'ppsd_spectrogram.png', reltol=1.5) as ic: fig = ppsd.plot_spectrogram(filename=None, show=False) fig.savefig(ic.name) with ImageComparison(self.path_images, 'ppsd_spectrogram.png', reltol=1.5) as ic: ppsd.plot_spectrogram(filename=ic.name, show=False)
def test_ppsd_save_and_load_npz(self): """ Test PPSD.load_npz() and PPSD.save_npz() """ _, paz = _get_sample_data() ppsd = _get_ppsd() # save results to npz file with NamedTemporaryFile(suffix=".npz") as tf: filename = tf.name # test saving and loading an uncompressed file ppsd.save_npz(filename) ppsd_loaded = PPSD.load_npz(filename, metadata=paz) for key in PPSD.NPZ_STORE_KEYS: if isinstance(getattr(ppsd, key), np.ndarray) or \ key == '_binned_psds': np.testing.assert_equal(getattr(ppsd, key), getattr(ppsd_loaded, key)) else: self.assertEqual(getattr(ppsd, key), getattr(ppsd_loaded, key))
def test_ppsd_spectrogram_plot(self): """ Test spectrogram type plot of PPSD Matplotlib version 3 shifts the x-axis labels but everything else looks the same. Skipping test for matplotlib >= 3 on 05/12/2018. """ ppsd = PPSD.load_npz(self.example_ppsd_npz) # add some gaps in the middle for i in sorted(list(range(30, 40)) + list(range(8, 18)) + [4])[::-1]: ppsd._times_processed.pop(i) ppsd._binned_psds.pop(i) with ImageComparison(self.path_images, 'ppsd_spectrogram.png', reltol=1.5) as ic: fig = ppsd.plot_spectrogram(filename=None, show=False) fig.savefig(ic.name) with ImageComparison(self.path_images, 'ppsd_spectrogram.png', reltol=1.5) as ic: ppsd.plot_spectrogram(filename=ic.name, show=False)
def test_ppsd_temporal_plot(self, state, image_path): """ Test plot of several period bins over time """ ppsd = PPSD.load_npz(state.example_ppsd_npz, allow_pickle=True) restrictions = { 'starttime': UTCDateTime(2011, 2, 6, 1, 1), 'endtime': UTCDateTime(2011, 2, 7, 21, 12), 'year': [2011], 'time_of_weekday': [(-1, 2, 23)] } # add some gaps in the middle for i in sorted(list(range(30, 40)) + list(range(8, 18)) + [4])[::-1]: ppsd._times_processed.pop(i) ppsd._binned_psds.pop(i) fig = ppsd.plot_temporal([0.1, 1, 10], filename=None, show=False, **restrictions) fig.savefig(image_path)
newpow *= a newpow /= 10**9 return 20. * np.log10(newpow) per, NLNM = get_nlnm() per, NHNM = get_nhnm() fig = plt.figure(1, figsize=(10, 14)) for idx, npz in enumerate(npzs): if 'QSPA' in npz: continue plt.subplot(2, 1, 1) ppsd = PPSD.load_npz(npz) per10, pow10 = ppsd.get_percentile(10.) per50, pow50 = ppsd.get_percentile(90.) if 'mvec' not in vars(): mvec = pow10 Mvec = pow50 else: mvec = np.minimum(pow10, mvec) Mvec = np.maximum(pow50, Mvec) if idx == 0: plt.semilogx(per10, pow10, color='C0', alpha=0.5, label='10th Percentile')
def test_ppsd_w_iris_against_obspy_results(self): """ Test against results obtained after merging of #1108. """ # Read in ANMO data for one day st = read(os.path.join(self.path, 'IUANMO.seed')) # Read in metadata in various different formats paz = {'gain': 86298.5, 'zeros': [0, 0], 'poles': [-59.4313, -22.7121 + 27.1065j, -22.7121 + 27.1065j, -0.0048004, -0.073199], 'sensitivity': 3.3554*10**9} resp = os.path.join(self.path, 'IUANMO.resp') parser = Parser(os.path.join(self.path, 'IUANMO.dataless')) inv = read_inventory(os.path.join(self.path, 'IUANMO.xml')) # load expected results, for both only PAZ and full response filename_paz = os.path.join(self.path, 'IUANMO_ppsd_paz.npz') results_paz = PPSD.load_npz(filename_paz, metadata=None) filename_full = os.path.join(self.path, 'IUANMO_ppsd_fullresponse.npz') results_full = PPSD.load_npz(filename_full, metadata=None) # Calculate the PPSDs and test against expected results # first: only PAZ ppsd = PPSD(st[0].stats, paz) ppsd.add(st) # commented code to generate the test data: # ## np.savez(filename_paz, # ## **dict([(k, getattr(ppsd, k)) # ## for k in PPSD.NPZ_STORE_KEYS])) for key in PPSD.NPZ_STORE_KEYS_ARRAY_TYPES: np.testing.assert_allclose( getattr(ppsd, key), getattr(results_paz, key), rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_LIST_TYPES: for got, expected in zip(getattr(ppsd, key), getattr(results_paz, key)): np.testing.assert_allclose(got, expected, rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_SIMPLE_TYPES: if key in ["obspy_version", "numpy_version", "matplotlib_version"]: continue self.assertEqual(getattr(ppsd, key), getattr(results_paz, key)) # second: various methods for full response # (also test various means of initialization, basically testing the # decorator that maps the deprecated keywords) for metadata in [parser, inv, resp]: with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') ppsd = PPSD(st[0].stats, paz=metadata) self.assertEqual(len(w), 1) self.assertIs(w[0].category, ObsPyDeprecationWarning) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') ppsd = PPSD(st[0].stats, parser=metadata) self.assertEqual(len(w), 1) self.assertIs(w[0].category, ObsPyDeprecationWarning) ppsd = PPSD(st[0].stats, metadata) ppsd.add(st) # commented code to generate the test data: # ## np.savez(filename_full, # ## **dict([(k, getattr(ppsd, k)) # ## for k in PPSD.NPZ_STORE_KEYS])) for key in PPSD.NPZ_STORE_KEYS_ARRAY_TYPES: np.testing.assert_allclose( getattr(ppsd, key), getattr(results_full, key), rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_LIST_TYPES: for got, expected in zip(getattr(ppsd, key), getattr(results_full, key)): np.testing.assert_allclose(got, expected, rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_SIMPLE_TYPES: if key in ["obspy_version", "numpy_version", "matplotlib_version"]: continue self.assertEqual(getattr(ppsd, key), getattr(results_full, key))
def test_ppsd_w_iris_against_obspy_results(self): """ Test against results obtained after merging of #1108. """ # Read in ANMO data for one day st = read(os.path.join(self.path, 'IUANMO.seed')) # Read in metadata in various different formats paz = { 'gain': 86298.5, 'zeros': [0, 0], 'poles': [ -59.4313, -22.7121 + 27.1065j, -22.7121 + 27.1065j, -0.0048004, -0.073199 ], 'sensitivity': 3.3554 * 10**9 } resp = os.path.join(self.path, 'IUANMO.resp') parser = Parser(os.path.join(self.path, 'IUANMO.dataless')) inv = read_inventory(os.path.join(self.path, 'IUANMO.xml')) # load expected results, for both only PAZ and full response filename_paz = os.path.join(self.path, 'IUANMO_ppsd_paz.npz') results_paz = PPSD.load_npz(filename_paz, metadata=None) filename_full = os.path.join(self.path, 'IUANMO_ppsd_fullresponse.npz') results_full = PPSD.load_npz(filename_full, metadata=None) # Calculate the PPSDs and test against expected results # first: only PAZ ppsd = PPSD(st[0].stats, paz) ppsd.add(st) # commented code to generate the test data: # ## np.savez(filename_paz, # ## **dict([(k, getattr(ppsd, k)) # ## for k in PPSD.NPZ_STORE_KEYS])) for key in PPSD.NPZ_STORE_KEYS_ARRAY_TYPES: np.testing.assert_allclose(getattr(ppsd, key), getattr(results_paz, key), rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_LIST_TYPES: for got, expected in zip(getattr(ppsd, key), getattr(results_paz, key)): np.testing.assert_allclose(got, expected, rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_SIMPLE_TYPES: if key in ["obspy_version", "numpy_version", "matplotlib_version"]: continue self.assertEqual(getattr(ppsd, key), getattr(results_paz, key)) # second: various methods for full response for metadata in [parser, inv, resp]: ppsd = PPSD(st[0].stats, metadata) ppsd.add(st) # commented code to generate the test data: # ## np.savez(filename_full, # ## **dict([(k, getattr(ppsd, k)) # ## for k in PPSD.NPZ_STORE_KEYS])) for key in PPSD.NPZ_STORE_KEYS_ARRAY_TYPES: np.testing.assert_allclose(getattr(ppsd, key), getattr(results_full, key), rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_LIST_TYPES: for got, expected in zip(getattr(ppsd, key), getattr(results_full, key)): np.testing.assert_allclose(got, expected, rtol=1e-5) for key in PPSD.NPZ_STORE_KEYS_SIMPLE_TYPES: if key in [ "obspy_version", "numpy_version", "matplotlib_version" ]: continue self.assertEqual(getattr(ppsd, key), getattr(results_full, key))
def get_availability(massive_paths,startdate,enddate, save=None, figsize=(14,10)): """ It returns the masssive ppsds availability Parameters: ----------- masssive_paths: dict keys are contents: network.station.location.channel values are paths of the massive ppsds. startdate: UTCDateTime Start date to graph the figure. enddate: UTCDateTime End date to graph the figure. save: str Pathe to save the figure figsize: tuple Size of the figure """ UTC_startdate = startdate.matplotlib_date UTC_enddate = enddate.matplotlib_date fig = plt.figure(figsize=figsize) for i, (content,path) in enumerate(massive_paths.items()): try: ppsd = PPSD.load_npz(path) times = ppsd.times_data gaps = ppsd.times_gaps ax = plt.subplot(len(massive_paths),1,i+1) ax.set_yticks([]) ax.xaxis_date() net, sta, loc ,cha = content.split('.') ax.set_ylabel(sta+'\n'+loc) for j, (start, end) in enumerate(times): start = start.matplotlib_date end = end.matplotlib_date if j == 0: print(content) if UTC_startdate < start: ax.axvspan(UTC_startdate, start, 0, 1, facecolor="w", lw=0) elif j == len(times)-1: if end < UTC_enddate: ax.axvspan(end, UTC_enddate, 0, 1, facecolor="w", lw=0) ax.axvspan(start, end, 0, 1, facecolor="g", lw=0) for start, end in gaps: start = start.matplotlib_date end = end.matplotlib_date ax.axvspan(start, end, 0, 1, facecolor="w", lw=0) if i != len(massive_paths)-1: ax.set_xticks([]) else: for label in ax.get_xticklabels(): label.set_rotation(40) label.set_horizontalalignment('right') # ax.xaxis.set_major_formatter('%d %b %Y') except: pass if save != None: plt.savefig(save, dpi=300) else: plt.show()