def test_write_reference_datetime(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return for reference_datetime in ('1751-2-3', '1492-12-30'): for chunksize in self.chunk_sizes: cf.chunksize(chunksize) f = cf.read(self.filename)[0] t = cf.DimensionCoordinate( data=cf.Data([123], 'days since 1750-1-1') ) t.standard_name = 'time' axisT = f.set_construct(cf.DomainAxis(1)) f.set_construct(t, axes=[axisT]) cf.write(f, tmpfile, fmt='NETCDF4', reference_datetime=reference_datetime) g = cf.read(tmpfile)[0] t = g.dimension_coordinate('T') self.assertEqual( t.Units, cf.Units('days since ' + reference_datetime), ('Units written were ' + repr(t.Units.reftime) + ' not ' + repr(reference_datetime))) # --- End: for cf.chunksize(self.original_chunksize)
def test_read_write_string(self): f = cf.read(self.string_filename) n = int(len(f) / 2) for i in range(n): j = i + n self.assertTrue( f[i].data.equals(f[j].data, verbose=1), "{!r} {!r}".format(f[i], f[j]), ) self.assertTrue( f[j].data.equals(f[i].data, verbose=1), "{!r} {!r}".format(f[j], f[i]), ) # Note: Don't loop round all netCDF formats for better # performance. Just one netCDF3 and one netCDF4 format # is sufficient to test the functionality for string0 in (True, False): for fmt0 in ("NETCDF4", "NETCDF3_CLASSIC"): cf.write(f, tmpfile0, fmt=fmt0, string=string0) for string1 in (True, False): for fmt1 in ("NETCDF4", "NETCDF3_CLASSIC"): cf.write(f, tmpfile1, fmt=fmt1, string=string1) for i, j in zip(cf.read(tmpfile1), cf.read(tmpfile0)): self.assertTrue(i.equals(j, verbose=1))
def test_PP_WGDOS_UNPACKING(self): f = cf.read(self.ppfilename)[0] self.assertTrue(f.minimum() > 221.71, 'Bad unpacking of WGDOS packed data') self.assertTrue(f.maximum() < 310.45, 'Bad unpacking of WGDOS packed data') array = f.array for chunksize in self.chunk_sizes: cf.chunksize(chunksize) f = cf.read(self.ppfilename)[0] for fmt in ('NETCDF4', 'CFA4'): # print (fmt) # f.dump() # print (repr(f.dtype)) # print (f._FillValue) # print (type(f._FillValue)) # f._FillValue = numpy.array(f._FillValue , dtype='float32') cf.write(f, tmpfile, fmt=fmt) g = cf.read(tmpfile)[0] self.assertTrue((f.array == array).all(), 'Bad unpacking of PP WGDOS packed data') self.assertTrue(f.equals(g, verbose=2), 'Bad writing/reading. fmt='+fmt) cf.chunksize(self.original_chunksize)
def create_empty_array(datapathea, count_time, divt, latitude, longitude, yearpart, years): Sa_track_down_last = np.zeros((1, len(latitude), len(longitude))) Sa_track_down_day = np.zeros((1, len(latitude), len(longitude))) Sa_track_top_last = np.zeros((1, len(latitude), len(longitude))) Sa_track_top_day = np.zeros((1, len(latitude), len(longitude))) # Sa_time_down_last = np.zeros((1, len(latitude), len(longitude))) Sa_time_down_day = np.zeros((1, len(latitude), len(longitude))) Sa_time_top_last = np.zeros((1, len(latitude), len(longitude))) Sa_time_top_day = np.zeros((1, len(latitude), len(longitude))) # Sa_dist_down_last = np.zeros((1, len(latitude), len(longitude))) Sa_dist_down_day = np.zeros((1, len(latitude), len(longitude))) Sa_dist_top_last = np.zeros((1, len(latitude), len(longitude))) Sa_dist_top_day = np.zeros((1, len(latitude), len(longitude))) # Build cf.field here. if yearpart[0] == 365: year_o = years[0] + 1 yearpart_o = 0 else: year_o = years[0] yearpart_o = yearpart[0] + 1 f0l = wrap_netcdf(year_o, yearpart_o, Sa_track_down_last, 'Sa_track_down_last', 'm3') f0d = wrap_netcdf(year_o, yearpart_o, Sa_track_down_day, 'Sa_track_down', 'm3') f1l = wrap_netcdf(year_o, yearpart_o, Sa_track_top_last, 'Sa_track_top_last', 'm3') f1d = wrap_netcdf(year_o, yearpart_o, Sa_track_top_day, 'Sa_track_top', 'm3') # f2l = wrap_netcdf(year_o, yearpart_o, Sa_time_down_last, 'Sa_time_down_last', 's') f2d = wrap_netcdf(year_o, yearpart_o, Sa_time_down_day, 'Sa_time_down', 's') f3l = wrap_netcdf(year_o, yearpart_o, Sa_time_top_last, 'Sa_time_top_last', 's') f3d = wrap_netcdf(year_o, yearpart_o, Sa_time_top_day, 'Sa_time_top', 's') # f4l = wrap_netcdf(year_o, yearpart_o, Sa_dist_down_last, 'Sa_dist_down_last', 'm') f4d = wrap_netcdf(year_o, yearpart_o, Sa_dist_down_day, 'Sa_dist_down', 'm') f5l = wrap_netcdf(year_o, yearpart_o, Sa_dist_top_last, 'Sa_dist_top_last', 'm') f5d = wrap_netcdf(year_o, yearpart_o, Sa_dist_top_day, 'Sa_dist_top', 'm') # Write out netcdf if yearpart[0] == 365: datapathnc = datapathea[0] else: datapathnc = datapathea[1] f_list = cf.FieldList( [f0l, f0d, f1l, f1d, f2l, f2d, f3l, f3d, f4l, f4d, f5l, f5d]) cf.write(f_list, datapathnc, single=True, unlimited='time', compress=3) return
def save_datasets(self, datasets, filename, **kwargs): """Save all datasets to one or more files) """ fields = [] shapes = {} for dataset in datasets: if dataset.shape in shapes: domain = shapes[dataset.shape] else: lines, pixels = dataset.shape # Create a grid_latitude dimension coordinate line_coord = cf.DimensionCoordinate( data=cf.Data(np.arange(lines), '1')) pixel_coord = cf.DimensionCoordinate( data=cf.Data(np.arange(pixels), '1')) domain = cf.Domain(dim={ 'lines': line_coord, 'pixels': pixel_coord }, ) shapes[dataset.shape] = domain data = cf.Data(dataset, dataset.info['units']) properties = {'standard_name': dataset.info['standard_name']} fields.append( cf.Field(properties=properties, data=data, axes=['lines', 'pixels'], domain=domain)) cf.write(fields, filename, fmt='NETCDF4')
def test_DSG_indexed_contiguous(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return f = cf.read(self.indexed_contiguous, verbose=0) self.assertEqual(len(f), 2) # Select the specific humidity field q = f.select('specific_humidity')[0] qa = q.data.array for n in range(qa.shape[0]): for m in range(qa.shape[1]): self.assertTrue( q._equals(qa.mask[n, m], self.b.mask[n, m]), str(n) + ' ' + str(m) + ' ' + str(qa[n, m]) + ' ' + str(self.b[n, m])) message = repr(qa - self.b) # ... +'\n'+repr(qa[2,0])+'\n'+repr(self.b[2, 0]) self.assertTrue(q._equals(qa, self.b), message) cf.write(f, self.tempfilename, verbose=0) g = cf.read(self.tempfilename, verbose=0) self.assertEqual(len(g), len(f)) for i in range(len(f)): self.assertTrue(g[i].equals(f[i], verbose=2))
def test_geometry_3(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return f = cf.read(self.geometry_3_file, verbose=0) self.assertEqual(len(f), 2, 'f = ' + repr(f)) for g in f: self.assertTrue(g.equals(g.copy(), verbose=2)) self.assertEqual(len(g.auxiliary_coordinates), 3) g = f[0] for axis in ('X', 'Y', 'Z'): coord = g.construct('axis=' + axis) self.assertFalse(coord.has_node_count(), 'axis=' + axis) self.assertFalse(coord.has_part_node_count(), 'axis=' + axis) self.assertFalse(coord.has_interior_ring(), 'axis=' + axis) cf.write(f, self.tempfilename, Conventions='CF-' + VN, verbose=0) f2 = cf.read(self.tempfilename, verbose=0) self.assertEqual(len(f2), 2, 'f2 = ' + repr(f2)) for a, b in zip(f, f2): self.assertTrue(a.equals(b, verbose=2))
def test_DSG_indexed(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return f = cf.read(self.indexed) self.assertEqual(len(f), 2) # Select the specific humidity field q = [g for g in f if g.get_property('standard_name') == 'specific_humidity'][0] self.assertTrue(q._equals(q.data.array.mask, self.a.mask)) self.assertTrue( q._equals(q.data.array, self.a), '\nself.a=\n' + str(self.a) + '\nq.array=\n' + str(q.array) ) cf.write(f, tmpfile, verbose=0) g = cf.read(tmpfile) self.assertEqual(len(g), len(f)) for i in range(len(f)): self.assertTrue(g[i].equals(f[i], verbose=2))
def test_read_write_string(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return f = cf.read(self.string_filename) n = int(len(f) / 2) for i in range(0, n): j = i + n self.assertTrue( f[i].data.equals(f[j].data, verbose=1), "{!r} {!r}".format(f[i], f[j]), ) self.assertTrue( f[j].data.equals(f[i].data, verbose=1), "{!r} {!r}".format(f[j], f[i]), ) f0 = cf.read(self.string_filename) for string0 in (True, False): for fmt0 in ("NETCDF4", "NETCDF3_CLASSIC"): cf.write(f0, tmpfile0, fmt=fmt0, string=string0) for string1 in (True, False): for fmt1 in ("NETCDF4", "NETCDF3_CLASSIC"): cf.write(f0, tmpfile1, fmt=fmt1, string=string1) for i, j in zip(cf.read(tmpfile1), cf.read(tmpfile0)): self.assertTrue(i.equals(j, verbose=1))
def test_DSG_indexed(self): f = cf.read(self.indexed) self.assertEqual(len(f), 2) # Select the specific humidity field q = [ g for g in f if g.get_property("standard_name") == "specific_humidity" ][0] self.assertTrue(q._equals(q.data.array.mask, self.a.mask)) self.assertTrue( q._equals(q.data.array, self.a), "\nself.a=\n" + str(self.a) + "\nq.array=\n" + str(q.array), ) cf.write(f, tmpfile, verbose=0) g = cf.read(tmpfile) self.assertEqual(len(g), len(f)) for i in range(len(f)): self.assertTrue(g[i].equals(f[i], verbose=2))
def test_DSG_indexed_contiguous(self): f = cf.read(self.indexed_contiguous, verbose=0) self.assertEqual(len(f), 2) # Select the specific humidity field q = f.select("specific_humidity")[0] qa = q.data.array for n in range(qa.shape[0]): for m in range(qa.shape[1]): self.assertTrue( q._equals(qa.mask[n, m], self.b.mask[n, m]), str(n) + " " + str(m) + " " + str(qa[n, m]) + " " + str(self.b[n, m]), ) message = repr(qa - self.b) # ... +'\n'+repr(qa[2,0])+'\n'+repr(self.b[2, 0]) self.assertTrue(q._equals(qa, self.b), message) cf.write(f, tmpfile, verbose=0) g = cf.read(tmpfile, verbose=0) self.assertEqual(len(g), len(f)) for i in range(len(f)): self.assertTrue(g[i].equals(f[i], verbose=2))
def test_write_reference_datetime(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return for reference_datetime in ("1751-2-3", "1492-12-30"): for chunksize in self.chunk_sizes: cf.chunksize(chunksize) f = cf.read(self.filename)[0] t = cf.DimensionCoordinate( data=cf.Data([123], "days since 1750-1-1")) t.standard_name = "time" axisT = f.set_construct(cf.DomainAxis(1)) f.set_construct(t, axes=[axisT]) cf.write( f, tmpfile, fmt="NETCDF4", reference_datetime=reference_datetime, ) g = cf.read(tmpfile)[0] t = g.dimension_coordinate("T") self.assertEqual( t.Units, cf.Units("days since " + reference_datetime), ("Units written were " + repr(t.Units.reftime) + " not " + repr(reference_datetime)), ) # --- End: for cf.chunksize(self.original_chunksize)
def test_read_write_netCDF4_compress_shuffle(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return tmpfiles.append(tmpfile) for chunksize in self.chunk_sizes: cf.chunksize(chunksize) f = cf.read(self.filename)[0] for fmt in ("NETCDF4", "NETCDF4_CLASSIC", "CFA4"): for shuffle in (True, ): for compress in (1, ): # range(10): cf.write( f, tmpfile, fmt=fmt, compress=compress, shuffle=shuffle, ) g = cf.read(tmpfile)[0] self.assertTrue( f.equals(g, verbose=2), "Bad read/write with lossless compression: " "{0}, {1}, {2}".format(fmt, compress, shuffle), ) # --- End: for cf.chunksize(self.original_chunksize)
def test_read_write_format(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return for chunksize in self.chunk_sizes: cf.chunksize(chunksize) for fmt in ( "NETCDF3_CLASSIC", "NETCDF3_64BIT", "NETCDF3_64BIT_OFFSET", "NETCDF3_64BIT_DATA", "NETCDF4", "NETCDF4_CLASSIC", "CFA", ): # print (fmt, string) f = cf.read(self.filename)[0] f0 = f.copy() cf.write(f, tmpfile, fmt=fmt) g = cf.read(tmpfile, verbose=0) self.assertEqual(len(g), 1, "g = " + repr(g)) g0 = g[0] self.assertTrue( f0.equals(g0, verbose=1), "Bad read/write of format {!r}".format(fmt), )
def test_read_mask(self): f = self.f0.copy() N = f.size f.data[1, 1] = cf.masked f.data[2, 2] = cf.masked f.del_property("_FillValue", None) f.del_property("missing_value", None) cf.write(f, tmpfile) g = cf.read(tmpfile)[0] self.assertEqual(numpy.ma.count(g.data.array), N - 2) g = cf.read(tmpfile, mask=False)[0] self.assertEqual(numpy.ma.count(g.data.array), N) g.apply_masking(inplace=True) self.assertEqual(numpy.ma.count(g.data.array), N - 2) f.set_property("_FillValue", 999) f.set_property("missing_value", -111) cf.write(f, tmpfile) g = cf.read(tmpfile)[0] self.assertEqual(numpy.ma.count(g.data.array), N - 2) g = cf.read(tmpfile, mask=False)[0] self.assertEqual(numpy.ma.count(g.data.array), N) g.apply_masking(inplace=True) self.assertEqual(numpy.ma.count(g.data.array), N - 2)
def test_write_coordinates(self): f = cf.example_field(0) cf.write(f, tmpfile, coordinates=True) g = cf.read(tmpfile) self.assertEqual(len(g), 1) self.assertTrue(g[0].equals(f))
def test_groups_compression(self): f = cf.example_field(4) ungrouped_file = ungrouped_file3 grouped_file = grouped_file3 f.compress('indexed_contiguous', inplace=True) f.data.get_count().nc_set_variable('count') f.data.get_index().nc_set_variable('index') cf.write(f, ungrouped_file, verbose=1) g = cf.read(ungrouped_file)[0] self.assertTrue(f.equals(g, verbose=2)) # ------------------------------------------------------------ # Move the field construct to the /forecast/model group # ------------------------------------------------------------ g.nc_set_variable_groups(['forecast', 'model']) # ------------------------------------------------------------ # Move the count variable to the /forecast group # ------------------------------------------------------------ g.data.get_count().nc_set_variable_groups(['forecast']) # ------------------------------------------------------------ # Move the index variable to the /forecast group # ------------------------------------------------------------ g.data.get_index().nc_set_variable_groups(['forecast']) # ------------------------------------------------------------ # Move the coordinates that span the element dimension to the # /forecast group # ------------------------------------------------------------ name = 'altitude' g.construct(name).nc_set_variable_groups(['forecast']) # ------------------------------------------------------------ # Move the sample dimension to the /forecast group # ------------------------------------------------------------ g.data.get_count().nc_set_sample_dimension_groups(['forecast']) cf.write(g, grouped_file, verbose=1) nc = netCDF4.Dataset(grouped_file, 'r') self.assertIn(f.nc_get_variable(), nc.groups['forecast'].groups['model'].variables) self.assertIn(f.data.get_count().nc_get_variable(), nc.groups['forecast'].variables) self.assertIn(f.data.get_index().nc_get_variable(), nc.groups['forecast'].variables) self.assertIn( f.construct('altitude').nc_get_variable(), nc.groups['forecast'].variables) nc.close() h = cf.read(grouped_file, verbose=1) self.assertEqual(len(h), 1, repr(h)) self.assertTrue(f.equals(h[0], verbose=2))
def save(v, fname, compress=5, **kwds): """save to file :param cf.Field v: cf.Field to save :param str fname: filename :param int compress: 0-9 """ cf.write(v, fname, compress=compress, **kwds)
def test_write_filename(self): f = self.f0 a = f.array cf.write(f, tmpfile) g = cf.read(tmpfile) with self.assertRaises(Exception): cf.write(g, tmpfile) self.assertTrue((a == g[0].array).all())
def test_write_datatype(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return tmpfiles.append(tmpfile) for chunksize in self.chunk_sizes: cf.chunksize(chunksize) f = cf.read(self.filename)[0] self.assertEqual(f.dtype, numpy.dtype(float)) cf.write( f, tmpfile, fmt="NETCDF4", datatype={numpy.dtype(float): numpy.dtype("float32")}, ) g = cf.read(tmpfile)[0] self.assertEqual( g.dtype, numpy.dtype("float32"), "datatype read in is " + str(g.dtype), ) cf.chunksize(self.original_chunksize) # Keyword single f = cf.read(self.filename)[0] self.assertEqual(f.dtype, numpy.dtype(float)) cf.write(f, tmpfile, fmt="NETCDF4", single=True) g = cf.read(tmpfile)[0] self.assertEqual( g.dtype, numpy.dtype("float32"), "datatype read in is " + str(g.dtype), ) tmpfiles.append(tmpfile2) # Keyword double f = g self.assertEqual(f.dtype, numpy.dtype("float32")) cf.write(f, tmpfile2, fmt="NETCDF4", double=True) g = cf.read(tmpfile2)[0] self.assertEqual(g.dtype, numpy.dtype(float), "datatype read in is " + str(g.dtype)) for single in (True, False): for double in (True, False): with self.assertRaises(Exception): _ = cf.write(g, double=double, single=single) # --- End: for datatype = {numpy.dtype(float): numpy.dtype("float32")} with self.assertRaises(Exception): _ = cf.write(g, datatype=datatype, single=True) with self.assertRaises(Exception): _ = cf.write(g, datatype=datatype, double=True)
def test_write_reference_datetime(self): for reference_datetime in ("1751-2-3", "1492-12-30"): cf.write(self.f0, tmpfile, reference_datetime=reference_datetime) g = cf.read(tmpfile)[0] t = g.dimension_coordinate("T") self.assertEqual( t.Units, cf.Units("days since " + reference_datetime), f"Units written were {t.Units.reftime!r} not " f"{reference_datetime!r}", )
def test_geometry_4(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return f = cf.read(self.geometry_4_file, verbose=0) self.assertEqual(len(f), 2, 'f = ' + repr(f)) for g in f: self.assertTrue(g.equals(g.copy(), verbose=2)) self.assertEqual(len(g.auxiliary_coordinates), 3) for axis in ('X', 'Y'): coord = g.construct('axis=' + axis) self.assertTrue(coord.has_node_count(), 'axis=' + axis) self.assertFalse(coord.has_part_node_count(), 'axis=' + axis) self.assertFalse(coord.has_interior_ring(), 'axis=' + axis) cf.write(f, self.tempfilename, Conventions='CF-' + VN, verbose=0) f2 = cf.read(self.tempfilename, verbose=0) self.assertEqual(len(f2), 2, 'f2 = ' + repr(f2)) for a, b in zip(f, f2): self.assertTrue(a.equals(b, verbose=2)) # Setting of node count properties coord = f[0].construct('axis=X') nc = coord.get_node_count() cf.write(f, self.tempfilename) nc.set_property('long_name', 'Node counts') cf.write(f, self.tempfilename, verbose=0) nc.nc_set_variable('new_var_name') cf.write(f, self.tempfilename, verbose=0)
def test_GATHERING(self): f = self.f.copy() self.assertEqual(len(f), 3) g = f.select("long_name=temp3")[0] cf.write(f, tmpfile, verbose=0) g = cf.read(tmpfile, verbose=0) self.assertEqual(len(g), len(f), str(len(g)) + " " + str(len(f))) for a, b in zip(f, g): self.assertTrue(b.equals(a, verbose=2))
def test_EXTERNAL_WRITE(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return parent = cf.read(self.parent_file) combined = cf.read(self.combined_file) # External file contains only the cell measure variable f = cf.read(self.parent_file, external=self.external_file) cf.write(f, self.tempfilename) g = cf.read(self.tempfilename) self.assertEqual(len(g), len(combined)) for i in range(len(g)): self.assertTrue(combined[i].equals(g[i], verbose=2)) cell_measure = g[0].constructs("measure:area").value() self.assertFalse(cell_measure.nc_get_external()) cell_measure.nc_set_external(True) self.assertTrue(cell_measure.nc_get_external()) self.assertTrue(cell_measure.properties()) self.assertTrue(cell_measure.has_data()) self.assertTrue(g[0].constructs.filter_by_identity( "measure:area").value().nc_get_external()) cf.write( g, self.tempfilename_parent, external=self.tempfilename_external, verbose=0, ) h = cf.read(self.tempfilename_parent, verbose=0) self.assertEqual(len(h), len(parent)) for i in range(len(h)): self.assertTrue(parent[i].equals(h[i], verbose=2)) h = cf.read(self.tempfilename_external) external = cf.read(self.external_file) self.assertEqual(len(h), len(external)) for i in range(len(h)): self.assertTrue(external[i].equals(h[i], verbose=2))
def test_geometry_2(self): f = cf.read(self.geometry_2_file, verbose=0) self.assertEqual(len(f), 2, "f = " + repr(f)) for g in f: self.assertTrue(g.equals(g.copy(), verbose=2)) self.assertEqual(len(g.auxiliary_coordinates()), 3) g = f[0] for axis in ("X", "Y", "Z"): coord = g.construct("axis=" + axis) self.assertTrue(coord.has_node_count(), "axis=" + axis) self.assertFalse(coord.has_part_node_count(), "axis=" + axis) self.assertFalse(coord.has_interior_ring(), "axis=" + axis) cf.write(f, self.tempfilename, Conventions="CF-" + VN, verbose=0) f2 = cf.read(self.tempfilename, verbose=0) self.assertEqual(len(f2), 2, "f2 = " + repr(f2)) for a, b in zip(f, f2): self.assertTrue(a.equals(b, verbose=2)) # Setting of node count properties coord = f[0].construct("axis=X") nc = coord.get_node_count() cf.write(f, self.tempfilename) nc.set_property("long_name", "Node counts") cf.write(f, self.tempfilename, verbose=0) nc.nc_set_variable("new_var_name") cf.write(f, self.tempfilename, verbose=0)
def test_write_filename(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return tmpfiles.append(tmpfile) f = cf.example_field(0) a = f.array cf.write(f, tmpfile) g = cf.read(tmpfile) with self.assertRaises(Exception): cf.write(g, tmpfile) self.assertTrue((a == g[0].array).all())
def test_GATHERING(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return f = cf.read(self.gathered, verbose=0) self.assertEqual(len(f), 3) g = f.select('long_name=temp3')[0] cf.write(f, self.tempfilename, verbose=0) g = cf.read(self.tempfilename, verbose=0) self.assertEqual(len(g), len(f), str(len(g)) + ' ' + str(len(f))) for a, b in zip(f, g): self.assertTrue(b.equals(a, verbose=2))
def test_GATHERING(self): if self.test_only and inspect.stack()[0][3] not in self.test_only: return f = self.f.copy() self.assertEqual(len(f), 3) g = f.select("long_name=temp3")[0] cf.write(f, tmpfile, verbose=0) g = cf.read(tmpfile, verbose=0) self.assertEqual(len(g), len(f), str(len(g)) + " " + str(len(f))) for a, b in zip(f, g): self.assertTrue(b.equals(a, verbose=2))
def test_read_write_format(self): cf.write(self.f1, tmpfile) for chunksize in self.chunk_sizes: with cf.chunksize(chunksize): for fmt in self.netcdf3_fmts + ["CFA"]: f = cf.read(tmpfile)[0] cf.write(f, tmpfile2, fmt=fmt) g = cf.read(tmpfile2, verbose=0) self.assertEqual(len(g), 1) g = g[0] self.assertTrue( f.equals(g, verbose=1), f"Bad read/write of format {fmt!r}", )
def test_read_write_netCDF4_compress_shuffle(self): for chunksize in self.chunk_sizes: with cf.chunksize(chunksize): f = cf.read(self.filename)[0] for fmt in ("NETCDF4", "NETCDF4_CLASSIC", "CFA4"): cf.write( f, tmpfile, fmt=fmt, compress=1, shuffle=True, ) g = cf.read(tmpfile)[0] self.assertTrue( f.equals(g, verbose=2), f"Bad read/write with lossless compression: {fmt}", )