def test_add_variables(self):
ds = xr.Dataset()
SST_ENSEMBLE.add_variables(ds, 409, 12623, 11)
Assertions.assert_geolocation_variables(self,
ds,
409,
12623,
chunking=self.CHUNKING)
Assertions.assert_quality_flags(self,
ds,
409,
12623,
chunking=self.CHUNKING)
time = ds.variables["time"]
self.assertEqual((12623, ), time.shape)
self.assertEqual(-1, time.values[166])
self.assertEqual(4294967295, time.attrs["_FillValue"])
self.assertEqual("time", time.attrs["standard_name"])
self.assertEqual(
"Acquisition time in seconds since 1970-01-01 00:00:00",
time.attrs["long_name"])
self.assertEqual("s", time.attrs["units"])
sst = ds.variables["sst"]
self.assertEqual((11, 12623, 409), sst.shape)
self.assertTrue(np.isnan(sst.values[6, 198, 199]))
self.assertTrue(np.isnan(sst.attrs["_FillValue"]))
self.assertEqual("sea_surface_temperature", sst.attrs["standard_name"])
self.assertEqual("K", sst.attrs["units"])
self.assertEqual("longitude latitude", sst.attrs["coordinates"])
def testCreateTemplateEasy_HIRS4(self):
ds = FCDRWriter.createTemplateEasy('HIRS4', 211)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self.assertEqual(22, len(ds.data_vars))
# geolocation + flags
self._verify_geolocation_variables(ds)
self._verify_quality_flags(ds)
# sensor specific
self.assertIsNotNone(ds.variables["bt"])
self.assertIsNotNone(ds.variables["satellite_zenith_angle"])
self.assertIsNotNone(ds.variables["satellite_azimuth_angle"])
self.assertIsNotNone(ds.variables["solar_zenith_angle"])
self.assertIsNotNone(ds.variables["solar_azimuth_angle"])
self.assertIsNotNone(ds.variables["scanline"])
self.assertIsNotNone(ds.variables["time"])
self.assertIsNotNone(ds.variables["data_quality_bitmask"])
self.assertIsNotNone(ds.variables["quality_scanline_bitmask"])
self.assertIsNotNone(ds.variables["quality_channel_bitmask"])
self.assertIsNotNone(ds.variables["SRF_weights"])
self.assertIsNotNone(ds.variables["SRF_wavelengths"])
self.assertIsNotNone(ds.variables["scanline_map_to_origl1bfile"])
self.assertIsNotNone(ds.variables["scanline_origl1b"])
self._assert_HIRS_easy_uncertainties(ds)
def testCreateTemplateFull_AMSUB(self):
ds = FCDRWriter.createTemplateFull('AMSUB', 2562)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self.assertEqual(27, len(ds.data_vars))
# geolocation + flags
self._verify_geolocation_variables(ds)
self._verify_quality_flags(ds)
# sensor specific
self._verify_amsub_specific_variables(ds)
# full FCDR variables
self.assertIsNotNone(ds.variables["u_btemps"])
self.assertIsNotNone(ds.variables["u_syst_btemps"])
self.assertIsNotNone(ds.variables["u_random_btemps"])
self.assertIsNotNone(ds.variables["u_instrtemp"])
self.assertIsNotNone(ds.variables["u_latitude"])
self.assertIsNotNone(ds.variables["u_longitude"])
self.assertIsNotNone(ds.variables["u_satellite_azimuth_angle"])
self.assertIsNotNone(ds.variables["u_satellite_zenith_angle"])
self.assertIsNotNone(ds.variables["u_solar_azimuth_angle"])
self.assertIsNotNone(ds.variables["u_solar_zenith_angle"])
def testCreateTemplateEasy_MVIRI(self):
ds = FCDRWriter.createTemplateEasy('MVIRI', 5000)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self._verify_quality_flags(ds)
self.assertEqual(40, len(ds.data_vars))
# sensor specific
self.assertIsNotNone(ds.variables["time"])
self.assertIsNotNone(ds.variables["SRF_weights"])
self.assertIsNotNone(ds.variables["SRF_frequencies"])
self.assertIsNotNone(
ds.variables["covariance_spectral_response_function_vis"])
self.assertIsNotNone(ds.variables["u_spectral_response_function_ir"])
self.assertIsNotNone(ds.variables["u_spectral_response_function_wv"])
self.assertIsNotNone(ds.variables["solar_zenith_angle"])
self.assertIsNotNone(ds.variables["solar_azimuth_angle"])
self.assertIsNotNone(ds.variables["satellite_azimuth_angle"])
self.assertIsNotNone(ds.variables["satellite_zenith_angle"])
self.assertIsNotNone(ds.variables["count_ir"])
self.assertIsNotNone(ds.variables["count_wv"])
self.assertIsNotNone(ds.variables["data_quality_bitmask"])
self.assertIsNotNone(ds.variables["distance_sun_earth"])
self.assertIsNotNone(ds.variables["solar_irradiance_vis"])
self.assertIsNotNone(ds.variables["u_solar_irradiance_vis"])
self.assertIsNotNone(ds.variables["a_ir"])
self.assertIsNotNone(ds.variables["b_ir"])
self.assertIsNotNone(ds.variables["u_a_ir"])
self.assertIsNotNone(ds.variables["u_b_ir"])
self.assertIsNotNone(ds.variables["a_wv"])
self.assertIsNotNone(ds.variables["b_wv"])
self.assertIsNotNone(ds.variables["u_a_wv"])
self.assertIsNotNone(ds.variables["u_b_wv"])
self.assertIsNotNone(ds.variables["bt_a_ir"])
self.assertIsNotNone(ds.variables["bt_b_ir"])
self.assertIsNotNone(ds.variables["bt_a_wv"])
self.assertIsNotNone(ds.variables["bt_b_wv"])
self.assertIsNotNone(ds.variables["years_since_launch"])
# easy FCDR uncertainties
self.assertIsNotNone(ds.variables["toa_bidirectional_reflectance_vis"])
self.assertIsNotNone(
ds.variables["u_independent_toa_bidirectional_reflectance"])
self.assertIsNotNone(
ds.variables["u_structured_toa_bidirectional_reflectance"])
self.assertIsNotNone(
ds.variables["u_common_toa_bidirectional_reflectance"])
self.assertIsNotNone(ds.variables["sub_satellite_latitude_start"])
self.assertIsNotNone(ds.variables["sub_satellite_longitude_start"])
self.assertIsNotNone(ds.variables["sub_satellite_latitude_end"])
self.assertIsNotNone(ds.variables["sub_satellite_longitude_end"])
self.assertIsNotNone(
ds.variables["channel_correlation_matrix_independent"])
self.assertIsNotNone(
ds.variables["channel_correlation_matrix_structured"])
def test_add_variables(self):
ds = xr.Dataset()
AOT.add_variables(ds, 409, 12876)
Assertions.assert_geolocation_variables(self,
ds,
409,
12876,
chunking=self.CHUNKING)
Assertions.assert_quality_flags(self,
ds,
409,
12876,
chunking=self.CHUNKING)
time = ds.variables["time"]
self.assertEqual((12876, ), time.shape)
self.assertEqual(-1, time.values[165])
self.assertEqual(4294967295, time.attrs["_FillValue"])
self.assertEqual("time", time.attrs["standard_name"])
self.assertEqual(
"Acquisition time in seconds since 1970-01-01 00:00:00",
time.attrs["long_name"])
self.assertEqual("s", time.attrs["units"])
aot = ds.variables["aot"]
self.assertEqual((12876, 409), aot.shape)
self.assertTrue(np.isnan(aot.values[176, 177]))
self.assertTrue(np.isnan(aot.attrs["_FillValue"]))
self.assertEqual("longitude latitude", aot.attrs["coordinates"])
u_ind_aot = ds.variables["u_independent_aot"]
self.assertEqual((12876, 409), u_ind_aot.shape)
self.assertTrue(np.isnan(u_ind_aot.values[178, 179]))
self.assertTrue(np.isnan(u_ind_aot.attrs["_FillValue"]))
self.assertEqual("Uncertainty of aot due to independent effects",
u_ind_aot.attrs["description"])
self.assertEqual("longitude latitude", u_ind_aot.attrs["coordinates"])
u_str_aot = ds.variables["u_structured_aot"]
self.assertEqual((12876, 409), u_str_aot.shape)
self.assertTrue(np.isnan(u_str_aot.values[180, 181]))
self.assertTrue(np.isnan(u_str_aot.attrs["_FillValue"]))
self.assertEqual("Uncertainty of aot due to structured effects",
u_str_aot.attrs["description"])
self.assertEqual("longitude latitude", u_str_aot.attrs["coordinates"])
u_com_aot = ds.variables["u_common_aot"]
self.assertEqual((12876, 409), u_com_aot.shape)
self.assertTrue(np.isnan(u_com_aot.values[182, 183]))
self.assertTrue(np.isnan(u_com_aot.attrs["_FillValue"]))
self.assertEqual("Uncertainty of aot due to common effects",
u_com_aot.attrs["description"])
self.assertEqual("longitude latitude", u_com_aot.attrs["coordinates"])
def test_add_variables(self):
ds = xr.Dataset()
Albedo.add_variables(ds, 5000, 5000)
Assertions.assert_quality_flags(self,
ds,
5000,
5000,
chunking=self.CHUNKING)
time = ds.variables["time"]
self.assertEqual((5000, ), time.shape)
self.assertEqual(-1, time.values[165])
self.assertEqual(-1, time.attrs["_FillValue"])
self.assertEqual("time", time.attrs["standard_name"])
self.assertEqual(
"Acquisition time in seconds since 1970-01-01 00:00:00",
time.attrs["long_name"])
self.assertEqual("s", time.attrs["units"])
albedo = ds.variables["surface_albedo"]
self.assertEqual((5000, 5000), albedo.shape)
self.assertTrue(np.isnan(albedo.values[166, 167]))
self.assertTrue(np.isnan(albedo.attrs["_FillValue"]))
self.assertEqual("surface_albedo", albedo.attrs["standard_name"])
self.assertEqual("longitude latitude", albedo.attrs["coordinates"])
u_ind_albedo = ds.variables["u_independent_surface_albedo"]
self.assertEqual((5000, 5000), u_ind_albedo.shape)
self.assertTrue(np.isnan(u_ind_albedo.values[168, 169]))
self.assertTrue(np.isnan(u_ind_albedo.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of surface_albedo due to independent effects",
u_ind_albedo.attrs["description"])
self.assertEqual("longitude latitude",
u_ind_albedo.attrs["coordinates"])
u_str_albedo = ds.variables["u_structured_surface_albedo"]
self.assertEqual((5000, 5000), u_str_albedo.shape)
self.assertTrue(np.isnan(u_str_albedo.values[170, 171]))
self.assertTrue(np.isnan(u_str_albedo.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of surface_albedo due to structured effects",
u_str_albedo.attrs["description"])
self.assertEqual("longitude latitude",
u_str_albedo.attrs["coordinates"])
u_com_albedo = ds.variables["u_common_surface_albedo"]
self.assertEqual((5000, 5000), u_com_albedo.shape)
self.assertTrue(np.isnan(u_com_albedo.values[170, 171]))
self.assertTrue(np.isnan(u_com_albedo.attrs["_FillValue"]))
self.assertEqual("Uncertainty of surface_albedo due to common effects",
u_com_albedo.attrs["description"])
self.assertEqual("longitude latitude",
u_com_albedo.attrs["coordinates"])
def test_add_original_variables(self):
ha = HIRSAssert()
ds = xr.Dataset()
HIRS2.add_original_variables(ds, 6)
Assertions.assert_geolocation_variables(self, ds, 56, 6, chunking=CHUNKING_2D)
Assertions.assert_quality_flags(self, ds, 56, 6, chunking=CHUNKING_2D)
ha.assert_bt_variable(ds, chunking=(10, 6, 56))
ha.assert_common_angles(ds, chunking=CHUNKING_2D)
ha.assert_common_sensor_variables(ds, 102)
ha.assert_coordinates(ds)
def test_add_original_variables(self):
ha = HIRSAssert()
ds = xr.Dataset()
HIRS3.add_original_variables(ds, 6, srf_size=SRF_SIZE)
Assertions.assert_geolocation_variables(self, ds, 56, 6, chunking=CHUNKING_2D)
Assertions.assert_quality_flags(self, ds, 56, 6, chunking=CHUNKING_2D)
ha.assert_bt_variable(ds, chunking=(10, 6, 56))
ha.assert_common_angles(ds, chunking=CHUNKING_2D)
ha.assert_common_sensor_variables(ds, SRF_SIZE)
ha.assert_extended_quality_flags(ds)
ha.assert_coordinates(ds)
def testCreateTemplateFull_HIRS3(self):
ds = FCDRWriter.createTemplateFull('HIRS3', 209)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self.assertEqual(98, len(ds.data_vars))
# geolocation + flags
self._verify_geolocation_variables(ds)
self._verify_quality_flags(ds)
self._assert_HIRS_common_variables(ds)
self.assertIsNotNone(ds.variables["satellite_azimuth_angle"])
self.assertIsNotNone(ds.variables["solar_zenith_angle"])
self.assertIsNotNone(ds.variables["scanline_map_to_origl1bfile"])
self.assertIsNotNone(ds.variables["scanline_origl1b"])
self.assertIsNotNone(ds.variables["data_quality_bitmask"])
self.assertIsNotNone(ds.variables["c_earth"])
self.assertIsNotNone(ds.variables["L_earth"])
self.assertIsNotNone(ds.variables["u_L_earth_independent"])
self.assertIsNotNone(ds.variables["navigation_status"])
self.assertIsNotNone(ds.variables["platform_altitude"])
self.assertIsNotNone(ds.variables["platform_pitch_angle"])
self.assertIsNotNone(ds.variables["platform_roll_angle"])
self.assertIsNotNone(ds.variables["platform_yaw_angle"])
self.assertIsNotNone(ds.variables["quality_flags"])
self.assertIsNotNone(ds.variables["scan_angles"])
self.assertIsNotNone(ds.variables["l1b_scanline_number"])
self.assertIsNotNone(ds.variables["scanline_position"])
self.assertIsNotNone(
ds.variables["l1b_second_original_calibration_coefficients"])
self.assertIsNotNone(ds.variables["u_c_earth"])
self.assertIsNotNone(ds.variables["u_c_earth_chan_corr"])
self.assertIsNotNone(ds.variables["u_c_space"])
self.assertIsNotNone(ds.variables["u_c_space_chan_corr"])
self.assertIsNotNone(ds.variables["u_Earthshine"])
self.assertIsNotNone(ds.variables["u_O_Re"])
self.assertIsNotNone(ds.variables["u_O_TIWCT"])
self.assertIsNotNone(ds.variables["u_O_TPRT"])
self.assertIsNotNone(ds.variables["u_d_PRT"])
self.assertIsNotNone(ds.variables["u_electronics"])
self.assertIsNotNone(ds.variables["u_nonlinearity"])
self.assertIsNotNone(ds.variables["temp_corr_slope"])
self.assertIsNotNone(ds.variables["temp_corr_offset"])
self.assertIsNotNone(ds.variables["emissivity"])
self.assertIsNotNone(ds.variables["mnfrqualflags"])
def testCreateTemplateEasy_AVHRR(self):
ds = FCDRWriter.createTemplateEasy('AVHRR',
12198,
srf_size=13,
corr_dx=14,
corr_dy=15)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self.assertEqual(42, len(ds.data_vars))
# geolocation + flags
self._verify_geolocation_variables(ds)
self._verify_quality_flags(ds)
# sensor specific
self._verify_avhrr_specific_variables(ds)
# easy FCDR variables
self.assertIsNotNone(ds.variables["u_independent_Ch1"])
self.assertIsNotNone(ds.variables["u_structured_Ch1"])
self.assertIsNotNone(ds.variables["u_common_Ch1"])
self.assertIsNotNone(ds.variables["u_independent_Ch2"])
self.assertIsNotNone(ds.variables["u_structured_Ch2"])
self.assertIsNotNone(ds.variables["u_common_Ch2"])
self.assertIsNotNone(ds.variables["u_independent_Ch3a"])
self.assertIsNotNone(ds.variables["u_structured_Ch3a"])
self.assertIsNotNone(ds.variables["u_common_Ch3a"])
self.assertIsNotNone(ds.variables["u_independent_Ch3b"])
self.assertIsNotNone(ds.variables["u_structured_Ch3b"])
self.assertIsNotNone(ds.variables["u_common_Ch3b"])
self.assertIsNotNone(ds.variables["u_independent_Ch4"])
self.assertIsNotNone(ds.variables["u_structured_Ch4"])
self.assertIsNotNone(ds.variables["u_common_Ch4"])
self.assertIsNotNone(ds.variables["u_independent_Ch5"])
self.assertIsNotNone(ds.variables["u_structured_Ch5"])
self.assertIsNotNone(ds.variables["u_common_Ch5"])
self.assertIsNotNone(
ds.variables["channel_correlation_matrix_independent"])
self.assertIsNotNone(
ds.variables["channel_correlation_matrix_structured"])
self.assertIsNotNone(
ds.variables["cross_element_correlation_coefficients"])
self.assertIsNotNone(
ds.variables["cross_line_correlation_coefficients"])
def testCreateTemplateEasy_SSMT2(self):
ds = FCDRWriter.createTemplateEasy('SSMT2', 722)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self.assertEqual(15, len(ds.data_vars))
# geolocation + flags
self._verify_geolocation_variables(ds)
self._verify_quality_flags(ds)
# sensor specific
self.verify_SSMT2_specific_variables(ds)
# easy FCDR variables
self.assertIsNotNone(ds.variables["u_independent_tb"])
self.assertIsNotNone(ds.variables["u_structured_tb"])
def testCreateTemplateEasy_AMSUB(self):
ds = FCDRWriter.createTemplateEasy('AMSUB', 2561)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self.assertEqual(19, len(ds.data_vars))
# geolocation + flags
self._verify_geolocation_variables(ds)
self._verify_quality_flags(ds)
# sensor specific
self._verify_amsub_specific_variables(ds)
# easy FCDR variables
self.assertIsNotNone(ds.variables["u_independent_btemps"])
self.assertIsNotNone(ds.variables["u_structured_btemps"])
def test_add_variables(self):
ds = xr.Dataset()
SST.add_variables(ds, 409, 12877)
Assertions.assert_geolocation_variables(self, ds, 409, 12877, chunking=self.CHUNKING)
Assertions.assert_quality_flags(self, ds, 409, 12877, chunking=self.CHUNKING)
time = ds.variables["time"]
self.assertEqual((12877,), time.shape)
self.assertEqual(-1, time.values[166])
self.assertEqual(4294967295, time.attrs["_FillValue"])
self.assertEqual("time", time.attrs["standard_name"])
self.assertEqual("Acquisition time in seconds since 1970-01-01 00:00:00", time.attrs["long_name"])
self.assertEqual("s", time.attrs["units"])
sst = ds.variables["sst"]
self.assertEqual((12877, 409), sst.shape)
self.assertTrue(np.isnan(sst.values[196, 197]))
self.assertTrue(np.isnan(sst.attrs["_FillValue"]))
self.assertEqual("sea_surface_temperature", sst.attrs["standard_name"])
self.assertEqual("K", sst.attrs["units"])
self.assertEqual("longitude latitude", sst.attrs["coordinates"])
u_ind_sst = ds.variables["u_independent_sst"]
self.assertEqual((12877, 409), u_ind_sst.shape)
self.assertTrue(np.isnan(u_ind_sst.values[198, 199]))
self.assertTrue(np.isnan(u_ind_sst.attrs["_FillValue"]))
self.assertEqual("Uncertainty of sst due to independent effects", u_ind_sst.attrs["description"])
self.assertEqual("longitude latitude", u_ind_sst.attrs["coordinates"])
u_str_sst = ds.variables["u_structured_sst"]
self.assertEqual((12877, 409), u_str_sst.shape)
self.assertTrue(np.isnan(u_str_sst.values[200, 201]))
self.assertTrue(np.isnan(u_str_sst.attrs["_FillValue"]))
self.assertEqual("Uncertainty of sst due to structured effects", u_str_sst.attrs["description"])
self.assertEqual("longitude latitude", u_str_sst.attrs["coordinates"])
u_com_sst = ds.variables["u_common_sst"]
self.assertEqual((12877, 409), u_com_sst.shape)
self.assertTrue(np.isnan(u_com_sst.values[170, 171]))
self.assertTrue(np.isnan(u_com_sst.attrs["_FillValue"]))
self.assertEqual("Uncertainty of sst due to common effects", u_com_sst.attrs["description"])
self.assertEqual("longitude latitude", u_com_sst.attrs["coordinates"])
def testTemplateEasy_UTH(self):
ds = CDRWriter.createTemplate('UTH', 360, 120)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
Assertions.assert_cdr_global_attributes(self, ds.attrs)
Assertions.assert_gridded_global_attributes(self, ds.attrs)
def testCreateTemplateFull_SSMT2(self):
ds = FCDRWriter.createTemplateFull('SSMT2', 722)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self.assertEqual(21, len(ds.data_vars))
# geolocation + flags
self._verify_geolocation_variables(ds)
self._verify_quality_flags(ds)
# sensor specific
self.verify_SSMT2_specific_variables(ds)
# easy FCDR variables
self.assertIsNotNone(ds.variables["u_Temperature_misc_housekeeping"])
self.assertIsNotNone(ds.variables["u_cold_counts"])
self.assertIsNotNone(ds.variables["u_counts_to_tb_gain"])
self.assertIsNotNone(ds.variables["u_counts_to_tb_offset"])
self.assertIsNotNone(ds.variables["u_gain_control"])
self.assertIsNotNone(ds.variables["u_tb"])
self.assertIsNotNone(ds.variables["u_thermal_reference"])
self.assertIsNotNone(ds.variables["u_warm_counts"])
def test_add_easy_fcdr_variables(self):
delta_x = 16
delta_y = 17
ha = HIRSAssert()
ds = xr.Dataset()
HIRS4.add_easy_fcdr_variables(ds, 7, lut_size=24, corr_dx=delta_x, corr_dy=delta_y)
ha.assert_easy_fcdr_uncertainties(ds, chunking=CHUNKING_3D)
Assertions.assert_correlation_matrices(self, ds, NUM_CHANNELS)
Assertions.assert_lookup_tables(self, ds, NUM_CHANNELS, 24)
Assertions.assert_correlation_coefficients(self, ds, NUM_CHANNELS, delta_x, delta_y)
def test_add_easy_fcdr_variables(self):
delta_x = 14
delta_y = 15
ha = HIRSAssert()
ds = xr.Dataset()
HIRS2.add_easy_fcdr_variables(ds, 7, lut_size=22, corr_dx=delta_x, corr_dy=delta_y)
ha.assert_easy_fcdr_uncertainties(ds, chunking=(10, 7, 56))
Assertions.assert_correlation_matrices(self, ds, NUM_CHANNELS)
Assertions.assert_lookup_tables(self, ds, NUM_CHANNELS, 22)
Assertions.assert_correlation_coefficients(self, ds, NUM_CHANNELS, delta_x, delta_y)
def test_add_easy_fcdr_variables(self):
delta_x = 17
delta_y = 18
ds = xr.Dataset()
MVIRI.add_easy_fcdr_variables(ds,
8,
lut_size=37,
corr_dx=delta_x,
corr_dy=delta_y)
reflectance = ds.variables["toa_bidirectional_reflectance_vis"]
self.assertEqual((5000, 5000), reflectance.shape)
self.assertTrue(np.isnan(reflectance.data[3, 115]))
self.assertEqual("toa_bidirectional_reflectance_vis",
reflectance.attrs["standard_name"])
self.assertEqual(
"top of atmosphere bidirectional reflectance factor per pixel of the visible band with central wavelength 0.7",
reflectance.attrs["long_name"])
self.assertEqual("1", reflectance.attrs["units"])
self.assertEqual(np.uint16, reflectance.encoding['dtype'])
self.assertEqual(DefaultData.get_default_fill_value(np.uint16),
reflectance.encoding['_FillValue'])
self.assertEqual(3.05176E-05, reflectance.encoding['scale_factor'])
self.assertEqual(0.0, reflectance.encoding['add_offset'])
self.assertEqual(CHUNKING, reflectance.encoding["chunksizes"])
u_indep = ds.variables["u_independent_toa_bidirectional_reflectance"]
self.assertEqual((5000, 5000), u_indep.shape)
self.assertTrue(np.isnan(u_indep.data[118, 234]))
self.assertEqual("independent uncertainty per pixel",
u_indep.attrs["long_name"])
self.assertEqual("1", u_indep.attrs["units"])
self.assertEqual(np.uint16, u_indep.encoding['dtype'])
self.assertEqual(DefaultData.get_default_fill_value(np.uint16),
u_indep.encoding['_FillValue'])
self.assertEqual(3.05176E-05, u_indep.encoding['scale_factor'])
self.assertEqual(0.0, u_indep.encoding['add_offset'])
self.assertEqual(CHUNKING, u_indep.encoding["chunksizes"])
u_struct = ds.variables["u_structured_toa_bidirectional_reflectance"]
self.assertEqual((5000, 5000), u_struct.shape)
self.assertTrue(np.isnan(u_struct.data[119, 235]))
self.assertEqual("structured uncertainty per pixel",
u_struct.attrs["long_name"])
self.assertEqual("1", u_struct.attrs["units"])
self.assertEqual(np.uint16, u_struct.encoding['dtype'])
self.assertEqual(65535, u_struct.encoding['_FillValue'])
self.assertEqual(3.05176E-05, u_struct.encoding['scale_factor'])
self.assertEqual(0.0, u_struct.encoding['add_offset'])
self.assertEqual(CHUNKING, u_struct.encoding["chunksizes"])
self._assert_scalar_float_variable(
ds, "u_common_toa_bidirectional_reflectance",
"common uncertainty per slot", "1")
self._assert_scalar_float_variable(
ds, "sub_satellite_latitude_start",
"Latitude of the sub satellite point at image start",
"degrees_north")
self._assert_scalar_float_variable(
ds, "sub_satellite_longitude_start",
"Longitude of the sub satellite point at image start",
"degrees_east")
self._assert_scalar_float_variable(
ds, "sub_satellite_latitude_end",
"Latitude of the sub satellite point at image end",
"degrees_north")
self._assert_scalar_float_variable(
ds, "sub_satellite_longitude_end",
"Longitude of the sub satellite point at image end",
"degrees_east")
Assertions.assert_correlation_matrices(self, ds, 3)
channel = ds.coords["channel"]
self.assertEqual((3, ), channel.shape)
self.assertEqual("wv", channel[1])
Assertions.assert_lookup_tables(self, ds, 3, 37)
Assertions.assert_correlation_coefficients(self, ds, 3, delta_x,
delta_y)
def testTemplateEasy_ALBEDO(self):
ds = CDRWriter.createTemplate('ALBEDO', 5000, 5000)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
Assertions.assert_cdr_global_attributes(self, ds.attrs)
def testTemplateEasy_SST_ENSEMBLE(self):
ds = CDRWriter.createTemplate('SST_ENSEMBLE', 409, 11732, 20)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
Assertions.assert_cdr_global_attributes(self, ds.attrs)
def testTemplateEasy_AOT(self):
ds = CDRWriter.createTemplate('AOT', 409, 12941)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
Assertions.assert_cdr_global_attributes(self, ds.attrs)
def test_add_original_variables(self):
ds = xr.Dataset()
AVHRR.add_original_variables(ds, 5, srf_size=SRF_SIZE)
Assertions.assert_geolocation_variables(self,
ds,
409,
5,
chunking=CHUNKING)
Assertions.assert_quality_flags(self, ds, 409, 5, chunking=CHUNKING)
time = ds.variables["Time"]
self.assertEqual((5, ), time.shape)
self.assertTrue(np.isnan(time.data[2]))
self.assertTrue(np.isnan(time.attrs["_FillValue"]))
self.assertEqual("time", time.attrs["standard_name"])
self.assertEqual(
"Acquisition time in seconds since 1970-01-01 00:00:00",
time.attrs["long_name"])
self.assertEqual("s", time.attrs["units"])
sat_zenith = ds.variables["satellite_zenith_angle"]
self.assertEqual((5, 409), sat_zenith.shape)
self.assertTrue(np.isnan(sat_zenith.data[0, 5]))
self.assertEqual("sensor_zenith_angle",
sat_zenith.attrs["standard_name"])
self.assertEqual("degree", sat_zenith.attrs["units"])
self.assertEqual(9000, sat_zenith.attrs["valid_max"])
self.assertEqual(0, sat_zenith.attrs["valid_min"])
self.assertEqual("longitude latitude", sat_zenith.attrs["coordinates"])
self.assertEqual(np.int16, sat_zenith.encoding['dtype'])
self.assertEqual(DefaultData.get_default_fill_value(np.int16),
sat_zenith.encoding['_FillValue'])
self.assertEqual(0.01, sat_zenith.encoding['scale_factor'])
self.assertEqual(0.0, sat_zenith.encoding['add_offset'])
self.assertEqual(CHUNKING, sat_zenith.encoding["chunksizes"])
sol_zenith = ds.variables["solar_zenith_angle"]
self.assertEqual((5, 409), sol_zenith.shape)
self.assertTrue(np.isnan(sol_zenith.data[0, 7]))
self.assertEqual("solar_zenith_angle",
sol_zenith.attrs["standard_name"])
self.assertEqual("degree", sol_zenith.attrs["units"])
self.assertEqual(18000, sol_zenith.attrs["valid_max"])
self.assertEqual(0, sol_zenith.attrs["valid_min"])
self.assertEqual("longitude latitude", sol_zenith.attrs["coordinates"])
self.assertEqual(np.int16, sol_zenith.encoding['dtype'])
self.assertEqual(DefaultData.get_default_fill_value(np.int16),
sol_zenith.encoding['_FillValue'])
self.assertEqual(0.01, sol_zenith.encoding['scale_factor'])
self.assertEqual(0.0, sol_zenith.encoding['add_offset'])
self.assertEqual(CHUNKING, sol_zenith.encoding["chunksizes"])
ch1 = ds.variables["Ch1"]
self._assert_correct_refl_variable(ch1, "Channel 1 Reflectance")
ch2 = ds.variables["Ch2"]
self._assert_correct_refl_variable(ch2, "Channel 2 Reflectance")
ch3a = ds.variables["Ch3a"]
self._assert_correct_refl_variable(ch3a, "Channel 3a Reflectance")
ch3b = ds.variables["Ch3b"]
self._assert_correct_bt_variable(ch3b,
"Channel 3b Brightness Temperature")
ch4 = ds.variables["Ch4"]
self._assert_correct_bt_variable(ch4,
"Channel 4 Brightness Temperature")
ch5 = ds.variables["Ch5"]
self._assert_correct_bt_variable(ch5,
"Channel 5 Brightness Temperature")
dq_bitmask = ds.variables["data_quality_bitmask"]
self.assertEqual((5, 409), dq_bitmask.shape)
self.assertEqual(0, dq_bitmask.data[1, 23])
self.assertEqual("status_flag", dq_bitmask.attrs["standard_name"])
self.assertEqual("bitmask for quality per pixel",
dq_bitmask.attrs["long_name"])
self.assertEqual("1,2", dq_bitmask.attrs["flag_masks"])
self.assertEqual(
"bad_geolocation_timing_err bad_calibration_radiometer_err",
dq_bitmask.attrs["flag_meanings"])
self.assertEqual("longitude latitude", dq_bitmask.attrs["coordinates"])
qs_bitmask = ds.variables["quality_scanline_bitmask"]
self.assertEqual((5, ), qs_bitmask.shape)
self.assertEqual(0, qs_bitmask.data[1])
self.assertEqual("status_flag", qs_bitmask.attrs["standard_name"])
self.assertEqual("bitmask for quality per scanline",
qs_bitmask.attrs["long_name"])
self.assertEqual("1,2,4,8,16,32,64", qs_bitmask.attrs["flag_masks"])
self.assertEqual(
"do_not_use bad_time bad_navigation bad_calibration channel3a_present solar_contamination_failure solar_contamination",
qs_bitmask.attrs["flag_meanings"])
qc_bitmask = ds.variables["quality_channel_bitmask"]
self.assertEqual((5, 6), qc_bitmask.shape)
self.assertEqual(0, qc_bitmask.data[2, 1])
self.assertEqual("status_flag", qc_bitmask.attrs["standard_name"])
self.assertEqual("bitmask for quality per channel",
qc_bitmask.attrs["long_name"])
self.assertEqual("1,2", qc_bitmask.attrs["flag_masks"])
self.assertEqual("bad_channel some_pixels_not_detected_2sigma",
qc_bitmask.attrs["flag_meanings"])
srf_weights = ds.variables["SRF_weights"]
self.assertEqual((6, SRF_SIZE), srf_weights.shape)
self.assertTrue(np.isnan(srf_weights.data[3, 5]))
self.assertEqual("Spectral Response Function weights",
srf_weights.attrs["long_name"])
self.assertEqual(
"Per channel: weights for the relative spectral response function",
srf_weights.attrs["description"])
self.assertEqual(-32768, srf_weights.encoding['_FillValue'])
self.assertEqual(0.000033, srf_weights.encoding['scale_factor'])
srf_wls = ds.variables["SRF_wavelengths"]
self.assertEqual((6, SRF_SIZE), srf_wls.shape)
self.assertTrue(np.isnan(srf_wls.data[4, 6]))
self.assertEqual("Spectral Response Function wavelengths",
srf_wls.attrs["long_name"])
self.assertEqual(
"Per channel: wavelengths for the relative spectral response function",
srf_wls.attrs["description"])
self.assertEqual(-2147483648, srf_wls.encoding['_FillValue'])
self.assertEqual(0.0001, srf_wls.encoding['scale_factor'])
self.assertEqual("um", srf_wls.attrs["units"])
x = ds.coords["x"]
self.assertEqual((409, ), x.shape)
self.assertEqual(13, x[13])
y = ds.coords["y"]
self.assertEqual((5, ), y.shape)
self.assertEqual(4, y[4])
channel = ds.coords["channel"]
self.assertEqual((6, ), channel.shape)
self.assertEqual("Ch5", channel[5])
scnlin_map = ds.variables["scanline_map_to_origl1bfile"]
self.assertEqual((5, ), scnlin_map.shape)
self.assertEqual(255, scnlin_map[0])
self.assertEqual(255, scnlin_map.attrs['_FillValue'])
self.assertEqual("Indicator of original file",
scnlin_map.attrs['long_name'])
self.assertEqual(
"Indicator for mapping each line to its corresponding original level 1b file. See global attribute 'source' for the filenames. 0 corresponds to 1st listed file, 1 to 2nd file.",
scnlin_map.attrs['description'])
scnlin_orig = ds.variables["scanline_origl1b"]
self.assertEqual((5, ), scnlin_orig.shape)
self.assertEqual(-32767, scnlin_orig[1])
self.assertEqual(-32767, scnlin_orig.attrs['_FillValue'])
self.assertEqual("Original_Scan_line_number",
scnlin_orig.attrs['long_name'])
self.assertEqual(
"Original scan line numbers from corresponding l1b records",
scnlin_orig.attrs['description'])
def test_add_original_variables(self):
ds = xr.Dataset()
AMSUB_MHS.add_original_variables(ds, 4)
Assertions.assert_geolocation_variables(self, ds, 90, 4)
Assertions.assert_quality_flags(self, ds, 90, 4)
btemps = ds.variables["btemps"]
self.assertEqual((5, 4, 90), btemps.shape)
self.assertTrue(np.isnan(btemps.data[0, 2, 0]))
self.assertEqual("toa_brightness_temperature",
btemps.attrs["standard_name"])
self.assertEqual("K", btemps.attrs["units"])
self.assertEqual("chanqual qualind scanqual",
btemps.attrs["ancillary_variables"])
self.assertEqual(np.int32, btemps.encoding['dtype'])
self.assertEqual(-999999, btemps.encoding['_FillValue'])
self.assertEqual(0.01, btemps.encoding['scale_factor'])
self.assertEqual(0.0, btemps.encoding['add_offset'])
chanqual = ds.variables["chanqual"]
self.assertEqual((5, 4), chanqual.shape)
self.assertEqual(0, chanqual.data[0, 3])
self.assertEqual("status_flag", chanqual.attrs["standard_name"])
self.assertEqual("1, 2, 4, 8, 16, 32", chanqual.attrs["flag_masks"])
self.assertEqual(
"some_bad_prt_temps some_bad_space_view_counts some_bad_bb_counts no_good_prt_temps no_good_space_view_counts no_good_bb_counts",
chanqual.attrs["flag_meanings"])
instrtemp = ds.variables["instrtemp"]
self.assertEqual((4, ), instrtemp.shape)
self.assertTrue(np.isnan(instrtemp.data[0]))
self.assertEqual("K", instrtemp.attrs["units"])
self.assertEqual("instrument_temperature",
instrtemp.attrs["long_name"])
self.assertEqual(np.int32, instrtemp.encoding['dtype'])
self.assertEqual(DefaultData.get_default_fill_value(np.int32),
instrtemp.encoding['_FillValue'])
self.assertEqual(0.01, instrtemp.encoding['scale_factor'])
self.assertEqual(0.0, instrtemp.encoding['add_offset'])
qualind = ds.variables["qualind"]
self.assertEqual((4, ), qualind.shape)
self.assertEqual(0, qualind.data[1])
self.assertEqual("status_flag", qualind.attrs["standard_name"])
self.assertEqual(
"33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648",
qualind.attrs["flag_masks"])
self.assertEqual(
"instr_status_changed first_good_clock_update no_earth_loc no_calib data_gap_precedes time_seq_error not_use_scan",
qualind.attrs["flag_meanings"])
scanqual = ds.variables["scanqual"]
self.assertEqual((4, ), scanqual.shape)
self.assertEqual(0, scanqual.data[1])
self.assertEqual("status_flag", scanqual.attrs["standard_name"])
self.assertEqual(
"8, 16, 32, 64, 128, 1024, 2048, 4096, 8192, 16384, 32768, 1048576, 2097152, 4194304, 8388608",
scanqual.attrs["flag_masks"])
self.assertEqual(
"earth_loc_quest_ant_pos earth_loc_quest_reas earth_loc_quest_margin earth_loc_quest_time no_earth_loc_time uncalib_instr_mode uncalib_channels calib_marg_prt uncalib_bad_prt calib_few_scans uncalib_bad_time repeat_scan_times inconsistent_time time_field_bad time_field_inferred",
scanqual.attrs["flag_meanings"])
scnlin = ds.variables["scnlin"]
self.assertEqual((4, ), scnlin.shape)
self.assertEqual(-2147483647, scnlin.data[2])
self.assertEqual(-2147483647, scnlin.attrs["_FillValue"])
self.assertEqual("scanline", scnlin.attrs["long_name"])
scnlindy = ds.variables["scnlindy"]
self.assertEqual((4, ), scnlindy.shape)
self.assertEqual(-2147483647, scnlindy.data[3])
self.assertEqual(-2147483647, scnlindy.attrs["_FillValue"])
self.assertEqual("Acquisition day of year of scan",
scnlindy.attrs["long_name"])
scnlintime = ds.variables["scnlintime"]
self.assertEqual((4, ), scnlintime.shape)
self.assertEqual(-2147483647, scnlintime.data[0])
self.assertEqual(-2147483647, scnlintime.attrs["_FillValue"])
self.assertEqual(
"Acquisition time of scan in milliseconds since beginning of the day",
scnlintime.attrs["long_name"])
self.assertEqual("ms", scnlintime.attrs["units"])
scnlinyr = ds.variables["scnlinyr"]
self.assertEqual((4, ), scnlinyr.shape)
self.assertEqual(-2147483647, scnlinyr.data[1])
self.assertEqual(-2147483647, scnlinyr.attrs["_FillValue"])
self.assertEqual("Acquisition year of scan",
scnlinyr.attrs["long_name"])
sat_azimuth = ds.variables["satellite_azimuth_angle"]
self.assertEqual((4, 90), sat_azimuth.shape)
self.assertTrue(np.isnan(sat_azimuth.data[2, 1]))
self.assertEqual("sensor_azimuth_angle",
sat_azimuth.attrs["standard_name"])
self.assertEqual("degree", sat_azimuth.attrs["units"])
self.assertEqual(np.int32, sat_azimuth.encoding['dtype'])
self.assertEqual(-999999, sat_azimuth.encoding['_FillValue'])
self.assertEqual(0.01, sat_azimuth.encoding['scale_factor'])
self.assertEqual(0.0, sat_azimuth.encoding['add_offset'])
sat_zenith = ds.variables["satellite_zenith_angle"]
self.assertEqual((4, 90), sat_zenith.shape)
self.assertTrue(np.isnan(sat_zenith.data[2, 1]))
self.assertEqual("sensor_zenith_angle",
sat_zenith.attrs["standard_name"])
self.assertEqual("degree", sat_zenith.attrs["units"])
self.assertEqual(np.int32, sat_zenith.encoding['dtype'])
self.assertEqual(-999999, sat_zenith.encoding['_FillValue'])
self.assertEqual(0.01, sat_zenith.encoding['scale_factor'])
self.assertEqual(0.0, sat_zenith.encoding['add_offset'])
sol_azimuth = ds.variables["solar_azimuth_angle"]
self.assertEqual((4, 90), sol_azimuth.shape)
self.assertTrue(np.isnan(sol_azimuth.data[3, 0]))
self.assertEqual("solar_azimuth_angle",
sol_azimuth.attrs["standard_name"])
self.assertEqual("degree", sol_azimuth.attrs["units"])
self.assertEqual(np.int32, sol_azimuth.encoding['dtype'])
self.assertEqual(-999999, sol_azimuth.encoding['_FillValue'])
self.assertEqual(0.01, sol_azimuth.encoding['scale_factor'])
self.assertEqual(0.0, sol_azimuth.encoding['add_offset'])
sol_zenith = ds.variables["solar_zenith_angle"]
self.assertEqual((4, 90), sol_zenith.shape)
self.assertTrue(np.isnan(sol_zenith.data[3, 0]))
self.assertEqual("solar_zenith_angle",
sol_zenith.attrs["standard_name"])
self.assertEqual("degree", sol_zenith.attrs["units"])
self.assertEqual(np.int32, sol_zenith.encoding['dtype'])
self.assertEqual(-999999, sol_zenith.encoding['_FillValue'])
self.assertEqual(0.01, sol_zenith.encoding['scale_factor'])
self.assertEqual(0.0, sol_zenith.encoding['add_offset'])
acquisition_time = ds.variables["acquisition_time"]
self.assertEqual((4, ), acquisition_time.shape)
self.assertEqual(-2147483647, acquisition_time.data[2])
self.assertEqual(-2147483647, acquisition_time.attrs["_FillValue"])
self.assertEqual("time", acquisition_time.attrs["standard_name"])
self.assertEqual(
"Acquisition time in seconds since 1970-01-01 00:00:00",
acquisition_time.attrs["long_name"])
self.assertEqual("s", acquisition_time.attrs["units"])
def test_add_original_variables(self):
ds = xr.Dataset()
MVIRI.add_original_variables(ds, 5)
Assertions.assert_quality_flags(self, ds, 5000, 5000)
time = ds.variables["time"]
self.assertEqual((2500, 2500), time.shape)
self.assertEqual(4294967295, time.data[4, 117])
self.assertEqual(4294967295, time.attrs["_FillValue"])
self.assertEqual("time", time.attrs["standard_name"])
self.assertEqual("Acquisition time of pixel", time.attrs["long_name"])
self.assertEqual("seconds since 1970-01-01 00:00:00",
time.attrs["units"])
self.assertEqual(CHUNKING, time.encoding["chunksizes"])
self.assertEqual(-32768, time.attrs["add_offset"])
sol_azimuth = ds.variables["solar_azimuth_angle"]
self.assertEqual((500, 500), sol_azimuth.shape)
self.assertTrue(np.isnan(sol_azimuth.data[0, 111]))
self.assertEqual("solar_azimuth_angle",
sol_azimuth.attrs["standard_name"])
self.assertEqual("degree", sol_azimuth.attrs["units"])
self.assertEqual("true", sol_azimuth.attrs["tie_points"])
self.assertEqual(np.uint16, sol_azimuth.encoding['dtype'])
self.assertEqual(DefaultData.get_default_fill_value(np.uint16),
sol_azimuth.encoding['_FillValue'])
self.assertEqual(0.005493164, sol_azimuth.encoding['scale_factor'])
self.assertEqual(0.0, sol_azimuth.encoding['add_offset'])
self.assertEqual(CHUNKING, sol_azimuth.encoding["chunksizes"])
sol_zenith = ds.variables["solar_zenith_angle"]
self.assertEqual((500, 500), sol_zenith.shape)
self.assertTrue(np.isnan(sol_zenith.data[0, 112]))
self.assertEqual("solar_zenith_angle",
sol_zenith.attrs["standard_name"])
self.assertEqual("degree", sol_zenith.attrs["units"])
self.assertEqual("true", sol_zenith.attrs["tie_points"])
self.assertEqual(np.int16, sol_zenith.encoding['dtype'])
self.assertEqual(DefaultData.get_default_fill_value(np.int16),
sol_zenith.encoding['_FillValue'])
self.assertEqual(0.005493248, sol_zenith.encoding['scale_factor'])
self.assertEqual(0.0, sol_zenith.encoding['add_offset'])
self.assertEqual(CHUNKING, sol_zenith.encoding["chunksizes"])
sat_azimuth = ds.variables["satellite_azimuth_angle"]
self.assertEqual((500, 500), sat_azimuth.shape)
self.assertTrue(np.isnan(sat_azimuth.data[2, 114]))
self.assertEqual("sensor_azimuth_angle",
sat_azimuth.attrs["standard_name"])
self.assertEqual("sensor_azimuth_angle",
sat_azimuth.attrs["long_name"])
self.assertEqual("degree", sat_azimuth.attrs["units"])
self.assertEqual("true", sat_azimuth.attrs["tie_points"])
self.assertEqual(np.uint16, sat_azimuth.encoding['dtype'])
self.assertEqual(65535, sat_azimuth.encoding['_FillValue'])
self.assertEqual(0.01, sat_azimuth.encoding['scale_factor'])
self.assertEqual(0.0, sat_azimuth.encoding['add_offset'])
self.assertEqual(CHUNKING, sat_azimuth.encoding["chunksizes"])
sat_zenith = ds.variables["satellite_zenith_angle"]
self.assertEqual((500, 500), sat_zenith.shape)
self.assertTrue(np.isnan(sat_zenith.data[1, 113]))
self.assertEqual("platform_zenith_angle",
sat_zenith.attrs["standard_name"])
self.assertEqual("degree", sat_zenith.attrs["units"])
self.assertEqual("true", sat_zenith.attrs["tie_points"])
self.assertEqual(np.uint16, sat_zenith.encoding['dtype'])
self.assertEqual(65535, sat_zenith.encoding['_FillValue'])
self.assertEqual(0.01, sat_zenith.encoding['scale_factor'])
self.assertEqual(0.0, sat_zenith.encoding['add_offset'])
self.assertEqual(CHUNKING, sat_zenith.encoding["chunksizes"])
count = ds.variables["count_ir"]
self.assertEqual((2500, 2500), count.shape)
self.assertEqual(DefaultData.get_default_fill_value(np.uint8),
count.data[0, 113])
self.assertEqual(DefaultData.get_default_fill_value(np.uint8),
count.attrs["_FillValue"])
self.assertEqual("Infrared Image Counts", count.attrs["long_name"])
self.assertEqual("count", count.attrs["units"])
self.assertEqual(CHUNKING, count.encoding["chunksizes"])
count = ds.variables["count_wv"]
self.assertEqual((2500, 2500), count.shape)
self.assertEqual(DefaultData.get_default_fill_value(np.uint8),
count.data[1, 114])
self.assertEqual(DefaultData.get_default_fill_value(np.uint8),
count.attrs["_FillValue"])
self.assertEqual("WV Image Counts", count.attrs["long_name"])
self.assertEqual("count", count.attrs["units"])
self.assertEqual(CHUNKING, count.encoding["chunksizes"])
dq_bitmask = ds.variables["data_quality_bitmask"]
self.assertEqual((5000, 5000), dq_bitmask.shape)
self.assertEqual(0, dq_bitmask.data[1, 6])
self.assertEqual("1, 2, 4, 8, 16, 32", dq_bitmask.attrs["flag_masks"])
self.assertEqual(
"uncertainty_suspicious uncertainty_too_large space_view_suspicious not_on_earth suspect_time suspect_geo",
dq_bitmask.attrs["flag_meanings"])
self.assertEqual("status_flag", dq_bitmask.attrs["standard_name"])
self._assert_scalar_float_variable(ds, "distance_sun_earth",
"Sun-Earth distance", "au")
self._assert_scalar_float_variable(
ds,
"solar_irradiance_vis",
"Solar effective Irradiance",
"W*m-2",
standard_name="solar_irradiance_vis")
u_sol_irr = ds.variables["u_solar_irradiance_vis"]
self.assertEqual((), u_sol_irr.shape)
self.assertTrue(np.isnan(u_sol_irr.data))
self.assertTrue(np.isnan(u_sol_irr.attrs["_FillValue"]))
self.assertEqual("Uncertainty in Solar effective Irradiance",
u_sol_irr.attrs["long_name"])
self.assertEqual("Wm^-2", u_sol_irr.attrs["units"])
self.assertEqual("rectangle_absolute",
u_sol_irr.attrs["pixel_correlation_form"])
self.assertEqual("pixel", u_sol_irr.attrs["pixel_correlation_units"])
self.assertEqual([-np.inf, np.inf],
u_sol_irr.attrs["pixel_correlation_scales"])
self.assertEqual("rectangle_absolute",
u_sol_irr.attrs["scan_correlation_form"])
self.assertEqual("line", u_sol_irr.attrs["scan_correlation_units"])
self.assertEqual([-np.inf, np.inf],
u_sol_irr.attrs["scan_correlation_scales"])
self.assertEqual("rectangle_absolute",
u_sol_irr.attrs["image_correlation_form"])
self.assertEqual("days", u_sol_irr.attrs["image_correlation_units"])
self.assertEqual([-np.inf, np.inf],
u_sol_irr.attrs["image_correlation_scales"])
self.assertEqual("rectangle", u_sol_irr.attrs["pdf_shape"])
srf_weights = ds.variables["SRF_weights"]
self.assertEqual((3, 1011), srf_weights.shape)
self.assertTrue(np.isnan(srf_weights.data[0, 7]))
self.assertEqual("Spectral Response Function weights",
srf_weights.attrs["long_name"])
self.assertEqual(
"Per channel: weights for the relative spectral response function",
srf_weights.attrs["description"])
self.assertEqual(-32768, srf_weights.encoding['_FillValue'])
self.assertEqual(0.000033, srf_weights.encoding['scale_factor'])
srf_freqs = ds.variables["SRF_frequencies"]
self.assertEqual((3, 1011), srf_freqs.shape)
self.assertTrue(np.isnan(srf_freqs.data[1, 8]))
self.assertEqual("Spectral Response Function frequencies",
srf_freqs.attrs["long_name"])
self.assertEqual(
"Per channel: frequencies for the relative spectral response function",
srf_freqs.attrs["description"])
self.assertEqual(-2147483648, srf_freqs.encoding['_FillValue'])
self.assertEqual(0.0001, srf_freqs.encoding['scale_factor'])
self.assertEqual("nm", srf_freqs.attrs["units"])
self.assertEqual("Filename of SRF", srf_freqs.attrs["source"])
self.assertEqual("datestring", srf_freqs.attrs["Valid(YYYYDDD)"])
cov_srf = ds.variables["covariance_spectral_response_function_vis"]
self.assertEqual((1011, 1011), cov_srf.shape)
self.assertTrue(np.isnan(cov_srf.data[116, 22]))
self.assertTrue(np.isnan(cov_srf.attrs["_FillValue"]))
self.assertEqual(
"Covariance of the Visible Band Spectral Response Function",
cov_srf.attrs["long_name"])
self.assertEqual(CHUNKING, cov_srf.encoding["chunksizes"])
u_srf_ir = ds.variables["u_spectral_response_function_ir"]
self.assertEqual((1011, ), u_srf_ir.shape)
self.assertTrue(np.isnan(u_srf_ir.data[119]))
self.assertTrue(np.isnan(u_srf_ir.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty in Spectral Response Function for IR channel",
u_srf_ir.attrs["long_name"])
u_srf_wv = ds.variables["u_spectral_response_function_wv"]
self.assertEqual((1011, ), u_srf_wv.shape)
self.assertTrue(np.isnan(u_srf_wv.data[120]))
self.assertTrue(np.isnan(u_srf_wv.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty in Spectral Response Function for WV channel",
u_srf_wv.attrs["long_name"])
self._assert_scalar_float_variable(
ds, "a_ir", "Calibration parameter a for IR Band",
"mWm^-2sr^-1cm^-1")
self._assert_scalar_float_variable(
ds, "b_ir", "Calibration parameter b for IR Band",
"mWm^-2sr^-1cm^-1/DC")
self._assert_scalar_float_variable(
ds, "u_a_ir", "Uncertainty of calibration parameter a for IR Band",
"mWm^-2sr^-1cm^-1")
self._assert_scalar_float_variable(
ds, "u_b_ir", "Uncertainty of calibration parameter b for IR Band",
"mWm^-2sr^-1cm^-1/DC")
self._assert_scalar_float_variable(
ds, "a_wv", "Calibration parameter a for WV Band",
"mWm^-2sr^-1cm^-1")
self._assert_scalar_float_variable(
ds, "b_wv", "Calibration parameter b for WV Band",
"mWm^-2sr^-1cm^-1/DC")
self._assert_scalar_float_variable(
ds, "u_a_wv", "Uncertainty of calibration parameter a for WV Band",
"mWm^-2sr^-1cm^-1")
self._assert_scalar_float_variable(
ds, "u_b_wv", "Uncertainty of calibration parameter b for WV Band",
"mWm^-2sr^-1cm^-1/DC")
self._assert_scalar_float_variable(
ds, "bt_a_ir", "IR Band BT conversion parameter A", "1")
self._assert_scalar_float_variable(
ds, "bt_b_ir", "IR Band BT conversion parameter B", "1")
self._assert_scalar_float_variable(
ds, "bt_a_wv", "WV Band BT conversion parameter A", "1")
self._assert_scalar_float_variable(
ds, "bt_b_wv", "WV Band BT conversion parameter B", "1")
self._assert_scalar_float_variable(
ds, "years_since_launch",
"Fractional year since launch of satellite", "years")
x = ds.coords["x"]
self.assertEqual((5000, ), x.shape)
self.assertEqual(15, x[15])
y = ds.coords["y"]
self.assertEqual((5000, ), y.shape)
self.assertEqual(6, y[6])
x_ir_wv = ds.coords["x_ir_wv"]
self.assertEqual((2500, ), x_ir_wv.shape)
self.assertEqual(16, x_ir_wv[16])
y_ir_wv = ds.coords["y_ir_wv"]
self.assertEqual((2500, ), y_ir_wv.shape)
self.assertEqual(17, x[17])
srf_size = ds.coords["srf_size"]
self.assertEqual((1011, ), srf_size.shape)
self.assertEqual(18, srf_size[18])
def test_add_gridded_global_attributes(self):
dataset = xr.Dataset()
WriterUtils.add_gridded_global_attributes(dataset)
Assertions.assert_gridded_global_attributes(self, dataset.attrs)
def test_add_easy_fcdr_variables(self):
ds = xr.Dataset()
AVHRR.add_easy_fcdr_variables(ds,
5,
lut_size=LUT_SIZE,
corr_dx=12,
corr_dy=13)
self._assert_correct_refl_uncertainty_variable(
ds,
"u_independent_Ch1",
long_name="independent uncertainty per pixel for channel 1",
units="percent",
valid_min=10,
valid_max=1000)
self._assert_correct_refl_uncertainty_variable(
ds,
"u_structured_Ch1",
long_name="structured uncertainty per pixel for channel 1",
units="percent",
valid_min=3,
valid_max=5)
self._assert_correct_refl_uncertainty_variable(
ds,
"u_common_Ch1",
long_name="common uncertainty per pixel for channel 1",
units="percent",
valid_min=10,
valid_max=1000)
self._assert_correct_refl_uncertainty_variable(
ds,
"u_independent_Ch2",
long_name="independent uncertainty per pixel for channel 2",
units="percent",
valid_min=10,
valid_max=1000)
self._assert_correct_refl_uncertainty_variable(
ds,
"u_structured_Ch2",
long_name="structured uncertainty per pixel for channel 2",
units="percent",
valid_min=3,
valid_max=5)
self._assert_correct_refl_uncertainty_variable(
ds,
"u_common_Ch2",
long_name="common uncertainty per pixel for channel 2",
units="percent",
valid_min=10,
valid_max=1000)
self._assert_correct_refl_uncertainty_variable(
ds,
"u_independent_Ch3a",
long_name="independent uncertainty per pixel for channel 3a",
units="percent",
valid_min=10,
valid_max=1000)
self._assert_correct_refl_uncertainty_variable(
ds,
"u_structured_Ch3a",
long_name="structured uncertainty per pixel for channel 3a",
units="percent",
valid_min=3,
valid_max=5)
self._assert_correct_refl_uncertainty_variable(
ds,
"u_common_Ch3a",
long_name="common uncertainty per pixel for channel 3a",
units="percent",
valid_min=10,
valid_max=1000)
self._assert_correct_bt_uncertainty_variable(
ds,
"u_independent_Ch3b",
long_name="independent uncertainty per pixel for channel 3b")
self._assert_correct_bt_uncertainty_variable(
ds,
"u_structured_Ch3b",
long_name="structured uncertainty per pixel for channel 3b")
self._assert_correct_bt_uncertainty_variable(
ds,
"u_common_Ch3b",
long_name="common uncertainty per pixel for channel 3b")
self._assert_correct_bt_uncertainty_variable(
ds,
"u_independent_Ch4",
long_name="independent uncertainty per pixel for channel 4")
self._assert_correct_bt_uncertainty_variable(
ds,
"u_structured_Ch4",
long_name="structured uncertainty per pixel for channel 4")
self._assert_correct_bt_uncertainty_variable(
ds,
"u_common_Ch4",
long_name="common uncertainty per pixel for channel 4")
self._assert_correct_bt_uncertainty_variable(
ds,
"u_independent_Ch5",
long_name="independent uncertainty per pixel for channel 5")
self._assert_correct_bt_uncertainty_variable(
ds,
"u_structured_Ch5",
long_name="structured uncertainty per pixel for channel 5")
self._assert_correct_bt_uncertainty_variable(
ds,
"u_common_Ch5",
long_name="common uncertainty per pixel for channel 5")
Assertions.assert_correlation_matrices(self, ds, NUM_CHANNELS)
Assertions.assert_lookup_tables(self, ds, NUM_CHANNELS, LUT_SIZE)
Assertions.assert_correlation_coefficients(self, ds, NUM_CHANNELS, 12,
13)
def testCreateTemplateFull_MVIRI(self):
ds = FCDRWriter.createTemplateFull('MVIRI', 5000)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self.assertEqual(58, len(ds.data_vars))
self._verify_quality_flags(ds)
# sensor specific
self.assertIsNotNone(ds.variables["count_vis"])
self.assertIsNotNone(ds.variables["time"])
self.assertIsNotNone(ds.variables["solar_zenith_angle"])
self.assertIsNotNone(ds.variables["solar_azimuth_angle"])
self.assertIsNotNone(ds.variables["satellite_azimuth_angle"])
self.assertIsNotNone(ds.variables["satellite_zenith_angle"])
self.assertIsNotNone(ds.variables["count_ir"])
self.assertIsNotNone(ds.variables["count_wv"])
self.assertIsNotNone(ds.variables["count_vis"])
self.assertIsNotNone(ds.variables["data_quality_bitmask"])
self.assertIsNotNone(ds.variables["SRF_weights"])
self.assertIsNotNone(ds.variables["SRF_frequencies"])
self.assertIsNotNone(
ds.variables["covariance_spectral_response_function_vis"])
self.assertIsNotNone(ds.variables["u_spectral_response_function_ir"])
self.assertIsNotNone(ds.variables["u_spectral_response_function_wv"])
self.assertIsNotNone(ds.variables["a0_vis"])
self.assertIsNotNone(ds.variables["a1_vis"])
self.assertIsNotNone(ds.variables["a2_vis"])
self.assertIsNotNone(ds.variables["solar_irradiance_vis"])
self.assertIsNotNone(ds.variables["u_solar_irradiance_vis"])
self.assertIsNotNone(ds.variables["distance_sun_earth"])
self.assertIsNotNone(ds.variables["a_ir"])
self.assertIsNotNone(ds.variables["b_ir"])
self.assertIsNotNone(ds.variables["u_a_ir"])
self.assertIsNotNone(ds.variables["u_b_ir"])
self.assertIsNotNone(ds.variables["a_wv"])
self.assertIsNotNone(ds.variables["b_wv"])
self.assertIsNotNone(ds.variables["u_a_wv"])
self.assertIsNotNone(ds.variables["u_b_wv"])
self.assertIsNotNone(ds.variables["bt_a_ir"])
self.assertIsNotNone(ds.variables["bt_b_ir"])
self.assertIsNotNone(ds.variables["bt_a_wv"])
self.assertIsNotNone(ds.variables["bt_b_wv"])
self.assertIsNotNone(ds.variables["years_since_launch"])
# full FCDR uncertainties
self.assertIsNotNone(ds.variables["u_latitude"])
self.assertIsNotNone(ds.variables["u_longitude"])
self.assertIsNotNone(ds.variables["u_time"])
self.assertIsNotNone(ds.variables["u_a0_vis"])
self.assertIsNotNone(ds.variables["u_a1_vis"])
self.assertIsNotNone(ds.variables["u_a2_vis"])
self.assertIsNotNone(ds.variables["u_zero_vis"])
self.assertIsNotNone(ds.variables["covariance_a_vis"])
self.assertIsNotNone(ds.variables["u_electronics_counts_vis"])
self.assertIsNotNone(ds.variables["u_digitization_counts_vis"])
self.assertIsNotNone(ds.variables["allan_deviation_counts_space_vis"])
self.assertIsNotNone(ds.variables["u_mean_counts_space_vis"])
self.assertIsNotNone(ds.variables["u_solar_zenith_angle"])
self.assertIsNotNone(ds.variables["u_solar_azimuth_angle"])
self.assertIsNotNone(ds.variables["u_satellite_zenith_angle"])
self.assertIsNotNone(ds.variables["u_satellite_azimuth_angle"])
self.assertIsNotNone(ds.variables["effect_correlation_matrix"])
# virtual variables
self.assertIsNotNone(ds.variables["sensitivity_solar_irradiance_vis"])
self.assertIsNotNone(ds.variables["sensitivity_count_vis"])
self.assertIsNotNone(ds.variables["sensitivity_count_space"])
self.assertIsNotNone(ds.variables["sensitivity_a0_vis"])
self.assertIsNotNone(ds.variables["sensitivity_a1_vis"])
self.assertIsNotNone(ds.variables["sensitivity_a2_vis"])
def testCreateTemplateFull_AVHRR(self):
ds = FCDRWriter.createTemplateFull('AVHRR', 13667)
self.assertIsNotNone(ds)
Assertions.assert_global_attributes(self, ds.attrs)
self.assertEqual(73, len(ds.data_vars))
# geolocation + flags
self._verify_geolocation_variables(ds)
self._verify_quality_flags(ds)
# sensor specific
self._verify_avhrr_specific_variables(ds)
# variables of full FCDR
self.assertIsNotNone(ds.variables["u_latitude"])
self.assertIsNotNone(ds.variables["u_longitude"])
self.assertIsNotNone(ds.variables["u_time"])
self.assertIsNotNone(ds.variables["u_satellite_azimuth_angle"])
self.assertIsNotNone(ds.variables["u_satellite_zenith_angle"])
self.assertIsNotNone(ds.variables["u_solar_azimuth_angle"])
self.assertIsNotNone(ds.variables["u_solar_zenith_angle"])
self.assertIsNotNone(ds.variables["PRT_C"])
self.assertIsNotNone(ds.variables["u_prt"]) # geolocation
self._verify_geolocation_variables(ds)
self.assertIsNotNone(ds.variables["R_ICT"])
self.assertIsNotNone(ds.variables["T_instr"])
self.assertIsNotNone(ds.variables["Ch1_Csp"])
self.assertIsNotNone(ds.variables["Ch2_Csp"])
self.assertIsNotNone(ds.variables["Ch3a_Csp"])
self.assertIsNotNone(ds.variables["Ch3b_Csp"])
self.assertIsNotNone(ds.variables["Ch4_Csp"])
self.assertIsNotNone(ds.variables["Ch5_Csp"])
self.assertIsNotNone(ds.variables["Ch3b_Cict"])
self.assertIsNotNone(ds.variables["Ch4_Cict"])
self.assertIsNotNone(ds.variables["Ch5_Cict"])
self.assertIsNotNone(ds.variables["Ch1_Ce"])
self.assertIsNotNone(ds.variables["Ch2_Ce"])
self.assertIsNotNone(ds.variables["Ch3a_Ce"])
self.assertIsNotNone(ds.variables["Ch3b_Ce"])
self.assertIsNotNone(ds.variables["Ch4_Ce"])
self.assertIsNotNone(ds.variables["Ch5_Ce"])
self.assertIsNotNone(ds.variables["Ch1_u_Csp"])
self.assertIsNotNone(ds.variables["Ch2_u_Csp"])
self.assertIsNotNone(ds.variables["Ch3a_u_Csp"])
self.assertIsNotNone(ds.variables["Ch3b_u_Csp"])
self.assertIsNotNone(ds.variables["Ch4_u_Csp"])
self.assertIsNotNone(ds.variables["Ch5_u_Csp"])
self.assertIsNotNone(ds.variables["Ch3b_u_Cict"])
self.assertIsNotNone(ds.variables["Ch4_u_Cict"])
self.assertIsNotNone(ds.variables["Ch5_u_Cict"])
self.assertIsNotNone(ds.variables["Ch1_u_Ce"])
self.assertIsNotNone(ds.variables["Ch2_u_Ce"])
self.assertIsNotNone(ds.variables["Ch3a_u_Ce"])
self.assertIsNotNone(ds.variables["Ch3b_u_Ce"])
self.assertIsNotNone(ds.variables["Ch4_u_Ce"])
self.assertIsNotNone(ds.variables["Ch5_u_Ce"])
self.assertIsNotNone(ds.variables["Ch1_u_Refl"])
self.assertIsNotNone(ds.variables["Ch2_u_Refl"])
self.assertIsNotNone(ds.variables["Ch3a_u_Refl"])
self.assertIsNotNone(ds.variables["Ch3b_u_Bt"])
self.assertIsNotNone(ds.variables["Ch4_u_Bt"])
self.assertIsNotNone(ds.variables["Ch5_u_Bt"])
self.assertIsNotNone(ds.variables["Ch3b_ur_Bt"])
self.assertIsNotNone(ds.variables["Ch4_ur_Bt"])
self.assertIsNotNone(ds.variables["Ch5_ur_Bt"])
self.assertIsNotNone(ds.variables["Ch3b_us_Bt"])
self.assertIsNotNone(ds.variables["Ch4_us_Bt"])
self.assertIsNotNone(ds.variables["Ch5_us_Bt"])
def test_add_variables(self):
ds = xr.Dataset()
UTH.add_variables(ds, 360, 100)
Assertions.assert_gridded_geolocation_variables(self, ds, 360, 100)
Assertions.assert_quality_flags(self, ds, 360, 100)
time_ranges_asc = ds.variables["time_ranges_ascend"]
self.assertEqual((2, 100, 360), time_ranges_asc.shape)
self.assertEqual(-1, time_ranges_asc.values[0, 66, 178])
self.assertEqual(4294967295, time_ranges_asc.attrs["_FillValue"])
self.assertEqual(
"Minimum and maximum seconds of day pixel contribution time, ascending nodes",
time_ranges_asc.attrs["description"])
self.assertEqual("s", time_ranges_asc.attrs["units"])
self.assertEqual("lon lat", time_ranges_asc.attrs["coordinates"])
time_ranges_desc = ds.variables["time_ranges_descend"]
self.assertEqual((2, 100, 360), time_ranges_desc.shape)
self.assertEqual(-1, time_ranges_desc.values[1, 67, 179])
self.assertEqual(4294967295, time_ranges_desc.attrs["_FillValue"])
self.assertEqual(
"Minimum and maximum seconds of day pixel contribution time, descending nodes",
time_ranges_desc.attrs["description"])
self.assertEqual("s", time_ranges_desc.attrs["units"])
self.assertEqual("lon lat", time_ranges_desc.attrs["coordinates"])
obs_count_asc = ds.variables["observation_count_ascend"]
self.assertEqual((100, 360), obs_count_asc.shape)
self.assertEqual(-32767, obs_count_asc.values[67, 179])
self.assertEqual(-32767, obs_count_asc.attrs["_FillValue"])
self.assertEqual(
"Number of UTH/brightness temperature observations in a grid box for ascending passes",
obs_count_asc.attrs["description"])
self.assertEqual("lon lat", obs_count_asc.attrs["coordinates"])
obs_count_desc = ds.variables["observation_count_descend"]
self.assertEqual((100, 360), obs_count_desc.shape)
self.assertEqual(-32767, obs_count_desc.values[68, 180])
self.assertEqual(-32767, obs_count_desc.attrs["_FillValue"])
self.assertEqual(
"Number of UTH/brightness temperature observations in a grid box for descending passes",
obs_count_desc.attrs["description"])
self.assertEqual("lon lat", obs_count_desc.attrs["coordinates"])
overp_count_asc = ds.variables["overpass_count_ascend"]
self.assertEqual((100, 360), overp_count_asc.shape)
self.assertEqual(255, overp_count_asc.values[69, 179])
self.assertEqual(255, overp_count_asc.attrs["_FillValue"])
self.assertEqual(
"Number of satellite overpasses in a grid box for ascending passes",
overp_count_asc.attrs["description"])
self.assertEqual("lon lat", overp_count_asc.attrs["coordinates"])
overp_count_desc = ds.variables["overpass_count_descend"]
self.assertEqual((100, 360), overp_count_desc.shape)
self.assertEqual(255, overp_count_desc.values[70, 180])
self.assertEqual(255, overp_count_desc.attrs["_FillValue"])
self.assertEqual(
"Number of satellite overpasses in a grid box for descending passes",
overp_count_desc.attrs["description"])
self.assertEqual("lon lat", overp_count_desc.attrs["coordinates"])
uth_asc = ds.variables["uth_ascend"]
self.assertEqual((100, 360), uth_asc.shape)
self.assertTrue(np.isnan(uth_asc.values[97, 198]))
self.assertTrue(np.isnan(uth_asc.attrs["_FillValue"]))
self.assertEqual("lon lat", uth_asc.attrs["coordinates"])
self.assertEqual("%", uth_asc.attrs["units"])
self.assertEqual("upper_tropospheric_humidity",
uth_asc.attrs["long_name"])
self.assertEqual(
"Monthly average of all UTH retrievals in a grid box for ascending passes (calculated from daily averages)",
uth_asc.attrs["description"])
uth_desc = ds.variables["uth_descend"]
self.assertEqual((100, 360), uth_desc.shape)
self.assertTrue(np.isnan(uth_desc.values[98, 199]))
self.assertTrue(np.isnan(uth_desc.attrs["_FillValue"]))
self.assertEqual("lon lat", uth_desc.attrs["coordinates"])
self.assertEqual("%", uth_desc.attrs["units"])
self.assertEqual("upper_tropospheric_humidity",
uth_desc.attrs["long_name"])
self.assertEqual(
"Monthly average of all UTH retrievals in a grid box for descending passes (calculated from daily averages)",
uth_desc.attrs["description"])
u_ind_uth_asc = ds.variables["u_independent_uth_ascend"]
self.assertEqual((100, 360), u_ind_uth_asc.shape)
self.assertTrue(np.isnan(u_ind_uth_asc.values[98, 199]))
self.assertTrue(np.isnan(u_ind_uth_asc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of UTH due to independent effects for ascending passes",
u_ind_uth_asc.attrs["description"])
self.assertEqual("lon lat", u_ind_uth_asc.attrs["coordinates"])
self.assertEqual("%", u_ind_uth_asc.attrs["units"])
u_ind_uth_desc = ds.variables["u_independent_uth_descend"]
self.assertEqual((100, 360), u_ind_uth_desc.shape)
self.assertTrue(np.isnan(u_ind_uth_desc.values[99, 200]))
self.assertTrue(np.isnan(u_ind_uth_desc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of UTH due to independent effects for descending passes",
u_ind_uth_desc.attrs["description"])
self.assertEqual("lon lat", u_ind_uth_desc.attrs["coordinates"])
self.assertEqual("%", u_ind_uth_desc.attrs["units"])
u_str_uth_asc = ds.variables["u_structured_uth_ascend"]
self.assertEqual((100, 360), u_str_uth_asc.shape)
self.assertTrue(np.isnan(u_str_uth_asc.values[0, 201]))
self.assertTrue(np.isnan(u_str_uth_asc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of UTH due to structured effects for ascending passes",
u_str_uth_asc.attrs["description"])
self.assertEqual("lon lat", u_str_uth_asc.attrs["coordinates"])
self.assertEqual("%", u_str_uth_asc.attrs["units"])
u_str_uth_desc = ds.variables["u_structured_uth_descend"]
self.assertEqual((100, 360), u_str_uth_desc.shape)
self.assertTrue(np.isnan(u_str_uth_desc.values[1, 202]))
self.assertTrue(np.isnan(u_str_uth_desc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of UTH due to structured effects for descending passes",
u_str_uth_desc.attrs["description"])
self.assertEqual("lon lat", u_str_uth_desc.attrs["coordinates"])
self.assertEqual("%", u_str_uth_desc.attrs["units"])
u_com_uth_asc = ds.variables["u_common_uth_ascend"]
self.assertEqual((100, 360), u_com_uth_asc.shape)
self.assertTrue(np.isnan(u_com_uth_asc.values[70, 171]))
self.assertTrue(np.isnan(u_com_uth_asc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of UTH due to common effects for ascending passes",
u_com_uth_asc.attrs["description"])
self.assertEqual("lon lat", u_com_uth_asc.attrs["coordinates"])
self.assertEqual("%", u_com_uth_asc.attrs["units"])
u_com_uth_desc = ds.variables["u_common_uth_descend"]
self.assertEqual((100, 360), u_com_uth_desc.shape)
self.assertTrue(np.isnan(u_com_uth_desc.values[71, 172]))
self.assertTrue(np.isnan(u_com_uth_desc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of UTH due to common effects for descending passes",
u_com_uth_desc.attrs["description"])
self.assertEqual("lon lat", u_com_uth_desc.attrs["coordinates"])
self.assertEqual("%", u_com_uth_desc.attrs["units"])
uth_inhom_asc = ds.variables["uth_inhomogeneity_ascend"]
self.assertEqual((100, 360), uth_inhom_asc.shape)
self.assertTrue(np.isnan(uth_inhom_asc.values[71, 172]))
self.assertTrue(np.isnan(uth_inhom_asc.attrs["_FillValue"]))
self.assertEqual(
"Standard deviation of all daily UTH averages which were used to calculate the monthly UTH average in a grid box for ascending passes",
uth_inhom_asc.attrs["description"])
self.assertEqual("lon lat", uth_inhom_asc.attrs["coordinates"])
self.assertEqual("%", uth_inhom_asc.attrs["units"])
uth_inhom_desc = ds.variables["uth_inhomogeneity_descend"]
self.assertEqual((100, 360), uth_inhom_desc.shape)
self.assertTrue(np.isnan(uth_inhom_desc.values[72, 173]))
self.assertTrue(np.isnan(uth_inhom_desc.attrs["_FillValue"]))
self.assertEqual(
"Standard deviation of all daily UTH averages which were used to calculate the monthly UTH average in a grid box for descending passes",
uth_inhom_desc.attrs["description"])
self.assertEqual("lon lat", uth_inhom_desc.attrs["coordinates"])
self.assertEqual("%", uth_inhom_desc.attrs["units"])
bt_ascend = ds.variables["BT_ascend"]
self.assertEqual((100, 360), bt_ascend.shape)
self.assertTrue(np.isnan(bt_ascend.values[73, 174]))
self.assertTrue(np.isnan(bt_ascend.attrs["_FillValue"]))
self.assertEqual(
"Monthly average of all brightness temperatures which were used to retrieve UTH in a grid box for ascending passes (calculated from daily averages)",
bt_ascend.attrs["description"])
self.assertEqual("lon lat", bt_ascend.attrs["coordinates"])
self.assertEqual("K", bt_ascend.attrs["units"])
self.assertEqual("toa_brightness_temperature",
bt_ascend.attrs["standard_name"])
bt_descend = ds.variables["BT_descend"]
self.assertEqual((100, 360), bt_descend.shape)
self.assertTrue(np.isnan(bt_descend.values[74, 175]))
self.assertTrue(np.isnan(bt_descend.attrs["_FillValue"]))
self.assertEqual(
"Monthly average of all brightness temperatures which were used to retrieve UTH in a grid box for descending passes (calculated from daily averages)",
bt_descend.attrs["description"])
self.assertEqual("lon lat", bt_descend.attrs["coordinates"])
self.assertEqual("K", bt_descend.attrs["units"])
self.assertEqual("toa_brightness_temperature",
bt_descend.attrs["standard_name"])
u_ind_bt_asc = ds.variables["u_independent_BT_ascend"]
self.assertEqual((100, 360), u_ind_bt_asc.shape)
self.assertTrue(np.isnan(u_ind_bt_asc.values[99, 200]))
self.assertTrue(np.isnan(u_ind_bt_asc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of brightness temperature due to independent effects for ascending passes",
u_ind_bt_asc.attrs["description"])
self.assertEqual("lon lat", u_ind_bt_asc.attrs["coordinates"])
self.assertEqual("K", u_ind_bt_asc.attrs["units"])
u_ind_bt_desc = ds.variables["u_independent_BT_descend"]
self.assertEqual((100, 360), u_ind_bt_desc.shape)
self.assertTrue(np.isnan(u_ind_bt_desc.values[0, 201]))
self.assertTrue(np.isnan(u_ind_bt_desc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of brightness temperature due to independent effects for descending passes",
u_ind_bt_desc.attrs["description"])
self.assertEqual("lon lat", u_ind_bt_desc.attrs["coordinates"])
self.assertEqual("K", u_ind_bt_desc.attrs["units"])
u_str_bt_asc = ds.variables["u_structured_BT_ascend"]
self.assertEqual((100, 360), u_str_bt_asc.shape)
self.assertTrue(np.isnan(u_str_bt_asc.values[1, 202]))
self.assertTrue(np.isnan(u_str_bt_asc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of brightness temperature due to structured effects for ascending passes",
u_str_bt_asc.attrs["description"])
self.assertEqual("lon lat", u_str_bt_asc.attrs["coordinates"])
self.assertEqual("K", u_str_bt_asc.attrs["units"])
u_str_bt_desc = ds.variables["u_structured_BT_descend"]
self.assertEqual((100, 360), u_str_bt_desc.shape)
self.assertTrue(np.isnan(u_str_bt_desc.values[2, 203]))
self.assertTrue(np.isnan(u_str_bt_desc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of brightness temperature due to structured effects for descending passes",
u_str_bt_desc.attrs["description"])
self.assertEqual("lon lat", u_str_bt_desc.attrs["coordinates"])
self.assertEqual("K", u_str_bt_desc.attrs["units"])
u_com_bt_asc = ds.variables["u_common_BT_ascend"]
self.assertEqual((100, 360), u_com_bt_asc.shape)
self.assertTrue(np.isnan(u_com_bt_asc.values[3, 204]))
self.assertTrue(np.isnan(u_str_bt_asc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of brightness temperature due to common effects for ascending passes",
u_com_bt_asc.attrs["description"])
self.assertEqual("lon lat", u_com_bt_asc.attrs["coordinates"])
self.assertEqual("K", u_com_bt_asc.attrs["units"])
u_com_bt_desc = ds.variables["u_common_BT_descend"]
self.assertEqual((100, 360), u_com_bt_desc.shape)
self.assertTrue(np.isnan(u_com_bt_desc.values[5, 206]))
self.assertTrue(np.isnan(u_com_bt_desc.attrs["_FillValue"]))
self.assertEqual(
"Uncertainty of brightness temperature due to common effects for descending passes",
u_com_bt_desc.attrs["description"])
self.assertEqual("lon lat", u_com_bt_desc.attrs["coordinates"])
self.assertEqual("K", u_com_bt_desc.attrs["units"])
bt_inhom_asc = ds.variables["BT_inhomogeneity_ascend"]
self.assertEqual((100, 360), bt_inhom_asc.shape)
self.assertTrue(np.isnan(bt_inhom_asc.values[72, 173]))
self.assertTrue(np.isnan(bt_inhom_asc.attrs["_FillValue"]))
self.assertEqual(
"Standard deviation of all daily brightness temperature averages which were used to calculate the monthly brightness temperature average for ascending passes",
bt_inhom_asc.attrs["description"])
self.assertEqual("lon lat", bt_inhom_asc.attrs["coordinates"])
self.assertEqual("K", bt_inhom_asc.attrs["units"])
bt_inhom_desc = ds.variables["BT_inhomogeneity_descend"]
self.assertEqual((100, 360), bt_inhom_desc.shape)
self.assertTrue(np.isnan(bt_inhom_desc.values[73, 174]))
self.assertTrue(np.isnan(bt_inhom_desc.attrs["_FillValue"]))
self.assertEqual(
"Standard deviation of all daily brightness temperature averages which were used to calculate the monthly brightness temperature average for descending passes",
bt_inhom_desc.attrs["description"])
self.assertEqual("lon lat", bt_inhom_desc.attrs["coordinates"])
self.assertEqual("K", bt_inhom_desc.attrs["units"])
obs_count_all_asc = ds.variables["observation_count_all_ascend"]
self.assertEqual((100, 360), obs_count_all_asc.shape)
self.assertEqual(-32767, obs_count_all_asc.values[68, 180])
self.assertEqual(-32767, obs_count_all_asc.attrs["_FillValue"])
self.assertEqual(
"Number of all observations in a grid box for ascending passes - no filtering done",
obs_count_all_asc.attrs["description"])
self.assertEqual("lon lat", obs_count_all_asc.attrs["coordinates"])
obs_count_all_desc = ds.variables["observation_count_all_descend"]
self.assertEqual((100, 360), obs_count_all_desc.shape)
self.assertEqual(-32767, obs_count_all_desc.values[69, 181])
self.assertEqual(-32767, obs_count_all_desc.attrs["_FillValue"])
self.assertEqual(
"Number of all observations in a grid box for descending passes - no filtering done",
obs_count_all_desc.attrs["description"])
self.assertEqual("lon lat", obs_count_all_desc.attrs["coordinates"])
def test_add_original_variables(self):
ds = xr.Dataset()
SSMT2.add_original_variables(ds, 4)
Assertions.assert_geolocation_variables(self, ds, 28, 4)
Assertions.assert_quality_flags(self, ds, 28, 4)
temp_misc_hk = ds.variables["Temperature_misc_housekeeping"]
self.assertEqual((18, 4), temp_misc_hk.shape)
self.assertTrue(np.isnan(temp_misc_hk.data[1, 3]))
self.assertTrue(np.isnan(temp_misc_hk.attrs['_FillValue']))
self.assertEqual("TODO", temp_misc_hk.attrs["long_name"])
self.assertEqual("TODO", temp_misc_hk.attrs["units"])
ancil_data = ds.variables["ancil_data"]
self.assertEqual((10, 4), ancil_data.shape)
self.assertTrue(np.isnan(ancil_data.data[2, 3]))
self.assertTrue(np.isnan(ancil_data.attrs['_FillValue']))
self.assertEqual(
"Additional per scan information: year, day_of_year, secs_of_day, sat_lat, sat_long, sat_alt, sat_heading, year, day_of_year, secs_of_day",
ancil_data.attrs["long_name"])
ch_qual_flag = ds.variables["channel_quality_flag"]
self.assertEqual((5, 4, 28), ch_qual_flag.shape)
self.assertTrue(np.isnan(ch_qual_flag.data[2, 3, 4]))
self.assertTrue(np.isnan(ch_qual_flag.attrs['_FillValue']))
self.assertEqual("TODO", temp_misc_hk.attrs["long_name"])
cold_counts = ds.variables["cold_counts"]
self.assertEqual((4, 4, 28), cold_counts.shape)
self.assertTrue(np.isnan(cold_counts.data[3, 0, 5]))
self.assertTrue(np.isnan(cold_counts.attrs['_FillValue']))
self.assertEqual("TODO", cold_counts.attrs["long_name"])
counts_to_tb_gain = ds.variables["counts_to_tb_gain"]
self.assertEqual((5, 4), counts_to_tb_gain.shape)
self.assertTrue(np.isnan(counts_to_tb_gain.data[2, 3]))
self.assertTrue(np.isnan(counts_to_tb_gain.attrs['_FillValue']))
self.assertEqual("TODO", counts_to_tb_gain.attrs["long_name"])
counts_to_tb_offset = ds.variables["counts_to_tb_offset"]
self.assertEqual((5, 4), counts_to_tb_offset.shape)
self.assertTrue(np.isnan(counts_to_tb_offset.data[3, 0]))
self.assertTrue(np.isnan(counts_to_tb_offset.attrs['_FillValue']))
self.assertEqual("TODO", counts_to_tb_offset.attrs["long_name"])
gain_control = ds.variables["gain_control"]
self.assertEqual((5, 4), gain_control.shape)
self.assertTrue(np.isnan(gain_control.data[4, 1]))
self.assertTrue(np.isnan(gain_control.attrs['_FillValue']))
self.assertEqual("TODO", gain_control.attrs["long_name"])
tb = ds.variables["tb"]
self.assertEqual((5, 4, 28), tb.shape)
self.assertTrue(np.isnan(tb.data[2, 3, 4]))
self.assertTrue(np.isnan(tb.attrs['_FillValue']))
self.assertEqual("TODO", tb.attrs["long_name"])
self.assertEqual("toa_brightness_temperature",
tb.attrs["standard_name"])
self.assertEqual("K", tb.attrs["units"])
thermal_reference = ds.variables["thermal_reference"]
self.assertEqual((4, ), thermal_reference.shape)
self.assertTrue(np.isnan(thermal_reference.data[3]))
self.assertTrue(np.isnan(thermal_reference.attrs['_FillValue']))
self.assertEqual("TODO", thermal_reference.attrs["long_name"])
self.assertEqual("TODO", thermal_reference.attrs["units"])
warm_counts = ds.variables["warm_counts"]
self.assertEqual((4, 4, 28), warm_counts.shape)
self.assertTrue(np.isnan(warm_counts.data[0, 1, 6]))
self.assertTrue(np.isnan(warm_counts.attrs['_FillValue']))
self.assertEqual("TODO", warm_counts.attrs["long_name"])
