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 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_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 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 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()
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()
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"])