/[escript]/branches/domexper/dudley/src/Mesh_saveVTK.c
ViewVC logotype

Diff of /branches/domexper/dudley/src/Mesh_saveVTK.c

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

revision 1740 by ksteube, Thu Aug 14 05:56:40 2008 UTC revision 1741 by gross, Mon Sep 1 04:06:41 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 52  void Finley_Mesh_saveVTK(const char * fi Line 55  void Finley_Mesh_saveVTK(const char * fi
55  {  {
56  #ifdef USE_VTK  #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 161  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 184  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 193  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 210  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 219  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 247  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 286  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 333  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 393  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 507  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 517  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 542  void Finley_Mesh_saveVTK(const char * fi Line 700  void Finley_Mesh_saveVTK(const char * fi
700          #endif              #endif    
701       } else {       } else {
702          if (node_index == NULL) {          if (node_index == NULL) {
703               if (TypeId==Rec9) {
704                  for (i = 0; i < numCells; i++) {
705                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(0, i, NN)]]);
706                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
707                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
708                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
709                            fprintf(fileHandle_p,NEWLINE);
710    
711                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(4, i, NN)]]);
712                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(1, i, NN)]]);
713                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
714                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
715                            fprintf(fileHandle_p,NEWLINE);
716    
717                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(7, i, NN)]]);
718                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
719                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
720                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(3, i, NN)]]);
721                            fprintf(fileHandle_p,NEWLINE);
722    
723                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(8, i, NN)]]);
724                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(5, i, NN)]]);
725                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(2, i, NN)]]);
726                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(6, i, NN)]]);
727                            fprintf(fileHandle_p,NEWLINE);
728                  }
729    
730               } else if (TypeId==Hex27) {
731                     for (i = 0; i < numCells; i++) {
732                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 0, i, NN)]]);
733                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
734                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
735                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
736                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
737                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
738                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
739                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
740                            fprintf(fileHandle_p,NEWLINE);
741    
742                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 8, i, NN)]]);
743                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 1, i, NN)]]);
744                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
745                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
746                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
747                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
748                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
749                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
750                            fprintf(fileHandle_p,NEWLINE);
751    
752                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(11, i, NN)]]);
753                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
754                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
755                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 3, i, NN)]]);
756                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
757                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
758                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
759                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
760                            fprintf(fileHandle_p,NEWLINE);
761    
762                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(20, i, NN)]]);
763                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 9, i, NN)]]);
764                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 2, i, NN)]]);
765                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(10, i, NN)]]);
766                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
767                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
768                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
769                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
770                            fprintf(fileHandle_p,NEWLINE);
771    
772                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(12, i, NN)]]);
773                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
774                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
775                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
776                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 4, i, NN)]]);
777                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
778                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
779                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
780                            fprintf(fileHandle_p,NEWLINE);
781    
782                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(21, i, NN)]]);
783                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(13, i, NN)]]);
784                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
785                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
786                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(16, i, NN)]]);
787                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 5, i, NN)]]);
788                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
789                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
790                            fprintf(fileHandle_p,NEWLINE);
791    
792                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(24, i, NN)]]);
793                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
794                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
795                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(15, i, NN)]]);
796                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(19, i, NN)]]);
797                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
798                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
799                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 7, i, NN)]]);
800                            fprintf(fileHandle_p,NEWLINE);
801    
802                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(26, i, NN)]]);
803                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(22, i, NN)]]);
804                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(14, i, NN)]]);
805                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(23, i, NN)]]);
806                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(25, i, NN)]]);
807                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(17, i, NN)]]);
808                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2( 6, i, NN)]]);
809                            fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(18, i, NN)]]);
810                            fprintf(fileHandle_p,NEWLINE);
811                     }
812                  } else {
813             for (i = 0; i < numCells; i++) {             for (i = 0; i < numCells; i++) {
814                for (j = 0; j < numVTKNodesPerElement; j++) {                   for (j = 0; j < numVTKNodesPerElement; j++) {
815                   fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);                      fprintf(fileHandle_p,INT_FORMAT,globalNodeIndex[elements->Nodes[INDEX2(j, i, NN)]]);
816                 }                    }
817                fprintf(fileHandle_p,NEWLINE);                   fprintf(fileHandle_p,NEWLINE);
818             }                }
819              }
820          } else {          } else {
821             for (i = 0; i < numCells; i++) {             for (i = 0; i < numCells; i++) {
822                for (j = 0; j < numVTKNodesPerElement; j++) {                for (j = 0; j < numVTKNodesPerElement; j++) {
# Line 558  void Finley_Mesh_saveVTK(const char * fi Line 827  void Finley_Mesh_saveVTK(const char * fi
827          }          }
828    
829       }       }
       
830       /* finalize the connection and start the offset section */       /* finalize the connection and start the offset section */
831       if (mpi_size > 1) {       if (mpi_size > 1) {
832          if( my_mpi_rank == 0) {          if( my_mpi_rank == 0) {
# Line 717  void Finley_Mesh_saveVTK(const char * fi Line 985  void Finley_Mesh_saveVTK(const char * fi
985                 } else {                 } else {
986                     fprintf(fileHandle_p,txt_buffer);                     fprintf(fileHandle_p,txt_buffer);
987                 }                 }
988    
989                 for (i=0; i<numCells; i++) {                 for (i=0; i<numCells; i++) {
990                     if (elements->Owner[i] == my_mpi_rank) {                     if (elements->Owner[i] == my_mpi_rank) {
991                        values = getSampleData(data_pp[i_data], i);                        values = getSampleData(data_pp[i_data], i);
992                        /* averaging over the number of points in the sample */                        for (l=0; l< numCellFactor;++l) {
993                        for (k=0; k<MIN(nComp,NCOMP_MAX); k++) {                           /* averaging over the number of points in the sample */
994                           if (isExpanded(data_pp[i_data])) {                           if (isExpanded(data_pp[i_data])) {
995                             rtmp = 0.;                                for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k]=0;
996                             for (j=0; j<numPointsPerSample; j++) rtmp += values[INDEX2(k,j,nComp)];                                hits=0;
997                             sampleAvg[k] = rtmp/numPointsPerSample;                                for (j=0; j<numPointsPerSample; j++) {
998                          } else {                                   hits_old=hits;
999                             sampleAvg[k] = values[k];                                   if (TypeId==Rec9) {
1000                          }                                      switch(l) {
1001                        }                                        case 0:
1002                        /* 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++;  
1003                        * of actual components, pad with zeros                                          break;
1004                        */                                        case 1:
1005                        /* 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++;  
1006                        /* write the data different ways for scalar, vector and tensor */                                          break;
1007                        if (nCompReqd == 1) {                                        case 2:
1008                          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++;  
1009                        } else if (nCompReqd == 3) {                                          break;
1010                          if (shape==1) {                                        case 3:
1011                           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++;  
1012                          } else if (shape==2) {                                          break;
1013                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],0.);                                        }
1014                          } else if (shape==3) {                                   } else if (TypeId==Hex27) {
1015                           sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2]);                                      switch(l) {
1016                          }                                        case 0:
1017                        } 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++;  
1018                          if (shape==1) {                                          break;
1019                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],0.,0.,                                        case 1:
1020                                                                  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++;  
1021                                                                  0.,0.,0.);                                          break;
1022                          } else if (shape==2) {                                        case 2:
1023                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],0.,                                          if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.25,0.25)) hits++;  
1024                                                                  sampleAvg[2],sampleAvg[3],0.,                                          break;
1025                                          case 3:
1026                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.25,0.25)) hits++;  
1027                                            break;
1028                                          case 4:
1029                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.25,0.75,0.25)) hits++;  
1030                                            break;
1031                                          case 5:
1032                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.25,0.75,0.25)) hits++;  
1033                                            break;
1034                                          case 6:
1035                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.25,0.75,0.75,0.25)) hits++;  
1036                                            break;
1037                                          case 7:
1038                                            if (INSIDE_3D(QuadNodes[3*j],QuadNodes[3*j+1],QuadNodes[3*j+2],0.75,0.75,0.75,0.25)) hits++;  
1039                                            break;
1040                                        }
1041                                     } else {
1042                                        hits++;
1043                                     }
1044                                     if (hits_old<hits) for (k=0; k<MIN(nComp,NCOMP_MAX); k++) {
1045                                         sampleAvg[k] += values[INDEX2(k,j,nComp)];
1046                                     }
1047                                  }
1048                                  for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] /=MAX(hits,1);
1049                             } else {
1050                                  for (k=0; k<MIN(nComp,NCOMP_MAX); k++) sampleAvg[k] = values[k];
1051                             }
1052                             /* if the number of required components is more than the number
1053                             * of actual components, pad with zeros
1054                             */
1055                             /* probably only need to get shape of first element */
1056                             /* write the data different ways for scalar, vector and tensor */
1057                             if (nCompReqd == 1) {
1058                               sprintf(tmp_buffer,FLOAT_SCALAR_FORMAT,sampleAvg[0]);
1059                             } else if (nCompReqd == 3) {
1060                               if (shape==1) {
1061                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],0.,0.);
1062                               } else if (shape==2) {
1063                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],0.);
1064                               } else if (shape==3) {
1065                                sprintf(tmp_buffer,FLOAT_VECTOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2]);
1066                               }
1067                             } else if (nCompReqd == 9) {
1068                               if (shape==1) {
1069                                sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],0.,0.,
1070                                                                       0.,0.,0.,
1071                                                                  0.,0.,0.);                                                                  0.,0.,0.);
1072                          } else if (shape==3) {                             } else if (shape==2) {
1073                           sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2],                              sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],0.,
1074                                                                  sampleAvg[3],sampleAvg[4],sampleAvg[5],                                                                     sampleAvg[2],sampleAvg[3],0.,
1075                                                                  sampleAvg[6],sampleAvg[7],sampleAvg[8]);                                                                     0.,0.,0.);
1076                               } else if (shape==3) {
1077                                sprintf(tmp_buffer,FLOAT_TENSOR_FORMAT,sampleAvg[0],sampleAvg[1],sampleAvg[2],
1078                                                                       sampleAvg[3],sampleAvg[4],sampleAvg[5],
1079                                                                       sampleAvg[6],sampleAvg[7],sampleAvg[8]);
1080                               }
1081                             }
1082                             /* this needs a bit mor work!!! */
1083                                if ( mpi_size > 1) {
1084                                  __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);
1085                                } else {
1086                                  fprintf(fileHandle_p,tmp_buffer);
1087                                }
1088                          }                          }
1089                        }                     }
                       if ( mpi_size > 1) {  
                         __STRCAT(txt_buffer,tmp_buffer,txt_buffer_in_use);  
                       } else {  
                         fprintf(fileHandle_p,tmp_buffer);  
                       }  
                   }  
1090                 }                 }
1091                 if ( mpi_size > 1) {                 if ( mpi_size > 1) {
1092                       #ifdef PASO_MPI                       #ifdef PASO_MPI

Legend:
Removed from v.1740  
changed lines
  Added in v.1741

  ViewVC Help
Powered by ViewVC 1.1.26