pycontrails 0.50.1__tar.gz → 0.50.2__tar.gz

{pycontrails-0.50.1 → pycontrails-0.50.2}/CHANGELOG.md

@@ -1,6 +1,25 @@
 
 # Changelog
 
+## v0.50.2
+
+### Breaking changes
+
+- Replaces engine-uid `01P10IA024` with `04P10IA027` (superseded in the IACO EDB).
+
+### Features
+
+- Adds support for the `E190` aircraft type in the PS model
+- Adds `Flight.distance_to_coords` which takes in a distance along a flight trajectory in meters and returns geodesic coordinates.
+- Adds methods to `ps_operational_limits` to find the maximum and minimum mach numbers for a given set of operating conditions.
+- Updates ICAO aircraft engine emissions databank (EDB) from v28c to v29b.
+
+### Internals
+
+- New data for gaseous and nvPM emissions for PW812D, PW812GA, RR Trent 7000 with improved nvPM combustor
+- Update nvPM emissions for IAE V2530-A5, PW1500G and PW1900G
+- Update PS model coeffiencts to match the latest version provided by Ian Poll
+
 ## v0.50.1
 
 ### Breaking changes

{pycontrails-0.50.1 → pycontrails-0.50.2}/PKG-INFO

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

{pycontrails-0.50.1 → pycontrails-0.50.2}/docs/notebooks/GFS.ipynb

@@ -19,7 +19,7 @@
     "\n",
     "- [NOAA GFS](https://registry.opendata.aws/noaa-gfs-bdp-pds/) - AWS Open Data Registry\n",
     "- [NCEI GFS Documentation](https://www.ncei.noaa.gov/products/weather-climate-models/global-forecast)\n",
-    "- [NOAA GFS Documentation](https://www.emc.ncep.noaa.gov/emc/pages/numerical_forecast_systems/gfs/documentation.php)\n",
+    "- [NOAA GFS Documentation](https://vlab.noaa.gov/web/gfs/documentation)\n",
     "- [Parameter definitions](https://www.nco.ncep.noaa.gov/pmb/products/gfs/)\n",
     "    \n",
     "See [API Reference](https://py.contrails.org/api.html#gfs) for usage."

{pycontrails-0.50.1 → pycontrails-0.50.2}/pycontrails/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.50.1'
-__version_tuple__ = version_tuple = (0, 50, 1)
+__version__ = version = '0.50.2'
+__version_tuple__ = version_tuple = (0, 50, 2)

{pycontrails-0.50.1 → pycontrails-0.50.2}/pycontrails/core/flight.py

@@ -17,6 +17,7 @@ from pycontrails.core.fuel import Fuel, JetA
 from pycontrails.core.vector import AttrDict, GeoVectorDataset, VectorDataDict, VectorDataset
 from pycontrails.physics import constants, geo, units
 from pycontrails.utils import dependencies
+from pycontrails.utils.types import ArrayOrFloat
 
 logger = logging.getLogger(__name__)
 
@@ -1112,6 +1113,102 @@ class Flight(GeoVectorDataset):
         out.data.pop("level", None)  # avoid any ambiguity
         return out
 
+    def distance_to_coords(self: Flight, distance: ArrayOrFloat) -> tuple[
+        ArrayOrFloat,
+        ArrayOrFloat,
+        np.intp | npt.NDArray[np.intp],
+    ]:
+        """
+        Convert distance along flight path to geodesic coordinates.
+
+        Will return a tuple containing `(lat, lon, index)`, where index indicates which flight
+        segment contains the returned coordinate.
+
+        Parameters
+        ----------
+        distance : ArrayOrFloat
+            Distance along flight path, [:math:`m`]
+
+        Returns
+        -------
+        (ArrayOrFloat, ArrayOrFloat, int | npt.NDArray[int])
+            latitude, longitude, and segment index cooresponding to distance.
+        """
+
+        # Check if flight crosses antimeridian line
+        lon_ = self["longitude"]
+        lat_ = self["latitude"]
+        sign_ = np.sign(lon_)
+        min_pos = np.min(lon_[sign_ == 1.0], initial=np.inf)
+        max_neg = np.max(lon_[sign_ == -1.0], initial=-np.inf)
+
+        if (180.0 - min_pos) + (180.0 + max_neg) < 180.0 and min_pos < np.inf and max_neg > -np.inf:
+            # In this case, we believe the flight crosses the antimeridian
+            shift = min_pos
+            # So we shift the longitude "chart"
+            lon_ = (lon_ - shift) % 360.0
+        else:
+            shift = None
+
+        # Make a fake flight that flies at constant height so distance is just
+        # distance traveled across groud
+        flat_dataset = Flight(
+            longitude=self.coords["longitude"],
+            latitude=self.coords["latitude"],
+            time=self.coords["time"],
+            level=[self.coords["level"][0] for _ in range(self.size)],
+        )
+
+        lengths = flat_dataset.segment_length()
+        cumulative_lengths = np.nancumsum(lengths)
+        cumulative_lengths = np.insert(cumulative_lengths[:-1], 0, 0)
+        seg_idx: np.intp | npt.NDArray[np.intp]
+
+        if isinstance(distance, float):
+            seg_idx = np.argmax(cumulative_lengths > distance)
+        else:
+            seg_idx = np.argmax(cumulative_lengths > distance.reshape((distance.size, 1)), axis=1)
+
+        # If in the last segment (which has length 0), then just return the last waypoint
+        seg_idx -= 1
+
+        # linear interpolation in lat/lon - assuming the way points are within 100-200km so this
+        # should be accurate enough without needed to reproject or use spherical distance
+        lat1: ArrayOrFloat = lat_[seg_idx]
+        lon1: ArrayOrFloat = lon_[seg_idx]
+        lat2: ArrayOrFloat = lat_[seg_idx + 1]
+        lon2: ArrayOrFloat = lon_[seg_idx + 1]
+
+        dx = distance - cumulative_lengths[seg_idx]
+        fx = dx / lengths[seg_idx]
+        lat = (1 - fx) * lat1 + fx * lat2
+        lon = (1 - fx) * lon1 + fx * lon2
+
+        if isinstance(distance, float):
+            if distance < 0:
+                lat = np.nan
+                lon = np.nan
+                seg_idx = np.intp(0)
+            elif distance >= cumulative_lengths[-1]:
+                lat = lat_[-1]
+                lon = lon_[-1]
+                seg_idx = np.intp(self.size - 1)
+        else:
+            lat[distance < 0] = np.nan
+            lon[distance < 0] = np.nan
+            seg_idx[distance < 0] = 0  # type: ignore
+
+            lat[distance >= cumulative_lengths[-1]] = lat_[-1]
+            lon[distance >= cumulative_lengths[-1]] = lon_[-1]
+            seg_idx[distance >= cumulative_lengths[-1]] = self.size - 1  # type: ignore
+
+        if shift is not None:
+            # We need to translate back to the original chart here
+            lon += shift
+            lon = ((lon + 180.0) % 360.0) - 180.0
+
+        return lat, lon, seg_idx
+
     def _geodesic_interpolation(self, geodesic_threshold: float) -> pd.DataFrame | None:
         """Geodesic interpolate between large gaps between waypoints.