System loaded using a spring. More...

#include <GooseEPM/System.h>

Inheritance diagram for GooseEPM::SystemDepinningSpringLoading< Dim >:

Public Member Functions
	SystemDepinningSpringLoading (const array_type::tensor< double, Dim > &propagator, const std::vector< array_type::tensor< ptrdiff_t, 1 > > &distances, const array_type::tensor< double, Dim > &sigmay_std, uint64_t seed, double kframe, double failure_rate=1, double alpha=1.5, bool random_stress=true)
	Important

Detailed Description

template<size_t Dim>
class GooseEPM::SystemDepinningSpringLoading< Dim >

System loaded using a spring.

Failure rules

Blocks fails only in the positive direction. The distance to yielding locally is \( x_i = (\sigma_y)_i - \sigma \) for each block \( i \). The dynamics use \( x_i \) to determine which block fails, see below.
If a block \( f \) fails it looses a fixed stress \( \Delta \sigma_f \equiv 1 \).

Failure

If a block \( f \) fails:

The block looses stress: \( \sigma_f (t + \tau) = \sigma_f (t) - \Delta \sigma_f \) (see above).
The stress in surrounding blocks is changed according to the propagator: \( \sigma (\vec{r}_f + \Delta \vec{r}, t + \tau) = \sigma (\vec{r}_f + \Delta \vec{r}, t) + G(\Delta \vec{r}) \Delta \sigma_f \), with \( \vec{r}_f \) is the position of the failing block and \( \Delta \vec{r} \neq \vec{0} \) the distance to it. Note: the propagator is modified internally, see below.
The plastic strain of the block is increased by: \( \varepsilon^p_f (t + \tau) = \varepsilon^p_f (t) + \Delta \sigma_f / \mu \), where \( \mu \equiv 1 \) is the shear modulus.

Note: In practice the stress of the failing and surrounding blocks is updated in a single step: \( \sigma (\vec{r}_f + \Delta \vec{r}, t + \tau) = \sigma (\vec{r}_f + \Delta \vec{r}, t) + G(\Delta \vec{r}) \Delta \sigma_f \), with \( G(\Delta \vec{r} = \vec{0}) \equiv -1 \). This requirement is enforced internally upon construction.

Dynamics

Which block fails is determined based on the 'temperature', as follows:

"Athermal": One of the unstable ( \( x < 0 \)) blocks fails.
"Thermal": The blocks with the smallest time to failure fails. For unstable blocks the time to failure is \( \tau \), for stable blocks it is \( \tau \exp( x^\alpha / T ) \).
- SystemBase::makeThermalFailureStep
- SystemBase::makeThermalFailureSteps
(Only available for thermal systems.)
"Extreme Dynamics": Assume that the temperature \( T = 0^+ \). Consequently, the difference in failure times are so great that the weakest block (for which \( x = \min(x) \)) always fails.

Dimension

The dimensionality of the system is the template parameter Dim. In the Python API the system is pre-compiled in all available dimensions. For example:

 // C++
 GooseEPM::SystemStressControl<2> system(...);

 # Python
 system = GooseEPM.SystemStressControl2(...)

Initialisation

By default the stress is chosen randomly (from normal distribution with mean 0 and standard deviation 0.1) according to compatibility, and the system is relaxed to being stable. For customisation you can (in Python code):

 system = System(..., random_stress=False)
 system.sigma = ...
 ...

Since initialisation can be a expensive, you can also use the above to re-use the same initial stress distribution in multiple simulations.

Athermal-quasistatic (AQS)

Elastic loading: SystemBase::shiftImposedShear

Internal details: Equilibrium is preserved during elastic loading. As such \( k_{frame} (\Delta \varepsilon_{frame} - \Delta \varepsilon_i) = \mu \Delta \varepsilon_i \) for all \( i \). The frame is therefore advanced by \( \Delta \varepsilon_{frame} = (k_{frame} + \mu) / k_{frame} \Delta \varepsilon_i \), where \( \Delta \varepsilon_i = (\sigma_f^y - \sigma_f + \epsilon) / \mu \), with \( f \) the index of the softest block.
Energy minimisation: SystemBase::relaxAthermal

Internal details: The propagator \( G \) is modified to be stress-preserving: \( \sum\limits_{i = 1}^N G_i = 0 \) and \( G(\Delta \vec{r} = \vec{0}) = -1 \).

Consequently, if a block fails, the average strain changes by \( \Delta \bar{\varepsilon} = 1 / N \sum\limits_{i = 1}^N (\Delta \varepsilon_i^p + \Delta \sigma_i / \mu) \). Since \( \sum\limits_{i = 1}^N \Delta \sigma_i = 0 \) by construction and \( \Delta \varepsilon_i^p \) is non-zero only for the failing block, the change in average strain is \( \Delta \bar{\varepsilon} = \Delta \varepsilon_f^p / N \). Consequently, the stress due to driving reduces by \( \Delta \bar{\sigma} = k_{frame} \Delta \bar{\varepsilon} = k_{frame} \Delta \varepsilon_f^p / N \).

Definition at line 1866 of file System.h.

Constructor & Destructor Documentation

◆ SystemDepinningSpringLoading()

template<size_t Dim>

GooseEPM::SystemDepinningSpringLoading< Dim >::SystemDepinningSpringLoading	(	const array_type::tensor< double, Dim > &	propagator,
		const std::vector< array_type::tensor< ptrdiff_t, 1 > > &	distances,
		const array_type::tensor< double, Dim > &	sigmay_std,
		uint64_t	seed,
		double	kframe,
		double	failure_rate = `1`,
		double	alpha = `1.5`,
		bool	random_stress = `true`
	)

inline

Important

Difference compared to the regular elasto-plastic model:

Failure at negative stress is not allowed. This corresponds to the definition of stability \( x_i = (\sigma_y)_i - \sigma_i \). Note that this 'overwrites' any other mentions in the documentation.
Yield stresses: \( p(\sigma_y) = | \mathcal{N}(0, s) | \), where \( s = \) sigmay_std.
Stress drop of the failing block always equal to 1.

Parameters

propagator	The propagator `[shape]`.
distances	The distance of each row, column, ... of the propagator `[shape(0), ...]`.
sigmay_std	Standard deviation of the yield stress for every block `[shape]`.
seed	Seed of the random number generator.
failure_rate	Failure rate \( f_0 \).
alpha	Exponent characterising the shape of the potential.
random_stress	Initialise the stress: random, zero mean, no unstable blocks.
kframe	Stiffness of the driving 'spring'.

Definition at line 1877 of file System.h.

The documentation for this class was generated from the following file:

GooseEPM/System.h

Public Member Functions