def test_transpose(): x = np.arange(10) x_transposed = utils.transpose(x) assert x.shape == (10, ) assert x_transposed.shape == (10, 1) with pytest.raises(ValueError): utils.transpose(np.array([1])) with pytest.raises(ValueError): utils.transpose(np.array([[1, 2], [3, 5]]))
def _specific_to_gas_atten(self, specific_atten: np.ndarray) -> np.ndarray: layer1_atten = self._model["gas_atten"][:, 0] atten_cumsum = ma.cumsum(specific_atten, axis=1) atten = TWO_WAY * atten_cumsum * self._dheight * M_TO_KM atten += utils.transpose(layer1_atten) atten = np.insert(atten, 0, layer1_atten, axis=1)[:, :-1] return ma.array(atten, mask=atten_cumsum.mask)
def _specific_to_gas_atten(self, specific_atten): layer1_atten = self._model['gas_atten'][:, 0] atten_cumsum = np.cumsum(specific_atten, axis=1) atten = TWO_WAY * atten_cumsum * self._dheight * M_TO_KM atten += utils.transpose(layer1_atten) atten = np.insert(atten, 0, layer1_atten, axis=1)[:, :-1] return atten
def test_calc_combined_error(): from cloudnetpy.utils import l2norm, transpose err_2d = np.array([[0, 0.1, 0.1], [0.2, 0.4, 0.15]]) err_1d = np.array([0.3, 0.2]) expected = l2norm(err_2d, transpose(err_1d)) assert_array_equal(ERROR_OBJ._calc_combined_error(err_2d, err_1d), expected)
def _find_would_be_drizzle(self): return (~utils.transpose(self.is_rain) & self.warm_liquid & self.category_bits['falling'] & ~self.category_bits['melting'] & ~self.category_bits['insect'] & self.quality_bits['radar'] & ~self.quality_bits['clutter'] & ~self.quality_bits['molecular'])
def _find_would_be_drizzle(self): return (~utils.transpose(self.is_rain) & self.warm_liquid & self.category_bits["falling"] & ~self.category_bits["melting"] & ~self.category_bits["insect"] & self.quality_bits["radar"] & ~self.quality_bits["clutter"] & ~self.quality_bits["molecular"])
def _convert_backscatter(self): """Steps to convert Jenoptik SNR to raw beta.""" beta_raw = self._getvar('beta_raw') data_std = self._getvar('stddev') normalised_apd = self._get_nn() beta_raw *= utils.transpose(data_std / normalised_apd) if not self.calibration_info.is_range_corrected: beta_raw *= self.range**2 overlap_function = _get_overlap(self.range, self.calibration_info) beta_raw /= overlap_function beta_raw *= self.calibration_info.calibration_factor return beta_raw
def _find_drizzle(self): return (~utils.transpose(self.is_rain) & self.category_bits['falling'] & ~self.category_bits['droplet'] & ~self.category_bits['cold'] & ~self.category_bits['melting'] & ~self.category_bits['insect'] & self.quality_bits['radar'] & self.quality_bits['lidar'] & ~self.quality_bits['clutter'] & ~self.quality_bits['molecular'] & ~self.quality_bits['attenuated'] & self.is_v_sigma)
def _find_drizzle(self): return (~utils.transpose(self.is_rain) & self.category_bits["falling"] & ~self.category_bits["droplet"] & ~self.category_bits["cold"] & ~self.category_bits["melting"] & ~self.category_bits["insect"] & self.quality_bits["radar"] & self.quality_bits["lidar"] & ~self.quality_bits["clutter"] & ~self.quality_bits["molecular"] & ~self.quality_bits["attenuated"] & self.is_v_sigma)
def _remove_noise(self, array: np.ndarray, noise: np.ndarray, keep_negative: bool, snr_limit: float) -> np.ndarray: snr = array / utils.transpose(noise) if self.range_corrected is False: snr_scale_factor = 6 ind = self._get_altitude_ind() snr[:, ind] *= snr_scale_factor if ma.isMaskedArray(array) is False: array = ma.masked_array(array) if keep_negative is True: array[np.abs(snr) < snr_limit] = ma.masked else: array[snr < snr_limit] = ma.masked return array
def _get_probabilities(obs): smooth_v = _get_smoothed_v(obs) lwp_interp = droplet.interpolate_lwp(obs) fun = utils.array_to_probability return { 'width': fun(obs.width, 1, 0.3, True), 'z': fun(obs.z, -15, 8, True), 'ldr': fun(obs.ldr, -20, 5), 'temp_loose': fun(obs.tw, 268, 2), 'temp_strict': fun(obs.tw, 274, 1), 'v': fun(smooth_v, -2.5, 2), 'lwp': utils.transpose(fun(lwp_interp, 150, 50, invert=True)), 'v_sigma': fun(obs.v_sigma, 0.01, 0.1) }
def _get_probabilities(obs: ClassData) -> dict: smooth_v = _get_smoothed_v(obs) lwp_interp = droplet.interpolate_lwp(obs) fun = utils.array_to_probability return { "width": fun(obs.width, 1, 0.3, True) if hasattr(obs, "width") else 1, "z_strong": fun(obs.z, 0, 8, True), "z_weak": fun(obs.z, -20, 8, True), "ldr": fun(obs.ldr, -25, 5) if hasattr(obs, "ldr") else None, "temp_loose": fun(obs.tw, 268, 2), "temp_strict": fun(obs.tw, 274, 1), "v": fun(smooth_v, -3.5, 2), "lwp": utils.transpose(fun(lwp_interp, 150, 50, invert=True)), "v_sigma": fun(obs.v_sigma, 0.01, 0.1), }
def _fetch_beta_raw(self, calibration_factor: Optional[float] = None) -> None: if calibration_factor is None: logging.warning("Using default calibration factor") calibration_factor = 3e-12 beta_raw = self._getvar("beta_raw", "beta_att") old_version = self._get_old_software_version() if old_version is not None: logging.warning( f"Software version {old_version}. Assuming data not range corrected." ) data_std = self._getvar("stddev") normalised_apd = self._get_nn() beta_raw *= utils.transpose(data_std / normalised_apd) beta_raw *= self.data["range"]**2 beta_raw *= calibration_factor self.data["calibration_factor"] = float(calibration_factor) self.data["beta_raw"] = beta_raw
def _find_clutter(v: np.ma.MaskedArray, is_rain: np.ndarray, n_gates: int = 10, v_lim: float = 0.05) -> np.ndarray: """Estimates clutter from doppler velocity. Args: n_gates: Number of range gates from the ground where clutter is expected to be found. Default is 10. v_lim: Velocity threshold. Smaller values are classified as clutter. Default is 0.05 (m/s). Returns: 2-D boolean array denoting pixels contaminated by clutter. """ is_clutter = np.zeros(v.shape, dtype=bool) tiny_velocity = (np.abs(v[:, :n_gates]) < v_lim).filled(False) is_clutter[:, :n_gates] = tiny_velocity * utils.transpose(~is_rain) return is_clutter
def test_transpose(): x = np.arange(10) x_transposed = utils.transpose(x) assert x.shape == (10, ) assert x_transposed.shape == (10, 1)
def _find_cold_above_rain(self) -> np.ndarray: is_cold = self.category_bits["cold"] is_rain = utils.transpose(self.is_rain) is_cold_rain = (is_cold * is_rain) == 1 return is_cold_rain & ~self.category_bits["melting"]
def _find_ice_above_rain(self) -> np.ndarray: is_rain = utils.transpose(self.is_rain) return (self.is_ice * is_rain) == 1
def _find_cold_above_rain(self): is_cold = self.category_bits['cold'] is_rain = utils.transpose(self.is_rain) return (((is_cold * is_rain) == 1) & ~self.category_bits['melting'])
def test_transpose_2(index, result): x = np.arange(5) assert utils.transpose(x)[index] == result
def _calc_combined_error(error_2d, error_1d): error_1d_transposed = utils.transpose(error_1d) return utils.l2norm(error_2d, error_1d_transposed)
def _find_retrieval_below_melting(self): cold_rain = utils.transpose(self.drizzle_class.cold_rain) below_melting = cold_rain * self.drizzle_class.drizzle self.retrieval_status[below_melting == 1] = 2
def _calc_combined_error(error_2d: np.ndarray, error_1d: np.ndarray) -> np.ndarray: error_1d_transposed = utils.transpose(error_1d) return utils.l2norm(error_2d, error_1d_transposed)