Example #1
0
    def add_easy_fcdr_variables(dataset,
                                height,
                                corr_dx=None,
                                corr_dy=None,
                                lut_size=None):
        default_array = DefaultData.create_default_array_3d(SWATH_WIDTH,
                                                            height,
                                                            NUM_CHANNELS,
                                                            np.float32,
                                                            fill_value=np.NaN)
        variable = Variable(["channel", "y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        tu.add_units(variable, "K")
        variable.attrs["long_name"] = "independent uncertainty per pixel"
        dataset["u_independent_tb"] = variable

        default_array = DefaultData.create_default_array_3d(SWATH_WIDTH,
                                                            height,
                                                            NUM_CHANNELS,
                                                            np.float32,
                                                            fill_value=np.NaN)
        variable = Variable(["channel", "y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        tu.add_units(variable, "K")
        variable.attrs["long_name"] = "structured uncertainty per pixel"
        dataset["u_structured_tb"] = variable
Example #2
0
    def test_add_geolocation_attribute(self):
        default_array = DefaultData.create_default_array_3d(
            8, 6, 4, np.float32, np.NaN)
        variable = Variable(["channel", "y", "x"], default_array)

        TemplateUtil.add_geolocation_attribute(variable)
        self.assertEqual("longitude latitude", variable.attrs["coordinates"])
Example #3
0
 def _create_temperature_array_3d(height, long_name, orig_name, dim_names):
     default_array = DefaultData.create_default_array_3d(PRT_READING, height, PRT_NUMBER, np.float32, fill_value=np.NaN, dims_names=dim_names)
     variable = Variable(["prt_number", "y", "prt_reading"], default_array)
     tu.add_fill_value(variable, np.NaN)
     tu.add_units(variable, "K")
     variable.attrs["long_name"] = long_name
     variable.attrs["orig_name"] = orig_name
     return variable
Example #4
0
 def _create_3d_float_variable(height):
     default_array = DefaultData.create_default_array_3d(SWATH_WIDTH,
                                                         height,
                                                         NUM_CHANNELS,
                                                         np.float32,
                                                         fill_value=np.NaN)
     variable = Variable(["channel", "y", "x"], default_array)
     tu.add_fill_value(variable, np.NaN)
     return variable
Example #5
0
 def _create_time_ranges_variable(height, width, description):
     default_array = DefaultData.create_default_array_3d(
         width, height, 2, np.int32, fill_value=4294967295)
     variable = Variable(["bounds", "y", "x"], default_array)
     tu.add_fill_value(variable, 4294967295)
     tu.add_units(variable, "s")
     variable.attrs["description"] = description
     variable.attrs["coordinates"] = "lon lat"
     return variable
Example #6
0
 def _create_easy_fcdr_variable(height, long_name):
     default_array = DefaultData.create_default_array_3d(SWATH_WIDTH, height, NUM_CHANNELS, np.float32, np.NaN)
     variable = Variable(["channel", "y", "x"], default_array)
     tu.add_encoding(variable, np.uint16, DefaultData.get_default_fill_value(np.uint16), 0.001, chunksizes=CHUNKING_BT)
     variable.attrs["long_name"] = long_name
     tu.add_units(variable, "K")
     tu.add_geolocation_attribute(variable)
     variable.attrs["valid_min"] = 1
     variable.attrs["valid_max"] = 65534
     return variable
Example #7
0
 def add_bt_variable(dataset, height):
     # bt
     default_array = DefaultData.create_default_array_3d(SWATH_WIDTH, height, NUM_CHANNELS, np.float32, np.NaN)
     variable = Variable(["channel", "y", "x"], default_array)
     variable.attrs["standard_name"] = "toa_brightness_temperature"
     variable.attrs["long_name"] = "Brightness temperature, NOAA/EUMETSAT calibrated"
     tu.add_units(variable, "K")
     tu.add_encoding(variable, np.int16, FILL_VALUE, 0.01, 150.0, chunksizes=CHUNKING_BT)
     tu.add_geolocation_attribute(variable)
     variable.attrs["ancilliary_variables"] = "quality_scanline_bitmask quality_channel_bitmask"
     dataset["bt"] = variable
Example #8
0
    def add_variables(dataset, width, height, num_samples=10):
        tu.add_geolocation_variables(dataset, width, height, chunksizes=CHUNKING)
        tu.add_quality_flags(dataset, width, height, chunksizes=CHUNKING)

        default_array = DefaultData.create_default_vector(height, np.int32, fill_value=4294967295)
        variable = Variable(["y"], default_array)
        tu.add_fill_value(variable, 4294967295)
        variable.attrs["standard_name"] = "time"
        variable.attrs["long_name"] = "Acquisition time in seconds since 1970-01-01 00:00:00"
        tu.add_units(variable, "s")
        dataset["time"] = variable

        default_array = DefaultData.create_default_array_3d(width, height, num_samples, np.float32, fill_value=np.NaN)
        variable = Variable(["samples","y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["standard_name"] = "sea_surface_temperature"
        variable.attrs["units"] = "K"
        variable.attrs["coordinates"] = "longitude latitude"
        dataset["sst"] = variable
Example #9
0
    def test_add_coordinates_with_channel(self):
        ds = xr.Dataset()
        TemplateUtil.add_geolocation_variables(ds, 8, 11)
        default_array = DefaultData.create_default_array_3d(
            8, 11, 4, np.float32, np.NaN)
        ds["three_d"] = Variable(["channel", "y", "x"], default_array)

        TemplateUtil.add_coordinates(ds)

        x = ds["x"]
        self.assertEqual((8, ), x.shape)
        self.assertEqual(np.uint16, x.dtype)

        y = ds["y"]
        self.assertEqual((11, ), y.shape)
        self.assertEqual(np.uint16, y.dtype)

        channel = ds["channel"]
        self.assertEqual((4, ), channel.shape)
        self.assertEqual(np.uint16, channel.dtype)
Example #10
0
    def add_original_variables(dataset,
                               height,
                               srf_size=None,
                               corr_dx=None,
                               corr_dy=None,
                               lut_size=None):
        tu.add_geolocation_variables(dataset, SWATH_WIDTH, height)
        tu.add_quality_flags(dataset, SWATH_WIDTH, height)

        # btemps
        default_array = DefaultData.create_default_array_3d(
            SWATH_WIDTH, height, NUM_CHANNELS, np.float32, np.NaN)
        variable = Variable(["channel", "y", "x"], default_array)
        variable.attrs["standard_name"] = "toa_brightness_temperature"
        tu.add_encoding(variable, np.int32, -999999, scale_factor=0.01)
        tu.add_units(variable, "K")
        variable.attrs["ancillary_variables"] = "chanqual qualind scanqual"
        dataset["btemps"] = variable

        # chanqual
        default_array = DefaultData.create_default_array(
            height,
            NUM_CHANNELS,
            np.int32,
            dims_names=["channel", "y"],
            fill_value=0)
        variable = Variable(["channel", "y"], default_array)
        variable.attrs["standard_name"] = "status_flag"
        variable.attrs["flag_masks"] = "1, 2, 4, 8, 16, 32"
        variable.attrs[
            "flag_meanings"] = "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"
        dataset["chanqual"] = variable

        # instrtemp
        default_array = DefaultData.create_default_vector(height,
                                                          np.float32,
                                                          fill_value=np.NaN)
        variable = Variable(["y"], default_array)
        tu.add_units(variable, "K")
        tu.add_encoding(variable,
                        np.int32,
                        DefaultData.get_default_fill_value(np.int32),
                        scale_factor=0.01)
        variable.attrs["long_name"] = "instrument_temperature"
        dataset["instrtemp"] = variable

        # qualind
        default_array = DefaultData.create_default_vector(height,
                                                          np.int32,
                                                          fill_value=0)
        variable = Variable(["y"], default_array)
        variable.attrs["standard_name"] = "status_flag"
        variable.attrs[
            "flag_masks"] = "33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648"
        variable.attrs[
            "flag_meanings"] = "instr_status_changed first_good_clock_update no_earth_loc no_calib data_gap_precedes time_seq_error not_use_scan"
        dataset["qualind"] = variable

        # scanqual
        default_array = DefaultData.create_default_vector(height,
                                                          np.int32,
                                                          fill_value=0)
        variable = Variable(["y"], default_array)
        variable.attrs["standard_name"] = "status_flag"
        variable.attrs[
            "flag_masks"] = "8, 16, 32, 64, 128, 1024, 2048, 4096, 8192, 16384, 32768, 1048576, 2097152, 4194304, 8388608"
        variable.attrs[
            "flag_meanings"] = "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"
        dataset["scanqual"] = variable

        # scnlin
        default_array = DefaultData.create_default_vector(height, np.int32)
        variable = Variable(["y"], default_array)
        tu.add_fill_value(variable,
                          DefaultData.get_default_fill_value(np.int32))
        variable.attrs["long_name"] = "scanline"
        dataset["scnlin"] = variable

        # scnlindy
        default_array = DefaultData.create_default_vector(height, np.int32)
        variable = Variable(["y"], default_array)
        tu.add_fill_value(variable,
                          DefaultData.get_default_fill_value(np.int32))
        variable.attrs["long_name"] = "Acquisition day of year of scan"
        dataset["scnlindy"] = variable

        # scnlintime
        default_array = DefaultData.create_default_vector(height, np.int32)
        variable = Variable(["y"], default_array)
        tu.add_fill_value(variable,
                          DefaultData.get_default_fill_value(np.int32))
        variable.attrs[
            "long_name"] = "Acquisition time of scan in milliseconds since beginning of the day"
        tu.add_units(variable, "ms")
        dataset["scnlintime"] = variable

        # scnlinyr
        default_array = DefaultData.create_default_vector(height, np.int32)
        variable = Variable(["y"], default_array)
        tu.add_fill_value(variable,
                          DefaultData.get_default_fill_value(np.int32))
        variable.attrs["long_name"] = "Acquisition year of scan"
        dataset["scnlinyr"] = variable

        # satellite_azimuth_angle
        variable = AMSUB_MHS.create_angle_variable(height,
                                                   "sensor_azimuth_angle")
        dataset["satellite_azimuth_angle"] = variable

        # satellite_zenith_angle
        variable = AMSUB_MHS.create_angle_variable(height,
                                                   "sensor_zenith_angle")
        dataset["satellite_zenith_angle"] = variable

        # solar_azimuth_angle
        variable = AMSUB_MHS.create_angle_variable(height,
                                                   "solar_azimuth_angle")
        dataset["solar_azimuth_angle"] = variable

        # solar_zenith_angle
        variable = AMSUB_MHS.create_angle_variable(height,
                                                   "solar_zenith_angle")
        dataset["solar_zenith_angle"] = variable

        # acquisition_time
        default_array = DefaultData.create_default_vector(height, np.int32)
        variable = Variable(["y"], default_array)
        tu.add_fill_value(variable,
                          DefaultData.get_default_fill_value(np.int32))
        variable.attrs["standard_name"] = "time"
        variable.attrs[
            "long_name"] = "Acquisition time in seconds since 1970-01-01 00:00:00"
        tu.add_units(variable, "s")
        dataset["acquisition_time"] = variable
Example #11
0
 def _create_3d_bt_uncertainty_variable(height, standard_name):
     default_array = DefaultData.create_default_array_3d(SWATH_WIDTH, height, NUM_CHANNELS, np.float32, dims_names=["channel", "y", "x"])
     variable = Variable(["channel", "y", "x"], default_array)
     tu.add_fill_value(variable, DefaultData.get_default_fill_value(np.float32))
     variable.attrs["standard_name"] = standard_name
     return variable
Example #12
0
    def add_full_fcdr_variables(dataset, height):
        # c_earth
        default_array = DefaultData.create_default_array_3d(SWATH_WIDTH, height, NUM_RAD_CHANNELS, np.uint16, dims_names=["rad_channel", "y", "x"])
        variable = Variable(["rad_channel", "y", "x"], default_array)
        tu.add_fill_value(variable, DefaultData.get_default_fill_value(np.uint16))
        variable.attrs["long_name"] = "counts_earth"
        tu.add_units(variable, "count")
        variable.attrs["ancilliary_variables"] = "scnlinf quality_scanline_bitmask quality_channel_bitmask mnfrqualflags"
        dataset["c_earth"] = variable

        # L_earth
        default_array = DefaultData.create_default_array_3d(SWATH_WIDTH, height, NUM_RAD_CHANNELS, np.float32, np.NaN, ["rad_channel", "y", "x"])
        variable = Variable(["rad_channel", "y", "x"], default_array)
        tu.add_encoding(variable, np.uint32, DefaultData.get_default_fill_value(np.uint32), 0.0001)
        variable.attrs["standard_name"] = "toa_outgoing_inband_radiance"
        tu.add_units(variable, "W/Hz/m ** 2/sr")
        variable.attrs["long_name"] = "Channel radiance, NOAA/EUMETSAT calibrated"
        variable.attrs["ancilliary_variables"] = "scnlinf quality_scanline_bitmask quality_channel_bitmask mnfrqualflags"
        dataset["L_earth"] = variable

        # u_lat
        variable = HIRS._create_angle_variable(height, "uncertainty_latitude")
        dataset["u_lat"] = variable

        # u_lon
        variable = HIRS._create_angle_variable(height, "uncertainty_longitude")
        dataset["u_lon"] = variable

        # u_time
        variable = tu.create_float_variable(SWATH_WIDTH, height, "uncertainty_time")
        tu.add_encoding(variable, np.uint16, 65535, 0.01)
        tu.add_units(variable, "s")
        dataset["u_time"] = variable

        # u_c_earth
        default_array = DefaultData.create_default_array(NUM_CALIBRATION_CYCLE, NUM_CHANNELS, np.uint16, dims_names=["channel", "calibration_cycle"])
        variable = Variable(["channel", "calibration_cycle"], default_array)
        tu.add_fill_value(variable, DefaultData.get_default_fill_value(np.uint16))
        tu.add_units(variable, "count")
        variable.attrs["long_name"] = "uncertainty counts for Earth views"
        variable.attrs["ancilliary_variables"] = "u_c_earth_chan_corr"
        variable.attrs["channels_affected"] = "all"
        variable.attrs["parameter"] = "C_E"
        variable.attrs["pdf_shape"] = "gaussian"
        dataset["u_c_earth"] = variable

        # u_L_earth_independent
        variable = HIRS._create_3d_rad_uncertainty_variable(height, "uncertainty_radiance_Earth_random")
        tu.add_encoding(variable, np.uint32, DefaultData.get_default_fill_value(np.uint32), 0.01)
        tu.add_units(variable, "mW m^-2 sr^-1 cm")
        dataset["u_L_earth_independent"] = variable

        # u_L_earth_structured
        variable = HIRS._create_3d_rad_uncertainty_variable(height, "uncertainty_radiance_Earth_structured")
        tu.add_encoding(variable, np.uint32, DefaultData.get_default_fill_value(np.uint32), 0.01)
        tu.add_units(variable, "mW m^-2 sr^-1 cm")
        dataset["u_L_earth_structured"] = variable

        # u_L_earth_systematic
        variable = HIRS._create_3d_rad_uncertainty_variable(height, "uncertainty_radiance_Earth_systematic")
        tu.add_encoding(variable, np.uint32, DefaultData.get_default_fill_value(np.uint32), 0.01)
        tu.add_units(variable, "mW m^-2 sr^-1 cm")
        dataset["u_L_earth_systematic"] = variable

        # u_L_earth_total
        variable = HIRS._create_3d_rad_uncertainty_variable(height, "uncertainty_radiance_Earth_total")
        tu.add_encoding(variable, np.uint32, DefaultData.get_default_fill_value(np.uint32), 0.01)
        tu.add_units(variable, "mW m^-2 sr^-1 cm")
        dataset["u_L_earth_total"] = variable

        # S_u_L_earth
        variable = tu.create_float_variable(NUM_RAD_CHANNELS, NUM_RAD_CHANNELS, "covariance_radiance_Earth", dim_names=["rad_channel", "rad_channel"])
        tu.add_encoding(variable, np.uint32, DefaultData.get_default_fill_value(np.uint32), 0.01)
        dataset["S_u_L_earth"] = variable

        # u_bt_random
        variable = HIRS._create_3d_bt_uncertainty_variable(height, "uncertainty_bt_random")
        tu.add_encoding(variable, np.uint16, DefaultData.get_default_fill_value(np.uint16), 0.01)
        tu.add_units(variable, "K")
        dataset["u_bt_random"] = variable

        # u_bt_structured
        variable = HIRS._create_3d_bt_uncertainty_variable(height, "uncertainty_bt_structured")
        tu.add_encoding(variable, np.uint16, DefaultData.get_default_fill_value(np.uint16), 0.01)
        tu.add_units(variable, "K")
        dataset["u_bt_structured"] = variable

        # u_bt_systematic
        variable = HIRS._create_3d_bt_uncertainty_variable(height, "uncertainty_bt_systematic")
        tu.add_encoding(variable, np.uint16, DefaultData.get_default_fill_value(np.uint16), 0.01)
        tu.add_units(variable, "K")
        dataset["u_bt_systematic"] = variable

        # u_bt_total
        variable = HIRS._create_3d_bt_uncertainty_variable(height, "uncertainty_bt_total")
        tu.add_encoding(variable, np.uint16, DefaultData.get_default_fill_value(np.uint16), 0.01)
        tu.add_units(variable, "K")
        dataset["u_bt_total"] = variable

        # S_bt
        variable = tu.create_float_variable(NUM_RAD_CHANNELS, NUM_RAD_CHANNELS, "covariance_brightness_temperature", dim_names=["rad_channel", "rad_channel"])
        tu.add_encoding(variable, np.uint16, DefaultData.get_default_fill_value(np.uint16), 0.01)
        dataset["S_bt"] = variable

        # l1b_calcof
        default_array = DefaultData.create_default_array(height, NUM_COEFFS, np.float32, dims_names=["coeffs", "y"])
        variable = Variable(["coeffs", "y"], default_array)
        tu.add_encoding(variable, np.int32, DefaultData.get_default_fill_value(np.int32), 0.01)
        variable.attrs["standard_name"] = "calibration_coefficients"
        dataset["l1b_calcof"] = variable

        # navigation_status
        variable = HIRS._create_int32_vector(height, standard_name="status_flag", long_name="Navigation status bit field", orig_name="hrs_navstat")
        dataset["navigation_status"] = variable

        # quality_flags
        variable = HIRS._create_int32_vector(height, standard_name="status_flag", long_name="Quality indicator bit field", orig_name="hrs_qualind")
        dataset["quality_flags"] = variable

        variable = HIRS._create_scaled_uint16_vector(height, long_name="Platform altitude", original_name="hrs_scalti")
        tu.add_units(variable, "km")
        dataset["platform_altitude"] = variable

        variable = HIRS._create_scaled_int16_vector(height, long_name="Platform pitch angle", original_name="hrs_pitchang")
        tu.add_units(variable, "degree")
        dataset["platform_pitch_angle"] = variable

        variable = HIRS._create_scaled_int16_vector(height, long_name="Platform roll angle", original_name="hrs_rollang")
        tu.add_units(variable, "degree")
        dataset["platform_roll_angle"] = variable

        variable = HIRS._create_scaled_int16_vector(height, long_name="Platform yaw angle", original_name="hrs_yawang")
        tu.add_units(variable, "degree")
        dataset["platform_yaw_angle"] = variable

        # scan_angles
        default_array = DefaultData.create_default_array(NUM_SCAN_ANGLES, height, np.float32, dims_names=["y", "num_scan_angles"], fill_value=np.NaN)
        variable = Variable(["y", "num_scan_angles"], default_array)
        tu.add_encoding(variable, np.uint16, DefaultData.get_default_fill_value(np.uint16), scale_factor=0.01)
        tu.add_units(variable, "degree")
        variable.attrs["long_name"] = "Scan angles"
        variable.attrs["orig_name"] = "hrs_ang"
        dataset["scan_angles"] = variable

        dataset["l1b_scanline_number"] = HIRS._create_int16_vector(height, long_name="scanline number", orig_name="hrs_scnlin")
        dataset["scanline_position"] = HIRS._create_int8_vector(height, long_name="Scanline position number in 32 second cycle", orig_name="hrs_scnpos")

        # second_original_calibration_coefficients
        default_array = DefaultData.create_default_array(WIDTH_TODO, height, np.float32, fill_value=np.NaN)
        variable = Variable(["y", "width_todo"], default_array)
        tu.add_encoding(variable, np.int32, DefaultData.get_default_fill_value(np.int32), scale_factor=0.01)
        variable.attrs["long_name"] = "Second original calibration coefficients (unsorted)"
        variable.attrs["orig_name"] = "hrs_scalcof"
        dataset["l1b_second_original_calibration_coefficients"] = variable

        dataset["Tc_baseplate"] = HIRS._create_counts_vector(height, "temperature_baseplate_counts")
        dataset["Tc_ch"] = HIRS._create_counts_vector(height, "temperature_coolerhousing_counts")
        dataset["Tc_elec"] = HIRS._create_counts_vector(height, "temperature_electronics_counts")
        dataset["Tc_fsr"] = HIRS._create_counts_vector(height, "temperature_first_stage_radiator_counts")
        dataset["Tc_fwh"] = HIRS._create_counts_vector(height, "temperature_filter_wheel_housing_counts")
        dataset["Tc_fwm"] = HIRS._create_counts_vector(height, "temperature_filter_wheel_monitor_counts")
        dataset["Tc_icct"] = HIRS._create_counts_vector(height, "temperature_internal_cold_calibration_target_counts")
        dataset["Tc_iwct"] = HIRS._create_counts_vector(height, "temperature_internal_warm_calibration_target_counts")
        dataset["Tc_patch_exp"] = HIRS._create_counts_vector(height, "temperature_patch_expanded_scale_counts")
        dataset["Tc_patch_full"] = HIRS._create_counts_vector(height, "temperature_patch_full_range_counts")
        dataset["Tc_tlscp_prim"] = HIRS._create_counts_vector(height, "temperature_telescope_primary_counts")
        dataset["Tc_tlscp_sec"] = HIRS._create_counts_vector(height, "temperature_telescope_secondary_counts")
        dataset["Tc_tlscp_tert"] = HIRS._create_counts_vector(height, "temperature_telescope_tertiary_counts")
        dataset["Tc_scanmirror"] = HIRS._create_counts_vector(height, "temperature_scanmirror_counts")
        dataset["Tc_scanmotor"] = HIRS._create_counts_vector(height, "temperature_scanmotor_counts")

        dataset["u_Tc_baseplate"] = HIRS._create_counts_uncertainty_vector(height, "uncertainty_temperature_baseplate_counts")
        dataset["u_Tc_ch"] = HIRS._create_counts_uncertainty_vector(height, "uncertainty_temperature_coolerhousing_counts")
        dataset["u_Tc_elec"] = HIRS._create_counts_uncertainty_vector(height, "uncertainty_temperature_electronics_counts")
        dataset["u_Tc_fsr"] = HIRS._create_counts_uncertainty_vector(height, "uncertainty_temperature_first_stage_radiator_counts")
        dataset["u_Tc_fwh"] = HIRS._create_counts_uncertainty_vector(height, "uncertainty_temperature_filter_wheel_housing_counts")
        dataset["u_Tc_fwm"] = HIRS._create_counts_uncertainty_vector(height, "uncertainty_temperature_filter_wheel_monitor_counts")
        dataset["u_Tc_icct"] = HIRS._create_counts_uncertainty_vector_uint32(height, "uncertainty_temperature_internal_cold_calibration_target_counts")
        dataset["u_Tc_iwct"] = HIRS._create_counts_uncertainty_vector_uint32(height, "uncertainty_temperature_internal_warm_calibration_target_counts")
        dataset["u_Tc_patch_exp"] = HIRS._create_counts_uncertainty_vector_uint32(height, "uncertainty_temperature_patch_expanded_scale_counts")
        dataset["u_Tc_patch_full"] = HIRS._create_counts_uncertainty_vector_uint32(height, "uncertainty_temperature_patch_full_range_counts")
        dataset["u_Tc_tlscp_prim"] = HIRS._create_counts_uncertainty_vector_uint32(height, "uncertainty_temperature_telescope_primary_counts")
        dataset["u_Tc_tlscp_sec"] = HIRS._create_counts_uncertainty_vector_uint32(height, "uncertainty_temperature_telescope_secondary_counts")
        dataset["u_Tc_tlscp_tert"] = HIRS._create_counts_uncertainty_vector_uint32(height, "uncertainty_temperature_telescope_tertiary_counts")
        dataset["u_Tc_scanmirror"] = HIRS._create_counts_uncertainty_vector_uint32(height, "uncertainty_temperature_scanmirror_counts")
        dataset["u_Tc_scanmotor"] = HIRS._create_counts_uncertainty_vector_uint32(height, "uncertainty_temperature_scanmotor_counts")

        dataset["u_sol_za"] = HIRS._create_geo_angle_uncertainty_variable("uncertainty_solar_zenith_angle", height, FILL_VALUE)
        dataset["u_sol_aa"] = HIRS._create_geo_angle_uncertainty_variable("uncertainty_solar_azimuth_angle", height, FILL_VALUE)
        dataset["u_sat_za"] = HIRS._create_geo_angle_uncertainty_variable("uncertainty_satellite_zenith_angle", height, FILL_VALUE)
        dataset["u_sat_aa"] = HIRS._create_geo_angle_uncertainty_variable("uncertainty_local_azimuth_angle", height, FILL_VALUE)

        # u_c_earth_chan_corr
        dataset["u_c_earth_chan_corr"] = HIRS._create_channel_correlation_variable("u_c_earth channel correlations", np.int16)

        # u_c_space
        default_array = DefaultData.create_default_array(NUM_CALIBRATION_CYCLE, NUM_CHANNELS, np.uint16, dims_names=["channel", "calibration_cycle"])
        variable = Variable(["channel", "calibration_cycle"], default_array)
        tu.add_fill_value(variable, DefaultData.get_default_fill_value(np.uint16))
        tu.add_units(variable, "count")
        tu.add_scale_factor(variable, 0.005)
        variable.attrs["long_name"] = "uncertainty counts for space views"
        variable.attrs["ancilliary_variables"] = "u_c_space_chan_corr"
        variable.attrs["channels_affected"] = "all"
        variable.attrs["parameter"] = "C_s"
        variable.attrs["pdf_shape"] = "gaussian"
        dataset["u_c_space"] = variable

        # u_c_space_chan_corr
        dataset["u_c_space_chan_corr"] = HIRS._create_channel_correlation_variable("u_c_space channel correlations", np.uint16)

        # u_Earthshine
        dataset["u_Earthshine"] = HIRS._create_channel_uncertainty_uint16(height)

        # u_O_Re
        dataset["u_O_Re"] = HIRS._create_channel_uncertainty_uint16(height)

        # u_O_TIWCT
        default_array = DefaultData.create_default_vector(height, np.float32, np.NaN)
        variable = Variable(["y"], default_array)
        tu.add_encoding(variable, np.uint16, DefaultData.get_default_fill_value(np.uint16), 0.01)
        dataset["u_O_TIWCT"] = variable

        # u_O_TPRT
        default_array = DefaultData.create_default_vector(height, np.uint16, DefaultData.get_default_fill_value(np.uint16))
        variable = Variable(["y"], default_array)
        tu.add_fill_value(variable, 65535)
        tu.add_scale_factor(variable, 0.01)
        tu.add_units(variable, "K")
        variable.attrs["channels_affected"] = "all"
        variable.attrs[corr.PIX_CORR_FORM] = corr.RECT_ABS
        variable.attrs[corr.PIX_CORR_UNIT] = corr.PIXEL
        variable.attrs[corr.PIX_CORR_SCALE] = [-np.inf, np.inf]
        variable.attrs[corr.SCAN_CORR_FORM] = corr.RECT_ABS
        variable.attrs[corr.SCAN_CORR_UNIT] = corr.LINE
        variable.attrs[corr.SCAN_CORR_SCALE] = [-np.inf, np.inf]
        variable.attrs[corr.IMG_CORR_FORM] = corr.RECT_ABS
        variable.attrs[corr.IMG_CORR_UNIT] = corr.IMG
        variable.attrs[corr.IMG_CORR_SCALE] = [-np.inf, np.inf]
        variable.attrs["parameter"] = "O_TPRT"
        variable.attrs["pdf_shape"] = "gaussian"
        variable.attrs["short_name"] = "O_TPRT"
        variable.attrs["ancilliary_variables"] = "u_O_TPRT_chan_corr"
        dataset["u_O_TPRT"] = variable

        dataset["u_Rself"] = HIRS._create_channel_uncertainty_uint16(height)
        dataset["u_SRF_calib"] = HIRS._create_channel_uncertainty_uint16(height)

        default_array = DefaultData.create_default_array(PRT_NUMBER_IWT, PRT_READING, dtype=np.float32, dims_names=["prt_number_iwt", "prt_reading"], fill_value=np.NaN)
        variable = Variable(["prt_number_iwt", "prt_reading"], default_array)
        tu.add_encoding(variable, np.uint16, DefaultData.get_default_fill_value(np.uint16), 0.01)
        dataset["u_d_PRT"] = variable

        dataset["u_electronics"] = HIRS._create_channel_uncertainty_uint16(height)
        dataset["u_periodic_noise"] = HIRS._create_channel_uncertainty_uint16(height)
        dataset["u_nonlinearity"] = HIRS._create_scaled_uint16_vector(NUM_CHANNELS, dimension_name=["channel"], scale_factor=0.01)
        dataset["emissivity"] = tu.create_scalar_float_variable("emissivity", units="1")
        dataset["temp_corr_slope"] = tu.create_scalar_float_variable("Slope for effective temperature correction", units="1")
        dataset["temp_corr_offset"] = tu.create_scalar_float_variable("Offset for effective temperature correction", units="1")

        # mnfrqualflags
        default_array = DefaultData.create_default_array(NUM_MINOR_FRAME, height, np.int32, dims_names=["y", "minor_frame"], fill_value=0)
        variable = Variable(["y", "minor_frame"], default_array)
        variable.attrs["standard_name"] = "status_flag"
        variable.attrs["long_name"] = "minor_frame_quality_flags_bitfield"
        dataset["mnfrqualflags"] = variable

        # scnlintime
        variable = HIRS._create_int32_vector(height, standard_name="time", long_name="Scan line time of day", orig_name="hrs_scnlintime")
        tu.add_units(variable, "ms")
        dataset["scnlintime"] = variable

        # scnlinf
        default_array = DefaultData.create_default_vector(height, np.int16, fill_value=0)
        variable = Variable(["y"], default_array)
        variable.attrs["standard_name"] = "status_flag"
        variable.attrs["long_name"] = "scanline_bitfield"
        variable.attrs["flag_masks"] = "16384, 32768"
        variable.attrs["flag_meanings"] = "clock_drift_correction southbound_data"
        dataset["scnlinf"] = variable

        # scantype
        default_array = DefaultData.create_default_vector(height, np.int8, fill_value=0)
        variable = Variable(["y"], default_array)
        variable.attrs["standard_name"] = "status_flag"
        variable.attrs["long_name"] = "scantype_bitfield"
        variable.attrs["flag_values"] = "0, 1, 2, 3"
        variable.attrs["flag_meanings"] = "earth_view space_view cold_bb_view main_bb_view"
        dataset["scantype"] = variable
Example #13
0
    def add_full_fcdr_variables(dataset, height):
        # u_Temperature_misc_housekeeping
        default_array = DefaultData.create_default_array(
            height,
            NUM_THERMISTORS,
            np.float32,
            dims_names=["housekeeping", "y"],
            fill_value=np.NaN)
        variable = Variable(["housekeeping", "y"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        variable.attrs["units"] = "TODO"
        dataset["u_Temperature_misc_housekeeping"] = variable

        # u_cold_counts
        default_array = DefaultData.create_default_array_3d(
            SWATH_WIDTH, height, CALIB_NUMBER, np.float32, np.NaN)
        variable = Variable(["calib_number", "y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["u_cold_counts"] = variable

        # u_counts_to_tb_gain
        default_array = DefaultData.create_default_array(
            height,
            NUM_CHANNELS,
            np.float32,
            dims_names=["channel", "y"],
            fill_value=np.NaN)
        variable = Variable([
            "channel",
            "y",
        ], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["u_counts_to_tb_gain"] = variable

        # u_counts_to_tb_offset
        default_array = DefaultData.create_default_array(
            height,
            NUM_CHANNELS,
            np.float32,
            dims_names=["channel", "y"],
            fill_value=np.NaN)
        variable = Variable([
            "channel",
            "y",
        ], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["u_counts_to_tb_offset"] = variable

        # u_gain_control
        default_array = DefaultData.create_default_array(
            height,
            NUM_CHANNELS,
            np.float32,
            dims_names=["channel", "y"],
            fill_value=np.NaN)
        variable = Variable([
            "channel",
            "y",
        ], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["u_gain_control"] = variable

        # u_tb
        default_array = DefaultData.create_default_array_3d(
            SWATH_WIDTH, height, NUM_CHANNELS, np.float32, np.NaN)
        variable = Variable(["channel", "y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        tu.add_units(variable, "K")
        dataset["u_tb"] = variable

        # u_thermal_reference
        default_array = DefaultData.create_default_vector(
            height, np.float32, np.NaN)
        variable = Variable(["y"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        tu.add_units(variable, "TODO")
        dataset["u_thermal_reference"] = variable

        # u_warm_counts
        default_array = DefaultData.create_default_array_3d(
            SWATH_WIDTH, height, CALIB_NUMBER, np.float32, np.NaN)
        variable = Variable(["calib_number", "y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["u_warm_counts"] = variable
Example #14
0
    def add_original_variables(dataset, height, srf_size=None):
        tu.add_geolocation_variables(dataset, SWATH_WIDTH, height)
        tu.add_quality_flags(dataset, SWATH_WIDTH, height)

        # Temperature_misc_housekeeping
        default_array = DefaultData.create_default_array(
            height,
            NUM_THERMISTORS,
            np.float32,
            dims_names=["housekeeping", "y"],
            fill_value=np.NaN)
        variable = Variable(["housekeeping", "y"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        variable.attrs["units"] = "TODO"
        dataset["Temperature_misc_housekeeping"] = variable

        # ancil_data
        default_array = DefaultData.create_default_array(
            height,
            ANCIL_VAL,
            np.float64,
            dims_names=["ancil_val", "y"],
            fill_value=np.NaN)
        variable = Variable(["ancil_val", "y"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "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"
        dataset["ancil_data"] = variable

        # channel_quality_flag
        default_array = DefaultData.create_default_array_3d(
            SWATH_WIDTH, height, NUM_CHANNELS, np.float32, np.NaN)
        variable = Variable(["channel", "y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        dataset["channel_quality_flag"] = variable

        # cold_counts
        default_array = DefaultData.create_default_array_3d(
            SWATH_WIDTH, height, CALIB_NUMBER, np.float32, np.NaN)
        variable = Variable(["calib_number", "y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["cold_counts"] = variable

        # counts_to_tb_gain
        default_array = DefaultData.create_default_array(
            height,
            NUM_CHANNELS,
            np.float32,
            dims_names=["channel", "y"],
            fill_value=np.NaN)
        variable = Variable([
            "channel",
            "y",
        ], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["counts_to_tb_gain"] = variable

        # counts_to_tb_offset
        default_array = DefaultData.create_default_array(
            height,
            NUM_CHANNELS,
            np.float32,
            dims_names=["channel", "y"],
            fill_value=np.NaN)
        variable = Variable([
            "channel",
            "y",
        ], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["counts_to_tb_offset"] = variable

        # gain_control
        default_array = DefaultData.create_default_array(
            height,
            NUM_CHANNELS,
            np.float32,
            dims_names=["channel", "y"],
            fill_value=np.NaN)
        variable = Variable([
            "channel",
            "y",
        ], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["gain_control"] = variable

        # tb
        default_array = DefaultData.create_default_array_3d(
            SWATH_WIDTH, height, NUM_CHANNELS, np.float32, np.NaN)
        variable = Variable(["channel", "y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        variable.attrs["standard_name"] = "toa_brightness_temperature"
        tu.add_units(variable, "K")
        dataset["tb"] = variable

        # thermal_reference
        default_array = DefaultData.create_default_vector(
            height, np.float32, np.NaN)
        variable = Variable(["y"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        tu.add_units(variable, "TODO")
        dataset["thermal_reference"] = variable

        # warm_counts
        default_array = DefaultData.create_default_array_3d(
            SWATH_WIDTH, height, CALIB_NUMBER, np.float32, np.NaN)
        variable = Variable(["calib_number", "y", "x"], default_array)
        tu.add_fill_value(variable, np.NaN)
        variable.attrs["long_name"] = "TODO"
        dataset["warm_counts"] = variable