MeshLib::IO::VtuInterface Class Reference

Detailed Description

Reads and writes VtkXMLUnstructuredGrid-files (vtu) to and from OGS data structures. This class is currently not inherited from Writer because VTK will implement writing to a string from 6.2 onwards.

Definition at line 37 of file VtuInterface.h.

#include <VtuInterface.h>

Collaboration diagram for MeshLib::IO::VtuInterface:

Public Member Functions
	VtuInterface (const MeshLib::Mesh *mesh, int dataMode=vtkXMLWriter::Appended, bool compressed=false)
	Provide the mesh to write and set if compression should be used. More...
bool	writeToFile (std::filesystem::path const &file_path)
template<typename UnstructuredGridWriter >
bool	writeVTU (std::string const &file_name, const int num_partitions=1, const int rank=1)

Static Public Member Functions
static MeshLib::Mesh *	readVTUFile (std::string const &file_name)
static MeshLib::Mesh *	readVTKFile (std::string const &file_name)

Private Attributes
const MeshLib::Mesh *	_mesh
int	_data_mode
bool	_use_compressor

Constructor & Destructor Documentation

VtuInterface()

MeshLib::IO::VtuInterface::VtuInterface ( const MeshLib::Mesh *  mesh, int  dataMode = vtkXMLWriter::Appended, bool  compressed = false  )

explicit

Provide the mesh to write and set if compression should be used.

Definition at line 43 of file VtuInterface.cpp.

    : _mesh(mesh), _data_mode(dataMode), _use_compressor(compress)
{
    if (_data_mode == vtkXMLWriter::Ascii && compress)
    {
        WARN("Ascii data cannot be compressed, ignoring compression flag.");
    }
}

References _data_mode, and WARN().

Member Function Documentation

readVTKFile()

MeshLib::Mesh * MeshLib::IO::VtuInterface::readVTKFile ( std::string const &  file_name )

static

Read an unstructured grid from a legacy VTK file. Other data structures such as PolyData are ignored.

Returns

The converted mesh or a nullptr if reading failed

Definition at line 79 of file VtuInterface.cpp.

{
    if (!BaseLib::IsFileExisting(file_name))
    {
        ERR("File '{:s}' does not exist.", file_name);
        return nullptr;
    }
 
    vtkSmartPointer<vtkGenericDataObjectReader> reader =
        vtkSmartPointer<vtkGenericDataObjectReader>::New();
    reader->SetFileName(file_name.c_str());
    reader->Update();
 
    // check for unstructured grid
    if (reader->ReadOutputType() != 4)
    {
        ERR("Only VTK-files with dataset type \"Unstructured Grid\" are "
            "currently supported.");
        return nullptr;
    }
 
    reader->ReadAllFieldsOn();
    reader->ReadAllScalarsOn();
    vtkUnstructuredGrid* vtkGrid = reader->GetUnstructuredGridOutput();
    if (vtkGrid->GetNumberOfPoints() == 0)
    {
        ERR("Mesh '{:s}' contains zero points.", file_name);
        return nullptr;
    }
 
    std::string const mesh_name(
        BaseLib::extractBaseNameWithoutExtension(file_name));
    return MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtkGrid,
                                                              mesh_name);
}

References MeshLib::VtkMeshConverter::convertUnstructuredGrid(), ERR(), BaseLib::extractBaseNameWithoutExtension(), and BaseLib::IsFileExisting().

Referenced by anonymous_namespace{readMeshFromFile.cpp}::readMeshFromFileSerial().

readVTUFile()

MeshLib::Mesh * MeshLib::IO::VtuInterface::readVTUFile ( std::string const &  file_name )

static

Read an unstructured grid from a VTU file.

Returns

The converted mesh or a nullptr if reading failed

Definition at line 53 of file VtuInterface.cpp.

{
    if (!BaseLib::IsFileExisting(file_name))
    {
        ERR("File '{:s}' does not exist.", file_name);
        return nullptr;
    }
 
    vtkSmartPointer<vtkXMLUnstructuredGridReader> reader =
        vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
    reader->SetFileName(file_name.c_str());
    reader->Update();
 
    vtkUnstructuredGrid* vtkGrid = reader->GetOutput();
    if (vtkGrid->GetNumberOfPoints() == 0)
    {
        ERR("Mesh '{:s}' contains zero points.", file_name);
        return nullptr;
    }
 
    std::string const mesh_name(
        BaseLib::extractBaseNameWithoutExtension(file_name));
    return MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtkGrid,
                                                              mesh_name);
}

References MeshLib::VtkMeshConverter::convertUnstructuredGrid(), ERR(), BaseLib::extractBaseNameWithoutExtension(), and BaseLib::IsFileExisting().

Referenced by OGSFileConverter::convertVTU2MSH(), main(), and anonymous_namespace{readMeshFromFile.cpp}::readMeshFromFileSerial().

writeToFile()

bool MeshLib::IO::VtuInterface::writeToFile

(

std::filesystem::path const &

file_path

)

Writes the given mesh to file.

Returns

True on success, false on error

Definition at line 138 of file VtuInterface.cpp.

{
#ifdef USE_PETSC
    auto const vtu_file_name =
        getVtuFileNameForPetscOutputWithoutExtension(file_path.string());
    int rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    int mpi_size;
    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
    return writeVTU<vtkXMLPUnstructuredGridWriter>(vtu_file_name + ".pvtu",
                                                   mpi_size, rank);
#else
    return writeVTU<vtkXMLUnstructuredGridWriter>(file_path.string());
#endif
}

References MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension().

Referenced by SaveMeshDialog::accept(), convert(), OGSFileConverter::convertMSH2VTU(), main(), ProcessLib::makeOutput(), writeBoundary(), writeDataToMesh(), writeMeshOutput(), MeshLib::IO::writeMeshToFile(), and MeshLib::IO::writeVtu().

writeVTU()

template<typename UnstructuredGridWriter >

bool MeshLib::IO::VtuInterface::writeVTU	(	std::string const &	file_name,
		const int	num_partitions = 1,
		const int	rank = 1
	)

Writes the given mesh to vtu file.

Parameters

file_name	File name.
num_partitions	Number of partitions to be merged.
rank	the rank of the mpi process.

Returns

True on success, false on error

Definition at line 32 of file VtuInterface-impl.h.

{
    if (!_mesh)
    {
        ERR("VtuInterface::write(): No mesh specified.");
        return false;
    }
 
    vtkNew<MeshLib::VtkMappedMeshSource> vtkSource;
    vtkSource->SetMesh(_mesh);
 
    vtkSmartPointer<UnstructuredGridWriter> vtuWriter =
        vtkSmartPointer<UnstructuredGridWriter>::New();
 
    vtkSource->Update();
    vtuWriter->SetInputData(vtkSource->GetOutput());
 
    if (_use_compressor)
    {
        vtuWriter->SetCompressorTypeToZLib();
    }
    else
    {
        vtuWriter->SetCompressorTypeToNone();
    }
 
    vtuWriter->SetDataMode(_data_mode);
    if (_data_mode == vtkXMLWriter::Appended)
    {
        vtuWriter->SetEncodeAppendedData(1);
    }
    if (_data_mode == vtkXMLWriter::Ascii)
    {
        vtkSource->Update();
        vtkSmartPointer<vtkUnstructuredGrid> tempGrid =
            vtkSmartPointer<vtkUnstructuredGrid>::New();
        tempGrid->DeepCopy(vtkSource->GetOutput());
        vtuWriter->SetInputDataObject(tempGrid);
    }
 
    vtuWriter->SetFileName(file_name.c_str());
#ifdef USE_PETSC
    vtuWriter->SetGhostLevel(1);
    vtuWriter->SetNumberOfPieces(num_partitions);
    vtuWriter->SetStartPiece(rank);
    vtuWriter->SetEndPiece(rank);
#else
    // avoid unused parameter warnings.
    (void)num_partitions;
    (void)rank;
#endif
 
#ifdef VTK_USE_64BIT_IDS
    vtuWriter->SetHeaderTypeToUInt64();
    // set SetIdTypeToInt64() as well?
#endif
 
    return (vtuWriter->Write() > 0);
}

References _data_mode, _mesh, _use_compressor, and ERR().

Member Data Documentation

_data_mode

int MeshLib::IO::VtuInterface::_data_mode

private

Definition at line 69 of file VtuInterface.h.

Referenced by VtuInterface(), and writeVTU().

_mesh

const MeshLib::Mesh* MeshLib::IO::VtuInterface::_mesh

private

Definition at line 68 of file VtuInterface.h.

Referenced by writeVTU().

_use_compressor

bool MeshLib::IO::VtuInterface::_use_compressor

private

Definition at line 70 of file VtuInterface.h.

Referenced by writeVTU().

---

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

• MeshLib/IO/VtkIO/VtuInterface.h
• MeshLib/IO/VtkIO/VtuInterface-impl.h
• MeshLib/IO/VtkIO/VtuInterface.cpp