def correlation(self, v, dim, region=None):
"""Compute the correlation is the specified dimension.
"""
self, v = align_latlon(self, v)
dims = []
if dim == 'time': dims = ['time']
if dim == 'space': dims = [self.lat_name, self.lon_name]
sds = self.ds if region is None else ilamb_regions.maskedDataset(
region, self)
vds = v.ds if region is None else ilamb_regions.maskedDataset(
region, v)
r = xr.corr(sds[self.varname], vds[v.varname], dim=dims)
dims = ["'%s'" % d for d in dims]
attrs = {}
attrs['ilamb'] = "correlation(%s,%s,dim=[%s]); " % (
self.varname, v.varname, ",".join(dims))
r.attrs = attrs
tm = self.ds['time_measure'] if ('time_measure' in self.ds
and 'time' in r.dims) else None
cm = self.ds['cell_measure'] if (
'cell_measure' in self.ds and
(self.lat_name in r.dims and self.lon_name in r.dims)) else None
r = Variable(da=r,
varname="corr_%s_%s" % (self.varname, v.varname),
cell_measure=cm,
time_measure=tm)
r.setAttr("units", "1")
if r.ds[r.varname].size == 1: r = float(r.ds[r.varname])
return r
def annual_cycle_correlation(sim, ref, window: int = 15):
"""Annual cycle correlation.
Pearson correlation coefficient between the smooth day-of-year averaged annual cycles of the simulation and
the reference. In the smooth day-of-year averaged annual cycles, each day-of-year is averaged over all years
and over a window of days around that day.
Parameters
----------
sim : xr.DataArray
data from the simulation (a time-series for each grid-point)
ref : xr.DataArray
data from the reference (observations) (a time-series for each grid-point)
window: int
Size of window around each day of year around which to take the mean.
E.g. If window=31, Jan 1st is averaged over from December 17th to January 16th.
Returns
-------
xr.DataArray,
Annual cycle correlation between the simulation and the reference
"""
# group by day-of-year and window around each doy
grouper_test = sdba.base.Grouper("time.dayofyear", window=window)
# for each day, mean over X day window and over all years to create a smooth avg annual cycle
sim_annual_cycle = grouper_test.apply("mean", sim)
ref_annual_cycle = grouper_test.apply("mean", ref)
out = xr.corr(ref_annual_cycle, sim_annual_cycle, dim="dayofyear")
out.attrs.update(sim.attrs)
out.attrs["long_name"] = "Correlation of the annual cycle"
return out
def get_cor_rmsd_std(mme, obs):
std = mme.std(dim='time')
corre = xr.corr(obs, mme, dim='time')
rmsd = xr.apply_ufunc(crmsd_func,
obs,
mme,
input_core_dims=[['time'], ['time']],
vectorize=True)
return corre, rmsd, std
def test_corr(da_a, da_b, dim):
if dim is not None:
def np_corr_ind(ts1, ts2, a, x):
# Ensure the ts are aligned and missing values ignored
ts1, ts2 = broadcast(ts1, ts2)
valid_values = ts1.notnull() & ts2.notnull()
ts1 = ts1.where(valid_values)
ts2 = ts2.where(valid_values)
return np.ma.corrcoef(
np.ma.masked_invalid(ts1.sel(a=a, x=x).data.flatten()),
np.ma.masked_invalid(ts2.sel(a=a, x=x).data.flatten()),
)[0, 1]
expected = np.zeros((3, 4))
for a in [0, 1, 2]:
for x in [0, 1, 2, 3]:
expected[a, x] = np_corr_ind(da_a, da_b, a=a, x=x)
actual = xr.corr(da_a, da_b, dim)
assert_allclose(actual, expected)
else:
def np_corr(ts1, ts2):
# Ensure the ts are aligned and missing values ignored
ts1, ts2 = broadcast(ts1, ts2)
valid_values = ts1.notnull() & ts2.notnull()
ts1 = ts1.where(valid_values)
ts2 = ts2.where(valid_values)
return np.ma.corrcoef(
np.ma.masked_invalid(ts1.data.flatten()),
np.ma.masked_invalid(ts2.data.flatten()),
)[0, 1]
expected = np_corr(da_a, da_b)
actual = xr.corr(da_a, da_b, dim)
assert_allclose(actual, expected)
def test_covcorr_consistency(da_a, da_b, dim):
# Testing that xr.corr and xr.cov are consistent with each other
# 1. Broadcast the two arrays
da_a, da_b = broadcast(da_a, da_b)
# 2. Ignore the nans
valid_values = da_a.notnull() & da_b.notnull()
da_a = da_a.where(valid_values)
da_b = da_b.where(valid_values)
expected = xr.cov(da_a, da_b, dim=dim,
ddof=0) / (da_a.std(dim=dim) * da_b.std(dim=dim))
actual = xr.corr(da_a, da_b, dim=dim)
assert_allclose(actual, expected)
def calcSkill(model,verif,var_list):
"""
Calculates correlation as a function of lead time
for given list of variables using verif and model.
"""
# Match verif and hindcast ics
verif_match=verif.sel(ic=model['ic'])
# Calculate correlation for specificed regions
corr=[]
for v in var_list:
corr.append((xr.corr(model[v],verif_match[v],
dim='ic')).to_dataset(name=v))
corr_regions=xr.merge(corr)
return corr_regions
def boot_corr_ci(a1, a2, conf, nboots=1000):
""" Output the conf% confidence interval on correlation between
two 1 dimensional arrays by bootstrapping with replacement
Input:
a1 = first array
a2 = second array
nboots = the number of bootstrap samples used to generate the ci
conf = the confidence interval you want e.g., 95 for 95% ci
Output:
minci = the minimum range of the confidence interval
maxci = the maximum range of the confidence interval
This assumes a two sided test.
"""
ptilemin = (100. - conf) / 2.
ptilemax = conf + (100 - conf) / 2.
if (a1.size != a2.size):
print("The two arrays must have the same size")
sys.exit()
samplesize = a1.size
ranu = np.random.uniform(0, samplesize, nboots * samplesize)
ranu = np.floor(ranu).astype(int)
bootdat = np.zeros([samplesize, nboots])
bootdat1 = np.array(a1[ranu])
bootdat2 = np.array(a2[ranu])
bootdat1 = bootdat1.reshape([samplesize, nboots])
bootdat2 = bootdat2.reshape([samplesize, nboots])
bootcor = xr.corr(xr.DataArray(bootdat1),
xr.DataArray(bootdat2),
dim='dim_0')
minci = np.percentile(bootcor, ptilemin)
maxci = np.percentile(bootcor, ptilemax)
return minci, maxci
def boot_corr_multimem(darrays, nboots, nmems, seed=None):
""" Generate nboots bootstrap samples, with nmems members for each sample, from two darrays of the same coords.
Calculate correlation coefficient of the two variables across the nmems members for each sample.
Input: darrays = list of xarray data arrays with the sampling being performed on the first dimension
nboots = the number of bootstrap samples
nmems = the number of members in each bootstrap sample
Output: bootdat = an xarray data array containing the bootstrap samples
with dimensions nboots
Option: a seed if you want to specify the seed for the random number generator
"""
dims = darrays[0].dims
bootcoords = [("iboot", np.arange(0, nboots, 1))]
# generate random numbers for bootstrapping
if (seed):
np.random.seed(seed)
nmemin = darrays[0][dims[0]].size
ranu = np.random.uniform(0, nmemin, nboots * nmems)
ranu = np.floor(ranu).astype(int)
## select ensemble members and reshape into long time series for each bootstrap sample
bootdat_var1 = np.array(darrays[0][ranu]).reshape(nboots, -1)
bootdat_var2 = np.array(darrays[1][ranu]).reshape(nboots, -1)
## calculate correlation for each bootstrap
bootdat_corr = xr.corr(xr.DataArray(bootdat_var1),
xr.DataArray(bootdat_var2),
dim="dim_1")
bootdat = xr.DataArray(bootdat_corr, coords=bootcoords)
return bootdat
prediction_val.values,
linestyle='--',
color='red')
ax1.plot(
da_x_original.time.values,
da_x_original.sel(variable='genesis_potential_index__gpi__for_tc').values,
color='green',
linestyle='--')
ax.legend(['Obs.', 'MLP_train', 'MLP_validation'])
ax1.legend(['GPI'])
ax.set_ylabel('Number of storms')
ax1.set_ylabel('GPI')
plt.title('Storms: Neural net. vs GPI')
plt.show()
xr.corr(prediction_val, da_y, dim='time')
xr.corr(da_x_original.sel(variable='genesis_potential_index__gpi__for_tc'),
da_y,
dim='time')
error_MLP_train = prediction_train - da_y
# Interpreting
import numpy as np
da_x_test = da_x_scaled.copy(data=np.zeros(da_x_scaled.shape) + .5)
da_x_test.values[:, -2] = np.linspace(0, 1, da_x_test.shape[0])
prediction_test = model.predict(da_x_test.values)
da_x_test = da_x_test.copy(data=scaler_x.inverse_transform(da_x_test.values))
plt.scatter(x=da_x_test.values[:, -2],
y=scaler_y.inverse_transform(prediction_test))
plt.show()
da_rain = da_rain.sel(latitude=slice(15, -40))
da = da.astype('float32')
da_rain = da_rain.astype('float32')
da_rain = da_rain.sortby('longitude')
da_rain = da_rain.sortby('latitude')
da_rain = da_rain.sel(latitude=da.latitude,
longitude=da.longitude,
method='nearest')
da_rain = da_rain.assign_coords(latitude=da.latitude)
da_rain = da_rain.assign_coords(longitude=da.longitude)
da_rain = da_rain.sel(time=da.time)
da_rain = da_rain.resample(time='2D').sum()
da = da.resample(time='2D').sum()
season_mask = [(pd.Timestamp(x).month % 12 + 3) // 3 for x in da.time.values]
season_mask_rain = [(pd.Timestamp(x).month % 12 + 3) // 3
for x in da_rain.time.values]
da['season_mask'] = ('time'), season_mask
da_rain['season_mask'] = ('time'), season_mask_rain
da = da.where(da.season_mask == season, drop=True)
da_rain = da_rain.where(da_rain.season_mask == season, drop=True)
da = da.load()
da = np.log(da)
da_rain = da_rain.load()
corr = xr.corr(da, da_rain, dim='time')
# da.to_netcdf(FTLEpath + f'Downsampled_ftle_{season}.nc')
# da_rain.to_netcdf(FTLEpath + f'Downsampled_{variable_dict[variable]}_{season}.nc')
corr.to_netcdf(FTLEpath + f'corr_{variable_dict[variable]}_{season}.nc')
gpcp_precip = xr.open_dataset(
'/disco/share/mp586/CSSP-postdoc/data/gpcp_daily_merge_noleap_JRA_55_grid_pentadsnoclim.nc'
)
## full precip fields
r1 = np.empty(len(model_list))
for i in range(len(model_list)):
model = model_list[i]
precip = xr.open_dataset('/disco/share/mp586/CSSP-postdoc/data/' + model +
'_pr_JRA_55_grid_pentadclim.nc')
gpcp_p = xr.DataArray(
np.asarray(gpcp_precip.precip),
coords=[precip.time, gpcp_precip.lat, gpcp_precip.lon],
dims=['time', 'lat', 'lon'])
r1[i] = xr.corr(gpcp_p, precip.pr)
print(model + ' = ' + str(r1[i]))
## precip fields in selected areas
r2 = np.empty(len(model_list))
for i in range(len(model_list)):
model = model_list[i]
precip = xr.open_dataset('/disco/share/mp586/CSSP-postdoc/data/' + model +
'_pr_JRA_55_grid_pentadclim.nc')
gpcp_p = xr.DataArray(
np.asarray(gpcp_precip.precip),
coords=[precip.time, gpcp_precip.lat, gpcp_precip.lon],
dims=['time', 'lat', 'lon'])
r2[i] = xr.corr(
gpcp_p.where(landmask_time == 0.).sel(lon=slice(90., 150.),
lat=slice(-40., 40.)),
def test_corr_only_dataarray():
with pytest.raises(TypeError, match="Only xr.DataArray is supported"):
xr.corr(xr.Dataset(), xr.Dataset())
def pearson_correlation(data1, data2):
# input data must be xarray.Datasets
pc = xr.corr(data1, data2).values.item()
return pc
# selecting winter season for index data
index_winter = index_crop.sel(time=index_crop['time.season'] == 'DJF')
'''
# Compute the Pearson correlation coefficient between
# two DataArray objects along a shared dimension
'''
# correlacao = {'Hs': xr.corr(dwave.swh.round(3),
# index_crop.round(3), dim='time'),
# 'Tp': xr.corr(dwave.mwp.round(3),
# index_crop.round(3), dim='time'),
# 'Wave Direction': xr.corr(dwave.mwd.round(3),
# index_crop.round(3), dim='time')}
correlacao = xr.merge([
xr.corr(dwave.swh.round(3), index_crop.round(3),
dim='time').to_dataset(name='Hs'),
xr.corr(dwave.mwp.round(3), index_crop.round(3),
dim='time').to_dataset(name='Tp'),
xr.corr(dwave.mwd.round(3), index_crop.round(3),
dim='time').to_dataset(name='Mwd')
])
# saving correlation matrix as file
correlacao.to_netcdf(path=(finalpath + 'map_corr2_' + tele + '.nc'))
# plotting figures
# limites = [-104, 40, 20, 85]
# #clevs = np.linspace(-1, 1, 10)
# proj = ccrs.LambertConformal(central_longitude=-40,
datetime_indices = {
'YEAR': ppcs.index.year,
'MONTH': ppcs.index.month,
'DAY': np.ones(len(ppcs), dtype=int)
}
ppcs.index = pd.to_datetime(datetime_indices)
ppcs.index.name = 'time'
# excluindo os 10 primeiros anos para obter o numero certo de climatologias
ppcs = ppcs[slice(hs.isel(time=0).time.values,
hs.isel(time=-1).time.values)].to_xarray()
ppcs = ppcs.expand_dims({'latitude': hs.latitude, 'longitude': hs.longitude})
hs_ppcs = xr.merge([hs, ppcs])
correlacao = xr.corr(hs_ppcs.hs, hs_ppcs.pseudo_pcs,
dim='time').to_dataset(name='Hs')
plot_correlacao(correlacao, 'Hs', 'AO', 0.19)
# fazendo alguns testes
onda_media_climatologica = hs_ppcs.hs.mean(dim='time')
onda_media_indice_negativo = hs_ppcs.where(hs_ppcs.pseudo_pcs < 0,
drop=True).hs.mean(dim='time')
anomalia_indice_negativo = (onda_media_indice_negativo -
onda_media_climatologica).to_dataset(name='Hs')
plot_correlacao(anomalia_indice_negativo,
'Hs',
'AO',
0.5,
clevs=np.linspace(-0.3, 0.3, 21))
onda_media_indice_extremo_negativo = hs_ppcs.where(
# significant['Hs'].plot.contourf(colors='none',
# hatches = ['///'],
# transform=ccrs.PlateCarree(),
# add_colorbar=False)
# if tempo == 'presente':
# plt.title('Correlation ' + modelo + ' Hs/AO index - 1980 : 2009')
# elif tempo == 'futuro':
# plt.title('Correlation ' + modelo + ' Hs/AO index - 2070 : 2100')
# selecionando agora só o periodo de inverno dos dois datasets
hs_deseason_ppcs_winter = hs_deseason_ppcs.sel(
time=hs_deseason_ppcs['time.season'] == 'DJF')
corr_deseason_winter = xr.corr(hs_deseason_ppcs_winter[parametro],
hs_deseason_ppcs_winter.indice,
dim='time').to_dataset(name=parametro)
siglev = n30_80
fig, ax = faz_mapa_lambert()
cd = corr_deseason_winter[parametro].plot(levels=clevs,
cmap=colormap,
transform=ccrs.PlateCarree(),
add_colorbar=False)
fig.colorbar(cd, orientation='horizontal', pad=0.03, shrink=0.8)
significant = corr_deseason_winter.where(abs(corr_deseason_winter) > siglev)
significant[parametro].plot.contourf(colors='none',
hatches=['///'],
transform=ccrs.PlateCarree(),
add_colorbar=False)
def boot_corr_signif(a1, a2, conf, dim="Model", nboots=1000, seed=None):
""" Output significance values for the correlation between a 1 dimensional array a1
and a multi-dimensional array a2
Input:
a1 = first array
a2 = second array
conf = the confidence interval you want e.g., 95 for 95% ci
dim = the dimension over which to perform eht correlation
Output:
signifdat = an array of dimensions a2 minus dim that contains
1's for grid points where the correlation is significant and nan's otherwise
This assumes a two sided test.
"""
samplesize = a1[dim].size
ptilemin = (100. - conf) / 2.
ptilemax = conf + (100 - conf) / 2.
# set up the dimensions and coordinates
dims = a2.dims
signifcoords = []
dimboot = [samplesize * nboots]
dimboot2d = [samplesize, nboots]
dimout = []
for icoord in range(1, len(dims)):
signifcoords.append((dims[icoord], a2[dims[icoord]]))
dimboot.append(a2[dims[icoord]].size)
dimboot2d.append(a2[dims[icoord]].size)
dimout.append(a2[dims[icoord]].size)
if (a1[dim].size != a2[dim].size):
print("The two arrays must have the same size")
sys.exit()
if (seed):
np.random.seed(seed)
ranu = np.random.uniform(0, samplesize, nboots * samplesize)
ranu = np.floor(ranu).astype(int)
bootdat1 = np.array(a1[ranu])
bootdat2 = np.array(a2[ranu])
bootdat1 = bootdat1.reshape([samplesize, nboots])
bootdat2 = bootdat2.reshape(dimboot2d)
bootcor = xr.corr(xr.DataArray(bootdat1),
xr.DataArray(bootdat2),
dim="dim_0")
minci = np.percentile(bootcor, ptilemin, axis=0)
maxci = np.percentile(bootcor, ptilemax, axis=0)
signifdat = np.zeros(dimout)
signifdat = np.where(np.logical_or(minci > 0, maxci < 0), 1, 0)
signifdat = xr.DataArray(signifdat, coords=signifcoords)
return signifdat
plt.tight_layout()
plt.savefig('figs/Figure4.png',dpi=300)
plt.savefig('figs/vector/Figure4.eps')
plt.savefig('figs/vector/Figure4.pdf')
plt.show()
try:
plt.savefig('figs/Figure4.jpeg',dpi=300)
except:
pass
plt.show()
# Check correlation between new prod and sst
# %%
ev=[ep_dates,cp_dates,nina_dates,info.index,neutral]
for e in ev:
sst_corr=sst.sel(time=e,method='nearest').sel(time=slice(np.datetime64('1997-09-01'),np.datetime64('2020-01-01')))#.mean(dim='time')-sst.sel(time=all_dates,method='nearest').mean(dim='time')
avg_npp_corr=avg_npp.sel(time=e,method='nearest').sel(lat=slice(-15,15))#.mean(dim='time')-avg_npp.sel(time=all_dates,method='nearest').mean(dim='time')).sel(lat=slice(-15,15))
startday=np.datetime64('2000-01-01')
endday=np.datetime64('2020-01-01')
sst_corr=sst_corr.sel(time=slice(startday,endday))
avg_npp_corr=avg_npp_corr.sel(time=slice(startday,endday))
c=xr.corr(sst_corr,avg_npp_corr,dim='time').mean().values
print(c)
def xr_pearson_r(a, b, dim=None, **kwargs):
return xr.corr(a, b, dim)
actual = apply_ufunc(
pandas_median,
data_array.chunk({"x": 1}),
input_core_dims=[["y"]],
vectorize=True,
dask="parallelized",
output_dtypes=[int],
meta=np.ndarray((0, 0), dtype=np.float),
)
assert_identical(expected, actual)
assert np.float == actual.dtype
with raises_regex(TypeError, "Only xr.DataArray is supported"):
xr.corr(xr.Dataset(), xr.Dataset())
def arrays_w_tuples():
da = xr.DataArray(
np.random.random((3, 21, 4)),
coords={"time": pd.date_range("2000-01-01", freq="1D", periods=21)},
dims=("a", "time", "x"),
)
arrays = [
da.isel(time=range(0, 18)),
da.isel(time=range(2, 20)).rolling(time=3, center=True).mean(),
xr.DataArray([[1, 2], [1, np.nan]], dims=["x", "time"]),
xr.DataArray([[1, 2], [np.nan, np.nan]], dims=["x", "time"]),
]
def xr_spearman_r(a, b, dim=None, **kwargs):
return xr.corr(_rankdata(a, dim), _rankdata(b, dim), dim)
def plot_corr(
dem_da_sub,
ifg_stack_sub,
col_slices=[slice(None)],
nbins=30,
alpha=0.5,
cor_thresh=0.4,
cor_mean_sub=None,
):
# cormean = sario.load("cor_stack_20190101_mean.tif")
# cor_mean_sub = xr.DataArray(
# cormean, coords={"lat": ifg_stack_sub.lat, "lon": ifg_stack_sub.lon}
# )
# ifg_stack_sub[0].data[(cor_mean_sub > cor_thresh)].shape
fig, axes = plt.subplots(4, len(col_slices), squeeze=False)
for idx, col_slice in enumerate(col_slices):
ax = axes[0, idx]
dem_pixels = dem_da_sub[:, col_slice].stack(space=("lat", "lon"))
ifg_pixels = ifg_stack_sub[:, :, col_slice].stack(space=("lat", "lon"))
print("ifg pixels shape:", ifg_pixels.shape)
# Option 1: get the correlation coefficients
trendvals = xr.corr(dem_pixels, ifg_pixels, dim="space")
bins = np.linspace(-1, 1, nbins)
# # Option 2: fit a line, find the slope of the line
# x, y = dem_da_sub.data, ifg_stack_sub.data
# mask_na = np.logical_and(np.isnan(x), np.isnan(y))
# pf = np.polyfit(x[~mask_na], y[~mask_na], 1)
# ifg_mask = (
# cor_mean_sub < cor_thresh
# if (cor_thresh and cor_mean_sub is not None)
# else None
# )
# trendvals = xr.apply_ufunc(
# linear_trend,
# dem_pixels,
# ifg_pixels,
# ifg_mask,
# vectorize=True,
# input_core_dims=[
# ["space"],
# ["space"],
# ["space"],
# ], # reduce along "space", leaving 1 per ifg
# )
# trendvals *= 10 # Go from cm/meter of slope to mm/meter
# bins = nbins
trendvals.plot.hist(ax=ax, bins=bins, alpha=alpha)
# row 2: plot the phase vs elevation plot for one
max_idx = np.abs(trendvals).argmax().item()
breakpoint()
max_rho = trendvals[max_idx].item()
ax = axes[1, idx]
max_idx = np.abs(trendvals).argmax().item()
ax.scatter(dem_pixels, ifg_pixels.isel(ifg_idx=max_idx).data.ravel())
ax.set_title(r"$\rho = $" + "{:.2f}".format(max_rho))
# row 3: plot the DEM
ax = axes[2, idx]
axim = ax.imshow(dem_da_sub[:, col_slice], cmap="gist_earth")
fig.colorbar(axim, ax=ax)
# row 3: plot the ifg with the strongest phase vs elevation trend
ax = axes[3, idx]
axim = ax.imshow(ifg_stack_sub[max_idx, :, col_slice])
ax.set_title(f"ifg_idx = {max_idx}")
fig.colorbar(axim, ax=ax)
def visualize_synoptic_class_on_time_series(da_ts,
path=climate_path,
ax=None,
leg_ncol=1,
add_mm=False,
leg_loc=1,
second_da_ts=None,
twin=None):
import xarray as xr
import matplotlib.pyplot as plt
from aux_gps import replace_time_series_with_its_group
time_dim = list(set(da_ts.dims))[0]
assert xr.infer_freq(da_ts[time_dim]) == 'D'
if ax is None:
fig, ax = plt.subplots()
# also calc the monthly means:
if add_mm:
da_ts_mm = replace_time_series_with_its_group(da_ts, grp='month')
da_ts_mm.plot.line('k-.', ax=ax)
if isinstance(da_ts, xr.Dataset):
styles = ['r-', 'g-', 'b-']
lns = []
for i, st in enumerate(da_ts):
lbl = st.upper()
ln = da_ts[st].plot.line(styles[i],
lw=2,
ax=ax,
zorder=20,
label=lbl)
lns.append(ln)
da_ts = da_ts[st]
else:
# plot daily values:
da_ts.plot.line('k-', lw=2, ax=ax, zorder=20)
if second_da_ts is not None:
# record the corr between second_da_ts and da_ts:
corr_all = xr.corr(da_ts, second_da_ts).item()
corr_oct = xr.corr(
da_ts.sel(time=da_ts['time.month'] == 10),
second_da_ts.sel(time=second_da_ts['time.month'] == 10)).item()
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
textstr = '\n'.join([
'r_all = {:.2f}'.format(corr_all),
'r_just_Oct = {:.2f}'.format(corr_oct)
])
# textstr = 'r_all = {:.2f}'.format(corr)
# place a text box in upper left in axes coords
ax.text(0.05,
0.95,
textstr,
transform=ax.transAxes,
fontsize=14,
verticalalignment='top',
bbox=props)
try:
if second_da_ts.attrs['units'] == da_ts.attrs['units']:
second_da_ts.plot.line('k--', lw=2, ax=ax, marker='o')
else:
twinx = ax.twinx()
second_da_ts.plot.line('k--', lw=2, ax=twinx, marker='o')
if twin is not None:
twinx.set_ylim(*twin)
except KeyError:
twinx = ax.twinx()
second_da_ts.plot.line('k--', lw=2, ax=twinx, marker='o')
if twin is not None:
twinx.set_ylim(*twin)
# ymin, ymax = ax.get_ylim()
df = read_synoptic_classification(path, report=False)
ind = da_ts.to_dataframe().index
da_ts = align_synoptic_class_with_daily_dataset(da_ts)
df = df.loc[ind]
color_dict, edge_dict = choose_color_for_synoptic_classification()
# df['color'] = df['class'].map(color_dict)
# monthly count of synoptics:
month_counts = agg_month_count_syn_class(freq=False)
min_year = da_ts[time_dim].min().dt.year.item()
min_month = da_ts[time_dim].min().dt.month.item()
max_year = da_ts[time_dim].max().dt.year.item()
max_month = da_ts[time_dim].max().dt.month.item()
min_dt = '{}-{}'.format(min_year, min_month)
max_dt = '{}-{}'.format(max_year, max_month)
month_counts = month_counts.sel(time=slice(min_dt, max_dt))
# alternative count since we need not just monthly but by time slice:
grp_dict = df.groupby('class').groups
for key_class, key_ind in grp_dict.items():
color = color_dict[key_class]
edge_color = edge_dict[key_class]
abbr = add_class_abbr(key_class)
# abbr_count = month_counts.sel(syn_cls=key_class).sum().item()
abbr_count = df[df['class'] == key_class].count().values[0]
abbr_label = r'${{{}}}$: {}'.format(abbr, int(abbr_count))
# for ind, row in df.iterrows():
da_ts[da_ts['syn_class'] == key_class].plot.line(
'k-',
lw=0,
ax=ax,
marker='o',
markersize=20,
markerfacecolor=color,
markeredgewidth=2,
markeredgecolor=edge_color,
label=abbr_label)
# ax.vlines(key_ind, 0, 80, colors=color, alpha=0.4, lw=10,
# label=abbr_label)
ax.legend(ncol=leg_ncol, labelspacing=1.5, fontsize=12, loc=leg_loc)
ax.grid()
return ax
umpd['time'] = obs.time
mpd['time'] = obs.time
umpdcor['time'] = obs.time
mpdcor['time'] = obs.time
G_umpd = (umpd.tasLut.std(dim='time') / umpdclim) / (obs.Tair.std(dim='time') /
obsclim)
G_mpd = (mpd.tasLut.std(dim='time') / mpdclim) / (obs.Tair.std(dim='time') /
obsclim)
G_umpdcor = (umpdcor.tasLut.std(dim='time') /
umpdcorclim) / (obs.Tair.std(dim='time') / obsclim)
G_mpdcor = (mpdcor.tasLut.std(dim='time') /
mpdcorclim) / (obs.Tair.std(dim='time') / obsclim)
P_umpd = xr.corr(umpd.tasLut, obs.Tair, dim='time')
P_mpd = xr.corr(mpd.tasLut, obs.Tair, dim='time')
P_umpdcor = xr.corr(umpdcor.tasLut, obs.Tair, dim='time')
P_mpdcor = xr.corr(mpdcor.tasLut, obs.Tair, dim='time')
kge_umpd = (1 - ((P_umpd - 1)**2 + (B_umpd - 1)**2 +
(G_umpd - 1)**2)**(0.5)).rename('kge')
kge_mpd = (1 - ((P_mpd - 1)**2 + (B_mpd - 1)**2 +
(G_mpd - 1)**2)**(0.5)).rename('kge')
kge_umpdcor = (1 - ((P_umpdcor - 1)**2 + (B_umpdcor - 1)**2 +
(G_umpdcor - 1)**2)**(0.5)).rename('kge')
kge_mpdcor = (1 - ((P_mpdcor - 1)**2 + (B_mpdcor - 1)**2 +
(G_mpdcor - 1)**2)**(0.5)).rename('kge')
kge_umpd.to_netcdf('../output/kge_umpd_laf_' + model + '.nc')
kge_umpdcor.to_netcdf('../output/kge_umpd_laf_' + model + '.nc')
lons_boxd=[245,245,280,280]
lats_boxe=[10,14,14,10]
lons_boxe=[150,150,260,260]
lats_boxf=[-14,-10,-10,-14]
lons_boxf=[150,150,240,240]
draw_screen_poly(lats_boxa,lons_boxa,m)
draw_screen_poly(lats_boxb,lons_boxb,m)
draw_screen_poly(lats_boxc,lons_boxc,m)
draw_screen_poly(lats_boxd,lons_boxd,m)
draw_screen_poly(lats_boxe,lons_boxe,m)
draw_screen_poly(lats_boxf,lons_boxf,m)
ws1d=xr.open_dataset('processed/ws_1deg.nc').windspeed
corr=xr.corr(pco2,ws1d,dim='time')
#corr=xr.corr(co2,newprod,dim='time')
fig=plt.figure(figsize=(20,15))
prec_dt=prec_1d.precip.copy(data=detrend(prec_1d.precip.fillna(-999)))
ws1d_dt=ws1d.copy(data=detrend(ws1d.fillna(-999)))
# NEW PRODUCTION AND WINDSPEED
corr=xr.corr(newprod,prec_1d.precip,dim='time')
#pv=get_spatial_trends(newprod,ws1d.sel(time=slice(startday,endday),lat=slice(-15,15))).pval
ax2=fig.add_subplot(8,2,1)
m=plot_basemap()
lo,la=np.meshgrid(newprod.lon.values,newprod.lat.values)
lo1,la1=m(lo,la)
m.contourf(lo1,la1,corr,cmap='bwr',levels=np.arange(-1,1.1,0.25))#,levels=np.arange(-0.001,0.0012,0.0002))
