def test_grid_grid_3d_bilinear_spherical(self):
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
# create a grid
srcgrid = grid_create_from_bounds_periodic_3d(60, 60, 14, corners=False)
dstgrid = grid_create_from_bounds_periodic_3d(50, 50, 11, corners=False)
# create Field objects on the Meshes
srcfield = ESMF.Field(srcgrid, name='srcfield')
dstfield = ESMF.Field(dstgrid, name='dstfield')
exactfield = ESMF.Field(dstgrid, name='exactfield')
# initialize the Fields to an analytic function
srcfield = initialize_field_grid_periodic_3d(srcfield)
exactfield = initialize_field_grid_periodic_3d(exactfield)
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
regrid_method=ESMF.RegridMethod.BILINEAR,
unmapped_action=ESMF.UnmappedAction.IGNORE)
dstfield = regridSrc2Dst(srcfield, dstfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, exactfield,
10E-03, 10E-03, 10E-16)
self.assertAlmostEqual(meanrel, 0.00061587737764545617)
self.assertAlmostEqual(csrvrel, 0.0)
def test_grid_grid_3d_bilinear_cartesian(self):
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
# create a grid
srcgrid = grid_create_from_bounds_3d([0, 21], [0, 21], [0, 21], 21, 21, 21, corners=False)
dstgrid = grid_create_from_bounds_3d([0.5, 19.5], [0.5, 19.5], [0.5, 19.5], 19, 19, 19, corners=False)
# create Field objects on the Meshes
srcfield = ESMF.Field(srcgrid, name='srcfield')
dstfield = ESMF.Field(dstgrid, name='dstfield')
exactfield = ESMF.Field(dstgrid, name='exactfield')
# initialize the Fields to an analytic function
srcfield = initialize_field_grid_3d(srcfield)
exactfield = initialize_field_grid_3d(exactfield)
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
regrid_method=ESMF.RegridMethod.BILINEAR,
unmapped_action=ESMF.UnmappedAction.ERROR)
dstfield = regridSrc2Dst(srcfield, dstfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, exactfield,
10E-02, 10E-02, 10E-16)
self.assertAlmostEqual(meanrel, 0.00215601743167)
self.assertAlmostEqual(csrvrel, 0.0)
def test_mesh_mesh_regrid(self):
parallel = False
if ESMF.pet_count() > 1:
if ESMF.pet_count() > 4:
raise NameError('MPI rank must be 4 in parallel mode!')
parallel = True
# create two unique Mesh objects
if parallel:
srcmesh, nodeCoordSrc, nodeOwnerSrc, elemTypeSrc, elemConnSrc = \
mesh_create_50_parallel()
dstmesh, nodeCoordDst, nodeOwnerDst, elemTypeDst, elemConnDst = \
mesh_create_10_parallel()
else:
srcmesh, nodeCoordSrc, nodeOwnerSrc, elemTypeSrc, elemConnSrc, _ = \
mesh_create_50()
dstmesh, nodeCoordDst, nodeOwnerDst, elemTypeDst, elemConnDst, _ = \
mesh_create_10()
# create ESMP_Field objects on the Meshes
srcfield = ESMF.Field(srcmesh, name='srcfield', meshloc=ESMF.MeshLoc.ELEMENT)
srcfracfield = ESMF.Field(srcmesh, name='srcfracfield', meshloc=ESMF.MeshLoc.ELEMENT)
dstfield = ESMF.Field(dstmesh, name='dstfield', meshloc=ESMF.MeshLoc.ELEMENT)
dstfracfield = ESMF.Field(dstmesh, name='dstfracfield', meshloc=ESMF.MeshLoc.ELEMENT)
exactfield = ESMF.Field(dstmesh, name='exactfield', meshloc=ESMF.MeshLoc.ELEMENT)
# initialize the Fields to an analytic function
srcfield = initialize_field_mesh(srcfield, nodeCoordSrc, nodeOwnerSrc,
elemTypeSrc, elemConnSrc)
exactfield = initialize_field_mesh(exactfield, nodeCoordDst, nodeOwnerDst,
elemTypeDst, elemConnDst)
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
regrid_method=ESMF.RegridMethod.CONSERVE,
norm_type=ESMF.NormType.FRACAREA,
unmapped_action=ESMF.UnmappedAction.ERROR,
ignore_degenerate=True,
src_frac_field=srcfracfield,
dst_frac_field=dstfracfield)
dstfield = regridSrc2Dst(srcfield, dstfield)
# compute the mass
srcmass = compute_mass_mesh(srcfield,
dofrac=True, fracfield=srcfracfield)
dstmass = compute_mass_mesh(dstfield,
dofrac=True, fracfield=dstfracfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, exactfield,
20E-2, 20E-2, 10E-16,
dstfracfield=dstfracfield,
mass1=srcmass, mass2=dstmass)
self.assertAlmostEqual(meanrel, 0.037109375)
self.assertAlmostEqual(csrvrel, 0.0)
def est_grid_mesh_pentatri_regrid_csrv(self):
parallel = False
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
parallel = True
# create a Mesh
if parallel:
mesh, nodeCoord, nodeOwner, elemType, elemConn = \
mesh_create_50_ngons_parallel()
else:
mesh, nodeCoord, nodeOwner, elemType, elemConn = \
mesh_create_50_ngons()
# create a grid
grid = grid_create_from_bounds([0, 4], [0, 4], 8, 8, corners=True, doarea=True)
# create Field objects on the Meshes
srcfield = ESMF.Field(mesh, name='srcfield', meshloc=ESMF.MeshLoc.ELEMENT)
srcfracfield = ESMF.Field(mesh, name='srcfracfield', meshloc=ESMF.MeshLoc.ELEMENT)
# make gridded fields
exactfield = ESMF.Field(grid, name='exactfield')
dstfield = ESMF.Field(grid, name='dstfield')
dstfracfield = ESMF.Field(grid, name='dstfracfield')
# initialize the Fields to an analytic function
# srcfield = initialize_field_mesh(srcfield, nodeCoord, nodeOwner, elemType, elemConn)
# exactfield = initialize_field_grid(exactfield)
# TODO: cannot make analytic fields on ngons yet
srcfield.data[...] = 25.
exactfield.data[...] = 25.
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
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_mesh(srcfield, dofrac=True,
fracfield=srcfracfield)
dstmass = compute_mass_grid(dstfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, exactfield,
80E-1, 80E-1, 10E-15,
dstfracfield=dstfracfield,
mass1=srcmass, mass2=dstmass)
assert (meanrel < 10E-2)
assert (csrvrel < 10E-14)
def test_grid_mesh_regrid_csrv_mask(self):
parallel = False
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
parallel = True
# create a Mesh
if parallel:
mesh, nodeCoord, nodeOwner, elemType, elemConn, elemMask, elemArea = \
mesh_create_50_parallel(domask=True, doarea=True)
else:
mesh, nodeCoord, nodeOwner, elemType, elemConn, elemMask, elemArea = \
mesh_create_50(domask=True, doarea=True)
# create a grid
grid = grid_create_from_bounds([0, 4], [0, 4], 8, 8, corners=True, doarea=True)
# create Field objects on the Meshes
srcfield = ESMF.Field(mesh, name='srcfield', meshloc=ESMF.MeshLoc.ELEMENT)
srcfracfield = ESMF.Field(mesh, name='srcfracfield', meshloc=ESMF.MeshLoc.ELEMENT)
# make gridded fields
exactfield = ESMF.Field(grid, name='exactfield')
dstfield = ESMF.Field(grid, name='dstfield')
dstfracfield = ESMF.Field(grid, name='dstfracfield')
# initialize the Fields to an analytic function
srcfield = initialize_field_mesh(srcfield, nodeCoord, nodeOwner, elemType, elemConn,
domask=True, elemMask=elemMask)
exactfield = initialize_field_grid(exactfield)
# run the ESMF regridding
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_mesh(srcfield, dofrac=True,
fracfield=srcfracfield)
dstmass = compute_mass_grid(dstfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, exactfield,
80E-1, 80E-1, 10E-15,
dstfracfield=dstfracfield,
mass1=srcmass, mass2=dstmass)
self.assertAlmostEqual(meanrel, 0.038806630051265847)
self.assertAlmostEqual(csrvrel, 0.0)
def test_grid_mesh_regrid_csrv(self):
parallel = False
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
parallel = True
# create a Mesh
if parallel:
mesh, nodeCoord, nodeOwner, elemType, elemConn = \
mesh_create_50_parallel()
else:
mesh, nodeCoord, nodeOwner, elemType, elemConn, _ = \
mesh_create_50()
# create a grid
grid = grid_create_from_bounds([0, 4], [0, 4], 8, 8, corners=True)
# create Fields
srcfield = ESMF.Field(mesh, name='srcfield', meshloc=ESMF.MeshLoc.ELEMENT)
srcfracfield = ESMF.Field(mesh, name='srcfracfield', meshloc=ESMF.MeshLoc.ELEMENT)
dstfield = ESMF.Field(grid, name='dstfield')
dstfracfield = ESMF.Field(grid, name='dstfracfield')
exactfield = ESMF.Field(grid, name='exactfield')
# initialize the Fields to an analytic function
srcfield = initialize_field_mesh(srcfield, nodeCoord, nodeOwner, elemType, elemConn)
exactfield = initialize_field_grid(exactfield)
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
regrid_method=ESMF.RegridMethod.CONSERVE,
norm_type=ESMF.NormType.FRACAREA,
unmapped_action=ESMF.UnmappedAction.ERROR,
src_frac_field=srcfracfield,
dst_frac_field=dstfracfield)
dstfield = regridSrc2Dst(srcfield, dstfield)
# compute the mass
srcmass = compute_mass_mesh(srcfield,
dofrac=True, fracfield=srcfracfield)
dstmass = compute_mass_grid(dstfield,
dofrac=True, fracfield=dstfracfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, exactfield,
50E-1, 50E-1, 10E-16,
dstfracfield=dstfracfield,
mass1=srcmass, mass2=dstmass)
self.assertAlmostEqual(meanrel, 0.037733241800767432)
self.assertAlmostEqual(csrvrel, 0.0)
def test_field_regrid_periodic(self):
parallel = False
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
parallel = True
# create a grid
srcgrid = grid_create_from_bounds_periodic(60, 30, corners=True, domask=True)
dstgrid = grid_create_from_bounds_periodic(55, 28, corners=True)
# create the Fields
srcfield = ESMF.Field(srcgrid, name='srcfield')
dstfield = ESMF.Field(dstgrid, name='dstfield')
exactfield = ESMF.Field(dstgrid, name='exactfield')
# create the fraction fields
srcfracfield = ESMF.Field(srcgrid, name='srcfracfield')
dstfracfield = ESMF.Field(dstgrid, name='dstfracfield')
# initialize the Fields to an analytic function
srcfield = initialize_field_grid_periodic(srcfield)
exact_field = initialize_field_grid_periodic(exactfield)
# run the ESMF regridding
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,
dofrac=True, fracfield=srcfracfield)
dstmass = compute_mass_grid(dstfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, exact_field,
10E-2, 10E-2, 10e-15,
dstfracfield=dstfracfield,
mass1=srcmass, mass2=dstmass)
self.assertAlmostEqual(meanrel, 0.0016447124122954575)
self.assertAlmostEqual(csrvrel, 0.0)
def test_grid_grid_regrid_srcmask_types(self):
# NOTE: this tests an old issue where the items of a grid were not properly set when
# the grid coord_typekind differed from the field typekind.
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
# create two unique Grid objects
srcgrid = grid_create_from_bounds([0, 21], [0, 21], 21, 21, corners=True, domask=True,
ctk=ESMF.TypeKind.R4)
dstgrid = grid_create_from_bounds([0.5, 19.5], [0.5, 19.5], 19, 19, corners=True)
# create Field objects on the Meshes
srcfield = ESMF.Field(srcgrid, name='srcfield')
srcfracfield = ESMF.Field(srcgrid, name='srcfracfield')
dstfield = ESMF.Field(dstgrid, name='dstfield')
dstfracfield = ESMF.Field(dstgrid, name='dstfracfield')
exactfield = ESMF.Field(dstgrid, name='exactfield')
# initialize the Fields to an analytic function
srcfield = initialize_field_grid(srcfield)
dstfield2 = initialize_field_grid(exactfield)
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
src_mask_values=[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,
dofrac=True, fracfield=srcfracfield)
dstmass = compute_mass_grid(dstfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, dstfield2,
10E-2, 10E-2, 10E-16,
dstfracfield=dstfracfield,
mass1=srcmass, mass2=dstmass)
self.assertAlmostEqual(meanrel, 0.0024803189848013785)
self.assertAlmostEqual(csrvrel, 0.0)
def test_field_regrid_extrapolation(self):
parallel = False
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
parallel = True
# create a grid
grid = grid_create_from_bounds([0, 4], [0, 4], 8, 8, corners=True)
# create a Mesh
if parallel:
mesh, nodeCoord, nodeOwner, elemType, elemConn = \
mesh_create_50_parallel()
else:
mesh, nodeCoord, nodeOwner, elemType, elemConn, _ = \
mesh_create_50()
# create Field objects
srcfield = ESMF.Field(grid, name='srcfield')
dstfield = ESMF.Field(mesh, name='dstfield')
exactfield = ESMF.Field(mesh, name='exactfield')
# initialize the Fields to an analytic function
srcfield = initialize_field_grid(srcfield)
exactfield = initialize_field_mesh(exactfield, nodeCoord, nodeOwner, elemType, elemConn)
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
regrid_method=ESMF.RegridMethod.BILINEAR,
extrap_method=ESMF.ExtrapMethod.NEAREST_IDAVG,
extrap_num_src_pnts=10,
extrap_dist_exponent=1.2,
unmapped_action=ESMF.UnmappedAction.ERROR)
dstfield = regridSrc2Dst(srcfield, dstfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, exactfield,
40E-2, 40E-2, 10E-16,
regrid_method=ESMF.RegridMethod.BILINEAR)
self.assertAlmostEqual(meanrel, 0.0)
self.assertAlmostEqual(csrvrel, 0.0)
def test_grid_grid_regrid_csrv_2nd_mask(self):
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
# create two unique Grid objects
srcgrid = grid_create_from_bounds([0, 21], [0, 21], 21, 21, corners=True, domask=True)
dstgrid = grid_create_from_bounds([0.5, 19.5], [0.5, 19.5], 19, 19, corners=True)
# create Field objects on the Meshes
srcfield = ESMF.Field(srcgrid, name='srcfield')
srcfracfield = ESMF.Field(srcgrid, name='srcfracfield')
dstfield = ESMF.Field(dstgrid, name='dstfield')
dstfracfield = ESMF.Field(dstgrid, name='dstfracfield')
exactfield = ESMF.Field(dstgrid, name='exactfield')
# initialize the Fields to an analytic function
srcfield = initialize_field_grid(srcfield)
dstfield2 = initialize_field_grid(exactfield)
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
src_mask_values=np.array([0]),
regrid_method=ESMF.RegridMethod.CONSERVE_2ND,
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,
dofrac=True, fracfield=srcfracfield)
dstmass = compute_mass_grid(dstfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, dstfield2,
10E-2, 10E-2, 10E-16,
dstfracfield=dstfracfield,
mass1=srcmass, mass2=dstmass)
self.assertAlmostEqual(meanrel, 0.0020296891000258252)
self.assertAlmostEqual(csrvrel, 0.0)
def test_grid_mesh_pentatri_regrid_bilinear(self):
parallel = False
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
parallel = True
# create a Mesh
if parallel:
mesh, nodeCoord, nodeOwner, elemType, elemConn = \
mesh_create_50_ngons_parallel()
else:
mesh, nodeCoord, nodeOwner, elemType, elemConn = \
mesh_create_50_ngons()
# create a grid
grid = grid_create_from_bounds([0, 4], [0, 4], 8, 8, corners=True, doarea=True)
# create Field objects on the Meshes
srcfield = ESMF.Field(mesh, name='srcfield', meshloc=ESMF.MeshLoc.NODE)
# make gridded fields
exactfield = ESMF.Field(grid, name='exactfield')
dstfield = ESMF.Field(grid, name='dstfield')
# initialize the Fields to an analytic function
# srcfield = initialize_field_mesh(srcfield, nodeCoord, nodeOwner, elemType, elemConn)
# exactfield = initialize_field_grid(exactfield)
# TODO: cannot make analytic fields on ngons yet
srcfield.data[...] = 25.
exactfield.data[...] = 25.
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
regrid_method=ESMF.RegridMethod.BILINEAR,
unmapped_action=ESMF.UnmappedAction.ERROR)
dstfield = regridSrc2Dst(srcfield, dstfield)
# compare results and output PASS or FAIL
meanrel, _, _ = compare_fields(dstfield, exactfield, 80E-1, 80E-1, 10E-16)
self.assertAlmostEqual(meanrel, 0)
def test_grid_mesh_regrid_mask(self):
parallel = False
if ESMF.pet_count() > 1:
if ESMF.pet_count() != 4:
raise NameError('MPI rank must be 4 in parallel mode!')
parallel = True
# create a grid
grid = grid_create_from_bounds([0, 4], [0, 4], 8, 8, corners=True, domask=True)
# create a Mesh
if parallel:
mesh, nodeCoord, nodeOwner, elemType, elemConn = \
mesh_create_50_parallel()
else:
mesh, nodeCoord, nodeOwner, elemType, elemConn, _ = \
mesh_create_50()
# create Field objects
srcfield = ESMF.Field(mesh, name='srcfield')
dstfield = ESMF.Field(grid, name='dstfield')
exactfield = ESMF.Field(grid, name='exactfield')
# initialize the Fields to an analytic function
srcfield = initialize_field_mesh(srcfield, nodeCoord, nodeOwner, elemType, elemConn)
exactfield = initialize_field_grid(exactfield, domask=True)
# run the ESMF regridding
regridSrc2Dst = ESMF.Regrid(srcfield, dstfield,
dst_mask_values=np.array([0]),
regrid_method=ESMF.RegridMethod.BILINEAR,
unmapped_action=ESMF.UnmappedAction.IGNORE)
dstfield = regridSrc2Dst(srcfield, dstfield)
# compare results and output PASS or FAIL
meanrel, csrvrel, correct = compare_fields(dstfield, exactfield,
20E-1, 20E-1, 10E-16,
regrid_method=ESMF.RegridMethod.BILINEAR)
self.assertAlmostEqual(meanrel, 0.0)
self.assertAlmostEqual(csrvrel, 0.0)
def regrid_check(src_fname, dst_fname, regrid_method, options, itrp_mean_err,
itrp_max_err, csrv_err):
# print ("\nregrid_weight_gen_check.py: mesh_check()")
parallel = False
if ESMF.pet_count() > 1:
parallel = True
# Settings for regrid
(src_type_str, dst_type_str, src_meshname, dst_meshname, unmapped_action,
pole_method_str, src_regional, dst_regional, src_missingvalue,
dst_missingvalue) = parse_options(options)
src_type = file_type_map[src_type_str]
dst_type = file_type_map[dst_type_str]
regrid_method = regrid_method_map[regrid_method]
convert_to_dual = (regrid_method != ESMF.RegridMethod.CONSERVE)
add_corner_stagger = (regrid_method == ESMF.RegridMethod.CONSERVE)
src_is_sphere = not src_regional
dst_is_sphere = not dst_regional
pole_method = None
pole_method_npntavg = 1
if pole_method_str:
if pole_method_str in pole_method_map:
pole_method = pole_method_map[pole_method_str]
else:
pole_method = ESMF.PoleMethod.NPNTAVG
pole_method_npntavg = int(pole_method_str)
src_mask = False
srcgrid, src_is_mesh, src_mask = create_grid_or_mesh_from_file(
src_fname,
src_type,
meshname=src_meshname,
convert_to_dual=convert_to_dual,
isSphere=src_is_sphere,
add_corner_stagger=add_corner_stagger,
missingvalue=src_missingvalue)
dst_mask = False
dstgrid, dst_is_mesh, dst_mask = create_grid_or_mesh_from_file(
dst_fname,
dst_type,
meshname=dst_meshname,
convert_to_dual=convert_to_dual,
isSphere=dst_is_sphere,
add_corner_stagger=add_corner_stagger,
missingvalue=dst_missingvalue)
# Get coordinates in radians.
src_lons, src_lats = get_coords_from_grid_or_mesh(srcgrid, src_is_mesh,
regrid_method)
dst_lons, dst_lats = get_coords_from_grid_or_mesh(dstgrid, dst_is_mesh,
regrid_method)
# create Field objects on the Grids
srcfield = create_field(srcgrid, 'srcfield', regrid_method=regrid_method)
dstfield = create_field(dstgrid, 'dstfield', regrid_method=regrid_method)
dstfield2 = create_field(dstgrid,
'dstfield_exact',
regrid_method=regrid_method)
#create the frac fields
srcfracfield = create_field(srcgrid,
'src_frac_field',
regrid_method=regrid_method)
dstfracfield = create_field(dstgrid,
'dst_frac_field',
regrid_method=regrid_method)
# initialize the Fields to an analytic function
srcfield = build_analyticfield(srcfield, src_lons, src_lats)
dstfield2 = build_analyticfield(dstfield2, dst_lons, dst_lats)
# run the ESMF regridding
dstfield.data[...] = UNINITVAL
dstfield = run_regridding(srcfield,
dstfield,
src_mask,
dst_mask,
regrid_method,
unmapped_action,
srcfracfield,
dstfracfield,
pole_method=pole_method,
regrid_pole_npoints=pole_method_npntavg)
srcmass = None
dstmass = None
if regrid_method == ESMF.RegridMethod.CONSERVE:
if src_is_mesh:
srcmass = compute_mass_mesh(srcfield,
dofrac=True,
fracfield=srcfracfield)
else:
srcmass = compute_mass_grid(srcfield,
dofrac=True,
fracfield=srcfracfield)
if dst_is_mesh:
dstmass = compute_mass_mesh(dstfield, uninitval=UNINITVAL)
else:
dstmass = compute_mass_grid(dstfield, uninitval=UNINITVAL)
else:
srcfracfield.destroy()
dstfracfield.destroy()
srcfracfield = None
dstfracfield = None
total_error, csrv_error, correct = compare_fields(
dstfield,
dstfield2,
itrp_mean_err,
itrp_max_err,
csrv_err,
dstfracfield=dstfracfield,
mass1=srcmass,
mass2=dstmass,
regrid_method=regrid_method,
uninitval=UNINITVAL)
# Destroy ESMF objects
srcfield.destroy()
dstfield.destroy()
dstfield2.destroy()
if regrid_method == ESMF.RegridMethod.CONSERVE:
srcfracfield.destroy()
dstfracfield.destroy()
srcgrid.destroy()
dstgrid.destroy()
return correct
