Stochastic slip (fakequakes)

Generating stochastic slip distributions

In this entry I will explain how to generate stochastic slip distributions using the fakequakes module. All of the files for this example can be found in examples/fakequakes/planar. I will discuss only a planar geometry. Fakequakes can also generate slip distributions on a 3D geometry, for example from Slab 2.0, I will cover that in another entry. Similarly you can synthesize HR-GPS and strong motion waveforms from the stochastic slip models. This will also be covered elsewhere. For now, the goal is simply to teach you to generate the slip model itself.

The details behind the fakequakes implementation can be found in these two papers:

• LeVeque, R. J., Waagan, K., González, F. I., Rim, D., & Lin, G. (2016). Generating random earthquake events for probabilistic tsunami hazard assessment. In Global Tsunami Science: Past and Future, Volume I (pp. 3671-3692). Birkhäuser, Cham.

• Melgar, D., LeVeque, R. J., Dreger, D. S., & Allen, R. M. (2016). Kinematic rupture scenarios and synthetic displacement data: An example application to the Cascadia subduction zone. Journal of Geophysical Research: Solid Earth, 121(9), 6658-6674.

The fakequakes parameter file

Begin by copying the file subduction.fq.py into a folder of your choice where you will keep your fakequakes runs. For example on my machine I have a folder /home/dmelgar/fakequakes/run where I keep all my parameter files.

This is the parameter or control file that defines all the details of your models. Open it in a text editor or IDE (I use Spyder). The first thing we will do is initalize the file structure. The first lines of code look like this:

Set the home variable to a folder of your choice where you will keep your fakequakes projects. Also set the project_name variable to some suitable name that describes the project you will be working on.

Next notice the set of action flags in lines 19-26. These are used to define which actions you want the code to take. Set init = 1 and run the parameter file by typing at your terminal $> python /path/to/file/subduction.fq.py This will simply create the folder structure needed by fakequakes

NOTE MudPy and fakequakes are still predominantly a python 2.7 code. Make sure you use a python 2.x interpreter when running these files. Porting to Python 3.x is underway.

After running the parameter file you can open your file browser and verify that indeed the relevant folders have been created, you should see something like this:

You have now created the folder structure. In order to avoid mistakes and confusion fakequakes and MudPy are very rigid in the sense that certain files have to be in certain folders. We will look at those auxiliary files next.

Auxiliary files

Fault geometry definition

You have to decide a priori what fault geometry you want your stochastic slip models to be on. An example of such a file is, again, under examples/fakequakes/planar. Copy this file subduction.fault to the folder /data/model_info within your fakequakes project folder.

Open the file in a text editor to see its contents. It should look something like this:

The columns are self explanatory. The fault is broken up into many subfaults. The file contains the geographic coordinates of the centers of each subfault as well as the depth in kilometers. The strike and dip of each subfault are defined as well as the length and width (in meters). Later on if you want to generate slip models on another geometry you need to create a .fault file with this exact structure. Note also that this file has ~7000 subfaults. This is because we are using relatively small subfaults, 4000 x 4000m over a relatively large area. The number of subfaults and size of the fault model will be entirely dependent on the application.

Earth structure model file

The second file you will need is a .mod file that defines the Earth structure. Fakequakes can handle homogenous half-space models and layered Earth models. There are examples of both in examples/fakequakes/planar. Lets use a layered Earth model, copy the file bbp_norcal.mod to the folder /structure/ within your fakequakes project folder.

Open the file in a text editor to examine it. This is a very detailed layered Earth model for northern California used by the SCEC BBP project. The file should look like this:

Due to somewhat silly reasons, which I will not explain here, the columns in that file are ordered as follows: layer thickness in kilometers, S-wave speed in km/s, P-wave speed in km/s, density in kg/cm^3, S-wave attenuation, and P-wave attenuation. Do not add headers to this file or unexpected results might occur. Also note that the final layer has thickness of 0. this indicates an infinite halfspace below the previous layers. If you wanted to have just a homogenous halfspace you could have a .mod file with only one 0 thickness layer.

Final notes before running the rupture models

That's it! It really is that simple you just need those two files, the .fault file and the .mod file together with the parameter file to get some nice stochastic slip models.

Before moving on I will just point out that if you are interested in stochastic models with a diversity of magnitudes you don't need many different .fault files. You can simply have one fault geometry that is big enough to fit the range of magnitudes you are interested in and the code will generate ruptures with random parts of the bigger geometry as the center. This will become clear with the examples below and is also discussed in the Melgar et al. (2016) paper at great length.

Setting up the parameter file

Ok, now back to the subduction.fq.py parameter file. If all you want to do is generate slip models not all of the parameters will be relevant. Many of them are related to waveform synthesis. For simply generating slip models these are the relevant ones:

I will not discuss all of these in detail. For simplicity's sake the relevant ones are:

• fault_name is the name of your .fault file
• model_name is the name of your .mod velocity structure file
• distances_name is the name of a matrix variable which will be created at run-time. This matrix will hold the along-strike and along-dip distances between all subfaults. Simply give it a name that relates to the geometry you are using.
• UTM_zone, fakequakes projects from geographic to cartesian coordinates using the UTM projection. This requires you define the UTM zone (roughly) of the center of your fault model.
• Nrealizations defines how many slip models you want per magnitude
• target_Mw is a vector of desired magnitudes. In the erxample above it will be M7.5 through M8.5 in 0.1 magnitude unit increments. Thus there will be a total of 50 slip models generated (because Nrealizations=5)
• max_slip is some reasonable bound (in meters) of what the maximum allowed slip will be
• time_epi is the UTC date and time at which your synthetic events will originate
• force_hypocenter if False then for every slip model a random subfault will be chosen as the hypocenter. If True then the hypocenter will be forced to whatever value is in hypocenter.

If you are interested in what the other parameters they are all explained in Melgar et al. (2016).

Run it!

Ok, you're ready to go. Now simply change the action flags at the top. Set init = 0 (otherwise you will initialize the folder structure and delete all that you have done). Now set make_ruptures = 1. Run the file once again by typing at your terminal $> python /path/to/file/subduction.fq.py you should see output in your terminal: