/[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 1990 by ksteube, Fri Nov 7 04:19:07 2008 UTC
# Line 1  Line 1 
1    
 /* $Id$ */  
   
2  /*******************************************************  /*******************************************************
3   *  *
4   *           Copyright 2003-2007 by ACceSS MNRF  * Copyright (c) 2003-2008 by University of Queensland
5   *       Copyright 2007 by University of Queensland  * Earth Systems Science Computational Center (ESSCC)
6   *  * http://www.uq.edu.au/esscc
7   *                http://esscc.uq.edu.au  *
8   *        Primary Business: Queensland, Australia  * Primary Business: Queensland, Australia
9   *  Licensed under the Open Software License version 3.0  * Licensed under the Open Software License version 3.0
10   *     http://www.opensource.org/licenses/osl-3.0.php  * http://www.opensource.org/licenses/osl-3.0.php
11   *  *
12   *******************************************************/  *******************************************************/
13    
14    
15  /**************************************************************/  /**************************************************************/
16    
# Line 24  Line 23 
23  #include "Mesh.h"  #include "Mesh.h"
24  #include "Assemble.h"  #include "Assemble.h"
25  #include "vtkCellType.h"  /* copied from vtk source directory !!! */  #include "vtkCellType.h"  /* copied from vtk source directory !!! */
26    #include "paso/PasoUtil.h"
27    
28  #define LEN_PRINTED_INT_FORMAT (9+1)  #define LEN_PRINTED_INT_FORMAT (9+1)
29  #define INT_FORMAT "%d "  #define INT_FORMAT "%d "
# Line 42  Line 42 
42    strcpy(&dest[dest_in_use], chunk); \    strcpy(&dest[dest_in_use], chunk); \
43    dest_in_use+=strlen(chunk); \    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,  void Finley_Mesh_saveVTK(const char * filename_p,
50                           Finley_Mesh *mesh_p,                           Finley_Mesh *mesh_p,
# Line 49  void Finley_Mesh_saveVTK(const char * fi Line 52  void Finley_Mesh_saveVTK(const char * fi
52                           char* *names_p,                           char* *names_p,
53                           escriptDataC* *data_pp)                           escriptDataC* *data_pp)
54  {  {
55    #ifdef USE_VTK
56    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];
57    double sampleAvg[NCOMP_MAX], *values, rtmp;    double sampleAvg[NCOMP_MAX], *values, *QuadNodes=NULL;
58    size_t len_txt_buffer, max_len_names, txt_buffer_in_use;    size_t txt_buffer_in_use;
59      dim_t len_txt_buffer,  max_len_names;
60    FILE * fileHandle_p = NULL;    FILE * fileHandle_p = NULL;
61    int mpi_size, i_data, i,j , cellType;    int mpi_size, i, j, l, cellType=0;
62    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;
63    bool_t do_write, *isCellCentered=NULL,write_celldata=FALSE,write_pointdata=FALSE;    dim_t nDim, globalNumPoints=0, numCells=0, globalNumCells=0, numVTKNodesPerElement=0;
64    bool_t set_scalar=FALSE,set_vector=FALSE, set_tensor=FALSE;    dim_t myNumPoints=0, numPointsPerSample, rank, nComp, nCompReqd;
65    index_t myFirstNode, myLastNode, *globalNodeIndex, k, *node_index, myFirstCell;    dim_t shape, NN=0, numCellFactor=0, myNumCells=0, 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=0, myLastNode=0, *globalNodeIndex=NULL;
69      index_t k, *node_index, myFirstCell=0;
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 69  void Finley_Mesh_saveVTK(const char * fi Line 79  void Finley_Mesh_saveVTK(const char * fi
79    Paso_MPI_rank my_mpi_rank;    Paso_MPI_rank my_mpi_rank;
80    int nodetype=FINLEY_NODES;    int nodetype=FINLEY_NODES;
81    int elementtype=FINLEY_UNKNOWN;    int elementtype=FINLEY_UNKNOWN;
   char elemTypeStr[32];  
82    Finley_NodeMapping *nodeMapping=NULL;    Finley_NodeMapping *nodeMapping=NULL;
83    Finley_ElementFile* elements=NULL;    Finley_ElementFile* elements=NULL;
84    ElementTypeId TypeId;    ElementTypeId TypeId=0;
85        
86    
87    /****************************************/    /****************************************/
# Line 85  void Finley_Mesh_saveVTK(const char * fi Line 94  void Finley_Mesh_saveVTK(const char * fi
94                      "<Piece NumberOfPoints=\"%d\" NumberOfCells=\"%d\">\n" \                      "<Piece NumberOfPoints=\"%d\" NumberOfCells=\"%d\">\n" \
95                      "<Points>\n" \                      "<Points>\n" \
96                      "<DataArray NumberOfComponents=\"%d\" type=\"Float64\" format=\"ascii\">\n";                      "<DataArray NumberOfComponents=\"%d\" type=\"Float64\" format=\"ascii\">\n";
97    char *tag_End_DataArray = "</DataArray>\n";    char* tag_End_DataArray = "</DataArray>\n";
98    char* tag_End_PointData =  "</PointData>\n";    char* tag_End_PointData = "</PointData>\n";
99    char* tag_End_CellData =  "</CellData>\n";    char* tag_End_CellData =  "</CellData>\n";
100    char *footer = "</Piece>\n</UnstructuredGrid>\n</VTKFile>\n";    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" ;    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";    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";    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";    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";    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 };    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    
109    /* if there is no mesh we just return */    /* if there is no mesh we just return */
110    if (mesh_p==NULL) return;    if (mesh_p==NULL) return;
111    
# 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 289  void Finley_Mesh_saveVTK(const char * fi Line 317  void Finley_Mesh_saveVTK(const char * fi
317            numCellFactor=1;            numCellFactor=1;
318            cellType = VTK_VERTEX;            cellType = VTK_VERTEX;
319            numVTKNodesPerElement = 1;            numVTKNodesPerElement = 1;
           strcpy(elemTypeStr, "VTK_VERTEX");  
320            break;            break;
321                
322          case Line2:          case Line2:
# Line 302  void Finley_Mesh_saveVTK(const char * fi Line 329  void Finley_Mesh_saveVTK(const char * fi
329            numCellFactor=1;            numCellFactor=1;
330            cellType = VTK_LINE;            cellType = VTK_LINE;
331            numVTKNodesPerElement = 2;            numVTKNodesPerElement = 2;
           strcpy(elemTypeStr, "VTK_LINE");  
332            break;            break;
333                
334          case Tri3:          case Tri3:
# Line 311  void Finley_Mesh_saveVTK(const char * fi Line 337  void Finley_Mesh_saveVTK(const char * fi
337            numCellFactor=1;            numCellFactor=1;
338            cellType = VTK_TRIANGLE;            cellType = VTK_TRIANGLE;
339            numVTKNodesPerElement = 3;            numVTKNodesPerElement = 3;
           strcpy(elemTypeStr, "VTK_TRIANGLE");  
340            break;            break;
341                
342          case Rec4:          case Rec4:
# Line 321  void Finley_Mesh_saveVTK(const char * fi Line 346  void Finley_Mesh_saveVTK(const char * fi
346            numCellFactor=1;            numCellFactor=1;
347            cellType = VTK_QUAD;            cellType = VTK_QUAD;
348            numVTKNodesPerElement = 4;            numVTKNodesPerElement = 4;
349            strcpy(elemTypeStr, "VTK_QUAD");            break;
350    
351            case Rec9:
352              numCellFactor=4;
353              cellType = VTK_QUAD;
354              numVTKNodesPerElement = 4;
355            break;            break;
356                
357          case Tet4:          case Tet4:
358            numCellFactor=1;            numCellFactor=1;
359            cellType = VTK_TETRA;            cellType = VTK_TETRA;
360            numVTKNodesPerElement = 4;            numVTKNodesPerElement = 4;
           strcpy(elemTypeStr, "VTK_TETRA");  
361            break;            break;
362                
363          case Hex8:          case Hex8:
364            numCellFactor=1;            numCellFactor=1;
365            cellType = VTK_HEXAHEDRON;            cellType = VTK_HEXAHEDRON;
366            numVTKNodesPerElement = 8;            numVTKNodesPerElement = 8;
           strcpy(elemTypeStr, "VTK_HEXAHEDRON");  
367            break;            break;
368                
369          case Line3:          case Line3:
# Line 347  void Finley_Mesh_saveVTK(const char * fi Line 375  void Finley_Mesh_saveVTK(const char * fi
375            numCellFactor=1;            numCellFactor=1;
376            cellType = VTK_QUADRATIC_EDGE;            cellType = VTK_QUADRATIC_EDGE;
377            numVTKNodesPerElement = 3;            numVTKNodesPerElement = 3;
           strcpy(elemTypeStr, "VTK_QUADRATIC_EDGE");  
378            break;            break;
379                
380          case Tri6:          case Tri6:
# Line 357  void Finley_Mesh_saveVTK(const char * fi Line 384  void Finley_Mesh_saveVTK(const char * fi
384            numCellFactor=1;            numCellFactor=1;
385            cellType = VTK_QUADRATIC_TRIANGLE;            cellType = VTK_QUADRATIC_TRIANGLE;
386            numVTKNodesPerElement = 6;            numVTKNodesPerElement = 6;
           strcpy(elemTypeStr, "VTK_QUADRATIC_TRIANGLE");  
387            break;            break;
388                
389          case Rec8:          case Rec8:
# Line 367  void Finley_Mesh_saveVTK(const char * fi Line 393  void Finley_Mesh_saveVTK(const char * fi
393            numCellFactor=1;            numCellFactor=1;
394            cellType = VTK_QUADRATIC_QUAD;            cellType = VTK_QUADRATIC_QUAD;
395            numVTKNodesPerElement = 8;            numVTKNodesPerElement = 8;
           strcpy(elemTypeStr, "VTK_QUADRATIC_QUAD");  
396            break;            break;
397                
398          case Tet10:          case Tet10:
399            numCellFactor=1;            numCellFactor=1;
400            cellType = VTK_QUADRATIC_TETRA;            cellType = VTK_QUADRATIC_TETRA;
401            numVTKNodesPerElement = 10;            numVTKNodesPerElement = 10;
           strcpy(elemTypeStr, "VTK_QUADRATIC_TETRA");  
402            break;            break;
403                
404          case Hex20:          case Hex20:
405            numCellFactor=1;            numCellFactor=1;
406            cellType = VTK_QUADRATIC_HEXAHEDRON;            cellType = VTK_QUADRATIC_HEXAHEDRON;
407            numVTKNodesPerElement = 20;            numVTKNodesPerElement = 20;
408            strcpy(elemTypeStr, "VTK_QUADRATIC_HEXAHEDRON");            break;
409    
410            case Hex27:
411              numCellFactor=8;
412              cellType = VTK_HEXAHEDRON;
413              numVTKNodesPerElement = 8;
414            break;            break;
415                
416          default:          default:
# Line 397  void Finley_Mesh_saveVTK(const char * fi Line 426  void Finley_Mesh_saveVTK(const char * fi
426    /*   allocate text buffer              */    /*   allocate text buffer              */
427    /*                                     */    /*                                     */
428    max_name_len=0;    max_name_len=0;
429    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]));
430    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 */
431    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);
432    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));
433    len_txt_buffer=MAX(len_txt_buffer,200+3*max_len_names);    len_txt_buffer=MAX(len_txt_buffer,200+3*max_len_names);
434    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);
435    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);
436    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);
437    txt_buffer=TMPMEMALLOC(len_txt_buffer+1,char);    txt_buffer=TMPMEMALLOC(len_txt_buffer+1,char);
# Line 422  void Finley_Mesh_saveVTK(const char * fi Line 451  void Finley_Mesh_saveVTK(const char * fi
451              #endif              #endif
452            }            }
453        } else {        } else {
454           fprintf(fileHandle_p,txt_buffer);           fprintf(fileHandle_p, "%s", txt_buffer);
455        }        }
456    
457        /* write the nodes */        /* write the nodes */
# Line 454  void Finley_Mesh_saveVTK(const char * fi Line 483  void Finley_Mesh_saveVTK(const char * fi
483        
484           }           }
485           #ifdef PASO_MPI           #ifdef PASO_MPI
486                if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
487              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);
488           #endif               #endif    
489        } else {        } else {
# Line 489  void Finley_Mesh_saveVTK(const char * fi Line 519  void Finley_Mesh_saveVTK(const char * fi
519               #endif               #endif
520            }            }
521        } else {        } else {
522           fprintf(fileHandle_p,tags_End_Points_and_Start_Conn);           fprintf(fileHandle_p, "%s", tags_End_Points_and_Start_Conn);
523        }        }
524    
525       /* write the cells */       /* write the cells */
# Line 497  void Finley_Mesh_saveVTK(const char * fi Line 527  void Finley_Mesh_saveVTK(const char * fi
527          node_index=elements->ReferenceElement->Type->linearNodes;          node_index=elements->ReferenceElement->Type->linearNodes;
528       } else if (VTK_QUADRATIC_HEXAHEDRON==cellType) {       } else if (VTK_QUADRATIC_HEXAHEDRON==cellType) {
529          node_index=VTK_QUADRATIC_HEXAHEDRON_INDEX;          node_index=VTK_QUADRATIC_HEXAHEDRON_INDEX;
530       } else if (numVTKNodesPerElement!=NN) {       } else if ( (numVTKNodesPerElement!=NN) && (TypeId!=Rec9) && (TypeId!=Hex27) ) {
531          node_index=elements->ReferenceElement->Type->geoNodes;          node_index=elements->ReferenceElement->Type->geoNodes;
532       } else {       } else {
533          node_index=NULL;          node_index=NULL;
# Line 507  void Finley_Mesh_saveVTK(const char * fi Line 537  void Finley_Mesh_saveVTK(const char * fi
537          txt_buffer[0] = '\0';          txt_buffer[0] = '\0';
538          txt_buffer_in_use=0;          txt_buffer_in_use=0;
539          if (node_index == NULL) {          if (node_index == NULL) {
540             for (i = 0; i < numCells; i++) {             if (TypeId==Rec9) {
541                if (elements->Owner[i] == my_mpi_rank) {                for (i = 0; i < numCells; i++) {
542                   for (j = 0; j < numVTKNodesPerElement; j++) {                   if (elements->Owner[i] == my_mpi_rank) {
543                       sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);                          sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(0, i, NN)]]);
544                       __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)                          sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
545                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
546                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
547                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
548                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
549    
550                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
551                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(1, i, NN)]]);
552                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
553                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
554                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
555                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
556    
557                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, 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(6, i, NN)]]);
560                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(3, i, NN)]]);
561                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
562                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
563    
564                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, 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(2, i, NN)]]);
567                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
568                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
569                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
570                    }
571                  }
572               } else if (TypeId==Hex27) {
573                  for (i = 0; i < numCells; i++) {
574                     if (elements->Owner[i] == my_mpi_rank) {
575                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 0, i, NN)]]);
576                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
577                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
578                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
579                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
580                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
581                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
582                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
583                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
584                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
585    
586                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
587                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 1, i, NN)]]);
588                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, 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(21, i, NN)]]);
591                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
592                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
593                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
594                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
595                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
596    
597                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
598                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
599                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
600                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 3, i, NN)]]);
601                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
602                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
603                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
604                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
605                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
606                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
607    
608                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
609                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
610                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 2, 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(26, i, NN)]]);
613                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
614                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
615                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
616                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
617                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
618    
619                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
620                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
621                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
622                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
623                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 4, i, NN)]]);
624                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
625                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
626                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
627                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
628                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
629    
630                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
631                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
632                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, 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(16, i, NN)]]);
635                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 5, i, NN)]]);
636                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
637                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
638                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
639                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
640    
641                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
642                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
643                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
644                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
645                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
646                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
647                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
648                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 7, i, NN)]]);
649                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
650                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
651    
652                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
653                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
654                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, 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(25, i, NN)]]);
657                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
658                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 6, i, NN)]]);
659                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
660                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
661                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
662                   }                   }
663                   __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)                }
664               } else {
665                  for (i = 0; i < numCells; i++) {
666                     if (elements->Owner[i] == my_mpi_rank) {
667                        for (j = 0; j < numVTKNodesPerElement; j++) {
668                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);
669                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
670                        }
671                        __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
672                     }
673                }                }
674             }             }
675          } else {          } else {
# Line 528  void Finley_Mesh_saveVTK(const char * fi Line 684  void Finley_Mesh_saveVTK(const char * fi
684             }             }
685          }          }
686          #ifdef PASO_MPI          #ifdef PASO_MPI
687               if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
688             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);
689          #endif              #endif    
690       } else {       } else {
691          if (node_index == NULL) {          if (node_index == NULL) {
692               if (TypeId==Rec9) {
693                  for (i = 0; i < numCells; i++) {
694                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(0, i, NN)]]);
695                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
696                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
697                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
698                            fprintf(fileHandle_p,NEWLINE);
699    
700                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
701                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(1, i, NN)]]);
702                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
703                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
704                            fprintf(fileHandle_p,NEWLINE);
705    
706                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
707                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
708                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
709                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(3, i, NN)]]);
710                            fprintf(fileHandle_p,NEWLINE);
711    
712                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
713                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
714                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(2, i, NN)]]);
715                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
716                            fprintf(fileHandle_p,NEWLINE);
717                  }
718    
719               } else if (TypeId==Hex27) {
720                     for (i = 0; i < numCells; i++) {
721                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 0, i, NN)]]);
722                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
723                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
724                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
725                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
726                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
727                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
728                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
729                            fprintf(fileHandle_p,NEWLINE);
730    
731                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
732                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 1, i, NN)]]);
733                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
734                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
735                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
736                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
737                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
738                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
739                            fprintf(fileHandle_p,NEWLINE);
740    
741                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
742                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
743                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
744                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 3, i, NN)]]);
745                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
746                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
747                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
748                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
749                            fprintf(fileHandle_p,NEWLINE);
750    
751                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
752                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
753                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 2, i, NN)]]);
754                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
755                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
756                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
757                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
758                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
759                            fprintf(fileHandle_p,NEWLINE);
760    
761                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
762                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
763                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
764                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
765                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 4, i, NN)]]);
766                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
767                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
768                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
769                            fprintf(fileHandle_p,NEWLINE);
770    
771                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
772                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
773                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
774                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
775                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
776                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 5, i, NN)]]);
777                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
778                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
779                            fprintf(fileHandle_p,NEWLINE);
780    
781                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
782                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
783                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
784                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
785                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
786                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
787                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
788                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 7, i, NN)]]);
789                            fprintf(fileHandle_p,NEWLINE);
790    
791                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
792                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
793                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
794                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
795                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
796                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
797                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 6, i, NN)]]);
798                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
799                            fprintf(fileHandle_p,NEWLINE);
800                     }
801                  } else {
802             for (i = 0; i < numCells; i++) {             for (i = 0; i < numCells; i++) {
803                for (j = 0; j < numVTKNodesPerElement; j++) {                   for (j = 0; j < numVTKNodesPerElement; j++) {
804                   fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);                      fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);
805                 }                    }
806                fprintf(fileHandle_p,NEWLINE);                   fprintf(fileHandle_p,NEWLINE);
807             }                }
808              }
809          } else {          } else {
810             for (i = 0; i < numCells; i++) {             for (i = 0; i < numCells; i++) {
811                for (j = 0; j < numVTKNodesPerElement; j++) {                for (j = 0; j < numVTKNodesPerElement; j++) {
# Line 548  void Finley_Mesh_saveVTK(const char * fi Line 816  void Finley_Mesh_saveVTK(const char * fi
816          }          }
817    
818       }       }
       
819       /* finalize the connection and start the offset section */       /* finalize the connection and start the offset section */
820       if (mpi_size > 1) {       if (mpi_size > 1) {
821          if( my_mpi_rank == 0) {          if( my_mpi_rank == 0) {
# Line 558  void Finley_Mesh_saveVTK(const char * fi Line 825  void Finley_Mesh_saveVTK(const char * fi
825             #endif             #endif
826          }          }
827       } else {       } else {
828          fprintf(fileHandle_p,tags_End_Conn_and_Start_Offset);          fprintf(fileHandle_p, "%s", tags_End_Conn_and_Start_Offset);
829       }       }
830    
831      /* write the offsets */      /* write the offsets */
# Line 566  void Finley_Mesh_saveVTK(const char * fi Line 833  void Finley_Mesh_saveVTK(const char * fi
833       if ( mpi_size > 1) {       if ( mpi_size > 1) {
834          txt_buffer[0] = '\0';          txt_buffer[0] = '\0';
835          txt_buffer_in_use=0;          txt_buffer_in_use=0;
836          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) {
837             sprintf(tmp_buffer, INT_NEWLINE_FORMAT, i);              sprintf(tmp_buffer, INT_NEWLINE_FORMAT, i);
838             __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);              __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
839           }           }
840           #ifdef PASO_MPI           #ifdef PASO_MPI
841                if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
842              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);
843           #endif               #endif    
844       } else {       } else {
# Line 588  void Finley_Mesh_saveVTK(const char * fi Line 856  void Finley_Mesh_saveVTK(const char * fi
856             #endif             #endif
857          }          }
858      } else {      } else {
859         fprintf(fileHandle_p,tags_End_Offset_and_Start_Type);         fprintf(fileHandle_p, "%s", tags_End_Offset_and_Start_Type);
860      }      }
       
         
861       /* write element type */       /* write element type */
862       sprintf(tmp_buffer, INT_NEWLINE_FORMAT, cellType);       sprintf(tmp_buffer, INT_NEWLINE_FORMAT, cellType);
863       if ( mpi_size > 1) {       if ( mpi_size > 1) {
864          txt_buffer[0] = '\0';          txt_buffer[0] = '\0';
865          txt_buffer_in_use=0;          txt_buffer_in_use=0;
866          for (i=0; i<numCells*numCellFactor; i++) __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);          for (i=numVTKNodesPerElement*(myFirstCell*numCellFactor+1); i<=(myFirstCell+myNumCells)*numVTKNodesPerElement*numCellFactor; i+=numVTKNodesPerElement) {
867              __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
868        }
869           #ifdef PASO_MPI           #ifdef PASO_MPI
870                if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
871              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);
872           #endif               #endif    
873       } else {       } else {
874          for (i=0; i<numCells*numCellFactor; i++) fprintf(fileHandle_p, tmp_buffer);          for (i=0; i<numCells*numCellFactor; i++) fprintf(fileHandle_p, "%s",  tmp_buffer);
875       }       }
876       /* finalize cell information */       /* finalize cell information */
877       if ( mpi_size > 1) {       if ( mpi_size > 1) {
# Line 613  void Finley_Mesh_saveVTK(const char * fi Line 882  void Finley_Mesh_saveVTK(const char * fi
882             #endif             #endif
883          }          }
884      } else {      } else {
885         fprintf(fileHandle_p,tags_End_Type_And_Cells);         fprintf(fileHandle_p, "%s", tags_End_Type_And_Cells);
886      }      }
887   }   }
888    
# Line 670  void Finley_Mesh_saveVTK(const char * fi Line 939  void Finley_Mesh_saveVTK(const char * fi
939             #endif             #endif
940          }          }
941        } else {        } else {
942            fprintf(fileHandle_p,txt_buffer);            fprintf(fileHandle_p, "%s", txt_buffer);
943        }        }
944        /* write the arrays */        /* write the arrays */
945        for (i_data =0 ;i_data<num_data;++i_data) {        for (i_data =0 ;i_data<num_data;++i_data) {
# Line 707  void Finley_Mesh_saveVTK(const char * fi Line 976  void Finley_Mesh_saveVTK(const char * fi
976                      #endif                      #endif
977                   }                   }
978                 } else {                 } else {
979                     fprintf(fileHandle_p,txt_buffer);                     fprintf(fileHandle_p, "%s", txt_buffer);
980                 }                 }
981    
982                 for (i=0; i<numCells; i++) {                 for (i=0; i<numCells; i++) {
983                     if (elements->Owner[i] == my_mpi_rank) {                     if (elements->Owner[i] == my_mpi_rank) {
984                        values = getSampleData(data_pp[i_data], i);                        values = getSampleData(data_pp[i_data], i);
985                        /* averaging over the number of points in the sample */                        for (l=0; l< numCellFactor;++l) {
986                        for (k=0; k<MIN(nComp,NCOMP_MAX); k++) {                           /* averaging over the number of points in the sample */
987                           if (isExpanded(data_pp[i_data])) {                           if (isExpanded(data_pp[i_data])) {
988                             rtmp = 0.;                                for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k]=0;
989                             for (j=0; j<numPointsPerSample; j++) rtmp += values[INDEX2(k,j,nComp)];                                hits=0;
990                             sampleAvg[k] = rtmp/numPointsPerSample;                                for (j=0; j<numPointsPerSample; j++) {
991                          } else {                                   hits_old=hits;
992                             sampleAvg[k] = values[k];                                   if (TypeId==Rec9) {
993                          }                                      switch(l) {
994                        }                                        case 0:
995                        /* 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++;  
996                        * of actual components, pad with zeros                                          break;
997                        */                                        case 1:
998                        /* 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++;  
999                        /* write the data different ways for scalar, vector and tensor */                                          break;
1000                        if (nCompReqd == 1) {                                        case 2:
1001                          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++;  
1002                        } else if (nCompReqd == 3) {                                          break;
1003                          if (shape==1) {                                        case 3:
1004                           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++;  
1005                          } else if (shape==2) {                                          break;
1006                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],0.);                                        }
1007                          } else if (shape==3) {                                   } else if (TypeId==Hex27) {
1008                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2]);                                      switch(l) {
1009                          }                                        case 0:
1010                        } 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++;  
1011                          if (shape==1) {                                          break;
1012                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],0.,0.,                                        case 1:
1013                                                                  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++;  
1014                                            break;
1015                                          case 2:
1016                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.25,0.25)) hits++;  
1017                                            break;
1018                                          case 3:
1019                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.25,0.25)) hits++;  
1020                                            break;
1021                                          case 4:
1022                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.25,0.75,0.25)) hits++;  
1023                                            break;
1024                                          case 5:
1025                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.25,0.75,0.25)) hits++;  
1026                                            break;
1027                                          case 6:
1028                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.75,0.25)) hits++;  
1029                                            break;
1030                                          case 7:
1031                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.75,0.25)) hits++;  
1032                                            break;
1033                                        }
1034                                     } else {
1035                                        hits++;
1036                                     }
1037                                     if (hits_old<hits) for (k=0; k<MIN(nComp,NCOMP_MAX); k++) {
1038                                         sampleAvg[k] += values[INDEX2(k,j,nComp)];
1039                                     }
1040                                  }
1041                                  for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] /=MAX(hits,1);
1042                             } else {
1043                                  for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] = values[k];
1044                             }
1045                             /* if the number of required components is more than the number
1046                             * of actual components, pad with zeros
1047                             */
1048                             /* probably only need to get shape of first element */
1049                             /* write the data different ways for scalar, vector and tensor */
1050                             if (nCompReqd == 1) {
1051                               sprintf(tmp_buffer,FLOAT_SCALAR_FORMAT,sampleAvg[0]);
1052                             } else if (nCompReqd == 3) {
1053                               if (shape==1) {
1054                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],0.,0.);
1055                               } else if (shape==2) {
1056                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],0.);
1057                               } else if (shape==3) {
1058                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2]);
1059                               }
1060                             } else if (nCompReqd == 9) {
1061                               if (shape==1) {
1062                                sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],0.,0.,
1063                                                                       0.,0.,0.,
1064                                                                  0.,0.,0.);                                                                  0.,0.,0.);
1065                          } else if (shape==2) {                             } else if (shape==2) {
1066                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],0.,                              sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],0.,
1067                                                                  sampleAvg[2],sampleAvg[3],0.,                                                                     sampleAvg[2],sampleAvg[3],0.,
1068                                                                  0.,0.,0.);                                                                     0.,0.,0.);
1069                          } else if (shape==3) {                             } else if (shape==3) {
1070                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2],                              sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2],
1071                                                                  sampleAvg[3],sampleAvg[4],sampleAvg[5],                                                                     sampleAvg[3],sampleAvg[4],sampleAvg[5],
1072                                                                  sampleAvg[6],sampleAvg[7],sampleAvg[8]);                                                                     sampleAvg[6],sampleAvg[7],sampleAvg[8]);
1073                               }
1074                             }
1075                             /* this needs a bit mor work!!! */
1076                                if ( mpi_size > 1) {
1077                                  __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
1078                                } else {
1079                                  fprintf(fileHandle_p, "%s", tmp_buffer);
1080                                }
1081                          }                          }
1082                        }                     }
                       if ( mpi_size > 1) {  
                         __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);  
                       } else {  
                         fprintf(fileHandle_p,tmp_buffer);  
                       }  
                   }  
1083                 }                 }
1084                 if ( mpi_size > 1) {                 if ( mpi_size > 1) {
1085                       #ifdef PASO_MPI                       #ifdef PASO_MPI
1086                            if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
1087                          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);
1088                       #endif                           #endif    
1089                       if ( my_mpi_rank == 0) {                       if ( my_mpi_rank == 0) {
# Line 770  void Finley_Mesh_saveVTK(const char * fi Line 1093  void Finley_Mesh_saveVTK(const char * fi
1093                          #endif                          #endif
1094                       }                       }
1095                 } else {                 } else {
1096                     fprintf(fileHandle_p,tag_End_DataArray);                     fprintf(fileHandle_p, "%s", tag_End_DataArray);
1097                 }                 }
1098              }              }
1099           }           }
# Line 783  void Finley_Mesh_saveVTK(const char * fi Line 1106  void Finley_Mesh_saveVTK(const char * fi
1106             #endif             #endif
1107          }          }
1108        } else {        } else {
1109            fprintf(fileHandle_p,tag_End_CellData);            fprintf(fileHandle_p, "%s", tag_End_CellData);
1110        }        }
1111    }    }
1112    /* point data */    /* point data */
# Line 839  void Finley_Mesh_saveVTK(const char * fi Line 1162  void Finley_Mesh_saveVTK(const char * fi
1162             #endif             #endif
1163          }          }
1164        } else {        } else {
1165            fprintf(fileHandle_p,txt_buffer);            fprintf(fileHandle_p, "%s", txt_buffer);
1166        }        }
1167        /* write the arrays */        /* write the arrays */
1168        for (i_data =0 ;i_data<num_data;++i_data) {        for (i_data =0 ;i_data<num_data;++i_data) {
# Line 881  void Finley_Mesh_saveVTK(const char * fi Line 1204  void Finley_Mesh_saveVTK(const char * fi
1204                      #endif                      #endif
1205                   }                   }
1206                 } else {                 } else {
1207                     fprintf(fileHandle_p,txt_buffer);                     fprintf(fileHandle_p, "%s", txt_buffer);
1208                 }                 }
1209                 for (i=0; i<mesh_p->Nodes->numNodes; i++) {                 for (i=0; i<mesh_p->Nodes->numNodes; i++) {
1210                    k=globalNodeIndex[i];                    k=globalNodeIndex[i];
# Line 920  void Finley_Mesh_saveVTK(const char * fi Line 1243  void Finley_Mesh_saveVTK(const char * fi
1243                       if ( mpi_size > 1) {                       if ( mpi_size > 1) {
1244                         __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);                         __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
1245                       } else {                       } else {
1246                         fprintf(fileHandle_p,tmp_buffer);                         fprintf(fileHandle_p, "%s", tmp_buffer);
1247                       }                       }
1248                    }                    }
1249                 }                 }
1250                 if ( mpi_size > 1) {                 if ( mpi_size > 1) {
1251                     #ifdef PASO_MPI                     #ifdef PASO_MPI
1252                         if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
1253                       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);
1254                     #endif                         #endif    
1255                     if ( my_mpi_rank == 0) {                     if ( my_mpi_rank == 0) {
# Line 935  void Finley_Mesh_saveVTK(const char * fi Line 1259  void Finley_Mesh_saveVTK(const char * fi
1259                        #endif                        #endif
1260                     }                     }
1261                 } else {                 } else {
1262                    fprintf(fileHandle_p,tag_End_DataArray);                    fprintf(fileHandle_p, "%s", tag_End_DataArray);
1263                 }                 }
1264              }              }
1265            }            }
# Line 943  void Finley_Mesh_saveVTK(const char * fi Line 1267  void Finley_Mesh_saveVTK(const char * fi
1267          if ( mpi_size > 1) {          if ( mpi_size > 1) {
1268            if ( my_mpi_rank == 0) {            if ( my_mpi_rank == 0) {
1269               #ifdef PASO_MPI               #ifdef PASO_MPI
1270                  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);
1271                  MPI_Wait(&mpi_req,&mpi_status);                  MPI_Wait(&mpi_req,&mpi_status);
1272               #endif               #endif
1273            }            }
1274          } else {          } else {
1275              fprintf(fileHandle_p,tag_End_PointData);              fprintf(fileHandle_p, "%s", tag_End_PointData);
1276          }          }
1277    }    }
1278    if (Finley_noError()) {    if (Finley_noError()) {
# Line 961  void Finley_Mesh_saveVTK(const char * fi Line 1285  void Finley_Mesh_saveVTK(const char * fi
1285                 MPI_Info_free(&mpi_info);                 MPI_Info_free(&mpi_info);
1286                 #undef MPIO_HINTS                 #undef MPIO_HINTS
1287               #endif               #endif
              MPI_File_close(&mpi_fileHandle_p);  
1288            #endif            #endif
1289          }          }
1290            #ifdef PASO_MPI
1291               MPI_File_close(&mpi_fileHandle_p);
1292            #endif
1293       } else {       } else {
1294           fprintf(fileHandle_p,footer);           fprintf(fileHandle_p, "%s", footer);
1295           fclose(fileHandle_p);           fclose(fileHandle_p);
1296       }       }
1297    }    }
1298    TMPMEMFREE(isCellCentered);    TMPMEMFREE(isCellCentered);
1299    TMPMEMFREE(txt_buffer);    TMPMEMFREE(txt_buffer);
1300    return;    return;
1301    #else
1302      /* Don't kill the job if saveVTK() doesn't work */
1303      fprintf(stderr, "\n\nsaveVTK warning: VTK is not available\n\n\n");
1304    #endif
1305  }  }

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

  ViewVC Help
Powered by ViewVC 1.1.26