/[escript]/branches/trilinos_from_5897/dudley/src/Mesh_readGmsh.cpp
ViewVC logotype

Diff of /branches/trilinos_from_5897/dudley/src/Mesh_readGmsh.cpp

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

revision 6078 by caltinay, Wed Mar 2 04:13:26 2016 UTC revision 6079 by caltinay, Mon Mar 21 12:22:38 2016 UTC
# Line 16  Line 16 
16    
17  #include "Mesh.h"  #include "Mesh.h"
18    
19  #include <cstdio>  using escript::IOError;
20    
21  namespace dudley {  namespace dudley {
22    
23  #define MAX_numNodes_gmsh 20  #define MAX_numNodes_gmsh 20
24    
25  /*  reads a mesh from a Dudley file of name fname */  /// reads a mesh from a gmsh file of name filename
26  Dudley_Mesh *Dudley_Mesh_readGmsh(char *fname, index_t numDim, index_t order, index_t reduced_order, bool optimize)  Mesh* Mesh::readGmsh(escript::JMPI mpiInfo, const std::string& filename,
27                         int numDim, bool optimize)
28  {  {
29      double version = 1.0;      double version = 1.0;
30      int format = 0, size = sizeof(double), scan_ret;      int format = 0, size = sizeof(double), scan_ret;
31      dim_t numNodes, totalNumElements = 0, numTags = 0, numNodesPerElement = 0, numNodesPerElement2, element_dim = 0;      dim_t numNodes, totalNumElements = 0, numTags = 0;
32      index_t e, i0, j, gmsh_type, partition_id, itmp, elementary_id;      int numNodesPerElement = 0, numNodesPerElement2, element_dim = 0;
33        index_t gmsh_type, partition_id, itmp, elementary_id;
34      index_t numElements = 0, numFaceElements = 0, *id = NULL, *tag = NULL, *vertices = NULL;      index_t numElements = 0, numFaceElements = 0, *id = NULL, *tag = NULL, *vertices = NULL;
     Dudley_Mesh *mesh_p = NULL;  
35      char line[1024];      char line[1024];
     char error_msg[1024];  
36      double rtmp0, rtmp1;      double rtmp0, rtmp1;
     FILE *fileHandle_p = NULL;  
     Dudley_ElementTypeId *element_type = NULL;  
37    
38      /* No! Bad! take a parameter for this */      if (mpiInfo->size > 1)
     escript::JMPI mpi_info = escript::makeInfo(MPI_COMM_WORLD);  
     if (mpi_info->size > 1)  
39          throw DudleyException("reading GMSH with MPI is not supported yet.");          throw DudleyException("reading GMSH with MPI is not supported yet.");
40    
41      /* allocate mesh */      // allocate mesh
42      mesh_p = Dudley_Mesh_alloc(fname, numDim, mpi_info);      Mesh* mesh = new Mesh(filename, numDim, mpiInfo);
43    
44      /* get file handle */      // open file
45      fileHandle_p = fopen(fname, "r");      FILE* fileHandle = fopen(filename.c_str(), "r");
46      if (fileHandle_p == NULL) {      if (fileHandle == NULL) {
47          sprintf(error_msg, "Opening Gmsh file %s for reading failed.", fname);          std::stringstream ss;
48          throw DudleyException(error_msg);          ss << "Opening gmsh file " << filename << " for reading failed.";
49            throw IOError(ss.str());
50      }      }
51    
52      /* start reading */      // start reading
53      while (1) {      while (1) {
54          /* find line staring with $ */          // find line staring with $
55          do {          do {
56              if (!fgets(line, sizeof(line), fileHandle_p))              if (!fgets(line, sizeof(line), fileHandle))
57                  break;                  break;
58              if (feof(fileHandle_p))              if (feof(fileHandle))
59                  break;                  break;
60          }          } while (line[0] != '$');
         while (line[0] != '$');  
61    
62          if (feof(fileHandle_p))          if (feof(fileHandle))
63              break;              break;
64    
65          /* format */          // format
66          if (!strncmp(&line[1], "MeshFormat", 10)) {          if (!strncmp(&line[1], "MeshFormat", 10)) {
67              scan_ret = fscanf(fileHandle_p, "%lf %d %d\n", &version, &format, &size);              scan_ret = fscanf(fileHandle, "%lf %d %d\n", &version, &format, &size);
68              if (scan_ret == EOF)              if (scan_ret == EOF)
69                  throw DudleyException("readGmsh: early EOF while reading file");                  throw IOError("readGmsh: early EOF while reading file");
70          }          }
71          /* nodes are read */          // nodes
72          if (!strncmp(&line[1], "NOD", 3) || !strncmp(&line[1], "NOE", 3) || !strncmp(&line[1], "Nodes", 5)) {          if (!strncmp(&line[1], "NOD", 3) || !strncmp(&line[1], "NOE", 3) || !strncmp(&line[1], "Nodes", 5)) {
73                scan_ret = fscanf(fileHandle, "%d", &numNodes);
             scan_ret = fscanf(fileHandle_p, "%d", &numNodes);  
74              if (scan_ret == EOF)              if (scan_ret == EOF)
75                  throw DudleyException("readGmsh: early EOF while reading file");                  throw IOError("readGmsh: early EOF while reading file");
76              Dudley_NodeFile_allocTable(mesh_p->Nodes, numNodes);              mesh->Nodes->allocTable(numNodes);
77              for (i0 = 0; i0 < numNodes; i0++)              for (index_t i0 = 0; i0 < numNodes; i0++) {
78              {                  if (1 == numDim) {
79                  if (1 == numDim)                      scan_ret = fscanf(fileHandle, "%d %le %le %le\n",
80                  {                              &mesh->Nodes->Id[i0],
81                      scan_ret = fscanf(fileHandle_p, "%d %le %le %le\n", &mesh_p->Nodes->Id[i0],                              &mesh->Nodes->Coordinates[INDEX2(0, i0, numDim)],
82                                        &mesh_p->Nodes->Coordinates[INDEX2(0, i0, numDim)], &rtmp0, &rtmp1);                              &rtmp0, &rtmp1);
83                      if (scan_ret == EOF)                      if (scan_ret == EOF)
84                          throw DudleyException("readGmsh: early EOF while reading file");                          throw IOError("readGmsh: early EOF while reading file");
85                  }                  } else if (2 == numDim) {
86                  else if (2 == numDim)                      scan_ret = fscanf(fileHandle, "%d %le %le %le\n",
87                  {                              &mesh->Nodes->Id[i0],
88                      scan_ret = fscanf(fileHandle_p, "%d %le %le %le\n", &mesh_p->Nodes->Id[i0],                              &mesh->Nodes->Coordinates[INDEX2(0, i0, numDim)],
89                                        &mesh_p->Nodes->Coordinates[INDEX2(0, i0, numDim)],                              &mesh->Nodes->Coordinates[INDEX2(1, i0, numDim)],
90                                        &mesh_p->Nodes->Coordinates[INDEX2(1, i0, numDim)], &rtmp0);                              &rtmp0);
91                      if (scan_ret == EOF)                      if (scan_ret == EOF)
92                          throw DudleyException("readGmsh: early EOF while reading file");                          throw IOError("readGmsh: early EOF while reading file");
93                  }                  } else if (3 == numDim) {
94                  else if (3 == numDim)                      scan_ret = fscanf(fileHandle, "%d %le %le %le\n",
95                  {                              &mesh->Nodes->Id[i0],
96                      scan_ret = fscanf(fileHandle_p, "%d %le %le %le\n", &mesh_p->Nodes->Id[i0],                              &mesh->Nodes->Coordinates[INDEX2(0, i0, numDim)],
97                                        &mesh_p->Nodes->Coordinates[INDEX2(0, i0, numDim)],                              &mesh->Nodes->Coordinates[INDEX2(1, i0, numDim)],
98                                        &mesh_p->Nodes->Coordinates[INDEX2(1, i0, numDim)],                              &mesh->Nodes->Coordinates[INDEX2(2, i0, numDim)]);
                                       &mesh_p->Nodes->Coordinates[INDEX2(2, i0, numDim)]);  
99                      if (scan_ret == EOF)                      if (scan_ret == EOF)
100                          throw DudleyException("readGmsh: early EOF while reading file");                          throw IOError("readGmsh: early EOF while reading file");
101                  }                  }
102                  mesh_p->Nodes->globalDegreesOfFreedom[i0] = mesh_p->Nodes->Id[i0];                  mesh->Nodes->globalDegreesOfFreedom[i0] = mesh->Nodes->Id[i0];
103                  mesh_p->Nodes->Tag[i0] = 0;                  mesh->Nodes->Tag[i0] = 0;
104              }              }
105          }          }
106          /* elements */          // elements
107          else if (!strncmp(&line[1], "ELM", 3) || !strncmp(&line[1], "Elements", 8))          else if (!strncmp(&line[1], "ELM", 3) || !strncmp(&line[1], "Elements", 8)) {
108          {              ElementTypeId final_element_type = Dudley_NoRef;
109              Dudley_ElementTypeId final_element_type = Dudley_NoRef;              ElementTypeId final_face_element_type = Dudley_NoRef;
             Dudley_ElementTypeId final_face_element_type = Dudley_NoRef;  
110              numElements = 0;              numElements = 0;
111              numFaceElements = 0;              numFaceElements = 0;
112              scan_ret = fscanf(fileHandle_p, "%d", &totalNumElements);              scan_ret = fscanf(fileHandle, "%d", &totalNumElements);
113              if (scan_ret == EOF)              if (scan_ret == EOF)
114                  throw DudleyException("readGmsh: early EOF while reading file");                  throw IOError("readGmsh: early EOF while reading file");
115    
116              id = new index_t[totalNumElements];              id = new index_t[totalNumElements];
117              tag = new index_t[totalNumElements];              tag = new index_t[totalNumElements];
118    
119              element_type = new Dudley_ElementTypeId[totalNumElements];              ElementTypeId* element_type = new ElementTypeId[totalNumElements];
120              vertices = new index_t[totalNumElements * MAX_numNodes_gmsh];              vertices = new index_t[totalNumElements * MAX_numNodes_gmsh];
121              /* read all in */              // read all in
122              for (e = 0; e < totalNumElements; e++)              for (index_t e = 0; e < totalNumElements; e++) {
123              {                  scan_ret = fscanf(fileHandle, "%d %d", &id[e], &gmsh_type);
                 scan_ret = fscanf(fileHandle_p, "%d %d", &id[e], &gmsh_type);  
124                  if (scan_ret == EOF)                  if (scan_ret == EOF)
125                      throw DudleyException("readGmsh: early EOF while reading file");                      throw IOError("readGmsh: early EOF while reading file");
126                  switch (gmsh_type)                  switch (gmsh_type) {
127                  {                      case 1: // line order 1
128                  case 1: /* line order 1 */                          element_type[e] = Dudley_Line2;
129                      element_type[e] = Dudley_Line2;                          element_dim = 1;
130                      element_dim = 1;                          numNodesPerElement = 2;
131                      numNodesPerElement = 2;                          break;
132                      break;                      case 2: // triangle order 1
133                  case 2: /* triangle order 1 */                          element_type[e] = Dudley_Tri3;
134                      element_type[e] = Dudley_Tri3;                          numNodesPerElement = 3;
135                      numNodesPerElement = 3;                          element_dim = 2;
136                      element_dim = 2;                          break;
137                      break;                      case 4: // tetrahedron order 1
138                  case 4: /* tetrahedron order 1 */                          element_type[e] = Dudley_Tet4;
139                      element_type[e] = Dudley_Tet4;                          numNodesPerElement = 4;
140                      numNodesPerElement = 4;                          element_dim = 3;
141                      element_dim = 3;                          break;
142                      break;                      case 15: // point
143                  case 15:        /* point */                          element_type[e] = Dudley_Point1;
144                      element_type[e] = Dudley_Point1;                          numNodesPerElement = 1;
145                      numNodesPerElement = 1;                          element_dim = 0;
146                      element_dim = 0;                          break;
147                      break;                      default: {
148                  default:                          std::stringstream ss;
149                      element_type[e] = Dudley_NoRef;                          ss << "Unexpected gmsh element type " << gmsh_type
150                      sprintf(error_msg, "Unexpected gmsh element type %d in mesh file %s.", gmsh_type, fname);                             << " in mesh file " << filename;
151                      throw DudleyException(error_msg);                          throw IOError(ss.str());
152                        }
153                  }                  }
154                  if (element_dim == numDim)                  if (element_dim == numDim) {
155                  {                      if (final_element_type == Dudley_NoRef) {
                     if (final_element_type == Dudley_NoRef)  
                     {  
156                          final_element_type = element_type[e];                          final_element_type = element_type[e];
157                      }                      } else if (final_element_type != element_type[e]) {
158                      else if (final_element_type != element_type[e])                          throw IOError("Dudley can handle a single type of "
159                      {                                        "internal elements only.");
                         sprintf(error_msg, "Dudley can handle a single type of internal elements only.");  
                         throw DudleyException(error_msg);  
160                      }                      }
161                      numElements++;                      numElements++;
162                  }                  } else if (element_dim == numDim - 1) {
                 else if (element_dim == numDim - 1)  
                 {  
163                      if (final_face_element_type == Dudley_NoRef) {                      if (final_face_element_type == Dudley_NoRef) {
164                          final_face_element_type = element_type[e];                          final_face_element_type = element_type[e];
165                      } else if (final_face_element_type != element_type[e]) {                      } else if (final_face_element_type != element_type[e]) {
166                          sprintf(error_msg, "Dudley can handle a single type of face elements only.");                          throw IOError("Dudley can handle a single type of "
167                          throw DudleyException(error_msg);                                        "face elements only.");
168                      }                      }
169                      numFaceElements++;                      numFaceElements++;
170                  }                  }
171    
172                  if (version <= 1.0) {                  if (version <= 1.0) {
173                      scan_ret = fscanf(fileHandle_p, "%d %d %d", &tag[e], &elementary_id, &numNodesPerElement2);                      scan_ret = fscanf(fileHandle, "%d %d %d", &tag[e],
174                                          &elementary_id, &numNodesPerElement2);
175                      if (scan_ret == EOF)                      if (scan_ret == EOF)
176                          throw DudleyException("readGmsh: early EOF while reading file");                          throw IOError("readGmsh: early EOF while reading file");
177                      partition_id = 1;                      partition_id = 1;
178                      if (numNodesPerElement2 != numNodesPerElement) {                      if (numNodesPerElement2 != numNodesPerElement) {
179                          sprintf(error_msg, "Illegal number of nodes for element %d in mesh file %s.", id[e],                          std::stringstream ss;
180                                  fname);                          ss << "Illegal number of nodes for element " << id[e]
181                          throw DudleyException(error_msg);                              << " in mesh file " << filename;
182                            throw IOError(ss.str());
183                      }                      }
184                  } else {                  } else {
185                      scan_ret = fscanf(fileHandle_p, "%d", &numTags);                      scan_ret = fscanf(fileHandle, "%d", &numTags);
186                      if (scan_ret == EOF)                      if (scan_ret == EOF)
187                          throw DudleyException("readGmsh: early EOF while reading file");                          throw IOError("readGmsh: early EOF while reading file");
188                      elementary_id = tag[e] = partition_id = 1;                      elementary_id = tag[e] = partition_id = 1;
189                      numNodesPerElement2 = -1;                      numNodesPerElement2 = -1;
190                      for (j = 0; j < numTags; j++) {                      for (int j = 0; j < numTags; j++) {
191                          scan_ret = fscanf(fileHandle_p, "%d", &itmp);                          scan_ret = fscanf(fileHandle, "%d", &itmp);
192                          if (scan_ret == EOF)                          if (scan_ret == EOF)
193                              throw DudleyException("readGmsh: early EOF while reading file");                              throw IOError("readGmsh: early EOF while reading file");
194                          if (j == 0) {                          if (j == 0) {
195                              tag[e] = itmp;                              tag[e] = itmp;
196                          } else if (j == 1) {                          } else if (j == 1) {
# Line 209  Dudley_Mesh *Dudley_Mesh_readGmsh(char * Line 198  Dudley_Mesh *Dudley_Mesh_readGmsh(char *
198                          } else if (j == 2) {                          } else if (j == 2) {
199                              partition_id = itmp;                              partition_id = itmp;
200                          }                          }
201                          /* ignore any other tags */                          // ignore any other tags
202                      }                      }
203                  }                  }
204                  for (j = 0; j < numNodesPerElement; j++)                  for (int j = 0; j < numNodesPerElement; j++) {
205                  {                      scan_ret = fscanf(fileHandle, "%d",
206                      scan_ret = fscanf(fileHandle_p, "%d", &vertices[INDEX2(j, e, MAX_numNodes_gmsh)]);                              &vertices[INDEX2(j, e, MAX_numNodes_gmsh)]);
207                      if (scan_ret == EOF)                      if (scan_ret == EOF)
208                          throw DudleyException("readGmsh: early EOF while reading file");                          throw IOError("readGmsh: early EOF while reading file");
209                  }                  }
210              }              }
211              /* all elements have been read, now we have to identify the elements for dudley */              // all elements have been read, now we have to identify the
212                // dudley elements to define Elements and FaceElements
             /* first we have to identify the elements to define Elements and FaceElements */  
213              if (final_element_type == Dudley_NoRef) {              if (final_element_type == Dudley_NoRef) {
214                  if (numDim == 1) {                  if (numDim == 1) {
215                      final_element_type = Dudley_Line2;                      final_element_type = Dudley_Line2;
# Line 240  Dudley_Mesh *Dudley_Mesh_readGmsh(char * Line 228  Dudley_Mesh *Dudley_Mesh_readGmsh(char *
228                      final_face_element_type = Dudley_Tri3;                      final_face_element_type = Dudley_Tri3;
229                  }                  }
230              }              }
231              mesh_p->Elements = Dudley_ElementFile_alloc(final_element_type, mpi_info);              mesh->Elements = new ElementFile(final_element_type, mpiInfo);
232              mesh_p->FaceElements = Dudley_ElementFile_alloc(final_face_element_type, mpi_info);              mesh->FaceElements = new ElementFile(final_face_element_type, mpiInfo);
233              mesh_p->Points = Dudley_ElementFile_alloc(Dudley_Point1, mpi_info);              mesh->Points = new ElementFile(Dudley_Point1, mpiInfo);
234              Dudley_ElementFile_allocTable(mesh_p->Elements, numElements);              mesh->Elements->allocTable(numElements);
235              Dudley_ElementFile_allocTable(mesh_p->FaceElements, numFaceElements);              mesh->FaceElements->allocTable(numFaceElements);
236              Dudley_ElementFile_allocTable(mesh_p->Points, 0);              mesh->Points->allocTable(0);
237              mesh_p->Elements->minColor = 0;              mesh->Elements->minColor = 0;
238              mesh_p->Elements->maxColor = numElements - 1;              mesh->Elements->maxColor = numElements - 1;
239              mesh_p->FaceElements->minColor = 0;              mesh->FaceElements->minColor = 0;
240              mesh_p->FaceElements->maxColor = numFaceElements - 1;              mesh->FaceElements->maxColor = numFaceElements - 1;
241              mesh_p->Points->minColor = 0;              mesh->Points->minColor = 0;
242              mesh_p->Points->maxColor = 0;              mesh->Points->maxColor = 0;
243              numElements = 0;              numElements = 0;
244              numFaceElements = 0;              numFaceElements = 0;
245              for (e = 0; e < totalNumElements; e++)              for (index_t e = 0; e < totalNumElements; e++) {
246              {                  if (element_type[e] == final_element_type) {
247                  if (element_type[e] == final_element_type)                      mesh->Elements->Id[numElements] = id[e];
248                  {                      mesh->Elements->Tag[numElements] = tag[e];
249                      mesh_p->Elements->Id[numElements] = id[e];                      mesh->Elements->Color[numElements] = numElements;
250                      mesh_p->Elements->Tag[numElements] = tag[e];                      mesh->Elements->Owner[numElements] = 0;
251                      mesh_p->Elements->Color[numElements] = numElements;                      for (int j = 0; j < mesh->Elements->numNodes; ++j) {
252                      mesh_p->Elements->Owner[numElements] = 0;                          mesh->Elements->Nodes[INDEX2(j, numElements,
253                      for (j = 0; j < mesh_p->Elements-> /*referenceElementSet-> */ numNodes; ++j)                                                   mesh->Elements->numNodes)] =
                     {  
                         mesh_p->Elements->Nodes[INDEX2  
                                                 (j, numElements,  
                                                  mesh_p->  
                                                  Elements-> /*referenceElementSet-> */ numNodes)] =  
254                              vertices[INDEX2(j, e, MAX_numNodes_gmsh)];                              vertices[INDEX2(j, e, MAX_numNodes_gmsh)];
255                      }                      }
256                      numElements++;                      numElements++;
257                  }                  } else if (element_type[e] == final_face_element_type) {
258                  else if (element_type[e] == final_face_element_type)                      mesh->FaceElements->Id[numFaceElements] = id[e];
259                  {                      mesh->FaceElements->Tag[numFaceElements] = tag[e];
260                      mesh_p->FaceElements->Id[numFaceElements] = id[e];                      mesh->FaceElements->Color[numFaceElements] = numFaceElements;
261                      mesh_p->FaceElements->Tag[numFaceElements] = tag[e];                      mesh->FaceElements->Owner[numFaceElements] = 0;
262                      mesh_p->FaceElements->Color[numFaceElements] = numFaceElements;                      for (int j = 0; j < mesh->FaceElements->numNodes; ++j)
                     mesh_p->FaceElements->Owner[numFaceElements] = 0;  
                     for (j = 0; j < mesh_p->FaceElements-> /*referenceElementSet-> */ numNodes; ++j)  
263                      {                      {
264                          mesh_p->FaceElements->Nodes[INDEX2                          mesh->FaceElements->Nodes[INDEX2(j, numFaceElements,
265                                                      (j, numFaceElements,                                                mesh->FaceElements->numNodes)] =
                                                      mesh_p->  
                                                      FaceElements-> /*referenceElementSet-> */  
                                                      numNodes)] =  
266                              vertices[INDEX2(j, e, MAX_numNodes_gmsh)];                              vertices[INDEX2(j, e, MAX_numNodes_gmsh)];
267                      }                      }
268                      numFaceElements++;                      numFaceElements++;
269                  }                  }
270              }              }
271              /* and clean up */              // and clean up
272              delete[] id;              delete[] id;
273              delete[] tag;              delete[] tag;
274              delete[] element_type;              delete[] element_type;
275              delete[] vertices;              delete[] vertices;
276          }                } // end reading elements  
277          /* name tags (thanks to Antoine Lefebvre, antoine.lefebvre2@mail.mcgill.ca ) */          // name tags (thanks to Antoine Lefebvre, antoine.lefebvre2@mail.mcgill.ca )
278          else if (!strncmp(&line[1], "PhysicalNames", 13)) {          else if (!strncmp(&line[1], "PhysicalNames", 13)) {
279              char name[1024];              char name[1024];
280              index_t tag_key;              index_t tag_key;
281              scan_ret = fscanf(fileHandle_p, "%d", &numTags);              scan_ret = fscanf(fileHandle, "%d", &numTags);
282              if (scan_ret == EOF)              if (scan_ret == EOF)
283                  throw DudleyException("readGmsh: early EOF while reading file");                  throw IOError("readGmsh: early EOF while reading file");
284              for (i0 = 0; i0 < numTags; i0++) {              for (int i0 = 0; i0 < numTags; i0++) {
285                  scan_ret = fscanf(fileHandle_p, "%d %d %s\n", &itmp, &tag_key, name);                  scan_ret = fscanf(fileHandle, "%d %d %s\n", &itmp, &tag_key, name);
286                  if (scan_ret == EOF)                  if (scan_ret == EOF)
287                      throw DudleyException("readGmsh: early EOF while reading file");                      throw IOError("readGmsh: early EOF while reading file");
288                  if (itmp != 2)                  if (itmp != 2)
289                      throw DudleyException("Dudley_Mesh_readGmsh: expecting two entries per physical name.");                      throw IOError("readGmsh: expecting two entries per physical name.");
290                  if (strlen(name) < 3)                  if (strlen(name) < 3)
291                      throw DudleyException("Dudley_Mesh_readGmsh: illegal tagname (\" missing?)");                      throw IOError("readGmsh: illegal tagname (\" missing?)");
292                  name[strlen(name)-1]='\0';                  name[strlen(name)-1]='\0';
293                  Dudley_Mesh_addTagMap(mesh_p,&name[1],tag_key);                  mesh->addTagMap(&name[1], tag_key);
294              }              }
295            }          }
296          /* search for end of data block */          // search for end of data block
297          do          do {
298          {              if (!fgets(line, sizeof(line), fileHandle)) {
299              if (!fgets(line, sizeof(line), fileHandle_p)) {                  std::stringstream ss;
300                  sprintf(error_msg, "Unexpected end of file in %s", fname);                  ss << "Unexpected end of file in " << filename;
301                  throw DudleyException(error_msg);                  throw IOError(ss.str());
302              }              }
303              if (feof(fileHandle_p)) {              if (feof(fileHandle)) {
304                  sprintf(error_msg, "Unexpected end of file in %s", fname);                  std::stringstream ss;
305                  throw DudleyException(error_msg);                  ss << "Unexpected end of file in " << filename;
306                    throw IOError(ss.str());
307              }              }
308          }          } while (line[0] != '$');
         while (line[0] != '$');  
309      }      }
310    
311      fclose(fileHandle_p);      fclose(fileHandle);
312      Dudley_Mesh_resolveNodeIds(mesh_p);      mesh->resolveNodeIds();
313      Dudley_Mesh_prepare(mesh_p, optimize);      mesh->prepare(optimize);
314      return mesh_p;      return mesh;
315  }  }
316    
317  } // namespace dudley  } // namespace dudley

Legend:
Removed from v.6078  
changed lines
  Added in v.6079

  ViewVC Help
Powered by ViewVC 1.1.26