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