# Loading (`simulation.cfg`

)

## Boundary Conditions

General boundary conditions can be applied (to general domains) by assiging velocities to nodes or node sets. Multi-point constraints are also available, to couple node velocities. RVE-type boundary conditions can also by applied, which are based on RVE-type variables, such as a strain rate.

### General Boundary Conditions

General boundary conditions are velocity conditions applied on specific nodes or node sets defined in the Mesh File (simulation.msh). Any number of conditions can be prescribed as follows:

```
set_bc vel <nset> <direction> <vel> ...
set_bc vel <nset> <direction> <vel>
...
```

where each `set_bc`

line defines a velocity boundary condition, `<nset>`

is the label of a node set (alternatively a node id), `<direction>`

is the direction of the constraint applied to the node set, and `<vel>`

is the velocity applied to the node set in the constraint direction. The options for `<direction>`

are: `<x>`

, `<y>`

or `<z>`

. Up to three `<direction>`

/`<vel>`

pairs can be defined per-line for a given `set_bc`

.

### Multi-Point Constraints (MPCs)

Multi-point constraints link the degrees of freedom of several nodes by a linear relation between nodal velocities of primary and secondary nodes [1]:

\[v_{x,y,z}^s=v_{x,y,z}^p+D_{x,y,z}\]

where \(v_{x,y,z}^s\) and \(v_{x,y,z}^p\) are the velocity on the primary and secondary nodes, respectively and \(D_{x,y,z}\) the velocity offset.

The following (and only) type of MPCs, `mpc1`

, is such that one or several velocity component(s) of all nodes belonging to a node set are equal:

```
set_mpc1 vel <nset> <direction> ...
```

where `<nset>`

is the node set and `<d>`

is the direction (among `x`

, `y`

and `z`

). Up to three directions can be defined per line for a given `set_mpc1 vel <nset>`

.

Any number of conditions can be prescribed as follows:

```
set_mpc1 vel <nset> <direction> ...
set_mpc1 vel <nset> <direction> ...
...
```

MPCs can typically be used to impose that a face should remain planar during a simulation (but not necessarily at the same coordinate). An example of use is provided in Cruciform Specimen Simulation.

### RVE-type Boundary Conditions

RVE-type boundary conditions apply to cubic (or right prisms) domains, for which the loading can typically be defined in terms of (components of the) velocity gradient or strain rate. They may also be applied to to other domains, such as cylinders, or periodic tessellation.
For a cubic domain, the faces are named `x0`

, `y0`

and `z0`

at minimum (typically 0) coordinates, and `x1`

, `y1`

, `z1`

at maximum (typically 1) coordinates. In this section, the minimum-coordinate face is called the *reference* face, while the maximum-coordinate face is called the *loading* face.

To apply strain rates along the sample axes, the input is:

```
set_bc strainrate <component> <strainrate> [ <method> ]
...
```

To apply velocity gradient components (which allows for shear), the input is:

```
set_bc velgrad <component> <velgrad> [ <method> ]
...
```

`<component>`

can be `11`

, `22`

or `33`

for `strainrate`

, and
`11`

, `12`

, `13`

, `21`

, `22`

, `23`

,
`31`

, `32`

or `33`

for `velgrad`

.
The (optional) method argument indicates how to translate the specified velocity gradient or strain rate into actual velocities, on the corresponding faces (other faces are unconstrained). Options for `<method>`

are:

`minimal`

(the default): zero velocity along the loading direction is applied on the reference face, while prescribed velocity along the loading direction is applied on the loading face. Other directions are unconstrained.

`grip`

: fully constrained mode, where zero velocity in all directions is applied on the reference face, while prescribed velocity in the loading direction is applied on the loading face, with 0 velocity in other directions. Note that`grip`

boundary conditions make particular sense when the loading face is not expected to change shape (or surface area), like in pure shear; however, applying`grip`

boundary conditions in different directions will generally result in conflicting velocity conditions (and an error).

`periodic`

: to apply Periodic Boundary Conditions (PBCs) in the case of a periodic tessellation. To use with`set_bc strainrate`

. Available for triaxial traction-compression loading, i.e. non-zero components can be`11`

,`22`

or`33`

. The shear components`12`

(or`21`

),`23`

(or`32`

) and`13`

(or`31`

) must be specified and equal to`0`

. Otherwise explicitly indicated in the simulation, rigid-body motions do not need to be fixed by the user when at least one`periodic`

option is specified in`simulation.cfg`

.

Note

Several `set_bc vel`

, `set_bc strainrate`

and `set_bc velgrad`

inputs can be combined as long as they do not conflict. One or several `set_bc vel`

inputs can for example be used to fix the rigid-body motions that may remain as a result of `set_bc velgrad`

or `set_bc strainrate`

boundary conditions.

## Deformation History (Steps)

A simulation is divided into a series of *steps*. There can be any number of steps, and different types of *targets* can be specified for the steps; however, the same type must be used for all steps. (If the number of steps is not defined, it is determined from the number of provided targets.) The format for specifying steps is as follows:

[ number_of_steps <n> ] [ target_time <time_1> ... <time_n> ] [ target_strain<c> <strain_1> ... <strain_n> ] [ target_load<d> <load_1> ... <load_n> ]

`number_of_steps`

defines the number of steps.
`target_time`

, `target_strain`

and `target_load`

(mutually exclusive) can be used to define the step targets,
where `time`

is the cumulative time,
`strain`

is the `<c>`

component of the engineering strain (among `11`

, `22`

and `33`

),
and
`load`

is the load alond direction `<d>`

(among `1`

, `2`

and `3`

).
If the number of steps is undefined as the targets are specified, it is set to the number of target values.

A step is divided into (time) *increments*. There can be any number of increments within a step, and it can be defined from different variables; however, it must be defined using the same variable for all steps. (For conveninence, if the number of provided values for a parameter is smaller than the number of steps, then the last specified value is used for all next steps.) The format for specifying increments is as follows.

[ number_of_incrs <num_incrs_1> ... <num_incrs_n> ] [ dtime <dtime_1> ... <dtime_n> ] [ dtime_min <dtime_min_1> ... <dtime_min_n> ] [ dstrain <dstrain_1> ... <dstrain_n> ]

All variables are mutually exclusive.
`number_of_incrs`

corresponds to the number of increments,
`dtime`

corresponds to a time increment,
`dtime_min`

corresponds to a minimum time increment (needed by `target_load`

),
and
`dstrain`

corresponds to a strain increment.

Finally, it is possible to specify whether the results should be printed (or not) at the end of the steps (optional, default `1`

):

[ print_results <print_flag_1> ... <print_flag_n> ]

## [LEGACY] Multiaxial

Note

The features described in this section are legacy and will change in a future version.

Multiaxial loading operates on cubic domains, at either a constant engineering strain rate or constant load rate; however, only specific load targets may be prescribed.
The principal loading directions must be aligned with the coordinate axes of the mesh and the surface face normals should likewise be coincident with the coordinate axis of the mesh. Symmetry boundary conditions (zero normal velocities) are enforced on the three faces of minimal coordinates (`<*0>`

), and, in the general case, non-zero normal velocities are applied to the faces of maximal coordinates (`<*1>`

). The velocity on the primary control surface is held constant through the simulation (except during a strain rate jump).

Multiaxial loading with a constant strain rate (CSR) is defined as follows:

```
def_control_by triaxial_constant_strain_rate
number_of_steps <num_steps>
target_csr_load <load_x> <load_y> <load_z> <dt_max> <dt_min> <print_flag>
...
```

where `<num_steps>`

is the number of CSR load steps that are defined in the file after this line, `<load_x>`

is the desired load value to be reached in the `x`

direction, `<load_y>`

is the desired load value to be reached in the `y`

direction, `<load_z>`

is the desired load value to be reached in the `z`

direction, `<dt_max>`

is the maximum time-step value to be used for a given increment, `<dt_min>`

is the minimum time-step value to be used for a given increment, and `<print_flag>`

allows for the printing (or not) of specific steps. The options available for `<print_flag>`

are: `print_data`

or `suppress_data`

.

Strain rate jumps are available for this deformation mode and are defined by adding the following input to the block:

```
number_of_strain_rate_jumps <njumps>
strain_rate_jump <target_step> <new_strain_rate>
...
```

where `<njumps>`

is the number of strain rate jumps defined in the file after this line, `<target_step>`

defines which `target_csr_load`

step is assigned a new strain rate, and `<new_strain_rate>`

is the new strain rate to be assigned and has units of [1/s].

Multiaxial loading with a constant load rate (CLR) is defined as follows:

```
def_control_by triaxial_constant_load_rate
number_of_steps <num_steps>
target_clr_load <load_x> <load_y> <load_z> <target_time_incr> <print_flag>
...
```

where `<num_steps>`

is the number of CLR load steps that are defined in the file after this line, `<load_x>`

is the desired load value to be reached in the `x`

direction, `<load_y>`

is the desired load value to be reached in the `y`

direction, `<load_z>`

is the desired load value to be reached in the `z`

direction, `<target_time_incr>`

is the physical time increment to be reached for the given `target_clr_load`

steps for a given load rate, and `<print_flag>`

allows for the printing (or not) of specific steps. The options available for `<print_flag>`

are: `print_data`

or `suppress_data`

.

Load rate jumps and dwell episodes are available for this deformation mode. A dwell episode maintains the macroscopic loads of the step in which it is defined, but holds the ramp rate at zero for the amount of time defined by `<dwell_time>`

. These options are defined as follows:

For load rate jumps:

number_of_load_rate_jumps <njumps> load_rate_jump <target_step> <new_ramp_rate> ...

where

`<njumps>`

is the number of load rate jumps defined in the file after this line,`<target_step>`

defines which`target_clr_load`

step is assigned a new load rate, and`<new_load_rate>`

is the new load rate to be assigned and has units of [force/s].For dwell episodes:

number_of_dwell_episodes <nepisodes> dwell_episode <target_step> <dwell_time> <target_time_incr> <print_flag> ...

where

`<nepisodes>`

is the number of dwell episodes defined in the file after this line,`<target_step>`

defines which`target_clr_load`

step is assigned to dwell,`<dwell_time>`

is the physical amount of time in [s] for a given dwell episode,`<target_time_incr>`

is the physical time increment to be reached for the given dwell episode, and`<print_flag>`

allows for the printing (or not) of specific steps. The options available for`<print_flag>`

are:`print_data`

or`suppress_data`

.

Multiaxial boundary conditions are generally consistent across modes, however, the input rate type varies depending on the mode. For both modes, the `loading_direction`

defines the primary control direction in which the normal velocities are held constant throughout the simulation.

Multiaxial loading with a constant strain rate (CSR) is defined as follows:

```
boundary_conditions triaxial
loading_direction <sample_dir>
strain_rate <strain_rate>
```

where `<sample_dir>`

is the direction along the positive sample axis in which the sample is loaded, and `<strain_rate>`

is the strain rate value in units of [1/s].

Multiaxial loading with a constant load rate (CLR) is defined as follows:

```
boundary_conditions triaxial
loading_direction <sample_dir>
load_rate <load_rate>
```

where `<sample_dir>`

is the direction along the positive sample axis in which the sample is loaded, and `<load_rate>`

is the loading rate value in units of [force/s].