diff --git a/src/mesh/CMakeLists.txt b/src/mesh/CMakeLists.txt index 99d9680a55263e0de7434676fb5478df7d6438cb..78b72bcafc640ecc888c0997eeb3ff8f3056db58 100644 --- a/src/mesh/CMakeLists.txt +++ b/src/mesh/CMakeLists.txt @@ -35,6 +35,7 @@ add_library( MeshLineFaceBoundary.cpp MeshLineNodeBoundary.cpp MeshNodeBoundary.cpp + MeshNodeBoundaryUtils.cpp MeshNodeInterface.cpp MeshRandomizer.cpp MeshRelaxer.cpp diff --git a/src/mesh/MeshEdgeBoundary.cpp b/src/mesh/MeshEdgeBoundary.cpp index 4c60b3424e93470e0135ee34fb81e870058e2fa9..0a4aed04bb9e54e0f35dda08e3b9ce5e8f584559 100644 --- a/src/mesh/MeshEdgeBoundary.cpp +++ b/src/mesh/MeshEdgeBoundary.cpp @@ -5,19 +5,19 @@ #include <mesh/Mesh.hpp> #include <utils/Messenger.hpp> -template <size_t Dimension> -MeshEdgeBoundary<Dimension>::MeshEdgeBoundary(const Mesh<Connectivity<Dimension>>&, const RefEdgeList& ref_edge_list) - : m_ref_edge_list(ref_edge_list) +template <typename MeshType> +MeshEdgeBoundary::MeshEdgeBoundary(const MeshType&, const RefEdgeList& ref_edge_list) : m_ref_edge_list(ref_edge_list) {} -template MeshEdgeBoundary<1>::MeshEdgeBoundary(const Mesh<Connectivity<1>>&, const RefEdgeList&); -template MeshEdgeBoundary<2>::MeshEdgeBoundary(const Mesh<Connectivity<2>>&, const RefEdgeList&); -template MeshEdgeBoundary<3>::MeshEdgeBoundary(const Mesh<Connectivity<3>>&, const RefEdgeList&); +template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<1>>&, const RefEdgeList&); +template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<2>>&, const RefEdgeList&); +template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<3>>&, const RefEdgeList&); -template <size_t Dimension> -MeshEdgeBoundary<Dimension>::MeshEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const RefFaceList& ref_face_list) +template <typename MeshType> +MeshEdgeBoundary::MeshEdgeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list) { + constexpr size_t Dimension = MeshType::Dimension; + const Array<const FaceId>& face_list = ref_face_list.list(); static_assert(Dimension > 1, "conversion from to edge from face is valid in dimension > 1"); @@ -55,13 +55,15 @@ MeshEdgeBoundary<Dimension>::MeshEdgeBoundary(const Mesh<Connectivity<Dimension> const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_edge_list); } -template MeshEdgeBoundary<2>::MeshEdgeBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&); -template MeshEdgeBoundary<3>::MeshEdgeBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&); +template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&); +template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&); -template <size_t Dimension> -MeshEdgeBoundary<Dimension> -getMeshEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDescriptor& boundary_descriptor) +template <typename MeshType> +MeshEdgeBoundary +getMeshEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { + constexpr size_t Dimension = MeshType::Dimension; + for (size_t i_ref_edge_list = 0; i_ref_edge_list < mesh.connectivity().template numberOfRefItemList<ItemType::edge>(); ++i_ref_edge_list) { const auto& ref_edge_list = mesh.connectivity().template refItemList<ItemType::edge>(i_ref_edge_list); @@ -76,7 +78,7 @@ getMeshEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDe throw NormalError(ost.str()); } - return MeshEdgeBoundary<Dimension>{mesh, ref_edge_list}; + return MeshEdgeBoundary{mesh, ref_edge_list}; } } if constexpr (Dimension > 1) { @@ -94,7 +96,7 @@ getMeshEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDe throw NormalError(ost.str()); } - return MeshEdgeBoundary<Dimension>{mesh, ref_face_list}; + return MeshEdgeBoundary{mesh, ref_face_list}; } } } @@ -105,6 +107,6 @@ getMeshEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDe throw NormalError(ost.str()); } -template MeshEdgeBoundary<1> getMeshEdgeBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&); -template MeshEdgeBoundary<2> getMeshEdgeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); -template MeshEdgeBoundary<3> getMeshEdgeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); +template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&); +template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); +template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); diff --git a/src/mesh/MeshEdgeBoundary.hpp b/src/mesh/MeshEdgeBoundary.hpp index e37c4fdffefdc494c97bd8ddbea61f656ef938b7..c65106b2d3d0d7958f0c3010295f07f7a9e9b6d9 100644 --- a/src/mesh/MeshEdgeBoundary.hpp +++ b/src/mesh/MeshEdgeBoundary.hpp @@ -6,52 +6,47 @@ #include <mesh/RefItemList.hpp> #include <utils/Array.hpp> -template <size_t Dimension> -class Connectivity; - -template <typename ConnectivityType> -class Mesh; - -template <size_t Dimension> class [[nodiscard]] MeshEdgeBoundary // clazy:exclude=copyable-polymorphic { protected: RefEdgeList m_ref_edge_list; public: - template <size_t MeshDimension> - friend MeshEdgeBoundary<MeshDimension> getMeshEdgeBoundary(const Mesh<Connectivity<MeshDimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); + template <typename MeshType> + friend MeshEdgeBoundary getMeshEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor); MeshEdgeBoundary& operator=(const MeshEdgeBoundary&) = default; - MeshEdgeBoundary& operator=(MeshEdgeBoundary&&) = default; + MeshEdgeBoundary& operator=(MeshEdgeBoundary&&) = default; PUGS_INLINE - const RefEdgeList& refEdgeList() const + const RefEdgeList& + refEdgeList() const { return m_ref_edge_list; } PUGS_INLINE - const Array<const EdgeId>& edgeList() const + const Array<const EdgeId>& + edgeList() const { return m_ref_edge_list.list(); } protected: - MeshEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefEdgeList& ref_edge_list); - MeshEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list); + template <typename MeshType> + MeshEdgeBoundary(const MeshType& mesh, const RefEdgeList& ref_edge_list); + template <typename MeshType> + MeshEdgeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list); public: MeshEdgeBoundary(const MeshEdgeBoundary&) = default; // LCOV_EXCL_LINE - MeshEdgeBoundary(MeshEdgeBoundary &&) = default; // LCOV_EXCL_LINE + MeshEdgeBoundary(MeshEdgeBoundary&&) = default; // LCOV_EXCL_LINE MeshEdgeBoundary() = default; virtual ~MeshEdgeBoundary() = default; }; -template <size_t Dimension> -MeshEdgeBoundary<Dimension> getMeshEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); +template <typename MeshType> +MeshEdgeBoundary getMeshEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_EDGE_BOUNDARY_HPP diff --git a/src/mesh/MeshFaceBoundary.cpp b/src/mesh/MeshFaceBoundary.cpp index ad77830f5cbcb10070cfb7cb4989a7065a650f16..3a578bb7893040ca3838581b0b7c5ad5d297d9a3 100644 --- a/src/mesh/MeshFaceBoundary.cpp +++ b/src/mesh/MeshFaceBoundary.cpp @@ -4,18 +4,17 @@ #include <mesh/Mesh.hpp> #include <utils/Messenger.hpp> -template <size_t Dimension> -MeshFaceBoundary<Dimension>::MeshFaceBoundary(const Mesh<Connectivity<Dimension>>&, const RefFaceList& ref_face_list) - : m_ref_face_list(ref_face_list) +template <typename MeshType> +MeshFaceBoundary::MeshFaceBoundary(const MeshType&, const RefFaceList& ref_face_list) : m_ref_face_list(ref_face_list) {} -template MeshFaceBoundary<1>::MeshFaceBoundary(const Mesh<Connectivity<1>>&, const RefFaceList&); -template MeshFaceBoundary<2>::MeshFaceBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&); -template MeshFaceBoundary<3>::MeshFaceBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&); +template MeshFaceBoundary::MeshFaceBoundary(const Mesh<Connectivity<1>>&, const RefFaceList&); +template MeshFaceBoundary::MeshFaceBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&); +template MeshFaceBoundary::MeshFaceBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&); -template <size_t Dimension> -MeshFaceBoundary<Dimension> -getMeshFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDescriptor& boundary_descriptor) +template <typename MeshType> +MeshFaceBoundary +getMeshFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>(); ++i_ref_face_list) { @@ -31,7 +30,7 @@ getMeshFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDe throw NormalError(ost.str()); } - return MeshFaceBoundary<Dimension>{mesh, ref_face_list}; + return MeshFaceBoundary{mesh, ref_face_list}; } } @@ -41,6 +40,6 @@ getMeshFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDe throw NormalError(ost.str()); } -template MeshFaceBoundary<1> getMeshFaceBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&); -template MeshFaceBoundary<2> getMeshFaceBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); -template MeshFaceBoundary<3> getMeshFaceBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); +template MeshFaceBoundary getMeshFaceBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&); +template MeshFaceBoundary getMeshFaceBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); +template MeshFaceBoundary getMeshFaceBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); diff --git a/src/mesh/MeshFaceBoundary.hpp b/src/mesh/MeshFaceBoundary.hpp index 98a63774138e60bbb01437ee4fb6d88bd1400e40..c44aafa66c6f9f47dfc839a39025a42ae614b441 100644 --- a/src/mesh/MeshFaceBoundary.hpp +++ b/src/mesh/MeshFaceBoundary.hpp @@ -6,51 +6,45 @@ #include <mesh/RefItemList.hpp> #include <utils/Array.hpp> -template <size_t Dimension> -class Connectivity; - -template <typename ConnectivityType> -class Mesh; - -template <size_t Dimension> class [[nodiscard]] MeshFaceBoundary // clazy:exclude=copyable-polymorphic { protected: RefFaceList m_ref_face_list; public: - template <size_t MeshDimension> - friend MeshFaceBoundary<MeshDimension> getMeshFaceBoundary(const Mesh<Connectivity<MeshDimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); + template <typename MeshTypeT> + friend MeshFaceBoundary getMeshFaceBoundary(const MeshTypeT& mesh, const IBoundaryDescriptor& boundary_descriptor); MeshFaceBoundary& operator=(const MeshFaceBoundary&) = default; - MeshFaceBoundary& operator=(MeshFaceBoundary&&) = default; + MeshFaceBoundary& operator=(MeshFaceBoundary&&) = default; PUGS_INLINE - const RefFaceList& refFaceList() const + const RefFaceList& + refFaceList() const { return m_ref_face_list; } PUGS_INLINE - const Array<const FaceId>& faceList() const + const Array<const FaceId>& + faceList() const { return m_ref_face_list.list(); } protected: - MeshFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list); + template <typename MeshType> + MeshFaceBoundary(const MeshType& mesh, const RefFaceList& ref_face_list); public: MeshFaceBoundary(const MeshFaceBoundary&) = default; // LCOV_EXCL_LINE - MeshFaceBoundary(MeshFaceBoundary &&) = default; // LCOV_EXCL_LINE + MeshFaceBoundary(MeshFaceBoundary&&) = default; // LCOV_EXCL_LINE MeshFaceBoundary() = default; virtual ~MeshFaceBoundary() = default; }; -template <size_t Dimension> -MeshFaceBoundary<Dimension> getMeshFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); +template <typename MeshType> +MeshFaceBoundary getMeshFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_FACE_BOUNDARY_HPP diff --git a/src/mesh/MeshFlatEdgeBoundary.cpp b/src/mesh/MeshFlatEdgeBoundary.cpp index d4c1ec155a0e8c4d863facbf6280d71265944933..3783049ff2422e899f90210c1ffba722f71a4767 100644 --- a/src/mesh/MeshFlatEdgeBoundary.cpp +++ b/src/mesh/MeshFlatEdgeBoundary.cpp @@ -4,17 +4,20 @@ #include <mesh/Mesh.hpp> #include <mesh/MeshFlatNodeBoundary.hpp> -template <size_t Dimension> -MeshFlatEdgeBoundary<Dimension> -getMeshFlatEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDescriptor& boundary_descriptor) +template <typename MeshType> +MeshFlatEdgeBoundary<const MeshType> +getMeshFlatEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { - MeshEdgeBoundary<Dimension> mesh_edge_boundary = getMeshEdgeBoundary(mesh, boundary_descriptor); - MeshFlatNodeBoundary<Dimension> mesh_flat_node_boundary = getMeshFlatNodeBoundary(mesh, boundary_descriptor); + MeshEdgeBoundary mesh_edge_boundary = getMeshEdgeBoundary(mesh, boundary_descriptor); + MeshFlatNodeBoundary mesh_flat_node_boundary = getMeshFlatNodeBoundary(mesh, boundary_descriptor); - return MeshFlatEdgeBoundary<Dimension>{mesh, mesh_edge_boundary.refEdgeList(), - mesh_flat_node_boundary.outgoingNormal()}; + return MeshFlatEdgeBoundary<const MeshType>{mesh, mesh_edge_boundary.refEdgeList(), + mesh_flat_node_boundary.outgoingNormal()}; } -template MeshFlatEdgeBoundary<1> getMeshFlatEdgeBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&); -template MeshFlatEdgeBoundary<2> getMeshFlatEdgeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); -template MeshFlatEdgeBoundary<3> getMeshFlatEdgeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); +template MeshFlatEdgeBoundary<const Mesh<Connectivity<1>>> getMeshFlatEdgeBoundary(const Mesh<Connectivity<1>>&, + const IBoundaryDescriptor&); +template MeshFlatEdgeBoundary<const Mesh<Connectivity<2>>> getMeshFlatEdgeBoundary(const Mesh<Connectivity<2>>&, + const IBoundaryDescriptor&); +template MeshFlatEdgeBoundary<const Mesh<Connectivity<3>>> getMeshFlatEdgeBoundary(const Mesh<Connectivity<3>>&, + const IBoundaryDescriptor&); diff --git a/src/mesh/MeshFlatEdgeBoundary.hpp b/src/mesh/MeshFlatEdgeBoundary.hpp index a104d1413a7319f08b74bf1ef103a5157b803f18..60b54257fb8b038a110ba4860c4b5c54586d0307 100644 --- a/src/mesh/MeshFlatEdgeBoundary.hpp +++ b/src/mesh/MeshFlatEdgeBoundary.hpp @@ -3,11 +3,11 @@ #include <mesh/MeshEdgeBoundary.hpp> -template <size_t Dimension> -class MeshFlatEdgeBoundary final : public MeshEdgeBoundary<Dimension> // clazy:exclude=copyable-polymorphic +template <typename MeshType> +class MeshFlatEdgeBoundary final : public MeshEdgeBoundary // clazy:exclude=copyable-polymorphic { public: - using Rd = TinyVector<Dimension, double>; + using Rd = TinyVector<MeshType::Dimension, double>; private: const Rd m_outgoing_normal; @@ -20,16 +20,15 @@ class MeshFlatEdgeBoundary final : public MeshEdgeBoundary<Dimension> // clazy } MeshFlatEdgeBoundary& operator=(const MeshFlatEdgeBoundary&) = default; - MeshFlatEdgeBoundary& operator=(MeshFlatEdgeBoundary&&) = default; + MeshFlatEdgeBoundary& operator=(MeshFlatEdgeBoundary&&) = default; - template <size_t MeshDimension> - friend MeshFlatEdgeBoundary<MeshDimension> getMeshFlatEdgeBoundary(const Mesh<Connectivity<MeshDimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); + template <typename MeshTypeT> + friend MeshFlatEdgeBoundary<const MeshTypeT> getMeshFlatEdgeBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); private: - template <typename MeshType> MeshFlatEdgeBoundary(const MeshType& mesh, const RefEdgeList& ref_edge_list, const Rd& outgoing_normal) - : MeshEdgeBoundary<Dimension>(mesh, ref_edge_list), m_outgoing_normal(outgoing_normal) + : MeshEdgeBoundary(mesh, ref_edge_list), m_outgoing_normal(outgoing_normal) {} public: @@ -39,8 +38,8 @@ class MeshFlatEdgeBoundary final : public MeshEdgeBoundary<Dimension> // clazy ~MeshFlatEdgeBoundary() = default; }; -template <size_t Dimension> -MeshFlatEdgeBoundary<Dimension> getMeshFlatEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); +template <typename MeshType> +MeshFlatEdgeBoundary<const MeshType> getMeshFlatEdgeBoundary(const MeshType& mesh, + const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_FLAT_EDGE_BOUNDARY_HPP diff --git a/src/mesh/MeshFlatFaceBoundary.cpp b/src/mesh/MeshFlatFaceBoundary.cpp index 87d353e25404c3b5996a63945a9e220e49e97e55..e05373897dce3421af35fa94a06bb89dd760ec35 100644 --- a/src/mesh/MeshFlatFaceBoundary.cpp +++ b/src/mesh/MeshFlatFaceBoundary.cpp @@ -4,17 +4,20 @@ #include <mesh/Mesh.hpp> #include <mesh/MeshFlatNodeBoundary.hpp> -template <size_t Dimension> -MeshFlatFaceBoundary<Dimension> -getMeshFlatFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDescriptor& boundary_descriptor) +template <typename MeshType> +MeshFlatFaceBoundary<const MeshType> +getMeshFlatFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { - MeshFaceBoundary<Dimension> mesh_face_boundary = getMeshFaceBoundary(mesh, boundary_descriptor); - MeshFlatNodeBoundary<Dimension> mesh_flat_node_boundary = getMeshFlatNodeBoundary(mesh, boundary_descriptor); + MeshFaceBoundary mesh_face_boundary = getMeshFaceBoundary(mesh, boundary_descriptor); + MeshFlatNodeBoundary mesh_flat_node_boundary = getMeshFlatNodeBoundary(mesh, boundary_descriptor); - return MeshFlatFaceBoundary<Dimension>{mesh, mesh_face_boundary.refFaceList(), - mesh_flat_node_boundary.outgoingNormal()}; + return MeshFlatFaceBoundary<const MeshType>{mesh, mesh_face_boundary.refFaceList(), + mesh_flat_node_boundary.outgoingNormal()}; } -template MeshFlatFaceBoundary<1> getMeshFlatFaceBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&); -template MeshFlatFaceBoundary<2> getMeshFlatFaceBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); -template MeshFlatFaceBoundary<3> getMeshFlatFaceBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); +template MeshFlatFaceBoundary<const Mesh<Connectivity<1>>> getMeshFlatFaceBoundary(const Mesh<Connectivity<1>>&, + const IBoundaryDescriptor&); +template MeshFlatFaceBoundary<const Mesh<Connectivity<2>>> getMeshFlatFaceBoundary(const Mesh<Connectivity<2>>&, + const IBoundaryDescriptor&); +template MeshFlatFaceBoundary<const Mesh<Connectivity<3>>> getMeshFlatFaceBoundary(const Mesh<Connectivity<3>>&, + const IBoundaryDescriptor&); diff --git a/src/mesh/MeshFlatFaceBoundary.hpp b/src/mesh/MeshFlatFaceBoundary.hpp index f3d34e16c5d52af38033e82dcd75e6897f392a3d..3620d0f3db39b0754fa85c72fa2b441327d7012b 100644 --- a/src/mesh/MeshFlatFaceBoundary.hpp +++ b/src/mesh/MeshFlatFaceBoundary.hpp @@ -3,11 +3,11 @@ #include <mesh/MeshFaceBoundary.hpp> -template <size_t Dimension> -class MeshFlatFaceBoundary final : public MeshFaceBoundary<Dimension> // clazy:exclude=copyable-polymorphic +template <typename MeshType> +class MeshFlatFaceBoundary final : public MeshFaceBoundary // clazy:exclude=copyable-polymorphic { public: - using Rd = TinyVector<Dimension, double>; + using Rd = TinyVector<MeshType::Dimension, double>; private: const Rd m_outgoing_normal; @@ -20,16 +20,15 @@ class MeshFlatFaceBoundary final : public MeshFaceBoundary<Dimension> // clazy } MeshFlatFaceBoundary& operator=(const MeshFlatFaceBoundary&) = default; - MeshFlatFaceBoundary& operator=(MeshFlatFaceBoundary&&) = default; + MeshFlatFaceBoundary& operator=(MeshFlatFaceBoundary&&) = default; - template <size_t MeshDimension> - friend MeshFlatFaceBoundary<MeshDimension> getMeshFlatFaceBoundary(const Mesh<Connectivity<MeshDimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); + template <typename MeshTypeT> + friend MeshFlatFaceBoundary<const MeshTypeT> getMeshFlatFaceBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); private: - template <typename MeshType> MeshFlatFaceBoundary(const MeshType& mesh, const RefFaceList& ref_face_list, const Rd& outgoing_normal) - : MeshFaceBoundary<Dimension>(mesh, ref_face_list), m_outgoing_normal(outgoing_normal) + : MeshFaceBoundary(mesh, ref_face_list), m_outgoing_normal(outgoing_normal) {} public: @@ -39,8 +38,8 @@ class MeshFlatFaceBoundary final : public MeshFaceBoundary<Dimension> // clazy ~MeshFlatFaceBoundary() = default; }; -template <size_t Dimension> -MeshFlatFaceBoundary<Dimension> getMeshFlatFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); +template <typename MeshType> +MeshFlatFaceBoundary<const MeshType> getMeshFlatFaceBoundary(const MeshType& mesh, + const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_FLAT_FACE_BOUNDARY_HPP diff --git a/src/mesh/MeshFlatNodeBoundary.cpp b/src/mesh/MeshFlatNodeBoundary.cpp index f5e60af046b49903304762aec86a237d7b2a868a..3ee564332b57c1bdf5a1f219af6417d9b9c0844c 100644 --- a/src/mesh/MeshFlatNodeBoundary.cpp +++ b/src/mesh/MeshFlatNodeBoundary.cpp @@ -2,14 +2,15 @@ #include <mesh/Connectivity.hpp> #include <mesh/Mesh.hpp> +#include <mesh/MeshNodeBoundaryUtils.hpp> #include <utils/Messenger.hpp> -template <size_t Dimension> +template <typename MeshType> void -MeshFlatNodeBoundary<Dimension>::_checkBoundaryIsFlat(const TinyVector<Dimension, double>& normal, - const TinyVector<Dimension, double>& origin, - const double length, - const Mesh<Connectivity<Dimension>>& mesh) const +MeshFlatNodeBoundary<MeshType>::_checkBoundaryIsFlat(const TinyVector<MeshType::Dimension, double>& normal, + const TinyVector<MeshType::Dimension, double>& origin, + const double length, + const MeshType& mesh) const { const NodeValue<const Rd>& xr = mesh.xr(); @@ -33,7 +34,7 @@ MeshFlatNodeBoundary<Dimension>::_checkBoundaryIsFlat(const TinyVector<Dimension template <> TinyVector<1, double> -MeshFlatNodeBoundary<1>::_getNormal(const Mesh<Connectivity<1>>& mesh) +MeshFlatNodeBoundary<const Mesh<Connectivity<1>>>::_getNormal(const Mesh<Connectivity<1>>& mesh) { using R = TinyVector<1, double>; @@ -59,11 +60,11 @@ MeshFlatNodeBoundary<1>::_getNormal(const Mesh<Connectivity<1>>& mesh) template <> TinyVector<2, double> -MeshFlatNodeBoundary<2>::_getNormal(const Mesh<Connectivity<2>>& mesh) +MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getNormal(const Mesh<Connectivity<2>>& mesh) { using R2 = TinyVector<2, double>; - std::array<R2, 2> bounds = this->_getBounds(mesh); + std::array<R2, 2> bounds = getBounds(mesh, m_ref_node_list); const R2& xmin = bounds[0]; const R2& xmax = bounds[1]; @@ -87,7 +88,9 @@ MeshFlatNodeBoundary<2>::_getNormal(const Mesh<Connectivity<2>>& mesh) template <> TinyVector<3, double> -MeshFlatNodeBoundary<3>::_getFarestNode(const Mesh<Connectivity<3>>& mesh, const Rd& x0, const Rd& x1) +MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getFarestNode(const Mesh<Connectivity<3>>& mesh, + const Rd& x0, + const Rd& x1) { const NodeValue<const Rd>& xr = mesh.xr(); const auto node_number = mesh.connectivity().nodeNumber(); @@ -138,7 +141,7 @@ MeshFlatNodeBoundary<3>::_getFarestNode(const Mesh<Connectivity<3>>& mesh, const template <> TinyVector<3, double> -MeshFlatNodeBoundary<3>::_getNormal(const Mesh<Connectivity<3>>& mesh) +MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getNormal(const Mesh<Connectivity<3>>& mesh) { using R3 = TinyVector<3, double>; @@ -159,7 +162,7 @@ MeshFlatNodeBoundary<3>::_getNormal(const Mesh<Connectivity<3>>& mesh) } return std::array<R3, 2>{bounds[max_i], bounds[max_j]}; - }(this->_getBounds(mesh)); + }(getBounds(mesh, m_ref_node_list)); const R3& x0 = diagonal[0]; const R3& x1 = diagonal[1]; @@ -195,7 +198,7 @@ MeshFlatNodeBoundary<3>::_getNormal(const Mesh<Connectivity<3>>& mesh) template <> TinyVector<1, double> -MeshFlatNodeBoundary<1>::_getOutgoingNormal(const Mesh<Connectivity<1>>& mesh) +MeshFlatNodeBoundary<const Mesh<Connectivity<1>>>::_getOutgoingNormal(const Mesh<Connectivity<1>>& mesh) { using R = TinyVector<1, double>; @@ -238,7 +241,7 @@ MeshFlatNodeBoundary<1>::_getOutgoingNormal(const Mesh<Connectivity<1>>& mesh) template <> TinyVector<2, double> -MeshFlatNodeBoundary<2>::_getOutgoingNormal(const Mesh<Connectivity<2>>& mesh) +MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getOutgoingNormal(const Mesh<Connectivity<2>>& mesh) { using R2 = TinyVector<2, double>; @@ -281,7 +284,7 @@ MeshFlatNodeBoundary<2>::_getOutgoingNormal(const Mesh<Connectivity<2>>& mesh) template <> TinyVector<3, double> -MeshFlatNodeBoundary<3>::_getOutgoingNormal(const Mesh<Connectivity<3>>& mesh) +MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getOutgoingNormal(const Mesh<Connectivity<3>>& mesh) { using R3 = TinyVector<3, double>; @@ -322,16 +325,16 @@ MeshFlatNodeBoundary<3>::_getOutgoingNormal(const Mesh<Connectivity<3>>& mesh) } } -template <size_t Dimension> -MeshFlatNodeBoundary<Dimension> -getMeshFlatNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDescriptor& boundary_descriptor) +template <typename MeshType> +MeshFlatNodeBoundary<const MeshType> +getMeshFlatNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { for (size_t i_ref_node_list = 0; i_ref_node_list < mesh.connectivity().template numberOfRefItemList<ItemType::node>(); ++i_ref_node_list) { const auto& ref_node_list = mesh.connectivity().template refItemList<ItemType::node>(i_ref_node_list); const RefId& ref = ref_node_list.refId(); if (ref == boundary_descriptor) { - return MeshFlatNodeBoundary<Dimension>{mesh, ref_node_list}; + return MeshFlatNodeBoundary<const MeshType>{mesh, ref_node_list}; } } for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>(); @@ -339,7 +342,7 @@ getMeshFlatNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBounda const auto& ref_face_list = mesh.connectivity().template refItemList<ItemType::face>(i_ref_face_list); const RefId& ref = ref_face_list.refId(); if (ref == boundary_descriptor) { - return MeshFlatNodeBoundary<Dimension>{mesh, ref_face_list}; + return MeshFlatNodeBoundary<const MeshType>{mesh, ref_face_list}; } } @@ -349,6 +352,9 @@ getMeshFlatNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBounda throw NormalError(ost.str()); } -template MeshFlatNodeBoundary<1> getMeshFlatNodeBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&); -template MeshFlatNodeBoundary<2> getMeshFlatNodeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); -template MeshFlatNodeBoundary<3> getMeshFlatNodeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); +template MeshFlatNodeBoundary<const Mesh<Connectivity<1>>> getMeshFlatNodeBoundary(const Mesh<Connectivity<1>>&, + const IBoundaryDescriptor&); +template MeshFlatNodeBoundary<const Mesh<Connectivity<2>>> getMeshFlatNodeBoundary(const Mesh<Connectivity<2>>&, + const IBoundaryDescriptor&); +template MeshFlatNodeBoundary<const Mesh<Connectivity<3>>> getMeshFlatNodeBoundary(const Mesh<Connectivity<3>>&, + const IBoundaryDescriptor&); diff --git a/src/mesh/MeshFlatNodeBoundary.hpp b/src/mesh/MeshFlatNodeBoundary.hpp index 54a10ae1c1412005440cd9e6cc49973c017265e0..df3c9d28851c635d6079f87082356717edfa0b52 100644 --- a/src/mesh/MeshFlatNodeBoundary.hpp +++ b/src/mesh/MeshFlatNodeBoundary.hpp @@ -3,26 +3,25 @@ #include <mesh/MeshNodeBoundary.hpp> -template <size_t Dimension> -class [[nodiscard]] MeshFlatNodeBoundary final - : public MeshNodeBoundary<Dimension> // clazy:exclude=copyable-polymorphic +template <typename MeshType> +class [[nodiscard]] MeshFlatNodeBoundary final : public MeshNodeBoundary // clazy:exclude=copyable-polymorphic { public: - using Rd = TinyVector<Dimension, double>; + using Rd = TinyVector<MeshType::Dimension, double>; private: const Rd m_outgoing_normal; - Rd _getFarestNode(const Mesh<Connectivity<Dimension>>& mesh, const Rd& x0, const Rd& x1); + Rd _getFarestNode(const MeshType& mesh, const Rd& x0, const Rd& x1); - Rd _getNormal(const Mesh<Connectivity<Dimension>>& mesh); + Rd _getNormal(const MeshType& mesh); - void _checkBoundaryIsFlat(const TinyVector<Dimension, double>& normal, - const TinyVector<Dimension, double>& origin, + void _checkBoundaryIsFlat(const TinyVector<MeshType::Dimension, double>& normal, + const TinyVector<MeshType::Dimension, double>& origin, const double length, - const Mesh<Connectivity<Dimension>>& mesh) const; + const MeshType& mesh) const; - Rd _getOutgoingNormal(const Mesh<Connectivity<Dimension>>& mesh); + Rd _getOutgoingNormal(const MeshType& mesh); public: const Rd& @@ -34,19 +33,17 @@ class [[nodiscard]] MeshFlatNodeBoundary final MeshFlatNodeBoundary& operator=(const MeshFlatNodeBoundary&) = default; MeshFlatNodeBoundary& operator=(MeshFlatNodeBoundary&&) = default; - template <size_t MeshDimension> - friend MeshFlatNodeBoundary<MeshDimension> getMeshFlatNodeBoundary(const Mesh<Connectivity<MeshDimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); + template <typename MeshTypeT> + friend MeshFlatNodeBoundary<const MeshTypeT> getMeshFlatNodeBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); private: - template <typename MeshType> MeshFlatNodeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list) - : MeshNodeBoundary<Dimension>(mesh, ref_face_list), m_outgoing_normal(_getOutgoingNormal(mesh)) + : MeshNodeBoundary(mesh, ref_face_list), m_outgoing_normal(_getOutgoingNormal(mesh)) {} - template <typename MeshType> MeshFlatNodeBoundary(const MeshType& mesh, const RefNodeList& ref_node_list) - : MeshNodeBoundary<Dimension>(mesh, ref_node_list), m_outgoing_normal(_getOutgoingNormal(mesh)) + : MeshNodeBoundary(mesh, ref_node_list), m_outgoing_normal(_getOutgoingNormal(mesh)) {} public: @@ -56,8 +53,8 @@ class [[nodiscard]] MeshFlatNodeBoundary final ~MeshFlatNodeBoundary() = default; }; -template <size_t Dimension> -MeshFlatNodeBoundary<Dimension> getMeshFlatNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); +template <typename MeshType> +MeshFlatNodeBoundary<const MeshType> getMeshFlatNodeBoundary(const MeshType& mesh, + const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_FLAT_NODE_BOUNDARY_HPP diff --git a/src/mesh/MeshLineEdgeBoundary.cpp b/src/mesh/MeshLineEdgeBoundary.cpp index 16e2e3e9764d1465cd767c130fbf27b0e7589afd..31c4bb52465870eb4c6def597d1faa89e8df9e73 100644 --- a/src/mesh/MeshLineEdgeBoundary.cpp +++ b/src/mesh/MeshLineEdgeBoundary.cpp @@ -5,15 +5,18 @@ #include <mesh/MeshLineNodeBoundary.hpp> #include <utils/Messenger.hpp> -template <size_t Dimension> -MeshLineEdgeBoundary<Dimension> -getMeshLineEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDescriptor& boundary_descriptor) +template <typename MeshType> +MeshLineEdgeBoundary<const MeshType> +getMeshLineEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { - MeshEdgeBoundary<Dimension> mesh_edge_boundary = getMeshEdgeBoundary(mesh, boundary_descriptor); - MeshLineNodeBoundary<Dimension> mesh_line_node_boundary = getMeshLineNodeBoundary(mesh, boundary_descriptor); + MeshEdgeBoundary mesh_edge_boundary = getMeshEdgeBoundary(mesh, boundary_descriptor); + MeshLineNodeBoundary mesh_line_node_boundary = getMeshLineNodeBoundary(mesh, boundary_descriptor); - return MeshLineEdgeBoundary<Dimension>{mesh, mesh_edge_boundary.refEdgeList(), mesh_line_node_boundary.direction()}; + return MeshLineEdgeBoundary<const MeshType>{mesh, mesh_edge_boundary.refEdgeList(), + mesh_line_node_boundary.direction()}; } -template MeshLineEdgeBoundary<2> getMeshLineEdgeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); -template MeshLineEdgeBoundary<3> getMeshLineEdgeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); +template MeshLineEdgeBoundary<const Mesh<Connectivity<2>>> getMeshLineEdgeBoundary(const Mesh<Connectivity<2>>&, + const IBoundaryDescriptor&); +template MeshLineEdgeBoundary<const Mesh<Connectivity<3>>> getMeshLineEdgeBoundary(const Mesh<Connectivity<3>>&, + const IBoundaryDescriptor&); diff --git a/src/mesh/MeshLineEdgeBoundary.hpp b/src/mesh/MeshLineEdgeBoundary.hpp index 160444648524f266941a8d2903124bf91b77ee8b..b120a6882896e354f899a8c59b178c48f8934610 100644 --- a/src/mesh/MeshLineEdgeBoundary.hpp +++ b/src/mesh/MeshLineEdgeBoundary.hpp @@ -4,46 +4,46 @@ #include <algebra/TinyMatrix.hpp> #include <mesh/MeshEdgeBoundary.hpp> -template <size_t Dimension> -class [[nodiscard]] MeshLineEdgeBoundary final - : public MeshEdgeBoundary<Dimension> // clazy:exclude=copyable-polymorphic +template <typename MeshType> +class [[nodiscard]] MeshLineEdgeBoundary final : public MeshEdgeBoundary // clazy:exclude=copyable-polymorphic { public: - static_assert(Dimension > 1, "MeshLineEdgeBoundary makes only sense in dimension 1"); + static_assert(MeshType::Dimension > 1, "MeshLineEdgeBoundary makes only sense in dimension 1"); - using Rd = TinyVector<Dimension, double>; + using Rd = TinyVector<MeshType::Dimension, double>; private: const Rd m_direction; public: - template <size_t MeshDimension> - friend MeshLineEdgeBoundary<MeshDimension> getMeshLineEdgeBoundary(const Mesh<Connectivity<MeshDimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); + template <typename MeshTypeT> + friend MeshLineEdgeBoundary<const MeshTypeT> getMeshLineEdgeBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); PUGS_INLINE - const Rd& direction() const + const Rd& + direction() const { return m_direction; } MeshLineEdgeBoundary& operator=(const MeshLineEdgeBoundary&) = default; - MeshLineEdgeBoundary& operator=(MeshLineEdgeBoundary&&) = default; + MeshLineEdgeBoundary& operator=(MeshLineEdgeBoundary&&) = default; private: - MeshLineEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefEdgeList& ref_edge_list, const Rd& direction) - : MeshEdgeBoundary<Dimension>(mesh, ref_edge_list), m_direction(direction) + MeshLineEdgeBoundary(const MeshType& mesh, const RefEdgeList& ref_edge_list, const Rd& direction) + : MeshEdgeBoundary(mesh, ref_edge_list), m_direction(direction) {} public: MeshLineEdgeBoundary() = default; MeshLineEdgeBoundary(const MeshLineEdgeBoundary&) = default; - MeshLineEdgeBoundary(MeshLineEdgeBoundary &&) = default; + MeshLineEdgeBoundary(MeshLineEdgeBoundary&&) = default; ~MeshLineEdgeBoundary() = default; }; -template <size_t Dimension> -MeshLineEdgeBoundary<Dimension> getMeshLineEdgeBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); +template <typename MeshType> +MeshLineEdgeBoundary<const MeshType> getMeshLineEdgeBoundary(const MeshType& mesh, + const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_LINE_EDGE_BOUNDARY_HPP diff --git a/src/mesh/MeshLineFaceBoundary.cpp b/src/mesh/MeshLineFaceBoundary.cpp index cd67176349d0edb475001c58acc99d9cac9792ec..e81aef554062fe97509a2ebd770652828743d265 100644 --- a/src/mesh/MeshLineFaceBoundary.cpp +++ b/src/mesh/MeshLineFaceBoundary.cpp @@ -5,14 +5,16 @@ #include <mesh/MeshLineNodeBoundary.hpp> #include <utils/Messenger.hpp> -template <size_t Dimension> -MeshLineFaceBoundary<Dimension> -getMeshLineFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDescriptor& boundary_descriptor) +template <typename MeshType> +MeshLineFaceBoundary<const MeshType> +getMeshLineFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { - MeshFaceBoundary<Dimension> mesh_face_boundary = getMeshFaceBoundary(mesh, boundary_descriptor); - MeshLineNodeBoundary<Dimension> mesh_line_node_boundary = getMeshLineNodeBoundary(mesh, boundary_descriptor); + MeshFaceBoundary mesh_face_boundary = getMeshFaceBoundary(mesh, boundary_descriptor); + MeshLineNodeBoundary mesh_line_node_boundary = getMeshLineNodeBoundary(mesh, boundary_descriptor); - return MeshLineFaceBoundary<Dimension>{mesh, mesh_face_boundary.refFaceList(), mesh_line_node_boundary.direction()}; + return MeshLineFaceBoundary<const MeshType>{mesh, mesh_face_boundary.refFaceList(), + mesh_line_node_boundary.direction()}; } -template MeshLineFaceBoundary<2> getMeshLineFaceBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); +template MeshLineFaceBoundary<const Mesh<Connectivity<2>>> getMeshLineFaceBoundary(const Mesh<Connectivity<2>>&, + const IBoundaryDescriptor&); diff --git a/src/mesh/MeshLineFaceBoundary.hpp b/src/mesh/MeshLineFaceBoundary.hpp index 5631361f5f995883d80c5317a178eab122ddcda9..f95611bb8fd7f2f02ad11e505bb11df45395e32b 100644 --- a/src/mesh/MeshLineFaceBoundary.hpp +++ b/src/mesh/MeshLineFaceBoundary.hpp @@ -4,46 +4,46 @@ #include <algebra/TinyMatrix.hpp> #include <mesh/MeshFaceBoundary.hpp> -template <size_t Dimension> -class [[nodiscard]] MeshLineFaceBoundary final - : public MeshFaceBoundary<Dimension> // clazy:exclude=copyable-polymorphic +template <typename MeshType> +class [[nodiscard]] MeshLineFaceBoundary final : public MeshFaceBoundary // clazy:exclude=copyable-polymorphic { public: - static_assert(Dimension == 2, "MeshLineFaceBoundary makes only sense in dimension 2"); + static_assert(MeshType::Dimension == 2, "MeshLineFaceBoundary makes only sense in dimension 2"); - using Rd = TinyVector<Dimension, double>; + using Rd = TinyVector<MeshType::Dimension, double>; private: const Rd m_direction; public: - template <size_t MeshDimension> - friend MeshLineFaceBoundary<MeshDimension> getMeshLineFaceBoundary(const Mesh<Connectivity<MeshDimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); + template <typename MeshTypeT> + friend MeshLineFaceBoundary<const MeshTypeT> getMeshLineFaceBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); PUGS_INLINE - const Rd& direction() const + const Rd& + direction() const { return m_direction; } MeshLineFaceBoundary& operator=(const MeshLineFaceBoundary&) = default; - MeshLineFaceBoundary& operator=(MeshLineFaceBoundary&&) = default; + MeshLineFaceBoundary& operator=(MeshLineFaceBoundary&&) = default; private: - MeshLineFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list, const Rd& direction) - : MeshFaceBoundary<Dimension>(mesh, ref_face_list), m_direction(direction) + MeshLineFaceBoundary(const MeshType& mesh, const RefFaceList& ref_face_list, const Rd& direction) + : MeshFaceBoundary(mesh, ref_face_list), m_direction(direction) {} public: MeshLineFaceBoundary() = default; MeshLineFaceBoundary(const MeshLineFaceBoundary&) = default; - MeshLineFaceBoundary(MeshLineFaceBoundary &&) = default; + MeshLineFaceBoundary(MeshLineFaceBoundary&&) = default; ~MeshLineFaceBoundary() = default; }; -template <size_t Dimension> -MeshLineFaceBoundary<Dimension> getMeshLineFaceBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); +template <typename MeshType> +MeshLineFaceBoundary<const MeshType> getMeshLineFaceBoundary(const MeshType& mesh, + const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_LINE_FACE_BOUNDARY_HPP diff --git a/src/mesh/MeshLineNodeBoundary.cpp b/src/mesh/MeshLineNodeBoundary.cpp index 1b126f6207719d648415edbc41be6bb83c36abe7..a03c6102ba1ceeb37c35b75f3cd02040313b569d 100644 --- a/src/mesh/MeshLineNodeBoundary.cpp +++ b/src/mesh/MeshLineNodeBoundary.cpp @@ -2,16 +2,17 @@ #include <mesh/Connectivity.hpp> #include <mesh/Mesh.hpp> +#include <mesh/MeshNodeBoundaryUtils.hpp> #include <utils/Messenger.hpp> -template <size_t Dimension> +template <typename MeshType> void -MeshLineNodeBoundary<Dimension>::_checkBoundaryIsLine(const TinyVector<Dimension, double>& direction, - const TinyVector<Dimension, double>& origin, - const double length, - const Mesh<Connectivity<Dimension>>& mesh) const +MeshLineNodeBoundary<MeshType>::_checkBoundaryIsLine(const TinyVector<MeshType::Dimension, double>& direction, + const TinyVector<MeshType::Dimension, double>& origin, + const double length, + const MeshType& mesh) const { - using Rdxd = TinyMatrix<Dimension>; + using Rdxd = TinyMatrix<MeshType::Dimension>; const NodeValue<const Rd>& xr = mesh.xr(); @@ -35,14 +36,13 @@ MeshLineNodeBoundary<Dimension>::_checkBoundaryIsLine(const TinyVector<Dimension } } -template <> template <> TinyVector<2> -MeshLineNodeBoundary<2>::_getDirection(const Mesh<Connectivity<2>>& mesh) +MeshLineNodeBoundary<const Mesh<Connectivity<2>>>::_getDirection(const Mesh<Connectivity<2>>& mesh) { using R2 = TinyVector<2, double>; - std::array<R2, 2> bounds = this->_getBounds(mesh); + std::array<R2, 2> bounds = getBounds(mesh, m_ref_node_list); const R2& xmin = bounds[0]; const R2& xmax = bounds[1]; @@ -63,14 +63,13 @@ MeshLineNodeBoundary<2>::_getDirection(const Mesh<Connectivity<2>>& mesh) return direction; } -template <> template <> TinyVector<3> -MeshLineNodeBoundary<3>::_getDirection(const Mesh<Connectivity<3>>& mesh) +MeshLineNodeBoundary<const Mesh<Connectivity<3>>>::_getDirection(const Mesh<Connectivity<3>>& mesh) { using R3 = TinyVector<3, double>; - std::array<R3, 6> bounds = this->_getBounds(mesh); + std::array<R3, 6> bounds = getBounds(mesh, m_ref_node_list); const R3& xmin = bounds[0]; const R3& ymin = bounds[1]; @@ -106,16 +105,16 @@ MeshLineNodeBoundary<3>::_getDirection(const Mesh<Connectivity<3>>& mesh) return direction; } -template <size_t Dimension> -MeshLineNodeBoundary<Dimension> -getMeshLineNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDescriptor& boundary_descriptor) +template <typename MeshType> +MeshLineNodeBoundary<const MeshType> +getMeshLineNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { for (size_t i_ref_node_list = 0; i_ref_node_list < mesh.connectivity().template numberOfRefItemList<ItemType::node>(); ++i_ref_node_list) { const auto& ref_node_list = mesh.connectivity().template refItemList<ItemType::node>(i_ref_node_list); const RefId& ref = ref_node_list.refId(); if (ref == boundary_descriptor) { - return MeshLineNodeBoundary<Dimension>{mesh, ref_node_list}; + return MeshLineNodeBoundary<const MeshType>{mesh, ref_node_list}; } } for (size_t i_ref_edge_list = 0; i_ref_edge_list < mesh.connectivity().template numberOfRefItemList<ItemType::edge>(); @@ -123,7 +122,7 @@ getMeshLineNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBounda const auto& ref_edge_list = mesh.connectivity().template refItemList<ItemType::edge>(i_ref_edge_list); const RefId& ref = ref_edge_list.refId(); if (ref == boundary_descriptor) { - return MeshLineNodeBoundary<Dimension>{mesh, ref_edge_list}; + return MeshLineNodeBoundary<const MeshType>{mesh, ref_edge_list}; } } for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>(); @@ -131,7 +130,7 @@ getMeshLineNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBounda const auto& ref_face_list = mesh.connectivity().template refItemList<ItemType::face>(i_ref_face_list); const RefId& ref = ref_face_list.refId(); if (ref == boundary_descriptor) { - return MeshLineNodeBoundary<Dimension>{mesh, ref_face_list}; + return MeshLineNodeBoundary<const MeshType>{mesh, ref_face_list}; } } @@ -141,5 +140,7 @@ getMeshLineNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBounda throw NormalError(ost.str()); } -template MeshLineNodeBoundary<2> getMeshLineNodeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); -template MeshLineNodeBoundary<3> getMeshLineNodeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); +template MeshLineNodeBoundary<const Mesh<Connectivity<2>>> getMeshLineNodeBoundary(const Mesh<Connectivity<2>>&, + const IBoundaryDescriptor&); +template MeshLineNodeBoundary<const Mesh<Connectivity<3>>> getMeshLineNodeBoundary(const Mesh<Connectivity<3>>&, + const IBoundaryDescriptor&); diff --git a/src/mesh/MeshLineNodeBoundary.hpp b/src/mesh/MeshLineNodeBoundary.hpp index 730b9f536bbf5563d656b59c0d246ff71193ea57..50dbfa00b7e1bad64882562876ff40bb37adff77 100644 --- a/src/mesh/MeshLineNodeBoundary.hpp +++ b/src/mesh/MeshLineNodeBoundary.hpp @@ -4,60 +4,61 @@ #include <algebra/TinyMatrix.hpp> #include <mesh/MeshNodeBoundary.hpp> -template <size_t Dimension> -class [[nodiscard]] MeshLineNodeBoundary final - : public MeshNodeBoundary<Dimension> // clazy:exclude=copyable-polymorphic +template <typename MeshType> +class [[nodiscard]] MeshLineNodeBoundary final : public MeshNodeBoundary // clazy:exclude=copyable-polymorphic { public: - static_assert(Dimension > 1, "MeshLineNodeBoundary makes only sense in dimension greater than 1"); + static_assert(MeshType::Dimension > 1, "MeshLineNodeBoundary makes only sense in dimension greater than 1"); - using Rd = TinyVector<Dimension, double>; + using Rd = TinyVector<MeshType::Dimension, double>; private: const Rd m_direction; - template <size_t MeshDimension> - TinyVector<MeshDimension> _getDirection(const Mesh<Connectivity<MeshDimension>>&); + TinyVector<MeshType::Dimension> _getDirection(const MeshType&); - void _checkBoundaryIsLine(const TinyVector<Dimension, double>& direction, const TinyVector<Dimension, double>& origin, - const double length, const Mesh<Connectivity<Dimension>>& mesh) const; + void _checkBoundaryIsLine(const TinyVector<MeshType::Dimension, double>& direction, + const TinyVector<MeshType::Dimension, double>& origin, + const double length, + const MeshType& mesh) const; public: - template <size_t MeshDimension> - friend MeshLineNodeBoundary<MeshDimension> getMeshLineNodeBoundary(const Mesh<Connectivity<MeshDimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); + template <typename MeshTypeT> + friend MeshLineNodeBoundary<const MeshTypeT> getMeshLineNodeBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); PUGS_INLINE - const Rd& direction() const + const Rd& + direction() const { return m_direction; } MeshLineNodeBoundary& operator=(const MeshLineNodeBoundary&) = default; - MeshLineNodeBoundary& operator=(MeshLineNodeBoundary&&) = default; + MeshLineNodeBoundary& operator=(MeshLineNodeBoundary&&) = default; private: - MeshLineNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefEdgeList& ref_edge_list) - : MeshNodeBoundary<Dimension>(mesh, ref_edge_list), m_direction(_getDirection(mesh)) + MeshLineNodeBoundary(const MeshType& mesh, const RefEdgeList& ref_edge_list) + : MeshNodeBoundary(mesh, ref_edge_list), m_direction(_getDirection(mesh)) {} - MeshLineNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list) - : MeshNodeBoundary<Dimension>(mesh, ref_face_list), m_direction(_getDirection(mesh)) + MeshLineNodeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list) + : MeshNodeBoundary(mesh, ref_face_list), m_direction(_getDirection(mesh)) {} - MeshLineNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefNodeList& ref_node_list) - : MeshNodeBoundary<Dimension>(mesh, ref_node_list), m_direction(_getDirection(mesh)) + MeshLineNodeBoundary(const MeshType& mesh, const RefNodeList& ref_node_list) + : MeshNodeBoundary(mesh, ref_node_list), m_direction(_getDirection(mesh)) {} public: MeshLineNodeBoundary() = default; MeshLineNodeBoundary(const MeshLineNodeBoundary&) = default; - MeshLineNodeBoundary(MeshLineNodeBoundary &&) = default; + MeshLineNodeBoundary(MeshLineNodeBoundary&&) = default; ~MeshLineNodeBoundary() = default; }; -template <size_t Dimension> -MeshLineNodeBoundary<Dimension> getMeshLineNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); +template <typename MeshType> +MeshLineNodeBoundary<const MeshType> getMeshLineNodeBoundary(const MeshType& mesh, + const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_LINE_NODE_BOUNDARY_HPP diff --git a/src/mesh/MeshNodeBoundary.cpp b/src/mesh/MeshNodeBoundary.cpp index e883aa4eeb80b40962218208fc044f964a7d4a8d..97f32e9d433553e4d1826f21be08a46e48a91a78 100644 --- a/src/mesh/MeshNodeBoundary.cpp +++ b/src/mesh/MeshNodeBoundary.cpp @@ -5,175 +5,11 @@ #include <mesh/Mesh.hpp> #include <utils/Messenger.hpp> -template <> -std::array<TinyVector<2>, 2> -MeshNodeBoundary<2>::_getBounds(const Mesh<Connectivity<2>>& mesh) const +template <typename MeshType> +MeshNodeBoundary::MeshNodeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list) { - using R2 = TinyVector<2, double>; + constexpr size_t Dimension = MeshType::Dimension; - const NodeValue<const R2>& xr = mesh.xr(); - - std::array<R2, 2> bounds; - R2& xmin = bounds[0]; - R2& xmax = bounds[1]; - - xmin = R2{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; - xmax = R2{-std::numeric_limits<double>::max(), -std::numeric_limits<double>::max()}; - - auto update_xmin = [](const R2& x, R2& x_min) { - if ((x[0] < x_min[0]) or ((x[0] == x_min[0]) and (x[1] < x_min[1]))) { - x_min = x; - } - }; - - auto update_xmax = [](const R2& x, R2& x_max) { - if ((x[0] > x_max[0]) or ((x[0] == x_max[0]) and (x[1] > x_max[1]))) { - x_max = x; - } - }; - - auto node_list = m_ref_node_list.list(); - for (size_t r = 0; r < node_list.size(); ++r) { - const R2& x = xr[node_list[r]]; - update_xmin(x, xmin); - update_xmax(x, xmax); - } - - if (parallel::size() > 1) { - Array<R2> xmin_array = parallel::allGather(xmin); - Array<R2> xmax_array = parallel::allGather(xmax); - for (size_t i = 0; i < xmin_array.size(); ++i) { - update_xmin(xmin_array[i], xmin); - } - for (size_t i = 0; i < xmax_array.size(); ++i) { - update_xmax(xmax_array[i], xmax); - } - } - - return bounds; -} - -template <> -std::array<TinyVector<3>, 6> -MeshNodeBoundary<3>::_getBounds(const Mesh<Connectivity<3>>& mesh) const -{ - using R3 = TinyVector<3, double>; - - auto update_xmin = [](const R3& x, R3& xmin) { - // XMIN: X.xmin X.ymax X.zmax - if ((x[0] < xmin[0]) or ((x[0] == xmin[0]) and (x[1] > xmin[1])) or - ((x[0] == xmin[0]) and (x[1] == xmin[1]) and (x[2] > xmin[2]))) { - xmin = x; - } - }; - - auto update_xmax = [](const R3& x, R3& xmax) { - // XMAX: X.xmax X.ymin X.zmin - if ((x[0] > xmax[0]) or ((x[0] == xmax[0]) and (x[1] < xmax[1])) or - ((x[0] == xmax[0]) and (x[1] == xmax[1]) and (x[2] < xmax[2]))) { - xmax = x; - } - }; - - auto update_ymin = [](const R3& x, R3& ymin) { - // YMIN: X.ymin X.zmax X.xmin - if ((x[1] < ymin[1]) or ((x[1] == ymin[1]) and (x[2] > ymin[2])) or - ((x[1] == ymin[1]) and (x[2] == ymin[2]) and (x[0] < ymin[0]))) { - ymin = x; - } - }; - - auto update_ymax = [](const R3& x, R3& ymax) { - // YMAX: X.ymax X.zmin X.xmax - if ((x[1] > ymax[1]) or ((x[1] == ymax[1]) and (x[2] < ymax[2])) or - ((x[1] == ymax[1]) and (x[2] == ymax[2]) and (x[0] > ymax[0]))) { - ymax = x; - } - }; - - auto update_zmin = [](const R3& x, R3& zmin) { - // ZMIN: X.zmin X.xmin X.ymin - if ((x[2] < zmin[2]) or ((x[2] == zmin[2]) and (x[0] < zmin[0])) or - ((x[2] == zmin[2]) and (x[0] == zmin[0]) and (x[1] < zmin[1]))) { - zmin = x; - } - }; - - auto update_zmax = [](const R3& x, R3& zmax) { - // ZMAX: X.zmax X.xmax X.ymax - if ((x[2] > zmax[2]) or ((x[2] == zmax[2]) and (x[0] > zmax[0])) or - ((x[2] == zmax[2]) and (x[0] == zmax[0]) and (x[1] > zmax[1]))) { - zmax = x; - } - }; - - std::array<R3, 6> bounds; - R3& xmin = bounds[0]; - R3& ymin = bounds[1]; - R3& zmin = bounds[2]; - R3& xmax = bounds[3]; - R3& ymax = bounds[4]; - R3& zmax = bounds[5]; - - xmin = R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; - ymin = R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; - zmin = R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; - - xmax = - -R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; - ymax = - -R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; - zmax = - -R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; - - const NodeValue<const R3>& xr = mesh.xr(); - - auto node_list = m_ref_node_list.list(); - for (size_t r = 0; r < node_list.size(); ++r) { - const R3& x = xr[node_list[r]]; - update_xmin(x, xmin); - update_ymin(x, ymin); - update_zmin(x, zmin); - update_xmax(x, xmax); - update_ymax(x, ymax); - update_zmax(x, zmax); - } - - if (parallel::size() > 1) { - Array<const R3> xmin_array = parallel::allGather(xmin); - Array<const R3> ymin_array = parallel::allGather(ymin); - Array<const R3> zmin_array = parallel::allGather(zmin); - Array<const R3> xmax_array = parallel::allGather(xmax); - Array<const R3> ymax_array = parallel::allGather(ymax); - Array<const R3> zmax_array = parallel::allGather(zmax); - - for (size_t i = 0; i < xmin_array.size(); ++i) { - update_xmin(xmin_array[i], xmin); - } - for (size_t i = 0; i < ymin_array.size(); ++i) { - update_ymin(ymin_array[i], ymin); - } - for (size_t i = 0; i < zmin_array.size(); ++i) { - update_zmin(zmin_array[i], zmin); - } - for (size_t i = 0; i < xmax_array.size(); ++i) { - update_xmax(xmax_array[i], xmax); - } - for (size_t i = 0; i < ymax_array.size(); ++i) { - update_ymax(ymax_array[i], ymax); - } - for (size_t i = 0; i < zmax_array.size(); ++i) { - update_zmax(zmax_array[i], zmax); - } - } - - return bounds; -} - -template <size_t Dimension> -MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const RefFaceList& ref_face_list) -{ const Array<const FaceId>& face_list = ref_face_list.list(); if (ref_face_list.type() != RefItemListBase::Type::boundary) { std::ostringstream ost; @@ -216,10 +52,11 @@ MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension> const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_node_list); } -template <size_t Dimension> -MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const RefEdgeList& ref_edge_list) +template <typename MeshType> +MeshNodeBoundary::MeshNodeBoundary(const MeshType& mesh, const RefEdgeList& ref_edge_list) { + constexpr size_t Dimension = MeshType::Dimension; + const Array<const EdgeId>& edge_list = ref_edge_list.list(); if (ref_edge_list.type() != RefItemListBase::Type::boundary) { std::ostringstream ost; @@ -261,9 +98,8 @@ MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension> const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_node_list); } -template <size_t Dimension> -MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension>>&, const RefNodeList& ref_node_list) - : m_ref_node_list(ref_node_list) +template <typename MeshType> +MeshNodeBoundary::MeshNodeBoundary(const MeshType&, const RefNodeList& ref_node_list) : m_ref_node_list(ref_node_list) { if (ref_node_list.type() != RefItemListBase::Type::boundary) { std::ostringstream ost; @@ -273,28 +109,28 @@ MeshNodeBoundary<Dimension>::MeshNodeBoundary(const Mesh<Connectivity<Dimension> } } -template MeshNodeBoundary<1>::MeshNodeBoundary(const Mesh<Connectivity<1>>&, const RefFaceList&); -template MeshNodeBoundary<2>::MeshNodeBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&); -template MeshNodeBoundary<3>::MeshNodeBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&); +template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<1>>&, const RefFaceList&); +template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&); +template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&); -template MeshNodeBoundary<1>::MeshNodeBoundary(const Mesh<Connectivity<1>>&, const RefEdgeList&); -template MeshNodeBoundary<2>::MeshNodeBoundary(const Mesh<Connectivity<2>>&, const RefEdgeList&); -template MeshNodeBoundary<3>::MeshNodeBoundary(const Mesh<Connectivity<3>>&, const RefEdgeList&); +template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<1>>&, const RefEdgeList&); +template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<2>>&, const RefEdgeList&); +template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<3>>&, const RefEdgeList&); -template MeshNodeBoundary<1>::MeshNodeBoundary(const Mesh<Connectivity<1>>&, const RefNodeList&); -template MeshNodeBoundary<2>::MeshNodeBoundary(const Mesh<Connectivity<2>>&, const RefNodeList&); -template MeshNodeBoundary<3>::MeshNodeBoundary(const Mesh<Connectivity<3>>&, const RefNodeList&); +template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<1>>&, const RefNodeList&); +template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<2>>&, const RefNodeList&); +template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<3>>&, const RefNodeList&); -template <size_t Dimension> -MeshNodeBoundary<Dimension> -getMeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDescriptor& boundary_descriptor) +template <typename MeshType> +MeshNodeBoundary +getMeshNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { for (size_t i_ref_node_list = 0; i_ref_node_list < mesh.connectivity().template numberOfRefItemList<ItemType::node>(); ++i_ref_node_list) { const auto& ref_node_list = mesh.connectivity().template refItemList<ItemType::node>(i_ref_node_list); const RefId& ref = ref_node_list.refId(); if (ref == boundary_descriptor) { - return MeshNodeBoundary<Dimension>{mesh, ref_node_list}; + return MeshNodeBoundary{mesh, ref_node_list}; } } for (size_t i_ref_edge_list = 0; i_ref_edge_list < mesh.connectivity().template numberOfRefItemList<ItemType::edge>(); @@ -302,7 +138,7 @@ getMeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDe const auto& ref_edge_list = mesh.connectivity().template refItemList<ItemType::edge>(i_ref_edge_list); const RefId& ref = ref_edge_list.refId(); if (ref == boundary_descriptor) { - return MeshNodeBoundary<Dimension>{mesh, ref_edge_list}; + return MeshNodeBoundary{mesh, ref_edge_list}; } } for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>(); @@ -310,7 +146,7 @@ getMeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDe const auto& ref_face_list = mesh.connectivity().template refItemList<ItemType::face>(i_ref_face_list); const RefId& ref = ref_face_list.refId(); if (ref == boundary_descriptor) { - return MeshNodeBoundary<Dimension>{mesh, ref_face_list}; + return MeshNodeBoundary{mesh, ref_face_list}; } } @@ -320,6 +156,6 @@ getMeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const IBoundaryDe throw NormalError(ost.str()); } -template MeshNodeBoundary<1> getMeshNodeBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&); -template MeshNodeBoundary<2> getMeshNodeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); -template MeshNodeBoundary<3> getMeshNodeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); +template MeshNodeBoundary getMeshNodeBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&); +template MeshNodeBoundary getMeshNodeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&); +template MeshNodeBoundary getMeshNodeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&); diff --git a/src/mesh/MeshNodeBoundary.hpp b/src/mesh/MeshNodeBoundary.hpp index ce56579e853171e4b5be0d1f195936a75b838f78..0e869e2eef5b9783aba66840e050071cc3ddf57d 100644 --- a/src/mesh/MeshNodeBoundary.hpp +++ b/src/mesh/MeshNodeBoundary.hpp @@ -6,56 +6,49 @@ #include <mesh/RefItemList.hpp> #include <utils/Array.hpp> -template <size_t Dimension> -class Connectivity; - -template <typename ConnectivityType> -class Mesh; - -template <size_t Dimension> class [[nodiscard]] MeshNodeBoundary // clazy:exclude=copyable-polymorphic { protected: RefNodeList m_ref_node_list; - std::array<TinyVector<Dimension>, Dimension*(Dimension - 1)> _getBounds(const Mesh<Connectivity<Dimension>>& mesh) - const; - public: - template <size_t MeshDimension> - friend MeshNodeBoundary<MeshDimension> getMeshNodeBoundary(const Mesh<Connectivity<MeshDimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); + template <typename MeshTypeT> + friend MeshNodeBoundary getMeshNodeBoundary(const MeshTypeT& mesh, const IBoundaryDescriptor& boundary_descriptor); MeshNodeBoundary& operator=(const MeshNodeBoundary&) = default; - MeshNodeBoundary& operator=(MeshNodeBoundary&&) = default; + MeshNodeBoundary& operator=(MeshNodeBoundary&&) = default; PUGS_INLINE - const RefNodeList& refNodeList() const + const RefNodeList& + refNodeList() const { return m_ref_node_list; } PUGS_INLINE - const Array<const NodeId>& nodeList() const + const Array<const NodeId>& + nodeList() const { return m_ref_node_list.list(); } protected: - MeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list); - MeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, const RefEdgeList& ref_edge_list); - MeshNodeBoundary(const Mesh<Connectivity<Dimension>>&, const RefNodeList& ref_node_list); + template <typename MeshType> + MeshNodeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list); + template <typename MeshType> + MeshNodeBoundary(const MeshType& mesh, const RefEdgeList& ref_edge_list); + template <typename MeshType> + MeshNodeBoundary(const MeshType&, const RefNodeList& ref_node_list); public: MeshNodeBoundary(const MeshNodeBoundary&) = default; - MeshNodeBoundary(MeshNodeBoundary &&) = default; + MeshNodeBoundary(MeshNodeBoundary&&) = default; MeshNodeBoundary() = default; virtual ~MeshNodeBoundary() = default; }; -template <size_t Dimension> -MeshNodeBoundary<Dimension> getMeshNodeBoundary(const Mesh<Connectivity<Dimension>>& mesh, - const IBoundaryDescriptor& boundary_descriptor); +template <typename MeshType> +MeshNodeBoundary getMeshNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_NODE_BOUNDARY_HPP diff --git a/src/mesh/MeshNodeBoundaryUtils.cpp b/src/mesh/MeshNodeBoundaryUtils.cpp new file mode 100644 index 0000000000000000000000000000000000000000..63df3e36475d2d60029fe5cd27dba9f37eac21cc --- /dev/null +++ b/src/mesh/MeshNodeBoundaryUtils.cpp @@ -0,0 +1,170 @@ +#include <mesh/MeshNodeBoundaryUtils.hpp> + +#include <mesh/Connectivity.hpp> +#include <mesh/Mesh.hpp> +#include <utils/Messenger.hpp> + +template <> +std::array<TinyVector<2>, 2> +getBounds(const Mesh<Connectivity<2>>& mesh, const RefNodeList& ref_node_list) +{ + using R2 = TinyVector<2, double>; + + const NodeValue<const R2>& xr = mesh.xr(); + + std::array<R2, 2> bounds; + R2& xmin = bounds[0]; + R2& xmax = bounds[1]; + + xmin = R2{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; + xmax = R2{-std::numeric_limits<double>::max(), -std::numeric_limits<double>::max()}; + + auto update_xmin = [](const R2& x, R2& x_min) { + if ((x[0] < x_min[0]) or ((x[0] == x_min[0]) and (x[1] < x_min[1]))) { + x_min = x; + } + }; + + auto update_xmax = [](const R2& x, R2& x_max) { + if ((x[0] > x_max[0]) or ((x[0] == x_max[0]) and (x[1] > x_max[1]))) { + x_max = x; + } + }; + + auto node_list = ref_node_list.list(); + for (size_t r = 0; r < node_list.size(); ++r) { + const R2& x = xr[node_list[r]]; + update_xmin(x, xmin); + update_xmax(x, xmax); + } + + if (parallel::size() > 1) { + Array<R2> xmin_array = parallel::allGather(xmin); + Array<R2> xmax_array = parallel::allGather(xmax); + for (size_t i = 0; i < xmin_array.size(); ++i) { + update_xmin(xmin_array[i], xmin); + } + for (size_t i = 0; i < xmax_array.size(); ++i) { + update_xmax(xmax_array[i], xmax); + } + } + + return bounds; +} + +template <> +std::array<TinyVector<3>, 6> +getBounds(const Mesh<Connectivity<3>>& mesh, const RefNodeList& ref_node_list) +{ + using R3 = TinyVector<3, double>; + + auto update_xmin = [](const R3& x, R3& xmin) { + // XMIN: X.xmin X.ymax X.zmax + if ((x[0] < xmin[0]) or ((x[0] == xmin[0]) and (x[1] > xmin[1])) or + ((x[0] == xmin[0]) and (x[1] == xmin[1]) and (x[2] > xmin[2]))) { + xmin = x; + } + }; + + auto update_xmax = [](const R3& x, R3& xmax) { + // XMAX: X.xmax X.ymin X.zmin + if ((x[0] > xmax[0]) or ((x[0] == xmax[0]) and (x[1] < xmax[1])) or + ((x[0] == xmax[0]) and (x[1] == xmax[1]) and (x[2] < xmax[2]))) { + xmax = x; + } + }; + + auto update_ymin = [](const R3& x, R3& ymin) { + // YMIN: X.ymin X.zmax X.xmin + if ((x[1] < ymin[1]) or ((x[1] == ymin[1]) and (x[2] > ymin[2])) or + ((x[1] == ymin[1]) and (x[2] == ymin[2]) and (x[0] < ymin[0]))) { + ymin = x; + } + }; + + auto update_ymax = [](const R3& x, R3& ymax) { + // YMAX: X.ymax X.zmin X.xmax + if ((x[1] > ymax[1]) or ((x[1] == ymax[1]) and (x[2] < ymax[2])) or + ((x[1] == ymax[1]) and (x[2] == ymax[2]) and (x[0] > ymax[0]))) { + ymax = x; + } + }; + + auto update_zmin = [](const R3& x, R3& zmin) { + // ZMIN: X.zmin X.xmin X.ymin + if ((x[2] < zmin[2]) or ((x[2] == zmin[2]) and (x[0] < zmin[0])) or + ((x[2] == zmin[2]) and (x[0] == zmin[0]) and (x[1] < zmin[1]))) { + zmin = x; + } + }; + + auto update_zmax = [](const R3& x, R3& zmax) { + // ZMAX: X.zmax X.xmax X.ymax + if ((x[2] > zmax[2]) or ((x[2] == zmax[2]) and (x[0] > zmax[0])) or + ((x[2] == zmax[2]) and (x[0] == zmax[0]) and (x[1] > zmax[1]))) { + zmax = x; + } + }; + + std::array<R3, 6> bounds; + R3& xmin = bounds[0]; + R3& ymin = bounds[1]; + R3& zmin = bounds[2]; + R3& xmax = bounds[3]; + R3& ymax = bounds[4]; + R3& zmax = bounds[5]; + + xmin = R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; + ymin = R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; + zmin = R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; + + xmax = + -R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; + ymax = + -R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; + zmax = + -R3{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max()}; + + const NodeValue<const R3>& xr = mesh.xr(); + + auto node_list = ref_node_list.list(); + for (size_t r = 0; r < node_list.size(); ++r) { + const R3& x = xr[node_list[r]]; + update_xmin(x, xmin); + update_ymin(x, ymin); + update_zmin(x, zmin); + update_xmax(x, xmax); + update_ymax(x, ymax); + update_zmax(x, zmax); + } + + if (parallel::size() > 1) { + Array<const R3> xmin_array = parallel::allGather(xmin); + Array<const R3> ymin_array = parallel::allGather(ymin); + Array<const R3> zmin_array = parallel::allGather(zmin); + Array<const R3> xmax_array = parallel::allGather(xmax); + Array<const R3> ymax_array = parallel::allGather(ymax); + Array<const R3> zmax_array = parallel::allGather(zmax); + + for (size_t i = 0; i < xmin_array.size(); ++i) { + update_xmin(xmin_array[i], xmin); + } + for (size_t i = 0; i < ymin_array.size(); ++i) { + update_ymin(ymin_array[i], ymin); + } + for (size_t i = 0; i < zmin_array.size(); ++i) { + update_zmin(zmin_array[i], zmin); + } + for (size_t i = 0; i < xmax_array.size(); ++i) { + update_xmax(xmax_array[i], xmax); + } + for (size_t i = 0; i < ymax_array.size(); ++i) { + update_ymax(ymax_array[i], ymax); + } + for (size_t i = 0; i < zmax_array.size(); ++i) { + update_zmax(zmax_array[i], zmax); + } + } + + return bounds; +} diff --git a/src/mesh/MeshNodeBoundaryUtils.hpp b/src/mesh/MeshNodeBoundaryUtils.hpp new file mode 100644 index 0000000000000000000000000000000000000000..a62f9d8f3affa0cf2a840e69776b91c88fa8ec0e --- /dev/null +++ b/src/mesh/MeshNodeBoundaryUtils.hpp @@ -0,0 +1,14 @@ +#ifndef MESH_NODE_BOUNDARY_UTILS_HPP +#define MESH_NODE_BOUNDARY_UTILS_HPP + +#include <algebra/TinyVector.hpp> +#include <mesh/RefItemList.hpp> + +#include <array> + +template <typename MeshType> +std::array<TinyVector<MeshType::Dimension>, MeshType::Dimension*(MeshType::Dimension - 1)> getBounds( + const MeshType& mesh, + const RefNodeList& ref_node_list); + +#endif // MESH_NODE_BOUNDARY_UTILS_HPP diff --git a/src/mesh/MeshRandomizer.cpp b/src/mesh/MeshRandomizer.cpp index 57b826dff5ba409e69816b352c572b67547217e1..9a2a56d5a754d96a195cb88a6e70ac5f0d5c6dab 100644 --- a/src/mesh/MeshRandomizer.cpp +++ b/src/mesh/MeshRandomizer.cpp @@ -16,14 +16,15 @@ #include <scheme/SymmetryBoundaryConditionDescriptor.hpp> #include <utils/RandomEngine.hpp> -template <size_t Dimension> +template <typename MeshType> class MeshRandomizerHandler::MeshRandomizer { private: + static constexpr size_t Dimension = MeshType::Dimension; + using Rd = TinyVector<Dimension>; using Rdxd = TinyMatrix<Dimension>; - using ConnectivityType = Connectivity<Dimension>; - using MeshType = Mesh<ConnectivityType>; + using ConnectivityType = typename MeshType::Connectivity; const MeshType& m_given_mesh; @@ -273,14 +274,14 @@ class MeshRandomizerHandler::MeshRandomizer ~MeshRandomizer() = default; }; -template <size_t Dimension> -class MeshRandomizerHandler::MeshRandomizer<Dimension>::AxisBoundaryCondition +template <typename MeshType> +class MeshRandomizerHandler::MeshRandomizer<MeshType>::AxisBoundaryCondition { public: using Rd = TinyVector<Dimension, double>; private: - const MeshLineNodeBoundary<Dimension> m_mesh_line_node_boundary; + const MeshLineNodeBoundary<const MeshType> m_mesh_line_node_boundary; public: const Rd& @@ -295,7 +296,7 @@ class MeshRandomizerHandler::MeshRandomizer<Dimension>::AxisBoundaryCondition return m_mesh_line_node_boundary.nodeList(); } - AxisBoundaryCondition(MeshLineNodeBoundary<Dimension>&& mesh_line_node_boundary) + AxisBoundaryCondition(MeshLineNodeBoundary<const MeshType>&& mesh_line_node_boundary) : m_mesh_line_node_boundary(mesh_line_node_boundary) { ; @@ -305,18 +306,18 @@ class MeshRandomizerHandler::MeshRandomizer<Dimension>::AxisBoundaryCondition }; template <> -class MeshRandomizerHandler::MeshRandomizer<1>::AxisBoundaryCondition +class MeshRandomizerHandler::MeshRandomizer<Mesh<Connectivity<1>>>::AxisBoundaryCondition { public: AxisBoundaryCondition() = default; ~AxisBoundaryCondition() = default; }; -template <size_t Dimension> -class MeshRandomizerHandler::MeshRandomizer<Dimension>::FixedBoundaryCondition +template <typename MeshType> +class MeshRandomizerHandler::MeshRandomizer<MeshType>::FixedBoundaryCondition { private: - const MeshNodeBoundary<Dimension> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; public: const Array<const NodeId>& @@ -325,19 +326,19 @@ class MeshRandomizerHandler::MeshRandomizer<Dimension>::FixedBoundaryCondition return m_mesh_node_boundary.nodeList(); } - FixedBoundaryCondition(MeshNodeBoundary<Dimension>&& mesh_node_boundary) : m_mesh_node_boundary{mesh_node_boundary} {} + FixedBoundaryCondition(MeshNodeBoundary&& mesh_node_boundary) : m_mesh_node_boundary{mesh_node_boundary} {} ~FixedBoundaryCondition() = default; }; -template <size_t Dimension> -class MeshRandomizerHandler::MeshRandomizer<Dimension>::SymmetryBoundaryCondition +template <typename MeshType> +class MeshRandomizerHandler::MeshRandomizer<MeshType>::SymmetryBoundaryCondition { public: - using Rd = TinyVector<Dimension, double>; + using Rd = TinyVector<MeshType::Dimension, double>; private: - const MeshFlatNodeBoundary<Dimension> m_mesh_flat_node_boundary; + const MeshFlatNodeBoundary<const MeshType> m_mesh_flat_node_boundary; public: const Rd& @@ -352,7 +353,7 @@ class MeshRandomizerHandler::MeshRandomizer<Dimension>::SymmetryBoundaryConditio return m_mesh_flat_node_boundary.nodeList(); } - SymmetryBoundaryCondition(MeshFlatNodeBoundary<Dimension>&& mesh_flat_node_boundary) + SymmetryBoundaryCondition(MeshFlatNodeBoundary<const MeshType>&& mesh_flat_node_boundary) : m_mesh_flat_node_boundary(mesh_flat_node_boundary) { ; diff --git a/src/mesh/MeshRandomizer.hpp b/src/mesh/MeshRandomizer.hpp index b71d99a676c8c18201871efa11902eeaab63f742..048e04bfdad1780fc41362595ca0378400a6266e 100644 --- a/src/mesh/MeshRandomizer.hpp +++ b/src/mesh/MeshRandomizer.hpp @@ -11,7 +11,7 @@ class FunctionSymbolId; class MeshRandomizerHandler { private: - template <size_t Dimension> + template <typename MeshType> class MeshRandomizer; public: diff --git a/src/mesh/MeshSmoother.cpp b/src/mesh/MeshSmoother.cpp index 281548bf1401c3c33f209a582d2d8d33a9b99bb2..d90b95a4d9356e441155b844bc33eeb754aaee62 100644 --- a/src/mesh/MeshSmoother.cpp +++ b/src/mesh/MeshSmoother.cpp @@ -20,14 +20,15 @@ #include <variant> -template <size_t Dimension> +template <typename MeshType> class MeshSmootherHandler::MeshSmoother { private: + static constexpr size_t Dimension = MeshType::Dimension; + using Rd = TinyVector<Dimension>; using Rdxd = TinyMatrix<Dimension>; - using ConnectivityType = Connectivity<Dimension>; - using MeshType = Mesh<ConnectivityType>; + using ConnectivityType = typename MeshType::Connectivity; const MeshType& m_given_mesh; @@ -320,14 +321,14 @@ class MeshSmootherHandler::MeshSmoother ~MeshSmoother() = default; }; -template <size_t Dimension> -class MeshSmootherHandler::MeshSmoother<Dimension>::AxisBoundaryCondition +template <typename MeshType> +class MeshSmootherHandler::MeshSmoother<MeshType>::AxisBoundaryCondition { public: using Rd = TinyVector<Dimension, double>; private: - const MeshLineNodeBoundary<Dimension> m_mesh_line_node_boundary; + const MeshLineNodeBoundary<const MeshType> m_mesh_line_node_boundary; public: const Rd& @@ -342,7 +343,7 @@ class MeshSmootherHandler::MeshSmoother<Dimension>::AxisBoundaryCondition return m_mesh_line_node_boundary.nodeList(); } - AxisBoundaryCondition(MeshLineNodeBoundary<Dimension>&& mesh_line_node_boundary) + AxisBoundaryCondition(MeshLineNodeBoundary<const MeshType>&& mesh_line_node_boundary) : m_mesh_line_node_boundary(mesh_line_node_boundary) { ; @@ -352,18 +353,18 @@ class MeshSmootherHandler::MeshSmoother<Dimension>::AxisBoundaryCondition }; template <> -class MeshSmootherHandler::MeshSmoother<1>::AxisBoundaryCondition +class MeshSmootherHandler::MeshSmoother<Mesh<Connectivity<1>>>::AxisBoundaryCondition { public: AxisBoundaryCondition() = default; ~AxisBoundaryCondition() = default; }; -template <size_t Dimension> -class MeshSmootherHandler::MeshSmoother<Dimension>::FixedBoundaryCondition +template <typename MeshType> +class MeshSmootherHandler::MeshSmoother<MeshType>::FixedBoundaryCondition { private: - const MeshNodeBoundary<Dimension> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; public: const Array<const NodeId>& @@ -372,19 +373,19 @@ class MeshSmootherHandler::MeshSmoother<Dimension>::FixedBoundaryCondition return m_mesh_node_boundary.nodeList(); } - FixedBoundaryCondition(MeshNodeBoundary<Dimension>&& mesh_node_boundary) : m_mesh_node_boundary{mesh_node_boundary} {} + FixedBoundaryCondition(MeshNodeBoundary&& mesh_node_boundary) : m_mesh_node_boundary{mesh_node_boundary} {} ~FixedBoundaryCondition() = default; }; -template <size_t Dimension> -class MeshSmootherHandler::MeshSmoother<Dimension>::SymmetryBoundaryCondition +template <typename MeshType> +class MeshSmootherHandler::MeshSmoother<MeshType>::SymmetryBoundaryCondition { public: - using Rd = TinyVector<Dimension, double>; + using Rd = TinyVector<MeshType::Dimension, double>; private: - const MeshFlatNodeBoundary<Dimension> m_mesh_flat_node_boundary; + const MeshFlatNodeBoundary<const MeshType> m_mesh_flat_node_boundary; public: const Rd& @@ -399,7 +400,7 @@ class MeshSmootherHandler::MeshSmoother<Dimension>::SymmetryBoundaryCondition return m_mesh_flat_node_boundary.nodeList(); } - SymmetryBoundaryCondition(MeshFlatNodeBoundary<Dimension>&& mesh_flat_node_boundary) + SymmetryBoundaryCondition(MeshFlatNodeBoundary<const MeshType>&& mesh_flat_node_boundary) : m_mesh_flat_node_boundary(mesh_flat_node_boundary) { ; diff --git a/src/mesh/MeshSmoother.hpp b/src/mesh/MeshSmoother.hpp index 209be6c1339495203df264b967e7995d9485bdb3..c5875561a5bce80257dbf6a118517c2b8443c021 100644 --- a/src/mesh/MeshSmoother.hpp +++ b/src/mesh/MeshSmoother.hpp @@ -13,7 +13,7 @@ class DiscreteFunctionVariant; class MeshSmootherHandler { private: - template <size_t Dimension> + template <typename MeshType> class MeshSmoother; public: diff --git a/src/scheme/AcousticSolver.cpp b/src/scheme/AcousticSolver.cpp index 575a281c19fddd3a74448c725080ca2025c0c4b5..e60372f0c46b1d3eed0852c5fc60486b6f1c611d 100644 --- a/src/scheme/AcousticSolver.cpp +++ b/src/scheme/AcousticSolver.cpp @@ -61,14 +61,15 @@ acoustic_dt(const std::shared_ptr<const DiscreteFunctionVariant>& c) } } -template <size_t Dimension> +template <typename MeshType> class AcousticSolverHandler::AcousticSolver final : public AcousticSolverHandler::IAcousticSolver { private: + static constexpr size_t Dimension = MeshType::Dimension; + using Rdxd = TinyMatrix<Dimension>; using Rd = TinyVector<Dimension>; - using MeshType = Mesh<Connectivity<Dimension>>; using MeshDataType = MeshData<Dimension>; using DiscreteScalarFunction = DiscreteFunctionP0<Dimension, const double>; @@ -271,8 +272,7 @@ class AcousticSolverHandler::AcousticSolver final : public AcousticSolverHandler const DirichletBoundaryConditionDescriptor& dirichlet_bc_descriptor = dynamic_cast<const DirichletBoundaryConditionDescriptor&>(*bc_descriptor); if (dirichlet_bc_descriptor.name() == "velocity") { - MeshNodeBoundary<Dimension> mesh_node_boundary = - getMeshNodeBoundary(mesh, dirichlet_bc_descriptor.boundaryDescriptor()); + MeshNodeBoundary mesh_node_boundary = getMeshNodeBoundary(mesh, dirichlet_bc_descriptor.boundaryDescriptor()); Array<const Rd> value_list = InterpolateItemValue<Rd(Rd)>::template interpolate<ItemType::node>(dirichlet_bc_descriptor.rhsSymbolId(), @@ -284,17 +284,15 @@ class AcousticSolverHandler::AcousticSolver final : public AcousticSolverHandler const FunctionSymbolId pressure_id = dirichlet_bc_descriptor.rhsSymbolId(); if constexpr (Dimension == 1) { - MeshNodeBoundary<Dimension> mesh_node_boundary = - getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()); + MeshNodeBoundary mesh_node_boundary = getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()); Array<const double> node_values = InterpolateItemValue<double(Rd)>::template interpolate<ItemType::node>(pressure_id, mesh.xr(), mesh_node_boundary.nodeList()); - - bc_list.emplace_back(PressureBoundaryCondition{mesh_node_boundary, node_values}); + PressureBoundaryCondition p(mesh_node_boundary, node_values); + bc_list.emplace_back(p); } else { - MeshFaceBoundary<Dimension> mesh_face_boundary = - getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor()); + MeshFaceBoundary mesh_face_boundary = getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor()); MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(mesh); Array<const double> face_values = @@ -529,11 +527,11 @@ class AcousticSolverHandler::AcousticSolver final : public AcousticSolverHandler ~AcousticSolver() = default; }; -template <size_t Dimension> +template <typename MeshType> void -AcousticSolverHandler::AcousticSolver<Dimension>::_applyPressureBC(const BoundaryConditionList& bc_list, - const MeshType& mesh, - NodeValue<Rd>& br) const +AcousticSolverHandler::AcousticSolver<MeshType>::_applyPressureBC(const BoundaryConditionList& bc_list, + const MeshType& mesh, + NodeValue<Rd>& br) const { for (const auto& boundary_condition : bc_list) { std::visit( @@ -594,11 +592,11 @@ AcousticSolverHandler::AcousticSolver<Dimension>::_applyPressureBC(const Boundar } } -template <size_t Dimension> +template <typename MeshType> void -AcousticSolverHandler::AcousticSolver<Dimension>::_applySymmetryBC(const BoundaryConditionList& bc_list, - NodeValue<Rdxd>& Ar, - NodeValue<Rd>& br) const +AcousticSolverHandler::AcousticSolver<MeshType>::_applySymmetryBC(const BoundaryConditionList& bc_list, + NodeValue<Rdxd>& Ar, + NodeValue<Rd>& br) const { for (const auto& boundary_condition : bc_list) { std::visit( @@ -625,11 +623,11 @@ AcousticSolverHandler::AcousticSolver<Dimension>::_applySymmetryBC(const Boundar } } -template <size_t Dimension> +template <typename MeshType> void -AcousticSolverHandler::AcousticSolver<Dimension>::_applyVelocityBC(const BoundaryConditionList& bc_list, - NodeValue<Rdxd>& Ar, - NodeValue<Rd>& br) const +AcousticSolverHandler::AcousticSolver<MeshType>::_applyVelocityBC(const BoundaryConditionList& bc_list, + NodeValue<Rdxd>& Ar, + NodeValue<Rd>& br) const { for (const auto& boundary_condition : bc_list) { std::visit( @@ -662,12 +660,12 @@ AcousticSolverHandler::AcousticSolver<Dimension>::_applyVelocityBC(const Boundar } } -template <size_t Dimension> +template <typename MeshType> void -AcousticSolverHandler::AcousticSolver<Dimension>::_applyExternalVelocityBC(const BoundaryConditionList& bc_list, - const DiscreteScalarFunction& p, - NodeValue<Rdxd>& Ar, - NodeValue<Rd>& br) const +AcousticSolverHandler::AcousticSolver<MeshType>::_applyExternalVelocityBC(const BoundaryConditionList& bc_list, + const DiscreteScalarFunction& p, + NodeValue<Rdxd>& Ar, + NodeValue<Rd>& br) const { for (const auto& boundary_condition : bc_list) { std::visit( @@ -691,11 +689,11 @@ AcousticSolverHandler::AcousticSolver<Dimension>::_applyExternalVelocityBC(const } } -template <size_t Dimension> -class AcousticSolverHandler::AcousticSolver<Dimension>::FixedBoundaryCondition +template <typename MeshType> +class AcousticSolverHandler::AcousticSolver<MeshType>::FixedBoundaryCondition { private: - const MeshNodeBoundary<Dimension> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; public: const Array<const NodeId>& @@ -704,18 +702,16 @@ class AcousticSolverHandler::AcousticSolver<Dimension>::FixedBoundaryCondition return m_mesh_node_boundary.nodeList(); } - FixedBoundaryCondition(const MeshNodeBoundary<Dimension> mesh_node_boundary) - : m_mesh_node_boundary{mesh_node_boundary} - {} + FixedBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary) : m_mesh_node_boundary{mesh_node_boundary} {} ~FixedBoundaryCondition() = default; }; -template <size_t Dimension> -class AcousticSolverHandler::AcousticSolver<Dimension>::PressureBoundaryCondition +template <typename MeshType> +class AcousticSolverHandler::AcousticSolver<MeshType>::PressureBoundaryCondition { private: - const MeshFaceBoundary<Dimension> m_mesh_face_boundary; + const MeshFaceBoundary m_mesh_face_boundary; const Array<const double> m_value_list; public: @@ -731,8 +727,7 @@ class AcousticSolverHandler::AcousticSolver<Dimension>::PressureBoundaryConditio return m_value_list; } - PressureBoundaryCondition(const MeshFaceBoundary<Dimension>& mesh_face_boundary, - const Array<const double>& value_list) + PressureBoundaryCondition(const MeshFaceBoundary& mesh_face_boundary, const Array<const double>& value_list) : m_mesh_face_boundary{mesh_face_boundary}, m_value_list{value_list} {} @@ -740,10 +735,10 @@ class AcousticSolverHandler::AcousticSolver<Dimension>::PressureBoundaryConditio }; template <> -class AcousticSolverHandler::AcousticSolver<1>::PressureBoundaryCondition +class AcousticSolverHandler::AcousticSolver<const Mesh<Connectivity<1>>>::PressureBoundaryCondition { private: - const MeshNodeBoundary<1> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; const Array<const double> m_value_list; public: @@ -759,19 +754,19 @@ class AcousticSolverHandler::AcousticSolver<1>::PressureBoundaryCondition return m_value_list; } - PressureBoundaryCondition(const MeshNodeBoundary<1>& mesh_node_boundary, const Array<const double>& value_list) + PressureBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary, const Array<const double>& value_list) : m_mesh_node_boundary{mesh_node_boundary}, m_value_list{value_list} {} ~PressureBoundaryCondition() = default; }; -template <size_t Dimension> -class AcousticSolverHandler::AcousticSolver<Dimension>::ExternalFSIVelocityBoundaryCondition +template <typename MeshType> +class AcousticSolverHandler::AcousticSolver<MeshType>::ExternalFSIVelocityBoundaryCondition { private: const ItemToItemMatrix<ItemType::node, ItemType::cell> m_node_to_cell_matrix; - const MeshNodeBoundary<Dimension> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; const Array<TinyVector<Dimension>> m_value_list; const std::shared_ptr<const Socket> m_socket; @@ -800,7 +795,7 @@ class AcousticSolverHandler::AcousticSolver<Dimension>::ExternalFSIVelocityBound } ExternalFSIVelocityBoundaryCondition(const Mesh<Connectivity<Dimension>>& mesh, - const MeshNodeBoundary<Dimension>& mesh_node_boundary, + const MeshNodeBoundary& mesh_node_boundary, const std::shared_ptr<const Socket>& socket) : m_node_to_cell_matrix{mesh.connectivity().nodeToCellMatrix()}, m_mesh_node_boundary{mesh_node_boundary}, @@ -815,11 +810,11 @@ class AcousticSolverHandler::AcousticSolver<Dimension>::ExternalFSIVelocityBound ~ExternalFSIVelocityBoundaryCondition() = default; }; -template <size_t Dimension> -class AcousticSolverHandler::AcousticSolver<Dimension>::VelocityBoundaryCondition +template <typename MeshType> +class AcousticSolverHandler::AcousticSolver<MeshType>::VelocityBoundaryCondition { private: - const MeshNodeBoundary<Dimension> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; const Array<const TinyVector<Dimension>> m_value_list; @@ -836,7 +831,7 @@ class AcousticSolverHandler::AcousticSolver<Dimension>::VelocityBoundaryConditio return m_value_list; } - VelocityBoundaryCondition(const MeshNodeBoundary<Dimension>& mesh_node_boundary, + VelocityBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary, const Array<const TinyVector<Dimension>>& value_list) : m_mesh_node_boundary{mesh_node_boundary}, m_value_list{value_list} {} @@ -844,14 +839,14 @@ class AcousticSolverHandler::AcousticSolver<Dimension>::VelocityBoundaryConditio ~VelocityBoundaryCondition() = default; }; -template <size_t Dimension> -class AcousticSolverHandler::AcousticSolver<Dimension>::SymmetryBoundaryCondition +template <typename MeshType> +class AcousticSolverHandler::AcousticSolver<MeshType>::SymmetryBoundaryCondition { public: using Rd = TinyVector<Dimension, double>; private: - const MeshFlatNodeBoundary<Dimension> m_mesh_flat_node_boundary; + const MeshFlatNodeBoundary<MeshType> m_mesh_flat_node_boundary; public: const Rd& @@ -872,7 +867,7 @@ class AcousticSolverHandler::AcousticSolver<Dimension>::SymmetryBoundaryConditio return m_mesh_flat_node_boundary.nodeList(); } - SymmetryBoundaryCondition(const MeshFlatNodeBoundary<Dimension>& mesh_flat_node_boundary) + SymmetryBoundaryCondition(const MeshFlatNodeBoundary<MeshType>& mesh_flat_node_boundary) : m_mesh_flat_node_boundary(mesh_flat_node_boundary) { ; @@ -891,7 +886,7 @@ AcousticSolverHandler::AcousticSolverHandler(const std::shared_ptr<const MeshVar [&](auto&& mesh) { using MeshType = typename std::decay_t<decltype(mesh)>::element_type; if constexpr (is_polygonal_mesh<MeshType>) { - m_acoustic_solver = std::make_unique<AcousticSolver<MeshType::Dimension>>(); + m_acoustic_solver = std::make_unique<AcousticSolver<MeshType>>(); } else { throw NormalError("unexpected mesh type"); } diff --git a/src/scheme/AcousticSolver.hpp b/src/scheme/AcousticSolver.hpp index 85d829c1b126cf4ae1aebdc7db598de82fade217..75e08981dfb50993233eb80ddfdf67266a24cf06 100644 --- a/src/scheme/AcousticSolver.hpp +++ b/src/scheme/AcousticSolver.hpp @@ -59,14 +59,14 @@ class AcousticSolverHandler const std::shared_ptr<const DiscreteFunctionVariant>& p, const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list) const = 0; - IAcousticSolver() = default; - IAcousticSolver(IAcousticSolver&&) = default; + IAcousticSolver() = default; + IAcousticSolver(IAcousticSolver&&) = default; IAcousticSolver& operator=(IAcousticSolver&&) = default; virtual ~IAcousticSolver() = default; }; - template <size_t Dimension> + template <typename MeshType> class AcousticSolver; std::unique_ptr<IAcousticSolver> m_acoustic_solver; diff --git a/src/scheme/FluxingAdvectionSolver.cpp b/src/scheme/FluxingAdvectionSolver.cpp index 01ff407bd35a597a4285ce62ffec530bc77e81fe..25d9cf3de756c2b21f6a85447b4a69359cea4767 100644 --- a/src/scheme/FluxingAdvectionSolver.cpp +++ b/src/scheme/FluxingAdvectionSolver.cpp @@ -26,13 +26,13 @@ #include <variant> #include <vector> -template <size_t Dimension> +template <typename MeshType> class FluxingAdvectionSolver { private: - using Rd = TinyVector<Dimension>; + static constexpr size_t Dimension = MeshType::Dimension; - using MeshType = Mesh<Connectivity<Dimension>>; + using Rd = TinyVector<Dimension>; using MeshDataType = MeshData<Dimension>; const std::shared_ptr<const MeshType> m_old_mesh; @@ -114,8 +114,7 @@ class FluxingAdvectionSolver const InflowBoundaryConditionDescriptor& inflow_bc_descriptor = dynamic_cast<const InflowBoundaryConditionDescriptor&>(*i_bc); - MeshFaceBoundary<Dimension> mesh_face_boundary = - getMeshFaceBoundary(mesh, inflow_bc_descriptor.boundaryDescriptor()); + MeshFaceBoundary mesh_face_boundary = getMeshFaceBoundary(mesh, inflow_bc_descriptor.boundaryDescriptor()); FaceValue<const Rd> xl = MeshDataManager::instance().getMeshData(*m_old_mesh).xl(); Array<const DataType> value_list = @@ -158,8 +157,7 @@ class FluxingAdvectionSolver const InflowBoundaryConditionDescriptor& inflow_bc_descriptor = dynamic_cast<const InflowBoundaryConditionDescriptor&>(*i_bc); - MeshFaceBoundary<Dimension> mesh_face_boundary = - getMeshFaceBoundary(mesh, inflow_bc_descriptor.boundaryDescriptor()); + MeshFaceBoundary mesh_face_boundary = getMeshFaceBoundary(mesh, inflow_bc_descriptor.boundaryDescriptor()); FaceValue<const Rd> xl = MeshDataManager::instance().getMeshData(*m_old_mesh).xl(); Table<const double> array_list = @@ -209,9 +207,9 @@ class FluxingAdvectionSolver ~FluxingAdvectionSolver() = default; }; -template <size_t Dimension> +template <typename MeshType> void -FluxingAdvectionSolver<Dimension>::_computeDonorCells(FaceValue<const double> algebraic_fluxing_volumes) +FluxingAdvectionSolver<MeshType>::_computeDonorCells(FaceValue<const double> algebraic_fluxing_volumes) { m_donnor_cell = [&] { const FaceValuePerCell<const bool> cell_face_is_reversed = m_new_mesh->connectivity().cellFaceIsReversed(); @@ -242,7 +240,8 @@ FluxingAdvectionSolver<Dimension>::_computeDonorCells(FaceValue<const double> al template <> void -FluxingAdvectionSolver<1>::_computeDonorCells(FaceValue<const double> algebraic_fluxing_volumes) +FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeDonorCells( + FaceValue<const double> algebraic_fluxing_volumes) { m_donnor_cell = [&] { const auto face_to_cell_matrix = m_new_mesh->connectivity().faceToCellMatrix(); @@ -276,7 +275,7 @@ FluxingAdvectionSolver<1>::_computeDonorCells(FaceValue<const double> algebraic_ template <> FaceValue<double> -FluxingAdvectionSolver<1>::_computeAlgebraicFluxingVolume() +FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeAlgebraicFluxingVolume() { Array<double> fluxing_volumes{m_new_mesh->numberOfNodes()}; NodeValue<double> nodal_fluxing_volume(m_new_mesh->connectivity(), fluxing_volumes); @@ -295,7 +294,7 @@ FluxingAdvectionSolver<1>::_computeAlgebraicFluxingVolume() template <> FaceValue<double> -FluxingAdvectionSolver<2>::_computeAlgebraicFluxingVolume() +FluxingAdvectionSolver<const Mesh<Connectivity<2>>>::_computeAlgebraicFluxingVolume() { const auto face_to_node_matrix = m_old_mesh->connectivity().faceToNodeMatrix(); FaceValue<double> algebraic_fluxing_volume(m_new_mesh->connectivity()); @@ -322,7 +321,7 @@ FluxingAdvectionSolver<2>::_computeAlgebraicFluxingVolume() template <> FaceValue<double> -FluxingAdvectionSolver<3>::_computeAlgebraicFluxingVolume() +FluxingAdvectionSolver<const Mesh<Connectivity<3>>>::_computeAlgebraicFluxingVolume() { // due to the z component of the jacobian determinant, degree 3 // polynomials must be exactly integrated @@ -387,9 +386,9 @@ FluxingAdvectionSolver<3>::_computeAlgebraicFluxingVolume() return algebraic_fluxing_volume; } -template <size_t Dimension> +template <typename MeshType> FaceValue<double> -FluxingAdvectionSolver<Dimension>::_computeFluxingVolume(FaceValue<double> algebraic_fluxing_volumes) +FluxingAdvectionSolver<MeshType>::_computeFluxingVolume(FaceValue<double> algebraic_fluxing_volumes) { Assert(m_donnor_cell.isBuilt()); // Now that donnor cells are clearly defined, we consider the @@ -402,9 +401,9 @@ FluxingAdvectionSolver<Dimension>::_computeFluxingVolume(FaceValue<double> algeb return algebraic_fluxing_volumes; } -template <size_t Dimension> +template <typename MeshType> void -FluxingAdvectionSolver<Dimension>::_computeCycleNumber(FaceValue<double> fluxing_volumes) +FluxingAdvectionSolver<MeshType>::_computeCycleNumber(FaceValue<double> fluxing_volumes) { const auto cell_to_face_matrix = m_old_mesh->connectivity().cellToFaceMatrix(); @@ -445,9 +444,9 @@ FluxingAdvectionSolver<Dimension>::_computeCycleNumber(FaceValue<double> fluxing m_cycle_fluxing_volume = fluxing_volumes; } -template <size_t Dimension> +template <typename MeshType> void -FluxingAdvectionSolver<Dimension>::_computeGeometricalData() +FluxingAdvectionSolver<MeshType>::_computeGeometricalData() { auto fluxing_volumes = this->_computeAlgebraicFluxingVolume(); this->_computeDonorCells(fluxing_volumes); @@ -455,12 +454,12 @@ FluxingAdvectionSolver<Dimension>::_computeGeometricalData() this->_computeCycleNumber(fluxing_volumes); } -template <size_t Dimension> +template <typename MeshType> template <typename CellDataType> void -FluxingAdvectionSolver<Dimension>::_remapOne(const CellValue<const double>& step_Vj, - const std::vector<BoundaryConditionVariant>& q_bc_list, - CellDataType& old_q) +FluxingAdvectionSolver<MeshType>::_remapOne(const CellValue<const double>& step_Vj, + const std::vector<BoundaryConditionVariant>& q_bc_list, + CellDataType& old_q) { using DataType = std::decay_t<typename CellDataType::data_type>; @@ -635,9 +634,9 @@ FluxingAdvectionSolver<Dimension>::_remapOne(const CellValue<const double>& step old_q = new_q; } -template <size_t Dimension> +template <typename MeshType> void -FluxingAdvectionSolver<Dimension>::_remapAllQuantities() +FluxingAdvectionSolver<MeshType>::_remapAllQuantities() { const auto cell_to_face_matrix = m_new_mesh->connectivity().cellToFaceMatrix(); const auto face_local_number_in_their_cells = m_new_mesh->connectivity().faceLocalNumbersInTheirCells(); @@ -698,9 +697,9 @@ FluxingAdvectionSolver<Dimension>::_remapAllQuantities() } } -template <size_t Dimension> +template <typename MeshType> std::vector<std::shared_ptr<const DiscreteFunctionVariant>> -FluxingAdvectionSolver<Dimension>::remap( +FluxingAdvectionSolver<MeshType>::remap( const std::vector<std::shared_ptr<const VariableBCDescriptor>>& quantity_list_with_bc) { m_boundary_condition_list.resize(quantity_list_with_bc.size()); @@ -758,12 +757,12 @@ FluxingAdvectionSolver<Dimension>::remap( return new_variables; } -template <size_t Dimension> +template <typename MeshType> template <typename DataType> -class FluxingAdvectionSolver<Dimension>::InflowValueBoundaryCondition +class FluxingAdvectionSolver<MeshType>::InflowValueBoundaryCondition { private: - const MeshFaceBoundary<Dimension> m_mesh_face_boundary; + const MeshFaceBoundary m_mesh_face_boundary; Array<const DataType> m_value_list; @@ -780,7 +779,7 @@ class FluxingAdvectionSolver<Dimension>::InflowValueBoundaryCondition return m_value_list; } - InflowValueBoundaryCondition(const MeshFaceBoundary<Dimension>& mesh_face_boundary, Array<const DataType> value_list) + InflowValueBoundaryCondition(const MeshFaceBoundary& mesh_face_boundary, Array<const DataType> value_list) : m_mesh_face_boundary(mesh_face_boundary), m_value_list(value_list) { ; @@ -789,11 +788,11 @@ class FluxingAdvectionSolver<Dimension>::InflowValueBoundaryCondition ~InflowValueBoundaryCondition() = default; }; -template <size_t Dimension> -class FluxingAdvectionSolver<Dimension>::InflowArrayBoundaryCondition +template <typename MeshType> +class FluxingAdvectionSolver<MeshType>::InflowArrayBoundaryCondition { private: - const MeshFaceBoundary<Dimension> m_mesh_face_boundary; + const MeshFaceBoundary m_mesh_face_boundary; Table<const double> m_array_list; @@ -810,7 +809,7 @@ class FluxingAdvectionSolver<Dimension>::InflowArrayBoundaryCondition return m_array_list; } - InflowArrayBoundaryCondition(const MeshFaceBoundary<Dimension>& mesh_face_boundary, Table<const double> array_list) + InflowArrayBoundaryCondition(const MeshFaceBoundary& mesh_face_boundary, Table<const double> array_list) : m_mesh_face_boundary(mesh_face_boundary), m_array_list(array_list) { ; @@ -819,11 +818,11 @@ class FluxingAdvectionSolver<Dimension>::InflowArrayBoundaryCondition ~InflowArrayBoundaryCondition() = default; }; -template <size_t Dimension> -class FluxingAdvectionSolver<Dimension>::OutflowBoundaryCondition +template <typename MeshType> +class FluxingAdvectionSolver<MeshType>::OutflowBoundaryCondition { private: - const MeshFaceBoundary<Dimension> m_mesh_face_boundary; + const MeshFaceBoundary m_mesh_face_boundary; public: const Array<const FaceId>& @@ -832,8 +831,7 @@ class FluxingAdvectionSolver<Dimension>::OutflowBoundaryCondition return m_mesh_face_boundary.faceList(); } - OutflowBoundaryCondition(const MeshFaceBoundary<Dimension>& mesh_face_boundary) - : m_mesh_face_boundary(mesh_face_boundary) + OutflowBoundaryCondition(const MeshFaceBoundary& mesh_face_boundary) : m_mesh_face_boundary(mesh_face_boundary) { ; } @@ -841,11 +839,11 @@ class FluxingAdvectionSolver<Dimension>::OutflowBoundaryCondition ~OutflowBoundaryCondition() = default; }; -template <size_t Dimension> -class FluxingAdvectionSolver<Dimension>::SymmetryBoundaryCondition +template <typename MeshType> +class FluxingAdvectionSolver<MeshType>::SymmetryBoundaryCondition { private: - const MeshFlatFaceBoundary<Dimension> m_mesh_flat_face_boundary; + const MeshFlatFaceBoundary<MeshType> m_mesh_flat_face_boundary; public: const Array<const FaceId>& @@ -854,7 +852,7 @@ class FluxingAdvectionSolver<Dimension>::SymmetryBoundaryCondition return m_mesh_flat_face_boundary.faceList(); } - SymmetryBoundaryCondition(const MeshFlatFaceBoundary<Dimension>& mesh_flat_face_boundary) + SymmetryBoundaryCondition(const MeshFlatFaceBoundary<MeshType>& mesh_flat_face_boundary) : m_mesh_flat_face_boundary(mesh_flat_face_boundary) { ; @@ -884,8 +882,7 @@ advectByFluxing(const std::shared_ptr<const MeshVariant> new_mesh_v, using NewMeshType = typename std::decay_t<decltype(new_mesh)>::element_type; if constexpr (std::is_same_v<OldMeshType, NewMeshType>) { - constexpr size_t Dimension = OldMeshType::Dimension; - return FluxingAdvectionSolver<Dimension>{old_mesh, new_mesh}.remap(remapped_variables_with_bc); + return FluxingAdvectionSolver<OldMeshType>{old_mesh, new_mesh}.remap(remapped_variables_with_bc); } else { throw NormalError("incompatible mesh types"); } diff --git a/src/scheme/HyperelasticSolver.cpp b/src/scheme/HyperelasticSolver.cpp index a85ae5b2bebd4cece7f81d8e486d0f360863f73b..1e0654aebedcdc00108963f7ca05416752422008 100644 --- a/src/scheme/HyperelasticSolver.cpp +++ b/src/scheme/HyperelasticSolver.cpp @@ -55,14 +55,15 @@ hyperelastic_dt(const std::shared_ptr<const DiscreteFunctionVariant>& c) mesh_v->meshPointer()); } -template <size_t Dimension> +template <typename MeshType> class HyperelasticSolverHandler::HyperelasticSolver final : public HyperelasticSolverHandler::IHyperelasticSolver { private: + static constexpr size_t Dimension = MeshType::Dimension; + using Rdxd = TinyMatrix<Dimension>; using Rd = TinyVector<Dimension>; - using MeshType = Mesh<Connectivity<Dimension>>; using MeshDataType = MeshData<Dimension>; using DiscreteScalarFunction = DiscreteFunctionP0<Dimension, const double>; @@ -263,8 +264,7 @@ class HyperelasticSolverHandler::HyperelasticSolver final : public HyperelasticS const DirichletBoundaryConditionDescriptor& dirichlet_bc_descriptor = dynamic_cast<const DirichletBoundaryConditionDescriptor&>(*bc_descriptor); if (dirichlet_bc_descriptor.name() == "velocity") { - MeshNodeBoundary<Dimension> mesh_node_boundary = - getMeshNodeBoundary(mesh, dirichlet_bc_descriptor.boundaryDescriptor()); + MeshNodeBoundary mesh_node_boundary = getMeshNodeBoundary(mesh, dirichlet_bc_descriptor.boundaryDescriptor()); Array<const Rd> value_list = InterpolateItemValue<Rd(Rd)>::template interpolate<ItemType::node>(dirichlet_bc_descriptor.rhsSymbolId(), @@ -276,8 +276,7 @@ class HyperelasticSolverHandler::HyperelasticSolver final : public HyperelasticS const FunctionSymbolId pressure_id = dirichlet_bc_descriptor.rhsSymbolId(); if constexpr (Dimension == 1) { - MeshNodeBoundary<Dimension> mesh_node_boundary = - getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()); + MeshNodeBoundary mesh_node_boundary = getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()); Array<const double> node_values = InterpolateItemValue<double(Rd)>::template interpolate<ItemType::node>(pressure_id, mesh.xr(), @@ -285,8 +284,7 @@ class HyperelasticSolverHandler::HyperelasticSolver final : public HyperelasticS bc_list.emplace_back(PressureBoundaryCondition{mesh_node_boundary, node_values}); } else { - MeshFaceBoundary<Dimension> mesh_face_boundary = - getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor()); + MeshFaceBoundary mesh_face_boundary = getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor()); MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(mesh); Array<const double> face_values = @@ -299,8 +297,7 @@ class HyperelasticSolverHandler::HyperelasticSolver final : public HyperelasticS const FunctionSymbolId normal_stress_id = dirichlet_bc_descriptor.rhsSymbolId(); if constexpr (Dimension == 1) { - MeshNodeBoundary<Dimension> mesh_node_boundary = - getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()); + MeshNodeBoundary mesh_node_boundary = getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()); Array<const Rdxd> node_values = InterpolateItemValue<Rdxd(Rd)>::template interpolate<ItemType::node>(normal_stress_id, mesh.xr(), @@ -308,8 +305,7 @@ class HyperelasticSolverHandler::HyperelasticSolver final : public HyperelasticS bc_list.emplace_back(NormalStressBoundaryCondition{mesh_node_boundary, node_values}); } else { - MeshFaceBoundary<Dimension> mesh_face_boundary = - getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor()); + MeshFaceBoundary mesh_face_boundary = getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor()); MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(mesh); Array<const Rdxd> face_values = @@ -560,11 +556,11 @@ class HyperelasticSolverHandler::HyperelasticSolver final : public HyperelasticS ~HyperelasticSolver() = default; }; -template <size_t Dimension> +template <typename MeshType> void -HyperelasticSolverHandler::HyperelasticSolver<Dimension>::_applyPressureBC(const BoundaryConditionList& bc_list, - const MeshType& mesh, - NodeValue<Rd>& br) const +HyperelasticSolverHandler::HyperelasticSolver<MeshType>::_applyPressureBC(const BoundaryConditionList& bc_list, + const MeshType& mesh, + NodeValue<Rd>& br) const { for (const auto& boundary_condition : bc_list) { std::visit( @@ -625,11 +621,11 @@ HyperelasticSolverHandler::HyperelasticSolver<Dimension>::_applyPressureBC(const } } -template <size_t Dimension> +template <typename MeshType> void -HyperelasticSolverHandler::HyperelasticSolver<Dimension>::_applyNormalStressBC(const BoundaryConditionList& bc_list, - const MeshType& mesh, - NodeValue<Rd>& br) const +HyperelasticSolverHandler::HyperelasticSolver<MeshType>::_applyNormalStressBC(const BoundaryConditionList& bc_list, + const MeshType& mesh, + NodeValue<Rd>& br) const { for (const auto& boundary_condition : bc_list) { std::visit( @@ -690,11 +686,11 @@ HyperelasticSolverHandler::HyperelasticSolver<Dimension>::_applyNormalStressBC(c } } -template <size_t Dimension> +template <typename MeshType> void -HyperelasticSolverHandler::HyperelasticSolver<Dimension>::_applySymmetryBC(const BoundaryConditionList& bc_list, - NodeValue<Rdxd>& Ar, - NodeValue<Rd>& br) const +HyperelasticSolverHandler::HyperelasticSolver<MeshType>::_applySymmetryBC(const BoundaryConditionList& bc_list, + NodeValue<Rdxd>& Ar, + NodeValue<Rd>& br) const { for (const auto& boundary_condition : bc_list) { std::visit( @@ -721,11 +717,11 @@ HyperelasticSolverHandler::HyperelasticSolver<Dimension>::_applySymmetryBC(const } } -template <size_t Dimension> +template <typename MeshType> void -HyperelasticSolverHandler::HyperelasticSolver<Dimension>::_applyVelocityBC(const BoundaryConditionList& bc_list, - NodeValue<Rdxd>& Ar, - NodeValue<Rd>& br) const +HyperelasticSolverHandler::HyperelasticSolver<MeshType>::_applyVelocityBC(const BoundaryConditionList& bc_list, + NodeValue<Rdxd>& Ar, + NodeValue<Rd>& br) const { for (const auto& boundary_condition : bc_list) { std::visit( @@ -758,11 +754,11 @@ HyperelasticSolverHandler::HyperelasticSolver<Dimension>::_applyVelocityBC(const } } -template <size_t Dimension> -class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::FixedBoundaryCondition +template <typename MeshType> +class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::FixedBoundaryCondition { private: - const MeshNodeBoundary<Dimension> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; public: const Array<const NodeId>& @@ -771,18 +767,16 @@ class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::FixedBoundaryCon return m_mesh_node_boundary.nodeList(); } - FixedBoundaryCondition(const MeshNodeBoundary<Dimension> mesh_node_boundary) - : m_mesh_node_boundary{mesh_node_boundary} - {} + FixedBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary) : m_mesh_node_boundary{mesh_node_boundary} {} ~FixedBoundaryCondition() = default; }; -template <size_t Dimension> -class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::PressureBoundaryCondition +template <typename MeshType> +class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::PressureBoundaryCondition { private: - const MeshFaceBoundary<Dimension> m_mesh_face_boundary; + const MeshFaceBoundary m_mesh_face_boundary; const Array<const double> m_value_list; public: @@ -798,8 +792,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::PressureBoundary return m_value_list; } - PressureBoundaryCondition(const MeshFaceBoundary<Dimension>& mesh_face_boundary, - const Array<const double>& value_list) + PressureBoundaryCondition(const MeshFaceBoundary& mesh_face_boundary, const Array<const double>& value_list) : m_mesh_face_boundary{mesh_face_boundary}, m_value_list{value_list} {} @@ -807,10 +800,10 @@ class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::PressureBoundary }; template <> -class HyperelasticSolverHandler::HyperelasticSolver<1>::PressureBoundaryCondition +class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<Connectivity<1>>>::PressureBoundaryCondition { private: - const MeshNodeBoundary<1> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; const Array<const double> m_value_list; public: @@ -826,18 +819,18 @@ class HyperelasticSolverHandler::HyperelasticSolver<1>::PressureBoundaryConditio return m_value_list; } - PressureBoundaryCondition(const MeshNodeBoundary<1>& mesh_node_boundary, const Array<const double>& value_list) + PressureBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary, const Array<const double>& value_list) : m_mesh_node_boundary{mesh_node_boundary}, m_value_list{value_list} {} ~PressureBoundaryCondition() = default; }; -template <size_t Dimension> -class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::NormalStressBoundaryCondition +template <typename MeshType> +class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::NormalStressBoundaryCondition { private: - const MeshFaceBoundary<Dimension> m_mesh_face_boundary; + const MeshFaceBoundary m_mesh_face_boundary; const Array<const Rdxd> m_value_list; public: @@ -853,8 +846,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::NormalStressBoun return m_value_list; } - NormalStressBoundaryCondition(const MeshFaceBoundary<Dimension>& mesh_face_boundary, - const Array<const Rdxd>& value_list) + NormalStressBoundaryCondition(const MeshFaceBoundary& mesh_face_boundary, const Array<const Rdxd>& value_list) : m_mesh_face_boundary{mesh_face_boundary}, m_value_list{value_list} {} @@ -862,10 +854,10 @@ class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::NormalStressBoun }; template <> -class HyperelasticSolverHandler::HyperelasticSolver<1>::NormalStressBoundaryCondition +class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<Connectivity<1>>>::NormalStressBoundaryCondition { private: - const MeshNodeBoundary<1> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; const Array<const Rdxd> m_value_list; public: @@ -881,18 +873,18 @@ class HyperelasticSolverHandler::HyperelasticSolver<1>::NormalStressBoundaryCond return m_value_list; } - NormalStressBoundaryCondition(const MeshNodeBoundary<1>& mesh_node_boundary, const Array<const Rdxd>& value_list) + NormalStressBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary, const Array<const Rdxd>& value_list) : m_mesh_node_boundary{mesh_node_boundary}, m_value_list{value_list} {} ~NormalStressBoundaryCondition() = default; }; -template <size_t Dimension> -class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::VelocityBoundaryCondition +template <typename MeshType> +class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::VelocityBoundaryCondition { private: - const MeshNodeBoundary<Dimension> m_mesh_node_boundary; + const MeshNodeBoundary m_mesh_node_boundary; const Array<const TinyVector<Dimension>> m_value_list; @@ -909,7 +901,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::VelocityBoundary return m_value_list; } - VelocityBoundaryCondition(const MeshNodeBoundary<Dimension>& mesh_node_boundary, + VelocityBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary, const Array<const TinyVector<Dimension>>& value_list) : m_mesh_node_boundary{mesh_node_boundary}, m_value_list{value_list} {} @@ -917,14 +909,14 @@ class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::VelocityBoundary ~VelocityBoundaryCondition() = default; }; -template <size_t Dimension> -class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::SymmetryBoundaryCondition +template <typename MeshType> +class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::SymmetryBoundaryCondition { public: using Rd = TinyVector<Dimension, double>; private: - const MeshFlatNodeBoundary<Dimension> m_mesh_flat_node_boundary; + const MeshFlatNodeBoundary<MeshType> m_mesh_flat_node_boundary; public: const Rd& @@ -945,7 +937,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<Dimension>::SymmetryBoundary return m_mesh_flat_node_boundary.nodeList(); } - SymmetryBoundaryCondition(const MeshFlatNodeBoundary<Dimension>& mesh_flat_node_boundary) + SymmetryBoundaryCondition(const MeshFlatNodeBoundary<MeshType>& mesh_flat_node_boundary) : m_mesh_flat_node_boundary(mesh_flat_node_boundary) { ; @@ -964,7 +956,7 @@ HyperelasticSolverHandler::HyperelasticSolverHandler(const std::shared_ptr<const [&](auto&& mesh) { using MeshType = typename std::decay_t<decltype(mesh)>::element_type; if constexpr (is_polygonal_mesh<MeshType>) { - m_hyperelastic_solver = std::make_unique<HyperelasticSolver<MeshType::Dimension>>(); + m_hyperelastic_solver = std::make_unique<HyperelasticSolver<MeshType>>(); } else { throw NormalError("unexpected mesh type"); } diff --git a/src/scheme/HyperelasticSolver.hpp b/src/scheme/HyperelasticSolver.hpp index 37a20acbf372706656962718ab80230de399cd7a..75963a51971e623717bb363ec7e6c24fa4cced3e 100644 --- a/src/scheme/HyperelasticSolver.hpp +++ b/src/scheme/HyperelasticSolver.hpp @@ -65,14 +65,14 @@ class HyperelasticSolverHandler const std::shared_ptr<const DiscreteFunctionVariant>& p, const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list) const = 0; - IHyperelasticSolver() = default; - IHyperelasticSolver(IHyperelasticSolver&&) = default; + IHyperelasticSolver() = default; + IHyperelasticSolver(IHyperelasticSolver&&) = default; IHyperelasticSolver& operator=(IHyperelasticSolver&&) = default; virtual ~IHyperelasticSolver() = default; }; - template <size_t Dimension> + template <typename MeshType> class HyperelasticSolver; std::unique_ptr<IHyperelasticSolver> m_hyperelastic_solver;