pycontrails 0.54.12__cp313-cp313-win_amd64.whl → 0.56.0__cp313-cp313-win_amd64.whl

pycontrails/datalib/sentinel.py

@@ -7,12 +7,23 @@ from collections.abc import Iterable
 from xml.etree import ElementTree
 
 import numpy as np
+import numpy.typing as npt
 import pandas as pd
 import xarray as xr
 
 from pycontrails.core import Flight, cache
-from pycontrails.datalib._leo_utils import search
-from pycontrails.datalib._leo_utils.vis import equalize, normalize
+from pycontrails.datalib.leo_utils import correction, search
+from pycontrails.datalib.leo_utils.sentinel_metadata import (
+    _band_id,
+    get_detector_id,
+    get_time_delay_detectors,
+    parse_ephemeris_sentinel,
+    parse_high_res_viewing_incidence_angles,
+    parse_sensing_time,
+    parse_sentinel_crs,
+    read_image_coordinates,
+)
+from pycontrails.datalib.leo_utils.vis import equalize, normalize
 from pycontrails.utils import dependencies
 
 try:
@@ -53,7 +64,7 @@ ROI_QUERY_FILENAME = _path_to_static / "sentinel_roi_query.sql"
 BQ_TABLE = "bigquery-public-data.cloud_storage_geo_index.sentinel_2_index"
 
 #: Default columns to include in queries
-BQ_DEFAULT_COLUMNS = ["base_url", "granule_id", "sensing_time"]
+BQ_DEFAULT_COLUMNS = ["base_url", "granule_id", "sensing_time", "source_url"]
 
 #: Default spatial extent for queries
 BQ_DEFAULT_EXTENT = search.GLOBAL_EXTENT
@@ -84,10 +95,10 @@ def query(
         Start of time period for search
     end_time : np.datetime64
         End of time period for search
-    extent : str, optional
+    extent : str | None, optional
         Spatial region of interest as a GeoJSON string. If not provided, defaults
         to a global extent.
-    columns : list[str], optional
+    columns : list[str] | None, optional
         Columns to return from Google
         `BigQuery table <https://console.cloud.google.com/bigquery?p=bigquery-public-data&d=cloud_storage_geo_index&t=landsat_index&page=table&_ga=2.90807450.1051800793.1716904050-255800408.1705955196>`__.
         By default, returns imagery base URL, granule ID, and sensing time.
@@ -124,7 +135,7 @@ def intersect(
     ----------
     flight : Flight
         Flight for intersection
-    columns : list[str], optional.
+    columns : list[str] | None, optional
         Columns to return from Google
         `BigQuery table <https://console.cloud.google.com/bigquery?p=bigquery-public-data&d=cloud_storage_geo_index&t=landsat_index&page=table&_ga=2.90807450.1051800793.1716904050-255800408.1705955196>`__.
         By default, returns imagery base URL, granule ID, and sensing time.
@@ -139,18 +150,18 @@ def intersect(
     :func:`search.intersect`
     """
     columns = columns or BQ_DEFAULT_COLUMNS
-    return search.intersect(BQ_TABLE, flight, columns)
+    scenes = search.intersect(BQ_TABLE, flight, columns)
+
+    # overwrite the base_url with source_url.
+    # After 2024-03-14 there is a mistake in the Google BigQuery table,
+    # such that the base_url is written to the source_url column
+    scenes["base_url"] = scenes["base_url"].fillna(scenes["source_url"])
+    return scenes
 
 
 class Sentinel:
     """Support for Sentinel-2 data handling.
 
-    This class uses the `PROJ <https://proj.org/en/9.4/index.html>`__ coordinate
-    transformation software through the
-    `pyproj <https://pyproj4.github.io/pyproj/stable/index.html>`__ python interface.
-    pyproj is installed as part of the ``sat`` set of optional dependencies
-    (``pip install pycontrails[sat]``), but PROJ must be installed manually.
-
     Parameters
     ----------
     base_url : str
@@ -159,7 +170,7 @@ class Sentinel:
     granule_id : str
         Granule ID of Sentinel-2 scene. To find URLs for Sentinel-2 scenes at
         specific locations and times, see :func:`query` and :func:`intersect`.
-    bands : str | set[str] | None
+    bands : str | Iterable[str] | None
         Set of bands to retrieve. The 13 possible bands are represented by
         the string "B01" to "B12" plus "B8A". For the true color scheme, set
         ``bands=("B02", "B03", "B04")``. By default, bands for the true color scheme
@@ -169,7 +180,7 @@ class Sentinel:
         - B05-B07, B8A, B11, B12: 20 m
         - B01, B09, B10: 60 m
 
-    cachestore : cache.CacheStore, optional
+    cachestore : cache.CacheStore | None, optional
         Cache store for Landsat data. If None, a :class:`DiskCacheStore` is used.
 
     See Also
@@ -210,23 +221,163 @@ class Sentinel:
 
         Parameters
         ----------
-        reflective : str = {"raw", "reflectance"}, optional
-            Whether to return raw values or rescaled reflectances for reflective bands.
+        reflective : str, optional
+            Set to "raw" to return raw values or "reflectance" for rescaled reflectances.
             By default, return reflectances.
 
         Returns
         -------
-        xr.DataArray
-            DataArray of Sentinel-2 data.
+        xr.Dataset
+            Dataset of Sentinel-2 data.
         """
-        if reflective not in ["raw", "reflectance"]:
-            msg = "reflective band processing must be one of ['raw', 'radiance', 'reflectance']"
+        available = ("raw", "reflectance")
+        if reflective not in available:
+            msg = f"reflective band processing must be one of {available}"
             raise ValueError(msg)
 
-        ds = xr.Dataset()
-        for band in self.bands:
-            ds[band] = self._get(band, reflective)
-        return ds
+        data = {band: self._get(band, reflective) for band in self.bands}
+        return xr.Dataset(data)
+
+    def get_viewing_angle_metadata(self, scale: int = 10) -> xr.Dataset:
+        """Return the dataset with viewing angles.
+
+        See :func:`parse_high_res_viewing_incidence_angles` for details.
+        """
+        granule_meta_path, _ = self._get_meta()
+        _, detector_band_path = self._get_correction_meta()
+        return parse_high_res_viewing_incidence_angles(
+            granule_meta_path, detector_band_path, scale=scale
+        )
+
+    def get_detector_id(
+        self, x: npt.NDArray[np.floating], y: npt.NDArray[np.floating]
+    ) -> npt.NDArray[np.integer]:
+        """Return the detector_id of the Sentinel-2 detector that imaged the given points.
+
+        Parameters
+        ----------
+        x : npt.NDArray[np.floating]
+            x coordinates of points in the Sentinel-2 image CRS
+        y : npt.NDArray[np.floating]
+            y coordinates of points in the Sentinel-2 image CRS
+
+        Returns
+        -------
+        npt.NDArray[np.integer]
+            Detector IDs for each point. If a point is outside the image, the detector ID is 0.
+        """
+        granule_sink, _ = self._get_meta()
+        _, detector_band_sink = self._get_correction_meta()
+        return get_detector_id(detector_band_sink, granule_sink, x, y)
+
+    def get_time_delay_detector(
+        self, detector_id: npt.NDArray[np.integer], band: str = "B03"
+    ) -> npt.NDArray[np.timedelta64]:
+        """Return the time delay for the given detector IDs."""
+        datastrip_sink, _ = self._get_correction_meta()
+        delays = get_time_delay_detectors(datastrip_sink, band)
+
+        # Map the delays to the input array
+        unique_ids, inverse = np.unique(detector_id, return_inverse=True)
+
+        # Get offsets for each unique detector
+        offset_list = []
+        for did in unique_ids:
+            if did == 0:
+                offset_list.append(np.timedelta64("NaT"))
+            else:
+                offset_list.append(delays.get(did, np.timedelta64("NaT")))
+        offset_values = np.array(offset_list, dtype="timedelta64[ns]")
+
+        # Map back to the original array
+        return offset_values[inverse]
+
+    def get_ephemeris(self) -> pd.DataFrame:
+        """Return the satellite ephemeris as a :class:`pandas.DataFrame`."""
+        datastrip_sink, _ = self._get_correction_meta()
+
+        return parse_ephemeris_sentinel(datastrip_sink)
+
+    def get_crs(self) -> pyproj.CRS:
+        """Return the CRS of the satellite image."""
+        granule_meta_path, _ = self._get_meta()
+        return parse_sentinel_crs(granule_meta_path)
+
+    def get_sensing_time(self) -> pd.Timestamp:
+        """Return the sensing_time of the satellite image."""
+        granule_meta_path, _ = self._get_meta()
+        return parse_sensing_time(granule_meta_path)
+
+    def colocate_flight(
+        self,
+        flight: Flight,
+        band: str = "B03",
+    ) -> tuple[float, float, np.datetime64]:
+        """Colocate a flight track with satellite image pixels.
+
+        This function first projects flight waypoints into the UTM coordinate system
+        of the satellite image, then applies a viewing angle correction to estimate
+        the actual ground position imaged by the satellite. Next, the scan time for
+        each point is estimated based on the satellite meta data. Finally, the
+        point along the flight track is found where the flight time matches the
+        satellite scan time.
+
+        Parameters
+        ----------
+        flight : Flight
+            The flight object.
+        band : str, optional
+            Spectral band to use for geometry parsing. Default is "B03".
+
+        Returns
+        -------
+        tuple[float, float, np.datetime64]
+            A tuple containing the x and y coordinates of the flight position in the
+            satellite image CRS, and the corrected sensing_time of the satellite image.
+        """
+        utm_crs = self.get_crs()
+
+        # Project from WGS84 to the x and y coordinates in the UTM coordinate system
+        transformer = pyproj.Transformer.from_crs("EPSG:4326", utm_crs, always_xy=True)
+        x, y = transformer.transform(flight["longitude"], flight["latitude"])
+        z = flight.altitude
+
+        # Apply sensing angle correction
+        ds_angles = self.get_viewing_angle_metadata()
+        x_proj, y_proj = correction.scan_angle_correction(ds_angles, x, y, z, maxiter=3)
+
+        # Get the satellite ephemeris data prepared
+        ephemeris = self.get_ephemeris()
+
+        # Estimate the scan time for each point
+        scan_time_no_offset = correction.estimate_scan_time(ephemeris, utm_crs, x_proj, y_proj)
+
+        detector_id = self.get_detector_id(x_proj, y_proj)
+        offset = self.get_time_delay_detector(detector_id, band=band)
+        scan_time = scan_time_no_offset + offset
+
+        # To finish up, find the point along the project flight track at which the satellite
+        # scan time equals the flight time
+        # It's possible that if the flight has a really fine time resolution, that
+        # the diff_times array will have multiple zeros. This is okay, as np.interp
+        # will just return the first one.
+        valid = np.isfinite(x_proj) & np.isfinite(y_proj) & np.isfinite(scan_time)
+
+        diff_times = flight["time"][valid] - scan_time[valid]
+        if diff_times[0] > np.timedelta64(0) or diff_times[-1] < np.timedelta64(0):
+            msg = "Flight track does not overlap with satellite image in time."
+            raise ValueError(msg)
+
+        index = np.arange(len(diff_times))
+        frac_idx = np.interp(0, diff_times.astype(int), index)
+
+        x1 = np.interp(frac_idx, index, x_proj[valid]).item()
+        y1 = np.interp(frac_idx, index, y_proj[valid]).item()
+        t1 = np.interp(frac_idx, index, scan_time[valid].astype(int)).item()
+
+        return x1, y1, np.datetime64(int(t1), "ns")
+
+    # -------------------------------------------------------------------------------------
 
     def _get(self, band: str, processing: str) -> xr.DataArray:
         """Download Sentinel-2 band to the :attr:`cachestore` and return processed data."""
@@ -278,6 +429,61 @@ class Sentinel:
 
         return granule_sink, safe_sink
 
+    def _get_correction_meta(self) -> tuple[str, str]:
+        """Download Sentinel-2 metadata files and return path to cached files.
+
+        Note that two XML files must be retrieved: one inside the GRANULE
+        subdirectory, and one at the top level of the SAFE archive.
+        """
+        fs = self.fs
+        base_url = self.base_url
+        granule_id = self.granule_id
+
+        # Resolve the unknown subfolder in DATASTRIP using glob
+        # Probably there is a better method, but this worked for now
+        pattern = f"{base_url}/DATASTRIP/*"
+        matches = fs.glob(pattern)
+        if not matches:
+            raise FileNotFoundError(f"No DATASTRIP MTD_MDS.xml file found at pattern: {pattern}")
+        if len(matches) > 2:
+            raise RuntimeError(f"Multiple DATASTRIP MTD_MDS.xml files found: {matches}")
+
+        datastrip_id = matches[0].split("/")[-1].replace("_$folder$", "")
+        url = f"{base_url}/DATASTRIP/{datastrip_id}/MTD_DS.xml"
+        datastrip_sink = self.cachestore.path(url.removeprefix(GCP_STRIP_PREFIX))
+        if not self.cachestore.exists(datastrip_sink):
+            fs.get(url, datastrip_sink)
+
+        # Path to the QI_DATA folder
+        qi_data_url = f"{base_url}/GRANULE/{granule_id}/QI_DATA/"
+
+        # List files in QI_DATA (assuming fs can list directories)
+        files = fs.ls(qi_data_url)
+
+        # Filter for the detector mask files
+        mask_files = [f for f in files if "MSK_DETFOO_B03" in f]
+
+        if not mask_files:
+            raise FileNotFoundError(f"No detector mask found in {qi_data_url}")
+
+        # Choose the first available file (could prioritize .jp2 over .gml if needed)
+        mask_file = None
+        for ext in [".jp2", ".gml"]:
+            for f in mask_files:
+                if f.endswith(ext):
+                    mask_file = f
+                    break
+            if mask_file:
+                break
+
+        if mask_file is not None:
+            # Path where the file will be cached
+            detector_band_sink = self.cachestore.path(mask_file.removeprefix(GCP_STRIP_PREFIX))
+            if not self.cachestore.exists(detector_band_sink):
+                fs.get(mask_file, detector_band_sink)
+
+        return datastrip_sink, detector_band_sink
+
 
 def _parse_bands(bands: str | Iterable[str] | None) -> set[str]:
     """Check that the bands are valid and return as a set."""
@@ -328,7 +534,7 @@ def _read(path: str, granule_meta: str, safe_meta: str, band: str, processing: s
     epsg = int(elem.text.split(":")[1])
     crs = pyproj.CRS.from_epsg(epsg)
 
-    x, y = _read_image_coordinates(granule_meta, band)
+    x, y = read_image_coordinates(granule_meta, band)
 
     da = xr.DataArray(
         data=img,
@@ -345,22 +551,6 @@ def _read(path: str, granule_meta: str, safe_meta: str, band: str, processing: s
     return da
 
 
-def _band_resolution(band: str) -> int:
-    """Get band resolution in meters."""
-    return (
-        60 if band in ("B01", "B09", "B10") else 10 if band in ("B02", "B03", "B04", "B08") else 20
-    )
-
-
-def _band_id(band: str) -> int:
-    """Get band ID used in some metadata files."""
-    if band in (f"B{i:2d}" for i in range(1, 9)):
-        return int(band[1:]) - 1
-    if band == "B8A":
-        return 8
-    return int(band[1:])
-
-
 def _read_band_reflectance_rescaling(meta: str, band: str) -> tuple[float, float]:
     """Read reflectance rescaling factors from metadata file.
 
@@ -393,65 +583,18 @@ def _read_band_reflectance_rescaling(meta: str, band: str) -> tuple[float, float
     raise ValueError(msg)
 
 
-def _read_image_coordinates(meta: str, band: str) -> tuple[np.ndarray, np.ndarray]:
-    """Read image x and y coordinates."""
-
-    # convenience function that satisfies mypy
-    def _text_from_tag(parent: ElementTree.Element, tag: str) -> str:
-        elem = parent.find(tag)
-        if elem is None or elem.text is None:
-            msg = f"Could not find text in {tag} element"
-            raise ValueError(msg)
-        return elem.text
-
-    resolution = _band_resolution(band)
-
-    # find coordinates of upper left corner and pixel size
-    tree = ElementTree.parse(meta)
-    elems = tree.findall(".//Geoposition")
-    for elem in elems:
-        if int(elem.attrib["resolution"]) == resolution:
-            ulx = float(_text_from_tag(elem, "ULX"))
-            uly = float(_text_from_tag(elem, "ULY"))
-            dx = float(_text_from_tag(elem, "XDIM"))
-            dy = float(_text_from_tag(elem, "YDIM"))
-            break
-    else:
-        msg = f"Could not find image geoposition for resolution of {resolution} m"
-        raise ValueError(msg)
-
-    # find image size
-    elems = tree.findall(".//Size")
-    for elem in elems:
-        if int(elem.attrib["resolution"]) == resolution:
-            nx = int(_text_from_tag(elem, "NCOLS"))
-            ny = int(_text_from_tag(elem, "NROWS"))
-            break
-    else:
-        msg = f"Could not find image size for resolution of {resolution} m"
-        raise ValueError(msg)
-
-    # compute pixel coordinates
-    xlim = (ulx, ulx + (nx - 1) * dx)
-    ylim = (uly, uly + (ny - 1) * dy)  # dy is < 0
-    x = np.linspace(xlim[0], xlim[1], nx)
-    y = np.linspace(ylim[0], ylim[1], ny)
-
-    return x, y
-
-
 def extract_sentinel_visualization(
     ds: xr.Dataset, color_scheme: str = "true"
-) -> tuple[np.ndarray, pyproj.CRS, tuple[float, float, float, float]]:
+) -> tuple[npt.NDArray[np.float32], pyproj.CRS, tuple[float, float, float, float]]:
     """Extract artifacts for visualizing Sentinel data with the given color scheme.
 
     Parameters
     ----------
     ds : xr.Dataset
         Dataset of Sentinel data as returned by :meth:`Sentinel.get`.
-    color_scheme : str = {"true"}
+    color_scheme : str, optional
         Color scheme to use for visualization. The true color scheme
-        (the only option currently implemented) requires bands B02, B03, and B04.
+        (`"true"`, the only option currently implemented) requires bands B02, B03, and B04.
 
     Returns
     -------
@@ -459,7 +602,7 @@ def extract_sentinel_visualization(
         3D RGB array of shape ``(height, width, 3)``.
     src_crs : pyproj.CRS
         Imagery projection
-    src_extent : tuple[float,float,float,float]
+    src_extent : tuple[float, float, float, float]
         Imagery extent in projected coordinates
     """
 

pycontrails/models/cocip/cocip.py

@@ -27,7 +27,7 @@ from pycontrails.core.met_var import MetVariable
 from pycontrails.core.models import Model, interpolate_met
 from pycontrails.core.vector import GeoVectorDataset, VectorDataDict
 from pycontrails.datalib import ecmwf, gfs
-from pycontrails.models import sac, tau_cirrus
+from pycontrails.models import extended_k15, sac, tau_cirrus
 from pycontrails.models.cocip import (
     contrail_properties,
     radiative_forcing,
@@ -58,7 +58,7 @@ class Cocip(Model):
     rad : MetDataset
         Single level dataset containing top of atmosphere radiation fluxes.
         See *Notes* for variable names by data source.
-    params : dict[str, Any], optional
+    params : dict[str, Any] | None, optional
         Override Cocip model parameters with dictionary.
         See :class:`CocipFlightParams` for model parameters.
     **params_kwargs : Any
@@ -411,7 +411,7 @@ class Cocip(Model):
 
         Returns
         -------
-        Flight | list[Flight] | NoReturn
+        Flight | list[Flight]
             Flight(s) with updated Contrail data. The model parameter "verbose_outputs"
             determines the variables on the return flight object.
 
@@ -489,7 +489,7 @@ class Cocip(Model):
 
         Returns
         -------
-        tuple[MetVariable]
+        tuple[MetVariable, ...]
             List of model-agnostic variants of required variables
         """
         available = set(met_var.MET_VARIABLES)
@@ -501,7 +501,7 @@ class Cocip(Model):
 
         Returns
         -------
-        tuple[MetVariable]
+        tuple[MetVariable, ...]
             List of ECMWF-specific variants of required variables
         """
         available = set(ecmwf.ECMWF_VARIABLES)
@@ -513,7 +513,7 @@ class Cocip(Model):
 
         Returns
         -------
-        tuple[MetVariable]
+        tuple[MetVariable, ...]
             List of GFS-specific variants of required variables
         """
         available = set(gfs.GFS_VARIABLES)
@@ -981,6 +981,30 @@ class Cocip(Model):
         )
         iwc_1 = contrail_properties.iwc_post_wake_vortex(iwc, iwc_ad)
 
+        if self.params["vpm_activation"]:
+            # We can add a Cocip parameter for T_exhaust, vpm_ei_n, and particles
+            aei = extended_k15.droplet_apparent_emission_index(
+                specific_humidity=specific_humidity,
+                T_ambient=air_temperature,
+                T_exhaust=self.source.attrs.get("T_exhaust", extended_k15.DEFAULT_EXHAUST_T),
+                air_pressure=air_pressure,
+                nvpm_ei_n=nvpm_ei_n,
+                vpm_ei_n=self.source.attrs.get("vpm_ei_n", extended_k15.DEFAULT_VPM_EI_N),
+                G=self._sac_flight["G"],
+            )
+            min_aei = None  # don't clip
+
+        else:
+            f_activation = contrail_properties.ice_particle_activation_rate(
+                air_temperature, T_critical_sac
+            )
+            aei = nvpm_ei_n * f_activation
+            min_aei = self.params["min_ice_particle_number_nvpm_ei_n"]
+
+        n_ice_per_m_0 = contrail_properties.initial_ice_particle_number(
+            aei=aei, fuel_dist=fuel_dist, min_aei=min_aei
+        )
+
         if self.params["unterstrasser_ice_survival_fraction"]:
             wingspan = self._sac_flight.get_data_or_attr("wingspan")
             rhi_0 = thermo.rhi(specific_humidity, air_temperature, air_pressure)
@@ -997,13 +1021,6 @@ class Cocip(Model):
         else:
             f_surv = contrail_properties.ice_particle_survival_fraction(iwc, iwc_1)
 
-        n_ice_per_m_0 = contrail_properties.initial_ice_particle_number(
-            nvpm_ei_n=nvpm_ei_n,
-            fuel_dist=fuel_dist,
-            air_temperature=air_temperature,
-            T_crit_sac=T_critical_sac,
-            min_ice_particle_number_nvpm_ei_n=self.params["min_ice_particle_number_nvpm_ei_n"],
-        )
         n_ice_per_m_1 = n_ice_per_m_0 * f_surv
 
         # Check for persistent initial_contrails

pycontrails/models/cocip/cocip_params.py

@@ -195,8 +195,8 @@ class CocipParams(AdvectionBuffers):
     nvpm_ei_n_enhancement_factor: float = 1.0
 
     #: Lower bound for ``nvpm_ei_n`` to account for ambient aerosol
-    #: particles for newer engines, [:math:`kg^{-1}`]
-    min_ice_particle_number_nvpm_ei_n: float = 1e13
+    #: particles for newer engines, [:math:`kg^{-1}`]. Set to None to disable.
+    min_ice_particle_number_nvpm_ei_n: float | None = 1e13
 
     #: Upper bound for contrail plume depth, constraining it to realistic values.
     #: CoCiP only uses the ambient conditions at the mid-point of the Gaussian plume,
@@ -223,11 +223,17 @@ class CocipParams(AdvectionBuffers):
     #:  .. versionadded:: 0.28.9
     radiative_heating_effects: bool = False
 
+    #: Experimental. Apply the extended K15 model to account for vPM activation.
+    #: See the preprint `<https://doi.org/10.5194/egusphere-2025-1717>`_ for details.
+    #:
+    #: .. versionadded:: 0.55.0
+    vpm_activation: bool = False
+
     #: Experimental. Radiative effects due to contrail-contrail overlapping
     #: Account for change in local contrail shortwave and longwave radiative forcing
     #: due to contrail-contrail overlapping.
     #:
-    #: .. versionadded:: 0.45
+    #: .. versionadded:: 0.45.0
     contrail_contrail_overlapping: bool = False
 
     #: Experimental. Contrail-contrail overlapping altitude interval

pycontrails/models/cocip/cocip_uncertainty.py

@@ -40,9 +40,9 @@ class habit_dirichlet(rv_frozen):
 
         Parameters
         ----------
-        *args
+        *args : Any
             Used to create a number of habit distributions
-        **kwds
+        **kwds : Any
             Passed through to :func:`scipy.stats.dirichlet.rvs()`
 
         Returns
@@ -190,7 +190,7 @@ class CocipUncertaintyParams(CocipParams):
 
         Returns
         -------
-        dict[str, dict[str, Any]]
+        dict[str, rv_frozen]
             Uncertainty parameters and values
         """
         # handle these differently starting in version 0.27.0
@@ -230,7 +230,7 @@ class CocipUncertaintyParams(CocipParams):
 
         Returns
         -------
-        dict[str, float | npt.NDArray[np.floating]]
+        dict[str, np.float64 | npt.NDArray[np.floating]]
             Dictionary of random parameters. Dictionary keys consists of names of parameters in
             `CocipParams` to be overridden by random value.