pycontrails 0.50.0__cp310-cp310-win_amd64.whl → 0.50.2__cp310-cp310-win_amd64.whl

pycontrails/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.50.0'
-__version_tuple__ = version_tuple = (0, 50, 0)
+__version__ = version = '0.50.2'
+__version_tuple__ = version_tuple = (0, 50, 2)

pycontrails/core/flight.py

@@ -17,6 +17,7 @@ from pycontrails.core.fuel import Fuel, JetA
 from pycontrails.core.vector import AttrDict, GeoVectorDataset, VectorDataDict, VectorDataset
 from pycontrails.physics import constants, geo, units
 from pycontrails.utils import dependencies
+from pycontrails.utils.types import ArrayOrFloat
 
 logger = logging.getLogger(__name__)
 
@@ -787,6 +788,13 @@ class Flight(GeoVectorDataset):
         Waypoints are resampled according to the frequency ``freq``. Values for :attr:`data`
         columns ``longitude``, ``latitude``, and ``altitude`` are interpolated.
 
+        Resampled waypoints will include all multiples of ``freq`` between the flight
+        start and end time. For example, when resampling to a frequency of 1 minute,
+        a flight that starts at 2020/1/1 00:00:59 and ends at 2020/1/1 00:01:01
+        will return a single waypoint at 2020/1/1 00:01:00, whereas a flight that
+        starts at 2020/1/1 00:01:01 and ends at 2020/1/1 00:01:59 will return an empty
+        flight.
+
         Parameters
         ----------
         freq : str, optional
@@ -1105,6 +1113,102 @@ class Flight(GeoVectorDataset):
         out.data.pop("level", None)  # avoid any ambiguity
         return out
 
+    def distance_to_coords(self: Flight, distance: ArrayOrFloat) -> tuple[
+        ArrayOrFloat,
+        ArrayOrFloat,
+        np.intp | npt.NDArray[np.intp],
+    ]:
+        """
+        Convert distance along flight path to geodesic coordinates.
+
+        Will return a tuple containing `(lat, lon, index)`, where index indicates which flight
+        segment contains the returned coordinate.
+
+        Parameters
+        ----------
+        distance : ArrayOrFloat
+            Distance along flight path, [:math:`m`]
+
+        Returns
+        -------
+        (ArrayOrFloat, ArrayOrFloat, int | npt.NDArray[int])
+            latitude, longitude, and segment index cooresponding to distance.
+        """
+
+        # Check if flight crosses antimeridian line
+        lon_ = self["longitude"]
+        lat_ = self["latitude"]
+        sign_ = np.sign(lon_)
+        min_pos = np.min(lon_[sign_ == 1.0], initial=np.inf)
+        max_neg = np.max(lon_[sign_ == -1.0], initial=-np.inf)
+
+        if (180.0 - min_pos) + (180.0 + max_neg) < 180.0 and min_pos < np.inf and max_neg > -np.inf:
+            # In this case, we believe the flight crosses the antimeridian
+            shift = min_pos
+            # So we shift the longitude "chart"
+            lon_ = (lon_ - shift) % 360.0
+        else:
+            shift = None
+
+        # Make a fake flight that flies at constant height so distance is just
+        # distance traveled across groud
+        flat_dataset = Flight(
+            longitude=self.coords["longitude"],
+            latitude=self.coords["latitude"],
+            time=self.coords["time"],
+            level=[self.coords["level"][0] for _ in range(self.size)],
+        )
+
+        lengths = flat_dataset.segment_length()
+        cumulative_lengths = np.nancumsum(lengths)
+        cumulative_lengths = np.insert(cumulative_lengths[:-1], 0, 0)
+        seg_idx: np.intp | npt.NDArray[np.intp]
+
+        if isinstance(distance, float):
+            seg_idx = np.argmax(cumulative_lengths > distance)
+        else:
+            seg_idx = np.argmax(cumulative_lengths > distance.reshape((distance.size, 1)), axis=1)
+
+        # If in the last segment (which has length 0), then just return the last waypoint
+        seg_idx -= 1
+
+        # linear interpolation in lat/lon - assuming the way points are within 100-200km so this
+        # should be accurate enough without needed to reproject or use spherical distance
+        lat1: ArrayOrFloat = lat_[seg_idx]
+        lon1: ArrayOrFloat = lon_[seg_idx]
+        lat2: ArrayOrFloat = lat_[seg_idx + 1]
+        lon2: ArrayOrFloat = lon_[seg_idx + 1]
+
+        dx = distance - cumulative_lengths[seg_idx]
+        fx = dx / lengths[seg_idx]
+        lat = (1 - fx) * lat1 + fx * lat2
+        lon = (1 - fx) * lon1 + fx * lon2
+
+        if isinstance(distance, float):
+            if distance < 0:
+                lat = np.nan
+                lon = np.nan
+                seg_idx = np.intp(0)
+            elif distance >= cumulative_lengths[-1]:
+                lat = lat_[-1]
+                lon = lon_[-1]
+                seg_idx = np.intp(self.size - 1)
+        else:
+            lat[distance < 0] = np.nan
+            lon[distance < 0] = np.nan
+            seg_idx[distance < 0] = 0  # type: ignore
+
+            lat[distance >= cumulative_lengths[-1]] = lat_[-1]
+            lon[distance >= cumulative_lengths[-1]] = lon_[-1]
+            seg_idx[distance >= cumulative_lengths[-1]] = self.size - 1  # type: ignore
+
+        if shift is not None:
+            # We need to translate back to the original chart here
+            lon += shift
+            lon = ((lon + 180.0) % 360.0) - 180.0
+
+        return lat, lon, seg_idx
+
     def _geodesic_interpolation(self, geodesic_threshold: float) -> pd.DataFrame | None:
         """Geodesic interpolate between large gaps between waypoints.
 
@@ -1349,8 +1453,8 @@ class Flight(GeoVectorDataset):
         >>> # Intersect and attach
         >>> fl["air_temperature"] = fl.intersect_met(met['air_temperature'])
         >>> fl["air_temperature"]
-        array([235.94658, 235.95767, 235.96873, ..., 234.59918, 234.60388,
-               234.60846], dtype=float32)
+        array([235.94657007, 235.95766965, 235.96873412, ..., 234.59917962,
+               234.60387402, 234.60845312])
 
         >>> # Length (in meters) of waypoints whose temperature exceeds 236K
         >>> fl.length_met("air_temperature", threshold=236)
@@ -2063,11 +2167,9 @@ def _resample_to_freq(df: pd.DataFrame, freq: str) -> tuple[pd.DataFrame, pd.Dat
 
     # Manually create a new index that includes all the original index values
     # and the resampled-to-freq index values.
-    t0 = df.index[0]
+    t0 = df.index[0].ceil(freq)
     t1 = df.index[-1]
-    t = pd.date_range(t0, t1, freq=freq, name="time").floor(freq)
-    if t[0] < t0:
-        t = t[1:]
+    t = pd.date_range(t0, t1, freq=freq, name="time")
 
     concat_arr = np.concatenate([df.index, t])
     concat_arr = np.unique(concat_arr)

pycontrails/core/interpolation.py

@@ -71,7 +71,9 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
 
         self.grid = points
         self.values = values
-        self.method = method
+        # TODO: consider supporting updated tensor-product spline methods
+        # see https://github.com/scipy/scipy/releases/tag/v1.13.0
+        self.method = _pick_method(scipy.__version__, method)
         self.bounds_error = bounds_error
         self.fill_value = fill_value
 
@@ -219,6 +221,42 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
         raise ValueError(msg)
 
 
+def _pick_method(scipy_version: str, method: str) -> str:
+    """Select an interpolation method.
+
+    For scipy versions 1.13.0 and later, fall back on legacy implementations
+    of tensor-product spline methods. The default implementations in 1.13.0
+    and later are incompatible with this class.
+
+    Parameters
+    ----------
+    scipy_version : str
+        scipy version (major.minor.patch)
+
+    method : str
+        Interpolation method. Passed into :class:`scipy.interpolate.RegularGridInterpolator`
+        as-is unless ``scipy_version`` is 1.13.0 or later and ``method`` is ``"slinear"``,
+        ``"cubic"``, or ``"quintic"``. In this case, ``"_legacy"`` is appended to ``method``.
+
+    Returns
+    -------
+    str
+        Interpolation method adjusted for compatibility with this class.
+    """
+    try:
+        version = scipy_version.split(".")
+        major = int(version[0])
+        minor = int(version[1])
+    except (IndexError, ValueError) as exc:
+        msg = f"Failed to parse major and minor version from {scipy_version}"
+        raise ValueError(msg) from exc
+
+    reimplemented_methods = ["slinear", "cubic", "quintic"]
+    if major > 1 or (major == 1 and minor >= 13) and method in reimplemented_methods:
+        return method + "_legacy"
+    return method
+
+
 def _floatize_time(
     time: npt.NDArray[np.datetime64], offset: np.datetime64
 ) -> npt.NDArray[np.float64]:

pycontrails/core/met.py

@@ -674,13 +674,10 @@ class MetDataset(MetBase):
     >>> da = mda.data  # Underlying `xarray` object
 
     >>> # Check out a few values
-    >>> da[5:10, 5:10, 1, 1].values
-    array([[224.0896 , 224.41374, 224.75946, 225.16237, 225.60507],
-           [224.09457, 224.42038, 224.76526, 225.16817, 225.61089],
-           [224.10037, 224.42618, 224.77106, 225.17314, 225.61586],
-           [224.10617, 224.43282, 224.7777 , 225.17812, 225.62166],
-           [224.11115, 224.44028, 224.7835 , 225.18393, 225.62663]],
-          dtype=float32)
+    >>> da[5:8, 5:8, 1, 1].values
+    array([[224.08959005, 224.41374427, 224.75945349],
+           [224.09456429, 224.42037658, 224.76525676],
+           [224.10036756, 224.42617985, 224.77106004]])
 
     >>> # Mean temperature over entire array
     >>> da.mean().load().item()
@@ -1618,15 +1615,15 @@ class MetDataArray(MetBase):
 
         >>> # Interpolation at a grid point agrees with value
         >>> mda.interpolate(1, 2, 300, np.datetime64('2022-03-01T14:00'))
-        array([241.91974], dtype=float32)
+        array([241.91972984])
 
         >>> da = mda.data
         >>> da.sel(longitude=1, latitude=2, level=300, time=np.datetime64('2022-03-01T14')).item()
-        241.91974
+        241.9197298421629
 
         >>> # Interpolation off grid
         >>> mda.interpolate(1.1, 2.1, 290, np.datetime64('2022-03-01 13:10'))
-        array([239.83794], dtype=float32)
+        array([239.83793798])
 
         >>> # Interpolate along path
         >>> longitude = np.linspace(1, 2, 10)
@@ -1634,8 +1631,9 @@ class MetDataArray(MetBase):
         >>> level = np.linspace(200, 300, 10)
         >>> time = pd.date_range("2022-03-01T14", periods=10, freq="5min")
         >>> mda.interpolate(longitude, latitude, level, time)
-        array([220.44348, 223.089  , 225.7434 , 228.41643, 231.10858, 233.54858,
-               235.71506, 237.86479, 239.99275, 242.10793], dtype=float32)
+        array([220.44347694, 223.08900738, 225.74338924, 228.41642088,
+               231.10858599, 233.54857391, 235.71504913, 237.86478872,
+               239.99274623, 242.10792167])
         """
         # Load if necessary
         if not self.in_memory:

pycontrails/core/vector.py

@@ -1694,12 +1694,14 @@ class GeoVectorDataset(VectorDataset):
 
         >>> # Intersect
         >>> fl.intersect_met(met['air_temperature'], method='nearest')
-        array([231.6297 , 230.72604, 232.2432 , 231.88339, 231.0643 , 231.59073,
-               231.65126, 231.93065, 232.03345, 231.65955], dtype=float32)
+        array([231.62969892, 230.72604651, 232.24318771, 231.88338483,
+               231.06429438, 231.59073409, 231.65125393, 231.93064004,
+               232.03344087, 231.65954432])
 
         >>> fl.intersect_met(met['air_temperature'], method='linear')
-        array([225.77794, 225.13908, 226.23122, 226.31831, 225.56102, 225.81192,
-               226.03194, 226.22057, 226.0377 , 225.63226], dtype=float32)
+        array([225.77794552, 225.13908414, 226.231218  , 226.31831528,
+               225.56102321, 225.81192149, 226.03192642, 226.22056121,
+               226.03770174, 225.63226188])
 
         >>> # Interpolate and attach to `Flight` instance
         >>> for key in met:
@@ -1708,11 +1710,11 @@ class GeoVectorDataset(VectorDataset):
         >>> # Show the final three columns of the dataframe
         >>> fl.dataframe.iloc[:, -3:].head()
                          time  air_temperature  specific_humidity
-        0 2022-03-01 00:00:00       225.777939           0.000132
+        0 2022-03-01 00:00:00       225.777946           0.000132
         1 2022-03-01 00:13:20       225.139084           0.000132
-        2 2022-03-01 00:26:40       226.231216           0.000107
-        3 2022-03-01 00:40:00       226.318314           0.000171
-        4 2022-03-01 00:53:20       225.561020           0.000109
+        2 2022-03-01 00:26:40       226.231218           0.000107
+        3 2022-03-01 00:40:00       226.318315           0.000171
+        4 2022-03-01 00:53:20       225.561022           0.000109
 
         """
         # Override use_indices in certain situations

pycontrails/datalib/goes.py

@@ -50,7 +50,7 @@ except ModuleNotFoundError as exc:
 
 
 #: Default channels to use if none are specified. These are the channels
-#: required by the MIT ash color scheme.
+#: required by the SEVIRI (MIT) ash color scheme.
 DEFAULT_CHANNELS = "C11", "C14", "C15"
 
 #: The time at which the GOES scan mode changed from mode 3 to mode 6. This
@@ -203,10 +203,10 @@ def gcs_goes_path(
         GOES Region of interest.
     channels : str | Iterable[str]
         Set of channels or bands for CMIP data. The 16 possible channels are
-        represented by the strings "C01" to "C16". For the MIT ash color scheme,
+        represented by the strings "C01" to "C16". For the SEVIRI ash color scheme,
         set ``channels=("C11", "C14", "C15")``. For the true color scheme,
         set ``channels=("C01", "C02", "C03")``. By default, the channels
-        required by the MIT ash color scheme are used.
+        required by the SEVIRI ash color scheme are used.
 
     Returns
     -------
@@ -306,10 +306,10 @@ class GOES:
 
     channels : str | set[str] | None
         Set of channels or bands for CMIP data. The 16 possible channels are
-        represented by the strings "C01" to "C16". For the MIT ash color scheme,
+        represented by the strings "C01" to "C16". For the SEVIRI ash color scheme,
         set ``channels=("C11", "C14", "C15")``. For the true color scheme,
         set ``channels=("C01", "C02", "C03")``. By default, the channels
-        required by the MIT ash color scheme are used. The channels must have
+        required by the SEVIRI ash color scheme are used. The channels must have
         a common horizontal resolution. The resolutions are:
 
         - C01: 1.0 km
@@ -585,7 +585,7 @@ def _concat_c02(ds1: XArrayType, ds2: XArrayType) -> XArrayType:
 def extract_goes_visualization(
     da: xr.DataArray,
     color_scheme: str = "ash",
-    ash_convention: str = "MIT",
+    ash_convention: str = "SEVIRI",
     gamma: float = 2.2,
 ) -> tuple[npt.NDArray[np.float32], ccrs.Geostationary, tuple[float, float, float, float]]:
     """Extract artifacts for visualizing GOES data with the given color scheme.
@@ -597,7 +597,7 @@ def extract_goes_visualization(
         required by :func:`to_ash`.
     color_scheme : str = {"ash", "true"}
         Color scheme to use for visualization.
-    ash_convention : str = {"MIT", "standard"}
+    ash_convention : str = {"SEVIRI", "standard"}
         Passed into :func:`to_ash`. Only used if ``color_scheme="ash"``.
     gamma : float = 2.2
         Passed into :func:`to_true_color`. Only used if ``color_scheme="true"``.
@@ -672,17 +672,18 @@ def to_true_color(da: xr.DataArray, gamma: float = 2.2) -> npt.NDArray[np.float3
     return np.dstack([red, green, blue])
 
 
-def to_ash(da: xr.DataArray, convention: str = "MIT") -> npt.NDArray[np.float32]:
+def to_ash(da: xr.DataArray, convention: str = "SEVIRI") -> npt.NDArray[np.float32]:
     """Compute 3d RGB array for the ASH color scheme.
 
     Parameters
     ----------
     da : xr.DataArray
         DataArray of GOES data with appropriate channels.
-    convention : str = {"MIT", "standard"}
+    convention : str = {"SEVIRI", "standard"}
         Convention for color space.
 
-        - MIT convention requires channels C11, C14, C15
+        - SEVIRI convention requires channels C11, C14, C15.
+          Used in :cite:`kulikSatellitebasedDetectionContrails2019`.
         - Standard convention requires channels C11, C13, C14, C15
 
     Returns
@@ -693,6 +694,7 @@ def to_ash(da: xr.DataArray, convention: str = "MIT") -> npt.NDArray[np.float32]
     References
     ----------
     - `Ash RGB quick guide (the color space and color interpretations) <https://rammb.cira.colostate.edu/training/visit/quick_guides/GOES_Ash_RGB.pdf>`_
+    - :cite:`SEVIRIRGBCal`
     - :cite:`kulikSatellitebasedDetectionContrails2019`
 
     Examples
@@ -716,7 +718,7 @@ def to_ash(da: xr.DataArray, convention: str = "MIT") -> npt.NDArray[np.float32]
         green = c14 - c11
         blue = c13
 
-    elif convention == "MIT":
+    elif convention in ["SEVIRI", "MIT"]:  # retain MIT for backwards compatibility
         c11 = da.sel(band_id=11).values  # 8.44
         c14 = da.sel(band_id=14).values  # 11.19
         c15 = da.sel(band_id=15).values  # 12.27
@@ -726,7 +728,7 @@ def to_ash(da: xr.DataArray, convention: str = "MIT") -> npt.NDArray[np.float32]
         blue = c14
 
     else:
-        raise ValueError("Convention must be either 'MIT' or 'standard'")
+        raise ValueError("Convention must be either 'SEVIRI' or 'standard'")
 
     # See colostate pdf for slightly wider values
     red = _clip_and_scale(red, -4.0, 2.0)

pycontrails/models/cocip/cocip.py

@@ -26,6 +26,7 @@ from pycontrails.models.cocip import (
     contrail_properties,
     radiative_forcing,
     radiative_heating,
+    unterstrasser_wake_vortex,
     wake_vortex,
     wind_shear,
 )
@@ -838,9 +839,9 @@ class Cocip(Model):
         T_critical_sac = self._sac_flight["T_critical_sac"]
 
         # Flight performance parameters
-        fuel_dist = (
-            self._sac_flight.get_data_or_attr("fuel_flow") / self._sac_flight["true_airspeed"]
-        )
+        fuel_flow = self._sac_flight.get_data_or_attr("fuel_flow")
+        true_airspeed = self._sac_flight["true_airspeed"]
+        fuel_dist = fuel_flow / true_airspeed
 
         nvpm_ei_n = self._sac_flight.get_data_or_attr("nvpm_ei_n")
         ei_h2o = self._sac_flight.fuel.ei_h2o
@@ -890,11 +891,27 @@ class Cocip(Model):
             air_temperature, air_pressure, air_pressure_1
         )
         iwc_1 = contrail_properties.iwc_post_wake_vortex(iwc, iwc_ad)
+
+        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)
+            f_surv = unterstrasser_wake_vortex.ice_particle_number_survival_fraction(
+                air_temperature,
+                rhi_0,
+                ei_h2o,
+                wingspan,
+                true_airspeed,
+                fuel_flow,
+                nvpm_ei_n,
+                0.5 * depth,  # Taking the mid-point of the contrail plume
+            )
+        else:
+            f_surv = contrail_properties.ice_particle_survival_fraction(iwc, iwc_1)
+
         n_ice_per_m_1 = contrail_properties.ice_particle_number(
             nvpm_ei_n=nvpm_ei_n,
             fuel_dist=fuel_dist,
-            iwc=iwc,
-            iwc_1=iwc_1,
+            f_surv=f_surv,
             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"],

pycontrails/models/cocip/cocip_params.py

@@ -138,12 +138,12 @@ class CocipParams(ModelParams):
 
     #: Add additional metric of ATR20 and global yearly mean RF to model output.
     #: These are not standard CoCiP outputs but based on the derivation used
-    #: in the first supplement to :cite:`yin_predicting_2023`. ATR20 is defined
+    #: in the first supplement to :cite:`yinPredictingClimateImpact2023`. ATR20 is defined
     #: as the average temperature response over a 20 year horizon.
     compute_atr20: bool = False
 
     #: Constant factor used to convert global- and year-mean RF, [:math:`W m^{-2}`],
-    #: to ATR20, [:math:`K`], given by :cite:`yin_predicting_2023`.
+    #: to ATR20, [:math:`K`], given by :cite:`yinPredictingClimateImpact2023`.
     global_rf_to_atr20_factor: float = 0.0151
 
     # ----------------
@@ -184,6 +184,15 @@ class CocipParams(ModelParams):
     #: :attr:`radiative_heating_effects` is enabled.
     max_depth: float = 1500.0
 
+    #: Experimental. Improved ice crystal number survival fraction in the wake vortex phase.
+    #: Implement :cite:`unterstrasserPropertiesYoungContrails2016`, who developed a
+    #: parametric model that estimates the survival fraction of the contrail ice crystal
+    #: number after the wake vortex phase based on the results from large eddy simulations.
+    #: This replicates Fig. 4 of :cite:`karcherFormationRadiativeForcing2018`.
+    #:
+    #:  .. versionadded:: 0.50.1
+    unterstrasser_ice_survival_fraction: bool = False
+
     #: Experimental. Radiative heating effects on contrail cirrus properties.
     #: Terrestrial and solar radiances warm the contrail ice particles and cause
     #: convective turbulence. This effect is expected to enhance vertical mixing

pycontrails/models/cocip/contrail_properties.py

@@ -204,8 +204,7 @@ def iwc_post_wake_vortex(
 def ice_particle_number(
     nvpm_ei_n: npt.NDArray[np.float64],
     fuel_dist: npt.NDArray[np.float64],
-    iwc: npt.NDArray[np.float64],
-    iwc_1: npt.NDArray[np.float64],
+    f_surv: npt.NDArray[np.float64],
     air_temperature: npt.NDArray[np.float64],
     T_crit_sac: npt.NDArray[np.float64],
     min_ice_particle_number_nvpm_ei_n: float,
@@ -223,11 +222,8 @@ def ice_particle_number(
         black carbon number emissions index, [:math:`kg^{-1}`]
     fuel_dist : npt.NDArray[np.float64]
         fuel consumption of the flight segment per distance traveled, [:math:`kg m^{-1}`]
-    iwc : npt.NDArray[np.float64]
-        initial ice water content at each flight waypoint before the wake vortex
-        phase, [:math:`kg_{H_{2}O}/kg_{air}`]
-    iwc_1 : npt.NDArray[np.float64]
-        ice water content after the wake vortex phase, [:math:`kg_{H_{2}O}/kg_{air}`]
+    f_surv : npt.NDArray[np.float64]
+        Fraction of contrail ice particle number that survive the wake vortex phase.
     air_temperature : npt.NDArray[np.float64]
         ambient temperature for each waypoint, [:math:`K`]
     T_crit_sac : npt.NDArray[np.float64]
@@ -241,7 +237,6 @@ def ice_particle_number(
     npt.NDArray[np.float64]
         initial number of ice particles per distance after the wake vortex phase, [:math:`# m^{-1}`]
     """
-    f_surv = ice_particle_survival_factor(iwc, iwc_1)
     f_activation = ice_particle_activation_rate(air_temperature, T_crit_sac)
     nvpm_ei_n_activated = nvpm_ei_n * f_activation
     return fuel_dist * np.maximum(nvpm_ei_n_activated, min_ice_particle_number_nvpm_ei_n) * f_surv
@@ -289,7 +284,7 @@ def ice_particle_activation_rate(
     return -0.661 * np.exp(d_temp) + 1.0
 
 
-def ice_particle_survival_factor(
+def ice_particle_survival_fraction(
     iwc: npt.NDArray[np.float64], iwc_1: npt.NDArray[np.float64]
 ) -> npt.NDArray[np.float64]:
     """