Pylith quasistatic rate-and-state

Dear Pylith Developers,

How does Pylith handle slip rate and thus theta evolution in quasistatic simulations?
Is the slip rate considered zero and theta just evolves as time?

I can provide calculation details, if it helps, but the question is generic.

See slide 14 in from the 2017 tutorial on friction

We use a linear approximation at very low slip rates. Because we use an iterative solver, to detect actual stick behavior (with any friction model), we use a zero tolerance for detecting slip. If the slip is below this tolerance, it is set to zero. So you are correct in that quasistatic simulations will be locked when the slip / slip rate drops below the zero threshold. The state variable will continue to evolve according to the constitutive equations.

Dear Brad,

Thank you!
Are there any limits on setting the reference friction level for rate-and state friction (like with regard to zero_tolerance or friction.linear_slip_rate) or is it just a number that goes into the equation for updating mu and theta?

Also could you please have a look at my tolerances and tell me if it looks correct?
The only two constraints I found in the manual are: zero_tolerance should be larger than absolute tolerance in KSP solves and friction.linear_slip_rate should be about one order of magnitude larger than absolute tolerance in solve.
I would really like to decrease the zero_tolerance to get weakening for smaller slip rates, but it already takes forever to converge with these values.
Am I doing something wrong?
The simulation is quasistatic with dynamic rupture implementation.





Change fault to dynamic fault interface.

fault = pylith.faults.FaultCohesiveDyn

zero_tolerance = 1.0e-8

The label corresponds to the name of the nodeset in CUBIT.

label = fault
edge = fault_edge

We must define the quadrature information for fault cells.

The fault cells are 1D (surface).

quadrature.cell = pylith.feassemble.FIATSimplex
quadrature.cell.dimension = 1

Use rate- and state-friction with the ageing law for evolution of

the state variable.

friction = pylith.friction.RateStateAgeing
friction.label = Rate and state
friction.linear_slip_rate = 1.0e-6

friction.db_properties = spatialdata.spatialdb.SimpleDB
friction.db_properties.label = Rate State Ageing
friction.db_properties.iohandler.filename = spatialdb/2_v6_friction_rate_and_state_26.25_middle_0.5.spatialdb


Set spatial database for the initial value of the state variable.

friction.db_initial_state = spatialdata.spatialdb.UniformDB
friction.db_initial_state.label = Rate State Ageing State
friction.db_initial_state.values = [state-variable]

theta_ss = characteristic_slip_dist / reference_slip_rate = [0.5*s]


PETSc settings


NOTE: There are additional settings specific to fault friction.


Set the solver options.

malloc_dump =

Preconditioner settings.

pc_type = asm
sub_pc_factor_shift_type = nonzero
#pc_type = lu
#pc_factor_mat_solver_type = umfpack

Convergence parameters.

ksp_rtol = 1.0e-12
ksp_atol = 5.0e-9
ksp_max_it = 3000
ksp_gmres_restart = 50

Linear solver monitoring options.

ksp_monitor = true
#ksp_view = true
ksp_converged_reason = true
ksp_error_if_not_converged = true

Nonlinear convergence parameters.

snes_rtol = 1.0e-12
snes_atol = 1.0e-7
snes_max_it = 3000

Nonlinear solver monitoring options.

snes_monitor = true
snes_linesearch_monitor = true
#snes_view = true
snes_converged_reason = true
snes_error_if_not_converged = true

PETSc summary – useful for performance information.

log_summary = true

Uncomment to launch gdb when starting PyLith.

start_in_debugger = true

Friction sensitivity solve used to compute the increment in slip

associated with changes in the Lagrange multiplier imposed by the

fault constitutive model.

friction_pc_type = asm
friction_sub_pc_factor_shift_type = nonzero
friction_ksp_max_it = 50
friction_ksp_gmres_restart = 30

Uncomment to view details of friction sensitivity solve.

friction_ksp_monitor = true
friction_ksp_view = true
friction_ksp_converged_reason = true

And the friction db values are:

#SPATIAL.ascii 1
SimpleDB {
num-values = 6
value-names = reference-friction-coefficient reference-slip-rate characteristic-slip-distance constitutive-parameter-a constitutive-parameter-b cohesion
value-units = none m/s m none none MPa
num-locs = 3
data-dim = 1 // locations form a line
space-dim = 2
cs-data = cartesian {
to-meters = 1.0 // specify coordinates in m
space-dim = 2

// Columns are
// (1) x coordinate (m)
// (2) y coordinate (m)
// (3) reference-friction-coefficient (none)
// (4) reference-slip-rate (m/s)
// (5) characteristic-slip-distance (m)
// (6) constitutive-parameter-a (none)
// (7) constitutive-parameter-b (none)
// (8) cohesion (MPa)

-0.1 0.0 0.6145 2e-4 0.2047e-5 0.0029 0.0043 0.0
0.0 0.0 0.6 2e-4 0.2047e-5 1e-16 1e-16 0.0
0.1 0.0 0.6145 2e-4 0.2047e-5 0.0029 0.0043 0.0


The reference friction level for rate-state friction is just used to compute the coefficient of friction. It doesn’t have any relation to the solver tolerances.

Sorry, I meant reference slip rate.
But I guess, the answer is similar?

Yes, the answer is the same.