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

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

  ViewVC Help
Powered by ViewVC 1.1.26