Mesh.h

Go to the documentation of this file.

 
#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;
    }
    void setAxiallySymmetric(bool is_axial_symmetric) {…}
 
protected:
    void calcEdgeLengthRange();
 
    void setDimension();
 
    void setElementNeighbors();
 
    std::size_t const _id;
    unsigned _mesh_dimension;
    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 */
class Mesh {…};
 
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) {…}
 
inline bool operator!=(Mesh const& a, Mesh const& b)
{
    return !(a == b);
}
inline bool operator!=(Mesh const& a, Mesh const& 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();
    }
}
bool idsComparator(T const a, T const b) {…}
 
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}; });
}
inline auto meshLocations(Mesh const& mesh, MeshItemType const item_type) {…}
}  // namespace views
namespace views {…}
}  // namespace MeshLib