def __getitem__(self, index):
p_PO = self.arguments[0][index]
p_PS = self.arguments[1][index]
p_hyam = self.arguments[2][index]
p_hybm = self.arguments[3][index]
p_T = self.arguments[4][index]
p_PM25_o = self.arguments[5][index]
if index is None:
return PhysArray(
np.zeros((0, 0, 0, 0)),
dimensions=[
p_T.dimensions[0],
p_T.dimensions[1],
p_T.dimensions[2],
p_T.dimensions[3],
],
)
PO = p_PO.data
PS = p_PS.data
hyam = p_hyam.data
hybm = p_hybm.data
T = p_T.data
PM25_o = p_PM25_o.data
p = (hyam * PO) + (hybm * PS)
pm25 = PM25_o * 287.0 * T / p
new_name = "pm25({}{}{}{}{}{})".format(p_PO.name, p_PS.name,
p_hyam.name, p_hybm.name,
p_T.name, p_PM25_o.name)
return PhysArray(pm25, name=new_name, units="kg/kg")
def test_func_chunits_refdate_calendar(self):
key = 'chunits'
indata = PhysArray(2.5,
name='t',
units=Unit('days since 1850-01-01',
calendar='noleap'))
new_ref = '0001-01-01'
new_cal = 'gregorian'
testname = '{}({}, refdate={}, calendar={})'.format(
key, indata, new_ref, new_cal)
func = functions.find(key)
actual = func(indata, refdate=new_ref, calendar=new_cal)[:]
expected = PhysArray(2.5,
name='chunits(t, units=days since {}|{})'.format(
new_ref, new_cal),
units=Unit('days since {}'.format(new_ref),
calendar=new_cal))
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
np.testing.assert_array_equal(actual, expected,
'{} failed - data'.format(testname))
self.assertEqual(actual.name, expected.name,
'{} failed - name'.format(testname))
self.assertEqual(actual.units, expected.units,
'{} failed - units'.format(testname))
def test_func_limit(self):
key = 'limit'
indata = PhysArray([2.5, 7.3, 8.2, 1.4],
name='x',
units='m',
dimensions=('t', ))
below_val = 3.0
above_val = 7.5
testname = '{}({}, above={}, below={})'.format(key, indata, above_val,
below_val)
func = functions.find(key)
actual = func(indata, above=above_val, below=below_val)[:]
expected = PhysArray([3.0, 7.3, 7.5, 3.0],
name=testname,
units='m',
dimensions=('t', ))
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
np.testing.assert_array_equal(actual, expected,
'{} failed - data'.format(testname))
self.assertEqual(actual.name, expected.name,
'{} failed - name'.format(testname))
self.assertEqual(actual.units, expected.units,
'{} failed - units'.format(testname))
def test_func_chunits_refdate_calendar(self):
key = "chunits"
indata = PhysArray(
2.5, name="t", units=Unit("days since 1850-01-01", calendar="365_day")
)
new_ref = "0001-01-01"
new_cal = "gregorian"
testname = "{}({}, refdate={}, calendar={})".format(
key, indata, new_ref, new_cal
)
func = functions.find(key)
actual = func(indata, refdate=new_ref, calendar=new_cal)[:]
expected = PhysArray(
2.5,
name="chunits(t, units=days since {}|{})".format(new_ref, new_cal),
units=Unit("days since {}".format(new_ref), calendar=new_cal),
)
print_test_message(testname, indata=indata, actual=actual, expected=expected)
np.testing.assert_array_equal(
actual, expected, "{} failed - data".format(testname)
)
self.assertEqual(
actual.name, expected.name, "{} failed - name".format(testname)
)
self.assertEqual(
actual.units, expected.units, "{} failed - units".format(testname)
)
def test_func_mean_physarray_2d(self):
key = 'mean'
indata = PhysArray([[1.0, 2.0], [3.0, 4.0]],
mask=[[False, False], [True, False]],
name='x',
units='m',
dimensions=('t', 'u'))
testname = '{}({})'.format(key, indata)
func = functions.find(key)
fobj = func(indata, 't')
actual = fobj[:]
expected = PhysArray([1.0, 3.0],
name='mean(x, dims=[t])',
units='m',
dimensions=('u', ))
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
np.testing.assert_array_equal(actual, expected,
'{} failed - data'.format(testname))
self.assertEqual(actual.name, expected.name,
'{} failed - name'.format(testname))
self.assertEqual(actual.units, expected.units,
'{} failed - units'.format(testname))
def _test_binary_operator_(self, binop, expvals, testname):
for i, j in expvals:
expected = expvals[(i, j)]
X = (PhysArray(deepcopy(self.vs[i]), name="X") if isinstance(
self.vs[i], PhysArray) else deepcopy(self.vs[i]))
Y = (PhysArray(deepcopy(self.vs[j]), name="Y") if isinstance(
self.vs[j], PhysArray) else deepcopy(self.vs[j]))
print("TEST ID: {}".format((i, j)))
if type(expected) is type and issubclass(expected, Exception):
print_test_message(testname,
testid=(i, j),
X=X,
Y=Y,
expected=expected)
self.assertRaises(expected, binop, X, Y)
else:
actual = binop(X, Y)
print_test_message(testname,
testid=(i, j),
X=X,
Y=Y,
actual=actual,
expected=expected)
self.assertPhysArraysEqual(actual, expected, testname)
def __getitem__(self, index):
p_data = self.arguments[0][index]
p_time = self.arguments[1][index]
p_lat = self.arguments[2][index]
p_lon = self.arguments[3][index]
if index is None:
return PhysArray(np.zeros((0, 0, 0)),
dimensions=[
p_time.dimensions[0], p_lat.dimensions[0],
p_lon.dimensions[0]
])
data = p_data.data
time = p_time.data
lat = p_lat.data
lon = p_lon.data
a = np.zeros((len(time) * 12, len(lat), len(lon)))
for i in range(len(time)):
for j in range(12):
a[((i * 12) + j), :, :] = data[i, :, :]
new_name = 'yeartomonth_data({}{}{}{})'.format(p_data.name,
p_time.name, p_lat.name,
p_lon.name)
return PhysArray(a, name=new_name, units=p_data.units)
def __getitem__(self, index):
a1 = self.arguments[0][index]
condition = self.arguments[1]
a2 = self.arguments[2]
var = self.arguments[3][index]
value = self.arguments[4]
if index is None:
return PhysArray(a1.data,
dimensions=[
a1.dimensions[0], a1.dimensions[1],
a1.dimensions[2]
])
a = np.ma.zeros(a1.shape)
for t in range(a1.data.shape[0]):
if '>=' in condition:
a[t, :, :] = np.ma.where(a1[t, :, :] >= a2, var, value)
elif '<=' in condition:
a[t, :, :] = np.ma.where(a1[t, :, :] <= a2, var, value)
elif '==' in condition:
a[t, :, :] = np.ma.where(a1[t, :, :] == a2, var, value)
elif '<' in condition:
a[t, :, :] = np.ma.where(a1[t, :, :] < a2, var, value)
elif '>' in condition:
a[t, :, :] = np.ma.where(a1[t, :, :] > a2, var, value)
new_name = 'cice_where()'.format()
return PhysArray(
a,
name=new_name,
dimensions=[a1.dimensions[0], a1.dimensions[1], a1.dimensions[2]],
units=var.units)
def __getitem__(self, index):
p_time = self.arguments[0][index]
if index is None:
return PhysArray(np.zeros((0)),
dimensions=[p_time.dimensions[0]],
units=p_time.units,
calendar='noleap')
time = p_time.data
monLens = [
31.0, 28.0, 31.0, 30.0, 31.0, 30.0, 31.0, 31.0, 30.0, 31.0, 30.0,
31.0
]
a = np.zeros((len(time) * 12))
for i in range(len(time)):
prev = 0
for j in range(12):
a[((i * 12) + j)] = float((time[i] - 365) + prev +
float(monLens[j] / 2.0))
prev += monLens[j]
new_name = 'yeartomonth_time({})'.format(p_time.name)
return PhysArray(a,
name=new_name,
dimensions=[p_time.dimensions[0]],
units=p_time.units,
calendar='noleap')
def __getitem__(self, index):
p_PO = self.arguments[0][index]
p_PS = self.arguments[1][index]
p_hyam = self.arguments[2][index]
p_hybm = self.arguments[3][index]
p_T = self.arguments[4][index]
if index is None:
return PhysArray(
np.zeros((0, 0, 0, 0)),
dimensions=[
p_T.dimensions[0],
p_T.dimensions[1],
p_T.dimensions[2],
p_T.dimensions[3],
],
)
PO = p_PO.data
PS = p_PS.data
hyam = p_hyam.data
hybm = p_hybm.data
T = p_T.data
p = (hyam * PO) + (hybm * PS)
rho = p / (287.04 * T)
new_name = "rho({}{}{}{}{})".format(p_PO.name, p_PS.name, p_hyam.name,
p_hybm.name, p_T.name)
return PhysArray(rho, name=new_name, units="cm-3")
def __getitem__(self, index):
data = self.arguments[0][index]
dimensions = self.arguments[1:]
indims = []
if index is None:
return PhysArray(
np.zeros((0, 0, 0)),
units=data.units,
dimensions=[
data.dimensions[0], data.dimensions[2], data.dimensions[3]
],
)
for d in dimensions:
if d in data.dimensions:
indims.append(data.dimensions.index(d))
new_name = "max({},{})".format(data.name, dimensions[0])
m = np.amax(data, axis=indims[0])
return PhysArray(
m,
name=new_name,
positive=data.positive,
units=data.units,
dimensions=[
data.dimensions[0], data.dimensions[2], data.dimensions[3]
],
)
def __getitem__(self, index):
data = self.arguments[0][index]
bdim = self.keywords['bdim']
location = self.keywords['location']
bnds = PhysArray([1, 1], dimensions=(bdim, ))
new_data = PhysArray(data * bnds, name='bounds({})'.format(data.name))
if index is None:
return new_data
if self._compute_idata:
dx = diff(data.data)
if location == 0:
new_data[:-1, 1] = data.data[:-1] + dx
if self._mod_end:
new_data[-1, 1] = data.data[-1] + dx[-1]
elif location == 1:
hdx = 0.5 * dx
new_data[1:, 0] = data.data[1:] - hdx
new_data[:-1, 1] = data.data[:-1] + hdx
if self._mod_end:
new_data[0, 0] = data.data[0] - hdx[0]
new_data[-1, 1] = data.data[-1] + hdx[-1]
elif location == 2:
new_data[1:, 0] = data.data[1:] - dx
if self._mod_end:
new_data[0, 0] = data.data[0] - dx[0]
return new_data
else:
ddim = data.dimensions[0]
dslice = index[ddim] if ddim in index else slice(None)
islice = slice(None, None, dslice.step)
idata = self.keywords['idata'][islice]
ifc_len = len(data) + 1
ifc_data = empty(ifc_len, dtype=data.dtype)
if len(idata) == ifc_len:
ifc_data[:] = idata.data[:]
elif len(idata) == ifc_len - 2:
ifc_data[1:-1] = idata.data[:]
if location == 0:
ifc_data[0] = data.data[0]
ifc_data[-1] = 2 * data.data[-1] - data.data[-2]
elif location == 1:
ifc_data[0] = 2 * data.data[0] - idata.data[0]
ifc_data[-1] = 2 * data.data[-1] - idata.data[-1]
else:
ifc_data[0] = 2 * data.data[0] - data.data[1]
ifc_data[-1] = data.data[-1]
else:
raise ValueError(
'bounds: interface-data length is {} but should be {} or '
'{}'.format(len(idata), ifc_len, ifc_len - 2))
new_data[:, 0] = ifc_data[:-1]
new_data[:, 1] = ifc_data[1:]
return new_data
def test_func_rmunits(self):
key = 'rmunits'
indata = PhysArray(2.5, name='x', units='m')
testname = '{}({})'.format(key, indata)
func = functions.find(key)
actual = func(indata)[:]
expected = PhysArray(2.5, name='rmunits(x)')
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertPhysArraysEqual(actual, expected, '{} failed'.format(testname))
def test_func_sqrt_physarray(self):
key = "sqrt"
indata = PhysArray([9.0, 16.0, 4.0], name="x", units="m^2")
testname = "{}({})".format(key, indata)
func = functions.find(key)
actual = func(indata)[:]
expected = PhysArray([3.0, 4.0, 2.0], name="sqrt(x)", units="m")
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertPhysArraysEqual(actual, expected, "{} failed".format(testname))
def test_func_sqrt_physarray(self):
key = 'sqrt'
indata = PhysArray([9.0, 16.0, 4.0], name='x', units='m^2')
testname = '{}({})'.format(key, indata)
func = functions.find(key)
actual = func(indata)[:]
expected = PhysArray([3.0, 4.0, 2.0], name='sqrt(x)', units='m')
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertPhysArraysEqual(actual, expected, '{} failed'.format(testname))
def test_func_rmunits(self):
key = "rmunits"
indata = PhysArray(2.5, name="x", units="m")
testname = "{}({})".format(key, indata)
func = functions.find(key)
actual = func(indata)[:]
expected = PhysArray(2.5, name="rmunits(x)")
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertPhysArraysEqual(actual, expected, "{} failed".format(testname))
def test_op_neg_physarray(self):
key = "-"
indata = PhysArray(3, units="m")
testname = "({}{})".format(key, indata)
funcref = functions.find(key, 1)
func = funcref(indata)
actual = func[:]
expected = PhysArray(-3, name="3", units="m")
print_test_message(testname, input=indata, actual=actual, expected=expected)
np.testing.assert_array_equal(actual, expected, "{} failed".format(testname))
def test_func_chdims_long(self):
key = 'chdims'
indata = PhysArray([[1, 2], [3, 4]], name='x', dimensions=('a', 'b'))
inargs = ['A', 'B', 'C']
testname = "{}({}, 'A', 'B', 'C)".format(key, indata)
func = functions.find(key)
actual = func(indata, *inargs)[:]
expected = PhysArray([[1, 2], [3, 4]], name="chdims(x, 'A', 'B', 'C')", dimensions=('A', 'B'))
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertPhysArraysEqual(actual, expected, '{} failed'.format(testname))
def test_convert(self):
xdata = numpy.array(2., dtype='d')
X = PhysArray(xdata, name='X', units='km')
indata = 'm'
testname = 'X.convert({})'.format(indata)
actual = X.convert(Unit(indata))
new_name = "convert({}, from={}, to={})".format(
X.name, X.units, indata)
expected = PhysArray(2000., name=new_name, units=indata)
print_test_message(testname, actual=actual, expected=expected, X=X)
self.assertPhysArraysEqual(actual, expected, testname=testname)
def test_convert(self):
xdata = numpy.array(2.0, dtype="d")
X = PhysArray(xdata, name="X", units="km")
indata = "m"
testname = "X.convert({})".format(indata)
actual = X.convert(Unit(indata))
new_name = "convert({}, from={}, to={})".format(
X.name, X.units, indata)
expected = PhysArray(2000.0, name=new_name, units=indata)
print_test_message(testname, actual=actual, expected=expected, X=X)
self.assertPhysArraysEqual(actual, expected, testname=testname)
def test_func_chdims_long(self):
key = "chdims"
indata = PhysArray([[1, 2], [3, 4]], name="x", dimensions=("a", "b"))
inargs = ["A", "B", "C"]
testname = "{}({}, 'A', 'B', 'C)".format(key, indata)
func = functions.find(key)
actual = func(indata, *inargs)[:]
expected = PhysArray(
[[1, 2], [3, 4]], name="chdims(x, 'A', 'B', 'C')", dimensions=("A", "B")
)
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertPhysArraysEqual(actual, expected, "{} failed".format(testname))
def test_op_neg_physarray(self):
key = '-'
indata = PhysArray(3, units='m')
testname = '({}{})'.format(key, indata)
funcref = functions.find(key, 1)
func = funcref(indata)
actual = func[:]
expected = PhysArray(-3, name='3', units='m')
print_test_message(testname, input=indata,
actual=actual, expected=expected)
np.testing.assert_array_equal(
actual, expected, '{} failed'.format(testname))
def test_pow(self):
expvals = {
(1, 14): PhysArray(1.0, name='(X**2)'),
(15, 14): PhysArray(9.0, name='(X**2)'),
(8, 14): PhysArray([1., 4., 9.], name='(X**2)',
dimensions=('x', )),
(8, 8): DimensionsError,
(8, 4): UnitsError,
(2, 14): PhysArray(1., name='(X**2)'),
(2, 15): PhysArray(1., name='(X**Y)', positive='up')
}
self._test_binary_operator_(operator.pow, expvals, 'X ** Y')
self._test_binary_operator_(operator.ipow, expvals, 'X **= Y')
def test_transpose_dims(self):
xdata = numpy.array([[1.0, 2.0], [3.0, 4.0]], dtype="d")
X = PhysArray(xdata, name="X", units="m", dimensions=("u", "v"))
indata = ("v", "u")
testname = "X.transpose({}, {})".format(*indata)
actual = X.transpose(*indata)
new_name = "transpose({}, from=[u,v], to=[v,u])".format(X.name)
expected = PhysArray([[1.0, 3.0], [2.0, 4.0]],
units=X.units,
name=new_name,
dimensions=indata)
print_test_message(testname, actual=actual, expected=expected, X=X)
self.assertPhysArraysEqual(actual, expected, testname=testname)
def test_transpose_dims(self):
xdata = numpy.array([[1., 2.], [3., 4.]], dtype='d')
X = PhysArray(xdata, name='X', units='m', dimensions=('u', 'v'))
indata = ('v', 'u')
testname = 'X.transpose({}, {})'.format(*indata)
actual = X.transpose(*indata)
new_name = "transpose({}, from=[u,v], to=[v,u])".format(X.name, indata)
expected = PhysArray([[1., 3.], [2., 4.]],
units=X.units,
name=new_name,
dimensions=indata)
print_test_message(testname, actual=actual, expected=expected, X=X)
self.assertPhysArraysEqual(actual, expected, testname=testname)
def test_init(self):
inp = [(1, {}), (1.3, {}), ((1, 2, 3), {}), ([1, 2, 3], {}),
(numpy.array([1, 2, 3], dtype=numpy.float64), {}),
(PhysArray([1, 2, 3]), {}), ('asfeasefa', {}),
(['asfeasefa', 'asfe', 'e'], {})]
exp = [
PhysArray(1),
PhysArray(1.3),
PhysArray((1, 2, 3)),
PhysArray([1, 2, 3]),
PhysArray(numpy.array([1, 2, 3], dtype=numpy.float64)),
PhysArray([1, 2, 3]),
CharArray('asfeasefa'),
CharArray(['asfeasefa', 'asfe', 'e'])
]
for (arg, kwds), expected in zip(inp, exp):
argstr = repr(arg)
kwdstr = ', '.join('{}={!r}'.format(k, kwds[k]) for k in kwds)
initstr = argstr + (', {}'.format(kwdstr) if len(kwds) > 0 else '')
testname = 'PhysArray.__init__({})'.format(initstr)
actual = PhysArray(arg, **kwds)
print_test_message(testname,
parameter=arg,
keywords=kwds,
actual=actual,
expected=expected)
self.assertPhysArraysEqual(actual, expected, testname)
def test_init(self):
inp = [
(1, {}),
(1.3, {}),
((1, 2, 3), {}),
([1, 2, 3], {}),
(numpy.array([1, 2, 3], dtype=numpy.float64), {}),
(PhysArray([1, 2, 3]), {}),
("asfeasefa", {}),
(["asfeasefa", "asfe", "e"], {}),
]
exp = [
PhysArray(1),
PhysArray(1.3),
PhysArray((1, 2, 3)),
PhysArray([1, 2, 3]),
PhysArray(numpy.array([1, 2, 3], dtype=numpy.float64)),
PhysArray([1, 2, 3]),
CharArray("asfeasefa"),
CharArray(["asfeasefa", "asfe", "e"]),
]
for (arg, kwds), expected in zip(inp, exp):
argstr = repr(arg)
kwdstr = ", ".join("{}={!r}".format(k, kwds[k]) for k in kwds)
initstr = argstr + (", {}".format(kwdstr) if len(kwds) > 0 else "")
testname = "PhysArray.__init__({})".format(initstr)
actual = PhysArray(arg, **kwds)
print_test_message(testname,
parameter=arg,
keywords=kwds,
actual=actual,
expected=expected)
self.assertPhysArraysEqual(actual, expected, testname)
def test_pow(self):
expvals = {
(1, 14): PhysArray(1.0, name="(X**2)"),
(15, 14): PhysArray(9.0, name="(X**2)"),
(8, 14): PhysArray([1.0, 4.0, 9.0],
name="(X**2)",
dimensions=("x", )),
(8, 8): DimensionsError,
(8, 4): UnitsError,
(2, 14): PhysArray(1.0, name="(X**2)"),
(2, 15): PhysArray(1.0, name="(X**Y)", positive="up"),
}
self._test_binary_operator_(operator.pow, expvals, "X ** Y")
self._test_binary_operator_(operator.ipow, expvals, "X **= Y")
def test_func_down_physarray_up(self):
key = 'down'
indata = PhysArray(2.5, name='x', positive='up')
testname = '{}({})'.format(key, indata)
func = functions.find(key)
actual = func(indata)[:]
expected = PhysArray(-2.5, name='down(x)', positive='down')
print_test_message(testname, indata=indata,
actual=actual, expected=expected)
np.testing.assert_array_equal(
actual, expected, '{} failed - data'.format(testname))
self.assertEqual(actual.name, expected.name,
'{} failed - name'.format(testname))
self.assertEqual(actual.positive, expected.positive,
'{} failed - positive'.format(testname))
def test_op_pow_physarray(self):
key = '**'
x = PhysArray(4.3, name='x', units='m')
y = PhysArray(2, name='y')
testname = '({} {} {})'.format(x, key, y)
func = functions.find(key, 2)
actual = func(x, y)[:]
expected = PhysArray(4.3 ** 2, name='(x**y)', units=Unit('m') ** 2)
print_test_message(testname, actual=actual,
expected=expected, x=x, y=y)
self.assertEqual(actual, expected, '{} failed - data'.format(testname))
self.assertEqual(actual.name, expected.name,
'{} failed - name'.format(testname))
self.assertEqual(actual.units, expected.units,
'{} failed - units'.format(testname))
