The prognostic model or mass transport equation (the two terms are synonymous) describes how the ice thickness changes in time. The prognostic model is 1∂h∂t+∇⋅hu=a˙s-a˙b, where a˙s and a˙b are the surface and basal mass balance, respectively. This problem has the apparent form of a conservative advection equation, but the velocity u is coupled to the thickness and surface slope in such a way that the whole problem is not hyperbolic. For the specific case of the shallow ice approximation (see section Sect. ), the coupled system is parabolic. In all other cases, the problem does not have a PDE “type” in the usual sense because the velocity is found through solving an elliptic PDE where the thickness and surface slope are coefficients.

The icepack package represents the thickness using continuous, piecewise polynomial basis functions in each cell of the mesh. In the examples, we use up to degree 2, and the unit tests use up to degree 4. We have not yet implemented a formulation that works with discontinuous basis functions, but this extension is completely feasible within our framework.

The surface elevation is calculated as 2s=max⁡{b+h,(1-ρI/ρW)h}, with the first case corresponding to grounded ice and the second case corresponding to floating ice. In the immediate vicinity of the grounding line, the assumption that the floating ice is in hydrostatic equilibrium with the ocean fails. Most models assume hydrostasy, and icepack does as well. Elmer/Ice, on the other hand, solves a contact problem for the moving upper and lower ice surfaces and, thus, can accurately model non-hydrostatic ice shelves .

We implement two types of boundary conditions for the prognostic equation. First, users can specify an inflow flux value, and this value becomes a source of thickness at any point along the domain boundary where the ice velocity is pointing in to the domain. The flux at the inflow boundary can change in time. Second, we impose outflow boundary conditions on any part of the domain where the ice velocity is pointing outwards. The segments of the boundary that are inflow or outflow are diagnosed automatically by calculating the sign of the dot product between the velocity and the unit outward normal vector.

The mass transport equation for ice thickness is a free boundary problem, where the free boundary is the contour between ice-covered and ice-free regions . Where there is ablation in ice-free regions, a correctly implemented prognostic solver will compute a negative thickness, which is unphysical and requires correction. The prognostic solver in icepack truncates the thickness to zero, which approximates the free boundary, where there is ablation in ice-free regions. An implicit approach would instead treat the free boundary problem directly as a variational inequality . The icepack package currently lacks such a scheme, and this will be the subject of future development. The Portable Extensible Tookit for Scientific Computation (PETSc) includes scalable solvers for variational inequalities that are also available through Firedrake.

There are four diagnostic or stress balance models implemented in icepack. For each of the diagnostic models, we use a formulation of the physics based on a minimization or action principle . Action principles are completely equivalent to the usual weak form of a partial differential equation but have certain numerical advantages, as described below.

The most complex and most physically accurate model that we implement is the first-order or Blatter–Pattyn approximation, a 3D system describing the horizontal velocity . (In icepack, we refer to our implementation of this equation as a “hybrid model” as it includes both shear and plug flow modes, as described below.) The first-order model is based on an asymptotic expansion of the Stokes equations with respect to the ratio of the ice thickness to a typical horizontal length scale. The aspect ratio of most glacier flows is on the order of 1/20 or less, although there are some exceptions – for example, the main trunk of Jakobshavn Glacier in Greenland flows through a very deep and narrow trough with an aspect ratio closer to 1/5.

From the first-order model, two approximations are possible. First, the shallow ice approximation (SIA) comes from assuming that vertical shear is the dominant mode of ice flow. The SIA model describes the interior of ice sheets well, where flow can be simply described as bed-parallel shear and surface and basal slopes are small. This approximation breaks down near ice margins, where basal sliding can be a large fraction of the surface speed and where membrane stresses are substantial. Second, one could assume that ice flow is purely by horizontal extension and that the surface and bed velocities are practically the same, which is called the shallow stream approximation (SSA). The SSA model describes the fast-flowing margins of the ice sheet best, encompassing grounded ice streams or floating ice shelves .

All of the diagnostic models inherit a fundamental nonlinearity in the mechanics of ice flow. For a Newtonian viscous fluid, the stress tensor τ and the strain rate tensor ε˙ are linearly proportional to each other. Glaciers, however, have a nonlinear constitutive relation: 3ε˙=A|τ|n-1τ, where A is the fluidity, and n is the Glen flow law exponent . The most commonly used value of the flow law exponent is n≈3, as determined from laboratory experiments. Strictly speaking, the fluidity should be a tensor field but is almost universally treated as a scalar .

All of the diagnostic models in icepack are described through variational or action principles . Rather than describe the velocity as the weak solution of a nonlinear PDE, an action principle instead states that the velocity minimizes a functional called the action. The action consists of four terms: 4action=∬stress×strain ratedzdx-∫basal friction×sliding velocitydx-∬surface slope×velocitydzdx-∬ocean pressure×velocitydzdγ, where dzdx denotes integration over the entire glacier, dx denotes integration over the glacier footprint, and dzdγ denotes integration over the side wall boundary. The action has units of power (energy/time) and can be related to the rate of decrease of the thermodynamic free energy .

Every diagnostic model in icepack is encapsulated in its own Python class. The key responsibility of the model classes is to take in the input fields – the ice thickness, velocity, etc. – and return a symbolic description of the action functional in UFL.

The action principle is especially useful for designing a robust numerical solver, the implementation of which will be described in Sect. . For viscous flow problems near to steady state, the action is convex as a function of the ice velocity (i.e., its second derivative is positive-definite). Convexity implies that the action functional has a unique minimizer and that, with an appropriate line search strategy, Newton's method will converge from any initial guess. Algorithms for minimizing convex functionals have better convergence guarantees than algorithms for solving general nonlinear systems of equations while having no additional computational cost . Both formulations are mathematically equivalent.

The shallow shelf, shallow stream, and hybrid models require boundary conditions to be well posed. We implement three different types that are largely the same for each physics model:

Users can specify the velocity on segments of the domain boundary where ice is flowing in; this is a Dirichlet condition which is eliminated from the system at the level of the solver. Supplying inflow boundary conditions for the hybrid model necessarily requires more information, namely the variation of the horizontal velocity with depth.

Many aspects of glacier physics are not completely understood. For example, the most commonly used sliding law is the power law 28τb=-C|u|1m-1u for some exponent m. Older research assumed m=3 based on the theory of regelation , which has since been referred to as the Weertman sliding law. When m=∞, the basal shear stress is independent of the sliding speed; this is referred to as perfect plasticity. More recently, proposed an alternative form that acts like the Weertman law when |u|≪uc and like the plastic law when |u|≫uc. A simplified form of this model can be expressed as 29τb=-C|u||u|+uc1mu|u|, where uc is some critical speed. This latter equation has been found to agree best with laboratory experiments on till and in reproducing observed velocity variations .

The Weertman and plastic sliding laws possess the same functional form but differ only in the value of a single scalar parameter m. The Schoof sliding law, on the other hand, has a totally different functional dependence on the velocity. Several authors, including Schoof, have proposed that the basal shear stress is also a function of the effective pressure N=ρgh-pw within the subglacial hydrological system . Implementing these more sophisticated mathematical models would require adding an extra argument to the procedure for solving the diagnostic equation.

One of our goals with icepack is to facilitate experimentation with the model physics, even for novice users. Of the programming languages that are commonly used for scientific computing, only Python and possibly Julia would appear to meet these needs. To support use cases like implementing the Schoof sliding law, it must be possible not just to change the value of a single parameter but also to completely alter the functional form of a given model component. For uses cases like explicitly adding the dependence of basal shear stress on hydrology, it must also be possible to add entirely new fields to a given model component. In programming terms, this amounts to changing the number of arguments to the function that calculates basal shear stress, which Python accommodates easily. For a library developed in C or Fortran, the user would then also have to change the signature of the diagnostic solve function, which is undesirable. In C++, one could avoid changing the signature of the diagnostic solve routine by (1) using variadic templates, (2) wrapping the inputs in a class, or (3) passing all arguments in a dictionary. Using variadic templates or wrapping the inputs in a class would require users to know more about generic or object-oriented programming than a novice might. Using a dictionary data structure to pass arguments is relatively easier but would be more idiomatic in Python than in C++. Some of the difficulty associated with changing the model physics in a C++ code can be alleviated with automatic differentiation tools, which have been used successfully in Albany/FELIX and ISSM . Nonetheless, C++ or any language with a stronger type discipline will be much more restrictive about changing function signatures.

In icepack, users can substitute any diagnostic model component for the parameterization of their choosing, including adding new fields. From the user's perspective, substituting model physics components does not require any advanced language features beyond keyword arguments. To understand how this is possible, we will briefly describe the path that the input fields take through the program:

The user passes all arguments to the diagnostic solve procedure by keyword.

In step 3, any fields that were unnecessary for calculating a given component are ignored. For example, the gravitational driving power routine will pull out the velocity, thickness, and surface elevation. While the routine will not use them, it also has access to other fields, such as the ice fluidity.

In adopting this approach, we are restricted to using keyword arguments instead of positional arguments. We argue that employing only keyword arguments is a strength rather than a weakness because it enhances readability and comprehensibility for the particular use case of calling a physics solver. The user only needs to know the argument names, which are chosen to agree with the English name most commonly used in the literature – “friction”, “rheology”, “velocity”, etc. The order of the arguments is arbitrary and immaterial. The preference for argument passing by name is specific to this use case, however, and is not universal.

We implemented the enthalpy transport model described in . The enthalpy density E describes the heat content of the material in a way that incorporates both temperature T and latent heat stored in meltwater: 30E=ρI(cT+Lf), where L is the latent heat of melting of ice, and f is the melt fraction. The melt fraction can only be positive when the ice as at the pressure-melting point. The temperature and meltwater fraction can be uniquely calculated at any point from the value of the enthalpy, so nothing is sacrificed in describing heat content one way or the other. Using the enthalpy has the advantage of circumventing many of the difficulties associated with tracking the interface between cold and temperate ice. Our implementation of the model uses all of the simplifying assumptions described in – for example, that horizontal diffusion is negligible and that heat capacity and conductivity are not temperature-dependent within each phase. The resulting PDE is 31∂∂t+∇⋅uE-∂∂zα∂E∂z=q, where u is the full 3D velocity, α is the (temperature-dependent) thermal diffusivity, and q represents the volumetric heat sources. This form assumes some amount of vertical diffusion of water at the melting point. A realistic treatment would require treating the ice as a porous medium and modeling englacial water transport explicitly, which we have not done. The boundary condition at the ice base is a fixed flux of heat from geothermal sources or from the oceans. We depart from in one respect. Rather than fix the ice surface temperature to the atmospheric temperature, we instead use a Robin boundary condition that makes the ice temperature adjust to the external temperature: 32-α∂E∂z|z=s=κ(E-Es), where κ is a surface exchange coefficient, and Es is the temperature-equivalent enthalpy that forces the surface. Using a Robin instead of a Dirichlet boundary condition at the surface allows for more gradual adjustment to above-freezing temperatures that might otherwise create areas of unrealistically high melt fraction. Except in blue ice areas, the thermal contact between ice and the atmosphere is mediated by firn, which we do not model explicitly. The Robin boundary condition is a compromise to work around this missing component of the system. Finally, if there is an upstream boundary, the user must provide the inflow values of the enthalpy with depth, while outflow boundary conditions are applied at the glacier terminus.

The heat transport model assumes that the user will supply a volumetric heating rate, but the model itself does not calculate the heating rate from other fields. The simplest description for the shear heating rate is 33q=τ:ε˙=A-1n|ε˙(u)|1n+1. The fluidity factor A in Glen's law is roughly a known function of both temperature and melt fraction, and we have included this function in the package. However, parameterizing fluidity is not sufficient by itself. While the dependence of fluidity on temperature is known fairly well from laboratory experiments, the dependence on melt fraction is known with much less certainty . Some users of this module may want to substitute in their own parameterization for melt fraction dependence. Other processes such as damage, fabric development, and impurities can affect the fluidity as well. Moreover, there may be other volumetric heat sources that users wish to account for, such as cryo-hydrologic warming . These considerations defy any attempt to have one function that calculates the volumetric heating rate from the other state variables. Instead, we opted for an interface where users calculate this rate themselves, with tutorials and examples that show how to do so for simple scenarios, leaving the freedom to alter the thermal feedbacks as they see fit. Our general design principle is that icepack will solve differential equations for the various prognostic fields, but it is up to users to decide how these fields are coupled.

We have not implemented a model for the surface or englacial transport of meltwater, although it would be possible to include this process. Instead, we rely on an external scheme to act as a sink of enthalpy for meltwater fraction values above some user-defined critical value. A common choice for this critical value is 1 % .

Other physical fields besides temperature can influence ice fluidity. At large spatial scales (> 5 km), crevasse fields affect ice flow by reducing the lateral area over which stress can be transmitted. Modeling individual fractures is not computationally feasible for large-scale simulations. Instead, we have implemented the phenomenological model described in , which is based on the theory of continuum damage mechanics. This model is defined in the class DamageTransport. Prognostic damage models can be broken down into three parts: (1) evolve the damage field based on the membrane stress of the glacier, (2) advect the damage field with flow, and (3) feed the damage field back into the fluidity of the glacier. Changes in fluidity, in turn, affect the membrane stress; the coupling between bulk damage and ice flow goes both ways. The model from adds sources of damage where the membrane stress exceeds a critical value and sinks of damage when the principal strain rate is less than a critical value.

The icepack package offers two time-stepping schemes for solving the prognostic model (Eq. ). For testing purposes, we include the implicit Euler scheme, which is first-order accurate and unconditionally stable for the advection equation. The default is a second-order accurate scheme based on an implicit version of the Lax–Wendroff method, which is also unconditionally stable for the advection equation . Explicit schemes all require a time step that satisfies the Courant–Friedrichs–Lewy (CFL) stability condition, which many glaciologists may be unfamiliar with. With an unconditionally stable scheme, users will get an answer, rather than a runtime error, should they try to use a larger time step. The extra computational cost of using an implicit time discretization for the prognostic equation is dwarfed by the cost of the diagnostic solve. Advanced users who are interested in maximizing performance can subclass the solver to implement a faster explicit scheme. We note that, while the stability properties of different schemes for the linear advection equation guided our choice of method, the coupled system for both thickness and velocity is not linear and not hyperbolic.

The implicit Euler and Lax–Wendroff schemes tend to diffuse out sharp discontinuities that may be present in the true solution . As the ice thickness does not possess shock waves or propagating discontinuities, this error mode is tolerable. The coupling of ice thickness to velocity makes the whole system more closely resemble a parabolic problem than a hyperbolic one, and under the shallow ice approximation, the system is truly parabolic.

Other problems in glaciology have more of a hyperbolic character. For example, the thresholding behavior of the source terms for the damage model (see Sect. ) can create sharp discontinuities. The implicit Euler scheme would obscure this important feature. For the damage solver, we have instead used a strong stability-preserving Runge–Kutta method in time, a discontinuous Galerkin basis in space, and a flux limiter to best capture these sharp interfaces .

The icepack package currently lacks an adaptive time-stepping scheme. Implicit schemes allow for longer time steps to be taken than explicit ones, but taking very long time steps will give inaccurate solutions and, in the presence of ablation, may yield negative thickness values. At present, users are still responsible for checking the accuracy of their results – for example, by running at more than one resolution. Adaptive time-stepping will be added in a future release.

The action functional for each diagnostic model is convex (i.e., the second derivative is strictly positive-definite). From a theoretical perspective, convexity guarantees that the problem has a unique solution. This property is also especially advantageous for implementing numerical solvers. We use a damped Newton method to solve the diagnostic equations. Starting from a guess uk for the velocity, the search direction vk is the unique solution of the linear system 35d2J(uk)⋅vk=-dJ(uk). The next approximation for the velocity minimizes J along the search direction vk starting from uk, i.e., 36uk+1=uk+αk⋅vk,αk=argminαJ(uk+αvk). For an initial guess sufficiently close to the exact solution, the undamped Newton method (αk=1 at every step) converges quadratically. The line search step ensures that the method can converge even from a poor initial guess, provided that the line search method satisfies the Armijo–Wolfe criteria .

For a convex problem, d2J is a symmetric and positive-definite matrix. This has two advantages. First, the search direction is always a descent direction for J, which is not always the case for non-convex problems. Second, symmetry and positivity enable the use of specialized linear solvers, such as the Cholesky decomposition or the conjugate gradient algorithm, that are superior to their more general counterparts in many respects.

Other software packages that treat diagnostic models as nonlinear systems of equations tend to rely on ad hoc procedures for initializing the numerical solution process. For example, without a damping procedure in Newton's method, the iteration can prove unstable if initialized far away from the true solution. Some packages combat this problem by using a few iterations of the more robust but slower Picard method first . While this approach can be effective, it requires the number of Picard iterations to be tuned. There is no guarantee that an adequate amount for one problem will work well on another. This issue rarely appears on realistic input data, but when solving inverse problems, the intermediate guesses for the inferred field can be wildly unrealistic before converging. A forward model solver that is not sufficiently robust can crash in these extreme scenarios. By contrast, a damped Newton procedure using a line search that satisfies the Armijo–Wolfe criteria is guaranteed to converge on nondegenerate, if unrealistic, input data. The line search method that we used here is one way to achieve global convergence of Newton's method, but there are other approaches to achieve global convergence – for example, homotopy continuation or the trust region method .

Several works in the literature have weighed the relative merits of different iterative methods for solving the nonlinear diagnostic equation . Few have considered the problem of when to stop iterating. The most common stopping criteria are when (1) the 2-norm of the residual is sufficiently small or (2) the relative change in the iterates is sufficiently small. Each of these approaches has problems. The residual norm depends on the discretization and does not weight all degrees of freedom proportionally (e.g., vertex and edge degrees of freedom in higher-order finite element methods). The relative change criterion, on the other hand, can suggest convergence when, in fact, the method has stagnated.

We can devise a convergence criterion that works equally well, independently of the discretization and the quality of the initial guess, based on the Newton decrement . As the second derivative operator d2J(uk) is positive-definite, the Newton search direction vk computed from Eq. () is a descent direction for J: 37dJ(uk)⋅vk<0. The absolute value of the quantity in the last equation is defined as the Newton decrement. For uk sufficiently close to the true solution u, the Newton decrement roughly tells us how much we can expect the action to decrease: 38J(uk)-J(u)≈12dJ(uk)⋅vk. We can then use the Newton decrement to decide when to stop the iteration, as described below.

As shown in Eq. (), the action for most models has units of power and is the sum of dissipation due to viscosity, friction, gravitational driving, and ocean back-pressure at the terminus. The viscous and frictional terms are convex, positive functions of the velocity. The gravitational and terminus stress terms are linear in the velocity and can be of either sign. If we define the scale functional 39K(u)=viscous dissipation+frictional dissipation as only the positive parts of the action, the convergence criterion 40|dJ(uk)⋅vk|<ϵK(uk) is then independent of the discretization. The intuition behind this criterion is that the iteration is halted when the expected decrease in the action functional is much smaller than the positive part of the action itself.

We have found empirically that, with this criterion and the Newton solver implementation in icepack, the iteration usually converges to machine precision in around eight steps. The iteration count can reach as high as 20 for exceptionally bad initial guesses for the velocity or with unphysical fluidity or friction values. We also observe the expected doubling of the number of accurate digits in the value of the action once the velocity guesses are within the convergence basin of the true solution. Other convergence criteria, such as using relative change in the velocity guesses, can terminate prematurely when the initial guess is very far outside the quadratic convergence basin.

The numerical solvers in icepack have been designed so that users who are not familiar with numerical optimization need not be confronted with a possibly bewildering array of algorithmic parameters. Consequently, sensible defaults have been chosen for the Armijo and Wolfe criteria , and the tolerance for the line search is chosen based on that of the outer-level Newton iteration. The Newton search direction is calculated using a direct factorization solver rather than, say, the conjugate gradient algorithm, as the use of another iterative method would introduce yet another algorithmic parameter. Advanced users who are interested in performance optimization can change these algorithmic parameters by passing extra arguments to the solve procedure.

The InverseProblem class describes what problem is being solved, whereas the InverseSolver class is responsible for carrying out the numerical optimization. There are three inverse solvers in icepack: a simple gradient descent solver, a quasi-Newton solver based on the BFGS approximation to the Hessian, and a Gauss–Newton solver. All of these classes are based around the general idea of first computing a search direction and then performing a line search. They differ in how the search direction is computed.

The gradient descent solver uses the search direction 41ϕk=-M-1dJ(θk), where M is the finite element mass matrix. Gradient descent is a popular choice because the objective functional is always decreasing along this search direction. However, the search direction can be poorly scaled to the physical dimensions of the problem at hand. This method can be very expensive and brittle in the initial iterations and often takes many steps to converge.

The BFGS method uses the past m iterations of the algorithm to compute a low-rank approximation to the inverse of the objective functional's Hessian matrix (see , for a more in-depth discussion). The BFGS method converges faster than gradient descent. However, it suffers from many of the same brittleness issues in the initial iterations before it has built up enough history to approximate the Hessian inverse.

Finally, the Gauss–Newton solver defines an approximation to the “first-order” part of the objective functional Hessian . Each iteration of Gauss–Newton is more expensive than that of BFGS or gradient descent because it requires the solution of a more complex linear system than just the mass matrix. The Gauss–Newton method converges fastest by far in virtually every test case we have found, in some instances by up to factor of 50.

The derivative of the objective functional with respect to the unknown parameter is calculated using the adjoint method and the symbolic differentiation features of Firedrake. The user does not need to provide any routines for the derivatives, only the symbolic form of the error metric and the regularization functional. The model object is responsible for providing the symbolic form of the action functional.

The hybrid flow model uses several features that are available in Firedrake to better exploit the special structure of the problem. Implementing this model also required some mathematical sleight of hand related to the terminus boundary condition that has not appeared in the literature before. Additionally, the hierarchical structure of spectral basis functions presents an opportunity for developing fast algorithms. In all other respects, the implementation of the hybrid flow model using convex optimization follows the techniques described above.

The icepack package largely inherits the performance capabilities of the Firedrake package, for which we refer to the benchmarks in . Firedrake is, in turn, built on PETSc, which includes a rich suite of nonlinear solvers and preconditioners that have been demonstrated to scale up to hundreds of processors . Firedrake also includes special features for defining sophisticated solvers and preconditioners that take advantage of problem-specific structure . The icepack package exposes these tools through the interface of the flow solver objects, so users can select any solver and preconditioner from PETSc.

We have mainly developed icepack for process-scale studies of individual glaciers or drainage basins. For the demonstrations presented below, nearly all simulations run in a matter of minutes to hours on a single core. We have used sparse LU factorization to solve linear systems for many problem instances in order to eliminate the linear solver as a possible failure mode. Defaulting to a robust solution method is especially important for onboarding novice users who may not be familiar with different iterative linear solvers and preconditioners. Larger problems, such as continental-scale modeling, will require solving the diagnostic equations using the conjugate gradient method with an appropriate preconditioner to achieve parallel scalability. The particular structure of the problems that we solve may be useful in choosing a preconditioner. For example, a rudimentary preconditioner for the hybrid model system could use the degree-0 model as the coarse space in a multigrid-type approach. These optimizations will be the subject of future work.

As a first test case for icepack, we ran the first experiment from the Marine Ice Sheet Model Intercomparison Project version 3 (MISMIP+). The parameters and geometry for this experiment can be found in . The MISMIP+ experiment has three phases. First, the model must find a steady-state marine ice sheet with a fixed accumulation rate and no submarine melting. Next, submarine melting with a given depth-dependent parameterization is applied for 100 years. The increased melt thins the ice shelf and initiates a retreat of the glacier grounding line. Finally, submarine melting is turned off for at least 100 years, optionally longer. The grounding line then readvances, although not as far as its original position.

The original intercomparison project specified that participants could use the Weertman sliding law (Eq. ) as well as two other sliding laws that transition to a more plastic rheology at high sliding speeds. The first alternative sliding law consists of Weertman sliding until the stress reaches a critical value, at which point the constitutive relation transitions to perfect plasticity. The second alternative is the Schoof sliding law : 43τb=-C|u|1/m⋅τc(Cm|u|+τcm)1/mu|u|, where the critical stress τc is a certain specified fraction of the water pressure in the subglacial hydrological system. Sliding laws in icepack are not expressed directly, but rather as the derivative of an action functional. To implement the Schoof sliding law, we need to know the antiderivative of Eq. (). We found the antiderivative of this expression using a computer algebra system, but the result includes hypergeometric functions. The Unified Form Language has several transcendental functions (sine, cosine, exponential, etc.), but it does not currently support hypergeometric functions. Instead, we implemented a sliding relation that exhibits the important features of the Schoof law, i.e., it behaves like an m=3 power law at low sliding speeds and m=∞ at high sliding speeds, but which is more tractable algebraically. Knowing the critical stress τc and the friction coefficient C, which has units of stress × speed -1/m, we can define a critical speed uc as 44uc=C-mτcm. The power dissipation density for the Schoof-type sliding law that we use is 45P=τcuc1m+1+|u|1m+1mm+1-uc. Figure  shows a comparison of the original Schoof sliding law and the sliding law that arises as the derivative of the functional in Eq. (). The two have the same asymptotic behavior when the speed is much smaller or much larger than the critical speed; they differ in a relatively small range around the critical speed. The relative difference in basal shear stress between the two sliding laws is less than 10 % throughout the entire range. Although Fig.  shows a comparison of both sliding laws with the same value of the critical speed, by using different values, the agreement between our sliding law can be brought into much closer agreement with the Schoof law. Finally, the Schoof law itself is phenomenological. A different sliding law with the right asymptotic behavior is no more or less valid.

To change the sliding law, users only need to pass one function or the other to the model object at initialization. (See the “Code and data availability” section below for the source code.) Users do not need to implement a subclass that overrides some parent method. This approach would be idiomatic in C++, but it requires knowledge of object-oriented programming that a nonexpert might lack.

Figure shows the thickness and ice speed after spinning up the MISMIP+ geometry and input data to steady state with the sliding law described above. The spin-up used degree-1 basis functions for both thickness and velocity. To get a high-resolution estimate for the steady state, the spin-up started from a relatively coarse resolution to propagate out most of the transient signal. Then the mesh was successively refined and spun up again to propagate out the remaining high-wave-number transients. This process was repeated three times. The net result is that most of the spin-up is done at a relatively low computational cost. Figure  shows the total ice mass during the retreat and readvance phases of the experiment. The initial response to turning on melting is very rapid but then becomes roughly linear with time. When the high melt is turned off at the 100-year mark, the ice readvances, but the rate is much slower than the rate of decrease when melt was on. This asymmetric response is typical and expected from ice physics; the rates broadly agree with the reference results computed with BISICLES in the original experimental specification .

We also ran the experimental setup to steady state using the hybrid flow model with vertical basis functions up to degree 2. This is the most minimal set of vertical basis functions that can resolve plug flow and the stress boundary conditions at the ice base and surface. The ratio of basal velocity to surface velocity is shown in Fig. . The areas with the most significant vertical deformation are at the inflow boundary and where the troughs at the side walls are steepest. Otherwise, the sliding ratio is above 0.8 throughout almost the entire domain.

Using variational principles to express all constitutive laws is less flexible than specifying the sliding law directly, and this is a distinct disadvantage. Nonetheless, we were able to implement a sliding law that exhibits the important characteristics of the Schoof sliding law. also suggest using a sliding law that transitions sharply to exact plasticity above the critical speed. Expressing this sliding law in UFL requires a conditional in the velocity and is, thus, no longer differentiable, causing the forward solver to crash. The numerical advantages of using variational principles are so great, however, that we view this trade-off as acceptable.

As a demonstration of the shallow ice approximation model, we ran an experiment inspired by . In this work, the authors coupled an ice flow model to simple models for bed erosion, calving, and glacial isostatic adjustment (GIA) to investigate the formation of deep fjords that are characteristic of coastlines on Baffin Island, Greenland, and British Columbia, among others. We emulated their domain and bedrock geometry – a plateau surrounded by a ridge punctuated by four valleys – without also simulating erosion or GIA.

Figure  shows the results of this computational experiment. We initialized the experiment with a simple but unrealistic ice thickness. We then evolved the ice sheet without climate forcing for 500 years. The ice sheet relaxes very rapidly in the first 200 years, but changes are much slower after this, as ice must be funneled through one of the four narrow valleys. The resulting velocity pattern is similar to that of , with the highest velocities where ice flows out from the valleys. In and upstream of the valleys, the surface is drawn down due to the elevated export of ice.

The diagnostic model used in this demonstration is computationally cheap enough that it can be used to simulate ice sheets over several millennia in a matter of minutes on a desktop. A key feature of icepack is the ability to choose between many different diagnostic models. Users are free to decide what model works best for the spatial and temporal scales of their problem, how accurately they need to solve this problem to produce useful results, and what computational resources they are willing to devote.

We simulated the evolution of a synthetic ice shelf towards steady state and coupled it with the damage transport model described in Sect. . The geometry of the ice shelf consists of the intersection of two circles, one with a larger radius and offset center, designed to roughly mimic the shape and size of real ice shelves. The radius of the whole shelf is 200 km. Four ice streams flow into the shelf with varying speeds and a prescribed inflow thickness. In the first phase of the experiment, the ice shelf is propagated to steady state without damage for 200 years. After this time interval, the flux imbalance is less than 1 % of the influx. In the second phase, damage transport is turned on and coupled to the ice velocity. An interesting feature to observe in the approximate equilibrium damage field is that the highest values occur between the streams and not within them. Additionally, the spacing between the streams changes as a result of adding damage. The final ice thickness, velocity, strain rate, and damage are shown in Fig. .

To demonstrate the inverse solver, we will estimate the rheology of the Larsen C Ice Shelf in the Antarctic Peninsula from observational data. Several recent studies have focused on Larsen C because it may be unstable in the warmer climate of the coming decades. From January to March of 2002, the neighboring Larsen B Ice Shelf disintegrated due to surface melt pond-induced fracture . This mechanism might also lead to the breakup of Larsen C in the future. One of the key factors affecting the stability of ice shelves is the presence of marine ice – seawater that freezes onto the base of an ice shelf – in the suture zones where two flow units meet . Marine ice is warmer than meteoric ice and usually includes brine pockets, which are discernible in radio echo sounding measurements as the absence of reflection from the ice shelf base . This warmer and impurity-laden ice is more ductile and, thus, should be less prone to fracture than cold and brittle meteoric ice. Ocean models predict that marine ice forms under Larsen C as well . By estimating the material rigidity of an ice shelf, we can constrain where marine ice may be forming.

Each of the model objects in icepack is a class with a method ending in solve that takes in keyword arguments for the various input fields and options for things like boundary conditions. Users already familiar with, say, the IceStream class can then use the HeatTransport class under the assumption that the input fields – the current temperature T, ice velocity u, and basal melt rate m – are passed as keyword arguments with the same name as the fields themselves. Consistency obviates the need to repeatedly consult the documentation or examples once users are already familiar with the software.

Progressive evaluation is the main advantage of having a user interface in an interpreted programming language such as Python as opposed to a compiled language where programs can only run in batch mode. In the early stages of the development process, any nontrivial simulation of a physical system exists as a prototype which may be nonfunctional or even broken. The ability to manually step through a simulation and examine the entire state in an interpreter is critical to finding errors faster. The icepack package was designed to give fine-grained control over how simulations work in order to support this mode of debugging. The application programming interface (API) provides routines for solving the diagnostic and prognostic equations. It is the user's responsibility to make the repeated calls to these routines, either in a loop or by manually iterating through one step at a time. With this responsibility comes the freedom to add in arbitrary code. This capability might be used to add sanity checks, such as printing minimum and maximum thickness or velocity values. It can also be used to get feedback on how long the simulation will take or to save results for later visualization. Other packages support a more coarse-grained view where the user only specifies the start and end time of a simulation and has more limited options for inspecting the state of the running program.

The icepack package makes extensive use of Jupyter notebooks as a form of executable documentation. Jupyter notebooks are a document format that includes code and explanatory text with typeset mathematics that runs interactively in a web browser . The contents of a notebook can be executed incrementally much like running code in the Python interpreter. Most importantly, Jupyter notebooks can render and display visualizations on the fly. This enables a workflow where plotting all intermediate results serves for sanity-checking an experimental simulation.

Simulations that have been debugged can then easily be transformed into a single Python script, for example, using the tool nbconvert, for production runs and parallel execution. In other words, while there is an interactive interface, there is also a faster batch mode interface.

The API for icepack has been designed so that the users only need to decide what problem to solve and not how to solve it. Where a choice does concern the how more than the what, we use a sensible default that biases for correctness rather than speed. For example, the Newton solver uses a direct factorization method to solve the linear system for the search direction because factorization requires no tuning whereas iterative methods do. A user interested in achieving greater runtime performance can pass additional keyword arguments instead specifying, say, the preconditioned conjugate gradient method. This choice is of interest mostly to advanced users, so we keep the linear solver algorithm as a default argument. In so doing, we avoid confronting novice users with options that they might not understand.

Advanced users who do wish to tune solver performance for large simulations will need some way to make choices about algorithms. For example, one might choose the generalized minimum residual (GMRES) iterative solver together with an incomplete LU preconditioner to solve linear systems. The solver classes, as opposed to the model classes, provide the interface for making these choices. While alternative solvers might offer faster runtime performance than direct factorization, they also require additional choices to be made – for example, how often to restart GMRES, or how much fill-in to allow in the incomplete factorization. Many glaciologists do not have the background in numerical linear algebra to know that adjusting these parameters could make the difference between solver convergence or breakdown. As another example, users might want to select between different discretization strategies for the Stokes equations. The discretization of the Stokes equations has to be chosen carefully in order to satisfy the Ladyzhenskaya–Babuška–Brezzi (LBB) conditions . When using Galerkin least squares stabilization of the weak form, the user has to pick a value of the stabilization parameter. Determining exactly what value of this parameter is necessary to guarantee stability is a subtle problem, even more so for the kinds of highly anisotropic meshes that are commonly encountered in 3D glacier flow modeling. If the solver fails to converge, it might not be obvious, even to an expert, whether the problem lies with the stabilization or the aforementioned parameters of the linear solver.