/[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 2385 by gross, Wed Apr 15 03:52:38 2009 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 238  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 270  Finley_Mesh* Finley_Mesh_read_MPI(char*
270    
271  {  {
272    
273    Paso_MPIInfo *mpi_info = Paso_MPIInfo_alloc( MPI_COMM_WORLD );    Paso_MPIInfo *mpi_info = NULL;
274    dim_t numNodes, numDim, numEle, i0, i1;    dim_t numNodes, numDim, numEle, i0, i1;
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      mpi_info = Paso_MPIInfo_alloc( MPI_COMM_WORLD );
287    
288    if (mpi_info->rank == 0) {    if (mpi_info->rank == 0) {
289       /* get file handle */       /* get file handle */
# Line 263  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 297  Finley_Mesh* Finley_Mesh_read_MPI(char*
297    
298       /* read header */       /* read header */
299       sprintf(frm,"%%%d[^\n]",LenString_MAX-1);       sprintf(frm,"%%%d[^\n]",LenString_MAX-1);
300       fscanf(fileHandle_p, frm, name);       scan_ret = fscanf(fileHandle_p, frm, name);
301         FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
302    
303       /* get the number of nodes */       /* get the number of nodes */
304       fscanf(fileHandle_p, "%1d%*s %d\n", &numDim,&numNodes);       scan_ret = fscanf(fileHandle_p, "%1d%*s %d\n", &numDim,&numNodes);
305         FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
306    }    }
307    
308  #ifdef PASO_MPI  #ifdef PASO_MPI
309    /* MPI Broadcast numDim, numNodes, name if there are multiple MPI procs*/    /* MPI Broadcast numDim, numNodes, name if there are multiple MPI procs*/
310    if (mpi_info->size > 1) {    if (mpi_info->size > 1) {
311      int temp1[3], error_code;      int temp1[3], error_code;
312      temp1[0] = numDim;      if (mpi_info->rank == 0) {
313      temp1[1] = numNodes;         temp1[0] = numDim;
314      temp1[2] = strlen(name) + 1;         temp1[1] = numNodes;
315           temp1[2] = strlen(name) + 1;
316        } else {
317           temp1[0] = 0;
318           temp1[1] = 0;
319           temp1[2] = 1;
320        }
321      error_code = MPI_Bcast (temp1, 3, MPI_INT,  0, mpi_info->comm);      error_code = MPI_Bcast (temp1, 3, MPI_INT,  0, mpi_info->comm);
322      if (error_code != MPI_SUCCESS) {      if (error_code != MPI_SUCCESS) {
323        Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of temp1 failed");        Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of temp1 failed");
# Line 291  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 333  Finley_Mesh* Finley_Mesh_read_MPI(char*
333    }    }
334  #endif  #endif
335    
336    
337       /* allocate mesh */       /* allocate mesh */
338       mesh_p = Finley_Mesh_alloc(name,numDim,order,reduced_order,mpi_info);       mesh_p = Finley_Mesh_alloc(name,numDim,order,reduced_order,mpi_info);
339       if (Finley_noError()) {       if (Finley_noError()) {
# Line 314  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 357  Finley_Mesh* Finley_Mesh_read_MPI(char*
357          chunkNodes = 0;          chunkNodes = 0;
358          for (i1=0; i1<chunkSize; i1++) {          for (i1=0; i1<chunkSize; i1++) {
359            if (totalNodes >= numNodes) break;    /* End of inner loop */            if (totalNodes >= numNodes) break;    /* End of inner loop */
360                if (1 == numDim)                if (1 == numDim) {
361          fscanf(fileHandle_p, "%d %d %d %le\n",          scan_ret = fscanf(fileHandle_p, "%d %d %d %le\n",
362            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],
363            &tempCoords[i1*numDim+0]);            &tempCoords[i1*numDim+0]);
364                if (2 == numDim)          FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
365          fscanf(fileHandle_p, "%d %d %d %le %le\n",            }
366                  if (2 == numDim) {
367            scan_ret = fscanf(fileHandle_p, "%d %d %d %le %le\n",
368            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],
369            &tempCoords[i1*numDim+0], &tempCoords[i1*numDim+1]);            &tempCoords[i1*numDim+0], &tempCoords[i1*numDim+1]);
370                if (3 == numDim)          FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
371          fscanf(fileHandle_p, "%d %d %d %le %le %le\n",            }
372                  if (3 == numDim) {
373            scan_ret = fscanf(fileHandle_p, "%d %d %d %le %le %le\n",
374            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],            &tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1],
375            &tempCoords[i1*numDim+0], &tempCoords[i1*numDim+1], &tempCoords[i1*numDim+2]);            &tempCoords[i1*numDim+0], &tempCoords[i1*numDim+1], &tempCoords[i1*numDim+2]);
376            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
377              }
378            totalNodes++; /* When do we quit the infinite loop? */            totalNodes++; /* When do we quit the infinite loop? */
379            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. */
380          }          }
# Line 395  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 444  Finley_Mesh* Finley_Mesh_read_MPI(char*
444      /* Read the element typeID */      /* Read the element typeID */
445          if (Finley_noError()) {          if (Finley_noError()) {
446        if (mpi_info->rank == 0) {        if (mpi_info->rank == 0) {
447              fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);              scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
448            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
449              typeID=Finley_RefElement_getTypeId(element_type);              typeID=Finley_RefElement_getTypeId(element_type);
450        }        }
451  #ifdef PASO_MPI  #ifdef PASO_MPI
# Line 433  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 483  Finley_Mesh* Finley_Mesh_read_MPI(char*
483          chunkEle = 0;          chunkEle = 0;
484          for (i0=0; i0<chunkSize; i0++) {          for (i0=0; i0<chunkSize; i0++) {
485            if (totalEle >= numEle) break; /* End inner loop */            if (totalEle >= numEle) break; /* End inner loop */
486            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]);
487            for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
488            fscanf(fileHandle_p, "\n");            for (i1 = 0; i1 < numNodes; i1++) {
489            scan_ret = fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);
490                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
491              }
492              scan_ret = fscanf(fileHandle_p, "\n");
493              FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
494            totalEle++;            totalEle++;
495            chunkEle++;            chunkEle++;
496          }          }
# Line 495  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 550  Finley_Mesh* Finley_Mesh_read_MPI(char*
550      /* Read the element typeID */      /* Read the element typeID */
551          if (Finley_noError()) {          if (Finley_noError()) {
552        if (mpi_info->rank == 0) {        if (mpi_info->rank == 0) {
553              fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);              scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
554            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
555              typeID=Finley_RefElement_getTypeId(element_type);              typeID=Finley_RefElement_getTypeId(element_type);
556        }        }
557  #ifdef PASO_MPI  #ifdef PASO_MPI
# Line 533  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 589  Finley_Mesh* Finley_Mesh_read_MPI(char*
589          chunkEle = 0;          chunkEle = 0;
590          for (i0=0; i0<chunkSize; i0++) {          for (i0=0; i0<chunkSize; i0++) {
591            if (totalEle >= numEle) break; /* End inner loop */            if (totalEle >= numEle) break; /* End inner loop */
592            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]);
593            for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
594            fscanf(fileHandle_p, "\n");            for (i1 = 0; i1 < numNodes; i1++) {
595            scan_ret = fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);
596                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
597              }
598              scan_ret = fscanf(fileHandle_p, "\n");
599              FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
600            totalEle++;            totalEle++;
601            chunkEle++;            chunkEle++;
602          }          }
# Line 595  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 656  Finley_Mesh* Finley_Mesh_read_MPI(char*
656      /* Read the element typeID */      /* Read the element typeID */
657          if (Finley_noError()) {          if (Finley_noError()) {
658        if (mpi_info->rank == 0) {        if (mpi_info->rank == 0) {
659              fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);              scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
660            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
661              typeID=Finley_RefElement_getTypeId(element_type);              typeID=Finley_RefElement_getTypeId(element_type);
662        }        }
663  #ifdef PASO_MPI  #ifdef PASO_MPI
# Line 633  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 695  Finley_Mesh* Finley_Mesh_read_MPI(char*
695          chunkEle = 0;          chunkEle = 0;
696          for (i0=0; i0<chunkSize; i0++) {          for (i0=0; i0<chunkSize; i0++) {
697            if (totalEle >= numEle) break; /* End inner loop */            if (totalEle >= numEle) break; /* End inner loop */
698            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]);
699            for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
700            fscanf(fileHandle_p, "\n");            for (i1 = 0; i1 < numNodes; i1++) {
701            scan_ret = fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);
702                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
703              }
704              scan_ret = fscanf(fileHandle_p, "\n");
705              FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
706            totalEle++;            totalEle++;
707            chunkEle++;            chunkEle++;
708          }          }
# Line 695  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 762  Finley_Mesh* Finley_Mesh_read_MPI(char*
762      /* Read the element typeID */      /* Read the element typeID */
763          if (Finley_noError()) {          if (Finley_noError()) {
764        if (mpi_info->rank == 0) {        if (mpi_info->rank == 0) {
765              fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);              scan_ret = fscanf(fileHandle_p, "%s %d\n", element_type, &numEle);
766            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
767              typeID=Finley_RefElement_getTypeId(element_type);              typeID=Finley_RefElement_getTypeId(element_type);
768        }        }
769  #ifdef PASO_MPI  #ifdef PASO_MPI
# Line 733  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 801  Finley_Mesh* Finley_Mesh_read_MPI(char*
801          chunkEle = 0;          chunkEle = 0;
802          for (i0=0; i0<chunkSize; i0++) {          for (i0=0; i0<chunkSize; i0++) {
803            if (totalEle >= numEle) break; /* End inner loop */            if (totalEle >= numEle) break; /* End inner loop */
804            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]);
805            for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
806            fscanf(fileHandle_p, "\n");            for (i1 = 0; i1 < numNodes; i1++) {
807            scan_ret = fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]);
808                FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
809              }
810              scan_ret = fscanf(fileHandle_p, "\n");
811              FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
812            totalEle++;            totalEle++;
813            chunkEle++;            chunkEle++;
814          }          }
# Line 792  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 865  Finley_Mesh* Finley_Mesh_read_MPI(char*
865    
866        /* get the name tags */        /* get the name tags */
867        if (Finley_noError()) {        if (Finley_noError()) {
868          char *remainder, *ptr;          char *remainder=0, *ptr;
869          int tag_key, len, error_code;          size_t len=0;
870          long cur_pos, end_pos;  #ifdef PASO_MPI
871            int len_i;
872    #endif
873            int tag_key;
874          if (mpi_info->rank == 0) {  /* Master */          if (mpi_info->rank == 0) {  /* Master */
875        /* Read the word 'Tag' */        /* Read the word 'Tag' */
876        if (! feof(fileHandle_p)) fscanf(fileHandle_p, "%s\n", name);        if (! feof(fileHandle_p)) {
877            scan_ret = fscanf(fileHandle_p, "%s\n", name);
878            FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
879          }
880    
881    #if defined(_WIN32)  /* windows ftell lies on unix formatted text files */
882    
883          remainder = NULL;
884              len=0;
885          while (1)
886              {
887                 size_t malloc_chunk = 1024;
888                 size_t buff_size = 0;
889                 int ch;
890    
891                 ch = fgetc(fileHandle_p);
892                 if( ch == '\r' )
893                 {
894                    continue;
895                 }
896                 if( len+1 > buff_size )
897                 {
898                    TMPMEMREALLOC(remainder,remainder,buff_size+malloc_chunk,char);
899                 }
900                 if( ch == EOF )
901                 {
902                    /* hit EOF */
903                    remainder[len] = (char)0;
904                    break;
905                 }
906                 remainder[len] = (char)ch;
907                 len++;
908              }
909    #else
910        /* 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 */
911            cur_pos = ftell(fileHandle_p);            {
912            fseek(fileHandle_p, 0L, SEEK_END);               long cur_pos, end_pos;
913            end_pos = ftell(fileHandle_p);  
914            fseek(fileHandle_p, (long)cur_pos, SEEK_SET);               cur_pos = ftell(fileHandle_p);
915        remainder = TMPMEMALLOC(end_pos-cur_pos+1, char);               fseek(fileHandle_p, 0L, SEEK_END);
916        if (! feof(fileHandle_p)) fread(remainder, (size_t) end_pos-cur_pos, sizeof(char), fileHandle_p);               end_pos = ftell(fileHandle_p);
917        remainder[end_pos-cur_pos] = 0;               fseek(fileHandle_p, (long)cur_pos, SEEK_SET);
918        len = strlen(remainder);                   remainder = TMPMEMALLOC(end_pos-cur_pos+1, char);
919        while ((--len)>0 && isspace(remainder[len])) remainder[len]=0;               if (! feof(fileHandle_p))
920                 {
921                    scan_ret = fread(remainder, (size_t) end_pos-cur_pos,
922                                     sizeof(char), fileHandle_p);
923    
924                    FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
925                    remainder[end_pos-cur_pos] = 0;
926                }
927              }
928    #endif
929        len = strlen(remainder);        len = strlen(remainder);
930    /*    while (((--len)>0) && isspace((int)(remainder[len]))) {remainder[len]=0;}  */
931          while ((len>1) && isspace(remainder[--len])) {remainder[len]=0;}
932          len = strlen(remainder);
933              TMPMEMREALLOC(remainder,remainder,len+1,char);
934          }          }
935  #ifdef PASO_MPI  #ifdef PASO_MPI
936          error_code = MPI_Bcast (&len, 1, MPI_INT,  0, mpi_info->comm);  
937          if (error_code != MPI_SUCCESS) {          len_i=(int) len;
938            Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of tag len failed");          if (MPI_Bcast (&len_i, 1, MPI_INT,  0, mpi_info->comm) != MPI_SUCCESS)
939            return NULL;          {
940               Finley_setError(PASO_MPI_ERROR,
941                               "Finley_Mesh_read: broadcast of tag len failed");
942               return NULL;
943          }          }
944            len=(size_t) len_i;
945      if (mpi_info->rank != 0) {      if (mpi_info->rank != 0) {
946        remainder = TMPMEMALLOC(len+1, char);        remainder = TMPMEMALLOC(len+1, char);
947        remainder[0] = 0;        remainder[0] = 0;
948      }      }
949          error_code = MPI_Bcast (remainder, len+1, MPI_CHAR,  0, mpi_info->comm);          if (MPI_Bcast (remainder, len+1, MPI_CHAR,  0, mpi_info->comm) !=
950          if (error_code != MPI_SUCCESS) {              MPI_SUCCESS)
951            Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of tags failed");          {
952            return NULL;             Finley_setError(PASO_MPI_ERROR,
953                               "Finley_Mesh_read: broadcast of tags failed");
954               return NULL;
955          }          }
956  #endif  #endif
957    
958      if (remainder[0]) {      if (remainder[0]) {
959            ptr = remainder;            ptr = remainder;
960            do {            do {

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

  ViewVC Help
Powered by ViewVC 1.1.26