← Back to branch summary

~njansson/dolfin/hpc

« back to all changes in this revision

Viewing changes to src/kernel/io/XMLMesh.cpp

  • Committer: Anders Logg
  • Date: 2007-01-10 09:04:44 UTC
  • mfrom: (1689.1.221 trunk)
  • Revision ID: logg@simula.no-20070110090444-ecyux3n1qnei4i8h
Remove old head

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/kernel/io/XMLMesh.cpp
1
 
// Copyright (C) 2003-2005 Anders Logg.
 
1
// Copyright (C) 2003-2006 Anders Logg.
2
2
// Licensed under the GNU GPL Version 2.
3
3
//
4
4
// First added:  2003-10-21
5
 
// Last changed: 2005-12-19
 
5
// Last changed: 2006-06-22
6
6
 
7
7
#include <dolfin/dolfin_log.h>
 
8
#include <dolfin/CellType.h>
8
9
#include <dolfin/Mesh.h>
9
 
#include <dolfin/Cell.h>
10
 
#include <dolfin/MeshData.h>
11
10
#include <dolfin/XMLMesh.h>
12
11
 
13
12
using namespace dolfin;
14
13
 
15
14
//-----------------------------------------------------------------------------
16
 
XMLMesh::XMLMesh(Mesh& mesh_) : XMLObject(), mesh(mesh_)
17
 
{
18
 
  state = OUTSIDE;
19
 
  vertices = 0;
20
 
  cells = 0;
 
15
XMLMesh::XMLMesh(Mesh& mesh) : XMLObject(), _mesh(mesh), state(OUTSIDE)
 
16
{
 
17
  // Do nothing
 
18
}
 
19
//-----------------------------------------------------------------------------
 
20
XMLMesh::~XMLMesh()
 
21
{
 
22
  // Do nothing
21
23
}
22
24
//-----------------------------------------------------------------------------
23
25
void XMLMesh::startElement(const xmlChar *name, const xmlChar **attrs)
24
26
{
25
 
  //dolfin_debug1("Found start of element \"%s\"", (const char *) name);
26
 
 
27
 
  switch ( state ){
 
27
  switch ( state )
 
28
  {
28
29
  case OUTSIDE:
29
30
    
30
 
    if ( xmlStrcasecmp(name,(xmlChar *) "mesh") == 0 ) {
31
 
      readMesh(name,attrs);
 
31
    if ( xmlStrcasecmp(name, (xmlChar *) "mesh") == 0 )
 
32
    {
 
33
      readMesh(name, attrs);
32
34
      state = INSIDE_MESH;
33
35
    }
34
36
    
36
38
 
37
39
  case INSIDE_MESH:
38
40
    
39
 
    if ( xmlStrcasecmp(name,(xmlChar *) "vertices") == 0 ) {
40
 
      readVertices(name,attrs);
 
41
    if ( xmlStrcasecmp(name, (xmlChar *) "vertices") == 0 )
 
42
    {
 
43
      readVertices(name, attrs);
41
44
      state = INSIDE_VERTICES;
42
45
    }
43
 
    else if ( xmlStrcasecmp(name,(xmlChar *) "cells") == 0 ) {
44
 
      readCells(name,attrs);
 
46
    else if ( xmlStrcasecmp(name, (xmlChar *) "cells") == 0 )
 
47
    {
 
48
      readCells(name, attrs);
45
49
      state = INSIDE_CELLS;
46
50
    }
47
51
    
49
53
    
50
54
  case INSIDE_VERTICES:
51
55
    
52
 
    if ( xmlStrcasecmp(name,(xmlChar *) "vertex") == 0 )
53
 
    {
54
 
      readVertex(name,attrs);
55
 
      state = INSIDE_VERTEX;
56
 
    }
57
 
 
58
 
    break;
59
 
 
60
 
  case INSIDE_VERTEX:
61
 
    
62
 
    if ( xmlStrcasecmp(name,(xmlChar *) "boundaryid") == 0 )
63
 
      readBoundaryID(name,attrs);
64
 
    
 
56
    if ( xmlStrcasecmp(name, (xmlChar *) "vertex") == 0 )
 
57
      readVertex(name, attrs);
 
58
 
65
59
    break;
66
60
    
67
61
  case INSIDE_CELLS:
68
62
    
69
 
    if ( xmlStrcasecmp(name,(xmlChar *) "triangle") == 0 )
70
 
      readTriangle(name,attrs);
71
 
    if ( xmlStrcasecmp(name,(xmlChar *) "tetrahedron") == 0 )
72
 
      readTetrahedron(name,attrs);
 
63
    if ( xmlStrcasecmp(name, (xmlChar *) "interval") == 0 )
 
64
      readInterval(name, attrs);
 
65
    else if ( xmlStrcasecmp(name, (xmlChar *) "triangle") == 0 )
 
66
      readTriangle(name, attrs);
 
67
    else if ( xmlStrcasecmp(name, (xmlChar *) "tetrahedron") == 0 )
 
68
      readTetrahedron(name, attrs);
73
69
    
74
70
    break;
75
71
    
76
72
  default:
77
73
    ;
78
74
  }
79
 
  
80
75
}
81
76
//-----------------------------------------------------------------------------
82
77
void XMLMesh::endElement(const xmlChar *name)
83
78
{
84
 
  //dolfin_debug1("Found end of element \"%s\"", (const char *) name);
85
 
 
86
 
  switch ( state ){
 
79
  switch ( state )
 
80
  {
87
81
  case INSIDE_MESH:
88
82
    
89
 
    if ( xmlStrcasecmp(name,(xmlChar *) "mesh") == 0 ) {
90
 
      initMesh();
91
 
      ok = true;
 
83
    if ( xmlStrcasecmp(name, (xmlChar *) "mesh") == 0 )
 
84
    {
 
85
      closeMesh();
92
86
      state = DONE;
93
87
    }
94
88
    
96
90
    
97
91
  case INSIDE_VERTICES:
98
92
    
99
 
    if ( xmlStrcasecmp(name,(xmlChar *) "vertices") == 0 )
 
93
    if ( xmlStrcasecmp(name, (xmlChar *) "vertices") == 0 )
100
94
      state = INSIDE_MESH;
101
95
    
102
96
    break;
103
97
 
104
 
  case INSIDE_VERTEX:
105
 
    
106
 
    if ( xmlStrcasecmp(name,(xmlChar *) "vertex") == 0 )
107
 
      state = INSIDE_VERTICES;
108
 
    
109
 
    break;
110
 
    
111
98
  case INSIDE_CELLS:
112
99
         
113
 
    if ( xmlStrcasecmp(name,(xmlChar *) "cells") == 0 )
 
100
    if ( xmlStrcasecmp(name, (xmlChar *) "cells") == 0 )
114
101
      state = INSIDE_MESH;
115
102
    
116
103
    break;
118
105
  default:
119
106
    ;
120
107
  }
121
 
  
122
 
}
123
 
//-----------------------------------------------------------------------------
124
 
void XMLMesh::reading(std::string filename)
125
 
{
126
 
  cout << "Reading mesh from file \"" << filename << "\"." << endl;
127
 
}
128
 
//-----------------------------------------------------------------------------
129
 
void XMLMesh::done()
130
 
{
131
 
  //cout << "Reading mesh: " << mesh << endl;
 
108
}
 
109
//-----------------------------------------------------------------------------
 
110
void XMLMesh::open(std::string filename)
 
111
{
 
112
  cout << "Reading mesh from file " << filename << "." << endl;
 
113
}
 
114
//-----------------------------------------------------------------------------
 
115
bool XMLMesh::close()
 
116
{
 
117
  return state == DONE;
132
118
}
133
119
//-----------------------------------------------------------------------------
134
120
void XMLMesh::readMesh(const xmlChar *name, const xmlChar **attrs)
135
121
{
136
 
  mesh.clear();
 
122
  // Parse values
 
123
  std::string type = parseString(name, attrs, "celltype");
 
124
  uint gdim = parseUnsignedInt(name, attrs, "dim");
 
125
  
 
126
  // Create cell type to get topological dimension
 
127
  CellType* cell_type = CellType::create(type);
 
128
  uint tdim = cell_type->dim();
 
129
  delete cell_type;
 
130
 
 
131
  // Open mesh for editing
 
132
  editor.open(_mesh, CellType::string2type(type), tdim, gdim);
137
133
}
138
134
//-----------------------------------------------------------------------------
139
135
void XMLMesh::readVertices(const xmlChar *name, const xmlChar **attrs)
140
136
{
141
 
  // Set default values
142
 
  int size = 0;
143
 
 
144
137
  // Parse values
145
 
  parseIntegerRequired(name, attrs, "size", size);
 
138
  uint num_vertices = parseUnsignedInt(name, attrs, "size");
146
139
 
147
 
  // Set values
148
 
  vertices = size;
 
140
  // Set number of vertices
 
141
  editor.initVertices(num_vertices);
149
142
}
150
143
//-----------------------------------------------------------------------------
151
144
void XMLMesh::readCells(const xmlChar *name, const xmlChar **attrs)
152
145
{
153
 
  // Set default values
154
 
  int size = 0;
155
 
  
156
146
  // Parse values
157
 
  parseIntegerRequired(name, attrs, "size", size);
 
147
  uint num_cells = parseUnsignedInt(name, attrs, "size");
158
148
 
159
 
  // Set values
160
 
  cells = size;
 
149
  // Set number of vertices
 
150
  editor.initCells(num_cells);
161
151
}
162
152
//-----------------------------------------------------------------------------
163
153
void XMLMesh::readVertex(const xmlChar *name, const xmlChar **attrs)
164
154
{
165
 
  // Set default values
166
 
  int id = 0;
167
 
  real x = 0.0;
168
 
  real y = 0.0;
169
 
  real z = 0.0;
 
155
  // Read index
 
156
  uint v = parseUnsignedInt(name, attrs, "index");
170
157
  
171
 
  // Parse values
172
 
  parseIntegerRequired(name, attrs, "name", id);
173
 
  parseRealRequired(name, attrs, "x", x);
174
 
  parseRealRequired(name, attrs, "y", y);
175
 
  parseRealRequired(name, attrs, "z", z);
176
 
 
177
 
  // Set values
178
 
  Vertex &newvertex = mesh.createVertex(x, y, z);
179
 
  vertex = &newvertex;
180
 
 
181
 
  // FIXME: id of vertex is completely ignored. We assume that the
182
 
  // vertices are in correct order.
 
158
  // Handle differently depending on geometric dimension
 
159
  switch ( _mesh.geometry().dim() )
 
160
  {
 
161
  case 1:
 
162
    {
 
163
      real x = parseReal(name, attrs, "x");
 
164
      editor.addVertex(v, x);
 
165
    }
 
166
    break;
 
167
  case 2:
 
168
    {
 
169
      real x = parseReal(name, attrs, "x");
 
170
      real y = parseReal(name, attrs, "y");
 
171
      editor.addVertex(v, x, y);
 
172
    }
 
173
    break;
 
174
  case 3:
 
175
    {
 
176
      real x = parseReal(name, attrs, "x");
 
177
      real y = parseReal(name, attrs, "y");
 
178
      real z = parseReal(name, attrs, "z");
 
179
      editor.addVertex(v, x, y, z);
 
180
    }
 
181
    break;
 
182
  default:
 
183
    dolfin_error("Dimension of mesh must be 1, 2 or 3.");
 
184
  }
183
185
}
184
186
//-----------------------------------------------------------------------------
185
 
void XMLMesh::readBoundaryID(const xmlChar *name, const xmlChar **attrs)
 
187
void XMLMesh::readInterval(const xmlChar *name, const xmlChar **attrs)
186
188
{
187
 
  // Set default values
188
 
  int id = 0;
 
189
  // Check dimension
 
190
  if ( _mesh.topology().dim() != 1 )
 
191
    dolfin_error1("Mesh entity (interval) does not match dimension of mesh (%d).",
 
192
                 _mesh.topology().dim());
 
193
 
 
194
  // Parse values
 
195
  uint c  = parseUnsignedInt(name, attrs, "index");
 
196
  uint v0 = parseUnsignedInt(name, attrs, "v0");
 
197
  uint v1 = parseUnsignedInt(name, attrs, "v1");
189
198
  
190
 
  // Parse values
191
 
  parseIntegerRequired(name, attrs, "name", id);
192
 
 
193
 
  // Add Boundary ID to vertex
194
 
  vertex->nbids.insert(id);
195
 
 
196
 
  // FIXME: id of vertex is completely ignored. We assume that the
197
 
  // vertices are in correct order.
 
199
  // Add cell
 
200
  editor.addCell(c, v0, v1);
198
201
}
199
202
//-----------------------------------------------------------------------------
200
203
void XMLMesh::readTriangle(const xmlChar *name, const xmlChar **attrs)
201
204
{
202
 
  // Set default values
203
 
  int id = 0;
204
 
  int n0 = 0;
205
 
  int n1 = 0;
206
 
  int n2 = 0;
 
205
  // Check dimension
 
206
  if ( _mesh.topology().dim() != 2 )
 
207
    dolfin_error1("Mesh entity (triangle) does not match dimension of mesh (%d).",
 
208
                 _mesh.topology().dim());
 
209
 
 
210
  // Parse values
 
211
  uint c  = parseUnsignedInt(name, attrs, "index");
 
212
  uint v0 = parseUnsignedInt(name, attrs, "v0");
 
213
  uint v1 = parseUnsignedInt(name, attrs, "v1");
 
214
  uint v2 = parseUnsignedInt(name, attrs, "v2");
207
215
  
208
 
  // Parse values
209
 
  parseIntegerRequired(name, attrs, "name", id);
210
 
  parseIntegerRequired(name, attrs, "n0", n0);
211
 
  parseIntegerRequired(name, attrs, "n1", n1);
212
 
  parseIntegerRequired(name, attrs, "n2", n2);
213
 
 
214
 
  // Set values
215
 
  mesh.createCell(n0, n1, n2);
216
 
 
217
 
  // FIXME: id of cell is completely ignored. We assume that the
218
 
  // cells are in correct order.
 
216
  // Add cell
 
217
  editor.addCell(c, v0, v1, v2);
219
218
}
220
219
//-----------------------------------------------------------------------------
221
220
void XMLMesh::readTetrahedron(const xmlChar *name, const xmlChar **attrs)
222
221
{
223
 
  // Set default values
224
 
  int id = 0;
225
 
  int n0 = 0;
226
 
  int n1 = 0;
227
 
  int n2 = 0;
228
 
  int n3 = 0;
 
222
  // Check dimension
 
223
  if ( _mesh.topology().dim() != 3 )
 
224
    dolfin_error1("Mesh entity (tetrahedron) does not match dimension of mesh (%d).",
 
225
                 _mesh.topology().dim());
 
226
 
 
227
  // Parse values
 
228
  uint c  = parseUnsignedInt(name, attrs, "index");
 
229
  uint v0 = parseUnsignedInt(name, attrs, "v0");
 
230
  uint v1 = parseUnsignedInt(name, attrs, "v1");
 
231
  uint v2 = parseUnsignedInt(name, attrs, "v2");
 
232
  uint v3 = parseUnsignedInt(name, attrs, "v3");
229
233
  
230
 
  // Parse values
231
 
  parseIntegerRequired(name, attrs, "name", id);
232
 
  parseIntegerRequired(name, attrs, "n0", n0);
233
 
  parseIntegerRequired(name, attrs, "n1", n1);
234
 
  parseIntegerRequired(name, attrs, "n2", n2);
235
 
  parseIntegerRequired(name, attrs, "n3", n3);
236
 
 
237
 
  // Set values
238
 
  mesh.createCell(n0, n1, n2, n3);
239
 
 
240
 
  // FIXME: id of cell is completely ignored. We assume that the
241
 
  // cells are in correct order.
 
234
  // Add cell
 
235
  editor.addCell(c, v0, v1, v2, v3);
242
236
}
243
237
//-----------------------------------------------------------------------------
244
 
void XMLMesh::initMesh()
 
238
void XMLMesh::closeMesh()
245
239
{
246
 
  // Compute connections
247
 
  mesh.init();
 
240
  editor.close();
248
241
}
249
242
//-----------------------------------------------------------------------------