pycontrails 0.54.2__cp311-cp311-win_amd64.whl → 0.54.3__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.54.2'
-__version_tuple__ = version_tuple = (0, 54, 2)
+__version__ = version = '0.54.3'
+__version_tuple__ = version_tuple = (0, 54, 3)

pycontrails/core/aircraft_performance.py

@@ -26,7 +26,9 @@ from pycontrails.physics import jet
 from pycontrails.utils.types import ArrayOrFloat
 
 #: Default load factor for aircraft performance models.
-DEFAULT_LOAD_FACTOR = 0.7
+#: See :func:`pycontrails.physics.jet.aircraft_load_factor`
+#: for a higher precision approach to estimating the load factor.
+DEFAULT_LOAD_FACTOR = 0.83
 
 
 # --------------------------------------
@@ -35,7 +37,19 @@ DEFAULT_LOAD_FACTOR = 0.7
 
 
 @dataclasses.dataclass
-class AircraftPerformanceParams(ModelParams):
+class CommonAircraftPerformanceParams:
+    """Params for :class:`AircraftPerformanceParams` and :class:`AircraftPerformanceGridParams`."""
+
+    #: Account for "in-service" engine deterioration between maintenance cycles.
+    #: Default value is set to +2.5% increase in fuel consumption.
+    #: Reference:
+    #: Gurrola Arrieta, M.D.J., Botez, R.M. and Lasne, A., 2024. An Engine Deterioration Model for
+    #: Predicting Fuel Consumption Impact in a Regional Aircraft. Aerospace, 11(6), p.426.
+    engine_deterioration_factor: float = 0.025
+
+
+@dataclasses.dataclass
+class AircraftPerformanceParams(ModelParams, CommonAircraftPerformanceParams):
     """Parameters for :class:`AircraftPerformance`."""
 
     #: Whether to correct fuel flow to ensure it remains within
@@ -547,7 +561,7 @@ class AircraftPerformanceData:
 
 
 @dataclasses.dataclass
-class AircraftPerformanceGridParams(ModelParams):
+class AircraftPerformanceGridParams(ModelParams, CommonAircraftPerformanceParams):
     """Parameters for :class:`AircraftPerformanceGrid`."""
 
     #: Fuel type

pycontrails/core/flight.py

@@ -121,6 +121,8 @@ class Flight(GeoVectorDataset):
           calculations with the ICAO Aircraft Emissions Databank (EDB).
         - ``max_mach_number``: Maximum Mach number at cruise altitude. Used by
           some aircraft performance models to clip true airspeed.
+        - ``load_factor``: The load factor used in determining the aircraft's
+          take-off weight. Used by some aircraft performance models.
 
         Numeric quantities that are constant over the entire flight trajectory
         should be included as attributes.
@@ -961,7 +963,7 @@ class Flight(GeoVectorDataset):
                 msg = f"{msg} Pass 'keep_original_index=True' to keep the original index."
             warnings.warn(msg)
 
-        return Flight(data=df, attrs=self.attrs)
+        return Flight(data=df, attrs=self.attrs, fuel=self.fuel)
 
     def clean_and_resample(
         self,

pycontrails/datalib/ecmwf/variables.py

@@ -107,6 +107,7 @@ RelativeHumidity = MetVariable(
     long_name=met_var.RelativeHumidity.long_name,
     units="%",
     level_type=met_var.RelativeHumidity.level_type,
+    grib1_id=met_var.RelativeHumidity.grib1_id,
     ecmwf_id=met_var.RelativeHumidity.ecmwf_id,
     grib2_id=met_var.RelativeHumidity.grib2_id,
     description=(

pycontrails/datalib/landsat.py

@@ -152,7 +152,7 @@ class Landsat:
         are used. Bands must share a common resolution. The resolutions of each band are:
 
         - B1-B7, B9: 30 m
-        - B9: 15 m
+        - B8: 15 m
         - B10, B11: 30 m (upsampled from true resolution of 100 m)
 
     cachestore : cache.CacheStore, optional
@@ -291,9 +291,7 @@ def _check_band_resolution(bands: set[str]) -> None:
     there are two valid cases: only band 8, or any bands except band 8.
     """
     groups = [
-        {
-            "B8",
-        },  # 15 m
+        {"B8"},  # 15 m
         {f"B{i}" for i in range(1, 12) if i != 8},  # 30 m
     ]
     if not any(bands.issubset(group) for group in groups):
@@ -313,10 +311,9 @@ def _read(path: str, meta: str, band: str, processing: str) -> xr.DataArray:
             pycontrails_optional_package="sat",
         )
 
-    src = rasterio.open(path)
-    img = src.read(1)
-    crs = pyproj.CRS.from_epsg(src.crs.to_epsg())
-    src.close()
+    with rasterio.open(path) as src:
+        img = src.read(1)
+        crs = pyproj.CRS.from_epsg(src.crs.to_epsg())
 
     if processing == "reflectance":
         mult, add = _read_band_reflectance_rescaling(meta, band)

pycontrails/datalib/sentinel.py

@@ -313,9 +313,8 @@ def _check_band_resolution(bands: set[str]) -> None:
 def _read(path: str, granule_meta: str, safe_meta: str, band: str, processing: str) -> xr.DataArray:
     """Read imagery data from Sentinel-2 files."""
     Image.MAX_IMAGE_PIXELS = None  # avoid decompression bomb warning
-    src = Image.open(path)
-    img = np.asarray(src)
-    src.close()
+    with Image.open(path) as src:
+        img = np.asarray(src)
 
     if processing == "reflectance":
         gain, offset = _read_band_reflectance_rescaling(safe_meta, band)
@@ -357,10 +356,9 @@ def _band_id(band: str) -> int:
     """Get band ID used in some metadata files."""
     if band in (f"B{i:2d}" for i in range(1, 9)):
         return int(band[1:]) - 1
-    elif band == "B8A":
+    if band == "B8A":
         return 8
-    else:
-        return int(band[1:])
+    return int(band[1:])
 
 
 def _read_band_reflectance_rescaling(meta: str, band: str) -> tuple[float, float]:
@@ -389,12 +387,10 @@ def _read_band_reflectance_rescaling(meta: str, band: str) -> tuple[float, float
     for elem in elems:
         if int(elem.attrib["band_id"]) == band_id and elem.text is not None:
             offset = float(elem.text)
-            break
-    else:
-        msg = f"Could not find reflectance offset for band {band} (band ID {band_id})"
-        raise ValueError(msg)
+            return gain, offset
 
-    return gain, offset
+    msg = f"Could not find reflectance offset for band {band} (band ID {band_id})"
+    raise ValueError(msg)
 
 
 def _read_image_coordinates(meta: str, band: str) -> tuple[np.ndarray, np.ndarray]:

pycontrails/ext/bada.py

@@ -22,8 +22,9 @@ try:
 
 except ImportError as e:
     raise ImportError(
-        "Failed to import the 'pycontrails-bada' package. Install with 'pip install"
-        ' "pycontrails-bada @ git+ssh://git@github.com/contrailcirrus/pycontrails-bada.git"\'.'
+        "Failed to import the 'pycontrails-bada' package. Install with 'pip install "
+        "--index-url https://us-central1-python.pkg.dev/contrails-301217/pycontrails/simple "
+        "pycontrails-bada'."
     ) from e
 else:
     __all__ = [

pycontrails/ext/synthetic_flight.py

@@ -20,8 +20,9 @@ try:
     from pycontrails.ext.bada import bada_model
 except ImportError as e:
     raise ImportError(
-        'SyntheticFlight requires BADA extension. Install with `pip install "pycontrails-bada @'
-        ' git+ssh://git@github.com/contrailcirrus/pycontrails-bada.git"`'
+        "Failed to import the 'pycontrails-bada' package. Install with 'pip install "
+        "--index-url https://us-central1-python.pkg.dev/contrails-301217/pycontrails/simple "
+        "pycontrails-bada'."
     ) from e
 
 logger = logging.getLogger(__name__)

pycontrails/models/accf.py

@@ -88,13 +88,16 @@ class ACCFParams(ModelParams):
     h2o_scaling: float = 1.0
     o3_scaling: float = 1.0
 
-    forecast_step: float = 6.0
+    forecast_step: float | None = None
 
     sep_ri_rw: bool = False
 
     climate_indicator: str = "ATR"
 
-    horizontal_resolution: float = 0.5
+    #: The horizontal resolution of the meteorological data in degrees.
+    #: If None, it will be inferred from the ``met`` dataset for :class:`MetDataset`
+    #: source, otherwise it will be set to 0.5.
+    horizontal_resolution: float | None = None
 
     emission_scenario: str = "pulse"
 
@@ -116,6 +119,8 @@ class ACCFParams(ModelParams):
 
     PMO: bool = False
 
+    unit_K_per_kg_fuel: bool = False
+
 
 class ACCF(Model):
     """Compute Algorithmic Climate Change Functions (ACCF).
@@ -146,16 +151,13 @@ class ACCF(Model):
         SpecificHumidity,
         ecmwf.PotentialVorticity,
         Geopotential,
-        RelativeHumidity,
+        (RelativeHumidity, ecmwf.RelativeHumidity),
         NorthwardWind,
         EastwardWind,
-        ecmwf.PotentialVorticity,
     )
     sur_variables = (ecmwf.SurfaceSolarDownwardRadiation, ecmwf.TopNetThermalRadiation)
     default_params = ACCFParams
 
-    short_vars = frozenset(v.short_name for v in (*met_variables, *sur_variables))
-
     # This variable won't get used since we are not writing the output
     # anywhere, but the library will complain if it's not defined
     path_lib = "./"
@@ -168,7 +170,13 @@ class ACCF(Model):
         **params_kwargs: Any,
     ) -> None:
         # Normalize ECMWF variables
-        met = standardize_variables(met, self.met_variables)
+        variables = (v[0] if isinstance(v, tuple) else v for v in self.met_variables)
+        met = standardize_variables(met, variables)
+
+        # If relative humidity is in percentage, convert to a proportion
+        if met["relative_humidity"].attrs.get("units") == "%":
+            met.data["relative_humidity"] /= 100.0
+            met.data["relative_humidity"].attrs["units"] = "1"
 
         # Ignore humidity scaling warning
         with warnings.catch_warnings():
@@ -231,18 +239,21 @@ class ACCF(Model):
             if hasattr(self, "surface"):
                 self.surface = self.source.downselect_met(self.surface)
 
-        if isinstance(self.source, MetDataset):
-            # Overwrite horizontal resolution to match met
-            longitude = self.source.data["longitude"].values
-            if longitude.size > 1:
-                hres = abs(longitude[1] - longitude[0])
-                self.params["horizontal_resolution"] = float(hres)
-
-            else:
+        if self.params["horizontal_resolution"] is None:
+            if isinstance(self.source, MetDataset):
+                # Overwrite horizontal resolution to match met
+                longitude = self.source.data["longitude"].values
                 latitude = self.source.data["latitude"].values
-                if latitude.size > 1:
+                if longitude.size > 1:
+                    hres = abs(longitude[1] - longitude[0])
+                    self.params["horizontal_resolution"] = float(hres)
+                elif latitude.size > 1:
                     hres = abs(latitude[1] - latitude[0])
                     self.params["horizontal_resolution"] = float(hres)
+                else:
+                    self.params["horizontal_resolution"] = 0.5
+            else:
+                self.params["horizontal_resolution"] = 0.5
 
         p_settings = _get_accf_config(self.params)
 
@@ -267,10 +278,14 @@ class ACCF(Model):
         aCCFs, _ = clim_imp.get_xarray()
 
         # assign ACCF outputs to source
+        skip = {
+            v[0].short_name if isinstance(v, tuple) else v.short_name
+            for v in (*self.met_variables, *self.sur_variables)
+        }
         maCCFs = MetDataset(aCCFs)
         for key, arr in maCCFs.data.items():
             # skip met variables
-            if key in self.short_vars:
+            if key in skip:
                 continue
 
             assert isinstance(key, str)
@@ -292,7 +307,12 @@ class ACCF(Model):
         # It also needs variables to have the ECMWF short name
         if isinstance(self.met, MetDataset):
             ds_met = self.met.data.transpose("time", "level", "latitude", "longitude")
-            name_dict = {v.standard_name: v.short_name for v in self.met_variables}
+            name_dict = {
+                v[0].standard_name if isinstance(v, tuple) else v.standard_name: v[0].short_name
+                if isinstance(v, tuple)
+                else v.short_name
+                for v in self.met_variables
+            }
             ds_met = ds_met.rename(name_dict)
         else:
             ds_met = None
@@ -340,7 +360,7 @@ def _get_accf_config(params: dict[str, Any]) -> dict[str, Any]:
         "horizontal_resolution": params["horizontal_resolution"],
         "forecast_step": params["forecast_step"],
         "NOx_aCCF": True,
-        "NOx&inverse_EIs": params["nox_ei"],
+        "NOx_EI&F_km": params["nox_ei"],
         "output_format": "netCDF",
         "mean": False,
         "std": False,
@@ -361,6 +381,7 @@ def _get_accf_config(params: dict[str, Any]) -> dict[str, Any]:
             "H2O": params["h2o_scaling"],
             "O3": params["o3_scaling"],
         },
+        "unit_K/kg(fuel)": params["unit_K_per_kg_fuel"],
         "PCFA": params["pfca"],
         "PCFA-ISSR": {
             "rhi_threshold": params["issr_rhi_threshold"],

pycontrails/models/apcemm/apcemm.py

@@ -28,6 +28,7 @@ from pycontrails.core.met_var import (
     SpecificHumidity,
     VerticalVelocity,
 )
+from pycontrails.core.vector import GeoVectorDataset
 from pycontrails.models.apcemm import utils
 from pycontrails.models.apcemm.inputs import APCEMMInput
 from pycontrails.models.dry_advection import DryAdvection
@@ -314,7 +315,7 @@ class APCEMM(models.Model):
     source: Flight
 
     #: Output from trajectory calculation
-    trajectories: Flight | None
+    trajectories: GeoVectorDataset | None
 
     #: Time series output from the APCEMM early plume model
     vortex: pd.DataFrame | None

pycontrails/models/cocip/cocip.py

@@ -2296,8 +2296,7 @@ def calc_timestep_contrail_evolution(
     dt = time_2_array - time_1
 
     # get new contrail location & segment properties after t_step
-    longitude_2 = geo.advect_longitude(longitude_1, latitude_1, u_wind_1, dt)
-    latitude_2 = geo.advect_latitude(latitude_1, v_wind_1, dt)
+    longitude_2, latitude_2 = geo.advect_horizontal(longitude_1, latitude_1, u_wind_1, v_wind_1, dt)
     level_2 = geo.advect_level(level_1, vertical_velocity_1, rho_air_1, terminal_fall_speed_1, dt)
     altitude_2 = units.pl_to_m(level_2)
 

pycontrails/models/cocipgrid/cocip_grid.py

@@ -816,6 +816,9 @@ class CocipGrid(models.Model):
         """
         Shortcut to create a :class:`MetDataset` source from coordinate arrays.
 
+        .. versionchanged:: 0.54.3
+            By default, the returned latitude values now extend to the poles.
+
         Parameters
         ----------
         level : level: npt.NDArray[np.float64] | list[float] | float
@@ -829,8 +832,6 @@ class CocipGrid(models.Model):
         longitude, latitude : npt.NDArray[np.float64] | list[float], optional
             Longitude and latitude arrays, by default None. If not specified, values of
             ``lon_step`` and ``lat_step`` are used to define ``longitude`` and ``latitude``.
-            To avoid model degradation at the poles, latitude values are expected to be
-            between -80 and 80 degrees.
         lon_step, lat_step : float, optional
             Longitude and latitude resolution, by default 1.0.
             Only used if parameter ``longitude`` (respective ``latitude``) not specified.
@@ -847,15 +848,11 @@ class CocipGrid(models.Model):
         if longitude is None:
             longitude = np.arange(-180, 180, lon_step, dtype=float)
         if latitude is None:
-            latitude = np.arange(-80, 80.000001, lat_step, dtype=float)
-
-        out = MetDataset.from_coords(longitude=longitude, latitude=latitude, level=level, time=time)
-
-        if np.any(out.data.latitude > 80.0001) or np.any(out.data.latitude < -80.0001):
-            msg = "Model only supports latitude between -80 and 80."
-            raise ValueError(msg)
+            latitude = np.arange(-90, 90.000001, lat_step, dtype=float)
 
-        return out
+        return MetDataset.from_coords(
+            longitude=longitude, latitude=latitude, level=level, time=time
+        )
 
 
 ################################
@@ -2054,10 +2051,13 @@ def advect(
     time_t2 = time + dt
     age_t2 = age + dt
 
-    longitude_t2 = geo.advect_longitude(
-        longitude=longitude, latitude=latitude, u_wind=u_wind, dt=dt
+    longitude_t2, latitude_t2 = geo.advect_horizontal(
+        longitude=longitude,
+        latitude=latitude,
+        u_wind=u_wind,
+        v_wind=v_wind,
+        dt=dt,
     )
-    latitude_t2 = geo.advect_latitude(latitude=latitude, v_wind=v_wind, dt=dt)
     level_t2 = geo.advect_level(level, vertical_velocity, rho_air, terminal_fall_speed, dt)
     altitude_t2 = units.pl_to_m(level_t2)
 
@@ -2089,15 +2089,20 @@ def advect(
     u_wind_tail = contrail["eastward_wind_tail"]
     v_wind_tail = contrail["northward_wind_tail"]
 
-    longitude_head_t2 = geo.advect_longitude(
-        longitude=longitude_head, latitude=latitude_head, u_wind=u_wind_head, dt=dt_head
+    longitude_head_t2, latitude_head_t2 = geo.advect_horizontal(
+        longitude=longitude_head,
+        latitude=latitude_head,
+        u_wind=u_wind_head,
+        v_wind=v_wind_head,
+        dt=dt_head,
     )
-    latitude_head_t2 = geo.advect_latitude(latitude=latitude_head, v_wind=v_wind_head, dt=dt_head)
-
-    longitude_tail_t2 = geo.advect_longitude(
-        longitude=longitude_tail, latitude=latitude_tail, u_wind=u_wind_tail, dt=dt_tail
+    longitude_tail_t2, latitude_tail_t2 = geo.advect_horizontal(
+        longitude=longitude_tail,
+        latitude=latitude_tail,
+        u_wind=u_wind_tail,
+        v_wind=v_wind_tail,
+        dt=dt_tail,
     )
-    latitude_tail_t2 = geo.advect_latitude(latitude=latitude_tail, v_wind=v_wind_tail, dt=dt_tail)
 
     segment_length_t2 = geo.haversine(
         lons0=longitude_head_t2,

pycontrails/models/dry_advection.py

@@ -9,7 +9,6 @@ import numpy as np
 import numpy.typing as npt
 
 from pycontrails.core import models
-from pycontrails.core.flight import Flight
 from pycontrails.core.met import MetDataset
 from pycontrails.core.met_var import AirTemperature, EastwardWind, NorthwardWind, VerticalVelocity
 from pycontrails.core.vector import GeoVectorDataset
@@ -92,9 +91,6 @@ class DryAdvection(models.Model):
     met_required = True
     source: GeoVectorDataset
 
-    @overload
-    def eval(self, source: Flight, **params: Any) -> Flight: ...
-
     @overload
     def eval(self, source: GeoVectorDataset, **params: Any) -> GeoVectorDataset: ...
 
@@ -109,7 +105,12 @@ class DryAdvection(models.Model):
         Parameters
         ----------
         source : GeoVectorDataset
-            Arbitrary points to advect.
+            Arbitrary points to advect. A :class:`Flight` instance is not treated any
+            differently than a :class:`GeoVectorDataset`. In particular, the user must
+            explicitly set ``flight["azimuth"] = flight.segment_azimuth()`` if they
+            want to use wind shear effects for a flight.
+            In the current implementation, any existing meteorological variables in the ``source``
+            are ignored. The ``source`` will be interpolated against the :attr:`met` dataset.
         params : Any
             Overwrite model parameters defined in ``__init__``.
 
@@ -122,7 +123,7 @@ class DryAdvection(models.Model):
         self.set_source(source)
         self.source = self.require_source_type(GeoVectorDataset)
 
-        self._prepare_source()
+        self.source = self._prepare_source()
 
         interp_kwargs = self.interp_kwargs
 
@@ -142,7 +143,7 @@ class DryAdvection(models.Model):
         evolved = []
         for t in timesteps:
             filt = (source_time < t) & (source_time >= t - dt_integration)
-            vector = self.source.filter(filt) + vector
+            vector = self.source.filter(filt, copy=False) + vector
             vector = _evolve_one_step(
                 self.met,
                 vector,
@@ -162,49 +163,44 @@ class DryAdvection(models.Model):
 
         return GeoVectorDataset.sum(evolved, fill_value=np.nan)
 
-    def _prepare_source(self) -> None:
+    def _prepare_source(self) -> GeoVectorDataset:
         r"""Prepare :attr:`source` vector for advection by wind-shear-derived variables.
 
-        This method adds the following variables to :attr:`source` if the `"azimuth"`
-        parameter is not None:
+        The following variables are always guaranteed to be present in :attr:`source`:
 
         - ``age``: Age of plume.
+        - ``waypoint``: Identifier for each waypoint.
+
+        If `"azimuth"` is present in :attr:`source`, `source.attrs`, or :attr:`params`,
+        the following variables will also be added:
+
         - ``azimuth``: Initial plume direction, measured in clockwise direction from
-          true north, [:math:`\deg`].
+            true north, [:math:`\deg`].
         - ``width``: Initial plume width, [:math:`m`].
         - ``depth``: Initial plume depth, [:math:`m`].
         - ``sigma_yz``: All zeros for cross-term term in covariance matrix of plume.
-        """
 
+        Returns
+        -------
+        GeoVectorDataset
+            A filtered version of the source with only the required columns.
+        """
         self.source.setdefault("level", self.source.level)
-
-        columns: tuple[str, ...] = ("longitude", "latitude", "level", "time")
-        if "azimuth" in self.source:
-            columns += ("azimuth",)
-        self.source = GeoVectorDataset(self.source.select(columns, copy=False))
-
-        # Get waypoint index if not already set
+        self.source["age"] = np.full(self.source.size, np.timedelta64(0, "ns"))
         self.source.setdefault("waypoint", np.arange(self.source.size))
 
-        self.source["age"] = np.full(self.source.size, np.timedelta64(0, "ns"))
+        columns = ["longitude", "latitude", "level", "time", "age", "waypoint"]
+        azimuth = self.get_source_param("azimuth", set_attr=False)
+        if azimuth is None:
+            # Early exit for pointwise only simulation
+            if self.params["width"] is not None or self.params["depth"] is not None:
+                raise ValueError(
+                    "If 'azimuth' is None, then 'width' and 'depth' must also be None."
+                )
+            return GeoVectorDataset(self.source.select(columns, copy=False), copy=False)
 
         if "azimuth" not in self.source:
-            if isinstance(self.source, Flight):
-                pointwise_only = False
-                self.source["azimuth"] = self.source.segment_azimuth()
-            else:
-                try:
-                    self.source.broadcast_attrs("azimuth")
-                except KeyError:
-                    if (azimuth := self.params["azimuth"]) is not None:
-                        pointwise_only = False
-                        self.source["azimuth"] = np.full_like(self.source["longitude"], azimuth)
-                    else:
-                        pointwise_only = True
-                else:
-                    pointwise_only = False
-        else:
-            pointwise_only = False
+            self.source["azimuth"] = np.full_like(self.source["longitude"], azimuth)
 
         for key in ("width", "depth"):
             if key in self.source:
@@ -214,18 +210,12 @@ class DryAdvection(models.Model):
                 continue
 
             val = self.params[key]
-            if val is None and not pointwise_only:
+            if val is None:
                 raise ValueError(f"If '{key}' is None, then 'azimuth' must also be None.")
 
-            if val is not None and pointwise_only:
-                raise ValueError(f"Cannot specify '{key}' without specifying 'azimuth'.")
-
-            if not pointwise_only:
-                self.source[key] = np.full_like(self.source["longitude"], val)
-
-        if pointwise_only:
-            return
+            self.source[key] = np.full_like(self.source["longitude"], val)
 
+        columns.extend(["azimuth", "width", "depth", "sigma_yz", "area_eff"])
         self.source["sigma_yz"] = np.zeros_like(self.source["longitude"])
         width = self.source["width"]
         depth = self.source["depth"]
@@ -233,6 +223,8 @@ class DryAdvection(models.Model):
             width, depth, sigma_yz=0.0
         )
 
+        return GeoVectorDataset(self.source.select(columns, copy=False), copy=False)
+
 
 def _perform_interp_for_step(
     met: MetDataset,
@@ -412,15 +404,20 @@ def _calc_geometry(
     u_wind_tail = vector.data.pop("eastward_wind_tail")
     v_wind_tail = vector.data.pop("northward_wind_tail")
 
-    longitude_head_t2 = geo.advect_longitude(
-        longitude=longitude_head, latitude=latitude_head, u_wind=u_wind_head, dt=dt
+    longitude_head_t2, latitude_head_t2 = geo.advect_horizontal(
+        longitude=longitude_head,
+        latitude=latitude_head,
+        u_wind=u_wind_head,
+        v_wind=v_wind_head,
+        dt=dt,
     )
-    latitude_head_t2 = geo.advect_latitude(latitude=latitude_head, v_wind=v_wind_head, dt=dt)
-
-    longitude_tail_t2 = geo.advect_longitude(
-        longitude=longitude_tail, latitude=latitude_tail, u_wind=u_wind_tail, dt=dt
+    longitude_tail_t2, latitude_tail_t2 = geo.advect_horizontal(
+        longitude=longitude_tail,
+        latitude=latitude_tail,
+        u_wind=u_wind_tail,
+        v_wind=v_wind_tail,
+        dt=dt,
     )
-    latitude_tail_t2 = geo.advect_latitude(latitude=latitude_tail, v_wind=v_wind_tail, dt=dt)
 
     azimuth_2 = geo.azimuth(
         lons0=longitude_tail_t2,
@@ -453,8 +450,7 @@ def _evolve_one_step(
     longitude = vector["longitude"]
 
     dt = t - vector["time"]
-    longitude_2 = geo.advect_longitude(longitude, latitude, u_wind, dt)  # type: ignore[arg-type]
-    latitude_2 = geo.advect_latitude(latitude, v_wind, dt)  # type: ignore[arg-type]
+    longitude_2, latitude_2 = geo.advect_horizontal(longitude, latitude, u_wind, v_wind, dt)  # type: ignore[arg-type]
     level_2 = geo.advect_level(
         vector.level,
         vertical_velocity,

pycontrails/models/ps_model/__init__.py

@@ -4,7 +4,7 @@ from pycontrails.models.ps_model.ps_aircraft_params import (
     PSAircraftEngineParams,
     load_aircraft_engine_params,
 )
-from pycontrails.models.ps_model.ps_grid import PSGrid, ps_nominal_grid
+from pycontrails.models.ps_model.ps_grid import PSGrid, ps_nominal_grid, ps_nominal_optimize_mach
 from pycontrails.models.ps_model.ps_model import PSFlight, PSFlightParams
 
 __all__ = [
@@ -14,4 +14,5 @@ __all__ = [
     "PSGrid",
     "load_aircraft_engine_params",
     "ps_nominal_grid",
+    "ps_nominal_optimize_mach",
 ]

pycontrails/models/ps_model/ps_aircraft_params.py

@@ -11,6 +11,7 @@ from typing import Any
 import numpy as np
 import pandas as pd
 
+from pycontrails.core.aircraft_performance import AircraftPerformanceParams
 from pycontrails.physics import constants as c
 
 #: Path to the Poll-Schumann aircraft parameters CSV file.
@@ -193,7 +194,7 @@ def _row_to_aircraft_engine_params(tup: Any) -> tuple[str, PSAircraftEngineParam
 
 @functools.cache
 def load_aircraft_engine_params(
-    engine_deterioration_factor: float = 0.025,
+    engine_deterioration_factor: float = AircraftPerformanceParams.engine_deterioration_factor,
 ) -> Mapping[str, PSAircraftEngineParams]:
     """
     Extract aircraft-engine parameters for each aircraft type supported by the PS model.
@@ -254,7 +255,7 @@ def load_aircraft_engine_params(
     }
 
     df = pd.read_csv(PS_FILE_PATH, dtype=dtypes)
-    df["eta_1"] = df["eta_1"] * (1.0 - engine_deterioration_factor)
+    df["eta_1"] *= 1.0 - engine_deterioration_factor
 
     return dict(_row_to_aircraft_engine_params(tup) for tup in df.itertuples(index=False))