output_name = arg if opt in ("-v", "--variables"): variables = arg.split(',') if opt in ("-e", "--exclude"): exclude = arg.split(',') if len(args) != 1: print "ERROR! Please specify one input file. Exiting..." exit(-1) input_name = args[0] if output_name == "": output_name = splitext(input_name)[0] + '.mat' except GetoptError: print_options_and_exit(-1) try: input_file = NC(input_name, "r") except Exception, message: print "ERROR: ", message print "Can't open %s. Exiting..." % (input_name) exit(-1) print "Reading data from %s..." % (input_name) # if no variables were specified, assume that we need to dump them all if variables == []: variables = input_file.variables.keys() print "Loading variables...", mdict = {} missing = [] for each in variables:
'select minimum: if -c is used then above this value (of -s var) the points will not be plotted' ) parser.add_argument('-wmin', type=float, default=None, help='lower limit on W axis') parser.add_argument('-wmax', type=float, default=None, help='upper limit on W axis') args = parser.parse_args() try: nc = NC(args.filename, 'r') except: print "ERROR: can't read from file ..." sys.exit(1) print " reading 'bwprel' field from file %s ..." % (args.filename) try: bwprel = nc.variables["bwprel"] except: print "ERROR: variable 'bwprel' not found ..." sys.exit(2) print " reading 'bwat' field from file %s ..." % (args.filename) try: bwat = nc.variables["bwat"] except:
default="age") options = parser.parse_args() fill_value = -2e9 variables = options.variables.split(",") n_levels = options.n_levels age_iso = np.fromstring(options.age_iso, dtype=float, sep=",") n_age_iso = len(age_iso) print("-----------------------------------------------------------------") print(("Running script %s ..." % __file__.split("/")[-1])) print("-----------------------------------------------------------------") print(("Opening NetCDF file %s ..." % options.INPUTFILE[0])) try: # open netCDF file in 'read' mode nc_in = NC(options.INPUTFILE[0], "r") except: print(( "ERROR: file '%s' not found or not NetCDF format ... ending ..." % options.INPUTFILE[0])) import sys sys.exit() # get file format format = nc_in.file_format # get the dimensions xdim, ydim, zdim, tdim = ppt.get_dims(nc_in) # read projection information projection = ppt.get_projection_from_file(nc_in) # new sigma coordinate with n_levels
nargs="+", dest="tests_to_plot", default=None, help="Test results to plot (space-delimited list)") parser.add_argument("--save_figures", dest="save_figures", action="store_true", help="Save figures to .png files") parser.add_argument("--file_format", dest="file_format", default="png", help="File format for --save_figures (png, pdf, jpg, ...)") options = parser.parse_args() input_file = NC(options.filename, 'r') available_tests = unique(array(list(map(chr, input_file.variables['test'][:])))) tests_to_plot = options.tests_to_plot if len(available_tests) == 1: if tests_to_plot == None: tests_to_plot = available_tests else: if (tests_to_plot == None): print("""Please choose tests to plot using the -t option. (Input file %s has reports for tests %s available.)""" % (input, str(available_tests))) sys.exit(0) if (tests_to_plot[0] == "all"):
options = parser.parse_args() args = options.FILE start = 0 end = 1000 step = 1. / 12. amplitude = options.amplitude t_max = options.t_max T_max = options.T_max bnds_interval_since_refdate = np.linspace(start, end, end * 12 + 1) time_interval_since_refdate = (bnds_interval_since_refdate[0:-1] + np.diff(bnds_interval_since_refdate) / 2) infile = args[0] nc = NC(infile, 'w') def def_var(nc, name, units): var = nc.createVariable(name, 'f', dimensions=('time')) var.units = units return var # create a new dimension for bounds only if it does not yet exist time_dim = "time" if time_dim not in list(nc.dimensions.keys()): nc.createDimension(time_dim) # create a new dimension for bounds only if it does not yet exist bnds_dim = "nb2"
def plot_basin_mass(): fig = plt.figure() offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans) ax = fig.add_subplot(111) mass_var_vals_positive_cum = 0 mass_var_vals_negative_cum = 0 for k, ifile in enumerate(ifiles): basin = basin_list[k] print('reading {}'.format(ifile)) nc = NC(ifile, 'r') t = nc.variables["time"][:] date = np.arange(start_year + step, start_year + (len(t[:]) + 1) * step, step) idx = np.where(np.array(date) == time_bounds[-1])[0][0] mvar = 'ice_mass' mass_var_vals = -np.squeeze(nc.variables[mvar][:] - nc.variables[mvar][0]) * gt2mSLE iunits = nc.variables[mvar].units mass_var_vals = unit_converter(mass_var_vals, iunits, mass_ounits) if mass_var_vals[idx] > 0: ax.fill_between(date[:], mass_var_vals_positive_cum, mass_var_vals_positive_cum + mass_var_vals[:], color=basin_col_dict[basin], linewidth=0, label=basin) else: print mass_var_vals[idx] ax.fill_between(date[:], mass_var_vals_negative_cum, mass_var_vals_negative_cum + mass_var_vals[:], color=basin_col_dict[basin], linewidth=0, label=basin) plt.rcParams['hatch.color'] = basin_col_dict[basin] plt.rcParams['hatch.linewidth'] = 0.1 ax.fill_between(date[:], mass_var_vals_negative_cum, mass_var_vals_negative_cum + mass_var_vals[:], facecolor="none", hatch="XXXXX", edgecolor="k", linewidth=0.0) if mass_var_vals[idx] > 0: ax.plot(date[:], mass_var_vals_positive_cum + mass_var_vals[:], color='k', linewidth=0.1) else: ax.plot(date[:], mass_var_vals_negative_cum + mass_var_vals[:], color='k', linewidth=0.1) offset = 0 if mass_var_vals[idx] > 0: try: x_sle, y_sle = date[idx] + offset, mass_var_vals_positive_cum[ idx] except: # first iteratio x_sle, y_sle = date[idx] + offset, mass_var_vals_positive_cum else: try: x_sle, y_sle = date[idx] + offset, mass_var_vals_negative_cum[ idx] + mass_var_vals[idx] except: # first iteration x_sle, y_sle = date[ idx] + offset, mass_var_vals_negative_cum + mass_var_vals[ idx] nc.close() if mass_var_vals[idx] > 0: mass_var_vals_positive_cum += mass_var_vals else: mass_var_vals_negative_cum += mass_var_vals ax.hlines(0, time_bounds[0], time_bounds[-1], lw=0.25) legend = ax.legend(loc="upper right", edgecolor='0', bbox_to_anchor=(0, 0, 1.15, 1), bbox_transform=plt.gcf().transFigure) legend.get_frame().set_linewidth(0.2) ax.set_xlabel('Year (CE)') ax.set_ylabel('$\Delta$(GMSL) (m)') if time_bounds: ax.set_xlim(time_bounds[0], time_bounds[1]) if bounds: ax.set_ylim(bounds[0], bounds[-1]) if rotate_xticks: ticklabels = ax.get_xticklabels() for tick in ticklabels: tick.set_rotation(30) else: ticklabels = ax.get_xticklabels() for tick in ticklabels: tick.set_rotation(0) if title is not None: plt.title(title) for out_format in out_formats: out_file = outfile + '_' + mvar + '.' + out_format print " - writing image %s ..." % out_file fig.savefig(out_file, bbox_inches='tight', dpi=out_res)
help="Maximum backpressure fraction", default=0.3) parser.add_argument("-n", dest="n", type=float, help="power-law exponent", default=2) options = parser.parse_args() args = options.FILE n = options.n backpressure_max = options.backpressure_max infile = args[0] nc = NC(infile, "a") temp = nc.variables["delta_T"][:] def def_var(nc, name, units): var = nc.createVariable(name, "f", dimensions=("time")) var.units = units return var T_max = 0 T_min = -10 psi_min = 0.01 psi_max = 1.0
xExtent = 500 # in km standard_gravity = 9.81 # g B0 = 1.9e8 # ice hardness rho_ice = 910.0 # in kg/m^3 rho_ocean = 1028.0 # in kg/m^3 # create config overwrite file as used in T. Albrecht, M. A. Martin, R. Winkelmann, M. Haseloff, A. Levermann; Parameterization for subgrid-scale motion of ice-shelf calving fronts; (2011), The Cryosphere 5, 35-44, DOI:10.5194/tc-5-35-2011. '''Generates a config file containing flags and parameters for a particular experiment and step. This takes care of flags and parameters that *cannot* be set using command-line options. (We try to use command-line options whenever we can.) ''' filename = "flowline_config.nc" nc = NC(filename, 'w', format="NETCDF3_CLASSIC") var = nc.createVariable("pism_overrides", 'i') attrs = { "ocean.always_grounded": "no", "geometry.update.use_basal_melt_rate": "no", "stress_balance.ssa.compute_surface_gradient_inward": "no", "flow_law.isothermal_Glen.ice_softness": (B0)**-3, "constants.ice.density": rho_ice, "constants.sea_water.density": rho_ocean, "bootstrapping.defaults.geothermal_flux": 0.0, "stress_balance.ssa.Glen_exponent": 3.0, "constants.standard_gravity": standard_gravity, "ocean.sub_shelf_heat_flux_into_ice": 0.0, "stress_balance.sia.bed_smoother.range": 0.0, }
exit(2) # read specmap.017 print "reading data from ", SPEC_FILE try: years_sea, d18Osea = loadtxt(SPEC_FILE, skiprows=2, unpack=True) except IOError: print 'ERROR: File: ' + SPEC_FILE + ' could not be found.' exit(2) years_sea *= 1000.0 # compute sea level from \delta 18^O; see C. Ritz, 1997. "EISMINT # intercomparison experiment comparison of existing Greenland models" dSea = -34.83 * (d18Osea + 1.93) # open the nc for delta Sea Level file to write to ncfile = NC(DSL_FILE, 'w', format='NETCDF3_CLASSIC') # set global attributes historysep = ' ' historystr = asctime() + ': ' + historysep.join(argv) + '\n' setattr(ncfile, 'history', historystr) # define time dimension, then time variable Stdim = ncfile.createDimension('t', None) Stvar = ncfile.createVariable('t', 'f4', ('t', )) setattr(Stvar, 'units', 'years since 1-1-1') # define climate data variables and attributes d18Oseavar = ncfile.createVariable('delta_18_O', 'f4', ('t', )) setattr(d18Oseavar, 'units', 'normalized O-18') # see specmap_readme.txt setattr(d18Oseavar, 'long_name',
Bcount = Bcount + 1 else: # accumulation (m/a -> m/s) acc[Acccount / int(dim[1]), Acccount % int(dim[1])] = float(line) Acccount = Acccount + 1 x = x + 1 # done reading from data file input.close() print "Total Values Read: " + str(x) # replace zero (used to represent missing values in the input file) with a # value outside the valid range putmask(B, B == 0, topg_fill_value) # ready to write NetCDF file ncfile = NC(WRIT_FILE, 'w', format='NETCDF3_CLASSIC') # set global attributes ncfile.Conventions = 'CF-1.4' historysep = ' ' historystr = time.asctime() + ': ' + historysep.join(sys.argv) + '\n' ncfile.history = historystr # define the dimensions xdim = ncfile.createDimension('x', int(dim[1])) ydim = ncfile.createDimension('y', int(dim[0])) # define the variables polarVar = ncfile.createVariable('mapping', 'i4') xvar = ncfile.createVariable('x', 'f8', dimensions=('x', )) yvar = ncfile.createVariable('y', 'f8', dimensions=('y', ))
# set up the option parser parser = ArgumentParser() parser.description = "Pasting 3d fields from subset domain into large domain." parser.add_argument("FILE", nargs=2, help="Small and large domain files with 3d fields", default=None) options = parser.parse_args() file_sm = options.FILE[0] file_lg = options.FILE[1] print(("Pasting regrid fields from {} to {}".format(file_sm, file_lg))) nc_sm = NC(file_sm, "r") nc_lg = NC(file_lg, "a") x_sm = nc_sm.variables["x"][:] y_sm = nc_sm.variables["y"][:] x_lg = nc_lg.variables["x"][:] y_lg = nc_lg.variables["y"][:] # latitude lower and upper index y_li = np.argmin(np.abs(y_lg - y_sm[0])) y_ui = np.argmin(np.abs(y_lg - y_sm[-1])) # longitude lower and upper index x_li = np.argmin(np.abs(x_lg - x_sm[0])) x_ui = np.argmin(np.abs(x_lg - x_sm[-1]))
time = zeros([datalength - datastart]) slev = zeros([datalength - datastart]) for linecount, line in enumerate(f.readlines()): for entrycount, entry in enumerate(line.split("\t")): if linecount >= datastart and linecount < datalength: if entrycount == 0: time[linecount - datastart] = float(entry) * (-1.0e3) elif entrycount == 1: slev[linecount - datastart] = float(entry) f.close() # ######################################################################### timeseries = 'timeseries_spratt16_sl.nc' ncf = NC(timeseries, 'w', format='NETCDF3_CLASSIC') # define time dimension, then time variable, then attributes timedim = ncf.createDimension('time', None) yearvar = ncf.createVariable('time', 'f4', dimensions=('time', )) setattr(yearvar, 'units', 'years since 1950-01-01') #os.system("chmod 775 " + timeseries + " 2> /dev/null") sealevel = ncf.createVariable('delta_SL', 'f4', dimensions=('time', )) setattr(sealevel, 'units', 'meters') setattr(sealevel, 'interpolation', 'linear') sealevel.long_name = 'Relative Sea Level (variation from present)' setattr(sealevel, 'standard_name', 'global_average_sea_level_change') yearvar[:] = time[:] #+50.0 sealevel[:] = slev[:] - slev[0]
if e != 0: exit(1) e = system( "ncks -O -v temp -d z,0 foo-temp-continuity.nc temp-temp-continuity.nc" ) if e != 0: exit(1) e = system( "ncks -O -v litho_temp -d zb,10 foo-temp-continuity.nc litho_temp-temp-continuity.nc" ) if e != 0: exit(1) nc1 = NC("temp-temp-continuity.nc") nc2 = NC("litho_temp-temp-continuity.nc") temp = squeeze(nc1.variables['temp'][:]) litho_temp = squeeze(nc2.variables['litho_temp'][:]) deltas.append(abs(temp - litho_temp).max()) # these deltas are observed to decrease O(dt^1) approximately, which is expected from theory for (dt, delta) in zip(dts, deltas): stderr.write("dt = %f, delta = %f\n" % (dt, delta)) # the only test is whether they decrease; no rate measured if any(diff(deltas) > 0): print(diff(deltas)) exit(1)
#!/usr/bin/env python from numpy import * try: from netCDF4 import Dataset as NC except: from netCDF3 import Dataset as NC from pylab import * nc_no = NC("ts_no_force.nc", "r") nc_with = NC("ts_with_force.nc", "r") nc_weak = NC("ts_weak_force.nc", "r") t = nc_no.variables["t"][:] ivol_no = nc_no.variables["ivol"][:] ivol_with = nc_with.variables["ivol"][:] ivol_weak = nc_weak.variables["ivol"][:] plot(t, ivol_no * 1.0e-15, '-o', t, ivol_with * 1.0e-15, '-o', t, ivol_weak * 1.0e-15, '-o', t, 2.82528 * ones(shape(t)),'--k') legend( ('no forcing', 'alpha = 0.002 (default)', 'alpha = 0.0002', 'target volume'), loc='right') xlabel("t (years)", size=16) ylabel("ice volume (10^6 km^3)", size=16) grid(True)
def adjust_timeline( filename, start_date="2015-1-1", interval=1, interval_type="mid", bounds=True, periodicity="yearly".upper(), ref_date="2008-1-1", ref_unit="days", calendar="standard", ): nc = NC(filename, "a") nt = len(nc.variables["time"]) time_units = "%s since %s" % (ref_unit, ref_date) time_calendar = calendar cdftime = utime(time_units, time_calendar) # create a dictionary so that we can supply the periodicity as a # command-line argument. pdict = {} pdict["SECONDLY"] = rrule.SECONDLY pdict["MINUTELY"] = rrule.MINUTELY pdict["HOURLY"] = rrule.HOURLY pdict["DAILY"] = rrule.DAILY pdict["WEEKLY"] = rrule.WEEKLY pdict["MONTHLY"] = rrule.MONTHLY pdict["YEARLY"] = rrule.YEARLY prule = pdict[periodicity] # reference date from command-line argument r = time_units.split(" ")[2].split("-") refdate = datetime(int(r[0]), int(r[1]), int(r[2])) # create list with dates from start_date for nt counts # periodicity prule. bnds_datelist = list( rrule.rrule(freq=prule, dtstart=parse(start_date), count=nt + 1, interval=interval)) # calculate the days since refdate, including refdate, with time being the bnds_interval_since_refdate = cdftime.date2num(bnds_datelist) if interval_type == "mid": # mid-point value: # time[n] = (bnds[n] + bnds[n+1]) / 2 time_interval_since_refdate = bnds_interval_since_refdate[ 0:-1] + np.diff(bnds_interval_since_refdate) / 2 elif interval_type == "start": time_interval_since_refdate = bnds_interval_since_refdate[:-1] else: time_interval_since_refdate = bnds_interval_since_refdate[1:] # create a new dimension for bounds only if it does not yet exist time_dim = "time" if time_dim not in list(nc.dimensions.keys()): nc.createDimension(time_dim) # variable names consistent with PISM time_var_name = "time" bnds_var_name = "time_bnds" # create time variable if time_var_name not in nc.variables: time_var = nc.createVariable(time_var_name, "d", dimensions=(time_dim)) else: time_var = nc.variables[time_var_name] time_var[:] = time_interval_since_refdate time_var.units = time_units time_var.calendar = time_calendar time_var.standard_name = time_var_name time_var.axis = "T" if bounds: # create a new dimension for bounds only if it does not yet exist bnds_dim = "nb2" if bnds_dim not in list(nc.dimensions.keys()): nc.createDimension(bnds_dim, 2) # create time bounds variable if bnds_var_name not in nc.variables: time_bnds_var = nc.createVariable(bnds_var_name, "d", dimensions=(time_dim, bnds_dim)) else: time_bnds_var = nc.variables[bnds_var_name] time_bnds_var[:, 0] = bnds_interval_since_refdate[0:-1] time_bnds_var[:, 1] = bnds_interval_since_refdate[1::] time_var.bounds = bnds_var_name else: delattr(time_var, "bounds") nc.close()
parser.description = "Fill missing values by solving the Laplace equation in on the missing values and using present values as Dirichlet B.C." parser.add_argument("INPUT", nargs=1, help="Input file name.") parser.add_argument("OUTPUT", nargs=1, help="Output file name.") parser.add_argument("-a", "--all", dest="all", action="store_true", help="Process all variables.") parser.add_argument("-v", "--vars", dest="variables", help="comma-separated list of variables to process") options, _ = parser.parse_known_args() input_filename = options.INPUT[0] output_filename = options.OUTPUT[0] if options.all: nc = NC(input_filename) variables = list(nc.variables.keys()) nc.close() else: try: variables = (options.variables).split(',') except: PETSc.Sys.Print("Please specify variables using the -v option.") sys.exit(-1) # Done processing command-line options. comm = PETSc.COMM_WORLD rank = comm.getRank() t0 = time()
xcu, ycu = 50e3, y1 CL = (X - xcl) ** 2 + (Y - ycl) ** 2 < radius ** 2 CU = (X - xcu) ** 2 + (Y - ycu) ** 2 < radius ** 2 wall_elevation = 1000.0 if has_sidewalls: Zpi[np.logical_or(CL, CU)] = wall_elevation Zpi[np.logical_and((X < xcl), (Y < ycl + radius))] = wall_elevation Zpi[np.logical_and((X < xcu), (Y > ycu - radius))] = wall_elevation thk = Zspi - Zpi thk[X < x_s] = 0.0 thk[thk < 0] = 0.0 nc = NC(nc_outfile, "w", format=fileformat) nc.createDimension("x", size=x.shape[0]) nc.createDimension("y", size=y.shape[0]) var = "x" var_out = nc.createVariable(var, "d", dimensions=("x")) var_out.axis = "X" var_out.long_name = "X-coordinate in Cartesian system" var_out.standard_name = "projection_x_coordinate" var_out.units = "meters" var_out[:] = x var = "y" var_out = nc.createVariable(var, "d", dimensions=("y")) var_out.axis = "Y"
# load RIGGS data FROM D. MACAYEAL TO ELB ON 19 DEC 2006. try: print "Loading RIGGS data from '%s'..." % (riggs_file), RIGGS = loadtxt(riggs_file) # pylab now suggests numpy.loadtxt instead of # pylab's "load" print "done." except IOError: print """ERROR!\nMake sure that '%s' is in the expected location and try again. Exiting...""" % (riggs_file) exit(-1) # load the PISM output try: print "Loading PISM output from '%s'..." % (pism_output), infile = NC(pism_output, 'r') except Exception: print """ERROR!\nSpecify NetCDF file from PISM run with -p. See ross_plot.py --help and User's Manual. Exiting...""" exit(-1) def get_var(nc, name): """Get a 2D field from a NetCDF file, transposing if necessary. The returned array will always have the (y,x) variable order.""" var = nc.variables[name] dims = var.dimensions if dims.index('x') < dims.index('y'): # transpose return squeeze(var[:]).T
def plot_rcp_traj_mass(plot_var=mass_plot_vars): jet = cm = plt.get_cmap('jet') for k, rcp in enumerate(rcp_list): rcp_files = [f for f in ifiles if 'rcp_{}'.format(rcp) in f] if len(rcp_files) < 3: print('Less than 3 files found for {}, skipping'.format( rcp_dict[rcp])) else: print('Reading files for {}'.format(rcp_dict[rcp])) cdf_mass_enspctl16 = cdo.enspctl('16', input=rcp_files, returnCdf=True, options=pthreads) cdf_mass_enspctl84 = cdo.enspctl('84', input=rcp_files, returnCdf=True, options=pthreads) cdf_mass_ensmedian = cdo.enspctl('50', input=rcp_files, returnCdf=True, options=pthreads) t = cdf_mass_ensmedian.variables['time'][:] mass_enspctl16_vals = cdf_mass_enspctl16.variables[ plot_var][:] - cdf_mass_enspctl16.variables[plot_var][0] iunits = cdf_mass_enspctl16[plot_var].units mass_enspctl16_vals = -unit_converter(mass_enspctl16_vals, iunits, mass_ounits) * gt2mSLE mass_enspctl84_vals = cdf_mass_enspctl84.variables[ plot_var][:] - cdf_mass_enspctl84.variables[plot_var][0] iunits = cdf_mass_enspctl84[plot_var].units mass_enspctl84_vals = -unit_converter(mass_enspctl84_vals, iunits, mass_ounits) * gt2mSLE mass_ensmedian_vals = cdf_mass_ensmedian.variables[ plot_var][:] - cdf_mass_ensmedian.variables[plot_var][0] iunits = cdf_mass_ensmedian[plot_var].units mass_ensmedian_vals = -unit_converter(mass_ensmedian_vals, iunits, mass_ounits) * gt2mSLE date = np.arange(start_year + step, start_year + (len(t[:]) + 1) * step, step) for lhs_param in lhs_params_dict: param = lhs_params_dict[lhs_param] param_name = param['param_name'] param_scale_factor = param['scale_factor'] norm = mpl.colors.Normalize(vmin=param['vmin'], vmax=param['vmax']) scalarMap = cmx.ScalarMappable(norm=norm, cmap=jet) fig = plt.figure() offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans) ax = fig.add_subplot(111) for rcp_file in rcp_files: nc = NC(rcp_file, 'r') pism_config = nc.variables['pism_config'] param_value = getattr(pism_config, param_name) * param_scale_factor colorVal = scalarMap.to_rgba(param_value) cdf_rcp_mass_file = nc.variables[plot_var] mass_vals = nc.variables[plot_var][:] - nc.variables[ plot_var][0] iunits = cdf_rcp_mass_file.units mass_vals = -unit_converter(mass_vals, iunits, mass_ounits) * gt2mSLE ax.plot(date[:], mass_vals, alpha=0.3, linewidth=0.2, color=colorVal) nc.close() ax.plot(date[:], mass_ensmedian_vals, color='k', linewidth=0.5) ax.plot(date[:], mass_enspctl16_vals, color='k', linestyle='dashed', linewidth=0.25) ax.plot(date[:], mass_enspctl84_vals, color='k', linestyle='dashed', linewidth=0.25) idx = np.where(np.array(date) == time_bounds[-1])[0][0] m_median = mass_ensmedian_vals[idx] m_pctl16 = mass_enspctl16_vals[idx] m_pctl84 = mass_enspctl84_vals[idx] # x_sle, y_sle = time_bounds[-1], m_median # plt.text( x_sle, y_sle, '{: 1.2f}$\pm${:1.2f}'.format(m_median, m_diff), # color='k') # if do_legend: # legend = ax.legend(loc="upper right", # edgecolor='0', # bbox_to_anchor=(0, 0, .35, 0.88), # bbox_transform=plt.gcf().transFigure) # legend.get_frame().set_linewidth(0.0) ax.set_xlabel('Year (CE)') ax.set_ylabel('$\Delta$(GMSL) (m)') if time_bounds: ax.set_xlim(time_bounds[0], time_bounds[1]) if bounds: ax.set_ylim(bounds[0], bounds[1]) ymin, ymax = ax.get_ylim() ax.yaxis.set_major_formatter(FormatStrFormatter('%1.2f')) if rotate_xticks: ticklabels = ax.get_xticklabels() for tick in ticklabels: tick.set_rotation(30) else: ticklabels = ax.get_xticklabels() for tick in ticklabels: tick.set_rotation(0) title = '{} {}'.format(rcp_dict[rcp], lhs_params_dict[lhs_param]['symb']) if title is not None: plt.title(title) for out_format in out_formats: out_file = outfile + '_rcp' + '_' + rcp + '_' + lhs_param.lower( ) + '_' + plot_var + '.' + out_format print " - writing image %s ..." % out_file fig.savefig(out_file, bbox_inches='tight', dpi=out_res)
######## geometry setup (moritz.huetten@pik) ######### ### CONSTANTS ### secpera = 31556926. ice_density = 910.0 yExtent = 2 * 50 # in km xExtent = 2 * 800 # in km # load data from Stnd-experiment try: name = inpath # + '.nc' infile = NC(name, 'r') except Exception: print("file '%s' not found" % name) sys.exit(2) # exit(-1) x = squeeze(infile.variables["x"][:]) nx = len(x) boxWidth = x[nx - 1] / ((nx - 1) / 2) / 1e3 # grid size: # of boxes ny = int(np.floor(yExtent / boxWidth / 2) * 2 + 1) # make it an odd number # grid size: extent in km's, origin (0,0) in the center of the domain
default="interface.shp") parser.add_argument("-v", "--variable", dest="dst_fieldname", help="Name of variable to use", default="usurf") options = parser.parse_args() filename = options.FILE[0] epsg = options.epsg levels = np.array(options.levels.split(","), dtype=float) shp_filename = options.out_file ts_fieldname = "timestamp" dst_fieldname = options.dst_fieldname nc = NC(filename, "r") xdim, ydim, zdim, tdim = ppt.get_dims(nc) if tdim: time = nc.variables[tdim] time_units = time.units time_calendar = time.calendar cdftime = utime(time_units, time_calendar) timestamps = cdftime.num2date(time[:]) has_time = True else: tdim = None nc.close() src_ds = gdal.Open("NETCDF:{}:{}".format(filename, dst_fieldname))
def evalcase(stddev, cp, fn, deletencfiles): """evaluates one pclimate run against smb target in a file""" # input cp is of type Case() # input fn is of type Filenames() cp.stddev = stddev try: from netCDF4 import Dataset as NC except: from netCDF3 import Dataset as NC from objective import computeobjective configopt = " -config_override " + fn.configfile(cp) print " creating -config_override file %s ..." % fn.configfile(cp) try: nc_config = NC(fn.configfile(cp), 'w') except: usagefailure("ERROR: NETCDF FILE '%s' CANNOT BE OPENED FOR WRITING" \ % fn.configfile(cp) ) cp.put_pism_overrides(nc_config) nc_config.close() # change this to "mpiexec -n 8" or similar to run on multiple processes mpido = "" # coupler settings: Fausto 2m air temp parameterization, but default PDD # (w/o Greve/Fausto settings of PDD parameters) coupleropts = " -atmosphere searise_greenland -surface pdd" if cp.annualizepdd: coupleropts += " -pdd_annualize" timeopts = " -times 1990:1.0:1991" #dt = 0.0833333333 # monthly = (1/12) of year if len(fn.diffsfile) > 0: print " will add lines of text to " + fn.diffsfile + " ..." if deletencfiles: print " will delete NetCDF files %s and %s when no longer needed ..." % \ (fn.configfile(cp), fn.climatefile(cp)) # run PISM: command = mpido + " pclimate -i " + fn.startfile + coupleropts + configopt \ + timeopts + " -o " + fn.climatefile(cp) print " doing:" print " " + command try: (status, output) = commands.getstatusoutput(command) except KeyboardInterrupt: exit(2) if status: #exit(status) print status print output countvalid, avdiff, avL2, av2kL2 = computeobjective( fn.startfile, fn.climatefile(cp), fn.targetfile, "acab", "smb") print " result: " print " %d locations for valid (thk>0) comparison:" % countvalid print " average of signed differences (whole sheet) is %12.7f" % avdiff print " average of squared differences (whole sheet) is %12.7f" % avL2 print " average of squared differences (H < 2000) is %12.7f" % av2kL2 # FIXME: allow choice of weights weighted = 1.0 * avL2 + 3.0 * av2kL2 print " weighted average of above quantities is %12.7f" % weighted # write results to file if a file name was given, otherwise stdout lineoftxt = "%s %12.7f %12.7f %12.7f %12.7f\n" % \ (fn.climatefile(cp), avdiff, avL2, av2kL2, weighted) if len(fn.diffsfile) > 0: diffs = file(fn.diffsfile, 'a') diffs.write(lineoftxt) diffs.close() else: print " result in one line:" print lineoftxt # finalize: if option was given, clean up generated NetCDF file if deletencfiles: command = "rm -rf " + fn.configfile(cp) + " " + fn.climatefile(cp) print " doing:" print " " + command try: (status, output) = commands.getstatusoutput(command) except KeyboardInterrupt: exit(2) if status: #exit(status) print status print output print "" return avdiff
nco = Nco() # Set up the option parser parser = ArgumentParser() parser.description = "Extract basal enthalpy." parser.add_argument("INFILE", nargs=1) parser.add_argument("OUTFILE", nargs=1) options = parser.parse_args() infile = options.INFILE[0] outfile = options.OUTFILE[0] fill_value = -9999 nco.ncks(input=infile, output=outfile, variable='thk', overwrite=True) nc_in = NC(infile, 'r') nc_out = NC(outfile, 'a') z = nc_in.variables['z'][:] thk = nc_in.variables['thk'][:] basal_layer_thickness = 200 enthalpy = nc_in.variables['enthalpy'][:, :, :, z <= basal_layer_thickness] eb_values = np.sum(enthalpy, axis=3) eb_values[thk < 10] = fill_value eb_var = nc_out.createVariable('basal_enthalpy', 'f', dimensions=('time', 'y', 'x'), fill_value=fill_value) eb_var.comment = 'enthalpy in the lowermost {}m'.format(basal_layer_thickness) eb_var.units = 'J kg-1' eb_var.long_name = 'enthalpy in the lowermost {}m'.format(
import numpy as np from netCDF4 import Dataset as NC import os import re from glob import glob import pandas as pd infiles = glob(os.path.join("2018_09_les/scalar_clean", "ts_*.nc")) start_year = 2008 dfs = [] for infile in infiles: print(f"Processing {infile}") if os.path.isfile(infile): nc = NC(infile) m_id = int(re.search("id_(.+?)_", infile).group(1)) m_dx = int(re.search("gris_g(.+?)m", infile).group(1)) m_rcp = int(re.search("rcp_(.+?)_", infile).group(1)) m_m = np.squeeze(nc.variables["limnsw"][:]) / 1e12 m_m -= m_m[0] m_dm = np.squeeze(nc.variables["tendency_of_ice_mass_glacierized"][:]) / 1e12 m_dm -= m_dm[0] m_smb = np.squeeze(nc.variables["tendency_of_ice_mass_due_to_surface_mass_balance"][:]) / 1e12 m_d = np.squeeze(nc.variables["tendency_of_ice_mass_due_to_discharge"][:]) / 1e12 n = len(m_m) m_years = start_year + np.linspace(0, n - 1, n) dfs.append( pd.DataFrame( data=np.hstack(
sys.exit(0) ################## NetCDF write option ################# #### write a PISM-readable file with thickness only #### try: from netCDF4 import Dataset as NC except: from netCDF3 import Dataset as NC My = 3 dy = (2. * LL) / (float(Mx-1)) Lx = (dy * float(My)) / 2. # truely periodic in x direction ncfile = NC(ncfilename, 'w',format='NETCDF3_CLASSIC') # set global attributes historysep = ' ' historystr = time.asctime() + ': ' + historysep.join(sys.argv) + '\n' setattr(ncfile, 'history', historystr) setattr(ncfile, 'source', "PISM: examples/mismip/solverMS.py") # define the dimensions & variables xdim = ncfile.createDimension('x', Mx) ydim = ncfile.createDimension('y', My) xvar = ncfile.createVariable('x', 'f8', dimensions=('x',)) yvar = ncfile.createVariable('y', 'f8', dimensions=('y',)) Hvar = ncfile.createVariable('thk', 'f4', dimensions=('y', 'x')) # attributes of the variables
'85': '#31a354' }, 'NorESM1': { '45': '#bcbddc', '85': '#756bb1' } } fig, ax = plt.subplots() rus = [] tass = [] p_ols = [] for k, ifile in enumerate(options.FILE): print(ifile, k) nc = NC(ifile, 'r') forcing = nc.forcing gcm, rcp = forcing.split('-') rcp = rcp.split('rcp')[-1] tas = np.squeeze(nc.variables['ST'][:]) ru = np.squeeze(nc.variables['RU'][:]) tas -= tas.min() ru /= ru.min() rus.append(ru) tass.append(tas) print(gcm, rcp) ax.scatter(tas, ru, s=2.5, facecolors='none',
# Copyright (C) 2012, 2014, 2016, 2018 Moritz Huetten and Torsten Albrecht # create MISMIP config override file try: from netCDF4 import Dataset as NC except: print("netCDF4 is not installed!") sys.exit(1) filename = "MISMIP3D_conf.nc" print( ' creating MISMIP3D_conf.nc for configuration parameters (overrides) ...') nc = NC(filename, 'w', format="NETCDF3_CLASSIC") var = nc.createVariable("pism_overrides", 'i') attrs = { "ocean.always_grounded": "no", "geometry.update.use_basal_melt_rate": "no", "stress_balance.ssa.compute_surface_gradient_inward": "no", "flow_law.isothermal_Glen.ice_softness": 1.0e-25, "constants.ice.density": 900., "constants.sea_water.density": 1000., "bootstrapping.defaults.geothermal_flux": 0.0, "stress_balance.ssa.Glen_exponent": 3., "constants.standard_gravity": 9.81, "ocean.sub_shelf_heat_flux_into_ice": 0.0, "stress_balance.sia.bed_smoother.range": 0.0,
"altitude", "altitude", "ice thickness", "ice thickness", "ice thickness", ) var_name_dict = dict(list(zip(var_long, var_short))) flow_types = {0: "isbr{\\ae}", 1: "ice-stream", 2: "undefined"} glacier_types = {0: "ffmt", 1: "lvmt", 2: "ist", 3: "lt"} # Open first file filename = args[0] print((" opening NetCDF file %s ..." % filename)) try: nc0 = NC(filename, "r") except: print(("ERROR: file '%s' not found or not NetCDF format ... ending ..." % filename)) import sys sys.exit(1) # Get profiles from first file # All experiments have to contain the same profiles # Create flux gates profile_names = nc0.variables["profile_name"][:] flux_gates = [] for pos_id, profile_name in enumerate(profile_names): profile_axis = nc0.variables["profile_axis"][pos_id] profile_axis_units = nc0.variables["profile_axis"].units profile_axis_name = nc0.variables["profile_axis"].long_name
output_filename = options.output_filename eps = float(options.eps) # Done processing command-line options. print("Creating the temporary file...") try: (handle, tmp_filename) = mkstemp() close(handle) # mkstemp returns a file handle (which we don't need) copy(input_filename, tmp_filename) except IOError: print("ERROR: Can't create %s, Exiting..." % tmp_filename) try: nc = NC(tmp_filename, 'a') except Exception as message: print(message) print("Note: %s was not modified." % output_filename) exit(-1) # add history global attribute (after checking if present) historysep = ' ' historystr = asctime() + ': ' + historysep.join(argv) + '\n' if 'history' in nc.ncattrs(): nc.history = historystr + nc.history # prepend to history string else: nc.history = historystr t_zero = time() for name in variables:
""" w, h: width, height in inches """ if not ax: ax = plt.gca() l = ax.figure.subplotpars.left r = ax.figure.subplotpars.right t = ax.figure.subplotpars.top b = ax.figure.subplotpars.bottom figw = float(w) / (r - l) figh = float(h) / (t - b) ax.figure.set_size_inches(figw, figh) nc = NC("fldsum_synth_jib_runoff_g1000m.nc", "r") water_input_rate = np.squeeze(nc.variables["water_input_rate"][:]) nc.close() nc_r = NC("2019_12_routing/spatial/fldmax_ex_synth_jib_g1000m_id_ROUTING_0_10.nc", "r") nc_s = NC("2019_12_steady/spatial/fldmax_ex_synth_jib_g1000m_id_STEADY_0_10.nc", "r") calving_r = np.squeeze(nc_r.variables["vonmises_calving_rate"][:]) fm_r = np.squeeze(nc_r.variables["frontal_melt_rate"][:]) fm_s = np.squeeze(nc_s.variables["frontal_melt_rate"][:]) time = range(0, 365) fig = plt.figure() ax = fig.add_subplot(111) ax.plot(time, water_input_rate)