def test_plot_topomap_cnorm():
"""Test colormap normalization."""
if check_version("matplotlib", "3.2.0"):
from matplotlib.colors import TwoSlopeNorm
else:
from matplotlib.colors import DivergingNorm as TwoSlopeNorm
np.random.seed(42)
v = np.random.uniform(low=-1, high=2.5, size=64)
v[:3] = [-1, 0, 2.5]
montage = make_standard_montage("biosemi64")
info = create_info(montage.ch_names, 256, "eeg").set_montage("biosemi64")
cnorm = TwoSlopeNorm(vmin=-1, vcenter=0, vmax=2.5)
# pass only cnorm, no vmin/vmax
plot_topomap(v, info, cnorm=cnorm)
# pass cnorm and vmin
msg = "vmin=-1.* is implicitly defined by cnorm, ignoring vmin=-10.*"
with pytest.warns(RuntimeWarning, match=msg):
plot_topomap(v, info, vmin=-10, cnorm=cnorm)
# pass cnorm and vmax
msg = "vmax=2.5 is implicitly defined by cnorm, ignoring vmax=10.*"
with pytest.warns(RuntimeWarning, match=msg):
plot_topomap(v, info, vmax=10, cnorm=cnorm)
def vapour_anomaly(cubes, lat=45, long=0, time_slice=-1):
for cube in cubes:
if cube.standard_name == 'specific_humidity':
vapour = cube.copy()
mean_vapour = vapour.collapsed('time', iris.analysis.MEAN)
anomaly = vapour - mean_vapour
data = vapour.data
run_length = vapour.shape[0]
x_axis = vapour.coord('longitude').points
y_axis = vapour.coord('level_height').points
plt.contourf(np.arange(0, run_length) * 0.25,
y_axis,
data[:, :, lat, long].T,
bg.N,
cmap=bg,
norm=TwoSlopeNorm(0))
plt.title('Water vapour abundance at equator, long=%s' % x_axis[long])
plt.xlabel('Time [days]')
plt.ylabel('Height [m]')
plt.colorbar(pad=0.1)
plt.show()
def redraw(self, event):
# Only redraw if mouse isn't being held down
galaxy = self.galaxy
systems = galaxy.systems
total = sum([scale.get() for scale in self.scales])
weights = [scale.get() / total for scale in self.scales]
for s in systems:
s.updateScore(weights, galaxy.min_resources, galaxy.max_resources)
galaxy.calcScoreRange()
galaxy.calcMedian()
try:
norm = TwoSlopeNorm(vmin=galaxy.min_score,
vcenter=galaxy.median_score,
vmax=galaxy.max_score)
except: # Use regular Normalize in the case TwoSlopeNorm fails
norm = Normalize(vmin=galaxy.min_score, vmax=galaxy.max_score)
for i in range(len(systems)):
s = systems[i]
normed = norm(s.score)
rgba = self.cmap(normed)
color = self.convert_to_hex(rgba)
self.canvas.itemconfig(self.system_to_circ[i], fill=color)
def sphere_qbo(cubes, level=47, time_slice=-1, long=0, lat=0):
for cube in cubes:
if cube.standard_name == 'x_wind' or cube.standard_name == 'eastward_wind':
x_wind = cube.copy()
longs = np.linspace(-180, 180, 144)
lats = np.linspace(-90, 90, 90)
# x_wind = x_wind[:,:,25:65,:]
ortho = ccrs.Orthographic(central_longitude=long, central_latitude=lat)
fig = plt.figure()
# fig, ax0 = plt.subplots(figsize=(5,5))
# ax0.imshow(image)
fig.patch.set_facecolor('black')
ax1 = plt.axes(projection=ortho)
ax1.set_global()
# ax.gridlines()
ax1.contourf(longs,
lats,
np.roll(x_wind[time_slice, level, :, :].data, 72, axis=1),
transform=ccrs.PlateCarree(),
cmap=redblu,
norm=TwoSlopeNorm(0))
def plot_divergent_heatmap(df, topics, ordered_topics_dict, colormap):
"""Plot a heat map showing the mean topic distribution per outlet"""
topic_words = get_top_n_words(ordered_topics_dict)
num_topics = topics['params']['num_topics']
fig_width = min(ceil(0.6 * num_topics + 6), 20)
fig_height = min(ceil(0.65 * num_topics), 20)
fig = plt.figure(figsize=(fig_width, fig_height))
sns.set_color_codes("pastel")
s = sns.heatmap(df,
cmap=colormap,
norm=TwoSlopeNorm(0),
linewidths=2.0,
square=True)
s.set_xticklabels(s.get_xticklabels(), rotation=-45, ha='left')
s.set_yticklabels(topic_words, rotation=0, fontsize=12)
s.set_xlabel("")
st = fig.suptitle("Start Date: {} End Date: {} Articles: {}".format(
topics['params']['begin_date'], topics['params']['end_date'],
topics['params']['articleCount']),
y=0.92)
fig.savefig(f"fig-{prefix}-divergent-heatmap.png",
bbox_extra_artists=[st],
bbox_inches='tight')
def test_extend_colorbar_customnorm():
# This was a funny error with TwoSlopeNorm, maybe with other norms,
# when extend='both'
fig, (ax0, ax1) = plt.subplots(2, 1)
pcm = ax0.pcolormesh([[0]], norm=TwoSlopeNorm(vcenter=0., vmin=-2, vmax=1))
cb = fig.colorbar(pcm, ax=ax0, extend='both')
np.testing.assert_allclose(cb.ax.get_position().extents,
[0.78375, 0.536364, 0.796147, 0.9], rtol=1e-3)
def colormapAndNorm(p, df, final_df=final_df):
cc_cmap = returnCMAP(p)
cmap = ListedColormap(cc_cmap)
if p != 'pH':
norm = Normalize(vmin=df[p].min(), vmax=df[p].max())
else:
norm = TwoSlopeNorm(vmin=final_df[p].min(),
vcenter=7,
vmax=final_df[p].max())
return cmap, norm
def pcolormesh_dict(vmin, vmax, center=None, cmap=None, norm=None, **kwargs):
ret = {}
ret.update(kwargs)
if center is not None and norm is None:
assert vmin < center < vmax
ret.setdefault("norm", TwoSlopeNorm(center, vmin, vmax))
if cmap is None:
ret.setdefault("cmap", "crownet_bwr")
ret.setdefault("norm", Normalize(vmin, vmax))
ret.setdefault("cmap", t_cmap("Reds", replace_index=(0, 1, 0.0)))
return ret
def visualize_names(self,
name: str,
people: bool = False,
save: str = None):
""" Visualize the most frequent names and their respective averaged sentiment
Parameters
----------
name : str
Name of the movie
people : bool, default = False
Whether to only use names with a first and last name
save : str, default None
The save prefix name
"""
if not self.processed_names:
raise Exception(
"Please preprocess the names from the reviews first through: \n"
"character.preprocess_names_and_reviews('reviews.json', 'names.json')"
)
if name not in self.processed_names.keys():
names = list(self.processed_names.keys())
raise Exception(
f"Please select one of the following names: {names}")
df = self.processed_names[name]
if people:
df = df.loc[df.Nr_Words > 1, :]
plt.figure(figsize=(12, 5))
norm = TwoSlopeNorm(vmin=-1, vcenter=0.0, vmax=1)
colors = [plt.cm.bwr(norm(c)) for c in df.Sentiment.head(15)]
ax = sns.barplot(x='Sentiment',
y='Word',
data=df.head(15),
palette=colors,
edgecolor='black')
plt.tight_layout()
plt.xlabel("Sentiment")
plt.ylabel("")
if save:
plt.savefig(
f"{self.dir_path}images/characters/{save}_characters.png",
dpi=300)
else:
plt.show()
def plot_temp_anomaly(cubes, period=(0, 220), lat=45, level=47):
""" Plot temperature anomaly, temperature minus the local time-averaged temperature
Default latitude is the equator
Arguments: CubeList, latitude, and atmospheric level"""
for cube in cubes:
if cube.standard_name == 'air_potential_temperature':
theta = cube[period[0]:period[1], :, lat, :].copy()
if cube.standard_name == 'air_pressure':
pressure = cube[period[0]:period[1], :, lat, :].copy()
run_length, longitudes = theta.shape[0], theta.shape[2] / 2
for coord in theta.coords():
if coord.long_name == 'Hybrid height':
heights = np.round(theta.coord('Hybrid height').points * 1e-03, 0)
elif coord.long_name == 'level_height':
heights = np.round(theta.coord('level_height').points * 1e-03, 0)
p0 = iris.coords.AuxCoord(100000.0,
long_name='reference_pressure',
units='Pa')
p0.convert_units(pressure.units)
# R and cp in J/kgK for 300K
temperature = theta * ((pressure / p0)**(287.05 / 1005))
temp_time_mean = temperature.collapsed('time', iris.analysis.MEAN)
anomaly = temperature - temp_time_mean
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.arange(period[0], period[1]),
np.roll(anomaly[:, level, :].data, 72, axis=1),
np.arange(-20, 21, 5),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('Temperature Anomaly at Equator, h=%s km' % (heights[level]))
plt.xlabel('Longitude [degrees]')
plt.xticks((-144, -120, -96, -72, -48, -24, 0, 24, 48, 72, 96, 120, 144),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
# plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72), ('180W', '150W',
# '120W', '90W', '60W', '30W', '0', '30E', '60E', '90E', '120E', '150E', '180E'))
plt.ylabel('Time [months]')
cbar = plt.colorbar(pad=0.1)
cbar.set_ticks(np.arange(-20, 21, 5))
cbar.ax.set_title('K')
# plt.savefig('/exports/csce/datastore/geos/users/s1144983/papers/laso/epsfigs/abs_temp_anomaly_%s_new.eps' %(heights[level]), format='eps')
plt.show()
def plot_world_var(gdf_world, var):
vmin = min(gdf_world[var])
vmax = max(gdf_world[var])
if vmin < 0:
norm = TwoSlopeNorm(vmin=vmin, vcenter=0, vmax=vmax)
gdf_world.plot(
column=var,
legend=True,
cmap=sns.color_palette("vlag", as_cmap=True),
norm=norm,
)
else:
gdf_world.plot(
column=var, legend=True, cmap=sns.color_palette("crest", as_cmap=True)
)
plt.savefig(cfg.RESULT_PNG_DIR_PATH + "{}_{}".format(cfg.DATE, var))
def draw_universe(self, galaxy):
self.galaxy = galaxy
systems = galaxy.systems
#make key for colors
self.key = tk.Canvas(self.view, height=15, width=385)
self.key.grid(row=0, column=0, sticky='ne')
self.key.create_text(0, 0, anchor='nw', text="Worst")
self.key.create_text(355, 0, anchor='nw', text="Best")
for s in systems:
for c in s.hyperlanes:
p1 = s.pos
p2 = systems[c].pos
self.canvas.create_line(p1[0], p1[1], p2[0], p2[1])
self.system_to_circ = {}
print(galaxy.min_score, galaxy.max_score, galaxy.avg_score,
galaxy.median_score)
try:
norm = TwoSlopeNorm(vmin=galaxy.min_score,
vcenter=galaxy.median_score,
vmax=galaxy.max_score)
except: # Use regular Normalize in the case TwoSlopeNorm fails
norm = Normalize(vmin=galaxy.min_score, vmax=galaxy.max_score)
for i in range(len(systems)):
s = systems[i]
p = s.pos
normed = norm(s.score)
rgba = self.cmap(normed)
color = self.convert_to_hex(rgba)
circ_id = self.canvas.create_circle(p[0],
p[1],
5,
fill=color,
activewidth=4,
tags=i)
self.system_to_circ[i] = circ_id
enter_callback = lambda event, tag=i: self.system_enter(event, tag)
leave_callback = lambda event, tag=i: self.system_exit(event, tag)
self.canvas.tag_bind(circ_id, "<Enter>", enter_callback)
self.canvas.tag_bind(circ_id, "<Leave>", leave_callback)
self.color_key(False)
def plot_uv(cubes, start=0, end=240, levels=(37, 44, 47, 53)):
for cube in cubes:
if cube.standard_name == 'eastward_wind' or cube.standard_name == 'x_wind':
x_wind = cube[start:end, :, :, :].copy()
if cube.standard_name == 'northward_wind' or cube.standard_name == 'y_wind':
y_wind = cube[start:end, :, :, :].copy()
longitudes, latitudes = x_wind.shape[3] / 2, x_wind.shape[2] / 2
y_wind = y_wind.regrid(x_wind, iris.analysis.Linear())
for coord in x_wind.coords():
if coord.long_name == 'Hybrid height':
heights = np.round(x_wind.coord('Hybrid height').points * 1e-03, 0)
elif coord.long_name == 'level_height':
heights = np.round(x_wind.coord('level_height').points * 1e-03, 0)
zonal_mean_u = x_wind.collapsed('t', iris.analysis.MEAN)
u_prime = x_wind - zonal_mean_u
zonal_mean_v = y_wind.collapsed('t', iris.analysis.MEAN)
v_prime = y_wind - zonal_mean_v
cross_term = u_prime * v_prime
for level in levels:
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.arange(-latitudes, latitudes),
np.roll(cross_term[end - 1, level, :, :].data, 72,
axis=1),
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('$U^{\prime} \cdot V^{\prime}$ [m2 s-2], h=%s km, day=%s' %
(heights[level], end / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E',
'60E', '90E', '120E', '150E', '180E'))
plt.ylabel('Latitude [degrees]')
plt.colorbar(pad=0.1)
plt.show()
def test_extend_colorbar_customnorm():
# This was a funny error with TwoSlopeNorm, maybe with other norms,
# when extend='both'
N = 100
X, Y = np.mgrid[-3:3:complex(0, N), -2:2:complex(0, N)]
Z1 = np.exp(-X**2 - Y**2)
Z2 = np.exp(-(X - 1)**2 - (Y - 1)**2)
Z = (Z1 - Z2) * 2
fig, ax = plt.subplots(2, 1)
pcm = ax[0].pcolormesh(X,
Y,
Z,
norm=TwoSlopeNorm(vcenter=0., vmin=-2, vmax=1),
cmap='RdBu_r')
cb = fig.colorbar(pcm, ax=ax[0], extend='both')
np.testing.assert_allclose(cb.ax.get_position().extents,
[0.78375, 0.536364, 0.796147, 0.9],
rtol=1e-3)
def property_to_color(prop, cmap="viridis", **kwargs):
"""
Convert a scalar array of property values to colors,
given a provided color map (or property name).
Args:
prop (array_like): the scalar array of property values
cmap (str): the color map name or property name
vmin (float): the minimum value of the property color scale
vmax (float): the maximum value of the property color scale
kwargs (dict): optional keyword arguments
Returns:
array_like: the array of color values for the given property
"""
from matplotlib.cm import get_cmap
midpoint = kwargs.get("midpoint",
0.0 if cmap in ("d_norm", "esp") else None)
colormap = get_cmap(
kwargs.get("colormap", DEFAULT_COLORMAPS.get(cmap, cmap)))
norm = None
vmin = kwargs.get("vmin", prop.min())
vmax = kwargs.get("vmax", prop.max())
if midpoint is not None:
try:
from matplotlib.colors import TwoSlopeNorm
except ImportError:
from matplotlib.colors import DivergingNorm as TwoSlopeNorm
assert vmin <= midpoint
assert vmax >= midpoint
norm = TwoSlopeNorm(vmin=vmin, vcenter=midpoint, vmax=vmax)
prop = norm(prop)
return colormap(prop)
else:
import numpy as np
prop = np.clip(prop, vmin, vmax) - vmin
return colormap(prop)
def main(parser):
args = parser.parse_args()
infastx = args.inFastx if args.inFastx else "-"
motifs = args.motifs.split(',')
sortedRecs = sorted(list(pysam.FastxFile(infastx, 'r')),
key=sortFunc(args.sortCluster))
if not len(sortedRecs):
print(f'No records in {infastx}')
return None
colors = OrderedDict([(m, COLORMAP.colors[i])
for i, m in enumerate(motifs)])
raster = motifRaster(sortedRecs, motifs, colors)
patches = [
mpatches.Patch(color=color, label=motif)
for motif, color in list(colors.items())
]
f, ax = plotWaterfall(raster, XLABEL, args.ylabel, labels=patches)
out = args.out if args.out.endswith(
args.format) else '%s.%s' % (args.out, args.format)
plt.tight_layout()
f.savefig(out, dpi=args.dpi, format=args.format)
if args.plotQV:
qvraster = qvRaster(sortedRecs, 'Base QV')
norm = TwoSlopeNorm(CENTERQV, vmin=MINQV, vmax=MAXQV)
f, ax = plotWaterfall(qvraster,
XLABEL,
args.ylabel,
norm=norm,
cmap=QVCOLOR,
colorbar='QV')
name, ext = out.rsplit('.', 1)
f.savefig(f'{name}.QV.{ext}', format=args.format)
print('Done')
return raster
def irrigated_change_by_county(json_file):
from mpl_toolkits.axes_grid1 import make_axes_locatable
import matplotlib
from matplotlib.colors import TwoSlopeNorm
unet = prepare_unet_from_json(json_file, 50)
unet = unet.drop([2002], axis=1)
unet = unet.T.groupby(np.arange(len(unet.T)) // 5).mean()
# unet = unet.T.rolling(5).mean()
u2019 = unet.iloc[-1]
u2000 = unet.iloc[0]
diff = u2019 - u2000
r = '/home/thomas/share/irrigated-training-data-aug21/aux-shapefiles/MontanaCounties_shp/County.shp'
gdf = gpd.read_file(r)
gdf['NAME'] = [n.replace(' ', '_') for n in gdf['NAME']]
diff = diff.loc[gdf['NAME']]
gdf['diff'] = diff.values
fig, ax = plt.subplots(1, 1)
divider = make_axes_locatable(ax)
vmin, vmax, vcenter = gdf['diff'].min(), gdf['diff'].max(), 0
norm = TwoSlopeNorm(vmin=vmin, vcenter=vcenter, vmax=vmax)
cmap = 'coolwarm'
cbar = plt.cm.ScalarMappable(norm=norm, cmap=cmap)
cax = divider.append_axes("left", size="5%", pad=0.1)
gdf.plot(column='diff', ax=ax, cmap='coolwarm')
cbar = fig.colorbar(cbar, ax=ax, cax=cax)
cbar.outline.set_visible(False)
ax.axis('off')
ax.set_title('Change in irrigated area by county, 2000-2019', fontsize=20)
fig.text(0.13,
0.35,
r'$\Delta$ irrigated area (acres)',
ha='center',
rotation='vertical',
fontsize=20)
plt.show()
def gravity_wave_drag(cubes, time=-1, level=47):
for cube in cubes:
if cube.long_name == 'change_over_time_in_air_temperature_due_to_gravity_wave_drag':
drag = cube.copy()
heights = np.round(drag.coord('level_height').points * 1e-03, 0)
run_length = np.arange(0, drag.shape[0])
# longitudes = drag.shape[3]
# latitudes = drag.coord('latitude').points
plt.figure(figsize=(12, 6))
iplt.contour(drag[time, level, :, :],
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
ax = plt.gca()
ax.gridlines(draw_labels=True)
plt.title('Temp change due to gravity wave drag [K], month %s, h=%s km' %
(run_length[time], heights[level]),
y=1.2)
plt.colorbar(pad=0.1)
plt.show()
def plot_hovmoellerx(cubes, radius=7160000, time='days'):
""" Plot Hovmoeller diagrams of zonal wind
Arguments: CubeList, time (can be '6-hours' or 'days')
Outputs: 1) Hovmoeller plot of mean equatorial wind between -10 and 10
lat, axes time vs. height
2) Hovmoeller plot of zonal mean wind at 40 km, axes time vs.
latitude (top view) """
for cube in cubes:
if cube.standard_name == 'eastward_wind' or cube.standard_name == 'x_wind':
x_wind = cube.copy()
x_wind.coord('latitude').coord_system = GeogCS(radius)
x_wind.coord('longitude').coord_system = GeogCS(radius)
run_length, lats, longs = x_wind.shape[0], x_wind.coord(
'latitude'), x_wind.coord('longitude')
for coord in x_wind.coords():
if coord.long_name == 'Hybrid height':
heights = np.round(x_wind.coord('Hybrid height').points * 1e-03, 0)
elif coord.long_name == 'level_height':
heights = np.round(x_wind.coord('level_height').points * 1e-03, 0)
if lats.bounds == None:
x_wind.coord('latitude').guess_bounds()
if longs.bounds == None:
x_wind.coord('longitude').guess_bounds()
dayside, nightside = x_wind.intersection(
longitude=(-90, 89),
latitude=(-10, 10)), x_wind.intersection(longitude=(90, 270),
latitude=(-10, 10))
dayside_full, nightside_full = x_wind.intersection(
longitude=(-90, 89)), x_wind.intersection(longitude=(90, 270))
day_grid, night_grid = iris.analysis.cartography.area_weights(
dayside), iris.analysis.cartography.area_weights(nightside)
dayside_mean = dayside.collapsed(['latitude', 'longitude'],
iris.analysis.MEAN,
weights=day_grid)
nightside_mean = nightside.collapsed(['latitude', 'longitude'],
iris.analysis.MEAN,
weights=night_grid)
dayside_zonal_mean = dayside_full.collapsed('longitude',
iris.analysis.MEAN)
nightside_zonal_mean = nightside_full.collapsed('longitude',
iris.analysis.MEAN)
for cube in (dayside_mean, nightside_mean):
if cube == dayside_mean:
side = 'Dayside'
else:
side = 'Nightside'
plt.contourf(np.arange(0, run_length) * 0.25,
np.array(heights),
cube.data.T,
levels=np.arange(-120, 121, 20),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('%s Mean Zonal Equatorial Wind' % (side))
plt.xlabel('Time [%s]' % (time))
plt.ylabel('Height [km]')
cbar = plt.colorbar(pad=0.1)
cbar.set_ticks(np.arange(-120, 121, 20))
cbar.ax.set_title('m/s')
# plt.savefig('/exports/csce/datastore/geos/users/s1144983/papers/laso/epsfigs/hovmoeller_%s_new.eps' %(side), format='eps')
plt.show()
for cube in (dayside_zonal_mean, nightside_zonal_mean):
if cube == dayside_zonal_mean:
side = 'Dayside'
else:
side = 'Nightside'
plt.contourf(np.arange(0, run_length) * 0.25,
np.arange(-45, 45),
cube[:, 47, :].data.T,
np.arange(-120, 121, 20),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('%s Mean Zonal Wind at 41 km' % (side))
plt.xlabel('Time [%s]' % (time))
plt.ylabel('Latitude')
plt.yticks((-45, 0, 45), ('90S', '0', '90N'))
mbar = plt.colorbar(pad=0.1)
mbar.set_ticks(np.arange(-120, 121, 20))
mbar.ax.set_title('m/s')
# plt.savefig('/exports/csce/datastore/geos/users/s1144983/papers/laso/epsfigs/topview_%s_new.eps' %(side), format='eps')
plt.show()
def wave_acceleration(cubes,
density,
hlevel=47,
lat=45,
long=0,
start=2880,
end=3240,
plot=False):
""" This function plots several things:
1) The high-pass filtered u-prime. We need to filter u-prime because
the standing Rossby waves create an asymmetrical background flow. Taking
the zonal anomaly without filtering out long Rossby waves results in a
zonal anomaly that represents these waves instead of the transient gravity
waves we're looking for. We filter out wavelengths of wave number < 5.1.
2) The time anomaly of the upward wind, w'. We use the time anomaly
instead of zonal anomaly because the asymmetrical dayside/nightside
rising/subsiding air pattern creates the same problem as the standing
Rossby waves do for the zonal wind.
3) The wave momentum flux, calculated by multiplying 1) and 2) and
differentiating in the vertical direction. We plot the latitudinal
cross-section of the zonal mean wave momentum flux together with the change
in zonal mean zonal wind to see if the direction of acceleration matches the
change in direction of the zonal wind. We also plot the longitudinal
cross-section along the equator (not the meridional mean, just a slice) and
overlay the longitudinal cross-section of the zonal wind to show that the
areas of high wave-induced acceleration are collocated with the jet exit region
at the western terminator and the deep convection zone to the west of the
substellar point.
Note: The wave-induced acceleration is calculated ONLY for the resolved,
larger-than-gridbox gravity waves and does not include the acceleration
from parameterised gravity waves.
You must use the six-hourly data with this function.
Paper plot time spans: 2880-3240 and 3340-3680"""
for cube in cubes:
if cube.standard_name == 'eastward_wind':
x_wind = cube[start:end, :, :, :].copy()
if cube.standard_name == 'upward_air_velocity':
z_wind = cube[start:end, :, :, :].copy()
z_wind = z_wind.regrid(x_wind, iris.analysis.Linear())
vertical = [('Hybrid height', x_wind.coord('Hybrid height').points)]
z_wind = z_wind.interpolate(vertical, iris.analysis.Linear())
longitudes = x_wind.shape[3] / 2
latitudes = x_wind.shape[2] / 2
heights = x_wind.coord('Hybrid height').points
heights_km = np.round(x_wind.coord('Hybrid height').points * 1e-03, 0)
""" Filter zonal wind, remove longer wavelengths, calculate u-prime"""
x_data = x_wind.data
u_prime_list = []
for time in range(0, x_wind.shape[0]):
time_list = []
for level in range(0, x_wind.shape[1]):
level_list = []
for latx in range(0, x_wind.shape[2]):
u_fft = sp.fftpack.fft(x_data[time, level, latx, :])
u_psd = np.abs(u_fft)**2
u_freq = sp.fftpack.fftfreq(len(u_psd), 1. / 144)
highpass = u_fft.copy()
highpass[np.abs(u_freq) < 5.1] = 0
u_cleaned = np.real(sp.fftpack.ifft(highpass))
u_bar = np.mean(u_cleaned)
u_prime = u_cleaned - u_bar
level_list.append(u_prime)
time_list.append(level_list)
u_prime_list.append(time_list)
u_prime = np.array(u_prime_list)
print(u_prime.shape)
if plot == True:
zonal_mean = x_wind.collapsed('longitude', iris.analysis.MEAN)
fig, (ax1, ax2) = plt.subplots(1,
2,
figsize=(16, 8),
gridspec_kw={'width_ratios': [4, 1]},
sharey=True)
up = ax1.contourf(np.arange(-longitudes, longitudes),
np.array(heights_km),
np.roll(u_prime[-1, :, lat, :], 72, axis=1),
np.linspace(-35, 35, 70),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
ax1.set_title('$U^{\prime}$ at Equator, t=%s days' % (end / 4))
ax1.set_xlabel('Longitude [degrees]')
ax1.set_xticks((-72, -48, -24, 0, 24, 48, 72),
('180W', '120W', '60W', '0', '60E', '120E', '180E'))
ax1.set_ylabel('Height [km]')
# ax1.annotate('', xy=(0.177, 0.55), xytext=(0.11, 0.55), xycoords='figure fraction', arrowprops=dict(facecolor='black',shrink=0.005),
# horizontalalignment='left', verticalalignment='top')
cbar = plt.colorbar(up, pad=0.05, ax=ax1)
cbar.locator = ticker.AutoLocator()
cbar.update_ticks()
cbar.ax.set_title('m/s')
# plt.figure(figsize=(10, 5))
# plt.contourf(np.arange(-longitudes, longitudes), np.array(heights_km), np.roll(
# u_prime[-1, :, lat, :], 72, axis=1), np.linspace(-35, 35, 70), cmap=brewer_redblu, norm=TwoSlopeNorm(0))
# plt.title('$U^{\prime}$ at Equator, t=%s days' % (end/4))
# plt.xlabel('Longitude [degrees]')
# plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72), ('180W', '150W',
# '120W', '90W', '60W', '30W', '0', '30E', '60E', '90E', '120E', '150E', '180E'))
# plt.ylabel('Height [km]')
# cbar = plt.colorbar(pad=0.1)
# cbar.locator = ticker.AutoLocator()
# cbar.update_ticks()
# cbar.ax.set_title('m/s')
# # plt.savefig(
# # '/exports/csce/datastore/geos/users/s1144983/papers/laso/epsfigs/uprime_%s_ticks.eps' % (end), format='eps')
# plt.show()
# plt.figure(figsize=(2.5, 5))
zmzw = ax2.contour(np.arange(-latitudes, latitudes) * 2,
np.array(heights_km),
zonal_mean[-1, :, :].data,
np.arange(-80, 81, 20),
colors='black',
linewidths=2.0)
ax2.set_title('Zonal Mean Zonal Wind, t=%s days' % (end / 4))
ax2.set_xlabel('Latitude [degrees]')
# ax2.set_ylabel('Height [km]')
ax2.clabel(zmzw, inline=False, colors='k', fmt='%1.1f')
fig.tight_layout()
# fig.suptitle('$U^{\prime}$ at Equator and Zonal Mean Zonal Wind, t=%s days' %(end/4), fontsize=18)
# plt.savefig(
# '/exports/csce/datastore/geos/users/s1144983/papers/laso/epsfigs/uprime_subplots_%s_right.eps' % (end), format='eps')
plt.show()
""" Calculate w-prime"""
z_mean = z_wind.collapsed('t', iris.analysis.MEAN)
z_anomaly = z_wind - z_mean
if plot == True:
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.array(heights_km),
np.roll(z_anomaly[-1, :, lat, :].data, 72, axis=1),
np.linspace(-0.09, 0.09, 20),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('Vertical Wind Anomaly at Equator [m s-1], t = %s days' %
(end / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E',
'60E', '90E', '120E', '150E', '180E'))
plt.ylabel('Height [km]')
plt.colorbar(pad=0.1)
plt.show()
""" Differentiate wrt height"""
array = u_prime * z_anomaly.data
h = np.array([heights])
h = np.repeat(h[:, np.newaxis], (end - start), axis=0)
h = np.reshape(h, ((end - start), 60))
h = np.repeat(h[:, :, np.newaxis], 90, axis=2)
h = np.repeat(h[:, :, :, np.newaxis], 144, axis=3)
print(array.shape, h.shape)
acceleration = array.copy() * density[start:end, :-1, :, :]
acceleration[:, 0,
...] = (array[:, 1, ...] - array[:, 0, ...]) / (h[:, 1, ...] -
h[:, 0, ...])
acceleration[:, -1,
...] = (array[:, -1, ...] -
array[:, -2, ...]) / (h[:, -1, ...] - h[:, -2, ...])
acceleration[:, 1:-1, ...] = (array[:, 2:, ...] - array[:, 0:-2, ...]) / (
h[:, 2:, ...] - h[:, 0:-2, ...])
acceleration = -acceleration
# Negative because Plumb 1977 paper formula has a negative, just so you don't forget this and freak out
""" Plot """
zonal_acc = np.mean(acceleration, axis=3)
net_acc = np.mean(zonal_acc, axis=0)
x_mean = x_wind.collapsed('longitude', iris.analysis.MEAN)
x_avg = x_wind.collapsed('t', iris.analysis.MEAN)
mean_acc = np.mean(acceleration, axis=0)
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.array(heights_km),
np.roll(mean_acc[:, lat, :], 72, axis=1),
np.linspace(-8e-05, 8e-05, 20),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
mbar = plt.colorbar(pad=0.1)
mbar.locator = ticker.AutoLocator()
mbar.update_ticks()
mbar.set_label('$m/s^2$')
contours = plt.contour(np.arange(-longitudes, longitudes),
np.array(heights_km),
np.roll(x_avg[:, lat, :].data, 72, axis=1),
np.arange(-80, 81, 20),
colors='black',
linewidths=0.3)
plt.title('Mean Wave-Induced Acceleration at Equator, t=%s to %s days' %
(start / 4, end / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
plt.ylabel('Height [km]')
plt.clabel(contours, inline=False, colors='k', fmt='%1.1f')
# plt.savefig('/exports/csce/datastore/geos/users/s1144983/papers/laso/epsfigs/jetexit_%s_ticks_by20s.eps' %(end), format='eps')
plt.show()
x_axis = x_wind.coord('latitude').points
y_axis = np.round(x_wind.coord('Hybrid height').points * 1e-03, 0)
plt.figure(figsize=(8, 10))
plt.contourf(x_axis,
y_axis,
net_acc,
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
wbar = plt.colorbar(pad=0.1)
wbar.locator = ticker.AutoLocator()
wbar.update_ticks()
wbar.set_label('$m/s^2$', rotation=90)
CS = plt.contour(x_axis,
y_axis, (x_mean[-1, :, :].data - x_mean[0, :, :].data),
colors='black',
linewidths=1.5)
plt.title('Mean Zonal Mean Wave-Induced Acceleration, t=%s to %s days' %
(start / 4, end / 4))
plt.xlabel('Latitude [degrees]')
plt.ylabel('Height [km]')
plt.clabel(CS, inline=False, colors='k', fmt='%1.1f')
# plt.savefig('/exports/csce/datastore/geos/users/s1144983/papers/laso/epsfigs/waveinducedacc_%s_ticks.eps' %(end), format='eps')
plt.show()
zonal_acc_day = np.mean(zonal_acc[-4:-1, :, :], axis=0)
latmean = np.mean(zonal_acc_day[:, 40:51], axis=1)
latwind = x_mean[-4:-1, :, 40:51].collapsed(['latitude', 't'],
iris.analysis.MEAN)
fig, ax1 = plt.subplots(figsize=(8, 10))
ax1.set_xlabel('Acceleration [m/s$^2$]')
ax1.set_ylabel('Height [km]')
ax1.plot(latmean, y_axis, color='b', label='Acc')
ax1.tick_params(axis='x', labelcolor='b')
ax2 = ax1.twiny()
ax2.set_xlabel('Zonal mean equatorial wind [m/s]')
ax2.plot(latwind.data, y_axis, color='r', label='Wind')
ax2.tick_params(axis='x', labelcolor='r')
plt.title(
'Mean Zonal Mean Equatorial Wave-Induced Acceleration, t=%s to %s days'
% (start / 4, end / 4))
# fig.tight_layout()
plt.show()
data = f[1].data
print(type(data))
print(data.shape)
print(data.dtype.name)
print("\nMin:", np.min(data))
print("\nMax:", np.max(data))
print("\nMean:", np.mean(data))
print("\nStd:", np.std(data))
from matplotlib.colors import TwoSlopeNorm
x_ticks = ['-10', '-5', '0', '5', '10']
y_ticks = ['-10', '-5', '0', '5', '10']
t11 = [0, 175, 350, 525, 699]
plt.xticks(ticks=t11, labels=x_ticks, size=7)
plt.yticks(ticks=t11, labels=y_ticks, size=7)
norm = TwoSlopeNorm(vmin=data.min(), vcenter=0, vmax=data.max())
pc = plt.pcolormesh(data, norm=norm, cmap="seismic")
plt.imshow(data, cmap='seismic')
#plt.colorbar(pc)
cbar = plt.colorbar()
for t in cbar.ax.get_yticklabels():
t.set_fontsize(7)
plt.xlabel("degrees", fontsize=8)
plt.ylabel("degrees", fontsize=8)
#plt.title("MILCA y map of Coma",fontsize=8)
plt.savefig("../images/figure 1.png", dpi=600)
plt.show()
def meridional_wind(cubes, n=3, time_slice=-1, level=38):
for cube in cubes:
if cube.standard_name == 'y_wind':
y_wind = cube.copy()
if cube.standard_name == 'air_pressure':
pressure = cube.copy()
height = [('level_height', y_wind.coord('level_height').points)]
pressure = pressure.interpolate(height, iris.analysis.Linear())
# Regrid so that all three cubes are on the same x, y, z grid. Uses the x_wind as reference for the others
p_heights = np.round(pressure.data * 1e-05, 4)
km_heights = np.round(pressure.coord('level_height').points * 1e-03, 1)
# For labelling the quiver plot
mean_y = y_wind[time_slice, :, :, :].collapsed('longitude',
iris.analysis.MEAN)
y_prime = y_wind - mean_y
# Zonal mean meridional winds
y_wind = y_wind[time_slice, level, :, :].data
x_wind = np.zeros_like(y_wind)
X, Y = np.meshgrid(np.arange(-72, 72), np.arange(-45, 46))
fig1, ax1 = plt.subplots(figsize=(10, 5))
q1 = ax1.quiver(X[::n, ::n],
Y[::n, ::n],
np.roll(x_wind[::n, ::n], 72, axis=1),
np.roll(y_wind[::n, ::n], 72, axis=1),
angles='xy',
scale_units='xy',
scale=3)
# Create a quiver plot. The np.roll function moves the cube data so the substellar point is centred.
ax1.quiverkey(q1,
X=0.9,
Y=1.05,
U=3,
label='3 m/s',
labelpos='E',
coordinates='axes')
# This creates the key with the arrow size. The value of U, the label string, and the value of scale in the previous line should all match.
plt.title('Meridional wind vectors [m s-1], h=%s bar, %s km' %
(p_heights[time_slice, level, 0, 0], km_heights[level]))
plt.xlabel('Longitude')
plt.ylabel('Latitude')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
plt.yticks((-45, -30, -15, 0, 15, 30, 45),
('90S', '60S', '30S', '0', '30N', '60N', '90N'))
# Labelled the longs and lats manually
plt.show()
CS = iplt.contourf(mean_y,
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('Zonal Mean Meridional Wind [m s-1]', y=1.05)
plt.ylabel('Height [m]')
plt.xlabel('Latitude [degrees]')
plt.clabel(CS, inline=False, colors='k', fmt='%1.1f')
plt.colorbar(pad=0.1)
plt.show()
def plot_uw(cubes, start=0, end=120, lat=45, levels=(37, 44, 47, 53)):
for cube in cubes:
if cube.standard_name == 'eastward_wind' or cube.standard_name == 'x_wind':
x_wind = cube[start:end, :, :, :].copy()
if cube.standard_name == 'northward_wind' or cube.standard_name == 'y_wind':
y_wind = cube[start:end, :, :, :].copy()
if cube.standard_name == 'upward_air_velocity':
z_wind = cube[start:end, :, :, :].copy()
run_length, longitudes, latitudes = x_wind.shape[
0], x_wind.shape[3] / 2, x_wind.shape[2] / 2
y_wind, z_wind = y_wind.regrid(x_wind,
iris.analysis.Linear()), z_wind.regrid(
x_wind, iris.analysis.Linear())
for coord in x_wind.coords():
if coord.long_name == 'Hybrid height':
heights = np.round(x_wind.coord('Hybrid height').points * 1e-03, 0)
vertical = [('Hybrid height', x_wind.coord('Hybrid height').points)
]
elif coord.long_name == 'level_height':
heights = np.round(x_wind.coord('level_height').points * 1e-03, 0)
vertical = [('level_height', x_wind.coord('level_height').points)]
z_wind = z_wind.interpolate(vertical, iris.analysis.Linear())
zonal_mean_u = x_wind.collapsed('t', iris.analysis.MEAN)
u_prime = x_wind - zonal_mean_u
zonal_mean_w = z_wind.collapsed('t', iris.analysis.MEAN)
w_prime = z_wind - zonal_mean_w
cross_term = u_prime * w_prime
for level in levels:
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.arange(0, run_length),
np.roll(cross_term[:, level, lat, :].data, 72, axis=1),
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title(
'$U^{\prime} \cdot W^{\prime}$ at Equator [m2 s-2], h=%s km, %s to %s days'
% (heights[level], start / 4, end / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E',
'60E', '90E', '120E', '150E', '180E'))
plt.ylabel('Time [6-hours]')
plt.colorbar(pad=0.1)
plt.show()
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.arange(-latitudes, latitudes),
np.roll(cross_term[-1, level, :, :].data, 72, axis=1),
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('$U^{\prime} \cdot W^{\prime}$ [m2 s-2], h=%s km, day=%s' %
(heights[level], end / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E',
'60E', '90E', '120E', '150E', '180E'))
plt.ylabel('Latitude [degrees]')
plt.colorbar(pad=0.1)
plt.show()
def NDVI():
data_path = file_path
bands_grep = re.compile(".*_(B4|B5)\.(tif|TIF)")
file_list = glob.glob(data_path + '\*.TIF')
print(file_list)
# Filter and keep only useful files (bands 4 and 5 to compute NDVI)
bands = filter(lambda x: bands_grep.search(x), file_list)
bands = [s for s in bands]
#Open and read files
with rasterio.open(bands[0]) as src:
b4 = src.read(1).astype('float64')
with rasterio.open(bands[1]) as src:
b5 = src.read(1).astype('float64')
# Allow division by zero
np.seterr(divide='ignore', invalid='ignore')
# Calculate NDVI
ndvi = (b5.astype(float) - b4.astype(float)) / (b4 + b5)
#No data values
ndvi = np.where((b5.astype(float) - b4.astype(float)) / (b4 + b5) == 0, 0,
(b5.astype(float) - b4.astype(float)) / (b4 + b5))
# Define spatial characteristics of output object (basically they are analog to the input)
kwargs = src.meta
# Update kwargs (change in data type)
kwargs.update(dtype=rasterio.float64, count=1)
with rasterio.open(output_path + '/NDVI.tif', 'w', **kwargs) as dst:
dst.write_band(1, ndvi.astype(rasterio.float64))
src = rasterio.open(output_path + '/NDVI.tif')
# Render with colormap and colorbar
z = np.linspace(-1, 1, 50 * 50)
norm = TwoSlopeNorm(vmin=z.min(), vcenter=0, vmax=z.max())
pc = plt.imshow(src.read(1).astype('float64'), norm=norm, cmap='RdBu_r')
plt.colorbar(pc)
plt.show()
# geotiff kaydetme
naip_data_path = output_path + '/NDVI.tif'
with rasterio.open(naip_data_path) as src:
naip_data = src.read()
naip_meta = src.profile
naip_transform = naip_meta["transform"]
naip_crs = naip_meta["crs"]
w, h = ndvi.shape
customized_cmap = {}
a = float(255 / 2)
print(a)
print(customized_cmap)
for s in range(-1, 2):
s = s * (255 / 2)
print(s)
a = 0
b = 255
for s in range(0, 256):
s_color = (a, 0, b, 0)
customized_cmap[s] = s_color
a += 1
b -= 1
print(customized_cmap)
ndvi = cv2.normalize(ndvi,
None,
alpha=0,
beta=255,
norm_type=cv2.NORM_MINMAX,
dtype=cv2.CV_32F)
with rasterio.open((output_path + '/NDVI.tif'),
'w',
driver='GTiff',
width=w,
height=h,
count=1,
dtype=rasterio.uint8,
crs=naip_crs,
transform=naip_transform) as dst:
dst.write(ndvi.astype(rasterio.uint8), indexes=1)
dst.write_colormap(1, customized_cmap)
def wave_acceleration(cubes, lat=45, long=0, start=0, end=240):
for cube in cubes:
if cube.standard_name == 'eastward_wind':
x_wind = cube[start:end, :, :, :].copy()
if cube.standard_name == 'northward_wind':
y_wind = cube[start:end, :, :, :].copy()
if cube.standard_name == 'upward_air_velocity':
z_wind = cube[start:end, :, :, :].copy()
if cube.standard_name == 'air_pressure':
pressure = cube[start:end, :, :, :].copy()
y_wind = y_wind.regrid(x_wind, iris.analysis.Linear())
z_wind = z_wind.regrid(x_wind, iris.analysis.Linear())
z_wind = -1 * z_wind
pressure = pressure.regrid(x_wind, iris.analysis.Linear())
heights = pressure.coord('Hybrid height').points
height = [('Hybrid height', pressure.coord('Hybrid height').points)]
x_wind, y_wind = x_wind.interpolate(
height,
iris.analysis.Linear()), y_wind.interpolate(height,
iris.analysis.Linear())
longitudes = x_wind.shape[3] / 2
# x_zonal_mean = x_wind.collapsed('longitude', iris.analysis.MEAN)
# avg_zonal_mean = x_zonal_mean.collapsed('t', iris.analysis.MEAN)
x_mean = x_wind.collapsed('t', iris.analysis.MEAN)
z_mean = z_wind.collapsed('t', iris.analysis.MEAN)
x_anomaly = x_wind - x_mean
z_anomaly = z_wind - z_mean
result = x_wind.copy()
result.data = x_anomaly.data * z_anomaly.data
array = result.data
# h = np.log(pressure.data)
h = np.array([heights])
h = np.repeat(h[:, np.newaxis], (end - start), axis=0)
h = np.reshape(h, ((end - start), 61))
h = np.repeat(h[:, :, np.newaxis], 90, axis=2)
h = np.repeat(h[:, :, :, np.newaxis], 144, axis=3)
print(h.shape)
acceleration = array.copy()
acceleration[:, 0,
...] = (array[:, 1, ...] - array[:, 0, ...]) / (h[:, 1, ...] -
h[:, 0, ...])
acceleration[:, -1,
...] = (array[:, -1, ...] -
array[:, -2, ...]) / (h[:, -1, ...] - h[:, -2, ...])
acceleration[:, 1:-1, ...] = (array[:, 2:, ...] - array[:, 0:-2, ...]) / (
h[:, 2:, ...] - h[:, 0:-2, ...])
# acceleration = array.copy()
# acceleration[:,0,...] = (array[:,1,...]-array[:,0,...])/(h[1]-h[0])
# acceleration[:,-1,...] = (array[:,-1,...]-array[:,-2,...])/(h[-1]-h[-2])
# acceleration[:,1:-1,...] = (array[:,2:,...]-array[:,0:-2,...])/(h[2:]-h[0:-2])
# zonal_acc = np.mean(acceleration, axis=3)
# net_acc = np.sum(acceleration, axis=3)
# net_acc_total = np.mean(zonal_acc, axis=0)
substellar = acceleration[:, :, 31:59:, long]
net_acc = np.mean(substellar, axis=0) # + x_wind[start,:,31:59,long].data
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.array(heights),
np.roll(x_anomaly[end - start - 1, :, lat, :].data,
72,
axis=1),
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('Zonal Wind Anomaly at Equator [m s-1], t = %s days' % (end / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
plt.ylabel('Height [m]')
plt.colorbar(pad=0.1)
plt.show()
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.array(heights),
np.roll(z_anomaly[end - start - 1, :, lat, :].data,
72,
axis=1),
np.linspace(-0.05, 0.05, 20),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('Vertical Wind Anomaly at Equator [m s-1], t = %s days' %
(end / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
plt.ylabel('Height [m]')
plt.colorbar(pad=0.1)
plt.show()
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.array(heights),
np.roll(acceleration[end - start - 1, :, lat, :], 72, axis=1),
np.linspace(-0.0024, 0.0024, 20),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('Wave-Induced Acceleration at Equator [m s-2], t = %s days' %
(end / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
plt.ylabel('Height [m]')
plt.colorbar(pad=0.1)
plt.show()
x_axis = pressure.coord('latitude').points
y_axis = pressure.coord('Hybrid height').points
plt.figure(figsize=(6, 10))
plt.contourf(x_axis[31:59],
y_axis,
net_acc,
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.colorbar(pad=0.1)
CS = plt.contour(x_axis[31:59],
y_axis,
x_anomaly[end - start - 1, :, 31:59, long].data,
colors='black',
linewidths=0.5)
plt.title('Mean acceleration at long %s from day=%s to %s' %
(long * 2.5, start / 4, end / 4))
plt.xlabel('Latitude [degrees]')
plt.ylabel('Height [m]')
plt.clabel(CS, inline=False, colors='k', fmt='%1.1f')
plt.show()
# For each laguerre filter
for j1 in range(L):
for j2 in range(L):
sum_filters += W[h][j1] * W[h][j2] * laguerre_bank[j1, m1] * laguerre_bank[j2, m2]
sum_units += C[h, 1] * sum_filters
kernel_2[m1, m2] = sum_units
print("[2nd order Volterra kernel]")
print(kernel_2)
fig = plt.figure(figsize=(10,10))
# 3D plot
# ax = fig.gca(projection='3d')
# x = y = np.arange(0, memory, 1)
# X, Y = np.meshgrid(x, y)
# ax.plot_surface(X, Y, kernel_2, cmap='inferno', antialiased=False, alpha=0.27)
# # Customize the z axis.
# ax.set_zlim(-1.01, 1.01)
# ax.zaxis.set_major_locator(LinearLocator(10))
# ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
# Heatmap plot
norm = TwoSlopeNorm(vmin=kernel_2.min(), vmax = kernel_2.max(), vcenter=0)
plt.imshow(kernel_2, cmap='RdBu', interpolation='nearest', norm=norm)
plt.xticks(np.arange(0, memory, 1))
plt.yticks(np.arange(0, memory, 1))
plt.colorbar()
plt.show()
def ep_flux(cubes, omega=0.64617667e-05, start=0, end=240):
for cube in cubes:
if cube.standard_name == 'air_potential_temperature':
theta = cube[start:end, :, :, :].copy()
if cube.standard_name == 'eastward_wind':
x_wind = cube[start:end, :, :, :].copy()
if cube.standard_name == 'northward_wind':
y_wind = cube[start:end, :, :, :].copy()
if cube.standard_name == 'air_pressure':
pressure = cube[start:end, :, :, :].copy()
heights, longitudes, longs = np.round(
pressure.coord('Hybrid height').points * 1e-03,
0), pressure.coord('longitude').points, pressure.shape[3] / 2
y_wind, x_wind = y_wind.regrid(pressure,
iris.analysis.Linear()), x_wind.regrid(
pressure, iris.analysis.Linear())
vertical = [('Hybrid height', pressure.coord('Hybrid height').points)]
x_wind, y_wind = x_wind.interpolate(
vertical,
iris.analysis.Linear()), y_wind.interpolate(vertical,
iris.analysis.Linear())
theta_data = theta.data
x_wind_data = x_wind.data
y_wind_data = y_wind.data
pressure_data = pressure.data
logpressure = np.log(pressure_data)
theta_zonal_mean = theta.collapsed('t', iris.analysis.MEAN)
theta_zonal_mean_data = theta_zonal_mean.data
logpressure_zonal_mean = np.mean(logpressure, axis=2)
pressure_zonal_mean = np.mean(pressure_data, axis=2)
THETAp = ep_zderivative(theta_zonal_mean_data, logpressure_zonal_mean)
THETAp /= pressure_zonal_mean
# u_prime_lats = []
# for level in range(0,61):
# u_prime_heights = []
# for lat in range(0,90):
# u_fft = sp.fftpack.fft(x_wind_data[level,lat,:])
# u_psd = np.abs(u_fft)**2
# u_freq = sp.fftpack.fftfreq(len(u_psd), 1./144)
# highpass = u_fft.copy()
# highpass[np.abs(u_freq) < 1.1] = 0
# u_cleaned = np.real(sp.fftpack.ifft(highpass))
# u_bar = np.mean(u_cleaned)
# u_prime = u_cleaned - u_bar
# u_prime_heights.append(u_prime)
# u_prime_lats.append(u_prime_heights)
y_zonal_mean = y_wind.collapsed('t', iris.analysis.MEAN)
x_zonal_mean = x_wind.collapsed('t', iris.analysis.MEAN)
# x_anomaly_data = np.array(u_prime_lats)
x_anomaly = x_wind - x_zonal_mean
y_anomaly = y_wind - y_zonal_mean
theta_anomaly = theta - theta_zonal_mean
y_anomaly_data = y_anomaly.data
theta_anomaly_data = theta_anomaly.data
x_anomaly_data = x_anomaly.data
XY_anomaly = x_anomaly_data * y_anomaly_data
YTH_anomaly = y_anomaly_data * theta_anomaly_data
XY_anomaly_zonal_mean = np.mean(XY_anomaly, axis=2)
YTH_anomaly_zonal_mean = np.mean(YTH_anomaly, axis=2)
lats = (pressure.coord('latitude').points) * (np.pi / 180
) # Latitudes in radians
coriolis = 2 * omega * np.sin(lats) # Coriolis force
radius = 7160000 # radius of ProxB in meters
rcosphi = radius * np.cos(lats)
rsinphi = radius * np.sin(lats)
latfac = rcosphi * np.cos(lats)
EP_phi = -XY_anomaly_zonal_mean * latfac
EP_up = (coriolis * rcosphi * YTH_anomaly_zonal_mean) / THETAp
EP_phi_div = ep_latderivative(EP_phi, rsinphi)
EP_up_div = ep_zderivative(EP_up, pressure_zonal_mean)
EP_div = (EP_phi_div + EP_up_div)
# x_zonal_mean = x_wind.collapsed('longitude', iris.analysis.MEAN)
x_mean = x_wind.collapsed('longitude', iris.analysis.MEAN)
x_axis = pressure.coord('latitude').points
# y_axis = pressure_zonal_mean
y_axis = pressure.coord('Hybrid height').points
plt.contourf(x_axis,
y_axis[35:59],
EP_div[35:59, :],
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.colorbar(pad=0.1)
CS = plt.contour(x_axis,
y_axis[35:59],
x_mean[35:59, :].data,
colors='black',
linewidths=0.5)
plt.title('EP flux divergence for day=%s, long=%s to %s' %
(time_slice / 4, longitudes[0], longitudes[-1]))
plt.xlabel('Latitude [degrees]')
plt.ylabel('Height [m]')
plt.clabel(CS, inline=False, colors='k', fmt='%1.1f')
plt.show()
def create_xsection(cubes, time_slice=1780, lat=45):
for cube in cubes:
if cube.standard_name == 'eastward_wind' or cube.standard_name == 'x_wind':
x_wind = cube[time_slice, :, :, :].copy()
if cube.standard_name == 'air_pressure':
pressure = cube[time_slice, :, :, :].copy()
longitudes, heights = x_wind.shape[2] / 2, np.round(
x_wind.coord('Hybrid height').points * 1e-03, 0)
pressure = pressure.regrid(x_wind, iris.analysis.Linear())
height = [('Hybrid height', x_wind.coord('Hybrid height').points)]
pressure = pressure.interpolate(height, iris.analysis.Linear())
pressure = pressure.extract(iris.Constraint(latitude=45))
h = np.log(pressure.data)
u_prime_array = []
xterm_array = []
for level in range(0, 60):
u_prime, cross_term = plot_uwprime(cubes=cubes,
time_slice=time_slice,
lat=lat,
level=level,
plots=False)
u_prime_array.append(u_prime)
xterm_array.append(cross_term)
u_prime_array = np.array(u_prime_array)
xterm_array = np.array(xterm_array)
array = xterm_array.copy()
acceleration = array.copy()
acceleration[0, :] = (array[1, :] - array[0, :]) / (h[1, :] - h[0, :])
acceleration[-1, :] = (array[-1, :] - array[-2, :]) / (h[-1, :] - h[-2, :])
acceleration[1:-1, :] = (array[2:, :] - array[0:-2, :]) / (h[2:, :] -
h[0:-2, :])
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.array(heights),
np.roll(u_prime_array, 72, axis=1),
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('$U^{\prime}$ at Equator, t=%s days' % (time_slice / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
plt.ylabel('Height [km]')
plt.colorbar(pad=0.1)
plt.show()
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.array(heights),
np.roll(xterm_array, 72, axis=1),
brewer_redblu.N,
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('$U^{\prime} \cdot W^{\prime}$ at Equator, t=%s days' %
(time_slice / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
plt.ylabel('Height [km]')
plt.colorbar(pad=0.1)
plt.show()
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.array(heights[33:42]),
np.roll(u_prime_array[33:42], 72, axis=1),
np.linspace(-5, 5, 80),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('$U^{\prime}$ at Equator, t=%s days' % (time_slice / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
plt.ylabel('Height [km]')
plt.colorbar(pad=0.1)
plt.show()
plt.figure(figsize=(10, 5))
plt.contourf(np.arange(-longitudes, longitudes),
np.array(heights),
np.roll(acceleration, 72, axis=1),
np.linspace(-0.5, 0.5, 10),
cmap=brewer_redblu,
norm=TwoSlopeNorm(0))
plt.title('Wave-Induced Acceleration at Equator (filtered), t=%s days' %
(time_slice / 4))
plt.xlabel('Longitude [degrees]')
plt.xticks((-72, -60, -48, -36, -24, -12, 0, 12, 24, 36, 48, 60, 72),
('180W', '150W', '120W', '90W', '60W', '30W', '0', '30E', '60E',
'90E', '120E', '150E', '180E'))
plt.ylabel('Height [km]')
plt.colorbar(pad=0.1)
plt.show()
dist = int((len(y_fluc) / 2.) / 4)
NGC4839 = [345, 381]
print("\nLength of y fluctuation matrix =", len(y_fluc))
from matplotlib.colors import TwoSlopeNorm #Needed in plotting diverging colormaps
x_ticks = ['-2', '-1', '0', '1', '2']
y_ticks = ['-2', '-1', '0', '1', '2']
t11 = [0, 35, 70, 105, 138]
plt.figure()
plt.xticks(ticks=t11, labels=x_ticks, size='small')
plt.yticks(ticks=t11, labels=y_ticks, size='small')
norm = TwoSlopeNorm(vmin=y_fluc.min(), vcenter=0, vmax=y_fluc.max())
pc = plt.pcolormesh(y_fluc, norm=norm, cmap="seismic")
plt.imshow(y_fluc, cmap='seismic')
ax = plt.gca()
rect = patches.Rectangle((mid - dist, mid - dist),
2 * dist,
2 * dist,
linewidth=2,
edgecolor='black',
facecolor="none")
ax.add_patch(rect)
circ = patches.Circle((NGC4839[0] - x_ind[0][0], NGC4839[1] - y_ind[0][0]),
15 / pixsize,
linewidth=2,
edgecolor='green',
facecolor="none")
def MSI():
data_path = file_path
bands_grep = re.compile(".*_(B5|B6)\.(tif|TIF)")
file_list = glob.glob(data_path + '\*.TIF')
# Filter and keep only useful files (bands 4 and 5 to compute NDVI)
bands = filter(lambda x: bands_grep.search(x), file_list)
bands = [s for s in bands]
with rasterio.open(bands[0]) as src:
b5 = src.read(1).astype('float64')
with rasterio.open(bands[1]) as src:
b6 = src.read(1).astype('float64')
# Allow division by zero
np.seterr(divide='ignore', invalid='ignore')
msi_temp = np.where(b5 == 0, 0, b6 / b5)
max = msi_temp.astype(float).max()
msi = np.where(b6 / b5 >= max, max, b6 / b5)
# Define spatial characteristics of output object (basically they are analog to the input)
kwargs = src.meta
# Update kwargs (change in data type)
kwargs.update(dtype=rasterio.float64, count=1)
with rasterio.open(output_path + '/MSI.tif', 'w', **kwargs) as dst:
dst.write_band(1, msi.astype(rasterio.float64))
src = rasterio.open(output_path + '/MSI.tif')
# matplotlib ile görsel ve colorbar ayrı ayrı
z = np.linspace(0, max, 50 * 50)
norm = TwoSlopeNorm(vmin=z.min(), vcenter=max / 2, vmax=z.max())
pc = plt.imshow(src.read(1).astype('float64'), norm=norm, cmap='RdBu_r')
plt.colorbar(pc)
plt.show()
# geotiff kaydetme
naip_data_path = output_path + '/MSI.tif'
with rasterio.open(naip_data_path) as src:
naip_data = src.read()
naip_meta = src.profile
naip_transform = naip_meta["transform"]
naip_crs = naip_meta["crs"]
w, h = msi.shape
customized_cmap = {}
a = float(255 / (max + 2))
for s in range(0, int(max + 2)):
s_color = (0 + a, 0, 255 - a, 0)
customized_cmap[s] = s_color
s += 1
a += float(255 / (max + 2))
with rasterio.open(output_path + '/MSI.tif',
'w',
driver='GTiff',
width=w,
height=h,
count=1,
dtype=rasterio.uint8,
crs=naip_crs,
transform=naip_transform) as dst:
dst.write(msi.astype(rasterio.uint8), indexes=1)
dst.write_colormap(1, customized_cmap)
