FreeFem 3.5.x
List of all members
fem::femMesh Class Reference

Mesh class. More...

#include <femMesh.hpp>

Public Types

Typedefs
typedef long integer
 integer type
 
typedef long logical
 logical
 
typedef float femPoint[2]
 node type
 
typedef long femTriangle[3]
 cell type
 

Public Member Functions

Constructors and destructor
 femMesh ()
 
 femMesh (femMesh const &)
 
Accessors
int getNumberOfPoints () const
 
int getNumberOfCells () const
 
Mutators
void setDimensions (int, int)
 

Methods

femPointrp
 
femTriangletr
 
int * ngt
 
int * ng
 
void Delete ()
 delete the mesh More...
 
void removeBdyT ()
 
long create (long nbs, long nbsmax, long nba, float *crbdy, float *hbdy, long *arete, int *ngbdy, long *sd, long nbsd, int *flag, int fflag)
 prepare the mesh for generation More...
 
int mshptg_ (float *cr, float *h, long *c, long *nu, long *nbs, long nbsmx, long *tri, long *arete, long nba, long *sd, long nbsd, long *reft, long *nbt, float coef, float puis, long *err)
 mesh generator More...
 
int check (float *, int) const
 check the mesh More...
 

Detailed Description

Mesh class.

Finite element mesh using P1 elements(triangles).

Author
Christophe Prud'homme prudh.nosp@m.omm@.nosp@m.users.nosp@m..sou.nosp@m.rcefo.nosp@m.rge..nosp@m.net
Version
Id
femMesh.hpp,v 1.3 2001/07/12 15:15:39 delpinux Exp

Constructor & Destructor Documentation

◆ femMesh() [1/2]

fem::femMesh::femMesh ( )
51 :
52 np( 0 ),
53 nt( 0 ),
54 rp( 0 ),
55 tr( 0 ),
56 ngt( 0 ),
57 ng( 0 )
58{
59}

◆ femMesh() [2/2]

fem::femMesh::femMesh ( femMesh const &  __t)
62 :
63 np( __t.getNumberOfPoints() ),
64 nt( __t.getNumberOfCells() ),
65 rp( new femPoint[np] ),
66 tr( new femTriangle[nt] ),
67 ngt( new int[nt] ),
68 ng( new int[np] )
69{
70 for( int __i = 0; __i < np; __i++)
71 {
72 rp[__i][0] = __t.rp[__i][0];
73 rp[__i][1] = __t.rp[__i][1];
74 ng[__i] = __t.ng[__i];
75 }
76 for( int __i = 0; __i < nt; __i++)
77 {
78 tr[__i][0] = __t.tr[__i][0];
79 tr[__i][1] = __t.tr[__i][1];
80 tr[__i][2] = __t.tr[__i][2];
81 ngt[__i] = __t.ngt[__i];
82 }
83
84
85}
float femPoint[2]
node type
Definition: femMesh.hpp:67
long femTriangle[3]
cell type
Definition: femMesh.hpp:70

Member Function Documentation

◆ check()

int fem::femMesh::check ( float *  cr,
int  ns 
) const

check the mesh

279{
280 int i;
281 float xh, diameter = 1.F;
282
283 if (ns == 0)
284 return -1;
285 if (ns > 1)
286 {
287 diameter = 0.F;
288 for (i = 0; i < ns; i++)
289 diameter = amax (diameter, aabs (cr[2 * i] - cr[0]) + aabs (cr[2 * i + 1] - cr[1]));
290 }
291 else
292 diameter = 0.001F;
293 for (i = 0; i < ns; i++)
294 {
295 xh = aabs (cr[2 * i] - cr[2 * ns]) + aabs (cr[2 * i + 1] - cr[2 * ns + 1]);
296 if (xh < 1e-5 * diameter)
297 return i;
298 }
299 return -1;
300}

◆ create()

long fem::femMesh::create ( long  nbs,
long  nbsmax,
long  nba,
float *  crbdy,
float *  hbdy,
long *  arete,
int *  ngbdy,
long *  sd,
long  nbsd,
int *  flag,
int  fflag 
)

prepare the mesh for generation

193{
194 int i, j;
195 long err = 0, nbt, nbsold = nbs;
196 long *c = NULL;
197 long *tri = NULL;
198 long *nu = NULL;
199 long *reft = NULL;
200 int *ngg = NULL;
201 float *cr = NULL;
202 float *h = NULL;
203
204 nbt = 2 * nbsmax;
205 nu = new long[6*nbt];
206 c = new long[2*nbsmax];
207 ngg = new int[nbsmax];
208 tri = new long[(4 * nbsmax + 2 * nbsd)];
209 reft = new long[nbt];
210 cr = new float[(2 * nbsmax + 2)];
211 h = new float[nbsmax];
212
213 for (i = 0; i < 2 * nba; i++)
214 arete[i]++;
215 for (i = 0; i < nbs; i++)
216 {
217 ngg[i] = ngbdy[i];
218 cr[2 * i] = crbdy[2 * i];
219 cr[2 * i + 1] = crbdy[2 * i + 1];
220 h[i] = hbdy[i];
221 }
222 for (i = nbs; i < nbsmax; i++)
223 ngg[i] = 0;
224
225 mshptg_ (cr, h, c, nu, &nbs, nbsmax, tri, arete, nba, (long *) sd, nbsd, reft, &nbt, .25, .75, &err);
226 for (i = 0; i < 2 * nba; i++)
227 arete[i]--;
228 if (err)
229 goto L1;
230 if (*flag)
231 {
232 delete [] rp;rp = NULL;
233 delete [] tr;tr = NULL;
234 delete [] ng;ng = NULL;
235 delete [] ngt;ngt = NULL;
236 }
237 rp =new femPoint[nbs];
238 tr = new femTriangle[nbt];
239 ng = new int[nbs];
240 ngt = new int[nbt];
241
242 *flag = 1;
243 np = nbs;
244 nt = nbt;
245 for (i = 0; i < nbt; i++)
246 {
247 for (j = 0; j < 3; j++)
248 tr[i][j] = nu[3 * i + j] - 1;
249 ngt[i] = reft[i] - 1;
250 }
251 for (i = 0; i < nbs; i++)
252 {
253 rp[i][0] = cr[2 * i];
254 rp[i][1] = cr[2 * i + 1];
255 if (i < nbsold)
256 ng[i] = ngg[i];
257 else
258 ng[i] = 0;
259 }
260
261 renumerotate();
262 if(!fflag) removeBdyT();
263
264L1:
265 delete [] nu;nu = NULL;
266 delete [] cr;cr = NULL;
267 delete [] c;c = NULL;
268 delete [] tri;tri = NULL;
269 delete [] reft;reft = NULL;
270 delete [] ngg;ngg = NULL;
271 delete [] h;h = NULL;
272 return err;
273}
int mshptg_(float *cr, float *h, long *c, long *nu, long *nbs, long nbsmx, long *tri, long *arete, long nba, long *sd, long nbsd, long *reft, long *nbt, float coef, float puis, long *err)
mesh generator
Definition: femMesh.cpp:302

◆ Delete()

void fem::femMesh::Delete ( )
inline

delete the mesh

109 {
110 if (rp)
111 {
112 delete [] rp;
113 rp = NULL;
114 }
115 if (tr)
116 {
117 delete [] tr;
118 tr = NULL;
119 }
120 if (ng)
121 {
122 delete [] ng;
123 ng = NULL;
124 }
125 if (ngt)
126 {
127 delete [] ngt;
128 ngt = NULL;
129 }
130 }

◆ getNumberOfCells()

int fem::femMesh::getNumberOfCells ( ) const
inline
90 {
91 return nt;
92 }

◆ getNumberOfPoints()

int fem::femMesh::getNumberOfPoints ( ) const
inline
85 {
86 return np;
87 }

◆ mshptg_()

int fem::femMesh::mshptg_ ( float *  cr,
float *  h,
long *  c,
long *  nu,
long *  nbs,
long  nbsmx,
long *  tri,
long *  arete,
long  nba,
long *  sd,
long  nbsd,
long *  reft,
long *  nbt,
float  coef,
float  puis,
long *  err 
)

mesh generator

305{
306 /* System generated locals */
307 long i_1;
308
309 /* Local variables */
310 static long tete, i, j, k, t;
311 static float trfri[4];
312 static long nbsgrn, nbtgrn;
313
314/* ----------------------------------------------------------------------- */
315/* but: construire une triangulation a partir d'un ensemble de */
316/* points et d'un maillage frontalier */
317/* ----------------------------------------------------------------------- */
318/* entre : */
319/* ------- */
320/* cr(2,nbsmx) tableau des coordonnees des nbs points donnes */
321
322
323/* h (nbsmx) tableau du h local voulu autour de chaque point */
324/* donnes */
325/* nbs nombre de points donnes */
326/* nbsmx nombre de points maximal a cree */
327/* si nbs = nbsmx ont ne cree pas de points */
328/* si nbs < nbsmx => erreur */
329/* arete(2,nba) tableau des aretes du maillage a forcer */
330/* exemple :la frontiere */
331/* nba le nombre d'aretes du maillage */
332/* sd(2,nbsd) tableau definisant les nbsd sous domaine */
333/* (reference des femTriangles gerener) */
334/* abs(sd(1,i)) = numero d'une l'arete */
335/* si sd(1,i) est positive alors le sous domaine */
336/* est a gauche de l'arete sinon il est a droite */
337/* sd(2,i) donne le numero du sous doimaine */
338
339/* puis coefficent de generation des points */
340/* .1 => on propage plus loin les rafinement */
341/* donnes par h */
342/* .25 => valeur conseillee */
343/* coef coefficent sur le test arret */
344/* le valeur conseillee est .75 */
345/* remarque le nombre de point genere est en */
346/* O(coef**2) */
347
348/* tableaux de travail: */
349/* -------------------- */
350/* c(2,nbsmx) tableau d'entiers (copie de coordonnees) */
351/* tri(ltri) tableau d'entiers */
352/* out : */
353/* ----- */
354/* nbs nombre de points donnes + generes */
355/* nbt nombre de femTriangles generes */
356/* cr(1:2,nbs) coordonnees des sommets donnes + generes */
357/* nu(1:3,nbt) sommets des femTriangles (tableau des connections) */
358/* telle que les sommets tourne dans le sens direct */
359/* reft(1:nbt) numero de sous domaine de chaque femTriangle */
360/* err si err = 0 alors pas de probleme */
361/* sinon nbt = 0 et pas de triangulation */
362/* dimension des tableaux */
363/* ---------------------- */
364/* definition des parameters */
365/* nbtmx = 2*(nbs-1) , ltri = max(4*nbs+2*nbsd,nba) */
366/* long : nu(6*nbtmx) , reft(nbtmx) , c(2*nbsmx) , tri(ltri) */
367/* long : arete(2,nba), sd(2,nbsd) */
368/* float : cr(2*nbsmx) , h(nbsmx) */
369
370/* ---------------------------------------------------------------------- */
371/* programmeur F.Hecht, France */
372/* version 1.0 mars 1986 */
373/* ----------------------------------------------------------------------- */
374
375 /* Parameter adjustments */
376 --reft;
377 sd -= 3;
378 arete -= 3;
379 --tri;
380 --nu;
381 c -= 3;
382 --h;
383 cr -= 3;
384
385 /* Function Body */
386 *err = 0;
387 *nbt = 0;
388 if (*nbs < 3 || nbsmx < *nbs)
389 {
390 *err = 1;
391 return 0;
392 }
393/* ------------------------- */
394/* preparation des donnees */
395/* ------------------------- */
396 mshtri_ (&cr[3], &c[3], nbs, &tri[1], &tri[*nbs + 1], trfri, err);
397 if (*err != 0)
398 {
399 return 0;
400 }
401/* -------------------------------- */
402/* maillage de l enveloppe convexe */
403/* -------------------------------- */
404 mshcxi_ (&c[3], &nu[1], &tri[1], nbs, &tete, err);
405/* ----------------------------------------------------------------------- */
406/* definition de tableau nu(1:6,2*nbs-2) */
407/* ----------------------------------------------------------------------- */
408/* nu(*,ie) definit soit un element ,soit un sommet frontiere */
409/* si nu(5:6,ie) = (0,0) alors ie est un sommet frontiere */
410/* avec nu(1,ie) = numero du sommet */
411/* nu(2,ie) = 8*t + a */
412/* ou t est le numero du femTriangle ayant l'arete */
413/* frontiere (a) dont le premier sommet est nu(1,ie) */
414/* nu(3,ie) = pointeur dans nu sur sommet frontiere precedent */
415/* nu(4,ie) = pointeur dans nu sur sommet frontiere suivant */
416/* sinon ie est un element : */
417/* nu(1:3,ie) numero des 3 sommets du triangle ie tournant dans */
418/* le sens direct */
419/* nu(4:6,ie) = (d4,d5,d6) donnee des 3 aretes ai */
420/* ai est forme des sommets nu(i-3,ie),nu(mod(i,3)+1,ie) */
421/* si di < 0 alors arete i est frontiere et -di est pointeur */
422/* sur 1er sommet frontiere de i */
423/* sinon arete est interne et di = 8*ta + ata */
424/* ou ta est le numero du triangle adjacent a l'arete */
425/* et ata est le numero de l'arete dans ta */
426/* ------------------------------------------------------------------------ */
427 if (*err != 0)
428 {
429 return 0;
430 }
431
432 i_1 = *nbs;
433 for (i = 1; i <= i_1; ++i)
434 {
435 tri[i] = 0;
436 }
437 i = tete;
438L20:
439 j = nu[(i - 1) * 6 + 4];
440 tri[nu[(i - 1) * 6 + 1]] = nu[(j - 1) * 6 + 1];
441 i = j;
442 if (i != tete)
443 {
444 goto L20;
445 }
446/* ----------------------------- */
447/* traitement frontiere */
448/* ----------------------------- */
449 k = 0;
450 mshfrt_ (&c[3], &nu[1], nbs, &arete[3], nba, &sd[3], nbsd, &reft[1], &tri[
451 1], err);
452 if (*err != 0)
453 {
454 return 0;
455 }
456/* ------------------------------------------------------------------- */
457/* on a modifie nu les sommets frontiere n'ont plus de sens */
458/* ainsi que les pointeurs sur ces elements */
459/* ------------------------------------------------------------------- */
460 nbsgrn = *nbs;
461 mshgpt_ (&c[3], &cr[3], &nu[1], &h[1], &reft[1], &nbsgrn, nbsmx, &nbtgrn,
462 coef, puis, trfri, err);
463 if (*err != 0)
464 {
465 return 0;
466 }
467/* construction du tableau nu(1:3,1:nbt) */
468/* ------------------------------------------ */
469 *nbt = 0;
470 k = 0;
471 j = 1;
472 i_1 = nbtgrn;
473 for (t = 1; t <= i_1; ++t)
474 {
475 if (nu[j + 5] != 0)
476 {
477 ++(*nbt);
478 reft[*nbt] = reft[t];
479 for (i = 0; i <= 2; ++i)
480 {
481 ++k;
482 nu[k] = nu[j + i];
483 }
484 }
485 j += 6;
486 }
487/* dans nu il y a (s1(t),s2(t),s3(t),t=1,nbt) */
488/* ou s1 s2 s3 sont les 3 sommets de t */
489/* ------------------------------------------------ */
490 i_1 = *nbs;
491 for (i = 1; i <= i_1; ++i)
492 {
493 tri[i] = 1;
494 }
495 i_1 = nbsgrn;
496 for (i = *nbs + 1; i <= i_1; ++i)
497 {
498 tri[i] = 0;
499 }
500 mshvoi_ (&nu[1], &tri[nbsgrn + 1], &nu[*nbt * 3 + 1], nbt, &nbsgrn);
501 mshrgl_ (&cr[3], &tri[1], &nbsgrn, &nu[1], &tri[nbsgrn + 1], &nu[*nbt * 3
502 + 1], 1.4F, 20L, .005F);
503 *nbs = nbsgrn;
504 return 1;
505} /* mshptg_ */

◆ removeBdyT()

void fem::femMesh::removeBdyT ( )
124{ /* swap diagonals when a femTriangle has 3 bdy sides and reverse order if area<0 */
125 int k, j;
126 float area2;
127 femPoint *q = rp;
128
129 for (k = 0; k < nt; k++)
130 {
131 area2 = (q[tr[k][1]][0] - q[tr[k][0]][0]) * (q[tr[k][2]][1] - q[tr[k][0]][1])
132 - (q[tr[k][1]][1] - q[tr[k][0]][1]) * (q[tr[k][2]][0] - q[tr[k][0]][0]);
133 if (area2 <= 0)
134 {
135 j = tr[k][1];
136 tr[k][1] = tr[k][2];
137 tr[k][2] = j;
138 }
139 for (k = 0; k < nt; k++)
140 if ((ng[tr[k][0]] != 0) && (ng[tr[k][1]] != 0) && (ng[tr[k][2]] != 0))
141 swapWithNeibhor( k );
142 }
143}

◆ setDimensions()

void fem::femMesh::setDimensions ( int  p,
int  t 
)
90{
91 np = p;
92 nt = t;
93
94 rp = new femPoint[p];
95 tr = new femTriangle[t];
96 ng = new int[p];
97 ngt = new int[t];
98
99
100}

The documentation for this class was generated from the following files:

This is the FreeFEM reference manual
Provided by The KFEM project