def test_read_range_2d(self):
""" Test reading subset of data in 2d"""
data = einput.NetCdf(self.file).read_variable(
VAR_MULT_NAME, input_range=(0, DIM1_LEN - 2))
assert_array_equal(
data,
random_mult_data[:DIM1_LEN - 2, :],
)
data = einput.NetCdf(self.file).read_variable(
VAR_MULT_NAME, input_range=(None, None, 0, DIM1_LEN - 2))
assert_array_equal(data, random_mult_data[:, :DIM1_LEN - 2])
def setUp(self):
self.file = FILE_NAME
f = input.NetCdf(self.file, 'w')
f.add_dim(DIM1_NAME, DIM1_LEN)
f.add_dim(DIM2_NAME, DIM2_LEN)
f.write_variable(random_data, VAR_NAME, (DIM1_NAME, ), 'double')
f.write_variable(random_mult_data, VAR_MULT_NAME, (
DIM1_NAME,
DIM2_NAME,
), 'double')
f.add_attribute('units', VAR_UNITS, VAR_NAME)
f.add_attribute('units', VAR_MULT_UNITS, VAR_MULT_NAME)
# self.data_1d = egads.EgadsData(value=random_data, units=VAR_UNITS)
# self.data_2d = egads.EgadsData(value=random_mult_data, units=VAR_MULT_UNITS)
# f = netCDF4.Dataset(self.file, 'w')
# f.createDimension(DIM1_NAME, DIM1_LEN)
# f.createDimension(DIM2_NAME, DIM2_LEN)
# v1 = f.createVariable(VAR_NAME, 'f8', (DIM1_NAME))
# v2 = f.createVariable(VAR_MULT_NAME, 'f8', (DIM1_NAME, DIM2_NAME))
# v1.units = VAR_UNITS
# v2.units = VAR_MULT_UNITS
# v1[:] = random_data
# v2[:] = random_mult_data
pass
def test_load_data_1d(self):
"""test reading 1D netcdf data"""
data = input.NetCdf(self.file).read_variable(VAR_NAME)
self.assertEqual(len(data), DIM1_LEN, "Input dimensions don't match")
assert_array_equal(data, random_data)
def test_read_range_1d(self):
""" Test reading subset of data"""
data = einput.NetCdf(self.file).read_variable(
VAR_NAME, input_range=(0, DIM1_LEN - 2))
assert_array_equal(data, random_data[:DIM1_LEN - 2])
data = einput.NetCdf(self.file).read_variable(VAR_NAME,
input_range=(-1,
DIM1_LEN))
assert_array_equal(data, random_data[-1:DIM1_LEN])
data = einput.NetCdf(self.file).read_variable(VAR_NAME,
input_range=(None,
DIM1_LEN))
assert_array_equal(data, random_data[0:DIM1_LEN])
data = einput.NetCdf(self.file).read_variable(
VAR_NAME, input_range=(None, DIM1_LEN + 1))
assert_array_equal(data, random_data[0:DIM1_LEN])
def test_load_data_2d(self):
""" Test reading 2D netcdf data"""
data = einput.NetCdf(self.file).read_variable(VAR_MULT_NAME)
self.assertEqual(data.shape, (DIM1_LEN, DIM2_LEN),
"Input dimensions don't match")
assert_array_equal(data, random_mult_data)
def test_open_file(self):
""" Test opening of file using open method """
data = einput.NetCdf()
data.open(self.file)
self.assertEqual(data.filename, self.file, 'file opening failed')
self.assertEqual(data.get_perms(), 'r',
'file permissions do not match')
data.close()
data_write = einput.NetCdf()
data_write.open(self.file, 'w')
self.assertEqual(data_write.filename, self.file,
'file opening failed for write')
self.assertEqual(data_write.get_perms(), 'w',
'file permissions do not match')
data_write.close()
def test_read_attribute(self):
""" test reading attribute from file """
data = input.NetCdf(self.file)
self.assertEqual(data.get_attribute_value('units', VAR_NAME),
VAR_UNITS, 'Variable attributes do not match')
self.assertEqual(data.get_attribute_value('attribute'),
GLOBAL_ATTRIBUTE, 'Global attributes do not match')
def test_bad_attribute(self):
""" Test handling of bad attribute name"""
data = einput.NetCdf(self.file)
self.assertRaises(KeyError, data.get_attribute_value, 'bad_attr')
self.assertRaises(KeyError, data.get_attribute_value, 'bad_attr',
VAR_NAME)
data.close()
def test_read_dimensions(self):
""" test reading dimensions from file """
data = input.NetCdf(self.file)
dimdict = {DIM1_NAME: DIM1_LEN, DIM2_NAME: DIM2_LEN}
self.assertEqual(data.get_dimension_list(), dimdict,
'dimensions dictionary does not match')
vardimdict = {DIM1_NAME: DIM1_LEN}
self.assertEqual(data.get_dimension_list(VAR_NAME), vardimdict,
'variable dimensions do not match')
def test_convert_nc_to_na_netcdf(self):
""" Test conversion of NetCDF to NASA Ames, using the NetCdf class """
f = einput.NetCdf(self.ncfilename)
f.convert_to_nasa_ames(self.nafilename)
f.close()
g = einput.NasaAmes(self.nafilename)
self.assertEqual('John Doe ([email protected])',
g.file_metadata['Originator'],
'Originator values do not match')
self.assertEqual('computer', g.file_metadata['Source'],
'Source values do not match')
data = g.read_variable('data')
self.assertListEqual(self.data1.value.tolist(), data.value.tolist(),
'data and data1 values do not match')
g.close()
def setUp(self):
self.data1 = egads.EgadsData(value=[0.5, 2.3, 6.2, 8.1, 4.],
units='mm',
long_name='a common data',
scale_factor=1.,
_FillValue=-999)
self.data2 = egads.EgadsData(value=[0., 1., 2., 3., 4.],
units='days since 20170101 00:00:00Z',
long_name='a common time vector',
scale_factor=1.,
_FillValue=-999)
self.file = FILE_NAME_ALT
f = einput.NetCdf(self.file, 'w')
f.add_dim(DIM1_NAME, DIM1_LEN)
f.add_dim(DIM2_NAME, DIM2_LEN)
f.write_variable(random_data, VAR_NAME, (DIM1_NAME, ), 'double')
f.write_variable(random_mult_data, VAR_MULT_NAME, (
DIM1_NAME,
DIM2_NAME,
), 'double')
f.add_attribute('units', VAR_UNITS, VAR_NAME)
f.add_attribute('units', VAR_MULT_UNITS, VAR_MULT_NAME)
f.close()
def test_convert_nc_to_csv_netcdf(self):
""" Test conversion of NetCDF to Nasa/Ames CSV, using the NetCdf class """
f = einput.NetCdf(self.ncfilename)
f.convert_to_csv(self.csvfilename)
f.close()
g = einput.EgadsCsv()
g.open(self.csvfilename, 'r')
lines = g.read()
author = lines[1][0]
computer = lines[3][0]
raw = lines[-5:]
time = []
data = []
for i in raw:
time.append(float(i[0]))
data.append(float(i[1]))
self.assertEqual('John Doe ([email protected])', author,
'Originator values do not match')
self.assertEqual('computer', computer, 'Source values do not match')
self.assertListEqual(self.data1.value.tolist(), data,
'data and data1 values do not match')
self.assertListEqual(self.data2.value.tolist(), time,
'time and data2 values do not match')
def test_bad_variable(self):
""" test handling of missing variable name"""
data = input.NetCdf(self.file)
self.assertRaises(KeyError, data.read_variable, 'blah')
