def _regrid_area_weighted_rectilinear_src_and_grid__perform(
src_cube, regrid_info, mdtol):
"""
Second (regrid) part of 'regrid_area_weighted_rectilinear_src_and_grid'.
Perform the prepared regrid calculation on a single 2d cube.
"""
(
src_x,
src_y,
src_x_dim,
src_y_dim,
grid_x,
grid_y,
meshgrid_x,
meshgrid_y,
weights_info,
index_info,
) = regrid_info
# Calculate new data array for regridded cube.
regrid = functools.partial(
_regrid_area_weighted_array,
x_dim=src_x_dim,
y_dim=src_y_dim,
weights_info=weights_info,
index_info=index_info,
mdtol=mdtol,
)
new_data = map_complete_blocks(src_cube, regrid, (src_y_dim, src_x_dim),
meshgrid_x.shape)
# Wrap up the data as a Cube.
regrid_callback = RectilinearRegridder._regrid
new_cube = RectilinearRegridder._create_cube(
new_data,
src_cube,
src_x_dim,
src_y_dim,
src_x,
src_y,
grid_x,
grid_y,
meshgrid_x,
meshgrid_y,
regrid_callback,
)
# Slice out any length 1 dimensions.
indices = [slice(None, None)] * new_data.ndim
if src_x_dim is not None and new_cube.shape[src_x_dim] == 1:
indices[src_x_dim] = 0
if src_y_dim is not None and new_cube.shape[src_y_dim] == 1:
indices[src_y_dim] = 0
if 0 in indices:
new_cube = new_cube[tuple(indices)]
return new_cube
def regrid_conservative_via_esmpy(source_cube, grid_cube):
"""
Perform a conservative regridding with ESMPy.
Regrids the data of a source cube onto a new grid defined by a destination
cube.
Args:
* source_cube (:class:`iris.cube.Cube`):
Source data. Must have two identifiable horizontal dimension
coordinates.
* grid_cube (:class:`iris.cube.Cube`):
Define the target horizontal grid: Only the horizontal dimension
coordinates are actually used.
Returns:
A new cube derived from source_cube, regridded onto the specified
horizontal grid.
Any additional coordinates which map onto the horizontal dimensions are
removed, while all other metadata is retained.
If there are coordinate factories with 2d horizontal reference surfaces,
the reference surfaces are also regridded, using ordinary bilinear
interpolation.
.. note::
Both source and destination cubes must have two dimension coordinates
identified with axes 'X' and 'Y' which share a coord_system with a
Cartopy CRS.
The grids are defined by :meth:`iris.coords.Coord.contiguous_bounds` of
these.
.. note::
Initialises the ESMF Manager, if it was not already called.
This implements default Manager operations (e.g. logging).
To alter this, make a prior call to ESMF.Manager().
"""
# Lazy import so we can build the docs with no ESMF.
import ESMF
# Get source + target XY coordinate pairs and check they are suitable.
src_coords = get_xy_dim_coords(source_cube)
dst_coords = get_xy_dim_coords(grid_cube)
src_cs = src_coords[0].coord_system
grid_cs = dst_coords[0].coord_system
if src_cs is None or grid_cs is None:
raise ValueError("Both 'src' and 'grid' Cubes must have a"
" coordinate system for their rectilinear grid"
" coordinates.")
if src_cs.as_cartopy_crs() is None or grid_cs.as_cartopy_crs() is None:
raise ValueError("Both 'src' and 'grid' Cubes coord_systems must have "
"a valid associated Cartopy CRS.")
def _valid_units(coord):
if isinstance(coord.coord_system, (iris.coord_systems.GeogCS,
iris.coord_systems.RotatedGeogCS)):
valid_units = 'degrees'
else:
valid_units = 'm'
return coord.units == valid_units
if not all(_valid_units(coord) for coord in src_coords + dst_coords):
raise ValueError("Unsupported units: must be 'degrees' or 'm'.")
# Initialise the ESMF manager in case it was not already done.
ESMF.Manager()
# Create a data array for the output cube.
src_dims_xy = [source_cube.coord_dims(coord)[0] for coord in src_coords]
# Size matches source, except for X+Y dimensions
dst_shape = np.array(source_cube.shape)
dst_shape[src_dims_xy] = [coord.shape[0] for coord in dst_coords]
# NOTE: result array is masked -- fix this afterward if all unmasked
fullcube_data = np.ma.zeros(dst_shape)
# Iterate 2d slices over all possible indices of the 'other' dimensions
all_other_dims = [i_dim for i_dim in range(source_cube.ndim)
if i_dim not in src_dims_xy]
all_combinations_of_other_inds = np.ndindex(*dst_shape[all_other_dims])
for other_indices in all_combinations_of_other_inds:
# Construct a tuple of slices to address the 2d xy field
slice_indices_array = np.array([slice(None)] * source_cube.ndim)
slice_indices_array[all_other_dims] = other_indices
slice_indices_tuple = tuple(slice_indices_array)
# Get the source data, reformed into the right dimension order, (x,y).
src_data_2d = source_cube.data[slice_indices_tuple]
if (src_dims_xy[0] > src_dims_xy[1]):
src_data_2d = src_data_2d.transpose()
# Work out whether we have missing data to define a source grid mask.
if np.ma.is_masked(src_data_2d):
srcdata_mask = np.ma.getmask(src_data_2d)
else:
srcdata_mask = None
# Construct ESMF Field objects on source and destination grids.
src_field = _make_esmpy_field(src_coords[0], src_coords[1],
data=src_data_2d, mask=srcdata_mask)
dst_field = _make_esmpy_field(dst_coords[0], dst_coords[1])
# Make Field for destination coverage fraction (for missing data calc).
coverage_field = ESMF.Field(dst_field.grid, 'validmask_dst')
# Do the actual regrid with ESMF.
mask_flag_values = np.array([1], dtype=np.int32)
regrid_method = ESMF.Regrid(src_field, dst_field,
src_mask_values=mask_flag_values,
regrid_method=ESMF.RegridMethod.CONSERVE,
unmapped_action=ESMF.UnmappedAction.IGNORE,
dst_frac_field=coverage_field)
regrid_method(src_field, dst_field)
data = dst_field.data
# Convert destination 'coverage fraction' into a missing-data mask.
# Set = wherever part of cell goes outside source grid, or overlaps a
# masked source cell.
coverage_tolerance_threshold = 1.0 - 1.0e-8
data.mask = coverage_field.data < coverage_tolerance_threshold
# Transpose ESMF result dims (X,Y) back to the order of the source
if (src_dims_xy[0] > src_dims_xy[1]):
data = data.transpose()
# Paste regridded slice back into parent array
fullcube_data[slice_indices_tuple] = data
# Remove the data mask if completely unused.
if not np.ma.is_masked(fullcube_data):
fullcube_data = np.array(fullcube_data)
# Generate a full 2d sample grid, as required for regridding orography
# NOTE: as seen in "regrid_bilinear_rectilinear_src_and_grid"
# TODO: can this not also be wound into the _create_cube method ?
src_cs = src_coords[0].coord_system
sample_grid_x, sample_grid_y = RectilinearRegridder._sample_grid(
src_cs, dst_coords[0], dst_coords[1])
# Return result as a new cube based on the source.
# TODO: please tidy this interface !!!
return RectilinearRegridder._create_cube(
fullcube_data,
src=source_cube,
x_dim=src_dims_xy[0],
y_dim=src_dims_xy[1],
src_x_coord=src_coords[0],
src_y_coord=src_coords[1],
grid_x_coord=dst_coords[0],
grid_y_coord=dst_coords[1],
sample_grid_x=sample_grid_x,
sample_grid_y=sample_grid_y,
regrid_callback=RectilinearRegridder._regrid)
def regrid_conservative_via_esmpy(source_cube, grid_cube):
"""
Perform a conservative regridding with ESMPy.
Regrids the data of a source cube onto a new grid defined by a destination
cube.
Args:
* source_cube (:class:`iris.cube.Cube`):
Source data. Must have two identifiable horizontal dimension
coordinates.
* grid_cube (:class:`iris.cube.Cube`):
Define the target horizontal grid: Only the horizontal dimension
coordinates are actually used.
Returns:
A new cube derived from source_cube, regridded onto the specified
horizontal grid.
Any additional coordinates which map onto the horizontal dimensions are
removed, while all other metadata is retained.
If there are coordinate factories with 2d horizontal reference surfaces,
the reference surfaces are also regridded, using ordinary bilinear
interpolation.
.. note::
Both source and destination cubes must have two dimension coordinates
identified with axes 'X' and 'Y' which share a coord_system with a
Cartopy CRS.
The grids are defined by :meth:`iris.coords.Coord.contiguous_bounds` of
these.
.. note::
Initialises the ESMF Manager, if it was not already called.
This implements default Manager operations (e.g. logging).
To alter this, make a prior call to ESMF.Manager().
"""
# Lazy import so we can build the docs with no ESMF.
import ESMF
# Get source + target XY coordinate pairs and check they are suitable.
src_coords = get_xy_dim_coords(source_cube)
dst_coords = get_xy_dim_coords(grid_cube)
src_cs = src_coords[0].coord_system
grid_cs = dst_coords[0].coord_system
if src_cs is None or grid_cs is None:
raise ValueError("Both 'src' and 'grid' Cubes must have a"
" coordinate system for their rectilinear grid"
" coordinates.")
if src_cs.as_cartopy_crs() is None or grid_cs.as_cartopy_crs() is None:
raise ValueError("Both 'src' and 'grid' Cubes coord_systems must have "
"a valid associated Cartopy CRS.")
def _valid_units(coord):
if isinstance(coord.coord_system, (iris.coord_systems.GeogCS,
iris.coord_systems.RotatedGeogCS)):
valid_units = 'degrees'
else:
valid_units = 'm'
return coord.units == valid_units
if not all(_valid_units(coord) for coord in src_coords + dst_coords):
raise ValueError("Unsupported units: must be 'degrees' or 'm'.")
# Initialise the ESMF manager in case it was not already done.
ESMF.Manager()
# Create a data array for the output cube.
src_dims_xy = [source_cube.coord_dims(coord)[0] for coord in src_coords]
# Size matches source, except for X+Y dimensions
dst_shape = np.array(source_cube.shape)
dst_shape[src_dims_xy] = [coord.shape[0] for coord in dst_coords]
# NOTE: result array is masked -- fix this afterward if all unmasked
fullcube_data = np.ma.zeros(dst_shape)
# Iterate 2d slices over all possible indices of the 'other' dimensions
all_other_dims = [i_dim for i_dim in range(source_cube.ndim)
if i_dim not in src_dims_xy]
all_combinations_of_other_inds = np.ndindex(*dst_shape[all_other_dims])
for other_indices in all_combinations_of_other_inds:
# Construct a tuple of slices to address the 2d xy field
slice_indices_array = np.array([slice(None)] * source_cube.ndim)
slice_indices_array[all_other_dims] = other_indices
slice_indices_tuple = tuple(slice_indices_array)
# Get the source data, reformed into the right dimension order, (x,y).
src_data_2d = source_cube.data[slice_indices_tuple]
if (src_dims_xy[0] > src_dims_xy[1]):
src_data_2d = src_data_2d.transpose()
# Work out whether we have missing data to define a source grid mask.
if np.ma.is_masked(src_data_2d):
srcdata_mask = np.ma.getmask(src_data_2d)
else:
srcdata_mask = None
# Construct ESMF Field objects on source and destination grids.
src_field = _make_esmpy_field(src_coords[0], src_coords[1],
data=src_data_2d, mask=srcdata_mask)
dst_field = _make_esmpy_field(dst_coords[0], dst_coords[1])
# Make Field for destination coverage fraction (for missing data calc).
coverage_field = ESMF.Field(dst_field.grid, 'validmask_dst')
# Do the actual regrid with ESMF.
mask_flag_values = np.array([1], dtype=np.int32)
regrid_method = ESMF.Regrid(src_field, dst_field,
src_mask_values=mask_flag_values,
regrid_method=ESMF.RegridMethod.CONSERVE,
unmapped_action=ESMF.UnmappedAction.IGNORE,
dst_frac_field=coverage_field)
regrid_method(src_field, dst_field)
data = np.ma.masked_array(dst_field.data)
# Convert destination 'coverage fraction' into a missing-data mask.
# Set = wherever part of cell goes outside source grid, or overlaps a
# masked source cell.
coverage_tolerance_threshold = 1.0 - 1.0e-8
data.mask = coverage_field.data < coverage_tolerance_threshold
# Transpose ESMF result dims (X,Y) back to the order of the source
if (src_dims_xy[0] > src_dims_xy[1]):
data = data.transpose()
# Paste regridded slice back into parent array
fullcube_data[slice_indices_tuple] = data
# Remove the data mask if completely unused.
if not np.ma.is_masked(fullcube_data):
fullcube_data = np.array(fullcube_data)
# Generate a full 2d sample grid, as required for regridding orography
# NOTE: as seen in "regrid_bilinear_rectilinear_src_and_grid"
# TODO: can this not also be wound into the _create_cube method ?
src_cs = src_coords[0].coord_system
sample_grid_x, sample_grid_y = RectilinearRegridder._sample_grid(
src_cs, dst_coords[0], dst_coords[1])
# Return result as a new cube based on the source.
# TODO: please tidy this interface !!!
return RectilinearRegridder._create_cube(
fullcube_data,
src=source_cube,
x_dim=src_dims_xy[0],
y_dim=src_dims_xy[1],
src_x_coord=src_coords[0],
src_y_coord=src_coords[1],
grid_x_coord=dst_coords[0],
grid_y_coord=dst_coords[1],
sample_grid_x=sample_grid_x,
sample_grid_y=sample_grid_y,
regrid_callback=RectilinearRegridder._regrid)
def regrid_area_weighted_rectilinear_src_and_grid(src_cube, grid_cube,
mdtol=0):
"""
Return a new cube with data values calculated using the area weighted
mean of data values from src_grid regridded onto the horizontal grid of
grid_cube.
This function requires that the horizontal grids of both cubes are
rectilinear (i.e. expressed in terms of two orthogonal 1D coordinates)
and that these grids are in the same coordinate system. This function
also requires that the coordinates describing the horizontal grids
all have bounds.
.. note::
Elements in data array of the returned cube that lie either partially
or entirely outside of the horizontal extent of the src_cube will
be masked irrespective of the value of mdtol.
Args:
* src_cube:
An instance of :class:`iris.cube.Cube` that supplies the data,
metadata and coordinates.
* grid_cube:
An instance of :class:`iris.cube.Cube` that supplies the desired
horizontal grid definition.
Kwargs:
* mdtol:
Tolerance of missing data. The value returned in each element of the
returned cube's data array will be masked if the fraction of masked
data in the overlapping cells of the source cube exceeds mdtol. This
fraction is calculated based on the area of masked cells within each
target cell. mdtol=0 means no missing data is tolerated while mdtol=1
will mean the resulting element will be masked if and only if all the
overlapping cells of the source cube are masked. Defaults to 0.
Returns:
A new :class:`iris.cube.Cube` instance.
"""
# Get the 1d monotonic (or scalar) src and grid coordinates.
src_x, src_y = _get_xy_coords(src_cube)
grid_x, grid_y = _get_xy_coords(grid_cube)
# Condition 1: All x and y coordinates must have contiguous bounds to
# define areas.
if not src_x.is_contiguous() or not src_y.is_contiguous() or \
not grid_x.is_contiguous() or not grid_y.is_contiguous():
raise ValueError("The horizontal grid coordinates of both the source "
"and grid cubes must have contiguous bounds.")
# Condition 2: Everything must have the same coordinate system.
src_cs = src_x.coord_system
grid_cs = grid_x.coord_system
if src_cs != grid_cs:
raise ValueError("The horizontal grid coordinates of both the source "
"and grid cubes must have the same coordinate "
"system.")
# Condition 3: cannot create vector coords from scalars.
src_x_dims = src_cube.coord_dims(src_x)
src_x_dim = None
if src_x_dims:
src_x_dim = src_x_dims[0]
src_y_dims = src_cube.coord_dims(src_y)
src_y_dim = None
if src_y_dims:
src_y_dim = src_y_dims[0]
if src_x_dim is None and grid_x.shape[0] != 1 or \
src_y_dim is None and grid_y.shape[0] != 1:
raise ValueError('The horizontal grid coordinates of source cube '
'includes scalar coordinates, but the new grid does '
'not. The new grid must not require additional data '
'dimensions to be created.')
# Determine whether to calculate flat or spherical areas.
# Don't only rely on coord system as it may be None.
spherical = (isinstance(src_cs, (iris.coord_systems.GeogCS,
iris.coord_systems.RotatedGeogCS)) or
src_x.units == 'degrees' or src_x.units == 'radians')
# Get src and grid bounds in the same units.
x_units = iris.unit.Unit('radians') if spherical else src_x.units
y_units = iris.unit.Unit('radians') if spherical else src_y.units
# Operate in highest precision.
src_dtype = np.promote_types(src_x.bounds.dtype, src_y.bounds.dtype)
grid_dtype = np.promote_types(grid_x.bounds.dtype, grid_y.bounds.dtype)
dtype = np.promote_types(src_dtype, grid_dtype)
src_x_bounds = _get_bounds_in_units(src_x, x_units, dtype)
src_y_bounds = _get_bounds_in_units(src_y, y_units, dtype)
grid_x_bounds = _get_bounds_in_units(grid_x, x_units, dtype)
grid_y_bounds = _get_bounds_in_units(grid_y, y_units, dtype)
# Determine whether target grid bounds are decreasing. This must
# be determined prior to wrap_lons being called.
grid_x_decreasing = grid_x_bounds[-1, 0] < grid_x_bounds[0, 0]
grid_y_decreasing = grid_y_bounds[-1, 0] < grid_y_bounds[0, 0]
# Wrapping of longitudes.
if spherical:
base = np.min(src_x_bounds)
modulus = x_units.modulus
# Only wrap if necessary to avoid introducing floating
# point errors.
if np.min(grid_x_bounds) < base or \
np.max(grid_x_bounds) > (base + modulus):
grid_x_bounds = iris.analysis.cartography.wrap_lons(grid_x_bounds,
base, modulus)
# Determine whether the src_x coord has periodic boundary conditions.
circular = getattr(src_x, 'circular', False)
# Use simple cartesian area function or one that takes into
# account the curved surface if coord system is spherical.
if spherical:
area_func = _spherical_area
else:
area_func = _cartesian_area
# Calculate new data array for regridded cube.
new_data = _regrid_area_weighted_array(src_cube.data, src_x_dim, src_y_dim,
src_x_bounds, src_y_bounds,
grid_x_bounds, grid_y_bounds,
grid_x_decreasing,
grid_y_decreasing,
area_func, circular, mdtol)
# Wrap up the data as a Cube.
# Create 2d meshgrids as required by _create_cube func.
meshgrid_x, meshgrid_y = np.meshgrid(grid_x.points, grid_y.points)
regrid_callback = RectilinearRegridder._regrid
new_cube = RectilinearRegridder._create_cube(new_data, src_cube,
src_x_dim, src_y_dim,
src_x, src_y, grid_x, grid_y,
meshgrid_x, meshgrid_y,
regrid_callback)
# Slice out any length 1 dimensions.
indices = [slice(None, None)] * new_data.ndim
if src_x_dim is not None and new_cube.shape[src_x_dim] == 1:
indices[src_x_dim] = 0
if src_y_dim is not None and new_cube.shape[src_y_dim] == 1:
indices[src_y_dim] = 0
if 0 in indices:
new_cube = new_cube[tuple(indices)]
return new_cube
def regrid_area_weighted_rectilinear_src_and_grid(src_cube,
grid_cube,
mdtol=0):
"""
Return a new cube with data values calculated using the area weighted
mean of data values from src_grid regridded onto the horizontal grid of
grid_cube.
This function requires that the horizontal grids of both cubes are
rectilinear (i.e. expressed in terms of two orthogonal 1D coordinates)
and that these grids are in the same coordinate system. This function
also requires that the coordinates describing the horizontal grids
all have bounds.
.. note::
Elements in data array of the returned cube that lie either partially
or entirely outside of the horizontal extent of the src_cube will
be masked irrespective of the value of mdtol.
Args:
* src_cube:
An instance of :class:`iris.cube.Cube` that supplies the data,
metadata and coordinates.
* grid_cube:
An instance of :class:`iris.cube.Cube` that supplies the desired
horizontal grid definition.
Kwargs:
* mdtol:
Tolerance of missing data. The value returned in each element of the
returned cube's data array will be masked if the fraction of masked
data in the overlapping cells of the source cube exceeds mdtol. This
fraction is calculated based on the area of masked cells within each
target cell. mdtol=0 means no missing data is tolerated while mdtol=1
will mean the resulting element will be masked if and only if all the
overlapping cells of the source cube are masked. Defaults to 0.
Returns:
A new :class:`iris.cube.Cube` instance.
"""
# Get the 1d monotonic (or scalar) src and grid coordinates.
src_x, src_y = _get_xy_coords(src_cube)
grid_x, grid_y = _get_xy_coords(grid_cube)
# Condition 1: All x and y coordinates must have contiguous bounds to
# define areas.
if not src_x.is_contiguous() or not src_y.is_contiguous() or \
not grid_x.is_contiguous() or not grid_y.is_contiguous():
raise ValueError("The horizontal grid coordinates of both the source "
"and grid cubes must have contiguous bounds.")
# Condition 2: Everything must have the same coordinate system.
src_cs = src_x.coord_system
grid_cs = grid_x.coord_system
if src_cs != grid_cs:
raise ValueError("The horizontal grid coordinates of both the source "
"and grid cubes must have the same coordinate "
"system.")
# Condition 3: cannot create vector coords from scalars.
src_x_dims = src_cube.coord_dims(src_x)
src_x_dim = None
if src_x_dims:
src_x_dim = src_x_dims[0]
src_y_dims = src_cube.coord_dims(src_y)
src_y_dim = None
if src_y_dims:
src_y_dim = src_y_dims[0]
if src_x_dim is None and grid_x.shape[0] != 1 or \
src_y_dim is None and grid_y.shape[0] != 1:
raise ValueError('The horizontal grid coordinates of source cube '
'includes scalar coordinates, but the new grid does '
'not. The new grid must not require additional data '
'dimensions to be created.')
# Determine whether to calculate flat or spherical areas.
# Don't only rely on coord system as it may be None.
spherical = (isinstance(
src_cs, (iris.coord_systems.GeogCS, iris.coord_systems.RotatedGeogCS))
or src_x.units == 'degrees' or src_x.units == 'radians')
# Get src and grid bounds in the same units.
x_units = iris.unit.Unit('radians') if spherical else src_x.units
y_units = iris.unit.Unit('radians') if spherical else src_y.units
# Operate in highest precision.
src_dtype = np.promote_types(src_x.bounds.dtype, src_y.bounds.dtype)
grid_dtype = np.promote_types(grid_x.bounds.dtype, grid_y.bounds.dtype)
dtype = np.promote_types(src_dtype, grid_dtype)
src_x_bounds = _get_bounds_in_units(src_x, x_units, dtype)
src_y_bounds = _get_bounds_in_units(src_y, y_units, dtype)
grid_x_bounds = _get_bounds_in_units(grid_x, x_units, dtype)
grid_y_bounds = _get_bounds_in_units(grid_y, y_units, dtype)
# Determine whether target grid bounds are decreasing. This must
# be determined prior to wrap_lons being called.
grid_x_decreasing = grid_x_bounds[-1, 0] < grid_x_bounds[0, 0]
grid_y_decreasing = grid_y_bounds[-1, 0] < grid_y_bounds[0, 0]
# Wrapping of longitudes.
if spherical:
base = np.min(src_x_bounds)
modulus = x_units.modulus
# Only wrap if necessary to avoid introducing floating
# point errors.
if np.min(grid_x_bounds) < base or \
np.max(grid_x_bounds) > (base + modulus):
grid_x_bounds = iris.analysis.cartography.wrap_lons(
grid_x_bounds, base, modulus)
# Determine whether the src_x coord has periodic boundary conditions.
circular = getattr(src_x, 'circular', False)
# Use simple cartesian area function or one that takes into
# account the curved surface if coord system is spherical.
if spherical:
area_func = _spherical_area
else:
area_func = _cartesian_area
# Calculate new data array for regridded cube.
new_data = _regrid_area_weighted_array(src_cube.data, src_x_dim, src_y_dim,
src_x_bounds, src_y_bounds,
grid_x_bounds, grid_y_bounds,
grid_x_decreasing,
grid_y_decreasing, area_func,
circular, mdtol)
# Wrap up the data as a Cube.
# Create 2d meshgrids as required by _create_cube func.
meshgrid_x, meshgrid_y = np.meshgrid(grid_x.points, grid_y.points)
regrid_callback = RectilinearRegridder._regrid
new_cube = RectilinearRegridder._create_cube(new_data, src_cube, src_x_dim,
src_y_dim, src_x, src_y,
grid_x, grid_y, meshgrid_x,
meshgrid_y, regrid_callback)
# Slice out any length 1 dimensions.
indices = [slice(None, None)] * new_data.ndim
if src_x_dim is not None and new_cube.shape[src_x_dim] == 1:
indices[src_x_dim] = 0
if src_y_dim is not None and new_cube.shape[src_y_dim] == 1:
indices[src_y_dim] = 0
if 0 in indices:
new_cube = new_cube[tuple(indices)]
return new_cube
