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_warn_deprecated(self): sample_path = _temp_file(self.sample_dir) with mock.patch('warnings.warn') as warn: sample_data_path(os.path.basename(sample_path)) self.assertEqual(warn.call_count, 1) (warn_msg, warn_exception), _ = warn.call_args msg = 'iris.config.SAMPLE_DATA_DIR was deprecated' self.assertTrue(warn_msg.startswith(msg)) self.assertEqual(warn_exception, IrisDeprecation)
def main(): # Load data into three Cubes, one for each set of PP files e1 = iris.load_strict(iris.sample_data_path('E1_north_america.nc')) a1b = iris.load_strict(iris.sample_data_path('A1B_north_america.nc')) # load in the global pre-industrial mean temperature, and limit the domain to # the same North American region that e1 and a1b are at. north_america = iris.Constraint( longitude=lambda v: 225 <= v <= 315, latitude=lambda v: 15 <= v <= 60, ) pre_industrial = iris.load_strict(iris.sample_data_path('pre-industrial.pp'), north_america ) pre_industrial_mean = pre_industrial.collapsed(['latitude', 'longitude'], iris.analysis.MEAN) e1_mean = e1.collapsed(['latitude', 'longitude'], iris.analysis.MEAN) a1b_mean = a1b.collapsed(['latitude', 'longitude'], iris.analysis.MEAN) # Show ticks 30 years apart plt.gca().xaxis.set_major_locator(mdates.YearLocator(30)) # Label the ticks with year data plt.gca().format_xdata = mdates.DateFormatter('%Y') # Plot the datasets qplt.plot(e1_mean, coords=['time'], label='E1 scenario', lw=1.5, color='blue') qplt.plot(a1b_mean, coords=['time'], label='A1B-Image scenario', lw=1.5, color='red') # Draw a horizontal line showing the pre industrial mean plt.axhline(y=pre_industrial_mean.data, color='gray', linestyle='dashed', label='pre-industrial', lw=1.5) # Establish where r and t have the same data, i.e. the observations common = numpy.where(a1b_mean.data == e1_mean.data)[0] observed = a1b_mean[common] # Plot the observed data qplt.plot(observed, coords=['time'], label='observed', color='black', lw=1.5) # Add a legend and title plt.legend(loc="upper left") plt.title('North American mean air temperature', fontsize=18) plt.xlabel('Time / year') plt.grid() iplt.show()
def main(): # load a single cube of surface temperature between +/- 5 latitude fname = iris.sample_data_path("ostia_monthly.nc") 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")) iplt.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 main(): fname = iris.sample_data_path('/nfs/a266/data/CMIP5_AFRICA/BC_0.5x0.5/IPSL-CM5A-LR/historical/tasmax_WFDEI_1979-2013_0.5x0.5_day_IPSL-CM5A-LR_africa_historical_r1i1p1_full.nc') soi = iris.load_cube(fname) # Window length for filters. window = 121 # Construct 2-year (24-month) and 7-year (84-month) low pass filters # for the SOI data which is monthly. wgts24 = low_pass_weights(window, 1. / 24.) wgts84 = low_pass_weights(window, 1. / 84.) soi24 = soi.rolling_window('time', iris.analysis.SUM, len(wgts24), weights=wgts24) soi84 = soi.rolling_window('time', iris.analysis.SUM, len(wgts84), weights=wgts84) # Plot the SOI time series and both filtered versions. plt.figure(figsize=(9, 4)) iplt.plot(soi, color='0.7', linewidth=1., linestyle='-',alpha=1., label='no filter') iplt.plot(soi24, color='b', linewidth=2., linestyle='-',alpha=.7, label='2-year filter') iplt.plot(soi84, color='r', linewidth=2., linestyle='-',alpha=.7, label='7-year filter') plt.ylim([-4, 4]) plt.title('West Africa') plt.xlabel('Time') plt.ylabel('SOI') plt.legend(fontsize=10) iplt.show()
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(): fname = iris.sample_data_path('NAME_output.txt') boundary_volc_ash_constraint = iris.Constraint( 'VOLCANIC_ASH_AIR_CONCENTRATION', flight_level='From FL000 - FL200') # Callback shown as None to illustrate where a cube-level callback function would be used if required cube = iris.load_strict(fname, boundary_volc_ash_constraint, callback=None) map = iplt.map_setup(lon_range=[-70, 20], lat_range=[20, 75], resolution='i') map.drawcoastlines() iplt.contourf(cube, levels=(0.0002, 0.002, 0.004, 1), colors=('#80ffff', '#939598', '#e00404'), extend='max') time = cube.coord('time') time_date = time.units.num2date(time.points[0]).strftime(UTC_format) plt.title('Volcanic ash concentration forecast\nvalid at %s' % time_date) 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 a single cube of surface temperature between +/- 5 latitude fname = iris.sample_data_path('ostia_monthly.nc') 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')) iplt.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 testSetPlotpcolormeshLargeRange(self): cube = iris.load_cube(iris.sample_data_path('air_temp.pp')) plt.subplot(1,2,1) cc.setPlot(cube, "pcolormesh", "brewer_Blues_09", 15, True, 400, 200) plt.subplot(1,2,2) qplt.pcolormesh(cube, cmap="brewer_Blues_09", vmin=200, vmax=400) plt.show()
def testSetPlotpcolormeshPlain(self): cube = iris.load_cube(iris.sample_data_path('air_temp.pp')) plt.subplot(1,2,1) cc.setPlot(cube, "pcolormesh", "Automatic", 15, False, None, None) plt.subplot(1,2,2) qplt.pcolormesh(cube) plt.show()
def testSetPlotContourPlain(self): cube = iris.load_cube(iris.sample_data_path('air_temp.pp')) plt.subplot(1,2,1) cc.setPlot(cube, "Contour", "Automatic", 15, False, None, None) plt.subplot(1,2,2) qplt.contour(cube, 15) plt.show()
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 test_glob_ok(self): sample_path = _temp_file(self.sample_dir) sample_glob = '?' + os.path.basename(sample_path)[1:] with mock.patch('iris_sample_data.path', self.sample_dir): result = sample_data_path(sample_glob) self.assertEqual(result, os.path.join(self.sample_dir, sample_glob))
def main(): fname = iris.sample_data_path("NAME_output.txt") boundary_volc_ash_constraint = iris.Constraint("VOLCANIC_ASH_AIR_CONCENTRATION", flight_level="From FL000 - FL200") # Callback shown as None to illustrate where a cube-level callback function would be used if required cube = iris.load_cube(fname, boundary_volc_ash_constraint, callback=None) # draw contour levels for the data (the top level is just a catch-all) levels = (0.0002, 0.002, 0.004, 1e10) cs = iplt.contourf(cube, levels=levels, colors=("#80ffff", "#939598", "#e00404")) # draw a black outline at the lowest contour to highlight affected areas iplt.contour(cube, levels=(levels[0], 100), colors="black") # set an extent and a background image for the map ax = plt.gca() ax.set_extent((-90, 20, 20, 75)) ax.stock_img("ne_shaded") # make a legend, with custom labels, for the coloured contour set artists, _ = cs.legend_elements() labels = [ r"$%s < x \leq %s$" % (levels[0], levels[1]), r"$%s < x \leq %s$" % (levels[1], levels[2]), r"$x > %s$" % levels[2], ] ax.legend(artists, labels, title="Ash concentration / g m-3", loc="upper left") time = cube.coord("time") time_date = time.units.num2date(time.points[0]).strftime(UTC_format) plt.title("Volcanic ash concentration forecast\nvalid at %s" % time_date) iplt.show()
def main(): # 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 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('A1B_north_america.nc') cube = iris.load_cube(fname) # Extract a single time series at a latitude and longitude point. location = next(cube.slices(['time'])) # Calculate a polynomial fit to the data at this time series. x_points = location.coord('time').points y_points = location.data degree = 2 p = np.polyfit(x_points, y_points, degree) y_fitted = np.polyval(p, x_points) # Add the polynomial fit values to the time series to take # full advantage of Iris plotting functionality. long_name = 'degree_{}_polynomial_fit_of_{}'.format(degree, cube.name()) fit = iris.coords.AuxCoord(y_fitted, long_name=long_name, units=location.units) location.add_aux_coord(fit, 0) qplt.plot(location.coord('time'), location, label='data') qplt.plot(location.coord('time'), location.coord(long_name), 'g-', label='polynomial fit') plt.legend(loc='best') plt.title('Trend of US air temperature over time') qplt.show()
def main(): # Load data filepath = iris.sample_data_path('orca2_votemper.nc') cube = iris.load_cube(filepath) # Choose plot projections projections = {} projections['Mollweide'] = ccrs.Mollweide() projections['PlateCarree'] = ccrs.PlateCarree() projections['NorthPolarStereo'] = ccrs.NorthPolarStereo() projections['Orthographic'] = ccrs.Orthographic(central_longitude=-90, central_latitude=45) pcarree = projections['PlateCarree'] # Transform cube to target projection new_cube, extent = iris.analysis.cartography.project(cube, pcarree, nx=400, ny=200) # Plot data in each projection for name in sorted(projections): fig = plt.figure() fig.suptitle('ORCA2 Data Projected to {}'.format(name)) # Set up axes and title ax = plt.subplot(projection=projections[name]) # Set limits ax.set_global() # plot with Iris quickplot pcolormesh qplt.pcolormesh(new_cube) # Draw coastlines ax.coastlines() 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 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 main(): fname = iris.sample_data_path('air_temp.pp') # Load exactly one cube from the given file. temperature = iris.load_cube(fname) # We only want a small number of latitudes, so filter some out # using "extract". temperature = temperature.extract( iris.Constraint(latitude=lambda cell: 68 <= cell < 78)) for cube in temperature.slices('longitude'): # Create a string label to identify this cube (i.e. latitude: value). cube_label = 'latitude: %s' % cube.coord('latitude').points[0] # Plot the cube, and associate it with a label. qplt.plot(cube, label=cube_label) # Add the legend with 2 columns. plt.legend(ncol=2) # Put a grid on the plot. plt.grid(True) # Tell matplotlib not to extend the plot axes range to nicely # rounded numbers. plt.axis('tight') # Finally, show it. plt.show()
def testPlot1DwithoutGridlines(self): cube = iris.load_cube(iris.sample_data_path('SOI_Darwin.nc')) plt.subplot(1,2,1) cc.plot1D(cube, False) plt.subplot(1,2,2) qplt.plot(cube) plt.show()
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 __init__(self, initial_value=''): if initial_value == '': try: initial_value = iris.sample_data_path('') except ValueError: initial_value = '' # Define the file system path for input files. self._path = ipywidgets.Text(description='Path:', value=initial_value, width="100%") # Observe the path. self._path.observe(self._handle_path, names='value') # Use default path value to initialise file options. options = [] if os.path.exists(self._path.value): options = glob.glob('{}/*'.format(self._path.value)) options.sort() # Defines the files selected to be loaded. self._files = ipywidgets.SelectMultiple(description='Files:', options=OrderedDict([ (os.path.basename(f), f) for f in options ]), width="100%") self._box = ipywidgets.Box(children=[self._path, self._files], width="100%")
def main(): # Load some test data. fname = iris.sample_data_path("A1B_north_america.nc") cube = iris.load_cube(fname) # Extract a single time series at a latitude and longitude point. location = next(cube.slices(["time"])) # Calculate a polynomial fit to the data at this time series. x_points = location.coord("time").points y_points = location.data degree = 2 p = np.polyfit(x_points, y_points, degree) y_fitted = np.polyval(p, x_points) # Add the polynomial fit values to the time series to take # full advantage of Iris plotting functionality. long_name = "degree_{}_polynomial_fit_of_{}".format(degree, cube.name()) fit = iris.coords.AuxCoord(y_fitted, long_name=long_name, units=location.units) location.add_aux_coord(fit, 0) qplt.plot(location.coord("time"), location, label="data") qplt.plot( location.coord("time"), location.coord(long_name), "g-", label="polynomial fit", ) plt.legend(loc="best") plt.title("Trend of US air temperature over time") qplt.show()
def __init__(self, initial_value=''): if initial_value == '': try: initial_value = iris.sample_data_path('') except ValueError: initial_value = '' # Define the file system path for input files. self._path = ipywidgets.Text( description='Path:', value=initial_value, width="100%") # Observe the path. self._path.observe(self._handle_path, names='value') # Use default path value to initialise file options. options = [] if os.path.exists(self._path.value): options = glob.glob('{}/*'.format(self._path.value)) options.sort() # Defines the files selected to be loaded. self._files = ipywidgets.SelectMultiple( description='Files:', options=OrderedDict([(os.path.basename(f), f) for f in options]), width="100%" ) self._box = ipywidgets.Box(children=[self._path, self._files], width="100%")
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(): # Load data filepath = iris.sample_data_path("orca2_votemper.nc") cube = iris.load_cube(filepath) # Choose plot projections projections = {} projections["Mollweide"] = ccrs.Mollweide() projections["PlateCarree"] = ccrs.PlateCarree() projections["NorthPolarStereo"] = ccrs.NorthPolarStereo() projections["Orthographic"] = ccrs.Orthographic(central_longitude=-90, central_latitude=45) pcarree = projections["PlateCarree"] # Transform cube to target projection new_cube, extent = iris.analysis.cartography.project(cube, pcarree, nx=400, ny=200) # Plot data in each projection for name in sorted(projections): fig = plt.figure() fig.suptitle("ORCA2 Data Projected to {}".format(name)) # Set up axes and title ax = plt.subplot(projection=projections[name]) # Set limits ax.set_global() # plot with Iris quickplot pcolormesh qplt.pcolormesh(new_cube) # Draw coastlines ax.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") 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 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 gridded temperature and salinity data. fname = iris.sample_data_path('atlantic_profiles.nc') cubes = iris.load(fname) theta, = cubes.extract('sea_water_potential_temperature') salinity, = cubes.extract('sea_water_practical_salinity') # Extract profiles of temperature and salinity from a particular point in # the southern portion of the domain, and limit the depth of the profile # to 1000m. lon_cons = iris.Constraint(longitude=330.5) lat_cons = iris.Constraint(latitude=lambda l: -10 < l < -9) depth_cons = iris.Constraint(depth=lambda d: d <= 1000) theta_1000m = theta.extract(depth_cons & lon_cons & lat_cons) salinity_1000m = salinity.extract(depth_cons & lon_cons & lat_cons) # Plot these profiles on the same set of axes. In each case we call plot # with two arguments, the cube followed by the depth coordinate. Putting # them in this order places the depth coordinate on the y-axis. # The first plot is in the default axes. We'll use the same color for the # curve and its axes/tick labels. plt.figure(figsize=(5, 6)) temperature_color = (.3, .4, .5) ax1 = plt.gca() iplt.plot(theta_1000m, theta_1000m.coord('depth'), linewidth=2, color=temperature_color, alpha=.75) ax1.set_xlabel('Potential Temperature / K', color=temperature_color) ax1.set_ylabel('Depth / m') for ticklabel in ax1.get_xticklabels(): ticklabel.set_color(temperature_color) # To plot salinity in the same axes we use twiny(). We'll use a different # color to identify salinity. salinity_color = (.6, .1, .15) ax2 = plt.gca().twiny() iplt.plot(salinity_1000m, salinity_1000m.coord('depth'), linewidth=2, color=salinity_color, alpha=.75) ax2.set_xlabel('Salinity / PSU', color=salinity_color) for ticklabel in ax2.get_xticklabels(): ticklabel.set_color(salinity_color) plt.tight_layout() iplt.show() # Now plot a T-S diagram using scatter. We'll use all the profiles here, # and each point will be coloured according to its depth. plt.figure(figsize=(6, 6)) depth_values = theta.coord('depth').points for s, t in iris.iterate.izip(salinity, theta, coords='depth'): iplt.scatter(s, t, c=depth_values, marker='+', cmap='RdYlBu_r') ax = plt.gca() ax.set_xlabel('Salinity / PSU') ax.set_ylabel('Potential Temperature / K') cb = plt.colorbar(orientation='horizontal') cb.set_label('Depth / m') plt.tight_layout() iplt.show()
def testSetPlotContourLargeRange(self): cube = iris.load_cube(iris.sample_data_path('air_temp.pp')) plt.subplot(1,2,1) cc.setPlot(cube, "Contour", "brewer_Blues_09", 15, True, 400, 200) plt.subplot(1,2,2) contours = qplt.contour(cube, 15, cmap="brewer_Blues_09", vmin=200, vmax=400) plt.clabel(contours, inline=1, fontsize=8) 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 main(): file_path = iris.sample_data_path("toa_brightness_stereographic.nc") cube = iris.load_cube(file_path) qplt.contourf(cube) ax = plt.gca() ax.coastlines() ax.gridlines() iplt.show()
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 test_call(self): try: sample_file = _temp_file(self.sample_dir) with mock.patch('iris_sample_data.path', self.sample_dir): import iris_sample_data result = sample_data_path(os.path.basename(sample_file)) self.assertEqual(result, sample_file) except ImportError: pass
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 main(): # Load the monthly-valued Southern Oscillation Index (SOI) time-series. fname = iris.sample_data_path("SOI_Darwin.nc") soi = iris.load_cube(fname) # Window length for filters. window = 121 # Construct 2-year (24-month) and 7-year (84-month) low pass filters # for the SOI data which is monthly. wgts24 = low_pass_weights(window, 1.0 / 24.0) wgts84 = low_pass_weights(window, 1.0 / 84.0) # Apply each filter using the rolling_window method used with the weights # keyword argument. A weighted sum is required because the magnitude of # the weights are just as important as their relative sizes. soi24 = soi.rolling_window("time", iris.analysis.SUM, len(wgts24), weights=wgts24) soi84 = soi.rolling_window("time", iris.analysis.SUM, len(wgts84), weights=wgts84) # Plot the SOI time series and both filtered versions. plt.figure(figsize=(9, 4)) iplt.plot( soi, color="0.7", linewidth=1.0, linestyle="-", alpha=1.0, label="no filter", ) iplt.plot( soi24, color="b", linewidth=2.0, linestyle="-", alpha=0.7, label="2-year filter", ) iplt.plot( soi84, color="r", linewidth=2.0, linestyle="-", alpha=0.7, label="7-year filter", ) plt.ylim([-4, 4]) plt.title("Southern Oscillation Index (Darwin Only)") plt.xlabel("Time") plt.ylabel("SOI") plt.legend(fontsize=10) iplt.show()
def main(): # Load data into three Cubes, one for each set of PP files e1 = iris.load_cube(iris.sample_data_path("E1_north_america.nc")) a1b = iris.load_cube(iris.sample_data_path("A1B_north_america.nc")) # load in the global pre-industrial mean temperature, and limit the domain to # the same North American region that e1 and a1b are at. north_america = iris.Constraint(longitude=lambda v: 225 <= v <= 315, latitude=lambda v: 15 <= v <= 60) pre_industrial = iris.load_cube(iris.sample_data_path("pre-industrial.pp"), north_america) pre_industrial_mean = pre_industrial.collapsed(["latitude", "longitude"], iris.analysis.MEAN) e1_mean = e1.collapsed(["latitude", "longitude"], iris.analysis.MEAN) a1b_mean = a1b.collapsed(["latitude", "longitude"], iris.analysis.MEAN) # Show ticks 30 years apart plt.gca().xaxis.set_major_locator(mdates.YearLocator(30)) # Label the ticks with year data plt.gca().format_xdata = mdates.DateFormatter("%Y") # Plot the datasets qplt.plot(e1_mean, coords=["time"], label="E1 scenario", lw=1.5, color="blue") qplt.plot(a1b_mean, coords=["time"], label="A1B-Image scenario", lw=1.5, color="red") # Draw a horizontal line showing the pre industrial mean plt.axhline(y=pre_industrial_mean.data, color="gray", linestyle="dashed", label="pre-industrial", lw=1.5) # Establish where r and t have the same data, i.e. the observations common = np.where(a1b_mean.data == e1_mean.data)[0] observed = a1b_mean[common] # Plot the observed data qplt.plot(observed, coords=["time"], label="observed", color="black", lw=1.5) # Add a legend and title plt.legend(loc="upper left") plt.title("North American mean air temperature", fontsize=18) plt.xlabel("Time / year") plt.grid() iplt.show()
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"], ) # For the purposes of this example, we only want to demonstrate the first # plot. lat_lon_slice_pairs = [next(lat_lon_slice_pairs)] 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) iplt.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 the monthly-valued Southern Oscillation Index (SOI) time-series. fname = iris.sample_data_path('SOI_Darwin.nc') soi = iris.load_cube(fname) # Window length for filters. window = 121 # Construct 2-year (24-month) and 7-year (84-month) low pass filters # for the SOI data which is monthly. wgts24 = low_pass_weights(window, 1. / 24.) wgts84 = low_pass_weights(window, 1. / 84.) # Apply each filter using the rolling_window method used with the weights # keyword argument. A weighted sum is required because the magnitude of # the weights are just as important as their relative sizes. soi24 = soi.rolling_window('time', iris.analysis.SUM, len(wgts24), weights=wgts24) soi84 = soi.rolling_window('time', iris.analysis.SUM, len(wgts84), weights=wgts84) # Plot the SOI time series and both filtered versions. plt.figure(figsize=(9, 4)) iplt.plot(soi, color='0.7', linewidth=1., linestyle='-', alpha=1., label='no filter') iplt.plot(soi24, color='b', linewidth=2., linestyle='-', alpha=.7, label='2-year filter') iplt.plot(soi84, color='r', linewidth=2., linestyle='-', alpha=.7, label='7-year filter') plt.ylim([-4, 4]) plt.title('Southern Oscillation Index (Darwin Only)') plt.xlabel('Time') plt.ylabel('SOI') plt.legend(fontsize=10) iplt.show()
def main(): fname = iris.sample_data_path('air_temp.pp') temperature_orig = iris.load_cube(fname) temperature_noisy = copy.deepcopy(temperature_orig) sx = (temperature_orig.data.shape)[0] sy = (temperature_orig.data.shape)[1] gaussian_noise = np.random.normal(loc=0.0, scale=5, size=(sx, sy)) gaussian_noise[:sx/4, :] = 0 gaussian_noise[(3*sx)/4:, :] = 0 gaussian_noise[:, sy/4:(3*sy)/4] = 0 temperature_noisy.data = 2*temperature_noisy.data + gaussian_noise #Original data plt.figure(figsize=(12, 5)) plt.subplot(221) qplt.contourf(temperature_orig, 15) plt.gca().coastlines() #Noisy data plt.subplot(222) qplt.contourf(temperature_noisy, 15) plt.gca().coastlines() # Plot scatter scatter_x = temperature_orig.data.flatten() scatter_y = temperature_noisy.data.flatten() plt.subplot(223) plt.plot(scatter_x, scatter_y, '.', label="scatter") coeffs = np.polyfit(scatter_x, scatter_y, 1) print(coeffs) plt.title("Scatter plot") plt.xlabel("orig [K]") plt.ylabel("noisy [K]") fitted_y = np.polyval(coeffs, scatter_x) plt.plot(scatter_x, fitted_y, 'k', label="fit") plt.text(np.min(scatter_x), np.max(fitted_y), "\nax+b\na=%f3\nb=%g4" % (coeffs[0], coeffs[1])) #Plot diff_y = scatter_y - fitted_y temperature_diff = copy.deepcopy(temperature_orig) temperature_diff.data = diff_y.reshape(temperature_noisy.data.shape) temperature_diff.standard_name = None temperature_diff.long_name = "Residual from fitted curve" temperature_diff.var_name = "Hello_World" plt.subplot(224) qplt.contourf(temperature_diff, 15) plt.gca().coastlines() iplt.show()
def main(): # load the monthly-valued Southern Oscillation Index (SOI) time-series fname = iris.sample_data_path('SOI_Darwin.nc') soi = iris.load_cube(fname) # window length for filters window = 121 # construct 2-year (24-month) and 7-year (84-month) low pass filters # for the SOI data which is monthly wgts24 = low_pass_weights(window, 1. / 24.) # wgts84 = low_pass_weights(window, 1. / 84.) # apply the filters using the rolling_window method with the weights # keyword argument soi24 = soi.rolling_window('time', iris.analysis.MEAN, len(wgts24), weights=wgts24) soi84 = soi.rolling_window('time', iris.analysis.MEAN, len(wgts84), weights=wgts84) # plot the SOI time series and both filtered versions fig = plt.figure(figsize=(9, 4)) iplt.plot(soi, coords=['time'], color='0.7', linewidth=1., linestyle='-', alpha=1., label='no filter') iplt.plot(soi24, coords=['time'], color='b', linewidth=2., linestyle='-', alpha=.7, label='2-year filter') iplt.plot(soi84, coords=['time'], color='r', linewidth=2., linestyle='-', alpha=.7, label='7-year filter') plt.ylim([-4, 4]) plt.title('Southern Oscillation Index (Darwin Only)') plt.xlabel('Time') plt.ylabel('SOI') plt.legend(fontsize=10) plt.show()
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 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 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_trajectory(self): cube = iris.load_cube(iris.sample_data_path('air_temp.pp')) # extract a trajectory xpoint = cube.coord('longitude').points[:10] ypoint = cube.coord('latitude').points[:10] sample_points = [('latitude', xpoint), ('longitude', ypoint)] traj = iris.analysis.trajectory.interpolate(cube, sample_points) # save, reload and check with self.temp_filename(suffix='.nc') as temp_filename: iris.save(traj, temp_filename) reloaded = iris.load_cube(temp_filename) self.assertCML(reloaded, ('netcdf', 'save_load_traj.cml'))
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_strict( fname, constraints) # define a coordinate which represents 1000 hPa p0 = coords.AuxCoord(100000, long_name='P0', units='Pa') # calculate Exner pressure exner_pressure = (air_pressure / p0)**(287.05 / 1005.0) # set the standard name (the unit is scalar) exner_pressure.rename('exner_pressure') # calculate air_temp air_temperature = exner_pressure * air_potential_temperature # set phenomenon definition and unit air_temperature.standard_name = 'air_temperature' air_temperature.units = 'K' # 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 = itertools.izip( exner_pressure.slices(['grid_latitude', 'grid_longitude']), air_temperature.slices(['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 draw(geoaxes): import iris import iris.plot as iplt # Add some high-resolution coastlines so we can produce nice results # even when zoomed a long way in. geoaxes.coastlines('10m') fname = iris.sample_data_path('rotated_pole.nc') temperature = iris.load_cube(fname) iplt.pcolormesh(temperature) # Do the initial draw so that the coastlines are projected # (the slow part). plt.draw()
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()