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

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

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

revision 2548 by jfenwick, Mon Jul 20 06:20:06 2009 UTC revision 3259 by jfenwick, Mon Oct 11 01:48:14 2010 UTC
# Line 1  Line 1 
1    
2  /*******************************************************  /*******************************************************
3  *  *
4  * Copyright (c) 2003-2009 by University of Queensland  * Copyright (c) 2003-2010 by University of Queensland
5  * Earth Systems Science Computational Center (ESSCC)  * Earth Systems Science Computational Center (ESSCC)
6  * http://www.uq.edu.au/esscc  * http://www.uq.edu.au/esscc
7  *  *
# Line 22  Line 22 
22  #include "paso/PasoUtil.h"  #include "paso/PasoUtil.h"
23    
24  #define INT_FORMAT "%d "  #define INT_FORMAT "%d "
25  #define LEN_INT_FORMAT (unsigned int)(9+1)  #define LEN_INT_FORMAT (unsigned int)(9+2)
26  #define INT_NEWLINE_FORMAT "%d\n"  #define INT_NEWLINE_FORMAT "%d\n"
27  #define SCALAR_FORMAT "%12.6e\n"  #define SCALAR_FORMAT "%12.6e\n"
28  #define VECTOR_FORMAT "%12.6e %12.6e %12.6e\n"  #define VECTOR_FORMAT "%12.6e %12.6e %12.6e\n"
29  #define TENSOR_FORMAT "%12.6e %12.6e %12.6e %12.6e %12.6e %12.6e %12.6e %12.6e %12.6e\n"  #define TENSOR_FORMAT "%12.6e %12.6e %12.6e %12.6e %12.6e %12.6e %12.6e %12.6e %12.6e\n"
30  #define LEN_TENSOR_FORMAT (unsigned int)(9*(12+1)+1)  /* strlen("-1.234567e+789 ") == 15 */
31    #define LEN_TENSOR_FORMAT (unsigned int)(9*15+2)
32  #define NEWLINE "\n"  #define NEWLINE "\n"
33  #define LEN_TMP_BUFFER LEN_TENSOR_FORMAT+(MAX_numNodes*LEN_INT_FORMAT+1)+2  #define LEN_TMP_BUFFER LEN_TENSOR_FORMAT+(MAX_numNodes*LEN_INT_FORMAT+1)+2
34  #define NCOMP_MAX (unsigned int)9  #define NCOMP_MAX (unsigned int)9
# Line 38  do {\ Line 39  do {\
39      dest_in_use += strlen(chunk);\      dest_in_use += strlen(chunk);\
40  } while(0)  } while(0)
41    
42  #ifdef PASO_MPI  #ifdef ESYS_MPI
43  /* writes buffer to file catching the empty buffer case which causes problems  /* writes buffer to file catching the empty buffer case which causes problems
44   * with some MPI versions */   * with some MPI versions */
45  #define MPI_WRITE_ORDERED(BUF) \  #define MPI_WRITE_ORDERED(BUF) \
# Line 82  void create_MPIInfo(MPI_Info& info) Line 83  void create_MPIInfo(MPI_Info& info)
83  #define MPI_WRITE_ORDERED(A)  #define MPI_WRITE_ORDERED(A)
84  #define MPI_RANK0_WRITE_SHARED(A)  #define MPI_RANK0_WRITE_SHARED(A)
85    
86  #endif /* PASO_MPI */  #endif /* ESYS_MPI */
87    
88    
89  /* Returns one if the node given by coords and idx is within the quadrant  /* Returns one if the node given by coords and idx is within the quadrant
90   * indexed by q and if the element type is Rec9 or Hex27, zero otherwise */   * indexed by q and if the element type is Rec9 or Hex27, zero otherwise */
91  int nodeInQuadrant(const double *coords, ElementTypeId type, int idx, int q)  int nodeInQuadrant(const double *coords, Finley_ElementTypeId type, int idx, int q)
92  {  {
93  #define INSIDE_1D(_X_,_C_,_R_) ( ABS((_X_)-(_C_)) <= (_R_) )  #define INSIDE_1D(_X_,_C_,_R_) ( ABS((_X_)-(_C_)) <= (_R_) )
94  #define INSIDE_2D(_X_,_Y_,_CX_,_CY_,_R_) ( INSIDE_1D(_X_,_CX_,_R_) && INSIDE_1D(_Y_,_CY_,_R_))  #define INSIDE_2D(_X_,_Y_,_CX_,_CY_,_R_) ( INSIDE_1D(_X_,_CX_,_R_) && INSIDE_1D(_Y_,_CY_,_R_))
95  #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_) )  #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_) )
96    
97      int ret;      int ret;
98      if (type == Rec9) {      if ( type == Finley_Line3Macro ) {
99            if (q==0)
100                ret = INSIDE_1D(coords[idx],0.25,0.25);
101            else if (q==1)
102                ret = INSIDE_1D(coords[idx],0.75,0.25);
103            else
104                ret=1;
105        } else if ( (type == Finley_Rec9) || (type == Finley_Rec9Macro) ) {
106          if (q==0)          if (q==0)
107              ret = INSIDE_2D(coords[2*idx], coords[2*idx+1], 0.25, 0.25, 0.25);              ret = INSIDE_2D(coords[2*idx], coords[2*idx+1], 0.25, 0.25, 0.25);
108          else if (q==1)          else if (q==1)
# Line 105  int nodeInQuadrant(const double *coords, Line 113  int nodeInQuadrant(const double *coords,
113              ret = INSIDE_2D(coords[2*idx], coords[2*idx+1], 0.75, 0.75, 0.25);              ret = INSIDE_2D(coords[2*idx], coords[2*idx+1], 0.75, 0.75, 0.25);
114          else          else
115              ret = 0;              ret = 0;
116      } else if (type == Hex27) {      } else if ((type == Finley_Hex27) || (type == Finley_Hex27Macro) ){
117          if (q==0)          if (q==0)
118              ret = INSIDE_3D(coords[3*idx], coords[3*idx+1], coords[3*idx+2],              ret = INSIDE_3D(coords[3*idx], coords[3*idx+1], coords[3*idx+2],
119                      0.25, 0.25, 0.25, 0.25);                      0.25, 0.25, 0.25, 0.25);
# Line 146  void Finley_Mesh_saveVTK(const char *fil Line 154  void Finley_Mesh_saveVTK(const char *fil
154                           const char* metadata,                           const char* metadata,
155                           const char*metadata_schema)                           const char*metadata_schema)
156  {  {
157  #ifdef PASO_MPI  #ifdef ESYS_MPI
158      MPI_File mpi_fileHandle_p;      MPI_File mpi_fileHandle_p;
159      MPI_Status mpi_status;      MPI_Status mpi_status;
160      MPI_Request mpi_req;      MPI_Request mpi_req;
161      MPI_Info mpi_info = MPI_INFO_NULL;      MPI_Info mpi_info = MPI_INFO_NULL;
162  #endif  #endif
163      Paso_MPI_rank my_mpi_rank;      Esys_MPI_rank my_mpi_rank;
164      FILE *fileHandle_p = NULL;      FILE *fileHandle_p = NULL;
165      char errorMsg[LenErrorMsg_MAX], *txtBuffer;      char errorMsg[LenErrorMsg_MAX], *txtBuffer;
166      char tmpBuffer[LEN_TMP_BUFFER];      char tmpBuffer[LEN_TMP_BUFFER];
# Line 169  void Finley_Mesh_saveVTK(const char *fil Line 177  void Finley_Mesh_saveVTK(const char *fil
177      int mpi_size, i, j, l;      int mpi_size, i, j, l;
178      int cellType=0, nodeType=FINLEY_NODES, elementType=FINLEY_UNKNOWN;      int cellType=0, nodeType=FINLEY_NODES, elementType=FINLEY_UNKNOWN;
179      Finley_ElementFile *elements = NULL;      Finley_ElementFile *elements = NULL;
180      ElementTypeId typeId = NoType;      Finley_ElementTypeId typeId = Finley_NoRef;
181    
182      const char *vtkHeader = \      const char *vtkHeader = \
183        "<?xml version=\"1.0\"?>\n" \        "<?xml version=\"1.0\"?>\n" \
# Line 185  void Finley_Mesh_saveVTK(const char *fil Line 193  void Finley_Mesh_saveVTK(const char *fil
193      char *tags_End_Offset_and_Start_Type = "</DataArray>\n<DataArray Name=\"types\" type=\"UInt8\" format=\"ascii\">\n";      char *tags_End_Offset_and_Start_Type = "</DataArray>\n<DataArray Name=\"types\" type=\"UInt8\" format=\"ascii\">\n";
194      char *tag_End_DataArray = "</DataArray>\n";      char *tag_End_DataArray = "</DataArray>\n";
195    
196        const int VTK_LINE3_INDEX[] =
197          { 0, 2,
198            2, 1 };
199      const int VTK_HEX20_INDEX[] =      const int VTK_HEX20_INDEX[] =
200        { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16, 17, 18, 19, 12, 13, 14, 15 };        { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16, 17, 18, 19, 12, 13, 14, 15 };
201      const int VTK_REC9_INDEX[] =      const int VTK_REC9_INDEX[] =
# Line 215  void Finley_Mesh_saveVTK(const char *fil Line 226  void Finley_Mesh_saveVTK(const char *fil
226       * open the file and check handle *       * open the file and check handle *
227       */       */
228      if (mpi_size > 1) {      if (mpi_size > 1) {
229  #ifdef PASO_MPI  #ifdef ESYS_MPI
230          const int amode = MPI_MODE_CREATE|MPI_MODE_WRONLY|MPI_MODE_UNIQUE_OPEN;          const int amode = MPI_MODE_CREATE|MPI_MODE_WRONLY|MPI_MODE_UNIQUE_OPEN;
231          int ierr;          int ierr;
232          if (my_mpi_rank == 0 && Paso_fileExists(filename_p)) {          if (my_mpi_rank == 0 && Paso_fileExists(filename_p)) {
# Line 230  void Finley_Mesh_saveVTK(const char *fil Line 241  void Finley_Mesh_saveVTK(const char *fil
241              ierr=MPI_File_set_view(mpi_fileHandle_p,MPI_DISPLACEMENT_CURRENT,              ierr=MPI_File_set_view(mpi_fileHandle_p,MPI_DISPLACEMENT_CURRENT,
242                      MPI_CHAR, MPI_CHAR, "native", mpi_info);                      MPI_CHAR, MPI_CHAR, "native", mpi_info);
243          }          }
244  #endif /* PASO_MPI */  #endif /* ESYS_MPI */
245      } else {      } else {
246          fileHandle_p = fopen(filename_p, "w");          fileHandle_p = fopen(filename_p, "w");
247          if (fileHandle_p==NULL) {          if (fileHandle_p==NULL) {
# Line 238  void Finley_Mesh_saveVTK(const char *fil Line 249  void Finley_Mesh_saveVTK(const char *fil
249              Finley_setError(IO_ERROR, errorMsg);              Finley_setError(IO_ERROR, errorMsg);
250          }          }
251      }      }
252      if (!Paso_MPIInfo_noError(mesh_p->Nodes->MPIInfo)) return;      if (!Esys_MPIInfo_noError(mesh_p->Nodes->MPIInfo)) return;
253    
254      /* General note: From this point if an error occurs Finley_setError is      /* General note: From this point if an error occurs Finley_setError is
255       * called and subsequent steps are skipped until the end of this function       * called and subsequent steps are skipped until the end of this function
# Line 373  void Finley_Mesh_saveVTK(const char *fil Line 384  void Finley_Mesh_saveVTK(const char *fil
384              myNumCells = Finley_ElementFile_getMyNumElements(elements);              myNumCells = Finley_ElementFile_getMyNumElements(elements);
385              myFirstCell = Finley_ElementFile_getFirstElement(elements);              myFirstCell = Finley_ElementFile_getFirstElement(elements);
386              NN = elements->numNodes;              NN = elements->numNodes;
387                if (hasReducedElements) {
388                    quadNodes_p=elements->referenceElementSet->referenceElementReducedQuadrature->Parametrization->QuadNodes;
389                } else {
390                    quadNodes_p=elements->referenceElementSet->referenceElement->Parametrization->QuadNodes;
391                }
392              if (nodeType==FINLEY_REDUCED_NODES) {              if (nodeType==FINLEY_REDUCED_NODES) {
393                  typeId = elements->LinearReferenceElement->Type->TypeId;                  typeId = elements->referenceElementSet->referenceElement->LinearType->TypeId;
                 if (hasReducedElements) {  
                     quadNodes_p=elements->LinearReferenceElementReducedOrder->QuadNodes;  
                 } else {  
                     quadNodes_p=elements->LinearReferenceElement->QuadNodes;  
                 }  
394              } else {              } else {
395                  typeId = elements->ReferenceElement->Type->TypeId;                  typeId = elements->referenceElementSet->referenceElement->Type->TypeId;
                 if (hasReducedElements)  
                     quadNodes_p=elements->ReferenceElementReducedOrder->QuadNodes;  
                 else  
                     quadNodes_p=elements->ReferenceElement->QuadNodes;  
396              }              }
397              switch (typeId) {              switch (typeId) {
398                  case Point1:                  case Finley_Point1:
399                  case Line2Face:                  case Finley_Line2Face:
400                  case Line3Face:                  case Finley_Line3Face:
401                  case Point1_Contact:                  case Finley_Point1_Contact:
402                  case Line2Face_Contact:                  case Finley_Line2Face_Contact:
403                  case Line3Face_Contact:                  case Finley_Line3Face_Contact:
404                      cellType = VTK_VERTEX;                      cellType = VTK_VERTEX;
405                      numVTKNodesPerElement = 1;                      numVTKNodesPerElement = 1;
406                  break;                  break;
407    
408                  case Line2:                  case Finley_Line2:
409                  case Tri3Face:                  case Finley_Tri3Face:
410                  case Rec4Face:                  case Finley_Rec4Face:
411                  case Line2_Contact:                  case Finley_Line2_Contact:
412                  case Tri3_Contact:                  case Finley_Tri3_Contact:
413                  case Tri3Face_Contact:                  case Finley_Tri3Face_Contact:
414                  case Rec4Face_Contact:                  case Finley_Rec4Face_Contact:
415                        cellType = VTK_LINE;
416                        numVTKNodesPerElement = 2;
417                    break;
418    
419                    case Finley_Line3Macro:
420                      cellType = VTK_LINE;                      cellType = VTK_LINE;
421                        numCellFactor = 2;
422                      numVTKNodesPerElement = 2;                      numVTKNodesPerElement = 2;
423                  break;                  break;
424    
425                  case Tri3:                  case Finley_Tri3:
426                  case Tet4Face:                  case Finley_Tet4Face:
427                  case Tet4Face_Contact:                  case Finley_Tet4Face_Contact:
428                      cellType = VTK_TRIANGLE;                      cellType = VTK_TRIANGLE;
429                      numVTKNodesPerElement = 3;                      numVTKNodesPerElement = 3;
430                  break;                  break;
431    
432                  case Rec4:                  case Finley_Rec4:
433                  case Hex8Face:                  case Finley_Hex8Face:
434                  case Rec4_Contact:                  case Finley_Rec4_Contact:
435                  case Hex8Face_Contact:                  case Finley_Hex8Face_Contact:
436                      cellType = VTK_QUAD;                      cellType = VTK_QUAD;
437                      numVTKNodesPerElement = 4;                      numVTKNodesPerElement = 4;
438                  break;                  break;
439    
440                  case Rec9:                  case Finley_Rec9Macro:
441                    case Finley_Rec9:
442                      numCellFactor = 4;                      numCellFactor = 4;
443                      cellType = VTK_QUAD;                      cellType = VTK_QUAD;
444                      numVTKNodesPerElement = 4;                      numVTKNodesPerElement = 4;
445                  break;                  break;
446    
447                  case Tet4:                  case Finley_Tet4:
448                      cellType = VTK_TETRA;                      cellType = VTK_TETRA;
449                      numVTKNodesPerElement = 4;                      numVTKNodesPerElement = 4;
450                  break;                  break;
451    
452                  case Hex8:                  case Finley_Hex8:
453                      cellType = VTK_HEXAHEDRON;                      cellType = VTK_HEXAHEDRON;
454                      numVTKNodesPerElement = 8;                      numVTKNodesPerElement = 8;
455                  break;                  break;
456    
457                  case Line3:                  case Finley_Line3:
458                  case Tri6Face:                  case Finley_Tri6Face:
459                  case Rec8Face:                  case Finley_Rec8Face:
460                  case Line3_Contact:                  case Finley_Line3_Contact:
461                  case Tri6Face_Contact:                  case Finley_Tri6Face_Contact:
462                  case Rec8Face_Contact:                  case Finley_Rec8Face_Contact:
463                      cellType = VTK_QUADRATIC_EDGE;                      cellType = VTK_QUADRATIC_EDGE;
464                      numVTKNodesPerElement = 3;                      numVTKNodesPerElement = 3;
465                  break;                  break;
466    
467                  case Tri6:                  case Finley_Tri6:
468                  case Tet10Face:                  case Finley_Tri6Macro:
469                  case Tri6_Contact:                  case Finley_Tet10Face:
470                  case Tet10Face_Contact:                  case Finley_Tri6_Contact:
471                    case Finley_Tet10Face_Contact:
472                      cellType = VTK_QUADRATIC_TRIANGLE;                      cellType = VTK_QUADRATIC_TRIANGLE;
473                      numVTKNodesPerElement = 6;                      numVTKNodesPerElement = 6;
474                  break;                  break;
475    
476                  case Rec8:  
477                  case Hex20Face:                  case Finley_Rec8:
478                  case Rec8_Contact:                  case Finley_Hex20Face:
479                  case Hex20Face_Contact:                  case Finley_Rec8_Contact:
480                    case Finley_Hex20Face_Contact:
481                      cellType = VTK_QUADRATIC_QUAD;                      cellType = VTK_QUADRATIC_QUAD;
482                      numVTKNodesPerElement = 8;                      numVTKNodesPerElement = 8;
483                  break;                  break;
484    
485                  case Tet10:                  case Finley_Tet10Macro:
486                    case Finley_Tet10:
487                      cellType = VTK_QUADRATIC_TETRA;                      cellType = VTK_QUADRATIC_TETRA;
488                      numVTKNodesPerElement = 10;                      numVTKNodesPerElement = 10;
489                  break;                  break;
490    
491                  case Hex20:                  case Finley_Hex20:
492                      cellType = VTK_QUADRATIC_HEXAHEDRON;                      cellType = VTK_QUADRATIC_HEXAHEDRON;
493                      numVTKNodesPerElement = 20;                      numVTKNodesPerElement = 20;
494                  break;                  break;
495    
496                  case Hex27:                  case Finley_Hex27Macro:
497                    case Finley_Hex27:
498                      numCellFactor = 8;                      numCellFactor = 8;
499                      cellType = VTK_HEXAHEDRON;                      cellType = VTK_HEXAHEDRON;
500                      numVTKNodesPerElement = 8;                      numVTKNodesPerElement = 8;
501                  break;                  break;
502    
503                  default:                  default:
504                      sprintf(errorMsg, "saveVTK: Element type %s is not supported by VTK.", elements->ReferenceElement->Type->Name);                      sprintf(errorMsg, "saveVTK: Element type %s is not supported by VTK.", elements->referenceElementSet->referenceElement->Type->Name);
505                      Finley_setError(VALUE_ERROR, errorMsg);                      Finley_setError(VALUE_ERROR, errorMsg);
506              }              }
507          }          }
# Line 493  void Finley_Mesh_saveVTK(const char *fil Line 511  void Finley_Mesh_saveVTK(const char *fil
511    
512      txtBufferSize = strlen(vtkHeader) + 3*LEN_INT_FORMAT + (30+3*maxNameLen)+strlen(metadata)+strlen(metadata_schema);      txtBufferSize = strlen(vtkHeader) + 3*LEN_INT_FORMAT + (30+3*maxNameLen)+strlen(metadata)+strlen(metadata_schema);
513      if (mpi_size > 1) {      if (mpi_size > 1) {
514         txtBufferSize = MAX(txtBufferSize, myNumPoints * LEN_TMP_BUFFER);          txtBufferSize = MAX(txtBufferSize, myNumPoints * LEN_TMP_BUFFER);
515          txtBufferSize = MAX(txtBufferSize, numCellFactor * myNumCells *          txtBufferSize = MAX(txtBufferSize, numCellFactor * myNumCells *
516                  (LEN_INT_FORMAT * numVTKNodesPerElement + 1));                  (LEN_INT_FORMAT * numVTKNodesPerElement + 1));
517          txtBufferSize = MAX(txtBufferSize,          txtBufferSize = MAX(txtBufferSize,
# Line 511  void Finley_Mesh_saveVTK(const char *fil Line 529  void Finley_Mesh_saveVTK(const char *fil
529      if (Finley_noError()) {      if (Finley_noError()) {
530          const index_t *nodeIndex;          const index_t *nodeIndex;
531          if (FINLEY_REDUCED_NODES == nodeType) {          if (FINLEY_REDUCED_NODES == nodeType) {
532              nodeIndex = elements->ReferenceElement->Type->linearNodes;              nodeIndex = elements->referenceElementSet->referenceElement->Type->linearNodes;
533          } else if (Rec9 == typeId) {          } else if (Finley_Line3Macro == typeId) {
534                 nodeIndex = VTK_LINE3_INDEX;
535            } else if ( (Finley_Rec9 == typeId) || (Finley_Rec9Macro == typeId) ) {
536              nodeIndex = VTK_REC9_INDEX;              nodeIndex = VTK_REC9_INDEX;
537          } else if (Hex20 == typeId) {          } else if (Finley_Hex20 == typeId) {
538              nodeIndex = VTK_HEX20_INDEX;              nodeIndex = VTK_HEX20_INDEX;
539          } else if (Hex27 == typeId) {          } else if ( (Finley_Hex27 == typeId) || (Finley_Hex27Macro == typeId) ){
540              nodeIndex = VTK_HEX27_INDEX;              nodeIndex = VTK_HEX27_INDEX;
541          } else if (numVTKNodesPerElement != NN) {          } else if (numVTKNodesPerElement  !=  elements->referenceElementSet->referenceElement->Type->numNodes) {
542              nodeIndex = elements->ReferenceElement->Type->geoNodes;              nodeIndex = elements->referenceElementSet->referenceElement->Type->relevantGeoNodes;
543          } else {          } else {
544              nodeIndex = NULL;              nodeIndex = NULL;
545          }          }
# Line 778  void Finley_Mesh_saveVTK(const char *fil Line 798  void Finley_Mesh_saveVTK(const char *fil
798                  txtBufferInUse = 0;                  txtBufferInUse = 0;
799                  for (i=0; i<numCells; i++) {                  for (i=0; i<numCells; i++) {
800                      if (elements->Owner[i] == my_mpi_rank) {                      if (elements->Owner[i] == my_mpi_rank) {
801              void* sampleBuffer=allocSampleBuffer(data_pp[dataIdx]);                          __const double *values = getSampleDataRO(data_pp[dataIdx], i);
                         __const double *values = getSampleDataRO(data_pp[dataIdx], i,sampleBuffer);  
802                          for (l = 0; l < numCellFactor; l++) {                          for (l = 0; l < numCellFactor; l++) {
803                              double sampleAvg[NCOMP_MAX];                              double sampleAvg[NCOMP_MAX];
804                              dim_t nCompUsed = MIN(nComp, NCOMP_MAX);                              dim_t nCompUsed = MIN(nComp, NCOMP_MAX);
805    
806                              /* average over number of points in the sample */                              /* average over number of points in the sample */
807                              if (isExpanded(data_pp[dataIdx])) {                              if (isExpanded(data_pp[dataIdx])) {
808                                  dim_t hits=0, hits_old;                                  dim_t hits=0;
809                                  for (k=0; k<nCompUsed; k++) sampleAvg[k]=0;                                  for (k=0; k<nCompUsed; k++) sampleAvg[k]=0;
810                                  for (j=0; j<numPointsPerSample; j++) {                                  for (j=0; j<numPointsPerSample; j++) {
                                     hits_old=hits;  
811                                      if (nodeInQuadrant(quadNodes_p, typeId, j, l)) {                                      if (nodeInQuadrant(quadNodes_p, typeId, j, l)) {
812                                          hits++;                                          hits++;
813                                          for (k=0; k<nCompUsed; k++) {                                          for (k=0; k<nCompUsed; k++) {
# Line 845  void Finley_Mesh_saveVTK(const char *fil Line 863  void Finley_Mesh_saveVTK(const char *fil
863                                  fputs(tmpBuffer, fileHandle_p);                                  fputs(tmpBuffer, fileHandle_p);
864                              }                              }
865                          } /* for l (numCellFactor) */                          } /* for l (numCellFactor) */
             freeSampleBuffer(sampleBuffer);  
866                      } /* if I am the owner */                      } /* if I am the owner */
867                  } /* for i (numCells) */                  } /* for i (numCells) */
868    
# Line 961  void Finley_Mesh_saveVTK(const char *fil Line 978  void Finley_Mesh_saveVTK(const char *fil
978                  for (i=0; i<mesh_p->Nodes->numNodes; i++) {                  for (i=0; i<mesh_p->Nodes->numNodes; i++) {
979                      k = globalNodeIndex[i];                      k = globalNodeIndex[i];
980                      if ( (myFirstNode <= k) && (k < myLastNode) ) {                      if ( (myFirstNode <= k) && (k < myLastNode) ) {
981              void* sampleBuffer=allocSampleBuffer(data_pp[dataIdx]);                          __const double *values = getSampleDataRO(data_pp[dataIdx], nodeMapping->target[i]);
                         __const double *values = getSampleDataRO(data_pp[dataIdx], nodeMapping->target[i], sampleBuffer);  
982                          /* if the number of mpi_required components is more than                          /* if the number of mpi_required components is more than
983                           * the number of actual components, pad with zeros.                           * the number of actual components, pad with zeros.
984                           * Probably only need to get shape of first element */                           * Probably only need to get shape of first element */
# Line 1002  void Finley_Mesh_saveVTK(const char *fil Line 1018  void Finley_Mesh_saveVTK(const char *fil
1018                          } else {                          } else {
1019                              fputs(tmpBuffer, fileHandle_p);                              fputs(tmpBuffer, fileHandle_p);
1020                          }                          }
             freeSampleBuffer(sampleBuffer);         /* no-one needs values anymore */  
1021                      } /* if this is my node */                      } /* if this is my node */
1022                  } /* for i (numNodes) */                  } /* for i (numNodes) */
1023    
# Line 1033  void Finley_Mesh_saveVTK(const char *fil Line 1048  void Finley_Mesh_saveVTK(const char *fil
1048      }      }
1049    
1050      if ( mpi_size > 1) {      if ( mpi_size > 1) {
1051  #ifdef PASO_MPI  #ifdef ESYS_MPI
1052          MPI_File_close(&mpi_fileHandle_p);          MPI_File_close(&mpi_fileHandle_p);
1053      MPI_Barrier(mesh_p->Nodes->MPIInfo->comm);          MPI_Barrier(mesh_p->Nodes->MPIInfo->comm);
1054  #endif  #endif
1055      } else {      } else {
1056          fclose(fileHandle_p);          fclose(fileHandle_p);

Legend:
Removed from v.2548  
changed lines
  Added in v.3259

  ViewVC Help
Powered by ViewVC 1.1.26