37 MMG5_int k,kk,pp,l,ll,mins,mins1,maxs,maxs1;
38 MMG5_int *hcode,*link,inival,hsize,iadr;
50 printf(
" Exit program.\n");
59 for (k=0; k<=
mesh->
nt; k++)
63 for (k=1; k<=
mesh->
nt; k++) {
66 if ( !pt->
v[0] )
continue;
70 if ( pt->
v[i1] < pt->
v[i2] ) {
80 key = (
KTA*(int64_t)mins +
KTB*(int64_t)maxs)%hsize+1;
84 link[iadr] = hcode[key];
90 for (l=3*
mesh->
nt; l>0; l--) {
91 if ( link[l] >= 0 )
continue;
98 mins =
M_MIN(pt->
v[i1],pt->
v[i2]);
99 maxs =
M_MAX(pt->
v[i1],pt->
v[i2]);
106 while ( ll != inival ) {
112 if ( pt1->
v[i1] < pt1->
v[i2] ) {
121 if ( mins1 == mins && maxs1 == maxs ) {
123 if ( pp != 0 ) link[pp] = link[ll];
154 MMG5_int k,kk,pp,l,ll,mins,mins1,maxs,maxs1,iadr;
155 MMG5_int *hcode,*link,hsize,inival;
167 fprintf(stderr,
"\n ## Warning: %s: no re-build of adjacencies of quadrangles. "
168 "mesh->adjq must be freed to enforce analysis.\n",__func__);
174 fprintf(stdout,
" ** SETTING QUAD ADJACENCY\n");
178 fprintf(stderr,
" Exit program.\n");
196 if ( !
MG_EOK(pq) )
continue;
197 for (i=0; i<4; i++) {
200 if ( pq->
v[i1] < pq->
v[i2] ) {
210 key = (
KTA*(int64_t)mins +
KTB*(int64_t)maxs)%hsize+1;
214 link[iadr] = hcode[key];
220 if (
mesh->
info.
ddebug ) fprintf(stdout,
" h- stage 2: adjacencies\n");
222 for (l=iadr; l>0; l--) {
223 if ( link[l] >= 0 )
continue;
232 if ( pq->
v[i1] < pq->
v[i2] ) {
245 while ( ll != inival ) {
252 if ( pq1->
v[i1] < pq1->
v[i2] ) {
261 if ( mins1 == mins && maxs1 == maxs ) {
263 if ( pp != 0 ) link[pp] = link[ll];
279 for (k=1; k<=
mesh->
nt; k++) {
281 if ( !
MG_EOK(pt) )
continue;
284 for (i=0; i<3; i++) {
297 if ( !
MG_EOK(pq) )
continue;
300 for (i=0; i<4; i++) {
301 assert ( hcode[i] >= 0 );
355 for (k=1; k<=
mesh->
nt; k++) {
357 if ( !
MG_EOK(pt) )
continue;
365 for ( ia = 0; ia < 3; ++ia ) {
366 pt->
tag[ia] &= ~MG_REQ;
372 if ( !
mesh->
na )
return 1;
377 printf(
" ## Error: %s: Unable to allocate edge hash table\n.",__func__);
382 for (k=1; k<=
mesh->
na; k++) {
385 fprintf(stderr,
"\n ## Error: %s: unable to hash edge %" MMG5_PRId
" %" MMG5_PRId
".\n",__func__,
392 for (k=1; k<=
mesh->
nt; k++) {
394 if ( !
MG_EOK(pt) )
continue;
396 for (i=0; i<3; i++) {
412 if ( !
MG_EOK(pq) )
continue;
414 for (i=0; i<4; i++) {
450 MMG5_int k,*adja,natmp,iel;
457 for (k=1; k<=
mesh->
nt; k++) {
459 if ( !
MG_EOK(pt) )
continue;
463 for (i=0; i<3; i++) {
467 if ( iel && pt->
ref <= pt1->
ref )
continue;
476 for (k=1; k<=
mesh->
nt; k++) {
478 if ( !
MG_EOK(pt) )
continue;
482 for (i=0; i<3; i++) {
486 if ( iel && pt->
ref <= pt1->
ref )
continue;
503 for (k=1; k<=
mesh->
na; k++) {
532 MMG5_int np,ned,nt,k,iel,nbl,isol,isolnew,memWarn,nc;
533 MMG5_int iadr,iadrnew,iadrv,*adjav,*adja,*adjanew,voy;
541 fprintf(stderr,
"\n ## Warning: %s: hashing problem. Exit program.\n",
548 for (k=1; k<=
mesh->
np; k++) {
550 if ( !
MG_VOK(ppt) )
continue;
556 ppt->
tag &= ~MG_NOSURF;
566 fprintf(stderr,
"\n ## Warning: %s: unexpected edge table..."
567 " Ignored data.\n",__func__);
574 fprintf(stderr,
"\n ## Warning: %s: unable to build quad adjacencies."
575 " Quad edges will be ignored.\n",__func__);
581 for (k=1; k<=
mesh->
nt; k++) {
583 if ( !
MG_EOK(pt) )
continue;
586 for (i=0; i<3; i++) {
590 pt->
tag[i] &= ~MG_REQ;
591 pt->
tag[i] &= ~MG_NOSURF;
595 if ( (!iel) || (pt->
ref > pt1->
ref) ) {
612 if ( !
MG_EOK(pq) )
continue;
615 for (i=0; i<4; i++) {
624 if ( (!iel) || (pq->
ref > pq1->
ref) ) {
647 printf(
" -- Attempt to allocate a smallest edge table...\n");
651 fprintf(stderr,
"\n ## Warning: %s: uncomplete mesh.\n",
664 for (k=1; k<=
mesh->
nt; k++) {
666 if ( !
MG_EOK(pt) )
continue;
670 for (i=0; i<3; i++) {
675 if ( !iel || (pt->
ref > pt1->
ref) ||
695 if ( !
MG_EOK(pq) )
continue;
699 for (i=0; i<4; i++) {
711 if ( !iel || (pq->
ref > pq1->
ref) ||
729 for (k=1; k<=
mesh->
na; k++) {
731 if ( !ped->
a )
continue;
739 for (k=1; k<=
mesh->
nt; k++) {
741 if ( !
MG_EOK(pt) )
continue;
755 iadrnew = 3*(nbl-1) + 1;
759 adjanew[i] = adja[i];
760 if ( !adja[i] )
continue;
761 iadrv = 3*(adja[i]/3-1)+1;
764 adjav[adja[i]%3] = 3*nbl + voy;
780 assert( pq && pq1 &&
MG_EOK(pq1) );
785 while ( ++k < mesh->nquad );
791 if ( !
MG_EOK(pq) )
continue;
802 for (k=1; k<=
mesh->
np; k++) {
804 if ( !
MG_VOK(ppt) )
continue;
805 isol = k *
sol->size;
806 isolnew = nbl *
sol->size;
808 for (i=0; i<
sol->size; i++)
809 sol->m[isolnew + i] =
sol->m[isol + i];
814 if ( met && met->
m ) {
816 for (k=1; k<=
mesh->
np; k++) {
818 if ( !
MG_VOK(ppt) )
continue;
819 isol = k * met->
size;
820 isolnew = nbl * met->
size;
822 for (i=0; i<met->
size; i++)
823 met->
m[isolnew + i] = met->
m[isol + i];
831 for (k=1; k<=
mesh->
np; k++) {
833 if ( !
MG_VOK(ppt) )
continue;
839 assert ( ppt->
tmp == nbl );
853 for(k=1 ; k<=
mesh->
np ; k++)
858 for (k=
mesh->
npnil; k<mesh->npmax-1; k++)
868 for (k=
mesh->
nenil; k<mesh->ntmax-1; k++)
876 fprintf(stdout,
" NUMBER OF VERTICES %8" MMG5_PRId
" CORNERS %8" MMG5_PRId
"\n",
mesh->
np,nc);
877 fprintf(stdout,
" NUMBER OF TRIANGLES %8" MMG5_PRId
"\n",
mesh->
nt);
879 fprintf(stdout,
" NUMBER OF QUADRILATERALS %8" MMG5_PRId
"\n",
mesh->
nquad);
882 fprintf(stdout,
" NUMBER OF EDGES %8" MMG5_PRId
"\n",
mesh->
na);
885 if ( memWarn )
return 0;
MMG5_pMesh MMG5_pSol * sol
int MMG5_hashNew(MMG5_pMesh mesh, MMG5_Hash *hash, MMG5_int hsiz, MMG5_int hmax)
MMG5_int MMG5_hashGet(MMG5_Hash *hash, MMG5_int a, MMG5_int b)
int MMG5_hashEdge(MMG5_pMesh mesh, MMG5_Hash *hash, MMG5_int a, MMG5_int b, MMG5_int k)
int MMG2D_bdryEdge(MMG5_pMesh mesh)
int MMG2D_hashQuad(MMG5_pMesh mesh)
int MMG2D_assignEdge(MMG5_pMesh mesh)
int MMG2D_hashTria(MMG5_pMesh mesh)
int MMG2D_pack(MMG5_pMesh mesh, MMG5_pSol sol, MMG5_pSol met)
MMG5_int MMG2D_indPt(MMG5_pMesh mesh, MMG5_int kp)
static const unsigned int MMG2D_idir[5]
static const uint8_t MMG2D_idir_q[4][2]
idir[i]: vertices of edge i for a quad
void MMG2D_keep_only1Subdomain(MMG5_pMesh mesh, int nsd)
#define MMG5_SAFE_CALLOC(ptr, size, type, law)
#define MMG5_ADD_MEM(mesh, size, message, law)
static const uint8_t MMG5_iprv2[3]
static const uint8_t MMG5_inxt2[6]
#define MMG5_SAFE_FREE(ptr)
#define MMG5_DEL_MEM(mesh, ptr)
Structure to store edges of a MMG mesh.
Identic as MMG5_HGeom but use MMG5_hedge to store edges instead of MMG5_hgeom (memory economy).
Structure to store points of a MMG mesh.