/[escript]/branches/arrayview_from_1695_trunk/finley/src/Mesh_saveVTK.c
ViewVC logotype

Diff of /branches/arrayview_from_1695_trunk/finley/src/Mesh_saveVTK.c

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

revision 1780 by jfenwick, Mon Aug 11 03:33:40 2008 UTC revision 1781 by jfenwick, Thu Sep 11 05:03:14 2008 UTC
# Line 43  Line 43 
43    strcpy(&dest[dest_in_use], chunk); \    strcpy(&dest[dest_in_use], chunk); \
44    dest_in_use+=strlen(chunk); \    dest_in_use+=strlen(chunk); \
45  }  }
46    #define INSIDE_1D(_X_,_C_,_R_) ( ABS((_X_)-(_C_)) <= (_R_) )
47    #define INSIDE_2D(_X_,_Y_,_CX_,_CY_,_R_) ( INSIDE_1D(_X_,_CX_,_R_) &&  INSIDE_1D(_Y_,_CY_,_R_))
48    #define INSIDE_3D(_X_,_Y_,_Z_,_CX_,_CY_,_CZ_,_R_) ( INSIDE_1D(_X_,_CX_,_R_) &&  INSIDE_1D(_Y_,_CY_,_R_) && INSIDE_1D(_Z_,_CZ_,_R_) )
49    
50  void Finley_Mesh_saveVTK(const char * filename_p,  void Finley_Mesh_saveVTK(const char * filename_p,
51                           Finley_Mesh *mesh_p,                           Finley_Mesh *mesh_p,
# Line 50  void Finley_Mesh_saveVTK(const char * fi Line 53  void Finley_Mesh_saveVTK(const char * fi
53                           char* *names_p,                           char* *names_p,
54                           escriptDataC* *data_pp)                           escriptDataC* *data_pp)
55  {  {
56    #ifdef USE_VTK
57    char error_msg[LenErrorMsg_MAX], *txt_buffer=NULL, tmp_buffer[LEN_TMP_BUFFER];    char error_msg[LenErrorMsg_MAX], *txt_buffer=NULL, tmp_buffer[LEN_TMP_BUFFER];
58    double sampleAvg[NCOMP_MAX], *values, rtmp;    double sampleAvg[NCOMP_MAX], *values, rtmp, *QuadNodes;
59    size_t txt_buffer_in_use;    size_t txt_buffer_in_use;
60    dim_t len_txt_buffer,  max_len_names;    dim_t len_txt_buffer,  max_len_names;
61    FILE * fileHandle_p = NULL;    FILE * fileHandle_p = NULL;
62    int mpi_size, i, j, cellType;    int mpi_size, i, j, l, cellType;
63    dim_t i_data;    dim_t i_data, hits, hits_old;
64    dim_t nDim, globalNumPoints, numCells, globalNumCells, numVTKNodesPerElement;    dim_t nDim, globalNumPoints, numCells, globalNumCells, numVTKNodesPerElement;
65    dim_t myNumPoints, numPointsPerSample, rank, nComp, nCompReqd;    dim_t myNumPoints, numPointsPerSample, rank, nComp, nCompReqd;
66    dim_t shape, NN, numCellFactor, myNumCells, max_name_len;    dim_t shape, NN, numCellFactor, myNumCells, max_name_len;
67    bool_t *isCellCentered=NULL,write_celldata=FALSE,write_pointdata=FALSE;    bool_t *isCellCentered=NULL,write_celldata=FALSE,write_pointdata=FALSE, reduced_elements=FALSE;
68    bool_t set_scalar=FALSE,set_vector=FALSE, set_tensor=FALSE;    bool_t set_scalar=FALSE,set_vector=FALSE, set_tensor=FALSE;
69    index_t myFirstNode, myLastNode, *globalNodeIndex, k, *node_index, myFirstCell;    index_t myFirstNode, myLastNode, *globalNodeIndex, k, *node_index, myFirstCell;
70    #ifdef PASO_MPI    #ifdef PASO_MPI
# Line 160  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 183  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 192  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 209  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 218  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 246  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 285  void Finley_Mesh_saveVTK(const char * fi Line 294  void Finley_Mesh_saveVTK(const char * fi
294         NN = elements->numNodes;         NN = elements->numNodes;
295         if (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 332  void Finley_Mesh_saveVTK(const char * fi Line 351  void Finley_Mesh_saveVTK(const char * fi
351            numVTKNodesPerElement = 4;            numVTKNodesPerElement = 4;
352            strcpy(elemTypeStr, "VTK_QUAD");            strcpy(elemTypeStr, "VTK_QUAD");
353            break;            break;
354    
355            case Rec9:
356              numCellFactor=4;
357              cellType = VTK_QUAD;
358              numVTKNodesPerElement = 4;
359              strcpy(elemTypeStr, "VTK_QUAD");
360              break;
361                
362          case Tet4:          case Tet4:
363            numCellFactor=1;            numCellFactor=1;
# Line 392  void Finley_Mesh_saveVTK(const char * fi Line 418  void Finley_Mesh_saveVTK(const char * fi
418            numVTKNodesPerElement = 20;            numVTKNodesPerElement = 20;
419            strcpy(elemTypeStr, "VTK_QUADRATIC_HEXAHEDRON");            strcpy(elemTypeStr, "VTK_QUADRATIC_HEXAHEDRON");
420            break;            break;
421    
422            case Hex27:
423              numCellFactor=8;
424              cellType = VTK_HEXAHEDRON;
425              numVTKNodesPerElement = 8;
426              strcpy(elemTypeStr, "VTK_HEXAHEDRON");
427              break;
428                
429          default:          default:
430            sprintf(error_msg, "saveVTK: Element type %s is not supported by VTK",elements->ReferenceElement->Type->Name);            sprintf(error_msg, "saveVTK: Element type %s is not supported by VTK",elements->ReferenceElement->Type->Name);
# Line 463  void Finley_Mesh_saveVTK(const char * fi Line 496  void Finley_Mesh_saveVTK(const char * fi
496        
497           }           }
498           #ifdef PASO_MPI           #ifdef PASO_MPI
499                if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
500              MPI_File_write_ordered(mpi_fileHandle_p, txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);              MPI_File_write_ordered(mpi_fileHandle_p, txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
501           #endif               #endif    
502        } else {        } else {
# Line 506  void Finley_Mesh_saveVTK(const char * fi Line 540  void Finley_Mesh_saveVTK(const char * fi
540          node_index=elements->ReferenceElement->Type->linearNodes;          node_index=elements->ReferenceElement->Type->linearNodes;
541       } else if (VTK_QUADRATIC_HEXAHEDRON==cellType) {       } else if (VTK_QUADRATIC_HEXAHEDRON==cellType) {
542          node_index=VTK_QUADRATIC_HEXAHEDRON_INDEX;          node_index=VTK_QUADRATIC_HEXAHEDRON_INDEX;
543       } else if (numVTKNodesPerElement!=NN) {       } else if ( (numVTKNodesPerElement!=NN) && (TypeId!=Rec9) && (TypeId!=Hex27) ) {
544          node_index=elements->ReferenceElement->Type->geoNodes;          node_index=elements->ReferenceElement->Type->geoNodes;
545       } else {       } else {
546          node_index=NULL;          node_index=NULL;
# Line 516  void Finley_Mesh_saveVTK(const char * fi Line 550  void Finley_Mesh_saveVTK(const char * fi
550          txt_buffer[0] = '\0';          txt_buffer[0] = '\0';
551          txt_buffer_in_use=0;          txt_buffer_in_use=0;
552          if (node_index == NULL) {          if (node_index == NULL) {
553             for (i = 0; i < numCells; i++) {             if (TypeId==Rec9) {
554                if (elements->Owner[i] == my_mpi_rank) {                for (i = 0; i < numCells; i++) {
555                   for (j = 0; j < numVTKNodesPerElement; j++) {                   if (elements->Owner[i] == my_mpi_rank) {
556                       sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);                          sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(0, i, NN)]]);
557                       __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)                          sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
558                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
559                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
560                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
561                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
562    
563                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
564                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(1, i, NN)]]);
565                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
566                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
567                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
568                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
569    
570                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
571                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
572                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
573                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(3, i, NN)]]);
574                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
575                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
576    
577                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
578                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
579                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(2, i, NN)]]);
580                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
581                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
582                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
583                    }
584                  }
585               } else if (TypeId==Hex27) {
586                  for (i = 0; i < numCells; i++) {
587                     if (elements->Owner[i] == my_mpi_rank) {
588                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 0, i, NN)]]);
589                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
590                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
591                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
592                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
593                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
594                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
595                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
596                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
597                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
598    
599                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
600                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 1, i, NN)]]);
601                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
602                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
603                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
604                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
605                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
606                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
607                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
608                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
609    
610                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
611                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
612                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
613                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 3, i, NN)]]);
614                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
615                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
616                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
617                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
618                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
619                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
620    
621                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
622                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
623                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 2, i, NN)]]);
624                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
625                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
626                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
627                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
628                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
629                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
630                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
631    
632                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
633                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
634                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
635                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
636                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 4, i, NN)]]);
637                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
638                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
639                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
640                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
641                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
642    
643                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
644                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
645                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
646                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
647                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
648                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 5, i, NN)]]);
649                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
650                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
651                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
652                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
653    
654                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
655                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
656                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
657                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
658                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
659                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
660                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
661                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 7, i, NN)]]);
662                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
663                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
664    
665                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
666                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
667                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
668                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
669                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
670                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
671                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 6, i, NN)]]);
672                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
673                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
674                            __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
675                   }                   }
676                   __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)                }
677               } else {
678                  for (i = 0; i < numCells; i++) {
679                     if (elements->Owner[i] == my_mpi_rank) {
680                        for (j = 0; j < numVTKNodesPerElement; j++) {
681                            sprintf(tmp_buffer,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);
682                            __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use)
683                        }
684                        __STRCAT(txt_buffer,NEWLINE,txt_buffer_in_use)
685                     }
686                }                }
687             }             }
688          } else {          } else {
# Line 537  void Finley_Mesh_saveVTK(const char * fi Line 697  void Finley_Mesh_saveVTK(const char * fi
697             }             }
698          }          }
699          #ifdef PASO_MPI          #ifdef PASO_MPI
700               if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
701             MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);             MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
702          #endif              #endif    
703       } else {       } else {
704          if (node_index == NULL) {          if (node_index == NULL) {
705               if (TypeId==Rec9) {
706                  for (i = 0; i < numCells; i++) {
707                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(0, i, NN)]]);
708                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
709                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
710                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
711                            fprintf(fileHandle_p,NEWLINE);
712    
713                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
714                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(1, i, NN)]]);
715                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
716                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
717                            fprintf(fileHandle_p,NEWLINE);
718    
719                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
720                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
721                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
722                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(3, i, NN)]]);
723                            fprintf(fileHandle_p,NEWLINE);
724    
725                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
726                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
727                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(2, i, NN)]]);
728                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
729                            fprintf(fileHandle_p,NEWLINE);
730                  }
731    
732               } else if (TypeId==Hex27) {
733                     for (i = 0; i < numCells; i++) {
734                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 0, i, NN)]]);
735                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
736                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
737                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
738                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
739                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
740                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
741                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
742                            fprintf(fileHandle_p,NEWLINE);
743    
744                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
745                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 1, i, NN)]]);
746                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
747                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
748                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
749                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
750                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
751                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
752                            fprintf(fileHandle_p,NEWLINE);
753    
754                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
755                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
756                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
757                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 3, i, NN)]]);
758                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
759                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
760                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
761                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
762                            fprintf(fileHandle_p,NEWLINE);
763    
764                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
765                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
766                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 2, i, NN)]]);
767                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
768                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
769                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
770                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
771                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
772                            fprintf(fileHandle_p,NEWLINE);
773    
774                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
775                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
776                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
777                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
778                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 4, i, NN)]]);
779                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
780                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
781                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
782                            fprintf(fileHandle_p,NEWLINE);
783    
784                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
785                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
786                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
787                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
788                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
789                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 5, i, NN)]]);
790                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
791                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
792                            fprintf(fileHandle_p,NEWLINE);
793    
794                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
795                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
796                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
797                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
798                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
799                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
800                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
801                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 7, i, NN)]]);
802                            fprintf(fileHandle_p,NEWLINE);
803    
804                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
805                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
806                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
807                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
808                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
809                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
810                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 6, i, NN)]]);
811                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
812                            fprintf(fileHandle_p,NEWLINE);
813                     }
814                  } else {
815             for (i = 0; i < numCells; i++) {             for (i = 0; i < numCells; i++) {
816                for (j = 0; j < numVTKNodesPerElement; j++) {                   for (j = 0; j < numVTKNodesPerElement; j++) {
817                   fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);                      fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);
818                 }                    }
819                fprintf(fileHandle_p,NEWLINE);                   fprintf(fileHandle_p,NEWLINE);
820             }                }
821              }
822          } else {          } else {
823             for (i = 0; i < numCells; i++) {             for (i = 0; i < numCells; i++) {
824                for (j = 0; j < numVTKNodesPerElement; j++) {                for (j = 0; j < numVTKNodesPerElement; j++) {
# Line 557  void Finley_Mesh_saveVTK(const char * fi Line 829  void Finley_Mesh_saveVTK(const char * fi
829          }          }
830    
831       }       }
       
832       /* finalize the connection and start the offset section */       /* finalize the connection and start the offset section */
833       if (mpi_size > 1) {       if (mpi_size > 1) {
834          if( my_mpi_rank == 0) {          if( my_mpi_rank == 0) {
# Line 580  void Finley_Mesh_saveVTK(const char * fi Line 851  void Finley_Mesh_saveVTK(const char * fi
851              __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);              __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
852           }           }
853           #ifdef PASO_MPI           #ifdef PASO_MPI
854                if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
855              MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);              MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
856           #endif               #endif    
857       } else {       } else {
# Line 606  void Finley_Mesh_saveVTK(const char * fi Line 878  void Finley_Mesh_saveVTK(const char * fi
878          txt_buffer_in_use=0;          txt_buffer_in_use=0;
879          for (i=0; i<numCells*numCellFactor; i++) __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);          for (i=0; i<numCells*numCellFactor; i++) __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
880           #ifdef PASO_MPI           #ifdef PASO_MPI
881                if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
882              MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);              MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
883           #endif               #endif    
884       } else {       } else {
# Line 716  void Finley_Mesh_saveVTK(const char * fi Line 989  void Finley_Mesh_saveVTK(const char * fi
989                 } else {                 } else {
990                     fprintf(fileHandle_p,txt_buffer);                     fprintf(fileHandle_p,txt_buffer);
991                 }                 }
992    
993                 for (i=0; i<numCells; i++) {                 for (i=0; i<numCells; i++) {
994                     if (elements->Owner[i] == my_mpi_rank) {                     if (elements->Owner[i] == my_mpi_rank) {
995                        values = getSampleData(data_pp[i_data], i);                        values = getSampleData(data_pp[i_data], i);
996                        /* averaging over the number of points in the sample */                        for (l=0; l< numCellFactor;++l) {
997                        for (k=0; k<MIN(nComp,NCOMP_MAX); k++) {                           /* averaging over the number of points in the sample */
998                           if (isExpanded(data_pp[i_data])) {                           if (isExpanded(data_pp[i_data])) {
999                             rtmp = 0.;                                for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k]=0;
1000                             for (j=0; j<numPointsPerSample; j++) rtmp += values[INDEX2(k,j,nComp)];                                hits=0;
1001                             sampleAvg[k] = rtmp/numPointsPerSample;                                for (j=0; j<numPointsPerSample; j++) {
1002                          } else {                                   hits_old=hits;
1003                             sampleAvg[k] = values[k];                                   if (TypeId==Rec9) {
1004                          }                                      switch(l) {
1005                        }                                        case 0:
1006                        /* if the number of mpi_required components is more than the number                                          if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.25,0.25,0.25)) hits++;  
1007                        * of actual components, pad with zeros                                          break;
1008                        */                                        case 1:
1009                        /* probably only need to get shape of first element */                                          if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.75,0.25,0.25)) hits++;  
1010                        /* write the data different ways for scalar, vector and tensor */                                          break;
1011                        if (nCompReqd == 1) {                                        case 2:
1012                          sprintf(tmp_buffer,FLOAT_SCALAR_FORMAT,sampleAvg[0]);                                          if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.25,0.75,0.25)) hits++;  
1013                        } else if (nCompReqd == 3) {                                          break;
1014                          if (shape==1) {                                        case 3:
1015                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],0.,0.);                                          if (INSIDE_2D(QuadNodes[2*j],QuadNodes[2*j+1],0.75,0.75,0.25)) hits++;  
1016                          } else if (shape==2) {                                          break;
1017                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],0.);                                        }
1018                          } else if (shape==3) {                                   } else if (TypeId==Hex27) {
1019                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2]);                                      switch(l) {
1020                          }                                        case 0:
1021                        } else if (nCompReqd == 9) {                                          if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.25,0.25,0.25)) hits++;  
1022                          if (shape==1) {                                          break;
1023                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],0.,0.,                                        case 1:
1024                                                                  0.,0.,0.,                                          if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.25,0.25,0.25)) hits++;  
1025                                            break;
1026                                          case 2:
1027                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.25,0.25)) hits++;  
1028                                            break;
1029                                          case 3:
1030                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.25,0.25)) hits++;  
1031                                            break;
1032                                          case 4:
1033                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.25,0.75,0.25)) hits++;  
1034                                            break;
1035                                          case 5:
1036                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.25,0.75,0.25)) hits++;  
1037                                            break;
1038                                          case 6:
1039                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.75,0.25)) hits++;  
1040                                            break;
1041                                          case 7:
1042                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.75,0.25)) hits++;  
1043                                            break;
1044                                        }
1045                                     } else {
1046                                        hits++;
1047                                     }
1048                                     if (hits_old<hits) for (k=0; k<MIN(nComp,NCOMP_MAX); k++) {
1049                                         sampleAvg[k] += values[INDEX2(k,j,nComp)];
1050                                     }
1051                                  }
1052                                  for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] /=MAX(hits,1);
1053                             } else {
1054                                  for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] = values[k];
1055                             }
1056                             /* if the number of required components is more than the number
1057                             * of actual components, pad with zeros
1058                             */
1059                             /* probably only need to get shape of first element */
1060                             /* write the data different ways for scalar, vector and tensor */
1061                             if (nCompReqd == 1) {
1062                               sprintf(tmp_buffer,FLOAT_SCALAR_FORMAT,sampleAvg[0]);
1063                             } else if (nCompReqd == 3) {
1064                               if (shape==1) {
1065                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],0.,0.);
1066                               } else if (shape==2) {
1067                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],0.);
1068                               } else if (shape==3) {
1069                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2]);
1070                               }
1071                             } else if (nCompReqd == 9) {
1072                               if (shape==1) {
1073                                sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],0.,0.,
1074                                                                       0.,0.,0.,
1075                                                                  0.,0.,0.);                                                                  0.,0.,0.);
1076                          } else if (shape==2) {                             } else if (shape==2) {
1077                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],0.,                              sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],0.,
1078                                                                  sampleAvg[2],sampleAvg[3],0.,                                                                     sampleAvg[2],sampleAvg[3],0.,
1079                                                                  0.,0.,0.);                                                                     0.,0.,0.);
1080                          } else if (shape==3) {                             } else if (shape==3) {
1081                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2],                              sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2],
1082                                                                  sampleAvg[3],sampleAvg[4],sampleAvg[5],                                                                     sampleAvg[3],sampleAvg[4],sampleAvg[5],
1083                                                                  sampleAvg[6],sampleAvg[7],sampleAvg[8]);                                                                     sampleAvg[6],sampleAvg[7],sampleAvg[8]);
1084                               }
1085                             }
1086                             /* this needs a bit mor work!!! */
1087                                if ( mpi_size > 1) {
1088                                  __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
1089                                } else {
1090                                  fprintf(fileHandle_p,tmp_buffer);
1091                                }
1092                          }                          }
1093                        }                     }
                       if ( mpi_size > 1) {  
                         __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);  
                       } else {  
                         fprintf(fileHandle_p,tmp_buffer);  
                       }  
                   }  
1094                 }                 }
1095                 if ( mpi_size > 1) {                 if ( mpi_size > 1) {
1096                       #ifdef PASO_MPI                       #ifdef PASO_MPI
1097                            if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
1098                          MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);                          MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
1099                       #endif                           #endif    
1100                       if ( my_mpi_rank == 0) {                       if ( my_mpi_rank == 0) {
# Line 933  void Finley_Mesh_saveVTK(const char * fi Line 1260  void Finley_Mesh_saveVTK(const char * fi
1260                 }                 }
1261                 if ( mpi_size > 1) {                 if ( mpi_size > 1) {
1262                     #ifdef PASO_MPI                     #ifdef PASO_MPI
1263                         if (txt_buffer_in_use==0) { strcpy(txt_buffer, " "); txt_buffer_in_use = 1; } /* avoid zero-length writes */
1264                       MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);                       MPI_File_write_ordered(mpi_fileHandle_p,txt_buffer,txt_buffer_in_use, MPI_CHAR, &mpi_status);
1265                     #endif                         #endif    
1266                     if ( my_mpi_rank == 0) {                     if ( my_mpi_rank == 0) {
# Line 981  void Finley_Mesh_saveVTK(const char * fi Line 1309  void Finley_Mesh_saveVTK(const char * fi
1309    TMPMEMFREE(isCellCentered);    TMPMEMFREE(isCellCentered);
1310    TMPMEMFREE(txt_buffer);    TMPMEMFREE(txt_buffer);
1311    return;    return;
1312    #else
1313      /* Don't kill the job if saveVTK() doesn't work */
1314      fprintf(stderr, "\n\nsaveVTK warning: VTK is not available\n\n\n");
1315    #endif
1316  }  }

Legend:
Removed from v.1780  
changed lines
  Added in v.1781

  ViewVC Help
Powered by ViewVC 1.1.26