def teestTimes2(self):
a=MV2.masked_array(MV2.array([0,0,0,0,0,0,0,0,0,0,0,0]),[0,1,1,1,1,1,1,1,1,1,1,0])
bounds=numpy.ma.array(
[[0,31],
[31,59],
[59,90],
[90,120],
[120,151],
[151,181],
[181,212],
[212,243],
[243,273],
[273,304],
[304,334],
[334,365]]
)
ax=a.getAxis(0)
ax.setBounds(bounds)
#print cdutil.times.centroid(a,[-10,30])
print(('Centroid Normal:',cdutil.times.centroid(a,[0,365])))
print(('Centroid Cyclic:',cdutil.times.cyclicalcentroid(a,[0,365])))
djf=cdutil.DJF(self.tas_mo)
djf=cdutil.DJF(self.tas_mo,criteriaarg=[.8,0.0001])
djf=cdutil.ANNUALCYCLE.climatology(self.tas_mo)
djf=cdutil.YEAR.departures(self.tas_mo)
def corr_proba(r, ndata, ndataset=2, dof=False):
"""Probability of rejecting correlations
- **r**: Correlation coefficient
- **ndata**: Number of records use for correlations
- **ndataset**, optional: Number of datasets (1 for autocorrelations, else 2) [default: 2]
.. todo::
This must be rewritten using :mod:`scipy.stats`
"""
# TODO: use scipy for betai and _gamma?
from genutil.salstat import betai,_gammaln
# Basic tests
ndata = MA.masked_equal(ndata,0,copy=0)
r = MV2.masked_where(MA.equal(MA.absolute(r),1.),r,copy=0)
# Degree of freedom
if dof:
df = ndata
else:
df = ndata-2-ndataset
# Advanced test: prevent extreme values by locally decreasing the dof
reduc = N.ones(r.shape)
z = None
while z is None or MA.count(MA.masked_greater(z,-600.)):
if z is not None:
imax = MA.argmin(z.ravel())
reduc.flat[imax] += 1
dfr = df/reduc
t = r*MV2.sqrt(dfr/((1.0-r)* (1.0+r)))
a = 0.5*dfr
b = 0.5
x = df/(dfr+t**2)
z = _gammaln(a+b)-_gammaln(a)-_gammaln(b)+a*MA.log(x)+b*MA.log(1.0-x)
# Perfom the test and format the variable
prob = MV2.masked_array(betai(a,b,x),axes=r.getAxisList())*100
prob.id = 'corr_proba' ; prob.name = prob.id
prob.long_name = 'Probability of rejection'
prob.units = '%'
return prob
def corr_proba(r, ndata, ndataset=2, dof=False):
"""Probability of rejecting correlations
- **r**: Correlation coefficient
- **ndata**: Number of records use for correlations
- **ndataset**, optional: Number of datasets (1 for autocorrelations, else 2) [default: 2]
.. todo::
This must be rewritten using :mod:`scipy.stats`
"""
# Basic tests
ndata = MA.masked_equal(ndata,0,copy=0)
r = MV2.masked_where(MA.equal(MA.absolute(r),1.),r,copy=0)
# Degree of freedom
if dof:
df = ndata
else:
df = ndata-2-ndataset
# Advanced test: prevent extreme values by locally decreasing the dof
reduc = N.ones(r.shape)
z = None
while z is None or MA.count(MA.masked_greater(z,-600.)):
if z is not None:
imax = MA.argmin(z.ravel())
reduc.flat[imax] += 1
dfr = df/reduc
t = r*MV2.sqrt(dfr/((1.0-r)* (1.0+r)))
a = 0.5*dfr
b = 0.5
x = df/(dfr+t**2)
z = _gammaln(a+b)-_gammaln(a)-_gammaln(b)+a*MA.log(x)+b*MA.log(1.0-x)
# Perfom the test and format the variable
prob = MV2.masked_array(betai(a,b,x),axes=r.getAxisList())*100
prob.id = 'corr_proba' ; prob.name = prob.id
prob.long_name = 'Probability of rejection'
prob.units = '%'
return prob
x13 = MV2.add.reduce(uf)
x14 = MV2.add.reduce(ud)
x15 = x9.astype(numpy.float32)
if not x15.dtype.char == numpy.sctype2char(numpy.float32):
markError('astype error')
## arrayrange(start, stop=None, step=1, typecode=None, axis=None, attributes=None, id=None)
## Just like range() except it returns a variable whose type can be specfied
## by the keyword argument typecode. The axis of the result variable may be specified.
xarange = MV2.arange(16., axis=ulat)
## masked_array(a, mask=None, fill_value=None, axes=None, attributes=None, id=None)
## masked_array(a, mask=None) =
## array(a, mask=mask, copy=0, fill_value=fill_value)
## Use fill_value(a) if None.
xmarray = MV2.masked_array(ud)
## masked_object(data, value, copy=1, savespace=0)
## Create array masked where exactly data equal to value
## masked_values(data, value, rtol=1.0000000000000001e-05, atol=1e-08, copy=1, savespace=0, axes=None,
## attributes=None, id=None)
## masked_values(data, value, rtol=1.e-5, atol=1.e-8)
## Create a masked array; mask is None if possible.
## May share data values with original array, but not recommended.
## Masked where abs(data-value)<= atol + rtol * abs(value)
## ones(shape, typecode='l', savespace=0, axes=None, attributes=None, id=None)
## ones(n, typecode=Int, savespace=0, axes=None, attributes=None, id=None) =
## an array of all ones of the given length or shape.
xones = MV2.ones(uf.shape,
def plot(self, data, template=None, bg=0, x=None, **kwargs):
if x is None:
x = self.x
if template is None:
template = self.template
elif isinstance(template, str):
template = x.gettemplate(template)
elif not vcs.istemplate(template): # pragma: no cover
raise ValueError("Error did not know what to do with template: %s" % template) # pragma: no cover
try:
data_name = data.title
except AttributeError:
try:
data_name = data.long_name
except AttributeError:
try:
data_name = data.id + data.units
except AttributeError:
try:
data_name = data.id
except AttributeError:
data_name = "array"
# We'll just flatten the data... if they want to be more precise, should pass in more precise data
if isinstance(data, cdms2.avariable.AbstractVariable):
data = data.asma()
data = data.flatten()
# ok now we have a good x and a good data
if not self.bins:
self.bins = vcs.utils.mkscale(*vcs.minmax(data))
# Sort the bins
self.bins.sort()
# Prune duplicates
pruned_bins = []
for bin in self.bins:
if pruned_bins and numpy.allclose(bin, pruned_bins[-1]):
continue
pruned_bins.append(bin)
self.bins = pruned_bins
data_bins = numpy.digitize(data, self.bins) - 1
binned = [data[data_bins==i] for i in range(len(self.bins))]
means = []
stds = []
max_possible_deviance = 0
for ind, databin in enumerate(binned):
if len(databin) > 0:
means.append(databin.mean())
stds.append(databin.std())
else:
means.append(0)
stds.append(0)
if len(self.bins) > ind + 1:
max_possible_deviance = max(means[ind] - self.bins[ind], self.bins[ind + 1] - means[ind], max_possible_deviance)
else:
max_possible_deviance = max(means[ind] - self.bins[ind], max_possible_deviance)
color_values = [std / max_possible_deviance for std in stds]
y_values = [len(databin) for databin in binned]
nbars = len(self.bins) - 1
# create the primitive
fill = x.createfillarea()
line = x.createline()
fill.viewport = [
template.data.x1, template.data.x2, template.data.y1, template.data.y2]
line.viewport = [
template.data.x1, template.data.x2, template.data.y1, template.data.y2]
vcs_min_max = vcs.minmax(self.bins)
if numpy.allclose(self.datawc_x1, 1e20):
xmn = vcs_min_max[0]
else:
xmn = self.datawc_x1
if numpy.allclose(self.datawc_x2, 1e20):
xmx = vcs_min_max[1]
else:
xmx = self.datawc_x2
if numpy.allclose(self.datawc_y2, 1e20):
# Make the y scale be slightly larger than the largest bar
ymx = max(y_values) * 1.25
else:
ymx = self.datawc_y2
if numpy.allclose(self.datawc_y1, 1e20):
ymn = 0
else:
ymn = self.datawc_y1
fill.worldcoordinate = [xmn, xmx, ymn, ymx]
line.worldcoordinate = [xmn, xmx, ymn, ymx]
styles = []
cols = []
indices = []
lt = []
lw = []
lc = []
xs = []
ys = []
levels = [.1 * i for i in range(11)]
# Extend fillarea and line attrs to levels
if self.fillareastyles:
while len(self.fillareastyles) < (len(levels) - 1):
self.fillareastyles.append(self.fillareastyles[-1])
else:
self.fillareastyles = ["solid"] * (len(levels) - 1)
if self.fillareacolors:
while len(self.fillareacolors) < (len(levels) - 1):
self.fillareacolors.append(self.fillareacolors[-1])
else:
for lev in levels[:-1]:
self.fillareacolors.append(int((self.color_2 - self.color_1) * lev) + self.color_1)
if self.fillareaindices:
while len(self.fillareaindices) < (len(levels) - 1):
self.fillareaindices.append(self.fillareaindices[-1])
else:
self.fillareaindices = [1] * (len(levels) - 1)
if self.line:
while len(self.line) < (len(levels) - 1):
self.line.append(self.line[-1])
else:
self.line = ["solid"] * (len(levels) - 1)
if self.linewidth:
while len(self.linewidth) < (len(levels) - 1):
self.linewidth.append(self.linewidth[-1])
else:
self.linewidth = [1] * (len(levels) - 1)
if self.linecolors:
while len(self.linecolors) < (len(levels) - 1):
self.linecolors.append(self.linecolors[-1])
else:
self.linecolors = ["black"] * (len(levels) - 1)
for i in range(nbars):
# Calculate level for bar
value = color_values[i]
for lev_ind in range(len(levels)):
if levels[lev_ind] > value:
if lev_ind > 0:
lev_ind -= 1
break
else:
# Shouldn't ever get here since level 0 is 0
assert False # pragma: no cover
else:
assert False # pragma: no cover
styles.append(self.fillareastyles[lev_ind])
cols.append(self.fillareacolors[lev_ind])
indices.append(self.fillareaindices[lev_ind])
lt.append(self.line[lev_ind])
lw.append(self.linewidth[lev_ind])
lc.append(self.linecolors[lev_ind])
xs.append([self.bins[i], self.bins[i], self.bins[i + 1], self.bins[i + 1]])
ys.append([0, y_values[i], y_values[i], 0])
fill.style = styles
fill.x = xs
fill.y = ys
fill.style
fill.index = indices
fill.color = cols
fill.colormap = self.colormap
line.x = xs
line.y = ys
line.type = lt
line.width = lw
line.color = lc
displays = []
x_axis = cdms2.createAxis(self.bins, id=data_name)
y_axis = cdms2.createAxis(vcs.mkscale(ymn, ymx), id="bin_size")
displays.append(x.plot(fill, bg=bg, render=False))
arr = MV2.masked_array(y_values)
arr.setAxis(0, x_axis)
dsp = template.plot(x, arr, self, bg=bg, X=x_axis, Y=y_axis)
for d in dsp:
if d is not None:
displays.append(d)
legend_labels = {0: "No Variance",
.1: "",
.2: "",
.3: "",
.4: "",
.5: "",
.6: "",
.7: "",
.8: "",
.9: "",
1: "High Variance"}
template.drawColorBar(self.fillareacolors, levels,
legend=legend_labels, x=x,
style=self.fillareastyles,
index=self.fillareaindices)
displays.append(x.plot(line, bg=bg))
x.worldcoordinate = fill.worldcoordinate
self.restore()
return displays
def plot(self, data, template=None, bg=0, x=None, **kwargs):
if x is None:
x = self.x
if template is None:
template = self.template
elif isinstance(template, str):
template = x.gettemplate(template)
elif not vcs.istemplate(template): # pragma: no cover
raise ValueError(
"Error did not know what to do with template: %s" %
template) # pragma: no cover
try:
data_name = data.title
except AttributeError:
try:
data_name = data.long_name
except AttributeError:
try:
data_name = data.id + data.units
except AttributeError:
try:
data_name = data.id
except AttributeError:
data_name = "array"
# We'll just flatten the data... if they want to be more precise,
# should pass in more precise data
if isinstance(data, cdms2.avariable.AbstractVariable):
data = data.asma()
data = data.flatten()
# ok now we have a good x and a good data
if not self.bins:
self.bins = vcs.utils.mkscale(*vcs.minmax(data))
# Sort the bins
self.bins.sort()
# Prune duplicates
pruned_bins = []
for bin in self.bins:
if pruned_bins and numpy.allclose(bin, pruned_bins[-1]):
continue
pruned_bins.append(bin)
self.bins = pruned_bins
data_bins = numpy.digitize(data, self.bins) - 1
binned = [data[data_bins == i] for i in range(len(self.bins))]
means = []
stds = []
max_possible_deviance = 0
for ind, databin in enumerate(binned):
if len(databin) > 0:
means.append(databin.mean())
stds.append(databin.std())
else:
means.append(0)
stds.append(0)
if len(self.bins) > ind + 1:
max_possible_deviance = max(means[ind] - self.bins[ind],
self.bins[ind + 1] - means[ind],
max_possible_deviance)
else:
max_possible_deviance = max(means[ind] - self.bins[ind],
max_possible_deviance)
color_values = [std / max_possible_deviance for std in stds]
y_values = [len(databin) for databin in binned]
nbars = len(self.bins) - 1
# create the primitive
fill = x.createfillarea()
line = x.createline()
fill.viewport = [
template.data.x1, template.data.x2, template.data.y1,
template.data.y2
]
line.viewport = [
template.data.x1, template.data.x2, template.data.y1,
template.data.y2
]
vcs_min_max = vcs.minmax(self.bins)
if numpy.allclose(self.datawc_x1, 1e20):
xmn = vcs_min_max[0]
else:
xmn = self.datawc_x1
if numpy.allclose(self.datawc_x2, 1e20):
xmx = vcs_min_max[1]
else:
xmx = self.datawc_x2
if numpy.allclose(self.datawc_y2, 1e20):
# Make the y scale be slightly larger than the largest bar
ymx = max(y_values) * 1.25
else:
ymx = self.datawc_y2
if numpy.allclose(self.datawc_y1, 1e20):
ymn = 0
else:
ymn = self.datawc_y1
fill.worldcoordinate = [xmn, xmx, ymn, ymx]
line.worldcoordinate = [xmn, xmx, ymn, ymx]
styles = []
cols = []
indices = []
lt = []
lw = []
lc = []
xs = []
ys = []
levels = [.1 * i for i in range(11)]
# Extend fillarea and line attrs to levels
if self.fillareastyles:
while len(self.fillareastyles) < (len(levels) - 1):
self.fillareastyles.append(self.fillareastyles[-1])
else:
self.fillareastyles = ["solid"] * (len(levels) - 1)
if self.fillareacolors:
while len(self.fillareacolors) < (len(levels) - 1):
self.fillareacolors.append(self.fillareacolors[-1])
else:
for lev in levels[:-1]:
self.fillareacolors.append(
int((self.color_2 - self.color_1) * lev) + self.color_1)
if self.fillareaindices:
while len(self.fillareaindices) < (len(levels) - 1):
self.fillareaindices.append(self.fillareaindices[-1])
else:
self.fillareaindices = [1] * (len(levels) - 1)
if self.line:
while len(self.line) < (len(levels) - 1):
self.line.append(self.line[-1])
else:
self.line = ["solid"] * (len(levels) - 1)
if self.linewidth:
while len(self.linewidth) < (len(levels) - 1):
self.linewidth.append(self.linewidth[-1])
else:
self.linewidth = [1] * (len(levels) - 1)
if self.linecolors:
while len(self.linecolors) < (len(levels) - 1):
self.linecolors.append(self.linecolors[-1])
else:
self.linecolors = ["black"] * (len(levels) - 1)
for i in range(nbars):
# Calculate level for bar
value = color_values[i]
for lev_ind in range(len(levels)):
if levels[lev_ind] > value:
if lev_ind > 0:
lev_ind -= 1
break
else:
# Shouldn't ever get here since level 0 is 0
assert False # pragma: no cover
else:
assert False # pragma: no cover
styles.append(self.fillareastyles[lev_ind])
cols.append(self.fillareacolors[lev_ind])
indices.append(self.fillareaindices[lev_ind])
lt.append(self.line[lev_ind])
lw.append(self.linewidth[lev_ind])
lc.append(self.linecolors[lev_ind])
xs.append([
self.bins[i], self.bins[i], self.bins[i + 1], self.bins[i + 1]
])
ys.append([0, y_values[i], y_values[i], 0])
fill.style = styles
fill.x = xs
fill.y = ys
fill.style
fill.index = indices
fill.color = cols
fill.colormap = self.colormap
line.x = xs
line.y = ys
line.type = lt
line.width = lw
line.color = lc
displays = []
x_axis = cdms2.createAxis(self.bins, id=data_name)
y_axis = cdms2.createAxis(vcs.mkscale(ymn, ymx), id="bin_size")
displays.append(x.plot(fill, bg=bg, render=False))
arr = MV2.masked_array(y_values)
arr.setAxis(0, x_axis)
dsp = template.plot(x, arr, self, bg=bg, X=x_axis, Y=y_axis)
for d in dsp:
if d is not None:
displays.append(d)
legend_labels = {
0: "No Variance",
.1: "",
.2: "",
.3: "",
.4: "",
.5: "",
.6: "",
.7: "",
.8: "",
.9: "",
1: "High Variance"
}
template.drawColorBar(self.fillareacolors,
levels,
legend=legend_labels,
x=x,
style=self.fillareastyles,
index=self.fillareaindices)
displays.append(x.plot(line, bg=bg))
x.worldcoordinate = fill.worldcoordinate
self.restore()
return displays
# Adapted for numpy/ma/cdms2 by convertcdms.py
import cdms2, cdutil, numpy.ma, MV2, os, sys, cdat_info
cdms2.setAutoBounds('on')
# centroid test
a = MV2.masked_array(MV2.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0])
bounds = numpy.ma.array([[0, 31], [31, 59], [59, 90], [90, 120], [120, 151],
[151, 181], [181, 212], [212, 243], [243, 273],
[273, 304], [304, 334], [334, 365]])
ax = a.getAxis(0)
ax.setBounds(bounds)
#print cdutil.times.centroid(a,[-10,30])
print 'Centroid Normal:', cdutil.times.centroid(a, [0, 365])
print 'Centroid Cyclic:', cdutil.times.cyclicalcentroid(a, [0, 365])
f = cdms2.open(os.path.join(cdat_info.get_sampledata_path(), 'tas_mo.nc'))
s = f('tas')
cdutil.setTimeBoundsMonthly(s)
djf = cdutil.DJF(s)
djf = cdutil.DJF(s, criteriaarg=[.8, 0.0001])
djf = cdutil.ANNUALCYCLE.climatology(s)
djf = cdutil.YEAR.departures(s)
def spatial_mean(self):
""" Moyenne spatiale en chaque pas de temps pour les champs modelises et observes """
import cdutil, cdms2, MV2, numpy
from vacumm.misc.grid import meshweights
#self.modelspatialmean = MV2.average(MV2.average(self.model, axis=-1), axis=-1)
# --> equivalent a nanmean(nanmean(sst')) sous matlab
#self.modelspatialmean = MV2.average(MV2.average(self.model, axis=1), axis=1)
# --> equivalent a nanmean(nanmean(sst)) sous matlab
#print self.modelspatialmean
self.model.spa_mean = list() #Initialise une liste
self.obs.spa_mean = list() #Initialise une liste
# Estimation de la moyenne a chaque pas de temps
tps = self.obs.getTime()
for i, t in enumerate(tps):
if self.obs[i, :, :].count() == 0:
#self.obs.spa_mean.append(self.obs.fill_value) # voir pour mettre un masque dans la variable a tracer ... ou pour choisir une autre valeur
self.obs.spa_mean.append(0)
self.model.spa_mean.append(0)
else:
#modif J.Gatti- pour que moyenne spatiale fontionne avec une grille curvilineaire et poids soient en metres
lonmod = self.model.getLongitude()
latmod = self.model.getLatitude()
# lon et lat doivent etre 2D pour que meshweigths calcule des poids en m2
if lonmod.rank() == 1:
lonmod, latmod = numpy.meshgrid(lonmod, latmod)
wtsmod = meshweights(lonmod, latmod, proj=True)
# la matrice de poids doit avoir le meme type que la variable moyennee (MV dans notre cas)
wtsmod = MV2.masked_array(
wtsmod,
MV2.getmask(self.model[i, :, :]),
axes=self.model[i, :, :].getAxisList())
self.model.spa_mean.append(
cdutil.averager(self.model[i, :, :],
axis='yx',
weights=wtsmod))
lonobs = self.obs.getLongitude()
latobs = self.obs.getLatitude()
if lonobs.rank() == 1:
lonobs, latobs = numpy.meshgrid(lonobs, latobs)
wtsobs = meshweights(lonobs, latobs, proj=True)
wtsobs = MV2.masked_array(wtsobs,
MV2.getmask(self.obs[i, :, :]),
axes=self.obs[i, :, :].getAxisList())
self.obs.spa_mean.append(
cdutil.averager(self.obs[i, :, :],
axis='yx',
weights=wtsobs))
#self.model.spa_mean.append(cdutil.averager(self.model[i, :, :],axis='yx'))
#self.obs.spa_mean.append(cdutil.averager(self.obs[i, :, :],axis='yx'))
#fin modif J.Gatti
# Transformation en variable cdms2
self.model.spa_mean = cdms2.createVariable(
self.model.spa_mean,
typecode='f',
id='model_spa_mean',
attributes=dict(units=self.model.units))
self.obs.spa_mean = cdms2.createVariable(
self.obs.spa_mean,
typecode='f',
id='obs_spa_mean',
attributes=dict(units=self.obs.units))
# Ajout de l'axe des temps correspondant a self...
self.model.spa_mean.setAxis(0, tps)
self.obs.spa_mean.setAxis(0, tps)
def spatial_mean(self):
""" Moyenne spatiale en chaque pas de temps pour les champs modelises et observes """
import cdutil, cdms2, MV2, numpy
from vacumm.misc.grid import meshweights
#self.modelspatialmean = MV2.average(MV2.average(self.model, axis=-1), axis=-1)
# --> equivalent a nanmean(nanmean(sst')) sous matlab
#self.modelspatialmean = MV2.average(MV2.average(self.model, axis=1), axis=1)
# --> equivalent a nanmean(nanmean(sst)) sous matlab
#print self.modelspatialmean
self.model.spa_mean = list() #Initialise une liste
self.obs.spa_mean = list() #Initialise une liste
# Estimation de la moyenne a chaque pas de temps
tps = self.obs.getTime()
for i, t in enumerate(tps):
if self.obs[i, :, :].count()==0:
#self.obs.spa_mean.append(self.obs.fill_value) # voir pour mettre un masque dans la variable a tracer ... ou pour choisir une autre valeur
self.obs.spa_mean.append(0)
self.model.spa_mean.append(0)
else:
#modif J.Gatti- pour que moyenne spatiale fontionne avec une grille curvilineaire et poids soient en metres
lonmod=self.model.getLongitude()
latmod=self.model.getLatitude()
# lon et lat doivent etre 2D pour que meshweigths calcule des poids en m2
if lonmod.rank()==1:
lonmod,latmod=numpy.meshgrid(lonmod,latmod)
wtsmod=meshweights(lonmod, latmod, proj=True)
# la matrice de poids doit avoir le meme type que la variable moyennee (MV dans notre cas)
wtsmod = MV2.masked_array(wtsmod, MV2.getmask(self.model[i, :, :]), axes=self.model[i, :, :].getAxisList())
self.model.spa_mean.append(cdutil.averager(self.model[i, :, :], axis='yx', weights=wtsmod))
lonobs=self.obs.getLongitude()
latobs=self.obs.getLatitude()
if lonobs.rank()==1:
lonobs,latobs=numpy.meshgrid(lonobs,latobs)
wtsobs=meshweights(lonobs, latobs, proj=True)
wtsobs = MV2.masked_array(wtsobs, MV2.getmask(self.obs[i, :, :]), axes=self.obs[i, :, :].getAxisList())
self.obs.spa_mean.append(cdutil.averager(self.obs[i, :, :], axis='yx', weights=wtsobs))
#self.model.spa_mean.append(cdutil.averager(self.model[i, :, :],axis='yx'))
#self.obs.spa_mean.append(cdutil.averager(self.obs[i, :, :],axis='yx'))
#fin modif J.Gatti
# Transformation en variable cdms2
self.model.spa_mean = cdms2.createVariable(self.model.spa_mean,typecode='f',id='model_spa_mean', attributes=dict(units=self.model.units))
self.obs.spa_mean = cdms2.createVariable(self.obs.spa_mean,typecode='f',id='obs_spa_mean', attributes=dict(units=self.obs.units))
# Ajout de l'axe des temps correspondant a self...
self.model.spa_mean.setAxis(0, tps)
self.obs.spa_mean.setAxis(0, tps)
def testMaskedArray(self):
xmarray = MV2.masked_array(self.u_file, mask=self.u_file > .01)
self.assertEqual(len(xmarray.getAxisList()),
len(self.u_file.getAxisList()))
self.assertTrue(MV2.allequal(xmarray.mask, self.u_file > .01))
x10=uf**3
x13 = MV2.add.reduce(uf)
x14 = MV2.add.reduce(ud)
x15 = x9.astype(numpy.float32)
if not x15.dtype.char==numpy.sctype2char(numpy.float32): markError('astype error')
## arrayrange(start, stop=None, step=1, typecode=None, axis=None, attributes=None, id=None)
## Just like range() except it returns a variable whose type can be specfied
## by the keyword argument typecode. The axis of the result variable may be specified.
xarange = MV2.arange(16., axis=ulat)
## masked_array(a, mask=None, fill_value=None, axes=None, attributes=None, id=None)
## masked_array(a, mask=None) =
## array(a, mask=mask, copy=0, fill_value=fill_value)
## Use fill_value(a) if None.
xmarray = MV2.masked_array(ud)
## masked_object(data, value, copy=1, savespace=0)
## Create array masked where exactly data equal to value
## masked_values(data, value, rtol=1.0000000000000001e-05, atol=1e-08, copy=1, savespace=0, axes=None,
## attributes=None, id=None)
## masked_values(data, value, rtol=1.e-5, atol=1.e-8)
## Create a masked array; mask is None if possible.
## May share data values with original array, but not recommended.
## Masked where abs(data-value)<= atol + rtol * abs(value)
## ones(shape, typecode='l', savespace=0, axes=None, attributes=None, id=None)
## ones(n, typecode=Int, savespace=0, axes=None, attributes=None, id=None) =
## an array of all ones of the given length or shape.
xones = MV2.ones(uf.shape, numpy.float32, axes=uf.getAxisList(), attributes=uf.attributes, id=uf.id)
pft_13.long_name = 'Vegetation types'
pft_13.units = '-'
pft13_axislist_pft = pft_13.getAxisList(('veget', 'lat', 'lon'))
timax_slide = cdms2.createAxis(np.asarray([2010], np.float32))
timax_slide.designateTime(calendar=cdtime.MixedCalendar)
timax_slide.id = 'time_counter'
timax_slide.units = 'years since 0-1-1'
#********************************************************************************************************
#********************************************************************************************************
#Get the LUH masking
#mask_file = cdms2.open('esa_mask.nc')
#esa_mask = mask_file('Mask_only',latitude=latrange, longitude=lonrange)
luh_mask = MV2.getmask(primf[0, :, :])
print 'luh_mask', luh_mask.shape
icwtr = MV2.masked_array(icwtr, mask=luh_mask)
#Total land frac in ORCmap (Sum of all land units in ORCmap is 1)
orc_pft = MV2.masked_array(pft)
for n1 in range(0, 15):
orc_pft[n1, :, :] = MV2.masked_array(orc_pft[n1, :, :], mask=luh_mask)
#print n1
lndf_esa = MV2.minimum(MV2.sum(orc_pft, axis=0), 1)
lndf_esa.id = 'lndfrac_esa'
lndf_esa.long_name = 'Sum of all ORCmap PFTs'
#Total land frac in Hurtt data set (sum of all land units in LUH is one after including icwtr)
lndf_hurt = primf[nyears - 1, :, :] + secdf[nyears - 1, :, :] + primn[
nyears -
1, :, :] + secdn[nyears - 1, :, :] + c3ann[nyears - 1, :, :] + c4ann[
nyears -
1, :, :] + c3per[nyears - 1, :, :] + c4per[nyears - 1, :, :] + c3nfx[
# Adapted for numpy/ma/cdms2 by convertcdms.py
import cdms2, cdutil, numpy.ma, MV2, os, sys
cdms2.setAutoBounds("on")
# centroid test
a = MV2.masked_array(MV2.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0])
bounds = numpy.ma.array(
[
[0, 31],
[31, 59],
[59, 90],
[90, 120],
[120, 151],
[151, 181],
[181, 212],
[212, 243],
[243, 273],
[273, 304],
[304, 334],
[334, 365],
]
)
ax = a.getAxis(0)
ax.setBounds(bounds)
# print cdutil.times.centroid(a,[-10,30])
print "Centroid Normal:", cdutil.times.centroid(a, [0, 365])
print "Centroid Cyclic:", cdutil.times.cyclicalcentroid(a, [0, 365])
f = cdms2.open(os.path.join(cdms2.__path__[0], "..", "..", "..", "..", "sample_data", "tas_mo.nc"))
