# VECFEM3 Reference Manual: mesh

Type: format

## NAME

mesh - data format of the VECFEM mesh arrays

## SYNOPSIS

  LIVEM, IVEM, LNEK, NEK, LRPARM, RPARM, LIPARM, IPARM, LDNOD, DNOD, LRDPRM, RDPARM, LIDPRM, IDPARM, LNODN, NODNUM, LNOD, NOD, LNOPRM, NOPARM,
INTEGER
  LIVEM, LNEK, LRPARM, LIPARM, LDNOD, LRDPRM, LIDPRM, LNODN, LNOPRM
INTEGER
  IVEM(LIVEM), NEK(LNEK), IPARM(LIPARM), DNOD(LDNOD), IDPARM(LIDPRM), NODNUM(LNODN)
DOUBLE PRECISION
  RPARM(LRPARM), RDPARM(LRDPRM), NOD(LDNOD), NOPARM(LNOPRM)

## PURPOSE

The mesh arrays describe the finite element mesh for the VECFEM tool. The arrays NEK, IPARM and RPARM contain the information of the mesh topology, the arrays DNOD, IDPARM and RDPARM contain the information of the Dirichlet condition and NODNUM, NOD and NOPARM contain the information of the geometrical nodes of the FEM mesh. The array IVEM contains the necessary information for the management of the mesh arrays. It is also used to hand over special parameters to the routines in the VECFEM library.

The mesh arrays have to be set by the user or to be read from a data file by vemu02, idevem or patvem. At the beginning the distribution of the data onto the processes is arbitrary. The node id numbers refer to a numbering over all processes. Before the calculation starts the mesh is prepared by the subroutine vemdis. Especially the id numbers of the geometrical nodes refer afterwards to a local numbering on the process and the elements and Dirichlet conditions are rearranged. In the description of the arguments, values, which will be changed by the mesh preparation, are marked by 'input/output' and unchanged values are marked by 'input'. Values with marker 'global' have to be equal on all processes. 'Local' values may vary on the processes.

The mesh arrays describe the geometry of the elements and so the union of all elements describes the domain of the functional equation. The needed information is called the 'geometrical mesh'. On every element the method for the approximation of the solution of the functional equation is defined by the information in the mesh arrays, which are called 'proposal mesh'.

To introduce parameters into the definition of the functional equations (e.g. material constants, temperature distributions) the element oriented parameter sets IPARM and RPARM, the Dirichlet condition oriented parameter sets IDPARM and RDPARM and the geometrical node oriented parameter set NOPARM should be used. The user can freely define them. VECFEM ensures that the parameter sets are always matched to resorting, renumbering and distributions of the mesh arrays. See also userb, userf, usrfu and userl.

The linear forms used for the formulation of functional equations are sums of integrals over the manifolds M(DIM),...,M(0), where M(CLASS) is a manifold of dimension CLASS for CLASS=0,...,DIM. The union of the manifolds is covered by a set of points called the (global) geometrical nodes. The array NOD specifies their coordinates and NODNUM the corresponding id numbers.

The manifold M(CLASS) is covered by the elements of dimension CLASS. GEOTYP global geometrical nodes describe an element. The id numbers of these geometrical nodes have to be specified in the array NEK. The succession in which the geometrical nodes for an element have to be stored (called the local (geometrical) node numbering) depends on the element type and is described in the VECFEM manual. The three parameters GEOTYP, FORM and CLASS distinguish the different types of elements:

GEOTYP | number of geometrical nodes
FORM | number of vertices of the element
CLASS | the dimension of the manifold the element belongs to.

The following table shows all geometrical element types of VECFEM and their parameters ('/' marks a choice):

manifold | element | GEOTYP for order | FORM | CLASS
|  | 1 | 2 | 3 |  |
point | point | 1 | 1 | 1 | 1 | 0
line | line | 2 | 3 | 4 | 2 | 1
area | triangle | 3 | 6 | 9/10 | 3 | 2
| quadrilateral | 4 | 8/9 | 12/16 | 4 | 2
body | tetrahedron | 4 | 10 | 16 | 4 | 3
| prism | 6 | 15 | 24 | 6 | 3
| hexahedron | 8 | 20 | 32 | 8 | 3

The element subdivision has to be selected such that for i=0,DIM the restrictions of the elements used for the subdivision of a manifold M(i) are also elements used for the subdivision of manifolds M(j) of lower dimension 0<=j<i. Additionally you have to consider that a node which is vertex/face node of any element has also to be vertex/face node of every other element containing this node. In general a mesh with elements of different order is not possible.

For the definition of linear forms tangential spaces at the manifolds can be used. In the case DIM=3, the first tangential direction TAU(1) at a manifold M(2) points from the first geometrical node of the element to the second one and for quadrilateral/triangle elements the second tangential direction TAU(2) points from the first geometrical node of the element to the fourth/third one. In the case DIM=2,3, the tangential direction TAU(1) at a manifold M(1) points from the first geometrical node of the element to the second one. If you use tangential directions in your linear forms you have to take these conventions into consideration in the mesh generation.

The proposal mesh defines the approximation of the NK-valued solution of the functional equation. The union of the manifold M(DIM),...,M(0) is covered by points called the global nodes. They are model only, their coordinates do not have to be generated. In most cases their coordinates are equal to the coordinates of the geometrical nodes, but this is not necessary. On an element defined by the geometrical mesh, the solution is interpolated by a polynomial from its values at the global nodes in this element. The interpolation polynomial is called 'proposal function'. The global nodes, which are on the contact faces of the elements, ensure that the approximation of the solution is continuous at the contact faces. For every component the element needs the id number of those NELTYP global nodes, which are used to interpolate the solution component on this element. These id numbers are also stored in the array NEK. The succession in which the global nodes for an element have to be stored (called the local node numbering) depends on the element type and the type of the interpolation polynomial. It is described in the VECFEM manual.

Currently VECFEM allows four different types of polynomials on the elements characterised by the value PRFLIB:

Isoparametrical proposal functions (PRFLIB=0):
  On the element the global nodes are equal to the geometrical nodes (NELTYP=GEOTYP). The succession in the local numbering is the same. So the geometry and the solution are represented in the same way, which motivates the name 'isoparametrical'. It is the usual selection of the proposal function. For a given geometrical mesh the corresponding proposal mesh can be generated by vemge2.
Lagrangian proposal functions (PRFLIB=1):
  On every element the number of global nodes depends on the order p>0 of the polynomial, which is used for the interpolation of the solution. We recommend restricting p<6. The following table gives the value of NELTYP for prescribed order p:

elements | NELTYP for order p | FORM | CLASS
point | 1 | 1 | 0
line | p+1 | 2 | 1
triangle | (p+1)(p+2)/2 | 3 | 2
quadrilateral | (p+1)² | 4 | 2
tetrahedron | (p+1)(p+2)(p+3)/6 | 4 | 3
prism | (p+1)²(p+2)/2 | 6 | 3
hexahedron | (p+1)³ | 8 | 3

  The local numbering runs from the first geometrical node in direction of the second global geometrical node, then in direction of the third/fourth geometrical node for triangle, tetrahedron and prism/ quadrilateral and hexahedron elements and then in direction of the fourth/sixth/eighth geometrical node for tetrahedron/ prism/ hexahedron elements (more details in [THEOMAN])). For a given geometrical mesh a suitable proposal mesh can be generated by vemgen(later).
Pieced isoparametrical proposal functions (PRFLIB=2):
  The locations of global nodes are selected like for PRFLIB=0, but the proposal functions are piecewise polynomials with reduced order int((p+1)/2) (e.g. order 1 -> order 0, order 2 -> order 1 and order 3 -> order 2) and a subdivision into 2**CLASS sub-elements (more details in [THEOMAN]). The local numbering of the nodes is the same as for isoparametrical proposal functions. For a given geometrical mesh a suitable proposal mesh can be generated by vemge2, if after the vemge2 call PRFLIB=2 is set.
Pieced Lagrangian proposal functions (PRFLIB=3):
  The locations of global nodes are selected like for PRFLIB=1, but the proposal functions are piecewise polynomials with reduced order int((p+1)/2) and a subdivision into 2**CLASS sub-elements (more details in [THEOMAN]). The local numbering of the nodes is the same as for Lagrangian proposal functions. For a given geometrical mesh a suitable proposal mesh can be generated by vemgen(later), if after the vemgen(later) call PRFLIB=3 is set.

VECFEM includes estimation for the error of the solution approximation by a change of the proposal function using the following table:

approximation | error estimation | note
PRFLIB=0 | PRFLIB=2 | good performance but lower estimation quality
PRFLIB=1 | PRFLIB=3 | good performance but lower estimation quality
PRFLIB=2 | PRFLIB=0 | lower performance and good estimation quality
PRFLIB=3 | PRFLIB=1 | lower performance and good estimation quality.

The type of the proposal functions PRFLIB and the order of the element NELTYP may be different for the various components of the solution. Therefore NELTYP and PRFLIB have NK components. This general case is called a 'mixed finite element mesh' and is denoted by OWN=NK. The global nodes are numbered over all components. Global nodes, which have the same coordinates but are used for the approximation of different components get different id numbers. The number of unknowns is equal to the number of global nodes. In many applications the same proposal functions are used for all components. Then only the proposal mesh for the first component has to be specified. This type of proposal mesh is called a 'component-by-component numbering' and is denoted by OWN=1. It is useful for periodical boundary conditions and high order approximations. The number of unknowns is equal to the number of global nodes times the number of components NK. If additionally the global nodes are equal to the geometrical nodes, the proposal mesh is called an 'isoparametrical mesh'. It is denoted by OWN=0. In this case the geometrical mesh does not have to be specified. Since it is easy to handle it is the usual mesh type. But you have to keep in mind that there are some type of problems where mixed meshes have to be used (e.g. Navier-Stokes equation).

The set of all elements, which are used to describe the domain and to approximate the solution, is split into groups. In every group all elements have the same (3+2*NK)-tuple of parameters (GEOTYP,FORM,CLASS,NELTYP,PRFLIB). It is optimal to subdivide every manifold into elements of one type. In many cases the use of more groups is unavoidable to subdivide the body or to define material coefficients. VECFEM sets no limit to the number of groups, but it should be kept as small as possible so that you will get maximal efficiency.

## ARGUMENTS

LIVEM integer, scalar, input, local
  Length of the integer information vector, LIVEM>= MESH+ DINFO* DINFO1.
IVEM integer, array: IVEM(LIVEM), input/output, local/global
  Integer information vector.
(1)=MESH, input, local
  Start address of the mesh information in IVEM.
(MESH), void, local
  Start of the mesh information.
(MESH+1)=NDEG, input/output, local
  Number of geometrical nodes on the process.
(MESH+2)=NK, input, global
  Number of the solution components.
(MESH+3)=DIM, input, global
  Space dimension, DIM=1,2 or 3.
(MESH+4)=NGROUP, input, global
  Number of element groups
(MESH+5)=NN, input/output, local
  Leading dimension of the node array NOD, NN>=NDEG.
(MESH+13)=NOP1, input/output, local
  Leading dimension of the node parameter array NOPARM, NOP1>=NDEG.
(MESH+14)=NOP, input, global
  Number of node parameters.
(MESH+15)=OWN, input, global
  Mesh type.

0 | isoparametrical mesh.
1 | the same approximation for all components, component-by-component numbering of global nodes.
NK | individual approximation for the components.

(MESH+18)=DIS, input/output, global
  Set DIS=0.
(MESH+21)=GINFO, input, local
  Start address of group information in IVEM relative to MESH, GINFO>=30.
(MESH+22)=GINFO1, input, local
  Number of information per group, GINFO1>=23+2*NK.
(MESH+23)=DINFO, input, local
  Start address of information for Dirichlet conditions in IVEM relative to MESH, DINFO>=GINFO+ GINFO1*NGROUP.
(MESH+24)=DINFO1, input, local
  Number of information per component, DINFO1>=14.
  Now the information for group g follow, g=1,NGROUP, ng= MESH+GINFO+ GINFO1* (g-1):
(ng)=NE, input/output, local
  Number of elements in group g on the process.
(ng+1)=GEOTYP, input, global
  Number of geometrical nodes in the elements. In the case of an isoparametrical mesh it does not have to be specified.
(ng+2)=FORM, input, global
  Number of vertices of the elements.
(ng+3)=CLASS, input, global
  Dimension of the elements.
(ng+4)=ADDGEO, input/output, local
  Start address of the geometrical node numbers describing the elements in NEK. In the case of an isoparametrical mesh it does not have to be specified.
(ng+5)=GEO1, input/output, local
  Leading dimension of geometrical node numbers describing the elements, normally GEO=NE. In the case of an isoparametrical mesh it does not have to be specified.
(ng+7)=ADRSP, input/output, local
  Start address of the real scalar parameters in RPARM.
(ng+8)=NRSP, input, global
  Number of the real scalar parameters.
(ng+9)=ADRVP, input/output, local
  Start address of the real vector parameters in RPARM.
(ng+10)=RVP1, input/output, local
  Leading dimension of the real vector parameters, normally RVP1=NE.
(ng+11)=NRVP, input, global
  Number of the real vector parameters per element.
(ng+12)=ADISP, input/output, local
  Start address of the integer scalar parameters in IPARM.
(ng+13)=NISP, input, global
  Number of the integer scalar parameters.
(ng+14)=ADIVP, input/output, local
  Start address of the integer vector parameters in IPARM.
(ng+15)=IVP1, input/output, local
  Leading dimension of the integer vector parameters, normally IVP1=NE.
(ng+16)=NIVP, input, global
  Number of the integer vector parameters per element.
(ng+20)=ADDNEK, input/output, local
  Start address of the global node numbers describing the elements in NEK.
(ng+21)=NEK1, input/output, local
  Leading dimension of the global node numbers describing the nodes.
  For d=1,max(OWN,1) the approximation polynomials for the solution have to be defined for group g:
(ng+22+d)=NELTYP, input, global
  Number of local nodes in the elements for component d.
(ng+22+NK+d)=PRFLIB, input, global
  Selection of the element library.

0 | isoparametrical elements.
1 | Lagrangian proposal functions.
2 | pieced isoparametrical elements with half the element size and half the order.
4 | pieced Lagrangian proposal functions with half the element size and half the order.

  Now the information for the Dirichlet conditions of component d follow, d=1,NK, nd= MESH+DINFO+ DINFO1* (d-1):
(nd)=NDC, input/output, local
  Number of Dirichlet conditions for component d on the process.
(nd+1)=ADDCG, input/output, local
  Start address of the geometrical node numbers of the Dirichlet conditions in DNOD.
(nd+2)=ADDC, input/output, local
  Start address of the global node numbers of the Dirichlet conditions in DNOD.
(nd+3)=ADRSP, input/output, local
  Start address of the real scalar parameters for the Dirichlet conditions in RDPARM.
(nd+4)=NRSDP, input, global
  Number of the real scalar parameters for the Dirichlet conditions.
(nd+5)=ADRVDP, input/output, local
  Start address of the real vector parameters for the Dirichlet conditions in RDPARM.
(nd+6)=RVDP1, input/output, local
  Leading dimension of the real vector parameters for the Dirichlet conditions, normally RVDP1=NDC.
(nd+7)=NRVDP, input, global
  Number of the real vector parameters for the Dirichlet conditions.
(nd+8)=ADISDP, input/output, local
  Start address of the integer scalar parameters for the Dirichlet conditions in IDPARM.
(nd+9)=NISDP, input, global
  Number of the integer scalar parameters for the Dirichlet conditions.
(nd+10)=ADIVDP, input/output, local
  Start address of the integer vector parameters for the Dirichlet conditions in IDPARM.
(nd+11)=IVDP1, input/output, local
  Leading dimension of the integer vector parameters for the Dirichlet conditions, normally IVDP1=NDC.
(nd+12)=NIVDP, input, global
  Number of the integer vector parameters for the Dirichlet conditions.
LNEK integer, scalar, input, local
  Length of the element array.
NEK integer, array: NEK(LNEK), input/output, local
  Array of the elements on the process. NEK contains the key list to define the geometrical mesh and the proposal mesh. For the elements in group g the id numbers of the geometrical nodes describing the elements start at position ADDGEO:

NEK(ADDGEO-1+GEO1*(i-1)+z) = | id number of the i-th geometrical node for the z-th element in group g,

  where i=1,...,GEOTYP and z=1,...NE. GEO1 is greater or equal NE and should be odd. In the case of an isoparametrical mesh the geometrical mesh does not have to be specified. For the elements in group g the id numbers of the global nodes which are used for the approximation of the component d start at position ADDNEK+NEK1*S, where S is the sum of all NELTYP for the components 0<c<d. NEK1 is greater or equal NE and should be odd.

NEK(ADDNEK-1+NEK1*(i-1+S)+z)= | id number of the i-th global node for the z-th element and component d in group g,

  where i=1,...,NELTYP and z=1,...NE. In the case of a component-by-component numbering and an isoparametrical mesh, only the global nodes for the first component have to specified (S=0!).
LRPARM integer, scalar, input, local
  Length of the real parameter array.
RPARM double precision, array: RPARM(LRPARM), input/output, local
  Real parameter array. To every group g the user can assign a set of NRSP real values called 'real scalar parameters', and to every element in group g the user can assign a set of NRVP real values called 'real vector parameters'. Using these parameter sets, values (e.g. material properties, nodal forces) are handed over to the user routines. The real scalar parameters define a homogeneous and the real vector parameters specify a nonhomogeneous value distribution. The real scalar parameters are stored in RPARM starting at ADRSP:

RPARM(ADRSP-1+i)= | the i-th real scalar parameter for group g,

  where i=1,...,NRSP. The real vector parameters are stored in RPARM starting at ADRVP:

RPARM(ADRVP-1+RVP1*(i-1)+z)= | the i-th real vector parameter for the z-th element for group g,

  where i=1,...,NRVP and z=1,...NE and RVP1 is greater or equal NE. The real scalar parameters have to be equal on all processes.
LIPARM integer, scalar, input, local
  Length of the integer parameter array.
IPARM integer, array: IPARM(LIPARM), input/output, local
  Integer parameter array. To every group g the user can assign a set of NISP integer values called 'integer scalar parameters', and to every element in group g the user can assign a set of NIVP integer values called 'integer vector parameters'. The vector integer parameters should be used to assign a unique number over all processes to every element. This element number is necessary if you hand over the FEM mesh to a postprocessor, see vemide, vempat. Additional integer vector parameters can be used to distinguish different material properties in a group, e.g. the value 1 for the second integer vector parameters marks steel, the value 2 marks iron, and so on. The integer scalar parameters are stored in IPARM starting at ADISP:

IPARM(ADISP-1+i)= | the i-th integer scalar parameter for group g,

  where i=1,...,NISP. The integer vector parameters are stored in IPARM starting at ADIVP:

IPARM(ADIVP-1+IVP1*(i-1)+z)= | the i-th integer vector parameter for the z-th element for group g,

  where i=1,...,NIVP and z=1,...NE and IVP1 is greater or equal NE. The integer scalar parameters have to be equal on all processes.
LDNOD integer, scalar, input, local
  Length of the array of the Dirichlet nodes.
DNOD integer, array: DNOD(LDNOD), input/output, local
  Array of the Dirichlet nodes on the process. For every component d the id numbers of the global nodes where Dirichlet conditions are prescribed have to be specified. They represent the support D(d) of the Dirichlet condition in the definition of the functional equations, see veme00, veme02 and vemp02. Starting at ADDC the id numbers of the NDC global nodes are stored. The id numbers of the corresponding geometrical nodes start at ADDCG:

DNOD(ADDCG-1+z)= | number of the geometrical node of the z-th Dirichlet condition for component d
DNOD(ADDC-1+z)= | number of the global node of the z-th Dirichlet condition for component d

  where z=1,...NDC. In the case of an isoparametrical mesh the global node numbers do not have to be specified. If you use a mesh of order one to describe the geometrical structures but a order two approximation of the solution it will be necessary to introduce geometrical nodes which are not referred to by the geometrical representation of the elements. If you do not use the location of the Dirichlet conditions (e.g. if it is constant zero) it is not necessary to introduce new geometrical nodes. Set the id number of the geometrical node to 1.
LRDPRM integer, scalar, input, local
  Length of the real Dirichlet parameter array.
RDPARM double precision, array: RDPARM(LRDPRM), input/output, local
  Array of the real Dirichlet parameters. To every component d the user can assign a set of NRSDP real values called 'real scalar Dirichlet parameters', and to every Dirichlet condition for component d the user can assign a set of NRVDP real values called 'real vector Dirichlet parameters'. Using these Dirichlet parameter sets, values (e.g. the values of the prescribed function, defined by userb) are handed over to the user routines. The real scalar Dirichlet parameters are stored in RDPARM starting at ADRSDP:

RDPARM(ADRSDP-1+i)= | the i-th real scalar Dirichlet parameter for component d,

  where i=1,...,NRSDP. The real vector Dirichlet parameters are stored in RDPARM starting at ADRVDP:

RDPARM(ADRVDP-1+RVP1*(i-1)+z)= | the i-th real vector Dirichlet parameter for the z-th Dirichlet condition for component d,

  where i=1,...,NRVDP and z=1,...NDC and RVP1 is greater or equal NDC. The real scalar Dirichlet parameters have to be equal on all processes.
LIDPRM integer, scalar, input, local
  Length of the integer Dirichlet parameter array.
IDPARM integer, array: IDPARM(LIDPRM), input/output, local
  Array of the integer Dirichlet parameters. To every component d the user can assign a set of NISDP integer values called 'integer scalar Dirichlet parameters', and to every Dirichlet condition in component d the user can assign a set of NIVDP integer values called 'integer vector Dirichlet parameters'. The integer vector Dirichlet parameters can be used to distinguish different types of Dirichlet conditions for one component. E.g. in a rectangle domain with Dirichlet conditions on its border, the value 1 for the first integer vector Dirichlet parameter marks Dirichlet conditions at the top boundary, the value 2 marks the right boundary and so on. The integer scalar Dirichlet parameters are stored in IDPARM starting at ADISDP:

IDPARM(ADISDP-1+i)= | the i-th integer scalar Dirichlet parameter for component d,

  where i=1,...,NISDP. The integer vector Dirichlet parameters are stored in IDPARM starting at ADIVDP:

IDPARM(ADIVDP-1+IVP1*(i-1)+z)= | the i-th integer vector Dirichlet parameter for the z-th Dirichlet condition for component d,

  where i=1,...,NIVDP and z=1,...NDC and IVP1 is greater or equal NDC. The integer scalar Dirichlet parameters have to be equal on all processes.
LNODN integer, scalar, input, local
  Length of the array of the id numbers of the geometrical nodes, LNODN>=NDEG.
NODNUM integer, array: NODNUM(LNODN), input/output, local
  Array of the id numbers of the geometrical nodes on the process. The geometrical nodes used on the process are continuously numbered from 1 to NDEG. Additionally there is a numbering of the geometrical nodes over all processes (it need not be continuous). NODNUM(i) is the global geometrical node id number over all processes of the geometrical node with local node id i on the process. Normally a global geometrical node id is referred to by more than one process.
LNOD integer, scalar, input, local
  Length of the array of the coordinates of the geometrical nodes on the process, LNOD>=DIM*NN.
NOD double precision, array: NOD(LNOD), input/output, local
  Array of the coordinates of the geometrical nodes. For the geometrical node with id i on the process we have

NOD(i )= | x1-coordinate,
NOD(i+ NN)= | x2-coordinate,
NOD(i+2*NN)= | x3-coordinate,

  where i=1,...,NDEG. If two processes refer to the same global geometrical node via the NODNUM vector (this is a normal situation), any of the both specified node coordinates on the processes is selected during the element distribution.
LNOPRM integer, scalar, input, local
  Length of the array of the node parameters, LNOPRM>= NOP1* NOP.
NOPARM double precision, array: NOPARM(LNOPRM), input/output, local
  Array of the node parameters for the geometrical nodes on the process. In many cases the linear forms depend on a NOP-valued function (e.g. a temperature distribution). It is given at the geometrical nodes. So NOP real values are allocated to every geometrical node. They are called the (real) node parameters. We have

NOPARM(NOP1*(j-1)+i)= | the j-th parameter at the i-th node on the process,

  where i=1,NDEG and j=1,NOP1. The node parameters are interpolated at the elements by polynomials. The evaluations of this polynomial and its derivatives is handed over to the user routines, see userf, userl usrfu and userb. If two processes refer to the same global geometrical node via the NODNUM vector (this is a normal situation), one of the two specified node parameter sets on the processes is arbitrarily selected during the element distribution.

## EXAMPLE

See vemexamples.

## REMARKS

1. The elements are distributed to the processes to get good load balancing, and on every process the elements are resorted to get good vectorization (blocking). The efficiency is maximal if you avoid containing the same geometrical and global nodes in a large number of elements.
2. The set of the distances of the global node numbers in all elements is called the diagonals of the mesh. To get optimal efficiency in lsolpp the cardinality of the diagonals should be as small as possible. This is called a diagonal optimal numbering of the global nodes (a bandwidth optimal numbering has a minimal bound for the diagonal numbers). If you expect a large number of diagonals you should use the bandwidth optimizer vemopt(later) to reduced the number of diagonals.
3. The parameter sets NOPARM, RPARM, IPARM, RDPARM and IDPARM are insignificant for VECFEM. vemdis resorts them in the element distribution and block procedure and hands them over to the user routines, see userb userb, userf, usrfu and userl. They get their significance by the statements in your routines, which define the linear forms and the Dirichlet conditions.

## INTERNAL

The following entries in the IVEM are set by vemdis.

(19)=XVEM, input, global
  If XVEM=30841, the error messages are printed with respect of vembuild and xvem.
(MESH+6)=NNEK, output, local
  Used storage in the element array NEK.
(MESH+7)=NRPARM, output, local
  Used storage in the real element parameter array RPARM.
(MESH+8)=NIPARM, output, local
  Used storage in the integer element parameter array IPARM.
(MESH+9)=NDNOD, output, local
  Used storage in the Dirichlet condition array DNOD.
(MESH+10)=NRDPRM, output, local
  Used storage in the real Dirichlet parameter array RDPARM.
(MESH+11)=NIDPRM, output, local
  Used storage in the integer Dirichlet parameter array DPARM.
(MESH+12)=NINFO, output, local
  Used storage in IVEM for the mesh information, NINFO= DINFO+ NK* DINFO1+ 2+3*NPROC+ NGROUP+ NBLK.
(MESH+16)=LM, output, global
  Maximal number of global nodes on a process.
(MESH+18)=DIS, output, global
  DIS=220964 indicates a distributed mesh. If DIS<>220964, the numbering of the geometrical nodes refers to numbering over all processes.
(MESH+19)=SORTI, output, local
  Start address of resort information in IVEM relative to MESH, SORTI=DINFO+DINFO1*NK.
  Now the information for group g follow, g=1,NGROUP, ng= MESH+GINFO+ GINFO1* (g-1):
(ng+22)=TOTNT, output, global
  Total number of global nodes for the element in group g.
(MESH+SORTI)=NJUMP, output, global
  Number of communication cycles to consider all mesh couplings.
(MESH+SORTI+1)=NBLK, output, local
  Number of element blocks on the process.
(MESH+SORTI+1+p)=JUMP, output, global
  MYPROC+JUMP(p) is target of the p-th communication cycle, p=1,NJUMP.
(MESH+SORTI+NPROC+1+p)=LMATBK, output, global
  LMATBK(p) is the number of global nodes on process p, p=1,NPROC.
(MESH+SORTI+2*NPROC+1+p)=PTRMBK, output, global
  PTRMBK(p)+1 is the first global node on process p, p=1,NPROC.
(MESH+SORTI+3*NPROC+1+g)=BLKLST, local, global
  Number of element blocks in group g, g=1,NGROUP.
(MESH+SORTI+3*NPROC+1+NGROUP+i)=BLK, output, local
  Length of element block i, i=1,NBLK.
(MESH+SORTI+3*NPROC+1+NGROUP+NBLK), output, local
  End of mesh information.

## REFERENCES

[FAQ], [THEOMAN], [DATAMAN], [DATAMAN2], [P_MPI].

## ALSO SEE

VECFEM, vemexamples.

## COPYRIGHTS

Program by L. Grosz, C. Roll, P. Sternecker, 1989-1996. Copyrights by Universitaet Karlsruhe 1989-1996. Copyrights by Lutz Grosz 1996. All rights reserved. More details see VECFEM.

By L. Grosz, Auckland, 31 May, 2000.