pycontrails 0.50.0__cp311-cp311-win_amd64.whl → 0.50.1__cp311-cp311-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.1'
+__version_tuple__ = version_tuple = (0, 50, 1)

pycontrails/core/flight.py

@@ -787,6 +787,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
@@ -1349,8 +1356,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 +2070,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]:
     """

pycontrails/models/cocip/unterstrasser_wake_vortex.py

@@ -0,0 +1,403 @@
+"""Wave-vortex downwash functions from Unterstrasser (2016).
+
+Notes
+-----
+:cite:`unterstrasserPropertiesYoungContrails2016` provides a parameterized model of the
+survival fraction of the contrail ice crystal number ``f_surv`` during the  wake-vortex phase.
+The model was developed based on output from large eddy simulations, and improves agreement with
+LES outputs relative to the default survival fraction parameterization used in CoCiP.
+
+For comparison, CoCiP assumes that ``f_surv`` is equal to the change in the contrail ice water
+content (by mass) before and after the wake vortex phase. However, for larger (smaller) ice
+particles, their survival fraction by number could be smaller (larger) than their survival fraction
+by mass. This is particularly important in the "soot-poor" scenario, for example, in cleaner
+lean-burn engines where their soot emissions can be 3-4 orders of magnitude lower than conventional
+RQL engines.
+
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import numpy.typing as npt
+
+from pycontrails.models.cocip.wake_vortex import wake_vortex_separation
+from pycontrails.physics import constants, thermo
+
+
+def ice_particle_number_survival_fraction(
+    air_temperature: npt.NDArray[np.float64],
+    rhi_0: npt.NDArray[np.float64],
+    ei_h2o: npt.NDArray[np.float64] | float,
+    wingspan: npt.NDArray[np.float64] | float,
+    true_airspeed: npt.NDArray[np.float64],
+    fuel_flow: npt.NDArray[np.float64],
+    aei_n: npt.NDArray[np.float64],
+    z_desc: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    r"""
+    Calculate fraction of ice particle number surviving the wake vortex phase and required inputs.
+
+    This implementation is based on the work of :cite:`unterstrasserPropertiesYoungContrails2016`
+    and is an improved estimation compared with
+    :func:`contrail_properties.ice_particle_survival_fraction`.
+
+    Parameters
+    ----------
+    air_temperature : npt.NDArray[np.float64]
+        ambient temperature for each waypoint, [:math:`K`]
+    rhi_0: npt.NDArray[np.float64]
+        Relative humidity with respect to ice at the flight waypoint
+    ei_h2o : npt.NDArray[np.float64] | float
+        Emission index of water vapor, [:math:`kg \ kg^{-1}`]
+    wingspan : npt.NDArray[np.float64] | float
+        aircraft wingspan, [:math:`m`]
+    true_airspeed : npt.NDArray[np.float64]
+        true airspeed for each waypoint, [:math:`m s^{-1}`]
+    fuel_flow : npt.NDArray[np.float64]
+        Fuel mass flow rate, [:math:`kg s^{-1}`]
+    aei_n : npt.NDArray[np.float64]
+        Apparent ice crystal number emissions index at contrail formation, [:math:`kg^{-1}`]
+    z_desc : npt.NDArray[np.float64]
+        Final vertical displacement of the wake vortex, ``dz_max`` in :mod:`wake_vortex.py`,
+        [:math:`m`].
+
+    Returns
+    -------
+    npt.NDArray[np.float64]
+        Fraction of contrail ice particle number that survive the wake vortex phase.
+
+    References
+    ----------
+    - :cite:`unterstrasserPropertiesYoungContrails2016`
+
+    Notes
+    -----
+    - See eq. (3), (9), and (10) in :cite:`unterstrasserPropertiesYoungContrails2016`.
+    - For consistency in CoCiP, ``z_desc`` should be calculated using :func:`dz_max` instead of
+      using :func:`z_desc_length_scale`.
+    """
+    # Length scales
+    z_atm = z_atm_length_scale(air_temperature, rhi_0)
+    rho_emit = emitted_water_vapour_concentration(ei_h2o, wingspan, true_airspeed, fuel_flow)
+    z_emit = z_emit_length_scale(rho_emit, air_temperature)
+    z_total = z_total_length_scale(aei_n, z_atm, z_emit, z_desc)
+    return _survival_fraction_from_length_scale(z_total)
+
+
+def z_total_length_scale(
+    aei_n: npt.NDArray[np.float64],
+    z_atm: npt.NDArray[np.float64],
+    z_emit: npt.NDArray[np.float64],
+    z_desc: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """
+    Calculate the total length-scale effect of the wake vortex downwash.
+
+    Parameters
+    ----------
+    aei_n : npt.NDArray[np.float64]
+        Apparent ice crystal number emissions index at contrail formation, [:math:`kg^{-1}`]
+    z_atm : npt.NDArray[np.float64]
+        Length-scale effect of ambient supersaturation on the ice crystal mass budget, [:math:`m`]
+    z_emit : npt.NDArray[np.float64]
+        Length-scale effect of water vapour emissions on the ice crystal mass budget, [:math:`m`]
+    z_desc : npt.NDArray[np.float64]
+        Final vertical displacement of the wake vortex, `dz_max` in `wake_vortex.py`, [:math:`m`]
+
+    Returns
+    -------
+    npt.NDArray[np.float64]
+        Total length-scale effect of the wake vortex downwash, [:math:`m`]
+    """
+    alpha_base = (aei_n / 2.8e14) ** (-0.18)
+    alpha_atm = 1.7 * alpha_base
+    alpha_emit = 1.15 * alpha_base
+
+    z_total = alpha_atm * z_atm + alpha_emit * z_emit - 0.6 * z_desc
+
+    z_total.clip(min=0.0, out=z_total)
+    return z_total
+
+
+def z_atm_length_scale(
+    air_temperature: npt.NDArray[np.float64],
+    rhi_0: npt.NDArray[np.float64],
+    *,
+    n_iter: int = 10,
+) -> npt.NDArray[np.float64]:
+    """Calculate the length-scale effect of ambient supersaturation on the ice crystal mass budget.
+
+    Parameters
+    ----------
+    air_temperature : npt.NDArray[np.float64]
+        Ambient temperature for each waypoint, [:math:`K`].
+    rhi_0 : npt.NDArray[np.float64]
+        Relative humidity with respect to ice at the flight waypoint.
+    n_iter : int
+        Number of iterations, set to 10 as default where ``z_atm`` is accurate to within +-1 m.
+
+    Returns
+    -------
+    npt.NDArray[np.float64]
+        The effect of the ambient supersaturation on the ice crystal mass budget,
+        provided as a length scale equivalent, [:math:`m`].
+
+    Notes
+    -----
+    - See eq. (5) in :cite:`unterstrasserPropertiesYoungContrails2016`.
+    """
+    # Only perform operation when the ambient condition is supersaturated w.r.t. ice
+    issr = rhi_0 > 1.0
+
+    rhi_issr = rhi_0[issr]
+    air_temperature_issr = air_temperature[issr]
+
+    # Solve non-linear equation numerically using the bisection method
+    # Did not use scipy functions because it is unstable when dealing with np.arrays
+    z_1 = np.zeros_like(rhi_issr)
+    z_2 = np.full_like(rhi_issr, 1000.0)
+    lhs = rhi_issr * thermo.e_sat_ice(air_temperature_issr) / air_temperature_issr
+
+    dry_adiabatic_lapse_rate = constants.g / constants.c_pd
+    for _ in range(n_iter):
+        z_est = 0.5 * (z_1 + z_2)
+        rhs = (thermo.e_sat_ice(air_temperature_issr + dry_adiabatic_lapse_rate * z_est)) / (
+            air_temperature_issr + dry_adiabatic_lapse_rate * z_est
+        )
+        z_1[lhs > rhs] = z_est[lhs > rhs]
+        z_2[lhs < rhs] = z_est[lhs < rhs]
+
+    out = np.zeros_like(rhi_0)
+    out[issr] = 0.5 * (z_1 + z_2)
+    return out
+
+
+def emitted_water_vapour_concentration(
+    ei_h2o: npt.NDArray[np.float64] | float,
+    wingspan: npt.NDArray[np.float64] | float,
+    true_airspeed: npt.NDArray[np.float64],
+    fuel_flow: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    r"""
+    Calculate aircraft-emitted water vapour concentration in the plume.
+
+    Parameters
+    ----------
+    ei_h2o : npt.NDArray[np.float64] | float
+        Emission index of water vapor, [:math:`kg \ kg^{-1}`]
+    wingspan : npt.NDArray[np.float64] | float
+        aircraft wingspan, [:math:`m`]
+    true_airspeed : npt.NDArray[np.float64]
+        true airspeed for each waypoint, [:math:`m s^{-1}`]
+    fuel_flow : npt.NDArray[np.float64]
+        Fuel mass flow rate, [:math:`kg s^{-1}`]
+
+    Returns
+    -------
+    npt.NDArray[np.float64]
+        Aircraft-emitted water vapour concentration in the plume, [:math:`kg m^{-3}`]
+
+    Notes
+    -----
+    - See eq. (6) and (A8) in :cite:`unterstrasserPropertiesYoungContrails2016`.
+    """
+    h2o_per_dist = (ei_h2o * fuel_flow) / true_airspeed
+    area_p = plume_area(wingspan)
+    return h2o_per_dist / area_p
+
+
+def z_emit_length_scale(
+    rho_emit: npt.NDArray[np.float64], air_temperature: npt.NDArray[np.float64], *, n_iter: int = 10
+) -> npt.NDArray[np.float64]:
+    """Calculate the length-scale effect of water vapour emissions on the ice crystal mass budget.
+
+    Parameters
+    ----------
+    rho_emit : npt.NDArray[np.float64] | float
+        Aircraft-emitted water vapour concentration in the plume, [:math:`kg m^{-3}`]
+    air_temperature : npt.NDArray[np.float64]
+        ambient temperature for each waypoint, [:math:`K`]
+    n_iter : int
+        Number of iterations, set to 10 as default where ``z_emit`` is accurate to within +-1 m.
+
+    Returns
+    -------
+    npt.NDArray[np.float64]
+        The effect of the aircraft water vapour emission on the ice crystal mass budget,
+        provided as a length scale equivalent, [:math:`m`]
+
+    Notes
+    -----
+    - See eq. (7) in :cite:`unterstrasserPropertiesYoungContrails2016`.
+    """
+    # Solve non-linear equation numerically using the bisection method
+    # Did not use scipy functions because it is unstable when dealing with np.arrays
+    z_1 = np.zeros_like(rho_emit)
+    z_2 = np.full_like(rho_emit, 1000.0)
+
+    lhs = (thermo.e_sat_ice(air_temperature) / (constants.R_v * air_temperature)) + rho_emit
+
+    dry_adiabatic_lapse_rate = constants.g / constants.c_pd
+    for _ in range(n_iter):
+        z_est = 0.5 * (z_1 + z_2)
+        rhs = thermo.e_sat_ice(air_temperature + dry_adiabatic_lapse_rate * z_est) / (
+            constants.R_v * (air_temperature + dry_adiabatic_lapse_rate * z_est)
+        )
+        z_1[lhs > rhs] = z_est[lhs > rhs]
+        z_2[lhs < rhs] = z_est[lhs < rhs]
+
+    return 0.5 * (z_1 + z_2)
+
+
+def plume_area(wingspan: npt.NDArray[np.float64] | float) -> npt.NDArray[np.float64] | float:
+    """Calculate area of the wake-vortex plume.
+
+    Parameters
+    ----------
+    wingspan : npt.NDArray[np.float64] | float
+        aircraft wingspan, [:math:`m`]
+
+    Returns
+    -------
+    float
+        Area of two wake-vortex plumes, [:math:`m^{2}`]
+
+    Notes
+    -----
+    - See eq. (A6) and (A7) in :cite:`unterstrasserPropertiesYoungContrails2016`.
+    """
+    r_plume = 1.5 + 0.314 * wingspan
+    return 2.0 * 2.0 * np.pi * r_plume**2
+
+
+def z_desc_length_scale(
+    wingspan: npt.NDArray[np.float64] | float,
+    air_temperature: npt.NDArray[np.float64],
+    air_pressure: npt.NDArray[np.float64],
+    true_airspeed: npt.NDArray[np.float64],
+    aircraft_mass: npt.NDArray[np.float64],
+    dT_dz: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """Calculate the final vertical displacement of the wake vortex.
+
+    Parameters
+    ----------
+    wingspan : npt.NDArray[np.float64] | float
+        aircraft wingspan, [:math:`m`]
+    air_temperature : npt.NDArray[np.float64]
+        ambient temperature for each waypoint, [:math:`K`]
+    air_pressure : npt.NDArray[np.float64]
+        pressure altitude at each waypoint, [:math:`Pa`]
+    true_airspeed : npt.NDArray[np.float64]
+        true airspeed for each waypoint, [:math:`m s^{-1}`]
+    aircraft_mass : npt.NDArray[np.float64] | float
+        aircraft mass for each waypoint, [:math:`kg`]
+    dT_dz : npt.NDArray[np.float64]
+        potential temperature gradient, [:math:`K m^{-1}`]
+
+    Returns
+    -------
+    npt.NDArray[np.float64]
+        Final vertical displacement of the wake vortex, [:math:`m`]
+
+    Notes
+    -----
+    - See eq. (4) in :cite:`unterstrasserPropertiesYoungContrails2016`.
+    """
+    gamma_0 = _initial_wake_vortex_circulation(
+        wingspan, air_temperature, air_pressure, true_airspeed, aircraft_mass
+    )
+    n_bv = thermo.brunt_vaisala_frequency(air_pressure, air_temperature, dT_dz)
+    return ((8.0 * gamma_0) / (np.pi * n_bv)) ** 0.5
+
+
+def _initial_wake_vortex_circulation(
+    wingspan: npt.NDArray[np.float64] | float,
+    air_temperature: npt.NDArray[np.float64],
+    air_pressure: npt.NDArray[np.float64],
+    true_airspeed: npt.NDArray[np.float64],
+    aircraft_mass: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """Calculate initial wake vortex circulation.
+
+    Parameters
+    ----------
+    wingspan : npt.NDArray[np.float64] | float
+        aircraft wingspan, [:math:`m`]
+    air_temperature : npt.NDArray[np.float64]
+        ambient temperature for each waypoint, [:math:`K`]
+    air_pressure : npt.NDArray[np.float64]
+        pressure altitude at each waypoint, [:math:`Pa`]
+    true_airspeed : npt.NDArray[np.float64]
+        true airspeed for each waypoint, [:math:`m s^{-1}`]
+    aircraft_mass : npt.NDArray[np.float64] | float
+        aircraft mass for each waypoint, [:math:`kg`]
+
+    Returns
+    -------
+    npt.NDArray[np.float64]
+        Initial wake vortex circulation, [:math:`m^{2} s^{-1}`]
+
+    Notes
+    -----
+    - This is a measure of the strength/intensity of the wake vortex circulation.
+    - See eq. (A1) in :cite:`unterstrasserPropertiesYoungContrails2016`.
+    """
+    b_0 = wake_vortex_separation(wingspan)
+    rho_air = thermo.rho_d(air_temperature, air_pressure)
+    return (constants.g * aircraft_mass) / (rho_air * b_0 * true_airspeed)
+
+
+def _survival_fraction_from_length_scale(
+    z_total: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """
+    Calculate fraction of ice particle number surviving the wake vortex phase.
+
+    Parameters
+    ----------
+    z_total : npt.NDArray[np.float64]
+        Total length-scale effect of the wake vortex downwash, [:math:`m`]
+
+    Returns
+    -------
+    npt.NDArray[np.float64]
+        Fraction of ice particle number surviving the wake vortex phase
+    """
+    f_surv = 0.45 + (1.19 / np.pi) * np.arctan(-1.35 + (z_total / 100.0))
+    np.clip(f_surv, 0.0, 1.0, out=f_surv)
+    return f_surv
+
+
+def initial_contrail_depth(
+    z_desc: npt.NDArray[np.float64],
+    f_surv: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """Calculate initial contrail depth using :cite:`unterstrasserPropertiesYoungContrails2016`.
+
+    Parameters
+    ----------
+    z_desc : npt.NDArray[np.float64]
+        Final vertical displacement of the wake vortex, ``dz_max`` in :mod:`wake_vortex.py`,
+        [:math:`m`].
+    f_surv : npt.NDArray[np.float64]
+        Fraction of contrail ice particle number that survive the wake vortex phase.
+        See :func:`ice_particle_survival_fraction`.
+
+    Returns
+    -------
+    npt.NDArray[np.float64]
+        Initial contrail depth, [:math:`m`]
+
+    Notes
+    -----
+    - See eq. (12), and (13) in :cite:`unterstrasserPropertiesYoungContrails2016`.
+    - For consistency in CoCiP, `z_desc` should be calculated using :func:`dz_max` instead of
+      using :func:`z_desc_length_scale`.
+    """
+    return z_desc * np.where(
+        f_surv <= 0.2,
+        6.0 * f_surv,
+        0.15 * f_surv + (6.0 - 0.15) * 0.2,
+    )

pycontrails/models/cocip/wake_vortex.py

@@ -1,4 +1,25 @@
-"""Wave-vortex downwash functions."""
+"""Wave-vortex downwash functions.
+
+This module includes equations from the original CoCiP model
+:cite:`schumannContrailCirrusPrediction2012`. An alternative set of equations based on
+:cite:`unterstrasserPropertiesYoungContrails2016` is available in
+:py:mod:`unterstrasser_wake_vortex`.
+
+Unterstrasser Notes
+-------------------
+
+Improved estimation of the survival fraction of the contrail ice crystal number ``f_surv``
+during the  wake-vortex phase. This is a parameterised model that is developed based on
+outputs provided by large eddy simulations.
+
+For comparison, CoCiP assumes that ``f_surv`` is equal to the change in the contrail ice water
+content (by mass) before and after the wake vortex phase. However, for larger (smaller) ice
+particles, their survival fraction by number could be smaller (larger) than their survival fraction
+by mass. This is particularly important in the "soot-poor" scenario, for example, in cleaner
+lean-burn engines where their soot emissions can be 3-4 orders of magnitude lower than conventional
+RQL engines.
+
+"""
 
 from __future__ import annotations
 

pycontrails/models/cocipgrid/cocip_grid.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Any, NoReturn, TypeVar, overload
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
+import xarray as xr
 
 import pycontrails
 from pycontrails.core import models
@@ -20,7 +21,7 @@ from pycontrails.models import humidity_scaling, sac
 from pycontrails.models.cocip import cocip, contrail_properties, wake_vortex, wind_shear
 from pycontrails.models.cocipgrid.cocip_grid_params import CocipGridParams
 from pycontrails.models.emissions import Emissions
-from pycontrails.physics import geo, thermo, units
+from pycontrails.physics import constants, geo, thermo, units
 from pycontrails.utils import dependencies
 
 if TYPE_CHECKING:
@@ -122,6 +123,13 @@ class CocipGrid(models.Model):
             msg = "Parameter 'radiative_heating_effects' is not yet implemented in CocipGrid"
             raise NotImplementedError(msg)
 
+        if self.params["unterstrasser_ice_survival_fraction"]:
+            msg = (
+                "Parameter 'unterstrasser_ice_survival_fraction' is not "
+                "yet implemented in CocipGrid"
+            )
+            raise NotImplementedError(msg)
+
         self._target_dtype = np.result_type(*self.met.data.values())
 
     @overload
@@ -304,23 +312,76 @@ class CocipGrid(models.Model):
         ``time_end``, new slices are selected from the larger ``self.met`` and
         ``self.rad`` data. The slicing only occurs in the time domain.
 
+        The end of currently-used ``met`` and ``rad`` will be used as the start
+        of newly-selected met slices when possible to avoid losing and re-loading
+        already-loaded met data.
+
         If ``self.params["downselect_met"]`` is True, :func:`_downselect_met` has
         already performed a spatial downselection of the met data.
         """
-        if met is None or time_end > met.indexes["time"].to_numpy()[-1]:
+
+        if met is None:
             # idx is the first index at which self.met.variables["time"].to_numpy() >= time_end
             idx = np.searchsorted(self.met.indexes["time"].to_numpy(), time_end)
             sl = slice(max(0, idx - 1), idx + 1)
             logger.debug("Select met slice %s", sl)
             met = MetDataset(self.met.data.isel(time=sl), copy=False)
 
-        if rad is None or time_end > rad.indexes["time"].to_numpy()[-1]:
+        elif time_end > met.indexes["time"].to_numpy()[-1]:
+            current_times = met.indexes["time"].to_numpy()
+            all_times = self.met.indexes["time"].to_numpy()
+            # idx is the first index at which all_times >= time_end
+            idx = np.searchsorted(all_times, time_end)
+            sl = slice(max(0, idx - 1), idx + 1)
+
+            # case 1: cannot re-use end of current met as start of new met
+            if current_times[-1] != all_times[sl.start]:
+                logger.debug("Select met slice %s", sl)
+                met = MetDataset(self.met.data.isel(time=sl), copy=False)
+            # case 2: can re-use end of current met plus one step of new met
+            elif sl.start < all_times.size - 1:
+                sl = slice(sl.start + 1, sl.stop)
+                logger.debug("Reuse end of met and select met slice %s", sl)
+                met = MetDataset(
+                    xr.concat((met.data.isel(time=[-1]), self.met.data.isel(time=sl)), dim="time"),
+                    copy=False,
+                )
+            # case 3: can re-use end of current met and nothing else
+            else:
+                logger.debug("Reuse end of met")
+                met = MetDataset(met.data.isel(time=[-1]), copy=False)
+
+        if rad is None:
             # idx is the first index at which self.rad.variables["time"].to_numpy() >= time_end
             idx = np.searchsorted(self.rad.indexes["time"].to_numpy(), time_end)
             sl = slice(max(0, idx - 1), idx + 1)
             logger.debug("Select rad slice %s", sl)
             rad = MetDataset(self.rad.data.isel(time=sl), copy=False)
 
+        elif time_end > rad.indexes["time"].to_numpy()[-1]:
+            current_times = rad.indexes["time"].to_numpy()
+            all_times = self.rad.indexes["time"].to_numpy()
+            # idx is the first index at which all_times >= time_end
+            idx = np.searchsorted(all_times, time_end)
+            sl = slice(max(0, idx - 1), idx + 1)
+
+            # case 1: cannot re-use end of current rad as start of new rad
+            if current_times[-1] != all_times[sl.start]:
+                logger.debug("Select rad slice %s", sl)
+                rad = MetDataset(self.rad.data.isel(time=sl), copy=False)
+            # case 2: can re-use end of current rad plus one step of new rad
+            elif sl.start < all_times.size - 1:
+                sl = slice(sl.start + 1, sl.stop)
+                logger.debug("Reuse end of rad and select rad slice %s", sl)
+                rad = MetDataset(
+                    xr.concat((rad.data.isel(time=[-1]), self.rad.data.isel(time=sl)), dim="time"),
+                    copy=False,
+                )
+            # case 3: can re-use end of current rad and nothing else
+            else:
+                logger.debug("Reuse end of rad")
+                rad = MetDataset(rad.data.isel(time=[-1]), copy=False)
+
         return met, rad
 
     def _attach_verbose_outputs_evolution(self, contrail_list: list[GeoVectorDataset]) -> None:
@@ -398,6 +459,17 @@ class CocipGrid(models.Model):
                 nominal_segment_length=segment_length,
                 attrs=attrs,
             )
+
+            if self.params["compute_atr20"]:
+                self.source["global_yearly_mean_rf_per_m"] = (
+                    self.source["ef_per_m"].data
+                    / constants.surface_area_earth
+                    / constants.seconds_per_year
+                )
+                self.source["atr20_per_m"] = (
+                    self.params["global_rf_to_atr20_factor"]
+                    * self.source["global_yearly_mean_rf_per_m"].data
+                )
         else:
             self.source = result_merge_source(
                 result=summary,
@@ -406,6 +478,18 @@ class CocipGrid(models.Model):
                 nominal_segment_length=segment_length,
                 attrs=attrs,
             )
+
+            if self.params["compute_atr20"]:
+                self.source["global_yearly_mean_rf_per_m"] = (
+                    self.source["ef_per_m"]
+                    / constants.surface_area_earth
+                    / constants.seconds_per_year
+                )
+                self.source["atr20_per_m"] = (
+                    self.params["global_rf_to_atr20_factor"]
+                    * self.source["global_yearly_mean_rf_per_m"]
+                )
+
         return self.source
 
     # ---------------------------
@@ -1459,11 +1543,11 @@ def find_initial_persistent_contrails(
         air_pressure_1=air_pressure_1,
     )
     iwc_1 = contrail_properties.iwc_post_wake_vortex(iwc, iwc_ad)
+    f_surv = contrail_properties.ice_particle_survival_fraction(iwc, iwc_1)
     n_ice_per_m = 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_crit_sac,
         min_ice_particle_number_nvpm_ei_n=params["min_ice_particle_number_nvpm_ei_n"],
@@ -2241,6 +2325,14 @@ def _contrail_grid_variable_attrs() -> dict[str, dict[str, str]]:
             "long_name": "Ice water content after the wake vortex phase",
             "units": "kg_h2o / kg_air",
         },
+        "global_yearly_mean_rf_per_m": {
+            "long_name": "Global yearly mean RF per meter of flight trajectory",
+            "units": "W / m**2 / m",
+        },
+        "atr20_per_m": {
+            "long_name": "Average Temperature Response over a 20 year horizon",
+            "units": "K / m",
+        },
     }
 
 
@@ -2249,7 +2341,12 @@ def _supported_verbose_outputs_formation() -> set[str]:
 
     Uses output of :func:`_contrail_grid_variable_attrs` as a source of truth.
     """
-    return set(_contrail_grid_variable_attrs()) - {"contrail_age", "ef_per_m"}
+    return set(_contrail_grid_variable_attrs()) - {
+        "contrail_age",
+        "ef_per_m",
+        "global_yearly_mean_rf_per_m",
+        "atr20_per_m",
+    }
 
 
 def _warn_not_wrap(met: MetDataset) -> None:

pycontrails/models/issr.py

@@ -59,7 +59,7 @@ class ISSR(Model):
     >>> out1 = model.eval()
     >>> issr1 = out1["issr"]
     >>> issr1.proportion  # Get proportion of values with ice supersaturation
-    0.114140
+    0.11414134603859523
 
     >>> # Run with a lower threshold
     >>> out2 = model.eval(rhi_threshold=0.95)

{pycontrails-0.50.0.dist-info → pycontrails-0.50.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycontrails
-Version: 0.50.0
+Version: 0.50.1
 Summary: Python library for modeling aviation climate impacts
 Author-email: Breakthrough Energy <py@contrails.org>
 License: Apache-2.0

{pycontrails-0.50.0.dist-info → pycontrails-0.50.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pycontrails/__init__.py,sha256=8WUs6hZAAIH1yKfwYJ8UEqNsk5voRyLmmD3Dje9DZaE,2055
-pycontrails/_version.py,sha256=b7AfuH4OcP5xNu-o3fLCv9MgMbM00aNaiiWCwRH5eV8,429
+pycontrails/_version.py,sha256=iOkMTC9BGn2KBWKt1YcKpLAm1DBaIq115ye0ZvuYj54,429
 pycontrails/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pycontrails/core/__init__.py,sha256=eNypVTz1kHBSKAJX3CgfKw-VKrMRRkKTutmjSlrfeUs,870
 pycontrails/core/aircraft_performance.py,sha256=ikeJmdvFRDa1RdfR-JKfhQbiiIzL0c2vzcBmobmoxMs,22511
@@ -8,18 +8,18 @@ pycontrails/core/cache.py,sha256=NNrFNUvmDEkeS0d1VpDNWmF225a8u2d-TGcpRgQd9Qs,288
 pycontrails/core/coordinates.py,sha256=cb8RprpoSgRTFbAXTPNfuUHVnOxyV3zZ0Ac88P5YbBw,5465
 pycontrails/core/datalib.py,sha256=u2dNc8HxkeJd1jMPTZsOTEagTI0wQkzF1ComctmxJO8,23993
 pycontrails/core/fleet.py,sha256=WKF_s_gRXHmB9b1OW7RUkM1TzfvVD8Ab0Md-qKRwkzs,16544
-pycontrails/core/flight.py,sha256=ehxpo-Ofr4unQpeSR1ZXmbFGClyW628cA000oJZ_Jp8,77974
+pycontrails/core/flight.py,sha256=u3if3cTTWtSIi2eVaq3OyhMbthcTNrVbWVypegAp3sg,78382
 pycontrails/core/flightplan.py,sha256=cpMZ6VCYbfwh3vnew2XgVEHnqBx1NzeAhrTVCvlbbss,7569
 pycontrails/core/fuel.py,sha256=06YUDhvC8Rx6KbUXRB9qLTsJX2V7tLbzjwAfDH0R6l8,4472
-pycontrails/core/interpolation.py,sha256=pDSQx8b3UjwWzKRKn_yKd3h2XsUA_ARRnZjIaH6sf60,24719
-pycontrails/core/met.py,sha256=0Nn03FZ43l10um5RlDQ3_gH1sHq_H59q-PpTb7xARPY,95114
+pycontrails/core/interpolation.py,sha256=Sp9s17i1QQx3jZwnwvt3vo6enWwlkYwTVKCE27N2Wdk,26214
+pycontrails/core/met.py,sha256=J7m0fJNJrFfcXP4d0ctf_ZK4eDa2kT9kWFHfwnEECo8,94924
 pycontrails/core/met_var.py,sha256=JzB7UhBLQyU4TuKZqemhpBHA6Dbt89BPYO2sYBLMkL4,9504
 pycontrails/core/models.py,sha256=VS-ct4xkojJIuqdPpT1ke1ZetNzv10nNx_Z_XalZyeo,40175
 pycontrails/core/polygon.py,sha256=ukcYh4TzGxz-ggipYe1m6DR50aEBgQhxWkEtjoTqC3w,18227
-pycontrails/core/rgi_cython.cp311-win_amd64.pyd,sha256=mAAHBlOJSW9K4PjGODsrnYbw-fFPwMQCzXIEyjpRQo4,258560
-pycontrails/core/vector.py,sha256=xYZDm9VjGlZGWVGqG6u5k0fwT8Ir9U5wThreB1wKOXQ,73854
+pycontrails/core/rgi_cython.cp311-win_amd64.pyd,sha256=-0fMQ4TpMhIrFkMWhQVJtiT4ILu0n8Rk8tUUKfD3aPE,258560
+pycontrails/core/vector.py,sha256=MF0oWX0Ghp_G41A712VbU1GEKRNU_Pj9PtzMREPG5Z8,73916
 pycontrails/datalib/__init__.py,sha256=WnXqgv20SrHZLjFZ9qpQEwRnf0QvfZU-YvMqh7PAUwg,246
-pycontrails/datalib/goes.py,sha256=Ky7elxQJyKsk6dlJ22wsOtpaZn34LaEQCqqdX3M4a5s,26932
+pycontrails/datalib/goes.py,sha256=NVk6QFfHbGpOINlKlG6PR1Hn_LCmzP7k20VJQZXpVG8,27124
 pycontrails/datalib/ecmwf/__init__.py,sha256=MZBpXU2ZD4GOJX9Pr43_N-8TLF-KtV6aZQ5hADmGFCE,1262
 pycontrails/datalib/ecmwf/arco_era5.py,sha256=aWI69KhTfR42mZYssXCrB43lJelcV85GC8FPZDPxMak,20835
 pycontrails/datalib/ecmwf/common.py,sha256=XWPlWPQskuTMHBxWeKvRSuYWHRcKeiJAxfl5lScyTPc,3806
@@ -39,23 +39,24 @@ pycontrails/ext/synthetic_flight.py,sha256=CxKDAX8Jao9VXuy_eRksS8zqIaMYgiv9az5DW
 pycontrails/models/__init__.py,sha256=TKhrXe1Pu1-mV1gctx8cUAMrVxCCAtBkbZi9olfWq8s,34
 pycontrails/models/accf.py,sha256=72-2oRCSM98cwHxmKmO5ECaRPbiRE010jX5nTQDfHCs,12965
 pycontrails/models/dry_advection.py,sha256=z4XbEa0ihmcKyCrdaYbWEOYQ4yt9KfmpJ7jYhZ6g5lU,16622
-pycontrails/models/issr.py,sha256=uDMEFjQH_wh3jcQexMgFFq3-XrM7DEz4kZcgLSGqAM4,7550
+pycontrails/models/issr.py,sha256=mqRKm106kz8um1cbRblxLRZDJanvqa5Q1BI2sqK5pkQ,7561
 pycontrails/models/pcc.py,sha256=M5KhtRgdCP9pfDFgui7ibbijtRBTjx3QOJL_m1tQYfs,11443
 pycontrails/models/pcr.py,sha256=G_0yR5PsCMeJBP6tZFi3M7A6Wcq8s71UvosdA7ozUkI,5502
 pycontrails/models/sac.py,sha256=Cj4Hi3324wjqLQ7I2CPVkrIh2Fq5W5pKpGrwhYADoHI,16420
 pycontrails/models/tau_cirrus.py,sha256=eXt3yRrcFBaZNNeH6ZOuU4XEZU2rOfrLKEOC7f0_Ywo,5194
 pycontrails/models/cocip/__init__.py,sha256=X_MlkJzQ-henQ0xGq-1bfCMajH6s9tlK5QLnN7yfQ68,929
-pycontrails/models/cocip/cocip.py,sha256=0nDEdSEjvWE4Klx_x2cIutjlwOmLrgWQ2bhDE65xoTE,99388
-pycontrails/models/cocip/cocip_params.py,sha256=L-DAw34JgD39UV6xjRIQt2CjpIRQRqzwNxU37WjNKrw,11107
+pycontrails/models/cocip/cocip.py,sha256=s9j5UhPCaaxiJZDXUvQ2KnEgvQz2pMrRHlWKZijwRIw,100140
+pycontrails/models/cocip/cocip_params.py,sha256=T4IseK6KtY4hG3BuGZBtFgM90HCYecUXsb_QVEK6uGo,11670
 pycontrails/models/cocip/cocip_uncertainty.py,sha256=lksROIRLt-jxEdjJTiLP9Da-FYt1GjZKaIxwDaH2Ytg,12069
-pycontrails/models/cocip/contrail_properties.py,sha256=dRq5o-YuC-s487Fs54OHpAuS8LkxM-HATNVclHKUhL0,57362
+pycontrails/models/cocip/contrail_properties.py,sha256=u6SvucHC6VtF2kujfSVFTfv0263t5uYpNOUJZAroEzc,57111
 pycontrails/models/cocip/output_formats.py,sha256=sYGYosAL6BQvntKXdeomAph-K6EKOgsI2VQynLEHxnM,79228
 pycontrails/models/cocip/radiative_forcing.py,sha256=SYmQ8lL8gpWbf6he2C9mKSjODtytbFcdnMdBM-LtBKE,46206
 pycontrails/models/cocip/radiative_heating.py,sha256=N7FTR20luERmokprdqMOl-d8-cTYZZ2ZSsTdxZnLHfs,19368
-pycontrails/models/cocip/wake_vortex.py,sha256=d3oLkTWIocwYb99fl6t99LtEsbKkdsupAfoUY-GmbTI,13783
+pycontrails/models/cocip/unterstrasser_wake_vortex.py,sha256=Ymz-uO9vVhLIFwT9yuF5g1g3hcT-XWdryLsebSBqoVU,14976
+pycontrails/models/cocip/wake_vortex.py,sha256=r3FM4egyGohRF0qGD3pFWBJppUQ_3GhtO_g7L74HmjU,14817
 pycontrails/models/cocip/wind_shear.py,sha256=Dm181EsiCBJWTnRTZ3ZI3YXscBRnhA6ANnKer004b2Q,3980
 pycontrails/models/cocipgrid/__init__.py,sha256=OYSdZ1Htbr_IP7N_HuOAj1Pa_KLHtdEeJfXP-cN-gnU,271
-pycontrails/models/cocipgrid/cocip_grid.py,sha256=mcz8_G4YyiyqkuAAZiwWZk-NOtcxKJY57pVkhSunHSQ,92278
+pycontrails/models/cocipgrid/cocip_grid.py,sha256=0KWf3Wm8GZOOIy-D86Y8bC-2MIjKbVkhevXMG-eF85s,96680
 pycontrails/models/cocipgrid/cocip_grid_params.py,sha256=ZpN00VEmeRYaeZhvSfVjnEjrgn6XdClf1eqJC8Ytcuw,6013
 pycontrails/models/emissions/__init__.py,sha256=BXzV2pBps8j3xbaF1n9uPdVVLI5MBIGYx8xqDJezYIE,499
 pycontrails/models/emissions/black_carbon.py,sha256=9DRqB487pH8Iq83FXggA5mPLYEAA8NpsKx24f8uTEF4,20828
@@ -85,9 +86,9 @@ pycontrails/utils/iteration.py,sha256=En2YY4NiNwCNtAVO8HL6tv9byBGKs8MKSI7R8P-gZy
 pycontrails/utils/json.py,sha256=xCv71CKVZNHk4MyoYC-hl7dXObXXbI7P8gcNCn3AUoU,6172
 pycontrails/utils/temp.py,sha256=5XXqQoEfWjz1OrhoOBZD5vkkCFeuq9LpZkyhc38gIeY,1159
 pycontrails/utils/types.py,sha256=f8FNSSzW-1ISgJ0zDtCwZgpuzpt26sUABiHHusS414s,4725
-pycontrails-0.50.0.dist-info/LICENSE,sha256=HVr8JnZfTaA-12BfKUQZi5hdrB3awOwLWs5X_ga5QzA,10353
-pycontrails-0.50.0.dist-info/METADATA,sha256=AEbrq0M0Zhb8ttYIrKZnhxUdo_3OYubbVuzmFHAGEf0,8528
-pycontrails-0.50.0.dist-info/NOTICE,sha256=qYeNEp8OjDK5jSW3hTlr9LQRjZeEhXQm0zDei5UFaYs,1969
-pycontrails-0.50.0.dist-info/WHEEL,sha256=nSybvzWlmdJnHiUQSY-d7V1ycwEVUTqXiTvr2eshg44,102
-pycontrails-0.50.0.dist-info/top_level.txt,sha256=Z8J1R_AiBAyCVjNw6jYLdrA68PrQqTg0t3_Yek_IZ0Q,29
-pycontrails-0.50.0.dist-info/RECORD,,
+pycontrails-0.50.1.dist-info/LICENSE,sha256=HVr8JnZfTaA-12BfKUQZi5hdrB3awOwLWs5X_ga5QzA,10353
+pycontrails-0.50.1.dist-info/METADATA,sha256=N03Ih7BucWyRsdXMP6kHazTHfGYPfkm2e6FAs_5NnHM,8528
+pycontrails-0.50.1.dist-info/NOTICE,sha256=qYeNEp8OjDK5jSW3hTlr9LQRjZeEhXQm0zDei5UFaYs,1969
+pycontrails-0.50.1.dist-info/WHEEL,sha256=nSybvzWlmdJnHiUQSY-d7V1ycwEVUTqXiTvr2eshg44,102
+pycontrails-0.50.1.dist-info/top_level.txt,sha256=Z8J1R_AiBAyCVjNw6jYLdrA68PrQqTg0t3_Yek_IZ0Q,29
+pycontrails-0.50.1.dist-info/RECORD,,