def getDstAreas(self, rootPe):
"""
Get the dst grid areas as used by conservative interpolation
@param rootPe None is local areas are returned, otherwise
provide rootPe and the data will be gathered
@return numpy array or None if interpolation is not conservative
"""
if self.srcAreaField is not None:
ESMP.ESMP_FieldRegridGetArea(self.dstAreaField.field)
return self.dstAreaField.getData(rootPe = rootPe)
return None
def XXtest0_ESMP(self):
import scipy.io.netcdf
srcF = scipy.io.netcdf.netcdf_file(
'so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = srcF.variables['so'][0, 0, ...]
missing_value = 1.e20
srcGrd = [srcF.variables['lat'][:], srcF.variables['lon'][:]]
srcBounds = _getCorners([
srcF.variables['lat_vertices'][:],
srcF.variables['lon_vertices'][:]
])
lat1dBounds = numpy.arange(-90.0, 90.001, 5.0)
lon1dBounds = numpy.arange(-180.0, 180.001, 5.0)
lat1dCenter = 0.5 * (lat1dBounds[:-1] + lat1dBounds[1:])
lon1dCenter = 0.5 * (lon1dBounds[:-1] + lon1dBounds[1:])
lat2dBounds = numpy.outer(
lat1dBounds, numpy.ones((len(lon1dBounds), ), lon1dBounds.dtype))
lon2dBounds = numpy.outer(
numpy.ones((len(lat1dBounds), ), lat1dBounds.dtype), lon1dBounds)
lat2dCenter = numpy.outer(
lat1dCenter, numpy.ones((len(lon1dCenter), ), lon1dCenter.dtype))
lon2dCenter = numpy.outer(
numpy.ones((len(lat1dCenter), ), lat1dCenter.dtype), lon1dCenter)
dstGrd = [lat2dCenter, lon2dCenter]
dstBounds = [lat2dBounds, lon2dBounds]
coordSys = ESMP.ESMP_COORDSYS_SPH_DEG # ESMP.ESMP_COORDSYS_CART fails
srcDims = srcGrd[0].shape
dstDims = dstGrd[0].shape
# do we need to revert the order here?
srcMaxIndex = numpy.array(srcDims[::-1],
numpy.int32) # number of cells
dstMaxIndex = numpy.array(dstDims[::-1],
numpy.int32) # number of cells
# grids
srcGrid = ESMP.ESMP_GridCreateNoPeriDim(srcMaxIndex, coordSys=coordSys)
dstGrid = ESMP.ESMP_GridCreateNoPeriDim(dstMaxIndex, coordSys=coordSys)
# it's a good idea to always add the nodal coordinates
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER)
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
# masks
ESMP.ESMP_GridAddItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
srcGridMaskPtr = ESMP.ESMP_GridGetItem(srcGrid,
item=ESMP.ESMP_GRIDITEM_MASK)
ESMP.ESMP_GridAddItem(dstGrid, item=ESMP.ESMP_GRIDITEM_MASK)
dstGridMaskPtr = ESMP.ESMP_GridGetItem(dstGrid,
item=ESMP.ESMP_GRIDITEM_MASK)
# get pointer to coordinates array and dimensions
# src
srcXCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0,
ESMP.ESMP_STAGGERLOC_CORNER)
srcYCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1,
ESMP.ESMP_STAGGERLOC_CORNER)
srcLoCorner, srcHiCorner = ESMP.ESMP_GridGetCoord(
srcGrid, ESMP.ESMP_STAGGERLOC_CORNER)
srcXCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0,
ESMP.ESMP_STAGGERLOC_CENTER)
srcYCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1,
ESMP.ESMP_STAGGERLOC_CENTER)
srcLoCenter, srcHiCenter = ESMP.ESMP_GridGetCoord(
srcGrid, ESMP.ESMP_STAGGERLOC_CENTER)
# dst
dstXCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0,
ESMP.ESMP_STAGGERLOC_CORNER)
dstYCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1,
ESMP.ESMP_STAGGERLOC_CORNER)
dstLoCorner, dstHiCorner = ESMP.ESMP_GridGetCoord(
dstGrid, ESMP.ESMP_STAGGERLOC_CORNER)
dstXCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0,
ESMP.ESMP_STAGGERLOC_CENTER)
dstYCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1,
ESMP.ESMP_STAGGERLOC_CENTER)
dstLoCenter, dstHiCenter = ESMP.ESMP_GridGetCoord(
dstGrid, ESMP.ESMP_STAGGERLOC_CENTER)
# fields
srcFld = ESMP.ESMP_FieldCreateGrid(
srcGrid,
'srcFld',
typekind=ESMP.ESMP_TYPEKIND_R8,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstFld = ESMP.ESMP_FieldCreateGrid(
dstGrid,
'dstFld',
typekind=ESMP.ESMP_TYPEKIND_R8,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcAreaField = ESMP.ESMP_FieldCreateGrid(
srcGrid,
'srcAreas',
typekind=ESMP.ESMP_TYPEKIND_R8,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstAreaField = ESMP.ESMP_FieldCreateGrid(
dstGrid,
'dstAreas',
typekind=ESMP.ESMP_TYPEKIND_R8,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcFracField = ESMP.ESMP_FieldCreateGrid(
srcGrid,
'srcFracAreas',
typekind=ESMP.ESMP_TYPEKIND_R8,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstFracField = ESMP.ESMP_FieldCreateGrid(
dstGrid,
'dstFracAreas',
typekind=ESMP.ESMP_TYPEKIND_R8,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcFieldPtr = ESMP.ESMP_FieldGetPtr(srcFld)
srcFracPtr = ESMP.ESMP_FieldGetPtr(srcFracField)
dstFieldPtr = ESMP.ESMP_FieldGetPtr(dstFld)
dstFracPtr = ESMP.ESMP_FieldGetPtr(dstFracField)
# set the coordinates and field values. In ESMP, arrays are column major!
# src-corners
srcNx1 = srcHiCorner[0] - srcLoCorner[0]
srcNy1 = srcHiCorner[1] - srcLoCorner[1]
srcYCorner[:] = srcBounds[0][srcLoCorner[1]:srcHiCorner[1],
srcLoCorner[0]:srcHiCorner[0]].flat
srcXCorner[:] = srcBounds[1][srcLoCorner[1]:srcHiCorner[1],
srcLoCorner[0]:srcHiCorner[0]].flat
# src-center coordinates, field, and mask
srcNx = srcHiCenter[0] - srcLoCenter[0]
srcNy = srcHiCenter[1] - srcLoCenter[1]
yc = numpy.array(srcGrd[0][srcLoCenter[1]:srcHiCenter[1],
srcLoCenter[0]:srcHiCenter[0]])
xc = numpy.array(srcGrd[1][srcLoCenter[1]:srcHiCenter[1],
srcLoCenter[0]:srcHiCenter[0]])
srcYCenter[:] = yc.flat
srcXCenter[:] = xc.flat
msk = numpy.array(so[srcLoCenter[1]:srcHiCenter[1], srcLoCenter[0]:srcHiCenter[0]] \
== missing_value, numpy.int32)
srcGridMaskPtr[:] = msk.flat
fld = numpy.array(
so[srcLoCenter[1]:srcHiCenter[1], srcLoCenter[0]:srcHiCenter[0]],
so.dtype)
# set to zero where masked
fld *= (1 - msk)
srcFieldPtr[:] = fld.flat
srcFracPtr[:] = 1.0
# dst-corners
dstNx1 = dstHiCorner[0] - dstLoCorner[0]
dstNy1 = dstHiCorner[1] - dstLoCorner[1]
dstYCorner[:] = dstBounds[0][dstLoCorner[1]:dstHiCorner[1],
dstLoCorner[0]:dstHiCorner[0]].flat
dstXCorner[:] = dstBounds[1][dstLoCorner[1]:dstHiCorner[1],
dstLoCorner[0]:dstHiCorner[0]].flat
# dst-center coordinates, field, and mask
dstNx = dstHiCenter[0] - dstLoCenter[0]
dstNy = dstHiCenter[1] - dstLoCenter[1]
yc = numpy.array(dstGrd[0][dstLoCenter[1]:dstHiCenter[1],
dstLoCenter[0]:dstHiCenter[0]])
xc = numpy.array(dstGrd[1][dstLoCenter[1]:dstHiCenter[1],
dstLoCenter[0]:dstHiCenter[0]])
dstYCenter[:] = yc.flat
dstXCenter[:] = xc.flat
dstGridMaskPtr[:] = 0
dstFieldPtr[:] = missing_value
dstFracPtr[:] = 1.0
# interpolation
maskVals = numpy.array([1], numpy.int32) # values defining mask
regrid = ESMP.ESMP_FieldRegridStore(
srcFld,
dstFld,
srcMaskValues=maskVals,
dstMaskValues=maskVals,
regridmethod=ESMP.ESMP_REGRIDMETHOD_CONSERVE,
unmappedaction=ESMP.ESMP_UNMAPPEDACTION_IGNORE,
srcFracField=srcFracField,
dstFracField=dstFracField)
ESMP.ESMP_FieldRegrid(srcFld, dstFld, regrid)
# get the cell areas
ESMP.ESMP_FieldRegridGetArea(srcAreaField)
ESMP.ESMP_FieldRegridGetArea(dstAreaField)
srcAreasPtr = ESMP.ESMP_FieldGetPtr(srcAreaField)
dstAreasPtr = ESMP.ESMP_FieldGetPtr(dstAreaField)
srcFracPtr = ESMP.ESMP_FieldGetPtr(srcFracField)
dstFracPtr = ESMP.ESMP_FieldGetPtr(dstFracField)
# check conservation
srcFldSum, dstFldSum = srcFieldPtr.sum(), dstFieldPtr.sum()
srcFldIntegral = (srcFieldPtr * srcAreasPtr * srcFracPtr).sum()
dstFldIntegral = (dstFieldPtr * dstAreasPtr * dstFracPtr).sum()
lackConservLocal = srcFldIntegral - dstFldIntegral
# check for nans
if numpy.isnan(srcFracPtr).sum() > 0:
print '[%d] *** %d Nans found in srcFracPtr!!' % (
self.pe, numpy.isnan().sum(srcFracPtr))
if numpy.isnan(dstFracPtr).sum() > 0:
print '[%d] *** %d Nans found in dstFracPtr!!' % (
self.pe, numpy.isnan().sum(dstFracPtr))
print '[%d] checksum of src: %g checksum of dst: %g' % (
self.pe, srcFldSum, dstFldSum)
print '[%d] src total area integral: %g dst total area integral: %g diff: %g\n' % \
(self.pe, srcFldIntegral, dstFldIntegral, lackConservLocal)
if HAS_MPI:
lackConserv = MPI.COMM_WORLD.reduce(lackConservLocal,
op=MPI.SUM,
root=0)
else:
lackConserv = lackConservLocal
if self.pe == 0:
print 'ROOT: total lack of conservation (should be small): %f' % lackConserv
# cleanup
ESMP.ESMP_FieldRegridRelease(regrid)
ESMP.ESMP_FieldDestroy(srcAreaField)
ESMP.ESMP_FieldDestroy(dstAreaField)
ESMP.ESMP_FieldDestroy(srcFracField)
ESMP.ESMP_FieldDestroy(dstFracField)
ESMP.ESMP_FieldDestroy(srcFld)
ESMP.ESMP_FieldDestroy(dstFld)
ESMP.ESMP_GridDestroy(srcGrid)
ESMP.ESMP_GridDestroy(dstGrid)
def Xtest0_ESMP(self):
import scipy.io.netcdf
#
# 1. input
#
coordSys = ESMP.ESMP_COORDSYS_SPH_DEG # ESMP.ESMP_COORDSYS_CART fails
inFile = sys.prefix + \
'/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc'
srcF = scipy.io.netcdf.netcdf_file(inFile)
#so = srcF.variables['so'][0, 0,...]
missing_value = 1.e20
srcGrd = [srcF.variables['lat'][:], srcF.variables['lon'][:]]
srcBounds = _getCorners([srcF.variables['lat_vertices'][:], srcF.variables['lon_vertices'][:]])
lat1dBounds = numpy.arange(-90.0, 90.001, 5.0)
lon1dBounds = numpy.arange(-180.0, 180.001, 5.0)
lat1dCenter = 0.5*(lat1dBounds[:-1] + lat1dBounds[1:])
lon1dCenter = 0.5*(lon1dBounds[:-1] + lon1dBounds[1:])
lat2dBounds = numpy.outer(lat1dBounds,
numpy.ones( (len(lon1dBounds),), lon1dBounds.dtype ) )
lon2dBounds = numpy.outer(numpy.ones( (len(lat1dBounds),),
lat1dBounds.dtype ), lon1dBounds )
lat2dCenter = numpy.outer(lat1dCenter,
numpy.ones( (len(lon1dCenter),), lon1dCenter.dtype ) )
lon2dCenter = numpy.outer(numpy.ones( (len(lat1dCenter),),
lat1dCenter.dtype ), lon1dCenter )
dstGrd = [lat2dCenter, lon2dCenter]
dstBounds = [lat2dBounds, lon2dBounds]
srcDims = srcGrd[0].shape
dstDims = dstGrd[0].shape
srcMaxIndex = numpy.array(srcDims[::-1], numpy.int32) # number of cells
dstMaxIndex = numpy.array(dstDims[::-1], numpy.int32) # number of cells
#
# 2. create grid objects
#
srcGrid = ESMP.ESMP_GridCreateNoPeriDim(srcMaxIndex, coordSys = coordSys)
dstGrid = ESMP.ESMP_GridCreateNoPeriDim(dstMaxIndex, coordSys = coordSys)
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc = CORNER)
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc = CENTER)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc = CORNER)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc = CENTER)
# add masks
ESMP.ESMP_GridAddItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
srcGridMaskPtr = ESMP.ESMP_GridGetItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
ESMP.ESMP_GridAddItem(dstGrid, item=ESMP.ESMP_GRIDITEM_MASK)
dstGridMaskPtr = ESMP.ESMP_GridGetItem(dstGrid, item=ESMP.ESMP_GRIDITEM_MASK)
srcLoCorner, srcHiCorner = ESMP.ESMP_GridGetCoord(srcGrid, CORNER)
srcLoCenter, srcHiCenter = ESMP.ESMP_GridGetCoord(srcGrid, CENTER)
dstLoCorner, dstHiCorner = ESMP.ESMP_GridGetCoord(dstGrid, CORNER)
dstLoCenter, dstHiCenter = ESMP.ESMP_GridGetCoord(dstGrid, CENTER)
srcNx1 = srcHiCorner[0] - srcLoCorner[0]
srcNy1 = srcHiCorner[1] - srcLoCorner[1]
srcNx = srcHiCenter[0] - srcLoCenter[0]
srcNy = srcHiCenter[1] - srcLoCenter[1]
dstNx1 = dstHiCorner[0] - dstLoCorner[0]
dstNy1 = dstHiCorner[1] - dstLoCorner[1]
dstNx = dstHiCenter[0] - dstLoCenter[0]
dstNy = dstHiCenter[1] - dstLoCenter[1]
srcXCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0, CORNER)
srcYCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1, CORNER)
srcXCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0, CENTER)
srcYCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1, CENTER)
dstXCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0, CORNER)
dstYCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1, CORNER)
dstXCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0, CENTER)
dstYCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1, CENTER)
#
# 3. create fields
#
srcFld = ESMP.ESMP_FieldCreateGrid(srcGrid, 'srcFld',
typekind = R8, staggerloc = CENTER)
dstFld = ESMP.ESMP_FieldCreateGrid(dstGrid, 'dstFld',
typekind = R8, staggerloc = CENTER)
srcAreaField = ESMP.ESMP_FieldCreateGrid(srcGrid, 'srcAreas',
typekind = R8, staggerloc = CENTER)
dstAreaField = ESMP.ESMP_FieldCreateGrid(dstGrid, 'dstAreas',
typekind = R8, staggerloc = CENTER)
srcFracField = ESMP.ESMP_FieldCreateGrid(srcGrid, 'srcFracAreas',
typekind = R8, staggerloc = CENTER)
dstFracField = ESMP.ESMP_FieldCreateGrid(dstGrid, 'dstFracAreas',
typekind = R8, staggerloc = CENTER)
srcFieldPtr = ESMP.ESMP_FieldGetPtr(srcFld)
srcFracPtr = ESMP.ESMP_FieldGetPtr(srcFracField)
dstFieldPtr = ESMP.ESMP_FieldGetPtr(dstFld)
dstFracPtr = ESMP.ESMP_FieldGetPtr(dstFracField)
#
# 4. set the coordinates and the fields
#
srcYCorner[:] = srcBounds[0][srcLoCorner[1]:srcHiCorner[1], srcLoCorner[0]:srcHiCorner[0]].flat
srcXCorner[:] = srcBounds[1][srcLoCorner[1]:srcHiCorner[1], srcLoCorner[0]:srcHiCorner[0]].flat
# src-center coordinates, field, and mask
yc = numpy.array(srcGrd[0][srcLoCenter[1]:srcHiCenter[1], srcLoCenter[0]:srcHiCenter[0]])
xc = numpy.array(srcGrd[1][srcLoCenter[1]:srcHiCenter[1], srcLoCenter[0]:srcHiCenter[0]])
srcYCenter[:] = yc.flat
srcXCenter[:] = xc.flat
# read the local data
soLocalToPe = srcF.variables['so'][0, 0, srcLoCenter[1]:srcHiCenter[1], srcLoCenter[0]:srcHiCenter[0]]
msk = numpy.array(soLocalToPe == missing_value, numpy.int32)
srcGridMaskPtr[:] = msk.flat
fld = numpy.array(soLocalToPe, soLocalToPe.dtype)
# set to zero where masked
fld *= (1 - msk)
srcFieldPtr[:] = fld.flat
srcFracPtr[:] = 1.0
dstYCorner[:] = dstBounds[0][dstLoCorner[1]:dstHiCorner[1], dstLoCorner[0]:dstHiCorner[0]].flat
dstXCorner[:] = dstBounds[1][dstLoCorner[1]:dstHiCorner[1], dstLoCorner[0]:dstHiCorner[0]].flat
# dst-center coordinates, field, and mask
yc = numpy.array(dstGrd[0][dstLoCenter[1]:dstHiCenter[1], dstLoCenter[0]:dstHiCenter[0]])
xc = numpy.array(dstGrd[1][dstLoCenter[1]:dstHiCenter[1], dstLoCenter[0]:dstHiCenter[0]])
dstYCenter[:] = yc.flat
dstXCenter[:] = xc.flat
dstGridMaskPtr[:] = 0
dstFieldPtr[:] = missing_value
dstFracPtr[:] = 1.0
#
# 5. interpolate
#
maskVals = numpy.array([1], numpy.int32) # values defining mask
regrid = ESMP.ESMP_FieldRegridStore(srcFld,
dstFld,
srcMaskValues=maskVals,
dstMaskValues=maskVals,
regridmethod=ESMP.ESMP_REGRIDMETHOD_CONSERVE,
unmappedaction=ESMP.ESMP_UNMAPPEDACTION_IGNORE,
srcFracField=srcFracField,
dstFracField=dstFracField)
ESMP.ESMP_FieldRegrid(srcFld, dstFld, regrid)
#
# 6. check
#
ESMP.ESMP_FieldRegridGetArea(srcAreaField)
ESMP.ESMP_FieldRegridGetArea(dstAreaField)
srcAreasPtr = ESMP.ESMP_FieldGetPtr(srcAreaField)
dstAreasPtr = ESMP.ESMP_FieldGetPtr(dstAreaField)
srcFracPtr = ESMP.ESMP_FieldGetPtr(srcFracField)
dstFracPtr = ESMP.ESMP_FieldGetPtr(dstFracField)
# conservation
srcFldSum, dstFldSum = srcFieldPtr.sum(), dstFieldPtr.sum()
srcFldIntegral = (srcFieldPtr * srcAreasPtr * srcFracPtr).sum()
dstFldIntegral = (dstFieldPtr * dstAreasPtr * dstFracPtr).sum()
lackConservLocal = srcFldIntegral - dstFldIntegral
# nans
if numpy.isnan(srcFracPtr).sum() > 0:
print '[%d] *** %d Nans found in srcFracPtr!!' % \
(self.pe, numpy.isnan().sum(srcFracPtr))
if numpy.isnan(dstFracPtr).sum() > 0:
print '[%d] *** %d Nans found in dstFracPtr!!' % \
(self.pe, numpy.isnan().sum(dstFracPtr))
print '[%d] checksum of src: %g checksum of dst: %g' % \
(self.pe, srcFldSum, dstFldSum)
print '[%d] src total area integral: %g dst total area integral: %g diff: %g\n' % \
(self.pe, srcFldIntegral, dstFldIntegral, lackConservLocal)
if HAS_MPI:
lackConserv = MPI.COMM_WORLD.reduce(lackConservLocal,
op=MPI.SUM, root=0)
else:
lackConserv = lackConservLocal
if self.pe == 0:
print 'ROOT: total lack of conservation (should be small): %f' % lackConserv
#
# 7. clean up
#
ESMP.ESMP_FieldRegridRelease(regrid)
ESMP.ESMP_FieldDestroy(srcAreaField)
ESMP.ESMP_FieldDestroy(dstAreaField)
ESMP.ESMP_FieldDestroy(srcFracField)
ESMP.ESMP_FieldDestroy(dstFracField)
ESMP.ESMP_FieldDestroy(srcFld)
ESMP.ESMP_FieldDestroy(dstFld)
ESMP.ESMP_GridDestroy(srcGrid)
ESMP.ESMP_GridDestroy(dstGrid)
def test1_ESMP(self):
rk = 0
if HAS_MPI:
rk = MPI.COMM_WORLD.Get_rank()
coordSys = ESMP.ESMP_COORDSYS_CART
nres = 4
self.srcDims = (4 * nres, 3 * nres)
self.dstDims = (4 * nres, 3 * nres)
srcMaxIndex = numpy.array(self.srcDims, numpy.int32) # number of cells
dstMaxIndex = numpy.array(self.dstDims, numpy.int32) # number of cells
# grids
srcGrid = ESMP.ESMP_GridCreateNoPeriDim(srcMaxIndex, coordSys=coordSys)
dstGrid = ESMP.ESMP_GridCreateNoPeriDim(dstMaxIndex, coordSys=coordSys)
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER)
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
# masks
ESMP.ESMP_GridAddItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
srcGridMaskPtr = ESMP.ESMP_GridGetItem(srcGrid,
item=ESMP.ESMP_GRIDITEM_MASK)
ESMP.ESMP_GridAddItem(dstGrid, item=ESMP.ESMP_GRIDITEM_MASK)
dstGridMaskPtr = ESMP.ESMP_GridGetItem(dstGrid,
item=ESMP.ESMP_GRIDITEM_MASK)
# coordinates
srcXCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0,
ESMP.ESMP_STAGGERLOC_CORNER)
srcYCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1,
ESMP.ESMP_STAGGERLOC_CORNER)
srcLoCorner, srcHiCorner = ESMP.ESMP_GridGetCoord(
srcGrid, ESMP.ESMP_STAGGERLOC_CORNER)
srcXCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0,
ESMP.ESMP_STAGGERLOC_CENTER)
srcYCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1,
ESMP.ESMP_STAGGERLOC_CENTER)
srcLoCenter, srcHiCenter = ESMP.ESMP_GridGetCoord(
srcGrid, ESMP.ESMP_STAGGERLOC_CENTER)
dstXCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0,
ESMP.ESMP_STAGGERLOC_CORNER)
dstYCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1,
ESMP.ESMP_STAGGERLOC_CORNER)
dstLoCorner, dstHiCorner = ESMP.ESMP_GridGetCoord(
dstGrid, ESMP.ESMP_STAGGERLOC_CORNER)
dstXCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0,
ESMP.ESMP_STAGGERLOC_CENTER)
dstYCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1,
ESMP.ESMP_STAGGERLOC_CENTER)
dstLoCenter, dstHiCenter = ESMP.ESMP_GridGetCoord(
dstGrid, ESMP.ESMP_STAGGERLOC_CENTER)
# fields
srcFld = ESMP.ESMP_FieldCreateGrid(
srcGrid,
'srcFld',
typekind=ESMP.ESMP_TYPEKIND_R8,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstFld = ESMP.ESMP_FieldCreateGrid(
dstGrid,
'dstFld',
typekind=ESMP.ESMP_TYPEKIND_R8,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcFieldPtr = ESMP.ESMP_FieldGetPtr(srcFld)
dstFieldPtr = ESMP.ESMP_FieldGetPtr(dstFld)
# set the coordinates and field values
# src-corners
srcNx1 = srcHiCorner[0] - srcLoCorner[0]
srcNy1 = self.srcDims[1] + 1
self.dims = self.srcDims
for iy in range(srcNy1):
iyp = iy + srcLoCorner[0]
for ix in range(srcNx1):
ixp = ix + srcLoCorner[1]
srcXCorner[ix + iy * srcNx1] = self.xFunct(iyp, ixp)
srcYCorner[ix + iy * srcNx1] = self.yFunct(iyp, ixp)
# src-centers and mask
srcNx = srcHiCenter[0] - srcLoCenter[0]
srcNy = srcHiCenter[1] - srcLoCenter[1]
self.dims = self.srcDims
for iy in range(srcNy):
iyp = iy + srcLoCenter[0]
for ix in range(srcNx):
ixp = ix + srcLoCenter[1]
x = self.xFunct(iyp + 0.5, ixp + 0.5)
y = self.yFunct(iyp + 0.5, ixp + 0.5)
srcXCenter[ix + iy * srcNx] = x
srcYCenter[ix + iy * srcNx] = y
mask = 0
if ((iyp * ixp) % 3) == 1:
mask = 1
srcGridMaskPtr[ix + iy * srcNx] = mask # valid
srcFieldPtr[ix + iy * srcNx] = self.func(ixp, iyp)
# dst-corners
dstNx1 = dstHiCorner[0] - dstLoCorner[0]
dstNy1 = dstHiCorner[1] - dstLoCorner[1]
self.dims = self.dstDims
for iy in range(dstNy1):
iyp = iy + dstLoCorner[0]
for ix in range(dstNx1):
ixp = ix + dstLoCorner[1]
dstXCorner[ix + iy * dstNx1] = self.xFunct(iyp, ixp)
dstYCorner[ix + iy * dstNx1] = self.yFunct(iyp, ixp)
# dst-centers and mask
dstNx = dstHiCenter[0] - dstLoCenter[0]
dstNy = dstHiCenter[1] - dstLoCenter[1]
self.dims = self.dstDims
for iy in range(dstNy):
iyp = iy + dstLoCenter[0]
for ix in range(dstNx):
ixp = ix + dstLoCenter[1]
x = self.xFunct(iyp + 0.5, ixp + 0.5)
y = self.yFunct(iyp + 0.5, ixp + 0.5)
dstXCenter[ix + iy * dstNx] = x
dstYCenter[ix + iy * dstNx] = y
dstGridMaskPtr[ix + iy * dstNx] = 0 # valid
dstFieldPtr[ix + iy * dstNx] = -20 # fill value
srcAreaField = ESMP.ESMP_FieldCreateGrid(srcGrid, 'srcArea')
dstAreaField = ESMP.ESMP_FieldCreateGrid(dstGrid, 'dstArea')
srcFracField = ESMP.ESMP_FieldCreateGrid(srcGrid, 'srcFrac')
dstFracField = ESMP.ESMP_FieldCreateGrid(dstGrid, 'dstFrac')
# IF you want to set your own area. These lines are required.
# Otherwise, let ESMF do it.
# ESMP.ESMP_GridAddItem(srcGrid, item = ESMP.ESMP_GRIDITEM_AREA)
# srcAreas = ESMP.ESMP_GridGetItem(srcGrid, item = ESMP.ESMP_GRIDITEM_AREA)
# ESMP.ESMP_GridAddItem(dstGrid, item = ESMP.ESMP_GRIDITEM_AREA)
# dstAreas = ESMP.ESMP_GridGetItem(dstGrid, item = ESMP.ESMP_GRIDITEM_AREA)
# srcAreas[:] = 0.02080333333
# dstAreas[:] = 0.08333333333
# interpolation
maskVals = numpy.array([1], numpy.int32) # values defining mask
regrid = ESMP.ESMP_FieldRegridStore(
srcFld,
dstFld,
srcMaskValues=maskVals,
dstMaskValues=None,
regridmethod=ESMP.ESMP_REGRIDMETHOD_CONSERVE,
unmappedaction=ESMP.ESMP_UNMAPPEDACTION_IGNORE,
srcFracField=srcFracField,
dstFracField=None)
ESMP.ESMP_FieldRegrid(srcFld, dstFld, regrid)
# get the cell areas
ESMP.ESMP_FieldRegridGetArea(srcAreaField)
ESMP.ESMP_FieldRegridGetArea(dstAreaField)
srcarea = ESMP.ESMP_FieldGetPtr(srcAreaField)
dstarea = ESMP.ESMP_FieldGetPtr(dstAreaField)
srcFracPtr = ESMP.ESMP_FieldGetPtr(srcFracField)
# check conservation
marr = numpy.array(mask == 0, dtype=numpy.int32)
srcFldSum, dstFldSum = srcFieldPtr.sum(), dstFieldPtr.sum()
srcFldIntegral = (srcFieldPtr * srcarea * srcFracPtr).sum()
dstFldIntegral = (dstFieldPtr * dstarea).sum()
lackConservLocal = srcFldIntegral - dstFldIntegral
print '[%d] src corner lo = %s hi = %s dst corner lo = %s hi = %s' % (
rk, str(srcLoCorner), str(srcHiCorner), str(dstLoCorner),
str(dstHiCorner))
print '[%d] src center lo = %s hi = %s dst center lo = %s hi = %s' % (
rk, str(srcLoCenter), str(srcHiCenter), str(dstLoCenter),
str(dstHiCenter))
print '[%d] checksum of src: %f checksum of dst: %f' % (rk, srcFldSum,
dstFldSum)
print '[%d] src total area integral: %g dst total area integral: %g diff: %g\n' % \
(rk, srcFldIntegral, dstFldIntegral, lackConservLocal)
if HAS_MPI:
lackConserv = MPI.COMM_WORLD.reduce(lackConservLocal,
op=MPI.SUM,
root=0)
else:
lackConserv = lackConservLocal
if rk == 0:
print '[0] total lack of conservation (should be small): %f' % lackConserv
assert (abs(lackConserv) < 1.e-6)
# cleanup
ESMP.ESMP_FieldRegridRelease(regrid)
ESMP.ESMP_FieldDestroy(srcFld)
ESMP.ESMP_FieldDestroy(dstFld)
ESMP.ESMP_GridDestroy(srcGrid)
ESMP.ESMP_GridDestroy(dstGrid)
def test1_2d_esmf_native_tripolar_fraction(self):
mype = MPI.COMM_WORLD.Get_rank()
f = cdms2.open(sys.prefix + \
'/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = f('so')[0, 0, :, :]
h = cdms2.open(sys.prefix + \
'/sample_data/so_Omon_HadGEM2-CC_historical_r1i1p1_185912-186911_2timesteps.nc')
hadGEM2Model = h('so')[0, 0, ...]
ny, nx = so.shape
soBounds = so.getGrid().getBounds()
srcLatCorner = numpy.zeros((ny + 1, nx + 1), numpy.float32)
srcLatCorner[:ny, :nx] = soBounds[0][:, :, 0]
srcLatCorner[:ny, nx] = soBounds[0][:ny, nx - 1, 1]
srcLatCorner[ny, nx] = soBounds[0][ny - 1, nx - 1, 2]
srcLatCorner[ny, :nx] = soBounds[0][ny - 1, :nx, 3]
srcLonCorner = numpy.zeros((ny + 1, nx + 1), numpy.float32)
srcLonCorner[:ny, :nx] = soBounds[1][:, :, 0]
srcLonCorner[:ny, nx] = soBounds[1][:ny, nx - 1, 1]
srcLonCorner[ny, nx] = soBounds[1][ny - 1, nx - 1, 2]
srcLonCorner[ny, :nx] = soBounds[1][ny - 1, :nx, 3]
srcCells = [so.getLatitude(), so.getLongitude()]
srcNodes = [srcLatCorner, srcLonCorner]
clt = cdms2.open(sys.prefix + 'sample_data/clt.nc')('clt')[0, :, :]
cltBounds = clt.getGrid().getBounds()
ny, nx = clt.shape
# clt grid is rectilinear, transform to curvilinear
CLGrid = clt.getGrid().toCurveGrid()
#lats = CLGrid.getLatitude()[:].data
lons = CLGrid.getLongitude()[:].data
# Make the bounds go from -90, 90 with uniform spacing and the
# Cell Centers go from -88.something to 88.something
yb = numpy.linspace(-90, 90, ny + 1)
interval = abs(yb[0] - yb[1])
y = numpy.linspace(-90 + interval / 2., 90 - interval / 2., ny)
lats = numpy.outer(y, numpy.ones((nx), numpy.float32))
ny, nx = clt.shape
#yb = numpy.zeros((ny+1,), numpy.float32)
#yb[:ny] = cltBounds[0][:, 0]
#yb[ny] = cltBounds[0][ny-1, 1]
xb = numpy.zeros((nx + 1, ), numpy.float32)
xb[:nx] = cltBounds[1][:, 0]
xb[nx] = cltBounds[1][nx - 1, 1]
# make curvilinear
dstLatCorner = numpy.outer(yb, numpy.ones((nx + 1, ), numpy.float32))
dstLonCorner = numpy.outer(numpy.ones((ny + 1, ), numpy.float32), xb)
dstCells = [lats, lons]
dstNodes = [dstLatCorner, dstLonCorner]
print 'running test2_2d_esmf_native_tripolar_fraction...'
tic = time.time()
# create grid
srcMaxIndex = numpy.array(so.shape[::-1], dtype=numpy.int32)
srcGrid = ESMP.ESMP_GridCreate1PeriDim(
srcMaxIndex, coordSys=ESMP.ESMP_COORDSYS_SPH_DEG)
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER)
srcDimsCenter = ESMP.ESMP_GridGetCoord(srcGrid,
ESMP.ESMP_STAGGERLOC_CENTER)
srcDimsCorner = ESMP.ESMP_GridGetCoord(srcGrid,
ESMP.ESMP_STAGGERLOC_CORNER)
srcXCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0,
ESMP.ESMP_STAGGERLOC_CENTER)
srcYCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1,
ESMP.ESMP_STAGGERLOC_CENTER)
srcXCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0,
ESMP.ESMP_STAGGERLOC_CORNER)
srcYCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1,
ESMP.ESMP_STAGGERLOC_CORNER)
dstMaxIndex = numpy.array(clt.shape[::-1], dtype=numpy.int32)
dstGrid = ESMP.ESMP_GridCreate1PeriDim(
dstMaxIndex, coordSys=ESMP.ESMP_COORDSYS_SPH_DEG)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER)
dstDimsCenter = ESMP.ESMP_GridGetCoord(dstGrid,
ESMP.ESMP_STAGGERLOC_CENTER)
dstDimsCorner = ESMP.ESMP_GridGetCoord(dstGrid,
ESMP.ESMP_STAGGERLOC_CORNER)
dstXCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0,
ESMP.ESMP_STAGGERLOC_CENTER)
dstYCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1,
ESMP.ESMP_STAGGERLOC_CENTER)
dstXCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0,
ESMP.ESMP_STAGGERLOC_CORNER)
dstYCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1,
ESMP.ESMP_STAGGERLOC_CORNER)
# mask
ESMP.ESMP_GridAddItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
srcMask = ESMP.ESMP_GridGetItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
# create field
srcFld = ESMP.ESMP_FieldCreateGrid(
srcGrid,
'srcFld',
typekind=ESMP.ESMP_TYPEKIND_R4,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcFldPtr = ESMP.ESMP_FieldGetPtr(srcFld)
dstFld = ESMP.ESMP_FieldCreateGrid(
dstGrid,
'dstFld',
typekind=ESMP.ESMP_TYPEKIND_R4,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstFldPtr = ESMP.ESMP_FieldGetPtr(dstFld)
# Create the field for the fractional areas
srcFracFld = ESMP.ESMP_FieldCreateGrid(
srcGrid,
'srcFrac',
typekind=ESMP.ESMP_TYPEKIND_R4,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcFracPtr = ESMP.ESMP_FieldGetPtr(srcFracFld)
dstFracFld = ESMP.ESMP_FieldCreateGrid(
dstGrid,
'dstFrac',
typekind=ESMP.ESMP_TYPEKIND_R4,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstFracPtr = ESMP.ESMP_FieldGetPtr(dstFracFld)
# set coords, mask, and field values for src and dst
srcNtotCenter = reduce(operator.mul,
[srcDimsCenter[1][i] - srcDimsCenter[0][i] \
for i in range(2)])
srcNtotCorner = reduce(operator.mul,
[srcDimsCorner[1][i] - srcDimsCorner[0][i] \
for i in range(2)])
srcJCenterBeg = srcDimsCenter[0][1]
srcJCenterEnd = srcDimsCenter[1][1]
srcJCornerBeg = srcDimsCorner[0][1]
srcJCornerEnd = srcDimsCorner[1][1]
srcICenterBeg = srcDimsCenter[0][0]
srcICenterEnd = srcDimsCenter[1][0]
srcICornerBeg = srcDimsCorner[0][0]
srcICornerEnd = srcDimsCorner[1][0]
srcXCenter[:] = numpy.reshape(
srcCells[1][srcJCenterBeg:srcJCenterEnd,
srcICenterBeg:srcICenterEnd], (srcNtotCenter, ))
srcYCenter[:] = numpy.reshape(
srcCells[0][srcJCenterBeg:srcJCenterEnd,
srcICenterBeg:srcICenterEnd], (srcNtotCenter, ))
srcXCorner[:] = numpy.reshape(
srcNodes[1][srcJCornerBeg:srcJCornerEnd,
srcICornerBeg:srcICornerEnd], (srcNtotCorner, ))
srcYCorner[:] = numpy.reshape(
srcNodes[0][srcJCornerBeg:srcJCornerEnd,
srcICornerBeg:srcICornerEnd], (srcNtotCorner, ))
srcFldPtr[:] = numpy.reshape(
so[srcJCenterBeg:srcJCenterEnd, srcICenterBeg:srcICenterEnd],
(srcNtotCenter, ))
srcMask[:] = (srcFldPtr == so.missing_value)
srcFracPtr[:] = -999
dstFracPtr[:] = -999
dstNtotCenter = reduce(
operator.mul,
[dstDimsCenter[1][i] - dstDimsCenter[0][i] for i in range(2)])
dstNtotCorner = reduce(
operator.mul,
[dstDimsCorner[1][i] - dstDimsCorner[0][i] for i in range(2)])
dstXCenter[:] = numpy.reshape(
dstCells[1][dstDimsCenter[0][1]:dstDimsCenter[1][1],
dstDimsCenter[0][0]:dstDimsCenter[1][0]],
(dstNtotCenter))
dstXCenter[:] = numpy.reshape(
dstCells[0][dstDimsCenter[0][1]:dstDimsCenter[1][1],
dstDimsCenter[0][0]:dstDimsCenter[1][0]],
(dstNtotCenter))
dstXCorner[:] = numpy.reshape(
dstNodes[1][dstDimsCorner[0][1]:dstDimsCorner[1][1],
dstDimsCorner[0][0]:dstDimsCorner[1][0]],
(dstNtotCorner, ))
dstYCorner[:] = numpy.reshape(
dstNodes[0][dstDimsCorner[0][1]:dstDimsCorner[1][1],
dstDimsCorner[0][0]:dstDimsCorner[1][0]],
(dstNtotCorner, ))
dstFldPtr[:] = 0
srcAreaFld = ESMP.ESMP_FieldCreateGrid(srcGrid, 'srcArea')
dstAreaFld = ESMP.ESMP_FieldCreateGrid(dstGrid, 'dstArea')
# regrid forward and backward
maskVals = numpy.array([1], numpy.int32) # values defining mask
regrid1 = ESMP.ESMP_FieldRegridStore(
srcFld,
dstFld,
srcMaskValues=maskVals,
dstMaskValues=None,
regridmethod=ESMP.ESMP_REGRIDMETHOD_CONSERVE,
unmappedaction=ESMP.ESMP_UNMAPPEDACTION_IGNORE,
srcFracField=srcFracFld,
dstFracField=dstFracFld)
ESMP.ESMP_FieldRegrid(srcFld, dstFld, regrid1)
srcAreas = ESMP.ESMP_FieldRegridGetArea(srcAreaFld)
dstAreas = ESMP.ESMP_FieldRegridGetArea(dstAreaFld)
srcAreaPtr = ESMP.ESMP_FieldGetPtr(srcAreaFld)
dstAreaPtr = ESMP.ESMP_FieldGetPtr(dstAreaFld)
if mype == 0:
srcHasNan = numpy.any(numpy.isnan(srcFracPtr))
dstHasNan = numpy.any(numpy.isnan(dstFracPtr))
aa = numpy.isnan(srcFracPtr)
bb = numpy.isnan(dstFracPtr)
cc = srcFldPtr == 0
dd = dstFldPtr == 0
if PLOT:
pl.figure(1)
pl.subplot(2, 1, 1)
pl.pcolor(numpy.reshape(aa, so.shape))
pl.colorbar()
pl.title('source')
pl.subplot(2, 1, 2)
pl.pcolor(numpy.reshape(bb, clt.shape))
pl.colorbar()
pl.title('destination')
pl.suptitle("Red == location of nan's")
print srcHasNan, dstHasNan
# Do they have nans?
self.assertFalse(srcHasNan, True)
self.assertFalse(dstHasNan, True)
jbeg, jend = dstDimsCenter[0][1], dstDimsCenter[1][1]
ibeg, iend = dstDimsCenter[0][0], dstDimsCenter[1][0]
soInterp = numpy.reshape(dstFldPtr, (jend - jbeg, iend - ibeg))
toc = time.time()
# clean up
ESMP.ESMP_FieldRegridRelease(regrid1)
ESMP.ESMP_FieldDestroy(dstFld)
ESMP.ESMP_GridDestroy(dstGrid)
ESMP.ESMP_FieldDestroy(srcFld)
ESMP.ESMP_GridDestroy(srcGrid)