rw::reader::VtkReader Class Reference

A class to read VTK (.vtu) mesh files. More...

#include <vtkReader.h>

Collaboration diagram for rw::reader::VtkReader:

Public Member Functions
	VtkReader (const std::string &filename)
	Constructor.
void	readMesh (size_t dim, std::vector< util::Point > *nodes, size_t &element_type, size_t &num_elems, std::vector< size_t > *enc, std::vector< std::vector< size_t > > *nec, std::vector< double > *volumes, bool is_fd=false)
	Reads mesh data into node file and element file.
void	readNodes (std::vector< util::Point > *nodes)
	Reads nodal position.
void	readCells (size_t dim, size_t &element_type, size_t &num_elems, std::vector< size_t > *enc, std::vector< std::vector< size_t > > *nec)
	Reads cell data, i.e. element-node connectivity and node-element connectivity.
bool	readPointData (const std::string &name, std::vector< uint8_t > *data)
	reads point data from .vtu file
bool	readPointData (const std::string &name, std::vector< size_t > *data)
	reads point data from .vtu file
bool	readPointData (const std::string &name, std::vector< int > *data)
	reads point data from .vtu file
bool	readPointData (const std::string &name, std::vector< float > *data)
	reads point data from .vtu file
bool	readPointData (const std::string &name, std::vector< double > *data)
	reads point data from .vtu file
bool	readPointData (const std::string &name, std::vector< util::Point > *data)
	reads point data from .vtu file
bool	readPointData (const std::string &name, std::vector< util::SymMatrix3 > *data)
	reads point data from .vtu file
bool	readPointData (const std::string &name, std::vector< util::Matrix3 > *data)
	reads point data from .vtu file
bool	readCellData (const std::string &name, std::vector< float > *data)
	reads cell data from .vtu file
bool	readCellData (const std::string &name, std::vector< double > *data)
	reads cell data from .vtu file
bool	readCellData (const std::string &name, std::vector< util::Point > *data)
	reads cell data from .vtu file
bool	readCellData (const std::string &name, std::vector< util::SymMatrix3 > *data)
	reads cell data from .vtu file
bool	readCellData (const std::string &name, std::vector< util::Matrix3 > *data)
	reads cell data from .vtu file
void	close ()
	Close the file.

Private Attributes
vtkSmartPointer< vtkXMLUnstructuredGridReader >	d_reader_p
	XML unstructured grid writer.
vtkSmartPointer< vtkUnstructuredGrid >	d_grid_p
	Unstructured grid.

Static Private Attributes
static size_t	d_count = 0
	Counter.

Detailed Description

A class to read VTK (.vtu) mesh files.

Note

Depends on VTK library.

Definition at line 32 of file vtkReader.h.

Constructor & Destructor Documentation

VtkReader()

rw::reader::VtkReader::VtkReader ( const std::string &  filename )

explicit

Constructor.

Parameters

filename

Name of mesh file (with/without .vtu extension)

Definition at line 30 of file vtkReader.cpp.

                                                      {
  d_count++;
 
  auto f = util::io::checkAndCreateNewFilename(filename, "vtu");
 
  // Append the extension vtu to file_name
  d_reader_p = vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
  d_reader_p->SetFileName(const_cast<char *>(f.c_str()));
  d_reader_p->Update();
}

References util::io::checkAndCreateNewFilename(), d_count, and d_reader_p.

Here is the call graph for this function:

Member Function Documentation

close()

void rw::reader::VtkReader::close

(

)

Close the file.

Definition at line 616 of file vtkReader.cpp.

                              {
  // delete d_reader_p;
  // delete d_grid_p;
}

readCellData() [1/5]

bool rw::reader::VtkReader::readCellData	(	const std::string &	name,
		std::vector< double > *	data
	)

reads cell data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 494 of file vtkReader.cpp.

                                                                  {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkCellData *c_field = d_grid_p->GetCellData();
 
  // handle for displacement, fixity and node element connectivity
  if (c_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = c_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(1);
  data_a->Allocate(1, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = data_a->GetValue(0);
  }
 
  return true;
}

readCellData() [2/5]

bool rw::reader::VtkReader::readCellData	(	const std::string &	name,
		std::vector< float > *	data
	)

reads cell data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 468 of file vtkReader.cpp.

                                                                 {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkCellData *c_field = d_grid_p->GetCellData();
 
  // handle for displacement, fixity and node element connectivity
  if (c_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = c_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(1);
  data_a->Allocate(1, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = data_a->GetValue(0);
  }
 
  return true;
}

readCellData() [3/5]

bool rw::reader::VtkReader::readCellData	(	const std::string &	name,
		std::vector< util::Matrix3 > *	data
	)

reads cell data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 575 of file vtkReader.cpp.

                                                                       {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkCellData *c_field = d_grid_p->GetCellData();
 
  // handle for displacement, fixity and node element connectivity
  if (c_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = c_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(6);
  data_a->Allocate(6, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
 
    util::Matrix3 m;
    m(0,0) = data_a->GetValue(0);
    m(1,1) = data_a->GetValue(1);
    m(2,2) = data_a->GetValue(2);
    m(1,2) = data_a->GetValue(3);
    m(0,2) = data_a->GetValue(4);
    m(0,1) = data_a->GetValue(5);
 
    // symmetrize
    m(2,1) = m(1,2);
    m(2,0) = m(0,2);
    m(1,0) = m(0,1);
 
    // add to the data
    (*data)[i] = m;
  }
 
  return true;
}

readCellData() [4/5]

bool rw::reader::VtkReader::readCellData	(	const std::string &	name,
		std::vector< util::Point > *	data
	)

reads cell data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 520 of file vtkReader.cpp.

                                                                     {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkCellData *c_field = d_grid_p->GetCellData();
 
  // handle for displacement, fixity and node element connectivity
  if (c_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = c_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(3);
  data_a->Allocate(3, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = util::Point(data_a->GetValue(0), data_a->GetValue(1),
                              data_a->GetValue(2));
  }
 
  return true;
}

readCellData() [5/5]

bool rw::reader::VtkReader::readCellData	(	const std::string &	name,
		std::vector< util::SymMatrix3 > *	data
	)

reads cell data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 547 of file vtkReader.cpp.

                                                                          {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkCellData *c_field = d_grid_p->GetCellData();
 
  // handle for displacement, fixity and node element connectivity
  if (c_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = c_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(6);
  data_a->Allocate(6, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = util::SymMatrix3({data_a->GetValue(0), data_a->GetValue(1),
                                  data_a->GetValue(2), data_a->GetValue(3),
                                  data_a->GetValue(4), data_a->GetValue(5)});
  }
 
  return true;
}

readCells()

void rw::reader::VtkReader::readCells	(	size_t	dim,
		size_t &	element_type,
		size_t &	num_elems,
		std::vector< size_t > *	enc,
		std::vector< std::vector< size_t > > *	nec
	)

Reads cell data, i.e. element-node connectivity and node-element connectivity.

Parameters

dim	Dimension
element_type	Type of element
num_elems	Number of elements
enc	Element-node connectivity
nec	Node-element connectivity

Definition at line 183 of file vtkReader.cpp.

                                                                         {
  d_grid_p = d_reader_p->GetOutput();
  vtkIdType num_nodes = d_grid_p->GetNumberOfPoints();
  vtkIdType num_elems = d_grid_p->GetNumberOfCells();
 
  // set number of elements
  num_elem = num_elems;
 
  // resize data (we resize enc data inside loop, see below)
  nec->clear();
  nec->resize(num_nodes);
 
  // get cell types array
  vtkUnsignedCharArray *elem_types = d_grid_p->GetCellTypesArray();
 
  // read cell field data
  vtkCellData *c_field = d_grid_p->GetCellData();
 
  // to hold integer
  auto val = vtkSmartPointer<vtkUnsignedIntArray>::New();
  val->SetNumberOfComponents(1);
  val->Allocate(1, 1);  // allocate memory
 
  int nds_per_el = 0;
  for (size_t i = 0; i < num_elems; i++) {
    vtkIdType id = i;
    vtkIdType num_ids;
    vtkIdType const *nodes_ids;
 
    d_grid_p->GetCellPoints(id, num_ids, nodes_ids);
 
    // resize element-node connectivity data in the beginning of the loop
    if (i == 0) {
      elem_types->GetTuples(i, i, val);
      element_type = val->GetValue(0);
 
      nds_per_el = util::vtk_map_element_to_num_nodes[element_type];
 
      //      std::cout << "nodes per element = " << nds_per_el << "\n";
      //      std::cout << "Num elements = " << num_elems << "\n";
 
      // resize the element-node connectivity
      enc->clear();
      enc->resize(nds_per_el * num_elems);
    }
 
    for (size_t j = 0; j < num_ids; j++) {
      // read element-node connectivity data
      (*enc)[nds_per_el * i + j] = nodes_ids[j];
 
      // update node-element connectivity data
      (*nec)[nodes_ids[j]].push_back(i);
    }
  }
}

References util::vtk_map_element_to_num_nodes.

readMesh()

void rw::reader::VtkReader::readMesh	(	size_t	dim,
		std::vector< util::Point > *	nodes,
		size_t &	element_type,
		size_t &	num_elems,
		std::vector< size_t > *	enc,
		std::vector< std::vector< size_t > > *	nec,
		std::vector< double > *	volumes,
		bool	is_fd = false
	)

Reads mesh data into node file and element file.

Parameters

dim	Dimension
nodes	Vector of nodes data
element_type	Type of element
num_elems	Number of elements
enc	Vector holding element-node connectivity
nec	Vector holding node-element connectivity
volumes	Vector holding volume of the nodes
is_fd	Flag indicating if this mesh is for finite_difference simulation

Definition at line 41 of file vtkReader.cpp.

                                                                             {
  //
  // For nodes, we read following data
  // 1. nodes initial configuration
  // 2. nodes volume (if provided)
  // 3. nodes element connectivity (if provided)
  //
  // For elements, we read following data
  // 1. element node connectivity
  // 2. element type
  //
  d_grid_p = d_reader_p->GetOutput();
  vtkIdType num_nodes = d_grid_p->GetNumberOfPoints();
  vtkIdType num_elems = d_grid_p->GetNumberOfCells();
 
  // read point field data
  vtkPointData *p_field = d_grid_p->GetPointData();
 
  // check if file contains nodal volumes
  bool has_volume = true;
  if (p_field->HasArray("Node_Volume") == 0 and
      p_field->HasArray("Volume") == 0)
    has_volume = false;
  vtkDataArray *vol_array;
  if (has_volume) {
    if (p_field->HasArray("Node_Volume"))
      vol_array = p_field->GetArray("Node_Volume");
    else if (p_field->HasArray("Volume"))
      vol_array = p_field->GetArray("Volume");
  }
 
  // resize data
  nodes->resize(num_nodes);
  if (has_volume) volumes->resize(num_nodes);
 
  // Below is not efficient and need improvement
  // declare another array data to hold the ux,uy,uz
  auto u_a = vtkSmartPointer<vtkDoubleArray>::New();
  u_a->SetNumberOfComponents(3);
  u_a->Allocate(3, 1);  // allocate memory
 
  auto fix_a = vtkSmartPointer<vtkUnsignedIntArray>::New();
  fix_a->SetNumberOfComponents(1);
  fix_a->Allocate(1, 1);  // allocate memory
 
  auto vol_a = vtkSmartPointer<vtkDoubleArray>::New();
  vol_a->SetNumberOfComponents(1);
  vol_a->Allocate(1, 1);  // allocate memory
 
  auto con_a = vtkSmartPointer<vtkIntArray>::New();
  con_a->SetNumberOfComponents(11);
  con_a->Allocate(11, 1);  // allocate memory
 
  for (size_t i = 0; i < num_nodes; i++) {
    vtkIdType id = i;
 
    double x[3];
    d_grid_p->GetPoint(id, x);
 
    util::Point i_node = util::Point(x[0], x[1], x[2]);
    (*nodes)[i] = i_node;
 
    // read node volume
    if (has_volume) {
      vol_array->GetTuples(i, i, vol_a);
      (*volumes)[i] = vol_a->GetValue(0);
    }
  }
 
  // if mesh is for finite difference simulation and if we have read the
  // volume data then we do not need to go further
  if (is_fd and has_volume) return;
 
  // read elements
  // to resize element-node connectivity, we need to know the number of
  // vertex in the given element type
  num_elem = num_elems;
 
  // resize node-element connectivity
  nec->resize(num_nodes);
 
  // get cell types array
  vtkUnsignedCharArray *elem_types = d_grid_p->GetCellTypesArray();
 
  // read cell field data
  vtkCellData *c_field = d_grid_p->GetCellData();
 
  int nds_per_el = 0;
  for (size_t i = 0; i < num_elems; i++) {
    vtkIdType id = i;
    vtkIdType num_ids;
    vtkIdType const *nodes_ids;
 
    d_grid_p->GetCellPoints(id, num_ids, nodes_ids);
 
    // resize element-node connectivity data in the beginning of the loop
    if (i == 0) {
      elem_types->GetTuples(i, i, fix_a);
      element_type = fix_a->GetValue(0);
 
      nds_per_el = util::vtk_map_element_to_num_nodes[element_type];
 
      //      std::cout << "nodes per element = " << nds_per_el << "\n";
      //      std::cout << "Num elements = " << num_elems << "\n";
 
      // resize the element-node connectivity
      enc->resize(nds_per_el * num_elems);
    }
 
    for (size_t j = 0; j < num_ids; j++) {
      // read element-node connectivity data
      (*enc)[nds_per_el * i + j] = nodes_ids[j];
 
      // update node-element connectivity data
      (*nec)[nodes_ids[j]].push_back(i);
    }
  }
}

References util::vtk_map_element_to_num_nodes.

readNodes()

void rw::reader::VtkReader::readNodes

(

std::vector< util::Point > *

nodes

)

Reads nodal position.

Parameters

nodes

Vector of nodal coordinates

Definition at line 165 of file vtkReader.cpp.

                                                             {
  d_grid_p = d_reader_p->GetOutput();
  vtkIdType num_nodes = d_grid_p->GetNumberOfPoints();
 
  // resize data
  nodes->clear();
  nodes->resize(num_nodes);
  for (size_t i = 0; i < num_nodes; i++) {
    vtkIdType id = i;
 
    double x[3];
    d_grid_p->GetPoint(id, x);
 
    util::Point i_node = util::Point(x[0], x[1], x[2]);
    (*nodes)[i] = i_node;
  }
}

readPointData() [1/8]

bool rw::reader::VtkReader::readPointData	(	const std::string &	name,
		std::vector< double > *	data
	)

reads point data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 346 of file vtkReader.cpp.

                                                                   {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkPointData *p_field = d_grid_p->GetPointData();
 
  // handle for displacement, fixity and node element connectivity
  if (p_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = p_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(1);
  data_a->Allocate(1, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = data_a->GetValue(0);
  }
 
  return true;
}

readPointData() [2/8]

bool rw::reader::VtkReader::readPointData	(	const std::string &	name,
		std::vector< float > *	data
	)

reads point data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 320 of file vtkReader.cpp.

                                                                  {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkPointData *p_field = d_grid_p->GetPointData();
 
  // handle for displacement, fixity and node element connectivity
  if (p_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = p_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(1);
  data_a->Allocate(1, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = data_a->GetValue(0);
  }
 
  return true;
}

readPointData() [3/8]

bool rw::reader::VtkReader::readPointData	(	const std::string &	name,
		std::vector< int > *	data
	)

reads point data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 294 of file vtkReader.cpp.

                                                                {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkPointData *p_field = d_grid_p->GetPointData();
 
  // handle for displacement, fixity and node element connectivity
  if (p_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = p_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(1);
  data_a->Allocate(1, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = data_a->GetValue(0);
  }
 
  return true;
}

readPointData() [4/8]

bool rw::reader::VtkReader::readPointData	(	const std::string &	name,
		std::vector< size_t > *	data
	)

reads point data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 268 of file vtkReader.cpp.

                                                                   {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkPointData *p_field = d_grid_p->GetPointData();
 
  // handle for displacement, fixity and node element connectivity
  if (p_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = p_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(1);
  data_a->Allocate(1, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = data_a->GetValue(0);
  }
 
  return true;
}

readPointData() [5/8]

bool rw::reader::VtkReader::readPointData	(	const std::string &	name,
		std::vector< uint8_t > *	data
	)

reads point data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 242 of file vtkReader.cpp.

                                                                    {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkPointData *p_field = d_grid_p->GetPointData();
 
  // handle for displacement, fixity and node element connectivity
  if (p_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = p_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(1);
  data_a->Allocate(1, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = data_a->GetValue(0);
  }
 
  return true;
}

readPointData() [6/8]

bool rw::reader::VtkReader::readPointData	(	const std::string &	name,
		std::vector< util::Matrix3 > *	data
	)

reads point data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 427 of file vtkReader.cpp.

                                                                        {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkPointData *p_field = d_grid_p->GetPointData();
 
  // handle for displacement, fixity and node element connectivity
  if (p_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = p_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(6);
  data_a->Allocate(6, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
 
    util::Matrix3 m;
    m(0,0) = data_a->GetValue(0);
    m(1,1) = data_a->GetValue(1);
    m(2,2) = data_a->GetValue(2);
    m(1,2) = data_a->GetValue(3);
    m(0,2) = data_a->GetValue(4);
    m(0,1) = data_a->GetValue(5);
 
    // symmetrize
    m(2,1) = m(1,2);
    m(2,0) = m(0,2);
    m(1,0) = m(0,1);
 
    // add to the data
    (*data)[i] = m;
  }
 
  return true;
}

readPointData() [7/8]

bool rw::reader::VtkReader::readPointData	(	const std::string &	name,
		std::vector< util::Point > *	data
	)

reads point data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 372 of file vtkReader.cpp.

                                                                      {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkPointData *p_field = d_grid_p->GetPointData();
 
  // handle for displacement, fixity and node element connectivity
  if (p_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = p_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(3);
  data_a->Allocate(3, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = util::Point(data_a->GetValue(0), data_a->GetValue(1),
                              data_a->GetValue(2));
  }
 
  return true;
}

readPointData() [8/8]

bool rw::reader::VtkReader::readPointData	(	const std::string &	name,
		std::vector< util::SymMatrix3 > *	data
	)

reads point data from .vtu file

Parameters

name	Name of data
data	Pointer to the vector of data

Returns

status True if data is found otherwise false

Definition at line 399 of file vtkReader.cpp.

                                                                           {
  // read point field data
  d_grid_p = d_reader_p->GetOutput();
  vtkPointData *p_field = d_grid_p->GetPointData();
 
  // handle for displacement, fixity and node element connectivity
  if (p_field->HasArray(name.c_str()) == 0) return false;
 
  vtkDataArray *array = p_field->GetArray(name.c_str());
 
  // Below is not efficient. Later this can be improved.
  // declare another array data to hold the ux,uy,uz
  auto data_a = vtkSmartPointer<vtkDoubleArray>::New();
  data_a->SetNumberOfComponents(6);
  data_a->Allocate(6, 1);  // allocate memory
 
  (*data).resize(array->GetNumberOfTuples());
  for (size_t i = 0; i < array->GetNumberOfTuples(); i++) {
    array->GetTuples(i, i, data_a);
    (*data)[i] = util::SymMatrix3({data_a->GetValue(0), data_a->GetValue(1),
                                  data_a->GetValue(2), data_a->GetValue(3),
                                  data_a->GetValue(4), data_a->GetValue(5)});
  }
 
  return true;
}

Field Documentation

d_count

size_t rw::reader::VtkReader::d_count = 0

staticprivate

Counter.

Definition at line 133 of file vtkReader.h.

Referenced by VtkReader().

d_grid_p

vtkSmartPointer<vtkUnstructuredGrid> rw::reader::VtkReader::d_grid_p

private

Unstructured grid.

Definition at line 139 of file vtkReader.h.

d_reader_p

vtkSmartPointer<vtkXMLUnstructuredGridReader> rw::reader::VtkReader::d_reader_p

private

XML unstructured grid writer.

Definition at line 136 of file vtkReader.h.

Referenced by VtkReader().

---

The documentation for this class was generated from the following files:

• /home/user/project/src/rw/vtkReader.h
• /home/user/project/src/rw/vtkReader.cpp