1 /* This file provides interface functions for 'partial ' random
2 access into the PHASTA input files
3
4 Anil Karanam March 2001 */
5
6 #include <stdio.h>
7 #include <string.h>
8 #include <ctype.h>
9 #include <stdlib.h>
10 #include <time.h>
11 #include <math.h>
12 #include <mpi.h>
13 #include "phastaIO.h"
14 #include <FCMangle.h>
15 #include "new_interfaceAcuStat.h"
16
17 //MR CHANGE
18 #include "commonAcuStat_c.h"
19 //MR CHANGE END
20
21 #ifdef intel
22 #include <winsock2.h>
23 #else
24 #include <unistd.h>
25 #include <strings.h>
26 #endif
27
28
29 void
Write_AcuStat(int * pid,int * stepstart,int * stepend,int * steptot,int * nshg,int * numVars,double * array1)30 Write_AcuStat( int* pid,
31 int* stepstart,
32 int* stepend,
33 int* steptot,
34 int* nshg,
35 int* numVars,
36 double* array1 ) {
37
38 char fname[255];
39 char rfile[60];
40 char existingfile[30], linkfile[30];
41 int irstou;
42 int magic_number = 362436;
43 int* mptr = &magic_number;
44 double version=0.0;
45 int isize, nitems;
46 int iarray[10];
47 int nfiles;
48 int nfields;
49 int numparts;
50 int irank;
51 int nprocs;
52
53
54 irank = *pid;
55
56 // Retrieve and compute the parameters required for SyncIO
57 nfiles = outpar.nsynciofiles; //We use the same number of files as before
58 nfields = outpar.nsynciofieldswriterestart; // >=4
59 numparts = workfc.numpe;
60 nprocs= workfc.numpe;
61
62 int nppf = numparts/nfiles;
63 int GPID;
64
65 // Calculate number of parts each proc deal with and where it start and end ...
66 int nppp = numparts/nprocs;// nppp : Number of parts per proc ...
67 int startpart = irank * nppp +1;// Part id from which I (myrank) start ...
68 int endpart = startpart + nppp - 1;// Part id to which I (myrank) end ...
69
70 int descriptor;
71 char filename[255],path[255],fieldtag_s[255];
72 bzero((void*)filename,255);
73 bzero((void*)fieldtag_s,255);
74
75 //sprintf(filename,"restartAcuStat-dat.%d.%d",*stepend,((int)(irank/(nprocs/nfiles))+1));
76 sprintf(filename,"restartAcuStat.%d.%d.%d.%d",*stepstart,*stepend,*steptot,((int)(irank/(nprocs/nfiles))+1));
77 if (*pid==0) {
78 printf("Filename is %s \n",filename);
79 }
80
81 initphmpiio(&nfields, &nppf, &nfiles, &f_descriptor, "write");
82 openfile(filename, "write", &f_descriptor);
83
84 field_flag=0;
85 // solution
86 int i;
87 for ( i = 0; i < nppp; i++) { //This loop is useful only if several parts per processor
88 // GPID : global part id, corresponds to rank ...
89 // e.g : (in this example)
90 // proc 0 : 1--4
91 // proc 1 : 5--8 ...
92 GPID = startpart + i;
93
94 // Write solution field ...
95 sprintf(fieldtag_s,"solution@%d",GPID);
96
97 isize = (*nshg)*(*numVars);
98 nitems = 3;
99 iarray[ 0 ] = (*nshg);
100 iarray[ 1 ] = (*numVars);
101 iarray[ 2 ] = (*stepend);
102 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
103 writedatablock( &f_descriptor, fieldtag_s, (void*)(array1), &isize, "double", phasta_iotype );
104 }
105 field_flag++;
106
107 if (field_flag==nfields){
108 closefile(&f_descriptor, "write");
109 finalizephmpiio(&f_descriptor);
110 printf("file closed\n");
111 if (*pid==0) {
112 printf("\n");
113 }
114 }
115
116 return;
117 }
118
119
120
121 void
Write_AcuStat2(int * pid,int * stepstart,int * stepend,int * steptot,int * nshg,int * numVars,int * ndoferrors,int * ndofybar,double * array1,double * array2,double * array3,double * array4)122 Write_AcuStat2( int* pid,
123 int* stepstart,
124 int* stepend,
125 int* steptot,
126 int* nshg,
127 int* numVars,
128 int* ndoferrors,
129 int* ndofybar,
130 double* array1,
131 double* array2,
132 double* array3,
133 double* array4 ) {
134
135 char fname[255];
136 char rfile[60];
137 char existingfile[30], linkfile[30];
138 int irstou;
139 int magic_number = 362436;
140 int* mptr = &magic_number;
141 double version=0.0;
142 int isize, nitems;
143 int iarray[10];
144 int nfiles;
145 int nfields;
146 int numparts;
147 int irank;
148 int nprocs;
149
150
151 irank = *pid;
152
153 // Retrieve and compute the parameters required for SyncIO
154 nfiles = outpar.nsynciofiles; //We use the same number of files as before
155 nfields = outpar.nsynciofieldswriterestart; // >=4
156 numparts = workfc.numpe;
157 nprocs= workfc.numpe;
158
159 int nppf = numparts/nfiles;
160 int GPID;
161
162 // Calculate number of parts each proc deal with and where it start and end ...
163 int nppp = numparts/nprocs;// nppp : Number of parts per proc ...
164 int startpart = irank * nppp +1;// Part id from which I (myrank) start ...
165 int endpart = startpart + nppp - 1;// Part id to which I (myrank) end ...
166
167 int descriptor;
168 char filename[255],fieldtag_s[255];
169 bzero((void*)filename,255);
170 bzero((void*)fieldtag_s,255);
171
172 sprintf(filename,"restartAcuStat.%d.%d.%d.%d",*stepstart,*stepend,*steptot,((int)(irank/(nprocs/nfiles))+1));
173 if (*pid==0) {
174 printf("Filename is %s \n",filename);
175 }
176
177 initphmpiio(&nfields, &nppf, &nfiles, &f_descriptor, "write");
178 openfile(filename, "write", &f_descriptor);
179
180 field_flag=0;
181 // solution
182 int i;
183 for ( i = 0; i < nppp; i++) { //This loop is useful only if several parts per processor
184 // GPID : global part id, corresponds to rank ...
185 // e.g : (in this example)
186 // proc 0 : 1--4
187 // proc 1 : 5--8 ...
188 GPID = startpart + i;
189
190 // Write solution field ...
191 sprintf(fieldtag_s,"solution@%d",GPID);
192
193 isize = (*nshg)*(*numVars);
194 nitems = 3;
195 iarray[ 0 ] = (*nshg);
196 iarray[ 1 ] = (*numVars);
197 iarray[ 2 ] = (*stepend);
198 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
199 writedatablock( &f_descriptor, fieldtag_s, (void*)(array1), &isize, "double", phasta_iotype );
200 }
201 field_flag++;
202
203 // dwal
204 for ( i = 0; i < nppp; i++) { //This loop is useful only if several parts per processor
205 // GPID : global part id, corresponds to rank ...
206 // e.g : (in this example)
207 // proc 0 : 1--4
208 // proc 1 : 5--8 ...
209 GPID = startpart + i;
210
211 // Write solution field ...
212 sprintf(fieldtag_s,"dwal@%d",GPID);
213
214 isize = (*nshg)*1;
215 nitems = 3;
216 iarray[ 0 ] = (*nshg);
217 iarray[ 1 ] = 1;
218 iarray[ 2 ] = (*stepend);
219 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
220 writedatablock( &f_descriptor, fieldtag_s, (void*)(array2), &isize, "double", phasta_iotype );
221 }
222 field_flag++;
223
224 // errors
225 for ( i = 0; i < nppp; i++) { //This loop is useful only if several parts per processor
226 // GPID : global part id, corresponds to rank ...
227 // e.g : (in this example)
228 // proc 0 : 1--4
229 // proc 1 : 5--8 ...
230 GPID = startpart + i;
231
232 // Write solution field ...
233 sprintf(fieldtag_s,"errors@%d",GPID);
234
235 isize = (*nshg)*(*ndoferrors);
236 nitems = 3;
237 iarray[ 0 ] = (*nshg);
238 iarray[ 1 ] = (*ndoferrors);
239 iarray[ 2 ] = (*stepend);
240 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
241 writedatablock( &f_descriptor, fieldtag_s, (void*)(array3), &isize, "double", phasta_iotype );
242 }
243 field_flag++;
244
245 // ybar
246 for ( i = 0; i < nppp; i++) { //This loop is useful only if several parts per processor
247 // GPID : global part id, corresponds to rank ...
248 // e.g : (in this example)
249 // proc 0 : 1--4
250 // proc 1 : 5--8 ...
251 GPID = startpart + i;
252
253 // Write solution field ...
254 sprintf(fieldtag_s,"ybar@%d",GPID);
255
256 isize = (*nshg)*(*ndofybar);
257 nitems = 3;
258 iarray[ 0 ] = (*nshg);
259 iarray[ 1 ] = (*ndofybar);
260 iarray[ 2 ] = (*stepend);
261 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
262 writedatablock( &f_descriptor, fieldtag_s, (void*)(array4), &isize, "double", phasta_iotype );
263 }
264 field_flag++;
265
266
267 if (field_flag==nfields){
268 closefile(&f_descriptor, "write");
269 finalizephmpiio(&f_descriptor);
270 printf("file closed\n");
271 if (*pid==0) {
272 printf("\n");
273 }
274 }
275
276
277 return;
278 }
279
280 void
Write_Ybar(int * pid,int * stepstart,int * stepend,int * steptot,int * nshg,int * numVars,double * array1)281 Write_Ybar( int* pid,
282 int* stepstart,
283 int* stepend,
284 int* steptot,
285 int* nshg,
286 int* numVars,
287 double* array1) {
288
289 char fname[255];
290 char rfile[60];
291 char existingfile[30], linkfile[30];
292 int irstou;
293 int magic_number = 362436;
294 int* mptr = &magic_number;
295 double version=0.0;
296 int isize, nitems;
297 int iarray[10];
298
299 int nfiles;
300 int nfields;
301 int numparts;
302 int irank;
303 int nprocs;
304
305 // First, count the number of fields to write and store the result in
306 //countfieldstowriterestart();
307
308 // Retrieve and compute the parameters required for SyncIO
309 nfiles = outpar.nsynciofiles;
310 //nfields = outpar.nsynciofieldswriterestart;
311 nfields=1;
312 numparts = workfc.numpe;
313 irank = *pid; //workfc.myrank;
314 nprocs = workfc.numpe;
315 int nppf = numparts/nfiles;
316 int GPID;
317
318 // Calculate number of parts each proc deal with and where it start and end ...
319 int nppp = numparts/nprocs;// nppp : Number of parts per proc ...
320 int startpart = irank * nppp +1;// Part id from which I (myrank) start ...
321 int endpart = startpart + nppp - 1;// Part id to which I (myrank) end ...
322
323 int descriptor;
324 char filename[255],fieldtag_s[255];
325 bzero((void*)filename,255);
326 bzero((void*)fieldtag_s,255);
327
328 // sprintf(filename,"ybar.%d.%d",*stepno,((int)(irank/(nprocs/nfiles))+1));
329 sprintf(filename,"restartAcuStat.%d.%d.%d.%d",*stepstart,*stepend,*steptot,((int)(irank/(nprocs/nfiles))+1));
330
331 initphmpiio(&nfields, &nppf, &nfiles, &f_descriptor, "write");
332
333 if (*pid==0) {
334 printf("Filename is %s \n",filename);
335 }
336
337 openfile(filename, "write", &f_descriptor);
338
339 field_flag=0;
340
341 int i;
342 for ( i = 0; i < nppp; i++) { //This loop is useful only if several parts per processor
343 // GPID : global part id, corresponds to rank ...
344 // e.g : (in this example)
345 // proc 0 : 1--4
346 // proc 1 : 5--8 ...
347 GPID = startpart + i;
348
349 // Write ybar field ...
350 sprintf(fieldtag_s,"ybar@%d",GPID);
351
352 isize = (*nshg)*(*numVars);
353 nitems = 3;
354 iarray[ 0 ] = (*nshg);
355 iarray[ 1 ] = (*numVars);
356 iarray[ 2 ] = (*stepend);
357 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
358 writedatablock( &f_descriptor, fieldtag_s, (void*)(array1), &isize, "double", phasta_iotype );
359 }
360 field_flag++;
361
362 if (field_flag==nfields){
363 closefile(&f_descriptor, "write");
364 finalizephmpiio(&f_descriptor);
365 if (*pid==0) {
366 printf("\n");
367 }
368 }
369 }
370
371 void
Write_Restart(int * pid,int * stepno,int * nshg,int * numVars,double * array1,double * array2)372 Write_Restart( int* pid,
373 int* stepno,
374 int* nshg,
375 int* numVars,
376 double* array1,
377 double* array2 ) {
378
379 char fname[255];
380 char rfile[60];
381 char existingfile[30], linkfile[30];
382 int irstou;
383 int magic_number = 362436;
384 int* mptr = &magic_number;
385 double version=0.0;
386 int isize, nitems;
387 int iarray[10];
388 int nfiles;
389 int nfields;
390 int numparts;
391 int irank;
392 int nprocs;
393
394 // First, count the number of fields to write and store the result in
395 //countfieldstowriterestart();
396
397 // Retrieve and compute the parameters required for SyncIO
398 nfiles = outpar.nsynciofiles;
399 nfields = outpar.nsynciofieldswriterestart;
400 numparts = workfc.numpe;
401 irank = *pid; //workfc.myrank;
402 nprocs = workfc.numpe;
403 int nppf = numparts/nfiles;
404 int GPID;
405
406 // Calculate number of parts each proc deal with and where it start and end ...
407 int nppp = numparts/nprocs;// nppp : Number of parts per proc ...
408 int startpart = irank * nppp +1;// Part id from which I (myrank) start ...
409 int endpart = startpart + nppp - 1;// Part id to which I (myrank) end ...
410
411 int descriptor;
412 char filename[255],fieldtag_s[255];
413 bzero((void*)filename,255);
414 bzero((void*)fieldtag_s,255);
415
416 sprintf(filename,"restart-dat.%d.%d",*stepno,((int)(irank/(nprocs/nfiles))+1));
417
418 initphmpiio(&nfields, &nppf, &nfiles, &f_descriptor, "write");
419
420 if (*pid==0) {
421 printf("Filename is %s \n",filename);
422 }
423
424 openfile(filename, "write", &f_descriptor);
425
426 field_flag=0;
427
428 int i;
429 for ( i = 0; i < nppp; i++) { //This loop is useful only if several parts per processor
430 // GPID : global part id, corresponds to rank ...
431 // e.g : (in this example)
432 // proc 0 : 1--4
433 // proc 1 : 5--8 ...
434 GPID = startpart + i;
435
436 // Write solution field ...
437 sprintf(fieldtag_s,"solution@%d",GPID);
438
439 isize = (*nshg)*(*numVars);
440 nitems = 3;
441 iarray[ 0 ] = (*nshg);
442 iarray[ 1 ] = (*numVars);
443 iarray[ 2 ] = (*stepno);
444 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
445 writedatablock( &f_descriptor, fieldtag_s, (void*)(array1), &isize, "double", phasta_iotype );
446 }
447 field_flag++;
448
449 for ( i = 0; i < nppp; i++) {
450
451 // GPID : global part id, corresponds to rank ...
452 // e.g : (in this example)
453 // proc 0 : 1--4
454 // proc 1 : 5--8 ...
455 GPID = startpart + i;
456
457 // Write solution field ...
458 sprintf(fieldtag_s,"time derivative of solution@%d",GPID);
459
460 isize = (*nshg)*(*numVars);
461 nitems = 3;
462 iarray[ 0 ] = (*nshg);
463 iarray[ 1 ] = (*numVars);
464 iarray[ 2 ] = (*stepno);
465 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
466 writedatablock( &f_descriptor, fieldtag_s, (void*)(array2), &isize, "double", phasta_iotype );
467 }
468 field_flag++;
469
470 if (field_flag==nfields){
471 closefile(&f_descriptor, "write");
472 finalizephmpiio(&f_descriptor);
473 if (*pid==0) {
474 printf("\n");
475 }
476 }
477 }
478
479
480 void
Write_Error(int * pid,int * stepno,int * nshg,int * numVars,double * array1)481 Write_Error( int* pid,
482 int* stepno,
483 int* nshg,
484 int* numVars,
485 double* array1 ) {
486
487
488 char fname[255];
489 char rfile[60];
490 int irstou;
491 int magic_number = 362436;
492 int* mptr = &magic_number;
493 double version=0.0;
494 int isize, nitems;
495 int iarray[10];
496
497 /////////////////////////////// Start of writing using new-lib ////////////////////////////
498
499 int nfiles;
500 int nfields;
501 int numparts;
502 int irank;
503 int nprocs;
504
505 nfiles = outpar.nsynciofiles;
506 nfields = outpar.nsynciofieldswriterestart;
507 numparts = workfc.numpe;
508 irank = *pid; //workfc.myrank;
509 nprocs = workfc.numpe;
510
511 int nppf = numparts/nfiles;
512 int GPID;
513
514 // Calculate number of parts each proc deal with and where it start and end ...
515 int nppp = numparts/nprocs;// nppp : Number of parts per proc ...
516 int startpart = irank * nppp +1;// Part id from which I (myrank) start ...
517 int endpart = startpart + nppp - 1;// Part id to which I (myrank) end ...
518
519 field_flag++;
520
521 char fieldtag[255];
522
523 int i;
524 for ( i = 0; i < nppp; i++ ) {
525 GPID = startpart + i;
526 sprintf(fieldtag,"errors@%d",GPID);
527
528 if(*pid==0) {
529 printf("\n");
530 printf("The %d/%d th field to be written is '%s'\n",field_flag,nfields,fieldtag);
531 }
532
533 isize = (*nshg)*(*numVars);
534 nitems = 3;
535 iarray[ 0 ] = (*nshg);
536 iarray[ 1 ] = (*numVars);
537 iarray[ 2 ] = (*stepno);
538 writeheader( &f_descriptor, fieldtag, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
539 writedatablock( &f_descriptor, fieldtag, (void*)array1, &isize, "double", phasta_iotype );
540 }
541
542 if (field_flag==nfields){
543 closefile(&f_descriptor, "write");
544 finalizephmpiio(&f_descriptor);
545 if (*pid==0) {
546 printf("Last field %d '%s' finished! \n",nfields, fieldtag);
547 printf("\n");
548 }
549 }
550
551 }
552
553 void
Write_Displ(int * pid,int * stepno,int * nshg,int * numVars,double * array1)554 Write_Displ( int* pid,
555 int* stepno,
556 int* nshg,
557 int* numVars,
558 double* array1 ) { //TO BE UPDATED FOR SYNCIO
559
560
561 char fname[255];
562 char rfile[60];
563 int irstou;
564 int magic_number = 362436;
565 int* mptr = &magic_number;
566 time_t timenow = time ( &timenow);
567 double version=0.0;
568 int isize, nitems;
569 int iarray[10];
570
571 sprintf(rfile,"restart.%d.%d",*stepno,*pid+1);
572 openfile(rfile,"append", &irstou);
573
574 isize = (*nshg)*(*numVars);
575 nitems = 3;
576 iarray[ 0 ] = (*nshg);
577 iarray[ 1 ] = (*numVars);
578 iarray[ 2 ] = (*stepno);
579 writeheader( &irstou, "displacement", (void*)iarray, &nitems, &isize, "double", phasta_iotype );
580 writedatablock( &irstou, "displacement", (void*)(array1), &isize, "double", phasta_iotype );
581
582 closefile( &irstou, "append" );
583 }
584
585 void
Write_Field(int * pid,char * filemode,char * fieldtag,int * tagsize,void * array,char * arraytype,int * nshg,int * numvars,int * stepno)586 Write_Field( int *pid,
587 char* filemode,
588 char* fieldtag,
589 int* tagsize,
590 void* array,
591 char* arraytype,
592 int* nshg,
593 int* numvars,
594 int* stepno) {
595
596 //printf("Rank is %d, field is %s, tagsize is %d, nshg is %d, numvars is %d\n",*pid,fieldtag,*tagsize,*nshg,*numvars);
597
598 char *fieldlabel = (char *)malloc((*tagsize+1)*sizeof(char));
599 strncpy(fieldlabel, fieldtag, *tagsize);
600 fieldlabel[*tagsize] = '\0';
601
602 int irstou;
603 int magic_number = 362436;
604 int* mptr = &magic_number;
605 double version=0.0;
606 int isize, nitems;
607 int iarray[10];
608
609 char fmode[10];
610 if(!strncmp(filemode,"w",1))
611 strcpy(fmode,"write");
612 else // default is append
613 strcpy(fmode,"append");
614
615 char datatype[10];
616 if(!strncmp(arraytype,"i",1))
617 strcpy(datatype,"int");
618 else // default is double
619 strcpy(datatype,"double");
620
621 // Old posix format
622 /* openfile_(rfile, fmode, &irstou);
623
624 nitems = 3; // assuming field will write 3 items in iarray
625 iarray[ 0 ] = (*nshg);
626 iarray[ 1 ] = (*numvars);
627 iarray[ 2 ] = (*stepno);
628
629 isize = (*nshg)*(*numvars);
630 writeheader_( &irstou, fieldlabel, (void*)iarray, &nitems, &isize, datatype, phasta_iotype );
631
632 nitems = (*nshg)*(*numvars);
633 writedatablock_( &irstou, fieldlabel, array, &nitems, datatype, phasta_iotype );
634 closefile_( &irstou, fmode);
635 */
636 /////////////////////////////// Start of writing using new-lib ////////////////////////////
637
638 int nfiles;
639 int nfields;
640 int numparts;
641 int irank;
642 int nprocs;
643
644 // unsigned long long timer_start;
645 // unsigned long long timer_end;
646 // double time_span;
647
648 nfiles = outpar.nsynciofiles;
649 nfields = outpar.nsynciofieldswriterestart;
650 numparts = workfc.numpe;
651 irank = *pid; //workfc.myrank;
652 nprocs = workfc.numpe;
653
654 int nppf = numparts/nfiles;
655 int GPID;
656
657 // Calculate number of parts each proc deal with and where it start and end ...
658 int nppp = numparts/nprocs;// nppp : Number of parts per proc ...
659 int startpart = irank * nppp +1;// Part id from which I (myrank) start ...
660 int endpart = startpart + nppp - 1;// Part id to which I (myrank) end ...
661
662 char fieldtag_s[255];
663 bzero((void*)fieldtag_s,255);
664
665 strncpy(fieldlabel, fieldtag, *tagsize);
666
667 field_flag++;
668 if(*pid==0) {
669 printf("\n");
670 printf("The %d/%d th field to be written is '%s'\n",field_flag,nfields,fieldlabel);
671 }
672
673 int i;
674 for ( i = 0; i < nppp; i++ ) {
675 GPID = startpart + i;
676
677 // Write solution field ...
678 sprintf(fieldtag_s,"%s@%d",fieldlabel,GPID);
679
680 isize = (*nshg)*(*numvars);
681 nitems = 3;
682 iarray[ 0 ] = (*nshg);
683 iarray[ 1 ] = (*numvars);
684 iarray[ 2 ] = (*stepno);
685 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, datatype, phasta_iotype);
686 writedatablock( &f_descriptor, fieldtag_s, array, &isize, datatype, phasta_iotype );
687 }
688
689 if (field_flag==nfields){
690 closefile(&f_descriptor, "write");
691 finalizephmpiio(&f_descriptor);
692 if (*pid==0) {
693 printf("Last field %d '%s' finished! \n",nfields, fieldtag);
694 printf("\n");
695 }
696 }
697
698 free(fieldlabel);
699 }
700
701 void
Write_PhAvg(int * pid,char * filemode,char * fieldtag,int * tagsize,int * iphase,void * array,char * arraytype,int * nshg,int * numvars,int * stepno)702 Write_PhAvg( int* pid,
703 char* filemode,
704 char* fieldtag,
705 int* tagsize,
706 int* iphase,
707 void* array,
708 char* arraytype,
709 int* nshg,
710 int* numvars,
711 int* stepno) {
712
713 char rfile[32];
714 // assuming restart_phase_avg_<sn>.<iphase>.<pid+1>
715 sprintf(rfile,"restart_phase_avg_%d.%d.%d",*stepno,*iphase,*pid+1);
716
717 char *fieldlabel = (char *)malloc((*tagsize+1)*sizeof(char));
718 strncpy(fieldlabel, fieldtag, *tagsize);
719 fieldlabel[*tagsize] = '\0';
720
721 int irstou;
722 int isize, nitems;
723 int iarray[10];
724
725 char fmode[10];
726 if(!strncmp(filemode,"w",1))
727 strcpy(fmode,"write");
728 else // default is append
729 strcpy(fmode,"append");
730
731 char datatype[10];
732 if(!strncmp(arraytype,"i",1))
733 strcpy(datatype,"int");
734 else // default is double
735 strcpy(datatype,"double");
736
737 openfile(rfile, fmode, &irstou);
738
739 if(!strcmp(fmode,"write")) {
740 // may be create a routine for 'top' portion under write mode
741 int magic_number = 362436;
742 int* mptr = &magic_number;
743 time_t timenow = time ( &timenow);
744 double version=0.0;
745
746 /* writing the top ascii header for the restart file */
747
748 writestring( &irstou,"# PHASTA Input File Version 2.0\n");
749 writestring( &irstou,
750 "# format \"keyphrase : sizeofnextblock usual headers\"\n");
751
752 char fname[255];
753 bzero( (void*)fname, 255 );
754 sprintf(fname,"# Output generated by phasta version (NOT YET CURRENT): %lf \n", version);
755 writestring( &irstou, fname );
756
757 bzero( (void*)fname, 255 );
758 gethostname(fname,255);
759 writestring( &irstou,"# This result was produced on: ");
760 writestring( &irstou, fname );
761 writestring( &irstou,"\n");
762
763 bzero( (void*)fname, 255 );
764 sprintf(fname,"# %s\n", ctime( &timenow ));
765 writestring( &irstou, fname );
766
767 isize = 1;
768 nitems = 1;
769 iarray[ 0 ] = 1;
770 writeheader( &irstou, "byteorder magic number ",
771 (void*)iarray, &nitems, &isize, "integer", phasta_iotype );
772 writedatablock( &irstou, "byteorder magic number ",
773 (void*)mptr, &isize, "integer", phasta_iotype );
774 }
775
776 isize = (*nshg)*(*numvars);
777 nitems = 3; // assuming field will write 3 items in iarray
778 iarray[ 0 ] = (*nshg);
779 iarray[ 1 ] = (*numvars);
780 iarray[ 2 ] = (*stepno);
781 writeheader( &irstou, fieldlabel, (void*)iarray, &nitems, &isize, datatype, phasta_iotype );
782 writedatablock( &irstou, fieldlabel, array, &isize, datatype, phasta_iotype );
783
784 closefile( &irstou, fmode);
785
786 free(fieldlabel);
787 }
788
789 void
Write_PhAvg2(int * pid,char * filemode,char * fieldtag,int * tagsize,int * iphase,int * nphasesincycle,void * array,char * arraytype,int * nshg,int * numvars,int * stepno)790 Write_PhAvg2( int* pid,
791 char* filemode,
792 char* fieldtag,
793 int* tagsize,
794 int* iphase,
795 int* nphasesincycle,
796 void* array,
797 char* arraytype,
798 int* nshg,
799 int* numvars,
800 int* stepno) {
801
802 int addtagsize=0; // phase number is added to the name of the field
803 if(*iphase<10)
804 addtagsize=1;
805 else if(*iphase<100)
806 addtagsize=2;
807 else if(*iphase<1000)
808 addtagsize=3;
809
810 int tagsize2;
811 tagsize2=*tagsize+addtagsize;
812
813 char *fieldlabel = (char *)malloc((tagsize2+1)*sizeof(char));
814 strncpy(fieldlabel, fieldtag, *tagsize);
815 fieldlabel[tagsize2] = '\0';
816
817 char straddtagsize[10];
818 sprintf(straddtagsize,"%d",*iphase);
819
820 if(*iphase<10) {
821 fieldlabel[tagsize2-1]=straddtagsize[0];
822 }
823 else if(*iphase<100) {
824 fieldlabel[tagsize2-2]=straddtagsize[0];
825 fieldlabel[tagsize2-1]=straddtagsize[1];
826 }
827 else if(*iphase<1000) {
828 fieldlabel[tagsize2-3]=straddtagsize[0];
829 fieldlabel[tagsize2-2]=straddtagsize[1];
830 fieldlabel[tagsize2-1]=straddtagsize[2];
831 }
832
833 int irstou;
834 int magic_number = 362436;
835 int* mptr = &magic_number;
836 double version=0.0;
837 int isize, nitems;
838 int iarray[10];
839
840 char fmode[10];
841 if(!strncmp(filemode,"w",1))
842 strcpy(fmode,"write");
843 else // default is append
844 strcpy(fmode,"append");
845
846 char datatype[10];
847 if(!strncmp(arraytype,"i",1))
848 strcpy(datatype,"int");
849 else // default is double
850 strcpy(datatype,"double");
851
852 /////////////////////////////// Start of writing using new-lib ////////////////////////////
853
854 int nfiles;
855 int nfields;
856 int numparts;
857 int irank;
858 int nprocs;
859
860 nfiles = outpar.nsynciofiles;
861 nfields = outpar.nsynciofieldswriterestart;
862 numparts = workfc.numpe;
863 irank = *pid; //workfc.myrank;
864 nprocs = workfc.numpe;
865
866 int nppf = numparts/nfiles;
867 int GPID;
868
869 // Calculate number of parts each proc deal with and where it start and end ...
870 int nppp = numparts/nprocs;// nppp : Number of parts per proc ...
871 int startpart = irank * nppp +1;// Part id from which I (myrank) start ...
872 int endpart = startpart + nppp - 1;// Part id to which I (myrank) end ...
873
874 char fieldtag_s[255];
875 bzero((void*)fieldtag_s,255);
876
877 field_flag++;
878 if(*pid==0) {
879 printf("\n");
880 printf("The %d/%d th field to be written is '%s'\n",field_flag,nfields,fieldlabel);
881 }
882
883 int i;
884 for ( i = 0; i < nppp; i++ ) {
885 GPID = startpart + i;
886
887 // Write solution field ...
888 sprintf(fieldtag_s,"%s@%d",fieldlabel,GPID);
889
890 isize = (*nshg)*(*numvars);
891 nitems = 3;
892 iarray[ 0 ] = (*nshg);
893 iarray[ 1 ] = (*numvars);
894 iarray[ 2 ] = (*stepno);
895 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
896 writedatablock( &f_descriptor, fieldtag_s, array, &isize, "double", phasta_iotype );
897 }
898
899 if (field_flag==nfields){
900 closefile(&f_descriptor, "write");
901 finalizephmpiio(&f_descriptor);
902 if (*pid==0) {
903 printf("\n");
904 }
905 }
906
907 free(fieldlabel);
908 }
909
910
911 void
Write_d2wall(int * pid,int * numnp,double * array1)912 Write_d2wall( int* pid,
913 int* numnp,
914 double* array1 ) {
915
916 int isize, nitems;
917 int iarray[10];
918
919 /////////////////////////////// Start of writing using new-lib ////////////////////////////
920
921 int nfiles;
922 int nfields;
923 int numparts;
924 int irank;
925 int nprocs;
926
927 // First, count the number of fields to write and store the result in
928 //countfieldstowriterestart();
929
930 // Retrieve and compute the parameters required for SyncIO
931 nfiles = outpar.nsynciofiles;
932 nfields = 1; //outpar.nsynciofieldswriterestart; // Only the distance to the walls in d2wall
933 numparts = workfc.numpe;
934 irank = *pid; //workfc.myrank;
935 nprocs = workfc.numpe;
936 int nppf = numparts/nfiles;
937 int GPID;
938
939 // Calculate number of parts each proc deal with and where it start and end ...
940 int nppp = numparts/nprocs;// nppp : Number of parts per proc ...
941 int startpart = irank * nppp +1;// Part id from which I (myrank) start ...
942 int endpart = startpart + nppp - 1;// Part id to which I (myrank) end ...
943
944 int descriptor;
945 char filename[255],fieldtag_s[255];
946 bzero((void*)filename,255);
947 bzero((void*)fieldtag_s,255);
948
949 sprintf(filename,"d2wall.%d",((int)(irank/(nprocs/nfiles))+1));
950
951 if (irank==0) {
952 printf("Filename is %s \n",filename);
953 }
954
955 initphmpiio(&nfields, &nppf, &nfiles, &f_descriptor, "write");
956
957 openfile(filename, "write", &f_descriptor);
958
959 field_flag=0;
960
961 int i;
962 for ( i = 0; i < nppp; i++) { //This loop is useful only if several parts per processor
963 // GPID : global part id, corresponds to rank ...
964 // e.g : (in this example)
965 // proc 0 : 1--4
966 // proc 1 : 5--8 ...
967 GPID = startpart + i;
968
969 // Write solution field ...
970 sprintf(fieldtag_s,"d2wall@%d",GPID);
971
972 isize = (*numnp);
973 nitems = 2;
974 iarray[ 0 ] = (*numnp);
975 iarray[ 1 ] = 1; //numVars = 1
976 writeheader( &f_descriptor, fieldtag_s, (void*)iarray, &nitems, &isize, "double", phasta_iotype);
977 writedatablock( &f_descriptor, fieldtag_s, (void*)(array1), &isize, "double", phasta_iotype );
978 }
979 field_flag++;
980
981 if (field_flag==nfields){
982 closefile(&f_descriptor, "write");
983 finalizephmpiio(&f_descriptor);
984 if (irank==0) {
985 printf("\n");
986 }
987 }
988 }
989
990