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))