def __init__(self, esmfGrid, name, datatype, staggerloc=CENTER): """ Creator for structured ESMF Field @param esmfGrid instance of an ESMF @param name field name (must be unique) @param datatype data type, one of 'float64', 'float32', 'int64', or 'int32' (or equivalent numpy dtype) @param staggerloc ESMF.StaggerLoc.CENTER ESMF.StaggerLoc.CORNER """ # field object self.field = None # the local processor rank self.pe = 0 # the number of processors self.nprocs = 1 # associated grid self.grid = esmfGrid # staggering self.staggerloc = staggerloc # communicator self.comm = None try: from mpi4py import MPI self.comm = MPI.COMM_WORLD except BaseException: pass etype = None sdatatype = str(datatype) # in case user passes a numpy dtype if re.search('float64', sdatatype): etype = R8 elif re.search('float32', sdatatype): etype = R4 elif re.search('int64', sdatatype): etype = I8 elif re.search('int32', sdatatype): etype = I4 else: msg = 'esmf.EsmfStructField.__init__: ERROR invalid type %s' % datatype raise RegridError(msg) self.field = ESMF.Field(grid=esmfGrid.grid, name=name, typekind=etype, staggerloc=staggerloc) vm = ESMF.ESMP_VMGetGlobal() self.pe, self.nprocs = ESMF.ESMP_VMGet(vm)
def __init__(self, numTopoDims, numSpaceDims): # handle to the grid object self.grid = None # whether or not nodes were added self.nodesAdded = False # whether or not cells were added self.cellsAdded = False # the local processor rank self.pe = 0 # number of processors self.nprocs = 1 # communicator self.comm = None vm = ESMF.ESMP_VMGetGlobal() self.pe, self.nprocs = ESMF.ESMP_VMGet(vm) self.grid = ESMF.Mesh(parametric_dim=numTopoDims, spatial_dim=numSpaceDims)
def __init__(self, esmfGrid, name, datatype, staggerloc=CENTER): """ """ # field object self.field = None # the local processor rank self.pe = 0 # the number of processors self.nprocs = 1 # associated grid self.grid = esmfGrid # staggering self.staggerloc = staggerloc # communicator self.comm = None try: from mpi4py import MPI self.comm = MPI.COMM_WORLD except BaseException: pass etype = None sdatatype = str(datatype) # in case user passes a numpy dtype if re.search('float64', sdatatype): etype = R8 elif re.search('float32', sdatatype): etype = R4 elif re.search('int64', sdatatype): etype = I8 elif re.search('int32', sdatatype): etype = I4 else: msg = 'esmf.EsmfStructField.__init__: ERROR invalid type %s' % datatype raise RegridError(msg) self.field = ESMF.Field(grid=esmfGrid.grid, name=name, typekind=etype, staggerloc=staggerloc) vm = ESMF.ESMP_VMGetGlobal() self.pe, self.nprocs = ESMF.ESMP_VMGet(vm)
def create_grid(bounds, domask): ''' PRECONDITIONS: ESMPy has been initialized, 'bounds' contains the number of indices required for the first two dimensions of a Grid. 'domask' is a boolean value that gives the option to put a mask on this Grid.\n POSTCONDITIONS: An Grid has been created.\n RETURN VALUES: \n Grid :: grid \n ''' nx = float(bounds[0]) ny = float(bounds[1]) dx = 360.0/nx dy = 180.0/ny DEG2RAD = 3.141592653589793/180.0 maxIndex = np.array([nx,ny], dtype=np.int32) staggerLocs = [ESMF.StaggerLoc.CORNER, ESMF.StaggerLoc.CENTER] grid = ESMF.Grid(maxIndex, num_peri_dims=1, staggerloc=staggerLocs) # VM vm = ESMF.ESMP_VMGetGlobal() localPet, petCount = ESMF.ESMP_VMGet(vm) # get the coordinate pointers and set the coordinates [x,y] = [0, 1] gridXCorner = grid.get_coords(x, ESMF.StaggerLoc.CORNER) gridYCorner = grid.get_coords(y, ESMF.StaggerLoc.CORNER) for i in xrange(gridXCorner.shape[x]): gridXCorner[i, :] = float(i)*dx - 180.0 for j in xrange(gridYCorner.shape[y]): gridYCorner[:, j] = float(j)*dy - 90.0 ## CENTERS # get the coordinate pointers and set the coordinates [x,y] = [0, 1] gridXCenter = grid.get_coords(x, ESMF.StaggerLoc.CENTER) gridYCenter = grid.get_coords(y, ESMF.StaggerLoc.CENTER) for i in xrange(gridXCenter.shape[x]): gridXCenter[i, :] = float(i)*dx + 0.5*dx - 180.0 for j in xrange(gridYCenter.shape[y]): y = (float(j)*dy - 90.0) yp1 = (float(j+1)*dy - 90.0) gridYCenter[:, j] = (y+yp1)/2.0 mask = 0 if domask: # set up the grid mask grid.add_item(ESMF.GridItem.MASK) mask = grid.get_item(ESMF.GridItem.MASK) [x,y] = [0, 1] for i in range(mask.shape[x]): if (i == 2.0): mask[i, :] = 1 else: mask[i, :] = 0 return grid
def compare_fields(interp_field, exact_field, dstfracfield, srcmass, dstmass, \ parallel): ''' PRECONDITIONS: 'interp_field' is a Field that holds the values resulting from a regridding operation, 'exact_field' is a Field containing the values of the exact solution that is expected, and 'dstfracfield' is a Field containing the fractions of the 'interp_field' which contributed to the regridding product. 'srcmass' and 'dstmass' are the mass values for the source and destination data fields. 'parallel' is an internal variable used to determine if this run should be done in serial or parallel.\n POSTCONDITIONS: The interpolation accuracy of a regridding operation is determined by comparing the 'interp_field' to the 'exact_field'. The mass conservation is validated by comparing the 'srcmass' to the 'dstmass'.\n RETURN VALUES: None \n ''' vm = ESMF.ESMP_VMGetGlobal() localPet, _ = ESMF.ESMP_VMGet(vm) if (interp_field.data.shape != exact_field.data.shape): raise TypeError('compare_fields: Fields must be the same size!') # initialize to True, and check for False point values [x, y] = [0, 1] total_error = 0.0 max_error = 0.0 min_error = 1000000.0 for i in range(interp_field.data.shape[x]): for j in range(interp_field.data.shape[y]): if (exact_field.data[i, j] != 0.0): err = abs(interp_field.data[i, j] / dstfracfield.data[i, j] - \ exact_field.data[i, j]) / abs(exact_field.data[i, j]) else: err = abs(interp_field.data[i, j] / dstfracfield.data[i, j] - \ exact_field.data[i, j]) total_error = total_error + err if (err > max_error): max_error = err if (err < min_error): min_error = err if parallel: # use mpi4py to collect values from mpi4py import MPI comm = MPI.COMM_WORLD rank = comm.Get_rank() max_error_global = comm.reduce(max_error, op=MPI.MAX) min_error_global = comm.reduce(min_error, op=MPI.MIN) total_error_global = comm.reduce(total_error, op=MPI.SUM) srcmass_global = comm.reduce(srcmass, op=MPI.SUM) dstmass_global = comm.reduce(dstmass, op=MPI.SUM) if rank == 0: # check the mass csrv = False csrv_error = abs(dstmass_global - srcmass_global)/srcmass_global if (csrv_error < 10e-12): csrv = True itrp = False if (max_error_global < 10E-2): itrp = True if (itrp and csrv): print "PASS" else: print "FAIL" print " Total error = "+str(total_error_global) print " Max error = "+str(max_error_global) print " Min error = "+str(min_error_global) print " Csrv error = "+str(csrv_error) print " srcmass = "+str(srcmass_global) print " dstmass = "+str(dstmass_global) else: # check the mass csrv = False csrv_error = abs(dstmass - srcmass)/srcmass if (csrv_error < 10e-12): csrv = True itrp = False if (max_error < 10E-2): itrp = True if (itrp and csrv): print "PASS" else: print "FAIL" print " Total error = "+str(total_error) print " Max error = "+str(max_error) print " Min error = "+str(min_error) print " Csrv error = "+str(csrv_error) print " srcmass = "+str(srcmass) print " dstmass = "+str(dstmass) return