def project_east_west(self, dataset, experiment, best_fit=True):
X = self.OBS[string.upper(dataset)]
fingerprint = getattr(self, experiment)
westsolver = fingerprint.solvers["west"]
westfac = da.get_orientation(westsolver)
time_plot(westfac * westsolver.projectField(X.reshaped["west"])[:, 0],
label="WEST",
color=get_colors("west"))
eastsolver = fingerprint.solvers["east"]
eastfac = da.get_orientation(eastsolver)
time_plot(eastfac * eastsolver.projectField(X.reshaped["east"])[:, 0],
label="EAST",
color=get_colors("east"))
plt.legend()
plt.ylabel("Projection onto " + fingerprint.experiment +
" fingerprint")
if best_fit:
y = westfac * westsolver.projectField(X.reshaped["west"])[:, 0]
t = cmip5.get_plottable_time(y)
p = np.polyfit(t, y.asma(), 1)
plt.plot(t, np.polyval(p, t), "--", color=get_colors("west"))
y = eastfac * eastsolver.projectField(X.reshaped["east"])[:, 0]
t = cmip5.get_plottable_time(y)
p = np.polyfit(t, y.asma(), 1)
plt.plot(t, np.polyval(p, t), "--", color=get_colors("east"))
def project_piControl_on_solver(self, solver=None):
direc = "/Volumes/Marvel/PICTRL/PDSI_REGRIDDED_SUMMER/"
files = glob.glob(direc + "*")
npiC = len(files)
fname = files[0]
f = cdms.open(fname)
piC_pdsi_regrid = f("pdsi_summer")
piC_pdsi_regrid = MV.masked_where(np.isnan(piC_pdsi_regrid),
piC_pdsi_regrid)
mask = self.solver.eofs()[0].mask
# grid=self.model.getGrid()
nyears = piC_pdsi_regrid.shape[0]
# tax=cdms.createAxis(np.arange(piC_pdsi.shape[0]))
# tax.designateTime()
# tax.units = 'years since 0000-7-1'
# tax.id="time"
# piC_pdsi.setAxis(0,tax)
# piC_pdsi_regrid = piC_pdsi.regrid(grid,regridTool='regrid2')
piC_mask = mask_data(piC_pdsi_regrid, mask)
newmask = np.prod(~piC_mask.mask, axis=0)
if solver is None:
solver = Eof(mask_data(self.mma, newmask == 0), weights='area')
fac = da.get_orientation(solver)
p = solver.projectField(piC_mask)[:, 0] * fac
for i in range(npiC)[1:]:
fname = files[i]
f = cdms.open(fname)
piC_pdsi_regrid = f("pdsi_summer")
piC_pdsi_regrid = MV.masked_where(np.isnan(piC_pdsi_regrid),
piC_pdsi_regrid)
# piC_pdsi = MV.masked_where(np.isnan(piC_pdsi),piC_pdsi)
nyears += piC_pdsi_regrid.shape[0]
# tax=cdms.createAxis(np.arange(piC_pdsi.shape[0]))
# tax.designateTime()
# tax.units = 'years since 0000-7-1'
# tax.id="time"
# piC_pdsi.setAxis(0,tax)
# piC_pdsi_regrid = piC_pdsi.regrid(grid,regridTool='regrid2')
piC_mask = mask_data(piC_pdsi_regrid, mask)
newmask = np.prod(~piC_mask.mask, axis=0)
solver = Eof(mask_data(self.mma, newmask == 0), weights='area')
fac = da.get_orientation(solver)
f.close()
p = MV.concatenate((p, fac * solver.projectField(piC_mask)[:, 0]))
tax = cdms.createAxis(np.arange(nyears))
tax.designateTime()
tax.units = 'years since 0000-7-1'
tax.id = "time"
p.setAxis(0, tax)
return p
def project_piControl_on_solver(self, depth):
if depth in self.noise.keys():
pass
else:
direc = "/Volumes/Marvel/PICTRL/SM" + depth + "_REGRIDDED_SUMMER/"
files = glob.glob(direc + "*")
npiC = len(files)
fname = files[0]
f = cdms.open(fname)
piC_pdsi_regrid = f("sm" + depth + "_summer")
piC_pdsi_regrid = MV.masked_where(np.isnan(piC_pdsi_regrid),
piC_pdsi_regrid)
mask = self.solvers[depth].eofs()[0].mask
grid = self.soilmoisture[depth].getGrid()
nyears = piC_pdsi_regrid.shape[0]
piC_mask = mask_data(piC_pdsi_regrid, mask)
newmask = np.prod(~piC_mask.mask, axis=0)
solver = Eof(mask_data(self.mma[depth], newmask == 0),
weights='area')
fac = da.get_orientation(solver)
p = solver.projectField(piC_mask)[:, 0] * fac
for i in range(npiC)[1:]:
fname = files[i]
f = cdms.open(fname)
piC_pdsi_regrid = f("sm" + depth + "_summer")
piC_pdsi_regrid = MV.masked_where(np.isnan(piC_pdsi_regrid),
piC_pdsi_regrid)
nyears += piC_pdsi_regrid.shape[0]
piC_mask = mask_data(piC_pdsi_regrid, mask)
newmask = np.prod(~piC_mask.mask, axis=0)
solver = Eof(mask_data(self.mma[depth], newmask == 0),
weights='area')
fac = da.get_orientation(solver)
f.close()
p = MV.concatenate(
(p, fac * solver.projectField(piC_mask)[:, 0]))
tax = cdms.createAxis(np.arange(nyears))
tax.designateTime()
tax.units = 'years since 0000-7-1'
tax.id = "time"
p.setAxis(0, tax)
self.noise[depth] = p
def plot_eastwest(X):
if len(X.reshaped["west"].shape) > 2:
data = [
MV.average(cmip5.ensemble2multimodel(X.reshaped["west"]), axis=0),
MV.average(cmip5.ensemble2multimodel(X.reshaped["east"]), axis=0)
]
else:
data = [X.reshaped["west"], X.reshaped["east"]]
solver = MultivariateEof(data)
weofs, eeofs = solver.eofs()
westsolver = weofs[0]
eastsolver = eeofs[0]
fac = da.get_orientation(solver)
plt.subplot(211)
months = [
"JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT",
"NOV", "DEC"
]
plt.plot(fac * westsolver.asma(), label="WEST")
plt.plot(eastsolver.asma() * fac, label="EAST")
plt.xticks(np.arange(12), months)
plt.legend()
plt.subplot(212)
time_plot(fac * solver.pcs()[:, 0], label="WEST")
def proj_aerosols(AA, piControl, H85, start=None, stop=None):
if start is None:
start = cdtime.comptime(1945, 1, 1)
if stop is None:
stop = cdtime.comptime(1984, 12, 31)
data = [H85.reshaped["west"], H85.reshaped["east"]]
nmod, nyears, nmonths = H85.reshaped["west"].shape
P = MV.zeros((nmod, nyears))
msolver = AA.solvers["multi"]
fac = da.get_orientation(msolver)
for i in range(nmod):
to_proj = [H85.reshaped["west"][i], H85.reshaped["east"][i]]
P[i] = msolver.projectField(to_proj)[:, 0] * fac
P.setAxis(0, H85.reshaped["west"].getAxis(0))
timeax = H85.reshaped["west"].getAxis(1)
timeax.id = "time"
P.setAxis(1, timeax)
piCdata = [piControl.reshaped["west"], piControl.reshaped["east"]]
pc = msolver.projectField(piCdata)[:, 0]
Pt = P(time=(start, stop))
nt = len(Pt.getTime())
hslopes = cmip5.get_linear_trends(Pt)
pslopes = da.get_slopes(pc, nt)
def compare_pre_post_1100_noise(X,L=31,latbounds=None):
time1=('1100-1-1','1399-12-31')
c1=cm.Purples(.8)
time2=('1400-1-1','2005-12-31')
if latbounds is not None:
obs=X.obs(latitude=latbounds)
mma = MV.average(X.model(latitude=latbounds),axis=0)
mma = mask_data(mma,obs[0].mask)
solver = Eof(mma)
obs = mask_data(obs,solver.eofs()[0].mask)
truncnoise=solver.projectField(obs)[:,0]*da.get_orientation(solver)
noisy1=truncnoise(time=time1)
noisy2=truncnoise(time=time2)
else:
noisy1=X.noise(time=time1)
noisy2=X.noise(time=time2)
c2=cm.viridis(.1)
plt.subplot(121)
Plotting.Plotting.time_plot(noisy1,c=c1)
Plotting.Plotting.time_plot(noisy2,c=c2)
plt.ylabel("Projection")
plt.title("(a): Noise time series")
plt.subplot(122)
plt.hist(b.bootstrap_slopes(noisy1,L),color=c1,normed=True,alpha=.5)
da.fit_normals_to_data(b.bootstrap_slopes(noisy1,L),c=c1,label="1100-1400")
plt.hist(b.bootstrap_slopes(noisy2,L),color=c2,normed=True,alpha=.5)
da.fit_normals_to_data(b.bootstrap_slopes(noisy2,L),c=c2,label="1400-2005")
plt.legend()
plt.title("(b): 31-year trend distributions")
return np.std(b.bootstrap_slopes(noisy1,L)),np.std(b.bootstrap_slopes(noisy2,L))
def obs_projections(self, experiment, dataset, direction):
fingerprint = getattr(self, experiment)
X = self.OBS[string.upper(dataset)]
solver = fingerprint.solvers[direction]
fac = da.get_orientation(solver)
data = X.reshaped[direction]
return fac * solver.projectField(data)[:, 0]
def model_projections(self, experiment, direction):
fingerprint = getattr(self, experiment)
solver = fingerprint.solvers[direction]
fac = da.get_orientation(solver)
if direction == "multi":
modeldata = [self.h85.reshaped["west"], self.h85.reshaped["east"]]
shaper = self.h85.reshaped["west"]
else:
modeldata = self.h85.reshaped[direction]
shaper = modeldata
P = MV.zeros(shaper.shape[:-1]) + 1.e20
for i in range(shaper.shape[0]):
try:
if direction != "multi":
P[i] = fac * solver.projectField(modeldata[i])[:, 0]
else:
P[i] = fac * solver.projectField([
self.h85.reshaped["west"][i],
self.h85.reshaped["east"][i]
])[:, 0]
except:
continue
Pm = MV.masked_where(np.abs(P) > 1.e10, P)
Pm.setAxisList(shaper.getAxisList()[:-1])
Pm.getAxis(1).id = "time"
return Pm
def soilmoisture_fingerprints(mask,name=None):
depths = ["30cm","2m","pdsi"]
letters = ["(a): ","(b): ","(c): "]
pcs = []
pclabels = []
for depth in depths:
i=depths.index(depth)
plt.subplot(2,2,i+1)
sm = soilmoisture(depth,mask=mask)
solver = Eof(MV.average(sm,axis=0))
fac = da.get_orientation(solver)
if name is None:
m=landplot(fac*solver.eofs()[0],vmin=-.1,vmax=.1)
plt.colorbar(orientation='horizontal',label='EOF loading')
else:
m=plot_regional(fac*solver.eofs()[0],name,vmin=-.1,vmax=.1)
m.drawcountries()
m.drawcoastlines(color='gray')
plt.title(letters[i]+depth+" fingerprint")
pcs+=[fac*solver.pcs()[:,0]]
plt.subplot(2,2,4)
for i in range(3):
time_plot(pcs[i],label=depths[i])
plt.legend(loc=0)
plt.title("(d): Principal Components")
plt.xlabel("Time")
plt.ylabel("Temporal amplitude")
def get_noise(self, solver=None):
if solver is None:
return self.noise
else:
proj = solver.projectField(mask_data(
self.obs, self.eofmask))[:, 0] * da.get_orientation(solver)
noise = proj(time=('1-1-1', '1850-1-1'))
return noise
def get_tree_ring_projection(self, solver=None):
if solver is None:
return self.projection
else:
fac = da.get_orientation(solver)
projection = solver.projectField(mask_data(
self.obs, self.eofmask))[:, 0] * fac
return projection
def noise_projections(fingerprint, piC, direction):
if direction == "multi":
data = [piC.reshaped["west"], piC.reshaped["east"]]
else:
data = piC.reshaped[direction]
solver = fingerprint.solvers[direction]
fac = da.get_orientation(solver)
return fac * solver.projectField(data)[:, 0]
def noise_projections(self, experiment, direction):
fingerprint = getattr(self, experiment)
if direction == "multi":
data = [self.piC.reshaped["west"], self.piC.reshaped["east"]]
else:
data = self.piC.reshaped[direction]
solver = fingerprint.solvers[direction]
fac = da.get_orientation(solver)
return fac * solver.projectField(data)[:, 0]
def fingerprint_agreement_percentages(D,SM=None):
pdsi_eof=da.get_orientation(D.ALL.solver)*D.ALL.solver.eofs()[0]
mask = D.ALL.obs[0].mask
if SM is None:
SM = b.SoilMoisture(mask)
SM30_eof=da.get_orientation(SM.solvers["30cm"] )*SM.solvers["30cm"].eofs()[0]
SM2m_eof=da.get_orientation(SM.solvers["2m"] )*SM.solvers["2m"].eofs()[0]
samesign=cmip5.cdms_clone(np.sign(pdsi_eof)*np.sign(SM30_eof),pdsi_eof)
aw=cdutil.area_weights(pdsi_eof)
test_area=np.ma.sum(MV.absolute(samesign)*aw)
samesign_area=np.ma.sum(MV.masked_where(samesign<1,samesign)*aw)
print "PDSI and 30cm have same sign in "+str(samesign_area/test_area*100)+"% of area"
samesign=cmip5.cdms_clone(np.sign(pdsi_eof)*np.sign(SM2m_eof),pdsi_eof)
samesign_area=np.ma.sum(MV.masked_where(samesign<1,samesign)*aw)
print "PDSI and 2m have same sign in "+str(samesign_area/test_area*100)+"% of area"
samesign=cmip5.cdms_clone(np.sign(SM30_eof)*np.sign(SM2m_eof),pdsi_eof)
samesign_area=np.ma.sum(MV.masked_where(samesign<1,samesign)*aw)
print "30cm and 2m have same sign in "+str(samesign_area/test_area*100)+"% of area"
def project_soilmoisture(self, dataset):
mask = self.mask
self.OBS_PROJECTIONS[dataset] = {}
surf, root = standardize_soilmoisture(dataset)
surfsolver = Eof(mask_data(self.mma["30cm"], mask), weights='area')
surfmask = mask_data(surf, surfsolver.eofs()[0].mask)
surfsolver = Eof(mask_data(self.mma["30cm"], surfmask[-1].mask),
weights='area')
surfanom = surfmask - MV.average(surfmask, axis=0)
self.OBS_PROJECTIONS[dataset]["30cm"] = surfsolver.projectField(
surfanom)[:, 0] * da.get_orientation(surfsolver)
rootsolver = Eof(mask_data(self.mma["2m"], mask), weights='area')
rootmask = mask_data(root, rootsolver.eofs()[0].mask)
rootsolver = Eof(mask_data(self.mma["2m"], rootmask[-1].mask),
weights='area')
rootanom = rootmask - MV.average(rootmask, axis=0)
self.OBS_PROJECTIONS[dataset]["2m"] = rootsolver.projectField(
rootanom)[:, 0] * da.get_orientation(rootsolver)
def project_dai_on_solver(self,start='1970-1-1'):
f = cdms.open("../DROUGHT_ATLAS/OBSERVATIONS/DAI_selfcalibrated.nc")
dai_jja=f("pdsi")
f.close()
dai_jja_mask = mask_data(dai_jja,self.obs[0].mask)(time=(start,'2018-12-31'))
newmask = np.prod(~dai_jja_mask.mask,axis=0)
dai_jja_mask = mask_data(dai_jja_mask,newmask==0)
solver = Eof(mask_data(self.mma,newmask==0))
dai_jja_mask = mask_data(dai_jja_mask,solver.eofs()[0].mask)
fac = da.get_orientation(solver)
return solver.projectField(dai_jja_mask)[:,0]*fac
def model_projections(self):
to_proj = mask_data(self.model,self.solver.eofs()[0].mask)
P=MV.zeros(to_proj.shape[:2])
for i in range(to_proj.shape[0]):
tp = to_proj[i]
mma_mask = mask_data(self.mma,tp[0].mask)
solver = Eof(mma_mask)
fac=da.get_orientation(solver)
P[i] = solver.projectField(tp)[:,0]*fac
P.setAxisList(to_proj.getAxisList()[:2])
self.P=P
def soilmoisture_fingerprints(mask, name=None, fortalk=False):
Fingerprints = {}
depths = ["pdsi", "30cm", "2m"]
if fortalk:
letters = ["", "", ""]
else:
letters = ["(a): ", "(b): ", "(c): "]
pcs = []
pclabels = []
for depth in depths:
i = depths.index(depth)
if fortalk:
plt.figure()
else:
plt.subplot(2, 2, i + 1)
sm = soilmoisture(depth, mask=mask)
solver = Eof(MV.average(sm, axis=0), weights='area')
Fingerprints[depth] = solver
fac = da.get_orientation(solver)
if name is None:
m = b.landplot(fac * solver.eofs()[0], vmin=-.1, vmax=.1)
plt.colorbar(orientation='horizontal', label='EOF loading')
else:
m = b.plot_regional(fac * solver.eofs()[0],
name,
vmin=-.1,
vmax=.1)
m.drawcountries()
m.drawcoastlines(color='gray')
if depth is not "pdsi":
plt.title(letters[i] + depth + " fingerprint")
else:
plt.title(letters[i] + " PDSI fingerprint")
pcs += [fac * solver.pcs()[:, 0]]
if fortalk:
plt.figure()
else:
plt.subplot(2, 2, 4)
for i in range(3):
if depths[i] == "pdsi":
label = "PDSI"
else:
label = depths[i]
time_plot(pcs[i], label=label, lw=3, color=cm.copper(i / 2.))
plt.legend(loc=0)
plt.title("(d): Principal Components")
plt.xlabel("Time")
plt.ylabel("Temporal amplitude")
plt.xlim(1900, 2100)
return Fingerprints
def aerosol_fingerprint(D):
NO,YES=b.aerosol_indirect(D)
aerosol_start = cdtime.comptime(1951,1,1)
aerosol_stop = cdtime.comptime(1975,12,31)
yessolver = b.Eof(YES(time=(aerosol_start,aerosol_stop)))
nosolver = b.Eof(NO(time=(aerosol_start,aerosol_stop)))
yesfac=da.get_orientation(yessolver)
nofac=da.get_orientation(nosolver)
plt.subplot(221)
m=b.landplot(yesfac*yessolver.eofs()[0],vmin=-.1,vmax=.1)
#m.drawcoastlines()
m.fillcontinents(color="gray",zorder=0)
plt.colorbar(orientation="horizontal",label="EOF loading")
plt.title("(a): EOF1 for models with aerosol indirect effect",fontsize=8)
plt.ylim(-60,90)
plt.subplot(222)
m=b.landplot(nofac*nosolver.eofs()[0],vmin=-.1,vmax=.1)
#m.drawcoastlines()
m.fillcontinents(color="gray",zorder=0)
plt.ylim(-60,90)
plt.colorbar(orientation="horizontal",label="EOF loading")
plt.title("(b) EOF1 for models without aerosol indirect effect",fontsize=8)
plt.subplot(223)
Plotting.time_plot(yesfac*yessolver.pcs()[:,0],c="k")
plt.ylabel("Temporal Amplitude")
plt.title("(c) PC1 for models with aerosol indirect effect",fontsize=8)
plt.subplot(224)
Plotting.time_plot(nofac*nosolver.pcs()[:,0],c="k")
plt.ylabel("Temporal Amplitude")
plt.title("(d) PC1 for models without aerosol indirect effect",fontsize=8)
for ax in plt.gcf().axes:
plt.setp(ax.get_xticklabels(),fontsize=6)
plt.setp(ax.get_yticklabels(),fontsize=6)
plt.setp(ax.xaxis.get_label(),fontsize=6)
plt.setp(ax.yaxis.get_label(),fontsize=6)
def project_multi(X, fingerprint, best_fit=True):
multisolver = fingerprint.solvers["multi"]
multifac = da.get_orientation(multisolver)
time_plot(multifac * multisolver.projectField(X)[:, 0],
label="MULTI",
color=get_colors("multi"))
plt.legend()
plt.ylabel("Projection onto " + fingerprint.experiment + " fingerprint")
if best_fit:
y = multifac * multisolver.projectField(X)[:, 0]
t = cmip5.get_plottable_time(y)
p = np.polyfit(t, y.asma(), 1)
plt.plot(t, np.polyval(p, t), "--", color=get_colors("multi"))
def project_cru_on_solver(self, start='1970-1-1', solver=None):
f = cdms.open("../DROUGHT_ATLAS/OBSERVATIONS/CRU_selfcalibrated.nc")
cru_jja = f("pdsi")
f.close()
cru_jja_mask = mask_data(cru_jja,
self.obs[0].mask)(time=(start, '2018-12-31'))
newmask = np.prod(~cru_jja_mask.mask, axis=0)
cru_jja_mask = mask_data(cru_jja_mask, newmask == 0)
if solver is None:
solver = Eof(mask_data(self.mma, newmask == 0), weights='area')
cru_jja_mask = mask_data(cru_jja_mask, solver.eofs()[0].mask)
fac = da.get_orientation(solver)
return solver.projectField(cru_jja_mask)[:, 0] * fac
def regional_DA(OWDA,
region,
start_time=None,
typ='fingerprint',
return_noise=False):
if start_time is None:
start_time = cdtime.comptime(2000, 1, 1)
times = np.arange(10, 76)
modeldata = mask_data(OWDA.model(region), OWDA.obs(region)[0].mask)
if typ == 'fingerprint':
mma = MV.average(modeldata, axis=0)
solver = Eof(mma, weights='area')
to_proj = mask_data(modeldata, solver.eofs()[0].mask)
P = MV.zeros(to_proj.shape[:2])
for i in range(to_proj.shape[0]):
tp = to_proj[i]
mma_mask = mask_data(mma, tp[0].mask)
solver = Eof(mma_mask, weights='area')
fac = da.get_orientation(solver)
P[i] = solver.projectField(tp)[:, 0] * fac
P.setAxisList(to_proj.getAxisList()[:2])
noise = solver.projectField(OWDA.obs(region))[:, 0]
else:
P = cdutil.averager(modeldata, axis='xy')
noise = cdutil.averager(OWDA.obs(region), axis='xy')
if return_noise:
return P, noise
else:
nmod, nyears = P.shape
TOE = MV.zeros((nmod, len(times)))
for i in range(len(times)):
L = times[i]
stop_time = start_time.add(L, cdtime.Years)
modslopes = cmip5.get_linear_trends(P(time=(start_time,
stop_time)))
noiseterm = np.std(bootstrap_slopes(noise, L))
TOE[:, i] = modslopes / noiseterm
TOE.setAxis(0, P.getAxis(0))
return TOE
def model_projections(self, depth):
if depth in self.P.keys():
pass
else:
to_proj = mask_data(self.soilmoisture[depth],
self.solvers[depth].eofs()[0].mask)
P = MV.zeros(to_proj.shape[:2])
for i in range(to_proj.shape[0]):
tp = to_proj[i]
mma_mask = mask_data(self.mma[depth], tp[0].mask)
solver = Eof(mma_mask, weights='area')
tp = mask_data(tp, solver.eofs()[0].mask)
fac = da.get_orientation(solver)
P[i] = solver.projectField(tp)[:, 0] * fac
P.setAxisList(to_proj.getAxisList()[:2])
self.P[depth] = P
self.P[depth].getTime().id = "time"
def model_projections(self, solver=None):
if solver is None:
make_own_solver = True
else:
make_own_solver = False
if solver is None:
to_proj = mask_data(self.model, self.solver.eofs()[0].mask)
else:
to_proj = cmip5.cdms_clone(MV.filled(self.model, fill_value=0),
self.model)
to_proj = mask_data(to_proj, solver.eofs()[0].mask)
P = MV.zeros(to_proj.shape[:2])
for i in range(to_proj.shape[0]):
tp = to_proj[i]
if make_own_solver:
mma_mask = mask_data(self.mma, tp[0].mask)
solver = Eof(mma_mask, weights='area')
fac = da.get_orientation(solver)
P[i] = solver.projectField(tp)[:, 0] * fac
P.setAxisList(to_proj.getAxisList()[:2])
return P
def TOE(OnePct, piControl, H85, start=None):
#Calculate the time of emergence:
data = [H85.reshaped["west"], H85.reshaped["east"]]
nmod, nyears, nmonths = H85.reshaped["west"].shape
P = MV.zeros((nmod, nyears))
msolver = OnePct.solvers["multi"]
fac = da.get_orientation(msolver)
for i in range(nmod):
to_proj = [H85.reshaped["west"][i], H85.reshaped["east"][i]]
P[i] = msolver.projectField(to_proj)[:, 0] * fac
P.setAxis(0, H85.reshaped["west"].getAxis(0))
timeax = H85.reshaped["west"].getAxis(1)
timeax.id = "time"
P.setAxis(1, timeax)
piCdata = [piControl.reshaped["west"], piControl.reshaped["east"]]
pc = msolver.projectField(piCdata)[:, 0]
if start is None:
start = cdtime.comptime(2000, 1, 1)
stop = start.add(1, cdtime.Years)
final_year = cdtime.comptime(2099, 12, 31)
tl = final_year.year - start.year + 1
NOISE = MV.zeros(tl)
SIGNAL = MV.zeros((nmod, tl))
i = 0
while stop.cmp(final_year) < 0:
modelproj = P(time=(start, stop))
L = modelproj.shape[1]
slopes = da.get_slopes(pc, L)
SIGNAL[:, i] = cmip5.get_linear_trends(modelproj)
NOISE[i] = np.ma.std(slopes)
stop = stop.add(1, cdtime.Years)
i += 1
return SIGNAL, NOISE
def obs_projections(fingerprint, X, direction):
solver = fingerprint.solvers[direction]
fac = da.get_orientation(solver)
data = X.reshaped[direction]
return fac * solver.projectField(data)[:, 0]
def __init__(self, name, cutoff='0001-1-1'):
if name.find("2.5") >= 0:
self.name = name.split("2.5")[0]
else:
self.name = name
#if name.find("+")<0:
f = cdms.open("../DROUGHT_ATLAS/PROCESSED/" + name + ".nc")
obs = f("pdsi")
self.obs = MV.masked_where(np.isnan(obs), obs)
self.obs = MV.masked_where(np.abs(self.obs) > 90, self.obs)
self.obs = self.obs(time=(cutoff, '2020-12-31'))
self.obs = mask_data(
self.obs, self.obs.mask[0]
) #Make all the obs have the same mask as the first datapoint
f.close()
fm = cdms.open("../DROUGHT_ATLAS/CMIP5/pdsi." + name +
".hist.rcp85.nc")
self.model = get_rid_of_bad(fm("pdsi"))
self.model = MV.masked_where(np.isnan(self.model), self.model)
fm.close()
# else:
#DEPRECATED: MERGE observations onto common grid using old code
# name1,name2=name.split("+")
# f1 = cdms.open("../DROUGHT_ATLAS/PROCESSED/"+name1+".nc")
# obs1 = f1("pdsi")
# obs1 = MV.masked_where(np.isnan(obs1),obs1)
# obs1 = MV.masked_where(np.abs(obs1)>90,obs1)
# obs1 = obs1(time=(cutoff,'2017-12-31'))
# obs1=mask_data(obs1,obs1.mask[0])
# f1.close()
# fm1 = cdms.open("../DROUGHT_ATLAS/CMIP5/pdsi."+name1+".hist.rcp85.nc")
# model1=get_rid_of_bad(fm1("pdsi"))
# model1=MV.masked_where(np.isnan(model1),model1)
# fm1.close()
# f2 = cdms.open("../DROUGHT_ATLAS/PROCESSED/"+name2+".nc")
# obs2 = f2("pdsi")
# obs2 = MV.masked_where(np.isnan(obs2),obs2)
# obs2 = MV.masked_where(np.abs(obs2)>90,obs2)
# obs2 = obs2(time=(cutoff,'2017-12-12'))
# obs2=mask_data(obs2,obs2.mask[0])
# f2.close()
# fm2 = cdms.open("../DROUGHT_ATLAS/CMIP5/pdsi."+name2+".hist.rcp85.nc")
# model2=get_rid_of_bad(fm2("pdsi"))
# model2=MV.masked_where(np.isnan(model2),model2)
# fm2.close()
# self.obs=merge.merge(obs1,obs2)
# self.model=merge.merge(model1,model2)
mma = MV.average(self.model, axis=0)
self.mma = mask_data(
mma, self.obs[0].mask) #make all the models have the same mask
self.solver = Eof(self.mma, weights='area')
self.eofmask = self.solver.eofs()[0].mask
self.fac = da.get_orientation(self.solver)
self.projection = self.solver.projectField(
mask_data(self.obs, self.eofmask))[:, 0] * self.fac
self.noise = self.projection(time=('1-1-1', '1850-1-1'))
self.P = self.model_projections()
def __init__(self, experiment):
self.experiment = experiment
f = cdms.open("DATA/cmip5.sahel_precip." + experiment + ".nc")
west = f("pr_W")
east = f("pr_CE")
self.data = {}
self.data["west"] = west
self.data["east"] = east
west_a = cdutil.ANNUALCYCLE.departures(west)
east_a = cdutil.ANNUALCYCLE.departures(east)
if experiment != "piControl":
nmod, nmon = west_a.shape
west_rs = west_a.reshape((nmod, nmon / 12, 12))
west_rs.setAxis(0, west.getAxis(0))
tax = cdms.createAxis(west.getTime()[6::12])
tax.id = 'time'
tax.designateTime()
tax.units = west.getTime().units
west_rs.setAxis(1, tax)
westsolver = Eof(MV.average(west_rs, axis=0))
else:
west_a = da.concatenate_this(west_a, compressed=True)
nmon, = west_a.shape
tax = cdms.createAxis(np.arange(west_a.shape[0]))
tax.units = 'months since 0001-1-15'
tax.id = 'time'
tax.designateTime()
taxC = tax.asComponentTime()
test = [x.torel('days since 0001-1-15').value for x in taxC]
tax_days = cdms.createAxis(test)
tax_days.designateTime()
tax_days.id = 'time'
tax_days.units = 'days since 0001-1-15'
west_a.setAxis(0, tax_days)
taxmonthly = cdms.createAxis(west_a.getTime()[6::12])
taxmonthly.units = west_a.getTime().units
taxmonthly.designateTime()
taxmonthly.id = 'time'
west_rs = west_a.reshape((nmon / 12, 12))
west_rs.setAxis(0, taxmonthly)
westsolver = Eof(west_rs)
if experiment != "piControl":
nmod, nmon = east_a.shape
east_rs = east_a.reshape((nmod, nmon / 12, 12))
east_rs.setAxis(0, east.getAxis(0))
east_rs.setAxis(1, tax)
eastsolver = Eof(MV.average(east_rs, axis=0))
else:
east_a = da.concatenate_this(east_a, compressed=True)
east_a.setAxis(0, tax_days)
nmon, = east_a.shape
east_rs = east_a.reshape((nmon / 12, 12))
east_rs.setAxis(0, taxmonthly)
eastsolver = Eof(east_rs)
facwest = da.get_orientation(westsolver)
faceast = da.get_orientation(eastsolver)
self.solvers = {}
self.solvers["east"] = eastsolver
self.solvers["west"] = westsolver
self.reshaped = {}
self.reshaped["east"] = east_rs
self.reshaped["west"] = west_rs
if len(self.reshaped["west"].shape) > 2:
data = [
MV.average(cmip5.ensemble2multimodel(self.reshaped["west"]),
axis=0),
MV.average(cmip5.ensemble2multimodel(self.reshaped["east"]),
axis=0)
]
else:
data = [self.reshaped["west"], self.reshaped["east"]]
msolver = MultivariateEof(data)
self.solvers["multi"] = msolver
self.anomalies = {}
self.anomalies["east"] = east_a
self.anomalies["west"] = west_a
def NatureRevisions_Figure5(D):
aerosol_start = cdtime.comptime(1950,1,1)
aerosol_stop = cdtime.comptime(1975,12,31)
aerosolsolver=Eof(D.ALL.mma(time=(aerosol_start,aerosol_stop)),weights='area')
fac=da.get_orientation(aerosolsolver)
plt.subplot(221)
m=b.landplot(fac*aerosolsolver.eofs()[0],vmin=-.1,vmax=.1)
m.fillcontinents(color="gray",zorder=0)
varex= str(int(100*np.round(aerosolsolver.varianceFraction()[0],2)))
plt.title("(a)")#: 1950-1975 historical fingerprint ("+varex+"% of variance explained)",fontsize=8)
m.drawcoastlines(color='gray')
plt.ylim(-60,90)
plt.colorbar(orientation='horizontal',label='EOF loading')
plt.subplot(222)
Plotting.time_plot(fac*aerosolsolver.pcs()[:,0],color=cm.Greys(.8),lw=1)
plt.title("(b)")#: Associated PC",fontsize=8)
plt.ylabel("Temporal amplitude")
plt.subplot(223)
target_obs,cru_proj,dai_proj=pdsi_time_series(D,aerosol_start,aerosol_stop,aerosols=True)
plt.legend(fontsize=6)
plt.title("(c)")#: Projections on fingerprint",fontsize=8)
plt.subplot(224)
# target_obs = D.ALL.get_tree_ring_projection(solver = aerosolsolver)(time=(aerosol_start,aerosol_stop))
L=len(target_obs)
modslopes,noiseterm = D.ALL.sn_at_time(aerosol_start,L,overlapping=True,solver=aerosolsolver)
ns=np.std(noiseterm)
signal = float(cmip5.get_linear_trends(target_obs))
plt.hist(modslopes/ns,20,normed=True,color=get_dataset_color("h85"),alpha=.5)
lab = str(aerosol_start.year)+"-"+str(aerosol_stop.year)
da.fit_normals_to_data(modslopes/ns,color=get_dataset_color("h85"),lw=1,label="H85")
plt.hist(noiseterm/ns,20,normed=True,color=get_dataset_color("tree_noise"),alpha=.5)
da.fit_normals_to_data(noiseterm/ns,color=get_dataset_color("tree_noise"),lw=1,label="Pre-1850 tree rings")
percentiles=[]
plt.axvline(signal/ns,color=get_dataset_color("tree"),lw=1,label=lab+" GDA trend")
noise_percentile=stats.percentileofscore(noiseterm.tolist(),signal)
h85_percentile=stats.percentileofscore(modslopes.tolist(),signal)
percentiles += [noise_percentile,h85_percentile]
daitrend = cmip5.get_linear_trends(dai_proj)
print "DAI slope is "+str(daitrend)
daisignal = daitrend/ns
plt.axvline(daisignal,color=get_dataset_color("dai"),lw=1,label="Dai")
print "DAI signal/noise is "+str(daisignal)
crutrend = cmip5.get_linear_trends(cru_proj)
print "CRU slope is "+str(crutrend)
crusignal = crutrend/ns
plt.axvline(crusignal,color=get_dataset_color("cru"),lw=1,label="CRU")
print "CRU signal/noise is "+str(crusignal)
plt.legend(loc=0,fontsize=8)
plt.xlabel("S/N")
plt.ylabel("Normalized Frequency")
plt.title("(d)")#: Detection and Attribution Results",fontsize=8)
fig=plt.gcf()
for ax in fig.axes:
plt.setp(ax.xaxis.get_label(),fontsize=6)
plt.setp(ax.yaxis.get_label(),fontsize=6)
plt.setp(ax.get_xticklabels(),fontsize=6)
plt.setp(ax.get_yticklabels(),fontsize=6)
ax=fig.axes[0]
ax.set_title("(a)",fontsize=6)
ax=fig.axes[2]
ax.set_title("(b)",fontsize=6)
ax=fig.axes[3]
ax.set_title("(c)",fontsize=6)
ax=fig.axes[4]
ax.set_title("(d)",fontsize=6)
leg=ax.legend(fontsize=6,ncol=1,loc=2)
leg.set_frame_on(False)
cax=fig.axes[1]
ticklabels=["-0.1","","-0.05","","0","","0.05","","0.1"]
cax.set_xticklabels(ticklabels)
plt.setp(cax.xaxis.get_ticklabels(),fontsize=6)
plt.setp(cax.xaxis.get_label(),fontsize=6)
def NatureRevisions_Figure1(D):
#fig=naturefig(1.5,heightfrac=1)
i=1
letters =["a","b","c","d","e"]
letters2=["f","g","h","i","j"]
for X in ["ANZDA","MADA","MXDA","NADA","OWDA"]:
solver = getattr(D,X).solver
fac=da.get_orientation(solver)
calib_period=('1920-1-1','2005-12-31')
eof1 = fac*solver.eofs()[0]
# plt.subplot(2,5,i)
plt.subplot(5,2,2*i-1)
m=b.plot_regional(eof1,X,vmin=-.15,vmax=.15)
m.drawcoastlines(color='gray')
plt.title("("+letters[i-1]+")",fontsize=6)#: "+X+" fingerprint",fontsize=8)
if letters[i-1]=="a":
print "AAAA"
plt.subplot(5,2,2*i)
#if i==1:
# fig = plt.gcf()
# cb_ax = fig.add_axes([0.1, 0.55, 0.83, 0.02])
# plt.colorbar(label="EOF Loading",cax=cb_ax)
# i+=1
#plt.subplot(2,5,i+5)
cru=getattr(D,X).project_cru_on_solver(start='1901-1-1')
Plotting.time_plot(cru-np.ma.average(cru(time=calib_period)),lw=1,color=get_dataset_color("CRU"),label="CRU")
dai=getattr(D,X).project_dai_on_solver(start='1901-1-1')
Plotting.time_plot(dai-np.ma.average(dai(time=calib_period)),lw=1,color=get_dataset_color("DAI"),label="DAI")
trees = getattr(D,X).projection(time=('1900-1-1','1975-1-1'))
Plotting.time_plot(trees-np.ma.average(trees(time=calib_period)),lw=1,color=get_dataset_color("tree"),label=X)
pc1= fac*solver.pcs()[:,0](time=('1900-1-1','2050-12-31'))
Plotting.time_plot(pc1-np.ma.average(pc1(time=calib_period)),lw=1,color='k',label="PC1")
plt.ylim(-.3,.3)
plt.setp(plt.gca().get_yticklabels(),fontsize=6)
plt.ylabel("Temporal Amplitude",fontsize=6)
if i!=5:
plt.xticks([])
else:
plt.legend(loc=0,ncol=2,fontsize=6)
plt.setp(plt.gca().get_xticklabels(),fontsize=6)
plt.xlabel("Year",fontsize=6)
plt.title("("+letters2[i-1]+")",fontsize=6)#: "+X+" PC1 and projections",fontsize=8)
i+=1
#colorbar kludge
if 1:
fig = plt.gcf()
#fig.subplots_adjust(left=-.15)
#fig.subplots_adjust(bottom=.075)
axes = plt.gcf().axes
ax = axes[0]
#left=fig.subplotpars.left+fig.subplotpars.hspace/2.
left=0.03
height = 0.01
#bottom=fig.subplotpars.bottom-height*1.5
bottom=.05
width=.22
#width=0.5-fig.subplotpars.hspace*1.5
cb_ax = fig.add_axes([left,bottom,width,height])
ax.clear()
eof1= D.ANZDA.solver.eofs()[0]*da.get_orientation(D.ANZDA.solver)
m=b.plot_regional(eof1,"ANZDA",vmin=-.15,vmax=.15,ax=ax,cax=cb_ax,orientation='horizontal')
m.drawcoastlines(color='gray',ax=ax)
#cb_ax.yaxis.set_ticks_position('left')
#cb_ax.yaxis.set_label_position("left")
cb_ax.set_xticklabels(["-0.15","","","0","","","0.15"])
plt.setp(cb_ax.get_xticklabels(),fontsize=6)
plt.setp(cb_ax.xaxis.get_label(),fontsize=6)
fig.axes[0].set_title("(a)",fontsize=6) # for some reason this disappears
return cb_ax