Next: 5 Tutorial examples
Up: 4 List of the modules
Prev: 4.2 Mesh generation modules
Index
Contents
An alphabetic list of the mesh modification modules is given below (we start with the utility module INITI):
CALL INITI (M,LM,IMPRE,NNN)
where
From a P1 (nodes = vertices) type starting mesh , the module generates the nodes and assigns a number to each one (the exact positions of the nodes are calculated by the interpolation module). This operation is performed in order to allow for an optimal numbering of the nodes.
For compatibility reasons, the number of nodes in a triangle, or on a triangular face, must equal 1 or a multiple of 3. Similarly, inside a quadrilateral, or on a quadrilateral face, the number of nodes must be 1 or a multiple of 4.
Dimension array M (in the blank common), call INITI
CALL ADPNOP (M,ISEG,ISET,ISEQ,ISETE,ISEPE,ISEHE,NOESOM,
. NFNOPE,NINOPE,NFNOPS,NINOPS)
where
The method is only suitable for the two-dimensional case.
Figure 4.4: Refinement around vertices
Many situations are possible depending on the type of element, for which at least one point is given in the list of points to treat, and the position of the vertices under consideration (see figure 4.4).
Dimension array M (in the blank common) and arrays NSAT and
NNFRON, declare the logical FONINT, declare the
external FFRONT, call INITI
CALL AFFNOP (M,NFNOPE,NINOPE,NFNOPS,NINOPS,NQUAD,
. LSAT,NSAT,NBFRON,NNFRON,FONINT,FFRONT)
where
affini.psfig:aff2Initial meshaffout.psfig:aff21After refinement
Dimension array M (in the blank common), call INITI
CALL AIGUNO (M,NOPTION,NITER,NFNOPE,NINOPE,
. NFNOPS,NINOPS)
where
Dimension array M (in the blank common), call INITI
CALL AKHHAT (M,NOCODE,NITER,NFNOPE,NINOPE,NFNOPS,
. NINOPS)
where
Dimension the arrays NONO, NOPOI, COORP and call CLNO5C as follows:
CALL CLNO5C (NDIM,NCOPNP,NOP5,IA,NCGE,NDSDE,NNO,
. NONO,NPO,NOPOI,NOP4,COORP)
where
Dimension array NOPOI and call CLNOIA as follows:
CALL CLNOIA (NCOPNP,NOP5,IA,NCGE,IAS,IAR,IAF,NPO,NOPOI)
where
Similar to CLNOIA, this utility is used to obtain NNO and NONO(.), the number and list of the nodes of the element.
Dimension array NONO and call CLNOIN as follows:
CALL CLNOIN (NCOPNP,NOP5,IA,NCGE,IAS,IAR,IAF,NPO,NNO,
. NONO)
where
Dimension arrays NONO, NOPOI, NREF and COORP, and call CLNOPO as follows:
CALL CLNOPO (M,M,IA2,IA4,IA,NCGE,NDSDE,NNO,NONO,
. NPO,NOPOI,COORP,NREF)
where
NREF is completed systematically, even if the references are all zero.
Generally, and for all the CLNO** utilities, the arrays are declared by over-estimating their length.
SUBROUTINE REFNOP(M,XM,DM,NFNOPE,NINOPE,NREFE,INDIC,LINDIC) C +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ . C C ------ ADDRESSING ------ C OVER-ESTIMATE THE NUMBER OF NODES (I.E. OF POINTS) BY 20 ... C NDIM = M(IANOP2) NOE23 = NDIM * 20 CALL READRE(2,'XCOO',IACOO,NOE23,M,NRET) NOE2 = 2 * 20 CALL READRE(1,'AUX ',IANOE,NOE2,M,NRET) IAPOI = IANOE + 20 LREF = 26 CALL READRE(1,'NREF',IAREF,LREF,M,NRET) C LINDIC = 0 IANOP5 = M( ICNOPO + 17 ) IA = IANOP5 DO 10 J=1,NE CALL CLNOPO(M,M,IANOP2,IANOP4,IA,NCGE,NDSDE,NNO,M(IANOE), + NPO,M(IAPOI),XM(IACOO),M(IAREF)) LONG = NTOT(NCGE) ITEST = 0 DO 1 K=1,LONG IF ( M(IAREF+K-1) .NE. 0 ) ITEST = 1 1 CONTINUE IF ( ITEST .EQ. 0 ) GO TO 10 IDEB = LONG - NFAC(NCGE) + 1 IF ( NDIM .EQ. 2) IDEB = LONG - NARE(NCGE) + 1 DO 2 K=IDEB,LONG IF ( M(IAREF+K-1) .NE. NREFE ) GO TO 2 LINDIC = LINDIC + 1 INDIC(LINDIC) = J GO TO 3 2 CONTINUE 3 CONTINUE 10 CONTINUE . END
The aim of this procedure is to allow for vector and/or parallel computing, for example at the element matrix calculation level.
Dimension array M (in the blank common), declare the integer array COURB of length NLC, call INITI
CALL COULE1 (M,M,NFNOPE,NINOPE,NFNOPS,NINOPS,
. LVECT,NOMCOU,COURB,NLC)
where
The method works for Lagrange type elements or elements for which the first 2 (in 2D) or 3 (in 3D) d.o.f. correspond to the displacements.
Dimension array M (in the blank common), call INITI
CALL DEFNOP (M,M,M,NFNOPE,NINOPE,NFB,NIB,RAPORT,NO,
. NFNOPS,NINOPS,NFNDL1,NINDL1)
where
The method works for P1 Lagrange type elements.
Dimension array M (in the blank common), declare the integer arrays NNF and NNDSD of length 2
(if not utilized) or 2 LNNF and 2 LNDSD (see below), call INITI
CALL DILNOP (M,NFNOPE,NINOPE,NFNOPS,NINOPS,A,B,C,X0,
. Y0,Z0,LNNF,NNF,LNDSD,NNDSD)
where
The I.D.S. is a P1 Lagrange type data structure.
Dimension array M (in the blank common), call INITI
CALL DTRI3D (M,NFNOPE,NINOPE,NFNOPS,NINOPS,IOPT)
where
Dimension array M (in the blank common), declare array LISTE and call INITI
CALL ELIMNO (M,NFNOPE,NINOPE,NBRE,LISTE,NFNOPS,
. NINOPS,IAPOI)
where
Dimension array M (in the blank common), call INITI
CALL GEONOP (M,NFGEOM,NIGEOM,NFNOPS,NINOPS)
where
Dimension array M (in the blank common), call INITI
CALL GIBBS (M,NOCODE,NFNOPE,NINOPE,NFNOPS,NINOPS,
. NOMTAB,LONTAB,IANOUV)
where
The array called NOMTAB, of length LONTAB and address IANOUV, is used to determine the correspondence between the new and old node numbers:
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& MODULE GIBBS : PART_OVEN &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& MODULE RENUM1 : PART_OVEN &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& PERMUTATION OF THE COORDINATES ------------------------------ RENUMBERING OF THE NODES ------------------------- NUMBER OF NODES : 166 ------------------------------------------------------------------ I CARACTERISTICS I BEFORE RENUMBERING I AFTER RENUMBERING I ------------------------------------------------------------------ I BAND WIDTH I 120 I 16 I ------------------------------------------------------------------ I TOTAL PROFILE I 4247 I 2034 I I MEAN PROFILE I 25.584 I 12.253 I ------------------------------------------------------------------ &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& END OF MODULE RENUM1 &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& END OF MODULE GIBBS &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
Dimension array M (in the blank common), call INITI
CALL IMGEOM (M,NFGEOM,NIGEOM,IMPRE)
where
Dimension array M ( in the blank common), call INITI
CALL IMNOPO (M,NFNOPO,NINOPO,IMPRE)
where
A complete description of the NOPO data structure will now be given.
Constructed along the same principles as the other data structures, it is composed of six arrays of predefined organization.
This integer array consists of 32 variables. It contains a general description of the job (title, date, name), the D.S. NOPO (type, level, etc.), and indicates the presence of the array NOP1.
This integer array exists if NTACM (see NOP0) is non-zero. It contains 22 variables per array. In general, there are no arrays associated except for certain applications where it is necessary to conserve the values that do not enter in its standard definition in the data structure.
If the array NOP1 exist, it contains sequentially:
Loop I from 1 to NTACM
This integer array contains 27 values.
If NBEGM (array NOP2) is non-zero, this integer array contains information which is relative to each super-element or description (this array is not used currently).
This NTYCOO type array contains the NDIM.NP vertex coordinates: X1, Y1, X2, Y2, ..., or X1, Y1, Z1, X2, ...
This integer array describes each element in the mesh sequentially. It contains:
Loop I from 1 to NE
Loop J from 1 to NNO
If INING = 3 only the vertex reference numbers are given, for INING = 2 the edge, followed by the
vertex reference numbers are given, and for
INING = 1 the face, edge and vertex reference numbers are specified.
Loop from 2 to NMAE
Dimension array M (in the common blank), call INITI, restore the D.S. GEOM to be processed into
main memory (see SDREST [George et al. 1989d]) in order to determine the addresses of the generic arrays,
GEO2, GEO3, ... GEO7, call the module:
CALL INFOGE (M,IOPT,TYPESD,NIVEAU,TAB2,TAB3,TAB4,
. TAB5,TAB6,TAB7,NUMREC,XREC,YREC,ZREC)
where
Dimension array M (in the blank common), call INITI, restore the appropriate D.S. NOPO into main memory
(see SDREST [George et al. 1989d]) in order to determine the addresses of the generic arrays NOP2, NOP4 and NOP5,
call the module:
CALL INFONO (M,IOPT,TYPESD,NIVEAU,TAB2,TAB4,
. TAB5,NUMREC,XREC,YREC,ZREC)
where
CALL INITI (M,LM,IMPRE,NNN)
where
This method applies to P1 Lagrange type elements.
Dimension array M (in the blank common), declare the integer arrays NNF and NNDSD of length 2 (if not used) or
2 LNNF and 2 LNDSD (see below), declare the integer array ITYPE of length NTRANS, declare the real
array TRANS with dimension 12 NTRANS, call INITI:
CALL MODNOP (M,NFNOPE,NINOPE,NFNOPS,NINOPS,NTRANS,
. ITYPE,TRANS,INVER,LNNF,NNF,LNDSD,NNDSD)
where
The transformed mesh can be equipped with other physical attributes by associating new values to old reference or sub-domain numbers.
This module can be used to change the physical numbers of the mesh by defining an identity as a geometric transformation.
This module permits post-processing. In fact, if a problem exhibits symmetries, it could be solved on one part of the domain only. It is, on the other hand, interesting to plot the results on the entire domain. This is done by creating the symmetrical mesh of the part treated and the solution obtained by symmetry from the solution actually calculated; the 2 meshes and 2 solutions obtained must then be added together (see RECOLC). These type of operations are only possible for P1 (or Q1) meshes. The initial data must thus be converted to P1 (or Q1), which is the aim of this module.
Dimension array M (in the blank common), call INITI
CALL NOP2P1 (M,NFNOPE,NINOPE,NFNOPS,NINOPS)
where
Dimension array m (in the blank common), call INITI
CALL NOPGEO (M,NFNOPO,NINOPO,NFGEOM,NIGEOM)
where
Dimension array M (in the blank common), call INITI
CALL QUA4TR (M,NFNOPE,NINOPE,NFNOPS,NINOPS)
where
Dimension array M (in the blank common), call INITI
CALL QUADRA (M,NFNOPE,NINOPE,NFNOPS,NINOPS)
where
Furthermore, this module can be used to add 2 D.S. B, containing the solution corresponding to the 2 initial meshes in order to form the D.S. B corresponding to the mesh resulting from pasting together the 2 initial meshes.
Meshes and solutions are of type P1.
The method used to allocate the common items (points, edges and faces) in the 2 initial meshes is based on encoding the point positions by a hashing process. The common points are of two types:
The edges and faces are said to be identical if their extremities (in terms of points) are the same; we also have the distinction seen above where the reference number is either taken into account, or not, in the item under consideration.
The parameter defines the precision of the "gluing" operation.
Dimension array M (in the blank common), call INITI
CALL RECOLC (M,M,EPS,NFNOP1,NINOP1,NFNOP2,NINOP2,
. IOPT,IEB,NFB1,NIB1,NFB2,NIB2,NFNOPS,NINOPS,NTNOPS,
. NFBS,NIBS,NTBS)
where
If NTNOPS or NTBS is non-zero, it is necessary to input the following information on data cards
(free format):
Loop I from 1 to NTNOPS (NTBS)
The element numbers are output to an array for later use.
Dimension array M (in the blank common), declare the integer array, TABNUM, of LTAB words, call INITI
CALL REFNOP (M,M,M,NFNOPE,NINOPE,NREF,TABNUM,LONG)
where
Output the numbers of these points to an array for later use.
Dimension array M (in the blank common), declare the integer array, TABNUM, of LTAB words long, call INITI
CALL REFPOI (M,M,M,IACOOR,NP,NFNOPE,NINOPE,NREF,
. TABNUM,LONG)
where
Certain points are not affected by this transformation:
Dimension array M (in the blank common), declare the integer array, NPFIX, of NBFIX words, call INITI
CALL REGMA2 (M,NFNOPE,NINOPE,NFNOPS,NINOPS,
. NBI,NPFIX,NBFIX)
where
inter.psfig:regu2Initial meshinterregu.psfig:regu21Regularized
Dimension array M (in the blank common), declare the integer array NNFRON of 1 or NBFRON words, declare the
logical FONINT and the external FFRONT, call INITI
CALL RETRIN (M,NFNOPE,NINOPE,NFNOPS,NINOPS,NAUXI,N,
. NBFRON,NNFRON,FONINT,FFRONT)
where
afffin.psfig:retrInitial meshretr.psfig:retr1After splitting
The method applies to P1 Lagrange type elements.
Dimension array M (in the blank common), declare the integer arrays, NNF and NNDSD, of length 2 (if not used), or
2 LNNF and 2 LNDSD (see below), call INITI
CALL ROTNOP (M,NFNOPE,NINOPE,NFNOPS,NINOPS,A,B,C,X0,
. Y0,Z0,TETA,LNNF,NNF,LNDSD,NNDSD)
where
The method applies to P1 Lagrange type elements.
Dimension array M (in the blank common),
declare the integer arrays, NNF and NNDSD, of length 2
(if not used), or 2 LNNF and 2 LNDSD (see below), call INITI
CALL SYMNOP (M,NFNOPE,NINOPE,NFNOPS,NINOPS,A,B,C,D,
. LNNF,NNF,LNDSD,NNDSD)
where
The method applies to P1 Lagrange type elements.
Dimension array M (in the blank common), call INITI
CALL TN3D2D (M,NFNOPE,NINOPE,NFNOPS,NINOPS)
where
The method applies to P1 Lagrange type elements.
Dimension array M (in the blank common), declare the integer arrays, NNF and NNDSD, of length 2
(if not used), or 2 LNNF and 2 LNDSD (see below), call INITI
CALL TRANOP (M,NFNOPE,NINOPE,NFNOPS,NINOPS,A,B,C,
. LNNF,NNF,LNDSD,NNDSD)
where
Dimension array M (in the blank common), declare the integer array, REF, of length NBREF, call INITI
CALL TRCOAC (M,M,M,REF,NBREF,NFNOPE,NINOPE,NFNOPS,
. NINOPS)
where
For more detail, consult the MODULEF report [George et al. 1987].