def setUp(self):
self.filename = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'test_file.nc')
aux1 = cf.AuxiliaryCoordinate()
aux1.standard_name = 'latitude'
a = numpy.array(
[-30, -23.5, -17.8123, -11.3345, -0.7, -0.2, 0, 0.2, 0.7,
11.30003, 17.8678678, 23.5, 30]
)
aux1.set_data(cf.Data(a, 'degrees_north'))
bounds = cf.Bounds()
b = numpy.empty(a.shape + (2,))
b[:, 0] = a - 0.1
b[:, 1] = a + 0.1
bounds.set_data(cf.Data(b))
aux1.set_bounds(bounds)
self.aux1 = aux1
def test_AuxiliaryCoordinate_transpose(self):
x = self.f.auxiliary_coordinate("longitude").copy()
bounds = cf.Bounds(
data=cf.Data(numpy.arange(9 * 10 * 4).reshape(9, 10, 4)))
x.set_bounds(bounds)
self.assertEqual(x.shape, (9, 10))
self.assertEqual(x.bounds.shape, (9, 10, 4))
y = x.transpose()
self.assertEqual(y.shape, (10, 9))
self.assertEqual(y.bounds.shape, (10, 9, 4), y.bounds.shape)
x.transpose([1, 0], inplace=True)
self.assertEqual(x.shape, (10, 9))
self.assertEqual(x.bounds.shape, (10, 9, 4), x.bounds.shape)
def test_AuxiliaryCoordinate_transpose(self):
f = cf.read(self.filename)[0]
x = f.auxiliary_coordinates('longitude').value()
bounds = cf.Bounds(
data=cf.Data(numpy.arange(9 * 10 * 4).reshape(9, 10, 4)))
x.set_bounds(bounds)
self.assertEqual(x.shape, (9, 10))
self.assertEqual(x.bounds.shape, (9, 10, 4))
y = x.transpose()
self.assertEqual(y.shape, (10, 9))
self.assertEqual(y.bounds.shape, (10, 9, 4), y.bounds.shape)
x.transpose([1, 0], inplace=True)
self.assertEqual(x.shape, (10, 9))
self.assertEqual(x.bounds.shape, (10, 9, 4), x.bounds.shape)
def test_AuxiliaryCoordinate_squeeze(self):
x = self.f.auxiliary_coordinate("longitude").copy()
bounds = cf.Bounds(
data=cf.Data(numpy.arange(9 * 10 * 4).reshape(9, 10, 4)))
x.set_bounds(bounds)
x.insert_dimension(1, inplace=True)
x.insert_dimension(0, inplace=True)
self.assertEqual(x.shape, (1, 9, 1, 10))
self.assertEqual(x.bounds.shape, (1, 9, 1, 10, 4))
y = x.squeeze()
self.assertEqual(y.shape, (9, 10))
self.assertEqual(y.bounds.shape, (9, 10, 4), y.bounds.shape)
x.squeeze(2, inplace=True)
self.assertEqual(x.shape, (1, 9, 10))
self.assertEqual(x.bounds.shape, (1, 9, 10, 4), x.bounds.shape)
def test_AuxiliaryCoordinate_squeeze(self):
f = cf.read(self.filename)[0]
x = f.auxiliary_coordinates('longitude').value()
bounds = cf.Bounds(
data=cf.Data(numpy.arange(9 * 10 * 4).reshape(9, 10, 4)))
x.set_bounds(bounds)
x.insert_dimension(1, inplace=True)
x.insert_dimension(0, inplace=True)
self.assertEqual(x.shape, (1, 9, 1, 10))
self.assertEqual(x.bounds.shape, (1, 9, 1, 10, 4))
y = x.squeeze()
self.assertEqual(y.shape, (9, 10))
self.assertEqual(y.bounds.shape, (9, 10, 4), y.bounds.shape)
x.squeeze(2, inplace=True)
self.assertEqual(x.shape, (1, 9, 10))
self.assertEqual(x.bounds.shape, (1, 9, 10, 4), x.bounds.shape)
cell_method2.set_axes(axisT)
cell_method2.set_method('maximum')
# Insert the cell method constructs into the field in the same
# order that their methods were applied to the data
Q.set_construct(cell_method1)
Q.set_construct(cell_method2)
# Create a "time" dimension coordinate construct, with coordinate
# bounds
dimT = cf.DimensionCoordinate(properties={
'standard_name': 'time',
'units': 'days since 2018-12-01'
},
data=cf.Data([15.5]),
bounds=cf.Bounds(data=cf.Data([[0, 31.]])))
# Create a "longitude" dimension coordinate construct, without
# coordinate bounds
dimX = cf.DimensionCoordinate(data=cf.Data(numpy.arange(8.)))
dimX.set_properties({'standard_name': 'longitude', 'units': 'degrees_east'})
# Create a "longitude" dimension coordinate construct
dimY = cf.DimensionCoordinate(properties={
'standard_name': 'latitude',
'units': 'degrees_north'
})
array = numpy.arange(5.)
dimY.set_data(cf.Data(array))
# Create and insert the latitude coordinate bounds
def _formula_terms(standard_name):
"""Return a field construct with a vertical CRS, its computed non-
parametric coordinates, and the computed standard name."""
# field: air_temperature
field = cf.Field()
field.set_properties({"standard_name": "air_temperature", "units": "K"})
data = cf.Data([0, 1, 2], units="K", dtype="f8")
# domain_axis: Z
c = cf.DomainAxis()
c.set_size(3)
c.nc_set_dimension("z")
axisZ = field.set_construct(c, key="domainaxis1", copy=False)
field.set_data(data)
# coordinate_reference:
coordref = cf.CoordinateReference()
coordref.coordinate_conversion.set_parameter(
"standard_name", standard_name
)
aux = cf.AuxiliaryCoordinate()
aux.long_name = "Computed from parametric {} vertical coordinates".format(
standard_name
)
if standard_name == "atmosphere_ln_pressure_coordinate":
computed_standard_name = "air_pressure"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data([700, 500, 300], "hPa", dtype="f8")
aux.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[800, 600], [600, 400], [400, 200]], "hPa", dtype="f8")
bounds.set_data(data)
aux.set_bounds(bounds)
# domain_ancillary: p0
p0 = cf.DomainAncillary()
p0.standard_name = (
"reference_air_pressure_for_atmosphere_vertical_coordinate"
)
data = cf.Data(1000.0, units="hPa", dtype="f8")
p0.set_data(data)
p0_key = field.set_construct(p0, axes=(), copy=False)
# domain_ancillary: Z
lev = cf.DomainAncillary()
lev.standard_name = standard_name
data = -(aux.data / p0.data).log()
lev.set_data(data)
bounds = cf.Bounds()
data = -(aux.bounds.data / p0.data).log()
bounds.set_data(data)
lev.set_bounds(bounds)
lev_key = field.set_construct(lev, axes=axisZ, copy=False)
# dimension_coordinate: Z
levc = cf.DimensionCoordinate(source=lev)
levc_key = field.set_construct(levc, axes=axisZ, copy=False)
# coordinate_reference:
coordref.set_coordinates({levc_key})
coordref.coordinate_conversion.set_domain_ancillaries(
{"p0": p0_key, "lev": lev_key}
)
field.set_construct(coordref)
elif standard_name == "atmosphere_sigma_coordinate":
computed_standard_name = "air_pressure"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data([700, 500, 300], "hPa", dtype="f8")
aux.set_data(data)
b = cf.Bounds()
data = cf.Data([[800, 600], [600, 400], [400, 200]], "hPa", dtype="f8")
b.set_data(data)
aux.set_bounds(b)
# domain_ancillary: ps
ps = cf.DomainAncillary()
ps.standard_name = "surface_air_pressure"
data = cf.Data(1000, units="hPa", dtype="f8")
ps.set_data(data)
ps_key = field.set_construct(ps, axes=(), copy=False)
# domain_ancillary: ptop
ptop = cf.DomainAncillary()
ptop.standard_name = "air_pressure_at_top_of_atmosphere_model"
data = cf.Data(10, units="hPa", dtype="f8")
ptop.set_data(data)
ptop_key = field.set_construct(ptop, axes=(), copy=False)
# domain_ancillary: sigma
sigma = cf.DomainAncillary()
sigma.standard_name = standard_name
data = cf.Data([0.6969697, 0.49494949, 0.29292929])
sigma.set_data(data)
b = cf.Bounds()
data = cf.Data(
[
[0.7979798, 0.5959596],
[0.5959596, 0.39393939],
[0.39393939, 0.19191919],
]
)
b.set_data(data)
sigma.set_bounds(b)
sigma_key = field.set_construct(sigma, axes=axisZ, copy=False)
# dimension_coordinate: sigma
sigmac = cf.DimensionCoordinate(source=sigma)
sigmac_key = field.set_construct(sigmac, axes=axisZ, copy=False)
# coordinate_reference:
coordref.set_coordinates({sigmac_key})
coordref.coordinate_conversion.set_domain_ancillaries(
{"ptop": ptop_key, "ps": ps_key, "sigma": sigma_key}
)
field.set_construct(coordref)
elif standard_name == "atmosphere_hybrid_sigma_pressure_coordinate":
computed_standard_name = "air_pressure"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data([700, 500, 300], "hPa", dtype="f8")
aux.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[800, 600], [600, 400], [400, 200]], "hPa", dtype="f8")
bounds.set_data(data)
aux.set_bounds(bounds)
# domain_ancillary: ps
ps = cf.DomainAncillary()
ps.standard_name = "surface_air_pressure"
data = cf.Data(1000, units="hPa", dtype="f8")
ps.set_data(data)
ps_key = field.set_construct(ps, axes=(), copy=False)
# domain_ancillary: p0
p0 = cf.DomainAncillary()
data = cf.Data(1000, units="hPa", dtype="f8")
p0.set_data(data)
p0_key = field.set_construct(p0, axes=(), copy=False)
# domain_ancillary: a
a = cf.DomainAncillary()
data = cf.Data([0.6, 0.3, 0], dtype="f8")
a.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[0.75, 0.45], [0.45, 0.15], [0.15, 0]])
bounds.set_data(data)
a.set_bounds(bounds)
a_key = field.set_construct(a, axes=axisZ, copy=False)
# domain_ancillary: b
b = cf.DomainAncillary()
data = cf.Data([0.1, 0.2, 0.3], dtype="f8")
b.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[0.05, 0.15], [0.15, 0.25], [0.25, 0.2]])
bounds.set_data(data)
b.set_bounds(bounds)
b_key = field.set_construct(b, axes=axisZ, copy=False)
# dimension_coordinate: sigma
sigma = cf.DimensionCoordinate()
sigma.standard_name = standard_name
data = cf.Data([0.6969697, 0.49494949, 0.29292929])
sigma.set_data(data)
bounds = cf.Bounds()
data = cf.Data(
[
[0.7979798, 0.5959596],
[0.5959596, 0.39393939],
[0.39393939, 0.19191919],
]
)
bounds.set_data(data)
sigma.set_bounds(bounds)
sigma_key = field.set_construct(sigma, axes=axisZ, copy=False)
# coordinate_reference:
coordref.set_coordinates({sigma_key})
coordref.coordinate_conversion.set_domain_ancillaries(
{"p0": p0_key, "a": a_key, "b": b_key, "ps": ps_key}
)
field.set_construct(coordref)
elif standard_name == "atmosphere_sleve_coordinate":
computed_standard_name = "altitude"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data([100, 200, 300], "m", dtype="f8")
aux.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[50, 150], [150, 250], [250, 350]], "m", dtype="f8")
bounds.set_data(data)
aux.set_bounds(bounds)
# domain_ancillary: ztop
ztop = cf.DomainAncillary()
ztop.standard_name = "altitude_at_top_of_atmosphere_model"
data = cf.Data(1000, units="m", dtype="f8")
ztop.set_data(data)
ztop_key = field.set_construct(ztop, axes=(), copy=False)
# domain_ancillary: zsurf1
zsurf1 = cf.DomainAncillary()
data = cf.Data(90, units="m", dtype="f8")
zsurf1.set_data(data)
zsurf1_key = field.set_construct(zsurf1, axes=(), copy=False)
# domain_ancillary: zsurf2
zsurf2 = cf.DomainAncillary()
data = cf.Data(0.1, units="m", dtype="f8")
zsurf2.set_data(data)
zsurf2_key = field.set_construct(zsurf2, axes=(), copy=False)
# domain_ancillary: b1
b1 = cf.DomainAncillary()
data = cf.Data([0.05, 0.04, 0.03], dtype="f8")
b1.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[0.055, 0.045], [0.045, 0.035], [0.035, 0.025]])
bounds.set_data(data)
b1.set_bounds(bounds)
b1_key = field.set_construct(b1, axes=axisZ, copy=False)
# domain_ancillary: b2
b2 = cf.DomainAncillary()
data = cf.Data([0.5, 0.4, 0.3])
b2.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[0.55, 0.45], [0.45, 0.35], [0.35, 0.25]])
bounds.set_data(data)
b2.set_bounds(bounds)
b2_key = field.set_construct(b2, axes=axisZ, copy=False)
# domain_ancillary: a
a = cf.DomainAncillary()
data = cf.Data([0.09545, 0.19636, 0.29727])
a.set_data(data)
bounds = cf.Bounds()
data = cf.Data(
[[0.044995, 0.145905], [0.145905, 0.246815], [0.246815, 0.347725]]
)
bounds.set_data(data)
a.set_bounds(bounds)
a_key = field.set_construct(a, axes=axisZ, copy=False)
# coordinate_reference:
coordref.coordinate_conversion.set_domain_ancillaries(
{
"zsurf1": zsurf1_key,
"a": a_key,
"b1": b1_key,
"b2": b2_key,
"zsurf2": zsurf2_key,
"ztop": ztop_key,
}
)
field.set_construct(coordref)
elif standard_name == "ocean_sigma_coordinate":
computed_standard_name = "altitude"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data([10, 20, 30], "m", dtype="f8")
aux.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[5, 15], [15, 25], [25, 35]], "m", dtype="f8")
bounds.set_data(data)
aux.set_bounds(bounds)
# domain_ancillary: depth
depth = cf.DomainAncillary()
depth.standard_name = "sea_floor_depth_below_geoid"
data = cf.Data(-1000.0, units="m")
depth.set_data(data)
depth_key = field.set_construct(depth, axes=(), copy=False)
# domain_ancillary: eta
eta = cf.DomainAncillary()
eta.standard_name = "sea_surface_height_above_geoid"
data = cf.Data(100.0, units="m")
eta.set_data(data)
eta_key = field.set_construct(eta, axes=(), copy=False)
# domain_ancillary: sigma
sigma = cf.DomainAncillary()
sigma.standard_name = standard_name
data = cf.Data([0.1, 0.08888888888888889, 0.07777777777777778])
sigma.set_data(data)
bounds = cf.Bounds()
data = cf.Data(
[
[0.10555556, 0.09444444],
[0.09444444, 0.08333333],
[0.08333333, 0.07222222],
]
)
bounds.set_data(data)
sigma.set_bounds(bounds)
sigma_key = field.set_construct(sigma, axes=axisZ, copy=False)
# dimension_coordinate: sigma
sigmac = cf.DimensionCoordinate(source=sigma)
sigmac_key = field.set_construct(sigmac, axes=axisZ, copy=False)
# coordinate_reference:
coordref.set_coordinates({sigmac_key})
coordref.coordinate_conversion.set_domain_ancillaries(
{"depth": depth_key, "eta": eta_key, "sigma": sigma_key}
)
field.set_construct(coordref)
elif standard_name == "ocean_s_coordinate":
computed_standard_name = "altitude"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data([15.01701191, 31.86034296, 40.31150319], units="m")
aux.set_data(data)
bounds = cf.Bounds()
data = cf.Data(
[
[15.01701191, 23.42877638],
[23.42877638, 31.86034296],
[31.86034296, 40.31150319],
],
units="m",
)
bounds.set_data(data)
aux.set_bounds(bounds)
# domain_ancillary: depth
depth = cf.DomainAncillary()
depth.standard_name = "sea_floor_depth_below_geoid"
data = cf.Data(-1000.0, units="m")
depth.set_data(data)
depth_key = field.set_construct(depth, axes=(), copy=False)
# domain_ancillary: eta
eta = cf.DomainAncillary()
eta.standard_name = "sea_surface_height_above_geoid"
data = cf.Data(100.0, units="m")
eta.set_data(data)
eta_key = field.set_construct(eta, axes=(), copy=False)
# domain_ancillary: depth_c
depth_c = cf.DomainAncillary()
data = cf.Data(10.0, units="m")
depth_c.set_data(data)
depth_c_key = field.set_construct(depth_c, axes=(), copy=False)
# domain_ancillary: a
a = cf.DomainAncillary()
data = cf.Data(0.5)
a.set_data(data)
a_key = field.set_construct(a, axes=(), copy=False)
# domain_ancillary: b
b = cf.DomainAncillary()
data = cf.Data(0.75)
b.set_data(data)
b_key = field.set_construct(b, axes=(), copy=False)
# domain_ancillary: s
s = cf.DomainAncillary()
s.standard_name = standard_name
data = cf.Data([0.1, 0.08, 0.07])
s.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[0.10, 0.09], [0.09, 0.08], [0.08, 0.07]])
bounds.set_data(data)
s.set_bounds(bounds)
s_key = field.set_construct(s, axes=axisZ, copy=False)
# dimension_coordinate: s
sc = cf.DimensionCoordinate(source=s)
sc_key = field.set_construct(sc, axes=axisZ, copy=False)
# coordinate_reference:
coordref.set_coordinates({sc_key})
coordref.coordinate_conversion.set_domain_ancillaries(
{
"depth": depth_key,
"eta": eta_key,
"depth_c": depth_c_key,
"a": a_key,
"b": b_key,
"s": s_key,
}
)
field.set_construct(coordref)
elif standard_name == "ocean_s_coordinate_g1":
computed_standard_name = "altitude"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data([555.4, 464.32, 373.33], units="m")
aux.set_data(data)
bounds = cf.Bounds()
data = cf.Data(
[[600.85, 509.86], [509.86, 418.87], [418.87, 327.88]], units="m"
)
bounds.set_data(data)
aux.set_bounds(bounds)
# domain_ancillary: depth
depth = cf.DomainAncillary()
depth.standard_name = "sea_floor_depth_below_geoid"
data = cf.Data(-1000.0, units="m")
depth.set_data(data)
depth_key = field.set_construct(depth, axes=(), copy=False)
# domain_ancillary: eta
eta = cf.DomainAncillary()
eta.standard_name = "sea_surface_height_above_geoid"
data = cf.Data(100.0, units="m")
eta.set_data(data)
eta_key = field.set_construct(eta, axes=(), copy=False)
# domain_ancillary: depth_c
depth_c = cf.DomainAncillary()
data = cf.Data(10.0, units="m")
depth_c.set_data(data)
depth_c_key = field.set_construct(depth_c, axes=(), copy=False)
# domain_ancillary: C
C = cf.DomainAncillary()
data = cf.Data([-0.5, -0.4, -0.3])
C.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[-0.55, -0.45], [-0.45, -0.35], [-0.35, -0.25]])
bounds.set_data(data)
C.set_bounds(bounds)
C_key = field.set_construct(C, axes=axisZ, copy=False)
# domain_ancillary: s
s = cf.DomainAncillary()
s.standard_name = standard_name
data = cf.Data([0.1, 0.08, 0.07])
s.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[0.10, 0.09], [0.09, 0.08], [0.08, 0.07]])
bounds.set_data(data)
s.set_bounds(bounds)
s_key = field.set_construct(s, axes=axisZ, copy=False)
# dimension_coordinate: s
sc = cf.DimensionCoordinate(source=s)
sc_key = field.set_construct(sc, axes=axisZ, copy=False)
# coordinate_reference:
coordref.set_coordinates({sc_key})
coordref.coordinate_conversion.set_domain_ancillaries(
{
"depth": depth_key,
"eta": eta_key,
"depth_c": depth_c_key,
"C": C_key,
"s": s_key,
}
)
field.set_construct(coordref)
elif standard_name == "ocean_s_coordinate_g2":
computed_standard_name = "altitude"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data([555.45454545, 464.36363636, 373.36363636], units="m")
aux.set_data(data)
bounds = cf.Bounds()
data = cf.Data(
[
[600.90909091, 509.90909091],
[509.90909091, 418.90909091],
[418.90909091, 327.90909091],
],
units="m",
)
bounds.set_data(data)
aux.set_bounds(bounds)
# domain_ancillary: depth
depth = cf.DomainAncillary()
depth.standard_name = "sea_floor_depth_below_geoid"
data = cf.Data(-1000.0, units="m")
depth.set_data(data)
depth_key = field.set_construct(depth, axes=(), copy=False)
# domain_ancillary: eta
eta = cf.DomainAncillary()
eta.standard_name = "sea_surface_height_above_geoid"
data = cf.Data(100.0, units="m")
eta.set_data(data)
eta_key = field.set_construct(eta, axes=(), copy=False)
# domain_ancillary: depth_c
depth_c = cf.DomainAncillary()
data = cf.Data(10.0, units="m")
depth_c.set_data(data)
depth_c_key = field.set_construct(depth_c, axes=(), copy=False)
# domain_ancillary: C
C = cf.DomainAncillary()
data = cf.Data([-0.5, -0.4, -0.3])
C.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[-0.55, -0.45], [-0.45, -0.35], [-0.35, -0.25]])
bounds.set_data(data)
C.set_bounds(bounds)
C_key = field.set_construct(C, axes=axisZ, copy=False)
# domain_ancillary: s
s = cf.DomainAncillary()
s.standard_name = standard_name
data = cf.Data([0.1, 0.08, 0.07])
s.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[0.10, 0.09], [0.09, 0.08], [0.08, 0.07]])
bounds.set_data(data)
s.set_bounds(bounds)
s_key = field.set_construct(s, axes=axisZ, copy=False)
# dimension_coordinate: s
sc = cf.DimensionCoordinate(source=s)
sc_key = field.set_construct(sc, axes=axisZ, copy=False)
# coordinat
# coordinate_reference:
coordref.set_coordinates({sc_key})
coordref.coordinate_conversion.set_domain_ancillaries(
{
"depth": depth_key,
"eta": eta_key,
"depth_c": depth_c_key,
"C": C_key,
"s": s_key,
}
)
field.set_construct(coordref)
elif standard_name == "ocean_sigma_z_coordinate":
computed_standard_name = "altitude"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data([10.0, 30.0, 40.0], "m", dtype="f8")
aux.set_data(data)
bounds = cf.Bounds()
data = cf.Data(
[[10.0, 19.0], [25.0, 35.0], [35.0, 45.0]], "m", dtype="f8"
)
bounds.set_data(data)
aux.set_bounds(bounds)
# domain_ancillary: depth
depth = cf.DomainAncillary()
depth.standard_name = "sea_floor_depth_below_geoid"
data = cf.Data(-1000.0, units="m")
depth.set_data(data)
depth_key = field.set_construct(depth, axes=(), copy=False)
# domain_ancillary: eta
eta = cf.DomainAncillary()
eta.standard_name = "sea_surface_height_above_geoid"
data = cf.Data(100.0, units="m")
eta.set_data(data)
eta_key = field.set_construct(eta, axes=(), copy=False)
# domain_ancillary: depth_c
depth_c = cf.DomainAncillary()
data = cf.Data(10.0, units="m")
depth_c.set_data(data)
depth_c_key = field.set_construct(depth_c, axes=(), copy=False)
# domain_ancillary: nsigma
nsigma = cf.DomainAncillary()
data = cf.Data(1)
nsigma.set_data(data)
nsigma_key = field.set_construct(nsigma, axes=(), copy=False)
# domain_ancillary: zlev
zlev = cf.DomainAncillary()
zlev.standard_name = "altitude"
data = cf.Data([20, 30, 40], units="m", dtype="f8")
zlev.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[15, 25], [25, 35], [35, 45]], units="m", dtype="f8")
bounds.set_data(data)
zlev.set_bounds(bounds)
zlev_key = field.set_construct(zlev, axes=axisZ, copy=False)
# domain_ancillary: sigma
sigma = cf.DomainAncillary()
sigma.standard_name = standard_name
data = cf.Data([0.1, 0.08, 0.07])
sigma.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[0.10, 0.09], [0.09, 0.08], [0.08, 0.07]])
bounds.set_data(data)
sigma.set_bounds(bounds)
sigma_key = field.set_construct(sigma, axes=axisZ, copy=False)
# dimension_coordinate: sigma
sigmac = cf.DimensionCoordinate(source=sigma)
sigmac_key = field.set_construct(sigmac, axes=axisZ, copy=False)
# coordinate_reference:
coordref.set_coordinates({sigmac_key})
coordref.coordinate_conversion.set_domain_ancillaries(
{
"depth": depth_key,
"eta": eta_key,
"depth_c": depth_c_key,
"nsigma": nsigma_key,
"zlev": zlev_key,
"sigma": sigma_key,
}
)
field.set_construct(coordref)
elif standard_name == "ocean_double_sigma_coordinate":
computed_standard_name = "altitude"
# Computed vertical corodinates
aux.standard_name = computed_standard_name
data = cf.Data(
[0.15000000000000002, 0.12, 932.895], units="m", dtype="f8"
)
aux.set_data(data)
bounds = cf.Bounds()
data = cf.Data(
[
[1.50000e-01, 1.35000e-01],
[1.35000e-01, 1.20000e-01],
[9.22880e02, 9.32895e02],
],
units="m",
dtype="f8",
)
bounds.set_data(data)
aux.set_bounds(bounds)
# domain_ancillary: depth
depth = cf.DomainAncillary()
depth.standard_name = "sea_floor_depth_below_geoid"
data = cf.Data(-1000.0, units="m")
depth.set_data(data)
depth_key = field.set_construct(depth, axes=(), copy=False)
# domain_ancillary: z1
z1 = cf.DomainAncillary()
data = cf.Data(2, units="m")
z1.set_data(data)
z1_key = field.set_construct(z1, axes=(), copy=False)
# domain_ancillary: z2
z2 = cf.DomainAncillary()
data = cf.Data(1.5, units="m")
z2.set_data(data)
z2_key = field.set_construct(z2, axes=(), copy=False)
# domain_ancillary: a
a = cf.DomainAncillary()
data = cf.Data(2.5, units="m")
a.set_data(data)
a_key = field.set_construct(a, axes=(), copy=False)
# domain_ancillary: href
href = cf.DomainAncillary()
data = cf.Data(10.5, units="m")
href.set_data(data)
href_key = field.set_construct(href, axes=(), copy=False)
# domain_ancillary: k_c
k_c = cf.DomainAncillary()
data = cf.Data(1)
k_c.set_data(data)
k_c_key = field.set_construct(k_c, axes=(), copy=False)
# dimension_coordinate: sigma
sigma = cf.DomainAncillary()
sigma.standard_name = standard_name
data = cf.Data([0.1, 0.08, 0.07])
sigma.set_data(data)
bounds = cf.Bounds()
data = cf.Data([[0.10, 0.09], [0.09, 0.08], [0.08, 0.07]])
bounds.set_data(data)
sigma.set_bounds(bounds)
sigma_key = field.set_construct(sigma, axes=axisZ, copy=False)
# dimension_coordinate: sigma
sigmac = cf.DimensionCoordinate(source=sigma)
sigmac_key = field.set_construct(sigmac, axes=axisZ, copy=False)
# coordinate_reference:
coordref.set_coordinates({sigmac_key})
coordref.coordinate_conversion.set_domain_ancillaries(
{
"depth": depth_key,
"a": a_key,
"k_c": k_c_key,
"z1": z1_key,
"z2": z2_key,
"href": href_key,
"sigma": sigma_key,
}
)
field.set_construct(coordref)
else:
raise ValueError(
"Bad standard name: {}, "
"not an element of FormulaTerms.standard_names".format(
standard_name
)
)
return (field, aux, computed_standard_name)
class AuxiliaryCoordinateTest(unittest.TestCase):
f = cf.example_field(1)
aux1 = cf.AuxiliaryCoordinate()
aux1.standard_name = "latitude"
a = numpy.array([
-30,
-23.5,
-17.8123,
-11.3345,
-0.7,
-0.2,
0,
0.2,
0.7,
11.30003,
17.8678678,
23.5,
30,
])
aux1.set_data(cf.Data(a, "degrees_north"))
bounds = cf.Bounds()
b = numpy.empty(a.shape + (2, ))
b[:, 0] = a - 0.1
b[:, 1] = a + 0.1
bounds.set_data(cf.Data(b))
aux1.set_bounds(bounds)
def test_AuxiliaryCoordinate_mask_invalid(self):
a = self.aux1.copy()
a.mask_invalid()
self.assertIsNone(a.mask_invalid(inplace=True))
a.del_bounds()
a.mask_invalid()
self.assertIsNone(a.mask_invalid(inplace=True))
def test_AuxiliaryCoordinate_chunk(self):
a = self.aux1.copy()
a.chunk()
def test_AuxiliaryCoordinate__repr__str__dump(self):
x = self.f.auxiliary_coordinate("latitude")
repr(x)
str(x)
x.dump(display=False)
def test_AuxiliaryCoordinate_bounds(self):
d = self.f.dimension_coordinate("X")
x = cf.AuxiliaryCoordinate(source=d)
x.upper_bounds
x.lower_bounds
def test_AuxiliaryCoordinate_properties(self):
x = self.f.auxiliary_coordinate("latitude")
x.positive = "up"
self.assertEqual(x.positive, "up")
del x.positive
self.assertIsNone(getattr(x, "positive", None))
x.axis = "Z"
self.assertEqual(x.axis, "Z")
del x.axis
self.assertIsNone(getattr(x, "axis", None))
d = self.f.dimension_coordinate("X")
x = cf.AuxiliaryCoordinate(source=d)
def test_AuxiliaryCoordinate_insert_dimension(self):
d = self.f.dimension_coordinate("X")
x = cf.AuxiliaryCoordinate(source=d)
self.assertEqual(x.shape, (9, ))
self.assertEqual(x.bounds.shape, (9, 2))
y = x.insert_dimension(0)
self.assertEqual(y.shape, (1, 9))
self.assertEqual(y.bounds.shape, (1, 9, 2), y.bounds.shape)
x.insert_dimension(-1, inplace=True)
self.assertEqual(x.shape, (9, 1))
self.assertEqual(x.bounds.shape, (9, 1, 2), x.bounds.shape)
def test_AuxiliaryCoordinate_transpose(self):
x = self.f.auxiliary_coordinate("longitude").copy()
bounds = cf.Bounds(
data=cf.Data(numpy.arange(9 * 10 * 4).reshape(9, 10, 4)))
x.set_bounds(bounds)
self.assertEqual(x.shape, (9, 10))
self.assertEqual(x.bounds.shape, (9, 10, 4))
y = x.transpose()
self.assertEqual(y.shape, (10, 9))
self.assertEqual(y.bounds.shape, (10, 9, 4), y.bounds.shape)
x.transpose([1, 0], inplace=True)
self.assertEqual(x.shape, (10, 9))
self.assertEqual(x.bounds.shape, (10, 9, 4), x.bounds.shape)
def test_AuxiliaryCoordinate_squeeze(self):
x = self.f.auxiliary_coordinate("longitude").copy()
bounds = cf.Bounds(
data=cf.Data(numpy.arange(9 * 10 * 4).reshape(9, 10, 4)))
x.set_bounds(bounds)
x.insert_dimension(1, inplace=True)
x.insert_dimension(0, inplace=True)
self.assertEqual(x.shape, (1, 9, 1, 10))
self.assertEqual(x.bounds.shape, (1, 9, 1, 10, 4))
y = x.squeeze()
self.assertEqual(y.shape, (9, 10))
self.assertEqual(y.bounds.shape, (9, 10, 4), y.bounds.shape)
x.squeeze(2, inplace=True)
self.assertEqual(x.shape, (1, 9, 10))
self.assertEqual(x.bounds.shape, (1, 9, 10, 4), x.bounds.shape)
def test_AuxiliaryCoordinate_floor(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
self.assertTrue((aux.floor().array == numpy.floor(a)).all())
self.assertTrue((aux.floor().bounds.array == numpy.floor(b)).all())
self.assertTrue(
(aux.floor(bounds=False).array == numpy.floor(a)).all())
self.assertTrue((aux.floor(bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.floor().array == numpy.floor(a)).all())
self.assertTrue(
(aux.floor(bounds=False).array == numpy.floor(a)).all())
self.assertIsNone(aux.floor(inplace=True))
self.assertTrue((aux.array == numpy.floor(a)).all())
def test_AuxiliaryCoordinate_ceil(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
self.assertTrue((aux.ceil().array == numpy.ceil(a)).all())
self.assertTrue((aux.ceil().bounds.array == numpy.ceil(b)).all())
self.assertTrue((aux.ceil(bounds=False).array == numpy.ceil(a)).all())
self.assertTrue((aux.ceil(bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.ceil().array == numpy.ceil(a)).all())
self.assertTrue((aux.ceil(bounds=False).array == numpy.ceil(a)).all())
self.assertIsNone(aux.ceil(inplace=True))
self.assertTrue((aux.array == numpy.ceil(a)).all())
def test_AuxiliaryCoordinate_trunc(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
self.assertTrue((aux.trunc().array == numpy.trunc(a)).all())
self.assertTrue((aux.trunc().bounds.array == numpy.trunc(b)).all())
self.assertTrue(
(aux.trunc(bounds=False).array == numpy.trunc(a)).all())
self.assertTrue((aux.trunc(bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.trunc().array == numpy.trunc(a)).all())
self.assertTrue(
(aux.trunc(bounds=False).array == numpy.trunc(a)).all())
self.assertIsNone(aux.trunc(inplace=True))
self.assertTrue((aux.array == numpy.trunc(a)).all())
def test_AuxiliaryCoordinate_rint(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
x0 = aux.rint()
x = x0.array
self.assertTrue((x == numpy.rint(a)).all(), x)
self.assertTrue((aux.rint().bounds.array == numpy.rint(b)).all())
self.assertTrue((aux.rint(bounds=False).array == numpy.rint(a)).all())
self.assertTrue((aux.rint(bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.rint().array == numpy.rint(a)).all())
self.assertTrue((aux.rint(bounds=False).array == numpy.rint(a)).all())
self.assertIsNone(aux.rint(inplace=True))
self.assertTrue((aux.array == numpy.rint(a)).all())
def test_AuxiliaryCoordinate_close(self):
aux = self.aux1.copy()
aux.close()
def test_AuxiliaryCoordinate_sin_cos_tan(self):
aux = self.aux1.copy()
aux.cos()
self.assertIsNone(aux.cos(inplace=True))
aux.sin()
self.assertIsNone(aux.sin(inplace=True))
aux.tan()
self.assertIsNone(aux.tan(inplace=True))
def test_AuxiliaryCoordinate_log_exp(self):
aux = self.aux1.copy()
aux.exp()
self.assertIsNone(aux.exp(inplace=True))
aux.log()
self.assertIsNone(aux.log(inplace=True))
def test_AuxiliaryCoordinate_count(self):
aux = self.aux1.copy()
aux.count()
aux.del_data()
with self.assertRaises(Exception):
aux.count()
def test_AuxiliaryCoordinate_cyclic(self):
aux = self.aux1.copy()
self.assertEqual(aux.cyclic(), set())
self.assertEqual(aux.cyclic(0), set())
self.assertEqual(aux.cyclic(), set([0]))
def test_AuxiliaryCoordinate_roll(self):
aux = self.aux1.copy()
aux.roll(0, 3)
self.assertIsNone(aux.roll(-1, 4, inplace=True))
def test_AuxiliaryCoordinate_round(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
for decimals in (0, 1, 2, 3, 4, 5):
aux = self.aux1.copy()
self.assertTrue(
(aux.round(decimals).array == numpy.round(a, decimals)).all())
self.assertTrue((aux.round(decimals).bounds.array == numpy.round(
b, decimals)).all())
self.assertTrue(
(aux.round(decimals,
bounds=False).array == numpy.round(a,
decimals)).all())
self.assertTrue((aux.round(decimals,
bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue(
(aux.round(decimals).array == numpy.round(a, decimals)).all())
self.assertTrue(
(aux.round(decimals,
bounds=False).array == numpy.round(a,
decimals)).all())
self.assertIsNone(aux.round(decimals, inplace=True))
self.assertTrue((aux.array == numpy.round(a, decimals)).all())
def test_AuxiliaryCoordinate_clip(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
self.assertTrue((aux.clip(-15, 25).array == numpy.clip(a, -15,
25)).all())
self.assertTrue(
(aux.clip(-15, 25).bounds.array == numpy.clip(b, -15, 25)).all())
self.assertTrue(
(aux.clip(-15, 25, bounds=False).array == numpy.clip(a, -15,
25)).all())
self.assertTrue((aux.clip(-15, 25,
bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.clip(-15, 25).array == numpy.clip(a, -15,
25)).all())
self.assertTrue(
(aux.clip(-15, 25, bounds=False).array == numpy.clip(a, -15,
25)).all())
self.assertIsNone(aux.clip(-15, 25, inplace=True))
def test_create_field(self):
# Dimension coordinates
dim1 = cf.DimensionCoordinate(
data=cf.Data(numpy.arange(10.0), "degrees"))
dim1.standard_name = "grid_latitude"
dim0 = cf.DimensionCoordinate(
data=cf.Data(numpy.arange(9.0) + 20, "degrees"))
dim0.standard_name = "grid_longitude"
dim0.data[-1] += 5
bounds = cf.Data(
numpy.array([dim0.data.array - 0.5,
dim0.data.array + 0.5]).transpose((1, 0)))
bounds[-2, 1] = 30
bounds[-1, :] = [30, 36]
dim0.set_bounds(cf.Bounds(data=bounds))
dim2 = cf.DimensionCoordinate(
data=cf.Data([1.5]), bounds=cf.Bounds(data=cf.Data([[1, 2.0]])))
dim2.standard_name = "atmosphere_hybrid_height_coordinate"
# Auxiliary coordinates
ak = cf.DomainAncillary(data=cf.Data([10.0], "m"))
ak.id = "atmosphere_hybrid_height_coordinate_ak"
bounds = cf.Bounds(data=cf.Data([[5, 15.0]], units=ak.Units))
ak.set_bounds(bounds)
bk = cf.DomainAncillary(data=cf.Data([20.0]))
bk.id = "atmosphere_hybrid_height_coordinate_bk"
bounds = cf.Bounds(data=cf.Data([[14, 26.0]]))
bk.set_bounds(bounds)
aux2 = cf.AuxiliaryCoordinate(data=cf.Data(
numpy.arange(-45, 45, dtype="int32").reshape(10, 9),
units="degree_N",
))
aux2.standard_name = "latitude"
aux3 = cf.AuxiliaryCoordinate(data=cf.Data(
numpy.arange(60, 150, dtype="int32").reshape(9, 10),
units="degreesE",
))
aux3.standard_name = "longitude"
aux4 = cf.AuxiliaryCoordinate(data=cf.Data(
numpy.array(
[
"alpha",
"beta",
"gamma",
"delta",
"epsilon",
"zeta",
"eta",
"theta",
"iota",
"kappa",
],
dtype="S",
)))
aux4.standard_name = "greek_letters"
aux4[0] = cf.masked
# Cell measures
msr0 = cf.CellMeasure(
data=cf.Data(1 + numpy.arange(90.0).reshape(9, 10) * 1234, "km 2"))
msr0.measure = "area"
# Data
data = cf.Data(numpy.arange(90.0).reshape(10, 9), "m s-1")
properties = {"standard_name": "eastward_wind"}
f = cf.Field(properties=properties)
axisX = f.set_construct(cf.DomainAxis(9))
axisY = f.set_construct(cf.DomainAxis(10))
axisZ = f.set_construct(cf.DomainAxis(1))
f.set_data(data)
x = f.set_construct(dim0)
y = f.set_construct(dim1, axes=[axisY])
z = f.set_construct(dim2, axes=[axisZ])
lat = f.set_construct(aux2)
lon = f.set_construct(aux3, axes=["X", axisY])
f.set_construct(aux4, axes=["Y"])
ak = f.set_construct(ak, axes=["Z"])
bk = f.set_construct(bk, axes=[axisZ])
# Coordinate references
coordinate_conversion = cf.CoordinateConversion(
parameters={
"grid_mapping_name": "rotated_latitude_longitude",
"grid_north_pole_latitude": 38.0,
"grid_north_pole_longitude": 190.0,
})
ref0 = cf.CoordinateReference(
coordinate_conversion=coordinate_conversion,
coordinates=[x, y, lat, lon],
)
f.set_construct(msr0, axes=[axisX, "Y"])
f.set_construct(ref0)
orog = cf.DomainAncillary()
orog.standard_name = "surface_altitude"
orog.set_data(cf.Data(f.array * 2, "m"))
orog.transpose([1, 0], inplace=True)
orog_key = f.set_construct(orog, axes=["X", axisY])
coordinate_conversion = cf.CoordinateConversion(
parameters={
"standard_name": "atmosphere_hybrid_height_coordinate"
},
domain_ancillaries={
"orog": orog_key,
"a": ak,
"b": bk
},
)
ref1 = cf.CoordinateReference(
coordinate_conversion=coordinate_conversion, coordinates=[z])
f.set_construct(ref1)
# Field ancillary variables
g = cf.FieldAncillary()
g.set_data(f.data)
g.transpose([1, 0], inplace=True)
g.standard_name = "ancillary0"
g *= 0.01
f.set_construct(g)
g = cf.FieldAncillary()
g.set_data(f.data)
g.standard_name = "ancillary1"
g *= 0.01
f.set_construct(g)
g = cf.FieldAncillary()
g.set_data(f[0, :].data)
g.squeeze(inplace=True)
g.standard_name = "ancillary2"
g *= 0.001
f.set_construct(g)
g = cf.FieldAncillary()
g.set_data(f[:, 0].data)
g.squeeze(inplace=True)
g.standard_name = "ancillary3"
g *= 0.001
f.set_construct(g)
f.flag_values = [1, 2, 4]
f.flag_meanings = ["a", "bb", "ccc"]
for cm in cf.CellMethod.create(
"grid_longitude: mean grid_latitude: max"):
f.set_construct(cm)
# Write the file, and read it in
cf.write(f, self.filename, verbose=0, string=True)
g = cf.read(self.filename, squeeze=True, verbose=0)[0]
self.assertTrue(g.equals(f, verbose=0),
"Field not equal to itself read back in")
x = g.dump(display=False)
x = f.dump(display=False)
class AuxiliaryCoordinateTest(unittest.TestCase):
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'test_file.nc')
# f = cf.read(filename)[0]
aux1 = cf.AuxiliaryCoordinate()
aux1.standard_name = 'latitude'
a = numpy.array([
-30, -23.5, -17.8123, -11.3345, -0.7, -0.2, 0, 0.2, 0.7, 11.30003,
17.8678678, 23.5, 30
])
aux1.set_data(cf.Data(a, 'degrees_north'))
bounds = cf.Bounds()
b = numpy.empty(a.shape + (2, ))
b[:, 0] = a - 0.1
b[:, 1] = a + 0.1
bounds.set_data(cf.Data(b))
aux1.set_bounds(bounds)
def test_AuxiliaryCoordinate_mask_invalid(self):
a = self.aux1.copy()
_ = a.mask_invalid()
self.assertIsNone(a.mask_invalid(inplace=True))
a.del_bounds()
_ = a.mask_invalid()
self.assertIsNone(a.mask_invalid(inplace=True))
def test_AuxiliaryCoordinate_chunk(self):
a = self.aux1.copy()
a.chunk()
def test_AuxiliaryCoordinate__repr__str__dump(self):
f = cf.read(self.filename)[0]
x = f.auxiliary_coordinates('latitude').value()
_ = repr(x)
_ = str(x)
_ = x.dump(display=False)
def test_AuxiliaryCoordinate_bounds(self):
f = cf.read(self.filename)[0]
d = f.dimension_coordinates('X').value()
x = cf.AuxiliaryCoordinate(source=d)
_ = x.upper_bounds
_ = x.lower_bounds
def test_AuxiliaryCoordinate_properties(self):
f = cf.read(self.filename)[0]
x = f.auxiliary_coordinates('latitude').value()
x.positive = 'up'
self.assertEqual(x.positive, 'up')
del x.positive
self.assertIsNone(getattr(x, 'positive', None))
x.axis = 'Z'
self.assertEqual(x.axis, 'Z')
del x.axis
self.assertIsNone(getattr(x, 'axis', None))
d = f.dimension_coordinates('X').value()
x = cf.AuxiliaryCoordinate(source=d)
def test_AuxiliaryCoordinate_insert_dimension(self):
f = cf.read(self.filename)[0]
d = f.dimension_coordinates('X').value()
x = cf.AuxiliaryCoordinate(source=d)
self.assertEqual(x.shape, (9, ))
self.assertEqual(x.bounds.shape, (9, 2))
y = x.insert_dimension(0)
self.assertEqual(y.shape, (1, 9))
self.assertEqual(y.bounds.shape, (1, 9, 2), y.bounds.shape)
x.insert_dimension(-1, inplace=True)
self.assertEqual(x.shape, (9, 1))
self.assertEqual(x.bounds.shape, (9, 1, 2), x.bounds.shape)
def test_AuxiliaryCoordinate_transpose(self):
f = cf.read(self.filename)[0]
x = f.auxiliary_coordinates('longitude').value()
bounds = cf.Bounds(
data=cf.Data(numpy.arange(9 * 10 * 4).reshape(9, 10, 4)))
x.set_bounds(bounds)
self.assertEqual(x.shape, (9, 10))
self.assertEqual(x.bounds.shape, (9, 10, 4))
y = x.transpose()
self.assertEqual(y.shape, (10, 9))
self.assertEqual(y.bounds.shape, (10, 9, 4), y.bounds.shape)
x.transpose([1, 0], inplace=True)
self.assertEqual(x.shape, (10, 9))
self.assertEqual(x.bounds.shape, (10, 9, 4), x.bounds.shape)
def test_AuxiliaryCoordinate_squeeze(self):
f = cf.read(self.filename)[0]
x = f.auxiliary_coordinates('longitude').value()
bounds = cf.Bounds(
data=cf.Data(numpy.arange(9 * 10 * 4).reshape(9, 10, 4)))
x.set_bounds(bounds)
x.insert_dimension(1, inplace=True)
x.insert_dimension(0, inplace=True)
self.assertEqual(x.shape, (1, 9, 1, 10))
self.assertEqual(x.bounds.shape, (1, 9, 1, 10, 4))
y = x.squeeze()
self.assertEqual(y.shape, (9, 10))
self.assertEqual(y.bounds.shape, (9, 10, 4), y.bounds.shape)
x.squeeze(2, inplace=True)
self.assertEqual(x.shape, (1, 9, 10))
self.assertEqual(x.bounds.shape, (1, 9, 10, 4), x.bounds.shape)
def test_AuxiliaryCoordinate_floor(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
self.assertTrue((aux.floor().array == numpy.floor(a)).all())
self.assertTrue((aux.floor().bounds.array == numpy.floor(b)).all())
self.assertTrue(
(aux.floor(bounds=False).array == numpy.floor(a)).all())
self.assertTrue((aux.floor(bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.floor().array == numpy.floor(a)).all())
self.assertTrue(
(aux.floor(bounds=False).array == numpy.floor(a)).all())
self.assertIsNone(aux.floor(inplace=True))
self.assertTrue((aux.array == numpy.floor(a)).all())
def test_AuxiliaryCoordinate_ceil(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
self.assertTrue((aux.ceil().array == numpy.ceil(a)).all())
self.assertTrue((aux.ceil().bounds.array == numpy.ceil(b)).all())
self.assertTrue((aux.ceil(bounds=False).array == numpy.ceil(a)).all())
self.assertTrue((aux.ceil(bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.ceil().array == numpy.ceil(a)).all())
self.assertTrue((aux.ceil(bounds=False).array == numpy.ceil(a)).all())
self.assertIsNone(aux.ceil(inplace=True))
self.assertTrue((aux.array == numpy.ceil(a)).all())
def test_AuxiliaryCoordinate_trunc(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
self.assertTrue((aux.trunc().array == numpy.trunc(a)).all())
self.assertTrue((aux.trunc().bounds.array == numpy.trunc(b)).all())
self.assertTrue(
(aux.trunc(bounds=False).array == numpy.trunc(a)).all())
self.assertTrue((aux.trunc(bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.trunc().array == numpy.trunc(a)).all())
self.assertTrue(
(aux.trunc(bounds=False).array == numpy.trunc(a)).all())
self.assertIsNone(aux.trunc(inplace=True))
self.assertTrue((aux.array == numpy.trunc(a)).all())
def test_AuxiliaryCoordinate_rint(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
x0 = aux.rint()
x = x0.array
self.assertTrue((x == numpy.rint(a)).all(), x)
self.assertTrue((aux.rint().bounds.array == numpy.rint(b)).all())
self.assertTrue((aux.rint(bounds=False).array == numpy.rint(a)).all())
self.assertTrue((aux.rint(bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.rint().array == numpy.rint(a)).all())
self.assertTrue((aux.rint(bounds=False).array == numpy.rint(a)).all())
self.assertIsNone(aux.rint(inplace=True))
self.assertTrue((aux.array == numpy.rint(a)).all())
def test_AuxiliaryCoordinate_close(self):
aux = self.aux1.copy()
aux.close()
def test_AuxiliaryCoordinate_sin_cos_tan(self):
aux = self.aux1.copy()
_ = aux.cos()
self.assertIsNone(aux.cos(inplace=True))
_ = aux.sin()
self.assertIsNone(aux.sin(inplace=True))
_ = aux.tan()
self.assertIsNone(aux.tan(inplace=True))
def test_AuxiliaryCoordinate_log_exp(self):
aux = self.aux1.copy()
_ = aux.exp()
self.assertIsNone(aux.exp(inplace=True))
_ = aux.log()
self.assertIsNone(aux.log(inplace=True))
def test_AuxiliaryCoordinate_count(self):
aux = self.aux1.copy()
_ = aux.count()
aux.del_data()
with self.assertRaises(Exception):
aux.count()
def test_AuxiliaryCoordinate_cyclic(self):
aux = self.aux1.copy()
self.assertEqual(aux.cyclic(), set())
self.assertEqual(aux.cyclic(0), set())
self.assertEqual(aux.cyclic(), set([0]))
def test_AuxiliaryCoordinate_roll(self):
aux = self.aux1.copy()
_ = aux.roll(0, 3)
self.assertIsNone(aux.roll(-1, 4, inplace=True))
def test_AuxiliaryCoordinate_round(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
for decimals in (0, 1, 2, 3, 4, 5):
aux = self.aux1.copy()
self.assertTrue(
(aux.round(decimals).array == numpy.round(a, decimals)).all())
self.assertTrue((aux.round(decimals).bounds.array == numpy.round(
b, decimals)).all())
self.assertTrue(
(aux.round(decimals,
bounds=False).array == numpy.round(a,
decimals)).all())
self.assertTrue((aux.round(decimals,
bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue(
(aux.round(decimals).array == numpy.round(a, decimals)).all())
self.assertTrue(
(aux.round(decimals,
bounds=False).array == numpy.round(a,
decimals)).all())
self.assertIsNone(aux.round(decimals, inplace=True))
self.assertTrue((aux.array == numpy.round(a, decimals)).all())
def test_AuxiliaryCoordinate_clip(self):
aux = self.aux1.copy()
a = aux.array
b = aux.bounds.array
self.assertTrue((aux.clip(-15, 25).array == numpy.clip(a, -15,
25)).all())
self.assertTrue(
(aux.clip(-15, 25).bounds.array == numpy.clip(b, -15, 25)).all())
self.assertTrue(
(aux.clip(-15, 25, bounds=False).array == numpy.clip(a, -15,
25)).all())
self.assertTrue((aux.clip(-15, 25,
bounds=False).bounds.array == b).all())
aux.del_bounds()
self.assertTrue((aux.clip(-15, 25).array == numpy.clip(a, -15,
25)).all())
self.assertTrue(
(aux.clip(-15, 25, bounds=False).array == numpy.clip(a, -15,
25)).all())
self.assertIsNone(aux.clip(-15, 25, inplace=True))
class DimensionCoordinateTest(unittest.TestCase):
f = cf.example_field(1)
dim = cf.DimensionCoordinate()
dim.standard_name = "latitude"
a = numpy.array([
-30,
-23.5,
-17.8123,
-11.3345,
-0.7,
-0.2,
0,
0.2,
0.7,
11.30003,
17.8678678,
23.5,
30,
])
dim.set_data(cf.Data(a, "degrees_north"))
bounds = cf.Bounds()
b = numpy.empty(a.shape + (2, ))
b[:, 0] = a - 0.1
b[:, 1] = a + 0.1
bounds.set_data(cf.Data(b))
dim.set_bounds(bounds)
def test_DimensionCoordinate__repr__str__dump(self):
x = self.f.dimension_coordinate("X")
repr(x)
str(x)
x.dump(display=False)
def test_DimensionCoordinate_convert_reference_time(self):
d = cf.DimensionCoordinate()
d.set_data(
cf.Data([1, 2, 3], "months since 2004-1-1", calendar="gregorian"))
self.assertTrue((d.array == [1.0, 2, 3]).all())
e = d.copy()
self.assertIsNone(
e.convert_reference_time(calendar_months=True, inplace=True))
f = d.convert_reference_time(calendar_months=True)
for x in (e, f):
self.assertTrue((x.array == [31.0, 60.0, 91.0]).all())
self.assertTrue((x.datetime_array == [
cf.dt("2004-02-01 00:00:00", calendar="gregorian"),
cf.dt("2004-03-01 00:00:00", calendar="gregorian"),
cf.dt("2004-04-01 00:00:00", calendar="gregorian"),
]).all())
self.assertTrue((d.array == [1.0, 2, 3]).all())
d = cf.DimensionCoordinate()
d.set_data(
cf.Data([1, 2, 3], "months since 2004-1-1", calendar="360_day"))
e = d.copy()
self.assertIsNone(
e.convert_reference_time(calendar_months=True, inplace=True))
f = d.convert_reference_time(calendar_months=True)
for x in (e, f):
self.assertTrue((x.array == [30.0, 60.0, 90.0]).all())
self.assertTrue((x.datetime_array == [
cf.dt("2004-02-01 00:00:00", calendar="360_day"),
cf.dt("2004-03-01 00:00:00", calendar="360_day"),
cf.dt("2004-04-01 00:00:00", calendar="360_day"),
]).all())
self.assertTrue((d.array == [1.0, 2, 3]).all())
d = cf.DimensionCoordinate()
d.set_data(
cf.Data([1, 2, 3], "months since 2004-1-1", calendar="noleap"))
e = d.copy()
self.assertIsNone(
e.convert_reference_time(calendar_months=True, inplace=True))
f = d.convert_reference_time(calendar_months=True)
for x in (e, f):
self.assertTrue((x.array == [31.0, 59.0, 90.0]).all())
self.assertTrue((x.datetime_array == [
cf.dt("2004-02-01 00:00:00", calendar="noleap"),
cf.dt("2004-03-01 00:00:00", calendar="noleap"),
cf.dt("2004-04-01 00:00:00", calendar="noleap"),
]).all())
self.assertTrue((d.array == [1.0, 2, 3]).all())
def test_DimensionCoordinate_roll(self):
x = self.f.dimension_coordinate("X").copy()
y = self.f.dimension_coordinate("Y")
x.roll(0, 3)
with self.assertRaises(Exception):
y.roll(0, 3)
x.roll(0, 3)
x.roll(-1, 3)
with self.assertRaises(Exception):
x.roll(2, 3)
a = x[0]
a.roll(0, 3)
self.assertIsNone(a.roll(0, 3, inplace=True))
x.roll(0, 0)
x.roll(0, 3, inplace=True)
self.assertIsNone(x.roll(0, 0, inplace=True))
x._centre(360)
x.flip()._centre(360)
# Test roll on coordinate without bounds:
g = self.f.copy()
g.dimension_coordinate("X").del_bounds()
for shift_by in [1, -1, g.shape[2]]: # vary roll direction and extent
g_rolled = g.roll("X", shift=shift_by)
if shift_by == g.shape[2]: # shift_by equal to the roll axis size
g_rolled_0 = g.roll("X", shift=0)
# A roll of the axes size, or 0, should not change the array:
self.assertTrue((g_rolled.array == g.array).all())
self.assertTrue((g_rolled.array == g_rolled_0.array).all())
for index in range(0, 10): # check all elements are rolled
self.assertEqual(g_rolled.array[0, index, 0],
g.array[0, index, -shift_by])
def test_DimensionCoordinate_cellsize(self):
d = self.dim.copy()
c = d.cellsize
self.assertTrue(numpy.allclose(c.array, 0.2))
self.assertTrue(d.Units.equals(cf.Units("degrees_north")))
self.assertTrue(d.bounds.Units.equals(cf.Units("degrees_north")))
d.override_units("km", inplace=True)
self.assertTrue(d.Units.equals(cf.Units("km")))
self.assertTrue(d.bounds.Units.equals(cf.Units("km")))
c = d.cellsize
self.assertTrue(c.Units.equals(cf.Units("km")))
d.del_bounds()
c = d.cellsize
self.assertTrue(numpy.allclose(c.array, 0))
def test_DimensionCoordinate_override_units(self):
d = self.dim.copy()
self.assertTrue(d.Units.equals(cf.Units("degrees_north")))
self.assertTrue(d.bounds.Units.equals(cf.Units("degrees_north")))
d.override_units("km", inplace=True)
self.assertTrue(d.Units.equals(cf.Units("km")))
self.assertTrue(d.bounds.Units.equals(cf.Units("km")))
c = d.cellsize
self.assertTrue(c.Units.equals(cf.Units("km")))
def test_DimensionCoordinate_override_calendar(self):
d = self.dim.copy()
self.assertTrue(d.Units.equals(cf.Units("degrees_north")))
self.assertTrue(d.bounds.Units.equals(cf.Units("degrees_north")))
d.override_units("days since 2000-01-01", inplace=True)
self.assertTrue(d.Units.equals(cf.Units("days since 2000-01-01")))
self.assertTrue(
d.bounds.Units.equals(cf.Units("days since 2000-01-01")))
d.override_calendar("360_day", inplace=True)
self.assertTrue(
d.Units.equals(
cf.Units("days since 2000-01-01", calendar="360_day")))
self.assertTrue(
d.bounds.Units.equals(
cf.Units("days since 2000-01-01", calendar="360_day")))
d.override_calendar("365_day", inplace=True)
self.assertTrue(
d.Units.equals(
cf.Units("days since 2000-01-01", calendar="365_day")))
self.assertTrue(
d.bounds.Units.equals(
cf.Units("days since 2000-01-01", calendar="365_day")))
def test_DimensionCoordinate_bounds(self):
x = self.f.dimension_coordinate("X")
x.upper_bounds
x.lower_bounds
self.assertTrue(x.increasing)
y = x.flip()
self.assertTrue(y.decreasing)
self.assertTrue(y.upper_bounds.equals(x.upper_bounds[::-1]))
self.assertTrue(y.lower_bounds.equals(x.lower_bounds[::-1]))
x.cellsize
y.cellsize
y.del_bounds()
y.create_bounds()
def test_DimensionCoordinate_properties(self):
x = self.f.dimension_coordinate("X").copy()
x.positive = "up"
self.assertEqual(x.positive, "up")
del x.positive
x.axis = "Z"
self.assertEqual(x.axis, "Z")
del x.axis
x.axis = "T"
self.assertEqual(x.ndim, 1)
def test_DimensionCoordinate_insert_dimension(self):
x = self.f.dimension_coordinate("X").copy()
self.assertEqual(x.shape, (9, ))
self.assertEqual(x.bounds.shape, (9, 2))
y = x.insert_dimension(0)
self.assertEqual(y.shape, (1, 9))
self.assertEqual(y.bounds.shape, (1, 9, 2), y.bounds.shape)
x.insert_dimension(-1, inplace=True)
self.assertEqual(x.shape, (9, 1))
self.assertEqual(x.bounds.shape, (9, 1, 2), x.bounds.shape)
def test_DimensionCoordinate_unary_operation(self):
d = self.dim
self.assertLess(d.minimum(), 0)
self.assertLess(d.bounds.minimum(), 0)
d = abs(d)
self.assertGreaterEqual(d.minimum(), 0, d.array)
self.assertGreaterEqual(d.bounds.minimum(), 0, d.bounds.array)
d = -d
self.assertLess(d.minimum(), 0)
self.assertLess(d.bounds.minimum(), 0)
d = +d
self.assertLess(d.minimum(), 0)
self.assertLess(d.bounds.minimum(), 0)
d.dtype = int
d.bounds.dtype = int
d = ~d
def test_DimensionCoordinate_binary_operation(self):
dim = self.dim
c = dim.array
b = dim.bounds.array
c2 = numpy.expand_dims(c, -1)
x = dim.copy()
y = dim.copy()
old = cf.bounds_combination_mode()
# ------------------------------------------------------------
# Out-of-place addition
# ------------------------------------------------------------
for value in ("AND", "NONE"):
cf.bounds_combination_mode(value)
z = x + 2
self.assertTrue((z.array == c + 2).all())
self.assertFalse(z.has_bounds())
for value in ("OR", "XOR"):
cf.bounds_combination_mode(value)
z = x + 2
self.assertTrue((z.array == c + 2).all())
self.assertTrue((z.bounds.array == b + 2).all())
for value in ("AND", "OR"):
cf.bounds_combination_mode(value)
z = x + y
self.assertTrue((z.array == c + c).all())
self.assertTrue((z.bounds.array == b + b).all())
for value in ("XOR", "NONE"):
cf.bounds_combination_mode(value)
z = x + y
self.assertTrue((z.array == c + c).all())
self.assertFalse(z.has_bounds())
x.del_bounds()
for value in ("AND", "XOR", "OR", "NONE"):
cf.bounds_combination_mode(value)
z = x + 2
self.assertTrue((z.array == c + 2).all())
self.assertFalse(z.has_bounds())
for value in ("AND", "NONE"):
cf.bounds_combination_mode(value)
z = x + y
self.assertTrue((z.array == c + c).all())
self.assertFalse(z.has_bounds())
for value in ("OR", "XOR"):
cf.bounds_combination_mode(value)
z = x + y
self.assertTrue((z.array == c + c).all())
self.assertTrue((z.bounds.array == c2 + b).all())
# ------------------------------------------------------------
# In-place addition
# ------------------------------------------------------------
for value in ("AND", "NONE"):
cf.bounds_combination_mode(value)
x = dim.copy()
x += 2
self.assertTrue((x.array == c + 2).all())
self.assertFalse(x.has_bounds())
for value in ("OR", "XOR"):
cf.bounds_combination_mode(value)
x = dim.copy()
x += 2
self.assertTrue((x.array == c + 2).all())
self.assertTrue((x.bounds.array == b + 2).all())
for value in ("AND", "OR"):
cf.bounds_combination_mode(value)
x = dim.copy()
x += y
self.assertTrue((x.array == c + c).all())
self.assertTrue((x.bounds.array == b + b).all())
for value in ("XOR", "NONE"):
cf.bounds_combination_mode(value)
x = dim.copy()
x += y
self.assertTrue((x.array == c + c).all())
self.assertFalse(x.has_bounds())
for value in ("XOR", "OR"):
cf.bounds_combination_mode(value)
x = dim.copy()
x.del_bounds()
x += y
self.assertTrue((x.array == c + c).all())
self.assertTrue((x.bounds.array == c2 + b).all())
for value in ("AND", "NONE"):
cf.bounds_combination_mode(value)
x = dim.copy()
x.del_bounds()
x += y
self.assertTrue((x.array == c + c).all())
self.assertFalse(x.has_bounds())
# ------------------------------------------------------------
# Reset constant
# ------------------------------------------------------------
cf.bounds_combination_mode(old)
def test_DimensionCoordinate_set_data(self):
x = cf.DimensionCoordinate()
y = x.set_data(cf.Data([1, 2, 3]))
self.assertIsNone(y)
self.assertTrue(x.has_data())
# Test inplace
x.del_data()
y = x.set_data(cf.Data([1, 2, 3]), inplace=False)
self.assertIsInstance(y, cf.DimensionCoordinate)
self.assertFalse(x.has_data())
self.assertTrue(y.has_data())
# Exceptions should be raised for 0-d and N-d (N>=2) data
with self.assertRaises(Exception):
y = x.set_data(cf.Data([[1, 2, 3]]))
with self.assertRaises(Exception):
y = x.set_data(cf.Data(1))
def test_DimensionCoordinate__setitem__(self):
d = self.dim.copy()
d.array
d.bounds.array
d[...] = 999
self.assertTrue(d.bounds.equals(self.dim.bounds, verbose=3))
d = self.dim.copy()
e = self.dim.copy()
d[...] = -e
self.assertTrue(d.data.equals(-e.data, verbose=3))
self.assertTrue(d.bounds.equals(-e.bounds, verbose=3))
d = self.dim.copy()
e = self.dim.copy()
e.del_bounds()
d[...] = -e
self.assertTrue(d.data.equals(-e.data, verbose=3))
self.assertTrue(d.bounds.equals(self.dim.bounds, verbose=3))
class DimensionCoordinateTest(unittest.TestCase):
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'test_file.nc')
# f = cf.read(filename)[0]
dim = cf.DimensionCoordinate()
dim.standard_name = 'latitude'
a = numpy.array([
-30, -23.5, -17.8123, -11.3345, -0.7, -0.2, 0, 0.2, 0.7, 11.30003,
17.8678678, 23.5, 30
])
dim.set_data(cf.Data(a, 'degrees_north'))
bounds = cf.Bounds()
b = numpy.empty(a.shape + (2, ))
b[:, 0] = a - 0.1
b[:, 1] = a + 0.1
bounds.set_data(cf.Data(b))
dim.set_bounds(bounds)
def test_DimensionCoordinate__repr__str__dump(self):
f = cf.read(self.filename)[0]
x = f.dimension_coordinates('X').value()
_ = repr(x)
_ = str(x)
_ = x.dump(display=False)
def test_DimensionCoordinate_convert_reference_time(self):
d = cf.DimensionCoordinate()
d.set_data(
cf.Data([1, 2, 3], 'months since 2004-1-1', calendar='gregorian'))
self.assertTrue((d.array == [1., 2, 3]).all())
e = d.copy()
self.assertIsNone(
e.convert_reference_time(calendar_months=True, inplace=True))
f = d.convert_reference_time(calendar_months=True)
for x in (e, f):
self.assertTrue((x.array == [31., 60., 91.]).all())
self.assertTrue((x.datetime_array == [
cf.dt('2004-02-01 00:00:00', calendar='gregorian'),
cf.dt('2004-03-01 00:00:00', calendar='gregorian'),
cf.dt('2004-04-01 00:00:00', calendar='gregorian')
]).all())
self.assertTrue((d.array == [1., 2, 3]).all())
d = cf.DimensionCoordinate()
d.set_data(
cf.Data([1, 2, 3], 'months since 2004-1-1', calendar='360_day'))
e = d.copy()
self.assertIsNone(
e.convert_reference_time(calendar_months=True, inplace=True))
f = d.convert_reference_time(calendar_months=True)
for x in (e, f):
self.assertTrue((x.array == [30., 60., 90.]).all())
self.assertTrue((x.datetime_array == [
cf.dt('2004-02-01 00:00:00', calendar='360_day'),
cf.dt('2004-03-01 00:00:00', calendar='360_day'),
cf.dt('2004-04-01 00:00:00', calendar='360_day')
]).all())
self.assertTrue((d.array == [1., 2, 3]).all())
d = cf.DimensionCoordinate()
d.set_data(
cf.Data([1, 2, 3], 'months since 2004-1-1', calendar='noleap'))
e = d.copy()
self.assertIsNone(
e.convert_reference_time(calendar_months=True, inplace=True))
f = d.convert_reference_time(calendar_months=True)
for x in (e, f):
self.assertTrue((x.array == [31., 59., 90.]).all())
self.assertTrue((x.datetime_array == [
cf.dt('2004-02-01 00:00:00', calendar='noleap'),
cf.dt('2004-03-01 00:00:00', calendar='noleap'),
cf.dt('2004-04-01 00:00:00', calendar='noleap')
]).all())
self.assertTrue((d.array == [1., 2, 3]).all())
def test_DimensionCoordinate_roll(self):
f = cf.read(self.filename)[0]
x = f.dimension_coordinates('X').value()
y = f.dimension_coordinates('Y').value()
_ = x.roll(0, 3)
with self.assertRaises(Exception):
y.roll(0, 3)
_ = x.roll(0, 3)
_ = x.roll(-1, 3)
with self.assertRaises(Exception):
_ = x.roll(2, 3)
a = x[0]
_ = a.roll(0, 3)
self.assertIsNone(a.roll(0, 3, inplace=True))
_ = x.roll(0, 0)
_ = x.roll(0, 3, inplace=True)
self.assertIsNone(x.roll(0, 0, inplace=True))
_ = x._centre(360)
_ = x.flip()._centre(360)
# Test roll on coordinate without bounds:
g = f.copy()
g.dimension_coordinate('X').del_bounds()
for shift_by in [1, -1, g.shape[2]]: # vary roll direction and extent
g_rolled = g.roll('X', shift=shift_by)
if shift_by == g.shape[2]: # shift_by equal to the roll axis size
g_rolled_0 = g.roll('X', shift=0)
# A roll of the axes size, or 0, should not change the array:
self.assertTrue((g_rolled.array == g.array).all())
self.assertTrue((g_rolled.array == g_rolled_0.array).all())
for index in range(0, 10): # check all elements are rolled
self.assertEqual(g_rolled.array[0, index, 0],
g.array[0, index, -shift_by])
def test_DimensionCoordinate_cellsize(self):
d = self.dim.copy()
c = d.cellsize
self.assertTrue(numpy.allclose(c.array, 0.2))
self.assertTrue(d.Units.equals(cf.Units('degrees_north')))
self.assertTrue(d.bounds.Units.equals(cf.Units('degrees_north')))
d.override_units('km', inplace=True)
self.assertTrue(d.Units.equals(cf.Units('km')))
self.assertTrue(d.bounds.Units.equals(cf.Units('km')))
c = d.cellsize
self.assertTrue(c.Units.equals(cf.Units('km')))
d.del_bounds()
c = d.cellsize
self.assertTrue(numpy.allclose(c.array, 0))
def test_DimensionCoordinate_override_units(self):
d = self.dim.copy()
self.assertTrue(d.Units.equals(cf.Units('degrees_north')))
self.assertTrue(d.bounds.Units.equals(cf.Units('degrees_north')))
d.override_units('km', inplace=True)
self.assertTrue(d.Units.equals(cf.Units('km')))
self.assertTrue(d.bounds.Units.equals(cf.Units('km')))
c = d.cellsize
self.assertTrue(c.Units.equals(cf.Units('km')))
def test_DimensionCoordinate_override_calendar(self):
d = self.dim.copy()
self.assertTrue(d.Units.equals(cf.Units('degrees_north')))
self.assertTrue(d.bounds.Units.equals(cf.Units('degrees_north')))
d.override_units('days since 2000-01-01', inplace=True)
self.assertTrue(d.Units.equals(cf.Units('days since 2000-01-01')))
self.assertTrue(
d.bounds.Units.equals(cf.Units('days since 2000-01-01')))
d.override_calendar('360_day', inplace=True)
self.assertTrue(
d.Units.equals(
cf.Units('days since 2000-01-01', calendar='360_day')))
self.assertTrue(
d.bounds.Units.equals(
cf.Units('days since 2000-01-01', calendar='360_day')))
d.override_calendar('365_day', inplace=True)
self.assertTrue(
d.Units.equals(
cf.Units('days since 2000-01-01', calendar='365_day')))
self.assertTrue(
d.bounds.Units.equals(
cf.Units('days since 2000-01-01', calendar='365_day')))
def test_DimensionCoordinate_bounds(self):
f = cf.read(self.filename)[0]
x = f.dimension_coordinates('X').value()
_ = x.upper_bounds
_ = x.lower_bounds
self.assertTrue(x.increasing)
y = x.flip()
self.assertTrue(y.decreasing)
self.assertTrue(y.upper_bounds.equals(x.upper_bounds[::-1]))
self.assertTrue(y.lower_bounds.equals(x.lower_bounds[::-1]))
c = x.cellsize
c = y.cellsize
y.del_bounds()
b = y.create_bounds()
def test_DimensionCoordinate_properties(self):
f = cf.read(self.filename)[0]
x = f.dimension_coordinates('X').value()
x.positive = 'up'
self.assertEqual(x.positive, 'up')
del x.positive
x.axis = 'Z'
self.assertEqual(x.axis, 'Z')
del x.axis
x.axis = 'T'
self.assertEqual(x.ndim, 1)
def test_DimensionCoordinate_insert_dimension(self):
f = cf.read(self.filename)[0]
x = f.dimension_coordinates('X').value()
self.assertEqual(x.shape, (9, ))
self.assertEqual(x.bounds.shape, (9, 2))
y = x.insert_dimension(0)
self.assertEqual(y.shape, (1, 9))
self.assertEqual(y.bounds.shape, (1, 9, 2), y.bounds.shape)
x.insert_dimension(-1, inplace=True)
self.assertEqual(x.shape, (9, 1))
self.assertEqual(x.bounds.shape, (9, 1, 2), x.bounds.shape)
def test_DimensionCoordinate_binary_operation(self):
f = cf.read(self.filename)[0]
x = f.dimension_coordinates('X').value()
d = x.array
b = x.bounds.array
d2 = numpy.expand_dims(d, -1)
# --------------------------------------------------------
# Out-of-place addition
# --------------------------------------------------------
c = x + 2
self.assertTrue((c.array == d + 2).all())
self.assertTrue((c.bounds.array == b + 2).all())
c = x + x
self.assertTrue((c.array == d + d).all())
self.assertTrue((c.bounds.array == b + d2).all())
c = x + 2
self.assertTrue((c.array == d + 2).all())
self.assertTrue((c.bounds.array == b + 2).all())
self.assertTrue((x.array == d).all())
self.assertTrue((x.bounds.array == b).all())
# --------------------------------------------------------
# In-place addition
# --------------------------------------------------------
x += 2
self.assertTrue((x.array == d + 2).all())
self.assertTrue((x.bounds.array == b + 2).all())
x += x
self.assertTrue((x.array == (d + 2) * 2).all())
self.assertTrue((x.bounds.array == b + 2 + d2 + 2).all())
x += 2
self.assertTrue((x.array == (d + 2) * 2 + 2).all())
self.assertTrue((x.bounds.array == b + 2 + d2 + 2 + 2).all())
# --------------------------------------------------------
# Out-of-place addition (no bounds)
# --------------------------------------------------------
f = cf.read(self.filename)[0]
x = f.dimension_coordinates('X').value()
x.del_bounds()
self.assertFalse(x.has_bounds())
d = x.array
c = x + 2
self.assertTrue((c.array == d + 2).all())
c = x + x
self.assertTrue((c.array == d + d).all())
c = x + 2
self.assertTrue((c.array == d + 2).all())
self.assertTrue((x.array == d).all())
# --------------------------------------------------------
# In-place addition (no bounds)
# --------------------------------------------------------
x += 2
self.assertTrue((x.array == d + 2).all())
x += x
self.assertTrue((x.array == (d + 2) * 2).all())
x += 2
self.assertTrue((x.array == (d + 2) * 2 + 2).all())
def test_DimensionCoordinate_set_data(self):
x = cf.DimensionCoordinate()
y = x.set_data(cf.Data([1, 2, 3]))
self.assertIsNone(y)
self.assertTrue(x.has_data())
# Test inplace
x.del_data()
y = x.set_data(cf.Data([1, 2, 3]), inplace=False)
self.assertIsInstance(y, cf.DimensionCoordinate)
self.assertFalse(x.has_data())
self.assertTrue(y.has_data())
# Exceptions should be raised for 0-d and N-d (N>=2) data
with self.assertRaises(Exception):
y = x.set_data(cf.Data([[1, 2, 3]]))
with self.assertRaises(Exception):
y = x.set_data(cf.Data(1))
def test_create_field(self):
# Dimension coordinates
dim1 = cf.DimensionCoordinate(
data=cf.Data(numpy.arange(10.), 'degrees'))
dim1.standard_name = 'grid_latitude'
dim0 = cf.DimensionCoordinate(
data=cf.Data(numpy.arange(9.) + 20, 'degrees'))
dim0.standard_name = 'grid_longitude'
dim0.data[-1] += 5
bounds = cf.Data(numpy.array(
[dim0.data.array-0.5, dim0.data.array+0.5]).transpose((1, 0)))
bounds[-2, 1] = 30
bounds[-1, :] = [30, 36]
dim0.set_bounds(cf.Bounds(data=bounds))
dim2 = cf.DimensionCoordinate(
data=cf.Data([1.5]),
bounds=cf.Bounds(data=cf.Data([[1, 2.]]))
)
dim2.standard_name = 'atmosphere_hybrid_height_coordinate'
# Auxiliary coordinates
ak = cf.DomainAncillary(data=cf.Data([10.], 'm'))
ak.id = 'atmosphere_hybrid_height_coordinate_ak'
bounds = cf.Bounds(data=cf.Data([[5, 15.]], units=ak.Units))
ak.set_bounds(bounds)
bk = cf.DomainAncillary(data=cf.Data([20.]))
bk.id = 'atmosphere_hybrid_height_coordinate_bk'
bounds = cf.Bounds(data=cf.Data([[14, 26.]]))
bk.set_bounds(bounds)
aux2 = cf.AuxiliaryCoordinate(
data=cf.Data(numpy.arange(-45, 45, dtype='int32').reshape(10, 9),
units='degree_N'))
aux2.standard_name = 'latitude'
aux3 = cf.AuxiliaryCoordinate(
data=cf.Data(numpy.arange(60, 150, dtype='int32').reshape(9, 10),
units='degreesE'))
aux3.standard_name = 'longitude'
aux4 = cf.AuxiliaryCoordinate(
data=cf.Data(numpy.array(
['alpha', 'beta', 'gamma', 'delta', 'epsilon',
'zeta', 'eta', 'theta', 'iota', 'kappa'],
dtype='S'
))
)
aux4.standard_name = 'greek_letters'
aux4[0] = cf.masked
# Cell measures
msr0 = cf.CellMeasure(
data=cf.Data(1+numpy.arange(90.).reshape(9, 10)*1234, 'km 2'))
msr0.measure = 'area'
# Data
data = cf.Data(numpy.arange(90.).reshape(10, 9), 'm s-1')
properties = {'standard_name': 'eastward_wind'}
f = cf.Field(properties=properties)
axisX = f.set_construct(cf.DomainAxis(9))
axisY = f.set_construct(cf.DomainAxis(10))
axisZ = f.set_construct(cf.DomainAxis(1))
f.set_data(data)
x = f.set_construct(dim0)
y = f.set_construct(dim1, axes=[axisY])
z = f.set_construct(dim2, axes=[axisZ])
lat = f.set_construct(aux2)
lon = f.set_construct(aux3, axes=['X', axisY])
f.set_construct(aux4, axes=['Y'])
ak = f.set_construct(ak, axes=['Z'])
bk = f.set_construct(bk, axes=[axisZ])
# Coordinate references
coordinate_conversion = cf.CoordinateConversion(
parameters={'grid_mapping_name': 'rotated_latitude_longitude',
'grid_north_pole_latitude': 38.0,
'grid_north_pole_longitude': 190.0})
ref0 = cf.CoordinateReference(
coordinate_conversion=coordinate_conversion,
coordinates=[x, y, lat, lon]
)
f.set_construct(msr0, axes=[axisX, 'Y'])
f.set_construct(ref0)
orog = cf.DomainAncillary()
orog.standard_name = 'surface_altitude'
orog.set_data(cf.Data(f.array*2, 'm'))
orog.transpose([1, 0], inplace=True)
orog_key = f.set_construct(orog, axes=['X', axisY])
coordinate_conversion = cf.CoordinateConversion(
parameters={
'standard_name': 'atmosphere_hybrid_height_coordinate'
},
domain_ancillaries={
'orog': orog_key,
'a': ak,
'b': bk
}
)
ref1 = cf.CoordinateReference(
coordinate_conversion=coordinate_conversion, coordinates=[z])
f.set_construct(ref1)
# Field ancillary variables
g = cf.FieldAncillary()
g.set_data(f.data)
g.transpose([1, 0], inplace=True)
g.standard_name = 'ancillary0'
g *= 0.01
f.set_construct(g)
g = cf.FieldAncillary()
g.set_data(f.data)
g.standard_name = 'ancillary1'
g *= 0.01
f.set_construct(g)
g = cf.FieldAncillary()
g.set_data(f[0, :].data)
g.squeeze(inplace=True)
g.standard_name = 'ancillary2'
g *= 0.001
f.set_construct(g)
g = cf.FieldAncillary()
g.set_data(f[:, 0].data)
g.squeeze(inplace=True)
g.standard_name = 'ancillary3'
g *= 0.001
f.set_construct(g)
f.flag_values = [1, 2, 4]
f.flag_meanings = ['a', 'bb', 'ccc']
for cm in cf.CellMethod.create(
'grid_longitude: mean grid_latitude: max'):
f.set_construct(cm)
# Write the file, and read it in
cf.write(f, self.filename, verbose=0, string=True)
g = cf.read(self.filename, squeeze=True, verbose=0)[0]
self.assertTrue(g.equals(f, verbose=0),
"Field not equal to itself read back in")
x = g.dump(display=False)
x = f.dump(display=False)
