def test_non_cube_coordinate(self): cube = self.cube[0, :, :, 0] pts = -100 + np.arange(cube.shape[1]) * 13 x = coords.DimCoord( pts, standard_name="model_level_number", attributes={"positive": "up"}, units="1", ) self.draw("contourf", cube, coords=["grid_latitude", x])
def setup(self): repeat_number = 10 repeat_range = range(int(ARTIFICIAL_DIM_SIZE / repeat_number)) array_repeat = np.repeat(repeat_range, repeat_number) array_unique = np.arange(len(array_repeat)) coord_repeat = coords.AuxCoord(points=array_repeat, long_name="repeat") coord_unique = coords.DimCoord(points=array_unique, long_name="unique") local_cube = general_cube.copy() local_cube.add_aux_coord(coord_repeat, 0) local_cube.add_dim_coord(coord_unique, 0) self.cube = local_cube
def realistic_3d(): """ Returns a realistic 3d cube. >>> print(repr(realistic_3d())) <iris 'Cube' of air_potential_temperature (time: 7; grid_latitude: 9; grid_longitude: 11)> """ data = np.arange(7 * 9 * 11).reshape((7, 9, 11)) lat_pts = np.linspace(-4, 4, 9) lon_pts = np.linspace(-5, 5, 11) time_pts = np.linspace(394200, 394236, 7) forecast_period_pts = np.linspace(0, 36, 7) ll_cs = RotatedGeogCS(37.5, 177.5, ellipsoid=GeogCS(6371229.0)) lat = icoords.DimCoord(lat_pts, standard_name='grid_latitude', units='degrees', coord_system=ll_cs) lon = icoords.DimCoord(lon_pts, standard_name='grid_longitude', units='degrees', coord_system=ll_cs) time = icoords.DimCoord(time_pts, standard_name='time', units='hours since 1970-01-01 00:00:00') forecast_period = icoords.DimCoord(forecast_period_pts, standard_name='forecast_period', units='hours') height = icoords.DimCoord(1000.0, standard_name='air_pressure', units='Pa') cube = iris.cube.Cube(data, standard_name='air_potential_temperature', units='K', dim_coords_and_dims=[(time, 0), (lat, 1), (lon, 2)], aux_coords_and_dims=[(forecast_period, 0), (height, None)], attributes={'source': 'Iris test case'}) return cube
def make_time_coord(coord_dict): from datetime import datetime,timedelta from iris import coords timestr=str(int(coord_dict['iyear1'][0]))+str(int(coord_dict['imonth1'][0])).zfill(2)+str(int(coord_dict['idate1'][0])).zfill(2)+str(int(coord_dict['itime1'][0])).zfill(4) timeobj = datetime.strptime(timestr,"%Y%m%d%H%M")+timedelta(seconds=1)*coord_dict['time'][0] if timeobj<datetime(100,1,1): base_date=datetime(1,1,1) else: base_date=datetime(1970,1,1) time_units='days since '+ base_date.strftime('%Y-%m-%d') time_days=(timeobj - base_date).total_seconds() / timedelta(days=1).total_seconds() time_coord=coords.DimCoord(time_days, standard_name='time', long_name='time', var_name='time', units=time_units, bounds=None, attributes=None, coord_system=None, circular=False) return time_coord
def setup(self): # Manufacture data from which contours can be derived. # Should generate 10 distinct contours, regardless of dim size. dim_size = int(ARTIFICIAL_DIM_SIZE / 5) repeat_number = int(dim_size / 10) repeat_range = range(int((dim_size ** 2) / repeat_number)) data = np.repeat(repeat_range, repeat_number) data = data.reshape((dim_size,) * 2) # These benchmarks are from a user perspective, so setting up a # user-level case that will prompt the calling of aux_coords.sort in plot.py. dim_coord = coords.DimCoord(np.arange(dim_size)) local_cube = cube.Cube(data) local_cube.add_aux_coord(dim_coord, 0) self.cube = local_cube
def realistic_3d(): data = np.arange(7 * 9 * 11).reshape((7, 9, 11)) lat_pts = np.linspace(-4, 4, 9) lon_pts = np.linspace(-5, 5, 11) time_pts = np.linspace(394200, 394236, 7) forecast_period_pts = np.linspace(0, 36, 7) ll_cs = RotatedGeogCS(37.5, 177.5, ellipsoid=GeogCS(6371229.0)) lat = icoords.DimCoord( lat_pts, standard_name="grid_latitude", units="degrees", coord_system=ll_cs, ) lon = icoords.DimCoord( lon_pts, standard_name="grid_longitude", units="degrees", coord_system=ll_cs, ) time = icoords.DimCoord(time_pts, standard_name="time", units="hours since 1970-01-01 00:00:00") forecast_period = icoords.DimCoord(forecast_period_pts, standard_name="forecast_period", units="hours") height = icoords.DimCoord(1000.0, standard_name="air_pressure", units="Pa") cube = iris.cube.Cube( data, standard_name="air_potential_temperature", units="K", dim_coords_and_dims=[(time, 0), (lat, 1), (lon, 2)], aux_coords_and_dims=[(forecast_period, 0), (height, None)], attributes={"source": "Iris test case"}, ) return cube
def hybrid_height(): """ Returns a two-dimensional (Z, X), hybrid-height cube. >>> print hybrid_height() TODO: Update! air_temperature (level_height: 3; *ANONYMOUS*: 4) Dimension coordinates: level_height x - Auxiliary coordinates: model_level_number x - sigma x - surface_altitude - x Derived coordinates: altitude x x >>> print hybrid_height().data [[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] """ data = np.arange(12, dtype='i8').reshape((3, 4)) orography = icoords.AuxCoord([10, 25, 50, 5], standard_name='surface_altitude', units='m') model_level = icoords.AuxCoord([2, 1, 0], standard_name='model_level_number') level_height = icoords.DimCoord([100, 50, 10], long_name='level_height', units='m', attributes={'positive': 'up'}, bounds=[[150, 75], [75, 20], [20, 0]]) sigma = icoords.AuxCoord([0.8, 0.9, 0.95], long_name='sigma', bounds=[[0.7, 0.85], [0.85, 0.97], [0.97, 1.0]]) hybrid_height = iris.aux_factory.HybridHeightFactory( level_height, sigma, orography) cube = iris.cube.Cube(data, standard_name='air_temperature', units='K', dim_coords_and_dims=[(level_height, 0)], aux_coords_and_dims=[(orography, 1), (model_level, 0), (sigma, 0)], aux_factories=[hybrid_height]) return cube
def add_dim_coordinates(filename, variable,variable_cube,variable_dict, coord_dict,domain,add_coordinates=None): from iris import coords import numpy as np # from iris import coord_systems # coord_system=coord_systems.LambertConformal(central_lat=MOAD_CEN_LAT, central_lon=CEN_LON, false_easting=0.0, false_northing=0.0, secant_latitudes=(TRUELAT1, TRUELAT2)) coord_system=None if (variable_dict[variable]==3): time_coord=make_time_coord(coord_dict) variable_cube.add_aux_coord(time_coord) z_coord=coords.DimCoord(coord_dict['ztn01'], standard_name='geopotential_height', long_name='z', var_name='z', units='m', bounds=None, attributes=None, coord_system=coord_system) variable_cube.add_dim_coord(z_coord,0) model_level_number_coord=make_model_level_number_coordinate(len(z_coord.points)) variable_cube.add_aux_coord(model_level_number_coord,0) x_coord=coords.DimCoord(np.arange(len(coord_dict['xtn0'+domain])), long_name='x', units='1', bounds=None, attributes=None, coord_system=coord_system) variable_cube.add_dim_coord(x_coord,2) y_coord=coords.DimCoord(np.arange(len(coord_dict['ytn0'+domain])), long_name='y', units='1', bounds=None, attributes=None, coord_system=coord_system) variable_cube.add_dim_coord(y_coord,1) projection_x_coord=coords.DimCoord(coord_dict['xtn0'+domain], standard_name='projection_x_coordinate', long_name='x', var_name='x', units='m', bounds=None, attributes=None, coord_system=coord_system) variable_cube.add_aux_coord(projection_x_coord,(2)) projection_y_coord=coords.DimCoord(coord_dict['ytn0'+domain], standard_name='projection_y_coordinate', long_name='y', var_name='y', units='m', bounds=None, attributes=None, coord_system=coord_system) variable_cube.add_aux_coord(projection_y_coord,(1)) elif (variable_dict[variable]==2): x_coord=coords.DimCoord(np.arange(len(coord_dict['xtn0'+domain])), long_name='x', units='1', bounds=None, attributes=None, coord_system=coord_system) variable_cube.add_dim_coord(x_coord,1) y_coord=coords.DimCoord(np.arange(len(coord_dict['ytn0'+domain])), long_name='y', units='1', bounds=None, attributes=None, coord_system=coord_system) variable_cube.add_dim_coord(y_coord,0) projection_x_coord=coords.DimCoord(coord_dict['xtn0'+domain], standard_name='projection_x_coordinate', long_name='x', var_name='x', units='m', bounds=None, attributes=None, coord_system=coord_system) variable_cube.add_aux_coord(projection_x_coord,(1)) projection_y_coord=coords.DimCoord(coord_dict['ytn0'+domain], standard_name='projection_y_coordinate', long_name='y', var_name='y', units='m', bounds=None, attributes=None, coord_system=coord_system) variable_cube.add_aux_coord(projection_y_coord,(0)) time_coord=make_time_coord(coord_dict) variable_cube.add_aux_coord(time_coord) return variable_cube
def NAME_to_cube(filenames, callback): """Returns a generator of cubes given a list of filenames and a callback.""" for filename in filenames: header, column_headings, data_arrays = load_NAME_III(filename) for i, data_array in enumerate(data_arrays): # turn the dictionary of column headers with a list of header information for each field into a dictionary of # headers for just this field. Ignore the first 4 columns of grid position (data was located with the data array). field_headings = dict([(k, v[i + 4]) for k, v in column_headings.iteritems()]) # make an cube cube = iris.cube.Cube(data_array) # define the name and unit name = ('%s %s' % (field_headings['species'], field_headings['quantity'])).upper().replace( ' ', '_') cube.rename(name) # Some units are badly encoded in the file, fix this by putting a space in between. (if gs is not found, then the # string will be returned unchanged) cube.units = field_headings['unit'].replace('gs', 'g s') # define and add the singular coordinates of the field (flight level, time etc.) cube.add_aux_coord( icoords.AuxCoord(field_headings['z_level'], long_name='flight_level', units='1')) # define the time unit and use it to serialise the datetime for the time coordinate time_unit = iris.unit.Unit('hours since epoch', calendar=iris.unit.CALENDAR_GREGORIAN) time_coord = icoords.AuxCoord(time_unit.date2num( field_headings['time']), standard_name='time', units=time_unit) cube.add_aux_coord(time_coord) # build a coordinate system which can be referenced by latitude and longitude coordinates lat_lon_coord_system = icoord_systems.LatLonCS( icoord_systems.SpheroidDatum("spherical", 6371229.0, flattening=0.0, units='m'), icoord_systems.PrimeMeridian(label="Greenwich", value=0.0), n_pole=icoord_systems.GeoPosition(90, 0), reference_longitude=0.0) # build regular latitude and longitude coordinates which have bounds start = header['X grid origin'] + header['X grid resolution'] step = header['X grid resolution'] count = header['X grid size'] pts = start + numpy.arange(count, dtype=numpy.float32) * step lon_coord = icoords.DimCoord(pts, standard_name='longitude', units='degrees', coord_system=lat_lon_coord_system) lon_coord.guess_bounds() start = header['Y grid origin'] + header['Y grid resolution'] step = header['Y grid resolution'] count = header['Y grid size'] pts = start + numpy.arange(count, dtype=numpy.float32) * step lat_coord = icoords.DimCoord(pts, standard_name='latitude', units='degrees', coord_system=lat_lon_coord_system) lat_coord.guess_bounds() # add the latitude and longitude coordinates to the cube, with mappings to data dimensions cube.add_dim_coord(lat_coord, 0) cube.add_dim_coord(lon_coord, 1) # implement standard iris callback capability. Although callbacks are not used in this example, the standard # mechanism for a custom loader to implement a callback is shown: cube = iris.io.run_callback(callback, cube, [header, field_headings, data_array], filename) # yield the cube created (the loop will continue when the next() element is requested) yield cube
def realistic_4d(): """ Returns a realistic 4d cube. >>> print repr(realistic_4d()) <iris 'Cube' of air_potential_temperature (time: 6; model_level_number: 70; grid_latitude: 100; grid_longitude: 100)> """ # the stock arrays were created in Iris 0.8 with: # >>> fname = iris.sample_data_path('PP', 'COLPEX', 'theta_and_orog_subset.pp') # >>> theta = iris.load_cube(fname, 'air_potential_temperature') # >>> for coord in theta.coords(): # ... print coord.name, coord.has_points(), coord.has_bounds(), coord.units # ... # grid_latitude True True degrees # grid_longitude True True degrees # level_height True True m # model_level True False 1 # sigma True True 1 # time True False hours since 1970-01-01 00:00:00 # source True False no_unit # forecast_period True False hours # >>> arrays = [] # >>> for coord in theta.coords(): # ... if coord.has_points(): arrays.append(coord.points) # ... if coord.has_bounds(): arrays.append(coord.bounds) # >>> arrays.append(theta.data) # >>> arrays.append(theta.coord('sigma').coord_system.orography.data) # >>> np.savez('stock_arrays.npz', *arrays) data_path = os.path.join(os.path.dirname(__file__), 'stock_arrays.npz') r = np.load(data_path) # sort the arrays based on the order they were originally given. The names given are of the form 'arr_1' or 'arr_10' _, arrays = zip(*sorted(r.iteritems(), key=lambda item: int(item[0][4:]))) lat_pts, lat_bnds, lon_pts, lon_bnds, level_height_pts, \ level_height_bnds, model_level_pts, sigma_pts, sigma_bnds, time_pts, \ _source_pts, forecast_period_pts, data, orography = arrays ll_cs = RotatedGeogCS(37.5, 177.5, ellipsoid=GeogCS(6371229.0)) lat = icoords.DimCoord(lat_pts, standard_name='grid_latitude', units='degrees', bounds=lat_bnds, coord_system=ll_cs) lon = icoords.DimCoord(lon_pts, standard_name='grid_longitude', units='degrees', bounds=lon_bnds, coord_system=ll_cs) level_height = icoords.DimCoord(level_height_pts, long_name='level_height', units='m', bounds=level_height_bnds, attributes={'positive': 'up'}) model_level = icoords.DimCoord(model_level_pts, standard_name='model_level_number', units='1', attributes={'positive': 'up'}) sigma = icoords.AuxCoord(sigma_pts, long_name='sigma', units='1', bounds=sigma_bnds) orography = icoords.AuxCoord(orography, standard_name='surface_altitude', units='m') time = icoords.DimCoord(time_pts, standard_name='time', units='hours since 1970-01-01 00:00:00') forecast_period = icoords.DimCoord(forecast_period_pts, standard_name='forecast_period', units='hours') hybrid_height = iris.aux_factory.HybridHeightFactory( level_height, sigma, orography) cube = iris.cube.Cube(data, standard_name='air_potential_temperature', units='K', dim_coords_and_dims=[(time, 0), (model_level, 1), (lat, 2), (lon, 3)], aux_coords_and_dims=[(orography, (2, 3)), (level_height, 1), (sigma, 1), (forecast_period, None)], attributes={'source': 'Iris test case'}, aux_factories=[hybrid_height]) return cube
#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Created on Fri Jul 7 13:16:46 2017 @author: gy11s2s """ import iris import iris.coords as icoords import numpy as np import matplotlib.pyplot as plt import pandas as pd level_number_coord = icoords.DimCoord(range(1, 86), standard_name='model_level_number') model_height = np.loadtxt( '/nfs/see-fs-01_users/gy11s2s/Python/Layers_over_time_analysis/Model/model_height_levels.txt', delimiter=',') #hybrid_ht = np.array([20, 53.33334, 100, 160, 233.3333, 320, 420, 533.3334, 659.9999, 799.9999, 953.3337, 1120, 1300, 1493.333, 1700, 1920, 2153.333, 2400, 2659.999, 2933.333, 3220, 3520, 3833.333, 4160, 4500, 4853.333, 5220, 5600, 5993.333, 6400, 6820, 7253.333, 7700, 8160.001, 8633.34, 9120.007, 9620.02, 10133.37, 10660.08, 11200.16, 11753.64, 12320.55, 12900.93, 13494.88, 14102.48, 14723.88, 15359.24, 16008.82, 16672.9, 17351.9, 18046.29, 18756.7, 19483.89, 20228.78, 20992.53, 21776.51, 22582.39, 23412.16, 24268.18, 25153.22, 26070.59, 27024.11, 28018.26, 29058.23, 30150.02, 31300.54, 32517.71, 33810.59, 35189.52, 36666.24, 38254.03, 39967.93, 41824.85, 43843.83, 46046.21, 48455.83, 51099.35, 54006.43,57210.02,60746.7,64656.96,68985.52,73781.77,79100.02,85000]) MLO_data = iris.load_cube( '/nfs/see-fs-01_users/gy11s2s/Python/Layers_over_time_analysis/model_extinction_sites/Extinction_550nm_site_10.nc' ) x = np.array(range(0, 3600)) #TIME FOR WHOLE RANGE OF MODEL DATA # Setting time to 3600(240(10 days x 3 x 8 points/day) x 15 (number of months Dec1990-Feb1992))/120 = 30 # 1-30 = Dec1990, 31-60 = Jan1991 etc... time = (x / 240) # Each month has an index e.g. 0 = Dec1990 months = [ 'Dec 1990', 'Jan 1991', 'Feb 1991', 'Mar 1991', 'Apr 1991', 'May 1991',
def realistic_4d(): """ Returns a realistic 4d cube. >>> print(repr(realistic_4d())) <iris 'Cube' of air_potential_temperature (time: 6; model_level_number: 70; grid_latitude: 100; grid_longitude: 100)> """ data_path = tests.get_data_path(("stock", "stock_arrays.npz")) if not os.path.isfile(data_path): raise IOError("Test data is not available at {}.".format(data_path)) r = np.load(data_path) # sort the arrays based on the order they were originally given. # The names given are of the form 'arr_1' or 'arr_10' _, arrays = zip(*sorted(r.items(), key=lambda item: int(item[0][4:]))) ( lat_pts, lat_bnds, lon_pts, lon_bnds, level_height_pts, level_height_bnds, model_level_pts, sigma_pts, sigma_bnds, time_pts, _source_pts, forecast_period_pts, data, orography, ) = arrays ll_cs = RotatedGeogCS(37.5, 177.5, ellipsoid=GeogCS(6371229.0)) lat = icoords.DimCoord( lat_pts, standard_name="grid_latitude", units="degrees", bounds=lat_bnds, coord_system=ll_cs, ) lon = icoords.DimCoord( lon_pts, standard_name="grid_longitude", units="degrees", bounds=lon_bnds, coord_system=ll_cs, ) level_height = icoords.DimCoord( level_height_pts, long_name="level_height", units="m", bounds=level_height_bnds, attributes={"positive": "up"}, ) model_level = icoords.DimCoord( model_level_pts, standard_name="model_level_number", units="1", attributes={"positive": "up"}, ) sigma = icoords.AuxCoord(sigma_pts, long_name="sigma", units="1", bounds=sigma_bnds) orography = icoords.AuxCoord(orography, standard_name="surface_altitude", units="m") time = icoords.DimCoord(time_pts, standard_name="time", units="hours since 1970-01-01 00:00:00") forecast_period = icoords.DimCoord(forecast_period_pts, standard_name="forecast_period", units="hours") hybrid_height = iris.aux_factory.HybridHeightFactory( level_height, sigma, orography) cube = iris.cube.Cube( data, standard_name="air_potential_temperature", units="K", dim_coords_and_dims=[(time, 0), (model_level, 1), (lat, 2), (lon, 3)], aux_coords_and_dims=[ (orography, (2, 3)), (level_height, 1), (sigma, 1), (forecast_period, None), ], attributes={"source": "Iris test case"}, aux_factories=[hybrid_height], ) return cube
def NAME_to_cube(filenames, callback): """ Returns a generator of cubes given a list of filenames and a callback. """ for filename in filenames: header, column_headings, data_arrays = load_NAME_III(filename) for i, data_array in enumerate(data_arrays): # turn the dictionary of column headers with a list of header # information for each field into a dictionary of headers for just # this field. Ignore the first 4 columns of grid position (data was # located with the data array). field_headings = dict( (k, v[i + 4]) for k, v in column_headings.items()) # make an cube cube = iris.cube.Cube(data_array) # define the name and unit name = "%s %s" % ( field_headings["species"], field_headings["quantity"], ) name = name.upper().replace(" ", "_") cube.rename(name) # Some units are badly encoded in the file, fix this by putting a # space in between. (if gs is not found, then the string will be # returned unchanged) cube.units = field_headings["unit"].replace("gs", "g s") # define and add the singular coordinates of the field (flight # level, time etc.) cube.add_aux_coord( icoords.AuxCoord( field_headings["z_level"], long_name="flight_level", units="1", )) # define the time unit and use it to serialise the datetime for the # time coordinate time_unit = Unit("hours since epoch", calendar=CALENDAR_GREGORIAN) time_coord = icoords.AuxCoord( time_unit.date2num(field_headings["time"]), standard_name="time", units=time_unit, ) cube.add_aux_coord(time_coord) # build a coordinate system which can be referenced by latitude and # longitude coordinates lat_lon_coord_system = icoord_systems.GeogCS(6371229) # build regular latitude and longitude coordinates which have # bounds start = header["X grid origin"] + header["X grid resolution"] step = header["X grid resolution"] count = header["X grid size"] pts = start + np.arange(count, dtype=np.float32) * step lon_coord = icoords.DimCoord( pts, standard_name="longitude", units="degrees", coord_system=lat_lon_coord_system, ) lon_coord.guess_bounds() start = header["Y grid origin"] + header["Y grid resolution"] step = header["Y grid resolution"] count = header["Y grid size"] pts = start + np.arange(count, dtype=np.float32) * step lat_coord = icoords.DimCoord( pts, standard_name="latitude", units="degrees", coord_system=lat_lon_coord_system, ) lat_coord.guess_bounds() # add the latitude and longitude coordinates to the cube, with # mappings to data dimensions cube.add_dim_coord(lat_coord, 0) cube.add_dim_coord(lon_coord, 1) # implement standard iris callback capability. Although callbacks # are not used in this example, the standard mechanism for a custom # loader to implement a callback is shown: cube = iris.io.run_callback(callback, cube, [header, field_headings, data_array], filename) # yield the cube created (the loop will continue when the next() # element is requested) yield cube
def realistic_4d(): """ Returns a realistic 4d cube. >>> print(repr(realistic_4d())) <iris 'Cube' of air_potential_temperature (time: 6; model_level_number: 70; grid_latitude: 100; grid_longitude: 100)> """ data_path = tests.get_data_path(('stock', 'stock_arrays.npz')) if not os.path.isfile(data_path): raise IOError('Test data is not available at {}.'.format(data_path)) r = np.load(data_path) # sort the arrays based on the order they were originally given. # The names given are of the form 'arr_1' or 'arr_10' _, arrays = zip(*sorted(r.items(), key=lambda item: int(item[0][4:]))) lat_pts, lat_bnds, lon_pts, lon_bnds, level_height_pts, \ level_height_bnds, model_level_pts, sigma_pts, sigma_bnds, time_pts, \ _source_pts, forecast_period_pts, data, orography = arrays ll_cs = RotatedGeogCS(37.5, 177.5, ellipsoid=GeogCS(6371229.0)) lat = icoords.DimCoord(lat_pts, standard_name='grid_latitude', units='degrees', bounds=lat_bnds, coord_system=ll_cs) lon = icoords.DimCoord(lon_pts, standard_name='grid_longitude', units='degrees', bounds=lon_bnds, coord_system=ll_cs) level_height = icoords.DimCoord(level_height_pts, long_name='level_height', units='m', bounds=level_height_bnds, attributes={'positive': 'up'}) model_level = icoords.DimCoord(model_level_pts, standard_name='model_level_number', units='1', attributes={'positive': 'up'}) sigma = icoords.AuxCoord(sigma_pts, long_name='sigma', units='1', bounds=sigma_bnds) orography = icoords.AuxCoord(orography, standard_name='surface_altitude', units='m') time = icoords.DimCoord(time_pts, standard_name='time', units='hours since 1970-01-01 00:00:00') forecast_period = icoords.DimCoord(forecast_period_pts, standard_name='forecast_period', units='hours') hybrid_height = iris.aux_factory.HybridHeightFactory( level_height, sigma, orography) cube = iris.cube.Cube(data, standard_name='air_potential_temperature', units='K', dim_coords_and_dims=[(time, 0), (model_level, 1), (lat, 2), (lon, 3)], aux_coords_and_dims=[(orography, (2, 3)), (level_height, 1), (sigma, 1), (forecast_period, None)], attributes={'source': 'Iris test case'}, aux_factories=[hybrid_height]) return cube
def test_non_cube_coordinate(self): cube = self.cube[0, :, :, 0] pts = -100 + np.arange(cube.shape[1]) * 13 x = coords.DimCoord(pts, standard_name='model_level_number', attributes={'positive': 'up'}) self.draw('contourf', cube, coords=['grid_latitude', x])
def create(self): return coords.DimCoord(**self.create_kwargs)