def write_rest(MOM,SIS,FLAGS):
# Load new restart files
# Out: Restart files ice_model.res.nc and MOM.res.nc; bathymetry file topog
# Change all ocean/ ice fields that need to be changed
# Save new fields to netCDF
# Write change mask to netCDF
if FLAGS.test:
chg_msk = CDF('/p/projects/climber3/huiskamp/POEM/work/slr_tool/test_data/change_mask.nc', 'w')
else:
if os.path.isfile(str(path)+'history/change_mask.nc') == False: # Does the change mask file exist yet? If not, make one
chg_msk = CDF(str(path)+'history/change_mask', 'w')
# Create dimensions for vars.
chg_msk.createDimension('lonh', lon.shape[1])
chg_msk.createDimension('lath', lat.shape[0])
chg_msk.createDimension('time', None)
chg_msk.createVariable('lonh', 'f8', ('lonh'));
chg_msk.variables['lonh'].units = 'degrees_east'
chg_msk.variables['lonh'].cartesian_axis = 'X'
chg_msk.variables['lonh'].long_name = 'T-cell longitude'
chg_msk.variables['lonh'][:] = grid.variables['lonh'][:]
chg_msk.createVariable('lath', 'f8', ('lath'));
chg_msk.variables['lath'].units = 'degrees_north'
chg_msk.variables['lath'].cartesian_axis = 'Y'
chg_msk.variables['lath'].long_name = 'T-cell latitude'
chg_msk.variables['lath'][:] = grid.variables['lath'][:]
chg_msk.createVariable('time')
# Define variables and fill data
# Cell change mask
chg_msk.createVariable('chng_mask', 'f8', ('lath','lonh'))
chg_msk.variables['chng_mask'].units = 'none'
chg_msk.variables['chng_mask'].long_name = 'Mask indicating changing ocean/ land cells'
chg_msk.variables['chng_mask'][:] = chng_mask[:]
# New ocean mask
chg_msk.createVariable('o_mask_new', 'f8', ('lath','lonh'))
chg_msk.variables['o_mask_new'].units = 'none'
chg_msk.variables['o_mask_new'].long_name = 'Updated ocean mask'
chg_msk.variables['o_mask_new'][:] = o_mask_new[:]
chg_msk.description = "This file contains a mask which lists cells that should change from \
ocean to land (-1) or land to ocean (1) as well as an updated land-sea mask"
chg_msk.history = "Created " + time.ctime(time.time())
chg_msk.source = "created using /p/projects/climber3/huiskamp/POEM/work/slr_tool/5_prep_restarts/prep_restarts.py"
chg_msk.close()
else:
chg_msk = CDF(str(path)+'history/change_mask.nc','r+');
# Write appropriate diagnostics to restart's metadata
def process(input, output, direction, collapse):
"""Process the file 'input', expanding or collapsing data according to
'action' and 'direction'. Saves result in 'output'."""
try:
nc = CDF(input)
except:
print "ERROR: Can't open %s" % input
exit(1)
try:
out = CDF(output, 'w', format="NETCDF3_CLASSIC")
except:
print "ERROR: Can't open %s" % output
exit(1)
copy_attributes(nc, out)
for name in nc.dimensions.keys():
copy_dim(nc, out, name, direction)
if collapse:
for name in nc.variables.keys():
if name == direction:
continue
collapse_var(nc, out, name, direction)
message = "Collapsed using flowline.py"
else:
out.createDimension(direction, 3)
if direction == 'x':
dim = 'y'
else:
dim = 'x'
var1 = nc.variables[dim]
delta = np.diff(var1[:])[0]
var2 = out.createVariable(direction, 'f8', (direction, ))
var2.axis = "%s" % direction.upper()
var2.long_name = "%s-coordinate in Cartesian system" % direction.upper(
)
var2.standard_name = "projection_%s_coordinate" % direction
var2.units = var1.units
var2[:] = [-delta, 0, delta]
for name in nc.variables.keys():
expand_var(nc, out, name, direction)
message = asctime() + ': ' + ' '.join(argv) + '\n'
if 'history' in out.ncattrs():
out.history = message + out.history # prepend to history string
else:
out.history = message
out.close()
def make_scalar_vars_ismip6_conforming(filename, ismip6_vars_dict):
'''
Make file ISMIP6 conforming
'''
# Open file
nc = CDF(filename, 'a')
pism_to_ismip6_dict = dict((v.pism_name, k) for k, v in ismip6_vars_dict.iteritems())
for pism_var in nc.variables:
nc_var = nc.variables[pism_var]
if pism_var in pism_to_ismip6_dict.keys():
ismip6_var = pism_to_ismip6_dict[pism_var]
print('Processing {} / {}'.format(pism_var, ismip6_var))
if not pism_var == ismip6_var:
print(' Renaming {pism_var} to {ismip6_var}'.format(pism_var=pism_var, ismip6_var=ismip6_var))
nc.renameVariable(pism_var, ismip6_var)
nc.sync()
if not nc_var.units == ismip6_vars_dict[ismip6_var].units:
o_units = ismip6_vars_dict[ismip6_var].units
i_units = nc_var.units
print(' Converting {pism_var} from {i_units} to {o_units}'.format(pism_var=pism_var, i_units=i_units, o_units=o_units))
i_f = cf_units.Unit(i_units)
o_f = cf_units.Unit(o_units)
nc_var[:] = i_f.convert(nc_var[:], o_f)
nc_var.units = o_units
nc_var.standard_name = ismip6_vars_dict[ismip6_var].standard_name
nc.close()
def adjust_time_axis(icesheet,filename):
'''
Adjusts the time axis
'''
nc = CDF(filename, 'a')
time = nc.variables['time']
time_bnds_var = time.bounds
time_bnds = nc.variables[time_bnds_var]
if icesheet=="GIS":
nt = len(time[:])
new_timeline = np.linspace(0, 100, nt, endpoint=True)
time[:] = new_timeline
time_bnds[:,0] = new_timeline - 5
time_bnds[:,1] = new_timeline
time.units = 'years since 2008-1-1'
elif icesheet=="AIS":
#time.units = 'years since 2000-1-1'
#time_bnds.units = 'years since 2000-1-1'
time.units = 'seconds since 2000-01-01 00:00:00'
time_bnds.units = 'seconds since 2000-01-01 00:00:00'
nc.close()
def open_ncfile(infile):
try:
nc = CDF(infile, 'r')
try:
'time' in nc.variables.keys()
except:
print('Variable t not found in file %s' % infile)
except IOError:
pass
return nc
def adjust_time_axis(ifile):
nc = CDF(ifile, "a")
# create list with dates from start_date until end_date with
# periodicity prule.
bnds_datelist = np.arange(0, 366)
# calculate the days since refdate, including refdate, with time being the
# mid-point value:
# time[n] = (bnds[n] + bnds[n+1]) / 2
bnds_interval_since_refdate = bnds_datelist
time_interval_since_refdate = bnds_interval_since_refdate[0:-1] + np.diff(
bnds_interval_since_refdate) / 2
# 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"
if bnds_dim not in list(nc.dimensions.keys()):
nc.createDimension(bnds_dim, 2)
# 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.bounds = bnds_var_name
time_var.units = "days since 2007-1-1"
time_var.calendar = "365_day"
time_var.standard_name = time_var_name
time_var.axis = "T"
# 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::]
nc.close()
def create_config():
print(" creating PISM-readable config override file gumparams.nc ...")
nc = CDF("gumparams.nc", 'w')
config = nc.createVariable("pism_overrides", 'i4')
attrs = {
"constants.standard_gravity": 9.81,
"constants.standard_gravity_doc": "m s-2; = g",
"constants.ice.density": 1000.0,
"constants.ice.density_doc": "kg m-3; 1% Xanthan gum in water has same density as water",
"stress_balance.sia.bed_smoother.range": -1.0,
"stress_balance.sia.bed_smoother.range_doc": "m; negative value de-activates bed smoother",
"bootstrapping.defaults.geothermal_flux": 0.0,
"bootstrapping.defaults.geothermal_flux_doc": "W m-2; no geothermal",
"output.runtime.time_unit_name": "second",
"output.runtime.time_unit_name_doc": "stdout uses seconds (not years) to show model time",
"output.runtime.time_use_calendar": "no",
"output.runtime.time_use_calendar_doc": "stdout does not use a calendar to show model time",
"output.runtime.volume_scale_factor_log10": -15,
"output.runtime.volume_scale_factor_log10_doc": "; an integer; log base 10 of scale factor to use for volume in summary line to stdout; -15 gives volume in cm^3",
"output.runtime.area_scale_factor_log10": -10,
"output.runtime.area_scale_factor_log10_doc": "; an integer; log base 10 of scale factor to use for area in summary line to stdout; -10 gives area in cm^2",
"geometry.ice_free_thickness_standard": 1e-8,
"geometry.ice_free_thickness_standard_doc": "m; only if the fluid is less than this is a cell marked as ice free",
"output.ice_free_thickness_standard": 1e-8,
"output.ice_free_thickness_standard_doc": "fluid layer exceeding this thickness is included in computations of areas and volumes",
"time_stepping.adaptive_ratio": 0.08,
"time_stepping.adaptive_ratio_doc": "; compare default 0.12; needs to be smaller because gum suspension is more shear-thinning than ice?",
"stress_balance.sia.Glen_exponent": 5.9,
"stress_balance.sia.Glen_exponent_doc": "; : n; Sayag & Worster (2013) give n = 5.9 +- 0.2",
"flow_law.isothermal_Glen.ice_softness": 9.7316e-09, # vs (e.g.) 4e-25 Pa-3 s-1 for ice
"ice_softness_doc": "Pa-n s-1; = A_0 = B_0^(-n) = (2 x 11.4 Pa s^(1/n))^(-n); Sayag & Worster (2013) give B_0/2 = tilde mu = 11.4 +- 0.25 Pa s^(1/n)"
}
keys = list(attrs.keys())
keys.sort()
for k in keys:
config.setncattr(k, attrs[k])
nc.close()
def add_projection_info(ncfile):
# if 'mapping' not in pism_vars_av:
print " Add 'mapping' information"
nc = CDF(ncfile, 'a')
mapping = nc.createVariable("mapping", 'c')
mapping.ellipsoid = "WGS84"
mapping.false_easting = 0.
mapping.false_northing = 0.
mapping.grid_mapping_name = "polar_stereographic"
mapping.latitude_of_projection_origin = -90.
mapping.standard_parallel = -71.
mapping.straight_vertical_longitude_from_pole = 0.
nc.close()
def create_config():
print " creating PISM-readable config override file gumparams.nc ..."
nc = CDF("gumparams.nc", 'w')
config = nc.createVariable("pism_overrides", 'i4')
config.standard_gravity = 9.81
config.standard_gravity_doc = "m s-2; = g"
config.ice_density = 1000.0
config.ice_density_doc = "kg m-3; 1% Xanthan gum in water has same density as water"
config.bed_smoother_range = -1.0
config.bed_smoother_range_doc = "m; negative value de-activates bed smoother"
config.bootstrapping_geothermal_flux_value_no_var = 0.0
config.bootstrapping_geothermal_flux_value_no_var_doc = "W m-2; no geothermal"
config.summary_time_unit_name = "second"
config.summary_time_unit_name_doc = "stdout uses seconds (not years) to show model time"
config.summary_time_use_calendar = "no"
config.summary_time_use_calendar_doc = "stdout does not use a calendar to show model time"
config.summary_vol_scale_factor_log10 = -15
config.summary_vol_scale_factor_log10_doc = "; an integer; log base 10 of scale factor to use for volume in summary line to stdout; -15 gives volume in cm^3"
config.summary_area_scale_factor_log10 = -10
config.summary_area_scale_factor_log10_doc = "; an integer; log base 10 of scale factor to use for area in summary line to stdout; -10 gives area in cm^2"
config.mask_icefree_thickness_standard = 1e-8
config.mask_icefree_thickness_standard_doc = "m; only if the fluid is less than this is a cell marked as ice free"
config.mask_is_floating_thickness_standard = 1e-8
config.mask_is_floating_thickness_standard_doc = "m; should not matter since all grounded"
config.adaptive_timestepping_ratio = 0.08
config.adaptive_timestepping_ratio_doc = "; compare default 0.12; needs to be smaller because gum suspension is more shear-thinning than ice?"
config.sia_Glen_exponent = 5.9
config.sia_Glen_exponent_doc = "; = n; Sayag & Worster (2013) give n = 5.9 +- 0.2"
config.ice_softness = 9.7316e-09 # vs (e.g.) 4e-25 Pa-3 s-1 for ice
config.ice_softness_doc = "Pa-n s-1; = A_0 = B_0^(-n) = (2 x 11.4 Pa s^(1/n))^(-n); Sayag & Worster (2013) give B_0/2 = tilde mu = 11.4 +- 0.25 Pa s^(1/n)"
nc.close()
(opts, args) = parser.parse_args()
if len(args) != 1:
print("ERROR: File argument is missing.")
exit(1)
if (opts.expand and opts.collapse) or ((not opts.expand) and (not opts.collapse)):
print("ERROR: exactly one of -e and -c is required.")
exit(1)
if not opts.direction:
if opts.collapse or (not opts.expand):
opts.direction = 'y'
else:
nc = CDF(args[0])
try:
x = nc.variables['x']
opts.direction = 'y'
except:
opts.direction = 'x'
nc.close()
elif opts.direction not in ['x', 'y']:
print("ERROR: Please specify direction using the -d option. (Choose one of x,y.)")
exit(1)
if (not opts.output_filename):
print("ERROR: Please specify the output file name using the -o option.")
exit(1)
if opts.collapse:
'#984EA3', # violet
'#FF7F00', # orange
'#FF7F00', # orange
'#FF7F00', # orange
'#377EB8', # light blue
'#377EB8', # light blue
'#377EB8', # light blue
'#4DAF4A'
] # green
dashes = ['-', '--', '-.', '-', '--', '-.', '-', '--', '-.', '-']
print "control run name is " + NCNAMES[0]
n = len(NCNAMES)
nc0 = CDF(NCNAMES[0], 'r')
try:
t_units = nc0.variables['tseries'].units
t = nc0.variables['tseries'][t_a:t_e]
except:
t_units = nc0.variables['time'].units
t = nc0.variables['time'][t_a:t_e]
nc0.close()
# convert to years if t is in seconds
if (t_units.split()[0] == ('seconds' or 's')):
t /= 3.15569259747e7
ivol = zeros((len(t), n))
ivolshift = zeros((len(t), n - 1))
"-t",
"--target_resolution",
dest="target_resolution",
type=int,
choices=[1000, 5000],
help="Horizontal grid resolution",
default=5000,
)
options = parser.parse_args()
experiment = options.experiment
infile = options.EXP_FILE[0]
target_resolution = options.target_resolution
# Need to get grid resolution from file
nc = CDF(infile, "r")
pism_grid_dx = int(round(nc.variables["run_stats"].grid_dx_meters))
nc.close()
PISM_GRID_RES_ID = str(pism_grid_dx / 100)
TARGET_GRID_RES_ID = str(target_resolution / 1000)
ID = options.id
IS = "GIS"
GROUP = "UAF"
MODEL = "PISM" + PISM_GRID_RES_ID + ID
EXP = experiment
TYPE = "_".join([EXP, "0" + TARGET_GRID_RES_ID])
INIT = "_".join(["init", "0" + TARGET_GRID_RES_ID])
project = "{IS}_{GROUP}_{MODEL}".format(IS=IS, GROUP=GROUP, MODEL=MODEL)
pism_stats_vars = ["pism_config", "run_stats"]
lat_ts=var_mapping.standard_parallel,
lat_0=var_mapping.latitude_of_projection_origin,
lon_0=var_mapping.straight_vertical_longitude_from_pole,
x_0=var_mapping.false_easting,
y_0=var_mapping.false_northing)
except:
print('No mapping information found, exiting.')
sys.exit(1)
return p
if __name__ == "__main__":
# open netCDF file in 'append' mode
nc = CDF(nc_outfile, 'a')
# a list of possible x-dimensions names
xdims = ['x', 'x1']
# a list of possible y-dimensions names
ydims = ['y', 'y1']
# assign x dimension
for dim in xdims:
if dim in list(nc.dimensions.keys()):
xdim = dim
# assign y dimension
for dim in ydims:
if dim in list(nc.dimensions.keys()):
ydim = dim
lat_ts=var_mapping.standard_parallel,
lat_0=var_mapping.latitude_of_projection_origin,
lon_0=var_mapping.straight_vertical_longitude_from_pole,
x_0=var_mapping.false_easting,
y_0=var_mapping.false_northing)
except:
print('No mapping information found, exiting.')
exit(1)
return p
if __name__ == "__main__":
## open netCDF file in 'append' mode
nc = CDF(nc_outfile, 'a', format='NETCDF3_CLASSIC')
## a list of possible x-dimensions names
xdims = ['x', 'x1']
## a list of possible y-dimensions names
ydims = ['y', 'y1']
## assign x dimension
for dim in xdims:
if dim in nc.dimensions.keys():
xdim = dim
## assign y dimension
for dim in ydims:
if dim in nc.dimensions.keys():
ydim = dim
]
#sub.call(cmd_ncre)
#add step forcing
ca_cmd = [
'python', 'create_anomalies.py', '--force_file', IM_filename,
'--background_file', PD_pism_climate, '{}'.format(final_filename)
]
#print ca_cmd
sub.call(ca_cmd)
#add x and y and mapping
ncks_cmd = ['ncks', '-A', '-v', 'x,y', IM_filename, final_filename]
sub.call(ncks_cmd)
nc = CDF(final_filename, 'a')
try:
mapping = nc.createVariable("mapping", 'c')
mapping.ellipsoid = "WGS84"
mapping.false_easting = 0.
mapping.false_northing = 0.
mapping.grid_mapping_name = "polar_stereographic"
mapping.latitude_of_projection_origin = -90.
mapping.standard_parallel = -71.
mapping.straight_vertical_longitude_from_pole = 0.
except:
print " Mapping seems to exist!"
nc.close()
#change units
ncatted_cmd = [
ice_thickness_threshold = 10.0
# PISM mask values:
pism_ice_free_bedrock = 0
pism_grounded = 2
pism_floating = 3
pism_ocean = 4
# SeaRISE mask values:
searise_ocean = 1
searise_ice_free_land = 2
searise_grounded_ice = 3
searise_floating_ice = 4
nc = CDF(input, 'a')
# number of records to process:
try:
N = len(nc.variables['t'][:])
except:
N = len(nc.variables['time'][:])
thk = nc.variables['thk']
mask = nc.variables['mask']
mask.flag_meanings = "ice_free_ocean ice_free_land grounded_ice floating_ice"
mask.flag_values = [1, 2, 3, 4]
mask.long_name = "integer mask specifying cell type"
for j in range(N):
def create_epsg3413_grid(ofile, grid_spacing):
xdim = "x"
ydim = "y"
# define output grid, these are the extents of Mathieu's domain (cell
# corners)
e0 = -638000
n0 = -3349600
e1 = 864700
n1 = -657600
# Add a buffer on each side such that we get nice grids up to a grid spacing
# of 36 km.
buffer_e = 148650
buffer_n = 130000
e0 -= buffer_e + 468000
n0 -= buffer_n
e1 += buffer_e
n1 += buffer_n
# Shift to cell centers
e0 += grid_spacing / 2
n0 += grid_spacing / 2
e1 -= grid_spacing / 2
n1 -= grid_spacing / 2
de = dn = grid_spacing # m
M = int((e1 - e0) / de) + 1
N = int((n1 - n0) / dn) + 1
easting = np.linspace(e0, e1, M)
northing = np.linspace(n0, n1, N)
ee, nn = np.meshgrid(easting, northing)
# Set up EPSG 3413 (NSIDC north polar stereo) projection
projection = "+init=epsg:3413"
proj = Proj(projection)
lon, lat = proj(ee, nn, inverse=True)
# number of grid corners
grid_corners = 4
# grid corner dimension name
grid_corner_dim_name = "nv4"
# array holding x-component of grid corners
gc_easting = np.zeros((M, grid_corners))
# array holding y-component of grid corners
gc_northing = np.zeros((N, grid_corners))
# array holding the offsets from the cell centers
# in x-direction (counter-clockwise)
de_vec = np.array([-de / 2, de / 2, de / 2, -de / 2])
# array holding the offsets from the cell centers
# in y-direction (counter-clockwise)
dn_vec = np.array([-dn / 2, -dn / 2, dn / 2, dn / 2])
# array holding lat-component of grid corners
gc_lat = np.zeros((N, M, grid_corners))
# array holding lon-component of grid corners
gc_lon = np.zeros((N, M, grid_corners))
for corner in range(0, grid_corners):
## grid_corners in x-direction
gc_easting[:, corner] = easting + de_vec[corner]
# grid corners in y-direction
gc_northing[:, corner] = northing + dn_vec[corner]
# meshgrid of grid corners in x-y space
gc_ee, gc_nn = np.meshgrid(gc_easting[:, corner], gc_northing[:,
corner])
# project grid corners from x-y to lat-lon space
gc_lon[:, :, corner], gc_lat[:, :, corner] = proj(gc_ee,
gc_nn,
inverse=True)
nc = CDF(ofile, "w")
nc.createDimension(xdim, size=easting.shape[0])
nc.createDimension(ydim, size=northing.shape[0])
var = xdim
var_out = nc.createVariable(var, "f", dimensions=(xdim))
var_out.axis = xdim
var_out.long_name = "X-coordinate in Cartesian system"
var_out.standard_name = "projection_x_coordinate"
var_out.units = "meters"
var_out[:] = easting
var = ydim
var_out = nc.createVariable(var, "f", dimensions=(ydim))
var_out.axis = ydim
var_out.long_name = "Y-coordinate in Cartesian system"
var_out.standard_name = "projection_y_coordinate"
var_out.units = "meters"
var_out[:] = northing
var = "lon"
var_out = nc.createVariable(var, "f", dimensions=(ydim, xdim))
var_out.units = "degrees_east"
var_out.valid_range = -180.0, 180.0
var_out.standard_name = "longitude"
var_out.bounds = "lon_bnds"
var_out[:] = lon
var = "lat"
var_out = nc.createVariable(var, "f", dimensions=(ydim, xdim))
var_out.units = "degrees_north"
var_out.valid_range = -90.0, 90.0
var_out.standard_name = "latitude"
var_out.bounds = "lat_bnds"
var_out[:] = lat
nc.createDimension(grid_corner_dim_name, size=grid_corners)
var = "lon_bnds"
# Create variable 'lon_bnds'
var_out = nc.createVariable(var,
"f",
dimensions=(ydim, xdim, grid_corner_dim_name))
# Assign units to variable 'lon_bnds'
var_out.units = "degreesE"
# Assign values to variable 'lon_nds'
var_out[:] = gc_lon
var = "lat_bnds"
# Create variable 'lat_bnds'
var_out = nc.createVariable(var,
"f",
dimensions=(ydim, xdim, grid_corner_dim_name))
# Assign units to variable 'lat_bnds'
var_out.units = "degreesN"
# Assign values to variable 'lat_bnds'
var_out[:] = gc_lat
var = "dummy"
var_out = nc.createVariable(var,
"f",
dimensions=("y", "x"),
fill_value=-2e9)
var_out.units = "meters"
var_out.long_name = "Just A Dummy"
var_out.comment = "This is just a dummy variable for CDO."
var_out.grid_mapping = "mapping"
var_out.coordinates = "lon lat"
var_out[:] = 0.0
mapping = nc.createVariable("mapping", "c")
mapping.ellipsoid = "WGS84"
mapping.false_easting = 0.0
mapping.false_northing = 0.0
mapping.grid_mapping_name = "polar_stereographic"
mapping.latitude_of_projection_origin = 90.0
mapping.standard_parallel = 70.0
mapping.straight_vertical_longitude_from_pole = -45.0
from time import asctime
historystr = "Created " + asctime() + "\n"
nc.history = historystr
nc.proj4 = projection
nc.Conventions = "CF-1.5"
nc.close()
def adjust_time_axis(ifile, start_date, end_date, ref_unit, ref_date,
periodicity):
nc = CDF(ifile, "a")
time_units = "%s since %s" % (ref_unit, ref_date)
time_calendar = "standard"
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.upper()]
# 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 until end_date with
# periodicity prule.
bnds_datelist = list(
rrule.rrule(prule, dtstart=parse(start_date), until=parse(end_date)))
# calculate the days since refdate, including refdate, with time being the
# mid-point value:
# time[n] = (bnds[n] + bnds[n+1]) / 2
bnds_interval_since_refdate = cdftime.date2num(bnds_datelist)
time_interval_since_refdate = bnds_interval_since_refdate[0:-1] + np.diff(
bnds_interval_since_refdate) / 2
# 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"
if bnds_dim not in list(nc.dimensions.keys()):
nc.createDimension(bnds_dim, 2)
# 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.bounds = bnds_var_name
time_var.units = time_units
time_var.calendar = time_calendar
time_var.standard_name = time_var_name
time_var.axis = "T"
# 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::]
nc.close()
print "Prepare PISM output for ismip6 compatibility and save as '{}'".format(
infile_ismip6)
ncks_cmd = ['ncks', '-O', '-4', '-L', '3', infile, infile_ismip6]
sub.call(ncks_cmd)
#"total over ice domain of top surface ice mass flux = sub_shelf_ice_flux + grounded_basal_ice_flux" ;
print " Add variable 'tendlibmassbf'"
ncap2_cmd = [
'ncap2', '-O', '-s',
'tendlibmassbf = sub_shelf_ice_flux + grounded_basal_ice_flux',
infile_ismip6, infile_ismip6
]
sub.call(ncap2_cmd)
# Check if request variables are present
nc = CDF(infile_ismip6, 'r')
for m_var in pism_copy_vars:
if m_var not in nc.variables:
print("Requested variable '{}' missing".format(m_var))
nc.close()
print(' Transfer pism_copy_vars to {}'.format(out_file))
cmd = 'ncks -O -v ' + ','.join(
pism_copy_vars) + " " + infile_ismip6 + " " + initmipvars_file
sub.check_call(cmd, shell=True)
# adjust time axis: shift by two years (PISM issue: wrong time setting), and select
# the INITMIP 100 yr forcing period,
cmd = "module load cdo && cdo -O setreftime,20000101,000000,seconds -selyear,2000/2100 -shifttime,-2year "+\
initmipvars_file+" "+out_file
sub.check_call(cmd, shell=True)
import numpy as np
try:
from netCDF4 import Dataset as CDF
except:
print "netCDF4 is not installed!"
sys.exit(1)
x, topg, thk = np.loadtxt('sg_35m_flowline.txt', unpack=True)
output = 'storglaciaren_flowline.nc'
# Write the data:
print("Writing the data to '%s'... " % output)
nc = CDF(output, "w")
nc.createDimension("x", size=len(x))
x_var = nc.createVariable("x", 'f', dimensions=("x", ))
x_var.units = "m"
x_var[:] = x
topg_var = nc.createVariable("topg", 'f', dimensions=("x", ))
topg_var.units = "m"
topg_var.standard_name = "bedrock_altitude"
topg_var[:] = topg
thk_var = nc.createVariable("thk", 'f', dimensions=("x", ))
thk_var.units = "m"
thk_var.standard_name = "land_ice_thickness"
thk_var[:] = thk
def prepare_ncfile_for_cdo(nc_outfile):
""" This is a copy of the PISM nc2cdo.py code. """
print("Preparing {} for cdo...".format(nc_outfile))
# open netCDF file in 'append' mode
nc = CDF(nc_outfile, 'a')
# a list of possible x-dimensions names
xdims = ['x', 'x1']
# a list of possible y-dimensions names
ydims = ['y', 'y1']
# assign x dimension
for dim in xdims:
if dim in nc.dimensions.keys():
xdim = dim
# assign y dimension
for dim in ydims:
if dim in nc.dimensions.keys():
ydim = dim
# coordinate variable in x-direction
x_var = nc.variables[xdim]
# coordinate variable in y-direction
y_var = nc.variables[ydim]
# values of the coordinate variable in x-direction
easting = x_var[:]
# values of the coordinate variable in y-direction
northing = y_var[:]
# grid spacing in x-direction
de = np.diff(easting)[0]
# grid spacing in y-direction
dn = np.diff(northing)[0]
# number of grid points in x-direction
M = easting.shape[0]
# number of grid points in y-direction
N = northing.shape[0]
# number of grid corners
grid_corners = 4
# grid corner dimension name
grid_corner_dim_name = "nv4"
# array holding x-component of grid corners
gc_easting = np.zeros((M, grid_corners))
# array holding y-component of grid corners
gc_northing = np.zeros((N, grid_corners))
# array holding the offsets from the cell centers
# in x-direction (counter-clockwise)
de_vec = np.array([-de / 2, de / 2, de / 2, -de / 2])
# array holding the offsets from the cell centers
# in y-direction (counter-clockwise)
dn_vec = np.array([-dn / 2, -dn / 2, dn / 2, dn / 2])
# array holding lat-component of grid corners
gc_lat = np.zeros((N, M, grid_corners))
# array holding lon-component of grid corners
gc_lon = np.zeros((N, M, grid_corners))
proj = get_projection_from_file(nc)
# If it does not yet exist, create dimension 'grid_corner_dim_name'
if grid_corner_dim_name not in nc.dimensions.keys():
for corner in range(0, grid_corners):
## grid_corners in x-direction
gc_easting[:, corner] = easting + de_vec[corner]
# grid corners in y-direction
gc_northing[:, corner] = northing + dn_vec[corner]
# meshgrid of grid corners in x-y space
gc_ee, gc_nn = np.meshgrid(gc_easting[:, corner],
gc_northing[:, corner])
# project grid corners from x-y to lat-lon space
gc_lon[:, :, corner], gc_lat[:, :, corner] = proj(gc_ee,
gc_nn,
inverse=True)
nc.createDimension(grid_corner_dim_name, size=grid_corners)
var = 'lon_bnds'
# Create variable 'lon_bnds'
var_out = nc.createVariable(var,
'float64',
dimensions=(ydim, xdim,
grid_corner_dim_name))
# Assign units to variable 'lon_bnds'
var_out.units = "degreesE"
# Assign values to variable 'lon_nds'
var_out[:] = gc_lon
var = 'lat_bnds'
# Create variable 'lat_bnds'
var_out = nc.createVariable(var,
'float64',
dimensions=(ydim, xdim,
grid_corner_dim_name))
# Assign units to variable 'lat_bnds'
var_out.units = "degreesN"
# Assign values to variable 'lat_bnds'
var_out[:] = gc_lat
if (not 'lon' in nc.variables.keys()) or (not 'lat'
in nc.variables.keys()):
print("No lat/lon coordinates found, creating them")
ee, nn = np.meshgrid(easting, northing)
lon, lat = proj(ee, nn, inverse=True)
var = 'lon'
# If it does not yet exist, create variable 'lon'
if not var in nc.variables.keys():
var_out = nc.createVariable(var, 'f', dimensions=(ydim, xdim))
# Assign values to variable 'lon'
var_out[:] = lon
else:
var_out = nc.variables[var]
# Assign units to variable 'lon'
var_out.units = "degreesE"
# Assign long name to variable 'lon'
var_out.long_name = "Longitude"
# Assign standard name to variable 'lon'
var_out.standard_name = "longitude"
# Assign bounds to variable 'lon'
var_out.bounds = "lon_bnds"
var = 'lat'
# If it does not yet exist, create variable 'lat'
if not var in nc.variables.keys():
var_out = nc.createVariable(var, 'f', dimensions=(ydim, xdim))
var_out[:] = lat
else:
var_out = nc.variables[var]
# Assign units to variable 'lat'
var_out.units = "degreesN"
# Assign long name to variable 'lat'
var_out.long_name = "Latitude"
# Assign standard name to variable 'lat'
var_out.standard_name = "latitude"
# Assign bounds to variable 'lat'
var_out.bounds = "lat_bnds"
# Make sure variables have 'coordinates' attribute
for var in nc.variables.keys():
if (nc.variables[var].ndim >= 2):
nc.variables[var].coordinates = "lon lat"
# lat/lon coordinates must not have mapping and coordinate attributes
# if they exist, delete them
for var in ['lat', 'lon', 'lat_bnds', 'lon_bnds']:
if hasattr(nc.variables[var], 'grid_mapping'):
delattr(nc.variables[var], 'grid_mapping')
if hasattr(nc.variables[var], 'coordinates'):
delattr(nc.variables[var], 'coordinates')
# If present prepend history history attribute, otherwise create it
from time import asctime
histstr = asctime() + \
' : grid info for CDO added by nc2cdo.py, a PISM utility\n'
if 'History' in nc.ncattrs():
nc.History = histstr + str(nc.History)
elif 'history' in nc.ncattrs():
nc.history = histstr + str(nc.history)
else:
nc.history = histstr
for attr in ("projection", "proj4"):
if hasattr(nc, attr):
delattr(nc, attr)
# Write projection attribute
nc.proj4 = proj.srs
# Close file
nc.close()
print "Prepared file", nc_outfile, "for cdo."
lat_0=var_mapping.latitude_of_projection_origin,
lon_0=var_mapping.straight_vertical_longitude_from_pole,
x_0=var_mapping.false_easting,
y_0=var_mapping.false_northing,
)
except:
print("No mapping information found, exiting.")
sys.exit(1)
return p
if __name__ == "__main__":
# open netCDF file in 'append' mode
nc = CDF(nc_outfile, "a")
# a list of possible x-dimensions names
xdims = ["x", "x1"]
# a list of possible y-dimensions names
ydims = ["y", "y1"]
# assign x dimension
for dim in xdims:
if dim in list(nc.dimensions.keys()):
xdim = dim
# assign y dimension
for dim in ydims:
if dim in list(nc.dimensions.keys()):
ydim = dim
# -------------------- general setup --------------------
t_main_start = t.time()
if args.verbose:
print("Running", sys.argv[0])
print(" -> verbose output = True")
print()
# --------------- read PISM restart file ----------------
# -> read PISM restart file to extract timestamp
if args.verbose:
print("... reading PISM restart file '" + args.pism_restart_file + "'")
t_read_pismrestartfile_start = t.time()
try:
nc_pism = CDF(args.pism_restart_file, 'r')
except:
print("pism_restart_file '" + args.pism_restart_file + \
"' can't be found! Exiting.")
sys.exit(1)
# read field array
try:
nc_pism.variables['time'].set_auto_mask(False)
pism_time_raw = np.squeeze(nc_pism.variables['time'][:])
#pism_time__sec = pism_time_raw.data
pism_time__sec = pism_time_raw
print("pism_time__sec: ", pism_time__sec)
print("pism_time_raw: ", pism_time_raw)
print("type(pism_time_raw): ", type(pism_time_raw))
except:
action="store_true",
help="Override weights file",
default=False,
)
options = parser.parse_args()
experiment = options.experiment
infile = options.EXP_FILE[0]
n_procs = options.n_procs
override_weights_file = options.override_weights_file
remap_method = options.remap_method
target_resolution = options.target_resolution
target_grid_filename = "searise_grid_{}m.nc".format(target_resolution)
# Need to get grid resolution from file
nc = CDF(infile, "r")
pism_grid_dx = int(round(nc.variables["run_stats"].grid_dx_meters))
nc.close()
PISM_GRID_RES_ID = str(pism_grid_dx / 100)
TARGET_GRID_RES_ID = str(target_resolution / 1000)
ID = options.id
IS = "GIS"
GROUP = "UAF"
MODEL = "PISM" + PISM_GRID_RES_ID + ID
EXP = experiment
TYPE = "_".join([EXP, "0" + TARGET_GRID_RES_ID])
INIT = "_".join(["init", "0" + TARGET_GRID_RES_ID])
project = "{IS}_{GROUP}_{MODEL}".format(IS=IS, GROUP=GROUP, MODEL=MODEL)
pism_stats_vars = ["pism_config", "run_stats"]
# create dummy fields
[xx, yy] = np.meshgrid(x, y)
acab = np.zeros((Mx, My))
artm = np.zeros((Mx, My)) + 273.15 + 10.0
# 10 degrees Celsius
topg = 1000.0 + 200.0 * (xx + yy) / max(Lx, Ly)
# change "1000.0" to "0.0" to test
# flotation criterion, etc.
thk = 3000.0 * (1.0 - 3.0 * (xx**2 + yy**2) / Lx**2)
thk[thk < 0.0] = 0.0
# Output filename
ncfile = 'foo.nc'
# Write the data:
nc = CDF(ncfile, "w", format='NETCDF3_CLASSIC') # for netCDF4 module
# Create dimensions x and y
nc.createDimension("x", size=Mx)
nc.createDimension("y", size=My)
x_var = nc.createVariable("x", 'f4', dimensions=("x", ))
x_var.units = "m"
x_var.long_name = "easting"
x_var.standard_name = "projection_x_coordinate"
x_var[:] = x
y_var = nc.createVariable("y", 'f4', dimensions=("y", ))
y_var.units = "m"
y_var.long_name = "northing"
y_var.standard_name = "projection_y_coordinate"
output_dir, config.initmip_naming[exp] + "_" + config.resolution)
if not os.path.exists(single_variable_dir):
os.makedirs(single_variable_dir)
tmp_file1 = os.path.join(output_dir, 'tmp1.nc')
tmp_file2 = os.path.join(output_dir, 'tmp2.nc')
for f in [tmp_file1, tmp_file2]:
try:
os.remove(f)
except OSError:
pass
# Check if request variables are present
nc = CDF(infile, 'r')
for m_var in pism_copy_vars:
if m_var not in nc.variables:
print("Requested variable '{}' missing".format(m_var))
nc.close()
print('Extract initmip variables from {} to {}'.format(infile, tmp_file1))
# also delete last two and first time step.
cmd = 'ncks -O -4 -L3 -d time,1,-3 -v '+'{}'.format(','.join(pism_copy_vars))+' '+\
infile+" "+tmp_file1
print cmd
sub.check_call(cmd, shell=True)
# adjust time axis: shift by two years (PISM issue: wrong time setting)
cmd = "module load cdo && cdo setreftime,20000101,000000,seconds -shifttime,-2year " + tmp_file1 + " " + tmp_file2
sub.check_call(cmd, shell=True)
thk = np.zeros((Mx, My)) # no fluid on table at start
artm = np.zeros((Mx, My)) + 273.15 + temp # 20 degrees Celsius
# smb = flux as m s-1, but scaled so that the total is correct even on a coarse grid
smb = np.zeros((Mx, My))
smb[xx ** 2 + yy ** 2 <= pipeR ** 2 + 1.0e-10] = 1.0
smbpos = sum(sum(smb))
if smbpos == 0:
print "gridding ERROR: no cells have positive input flux ... ending now"
sys.exit(1)
else:
print " input flux > 0 at %d cells ..." % smbpos
smb = (flux / (smbpos * dx * dy)) * smb # [flux] = kg s-1 so now [smb] = kg m-2 s-1
# Write the data:
nc = CDF(args.o, "w", format='NETCDF3_CLASSIC') # for netCDF4 module
# Create dimensions x and y
nc.createDimension("x", size=Mx)
nc.createDimension("y", size=My)
x_var = nc.createVariable("x", 'f4', dimensions=("x",))
x_var.units = "m"
x_var.long_name = "easting"
x_var.standard_name = "projection_x_coordinate"
x_var[:] = x
y_var = nc.createVariable("y", 'f4', dimensions=("y",))
y_var.units = "m"
y_var.long_name = "northing"
y_var.standard_name = "projection_y_coordinate"
print(" -> verbose output = True")
print()
# a list of possible x,y-dimensions names
xdims = ['x', 'x1']
ydims = ['y', 'y1']
# -------------------- read input file --------------------
# -> read file with regridded variables to be processed
if args.verbose:
print("... reading input file '" + args.infile + "'")
t_read_infile_start = t.time()
try:
nc_src = CDF(args.infile, 'r')
except:
print("INFILE '" + args.infile + "' can't be found! Exiting.")
sys.exit(1)
# assign x,y dimension
for dim in xdims:
if dim in list(nc_src.dimensions.keys()):
xdim = dim
for dim in ydims:
if dim in list(nc_src.dimensions.keys()):
ydim = dim
# read field array
try:
field = np.squeeze(nc_src.variables[args.field][:])
de = dn = grid_spacing # m
M = int((e1 - e0) / de) + 1
N = int((n1 - n0) / dn) + 1
easting = np.linspace(e0, e1, M)
northing = np.linspace(n0, n1, N)
ee, nn = np.meshgrid(easting, northing)
# Set up EPSG 3413 (NSIDC north polar stereo) projection
projection = "+init=epsg:3413"
proj = Proj(projection)
lon, lat = proj(ee, nn, inverse=True)
nc = CDF(nc_outfile, "w", format=fileformat)
nc.createDimension("x", size=easting.shape[0])
nc.createDimension("y", size=northing.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[:] = easting
var = "y"
var_out = nc.createVariable(var, "d", dimensions=("y"))
var_out.axis = "Y"
# This script produces a figure depicting the first standard deviation of
# correlation coefficient variance over the 10 calibration windows for both
# surface air temperature and precipitation.
"""
Created on Mon Feb 10 16:31:38 2020
@author: huiskamp
"""
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap
import numpy as np
from netCDF4 import Dataset as CDF
import copy as cp
SAM_corrs = CDF('SAM_corrs.nc', 'r')
std = CDF('corr_std.nc', 'r')
sam_sat_corr = SAM_corrs.variables['SAM_SAT_land_model']
sam_pre_corr = SAM_corrs.variables['SAM_pre_land_model']
std_sat = std.variables['std_sat_wdw']
std_pre = std.variables['std_precip_wdw']
lat = std.variables['latitude']
lon = std.variables['longitude']
xgrid, ygrid = np.meshgrid(lon, lat)
minval = 0
maxval = 0.2
rng = 21
