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 29 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 compress=false)
	Provide the mesh to write and set if compression should be used.
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, bool const compute_element_neighbors=false)
static vtkSmartPointer< vtkUnstructuredGrid >	readVtuFileToVtkUnstructuredGrid (std::string const &file_name)
static MeshLib::Mesh *	readVTKFile (std::string const &file_name, bool const compute_element_neighbors=false)

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 compress = false )

explicit

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

Definition at line 30 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, _mesh, _use_compressor, and WARN().

Member Function Documentation

readVTKFile()

MeshLib::Mesh * MeshLib::IO::VtuInterface::readVTKFile ( std::string const & file_name, bool const compute_element_neighbors = false )

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 86 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, compute_element_neighbors, 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, bool const compute_element_neighbors = false )

static

Read an unstructured grid from a VTU file.

Returns

The converted mesh or a nullptr if reading failed

Definition at line 70 of file VtuInterface.cpp.

{
    vtkSmartPointer<vtkUnstructuredGrid> vtkGrid =
        VtuInterface::readVtuFileToVtkUnstructuredGrid(file_name);
    if (vtkGrid == nullptr)
    {
        return nullptr;
    }
 
    std::string const mesh_name(
        BaseLib::extractBaseNameWithoutExtension(file_name));
    return MeshLib::VtkMeshConverter::convertUnstructuredGrid(
        vtkGrid, compute_element_neighbors, mesh_name);
}

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

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

readVtuFileToVtkUnstructuredGrid()

vtkSmartPointer< vtkUnstructuredGrid > MeshLib::IO::VtuInterface::readVtuFileToVtkUnstructuredGrid ( std::string const & file_name )

static

Definition at line 41 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());
    {
        // Reading the VTU files can trigger floating point exceptions. Because
        // we are not debugging VTK (or other libraries) at this point, the
        // floating point exceptions are temporarily disabled and are restored
        // at the end of the scope.
        [[maybe_unused]] DisableFPE disable_fpe;
        reader->Update();
    }
 
    vtkUnstructuredGrid* vtkGrid = reader->GetOutput();
    if (vtkGrid->GetNumberOfPoints() == 0)
    {
        ERR("Mesh '{:s}' contains zero points.", file_name);
        return nullptr;
    }
    return vtkGrid;
}

References ERR(), and BaseLib::IsFileExisting().

Referenced by main(), readGrid(), and readVTUFile().

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 146 of file VtuInterface.cpp.

{
#ifdef USE_PETSC
    BaseLib::MPI::Mpi mpi;
    if (mpi.size == 1)
    {
        return writeVTU<vtkXMLUnstructuredGridWriter>(file_path.string());
    }
    auto const vtu_file_name =
        getVtuFileNameForPetscOutputWithoutExtension(file_path.string());
    return writeVTU<vtkXMLPUnstructuredGridWriter>(vtu_file_name + ".pvtu",
                                                   mpi.size, mpi.rank);
#endif
    return writeVTU<vtkXMLUnstructuredGridWriter>(file_path.string());
}

References MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), BaseLib::MPI::Mpi::rank, BaseLib::MPI::Mpi::size, and writeVTU().

Referenced by SaveMeshDialog::accept(), convert(), OGSFileConverter::convertMSH2VTU(), main(), ProcessLib::outputMeshVtk(), 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 29 of file VtuInterface-impl.h.

{
    if (!_mesh)
    {
        ERR("VtuInterface::write(): No mesh specified.");
        return false;
    }
 
#ifdef USE_PETSC
    if (_mesh->getProperties().existsPropertyVector<unsigned char>(
            "vtkGhostType", MeshLib::MeshItemType::Cell, 1))
    {
        auto* ghost_cell_property =
            _mesh->getProperties().getPropertyVector<unsigned char>(
                "vtkGhostType", MeshLib::MeshItemType::Cell, 1);
        if (ghost_cell_property)
        {
            const_cast<MeshLib::PropertyVector<unsigned char>*>(
                ghost_cell_property)
                ->is_for_output = true;
        }
    }
    else
    {
        DBUG("No vtkGhostType data in mesh '{}'.", _mesh->getName());
    }
#endif
 
    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
    if constexpr (std::is_same_v<UnstructuredGridWriter,
                                 vtkXMLPUnstructuredGridWriter>)
    {
        // Set the writer controller to same communicator as OGS
        vtkSmartPointer<vtkMPICommunicator> vtk_comm =
            vtkSmartPointer<vtkMPICommunicator>::New();
        MPI_Comm mpi_comm = BaseLib::MPI::OGS_COMM_WORLD;
        vtkMPICommunicatorOpaqueComm vtk_opaque_comm(&mpi_comm);
        vtk_comm->InitializeExternal(&vtk_opaque_comm);
 
        vtkSmartPointer<vtkMPIController> vtk_mpi_ctrl =
            vtkSmartPointer<vtkMPIController>::New();
        vtk_mpi_ctrl->SetCommunicator(vtk_comm);
 
        vtuWriter->SetController(vtk_mpi_ctrl);
 
        vtuWriter->SetGhostLevel(1);
        vtuWriter->SetNumberOfPieces(num_partitions);
        vtuWriter->SetStartPiece(rank);
        vtuWriter->SetEndPiece(rank);
    }
#endif
 
#ifdef VTK_USE_64BIT_IDS
    vtuWriter->SetHeaderTypeToUInt64();
    // set SetIdTypeToInt64() as well?
#endif
 
    return (vtuWriter->Write() > 0);
}

References _data_mode, _mesh, _use_compressor, MeshLib::Cell, DBUG(), ERR(), and BaseLib::MPI::OGS_COMM_WORLD.

Referenced by writeToFile().

Member Data Documentation

_data_mode

int MeshLib::IO::VtuInterface::_data_mode

private

Definition at line 68 of file VtuInterface.h.

Referenced by VtuInterface(), and writeVTU().

_mesh

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

private

Definition at line 67 of file VtuInterface.h.

Referenced by VtuInterface(), and writeVTU().

_use_compressor

bool MeshLib::IO::VtuInterface::_use_compressor

private

Definition at line 69 of file VtuInterface.h.

Referenced by VtuInterface(), and writeVTU().

---

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

• VtuInterface.h
• VtuInterface-impl.h
• VtuInterface.cpp