pycontrails 0.53.0__cp313-cp313-macosx_10_13_x86_64.whl

pycontrails/models/cocip/cocip_params.py

@@ -0,0 +1,299 @@
+"""Default parameters for CoCiP models.
+
+Used by :class:`Cocip` and :class:`CocipGrid`.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+import numpy as np
+import numpy.typing as npt
+
+from pycontrails.core.aircraft_performance import AircraftPerformance
+from pycontrails.core.models import ModelParams
+from pycontrails.models.emissions.emissions import EmissionsParams
+from pycontrails.models.humidity_scaling import HumidityScaling
+
+
+def _radius_threshold_um() -> npt.NDArray[np.float32]:
+    return np.array([5.0, 9.5, 23.0, 190.0, 310.0], dtype=np.float32)
+
+
+def _habit_distributions() -> npt.NDArray[np.float32]:
+    return np.array(
+        [
+            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
+            [0.0, 0.3, 0.0, 0.0, 0.0, 0.0, 0.7, 0.0],
+            [0.0, 0.3, 0.0, 0.0, 0.3, 0.0, 0.4, 0.0],
+            [0.0, 0.5, 0.0, 0.0, 0.15, 0.35, 0.0, 0.0],
+            [0.0, 0.45, 0.45, 0.1, 0.0, 0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.03, 0.97, 0.0, 0.0, 0.0],
+        ],
+        dtype=np.float32,
+    )
+
+
+def _habits() -> npt.NDArray[np.str_]:
+    return np.array(
+        [
+            "Sphere",
+            "Solid column",
+            "Hollow column",
+            "Rough aggregate",
+            "Rosette-6",
+            "Plate",
+            "Droxtal",
+            "Myhre",
+        ]
+    )
+
+
+@dataclasses.dataclass
+class CocipParams(ModelParams):
+    """Model parameters required by the CoCiP models."""
+
+    # -------------------------
+    # Implementation parameters
+    # -------------------------
+
+    #: Determines whether :meth:`Cocip.process_emissions` runs on model :meth:`Cocip.eval`
+    #: Set to ``False`` when input Flight includes emissions data.
+    process_emissions: bool = True
+
+    #: Apply Euler's method with a fixed step size of ``dt_integration``. Advected waypoints
+    #: are interpolated against met data once each ``dt_integration``.
+    dt_integration: np.timedelta64 = np.timedelta64(30, "m")
+
+    #: Difference in altitude between top and bottom layer for stratification calculations,
+    #: [:math:`m`]. Used to approximate derivative of "lagrangian_tendency_of_air_pressure" layer.
+    dz_m: float = 200.0
+
+    #: Vertical resolution (m) associated to met data.
+    #: Constant below applies to ECMWF data.
+    effective_vertical_resolution: float = 2000.0
+
+    #: Smoothing parameters for true airspeed.
+    #: Only used for Flight models.
+    #: Passed directly to :func:`scipy.signal.savgol_filter`.
+    #: See :meth:`pycontrails.Flight.segment_true_airspeed` for details.
+    smooth_true_airspeed: bool = True
+    smooth_true_airspeed_window_length: int = 7
+    smooth_true_airspeed_polyorder: int = 1
+
+    #: Humidity scaling
+    humidity_scaling: HumidityScaling | None = None
+
+    #: Experimental. If ``True``, attempt to reduce memory consumption during
+    #: aircraft performance and initial contrail formation/persistent calculations
+    #: by calling :meth:`MetDataArray.interpolate` with ``lowmem=True``.
+    #:
+    #: **IMPORTANT**:
+    #:
+    #: * Memory optimizations used when ``proprocess_lowmem=True`` are designed for
+    #:   meteorology backed by dask arrays with a chunk size of 1 along
+    #:   the time dimension. This option may degrade performance if dask if not used
+    #:   or if chunks contain more than a single time step.
+    #: * The impact on runtime of setting ``preprocess_lowmem=True`` depends on how
+    #:   meteorology data is chunked. Runtime is likely to increase if meteorology
+    #:   data is chunked in time only, but may decrease if meteorology data is also
+    #:   chunked in longitude, latitude, and level.
+    #: * Changes to data access patterns with ``preprocess_lowmem=True`` alter locations
+    #:   where interpolation is in- vs out-of-bounds. As a consequence,
+    #:   Cocip output with ``preprocess_lowmem=True`` is only guaranteed to match output
+    #:   with ``preprocess_lowmem=False`` when run with ``interpolation_bounds_error=True``
+    #:   to ensure no out-of-bounds interpolation occurs.
+    preprocess_lowmem: bool = False
+
+    # --------------
+    # Downselect met
+    # --------------
+
+    #: Compute ``"tau_cirrus"`` variable in pressure-level met data during model
+    #: initialization. Must be one of ``"auto"``, ``True``, or ``False``. If set to
+    #: ``"auto"``, ``"tau_cirrus"`` will be computed during model initialization
+    #: iff the met data is dask-backed. Otherwise, it will be computed during model
+    #: evaluation after the met data is downselected.
+    compute_tau_cirrus_in_model_init: bool | str = "auto"
+
+    #: Met longitude [WGS84] buffer for Cocip evolution.
+    met_longitude_buffer: tuple[float, float] = (10.0, 10.0)
+
+    #: Met latitude buffer [WGS84] for Cocip evolution.
+    met_latitude_buffer: tuple[float, float] = (10.0, 10.0)
+
+    #: Met level buffer [:math:`hPa`] for Cocip initialization and evolution.
+    met_level_buffer: tuple[float, float] = (40.0, 40.0)
+
+    # ---------
+    # Filtering
+    # ---------
+
+    #: Filter out waypoints if the don't satisfy the SAC criteria
+    #: Note that the SAC algorithm will still be run to calculate
+    #: ``T_critical_sac`` for use estimating initial ice particle number.
+    #: Passing in a non-default value is unusual, but is included
+    #: to allow for false negative calibration and model uncertainty studies.
+    filter_sac: bool = True
+
+    #: Filter out waypoints if they don't satisfy the initial persistent criteria
+    #: Passing in a non-default value is unusual, but is included
+    #: to allow for false negative calibration and model uncertainty studies.
+    filter_initially_persistent: bool = True
+
+    #: Continue evolving contrail waypoints ``persistent_buffer`` beyond
+    #: end of contrail life.
+    #: Passing in a non-default value is unusual, but is included
+    #: to allow for false negative calibration and model uncertainty studies.
+    persistent_buffer: np.timedelta64 | None = None
+
+    # -------
+    # Outputs
+    # -------
+
+    #: Add additional values to the flight and contrail that are not explicitly
+    #: necessary for calculation.
+    #: See also :attr:`CocipGridParams.verbose_outputs_formation` and
+    #: :attr:`CocipGridParams.verbose_outputs_evolution`.
+    verbose_outputs: bool = False
+
+    #: 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:`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:`yinPredictingClimateImpact2023`.
+    global_rf_to_atr20_factor: float = 0.0151
+
+    # ----------------
+    # Model parameters
+    # ----------------
+
+    #: Initial wake vortex depth scaling factor.
+    #: This factor scales max contrail downward displacement after the wake vortex phase
+    #: to set the initial contrail depth.
+    #: Denoted :math:`C_{D0}` in eq (14) in :cite:`schumannContrailCirrusPrediction2012`.
+    initial_wake_vortex_depth: float = 0.5
+
+    #: Sedimentation impact factor. Denoted by :math:`f_{T}` in eq. (35) of
+    #: :cite:`schumannContrailCirrusPrediction2012`.
+    #: Schumann describes this as "an important adjustable parameter", and sets
+    #: it to 0.1 in the original publication. In :cite:`schumannAviationinducedCirrusRadiation2013`,
+    #: a value of 0.5 is referenced after comparing CoCiP predictions to observations.
+    sedimentation_impact_factor: float = 0.5
+
+    #: Default ``nvpm_ei_n`` value if no data provided and emissions calculations fails.
+    default_nvpm_ei_n: float = EmissionsParams.default_nvpm_ei_n
+
+    #: Parameter denoted by :math:`n` in eq. (39) of :cite:`schumannContrailCirrusPrediction2012`.
+    wind_shear_enhancement_exponent: float = 0.5
+
+    #: Multiply flight black carbon number by enhancement factor.
+    #: A value of 1.0 provides no scaling.
+    #: Primarily used to support uncertainty estimation.
+    nvpm_ei_n_enhancement_factor: float = 1.0
+
+    #: Lower bound for ``nvpm_ei_n`` to account for ambient aerosol
+    #: particles for newer engines, [:math:`kg^{-1}`]
+    min_ice_particle_number_nvpm_ei_n: float = 1e13
+
+    #: Upper bound for contrail plume depth, constraining it to realistic values.
+    #: CoCiP only uses the ambient conditions at the mid-point of the Gaussian plume,
+    #: and the edges could be in subsaturated conditions and sublimate. Important when
+    #: :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
+    #: and reduce the lifetime of contrail cirrus. This parameter is experimental,
+    #: and the CoCiP implementation of this parameter may change.
+    #:
+    #:  .. versionadded:: 0.28.9
+    radiative_heating_effects: bool = False
+
+    #: Experimental. Radiative effects due to contrail-contrail overlapping
+    #: Account for change in local contrail shortwave and longwave radiative forcing
+    #: due to contrail-contrail overlapping.
+    #:
+    #: .. versionadded:: 0.45
+    contrail_contrail_overlapping: bool = False
+
+    #: Experimental. Contrail-contrail overlapping altitude interval
+    #: If :attr:`contrail_contrail_overlapping` is set to True, contrails will be grouped into
+    #: altitude intervals, and all contrails within each altitude interval are treated as one
+    #: contrail layer where they do not overlap.
+    dz_overlap_m: float = 500.0
+
+    #: Radius threshold for regime bins, [:math:`\mu m`]
+    #: This is the row index label for ``habit_distributions``.
+    #: See Table 2 in :cite:`schumannEffectiveRadiusIce2011`.
+    radius_threshold_um: np.ndarray = dataclasses.field(default_factory=_radius_threshold_um)
+
+    #: Particle habit (shape) types.
+    #: This is the column index label for ``habit_distributions``.
+    #: See Table 2 in :cite:`schumannEffectiveRadiusIce2011`.
+    habits: np.ndarray = dataclasses.field(default_factory=_habits)
+
+    #: Mix of ice particle habits in each radius regime.
+    #: Rows indexes are ``radius_threshold_um`` elements.
+    #: Columns indexes are ``habits`` particle habit type.
+    #: See Table 2 from :cite:`schumannEffectiveRadiusIce2011`.
+    habit_distributions: np.ndarray = dataclasses.field(default_factory=_habit_distributions)
+
+    #: Scale shortwave radiative forcing.
+    #: Primarily used to support uncertainty estimation.
+    rf_sw_enhancement_factor: float = 1.0
+
+    #: Scale longwave radiative forcing.
+    #: Primarily used to support uncertainty estimation.
+    rf_lw_enhancement_factor: float = 1.0
+
+    # ---------------------------------------
+    # Conditions for end of contrail lifetime
+    # ---------------------------------------
+
+    #: Minimum altitude domain in simulation, [:math:`m`]
+    #: If set to ``None``, this check is disabled.
+    min_altitude_m: float | None = 6000.0
+
+    #: Maximum altitude domain in simulation, [:math:`m`]
+    #: If set to ``None``, this check is disabled.
+    max_altitude_m: float | None = 13000.0
+
+    #: Maximum contrail segment length in simulation to prevent unrealistic values, [:math:`m`].
+    max_seg_length_m: float = 40000.0
+
+    #: Max age of contrail evolution.
+    max_age: np.timedelta64 = np.timedelta64(20, "h")
+
+    #: Minimum contrail optical depth.
+    min_tau: float = 1e-6
+
+    #: Maximum contrail optical depth to prevent unrealistic values.
+    max_tau: float = 1e10
+
+    #: Minimum contrail ice particle number per volume of air.
+    min_n_ice_per_m3: float = 1e3
+
+    #: Maximum contrail ice particle number per volume of air to prevent unrealistic values.
+    max_n_ice_per_m3: float = 1e20
+
+
+@dataclasses.dataclass
+class CocipFlightParams(CocipParams):
+    """Flight specific CoCiP parameters."""
+
+    #: Aircraft performance model
+    aircraft_performance: AircraftPerformance | None = None

pycontrails/models/cocip/cocip_uncertainty.py

@@ -0,0 +1,285 @@
+"""Parameters for CoCiP uncertainty calculations."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import asdict, dataclass
+from typing import Any, ClassVar
+
+import numpy as np
+import numpy.typing as npt
+from scipy import stats
+from scipy.stats.distributions import rv_frozen
+
+from pycontrails.models.cocip import cocip_params
+from pycontrails.models.cocip.cocip_params import CocipParams
+
+logger = logging.getLogger(__name__)
+
+
+class habit_dirichlet(rv_frozen):
+    r"""Custom dirichlet distribution for habit weight distribution uncertainty.
+
+    Scale the habit distributions by a dirichlet distribution
+    with alpha parameter :math:`\alpha_{i} = 0.5 + \text{C} \text{G}_{i}`
+    where :math:`\text{G}_{i}` is the approximate habit weight distributions
+    defined in :attr:`CocipParams().habit_distributions`.
+
+    References
+    ----------
+    - Table 2 in :cite:`schumannEffectiveRadiusIce2011`
+    """
+
+    def __init__(self, C: float = 96.0):
+        self.C = C
+
+    def rvs(self, *args: Any, **kwds: Any) -> npt.NDArray[np.float32]:
+        """Generate sample set of habit distributions.
+
+        Sampled using dirichlet distribution.
+
+        Parameters
+        ----------
+        *args
+            Used to create a number of habit distributions
+        **kwds
+            Passed through to :func:`scipy.stats.dirichlet.rvs()`
+
+        Returns
+        -------
+        npt.NDArray[np.float32]
+            Sampled habit weight distribution with the same shape
+            as :attr:`CocipParams().habit_distributions`
+        """
+        if args or (kwds.get("size") is not None and kwds["size"] > 1):
+            raise ValueError("habit_dirichlet distribution only supports creating one rv at a time")
+
+        default_distributions = cocip_params._habit_distributions()
+        alpha_i = 0.5 + self.C * default_distributions
+
+        # In the first distribution, we assume all ice particles are droxtals
+        # There is no way to quantify the uncertainty in this assumption
+        # Consequently, we leave the first distribution in default_distributions
+        # alone, and only perturb the rest
+        distr_list = [stats.dirichlet(a) for a in alpha_i[1:]]
+
+        habit_weights = default_distributions.copy()
+        for i, distr in enumerate(distr_list, start=1):
+            habit_weights[i] = distr.rvs(**kwds)
+
+        return habit_weights
+
+
+@dataclass
+class CocipUncertaintyParams(CocipParams):
+    """Model parameters for CoCiP epistemic uncertainty.
+
+    Any uncertainty parameters should end with the suffix `uncertainty`. See `__post_init__`.
+
+    Uncertainty parameters take a `scipy.stats.distributions.rv_frozen` distribution.
+
+    Default distributions have mean at CocipParam default values.
+
+    To retain specific parameters as defaults, set the value of the key to None.
+
+    Examples
+    --------
+    >>> import scipy.stats
+    >>> from pycontrails.models.cocip import CocipUncertaintyParams
+
+    >>> # Override the 'initial_wake_vortex_depth' field from
+    >>> # CocipParams with a uniform value in [0.4, 0.6]
+    >>> distr = scipy.stats.uniform(loc=0.4, scale=0.2)
+    >>> params = CocipUncertaintyParams(seed=123, initial_wake_vortex_depth_uncertainty=distr)
+    >>> params.initial_wake_vortex_depth
+    np.float64(0.41076420...)
+
+    >>> # Once seeded, calling the class again gives a new value
+    >>> params = CocipUncertaintyParams(initial_wake_vortex_depth=distr)
+    >>> params.initial_wake_vortex_depth
+    np.float64(0.43526372...)
+
+    >>> # To retain the default value, set the uncertainty to None
+    >>> params = CocipUncertaintyParams(rf_lw_enhancement_factor_uncertainty=None)
+    >>> params.rf_lw_enhancement_factor
+    1.0
+    """
+
+    #: The random number generator is attached to the class (as opposed to an instance).
+    #: If many instances of :class:`CocipUncertaintyParams` are needed, it is best to seed
+    #: the random number generator once initially. Reseeding the generator will also
+    #: reset it, giving rise to duplicate random numbers.
+    rng: ClassVar[np.random.Generator] = np.random.default_rng(None)
+
+    #: Reseed the random generator defined in ``__post_init__``
+    seed: int | None = None
+
+    #: Schumann takes ``wind_shear_enhancement_exponent`` = 0.5 and discusses the case of 0 and 2/3
+    #: as possibilities.
+    #: With a value of 0, wind shear is not enhanced.
+    wind_shear_enhancement_exponent_uncertainty: rv_frozen | None = stats.triang(
+        loc=0.0, c=CocipParams.wind_shear_enhancement_exponent, scale=1.0
+    )
+
+    #: Schumann takes ``initial_wake_vortex_depth`` = 0.5 and discusses some
+    #: uncertainty in this value. This parameter should be non-negative.
+    initial_wake_vortex_depth_uncertainty: rv_frozen | None = stats.triang(
+        loc=0.3, c=CocipParams.initial_wake_vortex_depth, scale=0.4
+    )
+
+    #: Schumann takes a default value of 0.1 and describes it as an "important adjustable parameter"
+    #: Currently, `CocipParams` uses a default value of 0.5
+    sedimentation_impact_factor_uncertainty: rv_frozen | None = stats.norm(
+        loc=CocipParams.sedimentation_impact_factor, scale=0.1
+    )
+
+    #: Teoh 2022 (to appear) takes values between 70% decrease and 100% increase.
+    #: This coincides with the log normal distribution defined below.
+    nvpm_ei_n_enhancement_factor_uncertainty: rv_frozen | None = stats.lognorm(
+        s=0.15, scale=1 / stats.lognorm(s=0.15).mean()
+    )
+
+    #: Scale shortwave radiative forcing.
+    #: Table 2 in :cite:`schumannParametricRadiativeForcing2012`
+    #: provides relative RMS error for SW/LW fit to the data generated
+    #: by `libRadTran <http://www.libradtran.org/doku.php>`_.
+    #: We use the average RMS error across all habit types (pg 1397) as the standard deviation
+    #: of a normally distributed scaling factor for SW forcing
+    rf_sw_enhancement_factor_uncertainty: rv_frozen | None = stats.norm(
+        loc=CocipParams.rf_sw_enhancement_factor, scale=0.106
+    )
+
+    #: Scale longwave radiative forcing.
+    #: Table 2 in :cite:`schumannParametricRadiativeForcing2012` provides relative error for SW/LW
+    #: fit to the data generated by `libRadTran <http://www.libradtran.org/doku.php>`_.
+    #: We use the average RMS error across all habit types (pg 1397) as the standard deviation
+    #: of a normally distributed scaling factor for LW forcing.
+    rf_lw_enhancement_factor_uncertainty: rv_frozen | None = stats.norm(
+        loc=CocipParams.rf_lw_enhancement_factor, scale=0.071
+    )
+
+    #: Scale the habit distributions by a dirichlet distribution
+    #: with alpha parameter :math:`\alpha_{i} = 0.5 + \text{C} \text{G}_{i}`
+    #: where :math:`\text{G}_{i}` is the approximate habit weight distributions
+    #: defined in :attr:`CocipParams().habit_distributions`.
+    #: Higher values of :math:`\text{C}` correspond to higher confidence in initial estimates.
+    habit_distributions_uncertainty: rv_frozen | None = habit_dirichlet(C=96.0)
+
+    def __post_init__(self) -> None:
+        """Override values of model parameters according to ranges."""
+        if self.seed is not None:
+            # Reset the class variable `rng`
+            logger.info("Reset %s random seed to %s", self.__class__.__name__, self.seed)
+            self.__class__.rng = np.random.default_rng(self.seed)
+
+        # Override defaults value on `CocipParams` with random parameters
+        for param, value in self.rvs().items():
+            setattr(self, param, value)
+
+    @property
+    def uncertainty_params(self) -> dict[str, rv_frozen]:
+        """Get dictionary of uncertainty parameters.
+
+        Method checks for attributes ending in `"_uncertainty"`.
+
+        Returns
+        -------
+        dict[str, dict[str, Any]]
+            Uncertainty parameters and values
+        """
+        # handle these differently starting in version 0.27.0
+        exclude = {"rhi_adj", "rhi_boost_exponent"}
+
+        out = {}
+
+        param_dict = asdict(self)
+        for uncertainty_param, dist in param_dict.items():
+            if uncertainty_param.endswith("_uncertainty") and dist is not None:
+                param = uncertainty_param.split("_uncertainty")[0]
+                if param not in exclude and param not in param_dict:
+                    raise AttributeError(
+                        f"Parameter {param} corresponding to uncertainty parameter "
+                        f"{uncertainty_param} does not exist"
+                    )
+
+                if not isinstance(dist, rv_frozen):
+                    raise AttributeError(
+                        f"Uncertainty parameter '{uncertainty_param}' must be instance of "
+                        "'scipy.stats.distributions.rv_frozen'"
+                    )
+
+                out[param] = dist
+
+        return out
+
+    def rvs(self, size: None | int = None) -> dict[str, np.float64 | npt.NDArray[np.float64]]:
+        """Call each distribution's `rvs` method to generate random parameters.
+
+        Seed calls to `rvs` with class variable `rng`.
+
+        Parameters
+        ----------
+        size : None | int, optional
+            If specified, an `array` of values is generated for each uncertainty parameter.
+
+        Returns
+        -------
+        dict[str, float | npt.NDArray[np.float64]]
+            Dictionary of random parameters. Dictionary keys consists of names of parameters in
+            `CocipParams` to be overridden by random value.
+
+        Examples
+        --------
+        >>> from pprint import pprint
+        >>> from pycontrails.models.cocip import CocipUncertaintyParams
+        >>> params = CocipUncertaintyParams(seed=456)
+        >>> pprint(params.rvs())
+        {'habit_distributions': array([[0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,
+                0.0000000e+00, 0.0000000e+00, 1.0000000e+00, 0.0000000e+00],
+               [1.5554131e-02, 2.1363135e-01, 7.7715185e-03, 1.7690966e-02,
+                3.1576434e-03, 3.2992734e-06, 7.4009895e-01, 2.0921326e-03],
+               [3.8193921e-03, 2.1235342e-01, 3.3554080e-04, 5.2846869e-04,
+                3.1945917e-01, 4.8709914e-04, 4.6250960e-01, 5.0730183e-04],
+               [5.7327619e-04, 4.7781631e-01, 4.2596990e-03, 6.7235163e-04,
+                1.4447135e-01, 3.6184600e-01, 1.0150939e-02, 2.1006212e-04],
+               [1.5397545e-02, 4.0522218e-01, 4.2781001e-01, 1.4331797e-01,
+                7.1088417e-04, 9.4511814e-04, 3.3900745e-03, 3.2062260e-03],
+               [7.9063961e-04, 3.0336906e-03, 7.7571563e-04, 2.0577813e-02,
+                9.4205803e-01, 4.3379897e-03, 3.6786550e-03, 2.4747452e-02]],
+              dtype=float32),
+         'initial_wake_vortex_depth': np.float64(0.39805019708566847),
+         'nvpm_ei_n_enhancement_factor': np.float64(0.9371878437312526),
+         'rf_lw_enhancement_factor': np.float64(1.1017491252832377),
+         'rf_sw_enhancement_factor': np.float64(0.99721639115012),
+         'sedimentation_impact_factor': np.float64(0.5071779847244678),
+         'wind_shear_enhancement_exponent': np.float64(0.34100931239701004)}
+        """
+        return {
+            param: distr.rvs(size=size, random_state=self.rng)
+            for param, distr in self.uncertainty_params.items()
+        }
+
+    def as_dict(self) -> dict[str, Any]:
+        """Convert object to dictionary.
+
+        Wrapper around :meth:`ModelBase.as_dict` that removes
+        uncertainty specific parameters.
+
+        Returns
+        -------
+        dict[str, Any]
+            Dictionary version of self.
+        """
+        obj = super().as_dict()
+
+        # remove seed and _uncertainty attributes
+        # these will throw an error in `ModelBase._load_params()`
+        keys_to_remove = ["seed"]
+        for key in obj:
+            if key.endswith("_uncertainty"):
+                keys_to_remove.append(key)
+
+        for key in keys_to_remove:
+            obj.pop(key, None)
+
+        return obj