def Regrid2deg(d):
"""
Regrid to 2deg (180lon*90lat) horizontal resolution
Input
- d: cdms variable
Output
- drg: cdms variable with 2deg horizontal resolution
"""
# Regridding
tgrid = cdms.createUniformGrid(-89, 90, 2.0, 0, 180, 2.0, order='yx')
orig_grid = d.getGrid()
regridFunc = Regridder(orig_grid, tgrid)
drg = MV.zeros((d.shape[0], tgrid.shape[0], tgrid.shape[1]), MV.float)
for it in range(d.shape[0]):
drg[it] = regridFunc(d[it])
# Dimension information
time = d.getAxis(0)
lat = tgrid.getAxis(0)
lon = tgrid.getAxis(1)
drg.setAxisList((time, lat, lon))
# Missing value (In case, missing value is changed after regridding)
drg[drg >= d.missing_value] = d.missing_value
mask = np.array(drg == d.missing_value)
drg.mask = mask
print('Complete regridding from', d.shape, 'to', drg.shape)
return drg
def get_data():
f=cdms.open("tls_both_ccsm4.hist_rcp85.r1i1p1.mo.nc")
da=cdutil.ANNUALCYCLE.departures(f("eqmsu_tls"))
GRID=cdms.createUniformGrid(-90,9,20,-180,18,20)
return da.regrid(GRID,regridTool='esmf')
def get(self):
value = self.grid
if value is None:
if not self.latitude.n is None: # Ok we seem to have grid definition
if self.latitude.type == 1: # Gaussian
if self.longitude.first is None:
value = cdms2.createGaussianGrid(self.latitude.n)
else:
value = cdms2.createGaussianGrid(
self.latitude.n, self.longitude.first)
elif self.latitude.type == 0: # Uniform
value = cdms2.createUniformGrid(self.latitude.first,
self.latitude.n,
self.latitude.delta,
self.longitude.first,
self.longitude.n,
self.longitude.delta)
elif self.latitude.type == 2: # Equalarea
lat = cdms2.createEqualAreaAxis(self.latitude.n)
lon = cdms2.createUniformLongitude(self.longitude.first,
self.longitude.n,
self.longitude.delta)
value = cdms2.createGenericGrid(lat[:], lon[:],
lat.getBounds(),
lon.getBounds())
elif not self.file is None:
f = cdms2.open(self.file)
value = f[self.var].getGrid()
## Ok temporary stuff to try to be able to close the file
lat = value.getLatitude()
lon = value.getLongitude()
value = cdms2.createRectGrid(lat, lon)
f.close()
return value
def get(self):
value=self.grid
if value is None:
if not self.latitude.n is None: # Ok we seem to have grid definition
if self.latitude.type == 1: # Gaussian
if self.longitude.first is None:
value=cdms2.createGaussianGrid(self.latitude.n)
else:
value=cdms2.createGaussianGrid(self.latitude.n,self.longitude.first)
elif self.latitude.type == 0: # Uniform
value=cdms2.createUniformGrid(self.latitude.first,
self.latitude.n,
self.latitude.delta,
self.longitude.first,
self.longitude.n,
self.longitude.delta)
elif self.latitude.type== 2: # Equalarea
lat=cdms2.createEqualAreaAxis(self.latitude.n)
lon=cdms2.createUniformLongitude(self.longitude.first,
self.longitude.n,
self.longitude.delta)
value=cdms2.createGenericGrid(lat[:],lon[:],lat.getBounds(),lon.getBounds())
elif not self.file is None:
f=cdms2.open(self.file)
value=f[self.var].getGrid()
## Ok temporary stuff to try to be able to close the file
lat=value.getLatitude()
lon=value.getLongitude()
value=cdms2.createRectGrid(lat,lon)
f.close()
return value
def __call__(self, _var, region):
var = _var.clone()
if not region in self.regions.keys():
return None
val = self.regions[region]
# reading mask data
regions_data = self.file['mask']
regions_var = cdms2.createVariable(
ones(regions_data.shape),
grid = cdms2.createUniformGrid(89.75, 360, -0.5, -180, 720, 0.5),
mask = where(equal(regions_data, val), 0, 1))
lats = cdms2.createUniformLatitudeAxis(89.75, 360, -0.5)
lons = cdms2.createUniformLongitudeAxis(-180, 720, 0.5)
regions_var.setAxisList((lats,lons))
new_mask_var = regions_var.regrid(var.getGrid(), regridTool='regrid2', regridMethod='linear')
new_mask = getmask(new_mask_var)
if var.mask <> None:
var.mask = logical_or(var.mask, new_mask)
else:
var.mask = new_mask;
return var
def setTargetGrid(self, target, regridTool="esmf", regridMethod="linear"):
self.regridTool = regridTool
self.regridMethod = regridMethod
if target == "2.5x2.5":
self.targetGrid = cdms2.createUniformGrid(-88.875, 72, 2.5, 0, 144,
2.5)
elif cdms2.isGrid(target):
self.targetGrid = target
else:
raise RunTimeError, "Unknown grid: %s" % target
def generate_grid(self, gridder, spatial, chunk):
try:
grid_type, grid_param = gridder.grid.split('~')
except ValueError:
raise WPSError('Error generating grid "{name}"', name=gridder.grid)
if grid_type.lower() == 'uniform':
result = re.match('^(.*)x(.*)$', grid_param)
if result is None:
raise WPSError('Failed to parse uniform configuration from {value}', value=grid_param)
try:
start_lat, nlat, delta_lat = self.parse_uniform_arg(result.group(1), -90.0, 180.0)
except WPSError:
raise
try:
start_lon, nlon, delta_lon = self.parse_uniform_arg(result.group(2), 0.0, 360.0)
except WPSError:
raise
grid = cdms2.createUniformGrid(start_lat, nlat, delta_lat, start_lon, nlon, delta_lon)
logger.info('Created target uniform grid {} from lat {}:{}:{} lon {}:{}:{}'.format(
grid.shape, start_lat, delta_lat, nlat, start_lon, delta_lon, nlon))
else:
try:
nlats = int(grid_param)
except ValueError:
raise WPSError('Error converting gaussian parameter to an int')
grid = cdms2.createGaussianGrid(nlats)
logger.info('Created target gaussian grid {}'.format(grid.shape))
target = cdms2.MV2.ones(grid.shape)
target.setAxisList(grid.getAxisList())
lat = chunk.getLatitude()
lon = chunk.getLongitude()
try:
lat_spec = spatial[lat.id]
lon_spec = spatial[lon.id]
except KeyError as e:
logger.debug('Skipping subsetting the target grid')
else:
target = target(latitude=lat_spec, longitude=lon_spec)
return target.getGrid()
def setTargetGrid(self,target,regridTool="esmf",regridMethod="linear"):
self.regridTool = regridTool
self.regridMethod = regridMethod
if target=="2.5x2.5":
self.targetGrid = cdms2.createUniformGrid(-88.875,72,2.5,0,144,2.5)
self.targetGridName = target
elif cdms2.isGrid(target):
self.targetGrid = target
self.targetGridName = target
else:
raise RunTimeError,"Unknown grid: %s" % target
def test2DRect():
import cdms2
from numpy import pi, cos, sin
nlat, nlon = 3, 4
grid = cdms2.createUniformGrid(-0.0, nlat, 60. / (nlat - 1), 0., nlon,
30. / nlon)
lons = grid.getLongitude()
lats = grid.getLatitude()
data = numpy.outer(cos(3 * pi * lats[:] / 180.0),
sin(5 * pi * lons[:] / 180.0))
var = cdms2.createVariable(data, id='fake_data_2d_rect', axes=(lats, lons))
vw = VsWriter(var)
vw.write('test2DRect.vsh5')
def test2DRect():
import cdms2
from numpy import pi, cos, sin
nlat, nlon = 6, 10
grid = cdms2.createUniformGrid(-0.0, nlat, 60./(nlat-1),
0., nlon, 30./nlon)
lons = grid.getLongitude()
lats = grid.getLatitude()
data = numpy.outer(cos(3*pi*lats[:]/180.0),
sin(5*pi*lons[:]/180.0))
var = cdms2.createVariable(data, id='fake_data_2d_rect',
axes=(lats, lons))
vw = VTKSGWriter(var)
vw.write('test2DRect_SG.vtk')
def generate_user_defined_grid(self, gridder):
try:
grid_type, grid_param = gridder.grid.split('~')
except AttributeError:
return None
except ValueError:
raise WPSError('Error generating grid "{name}"', name=gridder.grid)
logger.info('Generating grid %r %r', grid_type, grid_param)
if grid_type.lower() == 'uniform':
result = re.match('^(.*)x(.*)$', grid_param)
if result is None:
raise WPSError(
'Failed to parse uniform configuration from {value}',
value=grid_param)
try:
start_lat, nlat, delta_lat = self.parse_uniform_arg(
result.group(1), -90.0, 180.0)
except WPSError:
raise
try:
start_lon, nlon, delta_lon = self.parse_uniform_arg(
result.group(2), 0.0, 360.0)
except WPSError:
raise
grid = cdms2.createUniformGrid(start_lat, nlat, delta_lat,
start_lon, nlon, delta_lon)
logger.info(
'Created target uniform grid {} from lat {}:{}:{} lon {}:{}:{}'
.format(grid.shape, start_lat, delta_lat, nlat, start_lon,
delta_lon, nlon))
elif grid_type.lower() == 'gaussian':
try:
nlats = int(grid_param)
except ValueError:
raise WPSError('Error converting gaussian parameter to an int')
grid = cdms2.createGaussianGrid(nlats)
logger.info('Created target gaussian grid {}'.format(grid.shape))
else:
raise WPSError('Unknown grid type for regridding: {}', grid_type)
return grid
def set_target_grid(self, target, regrid_tool='esmf',
regrid_method='linear'):
self.regrid_tool = regrid_tool
self.regrid_method = regrid_method
if target == '2.5x2.5':
self.target_grid = cdms2.createUniformGrid(
-88.875, 72, 2.5, 0, 144, 2.5
)
self.target_grid_name = target
elif cdms2.isGrid(target):
self.target_grid = target
self.target_grid_name = target
else:
logging.getLogger("pcmdi_metrics").error('Unknown grid: %s' % target)
raise RuntimeError('Unknown grid: %s' % target)
def set_target_grid(self, target, regrid_tool='esmf',
regrid_method='linear'):
self.regrid_tool = regrid_tool
self.regrid_method = regrid_method
if target == '2.5x2.5':
self.target_grid = cdms2.createUniformGrid(
-88.875, 72, 2.5, 0, 144, 2.5
)
self.target_grid_name = target
elif cdms2.isGrid(target):
self.target_grid = target
self.target_grid_name = target
else:
logging.getLogger("pcmdi_metrics").error(
'Unknown grid: %s' % target)
raise RuntimeError('Unknown grid: %s' % target)
def test2DRect():
"""
Test data on 2D rectilinear grid
"""
import cdms2
from numpy import pi, cos, sin
nlat, nlon = 12, 15
grid = cdms2.createUniformGrid(-0.0, nlat, 60. / (nlat - 1), 0., nlon,
30. / nlon)
lons = grid.getLongitude()
lats = grid.getLatitude()
data = numpy.outer(cos(3 * pi * lats[:] / 180.0),
sin(5 * pi * lons[:] / 180.0))
var = cdms2.createVariable(data, id='fake_data_2d_rect', axes=(lats, lons))
sphere_mesh = SphereMesh(var, 0.1)
print sphere_mesh.getXYZCoords()
def test2DRect():
"""
Test data on 2D rectilinear grid
"""
import cdms2
from numpy import pi, cos, sin
nlat, nlon = 12, 15
grid = cdms2.createUniformGrid(-0.0, nlat, 60./(nlat-1),
0., nlon, 30./nlon)
lons = grid.getLongitude()
lats = grid.getLatitude()
data = numpy.outer(cos(3*pi*lats[:]/180.0),
sin(5*pi*lons[:]/180.0))
var = cdms2.createVariable(data, id='fake_data_2d_rect',
axes=(lats, lons))
sphere_mesh = SphereMesh(var, 0.1)
print sphere_mesh.getXYZCoords()
def buildOutlineMap(self):
# This function load a binary image (black and white)
# and create a default grid for it. Then it uses re-gridding algorithms
# to scale in the correct domain.
from pylab import imread
import vtk.util.vtkImageImportFromArray as vtkUtil
# read outline image and convert to gray scale
try:
data = imread(defaultOutlineMapFile)
data = data.mean(axis=2)
# # create a variable using the data loaded in the image and an uniform grid
dims = data.shape
reso = [180.0 / dims[0], 360.0 / dims[1]]
var = cdms2.createVariable(data)
lat = cdms2.createUniformLatitudeAxis(90, dims[0], -reso[0])
lon = cdms2.createUniformLongitudeAxis(-180, dims[1], reso[1])
var.setAxis(0, lat)
var.setAxis(1, lon)
# create the final map using the ROI
ROI = self.roi[:]
if ROI[2] < -90.0: ROI[2] = -90.0
if ROI[3] > 90.0: ROI[3] = 90.0
odims = [(ROI[3] - ROI[2]) / reso[0], (ROI[1] - ROI[0]) / reso[1]]
ogrid = cdms2.createUniformGrid(ROI[2], odims[0], reso[0], ROI[0],
odims[1], reso[1])
ovar = var.regrid(ogrid, regridTool='regrid2')
# replace outlier numbers
d = ovar.data
d[d == 1e+20] = d[d <> 1e+20].max()
img = vtkUtil.vtkImageImportFromArray()
img.SetArray(ovar.data)
img.Update()
except Exception:
print >> sys.stderr, "Error building Outline Map"
traceback.print_exc()
return None
# convert to vtkImageData
return img.GetOutput()
def testMask2(self):
data = cdms2.open(
os.path.join(cdat_info.get_sampledata_path(), "ta.nc"))("ta")
tmp = cdms2.open(
os.path.join(cdat_info.get_sampledata_path(), "sftlf.nc"))
sft = tmp("sftlf")
tmp.close()
data2 = cdms2.MV2.masked_where(cdms2.MV2.less(sft, 50.), data)
tGrid = cdms2.createUniformGrid(-88.875, 72, 2.5, 0, 144, 2.5)
for mthd in ["conservative", "linear"]:
print("USING REGRID METHOD:", mthd)
data3 = data2.regrid(tGrid,
regridTool="esmf",
regridMethod=mthd,
mask=data2.mask)
def buildOutlineMap(self):
# This function load a binary image (black and white)
# and create a default grid for it. Then it uses re-gridding algorithms
# to scale in the correct domain.
from pylab import imread
import vtk.util.vtkImageImportFromArray as vtkUtil
# read outline image and convert to gray scale
try:
data = imread(defaultOutlineMapFile)
data = data.mean(axis=2)
# # create a variable using the data loaded in the image and an uniform grid
dims = data.shape
reso = [180.0/dims[0], 360.0/dims[1]]
var = cdms2.createVariable(data)
lat = cdms2.createUniformLatitudeAxis(90, dims[0], -reso[0])
lon = cdms2.createUniformLongitudeAxis(-180, dims[1], reso[1])
var.setAxis(0, lat)
var.setAxis(1, lon)
# create the final map using the ROI
ROI = self.roi[:]
if ROI[2] < -90.0: ROI[2] = -90.0
if ROI[3] > 90.0: ROI[3] = 90.0
odims = [ (ROI[3]-ROI[2])/reso[0] , (ROI[1]-ROI[0])/reso[1] ]
ogrid = cdms2.createUniformGrid( ROI[2], odims[0], reso[0], ROI[0], odims[1], reso[1] )
ovar = var.regrid(ogrid, regridTool='regrid2')
# replace outlier numbers
d = ovar.data
d[d==1e+20] = d[d<>1e+20].max()
img = vtkUtil.vtkImageImportFromArray()
img.SetArray(ovar.data)
img.Update()
except Exception:
print>>sys.stderr, "Error building Outline Map"
traceback.print_exc()
return None
# convert to vtkImageData
return img.GetOutput()
def generate_user_defined_grid(cls,
grid_type,
grid_param,
lat_bounds=None,
lon_bounds=None):
logger.info('Generating grid %r %r', grid_type, grid_param)
if grid_type.lower() == 'uniform':
result = re.match('^(.*)x(.*)$', grid_param)
if result is None:
raise Exception(
f'Failed to parse uniform configuration from {grid_param}')
start_lat, nlat, delta_lat = cls.parse_uniform_arg(
result.group(1), -90.0, 180.0, lat_bounds)
start_lon, nlon, delta_lon = cls.parse_uniform_arg(
result.group(2), 0.0, 360.0, lon_bounds)
grid = cdms2.createUniformGrid(start_lat, nlat, delta_lat,
start_lon, nlon, delta_lon)
logger.info(
'Created target uniform grid {} from lat {}:{}:{} lon {}:{}:{}'
.format(grid.shape, start_lat, delta_lat, nlat, start_lon,
delta_lon, nlon))
elif grid_type.lower() == 'gaussian':
try:
nlats = int(grid_param)
except ValueError:
raise Exception(
'Error converting gaussian parameter to an int')
grid = cdms2.createGaussianGrid(nlats)
logger.info(f'Created target gaussian grid {grid.shape}')
else:
raise Exception(f'Unknown grid type for regridding: {grid_type}')
return grid
def create_sftlf(parameter):
''' Create the sftlf file from the parameter. '''
sftlf = {}
for test in parameter.test_data_set:
tmp_name = getattr(parameter, "sftlf_filename_template")
if tmp_name is None: # Not defined from commandline or param file
tmp_name = parameter.filename_template
sft = Base(parameter.test_data_path, tmp_name)
sft.model_version = test
sft.table = "fx"
sft.realm = "atmos"
sft.period = getattr(parameter, 'period', '')
sft.ext = "nc"
sft.case_id = getattr(parameter, 'case_id', '')
sft.target_grid = None
sft.realization = "r0i0p0"
DataSet.apply_custom_keys(sft, parameter.custom_keys, "sftlf")
try:
sftlf[test] = {"raw": sft.get("sftlf")}
sftlf[test]["filename"] = os.path.basename(sft())
sftlf[test]["md5"] = sft.hash()
except Exception:
sftlf[test] = {"raw": None}
sftlf[test]["filename"] = None
sftlf[test]["md5"] = None
if parameter.target_grid == "2.5x2.5":
t_grid = cdms2.createUniformGrid(-88.875, 72, 2.5, 0, 144, 2.5)
else:
t_grid = parameter.target_grid
sft = cdutil.generateLandSeaMask(t_grid)
sft[:] = sft.filled(1.0) * 100.0
sftlf["target_grid"] = sft
return sftlf
def create_sftlf(parameter):
"""Create the sftlf file from the parameter."""
sftlf = {}
for test in parameter.test_data_set:
tmp_name = getattr(parameter, "sftlf_filename_template")
if tmp_name is None: # Not defined from commandline or param file
tmp_name = parameter.filename_template
sft = Base(parameter.test_data_path, tmp_name)
sft.model_version = test
sft.table = "fx"
sft.realm = "atmos"
sft.period = getattr(parameter, "period", "")
sft.ext = "nc"
sft.case_id = getattr(parameter, "case_id", "")
sft.target_grid = None
sft.realization = "r0i0p0"
DataSet.apply_custom_keys(sft, parameter.custom_keys, "sftlf")
try:
sftlf[test] = {"raw": sft.get("sftlf")}
sftlf[test]["filename"] = os.path.basename(sft())
sftlf[test]["md5"] = sft.hash()
except Exception:
sftlf[test] = {"raw": None}
sftlf[test]["filename"] = None
sftlf[test]["md5"] = None
if parameter.target_grid == "2.5x2.5":
t_grid = cdms2.createUniformGrid(-88.875, 72, 2.5, 0, 144, 2.5)
else:
t_grid = parameter.target_grid
sft = cdutil.generateLandSeaMask(t_grid)
sft[:] = sft.filled(1.0) * 100.0
sftlf["target_grid"] = sft
return sftlf
# Adapted for numpy/ma/cdms2 by convertcdms.py import cdms2 import sys,MV2 import ZonalMeans delta_lon=.5 delta_lat=.5 nlat=int(180./delta_lat) nlon=int(360/delta_lon) s=MV2.ones((nlat,nlon),typecode='f') print delta_lon,nlon,delta_lat,nlat g=cdms2.createUniformGrid(-89.5, nlat, delta_lat, 0., nlon, delta_lon) s.setAxis(-1,g.getLongitude()) s.setAxis(-2,g.getLatitude()) s.setGrid(g) print s.shape print s.getGrid() print s.getLongitude() print s.getLatitude() zm=ZonalMeans.compute(s,delta_band=5) print zm
sft.realization = "r0i0p0"
applyCustomKeys(sft, parameters.custom_keys, "sftlf")
try:
sftlf[model_version] = {"raw": sft.get("sftlf")}
sftlf[model_version]["filename"] = os.path.basename(sft())
sftlf[model_version]["md5"] = sft.hash()
except:
# Hum no sftlf...
dup.tb = args.traceback
dup("No mask for ", sft())
dup.tb = False
sftlf[model_version] = {"raw": None}
sftlf[model_version]["filename"] = None
sftlf[model_version]["md5"] = None
if parameters.targetGrid == "2.5x2.5":
tGrid = cdms2.createUniformGrid(-88.875, 72, 2.5, 0, 144, 2.5)
else:
tGrid = parameters.targetGrid
sft = cdutil.generateLandSeaMask(tGrid)
sft[:] = sft.filled(1.) * 100.
sftlf["targetGrid"] = sft
# At this point we need to create the tuples var/region to know if a
# variable needs to be ran over a specific region or global or both
regions = getattr(parameters, "regions", {})
vars = []
# Update/overwrite default region_values keys with user ones
regions_values = {}
regions_values.update(getattr(parameters, "regions_values", {}))
sft.model_version = model_version
sft.table = "fx"
sft.realm = "atmos"
sft.model_period = parameters.model_period
sft.ext = "nc"
sft.targetGrid = None
sft.realization="r0i0p0"
applyCustomKeys(sft,parameters.custom_keys,"sftlf")
try:
sftlf[model_version] = {"raw":sft.get("sftlf")}
except:
#Hum no sftlf...
dup("No mask for ",sft())
sftlf[model_version] = {"raw":None}
if parameters.targetGrid == "2.5x2.5":
tGrid = cdms2.createUniformGrid(-88.875,72,2.5,0,144,2.5)
else:
tGrid = parameters.targetGrid
sftlf["targetGrid"] = cdutil.generateLandSeaMask(tGrid)*100.
#At this point we need to create the tuples var/region to know if a variable needs to be ran over a specific region or global or both
regions = getattr(parameters,"regions",{})
vars = []
#Update/overwrite defsult region_values keys with user ones
regions_values.update(getattr(parameters,"regions_values",{}))
regions_dict = {}
#
# usage: %prog dataset lons lats outfile
#
# where lons and lats are integers representing number of grid points
import sys
import cdms2
dataset, lons, lats, outfile = sys.argv[1:]
lons = int(lons)
lats = int(lats)
#!TODO: should I check order='yx'
#!TODO: refine grid spec
dest_grid = cdms2.createUniformGrid(-90, lats, 180./lats,
0, lons, 360./lons)
ds = cdms2.open(dataset)
# Select first variable with a grid
for var in ds.variables.values():
if var.getGrid():
print 'Regridding variable %s' % var.id
break
else:
raise Exception("No variable with grid found")
new_var = var.regrid(dest_grid)
out = cdms2.open(outfile, 'w')
out.write(new_var, extend=0)
def standard_regrid( file, var, **args ):
from cdms2.coord import TransientVirtualAxis, TransientAxis2D
from cdms2.hgrid import TransientCurveGrid
isVolume = False
levaxis = None
product_cache = args.get( 'cache', None )
iproc = args.get( 'iproc', 0 )
if ( len( var.shape ) == 4 ):
Var = var[0,:,:,:]
levaxis = Var.getLevel()
if levaxis == None:
domain = Var.getDomain()
for axis in domain:
if isLevelAxisId( axis[0].id.lower() ):
levaxis = axis[0]
break
else:
Var = var[0,:,:]
if hasattr( Var, "coordinates" ):
axis_ids = Var.coordinates.strip().split(' ')
lat_d01 = file( axis_ids[1], squeeze=1 )
lon_d01 = file( axis_ids[0], squeeze=1 )
elif hasattr( Var, "stagger" ):
stagger = Var.stagger.strip()
lat_d01 = file( "XLAT_%s" % stagger, squeeze=1 )
lon_d01 = file( "XLONG_%s" % stagger, squeeze=1 )
else:
lat_d01 = file( "XLAT", squeeze=1 )
lon_d01 = file( "XLONG", squeeze=1 )
corners_id = ".".join( [ lat_d01.id, lon_d01.id ] )
corners_data = product_cache.get( corners_id, None ) if product_cache else None
if corners_data:
( lat_corners, lon_corners, roi ) = corners_data
else:
lat_corners, lon_corners, roi = make_corners( lat_d01, lon_d01 )
if product_cache <> None: product_cache[ corners_id ] = ( lat_corners, lon_corners, roi )
ni,nj = lat_d01.shape
iaxis = TransientVirtualAxis("i", ni)
jaxis = TransientVirtualAxis("j", nj)
lataxis = TransientAxis2D(lat_d01, axes=(iaxis, jaxis), bounds=lat_corners, attributes={'units':'degrees_east'}, id="latitude")
lonaxis = TransientAxis2D(lon_d01, axes=(iaxis, jaxis), bounds=lon_corners, attributes={'units':'degrees_north'}, id="longitude")
grid = TransientCurveGrid( lataxis, lonaxis, id='WRF_inner' )
if levaxis:
levaxis.designateLevel()
tVar = cdms2.createVariable( Var, axes=( levaxis, grid ), id=var.id, typecode=Var.typecode() )
else:
tVar = cdms2.createVariable( Var, axes=( grid, ), id=var.id, typecode=Var.typecode() )
a=tVar.getAxis(0)
a.name = 'Latitude'
b=tVar.getAxis(1)
b.name = 'Longitude'
dims = lat_d01.shape if ( lat_d01.MemoryOrder == 'XY' ) else [ lat_d01.shape[1], lat_d01.shape[0] ]
lon0 = roi[0]
dlon = ( roi[1] - roi[0] ) / dims[0]
lat0 = roi[2]
dlat = ( roi[3] - roi[2] ) / dims[1]
lat_lon_grid = cdms2.createUniformGrid( lat0, dims[1], dlat, lon0, dims[0], dlon )
# regrid_Var = tVar.regrid( lat_lon_grid, regridTool = 'esmf', regridMethod = 'conserve' )
# regrid_Var = tVar.regrid( lat_lon_grid )
regrid_Var = tVar.regrid( lat_lon_grid, regridTool = 'libcf', regridMethod = 'linear' )
return regrid_Var
import numpy, cdms2, os, cdtime, sys, shutil
from markError import clearError, markError, reportError
from markError import get_sample_data_dir
clearError()
print 'Test 10: Dataset (filemap) ...',
NYR = 6
NMO = 12
NLAT = 16
NLON = 32
timear = numpy.ma.arange(NYR * NMO, dtype=numpy.float)
time = cdms2.createAxis(timear, id='time')
time.units = "months since 2000-1"
g = cdms2.createUniformGrid(-90.0, NLAT, 180. / (NLAT - 1), 0., NLON,
360. / NLON)
uar = numpy.ma.arange(NYR * NMO * NLAT * NLON)
uar.shape = (NYR * NMO, NLAT, NLON)
u = cdms2.createVariable(uar,
id='u',
axes=(time, g.getLatitude(), g.getLongitude()))
u.units = 'm/s'
var = uar + 100000.
v = cdms2.createVariable(var, id='v', axes=u.getAxisList())
v.units = 'm/s'
tar = uar + 200000.
t = cdms2.createVariable(tar, id='t', axes=u.getAxisList())
t.units = 'K'
#!/usr/bin/env python
# Can't write a _FillValue attribute to a Variable
# J-Y Peterschmitt - LSCE - 07/2015
import cdms2, numpy, cdtime, os, sys
import numpy as np
from markError import NTIME, NLAT, NLON, x, clearError, markError, reportError
clearError()
data = np.random.random((10, 10))
data = np.ma.array(data, fill_value=1234.0)
data = np.ma.masked_less(data, 0.5)
dummy_grid = cdms2.createUniformGrid(10, 10, 1, 0, 10, 1)
dummy_var = cdms2.createVariable(data, axes=[dummy_grid.getLatitude(), dummy_grid.getLongitude()], id="my_var")
if dummy_var.fill_value != 1234.0:
markError("createVariable fill_value failed")
# Test if all fillvalue related attributes are changed
dummy_var.fill_value = 2.0e20
if (dummy_var.fill_value != 2.0e20) or (dummy_var._FillValue != 2.0e20) or (dummy_var.missing_value != 2.0e20):
markError("fill_value property failed (value 2.e20)")
dummy_var._FillValue = 1.33
if (dummy_var.fill_value != 1.33) or (dummy_var._FillValue != 1.33) or (dummy_var.missing_value != 1.33):
markError("fill_value property failed (value 1.33)")
dummy_var.dummy_att = "Dummy att"
dummy_var._dummy_att = "Dummy att starting with _"
dummy_var.units = "10e3 dummy"
def testFilemaps(self):
NYR = 6
NMO = 12
NLAT = 16
NLON = 32
timear = numpy.ma.arange(NYR * NMO, dtype=numpy.float)
time = cdms2.createAxis(timear, id='time')
time.units = "months since 2000-1"
g = cdms2.createUniformGrid(-90.0, NLAT, 180. / (NLAT - 1), 0., NLON,
360. / NLON)
uar = numpy.ma.arange(NYR * NMO * NLAT * NLON)
uar.shape = (NYR * NMO, NLAT, NLON)
u = cdms2.createVariable(uar,
id='u',
axes=(time, g.getLatitude(),
g.getLongitude()))
u.units = 'm/s'
var = uar + 100000.
v = cdms2.createVariable(var, id='v', axes=u.getAxisList())
v.units = 'm/s'
tar = uar + 200000.
t = cdms2.createVariable(tar, id='t', axes=u.getAxisList())
t.units = 'K'
imo = 0
for year in range(2000, 2006):
f = self.getTempFile('cdtest10_uv_%d.nc' % year, 'w')
uchunk = u.subSlice((imo, imo + 12))
f.write(uchunk)
vchunk = v.subSlice((imo, imo + 12))
f.write(vchunk)
f.close()
g = self.getTempFile('cdtest10_t_%d.nc' % year, 'w')
if year == 2004:
tchunk = t.subSlice(imo + 6)
else:
tchunk = t.subSlice((imo, imo + 12))
g.write(tchunk)
g.close()
imo += 12
# Test filemap access ...
pth = cdat_info.get_sampledata_path()
shutil.copy2(os.path.join(pth, "cdtest10.xml"),
os.path.join(self.tempdir, "cdtest10.xml"))
f = self.getTempFile('cdtest10.xml')
# Read u from 2001-7 to 2002-7 and compare
u = f.getVariable('u')
t = u.getTime()
t1 = cdtime.comptime(2001, 7).torel(t.units).value
t2 = cdtime.comptime(2002, 7).torel(t.units).value
uar2 = u.getRegion(time=(t1, t2, 'con'))
uar2p = uar[18:30]
self.assertTrue(numpy.ma.allclose(uar2, uar2p))
# Read u from 2003-7 to 2004-7 and compare
t1 = cdtime.comptime(2003, 7).torel(t.units).value
t2 = cdtime.comptime(2004, 7).torel(t.units).value
uar3 = u.getRegion(time=(t1, t2, 'con'))
uar3p = uar[48:54]
self.assertTrue(numpy.ma.allclose(uar3, uar3p))
# Read t from 2003-7 to 2005-7 and compare
tt = f.getVariable('t')
t1 = cdtime.comptime(2003, 7).torel(t.units).value
t2 = cdtime.comptime(2005, 7).torel(t.units).value
tar2 = tt.getRegion(time=(t1, t2, 'con'))
tar2p = numpy.ma.concatenate((tar[numpy.newaxis, 54], tar[60:66]))
self.assertTrue(numpy.ma.allclose(tar2, tar2p))
except getopt.error:
usage()
if not ifile or not ofile or not maskfile:
print "Error: filenames undefined"
usage()
m = umfile.UMFile(maskfile)
f = umfile.UMFile(ifile)
# Target grid properties
nlon_target = m.inthead[IC_XLen]
nlat_target = m.inthead[IC_YLen]
# Create new axes for the output grid
outgrid = cdms2.createUniformGrid(m.realhead[RC_FirstLat], nlat_target, m.realhead[RC_LatSpacing], m.realhead[RC_FirstLong], nlon_target, m.realhead[RC_LongSpacing])
g = umfile.UMFile(ofile, "w")
g.copyheader(f)
# Change the grid values in the output header to match the chosen origin and
# size
g.inthead[IC_XLen] = nlon_target
g.inthead[IC_YLen] = nlat_target
g.realhead[RC_FirstLat] = m.realhead[RC_FirstLat]
g.realhead[RC_FirstLong] = m.realhead[RC_FirstLong]
g.realhead[RC_PoleLong] = m.realhead[RC_PoleLong]
g.realhead[RC_PoleLat] = m.realhead[RC_PoleLat]
g.realhead[RC_LatSpacing] = m.realhead[RC_LatSpacing]
g.realhead[RC_LongSpacing] = m.realhead[RC_LongSpacing]
lat0 = g.realhead[RC_FirstLat] - g.realhead[RC_LatSpacing]
def standard_regrid(file, var, **args):
from cdms2.coord import TransientVirtualAxis, TransientAxis2D
from cdms2.hgrid import TransientCurveGrid
isVolume = False
levaxis = None
product_cache = args.get('cache', None)
iproc = args.get('iproc', 0)
if (len(var.shape) == 4):
Var = var[0, :, :, :]
levaxis = Var.getLevel()
if levaxis == None:
domain = Var.getDomain()
for axis in domain:
if isLevelAxisId(axis[0].id.lower()):
levaxis = axis[0]
break
else:
Var = var[0, :, :]
if hasattr(Var, "coordinates"):
axis_ids = Var.coordinates.strip().split(' ')
lat_d01 = file(axis_ids[1], squeeze=1)
lon_d01 = file(axis_ids[0], squeeze=1)
elif hasattr(Var, "stagger"):
stagger = Var.stagger.strip()
lat_d01 = file("XLAT_%s" % stagger, squeeze=1)
lon_d01 = file("XLONG_%s" % stagger, squeeze=1)
else:
lat_d01 = file("XLAT", squeeze=1)
lon_d01 = file("XLONG", squeeze=1)
corners_id = ".".join([lat_d01.id, lon_d01.id])
corners_data = product_cache.get(corners_id,
None) if product_cache else None
if corners_data:
(lat_corners, lon_corners, roi) = corners_data
else:
lat_corners, lon_corners, roi = make_corners(lat_d01, lon_d01)
if product_cache <> None:
product_cache[corners_id] = (lat_corners, lon_corners, roi)
ni, nj = lat_d01.shape
iaxis = TransientVirtualAxis("i", ni)
jaxis = TransientVirtualAxis("j", nj)
lataxis = TransientAxis2D(lat_d01,
axes=(iaxis, jaxis),
bounds=lat_corners,
attributes={'units': 'degrees_east'},
id="latitude")
lonaxis = TransientAxis2D(lon_d01,
axes=(iaxis, jaxis),
bounds=lon_corners,
attributes={'units': 'degrees_north'},
id="longitude")
grid = TransientCurveGrid(lataxis, lonaxis, id='WRF_inner')
if levaxis:
levaxis.designateLevel()
tVar = cdms2.createVariable(Var,
axes=(levaxis, grid),
id=var.id,
typecode=Var.typecode())
else:
tVar = cdms2.createVariable(Var,
axes=(grid, ),
id=var.id,
typecode=Var.typecode())
a = tVar.getAxis(0)
a.name = 'Latitude'
b = tVar.getAxis(1)
b.name = 'Longitude'
dims = lat_d01.shape if (
lat_d01.MemoryOrder == 'XY') else [lat_d01.shape[1], lat_d01.shape[0]]
lon0 = roi[0]
dlon = (roi[1] - roi[0]) / dims[0]
lat0 = roi[2]
dlat = (roi[3] - roi[2]) / dims[1]
lat_lon_grid = cdms2.createUniformGrid(lat0, dims[1], dlat, lon0, dims[0],
dlon)
# regrid_Var = tVar.regrid( lat_lon_grid, regridTool = 'esmf', regridMethod = 'conserve' )
# regrid_Var = tVar.regrid( lat_lon_grid )
regrid_Var = tVar.regrid(lat_lon_grid,
regridTool='libcf',
regridMethod='linear')
return regrid_Var
#!/usr/bin/env python
# Can't write a _FillValue attribute to a Variable
# J-Y Peterschmitt - LSCE - 07/2015
import cdms2, numpy, cdtime, os, sys
import numpy as np
from markError import NTIME, NLAT, NLON, x, clearError, markError, reportError
clearError()
data = np.random.random((10, 10))
data = np.ma.array(data, fill_value=1234.0)
data = np.ma.masked_less(data, 0.5)
dummy_grid = cdms2.createUniformGrid(10, 10, 1, 0, 10, 1)
dummy_var = cdms2.createVariable(
data,
axes=[dummy_grid.getLatitude(),
dummy_grid.getLongitude()],
id='my_var')
if dummy_var.fill_value != 1234.0:
markError("createVariable fill_value failed")
# Test if all fillvalue related attributes are changed
dummy_var.fill_value = 2.e+20
if (dummy_var.fill_value != 2.e20) or \
(dummy_var._FillValue != 2.e20) or \
(dummy_var.missing_value != 2.e20) :
markError("fill_value property failed (value 2.e20)")
dummy_var._FillValue = 1.33
if (dummy_var.fill_value != 1.33) or \
#!/usr/bin/env python import numpy, cdms2, os, cdtime, sys from markError import clearError,markError,reportError clearError() print 'Test 10: Dataset (filemap) ...', NYR = 6 NMO = 12 NLAT = 16 NLON = 32 timear = numpy.ma.arange(NYR*NMO, dtype=numpy.float) time = cdms2.createAxis(timear, id='time') time.units = "months since 2000-1" g = cdms2.createUniformGrid(-90.0, NLAT, 180./(NLAT-1), 0., NLON, 360./NLON) uar = numpy.ma.arange(NYR*NMO*NLAT*NLON) uar.shape = (NYR*NMO,NLAT,NLON) u = cdms2.createVariable(uar, id='u', axes = (time, g.getLatitude(), g.getLongitude())) u.units = 'm/s' var = uar + 100000. v = cdms2.createVariable(var, id='v', axes = u.getAxisList()) v.units = 'm/s' tar = uar + 200000. t = cdms2.createVariable(tar, id='t', axes = u.getAxisList()) t.units = 'K' imo = 0 for year in range(2000,2006):
#
# usage: %prog dataset lons lats outfile
#
# where lons and lats are integers representing number of grid points
import sys
import cdms2
dataset, lons, lats, outfile = sys.argv[1:]
lons = int(lons)
lats = int(lats)
#!TODO: should I check order='yx'
#!TODO: refine grid spec
dest_grid = cdms2.createUniformGrid(-90, lats, 180. / lats, 0, lons,
360. / lons)
ds = cdms2.open(dataset)
# Select first variable with a grid
for var in ds.variables.values():
if var.getGrid():
print 'Regridding variable %s' % var.id
break
else:
raise Exception("No variable with grid found")
new_var = var.regrid(dest_grid)
out = cdms2.open(outfile, 'w')
out.write(new_var, extend=0)
# Adapted for numpy/ma/cdms2 by convertcdms.py import cdms2 import sys, MV2 import ZonalMeans delta_lon = .5 delta_lat = .5 nlat = int(180. / delta_lat) nlon = int(360 / delta_lon) s = MV2.ones((nlat, nlon), typecode='f') print delta_lon, nlon, delta_lat, nlat g = cdms2.createUniformGrid(-89.5, nlat, delta_lat, 0., nlon, delta_lon) s.setAxis(-1, g.getLongitude()) s.setAxis(-2, g.getLatitude()) s.setGrid(g) print s.shape print s.getGrid() print s.getLongitude() print s.getLatitude() zm = ZonalMeans.compute(s, delta_band=5) print zm
usage()
if not ifile or not ofile or not maskfile:
print "Error: filenames undefined"
usage()
m = umfile.UMFile(maskfile)
f = umfile.UMFile(ifile)
# Target grid properties
nlon_target = m.inthead[IC_XLen]
nlat_target = m.inthead[IC_YLen]
# Create new axes for the output grid
outgrid = cdms2.createUniformGrid(m.realhead[RC_FirstLat], nlat_target,
m.realhead[RC_LatSpacing],
m.realhead[RC_FirstLong], nlon_target,
m.realhead[RC_LongSpacing])
g = umfile.UMFile(ofile, "w")
g.copyheader(f)
# Change the grid values in the output header to match the chosen origin and
# size
g.inthead[IC_XLen] = nlon_target
g.inthead[IC_YLen] = nlat_target
g.realhead[RC_FirstLat] = m.realhead[RC_FirstLat]
g.realhead[RC_FirstLong] = m.realhead[RC_FirstLong]
g.realhead[RC_PoleLong] = m.realhead[RC_PoleLong]
g.realhead[RC_PoleLat] = m.realhead[RC_PoleLat]
g.realhead[RC_LatSpacing] = m.realhead[RC_LatSpacing]
g.realhead[RC_LongSpacing] = m.realhead[RC_LongSpacing]
def make_grid(self):
return cdms2.createUniformGrid(-87.5, 36, 5.0, 5, 36, 10)
def make_grid(self):
return cdms2.createUniformGrid(-87.5, 36, 5.0, 5, 36, 10)
def _oisst_daily(daily_sst_dir, daily_sst_filename, targ_grid_res):
#---------------------------------------------------------------------
"""
See file header.
"""
print('targ_grid_res: ', targ_grid_res)
time_span_tag = daily_sst_filename.split('.')[2]
time_units = 'days since ' + time_span_tag.split('-')[0] + '-1-1 00:00:00'
year_start = int(time_span_tag.split('-')[0])
daily_ice_filename = daily_sst_filename.replace('sst', 'icec')
# Create target grid.
# For a ONEXONE target grid resolution with arguments:
# (-90., 181, 1., 0., 360, 1.)
# A grid will be created with:
# latitude starting at -90 & going north 181 points,
# with an increment of 1 degree;
# longitude starting at 0E & going east 360 points,
# with an increment of 1 degree.
# The out_filename will reflect the designated resolution.
#---------------------------------------------------------
args = TARG_GRID_RES_DICT[targ_grid_res]['args']
targ_grid = cdms2.createUniformGrid(args[0], args[1], args[2], args[3],
args[4], args[5])
label = TARG_GRID_RES_DICT[targ_grid_res]['label']
out_filename = 'sst_daily_cdcunits' + label + time_span_tag + '.nc'
fdaily_sst = cdms2.open(daily_sst_dir + '/' + daily_sst_filename)
fdaily_ice = cdms2.open(daily_sst_dir + '/' + daily_ice_filename)
input_grid = fdaily_sst.variables['sst'].getGrid()
rg_in2targ = Regridder(input_grid, targ_grid)
# Create file and variables for output.
#--------------------------------------
#fout = NetCDF.NetCDFFile(out_filename, 'w')
fout = Cdunif.CdunifFile(out_filename, 'w')
lons = targ_grid.getLongitude()[:]
lats = targ_grid.getLatitude()[:]
fout.createDimension('lon', len(lons))
fout.createDimension('lat', len(lats))
fout.createDimension('time', None)
sst_cpl = fout.createVariable('sst', 'f', ('time', 'lat', 'lon'))
sst_cpl.long_name = 'sea surface temperature'
sst_cpl.units = 'degrees_C'
ifrac = fout.createVariable('ifrac', 'f', ('time', 'lat', 'lon'))
ifrac.long_name = 'ice fraction'
ifrac.units = 'fraction'
lat = fout.createVariable('lat', 'd', ('lat', ))
lat.long_name = 'latitude of grid cell center'
lat.units = 'degrees_north'
lon = fout.createVariable('lon', 'd', ('lon', ))
lon.long_name = 'longitude of grid cell center'
lon.units = 'degrees_east'
time = fout.createVariable('time', 'd', ('time', ))
time.long_name = 'time'
time.units = time_units
time.calendar = 'noleap'
date = fout.createVariable('date', 'i', ('time', ))
date.long_name = 'calendar date (YYYYMMDD)'
datesec = fout.createVariable('datesec', 'i', ('time', ))
datesec.long_name = 'seconds elapsed on calendar date'
datesec.units = 'seconds'
# Coordinate data.
#-----------------
lat[:] = lats
lat.long_name = 'latitude'
lat.units = 'degrees_north'
lon[:] = lons
lon.long_name = 'longitude'
lon.units = 'degrees_east'
sst_w = fdaily_sst.variables['sst']
ntimes = sst_w.shape[0]
intime = sst_w.getTime()
intime_units = intime.units
intimes = intime[:]
# Time loop.
#-----------
time_idx_out = -1
for time_idx in range(ntimes - 1):
# Data is centered on time in file.
#----------------------------------
mid_intime = intimes[time_idx]
rtime = cdtime.reltime(mid_intime, intime_units)
ctime = rtime.tocomp()
new_reltime = ctime.torel(time_units, cdtime.NoLeapCalendar)
new_ctime = new_reltime.tocomp()
year = ctime.year
if year < year_start:
#=======
continue
#=======
month = ctime.month
day = ctime.day
hour = ctime.hour
minute = ctime.minute
second = ctime.second
# Change time units.
#-------------------
print ('time_idx_out, ctime, new_ctime: ', \
time_idx_out, ctime, new_ctime)
time[time_idx_out] = new_reltime.value
print('time[time_idx_out]: ', time[time_idx_out])
date[time_idx_out] = (year * 10000) + (month * 100) + day
datesec[time_idx_out] = (hour * 60 * 60) + (minute * 60) + second
data = fdaily_sst('sst',
time=slice(time_idx, (time_idx + 1)),
raw=1,
squeeze=1)
data_f = fill_msg(data, nscan=200)
data_f = n.array(data_f, n.float32)
print ('data_f min,max,mean: ', \
data_f.min(), data_f.max(), data_f.mean() )
data_f = rg_in2targ(data_f).filled()
out_sst = data_f
print ('out_sst min,max,mean: ', \
out_sst.min(), out_sst.max(), out_sst.mean() )
data = fdaily_ice('icec',
time=slice(time_idx, (time_idx + 1)),
raw=1,
squeeze=1)
data_f = data * 1.0
print ('data_f min,max,mean: ', \
data_f.min(), data_f.max(), data_f.mean() )
# Set ice to zero where missing - over land.
#-------------------------------------------
data_f = rg_in2targ(data_f).filled(0.0)
out_ice = data_f
print ('out_ice min,max,mean: ', \
out_ice.min(), out_ice.max(), out_ice.mean() )
sst_cpl[time_idx_out, :, :] = out_sst
ifrac[time_idx_out, :, :] = out_ice
time_idx_out = time_idx_out + 1
fout.sync()
fout.close()
return
def testWriteFillValue(self):
data = np.random.random((10, 10))
data = np.ma.array(data, fill_value=1234.0)
data = np.ma.masked_less(data, 0.5)
dummy_grid = cdms2.createUniformGrid(10, 10, 1, 0, 10, 1)
dummy_var = cdms2.createVariable(
data,
axes=[
dummy_grid.getLatitude(),
dummy_grid.getLongitude()],
id='my_var')
if dummy_var.fill_value != 1234.0:
markError("createVariable fill_value failed")
# Test if all fillvalue related attributes are changed
dummy_var.fill_value = 2.e+20
self.assertTrue(all([v == 2.e20 for v in (
dummy_var.fill_value, dummy_var._FillValue, dummy_var.missing_value)]))
dummy_var._FillValue = 1.33
self.assertTrue(all([v == 1.33 for v in (
dummy_var.fill_value, dummy_var._FillValue, dummy_var.missing_value)]))
dummy_var.dummy_att = 'Dummy att'
dummy_var._dummy_att = 'Dummy att starting with _'
dummy_var.units = '10e3 dummy'
cdms2.setNetcdfShuffleFlag(0)
cdms2.setNetcdfDeflateFlag(0)
cdms2.setNetcdfDeflateLevelFlag(0)
# Test 1 passing fill_value
var_att = dummy_var.attributes
f = self.getTempFile('dummy1.nc', 'w')
f.write(dummy_var, fill_value=999.999)
f.close()
f = self.getTempFile('dummy1.nc')
m = f("my_var")
self.assertTrue(
all([v == 999.999 for v in (m.fill_value, m._FillValue, m.missing_value)]))
# Test 2 Copy dummy_var attributes
var_att = dummy_var.attributes
var_att['another_att'] = 'New att'
var_att['_another_att'] = 'New att starting with _'
f = self.getTempFile('dummy2.nc', 'w')
f.write(dummy_var, attributes=var_att)
f.close()
f = self.getTempFile('dummy2.nc')
m = f("my_var")
self.assertTrue(
all([v == 1.33 for v in (m.fill_value, m._FillValue, m.missing_value)]))
# Test 3 pass variable as is
dummy_var = cdms2.createVariable(
data,
axes=[
dummy_grid.getLatitude(),
dummy_grid.getLongitude()],
id='dummy3_var')
f = self.getTempFile('dummy3.nc', 'w')
f.write(dummy_var)
f.close()
f = self.getTempFile('dummy3.nc')
m = f("dummy3_var")
self.assertTrue(
all([v == 1234.0 for v in (m.fill_value, m._FillValue, m.missing_value)]))
