def map2four(data,target,regridTool='regrid2'):
lons=target.getLongitude()
lats=target.getLatitude()
lonso=cdms2.createAxis(lons[::2])
lonse=cdms2.createAxis(lons[1::2])
latso=cdms2.createAxis(lats[::2])
latse=cdms2.createAxis(lats[1::2])
oo=cdms2.createRectGrid(latso,lonso)
oe=cdms2.createRectGrid(latso,lonse)
eo=cdms2.createRectGrid(latse,lonso)
ee=cdms2.createRectGrid(latse,lonse)
doo = data.regrid(oo,regridTool=regridTool)
doe = data.regrid(oe,regridTool=regridTool)
deo = data.regrid(eo,regridTool=regridTool)
dee = data.regrid(ee,regridTool=regridTool)
out=MV2.zeros(data.shape,dtype='f')
out[::2,::2]=doo
out[::2,1::2]=doe
out[1::2,::2]=deo
out[1::2,1::2]=dee
out.id=data.id
out.setAxisList((lats,lons))
return out
def map2four(data, target, regridTool='regrid2'):
lons = target.getLongitude()
lats = target.getLatitude()
lonso = cdms2.createAxis(lons[::2])
lonse = cdms2.createAxis(lons[1::2])
latso = cdms2.createAxis(lats[::2])
latse = cdms2.createAxis(lats[1::2])
oo = cdms2.createRectGrid(latso, lonso)
oe = cdms2.createRectGrid(latso, lonse)
eo = cdms2.createRectGrid(latse, lonso)
ee = cdms2.createRectGrid(latse, lonse)
doo = data.regrid(oo, regridTool=regridTool)
doe = data.regrid(oe, regridTool=regridTool)
deo = data.regrid(eo, regridTool=regridTool)
dee = data.regrid(ee, regridTool=regridTool)
out = MV2.zeros(data.shape, dtype='f')
out[::2, ::2] = doo
out[::2, 1::2] = doe
out[1::2, ::2] = deo
out[1::2, 1::2] = dee
out.id = data.id
out.setAxisList((lats, lons))
return out
def test_003_gridLatitudeDifferent(self):
grid1 = cdms.createRectGrid(self.y, self.x, 'yx')
y2 = cdms.createAxis([8.0, 10.0], id='y')
grid2 = cdms.createRectGrid(y2, self.x, 'yx')
v1 = cdms.createVariable(self.arr, axes=[self.x, self.y], grid=grid1)
v2 = cdms.createVariable(self.arr, axes=[self.x, y2], grid=grid2)
nt.assert_false(var_utils.areGridsEqual(v1, v2))
def get(self):
value = self.grid
if value is None:
if not self.latitude.n is None: # Ok we seem to have grid definition
if self.latitude.type == 1: # Gaussian
if self.longitude.first is None:
value = cdms2.createGaussianGrid(self.latitude.n)
else:
value = cdms2.createGaussianGrid(
self.latitude.n, self.longitude.first)
elif self.latitude.type == 0: # Uniform
value = cdms2.createUniformGrid(self.latitude.first,
self.latitude.n,
self.latitude.delta,
self.longitude.first,
self.longitude.n,
self.longitude.delta)
elif self.latitude.type == 2: # Equalarea
lat = cdms2.createEqualAreaAxis(self.latitude.n)
lon = cdms2.createUniformLongitude(self.longitude.first,
self.longitude.n,
self.longitude.delta)
value = cdms2.createGenericGrid(lat[:], lon[:],
lat.getBounds(),
lon.getBounds())
elif not self.file is None:
f = cdms2.open(self.file)
value = f[self.var].getGrid()
## Ok temporary stuff to try to be able to close the file
lat = value.getLatitude()
lon = value.getLongitude()
value = cdms2.createRectGrid(lat, lon)
f.close()
return value
def coarsenVars( filen, newfilen ):
"""Reads a NetCDF file, filen, and writes a new file, newfilen, containing all its variables,
but regridded in its horizontal axeseb to a 12x14 (15 degree) lat-lon grid.
"""
latbnds = numpy.linspace(-90,90,nlat)
lat = 0.5*( latbnds[1:]+latbnds[:-1] )
lataxis=cdms2.createAxis( lat, id='lat' )
lonbnds = numpy.linspace(0,360,nlon)
lon = 0.5*( lonbnds[1:]+lonbnds[:-1] )
lonaxis=cdms2.createAxis( lon, id='lon' )
newgrid=cdms2.createRectGrid(lataxis, lonaxis)
f = cdms2.open(filen)
nf = cdms2.open(newfilen,'w')
for varn in f.variables.keys():
print "working on",varn
var = f(varn)
if var.getGrid() is None:
print varn,"has no grid!"
continue
newvar = var.regrid(newgrid) # works even if var has levels
newvar.id = var.id # before, id was var.id+'_CdmaRegrid'
nf.write(newvar)
for attr in f.attributes.keys():
setattr(nf,attr,getattr(f,attr))
if hasattr(nf,'history'):
nf.history = nf.history + '; some variables deleted'
f.close()
nf.close()
def get(self):
value=self.grid
if value is None:
if not self.latitude.n is None: # Ok we seem to have grid definition
if self.latitude.type == 1: # Gaussian
if self.longitude.first is None:
value=cdms2.createGaussianGrid(self.latitude.n)
else:
value=cdms2.createGaussianGrid(self.latitude.n,self.longitude.first)
elif self.latitude.type == 0: # Uniform
value=cdms2.createUniformGrid(self.latitude.first,
self.latitude.n,
self.latitude.delta,
self.longitude.first,
self.longitude.n,
self.longitude.delta)
elif self.latitude.type== 2: # Equalarea
lat=cdms2.createEqualAreaAxis(self.latitude.n)
lon=cdms2.createUniformLongitude(self.longitude.first,
self.longitude.n,
self.longitude.delta)
value=cdms2.createGenericGrid(lat[:],lon[:],lat.getBounds(),lon.getBounds())
elif not self.file is None:
f=cdms2.open(self.file)
value=f[self.var].getGrid()
## Ok temporary stuff to try to be able to close the file
lat=value.getLatitude()
lon=value.getLongitude()
value=cdms2.createRectGrid(lat,lon)
f.close()
return value
def test_005_gridsAreTheSame(self):
grid1 = cdms.createRectGrid(self.y, self.x, 'yx')
v1 = cdms.createVariable(self.arr, axes=[self.x, self.y], grid=grid1)
v2 = cdms.createVariable(self.arr, axes=[self.x, self.y], grid=grid1)
nt.assert_true(var_utils.areGridsEqual(v1, v2))
nt.assert_true(var_utils.areGridsEqual(v2, v1))
def test_004_oneGridMissing(self):
grid1 = cdms.createRectGrid(self.y, self.x, 'yx')
v1 = cdms.createVariable(self.arr, axes=[self.x, self.y], grid=grid1)
v2 = cdms.createVariable(self.arr)
nt.assert_false(var_utils.areGridsEqual(v1, v2))
nt.assert_false(var_utils.areGridsEqual(v2, v1))
def test_005_areTheSame(self):
grid = cdms.createRectGrid(self.y, self.x, 'yx')
v1 = cdms.createVariable(self.arr,
axes=[self.x, self.y],
grid=grid,
attributes={'name': 'v1'})
v2 = cdms.createVariable(self.arr,
axes=[self.x, self.y],
grid=grid,
attributes={'name': 'v1'})
nt.assert_true(var_utils.areVariablesEqual(v1, v2))
def test3_srcGridHasNoBounds(self):
"""
Test that regridding will automatically choose libcf when there are
no bounds in the src grid
"""
toolsAndMethods = {
'libcf': [
'linear',
],
'esmf': ['conserve', 'patch', 'linear'],
}
f = cdms2.open(cdat_info.get_sampledata_path() + '/swan.four.nc')
vari = f('HS')
gridi = vari.getGrid()
lati = vari.getLatitude()
loni = vari.getLongitude()
f.close()
nyo, nxo = 100, 200
ymin, ymax = lati.min(), lati.max()
xmin, xmax = loni.min(), loni.max()
dy, dx = (ymax - ymin) / float(nyo), (xmax - xmin) / float(nxo)
yo = numpy.array([ymin + dy * (j + 0.5) for j in range(nyo)])
xo = numpy.array([xmin + dx * (i + 0.5) for i in range(nxo)])
lato = cdms2.createAxis(yo)
lato.designateLatitude()
lato.units = 'degrees_north'
lono = cdms2.createAxis(xo)
lono.designateLongitude()
lono.units = 'degrees_east'
grido = cdms2.createRectGrid(lato, lono)
for tool in toolsAndMethods:
for met in toolsAndMethods[tool]:
t0 = time()
print tool.upper(), met, ':'
diag = {'numDstPoints': None, 'numValid': None}
# although the user may choose esmf, we expect to interpolate
# using libcf as the source grid has no bounds in this case
varo = vari.regrid(grido,
regridMethod=met,
regridTool=tool,
coordSys='cart',
nitermax=10,
tolpos=0.01,
diag=diag)
# make sure libcf was selected
self.assertEqual(diag['regridTool'], 'libcf')
self.assertEqual(diag['regridMethod'], 'linear')
def test3_srcGridHasNoBounds(self):
"""
Test that regridding will automatically choose libcf when there are
no bounds in the src grid
"""
toolsAndMethods = {
'libcf': ['linear',],
'esmf': ['conserve', 'patch', 'linear'],
}
f = cdms2.open(sys.prefix + '/sample_data/swan.four.nc')
vari = f('HS')
gridi = vari.getGrid()
lati = vari.getLatitude()
loni = vari.getLongitude()
f.close()
nyo, nxo = 100, 200
ymin, ymax = lati.min(), lati.max()
xmin, xmax = loni.min(), loni.max()
dy, dx = (ymax - ymin)/float(nyo), (xmax - xmin)/float(nxo)
yo = numpy.array([ymin + dy*(j + 0.5) for j in range(nyo)])
xo = numpy.array([xmin + dx*(i + 0.5) for i in range(nxo)])
lato = cdms2.createAxis(yo)
lato.designateLatitude() ; lato.units = 'degrees_north'
lono = cdms2.createAxis(xo)
lono.designateLongitude() ; lono.units= 'degrees_east'
grido = cdms2.createRectGrid(lato, lono)
for tool in toolsAndMethods:
for met in toolsAndMethods[tool]:
t0 = time()
print tool.upper(), met, ':'
diag = {'numDstPoints': None, 'numValid': None}
# although the user may choose esmf, we expect to interpolate
# using libcf as the source grid has no bounds in this case
varo = vari.regrid(grido,
regridMethod = met, regridTool = tool,
coordSys = 'cart',
nitermax = 10, tolpos = 0.01,
diag = diag)
# make sure libcf was selected
self.assertEqual(diag['regridTool'], 'libcf')
self.assertEqual(diag['regridMethod'], 'linear')
def test_001_gridTypesDifferent(self):
latArr = N.array([[56., 58.], [54., 56.], [52., 54.]])
lonArr = N.array([[-14., -10.], [-12., -8.], [-10., -6.]])
lon = cdms.coord.TransientAxis2D(lonArr, axes=[self.x, self.y])
lon.id = 'lon'
lat = cdms.coord.TransientAxis2D(latArr, axes=[self.x, self.y])
lat.id = 'lat'
grid1 = cdms.hgrid.TransientCurveGrid(lat, lon)
#adding the x and y axis to the transient grid changes them so you need to retrieve them from the grid to make sure they match
x, y = grid1.getAxisList()
grid2 = cdms.createRectGrid(y, x, 'yx')
v1 = cdms.createVariable(self.arr, axes=[x, y], grid=grid1)
v2 = cdms.createVariable(self.arr, axes=[x, y], grid=grid2)
nt.assert_false(var_utils.areGridsEqual(v1, v2))
def test0(self):
"""
Test from Stephane Raynaud with a few modifications
"""
toolsAndMethods = {
'libcf': ['linear'],
'esmf': ['linear', 'patch', 'conserve'],
}
f = cdms2.open(cdat_info.get_sampledata_path() + '/swan.four.nc')
vari = f('HS')
f.close()
gridi = vari.getGrid()
# add bounds to input grid
lati = vari.getLatitude()
loni = vari.getLongitude()
xib, yib = bounds2d(loni, lati)
loni.setBounds(xib)
lati.setBounds(yib)
self.assertNotEqual(gridi.getLatitude().getBounds(), None)
self.assertNotEqual(gridi.getLongitude().getBounds(), None)
# output grid
nyo, nxo = 100, 200
ymin, ymax = lati.min(), lati.max()
xmin, xmax = loni.min(), loni.max()
dy, dx = (ymax - ymin) / float(nyo), (xmax - xmin) / float(nxo)
yo = numpy.array([ymin + dy * (j + 0.5) for j in range(nyo)])
xo = numpy.array([xmin + dx * (i + 0.5) for i in range(nxo)])
lato = cdms2.createAxis(yo)
lato.designateLatitude()
lato.units = 'degrees_north'
lono = cdms2.createAxis(xo)
lono.designateLongitude()
lono.units = 'degrees_east'
grido = cdms2.createRectGrid(lato, lono)
self.assertNotEqual(grido.getLatitude().getBounds(), None)
self.assertNotEqual(grido.getLongitude().getBounds(), None)
for tool in toolsAndMethods:
for met in toolsAndMethods[tool]:
t0 = time()
print tool.upper(), met, ':'
diag = {}
varo = vari.regrid(grido,
regridMethod=met,
regridTool=tool,
coordSys='cart',
nitermax=10,
diag=diag)
print 'diag = ', diag
met2 = diag['regridMethod']
tool2 = diag['regridTool']
self.assertEqual(met, met2)
self.assertEqual(tool2, tool)
self.assertGreater(varo.min(), -0.01)
dt = time() - t0
print tool.upper(), met, ':', dt, 'seconds'
if PLOT:
pylab.figure(figsize=(12, 6))
pylab.subplots_adjust(right=0.9)
pylab.subplot(121)
pylab.pcolor(loni[:],
lati[:],
vari[0].asma(),
vmin=0,
vmax=2.5)
pylab.axis([xmin, xmax, ymin, ymax])
pylab.colorbar()
pylab.title('Original')
pylab.subplot(122)
pylab.pcolor(lono[:],
lato[:],
varo[0].asma(),
vmin=0,
vmax=2.5)
pylab.axis([xmin, xmax, ymin, ymax])
pylab.title(tool.upper() + ' / ' + met.upper())
pylab.colorbar() #cax=pylab.axes([0.92, 0.3, 0.02, 0.6]))
pylab.savefig('testRaynaud.%(tool)s.%(met)s.png' % vars())
def test0(self):
"""
Test from Stephane Raynaud with a few modifications
"""
toolsAndMethods = {
'libcf': ['linear'],
'esmf': ['linear', 'patch', 'conserve'],
}
f = cdms2.open(sys.prefix + '/sample_data/swan.four.nc')
vari = f('HS')
f.close()
gridi = vari.getGrid()
# add bounds to input grid
lati = vari.getLatitude()
loni = vari.getLongitude()
xib, yib = bounds2d(loni, lati)
loni.setBounds(xib)
lati.setBounds(yib)
self.assertNotEqual(gridi.getLatitude().getBounds(), None)
self.assertNotEqual(gridi.getLongitude().getBounds(), None)
# output grid
nyo, nxo = 100, 200
ymin, ymax = lati.min(), lati.max()
xmin, xmax = loni.min(), loni.max()
dy, dx = (ymax - ymin)/float(nyo), (xmax - xmin)/float(nxo)
yo = numpy.array([ymin + dy*(j + 0.5) for j in range(nyo)])
xo = numpy.array([xmin + dx*(i + 0.5) for i in range(nxo)])
lato = cdms2.createAxis(yo)
lato.designateLatitude() ; lato.units = 'degrees_north'
lono = cdms2.createAxis(xo)
lono.designateLongitude() ; lono.units= 'degrees_east'
grido = cdms2.createRectGrid(lato, lono)
self.assertNotEqual(grido.getLatitude().getBounds(), None)
self.assertNotEqual(grido.getLongitude().getBounds(), None)
for tool in toolsAndMethods:
for met in toolsAndMethods[tool]:
t0 = time()
print tool.upper(), met, ':'
diag = {}
varo = vari.regrid(grido,
regridMethod = met, regridTool = tool,
coordSys = 'cart', nitermax = 10,
diag = diag)
print 'diag = ', diag
met2 = diag['regridMethod']
tool2 = diag['regridTool']
self.assertEqual(met, met2)
self.assertEqual(tool2, tool)
self.assertGreater(varo.min(), -0.01)
dt = time() - t0
print tool.upper(), met, ':', dt, 'seconds'
if PLOT:
pylab.figure(figsize=(12, 6))
pylab.subplots_adjust(right=0.9)
pylab.subplot(121)
pylab.pcolor(loni[:], lati[:], vari[0].asma(), vmin = 0, vmax = 2.5)
pylab.axis([xmin, xmax, ymin, ymax])
pylab.colorbar()
pylab.title('Original')
pylab.subplot(122)
pylab.pcolor(lono[:], lato[:], varo[0].asma(), vmin = 0, vmax = 2.5)
pylab.axis([xmin, xmax, ymin, ymax])
pylab.title(tool.upper()+' / '+met.upper())
pylab.colorbar()#cax=pylab.axes([0.92, 0.3, 0.02, 0.6]))
pylab.savefig('testRaynaud.%(tool)s.%(met)s.png'%vars())
#; Transform P from m/s to mm/day #P = P * 86400000. #====================================================================== #====================================================================== # 3. REGRID ALL DATA TO CAM GRID #====================================================================== #====================================================================== #====================================================================== # numpy array -> axis -> grid lonNp = np.linspace(0.0, 360.0, num=145) lonAxis = cdms2.createAxis(lonNp) latNp = np.linspace(-90., 90.0, num=96) latAxis = cdms2.createAxis(latNp) #====================================================================== grid3 = cdms2.createRectGrid(latAxis, lonAxis, 'yx', type="generic") print grid3 #====================================================================== # HAVE TO USE THE ORIGINAL CDMS VARIABLE HERE, THEN RE-SAVE IF NECESSARY: SPEEDY_pr_r=SPEEDY_dD_pr_ANN.regrid(grid3, regridTool='esmf', regridMethod='conserve') #====================================================================== # EPSILON VALUES #====================================================================== #====================================================================== # 2. PFT VEGETATION: READ IN FROM ETOT #======================================================================
def run_diag(parameter):
variables = parameter.variables
seasons = parameter.seasons
ref_name = getattr(parameter, "ref_name", "")
test_data = utils.dataset.Dataset(parameter, test=True)
ref_data = utils.dataset.Dataset(parameter, ref=True)
for season in seasons:
# Get the name of the data, appended with the years averaged.
parameter.test_name_yrs = utils.general.get_name_and_yrs(
parameter, test_data, season)
parameter.ref_name_yrs = utils.general.get_name_and_yrs(
parameter, ref_data, season)
for var in variables:
print("Variable: {}".format(var))
parameter.var_id = var
mv1 = test_data.get_climo_variable(var, season)
mv2 = ref_data.get_climo_variable(var, season)
parameter.viewer_descr[var] = (mv1.long_name if hasattr(
mv1, "long_name") else "No long_name attr in test data.")
# For variables with a z-axis.
if mv1.getLevel() and mv2.getLevel():
# Since the default is now stored in MeridionalMean2dParameter,
# we must get it from there if the plevs param is blank.
plevs = parameter.plevs
if (isinstance(plevs, numpy.ndarray) and not plevs.all()) or (
not isinstance(plevs, numpy.ndarray) and not plevs):
plevs = ZonalMean2dParameter().plevs
# print('Selected pressure level: {}'.format(plevs))
mv1_p = utils.general.convert_to_pressure_levels(
mv1, plevs, test_data, var, season)
mv2_p = utils.general.convert_to_pressure_levels(
mv2, plevs, ref_data, var, season)
mv1_p = cdutil.averager(mv1_p, axis="y")
mv2_p = cdutil.averager(mv2_p, axis="y")
parameter.output_file = "-".join(
[ref_name, var, season, parameter.regions[0]])
parameter.main_title = str(" ".join([var, season]))
# Regrid towards the lower resolution of the two
# variables for calculating the difference.
if len(mv1_p.getLongitude()) < len(mv2_p.getLongitude()):
mv1_reg = mv1_p
lev_out = mv1_p.getLevel()
lon_out = mv1_p.getLongitude()
# in order to use regrid tool we need to have at least two latitude bands, so generate new grid first
lat = cdms2.createAxis([0])
lat.setBounds(numpy.array([-1, 1]))
lat.designateLatitude()
grid = cdms2.createRectGrid(lat, lon_out)
data_shape = list(mv2_p.shape)
data_shape.append(1)
mv2_reg = MV2.resize(mv2_p, data_shape)
mv2_reg.setAxis(-1, lat)
for i, ax in enumerate(mv2_p.getAxisList()):
mv2_reg.setAxis(i, ax)
mv2_reg = mv2_reg.regrid(grid, regridTool="regrid2")[...,
0]
# Apply the mask back, since crossSectionRegrid
# doesn't preserve the mask.
mv2_reg = MV2.masked_where(mv2_reg == mv2_reg.fill_value,
mv2_reg)
elif len(mv1_p.getLongitude()) > len(mv2_p.getLongitude()):
mv2_reg = mv2_p
lev_out = mv2_p.getLevel()
lon_out = mv2_p.getLongitude()
mv1_reg = mv1_p.crossSectionRegrid(lev_out, lon_out)
# In order to use regrid tool we need to have at least two
# latitude bands, so generate new grid first.
lat = cdms2.createAxis([0])
lat.setBounds(numpy.array([-1, 1]))
lat.designateLatitude()
grid = cdms2.createRectGrid(lat, lon_out)
data_shape = list(mv1_p.shape)
data_shape.append(1)
mv1_reg = MV2.resize(mv1_p, data_shape)
mv1_reg.setAxis(-1, lat)
for i, ax in enumerate(mv1_p.getAxisList()):
mv1_reg.setAxis(i, ax)
mv1_reg = mv1_reg.regrid(grid, regridTool="regrid2")[...,
0]
# Apply the mask back, since crossSectionRegrid
# doesn't preserve the mask.
mv1_reg = MV2.masked_where(mv1_reg == mv1_reg.fill_value,
mv1_reg)
else:
mv1_reg = mv1_p
mv2_reg = mv2_p
diff = mv1_reg - mv2_reg
metrics_dict = create_metrics(mv2_p, mv1_p, mv2_reg, mv1_reg,
diff)
parameter.var_region = "global"
plot(
parameter.current_set,
mv2_p,
mv1_p,
diff,
metrics_dict,
parameter,
)
utils.general.save_ncfiles(parameter.current_set, mv1_p, mv2_p,
diff, parameter)
# For variables without a z-axis.
elif mv1.getLevel() is None and mv2.getLevel() is None:
raise RuntimeError(
"One of or both data doesn't have z dimention. Aborting.")
return parameter
