def modify_filter(gridfilename, ttlname, indflag=1): tm = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) ncfile = Dataset(gridfilename, 'a') if indflag: grid_center_lat_var = ncfile.variables['grid_center_lat'] setattr(grid_center_lat_var, 'units', 'degrees') grid_center_lon_var = ncfile.variables['grid_center_lon'] setattr(grid_center_lon_var, 'units', 'degrees') grid_corner_lat_var = ncfile.variables['grid_corner_lat'] setattr(grid_corner_lat_var, 'units', 'degrees') grid_corner_lon_var = ncfile.variables['grid_corner_lon'] setattr(grid_corner_lon_var, 'units', 'degrees') setattr(ncfile, 'title', ttlname) setattr(ncfile, 'modifydate', tm) if hasattr(ncfile, 'grid_name'): delattr(ncfile, 'grid_name') if hasattr(ncfile, 'map_method'): delattr(ncfile, 'map_method') ncfile.sync() ncfile.close()
def modify_filter(gridfilename, ttlname, indflag = 1): tm = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())) ncfile = Dataset(gridfilename, 'a') if indflag: grid_center_lat_var = ncfile.variables['grid_center_lat'] setattr(grid_center_lat_var, 'units', 'degrees') grid_center_lon_var = ncfile.variables['grid_center_lon'] setattr(grid_center_lon_var, 'units', 'degrees') grid_corner_lat_var = ncfile.variables['grid_corner_lat'] setattr(grid_corner_lat_var, 'units', 'degrees') grid_corner_lon_var = ncfile.variables['grid_corner_lon'] setattr(grid_corner_lon_var, 'units', 'degrees') setattr(ncfile, 'title', ttlname) setattr(ncfile, 'modifydate', tm) if hasattr(ncfile, 'grid_name'): delattr(ncfile, 'grid_name') if hasattr(ncfile, 'map_method'): delattr(ncfile, 'map_method') ncfile.sync() ncfile.close()
def writeNcFile(data, fileName=None, oldStyle=1): if not ncOk: raise Exception('module Scientific.IO.NetCDF not found, writeNcFile() failed!') if not fileName: fileName = data['name']+'_weather.nc' f = NetCDFFile(fileName, 'w') f.createDimension('time', data['time'].shape[0]) f.file_format = file_format if oldStyle: f.createDimension('scalar', 1) if data.has_key('comment'): f.comment = data['comment'] else: f.comment = 'created by MeteonormFile.py (v%s)' % version if data.has_key('source_file'): f.source_file = str(data['source_file']) for vn in ('latitude', 'longitude', 'height'): setattr(f, vn, data[vn]) if oldStyle: v = f.createVariable(vn, 'd', ('scalar', )) v[:] = [data[vn]] setattr(f, 'longitude_0', 15.0*data['timezone']) if oldStyle: v = f.createVariable('longitude_0', 'd', ('scalar', )) v[:] = [15.0 * data['timezone']] for vn in variables.keys(): t = variables[vn][1] v = f.createVariable(vn, t, ('time',)) v[:] = data[vn].astype(t) oname = variables[vn][0] if oname.startswith('<'): oname = oname[1:] if oname.endswith('>'): oname = oname[:-1] v.original_name = oname v.unit = variables[vn][2] f.sync() f.close()
class _ParNetCDFFile(ParBase): """ Distributed netCDF file A ParNetCDFFile object acts as much as possible like a NetCDFFile object. Variables become ParNetCDFVariable objects, which behave like distributed sequences. Variables that use the dimension named by |split_dimension| are automatically distributed among the processors such that each treats only one slice of the whole file. """ def __parinit__(self, pid, nprocs, filename, split_dimension, mode = 'r', local_access = False): """ @param filename: the name of the netCDF file @type filename: C{str} @param split_dimension: the name of the dimension along which the data is distributed over the processors @type split_dimension: C{str} @param mode: read ('r'), write ('w'), or append ('a') @type mode: C{str} @param local_access: if C{False}, processor 0 is the only one to access the file, all others communicate with processor 0. If C{True} (only for reading), each processor accesses the file directly. In the latter case, the file must be accessible on all processors under the same name. A third mode is 'auto', which uses some heuristics to decide if the file is accessible everywhere: it checks for existence of the file, then compares the size on all processors, and finally verifies that the same variables exist everywhere, with identical names, types, and sizes. @type local_access: C{bool} or C{str} """ if mode != 'r': local_access = 0 self.pid = pid self.nprocs = nprocs self.filename = filename self.split = split_dimension self.local_access = local_access self.read_only = mode == 'r' if local_access or pid == 0: self.file = NetCDFFile(filename, mode) try: length = self.file.dimensions[split_dimension] if length is None: length = -1 except KeyError: length = None variables = {} for name, var in self.file.variables.items(): variables[name] = (name, var.dimensions) if length < 0 and split_dimension in var.dimensions: index = list(var.dimensions).index(split_dimension) length = var.shape[index] else: self.file = None self.split = split_dimension length = None variables = None if not local_access: length = self.broadcast(length) variables = self.broadcast(variables) if length is not None: self._divideData(length) self.variables = {} for name, var in variables.items(): self.variables[name] = _ParNetCDFVariable(self, var[0], var[1], split_dimension) def __repr__(self): return repr(self.filename) def close(self): if self.local_access or self.pid == 0: self.file.close() def createDimension(self, name, length): if name == self.split: if length is None: raise ValueError("Split dimension cannot be unlimited") self._divideData(length) if self.pid == 0: self.file.createDimension(name, length) def createVariable(self, name, typecode, dimensions): if self.pid == 0: var = self.file.createVariable(name, typecode, dimensions) dim = var.dimensions else: dim = 0 name, dim = self.broadcast((name, dim)) self.variables[name] = _ParNetCDFVariable(self, name, dim, self.split) return self.variables[name] def _divideData(self, length): chunk = (length+self.nprocs-1)/self.nprocs self.first = min(self.pid*chunk, length) self.last = min(self.first+chunk, length) if (not self.local_access) and self.pid == 0: self.parts = [] for pid in range(self.nprocs): first = pid*chunk last = min(first+chunk, length) self.parts.append((first, last)) def sync(self): if self.pid == 0: self.file.sync() flush = sync
for i, pol in enumerate(polluants): data = dcrs[i] - (dsrs[i] - dsss[i]) dcss.append(data) print " > %s (min = %.1f, max = %1.f)" % (pol, data.min(), data.max()) del dsrs, dsss, dcrs # Enregistrement des résultats print "enregistrement des données" if fncs[-3:] != '.nc': fncs = "%s.nc" % fncs ncf = NetCDFFile(fncs, 'w') # dimensions ncf.createDimension('Time', None) ncf.createDimension('DateStrLen', 19) ncf.createDimension('Point', np) ncf.sync() print " > dimensions" # variables annexes ncf.createVariable('Times', 'c', ('Time', 'DateStrLen')) ncf.createVariable('area_pts', 'f', ('Point', )) ncf.createVariable('easting_pts', 'f', ('Point', )) ncf.createVariable('northing_pts', 'f', ('Point', )) ncf.createVariable('x_pts', 'f', ('Point', )) ncf.createVariable('y_pts', 'f', ('Point', )) ncf.sync() print " > variables" nctimes = ncf.variables['Times'] nctimes.assignValue(times) setattr(nctimes, 'long_name', 'date au format CHIMERE/WRF')
class _ParNetCDFFile(ParBase): """ Distributed netCDF file A ParNetCDFFile object acts as much as possible like a NetCDFFile object. Variables become ParNetCDFVariable objects, which behave like distributed sequences. Variables that use the dimension named by |split_dimension| are automatically distributed among the processors such that each treats only one slice of the whole file. """ def __parinit__(self, pid, nprocs, filename, split_dimension, mode='r', local_access=False): """ @param filename: the name of the netCDF file @type filename: C{str} @param split_dimension: the name of the dimension along which the data is distributed over the processors @type split_dimension: C{str} @param mode: read ('r'), write ('w'), or append ('a') @type mode: C{str} @param local_access: if C{False}, processor 0 is the only one to access the file, all others communicate with processor 0. If C{True} (only for reading), each processor accesses the file directly. In the latter case, the file must be accessible on all processors under the same name. A third mode is 'auto', which uses some heuristics to decide if the file is accessible everywhere: it checks for existence of the file, then compares the size on all processors, and finally verifies that the same variables exist everywhere, with identical names, types, and sizes. @type local_access: C{bool} or C{str} """ if mode != 'r': local_access = 0 self.pid = pid self.nprocs = nprocs self.filename = filename self.split = split_dimension self.local_access = local_access self.read_only = mode == 'r' if local_access or pid == 0: self.file = NetCDFFile(filename, mode) try: length = self.file.dimensions[split_dimension] if length is None: length = -1 except KeyError: length = None variables = {} for name, var in self.file.variables.items(): variables[name] = (name, var.dimensions) if length < 0 and split_dimension in var.dimensions: index = list(var.dimensions).index(split_dimension) length = var.shape[index] else: self.file = None self.split = split_dimension length = None variables = None if not local_access: length = self.broadcast(length) variables = self.broadcast(variables) if length is not None: self._divideData(length) self.variables = {} for name, var in variables.items(): self.variables[name] = _ParNetCDFVariable(self, var[0], var[1], split_dimension) def __repr__(self): return repr(self.filename) def close(self): if self.local_access or self.pid == 0: self.file.close() def createDimension(self, name, length): if name == self.split: if length is None: raise ValueError("Split dimension cannot be unlimited") self._divideData(length) if self.pid == 0: self.file.createDimension(name, length) def createVariable(self, name, typecode, dimensions): if self.pid == 0: var = self.file.createVariable(name, typecode, dimensions) dim = var.dimensions else: dim = 0 name, dim = self.broadcast((name, dim)) self.variables[name] = _ParNetCDFVariable(self, name, dim, self.split) return self.variables[name] def _divideData(self, length): chunk = (length + self.nprocs - 1) / self.nprocs self.first = min(self.pid * chunk, length) self.last = min(self.first + chunk, length) if (not self.local_access) and self.pid == 0: self.parts = [] for pid in range(self.nprocs): first = pid * chunk last = min(first + chunk, length) self.parts.append((first, last)) def sync(self): if self.pid == 0: self.file.sync() flush = sync
'set_var_chunk_cache', 'setncattr', 'shape', 'size')) or ('_' in a)): # don't copy these setattr(newVar, a, getattr(thevar, a)) # Loop over time, and vert levels if needed, interpolating each 2d field for this variable for t in range(0, time_length): if 'nVertLevels' in thevar.dimensions: for v in range(0, vert_levs): originalvalue = thevar[t, :, v] # Create an interpolator object for this variable interpolator = matplotlib.delaunay.NNInterpolator( triang, originalvalue, default_value=0.0) # use the object to regrid varGridded = interpolator[ymin:ymax:ny * 1j, xmin:xmax:nx * 1j] newVar[t, :, :, v] = varGridded[:, :] else: originalvalue = thevar[t, :] # Create an interpolator object for this variable interpolator = matplotlib.delaunay.NNInterpolator( triang, originalvalue, default_value=0.0) # use the object to regrid varGridded = interpolator[ymin:ymax:ny * 1j, xmin:xmax:nx * 1j] newVar[t, :, :] = varGridded[:, :] print 'Saved re-gridded fields to: ', fileoutname fileout.sync() filein.close() fileout.close()