def read_raw(self):
rawfile = fd.DumbCheckpoint("X_end", mode=fd.FILE_READ)
rawfile.load(self.X)
rawfile.close()
rawfile = fd.DumbCheckpoint("U_end", mode=fd.FILE_READ)
rawfile.load(self.U)
rawfile.close()
def write_raw(self):
rawfile = fd.DumbCheckpoint("X_end", mode=fd.FILE_CREATE)
rawfile.store(self.X)
rawfile.close()
rawfile = fd.DumbCheckpoint("U_end", mode=fd.FILE_CREATE)
rawfile.store(self.U)
rawfile.close()
def write_checkpoint(states, dirpath, filename, fieldname="solution"):
"""Write checkpoint for restarting and/or post-processing.
A solution is stored for each state in states.
Restarting requires states filling the time discretization stencil.
If a checkpoint already exists for a state's time, then no new
checkpoint is written for that state.
"""
checkpointer = fe.DumbCheckpoint(basename=str(dirpath) + "/" + filename,
mode=fe.FILE_UPDATE)
stored_times, stored_indices = checkpointer.get_timesteps()
for state in states:
time = state["time"].__float__()
if time in stored_times:
continue
else:
solution = state["solution"]
checkpointer.set_timestep(t=time, idx=state["index"])
print("Writing checkpoint to {}".format(
checkpointer.h5file.filename))
checkpointer.store(solution, name=fieldname)
def getCheckPointVars(checkFile, varNames, Q, t=None):
""" Read a variable from a firedrake checkpoint file
Parameters
----------
checkFile : str
checkfile name sans .h5
varNames : str or list of str
Names of variables to extract
Q : firedrake function space
firedrake function space can be a vector space, V, but not mixed
Returns
-------
myVars: dict
{'myVar':}
"""
# Ensure a list since a single str is allowed
if type(varNames) is not list:
varNames = [varNames]
# open checkpoint
myVars = {}
if not os.path.exists(f'{checkFile}.h5'):
myerror(f'getCheckPointVar: file {checkFile}.h5 does not exist')
with firedrake.DumbCheckpoint(checkFile, mode=firedrake.FILE_READ) as chk:
if t is not None:
print(t)
chk.set_timestep(t)
for varName in varNames:
myVar = firedrake.Function(Q, name=varName)
chk.load(myVar, name=varName)
myVars[varName] = myVar
return myVars
def load(self, vec, filename="control"):
"""
Load a vector from a file.
DumbCheckpoint requires that the mesh, FunctionSpace and parallel
decomposition are identical between store and load.
"""
with fd.DumbCheckpoint(filename, mode=fd.FILE_READ) as chk:
chk.load(vec.fun, name=filename)
def store(self, vec, filename="control"):
"""
Store the vector to a file to be reused in a later computation.
DumbCheckpoint requires that the mesh, FunctionSpace and parallel
decomposition are identical between store and load.
"""
with fd.DumbCheckpoint(filename, mode=fd.FILE_CREATE) as chk:
chk.store(vec.fun, name=filename)
def saveInversionResult(inversionParams, modelResults, solverBeta,
solverTheta, A, theta, beta, grounded, floating,
h, s, zb, uObs):
"""Save results to a firedrake dumbcheckpoint file
"""
outFile = \
f'{inversionParams["inversionResult"]}.deg{inversionParams["degree"]}'
# Names used in checkpoint file - use dict for yaml dump
varNames = {'uInv': 'uInv', 'betaInv': 'betaInv', 'AInv': 'AInv',
'groundedInv': 'groundedInv', 'floatingInv': 'floatingInv',
'hInv': 'hInv', 'sInv': 'sInv', 'zbInv': 'zbInv',
'uObsInv': 'uObsInv', 'thetaInv': 'thetaInv'}
# variables to constrain inversion
myVars = {'AInv': A, 'groundedInv': grounded, 'floatingInv': floating,
'hInv': h, 'sInv': s, 'zbInv': zb, 'uObsInv': uObs}
# Write results to check point file
with firedrake.DumbCheckpoint(outFile, mode=firedrake.FILE_CREATE) as chk:
# Beta solution
if solverBeta is not None: # Save inversion
chk.store(solverBeta.parameter, name=varNames['betaInv'])
else: # Save value used
chk.store(beta, name=varNames['betaInv'])
# Theta solution
if solverTheta is not None: # Save param and final state if solved
chk.store(solverTheta.parameter, name=varNames['thetaInv'])
chk.store(solverTheta.state, name=varNames['uInv'])
else: # Save theta used throughout model and final result
chk.store(theta, name=varNames['thetaInv'])
chk.store(solverBeta.state, name=varNames['uInv']) # Save beta v
# Save other variables
for myVar in myVars:
chk.store(myVars[myVar], name=myVar)
# Save end time
modelResults['end_time'] = datetime.now().strftime('%Y-%m-%d_%H:%M:%S')
# dump inputs and summary data to yaml file
outParams = f'{inversionParams["inversionResult"]}.' \
f'deg{inversionParams["degree"]}.yaml'
with open(outParams, 'w') as fpYaml:
myDicts = {'inversionParams': inversionParams,
'modelResults': modelResults, 'varNames': varNames}
yaml.dump(myDicts, fpYaml)
def read_checkpoint(states, dirpath, filename, fieldname="solution"):
checkpointer = fe.DumbCheckpoint(basename=str(dirpath) + "/" + filename,
mode=fe.FILE_READ)
stored_times, stored_indices = checkpointer.get_timesteps()
for state in states:
time = state["time"].__float__()
assert (time in stored_times)
solution = state["solution"]
checkpointer.set_timestep(t=time, idx=state["index"])
print("Reading checkpoint from {}".format(
checkpointer.h5file.filename))
checkpointer.load(solution, name=fieldname)
return states
def setupOutputs(forwardParams, inversionParams, meltParams, check=True):
''' Make output dir and dump forward and inversionParams
'''
if not os.path.exists(forwardParams['forwardResultDir']):
os.mkdir(forwardParams['forwardResultDir'])
inputsFile = f'{forwardParams["forwardResultDir"]}/' \
f'{forwardParams["forwardResult"]}.inputs.yaml'
chkFile = f'{forwardParams["forwardResultDir"]}/' \
f'{forwardParams["forwardResult"]}.history'
summaryFile = f'{forwardParams["forwardResultDir"]}/' \
f'{forwardParams["forwardResult"]}.summary.yaml'
# Abort if noOverwrite and all files exist
noOverwrite = forwardParams['noOverwrite']
for myFile in [inputsFile, f'{chkFile}.h5', summaryFile]:
noOverwrite = noOverwrite and os.path.exists(myFile)
print(myFile, noOverwrite)
if noOverwrite:
myerror(f'\nProducts exist for: {inputsFile}\nand noOverwrite set\n')
# Continue with new or overwrite
print(f'Writing inputs to: {inputsFile}')
#
with open(inputsFile, 'w') as fpYaml:
myDicts = {
'forwardParams': forwardParams,
'inversionParams': inversionParams,
'meltParams': meltParams
}
print
yaml.dump(myDicts, fpYaml)
# open check point file
if check:
if forwardParams['restart']:
mode = firedrake.FILE_UPDATE
else:
mode = firedrake.FILE_CREATE
return firedrake.DumbCheckpoint(chkFile, mode=mode)
return None
Lx, Ly = 640e3, 80e3
ny = 20
nx = int(Lx / Ly) * ny
coarse_mesh = firedrake.RectangleMesh(nx, ny, Lx, Ly)
mesh_hierarchy = firedrake.MeshHierarchy(coarse_mesh, args.level)
mesh = mesh_hierarchy[args.level]
Q = firedrake.FunctionSpace(mesh, family='CG', degree=1)
V = firedrake.VectorFunctionSpace(mesh, family='CG', degree=1)
h = firedrake.Function(Q)
u = firedrake.Function(V)
input_name = os.path.splitext(args.input)[0]
with firedrake.DumbCheckpoint(input_name, mode=firedrake.FILE_READ) as chk:
timesteps, indices = chk.get_timesteps()
chk.set_timestep(timesteps[-1], idx=indices[-1])
chk.load(h, name='h')
chk.load(u, name='u')
fig, axes = icepack.plot.subplots(nrows=2,
sharex=True,
sharey=True,
figsize=(6.4, 2.8))
axes[0].get_xaxis().set_visible(False)
for ax in axes:
ax.set_xlim(0, 640e3)
ax.set_ylim(0, 80e3)
parser.add_argument('--undamaged')
parser.add_argument('--damaged')
parser.add_argument('--output')
args = parser.parse_args()
def colorbar(figure, axes, mappable, *args, **kwargs):
divider = make_axes_locatable(axes)
cax = divider.append_axes('right', size='5%', pad=0.05)
return figure.colorbar(mappable, *args, cax=cax, **kwargs)
mesh = firedrake.Mesh(args.mesh)
Q = firedrake.FunctionSpace(mesh, family='CG', degree=2)
V = firedrake.VectorFunctionSpace(mesh, family='CG', degree=2)
Δ = firedrake.FunctionSpace(mesh, family='DG', degree=1)
with firedrake.DumbCheckpoint(args.undamaged, mode=firedrake.FILE_READ) as chk:
h_undamaged = firedrake.Function(Q)
u_undamaged = firedrake.Function(V)
chk.load(h_undamaged, name='h')
chk.load(u_undamaged, name='u')
with firedrake.DumbCheckpoint(args.damaged, mode=firedrake.FILE_READ) as chk:
h_damaged = firedrake.Function(Q)
u_damaged = firedrake.Function(V)
D = firedrake.Function(Δ)
chk.load(h_damaged, name='h')
chk.load(u_damaged, name='u')
chk.load(D, name='D')
δh = firedrake.interpolate(h_damaged - h_undamaged, Q)
import icepack.plot
def colorbar(figure, axes, mappable, *args, **kwargs):
divider = make_axes_locatable(axes)
cax = divider.append_axes('right', size='5%', pad=0.05)
return figure.colorbar(mappable, *args, cax=cax, **kwargs)
mesh = firedrake.Mesh('ice-shelf.msh')
Q = firedrake.FunctionSpace(mesh, family='CG', degree=2)
V = firedrake.VectorFunctionSpace(mesh, family='CG', degree=2)
Δ = firedrake.FunctionSpace(mesh, family='DG', degree=1)
filename = 'steady-state-undamaged'
with firedrake.DumbCheckpoint(filename, mode=firedrake.FILE_READ) as chk:
h_undamaged = firedrake.Function(Q)
u_undamaged = firedrake.Function(V)
chk.load(h_undamaged, name='h')
chk.load(u_undamaged, name='u')
filename = 'steady-state-damaged'
with firedrake.DumbCheckpoint(filename, mode=firedrake.FILE_READ) as chk:
h_damaged = firedrake.Function(Q)
u_damaged = firedrake.Function(V)
D = firedrake.Function(Δ)
chk.load(h_damaged, name='h')
chk.load(u_damaged, name='u')
chk.load(D, name='D')
δh = firedrake.interpolate(h_damaged - h_undamaged, Q)
# Create the mass balance
ela = 300.
max_a = 0. # alternative: 0.5
da_ds = 0. # alternative: 0.5 / 1000
def mass_balance(s, max_a, da_ds, ela):
return min_value((s - ela) * da_ds, max_a)
# Pick a timestep, a duration, and run the simulation
dt = args.timestep
num_timesteps = args.num_steps
for step in tqdm.trange(num_timesteps):
a = interpolate(mass_balance(s, ela, max_a, da_ds), Q)
h = solver.prognostic_solve(dt, thickness=h, accumulation=a, velocity=u)
h.interpolate(max_value(h, 0))
s = interpolate(h + b, Q)
u = solver.diagnostic_solve(velocity=u, thickness=h, surface=s, fluidity=A)
# Write out the results to a file
output_name = os.path.splitext(args.output)[0]
with firedrake.DumbCheckpoint(output_name, mode=firedrake.FILE_CREATE) as chk:
chk.store(b, name='bed')
chk.store(h, name='thickness')
chk.store(h0, name='thickness-initial')
chk.store(u, name='velocity')
# We run up in powers of 2 until we have plenty of observations per cell (on average)
# In[4]:
signal_to_noise = 20
U = u_true.dat.data_ro[:]
u_range = U.max() - U.min()
σ = firedrake.Constant(u_range / signal_to_noise)
methods = ['point-cloud', 'nearest', 'linear', 'clough-tocher', 'gaussian']
min_power_of_2 = 2
max_power_of_2 = 20
# We will dump our results to a checkpoint
chk = firedrake.DumbCheckpoint("poisson-inverse-conductivity-posterior-consistency-chk", mode=firedrake.FILE_CREATE)
np_file = open('poisson-inverse-conductivity-posterior-consistency-chk.npy', 'wb')
for i in range(min_power_of_2, max_power_of_2+1):
print(f'i = {i}')
# Setup Plot
ukw = {'vmin': 0.0, 'vmax': +0.2}
kw = {'vmin': -4, 'vmax': +4, 'shading': 'gouraud'}
title_fontsize = 20
text_fontsize = 20
fig, axes = plt.subplots(ncols=3, nrows=1+len(methods), sharex=True, sharey=True, figsize=(20,30), dpi=200)
plt.suptitle('Estimating Log-Conductivity $q$ \n where $k = k_0e^q$ and $-\\nabla \\cdot k \\nabla u = f$ for known $f$', fontsize=title_fontsize)
for ax in axes.ravel():
ax.set_aspect('equal')
