2.2 THE SPARSE MATRIX SOLVERS

NOTE:

Always compare FEA calculations with analytical rough calculations, results of experiments, plausibility considerations and other tests without exeption !

The two solver pairs

- Z88I1 and Z88I2 iteration solver
- Z88I1 and Z88PAR direct sparse matrix solver with fill-in

are using only the so-called non-zero elements. They are very suitable for larger structures but need more attention than Z88F. The principal task of every FEA program is the calculation of the displacements. This is the job of the sparse matrix solvers. The calculated deflections are the starting point for a stress calculation with Z88D or nodal force calculation with Z88E.

2.2.1 The Sparse Matrix Iteration Solver Z88I1/Z88I2

The iteration solver uses only the so-called non-zero elements - this results in an absolute minimum for storage - and features two parts:

Sparse Matrix Solver Part 1: Z88I1 is used for both the Iteration Solver Z88I2 and for the direct Sparse Matrix Solver with fill-in Z88PAR. Z88I1 builds the following pointers for the lower part of the total stiffness matrix GS:

- Pointer vektor IP points to the diagonal elements GS(i, i)
- Pointer vektor IEZ points to the column index GS(x, j)

Example (ref. Schwarz, H.R: Methode der finiten Elemente) : Let the lower part of GS be:

GS(1,1) |  |  |  |  |
GS(2,1) | GS(2,2) |  |  |  |
| GS(3,2) | GS(3,3) |  |  |
GS(4,1) |  |  | GS(4,4) |  |
GS(5,1) |  | GS(5,3) |  | GS(5,5) |
| GS(6,2) |  | GS(6,4) |  | GS(6,6)

GS results in the following vector of non-zero elements:

GS(1,1) | GS(2,1) | GS(2,2) | GS(3,2) | GS(3,3) | GS(4,1) | GS(4,4)
GS(5,1) | GS(5,3) | GS(5,5) | GS(6,2) | GS(6,4) | GS(6,6) |

IEZ will result in:

1 | 1 | 2 | 2 | 3 | 1 | 4 | 1 | 3 | 5 | 2 | 4 | 6

and IP:

1 | 3 | 5 | 7 | 10 | 13

The pointer IEZ holds MAXIEZ elements, ref. Memory definition file Z88.DYN. You must allocate memory MAXIEZ for the assembly of the sparse matrix. There is no way to pre-determine the needed memory but Z88I1 tells you if MAXIEZ was too small. Then, increase MAXIEZ in Z88.DYN and run Z88I1 again. Z88I1 stores the two pointer vectors in a binary file Z88O4.BNY, which may become quite large.

Z88I1 tells you how much memory for GS (= MAXGS) and for KOI (= MAXKOI) you must allocate; adjust this in Z88.DYN. See an example of Z88.DYN:

COMMON START

MAXGS 5200000 > adjust this before running Z88I2/Z88PAR

MAXKOI 270000 > adjust this before running Z88I2/Z88PAR

MAXK 46000

MAXE 27000

MAXNFG 137000

MAXNEG 32

MAXIEZ 5200000 > adjust this before running Z88I1

COMMON END

``

Thus proceed for large structures for Z88 in 3 or more steps:

1st: run Z88I1

2nd: if Z88I1 completed properly, read off the values for MAXGS and MAXKOI and adjust Z88.DYN, if necessary. Now memory is proper adjusted for Z88I2.

3rd: if Z88I1 stopped because of lack of MAXIEZ increase MAXIEZ in Z88.DYN and run Z88I1 again. Repeat this step until Z88I1 completes properly.

Sparse Matrix Iteration Solver Part 2: Z88I2 computes the element stiffness matrices, compiles the total stiffness matrix, incorporates the boundary conditions, scales the system of equations and solves the (huge) system of equations by the conjugate gradient algorithm. Preconditioning is done for better convergence. Choose your favourite pre-conditioner: Either a SOR step or a so-called incomplete Cholesky decomposition (shiftet incomplete Cholesky decomposition SIC). Default is SIC preconditioning because the main parameter, the so-called s hift factor a is easy to handle. The SOR preconditioning needs only ~ 2/3 of the memory of SIC but the SOR parameter w cannot be determined a-priori.

(1) Conjugate Gradients with SOR preconditioning

Windows: Z88I2 > Mode > Precon: Overrelaxation, Compute > Go
UNIX: z88i2 -s (console) or Solver: Z88I2 -S (Z88COM)

(2) Conjugate Gradients with SIC preconditioning

Windows: Z88I2 > Mode > Precon: Inco. Cholesky decom., Compute > Go
UNIX: z88i2 -c (console) or Solver: Z88I2 -C (Z88COM)

In addition you must supply 5 entries in the parameter file Z88I4.TXT:
+ termination criterion: maximum count of iterations(for example 10000) reached
+ termination criterion: residual vector < limit Epsilon (for example 1e-7)
+ parameter for the SIC convergence acceleration. Shift factor Alpha (from 0 to 1, good values may vary from 0.0001 to 0.1). For further information consult the literature)
+ parameter for the SOR convergence acceleration. Relaxation factor Omega (from 0 to 2, good values may vary from 0.8 to 1.2).
+ number of CPUs (Z88PAR only, max. 9)

Note: The files Z88I1.TXT, Z88I2, Z88I4.TXT and Z88I5.TXT mentioned here are described more precisely in chapter 3.

Input files:

Z88I1.TXT (general structure data)
Z88I2.TXT (boundary conditions, constraints)
Z88I4.TXT(parameter file for the sparse matrix solvers part 2: Z88I2 and Z88PAR)
Z88I5.TXT (surface and pressure loads), if needed

Output files:

Z88O0.TXT (processed structure data for documentation)
Z88O1.TXT (processed boundary conditions for documentation)
Z88O2.TXT (deflections)

In addition two binary files Z88O1.BNY and Z88O3.BNY are generated. These binary files are later used by Z88D (stress processor) and Z88E (nodal force processor).

2.2.2 The direct Sparse Matrix Solver with Fill-In Z88PAR

Before running Z88PAR launch the first solver part Z88I1, see Chp. 2.2.1.

Sparse Matrix Solver Part 2: Z88PAR. The solver Z88PAR does a matrix decomposition but in contrary to simple Z88F this solver operates with fill-in. Fill-in means allocating dynamic memory for the new matrix elements created by the decomposition process. Thus, the memory needs cannot calculated before starting Z88PAR. If the memory exhausts while Z88PAR is running, Z88PAR will quit with an error message.

This solver works at very high speed for not too large structures (100.000 ~ 1.000.000 DOF) because it can use up to 9 CPUs, but needs tremendous more memory than the sparse matrix iteration solver Z88I2. Thus, Z88PAR is only really usefull on machines with very much memory and 64 bit pointers and integers. I recommend for Z88PAR the 64 bit version of Z88, a 64 bit Windows operating system and a minimum of 4 GByte (8 or 16 Gbyte is better) of memory. When using a 32 bit operating system and 4 GByte of memory you are limited to ~ 150.000 DOF with Z88PAR. The solver core used is PARDISO by O. Schenk, University of Basel, Switzerland. Because of legal reasons we cannot publish the sources of Z88PAR – the one exception of our Open Source policy.

Enter the number of CPUs you want to use by the 5th entry in Z88I4.TXT with a maximum of 9 CPUs. The first four entries have no meaning for Z88PAR but must exist. Pay attention not to set these variables in the Windows environment, i.e. in the system settings:

NUM_THREADS, OMP_SET_NUM_THREADS.

Otherwise, this may conflict with entries Z88I4.TXT. For the input and output files see 2.2.1.

2.2.3 Which solver should i use?

Roughly spoken: Use the simple and reliable Cholesky solver Z88F for small structures. The sparse matrix iteration solver Z88I1/Z88I2 works always even for very large structures under 32 bit operating systems. For medium sized structures the direct sparse matrix solver with fill-in Z88I1/Z88PAR is very suitable because of its tremendous speed.

Solver | Type | Number of DOF | Memory needs | Speed | Multi-CPU | Notes
Z88F | Cholesky solver without Fill-In | up to ~ 30.000 | medium | medium | no | running Z88H before Z88F is recommended
Z88I1/ Z88PAR | direct Solver with fill-in | up to~ 150.000 for 32 bit PCs | very high | very high | yes | usefull with several CPUs and very much memory
Z88I1/ Z88I2 | conjugated gradients solver with pre-conditioning | no limits (up to 5 mio. DOF were run on an ordinary PC) | an absolute minimum | medium | no | a very stable and reliable solver for very large structures