def test_load_all_m_reflectances_no_geo(self): """Load all M band reflectances with no geo files provided""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVM01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM02_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM03_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM04_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM05_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM06_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM07_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM08_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM09_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM10_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM11_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) ds = r.load(['M01', 'M02', 'M03', 'M04', 'M05', 'M06', 'M07', 'M08', 'M09', 'M10', 'M11', ]) self.assertEqual(len(ds), 11) for d in ds.values(): self.assertEqual(d.attrs['calibration'], 'reflectance') self.assertEqual(d.attrs['units'], '%') self.assertNotIn('area', d.attrs)
def test_load_89ghz(self): """Test loading of 89GHz channels""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'GW1AM2_201607201808_128A_L1DLBTBR_1110110.h5', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) ds = r.load([ 'btemp_89.0av', 'btemp_89.0ah', 'btemp_89.0bv', 'btemp_89.0bh', ]) self.assertEqual(len(ds), 4) for d in ds.values(): self.assertEqual(d.attrs['calibration'], 'brightness_temperature') self.assertTupleEqual(d.shape, DEFAULT_FILE_SHAPE) self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area']) self.assertTupleEqual(d.attrs['area'].lons.shape, DEFAULT_FILE_SHAPE) self.assertTupleEqual(d.attrs['area'].lats.shape, DEFAULT_FILE_SHAPE)
def test_load_all_m_bts(self): """Load all M band brightness temperatures""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVM12_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM13_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM14_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM15_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM16_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GMTCO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) ds = r.load(['M12', 'M13', 'M14', 'M15', 'M16', ]) self.assertEqual(len(ds), 5) for d in ds.values(): self.assertEqual(d.attrs['calibration'], 'brightness_temperature') self.assertEqual(d.attrs['units'], 'K') self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area'])
def test_load_pressure_based(self): """Test loading all channels based on pressure""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'NUCAPS-EDR_v1r0_npp_s201603011158009_e201603011158307_c201603011222270.nc', ]) r.create_filehandlers(loadables) datasets = r.load(['Temperature', 'H2O', 'H2O_MR', 'O3', 'O3_MR', 'Liquid_H2O', 'Liquid_H2O_MR', 'CO', 'CO_MR', 'CH4', 'CH4_MR', 'CO2', 'HNO3', 'HNO3_MR', 'N2O', 'N2O_MR', 'SO2', 'SO2_MR', ]) self.assertEqual(len(datasets), 18) for v in datasets.values(): # self.assertNotEqual(v.info['resolution'], 0) self.assertEqual(v.ndim, 2)
def test_load_basic(self): """Test loading of basic channels""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'GW1AM2_201607201808_128A_L1DLBTBR_1110110.h5', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) ds = r.load([ 'btemp_10.7v', 'btemp_10.7h', 'btemp_6.9v', 'btemp_6.9h', 'btemp_7.3v', 'btemp_7.3h', 'btemp_18.7v', 'btemp_18.7h', 'btemp_23.8v', 'btemp_23.8h', 'btemp_36.5v', 'btemp_36.5h', ]) self.assertEqual(len(ds), 12) for d in ds.values(): self.assertEqual(d.attrs['calibration'], 'brightness_temperature') self.assertTupleEqual(d.shape, (DEFAULT_FILE_SHAPE[0], int(DEFAULT_FILE_SHAPE[1] // 2))) self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area']) self.assertTupleEqual(d.attrs['area'].lons.shape, (DEFAULT_FILE_SHAPE[0], DEFAULT_FILE_SHAPE[1] // 2)) self.assertTupleEqual(d.attrs['area'].lats.shape, (DEFAULT_FILE_SHAPE[0], DEFAULT_FILE_SHAPE[1] // 2))
def test_load_every_m_band_rad(self): """Test loading all M bands as radiances""" from satpy.readers import load_reader from satpy import DatasetID r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'VL1BM_snpp_d20161130_t012400_c20161130054822.nc', 'VGEOM_snpp_d20161130_t012400_c20161130054822.nc', ]) r.create_filehandlers(loadables) datasets = r.load([DatasetID('M01', calibration='radiance'), DatasetID('M02', calibration='radiance'), DatasetID('M03', calibration='radiance'), DatasetID('M04', calibration='radiance'), DatasetID('M05', calibration='radiance'), DatasetID('M06', calibration='radiance'), DatasetID('M07', calibration='radiance'), DatasetID('M08', calibration='radiance'), DatasetID('M09', calibration='radiance'), DatasetID('M10', calibration='radiance'), DatasetID('M11', calibration='radiance'), DatasetID('M12', calibration='radiance'), DatasetID('M13', calibration='radiance'), DatasetID('M14', calibration='radiance'), DatasetID('M15', calibration='radiance'), DatasetID('M16', calibration='radiance')]) self.assertEqual(len(datasets), 16) for v in datasets.values(): self.assertEqual(v.attrs['calibration'], 'radiance') self.assertEqual(v.attrs['units'], 'W m-2 um-1 sr-1')
def test_init(self): """Test basic init with no extra parameters.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'clavrx_npp_d20170520_t2053581_e2055223_b28822.level2.hdf', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_init(self): """Test basic init with no extra parameters.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'geocatL2.GOES-13.2015143.234500.nc', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_init(self): """Test basic init with no extra parameters.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'GW1AM2_201607201808_128A_L1DLBTBR_1110110.h5', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_init(self): """Test basic init with no extra parameters.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVI01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_init(self): """Test basic init with no extra parameters.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ '20170401174600-STAR-L2P_GHRSST-SSTskin-VIIRS_NPP-ACSPO_V2.40-v02.0-fv01.0.nc', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_init(self): """Test basic init with no extra parameters.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'VL1BM_snpp_d20161130_t012400_c20161130054822.nc', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_load_i_no_files(self): """Load I01 when only DNB files are provided""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVDNB_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GDNBO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) ds = r.load(['I01']) self.assertEqual(len(ds), 0)
def test_init(self): """Test basic init with no extra parameters.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'NUCAPS-EDR_v1r0_npp_s201603011158009_e201603011158307_c201603011222270.nc', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_init(self, pg): """Test basic init with no extra parameters.""" pg.open.return_value = FakeGRIB() from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'gfs.t18z.sfluxgrbf106.grib2', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_init_end_time_beyond(self): """Test basic init with end_time before the provided files.""" from satpy.readers import load_reader from datetime import datetime r = load_reader(self.reader_configs, filter_parameters={ 'end_time': datetime(2012, 2, 24) }) loadables = r.select_files_from_pathnames([ 'SVI01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) self.assertTrue(len(loadables), 0)
def test_init(self): """Test basic init with no extra parameters.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'OMPS-NPP-TC_EDR_SO2NRT-2016m0607t192031-o00001-2016m0607t192947.he5', 'OMPS-NPP-TC_EDR_TO3-v1.0-2016m0607t192031-o00001-2016m0607t192947.h5', ]) self.assertTrue(len(loadables), 2) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_load_individual_pressure_levels_single(self): """Test loading individual Temperature with specific levels""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'NUCAPS-EDR_v1r0_npp_s201603011158009_e201603011158307_c201603011222270.nc', ]) r.create_filehandlers(loadables) datasets = r.load(r.pressure_dataset_names['Temperature'], pressure_levels=(103.017,)) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.ndim, 1)
def test_load_pressure_levels_true(self): """Test loading Temperature with all pressure levels""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'NUCAPS-EDR_v1r0_npp_s201603011158009_e201603011158307_c201603011222270.nc', ]) r.create_filehandlers(loadables) datasets = r.load(['Temperature'], pressure_levels=True) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.ndim, 2) self.assertTupleEqual(v.shape, DEFAULT_PRES_FILE_SHAPE)
def test_load_dnb_radiance(self): """Test loading the main DNB dataset""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'VL1BD_snpp_d20161130_t012400_c20161130054822.nc', 'VGEOD_snpp_d20161130_t012400_c20161130054822.nc', ]) r.create_filehandlers(loadables) datasets = r.load(['DNB']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['calibration'], 'radiance') self.assertEqual(v.attrs['units'], 'W m-2 sr-1')
def test_load_all_m_radiances(self): """Load all M band radiances""" from satpy.readers import load_reader from satpy import DatasetID r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVM01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM02_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM03_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM04_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM05_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM06_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM07_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM08_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM09_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM10_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM11_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM12_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM13_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM14_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM15_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM16_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GMTCO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) ds = r.load([ DatasetID(name='M01', calibration='radiance', modifiers=None), DatasetID(name='M02', calibration='radiance', modifiers=None), DatasetID(name='M03', calibration='radiance', modifiers=None), DatasetID(name='M04', calibration='radiance', modifiers=None), DatasetID(name='M05', calibration='radiance', modifiers=None), DatasetID(name='M06', calibration='radiance', modifiers=None), DatasetID(name='M07', calibration='radiance', modifiers=None), DatasetID(name='M08', calibration='radiance', modifiers=None), DatasetID(name='M09', calibration='radiance', modifiers=None), DatasetID(name='M10', calibration='radiance', modifiers=None), DatasetID(name='M11', calibration='radiance', modifiers=None), DatasetID(name='M12', calibration='radiance', modifiers=None), DatasetID(name='M13', calibration='radiance', modifiers=None), DatasetID(name='M14', calibration='radiance', modifiers=None), DatasetID(name='M15', calibration='radiance', modifiers=None), DatasetID(name='M16', calibration='radiance', modifiers=None), ]) self.assertEqual(len(ds), 16) for d in ds.values(): self.assertEqual(d.attrs['calibration'], 'radiance') self.assertEqual(d.attrs['units'], 'W m-2 um-1 sr-1') self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area'])
def test_load_every_dataset(self): """Test loading all datasets""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ '20170401174600-STAR-L2P_GHRSST-SSTskin-VIIRS_NPP-ACSPO_V2.40-v02.0-fv01.0.nc', ]) r.create_filehandlers(loadables) datasets = r.load(['sst', 'satellite_zenith_angle', 'sea_ice_fraction', 'wind_speed']) self.assertEqual(len(datasets), 4) for d in datasets.values(): self.assertTupleEqual(d.shape, DEFAULT_FILE_SHAPE)
def test_init_start_end_time(self): """Test basic init with end_time before the provided files.""" from satpy.readers import load_reader from datetime import datetime r = load_reader(self.reader_configs, filter_parameters={ 'start_time': datetime(2012, 2, 24), 'end_time': datetime(2012, 2, 26) }) loadables = r.select_files_from_pathnames([ 'SVI01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) # make sure we have some files self.assertTrue(r.file_handlers)
def test_load_dnb(self): """Load DNB dataset""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVDNB_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GDNBO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) ds = r.load(['DNB']) self.assertEqual(len(ds), 1) for d in ds.values(): self.assertEqual(d.attrs['calibration'], 'radiance') self.assertEqual(d.attrs['units'], 'W m-2 sr-1') self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area'])
def test_load_pressure_levels_single_and_pressure_levels(self): """Test loading a specific Temperature level and pressure levels""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'NUCAPS-EDR_v1r0_npp_s201603011158009_e201603011158307_c201603011222270.nc', ]) r.create_filehandlers(loadables) datasets = r.load(['Temperature', 'Pressure_Levels'], pressure_levels=(103.017,)) self.assertEqual(len(datasets), 2) t_ds = datasets['Temperature'] self.assertEqual(t_ds.ndim, 2) self.assertTupleEqual(t_ds.shape, (DEFAULT_PRES_FILE_SHAPE[0], 1)) pl_ds = datasets['Pressure_Levels'] self.assertTupleEqual(pl_ds.shape, (1,))
def test_basic_load_to3(self): """Test basic load of to3 datasets""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'OMPS-NPP-TC_EDR_SO2NRT-2016m0607t192031-o00001-2016m0607t192947.he5', 'OMPS-NPP-TC_EDR_TO3-v1.0-2016m0607t192031-o00001-2016m0607t192947.h5', ]) self.assertTrue(len(loadables), 2) r.create_filehandlers(loadables) ds = r.load(['reflectivity_331', 'uvaerosol_index']) self.assertEqual(len(ds), 2) for d in ds.values(): self.assertEqual(d.attrs['resolution'], 50000) self.assertTupleEqual(d.shape, DEFAULT_FILE_SHAPE) self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area'])
def test_load_all(self): """Test loading all test datasets""" from satpy.readers import load_reader import xarray as xr r = load_reader(self.reader_configs) with mock.patch('satpy.readers.clavrx.SDS', xr.DataArray): loadables = r.select_files_from_pathnames([ 'clavrx_npp_d20170520_t2053581_e2055223_b28822.level2.hdf', ]) r.create_filehandlers(loadables) datasets = r.load(['variable1', 'variable2', 'variable3']) self.assertEqual(len(datasets), 3) for v in datasets.values(): self.assertIs(v.attrs['calibration'], None) self.assertEqual(v.attrs['units'], '1') self.assertIsNotNone(datasets['variable3'].attrs.get('flag_meanings'))
def test_load_every_m_band_bt(self): """Test loading all M band brightness temperatures""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'VL1BM_snpp_d20161130_t012400_c20161130054822.nc', 'VGEOM_snpp_d20161130_t012400_c20161130054822.nc', ]) r.create_filehandlers(loadables) datasets = r.load(['M12', 'M13', 'M14', 'M15', 'M16']) self.assertEqual(len(datasets), 5) for v in datasets.values(): self.assertEqual(v.attrs['calibration'], 'brightness_temperature') self.assertEqual(v.attrs['units'], 'K')
def test_load_all_old_goes(self): """Test loading all test datasets""" from satpy.readers import load_reader import xarray as xr r = load_reader(self.reader_configs) with mock.patch('satpy.readers.geocat.netCDF4.Variable', xr.DataArray): loadables = r.select_files_from_pathnames([ 'geocatL2.GOES-13.2015143.234500.nc', ]) r.create_filehandlers(loadables) datasets = r.load(['variable1', 'variable2', 'variable3']) self.assertEqual(len(datasets), 3) for v in datasets.values(): self.assertIs(v.attrs['calibration'], None) self.assertEqual(v.attrs['units'], '1') self.assertIsNotNone(datasets['variable3'].attrs.get('flag_meanings'))
def test_load_all(self, pg): """Test loading all test datasets""" pg.open.return_value = FakeGRIB() from satpy.readers import load_reader from satpy import DatasetID r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'gfs.t18z.sfluxgrbf106.grib2', ]) r.create_filehandlers(loadables) datasets = r.load([ DatasetID(name='t', level=100), DatasetID(name='t', level=200), DatasetID(name='t', level=300)]) self.assertEqual(len(datasets), 3) for v in datasets.values(): self.assertEqual(v.attrs['units'], 'K') self.assertIsInstance(v, xr.DataArray)
def test_load_all_m_reflectances_use_nontc(self): """Load all M band reflectances but use non-TC geolocation.""" from satpy.readers import load_reader r = load_reader(self.reader_configs, use_tc=False) loadables = r.select_files_from_pathnames([ 'SVM01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM02_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM03_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM04_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM05_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM06_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM07_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM08_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM09_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM10_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM11_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GMTCO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GMODO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) with touch_geo_files("GMTCO", "GMODO") as (geo_fn1, geo_fn2): r.create_filehandlers(loadables, {'use_tc': False}) ds = r.load(['M01', 'M02', 'M03', 'M04', 'M05', 'M06', 'M07', 'M08', 'M09', 'M10', 'M11', ]) self.assertEqual(len(ds), 11) for d in ds.values(): self._assert_reflectance_properties(d, with_area=True) self.assertEqual(d.attrs['area'].lons.min(), 15) self.assertEqual(d.attrs['area'].lats.min(), 55) self.assertEqual(d.attrs['area'].lons.attrs['rows_per_scan'], 16) self.assertEqual(d.attrs['area'].lats.attrs['rows_per_scan'], 16)
def test_load_all_m_reflectances_use_nontc2(self): """Load all M band reflectances but use non-TC geolocation (use_tc=None)""" from satpy.readers import load_reader r = load_reader(self.reader_configs, use_tc=None) loadables = r.select_files_from_pathnames([ 'SVM01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM02_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM03_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM04_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM05_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM06_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM07_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM08_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM09_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM10_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM11_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GMODO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) ds = r.load([ 'M01', 'M02', 'M03', 'M04', 'M05', 'M06', 'M07', 'M08', 'M09', 'M10', 'M11', ]) self.assertEqual(len(ds), 11) for d in ds.values(): self.assertEqual(d.info['calibration'], 'reflectance') self.assertEqual(d.info['units'], '%') self.assertIn('area', d.info) self.assertIsNotNone(d.info['area']) self.assertEqual(d.info['area'].lons.min(), 15) self.assertEqual(d.info['area'].lats.min(), 55)
def test_load_every_m_band_bt(self): """Test loading all M band brightness temperatures.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'VL1BM_snpp_d20161130_t012400_c20161130054822.nc', 'VGEOM_snpp_d20161130_t012400_c20161130054822.nc', ]) r.create_filehandlers(loadables) datasets = r.load(['M12', 'M13', 'M14', 'M15', 'M16']) assert len(datasets) == 5 for v in datasets.values(): assert v.attrs['calibration'] == 'brightness_temperature' assert v.attrs['units'] == 'K' assert v.attrs['rows_per_scan'] == 2 assert v.attrs['area'].lons.attrs['rows_per_scan'] == 2 assert v.attrs['area'].lats.attrs['rows_per_scan'] == 2 assert v.attrs['sensor'] == "viirs"
def test_load_wind_speed(self): """Load wind_speed dataset.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) with mock.patch('satpy.readers.smos_l2_wind.netCDF4.Variable', xr.DataArray): loadables = r.select_files_from_pathnames([ 'SM_OPER_MIR_SCNFSW_20200420T021649_20200420T035013_110_001_7.nc', ]) r.create_filehandlers(loadables) ds = r.load(['wind_speed']) self.assertEqual(len(ds), 1) for d in ds.values(): self.assertEqual(d.attrs['platform_shortname'], 'SM') self.assertEqual(d.attrs['sensor'], 'MIRAS') self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area']) self.assertIn('y', d.dims) self.assertIn('x', d.dims) self.assertEqual(d.shape, (719, 1440)) self.assertEqual(d.y[0].data, -89.75) self.assertEqual(d.y[d.shape[0] - 1].data, 89.75)
def test_load_bounds(self): """Load bounds dataset""" from satpy.readers import load_reader r = load_reader(self.reader_configs) with mock.patch('satpy.readers.tropomi_l2.netCDF4.Variable', xr.DataArray): loadables = r.select_files_from_pathnames([ 'S5P_OFFL_L2__NO2____20180709T170334_20180709T184504_03821_01_010002_20180715T184729.nc', ]) r.create_filehandlers(loadables) keys = ['latitude_bounds', 'longitude_bounds'] ds = r.load(keys) self.assertEqual(len(ds), 2) for key in keys: self.assertEqual(ds[key].attrs['platform_shortname'], 'S5P') self.assertIn('y', ds[key].dims) self.assertIn('x', ds[key].dims) self.assertIn('corner', ds[key].dims) # check assembled bounds left = np.vstack([ds[key][:, :, 0], ds[key][-1:, :, 3]]) right = np.vstack([ds[key][:, -1:, 1], ds[key][-1:, -1:, 2]]) dest = np.hstack([left, right]) dest = xr.DataArray(dest, dims=('y', 'x')) dest.attrs = ds[key].attrs self.assertEqual(dest.attrs['platform_shortname'], 'S5P') self.assertIn('y', dest.dims) self.assertIn('x', dest.dims) self.assertEqual(DEFAULT_FILE_SHAPE[0] + 1, dest.shape[0]) self.assertEqual(DEFAULT_FILE_SHAPE[1] + 1, dest.shape[1]) self.assertIsNone( np.testing.assert_array_equal(dest[:-1, :-1], ds[key][:, :, 0])) self.assertIsNone( np.testing.assert_array_equal(dest[-1, :-1], ds[key][-1, :, 3])) self.assertIsNone( np.testing.assert_array_equal( dest[:, -1], np.append(ds[key][:, -1, 1], ds[key][-1:, -1:, 2])))
def test_load_all_m_bts(self): """Load all M band brightness temperatures.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVM12_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM13_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM14_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM15_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM16_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GMTCO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) ds = r.load(['M12', 'M13', 'M14', 'M15', 'M16', ]) self.assertEqual(len(ds), 5) for d in ds.values(): self._assert_bt_properties(d, with_area=True)
def test_basic_load(self, filenames, loadable_ids, platform_name, reader_kw): """Test that variables are loaded properly.""" from satpy.readers import load_reader with mock.patch('satpy.readers.mirs.xr.open_dataset') as od: od.side_effect = fake_open_dataset r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames(filenames) r.create_filehandlers(loadables, fh_kwargs=reader_kw) with mock.patch('satpy.readers.mirs.read_atms_coeff_to_string') as \ fd, mock.patch('satpy.readers.mirs.retrieve'): fd.side_effect = fake_coeff_from_fn loaded_data_arrs = r.load(loadable_ids) assert len(loaded_data_arrs) == len(loadable_ids) test_data = fake_open_dataset(filenames[0]) for _data_id, data_arr in loaded_data_arrs.items(): data_arr = data_arr.compute() var_name = data_arr.attrs["name"] if var_name not in ['latitude', 'longitude']: self._check_area(data_arr) self._check_fill(data_arr) self._check_attrs(data_arr, platform_name) input_fake_data = test_data['BT'] if "btemp" in var_name \ else test_data[var_name] if "valid_range" in input_fake_data.attrs: valid_range = input_fake_data.attrs["valid_range"] self._check_valid_range(data_arr, valid_range) if "_FillValue" in input_fake_data.attrs: fill_value = input_fake_data.attrs["_FillValue"] self._check_fill_value(data_arr, fill_value) sensor = data_arr.attrs['sensor'] if reader_kw.get('limb_correction', True) and sensor == 'atms': fd.assert_called() else: fd.assert_not_called() assert data_arr.attrs['units'] == DEFAULT_UNITS[var_name]
def test_handling_bad_data_ir(self): """Test handling of bad data """ from satpy import DatasetID from satpy.readers import load_reader filenames = [ "W_XX-EUMETSAT-Darmstadt,IMG+SAT,MTI1+FCI-1C-RRAD-FDHSI-FD--" "CHK-BODY--L2P-NC4E_C_EUMT_20170410114434_GTT_DEV_" "20170410113925_20170410113934_N__C_0070_0067.nc", ] reader = load_reader(self.reader_configs) loadables = reader.select_files_from_pathnames(filenames) reader.create_filehandlers(loadables) with self.assertLogs( 'satpy.readers.fci_l1c_fdhsi', level="ERROR") as cm: reader.load([DatasetID( name="ir_123", calibration="brightness_temperature")]) self.assertRegex(cm.output[0], "cannot produce brightness temperatur")
def test_load_basic(self): """Test loading of basic channels""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'GW1AM2_202004160129_195B_L2SNSSWLB3300300.h5', ]) self.assertTrue(len(loadables), 1) r.create_filehandlers(loadables) ds = r.load(['ssw']) self.assertEqual(len(ds), 1) for d in ds.values(): self.assertTupleEqual( d.shape, (DEFAULT_FILE_SHAPE[0], int(DEFAULT_FILE_SHAPE[1]))) self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area']) self.assertTupleEqual( d.attrs['area'].lons.shape, (DEFAULT_FILE_SHAPE[0], DEFAULT_FILE_SHAPE[1])) self.assertTupleEqual( d.attrs['area'].lats.shape, (DEFAULT_FILE_SHAPE[0], DEFAULT_FILE_SHAPE[1]))
def test_load_all_i_reflectances_provided_geo(self): """Load all I band reflectances with geo files provided.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVI01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVI02_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVI03_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GITCO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) ds = r.load(['I01', 'I02', 'I03', ]) self.assertEqual(len(ds), 3) for d in ds.values(): self._assert_reflectance_properties(d, num_scans=32) self.assertEqual(d.attrs['area'].lons.min(), 5) self.assertEqual(d.attrs['area'].lats.min(), 45) self.assertEqual(d.attrs['area'].lons.attrs['rows_per_scan'], 32) self.assertEqual(d.attrs['area'].lats.attrs['rows_per_scan'], 32)
def test_bouding_box(self): """Test bouding box.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVI01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) # make sure we have some files expected_lons = [ 72.50243, 64.17125, 59.15234, 59.386833, 55.770416, 53.38952, 53.52594, 51.685738, 50.439102, 50.51393, 49.566296, 48.865967, 18.96082, -4.0238385, -7.05221, -10.247547, -13.951393, -18.062435, -22.608992, -27.620953, -33.091743, -39.28113, -17.749891 ] expected_lats = [ 81.67615, 79.49934, 77.278656, 77.393425, 74.977875, 72.62976, 72.74879, 70.2493, 67.84738, 67.969505, 65.545685, 63.103046, 61.853905, 55.169273, 57.062447, 58.77254, 60.465942, 62.036346, 63.465122, 64.72178, 65.78417, 66.66166, 79.00025 ] lons, lats = r.file_handlers['generic_file'][0].get_bounding_box() np.testing.assert_allclose(lons, expected_lons) np.testing.assert_allclose(lats, expected_lats)
def test_load_dnb_no_factors(self): """Load DNB dataset with no provided scale factors.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVDNB_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GDNBO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables, {'include_factors': False}) ds = r.load(['DNB']) self.assertEqual(len(ds), 1) for d in ds.values(): data = d.values # no scale factors, default factor 1 and offset 0 # multiply DNB by 10000 should mean the first value of 0 should be: # data * factor * 10000 + offset * 10000 # 0 * 1 * 10000 + 0 * 10000 => 0 self.assertEqual(data[0, 0], 0) # the second value of 1 should be: # 1 * 1 * 10000 + 0 * 10000 => 10000 self.assertEqual(data[0, 1], 10000) self._assert_dnb_radiance_properties(d, with_area=True)
def test_load_all_new_donor(self): """Test loading all test datasets with new donor.""" from satpy.readers import load_reader import xarray as xr r = load_reader(self.reader_configs) with mock.patch('satpy.readers.clavrx.SDS', xr.DataArray): loadables = r.select_files_from_pathnames([ 'clavrx_H08_20180806_1800.level2.hdf', ]) r.create_filehandlers(loadables) with mock.patch('satpy.readers.clavrx.glob') as g, mock.patch( 'satpy.readers.clavrx.netCDF4.Dataset') as d: g.return_value = ['fake_donor.nc'] x = np.linspace(-0.1518, 0.1518, 300) y = np.linspace(0.1518, -0.1518, 10) proj = mock.Mock( semi_major_axis=6378137, semi_minor_axis=6356752.3142, perspective_point_height=35791000, longitude_of_projection_origin=140.7, sweep_angle_axis='y', ) d.return_value = fake_donor = mock.MagicMock(variables={ 'goes_imager_projection': proj, 'x': x, 'y': y }, ) fake_donor.__getitem__.side_effect = lambda key: fake_donor.variables[ key] datasets = r.load(['variable1', 'variable2', 'variable3']) self.assertEqual(len(datasets), 3) for v in datasets.values(): self.assertIs(v.attrs['calibration'], None) self.assertEqual(v.attrs['units'], '1') self.assertIsInstance(v.attrs['area'], AreaDefinition) self.assertIsNotNone(datasets['variable3'].attrs.get('flag_meanings'))
def test_load_dataset(self): """Test loading all datasets""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'AFEDR_npp_d20180829_t2015451_e2017093_b35434_c20180829210527716708_cspp_dev.txt' ]) r.create_filehandlers(loadables) datasets = r.load(['detection_confidence']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['units'], '%') datasets = r.load(['T13']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['units'], 'K') datasets = r.load(['power']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['units'], 'MW')
def test_load_all_m_reflectances_provided_geo(self): """Load all M band reflectances with geo files provided""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVM01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM02_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM03_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM04_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM05_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM06_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM07_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM08_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM09_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM10_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM11_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'GMTCO_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) r.create_filehandlers(loadables) ds = r.load(['M01', 'M02', 'M03', 'M04', 'M05', 'M06', 'M07', 'M08', 'M09', 'M10', 'M11', ]) self.assertEqual(len(ds), 11) for d in ds.values(): self.assertEqual(d.attrs['calibration'], 'reflectance') self.assertEqual(d.attrs['units'], '%') self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area']) self.assertEqual(d.attrs['area'].lons.min(), 5) self.assertEqual(d.attrs['area'].lats.min(), 45)
def test_load_nonpressure_based(self): """Test loading all channels that aren't based on pressure""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'NUCAPS-EDR_v1r0_npp_s201603011158009_e201603011158307_c201603011222270.nc', ]) r.create_filehandlers(loadables) datasets = r.load([ 'Solar_Zenith', 'Topography', 'Land_Fraction', 'Surface_Pressure', 'Skin_Temperature', 'Quality_Flag', ]) self.assertEqual(len(datasets), 6) for v in datasets.values(): # self.assertNotEqual(v.info['resolution'], 0) # self.assertEqual(v.info['units'], 'degrees') self.assertEqual(v.ndim, 1) self.assertEqual(v.attrs['sensor'], ['CrIS', 'ATMS', 'VIIRS'])
def test_load_dnb_angles(self): """Test loading all DNB angle datasets.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'VL1BD_snpp_d20161130_t012400_c20161130054822.nc', 'VGEOD_snpp_d20161130_t012400_c20161130054822.nc', ]) r.create_filehandlers(loadables) datasets = r.load([ 'dnb_solar_zenith_angle', 'dnb_solar_azimuth_angle', 'dnb_satellite_zenith_angle', 'dnb_satellite_azimuth_angle', 'dnb_lunar_zenith_angle', 'dnb_lunar_azimuth_angle', ]) self.assertEqual(len(datasets), 6) for v in datasets.values(): self.assertEqual(v.attrs['units'], 'degrees') self.assertEqual(v.attrs['rows_per_scan'], 2) self.assertEqual(v.attrs['area'].lons.attrs['rows_per_scan'], 2) self.assertEqual(v.attrs['area'].lats.attrs['rows_per_scan'], 2)
def test_fy4a_500m_resolutions(self): """Test loading data when only 500m resolutions are available.""" from satpy.tests.utils import make_dsq from satpy.readers import load_reader, get_key filenames = [ 'FY4A-_AGRI--_N_REGC_1047E_L1-_FDI-_MULT_NOM_20190603003000_20190603003416_0500M_V0001.HDF', ] reader = load_reader(self.reader_configs) files = reader.select_files_from_pathnames(filenames) self.assertEqual(1, len(files)) reader.create_filehandlers(files) # Make sure we have some files self.assertTrue(reader.file_handlers) # Verify that the resolution is only 500m available_datasets = reader.available_dataset_ids band_names = ['C' + '%02d' % ch for ch in np.linspace(2, 2, 1)] for band_name in band_names: for resolution in [1000, 2000, 4000]: ds_q = make_dsq(name=band_name, resolution=resolution) with pytest.raises(KeyError): res = get_key(ds_q, available_datasets, num_results=0, best=False) ds_q = make_dsq(name=band_name, resolution=500) res = get_key(ds_q, available_datasets, num_results=0, best=False) self.assertEqual(2, len(res)) res = reader.load(band_names) self.assertEqual(1, len(res)) expected = np.array([[2.01, 2.02, 2.03, 2.04, 2.05], [2.06, 2.07, 2.08, 2.09, 2.1]]) for band_name in band_names: self.assertEqual((2, 5), res[band_name].shape) self.assertEqual('reflectance', res[band_name].attrs['calibration']) self.assertEqual('%', res[band_name].attrs['units']) self.assertTrue(np.allclose(res[band_name].values, expected, equal_nan=True))
def test_area_definition_computation(self, reader_configs): """Test that the geolocation computation is correct.""" from satpy.readers import load_reader filenames = [ "W_XX-EUMETSAT-Darmstadt,IMG+SAT,MTI1+FCI-1C-RRAD-FDHSI-FD--" "CHK-BODY--L2P-NC4E_C_EUMT_20170410114434_GTT_DEV_" "20170410113925_20170410113934_N__C_0070_0067.nc", ] reader = load_reader(reader_configs) loadables = reader.select_files_from_pathnames(filenames) reader.create_filehandlers(loadables) res = reader.load(['ir_105', 'vis_06'], pad_data=False) # test that area_ids are harmonisation-conform <platform>_<instrument>_<service>_<resolution> assert res['vis_06'].attrs['area'].area_id == 'mtg_fci_fdss_1km' assert res['ir_105'].attrs['area'].area_id == 'mtg_fci_fdss_2km' area_def = res['ir_105'].attrs['area'] # test area extents computation np.testing.assert_array_almost_equal( np.array(area_def.area_extent), np.array([ -5568062.23065902, 5168057.7600648, 16704186.692027, 5568062.23065902 ])) # check that the projection is read in properly assert area_def.crs.coordinate_operation.method_name == 'Geostationary Satellite (Sweep Y)' assert area_def.crs.coordinate_operation.params[ 0].value == 0.0 # projection origin longitude assert area_def.crs.coordinate_operation.params[ 1].value == 35786400.0 # projection height assert area_def.crs.ellipsoid.semi_major_metre == 6378137.0 assert area_def.crs.ellipsoid.inverse_flattening == 298.257223563 assert area_def.crs.ellipsoid.is_semi_minor_computed
def test_load_basic(self): """Test loading of basic channels.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'GW1AM2_201607201808_128A_L1DLBTBR_1110110.h5', ]) self.assertEqual(len(loadables), 1) r.create_filehandlers(loadables) ds = r.load([ 'btemp_10.7v', 'btemp_10.7h', 'btemp_6.9v', 'btemp_6.9h', 'btemp_7.3v', 'btemp_7.3h', 'btemp_18.7v', 'btemp_18.7h', 'btemp_23.8v', 'btemp_23.8h', 'btemp_36.5v', 'btemp_36.5h', ]) self.assertEqual(len(ds), 12) for d in ds.values(): self.assertEqual(d.attrs['calibration'], 'brightness_temperature') self.assertTupleEqual( d.shape, (DEFAULT_FILE_SHAPE[0], int(DEFAULT_FILE_SHAPE[1] // 2))) self.assertIn('area', d.attrs) self.assertIsNotNone(d.attrs['area']) self.assertTupleEqual( d.attrs['area'].lons.shape, (DEFAULT_FILE_SHAPE[0], DEFAULT_FILE_SHAPE[1] // 2)) self.assertTupleEqual( d.attrs['area'].lats.shape, (DEFAULT_FILE_SHAPE[0], DEFAULT_FILE_SHAPE[1] // 2))
def test_fy3d_rad_calib(self): """Test loading data at radiance calibration.""" from satpy.tests.utils import make_dataid from satpy.readers import load_reader filenames = [ 'tf2019071182739.FY3D-X_MERSI_0250M_L1B.HDF', 'tf2019071182739.FY3D-X_MERSI_1000M_L1B.HDF', 'tf2019071182739.FY3D-X_MERSI_GEO1K_L1B.HDF', 'tf2019071182739.FY3D-X_MERSI_GEOQK_L1B.HDF', ] reader = load_reader(self.reader_configs) files = reader.select_files_from_pathnames(filenames) self.assertEqual(4, len(files)) reader.create_filehandlers(files) # Make sure we have some files self.assertTrue(reader.file_handlers) ds_ids = [] for band_name in ['1', '2', '3', '4', '5']: ds_ids.append(make_dataid(name=band_name, calibration='radiance')) res = reader.load(ds_ids) self.assertEqual(5, len(res)) self.assertEqual((2 * 40, 2048 * 2), res['1'].shape) self.assertEqual('radiance', res['1'].attrs['calibration']) self.assertEqual('mW/ (m2 cm-1 sr)', res['1'].attrs['units']) self.assertEqual((2 * 40, 2048 * 2), res['2'].shape) self.assertEqual('radiance', res['2'].attrs['calibration']) self.assertEqual('mW/ (m2 cm-1 sr)', res['2'].attrs['units']) self.assertEqual((2 * 40, 2048 * 2), res['3'].shape) self.assertEqual('radiance', res['3'].attrs['calibration']) self.assertEqual('mW/ (m2 cm-1 sr)', res['3'].attrs['units']) self.assertEqual((2 * 40, 2048 * 2), res['4'].shape) self.assertEqual('radiance', res['4'].attrs['calibration']) self.assertEqual('mW/ (m2 cm-1 sr)', res['4'].attrs['units']) self.assertEqual((2 * 10, 2048), res['5'].shape) self.assertEqual('radiance', res['5'].attrs['calibration']) self.assertEqual('mW/ (m2 cm-1 sr)', res['5'].attrs['units'])
def test_load_data(self): """Test loading data.""" from satpy.readers import load_reader # Filename to test, needed for start and end times filenames = [ '3B-HHR.MS.MRG.3IMERG.20200131-S233000-E235959.1410.V06B.HDF5', ] # Expected projection in area def pdict = {'proj': 'longlat', 'datum': 'WGS84', 'no_defs': None, 'type': 'crs'} reader = load_reader(self.reader_configs) files = reader.select_files_from_pathnames(filenames) self.assertEqual(1, len(files)) reader.create_filehandlers(files) # Make sure we have some files self.assertTrue(reader.file_handlers) res = reader.load(['IRprecipitation']) self.assertEqual(1, len(res)) self.assertEqual(res['IRprecipitation'].start_time, datetime(2020, 1, 31, 23, 30, 0)) self.assertEqual(res['IRprecipitation'].end_time, datetime(2020, 1, 31, 23, 59, 59)) self.assertEqual(res['IRprecipitation'].resolution, 0.1) self.assertEqual(res['IRprecipitation'].area.width, 3600) self.assertEqual(res['IRprecipitation'].area.height, 1800) self.assertEqual(res['IRprecipitation'].area.proj_dict, pdict) np.testing.assert_almost_equal(res['IRprecipitation'].area.area_extent, (-179.95, -89.95, 179.95, 89.95), 5)
def test_load_every_m_band_refl(self): """Test loading all M band reflectances""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'VL1BM_snpp_d20161130_t012400_c20161130054822.nc', 'VGEOM_snpp_d20161130_t012400_c20161130054822.nc', ]) r.create_filehandlers(loadables) datasets = r.load(['M01', 'M02', 'M03', 'M04', 'M05', 'M06', 'M07', 'M08', 'M09', 'M10', 'M11']) self.assertEqual(len(datasets), 11) for v in datasets.values(): self.assertEqual(v.info['calibration'], 'reflectance') self.assertEqual(v.info['units'], '%')
def test_load_dataset(self, csv_mock): """Test loading all datasets.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'AFEDR_j01_d20180829_t2015451_e2017093_b35434_c20180829210527716708_cspp_dev.txt' ]) r.create_filehandlers(loadables) datasets = r.load(['confidence_pct']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['units'], '%') datasets = r.load(['T13']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['units'], 'K') datasets = r.load(['power']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['units'], 'MW') self.assertEqual(v.attrs['platform_name'], 'NOAA-20') self.assertEqual(v.attrs['sensor'], 'VIIRS')
def test_excs(self, reader_configs): """Test that exceptions are raised where expected.""" from satpy.tests.utils import make_dataid from satpy.readers import load_reader filenames = [ "W_XX-EUMETSAT-Darmstadt,IMG+SAT,MTI1+FCI-1C-RRAD-FDHSI-FD--" "CHK-BODY--L2P-NC4E_C_EUMT_20170410114434_GTT_DEV_" "20170410113925_20170410113934_N__C_0070_0067.nc", ] reader = load_reader(reader_configs) loadables = reader.select_files_from_pathnames(filenames) fhs = reader.create_filehandlers(loadables) with pytest.raises(ValueError): fhs["fci_l1c_fdhsi"][0].get_dataset(make_dataid(name="invalid"), {}) with pytest.raises(ValueError): fhs["fci_l1c_fdhsi"][0]._get_dataset_quality(make_dataid(name="invalid"), {}) with pytest.raises(ValueError): fhs["fci_l1c_fdhsi"][0].get_dataset( make_dataid(name="ir_123", calibration="unknown"), {"units": "unknown"})
def test_load_reflectance(self, reader_configs): """Test loading with reflectance.""" from satpy.tests.utils import make_dataid from satpy.readers import load_reader filenames = [ "W_XX-EUMETSAT-Darmstadt,IMG+SAT,MTI1+FCI-1C-RRAD-FDHSI-FD--" "CHK-BODY--L2P-NC4E_C_EUMT_20170410114434_GTT_DEV_" "20170410113925_20170410113934_N__C_0070_0067.nc", ] reader = load_reader(reader_configs) loadables = reader.select_files_from_pathnames(filenames) reader.create_filehandlers(loadables) res = reader.load( [make_dataid(name=name, calibration="reflectance") for name in self._chans["solar"]]) assert 8 == len(res) for ch in self._chans["solar"]: assert res[ch].shape == (200, 11136) assert res[ch].dtype == np.float64 assert res[ch].attrs["calibration"] == "reflectance" assert res[ch].attrs["units"] == "%" numpy.testing.assert_array_equal(res[ch], 100 * 15 * 1 * np.pi / 50)
def test_load_all_m_reflectances_find_geo(self): """Load all M band reflectances with geo files not specified but existing.""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'SVM01_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM02_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM03_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM04_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM05_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM06_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM07_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM08_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM09_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM10_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', 'SVM11_npp_d20120225_t1801245_e1802487_b01708_c20120226002130255476_noaa_ops.h5', ]) with touch_geo_files("GMTCO", "GMODO") as (geo_fn1, geo_fn2): r.create_filehandlers(loadables) ds = r.load([ 'M01', 'M02', 'M03', 'M04', 'M05', 'M06', 'M07', 'M08', 'M09', 'M10', 'M11', ]) self.assertEqual(len(ds), 11) for d in ds.values(): self._assert_reflectance_properties(d, with_area=True)
def test_load_dataset(self, mock_obj): """Test loading all datasets""" from satpy.readers import load_reader r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'AFIMG_npp_d20180829_t2015451_e2017093_b35434_c20180829210527716708_cspp_dev.txt' ]) r.create_filehandlers(loadables) datasets = r.load(['confidence_cat']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['units'], '[7,8,9]->[lo,med,hi]') datasets = r.load(['T4']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['units'], 'K') datasets = r.load(['power']) self.assertEqual(len(datasets), 1) for v in datasets.values(): self.assertEqual(v.attrs['units'], 'MW') self.assertEqual(v.attrs['platform_name'], 'Suomi-NPP') self.assertEqual(v.attrs['sensor'], 'VIIRS')
def test_load_data_all_ambiguities(self): """Test loading data.""" from satpy.readers import load_reader filenames = [ 'W_XX-EUMETSAT-Darmstadt,SURFACE+SATELLITE,HY2B+SM_C_EUMP_20200326------_07077_o_250_l2b.h5', ] reader = load_reader(self.reader_configs) files = reader.select_files_from_pathnames(filenames) self.assertEqual(1, len(files)) reader.create_filehandlers(files) # Make sure we have some files self.assertTrue(reader.file_handlers) res = reader.load(['wind_speed', 'wind_dir', 'max_likelihood_est', 'model_dir', 'model_speed', 'num_ambigs', 'num_in_aft', 'num_in_fore', 'num_out_aft', 'num_out_fore', 'wvc_quality_flag']) self.assertEqual(11, len(res))
def test_area_def(self): """Test loading all datasets from an area of interest file.""" r = load_reader(self.reader_configs) loadables = r.select_files_from_pathnames([ 'GEO_L1B-MSG1_2004-12-29T12-15-00_G_VIS08_V1-04.hdf', ]) r.create_filehandlers(loadables) datasets = r.load(['VIS008']) test_area = { 'area_id': 'geosmsg', 'width': 10, 'height': 300, 'area_extent': (-5567248.2834071, -5570248.6866857, -5537244.2506213, -4670127.7031114) } for v in datasets.values(): self.assertEqual(v.attrs['area'].area_id, test_area['area_id']) self.assertEqual(v.attrs['area'].width, test_area['width']) self.assertEqual(v.attrs['area'].height, test_area['height']) np.testing.assert_almost_equal(v.attrs['area'].area_extent, test_area['area_extent'])