Mesh.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <cstdlib>
#include <memory>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/transform.hpp>
#include <string>
#include <vector>
 
#include "BaseLib/Algorithm.h"
#include "BaseLib/Error.h"
#include "Location.h"
#include "MathLib/Point3d.h"
#include "MeshEnums.h"
#include "Properties.h"
 
namespace ApplicationUtils
{
class NodeWiseMeshPartitioner;
}
 
namespace MeshLib
{
class Node;
class Element;

class Mesh
{
    /* friend functions: */
    friend void removeMeshNodes(Mesh& mesh,
                                const std::vector<std::size_t>& nodes);
 
    friend class ApplicationUtils::NodeWiseMeshPartitioner;
 
public:
    Mesh(std::string name,
         std::vector<Node*>
             nodes,
         std::vector<Element*>
             elements,
         bool const compute_element_neighbors = false,
         Properties const& properties = Properties());

    Mesh(const Mesh& mesh);
 
    Mesh(Mesh&& mesh);
 
    Mesh& operator=(const Mesh& mesh) = delete;
    Mesh& operator=(Mesh&& mesh) = delete;

    virtual ~Mesh();

    void shallowClean();

    void addElement(Element* elem);

    unsigned getDimension() const { return _mesh_dimension; }

    const Node* getNode(std::size_t idx) const { return _nodes[idx]; }

    const Element* getElement(std::size_t idx) const { return _elements[idx]; }

    std::size_t getNumberOfElements() const { return _elements.size(); }

    std::size_t getNumberOfNodes() const { return _nodes.size(); }

    const std::string getName() const { return _name; }

    std::vector<Node*> const& getNodes() const { return _nodes; }

    std::vector<Element*> const& getElements() const { return _elements; }

    void resetElementIDs();

    void resetNodeIDs();

    void setName(const std::string& name) { this->_name = name; }

    std::size_t getID() const { return _id; }

    std::size_t computeNumberOfBaseNodes() const;

    bool hasNonlinearElement() const;
 
    std::vector<Element const*> const& getElementsConnectedToNode(
        std::size_t node_id) const;
    std::vector<Element const*> const& getElementsConnectedToNode(
        Node const& node) const;
 
    Properties& getProperties() { return _properties; }
    Properties const& getProperties() const { return _properties; }
 
    bool isAxiallySymmetric() const { return _is_axially_symmetric; }
    void setAxiallySymmetric(bool is_axial_symmetric)
    {
        _is_axially_symmetric = is_axial_symmetric;
    }
 
protected:
    void setDimension();

    void setElementNeighbors();
 
private:
    static std::size_t nextID();
 
protected:
    std::size_t const _id = nextID();
    unsigned _mesh_dimension = 0;
    std::pair<double, double> _node_distance;
    std::string _name;
    std::vector<Node*> _nodes;
    std::vector<Element*> _elements;
    Properties _properties;
 
    std::vector<std::vector<Element const*>> _elements_connected_to_nodes;
 
    bool _is_axially_symmetric = false;
    bool const _compute_element_neighbors;
}; /* class */

std::vector<std::vector<Node*>> calculateNodesConnectedByElements(
    Mesh const& mesh);

inline bool operator==(Mesh const& a, Mesh const& b)
{
    return a.getID() == b.getID();
}
 
inline bool operator!=(Mesh const& a, Mesh const& b)
{
    return !(a == b);
}

PropertyVector<int> const* materialIDs(Mesh const& mesh);
PropertyVector<int>* materialIDs(Mesh& mesh);
PropertyVector<std::size_t> const* bulkNodeIDs(Mesh const& mesh);
PropertyVector<std::size_t> const* bulkElementIDs(Mesh const& mesh);

bool isBaseNode(Node const& node,
                std::vector<Element const*> const& elements_connected_to_node);

std::pair<double, double> minMaxEdgeLength(
    std::vector<Element*> const& elements);

template <typename T>
bool idsComparator(T const a, T const b)
{
    if constexpr (std::is_pointer_v<T>)
    {
        return a->getID() < b->getID();
    }
    else
    {
        return a.getID() < b.getID();
    }
}
 
Mesh& findMeshByName(std::vector<std::unique_ptr<Mesh>> const& meshes,
                     std::string_view const name);

namespace views
{
inline constexpr ranges::views::view_closure ids =
    ranges::views::transform([](auto const& a) { return a->getID(); });

inline constexpr ranges::views::view_closure names =
    ranges::views::transform([](auto const& a) { return a->getName(); });
 
inline constexpr ranges::views::view_closure coords =
    ranges::views::transform([](MathLib::Point3d const* n)
                             { return std::span(n->data(), n->data() + 3); });
 
inline auto meshLocations(Mesh const& mesh, MeshItemType const item_type)
{
    return ranges::views::iota(std::size_t{0}, mesh.getNumberOfNodes()) |
           ranges::views::transform(
               [mesh_id = mesh.getID(), item_type](std::size_t const n)
               { return Location{mesh_id, item_type, n}; });
}
}  // namespace views
}  // namespace MeshLib