Unidata / MetPy

            mean_dewpoint.to(dewpt.units))

@exporter.export

@check_units('[pressure]')

def mixed_layer(p, *args, **kwargs):

    r"""Mix variable(s) over a layer, yielding a mass-weighted average.

    This function will integrate a data variable with respect to pressure and determine the

    average value using the mean value theorem.

    Parameters

    ----------

    p : array-like

        Atmospheric pressure profile

    datavar : array-like

        Atmospheric variable measured at the given pressures

    heights: array-like, optional

        Atmospheric heights corresponding to the given pressures (default None)

    bottom : `pint.Quantity`, optional

        The bottom of the layer as a pressure or height above the surface pressure

        (default None)

    depth : `pint.Quantity`, optional

        The thickness of the layer as a pressure or height above the bottom of the layer

        (default 100 hPa)

    interpolate : bool, optional

        Interpolate the top and bottom points if they are not in the given data

    Returns

    -------

    `pint.Quantity`

        The mixed value of the data variable.

    """

    # Pull out keyword arguments, remove when we drop Python 2.7

    heights = kwargs.pop('heights', None)

    bottom = kwargs.pop('bottom', None)

    depth = kwargs.pop('depth', 100 * units.hPa)

    interpolate = kwargs.pop('interpolate', True)

    layer = get_layer(p, *args, heights=heights, bottom=bottom,

                      depth=depth, interpolate=interpolate)

    p_layer = layer[0]

    datavars_layer = layer[1:]

    ret = []

    for datavar_layer in datavars_layer:

        actual_depth = abs(p_layer[0] - p_layer[-1])

        ret.append((-1. / actual_depth.m) * np.trapz(datavar_layer, p_layer) *

                   datavar_layer.units)

    return ret

        bottom = np.nanmax(pressure) * pressure.units

    pres_layer, dewpt_layer = get_layer(pressure, dewpt, bottom=bottom, depth=bottom - top)

    w = mixing_ratio(saturation_vapor_pressure(dewpt_layer), pres_layer)

    # Since pressure is in decreasing order, pw will be the opposite sign of that expected.

    pw = -1. * (np.trapz(w.magnitude, pres_layer.magnitude) * (w.units * pres_layer.units) /

                (g * rho_l))

    return pw.to('millimeters')

@exporter.export

@check_units('[pressure]')

def mean_pressure_weighted(pressure, *args, **kwargs):

    r"""Calculate pressure-weighted mean of an arbitrary variable through a layer.

    Layer top and bottom specified in height or pressure.

    Parameters

    ----------

    pressure : `pint.Quantity`

        Atmospheric pressure profile

    *args : `pint.Quantity`

        Parameters for which the pressure-weighted mean is to be calculated.

    heights : `pint.Quantity`, optional

        Heights from sounding. Standard atmosphere heights assumed (if needed)

        if no heights are given.

    bottom: `pint.Quantity`, optional

        The bottom of the layer in either the provided height coordinate

        or in pressure. Don't provide in meters AGL unless the provided

        height coordinate is meters AGL. Default is the first observation,

        assumed to be the surface.

    depth: `pint.Quantity`, optional

        The depth of the layer in meters or hPa.

    Returns

    -------

    `pint.Quantity`

        u_mean: u-component of layer mean wind.

    `pint.Quantity`

        v_mean: v-component of layer mean wind.

    """

    heights = kwargs.pop('heights', None)

    bottom = kwargs.pop('bottom', None)

    depth = kwargs.pop('depth', None)

    ret = []  # Returned variable means in layer

    layer_arg = get_layer(pressure, *args, heights=heights,

                          bottom=bottom, depth=depth)

    layer_p = layer_arg[0]

    layer_arg = layer_arg[1:]

    # Taking the integral of the weights (pressure) to feed into the weighting

    # function. Said integral works out to this function: