void VTKIO::cells_to_vtk()
{
const MeshBase& mesh = MeshOutput<MeshBase>::mesh();
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkIdList> pts = vtkSmartPointer<vtkIdList>::New();
std::vector<int> types(mesh.n_active_local_elem());
unsigned active_element_counter = 0;
vtkSmartPointer<vtkIntArray> elem_id = vtkSmartPointer<vtkIntArray>::New();
elem_id->SetName("libmesh_elem_id");
elem_id->SetNumberOfComponents(1);
vtkSmartPointer<vtkIntArray> subdomain_id = vtkSmartPointer<vtkIntArray>::New();
subdomain_id->SetName("subdomain_id");
subdomain_id->SetNumberOfComponents(1);
MeshBase::const_element_iterator it = mesh.active_local_elements_begin();
const MeshBase::const_element_iterator end = mesh.active_local_elements_end();
for (; it != end; ++it, ++active_element_counter)
{
Elem *elem = *it;
pts->SetNumberOfIds(elem->n_nodes());
// get the connectivity for this element
std::vector<dof_id_type> conn;
elem->connectivity(0, VTK, conn);
for (unsigned int i=0; i<conn.size(); ++i)
{
// If the node ID is not found in the _local_node_map, we'll
// add it to the _vtk_grid. NOTE[JWP]: none of the examples
// I have actually enters this section of code...
if (_local_node_map.find(conn[i]) == _local_node_map.end())
{
dof_id_type global_node_id = elem->node(i);
const Node* the_node = mesh.node_ptr(global_node_id);
// Error checking...
if (the_node == NULL)
{
libMesh::err << "Error getting pointer to node "
<< global_node_id
<< "!" << std::endl;
libmesh_error();
}
// InsertNextPoint accepts either a double or float array of length 3.
Real pt[3] = {0., 0., 0.};
for (unsigned int d=0; d<LIBMESH_DIM; ++d)
pt[d] = (*the_node)(d);
// Insert the point into the _vtk_grid
vtkIdType local = _vtk_grid->GetPoints()->InsertNextPoint(pt);
// Update the _local_node_map with the ID returned by VTK
_local_node_map[global_node_id] = local;
}
// Otherwise, the node ID was found in the _local_node_map, so
// insert it into the vtkIdList.
pts->InsertId(i, _local_node_map[conn[i]]);
}
vtkIdType vtkcellid = cells->InsertNextCell(pts);
types[active_element_counter] = this->get_elem_type(elem->type());
elem_id->InsertTuple1(vtkcellid, elem->id());
subdomain_id->InsertTuple1(vtkcellid, elem->subdomain_id());
} // end loop over active elements
_vtk_grid->SetCells(&types[0], cells);
_vtk_grid->GetCellData()->AddArray(elem_id);
_vtk_grid->GetCellData()->AddArray(subdomain_id);
}
void VTKIO::read (const std::string& name)
{
// This is a serial-only process for now;
// the Mesh should be read on processor 0 and
// broadcast later
libmesh_assert_equal_to (MeshOutput<MeshBase>::mesh().processor_id(), 0);
// Keep track of what kinds of elements this file contains
elems_of_dimension.clear();
elems_of_dimension.resize(4, false);
#ifndef LIBMESH_HAVE_VTK
libMesh::err << "Cannot read VTK file: " << name
<< "\nYou must have VTK installed and correctly configured to read VTK meshes."
<< std::endl;
libmesh_error();
#else
// Use a typedef, because these names are just crazy
typedef vtkSmartPointer<vtkXMLUnstructuredGridReader> MyReader;
MyReader reader = MyReader::New();
// Pass the filename along to the reader
reader->SetFileName( name.c_str() );
// Force reading
reader->Update();
// read in the grid
_vtk_grid = reader->GetOutput();
// _vtk_grid->Update(); // FIXME: Necessary?
// Get a reference to the mesh
MeshBase& mesh = MeshInput<MeshBase>::mesh();
// Clear out any pre-existing data from the Mesh
mesh.clear();
// Get the number of points from the _vtk_grid object
const unsigned int vtk_num_points = static_cast<unsigned int>(_vtk_grid->GetNumberOfPoints());
// always numbered nicely??, so we can loop like this
// I'm pretty sure it is numbered nicely
for (unsigned int i=0; i<vtk_num_points; ++i)
{
// add to the id map
// and add the actual point
double * pnt = _vtk_grid->GetPoint(static_cast<vtkIdType>(i));
Point xyz(pnt[0], pnt[1], pnt[2]);
Node* newnode = mesh.add_point(xyz, i);
// Add node to the nodes vector &
// tell the MeshData object the foreign node id.
if (this->_mesh_data != NULL)
this->_mesh_data->add_foreign_node_id (newnode, i);
}
// Get the number of cells from the _vtk_grid object
const unsigned int vtk_num_cells = static_cast<unsigned int>(_vtk_grid->GetNumberOfCells());
for (unsigned int i=0; i<vtk_num_cells; ++i)
{
vtkCell* cell = _vtk_grid->GetCell(i);
Elem* elem = NULL;
switch (cell->GetCellType())
{
case VTK_LINE:
elem = new Edge2;
break;
case VTK_QUADRATIC_EDGE:
elem = new Edge3;
break;
case VTK_TRIANGLE:
elem = new Tri3();
break;
case VTK_QUADRATIC_TRIANGLE:
elem = new Tri6();
break;
case VTK_QUAD:
elem = new Quad4();
break;
case VTK_QUADRATIC_QUAD:
elem = new Quad8();
break;
#if VTK_MAJOR_VERSION > 5 || (VTK_MAJOR_VERSION == 5 && VTK_MINOR_VERSION > 0)
case VTK_BIQUADRATIC_QUAD:
elem = new Quad9();
break;
#endif
case VTK_TETRA:
elem = new Tet4();
break;
case VTK_QUADRATIC_TETRA:
elem = new Tet10();
break;
case VTK_WEDGE:
elem = new Prism6();
break;
case VTK_QUADRATIC_WEDGE:
elem = new Prism15();
break;
case VTK_BIQUADRATIC_QUADRATIC_WEDGE:
elem = new Prism18();
break;
case VTK_HEXAHEDRON:
elem = new Hex8();
break;
case VTK_QUADRATIC_HEXAHEDRON:
elem = new Hex20();
break;
case VTK_TRIQUADRATIC_HEXAHEDRON:
elem = new Hex27();
break;
case VTK_PYRAMID:
elem = new Pyramid5();
break;
default:
libMesh::err << "element type not implemented in vtkinterface " << cell->GetCellType() << std::endl;
libmesh_error();
break;
}
// get the straightforward numbering from the VTK cells
for (unsigned int j=0; j<elem->n_nodes(); ++j)
elem->set_node(j) = mesh.node_ptr(cell->GetPointId(j));
// then get the connectivity
std::vector<dof_id_type> conn;
elem->connectivity(0, VTK, conn);
// then reshuffle the nodes according to the connectivity, this
// two-time-assign would evade the definition of the vtk_mapping
for (unsigned int j=0; j<conn.size(); ++j)
elem->set_node(j) = mesh.node_ptr(conn[j]);
elem->set_id(i);
elems_of_dimension[elem->dim()] = true;
mesh.add_elem(elem);
} // end loop over VTK cells
// Set the mesh dimension to the largest encountered for an element
for (unsigned int i=0; i!=4; ++i)
if (elems_of_dimension[i])
mesh.set_mesh_dimension(i);
#if LIBMESH_DIM < 3
if (mesh.mesh_dimension() > LIBMESH_DIM)
{
libMesh::err << "Cannot open dimension " <<
mesh.mesh_dimension() <<
" mesh file when configured without " <<
mesh.mesh_dimension() << "D support." <<
std::endl;
libmesh_error();
}
#endif
#endif // LIBMESH_HAVE_VTK
}
void VTKIO::read (const std::string & name)
{
// This is a serial-only process for now;
// the Mesh should be read on processor 0 and
// broadcast later
libmesh_assert_equal_to (MeshOutput<MeshBase>::mesh().processor_id(), 0);
// Keep track of what kinds of elements this file contains
elems_of_dimension.clear();
elems_of_dimension.resize(4, false);
// Use a typedef, because these names are just crazy
typedef vtkSmartPointer<vtkXMLUnstructuredGridReader> MyReader;
MyReader reader = MyReader::New();
// Pass the filename along to the reader
reader->SetFileName(name.c_str());
// Force reading
reader->Update();
// read in the grid
_vtk_grid = reader->GetOutput();
// _vtk_grid->Update(); // FIXME: Necessary?
// Get a reference to the mesh
MeshBase & mesh = MeshInput<MeshBase>::mesh();
// Clear out any pre-existing data from the Mesh
mesh.clear();
// Get the number of points from the _vtk_grid object
const unsigned int vtk_num_points = static_cast<unsigned int>(_vtk_grid->GetNumberOfPoints());
// always numbered nicely??, so we can loop like this
// I'm pretty sure it is numbered nicely
for (unsigned int i=0; i<vtk_num_points; ++i)
{
// add to the id map
// and add the actual point
double * pnt = _vtk_grid->GetPoint(static_cast<vtkIdType>(i));
Point xyz(pnt[0], pnt[1], pnt[2]);
Node * newnode = mesh.add_point(xyz, i);
// Add node to the nodes vector &
// tell the MeshData object the foreign node id.
if (this->_mesh_data != libmesh_nullptr)
this->_mesh_data->add_foreign_node_id (newnode, i);
}
// Get the number of cells from the _vtk_grid object
const unsigned int vtk_num_cells = static_cast<unsigned int>(_vtk_grid->GetNumberOfCells());
for (unsigned int i=0; i<vtk_num_cells; ++i)
{
vtkCell * cell = _vtk_grid->GetCell(i);
// Get the libMesh element type corresponding to this VTK element type.
ElemType libmesh_elem_type = _element_maps.find(cell->GetCellType());
Elem * elem = Elem::build(libmesh_elem_type).release();
// get the straightforward numbering from the VTK cells
for (unsigned int j=0; j<elem->n_nodes(); ++j)
elem->set_node(j) =
mesh.node_ptr(cast_int<dof_id_type>(cell->GetPointId(j)));
// then get the connectivity
std::vector<dof_id_type> conn;
elem->connectivity(0, VTK, conn);
// then reshuffle the nodes according to the connectivity, this
// two-time-assign would evade the definition of the vtk_mapping
for (unsigned int j=0; j<conn.size(); ++j)
elem->set_node(j) = mesh.node_ptr(conn[j]);
elem->set_id(i);
elems_of_dimension[elem->dim()] = true;
mesh.add_elem(elem);
} // end loop over VTK cells
// Set the mesh dimension to the largest encountered for an element
for (unsigned char i=0; i!=4; ++i)
if (elems_of_dimension[i])
mesh.set_mesh_dimension(i);
#if LIBMESH_DIM < 3
if (mesh.mesh_dimension() > LIBMESH_DIM)
libmesh_error_msg("Cannot open dimension " \
<< mesh.mesh_dimension() \
<< " mesh file when configured without " \
<< mesh.mesh_dimension() \
<< "D support.");
#endif // LIBMESH_DIM < 3
}