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)
