OGSMesh Class Reference

Detailed Description

Definition at line 12 of file OGSMesh.h.

#include <OGSMesh.h>

Collaboration diagram for OGSMesh:

Public Member Functions
	OGSMesh (MeshLib::Mesh &mesh)
std::vector< double >	getPointCoordinates () const
std::pair< std::vector< int >, std::vector< int > >	getCells () const
std::vector< std::string >	getDataArrayNames () const
MeshLib::MeshItemType	meshItemType (std::string_view const name) const
template<typename T>
pybind11::array &	dataArray (std::string const &name)
pybind11::object	dataArray_dispatch (std::string const &name, std::string const &dtype)

Private Attributes
MeshLib::Mesh &	_mesh
std::map< std::string, pybind11::array >	data_array_mapping

Constructor & Destructor Documentation

OGSMesh()

OGSMesh::OGSMesh ( MeshLib::Mesh & mesh )

explicit

Definition at line 21 of file OGSMesh.cpp.

: _mesh(mesh) {}

References _mesh.

Member Function Documentation

dataArray()

template<typename T>

pybind11::array & OGSMesh::dataArray ( std::string const & name )

inline

Definition at line 25 of file OGSMesh.h.

    {
        auto const data_array_it = data_array_mapping.find(name);
        if (data_array_it != data_array_mapping.end())
        {
            INFO("found data array '{}' with address: {}", name,
                 fmt::ptr(&(data_array_it->second)));
            return data_array_it->second;
        }
 
        auto& mesh_properties = _mesh.getProperties();
 
        // check if PropertyVector with specified data type T exists
        auto* property = mesh_properties.getPropertyVector<T>(name);
        if (property == nullptr)
        {
            OGS_FATAL("Couldn't access data array '{}'.", name);
        }
 
        // Capsule ties lifetime of the numpy array to the PropertyVector
        auto capsule = pybind11::capsule(property, [](void* /*ignored*/) {});
 
        auto const n_components = property->getNumberOfGlobalComponents();
        if (n_components == 1)
        {
            auto const& [it, success] = data_array_mapping.insert(
                {name,
                 pybind11::array(
                     pybind11::buffer_info(
                         property->data(),  // data pointer
                         sizeof(T),         // item size
                         pybind11::format_descriptor<T>::format(),  // dtype
                                                                    // format
                                                                    // string
                         1,                                         // ndim
                         {property->size()},                        // shape
                         {sizeof(T)}                                // strides
                         ),
                     capsule)});
            if (!success)
            {
                OGS_FATAL("Could not insert data array '{}' into internal map.",
                          name);
            }
            INFO("insert data array '{}' with address: {}", name,
                 fmt::ptr(&(it->second)));
            return it->second;
        }
        else
        {
            // 2D case: (n_items, n_components)
            auto const& [it, success] = data_array_mapping.insert(
                {name,
                 pybind11::array(
                     pybind11::buffer_info(
                         property->data(),  // data pointer
                         sizeof(T),         // item size
                         pybind11::format_descriptor<T>::format(),  // dtype
                                                                    // format
                                                                    // string
                         2,                                         // ndim
                         std::vector<pybind11::ssize_t>{
                             static_cast<pybind11::ssize_t>(property->size() /
                                                            n_components),
                             static_cast<pybind11::ssize_t>(
                                 n_components)},  // shape
                         std::vector<pybind11::ssize_t>{
                             static_cast<pybind11::ssize_t>(sizeof(T) *
                                                            n_components),
                             static_cast<pybind11::ssize_t>(sizeof(T))}
                         // strides
                         ),
                     capsule)});
            if (!success)
            {
                OGS_FATAL("Could not insert data array '{}' into internal map.",
                          name);
            }
            INFO("insert data array '{}' with address: {}", name,
                 fmt::ptr(&(it->second)));
            return it->second;
        }
    }

References _mesh, data_array_mapping, INFO(), and OGS_FATAL.

Referenced by dataArray_dispatch().

dataArray_dispatch()

pybind11::object OGSMesh::dataArray_dispatch ( std::string const & name, std::string const & dtype )

inline

Definition at line 109 of file OGSMesh.h.

    {
        if (dtype == "double")
        {
            return dataArray<double>(name);
        }
        if (dtype == "float")
        {
            return dataArray<float>(name);
        }
        if (dtype == "int")
        {
            return dataArray<int>(name);
        }
        if (dtype == "int64")
        {
            return dataArray<int64_t>(name);
        }
        if (dtype == "std::size_t")
        {
            return dataArray<std::size_t>(name);
        }
        if (dtype == "char")
        {
            return dataArray<char>(name);
        }
 
        throw std::runtime_error("Unsupported dtype: " + dtype);
    }

References dataArray().

Referenced by PYBIND11_MODULE().

getCells()

std::pair< std::vector< int >, std::vector< int > > OGSMesh::getCells

(

)

const

Definition at line 29 of file OGSMesh.cpp.

{
    auto const& elements = _mesh.getElements();
    std::vector<int> cells;
    std::vector<int> cell_types;
    for (auto const* element : elements)
    {
        ranges::copy(element->nodes() | MeshLib::views::ids,
                     std::back_inserter(cells));
        cell_types.push_back(OGSToVtkCellType(element->getCellType()));
    }
    return {cells, cell_types};
}

References _mesh, MeshLib::views::ids, and OGSToVtkCellType().

Referenced by PYBIND11_MODULE().

getDataArrayNames()

std::vector< std::string > OGSMesh::getDataArrayNames

(

)

const

Definition at line 43 of file OGSMesh.cpp.

{
    return _mesh.getProperties().getPropertyVectorNames();
}

References _mesh.

Referenced by PYBIND11_MODULE().

getPointCoordinates()

std::vector< double > OGSMesh::getPointCoordinates

(

)

const

Definition at line 23 of file OGSMesh.cpp.

{
    return ranges::to<std::vector>(_mesh.getNodes() | MeshLib::views::coords |
                                   ranges::views::join);
}

References _mesh, and MeshLib::views::coords.

Referenced by PYBIND11_MODULE().

meshItemType()

MeshLib::MeshItemType OGSMesh::meshItemType

(

std::string_view const

name

)

const

Definition at line 48 of file OGSMesh.cpp.

{
    auto const& properties = _mesh.getProperties();
 
    auto const& found = BaseLib::findElementOrError(
        properties,
        [&name](auto const& p) { return p.first == name; },
        [&name]()
        {
            OGS_FATAL("A property with the name '{}' doesn't exist in the mesh",
                      name);
        });
    return found.second->getMeshItemType();
}

References _mesh, BaseLib::findElementOrError(), and OGS_FATAL.

Referenced by PYBIND11_MODULE().

Member Data Documentation

_mesh

MeshLib::Mesh& OGSMesh::_mesh

private

Definition at line 141 of file OGSMesh.h.

Referenced by OGSMesh(), dataArray(), getCells(), getDataArrayNames(), getPointCoordinates(), and meshItemType().

data_array_mapping

std::map<std::string, pybind11::array> OGSMesh::data_array_mapping

private

Definition at line 142 of file OGSMesh.h.

Referenced by dataArray().

---

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

• OGSMesh.h
• OGSMesh.cpp