def test_orthogonal_with_realization(self):
# => fp: 2; rt: 2; t: 2; realization: 2
triples = ((0, 10, 1), (0, 10, 2), (0, 11, 1), (0, 11, 2), (1, 10, 1),
(1, 10, 2), (1, 11, 1), (1, 11, 2))
en1_cubes = [
self._make_cube(*triple, realization=1) for triple in triples
]
en2_cubes = [
self._make_cube(*triple, realization=2) for triple in triples
]
cubes = CubeList(en1_cubes) + CubeList(en2_cubes)
cube, = cubes.merge()
self.assertCML(cube, checksum=False)
def test_combination_with_extra_triple(self):
# => fp, rt, t, realization: 17
triples = ((0, 10, 1), (0, 10, 2), (0, 11, 1), (0, 11, 2), (1, 10, 1),
(1, 10, 2), (1, 11, 1), (1, 11, 2))
en1_cubes = [
self._make_cube(*triple, realization=1) for triple in triples
]
# Add extra time triple on the end.
en2_cubes = [
self._make_cube(*triple, realization=2)
for triple in triples + ((1, 11, 3), )
]
cubes = CubeList(en1_cubes) + CubeList(en2_cubes)
cube, = cubes.merge()
self.assertCML(cube, checksum=False)
def test_combination_with_extra_realization(self):
# => fp, rt, t, realization: 17
triples = ((0, 10, 1), (0, 10, 2), (0, 11, 1), (0, 11, 2), (1, 10, 1),
(1, 10, 2), (1, 11, 1), (1, 11, 2))
en1_cubes = [
self._make_cube(*triple, realization=1) for triple in triples
]
en2_cubes = [
self._make_cube(*triple, realization=2) for triple in triples
]
# Add extra that is a duplicate of one of the time triples
# but with a different realisation.
en3_cubes = [self._make_cube(0, 10, 2, realization=3)]
cubes = CubeList(en1_cubes) + CubeList(en2_cubes) + CubeList(en3_cubes)
cube, = cubes.merge()
self.assertCML(cube, checksum=False)
def test_combination_with_realization(self):
# => fp, rt, t: 8; realization: 2
triples = ((0, 10, 1),
(0, 10, 2),
(0, 11, 1),
(0, 11, 3), # This '3' breaks the pattern.
(1, 10, 1),
(1, 10, 2),
(1, 11, 1),
(1, 11, 2))
en1_cubes = [self._make_cube(*triple, realization=1) for
triple in triples]
en2_cubes = [self._make_cube(*triple, realization=2) for
triple in triples]
cubes = CubeList(en1_cubes) + CubeList(en2_cubes)
cube, = cubes.merge()
self.assertCML(cube, checksum=False)
def test_orthogonal_with_realization(self):
# => fp: 2; rt: 2; t: 2; realization: 2
triples = ((0, 10, 1),
(0, 10, 2),
(0, 11, 1),
(0, 11, 2),
(1, 10, 1),
(1, 10, 2),
(1, 11, 1),
(1, 11, 2))
en1_cubes = [self._make_cube(*triple, realization=1) for
triple in triples]
en2_cubes = [self._make_cube(*triple, realization=2) for
triple in triples]
cubes = CubeList(en1_cubes) + CubeList(en2_cubes)
cube, = cubes.merge()
self.assertCML(cube, checksum=False)
def test_combination_with_extra_triple(self):
# => fp, rt, t, realization: 17
triples = ((0, 10, 1),
(0, 10, 2),
(0, 11, 1),
(0, 11, 2),
(1, 10, 1),
(1, 10, 2),
(1, 11, 1),
(1, 11, 2))
en1_cubes = [self._make_cube(*triple, realization=1) for
triple in triples]
# Add extra time triple on the end.
en2_cubes = [self._make_cube(*triple, realization=2) for
triple in triples + ((1, 11, 3),)]
cubes = CubeList(en1_cubes) + CubeList(en2_cubes)
cube, = cubes.merge()
self.assertCML(cube, checksum=False)
def test_combination_with_extra_realization(self):
# => fp, rt, t, realization: 17
triples = ((0, 10, 1),
(0, 10, 2),
(0, 11, 1),
(0, 11, 2),
(1, 10, 1),
(1, 10, 2),
(1, 11, 1),
(1, 11, 2))
en1_cubes = [self._make_cube(*triple, realization=1) for
triple in triples]
en2_cubes = [self._make_cube(*triple, realization=2) for
triple in triples]
# Add extra that is a duplicate of one of the time triples
# but with a different realisation.
en3_cubes = [self._make_cube(0, 10, 2, realization=3)]
cubes = CubeList(en1_cubes) + CubeList(en2_cubes) + CubeList(en3_cubes)
cube, = cubes.merge()
self.assertCML(cube, checksum=False)
def extract_cell_cubes_subset_2D(cubelist_in,
mask,
track,
cell,
z_coord='model_level_number'):
import iris
from iris import Constraint
from iris.cube import CubeList
import numpy as np
from tobac import mask_cell_surface, get_bounding_box
from copy import deepcopy
track_i = track[track['cell'] == cell]
cubelist_cell_sum = CubeList()
for time_i in track_i['time'].values:
logging.debug('start extracting cubes for cell ' + str(cell) +
' and time ' + str(time_i))
constraint_time = Constraint(time=time_i)
mask_i = mask.extract(constraint_time)
mask_cell_surface_i = mask_cell_surface(mask_i,
cell,
track_i,
masked=False,
z_coord=z_coord)
x_dim = mask_cell_surface_i.coord_dims('projection_x_coordinate')[0]
y_dim = mask_cell_surface_i.coord_dims('projection_y_coordinate')[0]
x_coord = mask_cell_surface_i.coord('projection_x_coordinate')
y_coord = mask_cell_surface_i.coord('projection_y_coordinate')
if (mask_cell_surface_i.core_data() > 0).any():
box_mask_i = get_bounding_box(mask_cell_surface_i.core_data(),
buffer=1)
box_mask = [[
x_coord.points[box_mask_i[x_dim][0]],
x_coord.points[box_mask_i[x_dim][1]]
],
[
y_coord.points[box_mask_i[y_dim][0]],
y_coord.points[box_mask_i[y_dim][1]]
]]
else:
box_mask = [[np.nan, np.nan], [np.nan, np.nan]]
width = 20
dx = 500
x = track_i[track_i['time'].values ==
time_i]['projection_x_coordinate'].values[0]
y = track_i[track_i['time'].values ==
time_i]['projection_y_coordinate'].values[0]
n_add_width = 2
box_slice = [[
x - (width + n_add_width) * dx, x + (width + n_add_width) * dx
], [y - (width + n_add_width) * dx, y + (width + n_add_width) * dx]]
x_min = np.nanmin([box_mask[0][0], box_slice[0][0]])
x_max = np.nanmax([box_mask[0][1], box_slice[0][1]])
y_min = np.nanmin([box_mask[1][0], box_slice[1][0]])
y_max = np.nanmax([box_mask[1][1], box_slice[1][1]])
constraint_x = Constraint(projection_x_coordinate=lambda cell: int(
x_min) < cell < int(x_max))
constraint_y = Constraint(projection_y_coordinate=lambda cell: int(
y_min) < cell < int(y_max))
constraint = constraint_time & constraint_x & constraint_y
mask_cell_surface_i = mask_cell_surface_i.extract(constraint_x
& constraint_y)
cubelist_i = cubelist_in.extract(constraint)
cubelist_cell_sum.extend(
sum_mask_surface(cubelist_i, mask_cell_surface_i))
logging.debug(str(cubelist_cell_sum))
cubelist_cell_sum_out = cubelist_cell_sum.merge()
logging.debug(str(cubelist_cell_sum_out))
for cube in cubelist_cell_sum_out:
logging.debug(str(cube))
logging.debug(str(cube.attributes))
logging.debug(str(cube.coords()))
if len(cubelist_cell_sum_out) == 6:
logging.debug(
str(
iris.util.describe_diff(cubelist_cell_sum_out[0],
cubelist_cell_sum_out[3])))
logging.debug(
str(
iris.util.describe_diff(cubelist_cell_sum_out[1],
cubelist_cell_sum_out[4])))
logging.debug(
str(
iris.util.describe_diff(cubelist_cell_sum_out[2],
cubelist_cell_sum_out[5])))
track_cell = deepcopy(track_i)
for cube in cubelist_cell_sum_out:
logging.debug(f'cube.shape: {cube.shape}')
logging.debug(f'len(track_cell): {len(track_cell)}')
logging.debug(f'cube.coord("time"): {cube.coord("time")}')
logging.debug(f'track_cell[time]: {track_cell["time"]}')
track_cell[cube.name()] = cube.core_data()
return cubelist_cell_sum_out, track_cell
def extract_cell_cubes_subset(cubelist_in,
mask,
track,
cell,
z_coord='model_level_number',
height_levels=None):
from iris.analysis import SUM
from iris import Constraint
from iris.cube import CubeList
from iris.coords import AuxCoord
import numpy as np
from tobac import mask_cell, mask_cell_surface, get_bounding_box
from copy import deepcopy
track_i = track[track['cell'] == cell]
cubelist_cell_integrated_out = CubeList()
cubelist_cell_sum = CubeList()
for time_i in track_i['time'].values:
logging.debug('start extracting cubes for cell ' + str(cell) +
' and time ' + str(time_i))
constraint_time = Constraint(time=time_i)
mask_i = mask.extract(constraint_time)
mask_cell_i = mask_cell(mask_i, cell, track_i, masked=False)
mask_cell_surface_i = mask_cell_surface(mask_i,
cell,
track_i,
masked=False,
z_coord=z_coord)
x_dim = mask_cell_surface_i.coord_dims('projection_x_coordinate')[0]
y_dim = mask_cell_surface_i.coord_dims('projection_y_coordinate')[0]
x_coord = mask_cell_surface_i.coord('projection_x_coordinate')
y_coord = mask_cell_surface_i.coord('projection_y_coordinate')
if (mask_cell_surface_i.core_data() > 0).any():
box_mask_i = get_bounding_box(mask_cell_surface_i.core_data(),
buffer=1)
box_mask = [[
x_coord.points[box_mask_i[x_dim][0]],
x_coord.points[box_mask_i[x_dim][1]]
],
[
y_coord.points[box_mask_i[y_dim][0]],
y_coord.points[box_mask_i[y_dim][1]]
]]
else:
box_mask = [[np.nan, np.nan], [np.nan, np.nan]]
width = 20
dx = 500
x = track_i[track_i['time'].values ==
time_i]['projection_x_coordinate'].values[0]
y = track_i[track_i['time'].values ==
time_i]['projection_y_coordinate'].values[0]
n_add_width = 2
box_slice = [[
x - (width + n_add_width) * dx, x + (width + n_add_width) * dx
], [y - (width + n_add_width) * dx, y + (width + n_add_width) * dx]]
x_min = np.nanmin([box_mask[0][0], box_slice[0][0]])
x_max = np.nanmax([box_mask[0][1], box_slice[0][1]])
y_min = np.nanmin([box_mask[1][0], box_slice[1][0]])
y_max = np.nanmax([box_mask[1][1], box_slice[1][1]])
constraint_x = Constraint(projection_x_coordinate=lambda cell: int(
x_min) < cell < int(x_max))
constraint_y = Constraint(projection_y_coordinate=lambda cell: int(
y_min) < cell < int(y_max))
constraint = constraint_time & constraint_x & constraint_y
mask_cell_i = mask_cell_i.extract(constraint_x & constraint_y)
mask_cell_surface_i = mask_cell_surface_i.extract(constraint_x
& constraint_y)
cubelist_i = cubelist_in.extract(constraint)
cubelist_cell_sum.extend(
sum_profile_mask(cubelist_i, height_levels, mask_cell_i))
cubelist_cell_sum_out = cubelist_cell_sum.merge()
for cube in cubelist_cell_sum_out:
cell_time_coord = AuxCoord(
track_i['time_cell'].dt.total_seconds().values,
units='s',
long_name='time_cell')
cube.add_aux_coord(cell_time_coord, cube.coord_dims('time')[0])
for cube in cubelist_cell_sum_out:
cubelist_cell_integrated_out.append(
cube.collapsed(('geopotential_height'), SUM))
track_cell_integrated = deepcopy(track_i)
#
for cube in cubelist_cell_integrated_out:
track_cell_integrated[cube.name()] = cube.core_data()
return cubelist_cell_sum_out, cubelist_cell_integrated_out, track_cell_integrated
