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
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:
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:
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 shift 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,
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
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 |