![](http://www.gnu-darwin.org/hexley-gd-sm.png)
|
content="text/html; charset=iso-8859-1">
VECFEM3 Reference Manual: veme00
Type: FORTRAN routine
NAME
veme00 - solves a linear functional equation by mixed finite
elements
SYNOPSIS
- CALL VEME00(
- T, LU, U, LIVEM, IVEM, LLVEM, LVEM, LRVEM, RVEM, LNEK,
NEK, LRPARM, RPARM, LIPARM, IPARM, LDNOD, DNOD, LRDPRM,
RDPARM, LIDPRM, IDPARM, LNODN, NODNUM, LNOD, NOD, LNOPRM,
NOPARM, LBIG, RBIG, IBIG, MASKL, MASKF, USERB, USERL,
USERF, VEM50X, VEM63X)
-
- INTEGER
- LU, LIVEM, LLVEM, LRVEM, LNEK, LRPARM, LIPARM, LDNOD,
LRDPRM, LIDPRM, LNODN, LNOPRM, LBIG
- INTEGER
- IVEM(LIVEM), NEK(LNEK), IPARM(LIPARM), DNOD(LDNOD),
IDPARM(LIDPRM), NODNUM(LNODN), IBIG(*)
- DOUBLE PRECISION
- T, U(LU), RVEM(LRVEM), RPARM(LRPARM), RDPARM(LRDPRM), NOD(LDNOD),
NOPARM(LNOPRM), RBIG(LBIG)
- LOGICAL
- LVEM(LLVEM), MASKL(NK,NK,NGROUP), MASKF(NK,NRHS,NGROUP)
- EXTERNAL
- USERB, USERL, USERF, VEM50X, VEM63X
PURPOSE
veme00 is a subroutine for the numerical solution of a linear
steady functional equation on a space of smooth functions H. The
problem for the solution U in H has to be given in the form :
[1] functional equation
for all V in H with V(COMPV)|D(COMPV)=0 for all COMPV=1,..,NK:
L(V,U) = F(V)
[2] Dirichlet conditions
for all COMPU=1,...,NK : U(COMPU)|D(COMPU)=B(COMPU)
where L is a bilinear form (see userl)
and F is a linear form (see userf).
Simultaneously NRHS right hand sides F can be
considered. L, F and B must not depend on U. Using the finite
element method the bilinear form and the linear forms are
discretized. The resulting system of linear equations is solved
by the program package lsolpp. The
computed solution has to be postprocessed by the routines vemu03, vemu04
and vemu05 and can be handed over to a
postprocessor program (see vemide or vempat).
ARGUMENTS
- T double precision, scalar, input, local
- Real number (e.g. the current time).
- LU integer, scalar, input, local
- Length of solution vector U, LU
>=NRHS*LM.
- U double precision, array: U(LU),
input/output, local
- The solution vector at the global nodes. U(i+LM*(j-1))
is the value of the j-th right hand side at the global
node i+PTRMBK(MYPROC), see vemdis. If STARTU is
set, U gives an initial solution which is
handed over to the user routines and is an initial guess
of lsolpp.
- LIVEM integer, scalar, input, local
- Length of the integer information vector, LIVEM>=
MESH+ NINFO+ 60+9*NGROUP+
NDNOD+ NK+ LM.
- IVEM integer, array: IVEM(LIVEM),
input/output, local/global
- Integer information vector.
- (1)=MESH, input, local
- Start address of the mesh informations in IVEM,
MESH>203+ NPROC.
- (2)=ERR, output, global
- Error number.
0 |
program terminated without error. |
10 |
error in lsolpp. |
90 |
LBIG is too small. |
95 |
L/I/RVEM
arrays or solution array too small. |
98 |
read/write error. |
99 |
fatal error. |
- (3)=STEP, input/output, global
- Recall indicator.
0 |
the first call of veme00. |
1 |
a recall of veme00. |
If you want to recall veme00 with the same
matrix structure as in the first call, you can
set STEP=1 to save the packing of the
global matrix (e.g if veme00 is used in an outer
iteration). Between two calls the storage in RBIG
beginning at SPACE=IVEM(8)
of length LSPACE=IVEM(9)
can be used as work space. On output always STEP=0.
- (5)=NIVEM, output, local
- Used length of IVEM.
- (6)=NRVEM, output, local
- Used length of RVEM.
- (7)=NLVEM, output, local
- Used length of LVEM.
- (8)=SPACE, output, local
- See LSPACE.
- (9)=LSPACE, output, local
- The storage RBIG(SPACE),
..., RBIG(SPACE+LSPACE-1)
may be used as work space between two veme00
calls, if the recall option STEP=1 is
used.
- (10), input, local
- Unit for paging.
- (11), input, local
- Unit for paging, IVEM(10)<>IVEM(11).
If it is necessary, veme00 writes parts (pages)
of RBIG/IBIG to external
data sets. For that purpose veme00 needs two
temporary files on units IVEM(10) and IVEM(11).
They are only used if the storage for RBIG/IBIG
is too small. The needed lengths of these files
cannot be computed in advance because they depend
on the given mesh and the functional equation.
Every process has to get its own data set,
otherwise the results will be chaotic. If the
data sets are allocated on different discs, the i/o-time
will be reduced, since the i/o is done in
parallel.
- (40)=LOUT, input, local
- Unit number of the standard output file, normally
6.
- (41)=OUTCNT, input, local
- Output control flag.
0 |
only error messages are printed |
>0 |
a protocol and every OUTCNT-th
lsolpp are printed |
- (45)=MSPACK, input, global
- Maximal number of stripes to pack the global
matrix, normally 100. The packing of the global
matrix is divided into several steps (called
stripes). Before the packing starts, the needed
number of stripes is estimated. If this number is
greater than MSPACK, the computation
will be stopped. You have to give more storage
for RBIG/IBIG or to
increase MSPACK. In general a problem
needing more than 100 stripes is too large for
the given storage, or else the mesh is numbered
badly.
- (46)=PCLASS, input, local
- Packing limit, normally 0. The global matrix is
stored in packed form into RBIG/IBIG.
The needed storage can be controlled by PCLASS.
0 |
lsolpp will
need minimal CPU time. The needed storage is large. |
1 |
compromise of needed storage and CPU time for lsolpp. |
2 |
The storage for the global matrix
will be minimal. lsolpp will
need much CPU time. |
- (51)=ORDER, input, global
- Order of the integration formulas for the
computation of the element matrices (0<ORDER<19).
ORDER gives the maximal degree of the
polynomials which will be integrated exactly. You
should select ORDER greater than the
square of the order of the used proposal
functions.
- (52)=NRHS, input, global
- Number of right hand sides.
- (70)=MS, input, global
- Method selection in lsolpp.
- (71)=MSPREC, input, global
- Normalization method lsolpp.
- (72)=ITMAX, input, global
- Permit maximal number of matrix-vector
multiplications per right hand side in lsolpp.
- (73)=MUNIT, input, global
- If MUNIT is greater than 20 and less
than 100 the global matrix is written to unit MUNIT,
see lsolpp.
- (200)=NPROC, input, global
- Number of processes, see combgn.
- (201)=MYPROC, input, local
- Logical process id number, see combgn.
- (202)=NMSG, input/output, global
- Message counter. The difference of the input and
the output value gives the number of
communications during the veme00 call.
- (204)=TIDS(1), input, global
- Begin of the list TIDS which defines
the mapping of the logical process ids to the
physical process ids. See combgn.
- (MESH), input, local
- Start of mesh informations, see mesh.
- LRVEM integer, scalar, input, local
- Length of the real information vector, LRVEM>=40+
4*NK*NRHS+ 2*NK.
- RVEM double precision, array: RVEM(LRVEM),
input/output, local/global
- Real information vector.
- (2)=EPS, output, local
- Smallest positive number with 1.+EPS>1.
- (3)=EPSLIN, input, global
- Desired accuracy for the solution of the linear
systems, e.g. 1.D-7. EPSLIN prescribes
the defect relative to right hand side, see lsolpp.
- LLVEM integer, scalar, input, local
- Length of the logical information vector, LLVEM>=20+2*NK+
NGROUP*(NK*NK+ NK*NRHS).
- LVEM logical, array: LVEM(LLVEM),
input/output, local/global
- Logical information vector.
- (1)=LSYM, input, global
- LSYM=true indicates a symmetrical
bilinear form L, see userl.
- (5)=STARTU, input, global
- STARTU=true indicates that U
has to be handed over to the user routines and is
an initial guess of lsolpp.
Use vemu08 or vemu06 to set an inital
guess.
- (9)=NOSMTH, input, global
- NOSMTH=true indicates that lsolpp returns the
smoothed solution.
- LNEK integer, scalar, input, local
- Length of the element array.
- NEK integer, array: NEK(LNEK),
input, local
- Array of the elements, see mesh.
- LRPARM integer, scalar, input, local
- Length of the real parameter array.
- RPARM double precision, array: RPARM(LRPARM),
input, local
- Real parameter array, see mesh.
- LIPARM integer, scalar, input, local
- Length of the integer parameter array.
- IPARM integer, array: IPARM(LIPARM),
input, local
- Integer parameter array, see mesh.
- LDNOD integer, scalar, input, local
- Length of the array of the Dirichlet nodes.
- DNOD integer, array: DNOD(LDNOD),
input, local
- Array of the Dirichlet nodes, see mesh.
- LRDPRM integer, scalar, input, local
- Length of the real Dirichlet parameter array.
- RDPARM double precision, array: RDPARM(LRDPRM),
input, local
- Array of the real Dirichlet parameters, see mesh.
- LIDPRM integer, scalar, input, local
- Length of the integer Dirichlet parameter array.
- IDPARM integer, array: IDPARM(LIDPRM),
input, local
- Array of the integer Dirichlet parameters, see mesh.
- LNODN integer, scalar, input, local
- Length of the array of the id numbers of the geometrical
nodes.
- NODNUM integer, array: NODNUM(LNODN),
input, local
- Array of the id numbers of the geometrical nodes, see mesh.
- LNOD integer, scalar, input, local
- Length of the array of the coordinates of the geometrical
nodes.
- NOD double precision, array: NOD(LNOD),
input, local
- Array of the coordinates of the geometrical nodes, see mesh.
- LNOPRM integer, scalar, input, local
- Length of the array of the node parameters.
- NOPARM double precision, array: NOPARM(LNOPRM),
input, local
- Array of the node parameters, see mesh.
- LBIG integer, scalar, input, local
- Length of the real work array. It is impossible to
compute the needed length for LBIG before the
first veme00 run. It depends on the given mesh and the
functional equation. The needed length of LBIG
is controlled by the parameters MSPACK and PCLASS.
A minimal length of LBIG cannot be given. It
should be as large as possible.
- RBIG double precision, array: RBIG(LBIG),
work array, local
- Real work array.
- IBIG integer, array: IBIG(*), work
array, local
- Integer work array, RBIG and IBIG
have to be defined by the EQUIVALENCE statement.
- MASKL logical, array: MASKL(NK,NK,NGROUP),
input, global
- If MASKL(COMPV,COMPU,G)=true, the COMPV-th
component of the test function couples with the COMPU-th
component of the solution in the bilinear form L over the
elements in the group G, see userl.
- MASKF logical, array: MASKF(NK,NRHS,NGROUP),
input, global
- If MASKF(COMPV,RHS,G)=true, the COMPV-th
component of the test function gives a contribution to
the RHS-th linear form F over the elements in group G,
see userf. If you select the
masks in an optimal manner, the computation will use the
CPU and storage resources optimally. If you are uncertain
about the correct settings, you can set the masks equal
to true or call vemfre to check
your entries.
- USERB external, local
- Name of the subroutine in which the Dirichlet conditions
are described, see userb.
- USERL external, local
- Name of the subroutine in which the coefficients of
bilinear form L are described, see userl.
- USERF external, local
- Name of the subroutine in which the coefficients of the
linear forms F are described, see userf.
- VEM50X external, global
- Name of the subroutine in which the element matrices are
computed. The general case is VEM500. Special
versions for structural analysis are not yet available.
- VEM63X external, global
- Name of the subroutine in which the storage of VEM50X
is specified. The general case is VEM630.
EXAMPLE
See vemexamples.
METHOD
The functional equation [1]-[2] is discretized by the finite
element method. The solution of the resulting system of linear
equations is an approximation of the solution of [1]-[2].
Discretization
In every element the solution is replaced by a polynomial
which interpolates the solution at the global nodes of the
element. The parametric representation is the polynomial
interpolation of the assigned geometrical nodes.
Solution
A system of linear equations has to be solved, which is in
general very large and extremely sparse. The linear equations
solver lsolpp in veme00 uses iterative
methods.
Accuracy
The accuracy is determined by the stopping criterion EPSLIN
for lsolpp. Additionally the accuracy
of the numerical solution depends on the mesh width, the order of
the geometrical approximation, the order of the proposal
functions and the used order of integration formulas.
RESTRICTIONS
- The existence and uniqueness of the solution of the
problem have to be ensured.
- lsolpp uses iterative methods.
In some cases problems with convergence can be avoided if
the components of the solution are ordered in a way that
the coefficients of L for the interaction of the
derivatives of the COMPV-th component of the test
function and the derivatives of the COMPV-th component of
the solution are positive and/or that the coefficients
for the interaction of the COMPV-th component of the test
function and the COMPV-th component of the solution are
positive.
- The lsolpp iteration may be
divergent. In general this occurs if the coefficients for
derivatives of the test functions and the solution
interaction or the coefficients of L for derivatives of
solution and the test functions interaction get a
dominant value. If it is possible, scale the coefficients
in the linear form so that they are in the same order of
magnitude. In the case of divergence you should check the
bilinear form and the mesh. Sometimes an increase of the
integration order will produce convergence.
REFERENCES
[FAQ], [THEOMAN], [DATAMAN], [DATAMAN2], [LINSOL], [P_MPI].
SEE
vecfem, vemcompile,
vemrun, vemhint,
mesh, vemexamples,
vemdis, lsolpp,
userb, userf, userl, vemfre, vemge2, vemgen(later), vemopt(later), vemu06, vemu08.
COPYRIGHTS
Program by L.
Grosz, C. Roll, P. Sternecker, 1989-96. Copyrights by
Universitaet Karlsruhe 1989-1996. Copyrights by Lutz Grosz 1996.
All rights reserved. More details see VECFEM.
by L. Grosz, Auckland , 6. June, 2000. |