def test_template_statistics(self):
"""ensure that statistics fns work on template creation"""
v = np.ones(self.test_data.shape)
y = q.DiurnalLocalTimeStatistics(v, self.time_axis, self.timestep,
self.lons)
x = q.DiurnalLocalTimeStatistics(self.test_data, template=y)
x.load_day(3)
# mean
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).mean()
self.assertEqual(first_point, x.mean()[0])
first_point = self.test_data[0, 12:16].mean()
self.assertEqual(first_point, x.mean()[0])
# max
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).max()
self.assertEqual(first_point, x.max()[0])
first_point = self.test_data[0, 12:16].max()
self.assertEqual(first_point, x.max()[0])
# min
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).min()
self.assertEqual(first_point, x.min()[0])
first_point = self.test_data[0, 12:16].min()
self.assertEqual(first_point, x.min()[0])
def test_ref_val(self):
"""checks that we pick the correct reference value for all lon points."""
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
lsf = q.LongitudeSamplingFunction(24 * u.hour / self.timestep,
13 * u.hour)
i_lons = lsf.get_index(self.lons) + 4
result = np.empty((len(i_lons), ))
for i in range(len(i_lons)):
result[i] = self.test_data[i, i_lons[i]]
self.assertTrue(np.all(result == x.ref_val()))
# now switch test data so that there's more land points than time points
# and the axes are reversed
self.test_data = np.arange(100 * 16).reshape(16, 100)
self.time_axis = 0
self.lons = np.arange(100) * 2 * u.deg - 135 * u.deg
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
lsf = q.LongitudeSamplingFunction(24 * u.hour / self.timestep,
13 * u.hour)
i_lons = lsf.get_index(self.lons) + 4
result = np.empty((len(i_lons), ))
for i in range(len(i_lons)):
result[i] = self.test_data[i_lons[i], i]
self.assertTrue(np.all(result == x.ref_val()))
def test_template_create(self):
"""make sure we can create new instances from a template."""
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
v = np.ones(self.test_data.shape)
y = q.DiurnalLocalTimeStatistics(v, template=x)
self.assertEqual(self.time_axis, y.time_axis)
self.assertEqual(self.timestep, y.timestep)
self.assertTrue(np.all(self.lons == y.lons))
self.assertTrue(np.all(x.i_ref == y.i_ref))
self.assertTrue(np.all(x.mask == y.mask))
self.assertTrue(np.all(x.source == self.test_data))
self.assertTrue(np.all(y.source == v))
def test_nonsequential_stats(self):
"""checks that we can compute statistics after loading nonsequentially"""
x = q.DiurnalLocalTimeStatistics(self.test_data,
self.time_axis,
self.timestep,
self.lons,
sequential=False)
x.load_day(3)
# mean
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).mean()
self.assertEqual(first_point, x.mean()[0])
first_point = self.test_data[0, 12:16].mean()
self.assertEqual(first_point, x.mean()[0])
# max
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).max()
self.assertEqual(first_point, x.max()[0])
first_point = self.test_data[0, 12:16].max()
self.assertEqual(first_point, x.max()[0])
# min
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).min()
self.assertEqual(first_point, x.min()[0])
first_point = self.test_data[0, 12:16].min()
self.assertEqual(first_point, x.min()[0])
def test_forego_units(self):
"""make sure we can forego units if needed"""
x = q.DiurnalLocalTimeStatistics(self.test_data,
self.time_axis,
self.timestep,
self.lons,
unit=u.Pa)
self.assertEqual(x.get_utc_day().unit, u.Pa)
self.assertEqual(x.get_preceeding_day().unit, u.Pa)
self.assertEqual(x.get_buffer().unit, u.Pa)
x.load_day(3)
# mean
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).mean()
self.assertEqual(first_point, x.mean(unitted=False)[0])
first_point = self.test_data[0, 12:16].mean()
self.assertEqual(first_point, x.mean(unitted=False)[0])
# max
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).max()
self.assertEqual(first_point, x.max(unitted=False)[0])
first_point = self.test_data[0, 12:16].max()
self.assertEqual(first_point, x.max(unitted=False)[0])
# min
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).min()
self.assertEqual(first_point, x.min(unitted=False)[0])
first_point = self.test_data[0, 12:16].min()
self.assertEqual(first_point, x.min(unitted=False)[0])
def test_next(self):
"""test that next() advances to the next day"""
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
x.next()
self.assertEqual(x.cur_day, 3)
self.assertTrue(np.all(x.buffer[0, :] == self.test_data[0, 4:12]))
def test_max(self):
"""test the masked max function"""
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
first_point = ma.array(self.test_data[0, :8], mask=x.mask[0, :]).max()
self.assertEqual(first_point, x.max()[0])
first_point = self.test_data[0, 4:8].max()
self.assertEqual(first_point, x.max()[0])
def test_attributes(self):
"""test initialization of various attributes"""
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
self.assertEqual(x.diurnal_window, 4)
self.assertEqual(x.time_axis, self.time_axis)
self.assertEqual(x.timestep, self.timestep)
self.assertTrue(np.all(self.lons == x.lons))
self.assertTrue(np.all(x.buffer.shape == np.array((6, 8))))
def setUp(self):
# six points, four samples/day, 4 days
self.test_data = np.arange(96).reshape((6, 16))
self.time_axis = 1
self.timestep = 6 * u.hour
self.lons = np.arange(6) * 45 * u.deg - 135 * u.deg
self.dlts = q.DiurnalLocalTimeStatistics(self.test_data,
self.time_axis, self.timestep,
self.lons)
def test_unit(self):
"""make sure that returned data have correct units attached"""
x = q.DiurnalLocalTimeStatistics(self.test_data,
self.time_axis,
self.timestep,
self.lons,
unit=u.Pa)
self.assertEqual(x.get_utc_day().unit, u.Pa)
self.assertEqual(x.get_preceeding_day().unit, u.Pa)
self.assertEqual(x.get_buffer().unit, u.Pa)
# repeat for "no units" case
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
self.assertFalse(hasattr(x.get_utc_day(), "unit"))
self.assertFalse(hasattr(x.get_preceeding_day(), "unit"))
self.assertFalse(hasattr(x.get_buffer(), "unit"))
def test_nonsequential_load(self):
"""checks that loading days nonsequentially works OK"""
x = q.DiurnalLocalTimeStatistics(self.test_data,
self.time_axis,
self.timestep,
self.lons,
sequential=False)
self.assertEqual(None, x.cur_day)
self.assertEqual(None, x.buffer)
x.load_day(3)
self.assertTrue(np.all(x.buffer[0, :] == self.test_data[0, 8:16]))
x.load_day(1)
self.assertTrue(np.all(x.buffer[0, :] == self.test_data[0, :8]))
def test_preceeding_day(self):
"""tests to ensure the correct data is returned"""
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
lsf = q.LongitudeSamplingFunction(24 * u.hour / self.timestep,
13 * u.hour)
i_lons = lsf.get_index(self.lons)
result = np.empty((len(i_lons), 4))
for i in range(len(i_lons)):
result[i, :] = self.test_data[i, i_lons[i] + 1:i_lons[i] + 5]
self.assertTrue(np.all(result == x.get_preceeding_day()))
def test_mask(self):
"""test initialization of mask"""
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
lsf = q.LongitudeSamplingFunction(24 * u.hour / self.timestep,
13 * u.hour)
i_lons = lsf.get_index(self.lons)
afternoon = i_lons[0]
self.assertTrue(afternoon == 3)
mask_test = [
not ((i > afternoon) and (i <= afternoon + 4)) for i in range(8)
]
self.assertTrue(np.all(x.mask[0, :] == mask_test))
def register_variable(self, varname, unit):
"""adds "varname" to the list of variables to track"""
bufs = self.get_buffer_group()
forcing = self.get_forcing()
ncvar = forcing.variables[varname]
if not bufs.template_ready():
time_axis = ncvar.dimensions.index('tstep')
bufs.add(
varname,
q.DiurnalLocalTimeStatistics(ncvar,
time_axis,
self.get_timestep(),
self.get_longitudes(),
unit=unit))
else:
bufs.create(varname, ncvar, unit)
return bufs.get(varname)
def test_netcdf_source(self):
"""test to ensure we can use netcdf variable as source"""
d = nc.Dataset('test.nc', 'w', diskless=True)
d.createDimension('time', 16)
d.createDimension('land', 6)
v = d.createVariable('test',
self.test_data.dtype,
dimensions=('land', 'time'))
v[:] = self.test_data
x = q.DiurnalLocalTimeStatistics(v, self.time_axis, self.timestep,
self.lons)
x.load_day(3)
# mean
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).mean()
self.assertEqual(first_point, x.mean()[0])
first_point = self.test_data[0, 12:16].mean()
self.assertEqual(first_point, x.mean()[0])
# max
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).max()
self.assertEqual(first_point, x.max()[0])
first_point = self.test_data[0, 12:16].max()
self.assertEqual(first_point, x.max()[0])
# min
first_point = ma.array(self.test_data[0, 8:16],
mask=x.mask[0, :]).min()
self.assertEqual(first_point, x.min()[0])
first_point = self.test_data[0, 12:16].min()
self.assertEqual(first_point, x.min()[0])
def test_units_on_statistics(self):
"""make sure statistics functions return Quantities by default"""
x = q.DiurnalLocalTimeStatistics(self.test_data,
self.time_axis,
self.timestep,
self.lons,
sequential=False,
unit=u.Pa)
x.load_day(3)
# mean
mean = x.mean()
self.assertTrue(hasattr(mean, "unit"))
self.assertEqual(mean.unit, u.Pa)
# max
mx = x.max()
self.assertTrue(hasattr(mx, "unit"))
self.assertEqual(mx.unit, u.Pa)
# min
mn = x.min()
self.assertTrue(hasattr(mn, "unit"))
self.assertEqual(mn.unit, u.Pa)
def test_creation(self):
"""test creation and initialization of object"""
x = q.DiurnalLocalTimeStatistics(self.test_data, self.time_axis,
self.timestep, self.lons)
