This chapter on total life and crack initiation consists of descriptions of various MSC Fatigue modules. These modules can be accessed from subordinate forms of the MSC Fatigue main form within the MSC Fatigue Pre & Post or MSC Patran programs.

It is possible to carry out a MSC Fatigue analysis outside the pre- and post-processing environments such as the MSC Patran environment by executing the analysis programs from the system prompt. The main reason for doing this is to provide an alternative and sometimes, faster route for carrying out multiple computations with only one or two small changes to the analysis parameters. This can be achieved because the MSC Fatigue job parameters and the nodal or elemental fatigue data are stored in ASCII files. For completeness, a general schematic showing the analysis route is shown in Figure 5‑1. The aspects of this figure are described throughout this chapter. The crack growth analysis route is also shown in Figure 5‑1 but is specifically described in Crack Growth (Ch. 7).

MSC Fatigue runs on a wide range of computers and graphics devices. The parameters used by each graphics device must be defined by using the MENM module, prior to the first use of MSC Fatigue. For details, please see Module Operations (Ch. 17). This is automatically accomplished when running MSC Fatigue from a pre- and post-processing environment such as MSC Patran and is transparent to the user and defaults to the Motif driver.

All programs in the MSC Fatigue system may be executed by typing the name of the program or its symbol. These programs may ask questions which are not normally presented to you since they are executed as batch jobs when called from the pre-/postprocessing environment. The programs normally used in a typical or basic fatigue analysis are listed below.

The actual programs necessary to complete a global multi-node or element total life or crack initiation analysis aside from the pre/postprocessor are:

The programs and options must be used in this sequence with exception of the factor of safety option which may run directly after the fatigue pre-processing. The results may be reviewed using PFPOST or by inspecting the ASCII nodal or element results file (jobname.fef or jobname.fos) using a text editor or by inspecting fringe plots directly within the pre/postprocessor.

When a global multi-node fatigue analysis is set up using the MSC Fatigue pre-/post-processing menus, these are the files necessary to run the analysis and the files that are created.

The first of these files is ASCII and may be edited using a standard text file editor. Although this method of defining the MSC Fatigue job parameters is not as automated as using the MSC Fatigue Pre & Post menus, it does offer a simple and rapid method of changing a few job parameters without the encumbrance of a menu structure.

After the translator has been run (described in The Translator (PAT3FAT or FATTRANS), 272) and the fatigue input file (jobname.fes) has been created, the fatigue preprocessor, FEFAT, is run. A jobname.fpp file is created which is a scaled, rainflow cycle count for stresses or strains of the loading time history. The fatigue analysis is performed also by the program FEFAT. When run in interactive mode, this program asks for a number of input parameters which are passed in through the jobname.fin, jobname.fes and jobname.fpp files when run from the MSC Fatigue Pre & Post menus. A full description of file content is provided in Description of Files, 336.

MSC Fatigue uses a translator to combine the information in the database, the possible external results files and the job information file (jobname.fin) to create the fatigue input file (jobname.fes). For this reason, the translator must be run each time any information is changed in the database and/or the results and information files such as if the FEA analysis has been rerun.

To run the translator, the following command should be used:

pat3fat jobname

fattrans jobname

PAT3FAT and FATTRANS both produce a jobname.fes file which is a binary file. An ASCII to binary and binary to ASCII file convertor is provided for the jobname.fes file. The convertor program is part of the FEFAT module and is described in Utilities, 324. A description of the ASCII and binary versions of the fatigue input file (jobname.asc/fes) is provided in The Fatigue Input File (jobname.fes), 368. Remember that the fatigue executables can only read the binary version and the ASCII version must always be converted back to binary via FEFAT’s utility options.

Although FATTRANS, the new (since Release 2005) translator that handles large models more efficiently will ultimately replace the older translator, PAT3FAT is still the default translator for most of the fatigue analysis types. FATTRANS is currently the default for only the following analysis types:

FATTRANS can be made the default translator for all anlysis types, by setting the environment varianble, FAT_USE_TRANS as follows:

setenv FAT_USE_FATTRANS 1 (cshell)

FAT_USE_FATTRANS=1 ; export FAT_USE_FATTRANS (Bourne shell, kshell)

 

For Windows, the environment variable can be set from the "SystemProperties/Advanced/Environment Variables/User Variables" form. For a "New" variable, set "Variable Name" = FAT_USE_FATTRANS and "Variable Value" = 1.

One goal of the FATTRANS development was to ensure that the application performs well no matter how large the user's model is, and no matter how many time increments in results history data. The translator should never utterly fail for lack of memory.

In order to perform the translation of very large models, the FATTRANS translator computes the memory needs for the model, and automatically creates sub-groupings of entities that fit into user-defined available memory. The translator then performs the results fetch/write operations on a given sub-group at a time. For small or moderate size models, no subgrouping is needed.

To allow for maximum flexibility, the maximum amount of memory to be used by the FATTRANS translator can be modified with a user environment variable as follows:

setenv FAT_MAX_NUM_WORDS $value (cshell)

FAT_MAX_NUM_WORDS=$value ; export FAT_MAX_NUM_WORDS (Bourne shell, kshell)

 

For Windows, the environment variable can be set from the "SystemProperties/Advanced/Environment Variables/User Variables" form. For a "New" variable, set "Variable Name" = FAT_MAX_NUM_WORDS and "Variable Value" = $value.

Where:

$value-is the maximum amount of memory (in words) to be used by fattrans

And:

$value (default)=10E6-if the user does not specify the FAT_MAX_NUM_WORDS environment variable, a default value is used; the default value is set internally at 10E6 words.

 

Since most machines use some type of virtual memory, there should not be a problem with setting FAT_MAX_NUM_WORDS to a number higher than the physical memory available on a given machine. However, setting the number too high may lead to excessive use of virtual memory for very large models, and thus result in poor performance.

Conversely, setting FAT_MAX_NUM_WORDS to too small a number may result in too many subgroups being created. A large number of sub-groups can lead to degraded translator performance. The best procedure is to only specify FAT_MAX_NUM_WORDS when translating very large models or moderately sized models with a large number of result time steps.

The memory usage estimate for model translation is written from fattrans to the $jobname.msg file. This is illustrated from the following excerpt:

Message: Group 1 contains 733 entities. At 9 words per ent,

Max memory allocation is 6597 words.

In the case where the default FAT_MAX_NUM_WORDS is exceeded, (i.e., in the case of a very large model), the model is automatically divided into smaller subgroups. Each subgroup contains no more memory than that specified by FAT_MAX_NUM_WORDS, which in this case would be the default value of 10 megawords. The following example message is written to the $jobname.msg file:

Message: Group 2 sub-divided into 6 subgroups;

Max memory for each sub-group is 10000000 words.

During product testing, a crankshaft model was used which contained 32,000 nodes and 37 load increments. For one test, the default memory usage value was used.

By examining the jobname.msg file, the memory required for the translation could be determined as shown below:

(excerpt from crankshaft.msg)

Message: Group 1 contains 32000 entities. At 333 words per ent,

Max memory allocation is 10656000 words.

In another test with the same model, a smaller value for maximum memory was used. In this case, the maximum amount of memory to be used by fattrans was set at 1 megawords. For a 32-bit machine, this is equivalent to 32 megabytes.

setenv FAT_MAX_NUM_WORDS 1E6

 

During the run, the following messages were written to the msg file:

(excerpt from crankshaft.msg)

 

Message: User modifiable variable FAT_MAX_NUM_WORDS has been changed from 10000000 (default) to 1000000.

 

Message: Group 1 contains 32000 entities. At 333 words per ent,

Max memory allocation is 10656000 words.

 

Message: Group 1 sub-divided into 73 subgroups;

Max memory for each sub-group is 1000000 words.

 

Warning: Translator performance may be seriously degraded with exessive number of subgroups (i.e., 10+ subgroups).

Setting the FAT_MAX_NUM_WORDS environment variable to a number too small can cause excessive number of sub-groups.

In this case, the translator took aproximately 5 times longer to perform the translation. This was due to the results fetch routine having to be performed 73 times-once for each subgroup. This example shows that playing with the FAT_MAX_NUM_WORDS variable is not advisable. The default should not be over-ridden arbitrarily, and smaller default values may lead to increased translation times.