def setUp(self):
print('BEGIN RegridTests.setUp(): ', ICEBIN_IN)
self.elevI, self.maskI = giss.pism.read_elevI_maskI(ELEV_MASK)
self.elevmaskI = self.elevI
self.elevmaskI[self.maskI] = np.nan
self.mm = icebin.GCMRegridder(ICEBIN_IN)
self.rm = self.mm.regrid_matrices(ice_sheet, self.elevmaskI)
# Smooth 50km in XY direction, 100m in Z direction
sigma = (50000., 50000., 100.)
self.wIvE, self.IvE, self.IvEw = self.rm.matrix('IvE',
scale=True,
sigma=sigma)()
self.wAvI, self.AvI, self.AvIw = self.rm.matrix('AvI', scale=True)()
self.wIvA, self.IvA, self.IvAw = self.rm.matrix('IvA', scale=True)()
self.wEvI, self.EvI, self.EvIw = self.rm.matrix('EvI', scale=True)()
self.wIvE, self.IvE, self.IvEw = self.rm.matrix('IvE', scale=True)()
self.wIvE, self.IvE, self.IvEw = self.rm.matrix('IvE', scale=True)()
self.wEvA, self.EvA, self.EvAw = self.rm.matrix('EvA', scale=True)()
self.wAvE, self.AvE, self.AvEw = self.rm.matrix('AvE', scale=True)()
self.IvE_smooth_x = self.rm.matrix('IvE', scale=True, sigma=sigma)
with netCDF4.Dataset(ICEBIN_IN) as nc:
self.indexingA = ibgrid.Indexing(nc, 'm.agridA.indexing')
self.indexingHC = ibgrid.Indexing(nc, 'm.indexingHC')
self.indexingI = ibgrid.Indexing(
nc, 'm.{}.agridI.indexing'.format(ice_sheet))
self.plotterI = ibplotter.read_nc(nc,
'm.{}.agridI'.format(ice_sheet))
self.plotterA = ibplotter.read_nc(nc, 'm.agridA')
self.plotterE = ibplotter.PlotterE(ICEBIN_IN, ice_sheet, IvE=self.IvE)
print('END RegridTests.setUp()')
def setUp(self):
self.sheetname = 'greenland'
self.mmO = icebin.GCMRegridder(args.icebin_in)
rmO = self.mmO.regrid_matrices(self.sheetname)
OvI = rmO.matrix('AvI', scale=False, correctA=False) # WeightedSparse
_,_,self.wI = OvI()
with netCDF4.Dataset(args.icebin_in) as nc:
self.indexingI = ibgrid.Indexing(nc, 'm.greenland.gridI.indexing')
self.indexingA = ibgrid.Indexing(nc, 'm.gridA.indexing')
self.indexingHC = ibgrid.Indexing(nc, 'm.indexingHC')
self.hcdefs = nc.variables['m.hcdefs'][:]
self.nhc = len(nc.dimensions['m.nhc'])
indexA_sub = nc.variables['m.gridA.cells.index'][:]
areaA_sub = nc.variables['m.gridA.cells.native_area'][:]
nA1 = getattr(nc.variables['m.gridA.info'], 'cells.nfull')
self.areaA1 = np.zeros((nA1,))
self.areaA1[indexA_sub] = areaA_sub # Native area of full grid cell (on sphere)
self.fcontOp, self.fcontOm = compute_fcontO(self.mmO, self.sheetname)
# Construct a GCMRegridder_Model to/from the Atmosphere Grid
self.mmA = self.mmO.to_modele(1.-self.fcontOp, 1.-self.fcontOm)
def __init__(self, icebin_config, ice_sheet, elevmaskI=None, IvE=None, correctA=True):
"""icebin_config: str
Name of IceBin configuration file
ice_sheet: str
Name of ice sheet to create plotter for
elevmaskI:
Elevation on ice grid; NaN if no ice
OPTIONAL: Only needed for interactive plot (lookup())
IvE: sparse matrix
Matrix to convert [Ice Grid <-- Elevation Grid]"""
self.ice_sheet = ice_sheet
# Get the regridding matrix, if we don't already have it
if IvE is None:
mm = icebin.GCMRegridder(icebin_config)
rm = mm.regrid_matrices(ice_sheet)
IvE,wIvE = rm.regrid('IvE', scale=True)#, correctA=correctA)
self.IvE = IvE
with netCDF4.Dataset(icebin_config) as nc:
self.plotterI = read_nc(nc=nc, vname='m.' + ice_sheet + '.agridI')
# Create a plotterA, to help determine coords when user clicks
self.plotterA = _Grid_LonLat_read_plotter(nc, 'm.agridA')
# Used to determine nearest elevation point (for display)
# (convert sparse to dense vector)
#elevI = nc.variables['m.'+ice_sheet+'.elevI'][:]
self.elevmaskI = elevmaskI
if elevmaskI is not None:
self.elevmaskI = elevmaskI.reshape(self.plotterI.ny2, self.plotterI.nx2)
self.hcdefs = nc.variables['m.hcdefs'][:]
def setUp(self):
self.mm = icebin.GCMRegridder(ICEBIN_IN)
self.rm = self.mm.regrid_matrices(ice_sheet)
with netCDF4.Dataset(ICEBIN_IN) as nc:
self.indexingA = ibgrid.Indexing(nc, 'm.gridA.indexing')
self.indexingHP = ibgrid.Indexing(nc, 'm.indexingHP')
self.indexingI = ibgrid.Indexing(
nc, 'm.{}.gridI.indexing'.format(ice_sheet))
self.plotterI = ibplotter.read_nc(nc,
'm.{}.gridI'.format(ice_sheet))
self.plotterA = ibplotter.read_nc(nc, 'm.gridA')
def main():
ICEBIN_IN = 'pismsheet_g20_icebin_in.nc'
mm = icebin.GCMRegridder(ICEBIN_IN)
rm = mm.regrid_matrices('greenland')
AvI, wAvI = rm.regrid('AvI', scale=True)
print(AvI.shape)
print(wAvI.shape)
print(type(AvI))
for i, j, v in zip(AvI.row, AvI.col, AvI.data):
print('({}, {}) = {}'.format(i, j, v))
def compute_fcontO(mmO, sheetname):
"""Computes Continent land fractions, based on a single ice sheet.
This prototype code will likely be converted to C++"""
# ----------------------------------------------------------------
# Create a special regridder with elevI set according to the
# ice+land mask, instead of the default ice mask. This allows
# us to compute fcont (instead of fgice)
# See pism/src/base/util/Mask.hh
# enum MaskValue {
# MASK_UNKNOWN = -1,
# MASK_ICE_FREE_BEDROCK = 0,
# MASK_GROUNDED = 2,
# MASK_FLOATING = 3,
# MASK_ICE_FREE_OCEAN = 4
# };
with netCDF4.Dataset(args.elev_mask) as nc:
maskI = np.array(nc.variables['mask'][:], dtype=np.int32)[0,:,:]
maskI = np.where(
np.logical_or(maskI==2,maskI==3,maskI==0),np.int32(0),np.int32(1)).reshape(-1)
thkI = nc.variables['thk'][:].reshape(-1)
topgI = nc.variables['topg'][:].reshape(-1)
elevI = thkI + topgI
elevI[~maskI] = np.nan
mmO = icebin.GCMRegridder(args.icebin_in)
mmO.set_elevI(sheetname, elevI)
# ----------------------------------------------------------------
rmO = mmO.regrid_matrices(sheetname)
# Regrid to fxoceanOp (PISM fcont)
OvI = rmO.matrix('AvI', scale=False, correctA=False) # WeightedSparse
# OvI_correct = rmO.matrix('AvI', scale=False, correctA=True)
fcontOp = get_fcontOp(mmO, OvI)
# Round fcontOp (PISM) to get fcontOm (ModelE)
fcontOm = np.round(fcontOp)
return fcontOp, fcontOm
def make_icebin_in_base(gridA_fname, gridI_fname, overlap_fname, pism_spinup_fname, ofname):
# gridA_name = 'modele_ll_g2x2_5'
# gridI_name = 'searise_g%d' % ice_dx
# DATA_PATH = os.environ['DATA_PATH']
# pism_spinup_fname = os.path.join(DATA_PATH, 'searise/Greenland_5km_v1.1.nc')
# ice_dx=20 # 20km ice grid
#ice_dx=5 # 5km ice grid
# ========== Set up gridA and height points
# gridA_fname = os.path.join(grid_dir, gridA_name + '.nc')
hpdefs = np.array(range(0,21))*200.0 - 200.0
print('BEGIN read {}'.format(gridA_fname))
mm = icebin.GCMRegridder(gridA_fname, 'grid', hpdefs, True)
print('END read {}'.format(gridA_fname))
# ========= Add each Ice Sheet
# --- Greenland
print('PISM spinup file: {}'.format(pism_spinup_fname))
(elevI, maskI) = giss.pism.read_elevI_maskI(pism_spinup_fname)
print('len(elevI) = ', elevI.shape)
# gridI_fname = os.path.join(grid_dir, '%s.nc' % gridI_name)
# gridI_leaf = os.path.split(gridI_fname)[1]
# overlap_fname = os.path.join(grid_dir, '%s-%s.nc' % (gridA_name, gridI_leaf))
print('overlap_fname {}'.format(overlap_fname))
print('maskI',maskI.shape)
mm.add_sheet('greenland',
gridI_fname, 'grid',
overlap_fname, 'exgrid',
'Z_INTERP')
# elevI, maskI)
# ========== Finish up and write out
print('Writing: {}'.format(ofname))
ncio = ibmisc.NcIO(ofname, 'replace')
mm.ncio(ncio, 'm')
ncio.close()
def setUp(self):
self.mm = icebin.GCMRegridder(ICEBIN_IN)
self.rm = self.mm.regrid_matrices(ice_sheet)
with netCDF4.Dataset(ICEBIN_IN) as nc:
self.indexingA = ibgrid.Indexing(nc, 'm.gridA.indexing')
self.indexingHP = ibgrid.Indexing(nc, 'm.indexingHP')
self.indexingI = ibgrid.Indexing(
nc, 'm.{}.gridI.indexing'.format(ice_sheet))
self.plotterI = ibplotter.read_nc(nc,
'm.{}.gridI'.format(ice_sheet))
self.plotterA = ibplotter.read_nc(nc, 'm.gridA')
self.elevI, self.maskI = giss.pism.read_elevI_maskI('elev_mask.nc')
self.AvI, self.wAvI = self.rm.regrid('AvI', scale=True)
self.IvA, self.wIvA = self.rm.regrid('IvA', scale=True)
self.EvI, self.wEvI = self.rm.regrid('EvI', scale=True)
self.IvE, self.wIvE = self.rm.regrid('IvE', scale=True)
self.EvA, self.wEvA = self.rm.regrid('EvA', scale=True)
self.AvE, self.wAvE = self.rm.regrid('AvE', scale=True)
def modele_pism_gic(run_dir, pism_state, GIC0):
"""GIC0:
Original rundeck-provided GI file."""
print('BEGIN modele_pism_gic')
# ======== Step 1: Convert original GIC file to Lynch-Stieglitz GIC file
stem = os.path.splitext(os.path.split(GIC0)[1])[0]
GIC1 = os.path.join(run_dir, 'inputs', stem + '_stieglitz.nc')
print('stem {}'.format(stem))
print('GIC0 {}'.format(GIC0))
print('GIC1 {}'.format(GIC1))
modele.gic2stieglitz.gic2stieglitz(GIC0, GIC1)
# ======== Step 2: Merge ice sheet into GIC file
GIC2 = os.path.join(run_dir, 'inputs', stem + '_merged.nc')
print('***** GICs')
print(GIC0)
print(GIC1)
print(GIC2)
# Obtain IceBin regridder for Atmosphere (not ocean), based on results
# of above makefile
mmO = icebin.GCMRegridder(os.path.join(run_dir, 'inputs', 'gcmO.nc'))
with netCDF4.Dataset(os.path.join(run_dir, 'inputs',
'topoo_merged.nc')) as nc:
foceanAOp = nc.variables['FOCEANF'][:]
foceanAOm = nc.variables['FOCEAN'][:]
mmA = mmO.to_modele((foceanAOp, foceanAOm))
# Merge the GIC file
merge_GIC(GIC1, os.path.join(run_dir, 'inputs', 'topoa.nc'), pism_state,
mmA, GIC2)
# Symlink the GIC file
with pushd(os.path.join(run_dir, 'inputs')):
symlink_rel(GIC2, 'GIC')
out_raw.append((index, w0))
# Normalize sum(w0*cell_mass) = cell_mass0
factor = cell_mass0 / mass_sum
out = list()
for index,w in out_raw:
out.append((index,w*factor))
return out
# ==============================================================
# Get the regridding matrices
# (This tells us, among other thing, the mask and the weight of each gridcell)
mm = icebin.GCMRegridder(ICEBIN_IN)
rm = mm.regrid_matrices(ice_sheet)
with netCDF4.Dataset(ICEBIN_IN) as nc:
# indexingA = ibgrid.Indexing(nc, 'm.gridA.indexing')
# indexingHP = ibgrid.Indexing(nc, 'm.indexingHP')
indexingI = ibgrid.Indexing(nc, 'm.{}.gridI.indexing'.format(ice_sheet))
plotterI = ibplotter.read_nc(nc, 'm.{}.gridI'.format(ice_sheet))
# plotterA = ibplotter.read_nc(nc, 'm.gridA')
IvE,wIvE = rm.regrid('IvE', scale=True)
wI = wIvE # Numpy array
nI = len(wI)
# Read the grid
def make_icebin_in_base(grid_dir, gridA_name, gridI_name, pism_spinup_fname,
ofname):
# gridA_name = 'modele_ll_g2x2_5'
# gridI_name = 'searise_g%d' % ice_dx
# DATA_PATH = os.environ['DATA_PATH']
# pism_spinup_fname = os.path.join(DATA_PATH, 'searise/Greenland_5km_v1.1.nc')
ice_dx = 20 # 20km ice grid
#ice_dx=5 # 5km ice grid
# ofname = 'modele_ll_g2x2_5-searise_g%d-40-base.nc' % ice_dx
# Regrids data from the 5km SeaRISE grid to the 20km SeaRISE grid
# Just sub-sample, don't do anything fancy
def regrid_5_to_20(ff):
print(ff.shape[0] / 4 + 1, ff.shape[1] / 4 + 1)
ret = np.zeros((ff.shape[0] / 4 + 1, ff.shape[1] / 4 + 1),
dtype=ff.dtype)
for j in range(0, ret.shape[0]):
for i in range(0, ret.shape[1]):
ret[j, i] = ff[j * 4, i * 4]
print('regrid: %s to %s' % (ff.shape, ret.shape))
return ret
# ========== Set up gridA and height points
gridA_fname = os.path.join(grid_dir, gridA_name + '.nc')
hpdefs = np.array(range(0, 40)) * 100.0 - 50.0
mm = icebin.GCMRegridder(gridA_fname, 'grid', hpdefs, True)
# ========= Add each Ice Sheet
# --- Greenland
print('PISM spinup file: {}'.format(pism_spinup_fname))
(elevI, maskI) = giss.pism.read_elevI_maskI(pism_spinup_fname)
gridI_fname = os.path.join(grid_dir, '%s.nc' % gridI_name)
overlap_fname = os.path.join(grid_dir,
'%s-%s.nc' % (gridA_name, gridI_name))
print('maskI', maskI.shape)
mm.add_sheet('greenland', gridI_fname, 'grid', overlap_fname, 'exgrid',
'Z_INTERP', elevI, maskI)
# ========= Compute all regridding matrices for Python use
matrices = dict()
for sheet_name in ('greenland', ):
rm = mm.regrid_matrices(sheet_name)
for mat_base in ('EvI', 'AvI', 'IvA', 'IvE', 'EvA', 'AvE'):
for variant in ('PARTIAL_CELL', ):
key = (sheet_name, mat_base, variant)
print('-------- Computing', key)
sys.stdout.flush()
matrix = rm.regrid(mat_base + '(' + variant + ')')
matrices[key] = matrix
with open('matrices.pik', 'wb') as fout:
pickle.dump(matrices, fout)
sys.exit(0)
# ========== Finish up and write out
print('Writing: {}'.format(ofname))
ncio = ibmisc.NcIO(ofname, 'replace')
mm.ncio(ncio, 'm')
ncio.close()
print(' READ: iTOPO = {}'.format(iTOPO))
iGIC = giutil.search_file(args.gic+'.nc', file_path)
print(' READ: iGIC = {}'.format(iGIC))
# -------- New Output Files
#odir = os.path.join(os.environ['HOME'], 'modele_input', 'local', 'landice')
odir = '.'
oTOPO = os.path.join(odir, args.topo+'_EC2-{segment}.nc')
oGIC = os.path.join(odir, args.gic+'_EC2.nc')
print('WRITE: oTOPO = {}'.format(oTOPO))
print('WRITE: oGIC = {}'.format(oGIC))
# --------------------------------
# 1. Load up IceBin and create the matrix AvE
mm = icebin.GCMRegridder(args.icebin_in)
rm = mm.regrid_matrices('greenland')
wAvE,AvE,_ = rm.matrix('AvE', scale=True)()
wEvI,EvI,_ = rm.matrix('EvI', scale=True)()
wAvI,AvI,_ = rm.matrix('AvI', scale=True)()
with netCDF4.Dataset(args.icebin_in) as nc:
indexingHC = ibgrid.Indexing(nc, 'm.indexingHC')
hcdefs_ice = nc.variables['m.hcdefs'][:]
nhc_ice = len(nc.dimensions['m.nhc'])
indexA_sub = nc.variables['m.gridA.cells.index'][:]
areaA_sub = nc.variables['m.gridA.cells.native_area'][:]
nA1 = getattr(nc.variables['m.gridA.info'], 'cells.nfull')
areaA1 = np.zeros((nA1,))
areaA1[indexA_sub] = areaA_sub # Native area of full grid cell (on sphere)
hcdefs_ice = nc.variables['m.hcdefs'][:]
nhc_ice = len(nc.dimensions['m.nhc'])
imO = indexingO.extent[0]
jmO = indexingO.extent[1]
im = imO // 2 # Indices in alphabetical order
jm = jmO // 2 # /2 to convert Ocean to Atmosphere grid
segments = 'legacy,sealand,ec'
nhc_gcm = nhc_ice + 3
# ---------------------------------------
# Create gcmO and wrap to get gcmA. Not yet usable, we haven't done
# anything about foceanAOp or foceanAOm yet.
mmA = icebin.GCMRegridder(ICEBINO_IN).to_modele()
# Allocate arryas for update_topo to write into.
# In ModelE, these are allocated by the GCM.
fhc = np.zeros((nhc_gcm,jm,im), dtype='d')
underice = np.zeros((nhc_gcm,jm,im), dtype='i')
elevE = np.zeros((nhc_gcm,jm,im), dtype='d')
focean = np.zeros((jm,im), dtype='d')
flake = np.zeros((jm,im), dtype='d')
fgrnd = np.zeros((jm,im), dtype='d')
fgice = np.zeros((jm,im), dtype='d')
zatmo = np.zeros((jm,im), dtype='d')
foceanOm0 = np.zeros((jmO,imO), dtype='d')
# ---------------------------------------------------------
