rw::writer::VtkWriter Class Reference

A vtk writer for simple point data and complex fem mesh data. More...

#include <vtkWriter.h>

Collaboration diagram for rw::writer::VtkWriter:

Public Member Functions
	VtkWriter (const std::string &filename, const std::string &compress_type="")
	Constructor.
void	close ()
	Closes the file and store it to the hard disk.
Mesh data
void	appendNodes (const std::vector< util::Point > *nodes, const std::vector< util::Point > *u=nullptr)
	Writes the nodes to the file.
void	appendMesh (const std::vector< util::Point > *nodes, const size_t &element_type, const std::vector< size_t > *en_con, const std::vector< util::Point > *u=nullptr)
	Writes the mesh data to file.
Point data
void	appendPointData (const std::string &name, const std::vector< uint8_t > *data)
	Writes the scalar point data to the file.
void	appendPointData (const std::string &name, const std::vector< size_t > *data)
	Writes the scalar point data to the file.
void	appendPointData (const std::string &name, const std::vector< int > *data)
	Writes the scalar point data to the file.
void	appendPointData (const std::string &name, const std::vector< float > *data)
	Writes the scalar point data to the file.
void	appendPointData (const std::string &name, const std::vector< double > *data)
	Writes the scalar point data to the file.
void	appendPointData (const std::string &name, const std::vector< util::Point > *data)
	Writes the vector point data to the file.
void	appendPointData (const std::string &name, const std::vector< util::SymMatrix3 > *data)
	Writes the symmetric matrix data associated to nodes to the file.
Cell data
void	appendCellData (const std::string &name, const std::vector< float > *data)
	Writes the float data associated to cells to the file.
void	appendCellData (const std::string &name, const std::vector< util::SymMatrix3 > *data)
	Writes the symmetric matrix data associated to cells to the file.
Field data
void	appendFieldData (const std::string &name, const double &data)
	Writes the scalar field data to the file.
void	appendFieldData (const std::string &name, const float &data)
	Writes the scalar field data to the file.
void	addTimeStep (const double &timestep)
	Writes the time step to the file.

Private Attributes
vtkSmartPointer< vtkXMLUnstructuredGridWriter >	d_writer_p
	XML unstructured grid writer.
vtkSmartPointer< vtkUnstructuredGrid >	d_grid_p
	Unstructured grid.
std::string	d_compressType
	compression_type Specify the compressor (if any)

Detailed Description

A vtk writer for simple point data and complex fem mesh data.

Definition at line 28 of file vtkWriter.h.

Constructor & Destructor Documentation

VtkWriter()

rw::writer::VtkWriter::VtkWriter ( const std::string &  filename, const std::string &  compress_type = ""  )

explicit

Constructor.

Creates and opens .vtu file of name given by filename. The file remains open till the close() function is invoked.

Parameters

filename	Name of file which will be created
compress_type	Compression method (optional)

Definition at line 22 of file vtkWriter.cpp.

    : d_compressType(compress_type) {
 
  std::string f = filename + ".vtu";
 
  d_writer_p = vtkSmartPointer<vtkXMLUnstructuredGridWriter>::New();
  d_writer_p->SetFileName(const_cast<char *>(f.c_str()));
}

References d_writer_p.

Member Function Documentation

addTimeStep()

void rw::writer::VtkWriter::addTimeStep

(

const double &

timestep

)

Writes the time step to the file.

Parameters

timestep

Current time step of the simulation

Definition at line 268 of file vtkWriter.cpp.

                                                          {
 
  auto t = vtkDoubleArray::New();
  t->SetName("TIME");
  t->SetNumberOfTuples(1);
  t->SetTuple1(0, timestep);
  d_grid_p->GetFieldData()->AddArray(t);
}

appendCellData() [1/2]

void rw::writer::VtkWriter::appendCellData	(	const std::string &	name,
		const std::vector< float > *	data
	)

Writes the float data associated to cells to the file.

Parameters

name	Name of the data
data	Vector containing the data

Definition at line 225 of file vtkWriter.cpp.

                                                                         {
  auto array = vtkSmartPointer<vtkDoubleArray>::New();
  array->SetNumberOfComponents(1);
  array->SetName(name.c_str());
 
  double value[1];
  for (float i : *data) {
    value[0] = i;
    array->InsertNextTuple(value);
  }
 
  d_grid_p->GetCellData()->AddArray(array);
}

appendCellData() [2/2]

void rw::writer::VtkWriter::appendCellData	(	const std::string &	name,
		const std::vector< util::SymMatrix3 > *	data
	)

Writes the symmetric matrix data associated to cells to the file.

Parameters

name	Name of the data
data	Vector containing the data

Definition at line 240 of file vtkWriter.cpp.

                                                                  {
 
  auto array = vtkSmartPointer < vtkDoubleArray > ::New();
  array->SetNumberOfComponents(6);
  array->SetName(name.c_str());
 
  array->SetComponentName(0, "xx");
  array->SetComponentName(1, "yy");
  array->SetComponentName(2, "zz");
  array->SetComponentName(3, "yz");
  array->SetComponentName(4, "xz");
  array->SetComponentName(5, "xy");
 
  double value[6];
  for (const auto &i : *data) {
    value[0] = i(0,0);
    value[1] = i(1,1);
    value[2] = i(2,2);
    value[3] = i(1,2);
    value[4] = i(0,2);
    value[5] = i(0,1);
    array->InsertNextTuple(value);
  }
 
  d_grid_p->GetCellData()->AddArray(array);
}

appendFieldData() [1/2]

void rw::writer::VtkWriter::appendFieldData	(	const std::string &	name,
		const double &	data
	)

Writes the scalar field data to the file.

Parameters

name	Name of the data
data	Value

Definition at line 288 of file vtkWriter.cpp.

                                                                {
 
  auto t = vtkDoubleArray::New();
  t->SetName(name.c_str());
  t->SetNumberOfTuples(1);
  t->SetTuple1(0, data);
  d_grid_p->GetFieldData()->AddArray(t);
}

appendFieldData() [2/2]

void rw::writer::VtkWriter::appendFieldData	(	const std::string &	name,
		const float &	data
	)

Writes the scalar field data to the file.

Parameters

name	Name of the data
data	Value

Definition at line 298 of file vtkWriter.cpp.

                                                               {
 
  auto t = vtkDoubleArray::New();
  t->SetName(name.c_str());
  t->SetNumberOfTuples(1);
  t->SetTuple1(0, data);
  d_grid_p->GetFieldData()->AddArray(t);
}

appendMesh()

void rw::writer::VtkWriter::appendMesh	(	const std::vector< util::Point > *	nodes,
		const size_t &	element_type,
		const std::vector< size_t > *	en_con,
		const std::vector< util::Point > *	u = nullptr
	)

Writes the mesh data to file.

Parameters

nodes	Vector of nodal coordinates
element_type	Type of element
en_con	Vector of element-node connectivity
u	Vector of nodal displacement

Definition at line 49 of file vtkWriter.cpp.

                                   {
 
  // we write following things to the file
  //
  // Node data
  // 1. Coordinates of nodes (current)
  //
  // Element data
  // 1. element node connectivity
  // 2. element type (either triangle or square)
 
  // add current position of nodes
  this->appendNodes(nodes, u);
 
  // get the total number of elements
  size_t num_vertex = util::vtk_map_element_to_num_nodes[element_type];
  size_t num_elems = en_con->size() / num_vertex;
 
  //
  // process elements data
  //
  // element node connectivity
  auto cells = vtkSmartPointer<vtkCellArray>::New();
  cells->Allocate(num_vertex, num_elems);
 
  // element type
  int cell_types[num_elems];
 
  vtkIdType ids[num_vertex];
  for (size_t i = 0; i < num_elems; i++) {
 
    // get ids of vertex of this element
    for (size_t k = 0; k < num_vertex; k++)
      ids[k] = (*en_con)[num_vertex*i + k];
 
    cells->InsertNextCell(num_vertex, ids);
    cell_types[i] = element_type;
  }
 
  // element node connectivity
  d_grid_p->SetCells(cell_types, cells);
}

References util::vtk_map_element_to_num_nodes.

appendNodes()

void rw::writer::VtkWriter::appendNodes	(	const std::vector< util::Point > *	nodes,
		const std::vector< util::Point > *	u = nullptr
	)

Writes the nodes to the file.

Parameters

nodes	Reference positions of the nodes
u	Nodal displacements

Definition at line 32 of file vtkWriter.cpp.

                                                                       {
 
  auto points = vtkSmartPointer<vtkPoints>::New();
 
  for (size_t i = 0; i < nodes->size(); i++) {
 
    util::Point p = (*nodes)[i];
    if (u)
      p = p + (*u)[i];
    points->InsertNextPoint(p.d_x, p.d_y, p.d_z);
  }
 
  d_grid_p = vtkSmartPointer<vtkUnstructuredGrid>::New();
  d_grid_p->SetPoints(points);
}

References util::Point::d_x, util::Point::d_y, and util::Point::d_z.

appendPointData() [1/7]

void rw::writer::VtkWriter::appendPointData	(	const std::string &	name,
		const std::vector< double > *	data
	)

Writes the scalar point data to the file.

Parameters

name	Name of the data
data	Vector containing the data

Definition at line 159 of file vtkWriter.cpp.

                                                                           {
 
  auto array = vtkSmartPointer<vtkDoubleArray>::New();
  array->SetNumberOfComponents(1);
  array->SetName(name.c_str());
 
  double value[1];
  for (double i : *data) {
    value[0] = i;
    array->InsertNextTuple(value);
  }
 
  d_grid_p->GetPointData()->AddArray(array);
}

appendPointData() [2/7]

void rw::writer::VtkWriter::appendPointData	(	const std::string &	name,
		const std::vector< float > *	data
	)

Writes the scalar point data to the file.

Parameters

name	Name of the data
data	Vector containing the data

Definition at line 143 of file vtkWriter.cpp.

                                                                          {
 
  auto array = vtkSmartPointer<vtkDoubleArray>::New();
  array->SetNumberOfComponents(1);
  array->SetName(name.c_str());
 
  double value[1];
  for (float i : *data) {
    value[0] = i;
    array->InsertNextTuple(value);
  }
 
  d_grid_p->GetPointData()->AddArray(array);
}

appendPointData() [3/7]

void rw::writer::VtkWriter::appendPointData	(	const std::string &	name,
		const std::vector< int > *	data
	)

Writes the scalar point data to the file.

Parameters

name	Name of the data
data	Vector containing the data

Definition at line 127 of file vtkWriter.cpp.

                                                                        {
 
  auto array = vtkSmartPointer<vtkDoubleArray>::New();
  array->SetNumberOfComponents(1);
  array->SetName(name.c_str());
 
  double value[1];
  for (int i : *data) {
    value[0] = i;
    array->InsertNextTuple(value);
  }
 
  d_grid_p->GetPointData()->AddArray(array);
}

appendPointData() [4/7]

void rw::writer::VtkWriter::appendPointData	(	const std::string &	name,
		const std::vector< size_t > *	data
	)

Writes the scalar point data to the file.

Parameters

name	Name of the data
data	Vector containing the data

Definition at line 111 of file vtkWriter.cpp.

                                                                           {
 
  auto array = vtkSmartPointer<vtkDoubleArray>::New();
  array->SetNumberOfComponents(1);
  array->SetName(name.c_str());
 
  double value[1];
  for (unsigned long i : *data) {
    value[0] = i;
    array->InsertNextTuple(value);
  }
 
  d_grid_p->GetPointData()->AddArray(array);
}

appendPointData() [5/7]

void rw::writer::VtkWriter::appendPointData	(	const std::string &	name,
		const std::vector< uint8_t > *	data
	)

Writes the scalar point data to the file.

Parameters

name	Name of the data
data	Vector containing the data

Definition at line 95 of file vtkWriter.cpp.

                                                                            {
 
  auto array = vtkSmartPointer<vtkDoubleArray>::New();
  array->SetNumberOfComponents(1);
  array->SetName(name.c_str());
 
  double value[1];
  for (unsigned char i : *data) {
    value[0] = i;
    array->InsertNextTuple(value);
  }
 
  d_grid_p->GetPointData()->AddArray(array);
}

appendPointData() [6/7]

void rw::writer::VtkWriter::appendPointData	(	const std::string &	name,
		const std::vector< util::Point > *	data
	)

Writes the vector point data to the file.

Parameters

name	Name of the data
data	Vector containing the data

Definition at line 175 of file vtkWriter.cpp.

                                                             {
 
  auto array = vtkSmartPointer<vtkDoubleArray>::New();
  array->SetNumberOfComponents(3);
  array->SetName(name.c_str());
 
  array->SetComponentName(0, "x");
  array->SetComponentName(1, "y");
  array->SetComponentName(2, "z");
 
  double value[3];
  for (const auto &i : *data) {
    value[0] = i.d_x;
    value[1] = i.d_y;
    value[2] = i.d_z;
    array->InsertNextTuple(value);
  }
 
  d_grid_p->GetPointData()->AddArray(array);
}

appendPointData() [7/7]

void rw::writer::VtkWriter::appendPointData	(	const std::string &	name,
		const std::vector< util::SymMatrix3 > *	data
	)

Writes the symmetric matrix data associated to nodes to the file.

Parameters

name	Name of the data
data	Vector containing the data

Definition at line 197 of file vtkWriter.cpp.

                                                                  {
 
  auto array = vtkSmartPointer<vtkDoubleArray>::New();
  array->SetNumberOfComponents(6);
  array->SetName(name.c_str());
 
  array->SetComponentName(0, "xx");
  array->SetComponentName(1, "yy");
  array->SetComponentName(2, "zz");
  array->SetComponentName(3, "yz");
  array->SetComponentName(4, "xz");
  array->SetComponentName(5, "xy");
 
  double value[6];
  for (const auto &i : *data) {
    value[0] = i(0,0);
    value[1] = i(1,1);
    value[2] = i(2,2);
    value[3] = i(1,2);
    value[4] = i(0,2);
    value[5] = i(0,1);
    array->InsertNextTuple(value);
  }
 
  d_grid_p->GetPointData()->AddArray(array);
}

close()

void rw::writer::VtkWriter::close

(

)

Closes the file and store it to the hard disk.

Definition at line 277 of file vtkWriter.cpp.

                              {
  d_writer_p->SetInputData(d_grid_p);
  d_writer_p->SetDataModeToAppended();
  d_writer_p->EncodeAppendedDataOn();
  if (d_compressType == "zlib")
    d_writer_p->SetCompressorTypeToZLib();
  else
    d_writer_p->SetCompressor(0);
  d_writer_p->Write();
}

Field Documentation

d_compressType

std::string rw::writer::VtkWriter::d_compressType

private

compression_type Specify the compressor (if any)

Definition at line 194 of file vtkWriter.h.

d_grid_p

vtkSmartPointer<vtkUnstructuredGrid> rw::writer::VtkWriter::d_grid_p

private

Unstructured grid.

Definition at line 191 of file vtkWriter.h.

d_writer_p

vtkSmartPointer<vtkXMLUnstructuredGridWriter> rw::writer::VtkWriter::d_writer_p

private

XML unstructured grid writer.

Definition at line 188 of file vtkWriter.h.

Referenced by VtkWriter().

---

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

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