pycontrails 0.49.5__cp311-cp311-macosx_11_0_arm64.whl → 0.50.1__cp311-cp311-macosx_11_0_arm64.whl

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: