def testSetPlotFilledContourLargeRange(self):
cube = iris.load_cube(iris.sample_data_path('air_temp.pp'))
plt.subplot(1,2,1)
cc.setPlot(cube, "Filled Contour", "brewer_Blues_09", 15, True, 400, 200)
plt.subplot(1,2,2)
qplt.contourf(cube, 15, cmap="brewer_Blues_09", vmin=200, vmax=400)
plt.show()
def test_missing_cs(self):
cube = tests.stock.simple_pp()
cube.coord("latitude").coord_system = None
cube.coord("longitude").coord_system = None
qplt.contourf(cube)
qplt.plt.gca().coastlines()
self.check_graphic()
def main():
fname = iris.sample_data_path('air_temp.pp')
temperature = iris.load_cube(fname)
qplt.contourf(temperature, 15)
plt.gca().coastlines()
plt.show()
def main():
fname = iris.sample_data_path('ostia_monthly.nc')
# load a single cube of surface temperature between +/- 5 latitude
cube = iris.load_cube(fname, iris.Constraint('surface_temperature', latitude=lambda v: -5 < v < 5))
# Take the mean over latitude
cube = cube.collapsed('latitude', iris.analysis.MEAN)
# Now that we have our data in a nice way, lets create the plot
# contour with 20 levels
qplt.contourf(cube, 20)
# Put a custom label on the y axis
plt.ylabel('Time / years')
# Stop matplotlib providing clever axes range padding
plt.axis('tight')
# As we are plotting annual variability, put years as the y ticks
plt.gca().yaxis.set_major_locator(mdates.YearLocator())
# And format the ticks to just show the year
plt.gca().yaxis.set_major_formatter(mdates.DateFormatter('%Y'))
plt.show()
def read_and_plot(file_name, temp_model, var_name, output_directory):
# function to read ans plot CMIP5 data
print file_name.strip()
var = iris.load_cube(file_name.strip())
# Projection is required because the coords are not monotonic.
var_regridded, extent = iris.analysis.cartography.project(var[0, :, :], ccrs.PlateCarree())
# We now have two recognisable "x" and "y" coordinates,
# which currently confuses plotting code.
var_regridded.remove_coord("latitude")
var_regridded.remove_coord("longitude")
# set plot window size
qplt.plt.figure()
# plot
qplt.contourf(var_regridded, 30)
# add coastlines
qplt.plt.gca().coastlines()
plt.title(temp_model + " " + var_name)
# show the plot
# qplt.plt.show()
outfile = output_directory + "/" + temp_model.strip() + "_" + var_name + ".png"
plt.savefig(outfile)
def main():
# Enable a future option, to ensure that the netcdf load works the same way
# as in future Iris versions.
iris.FUTURE.netcdf_promote = True
# Load the whole time-sequence as a single cube.
file_path = iris.sample_data_path('E1_north_america.nc')
cube = iris.load_cube(file_path)
# Make an aggregator from the user function.
SPELL_COUNT = Aggregator('spell_count',
count_spells,
units_func=lambda units: 1)
# Define the parameters of the test.
threshold_temperature = 280.0
spell_years = 5
# Calculate the statistic.
warm_periods = cube.collapsed('time', SPELL_COUNT,
threshold=threshold_temperature,
spell_length=spell_years)
warm_periods.rename('Number of 5-year warm spells in 240 years')
# Plot the results.
qplt.contourf(warm_periods, cmap='RdYlBu_r')
plt.gca().coastlines()
iplt.show()
def testSetPlotFilledContourPlain(self):
cube = iris.load_cube(iris.sample_data_path('air_temp.pp'))
plt.subplot(1,2,1)
cc.setPlot(cube, "Filled Contour", "Automatic", 15, False, None, None)
plt.subplot(1,2,2)
qplt.contourf(cube, 15)
plt.show()
def main():
# Enable a future option, to ensure that the netcdf load works the same way
# as in future Iris versions.
iris.FUTURE.netcdf_promote = True
# Load some test data.
fname = iris.sample_data_path('hybrid_height.nc')
theta = iris.load_cube(fname, 'air_potential_temperature')
# Extract a single height vs longitude cross-section. N.B. This could
# easily be changed to extract a specific slice, or even to loop over *all*
# cross section slices.
cross_section = next(theta.slices(['grid_longitude',
'model_level_number']))
qplt.contourf(cross_section, coords=['grid_longitude', 'altitude'],
cmap='RdBu_r')
iplt.show()
# Now do the equivalent plot, only against model level
plt.figure()
qplt.contourf(cross_section,
coords=['grid_longitude', 'model_level_number'],
cmap='RdBu_r')
iplt.show()
def test_contourf_axes_specified(self):
# Check that the contourf function does not modify the matplotlib
# pyplot state machine.
# Create a figure and axes to be used by contourf
plt.figure()
axes1 = plt.axes()
# Create test figure and axes which will be the new results
# of plt.gcf and plt.gca.
plt.figure()
axes2 = plt.axes()
# Add a title to the test axes.
plt.title('This should not be changed')
# Draw the contourf on a specific axes.
qplt.contourf(self._small(), axes=axes1)
# Ensure that the correct axes got the appropriate title.
self.assertEqual(axes2.get_title(), 'This should not be changed')
self.assertEqual(axes1.get_title(), 'Air potential temperature')
# Check that the axes labels were set correctly.
self.assertEqual(axes1.get_xlabel(), 'Grid longitude / degrees')
self.assertEqual(axes1.get_ylabel(), 'Altitude / m')
def main():
fname = iris.sample_data_path('air_temp.pp')
temperature = iris.load_strict(fname)
qplt.contourf(temperature, 15)
iplt.gcm().drawcoastlines()
plt.show()
def main():
file_path = iris.sample_data_path('polar_stereo.grib2')
cube = iris.load_cube(file_path)
qplt.contourf(cube)
ax = plt.gca()
ax.coastlines()
ax.gridlines()
plt.show()
def plot_cube(cube, N, M, n, levels = [0, 0.1, 0.15, 0.2, .25, 0.3], cmap = 'brewer_Greys_09'):
plt.subplot(N, M, n, projection=ccrs.Robinson())
cmap = plt.get_cmap(cmap)
norm = BoundaryNorm(levels, ncolors=cmap.N - 1)
qplt.contourf(cube,levels = levels, cmap = cmap, norm = norm, extend = 'max')
plt.gca().coastlines()
def runme():
# Load a cube into Iris
filename = iris.sample_data_path("A1B.2098.pp")
cube = iris.load_cube(filename)
cube.coord(axis="x").guess_bounds()
cube.coord(axis="y").guess_bounds()
# Plot the cube with Iris, just to see it.
qplt.contourf(cube)
qplt.plt.gca().coastlines()
qplt.show()
# Export as GeoTIFF (shouldn't have to write to a physical file)
iris.experimental.raster.export_geotiff(cube, 'temp.geotiff')
data = open('temp.geotiff', "rb").read()
# Publish to geoserver
server = "localhost:8082"
username, password = '******', 'geoserver'
connect_to_server(server, username, password)
workspace = "iris_test_ws"
if not exists_workspace(server, workspace):
create_workspace(server, workspace)
coveragestore = "iris_test_cs"
if not exists_coveragestore(server, workspace, coveragestore):
create_coveragestore(server, workspace, coveragestore)
filename = "file.geotiff"
upload_file(server, workspace, coveragestore, filename, data)
# Tell geoserver it's global EPSG:4326. Shouldn't need this eventually.
coverage = coveragestore # (they get the same name from geoserver)
data = '<coverage>'\
'<srs>EPSG:4326</srs>'\
'<nativeCRS>EPSG:4326</nativeCRS>'\
' <nativeBoundingBox>'\
'<minx>-180.0</minx>'\
'<maxx>180.0</maxx>'\
'<miny>-90.0</miny>'\
'<maxy>90.0</maxy>'\
'<crs>EPSG:4326</crs>'\
'</nativeBoundingBox>'\
'<enabled>true</enabled>'\
'</coverage>'
update_coverage(server, workspace, coveragestore, coverage, data)
# Use the new WMS service as a background image!
wms_server = '{server}/{workspace}/wms?service=WMS'.format(server=server, workspace=workspace)
layers = '{workspace}:{coveragestore}'.format(workspace=workspace, coveragestore=coveragestore)
plt.axes(projection=ccrs.PlateCarree())
plt.gca().set_extent([-40, 40, 20, 80])
wms_image(wms_server, layers)
plt.gca().coastlines()
plt.show()
def main():
# Load the u and v components of wind from a pp file
infile = iris.sample_data_path('wind_speed_lake_victoria.pp')
uwind = iris.load_cube(infile, 'x_wind')
vwind = iris.load_cube(infile, 'y_wind')
ulon = uwind.coord('longitude')
vlon = vwind.coord('longitude')
# The longitude points go from 180 to 540, so subtract 360 from them
ulon.points = ulon.points - 360.0
vlon.points = vlon.points - 360.0
# Create a cube containing the wind speed
windspeed = (uwind ** 2 + vwind ** 2) ** 0.5
windspeed.rename('windspeed')
x = ulon.points
y = uwind.coord('latitude').points
u = uwind.data
v = vwind.data
# Set up axes to show the lake
lakes = cfeat.NaturalEarthFeature('physical', 'lakes', '50m',
facecolor='none')
plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.add_feature(lakes)
# Get the coordinate reference system used by the data
transform = ulon.coord_system.as_cartopy_projection()
# Plot the wind speed as a contour plot
qplt.contourf(windspeed, 20)
# Add arrows to show the wind vectors
plt.quiver(x, y, u, v, pivot='middle', transform=transform)
plt.title("Wind speed over Lake Victoria")
qplt.show()
# Normalise the data for uniform arrow size
u_norm = u / np.sqrt(u ** 2.0 + v ** 2.0)
v_norm = v / np.sqrt(u ** 2.0 + v ** 2.0)
plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.add_feature(lakes)
qplt.contourf(windspeed, 20)
plt.quiver(x, y, u_norm, v_norm, pivot='middle', transform=transform)
plt.title("Wind speed over Lake Victoria")
qplt.show()
def test_polar_stereo_grib1(self):
cube = iris.load_cube(tests.get_data_path(
("GRIB", "polar_stereo", "ST4.2013052210.01h")))
self.assertCML(cube, ("grib_load", "polar_stereo_grib1.cml"))
qplt.contourf(cube, norm=LogNorm())
plt.gca().coastlines()
plt.gca().gridlines()
plt.title("polar stereo grib1")
self.check_graphic()
def test_lambert_grib2(self):
cube = iris.load_cube(tests.get_data_path(
("GRIB", "lambert", "lambert.grib2")))
self.assertCML(cube, ("grib_load", "lambert_grib2.cml"))
qplt.contourf(cube)
plt.gca().coastlines()
plt.gca().gridlines()
plt.title("lambert grib2")
self.check_graphic()
def test_polar_stereo_grib2(self):
cube = iris.load_cube(tests.get_data_path(
("GRIB", "polar_stereo",
"CMC_glb_TMP_ISBL_1015_ps30km_2013052000_P006.grib2")))
self.assertCML(cube, ("grib_load", "polar_stereo_grib2.cml"))
qplt.contourf(cube)
plt.gca().coastlines()
plt.gca().gridlines()
plt.title("polar stereo grib2")
self.check_graphic()
def main():
# Enable a future option, to ensure that the grib load works the same way
# as in future Iris versions.
iris.FUTURE.strict_grib_load = True
file_path = iris.sample_data_path('polar_stereo.grib2')
cube = iris.load_cube(file_path)
qplt.contourf(cube)
ax = plt.gca()
ax.coastlines()
ax.gridlines()
iplt.show()
def level_plot(cube,saving_path,name,level=0,color_levels=9,cmap=plt.cm.CMRmap_r,logscale=0):
if logscale:
qplt.contourf(cube[level,],color_levels,cmap=cmap,norm=matplotlib.colors.LogNorm())
else:
qplt.contourf(cube[level,],color_levels,cmap=cmap)
plt.gca().coastlines()
if level==0:
saving_str=saving_path+'Surface_level_'+name+'.png'
else:
saving_str=saving_path+'Level_%i_'%level+name+'.png'
plt.savefig(saving_str,bbox_inches='tight')
plt.close()
def main():
fname = iris.sample_data_path('colpex.pp')
# The list of phenomena of interest
phenomena = ['air_potential_temperature', 'air_pressure']
# Define the constraint on standard name and model level
constraints = [iris.Constraint(phenom, model_level_number=1) for
phenom in phenomena]
air_potential_temperature, air_pressure = iris.load_cubes(fname,
constraints)
# Define a coordinate which represents 1000 hPa
p0 = coords.AuxCoord(1000, long_name='P0', units='hPa')
# Convert reference pressure 'p0' into the same units as 'air_pressure'
p0.convert_units(air_pressure.units)
# Calculate Exner pressure
exner_pressure = (air_pressure / p0) ** (287.05 / 1005.0)
# Set the name (the unit is scalar)
exner_pressure.rename('exner_pressure')
# Calculate air_temp
air_temperature = exner_pressure * air_potential_temperature
# Set the name (the unit is K)
air_temperature.rename('air_temperature')
# Now create an iterator which will give us lat lon slices of
# exner pressure and air temperature in the form
# (exner_slice, air_temp_slice).
lat_lon_slice_pairs = iris.iterate.izip(exner_pressure,
air_temperature,
coords=['grid_latitude',
'grid_longitude'])
plt.figure(figsize=(8, 4))
for exner_slice, air_temp_slice in lat_lon_slice_pairs:
plt.subplot(121)
cont = qplt.contourf(exner_slice)
# The default colorbar has a few too many ticks on it, causing text to
# overlap. Therefore, limit the number of ticks.
limit_colorbar_ticks(cont)
plt.subplot(122)
cont = qplt.contourf(air_temp_slice)
limit_colorbar_ticks(cont)
plt.show()
# For the purposes of this example, break after the first loop - we
# only want to demonstrate the first plot.
break
def test_load(self):
cube = iris.load(
tests.get_data_path(
('NIMROD', 'uk2km', 'WO0000000003452',
'201007020900_u1096_ng_ey00_visibility0180_screen_2km')))[0]
self.assertCML(cube, ("nimrod", "load.cml"))
ax = plt.subplot(1, 1, 1, projection=ccrs.OSGB())
qplt.contourf(cube, coords=["projection_x_coordinate",
"projection_y_coordinate"],
levels=np.linspace(-25000, 6000, 10))
ax.coastlines()
self.check_graphic()
def main():
fname = iris.sample_data_path('rotated_pole.nc')
temperature = iris.load_strict(fname)
# Calculate the lat lon range and buffer it by 10 degrees
lat_range, lon_range = iris.analysis.cartography.lat_lon_range(temperature)
lat_range = lat_range[0] - 10, lat_range[1] + 10
lon_range = lon_range[0] - 10, lon_range[1] + 10
# Plot #1: Point plot showing data values & a colorbar
plt.figure()
iplt.map_setup(temperature, lat_range=lat_range, lon_range=lon_range)
points = qplt.points(temperature, c=temperature.data)
cb = plt.colorbar(points, orientation='horizontal')
cb.set_label(temperature.units)
iplt.gcm().drawcoastlines()
plt.show()
# Plot #2: Contourf of the point based data
plt.figure()
iplt.map_setup(temperature, lat_range=lat_range, lon_range=lon_range)
qplt.contourf(temperature, 15)
iplt.gcm().drawcoastlines()
plt.show()
# Plot #3: Contourf overlayed by coloured point data
plt.figure()
iplt.map_setup(temperature, lat_range=lat_range, lon_range=lon_range)
qplt.contourf(temperature)
iplt.points(temperature, c=temperature.data)
iplt.gcm().drawcoastlines()
plt.show()
# For the purposes of this example, add some bounds to the latitude and longitude
temperature.coord('grid_latitude').guess_bounds()
temperature.coord('grid_longitude').guess_bounds()
# Plot #4: Block plot
plt.figure()
iplt.map_setup(temperature, lat_range=lat_range, lon_range=lon_range)
iplt.pcolormesh(temperature)
iplt.gcm().bluemarble()
iplt.gcm().drawcoastlines()
plt.show()
def level_plot(cube,saving_path,name='',level=0,color_levels=9,cmap=plt.cm.CMRmap_r,logscale=0,saving_format='.png'):
'''
This function works for 3 dimensional cubes (model_level_number, latitude, longitude)
It plots and saves a png file (by default)
You can use it like:
ukl.level_plot(cube_time_mean,saving_path)
By default, it plots the cube at level 0 (surface_level) in linear scale and saves it in the path given.
you can change 'level' for plotting a different level
For example
lev=22
ukl.level_plot(cube_time_mean,saving_path,level=lev)
Other kargs:
'name' sets a different name in the saved file. By default it uses cube.var_name
'color_levels' is an integrer number for setting how many levels you want
'logscale' if set to true, the plot will be in logarithmic scale
'cmap' changes the mapping colors
'saving_format' can be set to something different than png to change the format of the plot
'''
if cube.ndim!=3:
raise NameError('The cube has to have 3 dimensions (model_level_number, latitude, longitude) \n \
Currently its shape is: %s' % (cube.shape,) )
if logscale:
qplt.contourf(cube[level,],color_levels,cmap=cmap,norm=matplotlib.colors.LogNorm())
log_str='_log_scale'
else:
qplt.contourf(cube[level,],color_levels,cmap=cmap)
log_str=''
plt.gca().coastlines()
if name=='':
name=cube.var_name
if level==0:
saving_str=saving_path+'Surface_level_'+name+log_str+saving_format
else:
saving_str=saving_path+'Level_%i_'%level+name+log_str+saving_format
plt.savefig(saving_str,bbox_inches='tight')
plt.close()
def main():
fname = iris.sample_data_path("hybrid_height.nc")
theta = iris.load_cube(fname)
# Extract a single height vs longitude cross-section. N.B. This could easily be changed to
# extract a specific slice, or even to loop over *all* cross section slices.
cross_section = next(theta.slices(["grid_longitude", "model_level_number"]))
qplt.contourf(cross_section, coords=["grid_longitude", "altitude"], cmap="RdBu_r")
iplt.show()
# Now do the equivalent plot, only against model level
plt.figure()
qplt.contourf(cross_section, coords=["grid_longitude", "model_level_number"], cmap="RdBu_r")
iplt.show()
def main():
# Load the "total electron content" cube.
filename = iris.sample_data_path('space_weather.nc')
cube = iris.load_cube(filename, 'total electron content')
# Explicitly mask negative electron content.
cube.data = ma.masked_less(cube.data, 0)
# Plot the cube using one hundred colour levels.
qplt.contourf(cube, 100)
plt.title('Total Electron Content')
plt.xlabel('longitude / degrees')
plt.ylabel('latitude / degrees')
plt.gca().stock_img()
plt.gca().coastlines()
iplt.show()
def main():
fname = iris.sample_data_path('hybrid_height.nc')
theta = iris.load_strict(fname)
# Extract a single height vs longitude cross-section. N.B. This could easily be changed to
# extract a specific slice, or even to loop over *all* cross section slices.
cross_section = theta.slices(['grid_longitude', 'model_level_number']).next()
qplt.contourf(cross_section, coords=['grid_longitude', 'altitude'])
plt.show()
# Now do the equivalent plot, only against model level
plt.figure()
qplt.contourf(cross_section, coords=['grid_longitude', 'model_level_number'])
plt.show()
def main():
dir='/data/local2/hador/ostia_reanalysis/' # ELD140
filename = dir + '*.nc'
cube = iris.load_cube(filename,'sea_surface_temperature',callback=my_callback)
#reads in data using a special callback, because it is a nasty netcdf file
sst_mean = cube.collapsed('time', iris.analysis.MEAN)
#average all 12 months together
caribbean = iris.Constraint(
longitude=lambda v: 260 <= v <= 320,
latitude=lambda v: 0 <= v <= 40,
name='sea_surface_temperature'
)
caribbean_sst_mean = sst_mean.extract(caribbean)
#extract the Caribbean region
plt.figure()
contour=qplt.contourf(caribbean_sst_mean, 50)
contour=qplt.contour(caribbean_sst_mean, 5,colors='k')
plt.clabel(contour, inline=1, fontsize=10,fmt='%1.1f' )
plt.gca().coastlines()
#plt.gca().set_extent((-100,-60,0,40))
plt.show()
def zonal_mean_plot(cube,saving_path,name,cmap='CMRmap_r',logscale=0):
for coord in cube.coords():
#print coord.name()
if coord.name()=='surface_altitude':
cube.remove_coord('surface_altitude')
#print 'removed'
#coords_name=[coord.name() for coord in cube.coords()]
#print coords_name
cube_zonal_mean=cube.collapsed(['longitude'],iris.analysis.MEAN)
if logscale:
qplt.contourf(cube_zonal_mean,cmap=cmap,norm=matplotlib.colors.LogNorm())
else:
qplt.contourf(cube_zonal_mean,cmap=cmap)
plt.yscale('log')
plt.savefig(saving_path+'Zonal_mean_'+name+'.png',bbox_inches='tight')
plt.close()
def main():
fname = iris.sample_data_path('air_temp.pp')
temperature = iris.load_cube(fname)
# Plot #1: contourf with axes longitude from -180 to 180
fig = plt.figure(figsize=(12, 5))
plt.subplot(121)
qplt.contourf(temperature, 15)
plt.gca().coastlines()
# Plot #2: contourf with axes longitude from 0 to 360
proj = ccrs.PlateCarree(central_longitude=-180.0)
ax = plt.subplot(122, projection=proj)
qplt.contourf(temperature, 15)
plt.gca().coastlines()
iplt.show()
def main():
# Load the "total electron content" cube.
filename = iris.sample_data_path("space_weather.nc")
cube = iris.load_cube(filename, "total electron content")
# Explicitly mask negative electron content.
cube.data = ma.masked_less(cube.data, 0)
# Plot the cube using one hundred colour levels.
qplt.contourf(cube, 100)
plt.title("Total Electron Content")
plt.xlabel("longitude / degrees")
plt.ylabel("latitude / degrees")
plt.gca().stock_img()
plt.gca().coastlines()
iplt.show()
def set_plot(cube, plot_type, cmap, num_contours, contour_labels, colorbar_range):
"""
Produces a plot object for the desired cube using quickplot.
Args:
* cube
The cube to be plotted.
* plot_type
String holding the type of plot to be used. Choose from pcolormesh,
Contour and Contourf.
* cmap
String representing the colormap to be used. Can be any of the
Brewer Colormaps supported by Iris, or Automatic.
* num_contour
int holding the number of contours to be plotted.
* contour_labels
Boolean representing whether the contours on a Contour plot
(not contourf) should be labeled.
* colorbar_range
Dictionary containing ints representing the max and min to
which the colorbar will be set.
"""
# We unpack the colorbar_range dictionary
colorbar_max = colorbar_range["max"]
colorbar_min = colorbar_range["min"]
# We obtain the levels used to define the contours.
levels = get_levels(cube, colorbar_max, colorbar_min, num_contours)
if plot_type == "Filled Contour":
qplt.contourf(cube, num_contours, cmap=get_colormap(cmap), levels=levels, vmax=colorbar_max, vmin=colorbar_min)
elif plot_type == "Contour":
contours = qplt.contour(
cube, num_contours, cmap=get_colormap(cmap), levels=levels, vmax=colorbar_max, vmin=colorbar_min
)
if contour_labels:
plt.clabel(contours, inline=1, fontsize=8)
else:
qplt.pcolormesh(cube, cmap=get_colormap(cmap), vmax=colorbar_max, vmin=colorbar_min)
def test_orography(self):
qplt.contourf(self.cube)
iplt.orography_at_points(self.cube)
iplt.points(self.cube)
self.check_graphic()
coords = ['altitude', 'grid_longitude']
qplt.contourf(self.cube, coords=coords)
iplt.orography_at_points(self.cube, coords=coords)
iplt.points(self.cube, coords=coords)
self.check_graphic()
# TODO: Test bounds once they are supported.
with self.assertRaises(NotImplementedError):
qplt.pcolor(self.cube)
iplt.orography_at_bounds(self.cube)
iplt.outline(self.cube)
self.check_graphic()
def plot_cube(cube, Ns, N, cmap):
plt.subplot(Ns - 1, 2, N, projection=ccrs.Robinson())
print cube.name()
try:
cube = cube.collapsed('time', iris.analysis.MEAN)
except:
cube = cube.collapsed('forecast_reference_time', iris.analysis.MEAN)
cmap = plt.get_cmap(cmap)
levels, extend = hist_limits(cube, 7)
if (extend =='max'):
norm = BoundaryNorm(levels, ncolors=cmap.N - 1)
else:
norm = BoundaryNorm(levels, ncolors=cmap.N)
qplt.contourf(cube, levels = levels, cmap = cmap, norm = norm, extend = extend)
plt.gca().coastlines()
def main():
fname = iris.sample_data_path('hybrid_height.nc')
theta = iris.load_cube(fname)
# Extract a single height vs longitude cross-section. N.B. This could easily be changed to
# extract a specific slice, or even to loop over *all* cross section slices.
cross_section = theta.slices(['grid_longitude',
'model_level_number']).next()
qplt.contourf(cross_section, coords=['grid_longitude', 'altitude'])
plt.show()
# Now do the equivalent plot, only against model level
plt.figure()
qplt.contourf(cross_section,
coords=['grid_longitude', 'model_level_number'])
plt.show()
def main():
fname = iris.sample_data_path('rotated_pole.nc')
temperature = iris.load_strict(fname)
# Calculate the lat lon range and buffer it by 10 degrees
lat_range, lon_range = iris.analysis.cartography.lat_lon_range(temperature)
lat_range = lat_range[0] - 10, lat_range[1] + 10
lon_range = lon_range[0] - 10, lon_range[1] + 10
# Plot #1: Point plot showing data values & a colorbar
plt.figure()
iplt.map_setup(temperature, lat_range=lat_range, lon_range=lon_range)
points = qplt.points(temperature, c=temperature.data)
cb = plt.colorbar(points, orientation='horizontal')
cb.set_label(temperature.units)
iplt.gcm().drawcoastlines()
plt.show()
# Plot #2: Contourf of the point based data
plt.figure()
iplt.map_setup(temperature, lat_range=lat_range, lon_range=lon_range)
qplt.contourf(temperature, 15)
iplt.gcm().drawcoastlines()
plt.show()
# Plot #3: Contourf overlayed by coloured point data
plt.figure()
iplt.map_setup(temperature, lat_range=lat_range, lon_range=lon_range)
qplt.contourf(temperature)
iplt.points(temperature, c=temperature.data)
iplt.gcm().drawcoastlines()
plt.show()
# For the purposes of this example, add some bounds to the latitude and longitude
temperature.coord('grid_latitude').guess_bounds()
temperature.coord('grid_longitude').guess_bounds()
# Plot #4: Block plot
plt.figure()
iplt.map_setup(temperature, lat_range=lat_range, lon_range=lon_range)
iplt.pcolormesh(temperature)
iplt.gcm().bluemarble()
iplt.gcm().drawcoastlines()
plt.show()
def test_2d_coords_contour(self):
ny, nx = 4, 6
x1 = np.linspace(-20, 70, nx)
y1 = np.linspace(10, 60, ny)
data = np.zeros((ny, nx))
data.flat[:] = np.arange(nx * ny) % 7
cube = Cube(data, long_name='Odd data')
x2, y2 = np.meshgrid(x1, y1)
true_lons, true_lats = unrotate_pole(x2, y2, -130., 77.)
co_x = AuxCoord(true_lons, standard_name='longitude', units='degrees')
co_y = AuxCoord(true_lats, standard_name='latitude', units='degrees')
cube.add_aux_coord(co_y, (0, 1))
cube.add_aux_coord(co_x, (0, 1))
ax = plt.axes(projection=ccrs.PlateCarree())
qplt.contourf(cube)
ax.coastlines(color='red')
ax.gridlines(draw_labels=True)
ax.set_extent((0, 180, 0, 90))
self.check_graphic()
def main():
# Enable a future option, to ensure that the netcdf load works the same way
# as in future Iris versions.
iris.FUTURE.netcdf_promote = True
# Load some test data.
fname = iris.sample_data_path('rotated_pole.nc')
air_pressure = iris.load_cube(fname)
# Plot #1: Point plot showing data values & a colorbar
plt.figure()
points = qplt.points(air_pressure, c=air_pressure.data)
cb = plt.colorbar(points, orientation='horizontal')
cb.set_label(air_pressure.units)
plt.gca().coastlines()
iplt.show()
# Plot #2: Contourf of the point based data
plt.figure()
qplt.contourf(air_pressure, 15)
plt.gca().coastlines()
iplt.show()
# Plot #3: Contourf overlayed by coloured point data
plt.figure()
qplt.contourf(air_pressure)
iplt.points(air_pressure, c=air_pressure.data)
plt.gca().coastlines()
iplt.show()
# For the purposes of this example, add some bounds to the latitude
# and longitude
air_pressure.coord('grid_latitude').guess_bounds()
air_pressure.coord('grid_longitude').guess_bounds()
# Plot #4: Block plot
plt.figure()
plt.axes(projection=ccrs.PlateCarree())
iplt.pcolormesh(air_pressure)
plt.gca().stock_img()
plt.gca().coastlines()
iplt.show()
def zonal_mean_plot(cube,saving_path,name,cmap='CMRmap_r',logscale=0):
for coord in cube.coords():
#print coord.name()
if coord.name()=='surface_altitude':
cube.remove_coord('surface_altitude')
#print 'removed'
#coords_name=[coord.name() for coord in cube.coords()]
#print coords_name
cube_zonal_mean=cube.collapsed(['longitude'],iris.analysis.MEAN)
if logscale:
qplt.contourf(cube_zonal_mean,cmap=cmap,norm=matplotlib.colors.LogNorm())
else:
qplt.contourf(cube_zonal_mean,cmap=cmap)
# data=cube_zonal_mean.data
#
# title=cube.var_name+' max:%1.2f mean:%1.2f min:%1.2f'%(data.max(),data.mean(),data.min())
# plt.title(title)
plt.yscale('log')
plt.savefig(saving_path+'Zonal_mean_'+name+'.png',bbox_inches='tight')
plt.close()
def main():
# Enable a future option, to ensure that the netcdf load works the same way
# as in future Iris versions.
iris.FUTURE.netcdf_promote = True
# Load the "total electron content" cube.
filename = iris.sample_data_path('space_weather.nc')
cube = iris.load_cube(filename, 'total electron content')
# Explicitly mask negative electron content.
cube.data = ma.masked_less(cube.data, 0)
# Plot the cube using one hundred colour levels.
qplt.contourf(cube, 100)
plt.title('Total Electron Content')
plt.xlabel('longitude / degrees')
plt.ylabel('latitude / degrees')
plt.gca().stock_img()
plt.gca().coastlines()
iplt.show()
def add_map_subplot(subplot,
cube,
nspace,
title='',
cmap='',
extend='neither',
log=False):
"""
Add a map subplot to the current pyplot figure.
Parameters
----------
subplot: int
The matplotlib.pyplot subplot number. (ie 221)
cube: iris.cube.Cube
the iris cube to be plotted.
nspace: numpy.array
An array of the ticks of the colour part.
title: str
A string to set as the subplot title.
cmap: str
A string to describe the matplotlib colour map.
extend: str
Contourf-coloring of values outside the levels range
log: bool
Flag to plot the colour scale linearly (False) or
logarithmically (True)
"""
plt.subplot(subplot)
logger.info('add_map_subplot: %s', subplot)
if log:
qplot = qplt.contourf(cube,
nspace,
linewidth=0,
cmap=plt.cm.get_cmap(cmap),
norm=LogNorm(),
zmin=nspace.min(),
zmax=nspace.max())
qplot.colorbar.set_ticks([0.1, 1., 10.])
else:
qplot = iris.plot.contourf(cube,
nspace,
linewidth=0,
cmap=plt.cm.get_cmap(cmap),
extend=extend,
zmin=nspace.min(),
zmax=nspace.max())
cbar = pyplot.colorbar(orientation='horizontal')
cbar.set_ticks(
[nspace.min(), (nspace.max() + nspace.min()) / 2.,
nspace.max()])
plt.gca().coastlines()
plt.title(title)
def plot(self, cube, name):
plt.figure(figsize=(8, 6))
proj = ccrs.EuroPP()
plt.axes(projection=proj)
contour = qplt.contourf(cube)
plt.gca().coastlines()
plt.clabel(contour, inline=False)
plt.savefig(
os.path.join('/esarchive/scratch/jcos/esmvaltool/output/figures/',
name))
plt.clf()
def plot_2D(self, results, data):
# Plot the results for each dataset in the same plot
for result in results:
dataset = data[result][0]['dataset']
qplt.contourf(results[result], label=dataset)
plot_name = 'tas_mn_20002010_djf.{out}'.format(
out=self.cfg[n.OUTPUT_FILE_TYPE])
# Get the path to the plot directory
plot_dir = self.cfg[n.PLOT_DIR]
# Some tweaks using matplotlib
plt.legend()
plt.tick_params(axis='x', labelsize=8)
# Save the plot
# plt.savefig(os.path.join(plot_dir, plot_name))
plt.savefig(
os.path.join('/home/Earth/jcos/es-esmvaltool/output/', plot_name))
plt.close()
def plot_band_list(List, fname, lev, O3_bands, rates_in_bands):
fig = plt.figure(figsize=(13, 18), dpi=100)
index_grid = np.arange(9).reshape([3, 3])
gs = gridspec.GridSpec(4, 3)
for i in range(3):
for j in range(3):
plt1 = plt.subplot(gs[i, j])
divs = List[index_grid[i, j]]
qplt.contourf(divs, lev, cmap='bwr')
qplt.contour(divs, levels=[0], colors='black')
plt.title(
str(rates_in_bands[index_grid[i, j]]) +
' events/year, O$_3$ Percentile ' +
str(10 * index_grid[i, j]) + '-' +
str(10 + 10 * index_grid[i, j]))
plt1.set_yscale('log', basey=10, subsy=None)
plt.ylim(5, 10000)
plt1.invert_yaxis()
plt.ylabel('Pressure (Pa)')
plt.xlabel('Latitude')
plt1 = plt.subplot(gs[3, 0])
divs = List[9]
qplt.contourf(divs, lev, cmap='bwr')
qplt.contour(divs, levels=[0], colors='black')
plt.title(
str(rates_in_bands[index_grid[i, j]]) +
' events/year, O$_3$ Percentile 90-100')
plt1.set_yscale('log', basey=10, subsy=None)
plt.ylim(5, 10000)
plt1.invert_yaxis()
plt.ylabel('Pressure (Pa)')
plt.xlabel('Latitude')
plt.tight_layout()
plt.show()
fig.savefig('./figures/' + fname, dpi=200)
return
def main():
fname = iris.sample_data_path('rotated_pole.nc')
temperature = iris.load_cube(fname)
# Plot #1: Point plot showing data values & a colorbar
plt.figure()
points = qplt.points(temperature, c=temperature.data)
cb = plt.colorbar(points, orientation='horizontal')
cb.set_label(temperature.units)
plt.gca().coastlines()
plt.show()
# Plot #2: Contourf of the point based data
plt.figure()
qplt.contourf(temperature, 15)
plt.gca().coastlines()
plt.show()
# Plot #3: Contourf overlayed by coloured point data
plt.figure()
qplt.contourf(temperature)
iplt.points(temperature, c=temperature.data)
plt.gca().coastlines()
plt.show()
# For the purposes of this example, add some bounds to the latitude and longitude
temperature.coord('grid_latitude').guess_bounds()
temperature.coord('grid_longitude').guess_bounds()
# Plot #4: Block plot
plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
iplt.pcolormesh(temperature)
plt.gca().stock_img()
plt.gca().coastlines()
plt.show()
def main():
# Load the "total electron content" cube.
filename = iris.sample_data_path('space_weather.nc')
cube = iris.load_cube(filename, 'total electron content')
# Explicitly mask negative electron content.
cube.data = ma.masked_less(cube.data, 0)
# Currently require to remove the multi-dimensional
# latitude and longitude coordinates for Iris plotting.
cube.remove_coord('latitude')
cube.remove_coord('longitude')
# Plot the cube using one hundred colour levels.
qplt.contourf(cube, 100)
plt.title('Total Electron Content')
plt.xlabel('longitude / degrees')
plt.ylabel('latitude / degrees')
plt.gca().stock_img()
plt.gca().coastlines()
plt.show()
def main():
"""
"""
filename = datadir + 'iop5_36h.pp'
cubes = files.load(filename)
theta = convert.calc('air_potential_temperature', cubes)
plotter = CSP(False,
qplt.contourf,
theta,
np.linspace(270, 350, 15),
cmap='cubehelix_r',
extend='both')
onselect = CS([plotter])
qplt.contourf(theta[0], np.linspace(270, 300, 31), cmap='cubehelix_r')
RectangleSelector(plt.gca(), onselect, drawtype='line')
plt.show()
def main():
# This is a function that controls everything
# mycube = iris.load_cube('/nfs/a266/data/CMIP5_AFRICA/BC_0.5x0.5/HadGEM2-CC/rcp45/pr_WFDEI_1979-2013_0.5x0.5_day_HadGEM2-CC_africa_rcp45_r1i1p1_full.nc')
figdir = '/nfs/see-fs-01_teaching/earv057/plots'
try:
cube2plot = iris.load_cube(figdir + 'hovmoller.nc')
print cube2plot
except IOError:
mycube = iris.load_cube(
'/nfs/a266/data/CMIP5_AFRICA/0.5x0.5/CanESM2/historical/pr_day_CanESM2_africa_0.5x0.5_historical_r1i1p1_full.nc'
)
print mycube.coord('time').points[0:40]
reg_cube = mycube.intersection(latitude=(4, 25), longitude=(-10, 10))
reg_cube.coord('latitude').guess_bounds()
reg_cube.coord('longitude').guess_bounds()
reg_cube_coll = reg_cube.collapsed('longitude', iris.analysis.MEAN)
iris.coord_categorisation.add_month(reg_cube_coll,
'time',
name='month')
cube2plot = reg_cube_coll.aggregated_by('month', iris.analysis.MEAN)
cube2plot.convert_units('kg m-2 day-1')
print cube2plot
iris.save(cube2plot, figdir + 'hovmoller.nc')
print reg_cube_coll.coord('time')
# print reg_cube_coll
# print reg_cube_coll[0]
# iris.coord_categorisation.add_day_of_year(reg_cube_coll, 'time', name = 'day_of_year')
# partition
#mycube = mycube.collapsed('longitude', iris.analysis.MEAN)
# print mycube
levels = np.linspace(1, 20, 50)
plt.clf()
qplt.contourf(cube2plot, levels=levels, extend='max')
plt.ylabel('latitude')
plt.xlabel('time/months')
plt.show()
def main():
file_path = iris.sample_data_path(
'/nfs/a266/data/CMIP5_AFRICA/BC_0.5x0.5/IPSL-CM5A-LR/historical/pr_WFDEI_1979-2013_0.5x0.5_day_IPSL-CM5A-LR_africa_historical_r1i1p1_full.nc'
)
cube = iris.load_cube(file_path)
cube_wafr = cube.intersection(latitude=(-10.0, 10.0),
longitude=(4.0, 25.0))
iris.coord_categorisation.add_year(cube_wafr, 'time', name='year')
iris.coord_categorisation.add_month_number(cube_wafr,
'time',
name='month_number')
iris.coord_categorisation.add_season(cube_wafr, 'time', name='season')
SPELL_COUNT = Aggregator('spell_count',
count_spells,
units_func=lambda units: 1)
threshold_rainfall = 0.1
spell_days = 10
dry_periods = cube.collapsed('time',
SPELL_COUNT,
threshold=threshold_rainfall,
spell_length=spell_days)
dry_periods.rename('Number of 10-days dry spells in 35 years')
qplt.contourf(dry_periods, cmap='RdYlBu_r')
plt.gca().coastlines()
iplt.show()
def main():
# Load the u and v components of wind from a pp file.
infile = iris.sample_data_path("wind_speed_lake_victoria.pp")
uwind = iris.load_cube(infile, "x_wind")
vwind = iris.load_cube(infile, "y_wind")
# Create a cube containing the wind speed.
windspeed = (uwind ** 2 + vwind ** 2) ** 0.5
windspeed.rename("windspeed")
# Plot the wind speed as a contour plot.
qplt.contourf(windspeed, 20)
# Show the lake on the current axes.
lakes = cfeat.NaturalEarthFeature(
"physical", "lakes", "50m", facecolor="none"
)
plt.gca().add_feature(lakes)
# Add arrows to show the wind vectors.
iplt.quiver(uwind, vwind, pivot="middle")
plt.title("Wind speed over Lake Victoria")
qplt.show()
# Normalise the data for uniform arrow size.
u_norm = uwind / windspeed
v_norm = vwind / windspeed
# Make a new figure for the normalised plot.
plt.figure()
qplt.contourf(windspeed, 20)
plt.gca().add_feature(lakes)
iplt.quiver(u_norm, v_norm, pivot="middle")
plt.title("Wind speed over Lake Victoria")
qplt.show()
def map(incube, plotpath, modelID):
# plot a map for a smaller domain
print 'plotting a map'
fig = plt.figure(figsize=(12, 5))
qplt.contourf(incube[5, :, :])
plt.gca().coastlines()
# # get the current axes' subplot for use later on
# plt1_ax = plt.gca()
#
# # Add the second subplot showing the A1B scenario
# plt.subplot(122)
# contour_result = iplt.contourf(spi_ts)
#
# # get the current axes' subplot for use later on
# plt2_ax = plt.gca()ttom, width, height = plt2_ax.get_position().bounds
# first_plot_left = plt1_ax.get_position().bounds[0]
# colorbar_axes = fig.add_axes([first_plot_left, bottom + 0.07, width, 0.03])
cbar = plt.colorbar(spi_ts, colorbar_axes, orientation='horizontal')
plt.suptitle('Monthly distribution of the SPI over WA', fontsize=18)
#plt.show()
plt.savefig(plotpath + 'ts_' + modelID + '.png')
def main():
# Load some test data.
fname = iris.sample_data_path('hybrid_height.nc')
theta = iris.load_cube(fname, 'air_potential_temperature')
# Extract a single height vs longitude cross-section. N.B. This could
# easily be changed to extract a specific slice, or even to loop over *all*
# cross section slices.
cross_section = next(theta.slices(['grid_longitude',
'model_level_number']))
qplt.contourf(cross_section, coords=['grid_longitude', 'altitude'],
cmap='RdBu_r')
iplt.show()
# Now do the equivalent plot, only against model level
plt.figure()
qplt.contourf(cross_section,
coords=['grid_longitude', 'model_level_number'],
cmap='RdBu_r')
iplt.show()
def main():
# Load the u and v components of wind from a pp file
infile = iris.sample_data_path("wind_speed_lake_victoria.pp")
uwind = iris.load_cube(infile, "x_wind")
vwind = iris.load_cube(infile, "y_wind")
uwind.convert_units("knot")
vwind.convert_units("knot")
# To illustrate the full range of barbs, scale the wind speed up to pretend
# that a storm is passing over
magnitude = (uwind**2 + vwind**2)**0.5
magnitude.convert_units("knot")
max_speed = magnitude.collapsed(("latitude", "longitude"),
iris.analysis.MAX).data
max_desired = 65
uwind = uwind / max_speed * max_desired
vwind = vwind / max_speed * max_desired
# Create a cube containing the wind speed
windspeed = (uwind**2 + vwind**2)**0.5
windspeed.rename("windspeed")
windspeed.convert_units("knot")
plt.figure()
# Plot the wind speed as a contour plot
qplt.contourf(windspeed)
# Add wind barbs except for the outermost values which overhang the edge
# of the plot if left
iplt.barbs(uwind[1:-1, 1:-1], vwind[1:-1, 1:-1], pivot="middle", length=6)
plt.title("Wind speed during a simulated storm")
qplt.show()
def main():
figdir = '/nfs/see-fs-01_teaching/earv052/metrics_workshop/Yo_Sa'
try:
cube2plot = iris.load_cube(figdir+'/Leeds_numberdays30mm.nc')
print cube2plot
except IOError:
cube = iris.load_cube('/nfs/a266/data/CMIP5_AFRICA/BC_0.5x0.5/IPSL-CM5A-LR/historical/pr_WFDEI_1979-2013_0.5x0.5_day_IPSL-CM5A-LR_africa_historical_r1i1p1_full.nc')
precip = cube[0]
#print(precip)
precip = cube.intersection(longitude=(-18.0, 0.0), latitude=(10.0, 20.0))
precip.coord('latitude').guess_bounds()
precip.coord('longitude').guess_bounds()
precip.convert_units('kg m-2 day-1')
#print(precip)
iris.coord_categorisation.add_month_number(precip, 'time', name='month')
print(precip)
#iris.coord_categorisation.add_day_of_year(precip, 'time', name='day_of_year')
#ann_long = np.unique(precip.coord('year').points)
#ann = len(ann_long)
val=30.0
bigger = precip.aggregated_by('month', iris.analysis.COUNT, function = lambda values: values > val )
monthcount = precip.aggregated_by('month', iris.analysis.COUNT, function = lambda values: values > -5000)
monthcount.data = monthcount.data.astype(float)
print bigger
print monthcount.data
aug = bigger/monthcount
# aug = bigger.extract(iris.Constraint(month=8))/monthcount.extract(iris.Constraint(month=8))
print aug.data
qplt.contourf(aug.extract(iris.Constraint(month=8)))
## qplt.contourf(bigger.extract(iris.Constraint(month=8)))
#d = plt.gca() # get axis object
#d.coastlines() # to draw coastlines
m = bm.Basemap(projection='cyl', llcrnrlat=10.0, urcrnrlat=20.0, llcrnrlon=-18.0, urcrnrlon=0.0, resolution='c') # coarse resolution for grid
m.drawcoastlines(linewidth=2)
m.drawcountries(linewidth=2)
plt.show()
def plot2D(self, results, data, name):
for result in results:
dataset = data[result][0]['dataset']
central_lon, central_lat = 20, 30
extent = [-10, 40, 20, 60]
plt.figure(figsize=(8,6))
ax = plt.axes(projection=ccrs.Orthographic(central_lon, central_lat))
ax.set_extent(extent)
contour = qplt.contourf(results[result])
plt.gca().coastlines()
plt.clabel(contour, inline=False)
plt.title('2000-05 period temperature anomaly, with respect to 1950-1980 climatology. '+dataset)
plt.savefig(os.path.join('/esarchive/scratch/jcos/esmvaltool/output/figures/', dataset+name))
plt.clf()
def test_contourf(self):
qplt.contourf(self._small())
cube = self._small()
iplt.orography_at_points(cube)
self.check_graphic()
qplt.contourf(self._small(), coords=['model_level_number', 'grid_longitude'])
self.check_graphic()
qplt.contourf(self._small(), coords=['grid_longitude', 'model_level_number'])
self.check_graphic()
# wind_speed = wind_speed[
# times_to_use,
# pressure_levels_to_use,
# lats_to_use,
# lons_to_use
# ]
# altitude = altitude[
# times_to_use,
# pressure_levels_to_use,
# lats_to_use,
# lons_to_use
# ]
import iris.quickplot as qplt
import iris.analysis as an
fig = qplt.contourf(wind_speed[0, -1, :, :], cmap="viridis")
plt.xlabel("Longitude")
plt.ylabel("Latitude")
plt.title("Winds at Ground, 6/15/1972 0:00 GMT")
plt.tight_layout()
plt.savefig("ground_winds_demo.svg")
plt.show()
fig = qplt.contourf(wind_speed[0, 8, :, :], cmap="viridis")
plt.xlabel("Longitude")
plt.ylabel("Latitude")
plt.title("Winds at 5 kPa PL (~20908 m, ~68596 ft.), 6/15/1972 0:00 GMT")
plt.tight_layout()
plt.savefig("aloft_winds_demo.svg")
plt.show()
def _check(self, cube):
qplt.contourf(cube)
self.check_graphic()
qplt.pcolor(cube)
self.check_graphic()
def test_points(self):
cube = simple_cube()
qplt.contourf(cube)
self.check_graphic()
import matplotlib.cm as mpl_cm
import matplotlib.pyplot as plt
import iris
import iris.quickplot as qplt
fname = iris.sample_data_path('air_temp.pp')
temperature_cube = iris.load_cube(fname)
# Load a Cynthia Brewer palette.
brewer_cmap = mpl_cm.get_cmap('brewer_RdBu_11')
# Draw the contour with 25 levels.
qplt.contourf(temperature_cube, 25, cmap=brewer_cmap)
# Add coastlines to the map created by contourf.
plt.gca().coastlines()
plt.show()
import matplotlib.pyplot as plt
import iris
import iris.quickplot as qplt
## only 2dim
f = iris.load_cube('file_name')
iplt.contourf(f) # no color bar & name
qplt.contourf(f) # color bar & name
iplt.pcolormesh(f)
qplt.pcolormesh(f)
# applying cmap
import matplotlib.cm as mpl_cm
cmap = mpl_cm.get_cmap('brewer_OrRd_09')
qplt.contourf(temperature_cube, brewer_cmap.N, cmap=brewer_cmap)
qplt.pcolormesh(temperature_cube, cmap=brewer_cmap)
# ciation
qplt.contourf(temperature_cube, brewer_cmap.N, cmap=brewer_cmap)
iplt.citation('ciation')
plt.gca().coastlines()
