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

Legend:
Removed from v.6008  
changed lines
  Added in v.6009

  ViewVC Help
Powered by ViewVC 1.1.26