pyepwmorph 3.0.0__tar.gz → 3.1.0__tar.gz

{pyepwmorph-3.0.0 → pyepwmorph-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyepwmorph
-Version: 3.0.0
+Version: 3.1.0
 Summary: A python package to enable simple and easy gathering of climate model data and morphing of EPW files
 Project-URL: Homepage, https://github.com/justinfmccarty/pyepwmorph
 Project-URL: Issues, https://github.com/justinfmccarty/pyepwmorph/issues
@@ -51,6 +51,7 @@ A Python package for morphing EnergyPlus Weather (EPW) files with climate model
 
 - **CMIP6 data** fetched automatically from Google Cloud (Pangeo)
 - **Custom CSV data** from any climate model, including historical reconstructions
+- **CH2025 station scenarios** for Switzerland, shipped with the package and indexed by global warming level
 
 ## Installation
 
@@ -128,6 +129,29 @@ Custom CSVs should have a `date` column (parseable by pandas) and a column named
 
 The reference and target scenarios must cover **different years**, the same way the CMIP6 `historical` and `sspXXX` experiments do. The two series are concatenated before the baseline and target periods are sliced out, so overlapping years get averaged together and weaken the climate signal. Keep `baseline_range` inside the years the reference scenario covers.
 
+### Switzerland (CH2025 warming levels)
+
+For an EPW inside Switzerland, `data_source="ch2025"` morphs from MeteoSwiss CH2025 station scenarios. There is no target year: each pathway is a global warming level relative to 1991-2020, and the run is offline.
+
+```python
+results = workflow.morphing_workflow(
+    project_name="Zurich_GWL2",
+    epw_file="zurich.epw",
+    user_variables=["Temperature", "Humidity", "Wind", "Radiation", "Dew Point"],
+    user_pathways=["GWL 2.0"],
+    percentiles=[50],
+    output_directory="output/",
+    data_source="ch2025",
+)
+morphed = results["gwl2.0"]["50"]
+```
+
+The site is matched to the nearest station that has the requested variables (or, with `ch2025_full_coverage=True`, the nearest station that has every CH2025 variable), with an elevation penalty so a much higher station is not chosen just because it is close on the map. Supported variables are temperature, humidity, dew point, wind, and radiation (global, diffuse, and direct). Pressure and cloud cover are not in CH2025; requesting them raises an error. Sky cover is left at the EPW's baseline values when radiation is morphed, so longwave sky temperature in EnergyPlus does not follow the shortwave change.
+
+The signal is the change from the 1991-2020 reference climate to the chosen warming level. Each model chain's change is computed first, over the chains that reach that warming level, and the percentiles are taken of those changes. If the EPW's years fall outside 1991-2020, a `UserWarning` recommends a TMY built from 1991-2020 data and the signal is still applied to the file as it stands. The same caveats are listed in `MorphConfig.ch2025_notes` and the matched station in `MorphConfig.ch2025_station`.
+
+CH2025 data: MeteoSwiss & ETH Zurich (2025), Climate CH2025 - Daily Datasets, CC-BY 4.0, https://doi.org/10.18751/climate/scenarios/ch2025/data/1.0/
+
 ## Climate scenarios
 
 | Scenario              | SSP    | Description                             | Expected warming |
@@ -143,15 +167,16 @@ The reference and target scenarios must cover **different years**, the same way
 - **Humidity** -- relative humidity, stretched in specific humidity space
 - **Pressure** -- atmospheric pressure (shift)
 - **Wind** -- wind speed (stretch)
-- **Clouds and Radiation** -- global/diffuse/direct radiation and sky cover
+- **Radiation** -- global/diffuse/direct radiation, without changing sky cover (all sources; the only radiation option for CH2025)
+- **Clouds and Radiation** -- global/diffuse/direct radiation and sky cover (CMIP6 and custom data)
 - **Dew Point** -- recalculated from morphed temperature and humidity
 
 ### Variable dependencies
 
 Some variables cannot be morphed on their own:
 
-- **Humidity** requires Temperature and Pressure
-- **Dew Point** requires Temperature, Humidity, and Pressure
+- **Humidity** requires Temperature and Pressure, except with CH2025, where relative humidity is stretched directly
+- **Dew Point** requires Temperature, Humidity, and Pressure (Temperature and Humidity only with CH2025)
 
 Dependencies are added automatically and are **written to the output file**. Asking for `Dew Point` alone therefore returns an EPW with morphed pressure, temperature, relative humidity, and dew point, which keeps the file internally consistent. `MorphConfig.resolved_variables` shows exactly what will be written, in the order it is computed.
 
@@ -220,7 +245,7 @@ See [CHANGELOG.md](CHANGELOG.md) for the full history. The most recent release c
 
 - Python >= 3.9
 - pandas >= 2.2
-- Internet connection (for CMIP6 data download; the custom CSV workflow runs offline)
+- Internet connection (for CMIP6 data download; the custom CSV and CH2025 workflows run offline)
 
 ## License
 

{pyepwmorph-3.0.0 → pyepwmorph-3.1.0}/README.md

@@ -12,6 +12,7 @@ A Python package for morphing EnergyPlus Weather (EPW) files with climate model
 
 - **CMIP6 data** fetched automatically from Google Cloud (Pangeo)
 - **Custom CSV data** from any climate model, including historical reconstructions
+- **CH2025 station scenarios** for Switzerland, shipped with the package and indexed by global warming level
 
 ## Installation
 
@@ -89,6 +90,29 @@ Custom CSVs should have a `date` column (parseable by pandas) and a column named
 
 The reference and target scenarios must cover **different years**, the same way the CMIP6 `historical` and `sspXXX` experiments do. The two series are concatenated before the baseline and target periods are sliced out, so overlapping years get averaged together and weaken the climate signal. Keep `baseline_range` inside the years the reference scenario covers.
 
+### Switzerland (CH2025 warming levels)
+
+For an EPW inside Switzerland, `data_source="ch2025"` morphs from MeteoSwiss CH2025 station scenarios. There is no target year: each pathway is a global warming level relative to 1991-2020, and the run is offline.
+
+```python
+results = workflow.morphing_workflow(
+    project_name="Zurich_GWL2",
+    epw_file="zurich.epw",
+    user_variables=["Temperature", "Humidity", "Wind", "Radiation", "Dew Point"],
+    user_pathways=["GWL 2.0"],
+    percentiles=[50],
+    output_directory="output/",
+    data_source="ch2025",
+)
+morphed = results["gwl2.0"]["50"]
+```
+
+The site is matched to the nearest station that has the requested variables (or, with `ch2025_full_coverage=True`, the nearest station that has every CH2025 variable), with an elevation penalty so a much higher station is not chosen just because it is close on the map. Supported variables are temperature, humidity, dew point, wind, and radiation (global, diffuse, and direct). Pressure and cloud cover are not in CH2025; requesting them raises an error. Sky cover is left at the EPW's baseline values when radiation is morphed, so longwave sky temperature in EnergyPlus does not follow the shortwave change.
+
+The signal is the change from the 1991-2020 reference climate to the chosen warming level. Each model chain's change is computed first, over the chains that reach that warming level, and the percentiles are taken of those changes. If the EPW's years fall outside 1991-2020, a `UserWarning` recommends a TMY built from 1991-2020 data and the signal is still applied to the file as it stands. The same caveats are listed in `MorphConfig.ch2025_notes` and the matched station in `MorphConfig.ch2025_station`.
+
+CH2025 data: MeteoSwiss & ETH Zurich (2025), Climate CH2025 - Daily Datasets, CC-BY 4.0, https://doi.org/10.18751/climate/scenarios/ch2025/data/1.0/
+
 ## Climate scenarios
 
 | Scenario              | SSP    | Description                             | Expected warming |
@@ -104,15 +128,16 @@ The reference and target scenarios must cover **different years**, the same way
 - **Humidity** -- relative humidity, stretched in specific humidity space
 - **Pressure** -- atmospheric pressure (shift)
 - **Wind** -- wind speed (stretch)
-- **Clouds and Radiation** -- global/diffuse/direct radiation and sky cover
+- **Radiation** -- global/diffuse/direct radiation, without changing sky cover (all sources; the only radiation option for CH2025)
+- **Clouds and Radiation** -- global/diffuse/direct radiation and sky cover (CMIP6 and custom data)
 - **Dew Point** -- recalculated from morphed temperature and humidity
 
 ### Variable dependencies
 
 Some variables cannot be morphed on their own:
 
-- **Humidity** requires Temperature and Pressure
-- **Dew Point** requires Temperature, Humidity, and Pressure
+- **Humidity** requires Temperature and Pressure, except with CH2025, where relative humidity is stretched directly
+- **Dew Point** requires Temperature, Humidity, and Pressure (Temperature and Humidity only with CH2025)
 
 Dependencies are added automatically and are **written to the output file**. Asking for `Dew Point` alone therefore returns an EPW with morphed pressure, temperature, relative humidity, and dew point, which keeps the file internally consistent. `MorphConfig.resolved_variables` shows exactly what will be written, in the order it is computed.
 
@@ -181,7 +206,7 @@ See [CHANGELOG.md](CHANGELOG.md) for the full history. The most recent release c
 
 - Python >= 3.9
 - pandas >= 2.2
-- Internet connection (for CMIP6 data download; the custom CSV workflow runs offline)
+- Internet connection (for CMIP6 data download; the custom CSV and CH2025 workflows run offline)
 
 ## License
 

pyepwmorph-3.1.0/pyepwmorph/data/__init__.py

@@ -0,0 +1 @@
+"""Shipped climate datasets."""

{pyepwmorph-3.0.0 → pyepwmorph-3.1.0}/pyepwmorph/models/assemble.py

@@ -109,3 +109,27 @@ def calc_model_climatologies(baseline_range, future_range, baseline_data, future
 
 
     return baseline_means, future_means
+
+
+def calc_gwl_climatologies(baseline_data, future_data, variable):
+    """Return CH2025 monthly climatologies unchanged.
+
+    A warming-level state is already a stationary 30-year sample, so there
+    is no year range to slice the way ``calc_model_climatologies`` does for
+    a transient CMIP6 run.
+
+    Parameters
+    ----------
+    baseline_data : pd.Series
+        Twelve monthly values for the reference state.
+    future_data : pd.Series
+        Twelve monthly values for the warming-level state.
+    variable : str
+        Name used to rename both series.
+
+    Returns
+    -------
+    tuple
+        ``(baseline_data, future_data)``, each renamed to *variable*.
+    """
+    return baseline_data.rename(variable), future_data.rename(variable)

pyepwmorph-3.1.0/pyepwmorph/models/ch2025.py

@@ -0,0 +1,303 @@
+"""Offline access to MeteoSwiss CH2025 station scenarios.
+
+The monthly climatologies in ``pyepwmorph/data`` are reduced from the
+DAILY-LOCAL product. Each row is one model chain's mean for a calendar
+month, over the 30 synthetic climate years of a reference state or a
+global warming level.
+
+CH2025 data © MeteoSwiss & ETH Zurich, licensed CC-BY 4.0.
+https://doi.org/10.18751/climate/scenarios/ch2025/data/1.0/
+"""
+
+import logging
+from functools import lru_cache
+from importlib.resources import files
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+#: (west, south, east, north) of the CH2025 gridded domain, in degrees.
+CH2025_BBOX = (5.96, 45.82, 10.49, 47.81)
+
+CH2025_REFERENCE = "ref91-20"
+CH2025_BASELINE_RANGE = (1991, 2020)
+CH2025_STATES = ("gwl1.5", "gwl2.0", "gwl2.5", "gwl3.0")
+CH2025_VARIABLES = frozenset({"tas", "tasmax", "tasmin", "hurs", "rsds", "sfcWind"})
+
+#: Variables whose change is a difference (future - reference). The others
+#: (``hurs``, ``rsds``, ``sfcWind``) change as a ratio, matching how the
+#: morphing procedures apply them.
+CH2025_ADDITIVE_VARIABLES = frozenset({"tas", "tasmax", "tasmin"})
+
+#: Short attribution written into morphed EPW comments. No commas: EPW
+#: header fields are comma delimited.
+CH2025_CITATION = (
+    "CH2025 (c) MeteoSwiss and ETH Zurich CC-BY 4.0 "
+    "doi:10.18751/climate/scenarios/ch2025/data/1.0"
+)
+
+#: Kilometres of horizontal distance treated as equal to 100 m of elevation,
+#: so a station far below or above the site loses to a nearer-altitude one.
+DEFAULT_ELEVATION_WEIGHT_KM_PER_100M = 10.0
+WARN_DISTANCE_KM = 25.0
+WARN_ELEVATION_M = 300.0
+
+
+def _read_parquet(name: str) -> pd.DataFrame:
+    resource = files("pyepwmorph.data").joinpath(name)
+    with resource.open("rb") as handle:
+        return pd.read_parquet(handle)
+
+
+@lru_cache(maxsize=1)
+def load_table() -> pd.DataFrame:
+    """Return the shipped monthly climatology table.
+
+    Columns are ``station_id``, ``variable``, ``state``, ``chain``,
+    ``month``, and ``value``. The frame is cached; do not mutate it.
+    """
+    return _read_parquet("ch2025_monthly.parquet")
+
+
+@lru_cache(maxsize=1)
+def _load_stations() -> pd.DataFrame:
+    return _read_parquet("ch2025_stations.parquet")
+
+
+def available_stations(variables=None) -> pd.DataFrame:
+    """Return stations, optionally limited to those carrying every variable.
+
+    Parameters
+    ----------
+    variables : iterable of str or None
+        Model variable ids that a station must provide. ``None`` returns
+        every station in the shipped table.
+    """
+    stations = _load_stations().copy()
+    if variables is None:
+        return stations.reset_index(drop=True)
+    needed = set(variables)
+    mask = stations["variables"].map(lambda present: needed <= set(present))
+    return stations.loc[mask].reset_index(drop=True)
+
+
+def reference_key(state: str) -> str:
+    """Key under which the reference paired with *state* is stored.
+
+    Each warming level is compared with the reference over the model chains
+    the two share, so the reference climatology differs per warming level.
+    """
+    return f"{CH2025_REFERENCE}|{state}"
+
+
+def baseline_matches(baseline_range) -> bool:
+    """Return whether an EPW baseline lies inside the CH2025 reference period."""
+    start, end = (int(year) for year in baseline_range)
+    ref_start, ref_end = CH2025_BASELINE_RANGE
+    return ref_start <= start and end <= ref_end
+
+
+def in_switzerland(latitude: float, longitude: float) -> bool:
+    """Return whether a point lies inside the CH2025 domain."""
+    west, south, east, north = CH2025_BBOX
+    return south <= latitude <= north and west <= longitude <= east
+
+
+def _haversine_km(latitude, longitude, latitudes, longitudes) -> np.ndarray:
+    radius = 6371.0
+    lat1 = np.radians(latitude)
+    lat2 = np.radians(np.asarray(latitudes, dtype=float))
+    dlat = lat2 - lat1
+    dlon = np.radians(np.asarray(longitudes, dtype=float) - longitude)
+    a = np.sin(dlat / 2.0) ** 2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon / 2.0) ** 2
+    return 2.0 * radius * np.arcsin(np.sqrt(np.clip(a, 0.0, 1.0)))
+
+
+def nearest_station(
+    latitude: float,
+    longitude: float,
+    elevation: float,
+    variables=None,
+    elevation_weight_km_per_100m: float = DEFAULT_ELEVATION_WEIGHT_KM_PER_100M,
+) -> pd.Series:
+    """Pick the station that best matches a site.
+
+    The score is horizontal distance plus an elevation penalty, so a
+    station hundreds of metres higher loses to one farther away at a
+    similar altitude. Only stations that carry every requested variable
+    are eligible.
+
+    Returns
+    -------
+    pd.Series
+        The station row, with ``distance_km`` and ``elevation_difference_m``.
+    """
+    candidates = available_stations(variables)
+    if candidates.empty:
+        needed = ", ".join(sorted(variables or []))
+        raise ValueError(f"No CH2025 station provides {needed or 'any variables'}")
+
+    distance = _haversine_km(
+        latitude, longitude, candidates["latitude"], candidates["longitude"],
+    )
+    elevation_difference = candidates["elevation"].to_numpy(dtype=float) - float(elevation)
+    penalty = np.abs(elevation_difference) / 100.0 * elevation_weight_km_per_100m
+    position = int(np.argmin(distance + penalty))
+    chosen = candidates.iloc[position].copy()
+    chosen["distance_km"] = float(distance[position])
+    chosen["elevation_difference_m"] = float(elevation_difference[position])
+    chosen["weak_match"] = bool(
+        chosen["distance_km"] > WARN_DISTANCE_KM
+        or abs(chosen["elevation_difference_m"]) > WARN_ELEVATION_M
+    )
+
+    logger.info(
+        "CH2025 station %s (%s): %.1f km away, %+.0f m elevation",
+        chosen["station_id"],
+        chosen["name"],
+        chosen["distance_km"],
+        chosen["elevation_difference_m"],
+    )
+    if chosen["weak_match"]:
+        logger.warning(
+            "CH2025 station %s is a weak match (%.1f km, %+.0f m). "
+            "The morphed file uses that station's climate signal.",
+            chosen["station_id"],
+            chosen["distance_km"],
+            chosen["elevation_difference_m"],
+        )
+    return chosen
+
+
+def _check_variable(variable):
+    if variable not in CH2025_VARIABLES:
+        raise ValueError(
+            f"Variable '{variable}' is not in the CH2025 station table. "
+            f"Available: {sorted(CH2025_VARIABLES)}"
+        )
+
+
+def _chains_by_month(station_id, variable, state) -> pd.DataFrame:
+    """Return a month x chain table for one station, variable, and state."""
+    table = load_table()
+    subset = table[
+        (table["station_id"] == station_id)
+        & (table["variable"] == variable)
+        & (table["state"] == state)
+    ]
+    if subset.empty:
+        raise ValueError(
+            f"No CH2025 data for station '{station_id}', variable '{variable}', state '{state}'"
+        )
+    return subset.pivot(index="month", columns="chain", values="value").sort_index()
+
+
+def build_ch2025_change_ensemble(percentiles, variable, station_id, state):
+    """Build reference and warming-level climatologies from paired chain changes.
+
+    Each model chain's change from the reference to *state* is computed
+    first, over the chains present in both, and the percentiles are taken
+    of those changes. Taking percentiles of each state separately and
+    differencing them would mix chains, and at the tails can even flip the
+    sign of the change.
+
+    The reference returned is the median of the paired chains, the same for
+    every percentile column. The warming-level frame is that reference plus
+    the percentile change (temperatures) or times the percentile ratio
+    (humidity, radiation, wind), so the morphing procedures recover exactly
+    the percentile change.
+
+    Parameters
+    ----------
+    percentiles : list
+        Ensemble percentiles. Column labels match these values.
+    variable : str
+        One of ``CH2025_VARIABLES``.
+    station_id : str
+        Lower-case station abbreviation, for example ``"sma"``.
+    state : str
+        A warming level such as ``"gwl2.0"``.
+
+    Returns
+    -------
+    tuple[pd.DataFrame, pd.DataFrame]
+        ``(reference, future)``, each with twelve rows (months 1-12) and one
+        column per percentile. ``attrs["n_chains"]`` on both records how many
+        paired chains contributed.
+    """
+    _check_variable(variable)
+    reference = _chains_by_month(station_id, variable, CH2025_REFERENCE)
+    future = _chains_by_month(station_id, variable, state)
+    common = reference.columns.intersection(future.columns)
+    if len(common) == 0:
+        raise ValueError(
+            f"No CH2025 model chain provides both {CH2025_REFERENCE} and {state} "
+            f"for station '{station_id}', variable '{variable}'"
+        )
+    reference = reference[common]
+    future = future[common]
+    baseline = reference.median(axis=1)
+
+    if variable in CH2025_ADDITIVE_VARIABLES:
+        change = future - reference
+    else:
+        ref_values = reference.to_numpy(dtype=float)
+        change = pd.DataFrame(
+            np.divide(
+                future.to_numpy(dtype=float), ref_values,
+                out=np.ones_like(ref_values), where=ref_values != 0,
+            ),
+            index=reference.index, columns=reference.columns,
+        )
+
+    reference_frame = pd.DataFrame({percentile: baseline for percentile in percentiles})
+    future_columns = {}
+    for percentile in percentiles:
+        quantile = change.quantile(int(percentile) / 100.0, axis=1)
+        if variable in CH2025_ADDITIVE_VARIABLES:
+            future_columns[percentile] = baseline + quantile
+        else:
+            future_columns[percentile] = baseline * quantile
+    future_frame = pd.DataFrame(future_columns)
+
+    for frame in (reference_frame, future_frame):
+        frame.index.name = "month"
+        frame.attrs["n_chains"] = int(len(common))
+    return reference_frame, future_frame
+
+
+def build_ch2025_ensemble(percentiles, variable, station_id, state) -> pd.DataFrame:
+    """Reduce one station, variable, and state to percentile climatologies.
+
+    Parameters
+    ----------
+    percentiles : list
+        Ensemble percentiles. Column labels match these values, as in
+        ``assemble.build_cmip6_ensemble``.
+    variable : str
+        One of ``CH2025_VARIABLES``.
+    station_id : str
+        Lower-case station abbreviation, for example ``"sma"``.
+    state : str
+        ``"ref91-20"`` or a warming level such as ``"gwl2.0"``.
+
+    Returns
+    -------
+    pd.DataFrame
+        Twelve rows (months 1-12) and one column per percentile.
+        ``attrs["n_chains"]`` records how many model chains contributed.
+        Membership differs by variable and warming level.
+
+    Morphing does not use this: differencing two separately reduced states
+    mixes model chains. See ``build_ch2025_change_ensemble``.
+    """
+    _check_variable(variable)
+    wide = _chains_by_month(station_id, variable, state)
+    result = pd.DataFrame(
+        {percentile: wide.quantile(int(percentile) / 100.0, axis=1) for percentile in percentiles}
+    )
+    result.index.name = "month"
+    result.attrs["n_chains"] = int(wide.shape[1])
+    return result

{pyepwmorph-3.0.0 → pyepwmorph-3.1.0}/pyepwmorph/morph/procedures.py

@@ -221,6 +221,34 @@ def morph_relhum(present_relhum, present_psl, present_dbt, future_psl, future_db
     return _as_series(np.clip(morphed_relhum, 1, 100), index, "relhum_percent")
 
 
+def morph_relhum_direct(present_relhum, future_hurs, baseline_hurs):
+    """Stretch relative humidity by the modelled relative-humidity ratio.
+
+    CH2025 provides ``hurs`` directly, so the specific-humidity round trip
+    used by ``morph_relhum`` is not needed.
+
+    Parameters
+    ----------
+    present_relhum : pd.Series
+        Hourly present-day relative humidity in percent.
+    future_hurs : pd.Series
+        Twelve monthly future relative-humidity values.
+    baseline_hurs : pd.Series
+        Twelve monthly baseline relative-humidity values.
+
+    Returns
+    -------
+    pd.Series
+        Morphed relative humidity, clipped to ``[1, 100]``.
+    """
+    index = present_relhum.index
+    ratio = morph_utils.relative_delta(
+        morph_utils.as_array(future_hurs, 12), morph_utils.as_array(baseline_hurs, 12),
+    )
+    morphed = stretch(present_relhum.to_numpy(dtype=float), morph_utils.month_factors(index, ratio))
+    return _as_series(np.clip(morphed, 1, 100), index, "relhum_percent")
+
+
 def morph_psl(present_psl, future_psl, baseline_psl):
     """
     Pressure at sea level morph requires a shift
@@ -327,6 +355,31 @@ def morph_wspd(present_wspd, future_vas, baseline_vas, future_uas, baseline_uas)
     return _as_series(np.clip(morphed_wspd, 0, None), index, "windspd_ms")
 
 
+def morph_wspd_direct(present_wspd, future_sfcwind, baseline_sfcwind):
+    """Stretch wind speed by a scalar surface-wind ratio.
+
+    Parameters
+    ----------
+    present_wspd : pd.Series
+        Hourly present-day wind speed in m/s.
+    future_sfcwind : pd.Series
+        Twelve monthly future surface wind speeds.
+    baseline_sfcwind : pd.Series
+        Twelve monthly baseline surface wind speeds.
+
+    Returns
+    -------
+    pd.Series
+        Morphed wind speed, clipped at zero.
+    """
+    index = present_wspd.index
+    ratio = morph_utils.relative_delta(
+        morph_utils.as_array(future_sfcwind, 12), morph_utils.as_array(baseline_sfcwind, 12),
+    )
+    morphed = stretch(present_wspd.to_numpy(dtype=float), morph_utils.month_factors(index, ratio))
+    return _as_series(np.clip(morphed, 0, None), index, "windspd_ms")
+
+
 def morph_glohor(present_glohor, future_glohor, baseline_glohor):
     """
     Global horizontal radiation morph requires a stretch

{pyepwmorph-3.0.0 → pyepwmorph-3.1.0}/pyepwmorph/tools/configuration.py

@@ -28,21 +28,55 @@ VARIABLE_MAPPING = {
     'Humidity': ['huss'],
     'Pressure': ['psl'],
     'Wind': ['uas', 'vas'],
+    'Radiation': ['rsds'],
     'Clouds and Radiation': ['clt', 'rsds'],
 }
 
+#: CH2025 station scenarios carry relative humidity and scalar wind speed
+#: directly, and they do not include pressure or cloud cover.
+CH2025_PATHWAY_MAP = {
+    'GWL 1.5': 'gwl1.5',
+    'GWL 2.0': 'gwl2.0',
+    'GWL 2.5': 'gwl2.5',
+    'GWL 3.0': 'gwl3.0',
+}
+
+CH2025_VARIABLE_MAPPING = {
+    'Temperature': ['tas', 'tasmax', 'tasmin'],
+    'Humidity': ['hurs'],
+    'Wind': ['sfcWind'],
+    'Radiation': ['rsds'],
+    'Dew Point': [],
+}
+
+CH2025_UNSUPPORTED = frozenset({'Pressure', 'Clouds and Radiation'})
+
 VARIABLE_DEPENDENCIES = {
     'Humidity': ['Temperature', 'Pressure'],
     'Dew Point': ['Temperature', 'Humidity', 'Pressure'],
 }
 
+CH2025_VARIABLE_DEPENDENCIES = {
+    'Dew Point': ['Temperature', 'Humidity'],
+}
+
 #: The order variables must be morphed in so that every variable sees its
 #: dependencies already morphed.  Pressure and temperature feed humidity,
-#: which in turn feeds dew point.
-MORPH_ORDER = ['Pressure', 'Temperature', 'Humidity', 'Dew Point', 'Wind', 'Clouds and Radiation']
+#: which in turn feeds dew point.  ``Radiation`` morphs the solar fields
+#: without touching sky cover.
+MORPH_ORDER = [
+    'Pressure', 'Temperature', 'Humidity', 'Dew Point', 'Wind',
+    'Radiation', 'Clouds and Radiation',
+]
 
 
-def resolve_variable_order(user_variables):
+def _dependencies_for(data_source):
+    if data_source == "ch2025":
+        return CH2025_VARIABLE_DEPENDENCIES
+    return VARIABLE_DEPENDENCIES
+
+
+def resolve_variable_order(user_variables, data_source="cmip6"):
     """Expand variable dependencies and return them in a safe morphing order.
 
     Dependencies are pulled in transitively, so asking for ``Dew Point``
@@ -50,16 +84,23 @@ def resolve_variable_order(user_variables):
     resolved variable is written to the morphed EPW, which keeps the output
     file internally consistent.
 
+    For ``data_source="ch2025"`` humidity is a direct relative-humidity
+    stretch, so it has no dependencies, and dew point needs only temperature
+    and humidity.
+
     Parameters
     ----------
     user_variables : list[str]
         The variables the caller asked for.
+    data_source : str
+        ``"cmip6"`` (default), ``"custom"``, or ``"ch2025"``.
 
     Returns
     -------
     list[str]
         Supported variables, deduplicated and ordered for morphing.
     """
+    dependencies = _dependencies_for(data_source)
     resolved = set()
     pending = list(user_variables)
     while pending:
@@ -67,7 +108,7 @@ def resolve_variable_order(user_variables):
         if variable in resolved:
             continue
         resolved.add(variable)
-        pending.extend(VARIABLE_DEPENDENCIES.get(variable, []))
+        pending.extend(dependencies.get(variable, []))
 
     added = resolved - set(user_variables)
     if added:
@@ -107,14 +148,29 @@ class MorphConfig:
         ``(start_year, end_year)`` for the baseline period.  If *None*,
         derived from the EPW file.
     data_source : str
-        ``"cmip6"`` (default) or ``"custom"``.
+        ``"cmip6"`` (default), ``"custom"``, or ``"ch2025"``.
     custom_data : dict or None
         When *data_source* is ``"custom"``, a nested dict:
         ``{scenario_label: {variable: csv_path, ...}, ...}``.
         Must include a ``"reference"`` scenario and at least one target.
     reference_scenario : str or None
         Which scenario key to treat as the baseline/reference.
-        Defaults to ``"historical"`` for CMIP6, ``"reference"`` for custom.
+        Defaults to ``"historical"`` for CMIP6, ``"reference"`` for custom,
+        and ``"ref91-20"`` for CH2025.
+    ch2025_full_coverage : bool
+        CH2025 only. When True, match the site only against stations that
+        carry every CH2025 variable, so the station does not change with the
+        variables requested. Default False matches against stations that
+        carry the requested variables.
+
+    Attributes
+    ----------
+    ch2025_station : pd.Series or None
+        CH2025 only. The matched station row, including ``distance_km``,
+        ``elevation_difference_m`` and ``weak_match``.
+    ch2025_notes : list[str]
+        CH2025 only. Plain-language caveats about this morph (baseline
+        mismatch, weak station match), for display to users.
 
     Backward Compatibility
     ----------------------
@@ -136,6 +192,7 @@ class MorphConfig:
         data_source="cmip6",
         custom_data=None,
         reference_scenario=None,
+        ch2025_full_coverage=False,
         # backward-compat alias
         future_years=None,
     ):
@@ -146,8 +203,10 @@ class MorphConfig:
                 stacklevel=2,
             )
             target_years = future_years
-        if target_years is None:
+        if target_years is None and data_source != "ch2025":
             raise ValueError("target_years (or future_years) must be provided")
+        if data_source == "ch2025" and target_years is None:
+            target_years = []
 
         if model_sources is None:
             model_sources = ['ACCESS-CM2', 'CanESM5', 'TaiESM1']
@@ -184,12 +243,17 @@ class MorphConfig:
             self.reference_scenario = reference_scenario
         elif data_source == "custom":
             self.reference_scenario = "reference"
+        elif data_source == "ch2025":
+            self.reference_scenario = "ref91-20"
         else:
             self.reference_scenario = "historical"
 
         self.model_pathways: list[str] = []
         self.model_variables: list[str] = []
         self.resolved_variables: list[str] = []
+        self.ch2025_station = None
+        self.ch2025_notes: list[str] = []
+        self.ch2025_full_coverage = bool(ch2025_full_coverage)
 
         if output_directory is not None:
             self.output_directory = output_directory
@@ -199,6 +263,7 @@ class MorphConfig:
 
         self.assign_from_epw()
         self.assign_model_variables()
+        self.assign_ch2025_station()
         self.assign_model_pathways()
 
     def assign_from_epw(self):
@@ -209,23 +274,98 @@ class MorphConfig:
         if self.baseline_range is None:
             self.baseline_range = self.epw.detect_baseline_range()
 
+        if self.data_source == "ch2025":
+            from pyepwmorph.models.ch2025 import (
+                CH2025_BASELINE_RANGE,
+                CH2025_BBOX,
+                baseline_matches,
+                in_switzerland,
+            )
+
+            latitude = self.location['latitude']
+            longitude = self.location['longitude']
+            if not in_switzerland(latitude, longitude):
+                west, south, east, north = CH2025_BBOX
+                raise ValueError(
+                    f"EPW location ({latitude}, {longitude}) is outside Switzerland. "
+                    f"CH2025 covers longitude {west} to {east} and latitude {south} to {north}. "
+                    f"Use data_source='cmip6' for locations outside that domain."
+                )
+            if not baseline_matches(self.baseline_range):
+                start, end = (int(year) for year in self.baseline_range)
+                ref_start, ref_end = CH2025_BASELINE_RANGE
+                if end > ref_end:
+                    effect = (
+                        f"Years after {ref_end} already contain part of that warming, "
+                        f"so the morphed file may overstate it."
+                    )
+                else:
+                    effect = (
+                        f"Years before {ref_start} were cooler, so the morphed file may "
+                        f"understate the warming."
+                    )
+                note = (
+                    f"The EPW covers {start}-{end} but CH2025 changes are measured from "
+                    f"{ref_start}-{ref_end}. {effect} For CH2025, use a TMY built from "
+                    f"{ref_start}-{ref_end} data."
+                )
+                self.ch2025_notes.append(note)
+                warnings.warn(note, UserWarning, stacklevel=2)
+
     def assign_model_variables(self):
-        """Resolve user-facing variable names to CMIP6-style variable IDs."""
-        self.resolved_variables = resolve_variable_order(self.user_variables)
+        """Resolve user-facing variable names to model variable IDs."""
+        if self.data_source == "ch2025":
+            blocked = set(self.user_variables) & CH2025_UNSUPPORTED
+            if blocked:
+                names = ", ".join(sorted(blocked))
+                raise ValueError(
+                    f"CH2025 station scenarios do not include {names}. "
+                    f"Use data_source='cmip6' for pressure and cloud cover, "
+                    f"or request Radiation instead of Clouds and Radiation."
+                )
+            mapping = CH2025_VARIABLE_MAPPING
+        else:
+            mapping = VARIABLE_MAPPING
+
+        self.resolved_variables = resolve_variable_order(self.user_variables, self.data_source)
 
         model_variables = []
         for variable in self.resolved_variables:
-            model_variables.extend(VARIABLE_MAPPING.get(variable, []))
+            model_variables.extend(mapping.get(variable, []))
 
         self.model_variables = sorted(set(model_variables))
         logger.debug("Resolved model variables: %s", self.model_variables)
 
+    def assign_ch2025_station(self):
+        """Match the EPW site to a CH2025 station that has the requested variables."""
+        if self.data_source != "ch2025":
+            return
+        from pyepwmorph.models.ch2025 import CH2025_VARIABLES, nearest_station
+
+        variables = sorted(CH2025_VARIABLES) if self.ch2025_full_coverage else self.model_variables
+        station = nearest_station(
+            self.location['latitude'],
+            self.location['longitude'],
+            self.location['elevation'],
+            variables=variables,
+        )
+        self.ch2025_station = station
+        if station["weak_match"]:
+            self.ch2025_notes.append(
+                f"The nearest suitable CH2025 station, {station['name']}, is "
+                f"{station['distance_km']:.0f} km away and "
+                f"{station['elevation_difference_m']:+.0f} m in elevation. Its climate "
+                f"signal may not represent this site."
+            )
+
     def assign_model_pathways(self):
         """Resolve user-facing pathway labels to model experiment IDs.
 
         For ``data_source="cmip6"``, maps friendly names to SSP IDs.
         For ``data_source="custom"``, passes labels through directly
         and adds the reference scenario.
+        For ``data_source="ch2025"``, maps warming-level labels to state ids
+        and always includes the ``ref91-20`` reference.
         """
         self.model_pathways = []
 
@@ -236,6 +376,20 @@ class MorphConfig:
                     f"Reference scenario '{self.reference_scenario}' not found "
                     f"in custom_data keys: {self.model_pathways}"
                 )
+        elif self.data_source == "ch2025":
+            known = set(CH2025_PATHWAY_MAP.values())
+            for user_path in self.user_pathways:
+                if user_path in CH2025_PATHWAY_MAP:
+                    self.model_pathways.append(CH2025_PATHWAY_MAP[user_path])
+                elif user_path in known:
+                    self.model_pathways.append(user_path)
+                else:
+                    raise ValueError(
+                        f"Unknown CH2025 warming level '{user_path}'. "
+                        f"Use one of {list(CH2025_PATHWAY_MAP)} or {sorted(known)}."
+                    )
+            if self.reference_scenario not in self.model_pathways:
+                self.model_pathways.append(self.reference_scenario)
         else:
             for user_path in self.user_pathways:
                 if user_path in CMIP6_PATHWAY_MAP:

{pyepwmorph-3.0.0 → pyepwmorph-3.1.0}/pyepwmorph/tools/workflow.py

@@ -8,7 +8,7 @@ import datetime
 import logging
 import os
 
-from pyepwmorph.models import access, assemble, coordinate, custom
+from pyepwmorph.models import access, assemble, ch2025, coordinate, custom
 from pyepwmorph.morph import procedures
 from pyepwmorph.tools import cache
 from pyepwmorph.tools import configuration as morph_config
@@ -152,6 +152,49 @@ def compile_custom_model_data(custom_data, variables, percentile=50):
     return model_data_dict
 
 
+def compile_ch2025_model_data(station_id, pathways, variables, percentiles):
+    """Load shipped CH2025 climatologies for one station.
+
+    Each warming level gets its own paired reference, built from the model
+    chains it shares with ``ref91-20`` (see
+    ``ch2025.build_ch2025_change_ensemble``). The reference is stored under
+    ``ch2025.reference_key(state)``; pass that as ``reference_scenario`` to
+    ``morph_epw``.
+
+    Parameters
+    ----------
+    station_id : str
+        Lower-case CH2025 station abbreviation.
+    pathways : list[str]
+        State ids. ``ref91-20`` may be included and is skipped.
+    variables : list[str]
+        CH2025 variable ids.
+    percentiles : list
+        Ensemble percentiles.
+
+    Returns
+    -------
+    dict[str, dict[str, pd.DataFrame]]
+        ``model_data_dict[key][variable]`` with percentile columns, where
+        *key* is a warming level or its paired reference key.
+    """
+    model_data_dict = {}
+    for pathway in pathways:
+        if pathway == ch2025.CH2025_REFERENCE:
+            continue
+        reference_key = ch2025.reference_key(pathway)
+        model_data_dict[pathway] = {}
+        model_data_dict[reference_key] = {}
+        for variable in variables:
+            logger.info("Loading CH2025 data for '%s' / '%s' / '%s'", station_id, pathway, variable)
+            reference, future = ch2025.build_ch2025_change_ensemble(
+                percentiles, variable, station_id, pathway,
+            )
+            model_data_dict[reference_key][variable] = reference
+            model_data_dict[pathway][variable] = future
+    return model_data_dict
+
+
 # ---------------------------------------------------------------------------
 # Morphing
 # ---------------------------------------------------------------------------
@@ -165,6 +208,8 @@ def morph_epw(
     pathway,
     percentile,
     reference_scenario="historical",
+    data_source="cmip6",
+    station_label=None,
 ):
     """Apply morphing procedures to an EPW file.
 
@@ -194,6 +239,12 @@ def morph_epw(
     reference_scenario : str
         Key in *model_data_dict* for the baseline/reference data.
         Defaults to ``"historical"``.
+    data_source : str
+        ``"cmip6"``, ``"custom"``, or ``"ch2025"``. CH2025 uses warming-level
+        climatologies directly and morphs humidity and wind from ``hurs``
+        and ``sfcWind``.
+    station_label : str or None
+        CH2025 station named in the EPW comment.
 
     Returns
     -------
@@ -225,13 +276,16 @@ def morph_epw(
 
     def _climatology(var):
         """Return the (baseline, future) monthly climatologies for a variable."""
+        baseline = _get_series(reference_scenario, var)
+        future = _get_series(pathway, var)
+        if data_source == "ch2025":
+            return assemble.calc_gwl_climatologies(baseline, future, var)
         return assemble.calc_model_climatologies(
-            baseline_range, target_range,
-            _get_series(reference_scenario, var), _get_series(pathway, var), var,
+            baseline_range, target_range, baseline, future, var,
         )
 
     morphed = {}
-    for variable in morph_config.resolve_variable_order(user_variables):
+    for variable in morph_config.resolve_variable_order(user_variables, data_source):
         if variable == 'Pressure':
             psl_base, psl_future = _climatology('psl')
             morphed['atmos_Pa'] = procedures.morph_psl(
@@ -250,12 +304,18 @@ def morph_epw(
             )
 
         elif variable == 'Humidity':
-            huss_base, huss_future = _climatology('huss')
-            morphed['relhum_percent'] = procedures.morph_relhum(
-                present['relhum_percent'], present['atmos_Pa'], present['drybulb_C'],
-                morphed['atmos_Pa'], morphed['drybulb_C'],
-                huss_future, huss_base,
-            )
+            if data_source == "ch2025":
+                hurs_base, hurs_future = _climatology('hurs')
+                morphed['relhum_percent'] = procedures.morph_relhum_direct(
+                    present['relhum_percent'], hurs_future, hurs_base,
+                )
+            else:
+                huss_base, huss_future = _climatology('huss')
+                morphed['relhum_percent'] = procedures.morph_relhum(
+                    present['relhum_percent'], present['atmos_Pa'], present['drybulb_C'],
+                    morphed['atmos_Pa'], morphed['drybulb_C'],
+                    huss_future, huss_base,
+                )
 
         elif variable == 'Dew Point':
             morphed['dewpoint_C'] = procedures.morph_dewpt(
@@ -263,13 +323,39 @@ def morph_epw(
             )
 
         elif variable == 'Wind':
-            vas_base, vas_future = _climatology('vas')
-            uas_base, uas_future = _climatology('uas')
-            morphed['windspd_ms'] = procedures.morph_wspd(
-                present['windspd_ms'],
-                vas_future, vas_base,
-                uas_future, uas_base,
+            if data_source == "ch2025":
+                wind_base, wind_future = _climatology('sfcWind')
+                morphed['windspd_ms'] = procedures.morph_wspd_direct(
+                    present['windspd_ms'], wind_future, wind_base,
+                )
+            else:
+                vas_base, vas_future = _climatology('vas')
+                uas_base, uas_future = _climatology('uas')
+                morphed['windspd_ms'] = procedures.morph_wspd(
+                    present['windspd_ms'],
+                    vas_future, vas_base,
+                    uas_future, uas_base,
+                )
+
+        elif variable == 'Radiation':
+            rsds_base, rsds_future = _climatology('rsds')
+            longitude = location['longitude']
+            latitude = location['latitude']
+            utc_offset = location['utc_offset']
+
+            glohor = procedures.morph_glohor(
+                present['glohorrad_Whm2'], rsds_future, rsds_base,
             )
+            difhor = procedures.calc_difhor(
+                longitude, latitude, utc_offset, glohor, present['exthorrad_Whm2'],
+            )
+            dirnor = procedures.calc_dirnor(
+                glohor, difhor, longitude, latitude, utc_offset,
+                extraterrestrial_dirnor=present['extdirrad_Whm2'],
+            )
+            morphed['glohorrad_Whm2'] = glohor
+            morphed['difhorrad_Whm2'] = difhor
+            morphed['dirnorrad_Whm2'] = dirnor
 
         elif variable == 'Clouds and Radiation':
             rsds_base, rsds_future = _climatology('rsds')
@@ -306,10 +392,22 @@ def morph_epw(
             epw_object.dataframe[column] = values
         # EPW headers are comma delimited, so the comment itself must not
         # contain commas or it will be split across fields on the next read
-        epw_object.add_comment(
-            f" morphed for {pathway} ({target_range[0]}-{target_range[1]}) with pyepwmorph"
-            f" on {datetime.datetime.now().isoformat()} [{' '.join(morphed)}]"
-        )
+        sky_note = ""
+        if "Radiation" in morph_config.resolve_variable_order(user_variables, data_source):
+            sky_note = " [sky cover left unmorphed]"
+        if data_source == "ch2025":
+            station_note = f" station {station_label}" if station_label else ""
+            comment = (
+                f" morphed for {pathway} with CH2025{station_note} with pyepwmorph"
+                f" on {datetime.datetime.now().isoformat()} [{' '.join(morphed)}]{sky_note}"
+                f" {ch2025.CH2025_CITATION}"
+            )
+        else:
+            comment = (
+                f" morphed for {pathway} ({target_range[0]}-{target_range[1]}) with pyepwmorph"
+                f" on {datetime.datetime.now().isoformat()} [{' '.join(morphed)}]{sky_note}"
+            )
+        epw_object.add_comment(comment)
 
     return epw_object
 
@@ -333,13 +431,15 @@ def morphing_workflow(
     custom_data=None,
     reference_scenario=None,
     time_slices=None,
+    ch2025_full_coverage=False,
     # backward-compat alias
     future_years=None,
 ):
     """Run the full morphing pipeline.
 
-    Supports both CMIP6 (``data_source="cmip6"``) and custom CSV data
-    (``data_source="custom"``).
+    Supports CMIP6 (``data_source="cmip6"``), custom CSV data
+    (``data_source="custom"``), and Swiss CH2025 warming levels
+    (``data_source="ch2025"``).
 
     Parameters
     ----------
@@ -364,20 +464,25 @@ def morphing_workflow(
     write_file : bool
         Whether to write morphed EPW files to disk.
     data_source : str
-        ``"cmip6"`` or ``"custom"``.
+        ``"cmip6"``, ``"custom"``, or ``"ch2025"``. CH2025 does not use
+        ``target_years``; pathways are warming levels such as ``"gwl2.0"``.
     custom_data : dict or None
         Nested dict for custom data (see ``MorphConfig``).
     reference_scenario : str or None
         Baseline scenario key.
     time_slices : dict or None
         Optional per-pathway ``(start, end)`` temporal bounds for CMIP6 data.
+    ch2025_full_coverage : bool
+        CH2025 only. Match the site only against stations that carry every
+        CH2025 variable (see ``MorphConfig``).
     future_years : list[int] or None
         Deprecated alias for *target_years*.
 
     Returns
     -------
     dict
-        Nested ``result_data[year][pathway][percentile]`` -> morphed Epw.
+        For CMIP6 and custom data, ``result_data[year][pathway][percentile]``.
+        For CH2025, ``result_data[warming_level][percentile]``.
     """
     config_object = morph_config.MorphConfig(
         project_name, epw_file, user_variables, user_pathways, percentiles,
@@ -388,6 +493,7 @@ def morphing_workflow(
         data_source=data_source,
         custom_data=custom_data,
         reference_scenario=reference_scenario,
+        ch2025_full_coverage=ch2025_full_coverage,
         future_years=future_years,
     )
 
@@ -401,6 +507,14 @@ def morphing_workflow(
             config_object.model_variables,
             percentile=default_pctile,
         )
+    elif config_object.data_source == "ch2025":
+        station = config_object.ch2025_station
+        year_model_dict = compile_ch2025_model_data(
+            station["station_id"],
+            config_object.model_pathways,
+            config_object.model_variables,
+            config_object.percentiles,
+        )
     else:
         year_model_dict = iterate_compile_model_data(
             config_object.model_pathways,
@@ -416,6 +530,43 @@ def morphing_workflow(
     target_pathways = [p for p in config_object.model_pathways if p != ref_scenario]
     result_data = {}
 
+    if "Radiation" in config_object.resolved_variables:
+        logger.warning(
+            "Radiation morphs shortwave radiation while leaving sky cover at "
+            "baseline values. EnergyPlus derives sky temperature from opaque "
+            "sky cover when horizontal infrared is absent, so the longwave "
+            "side of this file does not follow the shortwave change."
+        )
+
+    if config_object.data_source == "ch2025":
+        station = config_object.ch2025_station
+        station_label = f"{station['station_id']} {station['name']}".replace(",", " ")
+        for pathway in target_pathways:
+            result_data[pathway] = {}
+            for percentile in config_object.percentiles:
+                percentile_key = str(percentile)
+                morphed_data = morph_epw(
+                    config_object.epw,
+                    config_object.resolved_variables,
+                    config_object.baseline_range,
+                    ch2025.CH2025_BASELINE_RANGE,
+                    year_model_dict,
+                    pathway,
+                    percentile,
+                    reference_scenario=ch2025.reference_key(pathway),
+                    data_source="ch2025",
+                    station_label=station_label,
+                )
+                result_data[pathway][percentile_key] = morphed_data
+                if write_file and config_object.output_directory:
+                    morphed_data.write_to_file(
+                        os.path.join(
+                            config_object.output_directory,
+                            f"{pathway}_{percentile_key}.epw",
+                        )
+                    )
+        return result_data
+
     for target_year in config_object.target_years:
         year_key = str(target_year)
         result_data[year_key] = {}

{pyepwmorph-3.0.0 → pyepwmorph-3.1.0}/pyproject.toml

@@ -3,12 +3,13 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build]
-include = ["pyepwmorph/*"]
+include = ["pyepwmorph"]
 
 # hatchling 1.32 defaults to core metadata 2.5, which twine below 7.0 rejects,
 # including the twine inside pypa/gh-action-pypi-publish. Stay on 2.4 until the
 # upload path supports 2.5.
 [tool.hatch.build.targets.wheel]
+artifacts = ["pyepwmorph/data/*.parquet"]
 core-metadata-version = "2.4"
 
 [tool.hatch.build.targets.sdist]
@@ -16,7 +17,7 @@ core-metadata-version = "2.4"
 
 [project]
 name = "pyepwmorph"
-version = "3.0.0"
+version = "3.1.0"
 authors = [
   { name="Justin McCarty", email="mccarty.justin.f@gmail.com" },
 ]