def test_error_longitude_no_latitude(self):
try:
grid([0], longitude=numpy.arange(2))
self.fail('should raise exception')
except Exception, e:
self.assertEquals(
"latitude and longitude must be BOTH an array or None", str(e))
def test_error_longitude_no_latitude(self):
try:
grid([0], longitude=numpy.arange(2))
self.fail('should raise exception')
except Exception as e:
self.assertEquals(
"latitude and longitude must be BOTH an array or None", str(e))
def test_error_latitude_no_longitude(self):
try:
grid([0], latitude=numpy.arange(2))
self.fail('should raise exception')
except Exception, e:
self.assertEquals(
"Error could not convert longitude to a numpy array", str(e))
def test_error_latitude_no_longitude(self):
try:
grid([0], latitude=numpy.arange(2))
self.fail('should raise exception')
except Exception as e:
self.assertEquals(
"Error could not convert longitude to a numpy array", str(e))
def test_error_type_lons(self):
lats = numpy.arange(2*3).reshape(2,3)
for lons in (0, 0.1, 'string', {}):
try:
grid([0, 1], latitude = lats, longitude = lons)
self.fail('should raise exception')
except Exception, e:
self.assertEquals('Error could not convert longitude to a numpy array', str(e))
def test_error_on_axis_ids(self):
bad_axis_ids = (0, 'astring')
for axis_ids in bad_axis_ids:
try:
grid(axis_ids)
self.fail('should raise exception')
except Exception as e:
self.assertEquals('Error could not convert axis_ids list to a numpy array',
str(e))
def test_error_type_lons(self):
lats = numpy.arange(2 * 3).reshape(2, 3)
for lons in (0, 0.1, 'string', {}):
try:
grid([0, 1], latitude=lats, longitude=lons)
self.fail('should raise exception')
except Exception as e:
self.assertEquals(
'Error could not convert longitude to a numpy array', str(e))
def test_error_on_axis_ids(self):
bad_axis_ids = ( 0, 'astring')
for axis_ids in bad_axis_ids:
try:
grid(axis_ids)
self.fail('should raise exception')
except Exception, e:
self.assertEquals('Error could not convert axis_ids list to a numpy array',
str(e))
def test_error_rank_lats(self):
axis_ids = [1, 2]
lats = numpy.arange(2)
lons = numpy.arange(2*3).reshape(2,3)
try:
grid(axis_ids, latitude = lats, longitude = lons)
self.fail('should raise exception')
except Exception, e:
self.assertEquals("latitude's rank does not match number of axes passed via axis_ids", str(e))
def test_error_rank_lats(self):
axis_ids = [1, 2]
lats = numpy.arange(2)
lons = numpy.arange(2 * 3).reshape(2, 3)
try:
grid(axis_ids, latitude=lats, longitude=lons)
self.fail('should raise exception')
except Exception as e:
self.assertEquals(
"latitude's rank does not match number of axes passed via axis_ids", str(e))
def test_error_rank_lon_verts(self): # this test may be fragile?
axis_ids = [1, 2]
lats = numpy.arange(2*3).reshape(2,3)
lons = numpy.arange(2*3).reshape(2,3)
lon_verts = lons
try:
grid(axis_ids, latitude = lats, longitude = lons,
longitude_vertices = lon_verts)
self.fail('should raise exception')
except Exception, e:
self.assertEquals("longitude_vertices's rank does not match number of axes passed via axis_ids +1 (for vertices)",
str(e))
def test_error_rank_lon_verts(self): # this test may be fragile?
axis_ids = [1, 2]
lats = numpy.arange(2 * 3).reshape(2, 3)
lons = numpy.arange(2 * 3).reshape(2, 3)
lon_verts = lons
try:
grid(axis_ids, latitude=lats, longitude=lons,
longitude_vertices=lon_verts)
self.fail('should raise exception')
except Exception as e:
self.assertEquals("longitude_vertices's rank does not match number of axes passed via axis_ids +1 (for vertices)",
str(e))
def cmor_define_and_write(values, axes):
table = 'CMIP5_cfSites'
cmor.load_table(table)
axis_ids = list()
for axis in axes:
axis_id = cmor.axis(**axis)
axis_ids.append(axis_id)
igrid = cmor.grid([axis_ids[1]], [0.], [0.])
cmor.zfactor(axis_ids[2], 'b', axis_ids = [axis_ids[2]],
zfactor_values = range(2),
zfactor_bounds = [[x-0.5, x+0.5] for x in range(2)])
cmor.zfactor(axis_ids[2], 'orog', 'm', axis_ids = [igrid],
zfactor_values = [0])
ids_for_var = [axis_ids[0], igrid, axis_ids[2]]
varid = cmor.variable('tnhus',
's-1',
ids_for_var,
history = 'variable history',
missing_value = -99,
)
for time in [x * 1800./ 86400 for x in range(48)]:
time += 1./3600./24.
tr = cdtime.reltime(time,axes[0]["units"])
print "Writing: %.03f" % time,"|",tr.tocomp(cdtime.Calendar360),"|",tr.tocomp()
cmor.write(varid, values, time_vals = [time])
return varid
def cmor_define_and_write(values, axes):
table = 'CMIP6_CFsubhr.json'
cmor.load_table(table)
axis_ids = list()
for axis in axes:
axis_id = cmor.axis(**axis)
axis_ids.append(axis_id)
igrid = cmor.grid([axis_ids[1]], [0.], [0.])
cmor.zfactor(axis_ids[2],
'b',
axis_ids=[axis_ids[2]],
zfactor_values=range(2),
zfactor_bounds=[[x - 0.5, x + 0.5] for x in range(2)])
cmor.zfactor(axis_ids[2],
'orog',
'm',
axis_ids=[igrid],
zfactor_values=[0])
ids_for_var = [axis_ids[0], igrid, axis_ids[2]]
varid = cmor.variable(
'tnhus',
's-1',
ids_for_var,
history='variable history',
missing_value=-99,
)
for time in [x * 1800. / 86400 for x in range(48)]:
cmor.write(varid, values, time_vals=[time])
return varid
def test_lat_lon_with_vertices(self):
axis_ids = [1, 2]
nvert = 4
for atype in (numpy.array, list, tuple):
lats = atype(numpy.arange(2 * 3).reshape(2, 3) + 0.1)
lons = atype(numpy.arange(2 * 3).reshape(2, 3) - 0.1)
lat_vert = atype(
numpy.arange(
2 *
3 *
nvert).reshape(
2,
3,
nvert) +
0.5)
lon_vert = atype(
numpy.arange(
2 *
3 *
nvert).reshape(
2,
3,
nvert) -
0.5)
args = grid(axis_ids,
latitude=lats,
longitude=lons,
latitude_vertices=lat_vert,
longitude_vertices=lon_vert)
self.assert_on_axis_id_args(axis_ids, args)
self.assert_on_coordiantes(lats, lons, args)
self.assert_on_vertices(nvert, lat_vert, lon_vert, args)
def create_gauss_grid(nx, x0, yvals):
ny = len(yvals)
i_index_id = cmor.axis(table_entry="i_index",
units="1",
coord_vals=numpy.array(range(1, nx + 1)))
j_index_id = cmor.axis(table_entry="j_index",
units="1",
coord_vals=numpy.array(range(1, ny + 1)))
dx = 360. / nx
x_vals = numpy.array([x0 + (i + 0.5) * dx for i in range(nx)])
lon_arr = numpy.tile(x_vals, (ny, 1))
lat_arr = numpy.tile(yvals[::-1], (nx, 1)).transpose()
lon_mids = numpy.array([x0 + i * dx for i in range(nx + 1)])
lat_mids = numpy.empty([ny + 1])
lat_mids[0] = 90.
lat_mids[1:ny] = 0.5 * (yvals[0:ny - 1] + yvals[1:ny])
lat_mids[ny] = -90.
vert_lats = numpy.empty([ny, nx, 4])
vert_lats[:, :, 0] = numpy.tile(lat_mids[0:ny], (nx, 1)).transpose()
vert_lats[:, :, 1] = vert_lats[:, :, 0]
vert_lats[:, :, 2] = numpy.tile(lat_mids[1:ny + 1], (nx, 1)).transpose()
vert_lats[:, :, 3] = vert_lats[:, :, 2]
vert_lons = numpy.empty([ny, nx, 4])
vert_lons[:, :, 0] = numpy.tile(lon_mids[0:nx], (ny, 1))
vert_lons[:, :, 3] = vert_lons[:, :, 0]
vert_lons[:, :, 1] = numpy.tile(lon_mids[1:nx + 1], (ny, 1))
vert_lons[:, :, 2] = vert_lons[:, :, 1]
return cmor.grid(axis_ids=[j_index_id, i_index_id],
latitude=lat_arr,
longitude=lon_arr,
latitude_vertices=vert_lats,
longitude_vertices=vert_lons)
def cmor_define_and_write(values, axes):
table = 'CMIP5_cfSites'
cmor.load_table(table)
site_axis_id = cmor.axis(**axes[1])
time_axis_id = cmor.axis(**axes[0])
gid = cmor.grid([
site_axis_id,
],
latitude=numpy.array([
-20,
]),
longitude=numpy.array([
150,
]))
axis_ids = [time_axis_id, gid]
varid = cmor.variable('rlut',
'W m-2',
axis_ids,
history='variable history',
missing_value=-99,
positive='up')
cmor.write(varid, values, time_vals=[15])
def create_gauss_grid(xvals, yvals):
nx, ny = len(xvals), len(yvals)
if use_2d_grid() and nx > 1 and ny > 1:
lon_mids, lat_mids = get_lon_mids(xvals), get_lat_mids(yvals)
vert_lats = numpy.empty([ny, nx, 4])
vert_lats[:, :, 0] = numpy.tile(lat_mids[0:ny], (nx, 1)).transpose()
vert_lats[:, :, 1] = vert_lats[:, :, 0]
vert_lats[:, :, 2] = numpy.tile(lat_mids[1:ny + 1], (nx, 1)).transpose()
vert_lats[:, :, 3] = vert_lats[:, :, 2]
vert_lons = numpy.empty([ny, nx, 4])
vert_lons[:, :, 0] = numpy.tile(lon_mids[0:nx], (ny, 1))
vert_lons[:, :, 3] = vert_lons[:, :, 0]
vert_lons[:, :, 1] = numpy.tile(lon_mids[1:nx + 1], (ny, 1))
vert_lons[:, :, 2] = vert_lons[:, :, 1]
i_index_id = cmor.axis(table_entry="i_index", units="1", coord_vals=numpy.array(range(1, nx + 1)))
j_index_id = cmor.axis(table_entry="j_index", units="1", coord_vals=numpy.array(range(1, ny + 1)))
lon_arr = numpy.tile(xvals, (ny, 1))
lat_arr = numpy.tile(yvals[::-1], (nx, 1)).transpose()
return cmor.grid(axis_ids=[j_index_id, i_index_id], latitude=lat_arr, longitude=lon_arr,
latitude_vertices=vert_lats, longitude_vertices=vert_lons)
else:
lats = cmor.axis(table_entry="latitude", coord_vals=yvals[::-1], cell_bounds=get_lat_mids(yvals)[::-1],
units="degrees_north") if (ny > 1) else None
lons = cmor.axis(table_entry="longitude", coord_vals=xvals, cell_bounds=get_lon_mids(xvals),
units="degrees_east") if (nx > 1) else None
return lats, lons
def write_grid(grid):
nx = grid.lons.shape[0]
ny = grid.lons.shape[1]
i_index_id = cmor.axis(table_entry="j_index", units="1", coord_vals=numpy.array(range(1, nx + 1)))
j_index_id = cmor.axis(table_entry="i_index", units="1", coord_vals=numpy.array(range(1, ny + 1)))
if ny == 1:
return cmor.grid(axis_ids=[i_index_id],
latitude=grid.lats[:, 0],
longitude=grid.lons[:, 0],
latitude_vertices=grid.vertex_lats,
longitude_vertices=grid.vertex_lons)
return cmor.grid(axis_ids=[i_index_id, j_index_id],
latitude=grid.lats,
longitude=grid.lons,
latitude_vertices=grid.vertex_lats,
longitude_vertices=grid.vertex_lons)
def cmor_define_and_write(values, axes):
table = 'CMIP6_cfSites.json'
cmor.load_table(table)
axis_ids = list()
for axis in axes:
axis_id = cmor.axis(**axis)
axis_ids.append(axis_id)
igrid = cmor.grid([axis_ids[1]], [0.], [0.])
cmor.zfactor(axis_ids[2], 'b', axis_ids = [axis_ids[2]],
zfactor_values = range(2),
zfactor_bounds = [[x-0.5, x+0.5] for x in range(2)])
cmor.zfactor(axis_ids[2], 'orog', 'm', axis_ids = [igrid],
zfactor_values = [0])
ids_for_var = [axis_ids[0], igrid, axis_ids[2]]
varid = cmor.variable('tnhus',
's-1',
ids_for_var,
history = 'variable history',
missing_value = -99,
)
for time in [x * 1800./ 86400 for x in range(48)]:
cmor.write(varid, values, time_vals = [time])
return varid
def cmor_define_and_write(values, axes):
table = 'CMIP5_cfSites'
cmor.load_table(table)
axis_ids = list()
for axis in axes:
axis_id = cmor.axis(**axis)
axis_ids.append(axis_id)
igrid = cmor.grid([axis_ids[1]], [0.], [0.])
cmor.zfactor(axis_ids[2], 'b', axis_ids=[axis_ids[2]],
zfactor_values=range(2),
zfactor_bounds=[[x - 0.5, x + 0.5] for x in range(2)])
cmor.zfactor(axis_ids[2], 'orog', 'm', axis_ids=[igrid],
zfactor_values=[0])
ids_for_var = [axis_ids[0], igrid, axis_ids[2]]
varid = cmor.variable('tnhus',
's-1',
ids_for_var,
history='variable history',
missing_value=-99,
)
for time in [x * 1800. / 86400 for x in range(48)]:
time += 1. / 3600. / 24.
tr = cdtime.reltime(time, axes[0]["units"])
print("Writing: %.03f" % time, "|", tr.tocomp(cdtime.Calendar360), "|", tr.tocomp())
cmor.write(varid, values, time_vals=[time])
return varid
def cmor_define_and_write(values, axes):
table = 'CMIP6_CFsubhr.json'
tid1 = cmor.load_table(table)
site_axis_id = cmor.axis(**axes[1])
time_axis_id = cmor.axis(**axes[0])
table2 = 'CMIP6_grids.json'
tid2 = cmor.load_table(table2)
gid = cmor.grid([
site_axis_id,
],
latitude=numpy.array([
-20,
]),
longitude=numpy.array([
150,
]))
axis_ids = [time_axis_id, gid]
cmor.set_table(tid1)
varid = cmor.variable('rlut',
'W m-2',
axis_ids,
history='variable history',
missing_value=-99,
positive='up')
cmor.write(varid, values, time_vals=[15])
def test_lat_lon_grid(self):
axis_ids = [1, 2]
for atype in (numpy.array, list, tuple):
lats = atype(numpy.arange(2 * 3).reshape(2, 3) + 0.1)
lons = atype(numpy.arange(2 * 3).reshape(2, 3) - 0.1)
args = grid(axis_ids, latitude=lats, longitude=lons)
self.assert_on_axis_id_args(axis_ids, args)
self.assert_on_coordiantes(lats, lons, args)
self.assert_on_default_vertices(args)
def test_lat_lon_grid(self):
axis_ids = [1, 2]
for atype in (numpy.array, list, tuple):
lats = atype(numpy.arange(2*3).reshape(2,3) + 0.1)
lons = atype(numpy.arange(2*3).reshape(2,3) - 0.1)
args = grid(axis_ids, latitude = lats, longitude = lons)
self.assert_on_axis_id_args(axis_ids, args)
self.assert_on_coordiantes(lats, lons, args)
self.assert_on_default_vertices(args)
def testCMIP6(self):
# -------------------------------------------
# Run CMOR using unicode strings
# -------------------------------------------
try:
cmor.setup(inpath=u'Tables', netcdf_file_action=cmor.CMOR_REPLACE, logfile=self.tmpfile)
cmor.dataset_json(u"Test/CMOR_input_example.json")
cmor.load_table(u"CMIP6_CFsubhr.json")
axes = [{u'table_entry': u'time1',
u'units': u'days since 2000-01-01 00:00:00',
},
{u'table_entry': u'site',
u'units': u'',
u'coord_vals': [0]},
{u'table_entry': u'hybrid_height',
u'units': u'm',
u'coord_vals': numpy.array(range(2), dtype=numpy.float64),
u'cell_bounds': [[x, x + 1] for x in range(2)],
},
]
values = numpy.array([0.5, 0.5], numpy.float32)
axis_ids = list()
for axis in axes:
axis_id = cmor.axis(**axis)
axis_ids.append(axis_id)
igrid = cmor.grid([axis_ids[1]], [0.], [0.])
cmor.zfactor(axis_ids[2], u'b', axis_ids=[axis_ids[2]],
zfactor_values=numpy.array(range(2), dtype=numpy.float64),
zfactor_bounds=[[x, x + 1] for x in range(2)])
cmor.zfactor(axis_ids[2], u'orog', u'm', axis_ids=[igrid],
zfactor_values=[0.] )
ids_for_var = [axis_ids[0], igrid, axis_ids[2]]
varid = cmor.variable(u'tnhus',
u's-1',
ids_for_var,
history=u'variable history',
missing_value=-99,
)
for time in [x * 1800. / 86400 for x in range(48)]:
cmor.write(varid, values, time_vals=[time])
self.delete_files += [cmor.close(varid, True)]
cmor.close()
except BaseException:
raise
def create_grid(self, gridname, axes, createfunc):
if (gridname in self.grids): return self.grids[gridname]
self.load_table("grids")
d = createfunc()
axisids = {}
for axis in axes:
axisinfo = d[axis]
axid = cmor.axis(axisinfo["name"], axisinfo["units"],
axisinfo["values"])
axisids.append(axid)
self.grids[gridname] = cmor.grid(axis_ids=axisids,
latitude=d["lats"],
longitude=d["lons"],
latitude_vertices=d["lat_bounds"],
longitude_vertices=d["lon_bounds"])
return self.grids[gridname]
def cmor_define_and_write(values, axes):
table = 'CMIP5_cfSites'
cmor.load_table(table)
site_axis_id = cmor.axis(**axes[1])
time_axis_id = cmor.axis(**axes[0])
gid = cmor.grid([site_axis_id,],latitude=numpy.array([-20,]),longitude=numpy.array([150,]))
axis_ids = [time_axis_id,gid]
varid = cmor.variable('rlut',
'W m-2',
axis_ids,
history = 'variable history',
missing_value = -99,
positive = 'up'
)
cmor.write(varid, values, time_vals = [15])
def cmor_define_and_write(values, axes):
table = 'CMIP6_CFsubhr.json'
tid1 = cmor.load_table(table)
site_axis_id = cmor.axis(**axes[1])
time_axis_id = cmor.axis(**axes[0])
table2 = 'CMIP6_grids.json'
tid2 = cmor.load_table(table2)
gid = cmor.grid([site_axis_id, ], latitude=numpy.array(
[-20, ]), longitude=numpy.array([150, ]))
axis_ids = [time_axis_id, gid]
cmor.set_table(tid1)
varid = cmor.variable('rlut',
'W m-2',
axis_ids,
history='variable history',
missing_value=-99,
positive='up'
)
cmor.write(varid, values, time_vals=[15])
zlevs = 480.*numpy.arange(0,n_lev)+240.
zbnds = numpy.zeros((n_lev,2))
zbnds[:,0]=zlevs-240.
zbnds[:,1]=zlevs+240.
# creates 1 degree grid
cmor.load_table("CMIP6_cf3hr.json")
ialt40 = cmor.axis("alt40",units="m",coord_vals=zlevs,cell_bounds=zbnds)
itm = cmor.axis("time1",units="months since 2000")
iloc = cmor.axis("location",units="1",coord_vals=numpy.arange(2))
igrid = cmor.grid(axis_ids=[iloc,itm])
print igrid
ilat = cmor.time_varying_grid_coordinate(igrid,table_entry='latitude',units='degrees_north')
ilon = cmor.time_varying_grid_coordinate(igrid,table_entry='longitude',units='degrees_east')
#cmor.load_table("Tables/CMIP6_cf3hr.json")
ivar = cmor.variable("clcalipso",axis_ids=[igrid,ialt40],units="%")
ierr =cmor.write(ivar,numpy.ones((2,3,n_lev)),time_vals=numpy.arange(3))
ierr =cmor.write(ilat,-90.*numpy.ones((2,3,n_lev)),time_vals=numpy.arange(3),store_with=ivar)
ierr =cmor.write(ilon,180.*numpy.ones((2,3,n_lev)),time_vals=numpy.arange(3),store_with=ivar)
error_flag = cmor.close()
cmor.set_cur_dataset_attribute('location', site_location[site_fac])
cmor.set_cur_dataset_attribute('version', version)
# read cmor table for the observational station data
table = 'obsSites'
cmor.load_table('./' + table)
# define the 'site' dimension, it needs also a grid definition
nsites = 1
isite = cmor.axis(table_entry="site",
coord_vals=numpy.arange(nsites),
units="1")
igrid = cmor.grid(axis_ids=(isite, ),
latitude=numpy.array([
lat,
]),
longitude=numpy.array([
lon,
]))
#cmor.grid.__doc__
# setup time dimension
itim = cmor.axis(table_entry='time1',
units=time_units,
coord_vals=time,
cell_bounds=time_bounds)
#var_time_bnds_id = cmor.variable('time_bnds',units_time,[itim,igrid])
#cmor.set_variable_attribute(var_time_bnds_id,'long_name','Time range for the hourly averages')
#fid.listvariables()
def testCMIP6(self):
# Create x and y coordinates and bounds.
#
coordVals = numpy.arange(-533750.0, 533750.0 +
2500.0, 2500.0, numpy.float32)
coordBnds = numpy.zeros((coordVals.shape[0], 2), numpy.float32)
coordBnds[:, 0] = coordVals - 1250.0
coordBnds[:, 1] = coordVals + 1250.0
# Create longitude and latitude fields for a polar stereographic projection.
#
xgrid, ygrid = numpy.broadcast_arrays(
numpy.expand_dims(
coordVals, 0), numpy.expand_dims(
coordVals, 1))
rhogrid = numpy.sqrt(xgrid**2 + ygrid**2)
cgrid = 2.0 * numpy.arctan((0.5 / 6378137.0) * rhogrid)
latgrid = (180.0 / 3.141592654) * numpy.arcsin(numpy.cos(cgrid))
longrid = (180.0 / 3.141592654) * numpy.arctan2(xgrid, -ygrid)
# Set up CMOR with information from the CMOR config dictionary.
#
cmor.setup("Tables", netcdf_file_action=cmor.CMOR_REPLACE_4)
# Create the output CMOR dataset using the output configuration.
#
cmor.dataset_json("Test/common_user_input.json")
# Load the grid table.
#
cmor_table_obj = cmor.load_table("CMIP6_grids.json")
# Create ygre and xgre axes.
#
entry = {
'table_entry': 'y',
'units': 'm',
'coord_vals': coordVals,
'cell_bounds': coordBnds}
axis_ygre = cmor.axis(**entry)
entry = {
'table_entry': 'x',
'units': 'm',
'coord_vals': coordVals,
'cell_bounds': coordBnds}
axis_xgre = cmor.axis(**entry)
# Create the grid
#
grid_id = cmor.grid(
axis_ids=[
axis_ygre,
axis_xgre],
latitude=latgrid,
longitude=longrid)
# Set the CMOR grid mapping.
#
# mapnm = 'polar_stereographic'
param_dict = {
'latitude_of_projection_origin': [90.0, 'degrees_north'],
'straight_vertical_longitude_from_pole': [135.0, 'degrees_east'],
'standard_parallel': [70.0, 'degrees_north'],
'false_northing': [0.0, 'meters'],
'false_easting': [0.0, 'meters']
}
ierr = cmor.set_grid_mapping(
grid_id, 'polar_stereographic', param_dict)
self.assertEqual(ierr, 0)
axes[1] = cmor.axis(
table_entry='j_index',
length=nlat,
coord_vals=numpy.arange(0, nlat, 1, numpy.float32),
units='1')
olat_val = f("grid_center_lat").filled().astype('f')
olon_val = f("grid_center_lon").filled().astype('f')
bnds_olat = f("grid_corner_lat").filled().astype('f')
bnds_olon = f("grid_corner_lon").filled().astype('f')
grid_id = cmor.grid(
axis_ids=axes,
latitude=olat_val,
longitude=olon_val,
latitude_vertices=bnds_olat,
longitude_vertices=bnds_olon)
cmor.set_table(ntables[1])
ntimes = 12
tim_id = cmor.axis(table_entry="time",
units="months since 2010")
time_vals = numpy.arange(ntimes).astype('f')
bnds_time = numpy.arange(ntimes + 1).astype('f')
var_ids = cmor.variable(
table_entry="sic",
def test_error_rank_axis_ids(self):
try:
grid([[1], [2]])
self.fail('should raise exception')
except Exception, e:
self.assertEquals('error axes list/array must be 1D', str(e))
def test_pass_only_axis_ids(self):
for axis_ids in ([1, 2], numpy.array([1, 2])):
args = grid(axis_ids)
self.assert_on_axis_id_args(axis_ids, args)
self.assert_on_default_coordinates(args)
self.assert_on_default_vertices(args)
print 'ok: created height axis', zaxis_id
# Create zfactors for b and orog for hybrid height axis.
# Where do these get used, if anywhere?
bfact_id = cmor.zfactor(zaxis_id,
'b',
'1', [zaxis_id],
'd',
zfactor_values=[1.0],
zfactor_bounds=[0.0, 2.0])
print 'ok: created b zfactors'
# Create grid object to link site-dimensioned variables to (lat,long).
# Need to make CMIP6_grids the current MIP table for this to work.
table_id = cmor.load_table('CMIP6_grids.json')
gaxis_id = cmor.grid([saxis_id], site_lats, site_lons)
print 'ok: created site grid'
# Create CMOR variable for cloud area fraction: MIP name = 'cl', STASH = m01s02i261*100
table_id = cmor.load_table('CMIP6_cfSites.json')
var_id = cmor.variable('cl',
'%', [taxis_id, gaxis_id, zaxis_id],
type='f',
missing_value=-99.0,
original_name='STASH m01s02i261*100')
print 'ok: created variable for "cl"'
ofact_id = cmor.zfactor(zaxis_id,
'orog',
'm', [gaxis_id],
'd',
x=f['x'][:]
y=f['y'][:]
lon_coords=fg['lon'][0,:]
lat_coords=fg['lat'][0,:]
myaxes[0] = cmor.axis(table_entry = 'y',
units = 'm',
coord_vals = y)
myaxes[1] = cmor.axis(table_entry = 'x',
units = 'm',
coord_vals = x)
grid_id = cmor.grid(axis_ids = myaxes[:2],
latitude = lat_coords,
longitude = lon_coords)
print 'got grid_id:',grid_id
myaxes[2] = grid_id
mapnm = 'polar_stereographic'
params = [ "standard_parallel",
"latitude_of_projection_origin",
"false_easting",
"false_northing",
"straight_vertical_longitude_from_pole",
"scale_factor_at_projection_origin"]
punits = ["","","","","","" ]
pvalues = [71.,90.,0.,0.,-39., 1. ]
def testUnicode():
# -------------------------------------------
# Run CMOR using unicode strings
# -------------------------------------------
cmor.setup(inpath=u'Tables', netcdf_file_action=cmor.CMOR_REPLACE)
cmor.dataset_json(u"Test/CMOR_input_example.json")
cmor.load_table(u"CMIP6_CFsubhr.json")
axes = [
{
u'table_entry': u'time1',
u'units': u'days since 2000-01-01 00:00:00',
},
{
u'table_entry': u'site',
u'units': u'',
u'coord_vals': [0]
},
{
u'table_entry': u'hybrid_height',
u'units': u'm',
u'coord_vals': numpy.array(range(2), dtype=numpy.float64),
u'cell_bounds': [[x, x + 1] for x in range(2)],
},
]
values = numpy.array([0.5, 0.5], numpy.float32)
axis_ids = list()
for axis in axes:
axis_id = cmor.axis(**axis)
axis_ids.append(axis_id)
igrid = cmor.grid([axis_ids[1]], [0.], [0.])
cmor.zfactor(axis_ids[2],
u'b',
axis_ids=[axis_ids[2]],
zfactor_values=numpy.array(range(2), dtype=numpy.float64),
zfactor_bounds=[[x - 0.5, x + 0.5] for x in range(2)])
cmor.zfactor(axis_ids[2],
u'orog',
u'm',
axis_ids=[igrid],
zfactor_values=[0.])
ids_for_var = [axis_ids[0], igrid, axis_ids[2]]
varid = cmor.variable(
u'tnhus',
u's-1',
ids_for_var,
history=u'variable history',
missing_value=-99,
)
for time in [x * 1800. / 86400 for x in range(48)]:
cmor.write(varid, values, time_vals=[time])
cmor.close()
def test_pass_only_axis_ids(self):
for axis_ids in ([1,2], numpy.array([1,2])):
args = grid(axis_ids)
self.assert_on_axis_id_args(axis_ids, args)
self.assert_on_default_coordinates(args)
self.assert_on_default_vertices(args)
cmor.set_table(tables[0])
x,y,lon_coords,lat_coords,lon_vertices,lat_vertices = gen_irreg_grid(lon,lat)
print lon_vertices.shape,lat_vertices.shape,x.shape,y.shape
myaxes[1] = cmor.axis(table_entry = 'y',
units = 'm',
coord_vals = y)
myaxes[0] = cmor.axis(table_entry = 'x',
units = 'm',
coord_vals = x)
print 'lons:',lon_vertices.shape,lon_coords.shape
grid_id = cmor.grid(axis_ids = myaxes[:2],
latitude = lat_coords,
longitude = lon_coords,
latitude_vertices = lat_vertices,
longitude_vertices = lon_vertices)
print 'got grid_id:',grid_id
myaxes[2] = grid_id
## mapnm = 'lambert_conformal_conic'
## params = [ "standard_parallel1",
## "longitude_of_central_meridian","latitude_of_projection_origin",
## "false_easting","false_northing","standard_parallel2" ]
## punits = ["","","","","","" ]
## pvalues = [-20.,175.,13.,8.,0.,20. ]
## cmor.set_grid_mapping(grid_id=myaxes[2],
## mapping_name = mapnm,
## parameter_names = params,
## parameter_values = pvalues,
def test_error_rank_axis_ids(self):
try:
grid([[1], [2]])
self.fail('should raise exception')
except Exception, e:
self.assertEquals('error axes list/array must be 1D', str(e))
fg = cdms2.open("~/Downloads/Greenland_5km_v1.1.nc")
x = f['x'][:]
y = f['y'][:]
lon_coords = fg['lon'][0, :]
lat_coords = fg['lat'][0, :]
myaxes[0] = cmor.axis(table_entry='y',
units='m',
coord_vals=y)
myaxes[1] = cmor.axis(table_entry='x',
units='m',
coord_vals=x)
grid_id = cmor.grid(axis_ids=myaxes[:2],
latitude=lat_coords,
longitude=lon_coords)
print('got grid_id:', grid_id)
myaxes[2] = grid_id
mapnm = 'polar_stereographic'
params = ["standard_parallel",
"latitude_of_projection_origin",
"false_easting",
"false_northing",
"straight_vertical_longitude_from_pole",
"scale_factor_at_projection_origin"]
punits = ["", "", "", "", "", ""]
pvalues = [71., 90., 0., 0., -39., 1.]
saxis_id = cmor.axis('site', units='1', coord_vals=[1,2,3])
print 'ok: created site axis',saxis_id
zaxis_id = cmor.axis('hybrid_height', units='m', coord_vals=[1.0], cell_bounds=[0.0,2.0])
print 'ok: created height axis',zaxis_id
# Create zfactors for b and orog for hybrid height axis.
# Where do these get used, if anywhere?
bfact_id = cmor.zfactor(zaxis_id, 'b', '1', [zaxis_id], 'd', zfactor_values=[1.0],
zfactor_bounds=[0.0,2.0])
print 'ok: created b zfactors'
# Create grid object to link site-dimensioned variables to (lat,long).
# Need to make CMIP6_grids the current MIP table for this to work.
table_id = cmor.load_table('CMIP6_grids.json')
gaxis_id = cmor.grid([saxis_id], site_lats, site_lons)
print 'ok: created site grid'
# Create CMOR variable for cloud area fraction: MIP name = 'cl', STASH = m01s02i261*100
table_id = cmor.load_table('CMIP6_cfSites.json')
var_id = cmor.variable('cl', '%', [taxis_id, gaxis_id, zaxis_id], type='f',
missing_value=-99.0, original_name='STASH m01s02i261*100')
print 'ok: created variable for "cl"'
ofact_id = cmor.zfactor(zaxis_id, 'orog', 'm', [gaxis_id], 'd',
zfactor_values=[123.0])
print 'ok: created orog zfactors'
# Write some data to this variable. First convert raw data to numpy arrays.
shape = (1, 3, 1)
data = numpy.array([10, 20, 30], dtype=numpy.float32)
data = data.reshape(shape)
def write_grid(grid, tasks):
global grid_ids_, lat_axes_
nx = grid.lons.shape[0]
ny = grid.lons.shape[1]
if ny == 1:
if nx == 1:
log.error(
"The grid %s consists of a single point which is not supported, dismissing variables %s"
% (grid.name, ','.join([
t.target.variable + " in " + t.target.table for t in tasks
])))
return
for task in tasks:
dims = getattr(task.target, "space_dims", "")
if "longitude" in dims:
log.error(
"Variable %s in %s has longitude dimension, but this is absent in the ocean output file of "
"grid %s" %
(task.target.variable, task.target.table, grid.name))
task.set_failed()
continue
latnames = {"latitude", "gridlatitude"}
latvars = list(set(dims).intersection(set(latnames)))
if not any(latvars):
log.error(
"Variable %s in %s has no (grid-)latitude defined where its output grid %s does, dismissing "
"it" %
(task.target.variable, task.target.table, grid.name))
task.set_failed()
continue
if len(latvars) > 1:
log.error(
"Variable %s in %s with double-latitude dimensions %s is not supported"
% (task.target.variable, task.target.table, str(dims)))
task.set_failed()
continue
key = (task.target.table, grid.name, latvars[0])
if key not in lat_axes_.keys():
cmor.load_table(table_root_ + "_" + task.target.table +
".json")
lat_axis_id = cmor.axis(table_entry=latvars[0],
coord_vals=grid.lats[:, 0],
units="degrees_north",
cell_bounds=grid.vertex_lats)
lat_axes_[key] = lat_axis_id
else:
lat_axis_id = lat_axes_[key]
setattr(task, "grid_id", lat_axis_id)
else:
if grid.name not in grid_ids_:
cmor.load_table(table_root_ + "_grids.json")
i_index_id = cmor.axis(table_entry="j_index",
units="1",
coord_vals=numpy.array(range(1, nx + 1)))
j_index_id = cmor.axis(table_entry="i_index",
units="1",
coord_vals=numpy.array(range(1, ny + 1)))
grid_id = cmor.grid(axis_ids=[i_index_id, j_index_id],
latitude=grid.lats,
longitude=grid.lons,
latitude_vertices=grid.vertex_lats,
longitude_vertices=grid.vertex_lons)
grid_ids_[grid.name] = grid_id
else:
grid_id = grid_ids_[grid.name]
for task in tasks:
dims = getattr(task.target, "space_dims", [])
if "latitude" in dims and "longitude" in dims:
setattr(task, "grid_id", grid_id)
else:
log.error(
"Variable %s in %s has output on a 2d horizontal grid, but its requested dimensions are %s"
% (task.target.variable, task.target.table, str(dims)))
task.set_failed()
tables.append(cmor.load_table("CMIP6_Omon.json"))
print 'Tables ids:', tables
cmor.set_table(tables[0])
x, y, lon_coords, lat_coords, lon_vertices, lat_vertices = gen_irreg_grid(
lon, lat)
print lon_vertices.shape, lat_vertices.shape, x.shape, y.shape
myaxes[1] = cmor.axis(table_entry='y', units='m', coord_vals=y)
myaxes[0] = cmor.axis(table_entry='x', units='m', coord_vals=x)
print 'lons:', lon_vertices.shape, lon_coords.shape
grid_id = cmor.grid(axis_ids=myaxes[:2],
latitude=lat_coords,
longitude=lon_coords,
latitude_vertices=lat_vertices,
longitude_vertices=lon_vertices)
print 'got grid_id:', grid_id
myaxes[2] = grid_id
## mapnm = 'lambert_conformal_conic'
# params = [ "standard_parallel1",
# "longitude_of_central_meridian","latitude_of_projection_origin",
# "false_easting","false_northing","standard_parallel2" ]
## punits = ["","","","","","" ]
## pvalues = [-20.,175.,13.,8.,0.,20. ]
# cmor.set_grid_mapping(grid_id=myaxes[2],
## mapping_name = mapnm,
## parameter_names = params,
## parameter_values = pvalues,
cmor.set_cur_dataset_attribute('agency','DOE')
cmor.set_cur_dataset_attribute('obs_project','ARM')
cmor.set_cur_dataset_attribute('obs_type','in-situ_stations')
cmor.set_cur_dataset_attribute('instrument','cmbe')
cmor.set_cur_dataset_attribute('location',site_location[site_fac])
cmor.set_cur_dataset_attribute('version',version)
# read cmor table for the observational station data
table='obsSites'
cmor.load_table('./' + table )
# define the 'site' dimension, it needs also a grid definition
nsites = 1
isite = cmor.axis(table_entry="site",coord_vals=numpy.arange(nsites),units="1")
igrid = cmor.grid(axis_ids=(isite,),latitude=numpy.array([lat,]),longitude=numpy.array([lon,]))
#cmor.grid.__doc__
# setup time dimension
itim = cmor.axis(
table_entry='time1',
units=time_units,
coord_vals=time,
cell_bounds=time_bounds)
#var_time_bnds_id = cmor.variable('time_bnds',units_time,[itim,igrid])
#cmor.set_variable_attribute(var_time_bnds_id,'long_name','Time range for the hourly averages')
#fid.listvariables()
vars_in = ['p_sfc', 'u_sfc','v_sfc','T_sfc','wspd_sfc','rh_sfc' ]
vars_out = ['ps', 'uas', 'vas', 'tas', 'sfcWind', 'hurs' ]
