Debian Codegraph @

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

raw
1 #include "mshmet.h"
2
3
4 /* return unique sol is at vertex ip, convert vector-tensor into scalar */
5 double getSol_3d(pSol sol,int ip,int is) {
6 double ux,uy,uz,u,m[6],lambda[3],vp[3][3];
7 int i,iadr;
8
9 u = 0.0;
10 iadr = (ip-1)*sol->size + is+1;
11 switch(sol->typtab[is]) {
12 case GmfSca:
13 u = sol->sol[iadr];
14 break;
15 case GmfVec:
16 ux = sol->sol[iadr];
17 uy = sol->sol[iadr+1];
18 uz = sol->sol[iadr+2];
19 u = sqrt(ux*ux + uy*uy + uz*uz);
20 break;
21 case GmfSymMat:
22 for (i=0; i<6; i++) m[i] = sol->sol[iadr+i];
23 eigenv(1,m,lambda,vp);
24 u = MS_MAX(lambda[0],MS_MAX(lambda[1],lambda[2]));
25 }
26
27 return(u);
28 }
29
30
31 double getSol_2d(pSol sol,int ip,int is) {
32 double ux,uy,u,m[3],lambda[2],vp[2][2];
33 int i,iadr;
34
35 u = 0.0;
36 iadr = (ip-1)*sol->size + is+1;
37 switch(sol->typtab[is]) {
38 case GmfSca:
39 u = sol->sol[iadr];
40 break;
41 case GmfVec:
42 ux = sol->sol[iadr];
43 uy = sol->sol[iadr+1];
44 u = sqrt(ux*ux + uy*uy);
45 break;
46 case GmfSymMat:
47 for (i=0; i<3; i++) m[i] = sol->sol[iadr+i];
48 eigen2(m,lambda,vp);
49 u = MS_MAX(lambda[0],lambda[1]);
50 }
51
52 return(u);
53 }
54
55
56 /* compute gradient via least square approx
57 in: ip = vertex num is = sol num
58 out: grd[3] gradient */
59 int gradLS_3d(pMesh mesh,pSol sol,int ip,int is) {
60 pPoint p0,p1;
61 pTetra pt;
62 double *grd,a[6],b[3],ax,ay,az,du,u,u1,aa,bb,cc,dd,ee,ff;
63 int i,iadr,nsdep,ip1,list[LONMAX+2],ilist;
64
65 p0 = &mesh->point[ip];
66 p0->nv = 0;
67 nsdep = p0->s;
68 assert(nsdep);
69
70 i = 0;
71 pt = &mesh->tetra[nsdep];
72 if ( pt->v[1] == ip ) i = 1;
73 else if ( pt->v[2] == ip ) i = 2;
74 else if ( pt->v[3] == ip ) i = 3;
75
76 ilist = boulep(mesh,nsdep,i,list);
77 if ( ilist < 1 ) return(0);
78
79 memset(a,0,6*sizeof(double));
80 memset(b,0,3*sizeof(double));
81 u = getSol(sol,ip,is);
82
83 iadr = (ip-1)*sol->dim + 1;
84 grd = &sol->grd[iadr];
85
86 /* Gradient: ui = u + <grad u,PPi> */
87 for (i=1; i<=ilist; i++) {
88 ip1 = list[i];
89 p1 = &mesh->point[ip1];
90 u1 = getSol(sol,ip1,is);
91 du = u1 - u;
92
93 /* M = At*A symmetric definite positive */
94 ax = p1->c[0] - p0->c[0];
95 ay = p1->c[1] - p0->c[1];
96 az = p1->c[2] - p0->c[2];
97 a[0] += ax * ax;
98 a[1] += ax * ay;
99 a[2] += ax * az;
100 a[3] += ay * ay;
101 a[4] += ay * az;
102 a[5] += az * az;
103
104 /* b = At*du */
105 b[0] += ax * du;
106 b[1] += ay * du;
107 b[2] += az * du;
108 p0->nv++;
109 }
110
111 /* solution of A(3,3)*grad(1,3) = b(1,3) */
112 aa = a[3]*a[5] - a[4]*a[4];
113 bb = a[4]*a[2] - a[1]*a[5];
114 cc = a[1]*a[4] - a[2]*a[3];
115 du = aa*a[0] + bb*a[1] + cc*a[2];
116 if ( fabs(du) == 0.0 ) {
117 fprintf(stdout," Invalid matrix (%d). Exit\n",ip);
118 return(-1);
119 }
120 du = 1.0 / du;
121 dd = a[0]*a[5] - a[2]*a[2];
122 ee = a[1]*a[2] - a[0]*a[4];
123 ff = a[0]*a[3] - a[1]*a[1];
124
125 grd[0] = (aa*b[0] + bb*b[1] + cc*b[2]) * du;
126 grd[1] = (bb*b[0] + dd*b[1] + ee*b[2]) * du;
127 grd[2] = (cc*b[0] + ee*b[1] + ff*b[2]) * du;
128
129 /* normalize */
130 if ( mesh->info.ls ) {
131 du = grd[0]*grd[0] + grd[1]*grd[1] + grd[2]*grd[2];
132 if ( du > EPS1 ) {
133 du = 1.0 / sqrt(du);
134 grd[0] *= du;
135 grd[1] *= du;
136 grd[2] *= du;
137 }
138 }
139
140 return(1);
141 }
142
143
144 int gradLS_2d(pMesh mesh,pSol sol,int ip,int is) {
145 pPoint p0,p1;
146 pTria pt;
147 double *grd,a[3],b[2],ax,ay,du,u,u1;
148 int i,iadr,nsdep,ip1,list[LONMAX+2],ilist;
149
150 p0 = &mesh->point[ip];
151 p0->nv = 0;
152 nsdep = p0->s;
153 assert(nsdep);
154
155 pt = &mesh->tria[nsdep];
156 if ( pt->v[0] == ip ) i = 0;
157 else if ( pt->v[1] == ip ) i = 1;
158 else i = 2;
159
160 ilist = boulep(mesh,nsdep,i,list);
161 if ( ilist < 1 ) return(0);
162
163 memset(a,0,3*sizeof(double));
164 memset(b,0,2*sizeof(double));
165 u = getSol(sol,ip,is);
166
167 iadr = (ip-1)*sol->dim + 1;
168 grd = &sol->grd[iadr];
169
170 /* Gradient: ui = u + <grad u,PPi> */
171 for (i=1; i<=ilist; i++) {
172 ip1 = list[i];
173 p1 = &mesh->point[ip1];
174 u1 = getSol(sol,ip1,is);
175
176 /* M = At*A symmetric definite positive */
177 ax = p1->c[0] - p0->c[0];
178 ay = p1->c[1] - p0->c[1];
179 a[0] += ax * ax;
180 a[1] += ax * ay;
181 a[2] += ay * ay;
182
183 /* b = At*du */
184 du = u1 - u;
185 b[0] += ax * du;
186 b[1] += ay * du;
187 p0->nv++;
188 }
189
190 /* solution of A(2,2)*grad(1,2) = b(1,2) */
191 du = a[0]*a[2] - a[1]*a[1];
192 if ( fabs(du) == 0.0 ) {
193 fprintf(stdout," Invalid matrix (%E). Exit\n",du);
194 return(0);
195 }
196 du = 1.0 / du;
197 grd[0] = (a[2]*b[0] - a[1]*b[1]) * du;
198 grd[1] = (a[0]*b[1] - a[1]*b[0]) * du;
199
200 /* normalize */
201 if ( mesh->info.ls ) {
202 du = grd[0]*grd[0] + grd[1]*grd[1];
203 if ( du > EPS1 ) {
204 du = 1.0 / sqrt(du);
205 grd[0] *= du;
206 grd[1] *= du;
207 }
208 }
209
210 return(1);
211 }
212
213
214 /* for surface mesh */
215 int gradLS_s(pMesh mesh,pSol sol,int ip,int is) {
216 pPoint p0,p1;
217 pTria pt;
218 double *grd,*nn,a[6],b[3],ax,ay,az,du,u,u1,aa,bb,cc,dd,ee,ff;
219 int i,iadr,nsdep,ip1,list[LONMAX+2],ilist;
220
221 p0 = &mesh->point[ip];
222 p0->nv = 0;
223 nsdep = p0->s;
224 assert(nsdep);
225
226 i = 0;
227 pt = &mesh->tria[nsdep];
228 if ( pt->v[1] == ip ) i = 1;
229 else if ( pt->v[2] == ip ) i = 2;
230
231 ilist = boulep(mesh,nsdep,i,list);
232 if ( ilist < 1 ) return(0);
233
234 memset(a,0,6*sizeof(double));
235 memset(b,0,3*sizeof(double));
236 u = getSol(sol,ip,is);
237
238 iadr = (ip-1)*sol->dim + 1;
239 grd = &sol->grd[iadr];
240 nn = &sol->nn[iadr];
241
242 /* Gradient: ui = u + <grad u,PPi> */
243 for (i=1; i<=ilist; i++) {
244 ip1 = list[i];
245 p1 = &mesh->point[ip1];
246 u1 = getSol(sol,ip1,is);
247 du = u1 - u;
248
249 ax = p1->c[0] - p0->c[0];
250 ay = p1->c[1] - p0->c[1];
251 az = p1->c[2] - p0->c[2];
252
253 /* M = At*A symmetric definite positive */
254 a[0] += ax * ax;
255 a[1] += ax * ay;
256 a[2] += ax * az;
257 a[3] += ay * ay;
258 a[4] += ay * az;
259 a[5] += az * az;
260
261 /* b = At*du */
262 b[0] += ax * du;
263 b[1] += ay * du;
264 b[2] += az * du;
265 p0->nv++;
266 }
267
268 /* solution of A(3,3)*grad(1,3) = b(1,3) */
269 aa = a[3]*a[5] - a[4]*a[4];
270 bb = a[4]*a[2] - a[1]*a[5];
271 cc = a[1]*a[4] - a[2]*a[3];
272 du = aa*a[0] + bb*a[1] + cc*a[2];
273 if ( fabs(du) == 0.0 ) {
274 fprintf(stdout," Invalid matrix (%E). Exit\n",du);
275 return(0);
276 }
277 du = 1.0 / du;
278 dd = a[0]*a[5] - a[2]*a[2];
279 ee = a[1]*a[2] - a[0]*a[4];
280 ff = a[0]*a[3] - a[1]*a[1];
281
282 grd[0] = (aa*b[0] + bb*b[1] + cc*b[2]) * du;
283 grd[1] = (bb*b[0] + dd*b[1] + ee*b[2]) * du;
284 grd[2] = (cc*b[0] + ee*b[1] + ff*b[2]) * du;
285
286 /* align w normal */
287 du = grd[0]*grd[0] + grd[1]*grd[1] + grd[2]*grd[2];
288 grd[0] = du * nn[0];
289 grd[1] = du * nn[1];
290 grd[2] = du * nn[2];
291
292 /* normalize */
293 if ( mesh->info.ls ) {
294 du = grd[0]*grd[0] + grd[1]*grd[1] + grd[2]*grd[2];
295 if ( du > EPS1 ) {
296 du = 1.0 / sqrt(du);
297 grd[0] *= du;
298 grd[1] *= du;
299 grd[2] *= du;
300 }
301 }
302
303 return(1);
304 }
305