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'])
