get_layer() - Code Metrics - Inspection of "Get Layer Function" - Unidata/MetPy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#444)

unknown

created 2017-06-23 14:35 UTC

get_layer() F

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

133

Duplication

Lines	32
Ratio	24.06 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
cc	21
c	3
b	0
f	0
dl	32
loc	133
rs	2

How to fix Long Method Complexity

# Copyright (c) 2008-2017 MetPy Developers.
# Distributed under the terms of the BSD 3-Clause License.
# SPDX-License-Identifier: BSD-3-Clause
"""Contains a collection of generally useful calculation tools."""

import functools

import numpy as np
import numpy.ma as ma
from scipy.spatial import cKDTree

from . import height_to_pressure_std, pressure_to_height_std
from ..package_tools import Exporter
from ..units import check_units, units

exporter = Exporter(globals())


@exporter.export
def resample_nn_1d(a, centers):
    """Return one-dimensional nearest-neighbor indexes based on user-specified centers.

    Parameters
    ----------
    a : array-like
        1-dimensional array of numeric values from which to
        extract indexes of nearest-neighbors
    centers : array-like
        1-dimensional array of numeric values representing a subset of values to approximate

    Returns
    -------
        An array of indexes representing values closest to given array values

    """
    ix = []
    for center in centers:
        index = (np.abs(a - center)).argmin()
        if index not in ix:
            ix.append(index)
    return ix


@exporter.export
def nearest_intersection_idx(a, b):
    """Determine the index of the point just before two lines with common x values.

    Parameters
    ----------
    a : array-like
        1-dimensional array of y-values for line 1
    b : array-like
        1-dimensional array of y-values for line 2

    Returns
    -------
        An array of indexes representing the index of the values
        just before the intersection(s) of the two lines.

    """
    # Difference in the two y-value sets
    difference = a - b

    # Determine the point just before the intersection of the lines
    # Will return multiple points for multiple intersections
    sign_change_idx, = np.nonzero(np.diff(np.sign(difference)))

    return sign_change_idx


@exporter.export
def find_intersections(x, a, b, direction='all'):
    """Calculate the best estimate of intersection.

    Calculates the best estimates of the intersection of two y-value
    data sets that share a common x-value set.

    Parameters
    ----------
    x : array-like
        1-dimensional array of numeric x-values
    a : array-like
        1-dimensional array of y-values for line 1
    b : array-like
        1-dimensional array of y-values for line 2
    direction : string
        specifies direction of crossing. 'all', 'increasing' (a becoming greater than b),
        or 'decreasing' (b becoming greater than a).

    Returns
    -------
        A tuple (x, y) of array-like with the x and y coordinates of the
        intersections of the lines.

    """
    # Find the index of the points just before the intersection(s)
    nearest_idx = nearest_intersection_idx(a, b)
    next_idx = nearest_idx + 1

    # Determine the sign of the change
    sign_change = np.sign(a[next_idx] - b[next_idx])

    # x-values around each intersection
    _, x0 = _next_non_masked_element(x, nearest_idx)
    _, x1 = _next_non_masked_element(x, next_idx)

    # y-values around each intersection for the first line
    _, a0 = _next_non_masked_element(a, nearest_idx)
    _, a1 = _next_non_masked_element(a, next_idx)

    # y-values around each intersection for the second line
    _, b0 = _next_non_masked_element(b, nearest_idx)
    _, b1 = _next_non_masked_element(b, next_idx)

    # Calculate the x-intersection. This comes from finding the equations of the two lines,
    # one through (x0, a0) and (x1, a1) and the other through (x0, b0) and (x1, b1),
    # finding their intersection, and reducing with a bunch of algebra.
    delta_y0 = a0 - b0
    delta_y1 = a1 - b1
    intersect_x = (delta_y1 * x0 - delta_y0 * x1) / (delta_y1 - delta_y0)

    # Calculate the y-intersection of the lines. Just plug the x above into the equation
    # for the line through the a points. One could solve for y like x above, but this
    # causes weirder unit behavior and seems a little less good numerically.
    intersect_y = ((intersect_x - x0) / (x1 - x0)) * (a1 - a0) + a0

    # Make a mask based on the direction of sign change desired
    if direction == 'increasing':
        mask = sign_change > 0
    elif direction == 'decreasing':
        mask = sign_change < 0
    elif direction == 'all':
        return intersect_x, intersect_y
    else:
        raise ValueError('Unknown option for direction: {0}'.format(str(direction)))
    return intersect_x[mask], intersect_y[mask]


@exporter.export
def interpolate_nans(x, y, kind='linear'):
    """Interpolate NaN values in y.

    Interpolate NaN values in the y dimension. Works with unsorted x values.

    Parameters
    ----------
    x : array-like
        1-dimensional array of numeric x-values
    y : array-like
        1-dimensional array of numeric y-values
    kind : string
        specifies the kind of interpolation x coordinate - 'linear' or 'log'

    Returns
    -------
        An array of the y coordinate data with NaN values interpolated.

    """
    x_sort_args = np.argsort(x)
    x = x[x_sort_args]
    y = y[x_sort_args]
    nans = np.isnan(y)
    if kind == 'linear':
        y[nans] = np.interp(x[nans], x[~nans], y[~nans])
    elif kind == 'log':
        y[nans] = np.interp(np.log(x[nans]), np.log(x[~nans]), y[~nans])
    else:
        raise ValueError('Unknown option for kind: {0}'.format(str(kind)))
    return y[x_sort_args]


def _next_non_masked_element(a, idx):
    """Return the next non masked element of a masked array.

    If an array is masked, return the next non-masked element (if the given index is masked).
    If no other unmasked points are after the given masked point, returns none.

    Parameters
    ----------
    a : array-like
        1-dimensional array of numeric values
    idx : integer
        index of requested element

    Returns
    -------
        Index of next non-masked element and next non-masked element

    """
    try:
        next_idx = idx + a[idx:].mask.argmin()
        if ma.is_masked(a[next_idx]):
            return None, None
        else:
            return next_idx, a[next_idx]
    except (AttributeError, TypeError, IndexError):
        return idx, a[idx]


def delete_masked_points(*arrs):
    """Delete masked points from arrays.

    Takes arrays and removes masked points to help with calculations and plotting.

    Parameters
    ----------
    arrs : one or more array-like
        source arrays

    Returns
    -------
    arrs : one or more array-like
        arrays with masked elements removed

    """
    if any(hasattr(a, 'mask') for a in arrs):
        keep = ~functools.reduce(np.logical_or, (np.ma.getmaskarray(a) for a in arrs))
        return tuple(ma.asarray(a[keep]) for a in arrs)
    else:
        return arrs


@exporter.export
def reduce_point_density(points, radius, priority=None):
    r"""Return a mask to reduce the density of points in irregularly-spaced data.

    This function is used to down-sample a collection of scattered points (e.g. surface
    data), returning a mask that can be used to select the points from one or more arrays
    (e.g. arrays of temperature and dew point). The points selected can be controlled by
    providing an array of ``priority`` values (e.g. rainfall totals to ensure that
    stations with higher precipitation remain in the mask).

    Parameters
    ----------
    points : (N, K) array-like
        N locations of the points in K dimensional space
    radius : float
        minimum radius allowed between points
    priority : (N, K) array-like, optional
        If given, this should have the same shape as ``points``; these values will
        be used to control selection priority for points.

    Returns
    -------
        (N,) array-like of boolean values indicating whether points should be kept. This
        can be used directly to index numpy arrays to return only the desired points.

    Examples
    --------
    >>> metpy.calc.reduce_point_density(np.array([1, 2, 3]), 1.)
    array([ True, False,  True], dtype=bool)
    >>> metpy.calc.reduce_point_density(np.array([1, 2, 3]), 1.,
    ... priority=np.array([0.1, 0.9, 0.3]))
    array([False,  True, False], dtype=bool)

    """
    # Handle 1D input
    if points.ndim < 2:
        points = points.reshape(-1, 1)

    # Make a kd-tree to speed searching of data.
    tree = cKDTree(points)

    # Need to use sorted indices rather than sorting the position
    # so that the keep mask matches *original* order.
    if priority is not None:
        # Need to sort the locations in decreasing priority.
        sorted_indices = np.argsort(priority)[::-1]
    else:
        # Take advantage of iterator nature of range here to avoid making big lists
        sorted_indices = range(len(points))

    # Keep all points initially
    keep = np.ones(len(points), dtype=np.bool)

    # Loop over all the potential points
    for ind in sorted_indices:
        # Only proceed if we haven't already excluded this point
        if keep[ind]:
            # Find the neighbors and eliminate them
            neighbors = tree.query_ball_point(points[ind], radius)
            keep[neighbors] = False

            # We just removed ourselves, so undo that
            keep[ind] = True

    return keep


@exporter.export
def log_interp(x, xp, fp, **kwargs):
    r"""Interpolates data with logarithmic x-scale.

    Interpolation on a logarithmic x-scale for interpolation values in pressure coordintates.

    Parameters
    ----------
    x : array-like
        The x-coordinates of the interpolated values.

    xp : array-like
        The x-coordinates of the data points.

    fp : array-like
        The y-coordinates of the data points, same length as xp.

    Returns
    -------
    array-like
        The interpolated values, same shape as x.

    Examples
    --------
    >>> x_log = np.array([1e3, 1e4, 1e5, 1e6])
    >>> y_log = np.log(x_log) * 2 + 3
    >>> x_interp = np.array([5e3, 5e4, 5e5])
    >>> metpy.calc.log_interp(x_interp, x_log, y_log)
    array([ 20.03438638,  24.63955657,  29.24472675])

    """
    sort_args = np.argsort(xp)

    if hasattr(x, 'units'):
        x = x.m

    if hasattr(xp, 'units'):
        xp = xp.m

    interpolated_vals = np.interp(np.log(x), np.log(xp[sort_args]), fp[sort_args], **kwargs)

    if hasattr(fp, 'units'):
        interpolated_vals = interpolated_vals * fp.units

    return interpolated_vals


@exporter.export
@check_units('[pressure]')
def get_layer(p, *args, heights=None, bottom=None, depth=100 * units.hPa, interpolate=True):
    r"""Return an atmospheric layer from upper air data with the requested bottom and depth.

    This function will subset an upper air dataset to contain only the specified layer. The
    bottom of the layer can be specified with a pressure or height above the surface
    pressure. The bottom defaults to the surface pressure. The depth of the layer can be
    specified in terms of pressure or height above the bottom of the layer. If the top and
    bottom of the layer are not in the data, they are interpolated by default.

    Parameters
    ----------
    p : array-like
        Atmospheric pressure profile
    *args : array-like
        Atmospheric variable(s) measured at the given pressures
    bottom : `pint.Quantity`
        The bottom of the layer as a pressure or height above the surface pressure
    depth : `pint.Quantity`
        The thickness of the layer as a pressure or height above the bottom of the layer
    interpolate : bool
        Interpolate the top and bottom points if they are not in the given data

    Returns
    -------
    `pint.Quantity, pint.Quantity`
        The pressure and data variables of the layer

    """
    # Make sure pressure and datavar are the same length
    for datavar in args:
        if len(p) != len(datavar):
            raise ValueError('Pressure and data variable must have the same length.')

    #
    # Bottom of layer calculations
    #

    # If no bottom is specified, use the first pressure value
    if bottom is None:
        bottom_pressure = p[0]
        if heights is not None:
            bottom_height = heights[0]
        else:
            bottom_height = pressure_to_height_std(bottom_pressure)

    # If the bottom pressure is specified
    else:
        # in pressure units, assign it
        if bottom.dimensionality == {'[length]': -1.0, '[mass]': 1.0, '[time]': -2.0}:

            bottom_pressure = bottom
            if heights is not None:
                bottom_height = log_interp(bottom_pressure, p, heights)
            else:
                bottom_height = pressure_to_height_std(bottom_pressure)
        # in height units
        elif bottom.dimensionality == {'[length]': 1.0}:
            bottom_height = bottom
            if heights is not None:
                bottom_pressure = np.interp(np.array([bottom_height.m]), heights,
                                            p)[0] * p.units
            else:
                bottom_pressure = height_to_pressure_std(bottom_height)

    #
    # Top of layer calculations
    #

    # Depth is in pressure
    if depth.dimensionality == {'[length]': -1.0, '[mass]': 1.0, '[time]': -2.0}:

        top_pressure = bottom_pressure - depth
        if heights is not None:
            top_height = log_interp(top_pressure, p, heights)
        else:
            top_height = pressure_to_height_std(top_pressure)

    # Depth is in height
    elif depth.dimensionality == {'[length]': 1.0}:
        top_height = bottom_height + depth
        if heights is not None:
            top_pressure = np.interp(np.array([top_height.m]), heights, p)[0] * p.units
        else:
            top_pressure = height_to_pressure_std(top_height)

    # Depth is in invalid units
    else:
        raise ValueError('Depth must be in units of length or pressure.')

    # Handle top or bottom values that are invalid
    if bottom_pressure > p[0]:
        raise ValueError(
            'Bottom of layer pressure is greater than the largest pressure in data.')
    if top_pressure < p[-1]:
        raise ValueError('Top of layer pressure is less than the lowest pressure in data.')
    if bottom_pressure < top_pressure:
        raise ValueError(
            'Pressure at the top of the layer is greater than that at the bottom.')

    ret = []  # returned data variables in layer

    # Ensure pressures are sorted in ascending order
    sort_inds = np.argsort(p)
    p = p[sort_inds]

    # Mask based on top and bottom pressure
    inds = (p <= bottom_pressure) & (p >= top_pressure)
    p_interp = p[inds]

    # Interpolate pressures at bounds if necessary and sort
    if interpolate:
        # If we don't have the bottom or top requested, append them
        if top_pressure not in p_interp:
            p_interp = np.sort(np.append(p_interp, top_pressure)) * p.units
        if bottom_pressure not in p_interp:
            p_interp = np.sort(np.append(p_interp, bottom_pressure)) * p.units

    ret.append(p_interp[::-1])

    for datavar in args:
        # Ensure that things are sorted in ascending order
        datavar = datavar[sort_inds]

        if interpolate:
            # Interpolate for the possibly missing bottom/top values
            datavar_interp = log_interp(p_interp, p, datavar)
            datavar = datavar_interp
        else:
            datavar = datavar[inds]

        ret.append(datavar[::-1])

    return ret


1		# Copyright (c) 2008-2017 MetPy Developers.
2		# Distributed under the terms of the BSD 3-Clause License.
3		# SPDX-License-Identifier: BSD-3-Clause
4		"""Contains a collection of generally useful calculation tools."""
5
6		import functools
7
8		import numpy as np
9		import numpy.ma as ma
10		from scipy.spatial import cKDTree
11
12		from . import height_to_pressure_std, pressure_to_height_std
13		from ..package_tools import Exporter
14		from ..units import check_units, units
15
16		exporter = Exporter(globals())
17
18
19		@exporter.export
20		def resample_nn_1d(a, centers):
21		"""Return one-dimensional nearest-neighbor indexes based on user-specified centers.
22
23		Parameters
24		----------
25		a : array-like
26		1-dimensional array of numeric values from which to
27		extract indexes of nearest-neighbors
28		centers : array-like
29		1-dimensional array of numeric values representing a subset of values to approximate
30
31		Returns
32		-------
33		An array of indexes representing values closest to given array values
34
35		"""
36		ix = []
37		for center in centers:
38		index = (np.abs(a - center)).argmin()
39		if index not in ix:
40		ix.append(index)
41		return ix
42
43
44		@exporter.export
45		def nearest_intersection_idx(a, b):
46		"""Determine the index of the point just before two lines with common x values.
47
48		Parameters
49		----------
50		a : array-like
51		1-dimensional array of y-values for line 1
52		b : array-like
53		1-dimensional array of y-values for line 2
54
55		Returns
56		-------
57		An array of indexes representing the index of the values
58		just before the intersection(s) of the two lines.
59
60		"""
61		# Difference in the two y-value sets
62		difference = a - b
63
64		# Determine the point just before the intersection of the lines
65		# Will return multiple points for multiple intersections
66		sign_change_idx, = np.nonzero(np.diff(np.sign(difference)))
67
68		return sign_change_idx
69
70
71		@exporter.export
72		def find_intersections(x, a, b, direction='all'):
73		"""Calculate the best estimate of intersection.
74
75		Calculates the best estimates of the intersection of two y-value
76		data sets that share a common x-value set.
77
78		Parameters
79		----------
80		x : array-like
81		1-dimensional array of numeric x-values
82		a : array-like
83		1-dimensional array of y-values for line 1
84		b : array-like
85		1-dimensional array of y-values for line 2
86		direction : string
87		specifies direction of crossing. 'all', 'increasing' (a becoming greater than b),
88		or 'decreasing' (b becoming greater than a).
89
90		Returns
91		-------
92		A tuple (x, y) of array-like with the x and y coordinates of the
93		intersections of the lines.
94
95		"""
96		# Find the index of the points just before the intersection(s)
97		nearest_idx = nearest_intersection_idx(a, b)
98		next_idx = nearest_idx + 1
99
100		# Determine the sign of the change
101		sign_change = np.sign(a[next_idx] - b[next_idx])
102
103		# x-values around each intersection
104		_, x0 = _next_non_masked_element(x, nearest_idx)
105		_, x1 = _next_non_masked_element(x, next_idx)
106
107		# y-values around each intersection for the first line
108		_, a0 = _next_non_masked_element(a, nearest_idx)
109		_, a1 = _next_non_masked_element(a, next_idx)
110
111		# y-values around each intersection for the second line
112		_, b0 = _next_non_masked_element(b, nearest_idx)
113		_, b1 = _next_non_masked_element(b, next_idx)
114
115		# Calculate the x-intersection. This comes from finding the equations of the two lines,
116		# one through (x0, a0) and (x1, a1) and the other through (x0, b0) and (x1, b1),
117		# finding their intersection, and reducing with a bunch of algebra.
118		delta_y0 = a0 - b0
119		delta_y1 = a1 - b1
120		intersect_x = (delta_y1 * x0 - delta_y0 * x1) / (delta_y1 - delta_y0)
121
122		# Calculate the y-intersection of the lines. Just plug the x above into the equation
123		# for the line through the a points. One could solve for y like x above, but this
124		# causes weirder unit behavior and seems a little less good numerically.
125		intersect_y = ((intersect_x - x0) / (x1 - x0)) * (a1 - a0) + a0
126
127		# Make a mask based on the direction of sign change desired
128		if direction == 'increasing':
129		mask = sign_change > 0
130		elif direction == 'decreasing':
131		mask = sign_change < 0
132		elif direction == 'all':
133		return intersect_x, intersect_y
134		else:
135		raise ValueError('Unknown option for direction: {0}'.format(str(direction)))
136		return intersect_x[mask], intersect_y[mask]
137
138
139		@exporter.export
140		def interpolate_nans(x, y, kind='linear'):
141		"""Interpolate NaN values in y.
142
143		Interpolate NaN values in the y dimension. Works with unsorted x values.
144
145		Parameters
146		----------
147		x : array-like
148		1-dimensional array of numeric x-values
149		y : array-like
150		1-dimensional array of numeric y-values
151		kind : string
152		specifies the kind of interpolation x coordinate - 'linear' or 'log'
153
154		Returns
155		-------
156		An array of the y coordinate data with NaN values interpolated.
157
158		"""
159		x_sort_args = np.argsort(x)
160		x = x[x_sort_args]
161		y = y[x_sort_args]
162		nans = np.isnan(y)
163		if kind == 'linear':
164		y[nans] = np.interp(x[nans], x[~nans], y[~nans])
165		elif kind == 'log':
166		y[nans] = np.interp(np.log(x[nans]), np.log(x[~nans]), y[~nans])
167		else:
168		raise ValueError('Unknown option for kind: {0}'.format(str(kind)))
169		return y[x_sort_args]
170
171
172		def _next_non_masked_element(a, idx):
173		"""Return the next non masked element of a masked array.
174
175		If an array is masked, return the next non-masked element (if the given index is masked).
176		If no other unmasked points are after the given masked point, returns none.
177
178		Parameters
179		----------
180		a : array-like
181		1-dimensional array of numeric values
182		idx : integer
183		index of requested element
184
185		Returns
186		-------
187		Index of next non-masked element and next non-masked element
188
189		"""
190		try:
191		next_idx = idx + a[idx:].mask.argmin()
192		if ma.is_masked(a[next_idx]):
193		return None, None
194		else:
195		return next_idx, a[next_idx]
196		except (AttributeError, TypeError, IndexError):
197		return idx, a[idx]
198
199
200		def delete_masked_points(*arrs):
201		"""Delete masked points from arrays.
202
203		Takes arrays and removes masked points to help with calculations and plotting.
204
205		Parameters
206		----------
207		arrs : one or more array-like
208		source arrays
209
210		Returns
211		-------
212		arrs : one or more array-like
213		arrays with masked elements removed
214
215		"""
216		if any(hasattr(a, 'mask') for a in arrs):
217		keep = ~functools.reduce(np.logical_or, (np.ma.getmaskarray(a) for a in arrs))
218		return tuple(ma.asarray(a[keep]) for a in arrs)
219		else:
220		return arrs
221
222
223		@exporter.export
224		def reduce_point_density(points, radius, priority=None):
225		r"""Return a mask to reduce the density of points in irregularly-spaced data.
226
227		This function is used to down-sample a collection of scattered points (e.g. surface
228		data), returning a mask that can be used to select the points from one or more arrays
229		(e.g. arrays of temperature and dew point). The points selected can be controlled by
230		providing an array of ``priority`` values (e.g. rainfall totals to ensure that
231		stations with higher precipitation remain in the mask).
232
233		Parameters
234		----------
235		points : (N, K) array-like
236		N locations of the points in K dimensional space
237		radius : float
238		minimum radius allowed between points
239		priority : (N, K) array-like, optional
240		If given, this should have the same shape as ``points``; these values will
241		be used to control selection priority for points.
242
243		Returns
244		-------
245		(N,) array-like of boolean values indicating whether points should be kept. This
246		can be used directly to index numpy arrays to return only the desired points.
247
248		Examples
249		--------
250		>>> metpy.calc.reduce_point_density(np.array([1, 2, 3]), 1.)
251		array([ True, False, True], dtype=bool)
252		>>> metpy.calc.reduce_point_density(np.array([1, 2, 3]), 1.,
253		... priority=np.array([0.1, 0.9, 0.3]))
254		array([False, True, False], dtype=bool)
255
256		"""
257		# Handle 1D input
258		if points.ndim < 2:
259		points = points.reshape(-1, 1)
260
261		# Make a kd-tree to speed searching of data.
262		tree = cKDTree(points)
263
264		# Need to use sorted indices rather than sorting the position
265		# so that the keep mask matches original order.
266		if priority is not None:
267		# Need to sort the locations in decreasing priority.
268		sorted_indices = np.argsort(priority)[::-1]
269		else:
270		# Take advantage of iterator nature of range here to avoid making big lists
271		sorted_indices = range(len(points))
272
273		# Keep all points initially
274		keep = np.ones(len(points), dtype=np.bool)
275
276		# Loop over all the potential points
277		for ind in sorted_indices:
278		# Only proceed if we haven't already excluded this point
279		if keep[ind]:
280		# Find the neighbors and eliminate them
281		neighbors = tree.query_ball_point(points[ind], radius)
282		keep[neighbors] = False
283
284		# We just removed ourselves, so undo that
285		keep[ind] = True
286
287		return keep
288
289
290		@exporter.export
291		def log_interp(x, xp, fp, **kwargs):
292		r"""Interpolates data with logarithmic x-scale.
293
294		Interpolation on a logarithmic x-scale for interpolation values in pressure coordintates.
295
296		Parameters
297		----------
298		x : array-like
299		The x-coordinates of the interpolated values.
300
301		xp : array-like
302		The x-coordinates of the data points.
303
304		fp : array-like
305		The y-coordinates of the data points, same length as xp.
306
307		Returns
308		-------
309		array-like
310		The interpolated values, same shape as x.
311
312		Examples
313		--------
314		>>> x_log = np.array([1e3, 1e4, 1e5, 1e6])
315		>>> y_log = np.log(x_log) * 2 + 3
316		>>> x_interp = np.array([5e3, 5e4, 5e5])
317		>>> metpy.calc.log_interp(x_interp, x_log, y_log)
318		array([ 20.03438638, 24.63955657, 29.24472675])
319
320		"""
321		sort_args = np.argsort(xp)
322
323		if hasattr(x, 'units'):
324		x = x.m
325
326		if hasattr(xp, 'units'):
327		xp = xp.m
328
329		interpolated_vals = np.interp(np.log(x), np.log(xp[sort_args]), fp[sort_args], **kwargs)
330
331		if hasattr(fp, 'units'):
332		interpolated_vals = interpolated_vals * fp.units
333
334		return interpolated_vals
335
336
337		@exporter.export
338		@check_units('[pressure]')
339		def get_layer(p, args, heights=None, bottom=None, depth=100 units.hPa, interpolate=True):
340		r"""Return an atmospheric layer from upper air data with the requested bottom and depth.
341
342		This function will subset an upper air dataset to contain only the specified layer. The
343		bottom of the layer can be specified with a pressure or height above the surface
344		pressure. The bottom defaults to the surface pressure. The depth of the layer can be
345		specified in terms of pressure or height above the bottom of the layer. If the top and
346		bottom of the layer are not in the data, they are interpolated by default.
347
348		Parameters
349		----------
350		p : array-like
351		Atmospheric pressure profile
352		*args : array-like
353		Atmospheric variable(s) measured at the given pressures
354		bottom : `pint.Quantity`
355		The bottom of the layer as a pressure or height above the surface pressure
356		depth : `pint.Quantity`
357		The thickness of the layer as a pressure or height above the bottom of the layer
358		interpolate : bool
359		Interpolate the top and bottom points if they are not in the given data
360
361		Returns
362		-------
363		`pint.Quantity, pint.Quantity`
364		The pressure and data variables of the layer
365
366		"""
367		# Make sure pressure and datavar are the same length
368		for datavar in args:
369		if len(p) != len(datavar):
370		raise ValueError('Pressure and data variable must have the same length.')
371
372		#
373		# Bottom of layer calculations
374		#
375
376		# If no bottom is specified, use the first pressure value
377		if bottom is None:
378		bottom_pressure = p[0]
379		if heights is not None:
380		bottom_height = heights[0]
381		else:
382		bottom_height = pressure_to_height_std(bottom_pressure)
383
384		# If the bottom pressure is specified
385		else:
386		# in pressure units, assign it
387	View Code Duplication	if bottom.dimensionality == {'[length]': -1.0, '[mass]': 1.0, '[time]': -2.0}:
		0 ignored issues – show Duplication introduced 2017-06-23 14:36 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
388		bottom_pressure = bottom
389		if heights is not None:
390		bottom_height = log_interp(bottom_pressure, p, heights)
391		else:
392		bottom_height = pressure_to_height_std(bottom_pressure)
393		# in height units
394		elif bottom.dimensionality == {'[length]': 1.0}:
395		bottom_height = bottom
396		if heights is not None:
397		bottom_pressure = np.interp(np.array([bottom_height.m]), heights,
398		p)[0] * p.units
399		else:
400		bottom_pressure = height_to_pressure_std(bottom_height)
401
402		#
403		# Top of layer calculations
404		#
405
406		# Depth is in pressure
407	View Code Duplication	if depth.dimensionality == {'[length]': -1.0, '[mass]': 1.0, '[time]': -2.0}:
		0 ignored issues – show Duplication introduced 2017-06-23 14:36 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
408		top_pressure = bottom_pressure - depth
409		if heights is not None:
410		top_height = log_interp(top_pressure, p, heights)
411		else:
412		top_height = pressure_to_height_std(top_pressure)
413
414		# Depth is in height
415		elif depth.dimensionality == {'[length]': 1.0}:
416		top_height = bottom_height + depth
417		if heights is not None:
418		top_pressure = np.interp(np.array([top_height.m]), heights, p)[0] * p.units
419		else:
420		top_pressure = height_to_pressure_std(top_height)
421
422		# Depth is in invalid units
423		else:
424		raise ValueError('Depth must be in units of length or pressure.')
425
426		# Handle top or bottom values that are invalid
427		if bottom_pressure > p[0]:
428		raise ValueError(
429		'Bottom of layer pressure is greater than the largest pressure in data.')
430		if top_pressure < p[-1]:
431		raise ValueError('Top of layer pressure is less than the lowest pressure in data.')
432		if bottom_pressure < top_pressure:
433		raise ValueError(
434		'Pressure at the top of the layer is greater than that at the bottom.')
435
436		ret = [] # returned data variables in layer
437
438		# Ensure pressures are sorted in ascending order
439		sort_inds = np.argsort(p)
440		p = p[sort_inds]
441
442		# Mask based on top and bottom pressure
443		inds = (p <= bottom_pressure) & (p >= top_pressure)
444		p_interp = p[inds]
445
446		# Interpolate pressures at bounds if necessary and sort
447		if interpolate:
448		# If we don't have the bottom or top requested, append them
449		if top_pressure not in p_interp:
450		p_interp = np.sort(np.append(p_interp, top_pressure)) * p.units
451		if bottom_pressure not in p_interp:
452		p_interp = np.sort(np.append(p_interp, bottom_pressure)) * p.units
453
454		ret.append(p_interp[::-1])
455
456		for datavar in args:
457		# Ensure that things are sorted in ascending order
458		datavar = datavar[sort_inds]
459
460		if interpolate:
461		# Interpolate for the possibly missing bottom/top values
462		datavar_interp = log_interp(p_interp, p, datavar)
463		datavar = datavar_interp
464		else:
465		datavar = datavar[inds]
466
467		ret.append(datavar[::-1])
468
469		return ret
470

Unidata / MetPy

Pull Request — master (#444)

get_layer() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like