pycontrails 0.59.0__cp314-cp314-macosx_10_15_x86_64.whl

pycontrails/models/issr.py

@@ -0,0 +1,210 @@
+"""Ice super-saturated regions (ISSR)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, overload
+
+import numpy as np
+
+import pycontrails
+from pycontrails.core.flight import Flight
+from pycontrails.core.met import MetDataset
+from pycontrails.core.met_var import AirTemperature, MetVariable, SpecificHumidity
+from pycontrails.core.models import Model, ModelParams
+from pycontrails.core.vector import GeoVectorDataset
+from pycontrails.models.humidity_scaling import HumidityScaling
+from pycontrails.physics import constants, thermo
+from pycontrails.utils.types import ArrayLike, apply_nan_mask_to_arraylike
+
+
+@dataclass
+class ISSRParams(ModelParams):
+    """Default ISSR model parameters."""
+
+    #: RHI Threshold
+    rhi_threshold: float = 1.0
+
+    #: Humidity scaling
+    humidity_scaling: HumidityScaling | None = None
+
+
+class ISSR(Model):
+    """Ice super-saturated regions over a :class:`Flight` trajectory or :class:`MetDataset` grid.
+
+    This model calculates points where the relative humidity over ice is greater than 1.
+
+    Parameters
+    ----------
+    met : MetDataset
+        Dataset containing "air_temperature" and "specific_humidity" variables
+
+    Examples
+    --------
+    >>> from datetime import datetime
+    >>> from pycontrails.datalib.ecmwf import ERA5
+    >>> from pycontrails.models.issr import ISSR
+    >>> from pycontrails.models.humidity_scaling import ConstantHumidityScaling
+
+    >>> # Get met data
+    >>> time = datetime(2022, 3, 1, 0), datetime(2022, 3, 1, 2)
+    >>> variables = ["air_temperature", "specific_humidity"]
+    >>> pressure_levels = [200, 250, 300]
+    >>> era5 = ERA5(time, variables, pressure_levels)
+    >>> met = era5.open_metdataset()
+
+    >>> # Instantiate and run model
+    >>> scaling = ConstantHumidityScaling(rhi_adj=0.98)
+    >>> model = ISSR(met, humidity_scaling=scaling)
+    >>> out1 = model.eval()
+    >>> issr1 = out1["issr"]
+    >>> issr1.proportion  # Get proportion of values with ice supersaturation
+    0.114...
+
+    >>> # Run with a lower threshold
+    >>> out2 = model.eval(rhi_threshold=0.95)
+    >>> issr2 = out2["issr"]
+    >>> issr2.proportion
+    0.146...
+    """
+
+    name = "issr"
+    long_name = "Ice super-saturated regions"
+    met_variables: tuple[MetVariable, ...] = AirTemperature, SpecificHumidity
+    default_params = ISSRParams
+
+    @overload
+    def eval(self, source: Flight, **params: Any) -> Flight: ...
+
+    @overload
+    def eval(self, source: GeoVectorDataset, **params: Any) -> GeoVectorDataset: ...
+
+    @overload
+    def eval(self, source: MetDataset | None = ..., **params: Any) -> MetDataset: ...
+
+    def eval(
+        self, source: GeoVectorDataset | Flight | MetDataset | None = None, **params: Any
+    ) -> GeoVectorDataset | Flight | MetDataset:
+        """Evaluate ice super-saturated regions along flight trajectory or on meteorology grid.
+
+        .. versionchanged:: 0.27.0
+
+            Humidity scaling now handled automatically. This is controlled by
+            model parameter ``humidity_scaling``.
+
+        .. versionchanged:: 0.48.0
+
+            If the ``source`` is a :class:`MetDataset`, the returned object will
+            also be a :class:`MetDataset`. Previous the "issr" :class:`MetDataArray`
+            was returned.
+
+        Parameters
+        ----------
+        source : GeoVectorDataset | Flight | MetDataset | None, optional
+            Input GeoVectorDataset or Flight.
+            If None, evaluates at the :attr:`met` grid points.
+        **params : Any
+            Overwrite model parameters before eval
+
+        Returns
+        -------
+        GeoVectorDataset | Flight | MetDataset
+            Returns 1 in ISSR, 0 everywhere else.
+            Returns `np.nan` if interpolating outside meteorology grid.
+
+        Raises
+        ------
+        NotImplementedError
+            Raises if input ``source`` is not supported.
+        """
+
+        self.update_params(params)
+        self.set_source(source)
+
+        if isinstance(self.source, GeoVectorDataset):
+            self.downselect_met()
+            self.source.setdefault("air_pressure", self.source.air_pressure)
+
+        humidity_scaling = self.params["humidity_scaling"]
+        scale_humidity = humidity_scaling is not None and "specific_humidity" not in self.source
+
+        self.set_source_met()
+
+        # apply humidity scaling, warn if no scaling is provided for ECMWF data
+        if scale_humidity:
+            humidity_scaling.eval(self.source, copy_source=False)
+
+        self.source["issr"] = issr(  # type: ignore[type-var]
+            air_temperature=self.source.data["air_temperature"],
+            specific_humidity=self.source.data["specific_humidity"],
+            air_pressure=self.source.data["air_pressure"],
+            rhi=self.source.data.get("rhi", None),  # if rhi already known, pass it in
+            rhi_threshold=self.params["rhi_threshold"],
+        )
+
+        # Tag output with additional metadata attrs
+        self.transfer_met_source_attrs()
+        self.source.attrs["pycontrails_version"] = pycontrails.__version__
+        if scale_humidity:
+            for k, v in humidity_scaling.description.items():
+                self.source.attrs[f"humidity_scaling_{k}"] = v
+
+        return self.source
+
+
+def issr(
+    air_temperature: ArrayLike,
+    specific_humidity: ArrayLike | None = None,
+    air_pressure: ArrayLike | None = None,
+    rhi: ArrayLike | None = None,
+    rhi_threshold: float = 1.0,
+) -> ArrayLike:
+    r"""Calculate ice super-saturated regions.
+
+    Regions where the atmospheric relative humidity over ice is greater than 1.
+
+    Parameters ``air_temperature``, ``specific_humidity``, ``air_pressure``,
+    and ``rhi`` must have compatible shapes when defined.
+
+    Either ``specific_humidity`` and ``air_pressure`` must both be provided, or
+    ``rhi`` must be provided.
+
+    Parameters
+    ----------
+    air_temperature : ArrayLike
+        A sequence or array of temperature values, :math:`[K]`.
+    specific_humidity : ArrayLike | None
+        A sequence or array of specific humidity values, [:math:`kg_{H_{2}O} \ kg_{moist air}`]
+        None by default.
+    air_pressure : ArrayLike | None
+        A sequence or array of atmospheric pressure values, [:math:`Pa`]. None by default.
+    rhi : ArrayLike | None, optional
+        A sequence of array of RHi values, if already known. If not provided, this function
+        will compute RHi from `air_temperature`, `specific_humidity`, and `air_pressure`.
+        None by default.
+    rhi_threshold : float, optional
+        Relative humidity over ice threshold for determining ISSR state
+
+    Returns
+    -------
+    ArrayLike
+        ISSR state of each point indexed by the parameters.
+    """
+    if rhi is None:
+        if specific_humidity is None or air_pressure is None:
+            raise TypeError(
+                "If 'rhi' is not specified, both 'specific_humidity' "
+                "and 'air_pressure' must be provided."
+            )
+        rhi = thermo.rhi(specific_humidity, air_temperature, air_pressure)
+
+    # store nan values to refill after casting
+    nan_mask = np.isnan(rhi)
+
+    # compute issr as int
+    sufficiently_cold = air_temperature < -constants.absolute_zero
+    sufficiently_humid = rhi > rhi_threshold
+
+    issr_ = (sufficiently_cold & sufficiently_humid).astype(rhi.dtype)
+
+    return apply_nan_mask_to_arraylike(issr_, nan_mask)

pycontrails/models/pcc.py

@@ -0,0 +1,326 @@
+"""Probability of persistent contrail coverage (PCC)."""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any
+
+import numpy as np
+import xarray as xr
+
+from pycontrails.core.fuel import Fuel, JetA
+from pycontrails.core.met import MetDataArray, MetDataset
+from pycontrails.core.met_var import AirTemperature, SpecificHumidity
+from pycontrails.core.models import Model, ModelParams
+from pycontrails.datalib.ecmwf.variables import SpecificCloudIceWaterContent
+from pycontrails.models import sac
+from pycontrails.models.humidity_scaling import HumidityScaling
+from pycontrails.physics import thermo
+
+
+@dataclasses.dataclass
+class PCCParams(ModelParams):
+    """PCC Model Parameters."""
+
+    #: Cloud model
+    #: Options include "Smith1990", "Sundqvist1989", "Slingo1980"
+    cloud_model: str = "Smith1990"
+
+    #: Critical RH Factor for the model to cirrus clouds
+    rh_crit_factor: float = 0.7
+
+    #: Fuel type
+    fuel: Fuel = dataclasses.field(default_factory=JetA)
+
+    #: Engine efficiency
+    engine_efficiency: float = 0.35
+
+    #: Humidity scaling
+    humidity_scaling: HumidityScaling | None = None
+
+
+class PCC(Model):
+    r"""Potential Contrail Coverage Algorithm.
+
+    Determines the potential of ambient atmosphere to allow contrail formation at grid points.
+
+    Parameters
+    ----------
+    met : MetDataset
+        Dataset containing  :attr:`met_variables` variables.
+    surface : MetDataset
+        Surface level dataset containing "air_pressure".
+    params : dict[str, Any], optional
+        Override PCC model parameters with dictionary.
+        See :class:`PCCParams` for model parameters.
+    **params_kwargs
+        Override PCC model parameters with keyword arguments.
+        See :class:`PCCParams` for model parameters.
+
+    Notes
+    -----
+    Based on Ponater et al. (2002)
+    """
+
+    __slots__ = ("_cloud_model", "surface")
+    name = "pcc"
+    long_name = "Potential contrail coverage"
+    met_variables = (AirTemperature, SpecificHumidity, SpecificCloudIceWaterContent)
+    _cloud_model: Any
+    source: MetDataset
+    surface: MetDataset
+    default_params = PCCParams
+
+    def __init__(
+        self,
+        met: MetDataset,
+        surface: MetDataset,
+        params: dict[str, Any] | None = None,
+        **params_kwargs: Any,
+    ) -> None:
+        super().__init__(met, params=params, **params_kwargs)
+
+        # set cloud model by method
+        self._cloud_model = getattr(self, self.params["cloud_model"], None)
+        if self._cloud_model is None:
+            raise ValueError(
+                "Cloud model must be one of 'Smith1990', 'Sundqvist1989', 'Slingo1980'"
+            )
+
+        # make sure surface level dataset is valid
+        if not isinstance(surface, MetDataset):
+            raise TypeError("Surface air pressure required as input parameter 'surface'")
+
+        self.surface = surface.copy()
+        self.surface.ensure_vars(["surface_air_pressure"])
+
+    def eval(self, source: MetDataset | None = None, **params: Any) -> MetDataArray:
+        """Evaluate PCC model.
+
+        Currently only implemented to work on the :attr:`met` data input.
+
+        Parameters
+        ----------
+        source : MetDataset | None, optional
+           Input MetDataset.
+            If None, evaluates at the :attr:`met` grid points.
+        **params : Any
+            Overwrite model parameters before eval
+
+
+        Returns
+        -------
+        MetDataArray
+            PCC model output
+        """
+        self.update_params(params)
+        self.set_source(source)
+
+        # apply humidity scaling
+        scale_humidity = (self.params["humidity_scaling"] is not None) and (
+            "specific_humidity" not in self.source
+        )
+        self.set_source_met()
+
+        if scale_humidity:
+            self.params["humidity_scaling"].eval(self.source, copy_source=False)
+
+        return MetDataArray(self.b_contr(), name="pcc")
+
+    def b_contr(self) -> xr.DataArray:
+        """Calculate critical relative humidity threshold of contrail formation.
+
+        Returns
+        -------
+        xr.DataArray
+            Critical relative humidity of contrail formation, [:math:`[0 - 1]`]
+
+        Notes
+        -----
+        Instead of using a prescribed threshold relative humidity for ``rh_crit_old``
+        the threshold relative humidity now change with pressure.
+
+        This equation is described in Roeckner et al. 1996, Eq.57
+        THE ATMOSPHERIC GENERAL CIRCULATION MODEL ECHAM-4: MODEL DESCRIPTION AND
+        SIMULATION OF PRESENT-DAY CLIMATE
+        """
+        sp = self.surface["surface_air_pressure"].data.loc[dict(level=-1)]  # surface air pressure
+
+        def _apply_b_contr_plev(_ds: xr.Dataset) -> xr.Dataset:
+            p = _ds["air_pressure"]
+
+            G = sac.slope_mixing_line(
+                _ds["specific_humidity"],
+                _ds["air_pressure"],
+                self.params["engine_efficiency"],
+                self.params["fuel"].ei_h2o,
+                self.params["fuel"].q_fuel,
+            )
+            T_sat_liquid = sac.T_sat_liquid(G)
+            rh_crit_sac = sac.rh_critical_sac(_ds["air_temperature"], T_sat_liquid, G)
+
+            # rh_crit_old = np.ones(p.shape) * self.rh_crit_factor
+            rh_crit_old = 0.99 + (0.6 - 0.99) * np.exp(1 - (sp / p) ** 4)
+            rh_crit_new = rh_crit_sac * rh_crit_old
+
+            b_crit = self._cloud_model(
+                _ds["air_temperature"],
+                _ds["air_pressure"],
+                _ds["specific_cloud_ice_water_content"],
+                _ds["specific_humidity"],
+                rh_crit_old,
+                rh_crit_old,
+            )
+            b_crit_contr = self._cloud_model(
+                _ds["air_temperature"],
+                _ds["air_pressure"],
+                _ds["specific_cloud_ice_water_content"],
+                _ds["specific_humidity"],
+                rh_crit_old,
+                rh_crit_new,
+            )
+            b_crit_potential = b_crit_contr - b_crit
+
+            b_crit_potential = xr.where((b_crit_potential > 1), 1, b_crit_potential)
+            b_crit_potential = xr.where((b_crit_potential < 0), 0, b_crit_potential)
+
+            # issue recombining groups arises if "level" is in dims
+            # convert "level" dimension to coordinate
+            return b_crit_potential.squeeze("level")
+
+        # apply calculation per pressure level
+        return (
+            self.source.data.groupby("level", squeeze=False)  # type: ignore
+            .map(_apply_b_contr_plev)
+            .transpose(*self.source.dim_order)
+        )
+
+    def Smith1990(
+        self,
+        T: xr.DataArray,
+        p: xr.DataArray,
+        iwc: xr.DataArray,
+        q: xr.DataArray,
+        rh_crit_old: xr.DataArray,
+        rh_crit_new: xr.DataArray,
+    ) -> xr.DataArray:
+        r"""Apply Smith Scheme described in Rap et al. (2009).
+
+        Parameterization of contrails in the UK Met OfficeClimate Model;
+
+        Parameters
+        ----------
+        T : :class:`xarray:DataArray`
+            Air Temperature, [:math:`K`]
+        p : :class:`xarray:DataArray`
+            Air Pressure, [:math:`Pa`]
+        iwc : :class:`xarray:DataArray`
+            Cloud ice water content, [:math:`kg \ kg^{-1}`]
+        q : :class:`xarray:DataArray`
+            Specific humidity
+        rh_crit_old : :class:`xarray:DataArray`
+            Critical relative humidity, [:math:`[0 - 1]`]
+        rh_crit_new : :class:`xarray:DataArray`
+            Critical relative humidity, [:math:`[0 - 1]`]
+
+        Returns
+        -------
+        :class:`xarray:DataArray`
+            Probability of cirrus formation, [:math:`[0 - 1]`]
+        """
+        r = thermo.rh(q, T, p)
+        q_sw = thermo.q_sat(T, p)
+        b_crit = (1 - rh_crit_old) * q_sw
+        Q_n = iwc / b_crit - (1 - r) / (1 - rh_crit_new)
+
+        b_cirrus = xr.DataArray(np.zeros(Q_n.shape), coords=Q_n.coords)
+        b_cirrus = xr.where((Q_n <= -1), 0, b_cirrus)
+        b_cirrus = xr.where(
+            (Q_n > -1) & (Q_n <= 0), 0.5 * (1 + Q_n.where((Q_n > -1) & (Q_n <= 0))) ** 2, b_cirrus
+        )
+        b_cirrus = xr.where(
+            (Q_n > 0) & (Q_n <= 1), 1 - 0.5 * (1 - Q_n.where((Q_n > 0) & (Q_n <= 1))) ** 2, b_cirrus
+        )
+        return xr.where((Q_n > 1), 1, b_cirrus)
+
+    def Slingo1980(
+        self,
+        T: xr.DataArray,
+        p: xr.DataArray,
+        iwc: xr.DataArray,
+        q: xr.DataArray,
+        rh_crit_old: xr.DataArray,
+        rh_crit_new: xr.DataArray,
+    ) -> xr.DataArray:
+        r"""Apply Slingo scheme described in Wood and Field, 1999.
+
+        Relationships between Total Water, Condensed Water, and Cloud Fraction in
+        Stratiform Clouds Examined Using Aircraft Data
+
+        Parameters
+        ----------
+        T : :class:`xarray:DataArray`
+            Air Temperature, [:math:`K`]
+        p : :class:`xarray:DataArray`
+            Air Pressure, [:math:`Pa`]
+        iwc : :class:`xarray:DataArray`
+            Cloud ice water content, [:math:`kg \ kg^{-1}`]
+        q : :class:`xarray:DataArray`
+            Specific humidity
+        rh_crit_old : :class:`xarray:DataArray`
+            Critical relative humidity, [:math:`[0 - 1]`]
+        rh_crit_new : :class:`xarray:DataArray`
+            Critical relative humidity, [:math:`[0 - 1]`]
+
+        Returns
+        -------
+        :class:`xarray:DataArray`
+            Probability of cirrus formation, [:math:`[0 - 1]`]
+        """
+        r = thermo.rh(q, T, p)
+        b_cirrus = ((r - rh_crit_new) / (1 - rh_crit_new)) ** 2
+        b_cirrus = xr.where(r < rh_crit_new, 0, b_cirrus)
+        return xr.where(r >= 1.0, 1.0, b_cirrus)
+
+    def Sundqvist1989(
+        self,
+        T: xr.DataArray,
+        p: xr.DataArray,
+        iwc: xr.DataArray,
+        q: xr.DataArray,
+        rh_crit_old: xr.DataArray,
+        rh_crit_new: xr.DataArray,
+    ) -> xr.DataArray:
+        r"""Apply Sundqvist scheme described in Ponater et al. (2002).
+
+        Contrails in a comprehensive global climate model: Parameterization and radiative
+        forcing results
+
+        Parameters
+        ----------
+        T : :class:`xarray:DataArray`
+            Air Temperature, [:math:`K`]
+        p : :class:`xarray:DataArray`
+            Air Pressure, [:math:`Pa`]
+        iwc : :class:`xarray:DataArray`
+            Cloud ice water content, [:math:`kg \ kg^{-1}`]
+        q : :class:`xarray:DataArray`
+            Specific humidity
+        rh_crit_old : :class:`xarray:DataArray`
+            Critical relative humidity, [:math:`[0 - 1]`]
+        rh_crit_new : :class:`xarray:DataArray`
+            Critical relative humidity, [:math:`[0 - 1]`]
+
+        Returns
+        -------
+        :class:`xarray:DataArray`
+            Probability of cirrus formation, [:math:`[0 - 1]`]
+        """
+        r = thermo.rh(q, T, p)
+
+        # clipping ratio at 1 to prevent np.sqrt from taking negative arguments
+        ratio = (r - rh_crit_new) / (1 - rh_crit_new)
+        ratio = xr.where(ratio > 1, 1, ratio)
+
+        b_cirrus = 1 - (1 - ratio) ** 0.5
+        return xr.where(r < rh_crit_new, 0, b_cirrus)

pycontrails/models/pcr.py

@@ -0,0 +1,154 @@
+"""
+Persistent contrail regions (PCR = SAC & ISSR).
+
+Equivalent to (SAC & ISSR)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, overload
+
+import numpy as np
+
+from pycontrails.core.flight import Flight
+from pycontrails.core.met import MetDataset
+from pycontrails.core.met_var import AirTemperature, SpecificHumidity
+from pycontrails.core.models import Model
+from pycontrails.core.vector import GeoVectorDataset
+from pycontrails.models import issr, sac
+from pycontrails.physics import thermo
+from pycontrails.utils.types import ArrayLike, apply_nan_mask_to_arraylike
+
+
+@dataclass
+class PCRParams(sac.SACParams, issr.ISSRParams):
+    """Persistent Contrail Regions (PCR) parameters."""
+
+
+class PCR(Model):
+    """Determine points with likely persistent contrails (PCR).
+
+    Intersection of Ice Super Saturated Regions (ISSR) with regions in which the Schmidt-Appleman
+    Criteria (SAC) is satisfied.
+
+    Parameters
+    ----------
+    met : MetDataset
+        Dataset containing "air_temperature", "specific_humidity" variables
+    params : dict[str, Any], optional
+        Override PCR model parameters with dictionary.
+        See :class:`PCRGridParams` for model parameters.
+    **params_kwargs
+        Override PCR model parameters with keyword arguments.
+        See :class:`PCRGridParams` for model parameters.
+    """
+
+    name = "pcr"
+    long_name = "Persistent contrail regions"
+    met_variables = AirTemperature, SpecificHumidity
+    default_params = PCRParams
+
+    @overload
+    def eval(self, source: Flight, **params: Any) -> Flight: ...
+
+    @overload
+    def eval(self, source: GeoVectorDataset, **params: Any) -> GeoVectorDataset: ...
+
+    @overload
+    def eval(self, source: MetDataset | None = ..., **params: Any) -> MetDataset: ...
+
+    def eval(
+        self, source: GeoVectorDataset | Flight | MetDataset | None = None, **params: Any
+    ) -> GeoVectorDataset | Flight | MetDataset:
+        """Evaluate potential contrails regions of the :attr:`met` grid.
+
+        Parameters
+        ----------
+        source : GeoVectorDataset | Flight | MetDataset | None, optional
+            Input GeoVectorDataset or Flight.
+            If None, evaluates at the :attr:`met` grid points.
+        **params : Any
+            Overwrite model parameters.
+
+        Returns
+        -------
+        GeoVectorDataset | Flight | MetDataset
+            Returns 1 in potential contrail regions, 0 everywhere else.
+            Returns ``np.nan`` if interpolating outside meteorology grid.
+
+        """
+
+        self.update_params(params)
+        self.set_source(source)
+        issr_params = {k: v for k, v in self.params.items() if hasattr(issr.ISSR.default_params, k)}
+        issr_model = issr.ISSR(self.met, params=issr_params, copy_source=False)
+        issr_model.eval(self.source)
+
+        sac_params = {k: v for k, v in self.params.items() if hasattr(sac.SAC.default_params, k)}
+        # NOTE: met is not needed here: ISSR already used it
+        sac_model = sac.SAC(met=None, params=sac_params, copy_source=False)
+        sac_model.eval(self.source)
+
+        pcr_ = _pcr_from_issr_and_sac(self.source.data["issr"], self.source.data["sac"])  # type: ignore[type-var]
+        self.source["pcr"] = pcr_
+
+        return self.source
+
+
+def pcr(
+    air_temperature: ArrayLike,
+    specific_humidity: ArrayLike,
+    air_pressure: ArrayLike,
+    engine_efficiency: float | ArrayLike,
+    ei_h2o: float,
+    q_fuel: float,
+) -> tuple[ArrayLike, ArrayLike, ArrayLike]:
+    r"""Calculate regions of persistent contrail formation.
+
+    Ice Super Saturated Regions (ISSR) where the Schmidt-Appleman Criteria (SAC) is satisfied.
+
+    Parameters of type :class:`ArrayLike` must have compatible shapes.
+
+    Parameters
+    ----------
+    air_temperature : ArrayLike
+        A sequence or array of temperature values, [:math:`K`]
+    specific_humidity : ArrayLike
+        A sequence or array of specific humidity values, [:math:`kg_{H_{2}O} \ kg_{air}^{-1}`]
+    air_pressure : ArrayLike
+        A sequence or array of atmospheric pressure values, [:math:`Pa`].
+    engine_efficiency: float | ArrayLike
+        Engine efficiency, [:math:`0 - 1`]
+    ei_h2o : float
+        Emission index of water vapor, [:math:`kg \ kg^{-1}`]
+    q_fuel : float
+        Specific combustion heat of fuel combustion, [:math:`J \ kg^{-1} \ K^{-1}`]
+
+    Returns
+    -------
+    pcr : ArrayLike
+        PCR state of each point indexed by the :class:`ArrayLike` parameters.
+    sac : ArrayLike
+        SAC state
+    issr : ArrayLike
+        ISSR state
+    """
+    issr_ = issr.issr(air_temperature, specific_humidity, air_pressure)
+    G = sac.slope_mixing_line(specific_humidity, air_pressure, engine_efficiency, ei_h2o, q_fuel)
+    T_sat_liquid_ = sac.T_sat_liquid(G)
+    rh = thermo.rh(specific_humidity, air_temperature, air_pressure)
+    rh_crit_sac = sac.rh_critical_sac(air_temperature, T_sat_liquid_, G)
+    sac_ = sac.sac(rh, rh_crit_sac)
+
+    pcr_ = _pcr_from_issr_and_sac(issr_, sac_)
+    return pcr_, sac_, issr_
+
+
+def _pcr_from_issr_and_sac(issr_: ArrayLike, sac_: ArrayLike) -> ArrayLike:
+    # store nan values to refill after casting
+    nan_mask = np.isnan(issr_) | np.isnan(sac_)
+
+    dtype = np.result_type(issr_, sac_)
+    pcr_ = ((issr_ > 0.0) & (sac_ > 0.0)).astype(dtype)
+    return apply_nan_mask_to_arraylike(pcr_, nan_mask)