System for which the average stress is fixed. More...

#include <GooseEPM/System.h>

Inheritance diagram for GooseEPM::SystemStressControl< Dim >:

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

Detailed Description

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

System for which the average stress is fixed.

Failure rules

The distance to yielding locally is \( x_i = (\sigma_y)_i - | \sigma_i | \) for each block \( i \). The dynamics use \( x_i \) to determine which block fails, see below.
If a block \( f \) fails it looses its stress (+ a small random fluctuation): \( \Delta \sigma_f = \sigma_f + \mathcal{N}(0, 0.01) \).

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.

Fixing the average stress

To set the average stress, use set_sigmabar().

Note: To run using a fixed stress, the propagator \( G \) must follow \( \sum\limits_{i = 1}^N G_i = 0 \) (while it is internally required that \( G(\Delta \vec{r} = \vec{0]) = -1 \)). These requirements of the propagator are enforced internally upon construction.

Definition at line 1642 of file System.h.

Constructor & Destructor Documentation

◆ SystemStressControl()

template<size_t Dim>

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

inline

Parameters

propagator	The propagator `[shape]`.
distances	The distance of each row, column, ... of the propagator `[shape(0), ...]`.
sigmay_mean	Mean yield stress for every block `[shape]`.
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.

Definition at line 1650 of file System.h.

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

GooseEPM/System.h

Public Member Functions