MeshLib::VtkMappedMeshSource Class Reference

Detailed Description

Adapter which maps a MeshLib::Mesh to a vtkUnstructuredGridAlgorithm. Allows for zero-copy access of the mesh from the visualization side.

Definition at line 44 of file VtkMappedMeshSource.h.

#include <VtkMappedMeshSource.h>

Inheritance diagram for MeshLib::VtkMappedMeshSource:

Collaboration diagram for MeshLib::VtkMappedMeshSource:

Public Member Functions
	vtkTypeMacro (VtkMappedMeshSource, vtkUnstructuredGridAlgorithm)
void	PrintSelf (std::ostream &os, vtkIndent indent) override
	VtkMappedMeshSource (const VtkMappedMeshSource &)=delete
void	operator= (const VtkMappedMeshSource &)=delete
void	SetMesh (const MeshLib::Mesh *mesh)
	Sets the mesh. Calling is mandatory.
const MeshLib::Mesh *	GetMesh () const
	Returns the mesh.

Static Public Member Functions
static VtkMappedMeshSource *	New ()

Protected Member Functions
	VtkMappedMeshSource ()
int	ProcessRequest (vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector) override
int	RequestData (vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
int	RequestInformation (vtkInformation *, vtkInformationVector **, vtkInformationVector *) override

Private Member Functions
template<typename T >
void	addProperty (MeshLib::PropertyVector< T > const &property) const
	Adds a zero-copy vtk array wrapper.

Private Attributes
const MeshLib::Mesh *	_mesh {}
int	NumberOfDimensions {0}
int	NumberOfNodes {0}
vtkNew< vtkPoints >	Points
vtkNew< vtkPointData >	PointData
vtkNew< vtkCellData >	CellData
vtkNew< vtkFieldData >	FieldData

Constructor & Destructor Documentation

VtkMappedMeshSource() [1/2]

MeshLib::VtkMappedMeshSource::VtkMappedMeshSource ( const VtkMappedMeshSource & )

delete

VtkMappedMeshSource() [2/2]

MeshLib::VtkMappedMeshSource::VtkMappedMeshSource ( )

protected

Definition at line 40 of file VtkMappedMeshSource.cpp.

{
    this->SetNumberOfInputPorts(0);
}

Member Function Documentation

addProperty()

template<typename T >

void MeshLib::VtkMappedMeshSource::addProperty ( MeshLib::PropertyVector< T > const & property ) const

private

Adds a zero-copy vtk array wrapper.

Definition at line 221 of file VtkMappedMeshSource.cpp.

{
    vtkNew<vtkAOSDataArrayTemplate<T>> dataArray;
    const bool hasArrayOwnership = false;
    dataArray->SetArray(const_cast<T*>(property.data()),
                        static_cast<vtkIdType>(property.size()),
                        static_cast<int>(!hasArrayOwnership));
    dataArray->SetNumberOfComponents(property.getNumberOfGlobalComponents());
    dataArray->SetName(property.getPropertyName().c_str());
 
    if (property.getMeshItemType() == MeshLib::MeshItemType::Node)
    {
        this->PointData->AddArray(dataArray.GetPointer());
    }
    else if (property.getMeshItemType() == MeshLib::MeshItemType::Cell)
    {
        this->CellData->AddArray(dataArray.GetPointer());
    }
    else if (property.getMeshItemType() ==
             MeshLib::MeshItemType::IntegrationPoint)
    {
        this->FieldData->AddArray(dataArray.GetPointer());
    }
}

References MeshLib::Cell, CellData, FieldData, MeshLib::PropertyVectorBase::getMeshItemType(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::PropertyVectorBase::getPropertyName(), MeshLib::IntegrationPoint, MeshLib::Node, PointData, and MeshLib::PropertyVector< PROP_VAL_TYPE >::size().

Referenced by RequestData().

GetMesh()

const MeshLib::Mesh * MeshLib::VtkMappedMeshSource::GetMesh ( ) const

inline

Returns the mesh.

Definition at line 62 of file VtkMappedMeshSource.h.

{ return _mesh; }

References _mesh.

Referenced by MeshItem::getMesh(), and MainWindow::showMeshQualitySelectionDialog().

New()

static VtkMappedMeshSource * MeshLib::VtkMappedMeshSource::New ( )

static

Referenced by MeshItem::MeshItem(), and RequestData().

operator=()

void MeshLib::VtkMappedMeshSource::operator= ( const VtkMappedMeshSource & )

delete

PrintSelf()

void MeshLib::VtkMappedMeshSource::PrintSelf ( std::ostream & os, vtkIndent indent )

override

ProcessRequest()

int MeshLib::VtkMappedMeshSource::ProcessRequest ( vtkInformation * request, vtkInformationVector ** inputVector, vtkInformationVector * outputVector )

overrideprotected

Definition at line 46 of file VtkMappedMeshSource.cpp.

{
    if (request->Has(vtkDemandDrivenPipeline::REQUEST_DATA()))
    {
        return this->RequestData(request, inputVector, outputVector);
    }
 
    if (request->Has(vtkDemandDrivenPipeline::REQUEST_INFORMATION()))
    {
        return this->RequestInformation(request, inputVector, outputVector);
    }
 
    return this->Superclass::ProcessRequest(request, inputVector, outputVector);
}

References RequestData(), and RequestInformation().

RequestData()

int MeshLib::VtkMappedMeshSource::RequestData ( vtkInformation * , vtkInformationVector ** , vtkInformationVector * outputVector )

overrideprotected

Definition at line 63 of file VtkMappedMeshSource.cpp.

{
    vtkSmartPointer<vtkInformation> outInfo =
        outputVector->GetInformationObject(0);
    vtkSmartPointer<vtkUnstructuredGrid> output =
        vtkUnstructuredGrid::SafeDownCast(
            outInfo->Get(vtkDataObject::DATA_OBJECT()));
 
    if (outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER()) >
        0)
    {
        return 1;
    }
 
    // Points
    this->Points->Reset();
 
    vtkSmartPointer<VtkMeshNodalCoordinatesTemplate<double>> nodeCoords =
        vtkSmartPointer<VtkMeshNodalCoordinatesTemplate<double>>::New();
    nodeCoords->SetNodes(_mesh->getNodes());
    this->Points->SetData(nodeCoords);
    output->SetPoints(this->Points.GetPointer());
 
    // Cells
    auto elems = _mesh->getElements();
    output->Allocate(elems.size());
    for (auto& cell : elems)
    {
        auto cellType = OGSToVtkCellType(cell->getCellType());
 
        const MeshLib::Element* const elem = cell;
        const unsigned numNodes(elem->getNumberOfNodes());
        const MeshLib::Node* const* nodes = cell->getNodes();
        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
        ptIds->SetNumberOfIds(numNodes);
 
        for (unsigned i = 0; i < numNodes; ++i)
        {
            ptIds->SetId(i, nodes[i]->getID());
        }
 
        if (cellType == VTK_WEDGE)
        {
            for (unsigned i = 0; i < 3; ++i)
            {
                const auto prism_swap_id = ptIds->GetId(i);
                ptIds->SetId(i, ptIds->GetId(i + 3));
                ptIds->SetId(i + 3, prism_swap_id);
            }
        }
 
        output->InsertNextCell(cellType, ptIds);
    }
 
    // Arrays
    for (auto [name, property] : _mesh->getProperties())
    {
        if (!property->is_for_output)
        {
            continue;
        }
        if (auto const* p = dynamic_cast<PropertyVector<double>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p = dynamic_cast<PropertyVector<float>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p = dynamic_cast<PropertyVector<int>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p =
                     dynamic_cast<PropertyVector<unsigned>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p = dynamic_cast<PropertyVector<long>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p =
                     dynamic_cast<PropertyVector<long long>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p =
                     dynamic_cast<PropertyVector<unsigned long>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p =
                     dynamic_cast<PropertyVector<unsigned long long>*>(
                         property))
        {
            addProperty(*p);
        }
        else if (auto const* p =
                     dynamic_cast<PropertyVector<std::size_t>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p = dynamic_cast<PropertyVector<char>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p =
                     dynamic_cast<PropertyVector<unsigned char>*>(property))
        {
            addProperty(*p);
        }
        else if (auto const* p =
                     dynamic_cast<PropertyVector<uint8_t>*>(property))
        {
            addProperty(*p);
        }
        else
        {
            OGS_FATAL(
                "Mesh property '{:s}' of unhandled data type '{:s}'. Please "
                "check the data type of the mesh properties. The available "
                "data types are:"
                "\n\t double,"
                "\n\t float,"
                "\n\t int,"
                "\n\t unsigned,"
                "\n\t long,"
                "\n\t long long,"
                "\n\t unsigned long long,"
                "\n\t char,",
                "\n\t unsigned char,",
                "\n\t uint8_t.",
                property->getPropertyName(),
                typeid(*property).name());
        }
    }
 
    output->GetPointData()->ShallowCopy(this->PointData.GetPointer());
    output->GetCellData()->ShallowCopy(this->CellData.GetPointer());
    output->GetFieldData()->ShallowCopy(this->FieldData.GetPointer());
    return 1;
}

References _mesh, addProperty(), CellData, FieldData, MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::Element::getNumberOfNodes(), MeshLib::Mesh::getProperties(), New(), OGS_FATAL, OGSToVtkCellType(), PointData, and Points.

Referenced by ProcessRequest().

RequestInformation()

int MeshLib::VtkMappedMeshSource::RequestInformation ( vtkInformation * , vtkInformationVector ** , vtkInformationVector *  )

overrideprotected

Definition at line 209 of file VtkMappedMeshSource.cpp.

{
    this->NumberOfDimensions = 3;
    this->NumberOfNodes = _mesh->getNumberOfNodes();
 
    return 1;
}

References _mesh, MeshLib::Mesh::getNumberOfNodes(), NumberOfDimensions, and NumberOfNodes.

Referenced by ProcessRequest().

SetMesh()

void MeshLib::VtkMappedMeshSource::SetMesh ( const MeshLib::Mesh * mesh )

inline

Sets the mesh. Calling is mandatory.

Definition at line 55 of file VtkMappedMeshSource.h.

    {
        this->_mesh = mesh;
        this->Modified();
    }

References _mesh.

vtkTypeMacro()

MeshLib::VtkMappedMeshSource::vtkTypeMacro	(	VtkMappedMeshSource	,
		vtkUnstructuredGridAlgorithm	)

Member Data Documentation

_mesh

const MeshLib::Mesh* MeshLib::VtkMappedMeshSource::_mesh {}

private

Definition at line 82 of file VtkMappedMeshSource.h.

{};

Referenced by GetMesh(), RequestData(), RequestInformation(), SetMesh(), and MeshLib::vtkStandardNewMacro().

CellData

vtkNew<vtkCellData> MeshLib::VtkMappedMeshSource::CellData

private

Definition at line 89 of file VtkMappedMeshSource.h.

Referenced by addProperty(), and RequestData().

FieldData

vtkNew<vtkFieldData> MeshLib::VtkMappedMeshSource::FieldData

private

Definition at line 90 of file VtkMappedMeshSource.h.

Referenced by addProperty(), and RequestData().

NumberOfDimensions

int MeshLib::VtkMappedMeshSource::NumberOfDimensions {0}

private

Definition at line 84 of file VtkMappedMeshSource.h.

{0};

Referenced by RequestInformation().

NumberOfNodes

int MeshLib::VtkMappedMeshSource::NumberOfNodes {0}

private

Definition at line 85 of file VtkMappedMeshSource.h.

{0};

Referenced by RequestInformation().

PointData

vtkNew<vtkPointData> MeshLib::VtkMappedMeshSource::PointData

private

Definition at line 88 of file VtkMappedMeshSource.h.

Referenced by addProperty(), and RequestData().

Points

vtkNew<vtkPoints> MeshLib::VtkMappedMeshSource::Points

private

Definition at line 87 of file VtkMappedMeshSource.h.

Referenced by RequestData().

---

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

• MeshLib/Vtk/VtkMappedMeshSource.h
• MeshLib/Vtk/VtkMappedMeshSource.cpp