The ice-sheet model implemented is based on the hybrid formulation described in and and uses the numerical implementation of . This formulation is derived from the Stokes equations using variational principles and is a hybrid of the shallow ice approximation and the shallow shelf approximation .

Following and , the conservation of momentum equations for depth-averaged velocities are

∂x(4hη¯∂xu¯+2hη¯∂yv¯)+∂y(hη¯∂xv¯+hη¯∂yu¯)-τbx=ρigh∂xs, ∂y(4hη¯∂yv¯+2hη¯∂xu¯)+∂x(hη¯∂yu¯+hη¯∂xv¯)-τby=ρigh∂ys, where u(x,y,z) and v(x,y,z) are velocities in the x and y directions, η(x,y,z) is dynamic viscosity, h(x,y) is ice thickness, s(x,y) is surface elevation, τbx(x,y) and τby(x,y) are basal drag in the x and y directions, g is the magnitude of gravitational acceleration, and ρi is the density of ice. The overbar (x¯) denotes the depth-averaged value of a variable, so that u¯(x,y) and v¯(x,y) are depth-averaged velocities and η¯(x,y) is depth-averaged viscosity.

Basal drag is defined by the sliding law. Three different sliding laws are implemented in the ice-sheet model: τb=β2ub, τb=μaN+pUbqubUb, τb=μbN+UbUb+λbAbN+n1nubUb, where τb=(τbx(x,y),τby(x,y)) is the basal drag, ub=(ub,vb)=(u(x,y,b),v(x,y,b)) is the basal velocity, Ub is the sliding speed (|ub|), N(x,y)=ρigh-pw is the effective pressure at the ice-sheet bed, pw is water pressure, β(x,y) is a basal drag coefficient, μa(x,y) is a drag coefficient, p and q are positive exponents, μb(x,y) is a limiting roughness slope, λb is the characteristic bed roughness length, and Ab and n are coefficients in Glen's flow law . Ab is the ice creep parameter used for basal ice. It set an order of magnitude lower than A to account for warmer ice at the base (following ). The value of Ab is used in both the Schoof sliding law and the subglacial hydrology model for determining creep closure of channels and cavities. The value of A is used in the momentum equations.

Following , negative effective pressures are eliminated by setting N+=max⁡(N,0) and regularized with a small regularization constant.

The linear sliding law (Eq. ) represents all ice–bed interactions by a single friction coefficient β. The second and third equations are a Budd sliding law and a Schoof sliding law respectively. These attempt to explicitly represent more complex interactions at the ice–bed interface, in particular the impact of basal water pressure. Equation () is a power law commonly used in glaciology to describe basal rheology e.g., although typically with no dependence on effective pressure (p=0). At high effective pressures the Schoof sliding law has a similar form (‖τb‖≈μb(λbAb)-1Ub1n) but transitions to a Coulomb description at low effective pressures (‖τb‖≈μbN).

It is useful to represent the sliding laws in a common form: τb=Cub, where C is a function multiplying basal velocities. The form and parameters of C depend on the sliding law.

The boundary conditions at the terminating margin of the ice sheet are 2η¯h(2∂xu¯+∂yv¯)n^x+η¯h(∂yu¯+∂xv¯)n^y=g2(ρih2-ρwd2)n^x, 2η¯h(2∂yv¯+∂xu¯)n^y+η¯h(∂yu¯+∂xv¯)n^x=g2(ρih2-ρwd2)n^y, where ρw is the density of water, d is the ice draft (zero at land-terminating portions of the margin), and n^x and n^y are the components of the outward pointing unit vector normal to the terminating margin .

Two further boundary conditions are used in the ice-sheet model: a no-penetration condition at the margin of nunataks and a Dirichlet boundary condition at the lateral margins of the ice-sheet domain which are not the termination edge.

The equation for viscosity is η=12A-1n((∂xu)2+(∂yv)2+(∂xv)(∂yu)+(∂xv+∂yu)2+14(∂zu)2+14(∂zv)2+ϵ0)1-n2n, where ϵ0 is a regularization term. Vertical shearing in the hybrid formulation is approximated by ∂zu≈∂zu+∂xw=σxzη,∂zv≈∂zv+∂yw=σyzη. As in and , a linear relationship between vertical shear stresses and depth is assumed: σxz=τbxs-zh,σyz=τbys-zh.

Viscosity is defined implicitly by Eq. (). With the standard choice of n=3, this is a cubic equation and can be solved exactly. Alternatively, a previous value of viscosity can be used to calculate an updated value. This process can be iterated upon to create a fixed point iteration. The default procedure in the model is to do two iterations .

The hybrid formulation of the conservation of momentum equations depend on depth-integrated viscosity: η¯=1h∫sbηdz.

This integral, and others, is numerically integrated using the composite Simpson law.

Following , the following integral is defined: Fa=∫sb1ηs-zhadz.

This integral can be used to define expressions for surface velocity in terms of basal velocity and basal velocity in terms of depth-averaged velocity : us=ub(1+CF1), u¯=ub(1+CF2), where F1 and F2 are determined using Eq.  .

Additionally, defining Ceff as follows, Ceff=C1+CF2, leads to an expression for basal drag in terms of depth-averaged velocity : τb=Ceffu¯.

As in , Eqs.  and can be written in the following form: L(u¯)u¯=f, where L=∂x4hη¯∂x+∂y2hη¯∂y-Ceff∂x2hη¯∂y+∂yhη¯∂x∂y2hη¯∂x+∂xhη¯∂y∂y4hη¯∂y+∂xhη¯∂x-Ceff and f=ρigh∂xsρigh∂ys.

Equation () is a non-linear equation for depth-integrated velocity. The non-linearity arises since depth-integrated viscosity is a function of velocity and, in the case of a non-linear sliding law, since Ceff is also a function of velocity. The ice-sheet model solves Eq.  on an Arakawa-C finite difference grid using a Picard iterative process.

Equation () is discretized following . The primary difference is that operators are appropriately extended to allow for periodic boundary conditions in the ISMIP-HOM experiments . Discretization of Eq.  results in a linear system of equations, which can be written as Lx¯=b, where the matrix (L) corresponds to the operator L, while the vector x corresponds to u¯, and the vector b corresponds to f. MATLAB's backslash operator is used to solve this system of equations. Alternatively, preconditioned iterative methods can be used .

The Picard iteration linearizes Eq.  by constructing L using the velocity of the previous iteration. An initial velocity guess and viscosity guess form the initial L. Equation () is then solved for an updated velocity guess, which in turn can is used to update viscosity and Ceff. This process is repeated within a loop until the solution converges below a specified tolerance or until a prescribed number of iterations are reached.

Evolution of surface geometry is not included in the ice-sheet model. This is appropriate since the ice-sheet model is applied on annual timescales, over which significant changes in ice-sheet geometry are not expected.

The ice-sheet model was tested against the ISMIP-HOM benchmark experiments A and C and found to compare favourably against previous models .

This section describes the details of an inversion code developed in conjunction with the ice-sheet model. The methodology is based on . However, the implementation developed here has a more limited capability due to software limitations.

The cost function returns a scalar which measures the fit of the model to the observations. The cost function is defined as J=γ1∫Γsw⋅(Uobs-Us)2dΓs+γ2∫Γb(∇α⋅∇α)dΓb, where γ1 and γ1 are user-defined scaling factors, Γs is the surface domain, Γb is the basal domain, w(x,y) is a weighting function, Uobs(x,y) are observed surface ice speeds, Us(x,y) are modelled surface speeds, and α(x,y) is the control parameter.

The cost function defined above has two terms: J=γ1J0+γ2JReg. The first term (J0) measures the weighted square of the difference between observed and modelled velocity. The second term (JReg) is a Tikhonov regularization term, which penalizes oscillations in α and stabilizes the inversion . Other formulations of the cost function are possible (e.g. ).

The control parameter refers to the variable which the inversion process optimizes in order to best match model prediction and observations. Since our aim is to determine the basal drag, the control parameter is a parameter in the basal sliding law. For the linear sliding law, α=β2. For the Budd sliding law, α=μa. Although the Schoof sliding law has two unknowns which can be inverted for, μb exerts a dominating control. Hence, λb is set to a constant while α=μb. In the numerical implementation of the adjoint, α is parameterized as α(x,y)=exp⁡(ζ(x,y)). This ensures that α remains positive, as expected for each of the three sliding laws. For simplicity, this is neglected in the remainder of the paper, and the discussion focuses on recovering α rather than ζ.

The inversion process aims to determine the field of α which minimizes the cost function. This is an optimization problem. Starting with an initial guess for α, the gradient of the cost function with respect to the initial input α is determined. The gradient provides a search direction for the optimization algorithm, which updates α. This process is repeated iteratively until α converges below a tolerance or until a maximum number of iterations occur. The critical component in this process is the gradient dJdα. The process to calculate this gradient is described in the next two subsections.

The methodology to obtain the gradient dJdα follows from . The key concepts of this approach are first explained for a generic algorithm, before showing how they can be applied to the ice-sheet model. This explanation follows that of and .

Consider the following model: b=B(ϕ), where ϕ is an arbitrary variable (or array of variables), and B can be considered a sequence of operations:

B(ϕ)=BN((…(B2(B1(B0(ϕ)))))) and each operation can be written as bN=BN().

Further, define a function J: J=J(b), where J returns a scalar. In the context of the adjoint model, the function is known as the cost function, objective function, or target function . This function quantifies an aspect of the model output which is of interest, such as the mean error of model output relative to observations.

The aim is to determine the gradient of the cost function J with respect to the initial input ϕ. To provide context for the adjoint model, the tangent linear model (TLM) is presented first. In the TLM, a small perturbation in the input is propagated forward through the model to determine the corresponding perturbation in the output. Applying the chain rule to J=J(b)=J(B(ϕ)) leads to the corresponding TLM: δJ=∏i=N1∂Bi∂bi-1∂B0∂ϕiδϕi.

There are several observations about the TLM. First, the TLM determines the perturbation of δJ from the perturbation of a single element ϕi. As the perturbation δϕi approaches zero, δJδϕi converges to dJdϕi. Second, to determine dJdϕ, the TLM needs to be run for each entry in ϕ. Although for small models this approach is feasible, the computational cost is too great for glaciological problems on domains of the size of interest. Finally, the TLM acts in a similar direction as the model B, in that the functions are applied successively starting with the counterpart to B0 .

The concept behind the adjoint model is that rather than determining how changes in the input ϕ impact the cost function J, it can be more efficient to determine how changes in the cost function J impact the initial input ϕ. In the adjoint model, sensitivities of J are propagated backwards through the model to determine the resulting change in ϕ. Similar to the TLM, the adjoint model is derived by applying the chain rule to J=J(b)=J(B(ϕ)): ∂J∂ϕ=∏i=1N∂Bi∂Bi-1T∂J∂bN.

Key observations about the adjoint model are as follows. (1) In contrast to the TLM, which acts upon a perturbation, the adjoint model acts upon the sensitivity of the cost function. (2) A single run of the adjoint model is sufficient to determine the gradient δJδϕ. (3) The adjoint model runs in reverse relative to both the model and the TLM, in that the adjoint model applies functions beginning with the counterpart to BN and ending with the counterpart of B0 .

The adjoint model is generated based on AD () of the MATLAB code implementations of the forward model. AD tools process an input code to generate a counterpart code, which returns the corresponding gradient (or Jacobian). The central concept behind AD is that a computer program is fundamentally a sequence of elementary operations and functions. This admits the repeated application of the chain rule to generate a derivative of high accuracy.

Multiple methodologies exist for AD tools to generate the derivative code. Previous applications of AD software to generate the adjoint in glaciology have used reverse accumulation AD tools e.g.. These types of AD software are conceptually similar to the adjoint model. They are designed to determine the gradient of a function (input code) by propagating sensitivities of the output variables backwards to the input variables. Hence, an ice-sheet model can be processed with relatively little modification by reverse accumulation AD tools to generate the adjoint model.

Here, we apply the open source AD tool ADiGator , which in contrast to previous work is a forward accumulation AD tool. The methodology of forward accumulation is conceptually similar to the TLM. It is designed to determine the gradient of a function (input code) by propagating sensitivities of the input variables forward through the program to the output. Applying a forward AD tool to an ice-sheet model to generate the adjoint is not feasible due to the size of the control space. Rather, we generate the adjoint by applying ADiGator to segments of the ice-sheet model code and multiplying the resulting Jacobians following Eq. ().

Pseudocode of the main ice-sheet model routine is shown in Algorithm A1, and the corresponding code to calculate the adjoint is shown in Algorithm A2 (see Appendix). Two new functions, S1 and S2, appear in the adjoint code. These encapsulate segments of code from the forward model and can be processed by ADiGator. The function S2 contains code which spans over two Picard iterations. The adjoint does not contain a for loop corresponding to iterating through the Picard iterations in reverse (cf. ). Rather, values from the final two Picard iterations of the forward model are saved and used as input for the adjoint code. The adjoint model is also modified to solve the cubic equation (following ) to determine η, rather than storing values from the previous iterations and implementing a fixed point iteration. This impacts the η, η¯, and Fa functions but leaves the overall structure the same. This is a necessary modification for ADiGator.

The adjoint code explicitly calculates several Jacobian matrices (lines 15 to 23 in Algorithm A2). ADiGator is applied to the corresponding functions to generate the Jacobian matrices, except the solution to the system of linear equations, which requires special treatment. A counterpart to the linear solve which returns the corresponding derivate is manually programmed following the procedure detailed in the appendix of . The adjoint is then calculated by multiplying out the sensitivities of the cost function with the transposes of the Jacobian matrices. Although this process is more complicated and less flexible than previous approaches, it is necessary because no non-commercial AD reverse accumulation tool is available for MATLAB.

This implementation of the adjoint is equivalent to previously published adjoint implementations restricted to one reverse step in the Picard iteration. This is mathematically equivalent to the Lagrangian multiplier method introduced by .

The gradient from the adjoint model is used to solve the optimization problem which minimizes the cost function. The inversion code relies on minFunc , a publicly available MATLAB unconstrained optimization package. The L-BFGS routine, with a Wolfe condition backtracking line search, is applied in the inversion code. The cost function is discretized using the same finite difference operators as the ice-sheet model.

Performance of the inversion code was verified using a series of identical twin tests . Results are shown in .