def test_load_file_with_captured_warnings(self): test_filename = tests.get_data_path(('NetCDF', 'testing', 'units.nc')) with warnings.catch_warnings(record=True) as filtered_warnings: with suppress_unit_warnings(): iris.load(test_filename) filtered_warnings_list = [str(w.message) for w in filtered_warnings] self.assertEqual(len(filtered_warnings_list), 0)
def test_deprecated_callbacks(self): # Tests that callback functions that return values are still supported but that warnings are generated def returns_cube(cube, field, filename): return cube def returns_no_cube(cube, field, filename): return iris.io.NO_CUBE fname = tests.get_data_path(["PP", "trui", "air_temp_init", "200812011200__qwqu12ff.initanl.pp"]) # Catch all warnings for returns_cube with warnings.catch_warnings(record=True) as generated_warnings_cube: warnings.simplefilter("always") r = iris.load(fname, callback=returns_cube) # Test that our warnings are present in the generated warnings: gen_warnings_cube = [str(x.message) for x in generated_warnings_cube] self.assertIn(iris.io.CALLBACK_DEPRECATION_MSG, gen_warnings_cube, "Callback deprecation warning message not issued.") # Catch all warnings for returns_no_cube with warnings.catch_warnings(record=True) as generated_warnings_no_cube: warnings.simplefilter("always") r = iris.load(fname, callback=returns_no_cube) # Test that our warnings are present in the generated warnings: gen_warnings_no_cube = [str(x.message) for x in generated_warnings_no_cube] self.assertIn(iris.io.CALLBACK_DEPRECATION_MSG, gen_warnings_no_cube, "Callback deprecation warning message not issued.")
def test_unhandled_grid_type(self): self.filename = tests.get_data_path(("FF", "n48_multi_field")) with self.temp_filename() as temp_path: shutil.copyfile(self.filename, temp_path) ffv = um.FieldsFileVariant(temp_path, mode=um.FieldsFileVariant.UPDATE_MODE) ffv.fields[3].lbuser4 = 60 ffv.close() with mock.patch("warnings.warn") as warn_fn: iris.load(temp_path) self.assertIn("Assuming the data is on a P grid.", warn_fn.call_args[0][0])
def test_load(self): cubes = iris.load(tests.get_data_path(('GRIB', 'rotated_uk', "uk_wrongparam.grib1"))) self.assertCML(cubes, ("grib_load", "rotated.cml")) cubes = iris.load(tests.get_data_path(('GRIB', "time_processed", "time_bound.grib2"))) self.assertCML(cubes, ("grib_load", "time_bound.cml")) cubes = iris.load(tests.get_data_path(('GRIB', "3_layer_viz", "3_layer.grib2"))) cubes = iris.cube.CubeList([cubes[1], cubes[0], cubes[2]]) self.assertCML(cubes, ("grib_load", "3_layer.cml"))
def test_iris_loading(self): ff32_fname = tests.get_data_path(('FF', 'n48_multi_field.ieee32')) ff64_fname = tests.get_data_path(('FF', 'n48_multi_field')) ff32_cubes = iris.load(ff32_fname) ff64_cubes = iris.load(ff64_fname) for ff32, ff64 in zip(ff32_cubes, ff64_cubes): # load the data _, _ = ff32.data, ff64.data self.assertEqual(ff32, ff64)
def setUp(self): # Call parent setup. super(TestFastCallbackLocationInfo, self).setUp() # Create a basic load test case. self.callback_collations = [] self.callback_filepaths = [] def fast_load_callback(cube, collation, filename): self.callback_collations.append(collation) self.callback_filepaths.append(filename) flds = self.fields(c_t='11112222', c_h='11221122', phn='01010101') self.test_filepath = self.save_fieldcubes(flds) iris.load(self.test_filepath, callback=fast_load_callback)
def test_duplicate(self): paths = ( tests.get_data_path(["PP", "aPPglob1", "global.pp"]), tests.get_data_path(["PP", "aPPglob1", "gl?bal.pp"]), ) cubes = iris.load(paths) self.assertEqual(len(cubes), 2)
def test_load_global_xyzt_gems_iter(self): # Test loading stepped single xyzt CF-netCDF file (multi-cube). for i, cube in enumerate(iris.load( tests.get_data_path(('NetCDF', 'global', 'xyz_t', 'GEMS_CO2_Apr2006.nc')))): self.assertCML(cube, ('netcdf', 'netcdf_global_xyzt_gems_iter_%d.cml' % i))
def test_time_mean(self): # This test for time-mean fields also tests negative forecast time. source_grib = tests.get_data_path(("GRIB", "time_processed", "time_bound.grib2")) cubes = iris.load(source_grib) expect_diffs = {'totalLength': (21232, 21227), 'productionStatusOfProcessedData': (0, 255), 'scaleFactorOfRadiusOfSphericalEarth': (MDI, 0), 'shapeOfTheEarth': (0, 1), 'scaledValueOfRadiusOfSphericalEarth': (MDI, 6367470), 'longitudeOfLastGridPoint': (356249908, 356249809), 'latitudeOfLastGridPoint': (-89999938, -89999944), 'typeOfGeneratingProcess': (0, 255), 'generatingProcessIdentifier': (128, 255), 'typeOfTimeIncrement': (2, 255) } self.skip_keys.append('stepType') self.skip_keys.append('stepTypeInternal') with self.temp_filename(suffix='.grib2') as temp_file_path: iris.save(cubes, temp_file_path) self.assertGribMessageDifference(source_grib, temp_file_path, expect_diffs, self.skip_keys, skip_sections=[2])
def test_lbproc(self): data_path = tests.get_data_path(("PP", "meanMaxMin", "200806081200__qwpb.T24.pp")) # Set up standard name and T+24 constraint constraint = iris.Constraint("air_temperature", forecast_period=24) cubes = iris.load(data_path, constraint) cubes = iris.cube.CubeList([cubes[0], cubes[3], cubes[1], cubes[2], cubes[4]]) self.assertCML(cubes, ("pp_rules", "lbproc_mean_max_min.cml"))
def test_units(self): # Test exercising graceful cube and coordinate units loading. cube0, cube1 = iris.load(tests.get_data_path(('NetCDF', 'testing', 'units.nc'))) self.assertCML(cube0, ('netcdf', 'netcdf_units_0.cml')) self.assertCML(cube1, ('netcdf', 'netcdf_units_1.cml'))
def test_name2_field(self): filepath = tests.get_data_path(('NAME', 'NAMEII_field.txt')) name_cubes = iris.load(filepath) # Check gribapi version, because we currently have a known load/save # problem with gribapi 1v14 (at least). gribapi_ver = gribapi.grib_get_api_version() gribapi_fully_supported_version = \ (StrictVersion(gribapi.grib_get_api_version()) < StrictVersion('1.13')) for i, name_cube in enumerate(name_cubes): if not gribapi_fully_supported_version: data = name_cube.data if np.min(data) == np.max(data): msg = ('NAMEII cube #{}, "{}" has empty data : ' 'SKIPPING test for this cube, as save/load will ' 'not currently work with gribabi > 1v12.') warnings.warn(msg.format(i, name_cube.name())) continue with self.temp_filename('.grib2') as temp_filename: iris.save(name_cube, temp_filename) grib_cube = iris.load_cube(temp_filename, callback=name_cb) self.check_common(name_cube, grib_cube) self.assertCML( grib_cube, tests.get_result_path( ('integration', 'name_grib', 'NAMEII', '{}_{}.cml'.format(i, name_cube.name()))))
def test_lbproc(self): data_path = tests.get_data_path(('PP', 'meanMaxMin', '200806081200__qwpb.T24.pp')) # Set up standard name and T+24 constraint constraint = iris.Constraint('air_temperature', forecast_period=24) cubes = iris.load(data_path, constraint) cubes = iris.cube.CubeList([cubes[0], cubes[3], cubes[1], cubes[2], cubes[4]]) self.assertCML(cubes, ('pp_rules', 'lbproc_mean_max_min.cml'))
def get_variable_names(self, filenames, data_type=None): """ This is exactly the same as the inherited version except I also exclude the mlev dimension """ import iris import cf_units as unit variables = [] cubes = iris.load(filenames, callback=self.load_multiple_files_callback) for cube in cubes: is_time_lat_lon_pressure_altitude_or_has_only_1_point = True for dim in cube.dim_coords: units = dim.units if dim.points.size > 1 and \ not units.is_time() and \ not units.is_time_reference() and \ not units.is_vertical() and \ not units.is_convertible(unit.Unit('degrees')) and \ dim.var_name != 'mlev': is_time_lat_lon_pressure_altitude_or_has_only_1_point = False break if is_time_lat_lon_pressure_altitude_or_has_only_1_point: if cube.var_name: variables.append(cube.var_name) else: variables.append(cube.name()) return set(variables)
def test_y_fastest(self): cubes = iris.load(tests.get_data_path(("GRIB", "y_fastest", "y_fast.grib2"))) self.assertCML(cubes, ("grib_load", "y_fastest.cml")) iplt.contourf(cubes[0]) iplt.gcm(cubes[0]).drawcoastlines() plt.title("y changes fastest") self.check_graphic()
def get_variable_names(self, filenames, data_type=None): import iris import cf_units as unit from cis.utils import single_warnings_only # Removes warnings and prepares for future Iris change iris.FUTURE.netcdf_promote = True variables = [] # Filter the warnings so that they only appear once - otherwise you get lots of repeated warnings with single_warnings_only(): cubes = iris.load(filenames) for cube in cubes: is_time_lat_lon_pressure_altitude_or_has_only_1_point = True for dim in cube.dim_coords: units = dim.units if dim.points.size > 1 and \ not units.is_time() and \ not units.is_time_reference() and \ not units.is_vertical() and \ not units.is_convertible(unit.Unit('degrees')): is_time_lat_lon_pressure_altitude_or_has_only_1_point = False break if is_time_lat_lon_pressure_altitude_or_has_only_1_point: name = cube.var_name or cube.name() if name == 'unknown' and 'STASH' in cube.attributes: name = '{}'.format(cube.attributes['STASH']) variables.append(name) return set(variables)
def test_duplicate(self): paths = ( tests.get_data_path(['PP', 'aPPglob1', 'global.pp']), tests.get_data_path(['PP', 'aPPglob1', 'gl?bal.pp']) ) cubes = iris.load(paths) self.assertEqual(len(cubes), 2)
def get_variable_names(self, filenames, data_type=None): import iris import cf_units as unit from cis.utils import single_warnings_only variables = [] # Filter the warnings so that they only appear once - otherwise you get lots of repeated warnings with single_warnings_only(): cubes = iris.load(filenames) for cube in cubes: is_time_lat_lon_pressure_altitude_or_has_only_1_point = True for dim in cube.dim_coords: units = dim.units if dim.points.size > 1 and \ not units.is_time() and \ not units.is_time_reference() and \ not units.is_vertical() and \ not units.is_convertible(unit.Unit('degrees')): is_time_lat_lon_pressure_altitude_or_has_only_1_point = False break if is_time_lat_lon_pressure_altitude_or_has_only_1_point: if cube.var_name: variables.append(cube.var_name) else: variables.append(cube.name()) return set(variables)
def event_means(self): """Calculate time mean and ntime for each event in time domain. Create cube_event_means and cube_event_ntimes attributes.""" # Check that time domain is of type 'event' self.tdomain.time_domain_type() if self.tdomain.type!='event': raise UserWarning("Warning: time domain type is '{0.tdomain.type}'. It must be 'event'.".format(self)) # Load list of cubes x1=iris.load(self.filein1,self.name) # Loop over events in time domain cube_event_means=[] cube_event_ntimes=[] for eventc in self.tdomain.partial_date_times: # Create time constraint time_beg=eventc[0] time_end=eventc[1] print('time_beg: {0!s}'.format(time_beg)) print('time_end: {0!s}'.format(time_end)) time_constraint=iris.Constraint(time=lambda cell: time_beg <=cell<= time_end) with iris.FUTURE.context(cell_datetime_objects=True): x2=x1.extract(time_constraint) x3=x2.concatenate_cube() ntime=x3.coord('time').shape[0] cube_event_ntimes.append(ntime) x4=x3.collapsed('time',iris.analysis.MEAN) cube_event_means.append(x4) self.cube_event_means=cube_event_means self.cube_event_ntimes=cube_event_ntimes
def test_round_trip(self): cube, = iris.load(self.fname) with self.temp_filename(suffix='.nc') as filename: iris.save(cube, filename, unlimited_dimensions=[]) round_cube, = iris.load_raw(filename) self.assertEqual(len(round_cube.cell_measures()), 1) self.assertEqual(round_cube.cell_measures()[0].measure, 'area')
def cosp_plot_column_2D(fnc, varname='equivalent_reflectivity_factor', level=0, column = 0, time = 0): """ Function that plots one column of lat/lon data. """ plt.interactive(True) fig=plt.figure() ax = fig.add_subplot(111) # Read cube z=iris.load(fnc) z=z[0] # Get coords c = z.coord('column') t = z.coord('time') # Select time and column y=z.extract(iris.Constraint(column=c.points[column])) y=y.extract(iris.Constraint(time=t.points[time])) # Select level. Not managed to make constrain with 'atmospheric model level' y=y[level] color_map = mpl_cm.get_cmap('Paired') qplt.pcolormesh(y,cmap=color_map,vmin=-20,vmax=20) plt.gca().coastlines() return
def _add_available_aux_coords(self, cube, filenames): from iris.aux_factory import HybridPressureFactory from iris.coords import AuxCoord from iris.exceptions import CoordinateNotFoundError import iris if cube.coords('hybrid A coefficient at layer midpoints'): # First convert the hybrid coefficients to hPa, so that air pressure will be in hPa cube.coord('hybrid A coefficient at layer midpoints').convert_units('hPa') try: surface_pressure = cube.coord('surface pressure') except iris.exceptions.CoordinateNotFoundError as e: # If there isn't a surface pressure coordinate we can try and pull out the lowest pressure level with demote_warnings(): surface_pressure_cubes = iris.load(filenames, 'atmospheric pressure at interfaces', callback=self.load_multiple_files_callback) surface_pressure_cube = surface_pressure_cubes.concatenate_cube()[:, -1, :, :] surface_pressure = AuxCoord(points=surface_pressure_cube.data, long_name='surface pressure', units='Pa') cube.add_aux_coord(surface_pressure, (0, 2, 3)) surface_pressure.convert_units('hPa') if len(cube.coords(long_name='hybrid level at layer midpoints')) > 0: cube.add_aux_factory(HybridPressureFactory(delta=cube.coord('hybrid A coefficient at layer midpoints'), sigma=cube.coord('hybrid B coefficient at layer midpoints'), surface_air_pressure=surface_pressure))
def load_all_steps(pp_name): cubes=iris.load(pp_name) ######################################### log.info("pp_name="+str(step_file)) ######################################### for cube in cubes: #capturing stash code from pp file stash_code=ukl.get_stash(cube) #print stash_code stashcodes.append(stash_code) #print stashcodes if stash_code in vd.variable_reference_stash: if not isinstance(cube.long_name,str): cube.long_name=vd.variable_reference_stash[stash_code].long_name # print 'added long_name',cube.long_name, 'to', stash_code if not isinstance(cube._var_name,str): if not vd.variable_reference_stash[stash_code].short_name=='': cube._var_name=vd.variable_reference_stash[stash_code].short_name # print 'added short_name as cube._var_name',cube._var_name, 'to', stash_code ######################################### log.info("cube.long_name= "+str(cube.long_name)) ######################################### folder_NETCDF=output_files_directory+'All_time_steps/' if cube._standard_name: saving_name=folder_NETCDF+'All_time_steps_'+stash_code+'_'+cube._standard_name+'.nc' elif isinstance(cube.long_name,str): saving_name=folder_NETCDF+'All_time_steps_'+stash_code+'_'+cube.long_name+'.nc' else: saving_name=folder_NETCDF+'All_time_steps_'+stash_code+'.nc' iris.save(cube,saving_name, netcdf_format="NETCDF4")
def test_FAIL_pseudo_levels(self): # Show how pseudo levels are handled. flds = self.fields(c_t='000111222', pse='123123123') file = self.save_fieldcubes(flds) results = iris.load(file) expected = CubeList(flds).merge() # NOTE: this problem is now fixed : Structured load gives the same answer. # # if not self.do_fast_loads: # expected = CubeList(flds).merge() # else: # # Structured loading doesn't understand pseudo-level. # # The result is rather horrible... # # # First get a cube over 9 timepoints. # flds = self.fields(c_t='012345678', # pse=1) # result gets level==2, not clear why. # # # Replace the time coord with an AUX coord. # nine_timepoints_cube = CubeList(flds).merge_cube() # co_time = nine_timepoints_cube.coord('time') # nine_timepoints_cube.remove_coord(co_time) # nine_timepoints_cube.add_aux_coord(AuxCoord.from_coord(co_time), # 0) # # Set the expected timepoints equivalent to '000111222'. # nine_timepoints_cube.coord('time').points = \ # np.array([0.0, 0.0, 0.0, 24.0, 24.0, 24.0, 48.0, 48.0, 48.0]) # # Make a cubelist with this single cube. # expected = CubeList([nine_timepoints_cube]) self.assertEqual(results, expected)
def test_phenomena(self): # Show that different phenomena are merged into distinct cubes. flds = self.fields(c_t='1122', phn='0101') file = self.save_fieldcubes(flds) results = iris.load(file) expected = CubeList(flds).merge() self.assertEqual(results, expected)
def test_FAIL_scalar_vector_concatenate(self): # Structured load can produce a scalar coordinate from one file, and a # matching vector one from another file, but these won't "combine". # We'd really like to fix this one... single_timepoint_fld, = self.fields(c_t='1') multi_timepoint_flds = self.fields(c_t='23') file_single = self.save_fieldcubes([single_timepoint_fld], basename='single') file_multi = self.save_fieldcubes(multi_timepoint_flds, basename='multi') results = iris.load((file_single, file_multi)) if not self.do_fast_loads: # This is what we'd LIKE to get (what iris.load gives). expected = CubeList(multi_timepoint_flds + [single_timepoint_fld]).merge() else: # This is what we ACTUALLY get at present. # It can't combine the scalar and vector time coords. expected = CubeList([CubeList(multi_timepoint_flds).merge_cube(), single_timepoint_fld]) # NOTE: in this case, we need to sort the results to ensure a # repeatable ordering, because ??somehow?? the random temporary # directory name affects the ordering of the cubes in the result ! results = CubeList(sorted(results, key=lambda cube: cube.shape)) self.assertEqual(results, expected)
def getJobs(db): try: q = tinydb.Query() rows = db.search(q.saved is None q.success == f) info = manifest.runnames[file.split("_")[-2]] newfiles = [] variables = info["variables"] for variable in info["variables"]: print "Ingesting " + variable try: thisdata = iris.load_cube(file, variable) stem, fname = os.path.split(file) newname = file.split("_")[-2] + "_" + variable + "_" + fname.split("_")[0] + "_piotr_" + fname.split("_")[-1].replace("grib2", "nc") iris.save(thisdata, os.path.join(stem, newname)) #postJob(newname) except iris.exceptions.ConstraintMismatchError: print variable + " not found in file " + file + ". continuing" cubes = iris.load(file) print cubes except: raise finally: print "Removing file", file
def test_basic(self): # Show that basic load merging works. flds = self.fields(c_t='123', cft='000', ctp='123', c_p=0) file = self.save_fieldcubes(flds) results = iris.load(file) expected = CubeList(flds).merge() self.assertEqual(results, expected)
def showOpenDialog(self): """ Handles the loading of a file, and calls functions to set up the GUI accordingly and then display the cube """ self.filename, _ = QtGui.QFileDialog.getOpenFileName(self, 'Open File', '/project/avd/iris/resources/public_sample_data_1.0') self.clearAll() QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) self.statusBar().showMessage('Loading Cube') try: self.cubes = iris.load(self.filename) except ValueError as e: flags = QtGui.QMessageBox.StandardButton.Ok response = QtGui.QMessageBox.critical(self, 'Unable to Load Cube: File type could not be read', str(e), flags) self.statusBar().showMessage('Load Failed') QApplication.restoreOverrideCursor() QApplication.restoreOverrideCursor() for self.cube in self.cubes: self.selectCube.addItem(self.cube.name()) #fills the selectCube combo box with the cubes from the file if len(self.cubes) == 1: self.selectCube.setEnabled(False) else: self.selectCube.setEnabled(True) self.cubeLoaded = True self.printCubeBrowser.setText(str(self.cube)) self.setDimensionCombos() self.update()
def test_netcdf_hybrid_height(self): # Test saving a CF-netCDF file which contains a hybrid height # (i.e. dimensionless vertical) coordinate. # Read PP input file. names = ['air_potential_temperature', 'surface_altitude'] file_in = tests.get_data_path( ('PP', 'COLPEX', 'small_colpex_theta_p_alt.pp')) cube = iris.load_cube(file_in, names[0]) # Write Cube to netCDF file. with self.temp_filename(suffix='.nc') as file_out: iris.save(cube, file_out) # Check the netCDF file against CDL expected output. self.assertCDL(file_out, ('netcdf', 'netcdf_save_hybrid_height.cdl')) # Read netCDF file. cubes = iris.load(file_out) cubes_names = [c.name() for c in cubes] self.assertEqual(cubes_names, names) # Check the PP read, netCDF write, netCDF read mechanism. self.assertCML(cubes.extract(names[0])[0], ('netcdf', 'netcdf_save_load_hybrid_height.cml'))
def load_cubelist( filepath: Union[str, List[str]], constraints: Optional[Union[Constraint, str]] = None, no_lazy_load: bool = False, ) -> CubeList: """Load cubes from filepath(s) into a cubelist. Strips off all var names except for "threshold"-type coordinates, where this is different from the standard or long name. Args: filepath: Filepath(s) that will be loaded. constraints: Constraint to be applied when loading from the input filepath. This can be in the form of an iris.Constraint or could be a string that is intended to match the name of the cube. The default is None. no_lazy_load: If True, bypass cube deferred (lazy) loading and load the whole cube into memory. This can increase performance at the cost of memory. If False (default) then lazy load. Returns: CubeList that has been created from the input filepath given the constraints provided. """ # Remove legacy metadata prefix cube if present constraints = ( iris.Constraint(cube_func=lambda cube: cube.long_name != "prefixes") & constraints ) # Load each file individually to avoid partial merging (not used # iris.load_raw() due to issues with time representation) with iris_nimrod_patcher(): if isinstance(filepath, str): cubes = iris.load(filepath, constraints=constraints) else: cubes = iris.cube.CubeList([]) for item in filepath: cubes.extend(iris.load(item, constraints=constraints)) if not cubes: message = "No cubes found using constraints {}".format(constraints) raise ValueError(message) # Remove var_name from cubes and coordinates (except where needed to # describe probabilistic data) cubes = strip_var_names(cubes) for cube in cubes: # Remove metadata attributes pointing to legacy prefix cube cube.attributes.pop("bald__isPrefixedBy", None) # Ensure the probabilistic coordinates are the first coordinates within # a cube and are in the specified order. enforce_coordinate_ordering(cube, ["realization", "percentile", "threshold"]) # Ensure the y and x dimensions are the last within the cube. y_name = cube.coord(axis="y").name() x_name = cube.coord(axis="x").name() enforce_coordinate_ordering(cube, [y_name, x_name], anchor_start=False) if no_lazy_load: # Force cube's data into memory by touching the .data attribute. # pylint: disable=pointless-statement cube.data return cubes
from matplotlib.colors import LogNorm from mpl_toolkits.basemap import Basemap from matplotlib.patches import Polygon import iris import iris.plot as iplt import iris.quickplot as qplt c5h8_stash = ['m01s34i027'] filename = '/exports/csce/datastore/geos/users/s1731217/output_ukca/u-av256/apm.pp/*' stash_constraint = iris.AttributeConstraint(STASH=c5h8_stash[0]) latitude_constraint = iris.Constraint(coord_values={'latitude':lambda cell: 17.5 < cell < 45}) longitude_constraint = iris.Constraint(coord_values={'longitude':lambda cell: 107.5 < cell < 125}) cube = iris.load(filename, stash_constraint).extract(latitude_constraint & longitude_constraint) print cube print cube[0] cube_ppb = cube[0]*29.0*1.0e9/65.0 print cube_ppb fig= plt.figure(figsize=(15, 8)) plt.subplot(3,4,1) plt.title('C5H8 Jan 2014', fontsize=5) tick_levels = [0.01, 0.1, 0.2, 0.4, 0.6, 0.8, 1, 1.5, 2, 2.5, 3, 3.5, 4]
def insert_netcdf(self, path): for cube in iris.load(path): for coord in cube.coords(): self.insert_coordinate(path, cube.var_name, coord.name())
def _handle_load(self, sender): """Load button action.""" fpfs = [fp.files for fp in self.file_pickers] selected_files = reduce(list.__add__, (list(files) for files in fpfs)) self._cubes = iris.load(selected_files) self.update_cubes_list()
import numpy as np import iris import matplotlib.pyplot as plt cube1 = iris.load('japp_default_new.nc')[0] cube2 = iris.load('japp_lehtinen_rc_units.nc')[0] level_num = cube1.coord('model_level_number').points plt.figure() plt.xlabel('Japp') plt.ylabel('Model_level_number') plt.plot((cube1[:, 72, 96].data), level_num, 'b*-', (cube2[:, 72, 96].data), level_num, 'r*-') plt.title('Japp_both_at (0,0)') plt.legend(('default', 'lehtinen')) plt.grid(True) #plt.show() #plt.show() plt.figure() plt.xlabel('Japp_default') plt.ylabel('Model_level_number') plt.plot((cube1[:, 72, 96].data), level_num, 'b*-') plt.title('Japp_default_at (0,0)') #plt.show() plt.figure() plt.xlabel('Japp_lehtinen') plt.ylabel('Model_level_number') plt.plot((cube2[:, 72, 96].data), level_num, 'b*-') plt.title('Japp_lehtinen_at (0,0)')
def load_forecast(self): return iris.load(self.forecast_filename)
def main(): # Plot diagnostics, model and pressure levels etc. to plot on for looping through plot_type='mean' plot_diags=['temp', 'sp_hum'] plot_levels = [925, 850, 700, 500] #plot_levels = [925] #experiment_ids = ['djznq', 'djzns', 'dklyu', 'dkmbq', 'dklwu', 'dklzq' ] experiment_ids = ['dkjxq'] #experiment_id = 'djzny' p_levels = [1000, 950, 925, 850, 700, 500, 400, 300, 250, 200, 150, 100, 70, 50, 30, 20, 10] ###### Unrotate global model data ############################## ######### Regrid to global, and difference ####### ############################################################################ ## Load global wind and orography fw_global = '/nfs/a90/eepdw/Mean_State_Plot_Data/pp_files/djzn/djzny/30201_mean.pp' fo_global = '/nfs/a90/eepdw/Mean_State_Plot_Data/pp_files/djzn/djzny/33.pp' u_global,v_global = iris.load(fw_global) oro_global = iris.load_cube(fo_global) # Unrotate global coordinates cs_glob = u_global.coord_system('CoordSystem') cs_glob_v = v_global.coord_system('CoordSystem') cs_glob_oro = oro_global.coord_system('CoordSystem') lat_g = u_global.coord('grid_latitude').points lon_g = u_global.coord('grid_longitude').points lat_g_oro = oro_global.coord('grid_latitude').points lon_g_oro = oro_global.coord('grid_longitude').points if cs_glob!=cs_glob_v: print 'Global model u and v winds have different poles of rotation' # Unrotate global winds if isinstance(cs_glob, iris.coord_systems.RotatedGeogCS): print ' Global Model - Winds - djzny - Unrotate pole %s' % cs_glob lons_g, lats_g = np.meshgrid(lon_g, lat_g) lons_g,lats_g = iris.analysis.cartography.unrotate_pole(lons_g,lats_g, cs_glob.grid_north_pole_longitude, cs_glob.grid_north_pole_latitude) lon_g=lons_g[0] lat_g=lats_g[:,0] for i, coord in enumerate (u_global.coords()): if coord.standard_name=='grid_latitude': lat_dim_coord_uglobal = i if coord.standard_name=='grid_longitude': lon_dim_coord_uglobal = i csur_glob=cs_glob.ellipsoid u_global.remove_coord('grid_latitude') u_global.remove_coord('grid_longitude') u_global.add_dim_coord(iris.coords.DimCoord(points=lat_g, standard_name='grid_latitude', units='degrees', coord_system=csur_glob), lat_dim_coord_uglobal) u_global.add_dim_coord(iris.coords.DimCoord(points=lon_g, standard_name='grid_longitude', units='degrees', coord_system=csur_glob), lon_dim_coord_uglobal) #print u_global v_global.remove_coord('grid_latitude') v_global.remove_coord('grid_longitude') v_global.add_dim_coord(iris.coords.DimCoord(points=lat_g, standard_name='grid_latitude', units='degrees', coord_system=csur_glob), lat_dim_coord_uglobal) v_global.add_dim_coord(iris.coords.DimCoord(points=lon_g, standard_name='grid_longitude', units='degrees', coord_system=csur_glob), lon_dim_coord_uglobal) #print v_global # Unrotate global model if isinstance(cs_glob_oro, iris.coord_systems.RotatedGeogCS): print ' Global Model - Orography - djzny - Unrotate pole %s - Winds and other diagnostics may have different number of grid points' % cs_glob_oro lons_go, lats_go = np.meshgrid(lon_g_oro, lat_g_oro) lons_go,lats_go = iris.analysis.cartography.unrotate_pole(lons_go,lats_go, cs_glob_oro.grid_north_pole_longitude, cs_glob_oro.grid_north_pole_latitude) lon_g_oro=lons_go[0] lat_g_oro=lats_go[:,0] for i, coord in enumerate (oro_global.coords()): if coord.standard_name=='grid_latitude': lat_dim_coord_og = i if coord.standard_name=='grid_longitude': lon_dim_coord_og = i csur_glob_oro=cs_glob_oro.ellipsoid oro_global.remove_coord('grid_latitude') oro_global.remove_coord('grid_longitude') oro_global.add_dim_coord(iris.coords.DimCoord(points=lat_g_oro, standard_name='grid_latitude', units='degrees', coord_system=csur_glob_oro), lat_dim_coord_og) oro_global.add_dim_coord(iris.coords.DimCoord(points=lon_g_oro, standard_name='grid_longitude', units='degrees', coord_system=csur_glob_oro), lon_dim_coord_og) ############################################################################### #################### Load global heights and temp/sp_hum ##################### f_glob_h = '/nfs/a90/eepdw/Mean_State_Plot_Data/Mean_Heights_Temps_etc/408_pressure_levels_interp_pressure_djzny_%s' % (plot_type) ###################################################################################### with h5py.File(f_glob_h, 'r') as i: mh = i['%s' % plot_type] mean_heights_global = mh[. . .] ###################################################################################### ## Loop through experiment id's ###################################################### for pl in plot_diags: plot_diag=pl f_glob_d = '/nfs/a90/eepdw/Mean_State_Plot_Data/Mean_Heights_Temps_etc/%s_pressure_levels_interp_djzny_%s' % (plot_diag, plot_type) with h5py.File(f_glob_d, 'r') as i: mg = i['%s' % plot_type] mean_var_global = mg[. . .] for experiment_id in experiment_ids: expmin1 = experiment_id[:-1] ############################################################################### #################### Load global heights and temp/sp_hum ##################### fname_h = '/nfs/a90/eepdw/Mean_State_Plot_Data/Mean_Heights_Temps_etc/408_pressure_levels_interp_pressure_%s_%s' % (experiment_id, plot_type) fname_d = '/nfs/a90/eepdw/Mean_State_Plot_Data/Mean_Heights_Temps_etc/%s_pressure_levels_interp_%s_%s' % (plot_diag, experiment_id, plot_type) # print fname_h # print fname_d # Height data file with h5py.File(fname_h, 'r') as i: mh = i['%s' % plot_type] mean_heights = mh[. . .] # print mean_heights.shape with h5py.File(fname_d, 'r') as i: mh = i['%s' % plot_type] mean_var = mh[. . .] # print mean_var.shape f_oro = '/nfs/a90/eepdw/Mean_State_Plot_Data/pp_files/%s/%s/409.pp' % (expmin1, experiment_id) oro = iris.load_cube(f_oro) #print oro for i, coord in enumerate (oro.coords()): if coord.standard_name=='grid_latitude': lat_dim_coord_oro = i if coord.standard_name=='grid_longitude': lon_dim_coord_oro = i fu = '/nfs/a90/eepdw/Mean_State_Plot_Data/pp_files/%s/%s/30201_mean.pp' % (expmin1, experiment_id) u_wind,v_wind = iris.load(fu) # Wind may have different number of grid points so need to do unrotate again for wind grid points lat_w = u_wind.coord('grid_latitude').points lon_w = u_wind.coord('grid_longitude').points p_levs = u_wind.coord('pressure').points lat = oro.coord('grid_latitude').points lon = oro.coord('grid_longitude').points cs_w = u_wind.coord_system('CoordSystem') cs = oro.coord_system('CoordSystem') if isinstance(cs_w, iris.coord_systems.RotatedGeogCS): print ' Wind - %s - Unrotate pole %s' % (experiment_id, cs_w) lons_w, lats_w = np.meshgrid(lon_w, lat_w) lons_w,lats_w = iris.analysis.cartography.unrotate_pole(lons_w,lats_w, cs_w.grid_north_pole_longitude, cs_w.grid_north_pole_latitude) lon_w=lons_w[0] lat_w=lats_w[:,0] csur_w=cs_w.ellipsoid for i, coord in enumerate (u_wind.coords()): if coord.standard_name=='grid_latitude': lat_dim_coord_uwind = i if coord.standard_name=='grid_longitude': lon_dim_coord_uwind = i u_wind.remove_coord('grid_latitude') u_wind.remove_coord('grid_longitude') u_wind.add_dim_coord(iris.coords.DimCoord(points=lat_w, standard_name='grid_latitude', units='degrees', coord_system=csur_w),lat_dim_coord_uwind ) u_wind.add_dim_coord(iris.coords.DimCoord(points=lon_w, standard_name='grid_longitude', units='degrees', coord_system=csur_w), lon_dim_coord_uwind) v_wind.remove_coord('grid_latitude') v_wind.remove_coord('grid_longitude') v_wind.add_dim_coord(iris.coords.DimCoord(points=lat_w, standard_name='grid_latitude', units='degrees', coord_system=csur_w), lat_dim_coord_uwind) v_wind.add_dim_coord(iris.coords.DimCoord(points=lon_w, standard_name='grid_longitude', units='degrees', coord_system=csur_w),lon_dim_coord_uwind ) if isinstance(cs, iris.coord_systems.RotatedGeogCS): print ' 409.pp - %s - Unrotate pole %s' % (experiment_id, cs) lons, lats = np.meshgrid(lon, lat) lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_corners, lat_corners = np.meshgrid((lon_low, lon_high), (lat_low, lat_high)) lons,lats = iris.analysis.cartography.unrotate_pole(lons,lats, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude) lon_corner_u,lat_corner_u = iris.analysis.cartography.unrotate_pole(lon_corners, lat_corners, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude) #lon_highu,lat_highu = iris.analysis.cartography.unrotate_pole(lon_high, lat_high, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude) lon=lons[0] lat=lats[:,0] lon_low = lon_corner_u[0,0] lon_high = lon_corner_u[0,1] lat_low = lat_corner_u[0,0] lat_high = lat_corner_u[1,0] for i, coord in enumerate (oro.coords()): if coord.standard_name=='grid_latitude': lat_dim_coord_oro = i if coord.standard_name=='grid_longitude': lon_dim_coord_oro = i csur=cs.ellipsoid oro.remove_coord('grid_latitude') oro.remove_coord('grid_longitude') oro.add_dim_coord(iris.coords.DimCoord(points=lat, standard_name='grid_latitude', units='degrees', coord_system=csur), lat_dim_coord_oro) oro.add_dim_coord(iris.coords.DimCoord(points=lon, standard_name='grid_longitude', units='degrees', coord_system=csur), lon_dim_coord_oro) else: lons, lats = np.meshgrid(lon, lat) lons_w, lats_w = np.meshgrid(lon_w, lat_w) lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) ############## Regrid and Difference ################################# # Regrid Height and Temp/Specific humidity to global grid h_regrid = np.empty((len(lat_g_oro), len(lon_g_oro))) v_regrid = np.empty((len(lat_g_oro), len(lon_g_oro))) for p in plot_levels: ### Search for pressure level match s = np.searchsorted(p_levels[::-1], p) h_regrid = scipy.interpolate.griddata((lats.flatten(),lons.flatten()),mean_heights[:,:,-(s+1)].flatten() , (lats_go,lons_go),method='linear') v_regrid = scipy.interpolate.griddata((lats.flatten(),lons.flatten()),mean_var[:,:,-(s+1)].flatten() , (lats_go,lons_go),method='linear') # Difference heights plt_h = np.where(np.isnan(h_regrid), np.nan, h_regrid - mean_heights_global[:,:,-(s+1)]) #Difference temperature/specific humidity plt_v = np.where(np.isnan(v_regrid), np.nan, v_regrid - mean_var_global[:,:,-(s+1)]) # Set u,v for winds, linear interpolate to approx. 2 degree grid sc = np.searchsorted(p_levs, p) ##### Does not work on iris1.0 as on Leeds computers. Does work on later versions #u_interp = u_wind[sc,:,:] #v_interp = v_wind[sc,:,:]. #sample_points = [('grid_latitude', np.arange(lat_low,lat_high,2)), ('grid_longitude', np.arange(lon_low,lon_high,2))] #u = iris.analysis.interpolate.linear(u_interp, sample_points, extrapolation_mode='linear') #v = iris.analysis.interpolate.linear(v_interp, sample_points).data ##### Does work on Iris 1.0 # 2 degree lats lon lists for wind regridding on plot lat_wind_1deg = np.arange(lat_low,lat_high, 2) lon_wind_1deg = np.arange(lon_low,lon_high, 2) ### Regrid winds to global, difference, and then regrid to 2 degree spacing fl_la_lo = (lats_w.flatten(),lons_w.flatten()) # print u_wind[sc,:,:].data.flatten().shape u_wind_rg_to_glob = scipy.interpolate.griddata(fl_la_lo, u_wind[sc,:,:].data.flatten(), (lats_g, lons_g), method='linear') v_wind_rg_to_glob = scipy.interpolate.griddata(fl_la_lo, v_wind[sc,:,:].data.flatten(), (lats_g, lons_g), method='linear') u_w=u_wind_rg_to_glob-u_global[sc,:,:].data v_w=v_wind_rg_to_glob-v_global[sc,:,:].data #u_interp = u_wind[sc,:,:].data #v_interp = v_wind[sc,:,:].data lons_wi, lats_wi = np.meshgrid(lon_wind_1deg, lat_wind_1deg) fl_la_lo = (lats_g.flatten(),lons_g.flatten()) u = scipy.interpolate.griddata(fl_la_lo, u_w.flatten(), (lats_wi, lons_wi), method='linear') v = scipy.interpolate.griddata(fl_la_lo, v_w.flatten(), (lats_wi, lons_wi), method='linear') ####################################################################################### ### Plotting ######################################################################### #m_title = 'Height of %s-hPa level (m)' % (p) # Set pressure height contour min/max if p == 925: clev_min = -24. clev_max = 24. elif p == 850: clev_min = -24. clev_max = 24. elif p == 700: clev_min = -24. clev_max = 24. elif p == 500: clev_min = -24. clev_max = 24. else: print 'Contour min/max not set for this pressure level' # Set potential temperature min/max if p == 925: clevpt_min = -10. clevpt_max = 10. elif p == 850: clevpt_min = -3. clevpt_max = 3. elif p == 700: clevpt_min = -3. clevpt_max = 3. elif p == 500: clevpt_min = -3. clevpt_max = 3. else: print 'Potential temperature min/max not set for this pressure level' # Set specific humidity min/max if p == 925: clevsh_min = -0.0025 clevsh_max = 0.0025 elif p == 850: clevsh_min = -0.0025 clevsh_max = 0.0025 elif p == 700: clevsh_min = -0.0025 clevsh_max = 0.0025 elif p == 500: clevsh_min = -0.0025 clevsh_max = 0.0025 else: print 'Specific humidity min/max not set for this pressure level' #clevs_col = np.arange(clev_min, clev_max) clevs_lin = np.linspace(clev_min, clev_max, num=24) m =\ Basemap(llcrnrlon=lon_low,llcrnrlat=lat_low,urcrnrlon=lon_high,urcrnrlat=lat_high, rsphere = 6371229) #x, y = m(lons, lats) x,y = m(lons_go,lats_go) print x.shape x_w,y_w = m(lons_wi, lats_wi) fig=plt.figure(figsize=(8,8)) ax = fig.add_axes([0.05,0.05,0.9,0.85], axisbg='#262626') m.drawcoastlines(color='#262626') m.drawcountries(color='#262626') m.drawcoastlines(linewidth=0.5) #m.fillcontinents(color='#CCFF99') m.drawparallels(np.arange(-80,81,10),labels=[1,1,0,0]) m.drawmeridians(np.arange(0,360,10),labels=[0,0,0,1]) cs_lin = m.contour(x,y, plt_h, clevs_lin,colors='#262626',linewidths=0.5) cmap=plt.cm.RdBu_r #cmap.set_bad('#262626', 1.) #cmap.set_over('#262626') #cmap.set_under('#262626') if plot_diag=='temp': plt_v = np.ma.masked_outside(plt_v, clevpt_max+20, clevpt_min-20) cs_col = m.contourf(x,y, plt_v, np.linspace(clevpt_min, clevpt_max), cmap=cmap, extend='both') cbar = m.colorbar(cs_col,location='bottom',pad="5%", format = '%d') cbar.set_ticks(np.arange(clevpt_min,clevpt_max+2,2.)) cbar.set_ticklabels(np.arange(clevpt_min,clevpt_max+2,2.)) cbar.set_label('K') plt.suptitle('Difference from global model (Model - global ) of Height, Potential Temperature and Wind Vectors at %s hPa'% (p), fontsize=10) elif plot_diag=='sp_hum': plt_v = np.ma.masked_outside(plt_v, clevsh_max+20, clevsh_min-20) cs_col = m.contourf(x,y, plt_v, np.linspace(clevsh_min, clevsh_max), cmap=cmap, extend='both') cbar = m.colorbar(cs_col,location='bottom',pad="5%", format = '%.3f') cbar.set_label('kg/kg') plt.suptitle('Difference from global model (Model - Global Model ) of Height, Specific Humidity and Wind Vectors at %s hPa'% (p), fontsize=10) wind = m.quiver(x_w,y_w, u, v, scale=150,color='#262626' ) qk = plt.quiverkey(wind, 0.1, 0.1, 5, '5 m/s', labelpos='W') plt.clabel(cs_lin, fontsize=10, fmt='%d', color='black') #plt.title('%s\n%s' % (m_title, model_name_convert_title.main(experiment_id)), fontsize=10) plt.title('\n'.join(wrap('%s' % (model_name_convert_title.main(experiment_id)), 80)), fontsize=10) #plt.show() if not os.path.exists('/nfs/a90/eepdw/Mean_State_Plot_Data/Figures/%s/%s' % (experiment_id, plot_diag)): os.makedirs('/nfs/a90/eepdw/Mean_State_Plot_Data/Figures/%s/%s' % (experiment_id, plot_diag)) plt.savefig('/nfs/a90/eepdw/Mean_State_Plot_Data/Figures/%s/%s/geop_height_difference_120LAM_%shPa_%s_%s.png' % (experiment_id, plot_diag, p, experiment_id, plot_diag), format='png', bbox_inches='tight')
import iris import netCDF4 as nc import climtools_lib as ctl import climdiags as cd from matplotlib.colors import LogNorm ####################################### nr = 1 ifile = '/data-hobbes/fabiano/OBS/ERA/ERA40+Int_daily_1957-2018_zg500_remap25_meters.nc' print('IRIS read\n') for i in range(nr): t1 = datetime.now() fh = iris.load(ifile) data = fh[0].data print(data.shape, np.max(data)) t2 = datetime.now() diff = (t2-t1).total_seconds() print('Data loaded in {:8.3f} s\n'.format(diff)) del data print('NetCDF read\n') for i in range(nr): t1 = datetime.now() fh = nc.Dataset(ifile, mode='r') data = list(fh.variables.values())[-1][:] print(data.shape, np.max(data)) t2 = datetime.now()
emissions_file='/group_workspaces/jasmin2/ukca/vol1/mkoehler/emissions/combined_1960/0.5x0.5/combined_sources_BC_fossil_1960_360d.nc' # # STASH code emissions are associated with # 301-320: surface # m01s00i310: Black carbon fossil fuel surface emissions # # 321-340: full atmosphere # stash='m01s00i310' # --- BELOW THIS LINE, NOTHING SHOULD NEED TO BE CHANGED --- species_name='BC_fossil' # this is the grid we want to regrid to, e.g. N96 ENDGame grd=iris.load(grid_file)[0] grd.coord(axis='x').guess_bounds() grd.coord(axis='y').guess_bounds() # This is the original data ems=iris.load_cube(emissions_file) # make intersection between 0 and 360 longitude to ensure that # the data is regridded correctly nems = ems.intersection(longitude=(0, 360)) # make sure that we use the same coordinate system, otherwise regrid won't work nems.coord(axis='x').coord_system=grd.coord_system() nems.coord(axis='y').coord_system=grd.coord_system() # now guess the bounds of the new grid prior to regridding
longitude=lambda c: left_lon <= c.point <= right_lon) #OUTPATH = '/scratch/vportge/plots/Climpact/'+MIN_OR_MAX+'_LST_in_cold_window/'+REGION+'/' OUTPATH = '/scratch/vportge/plots/warm_window_10_3/Climpact/' + MIN_OR_MAX + '_LST_in_cold_window/' + REGION + '/' for TIMERANGE in possible_times: if TIMERANGE == 'ANN': TITLE_TIME = 'annually' elif TIMERANGE == 'MON': TITLE_TIME = 'monthly' elif TIMERANGE == 'DAY': TITLE_TIME = 'daily' FPATH = glob.glob(INDIR + INAME + '_' + TIMERANGE + '*-' + MIN_OR_MAX + '*.nc') #Load in the data for the index and delete 'file_created' attribute. data = iris.load(FPATH) for i in range(len(data)): del data[i].attributes['file_created'] #concatenate data so that all tiles are sticked together. data = data.concatenate_cube() #Extract only a subregion of the whole region. data = data.extract(lat_constraint) data = data.extract(lon_constraint) #needed for collapsing the data data.coord('latitude').guess_bounds() data.coord('longitude').guess_bounds() #Those indices had problems due to thresholds. if INAME not in ['hw', 'tnx', 'txx', 'tx95t', 'tnm', 'tmm']:
lons = coords[1].points nj, ni = lats.shape # number of grid lines nc = 20 njstep, nistep = max(1, nj // nc), max(1, ni // nc) for j in range(0, nj, njstep): y = lats[j, :] x = lons[j, :] pylab.plot(x, y, lineType) for i in range(0, ni, nistep): y = lats[:, i] x = lons[:, i] pylab.plot(x, y, lineType) srcCubes = iris.load(args.src_file) srcCube = None for cb in srcCubes: if cb.var_name == 'pointData': srcCube = cb dstCubes = iris.load(args.dst_file) dstCube = None for cb in dstCubes: if cb.var_name == 'pointData': dstCube = cb #plotCellAreas(srcCube) plotGrid(srcCube, 'g-') plotGrid(dstCube, 'r-')
#air density is not the same #cube_unit_beijing = cube[0]*1.284*1.0e9 #cube_unit_shijiazhuang = cube[0]*1.275*1.0e9 #cube_unit_shanghai = cube[0]*1.248*1.0e9 #cube_unit_nanjing = cube[0]*1.252*1.0e9 #cube_unit_guangzhou = cube[0]*1.213*1.0e9 #cube_unit_hk = cube[0]*1.209*1.0e9 # #cube_beijing_no2 = iris.analysis.interpolate.extract_nearest_neighbour(cube_unit_beijing, [('latitude', 39.90), ('longitude', 116.41)]) #cube_shijiazhuang_no2 = iris.analysis.interpolate.extract_nearest_neighbour(cube_unit_shijiazhuang, [('latitude', 38.04), ('longitude', 114.51)]) #cube_shanghai_no2 = iris.analysis.interpolate.extract_nearest_neighbour(cube_unit_shanghai, [('latitude', 31.23), ('longitude', 121.47)]) #cube_nanjing_no2 = iris.analysis.interpolate.extract_nearest_neighbour(cube_unit_nanjing, [('latitude', 32.06), ('longitude', 118.80)]) #cube_guangzhou_no2 = iris.analysis.interpolate.extract_nearest_neighbour(cube_unit_guangzhou, [('latitude', 23.13), ('longitude', 113.26)]) #cube_hongkong_no2 = iris.analysis.interpolate.extract_nearest_neighbour(cube_unit_hk, [('latitude', 22.33), ('longitude', 114.19)]) cube2 = iris.load(filename2) cube_unit_beijing_nudging = cube2[0] * 1.284 * 1.0e9 cube_unit_shijiazhuang_nudging = cube2[0] * 1.275 * 1.0e9 cube_unit_shanghai_nudging = cube2[0] * 1.248 * 1.0e9 cube_unit_nanjing_nudging = cube2[0] * 1.252 * 1.0e9 cube_unit_guangzhou_nudging = cube2[0] * 1.213 * 1.0e9 cube_unit_hk_nudging = cube2[0] * 1.209 * 1.0e9 cube_beijing_no2_nudging = iris.analysis.interpolate.extract_nearest_neighbour( cube_unit_beijing_nudging, [('latitude', 39.90), ('longitude', 116.41)]) cube_shijiazhuang_no2_nudging = iris.analysis.interpolate.extract_nearest_neighbour( cube_unit_shijiazhuang_nudging, [('latitude', 38.04), ('longitude', 114.51)]) cube_shanghai_no2_nudging = iris.analysis.interpolate.extract_nearest_neighbour( cube_unit_shanghai_nudging, [('latitude', 31.23), ('longitude', 121.47)])
#directory='/nfs/a201/earhg/UKCA/tests-2016/xmmlla/' directory='/group_workspaces/jasmin2/crescendo/hgordon/u-an970-2/' directory='/group_workspaces/jasmin/clarify/users/hgordon/u-ap203/' directory='/group_workspaces/jasmin/clarify/users/hgordon/u-ar931/' directory='/group_workspaces/jasmin2/crescendo/hgordon/u-ax337/' directory='/group_workspaces/jasmin2/asci/eeara/' #folder= directory+'umnsa_glm_nc_time/' folder=directory+'All_months/'# +'All_time_steps/' #+'All_months' #folder=directory+'20160801' saving_folder_l1=directory+'L1/' ukl.create_folder(saving_folder_l1) #Reading necesary cubes potential_temperature=iris.load(ukl.Obtain_name(folder,'m01s00i004'))[0] air_pressure=iris.load(ukl.Obtain_name(folder,'m01s00i408'))[0] p0 = iris.coords.AuxCoord(1000.0, long_name='reference_pressure', units='hPa') p0.convert_units(air_pressure.units) Rd=287.05 # J/kg/K cp=1005.46 # J/kg/K Rd_cp=Rd/cp print '..................HELLOOOO...................' temperature=potential_temperature*(air_pressure/p0)**(Rd_cp) print temperature.data[0,0,0]
trial1 = iris.cube.CubeList() trial2 = iris.cube.CubeList() path = '/group_workspaces/jasmin2/gassp/eeara/CARIBIC/' #ANANTH mpath1 = '/group_workspaces/jasmin2/asci/eeara/model_runs/u-by920/' # biogenic nucelation branch mpath1 = '/group_workspaces/jasmin2/asci/eeara/model_runs/u-by921/' # baseline simulation branch #mpath1='/gws/nopw/j04/gassp/hgordon/u-be424-noColinFix/L1/' alt_path = '/group_workspaces/jasmin2/asci/eeara/model_runs/u-bf834/L1/' #alt_path='/gws/nopw/j04/gassp/hgordon/u-be424-noColinFix/L1/' #mpath2='/group_workspaces/jasmin2/gassp/eeara/model_runs/u-bc244/L1/' cutoff = 2 # this is a radius...12nm is a diameter!! altitude_path = alt_path + 'L1_rad_accsol_Radius_of_mode_accsol.nc' cube = iris.load(altitude_path) cube = cube[0] alt_data = cube.coord('altitude').points alt_data_2 = cube.coord('altitude').points alt_data = alt_data[:, 72, 96] alt_data = alt_data / 1000 sigma = [1.59, 1.59, 1.40, 2.0, 1.59, 1.59, 2.0] pref = 1.013e5 tref = 293.0 zboltz = 1.3807e-23 staird = pref / (tref * 287.058) #f=plt.figure() indx = [10, 20, 30, 35, 40, 45, 50, 55]
def Read_cube(self, string): try: self.cube = iris.load(ukl.Obtain_name(self.path, string))[0] except: self.cube = iris.load( ukl.Obtain_name(self.path[:-15] + 'L1/', string))[0]
def setUp(self): file = tests.get_data_path(('PP', 'aPProt1', 'rotatedMHtimecube.pp')) cubes = iris.load(file) self.cube = cubes[0] self.assertCML(self.cube, ('analysis', 'original.cml'))
def outflow_grid(k=0, levels=3, hoursafterinit=[42, 36, 42, 24], thlevs=[[320, 325, 330], [325, 330, 335], [310, 315, 320], [310, 315, 320]], folder='IOP3/T42', strapp=''): "This presently defines the grid of points from the sime time that the region is defined" "But by loading the forward trajectories this could easily be adapted to" "define the grid at any time along the trajectory" #save_dir = '/glusterfs/msc/users_2018/bn826011/NAWDEX/Final/' save_dir = '/storage/silver/scenario/bn826011/WCB_outflow/Final/' basetime = [ datetime.datetime(2016, 9, 22, 12), datetime.datetime(2016, 9, 26, 12), datetime.datetime(2016, 9, 30, 12), datetime.datetime(2016, 10, 03, 12) ] basetime_str = basetime[k].strftime('%Y%m%d_%H') TrB = load(save_dir + folder + '/{}_TrajectoryEnsemble_backward'.format(basetime_str) + strapp) start_time = [datetime.timedelta(hours=0)] # trajectory at definition time datadir = '/export/cloud/migrated-NCASweather/ben/nawdex/mi-ar482/{}/'.format( basetime_str) #hoursafterinit = [42, 42, 42, 72, 96]#42 time = basetime[k] + datetime.timedelta(hours=hoursafterinit[k]) mapping = {} leadtimehr = np.int((time - basetime[k]).total_seconds()) / 3600 fn = 'prodm_op_gl-mn_{0}_d{1:03d}_thgrid.pp'.\ format(basetime_str, 12 * (leadtimehr / 12)) mapping[time] = datadir + fn # dexs = iris.load('/export/cloud/NCASweather/ben/nawdex/mi-ar482/20160922_12/' + # 'prodm_op_gl-mn_20160922_12_d*_thsfcs_5K.nc', 'dimensionless_exner_function') # dexs[-1] = iris.util.new_axis(dexs[-1], 'time') # dex = dexs.concatenate_cube() # # temps = iris.load('/export/cloud/NCASweather/ben/nawdex/mi-ar482/20160922_12/' + # 'prodm_op_gl-mn_20160922_12_d*_thsfcs_5K.nc', 'air_temperature') # temps[-1] = iris.util.new_axis(temps[-1], 'time') # temp = temps.concatenate_cube() # # lvls = ('air_potential_temperature', thlevs[k]) # # altd = convert.calc('altitude', iris.cube.CubeList([dex, temp]), levels = lvls) # # 3D caltra works on altitude not theta levels # # however I don't know how to get altitude?! # # I think leo's data must've have altitude as a coordinate cubes = iris.load(mapping[time], iris.Constraint(time=time)) plt.figure(figsize=(10, 14)) zc = iris.load( '/export/cloud/migrated-NCASweather/ben/nawdex/mi-ar482/' + basetime_str + '/prodm_op_gl-mn_' + basetime_str + '_d*_thsfcs_5K.nc', 'altitude') zc = zc[:-1].concatenate_cube() # the last time step has different metadata? for kl in xrange(levels): theta_level = thlevs[k][kl] trajectories = TrB.select('air_potential_temperature', '==', theta_level, time=start_time) x = trajectories.x[:, 0] y = trajectories.y[:, 0] # # tlev_cstrnt = iris.Constraint(air_potential_temperature = theta_level) # # altdth = altd.extract(tlev_cstrnt) lvls = ('air_potential_temperature', [theta_level]) w = convert.calc('upward_air_velocity', cubes, levels=lvls) # I think fairly arbitrary cube # z = grid.make_cube(w, 'altitude') # # altitude # # print z # # lvls = ('air_potential_temperature', [theta_level]) # # coord_name, values = lvls # I now need some way to interpolate altitude to desired theta level # z = interpolate.to_level(z, **{coord_name: values}) # z = convert.calc('altitude', iris.cube.CubeList([z]), levels = lvls) glon, glat = grid.get_xy_grids(w) gridpoints = np.array([glon.flatten(), glat.flatten()]).transpose() points = np.array([x, y]).transpose() pth = Path(points) # Mask all points that are not contained in the circuit mask = np.logical_not( pth.contains_points(gridpoints).reshape(glat.shape)) tlev_cstrnt = iris.Constraint(air_potential_temperature=theta_level) time_cstrnt = iris.Constraint(time=time) #try this for altitude z = zc.extract(tlev_cstrnt & time_cstrnt) plt.subplot(levels, 2, 2 * kl + 1) plt.contourf(mask, cmap='gray') masked_lon = [] masked_lat = [] alt_list = [] for i, col in enumerate(mask): for j, point in enumerate(col): if point == False: lat = glat[i, j] lon = glon[i, j] alt = z.data[i, j] masked_lon.append(lon) masked_lat.append(lat) alt_list.append(alt) plt.subplot(levels, 2, 2 * kl + 2) plt.scatter(masked_lon, masked_lat, s=2, c='k', marker='.', edgecolor='k') lt = len(masked_lon) points3d = np.zeros([lt, 3]) points3d[:, 0] = np.array(masked_lon) points3d[:, 1] = np.array(masked_lat) points3d[:, 2] = np.array(alt_list) pointsth = np.zeros([lt, 3]) pointsth[:, 0] = np.array(masked_lon) pointsth[:, 1] = np.array(masked_lat) pointsth[:, 2] = theta_level * np.ones([lt]) if kl == 0: outflow_volume = points3d outflow_volume_th = pointsth else: outflow_volume = np.concatenate((outflow_volume, points3d)) outflow_volume_th = np.concatenate((outflow_volume_th, pointsth)) np.save( '/storage/silver/scenario/bn826011/WCB_outflow/Final/' + folder + '/inflow/' + basetime_str + strapp + 'initial_grid.npy', outflow_volume) np.save( '/storage/silver/scenario/bn826011/WCB_outflow/Final/' + folder + '/inflow/' + basetime_str + strapp + 'initial_grid_thlevs.npy', outflow_volume_th) #plt.savefig('/glusterfs/msc/users_2018/bn826011/NAWDEX/Final/' + folder + '/' + basetime_str + strapp + '_masks.jpg') plt.show()
def load_nc_file(self): ''' Method to read a NetCDF file ''' if not self.quiet: print('>> Reading NetCDF file ' + self.ncfile) self.cubes = iris.load(self.ncfile)
def test_monotonic(self): cubes = iris.load( tests.get_data_path( ('NetCDF', 'testing', 'test_monotonic_coordinate.nc'))) self.assertCML(cubes, ('netcdf', 'netcdf_monotonic.cml'))
def main(): #experiment_ids = ['djzns', 'djznq', 'djzny', 'djznw', 'dkhgu', 'dkjxq', 'dklyu', 'dkmbq', 'dklwu', 'dklzq','dkbhu' ] experiment_ids = ['dkbhu', 'djznu', 'dkhgu' ] for experiment_id in experiment_ids: expmin1 = experiment_id[:-1] pfile = '%s%s/%s/%s.pp' % (pp_file_dir, expmin1, experiment_id, pp_file) ofile = '%s%s/%s/33.pp' % (pp_file_dir, expmin1, experiment_id) # Get min and max latitude/longitude and unrotate to get min/max corners to crop plot automatically - otherwise end with blank bits on the edges oc = iris.load_cube(ofile) lats = oc.coord('grid_latitude').points lons = oc.coord('grid_longitude').points print lons cs = oc.coord_system('CoordSystem') if isinstance(cs, iris.coord_systems.RotatedGeogCS): print 'Rotated CS %s' % cs lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_corners, lat_corners = np.meshgrid((lon_low, lon_high), (lat_low, lat_high)) lon_corner_u,lat_corner_u = unrotate.unrotate_pole(lon_corners, lat_corners, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude) lon_low = lon_corner_u[0,0] lon_high = lon_corner_u[0,1] lat_low = lat_corner_u[0,0] lat_high = lat_corner_u[1,0] else: lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_low_tick=lon_low -(lon_low%divisor) lon_high_tick=math.ceil(lon_high/divisor)*divisor lat_low_tick=lat_low - (lat_low%divisor) lat_high_tick=math.ceil(lat_high/divisor)*divisor print lat_high_tick print lat_low_tick plist = iris.load(pfile) pcubef=np.empty(oc.shape, np.float32) latitude = iris.coords.DimCoord(oc.coord('grid_latitude').points, standard_name='grid_latitude', units='degrees') longitude = iris.coords.DimCoord(oc.coord('grid_longitude').points, standard_name='grid_longitude', units='degrees') #latitude = iris.coords.DimCoord(oc.coord('grid_latitude').points, standard_name='grid_latitude', #iris.coord_systems.RotatedGeogCS(76.0, 263.0, ellipsoid=iris.coord_systems.GeogCS(6371229.0))) #longitude = iris.coords.DimCoord(oc.coord('grid_longitude').points, standard_name='grid_longitude', #iris.coord_systems.RotatedGeogCS(76.0, 263.0, ellipsoid=iris.coord_systems.GeogCS(6371229.0)))) for pcube in plist: armin = np.searchsorted(oc.coord('grid_longitude').points, min(pcube.coord('grid_longitude').points)) armax = np.searchsorted(oc.coord('grid_longitude').points, max(pcube.coord('grid_longitude').points)) pcubef[:,armin:armax+1] = pcube.data pc = iris.cube.Cube(pcubef,standard_name=pcube.standard_name, units =pcube.units,dim_coords_and_dims=[(oc.coord('grid_latitude'), 0), (oc.coord('grid_longitude'), 1)]) print pc plt.figure(figsize=(8,8)) cmap= cmap=plt.cm.YlOrRd ax = plt.axes(projection=ccrs.PlateCarree(), extent=(lon_low,lon_high,lat_low+degs_crop_bottom,lat_high-degs_crop_top)) clevs = np.linspace(min_contour, max_contour,16) cont = iplt.contourf(pc, clevs, cmap=cmap, extend='both') #plt.clabel(cont, fmt='%d') #ax.stock_img() ax.coastlines(resolution='110m', color='#262626') gl = ax.gridlines(draw_labels=True,linewidth=0.5, color='#262626', alpha=0.5, linestyle='--') gl.xlabels_top = False gl.ylabels_right = False gl.xlines = True gl.ylines = True dx, dy = 10, 10 gl.xlocator = mticker.FixedLocator(range(int(lon_low_tick),int(lon_high_tick)+dx,dx)) gl.ylocator = mticker.FixedLocator(range(int(lat_low_tick),int(lat_high_tick)+dy,dy)) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER gl.xlabel_style = {'size': 12, 'color':'black'} #gl.xlabel_style = {'color': '#262626', 'weight': 'bold'} gl.ylabel_style = {'size': 12, 'color':'black'} cbar = plt.colorbar(cont, orientation='horizontal', pad=0.05, extend='both', format = '%d') #cbar.set_label('') cbar.set_label(pcube.units, fontsize=10) cbar.set_ticks(np.arange(min_contour, max_contour+tick_interval,tick_interval)) ticks = (np.arange(min_contour, max_contour+tick_interval,tick_interval)) cbar.set_ticklabels(['%d' % i for i in ticks]) main_title=pcube.standard_name.title().replace('_',' ') model_info=re.sub('(.{68}. )', '\\1\n', str(model_name_convert_title.main(experiment_id)), 0, re.DOTALL) model_info = re.sub(r'[(\']', ' ', model_info) model_info = re.sub(r'[\',)]', ' ', model_info) print model_info if not os.path.exists('%s%s/%s' % (save_path, experiment_id, pp_file)): os.makedirs('%s%s/%s' % (save_path, experiment_id, pp_file)) plt.savefig('%s%s/%s/%s_%s_notitle.png' % (save_path, experiment_id, pp_file, experiment_id, pp_file), format='png', bbox_inches='tight') plt.title('\n'.join(wrap('%s\n%s' % (main_title, model_info), 1000,replace_whitespace=False)), fontsize=16) #plt.show() plt.savefig('%s%s/%s/%s_%s.png' % (save_path, experiment_id, pp_file, experiment_id, pp_file), format='png', bbox_inches='tight') plt.close()
def test_duplication(self): cubes = iris.load(self._data_path) self.assertRaises(iris.exceptions.DuplicateDataError, (cubes + cubes).merge) cubes2 = (cubes + cubes).merge(unique=False) self.assertEqual(len(cubes2), 2 * len(cubes))
def _extr_var_n_calc_abs_tas(short_name, var, cfg, filepath, out_dir): """Extract variable.""" # load tas anomaly, climatology and sftlf with catch_warnings(): filterwarnings( action='ignore', message='Ignoring netCDF variable .* invalid units .*', category=UserWarning, module='iris', ) filterwarnings( action='ignore', message='.* not used since it\ncannot be safely cast to variable' ' data type *', category=UserWarning, module='iris', ) cubes = iris.load(filepath) # tas anomaly raw_var = var.get('raw', short_name) cube_anom = cubes.extract(utils.var_name_constraint(raw_var))[0] # tas climatology raw_var_clim = var.get('rawclim', short_name) cube_clim = cubes.extract(utils.var_name_constraint(raw_var_clim))[0] # information on time for the climatology are only present in the long_name climstart, climend = [ int(x) for x in re.findall(r"\d{4}", cube_clim.long_name) ] # redo the broken time coordinate cube_anom, cube_clim = reinit_broken_time(cube_anom, cube_clim, climstart, climend) # derive absolute tas values cube_abs = calc_abs_temperature(cube_anom, cube_clim, short_name) # fix coordinates logger.info("Fixing coordinates") attrs = cfg['attributes'] attrs['mip'] = var['mip'] short_names = [short_name, var['short_anom']] for s_name, cube in zip(short_names, [cube_abs, cube_anom]): cmor_info = cfg['cmor_table'].get_variable(var['mip'], s_name) utils.fix_coords(cube) if 'height2m' in cmor_info.dimensions: utils.add_height2m(cube) cube.units = var['raw_units'] if s_name != 'tasa': cube.convert_units(cmor_info.units) utils.fix_var_metadata(cube, cmor_info) # save temperature data logger.info("Saving temperature data") comments = { 'tas': "Temperature time-series calculated from the anomaly " "time-series by adding the temperature climatology " "for {}-{}".format(climstart, climend), 'tasa': "Temperature anomaly with respect to the period" " {}-{}".format(climstart, climend) } for s_name, cube in zip(short_names, [cube_abs, cube_anom]): attrs['comment'] = comments[s_name] utils.set_global_atts(cube, attrs) utils.save_variable(cube, s_name, out_dir, attrs, unlimited_dimensions=['time']) # sftlf # extract sftlf raw_var_sftlf = var.get('rawsftlf', short_name) cube_sftlf = cubes.extract(utils.var_name_constraint(raw_var_sftlf))[0] # fix coordinates utils.fix_coords(cube_sftlf) # cmorize sftlf units cmor_info_sftlf = cfg['cmor_table'].get_variable(var['rawsftlf_mip'], var['rawsftlf_varname']) attrs_sftlf = cfg['attributes'] attrs_sftlf['mip'] = var['rawsftlf_mip'] if 'rawsftlf_units' in var: if 'rawsftlf_units' in var: cube_sftlf.units = var['rawsftlf_units'] cube_sftlf.convert_units(cmor_info_sftlf.units) # fix metadata and save logger.info("Saving sftlf") utils.fix_var_metadata(cube_sftlf, cmor_info_sftlf) utils.set_global_atts(cube_sftlf, attrs_sftlf) utils.save_variable(cube_sftlf, var['rawsftlf_varname'], out_dir, attrs_sftlf)
#times_range=np.argwhere((times_ceres >= tdi) & (times_ceres <=tde)) #times_range=np.logical_and([times_ceres >= tdi],[times_ceres <=tde])[0] coord = np.zeros([len(grid_lon_2[0, ].flatten()), 2]) coord[:, 0] = grid_lon_2[0, ].flatten() coord[:, 1] = grid_lat_2[0, ].flatten() #X,Y=np.meshgrid(model_lons, model_lats) #grid_z0 = sc.interpolate.griddata(coord, sat_SW, (X,Y), method='nearest') grid_z1 = sc.interpolate.griddata(coord, mean_run2, (grid_lon_12, grid_lat_12), method='linear') plt.imshow(grid_z1[:, :]) plt.colorbar() run12 = iris.load(jle.store + 'sample_12km.nc')[0] run2 = iris.load(jle.store + 'sample_2km.nc')[0] run2 = iris.load(jle.store + 'sample_12km.nc')[0] regrided_cube = run2.regrid(run12, iris.analysis.Linear()) plt.imshow(regrided_cube[0, :, :].data) plt.imshow(run2[0, :, :].data) plt.colorbar() #rotated_air_temp = global_air_temp.regrid(rotated_psl, iris.analysis.Linear()) #%% bm = Basemap() # default: projection='cyl'
def test_colpex(self): cubes = iris.load(self._data_path) self.assertEqual(len(cubes), 3) self.assertCML(cubes, ("COLPEX", "small_colpex_theta_p_alt.cml"))
def test_monotonic(self): cubes = iris.load( tests.get_data_path( ('NetCDF', 'testing', 'test_monotonic_coordinate.nc'))) cubes = sorted(cubes, key=lambda cube: cube.var_name) self.assertCML(cubes, ('netcdf', 'netcdf_monotonic.cml'))
def test_normal_cubes(self): cubes = iris.load(self._data_path) self.assertEqual(len(cubes), self._num_cubes) self.assertCML(cubes, ["merge", self._prefix + ".cml"])
sat_lon = longitude.flatten() sat_lat = latitude.flatten() sat_data = data.flatten() #for att in sds.attributes(): # print att plt.imshow(data) plt.colorbar() plt.show() #%% sim_path = '/nfs/a201/eejvt/CASIM/SO_KALLI/' sub_folder = 'L1/' sub_folder = 'All_time_steps/' code = 'top_temp' code = 'm01s01i208' cloud_top = iris.load( ukl.Obtain_name(sim_path + 'TRY2/ALL_ICE_PROC/' + sub_folder, code))[0] cloud_top = iris.load( ukl.Obtain_name(sim_path + 'TRY2/LARGE_DOMAIN/' + sub_folder, code))[0] mb = netCDF4.Dataset( path + 'modis/' + 'MYD06_L2.A2014343.1325.006.2014344210847.nc', 'r') mb.variables['Cloud_Mask_1km'] #plt.imshow(mb.variables['Cloud_Fraction']) sat_dat = mb.variables['Cloud_Fraction'][:, ].flatten() sat_dat = mb.variables['Cloud_Mask_1km'][:, ].flatten() coord = np.zeros([len(sat_lon), 2]) coord[:, 0] = sat_lon coord[:, 1] = sat_lat cm = plt.cm.RdBu_r model_lons, model_lats = stc.unrotated_grid(cloud_top) X, Y = np.meshgrid(model_lons, model_lats) reload(stc)
if __name__ == "__main__": import doctest import warnings warnings.simplefilter("ignore") doctest.testmod() from pyaerocom.io.testfiles import get from pyaerocom import GriddedData files = get() data = GriddedData(files['models']['aatsr_su_v4.3'], var_name="od550aer") lons = data.grid.coord("longitude") try: get_lon_constraint(lon_range=(170, -160), meridian_centre=True) except ValueError: print("Expected behaviour") from iris import load cubes = load(files['models']['aatsr_su_v4.3']) lons = cubes[0].coord("longitude").points meridian_centre = True if lons.max() > 180 else False c = get_constraint(var_names="od550aer", lon_range=(50, 150), lat_range=(20, 60), time_range=("2008-02-01", "2008-02-05")) cube_crop = cubes.extract(c)[0] print(start_stop_str(2010, '15-2-2018', ts_type='monthly'))
import numpy as np import iris file1 = '/group_workspaces/jasmin2/gassp/eeara/2008/bb295a.pm2008apr.pp' file2 = '/group_workspaces/jasmin2/gassp/eeara/ba471a.p42014apr.pp' name1 = [] name2 = [] print 'start' cube1 = iris.load(file1) print '\ncube1 completed\n' cube2 = iris.load(file2) print 'completed' for i in cube1: name1 = np.append(name1, i.name()) for j in cube2: name2 = np.append(name2, j.name())
#username=getpass.getuser() plt.interactive(0) #files_directory='/nfs/a201/'+username+'/UKCA_TEST_FILES/tebxd/' #saving_folder=files_directory+'PLOTS' files_directory = output_files_directory folders = [files_directory + 'All_time_steps/', files_directory + 'L1/'] #folders=[files_directory+'L1/'] for data_folder in folders: saving_folder = data_folder + 'PLOTS/' ukl.create_folder(saving_folder) nc_files = glob(data_folder + '*nc') for nc_file in nc_files: #mb=netCDF4.Dataset(nc_file,'r') cube = iris.load(nc_file)[0] cube = cube.collapsed(['time'], iris.analysis.MEAN) print cube.var_name print cube.shape try: if cube.ndim == 2: qplt.contourf(cube, cmap=plt.cm.RdBu_r) plt.gca().coastlines() stash = '' try: stash = ukl.get_stash(cube) except: stash = 'L1' if isinstance(cube.var_name, str) or isinstance( cube.var_name, unicode):