~corrado-maurini/dolfin/tao

« back to all changes in this revision

Viewing changes to dolfin/io/XMLMesh.cpp

• browse files at revision 6721
• compare with another revision
• download diff
• download tarball
• view history from revision 6721

Show diffs side-by-side

added

removed

dolfin/io/XMLMesh.cpp

89

89

{

90

90

  // Get cell type and geometric dimension

91

91

  const std::string cell_type_str = mesh_node.attribute("celltype").value();

92

 

  const unsigned int gdim = mesh_node.attribute("dim").as_uint();

 

92

  const std::size_t gdim = mesh_node.attribute("dim").as_uint();

93

93

 

94

94

  // Get topological dimension

95

95

  boost::scoped_ptr<CellType> cell_type(CellType::create(cell_type_str));

96

 

  const unsigned int tdim = cell_type->dim();

 

96

  const std::size_t tdim = cell_type->dim();

97

97

 

98

98

  // Create mesh for editing

99

99

  MeshEditor editor;

104

104

  dolfin_assert(xml_vertices);

105

105

 

106

106

  // Get number of vertices and init editor

107

 

  const unsigned int num_vertices = xml_vertices.attribute("size").as_uint();

 

107

  const std::size_t num_vertices = xml_vertices.attribute("size").as_uint();

108

108

  editor.init_vertices(num_vertices);

109

109

 

110

110

  // Iterate over vertices and add to mesh

112

112

  for (pugi::xml_node_iterator it = xml_vertices.begin();

113

113

       it != xml_vertices.end(); ++it)

114

114

  {

115

 

    const unsigned int index = it->attribute("index").as_uint();

 

115

    const std::size_t index = it->attribute("index").as_uint();

116

116

    p[0] = it->attribute("x").as_double();

117

117

    p[1] = it->attribute("y").as_double();

118

118

    p[2] = it->attribute("z").as_double();

124

124

  dolfin_assert(xml_cells);

125

125

 

126

126

  // Get number of cells and init editor

127

 

  const unsigned int num_cells = xml_cells.attribute("size").as_uint();

 

127

  const std::size_t num_cells = xml_cells.attribute("size").as_uint();

128

128

  editor.init_cells(num_cells);

129

129

 

130

130

  // Create list of vertex index attribute names

131

131

  const unsigned int num_vertices_per_cell = cell_type->num_vertices(tdim);

132

132

  std::vector<std::string> v_str(num_vertices_per_cell);

133

 

  for (uint i = 0; i < num_vertices_per_cell; ++i)

 

133

  for (std::size_t i = 0; i < num_vertices_per_cell; ++i)

134

134

    v_str[i] = "v" + boost::lexical_cast<std::string, unsigned int>(i);

135

135

 

136

136

  // Iterate over cells and add to mesh

137

 

  std::vector<unsigned int> v(num_vertices_per_cell);

 

137

  std::vector<std::size_t> v(num_vertices_per_cell);

138

138

  for (pugi::xml_node_iterator it = xml_cells.begin(); it != xml_cells.end(); ++it)

139

139

  {

140

 

    const unsigned int index = it->attribute("index").as_uint();

 

140

    const std::size_t index = it->attribute("index").as_uint();

141

141

    for (unsigned int i = 0; i < num_vertices_per_cell; ++i)

142

142

      v[i] = it->attribute(v_str[i].c_str()).as_uint();

143

143

    editor.add_cell(index, v);

188

188

      if (data_type == "uint")

189

189

      {

190

190

        // Get vector from MeshData

191

 

        boost::shared_ptr<std::vector<unsigned int> >

 

191

        boost::shared_ptr<std::vector<std::size_t> >

192

192

          array = data.array(data_set_name);

193

193

        if (!array)

194

194

          array = data.create_array(data_set_name);

208

208

    {

209

209

      // Get MeshFunction from MeshData

210

210

      const std::string data_type = data_set.attribute("type").value();

211

 

      boost::shared_ptr<MeshFunction<unsigned int> >

 

211

      boost::shared_ptr<MeshFunction<std::size_t> >

212

212

        mf = data.mesh_function(data_set_name);

213

213

      if (!mf)

214

214

        mf = data.create_mesh_function(data_set_name);

257

257

 

258

258

    // Get attributes

259

259

    const std::string type = it->attribute("type").value();

260

 

    const uint dim = it->attribute("dim").as_uint();

 

260

    const std::size_t dim = it->attribute("dim").as_uint();

261

261

 

262

262

    // Check that the type is uint

263

263

    if (type != "uint")

274

274

  }

275

275

}

276

276

//-----------------------------------------------------------------------------

277

 

void XMLMesh::read_array_uint(std::vector<unsigned int>& array,

 

277

void XMLMesh::read_array_uint(std::vector<std::size_t>& array,

278

278

                              const pugi::xml_node xml_array)

279

279

{

280

280

  // Check that we have an array

296

296

  }

297

297

 

298

298

  // Get size and resize vector

299

 

  const unsigned int size = xml_array.attribute("size").as_uint();

 

299

  const std::size_t size = xml_array.attribute("size").as_uint();

300

300

  array.resize(size);

301

301

 

302

302

  // Iterate over array entries

303

303

  for (pugi::xml_node_iterator it = xml_array.begin(); it !=xml_array.end(); ++it)

304

304

  {

305

 

    const unsigned int index = it->attribute("index").as_uint();

 

305

    const std::size_t index = it->attribute("index").as_uint();

306

306

    const double value = it->attribute("value").as_uint();

307

307

    dolfin_assert(index < size);

308

308

    array[index] = value;

315

315

  const CellType::Type _cell_type = mesh.type().cell_type();

316

316

  const std::string cell_type = CellType::type2string(_cell_type);

317

317

  mesh_node.append_attribute("celltype") = cell_type.c_str();

318

 

  mesh_node.append_attribute("dim") = mesh.geometry().dim();

 

318

  mesh_node.append_attribute("dim") = (unsigned int) mesh.geometry().dim();

319

319

 

320

320

  // Add vertices node

321

321

  pugi::xml_node vertices_node = mesh_node.append_child("vertices");

322

 

  vertices_node.append_attribute("size") = mesh.num_vertices();

 

322

  vertices_node.append_attribute("size") = (unsigned int) mesh.num_vertices();

323

323

 

324

324

  // Write each vertex

325

325

  for (VertexIterator v(mesh); !v.end(); ++v)

326

326

  {

327

327

    pugi::xml_node vertex_node = vertices_node.append_child("vertex");

328

 

    vertex_node.append_attribute("index") = v->index();

 

328

    vertex_node.append_attribute("index") = (unsigned int) v->index();

329

329

 

330

330

    const Point p = v->point();

331

331

    switch (mesh.geometry().dim())

357

357

 

358

358

  // Add cells node

359

359

  pugi::xml_node cells_node = mesh_node.append_child("cells");

360

 

  cells_node.append_attribute("size") = mesh.num_cells();

 

360

  cells_node.append_attribute("size") = (unsigned int) mesh.num_cells();

361

361

 

362

362

  // Add each cell

363

363

  for (CellIterator c(mesh); !c.end(); ++c)

364

364

  {

365

365

    pugi::xml_node cell_node = cells_node.append_child(cell_type.c_str());

366

 

    cell_node.append_attribute("index") = c->index();

 

366

    cell_node.append_attribute("index") = (unsigned int) c->index();

367

367

 

368

 

    const uint* vertices = c->entities(0);

 

368

    const std::size_t* vertices = c->entities(0);

369

369

    dolfin_assert(vertices);

370

370

 

371

371

    switch (_cell_type)

372

372

    {

373

373

    case CellType::interval:

374

 

      cell_node.append_attribute("v0") = vertices[0];

375

 

      cell_node.append_attribute("v1") = vertices[1];

 

374

      cell_node.append_attribute("v0") = (unsigned int) vertices[0];

 

375

      cell_node.append_attribute("v1") = (unsigned int) vertices[1];

376

376

      break;

377

377

    case CellType::triangle:

378

 

      cell_node.append_attribute("v0") = vertices[0];

379

 

      cell_node.append_attribute("v1") = vertices[1];

380

 

      cell_node.append_attribute("v2") = vertices[2];

 

378

      cell_node.append_attribute("v0") = (unsigned int) vertices[0];

 

379

      cell_node.append_attribute("v1") = (unsigned int) vertices[1];

 

380

      cell_node.append_attribute("v2") = (unsigned int) vertices[2];

381

381

      break;

382

382

    case CellType::tetrahedron:

383

 

      cell_node.append_attribute("v0") = vertices[0];

384

 

      cell_node.append_attribute("v1") = vertices[1];

385

 

      cell_node.append_attribute("v2") = vertices[2];

386

 

      cell_node.append_attribute("v3") = vertices[3];

 

383

      cell_node.append_attribute("v0") = (unsigned int) vertices[0];

 

384

      cell_node.append_attribute("v1") = (unsigned int) vertices[1];

 

385

      cell_node.append_attribute("v2") = (unsigned int) vertices[2];

 

386

      cell_node.append_attribute("v3") = (unsigned int) vertices[3];

387

387

      break;

388

388

    default:

389

389

      dolfin_error("XMLMesh.cpp",

404

404

 

405

405

  // Write mesh functions

406

406

  typedef std::map<std::string,

407

 

                   boost::shared_ptr<MeshFunction<uint> > >

 

407

                   boost::shared_ptr<MeshFunction<std::size_t> > >

408

408

    ::const_iterator mf_iterator;

409

409

  for (mf_iterator it = data.mesh_functions.begin();

410

410

       it != data.mesh_functions.end(); ++it)

411

411

  {

412

412

    std::string name = it->first;

413

 

    boost::shared_ptr<MeshFunction<unsigned int> > mf = it->second;

 

413

    boost::shared_ptr<MeshFunction<std::size_t> > mf = it->second;

414

414

    dolfin_assert(mf);

415

415

 

416

416

    pugi::xml_node data_entry_node = mesh_data_node.append_child("data_entry");

418

418

 

419

419

    pugi::xml_node mf_node = data_entry_node.append_child("mesh_function");

420

420

    mf_node.append_attribute("type") = "uint";

421

 

    mf_node.append_attribute("dim") = mf->dim();

422

 

    mf_node.append_attribute("size") = mf->size();

 

421

    mf_node.append_attribute("dim") = (unsigned int) mf->dim();

 

422

    mf_node.append_attribute("size") = (unsigned int) mf->size();

423

423

 

424

 

    for (uint i = 0; i < mf->size(); i++)

 

424

    for (std::size_t i = 0; i < mf->size(); i++)

425

425

    {

426

426

      pugi::xml_node entity_node = mf_node.append_child("entity");

427

 

      entity_node.append_attribute("index") = i;

428

 

      entity_node.append_attribute("value") = (*mf)[i];

 

427

      entity_node.append_attribute("index") = (unsigned int) i;

 

428

      entity_node.append_attribute("value") = (unsigned int) (*mf)[i];

429

429

    }

430

430

  }

431

431

 

432

432

  // Write arrays

433

433

  typedef std::map<std::string,

434

 

                   boost::shared_ptr<std::vector<uint> > >

 

434

                   boost::shared_ptr<std::vector<std::size_t> > >

435

435

    ::const_iterator array_iterator;

436

436

  for (array_iterator it = data.arrays.begin(); it != data.arrays.end(); ++it)

437

437

  {

438

438

    std::string name = it->first;

439

 

    boost::shared_ptr<std::vector<unsigned int> > array = it->second;

 

439

    boost::shared_ptr<std::vector<std::size_t> > array = it->second;

440

440

    dolfin_assert(array);

441

441

 

442

442

    pugi::xml_node data_entry_node = mesh_data_node.append_child("data_entry");

444

444

 

445

445

    pugi::xml_node array_node = data_entry_node.append_child("array");

446

446

    array_node.append_attribute("type") = "uint";

447

 

    array_node.append_attribute("size") = static_cast<uint>(array->size());

 

447

    array_node.append_attribute("size") = static_cast<unsigned int>(array->size());

448

448

 

449

 

    for (uint i = 0; i < array->size(); i++)

 

449

    for (std::size_t i = 0; i < array->size(); i++)

450

450

    {

451

451

      pugi::xml_node element_node = array_node.append_child("element");

452

 

      element_node.append_attribute("index") = i;

453

 

      element_node.append_attribute("value") = (*array)[i];

 

452

      element_node.append_attribute("index") = (unsigned int) i;

 

453

      element_node.append_attribute("value") = (unsigned int) (*array)[i];

454

454

    }

455

455

  }

456

456

}

466

466

  pugi::xml_node domains_node = mesh_node.append_child("domains");

467

467

 

468

468

  // Write mesh markers

469

 

  for (uint d = 0; d <= domains.max_dim(); d++)

 

469

  for (std::size_t d = 0; d <= domains.max_dim(); d++)

470

470

  {

471

471

    dolfin_assert(domains.markers(d));

472

472

    if (!domains.markers(d)->empty())

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1