diff --git a/src/language/modules/MeshModule.cpp b/src/language/modules/MeshModule.cpp index bf2f0f0af34ce3d370137d79133804ef5eb51b37..153c1be1154ac1a5432ae00ba66b56e7b44937c2 100644 --- a/src/language/modules/MeshModule.cpp +++ b/src/language/modules/MeshModule.cpp @@ -146,19 +146,19 @@ MeshModule::MeshModule() using MeshType = Mesh<Connectivity<1>>; std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh); - return DualMeshManager::instance().getDiamondDualMesh(p_mesh); + return DualMeshManager::instance().getDiamondDualMesh(*p_mesh); } case 2: { using MeshType = Mesh<Connectivity<2>>; std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh); - return DualMeshManager::instance().getDiamondDualMesh(p_mesh); + return DualMeshManager::instance().getDiamondDualMesh(*p_mesh); } case 3: { using MeshType = Mesh<Connectivity<3>>; std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh); - return DualMeshManager::instance().getDiamondDualMesh(p_mesh); + return DualMeshManager::instance().getDiamondDualMesh(*p_mesh); } default: { throw UnexpectedError("invalid dimension"); @@ -178,19 +178,19 @@ MeshModule::MeshModule() using MeshType = Mesh<Connectivity<1>>; std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh); - return DualMeshManager::instance().getMedianDualMesh(p_mesh); + return DualMeshManager::instance().getMedianDualMesh(*p_mesh); } case 2: { using MeshType = Mesh<Connectivity<2>>; std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh); - return DualMeshManager::instance().getMedianDualMesh(p_mesh); + return DualMeshManager::instance().getMedianDualMesh(*p_mesh); } case 3: { using MeshType = Mesh<Connectivity<3>>; std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh); - return DualMeshManager::instance().getMedianDualMesh(p_mesh); + return DualMeshManager::instance().getMedianDualMesh(*p_mesh); } default: { throw UnexpectedError("invalid dimension"); diff --git a/src/mesh/CMakeLists.txt b/src/mesh/CMakeLists.txt index b85297c5152e477eac044e59dc41d7409a580363..7634b113494dc081bed63091e722dc8ea4b757fa 100644 --- a/src/mesh/CMakeLists.txt +++ b/src/mesh/CMakeLists.txt @@ -10,6 +10,7 @@ add_library( DiamondDualConnectivityBuilder.cpp DiamondDualMeshBuilder.cpp Dual1DConnectivityBuilder.cpp + Dual1DMeshBuilder.cpp DualConnectivityManager.cpp DualMeshManager.cpp GmshReader.cpp diff --git a/src/mesh/DiamondDualMeshBuilder.cpp b/src/mesh/DiamondDualMeshBuilder.cpp index 5db07c20fd46565a34b56d88b8ab2e6d43dfa80e..6f4c141cd9db559b65cb477088958e24418ae31a 100644 --- a/src/mesh/DiamondDualMeshBuilder.cpp +++ b/src/mesh/DiamondDualMeshBuilder.cpp @@ -7,17 +7,17 @@ #include <mesh/MeshData.hpp> #include <mesh/MeshDataManager.hpp> #include <mesh/PrimalToDiamondDualConnectivityDataMapper.hpp> -#include <mesh/PrimalToDual1DConnectivityDataMapper.hpp> template <size_t Dimension> void -DiamondDualMeshBuilder::_buildDualDiamondMeshFrom(const std::shared_ptr<const IMesh>& p_i_mesh) +DiamondDualMeshBuilder::_buildDualDiamondMeshFrom(const IMesh& i_mesh) { + static_assert(Dimension > 1); + using ConnectivityType = Connectivity<Dimension>; using MeshType = Mesh<Connectivity<Dimension>>; - std::shared_ptr p_primal_mesh = std::dynamic_pointer_cast<const MeshType>(p_i_mesh); - const MeshType& primal_mesh = *p_primal_mesh; + const MeshType& primal_mesh = dynamic_cast<const MeshType&>(i_mesh); DualConnectivityManager& manager = DualConnectivityManager::instance(); @@ -40,25 +40,21 @@ DiamondDualMeshBuilder::_buildDualDiamondMeshFrom(const std::shared_ptr<const IM m_mesh = std::make_shared<MeshType>(p_diamond_connectivity, diamond_xr); } -DiamondDualMeshBuilder::DiamondDualMeshBuilder(const std::shared_ptr<const IMesh>& p_mesh) +DiamondDualMeshBuilder::DiamondDualMeshBuilder(const IMesh& i_mesh) { std::cout << "building DiamondDualMesh\n"; - switch (p_mesh->dimension()) { - case 1: { - this->_buildDualDiamondMeshFrom<1>(p_mesh); - break; - } + switch (i_mesh.dimension()) { case 2: { - this->_buildDualDiamondMeshFrom<2>(p_mesh); + this->_buildDualDiamondMeshFrom<2>(i_mesh); break; } case 3: { - this->_buildDualDiamondMeshFrom<3>(p_mesh); + this->_buildDualDiamondMeshFrom<3>(i_mesh); break; } default: { - throw UnexpectedError("invalid mesh dimension: " + std::to_string(p_mesh->dimension())); + throw UnexpectedError("invalid mesh dimension: " + std::to_string(i_mesh.dimension())); } } } diff --git a/src/mesh/DiamondDualMeshBuilder.hpp b/src/mesh/DiamondDualMeshBuilder.hpp index a380bcbba5506f8c6a3de8f4cd48814aae100e2d..1dc670638796be11a686173b7bc07bff6728fbf8 100644 --- a/src/mesh/DiamondDualMeshBuilder.hpp +++ b/src/mesh/DiamondDualMeshBuilder.hpp @@ -9,10 +9,10 @@ class DiamondDualMeshBuilder : public MeshBuilderBase { private: template <size_t Dimension> - void _buildDualDiamondMeshFrom(const std::shared_ptr<const IMesh>&); + void _buildDualDiamondMeshFrom(const IMesh&); friend class DualMeshManager; - DiamondDualMeshBuilder(const std::shared_ptr<const IMesh>&); + DiamondDualMeshBuilder(const IMesh&); public: ~DiamondDualMeshBuilder() = default; diff --git a/src/mesh/Dual1DMeshBuilder.cpp b/src/mesh/Dual1DMeshBuilder.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0fd99847808d87967c097f85aa7ac0d0c85e1984 --- /dev/null +++ b/src/mesh/Dual1DMeshBuilder.cpp @@ -0,0 +1,50 @@ +#include <mesh/Dual1DMeshBuilder.hpp> + +#include <mesh/Connectivity.hpp> +#include <mesh/DualConnectivityManager.hpp> +#include <mesh/ItemValueUtils.hpp> +#include <mesh/Mesh.hpp> +#include <mesh/MeshData.hpp> +#include <mesh/MeshDataManager.hpp> +#include <mesh/PrimalToDiamondDualConnectivityDataMapper.hpp> +#include <mesh/PrimalToDual1DConnectivityDataMapper.hpp> + +void +Dual1DMeshBuilder::_buildDual1DMeshFrom(const IMesh& i_mesh) +{ + using ConnectivityType = Connectivity<1>; + using MeshType = Mesh<Connectivity<1>>; + + const MeshType& primal_mesh = dynamic_cast<const MeshType&>(i_mesh); + + DualConnectivityManager& manager = DualConnectivityManager::instance(); + + std::shared_ptr<const ConnectivityType> p_dual_connectivity = + manager.getDiamondDualConnectivity(primal_mesh.connectivity()); + + const ConnectivityType& dual_connectivity = *p_dual_connectivity; + + const NodeValue<const TinyVector<1>> primal_xr = primal_mesh.xr(); + + MeshData<1>& primal_mesh_data = MeshDataManager::instance().getMeshData(primal_mesh); + const CellValue<const TinyVector<1>> primal_xj = primal_mesh_data.xj(); + + std::shared_ptr primal_to_dual_1d_connectivity_data_mapper = + manager.getPrimalToDual1DConnectivityDataMapper(primal_mesh.connectivity()); + + NodeValue<TinyVector<1>> dual_xr{dual_connectivity}; + primal_to_dual_1d_connectivity_data_mapper->toDualNode(primal_xr, primal_xj, dual_xr); + + m_mesh = std::make_shared<MeshType>(p_dual_connectivity, dual_xr); +} + +Dual1DMeshBuilder::Dual1DMeshBuilder(const IMesh& i_mesh) +{ + std::cout << "building Dual1DMesh\n"; + + if (i_mesh.dimension() == 1) { + this->_buildDual1DMeshFrom(i_mesh); + } else { + throw UnexpectedError("invalid mesh dimension: " + std::to_string(i_mesh.dimension())); + } +} diff --git a/src/mesh/Dual1DMeshBuilder.hpp b/src/mesh/Dual1DMeshBuilder.hpp new file mode 100644 index 0000000000000000000000000000000000000000..d2b271aeebdfc9c8147ee7259610e344b9bdaae8 --- /dev/null +++ b/src/mesh/Dual1DMeshBuilder.hpp @@ -0,0 +1,20 @@ +#ifndef DUAL_1D_MESH_BUILDER_HPP +#define DUAL_1D_MESH_BUILDER_HPP + +#include <mesh/MeshBuilderBase.hpp> + +#include <memory> + +class Dual1DMeshBuilder : public MeshBuilderBase +{ + private: + void _buildDual1DMeshFrom(const IMesh&); + + friend class DualMeshManager; + Dual1DMeshBuilder(const IMesh&); + + public: + ~Dual1DMeshBuilder() = default; +}; + +#endif // DUAL_1D_MESH_BUILDER_HPP diff --git a/src/mesh/DualMeshManager.cpp b/src/mesh/DualMeshManager.cpp index 11f09ff2172dbd9ca02f88293a39de53323fda77..86384b6ad66d651b952a8ef1f1f86fd74a7b9176 100644 --- a/src/mesh/DualMeshManager.cpp +++ b/src/mesh/DualMeshManager.cpp @@ -2,6 +2,7 @@ #include <mesh/Connectivity.hpp> #include <mesh/DiamondDualMeshBuilder.hpp> +#include <mesh/Dual1DMeshBuilder.hpp> #include <mesh/MedianDualMeshBuilder.hpp> #include <mesh/Mesh.hpp> #include <utils/Exceptions.hpp> @@ -55,11 +56,35 @@ DualMeshManager::deleteMesh(const IMesh* p_mesh) } while (has_removed); } +std::shared_ptr<const Mesh<Connectivity<1>>> +DualMeshManager::getDual1DMesh(const Mesh<Connectivity<1>>& mesh) +{ + const IMesh* p_mesh = &mesh; + + auto key = std::make_pair(DualMeshType::Dual1D, p_mesh); + if (auto i_mesh_data = m_mesh_to_dual_mesh_map.find(key); i_mesh_data != m_mesh_to_dual_mesh_map.end()) { + return std::dynamic_pointer_cast<const Mesh<Connectivity<1>>>(i_mesh_data->second); + } else { + Dual1DMeshBuilder builder{mesh}; + + m_mesh_to_dual_mesh_map[key] = builder.mesh(); + return std::dynamic_pointer_cast<const Mesh<Connectivity<1>>>(builder.mesh()); + } +} + +template <> +std::shared_ptr<const Mesh<Connectivity<1>>> +DualMeshManager::getMedianDualMesh(const Mesh<Connectivity<1>>& mesh) +{ + return this->getDual1DMesh(mesh); +} + template <size_t Dimension> std::shared_ptr<const Mesh<Connectivity<Dimension>>> -DualMeshManager::getMedianDualMesh(std::shared_ptr<const Mesh<Connectivity<Dimension>>> mesh) +DualMeshManager::getMedianDualMesh(const Mesh<Connectivity<Dimension>>& mesh) { - const IMesh* p_mesh = mesh.get(); + static_assert(Dimension > 1); + const IMesh* p_mesh = &mesh; auto key = std::make_pair(DualMeshType::Median, p_mesh); if (auto i_mesh_data = m_mesh_to_dual_mesh_map.find(key); i_mesh_data != m_mesh_to_dual_mesh_map.end()) { @@ -72,11 +97,23 @@ DualMeshManager::getMedianDualMesh(std::shared_ptr<const Mesh<Connectivity<Dimen } } +template std::shared_ptr<const Mesh<Connectivity<2>>> DualMeshManager::getMedianDualMesh(const Mesh<Connectivity<2>>&); +template std::shared_ptr<const Mesh<Connectivity<3>>> DualMeshManager::getMedianDualMesh(const Mesh<Connectivity<3>>&); + +template <> +std::shared_ptr<const Mesh<Connectivity<1>>> +DualMeshManager::getDiamondDualMesh(const Mesh<Connectivity<1>>& mesh) +{ + return this->getDual1DMesh(mesh); +} + template <size_t Dimension> std::shared_ptr<const Mesh<Connectivity<Dimension>>> -DualMeshManager::getDiamondDualMesh(std::shared_ptr<const Mesh<Connectivity<Dimension>>> mesh) +DualMeshManager::getDiamondDualMesh(const Mesh<Connectivity<Dimension>>& mesh) { - const IMesh* p_mesh = mesh.get(); + static_assert(Dimension > 1); + + const IMesh* p_mesh = &mesh; auto key = std::make_pair(DualMeshType::Diamond, p_mesh); if (auto i_mesh_data = m_mesh_to_dual_mesh_map.find(key); i_mesh_data != m_mesh_to_dual_mesh_map.end()) { @@ -89,16 +126,5 @@ DualMeshManager::getDiamondDualMesh(std::shared_ptr<const Mesh<Connectivity<Dime } } -template std::shared_ptr<const Mesh<Connectivity<1>>> DualMeshManager::getMedianDualMesh( - std::shared_ptr<const Mesh<Connectivity<1>>>); -template std::shared_ptr<const Mesh<Connectivity<2>>> DualMeshManager::getMedianDualMesh( - std::shared_ptr<const Mesh<Connectivity<2>>>); -template std::shared_ptr<const Mesh<Connectivity<3>>> DualMeshManager::getMedianDualMesh( - std::shared_ptr<const Mesh<Connectivity<3>>>); - -template std::shared_ptr<const Mesh<Connectivity<1>>> DualMeshManager::getDiamondDualMesh( - std::shared_ptr<const Mesh<Connectivity<1>>>); -template std::shared_ptr<const Mesh<Connectivity<2>>> DualMeshManager::getDiamondDualMesh( - std::shared_ptr<const Mesh<Connectivity<2>>>); -template std::shared_ptr<const Mesh<Connectivity<3>>> DualMeshManager::getDiamondDualMesh( - std::shared_ptr<const Mesh<Connectivity<3>>>); +template std::shared_ptr<const Mesh<Connectivity<2>>> DualMeshManager::getDiamondDualMesh(const Mesh<Connectivity<2>>&); +template std::shared_ptr<const Mesh<Connectivity<3>>> DualMeshManager::getDiamondDualMesh(const Mesh<Connectivity<3>>&); diff --git a/src/mesh/DualMeshManager.hpp b/src/mesh/DualMeshManager.hpp index 77c14d5e4c7ab7ca073f2895566410390bfc4a7d..7b6358b7010d6e8a2487f53697e143640da79235 100644 --- a/src/mesh/DualMeshManager.hpp +++ b/src/mesh/DualMeshManager.hpp @@ -52,13 +52,13 @@ class DualMeshManager void deleteMesh(const IMesh*); + std::shared_ptr<const Mesh<Connectivity<1>>> getDual1DMesh(const Mesh<Connectivity<1>>&); + template <size_t Dimension> - std::shared_ptr<const Mesh<Connectivity<Dimension>>> getDiamondDualMesh( - std::shared_ptr<const Mesh<Connectivity<Dimension>>>); + std::shared_ptr<const Mesh<Connectivity<Dimension>>> getDiamondDualMesh(const Mesh<Connectivity<Dimension>>&); template <size_t Dimension> - std::shared_ptr<const Mesh<Connectivity<Dimension>>> getMedianDualMesh( - std::shared_ptr<const Mesh<Connectivity<Dimension>>>); + std::shared_ptr<const Mesh<Connectivity<Dimension>>> getMedianDualMesh(const Mesh<Connectivity<Dimension>>&); }; #endif // DUAL_MESH_MANAGER_HPP diff --git a/src/mesh/MedianDualMeshBuilder.cpp b/src/mesh/MedianDualMeshBuilder.cpp index 87af0be245da317c6f6b87f000b42af0b1166ae7..1dde88902dacb6e408d9f530a680772d59b50194 100644 --- a/src/mesh/MedianDualMeshBuilder.cpp +++ b/src/mesh/MedianDualMeshBuilder.cpp @@ -10,15 +10,14 @@ template <size_t Dimension> void -MedianDualMeshBuilder::_buildMedianDualMeshFrom(const std::shared_ptr<const IMesh>& p_i_mesh) +MedianDualMeshBuilder::_buildMedianDualMeshFrom(const IMesh& i_mesh) { static_assert(Dimension > 1); using ConnectivityType = Connectivity<Dimension>; using MeshType = Mesh<Connectivity<Dimension>>; - std::shared_ptr p_primal_mesh = std::dynamic_pointer_cast<const MeshType>(p_i_mesh); - const MeshType& primal_mesh = *p_primal_mesh; + const MeshType& primal_mesh = dynamic_cast<const MeshType&>(i_mesh); DualConnectivityManager& manager = DualConnectivityManager::instance(); @@ -42,15 +41,11 @@ MedianDualMeshBuilder::_buildMedianDualMeshFrom(const std::shared_ptr<const IMes m_mesh = std::make_shared<MeshType>(p_dual_connectivity, dual_xr); } -MedianDualMeshBuilder::MedianDualMeshBuilder(const std::shared_ptr<const IMesh>& p_mesh) +MedianDualMeshBuilder::MedianDualMeshBuilder(const IMesh& i_mesh) { - switch (p_mesh->dimension()) { - case 1: { - throw NotImplementedError("must be treated as a special common case with diamond dual meshes"); - break; - } + switch (i_mesh.dimension()) { case 2: { - this->_buildMedianDualMeshFrom<2>(p_mesh); + this->_buildMedianDualMeshFrom<2>(i_mesh); break; } case 3: { @@ -58,7 +53,7 @@ MedianDualMeshBuilder::MedianDualMeshBuilder(const std::shared_ptr<const IMesh>& break; } default: { - throw UnexpectedError("invalid mesh dimension: " + std::to_string(p_mesh->dimension())); + throw UnexpectedError("invalid mesh dimension: " + std::to_string(i_mesh.dimension())); } } } diff --git a/src/mesh/MedianDualMeshBuilder.hpp b/src/mesh/MedianDualMeshBuilder.hpp index 0d649c509b3e8f0f92c4f93532372a6a7adb68c4..6f8f1842c83bd272dd685984eb6dd91f84b0da8c 100644 --- a/src/mesh/MedianDualMeshBuilder.hpp +++ b/src/mesh/MedianDualMeshBuilder.hpp @@ -9,10 +9,10 @@ class MedianDualMeshBuilder : public MeshBuilderBase { private: template <size_t Dimension> - void _buildMedianDualMeshFrom(const std::shared_ptr<const IMesh>&); + void _buildMedianDualMeshFrom(const IMesh&); friend class DualMeshManager; - MedianDualMeshBuilder(const std::shared_ptr<const IMesh>&); + MedianDualMeshBuilder(const IMesh&); public: ~MedianDualMeshBuilder() = default; diff --git a/tests/test_CellIntegrator.cpp b/tests/test_CellIntegrator.cpp index a0f19555c110193a7805365cf16cfe9dfcfeb240..49f750afb6ebd7a28135949b2d6aca2473b24c44 100644 --- a/tests/test_CellIntegrator.cpp +++ b/tests/test_CellIntegrator.cpp @@ -493,7 +493,7 @@ TEST_CASE("CellIntegrator", "[scheme]") std::vector<std::pair<std::string, decltype(hybrid_mesh)>> mesh_list; mesh_list.push_back(std::make_pair("hybrid mesh", hybrid_mesh)); - mesh_list.push_back(std::make_pair("diamond mesh", DualMeshManager::instance().getDiamondDualMesh(hybrid_mesh))); + mesh_list.push_back(std::make_pair("diamond mesh", DualMeshManager::instance().getDiamondDualMesh(*hybrid_mesh))); for (auto mesh_info : mesh_list) { auto mesh_name = mesh_info.first; diff --git a/tests/test_DualMeshManager.cpp b/tests/test_DualMeshManager.cpp index 6e24f7aa99e558ebfd5ed621244a4a99e073bf37..e5c8dbcf83d5296390be98725e3fbca887464f5f 100644 --- a/tests/test_DualMeshManager.cpp +++ b/tests/test_DualMeshManager.cpp @@ -18,12 +18,12 @@ TEST_CASE("DualMeshManager", "[mesh]") SECTION("diamond dual mesh access") { - std::shared_ptr p_diamond_dual_mesh = DualMeshManager::instance().getDiamondDualMesh(mesh); + std::shared_ptr p_diamond_dual_mesh = DualMeshManager::instance().getDiamondDualMesh(*mesh); const auto ref_counter = p_diamond_dual_mesh.use_count(); { - std::shared_ptr p_diamond_dual_mesh2 = DualMeshManager::instance().getDiamondDualMesh(mesh); + std::shared_ptr p_diamond_dual_mesh2 = DualMeshManager::instance().getDiamondDualMesh(*mesh); REQUIRE(p_diamond_dual_mesh == p_diamond_dual_mesh2); REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter + 1); @@ -40,7 +40,7 @@ TEST_CASE("DualMeshManager", "[mesh]") REQUIRE(p_diamond_dual_mesh.use_count() == ref_counter - 1); // A new dual mesh is built - std::shared_ptr p_diamond_dual_mesh_rebuilt = DualMeshManager::instance().getDiamondDualMesh(mesh); + std::shared_ptr p_diamond_dual_mesh_rebuilt = DualMeshManager::instance().getDiamondDualMesh(*mesh); REQUIRE(p_diamond_dual_mesh != p_diamond_dual_mesh_rebuilt); REQUIRE(p_diamond_dual_mesh.get() != p_diamond_dual_mesh_rebuilt.get()); @@ -51,12 +51,12 @@ TEST_CASE("DualMeshManager", "[mesh]") SECTION("median dual mesh access") { - std::shared_ptr p_median_dual_mesh = DualMeshManager::instance().getMedianDualMesh(mesh); + std::shared_ptr p_median_dual_mesh = DualMeshManager::instance().getMedianDualMesh(*mesh); const auto ref_counter = p_median_dual_mesh.use_count(); { - std::shared_ptr p_median_dual_mesh2 = DualMeshManager::instance().getMedianDualMesh(mesh); + std::shared_ptr p_median_dual_mesh2 = DualMeshManager::instance().getMedianDualMesh(*mesh); REQUIRE(p_median_dual_mesh == p_median_dual_mesh2); REQUIRE(p_median_dual_mesh.use_count() == ref_counter + 1); @@ -73,7 +73,7 @@ TEST_CASE("DualMeshManager", "[mesh]") REQUIRE(p_median_dual_mesh.use_count() == ref_counter - 1); // A new dual mesh is built - std::shared_ptr p_median_dual_mesh_rebuilt = DualMeshManager::instance().getMedianDualMesh(mesh); + std::shared_ptr p_median_dual_mesh_rebuilt = DualMeshManager::instance().getMedianDualMesh(*mesh); REQUIRE(p_median_dual_mesh != p_median_dual_mesh_rebuilt); REQUIRE(p_median_dual_mesh.get() != p_median_dual_mesh_rebuilt.get()); @@ -84,8 +84,8 @@ TEST_CASE("DualMeshManager", "[mesh]") SECTION("check multiple dual mesh using/freeing") { - std::shared_ptr p_median_dual_mesh = DualMeshManager::instance().getMedianDualMesh(mesh); - std::shared_ptr p_diamond_dual_mesh = DualMeshManager::instance().getDiamondDualMesh(mesh); + std::shared_ptr p_median_dual_mesh = DualMeshManager::instance().getMedianDualMesh(*mesh); + std::shared_ptr p_diamond_dual_mesh = DualMeshManager::instance().getDiamondDualMesh(*mesh); const auto median_ref_counter = p_median_dual_mesh.use_count(); const auto diamond_ref_counter = p_diamond_dual_mesh.use_count(); diff --git a/tests/test_EdgeIntegrator.cpp b/tests/test_EdgeIntegrator.cpp index dbfc74d49b630a32d24f8b1c81c0f92273698c38..f8ea09cee6bdeef7352281f207e2dfcc3b66e408 100644 --- a/tests/test_EdgeIntegrator.cpp +++ b/tests/test_EdgeIntegrator.cpp @@ -30,7 +30,7 @@ TEST_CASE("EdgeIntegrator", "[scheme]") std::vector<std::pair<std::string, decltype(hybrid_mesh)>> mesh_list; mesh_list.push_back(std::make_pair("hybrid mesh", hybrid_mesh)); - mesh_list.push_back(std::make_pair("diamond mesh", DualMeshManager::instance().getDiamondDualMesh(hybrid_mesh))); + mesh_list.push_back(std::make_pair("diamond mesh", DualMeshManager::instance().getDiamondDualMesh(*hybrid_mesh))); for (auto mesh_info : mesh_list) { auto mesh_name = mesh_info.first; diff --git a/tests/test_FaceIntegrator.cpp b/tests/test_FaceIntegrator.cpp index 4afe3f9dc3c8573b1478ac06dc0ca9899956fc0c..184f1a8f97db137f99f638f5feef048f4d78ec04 100644 --- a/tests/test_FaceIntegrator.cpp +++ b/tests/test_FaceIntegrator.cpp @@ -258,7 +258,7 @@ TEST_CASE("FaceIntegrator", "[scheme]") std::vector<std::pair<std::string, decltype(hybrid_mesh)>> mesh_list; mesh_list.push_back(std::make_pair("hybrid mesh", hybrid_mesh)); - mesh_list.push_back(std::make_pair("diamond mesh", DualMeshManager::instance().getDiamondDualMesh(hybrid_mesh))); + mesh_list.push_back(std::make_pair("diamond mesh", DualMeshManager::instance().getDiamondDualMesh(*hybrid_mesh))); for (auto mesh_info : mesh_list) { auto mesh_name = mesh_info.first;