**sequence

Description

This command writes the sequences or blocks of time steps for the problem. Solution requires specification of discrete times for which the governing equations are to be evaluated. The program allows an unlimited number of **sequence or **cycles (see next command page) instances in order to create complex loading histories. There is really no distinction between the sequence and the cycle commands; the cycle command automatically generates a number of repeated sequence groups to form cycles.

As discussed in the introduction of ****calcul (page ), the sequences are broken up into increments which are the most fundamental unit of time stepping.

Syntax

Sequences are created as necessary according to the sub-options of the **sequence command. Normally, the sequences are defined by end times or incremental times of the sequences. The syntax for these definitions is the following:

**sequence [ N ] [ *algorithm algo1 [ algo2, algoN ] ] [ *increment inc1, inc2, …, incN ] [ *iteration iter1, iter2, …, iterN ] [ *limit_dof vari, vali1,…valin [ , varj, valj1,…, valjN ] ] [ *time time1, time2,…, timeN ] [ *dtime dtime1, dtime2,…, dtimeN ] [ *ratio [ absolu ] ratio1, ratio2, …, ratioN ]

The integer value N defines the number of sequences which will be run, even if there are more defined in the sub-commands. This allows the run-time of a problem to be limited quickly, without deleting or commenting information which may be useful later on. In the absence of this value, the number of sequences will be determined based on the number of time or dtime values input.

All the other options are used for specifying particular parameters which correspond to the sequences. If the number of values given after an option is less than the number of sequences of the current block (the last **sequence command), the last value given will be repeated for all the subsequent sequences. If one or several of the sub commands are absent, the default value will apply to all the sequences defined.

*algorithm

String values substituted for algo1 to algoN are the algorithm solution methods for each segment of the loading. The values for these methods are summarized:

Algorithm	Description
eeeee	Newton “elastic” method. Matrix is not re-calculated during iterations
EEEEE	Linear method. No iterations, matrix calculated only once (once after time step or Newmark coefficients changes in dynamics). The computation of internal forces is made through the K.U multiplication which is much faster than the classical element integration procedure. Only nodal fields are post-treated, no element fields are available. This can be useful to treat linear dynamics problems in a very fast way.
p1p1p1	Modified Newton algorithm with the matrix calculated and inverted the first and second iterations
p1p2p2	Modified Newton algorithm with the matrix calculated and inverted the first, second, and third iterations
p1p2p3	Newton-Raphson algorithm where the matrix is always updated during iterations

*increment

The integer values inc1, inc2, …, incN are used to define the number of increments in corresponding sequences. In the absence of this option, all sequences are calculated in a single loading increment.

*iteration iter1, …, iterN

Integer values used to limit the maximum number of iterations in a given increment, valid during a sequence. The default number of iterations is \(10\). These values may be used to adjust the divergence control, or limit the CPU consumption of a poorly converging problem.

*limit_dof vari, vali1,…valin, …

This option takes a DOF character name (U1, U2, etc) and a list of real values corresponding the given segments. Any number of DOF name / list of limiting values may be input sequentially to put limits on the different DOFs of the problem. Real numbers input are limiting values for any iteration of the degree of freedom. In the course of iterations, we will have available \(\Delta \bf u_i\) at iteration \(i+1\) from the solution of the linear system, \(d\bf u_i = \left(\bf K_i \right)^{-1} \bf R_i\). In place of the standard updating of the DOF values, \(\Delta \bf u_{i+1} = \Delta \bf u_i + d\bf u_i\) we have \(\Delta \bf u_{i+1} = \Delta \bf u_i + \beta d\bf u_i\) where \(\beta\) is a limiting factor:

(118)\[\beta = \min \left( \frac{\mbox{limitation value}}{\max_{DOF}(d\bf u_i) }, \beta \right)\]

with \(0<\beta<1\).

This option allows the calculation to pass points where the algorithm would predict instability, at the cost of increased number of iterations. Excessive trial delta values in the DOFs may occur when the problem tangent matrix displays softening behavior.

*time  *time1, time2,..., timeN*

specifies the absolute times at the end of the sequences. There are as many values as the number of sequences. The first sequence of the problem is at \(t=0\), or the last time given in the previous **sequence command. This initial value must be less than the first time time1 given here. In the absence of a time option, the times will be assigned to the sequence numbers.

*dtime dtime1, dtime2,…, dtimeN

specifies the increment of time taken over a sequence. This method of specifying the sequence times is useful if a “time shiftable” block of sequences is desired. An example is a block of loadings to be subjected to different pre-loadings, or loading after a series of cycles, where additional computations would be necessary to assure that the times are well-posed. Options *dtime and *time are mutually exclusive.

*ratio [ norme_force | absolu | automatic ] ratio1, ratio2, …, ratioN

This option is for specifying a global convergence criterion in a sequence. The real values ratio1, etc correspond to the sequences defined. A single given value will be repeated for all the sequences.

The norme_force keyword (default) means that convergence is achieved if:

(119)\[\frac{\left\|R^{\rm int} - R^{\rm ext}\right\|_2}{\left\|R^{\rm ext}\right\|_2} < 0.01 \times {\rm ratio}\]

where \(R^{\rm int}\) and \(R^{\rm ext}\) are the internal and external nodal forces vectors. \(R^{\rm int} - R^{\rm ext}\) is therefore the equilibrium residual. The absolute keyword means that convergence is achieved if:

(120)\[\left\|R^{\rm int} - R^{\rm ext}\right\|_\infty < {\rm ratio}\]

The automatic keyword means that norme_force is selected excepted if \(||R^{\rm ext}||=0\) in which case the absolute criterion is taken.

There is an extended syntax for ratio which is of the form :

*ratio (crit_type1 dof_type1:v1 crit_type2 dof_type2 : v2 …)

This extended syntax is useful for multifield problems. The global dof vector is split into sub-vectors corresponding to each specified dof_type. The specified criterion (crit_type can be norme_force, absolu or automatic) is then applied on each sub-vector and global convergence is achieved if all criteria are met. dof_type can be any dof type such as U1, U2, TP, … or any class of dof (i.e. dof names with the same prefix) such as U which concatenates U1, U2 and U3 in the same sub-vector.

Example

**sequence
 *time          1.0    5.0
 *increment     10
 *iteration     20
 *ratio absolu  1.0
 *algorithm     p1p2p3
 *limit_dof     U1 .1 .1  U2 .02 .03

In this example, d is a dof coming from a multifield element.

***resolution
 **sequence
  *time 1.
  *increment 20
  *iteration 5
  *algorithm p1p2p3
  *ratio (automatic U:1.e-3 absolu d:1.e-6)

%
% from ab429.inp making 3 sequences
%
**sequence
  *time       3.   33.  50.
  *ratio      1.    3.   3.
  *iteration  50   30   30
  *increment  10   15   34
  *algorithm  p1p2p3
  *limit_dof
     U1   0.2   0.5   0.5
     U2   0.2   0.5   0.5
     PR  10.0  10.0  10.0

**cycles

Description

The cycles option is essentially the same as the **sequence option except that it repeats the block of sequences a given number of times. Normally, use of the **cycles option will be employed after a series of pre-loading sequences, in order to attain the initial loading state of the cycles. Therefore, cyclic loadings will usually require a **sequence definition for the pre-load, followed by a **cycles definition for the cycles themselves. Unless the end segment of the cycles will return to zero loading, additional **segment definitions may be given to relax the structure to an unloaded state.

An example loading is a pre-load in tension, followed by tension-torsion cycles, and finally a relaxation of the initial tensile load. Many more cases may be imagined.

As the calculation time scale is the principal measure of the solution, it is important to understand the method of time scale construction from a cycles definition. The times given for this option are always relative to the beginning of the cycle. This defines a local cycle-based time scale, which may be repeated.

Syntax

The syntax for cyclic loading is the following:

**cycles [ N ] [ *algorithm algo1 [ algo2, algoN ] ] [ *increment inc1, inc2, …, incN ] [ *iteration iter1, iter2, …, iterN ] [ *limit_dof vari, vali1,…valin [ , varj, valj1,…, valjN ] ] [ *time time1, time2,…, timeN ] [ *dtime dtime1, dtime2,…, dtimeN ] [ *ratio [ absolu ] ratio1, ratio2, …, ratioN ]

the integer N is the number of cycles to be created.

Except for the time scale alteration for the cyclic sequences defined with the *time or *dtime options, all sub-commands for this command are equivalent to the **sequence command.

Example

An example loading gives 5 cycles with the waveform 10s-300s-10s after a pre-load of 1s.

**sequence
  *time      1.
**cycles 5
  *dtime     10. 300. 10.
  *increment 5   10   1
  *algorithm p1p2p3

This example assumes the first one second loading segment will be a linear solution. The first segment of the first cycle (from 1 second to 11 seconds on the “global” clock) may be a loading with non-linear behavior, so 5 increments are given. The following rest time has 10 increments, also assuming non-linear behavior. The final segment from times 311 seconds to 321 seconds is assumed linear and will be solved in one increment. The same increments will then be repeated 4 more times. A corresponding loading waveform is given in the ***table command.