Debian Codegraph @

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

raw
1 #include "mshmet.h"
2
3 extern int eigenv(int symmat,double *mat,double lambda[3],double v[3][3]);
4 extern int eigen2(double *mm,double *lambda,double vp[2][2]);
5
6
7 /* read mesh data */
8 int loadMesh(pMesh mesh,char *filename) {
9 pPoint ppt;
10 pTetra pt;
11 pTria pt1;
12 float fp1,fp2,fp3;
13 int i,k,ref;
14 int64_t inm;
15 char *ptr,data[128];
16
17 strcpy(data,filename);
18 ptr = strstr(data,".mesh");
19 mesh->info.bin = 0;
20 if ( !ptr ) {
21 strcat(data,".meshb");
22 mesh->info.bin = 1;
23 if ( !(inm = GmfOpenMesh(data,GmfRead,&mesh->ver,&mesh->dim)) ) {
24 ptr = strstr(data,".mesh");
25 *ptr = '\0';
26 strcat(data,".mesh");
27 if ( !(inm = GmfOpenMesh(data,GmfRead,&mesh->ver,&mesh->dim)) ) {
28 fprintf(stderr," ** %s NOT FOUND.\n",data);
29 return(0);
30 }
31 mesh->info.bin = 0;
32 }
33 }
34 else if ( !(inm = GmfOpenMesh(data,GmfRead,&mesh->ver,&mesh->dim)) ) {
35 fprintf(stderr," ** %s NOT FOUND.\n",data);
36 return(0);
37 }
38 fprintf(stdout," %%%% %s OPENED\n",data);
39
40 if ( abs(mesh->info.imprim) > 3 )
41 fprintf(stdout," -- READING DATA FILE %s\n",data);
42
43 mesh->np = GmfStatKwd(inm,GmfVertices);
44 mesh->nt = GmfStatKwd(inm,GmfTriangles);
45 mesh->ne = GmfStatKwd(inm,GmfTetrahedra);
46 if ( !mesh->np || mesh->ne+mesh->nt == 0 ) {
47 fprintf(stdout," ** MISSING DATA\n");
48 return(0);
49 }
50
51 /* mem alloc */
52 mesh->point = (pPoint)M_calloc(mesh->np+1,sizeof(Point),"point");
53 assert(mesh->point);
54 if ( mesh->ne ) {
55 mesh->tetra = (pTetra)M_calloc(mesh->ne+1,sizeof(Tetra),"tetra");
56 assert(mesh->tetra);
57 mesh->adja = (int*)M_calloc(4*mesh->ne+5,sizeof(int),"adja");
58 assert(mesh->adja);
59 mesh->nt = 0;
60 }
61 else if ( mesh->nt ) {
62 mesh->tria = (pTria)M_calloc(mesh->nt+1,sizeof(Tria),"tria");
63 assert(mesh->tria);
64 mesh->adja = (int*)M_calloc(3*mesh->nt+5,sizeof(int),"adja");
65 assert(mesh->adja);
66 }
67
68 /* read mesh vertices */
69 GmfGotoKwd(inm,GmfVertices);
70 if ( mesh->dim == 2 ) {
71 for (k=1; k<=mesh->np; k++) {
72 ppt = &mesh->point[k];
73 if ( mesh->ver == GmfFloat ) {
74 GmfGetLin(inm,GmfVertices,&fp1,&fp2,&ref);
75 ppt->c[0] = fp1;
76 ppt->c[1] = fp2;
77 }
78 else
79 GmfGetLin(inm,GmfVertices,&ppt->c[0],&ppt->c[1],&ref);
80 }
81 }
82 else {
83 for (k=1; k<=mesh->np; k++) {
84 ppt = &mesh->point[k];
85 if ( mesh->ver == GmfFloat ) {
86 GmfGetLin(inm,GmfVertices,&fp1,&fp2,&fp3,&ref);
87 ppt->c[0] = fp1;
88 ppt->c[1] = fp2;
89 ppt->c[2] = fp3;
90 }
91 else
92 GmfGetLin(inm,GmfVertices,&ppt->c[0],&ppt->c[1],&ppt->c[2],&ref);
93 }
94 }
95
96 /* read mesh triangles */
97 GmfGotoKwd(inm,GmfTriangles);
98 for (k=1; k<=mesh->nt; k++) {
99 pt1 = &mesh->tria[k];
100 GmfGetLin(inm,GmfTriangles,&pt1->v[0],&pt1->v[1],&pt1->v[2],&ref);
101 for (i=0; i<3; i++) {
102 ppt = &mesh->point[pt1->v[i]];
103 if ( !ppt->s ) ppt->s = k;
104 }
105 }
106
107 /* read mesh tetrahedra */
108 GmfGotoKwd(inm,GmfTetrahedra);
109 for (k=1; k<=mesh->ne; k++) {
110 pt = &mesh->tetra[k];
111 GmfGetLin(inm,GmfTetrahedra,&pt->v[0],&pt->v[1],&pt->v[2],&pt->v[3],&ref);
112 for (i=0; i<4; i++) {
113 ppt = &mesh->point[pt->v[i]];
114 if ( !ppt->s ) ppt->s = k;
115 }
116 }
117
118 GmfCloseMesh(inm);
119 return(1);
120 }
121
122
123 /* load solution (metric) */
124 int loadSol(pSol sol,Info *info,char *filename) {
125 double dbuf[ GmfMaxTyp ];
126 float fbuf[ GmfMaxTyp ];
127 int k,i,ia;
128 int64_t inm;
129 char *ptr,data[128];
130
131 strcpy(data,filename);
132 ptr = strstr(data,".mesh");
133 if ( ptr ) *ptr = '\0';
134 strcat(data,".solb");
135 if (!(inm = GmfOpenMesh(data,GmfRead,&sol->ver,&sol->dim)) ) {
136 ptr = strstr(data,".solb");
137 *ptr = '\0';
138 strcat(data,".sol");
139 if (!(inm = GmfOpenMesh(data,GmfRead,&sol->ver,&sol->dim)) ) {
140 fprintf(stderr," ** %s NOT FOUND.\n",data);
141 return(0);
142 }
143 }
144 fprintf(stdout," %%%% %s OPENED\n",data);
145
146 if ( abs(info->imprim) > 3 )
147 fprintf(stdout," -- READING DATA FILE %s\n",data);
148
149 sol->np = GmfStatKwd(inm,GmfSolAtVertices,&sol->type,&sol->size,sol->typtab);
150 if ( !sol->np ) {
151 fprintf(stdout," ** MISSING DATA.\n");
152 return(0);
153 }
154
155 /* mem alloc */
156 sol->sol = (double*)M_calloc(sol->np+1,sol->size*sizeof(double),"inout");
157 assert(sol->sol);
158
159 /* read mesh solutions */
160 GmfGotoKwd(inm,GmfSolAtVertices);
161 for (k=1; k<=sol->np; k++) {
162 if ( sol->ver == GmfFloat ) {
163 GmfGetLin(inm,GmfSolAtVertices,fbuf);
164 ia = (k-1)*sol->size + 1;
165 for (i=0; i<sol->size; i++)
166 sol->sol[ia+i] = fbuf[i]; // < -0.0001 ? -1.0 : fbuf[i];
167 }
168 else {
169 GmfGetLin(inm,GmfSolAtVertices,dbuf);
170 ia = (k-1)*sol->size + 1;
171 for (i=0; i<sol->size; i++)
172 sol->sol[ia+i] = dbuf[i];
173 }
174 }
175
176 GmfCloseMesh(inm);
177 return(1);
178 }
179
180
181 /* load solution (metric) */
182 int loadMetric(pSol sol,Info *info,char *filename) {
183 double dbuf[ GmfMaxTyp ],tmpd;
184 float fbuf[ GmfMaxTyp ],tmpf;
185 int i,k,ia,np,ver,dim,type,size,typtab[ GmfMaxTyp ];
186 int64_t inm;
187 if ( !(inm = GmfOpenMesh(filename,GmfRead,&ver,&dim)) ) {
188 fprintf(stderr," ** %s NOT FOUND.\n",filename);
189 return(0);
190 }
191 fprintf(stdout," %%%% %s OPENED\n",filename);
192
193 if ( abs(info->imprim) > 3 )
194 fprintf(stdout," -- READING METRIC FILE %s\n",filename);
195
196 np = GmfStatKwd(inm,GmfSolAtVertices,&type,&size,typtab);
197 if ( !np || np != sol->np ) {
198 fprintf(stdout," ** INCOMPLETE DATA.\n");
199 return(0);
200 }
201
202 /* mem alloc */
203 sol->met = (double*)M_calloc(np+1,size*sizeof(double),"inout");
204 assert(sol->met);
205
206 /* read mesh solutions */
207 GmfGotoKwd(inm,GmfSolAtVertices);
208 for (k=1; k<=np; k++) {
209 if ( ver == GmfFloat ) {
210 GmfGetLin(inm,GmfSolAtVertices,fbuf);
211 ia = (k-1)*size + 1;
212 if ( sol->dim == 3 ) {
213 tmpf = fbuf[3];
214 fbuf[3] = fbuf[2];
215 fbuf[2] = tmpf;
216 }
217 for (i=0; i<size; i++)
218 sol->met[ia+i] = fbuf[i];
219 }
220 else {
221 GmfGetLin(inm,GmfSolAtVertices,dbuf);
222 ia = (k-1)*size + 1;
223 if ( sol->dim == 3 ) {
224 tmpd = dbuf[3];
225 dbuf[3] = dbuf[2];
226 dbuf[2] = tmpd;
227 }
228 for (i=0; i<size; i++)
229 sol->met[ia+i] = dbuf[i];
230 }
231 }
232
233 GmfCloseMesh(inm);
234 return(1);
235 }
236
237
238 int saveMet(pSol sol,Info *info,char *filename) {
239 double dbuf[ GmfMaxTyp ],tmpd,hmin,lambda[3],vp2[2][2],vp3[3][3];
240 float fbuf[ GmfMaxTyp ],tmpf;
241 int k,i,ia,size;
242 int64_t outm;
243 char *ptr,data[128];
244
245 strcpy(data,filename);
246 ptr = strstr(data,".mesh");
247 if ( ptr ) {
248 *ptr = '\0';
249 strcat(data,".solb");
250 }
251 else {
252 ptr = strstr(data,".sol");
253 if ( !ptr ) strcat(data,".sol");
254 }
255 if (!(outm = GmfOpenMesh(data,GmfWrite,sol->ver,sol->dim)) ) {
256 fprintf(stderr," ** UNABLE TO OPEN %s\n",data);
257 return(0);
258 }
259 fprintf(stdout," %%%% %s OPENED\n",data);
260
261 /* write sol */
262 sol->type = 1;
263 if ( info->iso ) {
264 sol->typtab[0] = GmfSca;
265 sol->size = 1;
266 }
267 else {
268 sol->typtab[0] = GmfSymMat;
269 sol->size = sol->dim == 2 ? 3 : 6;
270 }
271 GmfSetKwd(outm,GmfSolAtVertices,sol->np,sol->type,sol->typtab);
272 for (k=1; k<=sol->np; k++) {
273 ia = (k-1)*sol->size + 1;
274 if ( sol->ver == GmfFloat ) {
275 for (i=0; i<sol->size; i++)
276 fbuf[i] = sol->met[ia+i];
277 if ( sol->dim == 3 ) {
278 tmpf = fbuf[3];
279 fbuf[3] = fbuf[2];
280 fbuf[2] = tmpf;
281 }
282 GmfSetLin(outm,GmfSolAtVertices,fbuf);
283 }
284 else {
285 for (i=0; i<sol->size; i++)
286 dbuf[i] = sol->met[ia+i];
287 if ( sol->dim == 3 ) {
288 tmpd = dbuf[3];
289 dbuf[3] = dbuf[2];
290 dbuf[2] = tmpd;
291 }
292 GmfSetLin(outm,GmfSolAtVertices,dbuf);
293 }
294 }
295 GmfCloseMesh(outm);
296
297 if ( !sol->mapname ) return(1);
298
299 /* save sizemap iso */
300 strcpy(data,sol->mapname);
301 ptr = strstr(data,".mesh");
302 if ( ptr ) {
303 *ptr = '\0';
304 strcat(data,".solb");
305 }
306 else {
307 ptr = strstr(data,".sol");
308 if ( !ptr ) strcat(data,".sol");
309 }
310 if ( !(outm = GmfOpenMesh(data,GmfWrite,sol->ver,sol->dim)) ) {
311 fprintf(stderr," ** UNABLE TO OPEN %s\n",data);
312 return(0);
313 }
314 fprintf(stdout," %%%% %s OPENED\n",data);
315
316 sol->type = 1;
317 sol->typtab[0] = GmfSca;
318 size = sol->dim*(sol->dim+1)/2;
319 GmfSetKwd(outm,GmfSolAtVertices,sol->np,sol->type,sol->typtab);
320 if ( sol->dim == 2 ) {
321 for (k=1; k<=sol->np; k++) {
322 ia = (k-1)*size + 1;
323 eigen2(&sol->met[ia],lambda,vp2);
324 lambda[0] = 1.0 / sqrt(lambda[0]);
325 lambda[1] = 1.0 / sqrt(lambda[1]);
326 hmin = MS_MIN(lambda[0],lambda[1]);
327 if ( sol->ver == GmfFloat ) {
328 fbuf[0] = hmin;
329 GmfSetLin(outm,GmfSolAtVertices,fbuf);
330 }
331 else
332 GmfSetLin(outm,GmfSolAtVertices,&hmin);
333 }
334 }
335 else {
336 for (k=1; k<=sol->np; k++) {
337 ia = (k-1)*size + 1;
338 eigenv(1,&sol->met[ia],lambda,vp3);
339 lambda[0] = 1.0 / sqrt(lambda[0]);
340 lambda[1] = 1.0 / sqrt(lambda[1]);
341 lambda[2] = 1.0 / sqrt(lambda[2]);
342 hmin = MS_MIN(lambda[0],lambda[1]);
343 hmin = MS_MIN(hmin,lambda[2]);
344 if ( sol->ver == GmfFloat ) {
345 fbuf[0] = hmin;
346 GmfSetLin(outm,GmfSolAtVertices,fbuf);
347 }
348 else
349 GmfSetLin(outm,GmfSolAtVertices,&hmin);
350 }
351 }
352
353 GmfCloseMesh(outm);
354 return(1);
355 }
356
357
358 int saveSol(pSol sol,Info *info,char *filename) {
359 double dbuf[ GmfMaxTyp ];
360 float fbuf[ GmfMaxTyp ];
361 int k,i,ia;
362 int64_t outm;
363 char *ptr,data[128];
364
365 strcpy(data,filename);
366 ptr = strstr(data,".mesh");
367 if ( ptr ) {
368 *ptr = '\0';
369 strcat(data,".solb");
370 }
371 else {
372 ptr = strstr(data,".sol");
373 if ( !ptr ) strcat(data,".sol");
374 }
375
376 if (!(outm = GmfOpenMesh(data,GmfWrite,sol->ver,sol->dim)) ) {
377 fprintf(stderr," ** UNABLE TO OPEN %s\n",data);
378 return(0);
379 }
380
381 fprintf(stdout," %%%% %s OPENED\n",data);
382
383 /* write sol */
384 sol->type = 1;
385 sol->typtab[0] = GmfSca;
386 sol->size = 1;
387 GmfSetKwd(outm,GmfSolAtVertices,sol->np,sol->type,sol->typtab);
388 for (k=1; k<=sol->np; k++) {
389 ia = (k-1)*sol->size + 1;
390 if ( sol->ver == GmfFloat ) {
391 for (i=0; i<sol->size; i++)
392 fbuf[i] = sol->sol[ia+i];
393 GmfSetLin(outm,GmfSolAtVertices,fbuf);
394 }
395 else {
396 for (i=0; i<sol->size; i++)
397 dbuf[i] = sol->sol[ia+i];
398 GmfSetLin(outm,GmfSolAtVertices,dbuf);
399 }
400 }
401
402 GmfCloseMesh(outm);
403 return(1);
404 }
405
406
407 int outder(pMesh mesh,pSol sol) {
408 double *grd,*hes,*np;
409 int k,iadr,ver,type,siz,typtab[GmfMaxTyp];
410 int64_t outm;
411 ver = GmfDouble;
412
413 /* gradients */
414 if ( !(outm = GmfOpenMesh("gradient.sol",GmfWrite,ver,sol->dim)) ) {
415 fprintf(stderr," ** UNABLE TO OPEN gradient\n");
416 return(0);
417 }
418 type = 1;
419 typtab[0] = GmfVec;
420 GmfSetKwd(outm,GmfSolAtVertices,mesh->np,type,typtab);
421 for (k=1; k<=mesh->np; k++) {
422 iadr = (k-1)*sol->dim + 1;
423 grd = &sol->grd[iadr];
424 GmfSetLin(outm,GmfSolAtVertices,grd);
425 }
426 GmfCloseMesh(outm);
427
428 /* hessian */
429 if ( !(outm = GmfOpenMesh("hessien.sol",GmfWrite,ver,sol->dim)) ) {
430 fprintf(stderr," ** UNABLE TO OPEN hessien\n");
431 return(0);
432 }
433 type = 1;
434 typtab[0] = GmfSymMat;
435 siz = sol->dim == 2 ? 3 : (mesh->ne > 0 ? 6 : 3);
436
437 GmfSetKwd(outm,GmfSolAtVertices,mesh->np,type,typtab);
438 for (k=1; k<=mesh->np; k++) {
439 iadr = (k-1)*siz + 1;
440 hes = &sol->hes[iadr];
441 GmfSetLin(outm,GmfSolAtVertices,hes);
442 }
443 GmfCloseMesh(outm);
444
445 if ( mesh->dim == 3 && mesh->ne == 0 ) {
446 if ( !(outm = GmfOpenMesh("normal.sol",GmfWrite,ver,sol->dim)) ) {
447 fprintf(stderr," ** UNABLE TO OPEN gradient\n");
448 return(0);
449 }
450 type = 1;
451 typtab[0] = GmfVec;
452 GmfSetKwd(outm,GmfSolAtVertices,mesh->np,type,typtab);
453 for (k=1; k<=mesh->np; k++) {
454 iadr = (k-1)*sol->dim + 1;
455 np = &sol->nn[iadr];
456 GmfSetLin(outm,GmfSolAtVertices,np);
457 }
458 GmfCloseMesh(outm);
459 }
460
461 return(1);
462 }
463
464