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

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

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

revision 1811 by ksteube, Thu Sep 25 23:11:13 2008 UTC revision 2059 by gross, Mon Nov 17 22:57:50 2008 UTC
# Line 21  Line 21 
21  #include <ctype.h>  #include <ctype.h>
22  #include "Mesh.h"  #include "Mesh.h"
23    
24    #define FSCANF_CHECK(scan_ret, reason) { if (scan_ret == EOF) { perror(reason); Finley_setError(IO_ERROR,"scan error while reading finley file"); return NULL;} }
25    
26  /**************************************************************/  /**************************************************************/
27    
28  /*  reads a mesh from a Finley file of name fname */  /*  reads a mesh from a Finley file of name fname */
# Line 35  Finley_Mesh* Finley_Mesh_read(char* fnam Line 37  Finley_Mesh* Finley_Mesh_read(char* fnam
37    Finley_Mesh *mesh_p=NULL;    Finley_Mesh *mesh_p=NULL;
38    char name[LenString_MAX],element_type[LenString_MAX],frm[20];    char name[LenString_MAX],element_type[LenString_MAX],frm[20];
39    char error_msg[LenErrorMsg_MAX];    char error_msg[LenErrorMsg_MAX];
40      #ifdef Finley_TRACE
41    double time0=Finley_timer();    double time0=Finley_timer();
42      #endif
43    FILE *fileHandle_p = NULL;    FILE *fileHandle_p = NULL;
44    ElementTypeId typeID, faceTypeID, contactTypeID, pointTypeID;    ElementTypeId typeID=NoType, faceTypeID=NoType, contactTypeID=NoType, pointTypeID=NoType;
45      int scan_ret;
46        
47    Finley_resetError();    Finley_resetError();
48    
# Line 55  Finley_Mesh* Finley_Mesh_read(char* fnam Line 60  Finley_Mesh* Finley_Mesh_read(char* fnam
60        
61       /* read header */       /* read header */
62       sprintf(frm,"%%%d[^\n]",LenString_MAX-1);       sprintf(frm,"%%%d[^\n]",LenString_MAX-1);
63       fscanf(fileHandle_p, frm, name);       scan_ret = fscanf(fileHandle_p, frm, name);
64         FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
65    
66        
67       /* get the nodes */       /* get the nodes */
68        
69       fscanf(fileHandle_p, "%1d%*s %d\n", &numDim,&numNodes);       scan_ret = fscanf(fileHandle_p, "%1d%*s %d\n", &numDim,&numNodes);
70         FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
71       /* allocate mesh */       /* allocate mesh */
72       mesh_p = Finley_Mesh_alloc(name,numDim,order,reduced_order,mpi_info);       mesh_p = Finley_Mesh_alloc(name,numDim,order,reduced_order,mpi_info);
73       if (Finley_noError()) {       if (Finley_noError()) {
# Line 68  Finley_Mesh* Finley_Mesh_read(char* fnam Line 76  Finley_Mesh* Finley_Mesh_read(char* fnam
76          Finley_NodeFile_allocTable(mesh_p->Nodes, numNodes);          Finley_NodeFile_allocTable(mesh_p->Nodes, numNodes);
77          if (Finley_noError()) {          if (Finley_noError()) {
78             if (1 == numDim) {             if (1 == numDim) {
79                 for (i0 = 0; i0 < numNodes; i0++)                 for (i0 = 0; i0 < numNodes; i0++) {
80                  fscanf(fileHandle_p, "%d %d %d %le\n", &mesh_p->Nodes->Id[i0],                  scan_ret = fscanf(fileHandle_p, "%d %d %d %le\n", &mesh_p->Nodes->Id[i0],
81                         &mesh_p->Nodes->globalDegreesOfFreedom[i0], &mesh_p->Nodes->Tag[i0],                         &mesh_p->Nodes->globalDegreesOfFreedom[i0], &mesh_p->Nodes->Tag[i0],
82                         &mesh_p->Nodes->Coordinates[INDEX2(0,i0,numDim)]);                         &mesh_p->Nodes->Coordinates[INDEX2(0,i0,numDim)]);
83                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
84               }
85             } else if (2 == numDim) {             } else if (2 == numDim) {
86                      for (i0 = 0; i0 < numNodes; i0++)                      for (i0 = 0; i0 < numNodes; i0++) {
87                            fscanf(fileHandle_p, "%d %d %d %le %le\n", &mesh_p->Nodes->Id[i0],                            scan_ret = fscanf(fileHandle_p, "%d %d %d %le %le\n", &mesh_p->Nodes->Id[i0],
88                                   &mesh_p->Nodes->globalDegreesOfFreedom[i0], &mesh_p->Nodes->Tag[i0],                                   &mesh_p->Nodes->globalDegreesOfFreedom[i0], &mesh_p->Nodes->Tag[i0],
89                                   &mesh_p->Nodes->Coordinates[INDEX2(0,i0,numDim)],                                   &mesh_p->Nodes->Coordinates[INDEX2(0,i0,numDim)],
90                                   &mesh_p->Nodes->Coordinates[INDEX2(1,i0,numDim)]);                                   &mesh_p->Nodes->Coordinates[INDEX2(1,i0,numDim)]);
91                      FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
92                    }
93             } else if (3 == numDim) {             } else if (3 == numDim) {
94                      for (i0 = 0; i0 < numNodes; i0++)                      for (i0 = 0; i0 < numNodes; i0++) {
95                            fscanf(fileHandle_p, "%d %d %d %le %le %le\n", &mesh_p->Nodes->Id[i0],                            scan_ret = fscanf(fileHandle_p, "%d %d %d %le %le %le\n", &mesh_p->Nodes->Id[i0],
96                                   &mesh_p->Nodes->globalDegreesOfFreedom[i0], &mesh_p->Nodes->Tag[i0],                                   &mesh_p->Nodes->globalDegreesOfFreedom[i0], &mesh_p->Nodes->Tag[i0],
97                                   &mesh_p->Nodes->Coordinates[INDEX2(0,i0,numDim)],                                   &mesh_p->Nodes->Coordinates[INDEX2(0,i0,numDim)],
98                                   &mesh_p->Nodes->Coordinates[INDEX2(1,i0,numDim)],                                   &mesh_p->Nodes->Coordinates[INDEX2(1,i0,numDim)],
99                                   &mesh_p->Nodes->Coordinates[INDEX2(2,i0,numDim)]);                                   &mesh_p->Nodes->Coordinates[INDEX2(2,i0,numDim)]);
100                      FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
101                    }
102             } /* if else else */             } /* if else else */
103          }          }
104          /* read elements */          /* read elements */
105          if (Finley_noError()) {          if (Finley_noError()) {
106        
107             fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);             scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
108           FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
109             typeID=Finley_RefElement_getTypeId(element_type);             typeID=Finley_RefElement_getTypeId(element_type);
110             if (typeID==NoType) {             if (typeID==NoType) {
111               sprintf(error_msg,"Finley_Mesh_read :Unidentified element type %s",element_type);               sprintf(error_msg,"Finley_Mesh_read :Unidentified element type %s",element_type);
# Line 104  Finley_Mesh* Finley_Mesh_read(char* fnam Line 119  Finley_Mesh* Finley_Mesh_read(char* fnam
119                   mesh_p->Elements->maxColor=numEle-1;                   mesh_p->Elements->maxColor=numEle-1;
120                   if (Finley_noError()) {                   if (Finley_noError()) {
121                      for (i0 = 0; i0 < numEle; i0++) {                      for (i0 = 0; i0 < numEle; i0++) {
122                        fscanf(fileHandle_p, "%d %d", &mesh_p->Elements->Id[i0], &mesh_p->Elements->Tag[i0]);                        scan_ret = fscanf(fileHandle_p, "%d %d", &mesh_p->Elements->Id[i0], &mesh_p->Elements->Tag[i0]);
123                  FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
124                        mesh_p->Elements->Color[i0]=i0;                        mesh_p->Elements->Color[i0]=i0;
125                        mesh_p->Elements->Owner[i0]=0;                        mesh_p->Elements->Owner[i0]=0;
126                        for (i1 = 0; i1 < mesh_p->Elements->ReferenceElement->Type->numNodes; i1++) {                        for (i1 = 0; i1 < mesh_p->Elements->ReferenceElement->Type->numNodes; i1++) {
127                             fscanf(fileHandle_p, " %d",                             scan_ret = fscanf(fileHandle_p, " %d",
128                                &mesh_p->Elements->Nodes[INDEX2(i1, i0, mesh_p->Elements->ReferenceElement->Type->numNodes)]);                                &mesh_p->Elements->Nodes[INDEX2(i1, i0, mesh_p->Elements->ReferenceElement->Type->numNodes)]);
129                   FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
130                        } /* for i1 */                        } /* for i1 */
131                        fscanf(fileHandle_p, "\n");                        scan_ret = fscanf(fileHandle_p, "\n");
132                  FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
133                      } /* for i0 */                      } /* for i0 */
134                   }                   }
135               }               }
# Line 119  Finley_Mesh* Finley_Mesh_read(char* fnam Line 137  Finley_Mesh* Finley_Mesh_read(char* fnam
137          }          }
138          /* get the face elements */          /* get the face elements */
139          if (Finley_noError()) {          if (Finley_noError()) {
140               fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);               scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
141             FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
142               faceTypeID=Finley_RefElement_getTypeId(element_type);               faceTypeID=Finley_RefElement_getTypeId(element_type);
143               if (faceTypeID==NoType) {               if (faceTypeID==NoType) {
144                 sprintf(error_msg,"Finley_Mesh_read :Unidentified element type %s for face elements",element_type);                 sprintf(error_msg,"Finley_Mesh_read :Unidentified element type %s for face elements",element_type);
# Line 132  Finley_Mesh* Finley_Mesh_read(char* fnam Line 151  Finley_Mesh* Finley_Mesh_read(char* fnam
151                        mesh_p->FaceElements->minColor=0;                        mesh_p->FaceElements->minColor=0;
152                        mesh_p->FaceElements->maxColor=numEle-1;                        mesh_p->FaceElements->maxColor=numEle-1;
153                        for (i0 = 0; i0 < numEle; i0++) {                        for (i0 = 0; i0 < numEle; i0++) {
154                          fscanf(fileHandle_p, "%d %d", &mesh_p->FaceElements->Id[i0], &mesh_p->FaceElements->Tag[i0]);                          scan_ret = fscanf(fileHandle_p, "%d %d", &mesh_p->FaceElements->Id[i0], &mesh_p->FaceElements->Tag[i0]);
155                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
156                          mesh_p->FaceElements->Color[i0]=i0;                          mesh_p->FaceElements->Color[i0]=i0;
157                          mesh_p->FaceElements->Owner[i0]=0;                          mesh_p->FaceElements->Owner[i0]=0;
158                          for (i1 = 0; i1 < mesh_p->FaceElements->ReferenceElement->Type->numNodes; i1++) {                          for (i1 = 0; i1 < mesh_p->FaceElements->ReferenceElement->Type->numNodes; i1++) {
159                               fscanf(fileHandle_p, " %d",                               scan_ret = fscanf(fileHandle_p, " %d",
160                                  &mesh_p->FaceElements->Nodes[INDEX2(i1, i0, mesh_p->FaceElements->ReferenceElement->Type->numNodes)]);                                  &mesh_p->FaceElements->Nodes[INDEX2(i1, i0, mesh_p->FaceElements->ReferenceElement->Type->numNodes)]);
161                     FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
162                          }   /* for i1 */                          }   /* for i1 */
163                          fscanf(fileHandle_p, "\n");                          scan_ret = fscanf(fileHandle_p, "\n");
164                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
165                        } /* for i0 */                        } /* for i0 */
166                     }                     }
167                  }                  }
# Line 147  Finley_Mesh* Finley_Mesh_read(char* fnam Line 169  Finley_Mesh* Finley_Mesh_read(char* fnam
169          }          }
170          /* get the Contact face element */          /* get the Contact face element */
171          if (Finley_noError()) {          if (Finley_noError()) {
172               fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);               scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
173             FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
174               contactTypeID=Finley_RefElement_getTypeId(element_type);               contactTypeID=Finley_RefElement_getTypeId(element_type);
175               if (contactTypeID==NoType) {               if (contactTypeID==NoType) {
176                 sprintf(error_msg,"Finley_Mesh_read: Unidentified element type %s for contact elements",element_type);                 sprintf(error_msg,"Finley_Mesh_read: Unidentified element type %s for contact elements",element_type);
# Line 160  Finley_Mesh* Finley_Mesh_read(char* fnam Line 183  Finley_Mesh* Finley_Mesh_read(char* fnam
183                        mesh_p->ContactElements->minColor=0;                        mesh_p->ContactElements->minColor=0;
184                        mesh_p->ContactElements->maxColor=numEle-1;                        mesh_p->ContactElements->maxColor=numEle-1;
185                        for (i0 = 0; i0 < numEle; i0++) {                        for (i0 = 0; i0 < numEle; i0++) {
186                          fscanf(fileHandle_p, "%d %d", &mesh_p->ContactElements->Id[i0], &mesh_p->ContactElements->Tag[i0]);                          scan_ret = fscanf(fileHandle_p, "%d %d", &mesh_p->ContactElements->Id[i0], &mesh_p->ContactElements->Tag[i0]);
187                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
188                          mesh_p->ContactElements->Color[i0]=i0;                          mesh_p->ContactElements->Color[i0]=i0;
189                          mesh_p->ContactElements->Owner[i0]=0;                          mesh_p->ContactElements->Owner[i0]=0;
190                          for (i1 = 0; i1 < mesh_p->ContactElements->ReferenceElement->Type->numNodes; i1++) {                          for (i1 = 0; i1 < mesh_p->ContactElements->ReferenceElement->Type->numNodes; i1++) {
191                              fscanf(fileHandle_p, " %d",                              scan_ret = fscanf(fileHandle_p, " %d",
192                                 &mesh_p->ContactElements->Nodes[INDEX2(i1, i0, mesh_p->ContactElements->ReferenceElement->Type->numNodes)]);                                 &mesh_p->ContactElements->Nodes[INDEX2(i1, i0, mesh_p->ContactElements->ReferenceElement->Type->numNodes)]);
193                    FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
194                          }   /* for i1 */                          }   /* for i1 */
195                          fscanf(fileHandle_p, "\n");                          scan_ret = fscanf(fileHandle_p, "\n");
196                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
197                        } /* for i0 */                        } /* for i0 */
198                    }                    }
199                 }                 }
# Line 175  Finley_Mesh* Finley_Mesh_read(char* fnam Line 201  Finley_Mesh* Finley_Mesh_read(char* fnam
201          }            }  
202          /* get the nodal element */          /* get the nodal element */
203          if (Finley_noError()) {          if (Finley_noError()) {
204               fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);               scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
205             FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
206               pointTypeID=Finley_RefElement_getTypeId(element_type);               pointTypeID=Finley_RefElement_getTypeId(element_type);
207               if (pointTypeID==NoType) {               if (pointTypeID==NoType) {
208                 sprintf(error_msg,"Finley_Mesh_read: Unidentified element type %s for points",element_type);                 sprintf(error_msg,"Finley_Mesh_read: Unidentified element type %s for points",element_type);
# Line 188  Finley_Mesh* Finley_Mesh_read(char* fnam Line 215  Finley_Mesh* Finley_Mesh_read(char* fnam
215                     mesh_p->Points->minColor=0;                     mesh_p->Points->minColor=0;
216                     mesh_p->Points->maxColor=numEle-1;                     mesh_p->Points->maxColor=numEle-1;
217                     for (i0 = 0; i0 < numEle; i0++) {                     for (i0 = 0; i0 < numEle; i0++) {
218                       fscanf(fileHandle_p, "%d %d", &mesh_p->Points->Id[i0], &mesh_p->Points->Tag[i0]);                       scan_ret = fscanf(fileHandle_p, "%d %d", &mesh_p->Points->Id[i0], &mesh_p->Points->Tag[i0]);
219                 FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
220                       mesh_p->Points->Color[i0]=i0;                       mesh_p->Points->Color[i0]=i0;
221                       mesh_p->Points->Owner[i0]=0;                       mesh_p->Points->Owner[i0]=0;
222                       for (i1 = 0; i1 < mesh_p->Points->ReferenceElement->Type->numNodes; i1++) {                       for (i1 = 0; i1 < mesh_p->Points->ReferenceElement->Type->numNodes; i1++) {
223                           fscanf(fileHandle_p, " %d",                           scan_ret = fscanf(fileHandle_p, " %d",
224                              &mesh_p->Points->Nodes[INDEX2(i1, i0, mesh_p->Points->ReferenceElement->Type->numNodes)]);                              &mesh_p->Points->Nodes[INDEX2(i1, i0, mesh_p->Points->ReferenceElement->Type->numNodes)]);
225                 FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
226                       }  /* for i1 */                       }  /* for i1 */
227                       fscanf(fileHandle_p, "\n");                       scan_ret = fscanf(fileHandle_p, "\n");
228                 FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
229                     } /* for i0 */                     } /* for i0 */
230                  }                  }
231               }               }
# Line 203  Finley_Mesh* Finley_Mesh_read(char* fnam Line 233  Finley_Mesh* Finley_Mesh_read(char* fnam
233          /* get the name tags */          /* get the name tags */
234          if (Finley_noError()) {          if (Finley_noError()) {
235             if (feof(fileHandle_p) == 0) {             if (feof(fileHandle_p) == 0) {
236                fscanf(fileHandle_p, "%s\n", name);                scan_ret = fscanf(fileHandle_p, "%s\n", name);
237              FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
238                while (feof(fileHandle_p) == 0) {                while (feof(fileHandle_p) == 0) {
239                     fscanf(fileHandle_p, "%s %d\n", name, &tag_key);                     scan_ret = fscanf(fileHandle_p, "%s %d\n", name, &tag_key);
240               FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
241                     Finley_Mesh_addTagMap(mesh_p,name,tag_key);                     Finley_Mesh_addTagMap(mesh_p,name,tag_key);
242                }                }
243             }             }
# Line 243  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 275  Finley_Mesh* Finley_Mesh_read_MPI(char*
275    Finley_Mesh *mesh_p=NULL;    Finley_Mesh *mesh_p=NULL;
276    char name[LenString_MAX],element_type[LenString_MAX],frm[20];    char name[LenString_MAX],element_type[LenString_MAX],frm[20];
277    char error_msg[LenErrorMsg_MAX];    char error_msg[LenErrorMsg_MAX];
278      #ifdef Finley_TRACE
279    double time0=Finley_timer();    double time0=Finley_timer();
280      #endif
281    FILE *fileHandle_p = NULL;    FILE *fileHandle_p = NULL;
282    ElementTypeId typeID, faceTypeID, contactTypeID, pointTypeID;    ElementTypeId typeID=NoType;
283    Finley_TagMap* tag_map;    int scan_ret;
   index_t tag_key;  
284    
285    Finley_resetError();    Finley_resetError();
286    
# Line 263  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 296  Finley_Mesh* Finley_Mesh_read_MPI(char*
296    
297       /* read header */       /* read header */
298       sprintf(frm,"%%%d[^\n]",LenString_MAX-1);       sprintf(frm,"%%%d[^\n]",LenString_MAX-1);
299       fscanf(fileHandle_p, frm, name);       scan_ret = fscanf(fileHandle_p, frm, name);
300         FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
301    
302       /* get the number of nodes */       /* get the number of nodes */
303       fscanf(fileHandle_p, "%1d%*s %d\n", &numDim,&numNodes);       scan_ret = fscanf(fileHandle_p, "%1d%*s %d\n", &numDim,&numNodes);
304         FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
305    }    }
306    
307  #ifdef PASO_MPI  #ifdef PASO_MPI
# Line 314  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 349  Finley_Mesh* Finley_Mesh_read_MPI(char*
349          chunkNodes = 0;          chunkNodes = 0;
350          for (i1=0; i1<chunkSize; i1++) {          for (i1=0; i1<chunkSize; i1++) {
351            if (totalNodes >= numNodes) break;    /* End of inner loop */            if (totalNodes >= numNodes) break;    /* End of inner loop */
352                if (1 == numDim)                if (1 == numDim) {
353          fscanf(fileHandle_p, "%d %d %d %le\n",          scan_ret = fscanf(fileHandle_p, "%d %d %d %le\n",
354            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],
355            &tempCoords[i1*numDim+0]);            &tempCoords[i1*numDim+0]);
356                if (2 == numDim)          FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
357          fscanf(fileHandle_p, "%d %d %d %le %le\n",            }
358                  if (2 == numDim) {
359            scan_ret = fscanf(fileHandle_p, "%d %d %d %le %le\n",
360            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],
361            &tempCoords[i1*numDim+0], &tempCoords[i1*numDim+1]);            &tempCoords[i1*numDim+0], &tempCoords[i1*numDim+1]);
362                if (3 == numDim)          FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
363          fscanf(fileHandle_p, "%d %d %d %le %le %le\n",            }
364                  if (3 == numDim) {
365            scan_ret = fscanf(fileHandle_p, "%d %d %d %le %le %le\n",
366            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],
367            &tempCoords[i1*numDim+0], &tempCoords[i1*numDim+1], &tempCoords[i1*numDim+2]);            &tempCoords[i1*numDim+0], &tempCoords[i1*numDim+1], &tempCoords[i1*numDim+2]);
368            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
369              }
370            totalNodes++; /* When do we quit the infinite loop? */            totalNodes++; /* When do we quit the infinite loop? */
371            chunkNodes++; /* How many nodes do we actually have in this chunk? It may be smaller than chunkSize. */            chunkNodes++; /* How many nodes do we actually have in this chunk? It may be smaller than chunkSize. */
372          }          }
# Line 395  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 436  Finley_Mesh* Finley_Mesh_read_MPI(char*
436      /* Read the element typeID */      /* Read the element typeID */
437          if (Finley_noError()) {          if (Finley_noError()) {
438        if (mpi_info->rank == 0) {        if (mpi_info->rank == 0) {
439              fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);              scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
440            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
441              typeID=Finley_RefElement_getTypeId(element_type);              typeID=Finley_RefElement_getTypeId(element_type);
442        }        }
443  #ifdef PASO_MPI  #ifdef PASO_MPI
# Line 433  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 475  Finley_Mesh* Finley_Mesh_read_MPI(char*
475          chunkEle = 0;          chunkEle = 0;
476          for (i0=0; i0<chunkSize; i0++) {          for (i0=0; i0<chunkSize; i0++) {
477            if (totalEle >= numEle) break; /* End inner loop */            if (totalEle >= numEle) break; /* End inner loop */
478            fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]);            scan_ret = fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]);
479            for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
480            fscanf(fileHandle_p, "\n");            for (i1 = 0; i1 < numNodes; i1++) {
481            scan_ret = fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);
482                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
483              }
484              scan_ret = fscanf(fileHandle_p, "\n");
485              FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
486            totalEle++;            totalEle++;
487            chunkEle++;            chunkEle++;
488          }          }
# Line 495  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 542  Finley_Mesh* Finley_Mesh_read_MPI(char*
542      /* Read the element typeID */      /* Read the element typeID */
543          if (Finley_noError()) {          if (Finley_noError()) {
544        if (mpi_info->rank == 0) {        if (mpi_info->rank == 0) {
545              fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);              scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
546            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
547              typeID=Finley_RefElement_getTypeId(element_type);              typeID=Finley_RefElement_getTypeId(element_type);
548        }        }
549  #ifdef PASO_MPI  #ifdef PASO_MPI
# Line 533  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 581  Finley_Mesh* Finley_Mesh_read_MPI(char*
581          chunkEle = 0;          chunkEle = 0;
582          for (i0=0; i0<chunkSize; i0++) {          for (i0=0; i0<chunkSize; i0++) {
583            if (totalEle >= numEle) break; /* End inner loop */            if (totalEle >= numEle) break; /* End inner loop */
584            fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]);            scan_ret = fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]);
585            for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
586            fscanf(fileHandle_p, "\n");            for (i1 = 0; i1 < numNodes; i1++) {
587            scan_ret = fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);
588                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
589              }
590              scan_ret = fscanf(fileHandle_p, "\n");
591              FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
592            totalEle++;            totalEle++;
593            chunkEle++;            chunkEle++;
594          }          }
# Line 595  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 648  Finley_Mesh* Finley_Mesh_read_MPI(char*
648      /* Read the element typeID */      /* Read the element typeID */
649          if (Finley_noError()) {          if (Finley_noError()) {
650        if (mpi_info->rank == 0) {        if (mpi_info->rank == 0) {
651              fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);              scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
652            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
653              typeID=Finley_RefElement_getTypeId(element_type);              typeID=Finley_RefElement_getTypeId(element_type);
654        }        }
655  #ifdef PASO_MPI  #ifdef PASO_MPI
# Line 633  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 687  Finley_Mesh* Finley_Mesh_read_MPI(char*
687          chunkEle = 0;          chunkEle = 0;
688          for (i0=0; i0<chunkSize; i0++) {          for (i0=0; i0<chunkSize; i0++) {
689            if (totalEle >= numEle) break; /* End inner loop */            if (totalEle >= numEle) break; /* End inner loop */
690            fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]);            scan_ret = fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]);
691            for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
692            fscanf(fileHandle_p, "\n");            for (i1 = 0; i1 < numNodes; i1++) {
693            scan_ret = fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);
694                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
695              }
696              scan_ret = fscanf(fileHandle_p, "\n");
697              FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
698            totalEle++;            totalEle++;
699            chunkEle++;            chunkEle++;
700          }          }
# Line 695  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 754  Finley_Mesh* Finley_Mesh_read_MPI(char*
754      /* Read the element typeID */      /* Read the element typeID */
755          if (Finley_noError()) {          if (Finley_noError()) {
756        if (mpi_info->rank == 0) {        if (mpi_info->rank == 0) {
757              fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);              scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
758            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
759              typeID=Finley_RefElement_getTypeId(element_type);              typeID=Finley_RefElement_getTypeId(element_type);
760        }        }
761  #ifdef PASO_MPI  #ifdef PASO_MPI
# Line 733  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 793  Finley_Mesh* Finley_Mesh_read_MPI(char*
793          chunkEle = 0;          chunkEle = 0;
794          for (i0=0; i0<chunkSize; i0++) {          for (i0=0; i0<chunkSize; i0++) {
795            if (totalEle >= numEle) break; /* End inner loop */            if (totalEle >= numEle) break; /* End inner loop */
796            fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]);            scan_ret = fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]);
797            for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
798            fscanf(fileHandle_p, "\n");            for (i1 = 0; i1 < numNodes; i1++) {
799            scan_ret = fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);
800                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
801              }
802              scan_ret = fscanf(fileHandle_p, "\n");
803              FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
804            totalEle++;            totalEle++;
805            chunkEle++;            chunkEle++;
806          }          }
# Line 792  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 857  Finley_Mesh* Finley_Mesh_read_MPI(char*
857    
858        /* get the name tags */        /* get the name tags */
859        if (Finley_noError()) {        if (Finley_noError()) {
860          char *remainder, *ptr;          char *remainder=0, *ptr;
861          int tag_key, len, error_code;          size_t len;
862          long cur_pos, end_pos;          int tag_key;
863    
864    
865    
866          if (mpi_info->rank == 0) {  /* Master */          if (mpi_info->rank == 0) {  /* Master */
867        /* Read the word 'Tag' */        /* Read the word 'Tag' */
868        if (! feof(fileHandle_p)) fscanf(fileHandle_p, "%s\n", name);        if (! feof(fileHandle_p)) {
869            scan_ret = fscanf(fileHandle_p, "%s\n", name);
870            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
871          }
872    
873    #if defined(_WIN32)  /* windows ftell lies on unix formatted text files */
874    
875          remainder = NULL;
876              len=0;
877          while (1)
878              {
879                 size_t malloc_chunk = 1024;
880                 size_t buff_size = 0;
881                 int ch;
882    
883                 ch = fgetc(fileHandle_p);
884                 if( ch == '\r' )
885                 {
886                    continue;
887                 }
888                 if( len+1 > buff_size )
889                 {
890                    TMPMEMREALLOC(remainder,remainder,buff_size+malloc_chunk,char);
891                 }
892                 if( ch == EOF )
893                 {
894                    /* hit EOF */
895                    remainder[len] = (char)0;
896                    break;
897                 }
898                 remainder[len] = (char)ch;
899                 len++;
900              }
901    #else
902        /* Read rest of file in one chunk, after using seek to find length */        /* Read rest of file in one chunk, after using seek to find length */
903            cur_pos = ftell(fileHandle_p);            {
904            fseek(fileHandle_p, 0L, SEEK_END);               long cur_pos, end_pos;
905            end_pos = ftell(fileHandle_p);  
906            fseek(fileHandle_p, (long)cur_pos, SEEK_SET);               cur_pos = ftell(fileHandle_p);
907        remainder = TMPMEMALLOC(end_pos-cur_pos+1, char);               fseek(fileHandle_p, 0L, SEEK_END);
908        if (! feof(fileHandle_p)) fread(remainder, (size_t) end_pos-cur_pos, sizeof(char), fileHandle_p);               end_pos = ftell(fileHandle_p);
909        remainder[end_pos-cur_pos] = 0;               fseek(fileHandle_p, (long)cur_pos, SEEK_SET);
910        len = strlen(remainder);                   remainder = TMPMEMALLOC(end_pos-cur_pos+1, char);
911                 if (! feof(fileHandle_p))
912                 {
913                    scan_ret = fread(remainder, (size_t) end_pos-cur_pos,
914                                     sizeof(char), fileHandle_p);
915    
916                    FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
917                    remainder[end_pos-cur_pos] = 0;
918                }
919              }
920    #endif
921          len = strlen(remainder);
922        while ((--len)>0 && isspace(remainder[len])) remainder[len]=0;        while ((--len)>0 && isspace(remainder[len])) remainder[len]=0;
923        len = strlen(remainder);        len = strlen(remainder);
924              TMPMEMREALLOC(remainder,remainder,len+1,char);
925          }          }
926  #ifdef PASO_MPI  #ifdef PASO_MPI
927          error_code = MPI_Bcast (&len, 1, MPI_INT,  0, mpi_info->comm);  
928          if (error_code != MPI_SUCCESS) {          if (MPI_Bcast (&len, 1, MPI_INT,  0, mpi_info->comm) != MPI_SUCCESS)
929            Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of tag len failed");          {
930            return NULL;             Finley_setError(PASO_MPI_ERROR,
931                               "Finley_Mesh_read: broadcast of tag len failed");
932               return NULL;
933          }          }
934      if (mpi_info->rank != 0) {      if (mpi_info->rank != 0) {
935        remainder = TMPMEMALLOC(len+1, char);        remainder = TMPMEMALLOC(len+1, char);
936        remainder[0] = 0;        remainder[0] = 0;
937      }      }
938          error_code = MPI_Bcast (remainder, len+1, MPI_CHAR,  0, mpi_info->comm);  
939          if (error_code != MPI_SUCCESS) {          if (MPI_Bcast (remainder, len+1, MPI_CHAR,  0, mpi_info->comm) !=
940            Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of tags failed");              MPI_SUCCESS)
941            return NULL;          {
942               Finley_setError(PASO_MPI_ERROR,
943                               "Finley_Mesh_read: broadcast of tags failed");
944               return NULL;
945          }          }
946  #endif  #endif
947      if (remainder[0]) {      if (remainder[0]) {

Legend:
Removed from v.1811  
changed lines
  Added in v.2059

  ViewVC Help
Powered by ViewVC 1.1.26