Loading (simulation.cfg)#
The loading is defined in two independent parts: the boundary conditions, which choose the
constrained nodes and degrees of freedom (boundary_conditions), and the deformation
history, a sequence of steps written as per-step rows. Velocities are in mm/s, strain
rates in 1/s, times in s.
Terminology#
A simulation is organized in nested levels:
the run: the whole simulation, a sequence of steps;
a step: a part of the deformation history with its own target (a strain or a time) and rate, and whose results can be written (
print_results);an increment: a time increment of a step (
number_of_incrs,dtimeordstrain); the velocities, stresses and orientations are solved for at the end of each increment;a global iteration: one iteration of the solution of an increment for its velocities (successive approximation or Newton–Raphson; keywords
global_..., see Solver Parameters (simulation.cfg)); each solves a linear system (cg_...);a point solve: at each global iteration, the solution for the stress at every quadrature point (keywords
point_...).
With crystal plasticity, the run starts by default with a small, unwritten elastic step that is
part of step 1, or with an isotropic viscoplastic start (initialization, see
Solver Parameters (simulation.cfg)).
Boundary Conditions#
boundary_conditions <type>
where <type> is a preset for cubic (right-prism) domains, uniaxial_grip,
uniaxial_symmetry, uniaxial_minimal or triaxial, or general for velocity
conditions given node set by node set, or periodic for periodic conditions on a periodic
mesh (Periodic conditions).
- boundary_conditions#
The boundary conditions: a preset for cubic domains (
uniaxial_grip,uniaxial_symmetry,uniaxial_minimal,triaxial),general(velocities on node sets,set_bc) orperiodic(a periodic mesh).- Values:
one of
uniaxial_grip,uniaxial_symmetry,uniaxial_minimal,triaxial,general,periodic- Default:
required
- Given:
once, for the whole run
Note
periodic_kinematicsandperiodic_preconditionerare used only withboundary_conditions periodic.The shear components (
23,13,12,32,31,21) ofstrain_rate,target_strain,target_load,target_stress,load_rate,stress_rateandcontrol_componentare used only withboundary_conditions periodic.strain_rate,load_rateandstress_ratecannot be used withboundary_conditions general(the velocities are given by theset_bclines).set_bccannot be used withboundary_conditions uniaxial_grip,uniaxial_symmetry,uniaxial_minimalortriaxial(the preset sets the velocities).Multi-point constraints (
set_mpc,set_mpc1) cannot be used withboundary_conditions periodic.Multi-point constraints (
set_mpc,set_mpc1) cannot be used withboundary_conditions triaxial.target_load,target_stress,load_rateandstress_ratecannot be used withboundary_conditions periodic(no macroscopic load or stress control).control_componentcannot be used withboundary_conditions general(the velocities are given by theset_bclines).check_necking oncannot be used withboundary_conditions periodic(no face loads).cg_preconditioner block_jacobiandnonecannot be used withboundary_conditions periodic(onlyjacobi).print forcesis ignored withboundary_conditions periodic(no face forces file; the macroscopic stress is written to results/macro).
Presets#
The presets apply to domains whose faces are the node sets x0, y0, z0 (minimum
coordinates) and x1, y1, z1 (maximum coordinates), as Neper writes them; corners
are the node sets x<i>y<j>z<k>. The loading axis \(a\) of a uniaxial preset is the
component of its loading rows (11: \(x\), 22: \(y\), 33: \(z\));
\(b\) and \(c\) are the next axes in cyclic order (for \(a = z\): \(b = x\),
\(c = y\)). The loading face \(a_1\) moves along \(a\) at the strain rate times the
original length of the domain along \(a\).
uniaxial_grip: face \(a_0\) fixed (all three components zero); face \(a_1\) moving along \(a\), with zero velocity along \(b\) and \(c\).uniaxial_symmetry: zero normal velocity on the faces \(a_0\), \(b_0\) and \(c_0\); face \(a_1\) moving along \(a\). The other faces are free.uniaxial_minimal: zero velocity along \(a\) on face \(a_0\); face \(a_1\) moving along \(a\); and the rigid-body motions removed by the corner at the origin (zero velocity along \(b\) and \(c\)) and the corner at coordinate 1 along \(b\) (zero velocity along \(c\)).triaxial: zero normal velocity on the facesx0,y0andz0; on each facex1,y1,z1of a component with loading rows, a normal velocity equal to that component’s strain rate times the original length; a face whose component has no rows is free. Requirescontrol_component(below). The control component may end its steps at load or stress targets, and the other components may be load-controlled (Triaxial load control): their faces then move at the uniform normal velocity that gives the prescribed load or stress.
General Conditions#
With boundary_conditions general, velocities are prescribed on node sets of the mesh (or on
single nodes, by node id):
set_bc vel <nset> <direction> <velocity> [ <direction> <velocity> ... ]
...
where <direction> is x, y or z; up to three direction/velocity pairs per line;
any number of lines. A degree of freedom given two velocities is an error. The set_bc
velocities are the loading: no rate rows are given.
- set_bc#
A velocity condition of
boundary_conditions general:vel, a node set (or a node id), then up to three pairs of a direction (x,y,z) and a velocity [mm/s]. Withperiodicconditions, on independent degrees of freedom only (Periodic conditions).- Values:
vel <nset> <d> <v> [<d> <v> [<d> <v>]]: a node set (or a node id), then one to three pairs of a directionx,yorzand a velocity; the line may be repeated- Unit:
mm/s
- Given:
once, for the whole run
Note
set_bccannot be used withboundary_conditions uniaxial_grip,uniaxial_symmetry,uniaxial_minimalortriaxial(the preset sets the velocities).
Multi-Point Constraints#
A multi-point constraint (MPC) ties one velocity component of every node of a node set to that of the set’s first node (as the mesh file lists it), the primary; the other nodes are its secondaries:
set_mpc1 vel <nset> <direction> [ <direction> [ <direction> ] ]
set_mpc vel <nset> <direction> <coefficient> <offset> [ ... ]
set_mpc1 makes the component equal on the whole node set (e.g. set_mpc1 vel x1 x keeps
face x1 planar). set_mpc gives every secondary \(s\)
\(v_s = c\,v_p + d\), with a nonzero coefficient \(c\) and an offset \(d\) [mm/s],
for up to three direction/coefficient/offset triples per line; the offset is constant over the
run. Any number of lines; one relation per node set and direction. A primary may itself be a
secondary of another line (a chain): it is followed to the top primary, with the coefficients
multiplied and the offsets composed.
- set_mpc1#
A multi-point constraint that makes velocity components equal on a node set:
vel, the node set, then one to three directions.- Values:
vel <nset> <d> [<d> [<d>]]: a node set, then one to three directionsx,yorz; the line may be repeated- Given:
once, for the whole run
Note
Multi-point constraints (
set_mpc,set_mpc1) cannot be used withboundary_conditions periodic.Multi-point constraints (
set_mpc,set_mpc1) cannot be used withboundary_conditions triaxial.Multi-point constraints (
set_mpc,set_mpc1) cannot be used with load or stress targets or rates (target_load,target_stress,load_rate,stress_rate: load control).cg_preconditioner block_jacobiandnonecannot be used with multi-point constraints (set_mpc,set_mpc1: onlyjacobi).
- set_mpc#
A multi-point constraint \(v_s = c\,v_p + d\) on a node set:
vel, the node set, then up to three triples of a direction, a nonzero coefficient \(c\) and an offset \(d\) [mm/s].- Values:
vel <nset> <d> <c> <o> [...]: a node set, then one to three triples of a directionx,yorz, a nonzero coefficient and an offset; the line may be repeated- Unit:
mm/s
- Given:
once, for the whole run
Note
Multi-point constraints (
set_mpc,set_mpc1) cannot be used withboundary_conditions periodic.Multi-point constraints (
set_mpc,set_mpc1) cannot be used withboundary_conditions triaxial.Multi-point constraints (
set_mpc,set_mpc1) cannot be used with load or stress targets or rates (target_load,target_stress,load_rate,stress_rate: load control).cg_preconditioner block_jacobiandnonecannot be used with multi-point constraints (set_mpc,set_mpc1: onlyjacobi).
A velocity condition (
set_bc vel, or a preset’s) on any node of a group fixes the group: every node then moves as the relation gives. Conditions on two nodes of a group that the relation cannot both satisfy are an error.A node that two lines make a secondary is an error, unless both give the same relation (the same primary, coefficient and offset). In Neper’s meshes two faces’ node sets start with their common corner (
x1andy1both withx1y1z0), soset_mpc1 vel x1 xandset_mpc1 vel y1 xare accepted. A cycle of relations is an error.MPCs are available with
boundary_conditions generaland the uniaxial presets at strain rates; they cannot be used withtriaxial, with load or stress targets or rates, or with periodic conditions (Periodic conditions).
The equations are solved for the primary and unconstrained degrees of freedom only (master–slave elimination; Solver Parameters (simulation.cfg)); the results are written for every node, as without MPCs. The step-0 velocities already satisfy the constraints.
Periodic Conditions#
With boundary_conditions periodic the domain is a periodic representative volume: the mesh
must have a $Periodicity section (Neper: neper -T ... -periodicity all, then
neper -M), periodic along all three axes. Such meshes are usually tessellations whose grains
cross the domain boundary, so the boundary is not planar; nothing in the periodic conditions
uses faces, node sets or the bounding box. Each relation ties a secondary node \(s\) to a
primary node \(p\) with \(\mathbf x_s = \mathbf x_p + \mathbf P \circ \mathbf l\)
(\(P_j \in \{-1, 0, 1\}\), \(\mathbf l\) the domain lengths), and imposes
where \(\dot{\bar{\mathbf F}}\) is the rate of the macroscopic deformation gradient (on the
reference periodicity vectors, so that the velocity jumps are constant at constant rate). Each
component of \(\dot{\bar{\mathbf F}}\) is imposed (a strain_rate row) or free (no
row: its macroscopic stress component is zero). The stress that vanishes is the one conjugate to
\(\dot{\bar{\mathbf F}}\), the nominal (first Piola–Kirchhoff) stress \(\bar{\mathbf
P} = J\,\bar{\boldsymbol\sigma}\,\bar{\mathbf F}^{-\mathsf T}\) of the volume-averaged Cauchy
stress written in results/macro (with small_strain, \(P_{ij} + P_{ji}\) of a free
shear pair); the written Cauchy component of a free direction is then not exactly zero under
shear, but of the order of the shear stress times the strain:
boundary_conditions periodic
periodic_kinematics small_strain | deformation_gradient_rate (default small_strain)
control_component <ij>
strain_rate <ij> <rate> ... <rate> (one row per imposed component)
target_strain <ij> <value> ... <value> (the control component only)
small_strain: \(\dot{\bar{\mathbf F}}\) is symmetric; the components are11 22 33 23 13 12and a shear row imposes \(ij\) and \(ji\) (one value, the tensor component).deformation_gradient_rate: the nine components11 12 13 21 22 23 31 32 33. A shear pair with both \(ij\) and \(ji\) free leaves a rigid rotation rate free: allowed with a warning, but the solution is then usually not unique (the run may not converge); impose one of the two.An imposed component has a value in every step (
-is not allowed); the rates may change from step to step.control_component(required) is an imposed component; its owntarget_strain(a component of \(\bar{\mathbf F} - \mathbf I\)), ortarget_timeortarget_duration, ends each step, with the increments of a uniaxial step (dstrainon the control component’s rate). No load or stress targets or rates; no multi-point constraints; nocheck_necking.The macroscopic deformation gradient and its rate are those of the drive pairs: for each axis \(j\), the first relation of the file with vector \(\pm\mathbf e_j\); the lengths \(l_j\) are their initial separations. A free component is carried by its drive pair’s velocities (one unknown per free component; with
small_strainone per free shear pair).Rigid translation: no node is fixed; the fluctuation \(\mathbf v - \dot{\bar{\mathbf F}}\mathbf X\) has zero mean over the initial volume (with the consistent nodal weights), as in the formulation of F. Villette et al. (in preparation).
set_bc velconditions may be given on independent degrees of freedom (an interior or primary node, a drive pair’s primary node); they are applied as given, not carried through the relations. A condition on a constrained degree of freedom (a secondary node, or the drive dof of an imposed component) is an error. A velocity component with a condition is not shifted to the zero mean.periodic_preconditioner lumped_diagonal | exact_diagonal(defaultlumped_diagonal): the Jacobi diagonal of the reduced system, lumped (the element diagonals summed onto the primary degrees of freedom) or the exact one (Solver Parameters (simulation.cfg)). It changes only the number of conjugate-gradient iterations.Output:
results/macro(Simulation Results (simulation.cfg)); the face forces file is not written (print forcesgives a warning).
- periodic_kinematics#
The kinematics of periodic conditions:
small_strain(a symmetric \(\dot{\bar{\mathbf F}}\), components11 22 33 23 13 12) ordeformation_gradient_rate(the nine components).- Values:
one of
small_strain,deformation_gradient_rate- Default:
small_strain- Given:
once, for the whole run
Note
periodic_kinematicsandperiodic_preconditionerare used only withboundary_conditions periodic.The components
32,31and21ofstrain_rate,target_strainandcontrol_componentcannot be used withperiodic_kinematics small_strain(it takes the shear components 23, 13 and 12, one per pair;deformation_gradient_ratetakes the nine components).
- periodic_preconditioner#
The Jacobi diagonal of the reduced system with periodic conditions:
lumped_diagonalorexact_diagonal. It changes only the number of conjugate-gradient iterations.- Values:
one of
lumped_diagonal,exact_diagonal- Default:
lumped_diagonal- Given:
once, for the whole run
Note
periodic_kinematicsandperiodic_preconditionerare used only withboundary_conditions periodic.
Deformation History (Steps)#
The simulation is divided into steps; each step reaches a target at a given rate, in one or
several time increments. Each loading row starts with its component (11, 22 or
33), followed by one value per step; - marks a step where the row is not used:
number_of_steps <n>
# comp step 1 ... step n
strain_rate <c> <rate> ... <rate>
[ load_rate <c> <rate> ... <rate> ]
[ stress_rate <c> <rate> ... <rate> ]
target_strain <c> <strain> ... <strain>
[ target_load <c> <load> ... <load> ]
[ target_stress <c> <stress> ... <stress> ]
[ target_time <time> ... <time> ]
[ target_duration <time> ... <time> ]
number_of_incrs | dtime | dstrain <value> ... <value>
[ dtime_min <time> ... <time> ]
[ print_results <flag> ... <flag> ]
Each step has exactly one target, of any kind (- in the other target rows): the steps of a
run may mix strain, load, stress and time targets.
target_strain <c>: the engineering strain of component<c>at the end of the step (cumulative).target_load <c>,target_stress <c>: a load or stress target (see Load and stress targets).target_time: the time at the end of the step (cumulative).target_duration: the length of the step from its actual start [s] (not with a load or stress target of the control component, which ends the step).strain_rate <c>: the engineering strain rate of component<c>during the step. Its sign must move the strain towards the target; a rate that changes sign between steps unloads.load_rate <c>,stress_rate <c>: a constant load [N/s] or stress [MPa/s] rate (see Load and stress rates, dwells).One of
number_of_incrs(the number of increments),dtime(the time increment) ordstrain(the strain increment of the control component) per step. Withdtimeordstrainthat do not divide the step, the last increment is shorter and ends the step exactly on its target, with a warning.print_results:1(default) writes the results at the end of the step,0does not. The initial state (step 0) is always written.
- number_of_steps#
The number of steps of the run: every per-step row gives this many values.
- Values:
integer >= 1
- Default:
required
- Given:
once, for the whole run
- strain_rate#
The engineering strain rate [1/s] of a component in each step: the component, then one value per step (
-where the component has another row in the step).- Values:
a component, then real, one value per step (
-for a step without a value)- Unit:
1/s
- Given:
once, for the whole run
Note
The shear components (
23,13,12,32,31,21) ofstrain_rate,target_strain,target_load,target_stress,load_rate,stress_rateandcontrol_componentare used only withboundary_conditions periodic.The components
32,31and21ofstrain_rate,target_strainandcontrol_componentcannot be used withperiodic_kinematics small_strain(it takes the shear components 23, 13 and 12, one per pair;deformation_gradient_ratetakes the nine components).strain_rate,load_rateandstress_ratecannot be used withboundary_conditions general(the velocities are given by theset_bclines).dstrainis used only with astrain_rateon the control component (not in a step at aload_rateorstress_rate: givenumber_of_incrsordtime).
- target_strain#
The engineering strain of a component at the end of each step (cumulative): the component, then one value per step.
- Values:
a component, then real, one value per step (
-for a step without a value)- Given:
once, for the whole run
Note
The shear components (
23,13,12,32,31,21) ofstrain_rate,target_strain,target_load,target_stress,load_rate,stress_rateandcontrol_componentare used only withboundary_conditions periodic.The components
32,31and21ofstrain_rate,target_strainandcontrol_componentcannot be used withperiodic_kinematics small_strain(it takes the shear components 23, 13 and 12, one per pair;deformation_gradient_ratetakes the nine components).check_necking onis used only with a loaded component (atarget_strain,target_loadortarget_stressrow; the load of its face x1, y1 or z1 is checked).
- target_time#
The time at the end of each step [s] (cumulative).
- Values:
real > 0, one value per step (
-for a step without a value)- Unit:
s
- Given:
once, for the whole run
- target_duration#
The length of each step from its actual start [s].
- Values:
real > 0, one value per step (
-for a step without a value)- Unit:
s
- Given:
once, for the whole run
- number_of_incrs#
The number of increments of each step (one of
number_of_incrs,dtimeanddstrainper step).- Values:
integer >= 1, one value per step (
-for a step without a value)- Default:
required (or dtime, dstrain)
- Given:
once, for the whole run
Note
number_of_incrscannot be used with a load or stress target at a strain rate, or a strain target at a load or stress rate (the duration of the step is not known: givedtimeordstrain(the largest increment) anddtime_min).number_of_incrscannot be used with a dwell (a step withload_rate 0orstress_rate 0on the control component: givedtime, its largest increment; its increments followmax_strain_incr).
- dtime#
The time increment of each step [s]; in a step whose duration is not known (a load or stress target), the largest increment.
- Values:
real > 0, one value per step (
-for a step without a value)- Unit:
s
- Default:
required (or number_of_incrs, dstrain)
- Given:
once, for the whole run
- dstrain#
The strain increment of the control component in each step; in a step whose duration is not known, the largest increment.
- Values:
real > 0, one value per step (
-for a step without a value)- Default:
required (or number_of_incrs, dtime)
- Given:
once, for the whole run
Note
dstrainis used only with astrain_rateon the control component (not in a step at aload_rateorstress_rate: givenumber_of_incrsordtime).
- print_results#
1: the results are written at the end of the step;0: they are not. One value per step.- Values:
integer from 0 to 1, one value per step
- Default:
1- Given:
once, for the whole run
Load and Stress Targets#
A step can end at a load instead of a strain. The load of component <c> is the
<c> component of the force on the face x1, y1 or z1 of that axis (as written in
results/forces; tension is positive) [N]; the stress is that force divided by the
face’s current area [MPa]. Load and stress targets of the other components are described in
Triaxial load control. The step runs at its strain rate (with general conditions: the
set_bc velocities, reversed when the target is below the current value) until the first
increment whose value is within the tolerance \(\delta\) of the target, \(\delta_F\) =
load_tol [N] for loads and \(\delta_\sigma\) = stress_tol [MPa] for stresses (absolute,
greater than 0, default 0.1 each); its results are those of that increment,
and the log reports the value reached. The step lands on its target: an increment that
passes the target by more than \(\delta\) is discarded (coordinates, velocities and state
restored) and solved again with a shorter time increment, found by false position between the
start of the increment and the attempts made (the time increment of the next attempt is where
the straight line through the bracketing attempts reaches the target), until an attempt ends
within the tolerance; only that attempt counts in the time, the increments and the output.
max_bc_iter (default 10) limits the attempts of an increment; beyond it the run writes the
last accepted increment as the current step and stops with an error. The log reports each
attempt and the number of attempts that landed. Since the step’s duration is not known in
advance:
the increments are given by
dtime(ordstrain), the largest increment, anddtime_min, the smallest, which is required in every load or stress target step (-in the other steps);number_of_incrscannot be used;near the target, the next increment is the time the last increment’s load rate needs to reach the target, times
dtime_factor(default 1.001, at least 1: aim slightly past the target), kept betweendtime_minanddtime; the landing attempts are not bound bydtime_minanddtime_factor;the strain rate’s sign must move the value towards the target (a positive strain rate is taken to increase the load); as the value at the start of a step is known only during the run (after a strain step it is the load reached; after a load step, the target within its tolerance), this is checked when the step starts, and before the run where possible; a target within its tolerance of the value at the start of its step is an error;
before the run, a load (stress) target of step 1 must be more than \(\delta\) from 0, and consecutive load (stress) targets more than \(2\delta\) apart (each step ends within \(\delta\) of its target, so the next step then starts more than \(\delta\) from its own);
under
triaxial, the other components with rows give astrain_rate, atarget_loador atarget_stressin such a step (atarget_strainwould need the step’s duration);the steps after a load or stress target start from the time and strains reached, and are planned when they start.
- target_load#
The load [N] of a component at the end of each step: the component, then one value per step. Of the control component, it ends the step; of another component (
triaxial), it is the end of the load path (Triaxial load control).- Values:
a component, then real, one value per step (
-for a step without a value)- Unit:
N
- Given:
once, for the whole run
Note
The shear components (
23,13,12,32,31,21) ofstrain_rate,target_strain,target_load,target_stress,load_rate,stress_rateandcontrol_componentare used only withboundary_conditions periodic.Multi-point constraints (
set_mpc,set_mpc1) cannot be used with load or stress targets or rates (target_load,target_stress,load_rate,stress_rate: load control).target_load,target_stress,load_rateandstress_ratecannot be used withboundary_conditions periodic(no macroscopic load or stress control).stress_ratecannot be used with atarget_loadof the same component in the same step (astress_rateends at atarget_stress,target_strain,target_timeortarget_duration).dtime_factoris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).load_tolis used only with atarget_loadorload_raterow.max_bc_iteris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).min_pert_fracis used only with atarget_loadortarget_stressrow on a component other than the control component, or aload_rateorstress_raterow.dtime_minis used only with a load or stress target at a strain rate, or a strain target at a load or stress rate (give “-” for the other steps).number_of_incrscannot be used with a load or stress target at a strain rate, or a strain target at a load or stress rate (the duration of the step is not known: givedtimeordstrain(the largest increment) anddtime_min).check_necking onis used only with a loaded component (atarget_strain,target_loadortarget_stressrow; the load of its face x1, y1 or z1 is checked).
- target_stress#
As
target_load, for the stress [MPa]: the load over the face’s current area.- Values:
a component, then real, one value per step (
-for a step without a value)- Unit:
MPa
- Given:
once, for the whole run
Note
The shear components (
23,13,12,32,31,21) ofstrain_rate,target_strain,target_load,target_stress,load_rate,stress_rateandcontrol_componentare used only withboundary_conditions periodic.Multi-point constraints (
set_mpc,set_mpc1) cannot be used with load or stress targets or rates (target_load,target_stress,load_rate,stress_rate: load control).target_load,target_stress,load_rateandstress_ratecannot be used withboundary_conditions periodic(no macroscopic load or stress control).load_ratecannot be used with atarget_stressof the same component in the same step (aload_rateends at atarget_load,target_strain,target_timeortarget_duration).dtime_factoris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).stress_tolis used only with atarget_stressorstress_raterow.max_bc_iteris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).min_pert_fracis used only with atarget_loadortarget_stressrow on a component other than the control component, or aload_rateorstress_raterow.dtime_minis used only with a load or stress target at a strain rate, or a strain target at a load or stress rate (give “-” for the other steps).number_of_incrscannot be used with a load or stress target at a strain rate, or a strain target at a load or stress rate (the duration of the step is not known: givedtimeordstrain(the largest increment) anddtime_min).check_necking onis used only with a loaded component (atarget_strain,target_loadortarget_stressrow; the load of its face x1, y1 or z1 is checked).
- dtime_min#
The smallest time increment [s] of each step whose duration is not known (
-in the other steps); at mostdtime.- Values:
real > 0, one value per step (
-for a step without a value)- Unit:
s
- Default:
required (unknown step duration)
- Given:
once, for the whole run
Note
dtime_minis used only with a load or stress target at a strain rate, or a strain target at a load or stress rate (give “-” for the other steps).
- dtime_factor#
The factor (at least 1) on the time the last increment’s rate needs to reach the target, which gives the next increment near a target.
- Values:
real >= 1
- Default:
1.001- Given:
once, for the whole run
Note
dtime_factoris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).
- load_tol#
The tolerance \(\delta_F\) [N] of the loads (targets and load-controlled values).
- Values:
real > 0
- Unit:
N
- Default:
0.1- Given:
once, for the whole run
Note
load_tolis used only with atarget_loadorload_raterow.
- stress_tol#
The tolerance \(\delta_\sigma\) [MPa] of the stresses.
- Values:
real > 0
- Unit:
MPa
- Default:
0.1- Given:
once, for the whole run
Note
stress_tolis used only with atarget_stressorstress_raterow.
- max_bc_iter#
The largest number of landing attempts of an increment, and of iterations of each loop of the boundary-velocity iteration.
- Values:
integer >= 1
- Default:
10- Given:
once, for the whole run
Note
max_bc_iteris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).
Example: loading to 1 % strain, unloading to zero stress, reloading to 1.2 % strain:
boundary_conditions uniaxial_grip
number_of_steps 3
strain_rate 33 0.01 -0.01 0.01
target_strain 33 0.010 - 0.012
target_stress 33 - 0.0 -
number_of_incrs 10 - 4
dtime - 0.05 -
dtime_min - 0.001 -
Load and Stress Rates, Dwells#
The control component can be driven at a constant load rate (load_rate <c> [N/s]) or
stress rate (stress_rate <c> [MPa/s], of the load over the face’s current area) instead
of a strain rate (constant load rate). Its face velocity is then found in
every increment so that its load (stress) has its value at the end of the increment, within
load_tol (stress_tol), by an iteration (see below). With a uniaxial preset the
loaded component is driven this way; with triaxial the other components may be
strain-controlled, free or load-controlled (Triaxial load control). general conditions
take no rate rows. A load_rate ends at:
a
target_load(astress_rateat atarget_stress): the step lasts \(|q^* - q_\mathrm{start}|/|\dot q|\) from the value at its start, and its increments are given as for a strain target (number_of_incrs, ordtimewith a shorter last increment); the rate’s sign must move the value towards the target (checked before the run where possible, else when the step starts), and the target must not be within the tolerance of the start value; before the run, step 1’s target must be more than \(\delta\) from 0 and consecutive targets more than \(2\delta\) apart, as for load targets;a
target_timeortarget_duration: the rate holds until that time;a
target_strain: the step ends at the first increment that reaches the strain of the control component’s face (its duration is not known:dtimeanddtime_mingive the largest and smallest increments, the next increment aimed at the target as for a load target,dtime_factor); the rate’s sign must move the strain towards it (a positive rate increases the strain). The other components then take rates only (strain_rate,load_rate,stress_rate).
A rate 0 is a dwell: the value is held for the step’s target_time or
target_duration (a target cannot be reached at rate 0); step 1 cannot be a dwell (the load
starts at 0). Its increments: dtime (required; not number_of_incrs or
dstrain) is the largest increment; the first increment of a dwell that follows a step that
is not a dwell is 0.01 dtime; then each increment is the time in which the control face, at
its last velocity, moves by max_strain_incr (default 0.001) times its original length, at
most dtime; the last increment ends the dwell at its time exactly. A dwell above yield
shows creep (the load held, the strain increasing); below yield the velocities vanish.
The components other than the control component may give a load_rate or stress_rate
too: their value then moves from its value at the start of the step at that rate (rate 0
holds it).
- load_rate#
The load rate [N/s] of a component in each step: the component, then one value per step;
0is a dwell.- Values:
a component, then real, one value per step (
-for a step without a value)- Unit:
N/s
- Given:
once, for the whole run
Note
The shear components (
23,13,12,32,31,21) ofstrain_rate,target_strain,target_load,target_stress,load_rate,stress_rateandcontrol_componentare used only withboundary_conditions periodic.strain_rate,load_rateandstress_ratecannot be used withboundary_conditions general(the velocities are given by theset_bclines).Multi-point constraints (
set_mpc,set_mpc1) cannot be used with load or stress targets or rates (target_load,target_stress,load_rate,stress_rate: load control).target_load,target_stress,load_rateandstress_ratecannot be used withboundary_conditions periodic(no macroscopic load or stress control).load_ratecannot be used with atarget_stressof the same component in the same step (aload_rateends at atarget_load,target_strain,target_timeortarget_duration).dtime_factoris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).load_tolis used only with atarget_loadorload_raterow.max_bc_iteris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).min_pert_fracis used only with atarget_loadortarget_stressrow on a component other than the control component, or aload_rateorstress_raterow.max_strain_incris used only with a dwell (a step withload_rate 0orstress_rate 0on the control component).dtime_minis used only with a load or stress target at a strain rate, or a strain target at a load or stress rate (give “-” for the other steps).number_of_incrscannot be used with a load or stress target at a strain rate, or a strain target at a load or stress rate (the duration of the step is not known: givedtimeordstrain(the largest increment) anddtime_min).number_of_incrscannot be used with a dwell (a step withload_rate 0orstress_rate 0on the control component: givedtime, its largest increment; its increments followmax_strain_incr).
- stress_rate#
The stress rate [MPa/s] of a component in each step, as
load_rate.- Values:
a component, then real, one value per step (
-for a step without a value)- Unit:
MPa/s
- Given:
once, for the whole run
Note
The shear components (
23,13,12,32,31,21) ofstrain_rate,target_strain,target_load,target_stress,load_rate,stress_rateandcontrol_componentare used only withboundary_conditions periodic.strain_rate,load_rateandstress_ratecannot be used withboundary_conditions general(the velocities are given by theset_bclines).Multi-point constraints (
set_mpc,set_mpc1) cannot be used with load or stress targets or rates (target_load,target_stress,load_rate,stress_rate: load control).target_load,target_stress,load_rateandstress_ratecannot be used withboundary_conditions periodic(no macroscopic load or stress control).stress_ratecannot be used with atarget_loadof the same component in the same step (astress_rateends at atarget_stress,target_strain,target_timeortarget_duration).dtime_factoris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).stress_tolis used only with atarget_stressorstress_raterow.max_bc_iteris used only with atarget_loadortarget_stress(or aload_rateorstress_raterow).min_pert_fracis used only with atarget_loadortarget_stressrow on a component other than the control component, or aload_rateorstress_raterow.max_strain_incris used only with a dwell (a step withload_rate 0orstress_rate 0on the control component).dtime_minis used only with a load or stress target at a strain rate, or a strain target at a load or stress rate (give “-” for the other steps).number_of_incrscannot be used with a load or stress target at a strain rate, or a strain target at a load or stress rate (the duration of the step is not known: givedtimeordstrain(the largest increment) anddtime_min).number_of_incrscannot be used with a dwell (a step withload_rate 0orstress_rate 0on the control component: givedtime, its largest increment; its increments followmax_strain_incr).
- max_strain_incr#
The strain of the control face (times its original length) by which each increment of a dwell moves it, at most
dtime.- Values:
real > 0
- Default:
0.001- Given:
once, for the whole run
Note
max_strain_incris used only with a dwell (a step withload_rate 0orstress_rate 0on the control component).
The iteration has two loops, each at most
max_bc_iter (default 10) iterations, after which the run stops with an error naming the
loop. The first scales every load-controlled face velocity until the control value is within
\(\max(\delta, 0.1\,|q^* - q_\mathrm{init}|)\) of its value (the factor 1.1, or 0.9 in a
dwell, then a secant through the last two solves); it stops after its first solve at the start
of a dwell or of a reload, in an unloading step, or with a zero control velocity. The second is
a finite-difference Newton iteration over the load-controlled face velocities (one solve with
each perturbed, the correction from the linear system, a solve), until every value is within
its tolerance; it makes no correction when the values already are. Its perturbations start at
1e-6 mm/s at the start of a dwell, otherwise at the larger of 0.1 times the control velocity’s
change in the increment and 0.01 times the control velocity, then the size of the last
correction, and never below min_pert_frac (default 0.001) times the largest elastic
estimate of the face velocities for the run’s largest targets over the increment (so that a
dwell below yield, with vanishing velocities, still gives a usable linear system). A step is
loading when the control value’s magnitude increases (from zero, or away from zero without
crossing it), unloading when it decreases or crosses zero, and a dwell at rate 0; a step at
a strain rate counts by the change of its control-face load. The first increment of an episode
starts: at the run’s first increment and at a reload (loading after a step that
was not loading) from an elastic estimate of the face velocities for the increment’s load
change (after a solve at zero velocity, at a reload); at an unload start from a tenth of the
velocities; at a dwell start from the velocities stored at the first increment of the last dwell
that followed the same kind of step (zero the first time). Necking is not tested at a load or
stress rate. A run whose step 1 is at a load or stress rate has no initialization step
(initialization elastic_step).
- min_pert_frac#
The smallest velocity perturbation of the boundary-velocity iteration, as a fraction of the reference velocity (above, and Triaxial load control).
- Values:
real > 0
- Default:
0.001- Given:
once, for the whole run
Note
min_pert_fracis used only with atarget_loadortarget_stressrow on a component other than the control component, or aload_rateorstress_raterow.
Example (with dwells): 33 at 2 N/s to 100 N, a 20 s dwell, to 250 N, a 10 s dwell, to 300 N;
11 and 22 load-controlled, their loads held during the dwells (load_rate 0):
boundary_conditions triaxial
control_component 33
number_of_steps 5
# comp step 1 step 2 step 3 step 4 step 5
load_rate 33 2.0 0.0 2.0 0.0 2.0
target_load 33 100.0 - 250.0 - 300.0
target_duration - 20.0 - 10.0 -
target_load 11 -37.50 - -93.75 - -112.50
target_load 22 0.0 - 0.0 - 0.0
load_rate 11 - 0.0 - 0.0 -
load_rate 22 - 0.0 - 0.0 -
number_of_incrs 1 - 3 - 2
dtime - 5.0 - 5.0 -
print_results 1 1 0 0 1
load_tol 5.0
max_strain_incr 0.002
Example: a uniaxial creep test, 100 N/s to 440 N, held for 2 s and 1 s (two dwell steps), then unloaded at 200 N/s to 100 N:
boundary_conditions uniaxial_grip
number_of_steps 4
load_rate 33 100.0 0.0 0.0 -200.0
target_load 33 440.0 - - 100.0
target_duration - 2.0 1.0 -
number_of_incrs 8 - - 3
dtime - 0.5 0.5 -
max_strain_incr 2.0e-4
Triaxial Load Control#
Under boundary_conditions triaxial, a component other than the control component may give a
target_load, target_stress, load_rate or stress_rate in a step: it is then
load-controlled in that step (as the control component itself at a load or stress rate,
Load and stress rates, dwells, whose iteration then finds all the load-controlled face
velocities). Its
face x1, y1 or z1 stays plane and moves at a uniform normal velocity (as a
strain-controlled face), and that velocity is found, in every increment, so that the face’s load
(stress: the load over the face’s current area) has the value it must have at the end of the
increment, within load_tol [N] (stress_tol [MPa]):
when the control component has a load or stress target (constant strain rate to a load), the loads follow the step’s load path: each load-controlled value moves from its value at the start of the step to its target in proportion to the control component’s progress towards its own target, \(q_j = q_{j,\mathrm{start}} + \lambda\,(q_j^* - q_{j,\mathrm{start}})\), \(\lambda = (q_p - q_{p,\mathrm{start}})/(q_p^* - q_{p,\mathrm{start}})\) (the starting values are those reached at the start of the step; step 1 starts at 0). The step ends when the control component lands on its target;
when the control component has a strain or time target (the step’s duration is known), or a load or stress rate to a target or a time, each load-controlled value moves linearly in time from its start value to its target over the step;
a
load_rateorstress_raterow moves the value from its start value at that rate, in any step.
A target equal to the start value holds the value. target_load 22 0 in every step is
therefore not a free face: the face y1 stays plane with zero net normal force.
The face velocities are found by a boundary-velocity iteration: a solve of the increment
at the current face velocities; if a load-controlled value is off by more than its tolerance,
one more solve with each load-controlled face velocity changed by a small perturbation, and the
velocity correction from the linear system these solves give (with the path, the corrected
values lie on the path); then again, at most max_bc_iter (default 10) iterations, after
which the run stops with an error. Each solve starts from the start of the increment; the loads
are those of the end of the increment (the geometry updated). The perturbations are the size of
the last correction, and at least min_pert_frac (default 0.001) times the velocity of the
control face, which must therefore not be zero in such a step. A velocity change of a face is
spread over the body as a uniform strain rate along its axis, which makes a good initial guess
of the next solve. The face velocities are carried from increment to increment and from step to
step; a run whose step 1 has load-controlled components starts from an elastic estimate
(isotropic, with the Voigt averages of the phases’ elastic constants weighted by their volume
fractions). With subincrementation on, the iteration runs in every sub-increment, and a
failed solve of the iteration rejects the attempt like any failed increment. The landing on the
control component’s target redoes whole increments, the iteration included. The log reports
every iteration (face velocities, values, values to reach), and the convergence file
(print convergence) numbers the iteration of every solve (Simulation Results (simulation.cfg)).
Example: compression along x at a constant strain rate to -300 and -600 N, with y held at zero load and z pulled in proportion:
boundary_conditions triaxial
control_component 11
number_of_steps 2
# comp step 1 step 2
strain_rate 11 -1e-4 -1e-4
target_load 11 -300.0 -600.0
target_load 22 0.0 0.0
target_load 33 300.0 600.0
dtime 5.0 10.0
dtime_min 0.25 0.25
load_tol 10.0
Example: strain control of 33 to 0.2 % and back to 0.1 %, with the stress of 11 interpolated in time to -50 MPa and back to 0 (22 free):
boundary_conditions triaxial
control_component 33
number_of_steps 2
# comp step 1 step 2
strain_rate 33 1.0e-3 -1.0e-3
target_strain 33 2.0e-3 1.0e-3
target_stress 11 -50.0 0.0
number_of_incrs 4 4
stress_tol 0.01
Control Component#
One component controls the duration of the steps:
control_component <c>
It is required with triaxial. With a uniaxial preset it is the loaded component (inferred;
if given, it must match), and it is an error with general. In every step:
the control component has exactly one target (
target_strain <c>,target_load <c>,target_stress <c>,target_timeortarget_duration) and, with a preset, exactly one rate (strain_rate <c>,load_rate <c>orstress_rate <c>); they set the step’s duration;every other component with rows has exactly one of a
strain_rate(its end strain follows from the duration), atarget_strain(its rate is the strain change over the duration), or atarget_load,target_stress,load_rateorstress_rate(it is load-controlled, Triaxial load control).
- control_component#
The component that sets the duration of the steps:
11,22or33; withperiodicconditions, an imposed component, shear components included.- Values:
one of
11,22,33,23,13,12,32,31,21- Default:
required (triaxial, periodic)
- Given:
once, for the whole run
Note
The shear components (
23,13,12,32,31,21) ofstrain_rate,target_strain,target_load,target_stress,load_rate,stress_rateandcontrol_componentare used only withboundary_conditions periodic.The components
32,31and21ofstrain_rate,target_strainandcontrol_componentcannot be used withperiodic_kinematics small_strain(it takes the shear components 23, 13 and 12, one per pair;deformation_gradient_ratetakes the nine components).control_componentcannot be used withboundary_conditions general(the velocities are given by theset_bclines).
Example: a triaxial run in which 33 is controlled, 11 follows a rate and 22 targets (step 2 with
dstrain):
boundary_conditions triaxial
control_component 33
number_of_steps 2
# comp step 1 step 2
strain_rate 33 1.0e-3 -1.0e-3
target_strain 33 2.0e-3 1.0e-3
strain_rate 11 -0.25e-3 0.3e-3
target_strain 22 -6.0e-4 -3.0e-4
number_of_incrs 4 -
dstrain - 2.5e-4
General Conditions and Steps#
With general conditions, the steps have targets but no rate rows: the set_bc
velocities apply. A target_strain <c> (on one component, the loading axis) is converted to
a time with the strain rate taken as the largest set_bc velocity divided by the length of
the domain along that axis; for a step towards a lower strain, the velocities are reversed.
target_time steps use the velocities as given.
Run Limits#
FEPX stops with an error, after writing the results of the current increment as the current step, when a limit is exceeded. The limits are checked after every increment (after the test for the end of a step), and, where the steps allow it, before the run starts:
max_incr <n>: total number of increments (default 50000);max_total_time <t>: simulated time (default 12000 s);max_strain <e>: largest normal engineering strain of the domain (no default: no limit);max_eqstrain <e>: equivalent engineering strain of the domain (no default: no limit).
- max_incr#
The largest total number of increments.
- Values:
integer >= 1
- Default:
50000- Given:
once, for the whole run
- max_total_time#
The largest simulated time [s].
- Values:
real > 0
- Unit:
s
- Default:
12000- Given:
once, for the whole run
- max_strain#
The largest normal engineering strain of the domain (no limit by default).
- Values:
real > 0
- Given:
once, for the whole run
- max_eqstrain#
The largest equivalent engineering strain of the domain (no limit by default).
- Values:
real > 0
- Given:
once, for the whole run
Necking#
check_necking on (default off) stops the run when the load on the control face (as
above) changes against the step’s direction (the target’s direction for a load or stress
target, the strain rate’s sign otherwise), as when a specimen begins to neck. The test is made
after every increment; the results of the increment where the load first fell are written as
the current step, then the run stops with an error that names the step, the increment and the
two loads.
- check_necking#
on: the run stops when the load on the control face changes against the step’s direction.- Values:
one of
on,off- Default:
off- Given:
once, for the whole run
Note
check_necking oncannot be used withboundary_conditions periodic(no face loads).check_necking onis used only with a loaded component (atarget_strain,target_loadortarget_stressrow; the load of its face x1, y1 or z1 is checked).