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