**process onera#

Description#

This command can be used in replacement of **process LCF to perform damage cumulation within a rainflow counting procedure. Cumulation rules and material parameters are the same as in the case of **process LCF. Given a complex multiaxial load sequence the post-processor performs the following operations:

  • for each point (integ point, node) decompose the input into elementary sub-cycles using the multiaxial rainflow algorithm (**process multirange, see multirange)

  • for each elementary cycle, compute the number of cycles to failure according to the onera fatigue model (*process fatigue_rainflow, see fatigue_rainflow)

  • optionally, if creep is included, compute the creep damage associated to each elementary cycle, using the *process creep model (see creep ),

  • performs damage cumulation, starting from an initial \(D_0\) (that may be non-zero if a preloading is defined). As shown in the next figure, the input loading sequence is repeated until a damage value of \(D=1\) is obtained. The number of cycles to failure computed by the post processor, then corresponds to the maximum number of repetitions \(N_r\) applied for the current point. During each repetition of the loading sequence, the damage \(D_i\) associated to each elementary sub-cycle, is cumulated to the total damage \(D\) using the selected cumulation rule (options LC, NLC or NLC_ONERA).

../../_images/onera_cumulation.svg

Syntax#

**process onera [ *reverse reverse ] \(~\,\) *mode LC | NLC | NLC_ONERA \(~\,\) *fatigue fatigue_rainflow section1 [ *creep name2 section2 ] [ *scale lin | log ] [ *preload b1-e1 [/r1] c2- e2 [/r2 ] … bn -en [/rn ] ] [ *cycle b1-e1 [/r1 ] b2-e2 [/r2 ] … bn-en [/rn ] ]

The main difference with **process LCF is the *reverse keyword, that allows to specify the maximum number of sub-cycles stored in the calculation, within the ones detected by the rainflow counting algorithm (see the **process multirange command). Default value is reverse=3. Note that **process multirange gives out cycles with maximum amplitude first, such that output is always given for the reverse most damaging elementary cycles. However, regardless of the reverse number, damage cumulation is always done for all elementary cycles detected by the rainflow algorithm.

Contrary to **process LCF, the only fatigue model allowed is the one implemented in the **process fatigue_rainflow post-processor (see this command).

Note also, that the creep damage part is optional in this post-processor, and that cumulation can be restrained only to the fatigue damage due to sub-cycles detected by rainflow counting.

The optional command *cycle can be used to define a a complex cycle from the output maps available in the results file (that may or not be selected by means of the **output_number command ). Cycle definitions have the form bi-ei/ri, where bi and ei are map numbers defining respectively the beginning and the end of sequence number i. r1 is the number of times this sequence should be repeated (default is ri=1, when this optional argument is not defined). An arbitrary number of sequences can be given, thus allowing to re-arrange output maps stored in results files in a loading sequence of arbitrary complexity. In this case, the number of cycles to failure, will correspond to the number of times this complex loading path can be repeated until failure.

Command *preload, with a syntax equivalent to *cycles, can also be used to define a preloading phase generating an initial damage before cycling occurs. In this case the number of cycles to failure calculated will correspond to the number of times the cyclic loading path can be repeated, taking into account a non-zero initial damage corresponding to the *preload definition.

Note that when *preload is defined, it is mandatory to add also a *cycle command to specify which subset of total input maps do correspond to the cycle definition. Also, map numbers given as argument to the *preload and *cycle commands are in fact relative, and depend on the **output_number definition specified before the current **process onera block, ie. those are ranks in the current selection.

Output is as follows:

  • ncyc the number of elementary cycles detected by the rainflow algorithm.

  • the number of cycles of failure NF\(i\) corresponding to fatigue damage associated with the reverse most damaging sub-cycles obtained by decomposition of the input sequence.

  • if the option *creep is included the number of cycles to failure NC associated with creep damage for the whole loading sequence.

  • the number of cycles to failure NR_mode obtained by cumulation of the previous damage mechanisms,

  • the initial damage Dpreload corresponding to preloading sequences when the command *preload is used.