/[escript]/trunk/finley/src/Mesh_saveVTK.c
ViewVC logotype

Contents of /trunk/finley/src/Mesh_saveVTK.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1942 - (show annotations)
Wed Oct 29 03:29:35 2008 UTC (10 years, 9 months ago) by phornby
File MIME type: text/plain
File size: 67050 byte(s)
remove unused rtmp var.
1
2 /*******************************************************
3 *
4 * Copyright (c) 2003-2008 by University of Queensland
5 * Earth Systems Science Computational Center (ESSCC)
6 * http://www.uq.edu.au/esscc
7 *
8 * Primary Business: Queensland, Australia
9 * Licensed under the Open Software License version 3.0
10 * http://www.opensource.org/licenses/osl-3.0.php
11 *
12 *******************************************************/
13
14
15 /**************************************************************/
16
17 /* writes data and mesh in a vtk file */
18 /* nodal data needs to be given on FINLEY_NODES or FINLEY_REDUCED_NODES */
19
20 /**************************************************************/
21
22
23 #include "Mesh.h"
24 #include "Assemble.h"
25 #include "vtkCellType.h" /* copied from vtk source directory !!! */
26 #include "paso/PasoUtil.h"
27
28 #define LEN_PRINTED_INT_FORMAT (9+1)
29 #define INT_FORMAT "%d "
30 #define INT_NEWLINE_FORMAT "%d\n"
31 #define FLOAT_SCALAR_FORMAT "%12.6e\n"
32 #define FLOAT_VECTOR_FORMAT "%12.6e %12.6e %12.6e\n"
33 #define FLOAT_TENSOR_FORMAT "%12.6e %12.6e %12.6e %12.6e %12.6e %12.6e %12.6e %12.6e %12.6e\n"
34 #define LEN_PRINTED_FLOAT_SCALAR_FORMAT (12+1)
35 #define LEN_PRINTED_FLOAT_VECTOR_FORMAT (3*(12+1)+1)
36 #define LEN_PRINTED_FLOAT_TENSOR_FORMAT (9*(12+1)+1)
37 #define NEWLINE "\n"
38 #define LEN_TMP_BUFFER LEN_PRINTED_FLOAT_TENSOR_FORMAT+(MAX_numNodes*LEN_PRINTED_INT_FORMAT+1)+2
39 #define NCOMP_MAX 9
40 #define __STRCAT(dest,chunk,dest_in_use) \
41 { \
42 strcpy(&dest[dest_in_use], chunk); \
43 dest_in_use+=strlen(chunk); \
44 }
45 #define INSIDE_1D(_X_,_C_,_R_) ( ABS((_X_)-(_C_)) <= (_R_) )
46 #define INSIDE_2D(_X_,_Y_,_CX_,_CY_,_R_) ( INSIDE_1D(_X_,_CX_,_R_) && INSIDE_1D(_Y_,_CY_,_R_))
47 #define INSIDE_3D(_X_,_Y_,_Z_,_CX_,_CY_,_CZ_,_R_) ( INSIDE_1D(_X_,_CX_,_R_) && INSIDE_1D(_Y_,_CY_,_R_) && INSIDE_1D(_Z_,_CZ_,_R_) )
48
49 void Finley_Mesh_saveVTK(const char * filename_p,
50 Finley_Mesh *mesh_p,
51 const dim_t num_data,
52 char* *names_p,
53 escriptDataC* *data_pp)
54 {
55 #ifdef USE_VTK
56 char error_msg[LenErrorMsg_MAX], *txt_buffer=NULL, tmp_buffer[LEN_TMP_BUFFER];
57 double sampleAvg[NCOMP_MAX], *values, *QuadNodes;
58 size_t txt_buffer_in_use;
59 dim_t len_txt_buffer, max_len_names;
60 FILE * fileHandle_p = NULL;
61 int mpi_size, i, j, l, cellType;
62 dim_t i_data, hits, hits_old;
63 dim_t nDim, globalNumPoints, numCells, globalNumCells, numVTKNodesPerElement;
64 dim_t myNumPoints, numPointsPerSample, rank, nComp, nCompReqd;
65 dim_t shape, NN, numCellFactor, myNumCells, max_name_len;
66 bool_t *isCellCentered=NULL,write_celldata=FALSE,write_pointdata=FALSE, reduced_elements=FALSE;
67 bool_t set_scalar=FALSE,set_vector=FALSE, set_tensor=FALSE;
68 index_t myFirstNode, myLastNode, *globalNodeIndex, k, *node_index, myFirstCell;
69 #ifdef PASO_MPI
70 int ierr;
71 /* int amode = MPI_MODE_CREATE | MPI_MODE_WRONLY | MPI_MODE_SEQUENTIAL; */
72 const int amode = MPI_MODE_CREATE | MPI_MODE_WRONLY | MPI_MODE_UNIQUE_OPEN;
73 MPI_File mpi_fileHandle_p;
74 MPI_Status mpi_status;
75 MPI_Request mpi_req;
76 MPI_Info mpi_info=MPI_INFO_NULL;
77 #endif
78 Paso_MPI_rank my_mpi_rank;
79 int nodetype=FINLEY_NODES;
80 int elementtype=FINLEY_UNKNOWN;
81 char elemTypeStr[32];
82 Finley_NodeMapping *nodeMapping=NULL;
83 Finley_ElementFile* elements=NULL;
84 ElementTypeId TypeId;
85
86
87 /****************************************/
88 /* */
89 /* tags in the vtk file */
90
91 char* tags_header="<?xml version=\"1.0\"?>\n" \
92 "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\">\n" \
93 "<UnstructuredGrid>\n" \
94 "<Piece NumberOfPoints=\"%d\" NumberOfCells=\"%d\">\n" \
95 "<Points>\n" \
96 "<DataArray NumberOfComponents=\"%d\" type=\"Float64\" format=\"ascii\">\n";
97 char *tag_End_DataArray = "</DataArray>\n";
98 char* tag_End_PointData = "</PointData>\n";
99 char* tag_End_CellData = "</CellData>\n";
100 char *footer = "</Piece>\n</UnstructuredGrid>\n</VTKFile>\n";
101 char* tags_End_Points_and_Start_Conn = "</DataArray>\n</Points>\n<Cells>\n<DataArray Name=\"connectivity\" type=\"Int32\" format=\"ascii\">\n" ;
102 char* tags_End_Conn_and_Start_Offset = "</DataArray>\n<DataArray Name=\"offsets\" type=\"Int32\" format=\"ascii\">\n";
103 char* tags_End_Offset_and_Start_Type = "</DataArray>\n<DataArray Name=\"types\" type=\"UInt8\" format=\"ascii\">\n";
104 char* tag_Float_DataArray="<DataArray Name=\"%s\" type=\"Float64\" NumberOfComponents=\"%d\" format=\"ascii\">\n";
105 char *tags_End_Type_And_Cells = "</DataArray>\n</Cells>\n";
106
107 int VTK_QUADRATIC_HEXAHEDRON_INDEX[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16, 17, 18, 19, 12, 13, 14, 15 };
108 /* if there is no mesh we just return */
109 if (mesh_p==NULL) return;
110
111 my_mpi_rank = mesh_p->Nodes->MPIInfo->rank;
112 mpi_size = mesh_p->Nodes->MPIInfo->size;
113 nDim = mesh_p->Nodes->numDim;
114
115 if (! ( (nDim ==2) || (nDim == 3) ) ) {
116 Finley_setError(IO_ERROR, "saveVTK: spatial dimension 2 or 3 is supported only.");
117 return;
118 }
119 /*************************************************************************************/
120
121 /* open the file and check handle */
122
123 if (mpi_size > 1) {
124 #ifdef PASO_MPI
125 /* Collective Call */
126 #ifdef MPIO_HINTS
127 MPI_Info_create(&mpi_info);
128 /* MPI_Info_set(mpi_info, "striping_unit", "424288"); */
129 /* MPI_Info_set(mpi_info, "striping_factor", "16"); */
130 /* MPI_Info_set(mpi_info, "collective_buffering", "true"); */
131 /* MPI_Info_set(mpi_info, "cb_block_size", "131072"); */
132 /* MPI_Info_set(mpi_info, "cb_buffer_size", "1048567"); */
133 /* MPI_Info_set(mpi_info, "cb_nodes", "8"); */
134 /* MPI_Info_set(mpi_info, "access_style", "write_once, sequential"); */
135
136 /*XFS only */
137 /* MPI_Info_set(mpi_info, "direct_write", "true"); */
138 #endif
139 if ( my_mpi_rank == 0) {
140 if (Paso_fileExists(filename_p)) remove(filename_p);
141 }
142 ierr=MPI_File_open(mesh_p->Nodes->MPIInfo->comm, (char*)filename_p, amode,mpi_info, &mpi_fileHandle_p);
143 if (ierr != MPI_SUCCESS) {
144 perror(filename_p);
145 sprintf(error_msg, "saveVTK: File %s could not be opened for writing in parallel.", filename_p);
146 Finley_setError(IO_ERROR,error_msg);
147 } else {
148 MPI_File_set_view(mpi_fileHandle_p,MPI_DISPLACEMENT_CURRENT,MPI_CHAR, MPI_CHAR, "native" , mpi_info);
149 }
150 #endif
151 } else {
152 fileHandle_p = fopen(filename_p, "w");
153 if (fileHandle_p==NULL) {
154 sprintf(error_msg, "saveVTK: File %s could not be opened for writing.", filename_p);
155 Finley_setError(IO_ERROR,error_msg);
156 }
157 }
158 if (! Paso_MPIInfo_noError(mesh_p->Nodes->MPIInfo) ) return;
159 /*************************************************************************************/
160
161 /* find the mesh type to be written */
162
163 isCellCentered=TMPMEMALLOC(num_data,bool_t);
164 max_len_names=0;
165 if (!Finley_checkPtr(isCellCentered)) {
166 reduced_elements=FALSE;
167 nodetype=FINLEY_UNKNOWN;
168 elementtype=FINLEY_UNKNOWN;
169 for (i_data=0;i_data<num_data;++i_data) {
170 if (! isEmpty(data_pp[i_data])) {
171 switch(getFunctionSpaceType(data_pp[i_data]) ) {
172 case FINLEY_NODES:
173 nodetype = (nodetype == FINLEY_REDUCED_NODES) ? FINLEY_REDUCED_NODES : FINLEY_NODES;
174 isCellCentered[i_data]=FALSE;
175 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
176 elementtype=FINLEY_ELEMENTS;
177 } else {
178 Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
179 }
180 break;
181 case FINLEY_REDUCED_NODES:
182 nodetype = FINLEY_REDUCED_NODES;
183 isCellCentered[i_data]=FALSE;
184 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
185 elementtype=FINLEY_ELEMENTS;
186 } else {
187 Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
188 }
189 break;
190 case FINLEY_REDUCED_ELEMENTS:
191 reduced_elements=TRUE;
192 case FINLEY_ELEMENTS:
193 isCellCentered[i_data]=TRUE;
194 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
195 elementtype=FINLEY_ELEMENTS;
196 } else {
197 Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
198 }
199 break;
200 case FINLEY_REDUCED_FACE_ELEMENTS:
201 reduced_elements=TRUE;
202 case FINLEY_FACE_ELEMENTS:
203 isCellCentered[i_data]=TRUE;
204 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_FACE_ELEMENTS) {
205 elementtype=FINLEY_FACE_ELEMENTS;
206 } else {
207 Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
208 }
209 break;
210 case FINLEY_POINTS:
211 isCellCentered[i_data]=TRUE;
212 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_POINTS) {
213 elementtype=FINLEY_POINTS;
214 } else {
215 Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
216 }
217 break;
218 case FINLEY_REDUCED_CONTACT_ELEMENTS_1:
219 reduced_elements=TRUE;
220 case FINLEY_CONTACT_ELEMENTS_1:
221 isCellCentered[i_data]=TRUE;
222 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {
223 elementtype=FINLEY_CONTACT_ELEMENTS_1;
224 } else {
225 Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
226 }
227 break;
228 case FINLEY_REDUCED_CONTACT_ELEMENTS_2:
229 reduced_elements=TRUE;
230 case FINLEY_CONTACT_ELEMENTS_2:
231 isCellCentered[i_data]=TRUE;
232 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {
233 elementtype=FINLEY_CONTACT_ELEMENTS_1;
234 } else {
235 Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
236 }
237 break;
238 default:
239 sprintf(error_msg,"saveVTK: unknown function space type %d",getFunctionSpaceType(data_pp[i_data]));
240 Finley_setError(TYPE_ERROR,error_msg);
241 }
242 if (isCellCentered[i_data]) {
243 write_celldata=TRUE;
244 } else {
245 write_pointdata=TRUE;
246 }
247 max_len_names =MAX(max_len_names,(dim_t)strlen(names_p[i_data]));
248 }
249 }
250 nodetype = (nodetype == FINLEY_UNKNOWN) ? FINLEY_NODES : nodetype;
251 }
252 if (Finley_noError()) {
253
254 /***************************************/
255
256 /* select number of points and the mesh component */
257
258 if (nodetype == FINLEY_REDUCED_NODES) {
259 myFirstNode = Finley_NodeFile_getFirstReducedNode(mesh_p->Nodes);
260 myLastNode = Finley_NodeFile_getLastReducedNode(mesh_p->Nodes);
261 globalNumPoints = Finley_NodeFile_getGlobalNumReducedNodes(mesh_p->Nodes);
262 globalNodeIndex= Finley_NodeFile_borrowGlobalReducedNodesIndex(mesh_p->Nodes);
263 } else {
264 myFirstNode = Finley_NodeFile_getFirstNode(mesh_p->Nodes);
265 myLastNode = Finley_NodeFile_getLastNode(mesh_p->Nodes);
266 globalNumPoints = Finley_NodeFile_getGlobalNumNodes(mesh_p->Nodes);
267 globalNodeIndex= Finley_NodeFile_borrowGlobalNodesIndex(mesh_p->Nodes);
268 }
269 myNumPoints = myLastNode - myFirstNode;
270 if (elementtype==FINLEY_UNKNOWN) elementtype=FINLEY_ELEMENTS;
271 switch(elementtype) {
272 case FINLEY_ELEMENTS:
273 elements=mesh_p->Elements;
274 break;
275 case FINLEY_FACE_ELEMENTS:
276 elements=mesh_p->FaceElements;
277 break;
278 case FINLEY_POINTS:
279 elements=mesh_p->Points;
280 break;
281 case FINLEY_CONTACT_ELEMENTS_1:
282 elements=mesh_p->ContactElements;
283 break;
284 }
285 if (elements==NULL) {
286 Finley_setError(SYSTEM_ERROR,"saveVTK: undefined element file");
287 } else {
288 /* map finley element type to VTK element type */
289 numCells = elements->numElements;
290 globalNumCells = Finley_ElementFile_getGlobalNumElements(elements);
291 myNumCells= Finley_ElementFile_getMyNumElements(elements);
292 myFirstCell= Finley_ElementFile_getFirstElement(elements);
293 NN = elements->numNodes;
294 if (nodetype==FINLEY_REDUCED_NODES) {
295 TypeId = elements->LinearReferenceElement->Type->TypeId;
296 if (reduced_elements) {
297 QuadNodes=elements->LinearReferenceElementReducedOrder->QuadNodes;
298 } else {
299 QuadNodes=elements->LinearReferenceElement->QuadNodes;
300 }
301 } else {
302 TypeId = elements->ReferenceElement->Type->TypeId;
303 if (reduced_elements) {
304 QuadNodes=elements->ReferenceElementReducedOrder->QuadNodes;
305 } else {
306 QuadNodes=elements->ReferenceElement->QuadNodes;
307 }
308 }
309 switch(TypeId) {
310 case Point1:
311 case Line2Face:
312 case Line3Face:
313 case Point1_Contact:
314 case Line2Face_Contact:
315 case Line3Face_Contact:
316 numCellFactor=1;
317 cellType = VTK_VERTEX;
318 numVTKNodesPerElement = 1;
319 strcpy(elemTypeStr, "VTK_VERTEX");
320 break;
321
322 case Line2:
323 case Tri3Face:
324 case Rec4Face:
325 case Line2_Contact:
326 case Tri3_Contact:
327 case Tri3Face_Contact:
328 case Rec4Face_Contact:
329 numCellFactor=1;
330 cellType = VTK_LINE;
331 numVTKNodesPerElement = 2;
332 strcpy(elemTypeStr, "VTK_LINE");
333 break;
334
335 case Tri3:
336 case Tet4Face:
337 case Tet4Face_Contact:
338 numCellFactor=1;
339 cellType = VTK_TRIANGLE;
340 numVTKNodesPerElement = 3;
341 strcpy(elemTypeStr, "VTK_TRIANGLE");
342 break;
343
344 case Rec4:
345 case Hex8Face:
346 case Rec4_Contact:
347 case Hex8Face_Contact:
348 numCellFactor=1;
349 cellType = VTK_QUAD;
350 numVTKNodesPerElement = 4;
351 strcpy(elemTypeStr, "VTK_QUAD");
352 break;
353
354 case Rec9:
355 numCellFactor=4;
356 cellType = VTK_QUAD;
357 numVTKNodesPerElement = 4;
358 strcpy(elemTypeStr, "VTK_QUAD");
359 break;
360
361 case Tet4:
362 numCellFactor=1;
363 cellType = VTK_TETRA;
364 numVTKNodesPerElement = 4;
365 strcpy(elemTypeStr, "VTK_TETRA");
366 break;
367
368 case Hex8:
369 numCellFactor=1;
370 cellType = VTK_HEXAHEDRON;
371 numVTKNodesPerElement = 8;
372 strcpy(elemTypeStr, "VTK_HEXAHEDRON");
373 break;
374
375 case Line3:
376 case Tri6Face:
377 case Rec8Face:
378 case Line3_Contact:
379 case Tri6Face_Contact:
380 case Rec8Face_Contact:
381 numCellFactor=1;
382 cellType = VTK_QUADRATIC_EDGE;
383 numVTKNodesPerElement = 3;
384 strcpy(elemTypeStr, "VTK_QUADRATIC_EDGE");
385 break;
386
387 case Tri6:
388 case Tet10Face:
389 case Tri6_Contact:
390 case Tet10Face_Contact:
391 numCellFactor=1;
392 cellType = VTK_QUADRATIC_TRIANGLE;
393 numVTKNodesPerElement = 6;
394 strcpy(elemTypeStr, "VTK_QUADRATIC_TRIANGLE");
395 break;
396
397 case Rec8:
398 case Hex20Face:
399 case Rec8_Contact:
400 case Hex20Face_Contact:
401 numCellFactor=1;
402 cellType = VTK_QUADRATIC_QUAD;
403 numVTKNodesPerElement = 8;
404 strcpy(elemTypeStr, "VTK_QUADRATIC_QUAD");
405 break;
406
407 case Tet10:
408 numCellFactor=1;
409 cellType = VTK_QUADRATIC_TETRA;
410 numVTKNodesPerElement = 10;
411 strcpy(elemTypeStr, "VTK_QUADRATIC_TETRA");
412 break;
413
414 case Hex20:
415 numCellFactor=1;
416 cellType = VTK_QUADRATIC_HEXAHEDRON;
417 numVTKNodesPerElement = 20;
418 strcpy(elemTypeStr, "VTK_QUADRATIC_HEXAHEDRON");
419 break;
420
421 case Hex27:
422 numCellFactor=8;
423 cellType = VTK_HEXAHEDRON;
424 numVTKNodesPerElement = 8;
425 strcpy(elemTypeStr, "VTK_HEXAHEDRON");
426 break;
427
428 default:
429 sprintf(error_msg, "saveVTK: Element type %s is not supported by VTK",elements->ReferenceElement->Type->Name);
430 Finley_setError(VALUE_ERROR,error_msg);
431 }
432 }
433 }
434 /***************************************/
435
436 /***************************************/
437 /* */
438 /* allocate text buffer */
439 /* */
440 max_name_len=0;
441 for (i_data =0 ;i_data<num_data;++i_data) max_name_len=MAX(max_name_len,(dim_t)strlen(names_p[i_data]));
442 len_txt_buffer= strlen(tags_header) + 3 * LEN_PRINTED_INT_FORMAT + (30+3*max_name_len); /* header */
443 if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, myNumPoints * LEN_TMP_BUFFER);
444 if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, numCellFactor*myNumCells*(LEN_PRINTED_INT_FORMAT*numVTKNodesPerElement+1));
445 len_txt_buffer=MAX(len_txt_buffer,200+3*max_len_names);
446 len_txt_buffer=MAX(len_txt_buffer, (dim_t)strlen(tag_Float_DataArray) + LEN_PRINTED_INT_FORMAT + max_len_names);
447 if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, numCellFactor*myNumCells*LEN_PRINTED_FLOAT_TENSOR_FORMAT);
448 if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, myNumPoints*LEN_PRINTED_FLOAT_TENSOR_FORMAT);
449 txt_buffer=TMPMEMALLOC(len_txt_buffer+1,char);
450 Finley_checkPtr(txt_buffer);
451
452 if (Finley_noError()) {
453
454 /* select number of points and the mesh component */
455
456 sprintf(txt_buffer,tags_header,globalNumPoints,numCellFactor*globalNumCells,3);
457
458 if (mpi_size > 1) {
459 if ( my_mpi_rank == 0) {
460 #ifdef PASO_MPI
461 MPI_File_iwrite_shared(mpi_fileHandle_p,txt_buffer,strlen(txt_buffer),MPI_CHAR,&mpi_req);
462 MPI_Wait(&mpi_req,&mpi_status);
463 #endif
464 }
465 } else {
466 fprintf(fileHandle_p,txt_buffer);
467 }
468
469 /* write the nodes */
470
471 if (mpi_size > 1) {
472
473 txt_buffer[0] = '\0';
474 txt_buffer_in_use=0;
475 if (nDim==2) {
476 for (i = 0; i < mesh_p->Nodes->numNodes; i++) {
477 if ( (myFirstNode <= globalNodeIndex[i]) && (globalNodeIndex[i] < myLastNode) ) {
478 sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,
479 mesh_p->Nodes->Coordinates[INDEX2(0, i, nDim)],
480 mesh_p->Nodes->Coordinates[INDEX2(1, i, nDim)],
481 0.);
482 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
483 }
484 }
485 } else {
486 for (i = 0; i < mesh_p->Nodes->numNodes; i++) {
487 if ( (myFirstNode <= globalNodeIndex[i]) && (globalNodeIndex[i] < myLastNode) ) {
488 sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,
489 mesh_p->Nodes->Coordinates[INDEX2(0, i, nDim)],
490 mesh_p->Nodes->Coordinates[INDEX2(1, i, nDim)],
491 mesh_p->Nodes->Coordinates[INDEX2(2, i, nDim)]);
492 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
493 }
494 }
495
496 }
497 #ifdef PASO_MPI
498 if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
499 MPI_File_write_ordered(mpi_fileHandle_p, txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
500 #endif
501 } else {
502 if (nDim==2) {
503 for (i = 0; i < mesh_p->Nodes->numNodes; i++) {
504 if ( (myFirstNode <= globalNodeIndex[i]) && (globalNodeIndex[i] < myLastNode) ) {
505 fprintf(fileHandle_p,FLOAT_VECTOR_FORMAT,
506 mesh_p->Nodes->Coordinates[INDEX2(0, i, nDim)],
507 mesh_p->Nodes->Coordinates[INDEX2(1, i, nDim)],
508 0.);
509 }
510 }
511 } else {
512 for (i = 0; i < mesh_p->Nodes->numNodes; i++) {
513 if ( (myFirstNode <= globalNodeIndex[i]) && (globalNodeIndex[i] < myLastNode) ) {
514 fprintf(fileHandle_p,FLOAT_VECTOR_FORMAT,
515 mesh_p->Nodes->Coordinates[INDEX2(0, i, nDim)],
516 mesh_p->Nodes->Coordinates[INDEX2(1, i, nDim)],
517 mesh_p->Nodes->Coordinates[INDEX2(2, i, nDim)]);
518 }
519 }
520
521 }
522 }
523
524 /* close the Points and open connectivity */
525
526 if (mpi_size > 1) {
527 if ( my_mpi_rank == 0) {
528 #ifdef PASO_MPI
529 MPI_File_iwrite_shared(mpi_fileHandle_p, tags_End_Points_and_Start_Conn, strlen(tags_End_Points_and_Start_Conn), MPI_CHAR, &mpi_req);
530 MPI_Wait(&mpi_req,&mpi_status);
531 #endif
532 }
533 } else {
534 fprintf(fileHandle_p,tags_End_Points_and_Start_Conn);
535 }
536
537 /* write the cells */
538 if (nodetype == FINLEY_REDUCED_NODES) {
539 node_index=elements->ReferenceElement->Type->linearNodes;
540 } else if (VTK_QUADRATIC_HEXAHEDRON==cellType) {
541 node_index=VTK_QUADRATIC_HEXAHEDRON_INDEX;
542 } else if ( (numVTKNodesPerElement!=NN) && (TypeId!=Rec9) && (TypeId!=Hex27) ) {
543 node_index=elements->ReferenceElement->Type->geoNodes;
544 } else {
545 node_index=NULL;
546 }
547
548 if ( mpi_size > 1) {
549 txt_buffer[0] = '\0';
550 txt_buffer_in_use=0;
551 if (node_index == NULL) {
552 if (TypeId==Rec9) {
553 for (i = 0; i < numCells; i++) {
554 if (elements->Owner[i] == my_mpi_rank) {
555 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(0, i, NN)]]);
556 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
557 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
558 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
559 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
560 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
561
562 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
563 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(1, i, NN)]]);
564 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
565 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
566 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
567 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
568
569 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
570 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
571 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
572 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(3, i, NN)]]);
573 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
574 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
575
576 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
577 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
578 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(2, i, NN)]]);
579 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
580 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
581 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
582 }
583 }
584 } else if (TypeId==Hex27) {
585 for (i = 0; i < numCells; i++) {
586 if (elements->Owner[i] == my_mpi_rank) {
587 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 0, i, NN)]]);
588 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
589 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
590 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
591 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
592 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
593 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
594 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
595 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
596 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
597
598 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
599 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 1, i, NN)]]);
600 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
601 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
602 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
603 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
604 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
605 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
606 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
607 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
608
609 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
610 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
611 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
612 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 3, i, NN)]]);
613 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
614 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
615 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
616 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
617 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
618 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
619
620 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
621 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
622 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 2, i, NN)]]);
623 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
624 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
625 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
626 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
627 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
628 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
629 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
630
631 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
632 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
633 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
634 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
635 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 4, i, NN)]]);
636 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
637 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
638 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
639 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
640 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
641
642 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
643 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
644 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
645 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
646 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
647 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 5, i, NN)]]);
648 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
649 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
650 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
651 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
652
653 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
654 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
655 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
656 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
657 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
658 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
659 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
660 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 7, i, NN)]]);
661 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
662 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
663
664 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
665 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
666 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
667 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
668 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
669 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
670 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 6, i, NN)]]);
671 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
672 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
673 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
674 }
675 }
676 } else {
677 for (i = 0; i < numCells; i++) {
678 if (elements->Owner[i] == my_mpi_rank) {
679 for (j = 0; j < numVTKNodesPerElement; j++) {
680 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);
681 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
682 }
683 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
684 }
685 }
686 }
687 } else {
688 for (i = 0; i < numCells; i++) {
689 if (elements->Owner[i] == my_mpi_rank) {
690 for (j = 0; j < numVTKNodesPerElement; j++) {
691 sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(node_index[j], i, NN)]]);
692 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
693 }
694 __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
695 }
696 }
697 }
698 #ifdef PASO_MPI
699 if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
700 MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
701 #endif
702 } else {
703 if (node_index == NULL) {
704 if (TypeId==Rec9) {
705 for (i = 0; i < numCells; i++) {
706 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(0, i, NN)]]);
707 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
708 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
709 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
710 fprintf(fileHandle_p,NEWLINE);
711
712 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
713 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(1, i, NN)]]);
714 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
715 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
716 fprintf(fileHandle_p,NEWLINE);
717
718 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
719 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
720 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
721 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(3, i, NN)]]);
722 fprintf(fileHandle_p,NEWLINE);
723
724 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
725 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
726 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(2, i, NN)]]);
727 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
728 fprintf(fileHandle_p,NEWLINE);
729 }
730
731 } else if (TypeId==Hex27) {
732 for (i = 0; i < numCells; i++) {
733 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 0, i, NN)]]);
734 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
735 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
736 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
737 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
738 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
739 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
740 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
741 fprintf(fileHandle_p,NEWLINE);
742
743 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
744 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 1, i, NN)]]);
745 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
746 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
747 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
748 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
749 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
750 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
751 fprintf(fileHandle_p,NEWLINE);
752
753 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
754 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
755 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
756 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 3, i, NN)]]);
757 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
758 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
759 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
760 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
761 fprintf(fileHandle_p,NEWLINE);
762
763 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
764 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
765 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 2, i, NN)]]);
766 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
767 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
768 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
769 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
770 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
771 fprintf(fileHandle_p,NEWLINE);
772
773 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
774 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
775 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
776 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
777 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 4, i, NN)]]);
778 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
779 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
780 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
781 fprintf(fileHandle_p,NEWLINE);
782
783 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
784 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
785 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
786 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
787 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
788 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 5, i, NN)]]);
789 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
790 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
791 fprintf(fileHandle_p,NEWLINE);
792
793 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
794 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
795 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
796 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
797 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
798 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
799 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
800 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 7, i, NN)]]);
801 fprintf(fileHandle_p,NEWLINE);
802
803 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
804 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
805 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
806 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
807 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
808 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
809 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 6, i, NN)]]);
810 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
811 fprintf(fileHandle_p,NEWLINE);
812 }
813 } else {
814 for (i = 0; i < numCells; i++) {
815 for (j = 0; j < numVTKNodesPerElement; j++) {
816 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);
817 }
818 fprintf(fileHandle_p,NEWLINE);
819 }
820 }
821 } else {
822 for (i = 0; i < numCells; i++) {
823 for (j = 0; j < numVTKNodesPerElement; j++) {
824 fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(node_index[j], i, NN)]]);
825 }
826 fprintf(fileHandle_p,NEWLINE);
827 }
828 }
829
830 }
831 /* finalize the connection and start the offset section */
832 if (mpi_size > 1) {
833 if( my_mpi_rank == 0) {
834 #ifdef PASO_MPI
835 MPI_File_iwrite_shared(mpi_fileHandle_p,tags_End_Conn_and_Start_Offset,strlen(tags_End_Conn_and_Start_Offset),MPI_CHAR,&mpi_req);
836 MPI_Wait(&mpi_req,&mpi_status);
837 #endif
838 }
839 } else {
840 fprintf(fileHandle_p,tags_End_Conn_and_Start_Offset);
841 }
842
843 /* write the offsets */
844
845 if ( mpi_size > 1) {
846 txt_buffer[0] = '\0';
847 txt_buffer_in_use=0;
848 for (i=numVTKNodesPerElement*(myFirstCell*numCellFactor+1); i<=(myFirstCell+myNumCells)*numVTKNodesPerElement*numCellFactor; i+=numVTKNodesPerElement) {
849 sprintf(tmp_buffer, INT_NEWLINE_FORMAT, i);
850 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
851 }
852 #ifdef PASO_MPI
853 if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
854 MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
855 #endif
856 } else {
857 for (i=numVTKNodesPerElement; i<=numCells*numVTKNodesPerElement*numCellFactor; i+=numVTKNodesPerElement) {
858 fprintf(fileHandle_p, INT_NEWLINE_FORMAT, i);
859 }
860
861 }
862 /* finalize the offset section and start the type section */
863 if ( mpi_size > 1) {
864 if ( my_mpi_rank == 0) {
865 #ifdef PASO_MPI
866 MPI_File_iwrite_shared(mpi_fileHandle_p,tags_End_Offset_and_Start_Type,strlen(tags_End_Offset_and_Start_Type),MPI_CHAR,&mpi_req);
867 MPI_Wait(&mpi_req,&mpi_status);
868 #endif
869 }
870 } else {
871 fprintf(fileHandle_p,tags_End_Offset_and_Start_Type);
872 }
873 /* write element type */
874 sprintf(tmp_buffer, INT_NEWLINE_FORMAT, cellType);
875 if ( mpi_size > 1) {
876 txt_buffer[0] = '\0';
877 txt_buffer_in_use=0;
878 for (i=numVTKNodesPerElement*(myFirstCell*numCellFactor+1); i<=(myFirstCell+myNumCells)*numVTKNodesPerElement*numCellFactor; i+=numVTKNodesPerElement) {
879 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
880 }
881 #ifdef PASO_MPI
882 if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
883 MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
884 #endif
885 } else {
886 for (i=0; i<numCells*numCellFactor; i++) fprintf(fileHandle_p, tmp_buffer);
887 }
888 /* finalize cell information */
889 if ( mpi_size > 1) {
890 if ( my_mpi_rank == 0) {
891 #ifdef PASO_MPI
892 MPI_File_iwrite_shared(mpi_fileHandle_p,tags_End_Type_And_Cells,strlen(tags_End_Type_And_Cells),MPI_CHAR,&mpi_req);
893 MPI_Wait(&mpi_req,&mpi_status);
894 #endif
895 }
896 } else {
897 fprintf(fileHandle_p,tags_End_Type_And_Cells);
898 }
899 }
900
901 /* Write cell data */
902 if (write_celldata && Finley_noError()) {
903 /* mark the active data arrays */
904 txt_buffer[0] = '\0';
905 set_scalar=FALSE,set_vector=FALSE, set_tensor=FALSE;
906 strcat(txt_buffer, "<CellData");
907 for (i_data =0 ;i_data<num_data;++i_data) {
908 if (! isEmpty(data_pp[i_data]) && isCellCentered[i_data]) {
909 /* if the rank == 0: --> scalar data */
910 /* if the rank == 1: --> vector data */
911 /* if the rank == 2: --> tensor data */
912
913 switch(getDataPointRank(data_pp[i_data])) {
914 case 0:
915 if (! set_scalar) {
916 strcat(txt_buffer," Scalars=\"");
917 strcat(txt_buffer,names_p[i_data]);
918 strcat(txt_buffer,"\"");
919 set_scalar=TRUE;
920 }
921 break;
922 case 1:
923 if (! set_vector) {
924 strcat(txt_buffer," Vectors=\"");
925 strcat(txt_buffer,names_p[i_data]);
926 strcat(txt_buffer,"\"");
927 set_vector=TRUE;
928 }
929 break;
930 case 2:
931 if (! set_tensor) {
932 strcat(txt_buffer," Tensors=\"");
933 strcat(txt_buffer,names_p[i_data]);
934 strcat(txt_buffer,"\"");
935 set_tensor=TRUE;
936 }
937 break;
938 default:
939 sprintf(error_msg, "saveVTK: data %s: Vtk can't handle objects with rank greater than 2.",names_p[i_data]);
940 Finley_setError(VALUE_ERROR,error_msg);
941 return;
942 }
943 }
944 }
945 strcat(txt_buffer, ">\n");
946 if ( mpi_size > 1) {
947 if ( my_mpi_rank == 0) {
948 #ifdef PASO_MPI
949 MPI_File_iwrite_shared(mpi_fileHandle_p,txt_buffer,strlen(txt_buffer),MPI_CHAR,&mpi_req);
950 MPI_Wait(&mpi_req,&mpi_status);
951 #endif
952 }
953 } else {
954 fprintf(fileHandle_p,txt_buffer);
955 }
956 /* write the arrays */
957 for (i_data =0 ;i_data<num_data;++i_data) {
958 if (! isEmpty(data_pp[i_data]) && isCellCentered[i_data]) {
959 txt_buffer[0] = '\0';
960 txt_buffer_in_use=0;
961 numPointsPerSample=getNumDataPointsPerSample(data_pp[i_data]);
962 rank = getDataPointRank(data_pp[i_data]);
963 nComp = getDataPointSize(data_pp[i_data]);
964 nCompReqd=1; /* the number of components mpi_required by vtk */
965 shape=0;
966 if (rank == 0) {
967 nCompReqd = 1;
968 } else if (rank == 1) {
969 shape=getDataPointShape(data_pp[i_data], 0);
970 if (shape>3) {
971 Finley_setError(VALUE_ERROR, "saveVTK: rank 1 object must have less then 4 components");
972 }
973 nCompReqd = 3;
974 } else {
975 shape=getDataPointShape(data_pp[i_data], 0);
976 if (shape>3 || shape != getDataPointShape(data_pp[i_data], 1)) {
977 Finley_setError(VALUE_ERROR, "saveVTK: rank 2 object must have less then 4x4 components and must have a square shape");
978 }
979 nCompReqd = 9;
980 }
981 if (Finley_noError()) {
982 sprintf(txt_buffer,tag_Float_DataArray,names_p[i_data], nCompReqd);
983 if ( mpi_size > 1) {
984 if ( my_mpi_rank == 0) {
985 #ifdef PASO_MPI
986 MPI_File_iwrite_shared(mpi_fileHandle_p,txt_buffer,strlen(txt_buffer),MPI_CHAR,&mpi_req);
987 MPI_Wait(&mpi_req,&mpi_status);
988 #endif
989 }
990 } else {
991 fprintf(fileHandle_p,txt_buffer);
992 }
993
994 for (i=0; i<numCells; i++) {
995 if (elements->Owner[i] == my_mpi_rank) {
996 values = getSampleData(data_pp[i_data], i);
997 for (l=0; l< numCellFactor;++l) {
998 /* averaging over the number of points in the sample */
999 if (isExpanded(data_pp[i_data])) {
1000 for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k]=0;
1001 hits=0;
1002 for (j=0; j<numPointsPerSample; j++) {
1003 hits_old=hits;
1004 if (TypeId==Rec9) {
1005 switch(l) {
1006 case 0:
1007 if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.25,0.25,0.25)) hits++;
1008 break;
1009 case 1:
1010 if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.75,0.25,0.25)) hits++;
1011 break;
1012 case 2:
1013 if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.25,0.75,0.25)) hits++;
1014 break;
1015 case 3:
1016 if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.75,0.75,0.25)) hits++;
1017 break;
1018 }
1019 } else if (TypeId==Hex27) {
1020 switch(l) {
1021 case 0:
1022 if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.25,0.25,0.25)) hits++;
1023 break;
1024 case 1:
1025 if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.25,0.25,0.25)) hits++;
1026 break;
1027 case 2:
1028 if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.25,0.25)) hits++;
1029 break;
1030 case 3:
1031 if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.25,0.25)) hits++;
1032 break;
1033 case 4:
1034 if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.25,0.75,0.25)) hits++;
1035 break;
1036 case 5:
1037 if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.25,0.75,0.25)) hits++;
1038 break;
1039 case 6:
1040 if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.75,0.25)) hits++;
1041 break;
1042 case 7:
1043 if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.75,0.25)) hits++;
1044 break;
1045 }
1046 } else {
1047 hits++;
1048 }
1049 if (hits_old<hits) for (k=0; k<MIN(nComp,NCOMP_MAX); k++) {
1050 sampleAvg[k] += values[INDEX2(k,j,nComp)];
1051 }
1052 }
1053 for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] /=MAX(hits,1);
1054 } else {
1055 for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] = values[k];
1056 }
1057 /* if the number of required components is more than the number
1058 * of actual components, pad with zeros
1059 */
1060 /* probably only need to get shape of first element */
1061 /* write the data different ways for scalar, vector and tensor */
1062 if (nCompReqd == 1) {
1063 sprintf(tmp_buffer,FLOAT_SCALAR_FORMAT,sampleAvg[0]);
1064 } else if (nCompReqd == 3) {
1065 if (shape==1) {
1066 sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],0.,0.);
1067 } else if (shape==2) {
1068 sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],0.);
1069 } else if (shape==3) {
1070 sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2]);
1071 }
1072 } else if (nCompReqd == 9) {
1073 if (shape==1) {
1074 sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],0.,0.,
1075 0.,0.,0.,
1076 0.,0.,0.);
1077 } else if (shape==2) {
1078 sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],0.,
1079 sampleAvg[2],sampleAvg[3],0.,
1080 0.,0.,0.);
1081 } else if (shape==3) {
1082 sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2],
1083 sampleAvg[3],sampleAvg[4],sampleAvg[5],
1084 sampleAvg[6],sampleAvg[7],sampleAvg[8]);
1085 }
1086 }
1087 /* this needs a bit mor work!!! */
1088 if ( mpi_size > 1) {
1089 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
1090 } else {
1091 fprintf(fileHandle_p,tmp_buffer);
1092 }
1093 }
1094 }
1095 }
1096 if ( mpi_size > 1) {
1097 #ifdef PASO_MPI
1098 if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
1099 MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
1100 #endif
1101 if ( my_mpi_rank == 0) {
1102 #ifdef PASO_MPI
1103 MPI_File_iwrite_shared(mpi_fileHandle_p,tag_End_DataArray,strlen(tag_End_DataArray),MPI_CHAR,&mpi_req);
1104 MPI_Wait(&mpi_req,&mpi_status);
1105 #endif
1106 }
1107 } else {
1108 fprintf(fileHandle_p,tag_End_DataArray);
1109 }
1110 }
1111 }
1112 }
1113 if ( mpi_size > 1) {
1114 if ( my_mpi_rank == 0) {
1115 #ifdef PASO_MPI
1116 MPI_File_iwrite_shared(mpi_fileHandle_p,tag_End_CellData,strlen(tag_End_CellData),MPI_CHAR,&mpi_req);
1117 MPI_Wait(&mpi_req,&mpi_status);
1118 #endif
1119 }
1120 } else {
1121 fprintf(fileHandle_p,tag_End_CellData);
1122 }
1123 }
1124 /* point data */
1125 if (write_pointdata && Finley_noError()) {
1126 /* mark the active data arrays */
1127 set_scalar=FALSE,set_vector=FALSE, set_tensor=FALSE;
1128 txt_buffer[0] = '\0';
1129 strcat(txt_buffer, "<PointData");
1130 for (i_data =0 ;i_data<num_data;++i_data) {
1131 if (! isEmpty(data_pp[i_data]) && !isCellCentered[i_data]) {
1132 /* if the rank == 0: --> scalar data */
1133 /* if the rank == 1: --> vector data */
1134 /* if the rank == 2: --> tensor data */
1135
1136 switch(getDataPointRank(data_pp[i_data])) {
1137 case 0:
1138 if (! set_scalar) {
1139 strcat(txt_buffer," Scalars=\"");
1140 strcat(txt_buffer,names_p[i_data]);
1141 strcat(txt_buffer,"\"");
1142 set_scalar=TRUE;
1143 }
1144 break;
1145 case 1:
1146 if (! set_vector) {
1147 strcat(txt_buffer," Vectors=\"");
1148 strcat(txt_buffer,names_p[i_data]);
1149 strcat(txt_buffer,"\"");
1150 set_vector=TRUE;
1151 }
1152 break;
1153 case 2:
1154 if (! set_tensor) {
1155 strcat(txt_buffer," Tensors=\"");
1156 strcat(txt_buffer,names_p[i_data]);
1157 strcat(txt_buffer,"\"");
1158 set_tensor=TRUE;
1159 }
1160 break;
1161 default:
1162 sprintf(error_msg, "saveVTK: data %s: Vtk can't handle objects with rank greater than 2.",names_p[i_data]);
1163 Finley_setError(VALUE_ERROR,error_msg);
1164 return;
1165 }
1166 }
1167 }
1168 strcat(txt_buffer, ">\n");
1169 if ( mpi_size > 1) {
1170 if ( my_mpi_rank == 0) {
1171 #ifdef PASO_MPI
1172 MPI_File_iwrite_shared(mpi_fileHandle_p,txt_buffer,strlen(txt_buffer),MPI_CHAR,&mpi_req);
1173 MPI_Wait(&mpi_req,&mpi_status);
1174 #endif
1175 }
1176 } else {
1177 fprintf(fileHandle_p,txt_buffer);
1178 }
1179 /* write the arrays */
1180 for (i_data =0 ;i_data<num_data;++i_data) {
1181 if (! isEmpty(data_pp[i_data]) && !isCellCentered[i_data]) {
1182 txt_buffer[0] = '\0';
1183 txt_buffer_in_use=0;
1184 numPointsPerSample=getNumDataPointsPerSample(data_pp[i_data]);
1185 rank = getDataPointRank(data_pp[i_data]);
1186 nComp = getDataPointSize(data_pp[i_data]);
1187 if (getFunctionSpaceType(data_pp[i_data]) == FINLEY_REDUCED_NODES) {
1188 nodeMapping=mesh_p->Nodes->reducedNodesMapping;
1189 } else {
1190 nodeMapping=mesh_p->Nodes->nodesMapping;
1191 }
1192 nCompReqd=1; /* the number of components mpi_required by vtk */
1193 shape=0;
1194 if (rank == 0) {
1195 nCompReqd = 1;
1196 } else if (rank == 1) {
1197 shape=getDataPointShape(data_pp[i_data], 0);
1198 if (shape>3) {
1199 Finley_setError(VALUE_ERROR, "saveVTK: rank 1 object must have less then 4 components");
1200 }
1201 nCompReqd = 3;
1202 } else {
1203 shape=getDataPointShape(data_pp[i_data], 0);
1204 if (shape>3 || shape != getDataPointShape(data_pp[i_data], 1)) {
1205 Finley_setError(VALUE_ERROR, "saveVTK: rank 2 object must have less then 4x4 components and must have a square shape");
1206 }
1207 nCompReqd = 9;
1208 }
1209 if (Finley_noError()) {
1210 sprintf(txt_buffer,tag_Float_DataArray,names_p[i_data], nCompReqd);
1211 if ( mpi_size > 1) {
1212 if ( my_mpi_rank == 0) {
1213 #ifdef PASO_MPI
1214 MPI_File_iwrite_shared(mpi_fileHandle_p,txt_buffer,strlen(txt_buffer),MPI_CHAR,&mpi_req);
1215 MPI_Wait(&mpi_req,&mpi_status);
1216 #endif
1217 }
1218 } else {
1219 fprintf(fileHandle_p,txt_buffer);
1220 }
1221 for (i=0; i<mesh_p->Nodes->numNodes; i++) {
1222 k=globalNodeIndex[i];
1223 if ( (myFirstNode <= k) && (k < myLastNode) ) {
1224 values = getSampleData(data_pp[i_data], nodeMapping->target[i]);
1225 /* if the number of mpi_required components is more than the number
1226 * of actual components, pad with zeros
1227 */
1228 /* probably only need to get shape of first element */
1229 /* write the data different ways for scalar, vector and tensor */
1230 if (nCompReqd == 1) {
1231 sprintf(tmp_buffer,FLOAT_SCALAR_FORMAT,values[0]);
1232 } else if (nCompReqd == 3) {
1233 if (shape==1) {
1234 sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,values[0],0.,0.);
1235 } else if (shape==2) {
1236 sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,values[0],values[1],0.);
1237 } else if (shape==3) {
1238 sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,values[0],values[1],values[2]);
1239 }
1240 } else if (nCompReqd == 9) {
1241 if (shape==1) {
1242 sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,values[0],0.,0.,
1243 0.,0.,0.,
1244 0.,0.,0.);
1245 } else if (shape==2) {
1246 sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,values[0],values[1],0.,
1247 values[2],values[3],0.,
1248 0.,0.,0.);
1249 } else if (shape==3) {
1250 sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,values[0],values[1],values[2],
1251 values[3],values[4],values[5],
1252 values[6],values[7],values[8]);
1253 }
1254 }
1255 if ( mpi_size > 1) {
1256 __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
1257 } else {
1258 fprintf(fileHandle_p,tmp_buffer);
1259 }
1260 }
1261 }
1262 if ( mpi_size > 1) {
1263 #ifdef PASO_MPI
1264 if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
1265 MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
1266 #endif
1267 if ( my_mpi_rank == 0) {
1268 #ifdef PASO_MPI
1269 MPI_File_iwrite_shared(mpi_fileHandle_p,tag_End_DataArray,strlen(tag_End_DataArray),MPI_CHAR,&mpi_req);
1270 MPI_Wait(&mpi_req,&mpi_status);
1271 #endif
1272 }
1273 } else {
1274 fprintf(fileHandle_p,tag_End_DataArray);
1275 }
1276 }
1277 }
1278 }
1279 if ( mpi_size > 1) {
1280 if ( my_mpi_rank == 0) {
1281 #ifdef PASO_MPI
1282 MPI_File_iwrite_shared(mpi_fileHandle_p,tag_End_PointData,strlen(tag_End_PointData),MPI_CHAR,&mpi_req);
1283 MPI_Wait(&mpi_req,&mpi_status);
1284 #endif
1285 }
1286 } else {
1287 fprintf(fileHandle_p,tag_End_PointData);
1288 }
1289 }
1290 if (Finley_noError()) {
1291 if ( mpi_size > 1) {
1292 if ( my_mpi_rank == 0) {
1293 #ifdef PASO_MPI
1294 MPI_File_iwrite_shared(mpi_fileHandle_p,footer,strlen(footer),MPI_CHAR,&mpi_req);
1295 MPI_Wait(&mpi_req,&mpi_status);
1296 #ifdef MPIO_HINTS
1297 MPI_Info_free(&mpi_info);
1298 #undef MPIO_HINTS
1299 #endif
1300 #endif
1301 }
1302 #ifdef PASO_MPI
1303 MPI_File_close(&mpi_fileHandle_p);
1304 #endif
1305 } else {
1306 fprintf(fileHandle_p,footer);
1307 fclose(fileHandle_p);
1308 }
1309 }
1310 TMPMEMFREE(isCellCentered);
1311 TMPMEMFREE(txt_buffer);
1312 return;
1313 #else
1314 /* Don't kill the job if saveVTK() doesn't work */
1315 fprintf(stderr, "\n\nsaveVTK warning: VTK is not available\n\n\n");
1316 #endif
1317 }

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26