def test_CoordinateReference__repr__str__dump(self): f = self.f.copy() coordinate_conversion = cf.CoordinateConversion(parameters={ 'standard_name': 'atmosphere_hybrid_height_coordinate' }, domain_ancillaries={ 'a': 'aux0', 'b': 'aux1', 'orog': 'orog' }) datum = cf.Datum(parameters={'earth_radius': 23423423423.34}) # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference(coordinates=('coord1', ), coordinate_conversion=coordinate_conversion, datum=datum) _ = repr(t) _ = str(t) _ = t.dump(display=False) self.assertFalse(t.has_bounds()) _ = repr(datum) _ = str(datum) _ = repr(coordinate_conversion) _ = str(coordinate_conversion)
def test_CoordinateReference__repr__str__dump(self): coordinate_conversion = cf.CoordinateConversion( parameters={ "standard_name": "atmosphere_hybrid_height_coordinate" }, domain_ancillaries={ "a": "aux0", "b": "aux1", "orog": "orog" }, ) datum = cf.Datum(parameters={"earth_radius": 23423423423.34}) # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference( coordinates=("coord1", ), coordinate_conversion=coordinate_conversion, datum=datum, ) repr(t) str(t) t.dump(display=False) self.assertFalse(t.has_bounds()) repr(datum) str(datum) repr(coordinate_conversion) str(coordinate_conversion)
'units': 'm' }, data=cf.Data(numpy.arange(90.).reshape(10, 9))) domain_anc_A = tas.set_construct(domain_ancillary_a, axes=axis_Z) domain_anc_B = tas.set_construct(domain_ancillary_b, axes=axis_Z) domain_anc_OROG = tas.set_construct(domain_ancillary_orog) # Create the datum for the coordinate reference constructs datum = cf.Datum(parameters={'earth_radius': 6371007.}) # Create the coordinate conversion for the horizontal coordinate # reference construct coordinate_conversion_h = cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'rotated_latitude_longitude', 'grid_north_pole_latitude': 38.0, 'grid_north_pole_longitude': 190.0 }) # Create the coordinate conversion for the vertical coordinate # reference construct coordinate_conversion_v = cf.CoordinateConversion(parameters={ 'standard_name': 'atmosphere_hybrid_height_coordinate', 'computed_standard_name': 'altitude' }, domain_ancillaries={ 'a': domain_anc_A, 'b': domain_anc_B, 'orog': domain_anc_OROG
def test_CoordinateReference_equals(self): # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference( coordinates=("coord1", ), coordinate_conversion=cf.CoordinateConversion( parameters={ "standard_name": "atmosphere_hybrid_height_coordinate" }, domain_ancillaries={ "a": "aux0", "b": "aux1", "orog": "orog" }, ), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=["coord1", "fred", "coord3"], coordinate_conversion=cf.CoordinateConversion( parameters={ "grid_mapping_name": "rotated_latitude_longitude", "grid_north_pole_latitude": 38.0, "grid_north_pole_longitude": 190.0, }), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) datum = cf.Datum(parameters={"earth_radius": 6371007}) conversion = cf.CoordinateConversion( parameters={ "grid_mapping_name": "rotated_latitude_longitude", "grid_north_pole_latitude": 38.0, "grid_north_pole_longitude": 190.0, }) t = cf.CoordinateReference( coordinate_conversion=conversion, datum=datum, coordinates=["x", "y", "lat", "lon"], ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=["coord1", "fred", "coord3"], coordinate_conversion=cf.CoordinateConversion( parameters={ "grid_mapping_name": "albers_conical_equal_area", "standard_parallel": [-30, 10], "longitude_of_projection_origin": 34.8, "false_easting": -20000, "false_northing": -30000, }), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=["coord1", "fred", "coord3"], coordinate_conversion=cf.CoordinateConversion( parameters={ "grid_mapping_name": "albers_conical_equal_area", "standard_parallel": cf.Data([-30, 10]), "longitude_of_projection_origin": 34.8, "false_easting": -20000, "false_northing": -30000, }), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2))
class CoordinateReferenceTest(unittest.TestCase): f = cf.example_field(1) datum = cf.Datum(parameters={"earth_radius": 6371007}) # Create a vertical grid mapping coordinate reference vconversion = cf.CoordinateConversion( parameters={"standard_name": "atmosphere_hybrid_height_coordinate"}, domain_ancillaries={ "a": "auxiliarycoordinate0", "b": "auxiliarycoordinate1", "orog": "domainancillary0", }, ) vcr = cf.CoordinateReference(coordinates=("coord1", ), datum=datum, coordinate_conversion=vconversion) # Create a horizontal grid mapping coordinate reference hconversion = cf.CoordinateConversion( parameters={ "grid_mapping_name": "rotated_latitude_longitude", "grid_north_pole_latitude": 38.0, "grid_north_pole_longitude": 190.0, }) hcr = cf.CoordinateReference( coordinate_conversion=hconversion, datum=datum, coordinates=["x", "y", "lat", "lon"], ) def test_CoordinateReference__repr__str__dump(self): coordinate_conversion = cf.CoordinateConversion( parameters={ "standard_name": "atmosphere_hybrid_height_coordinate" }, domain_ancillaries={ "a": "aux0", "b": "aux1", "orog": "orog" }, ) datum = cf.Datum(parameters={"earth_radius": 23423423423.34}) # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference( coordinates=("coord1", ), coordinate_conversion=coordinate_conversion, datum=datum, ) repr(t) str(t) t.dump(display=False) self.assertFalse(t.has_bounds()) repr(datum) str(datum) repr(coordinate_conversion) str(coordinate_conversion) def test_CoordinateReference_equals(self): # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference( coordinates=("coord1", ), coordinate_conversion=cf.CoordinateConversion( parameters={ "standard_name": "atmosphere_hybrid_height_coordinate" }, domain_ancillaries={ "a": "aux0", "b": "aux1", "orog": "orog" }, ), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=["coord1", "fred", "coord3"], coordinate_conversion=cf.CoordinateConversion( parameters={ "grid_mapping_name": "rotated_latitude_longitude", "grid_north_pole_latitude": 38.0, "grid_north_pole_longitude": 190.0, }), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) datum = cf.Datum(parameters={"earth_radius": 6371007}) conversion = cf.CoordinateConversion( parameters={ "grid_mapping_name": "rotated_latitude_longitude", "grid_north_pole_latitude": 38.0, "grid_north_pole_longitude": 190.0, }) t = cf.CoordinateReference( coordinate_conversion=conversion, datum=datum, coordinates=["x", "y", "lat", "lon"], ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=["coord1", "fred", "coord3"], coordinate_conversion=cf.CoordinateConversion( parameters={ "grid_mapping_name": "albers_conical_equal_area", "standard_parallel": [-30, 10], "longitude_of_projection_origin": 34.8, "false_easting": -20000, "false_northing": -30000, }), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=["coord1", "fred", "coord3"], coordinate_conversion=cf.CoordinateConversion( parameters={ "grid_mapping_name": "albers_conical_equal_area", "standard_parallel": cf.Data([-30, 10]), "longitude_of_projection_origin": 34.8, "false_easting": -20000, "false_northing": -30000, }), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) def test_CoordinateReference_default_value(self): f = self.f.copy() self.assertEqual(cf.CoordinateReference.default_value("qwerty"), 0.0) self.assertEqual(cf.CoordinateReference.default_value("earth_depth"), 0.0) cr = f.construct("standard_name:atmosphere_hybrid_height_coordinate") self.assertEqual(cr.default_value("qwerty"), 0.0) self.assertEqual(cr.default_value("earth_depth"), 0.0) def test_CoordinateReference_canonical_units(self): f = self.f.copy() self.assertIsNone(cf.CoordinateReference.canonical_units("qwerty")) self.assertEqual( cf.CoordinateReference.canonical_units("earth_radius"), cf.Units("m"), ) cr = f.construct("standard_name:atmosphere_hybrid_height_coordinate") self.assertIsNone(cr.canonical_units("qwerty")) self.assertEqual(cr.canonical_units("earth_radius"), cf.Units("m")) def test_CoordinateReference_match(self): self.assertTrue(self.vcr.match()) self.assertTrue( self.vcr.match( "standard_name:atmosphere_hybrid_height_coordinate")) self.assertTrue(self.vcr.match("atmosphere_hybrid_height_coordinate")) self.assertTrue( self.vcr.match("atmosphere_hybrid_height_coordinate", "qwerty")) self.assertTrue(self.hcr.match()) self.assertTrue( self.hcr.match("grid_mapping_name:rotated_latitude_longitude")) self.assertTrue(self.hcr.match("rotated_latitude_longitude")) self.assertTrue( self.hcr.match("grid_mapping_name:rotated_latitude_longitude", "qwerty")) def test_CoordinateReference_get__getitem__(self): self.assertEqual(self.vcr["earth_radius"], self.datum.get_parameter("earth_radius")) self.assertTrue( self.vcr["standard_name"], self.vconversion.get_parameter("standard_name"), ) self.assertEqual( self.vcr.get("earth_radius"), self.datum.get_parameter("earth_radius"), ) self.assertIsNone(self.vcr.get("orog")) self.assertEqual(self.vcr.get("orog", "qwerty"), "qwerty") self.assertIsNone(self.vcr.get("qwerty")) self.assertEqual( self.vcr["standard_name"], self.vconversion.get_parameter("standard_name"), ) with self.assertRaises(Exception): self.vcr["orog"] self.assertEqual(self.hcr["earth_radius"], self.datum.get_parameter("earth_radius")) self.assertEqual( self.hcr["grid_north_pole_latitude"], self.hconversion.get_parameter("grid_north_pole_latitude"), ) self.assertEqual( self.hcr["grid_mapping_name"], self.hconversion.get_parameter("grid_mapping_name"), ) self.assertEqual( self.hcr.get("earth_radius"), self.datum.get_parameter("earth_radius"), ) self.assertEqual( self.hcr.get("grid_north_pole_latitude", "qwerty"), self.hconversion.get_parameter("grid_north_pole_latitude"), ) self.assertIsNone(self.hcr.get("qwerty")) self.assertEqual(self.hcr.get("qwerty", 12), 12) with self.assertRaises(Exception): self.hcr["qwerty"] def test_CoordinateReference_structural_signature(self): c = self.hcr.copy() self.assertIsInstance(c.structural_signature(), tuple) c.datum.set_parameter("test", [23]) s = c.structural_signature() self.assertEqual(s[2], ("datum:test", (23.0, ), None)) c.datum.set_parameter("test", [23, 45]) s = c.structural_signature() self.assertEqual(s[2], ("datum:test", (23.0, 45.0), None)) c.datum.set_parameter("test", [[23, 45]]) s = c.structural_signature() self.assertEqual(s[2], ("datum:test", ((23.0, 45.0), ), None)) c.datum.set_parameter("test", np.array([[23, 45], [67, 89]])) s = c.structural_signature() self.assertEqual(s[2], ("datum:test", ((23.0, 45.0), (67.0, 89.0)), None))
def create(dat): """creates cf-python Field object :param dict dat: calpost_reader generated dict of data :return: cf.Field """ v = cf.Field( properties={ 'standard_name': 'mass_concentration_of_methane_in_air', 'units': 'kg m-3', }) v.set_data(dat['v'] / 1000) v.nc_set_variable('methane') if len(dat['v'].shape) == 4: nt, nz, ny, nx = dat['v'].shape has_z = True print(nt, nz, ny, nx) else: nt, ny, nx = dat['v'].shape has_z = False print('a') domain_axisT = cf.DomainAxis(nt) domain_axisT.nc_set_unlimited(True) domain_axisY = cf.DomainAxis(ny) domain_axisX = cf.DomainAxis(nx) domain_axisT.nc_set_dimension('time') domain_axisY.nc_set_dimension('y') domain_axisX.nc_set_dimension('x') axisT = v.set_construct(domain_axisT) axisY = v.set_construct(domain_axisY) axisX = v.set_construct(domain_axisX) if has_z: domain_axisZ = cf.DomainAxis(nz) domain_axisZ.nc_set_dimension('z') axisZ = v.set_construct(domain_axisZ) print(type(domain_axisY)) print(dir(domain_axisY)) print(domain_axisY.identity()) print('b') x = dat['x'] y = dat['y'] dimX = cf.DimensionCoordinate(data=x * 1000, properties={ 'standard_name': 'projection_x_coordinate', 'units': 'meters' }) dimY = cf.DimensionCoordinate(data=y * 1000, properties={ 'standard_name': 'projection_y_coordinate', 'units': 'meters' }) dimT = cf.DimensionCoordinate(data=dat['ts'], ) dimT.nc_set_variable('time') dimY.nc_set_variable('y') dimX.nc_set_variable('x') if has_z: z = dat['z'] dimZ = cf.DimensionCoordinate(data=z, properties={ 'standard_name': 'height', 'units': 'meters' }) dimZ.nc_set_variable('z') print('c') dim_t = v.set_construct(dimT, axes=domain_axisT.identity()) dim_y = v.set_construct(dimY, axes=domain_axisY.identity()) dim_x = v.set_construct(dimX, axes=domain_axisX.identity()) if has_z: v.set_construct(dimZ, axes=domain_axisZ.identity()) print('d') if has_z: v.set_data_axes([axisT, axisZ, axisY, axisX]) else: v.set_data_axes([axisT, axisY, axisX]) datum = cf.Datum(parameters={'earth_radius': 637000.0}) coordinate_conversion_h = cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'lambert_conformal_conic', 'standard_parallel': (38.5, 38.5), 'longitude_of_central_meridian': -97.5, 'latitude_of_projection_origin': 38.5, }) horizontal_crs = cf.CoordinateReference( datum=datum, coordinate_conversion=coordinate_conversion_h, coordinates=[dim_x, dim_y]) v.set_construct(horizontal_crs) return v
def test_groups(self): f = cf.example_field(1) ungrouped_file = ungrouped_file1 grouped_file = grouped_file1 # Add a second grid mapping datum = cf.Datum(parameters={"earth_radius": 7000000}) conversion = cf.CoordinateConversion( parameters={"grid_mapping_name": "latitude_longitude"} ) grid = cf.CoordinateReference( coordinate_conversion=conversion, datum=datum, coordinates=["auxiliarycoordinate0", "auxiliarycoordinate1"], ) f.set_construct(grid) grid0 = f.construct("grid_mapping_name:rotated_latitude_longitude") grid0.del_coordinate("auxiliarycoordinate0") grid0.del_coordinate("auxiliarycoordinate1") cf.write(f, ungrouped_file) g = cf.read(ungrouped_file, verbose=1) self.assertEqual(len(g), 1) g = g[0] self.assertTrue(f.equals(g, verbose=2)) # ------------------------------------------------------------ # Move the field construct to the /forecast/model group # ------------------------------------------------------------ g.nc_set_variable_groups(["forecast", "model"]) cf.write(g, grouped_file) nc = netCDF4.Dataset(grouped_file, "r") self.assertIn( f.nc_get_variable(), nc.groups["forecast"].groups["model"].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)) # ------------------------------------------------------------ # Move constructs one by one to the /forecast group. The order # in which we do this matters! # ------------------------------------------------------------ for name in ( "longitude", # Auxiliary coordinate "latitude", # Auxiliary coordinate "long_name=Grid latitude name", # Auxiliary coordinate "measure:area", # Cell measure "surface_altitude", # Domain ancillary "air_temperature standard_error", # Field ancillary "grid_mapping_name:rotated_latitude_longitude", "time", # Dimension coordinate "grid_latitude", # Dimension coordinate ): g.construct(name).nc_set_variable_groups(["forecast"]) cf.write(g, grouped_file, verbose=1) # Check that the variable is in the right group nc = netCDF4.Dataset(grouped_file, "r") self.assertIn( f.construct(name).nc_get_variable(), nc.groups["forecast"].variables, ) nc.close() # Check that the field construct hasn't changed h = cf.read(grouped_file, verbose=1) self.assertEqual(len(h), 1, repr(h)) self.assertTrue(f.equals(h[0], verbose=2), name) # ------------------------------------------------------------ # Move bounds to the /forecast group # ------------------------------------------------------------ name = "grid_latitude" g.construct(name).bounds.nc_set_variable_groups(["forecast"]) cf.write(g, grouped_file) nc = netCDF4.Dataset(grouped_file, "r") self.assertIn( f.construct(name).bounds.nc_get_variable(), nc.groups["forecast"].variables, ) nc.close() h = cf.read(grouped_file, verbose="WARNING") self.assertEqual(len(h), 1, repr(h)) self.assertTrue(f.equals(h[0], verbose=2))
def test_create_field(self): # Dimension coordinates dim1 = cf.DimensionCoordinate( data=cf.Data(numpy.arange(10.0), "degrees")) dim1.standard_name = "grid_latitude" dim0 = cf.DimensionCoordinate( data=cf.Data(numpy.arange(9.0) + 20, "degrees")) dim0.standard_name = "grid_longitude" dim0.data[-1] += 5 bounds = cf.Data( numpy.array([dim0.data.array - 0.5, dim0.data.array + 0.5]).transpose((1, 0))) bounds[-2, 1] = 30 bounds[-1, :] = [30, 36] dim0.set_bounds(cf.Bounds(data=bounds)) dim2 = cf.DimensionCoordinate( data=cf.Data([1.5]), bounds=cf.Bounds(data=cf.Data([[1, 2.0]]))) dim2.standard_name = "atmosphere_hybrid_height_coordinate" # Auxiliary coordinates ak = cf.DomainAncillary(data=cf.Data([10.0], "m")) ak.id = "atmosphere_hybrid_height_coordinate_ak" bounds = cf.Bounds(data=cf.Data([[5, 15.0]], units=ak.Units)) ak.set_bounds(bounds) bk = cf.DomainAncillary(data=cf.Data([20.0])) bk.id = "atmosphere_hybrid_height_coordinate_bk" bounds = cf.Bounds(data=cf.Data([[14, 26.0]])) bk.set_bounds(bounds) aux2 = cf.AuxiliaryCoordinate(data=cf.Data( numpy.arange(-45, 45, dtype="int32").reshape(10, 9), units="degree_N", )) aux2.standard_name = "latitude" aux3 = cf.AuxiliaryCoordinate(data=cf.Data( numpy.arange(60, 150, dtype="int32").reshape(9, 10), units="degreesE", )) aux3.standard_name = "longitude" aux4 = cf.AuxiliaryCoordinate(data=cf.Data( numpy.array( [ "alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta", "iota", "kappa", ], dtype="S", ))) aux4.standard_name = "greek_letters" aux4[0] = cf.masked # Cell measures msr0 = cf.CellMeasure( data=cf.Data(1 + numpy.arange(90.0).reshape(9, 10) * 1234, "km 2")) msr0.measure = "area" # Data data = cf.Data(numpy.arange(90.0).reshape(10, 9), "m s-1") properties = {"standard_name": "eastward_wind"} f = cf.Field(properties=properties) axisX = f.set_construct(cf.DomainAxis(9)) axisY = f.set_construct(cf.DomainAxis(10)) axisZ = f.set_construct(cf.DomainAxis(1)) f.set_data(data) x = f.set_construct(dim0) y = f.set_construct(dim1, axes=[axisY]) z = f.set_construct(dim2, axes=[axisZ]) lat = f.set_construct(aux2) lon = f.set_construct(aux3, axes=["X", axisY]) f.set_construct(aux4, axes=["Y"]) ak = f.set_construct(ak, axes=["Z"]) bk = f.set_construct(bk, axes=[axisZ]) # Coordinate references coordinate_conversion = cf.CoordinateConversion( parameters={ "grid_mapping_name": "rotated_latitude_longitude", "grid_north_pole_latitude": 38.0, "grid_north_pole_longitude": 190.0, }) ref0 = cf.CoordinateReference( coordinate_conversion=coordinate_conversion, coordinates=[x, y, lat, lon], ) f.set_construct(msr0, axes=[axisX, "Y"]) f.set_construct(ref0) orog = cf.DomainAncillary() orog.standard_name = "surface_altitude" orog.set_data(cf.Data(f.array * 2, "m")) orog.transpose([1, 0], inplace=True) orog_key = f.set_construct(orog, axes=["X", axisY]) coordinate_conversion = cf.CoordinateConversion( parameters={ "standard_name": "atmosphere_hybrid_height_coordinate" }, domain_ancillaries={ "orog": orog_key, "a": ak, "b": bk }, ) ref1 = cf.CoordinateReference( coordinate_conversion=coordinate_conversion, coordinates=[z]) f.set_construct(ref1) # Field ancillary variables g = cf.FieldAncillary() g.set_data(f.data) g.transpose([1, 0], inplace=True) g.standard_name = "ancillary0" g *= 0.01 f.set_construct(g) g = cf.FieldAncillary() g.set_data(f.data) g.standard_name = "ancillary1" g *= 0.01 f.set_construct(g) g = cf.FieldAncillary() g.set_data(f[0, :].data) g.squeeze(inplace=True) g.standard_name = "ancillary2" g *= 0.001 f.set_construct(g) g = cf.FieldAncillary() g.set_data(f[:, 0].data) g.squeeze(inplace=True) g.standard_name = "ancillary3" g *= 0.001 f.set_construct(g) f.flag_values = [1, 2, 4] f.flag_meanings = ["a", "bb", "ccc"] for cm in cf.CellMethod.create( "grid_longitude: mean grid_latitude: max"): f.set_construct(cm) # Write the file, and read it in cf.write(f, self.filename, verbose=0, string=True) g = cf.read(self.filename, squeeze=True, verbose=0)[0] self.assertTrue(g.equals(f, verbose=0), "Field not equal to itself read back in") x = g.dump(display=False) x = f.dump(display=False)
class CoordinateReferenceTest(unittest.TestCase): filename = os.path.join(os.path.dirname(os.path.abspath(__file__)), "test_file.nc") datum = cf.Datum(parameters={"earth_radius": 6371007}) # Create a vertical grid mapping coordinate reference vconversion = cf.CoordinateConversion( parameters={"standard_name": "atmosphere_hybrid_height_coordinate"}, domain_ancillaries={ "a": "auxiliarycoordinate0", "b": "auxiliarycoordinate1", "orog": "domainancillary0", }, ) vcr = cf.CoordinateReference(coordinates=("coord1", ), datum=datum, coordinate_conversion=vconversion) # Create a horizontal grid mapping coordinate reference hconversion = cf.CoordinateConversion( parameters={ "grid_mapping_name": "rotated_latitude_longitude", "grid_north_pole_latitude": 38.0, "grid_north_pole_longitude": 190.0, }) hcr = cf.CoordinateReference( coordinate_conversion=hconversion, datum=datum, coordinates=["x", "y", "lat", "lon"], ) def setUp(self): self.f = cf.read(self.filename)[0] def test_CoordinateReference__repr__str__dump(self): coordinate_conversion = cf.CoordinateConversion( parameters={ "standard_name": "atmosphere_hybrid_height_coordinate" }, domain_ancillaries={ "a": "aux0", "b": "aux1", "orog": "orog" }, ) datum = cf.Datum(parameters={"earth_radius": 23423423423.34}) # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference( coordinates=("coord1", ), coordinate_conversion=coordinate_conversion, datum=datum, ) _ = repr(t) _ = str(t) _ = t.dump(display=False) self.assertFalse(t.has_bounds()) _ = repr(datum) _ = str(datum) _ = repr(coordinate_conversion) _ = str(coordinate_conversion) def test_CoordinateReference_equals(self): # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference( coordinates=("coord1", ), coordinate_conversion=cf.CoordinateConversion( parameters={ "standard_name": "atmosphere_hybrid_height_coordinate" }, domain_ancillaries={ "a": "aux0", "b": "aux1", "orog": "orog" }, ), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=["coord1", "fred", "coord3"], coordinate_conversion=cf.CoordinateConversion( parameters={ "grid_mapping_name": "rotated_latitude_longitude", "grid_north_pole_latitude": 38.0, "grid_north_pole_longitude": 190.0, }), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) datum = cf.Datum(parameters={"earth_radius": 6371007}) conversion = cf.CoordinateConversion( parameters={ "grid_mapping_name": "rotated_latitude_longitude", "grid_north_pole_latitude": 38.0, "grid_north_pole_longitude": 190.0, }) t = cf.CoordinateReference( coordinate_conversion=conversion, datum=datum, coordinates=["x", "y", "lat", "lon"], ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=["coord1", "fred", "coord3"], coordinate_conversion=cf.CoordinateConversion( parameters={ "grid_mapping_name": "albers_conical_equal_area", "standard_parallel": [-30, 10], "longitude_of_projection_origin": 34.8, "false_easting": -20000, "false_northing": -30000, }), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=["coord1", "fred", "coord3"], coordinate_conversion=cf.CoordinateConversion( parameters={ "grid_mapping_name": "albers_conical_equal_area", "standard_parallel": cf.Data([-30, 10]), "longitude_of_projection_origin": 34.8, "false_easting": -20000, "false_northing": -30000, }), ) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) def test_CoordinateReference_default_value(self): f = self.f.copy() self.assertEqual(cf.CoordinateReference.default_value("qwerty"), 0.0) self.assertEqual(cf.CoordinateReference.default_value("earth_depth"), 0.0) cr = f.construct("standard_name:atmosphere_hybrid_height_coordinate") self.assertEqual(cr.default_value("qwerty"), 0.0) self.assertEqual(cr.default_value("earth_depth"), 0.0) def test_CoordinateReference_canonical_units(self): f = self.f.copy() self.assertIsNone(cf.CoordinateReference.canonical_units("qwerty")) self.assertEqual( cf.CoordinateReference.canonical_units("earth_radius"), cf.Units("m"), ) cr = f.construct("standard_name:atmosphere_hybrid_height_coordinate") self.assertIsNone(cr.canonical_units("qwerty")) self.assertEqual(cr.canonical_units("earth_radius"), cf.Units("m")) def test_CoordinateReference_match(self): self.assertTrue(self.vcr.match()) self.assertTrue( self.vcr.match( "standard_name:atmosphere_hybrid_height_coordinate")) self.assertTrue(self.vcr.match("atmosphere_hybrid_height_coordinate")) self.assertTrue( self.vcr.match("atmosphere_hybrid_height_coordinate", "qwerty")) self.assertTrue(self.hcr.match()) self.assertTrue( self.hcr.match("grid_mapping_name:rotated_latitude_longitude")) self.assertTrue(self.hcr.match("rotated_latitude_longitude")) self.assertTrue( self.hcr.match("grid_mapping_name:rotated_latitude_longitude", "qwerty")) def test_CoordinateReference_get__getitem__(self): self.assertEqual(self.vcr["earth_radius"], self.datum.get_parameter("earth_radius")) self.assertTrue( self.vcr["standard_name"], self.vconversion.get_parameter("standard_name"), ) self.assertTrue( self.vcr.get("earth_radius") is self.datum.get_parameter( "earth_radius")) self.assertIsNone(self.vcr.get("orog")) self.assertEqual(self.vcr.get("orog", "qwerty"), "qwerty") self.assertIsNone(self.vcr.get("qwerty")) self.assertEqual( self.vcr["standard_name"], self.vconversion.get_parameter("standard_name"), ) with self.assertRaises(Exception): _ = self.vcr["orog"] self.assertEqual(self.hcr["earth_radius"], self.datum.get_parameter("earth_radius")) self.assertEqual( self.hcr["grid_north_pole_latitude"], self.hconversion.get_parameter("grid_north_pole_latitude"), ) self.assertEqual( self.hcr["grid_mapping_name"], self.hconversion.get_parameter("grid_mapping_name"), ) self.assertIs( self.hcr.get("earth_radius"), self.datum.get_parameter("earth_radius"), ) self.assertIs( self.hcr.get("grid_north_pole_latitude", "qwerty"), self.hconversion.get_parameter("grid_north_pole_latitude"), ) self.assertIsNone(self.hcr.get("qwerty")) self.assertEqual(self.hcr.get("qwerty", 12), 12) with self.assertRaises(Exception): _ = self.hcr["qwerty"]
def test_CoordinateReference_equals(self): f = self.f.copy() # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference( coordinates=('coord1', ), coordinate_conversion=cf.CoordinateConversion(parameters={ 'standard_name': 'atmosphere_hybrid_height_coordinate' }, domain_ancillaries={ 'a': 'aux0', 'b': 'aux1', 'orog': 'orog' })) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=['coord1', 'fred', 'coord3'], coordinate_conversion=cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'rotated_latitude_longitude', 'grid_north_pole_latitude': 38.0, 'grid_north_pole_longitude': 190.0 })) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) datum = cf.Datum(parameters={'earth_radius': 6371007}) conversion = cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'rotated_latitude_longitude', 'grid_north_pole_latitude': 38.0, 'grid_north_pole_longitude': 190.0 }) t = cf.CoordinateReference(coordinate_conversion=conversion, datum=datum, coordinates=['x', 'y', 'lat', 'lon']) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=['coord1', 'fred', 'coord3'], coordinate_conversion=cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'albers_conical_equal_area', 'standard_parallel': [-30, 10], 'longitude_of_projection_origin': 34.8, 'false_easting': -20000, 'false_northing': -30000 })) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=['coord1', 'fred', 'coord3'], coordinate_conversion=cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'albers_conical_equal_area', 'standard_parallel': cf.Data([-30, 10]), 'longitude_of_projection_origin': 34.8, 'false_easting': -20000, 'false_northing': -30000 })) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2))
class CoordinateReferenceTest(unittest.TestCase): filename = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'test_file.nc') datum = cf.Datum(parameters={'earth_radius': 6371007}) # Create a vertical grid mapping coordinate reference vconversion = cf.CoordinateConversion( parameters={'standard_name': 'atmosphere_hybrid_height_coordinate'}, domain_ancillaries={ 'a': 'auxiliarycoordinate0', 'b': 'auxiliarycoordinate1', 'orog': 'domainancillary0' }) vcr = cf.CoordinateReference(coordinates=('coord1', ), datum=datum, coordinate_conversion=vconversion) # Create a horizontal grid mapping coordinate reference hconversion = cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'rotated_latitude_longitude', 'grid_north_pole_latitude': 38.0, 'grid_north_pole_longitude': 190.0 }) hcr = cf.CoordinateReference(coordinate_conversion=hconversion, datum=datum, coordinates=['x', 'y', 'lat', 'lon']) def setUp(self): self.f = cf.read(self.filename)[0] def test_CoordinateReference__repr__str__dump(self): f = self.f.copy() coordinate_conversion = cf.CoordinateConversion(parameters={ 'standard_name': 'atmosphere_hybrid_height_coordinate' }, domain_ancillaries={ 'a': 'aux0', 'b': 'aux1', 'orog': 'orog' }) datum = cf.Datum(parameters={'earth_radius': 23423423423.34}) # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference(coordinates=('coord1', ), coordinate_conversion=coordinate_conversion, datum=datum) _ = repr(t) _ = str(t) _ = t.dump(display=False) self.assertFalse(t.has_bounds()) _ = repr(datum) _ = str(datum) _ = repr(coordinate_conversion) _ = str(coordinate_conversion) def test_CoordinateReference_equals(self): f = self.f.copy() # Create a vertical grid mapping coordinate reference t = cf.CoordinateReference( coordinates=('coord1', ), coordinate_conversion=cf.CoordinateConversion(parameters={ 'standard_name': 'atmosphere_hybrid_height_coordinate' }, domain_ancillaries={ 'a': 'aux0', 'b': 'aux1', 'orog': 'orog' })) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=['coord1', 'fred', 'coord3'], coordinate_conversion=cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'rotated_latitude_longitude', 'grid_north_pole_latitude': 38.0, 'grid_north_pole_longitude': 190.0 })) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) datum = cf.Datum(parameters={'earth_radius': 6371007}) conversion = cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'rotated_latitude_longitude', 'grid_north_pole_latitude': 38.0, 'grid_north_pole_longitude': 190.0 }) t = cf.CoordinateReference(coordinate_conversion=conversion, datum=datum, coordinates=['x', 'y', 'lat', 'lon']) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=['coord1', 'fred', 'coord3'], coordinate_conversion=cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'albers_conical_equal_area', 'standard_parallel': [-30, 10], 'longitude_of_projection_origin': 34.8, 'false_easting': -20000, 'false_northing': -30000 })) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) # Create a horizontal grid mapping coordinate reference t = cf.CoordinateReference( coordinates=['coord1', 'fred', 'coord3'], coordinate_conversion=cf.CoordinateConversion( parameters={ 'grid_mapping_name': 'albers_conical_equal_area', 'standard_parallel': cf.Data([-30, 10]), 'longitude_of_projection_origin': 34.8, 'false_easting': -20000, 'false_northing': -30000 })) self.assertTrue(t.equals(t, verbose=2)) self.assertTrue(t.equals(t.copy(), verbose=2)) def test_CoordinateReference_default_value(self): f = self.f.copy() self.assertEqual(cf.CoordinateReference.default_value('qwerty'), 0.0) self.assertEqual(cf.CoordinateReference.default_value('earth_depth'), 0.0) cr = f.construct('standard_name:atmosphere_hybrid_height_coordinate') self.assertEqual(cr.default_value('qwerty'), 0.0) self.assertEqual(cr.default_value('earth_depth'), 0.0) def test_CoordinateReference_canonical_units(self): f = self.f.copy() self.assertIsNone(cf.CoordinateReference.canonical_units('qwerty')) self.assertEqual( cf.CoordinateReference.canonical_units('earth_radius'), cf.Units('m')) cr = f.construct('standard_name:atmosphere_hybrid_height_coordinate') self.assertIsNone(cr.canonical_units('qwerty')) self.assertEqual(cr.canonical_units('earth_radius'), cf.Units('m')) def test_CoordinateReference_match(self): self.assertTrue(self.vcr.match()) self.assertTrue( self.vcr.match( 'standard_name:atmosphere_hybrid_height_coordinate')) self.assertTrue(self.vcr.match('atmosphere_hybrid_height_coordinate')) self.assertTrue( self.vcr.match('atmosphere_hybrid_height_coordinate', 'qwerty')) self.assertTrue(self.hcr.match()) self.assertTrue( self.hcr.match('grid_mapping_name:rotated_latitude_longitude')) self.assertTrue(self.hcr.match('rotated_latitude_longitude')) self.assertTrue( self.hcr.match('grid_mapping_name:rotated_latitude_longitude', 'qwerty')) def test_CoordinateReference_get__getitem__(self): self.assertEqual(self.vcr['earth_radius'], self.datum.get_parameter('earth_radius')) self.assertTrue(self.vcr['standard_name'], self.vconversion.get_parameter('standard_name')) self.assertTrue( self.vcr.get('earth_radius') is self.datum.get_parameter( 'earth_radius')) self.assertIsNone(self.vcr.get('orog')) self.assertEqual(self.vcr.get('orog', 'qwerty'), 'qwerty') self.assertIsNone(self.vcr.get('qwerty')) self.assertEqual(self.vcr['standard_name'], self.vconversion.get_parameter('standard_name')) with self.assertRaises(Exception): _ = self.vcr['orog'] self.assertEqual(self.hcr['earth_radius'], self.datum.get_parameter('earth_radius')) self.assertEqual( self.hcr['grid_north_pole_latitude'], self.hconversion.get_parameter('grid_north_pole_latitude')) self.assertEqual(self.hcr['grid_mapping_name'], self.hconversion.get_parameter('grid_mapping_name')) self.assertIs(self.hcr.get('earth_radius'), self.datum.get_parameter('earth_radius')) self.assertIs( self.hcr.get('grid_north_pole_latitude', 'qwerty'), self.hconversion.get_parameter('grid_north_pole_latitude')) self.assertIsNone(self.hcr.get('qwerty')) self.assertEqual(self.hcr.get('qwerty', 12), 12) with self.assertRaises(Exception): _ = self.hcr['qwerty']
def test_groups(self): f = cf.example_field(1) ungrouped_file = ungrouped_file1 grouped_file = grouped_file1 # Add a second grid mapping datum = cf.Datum(parameters={'earth_radius': 7000000}) conversion = cf.CoordinateConversion( parameters={'grid_mapping_name': 'latitude_longitude'}) grid = cf.CoordinateReference( coordinate_conversion=conversion, datum=datum, coordinates=['auxiliarycoordinate0', 'auxiliarycoordinate1']) f.set_construct(grid) grid0 = f.construct('grid_mapping_name:rotated_latitude_longitude') grid0.del_coordinate('auxiliarycoordinate0') grid0.del_coordinate('auxiliarycoordinate1') cf.write(f, ungrouped_file) g = cf.read(ungrouped_file, verbose=1) self.assertEqual(len(g), 1) g = g[0] self.assertTrue(f.equals(g, verbose=2)) # ------------------------------------------------------------ # Move the field construct to the /forecast/model group # ------------------------------------------------------------ g.nc_set_variable_groups(['forecast', 'model']) cf.write(g, grouped_file) nc = netCDF4.Dataset(grouped_file, 'r') self.assertIn(f.nc_get_variable(), nc.groups['forecast'].groups['model'].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)) # ------------------------------------------------------------ # Move constructs one by one to the /forecast group. The order # in which we do this matters! # ------------------------------------------------------------ for name in ( 'longitude', # Auxiliary coordinate 'latitude', # Auxiliary coordinate 'long_name=Grid latitude name', # Auxiliary coordinate 'measure:area', # Cell measure 'surface_altitude', # Domain ancillary 'air_temperature standard_error', # Field ancillary 'grid_mapping_name:rotated_latitude_longitude', 'time', # Dimension coordinate 'grid_latitude', # Dimension coordinate ): g.construct(name).nc_set_variable_groups(['forecast']) cf.write(g, grouped_file, verbose=1) # Check that the variable is in the right group nc = netCDF4.Dataset(grouped_file, 'r') self.assertIn( f.construct(name).nc_get_variable(), nc.groups['forecast'].variables) nc.close() # Check that the field construct hasn't changed h = cf.read(grouped_file, verbose=1) self.assertEqual(len(h), 1, repr(h)) self.assertTrue(f.equals(h[0], verbose=2), name) # ------------------------------------------------------------ # Move bounds to the /forecast group # ------------------------------------------------------------ name = 'grid_latitude' g.construct(name).bounds.nc_set_variable_groups(['forecast']) cf.write(g, grouped_file) nc = netCDF4.Dataset(grouped_file, 'r') self.assertIn( f.construct(name).bounds.nc_get_variable(), nc.groups['forecast'].variables) nc.close() h = cf.read(grouped_file, verbose='WARNING') self.assertEqual(len(h), 1, repr(h)) self.assertTrue(f.equals(h[0], verbose=2))
def test_create_field(self): # Dimension coordinates dim1 = cf.DimensionCoordinate( data=cf.Data(numpy.arange(10.), 'degrees')) dim1.standard_name = 'grid_latitude' dim0 = cf.DimensionCoordinate( data=cf.Data(numpy.arange(9.) + 20, 'degrees')) dim0.standard_name = 'grid_longitude' dim0.data[-1] += 5 bounds = cf.Data(numpy.array( [dim0.data.array-0.5, dim0.data.array+0.5]).transpose((1, 0))) bounds[-2, 1] = 30 bounds[-1, :] = [30, 36] dim0.set_bounds(cf.Bounds(data=bounds)) dim2 = cf.DimensionCoordinate( data=cf.Data([1.5]), bounds=cf.Bounds(data=cf.Data([[1, 2.]])) ) dim2.standard_name = 'atmosphere_hybrid_height_coordinate' # Auxiliary coordinates ak = cf.DomainAncillary(data=cf.Data([10.], 'm')) ak.id = 'atmosphere_hybrid_height_coordinate_ak' bounds = cf.Bounds(data=cf.Data([[5, 15.]], units=ak.Units)) ak.set_bounds(bounds) bk = cf.DomainAncillary(data=cf.Data([20.])) bk.id = 'atmosphere_hybrid_height_coordinate_bk' bounds = cf.Bounds(data=cf.Data([[14, 26.]])) bk.set_bounds(bounds) aux2 = cf.AuxiliaryCoordinate( data=cf.Data(numpy.arange(-45, 45, dtype='int32').reshape(10, 9), units='degree_N')) aux2.standard_name = 'latitude' aux3 = cf.AuxiliaryCoordinate( data=cf.Data(numpy.arange(60, 150, dtype='int32').reshape(9, 10), units='degreesE')) aux3.standard_name = 'longitude' aux4 = cf.AuxiliaryCoordinate( data=cf.Data(numpy.array( ['alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta', 'eta', 'theta', 'iota', 'kappa'], dtype='S' )) ) aux4.standard_name = 'greek_letters' aux4[0] = cf.masked # Cell measures msr0 = cf.CellMeasure( data=cf.Data(1+numpy.arange(90.).reshape(9, 10)*1234, 'km 2')) msr0.measure = 'area' # Data data = cf.Data(numpy.arange(90.).reshape(10, 9), 'm s-1') properties = {'standard_name': 'eastward_wind'} f = cf.Field(properties=properties) axisX = f.set_construct(cf.DomainAxis(9)) axisY = f.set_construct(cf.DomainAxis(10)) axisZ = f.set_construct(cf.DomainAxis(1)) f.set_data(data) x = f.set_construct(dim0) y = f.set_construct(dim1, axes=[axisY]) z = f.set_construct(dim2, axes=[axisZ]) lat = f.set_construct(aux2) lon = f.set_construct(aux3, axes=['X', axisY]) f.set_construct(aux4, axes=['Y']) ak = f.set_construct(ak, axes=['Z']) bk = f.set_construct(bk, axes=[axisZ]) # Coordinate references coordinate_conversion = cf.CoordinateConversion( parameters={'grid_mapping_name': 'rotated_latitude_longitude', 'grid_north_pole_latitude': 38.0, 'grid_north_pole_longitude': 190.0}) ref0 = cf.CoordinateReference( coordinate_conversion=coordinate_conversion, coordinates=[x, y, lat, lon] ) f.set_construct(msr0, axes=[axisX, 'Y']) f.set_construct(ref0) orog = cf.DomainAncillary() orog.standard_name = 'surface_altitude' orog.set_data(cf.Data(f.array*2, 'm')) orog.transpose([1, 0], inplace=True) orog_key = f.set_construct(orog, axes=['X', axisY]) coordinate_conversion = cf.CoordinateConversion( parameters={ 'standard_name': 'atmosphere_hybrid_height_coordinate' }, domain_ancillaries={ 'orog': orog_key, 'a': ak, 'b': bk } ) ref1 = cf.CoordinateReference( coordinate_conversion=coordinate_conversion, coordinates=[z]) f.set_construct(ref1) # Field ancillary variables g = cf.FieldAncillary() g.set_data(f.data) g.transpose([1, 0], inplace=True) g.standard_name = 'ancillary0' g *= 0.01 f.set_construct(g) g = cf.FieldAncillary() g.set_data(f.data) g.standard_name = 'ancillary1' g *= 0.01 f.set_construct(g) g = cf.FieldAncillary() g.set_data(f[0, :].data) g.squeeze(inplace=True) g.standard_name = 'ancillary2' g *= 0.001 f.set_construct(g) g = cf.FieldAncillary() g.set_data(f[:, 0].data) g.squeeze(inplace=True) g.standard_name = 'ancillary3' g *= 0.001 f.set_construct(g) f.flag_values = [1, 2, 4] f.flag_meanings = ['a', 'bb', 'ccc'] for cm in cf.CellMethod.create( 'grid_longitude: mean grid_latitude: max'): f.set_construct(cm) # Write the file, and read it in cf.write(f, self.filename, verbose=0, string=True) g = cf.read(self.filename, squeeze=True, verbose=0)[0] self.assertTrue(g.equals(f, verbose=0), "Field not equal to itself read back in") x = g.dump(display=False) x = f.dump(display=False)