Supporting data: "How collective asperity detachments nucleate slip at frictional interfaces"

This repository supports:

T.W.J. de Geus, M. Popović, W. Ji, A, Rosso, M. Wyart. How collective asperity detachments nucleate slip at frictional interfaces. Proc. Natl. Acad. Sci. U.S.A. 2019. doi: 10.1073/pnas.1906551116, arXiv: 1904.07635

In particular, it provides all used data, all codes used to produce this data (including clones to all the used open-source libraries), and simple functions to plot the data. All data and code is free to use under the CC-BY-4 license, but: Please cite the above research article when using code or data (inspired) from this repository (or the open-source projects GooseFEM and GMatElastoPlasticQPot), in addition to this dataset (doi: 10.5281/zenodo.3477938).

(c) T.W.J. de Geus | 2019 | contact: [e-mail], www.geus.me

This work is licensed under a Creative Commons Attribution 4.0 International License.

Contents

In brief

Data files

Code

Plots

1. In brief

All codes (codes/) are written in C++ using a number of open-source libraries (libraries/). All data (data/) is stored in the HDF5 format. All plots (data/) are generated using Python and a number of open-source libraries.

All codes are developed and tested on macOS and Linux. The notation used here is consistent with these Unix-based platforms. Windows based compilation and use might differ from the description here.

2. Data files ("data/")

The different ensembles (datasets) are included in different directories in data/. They are distinguished through their directory name that comprises the system size (denoted nx=...) and the shape factor of the Weibull distribution from which the yield strains are drawn (denoted weibull=...).

Each ensemble consists of a number of realisations of the random yield strains at the frictional interface. Each realisation is stored in a separate file (id=xxx.hdf5). This file serves as input for the event-driven code (code/Run/main.cpp). This code stores the displacement field at the end of each event-driven step (for which it may take significant time for energy to be minimised). With these displacement fields, all other quantities (stress, strain, plastic strain, ...) can be reconstructed. The relevant reconstructed data for the entire ensemble is collected in EnsembleInfo.hdf5.

For the manually triggered avalanches at different stresses (and fixed relative strain increment w.r.t. the last system spanning event) only selected output is stored to limit storage usage (code/AvalancheAfterPush...). Please note that the simulations are stopped when an event becomes system spanning to save on computation time, for this case the output thus does not correspond to a state of mechanical equilibrium. By contrast, any simulation that was not system-spanning does correspond to a state of mechanical equilibrium.

2a. Realisation ("data/.../id=xxx.hdf5")

See code code/Run/main.cpp and generation code/Generate/generate.py

Mesh (input)

/coor: Nodal coordinates [nnode, ndim] (ndim == 2)

/conn: Connectivity [nelem, nne] (nne = 4)

/dofs: Degrees-of-freedom (DOF) per node [nnode, ndim]

/iip: Prescribed DOFs [n_iip]

Material model (input)

/elastic/elem: Elastic elements [n_elasic]

/elastic/G: Shear modulus [n_elasic]

/elastic/K: Bulk modulus [n_elasic]

/cusp/elem: Elasto-plastic elements [n_cusp]

/cusp/G: Shear modulus [n_cusp]

/cusp/K: Bulk modulus [n_cusp]

/cusp/epsy: Yield strains [n_cusp, n_potentials]

/uuid: Unique identifier for the realisation

Note that n_elasic + n_cusp == nelem

Simulation (input)

/alpha: Background damping coefficient [nelem] (homogeneous)

/rho: Mass density [nelem] (homogeneous)

/run/dt: Time-step

/run/epsd/kick: Size of the strain kick

/run/epsd/max: Local strain at which to stop

Output

/completed: Completion signal, emitted when /run/epsd/max was reached locally

/stored: Stored event-driven step numbers [n_event]

/t: Time at the end of each event-driven step [n_event]

/kick: Strain kick (yes/no) per event-driven step [n_event]

/disp/...: Nodal displacements per event-driven step [nnode, ndim]

2b. Simulation output ("data/.../EnsembleInfo.hdf5")

See code and help code/EnsembleInfo/main.cpp.

2c. Distribution P(x) ("data/.../EnsembleYieldDistance*.hdf5")

See code and help code/EnsembleYieldDistance_stressControl/main.cpp and EnsembleYieldDistance_strainControl/main.cpp.

2d. Manual triggering of events ("data/.../AvalancheAfterPush*.hdf5")

See code and help code/AvalancheAfterPush_stressControl/main.cpp and code/AvalancheAfterPush_strainControl/main.cpp.

3. Code ("code/")

The relevant codes to generate the datasets are referenced above. All non-standard libraries have been cloned under libraries/. Please note that they are subject to evolution: their cloned versions allow one to rerun the code in this dataset, however, for further development one is strongly encouraged to use the latest version. Please check out the development of:

GooseFEM (v0.2.3)

GMatElastoPlasticQPot (v0.2.1)

cpppath (v0.0.7)

xtensor (v0.20.8)

xtensor-blas (v0.16.1)

xtl (v0.6.5)

xsimd (v7.2.5)

highfive (master)

docopt (master)

fmt (master)

pyxtensor (v0.0.5)

GooseMPL (v0.2.24)

GooseEYE (v0.2.0)

h5py (master)

To compile code, follow the following structure:

cd code/...
mkdir build
cmake ..
make

Then to run use:

./Run ...

(use ./Run --help for help, and/or read the code). For some codes a support function generates commands. They can be generated and run as follows:

python makeJob.py
source commands.txt

4. Plots ("data/.../*.py")

Basic plot functions are included with the datasets. Note that all scripts require numpy, matplotlib, h5py, and GooseMPL to be installed. The latter two are included here, the other two are considered standard.