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 31 of file VtuInterface.h.

#include <VtuInterface.h>

Collaboration diagram for MeshLib::IO::VtuInterface:

[legend]

Public Member Functions
	VtuInterface (const MeshLib::Mesh *mesh, std::set< std::string > const &output_variable_names={}, 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
std::set< std::string >	_output_variable_names
int	_data_mode
bool	_use_compressor

Constructor & Destructor Documentation

◆ VtuInterface()

MeshLib::IO::VtuInterface::VtuInterface	(	const MeshLib::Mesh *	mesh,
		std::set< std::string > const &	output_variable_names = {},
		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),
      _output_variable_names(output_variable_names),
      _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, _output_variable_names, _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 91 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 75 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 46 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 151 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 OGSFileConverter::convertMSH2VTU(), main(), ProcessLib::outputMeshVtk(), writeBoundary(), writeDataToMesh(), and MeshLib::IO::writeMeshToFile().

◆ 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>(
            vtkGhostTypeString, MeshLib::MeshItemType::Cell, 1))
    {
        if (_output_variable_names.find(vtkGhostTypeString) ==
            _output_variable_names.cend())
        {
            _output_variable_names.insert(vtkGhostTypeString);
        }
    }
    else
    {
        DBUG(
            "No '{}' data in mesh '{}'.", vtkGhostTypeString, _mesh->getName());
    }
#endif
 
    vtkNew<MeshLib::VtkMappedMeshSource> vtkSource;
    vtkSource->SetMesh(_mesh);
    vtkSource->setOutputVariableNames(_output_variable_names);
 
    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, _output_variable_names, _use_compressor, MeshLib::Cell, DBUG(), ERR(), BaseLib::MPI::OGS_COMM_WORLD, and MeshLib::vtkGhostTypeString.

Referenced by writeToFile().

Member Data Documentation

◆ _data_mode

int MeshLib::IO::VtuInterface::_data_mode

private

Definition at line 73 of file VtuInterface.h.

Referenced by VtuInterface(), and writeVTU().

◆ _mesh

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

private

Definition at line 71 of file VtuInterface.h.

Referenced by VtuInterface(), and writeVTU().

◆ _output_variable_names

std::set<std::string> MeshLib::IO::VtuInterface::_output_variable_names

private

Definition at line 72 of file VtuInterface.h.

Referenced by VtuInterface(), and writeVTU().

◆ _use_compressor

bool MeshLib::IO::VtuInterface::_use_compressor

private

Definition at line 74 of file VtuInterface.h.

Referenced by VtuInterface(), and writeVTU().

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

Detailed Description

Public Member Functions

Static Public Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ VtuInterface()

Member Function Documentation

◆ readVTKFile()

◆ readVTUFile()

◆ readVtuFileToVtkUnstructuredGrid()

◆ writeToFile()

◆ writeVTU()

Member Data Documentation

◆ _data_mode

◆ _mesh

◆ _output_variable_names

◆ _use_compressor