cloudnetpy 1.49.9__py3-none-any.whl → 1.87.3__py3-none-any.whl

cloudnetpy/instruments/ceilometer.py

@@ -1,171 +1,245 @@
+import datetime
 import logging
+from typing import NamedTuple
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy.ndimage import gaussian_filter
 
 from cloudnetpy import utils
 from cloudnetpy.cloudnetarray import CloudnetArray
+from cloudnetpy.exceptions import ValidTimeStampError
 from cloudnetpy.instruments.instruments import Instrument
-from cloudnetpy.utils import Epoch
 
 
-class NoiseParam:
+class NoiseParam(NamedTuple):
     """Noise parameters. Values are weakly instrument-dependent."""
 
-    def __init__(self, noise_min: float = 1e-9, noise_smooth_min: float = 4e-9):
-        self.noise_min = noise_min
-        self.noise_smooth_min = noise_smooth_min
+    noise_min: float = 1e-9
+    noise_smooth_min: float = 4e-9
 
 
 class Ceilometer:
     """Base class for all types of ceilometers and pollyxt."""
 
-    def __init__(self, noise_param: NoiseParam = NoiseParam()):
-        self.noise_param = noise_param
+    def __init__(self, noise_param: NoiseParam | None = None) -> None:
+        self.noise_param = noise_param or NoiseParam()
         self.data: dict = {}  # Need to contain 'beta_raw', 'range' and 'time'
         self.metadata: dict = {}  # Need to contain 'date' as ('yyyy', 'mm', 'dd')
-        self.expected_date: str | None = None
+        self.expected_date: datetime.date | None = None
         self.site_meta: dict = {}
-        self.date: list[str] = []
+        self.date: datetime.date
         self.instrument: Instrument | None = None
+        self.serial_number: str | None = None
 
     def calc_screened_product(
         self,
-        array: np.ndarray,
+        array: npt.NDArray,
         snr_limit: int = 5,
+        n_negatives: int = 5,
+        *,
         range_corrected: bool = True,
-    ) -> np.ndarray:
+    ) -> npt.NDArray:
         """Screens noise from lidar variable."""
-        noisy_data = NoisyData(self.data, self.noise_param, range_corrected)
-        array_screened = noisy_data.screen_data(array, snr_limit=snr_limit)
-        return array_screened
+        noisy_data = NoisyData(
+            self.data,
+            self.noise_param,
+            range_corrected=range_corrected,
+            instrument=self.instrument,
+        )
+        return noisy_data.screen_data(
+            array,
+            snr_limit=snr_limit,
+            n_negatives=n_negatives,
+        )
 
     def calc_beta_smooth(
         self,
-        beta: np.ndarray,
+        beta: npt.NDArray,
         snr_limit: int = 5,
+        n_negatives: int = 5,
+        *,
         range_corrected: bool = True,
-    ) -> np.ndarray:
-        noisy_data = NoisyData(self.data, self.noise_param, range_corrected)
+    ) -> npt.NDArray:
+        noisy_data = NoisyData(
+            self.data,
+            self.noise_param,
+            range_corrected=range_corrected,
+            instrument=self.instrument,
+        )
         beta_raw = ma.copy(self.data["beta_raw"])
         cloud_ind, cloud_values, cloud_limit = _estimate_clouds_from_beta(beta)
         beta_raw[cloud_ind] = cloud_limit
         sigma = calc_sigma_units(self.data["time"], self.data["range"])
         beta_raw_smooth = gaussian_filter(beta_raw, sigma)
         beta_raw_smooth[cloud_ind] = cloud_values
-        beta_smooth = noisy_data.screen_data(
-            beta_raw_smooth, is_smoothed=True, snr_limit=snr_limit
+        return noisy_data.screen_data(
+            beta_raw_smooth,
+            is_smoothed=True,
+            snr_limit=snr_limit,
+            n_negatives=n_negatives,
         )
-        return beta_smooth
 
-    def prepare_data(self):
+    def prepare_data(self) -> None:
         """Add common additional data / metadata and convert into CloudnetArrays."""
         zenith_angle = self.data["zenith_angle"]
         self.data["height"] = np.array(
             self.site_meta["altitude"]
-            + utils.range_to_height(self.data["range"], zenith_angle)
+            + utils.range_to_height(self.data["range"], zenith_angle),
         )
         for key in ("time", "range"):
             self.data[key] = np.array(self.data[key])
-        assert self.instrument is not None
-        assert self.instrument.wavelength is not None
+        if self.instrument is None or self.instrument.wavelength is None:
+            msg = "Instrument wavelength not defined"
+            raise RuntimeError(msg)
         self.data["wavelength"] = float(self.instrument.wavelength)
-        for key in ("latitude", "longitude", "altitude"):
-            if key in self.site_meta:
-                self.data[key] = float(self.site_meta[key])
 
-    def get_date_and_time(self, epoch: Epoch) -> None:
+    def get_date_and_time(self, epoch: datetime.datetime) -> None:
+        if "time" not in self.data:
+            msg = "Time array missing from data"
+            raise ValidTimeStampError(msg)
         if self.expected_date is not None:
             self.data = utils.screen_by_time(self.data, epoch, self.expected_date)
-        self.date = utils.seconds2date(self.data["time"][0], epoch=epoch)[:3]
+        self.date = utils.seconds2date(self.data["time"][0], epoch=epoch).date()
         self.data["time"] = utils.seconds2hours(self.data["time"])
 
-    def remove_raw_data(self):
-        keys = [key for key in self.data.keys() if "raw" in key]
-        for key in keys:
-            del self.data[key]
-        self.data.pop("x_pol", None)
-        self.data.pop("p_pol", None)
-
-    def data_to_cloudnet_arrays(self):
+    def data_to_cloudnet_arrays(self, time_dtype: str = "f4") -> None:
         for key, array in self.data.items():
-            self.data[key] = CloudnetArray(array, key)
+            if key == "time":
+                self.data[key] = CloudnetArray(array, key, data_type=time_dtype)
+            else:
+                self.data[key] = CloudnetArray(array, key)
 
-    def screen_depol(self):
+    def add_site_geolocation(self) -> None:
+        utils.add_site_geolocation(self.data, gps=False, site_meta=self.site_meta)
+
+    def screen_depol(self) -> None:
         key = "depolarisation"
         if key in self.data:
             self.data[key][self.data[key] <= 0] = ma.masked
             self.data[key][self.data[key] > 1] = ma.masked
 
-    def add_snr_info(self, key: str, snr_limit: float):
+    def screen_invalid_values(self) -> None:
+        for key in self.data:
+            try:
+                if self.data[key][:].ndim == 2:
+                    self.data[key] = ma.masked_invalid(self.data[key])
+            except (IndexError, TypeError):
+                continue
+
+    def add_snr_info(self, key: str, snr_limit: float) -> None:
         if key in self.data:
             self.data[key].comment += f" SNR threshold applied: {snr_limit}."
 
+    def check_beta_raw_shape(self) -> None:
+        beta_raw = self.data["beta_raw"]
+        if beta_raw.ndim != 2 or (beta_raw.shape[0] == 1 or beta_raw.shape[1] == 1):
+            msg = f"Invalid beta_raw shape: {beta_raw.shape}"
+            raise ValidTimeStampError(msg)
+
+    def screen_sunbeam(self) -> None:
+        high_alt_mask = self.data["range"] > 10000
+        if not np.any(high_alt_mask):
+            return
+
+        is_data = ~self.data["beta"][:, high_alt_mask].mask
+        n_bins = 20
+
+        n_profiles, n_heights = is_data.shape
+        bin_size = n_heights // n_bins
+        reshaped = is_data[:, : bin_size * n_bins].reshape(n_profiles, n_bins, bin_size)
+
+        valid_profiles = np.any(reshaped, axis=2).sum(axis=1) < 15
+
+        for key, value in self.data.items():
+            if key == "time" or (isinstance(value, np.ndarray) and value.ndim == 2):
+                self.data[key] = value[valid_profiles]
+
 
 class NoisyData:
     def __init__(
-        self, data: dict, noise_param: NoiseParam, range_corrected: bool = True
-    ):
+        self,
+        data: dict,
+        noise_param: NoiseParam,
+        *,
+        range_corrected: bool = True,
+        instrument: Instrument | None = None,
+    ) -> None:
         self.data = data
         self.noise_param = noise_param
         self.range_corrected = range_corrected
+        self.instrument = instrument
 
     def screen_data(
         self,
-        data_in: np.ndarray,
+        data_in: npt.NDArray,
         snr_limit: float = 5,
+        n_negatives: int = 5,
+        *,
         is_smoothed: bool = False,
         keep_negative: bool = False,
         filter_fog: bool = True,
         filter_negatives: bool = True,
         filter_snr: bool = True,
-    ) -> np.ndarray:
-        data = ma.copy(data_in)
+    ) -> npt.NDArray:
+        data: npt.NDArray = ma.copy(data_in)
         self._calc_range_uncorrected(data)
         noise = _estimate_background_noise(data)
-        noise = self._adjust_noise(noise, is_smoothed)
+        noise = self._adjust_noise(noise, is_smoothed=is_smoothed)
         if filter_negatives is True:
-            is_negative = self._mask_low_values_above_consequent_negatives(data)
+            is_negative = self._mask_low_values_above_consequent_negatives(
+                data,
+                n_negatives=n_negatives,
+            )
             noise[is_negative] = 1e-12
         if filter_fog is True:
             is_fog = self._find_fog_profiles()
             self._clean_fog_profiles(data, is_fog)
             noise[is_fog] = 1e-12
         if filter_snr is True:
-            data = self._remove_noise(data, noise, keep_negative, snr_limit)
+            data = self._remove_noise(
+                data,
+                noise,
+                keep_negative=keep_negative,
+                snr_limit=snr_limit,
+            )
         self._calc_range_corrected(data)
         return data
 
-    def _adjust_noise(self, noise: np.ndarray, is_smoothed: bool) -> np.ndarray:
+    def _adjust_noise(self, noise: npt.NDArray, *, is_smoothed: bool) -> npt.NDArray:
         noise_min = (
             self.noise_param.noise_smooth_min
             if is_smoothed is True
             else self.noise_param.noise_min
         )
         noise_below_threshold = noise < noise_min
-        logging.debug(f"Adjusted noise of {sum(noise_below_threshold)} profiles")
+        logging.debug(
+            "Adjusted noise of %s profiles",
+            sum(np.array(noise_below_threshold)),
+        )
         noise[noise_below_threshold] = noise_min
         return noise
 
     @staticmethod
     def _mask_low_values_above_consequent_negatives(
-        data: np.ndarray,
+        data: npt.NDArray,
         n_negatives: int = 5,
         threshold: float = 8e-6,
         n_gates: int = 95,
         n_skip_lowest: int = 5,
-    ) -> np.ndarray:
+    ) -> npt.NDArray:
         negative_data = data[:, n_skip_lowest : n_gates + n_skip_lowest] < 0
         n_consequent_negatives = utils.cumsumr(negative_data, axis=1)
         time_indices, alt_indices = np.where(n_consequent_negatives > n_negatives)
         alt_indices += n_skip_lowest
-        for time_ind, alt_ind in zip(time_indices, alt_indices):
+        for time_ind, alt_ind in zip(time_indices, alt_indices, strict=True):
             profile = data[time_ind, alt_ind:]
             profile[profile < threshold] = ma.masked
         cleaned_time_indices = np.unique(time_indices)
         logging.debug(
-            f"Cleaned {len(cleaned_time_indices)} profiles with negative filter"
+            "Cleaned %s profiles with negative filter",
+            len(cleaned_time_indices),
         )
         return cleaned_time_indices
 
@@ -174,23 +248,25 @@ class NoisyData:
         n_gates_for_signal_sum: int = 20,
         signal_sum_threshold: float = 1e-3,
         variance_threshold: float = 1e-15,
-    ) -> np.ndarray:
+    ) -> npt.NDArray:
         """Finds saturated (usually fog) profiles from beta_raw."""
         signal_sum = ma.sum(
-            ma.abs(self.data["beta_raw"][:, :n_gates_for_signal_sum]), axis=1
+            ma.abs(self.data["beta_raw"][:, :n_gates_for_signal_sum]),
+            axis=1,
         )
         variance = _calc_var_from_top_gates(self.data["beta_raw"])
         is_fog = (signal_sum > signal_sum_threshold) | (variance < variance_threshold)
-        logging.debug(f"Cleaned {sum(is_fog)} profiles with fog filter")
+        logging.debug("Cleaned %s profiles with fog filter", sum(is_fog))
         return is_fog
 
     def _remove_noise(
         self,
-        array: np.ndarray,
-        noise: np.ndarray,
+        array: npt.NDArray,
+        noise: npt.NDArray,
+        *,
         keep_negative: bool,
         snr_limit: float,
-    ) -> np.ndarray:
+    ) -> npt.NDArray:
         snr = array / utils.transpose(noise)
         if self.range_corrected is False:
             snr_scale_factor = 6
@@ -204,32 +280,38 @@ class NoisyData:
             array[snr < snr_limit] = ma.masked
         return array
 
-    def _calc_range_uncorrected(self, data: np.ndarray) -> None:
+    def _calc_range_uncorrected(self, data: npt.NDArray) -> None:
         ind = self._get_altitude_ind()
         data[:, ind] = data[:, ind] / self._get_range_squared()[ind]
 
-    def _calc_range_corrected(self, data: np.ndarray) -> None:
+    def _calc_range_corrected(self, data: npt.NDArray) -> None:
         ind = self._get_altitude_ind()
         data[:, ind] = data[:, ind] * self._get_range_squared()[ind]
 
     def _get_altitude_ind(self) -> tuple:
-        if self.range_corrected is False:
-            alt_limit = 2400.0
-            logging.warning(
-                f"Raw data not range-corrected, correcting below {alt_limit} m"
-            )
-        else:
-            alt_limit = 1e12
+        alt_limit = 1e12  # All altitudes
+        if (
+            self.range_corrected is False
+            and self.instrument is not None
+            and self.instrument.model is not None
+        ):
+            model = self.instrument.model.lower()
+            if model == "ct25k":
+                alt_limit = 0.0
+            elif model in ("cl31", "cl51"):
+                alt_limit = 2400.0
         return np.where(self.data["range"] < alt_limit)
 
-    def _get_range_squared(self) -> np.ndarray:
+    def _get_range_squared(self) -> npt.NDArray:
         """Returns range (m), squared and converted to km."""
         m2km = 0.001
         return (self.data["range"] * m2km) ** 2
 
     @staticmethod
     def _clean_fog_profiles(
-        data: np.ndarray, is_fog: np.ndarray, threshold: float = 2e-6
+        data: npt.NDArray,
+        is_fog: npt.NDArray,
+        threshold: float = 2e-6,
     ) -> None:
         """Removes values in saturated (e.g. fog) profiles above peak."""
         for time_ind in np.where(is_fog)[0]:
@@ -238,19 +320,22 @@ class NoisyData:
             profile[peak_ind:][profile[peak_ind:] < threshold] = ma.masked
 
 
-def _estimate_background_noise(data: np.ndarray) -> np.ndarray:
+def _estimate_background_noise(data: npt.NDArray) -> npt.NDArray:
     var = _calc_var_from_top_gates(data)
     return np.sqrt(var)
 
 
-def _calc_var_from_top_gates(data: np.ndarray) -> np.ndarray:
+def _calc_var_from_top_gates(data: npt.NDArray) -> npt.NDArray:
     fraction = 0.1
     n_gates = round(data.shape[1] * fraction)
     return ma.var(data[:, -n_gates:], axis=1)
 
 
 def calc_sigma_units(
-    time_vector: np.ndarray, range_los: np.ndarray
+    time_vector: npt.NDArray,
+    range_los: npt.NDArray,
+    sigma_minutes: float = 1,
+    sigma_metres: float = 10,
 ) -> tuple[float, float]:
     """Calculates Gaussian peak std parameters.
 
@@ -260,6 +345,8 @@ def calc_sigma_units(
     Args:
         time_vector: 1D vector (fraction hour).
         range_los: 1D vector (m).
+        sigma_minutes: Smoothing in minutes.
+        sigma_metres: Smoothing in metres.
 
     Returns:
         tuple: Two element tuple containing number of steps in time and height to
@@ -267,10 +354,9 @@ def calc_sigma_units(
 
     """
     if len(time_vector) == 0 or np.max(time_vector) > 24:
-        raise ValueError("Invalid time vector")
+        msg = "Invalid time vector"
+        raise ValueError(msg)
     minutes_in_hour = 60
-    sigma_minutes = 2
-    sigma_metres = 5
     time_step = utils.mdiff(time_vector) * minutes_in_hour
     alt_step = utils.mdiff(range_los)
     x_std = sigma_minutes / time_step
@@ -278,9 +364,7 @@ def calc_sigma_units(
     return x_std, y_std
 
 
-def _estimate_clouds_from_beta(
-    beta: np.ndarray,
-) -> tuple[tuple, np.ndarray, float]:
+def _estimate_clouds_from_beta(beta: npt.NDArray) -> tuple[tuple, npt.NDArray, float]:
     """Naively finds strong clouds from ceilometer backscatter."""
     cloud_limit = 1e-6
     cloud_ind = np.where(beta > cloud_limit)

cloudnetpy/instruments/cl61d.py

@@ -1,8 +1,11 @@
-"""Module with a class for Lufft chm15k ceilometer."""
+import datetime
 import logging
+from os import PathLike
 
 import netCDF4
 
+from cloudnetpy import utils
+from cloudnetpy.exceptions import LidarDataError
 from cloudnetpy.instruments import instruments
 from cloudnetpy.instruments.nc_lidar import NcLidar
 
@@ -11,8 +14,11 @@ class Cl61d(NcLidar):
     """Class for Vaisala CL61d ceilometer."""
 
     def __init__(
-        self, file_name: str, site_meta: dict, expected_date: str | None = None
-    ):
+        self,
+        file_name: str | PathLike,
+        site_meta: dict,
+        expected_date: datetime.date | None = None,
+    ) -> None:
         super().__init__()
         self.file_name = file_name
         self.site_meta = site_meta
@@ -23,15 +29,21 @@ class Cl61d(NcLidar):
         """Reads data and metadata from concatenated Vaisala CL61d netCDF file."""
         with netCDF4.Dataset(self.file_name) as dataset:
             self.dataset = dataset
-            self._fetch_zenith_angle("zenith", default=3.0)
+            self._fetch_attributes()
+            self._fetch_zenith_angle("tilt_angle", default=3.0)
             self._fetch_range(reference="lower")
             self._fetch_lidar_variables(calibration_factor)
             self._fetch_time_and_date()
             self.dataset = None
 
     def _fetch_lidar_variables(self, calibration_factor: float | None = None) -> None:
-        assert self.dataset is not None
+        if self.dataset is None:
+            msg = "No dataset found"
+            raise RuntimeError(msg)
         beta_raw = self.dataset.variables["beta_att"][:]
+        if utils.is_all_masked(beta_raw):
+            msg = "All beta_raw values are masked. Check the input file(s)."
+            raise LidarDataError(msg)
         if calibration_factor is None:
             logging.warning("Using default calibration factor")
             calibration_factor = 1
@@ -41,3 +53,7 @@ class Cl61d(NcLidar):
         self.data["depolarisation"] = (
             self.dataset.variables["x_pol"][:] / self.dataset.variables["p_pol"][:]
         )
+        self.data["depolarisation_raw"] = self.data["depolarisation"].copy()
+
+    def _fetch_attributes(self) -> None:
+        self.serial_number = getattr(self.dataset, "instrument_serial_number", None)

cloudnetpy/instruments/cloudnet_instrument.py

@@ -1,57 +1,44 @@
 import logging
+from typing import TYPE_CHECKING
 
-import netCDF4
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import utils
 from cloudnetpy.cloudnetarray import CloudnetArray
+from cloudnetpy.exceptions import ValidTimeStampError
+from cloudnetpy.instruments.instruments import BASTA, FMCW35, FMCW94, HATPRO, Instrument
+
+if TYPE_CHECKING:
+    import netCDF4
 
 
 class CloudnetInstrument:
-    def __init__(self):
-        self.dataset: netCDF4.Dataset | None = None
-        self.time: np.ndarray = np.array([])
+    def __init__(self) -> None:
+        self.dataset: netCDF4.Dataset
+        self.time: npt.NDArray = np.array([])
         self.site_meta: dict = {}
         self.data: dict = {}
+        self.serial_number: str | None = None
+        self.instrument: Instrument | None = None
 
     def add_site_geolocation(self) -> None:
-        for key in ("latitude", "longitude", "altitude"):
-            value = None
-            # User-supplied:
-            if key in self.site_meta:
-                value = self.site_meta[key]
-            # From source global attributes (MIRA):
-            elif isinstance(self.dataset, netCDF4.Dataset) and hasattr(
-                self.dataset, key.capitalize()
-            ):
-                value = self.parse_global_attribute_numeral(key.capitalize())
-            # From source data (BASTA / RPG):
-            elif (
-                isinstance(self.dataset, netCDF4.Dataset)
-                and key in self.dataset.variables
-            ):
-                value = self.dataset.variables[key][:]
-            if value is not None:
-                value = float(ma.mean(value))
-                self.data[key] = CloudnetArray(value, key)
-
-    def parse_global_attribute_numeral(self, key: str) -> float:
-        new_str = ""
-        for char in getattr(self.dataset, key):
-            if char.isdigit() or char == ".":
-                new_str += char
-        return float(new_str)
+        has_gps = self.instrument in (BASTA, FMCW94, FMCW35, HATPRO)
+        utils.add_site_geolocation(
+            self.data,
+            gps=has_gps,
+            site_meta=self.site_meta,
+            dataset=self.dataset if hasattr(self, "dataset") else None,
+        )
 
     def add_height(self) -> None:
-        try:
-            zenith_angle = ma.median(self.data["zenith_angle"].data)
-        except RuntimeError:
+        zenith_angle = self._get_zenith_angle()
+        if zenith_angle is None:
             logging.warning("Assuming 0 deg zenith_angle")
             zenith_angle = 0
         height = utils.range_to_height(self.data["range"].data, zenith_angle)
         height += self.data["altitude"].data
-        height = np.array(height)
         self.data["height"] = CloudnetArray(height, "height")
 
     def linear_to_db(self, variables_to_log: tuple) -> None:
@@ -69,9 +56,17 @@ class CloudnetInstrument:
         ind = time.argsort()
         self.screen_time_indices(ind)
 
-    def screen_time_indices(self, valid_indices: list | np.ndarray) -> None:
+    def screen_time_indices(self, valid_indices: list | npt.NDArray) -> None:
         time = self._get_time()
         n_time = len(time)
+        if len(valid_indices) == 0 or (
+            isinstance(valid_indices, np.ndarray)
+            and valid_indices.dtype == np.bool_
+            and valid_indices.shape == time.shape
+            and not np.any(valid_indices)
+        ):
+            msg = "All timestamps screened"
+            raise ValidTimeStampError(msg)
         for cloudnet_array in self.data.values():
             array = cloudnet_array.data
             if not utils.isscalar(array) and array.shape[0] == n_time:
@@ -85,8 +80,51 @@ class CloudnetInstrument:
         if self.time.size > 0:
             self.time = self.time[valid_indices]
 
-    def _get_time(self) -> np.ndarray:
+    def _get_time(self) -> npt.NDArray:
         try:
             return self.data["time"].data[:]
         except KeyError:
             return self.time
+
+    def _get_zenith_angle(self) -> float | None:
+        if "zenith_angle" not in self.data or self.data["zenith_angle"].data.size == 0:
+            return None
+        zenith_angle = ma.median(self.data["zenith_angle"].data)
+        if np.isnan(zenith_angle) or zenith_angle is ma.masked:
+            return None
+        return zenith_angle
+
+
+class CSVFile(CloudnetInstrument):
+    def __init__(self, site_meta: dict) -> None:
+        super().__init__()
+        self.site_meta = site_meta
+        self._data: dict = {}
+
+    def add_date(self) -> None:
+        self.date = self._data["time"][0].date()
+
+    def add_data(self) -> None:
+        for key, value in self._data.items():
+            parsed = (
+                utils.datetime2decimal_hours(value)
+                if key == "time"
+                else ma.masked_invalid(value)
+            )
+            self.data[key] = CloudnetArray(parsed, key)
+
+    def normalize_cumulative_amount(self, key: str) -> None:
+        if key not in self.data:
+            return
+        amount = self.data[key][:]
+        offset = 0
+        last_valid = 0
+        for i in range(1, len(amount)):
+            if amount[i] is ma.masked:
+                continue
+            if amount[i] + offset < amount[last_valid]:
+                offset += amount[last_valid]
+            amount[i] += offset
+            last_valid = i
+        amount -= amount[0]
+        self.data[key].data = amount