pycontrails 0.48.0__cp310-cp310-win_amd64.whl → 0.48.1__cp310-cp310-win_amd64.whl

pycontrails/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.48.0'
-__version_tuple__ = version_tuple = (0, 48, 0)
+__version__ = version = '0.48.1'
+__version_tuple__ = version_tuple = (0, 48, 1)

pycontrails/core/met.py

@@ -96,13 +96,14 @@ class MetBase(ABC, Generic[XArrayType]):
         for dim in self.dim_order:
             if dim not in self.data.dims:
                 if dim == "level":
-                    raise ValueError(
+                    msg = (
                         f"Meteorology data must contain dimension '{dim}'. "
                         "For single level data, set 'level' coordinate to constant -1 "
                         "using `ds = ds.expand_dims({'level': [-1]})`"
                     )
                 else:
-                    raise ValueError(f"Meteorology data must contain dimension '{dim}'.")
+                    msg = f"Meteorology data must contain dimension '{dim}'."
+                raise ValueError(msg)
 
     def _validate_longitude(self) -> None:
         """Check longitude bounds.
@@ -196,15 +197,15 @@ class MetBase(ABC, Generic[XArrayType]):
 
         dims_tuple = tuple(self.dim_order)
 
-        def _check_da(da: xr.DataArray, key: str | None = None) -> None:
+        def _check_da(da: xr.DataArray, key: Hashable | None = None) -> None:
             if da.dims != dims_tuple:
                 if key is not None:
                     msg = (
-                        "Data dimension not transposed on variable '{key}'. Initiate with"
-                        " `copy=True`."
+                        f"Data dimension not transposed on variable '{key}'. Initiate with"
+                        " 'copy=True'."
                     )
                 else:
-                    msg = "Data dimension not transposed. Initiate with `copy=True`."
+                    msg = "Data dimension not transposed. Initiate with 'copy=True'."
                 raise ValueError(msg)
 
         data = self.data
@@ -212,7 +213,7 @@ class MetBase(ABC, Generic[XArrayType]):
             _check_da(data)
             return
 
-        for key, da in self.data.data_vars.items():
+        for key, da in self.data.items():
             _check_da(da, key)
 
     def _validate_dims(self) -> None:
@@ -654,11 +655,9 @@ class MetDataset(MetBase):
         attrs: dict[str, Any] | None = None,
         **attrs_kwargs: Any,
     ) -> None:
-        # init cache
         self.cachestore = cachestore
 
-        data.attrs.update(attrs or {})
-        data.attrs.update(attrs_kwargs)
+        data.attrs.update(attrs or {}, **attrs_kwargs)
 
         # if input is already a Dataset, copy into data
         if not isinstance(data, xr.Dataset):
@@ -872,7 +871,7 @@ class MetDataset(MetBase):
             Raises when dataset does not contain variable in ``vars``
         """
         if isinstance(vars, (MetVariable, str)):
-            vars = [vars]
+            vars = (vars,)
 
         met_keys: list[str] = []
         for variable in vars:
@@ -1372,7 +1371,7 @@ class MetDataArray(MetBase):
         """
         if not self.in_memory:
             self._check_memory("Extracting numpy array from")
-            self.data = self.data.load()
+            self.data.load()
 
         return self.data.values
 
@@ -1618,8 +1617,20 @@ class MetDataArray(MetBase):
         )
 
     def _check_memory(self, msg_start: str) -> None:
+        """Check the memory usage of the underlying data.
+
+        If the data is larger than 4 GB, a warning is issued. If the data is
+        larger than 32 GB, a RuntimeError is raised.
+        """
         n_bytes = self.data.nbytes
+        mb = round(n_bytes / int(1e6), 2)
+        logger.debug("Loading %s into memory consumes %s MB.", self.name, mb)
+
         n_gb = n_bytes // int(1e9)
+        if n_gb <= 4:
+            return
+
+        # Prevent something stupid
         msg = (
             f"{msg_start} MetDataArray {self.name} requires loading "
             f"at least {n_gb} GB of data into memory. Downselect data if possible. "
@@ -1627,13 +1638,9 @@ class MetDataArray(MetBase):
             "with the method 'downselect_met'."
         )
 
-        if n_gb > 32:  # Prevent something stupid
+        if n_gb > 32:
             raise RuntimeError(msg)
-        if n_gb > 4:
-            warnings.warn(msg)
-
-        mb = round(n_bytes / int(1e6), 2)
-        logger.debug("Loading %s into memory consumes %s MB.", self.name, mb)
+        warnings.warn(msg)
 
     def save(self, **kwargs: Any) -> list[str]:
         """Save intermediate to :attr:`cachestore` as netcdf.
@@ -2228,24 +2235,29 @@ def _is_zarr(ds: xr.Dataset | xr.DataArray) -> bool:
     return dask0.array.array.array.__class__.__name__ == "ZarrArrayWrapper"
 
 
-def shift_longitude(data: XArrayType) -> XArrayType:
-    """Shift longitude values from [0, 360) to [-180, 180) domain.
+def shift_longitude(data: XArrayType, bound: float = -180.0) -> XArrayType:
+    """Shift longitude values from any input domain to [bound, 360 + bound) domain.
 
     Sorts data by ascending longitude values.
 
+
     Parameters
     ----------
     data : XArrayType
         :class:`xr.Dataset` or :class:`xr.DataArray` with longitude dimension
+    bound : float, optional
+        Lower bound of the domain.
+        Output domain will be [bound, 360 + bound).
+        Defaults to -180, which results in longitude domain [-180, 180).
 
 
     Returns
     -------
     XArrayType
-        :class:`xr.Dataset` or :class:`xr.DataArray` with longitude values on [-180, 180).
+        :class:`xr.Dataset` or :class:`xr.DataArray` with longitude values on [a, 360 + a).
     """
     return data.assign_coords(
-        longitude=((data["longitude"].values + 180.0) % 360.0) - 180.0
+        longitude=((data["longitude"].values - bound) % 360.0) + bound
     ).sortby("longitude", ascending=True)
 
 

pycontrails/core/met_var.py

@@ -2,10 +2,10 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+import dataclasses
 
 
-@dataclass
+@dataclasses.dataclass(frozen=True)
 class MetVariable:
     """Met variable defined using CF, ECMWF, and WMO conventions.
 

pycontrails/core/models.py

@@ -714,6 +714,11 @@ class Model(ABC):
         except KeyError:
             pass
 
+        try:
+            source.attrs["met_source_forecast_time"] = self.met.attrs["forecast_time"]
+        except KeyError:
+            pass
+
 
 def _interp_grid_to_grid(
     met_key: str,

pycontrails/core/vector.py

@@ -18,7 +18,7 @@ from pycontrails.core import coordinates, interpolation
 from pycontrails.core import met as met_module
 from pycontrails.physics import units
 from pycontrails.utils import dependencies
-from pycontrails.utils import json as json_module
+from pycontrails.utils import json as json_utils
 
 logger = logging.getLogger(__name__)
 
@@ -633,6 +633,8 @@ class VectorDataset:
         8  15  18
 
         """
+        vectors = [v for v in vectors if v]  # remove empty vectors
+
         if not vectors:
             return cls()
 
@@ -753,7 +755,7 @@ class VectorDataset:
         str
             Unique hash for flight instance (sha1)
         """
-        _hash = json.dumps(self.data, cls=json_module.NumpyEncoder)
+        _hash = json.dumps(self.data, cls=json_utils.NumpyEncoder)
         return hashlib.sha1(bytes(_hash, "utf-8")).hexdigest()
 
     # ------------
@@ -982,6 +984,104 @@ class VectorDataset:
         df.attrs = self.attrs
         return df
 
+    def to_dict(self) -> dict[str, Any]:
+        """Create dictionary with :attr:`data` and :attr:`attrs`.
+
+        If geo-spatial coordinates (e.g. `"latitude"`, `"longitude"`, `"altitude"`)
+        are present, round to a reasonable precision. If a `"time"` variable is present,
+        round to unix seconds. When the instance is a :class:`GeoVectorDataset`,
+        disregard any `"altitude"` or `"level"` coordinate and only include
+        `"altitude_ft"`in the output.
+
+        Returns
+        -------
+        dict[str, Any]
+            Dictionary with :attr:`data` and :attr:`attrs`.
+
+        See Also
+        --------
+        :meth:`from_dict`
+
+        Examples
+        --------
+        >>> import pprint
+        >>> from pycontrails import Flight
+        >>> fl = Flight(
+        ...     longitude=[-100, -110],
+        ...     latitude=[40, 50],
+        ...     level=[200, 200],
+        ...     time=[np.datetime64("2020-01-01T09"), np.datetime64("2020-01-01T09:30")],
+        ...     aircraft_type="B737",
+        ... )
+        >>> fl = fl.resample_and_fill("5T")
+        >>> pprint.pprint(fl.to_dict())
+        {'aircraft_type': 'B737',
+         'altitude_ft': [38661.0, 38661.0, 38661.0, 38661.0, 38661.0, 38661.0, 38661.0],
+         'crs': 'EPSG:4326',
+         'latitude': [40.0, 41.724, 43.428, 45.111, 46.769, 48.399, 50.0],
+         'longitude': [-100.0,
+                       -101.441,
+                       -102.959,
+                       -104.563,
+                       -106.267,
+                       -108.076,
+                       -110.0],
+         'time': [1577869200,
+                  1577869500,
+                  1577869800,
+                  1577870100,
+                  1577870400,
+                  1577870700,
+                  1577871000]}
+        """
+        np_encoder = json_utils.NumpyEncoder()
+
+        # round latitude, longitude, and altitude
+        precision = {"longitude": 3, "latitude": 3, "altitude_ft": 0}
+
+        def encode(key: str, obj: Any) -> Any:
+            # Try to handle some pandas objects
+            if hasattr(obj, "to_numpy"):
+                obj = obj.to_numpy()
+
+            # Convert numpy objects to python objects
+            if isinstance(obj, (np.ndarray, np.generic)):
+
+                # round time to unix seconds
+                if key == "time":
+                    return np_encoder.default(obj.astype("datetime64[s]").astype(int))
+
+                # round specific keys in precision
+                try:
+                    d = precision[key]
+                except KeyError:
+                    return np_encoder.default(obj)
+
+                return np_encoder.default(obj.astype(float).round(d))
+
+            # Pass through everything else
+            return obj
+
+        data = {k: encode(k, v) for k, v in self.data.items()}
+        attrs = {k: encode(k, v) for k, v in self.attrs.items()}
+
+        # Only include one of the vertical coordinate keys
+        if isinstance(self, GeoVectorDataset):
+            data.pop("altitude", None)
+            data.pop("level", None)
+            if "altitude_ft" not in data:
+                data["altitude_ft"] = self.altitude_ft.round(precision["altitude_ft"]).tolist()
+
+        # Issue warning if any keys are duplicated
+        common_keys = data.keys() & attrs.keys()
+        if common_keys:
+            warnings.warn(
+                f"Found duplicate keys in data and attrs: {common_keys}. "
+                "Data keys will overwrite attrs keys in returned dictionary."
+            )
+
+        return {**attrs, **data}
+
     @classmethod
     def create_empty(
         cls: Type[VectorDatasetType],
@@ -1010,6 +1110,42 @@ class VectorDataset:
         """
         return cls(data=_empty_vector_dict(keys or set()), attrs=attrs, copy=False, **attrs_kwargs)
 
+    @classmethod
+    def from_dict(
+        cls: Type[VectorDatasetType], obj: dict[str, Any], copy: bool = True, **obj_kwargs: Any
+    ) -> VectorDatasetType:
+        """Create instance from dict representation containing data and attrs.
+
+        Parameters
+        ----------
+        obj : dict[str, Any]
+            Dict representation of VectorDataset (e.g. :meth:`to_dict`)
+        copy : bool, optional
+            Passed to VectorDataset constructor.
+            Defaults to True.
+        **obj_kwargs : Any
+            Additional properties passed as keyword arguments.
+
+        Returns
+        -------
+        VectorDatasetType
+            VectorDataset instance.
+
+        See Also
+        --------
+        :meth:`to_dict`
+        """
+        data = {}
+        attrs = {}
+
+        for k, v in {**obj, **obj_kwargs}.items():
+            if isinstance(v, (list, np.ndarray)):
+                data[k] = v
+            else:
+                attrs[k] = v
+
+        return cls(data=data, attrs=attrs, copy=copy)
+
     def generate_splits(
         self: VectorDatasetType, n_splits: int, copy: bool = True
     ) -> Generator[VectorDatasetType, None, None]:
@@ -1182,7 +1318,7 @@ class GeoVectorDataset(VectorDataset):
         if not np.issubdtype(time.dtype, np.datetime64):
             warnings.warn("Time data is not np.datetime64. Attempting to coerce.")
             try:
-                pd_time = pd.to_datetime(self["time"])
+                pd_time = _handle_time_column(pd.Series(self["time"]))
             except ValueError as e:
                 raise ValueError("Could not coerce time data to datetime64.") from e
             np_time = pd_time.to_numpy(dtype="datetime64[ns]")
@@ -1790,7 +1926,7 @@ class GeoVectorDataset(VectorDataset):
         dict[str, Any]
             Python representation of GeoJSON FeatureCollection
         """
-        return json_module.dataframe_to_geojson_points(self.dataframe)
+        return json_utils.dataframe_to_geojson_points(self.dataframe)
 
     def to_pseudo_mercator(self: GeoVectorDatasetType, copy: bool = True) -> GeoVectorDatasetType:
         """Convert data from :attr:`attrs["crs"]` to Pseudo Mercator (EPSG:3857).
@@ -1913,29 +2049,112 @@ def vector_to_lon_lat_grid(
 
 
 def _handle_time_column(time: pd.Series) -> pd.Series:
+    """Ensure that pd.Series has compatible Timestamps.
+
+    Parameters
+    ----------
+    time : pd.Series
+        Pandas dataframe column labeled "time".
+
+
+    Returns
+    -------
+    pd.Series
+        Parsed pandas time series.
+
+
+    Raises
+    ------
+    ValueError
+        When time series can't be parsed, or is not timezone naive.
+    """
     if not hasattr(time, "dt"):
-        # If the time column is a string, we try to convert it to a datetime
-        # If it fails (for example, a unix integer time), we raise an error
-        # and let the user figure it out.
-        try:
-            return pd.to_datetime(time)
-        except ValueError as exc:
-            raise ValueError(
-                "The 'time' field must hold datetime-like values. "
-                'Try data["time"] = pd.to_datetime(data["time"], unit=...) '
-                "with the appropriate unit."
-            ) from exc
+        time = _parse_pandas_time(time)
 
+    # Translate all times to UTC and then remove timezone.
     # If the time column contains a timezone, the call to `to_numpy`
-    # will convert it to an array of object. We do not want this, so
-    # we raise an error in this case. Timezone issues are complicated,
-    # and so it is better for the user to handle them rather than try
-    # to address them here.
+    # will convert it to an array of object.
+    # Note `.tz_convert(None)` automatically converts to UTC first.
     if time.dt.tz is not None:
-        raise ValueError(
-            "The 'time' field must be timezone naive. "
-            "This can be achieved with: "
-            'data["time"] = data["time"].dt.tz_localize(None)'
-        )
+        time = time.dt.tz_convert(None)
 
     return time
+
+
+def _parse_pandas_time(time: pd.Series) -> pd.Series:
+    """Parse pandas dataframe column labelled "time".
+
+    Parameters
+    ----------
+    time : pd.Series
+        Time series
+
+    Returns
+    -------
+    pd.Series
+        Parsed time series
+
+    Raises
+    ------
+    ValueError
+        When series values can't be inferred.
+    """
+    try:
+        # If the time series is a string, try to convert it to a datetime
+        if time.dtype == "O":
+            return pd.to_datetime(time)
+
+        # If the time is an int, try to parse it as unix time
+        if np.issubdtype(time.dtype, np.integer):
+            return _parse_unix_time(time)
+
+        raise ValueError("Unsupported time format")
+
+    except ValueError as exc:
+        raise ValueError(
+            "The 'time' field must hold datetime-like values. "
+            'Try data["time"] = pd.to_datetime(data["time"], unit=...) '
+            "with the appropriate unit."
+        ) from exc
+
+
+def _parse_unix_time(time: list[int] | npt.NDArray[np.int_] | pd.Series) -> pd.Series:
+    """Parse array of int times as unix epoch timestamps.
+
+    Attempts to parse the time in "s", "ms", "us", "ns"
+
+
+    Parameters
+    ----------
+    time : list[int] | npt.NDArray[np.int_] | pd.Series
+        Sequence of unix timestamps
+
+
+    Returns
+    -------
+    pd.Series
+        Series of timezone naive pandas Timestamps
+
+    Raises
+    ------
+    ValueError
+        When unable to parse time as unix epoch timestamp
+    """
+    units = "s", "ms", "us", "ns"
+    for unit in units:
+        try:
+            out = pd.to_datetime(time, unit=unit, utc=True)
+        except ValueError:
+            continue
+
+        # make timezone naive
+        out = out.dt.tz_convert(None)
+
+        # make sure time is reasonable
+        if (pd.Timestamp("1980-01-01") <= out).all() and (out <= pd.Timestamp("2030-01-01")).all():
+            return out
+
+    raise ValueError(
+        f"Unable to parse time parameter '{time}' as unix epoch timestamp between "
+        "1980-01-01 and 2030-01-01"
+    )

pycontrails/models/cocip/cocip.py

@@ -403,14 +403,13 @@ class Cocip(Model):
         self.contrail_list = []
         self._simulate_contrail_evolution()
 
-        self._cleanup_indices()
-
         if not self.contrail_list:
             logger.debug("No contrails formed by %s", label)
             return self._fill_empty_flight_results(return_flight_list)
 
         logger.debug("Complete contrail simulation for %s", label)
 
+        self._cleanup_indices()
         self._bundle_results()
 
         if return_flight_list:
@@ -1098,12 +1097,20 @@ class Cocip(Model):
 
     @overrides
     def _cleanup_indices(self) -> None:
-        if self.params["interpolation_use_indices"]:
+        """Cleanup interpolation artifacts."""
+
+        if not self.params["interpolation_use_indices"]:
+            return
+
+        if hasattr(self, "contrail_list"):
             for contrail in self.contrail_list:
                 contrail._invalidate_indices()
-            self.source._invalidate_indices()
-            self._sac_flight._invalidate_indices()
+
+        self.source._invalidate_indices()
+        self._sac_flight._invalidate_indices()
+        if hasattr(self, "_downwash_flight"):
             self._downwash_flight._invalidate_indices()
+        if hasattr(self, "_downwash_contrail"):
             self._downwash_contrail._invalidate_indices()
 
     def _bundle_results(self) -> None:
@@ -1115,7 +1122,9 @@ class Cocip(Model):
         self.contrail = pd.concat(dfs)
 
         # add age in hours to the contrail waypoint outputs
-        self.contrail["age_hours"] = self.contrail["age"] / np.timedelta64(1, "h")
+        age_hours = np.empty_like(self.contrail["ef"])
+        np.divide(self.contrail["age"], np.timedelta64(1, "h"), out=age_hours)
+        self.contrail["age_hours"] = age_hours
 
         if self.params["verbose_outputs"]:
             # Compute dt_integration -- logic is somewhat complicated, but
@@ -1140,10 +1149,9 @@ class Cocip(Model):
 
             self.contrail = seq_index.set_index("index")
 
-        # ---
-        # Create contrail xr.Dataset (self.contrail_dataset)
-        # ---
-        if self.params["verbose_outputs"]:
+            # ---
+            # Create contrail xr.Dataset (self.contrail_dataset)
+            # ---
             if isinstance(self.source, Fleet):
                 self.contrail_dataset = xr.Dataset.from_dataframe(
                     self.contrail.set_index(["flight_id", "timestep", "waypoint"])
@@ -1250,9 +1258,11 @@ class Cocip(Model):
         Flight or list[Flight]
             Flight or list of Flight objects with empty variables.
         """
+        self._cleanup_indices()
 
         intersection = self.source.data.pop("_met_intersection")
-        zeros_and_nans = np.where(intersection, 0.0, np.nan)
+        zeros_and_nans = np.zeros(intersection.shape, dtype=np.float32)
+        zeros_and_nans[~intersection] = np.nan
         self.source["ef"] = zeros_and_nans.copy()
         self.source["persistent_1"] = zeros_and_nans.copy()
         self.source["cocip"] = np.sign(zeros_and_nans)

pycontrails/models/cocip/wake_vortex.py

@@ -54,22 +54,24 @@ def max_downward_displacement(
     - :cite:`holzapfelProbabilisticTwoPhaseWake2003`
     - :cite:`schumannContrailCirrusPrediction2012`
     """
-    wingspan_arr = np.broadcast_to(wingspan, true_airspeed.shape)
-    aircraft_mass_arr = np.broadcast_to(aircraft_mass, true_airspeed.shape)
-
     rho_air = thermo.rho_d(air_temperature, air_pressure)
     n_bv = thermo.brunt_vaisala_frequency(air_pressure, air_temperature, dT_dz)
-    t_0 = effective_time_scale(wingspan, true_airspeed, aircraft_mass_arr, rho_air)
+    t_0 = effective_time_scale(wingspan, true_airspeed, aircraft_mass, rho_air)
 
     dz_max_strong = downward_displacement_strongly_stratified(
-        wingspan, true_airspeed, aircraft_mass_arr, rho_air, n_bv
+        wingspan, true_airspeed, aircraft_mass, rho_air, n_bv
     )
 
     is_weakly_stratified = n_bv * t_0 < 0.8
+    if isinstance(wingspan, np.ndarray):
+        wingspan = wingspan[is_weakly_stratified]
+    if isinstance(aircraft_mass, np.ndarray):
+        aircraft_mass = aircraft_mass[is_weakly_stratified]
+
     dz_max_weak = downward_displacement_weakly_stratified(
-        wingspan=wingspan_arr[is_weakly_stratified],
+        wingspan=wingspan,
         true_airspeed=true_airspeed[is_weakly_stratified],
-        aircraft_mass=aircraft_mass_arr[is_weakly_stratified],
+        aircraft_mass=aircraft_mass,
         rho_air=rho_air[is_weakly_stratified],
         n_bv=n_bv[is_weakly_stratified],
         dz_max_strong=dz_max_strong[is_weakly_stratified],

{pycontrails-0.48.0.dist-info → pycontrails-0.48.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycontrails
-Version: 0.48.0
+Version: 0.48.1
 Summary: Python library for modeling aviation climate impacts
 Author-email: Breakthrough Energy <py@contrails.org>
 License: Apache-2.0
@@ -86,6 +86,7 @@ Provides-Extra: goes
 Requires-Dist: cartopy >=0.22 ; extra == 'goes'
 Requires-Dist: gcsfs >=2022.3 ; extra == 'goes'
 Requires-Dist: h5netcdf >=1.2 ; extra == 'goes'
+Requires-Dist: aiohttp >=3.9.0b0 ; (python_version >= "3.12") and extra == 'goes'
 Provides-Extra: jupyter
 Requires-Dist: ipywidgets >=7.6 ; extra == 'jupyter'
 Requires-Dist: jupyterlab >=2.2 ; extra == 'jupyter'

{pycontrails-0.48.0.dist-info → pycontrails-0.48.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pycontrails/__init__.py,sha256=9HSzyDmy_173EPUcGk7kFMyvb3D7tAp8-sr5oZ4dMno,2033
-pycontrails/_version.py,sha256=3TGjKXUAUxgL7pRiVz99oj4qjIPtk8m-UHuEcOKc6zE,429
+pycontrails/_version.py,sha256=QlIinKPPwwIiHTXQ93n3zRDz5L4NRpaoBRvxPVIdkOo,429
 pycontrails/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pycontrails/core/__init__.py,sha256=eNypVTz1kHBSKAJX3CgfKw-VKrMRRkKTutmjSlrfeUs,870
 pycontrails/core/aircraft_performance.py,sha256=RgeO7kSwgB3amFYBqbyFKdvMiKii4y7QjoUxBWCoJAc,22699
@@ -12,12 +12,12 @@ pycontrails/core/flight.py,sha256=XFDH1k-Xg2h2dJ0sqNTrwGBPyCBfmQazfoFMSlqGwLY,73
 pycontrails/core/flightplan.py,sha256=DJ7-uHsS679RnB8C5u8s_rxeM_B-vkd2KhpPpArn9R0,7881
 pycontrails/core/fuel.py,sha256=tSavf34pbGdRJzHez8hEZqLe9MVyfZ1qOzxPRhwrH_E,4179
 pycontrails/core/interpolation.py,sha256=Eag6saurCnXz7L-LbXLptkbkahRHEDdYD-CF5XriK7g,24377
-pycontrails/core/met.py,sha256=mj3M0pY-ThmusOMfkpmQaVXSLEaQoIh_iGh-Bj1966I,91355
-pycontrails/core/met_var.py,sha256=UqGFkC_3PrLWJYy8at8EEQUVPlm62lgMQhxxAJMcUd0,9492
-pycontrails/core/models.py,sha256=EEf7LzXF4aDLXKNI3TMn_Vx-Wmjh7ek2QgzmW8OOopU,39305
+pycontrails/core/met.py,sha256=FpMgp3j8MyqT90e6yuItZ3EFuzIJ6leeZHvZ2V_Mavw,91778
+pycontrails/core/met_var.py,sha256=ZGvnYCXWnr0-A-bLmuhl1y2GIdL1X6pbzM-D-kcDpBg,9502
+pycontrails/core/models.py,sha256=SjaKc2hgtOrV4kWrnsaPMedyFd2YyaljMP7tzdub5W4,39453
 pycontrails/core/polygon.py,sha256=7vuuSASg0iBzj_tLG1zjwUD_zi4d6p9Ev7FVldic4wA,17846
-pycontrails/core/rgi_cython.cp310-win_amd64.pyd,sha256=KEgAgAXpHHKzuRXAhCPexSA_s9E950UN17m3ghkRCd4,243200
-pycontrails/core/vector.py,sha256=9CO9K9J-z4So8YA4ezVtCz7V8Fx0bLlOXuZP42oQe7Q,66016
+pycontrails/core/rgi_cython.cp310-win_amd64.pyd,sha256=g5c2VjisybQjSTv-ysNJMvMuuR7advzwAKfyEQCUyCU,243200
+pycontrails/core/vector.py,sha256=QRYK_SWcV92EdQyM9XUA8y5eMwOIPbZSy80R98KC0bU,72560
 pycontrails/datalib/__init__.py,sha256=WnXqgv20SrHZLjFZ9qpQEwRnf0QvfZU-YvMqh7PAUwg,246
 pycontrails/datalib/goes.py,sha256=L7bNr_ZvRC-4kW_cZtCuzwW0cm-8wwxqTP8eIW40MFU,26911
 pycontrails/datalib/ecmwf/__init__.py,sha256=7-05ELdTfcX6N-yhwe-fGH4E7FlBW9Hjx5aAXPZiTpc,1151
@@ -44,14 +44,14 @@ pycontrails/models/pcr.py,sha256=2rpgU8lGwtewfLJFvSF6Pl0FEXprJ42P8N-86dAByDs,562
 pycontrails/models/sac.py,sha256=bNohLpXUfsz6z0CftWm1mJEKt27NRuOnmEUz4TfK4z8,16538
 pycontrails/models/tau_cirrus.py,sha256=eXt3yRrcFBaZNNeH6ZOuU4XEZU2rOfrLKEOC7f0_Ywo,5194
 pycontrails/models/cocip/__init__.py,sha256=X_MlkJzQ-henQ0xGq-1bfCMajH6s9tlK5QLnN7yfQ68,929
-pycontrails/models/cocip/cocip.py,sha256=HYjNTF07h_PZXm_HZufbFnNKEjIhKaClDurpKCHDOaY,93803
+pycontrails/models/cocip/cocip.py,sha256=ZnPucfHfPwOmZygAFlgEsMJAfI_nSrc2UedTMNyMLe4,94171
 pycontrails/models/cocip/cocip_params.py,sha256=PN1EQ-VMtvoYjXWamRO85PPXp9lJ93NxeSG3S56fCjc,10553
 pycontrails/models/cocip/cocip_uncertainty.py,sha256=ma4ZHZS5stCyJgVlCb1Vy-QjSbyaxG5PU4fr4ifr3Wg,12067
 pycontrails/models/cocip/contrail_properties.py,sha256=TetleS9yKpePS-iswW71rW6hp5AtmaB5nNUomvo7Qos,57540
 pycontrails/models/cocip/output_formats.py,sha256=LYD6b_M_qX092r1PuyDcxs06GmYNYrcGl40gzGcL4B8,79196
 pycontrails/models/cocip/radiative_forcing.py,sha256=rsxgbgacAdjvlGFyQPSrROT7Q8QUE53d08g5Jb8M8WU,46061
 pycontrails/models/cocip/radiative_heating.py,sha256=VF1FmZTw3ZOPLG_IIXYEepQaDqOVV_ClOgwGWjqICDs,19232
-pycontrails/models/cocip/wake_vortex.py,sha256=f5aLm5-vRN7Tuc36P5nMrZR3R6OtbpZF4TDwkFDiI5k,13692
+pycontrails/models/cocip/wake_vortex.py,sha256=a_LcCcpGFfsKzMPIK9BxRkOwf17zE3m4T5AxTXV79YI,13689
 pycontrails/models/cocip/wind_shear.py,sha256=FkDWfoazSxyMQVE3dBEat4Yai3EUv_UYl0MXhJkIZBA,3972
 pycontrails/models/cocipgrid/__init__.py,sha256=OYSdZ1Htbr_IP7N_HuOAj1Pa_KLHtdEeJfXP-cN-gnU,271
 pycontrails/models/cocipgrid/cocip_grid.py,sha256=YDb8Ndh2WvT1heuGTdOR8zz8Bqw5eq-Scfp8RKwaIXY,86198
@@ -84,9 +84,9 @@ pycontrails/utils/iteration.py,sha256=jSII_Eb0kvDZz1uPiulTKVB4E0v3XJQurbSzpHqrFI
 pycontrails/utils/json.py,sha256=d2MJutSd4ZtVQFco70lURA2zuokFGryaTdKmjePd2qM,6180
 pycontrails/utils/temp.py,sha256=4S2BeY2mR5W_3gap3RyzQQmjwyuhJa7sOo68J1VrmWA,1150
 pycontrails/utils/types.py,sha256=3e9sOyFnLD-9xRr2dN4hMFnM6YWBycPohHu-OLKP1tE,4730
-pycontrails-0.48.0.dist-info/LICENSE,sha256=HVr8JnZfTaA-12BfKUQZi5hdrB3awOwLWs5X_ga5QzA,10353
-pycontrails-0.48.0.dist-info/METADATA,sha256=5mH5b9cp3lZ3Ovc22yFEj0zuz4SLtVOVEYZkDI11jYg,8502
-pycontrails-0.48.0.dist-info/NOTICE,sha256=qYeNEp8OjDK5jSW3hTlr9LQRjZeEhXQm0zDei5UFaYs,1969
-pycontrails-0.48.0.dist-info/WHEEL,sha256=yrvteVAZzxQvtDnzdCRh4dP01sPIxYhLXIXplC7o50E,102
-pycontrails-0.48.0.dist-info/top_level.txt,sha256=Z8J1R_AiBAyCVjNw6jYLdrA68PrQqTg0t3_Yek_IZ0Q,29
-pycontrails-0.48.0.dist-info/RECORD,,
+pycontrails-0.48.1.dist-info/LICENSE,sha256=HVr8JnZfTaA-12BfKUQZi5hdrB3awOwLWs5X_ga5QzA,10353
+pycontrails-0.48.1.dist-info/METADATA,sha256=p0gBPB6gJHHoXsFMNAO2tzsDtwQ8KBOKXbEj9mgo-mw,8585
+pycontrails-0.48.1.dist-info/NOTICE,sha256=qYeNEp8OjDK5jSW3hTlr9LQRjZeEhXQm0zDei5UFaYs,1969
+pycontrails-0.48.1.dist-info/WHEEL,sha256=QZRFZfINHXboTe9fmBqbFIViCGEqzQrgdxTyahla7mM,102
+pycontrails-0.48.1.dist-info/top_level.txt,sha256=Z8J1R_AiBAyCVjNw6jYLdrA68PrQqTg0t3_Yek_IZ0Q,29
+pycontrails-0.48.1.dist-info/RECORD,,

{pycontrails-0.48.0.dist-info → pycontrails-0.48.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.41.3)
 Root-Is-Purelib: false
 Tag: cp310-cp310-win_amd64