def test_fy3d_250_resolutions(self):
"""Test loading data when only 250m resolutions are available."""
from satpy.tests.utils import make_dataid
from satpy.readers import load_reader
from satpy.dataset.data_dict import get_key
filenames = [
'tf2019071182739.FY3D-X_MERSI_0250M_L1B.HDF',
'tf2019071182739.FY3D-X_MERSI_GEOQK_L1B.HDF',
]
reader = load_reader(self.reader_configs)
files = reader.select_files_from_pathnames(filenames)
self.assertEqual(2, len(files))
reader.create_filehandlers(files)
# Make sure we have some files
self.assertTrue(reader.file_handlers)
# Verify that we have multiple resolutions for:
# - Bands 1-4 (visible)
# - Bands 24-25 (IR)
available_datasets = reader.available_dataset_ids
for band_name in ('1', '2', '3', '4', '24', '25'):
if band_name in ('24', '25'):
# don't know how to get radiance for IR bands
num_results = 2
else:
num_results = 3
ds_id = make_dataid(name=band_name, resolution=250)
res = get_key(ds_id, available_datasets,
num_results=num_results, best=False)
self.assertEqual(num_results, len(res))
ds_id = make_dataid(name=band_name, resolution=1000)
with pytest.raises(KeyError):
res = get_key(ds_id, available_datasets,
num_results=num_results, best=False)
res = reader.load(['1', '2', '3', '4', '5', '20', '24', '25'])
self.assertEqual(6, len(res))
self.assertRaises(KeyError, res.__getitem__, '5')
self.assertRaises(KeyError, res.__getitem__, '20')
self.assertEqual((2 * 40, 2048 * 2), res['1'].shape)
self.assertEqual('reflectance', res['1'].attrs['calibration'])
self.assertEqual('%', res['1'].attrs['units'])
self.assertEqual((2 * 40, 2048 * 2), res['2'].shape)
self.assertEqual('reflectance', res['2'].attrs['calibration'])
self.assertEqual('%', res['2'].attrs['units'])
self.assertEqual((2 * 40, 2048 * 2), res['3'].shape)
self.assertEqual('reflectance', res['3'].attrs['calibration'])
self.assertEqual('%', res['3'].attrs['units'])
self.assertEqual((2 * 40, 2048 * 2), res['4'].shape)
self.assertEqual('reflectance', res['4'].attrs['calibration'])
self.assertEqual('%', res['4'].attrs['units'])
self.assertEqual((2 * 40, 2048 * 2), res['24'].shape)
self.assertEqual('brightness_temperature', res['24'].attrs['calibration'])
self.assertEqual('K', res['24'].attrs['units'])
self.assertEqual((2 * 40, 2048 * 2), res['25'].shape)
self.assertEqual('brightness_temperature', res['25'].attrs['calibration'])
self.assertEqual('K', res['25'].attrs['units'])
def test_fy4a_1km_resolutions(self):
"""Test loading data when only 1km resolutions are available."""
from satpy.tests.utils import make_dsq
from satpy.readers import load_reader
from satpy.dataset.data_dict import get_key
filenames = [
'FY4A-_AGRI--_N_REGC_1047E_L1-_FDI-_MULT_NOM_20190603003000_20190603003416_1000M_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 1km
available_datasets = reader.available_dataset_ids
band_names = ['C' + '%02d' % ch for ch in np.linspace(1, 3, 3)]
for band_name in band_names:
for resolution in [500, 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=1000)
res = get_key(ds_q, available_datasets, num_results=0, best=False)
self.assertEqual(2, len(res))
res = reader.load(band_names)
self.assertEqual(3, len(res))
expected = {
1:
np.array([[2.01, 2.02, 2.03, 2.04, 2.05],
[2.06, 2.07, 2.08, 2.09, 2.1]]),
2:
np.array([[4.03, 4.06, 4.09, 4.12, 4.15],
[4.18, 4.21, 4.24, 4.27, 4.3]]),
3:
np.array([[6.05, 6.1, 6.15, 6.2, 6.25],
[6.3, 6.35, 6.4, 6.45, 6.5]])
}
for index, band_name in enumerate(band_names):
self.assertEqual(1, res[band_name].attrs['sensor'].islower())
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[index + 1],
equal_nan=True))
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
from satpy.dataset.data_dict import 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_get_key(self):
"""Test 'get_key' special functions."""
from satpy.dataset import DataQuery
d = self.test_dict
res1 = get_key(make_dataid(name='test4'), d, calibration='radiance')
res2 = get_key(make_dataid(name='test4'),
d,
calibration='radiance',
num_results=0)
res3 = get_key(make_dataid(name='test4'),
d,
calibration='radiance',
num_results=3)
self.assertEqual(len(res2), 1)
self.assertEqual(len(res3), 1)
res2 = res2[0]
res3 = res3[0]
self.assertEqual(res1, res2)
self.assertEqual(res1, res3)
res1 = get_key('test4', d, query=DataQuery(polarization='V'))
self.assertEqual(
res1,
make_dataid(name='test4', calibration='radiance',
polarization='V'))
res1 = get_key(0.5, d, query=DataQuery(resolution=500))
self.assertEqual(
res1,
make_dataid(name='testh', wavelength=(0, 0.5, 1), resolution=500))
res1 = get_key('test6', d, query=DataQuery(level=100))
self.assertEqual(res1, make_dataid(name='test6', level=100))
res1 = get_key('test5', d)
res2 = get_key('test5', d, query=DataQuery(modifiers=('mod2', )))
res3 = get_key('test5',
d,
query=DataQuery(modifiers=(
'mod1',
'mod2',
)))
self.assertEqual(res1, make_dataid(name='test5', modifiers=('mod2', )))
self.assertEqual(res1, res2)
self.assertNotEqual(res1, res3)
# more than 1 result when default is to ask for 1 result
self.assertRaises(KeyError, get_key, 'test4', d, best=False)
def get_key(self, match_key):
"""Get multiple fully-specified keys that match the provided query.
Args:
match_key (DataID): DataID or DataQuery of query parameters to use for
searching. Can also be a string representing the
dataset name or a number representing the dataset
wavelength.
"""
return get_key(match_key, self.keys())
def _check_keys_for_dsq(available_datasets, resolution_to_test):
from satpy.dataset.data_dict import get_key
from satpy.tests.utils import make_dsq
band_names = CHANNELS_BY_RESOLUTION[resolution_to_test]
for band_name in band_names:
ds_q = make_dsq(name=band_name, resolution=resolution_to_test)
res = get_key(ds_q, available_datasets, num_results=0, best=False)
if band_name < 'C07':
assert len(res) == 2
else:
assert len(res) == 3
def _assert_which_channels_are_loaded(available_datasets, band_names,
resolution_to_test):
from satpy.dataset.data_dict import get_key
from satpy.tests.utils import make_dsq
other_resolutions = RESOLUTION_LIST.copy()
other_resolutions.remove(resolution_to_test)
for band_name in band_names:
for resolution in other_resolutions:
ds_q = make_dsq(name=band_name, resolution=resolution)
with pytest.raises(KeyError):
_ = get_key(ds_q,
available_datasets,
num_results=0,
best=False)
ds_q = make_dsq(name=band_name, resolution=resolution_to_test)
res = get_key(ds_q, available_datasets, num_results=0, best=False)
if band_name < 'C07':
assert len(res) == 2
else:
assert len(res) == 3
def test_fy4a_2km_resolutions(self):
"""Test loading data when only 2km resolutions are available."""
from satpy.tests.utils import make_dsq
from satpy.readers import load_reader
from satpy.dataset.data_dict import get_key
filenames = [
'FY4A-_AGRI--_N_REGC_1047E_L1-_FDI-_MULT_NOM_20190603003000_20190603003416_2000M_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 2km
available_datasets = reader.available_dataset_ids
band_names = ['C' + '%02d' % ch for ch in np.linspace(1, 7, 7)]
for band_name in band_names:
for resolution in [500, 1000, 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=2000)
res = get_key(ds_q, available_datasets, num_results=0, best=False)
if band_name < 'C07':
self.assertEqual(2, len(res))
else:
self.assertEqual(3, len(res))
res = reader.load(band_names)
self.assertEqual(7, len(res))
expected = {
1:
np.array([[2.01, 2.02, 2.03, 2.04, 2.05],
[2.06, 2.07, 2.08, 2.09, 2.1]]),
2:
np.array([[4.03, 4.06, 4.09, 4.12, 4.15],
[4.18, 4.21, 4.24, 4.27, 4.3]]),
3:
np.array([[6.05, 6.1, 6.15, 6.2, 6.25],
[6.3, 6.35, 6.4, 6.45, 6.5]]),
4:
np.array([[8.07, 8.14, 8.21, 8.28, 8.35],
[8.42, 8.49, 8.56, 8.63, 8.7]]),
5:
np.array([[10.09, 10.18, 10.27, 10.36, 10.45],
[10.54, 10.63, 10.72, 10.81, 10.9]]),
6:
np.array([[12.11, 12.22, 12.33, 12.44, 12.55],
[12.66, 12.77, 12.88, 12.99, 13.1]]),
7:
np.array([[0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1., np.nan]])
}
for index, band_name in enumerate(band_names):
self.assertEqual((2, 5), res[band_name].shape)
if band_name < 'C07':
self.assertEqual('reflectance',
res[band_name].attrs['calibration'])
else:
self.assertEqual('brightness_temperature',
res[band_name].attrs['calibration'])
if band_name < 'C07':
self.assertEqual('%', res[band_name].attrs['units'])
else:
self.assertEqual('K', res[band_name].attrs['units'])
self.assertTrue(
np.allclose(res[band_name].values,
expected[index + 1],
equal_nan=True))
def test_fy4a_all_resolutions(self):
"""Test loading data when all resolutions are available."""
from satpy.tests.utils import make_dsq
from satpy.readers import load_reader
from satpy.dataset.data_dict import get_key
filenames = [
'FY4A-_AGRI--_N_REGC_1047E_L1-_FDI-_MULT_NOM_20190603003000_20190603003416_0500M_V0001.HDF',
'FY4A-_AGRI--_N_REGC_1047E_L1-_FDI-_MULT_NOM_20190603003000_20190603003416_1000M_V0001.HDF',
'FY4A-_AGRI--_N_REGC_1047E_L1-_FDI-_MULT_NOM_20190603003000_20190603003416_2000M_V0001.HDF',
'FY4A-_AGRI--_N_REGC_1047E_L1-_FDI-_MULT_NOM_20190603003000_20190603003416_4000M_V0001.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)
available_datasets = reader.available_dataset_ids
# 500m
band_names = ['C' + '%02d' % ch for ch in np.linspace(2, 2, 1)]
for band_name in band_names:
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))
# 1km
band_names = ['C' + '%02d' % ch for ch in np.linspace(1, 3, 3)]
for band_name in band_names:
ds_q = make_dsq(name=band_name, resolution=1000)
res = get_key(ds_q, available_datasets, num_results=0, best=False)
self.assertEqual(2, len(res))
# 2km
band_names = ['C' + '%02d' % ch for ch in np.linspace(1, 7, 7)]
for band_name in band_names:
ds_q = make_dsq(name=band_name, resolution=2000)
res = get_key(ds_q, available_datasets, num_results=0, best=False)
if band_name < 'C07':
self.assertEqual(2, len(res))
else:
self.assertEqual(3, len(res))
band_names = ['C' + '%02d' % ch for ch in np.linspace(1, 14, 14)]
res = reader.load(band_names)
self.assertEqual(14, len(res))
for band_name in band_names:
self.assertEqual((2, 5), res[band_name].shape)
if band_name < 'C07':
self.assertEqual('reflectance',
res[band_name].attrs['calibration'])
else:
self.assertEqual('brightness_temperature',
res[band_name].attrs['calibration'])
if band_name < 'C07':
self.assertEqual('%', res[band_name].attrs['units'])
else:
self.assertEqual('K', res[band_name].attrs['units'])
# check whether the data type of orbital_parameters is float
orbital_parameters = res[band_names[0]].attrs['orbital_parameters']
for attr in orbital_parameters:
self.assertEqual(type(orbital_parameters[attr]), float)
self.assertEqual(orbital_parameters['satellite_nominal_latitude'], 0.)
self.assertEqual(orbital_parameters['satellite_nominal_longitude'],
104.7)
self.assertEqual(orbital_parameters['satellite_nominal_altitude'],
3.5786E7)
