Model:GFlex

Important: Flexure (soon to be rebranded isostasy) is undergoing a major revamping for inclusion in the CSDMS CMT framework for coupling with other models. This means that the instructions and description given here are no longer applicable. If you would like to use the standalone model described here, please contact Andy Wickert and he will provide you with a working copy. We hope to have a new integrated version done very soon (within a week or two). Andy Wickert 01:42, 30 July 2011 (MDT)

Edit Model information

GFlex

Metadata

Summary Contact Technical specs In/Output Process Testing Other Component info Also known as Model type Single Model part of larger framework Note on status model Date note status model Spatial dimensions 2D Spatial extent Continental, Regional-Scale, Landscape-Scale Model domain One-line model description Direct 2D finite difference solution of lithospheric flexure Extended model description Finite difference solution allows for calculations of flexural response in regions of variable elastic thickness / flexural rigidity. The direct solution technique means that it takes time to populate a cofactor matrix, but that once this has been done, flexural solutions may be obtained rapidly via a Thomas algorithm. This makes it less good for an individual solution where an iterative approach may be more computationally efficient, but better for modeling where elastic thickness does not change (meaning that you do not need to create a new cofactor matrix) but loads do. Keywords: lithospheric flexure, Name Andy Wickert Type of contact Model developer Institute / Organization University of Colorado Postal address 1 Department of Geological Sciences, UCB 399 Postal address 2 2200 Colorado Ave Town / City Boulder Postal code 80309 State Colorado Country US"US" is not in the list (Afghanistan, Albania, Algeria, Andorra, Angola, Antigua and Barbuda, Argentina, Armenia, Australia, Austria, ...) of allowed values for the "Country" property. Email address wickert@colorado.edu Phone Fax Supported platforms Unix, Linux Other platform Programming language Python Other program language Code optimized Single Processor Multiple processors implemented Nr of distributed processors Nr of shared processors Start year development 2010 Does model development still take place? Yes If above answer is no, provide end year model development Code development status When did you indicate the 'code development status'? Model availability As code Source code availability (Or provide future intension) Through CSDMS repository Source web address Source csdms web address Program license type GPL v3 Program license type other Memory requirements Typical run time Minutes to populate cofactor matrix, ~1 second for solution Describe input parameters Elastic thickness map (ASCII) Load map (ASCII) dx, dy Material properties Young's modulus Poisson's ratio density of load density of infilling material (optional; this can also be done via iteration for more complicated situations Only the elastic thickness and load need to be actual input files. The rest (scalars) can be specified at the command line interface. Input format ASCII Other input format Describe output parameters Cofactor matrix (*.mtx sparse matrix file; ASCII) Flexural response map (ASCII) Output format ASCII Other output format Pre-processing software needed? No Describe pre-processing software Post-processing software needed? No Describe post-processing software Visualization software needed? No If above answer is yes Other visualization software Describe processes represented by the model Response of a lithospheric plate, potentially with nonuniform elastic thickness, to an applied surface load Describe key physical parameters and equations [[Describe key physical parameters::See:#Key physical parameters and equations]] Describe length scale and resolution constraints Insufficiently tested to know. Describe time scale and resolution constraints Currently does not time-evolve. I would like to couple this to a 3D viscoelastic mantle at some point, but this hasn't happened yet. Describe any numerical limitations and issues Insufficiently tested to know. Describe available calibration data sets Upload calibration data sets if available: Describe available test data sets Upload test data sets if available: Describe ideal data for testing Do you have current or future plans for collaborating with other researchers? Is there a manual available? No Upload manual if available: Model website if any Model forum / discussion board Comments This part will be filled out by CSDMS staff OpenMI compliant No but possible BMI compliant No but planned WMT component In progress PyMT component Is this a data component Can be coupled with:

Model info Authors Andy Wickert Source code DOI Download GFlex [ version: 0.6] Doi: 10.1594/IEDA/100123 Model citations Nr. of publications: 2 Total citations: 34 h-index: 1 m-quotient: 0.08 QR-code Link to this page Other models by author AlluvStrat GFlex IceFlow NEXRAD-extract Terrapin

Introduction

The model flexure computes a direct finite difference (lower/upper decomposition) solution to the flexure equations for a lithospheric plate of nonuniform elastic thickness via a thin plate assumption. It consists of two modules, the first of which is used to generate the coefficient matrix for the Thomas algorithm solution and the second of which actually generates that solution (using the coefficient matrix produced by the first module as an input file). The first module is slow, but the second is very fast, making this a poor technique for a one-off equilibrium flexure calculation, but a good choice for situations in which flexural response needs to be calculated many times in a row. Such situations in which this model would excel include:

• Numerical models that require frequent updating of flexural deformations of the lithosphere
• Simulations with forcings that take place on a time-scale that is comparable to the time-scale of Earth response to loading and unloading (e.g., ice and water loading during glacial cycles)
• Calculations of mixed sediment and/or water loading, or water loading with onlap and offlap, such that a constant fill density cannot be assumed and solutions must be produced iteratively.

Key physical parameters and equations

We solve the PDE for lithospheric flexure in 2 dimensions:

[math]\displaystyle{ \nabla^2\left(D(x,y)\nabla^2 w \right) + \Delta \rho g w = q(x,y) }[/math]

Here, D is the flexural rigidity, w is the vertical displacement at each (x,y), Δρ is the mantle density minus the density of infilling material, g is gravitational acceleration, and q is the applied load. We follow Wees and Cloetingh (1994) in acknowledging that flexural rigidity is a tensor property:

[math]\displaystyle{ D = \frac{E T_e^3}{12\left(1-\nu^2\right)} \left[ \begin{array}{ccc} 1 & \nu & 0 \\ \nu & 1 & 0 \\ 0 & 0 & \frac{1-\nu}{2} \end{array} \right] }[/math]

History

Flexure was developed first in MATLAB (Spring / early Summer 2010) and then in Python with Numpy, Scipy, and Matplotlib (translated October 2010).

The next planned step in development is to make flexure be IRF- and CMT-compliant.

Planned development will proceed slowly through Spring 2011 (though this will go faster if I get a solid day or two to work on it). Because the program is based on a set of functions in a python module, we plan on adding additional functionality for 1D and 2D analytical solutions, a 1D Thomas algorithm solution, and a 2D alternating direction implicit (ADI) iterative solution. If all goes as planned, this should be a one-stop shop for flexure solutions.

Papers

Nothing published yet, so please email Andy Wickert (see contact info box at top) if you are going to use this model for a publication, and we'll figure out how you can cite it. I will hopefully get a Computers and Geosciences paper or something like it submitted in 2011.

Help

Basic instructions

(Modified from instructional emails)

Prerequisites

You need to have python, numpy, scipy, and matplotlib installed to use flexure.

Structure

The version 0.1 structure (prone to change) consists of two main files.

• flexcalc.py is a python module which contains all of the functions needed to execute flexure.
• flexit.py is the frontend that, via optparse, gives you the ability to specify inputs and outputs and run flexural solutions via an interactive command-line interface.

In addition to these files, version 0.1 comes with some basic test loads and elastic thickness maps.

Trial run

For the basic functionality on the first runthrough, you navigate to the directory with the flexit.py and type something in like:

python flexit.py -vcrp --dx=20000 --Te=Te_sample/bigrange_Te_test.txt --q0=q0_sample/top_bottom_bars.txt

You select which of the sample Te and q0 files you want. Andy_output.png is the flexural response (variable=w) output from:

python flexit.py -vcrp --dx=20000 --Te=Te_sample/bigrange_Te_test.txt --q0=q0_EW_bar.txt

The flags are explained in the help file (python flexit.py -h), as are other options for running the code. Basically you will want to run "-c" the first time, but not again unless you are going to redo the coefficient matrix (i.e., use a different pattern of elastic thickness). This calculation can take a long time for large grids, so you will want to store these files. When running without making a coefficient matrix, unless you're using the default coefficient matrix name (as we do above), you will have to specify its location with "--coeff-file=NAME". For example:

python flexit.py -vrp --Te=Te_sample/bigrange_Te_test.txt --q0=q0_sample/top_bottom_bars.txt --coeff_file=coeffs.txt

If all else fails

Have you typed:

python flexit -h

? This gives you all of the in-program help information.

Feel free to email Andy Wickert for anything related to this model (see contact info in box at top).

Input Files

The coefficient matrix for the 2D Thomas algorithm solution requires a map of elastic thicknesses in *.txt / ASCII format. This elastic thickness map must be two cells wider on each side than the map of loads; this is because the finite difference solution must "look" two cells in every direction. It also requires the specification of several parameters, including:

• Young's modulus (defaults to 10¹¹ Pa)
• Poisson's ratio (defaults to 0.25)
• Mantle density (defaults to 3300 kg/m³)
• Density of infilling material (defaults to 0 kg/m³)

This outputs an ASCII sparse matrix file (Matrix Market *.mtx format).

The flexural solution requires the ASCII file for the sparse coefficient matrix generated above and an imposed array of loads (also ASCII), along with the specification of input and output file names.

Output Files

The coefficient matrix creator writes a *.mtx sparse matrix ASCII file that is used in the direct solution. This matrix is characteristic to a given pattern of elastic thickness, and therefore can be reused if elastic thickness does not change.

The real solver outputs an ASCII grid of deflections due to the load. This is the output that is of scientific interest and/or useful to plug into other modules (e.g., for flexural subsidence).