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

cloudnetpy/products/lwc.py

@@ -1,20 +1,28 @@
 """Module for creating Cloudnet liquid water content file using scaled-adiabatic
 method.
 """
+
+from os import PathLike
+from uuid import UUID
+
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import output, utils
-from cloudnetpy.categorize import atmos
+from cloudnetpy.categorize import atmos_utils
 from cloudnetpy.datasource import DataSource
+from cloudnetpy.exceptions import InvalidSourceFileError
 from cloudnetpy.metadata import MetaData
 from cloudnetpy.products import product_tools as p_tools
 from cloudnetpy.products.product_tools import CategorizeBits, get_is_rain
 
 
 def generate_lwc(
-    categorize_file: str, output_file: str, uuid: str | None = None
-) -> str:
+    categorize_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+) -> UUID:
     """Generates Cloudnet liquid water content product.
 
     This function calculates cloud liquid water content using the so-called
@@ -43,6 +51,7 @@ def generate_lwc(
         Bull. Amer. Meteor. Soc., 88, 883–898, https://doi.org/10.1175/BAMS-88-6-883
 
     """
+    uuid = utils.get_uuid(uuid)
     with LwcSource(categorize_file) as lwc_source:
         lwc = Lwc(lwc_source)
         clouds = CloudAdjustor(lwc_source, lwc)
@@ -51,7 +60,7 @@ def generate_lwc(
         date = lwc_source.get_date()
         attributes = output.add_time_attribute(LWC_ATTRIBUTES, date)
         output.update_attributes(lwc_source.data, attributes)
-        uuid = output.save_product_file(
+        output.save_product_file(
             "lwc",
             lwc_source,
             output_file,
@@ -61,7 +70,7 @@ def generate_lwc(
                 "lwp_error",
             ),
         )
-    return uuid
+        return uuid
 
 
 class LwcSource(DataSource):
@@ -77,32 +86,41 @@ class LwcSource(DataSource):
         lwp (ndarray): 1D liquid water path.
         lwp_error (ndarray): 1D error of liquid water path.
         is_rain (ndarray): 1D array denoting presence of rain.
-        dheight (float): Median difference in height vector.
+        path_lengths (ndarray): 1D array of path lengths.
         atmosphere (dict): Dictionary containing interpolated fields `temperature`
             and `pressure`.
         categorize_bits (CategorizeBits): The :class:`CategorizeBits` instance.
 
     """
 
-    def __init__(self, categorize_file: str):
+    def __init__(self, categorize_file: str | PathLike) -> None:
         super().__init__(categorize_file)
+        if "lwp" not in self.dataset.variables:
+            msg = "Liquid water path missing from the categorize file."
+            raise InvalidSourceFileError(msg)
         self.lwp = self.getvar("lwp")
         self.lwp[self.lwp < 0] = 0
         self.lwp_error = self.getvar("lwp_error")
         self.is_rain = get_is_rain(categorize_file)
-        self.dheight = utils.mdiff(self.getvar("height"))
+        self.height_agl: npt.NDArray
+        self.path_lengths = utils.path_lengths_from_ground(self.height_agl)
         self.atmosphere = self._get_atmosphere(categorize_file)
         self.categorize_bits = CategorizeBits(categorize_file)
 
     def append_results(
-        self, lwc: np.ndarray, status: np.ndarray, error: np.ndarray
+        self,
+        lwc: npt.NDArray,
+        status: npt.NDArray,
+        error: npt.NDArray,
     ) -> None:
         self.append_data(lwc, "lwc", units="kg m-3")
         self.append_data(status, "lwc_retrieval_status")
         self.append_data(error, "lwc_error", units="dB")
 
     @staticmethod
-    def _get_atmosphere(categorize_file: str) -> tuple[np.ndarray, np.ndarray]:
+    def _get_atmosphere(
+        categorize_file: str | PathLike,
+    ) -> tuple[npt.NDArray, npt.NDArray]:
         fields = ["temperature", "pressure"]
         atmosphere = p_tools.interpolate_model(categorize_file, fields)
         return atmosphere["temperature"], atmosphere["pressure"]
@@ -116,41 +134,42 @@ class Lwc:
 
     Attributes:
         lwc_source (LwcSource): The :class:`LwcSource` instance.
-        dheight (float): Median difference in height vector.
         is_liquid (ndarray): 2D array denoting liquid.
         lwc_adiabatic (ndarray): 2D array storing adiabatic lwc.
         lwc (ndarray): 2D array of liquid water content (scaled with lwp).
 
     """
 
-    def __init__(self, lwc_source: LwcSource):
+    def __init__(self, lwc_source: LwcSource) -> None:
         self.lwc_source = lwc_source
-        self.dheight = self.lwc_source.dheight
+        self.height_agl = lwc_source.height_agl
         self.is_liquid = self._get_liquid()
         self.lwc_adiabatic = self._init_lwc_adiabatic()
         self.lwc = self._adiabatic_lwc_to_lwc()
         self._mask_rain()
 
-    def _get_liquid(self) -> np.ndarray:
+    def _get_liquid(self) -> npt.NDArray:
         category_bits = self.lwc_source.categorize_bits.category_bits
-        return category_bits["droplet"]
+        return category_bits.droplet
 
-    def _init_lwc_adiabatic(self) -> np.ndarray:
+    def _init_lwc_adiabatic(self) -> npt.NDArray:
         """Returns theoretical adiabatic lwc in liquid clouds (kg/m3)."""
-        lwc_dz = atmos.fill_clouds_with_lwc_dz(
-            self.lwc_source.atmosphere, self.is_liquid
+        lwc_dz = atmos_utils.fill_clouds_with_lwc_dz(
+            *self.lwc_source.atmosphere,
+            self.is_liquid,
         )
-        return atmos.calc_adiabatic_lwc(lwc_dz, self.dheight)
+        return atmos_utils.calc_adiabatic_lwc(lwc_dz, self.height_agl)
 
-    def _adiabatic_lwc_to_lwc(self) -> np.ndarray:
+    def _adiabatic_lwc_to_lwc(self) -> npt.NDArray:
         """Initialises liquid water content (kg/m3).
 
         Calculates LWC for ALL profiles (rain, lwp > theoretical, etc.),
         """
-        lwc_scaled = atmos.distribute_lwp_to_liquid_clouds(
-            self.lwc_adiabatic, self.lwc_source.lwp
+        return atmos_utils.normalize_lwc_by_lwp(
+            self.lwc_adiabatic,
+            self.lwc_source.lwp,
+            self.height_agl,
         )
-        return lwc_scaled / self.dheight
 
     def _mask_rain(self) -> None:
         is_rain = self.lwc_source.is_rain.astype(bool)
@@ -174,7 +193,7 @@ class CloudAdjustor:
 
     """
 
-    def __init__(self, lwc_source: LwcSource, lwc: Lwc):
+    def __init__(self, lwc_source: LwcSource, lwc: Lwc) -> None:
         self.lwc_source = lwc_source
         self.lwc = lwc.lwc
         self.is_liquid = lwc.is_liquid
@@ -187,22 +206,23 @@ class CloudAdjustor:
 
     def _get_echo(self) -> dict:
         quality_bits = self.lwc_source.categorize_bits.quality_bits
-        return {key: quality_bits[key] for key in ("radar", "lidar")}
+        return {"radar": quality_bits.radar, "lidar": quality_bits.lidar}
 
     def _init_status(self) -> ma.MaskedArray:
         status = ma.zeros(self.is_liquid.shape, dtype=int)
         status[self.is_liquid] = 1
         return status
 
-    def _adjust_cloud_tops(self, adjustable_clouds: np.ndarray) -> None:
+    def _adjust_cloud_tops(self, adjustable_clouds: npt.NDArray) -> None:
         """Adjusts cloud top index so that measured lwc corresponds to theoretical
-        value."""
+        value.
+        """
         for time_index in np.unique(np.where(adjustable_clouds)[0]):
             base_index = np.where(adjustable_clouds[time_index, :])[0][0]
             self._update_status(time_index)
             self._adjust_lwc(time_index, base_index)
 
-    def _update_status(self, time_ind: np.ndarray) -> None:
+    def _update_status(self, time_ind: npt.NDArray) -> None:
         alt_indices = np.where(self.is_liquid[time_ind, :])[0]
         self.status[time_ind, alt_indices] = 2
 
@@ -220,24 +240,21 @@ class CloudAdjustor:
             distance_from_base += 1
 
     def _has_converged(self, ind: int) -> bool:
-        lwc_sum = ma.sum(self.lwc_adiabatic[ind, :])
-        if lwc_sum * self.lwc_source.dheight > self.lwc_source.lwp[ind]:
-            return True
-        return False
+        lwc_sum = ma.sum(self.lwc_adiabatic[ind, :] * self.lwc_source.path_lengths)
+        return lwc_sum > self.lwc_source.lwp[ind]
 
     def _out_of_bound(self, ind: int) -> bool:
         return ind >= self.lwc.shape[1] - 1
 
-    def _find_adjustable_clouds(self) -> np.ndarray:
+    def _find_adjustable_clouds(self) -> npt.NDArray:
         top_clouds = self._find_topmost_clouds()
         detection_type = self._find_echo_combinations_in_liquid()
         detection_type[~top_clouds] = 0
         lidar_only_clouds = self._find_lidar_only_clouds(detection_type)
         top_clouds[~lidar_only_clouds, :] = 0
-        top_clouds = self._remove_good_profiles(top_clouds)
-        return top_clouds
+        return self._remove_good_profiles(top_clouds)
 
-    def _find_topmost_clouds(self) -> np.ndarray:
+    def _find_topmost_clouds(self) -> npt.NDArray:
         top_clouds = np.copy(self.is_liquid)
         cloud_edges = top_clouds[:, :-1][:, ::-1] < top_clouds[:, 1:][:, ::-1]
         topmost_bases = self.is_liquid.shape[1] - 1 - np.argmax(cloud_edges, axis=1)
@@ -245,14 +262,14 @@ class CloudAdjustor:
             top_clouds[n, :base] = 0
         return top_clouds
 
-    def _find_echo_combinations_in_liquid(self) -> np.ndarray:
+    def _find_echo_combinations_in_liquid(self) -> npt.NDArray:
         """Classifies liquid clouds by detection type: 1=lidar, 2=radar, 3=both."""
         lidar_detected = (self.is_liquid & self.echo["lidar"]).astype(int)
         radar_detected = (self.is_liquid & self.echo["radar"]).astype(int) * 2
         return lidar_detected + radar_detected
 
     @staticmethod
-    def _find_lidar_only_clouds(detection: np.ndarray) -> np.ndarray:
+    def _find_lidar_only_clouds(detection: npt.NDArray) -> npt.NDArray:
         """Finds top clouds that contain only lidar-detected pixels.
 
         Args:
@@ -266,20 +283,20 @@ class CloudAdjustor:
         sum_of_detection_type = ma.sum(detection, axis=1)
         return sum_of_cloud_pixels / sum_of_detection_type == 1
 
-    def _remove_good_profiles(self, top_clouds: np.ndarray) -> np.ndarray:
+    def _remove_good_profiles(self, top_clouds: npt.NDArray) -> npt.NDArray:
         no_rain = ~self.lwc_source.is_rain.astype(bool)
         lwp_difference = self._find_lwp_difference()
         dubious_profiles = (lwp_difference < 0) & no_rain
         top_clouds[~dubious_profiles, :] = 0
         return top_clouds
 
-    def _find_lwp_difference(self) -> np.ndarray:
+    def _find_lwp_difference(self) -> npt.NDArray:
         """Returns difference of theoretical LWP and measured LWP (g/m2).
 
         In theory, this difference should be always positive. Negative values
         indicate missing (or too narrow) liquid clouds.
         """
-        lwc_sum = ma.sum(self.lwc_adiabatic, axis=1) * self.lwc_source.dheight
+        lwc_sum = ma.sum(self.lwc_adiabatic * self.lwc_source.path_lengths, axis=1)
         return lwc_sum - self.lwc_source.lwp
 
     def _mask_rain(self) -> None:
@@ -305,47 +322,51 @@ class LwcError:
 
     """
 
-    def __init__(self, lwc_source: LwcSource, lwc: Lwc):
+    def __init__(self, lwc_source: LwcSource, lwc: Lwc) -> None:
         self.lwc = lwc.lwc
         self.lwc_source = lwc_source
         self.error = self._calculate_lwc_error()
         self._mask_rain()
 
-    def _calculate_lwc_error(self) -> np.ndarray:
+    def _calculate_lwc_error(self) -> npt.NDArray:
         lwc_relative_error = self._calc_lwc_relative_error()
         lwp_relative_error = self._calc_lwp_relative_error()
         combined_error = self._calc_combined_error(
-            lwc_relative_error, lwp_relative_error
+            lwc_relative_error,
+            lwp_relative_error,
         )
         return self._fill_error_array(combined_error)
 
-    def _calc_lwc_relative_error(self) -> np.ndarray:
+    def _calc_lwc_relative_error(self) -> npt.NDArray:
         lwc_gradient = self._calc_lwc_gradient()
         error = lwc_gradient / self.lwc / 2
         return self._limit_error(error, 5)
 
-    def _calc_lwc_gradient(self) -> np.ndarray:
-        assert isinstance(self.lwc, ma.MaskedArray)
+    def _calc_lwc_gradient(self) -> npt.NDArray:
+        if not isinstance(self.lwc, ma.MaskedArray):
+            self.lwc = ma.masked_array(self.lwc)
         gradient_elements = np.gradient(self.lwc.filled(0))
         return utils.l2norm(*gradient_elements)
 
-    def _calc_lwp_relative_error(self) -> np.ndarray:
+    def _calc_lwp_relative_error(self) -> npt.NDArray:
         err = self.lwc_source.lwp_error
         value = self.lwc_source.lwp
         error = np.divide(err, value, out=np.zeros_like(err), where=value != 0)
         return self._limit_error(error, 10)
 
     @staticmethod
-    def _limit_error(error: np.ndarray, max_value: float) -> np.ndarray:
+    def _limit_error(error: npt.NDArray, max_value: float) -> npt.NDArray:
         error[error > max_value] = max_value
         return error
 
     @staticmethod
-    def _calc_combined_error(error_2d: np.ndarray, error_1d: np.ndarray) -> np.ndarray:
+    def _calc_combined_error(
+        error_2d: npt.NDArray, error_1d: npt.NDArray
+    ) -> npt.NDArray:
         error_1d_transposed = utils.transpose(error_1d)
         return utils.l2norm(error_2d, error_1d_transposed)
 
-    def _fill_error_array(self, error_in: np.ndarray) -> ma.MaskedArray:
+    def _fill_error_array(self, error_in: npt.NDArray) -> ma.MaskedArray:
         lwc_error = ma.masked_all(self.lwc.shape)
         ind = ma.where(self.lwc)
         lwc_error[ind] = error_in[ind]
@@ -406,25 +427,26 @@ COMMENTS = {
 }
 
 DEFINITIONS = {
-    "lwc_retrieval_status": (
-        "\n"
-        "Value 0: No liquid water detected.\n"
-        "Value 1: Reliable retrieval.\n"
-        "Value 2: Adiabatic retrieval where cloud top has been adjusted to match\n"
-        "         liquid water path from microwave radiometer because layer is not\n"
-        "         detected by radar."
-        "Value 3: Adiabatic retrieval: new cloud pixels where cloud top has been\n"
-        "         adjusted to match liquid water path from microwave radiometer\n"
-        "         because layer is not detected by radar.\n"
-        "Value 4: No retrieval: either no liquid water path is available or liquid\n"
-        "          water path is uncertain.\n"
-        "Value 5: No retrieval: liquid water layer detected only by the lidar and\n"
-        "         liquid water path is unavailable or uncertain: cloud top may be\n"
-        "         higher than diagnosed cloud top since lidar signal has been\n"
-        "         attenuated."
-        "Value 6: Rain present: cloud extent is difficult to ascertain and liquid\n"
-        "         water path also uncertain."
-    )
+    "lwc_retrieval_status": utils.status_field_definition(
+        {
+            0: """No liquid water detected.""",
+            1: """Reliable retrieval.""",
+            2: """Adiabatic retrieval where cloud top has been adjusted to match
+                  liquid water path from microwave radiometer because layer is
+                  not detected by radar.""",
+            3: """Adiabatic retrieval: new cloud pixels where cloud top has been
+                  adjusted to match liquid water path from microwave radiometer
+                  because layer is not detected by radar.""",
+            4: """No retrieval: either no liquid water path is available or
+                  liquid water path is uncertain.""",
+            5: """No retrieval: liquid water layer detected only by the lidar
+                  and liquid water path is unavailable or uncertain: cloud top
+                  may be higher than diagnosed cloud top since lidar signal has
+                  been attenuated.""",
+            6: """Rain present: cloud extent is difficult to ascertain and
+                  liquid water path also uncertain.""",
+        }
+    ),
 }
 
 
@@ -433,16 +455,20 @@ LWC_ATTRIBUTES = {
         long_name="Liquid water content",
         comment=COMMENTS["lwc"],
         ancillary_variables="lwc_error",
+        standard_name="mass_concentration_of_liquid_water_in_air",
+        dimensions=("time", "height"),
     ),
     "lwc_error": MetaData(
         long_name="Random error in liquid water content, one standard deviation",
         comment=COMMENTS["lwc_error"],
         units="dB",
+        dimensions=("time", "height"),
     ),
     "lwc_retrieval_status": MetaData(
         long_name="Liquid water content retrieval status",
         comment=COMMENTS["lwc_retrieval_status"],
         definition=DEFINITIONS["lwc_retrieval_status"],
         units="1",
+        dimensions=("time", "height"),
     ),
 }

cloudnetpy/products/mwr_tools.py

@@ -0,0 +1,186 @@
+import os
+import tempfile
+from os import PathLike
+from typing import Literal
+from uuid import UUID
+
+import netCDF4
+import numpy as np
+import requests
+from mwrpy.level2.lev2_collocated import generate_lev2_lhumpro as gen_lhumpro
+from mwrpy.level2.lev2_collocated import generate_lev2_multi as gen_multi
+from mwrpy.level2.lev2_collocated import generate_lev2_single as gen_single
+from mwrpy.level2.write_lev2_nc import MissingInputData
+from mwrpy.version import __version__ as mwrpy_version
+
+from cloudnetpy import output, utils
+from cloudnetpy.exceptions import ValidTimeStampError
+
+
+def generate_mwr_single(
+    mwr_l1c_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+    lwp_offset: tuple[float | None, float | None] = (None, None),
+) -> UUID:
+    """Generates MWR single-pointing product including liquid water path, integrated
+    water vapor, etc. from zenith measurements.
+
+    Args:
+        mwr_l1c_file: The Level 1C MWR file to be processed.
+        output_file: The file path where the output file should be saved.
+        uuid: The UUID, if any, associated with the output file. Defaults to None.
+        lwp_offset: Optional offset to apply to the liquid water path.
+
+    Returns:
+        UUID of generated file.
+
+    Example:
+        >>> generate_mwr_single('input_mwr_l1c_file', 'output_file', 'abcdefg1234567')
+    """
+    return _generate_product(mwr_l1c_file, output_file, uuid, "single", lwp_offset)
+
+
+def generate_mwr_lhumpro(
+    mwr_l1c_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+    lwp_offset: tuple[float | None, float | None] = (None, None),
+) -> UUID:
+    """Generates LHUMPRO single-pointing product including liquid water path, integrated
+    water vapor, etc. from zenith measurements.
+
+    Args:
+        mwr_l1c_file: The Level 1C MWR file to be processed.
+        output_file: The file path where the output file should be saved.
+        uuid: The UUID, if any, associated with the output file. Defaults to None.
+        lwp_offset: Optional offset to apply to the liquid water path.
+
+    Returns:
+        UUID of generated file.
+
+    Example:
+        >>> generate_mwr_lhumpro('input_mwr_l1c_file', 'output_file', 'abcdefg1234567')
+    """
+    return _generate_product(mwr_l1c_file, output_file, uuid, "lhumpro", lwp_offset)
+
+
+def generate_mwr_multi(
+    mwr_l1c_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+) -> UUID:
+    """Generates MWR multiple-pointing product, including relative humidity profiles,
+    etc. from scanning measurements.
+
+    Args:
+        mwr_l1c_file: The input file in MWR L1C format.
+        output_file: The location where the output file should be generated.
+        uuid: The UUID for the MWR multi product, defaults to None if
+            not provided.
+
+    Returns:
+        UUID of generated file.
+    """
+    return _generate_product(mwr_l1c_file, output_file, uuid, "multi")
+
+
+def _generate_product(
+    mwr_l1c_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None,
+    product: Literal["single", "multi", "lhumpro"],
+    lwp_offset: tuple[float | None, float | None] = (None, None),
+) -> UUID:
+    uuid = utils.get_uuid(uuid)
+    with tempfile.TemporaryDirectory() as temp_dir:
+        coeffs = _read_mwrpy_coeffs(mwr_l1c_file, temp_dir)
+        try:
+            if product == "multi":
+                gen_multi(None, mwr_l1c_file, output_file, coeffs)
+            elif product == "single":
+                gen_single(None, mwr_l1c_file, output_file, lwp_offset, coeffs)
+            else:
+                gen_lhumpro(None, mwr_l1c_file, output_file, lwp_offset, coeffs)
+                product = "single"
+        except MissingInputData as err:
+            raise ValidTimeStampError from err
+    with (
+        netCDF4.Dataset(mwr_l1c_file, "r") as nc_input,
+        netCDF4.Dataset(output_file, "r+") as nc_output,
+    ):
+        flag_variable = "lwp" if product == "single" else "temperature"
+        flag_name = f"{flag_variable}_quality_flag"
+        flags = nc_output.variables[flag_name][:]
+        if not np.any(flags == 0):
+            msg = f"All {flag_variable} data are flagged."
+            raise ValidTimeStampError(msg)
+        mwr = Mwr(nc_input, nc_output, uuid)
+        return mwr.harmonize(product)
+
+
+class Mwr:
+    def __init__(
+        self, nc_l1c: netCDF4.Dataset, nc_l2: netCDF4.Dataset, uuid: UUID
+    ) -> None:
+        self.nc_l1c = nc_l1c
+        self.nc_l2 = nc_l2
+        self.uuid = uuid
+
+    def harmonize(self, product: Literal["multi", "single"]) -> UUID:
+        self._truncate_global_attributes()
+        self._copy_global_attributes()
+        self._fix_variable_attributes()
+        self._write_missing_global_attributes(product)
+        return self.uuid
+
+    def _truncate_global_attributes(self) -> None:
+        for attr in self.nc_l2.ncattrs():
+            delattr(self.nc_l2, attr)
+
+    def _copy_global_attributes(self) -> None:
+        keys = ("year", "month", "day", "location", "source")
+        output.copy_global(self.nc_l1c, self.nc_l2, keys)
+
+    def _fix_variable_attributes(self) -> None:
+        output.replace_attribute_with_standard_value(
+            self.nc_l2,
+            (
+                "lwp",
+                "iwv",
+                "temperature",
+                "azimuth_angle",
+                "latitude",
+                "longitude",
+                "altitude",
+            ),
+            ("units", "long_name", "standard_name"),
+        )
+
+    def _write_missing_global_attributes(
+        self, product: Literal["multi", "single"]
+    ) -> None:
+        output.add_standard_global_attributes(self.nc_l2, self.uuid)
+        product_type = "multiple-pointing" if product == "multi" else "single-pointing"
+        self.nc_l2.title = f"MWR {product_type} from {self.nc_l1c.location}"
+        self.nc_l2.cloudnet_file_type = f"mwr-{product}"
+        output.fix_time_attributes(self.nc_l2)
+        self.nc_l2.history = (
+            f"{utils.get_time()} - MWR {product_type} file created \n"
+            f"{self.nc_l1c.history}"
+        )
+        self.nc_l2.source_file_uuids = self.nc_l1c.file_uuid
+        self.nc_l2.mwrpy_version = mwrpy_version
+        self.nc_l2.instrument_pid = self.nc_l1c.instrument_pid
+
+
+def _read_mwrpy_coeffs(mwr_l1c_file: str | PathLike, folder: str) -> list[str]:
+    with netCDF4.Dataset(mwr_l1c_file) as nc:
+        links = nc.mwrpy_coefficients.split(", ")
+    coeffs = []
+    for link in links:
+        full_path = os.path.join(folder, link.split("/")[-1])
+        with open(full_path, "wb") as f:
+            f.write(requests.get(link, timeout=10).content)
+        coeffs.append(full_path)
+    return coeffs