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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

temp_trunk_copy/finley/src/Mesh_saveVTK.c revision 1384 by phornby, Fri Jan 11 02:29:38 2008 UTC trunk/finley/src/Mesh_saveVTK.c revision 1743 by ksteube, Tue Sep 2 00:54:05 2008 UTC
# Line 24  Line 24 
24  #include "Mesh.h"  #include "Mesh.h"
25  #include "Assemble.h"  #include "Assemble.h"
26  #include "vtkCellType.h"  /* copied from vtk source directory !!! */  #include "vtkCellType.h"  /* copied from vtk source directory !!! */
27    #include "paso/PasoUtil.h"
28    
29  #define LEN_PRINTED_INT_FORMAT (9+1)  #define LEN_PRINTED_INT_FORMAT (9+1)
30  #define INT_FORMAT "%d "  #define INT_FORMAT "%d "
# Line 42  Line 43 
43    strcpy(&dest[dest_in_use], chunk); \    strcpy(&dest[dest_in_use], chunk); \
44    dest_in_use+=strlen(chunk); \    dest_in_use+=strlen(chunk); \
45  }  }
46    #define INSIDE_1D(_X_,_C_,_R_) ( ABS((_X_)-(_C_)) <= (_R_) )
47    #define INSIDE_2D(_X_,_Y_,_CX_,_CY_,_R_) ( INSIDE_1D(_X_,_CX_,_R_) &&  INSIDE_1D(_Y_,_CY_,_R_))
48    #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_) )
49    
50  void Finley_Mesh_saveVTK(const char * filename_p,  void Finley_Mesh_saveVTK(const char * filename_p,
51                           Finley_Mesh *mesh_p,                           Finley_Mesh *mesh_p,
# Line 49  void Finley_Mesh_saveVTK(const char * fi Line 53  void Finley_Mesh_saveVTK(const char * fi
53                           char* *names_p,                           char* *names_p,
54                           escriptDataC* *data_pp)                           escriptDataC* *data_pp)
55  {  {
56    #ifdef USE_VTK
57    char error_msg[LenErrorMsg_MAX], *txt_buffer=NULL, tmp_buffer[LEN_TMP_BUFFER];    char error_msg[LenErrorMsg_MAX], *txt_buffer=NULL, tmp_buffer[LEN_TMP_BUFFER];
58    double sampleAvg[NCOMP_MAX], *values, rtmp;    double sampleAvg[NCOMP_MAX], *values, rtmp, *QuadNodes;
59    size_t len_txt_buffer, max_len_names, txt_buffer_in_use;    size_t txt_buffer_in_use;
60      dim_t len_txt_buffer,  max_len_names;
61    FILE * fileHandle_p = NULL;    FILE * fileHandle_p = NULL;
62    int mpi_size, i_data, i,j , cellType;    int mpi_size, i, j, l, cellType;
63    dim_t nDim, globalNumPoints, numCells, globalNumCells, numVTKNodesPerElement, myNumPoints, numPointsPerSample, rank, nComp, nCompReqd, shape, NN, numCellFactor, myNumCells, max_name_len;    dim_t i_data, hits, hits_old;
64    bool_t do_write, *isCellCentered=NULL,write_celldata=FALSE,write_pointdata=FALSE;    dim_t nDim, globalNumPoints, numCells, globalNumCells, numVTKNodesPerElement;
65      dim_t myNumPoints, numPointsPerSample, rank, nComp, nCompReqd;
66      dim_t shape, NN, numCellFactor, myNumCells, max_name_len;
67      bool_t *isCellCentered=NULL,write_celldata=FALSE,write_pointdata=FALSE, reduced_elements=FALSE;
68    bool_t set_scalar=FALSE,set_vector=FALSE, set_tensor=FALSE;    bool_t set_scalar=FALSE,set_vector=FALSE, set_tensor=FALSE;
69    index_t myFirstNode, myLastNode, *globalNodeIndex, k, *node_index, myFirstCell;    index_t myFirstNode, myLastNode, *globalNodeIndex, k, *node_index, myFirstCell;
70    #ifdef PASO_MPI    #ifdef PASO_MPI
71    int ierr;    int ierr;
72    int amode = MPI_MODE_CREATE | MPI_MODE_WRONLY |  MPI_MODE_SEQUENTIAL;    /* int amode = MPI_MODE_CREATE | MPI_MODE_WRONLY |  MPI_MODE_SEQUENTIAL;  */
73      const int amode = MPI_MODE_CREATE | MPI_MODE_WRONLY | MPI_MODE_UNIQUE_OPEN;
74    MPI_File mpi_fileHandle_p;    MPI_File mpi_fileHandle_p;
75    MPI_Status mpi_status;    MPI_Status mpi_status;
76    MPI_Request mpi_req;    MPI_Request mpi_req;
# Line 127  void Finley_Mesh_saveVTK(const char * fi Line 137  void Finley_Mesh_saveVTK(const char * fi
137              /*XFS only */              /*XFS only */
138              /*   MPI_Info_set(mpi_info, "direct_write",          "true"); */              /*   MPI_Info_set(mpi_info, "direct_write",          "true"); */
139            #endif            #endif
140              if ( my_mpi_rank == 0) {
141                  if  (Paso_fileExists(filename_p)) remove(filename_p);
142              }
143            ierr=MPI_File_open(mesh_p->Nodes->MPIInfo->comm, (char*)filename_p, amode,mpi_info, &mpi_fileHandle_p);            ierr=MPI_File_open(mesh_p->Nodes->MPIInfo->comm, (char*)filename_p, amode,mpi_info, &mpi_fileHandle_p);
144            if (! ierr) {            if (ierr != MPI_SUCCESS) {
145            perror(filename_p);            perror(filename_p);
146                sprintf(error_msg, "saveVTK: File %s could not be opened for writing in parallel.", filename_p);                sprintf(error_msg, "saveVTK: File %s could not be opened for writing in parallel.", filename_p);
147                Finley_setError(IO_ERROR,error_msg);                Finley_setError(IO_ERROR,error_msg);
# Line 151  void Finley_Mesh_saveVTK(const char * fi Line 164  void Finley_Mesh_saveVTK(const char * fi
164    isCellCentered=TMPMEMALLOC(num_data,bool_t);    isCellCentered=TMPMEMALLOC(num_data,bool_t);
165    max_len_names=0;    max_len_names=0;
166    if (!Finley_checkPtr(isCellCentered)) {    if (!Finley_checkPtr(isCellCentered)) {
167         reduced_elements=FALSE;
168       nodetype=FINLEY_UNKNOWN;       nodetype=FINLEY_UNKNOWN;
169       elementtype=FINLEY_UNKNOWN;       elementtype=FINLEY_UNKNOWN;
170       for (i_data=0;i_data<num_data;++i_data) {       for (i_data=0;i_data<num_data;++i_data) {
# Line 174  void Finley_Mesh_saveVTK(const char * fi Line 188  void Finley_Mesh_saveVTK(const char * fi
188               Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");               Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
189             }             }
190             break;             break;
          case FINLEY_ELEMENTS:  
191           case FINLEY_REDUCED_ELEMENTS:           case FINLEY_REDUCED_ELEMENTS:
192                reduced_elements=TRUE;
193             case FINLEY_ELEMENTS:
194             isCellCentered[i_data]=TRUE;             isCellCentered[i_data]=TRUE;
195             if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {             if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
196               elementtype=FINLEY_ELEMENTS;               elementtype=FINLEY_ELEMENTS;
# Line 183  void Finley_Mesh_saveVTK(const char * fi Line 198  void Finley_Mesh_saveVTK(const char * fi
198               Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");               Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
199             }             }
200             break;             break;
          case FINLEY_FACE_ELEMENTS:  
201           case FINLEY_REDUCED_FACE_ELEMENTS:           case FINLEY_REDUCED_FACE_ELEMENTS:
202                reduced_elements=TRUE;
203             case FINLEY_FACE_ELEMENTS:
204             isCellCentered[i_data]=TRUE;             isCellCentered[i_data]=TRUE;
205             if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_FACE_ELEMENTS) {             if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_FACE_ELEMENTS) {
206               elementtype=FINLEY_FACE_ELEMENTS;               elementtype=FINLEY_FACE_ELEMENTS;
# Line 200  void Finley_Mesh_saveVTK(const char * fi Line 216  void Finley_Mesh_saveVTK(const char * fi
216               Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");               Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
217             }             }
218             break;             break;
          case FINLEY_CONTACT_ELEMENTS_1:  
219           case FINLEY_REDUCED_CONTACT_ELEMENTS_1:           case FINLEY_REDUCED_CONTACT_ELEMENTS_1:
220                reduced_elements=TRUE;
221             case FINLEY_CONTACT_ELEMENTS_1:
222             isCellCentered[i_data]=TRUE;             isCellCentered[i_data]=TRUE;
223             if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {             if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {
224               elementtype=FINLEY_CONTACT_ELEMENTS_1;               elementtype=FINLEY_CONTACT_ELEMENTS_1;
# Line 209  void Finley_Mesh_saveVTK(const char * fi Line 226  void Finley_Mesh_saveVTK(const char * fi
226               Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");               Finley_setError(TYPE_ERROR,"saveVTK: cannot write given data in single file.");
227             }             }
228             break;             break;
          case FINLEY_CONTACT_ELEMENTS_2:  
229           case FINLEY_REDUCED_CONTACT_ELEMENTS_2:           case FINLEY_REDUCED_CONTACT_ELEMENTS_2:
230                reduced_elements=TRUE;
231             case FINLEY_CONTACT_ELEMENTS_2:
232             isCellCentered[i_data]=TRUE;             isCellCentered[i_data]=TRUE;
233             if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {             if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {
234               elementtype=FINLEY_CONTACT_ELEMENTS_1;               elementtype=FINLEY_CONTACT_ELEMENTS_1;
# Line 227  void Finley_Mesh_saveVTK(const char * fi Line 245  void Finley_Mesh_saveVTK(const char * fi
245           } else {           } else {
246             write_pointdata=TRUE;             write_pointdata=TRUE;
247           }           }
248           max_len_names =MAX(max_len_names,strlen(names_p[i_data]));           max_len_names =MAX(max_len_names,(dim_t)strlen(names_p[i_data]));
249         }         }
250       }       }
251       nodetype = (nodetype == FINLEY_UNKNOWN) ? FINLEY_NODES : nodetype;       nodetype = (nodetype == FINLEY_UNKNOWN) ? FINLEY_NODES : nodetype;
# Line 237  void Finley_Mesh_saveVTK(const char * fi Line 255  void Finley_Mesh_saveVTK(const char * fi
255       /***************************************/       /***************************************/
256    
257       /* select number of points and the mesh component */       /* select number of points and the mesh component */
258      
259       if (nodetype == FINLEY_REDUCED_NODES) {       if (nodetype == FINLEY_REDUCED_NODES) {
260          myFirstNode = Finley_NodeFile_getFirstReducedNode(mesh_p->Nodes);          myFirstNode = Finley_NodeFile_getFirstReducedNode(mesh_p->Nodes);
261          myLastNode = Finley_NodeFile_getLastReducedNode(mesh_p->Nodes);          myLastNode = Finley_NodeFile_getLastReducedNode(mesh_p->Nodes);
# Line 274  void Finley_Mesh_saveVTK(const char * fi Line 292  void Finley_Mesh_saveVTK(const char * fi
292         myNumCells= Finley_ElementFile_getMyNumElements(elements);         myNumCells= Finley_ElementFile_getMyNumElements(elements);
293         myFirstCell= Finley_ElementFile_getFirstElement(elements);         myFirstCell= Finley_ElementFile_getFirstElement(elements);
294         NN = elements->numNodes;         NN = elements->numNodes;
295         if (nodetype==FINLEY_REDUCED_NODES || nodetype==FINLEY_REDUCED_NODES) {         if (nodetype==FINLEY_REDUCED_NODES) {
296            TypeId = elements->LinearReferenceElement->Type->TypeId;            TypeId = elements->LinearReferenceElement->Type->TypeId;
297              if (reduced_elements) {
298                  QuadNodes=elements->LinearReferenceElementReducedOrder->QuadNodes;
299              } else {
300                  QuadNodes=elements->LinearReferenceElement->QuadNodes;
301              }
302         } else {         } else {
303            TypeId = elements->ReferenceElement->Type->TypeId;            TypeId = elements->ReferenceElement->Type->TypeId;
304              if (reduced_elements) {
305                  QuadNodes=elements->ReferenceElementReducedOrder->QuadNodes;
306              } else {
307                  QuadNodes=elements->ReferenceElement->QuadNodes;
308              }
309         }         }
310         switch(TypeId) {         switch(TypeId) {
311          case Point1:          case Point1:
# Line 323  void Finley_Mesh_saveVTK(const char * fi Line 351  void Finley_Mesh_saveVTK(const char * fi
351            numVTKNodesPerElement = 4;            numVTKNodesPerElement = 4;
352            strcpy(elemTypeStr, "VTK_QUAD");            strcpy(elemTypeStr, "VTK_QUAD");
353            break;            break;
354    
355            case Rec9:
356              numCellFactor=4;
357              cellType = VTK_QUAD;
358              numVTKNodesPerElement = 4;
359              strcpy(elemTypeStr, "VTK_QUAD");
360              break;
361                
362          case Tet4:          case Tet4:
363            numCellFactor=1;            numCellFactor=1;
# Line 383  void Finley_Mesh_saveVTK(const char * fi Line 418  void Finley_Mesh_saveVTK(const char * fi
418            numVTKNodesPerElement = 20;            numVTKNodesPerElement = 20;
419            strcpy(elemTypeStr, "VTK_QUADRATIC_HEXAHEDRON");            strcpy(elemTypeStr, "VTK_QUADRATIC_HEXAHEDRON");
420            break;            break;
421    
422            case Hex27:
423              numCellFactor=8;
424              cellType = VTK_HEXAHEDRON;
425              numVTKNodesPerElement = 8;
426              strcpy(elemTypeStr, "VTK_HEXAHEDRON");
427              break;
428                
429          default:          default:
430            sprintf(error_msg, "saveVTK: Element type %s is not supported by VTK",elements->ReferenceElement->Type->Name);            sprintf(error_msg, "saveVTK: Element type %s is not supported by VTK",elements->ReferenceElement->Type->Name);
# Line 397  void Finley_Mesh_saveVTK(const char * fi Line 439  void Finley_Mesh_saveVTK(const char * fi
439    /*   allocate text buffer              */    /*   allocate text buffer              */
440    /*                                     */    /*                                     */
441    max_name_len=0;    max_name_len=0;
442    for (i_data =0 ;i_data<num_data;++i_data) max_name_len=MAX(max_name_len,strlen(names_p[i_data]));    for (i_data =0 ;i_data<num_data;++i_data) max_name_len=MAX(max_name_len,(dim_t)strlen(names_p[i_data]));
443    len_txt_buffer= strlen(tags_header) + 3 * LEN_PRINTED_INT_FORMAT + (30+3*max_name_len); /* header */    len_txt_buffer= strlen(tags_header) + 3 * LEN_PRINTED_INT_FORMAT + (30+3*max_name_len); /* header */
444    if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, myNumPoints * LEN_TMP_BUFFER);    if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, myNumPoints * LEN_TMP_BUFFER);
445    if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, numCellFactor*myNumCells*(LEN_PRINTED_INT_FORMAT*numVTKNodesPerElement+1));    if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, numCellFactor*myNumCells*(LEN_PRINTED_INT_FORMAT*numVTKNodesPerElement+1));
446    len_txt_buffer=MAX(len_txt_buffer,200+3*max_len_names);    len_txt_buffer=MAX(len_txt_buffer,200+3*max_len_names);
447    len_txt_buffer=MAX(len_txt_buffer, strlen(tag_Float_DataArray) + LEN_PRINTED_INT_FORMAT + max_len_names);    len_txt_buffer=MAX(len_txt_buffer, (dim_t)strlen(tag_Float_DataArray) + LEN_PRINTED_INT_FORMAT + max_len_names);
448    if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, numCellFactor*myNumCells*LEN_PRINTED_FLOAT_TENSOR_FORMAT);    if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, numCellFactor*myNumCells*LEN_PRINTED_FLOAT_TENSOR_FORMAT);
449    if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, myNumPoints*LEN_PRINTED_FLOAT_TENSOR_FORMAT);    if (mpi_size > 1) len_txt_buffer=MAX(len_txt_buffer, myNumPoints*LEN_PRINTED_FLOAT_TENSOR_FORMAT);
450    txt_buffer=TMPMEMALLOC(len_txt_buffer+1,char);    txt_buffer=TMPMEMALLOC(len_txt_buffer+1,char);
# Line 454  void Finley_Mesh_saveVTK(const char * fi Line 496  void Finley_Mesh_saveVTK(const char * fi
496        
497           }           }
498           #ifdef PASO_MPI           #ifdef PASO_MPI
499                if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
500              MPI_File_write_ordered(mpi_fileHandle_p, txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);              MPI_File_write_ordered(mpi_fileHandle_p, txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
501           #endif               #endif    
502        } else {        } else {
# Line 497  void Finley_Mesh_saveVTK(const char * fi Line 540  void Finley_Mesh_saveVTK(const char * fi
540          node_index=elements->ReferenceElement->Type->linearNodes;          node_index=elements->ReferenceElement->Type->linearNodes;
541       } else if (VTK_QUADRATIC_HEXAHEDRON==cellType) {       } else if (VTK_QUADRATIC_HEXAHEDRON==cellType) {
542          node_index=VTK_QUADRATIC_HEXAHEDRON_INDEX;          node_index=VTK_QUADRATIC_HEXAHEDRON_INDEX;
543       } else if (numVTKNodesPerElement!=NN) {       } else if ( (numVTKNodesPerElement!=NN) && (TypeId!=Rec9) && (TypeId!=Hex27) ) {
544          node_index=elements->ReferenceElement->Type->geoNodes;          node_index=elements->ReferenceElement->Type->geoNodes;
545       } else {       } else {
546          node_index=NULL;          node_index=NULL;
# Line 507  void Finley_Mesh_saveVTK(const char * fi Line 550  void Finley_Mesh_saveVTK(const char * fi
550          txt_buffer[0] = '\0';          txt_buffer[0] = '\0';
551          txt_buffer_in_use=0;          txt_buffer_in_use=0;
552          if (node_index == NULL) {          if (node_index == NULL) {
553             for (i = 0; i < numCells; i++) {             if (TypeId==Rec9) {
554                if (elements->Owner[i] == my_mpi_rank) {                for (i = 0; i < numCells; i++) {
555                   for (j = 0; j < numVTKNodesPerElement; j++) {                   if (elements->Owner[i] == my_mpi_rank) {
556                       sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);                          sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(0, i, NN)]]);
557                       __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)                          sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
558                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
559                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
560                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
561                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
562    
563                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
564                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(1, i, NN)]]);
565                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
566                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
567                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
568                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
569    
570                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
571                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
572                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
573                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(3, i, NN)]]);
574                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
575                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
576    
577                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
578                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
579                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(2, i, NN)]]);
580                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
581                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
582                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
583                    }
584                  }
585               } else if (TypeId==Hex27) {
586                  for (i = 0; i < numCells; i++) {
587                     if (elements->Owner[i] == my_mpi_rank) {
588                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 0, i, NN)]]);
589                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
590                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
591                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
592                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
593                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
594                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
595                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
596                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
597                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
598    
599                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
600                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 1, i, NN)]]);
601                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
602                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
603                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
604                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
605                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
606                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
607                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
608                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
609    
610                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
611                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
612                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
613                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 3, i, NN)]]);
614                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
615                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
616                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
617                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
618                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
619                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
620    
621                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
622                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
623                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 2, i, NN)]]);
624                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
625                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
626                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
627                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
628                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
629                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
630                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
631    
632                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
633                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
634                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
635                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
636                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 4, i, NN)]]);
637                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
638                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
639                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
640                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
641                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
642    
643                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
644                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
645                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
646                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
647                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
648                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 5, i, NN)]]);
649                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
650                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
651                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
652                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
653    
654                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
655                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
656                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
657                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
658                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
659                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
660                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
661                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 7, i, NN)]]);
662                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
663                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
664    
665                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
666                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
667                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
668                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
669                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
670                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
671                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 6, i, NN)]]);
672                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
673                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
674                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
675                   }                   }
676                   __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)                }
677               } else {
678                  for (i = 0; i < numCells; i++) {
679                     if (elements->Owner[i] == my_mpi_rank) {
680                        for (j = 0; j < numVTKNodesPerElement; j++) {
681                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);
682                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
683                        }
684                        __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
685                     }
686                }                }
687             }             }
688          } else {          } else {
# Line 528  void Finley_Mesh_saveVTK(const char * fi Line 697  void Finley_Mesh_saveVTK(const char * fi
697             }             }
698          }          }
699          #ifdef PASO_MPI          #ifdef PASO_MPI
700               if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
701             MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);             MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
702          #endif              #endif    
703       } else {       } else {
704          if (node_index == NULL) {          if (node_index == NULL) {
705               if (TypeId==Rec9) {
706                  for (i = 0; i < numCells; i++) {
707                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(0, i, NN)]]);
708                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
709                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
710                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
711                            fprintf(fileHandle_p,NEWLINE);
712    
713                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
714                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(1, i, NN)]]);
715                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
716                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
717                            fprintf(fileHandle_p,NEWLINE);
718    
719                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
720                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
721                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
722                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(3, i, NN)]]);
723                            fprintf(fileHandle_p,NEWLINE);
724    
725                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
726                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
727                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(2, i, NN)]]);
728                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
729                            fprintf(fileHandle_p,NEWLINE);
730                  }
731    
732               } else if (TypeId==Hex27) {
733                     for (i = 0; i < numCells; i++) {
734                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 0, i, NN)]]);
735                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
736                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
737                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
738                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
739                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
740                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
741                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
742                            fprintf(fileHandle_p,NEWLINE);
743    
744                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
745                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 1, i, NN)]]);
746                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
747                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
748                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
749                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
750                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
751                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
752                            fprintf(fileHandle_p,NEWLINE);
753    
754                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
755                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
756                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
757                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 3, i, NN)]]);
758                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
759                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
760                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
761                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
762                            fprintf(fileHandle_p,NEWLINE);
763    
764                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
765                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
766                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 2, i, NN)]]);
767                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
768                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
769                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
770                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
771                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
772                            fprintf(fileHandle_p,NEWLINE);
773    
774                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
775                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
776                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
777                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
778                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 4, i, NN)]]);
779                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
780                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
781                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
782                            fprintf(fileHandle_p,NEWLINE);
783    
784                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
785                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
786                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
787                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
788                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
789                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 5, i, NN)]]);
790                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
791                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
792                            fprintf(fileHandle_p,NEWLINE);
793    
794                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
795                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
796                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
797                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
798                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
799                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
800                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
801                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 7, i, NN)]]);
802                            fprintf(fileHandle_p,NEWLINE);
803    
804                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
805                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
806                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
807                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
808                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
809                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
810                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 6, i, NN)]]);
811                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
812                            fprintf(fileHandle_p,NEWLINE);
813                     }
814                  } else {
815             for (i = 0; i < numCells; i++) {             for (i = 0; i < numCells; i++) {
816                for (j = 0; j < numVTKNodesPerElement; j++) {                   for (j = 0; j < numVTKNodesPerElement; j++) {
817                   fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);                      fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);
818                 }                    }
819                fprintf(fileHandle_p,NEWLINE);                   fprintf(fileHandle_p,NEWLINE);
820             }                }
821              }
822          } else {          } else {
823             for (i = 0; i < numCells; i++) {             for (i = 0; i < numCells; i++) {
824                for (j = 0; j < numVTKNodesPerElement; j++) {                for (j = 0; j < numVTKNodesPerElement; j++) {
# Line 548  void Finley_Mesh_saveVTK(const char * fi Line 829  void Finley_Mesh_saveVTK(const char * fi
829          }          }
830    
831       }       }
       
832       /* finalize the connection and start the offset section */       /* finalize the connection and start the offset section */
833       if (mpi_size > 1) {       if (mpi_size > 1) {
834          if( my_mpi_rank == 0) {          if( my_mpi_rank == 0) {
# Line 566  void Finley_Mesh_saveVTK(const char * fi Line 846  void Finley_Mesh_saveVTK(const char * fi
846       if ( mpi_size > 1) {       if ( mpi_size > 1) {
847          txt_buffer[0] = '\0';          txt_buffer[0] = '\0';
848          txt_buffer_in_use=0;          txt_buffer_in_use=0;
849          for (i=numVTKNodesPerElement*(myFirstCell*numCellFactor+1); i<=numCells*numVTKNodesPerElement*numCellFactor; i+=numVTKNodesPerElement) {          for (i=numVTKNodesPerElement*(myFirstCell*numCellFactor+1); i<=(myFirstCell+myNumCells)*numVTKNodesPerElement*numCellFactor; i+=numVTKNodesPerElement) {
850             sprintf(tmp_buffer, INT_NEWLINE_FORMAT, i);              sprintf(tmp_buffer, INT_NEWLINE_FORMAT, i);
851             __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);              __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
852           }           }
853           #ifdef PASO_MPI           #ifdef PASO_MPI
854                if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
855              MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);              MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
856           #endif               #endif    
857       } else {       } else {
# Line 590  void Finley_Mesh_saveVTK(const char * fi Line 871  void Finley_Mesh_saveVTK(const char * fi
871      } else {      } else {
872         fprintf(fileHandle_p,tags_End_Offset_and_Start_Type);         fprintf(fileHandle_p,tags_End_Offset_and_Start_Type);
873      }      }
       
         
874       /* write element type */       /* write element type */
875       sprintf(tmp_buffer, INT_NEWLINE_FORMAT, cellType);       sprintf(tmp_buffer, INT_NEWLINE_FORMAT, cellType);
876       if ( mpi_size > 1) {       if ( mpi_size > 1) {
# Line 599  void Finley_Mesh_saveVTK(const char * fi Line 878  void Finley_Mesh_saveVTK(const char * fi
878          txt_buffer_in_use=0;          txt_buffer_in_use=0;
879          for (i=0; i<numCells*numCellFactor; i++) __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);          for (i=0; i<numCells*numCellFactor; i++) __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
880           #ifdef PASO_MPI           #ifdef PASO_MPI
881                if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
882              MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);              MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
883           #endif               #endif    
884       } else {       } else {
# Line 709  void Finley_Mesh_saveVTK(const char * fi Line 989  void Finley_Mesh_saveVTK(const char * fi
989                 } else {                 } else {
990                     fprintf(fileHandle_p,txt_buffer);                     fprintf(fileHandle_p,txt_buffer);
991                 }                 }
992    
993                 for (i=0; i<numCells; i++) {                 for (i=0; i<numCells; i++) {
994                     if (elements->Owner[i] == my_mpi_rank) {                     if (elements->Owner[i] == my_mpi_rank) {
995                        values = getSampleData(data_pp[i_data], i);                        values = getSampleData(data_pp[i_data], i);
996                        /* averaging over the number of points in the sample */                        for (l=0; l< numCellFactor;++l) {
997                        for (k=0; k<MIN(nComp,NCOMP_MAX); k++) {                           /* averaging over the number of points in the sample */
998                           if (isExpanded(data_pp[i_data])) {                           if (isExpanded(data_pp[i_data])) {
999                             rtmp = 0.;                                for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k]=0;
1000                             for (j=0; j<numPointsPerSample; j++) rtmp += values[INDEX2(k,j,nComp)];                                hits=0;
1001                             sampleAvg[k] = rtmp/numPointsPerSample;                                for (j=0; j<numPointsPerSample; j++) {
1002                          } else {                                   hits_old=hits;
1003                             sampleAvg[k] = values[k];                                   if (TypeId==Rec9) {
1004                          }                                      switch(l) {
1005                        }                                        case 0:
1006                        /* if the number of mpi_required components is more than the number                                          if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.25,0.25,0.25)) hits++;  
1007                        * of actual components, pad with zeros                                          break;
1008                        */                                        case 1:
1009                        /* probably only need to get shape of first element */                                          if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.75,0.25,0.25)) hits++;  
1010                        /* write the data different ways for scalar, vector and tensor */                                          break;
1011                        if (nCompReqd == 1) {                                        case 2:
1012                          sprintf(tmp_buffer,FLOAT_SCALAR_FORMAT,sampleAvg[0]);                                          if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.25,0.75,0.25)) hits++;  
1013                        } else if (nCompReqd == 3) {                                          break;
1014                          if (shape==1) {                                        case 3:
1015                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],0.,0.);                                          if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.75,0.75,0.25)) hits++;  
1016                          } else if (shape==2) {                                          break;
1017                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],0.);                                        }
1018                          } else if (shape==3) {                                   } else if (TypeId==Hex27) {
1019                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2]);                                      switch(l) {
1020                          }                                        case 0:
1021                        } else if (nCompReqd == 9) {                                          if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.25,0.25,0.25)) hits++;  
1022                          if (shape==1) {                                          break;
1023                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],0.,0.,                                        case 1:
1024                                                                  0.,0.,0.,                                          if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.25,0.25,0.25)) hits++;  
1025                                                                  0.,0.,0.);                                          break;
1026                          } else if (shape==2) {                                        case 2:
1027                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],0.,                                          if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.25,0.25)) hits++;  
1028                                                                  sampleAvg[2],sampleAvg[3],0.,                                          break;
1029                                          case 3:
1030                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.25,0.25)) hits++;  
1031                                            break;
1032                                          case 4:
1033                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.25,0.75,0.25)) hits++;  
1034                                            break;
1035                                          case 5:
1036                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.25,0.75,0.25)) hits++;  
1037                                            break;
1038                                          case 6:
1039                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.75,0.25)) hits++;  
1040                                            break;
1041                                          case 7:
1042                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.75,0.25)) hits++;  
1043                                            break;
1044                                        }
1045                                     } else {
1046                                        hits++;
1047                                     }
1048                                     if (hits_old<hits) for (k=0; k<MIN(nComp,NCOMP_MAX); k++) {
1049                                         sampleAvg[k] += values[INDEX2(k,j,nComp)];
1050                                     }
1051                                  }
1052                                  for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] /=MAX(hits,1);
1053                             } else {
1054                                  for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] = values[k];
1055                             }
1056                             /* if the number of required components is more than the number
1057                             * of actual components, pad with zeros
1058                             */
1059                             /* probably only need to get shape of first element */
1060                             /* write the data different ways for scalar, vector and tensor */
1061                             if (nCompReqd == 1) {
1062                               sprintf(tmp_buffer,FLOAT_SCALAR_FORMAT,sampleAvg[0]);
1063                             } else if (nCompReqd == 3) {
1064                               if (shape==1) {
1065                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],0.,0.);
1066                               } else if (shape==2) {
1067                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],0.);
1068                               } else if (shape==3) {
1069                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2]);
1070                               }
1071                             } else if (nCompReqd == 9) {
1072                               if (shape==1) {
1073                                sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],0.,0.,
1074                                                                       0.,0.,0.,
1075                                                                  0.,0.,0.);                                                                  0.,0.,0.);
1076                          } else if (shape==3) {                             } else if (shape==2) {
1077                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2],                              sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],0.,
1078                                                                  sampleAvg[3],sampleAvg[4],sampleAvg[5],                                                                     sampleAvg[2],sampleAvg[3],0.,
1079                                                                  sampleAvg[6],sampleAvg[7],sampleAvg[8]);                                                                     0.,0.,0.);
1080                               } else if (shape==3) {
1081                                sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2],
1082                                                                       sampleAvg[3],sampleAvg[4],sampleAvg[5],
1083                                                                       sampleAvg[6],sampleAvg[7],sampleAvg[8]);
1084                               }
1085                             }
1086                             /* this needs a bit mor work!!! */
1087                                if ( mpi_size > 1) {
1088                                  __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
1089                                } else {
1090                                  fprintf(fileHandle_p,tmp_buffer);
1091                                }
1092                          }                          }
1093                        }                     }
                       if ( mpi_size > 1) {  
                         __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);  
                       } else {  
                         fprintf(fileHandle_p,tmp_buffer);  
                       }  
                   }  
1094                 }                 }
1095                 if ( mpi_size > 1) {                 if ( mpi_size > 1) {
1096                       #ifdef PASO_MPI                       #ifdef PASO_MPI
1097                            if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
1098                          MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);                          MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
1099                       #endif                           #endif    
1100                       if ( my_mpi_rank == 0) {                       if ( my_mpi_rank == 0) {
# Line 926  void Finley_Mesh_saveVTK(const char * fi Line 1260  void Finley_Mesh_saveVTK(const char * fi
1260                 }                 }
1261                 if ( mpi_size > 1) {                 if ( mpi_size > 1) {
1262                     #ifdef PASO_MPI                     #ifdef PASO_MPI
1263                         if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
1264                       MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);                       MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
1265                     #endif                         #endif    
1266                     if ( my_mpi_rank == 0) {                     if ( my_mpi_rank == 0) {
# Line 943  void Finley_Mesh_saveVTK(const char * fi Line 1278  void Finley_Mesh_saveVTK(const char * fi
1278          if ( mpi_size > 1) {          if ( mpi_size > 1) {
1279            if ( my_mpi_rank == 0) {            if ( my_mpi_rank == 0) {
1280               #ifdef PASO_MPI               #ifdef PASO_MPI
1281                  MPI_File_iwrite_shared(mpi_fileHandle_p,tag_End_CellData,strlen(tag_End_PointData),MPI_CHAR,&mpi_req);                  MPI_File_iwrite_shared(mpi_fileHandle_p,tag_End_PointData,strlen(tag_End_PointData),MPI_CHAR,&mpi_req);
1282                  MPI_Wait(&mpi_req,&mpi_status);                  MPI_Wait(&mpi_req,&mpi_status);
1283               #endif               #endif
1284            }            }
# Line 961  void Finley_Mesh_saveVTK(const char * fi Line 1296  void Finley_Mesh_saveVTK(const char * fi
1296                 MPI_Info_free(&mpi_info);                 MPI_Info_free(&mpi_info);
1297                 #undef MPIO_HINTS                 #undef MPIO_HINTS
1298               #endif               #endif
              MPI_File_close(&mpi_fileHandle_p);  
1299            #endif            #endif
1300          }          }
1301            #ifdef PASO_MPI
1302               MPI_File_close(&mpi_fileHandle_p);
1303            #endif
1304       } else {       } else {
1305           fprintf(fileHandle_p,footer);           fprintf(fileHandle_p,footer);
1306           fclose(fileHandle_p);           fclose(fileHandle_p);
# Line 972  void Finley_Mesh_saveVTK(const char * fi Line 1309  void Finley_Mesh_saveVTK(const char * fi
1309    TMPMEMFREE(isCellCentered);    TMPMEMFREE(isCellCentered);
1310    TMPMEMFREE(txt_buffer);    TMPMEMFREE(txt_buffer);
1311    return;    return;
1312    #else
1313      /* Don't kill the job if saveVTK() doesn't work */
1314      fprintf(stderr, "\n\nsaveVTK warning: VTK is not available\n\n\n");
1315    #endif
1316  }  }

Legend:
Removed from v.1384  
changed lines
  Added in v.1743

  ViewVC Help
Powered by ViewVC 1.1.26