def test1_esmf(self):
"""
Simple test using esmf.py directly
"""
srcMaxIndex = numpy.array(self.dimsSml, dtype=numpy.int32)
srcGrid = esmf.EsmfStructGrid(srcMaxIndex, coordSys=ESMF.CoordSys.CART)
srcGrid.setCoords(self.gridSml)
dstMaxIndex = numpy.array(self.dimsLrg, dtype=numpy.int32)
dstGrid = esmf.EsmfStructGrid(dstMaxIndex, coordSys=ESMF.CoordSys.CART)
dstGrid.setCoords(self.gridLrg)
srcField = esmf.EsmfStructField(srcGrid,
'srcData',
datatype=self.dataSml.dtype,
staggerloc=ESMF.StaggerLoc.CENTER)
srcField.setLocalData(self.dataSml * 0.0 - 1, ESMF.StaggerLoc.CENTER)
dstField = esmf.EsmfStructField(dstGrid,
'dstData',
datatype=self.dataLrg.dtype,
staggerloc=ESMF.StaggerLoc.CENTER)
dstField.setLocalData(self.dataLrg, ESMF.StaggerLoc.CENTER)
# The grids should be different
self.assertFalse(
numpy.all(srcField.getPointer() == dstField.getPointer()))
ro = esmf.EsmfRegrid(dstField, srcField)
ro()
srcAr = numpy.reshape(srcField.getPointer(), self.dimsSml)
dstAr = numpy.reshape(dstField.getPointer(), self.dimsLrg)
self.assertEqual(srcAr[-1, -1], dstAr[-1, -1])
def computeWeights(self, **args):
"""
Compute interpolation weights
@param **args (not used)
"""
self.regridObj = esmf.EsmfRegrid(self.srcFld, self.dstFld,
srcFrac = None,
dstFrac = None,
srcMaskValues = self.srcMaskValues,
dstMaskValues = self.dstMaskValues,
regridMethod = self.regridMethod,
unMappedAction = self.unMappedAction)
def XXtest1_esmf(self):
srcF = cdms2.open(cdat_info.get_prefix() + \
'/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = srcF('so')[0, 0, ...]
srcGridMask = numpy.array((so == so.missing_value), numpy.int32)
clt = cdms2.open(cdat_info.get_prefix() +
'/sample_data/clt.nc')('clt')[0, ...]
srcGrd = [so.getGrid().getLatitude(), so.getGrid().getLongitude()]
dG = clt.getGrid().toCurveGrid()
dstGrd = [dG.getLatitude()[:], dG.getLongitude()[:]]
srcBounds = cdms2.mvCdmsRegrid.getBoundList(srcGrd)
dstBounds = cdms2.mvCdmsRegrid.getBoundList(dstGrd)
srcGrid = esmf.EsmfStructGrid(srcGrd[0].shape,
coordSys=ESMP.ESMP_COORDSYS_SPH_DEG)
srcGrid.setCoords([numpy.array(coord) for coord in srcGrd],
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER,
globalIndexing=True)
srcGrid.setCoords(srcBounds,
staggerloc=ESMP.ESMP_STAGGERLOC_CORNER,
globalIndexing=True)
srcGrid.setMask(srcGridMask)
dstGrid = esmf.EsmfStructGrid(dstGrd[0].shape,
coordSys=ESMP.ESMP_COORDSYS_SPH_DEG)
dstGrid.setCoords([numpy.array(coord) for coord in dstGrd],
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER,
globalIndexing=True)
dstGrid.setCoords(dstBounds,
staggerloc=ESMP.ESMP_STAGGERLOC_CORNER,
globalIndexing=True)
srcFld = esmf.EsmfStructField(srcGrid,
'srcField',
datatype=so.dtype,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcFld.setLocalData(numpy.array(so),
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER,
globalIndexing=True)
dstFld = esmf.EsmfStructField(dstGrid,
'dstField',
datatype=so.dtype,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstFld.setLocalData(numpy.array(clt) * 0,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER,
globalIndexing=True)
srcFracFld = esmf.EsmfStructField(
srcGrid,
'srcFracAreasFld',
datatype='float64',
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcFracFld.setLocalData(numpy.ones(srcGrd[0].shape,
dtype=srcGrd[0].dtype),
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER,
globalIndexing=True)
dstFracFld = esmf.EsmfStructField(
dstGrid,
'dstFracAreasFld',
datatype='float64',
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstFracFld.setLocalData(numpy.ones(dstGrd[0].shape,
dtype=dstGrd[0].dtype),
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER,
globalIndexing=True)
# this fails on 7 and 8 procs (passing dstFrac = None works)
ro = esmf.EsmfRegrid(srcFld,
dstFld,
srcFrac=srcFracFld,
dstFrac=None,
srcMaskValues=numpy.array([1], numpy.int32),
dstMaskValues=numpy.array([1], numpy.int32),
regridMethod=ESMP.ESMP_REGRIDMETHOD_CONSERVE,
unMappedAction=ESMP.ESMP_UNMAPPEDACTION_IGNORE)
# interpolate
ro()
dstData = dstFld.getData(rootPe=0)
if self.pe == 0:
dstMask = (dstData >= 100)
dstDataM = numpy.ma.array(dstData, mask=dstMask)
dstDataM.missing_value = so.missing_value
zeroVal = (dstDataM == 0)
dstDataMMin = dstDataM.min()
dstDataMMax = dstDataM.max()
print 'Number of zero valued cells', zeroVal.sum()
print 'min/max value of dstDataM: %f %f' % (dstDataMMin,
dstDataMMax)
self.assertLess(dstDataMMax, so.max())
def test1_3D_esmf_Bilinear(self):
srcDims, srcXYZCenter, srcData, srcBounds = makeGrid(5, 4, 3)
dstDims, dstXYZCenter, dstData, dstBounds = makeGrid(5, 4, 3)
srcData = srcData.T
dstData = dstData.T
srcXYZCenter[0] = srcXYZCenter[0].T
dstXYZCenter[0] = dstXYZCenter[0].T
srcXYZCenter[1] = srcXYZCenter[1].T
dstXYZCenter[1] = dstXYZCenter[1].T
srcXYZCenter[2] = srcXYZCenter[2].T
dstXYZCenter[2] = dstXYZCenter[2].T
srcDims = srcDims[::-1]
dstDims = dstDims[::-1]
# Establish the destination grid
dstGrid3D = esmf.EsmfStructGrid(
dstData.shape,
periodicity=1,
coordSys=ESMF.CoordSys.CART,
staggerloc=ESMF.StaggerLoc.CENTER_VCENTER)
dstGrid3D.setCoords(dstXYZCenter,
staggerloc=ESMF.StaggerLoc.CENTER_VCENTER,
globalIndexing=True)
# Establish the Source grid
srcGrid3D = esmf.EsmfStructGrid(
srcData.shape,
periodicity=1,
coordSys=ESMF.CoordSys.CART,
staggerloc=ESMF.StaggerLoc.CENTER_VCENTER)
srcGrid3D.setCoords(srcXYZCenter,
staggerloc=ESMF.StaggerLoc.CENTER_VCENTER,
globalIndexing=True)
# Create and populate the fields
dstField = esmf.EsmfStructField(dstGrid3D, 'dstDataCtr', srcData.dtype,
ESMF.StaggerLoc.CENTER_VCENTER)
srcField = esmf.EsmfStructField(srcGrid3D, 'srcDataCtr', srcData.dtype,
ESMF.StaggerLoc.CENTER_VCENTER)
srcFldIn = esmf.EsmfStructField(srcGrid3D, 'srcDataInterp',
srcData.dtype,
ESMF.StaggerLoc.CENTER_VCENTER)
srcField.setLocalData(srcData,
ESMF.StaggerLoc.CENTER_VCENTER,
globalIndexing=True)
dstField.setLocalData(dstData * 0,
ESMF.StaggerLoc.CENTER_VCENTER,
globalIndexing=True)
srcFldIn.setLocalData(srcData * 0,
ESMF.StaggerLoc.CENTER_VCENTER,
globalIndexing=True)
# Regrid
regridOut = esmf.EsmfRegrid(srcField,
dstField,
srcMaskValues=None,
dstMaskValues=None,
regridMethod=ESMF.RegridMethod.BILINEAR,
unMappedAction=ESMF.UnmappedAction.IGNORE)
regridOut()
regridBck = esmf.EsmfRegrid(dstField,
srcFldIn,
srcMaskValues=None,
dstMaskValues=None,
regridMethod=ESMF.RegridMethod.BILINEAR,
unMappedAction=ESMF.UnmappedAction.IGNORE)
regridBck()
soInterp = dstField.getData(rootPe=self.rootPe)
soInterpInterp = srcFldIn.getData(rootPe=self.rootPe)
if self.pe == self.rootPe:
minlsd, maxlsd = srcData.min(), srcData.max()
minlsi, maxlsi = soInterp.min(), soInterp.max()
minlii, maxlii = soInterpInterp.min(), soInterpInterp.max()
self.assertEqual(minlsd, minlsi.round(2))
self.assertEqual(minlsd, minlii.round(2))
self.assertEqual(maxlsd, maxlsi.round(2))
self.assertEqual(maxlsd, maxlii.round(2))
# Regrid
regridOut = esmf.EsmfRegrid(srcField,
dstField,
srcMaskValues=None,
dstMaskValues=None,
regridMethod=ESMF.RegridMethod.CONSERVE,
unMappedAction=ESMF.UnmappedAction.IGNORE)
regridOut()
regridBck = esmf.EsmfRegrid(dstField,
srcFldIn,
srcMaskValues=None,
dstMaskValues=None,
regridMethod=ESMF.RegridMethod.CONSERVE,
unMappedAction=ESMF.UnmappedAction.IGNORE)
regridBck()
soInterp = dstField.getData(rootPe=self.rootPe)
soInterpInterp = srcFldIn.getData(rootPe=self.rootPe)
if self.pe == self.rootPe:
minlsd, maxlsd = srcData.min(), srcData.max()
minlsi, maxlsi = soInterp.min(), soInterp.max()
minlii, maxlii = soInterpInterp.min(), soInterpInterp.max()
self.assertEqual(minlsd, minlsi.round(2))
self.assertEqual(minlsd, minlii.round(2))
self.assertEqual(maxlsd, maxlsi.round(2))
self.assertEqual(maxlsd, maxlii.round(2))
def xtest2_2D_Native_Conserve(self):
print()
srcDims, srcXYZCenter, srcData, srcBounds = makeGrid(5, 4, 1)
dstDims, dstXYZCenter, dstData, dstBounds = makeGrid(5, 4, 1)
# Establish the Destination grid
dstGrid2D = esmf.EsmfStructGrid(dstData.shape[0:2],
periodicity=0,
coordSys=None,
hasBounds=True)
myCenter = [dstXYZCenter[0][:, :, 0], dstXYZCenter[1][:, :, 0]]
dstGrid2D.setCoords(myCenter,
staggerloc=ESMF.StaggerLoc.CENTER,
globalIndexing=True)
myBounds = [dstBounds[0][:, :, 0], dstBounds[1][:, :, 0]]
dstGrid2D.setCoords(myBounds,
staggerloc=ESMF.StaggerLoc.CORNER,
globalIndexing=True)
# Establish the Source grid
myCenter = [srcXYZCenter[0][:, :, 0], srcXYZCenter[1][:, :, 0]]
myBounds = [srcBounds[0][:, :, 0], srcBounds[1][:, :, 0]]
srcGrid2D = esmf.EsmfStructGrid(srcData.shape[0:2],
periodicity=0,
coordSys=None,
hasBounds=True)
srcGrid2D.setCoords(myCenter,
staggerloc=ESMF.StaggerLoc.CENTER,
globalIndexing=True)
srcGrid2D.setCoords(myBounds,
staggerloc=ESMF.StaggerLoc.CORNER,
globalIndexing=True)
# Create and populate the fields
dstField = esmf.EsmfStructField(dstGrid2D, 'dstDataCtr', srcData.dtype,
ESMF.StaggerLoc.CENTER)
srcField = esmf.EsmfStructField(srcGrid2D, 'srcDataCtr', srcData.dtype,
ESMF.StaggerLoc.CENTER)
srcFldIn = esmf.EsmfStructField(srcGrid2D, 'srcDataInterp',
srcData.dtype, ESMF.StaggerLoc.CENTER)
srcField.setLocalData(srcData[:, :, 0],
ESMF.StaggerLoc.CENTER,
globalIndexing=True)
dstField.setLocalData(dstData[:, :, 0] * 0,
ESMF.StaggerLoc.CENTER,
globalIndexing=True)
srcFldIn.setLocalData(srcData[:, :, 0] * 0,
ESMF.StaggerLoc.CENTER,
globalIndexing=True)
# Regrid
regridOut = esmf.EsmfRegrid(srcField,
dstField,
srcMaskValues=numpy.array([0]),
regridMethod=ESMF.RegridMethod.CONSERVE,
unMappedAction=ESMF.UnmappedAction.ERROR)
# unMappedAction = ESMF.UnmappedAction.IGNORE)
regridOut()
regridBck = esmf.EsmfRegrid(dstField,
srcFldIn,
srcMaskValues=numpy.array([0]),
regridMethod=ESMF.RegridMethod.CONSERVE,
unMappedAction=ESMF.UnmappedAction.ERROR)
regridBck()
soInterp = dstField.getData(rootPe=self.rootPe)
soInterpInterp = srcFldIn.getData(rootPe=self.rootPe)
if self.pe == self.rootPe:
minlsd, maxlsd = srcData.min(), srcData.max()
minlsi, maxlsi = soInterp.min(), soInterp.max()
minlii, maxlii = soInterpInterp.min(), soInterpInterp.max()
self.assertEqual(minlsd, minlsi)
self.assertEqual(maxlsd, maxlsi)
def dtest2_3D_Native_Conserve(self):
print()
# srcDims, srcXYZCenter, srcData, srcBounds = makeGrid(5, 4, 3)
# dstDims, dstXYZCenter, dstData, dstBounds = makeGrid(5, 4, 3)
[z, y, x] = [0, 1, 2]
xdom = [1, 5]
nx = 5
xs = np.linspace(xdom[0], xdom[1], nx + 1)
xcorner = np.array([xs[0:-1], xs[1::]]).T
xcenter = (xcorner[:, 1] + xcorner[:, 0]) / 2
ydom = [1, 4]
ny = 4
# +1 because corners have one more than center
ys = np.linspace(ydom[0], ydom[1], ny + 1)
ycorner = np.array([ys[0:-1], ys[1::]]).T
ycenter = (ycorner[:, 1] + ycorner[:, 0]) / 2
zdom = [1, 3]
nz = 3
# +1 because corners have one more than center
zs = np.linspace(zdom[0], zdom[1], nz + 1)
zcorner = np.array([zs[0:-1], zs[1::]]).T
zcenter = (zcorner[:, 1] + zcorner[:, 0]) / 2
srcData = np.random.rand(zs.shape[0] - 1, ys.shape[0] - 1,
xs.shape[0] - 1) * 100
dstData = np.random.rand(zs.shape[0] - 1, ys.shape[0] - 1,
xs.shape[0] - 1) * 100
print((srcData.dtype))
# Establish the Destination grid
# myCenter = [dstXYZCenter[0][:,:,:], dstXYZCenter[1][:,:,:],dstXYZCenter[2][:,:,:]]
ZCenter = np.zeros([nz, ny, nx])
YCenter = np.zeros([nz, ny, nx])
XCenter = np.zeros([nz, ny, nx])
ZCenter[...] = zcenter[0:nz].reshape(nz, 1, 1)
YCenter[...] = ycenter[0:ny].reshape(1, ny, 1)
XCenter[...] = xcenter[0:nx].reshape(1, 1, nx)
boundsz = np.zeros([nz + 1, ny + 1, nx + 1])
boundsy = np.zeros([nz + 1, ny + 1, nx + 1])
boundsx = np.zeros([nz + 1, ny + 1, nx + 1])
for i0 in range(nz):
boundsz[i0, :, ] = zcorner[i0, 0]
boundsz[-1, :, :] = zcorner[-1, 1]
for i1 in range(ny):
boundsy[:, i1, :] = ycorner[i1, 0]
boundsy[:, -1, :] = ycorner[-1, 1]
for i2 in range(nx):
boundsx[:, :, i2] = xcorner[i2, 0]
boundsx[:, :, -1] = xcorner[-1, 1]
print((boundsz[:, 1, 1]))
print((boundsy[1, :, 1]))
print((boundsx[1, 1, :]))
myCenter = [ZCenter, YCenter, XCenter]
dstGrid3D = esmf.EsmfStructGrid(dstData.shape,
periodicity=0,
coordSys=ESMF.CoordSys.CART,
hasBounds=True)
dstGrid3D.setCoords(myCenter,
staggerloc=ESMF.StaggerLoc.CENTER,
globalIndexing=True)
# myBounds = [dstBounds[0][:,:,:], dstBounds[1][:,:,:], dstBounds[2][:,:,:]]
myBounds = [boundsz, boundsy, boundsx]
dstGrid3D.setCoords(myBounds,
staggerloc=ESMF.StaggerLoc.CORNER_VFACE,
globalIndexing=True)
# Establish the Source grid
# myCenter = [srcXYZCenter[0][:,:,:], srcXYZCenter[1][:,:,:], srcXYZCenter[2][:,:,:]]
# myBounds = [srcBounds[0][:,:,:], srcBounds[1][:,:,:], srcBounds[2][:,:,:]]
srcGrid3D = esmf.EsmfStructGrid(srcData.shape,
periodicity=0,
coordSys=ESMF.CoordSys.CART,
hasBounds=True)
srcGrid3D.setCoords(myCenter,
staggerloc=ESMF.StaggerLoc.CENTER,
globalIndexing=True)
srcGrid3D.setCoords(myBounds,
staggerloc=ESMF.StaggerLoc.CORNER_VFACE,
globalIndexing=True)
# Create and populate the fields
dstField = esmf.EsmfStructField(dstGrid3D, 'dstDataCtr', srcData.dtype,
ESMF.StaggerLoc.CENTER)
srcField = esmf.EsmfStructField(srcGrid3D, 'srcDataCtr', srcData.dtype,
ESMF.StaggerLoc.CENTER)
srcFldIn = esmf.EsmfStructField(srcGrid3D, 'srcDataInterp',
srcData.dtype, ESMF.StaggerLoc.CENTER)
srcField.setLocalData(srcData,
ESMF.StaggerLoc.CENTER,
globalIndexing=True)
dstField.setLocalData(dstData * 0,
ESMF.StaggerLoc.CENTER,
globalIndexing=True)
srcFldIn.setLocalData(srcData * 0,
ESMF.StaggerLoc.CENTER,
globalIndexing=True)
# Regrid
regridOut = esmf.EsmfRegrid(srcField,
dstField,
srcMaskValues=numpy.array([0]),
regridMethod=ESMF.RegridMethod.CONSERVE,
unMappedAction=ESMF.UnmappedAction.ERROR)
# unMappedAction = ESMF.UnmappedAction.IGNORE)
regridOut()
regridBck = esmf.EsmfRegrid(dstField,
srcFldIn,
srcMaskValues=numpy.array([0]),
regridMethod=ESMF.RegridMethod.CONSERVE,
unMappedAction=ESMF.UnmappedAction.ERROR)
# unMappedAction = ESMF.UnmappedAction.IGNORE)
regridBck()
soInterp = dstField.getData(rootPe=self.rootPe)
soInterpInterp = srcFldIn.getData(rootPe=self.rootPe)
if self.pe == self.rootPe:
minlsd, maxlsd = srcData.min(), srcData.max()
minlsi, maxlsi = soInterp.min(), soInterp.max()
minlii, maxlii = soInterpInterp.min(), soInterpInterp.max()
self.assertEqual(minlsd, minlsi)
self.assertEqual(maxlsd, maxlsi)
def Xtest3_esmf(self):
print
print 'test3_esmf'
srcF = cdms2.open(sys.prefix + \
'/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = srcF('so')[0, 0, ...]
clt = cdms2.open(sys.prefix + '/sample_data/clt.nc')('clt')[0, ...]
diag = {
'srcAreas': None,
'dstAreas': None,
'srcAreaFractions': None,
'dstAreaFractions': None
}
srcCoords = [
so.getGrid().getLatitude()[:],
so.getGrid().getLongitude()[:]
]
srcBounds = cdms2.mvCdmsRegrid.getBoundList(srcCoords)
tmp = clt.getGrid().toCurveGrid()
dstCoords = [tmp.getLatitude()[:], tmp.getLongitude()[:]]
dstBounds = cdms2.mvCdmsRegrid.getBoundList(dstCoords)
# Establish the grids
srcGrid = esmf.EsmfStructGrid(so.shape, periodicity=1)
dstGrid = esmf.EsmfStructGrid(clt.shape, periodicity=1)
srcGrid.setCoords(srcCoords)
dstGrid.setCoords(dstCoords)
srcGrid.setCoords(srcBounds, staggerloc=esmf.CORNER)
dstGrid.setCoords(dstBounds, staggerloc=esmf.CORNER)
# Establish the fields
srcFeld = esmf.EsmfStructField(srcGrid, 'srcFeld', so.dtype)
dstFeld = esmf.EsmfStructField(dstGrid, 'dstFeld', so.dtype)
srcFeldPtr = srcFeld.getPointer()
srcFeldPtr[:] = so.data.flat
dstFeldPtr = dstFeld.getPointer()
dstFeldPtr[:] = so.missing_value
# Fractions
srcFrac = esmf.EsmfStructField(srcGrid, 'srcFrac', so.dtype)
dstFrac = esmf.EsmfStructField(dstGrid, 'dstFrac', so.dtype)
srcFracPtr = srcFrac.getPointer()
srcFracPtr[:] = 1.0
dstFracPtr = dstFrac.getPointer()
dstFracPtr[:] = 1.0
nnan = numpy.isnan(srcFeldPtr).sum()
if nnan > 0: print "There are nan's in srcFracPtr"
# Areas
presrcArea = esmf.EsmfStructField(srcGrid, 'srcArea', so.dtype)
predstArea = esmf.EsmfStructField(dstGrid, 'dstArea', so.dtype)
presrcAreaPtr = presrcArea.getPointer()
presrcAreaPtr[:] = 1.0
predstAreaPtr = predstArea.getPointer()
predstAreaPtr[:] = 1.0
ro = esmf.EsmfRegrid(srcFeld,
dstFeld,
srcFrac=srcFrac,
dstFrac=dstFrac,
srcMaskValues=None,
dstMaskValues=None,
regridMethod=esmf.CONSERVE,
unMappedAction=esmf.IGNORE)
ro()
srcAreas = ro.getSrcAreas(None)
dstAreas = ro.getDstAreas(None)
srcFracPtrPost = ro.getSrcAreaFractions(None)
nnanPost = numpy.isnan(srcFracPtrPost).sum()
nnan = numpy.isnan(srcFracPtr).sum()
if nnan > 0 or nnanPost > 0:
print "There are nan's in srcFracPtrPost", nnanPost
print "There are nan's in srcFracPtr", nnan
self.assertNotEqual(nnan, 0)
self.assertNotEqual(nnanPost, 0)
dstFracPtrPost = ro.getDstAreaFractions(None)
nnanPost = numpy.isnan(dstFracPtrPost).sum()
nnan = numpy.isnan(dstFracPtrPost).sum()
if nnan > 0 or nnanPost > 0:
print "There are nan's in dstFracPtrPost", nnanPost
print "There are nan's in dstFracPtr", nnan
self.assertNotEqual(nnan, 0)
self.assertNotEqual(nnanPost, 0)
srcMass = (srcFeldPtr * srcAreas.flatten() * srcFracPtr).sum()
dstMass = (dstFeldPtr * dstAreas.flatten()).sum()
dstMassPtr = (dstFeldPtr * predstAreaPtr).sum()
diff = abs(srcMass - dstMass)
self.assertLess(diff / srcMass, 1.e-7)
def test_field_regrid_periodic(self):
parallel = False
# create a grid
srcgrid = grid_create_periodic(60, 30, corners=True, domask=True)
dstgrid = grid_create_periodic(55, 28, corners=True)
srcGrid2D = esmf.EsmfStructGrid(srcgrid.coords[0][0].shape,
periodicity=1,
coordSys=None,
hasBounds=True)
mycoords = [srcgrid.coords[0][1], srcgrid.coords[0][0]]
srcGrid2D.setCoords(mycoords,
staggerloc=ESMF.StaggerLoc.CENTER,
globalIndexing=True)
mycoords = [srcgrid.coords[3][1], srcgrid.coords[3][0]]
srcGrid2D.setCoords(mycoords,
staggerloc=ESMF.StaggerLoc.CORNER,
globalIndexing=True)
dstGrid2D = esmf.EsmfStructGrid(dstgrid.coords[0][0].shape,
periodicity=1,
coordSys=None,
hasBounds=True)
mycoords = [dstgrid.coords[0][1], dstgrid.coords[0][0]]
dstGrid2D.setCoords(mycoords,
staggerloc=ESMF.StaggerLoc.CENTER,
globalIndexing=True)
mycoords = [dstgrid.coords[3][1], dstgrid.coords[3][0]]
dstGrid2D.setCoords(mycoords,
staggerloc=ESMF.StaggerLoc.CORNER,
globalIndexing=True)
# create the Fields
srcfield = esmf.EsmfStructField(srcGrid2D, 'srcDataCtr',
srcgrid.coords[0][0].dtype,
ESMF.StaggerLoc.CENTER)
dstfield = esmf.EsmfStructField(dstGrid2D, 'dstDataCtr',
dstgrid.coords[0][0].dtype,
ESMF.StaggerLoc.CENTER)
exactfield = esmf.EsmfStructField(dstGrid2D, 'exactDataCtr',
dstgrid.coords[0][0].dtype,
ESMF.StaggerLoc.CENTER)
# srcfield = ESMF.Field(srcgrid, name='srcfield')
# dstfield = ESMF.Field(dstgrid, name='dstfield')
# exactfield = ESMF.Field(dstgrid, name='exactfield')
# create the fraction fields
srcfracfield = esmf.EsmfStructField(srcGrid2D, 'srcfracfield',
srcgrid.coords[0][0].dtype,
ESMF.StaggerLoc.CENTER)
dstfracfield = esmf.EsmfStructField(dstGrid2D, 'dstfracfield',
srcgrid.coords[0][0].dtype,
ESMF.StaggerLoc.CENTER)
# srcfracfield = ESMF.Field(srcgrid, name='srcfracfield')
# dstfracfield = ESMF.Field(dstgrid, name='dstfracfield')
# initialize the Fields to an analytic function
srcfield.field = initialize_field_grid_periodic(srcfield.field)
exactfield.field = initialize_field_grid_periodic(exactfield.field)
# run the ESMF regridding
regridOut = esmf.EsmfRegrid(srcfield,
dstfield,
srcMaskValues=np.array([0]),
regridMethod=ESMF.RegridMethod.CONSERVE,
unMappedAction=ESMF.UnmappedAction.ERROR,
srcFrac=srcfracfield,
dstFrac=dstfracfield)
regridOut()
# regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
# src_mask_values=np.array([0]),
# regrid_method=ESMF.RegridMethod.CONSERVE,
# unmapped_action=ESMF.UnmappedAction.ERROR,
# src_frac_field=srcfracfield,
# dst_frac_field=dstfracfield)
# dstfield = regridSrc2Dst(srcfield, dstfield)
# compute the mass
srcmass = compute_mass_grid(srcfield.field,
dofrac=True,
fracfield=srcfracfield.field)
dstmass = compute_mass_grid(dstfield.field)
# compare results and output PASS or FAIL
meanrel, csrvrel = compare_fields_grid(dstfield.field,
exactfield.field,
10E-2,
10e-15,
parallel=parallel,
dstfracfield=dstfracfield.field,
mass1=srcmass,
mass2=dstmass)
self.assertAlmostEqual(meanrel, 0.0016447124122954575)
self.assertAlmostEqual(csrvrel, 0.0)
def test1_3D_esmf_Bilinear(self):
srcDims, srcXYZCenter, srcData, srcBounds = makeGrid(5, 4, 3)
dstDims, dstXYZCenter, dstData, dstBounds = makeGrid(5, 4, 3)
# Establish the destination grid
dstGrid3D = esmf.EsmfStructGrid(dstData.shape,
coordSys=ESMP.ESMP_COORDSYS_CART)
dstGrid3D.setCoords(dstXYZCenter,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER_VCENTER,
globalIndexing=True)
# Establish the Source grid
srcGrid3D = esmf.EsmfStructGrid(srcData.shape,
coordSys=ESMP.ESMP_COORDSYS_CART)
srcGrid3D.setCoords(srcXYZCenter,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER_VCENTER,
globalIndexing=True)
# Create and populate the fields
dstField = esmf.EsmfStructField(dstGrid3D, 'dstDataCtr', srcData.dtype,
ESMP.ESMP_STAGGERLOC_CENTER_VCENTER)
srcField = esmf.EsmfStructField(srcGrid3D, 'srcDataCtr', srcData.dtype,
ESMP.ESMP_STAGGERLOC_CENTER_VCENTER)
srcFldIn = esmf.EsmfStructField(srcGrid3D, 'srcDataInterp',
srcData.dtype,
ESMP.ESMP_STAGGERLOC_CENTER_VCENTER)
srcField.setLocalData(srcData,
ESMP.ESMP_STAGGERLOC_CENTER_VCENTER,
globalIndexing=True)
dstField.setLocalData(dstData * 0,
ESMP.ESMP_STAGGERLOC_CENTER_VCENTER,
globalIndexing=True)
srcFldIn.setLocalData(srcData * 0,
ESMP.ESMP_STAGGERLOC_CENTER_VCENTER,
globalIndexing=True)
# Regrid
regridOut = esmf.EsmfRegrid(
srcField,
dstField,
srcMaskValues=None,
dstMaskValues=None,
regridMethod=ESMP.ESMP_REGRIDMETHOD_BILINEAR,
unMappedAction=ESMP.ESMP_UNMAPPEDACTION_IGNORE)
regridOut()
regridBck = esmf.EsmfRegrid(
dstField,
srcFldIn,
srcMaskValues=None,
dstMaskValues=None,
regridMethod=ESMP.ESMP_REGRIDMETHOD_BILINEAR,
unMappedAction=ESMP.ESMP_UNMAPPEDACTION_IGNORE)
regridBck()
soInterp = dstField.getData(rootPe=self.rootPe)
soInterpInterp = srcFldIn.getData(rootPe=self.rootPe)
if self.pe == self.rootPe:
minlsd, maxlsd = srcData.min(), srcData.max()
minlsi, maxlsi = soInterp.min(), soInterp.max()
minlii, maxlii = soInterpInterp.min(), soInterpInterp.max()
self.assertEqual(minlsd, minlsi.round(2))
self.assertEqual(minlsd, minlii.round(2))
self.assertEqual(maxlsd, maxlsi.round(2))
self.assertEqual(maxlsd, maxlii.round(2))
