pypromice 1.5.3__py3-none-any.whl → 1.7.0__py3-none-any.whl

pypromice/core/variables/humidity.py

@@ -0,0 +1,111 @@
+__all__ = ["adjust", "convert", "calculate_specific_humidity"]
+
+import xarray as xr
+import numpy as np
+
+# Define constants
+T_0 = 273.15                # Ice point temperature (Kelvins)
+T_100 = T_0+100             # Steam point temperature (Kelvins)
+ews = 1013.246              # Saturation vapour pressure at steam point temperature (normal atmosphere) (hPa)
+ei0 = 6.1071                # Saturation vapour pressure at ice melting point temperature (normal atmosphere) (hPa)
+eps=0.622                   # Ratio of molar masses of vapor and dry air
+
+def adjust(rh: xr.DataArray,
+           t: xr.DataArray
+) -> xr.DataArray:
+    """Correct relative humidity so that values are given with respect to
+    saturation over ice in subfreezing conditions, and with respect to
+    saturation over water (as given by the instrument) above the melting
+    point temperature. Saturation water vapors are calculated after
+    Groff & Gratch method.
+
+    Parameters
+    ----------
+    rh : xr.DataArray
+        Relative humidity
+    t : xr.DataArray
+        Air temperature
+
+    Returns
+    -------
+    rh_wrt_ice_or_water : xr.DataArray
+        CAdjusted relative humidity
+    """
+    # Convert to hPa (Groff & Gratch)
+    e_s_wtr = 10**(-7.90298 * (T_100 / (t + T_0) - 1)
+                   + 5.02808 * np.log10(T_100 / (t + T_0))
+                   - 1.3816E-7 * (10**(11.344 * (1 - (t + T_0) / T_100)) - 1)
+                   + 8.1328E-3 * (10**(-3.49149 * (T_100/(t + T_0) - 1)) -1)
+                   + np.log10(ews))
+    e_s_ice = 10**(-9.09718 * (T_0 / (t + T_0) - 1)
+                   - 3.56654 * np.log10(T_0 / (t + T_0))
+                   + 0.876793 * (1 - (t + T_0) / T_0)
+                   + np.log10(ei0))
+
+    # Define freezing point. Why > -100?
+    nan_mask = t.notnull()
+    freezing = (t < 0) & (t > -100) & nan_mask
+
+    # Set to Groff & Gratch values when freezing, otherwise just rh
+    rh_wrt_ice_or_water = rh.where(~freezing & nan_mask,
+                                   other=rh*(e_s_wtr/e_s_ice))
+    return rh_wrt_ice_or_water
+
+
+def calculate_specific_humidity(t, p, rh_wrt_ice_or_water):
+    """Calculate specific humidity.
+
+    Parameters
+    ----------
+    t : xr.DataArray
+        Air temperature
+    p : xr.DataArray
+        Air pressure
+    rh_wrt_ice_or_water : xr.DataArray
+        Adjusted relative humidity
+
+    Returns
+    -------
+    xr.DataArray
+        Specific humidity (kg/kg)
+    """
+    # Saturation vapour pressure above 0 C (hPa)
+    es_wtr = 10**(-7.90298 * (T_100 / (t + T_0) - 1) + 5.02808 * np.log10(T_100 / (t + T_0))
+                  - 1.3816E-7 * (10**(11.344 * (1 - (t + T_0) / T_100)) - 1)
+                  + 8.1328E-3 * (10**(-3.49149 * (T_100 / (t + T_0) -1)) - 1) + np.log10(ews))
+
+    # Saturation vapour pressure below 0 C (hPa)
+    es_ice = 10**(-9.09718 * (T_0 / (t + T_0) - 1) - 3.56654
+                  * np.log10(T_0 / (t + T_0)) + 0.876793
+                  * (1 - (t + T_0) / T_0)
+                  + np.log10(ei0))
+
+    # Specific humidity at saturation (incorrect below melting point)
+    q_sat = eps * es_wtr / (p - (1 - eps) * es_wtr)
+
+    # Replace saturation specific humidity values below melting point
+    freezing = t < 0
+    q_sat[freezing] = eps * es_ice[freezing] / (p[freezing] - (1 - eps) * es_ice[freezing])
+
+    # Mask where temperature or pressure are null values
+    q_nan = np.isnan(t) | np.isnan(p)
+    q_sat[q_nan] = np.nan
+
+    # Convert to kg/kg
+    return rh_wrt_ice_or_water * q_sat / 100
+
+def convert(qh: xr.DataArray
+) -> xr.DataArray:
+    """Convert specific humidity from kg/kg to g/kg units
+
+    Parameters
+    ----------
+    qh : xr.DataArray
+        Specific humidity (kg/kg)
+
+    Returns
+    -------
+    xr.DataArray
+        Specific humidity (g/kg)
+    """
+    return 1000 * qh

pypromice/core/variables/precipitation.py

@@ -0,0 +1,108 @@
+__all__ = ["correct_rainfall_undercatch", "get_rainfall_per_timestep", "filter_lufft_errors"]
+
+import numpy as np
+import xarray as xr
+
+
+def filter_lufft_errors(
+    precip: xr.DataArray, t: xr.DataArray, p: xr.DataArray, rh: xr.DataArray
+) -> xr.DataArray:
+    """Filter precipitation measurements where air temperature, pressure, or
+    relative humidity measurements are null values. This assumes that
+    air temperature, air pressure, relative humidity and precipitation
+    measurements are measured using the same instrument, e.g. a
+    lufft instrument.
+
+    Parameters
+    ----------
+    precip : xr.DataArray
+        Cumulative precipitation measurements
+    t : xr.DataArray
+        Air temperature measurements
+    p : xr.DataArray
+        Air pressure measurements
+    rh : xr.DataArray
+        Relative humidity measurements
+
+    Returns
+    -------
+    xr.DataArray
+        Filtered precipitation values
+    """
+    mask = (t.isnull() | p.isnull() | rh.isnull()) & (precip == 0)
+    return precip.where(~mask)
+
+
+def correct_rainfall_undercatch(
+    rainfall_per_timestep: xr.DataArray, wspd: xr.DataArray
+) -> xr.DataArray:
+    """Corrects rainfall amount per timestep for undercatch as in
+    Yang et al. (1999) and Box et al. (2022), based on Goodison et al. (1998).
+
+    Yang, D., Ishida, S., Goodison, B. E., and Gunther, T.: Bias correction of
+    daily precipitation measurements for Greenland,
+    https://doi.org/10.1029/1998jd200110, 1999.
+
+    Box, J., Wehrle, A., van As, D., Fausto, R., Kjeldsen, K., Dachauer, A.,
+    Ahlstrom, A. P., and Picard, G.: Greenland Ice Sheet rainfall, heat and
+    albedo feedback imapacts from the Mid-August 2021 atmospheric river,
+    Geophys. Res. Lett. 49 (11), e2021GL097356,
+    https://doi.org/10.1029/2021GL097356, 2022.
+
+    Goodison, B. E., Louie, P. Y. T., and Yang, D.: Solid Precipitation
+    Measurement Intercomparison, WMO, 1998
+
+    Parameters
+    ----------
+    rainfall : xr.DataArray
+        Uncorrected rainfall per timestep
+    wspd : xr.DataArray
+        Wind speed measurements
+
+    Returns
+    -------
+    rainfall_cor : xr.DataArray
+        Corrected rainfall per timestep
+    """
+
+    # Calculate undercatch correction factor
+    corr = 100 / (100.00 - 4.37 * wspd + 0.35 * wspd * wspd)
+
+    # Fix all values below 1.02 to 1.02
+    corr = corr.where(corr > 1.02, other=1.02)
+
+    # Apply correction to rate
+    rainfall_per_timestep_cor = rainfall_per_timestep * corr
+
+    return rainfall_per_timestep_cor
+
+def get_rainfall_per_timestep(
+    precip: xr.DataArray,
+    t: xr.DataArray
+) -> xr.DataArray:
+    """
+    Derive rainfall per timestep from cumulative precipitation data.
+
+    Parameters
+    ----------
+    precip : xr.DataArray
+        Cumulative precipitation measurements.
+    t : xr.DataArray
+        Air temperature measurements.
+
+    Returns
+    -------
+    xr.DataArray
+        Rainfall per timestep with negative values removed and
+        cold-season precipitation (T < -2 °C) filtered out.
+    """
+    rainfall_per_timestep = precip.diff("time").reindex_like(precip)
+
+    # Removing all negative precipitation, both corrected and uncorrected
+    rainfall_per_timestep = rainfall_per_timestep.where(rainfall_per_timestep >= 0)
+
+    # Filtering cold season precipitation, both corrected and uncorrected
+    rain_in_cold = (rainfall_per_timestep > 0) & (t < -2)
+    rainfall_per_timestep = rainfall_per_timestep.where(~rain_in_cold)
+
+    return rainfall_per_timestep

pypromice/core/variables/pressure_transducer_depth.py

@@ -0,0 +1,79 @@
+__all__ = ["correct_and_calculate_depth", "apply_offset"]
+
+import xarray as xr
+import numpy as np
+import logging
+logger = logging.getLogger(__name__)
+
+def correct_and_calculate_depth(z_pt: xr.DataArray,
+                                air_pressure: xr.DataArray,
+                                pt_antifreeze: float,
+                                pt_z_factor: float,
+                                pt_z_coef: float,
+                                pt_z_p_coef: float
+) -> tuple[xr.DataArray, xr.DataArray]:
+    """Adjust pressure depth and calculate pressure transducer depth based on
+    pressure transducer fluid density
+
+    Parameters
+    ----------
+    z_pt : xr.DataArray
+        Pressure transducer height (corrected for offset)
+    air_pressure : xr.DataArray
+        Air pressure
+    pt_antifreeze : float
+        Pressure transducer anti-freeze percentage for fluid density
+        correction
+    pt_z_factor : float
+        Pressure transducer factor
+    pt_z_coef : float
+        Pressure transducer coefficient
+    pt_z_p_coef : float
+        Pressure transducer coefficient
+
+    Returns
+    -------
+    z_pt_cor : xr.DataArray
+        Pressure transducer height corrected
+    z_pt : xr.DataArray
+        Pressure transducer depth
+    """
+    # Calculate pressure transducer fluid density
+    # TODO: Implement function w/ reference (analytical or from LUT)
+    # TODO: Track uncertainty
+    if pt_antifreeze == 50:
+        rho_af = 1092
+    elif pt_antifreeze == 100:
+        rho_af = 1145
+    else:
+        rho_af = np.nan
+        logger.info('ERROR: Incorrect metadata: "pt_antifreeze" = ' +
+              f'{pt_antifreeze}. Antifreeze mix only supported at 50% or 100%')
+        # assert(False)
+
+    # Correct pressure depth
+    z_pt_cor = z_pt * pt_z_coef * pt_z_factor * 998.0 / rho_af + 100 * (pt_z_p_coef - air_pressure) / (rho_af * 9.81)
+
+    # Calculate pressure transducer depth
+    z_pt = z_pt * pt_z_coef * pt_z_factor * 998.0 / rho_af
+
+    return z_pt_cor, z_pt
+
+def apply_offset(z_pt: xr.DataArray,
+                 z_pt_offset: int
+) -> xr.DataArray:
+    """Apply defined offset to pressure transducer height
+
+    Parameters
+    ----------
+    z_pt : xr.DataArray
+        Pressure transducer height
+    z_pt_offset : xr.DataArray
+        Transducer height offset
+
+    Returns
+    -------
+    xr.DataArray
+        Adjusted pressure transducer height
+    """
+    return z_pt + z_pt_offset