Debian Codegraph @

3rdparty/mshmet/src/sourceslib/hessls.c

raw
1 #include "mshmet.h"
2
3
4 /* solve Mx=b using Gauss */
5 static int gauss(int n,double m[n][n],double *x,double *b,char dbg) {
6 double nn,dd;
7 int i,j,k,ip;
8
9 nn = m[0][0];
10 for (i=0; i<n; i++)
11 for (j=0; j<n; j++)
12 nn = MS_MAX(nn,m[i][j]);
13
14 if ( fabs(nn) < EPS1 ) {
15 if ( dbg ) fprintf(stdout," %%%% Null matrix\n");
16 return(0);
17 }
18 nn = 1.0 / nn;
19 for (i=0; i<n; i++) {
20 for (j=0; j<n; j++)
21 m[i][j] *= nn;
22 b[i] *= nn;
23 }
24
25 /* partial pivoting, column j */
26 for (j=0; j<n-1; j++) {
27 /* find line pivot */
28 ip = j;
29 for (i=j+1; i<n; i++)
30 if ( fabs(m[i][j]) > fabs(m[ip][j]) ) ip = i;
31
32 /* swap i <-> ip */
33 if ( i != ip ) {
34 for (k=j; k<n; k++) {
35 dd = m[j][k];
36 m[j][k] = m[ip][k];
37 m[ip][k] = dd;
38 }
39 dd = b[j];
40 b[j] = b[ip];
41 b[ip] = dd;
42 }
43 if ( fabs(m[j][j]) < EPS1 ) {
44 if ( dbg ) fprintf(stdout," %%%% Null pivot: %e.\n",m[j][i]);
45 return(0);
46 }
47
48 /* elimination */
49 for (i=j+1; i<n; i++) {
50 dd = m[i][j] / m[j][j];
51 m[i][j] = 0.0;
52 for (k=j+1; k<n; k++)
53 m[i][k] -= dd * m[j][k];
54 b[i] -= dd * b[j];
55 }
56 }
57
58 if ( fabs(m[n-1][n-1]) < EPS1 ) {
59 if ( dbg ) fprintf(stdout," %%%% Null pivot.\n");
60 return(0);
61 }
62
63 x[n-1] = b[n-1] / m[n-1][n-1];
64 for (i=n-2; i>=0; i--) {
65 dd = 0.0;
66 for (j=i+1; j<n; j++)
67 dd += m[i][j] * x[j];
68 x[i] = (b[i] - dd) / m[i][i];
69 }
70
71 if ( dbg ) {
72 for (i=0; i<n; i++) {
73 dd = 0.;
74 for (j=0; j<n; j++) dd += m[i][j] * x[j];
75 if ( fabs(dd-b[i]) > EPS ) {
76 fprintf(stdout," Ax[%d] = %f b[%d] = %E\n",i,dd,i,b[i]);
77 exit(1);
78 }
79 }
80 }
81
82 return(1);
83 }
84
85
86 /* least square approximation of hessian */
87 int hessLS_3d(pMesh mesh,pSol sol,int ip,int is) {
88 pPoint p0,p1;
89 pTetra pt;
90 double a[6],b[6],m[6][6],ax,ay,az;
91 double *grd,*hes,du,u,u1;
92 int i,j,l,iadr,ier,nsdep,ip1,list[LONMAX+2],ilist;
93
94 p0 = &mesh->point[ip];
95 if ( p0->nv < 6 ) return(-1);
96 nsdep = p0->s;
97 assert(nsdep);
98
99 i = 0;
100 pt = &mesh->tetra[nsdep];
101 if ( pt->v[1] == ip ) i = 1;
102 else if ( pt->v[2] == ip ) i = 2;
103 else if ( pt->v[3] == ip ) i = 3;
104
105 ilist = boulep(mesh,nsdep,i,list);
106 if ( ilist < 1 ) return(0);
107
108 memset(b,0,6*sizeof(double));
109 memset(m,0,36*sizeof(double));
110 u = getSol(sol,ip,is);
111
112 iadr = (ip-1)*sol->dim + 1;
113 grd = &sol->grd[iadr];
114
115 /* Hessian: Ui = U + <gradU,PPi> + 0.5*(tPPi.Hess.PPi) */
116 for (i=1; i<=ilist; i++) {
117 ip1 = list[i];
118 p1 = &mesh->point[ip1];
119 u1 = getSol(sol,ip1,is);
120
121 ax = p1->c[0] - p0->c[0];
122 ay = p1->c[1] - p0->c[1];
123 az = p1->c[2] - p0->c[2];
124
125 a[0] = 0.5 * ax*ax;
126 a[1] = ax*ay;
127 a[2] = ax*az;
128 a[3] = 0.5 * ay*ay;
129 a[4] = ay*az;
130 a[5] = 0.5 * az*az;
131 du = (u1-u) - (ax*grd[0] + ay*grd[1] + az*grd[2]);
132
133 /* M = At*A symmetric positive definite */
134 for (j=0; j<6; j++)
135 for (l=j; l<6; l++) {
136 m[j][l] += a[j]*a[l];
137 m[l][j] += a[l]*a[j];
138 }
139
140 /* c = At*b */
141 for (j=0; j<6; j++)
142 b[j] += a[j]*du;
143 }
144
145 /* solve m(6,6)*x(6) = b(6) */
146 iadr = 6*(ip-1) + 1;
147 hes = &sol->hes[iadr];
148
149 ier = gauss(6,m,hes,b,mesh->info.ddebug);
150 if ( !ier ) {
151 if ( mesh->info.ddebug ) fprintf(stdout," Ill cond'ed matrix (%d, %d).\n",ip,ier);
152 return(-1);
153 }
154
155 p0->h = 1;
156 return(1);
157 }
158
159
160 /* least square approximation of hessian */
161 int hessLS_2d(pMesh mesh,pSol sol,int ip,int is) {
162 pPoint p0,p1;
163 pTria pt;
164 double a[3],ma[6],mb[3],ax,ay;
165 double det,aa,bb,cc,dd,ee,ff;
166 double *grd,*hes,u,u1;
167 int i,iadr,nsdep,ip1,list[LONMAX+2],ilist;
168
169 p0 = &mesh->point[ip];
170 if ( p0->nv < 3 ) return(-1);
171 nsdep = p0->s;
172 assert(nsdep);
173
174 pt = &mesh->tria[nsdep];
175 if ( pt->v[0] == ip ) i = 0;
176 else if ( pt->v[1] == ip ) i = 1;
177 else i = 2;
178
179 ilist = boulep(mesh,nsdep,i,list);
180 if ( ilist < 1 ) return(0);
181
182 memset(ma,0,6*sizeof(double));
183 memset(mb,0,3*sizeof(double));
184 u = getSol(sol,ip,is);
185
186 iadr = (ip-1)*sol->dim + 1;
187 grd = &sol->grd[iadr];
188
189 /* Hessian: Ui = U + <gradU,PPi> + 0.5*(tPPi.Hess.PPi) */
190 for (i=1; i<=ilist; i++) {
191 ip1 = list[i];
192 p1 = &mesh->point[ip1];
193 u1 = getSol(sol,ip1,is);
194
195 ax = p1->c[0] - p0->c[0];
196 ay = p1->c[1] - p0->c[1];
197 a[0] = 0.5 * ax*ax;
198 a[1] = ax*ay;
199 a[2] = 0.5 * ay*ay;
200 dd = (u1-u) - (ax*grd[0] + ay*grd[1]);
201
202 /* M = At*A symmetric definite positive */
203 ma[0] += a[0]*a[0];
204 ma[1] += a[0]*a[1];
205 ma[2] += a[1]*a[1];
206 ma[3] += a[0]*a[2];
207 ma[4] += a[1]*a[2];
208 ma[5] += a[2]*a[2];
209
210 /* c = At*b */
211 mb[0] += a[0]*dd;
212 mb[1] += a[1]*dd;
213 mb[2] += a[2]*dd;
214 }
215
216 if ( fabs(ma[0]) < EPS1 ) {
217 if ( mesh->info.ddebug ) fprintf(stdout," Ill cond'ed matrix (%d, %E).\n",ip,ma[0]);
218 return(-1);
219 }
220
221 /* direct solving */
222 aa = ma[2]*ma[5] - ma[4]*ma[4];
223 bb = ma[4]*ma[3] - ma[1]*ma[5];
224 cc = ma[1]*ma[4] - ma[2]*ma[3];
225 dd = ma[0]*aa + ma[1]*bb + ma[3]*cc;
226
227 /* singular matrix */
228 if ( fabs(dd) == 0.0 ) {
229 if ( mesh->info.ddebug ) fprintf(stderr," Singular matrix (%d, %E).\n",ip,dd);
230 return(-1);
231 }
232 det = 1.0 / dd;
233 dd = ma[0]*ma[5] - ma[3]*ma[3];
234 ee = ma[1]*ma[3] - ma[0]*ma[4];
235 ff = ma[0]*ma[2] - ma[1]*ma[1];
236
237 iadr = (ip-1)*3 + 1;
238 hes = &sol->hes[iadr];
239
240 hes[0] = (mb[0]*aa + mb[1]*bb + mb[2]*cc) * det;
241 hes[1] = (mb[0]*bb + mb[1]*dd + mb[2]*ee) * det;
242 hes[2] = (mb[0]*cc + mb[1]*ee + mb[2]*ff) * det;
243
244 if ( !p0->b && p0->nv == 4 ) return(-1);
245
246 p0->h = 1;
247 return(1);
248 }
249
250
251 int hessLS_s(pMesh mesh,pSol sol,int ip,int is) {
252 pPoint p0,p1;
253 pTria pt;
254 double a[6],b[6],m[6][6],ax,ay,az;
255 double *grd,*hes,du,u,u1;
256 int i,j,l,iadr,ier,nsdep,ip1,list[LONMAX+2],ilist;
257
258 p0 = &mesh->point[ip];
259 if ( p0->nv < 3 ) return(-1);
260 nsdep = p0->s;
261 assert(nsdep);
262
263 i = 0;
264 pt = &mesh->tria[nsdep];
265 if ( pt->v[1] == ip ) i = 1;
266 else if ( pt->v[2] == ip ) i = 2;
267
268 ilist = boulep(mesh,nsdep,i,list);
269 if ( ilist < 1 ) return(0);
270
271 memset(b,0,6*sizeof(double));
272 memset(m,0,36*sizeof(double));
273 u = getSol(sol,ip,is);
274
275 iadr = (ip-1)*sol->dim + 1;
276 grd = &sol->grd[iadr];
277
278 /* Hessian: Ui = U + <gradU,PPi> + 0.5*(tPPi.Hess.PPi) */
279 for (i=1; i<=ilist; i++) {
280 ip1 = list[i];
281 p1 = &mesh->point[ip1];
282 u1 = getSol(sol,ip1,is);
283
284 ax = p1->c[0] - p0->c[0];
285 ay = p1->c[1] - p0->c[1];
286 az = p1->c[2] - p0->c[2];
287
288 a[0] = 0.5 * ax*ax;
289 a[1] = ax*ay;
290 a[2] = ax*az;
291 a[3] = 0.5 * ay*ay;
292 a[4] = ay*az;
293 a[5] = 0.5 * az*az;
294 du = (u1-u) - (ax*grd[0] + ay*grd[1] + az*grd[2]);
295
296 /* M = At*A symmetric positive definite */
297 for (j=0; j<6; j++)
298 for (l=j; l<6; l++) {
299 m[j][l] += a[j]*a[l];
300 m[l][j] += a[l]*a[j];
301 }
302
303 /* c = At*b */
304 for (j=0; j<6; j++)
305 b[j] += a[j]*du;
306 }
307
308 /* solve m(6,6)*x(6) = b(6) */
309 iadr = (ip-1)*6 + 1;
310 hes = &sol->hes[iadr];
311
312 ier = gauss(6,m,hes,b,mesh->info.ddebug);
313 if ( !ier ) {
314 if ( mesh->info.ddebug ) fprintf(stdout," Ill cond'ed matrix (%d, %d).\n",ip,ier);
315 return(-1);
316 }
317
318 p0->h = 1;
319 return(1);
320 }
321
322
323 /* average values of neighbors */
324 int avgval_3d(pMesh mesh,pSol sol,int ip) {
325 pPoint p0,p1;
326 pTetra pt;
327 double *hes,dd;
328 int i,j,iadr,nsdep,ip1,nb,list[LONMAX+2],ilist;
329
330 p0 = &mesh->point[ip];
331 nsdep = p0->s;
332 assert(nsdep);
333
334 i = 0;
335 pt = &mesh->tetra[nsdep];
336 if ( pt->v[1] == ip ) i = 1;
337 else if ( pt->v[2] == ip ) i = 2;
338 else if ( pt->v[3] == ip ) i = 3;
339
340 ilist = boulep(mesh,nsdep,i,list);
341 if ( ilist < 1 ) return(0);
342
343 iadr = (ip-1)*6 + 1;
344 hes = &sol->hes[iadr];
345 memset(hes,0,6*sizeof(double));
346 nb = 0;
347 for (i=1; i<=ilist; i++) {
348 ip1 = list[i];
349 p1 = &mesh->point[ip1];
350 if ( p1->h > 0 ) {
351 iadr = (ip1-1)*6 + 1;
352 for (j=0; j<6; j++)
353 hes[j] += sol->hes[iadr+j];
354 nb++;
355 }
356 }
357
358 if ( nb > 0 ) {
359 dd = 1.0 / (double)nb;
360 for (j=0; j<6; j++)
361 hes[j] = hes[j] * dd;
362 p0->h = 1;
363 return(1);
364 }
365
366 return(0);
367 }
368
369
370 int avgval_2d(pMesh mesh,pSol sol,int ip) {
371 pPoint p0,p1;
372 pTria pt;
373 double *hes,dd;
374 int i,j,iadr,nsdep,ip1,nb,list[LONMAX+2],ilist;
375
376 p0 = &mesh->point[ip];
377 nsdep = p0->s;
378 assert(nsdep);
379
380 pt = &mesh->tria[nsdep];
381 if ( pt->v[0] == ip ) i = 0;
382 else if ( pt->v[1] == ip ) i = 1;
383 else i = 2;
384
385 ilist = boulep(mesh,nsdep,i,list);
386 if ( ilist < 1 ) return(0);
387
388 iadr = (ip-1)*3 + 1;
389 hes = &sol->hes[iadr];
390 memset(hes,0,3*sizeof(double));
391 nb = 0;
392 for (i=1; i<=ilist; i++) {
393 ip1 = list[i];
394 p1 = &mesh->point[ip1];
395 if ( p1->h > 0 ) {
396 iadr = (ip1-1)*3 +1;
397 for (j=0; j<3; j++)
398 hes[j] += sol->hes[iadr+j];
399 nb++;
400 }
401 }
402
403 if ( nb > 0 ) {
404 dd = 1.0 / (double)nb;
405 for (j=0; j<3; j++)
406 hes[j] = hes[j] * dd;
407 p0->h = 1;
408 return(1);
409 }
410
411 return(0);
412 }
413
414
415 /* assign value of closest vertex */
416 int clsval_3d(pMesh mesh,pSol sol,int ip) {
417 pPoint p0,p1;
418 pTetra pt;
419 double *hes;
420 int i,j,iadr,nsdep,ip1;
421
422 p0 = &mesh->point[ip];
423 nsdep = p0->s;
424 assert(nsdep);
425
426 pt = &mesh->tetra[nsdep];
427 iadr = (ip-1)*6 + 1;
428 hes = &sol->hes[iadr];
429 for (i=0; i<4; i++) {
430 ip1 = pt->v[i];
431 p1 = &mesh->point[ip1];
432 if ( p1->h ) {
433 iadr = (ip1-1)*6 + 1;
434 for (j=0; j<6; j++)
435 hes[j] = sol->hes[iadr+j];
436 p0->h = 1;
437 return(1);
438 }
439 }
440
441 return(0);
442 }
443
444
445 int clsval_2d(pMesh mesh,pSol sol,int ip) {
446 pPoint p0,p1;
447 pTria pt;
448 double *hes;
449 int i,j,iadr,nsdep,ip1;
450
451 p0 = &mesh->point[ip];
452 nsdep = p0->s;
453 assert(nsdep);
454
455 pt = &mesh->tria[nsdep];
456 iadr = (ip-1)*3 + 1;
457 hes = &sol->hes[iadr];
458 for (i=0; i<3; i++) {
459 ip1 = pt->v[i];
460 p1 = &mesh->point[ip1];
461 if ( p1->h ) {
462 iadr = (ip1-1)*3 + 1;
463 for (j=0; j<3; j++)
464 hes[j] = sol->hes[iadr+j];
465 p0->h = 1;
466 return(1);
467 }
468 }
469
470 return(0);
471 }
472
473
474 int nrmhes_3d(pMesh mesh,pSol sol,int is) {
475 pPoint p0;
476 Info info;
477 double err,err1,errs,u,norm;
478 int i,k,iadr;
479
480 info = mesh->info;
481
482 if ( info.nnu > 0 || mesh->info.ls ) {
483 for (k=1; k<=mesh->np; k++) {
484 u = fabs(getSol(sol,k,is));
485 sol->umax = MS_MAX(u,sol->umax);
486 }
487 }
488
489 switch(info.nnu) {
490 /* no norm */
491 case 0:
492 err = CTE3D / info.eps;
493 for (k=1; k<=mesh->np; k++) {
494 iadr = (k-1)*6 + 1;
495 for (i=0; i<6; i++) sol->hes[iadr+i] *= err;
496 }
497 break;
498
499 /* relative value: M(u)= |H(u)| / (err*||u||_inf) */
500 case 1:
501 default:
502 if ( sol->umax < 1e-30 ) return(1);
503 err = CTE3D / (info.eps * sol->umax);
504 for (k=1; k<=mesh->np; k++) {
505 iadr = (k-1)*6 + 1;
506 for (i=0; i<6; i++) sol->hes[iadr+i] *= err;
507 }
508 break;
509
510 /* local norm: M(u)= |H(u)| / err*|u| */
511 case 2:
512 errs = sol->umax > 0.0 ? sol->umax*0.01 : 0.01;
513 for (k=1; k<=mesh->np; k++) {
514 u = fabs(getSol(sol,k,is));
515 err = CTE3D / MS_MAX(errs,u);
516 iadr = (k-1)*6 + 1;
517 for (i=0; i<6; i++) sol->hes[iadr+i] *= err;
518 }
519 break;
520
521 /* local norm: M(u)= |H(u)| / err*(e1*|u|+e2*h*|du|) */
522 case 3:
523 puts("A CODER");
524 exit(1);
525 /*
526 maxu = 0.0;
527 maxg = 0.0;
528 for (k=1; k<=mesh->np; k++) {
529 u = fabs(getSol(sol,k,is));
530 maxu = MS_MAX(maxu,u);
531 norm = der[k].grd[0]*der[k].grd[0] + der[k].grd[1]*der[k].grd[1] + der[k].grd[2]*der[k].grd[2];
532 norm = sqrt(norm);
533 if ( norm > maxg ) maxg = norm;
534 }
535 if ( maxu == 0.0 )
536 errs = 0.01;
537 else
538 errs = maxu * 0.01;
539 err1 = maxg * 0.01;
540
541 for (k=1; k<=mesh->np; k++) {
542 p0 = &mesh->point[k];
543 u = getSol(sol,k,is);
544 norm = der[k].grd[0]*der[k].grd[0] + der[k].grd[1]*der[k].grd[1] + der[k].grd[2]*der[k].grd[2];
545 norm = sqrt(norm);
546 norm = MS_MAX(err1,norm);
547 //norm *= p0->rins / p0->nv;
548 err1 = MS_MAX(errs,fabs(u));
549
550 /* variable weight /
551 err1 = 0.01*err1 + 0.01*norm;
552 maxu = CTE3D / (info.eps*err1);
553 for (i=0; i<6; i++) der[k].hes[i] *= maxu;
554 }
555 */
556 break;
557 }
558
559 return(1);
560 }
561
562
563 int nrmhes_2d(pMesh mesh,pSol sol,int is) {
564 pPoint p0;
565 Info info;
566 double err,err1,errs,u,norm;
567 int i,k,iadr;
568
569 info = mesh->info;
570
571 if ( info.nnu > 0 || mesh->info.ls ) {
572 sol->umax = 0.0;
573 for (k=1; k<=mesh->np; k++) {
574 u = fabs(getSol(sol,k,is));
575 sol->umax = MS_MAX(u,sol->umax);
576 }
577 }
578
579 switch(info.nnu) {
580 /* no norm */
581 case 0:
582 err = CTE2D / info.eps;
583 for (k=1; k<=mesh->np; k++) {
584 iadr = (k-1)*3 + 1;
585 for (i=0; i<3; i++) sol->hes[iadr+i] *= err;
586 }
587 break;
588
589 /* relative value: M(u)= |H(u)| / err*||u||_inf */
590 case 1:
591 default:
592 if ( fabs(sol->umax) < 1e-30 ) return(1);
593 err = CTE2D / (info.eps * sol->umax);
594 for (k=1; k<=mesh->np; k++) {
595 iadr = (k-1)*3 + 1;
596 for (i=0; i<3; i++) sol->hes[iadr+i] *= err;
597 }
598 break;
599
600 /* local norm: M(u)= |H(u)| / err*|u| */
601 case 2:
602 errs = sol->umax > 0.0 ? sol->umax*0.01 : 0.01;
603 for (k=1; k<=mesh->np; k++) {
604 u = fabs(getSol(sol,k,is));
605 err = CTE2D / MS_MAX(errs,u);
606 iadr = (k-1)*3 + 1;
607 for (i=0; i<3; i++) sol->hes[iadr+i] *= err;
608 }
609 break;
610
611 /* local norm: M(u)= |H(u)| / err*(e1*|u|+e2*h*|du|) */
612 case 3:
613 puts("A CODER");
614 exit(1);
615 /*
616 maxg = 0.0;
617 for (k=1; k<=mesh->np; k++) {
618 u = fabs(getSol(sol,k,is));
619 norm = der[k].grd[0]*der[k].grd[0] + der[k].grd[1]*der[k].grd[1];
620 norm = sqrt(norm);
621 if ( norm > maxg ) maxg = norm;
622 }
623 if ( sol->umax < 1.0e-30 )
624 errs = 0.01;
625 else
626 errs = sol->umax * 0.01;
627 err1 = maxg * 0.01;
628
629 for (k=1; k<=mesh->np; k++) {
630 p0 = &mesh->point[k];
631 u = getSol(sol,k,is);
632 norm = der[k].grd[0]*der[k].grd[0] + der[k].grd[1]*der[k].grd[1];
633 norm = sqrt(norm);
634 norm = MS_MAX(err1,norm);
635 puts("A CODER");
636 exit(1);
637 //norm *= p0->rins / p0->nv;
638 err1 = MS_MAX(errs,fabs(u));
639
640 /* variable weight *
641 err1 = 0.01*err1 + 0.01*norm;
642 maxu = CTE2D / (info.eps*err1);
643 der[k].hes[0] *= maxu;
644 der[k].hes[1] *= maxu;
645 der[k].hes[2] *= maxu;
646 } */
647 break;
648 }
649
650 return(1);
651 }
652
653
654 /* build metric for levelsets */
655 static double fsize(pMesh mesh,double u) {
656 double dd;
657
658 if ( u < mesh->info.width )
659 dd = mesh->info.hmin;
660 else
661 dd = mesh->info.hmin + u * (mesh->info.hmax - mesh->info.hmin);
662
663 return(dd);
664 }
665
666
667 /* compute ansotropic metric for levelset */
668 int metrLS_3d(pMesh mesh,pSol sol) {
669 double *tmet,*grd,*hes,mat[6],mr[6],e1[3],e2[3],e3[3],dd,u,urel,rap;
670 double tail,kappa,hh,hhmin,hhmax,lambda1,lambda2,lambda3,dx2,dy2,dz2,dxy,dxz,dyz;
671 int i,j,k,l,ias,iadr;
672
673 hhmin = 1.0 / (mesh->info.hmin*mesh->info.hmin);
674 hhmax = 1.0 / (mesh->info.hmax*mesh->info.hmax);
675
676 for (k=1; k<=mesh->np; k++) {
677 u = fabs(getSol(sol,k,0));
678 urel = u / sol->umax;
679 hh = fsize(mesh,urel);
680 lambda3 = 1.0 / (hh*hh);
681
682 iadr = (k-1)*3 + 1;
683 grd = &sol->grd[iadr];
684 iadr = (k-1)*6 + 1;
685 hes = &sol->hes[iadr];
686
687 /* gradient norm */
688 dx2 = grd[0]*grd[0];
689 dxy = grd[0]*grd[1];
690 dxz = grd[0]*grd[2];
691 dy2 = grd[1]*grd[1];
692 dyz = grd[1]*grd[2];
693 dz2 = grd[2]*grd[2];
694 dd = dx2 + dy2 + dz2;
695
696 /* curvature */
697 kappa = 0.0;
698 if ( dd > EPS1 ) {
699 kappa = dx2*hes[3] + dz2*hes[3] + dy2*hes[0] + dz2*hes[0] + dx2*hes[5] + dy2*hes[5] \
700 - 2.0 * (dxy*hes[1] + dxz*hes[2] + dyz*hes[4]);
701 kappa = fabs(kappa) / 2.0 * sqrt(dd*dd*dd);
702 }
703
704 /* vicinity of isovalue */
705 if ( urel < mesh->info.width ) {
706 lambda1 = kappa / mesh->info.eps; //kappa*kappa*eps; //(eps*hh);
707 lambda1 = MS_MIN(lambda1,hhmin);
708 lambda1 = MS_MAX(lambda1,hhmax);
709 lambda2 = lambda1;
710 }
711 else
712 lambda1 = lambda2 = hhmax;
713
714 /* isotropic */
715 if ( mesh->info.iso ) {
716 if ( lambda3 > lambda1 )
717 tail = 1.0 / sqrt(lambda3);
718 else
719 tail = 1.0 / sqrt(lambda1);
720 if ( !mesh->info.metric ) {
721 sol->met[k] = tail;
722 }
723 else
724 sol->met[k] = MS_MIN(sol->met[k],tail);
725 }
726 else {
727 /* lambda_i = sizes, truncation */
728 if ( mesh->info.ani > 0.0 ) {
729 if ( lambda1 > lambda3 ) {
730 rap = lambda1 / lambda3;
731 if ( rap*rap > mesh->info.ani ) {
732 lambda3 = lambda1 /(mesh->info.ani * mesh->info.ani);
733 lambda3 = MS_MIN(lambda3,hhmin);
734 lambda3 = MS_MAX(lambda3,hhmax);
735 }
736 }
737 else {
738 rap = lambda3 / lambda1;
739 if ( rap*rap > mesh->info.ani ) {
740 lambda1 = lambda3 /(mesh->info.ani * mesh->info.ani);
741 lambda1 = MS_MIN(lambda1,hhmin);
742 lambda1 = MS_MAX(lambda1,hhmax);
743 lambda2 = lambda1;
744 }
745 }
746 }
747
748 /* compute local basis */
749 dd = sqrt(dd);
750 if ( fabs(dd) > EPS1 ) {
751 memcpy(e3,grd,3*sizeof(double));
752 e3[0] /= dd;
753 e3[1] /= dd;
754 e3[2] /= dd;
755 if ( fabs(grd[0]) > EPS1 ) {
756 e2[0] = -(grd[1]+grd[2]) / grd[0];
757 e2[1] = e2[2] = 1.0;
758 }
759 else if ( fabs(grd[1]) > EPS1 ) {
760 e2[1] = -(grd[0]+grd[2]) / grd[1];
761 e2[0] = e2[2] = 1.0;
762 }
763 else if ( fabs(grd[2]) > EPS1 ) {
764 e2[2] = -(grd[0]+grd[1]) / grd[2];
765 e2[0] = e2[1] = 1.0;
766 }
767 else {
768 e2[0] = 0.0; e2[1] = 1.0; e2[2] = 0.0;
769 }
770 dd = sqrt(e2[0]*e2[0]+e2[1]*e2[1]+e2[2]*e2[2]);
771 if ( fabs(dd) > EPS1 ) {
772 e2[0] /= dd;
773 e2[1] /= dd;
774 e2[2] /= dd;
775 }
776 e1[0] = e2[1]*e3[2] - e2[2]*e3[1];
777 e1[1] = e2[2]*e3[0] - e2[0]*e3[2];
778 e1[2] = e2[0]*e3[1] - e2[1]*e3[0];
779 }
780 else {
781 e1[0] = 1.0; e1[1] = 0.0; e1[2] = 0.0;
782 e2[0] = 0.0; e2[1] = 1.0; e2[2] = 0.0;
783 e3[0] = 0.0; e3[1] = 0.; e3[2] = 1.0;
784 }
785
786 ias = (k-1)*6 + 1;
787 tmet = &sol->met[ias];
788
789 /* set coeffs directly */
790 if ( !mesh->info.metric ) {
791 for (l=0,i=0; i<3; i++)
792 for (j=i; j<3; j++)
793 tmet[l++] = lambda1*e1[i]*e1[j] + lambda2*e2[i]*e2[j] + lambda3*e3[i]*e3[j];
794 }
795 else {
796 for (l=0,i=0; i<3; i++) {
797 for (j=i; j<3; j++)
798 mat[l++] = lambda1*e1[i]*e1[j] + lambda2*e2[i]*e2[j] + lambda3*e3[i]*e3[j];
799 }
800 if ( !redsim(tmet,mat,mr) ) {
801 fprintf(stdout," %%%% Metric problem (point: %d)\n",k);
802 if ( mesh->info.ddebug ) {
803 fprintf(stdout," lambda: %e %e %e\n",lambda1,lambda2,lambda3);
804 fprintf(stdout," mat %e %e %e %e %e %e\n",mat[0],mat[1],mat[2],mat[3],mat[4],mat[5]);
805 fprintf(stdout," mat %e %e %e %e %e %e\n",tmet[0],tmet[1],tmet[2],tmet[3],tmet[4],tmet[5]);
806 }
807 /*memset(tmet,0,6*sizeof(double));
808 tmet[0] = tmet[3] = tmet[5] = hhmax;*/
809 }
810 else
811 for (i=0; i<6 ; i++) tmet[i] = mr[i];
812 }
813 }
814 }
815
816 return(1);
817 }
818
819
820 int metrLS_2d(pMesh mesh,pSol sol) {
821 double *tmet,*hes,*grd,mat[3],mr[3],u,urel;
822 double rap,tail,kappa,hh,hhmin,hhmax,lambda1,lambda2,dd,dx2,dy2,dxy;
823 int k,ias,iadr;
824
825 hhmin = 1.0 / (mesh->info.hmin*mesh->info.hmin);
826 hhmax = 1.0 / (mesh->info.hmax*mesh->info.hmax);
827
828 for (k=1; k<=mesh->np; k++) {
829 u = fabs(getSol(sol,k,0));
830 urel = u / sol->umax;
831 hh = fsize(mesh,urel);
832 lambda1 = 1.0 / (hh*hh);
833
834 iadr = (k-1)*2 + 1;
835 grd = &sol->grd[iadr];
836 iadr = (k-1)*3 + 1;
837 hes = &sol->hes[iadr];
838
839 dx2 = grd[0]*grd[0];
840 dxy = grd[0]*grd[1];
841 dy2 = grd[1]*grd[1];
842 dd = dx2 + dy2;
843 kappa = dx2*hes[2] - 2.0*dxy*hes[1] + dy2*hes[0];
844 kappa = fabs(kappa) / 2.0 * sqrt(dd*dd*dd);
845
846 if ( urel < mesh->info.width ) {
847 lambda2 = kappa / mesh->info.eps;
848 lambda2 = MS_MAX(lambda2,hhmin);
849 lambda2 = MS_MIN(lambda2,hhmax);
850 }
851 else {
852 lambda2 = hhmax;
853 }
854 lambda2 = MS_MAX(lambda2,hhmin); /* <-- chgt le 16/03/09 */
855 lambda2 = MS_MIN(lambda2,hhmax);
856
857 /* isotropic */
858 if ( mesh->info.iso ) {
859 if ( lambda1 > lambda2 )
860 tail = 1.0 / sqrt(lambda1);
861 else
862 tail = 1.0 / sqrt(lambda2);
863 if ( !mesh->info.metric )
864 sol->met[k] = tail;
865 else
866 sol->met[k] = MS_MIN(sol->met[k],tail);
867 }
868 else {
869 /* lambda_i = sizes, truncation */
870 if ( mesh->info.ani > 0.0 ) {
871 if ( lambda1 > lambda2 ) {
872 rap = lambda1 / lambda2;
873 if ( rap*rap > mesh->info.ani ) {
874 lambda2 = lambda1 /(mesh->info.ani * mesh->info.ani);
875 lambda2 = MS_MIN(lambda2,hhmin);
876 lambda2 = MS_MAX(lambda2,hhmax);
877 }
878 }
879 else {
880 rap = lambda2 / lambda1;
881 if ( rap*rap > mesh->info.ani ) {
882 lambda1 = lambda2 /(mesh->info.ani * mesh->info.ani);
883 lambda1 = MS_MIN(lambda1,hhmin);
884 lambda1 = MS_MAX(lambda1,hhmax);
885 }
886 }
887 }
888 ias = (k-1)*3 + 1;
889 tmet = &sol->met[ias];
890 if ( !mesh->info.metric ) {
891 if ( fabs(hes[0]) < EPS1 && fabs(hes[1]) < EPS1 && fabs(hes[2]) < EPS1 ) {
892 tmet[0] = lambda1;
893 tmet[1] = 0.0;
894 tmet[2] = lambda2;
895 }
896 else {
897 tmet[0] = lambda1*dx2 + lambda2*dy2;
898 tmet[1] = (lambda1-lambda2)*dxy;
899 tmet[2] = lambda2*dx2 + lambda1*dy2;
900 }
901 }
902 else {
903 if ( fabs(hes[0]) < EPS1 && fabs(hes[1]) < EPS1 && fabs(hes[2]) < EPS1 ) {
904 mat[0] = lambda1;
905 mat[1] = 0.0;
906 mat[2] = lambda2;
907 }
908 else {
909 mat[0] = lambda1*dx2 + lambda2*dy2;
910 mat[1] = (lambda1-lambda2)*dxy;
911 mat[2] = lambda2*dx2 + lambda1*dy2;
912 }
913 if ( !redsim(tmet,mat,mr) ) return(0);
914 tmet[0] = mr[0];
915 tmet[1] = mr[1];
916 tmet[2] = mr[2];
917 }
918 }
919 }
920
921 return(1);
922 }