**process LCF#

Description#

This process is used to apply a cumulation model for the life prediction under creep-fatigue interaction. The reference number of cycles to failure in pure fatigue and in pure creep must have been previously computed. The number of cycles to failure under creep-fatigue loading is defined as \(N_r\), from the number of cycles to failure under creep \(N_c\) and the number of cycles to failure \(N_f\) . Several cumulation rules can applied, according to users choice:

  • linear cumulation, LC

    (153)#\[\frac{1}{N_r} = \frac{1}{N_c} + \frac{1}{N_f}\]

  • bilinear cumulation, BLC

    A “knee-point” is defined in the cumulative diagram, from the numerical value of the material coefficients \(Kc\) and \(Kf\) (both values must be between O and 1).

    (154)#\[\hbox{if}\; \frac{N_c}{N_f} \geq \frac{K_c}{K_f} : \quad \frac{1}{N_r} = \frac{1}{N_f} + \frac{{1 - K_f}}{K_c} \frac{1}{N_f}\]
    (155)#\[\hbox{if}\; \frac{N_c}{N_f} \leq \frac{K_c}{K_f} : \quad \frac{1}{N_r} = \frac{1}{N_c} + \frac{{1 - K_c}}{K_f} \frac{1}{N_c}\]

    The resulting cumulation rule must : - be equivalent to the linear cumulation rule if \(K_c + K_f =1\) - predict lower life if \(K_c + K_f < 1\) - predict longer life if \(K_c + K_f > 1\)

  • nonlinear cumulation, NLC
    The cumulation rule uses the quantities \(C=\frac{1}{N_c}\) and \(F=\frac{1}{ N_f}\) to compute damage evolution from \(D_i\) to \(D_f\) in each cycle, according to:
    (156)#\[C = {\left (1-D_i \right )}^{k+1} - {\left ( 1-D \right )}^{k+1}\]
    (157)#\[F = {\left [1-{\left (1-D_f \right )} ^{\beta + 1} \right ]} ^{1-\alpha} - {\left [ 1 - {\left (1-D \right )} ^{\beta + 1} \right ]} ^{1-\alpha}\]

    The resulting cumulation rule predicts lower lives than linear cumulation does.

  • another nonlinear cumulation, NLC_ONERA
    This is the same cumulation rule as previously given. The difference rests in the the coefficient \(\alpha\) which is constant in the mode NLC and calculated as follows in this mode:
    (158)#\[\alpha = 1 - a \left ( \frac{Dsig/2 - \sigma_l} {\sigma_u - \sigma_{max}} \right )\]

    with

    (159)#\[\sigma_l = \sigma_{l0} ( 1 - b1 \overline{tr(\sigma)} )\]

Syntax#

The syntax for this criterion is as follows.

**process LCF \(~\,\) *mode LC | BLC | NLC | NLC_ONERA \(~\,\) *fatigue name1 section1 \(~\,\) *creep name2 section2 [ *initiation name3 section3 ] [ *scale lin | log ]

The user chooses his method of cumulation among the key words LC, BLC, NLC and NLC_ONERA after *mode. name1 is the name of the fatigue processor to apply, and name2 the name of the creep processor. Those which are currently available for fatigue are fatigue_S, fatigue_E and fatigue_EE. The current creep processor is uniquely creep. Plug-ins could however be created for new models of either of these. For each the user indicates after the processor type a number of post processing section containing the input for that processor.

The user can add an initiation phase, of which the name and the post processing section are specified after the option *initiation. Only the post-computation initiation is currently available. The number of cycles \(N_a\) is then taken into account in the cumulation rule.

The model LC does not require any material coefficients. Two coefficients Kc and Kf are necessary for the model BLC, three coefficients k, alpha and beta for the model NLC, and five coefficients k, beta, a, sigma_l0 and b1, are required for the model NLC_ONERA. Some of these coefficients appear in the criterions for creep or fatigue. In this case the reading will attempt to find the coefficients in the respective creep or fatigue sections. For example, the coefficient \(k\) of the mode NLC will be read in the section **process creep, if it is present, otherwise in the section **process LCF of the material file.

The number of cycles to failure \(N_r\) is called NR_mode in the output variables. The user can also ask for a logarithmic scale which will re-name the output to LNR_mode. The number of cycles to failure \(N_f\), \(N_c\) and \(N_a\) are also stored in the output (see these processors to find the specifics of variable naming).

Example#

A complete example with non linear cumulation rule follows:

**process LCF
  *mode NLC
  *fatigue fatigue_S 2
  *creep creep 2
  *scale log

% with in an other ****post_processing section
**process creep
  *var sig
**process fatigue_S
  *var sig
  *range 2
**range
  *var sig
  *method 2
  *alpha 0.2

% With the following definition in the material file
% beta and k are readed in their specific section
**process LCF
  alpha  0.9
**process fatigue_S
  M       980.
  beta    2.5
  sigma_l 70.
  sigma_u 180.
  b1      0.003
  b2      0.003
**process creep
  S0 0.
  A  420.
  r  10.
  k  30.