QDYN version 2.3.1

What's new in version 2.3.1?

Documentation

• Added SciPy as a requirement to the documentation
• Added documentation for the MPI_PATH variable

Bug fixes

• Updated tutorials to correctly plot vmax time series
• Fixed MPI initialisation bugs introduced by release 2.3.0
• Fixed a couple of issues in the new output modules in relation to MPI
• Modified the 2D mesh generation function in the pyqdyn.py wrapper
• Properly initialised the stressing rate (dtau_dt) to prevent NaNs in the output

QDYN version 2.3.0

What's new in version 2.3.0?

Better simulation output (#42, #45)

The output modules have been completely revised, as to ensure consistent output results across all simulation features:

• Output files now have semantic names (output_ox, output_vmax), etc.
• The time series output has been generalised, so that the output produced at the IC and IOT locations follow the same structure and are treated identically. Time series output from one location is stored in a file with the location index identifier (e.g. output_ot_1020 for location index 1020).
• To reduce overhead on the time series output, the output from the location at which V = max(V) is stored in a separate file (ot_vmax).
• Vmax and IOT output are now supported for MPI parallel simulations (#44)
• Octave support was dropped, which could no longer be guaranteed (#47)
• For 3D simulations, a separate snapshot output resolution was introduced for along-strike (NXOUT) and along-dip (NWOUT) directions (#48)
• A user variable for the MPI path was added to the PyQDYN wrapper

For the time being, binary output has been disabled. The generalised output structure expedites the implementation of HDF5 binary output, which will be implemented in the future (#51).

3D tutorial notebook (#52)

To introduce new users into 3D simulations, a Jupyter notebook tutorial has been added which illustrates how to set-up a basic 3D simulation (similar to the single asperity tutorial).

Bug fixes since version 2.2.0

• (#37) Fixed a small bug in pyqdyn.py which caused the grid nodes to be slightly offset (by half the grid spacing).
• (#38) Previously slip was computed by forward Euler integration of slip rate, which has a (much) lower-order accuracy than the implemented ODE solvers. To prevent the accumulation of discrepancies in the slip output for long-term simulations (see #17), the slip computation was incorporated within the ODE solver routine.
• (#38) The low precision output of the simulation time (in time series output) caused round-off issues for long-term simulations. The output precision has been increased for time quantities.
• (#53) The Runge-Kutta solver is now compatible with MPI parallel simulations
• Fixed various problems in the PyQDYN wrapper with running 3D simulations.
• Fixed a NumPy (v1.18+) issue interpreting floating point numbers as integers, which would throw an error while running the test suite. As a result, the TravisCI automated tests would fail too.
• Added a travis_wait command for the test suite to .travis.yml to prevent time-out during TravisCI testing.

QDYN version 2.2.2

What's new in version 2.2.2?

SEAS benchmark exercise BP2 example

The QDYN team participated in the Community Code Verification Exercise for Simulating Sequences of Earthquakes and Aseismic Slip (SEAS), funded by SCEC. The results of this community benchmark exercise are accepted for publication in Seismological Research Letters (see also this preprint on EarthArXiv). A script to run these simulations in QDYN is now included in the /examples/scec_benchmarks/BP2 directory.

Bug fixes since version 2.2.1

• Fixed a NumPy (v1.18+) issue interpreting floating point numbers as integers, which would throw an error while running the test suite. As a result, the TravisCI automated tests would fail too.

QDYN version 2.2.1

What's new in version 2.2.1?

Documentation

New tutorial notebooks (#36)

New Jupyter notebooks have been added that cover spring-block simulations using the CNS model

Bug fixes since version 2.2

• (#37) Fixed a small bug in pyqdyn.py which caused the grid nodes to be slightly offset (by half the grid spacing).
• (#38) Previously slip was computed by forward Euler integration of slip rate, which has a (much) lower-order accuracy than the implemented ODE solvers. To prevent the accumulation of discrepancies in the slip output for long-term simulations (see #17), the slip computation was incorporated within the ODE solver routine.
• (#38) The low precision output of the simulation time (in time series output) caused round-off issues for long-term simulations. The Python wrapper (pyqdyn.py) now uses higher precision time values read from a separate output file (fort.121).

QDYN version 2.2

What's new in version 2.2?

Documentation

QDYN documentation ported to GitHub Pages (#14)

Previously the QDYN documentation was hosted on Google Docs, with a PDF included in the GitHub repository. To allow for version control, community contributions, and version-specific documentation, the documentation was ported to GitHub Pages - see http://ydluo.github.io/qdyn/.

Tutorial notebooks

In addition to the example scripts, Jupyter Notebooks have been added to the examples/notebooks folder. These interactive notebooks guide new users through the process of creating a Python script file, run a simulation, and visualise its output. More (advanced) tutorials will be added in the future.

Developer features

2D kernel testing (#30)

Standard computed 2D kernels can now be exported using qdyn kernel, which writes the kernel "vectors" to files in the test/kernels/ directory. This includes any combination of finite/infinite/symmetric/asymmetric kernel geometries. The unit testing suite has been expanded with kernel tests, comparing computed kernels with pre-computed ones stored in test/kernels/.

Travis CI automated testing (#32)

Travis CI facilitates continuous integration (CI) through automated testing of commits and pull requests. From now on, all pull requests and commits will be automatically tested for compiling issues and compatibility with previous versions of the code. Specifically, the QDYN test suite (test/test_suite.py) is executed, performing a range of unit and integration tests.

QDYN version 2.1

What's new in version 2.1?

User features

Update of thermal pressurisation scheme (#28)

In release 2.0, the implementation of thermal pressurisation was announced, with the added disclaimer that this feature was still under active development. Since then, the consistency of the heat/fluid diffusion integration scheme has been improved, and the QDYN documentation has been updated. With the modified implementation, the simulation results that employ thermal pressurisation no longer depend on the solver accuracy (or simulation time step)

A spring-block example demonstrating the usage of the thermal pressurisation module has been added.

LVFZ in FINITE=1 loading conditions (#26)

1D faults with a low-velocity fault zone are now available for FINITE=1 loading conditions.

Bug fixes since version 2.0

• Fixed a bug in pyqdyn.py that caused snapshot data to be misaligned (output only, computations not affected) (#27)
• Fixed a bug in pyqdyn.py in which the time series/snapshot output contained multiple columns with the same name
• Fixed a bug in qdyn_read_in: error while dim = 2 and use the qdyn('read') because iwloc is undefined

Under development

• Implementation of a Runge-Kutta solver that better handles a maximum time-step

QDYN version 2.0

What's new in version 2.0?

User features

CNS friction model

The Chen-Niemeijer-Spiers (CNS) microphysical model has been implemented, and an alternative to the commonly used rate-and-state friction model. The CNS model can be seen as a friction law based on the interplay between granular flow (grain sliding) and one or more creep mechanisms. QDYN supports multiple independent creep mechanisms operating simultaneously. This facilitates (temperature-dependent) transitions from one mechanism to another. See Van den Ende et al. (2018) for details of the model mechanics and implementation.

Thermal pressurization

Thermal pressurization is a dynamic weakening mechanism, which causes a strong reduction in shear strength at coseismic slip velocities by thermal expansion of the pore fluid. This mechanism is compatible with both the CNS and rate-and-state friction laws. NOTE: the implementation of thermal pressurization is under active development, and the accuracy of this module is not guaranteed.

Faults surrounded by a damaged zone

Mature faults are surrounded by damaged materials, more compliant than their host rocks. QDYN now handles faults that bisect a pre-existing compliant layer of uniform thickness and elastic properties, embedded in a stiffer elastic medium. See Idini and Ampuero (2017) for results of earthquake cycle simulations based on this new feature.

Runge-Kutta solver

A second ODE solver has been implemented based on the Runge-Kutta-Fehlberg method. This method is 4th-order accurate, with a 5th-order error estimator for the time step control. The Runge-Kutta solver tends to make smaller time-steps than the Bulirsch-Stoer solver, but each of which are computationally cheaper, so that overall the performance of both solvers is similar.

Free surface in 2D simulations

The effect of a free surface at z=0 on a 1D vertical, anti-plane fault in a 2D half-space (MESHDIM=1) can be accounted for exactly by a mirror image approach, introducing a plane of symmetry around the first mesh element. Previously this had to be done by the user, but now QDYN can enforce symmetry internally by setting FINITE = 2 for infinite faults, or FINITE = 3 for periodic faults.

Python wrapper

In addition to the MATLAB wrapper, a Python 3 wrapper (pyqdyn.py) has been created. This wrapper contains similar functionalities as the MATLAB wrapper. Currently thermal pressurization and the CNS model are only supported by the Python wrapper.

Windows 10 compatibility

QDYN is now compatible with Windows 10 platforms, enabled by the Ubuntu subsystem. See the documentation for installation instructions.

Developer features

Testing suite

Internal unit testing is now possible by calling QDYN with the test keyword. The unit tests currently cover only parts related to rate-and-state friction, and are embedded within the QDYN Fortran code (so that the outcomes are independent of the compiler/platform). Python-based integration tests can be found in the new test/ directory. The entire test suite (unit and integration tests) can be launched by running test/test_suite.py. It is recommended to run this test suite prior to pushing a commit upstream.

SCEC2018 benchmark results

The QDYN team participated in the two first benchmarks of the SCEC SEAS project (Southern California Earthquake Center, Sequences of Earthquakes and Aseismic Slip project). The input and output processing scripts for the first benchmark exercise (BP1) are found in examples/scec_benchmarks/BP1.

Code clean-up and re-structuring

• Prior to the solver step, variables (theta, tau/v, etc.) are merged (packed) into a single variable and passed onto the solver subroutine. After the solver step, the resulting variable is split-up (unpacked) back into the original variables. This process is repeated on various locations in the code with some code duplication. The packing/unpacking procedure is now centralised as a subroutine in utils.f90.
• Pieces of legacy code have been removed, comments/descriptions in the code have been updated.
• Code preparations are made for the implementation of unstructured fault meshes.

Versioning and version control

The QDYN project will rely more heavily on git branches for code version control, each feature/patch being developed on and released from a dedicated branch. Features and bug fixes will be released more frequently and will be accompanied by a version number increment. This way, publications citing the QDYN project can refer to a specific version number.

Bug fixes since version 1.1

• Index bug in domain partitioning that affected parallel (MPI) runs (pull request #8)
• Stress variable now properly initialized. This may have been a bug for some compilers (commit 46ba675)
• Mesh orientation input handling in kernel_calc/qdyn_okada_kernel.m (commit 8e76c65)
• Crack size output now disabled in spring-block simulations (commit 9445b19)

QDYN v1.1

QDYN is a software to simulate quasi-dynamic earthquake cycles on rate-and-state-dependent faults using the boundary element method and adaptive time-stepping.

This release, QDYN v1.1, introduces the following features:

• MPI parallelization for distributed-memory HPC clusters
• Choice between strike-slip and thrust faulting in 3D
• Faults surrounded by damaged zones in 2D

The code was benchmarked with the stable version v1.0.
Other significant modifications include:

• Citable DOI at zenodo.org
• Fixed bug in normal stress coupling
• Fixed inconsistency in 1D infinite kernel