andre r. erler

PHY2609: Term Project Report1

Parameter Studies on Lithospheric Loading with2

Application to Terrestrial Planets and and Icy Moons3

Andre R. Erler4

December 19, 20095

1

Andre R. Erler PHY2609 December 19, 2009

The objective of this paper is to explore the scaling behavior of a litho-1

spheric flexure model. Of primary interest are parameter regimes that apply to2

the rocky lithosphere of terrestrial planets and the icy shells of some moons in3

the outer solar system, in particular Jupiter’s moon Europa. Only the topog-4

raphy and the outermost surface of a planet or moon are accessible to remote5

sensing; estimates of mechanical properties based on the characteristic scale6

of observed topography can for example provide constraints for models of the7

interior structure of a planet or moon.8

In this paper the response of the lithosphere to prototypical stress and load9

scenarios implied by certain topographical features will be simulated numeri-10

cally. The lithosphere will be approximated by a thin sheet; it is characterized11

by a flexural rigidity parameter, which is a function of the mechanical proper-12

ties of the material, and the effective thickness of the elastic sheet. It is further13

shown that in its nondimensional form, it is also a function the length–scale.14

The topography of planets and moons often exhibits a certain characteristic;15

the strength of the lithosphere supporting the observed topography can be es-16

timated from its characteristic length scale. It is for example argued that the17

apparent smoothness of Europa is due to its icy surface’ inability to support18

loads of a length scale larger than a few tens of kilometers.19

Many topographical feature from meteorite craters to subduction zones ex-20

hibit an approximate symmetry; this will be used to reduce the governing PDE21

to one dimension. The most common symmetries (and the only ones that will be22

considered here), are rotational symmetry and symmetry along one horizontal23

direction. Difference between the two symmetries will be discused as well.24

2


1 Introduction1

The Lithosphere is the rigid outer surface of the Earth and other planets and moons. It2

includes the entire crust and sufficiently cold parts of the mantle which behave rigidly.3

The Lithosphere floats (buoyantly) on a fluid–like hotter layer of the mantle, called the4

asthenosphere. The lithosphere is in reasonable approximation a rigid plate, which can bend5

under applied loads. Very much like sea ice floating on the oceans, only that the viscosity6

contrast between sea ice and water is much larger; the transition between the lithosphere7

and the asthenosphere is not as clearly cut. The tectonic plates and significant topography8

like major mountain ranges are usually supported by hydrostatic forces; large mountain9

ranges, are in this way again very similar to icebergs (which are also frequently frozen into10

a larger ice sheet, similar to a continental plate). On shorter length scales however, the11

rigidity of the lithosphere can support significant deviations from hydrostatic equilibrium.12

The other terrestrial planets also posses rigid lithospheres, although there is no known13

tectonic activity on any of them. Large planetary bodies are in good approximation in14

hydrostatic equilibrium and form ellipsoids.1 Depending on the mechanical strength of the15

lithosphere deviations from hydrostatic equilibrium can be supported by elastic forces. The16

gas giants are obviously hydrostatic equilibrium. Jupiter’s moons, however, not necessarily,17

as they have rigid outer shells. The outer layers of Ganymede, Callisto, and Europa consist18

of ice, while Io’s lithosphere is likely made of silicates. Io’s lithosphere is assumed to be19

very strong as it supports extreme topography. On Callisto, Ganymede, and Europa ice20

takes over the role of rock, forming a rigid, brittle outer shell, and a ductile, fluid–like layer21

underneath (analogous to glaciers; the deeper layers become more ductile under pressure22

and higher temperatures). Thickness estimates for the europan lithosphere (rigid outer ice23

1Hydrostatic equilibrium, leading to a spherical or ellipsoidal shape, is in fact part of the definition of a

planet.

3


shell) are of the order of 1 km to 10 km; the lithospheres of Callisto and Ganymede are1

estimated to be significantly thicker Luttrell and Sandwell (2006). This makes Europa’s2

lithosphere significantly weaker than its rocky counterparts, and provides the opportunity3

to study a different parameter regime.4

In the first part of this paper a lithospheric flexure analysis using an elastic flexure5

model for Venus and Europa will be compared; the apparent similarity then motivates an6

investigation into the parameter–dependence of the governing PDE and its solutions. In7

particular the dependence of the solution on length scale is investigated and implications8

for the length scale of surface topography are discussed. In this context the apparent9

smoothness of Europa will be addressed.10

The next chapter (Section 2) will introduce the elastic thin plate model used to model11

the lithosphere, in Section 3 the numerical implementation will be discussed, before the12

flexure analysis and the parameter study will be presented in Section 4. A discussion of the13

results in the broader context follows in Section 5, before a summary of the main points14

(Section 6) concludes this paper.15

2 Mathematical Formulation of Elastic Plate Bending16

The upper part of the mantle of planets and moons exhibits a strong temperature gradient17

and is significantly colder than the interior; because of the relatively low temperature the18

lithosphere (the uppermost part of the mantle and the crust) behaves like a rigid body,19

rather than a ductile fluid. The mechanical properties of the lithosphere are commonly20

described in terms of a rheological model. In order to relate strain and strain rates to21

stresses, assumptions have to be made about the rheology of the lithosphere.22

The best fits to observed lithosphere flexure and deformation is obtained from elastic–23

plastic rheologies, where purely elastic deformation occurs at the immediate surface, where24

4


the lithosphere floats as a rigid plate atop the fluid–like mantle material. When parts of1

the lithospheric plate is subducted into the hot mantle material under strong bending,2

permanent plastic deformation occurs Turcotte et al. (1978).3

In this paper we are only interested in the behavior of the uppermost lithosphere, which4

is exposed to the atmosphere, ocean, or space. For this reason we only need to consider5

elastic rheologies and can model the lithosphere as an thin elastic plate, floating on a6

fluid–like asthenosphere. The internal bending moments of a thin plate can be described7

by Kirchhoff’s Thin Plate Theory; for geophysical applications a buoyancy term has to be8

added, which is proportional to flexure.9

The partial differential equation (PDE) that governs the bending and flexure of the10

lithosphere represents a balance between internal bending moments, external load, and11

buoyancy forces.12

2.1 Kirchhoff’s Thin Plate Theory13

Kirchhoff’s Thin Plate Theory is a highly idealized model for plate flexure. Although14

better models are available, this model shall suffice for our purpose. The derivation of the15

model requires a number of assumptions, but it is still reasonably accurate when these16

assumptions are violated to some extend. The assumptions are:17

• The plate is thin, i.e. it’s lateral dimensions are much larger than its vertical extent18

(the thickness). At the same time the plate must be of finite thickness to support19

bending moments.20

• Mechanical plate properties are homogeneous (or vary slowly), throughout the plate;21

here only homogeneous plates will be considered.22

• No significant stretching of the mid–plane occurs (pure plate mechanics, no membrane23

mechanics).24

5


The second assumption is clearly violated, as lithospheric thickness, composition, and tem-1

perature do vary significantly. Neglecting this variation amounts to assuming effective mean2

values for mechanical parameters (e.g. effective elastic thickness).3

The derivation of the PDE governing elastic flexure of a thin plate in the framework4

of Kirchhoff’s theory can be broken down into three steps. The point of departure (the5

Ansatz ) is to assume that all internal (bending) moments are in equilibrium; then a moment6

equation is needed to relate bending moments to plate curvature and strain, and finally7

the relationship to plate flexure is established through a kinematic equation (i.e. strain is8

expressed in terms of plate flexure).9

Local equilibrium of bending moments implies that the infinitesimal bending moment M

exerted by a load–density q(x, y) on a line element dx must be balanced be a gradient in

the internal moments (the infinitesimal moment arm of the load–density q(x) is also dx).

The moment balance along the x–axis (longitudinal moments Mxx) and about the y–axis

(transversal moments Mxy), can be written as

∂Mxx

∂xdx +

∂Mxy

∂ydx =

∫ x0+dx

x0

q(x′) (x′ − x0) dx′ . (1)

The integral can be dealt with by differentiating with respect to x, which yields

∂2Mxx

∂x2dx +

∂2Mxy

∂x∂ydx = q(x) dx . (2)

In the two dimensional case the load is supported by the sum of all moments about both

axis. In an isotropic material (Mxy = Myx), this yields the internal equilibrium equation:

∂2Mxx

∂x2+∂2Mxy

∂x∂y+

∂2Myy

∂y2= q(x, y) . (3)

The kinematic equation follows from consideration of linear displacement in a verti-

cal/horizontal cross–section. The displacement d at a distance z above the mid–plane is

directly proportional to the bending angle θ at the corresponding foot–point in the mid–

plane d = z θ; the bending angle is given by the respective partial derivative of the flexure

6


w(x, y). Then the strain ε is given by the rate of change of displacement. Thus the two–

dimensional strain tensor in a plane–parallel to the mid–plane and a distance z above,

takes the form

εij(z) =∂

∂xi(z θj) =

∂

∂xi

(z∂w(x, y)

∂xj

), i, j = 1, 2 . (4)

Since the strain tensor is symmetric, only three components are independent, and it is

convenient to write the strain components as a three component vector ~e (six components

in three dimensions). The components are commonly denoted by the symbol e with the

corresponding axis (x, y) as subscript.2 Again in a plane a distance z above the mid–plane,

the three strain components take the form

exx = −z ∂2w

∂x2, eyy = −z ∂

2w

∂y2, exy = −2 z

∂2w

∂x∂y(5)

Finally, by use of the stress–strain–relationship in vector form ~s = T~e, the curvature–1

induced strains ~e can be related to the internal bending moments Mij.2

The strains ~e in Eq. 5 depend on z; in order to obtain the total bending moment, the

moments arising from the stresses as ~m(z) = ~s(z) z have to be integrated over the (finite)

thickness of the plate:

Mij = −∫ h/2

−h/2sij(z) z dz = −T

∫ h/2

−h/2eij(z) z dz =

h3

12Λij

∂2w

∂xi∂xj, (6)

where the symbol Λ is defined as Λxx = Λyy = 1 and Λxy = Λyx = 2.3

Like the strain tensor the stress tensor σij is symmetric and in two dimensions only

three of the four components are independent, and a similar vector–notation can be used.

Introducing the flexural rigidity parameter

D =E h3

12 (1− ν2), (7)

2The strain can also be written in terms of the curvature κ; here the curvature tensor is simply the second

derivative of the plate flexure κij = ∂2w∂xi∂xj

.

7


and using the definitions from Eq. 5, the stress–strain–relationship for the two normal

stresses can be used to express the first two total bending moments as

Mxx =E

1− ν2(εxx + ν εyy) = D

(∂2w

∂x2+ ν

∂2w

∂y2

), (8)

Myy =E

1− ν2(εyy + ν εxx) = D

(∂2w

∂y2+ ν

∂2w

∂x2

). (9)

Here E is Young’s modulus and ν denotes Poisson’s ratio; both are mechanical properties

of the material under consideration. In factoring out E and ν and using only one symbol

for each, we have implicitly made use of the homogeneity and isotropy assumption. In the

one dimensional plane–parallel case for symmetry reasons only stresses and strains along

the x–axis are considered. The third total bending moment in two dimensions is due to

shear stress, and, using the same definitions as above, takes the form

Mxy =E

1 + νεxy = D (1− ν)

∂2w

∂x∂y. (10)

This component also vanishes in the one–dimensional case.1

Now the biharmonic equation for elasticity can be formulated; for this purpose the

bending moments in Eq. 9 and 10 can be inserted into the equation of moment equilibrium

(Eq. 3). All terms involving ν cancel and we arrive at a biharmonic equation for plate

flexure w(x, y):

D(∇2)2w(x, y) = q(x, y) (11)

Where the biharmonic operator in Cartesian coordinates is defined as

D(∇2)2

=∂4

∂x4+

∂4

∂x2∂y2+

∂4

∂y4. (12)

In polar coordinates the expression is significantly more involved, but for our purpose the

rotationally symmetric form will suffice. Setting ∂∂φ

= 0, we obtain (Weisstein, 2009)

(∇2)2

=∂4

∂r4+

2

r

∂3

∂r3+−1

r2

∂2

∂r2+

1

r3

∂

∂r. (13)

8


This is the biharmonic equation for elastic plate flexure, as derived from Kirchhoff’s1

Thin Plate Theory; it was first derived by Lagrange (Felippa, 2009).2

2.2 Application to Geophysical Problems and Boundary Conditions3

The purpose of this discussion is to derive a partial differential equation that describes the4

flexure of the lithosphere under certain load distributions. In a somewhat idealized way,5

we think of the lithosphere in terms of cold rigid plates floating on top of a fluid–like hot6

mantle; not unlike sea ice floating on the oceans. When a lithospheric plate is bend, it dips7

into the mantle and displaces fluid–like mantle material. Therefore we also have to include8

buoyancy forces. Kirchhoff’s classic Thin Plate Theory only considers elastic forces.9

Fortunately buoyancy forces are strictly local and are linear in the vertical plate dis-

placement, which is equivalent to the flexure w(x, y). The effect of buoyancy forces is to

reduce the effective load, and they can be treated as a negative load function:

D(∇2)2w(x, y) = (q(x, y) − ∆ρg w(x, y)) . (14)

g is the gravitational acceleration; the density contrast ∆ρ is for our purpose given by

∆ρ = (ρM − ρL), where ρM is the mantle density, and ρL the density of the lithosphere.

Note however, that this definition implicitly assumes that the plate flexure does not create

any cavities in the supporting fluid. In the case of simple depressions this requires that

the depth of the depression does not exceed the thickness of the plate. Is the plate thin

compared to the amplitude of the flexure, the density contrast between the supporting and

the overlying fluid has to be used (e.g. water, for oceanic lithosphere). Rewriting q(x, y) in

terms of the load topography q(x, y) = ρCg f(x, y) yields

D(∇2)2w(x, y) + (ρM − ρL) g w(x, y) = ρCg f(x, y) . (15)

This is the equation that is used to model the flexure of the lithosphere in two dimensions.

In many cases of practical relevance the problem can be reduced to one dimension by

9


exploiting suitable symmetries of the problem. Consider for example a load distribution

which does not vary in the y–direction: the problem is symmetric along the y–axis, and

the solution will only depend on x. With ∂∂y

= 0 we obtain

D∂4w(x)

∂x4+ (ρM − ρL) g w(x) = ρCg f(x) . (16)

This one–dimensional Cartesian form of Eq. 15 can be found in most text books on geo-

dynamics (e.g. Turcotte and Schubert , 2002). Another prototypical load scenario involves

a load distribution which is concentrated around a center and exhibits approximate rota-

tional symmetry. In this case polar coordinates with the coordinate pole coinciding with

the load center are appropriate. Due to rotational symmetry the azimuthal dependence

vanishes ( ∂∂φ

= 0), and the biharmonic operator in polar coordinates (Eq. 13) can be used.

Eq. 15 reduces to

D∂4w(r)

∂r4+

2D

r

∂3w(r)

∂r3+−1D

r2

∂2w(r)

∂r2+D

r3

∂w(r)

∂r+ (ρM − ρL) g w(r) = ρCg f(r) .

(17)

In this paper only solutions to the one–dimensional forms Eq. 16 and 17 will be of interest.1

Numerical solutions will be presented in Section 4, and the discretization procedure will2

be discussed in Section 3.3

2.2.1 Boundary Conditions4

Obviously the load scenario will have a dominant impact on the form of the solution;5

the other major factor are the boundary conditions. As for every 4th–order equation, four6

boundary conditions are required. It is common but not necessary to specify two at each7

side.8

Figure 1 shows solutions to Eq. 16 with different boundary conditions (the equations were9

nondimensionalized as described in Section 2.3; the absolute amplitude is of no consequence10

10


here). Two different load scenarios were applied: the solutions with symmetric boundary1

conditions were subjected to a symmetric load at the center of the domain. In the cases with2

asymmetric boundary conditions the load was applied at the left boundary of the domain.3

The latter configuration can be thought of as a half–space solution, where symmetry of the4

solution with respect to the symmetry axis of the load was assumed.5

If symmetry with respect to one of the boundaries is assumed (a reflecting or mirror6

boundary), certain continuity conditions have to hold. For analytical solutions reflecting7

boundary conditions are usually taken to imply that the solution has to be an even function8

(with respect to the boundary). To ensure that an arbitrary (possibly numerical) solution is9

an even function, the appropriate conditions are that all odd derivatives must vanish at the10

boundary.3 For the problems discussed here this means that the first and third derivative11

have to vanish at the left boundary.12

The choice of the boundary conditions determine the type of plate that is modeled and13

how it is supported. The following four types are commonly used:14

Fixed (at infinity): Fixed boundary conditions prescribe a certain value for flexure15

(usually zero) and require that the first derivative vanishes, so as to continuously16

blend into a zero–flexure boundary conditions at infinity. This boundary condition is17

usually used for the far end of the domain (here the right boundary).18

Hinge: These boundary conditions imitate a rotating hinge: the value of the flexure19

is fixed, but the plate can rotate, so that bending moments at the hinge vanish (M ∼20

∂2w(x)∂x2 = 0). This boundary conditions is more relevant for engineering applications.21

Depression: A depression at the boundary is usually a half–space solution to a sym-22

metric centered load, producing a symmetric basin or depression. Reflecting boundary23

3This can easily be seen in a Taylor–series expansion about the boundary: only odd exponents produce

a non–vanishing term in an odd derivative, and odd exponents in a power–series imply asymmetry.

11


conditions are imposed at the symmetry axis/plane of the load, so that the first and1

the third derivative vanish. Unless otherwise noted, this type of boundary condition2

will be used for the analysis presented in Section 4.3

Free: A free boundary conditions is used to model a plate that is supported on one4

side, and free to bend under any load at the opposite end. The boundary condition at5

the free end is that the bending moment and its derivative, i.e. the second and third6

derivative, vanish. This type of boundary conditions is for example used to model7

the bending of a fractured plate or plate subduction at ocean trenches.8

All of these boundary conditions are displayed in Fig. 1 (left); note however that the9

latter two cases, denoted “depression” and “free”, are complemented by “fixed” boundary10

conditions on the far (right) end; the load distribution is indicated by dashed lines.11

2.3 Nondimensionalization12

For the objective of this paper it is of advantage to nondimensionalize Eq. 15, so as to13

minimize the number of free parameters and include coordinate scaling effects.14

First note that the PDE Eq. 15 is linear and thus the amplitude of the solution is

directly proportional to the amplitude of the forcing/load. If the amplitude of f(x, y) is F ,

we can normalize the solution and the forcing function. Introducing a length–scale L, the

horizontal coordinates x and y can be nondimensionalized as well (dividing by ρL g).

f ∗ =f

F

ρLρC

, w∗ =w

F, x∗ =

x

L, y∗ =

y

L(18)

Noting that spatial differential operators scale inversely with length–scale, the nondimen-

sional forms of the flexural rigidity parameter D and the buoyancy contrast ∆ρ can be

written as

D∗ =D

L4 ρ g=

E h3

12 (1− ν2) L4 ρ g, ∆ρ∗ =

∆ρ

ρ=

ρMρL− 1 . (19)

12


Note that the nondimensional flexural rigidity is now inversely proportional to length–scale

(in the forth power). With the above definitions the governing PDE (Eq. 15) takes the form

D∗(∇∗2)2w(x∗, y∗) + ∆ρ∗w∗(x∗, y∗) = f ∗(x∗, y∗) (20)

The relevant equations in Cartesian and polar coordinates follow immediately, by inserting1

the appropriate form for the biharmonic operator. Now the governing PDE depends on only2

two parameters, the nondimensional flexural rigidity and the nondimensional buoyancy3

contrast.4

3 Numerical Implementation5

The one–dimensional forms of Eq. 20 in Cartesian (Eq. 16) and polar coordinates (Eq. 17)6

were solved numerically. To this end Eq. 16 and 17 were discretized and solving the PDE7

is reduced to solving a linear system of equations.8

3.1 Finite Difference Approximation9

To discretize the governing PDE a finite difference approach was taken. The biharmonic10

operator was approximated by a 2nd–order centered difference operator in the interior of11

the domain, and by appropriate forward– and backward–biased operators at the bound-12

aries. The buoyancy term and the forcing term do not include any derivatives and the13

discretization merely amounts to evaluating the function at each grid point. A regularly14

spaced grid with 1500 grid points was used in all numerical experiments.15

A 2nd–order finite difference operator for a 4th–order differential operator requires a

5–point stencil. In the interior of the domain the discrete operator in point–form is

(δxxxx)j = wj−2 − 4wj−1 + 6wj − 4wj+1 + wj+2 . (21)

13


In matrix–notation the discrete differential operator can be written as a banded matrix

with five non–zero coefficients

(δxxxx)j : A4 = B( 1,−4, 6,−4, 1) . (22)

In the one–dimensional Cartesian case the discrete biharmonic operator is just Acart = A4.

In polar coordinates lower order derivatives are also required (Eq. 13); these also have to

be approximated by corresponding 2nd–order centered difference operators:

(δx)j : A1 =1

2B(−1, 0, 1) , (23)

(δxx)j : A2 = B( 1,−2, 1) , (24)

(δxxx)j : A3 =1

2B(−1, 2, 0,−2, 1) . (25)

The first and second derivative only require a 3–point stencil for 2nd–order accuracy. Since

all derivatives and their finite difference approximations are linear, the appropriate discrete

form of the biharmonic operator in Cartesian and polar coordinates can be obtained by

replacing the derivatives in Eq. 13 with their finite difference approximations in Eq. 22

through 25:

Apol = A4 +2

~rA3 +

−1

~r2A2 +

1

~r3A1 , (26)

where ~r is the discrete coordinate r (the powers are to be taken point–wise).1

As will be shown in the next section, boundary conditions generate constant additive2

contributions to the finite difference operator, which can be absorbed into the forcing3

vector; these contributions will be represented by the vector ~b.4

With the discrete solution vector ~w∗ and the discrete forcing vector ~f ∗ the discrete

one–dimensional approximation to Eq. 15 is

(D∗A + ∆ρ∗ I) ~w∗ =(~f ∗ − D∗~b

). (27)

14


This original PDE is now reduced to a linear system of equations that has to be solved by1

an appropriate method in order to obtain the (nondimensional) solution vector ~w∗ on the2

grid points ~x∗ or ~r∗.3

3.2 Boundary Conditions4

It has been shown in Section 2.2 that correct boundary conditions are crucial for the5

correctness of the solution. An improper treatment of boundary conditions in the finite6

difference approximation can render the solution worthless. Furthermore, as several con-7

figurations will be considered in this study the numerical treatment needs to be adaptable8

to different boundary conditions.9

In general for an nth–order PDE boundary conditions up to the (n− 1)th derivative can

be given; this is also the case here. In order to incorporate higher order derivatives into the

finite difference operator at the boundary, the following general point–form can be used

for up to 3rd–order boundary conditions:

(δxxxx)j±k = awj±1 + bwj±2 + cwj±3 + dwj±4 + ewj±5

+ αwj + β w′j + γ w′′j + δ w′′′j . (28)

The coefficients α through δ are associated with the boundary conditions. Positive signs in10

the indices apply for boundary to the left, and negative signs to a boundary the right. The11

scheme is analogous for the third derivative (δxxx); for the first (δx) and second derivative12

(δxx) a 3–point stencil can be used, and γ, δ, d, and e immediately vanish. Depending13

on how many conditions are available for the boundary under consideration, more or less14

points from the interior of the domain have to be used.4 j ± 4 is only used if no boundary15

conditions are given on this side (j ± 2 for a 3–point stencil).16

4Five data points are necessary to achieve 2nd–order accuracy for the third and fourth derivative, three

are necessary for the first and second derivative.

15


When a stencil is chosen (e.g. by the boundary conditions), the function w(xj) can be1

expanded into a Taylor–series about xj and the coefficients α-δ and a-e can be determined2

such that all terms of 2nd–order in ∆x = xj − xj−1 and below vanish. This amounts to3

solving a linear system of rank 5 for the third and fourth derivative, and rank 3 for the4

first and second derivative.5

Note that the value of wj and its derivatives at the boundary is known a priori, so that6

all terms in the second row of Eq. 28 are essentially constant (after the coefficients are7

determined), and can be stored in the vector ~b and treated as forcing terms in Eq. 27.8

The procedure is referred to as the Taylor–Table method (Lomax et al., 2003). It was9

also used to derive the linear operators given in Eq. 22-25, with α, .., δ = 0 and k = 3 (for10

the 5–point stencil; k = 2 for the 3–point stencil).11

3.3 Implementation with Python & SciPy12

The numerical method to solve equation Eq. 15 outlined in Section 3.1 was implemented13

in Python. The numerical packages Numpy and SciPy were used, as well as the plotting14

library Matplotlib for visualization.15

The main program (contained in the module lithosphere.py) consists of one primary16

class lithosphere, and two child–classes parameterTuning and parameterSpace. The pri-17

mary class performs the basic tasks of setting up the grid, the boundary conditions, and the18

forcing vector; it also constructs the discrete linear system and contains a method to solve19

the linear system. The two child classes perform more specialized tasks. parameterTuning20

is used to fit the solution to a target flexure profile by adjusting a tuneable parameter21

(D∗). parameterSpace on the other hand, contains methods to estimate certain properties22

of the solution, and store them, so that the solution can be characterized over a large range23

of parameters (the main purpose of the study).24

The Numpy array class was used to operate on large data vectors (such as the forcing ~f ∗25

16


or solution vector ~w∗). The finite difference operator D∗A + ∆ρ∗I was stored in a sparse–1

array class contained in the scipy.sparse–module. The system was then solved using2

an efficient direct (exact) solver method for sparse linear systems (available in the linear3

algebra submodule scipy.sparse.linalg).54

The parameter tuning procedure in the class parameterTuning was implemented using a5

minimization algorithm available in the scipy.optimize package of SciPy. For this purpose6

an error–function was defined as the mean–square difference of the current solution to the7

target, and the parameter D∗ was varied by the minimization algorithm so as to minimize8

the value of the error–function.9

The module finiteDifference.py contains the methods that were used to determine10

the coefficients of the finite difference operators described in Section 3.1 and 3.2, and11

construct the matrix operators. The coefficients of the finite difference operators are deter-12

mined at runtime for any given combination of boundary conditions (see Section 3.2).13

4 Numerical Experiments and Results14

The elastic bending model described in Section 3 was used to study the flexure of the15

lithosphere of the terrestrial planets Earth, Venus, and Mars, as well as the ice shell of16

Jupiters’s moon Europa. The parameter values used for these bodies are given in Tab. 1.17

First some simple examples will be discussed, before a larger parameter study will be18

presented.19

5I also implemented a Gauss–Seidel scheme to solve the linear system, but the direct sparse solver in

SciPy is orders of magnitude faster. This is not surprising as Python is an interpreted language and

SciPy (and Numpy) methods are implemented in C and Fortran, using highly optimized libraries. And

banded matrices are generally easy to solve exactly.

17


Parameter Earth Europa Venus Mars

Equatorial Radius R km 6378 1569* 6051* 3392

Surface Gravity g m s−2 9.81 1.314 8.87 3.72

Young’s Modulus E GPa 70 0.06 - 6 65 - 85* 100

Poisson’s Ratio ν 0.25 0.3 0.25 0.25

Mantle Density ρM kg m−3 3300 1186 3000 3500

Lithosphere Density ρL kg m−3 2800 1126 2500* 2800

Elastic Thickness h km 25 - 200 0.2 - 1.5 20 - 40 40 - 200

Table 1: Physical parameters used in this paper for Earth, Europa, Venus, and Mars.

The sources are: Turcotte and Schubert (2002) for Earth, Williams and Greeley (1998)

for Europa, Johnson and Sandwell (1994) for Venus, and Johnson et al. (2000) for Mars.

Values marked with an asterisk (*) are only estimated.

4.1 Some Simple Solutions1

For the purpose of model demonstration and in order to illustrate the broad characteristic2

of typical solutions, solutions for some simple scenarios were computed.3

In Fig. 1 (right) the lithosphere flexure for a bar or ring load scenario on Venus is4

displayed. Fixed boundary conditions were applied on the right and mirror boundary con-5

ditions on the left. The blue line represents the bar load scenario with a plane–parallel6

Cartesian geometry, the red line represents the axi–symmetric case with a ring load. This7

load scenario is motivated by the situation around coronae on Venus. The case displayed8

in Fig. 1 (right) vaguely resembles the Nishtigri Corona (Johnson and Sandwell , 1994,9

Fig. 6). The assumed effective elastic thickness of the lithosphere is hcart = 40 km in the10

plane–parallel case and hpol = 33.6 km in the axi–symmetric case; the load thickness is11

18


100 m with the same density as the lithosphere. The green dashed line is the applied load1

(shaped like a Gaussian), added on top of the lithosphere flexure (the axi–symmetric one),2

so that it represents the actual observed topography. An interesting point here is that the3

depth of the depression is in fact larger than the height of the topography anomaly causing4

it. This is because elastic forces are weak in this parameter regime and buoyancy forces5

contribute significantly; buoyancy forces however are relatively weak because the density6

contrast is not very large, so that the lithosphere has to sink significantly into the mantle7

to balance even a small load. The lithosphere itself is quasi–rigid, so that no buoyancy8

forces act within it. The load is centered at 250 km from the center, where the largest9

depression can be observed; in the center the lithosphere rises again, rendering the base of10

the depression almost level, with the decreasing load thickness.11

A similar effect can for example occur with very large impact craters: the excavated12

material forms a ring load and, if the radius is large enough (> 200 km) the lithosphere13

flexes downward and the rim sinks into the depression. In addition the center may rise even14

more because of the negative load due to the excavation.15

Figure 2 (left) shows a central load scenario, again in plane–parallel (blue) and axi–16

symmetric (red) geometry, on Jupiter’s moon Europa (boundary conditions same as above).17

This example is designed after Williams and Greeley (1998), Fig. 4. The load thickness is18

300 m, again shaped like a Gaussian. The assumed effective elastic thickness of the litho-19

sphere is hcart = 220 m in the plane–parallel case and hpol = 185 m in the axi–symmetric20

case. The topography was added in the same way as in Fig. 1 (right). Evidently a depression21

forms around the central load, as elastic forces distribute the load over a larger area. This22

effect can often be observed, also on terrestrial planets, only at significantly larger scales.23

The origin of the surface anomaly is, as with venusian coronae, uncertain. The topography24

and flexure in Williams and Greeley (1998) differs somewhat because they used a different25

load density (here the lithosphere value is used) and their load distribution represent actual26

19


topographical data (which is only close to a Gaussian).1

4.1.1 Fitting Observed Topography2

In both examples above, a plane–parallel solution in Cartesian coordinates as well as an axi–3

symmetric solution in polar coordinates was presented. The plane–parallel solutions have4

a different (larger) elastic thickness; the dashed red lines in Fig. 1 (right) and Fig. 2 (left)5

represent axi–symmetric solutions with the same effective elastic thickness as the plane–6

parallel solutions. The axi–symmetric solutions drawn with solid red lines demonstrate how7

a lithospheric flexure model can be fitted to observed topography (for example radar altime-8

try or seismological data) in order to estimate mechanical properties of the lithosphere: the9

plane–parallel flexure profile was taken as the target topography, and the axi–symmetric10

solution with the smallest mean square difference to the target profile was computed using11

the optimization method outlined in Section 3.3, with the flexural rigidity D as the ad-12

justable parameter. The new value of the effective elastic thickness h was then extracted13

from D. This form of inverse modelling is a common procedure to estimate geophysical14

parameters.15

Although these solutions are interesting in their own right, there are two more general16

points to mention. Firstly, both axi–symmetric solutions fitted to the Cartesian solutions17

produce a steeper slope and a deeper depression; at the same time the estimates for the18

effective elastic thickness are smaller. One may ask if this is always the case. Secondly,19

the solutions for both, Venus (Fig. 1, right) and Europa (Fig. 2, left) are qualitatively not20

very different; in fact one may reasonably argue that the qualitative differences can be21

attributed entirely to the different forcing scenarios. Both points will be addressed in the22

next section.23

20


4.2 Parameter Study1

The examples presented in the previous section motivate an investigation into the param-2

eter space of the elastic lithosphere model (defined by Eq. 15); two aspects are of interest:3

the difference between the axi–symmetric and the plane–parallel solution and the depen-4

dence on the two nondimensional parameter, the nondimensional flexural rigidity D∗ and5

the nondimensional buoyancy contrast ∆ρ∗, where D∗ is of particular interest because it6

depends on the length scale, as shown in Section 2.3.7

If all mechanical parameters (cf. Tab. 1) are assumed to be known, the nondimensional8

flexural rigidity D∗ can be regarded as a function of length scale D∗ ∼ 1X4 . In Fig. 2 (right)9

this relationship is plotted for Earth, Europa, Venus, and Mars. The solid lines are best10

estimates, and the dashed and dash-dotted lines of the same color are lower and upper11

bounds, respectively. The horizontal lines will be explained shortly.12

To study the dependence of the solution on the nondimensional flexural rigidity D∗13

(and thus on length scale) a series of experiments was conducted, where, for each set of14

parameters (each corresponding to a planet or moon) D∗ was varied from 10−7 to 103 in15

100 logarithmically spaced steps. The results are displayed for all four sets in Fig. 3 to 6.16

The load scenario in all experiments was a central Gaussian load of unit width and height.17

Fixed boundary conditions were applied on the right and mirror boundary conditions on18

the left. In the plane–parallel case this can be thought of as an elongated mountain or19

island chain, in the axisymmetric case it may be a central isolated mount, a volcanoe for20

example. Solutions for selected parameter values are displayed in the left panel of Fig. 321

to 6, along with the load distribution (black dashed line). Again solutions for Cartesian22

and polar geometry were computed (dashed and solid lines respectively).23

In order to characterize the solution over the displayed parameter space, two measures24

were introduced: the depression depth, which is defined as the vertical distance between25

21


the highest elevation and the lowest elevation (flexure), and the width of the depression,1

which is the distance from the highest elevation to the coordinate center (the origin). Both2

measures are displayed as a function of nondimensional flexural rigidity D∗ on the right3

panel of Fig. 3 to 6. The values for the nondimensional flexural rigidity D∗ for which4

solutions are displayed on the left panel are indicated by vertical lines on the right panel.5

The width of the depression is usually the entire domain width, unless buckling occurs6

(i.e. a rim forms around the depression). Buckling is a combined effect of buoyancy and7

elasticity; evidently it only occurs in the transition region between the buoyancy domi-8

nated regime (very small D∗) and the rigid regime (very large D∗). This is also the region9

where Cartesian (dashed) and axi–symmetric solutions (solid) differ the most, and where10

noticeable elastic effects occur. The horizontal lines in Fig. 2 (right) bound exactly this11

regime; the values are estimates taken from Fig. 3 to 6 (right panel), for each parameter12

set. Note that the buckling behavior undergoes an abrupt change around D∗ = 10−4; more13

of these abrupt changes occur, if the domain size is increase (i.e. the fixed boundary con-14

dition is removed farther from the central load). Essentially this is a boundary effect: if15

the domain size is large enough buckling can produce several crests and depressions (but16

usually only the first crest has an appreciable amplitude). The abrupt transition occurs17

when the number of crests and depressions in the solution changes. In an infinite domain18

this would occur continuously, but in a bounded domain this is not possible because one19

node must lie at the boundary.20

5 Discussion21

Two distinct limiting regimes can easily be identified. Between these regimes is a transition22

zone, where elastic and buoyancy forces interact. Quantitatively, these regimes are:23

D∗ < 10−5 The buoyancy dominated region. Elastic forces are weak and the load is24

22


Parameter Earth Europa Venus Mars

Flexural Rigidity D N m 6.2× 1024 6.9× 1016 3.7× 1023 1.5× 1025

Buoyancy Contrast ∆ρ g kg m−3 4905 92 4435* 2602

Topographic Length Scale

upper bound Lmax km 1540 50 840 2930

lower bound Lmin km 70 2 50 120

Scale Ratio Lmax/R ≈ 1/4 ≈ 1/51 ≈ 1/7 ≈ 7/8

Maximum Flexure w∗max 6.6 19.7 15.0 5.0

Nondimensional

Buoyancy Contrast ∆ρ∗ 0.15 0.05 0.07 0.2

Table 2: Typical values for flexural rigidity D and density contrast ∆ρ for Earth, Europa,

Venus, and Mars. The values were computed from Eq. 7 using the parameters given in

Tab. 1.

supported by hydrostatic forces (hydrostatic equilibrium).1

10−5 < D∗ < 1 The transition zone. Buoyancy and elastic forces are of comparable2

magnitude. elastic forces distribute load and buckling can occur (10−5D∗ < 10−1).63

1 < D∗ The rigid regime; elastic forces support the load and buoyancy forces have4

no significance locally. Lithosphere flexure is negligible.5

The functional dependence of the characteristic measures used to define these regimes6

(Fig. 3 to 6, right panel) is approximately the same for all parameter sets. The selected7

solutions plotted in Fig. 3 to 6 (left panel) are also qualitatively very similar. Only the8

6As the domain size increases this range extends towards smaller values of D∗.

23


absolute amplitude differs significantly; e.g. it varies by a factor of 4 between Mars and1

Europa. The reason for this difference is the nondimensional buoyancy contrast ∆ρ (which2

is exactly a factor 4 different). The product of the maximum absolute amplitude of flexure3

and the nondimensional buoyancy contrast is always constant (unity for unit forcing). This4

is because the maximum of the flexure amplitude is attained in the buoyancy dominated5

regime, where the vertical displacement (flexure) obviously scales inversely with the nondi-6

mensional buoyancy contrast ∆ρ∗. The solution in the transition regime appears to scale7

linearly with the density contrast, as long as nondimensional buoyancy contrast is small8

(∆ρ∗ ≈ 0.1). The rigid regime is of course unaffected by the density contrast. Another9

effect of the nondimensional buoyancy contrast is to shift the transition region to higher10

D∗ for increasing density contrast, but again, the shape of the solutions does not change.11

Since the dependence on nondimensional buoyancy contrast ∆ρ∗ is heuristically ex-12

plained, we can ignore it for a moment. Then there is only one parameter left, and simi-13

larity between the solutions in Fig. 3 to 6 can be established via the length scale. Length14

scales that correspond to the boundaries of the transition region are given in Tab. 2, as15

upper and lower bounds for the topographical length scale. The implication is that for a16

given value of D∗, solutions under vastly different conditions (parameter sets) are similar,17

provided the length scale is chosen appropriately. The ice–covered moon Europa exhibits18

the same types of elastically supported topography as the terrestrial planets, only at a19

much smaller length scale, due to the different mechanical properties of its icy shell. The20

form of the solution is dominated by the nondimensional flexural rigidity parameter D∗,21

but the regime transition is shifted slightly by the nondimensional buoyancy contrast ∆ρ.22

Whether an axi–symmetric (polar) or a plane–parallel (Cartesian) geometry is used,23

does not affect the location of the transition region, but the transition is more rapid in24

the axi–symmetric case. The axi–symmetric geometry consistently produces deeper depres-25

sions near the buoyancy dominated regime and smaller depressions near the rigid regime.26

24


Considering the solutions in Fig. 3 to 6, the axi–symmetric geometry seems to be more1

resistant to flexure in the elastically dominated range near the rigid regime. This behavior2

is very robust for all parameter sets; the two geometries are approximately equal for range3

of 10−3 < D∗ < 10−2, the shape of the solution, however, is slightly different, with the4

slope of the axi–symmetric solution being somewhat shallower. Buckling is generally more5

pronounced in Cartesian geometry; in the axi–symmetric case stresses are diverted radi-6

ally and distributed over a larger area. It is somewhat unexpected that the axi–symmetric7

solutions approach the buoyancy dominated limit faster on large length scale; naively one8

would expect the solutions to converge (monotonously) as the length scale is increased.9

5.1 The Length Scale of Topography10

It has already been noted that this parameter study permits some conclusions about the11

length scale of surface topography. Topography can generally be supported by two forces:12

elastic forces or buoyancy forces. For buoyancy forces to take effect a horizontal density13

inhomogeneity must be present. Elastic forces depend on the rigidity of the supporting14

layer (commonly called lithosphere). Here we use topography to refer to deviations from a15

spherical or ellipsoid surface. On short length scales, near the rigid regime, the lithosphere16

can support significant topography by elastic forces. The values given for the upper bound17

of the topographic length scale are a rough estimate of the maximum length scale that18

can be supported to some degree. Note however that strictly speaking this analysis does19

not constrain surface elevation anomalies, as the topographic length scale only refers to20

the horizontal scale, not the vertical of the load. It seems however empirically justified to21

assume that the vertical length scale is always significantly smaller than the horizontal22

(although the relationship may not be linear).23

On earth tectonic plates typically occur at a length scale larger than 1500 km, so that24

continental plates (and most mountain ranges for that matter) must be primarily supported25

25


by buoyancy forces (which is reasonable because there is a significant density contrast1

between the mantle and continental plates).2

The maximum topographic length scale for Europa is a mere 50 km, which indicates3

that no large–scale topography will be supported by its outer ice shell. In fact Luttrell4

and Sandwell (2006) show in a similar analysis that the largest significant length scale of5

europan topography is of the order of 10 km, consistent with the estimate presented here,6

given the uncertainties in the mechanical properties. There is the theoretical possibility7

that significant topography arises from density anomalies; this, however, does not seem to8

be the case for Europa.9

Venus is relatively close to Earth in parameter space, however Venus has no known10

tectonic activity, so that density anomalies must arise from other causes, possibly mantle11

plumes beneath coronae (Johnson and Sandwell , 1994).12

Mars is interesting because its lithosphere can apparently support topography at a very13

large scale; in fact at a planetary scale for Mars. And in fact strong deviations from the14

ellipsoid shape at a planetary scale can be observed on Mars (Turcotte et al., 2002). Another15

example where significant lithospheric bending occurs on Mars is flexure under the load of16

the polar caps (Johnson et al., 2000); the geometry of this situation is actually very close17

to the central load problem in polar coordinates studied in Section 4.18

The lower bound for topographical length scale given in Tab. 2 is the length scale below19

which no flexure of the lithosphere can be expected and topography is entirely supported20

by a rigid plate. Table 2 also lists the maximum length scale as a ratio of planetary radius.21

This number gives an indication as to how much deviation from a perfect sphere or ellipsoid22

( in hydrostatic equilibrium) can be expected on a planet or moon. For Earth and Venus23

the topographic length scale is a significant fraction of the planetary radius, so that some24

deviations can be expected. On Mars large deviations are to be expected (and do occur),25

since the ratio is very close to unity. Only Europa is radically different: the ratio of topo-26

26


graphic length scale to planetary radius is very small, so that deviations from hydrostatic1

equilibrium will also be very small. Since the moon is subject to strong tidal forcing and2

mixing, horizontal density anomalies were probably removed by differentiation (over long3

time scales). This analysis suggests that the reason for Europas apparent smoothness may4

be that its ice shell can not support significant deviations from hydrostatic equilibrium.5

5.2 Some Caveats6

There are of course some caveats to the parameter study presented here. First of all, the7

error margins for the parameter values given in Tab. 1 are fairly large. Parameters for Venus8

an Europa are estimates at best; Mars and in particular Earth are much better constraint9

by observations, but even then, the parameter values used can at best be effective mean10

values, because of the large spatial inhomogeneity, in particular on Earth. There is for11

example a strong contrast between oceanic and continental lithosphere. The mechanical12

parameters used for Europas ice shell are in fact values for sea ice, but for lack of a better13

estimate, this is the common approach.14

Fortunately the nondimensional flexural rigidity parameter is linear in most parameters,15

so that uncertainties which are not larger than an order of magnitude, do not affect the16

conclusions presented above. The largest sensitivity is in the effective elastic thickness,17

because the nondimensional flexural rigidity is a cubic function in this parameter (D∗ ∼ h3).18

Unfortunately this is also one of the most uncertain parameters. In fact it is frequently19

estimated using exactly the inverse modelling approach presented in Section 4.1.1 (Johnson20

and Sandwell , 1994; Williams and Greeley , 1998). This make the use of this parameter here21

somewhat questionable. However the aim of this study is not predict the topographic length22

scale a priori, but merely to contextualize and explain the observed topography on several23

terrestrial planets and a moon in terms of a physical model. In particular for Venus and24

Europa the uncertainties in the effective elastic thickness approach an order of magnitude.25

27


6 Summary1

The bending of the lithosphere under typical load scenarios was modeled numerically, using2

an elastic flexure model for the lithosphere. The model is based on Kirchhoff’s Thin Plate3

Theory of elastic plate bending with the addition of a buoyancy term. The model was4

written in Python using the Numpy– and SciPy–packages. First the governing PDE was5

discretized to obtain a linear system of equations, then the linear system was solved using6

an efficient direct solver for sparse matrices, available in the SciPy–package. Although the7

lithospheric flexure model is in principle two dimensional, only one–dimensional versions8

for plane–parallel and the axi–symmetric cases were implemented.9

To facilitate the analysis, the governing PDE was nondimensionalized, so that only two10

parameters remained: the nondimensional flexural rigidity D∗ and the nondimensional11

buoyancy contrast ∆ρ. An important observation is that D∗ is a function of length scale:12

D∗ ∼ L−4. In fact length scale is the dominant factor in D∗, along with h (which is cubic,13

D∗ ∼ h3); all other parameters are linear.14

For illustration purpose some solutions for Venus and Europa were presented; further-15

more a standard inverse modelling procedure was demonstrated that allows the estimation16

of mechanical parameters (here h) by fitting a flexure solution to observed topography17

profiles.18

The main objective of this study was to investigate the dependence of the lithospheric19

flexure on the values of nondimensional parameters; D∗ was of primary interest because20

it depends on the length scale. To this end a large number of experiments with different21

values for D∗ were conducted (flexure under a central Gaussian load); the parameter space22

was probed from D∗ = 10−7 to D∗ = 103, with values for ∆ρ given in Tab. 2 (along with23

some other results). It was found that the amplitude of the flexure scales linearly with the24

nondimensional buoyancy contrast, but otherwise the form of the solution only depends on25

28


D∗. The parameter space can be divided into two limiting regimes and a transition zone:1

the buoyancy dominated regime where elastic forces are negligible (D∗ < 10−5), and the2

rigid regime, where elastic forces prevent any appreciable lithospheric flexure (D∗ > 1).3

The transition zone is the most interesting, as this is the region where lithospheric flexure4

supports, but also changes, the topography.5

For a given set of parameters the values for D∗ directly translate into a length scale,6

permitting an estimate of the scale of topography that can be supported by the litho-7

sphere. The upper bound for the topographic length scale corresponds the boundary of the8

buoyancy dominated regime.9

The analysis was conducted for the plane–parallel case, as well as the axi–symmetric10

case. The conclusions given here apply equally to both geometries. It is interesting to11

note that the axisymmetric solutions are more rigid (less flexure) for smaller length scales12

(larger D∗), but deviate from the Cartesian solutions in the opposite direction on large13

length scales (small D∗), close to the buoyancy dominated regime. This is surprising as one14

would expect generally good agreement on larger length scales.15

Typical values of the topographical length scale for Earth, Europa, Venus, and Mars16

are given in Tab. 2. The most important result is that the same topographical flexure17

characteristics (same value of D∗) can be associated with vastly different length scales, in18

particular on Europa.19

On Earth and Venus the topographic length scale is smaller, but still a significant fraction20

of the planetary radius. Deviations from hydrostatic equilibrium on a planetary scale are21

small, but detectable; it is large enough to play a significant role in plate tectonics on22

earth. On Mars the topographic length scale is very close to the planetary radius, which23

would allow significant deviations from hydrostatic equilibrium on a planetary scale. This is24

observed, for example, as large scale lithospheric flexure under the load of the polar caps.25

Europa represents a sharp contrast to the three terrestrial planets: its ice shell is much26

29


weaker and thus supports much less topography. In fact Europa’s topographic length scale1

is of the order of 50 km, which is only about 2% of its radius. The fact that Europa’s2

ice shell can only support very small deviations from hydrostatic equilibrium, could be a3

possible explanation for its apparent smoothness on large scales.4

References5

Felippa, C. A. (2009), Asen 6367 – advanced finite elements for solids, plates and shells6

(lecture notes), chapter 24, Kirchhoff Plates: Field equations.7

Johnson, C. L., and D. T. Sandwell (1994), Lithospheric flexure on venus, Geophys. J. Int.,8

119 (2), 627–647.9

Johnson, C. L., S. C. Solomon, J. W. Head, R. J. Phillips, D. E. Smith, and M. T. Zuber10

(2000), Lithospheric loading by the northern polar cap on mars, Icarus, 144 (2), 313–328.11

Lomax, H., T. H. Pulliam, and D. W. Zingg (2003), Fundamentals of Computational Fluid12

Dynamics, Scientific Computation, 1st ed., Springer.13

Luttrell, K., and D. Sandwell (2006), Strength of the lithosphere of the galilean satellites,14

Icarus, 183 (1), 159–167, doi:10.1016/J.Icarus.2006.01.015.15

Turcotte, D. L., and G. Schubert (2002), Geodynamics, 2nd ed., Cambridge University16

Press.17

Turcotte, D. L., D. C. Mcadoo, and J. G. Caldwell (1978), Elastic–perfectly plastic analysis18

of bending of lithosphere at a trench, Tectonophysics, 47, 193–205.19

Turcotte, D. L., R. Shcherbakov, B. D. Malamud, and A. B. Kucinskas (2002), Is the20

30


martian crust also the martian elastic lithosphere?, J. Geophys. Res. – Planets, 107 (E11),1

–, doi:10.1029/2001je001594.2

Weisstein, E. W. (2009), Biharmonic equation, MathWorld – A Wolfram Web Resource.3

Williams, K. K., and R. Greeley (1998), Estimates of ice thickness in the conamara chaos4

region of europa, Geophys. Res. Lett., 25 (23), 4273–4276.5

Source Code6

The program “lithosphere’ (source code below) is released under the GNU General Public7

License (GPL). Author: Andre R. Erler (2009). The license text can be obtained at http:8

//www.gnu.org/licenses/gpl.html .9

Model Scripts10

Main Class (lithosphere.py)11

,12

#!/usr/bin/env python13

# Main Class Module for Planetary Physics Project14

# Created on Nov. 30, 200915

# Author: Andre R. Erler16

17

# some stuff I need18

from matplotlib.pylab import figure19

from numpy import arange , array , zeros_like , ones_like , pi , sin , exp ,20

mean , amin , amax , argmax21

from scipy.optimize import fmin , fmin_powell , fmin_cg , fmin_bfgs22

from scipy.sparse import eye , dia_matrix23

from scipy.sparse.linalg import spsolve , bicg , bicgstab , cg , cgs24

# my own library25

from finiteDifference import *26

27

class Lithosphere(object):28

# This is the main Class of my project; it managed representation and29

integration30

31

31


def __init__(self , (xmin ,xmax)=(0. ,1.), M=1000 , c4=1., c0=1., BCs=’1

periodic ’, geometry=’cartesian ’):2

# read parameters3

self.M = M # internal grid points4

self.c4 = c4 # thickness parameter , coefficient for 4th5

derivative6

self.c0 = c0 # buoyancy contrast , coefficient for first7

derivative8

# boundary conditions9

self.BCs = BCs10

# geometry11

self.geometry = geometry12

# periodic grid13

if BCs == ’periodic ’:14

self.dx = (xmax -xmin)/(M) # horizontal grid spacing15

self.x = arange(xmin+self.dx , xmax+self.dx , self.dx) # x16

vector17

else:18

self.dx = (xmax -xmin)/(M+1) # horizontal grid spacing19

self.x = arange(xmin+self.dx , xmax -self.dx/10, self.dx) # x20

vector21

# allocate with zero initial conditions22

self.w = zeros_like(self.x) # u vector23

self.s = [] # list to store results ...24

25

def forcing(self , h0=1., x0=0., l=1., type = ’’):26

# construct sinusodial forcing vector (ideally from function27

handle)28

self.h0 = h0 # forcing amplitude29

self.l = l # forcing length -scale/wavelength30

# forcing vector31

if type == ’sinusodial ’: self.f = h0*sin (2.*pi*(self.x-x0)/l)32

elif type == ’gaussMount ’: self.f = h0*exp(-((self.x-x0)/l)**2)33

elif type == ’constant ’: self.f = h0*ones_like(self.x)34

elif type == ’pointLoad ’: self.f = zeros_like(self.x); self.f[int35

(self.M*x0/(max(self.x)-min(self.x)))] = h036

#else: self.f = zeros_like(self.x)37

return (self.x,self.f)38

39

def discretize(self , operator=’biharmonic ’):40

# discretize governing equation on given grid and apply forcing41

# governing equation: c4*d4/dx4_w + c0*w = f42

# dg = degree of derivative , hwd = half stencil width43

if operator ==’biharmonic ’: dg=4; hwd=244

if operator ==’laplacian ’: dg=2; hwd=145

BCs = self.BCs46

32


M = self.M1

dx4 = self.dx**dg # (delta x)^42

# configure boundary conditions for 4th derivative3

if BCs == ’periodic ’: l = None; r = None # no BCs4

if BCs == ’freePlate ’: l = [[0.] ,[] ,[0.]]; r = [[0.] ,[] ,[0.]]5

# common right -hand side6

if BCs==’plane’ or BCs [0:4]== ’left’: r = [[0.] ,[0.]] # infinity7

# common left -hand side8

if BCs==’plane’ or BCs [0:5]== ’right’: l = [[0.] ,[0.]] # infinity9

# left -hand sides10

if BCs == ’leftNone ’: l = [[] ,[] ,[] ,[]]11

if BCs == ’leftFree ’: l = [[] ,[] ,[0.] ,[0.]]12

if BCs == ’leftDepression ’: l = [[] ,[0.] ,[] ,[0.]]13

# construct bi -harmonic operator14

if self.geometry == ’cartesian ’:15

s =(range(-hwd ,hwd+1) ,) # stencil for 2nd order accuracy , 4th16

order derivative17

(A4,b4) = FDoperator(dg, M, s, l, r)18

if self.geometry == ’polar’:19

s =(range(-hwd ,hwd+1) ,) # stencil for 2nd order accuracy , 4th20

order derivative21

rinv = self.dx*dia_matrix ((1./ self.x,array ([0 ,])), shape=(M,M22

)) # self.dx*23

if dg==2: abc = [1.,] # coefficients for 2nd , 3rd , and 4th24

derivative (1st is 1)25

else: abc = [-1., 2., 1.] # coefficients for 2nd , 3rd , and 426

th derivative (1st is 1)27

s =(range (-1,2) ,) # stencil for 2nd order accuracy , 1st order28

derivative29

(A4,b4) = FDoperator (1, M, s, l, r)30

for n in range(2,dg+1):31

A4 = rinv*A4; b4 = rinv*b432

s =(range(-n/2,(n+1) /2+1) ,) # stencil for 2nd order33

accuracy , nth order derivative34

(Ar,br) = FDoperator(n, M, s, l, r)35

A4 = A4 + abc[n-2]*Ar; b4 = b4 + abc[n-2]*br36

# Note: the construction of the operator could be formulated in a37

much more general form , unifying38

# euclidean and polar case and transferring everything into the39

coefficients , however , for40

# polar geometry this less general implementation appears to be41

much more efficient.42

# The code could easily be adapted to a general arbitrary -order43

discretization algorithm.44

# 0th derivative (buoyancy term)45

A0 = bandedMatrix (((1 ,) ,), M)46

33


# save operators and constants for later use1

self.dx4 = dx42

self.A4 = A43

self.A0 = A04

self.b4 = b45

# construct linear operator6

self.A = A4 + (dx4/self.c4)*self.c0*A07

# forcing vector (conditioned)8

self.b = b4 -(dx4/self.c4)*self.f9

# return operators10

return (self.A,self.b)11

12

def iterate(self , method = ’bicgstab ’):13

# solve linear system iteratively , using scipy sparse array14

solvers15

# bicg , bicgstab , cg , cgs16

if method == ’test’: w = (self.A*self.f, 0.)17

if method == ’mySOR’: w = (SOR(self.A,self.b), 0.) # my own18

implementation of the SOR scheme in Python19

if method == ’bicg’: w = bicg(self.A, self.b) # use biconjugate20

gradient21

if method == ’bicgstab ’: w = bicgstab(self.A, self.b) # use22

biconjugate gradient (stabilized)23

if method == ’cg’: w = cg(self.A, self.b) # use conjugate24

gradient25

if method == ’cgs’: w = cgs(self.A, self.b) # use conjugate26

gradient squared27

self.w = w[0] # only first component (don’t know what rest is...)28

# return solution29

return (self.x,self.w)30

31

def store(self):32

# store current solution in buffer ’s’33

self.s.append(self.w.copy())34

# return solution35

return (self.x,self.s[-1])36

37

def reset(self):38

# reset history/stored values39

self.s = []40

41

def direct(self):42

# solve linear system directly , using scipy sparse array solvers43

(fastest method)44

self.w = spsolve(self.A,self.b)45

# return solution46

34


return (self.x,self.w)1

2

def periodicPlate(self):3

# exact solution for 1D plate bending under periodic load ...4

comp = (self.c0 + self.c4 *(2.*pi/self.l)**4.) # compensation5

factor6

self.e = -1.*self.f/comp7

return (self.x,self.e)8

9

def plot(self , fig=0, ax=0, tag=’’, ls=’’, name=’’, multi =(1,1,1),10

scale =1.):11

# plot solution12

tag = tag or self.tag or ’_nolegend_ ’13

if tag == ’initialize ’:14

if not fig:15

fig = figure(figsize =(8,8)) # create figure16

fig.ax = [] # initialize axes list17

if ax:18

fig.ax = ax19

else:20

ax = fig.add_subplot(multi[0], multi[1], multi [2]) # create21

axes22

fig.ax.append(ax)23

# annotate24

ax.set_title(name)25

ax.set_xlabel(’x’); ax.set_ylabel(’w’)26

else:27

# use existing (passed) axes or create new subplot28

if not ax:29

ax = fig.add_subplot(multi[0], multi[1], multi [2])30

fig.ax.append(ax)31

(x,w) = self.plotOptions(tag , scale)32

# plot u vs. x33

tag = name or tag34

if ls: ax.plot(x, w, ls , label=tag) # using line styles35

else: ax.plot(x, w, label=tag) # with automatic color36

return (fig ,ax)37

38

def plotOptions(self , tag , scale):39

# handle special annotation functions40

if tag == ’periodicPlate ’: w = self.e/scale; x = self.x41

elif tag == ’topography ’: w = self.f/scale + self.w; x = self.x42

elif tag == ’direct ’: w = self.w/scale; x = self.x43

elif tag == ’forceScale ’: w = self.f*(max(self.w) - min(self.w))44

/(max(self.f) - min(self.f))/scale; x = self.x45

elif tag == ’forcing ’: w = self.f/scale; x = self.x46

35


else: w = self.w; x = self.x1

return (x,w)2

3

4

class parameterTuning(Lithosphere):5

# a class that also handles parameter estimation6

7

def __init__(self , (x,w), c4=1., c0=1., BCs=’periodic ’, geometry=’8

cartesian ’):9

# infer grid structure from target values10

M = x.shape [0]11

xmin = 2*x[0] - x[1];12

if BCs==’periodic ’: xmax = x[-1]13

else: xmax = 2*x[-1] - x[-2]14

# initialize15

Lithosphere.__init__(self , (xmin ,xmax), M, c4, c0, BCs , geometry)16

# save target vector (grid is the same)17

self.t = w18

# history of change19

self.c = []20

21

def reset(self):22


Lithosphere.reset(self)24

self.c = []25

26

def setParam(self , adjPar , c, store=True):27

# set new parameter value and recompute finite difference28

operators29

if adjPar == ’c4’:30

# recompute linear operator31

self.A = self.A4 + (self.dx4/c)*self.c0*self.A032

# recompute forcing vector (conditioned)33

self.b = self.b4 -(self.dx4/c)*self.f34

if adjPar == ’c0’:35

# recompute linear operator36

self.A = self.A4 + (self.dx4/self.c4)*c*self.A037

if adjPar == ’forcing ’:38

# call this function after calling self.forcing ()39

# recompute conditioned forcing vector40

self.b = self.b4 -(self.dx4/c)*self.f41

if adjPar == ’geometry ’:42

self.geometry = c43

# recompute discretization (essentially everything)44

self.discretize ()45

if adjPar == ’BCs’:46

36


self.BCs = c1

# recompute discretization (essentially everything)2

self.discretize ()3

# save history of change4

if store: self.c.append(c)5

6

def errFct(self):7

# measure for deviation of current solution from target8

delta = self.t - self.w9

return dot(delta ,delta.conj())/self.M10

11

def evaluate(self , adjPar , c):12

# update parameters13

self.setParam(adjPar , c)14

# evaluate system15

self.direct ()16

# compute error fucntion17

return self.errFct ()18

19

def adjustParameter(self , adjPar , c0 , method=’sim’):20

# use optimization algorithm to find value of parameter ’adjPar ’,21

using first guess c022

self.adjPar = adjPar23

f = lambda c: self.evaluate(adjPar ,c[0]) # function to minimize24

# minimize using scipy optimization package25

if method ==’sim’: cOpt = fmin(f,c0)26

if method ==’bfgs’: cOpt = fmin_bfgs(f,c0)27

if method ==’powell ’: cOpt = fmin_powell(f,c0)28

if method ==’cg’: cOpt = fmin_cg(f,c0)29

# return estimate30

return cOpt31

32



if tag == ’firstGuess ’: w = self.s[0]/ scale; x = self.x35

elif tag == ’topography ’: w = self.f/scale + self.w; x = self.x36

elif tag == ’target ’: w = self.t/scale; x = self.x37

elif tag == ’forceScale ’: w = self.f*(max(self.w) - min(self.w))38

/(max(self.f) - min(self.f))/scale; x = self.x39

elif tag == ’forcing ’: w = self.f/scale; x = self.x40

else: w = self.w; x = self.x41

return (x,w)42

43

class parameterSpace(parameterTuning):44

# a class to probe the parameter space of c4 and c045

46

37


def __init__(self , (xmin ,xmax)=(0. ,1.), M=1000 , c4=1., c0=1., BCs=’1

periodic ’, geometry=’cartesian ’):2

# initialize3

Lithosphere.__init__(self , (xmin ,xmax), M, c4, c0, BCs , geometry)4

# initialize lists of measure estimates5

self.depth = []6

self.width = []7

# save parameter history8

self.c = []9

10

def measure(self , measure):11

if measure == ’depression ’:12

# estimate depth and width of depression defined from the13

lowest depression to the highest rim (buckling)14

depth = amax(self.w) - amin(self.w) # estimate depth15

width = self.x[argmax(self.w)] # estimate width16

# add estimates to internal list17

self.depth.append(depth)18

self.width.append(width)19

m = (depth , width)20

# return estimates21

return m22

23

def reset(self):24


parameterTuning.reset(self)26

self.depth = []27

self.width = []28

29



if tag == ’depth’: w = array(self.depth)/scale; x = self.c32

elif tag == ’width’: w = array(self.width)/scale; x = self.c33

else: (x,w) = Lithosphere.plotOptions(self , tag , scale)34

return (x,w)35

36

def plot(self , fig=0, ax=0, tag=’’, ls=’’, name=’’, multi =(1,1,1),37

scale =1.):38

(fig , ax) = Lithosphere.plot(self , fig , ax, tag , ls, name , multi ,39

scale)40

if tag == ’depth’ or tag == ’width’: ax.set_xscale(’log’)41

return (fig , ax)42

Finite Difference Routines (finiteDifference.py)43

,44

38



# some utility functions to construct finite difference schemes2



5


from numpy import arange , zeros , zeros_like , sqrt , dot , int167

from scipy.sparse import eye8

from scipy.linalg import solve9

10

def countElt(list , d=1):11

# helper function to count elements in uniform nested list to depth d12

n = 0 # initialize13

for i in range(len(list)):14

if d:15

nn = countElt(list[i], d-1) # recurse into nested list16

n = n + nn17

else:18

n = n + 1 # terminate recursion19

return n20

21

def FDoperator(dg , M, k, l=None , r=None):22

# construct finite difference operator of dimension M23

# for derivative of order dg with boundary conditions l, r24

# k contains the inner stencil , boundary operators are25

# generated automatically (one order lower), default: periodic26

# special treatment for periodic case27

if l==None or r==None:28

b = matrixCoeff(k,dg)29

A = bandedMatrix(b, M)30

A = circulantMatrix(b, A)31

b = zeros(M)32

else:33

b = zeros(M) # allocate34

# internal operator35

A = bandedMatrix(matrixCoeff(k,dg), M)36

# implement boundary conditions37

bdpts = (len(k[0]) -1)/2 # number of points that extend beyond the38

domain39

# left -hand side40

for n in range(bdpts):41

l = l[0:dg] # trim42

# construct stencil43

t = len(l[0]); # count ghost cells44

if t > 1: print(’Warning: use of multiple ghost cells is 45

discouraged ’)46

39


stencil = [range(-t-n,bdpts +1) ,] # base stencil1

i = 1 # now add boundary conditions to constrain derivative (2

as available)3

while i<len(l) and (dg+1)>countElt(stencil ,1):4

t = len(l[i]); # include higher derivatives5

if t > 1: print(’Warning: too many von Neuman BCs’)6

stencil.append ([-1,]*t)7

i = i + 18

# for i in range(1,len(l)):9

# t = len(l[i]); # treatment of higher derivatives10

# if t > 1: print(’Warning: too many von Neuman BCs ’)11

# stencil.append ([-1,]*t)12

# if BC’s are not enough to constrain derivative , add more13

points14

while (dg+1)>countElt(stencil ,1):15

stencil [0]. append(stencil [0][ -1]+1) # extend stencil if16

constraints missing17

(A,b) = boundaryRow(matrixCoeff(stencil , dg), l, n, A, b)18

# right -hand side19

for n in range(bdpts):20

r = r[0:dg] # trim21

# construct stencil22

t = len(r[0]);23

if t > 1: print(’Warning: use of multiple ghost cells is 24

discouraged ’)25

stencil = [range(-bdpts ,t+1+n),] # base stencil26

i = 1 # for i in range(1,len(r)):27

while i<len(r) and (dg+1)>countElt(stencil ,1):28

t = len(r[i]); # treatment of higher derivatives29

if t > 1: print(’Warning: too many von Neuman BCs’)30

stencil.append ([1 ,]*t)31

i = i + 132

while (dg+1)>countElt(stencil ,1):33

stencil [0]. insert(0,stencil [0][0] -1) # extend stencil if34

constraints missing35

(A,b) = boundaryRow(matrixCoeff(stencil , dg), r, -1-n, A, b)36

# note special use of ’b’ in periodic case: coefficients37

return (A,b)38

39

def matrixCoeff(k, n):40

# compute coefficients for finite difference approximation to the n-41

th derivative42

# with highest order of accuracy possible for a given stencil k43

# k contains the indices of all stencil points relative to the44

evaluated point45

# total number of elements in nested list k46

40


M = 01

for i in range(len(k)): M += len(k[i])2

# construct matrix3

A = zeros ((M,M)); mos = 0 # offset in row index4

for m in range(len(k)): # order of derivative loop5

f = 0.6

for i in range(M-m): # stencil loop7

f = i*f or 1.8

for j in range(len(k[m])):9

A[i+m,j+mos] = k[m][j]**(i)/f10

mos += len(k[m])11

# construct "forcing", i.e. desired derivative12

d = zeros ((M,));13

d[n] = 1.14

# solve linear system ‘15

c = solve(A,d)16

# return coefficients c in nested list , ordered like k17

l = []; j = -118

for m in range(len(k)):19

l.append ([])20

for i in range(len(k[m])):21

j += 1; l[m]. append(c[j])22

return l23

24

def bandedMatrix(b, M):25

# construct banded sparse matrix of dimension (M,M) from diagonals in26

list b27

# the center value b[n/2] is interpreted as the main diagonal28

# and adjacent entries as the respective off -diagonals29

b = b[0] # use only first part30

n2 = len(b)/231

# main diagonal32

A = b[n2]*eye(M,M,0)33

# off -diagonals34

for i in range(0,n2):35

A = A + b[i]*eye(M,M,i-n2) + b[-1-i]*eye(M,M,n2-i) # two at a36

time ...37

A = A.tolil ()38

return A39

40

def boundaryRow(c, bd , n, A, b):41

# implement boundary values and coefficients of boundary scheme (c)42

into n-th row43

# of finite differencing matrix A and forcing vector b.44

# c is assumed to be centered , and boundary values follow same format45

as c (including higher derivatives)46

41


M = A.shape [0]1

bnd = len(bd[0])2

if n < 0: n = M + n3

if n < M/2: # left boundary4

for j in range(bnd ,len(c[0])): A[n,j-bnd] = c[0][j]5

for m in range(len(c)):6

for j in range(len(bd[m])): b[n] = b[n] - bd[m][j]*c[m][j]7

else: # right boundary8

os = M - (len(c[0])-bnd)9

for j in range(len(c[0])-bnd): A[n,os+j] = c[0][j]10

for m in range(len(c)):11

os = len(c[m]) - len(bd[m])12

for j in range(len(bd[m])): b[n] = b[n] - bd[m][j]*c[m][os+j]13

return A, b14

15

def circulantMatrix(b, C):16

# returns/add the outer diagonals of a circulant matrix; add to17

bandedMatrix A or create new18

M = C.shape [0]19

n2 = len(b)/220

# outer diagonals21

for i in range(0,n2):22

C = C + b[i]*eye(M,M,n2-M-i) + b[i]*eye(M,M,M-n2+i) # two at a23

time ...24

return C25

26

def SOR(A,b, dg=2, precision =1e-6):27

# solve a linear system given by A*x=b using the SOR scheme28

M = A.shape [0]29

# prepare linear system for iterative process30

C = A.copy(); d = b.copy()31

for i in range(M):32

c = - C[i,i]33

for j in range(M):34

C[i,j] = C[i,j]/c35

d[i] = d[i]/c36

C[i,i] = 0.37

# implement scheme38

x = zeros(M); l2o=1.e20; l2n=1.e10 # solution vector39

# iterate scheme40

n = 041

while abs(1-l2o/l2n)>precision:42

#for n in range (100):43

stencil = arange (2*dg+1, dtype=int16)44

for i in range(dg+1):45

x[i] = C[i,stencil ]*x[stencil] + b[i] # left boundary46

42


# Note: one normal iteration is included in left boundary loop1

for i in range(dg+1,M-dg):2

stencil = stencil + 1 # advance stencil3

x[i] = C[i,stencil ]*x[stencil] + b[i] # iterate system4

for i in range(M-dg ,M):5

x[i] = C[i,stencil ]*x[stencil] + b[i] # right boundary6

l2o = l2n; l2n = sqrt(dot(x,x.conj())) # compute norm7

n += 18

if not n%100: print l2n -l2o9

# return solution x10

return x11

Scripts for Parameter Study12

D∗ and Length Scale (someParameters.py)13

,14


# Parameter Values for Planetary Physics Project16

# Created on Dec. 10, 200917


19

from numpy import array , logspace20

from matplotlib.pylab import figure , loglog , title , xlabel , ylabel , axis ,21

legend , savefig , show , axhline22

23

# plot parameter24

write = True25

folder = ’/home/me/Courses/Planetary Physics/Project/Figures/’ # Figure26

folder27

file = ’dimlessDEarthEuropa.eps’28

figure(figsize =(8 ,8))29

30

# Values of dimensionless Flexural Rigidity and Buoyancy Parameter for31

some Planets32

print(’Values of some Dimensionless Flexural Rigidity and Buoyancy 33

Parameter for some Planets ’)34

l = logspace (2. ,8. ,100); l4 = (l)**435

ls = [’--’,’-’,’-.’] # line --styles for lower bound , best estimate , and36

upper bound37

38

# Earth ’s lithosphere:39

# constant parameters40

g = 9.81 # gravity41

E = 70.e9 # Young ’s modulus42

43


v = 0.25 # Poisson ’s ratio1

rhoM = 3.3e3 # density of mantle2

rhoC = 2.8e3 # density of crust3

# varying parameters4

h = array ([25. , 100., 250.]) *1.e3 # elastic thickness [km]5

# flexural parameter (array)6

D = E*h**3/(1. -v**2) /12.7

drho = 1.-rhoC/rhoM8

# plot9

color = ’g’ # green for earth10

Dscale = array ([4.e-5, 1.e1]) # range of realistic DD11

lenSc = (D[1]/g/rhoC/Dscale)**(1./4.) # range of topographic length scale12

for i in range(len(D)):13

# Non -dimensionalize14

DD = D[i]/g/rhoC/l415

label=’Earth , h=%3.0 fkm’%(h[i]/1e3)16

loglog(l/1.e3 ,DD ,ls[i]+color , label=label)17

axhline(y=Dscale [0], color=color); axhline(y=Dscale [1], color=color) #18

add a horizontal line marking the interesting region19

# print20

print(’’)21

print(’Earth:’)22

print(’ Topographic Length -scale: %3.2e km - %3.2e km’%(lenSc [0]/1.e3,23

lenSc [1]/1. e3))24

print(’ Flexural Parameter D: %3.2e, %3.2e, %3.2e’%(D[0],D[1],D[2]))25

print(’ Buoyancy Parameter delta -rho: %3.2e’%drho)26

27

# Europa ’s ice shell28

g = 1.314 # gravity29





E = array ([6.e7, 6.e9, 6.e9]) # Young ’s modulus34

h = array ([250. , 500., 1500.]) # elastic thickness [km]35

# flexural parameter36

D = E*h**3/(1. -v**2) /12.37


color = ’b’ # blue for europa39





DD = D[i]/g/rhoC/l4#/1.e944

if E[i] == 6.e7: label = ’Europa , E=%2.0 fMPa’%(E[i]/1.e6)45

else: label = ’Europa , h=%4.0fm’%(h[i])46

44





# print4

print(’’)5

print(’Europa:’)6


lenSc [1]/1. e3))8



11

# Venus ’ lithosphere:12




rhoM = 3.e3 # density of mantle16



E = array ([65.e9, 65.e9, 85.e9]) # Young ’s modulus19



D = E*h**3/(1. -v**2) /12.22


# plot24

color = ’y’ # green for earth25






if E[i] == 65.e9: label = ’Venus , h=%3.0 fkm’%(h[i]/1e3)31

else: label = ’Venus , E=%2.0 fGPa’%(E[i]/1.e9)32




# print36

print(’’)37

print(’Venus:’)38


lenSc [1]/1. e3))40



43

# Mars’ lithosphere:44



45









D = E*h**3/(1. -v**2) /12.8


# plot10

color = ’r’ # green for earth11

Dscale = array ([2.e-5, 8.e0]) # range of topographic length scale12

lenSc = (D[1]/g/rhoC/Dscale)**(1./4.)13




label=’Mars , h=%3.0 fkm’%(h[i]/1e3)17




# print21

print(’’)22

print(’Mars:’)23


lenSc [1]/1. e3))25



28

29

# customize plot30

title(’Non -dimensional D* as a function of length -scale ’)31

ylabel(’Non -dimensional Flexural Rigidity D*’)32

xlabel(’Length -scale [km]’)33

axis ([1e-1, 1e6 , 1e-8, 1e4])34

# display35

legend(loc=’upper right’)36

# print37

if write: savefig(folder+file , dpi=300, papertype=’letter ’,format=’eps’)38

show()39

Parameter Study (c4scaleLeftMount.py)40

,41


# Parameter Study for Planetary Physics Project43

46


# Created on Dec. 10, 20091


3

# Explore parameter space in direction of dimensionless Flexural Rigidity4

D*5

6


from matplotlib.pylab import show8

from numpy import logspace , array , amax9

from time import time10

# my own module11

from lithosphere import parameterSpace12

13

# switches14

parameter = ’Earth ’15

scenario = ’Center ’16

17

tag = parameter18

# Earth parameters19

if tag == ’Earth’:20

c0 = 1.515152e-0121

c4rng = [-7.,3.]22

plotList = [6.e-7, 9.e-5, 1.e-3, 4.e-2, 2.e2] # list of values at23

which solution will be plotted24

depthScale = 1.25

26

# Europa parameters27

if tag == ’Europa ’:28

c0 = 5.059022e-0229



c4rng = [-7.,3.]32

depthScale = 1.33

34

# Venus parameters35

if tag == ’Venus’:36

c0 = 6.666667e-0237

c4rng = [-7.,3.]38



depthScale = 1.41

42

# Mars parameters43

if tag == ’Mars’:44

c0 = 2.000000e-0145

c4rng = [-7.,3.]46

47




depthScale = 1.3

4

# other parameters5

N = 1006

M = 1500 # grid points7

xx = (0. ,5.) # Domain8

#c0 = 0.9 # buoyancy parameter9

BCs = ’leftDepression ’ # boundary conditions10

11

# plot parameter12

write = True13


folder15

res = ’%ix%i’%(N,M) + tag + ’.eps’ # N x M + Planet16

plotColor = [’b’, ’r’, ’m’, ’g’, ’k’] # associated colors17

18

# parameter space19

para = ’c4’20

cList = logspace(c4rng [0],c4rng [1],N).tolist ()21

for r in plotList: # prevent dublicates22

if not (r in cList): cList.append(r)23

cList.sort() # sort list24

25

# initialize Lithosphere26

exp = parameterSpace(xx , M, 1., c0 , BCs , geometry=’cartesian ’)27

# define forcing28

if scenario ==’Center ’: exp.forcing(h0=1., x0=0., l=1., type=’gaussMount ’)29

if scenario ==’Crater ’: exp.forcing(h0=1., x0=4./3. , l=1./3. , type=’30

gaussMount ’)31

# set up plots32

plotName=r’Buoyancy Parameter $\Delta \rho / \rho$ = %3.2f’%c0 + ’ (’ +33

tag + ’)’34

(figM ,axM) = exp.plot(tag=’initialize ’, name=plotName) # measure35

(figW ,axW) = exp.plot(tag=’initialize ’, name=plotName) # bending36

exp.plot(ax=axW ,tag=’forcing ’,ls=’-.k’) # plot forcing37

38

# different geometries39

geo = [’cartesian ’, ’polar’]40

line = [’--’, ’-’]41

42

# loop over geometry43

for i in range(len(geo)):44

print(geo[i])45

exp.setParam(’geometry ’, geo[i], store=False)46

48


exp.reset()1

p = 0 # index of plot (for annotation stuff)2

3

# iterate over c4-values4

tic = time()5

for c in cList:6

print(c)7

exp.setParam(para , c) # set parameter value8

exp.direct () # compute solution9

if c in plotList:10

# plot discrete solution for specified values of c11

exp.plot(ax=axW ,tag=’direct ’,ls=line[i]+ plotColor[p], name=’D12

* = %1.0e (’%c+geo[i]+’)’)13

p = p + 1 # index of plot (for annotation stuff)14

exp.measure(’depression ’) # measure depression15

toc = time()16

print(’timing: %5.3f’%(toc -tic))17

18

# display measures over parameter space19

exp.plot(ax=axM ,tag=’depth’,ls=line[i]+’b’,name=’Depth (’+geo[i]+’)’,20

scale=depthScale) # plot depth %(1./ depthScale)21

exp.plot(ax=axM ,tag=’width’,ls=line[i]+’g’,name=’Width (’+geo[i]+’)’)22

# plot width23

24

# show results25

axM.set_ylabel(’Width and Depth of Depression ’)26

axM.set_xlabel(’Flexural Rigidity D*’)27

if parameter ==’Mars’: axM.legend(loc=’right’)28

else: axM.legend(loc=’upper right’)29

for i in range(len(plotList)): axM.axvline(x=plotList[i],color=plotColor[30

i])31

axW.set_xlabel(’Distance from Load in Unit -length ’)32

axW.set_ylabel(’Flexure in Units of Forcing Amplitude ’)33

axW.set_xlim ([ -0.5 ,5])34

axW.legend(loc=’lower right’) # add legends35

maxW=amax(exp.depth)36

print(’ Maximum Topographic Flexure: %3.1f’%(maxW))37

print(’ Nondim. Buoyancy Contrast: %3.2f’%c0)38

print(’ Flexure x Buoyancy: %3.1f’%(maxW*c0))39

# print40

if write:41

figM.savefig(folder+’measure ’+scenario+’Mount’+res , dpi=300,42

papertype=’letter ’)43

figW.savefig(folder+’solution ’+scenario+’Mount’+res , dpi=300,44

papertype=’letter ’)45

show()46

49


Scripts for Other Experiments1

Boundary Conditions (somePlots.py)2

,3


# test script for Planetary Physics Project5



8




from math import pi12

# my own module13

from lithosphere import Lithosphere , parameterSpace14

15

# plot parameter16

write = True17


folder19

file = ’boundaryConditions.eps’20

21

# set parameters22

param = ’earth’23


if param == ’earth’:25




h = 25.e3 # elastic thickness29



h0 = 2.e3 # thickness of surface loading32

l = 420.e3 # loading wavelength33


if param == ’europa ’:35

g = 1.314 # gravity36



h = 250 # elastic thickness39

rhoM = 1.186 e3 # density of mantle40

rhoC = 1.126 e3 # density of crust41

h0 = 500 # thickness of surface loading42

l = (pi/3.) *1.e3 # loading length scale43

44


50


D = E*h**3/(1. -v**2) /12.1

2


DD = D/g/rhoC/l**44


6

# initialize Lithosphere7

exp = parameterSpace ((0. ,4.) ,1500, c4=DD , c0=drho , BCs=’leftFree ’,8

geometry=’cartesian ’)9

# define forcing10

exp.forcing(h0=1.,x0=0., l=1./2. , type=’gaussMount ’)11

# discretize12

exp.discretize ()13

# find solution14

exp.direct () # direct discrete solution15

16

# display solution17

(fig ,ax) = exp.plot(tag=’initialize ’) # initialize axes18

exp.plot(ax=ax ,tag=’direct ’,ls=’-r’,name=’Free End’) # plot discrete19

solution20

exp.plot(ax=ax ,tag=’forcing ’,ls=’--r’,name=’Boundary Load’) # plot21

discrete solution22

23

# next plot: Depression24

exp.setParam(’BCs’, ’leftDepression ’)25


exp.plot(ax=ax ,tag=’direct ’,ls=’-b’,name=’Depression ’) # plot discrete27

solution28

29

# next plot: center load30

exp.forcing(x0=2., l=1./2. , type=’gaussMount ’)31

exp.setParam(’BCs’, ’plane’)32

exp.direct ()33

exp.plot(ax=ax ,tag=’direct ’,ls=’-g’,name=’Fixed Boundaries ’) # plot34

discrete solution35

exp.plot(ax=ax ,tag=’forcing ’,ls=’--g’,name=’Central Load’) # plot36

discrete solution37

38

# next plot: hinged plate39

#exp.setParam(’BCs ’, ’freePlate ’)40

#exp.direct () # direct discrete solution41

#exp.plot(ax=ax,tag=’direct ’,ls=’-y’,name=’Hinged Plate ’) # plot discrete42

solution43

44

45

51


exp = parameterSpace ((0. ,4.) ,1500, c4=DD , c0=0., BCs=’freePlate ’,1

geometry=’cartesian ’)2

# define forcing3

exp.forcing(h0=7.e-4,x0=2., l=1./2. , type=’gaussMount ’)4

# discretize5

exp.discretize ()6

# find solution7


exp.plot(ax=ax ,tag=’direct ’,ls=’-m’,name=’Hinged Plate’) # plot discrete9

solution10

11

ax.legend(loc=’lower right’) # add legend12

fig.savefig(folder+file , dpi=300, papertype=’letter ’)13

# show results14

show()15

Venus Example (coronae.py)16

,17





22




# my own module26

from lithosphere import Lithosphere , parameterTuning27

28

# plot parameter29

write = True30


folder32

file = ’lithosphereFitVenus40.eps’33

34

# set parameters35

param = ’venus’36








52












#rhoC = rhoM11



l = 1.25e3 # loading wavelength14

# Venus ’ lithosphere:15

if param == ’venus’:16






h = 40.e3 # elastic thickness [km]22

h0 = 100 # surface elevation [m]23

l = 200e3 # distance of load from center24

25

# *** produce target solution using flat/euclidean geometry26

x0=l*4/3; ll=l27


D = E*h**3/(1. -v**2) /12.29

# initialize Lithosphere with euclidean geometry30

eucl = Lithosphere ((0. ,3*l), M=900, c4=D, c0=(rhoM -rhoC)*g, BCs=’31

leftDepression ’, geometry=’cartesian ’)32

# define forcing scenario33

eucl.forcing(h0=h0*rhoC*g, x0=x0 , l=ll , type=’gaussMount ’)34

# discretize35

eucl.discretize ()36

# obtain solution37

#exp.iterate(method=’mySOR ’) # iterative numerical solution38

(x,tgt) = eucl.direct () # direct discrete solution39

40

# *** estimate effect of axi -symmetric polar geometry41

42

# initialize parameterTuning experiment with axi -symetric/polar geometry43

# use target values from previous calculation44

axi = parameterTuning ((x,tgt.copy()), c4=D, c0=(rhoM -rhoC)*g, BCs=’45

leftDepression ’, geometry=’polar’)46

53


# use same forcing scenario1

axi.forcing(h0=h0*rhoC*g, x0=x0 , l=ll , type=’gaussMount ’)2

# discretize3

axi.discretize ()4

# store initial solution5

axi.direct () # solve6

axi.store() # store7

8

# find solution9

tic = time()10

# estimate first guess11

h0 = h12

D0 = E*h0**3/(1. -v**2) /12.13

# begin optimization process: optimize flexural regidity parameter , using14

euclidian value as first guess15

Daxi = axi.adjustParameter(adjPar=’c4’, c0=D0 , method=’sim’)16

toc = time()17

print(’Timing: %5.3f’%(toc -tic))18

19

# print results20

print(’Elastic Lithosphere Thickness in Cartesian Geometry: %4.0f m’)21

%(h)22

# D = E*h**3/(1. -v**2) /12.23

haxi = (12.*(1. -v**2)*Daxi/E)**(1./3.)24

print(’Elastic Lithosphere Thickness in Axi -symmetric Geometry: %4.0f m’)25

%(haxi)26

27

# display solution28

(fig ,ax) = axi.plot(tag=’initialize ’) # initialize axes29

axi.plot(ax=ax ,tag=’topography ’,ls=’--g’,name=’Topography ’,scale=rhoC*g)30

# plot exact solution31

#axi.plot(ax=ax,tag=’forceScale ’,ls=’--g ’) # plot exact solution32

axi.plot(ax=ax ,tag=’target ’,ls=’-b’,name=’Plane -parallel Solution ’) #33

plot target solution34

axi.plot(ax=ax ,tag=’firstGuess ’,ls=’--r’,name=’Axi -symmetric Solution ’) #35

plot discrete solution36

axi.plot(ax=ax ,tag=’direct ’,ls=’-r’,name=’Best Axi --symmetric fit’) #37


ax.set_xlim([-l/4. ,3*l+l/4.])39

ax.set_ylabel(’Flexure [m]’)40

ax.set_xlabel(’Distance from Center [m]’)41

ax.legend(loc=’upper left’) # add legend42

# show results43

if write: fig.savefig(folder+file , dpi=300, papertype=’letter ’)44

show()45

54


Europa Example (iceberg.py)1

,2





7




# my own module11

from lithosphere import Lithosphere , parameterTuning12

13

# plot parameter14

write = True15


folder17

file = ’lithosphereFitEuropa220.eps’18

19

# set parameters20

param = ’europa ’21













g = 1.314 # gravity34





#rhoC = rhoM39



l = 1.25e3 # loading wavelength42

43

# *** produce target solution using flat/euclidean geometry44

45

55



D = E*h**3/(1. -v**2) /12.2

# initialize Lithosphere with euclidean geometry3

eucl = Lithosphere ((0. ,5*l), M=1500, c4=D, c0=(rhoM -rhoC)*g, BCs=’4

leftDepression ’, geometry=’cartesian ’)5

# define forcing scenario6

eucl.forcing(h0=h0*rhoC*g, x0=0., l=l, type=’gaussMount ’)7

# discretize8

eucl.discretize ()9

# obtain solution10

#exp.iterate(method=’mySOR ’) # iterative numerical solution11

(x,tgt) = eucl.direct () # direct discrete solution12

13

# *** estimate effect of axi -symmetric polar geometry14

15

# initialize parameterTuning experiment with axi -symetric/polar geometry16

# use target values from previous calculation17

axi = parameterTuning ((x,tgt.copy()), c4=D, c0=(rhoM -rhoC)*g, BCs=’18

leftDepression ’, geometry=’polar’)19

# use same forcing scenario20

axi.forcing(h0=h0*rhoC*g, x0=0., l=l, type=’gaussMount ’)21

# discretize22

axi.discretize ()23

# store initial solution24

axi.direct () # solve25

axi.store() # store26

27

# find solution28

tic = time()29

# estimate first guess30

h0 = h31

D0 = E*h0**3/(1. -v**2) /12.32

# begin optimization process: optimize flexural regidity parameter , using33

euclidian value as first guess34

Daxi = axi.adjustParameter(adjPar=’c4’, c0=D0 , method=’sim’)35

toc = time()36

print(’Timing: %5.3f’%(toc -tic))37

38

# print results39

print(’Elastic Lithosphere Thickness in Cartesian Geometry: %4.0f m’)40

%(h)41

# D = E*h**3/(1. -v**2) /12.42

haxi = (12.*(1. -v**2)*Daxi/E)**(1./3.)43

print(’Elastic Lithosphere Thickness in Axi -symmetric Geometry: %4.0f m’)44

%(haxi)45

46

56


# display solution1

(fig ,ax) = axi.plot(tag=’initialize ’) # initialize axes2

axi.plot(ax=ax ,tag=’topography ’,ls=’--g’,name=’Topography ’,scale=rhoC*g)3

# plot exact solution4

#axi.plot(ax=ax,tag=’forceScale ’,ls=’--g ’) # plot exact solution5

axi.plot(ax=ax ,tag=’target ’,ls=’-b’,name=’Plane -parallel Solution ’) #6

plot target solution7

axi.plot(ax=ax ,tag=’firstGuess ’,ls=’--r’,name=’Axi -symmetric Solution ’) #8


axi.plot(ax=ax ,tag=’direct ’,ls=’-r’,name=’Best Axi -symmetric fit’) # plot10

discrete solution11

ax.set_xlim ([-0.5e3 ,6.5e3])12

ax.set_ylabel(’Flexure [m]’)13

ax.set_xlabel(’Distance from Load Center [m]’)14

ax.legend(loc=’lower right’) # add legend15

# show results16

if write: fig.savefig(folder+file , dpi=300, papertype=’letter ’)17

show()18

57


0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0x

�8�7�6�5�4�3�2�1

0

1

w

Free EndBoundary LoadDepressionFixed BoundariesCentral LoadHinged Plate

0 100000 200000 300000 400000 500000 600000Distance from Center [m]

�500

�400

�300

�200

�100

0

100

Flexure

[m

]

TopographyPlane-parallel SolutionAxi-symmetric SolutionBest Axi--symmetric fit

Figure 1: Left: Solutions for different boundary conditions (see Section 2.2.1); the solutions

were obtained numerically using the method described in Section 3. Right: A lithospheric

flexure solution for a ring load scenario (parameter values corresponding to Venus); the

elastic thickness in Cartesian geometry is hcart = 40 km and the best fit in the axi–

symmetric case is hpol = 33.6 km.

58


0 1000 2000 3000 4000 5000 6000Distance from Load Center [m]

�250

�200

�150

�100

�50

0

50

100

Flexure

[m

]

TopographyPlane-parallel SolutionAxi-symmetric SolutionBest Axi-symmetric fit

10-1 100 101 102 103 104 105 106

Length-scale [km]

10-8

10-7

10-6

10-5

10-4

10-3

10-2

10-1

100

101

102

103

104

Non-d

imensi

onal Fl

exura

l R

igid

ity D

*

Non-dimensional D* as a function of length-scale

Earth, h= 25kmEarth, h=100kmEarth, h=250kmEuropa, E=60MPaEuropa, h= 500mEuropa, h=1500mVenus, h= 20kmVenus, h= 40kmVenus, E=85GPaMars, h= 40kmMars, h=120kmMars, h=200km

Figure 2: Left: A lithospheric flexure solution for a central load scenario and parameter

values corresponding to Europa; the elastic thickness in the Cartesian case is hcart = 220m

and the best fit for the axi–symmetric case is hpol = 185m. Right: Relationship between

length–scale and dimensionless flexural rigidity (Europa default values: h = 250 km,

E = 6× 109Pa).

59


0 1 2 3 4 5Distance from Load in Unit-length

�7�6�5�4�3�2�1

0

1

Flexure

in U

nit

s of

Forc

ing A

mplit

ude

Buoyancy Parameter ��/� = 0.15 (Earth)

forcingD* = 6e-07 (cartesian)D* = 9e-05 (cartesian)D* = 1e-03 (cartesian)D* = 4e-02 (cartesian)D* = 2e+02 (cartesian)D* = 6e-07 (polar)D* = 9e-05 (polar)D* = 1e-03 (polar)D* = 4e-02 (polar)D* = 2e+02 (polar)

10-7 10-6 10-5 10-4 10-3 10-2 10-1 100 101 102 103

Flexural Rigidity D*

0

1

2

3

4

5

6

7

Wid

th a

nd D

epth

of

Depre

ssio

n

Buoyancy Parameter ��/� = 0.15 (Earth)

Depth (cartesian)Width (cartesian)Depth (polar)Width (polar)

Figure 3: Earth Left: Lithospheric flexure for selected values of D∗. Right: Depression

depth and width as a function of nondimensional flexural rigidity D∗. The value of the

nondimensional buoyancy contrast of ∆ρ∗ = 0.015 is representative for Earth.

60



�20

�15

�10

�50

5

Flexure

in U

nit

s of

Forc

ing A

mplit

ude

Buoyancy Parameter ��/� = 0.05 (Europa)


10-7 10-6 10-5 10-4 10-3 10-2 10-1 100 101 102 103


0

5

10

15

20

Wid

th a

nd D

epth

of

Depre

ssio

n

Buoyancy Parameter ��/� = 0.05 (Europa)


Figure 4: Europa Left: Lithospheric flexure for selected values of D∗. Right: Depression


nondimensional buoyancy contrast of ∆ρ∗ = 0.05 is representative for Europa.

61



�16

�14

�12

�10

�8�6�4�2

0

2

Flexure

in U

nit

s of

Forc

ing A

mplit

ude

Buoyancy Parameter ��/� = 0.07 (Venus)


10-7 10-6 10-5 10-4 10-3 10-2 10-1 100 101 102 103


0

2

4

6

8

10

12

14

16

Wid

th a

nd D

epth

of

Depre

ssio

n

Buoyancy Parameter ��/� = 0.07 (Venus)


Figure 5: Venus Left: Lithospheric flexure for selected values of D∗. Right: Depression


nondimensional buoyancy contrast of ∆ρ∗ = 0.07 is representative for Venus.

62



�5�4�3�2�1

0

1

Flexure

in U

nit

s of

Forc

ing A

mplit

ude

Buoyancy Parameter ��/� = 0.20 (Mars)


10-7 10-6 10-5 10-4 10-3 10-2 10-1 100 101 102 103


0

1

2

3

4

5

Wid

th a

nd D

epth

of

Depre

ssio

n

Buoyancy Parameter ��/� = 0.20 (Mars)


Figure 6: Mars Left: Lithospheric flexure for selected values of D∗. Right: Depression


nondimensional buoyancy contrast of ∆ρ∗ = 0.2 is representative for Mars.

63

andre r. erler

Documents