From 83670ac0666617809288dc54d66a9046eebb9e4b Mon Sep 17 00:00:00 2001 From: Stephane Del Pino <stephane.delpino44@gmail.com> Date: Tue, 5 Mar 2024 00:58:22 +0100 Subject: [PATCH] Simplify template code -add MeshConcept to simplify compilation error -add mesh_type_t template utility to simplify -simplify code (dealing with constness of mesh types was not that easy) -check constness (at compile time) to help code writing in boundary utilities --- src/language/modules/SchemeModule.cpp | 2 +- src/language/utils/IntegrateCellValue.hpp | 6 ++--- .../ItemArrayVariantFunctionInterpoler.cpp | 2 +- .../ItemValueVariantFunctionInterpoler.cpp | 2 +- src/mesh/DiamondDualMeshBuilder.cpp | 2 +- src/mesh/DualMeshManager.cpp | 5 ++-- src/mesh/MedianDualMeshBuilder.cpp | 2 +- src/mesh/MeshFlatEdgeBoundary.cpp | 12 ++++----- src/mesh/MeshFlatEdgeBoundary.hpp | 10 ++++--- src/mesh/MeshFlatFaceBoundary.cpp | 12 ++++----- src/mesh/MeshFlatFaceBoundary.hpp | 10 ++++--- src/mesh/MeshFlatNodeBoundary.cpp | 26 +++++++++---------- src/mesh/MeshFlatNodeBoundary.hpp | 10 ++++--- src/mesh/MeshLineEdgeBoundary.cpp | 9 +++---- src/mesh/MeshLineEdgeBoundary.hpp | 10 ++++--- src/mesh/MeshLineFaceBoundary.cpp | 7 +++-- src/mesh/MeshLineFaceBoundary.hpp | 9 ++++--- src/mesh/MeshLineNodeBoundary.cpp | 16 ++++++------ src/mesh/MeshLineNodeBoundary.hpp | 9 ++++--- src/mesh/MeshRandomizer.cpp | 12 ++++----- src/mesh/MeshRelaxer.cpp | 4 +-- src/mesh/MeshSmoother.cpp | 8 +++--- src/mesh/MeshTraits.hpp | 23 +++++++++++++++- src/mesh/MeshTransformer.cpp | 3 ++- src/output/GnuplotWriter.cpp | 7 ++--- src/output/GnuplotWriter1D.cpp | 5 ++-- src/scheme/AcousticSolver.cpp | 4 +-- src/scheme/DiscreteFunctionIntegrator.cpp | 5 ++-- src/scheme/DiscreteFunctionInterpoler.cpp | 4 ++- .../DiscreteFunctionVectorIntegrator.cpp | 4 ++- .../DiscreteFunctionVectorInterpoler.cpp | 4 ++- src/scheme/FluxingAdvectionSolver.cpp | 13 +++++----- src/scheme/HyperelasticSolver.cpp | 6 ++--- 33 files changed, 152 insertions(+), 111 deletions(-) diff --git a/src/language/modules/SchemeModule.cpp b/src/language/modules/SchemeModule.cpp index e8d4bb390..7b404fcf6 100644 --- a/src/language/modules/SchemeModule.cpp +++ b/src/language/modules/SchemeModule.cpp @@ -637,7 +637,7 @@ SchemeModule::SchemeModule() -> std::shared_ptr<const DiscreteFunctionVariant> { return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { return std::make_shared<DiscreteFunctionVariant>( DiscreteFunctionP0(mesh_v, diff --git a/src/language/utils/IntegrateCellValue.hpp b/src/language/utils/IntegrateCellValue.hpp index ecd304ca7..cde3bfacc 100644 --- a/src/language/utils/IntegrateCellValue.hpp +++ b/src/language/utils/IntegrateCellValue.hpp @@ -36,7 +36,7 @@ class IntegrateCellValue<OutputType(InputType)> { return std::visit( [&](auto&& p_mesh) -> CellValue<OutputType> { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr ((is_polygonal_mesh_v<MeshType>)and(MeshType::Dimension == InputType::Dimension)) { return integrate(function_symbol_id, quadrature_descriptor, *p_mesh); } else { @@ -66,7 +66,7 @@ class IntegrateCellValue<OutputType(InputType)> { return std::visit( [&](auto&& p_mesh) -> Array<OutputType> { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr ((is_polygonal_mesh_v<MeshType>)and(MeshType::Dimension == InputType::Dimension)) { return integrate(function_symbol_id, quadrature_descriptor, *p_mesh, list_of_cells); } else { @@ -95,7 +95,7 @@ class IntegrateCellValue<OutputType(InputType)> { return std::visit( [&](auto&& p_mesh) -> Array<OutputType> { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr ((is_polygonal_mesh_v<MeshType>)and(MeshType::Dimension == InputType::Dimension)) { return integrate(function_symbol_id, quadrature_descriptor, *p_mesh, list_of_cells); } else { diff --git a/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp b/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp index a288765cc..1c4b2b9f0 100644 --- a/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp +++ b/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp @@ -147,7 +147,7 @@ ItemArrayVariantFunctionInterpoler::interpolate() const { return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { return this->_interpolate<MeshType>(); } else { diff --git a/src/language/utils/ItemValueVariantFunctionInterpoler.cpp b/src/language/utils/ItemValueVariantFunctionInterpoler.cpp index 1273a8da4..74d07b577 100644 --- a/src/language/utils/ItemValueVariantFunctionInterpoler.cpp +++ b/src/language/utils/ItemValueVariantFunctionInterpoler.cpp @@ -133,7 +133,7 @@ ItemValueVariantFunctionInterpoler::interpolate() const { return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { return this->_interpolate<MeshType>(); } else { diff --git a/src/mesh/DiamondDualMeshBuilder.cpp b/src/mesh/DiamondDualMeshBuilder.cpp index 36cb042d3..f6ecba946 100644 --- a/src/mesh/DiamondDualMeshBuilder.cpp +++ b/src/mesh/DiamondDualMeshBuilder.cpp @@ -45,7 +45,7 @@ DiamondDualMeshBuilder::DiamondDualMeshBuilder(const std::shared_ptr<const MeshV { std::visit( [&](auto&& p_mesh) { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { if constexpr (MeshType::Dimension > 1) { this->_buildDualDiamondMeshFrom(*p_mesh); diff --git a/src/mesh/DualMeshManager.cpp b/src/mesh/DualMeshManager.cpp index 846033489..a09413776 100644 --- a/src/mesh/DualMeshManager.cpp +++ b/src/mesh/DualMeshManager.cpp @@ -5,6 +5,7 @@ #include <mesh/Dual1DMeshBuilder.hpp> #include <mesh/MedianDualMeshBuilder.hpp> #include <mesh/Mesh.hpp> +#include <mesh/MeshTraits.hpp> #include <mesh/MeshVariant.hpp> #include <utils/Exceptions.hpp> #include <utils/PugsAssert.hpp> @@ -77,7 +78,7 @@ DualMeshManager::getMedianDualMesh(const std::shared_ptr<const MeshVariant>& mes { return std::visit( [&](auto&& p_mesh) { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr (MeshType::Dimension == 1) { return this->getDual1DMesh(mesh_v); } else { @@ -100,7 +101,7 @@ DualMeshManager::getDiamondDualMesh(const std::shared_ptr<const MeshVariant>& me { return std::visit( [&](auto&& p_mesh) { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr (MeshType::Dimension == 1) { return this->getDual1DMesh(mesh_v); } else { diff --git a/src/mesh/MedianDualMeshBuilder.cpp b/src/mesh/MedianDualMeshBuilder.cpp index a895dd088..5a22cf0b2 100644 --- a/src/mesh/MedianDualMeshBuilder.cpp +++ b/src/mesh/MedianDualMeshBuilder.cpp @@ -46,7 +46,7 @@ MedianDualMeshBuilder::MedianDualMeshBuilder(const std::shared_ptr<const MeshVar { std::visit( [&](auto&& p_mesh) { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { if constexpr (MeshType::Dimension > 1) { this->_buildMedianDualMeshFrom(*p_mesh); diff --git a/src/mesh/MeshFlatEdgeBoundary.cpp b/src/mesh/MeshFlatEdgeBoundary.cpp index 8b5669a34..7a2d4918d 100644 --- a/src/mesh/MeshFlatEdgeBoundary.cpp +++ b/src/mesh/MeshFlatEdgeBoundary.cpp @@ -5,16 +5,16 @@ #include <mesh/MeshFlatNodeBoundary.hpp> template <typename MeshType> -MeshFlatEdgeBoundary<const MeshType> +MeshFlatEdgeBoundary<MeshType> getMeshFlatEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { MeshEdgeBoundary mesh_edge_boundary = getMeshEdgeBoundary(mesh, boundary_descriptor); MeshFlatNodeBoundary mesh_flat_node_boundary = getMeshFlatNodeBoundary(mesh, boundary_descriptor); - return MeshFlatEdgeBoundary<const MeshType>{mesh, mesh_edge_boundary.refEdgeList(), - mesh_flat_node_boundary.outgoingNormal()}; + return MeshFlatEdgeBoundary<MeshType>{mesh, mesh_edge_boundary.refEdgeList(), + mesh_flat_node_boundary.outgoingNormal()}; } -template MeshFlatEdgeBoundary<const Mesh<1>> getMeshFlatEdgeBoundary(const Mesh<1>&, const IBoundaryDescriptor&); -template MeshFlatEdgeBoundary<const Mesh<2>> getMeshFlatEdgeBoundary(const Mesh<2>&, const IBoundaryDescriptor&); -template MeshFlatEdgeBoundary<const Mesh<3>> getMeshFlatEdgeBoundary(const Mesh<3>&, const IBoundaryDescriptor&); +template MeshFlatEdgeBoundary<Mesh<1>> getMeshFlatEdgeBoundary(const Mesh<1>&, const IBoundaryDescriptor&); +template MeshFlatEdgeBoundary<Mesh<2>> getMeshFlatEdgeBoundary(const Mesh<2>&, const IBoundaryDescriptor&); +template MeshFlatEdgeBoundary<Mesh<3>> getMeshFlatEdgeBoundary(const Mesh<3>&, const IBoundaryDescriptor&); diff --git a/src/mesh/MeshFlatEdgeBoundary.hpp b/src/mesh/MeshFlatEdgeBoundary.hpp index 60b54257f..f395c4ebf 100644 --- a/src/mesh/MeshFlatEdgeBoundary.hpp +++ b/src/mesh/MeshFlatEdgeBoundary.hpp @@ -7,6 +7,8 @@ template <typename MeshType> class MeshFlatEdgeBoundary final : public MeshEdgeBoundary // clazy:exclude=copyable-polymorphic { public: + static_assert(not std::is_const_v<MeshType>, "MeshType must be non-const"); + using Rd = TinyVector<MeshType::Dimension, double>; private: @@ -23,8 +25,8 @@ class MeshFlatEdgeBoundary final : public MeshEdgeBoundary // clazy:exclude=co MeshFlatEdgeBoundary& operator=(MeshFlatEdgeBoundary&&) = default; template <typename MeshTypeT> - friend MeshFlatEdgeBoundary<const MeshTypeT> getMeshFlatEdgeBoundary(const MeshTypeT& mesh, - const IBoundaryDescriptor& boundary_descriptor); + friend MeshFlatEdgeBoundary<MeshTypeT> getMeshFlatEdgeBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); private: MeshFlatEdgeBoundary(const MeshType& mesh, const RefEdgeList& ref_edge_list, const Rd& outgoing_normal) @@ -39,7 +41,7 @@ class MeshFlatEdgeBoundary final : public MeshEdgeBoundary // clazy:exclude=co }; template <typename MeshType> -MeshFlatEdgeBoundary<const MeshType> getMeshFlatEdgeBoundary(const MeshType& mesh, - const IBoundaryDescriptor& boundary_descriptor); +MeshFlatEdgeBoundary<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 12d7f439f..2ecdf6768 100644 --- a/src/mesh/MeshFlatFaceBoundary.cpp +++ b/src/mesh/MeshFlatFaceBoundary.cpp @@ -5,16 +5,16 @@ #include <mesh/MeshFlatNodeBoundary.hpp> template <typename MeshType> -MeshFlatFaceBoundary<const MeshType> +MeshFlatFaceBoundary<MeshType> getMeshFlatFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { MeshFaceBoundary mesh_face_boundary = getMeshFaceBoundary(mesh, boundary_descriptor); MeshFlatNodeBoundary mesh_flat_node_boundary = getMeshFlatNodeBoundary(mesh, boundary_descriptor); - return MeshFlatFaceBoundary<const MeshType>{mesh, mesh_face_boundary.refFaceList(), - mesh_flat_node_boundary.outgoingNormal()}; + return MeshFlatFaceBoundary<MeshType>{mesh, mesh_face_boundary.refFaceList(), + mesh_flat_node_boundary.outgoingNormal()}; } -template MeshFlatFaceBoundary<const Mesh<1>> getMeshFlatFaceBoundary(const Mesh<1>&, const IBoundaryDescriptor&); -template MeshFlatFaceBoundary<const Mesh<2>> getMeshFlatFaceBoundary(const Mesh<2>&, const IBoundaryDescriptor&); -template MeshFlatFaceBoundary<const Mesh<3>> getMeshFlatFaceBoundary(const Mesh<3>&, const IBoundaryDescriptor&); +template MeshFlatFaceBoundary<Mesh<1>> getMeshFlatFaceBoundary(const Mesh<1>&, const IBoundaryDescriptor&); +template MeshFlatFaceBoundary<Mesh<2>> getMeshFlatFaceBoundary(const Mesh<2>&, const IBoundaryDescriptor&); +template MeshFlatFaceBoundary<Mesh<3>> getMeshFlatFaceBoundary(const Mesh<3>&, const IBoundaryDescriptor&); diff --git a/src/mesh/MeshFlatFaceBoundary.hpp b/src/mesh/MeshFlatFaceBoundary.hpp index 3620d0f3d..1aa2e854f 100644 --- a/src/mesh/MeshFlatFaceBoundary.hpp +++ b/src/mesh/MeshFlatFaceBoundary.hpp @@ -7,6 +7,8 @@ template <typename MeshType> class MeshFlatFaceBoundary final : public MeshFaceBoundary // clazy:exclude=copyable-polymorphic { public: + static_assert(not std::is_const_v<MeshType>, "MeshType must be non-const"); + using Rd = TinyVector<MeshType::Dimension, double>; private: @@ -23,8 +25,8 @@ class MeshFlatFaceBoundary final : public MeshFaceBoundary // clazy:exclude=co MeshFlatFaceBoundary& operator=(MeshFlatFaceBoundary&&) = default; template <typename MeshTypeT> - friend MeshFlatFaceBoundary<const MeshTypeT> getMeshFlatFaceBoundary(const MeshTypeT& mesh, - const IBoundaryDescriptor& boundary_descriptor); + friend MeshFlatFaceBoundary<MeshTypeT> getMeshFlatFaceBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); private: MeshFlatFaceBoundary(const MeshType& mesh, const RefFaceList& ref_face_list, const Rd& outgoing_normal) @@ -39,7 +41,7 @@ class MeshFlatFaceBoundary final : public MeshFaceBoundary // clazy:exclude=co }; template <typename MeshType> -MeshFlatFaceBoundary<const MeshType> getMeshFlatFaceBoundary(const MeshType& mesh, - const IBoundaryDescriptor& boundary_descriptor); +MeshFlatFaceBoundary<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 df7631988..983f96738 100644 --- a/src/mesh/MeshFlatNodeBoundary.cpp +++ b/src/mesh/MeshFlatNodeBoundary.cpp @@ -34,7 +34,7 @@ MeshFlatNodeBoundary<MeshType>::_checkBoundaryIsFlat(const TinyVector<MeshType:: template <> TinyVector<1, double> -MeshFlatNodeBoundary<const Mesh<1>>::_getNormal(const Mesh<1>& mesh) +MeshFlatNodeBoundary<Mesh<1>>::_getNormal(const Mesh<1>& mesh) { using R = TinyVector<1, double>; @@ -60,7 +60,7 @@ MeshFlatNodeBoundary<const Mesh<1>>::_getNormal(const Mesh<1>& mesh) template <> TinyVector<2, double> -MeshFlatNodeBoundary<const Mesh<2>>::_getNormal(const Mesh<2>& mesh) +MeshFlatNodeBoundary<Mesh<2>>::_getNormal(const Mesh<2>& mesh) { using R2 = TinyVector<2, double>; @@ -88,7 +88,7 @@ MeshFlatNodeBoundary<const Mesh<2>>::_getNormal(const Mesh<2>& mesh) template <> TinyVector<3, double> -MeshFlatNodeBoundary<const Mesh<3>>::_getFarestNode(const Mesh<3>& mesh, const Rd& x0, const Rd& x1) +MeshFlatNodeBoundary<Mesh<3>>::_getFarestNode(const Mesh<3>& mesh, const Rd& x0, const Rd& x1) { const NodeValue<const Rd>& xr = mesh.xr(); const auto node_number = mesh.connectivity().nodeNumber(); @@ -139,7 +139,7 @@ MeshFlatNodeBoundary<const Mesh<3>>::_getFarestNode(const Mesh<3>& mesh, const R template <> TinyVector<3, double> -MeshFlatNodeBoundary<const Mesh<3>>::_getNormal(const Mesh<3>& mesh) +MeshFlatNodeBoundary<Mesh<3>>::_getNormal(const Mesh<3>& mesh) { using R3 = TinyVector<3, double>; @@ -196,7 +196,7 @@ MeshFlatNodeBoundary<const Mesh<3>>::_getNormal(const Mesh<3>& mesh) template <> TinyVector<1, double> -MeshFlatNodeBoundary<const Mesh<1>>::_getOutgoingNormal(const Mesh<1>& mesh) +MeshFlatNodeBoundary<Mesh<1>>::_getOutgoingNormal(const Mesh<1>& mesh) { using R = TinyVector<1, double>; @@ -239,7 +239,7 @@ MeshFlatNodeBoundary<const Mesh<1>>::_getOutgoingNormal(const Mesh<1>& mesh) template <> TinyVector<2, double> -MeshFlatNodeBoundary<const Mesh<2>>::_getOutgoingNormal(const Mesh<2>& mesh) +MeshFlatNodeBoundary<Mesh<2>>::_getOutgoingNormal(const Mesh<2>& mesh) { using R2 = TinyVector<2, double>; @@ -282,7 +282,7 @@ MeshFlatNodeBoundary<const Mesh<2>>::_getOutgoingNormal(const Mesh<2>& mesh) template <> TinyVector<3, double> -MeshFlatNodeBoundary<const Mesh<3>>::_getOutgoingNormal(const Mesh<3>& mesh) +MeshFlatNodeBoundary<Mesh<3>>::_getOutgoingNormal(const Mesh<3>& mesh) { using R3 = TinyVector<3, double>; @@ -324,7 +324,7 @@ MeshFlatNodeBoundary<const Mesh<3>>::_getOutgoingNormal(const Mesh<3>& mesh) } template <typename MeshType> -MeshFlatNodeBoundary<const MeshType> +MeshFlatNodeBoundary<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>(); @@ -332,7 +332,7 @@ getMeshFlatNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar 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<const MeshType>{mesh, ref_node_list}; + return MeshFlatNodeBoundary<MeshType>{mesh, ref_node_list}; } } for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>(); @@ -340,7 +340,7 @@ getMeshFlatNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar 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<const MeshType>{mesh, ref_face_list}; + return MeshFlatNodeBoundary<MeshType>{mesh, ref_face_list}; } } @@ -350,6 +350,6 @@ getMeshFlatNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar throw NormalError(ost.str()); } -template MeshFlatNodeBoundary<const Mesh<1>> getMeshFlatNodeBoundary(const Mesh<1>&, const IBoundaryDescriptor&); -template MeshFlatNodeBoundary<const Mesh<2>> getMeshFlatNodeBoundary(const Mesh<2>&, const IBoundaryDescriptor&); -template MeshFlatNodeBoundary<const Mesh<3>> getMeshFlatNodeBoundary(const Mesh<3>&, const IBoundaryDescriptor&); +template MeshFlatNodeBoundary<Mesh<1>> getMeshFlatNodeBoundary(const Mesh<1>&, const IBoundaryDescriptor&); +template MeshFlatNodeBoundary<Mesh<2>> getMeshFlatNodeBoundary(const Mesh<2>&, const IBoundaryDescriptor&); +template MeshFlatNodeBoundary<Mesh<3>> getMeshFlatNodeBoundary(const Mesh<3>&, const IBoundaryDescriptor&); diff --git a/src/mesh/MeshFlatNodeBoundary.hpp b/src/mesh/MeshFlatNodeBoundary.hpp index df3c9d288..453804724 100644 --- a/src/mesh/MeshFlatNodeBoundary.hpp +++ b/src/mesh/MeshFlatNodeBoundary.hpp @@ -7,6 +7,8 @@ template <typename MeshType> class [[nodiscard]] MeshFlatNodeBoundary final : public MeshNodeBoundary // clazy:exclude=copyable-polymorphic { public: + static_assert(not std::is_const_v<MeshType>, "MeshType must be non-const"); + using Rd = TinyVector<MeshType::Dimension, double>; private: @@ -34,8 +36,8 @@ class [[nodiscard]] MeshFlatNodeBoundary final : public MeshNodeBoundary // cl MeshFlatNodeBoundary& operator=(MeshFlatNodeBoundary&&) = default; template <typename MeshTypeT> - friend MeshFlatNodeBoundary<const MeshTypeT> getMeshFlatNodeBoundary(const MeshTypeT& mesh, - const IBoundaryDescriptor& boundary_descriptor); + friend MeshFlatNodeBoundary<MeshTypeT> getMeshFlatNodeBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); private: MeshFlatNodeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list) @@ -54,7 +56,7 @@ class [[nodiscard]] MeshFlatNodeBoundary final : public MeshNodeBoundary // cl }; template <typename MeshType> -MeshFlatNodeBoundary<const MeshType> getMeshFlatNodeBoundary(const MeshType& mesh, - const IBoundaryDescriptor& boundary_descriptor); +MeshFlatNodeBoundary<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 1d0c37526..f1e0333a9 100644 --- a/src/mesh/MeshLineEdgeBoundary.cpp +++ b/src/mesh/MeshLineEdgeBoundary.cpp @@ -6,15 +6,14 @@ #include <utils/Messenger.hpp> template <typename MeshType> -MeshLineEdgeBoundary<const MeshType> +MeshLineEdgeBoundary<MeshType> getMeshLineEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { MeshEdgeBoundary mesh_edge_boundary = getMeshEdgeBoundary(mesh, boundary_descriptor); MeshLineNodeBoundary mesh_line_node_boundary = getMeshLineNodeBoundary(mesh, boundary_descriptor); - return MeshLineEdgeBoundary<const MeshType>{mesh, mesh_edge_boundary.refEdgeList(), - mesh_line_node_boundary.direction()}; + return MeshLineEdgeBoundary<MeshType>{mesh, mesh_edge_boundary.refEdgeList(), mesh_line_node_boundary.direction()}; } -template MeshLineEdgeBoundary<const Mesh<2>> getMeshLineEdgeBoundary(const Mesh<2>&, const IBoundaryDescriptor&); -template MeshLineEdgeBoundary<const Mesh<3>> getMeshLineEdgeBoundary(const Mesh<3>&, const IBoundaryDescriptor&); +template MeshLineEdgeBoundary<Mesh<2>> getMeshLineEdgeBoundary(const Mesh<2>&, const IBoundaryDescriptor&); +template MeshLineEdgeBoundary<Mesh<3>> getMeshLineEdgeBoundary(const Mesh<3>&, const IBoundaryDescriptor&); diff --git a/src/mesh/MeshLineEdgeBoundary.hpp b/src/mesh/MeshLineEdgeBoundary.hpp index b120a6882..39c97a194 100644 --- a/src/mesh/MeshLineEdgeBoundary.hpp +++ b/src/mesh/MeshLineEdgeBoundary.hpp @@ -8,6 +8,8 @@ template <typename MeshType> class [[nodiscard]] MeshLineEdgeBoundary final : public MeshEdgeBoundary // clazy:exclude=copyable-polymorphic { public: + static_assert(not std::is_const_v<MeshType>, "MeshType must be non-const"); + static_assert(MeshType::Dimension > 1, "MeshLineEdgeBoundary makes only sense in dimension 1"); using Rd = TinyVector<MeshType::Dimension, double>; @@ -17,8 +19,8 @@ class [[nodiscard]] MeshLineEdgeBoundary final : public MeshEdgeBoundary // cl public: template <typename MeshTypeT> - friend MeshLineEdgeBoundary<const MeshTypeT> getMeshLineEdgeBoundary(const MeshTypeT& mesh, - const IBoundaryDescriptor& boundary_descriptor); + friend MeshLineEdgeBoundary<MeshTypeT> getMeshLineEdgeBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); PUGS_INLINE const Rd& @@ -43,7 +45,7 @@ class [[nodiscard]] MeshLineEdgeBoundary final : public MeshEdgeBoundary // cl }; template <typename MeshType> -MeshLineEdgeBoundary<const MeshType> getMeshLineEdgeBoundary(const MeshType& mesh, - const IBoundaryDescriptor& boundary_descriptor); +MeshLineEdgeBoundary<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 83bfdf8cf..81ea991ed 100644 --- a/src/mesh/MeshLineFaceBoundary.cpp +++ b/src/mesh/MeshLineFaceBoundary.cpp @@ -6,14 +6,13 @@ #include <utils/Messenger.hpp> template <typename MeshType> -MeshLineFaceBoundary<const MeshType> +MeshLineFaceBoundary<MeshType> getMeshLineFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_descriptor) { MeshFaceBoundary mesh_face_boundary = getMeshFaceBoundary(mesh, boundary_descriptor); MeshLineNodeBoundary mesh_line_node_boundary = getMeshLineNodeBoundary(mesh, boundary_descriptor); - return MeshLineFaceBoundary<const MeshType>{mesh, mesh_face_boundary.refFaceList(), - mesh_line_node_boundary.direction()}; + return MeshLineFaceBoundary<MeshType>{mesh, mesh_face_boundary.refFaceList(), mesh_line_node_boundary.direction()}; } -template MeshLineFaceBoundary<const Mesh<2>> getMeshLineFaceBoundary(const Mesh<2>&, const IBoundaryDescriptor&); +template MeshLineFaceBoundary<Mesh<2>> getMeshLineFaceBoundary(const Mesh<2>&, const IBoundaryDescriptor&); diff --git a/src/mesh/MeshLineFaceBoundary.hpp b/src/mesh/MeshLineFaceBoundary.hpp index f95611bb8..203faac8e 100644 --- a/src/mesh/MeshLineFaceBoundary.hpp +++ b/src/mesh/MeshLineFaceBoundary.hpp @@ -8,6 +8,7 @@ template <typename MeshType> class [[nodiscard]] MeshLineFaceBoundary final : public MeshFaceBoundary // clazy:exclude=copyable-polymorphic { public: + static_assert(not std::is_const_v<MeshType>, "MeshType must be non-const"); static_assert(MeshType::Dimension == 2, "MeshLineFaceBoundary makes only sense in dimension 2"); using Rd = TinyVector<MeshType::Dimension, double>; @@ -17,8 +18,8 @@ class [[nodiscard]] MeshLineFaceBoundary final : public MeshFaceBoundary // cl public: template <typename MeshTypeT> - friend MeshLineFaceBoundary<const MeshTypeT> getMeshLineFaceBoundary(const MeshTypeT& mesh, - const IBoundaryDescriptor& boundary_descriptor); + friend MeshLineFaceBoundary<MeshTypeT> getMeshLineFaceBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); PUGS_INLINE const Rd& @@ -43,7 +44,7 @@ class [[nodiscard]] MeshLineFaceBoundary final : public MeshFaceBoundary // cl }; template <typename MeshType> -MeshLineFaceBoundary<const MeshType> getMeshLineFaceBoundary(const MeshType& mesh, - const IBoundaryDescriptor& boundary_descriptor); +MeshLineFaceBoundary<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 dd145d889..1228fa5aa 100644 --- a/src/mesh/MeshLineNodeBoundary.cpp +++ b/src/mesh/MeshLineNodeBoundary.cpp @@ -38,7 +38,7 @@ MeshLineNodeBoundary<MeshType>::_checkBoundaryIsLine(const TinyVector<MeshType:: template <> TinyVector<2> -MeshLineNodeBoundary<const Mesh<2>>::_getDirection(const Mesh<2>& mesh) +MeshLineNodeBoundary<Mesh<2>>::_getDirection(const Mesh<2>& mesh) { using R2 = TinyVector<2, double>; @@ -65,7 +65,7 @@ MeshLineNodeBoundary<const Mesh<2>>::_getDirection(const Mesh<2>& mesh) template <> TinyVector<3> -MeshLineNodeBoundary<const Mesh<3>>::_getDirection(const Mesh<3>& mesh) +MeshLineNodeBoundary<Mesh<3>>::_getDirection(const Mesh<3>& mesh) { using R3 = TinyVector<3, double>; @@ -106,7 +106,7 @@ MeshLineNodeBoundary<const Mesh<3>>::_getDirection(const Mesh<3>& mesh) } template <typename MeshType> -MeshLineNodeBoundary<const MeshType> +MeshLineNodeBoundary<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>(); @@ -114,7 +114,7 @@ getMeshLineNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar 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<const MeshType>{mesh, ref_node_list}; + return MeshLineNodeBoundary<MeshType>{mesh, ref_node_list}; } } for (size_t i_ref_edge_list = 0; i_ref_edge_list < mesh.connectivity().template numberOfRefItemList<ItemType::edge>(); @@ -122,7 +122,7 @@ getMeshLineNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar 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<const MeshType>{mesh, ref_edge_list}; + return MeshLineNodeBoundary<MeshType>{mesh, ref_edge_list}; } } for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>(); @@ -130,7 +130,7 @@ getMeshLineNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar 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<const MeshType>{mesh, ref_face_list}; + return MeshLineNodeBoundary<MeshType>{mesh, ref_face_list}; } } @@ -140,5 +140,5 @@ getMeshLineNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar throw NormalError(ost.str()); } -template MeshLineNodeBoundary<const Mesh<2>> getMeshLineNodeBoundary(const Mesh<2>&, const IBoundaryDescriptor&); -template MeshLineNodeBoundary<const Mesh<3>> getMeshLineNodeBoundary(const Mesh<3>&, const IBoundaryDescriptor&); +template MeshLineNodeBoundary<Mesh<2>> getMeshLineNodeBoundary(const Mesh<2>&, const IBoundaryDescriptor&); +template MeshLineNodeBoundary<Mesh<3>> getMeshLineNodeBoundary(const Mesh<3>&, const IBoundaryDescriptor&); diff --git a/src/mesh/MeshLineNodeBoundary.hpp b/src/mesh/MeshLineNodeBoundary.hpp index 50dbfa00b..bb6fc4b04 100644 --- a/src/mesh/MeshLineNodeBoundary.hpp +++ b/src/mesh/MeshLineNodeBoundary.hpp @@ -8,6 +8,7 @@ template <typename MeshType> class [[nodiscard]] MeshLineNodeBoundary final : public MeshNodeBoundary // clazy:exclude=copyable-polymorphic { public: + static_assert(not std::is_const_v<MeshType>, "MeshType must be non-const"); static_assert(MeshType::Dimension > 1, "MeshLineNodeBoundary makes only sense in dimension greater than 1"); using Rd = TinyVector<MeshType::Dimension, double>; @@ -24,8 +25,8 @@ class [[nodiscard]] MeshLineNodeBoundary final : public MeshNodeBoundary // cl public: template <typename MeshTypeT> - friend MeshLineNodeBoundary<const MeshTypeT> getMeshLineNodeBoundary(const MeshTypeT& mesh, - const IBoundaryDescriptor& boundary_descriptor); + friend MeshLineNodeBoundary<MeshTypeT> getMeshLineNodeBoundary(const MeshTypeT& mesh, + const IBoundaryDescriptor& boundary_descriptor); PUGS_INLINE const Rd& @@ -58,7 +59,7 @@ class [[nodiscard]] MeshLineNodeBoundary final : public MeshNodeBoundary // cl }; template <typename MeshType> -MeshLineNodeBoundary<const MeshType> getMeshLineNodeBoundary(const MeshType& mesh, - const IBoundaryDescriptor& boundary_descriptor); +MeshLineNodeBoundary<MeshType> getMeshLineNodeBoundary(const MeshType& mesh, + const IBoundaryDescriptor& boundary_descriptor); #endif // MESH_LINE_NODE_BOUNDARY_HPP diff --git a/src/mesh/MeshRandomizer.cpp b/src/mesh/MeshRandomizer.cpp index 6b7d6f4e4..d6b8c2f1b 100644 --- a/src/mesh/MeshRandomizer.cpp +++ b/src/mesh/MeshRandomizer.cpp @@ -281,7 +281,7 @@ class MeshRandomizerHandler::MeshRandomizer<MeshType>::AxisBoundaryCondition using Rd = TinyVector<Dimension, double>; private: - const MeshLineNodeBoundary<const MeshType> m_mesh_line_node_boundary; + const MeshLineNodeBoundary<MeshType> m_mesh_line_node_boundary; public: const Rd& @@ -296,7 +296,7 @@ class MeshRandomizerHandler::MeshRandomizer<MeshType>::AxisBoundaryCondition return m_mesh_line_node_boundary.nodeList(); } - AxisBoundaryCondition(MeshLineNodeBoundary<const MeshType>&& mesh_line_node_boundary) + AxisBoundaryCondition(MeshLineNodeBoundary<MeshType>&& mesh_line_node_boundary) : m_mesh_line_node_boundary(mesh_line_node_boundary) { ; @@ -338,7 +338,7 @@ class MeshRandomizerHandler::MeshRandomizer<MeshType>::SymmetryBoundaryCondition using Rd = TinyVector<MeshType::Dimension, double>; private: - const MeshFlatNodeBoundary<const MeshType> m_mesh_flat_node_boundary; + const MeshFlatNodeBoundary<MeshType> m_mesh_flat_node_boundary; public: const Rd& @@ -353,7 +353,7 @@ class MeshRandomizerHandler::MeshRandomizer<MeshType>::SymmetryBoundaryCondition return m_mesh_flat_node_boundary.nodeList(); } - SymmetryBoundaryCondition(MeshFlatNodeBoundary<const MeshType>&& mesh_flat_node_boundary) + SymmetryBoundaryCondition(MeshFlatNodeBoundary<MeshType>&& mesh_flat_node_boundary) : m_mesh_flat_node_boundary(mesh_flat_node_boundary) { ; @@ -369,7 +369,7 @@ MeshRandomizerHandler::getRandomizedMesh( { return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { MeshRandomizer randomizer(*mesh, bc_descriptor_list); return randomizer.getRandomizedMesh(); @@ -388,7 +388,7 @@ MeshRandomizerHandler::getRandomizedMesh( { return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { MeshRandomizer randomizer(*mesh, bc_descriptor_list); return randomizer.getRandomizedMesh(function_symbol_id); diff --git a/src/mesh/MeshRelaxer.cpp b/src/mesh/MeshRelaxer.cpp index 1192c2aed..7dcc86bc0 100644 --- a/src/mesh/MeshRelaxer.cpp +++ b/src/mesh/MeshRelaxer.cpp @@ -38,8 +38,8 @@ MeshRelaxer::relax(const std::shared_ptr<const MeshVariant>& p_source_mesh, { return std::visit( [&](auto&& source_mesh, auto&& destination_mesh) -> std::shared_ptr<const MeshVariant> { - using SourceMeshType = typename std::decay_t<decltype(source_mesh)>::element_type; - using DestinationMeshType = typename std::decay_t<decltype(destination_mesh)>::element_type; + using SourceMeshType = mesh_type_t<decltype(source_mesh)>; + using DestinationMeshType = mesh_type_t<decltype(destination_mesh)>; if constexpr (std::is_same_v<SourceMeshType, DestinationMeshType>) { return this->_relax(*source_mesh, *destination_mesh, theta); } else { diff --git a/src/mesh/MeshSmoother.cpp b/src/mesh/MeshSmoother.cpp index 22c8b41b6..eafc9b94b 100644 --- a/src/mesh/MeshSmoother.cpp +++ b/src/mesh/MeshSmoother.cpp @@ -328,7 +328,7 @@ class MeshSmootherHandler::MeshSmoother<MeshType>::AxisBoundaryCondition using Rd = TinyVector<Dimension, double>; private: - const MeshLineNodeBoundary<const MeshType> m_mesh_line_node_boundary; + const MeshLineNodeBoundary<MeshType> m_mesh_line_node_boundary; public: const Rd& @@ -343,7 +343,7 @@ class MeshSmootherHandler::MeshSmoother<MeshType>::AxisBoundaryCondition return m_mesh_line_node_boundary.nodeList(); } - AxisBoundaryCondition(MeshLineNodeBoundary<const MeshType>&& mesh_line_node_boundary) + AxisBoundaryCondition(MeshLineNodeBoundary<MeshType>&& mesh_line_node_boundary) : m_mesh_line_node_boundary(mesh_line_node_boundary) { ; @@ -385,7 +385,7 @@ class MeshSmootherHandler::MeshSmoother<MeshType>::SymmetryBoundaryCondition using Rd = TinyVector<MeshType::Dimension, double>; private: - const MeshFlatNodeBoundary<const MeshType> m_mesh_flat_node_boundary; + const MeshFlatNodeBoundary<MeshType> m_mesh_flat_node_boundary; public: const Rd& @@ -400,7 +400,7 @@ class MeshSmootherHandler::MeshSmoother<MeshType>::SymmetryBoundaryCondition return m_mesh_flat_node_boundary.nodeList(); } - SymmetryBoundaryCondition(MeshFlatNodeBoundary<const MeshType>&& mesh_flat_node_boundary) + SymmetryBoundaryCondition(MeshFlatNodeBoundary<MeshType>&& mesh_flat_node_boundary) : m_mesh_flat_node_boundary(mesh_flat_node_boundary) { ; diff --git a/src/mesh/MeshTraits.hpp b/src/mesh/MeshTraits.hpp index 976954ed1..f55b53934 100644 --- a/src/mesh/MeshTraits.hpp +++ b/src/mesh/MeshTraits.hpp @@ -1,7 +1,9 @@ #ifndef MESH_TRAITS_HPP #define MESH_TRAITS_HPP -#include <cstddef> +#include <utils/PugsTraits.hpp> + +#include <memory> #include <type_traits> template <size_t Dimension> @@ -22,6 +24,25 @@ constexpr bool is_mesh_v<T&> = is_mesh_v<std::remove_cvref_t<T>>; template <typename T> concept MeshConcept = is_mesh_v<T>; +// Get mesh type (from std::shared_ptr for instance) + +template <typename T> +struct mesh_type_t_from +{ + static_assert(is_mesh_v<T>, "Requires mesh type"); + using type = std::remove_const_t<T>; +}; + +template <MeshConcept T, template <typename T1> typename C> +struct mesh_type_t_from<C<T>> +{ + static_assert(is_shared_ptr_v<std::decay_t<C<T>>>, "Requires std::shared_ptr container"); + using type = std::remove_const_t<T>; +}; + +template <typename T> +using mesh_type_t = typename mesh_type_t_from<std::decay_t<T>>::type; + // Check mesh kind template <MeshConcept MeshType> constexpr inline bool is_polygonal_mesh_v = false; diff --git a/src/mesh/MeshTransformer.cpp b/src/mesh/MeshTransformer.cpp index 74911b312..d44d3251c 100644 --- a/src/mesh/MeshTransformer.cpp +++ b/src/mesh/MeshTransformer.cpp @@ -2,6 +2,7 @@ #include <mesh/Connectivity.hpp> #include <mesh/Mesh.hpp> +#include <mesh/MeshTraits.hpp> #include <mesh/MeshVariant.hpp> #include <language/utils/EvaluateAtPoints.hpp> @@ -30,7 +31,7 @@ MeshTransformer::transform(const FunctionSymbolId& function_id, std::shared_ptr< { return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; constexpr size_t Dimension = MeshType::Dimension; using TransformT = TinyVector<Dimension>(TinyVector<Dimension>); diff --git a/src/output/GnuplotWriter.cpp b/src/output/GnuplotWriter.cpp index f846dd2eb..5415d59f8 100644 --- a/src/output/GnuplotWriter.cpp +++ b/src/output/GnuplotWriter.cpp @@ -5,6 +5,7 @@ #include <mesh/Mesh.hpp> #include <mesh/MeshData.hpp> #include <mesh/MeshDataManager.hpp> +#include <mesh/MeshTraits.hpp> #include <mesh/MeshVariant.hpp> #include <utils/Filesystem.hpp> #include <utils/Messenger.hpp> @@ -320,7 +321,7 @@ GnuplotWriter::_writeAtTime(const MeshVariant& mesh_v, std::visit( [&](auto&& p_mesh) { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr ((MeshType::Dimension == 1) or (MeshType::Dimension == 2)) { this->_write(*p_mesh, output_named_item_data_set, time); } else { @@ -337,7 +338,7 @@ GnuplotWriter::_writeMesh(const MeshVariant& mesh_v) const std::visit( [&](auto&& p_mesh) { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr ((MeshType::Dimension == 1) or (MeshType::Dimension == 2)) { this->_write(*p_mesh, output_named_item_data_set, {}); } else { @@ -355,7 +356,7 @@ GnuplotWriter::_write(const MeshVariant& mesh_v, std::visit( [&](auto&& p_mesh) { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr ((MeshType::Dimension == 1) or (MeshType::Dimension == 2)) { this->_write(*p_mesh, output_named_item_data_set, {}); } else { diff --git a/src/output/GnuplotWriter1D.cpp b/src/output/GnuplotWriter1D.cpp index 745903222..a31d5432f 100644 --- a/src/output/GnuplotWriter1D.cpp +++ b/src/output/GnuplotWriter1D.cpp @@ -5,6 +5,7 @@ #include <mesh/Mesh.hpp> #include <mesh/MeshData.hpp> #include <mesh/MeshDataManager.hpp> +#include <mesh/MeshTraits.hpp> #include <mesh/MeshVariant.hpp> #include <utils/Filesystem.hpp> #include <utils/Messenger.hpp> @@ -367,7 +368,7 @@ GnuplotWriter1D::_writeAtTime(const MeshVariant& mesh_v, std::visit( [&](auto&& p_mesh) { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr (MeshType::Dimension == 1) { this->_write(*p_mesh, output_named_item_data_set, time); } else if constexpr (MeshType::Dimension == 2) { @@ -391,7 +392,7 @@ GnuplotWriter1D::_write(const MeshVariant& mesh_v, std::visit( [&](auto&& p_mesh) { - using MeshType = typename std::decay_t<decltype(p_mesh)>::element_type; + using MeshType = mesh_type_t<decltype(p_mesh)>; if constexpr (MeshType::Dimension == 1) { this->_write(*p_mesh, output_named_item_data_set, {}); } else if constexpr (MeshType::Dimension == 2) { diff --git a/src/scheme/AcousticSolver.cpp b/src/scheme/AcousticSolver.cpp index 131854ec8..9f00bf12b 100644 --- a/src/scheme/AcousticSolver.cpp +++ b/src/scheme/AcousticSolver.cpp @@ -722,7 +722,7 @@ class AcousticSolverHandler::AcousticSolver<MeshType>::PressureBoundaryCondition }; template <> -class AcousticSolverHandler::AcousticSolver<const Mesh<1>>::PressureBoundaryCondition +class AcousticSolverHandler::AcousticSolver<Mesh<1>>::PressureBoundaryCondition { private: const MeshNodeBoundary m_mesh_node_boundary; @@ -871,7 +871,7 @@ AcousticSolverHandler::AcousticSolverHandler(const std::shared_ptr<const MeshVar std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { m_acoustic_solver = std::make_unique<AcousticSolver<MeshType>>(); } else { diff --git a/src/scheme/DiscreteFunctionIntegrator.cpp b/src/scheme/DiscreteFunctionIntegrator.cpp index 8b2913fe2..92dd526d2 100644 --- a/src/scheme/DiscreteFunctionIntegrator.cpp +++ b/src/scheme/DiscreteFunctionIntegrator.cpp @@ -174,10 +174,11 @@ DiscreteFunctionIntegrator::integrate() const { return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; - + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { return this->_integrate<MeshType>(); + } else { + throw NormalError("unexpected mesh type"); } }, m_mesh->variant()); diff --git a/src/scheme/DiscreteFunctionInterpoler.cpp b/src/scheme/DiscreteFunctionInterpoler.cpp index 3894eaed8..6c5228a91 100644 --- a/src/scheme/DiscreteFunctionInterpoler.cpp +++ b/src/scheme/DiscreteFunctionInterpoler.cpp @@ -192,10 +192,12 @@ DiscreteFunctionInterpoler::interpolate() const { return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { return this->_interpolate<MeshType>(); + } else { + throw NormalError("unexpected mesh type"); } }, m_mesh->variant()); diff --git a/src/scheme/DiscreteFunctionVectorIntegrator.cpp b/src/scheme/DiscreteFunctionVectorIntegrator.cpp index 25b460a2e..74bb43d66 100644 --- a/src/scheme/DiscreteFunctionVectorIntegrator.cpp +++ b/src/scheme/DiscreteFunctionVectorIntegrator.cpp @@ -130,10 +130,12 @@ DiscreteFunctionVectorIntegrator::integrate() const return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { return this->_integrate<MeshType>(); + } else { + throw NormalError("unexpected mesh type"); } }, m_mesh->variant()); diff --git a/src/scheme/DiscreteFunctionVectorInterpoler.cpp b/src/scheme/DiscreteFunctionVectorInterpoler.cpp index b30fe107b..547709c45 100644 --- a/src/scheme/DiscreteFunctionVectorInterpoler.cpp +++ b/src/scheme/DiscreteFunctionVectorInterpoler.cpp @@ -151,10 +151,12 @@ DiscreteFunctionVectorInterpoler::interpolate() const return std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { return this->_interpolate<MeshType>(); + } else { + throw NormalError("unexpected mesh type"); } }, m_mesh->variant()); diff --git a/src/scheme/FluxingAdvectionSolver.cpp b/src/scheme/FluxingAdvectionSolver.cpp index e7ec1994b..e1bf11a8b 100644 --- a/src/scheme/FluxingAdvectionSolver.cpp +++ b/src/scheme/FluxingAdvectionSolver.cpp @@ -15,6 +15,7 @@ #include <mesh/MeshFaceBoundary.hpp> #include <mesh/MeshFlatFaceBoundary.hpp> #include <mesh/MeshNodeBoundary.hpp> +#include <mesh/MeshTraits.hpp> #include <mesh/SubItemValuePerItem.hpp> #include <scheme/DiscreteFunctionP0.hpp> #include <scheme/DiscreteFunctionUtils.hpp> @@ -240,7 +241,7 @@ FluxingAdvectionSolver<MeshType>::_computeDonorCells(FaceValue<const double> alg template <> void -FluxingAdvectionSolver<const Mesh<1>>::_computeDonorCells(FaceValue<const double> algebraic_fluxing_volumes) +FluxingAdvectionSolver<Mesh<1>>::_computeDonorCells(FaceValue<const double> algebraic_fluxing_volumes) { m_donnor_cell = [&] { const auto face_to_cell_matrix = m_new_mesh->connectivity().faceToCellMatrix(); @@ -274,7 +275,7 @@ FluxingAdvectionSolver<const Mesh<1>>::_computeDonorCells(FaceValue<const double template <> FaceValue<double> -FluxingAdvectionSolver<const Mesh<1>>::_computeAlgebraicFluxingVolume() +FluxingAdvectionSolver<Mesh<1>>::_computeAlgebraicFluxingVolume() { Array<double> fluxing_volumes{m_new_mesh->numberOfNodes()}; NodeValue<double> nodal_fluxing_volume(m_new_mesh->connectivity(), fluxing_volumes); @@ -293,7 +294,7 @@ FluxingAdvectionSolver<const Mesh<1>>::_computeAlgebraicFluxingVolume() template <> FaceValue<double> -FluxingAdvectionSolver<const Mesh<2>>::_computeAlgebraicFluxingVolume() +FluxingAdvectionSolver<Mesh<2>>::_computeAlgebraicFluxingVolume() { const auto face_to_node_matrix = m_old_mesh->connectivity().faceToNodeMatrix(); FaceValue<double> algebraic_fluxing_volume(m_new_mesh->connectivity()); @@ -320,7 +321,7 @@ FluxingAdvectionSolver<const Mesh<2>>::_computeAlgebraicFluxingVolume() template <> FaceValue<double> -FluxingAdvectionSolver<const Mesh<3>>::_computeAlgebraicFluxingVolume() +FluxingAdvectionSolver<Mesh<3>>::_computeAlgebraicFluxingVolume() { // due to the z component of the jacobian determinant, degree 3 // polynomials must be exactly integrated @@ -869,8 +870,8 @@ advectByFluxing(const std::shared_ptr<const MeshVariant> new_mesh_v, return std::visit( [&](auto&& old_mesh, auto&& new_mesh) -> std::vector<std::shared_ptr<const DiscreteFunctionVariant>> { - using OldMeshType = typename std::decay_t<decltype(old_mesh)>::element_type; - using NewMeshType = typename std::decay_t<decltype(new_mesh)>::element_type; + using OldMeshType = mesh_type_t<decltype(old_mesh)>; + using NewMeshType = mesh_type_t<decltype(new_mesh)>; if constexpr (std::is_same_v<OldMeshType, NewMeshType>) { return FluxingAdvectionSolver<OldMeshType>{old_mesh, new_mesh}.remap(remapped_variables_with_bc); diff --git a/src/scheme/HyperelasticSolver.cpp b/src/scheme/HyperelasticSolver.cpp index c0d011fed..4fc391885 100644 --- a/src/scheme/HyperelasticSolver.cpp +++ b/src/scheme/HyperelasticSolver.cpp @@ -793,7 +793,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::PressureBoundaryC }; template <> -class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<1>>::PressureBoundaryCondition +class HyperelasticSolverHandler::HyperelasticSolver<Mesh<1>>::PressureBoundaryCondition { private: const MeshNodeBoundary m_mesh_node_boundary; @@ -847,7 +847,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::NormalStressBound }; template <> -class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<1>>::NormalStressBoundaryCondition +class HyperelasticSolverHandler::HyperelasticSolver<Mesh<1>>::NormalStressBoundaryCondition { private: const MeshNodeBoundary m_mesh_node_boundary; @@ -947,7 +947,7 @@ HyperelasticSolverHandler::HyperelasticSolverHandler(const std::shared_ptr<const std::visit( [&](auto&& mesh) { - using MeshType = typename std::decay_t<decltype(mesh)>::element_type; + using MeshType = mesh_type_t<decltype(mesh)>; if constexpr (is_polygonal_mesh_v<MeshType>) { m_hyperelastic_solver = std::make_unique<HyperelasticSolver<MeshType>>(); } else { -- GitLab