From 6add3ad1dd2a238858b0cde45e0584685b7717b0 Mon Sep 17 00:00:00 2001
From: Stephane Del Pino <stephane.delpino44@gmail.com>
Date: Sun, 25 Feb 2024 19:57:34 +0100
Subject: [PATCH] Change Mesh class template argument
Mesh<Connectivity<Dimension>> now writes simply Mesh<Dimension>
Also remove dimension template parameters for Mesh*Interface classes
forgot previously
---
.../EmbeddedDiscreteFunctionMathFunctions.cpp | 2 +-
src/mesh/CartesianMeshBuilder.cpp | 2 +-
src/mesh/Dual1DMeshBuilder.cpp | 5 +-
src/mesh/DualMeshManager.hpp | 6 --
src/mesh/GmshReader.cpp | 6 +-
src/mesh/Mesh.cpp | 10 ++--
src/mesh/Mesh.hpp | 13 ++--
src/mesh/MeshBuilderBase.cpp | 6 +-
src/mesh/MeshCellZone.cpp | 10 ++--
src/mesh/MeshCellZone.hpp | 17 +++---
src/mesh/MeshData.hpp | 5 +-
src/mesh/MeshDataManager.cpp | 8 +--
src/mesh/MeshDataManager.hpp | 7 +--
src/mesh/MeshEdgeBoundary.cpp | 16 ++---
src/mesh/MeshEdgeInterface.cpp | 40 +++++++------
src/mesh/MeshEdgeInterface.hpp | 33 +++++------
src/mesh/MeshFaceBoundary.cpp | 12 ++--
src/mesh/MeshFaceInterface.cpp | 25 ++++----
src/mesh/MeshFaceInterface.hpp | 30 ++++------
src/mesh/MeshFlatEdgeBoundary.cpp | 9 +--
src/mesh/MeshFlatFaceBoundary.cpp | 9 +--
src/mesh/MeshFlatNodeBoundary.cpp | 25 ++++----
src/mesh/MeshLineEdgeBoundary.cpp | 6 +-
src/mesh/MeshLineFaceBoundary.cpp | 3 +-
src/mesh/MeshLineNodeBoundary.cpp | 10 ++--
src/mesh/MeshNodeBoundary.cpp | 24 ++++----
src/mesh/MeshNodeBoundaryUtils.cpp | 4 +-
src/mesh/MeshNodeInterface.cpp | 59 ++++++++++---------
src/mesh/MeshNodeInterface.hpp | 39 +++++-------
src/mesh/MeshRandomizer.cpp | 2 +-
src/mesh/MeshRelaxer.hpp | 3 -
src/mesh/MeshSmoother.cpp | 2 +-
src/mesh/MeshTraits.hpp | 9 +--
src/mesh/MeshVariant.hpp | 11 ++--
src/scheme/AcousticSolver.cpp | 8 +--
src/scheme/DiscreteFunctionP0.hpp | 7 +--
src/scheme/DiscreteFunctionP0Vector.hpp | 3 +-
src/scheme/FluxingAdvectionSolver.cpp | 13 ++--
src/scheme/HyperelasticSolver.cpp | 6 +-
tests/test_CellIntegrator.cpp | 18 +++---
tests/test_Connectivity.cpp | 58 +++++++++---------
tests/test_DiamondDualConnectivityBuilder.cpp | 8 +--
tests/test_DiamondDualMeshBuilder.cpp | 14 ++---
.../test_DiscreteFunctionIntegratorByZone.cpp | 6 +-
tests/test_DiscreteFunctionInterpoler.cpp | 6 +-
.../test_DiscreteFunctionInterpolerByZone.cpp | 6 +-
tests/test_DiscreteFunctionP0.cpp | 55 ++++++++---------
tests/test_DiscreteFunctionP0Vector.cpp | 36 +++++------
tests/test_DiscreteFunctionUtils.cpp | 18 +++---
.../test_DiscreteFunctionVectorIntegrator.cpp | 8 +--
...DiscreteFunctionVectorIntegratorByZone.cpp | 6 +-
.../test_DiscreteFunctionVectorInterpoler.cpp | 8 +--
...DiscreteFunctionVectorInterpolerByZone.cpp | 8 +--
tests/test_Dual1DConnectivityBuilder.cpp | 4 +-
tests/test_Dual1DMeshBuilder.cpp | 3 +-
tests/test_DualConnectivityManager.cpp | 4 +-
tests/test_DualMeshManager.cpp | 6 +-
tests/test_EdgeIntegrator.cpp | 6 +-
...mbeddedDiscreteFunctionMathFunctions1D.cpp | 5 +-
...mbeddedDiscreteFunctionMathFunctions2D.cpp | 5 +-
...mbeddedDiscreteFunctionMathFunctions3D.cpp | 5 +-
...st_EmbeddedDiscreteFunctionOperators1D.cpp | 5 +-
...st_EmbeddedDiscreteFunctionOperators2D.cpp | 5 +-
...st_EmbeddedDiscreteFunctionOperators3D.cpp | 5 +-
tests/test_EmbeddedDiscreteFunctionUtils.cpp | 4 +-
tests/test_FaceIntegrator.cpp | 12 ++--
tests/test_IntegrateCellArray.cpp | 12 ++--
tests/test_IntegrateCellValue.cpp | 12 ++--
tests/test_IntegrateOnCells.cpp | 36 +++++------
tests/test_InterpolateItemArray.cpp | 30 +++++-----
tests/test_InterpolateItemValue.cpp | 14 ++---
tests/test_ItemArray.cpp | 22 +++----
tests/test_ItemArrayUtils.cpp | 28 ++++-----
tests/test_ItemArrayVariant.cpp | 2 +-
...est_ItemArrayVariantFunctionInterpoler.cpp | 6 +-
tests/test_ItemValue.cpp | 22 +++----
tests/test_ItemValueUtils.cpp | 32 +++++-----
tests/test_ItemValueVariant.cpp | 2 +-
...est_ItemValueVariantFunctionInterpoler.cpp | 6 +-
tests/test_MedianDualConnectivityBuilder.cpp | 4 +-
tests/test_MedianDualMeshBuilder.cpp | 3 +-
tests/test_MeshEdgeBoundary.cpp | 24 ++++----
tests/test_MeshEdgeInterface.cpp | 15 +++--
tests/test_MeshFaceBoundary.cpp | 24 ++++----
tests/test_MeshFaceInterface.cpp | 24 ++++----
tests/test_MeshFlatEdgeBoundary.cpp | 28 ++++-----
tests/test_MeshFlatFaceBoundary.cpp | 28 ++++-----
tests/test_MeshFlatNodeBoundary.cpp | 36 +++++------
tests/test_MeshLineEdgeBoundary.cpp | 24 ++++----
tests/test_MeshLineFaceBoundary.cpp | 12 ++--
tests/test_MeshLineNodeBoundary.cpp | 24 ++++----
tests/test_MeshNodeBoundary.cpp | 24 ++++----
tests/test_MeshNodeInterface.cpp | 24 ++++----
tests/test_ParallelChecker_read.cpp | 46 +++++++--------
tests/test_ParallelChecker_write.cpp | 26 ++++----
...malToDiamondDualConnectivityDataMapper.cpp | 12 ++--
...t_PrimalToDual1DConnectivityDataMapper.cpp | 4 +-
...imalToMedianDualConnectivityDataMapper.cpp | 8 +--
tests/test_SubItemArrayPerItem.cpp | 22 +++----
tests/test_SubItemArrayPerItemUtils.cpp | 28 ++++-----
tests/test_SubItemArrayPerItemVariant.cpp | 4 +-
tests/test_SubItemValuePerItem.cpp | 26 ++++----
tests/test_SubItemValuePerItemUtils.cpp | 26 ++++----
tests/test_SubItemValuePerItemVariant.cpp | 4 +-
tests/test_Synchronizer.cpp | 32 ++++------
105 files changed, 741 insertions(+), 844 deletions(-)
diff --git a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
index eb7cebd57..b53e19ac6 100644
--- a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
+++ b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
@@ -509,7 +509,7 @@ sum_of_Vh_components(const std::shared_ptr<const DiscreteFunctionVariant>& f)
template <size_t Dimension>
void
vectorize_to(const std::vector<std::shared_ptr<const DiscreteFunctionVariant>>& discrete_function_list,
- const Mesh<Connectivity<Dimension>>& mesh,
+ const Mesh<Dimension>& mesh,
DiscreteFunctionP0Vector<Dimension, double>& discrete_vector_function)
{
if (hasSameMesh(discrete_function_list)) {
diff --git a/src/mesh/CartesianMeshBuilder.cpp b/src/mesh/CartesianMeshBuilder.cpp
index 7b98ea861..4ae7410ce 100644
--- a/src/mesh/CartesianMeshBuilder.cpp
+++ b/src/mesh/CartesianMeshBuilder.cpp
@@ -117,7 +117,7 @@ CartesianMeshBuilder::_buildCartesianMesh(const TinyVector<Dimension>& a,
NodeValue<TinyVector<Dimension>> xr = _getNodeCoordinates(a, b, cell_size, connectivity);
- m_mesh = std::make_shared<MeshVariant>(std::make_shared<const Mesh<ConnectivityType>>(p_connectivity, xr));
+ m_mesh = std::make_shared<MeshVariant>(std::make_shared<const Mesh<Dimension>>(p_connectivity, xr));
}
template <size_t Dimension>
diff --git a/src/mesh/Dual1DMeshBuilder.cpp b/src/mesh/Dual1DMeshBuilder.cpp
index c2d0f6342..495bbbe86 100644
--- a/src/mesh/Dual1DMeshBuilder.cpp
+++ b/src/mesh/Dual1DMeshBuilder.cpp
@@ -1,6 +1,5 @@
#include <mesh/Dual1DMeshBuilder.hpp>
-#include <mesh/Connectivity.hpp>
#include <mesh/DualConnectivityManager.hpp>
#include <mesh/ItemValueUtils.hpp>
#include <mesh/Mesh.hpp>
@@ -39,11 +38,11 @@ Dual1DMeshBuilder::_buildDual1DMeshFrom(const MeshType& primal_mesh)
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<MeshVariant>(std::make_shared<const Mesh<Connectivity<1>>>(p_dual_connectivity, dual_xr));
+ m_mesh = std::make_shared<MeshVariant>(std::make_shared<const Mesh<1>>(p_dual_connectivity, dual_xr));
}
Dual1DMeshBuilder::Dual1DMeshBuilder(const std::shared_ptr<const MeshVariant>& mesh_v)
{
std::cout << "building Dual1DMesh\n";
- this->_buildDual1DMeshFrom(*(mesh_v->get<Mesh<Connectivity<1>>>()));
+ this->_buildDual1DMeshFrom(*(mesh_v->get<Mesh<1>>()));
}
diff --git a/src/mesh/DualMeshManager.hpp b/src/mesh/DualMeshManager.hpp
index 040dfd8d6..46ad9c9f8 100644
--- a/src/mesh/DualMeshManager.hpp
+++ b/src/mesh/DualMeshManager.hpp
@@ -10,12 +10,6 @@
class MeshVariant;
-template <size_t Dimension>
-class Connectivity;
-
-template <typename ConnectivityType>
-class Mesh;
-
class DualMeshManager
{
private:
diff --git a/src/mesh/GmshReader.cpp b/src/mesh/GmshReader.cpp
index b8ddd2910..50ecb1af1 100644
--- a/src/mesh/GmshReader.cpp
+++ b/src/mesh/GmshReader.cpp
@@ -1502,7 +1502,7 @@ GmshReader::__proceedData()
std::dynamic_pointer_cast<const Connectivity3D>(connectivity_builder.connectivity());
const Connectivity3D& connectivity = *p_connectivity;
- using MeshType = Mesh<Connectivity3D>;
+ using MeshType = Mesh<3>;
using Rd = TinyVector<3, double>;
NodeValue<Rd> xr(connectivity);
@@ -1523,7 +1523,7 @@ GmshReader::__proceedData()
std::dynamic_pointer_cast<const Connectivity2D>(connectivity_builder.connectivity());
const Connectivity2D& connectivity = *p_connectivity;
- using MeshType = Mesh<Connectivity2D>;
+ using MeshType = Mesh<2>;
using Rd = TinyVector<2, double>;
NodeValue<Rd> xr(connectivity);
@@ -1543,7 +1543,7 @@ GmshReader::__proceedData()
std::dynamic_pointer_cast<const Connectivity1D>(connectivity_builder.connectivity());
const Connectivity1D& connectivity = *p_connectivity;
- using MeshType = Mesh<Connectivity1D>;
+ using MeshType = Mesh<1>;
using Rd = TinyVector<1, double>;
NodeValue<Rd> xr(connectivity);
diff --git a/src/mesh/Mesh.cpp b/src/mesh/Mesh.cpp
index b622bfb97..baa0d00d7 100644
--- a/src/mesh/Mesh.cpp
+++ b/src/mesh/Mesh.cpp
@@ -4,13 +4,13 @@
#include <mesh/DualMeshManager.hpp>
#include <mesh/MeshDataManager.hpp>
-template <typename ConnectivityType>
-Mesh<ConnectivityType>::~Mesh()
+template <size_t Dimension>
+Mesh<Dimension>::~Mesh()
{
MeshDataManager::instance().deleteMeshData(this->id());
DualMeshManager::instance().deleteMesh(this->id());
}
-template Mesh<Connectivity<1>>::~Mesh();
-template Mesh<Connectivity<2>>::~Mesh();
-template Mesh<Connectivity<3>>::~Mesh();
+template Mesh<1>::~Mesh();
+template Mesh<2>::~Mesh();
+template Mesh<3>::~Mesh();
diff --git a/src/mesh/Mesh.hpp b/src/mesh/Mesh.hpp
index 451d53a31..f260dd1fc 100644
--- a/src/mesh/Mesh.hpp
+++ b/src/mesh/Mesh.hpp
@@ -2,20 +2,21 @@
#define MESH_HPP
#include <algebra/TinyVector.hpp>
+#include <mesh/Connectivity.hpp>
#include <mesh/ItemValue.hpp>
#include <mesh/MeshVariant.hpp>
#include <utils/GlobalVariableManager.hpp>
#include <memory>
-template <typename ConnectivityType>
-class Mesh : public std::enable_shared_from_this<Mesh<ConnectivityType>>
+template <size_t MeshDimension>
+class Mesh : public std::enable_shared_from_this<Mesh<MeshDimension>>
{
public:
- using Connectivity = ConnectivityType;
+ static constexpr size_t Dimension = MeshDimension;
+ using Connectivity = Connectivity<Dimension>;
- static constexpr size_t Dimension = ConnectivityType::Dimension;
- using Rd = TinyVector<Dimension>;
+ using Rd = TinyVector<Dimension>;
private:
const size_t m_id;
@@ -44,7 +45,7 @@ class Mesh : public std::enable_shared_from_this<Mesh<ConnectivityType>>
}
PUGS_INLINE
- std::shared_ptr<const Mesh<ConnectivityType>>
+ std::shared_ptr<const Mesh<Dimension>>
shared_ptr() const
{
return this->shared_from_this();
diff --git a/src/mesh/MeshBuilderBase.cpp b/src/mesh/MeshBuilderBase.cpp
index 6787e4bdc..4537f83b2 100644
--- a/src/mesh/MeshBuilderBase.cpp
+++ b/src/mesh/MeshBuilderBase.cpp
@@ -23,7 +23,7 @@ MeshBuilderBase::_dispatch()
using ConnectivityType = Connectivity<Dimension>;
using Rd = TinyVector<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
if (not m_mesh) {
ConnectivityDescriptor descriptor;
@@ -49,8 +49,8 @@ template <size_t Dimension>
void
MeshBuilderBase::_checkMesh() const
{
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
if (not m_mesh) {
throw UnexpectedError("mesh is not built yet");
diff --git a/src/mesh/MeshCellZone.cpp b/src/mesh/MeshCellZone.cpp
index ac63998b6..08bdf64ba 100644
--- a/src/mesh/MeshCellZone.cpp
+++ b/src/mesh/MeshCellZone.cpp
@@ -5,13 +5,13 @@
#include <utils/Messenger.hpp>
template <size_t Dimension>
-MeshCellZone<Dimension>::MeshCellZone(const Mesh<Connectivity<Dimension>>&, const RefCellList& ref_cell_list)
+MeshCellZone<Dimension>::MeshCellZone(const Mesh<Dimension>&, const RefCellList& ref_cell_list)
: m_cell_list(ref_cell_list.list()), m_zone_name(ref_cell_list.refId().tagName())
{}
template <size_t Dimension>
MeshCellZone<Dimension>
-getMeshCellZone(const Mesh<Connectivity<Dimension>>& mesh, const IZoneDescriptor& zone_descriptor)
+getMeshCellZone(const Mesh<Dimension>& mesh, const IZoneDescriptor& zone_descriptor)
{
for (size_t i_ref_cell_list = 0; i_ref_cell_list < mesh.connectivity().template numberOfRefItemList<ItemType::cell>();
++i_ref_cell_list) {
@@ -28,6 +28,6 @@ getMeshCellZone(const Mesh<Connectivity<Dimension>>& mesh, const IZoneDescriptor
throw NormalError(ost.str());
}
-template MeshCellZone<1> getMeshCellZone(const Mesh<Connectivity<1>>&, const IZoneDescriptor&);
-template MeshCellZone<2> getMeshCellZone(const Mesh<Connectivity<2>>&, const IZoneDescriptor&);
-template MeshCellZone<3> getMeshCellZone(const Mesh<Connectivity<3>>&, const IZoneDescriptor&);
+template MeshCellZone<1> getMeshCellZone(const Mesh<1>&, const IZoneDescriptor&);
+template MeshCellZone<2> getMeshCellZone(const Mesh<2>&, const IZoneDescriptor&);
+template MeshCellZone<3> getMeshCellZone(const Mesh<3>&, const IZoneDescriptor&);
diff --git a/src/mesh/MeshCellZone.hpp b/src/mesh/MeshCellZone.hpp
index de4903689..1f8827b1b 100644
--- a/src/mesh/MeshCellZone.hpp
+++ b/src/mesh/MeshCellZone.hpp
@@ -6,9 +6,6 @@
#include <utils/Array.hpp>
template <size_t Dimension>
-class Connectivity;
-
-template <typename ConnectivityType>
class Mesh;
template <size_t Dimension>
@@ -20,30 +17,30 @@ class [[nodiscard]] MeshCellZone // clazy:exclude=copyable-polymorphic
public:
template <size_t MeshDimension>
- friend MeshCellZone<MeshDimension> getMeshCellZone(const Mesh<Connectivity<MeshDimension>>& mesh,
+ friend MeshCellZone<MeshDimension> getMeshCellZone(const Mesh<MeshDimension>& mesh,
const IZoneDescriptor& zone_descriptor);
MeshCellZone& operator=(const MeshCellZone&) = default;
- MeshCellZone& operator=(MeshCellZone&&) = default;
+ MeshCellZone& operator=(MeshCellZone&&) = default;
- const Array<const CellId>& cellList() const
+ const Array<const CellId>&
+ cellList() const
{
return m_cell_list;
}
protected:
- MeshCellZone(const Mesh<Connectivity<Dimension>>& mesh, const RefCellList& ref_cell_list);
+ MeshCellZone(const Mesh<Dimension>& mesh, const RefCellList& ref_cell_list);
public:
MeshCellZone(const MeshCellZone&) = default;
- MeshCellZone(MeshCellZone &&) = default;
+ MeshCellZone(MeshCellZone&&) = default;
MeshCellZone() = default;
virtual ~MeshCellZone() = default;
};
template <size_t Dimension>
-MeshCellZone<Dimension> getMeshCellZone(const Mesh<Connectivity<Dimension>>& mesh,
- const IZoneDescriptor& zone_descriptor);
+MeshCellZone<Dimension> getMeshCellZone(const Mesh<Dimension>& mesh, const IZoneDescriptor& zone_descriptor);
#endif // MESH_CELL_ZONE_HPP
diff --git a/src/mesh/MeshData.hpp b/src/mesh/MeshData.hpp
index 78b9b81e6..a198aab45 100644
--- a/src/mesh/MeshData.hpp
+++ b/src/mesh/MeshData.hpp
@@ -9,9 +9,6 @@
#include <utils/PugsUtils.hpp>
template <size_t Dimension>
-class Connectivity;
-
-template <typename ConnectivityType>
class Mesh;
template <size_t Dimension>
@@ -21,7 +18,7 @@ class MeshData : public IMeshData
static_assert(Dimension > 0, "dimension must be strictly positive");
static_assert((Dimension <= 3), "only 1d, 2d and 3d are implemented");
- using MeshType = Mesh<Connectivity<Dimension>>;
+ using MeshType = Mesh<Dimension>;
using Rd = TinyVector<Dimension>;
diff --git a/src/mesh/MeshDataManager.cpp b/src/mesh/MeshDataManager.cpp
index def1d1b61..3607fcad6 100644
--- a/src/mesh/MeshDataManager.cpp
+++ b/src/mesh/MeshDataManager.cpp
@@ -42,7 +42,7 @@ MeshDataManager::deleteMeshData(const size_t mesh_id)
template <size_t Dimension>
MeshData<Dimension>&
-MeshDataManager::getMeshData(const Mesh<Connectivity<Dimension>>& mesh)
+MeshDataManager::getMeshData(const Mesh<Dimension>& mesh)
{
if (auto i_mesh_data = m_mesh_id_mesh_data_map.find(mesh.id()); i_mesh_data != m_mesh_id_mesh_data_map.end()) {
return dynamic_cast<MeshData<Dimension>&>(*i_mesh_data->second);
@@ -55,6 +55,6 @@ MeshDataManager::getMeshData(const Mesh<Connectivity<Dimension>>& mesh)
}
}
-template MeshData<1>& MeshDataManager::getMeshData(const Mesh<Connectivity<1>>&);
-template MeshData<2>& MeshDataManager::getMeshData(const Mesh<Connectivity<2>>&);
-template MeshData<3>& MeshDataManager::getMeshData(const Mesh<Connectivity<3>>&);
+template MeshData<1>& MeshDataManager::getMeshData(const Mesh<1>&);
+template MeshData<2>& MeshDataManager::getMeshData(const Mesh<2>&);
+template MeshData<3>& MeshDataManager::getMeshData(const Mesh<3>&);
diff --git a/src/mesh/MeshDataManager.hpp b/src/mesh/MeshDataManager.hpp
index 8b1672b52..0d2bf964b 100644
--- a/src/mesh/MeshDataManager.hpp
+++ b/src/mesh/MeshDataManager.hpp
@@ -8,10 +8,7 @@
#include <memory>
#include <unordered_map>
-template <size_t>
-class Connectivity;
-
-template <typename ConnectivityType>
+template <size_t Dimension>
class Mesh;
template <size_t Dimension>
@@ -45,7 +42,7 @@ class MeshDataManager
void deleteMeshData(const size_t mesh_id);
template <size_t Dimension>
- MeshData<Dimension>& getMeshData(const Mesh<Connectivity<Dimension>>&);
+ MeshData<Dimension>& getMeshData(const Mesh<Dimension>&);
};
#endif // MESH_DATA_MANAGER_HPP
diff --git a/src/mesh/MeshEdgeBoundary.cpp b/src/mesh/MeshEdgeBoundary.cpp
index 0a4aed04b..0ad15dbad 100644
--- a/src/mesh/MeshEdgeBoundary.cpp
+++ b/src/mesh/MeshEdgeBoundary.cpp
@@ -9,9 +9,9 @@ template <typename MeshType>
MeshEdgeBoundary::MeshEdgeBoundary(const MeshType&, const RefEdgeList& ref_edge_list) : m_ref_edge_list(ref_edge_list)
{}
-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 MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<1>&, const RefEdgeList&);
+template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<2>&, const RefEdgeList&);
+template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<3>&, const RefEdgeList&);
template <typename MeshType>
MeshEdgeBoundary::MeshEdgeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list)
@@ -55,8 +55,8 @@ MeshEdgeBoundary::MeshEdgeBoundary(const MeshType& mesh, const RefFaceList& ref_
const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_edge_list);
}
-template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<2>&, const RefFaceList&);
+template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<3>&, const RefFaceList&);
template <typename MeshType>
MeshEdgeBoundary
@@ -107,6 +107,6 @@ getMeshEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_de
throw NormalError(ost.str());
}
-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&);
+template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<1>&, const IBoundaryDescriptor&);
+template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshEdgeInterface.cpp b/src/mesh/MeshEdgeInterface.cpp
index da4d0bc9f..55235d8c7 100644
--- a/src/mesh/MeshEdgeInterface.cpp
+++ b/src/mesh/MeshEdgeInterface.cpp
@@ -5,19 +5,19 @@
#include <mesh/Mesh.hpp>
#include <utils/Messenger.hpp>
-template <size_t Dimension>
-MeshEdgeInterface<Dimension>::MeshEdgeInterface(const Mesh<Connectivity<Dimension>>&, const RefEdgeList& ref_edge_list)
- : m_ref_edge_list(ref_edge_list)
+template <typename MeshType>
+MeshEdgeInterface::MeshEdgeInterface(const MeshType&, const RefEdgeList& ref_edge_list) : m_ref_edge_list(ref_edge_list)
{}
-template MeshEdgeInterface<1>::MeshEdgeInterface(const Mesh<Connectivity<1>>&, const RefEdgeList&);
-template MeshEdgeInterface<2>::MeshEdgeInterface(const Mesh<Connectivity<2>>&, const RefEdgeList&);
-template MeshEdgeInterface<3>::MeshEdgeInterface(const Mesh<Connectivity<3>>&, const RefEdgeList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<1>&, const RefEdgeList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<2>&, const RefEdgeList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<3>&, const RefEdgeList&);
-template <size_t Dimension>
-MeshEdgeInterface<Dimension>::MeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh,
- const RefFaceList& ref_face_list)
+template <typename MeshType>
+MeshEdgeInterface::MeshEdgeInterface(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 @@ MeshEdgeInterface<Dimension>::MeshEdgeInterface(const Mesh<Connectivity<Dimensio
const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_edge_list);
}
-template MeshEdgeInterface<2>::MeshEdgeInterface(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshEdgeInterface<3>::MeshEdgeInterface(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<2>&, const RefFaceList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<3>&, const RefFaceList&);
-template <size_t Dimension>
-MeshEdgeInterface<Dimension>
-getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterfaceDescriptor& interface_descriptor)
+template <typename MeshType>
+MeshEdgeInterface
+getMeshEdgeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_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 @@ getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
throw NormalError(ost.str());
}
- return MeshEdgeInterface<Dimension>{mesh, ref_edge_list};
+ return MeshEdgeInterface{mesh, ref_edge_list};
}
}
if constexpr (Dimension > 1) {
@@ -95,7 +97,7 @@ getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
throw NormalError(ost.str());
}
- return MeshEdgeInterface<Dimension>{mesh, ref_face_list};
+ return MeshEdgeInterface{mesh, ref_face_list};
}
}
}
@@ -106,6 +108,6 @@ getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
throw NormalError(ost.str());
}
-template MeshEdgeInterface<1> getMeshEdgeInterface(const Mesh<Connectivity<1>>&, const IInterfaceDescriptor&);
-template MeshEdgeInterface<2> getMeshEdgeInterface(const Mesh<Connectivity<2>>&, const IInterfaceDescriptor&);
-template MeshEdgeInterface<3> getMeshEdgeInterface(const Mesh<Connectivity<3>>&, const IInterfaceDescriptor&);
+template MeshEdgeInterface getMeshEdgeInterface(const Mesh<1>&, const IInterfaceDescriptor&);
+template MeshEdgeInterface getMeshEdgeInterface(const Mesh<2>&, const IInterfaceDescriptor&);
+template MeshEdgeInterface getMeshEdgeInterface(const Mesh<3>&, const IInterfaceDescriptor&);
diff --git a/src/mesh/MeshEdgeInterface.hpp b/src/mesh/MeshEdgeInterface.hpp
index 25226264c..45bcdbe84 100644
--- a/src/mesh/MeshEdgeInterface.hpp
+++ b/src/mesh/MeshEdgeInterface.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]] MeshEdgeInterface // clazy:exclude=copyable-polymorphic
{
protected:
RefEdgeList m_ref_edge_list;
public:
- template <size_t MeshDimension>
- friend MeshEdgeInterface<MeshDimension> getMeshEdgeInterface(const Mesh<Connectivity<MeshDimension>>& mesh,
- const IInterfaceDescriptor& interface_descriptor);
+ template <typename MeshType>
+ friend MeshEdgeInterface getMeshEdgeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
MeshEdgeInterface& operator=(const MeshEdgeInterface&) = default;
- MeshEdgeInterface& operator=(MeshEdgeInterface&&) = default;
+ MeshEdgeInterface& operator=(MeshEdgeInterface&&) = 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:
- MeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefEdgeList& ref_edge_list);
- MeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list);
+ template <typename MeshType>
+ MeshEdgeInterface(const MeshType& mesh, const RefEdgeList& ref_edge_list);
+ template <typename MeshType>
+ MeshEdgeInterface(const MeshType& mesh, const RefFaceList& ref_face_list);
public:
MeshEdgeInterface(const MeshEdgeInterface&) = default; // LCOV_EXCL_LINE
- MeshEdgeInterface(MeshEdgeInterface &&) = default; // LCOV_EXCL_LINE
+ MeshEdgeInterface(MeshEdgeInterface&&) = default; // LCOV_EXCL_LINE
MeshEdgeInterface() = default;
virtual ~MeshEdgeInterface() = default;
};
-template <size_t Dimension>
-MeshEdgeInterface<Dimension> getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh,
- const IInterfaceDescriptor& interface_descriptor);
+template <typename MeshType>
+MeshEdgeInterface getMeshEdgeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
#endif // MESH_EDGE_INTERFACE_HPP
diff --git a/src/mesh/MeshFaceBoundary.cpp b/src/mesh/MeshFaceBoundary.cpp
index 3a578bb78..d883ba63a 100644
--- a/src/mesh/MeshFaceBoundary.cpp
+++ b/src/mesh/MeshFaceBoundary.cpp
@@ -8,9 +8,9 @@ template <typename MeshType>
MeshFaceBoundary::MeshFaceBoundary(const MeshType&, const RefFaceList& ref_face_list) : m_ref_face_list(ref_face_list)
{}
-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 MeshFaceBoundary::MeshFaceBoundary(const Mesh<1>&, const RefFaceList&);
+template MeshFaceBoundary::MeshFaceBoundary(const Mesh<2>&, const RefFaceList&);
+template MeshFaceBoundary::MeshFaceBoundary(const Mesh<3>&, const RefFaceList&);
template <typename MeshType>
MeshFaceBoundary
@@ -40,6 +40,6 @@ getMeshFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_de
throw NormalError(ost.str());
}
-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&);
+template MeshFaceBoundary getMeshFaceBoundary(const Mesh<1>&, const IBoundaryDescriptor&);
+template MeshFaceBoundary getMeshFaceBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshFaceBoundary getMeshFaceBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshFaceInterface.cpp b/src/mesh/MeshFaceInterface.cpp
index afb73bf18..663ac8d44 100644
--- a/src/mesh/MeshFaceInterface.cpp
+++ b/src/mesh/MeshFaceInterface.cpp
@@ -4,18 +4,17 @@
#include <mesh/Mesh.hpp>
#include <utils/Messenger.hpp>
-template <size_t Dimension>
-MeshFaceInterface<Dimension>::MeshFaceInterface(const Mesh<Connectivity<Dimension>>&, const RefFaceList& ref_face_list)
- : m_ref_face_list(ref_face_list)
+template <typename MeshType>
+MeshFaceInterface::MeshFaceInterface(const MeshType&, const RefFaceList& ref_face_list) : m_ref_face_list(ref_face_list)
{}
-template MeshFaceInterface<1>::MeshFaceInterface(const Mesh<Connectivity<1>>&, const RefFaceList&);
-template MeshFaceInterface<2>::MeshFaceInterface(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshFaceInterface<3>::MeshFaceInterface(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshFaceInterface::MeshFaceInterface(const Mesh<1>&, const RefFaceList&);
+template MeshFaceInterface::MeshFaceInterface(const Mesh<2>&, const RefFaceList&);
+template MeshFaceInterface::MeshFaceInterface(const Mesh<3>&, const RefFaceList&);
-template <size_t Dimension>
-MeshFaceInterface<Dimension>
-getMeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterfaceDescriptor& interface_descriptor)
+template <typename MeshType>
+MeshFaceInterface
+getMeshFaceInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor)
{
for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>();
++i_ref_face_list) {
@@ -30,7 +29,7 @@ getMeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
throw NormalError(ost.str());
}
- return MeshFaceInterface<Dimension>{mesh, ref_face_list};
+ return MeshFaceInterface{mesh, ref_face_list};
}
}
@@ -40,6 +39,6 @@ getMeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
throw NormalError(ost.str());
}
-template MeshFaceInterface<1> getMeshFaceInterface(const Mesh<Connectivity<1>>&, const IInterfaceDescriptor&);
-template MeshFaceInterface<2> getMeshFaceInterface(const Mesh<Connectivity<2>>&, const IInterfaceDescriptor&);
-template MeshFaceInterface<3> getMeshFaceInterface(const Mesh<Connectivity<3>>&, const IInterfaceDescriptor&);
+template MeshFaceInterface getMeshFaceInterface(const Mesh<1>&, const IInterfaceDescriptor&);
+template MeshFaceInterface getMeshFaceInterface(const Mesh<2>&, const IInterfaceDescriptor&);
+template MeshFaceInterface getMeshFaceInterface(const Mesh<3>&, const IInterfaceDescriptor&);
diff --git a/src/mesh/MeshFaceInterface.hpp b/src/mesh/MeshFaceInterface.hpp
index 87d836a37..0d8277e0b 100644
--- a/src/mesh/MeshFaceInterface.hpp
+++ b/src/mesh/MeshFaceInterface.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]] MeshFaceInterface // clazy:exclude=copyable-polymorphic
{
protected:
RefFaceList m_ref_face_list;
public:
- template <size_t MeshDimension>
- friend MeshFaceInterface<MeshDimension> getMeshFaceInterface(const Mesh<Connectivity<MeshDimension>>& mesh,
- const IInterfaceDescriptor& interface_descriptor);
+ template <typename MeshType>
+ friend MeshFaceInterface getMeshFaceInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
MeshFaceInterface& operator=(const MeshFaceInterface&) = default;
- MeshFaceInterface& operator=(MeshFaceInterface&&) = default;
+ MeshFaceInterface& operator=(MeshFaceInterface&&) = 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:
- MeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list);
+ template <typename MeshType>
+ MeshFaceInterface(const MeshType& mesh, const RefFaceList& ref_face_list);
public:
MeshFaceInterface(const MeshFaceInterface&) = default; // LCOV_EXCL_LINE
- MeshFaceInterface(MeshFaceInterface &&) = default; // LCOV_EXCL_LINE
+ MeshFaceInterface(MeshFaceInterface&&) = default; // LCOV_EXCL_LINE
MeshFaceInterface() = default;
virtual ~MeshFaceInterface() = default;
};
-template <size_t Dimension>
-MeshFaceInterface<Dimension> getMeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh,
- const IInterfaceDescriptor& interface_descriptor);
+template <typename MeshType>
+MeshFaceInterface getMeshFaceInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
#endif // MESH_FACE_INTERFACE_HPP
diff --git a/src/mesh/MeshFlatEdgeBoundary.cpp b/src/mesh/MeshFlatEdgeBoundary.cpp
index 3783049ff..8b5669a34 100644
--- a/src/mesh/MeshFlatEdgeBoundary.cpp
+++ b/src/mesh/MeshFlatEdgeBoundary.cpp
@@ -15,9 +15,6 @@ getMeshFlatEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
mesh_flat_node_boundary.outgoingNormal()};
}
-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&);
+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&);
diff --git a/src/mesh/MeshFlatFaceBoundary.cpp b/src/mesh/MeshFlatFaceBoundary.cpp
index e05373897..12d7f439f 100644
--- a/src/mesh/MeshFlatFaceBoundary.cpp
+++ b/src/mesh/MeshFlatFaceBoundary.cpp
@@ -15,9 +15,6 @@ getMeshFlatFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
mesh_flat_node_boundary.outgoingNormal()};
}
-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&);
+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&);
diff --git a/src/mesh/MeshFlatNodeBoundary.cpp b/src/mesh/MeshFlatNodeBoundary.cpp
index 3ee564332..df7631988 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<Connectivity<1>>>::_getNormal(const Mesh<Connectivity<1>>& mesh)
+MeshFlatNodeBoundary<const Mesh<1>>::_getNormal(const Mesh<1>& mesh)
{
using R = TinyVector<1, double>;
@@ -60,7 +60,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<1>>>::_getNormal(const Mesh<Connect
template <>
TinyVector<2, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getNormal(const Mesh<Connectivity<2>>& mesh)
+MeshFlatNodeBoundary<const Mesh<2>>::_getNormal(const Mesh<2>& mesh)
{
using R2 = TinyVector<2, double>;
@@ -88,9 +88,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getNormal(const Mesh<Connect
template <>
TinyVector<3, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getFarestNode(const Mesh<Connectivity<3>>& mesh,
- const Rd& x0,
- const Rd& x1)
+MeshFlatNodeBoundary<const 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();
@@ -141,7 +139,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getFarestNode(const Mesh<Con
template <>
TinyVector<3, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getNormal(const Mesh<Connectivity<3>>& mesh)
+MeshFlatNodeBoundary<const Mesh<3>>::_getNormal(const Mesh<3>& mesh)
{
using R3 = TinyVector<3, double>;
@@ -198,7 +196,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getNormal(const Mesh<Connect
template <>
TinyVector<1, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<1>>>::_getOutgoingNormal(const Mesh<Connectivity<1>>& mesh)
+MeshFlatNodeBoundary<const Mesh<1>>::_getOutgoingNormal(const Mesh<1>& mesh)
{
using R = TinyVector<1, double>;
@@ -241,7 +239,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<1>>>::_getOutgoingNormal(const Mesh
template <>
TinyVector<2, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getOutgoingNormal(const Mesh<Connectivity<2>>& mesh)
+MeshFlatNodeBoundary<const Mesh<2>>::_getOutgoingNormal(const Mesh<2>& mesh)
{
using R2 = TinyVector<2, double>;
@@ -284,7 +282,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getOutgoingNormal(const Mesh
template <>
TinyVector<3, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getOutgoingNormal(const Mesh<Connectivity<3>>& mesh)
+MeshFlatNodeBoundary<const Mesh<3>>::_getOutgoingNormal(const Mesh<3>& mesh)
{
using R3 = TinyVector<3, double>;
@@ -352,9 +350,6 @@ getMeshFlatNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
throw NormalError(ost.str());
}
-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&);
+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&);
diff --git a/src/mesh/MeshLineEdgeBoundary.cpp b/src/mesh/MeshLineEdgeBoundary.cpp
index 31c4bb524..1d0c37526 100644
--- a/src/mesh/MeshLineEdgeBoundary.cpp
+++ b/src/mesh/MeshLineEdgeBoundary.cpp
@@ -16,7 +16,5 @@ getMeshLineEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
mesh_line_node_boundary.direction()};
}
-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&);
+template MeshLineEdgeBoundary<const Mesh<2>> getMeshLineEdgeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshLineEdgeBoundary<const Mesh<3>> getMeshLineEdgeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshLineFaceBoundary.cpp b/src/mesh/MeshLineFaceBoundary.cpp
index e81aef554..83bfdf8cf 100644
--- a/src/mesh/MeshLineFaceBoundary.cpp
+++ b/src/mesh/MeshLineFaceBoundary.cpp
@@ -16,5 +16,4 @@ getMeshLineFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
mesh_line_node_boundary.direction()};
}
-template MeshLineFaceBoundary<const Mesh<Connectivity<2>>> getMeshLineFaceBoundary(const Mesh<Connectivity<2>>&,
- const IBoundaryDescriptor&);
+template MeshLineFaceBoundary<const Mesh<2>> getMeshLineFaceBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshLineNodeBoundary.cpp b/src/mesh/MeshLineNodeBoundary.cpp
index a03c6102b..dd145d889 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<Connectivity<2>>>::_getDirection(const Mesh<Connectivity<2>>& mesh)
+MeshLineNodeBoundary<const Mesh<2>>::_getDirection(const Mesh<2>& mesh)
{
using R2 = TinyVector<2, double>;
@@ -65,7 +65,7 @@ MeshLineNodeBoundary<const Mesh<Connectivity<2>>>::_getDirection(const Mesh<Conn
template <>
TinyVector<3>
-MeshLineNodeBoundary<const Mesh<Connectivity<3>>>::_getDirection(const Mesh<Connectivity<3>>& mesh)
+MeshLineNodeBoundary<const Mesh<3>>::_getDirection(const Mesh<3>& mesh)
{
using R3 = TinyVector<3, double>;
@@ -140,7 +140,5 @@ getMeshLineNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
throw NormalError(ost.str());
}
-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&);
+template MeshLineNodeBoundary<const Mesh<2>> getMeshLineNodeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshLineNodeBoundary<const Mesh<3>> getMeshLineNodeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshNodeBoundary.cpp b/src/mesh/MeshNodeBoundary.cpp
index 97f32e9d4..e750580ce 100644
--- a/src/mesh/MeshNodeBoundary.cpp
+++ b/src/mesh/MeshNodeBoundary.cpp
@@ -109,17 +109,17 @@ MeshNodeBoundary::MeshNodeBoundary(const MeshType&, const RefNodeList& ref_node_
}
}
-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::MeshNodeBoundary(const Mesh<1>&, const RefFaceList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<2>&, const RefFaceList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<3>&, const RefFaceList&);
-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::MeshNodeBoundary(const Mesh<1>&, const RefEdgeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<2>&, const RefEdgeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<3>&, const RefEdgeList&);
-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 MeshNodeBoundary::MeshNodeBoundary(const Mesh<1>&, const RefNodeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<2>&, const RefNodeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<3>&, const RefNodeList&);
template <typename MeshType>
MeshNodeBoundary
@@ -156,6 +156,6 @@ getMeshNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_de
throw NormalError(ost.str());
}
-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&);
+template MeshNodeBoundary getMeshNodeBoundary(const Mesh<1>&, const IBoundaryDescriptor&);
+template MeshNodeBoundary getMeshNodeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshNodeBoundary getMeshNodeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshNodeBoundaryUtils.cpp b/src/mesh/MeshNodeBoundaryUtils.cpp
index 63df3e364..d6a0e31cd 100644
--- a/src/mesh/MeshNodeBoundaryUtils.cpp
+++ b/src/mesh/MeshNodeBoundaryUtils.cpp
@@ -6,7 +6,7 @@
template <>
std::array<TinyVector<2>, 2>
-getBounds(const Mesh<Connectivity<2>>& mesh, const RefNodeList& ref_node_list)
+getBounds(const Mesh<2>& mesh, const RefNodeList& ref_node_list)
{
using R2 = TinyVector<2, double>;
@@ -54,7 +54,7 @@ getBounds(const Mesh<Connectivity<2>>& mesh, const RefNodeList& ref_node_list)
template <>
std::array<TinyVector<3>, 6>
-getBounds(const Mesh<Connectivity<3>>& mesh, const RefNodeList& ref_node_list)
+getBounds(const Mesh<3>& mesh, const RefNodeList& ref_node_list)
{
using R3 = TinyVector<3, double>;
diff --git a/src/mesh/MeshNodeInterface.cpp b/src/mesh/MeshNodeInterface.cpp
index 84a5b2669..1703f36a0 100644
--- a/src/mesh/MeshNodeInterface.cpp
+++ b/src/mesh/MeshNodeInterface.cpp
@@ -1,14 +1,16 @@
#include <mesh/MeshNodeInterface.hpp>
#include <Kokkos_Vector.hpp>
-#include <mesh/Connectivity.hpp>
#include <mesh/Mesh.hpp>
+#include <mesh/MeshTraits.hpp>
#include <utils/Messenger.hpp>
-template <size_t Dimension>
-MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh,
- const RefFaceList& ref_face_list)
+template <typename MeshType>
+MeshNodeInterface::MeshNodeInterface(const MeshType& mesh, const RefFaceList& ref_face_list)
{
+ static_assert(is_polygonal_mesh<MeshType>);
+ constexpr size_t Dimension = MeshType::Dimension;
+
const Array<const FaceId>& face_list = ref_face_list.list();
if (ref_face_list.type() != RefItemListBase::Type::interface) {
std::ostringstream ost;
@@ -51,10 +53,12 @@ MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimensio
const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_node_list);
}
-template <size_t Dimension>
-MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh,
- const RefEdgeList& ref_edge_list)
+template <typename MeshType>
+MeshNodeInterface::MeshNodeInterface(const MeshType& mesh, const RefEdgeList& ref_edge_list)
{
+ static_assert(is_polygonal_mesh<MeshType>);
+ constexpr size_t Dimension = MeshType::Dimension;
+
const Array<const EdgeId>& edge_list = ref_edge_list.list();
if (ref_edge_list.type() != RefItemListBase::Type::interface) {
std::ostringstream ost;
@@ -96,9 +100,8 @@ MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimensio
const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_node_list);
}
-template <size_t Dimension>
-MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimension>>&, const RefNodeList& ref_node_list)
- : m_ref_node_list(ref_node_list)
+template <typename MeshType>
+MeshNodeInterface::MeshNodeInterface(const MeshType&, const RefNodeList& ref_node_list) : m_ref_node_list(ref_node_list)
{
if (ref_node_list.type() != RefItemListBase::Type::interface) {
std::ostringstream ost;
@@ -108,28 +111,28 @@ MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimensio
}
}
-template MeshNodeInterface<1>::MeshNodeInterface(const Mesh<Connectivity<1>>&, const RefFaceList&);
-template MeshNodeInterface<2>::MeshNodeInterface(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshNodeInterface<3>::MeshNodeInterface(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<1>&, const RefFaceList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<2>&, const RefFaceList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<3>&, const RefFaceList&);
-template MeshNodeInterface<1>::MeshNodeInterface(const Mesh<Connectivity<1>>&, const RefEdgeList&);
-template MeshNodeInterface<2>::MeshNodeInterface(const Mesh<Connectivity<2>>&, const RefEdgeList&);
-template MeshNodeInterface<3>::MeshNodeInterface(const Mesh<Connectivity<3>>&, const RefEdgeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<1>&, const RefEdgeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<2>&, const RefEdgeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<3>&, const RefEdgeList&);
-template MeshNodeInterface<1>::MeshNodeInterface(const Mesh<Connectivity<1>>&, const RefNodeList&);
-template MeshNodeInterface<2>::MeshNodeInterface(const Mesh<Connectivity<2>>&, const RefNodeList&);
-template MeshNodeInterface<3>::MeshNodeInterface(const Mesh<Connectivity<3>>&, const RefNodeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<1>&, const RefNodeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<2>&, const RefNodeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<3>&, const RefNodeList&);
-template <size_t Dimension>
-MeshNodeInterface<Dimension>
-getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterfaceDescriptor& interface_descriptor)
+template <typename MeshType>
+MeshNodeInterface
+getMeshNodeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_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 == interface_descriptor) {
- return MeshNodeInterface<Dimension>{mesh, ref_node_list};
+ return MeshNodeInterface{mesh, ref_node_list};
}
}
for (size_t i_ref_edge_list = 0; i_ref_edge_list < mesh.connectivity().template numberOfRefItemList<ItemType::edge>();
@@ -137,7 +140,7 @@ getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
const auto& ref_edge_list = mesh.connectivity().template refItemList<ItemType::edge>(i_ref_edge_list);
const RefId& ref = ref_edge_list.refId();
if (ref == interface_descriptor) {
- return MeshNodeInterface<Dimension>{mesh, ref_edge_list};
+ return MeshNodeInterface{mesh, ref_edge_list};
}
}
for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>();
@@ -145,7 +148,7 @@ getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
const auto& ref_face_list = mesh.connectivity().template refItemList<ItemType::face>(i_ref_face_list);
const RefId& ref = ref_face_list.refId();
if (ref == interface_descriptor) {
- return MeshNodeInterface<Dimension>{mesh, ref_face_list};
+ return MeshNodeInterface{mesh, ref_face_list};
}
}
@@ -155,6 +158,6 @@ getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
throw NormalError(ost.str());
}
-template MeshNodeInterface<1> getMeshNodeInterface(const Mesh<Connectivity<1>>&, const IInterfaceDescriptor&);
-template MeshNodeInterface<2> getMeshNodeInterface(const Mesh<Connectivity<2>>&, const IInterfaceDescriptor&);
-template MeshNodeInterface<3> getMeshNodeInterface(const Mesh<Connectivity<3>>&, const IInterfaceDescriptor&);
+template MeshNodeInterface getMeshNodeInterface(const Mesh<1>&, const IInterfaceDescriptor&);
+template MeshNodeInterface getMeshNodeInterface(const Mesh<2>&, const IInterfaceDescriptor&);
+template MeshNodeInterface getMeshNodeInterface(const Mesh<3>&, const IInterfaceDescriptor&);
diff --git a/src/mesh/MeshNodeInterface.hpp b/src/mesh/MeshNodeInterface.hpp
index 8fcbb6704..4eaafd06b 100644
--- a/src/mesh/MeshNodeInterface.hpp
+++ b/src/mesh/MeshNodeInterface.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]] MeshNodeInterface // 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 MeshNodeInterface<MeshDimension> getMeshNodeInterface(const Mesh<Connectivity<MeshDimension>>& mesh,
- const IInterfaceDescriptor& interface_descriptor);
+ template <typename MeshType>
+ friend MeshNodeInterface getMeshNodeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
MeshNodeInterface& operator=(const MeshNodeInterface&) = default;
- MeshNodeInterface& operator=(MeshNodeInterface&&) = default;
+ MeshNodeInterface& operator=(MeshNodeInterface&&) = 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:
- MeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list);
- MeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefEdgeList& ref_edge_list);
- MeshNodeInterface(const Mesh<Connectivity<Dimension>>&, const RefNodeList& ref_node_list);
+ template <typename MeshType>
+ MeshNodeInterface(const MeshType& mesh, const RefFaceList& ref_face_list);
+ template <typename MeshType>
+ MeshNodeInterface(const MeshType& mesh, const RefEdgeList& ref_edge_list);
+ template <typename MeshType>
+ MeshNodeInterface(const MeshType&, const RefNodeList& ref_node_list);
public:
MeshNodeInterface(const MeshNodeInterface&) = default;
- MeshNodeInterface(MeshNodeInterface &&) = default;
+ MeshNodeInterface(MeshNodeInterface&&) = default;
MeshNodeInterface() = default;
virtual ~MeshNodeInterface() = default;
};
-template <size_t Dimension>
-MeshNodeInterface<Dimension> getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh,
- const IInterfaceDescriptor& interface_descriptor);
+template <typename MeshType>
+MeshNodeInterface getMeshNodeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
#endif // MESH_NODE_INTERFACE_HPP
diff --git a/src/mesh/MeshRandomizer.cpp b/src/mesh/MeshRandomizer.cpp
index 9a2a56d5a..a5b0e0351 100644
--- a/src/mesh/MeshRandomizer.cpp
+++ b/src/mesh/MeshRandomizer.cpp
@@ -306,7 +306,7 @@ class MeshRandomizerHandler::MeshRandomizer<MeshType>::AxisBoundaryCondition
};
template <>
-class MeshRandomizerHandler::MeshRandomizer<Mesh<Connectivity<1>>>::AxisBoundaryCondition
+class MeshRandomizerHandler::MeshRandomizer<Mesh<1>>::AxisBoundaryCondition
{
public:
AxisBoundaryCondition() = default;
diff --git a/src/mesh/MeshRelaxer.hpp b/src/mesh/MeshRelaxer.hpp
index deb9f8a4a..1e2b08206 100644
--- a/src/mesh/MeshRelaxer.hpp
+++ b/src/mesh/MeshRelaxer.hpp
@@ -3,9 +3,6 @@
class MeshVariant;
-template <typename ConnectivityType>
-class Mesh;
-
#include <memory>
class MeshRelaxer
diff --git a/src/mesh/MeshSmoother.cpp b/src/mesh/MeshSmoother.cpp
index d90b95a4d..5eee712d8 100644
--- a/src/mesh/MeshSmoother.cpp
+++ b/src/mesh/MeshSmoother.cpp
@@ -353,7 +353,7 @@ class MeshSmootherHandler::MeshSmoother<MeshType>::AxisBoundaryCondition
};
template <>
-class MeshSmootherHandler::MeshSmoother<Mesh<Connectivity<1>>>::AxisBoundaryCondition
+class MeshSmootherHandler::MeshSmoother<Mesh<1>>::AxisBoundaryCondition
{
public:
AxisBoundaryCondition() = default;
diff --git a/src/mesh/MeshTraits.hpp b/src/mesh/MeshTraits.hpp
index 62ea22825..bf1a8a8f9 100644
--- a/src/mesh/MeshTraits.hpp
+++ b/src/mesh/MeshTraits.hpp
@@ -3,19 +3,16 @@
#include <cstddef>
-template <size_t>
-class Connectivity;
-
-template <typename ConnectivityType>
+template <size_t Dimension>
class Mesh;
template <typename MeshType>
constexpr inline bool is_polygonal_mesh = false;
template <size_t Dimension>
-constexpr inline bool is_polygonal_mesh<Mesh<Connectivity<Dimension>>> = true;
+constexpr inline bool is_polygonal_mesh<Mesh<Dimension>> = true;
template <size_t Dimension>
-constexpr inline bool is_polygonal_mesh<const Mesh<Connectivity<Dimension>>> = true;
+constexpr inline bool is_polygonal_mesh<const Mesh<Dimension>> = true;
#endif // MESH_TRAITS_HPP
diff --git a/src/mesh/MeshVariant.hpp b/src/mesh/MeshVariant.hpp
index bcc57e4cb..53e432795 100644
--- a/src/mesh/MeshVariant.hpp
+++ b/src/mesh/MeshVariant.hpp
@@ -7,18 +7,15 @@
#include <memory>
#include <variant>
-template <size_t>
-class Connectivity;
-
-template <typename ConnectivityType>
+template <size_t Dimension>
class Mesh;
class MeshVariant
{
private:
- using Variant = std::variant<std::shared_ptr<const Mesh<Connectivity<1>>>,
- std::shared_ptr<const Mesh<Connectivity<2>>>,
- std::shared_ptr<const Mesh<Connectivity<3>>>>;
+ using Variant = std::variant<std::shared_ptr<const Mesh<1>>, //
+ std::shared_ptr<const Mesh<2>>, //
+ std::shared_ptr<const Mesh<3>>>;
Variant m_p_mesh;
diff --git a/src/scheme/AcousticSolver.cpp b/src/scheme/AcousticSolver.cpp
index e60372f0c..3cd71fe5d 100644
--- a/src/scheme/AcousticSolver.cpp
+++ b/src/scheme/AcousticSolver.cpp
@@ -26,7 +26,7 @@ template <size_t Dimension>
double
acoustic_dt(const DiscreteFunctionP0<Dimension, const double>& c)
{
- const Mesh<Connectivity<Dimension>>& mesh = dynamic_cast<const Mesh<Connectivity<Dimension>>&>(*c.mesh());
+ const Mesh<Dimension>& mesh = dynamic_cast<const Mesh<Dimension>&>(*c.mesh());
const auto Vj = MeshDataManager::instance().getMeshData(mesh).Vj();
const auto Sj = MeshDataManager::instance().getMeshData(mesh).sumOverRLjr();
@@ -205,7 +205,7 @@ class AcousticSolverHandler::AcousticSolver final : public AcousticSolverHandler
}
NodeValue<Rd>
- _computeBr(const Mesh<Connectivity<Dimension>>& mesh,
+ _computeBr(const Mesh<Dimension>& mesh,
const NodeValuePerCell<const Rdxd>& Ajr,
const DiscreteVectorFunction& u,
const DiscreteScalarFunction& p) const
@@ -735,7 +735,7 @@ class AcousticSolverHandler::AcousticSolver<MeshType>::PressureBoundaryCondition
};
template <>
-class AcousticSolverHandler::AcousticSolver<const Mesh<Connectivity<1>>>::PressureBoundaryCondition
+class AcousticSolverHandler::AcousticSolver<const Mesh<1>>::PressureBoundaryCondition
{
private:
const MeshNodeBoundary m_mesh_node_boundary;
@@ -794,7 +794,7 @@ class AcousticSolverHandler::AcousticSolver<MeshType>::ExternalFSIVelocityBounda
return m_value_list;
}
- ExternalFSIVelocityBoundaryCondition(const Mesh<Connectivity<Dimension>>& mesh,
+ ExternalFSIVelocityBoundaryCondition(const Mesh<Dimension>& mesh,
const MeshNodeBoundary& mesh_node_boundary,
const std::shared_ptr<const Socket>& socket)
: m_node_to_cell_matrix{mesh.connectivity().nodeToCellMatrix()},
diff --git a/src/scheme/DiscreteFunctionP0.hpp b/src/scheme/DiscreteFunctionP0.hpp
index 0e11b608a..9f7fc39c5 100644
--- a/src/scheme/DiscreteFunctionP0.hpp
+++ b/src/scheme/DiscreteFunctionP0.hpp
@@ -3,7 +3,6 @@
#include <language/utils/ASTNodeDataTypeTraits.hpp>
-#include <mesh/Connectivity.hpp>
#include <mesh/ItemValueUtils.hpp>
#include <mesh/Mesh.hpp>
#include <mesh/MeshData.hpp>
@@ -16,7 +15,7 @@ class DiscreteFunctionP0
{
public:
using data_type = DataType;
- using MeshType = Mesh<Connectivity<Dimension>>;
+ using MeshType = Mesh<Dimension>;
friend class DiscreteFunctionP0<Dimension, std::add_const_t<DataType>>;
friend class DiscreteFunctionP0<Dimension, std::remove_const_t<DataType>>;
@@ -714,8 +713,8 @@ class DiscreteFunctionP0
{
Assert(f.m_cell_values.isBuilt());
- const Mesh<Connectivity<Dimension>>& mesh = *f.m_mesh;
- CellValue<const double> cell_volume = MeshDataManager::instance().getMeshData(mesh).Vj();
+ const Mesh<Dimension>& mesh = *f.m_mesh;
+ CellValue<const double> cell_volume = MeshDataManager::instance().getMeshData(mesh).Vj();
CellValue<std::remove_const_t<DataType>> f_v{mesh.connectivity()};
parallel_for(
diff --git a/src/scheme/DiscreteFunctionP0Vector.hpp b/src/scheme/DiscreteFunctionP0Vector.hpp
index 7801626a4..ada6df3ad 100644
--- a/src/scheme/DiscreteFunctionP0Vector.hpp
+++ b/src/scheme/DiscreteFunctionP0Vector.hpp
@@ -2,7 +2,6 @@
#define DISCRETE_FUNCTION_P0_VECTOR_HPP
#include <algebra/Vector.hpp>
-#include <mesh/Connectivity.hpp>
#include <mesh/ItemArray.hpp>
#include <mesh/Mesh.hpp>
#include <mesh/MeshData.hpp>
@@ -16,7 +15,7 @@ class DiscreteFunctionP0Vector
{
public:
using data_type = DataType;
- using MeshType = Mesh<Connectivity<Dimension>>;
+ using MeshType = Mesh<Dimension>;
friend class DiscreteFunctionP0Vector<Dimension, std::add_const_t<DataType>>;
friend class DiscreteFunctionP0Vector<Dimension, std::remove_const_t<DataType>>;
diff --git a/src/scheme/FluxingAdvectionSolver.cpp b/src/scheme/FluxingAdvectionSolver.cpp
index 25d9cf3de..0ee4e25f5 100644
--- a/src/scheme/FluxingAdvectionSolver.cpp
+++ b/src/scheme/FluxingAdvectionSolver.cpp
@@ -96,7 +96,7 @@ class FluxingAdvectionSolver
_storeValueBCList(const size_t i_quantity,
const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_list)
{
- const Mesh<Connectivity<Dimension>>& mesh = *m_old_mesh;
+ const Mesh<Dimension>& mesh = *m_old_mesh;
for (auto& i_bc : bc_list) {
switch (i_bc->type()) {
@@ -139,7 +139,7 @@ class FluxingAdvectionSolver
_storeArrayBCList(const size_t i_quantity,
const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_list)
{
- const Mesh<Connectivity<Dimension>>& mesh = *m_old_mesh;
+ const Mesh<Dimension>& mesh = *m_old_mesh;
for (auto& i_bc : bc_list) {
switch (i_bc->type()) {
@@ -240,8 +240,7 @@ FluxingAdvectionSolver<MeshType>::_computeDonorCells(FaceValue<const double> alg
template <>
void
-FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeDonorCells(
- FaceValue<const double> algebraic_fluxing_volumes)
+FluxingAdvectionSolver<const Mesh<1>>::_computeDonorCells(FaceValue<const double> algebraic_fluxing_volumes)
{
m_donnor_cell = [&] {
const auto face_to_cell_matrix = m_new_mesh->connectivity().faceToCellMatrix();
@@ -275,7 +274,7 @@ FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeDonorCells(
template <>
FaceValue<double>
-FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeAlgebraicFluxingVolume()
+FluxingAdvectionSolver<const Mesh<1>>::_computeAlgebraicFluxingVolume()
{
Array<double> fluxing_volumes{m_new_mesh->numberOfNodes()};
NodeValue<double> nodal_fluxing_volume(m_new_mesh->connectivity(), fluxing_volumes);
@@ -294,7 +293,7 @@ FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeAlgebraicFluxingVol
template <>
FaceValue<double>
-FluxingAdvectionSolver<const Mesh<Connectivity<2>>>::_computeAlgebraicFluxingVolume()
+FluxingAdvectionSolver<const Mesh<2>>::_computeAlgebraicFluxingVolume()
{
const auto face_to_node_matrix = m_old_mesh->connectivity().faceToNodeMatrix();
FaceValue<double> algebraic_fluxing_volume(m_new_mesh->connectivity());
@@ -321,7 +320,7 @@ FluxingAdvectionSolver<const Mesh<Connectivity<2>>>::_computeAlgebraicFluxingVol
template <>
FaceValue<double>
-FluxingAdvectionSolver<const Mesh<Connectivity<3>>>::_computeAlgebraicFluxingVolume()
+FluxingAdvectionSolver<const Mesh<3>>::_computeAlgebraicFluxingVolume()
{
// due to the z component of the jacobian determinant, degree 3
// polynomials must be exactly integrated
diff --git a/src/scheme/HyperelasticSolver.cpp b/src/scheme/HyperelasticSolver.cpp
index 1e0654aeb..edd4e4950 100644
--- a/src/scheme/HyperelasticSolver.cpp
+++ b/src/scheme/HyperelasticSolver.cpp
@@ -209,7 +209,7 @@ class HyperelasticSolverHandler::HyperelasticSolver final : public HyperelasticS
}
NodeValue<Rd>
- _computeBr(const Mesh<Connectivity<Dimension>>& mesh,
+ _computeBr(const Mesh<Dimension>& mesh,
const NodeValuePerCell<const Rdxd>& Ajr,
const DiscreteVectorFunction& u,
const DiscreteTensorFunction& sigma) const
@@ -800,7 +800,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::PressureBoundaryC
};
template <>
-class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<Connectivity<1>>>::PressureBoundaryCondition
+class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<1>>::PressureBoundaryCondition
{
private:
const MeshNodeBoundary m_mesh_node_boundary;
@@ -854,7 +854,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::NormalStressBound
};
template <>
-class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<Connectivity<1>>>::NormalStressBoundaryCondition
+class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<1>>::NormalStressBoundaryCondition
{
private:
const MeshNodeBoundary m_mesh_node_boundary;
diff --git a/tests/test_CellIntegrator.cpp b/tests/test_CellIntegrator.cpp
index cce926b68..d5e7dddec 100644
--- a/tests/test_CellIntegrator.cpp
+++ b/tests/test_CellIntegrator.cpp
@@ -21,7 +21,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
{
using R1 = TinyVector<1>;
- const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
auto f = [](const R1& x) -> double { return x[0] * x[0] + 1; };
Array<const double> int_f_per_cell = [=] {
@@ -236,7 +236,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
{
using R2 = TinyVector<2>;
- const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
auto f = [](const R2& X) -> double {
const double x = X[0];
@@ -499,7 +499,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
for (const auto& mesh_info : mesh_list) {
auto mesh_name = mesh_info.first;
- auto mesh = mesh_info.second->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_info.second->get<Mesh<3>>();
SECTION(mesh_name)
{
@@ -943,7 +943,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
{
using R1 = TinyVector<1>;
- const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
auto f = [](const R1& x) -> R2 { return R2{x[0] * x[0] + 1, 2 * x[0]}; };
Array<const R2> int_f_per_cell = [=] {
@@ -1156,7 +1156,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
SECTION("2D")
{
- const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
auto f = [](const R2& X) -> R2 {
const double x = X[0];
@@ -1418,7 +1418,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
for (const auto& mesh_info : mesh_list) {
auto mesh_name = mesh_info.first;
- auto mesh = mesh_info.second->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_info.second->get<Mesh<3>>();
SECTION(mesh_name)
{
@@ -1863,7 +1863,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
{
using R1 = TinyVector<1>;
- const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
auto f = [](const R1& x) -> R2x2 { return R2x2{x[0] * x[0] + 1, 2 * x[0], 3 - x[0], 3 * x[0] - 1}; };
Array<const R2x2> int_f_per_cell = [=] {
@@ -2081,7 +2081,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
{
using R2 = TinyVector<2>;
- const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
auto f = [](const R2& X) -> R2x2 {
const double x = X[0];
@@ -2345,7 +2345,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
for (const auto& mesh_info : mesh_list) {
auto mesh_name = mesh_info.first;
- auto mesh = mesh_info.second->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_info.second->get<Mesh<3>>();
SECTION(mesh_name)
{
diff --git a/tests/test_Connectivity.cpp b/tests/test_Connectivity.cpp
index a0277eaf6..c64988ec2 100644
--- a/tests/test_Connectivity.cpp
+++ b/tests/test_Connectivity.cpp
@@ -20,7 +20,7 @@ TEST_CASE("Connectivity", "[mesh]")
{
SECTION("unordered 1D mesh")
{
- const auto& mesh = *MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ const auto& mesh = *MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
if (parallel::size() == 1) {
REQUIRE(mesh.numberOfNodes() == 35);
@@ -37,7 +37,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("cartesian 1D mesh")
{
- const auto& mesh = *MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+ const auto& mesh = *MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
if (parallel::size() == 1) {
REQUIRE(mesh.numberOfNodes() == 24);
@@ -57,7 +57,7 @@ TEST_CASE("Connectivity", "[mesh]")
{
SECTION("hybrid 2D mesh")
{
- const auto& mesh = *MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ const auto& mesh = *MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
if (parallel::size() == 1) {
REQUIRE(mesh.numberOfNodes() == 53);
@@ -74,7 +74,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("cartesian 2D mesh")
{
- const auto& mesh = *MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+ const auto& mesh = *MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
if (parallel::size() == 1) {
REQUIRE(mesh.numberOfNodes() == 56);
@@ -94,7 +94,7 @@ TEST_CASE("Connectivity", "[mesh]")
{
SECTION("hybrid 3D mesh")
{
- const auto& mesh = *MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ const auto& mesh = *MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
if (parallel::size() == 1) {
REQUIRE(mesh.numberOfNodes() == 132);
@@ -111,7 +111,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("cartesian 3D mesh")
{
- const auto& mesh = *MeshDataBaseForTests::get().cartesian3DMesh()->get<Mesh<Connectivity<3>>>();
+ const auto& mesh = *MeshDataBaseForTests::get().cartesian3DMesh()->get<Mesh<3>>();
if (parallel::size() == 1) {
REQUIRE(mesh.numberOfNodes() == 280);
@@ -137,7 +137,7 @@ TEST_CASE("Connectivity", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
SECTION("nodes/edges/faces")
@@ -228,7 +228,7 @@ TEST_CASE("Connectivity", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
SECTION("nodes")
@@ -331,7 +331,7 @@ TEST_CASE("Connectivity", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -448,7 +448,7 @@ TEST_CASE("Connectivity", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
auto is_boundary_node = connectivity.isBoundaryNode();
@@ -497,7 +497,7 @@ TEST_CASE("Connectivity", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
SECTION("faces/edges")
@@ -575,7 +575,7 @@ TEST_CASE("Connectivity", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -683,7 +683,7 @@ TEST_CASE("Connectivity", "[mesh]")
{
SECTION("cell -> nodes")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<1>>();
auto xr = mesh->xr();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -702,7 +702,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("node -> cells")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -731,7 +731,7 @@ TEST_CASE("Connectivity", "[mesh]")
{
SECTION("face -> nodes")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -751,7 +751,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("node -> faces")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -770,7 +770,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("node -> cells")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -789,7 +789,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("face -> cells")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -818,7 +818,7 @@ TEST_CASE("Connectivity", "[mesh]")
{
SECTION("edge -> nodes")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -838,7 +838,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("face -> nodes")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -865,7 +865,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("node -> edges")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -887,7 +887,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("node -> faces")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -906,7 +906,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("node -> cells")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -925,7 +925,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("edge -> faces")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -944,7 +944,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("edge -> cells")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -963,7 +963,7 @@ TEST_CASE("Connectivity", "[mesh]")
SECTION("face -> cells")
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -1020,7 +1020,7 @@ TEST_CASE("Connectivity", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh->connectivity();
SECTION("node <-> cell")
@@ -1092,7 +1092,7 @@ TEST_CASE("Connectivity", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh->connectivity();
SECTION("node <-> cell")
@@ -1194,7 +1194,7 @@ TEST_CASE("Connectivity", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
SECTION("node <-> cell")
diff --git a/tests/test_DiamondDualConnectivityBuilder.cpp b/tests/test_DiamondDualConnectivityBuilder.cpp
index 5c9df535a..2a5d1d4b6 100644
--- a/tests/test_DiamondDualConnectivityBuilder.cpp
+++ b/tests/test_DiamondDualConnectivityBuilder.cpp
@@ -37,8 +37,8 @@ TEST_CASE("DiamondDualConnectivityBuilder", "[mesh]")
{
constexpr static size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
@@ -147,8 +147,8 @@ TEST_CASE("DiamondDualConnectivityBuilder", "[mesh]")
{
constexpr static size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_DiamondDualMeshBuilder.cpp b/tests/test_DiamondDualMeshBuilder.cpp
index debdf09f5..c1f95caab 100644
--- a/tests/test_DiamondDualMeshBuilder.cpp
+++ b/tests/test_DiamondDualMeshBuilder.cpp
@@ -18,18 +18,17 @@ TEST_CASE("DiamondDualMeshBuilder", "[mesh]")
{
constexpr static size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr primal_mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
- const MeshType& primal_mesh = *primal_mesh_v->get<Mesh<Connectivity<Dimension>>>();
+ const MeshType& primal_mesh = *primal_mesh_v->get<Mesh<Dimension>>();
REQUIRE(primal_mesh.numberOfNodes() == 53);
REQUIRE(primal_mesh.numberOfFaces() == 110);
REQUIRE(primal_mesh.numberOfCells() == 58);
std::shared_ptr diamond_dual_mesh_v = DualMeshManager::instance().getDiamondDualMesh(primal_mesh_v);
- const MeshType& dual_mesh = *diamond_dual_mesh_v->get<Mesh<Connectivity<Dimension>>>();
+ const MeshType& dual_mesh = *diamond_dual_mesh_v->get<Mesh<Dimension>>();
REQUIRE(dual_mesh.numberOfNodes() == 111);
REQUIRE(dual_mesh.numberOfFaces() == 220);
@@ -85,11 +84,10 @@ TEST_CASE("DiamondDualMeshBuilder", "[mesh]")
{
constexpr static size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr primal_mesh_v = MeshDataBaseForTests::get().hybrid3DMesh();
- const MeshType& primal_mesh = *primal_mesh_v->get<Mesh<Connectivity<Dimension>>>();
+ const MeshType& primal_mesh = *primal_mesh_v->get<Mesh<Dimension>>();
REQUIRE(primal_mesh.numberOfNodes() == 132);
REQUIRE(primal_mesh.numberOfEdges() == 452);
@@ -97,7 +95,7 @@ TEST_CASE("DiamondDualMeshBuilder", "[mesh]")
REQUIRE(primal_mesh.numberOfCells() == 199);
std::shared_ptr diamond_dual_mesh_v = DualMeshManager::instance().getDiamondDualMesh(primal_mesh_v);
- const MeshType& dual_mesh = *diamond_dual_mesh_v->get<Mesh<Connectivity<Dimension>>>();
+ const MeshType& dual_mesh = *diamond_dual_mesh_v->get<Mesh<Dimension>>();
REQUIRE(dual_mesh.numberOfNodes() == 331);
REQUIRE(dual_mesh.numberOfEdges() == 1461);
diff --git a/tests/test_DiscreteFunctionIntegratorByZone.cpp b/tests/test_DiscreteFunctionIntegratorByZone.cpp
index c556cf6ca..2e0d3dad2 100644
--- a/tests/test_DiscreteFunctionIntegratorByZone.cpp
+++ b/tests/test_DiscreteFunctionIntegratorByZone.cpp
@@ -54,7 +54,7 @@ TEST_CASE("DiscreteFunctionIntegratorByZone", "[scheme]")
std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
auto mesh_1d_v = MeshDataBaseForTests::get().unordered1DMesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -384,7 +384,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -714,7 +714,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
auto mesh_3d_v = MeshDataBaseForTests::get().hybrid3DMesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
diff --git a/tests/test_DiscreteFunctionInterpoler.cpp b/tests/test_DiscreteFunctionInterpoler.cpp
index 21bec01b1..b4c024d3f 100644
--- a/tests/test_DiscreteFunctionInterpoler.cpp
+++ b/tests/test_DiscreteFunctionInterpoler.cpp
@@ -53,7 +53,7 @@ TEST_CASE("DiscreteFunctionInterpoler", "[scheme]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
@@ -343,7 +343,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
@@ -634,7 +634,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
diff --git a/tests/test_DiscreteFunctionInterpolerByZone.cpp b/tests/test_DiscreteFunctionInterpolerByZone.cpp
index 9a95d7ffd..e62ab89fe 100644
--- a/tests/test_DiscreteFunctionInterpolerByZone.cpp
+++ b/tests/test_DiscreteFunctionInterpolerByZone.cpp
@@ -50,7 +50,7 @@ TEST_CASE("DiscreteFunctionInterpolerByZone", "[scheme]")
constexpr size_t Dimension = 1;
auto mesh_1d_v = MeshDataBaseForTests::get().unordered1DMesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -384,7 +384,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
constexpr size_t Dimension = 2;
auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -719,7 +719,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
constexpr size_t Dimension = 3;
auto mesh_3d_v = MeshDataBaseForTests::get().hybrid3DMesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
diff --git a/tests/test_DiscreteFunctionP0.cpp b/tests/test_DiscreteFunctionP0.cpp
index ccf962754..e43e1958d 100644
--- a/tests/test_DiscreteFunctionP0.cpp
+++ b/tests/test_DiscreteFunctionP0.cpp
@@ -33,7 +33,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<1>>();
DiscreteFunctionP0<Dimension, double> f{mesh};
REQUIRE(f.dataType() == ASTNodeDataType::double_t);
REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0);
@@ -81,7 +81,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
DiscreteFunctionP0<Dimension, double> f{mesh};
REQUIRE(f.dataType() == ASTNodeDataType::double_t);
REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0);
@@ -129,7 +129,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
DiscreteFunctionP0<Dimension, double> f{mesh};
REQUIRE(f.dataType() == ASTNodeDataType::double_t);
@@ -191,7 +191,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<1>>();
DiscreteFunctionP0<Dimension, double> f{mesh};
f.fill(3);
@@ -220,7 +220,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
DiscreteFunctionP0<Dimension, double> f{mesh};
f.fill(3);
@@ -249,7 +249,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
DiscreteFunctionP0<Dimension, double> f{mesh};
f.fill(3);
@@ -291,7 +291,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<1>>();
SECTION("scalar")
{
@@ -393,7 +393,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
SECTION("scalar")
{
@@ -495,7 +495,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
SECTION("scalar")
{
@@ -599,7 +599,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<1>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -684,7 +684,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<1>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -1265,7 +1265,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -1851,7 +1851,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -2500,7 +2500,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<1>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -2844,7 +2844,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<2>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -3188,7 +3188,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<3>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -3439,7 +3439,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
const double x = xj[cell_id][0];
Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, //
- -0.2 * x - 1, 2 + x};
+ -0.2 * x - 1, 2 + x};
});
{
@@ -3461,7 +3461,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
const double x = xj[cell_id][0];
Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, //
- -0.2 * x - 1, 2 + x};
+ -0.2 * x - 1, 2 + x};
});
{
@@ -3483,7 +3483,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
const double x = xj[cell_id][0];
Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, //
- -0.2 * x - 1, 2 + x};
+ -0.2 * x - 1, 2 + x};
});
{
@@ -3505,7 +3505,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
const double x = xj[cell_id][0];
Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, //
- -0.2 * x - 1, 2 + x};
+ -0.2 * x - 1, 2 + x};
});
{
@@ -3626,10 +3626,9 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1 = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1 = named_mesh.mesh()->get<Mesh<1>>();
- std::shared_ptr mesh_2 =
- std::make_shared<Mesh<Connectivity<Dimension>>>(mesh_1->shared_connectivity(), mesh_1->xr());
+ std::shared_ptr mesh_2 = std::make_shared<Mesh<Dimension>>(mesh_1->shared_connectivity(), mesh_1->xr());
DiscreteFunctionP0<Dimension, double> f1{mesh_1};
DiscreteFunctionP0<Dimension, double> f2{mesh_2};
@@ -3653,10 +3652,9 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1 = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_1 = named_mesh.mesh()->get<Mesh<2>>();
- std::shared_ptr mesh_2 =
- std::make_shared<Mesh<Connectivity<Dimension>>>(mesh_1->shared_connectivity(), mesh_1->xr());
+ std::shared_ptr mesh_2 = std::make_shared<Mesh<Dimension>>(mesh_1->shared_connectivity(), mesh_1->xr());
DiscreteFunctionP0<Dimension, double> f1{mesh_1};
DiscreteFunctionP0<Dimension, double> f2{mesh_2};
@@ -3680,10 +3678,9 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1 = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_1 = named_mesh.mesh()->get<Mesh<3>>();
- std::shared_ptr mesh_2 =
- std::make_shared<Mesh<Connectivity<Dimension>>>(mesh_1->shared_connectivity(), mesh_1->xr());
+ std::shared_ptr mesh_2 = std::make_shared<Mesh<Dimension>>(mesh_1->shared_connectivity(), mesh_1->xr());
DiscreteFunctionP0<Dimension, double> f1{mesh_1};
DiscreteFunctionP0<Dimension, double> f2{mesh_2};
diff --git a/tests/test_DiscreteFunctionP0Vector.cpp b/tests/test_DiscreteFunctionP0Vector.cpp
index 1bf27ddb2..4521e8fa8 100644
--- a/tests/test_DiscreteFunctionP0Vector.cpp
+++ b/tests/test_DiscreteFunctionP0Vector.cpp
@@ -34,7 +34,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
REQUIRE(f.dataType() == ASTNodeDataType::double_t);
REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0Vector);
@@ -82,7 +82,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
REQUIRE(f.dataType() == ASTNodeDataType::double_t);
REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0Vector);
@@ -130,7 +130,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
REQUIRE(f.dataType() == ASTNodeDataType::double_t);
REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0Vector);
@@ -193,7 +193,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
SECTION(named_mesh.name())
{
constexpr size_t Dimension = 1;
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
f.fill(3);
@@ -214,7 +214,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
f.fill(2.3);
@@ -234,7 +234,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
f.fill(3.2);
@@ -269,7 +269,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
const size_t size = 3;
const size_t value = parallel::rank() + 1;
@@ -315,7 +315,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
const size_t size = 3;
const size_t value = parallel::rank() + 1;
@@ -362,7 +362,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
const size_t size = 3;
const size_t value = parallel::rank() + 1;
@@ -413,7 +413,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -456,7 +456,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -500,7 +500,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -548,7 +548,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -631,7 +631,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -714,7 +714,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -800,7 +800,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -934,7 +934,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
@@ -1072,7 +1072,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
diff --git a/tests/test_DiscreteFunctionUtils.cpp b/tests/test_DiscreteFunctionUtils.cpp
index e7b547f40..f7adede0e 100644
--- a/tests/test_DiscreteFunctionUtils.cpp
+++ b/tests/test_DiscreteFunctionUtils.cpp
@@ -22,7 +22,7 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
SECTION(named_mesh.name())
{
auto mesh_v = named_mesh.mesh();
- auto mesh = mesh_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = mesh_v->get<Mesh<Dimension>>();
std::shared_ptr mesh_copy =
std::make_shared<const std::decay_t<decltype(*mesh)>>(mesh->shared_connectivity(), mesh->xr());
@@ -210,7 +210,7 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
SECTION(named_mesh.name())
{
auto mesh_v = named_mesh.mesh();
- auto mesh = mesh_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = mesh_v->get<Mesh<Dimension>>();
std::shared_ptr mesh_copy =
std::make_shared<const std::decay_t<decltype(*mesh)>>(mesh->shared_connectivity(), mesh->xr());
std::shared_ptr mesh_copy_v = std::make_shared<const MeshVariant>(mesh_copy);
@@ -397,7 +397,7 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
SECTION(named_mesh.name())
{
auto mesh_v = named_mesh.mesh();
- auto mesh = mesh_v->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_v->get<Mesh<3>>();
std::shared_ptr mesh_copy =
std::make_shared<const std::decay_t<decltype(*mesh)>>(mesh->shared_connectivity(), mesh->xr());
@@ -586,12 +586,10 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
std::shared_ptr other_mesh =
- CartesianMeshBuilder{TinyVector<1>{-1}, TinyVector<1>{3}, TinyVector<1, size_t>{19}}
- .mesh()
- ->get<Mesh<Connectivity<1>>>();
+ CartesianMeshBuilder{TinyVector<1>{-1}, TinyVector<1>{3}, TinyVector<1, size_t>{19}}.mesh()->get<Mesh<1>>();
std::shared_ptr other_mesh_v = std::make_shared<const MeshVariant>(other_mesh);
std::shared_ptr uh = std::make_shared<DiscreteFunctionVariant>(DiscreteFunctionP0<Dimension, double>(mesh));
@@ -605,9 +603,9 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
{
constexpr size_t Dimension = 1;
- std::shared_ptr mesh_1d = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
- std::shared_ptr mesh_2d_v = std::make_shared<const MeshVariant>(
- MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>());
+ std::shared_ptr mesh_1d = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
+ std::shared_ptr mesh_2d_v =
+ std::make_shared<const MeshVariant>(MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>());
std::shared_ptr uh = std::make_shared<DiscreteFunctionVariant>(DiscreteFunctionP0<Dimension, double>(mesh_1d));
diff --git a/tests/test_DiscreteFunctionVectorIntegrator.cpp b/tests/test_DiscreteFunctionVectorIntegrator.cpp
index 79cd612e5..58ad9cdf2 100644
--- a/tests/test_DiscreteFunctionVectorIntegrator.cpp
+++ b/tests/test_DiscreteFunctionVectorIntegrator.cpp
@@ -68,7 +68,7 @@ TEST_CASE("DiscreteFunctionVectorIntegrator", "[scheme]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
std::string_view data = R"(
import math;
@@ -158,7 +158,7 @@ let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
std::string_view data = R"(
import math;
@@ -248,7 +248,7 @@ let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0] + x[1]) + 3;
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
std::string_view data = R"(
import math;
@@ -336,7 +336,7 @@ let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
std::string_view data = R"(
import math;
diff --git a/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp b/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp
index f26721770..2522f3651 100644
--- a/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp
+++ b/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp
@@ -65,7 +65,7 @@ TEST_CASE("DiscreteFunctionVectorIntegratorByZone", "[scheme]")
std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
auto mesh_1d_v = MeshDataBaseForTests::get().unordered1DMesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -194,7 +194,7 @@ let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -323,7 +323,7 @@ let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0] + x[1]) + 3;
std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
auto mesh_3d_v = MeshDataBaseForTests::get().hybrid3DMesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
diff --git a/tests/test_DiscreteFunctionVectorInterpoler.cpp b/tests/test_DiscreteFunctionVectorInterpoler.cpp
index 0c0d60795..b86f833a2 100644
--- a/tests/test_DiscreteFunctionVectorInterpoler.cpp
+++ b/tests/test_DiscreteFunctionVectorInterpoler.cpp
@@ -63,7 +63,7 @@ TEST_CASE("DiscreteFunctionVectorInterpoler", "[scheme]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
@@ -168,7 +168,7 @@ let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
@@ -273,7 +273,7 @@ let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0] + x[1]) + 3;
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
@@ -376,7 +376,7 @@ let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
diff --git a/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp b/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
index 7468ce997..c17a9b397 100644
--- a/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
+++ b/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
@@ -60,7 +60,7 @@ TEST_CASE("DiscreteFunctionVectorInterpolerByZone", "[scheme]")
constexpr size_t Dimension = 1;
auto mesh_1d_v = MeshDataBaseForTests::get().unordered1DMesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -186,7 +186,7 @@ let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
constexpr size_t Dimension = 2;
auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -312,7 +312,7 @@ let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0] + x[1]) + 3;
constexpr size_t Dimension = 3;
auto mesh_3d_v = MeshDataBaseForTests::get().hybrid3DMesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -441,7 +441,7 @@ let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
diff --git a/tests/test_Dual1DConnectivityBuilder.cpp b/tests/test_Dual1DConnectivityBuilder.cpp
index b8eb91e42..d08d53b22 100644
--- a/tests/test_Dual1DConnectivityBuilder.cpp
+++ b/tests/test_Dual1DConnectivityBuilder.cpp
@@ -36,8 +36,8 @@ TEST_CASE("Dual1DConnectivityBuilder", "[mesh]")
{
constexpr static size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_Dual1DMeshBuilder.cpp b/tests/test_Dual1DMeshBuilder.cpp
index 50b130f12..88ac2de4f 100644
--- a/tests/test_Dual1DMeshBuilder.cpp
+++ b/tests/test_Dual1DMeshBuilder.cpp
@@ -18,8 +18,7 @@ TEST_CASE("Dual1DMeshBuilder", "[mesh]")
{
constexpr static size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr primal_mesh_v = MeshDataBaseForTests::get().unordered1DMesh();
diff --git a/tests/test_DualConnectivityManager.cpp b/tests/test_DualConnectivityManager.cpp
index f3b670390..8c24eb079 100644
--- a/tests/test_DualConnectivityManager.cpp
+++ b/tests/test_DualConnectivityManager.cpp
@@ -11,8 +11,8 @@
TEST_CASE("DualConnectivityManager", "[mesh]")
{
- using ConnectivityType = Connectivity<2>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<2>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
std::shared_ptr mesh = mesh_v->get<MeshType>();
diff --git a/tests/test_DualMeshManager.cpp b/tests/test_DualMeshManager.cpp
index da9aac557..9c60d8a27 100644
--- a/tests/test_DualMeshManager.cpp
+++ b/tests/test_DualMeshManager.cpp
@@ -26,8 +26,7 @@ TEST_CASE("DualMeshManager", "[mesh]")
SECTION("2D")
{
- using ConnectivityType = Connectivity<2>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<2>;
std::shared_ptr mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
@@ -117,8 +116,7 @@ TEST_CASE("DualMeshManager", "[mesh]")
SECTION("3D")
{
- using ConnectivityType = Connectivity<3>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<3>;
std::shared_ptr mesh_v = MeshDataBaseForTests::get().hybrid3DMesh();
std::shared_ptr mesh = mesh_v->get<MeshType>();
diff --git a/tests/test_EdgeIntegrator.cpp b/tests/test_EdgeIntegrator.cpp
index b20cb925f..5415a03f1 100644
--- a/tests/test_EdgeIntegrator.cpp
+++ b/tests/test_EdgeIntegrator.cpp
@@ -38,7 +38,7 @@ TEST_CASE("EdgeIntegrator", "[scheme]")
for (const auto& mesh_info : mesh_list) {
auto mesh_name = mesh_info.first;
- auto mesh = mesh_info.second->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_info.second->get<Mesh<3>>();
Array<const double> int_f_per_edge = [=] {
Array<double> int_f(mesh->numberOfEdges());
@@ -288,7 +288,7 @@ TEST_CASE("EdgeIntegrator", "[scheme]")
for (const auto& mesh_info : mesh_list) {
auto mesh_name = mesh_info.first;
- auto mesh = mesh_info.second->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_info.second->get<Mesh<3>>();
Array<const R2> int_f_per_edge = [=] {
Array<R2> int_f(mesh->numberOfEdges());
@@ -540,7 +540,7 @@ TEST_CASE("EdgeIntegrator", "[scheme]")
for (const auto& mesh_info : mesh_list) {
auto mesh_name = mesh_info.first;
- auto mesh = mesh_info.second->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_info.second->get<Mesh<3>>();
Array<const R2x2> int_f_per_edge = [=] {
Array<R2x2> int_f(mesh->numberOfEdges());
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp
index aa48d3ffc..7ebb75f85 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp
@@ -34,10 +34,9 @@ TEST_CASE("EmbeddedDiscreteFunctionVariantMathFunctions1D", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
- std::shared_ptr other_mesh =
- std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+ std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp
index 8658aa3da..989b66d39 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp
@@ -36,10 +36,9 @@ TEST_CASE("EmbeddedDiscreteFunctionVariantMathFunctions2D", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
- std::shared_ptr other_mesh =
- std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+ std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp
index 415173393..25afe5c0a 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp
@@ -34,10 +34,9 @@ TEST_CASE("EmbeddedDiscreteFunctionVariantMathFunctions3D", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
- std::shared_ptr other_mesh =
- std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+ std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
diff --git a/tests/test_EmbeddedDiscreteFunctionOperators1D.cpp b/tests/test_EmbeddedDiscreteFunctionOperators1D.cpp
index fbbcc8bc1..e790e4608 100644
--- a/tests/test_EmbeddedDiscreteFunctionOperators1D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionOperators1D.cpp
@@ -25,10 +25,9 @@ TEST_CASE("EmbeddedDiscreteFunctionOperators1D", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
- std::shared_ptr other_mesh =
- std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+ std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
diff --git a/tests/test_EmbeddedDiscreteFunctionOperators2D.cpp b/tests/test_EmbeddedDiscreteFunctionOperators2D.cpp
index d3fece0d8..0efe0cfbe 100644
--- a/tests/test_EmbeddedDiscreteFunctionOperators2D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionOperators2D.cpp
@@ -25,10 +25,9 @@ TEST_CASE("EmbeddedDiscreteFunctionOperators2D", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
- std::shared_ptr other_mesh =
- std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+ std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
diff --git a/tests/test_EmbeddedDiscreteFunctionOperators3D.cpp b/tests/test_EmbeddedDiscreteFunctionOperators3D.cpp
index eb30d18d5..a024c2dde 100644
--- a/tests/test_EmbeddedDiscreteFunctionOperators3D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionOperators3D.cpp
@@ -25,10 +25,9 @@ TEST_CASE("EmbeddedDiscreteFunctionOperators3D", "[scheme]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
- std::shared_ptr other_mesh =
- std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+ std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
diff --git a/tests/test_EmbeddedDiscreteFunctionUtils.cpp b/tests/test_EmbeddedDiscreteFunctionUtils.cpp
index 3640ea5b5..464313cb5 100644
--- a/tests/test_EmbeddedDiscreteFunctionUtils.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionUtils.cpp
@@ -34,7 +34,7 @@ TEST_CASE("EmbeddedDiscreteFunctionUtils", "[language]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, double>{mesh_1d}) ==
"Vh(P0:R)");
@@ -63,7 +63,7 @@ TEST_CASE("EmbeddedDiscreteFunctionUtils", "[language]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0Vector<1, double>{mesh_1d, 2}) ==
"Vh(P0Vector:R)");
diff --git a/tests/test_FaceIntegrator.cpp b/tests/test_FaceIntegrator.cpp
index 092ab55c3..73e6ecad9 100644
--- a/tests/test_FaceIntegrator.cpp
+++ b/tests/test_FaceIntegrator.cpp
@@ -22,7 +22,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
using R2 = TinyVector<2>;
const auto mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
- const auto mesh = mesh_v->get<Mesh<Connectivity<2>>>();
+ const auto mesh = mesh_v->get<Mesh<2>>();
auto f = [](const R2& X) -> double {
const double x = X[0];
@@ -265,7 +265,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
for (const auto& mesh_info : mesh_list) {
auto mesh_name = mesh_info.first;
- auto mesh = mesh_info.second->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_info.second->get<Mesh<3>>();
Array<const double> int_f_per_face = [=] {
Array<double> int_f(mesh->numberOfFaces());
@@ -514,7 +514,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
{
using R2 = TinyVector<2>;
- const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
auto f = [](const R2& X) -> R2 {
const double x = X[0];
@@ -757,7 +757,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
for (const auto& mesh_info : mesh_list) {
auto mesh_name = mesh_info.first;
- auto mesh = mesh_info.second->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_info.second->get<Mesh<3>>();
Array<const R2> int_f_per_face = [=] {
Array<R2> int_f(mesh->numberOfFaces());
@@ -1009,7 +1009,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
{
using R2 = TinyVector<2>;
- const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
auto f = [](const R2& X) -> R2x2 {
const double x = X[0];
@@ -1252,7 +1252,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
for (const auto& mesh_info : mesh_list) {
auto mesh_name = mesh_info.first;
- auto mesh = mesh_info.second->get<Mesh<Connectivity<3>>>();
+ auto mesh = mesh_info.second->get<Mesh<3>>();
Array<const R2x2> int_f_per_face = [=] {
Array<R2x2> int_f(mesh->numberOfFaces());
diff --git a/tests/test_IntegrateCellArray.cpp b/tests/test_IntegrateCellArray.cpp
index 6e45d92a7..738fad05f 100644
--- a/tests/test_IntegrateCellArray.cpp
+++ b/tests/test_IntegrateCellArray.cpp
@@ -55,7 +55,7 @@ TEST_CASE("IntegrateCellArray", "[language]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
std::string_view data = R"(
import math;
@@ -142,7 +142,7 @@ let g: R^1 -> R, x -> 2 * exp(x[0]) + 3;
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
std::string_view data = R"(
import math;
@@ -240,7 +240,7 @@ let g: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
std::string_view data = R"(
import math;
@@ -343,7 +343,7 @@ let g: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
@@ -438,7 +438,7 @@ let g: R^1 -> R, x -> 2 * exp(x[0]) + 3;
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
@@ -545,7 +545,7 @@ let g: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
diff --git a/tests/test_IntegrateCellValue.cpp b/tests/test_IntegrateCellValue.cpp
index 88d4e356d..ab2c86f82 100644
--- a/tests/test_IntegrateCellValue.cpp
+++ b/tests/test_IntegrateCellValue.cpp
@@ -53,7 +53,7 @@ TEST_CASE("IntegrateCellValue", "[language]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
std::string_view data = R"(
import math;
@@ -111,7 +111,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
std::string_view data = R"(
import math;
@@ -181,7 +181,7 @@ let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
std::string_view data = R"(
import math;
@@ -251,7 +251,7 @@ let scalar_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
@@ -316,7 +316,7 @@ let scalar_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
@@ -396,7 +396,7 @@ let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
diff --git a/tests/test_IntegrateOnCells.cpp b/tests/test_IntegrateOnCells.cpp
index f2f46e73d..93d1c6806 100644
--- a/tests/test_IntegrateOnCells.cpp
+++ b/tests/test_IntegrateOnCells.cpp
@@ -55,7 +55,7 @@ TEST_CASE("IntegrateOnCells", "[language]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
std::string_view data = R"(
import math;
@@ -156,7 +156,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
std::string_view data = R"(
import math;
@@ -270,7 +270,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
std::string_view data = R"(
import math;
@@ -389,7 +389,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
@@ -500,7 +500,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
@@ -624,7 +624,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
@@ -758,7 +758,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
std::string_view data = R"(
import math;
@@ -859,7 +859,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
std::string_view data = R"(
import math;
@@ -973,7 +973,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
std::string_view data = R"(
import math;
@@ -1092,7 +1092,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
@@ -1203,7 +1203,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
@@ -1327,7 +1327,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
@@ -1461,7 +1461,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
std::string_view data = R"(
import math;
@@ -1562,7 +1562,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
std::string_view data = R"(
import math;
@@ -1676,7 +1676,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
std::string_view data = R"(
import math;
@@ -1795,7 +1795,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
@@ -1906,7 +1906,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
@@ -2030,7 +2030,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
diff --git a/tests/test_InterpolateItemArray.cpp b/tests/test_InterpolateItemArray.cpp
index c23dedeaa..cab00ae0a 100644
--- a/tests/test_InterpolateItemArray.cpp
+++ b/tests/test_InterpolateItemArray.cpp
@@ -57,7 +57,7 @@ TEST_CASE("InterpolateItemArray", "[language]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
@@ -127,7 +127,7 @@ let scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
@@ -187,7 +187,7 @@ let f_1d: R^1 -> (R), x -> (2*x[0] + 2, 2 * exp(x[0]) + 3);
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
@@ -256,7 +256,7 @@ let f_1d: R^1 -> (R^1), x -> (2*x[0] + 2, [2 * exp(x[0]) + 3]);
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
@@ -326,7 +326,7 @@ let scalar_non_linear_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
@@ -393,7 +393,7 @@ let f_2d: R^2 -> (R), x -> (2*x[0] + 3*x[1] + 2, 2*exp(x[0])*sin(x[1])+3);
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
@@ -463,7 +463,7 @@ let scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
@@ -544,7 +544,7 @@ let f_3d: R^3 -> (R), x -> (2 * x[0] + 3 * x[1] + 2 * x[2] - 1, 2 * exp(x[0]) *
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
@@ -623,7 +623,7 @@ let scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
@@ -699,7 +699,7 @@ let f_1d: R^1 -> (R), x -> (2*x[0] + 2, 2 * exp(x[0]) + 3);
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
@@ -775,7 +775,7 @@ let scalar_non_linear_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
@@ -841,7 +841,7 @@ let f_2d: R^2 -> (R), x -> (2*x[0] + 3*x[1] + 2, 2*exp(x[0])*sin(x[1])+3);
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
@@ -919,7 +919,7 @@ let f_2d: R^2 -> (R^2x2), x -> ([[x[0],0],[2-x[1], x[0]*x[1]]], [[2*x[0], x[1]],
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
@@ -995,7 +995,7 @@ let scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
@@ -1061,7 +1061,7 @@ let f_3d: R^3 -> (R), x -> (2 * x[0] + 3 * x[1] + 2 * x[2] - 1, 2 * exp(x[0]) *
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
diff --git a/tests/test_InterpolateItemValue.cpp b/tests/test_InterpolateItemValue.cpp
index 8cb3ac498..370b8b401 100644
--- a/tests/test_InterpolateItemValue.cpp
+++ b/tests/test_InterpolateItemValue.cpp
@@ -52,7 +52,7 @@ TEST_CASE("InterpolateItemValue", "[language]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
@@ -224,7 +224,7 @@ let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
@@ -390,7 +390,7 @@ let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
@@ -536,7 +536,7 @@ let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos
cell_value.numberOfItems(), PUGS_LAMBDA(const CellId cell_id) {
const TinyVector<Dimension>& x = xj[cell_id];
cell_value[cell_id] = TinyMatrix<2>{2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]),
- sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]};
+ sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]};
});
CellValue<const TinyMatrix<2>> interpolate_value =
InterpolateItemValue<TinyMatrix<2>(TinyVector<Dimension>)>::interpolate(function_symbol_id, xj);
@@ -570,7 +570,7 @@ let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
@@ -753,7 +753,7 @@ let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
@@ -928,7 +928,7 @@ let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<Dimension>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
diff --git a/tests/test_ItemArray.cpp b/tests/test_ItemArray.cpp
index 313e51972..212e12141 100644
--- a/tests/test_ItemArray.cpp
+++ b/tests/test_ItemArray.cpp
@@ -34,7 +34,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -73,7 +73,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -110,7 +110,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -145,7 +145,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -197,7 +197,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -233,7 +233,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -280,7 +280,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION("output")
{
auto mesh_v = MeshDataBaseForTests::get().unordered1DMesh();
- auto mesh = mesh_v->get<Mesh<Connectivity<1>>>();
+ auto mesh = mesh_v->get<Mesh<1>>();
Table<int> table{mesh->numberOfCells(), 3};
for (size_t i = 0; i < table.numberOfRows(); ++i) {
@@ -324,7 +324,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -355,7 +355,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -373,7 +373,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity_2d = mesh_2d->connectivity();
@@ -383,7 +383,7 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION(named_mesh_3d.name())
{
auto mesh_3d_v = named_mesh_3d.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity_3d = mesh_3d->connectivity();
diff --git a/tests/test_ItemArrayUtils.cpp b/tests/test_ItemArrayUtils.cpp
index cd0ea471f..8d0484284 100644
--- a/tests/test_ItemArrayUtils.cpp
+++ b/tests/test_ItemArrayUtils.cpp
@@ -26,7 +26,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -301,7 +301,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -576,7 +576,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -854,7 +854,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -884,7 +884,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -914,7 +914,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -947,7 +947,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -977,7 +977,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -1007,7 +1007,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -1040,7 +1040,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -1070,7 +1070,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name() + " for double data")
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -1098,7 +1098,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name() + " for N^2 data")
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -1131,7 +1131,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name() + " for size_t data")
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -1154,7 +1154,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
SECTION(named_mesh.name() + " for N^3x2 data")
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
diff --git a/tests/test_ItemArrayVariant.cpp b/tests/test_ItemArrayVariant.cpp
index 878ee2a7f..1f0d1d822 100644
--- a/tests/test_ItemArrayVariant.cpp
+++ b/tests/test_ItemArrayVariant.cpp
@@ -12,7 +12,7 @@
TEST_CASE("ItemArrayVariant", "[mesh]")
{
std::shared_ptr mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
- std::shared_ptr mesh = mesh_v->get<Mesh<Connectivity<2>>>();
+ std::shared_ptr mesh = mesh_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = *mesh->shared_connectivity();
diff --git a/tests/test_ItemArrayVariantFunctionInterpoler.cpp b/tests/test_ItemArrayVariantFunctionInterpoler.cpp
index 50af9207e..95f9d9b5c 100644
--- a/tests/test_ItemArrayVariantFunctionInterpoler.cpp
+++ b/tests/test_ItemArrayVariantFunctionInterpoler.cpp
@@ -56,7 +56,7 @@ TEST_CASE("ItemArrayVariantFunctionInterpoler", "[scheme]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
auto xr = mesh_1d->xr();
@@ -431,7 +431,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
auto xl = MeshDataManager::instance().getMeshData(*mesh_2d).xl();
@@ -565,7 +565,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
auto xe = MeshDataManager::instance().getMeshData(*mesh_3d).xe();
diff --git a/tests/test_ItemValue.cpp b/tests/test_ItemValue.cpp
index 79b54c22b..43a8dd459 100644
--- a/tests/test_ItemValue.cpp
+++ b/tests/test_ItemValue.cpp
@@ -32,7 +32,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -66,7 +66,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -96,7 +96,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -121,7 +121,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -152,7 +152,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -191,7 +191,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -226,7 +226,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION("output")
{
auto mesh_v = MeshDataBaseForTests::get().unordered1DMesh();
- auto mesh = mesh_v->get<Mesh<Connectivity<1>>>();
+ auto mesh = mesh_v->get<Mesh<1>>();
Array<int> array{mesh->numberOfCells()};
for (size_t i = 0; i < array.size(); ++i) {
@@ -268,7 +268,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -299,7 +299,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -317,7 +317,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity_2d = mesh_2d->connectivity();
@@ -327,7 +327,7 @@ TEST_CASE("ItemValue", "[mesh]")
SECTION(named_mesh_3d.name())
{
auto mesh_3d_v = named_mesh_3d.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity_3d = mesh_3d->connectivity();
diff --git a/tests/test_ItemValueUtils.cpp b/tests/test_ItemValueUtils.cpp
index 6c5d8b0af..f80819f2c 100644
--- a/tests/test_ItemValueUtils.cpp
+++ b/tests/test_ItemValueUtils.cpp
@@ -24,7 +24,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -78,7 +78,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -106,7 +106,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -134,7 +134,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -165,7 +165,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -193,7 +193,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -221,7 +221,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -252,7 +252,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name() + " for size_t data")
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -280,7 +280,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name() + " for double data")
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -317,7 +317,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name() + "for size_t data")
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -345,7 +345,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name() + "for double data")
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -375,7 +375,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name() + "for N^3 data")
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -407,7 +407,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name() + "for R2 data")
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -452,7 +452,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name() + " for size_t data")
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -475,7 +475,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name() + " for N^3x2 data")
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -502,7 +502,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
SECTION(named_mesh.name() + "for R^2x3 data")
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
diff --git a/tests/test_ItemValueVariant.cpp b/tests/test_ItemValueVariant.cpp
index fb4180f4a..6eed537b9 100644
--- a/tests/test_ItemValueVariant.cpp
+++ b/tests/test_ItemValueVariant.cpp
@@ -12,7 +12,7 @@
TEST_CASE("ItemValueVariant", "[mesh]")
{
auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
const Connectivity<2>& connectivity = *mesh_2d->shared_connectivity();
diff --git a/tests/test_ItemValueVariantFunctionInterpoler.cpp b/tests/test_ItemValueVariantFunctionInterpoler.cpp
index a55435208..4bc251aba 100644
--- a/tests/test_ItemValueVariantFunctionInterpoler.cpp
+++ b/tests/test_ItemValueVariantFunctionInterpoler.cpp
@@ -50,7 +50,7 @@ TEST_CASE("ItemValueVariantFunctionInterpoler", "[scheme]")
SECTION(named_mesh.name())
{
auto mesh_1d_v = named_mesh.mesh();
- auto mesh_1d = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = mesh_1d_v->get<Mesh<1>>();
auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
auto xr = mesh_1d->xr();
@@ -331,7 +331,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
SECTION(named_mesh.name())
{
auto mesh_2d_v = named_mesh.mesh();
- auto mesh_2d = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = mesh_2d_v->get<Mesh<2>>();
auto xl = MeshDataManager::instance().getMeshData(*mesh_2d).xl();
@@ -451,7 +451,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
SECTION(named_mesh.name())
{
auto mesh_3d_v = named_mesh.mesh();
- auto mesh_3d = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = mesh_3d_v->get<Mesh<3>>();
auto xe = MeshDataManager::instance().getMeshData(*mesh_3d).xe();
diff --git a/tests/test_MedianDualConnectivityBuilder.cpp b/tests/test_MedianDualConnectivityBuilder.cpp
index 34728918d..ab418f24a 100644
--- a/tests/test_MedianDualConnectivityBuilder.cpp
+++ b/tests/test_MedianDualConnectivityBuilder.cpp
@@ -37,8 +37,8 @@ TEST_CASE("MedianDualConnectivityBuilder", "[mesh]")
{
constexpr static size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_MedianDualMeshBuilder.cpp b/tests/test_MedianDualMeshBuilder.cpp
index ac2fe9bb4..f4f96d240 100644
--- a/tests/test_MedianDualMeshBuilder.cpp
+++ b/tests/test_MedianDualMeshBuilder.cpp
@@ -18,8 +18,7 @@ TEST_CASE("MedianDualMeshBuilder", "[mesh]")
{
constexpr static size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr primal_mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
const MeshType& primal_mesh = *primal_mesh_v->get<MeshType>();
diff --git a/tests/test_MeshEdgeBoundary.cpp b/tests/test_MeshEdgeBoundary.cpp
index 0659a644b..307d73fdc 100644
--- a/tests/test_MeshEdgeBoundary.cpp
+++ b/tests/test_MeshEdgeBoundary.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("cartesian 1d")
{
@@ -120,8 +120,8 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("cartesian 2d")
{
@@ -192,8 +192,8 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("cartesian 3d")
{
@@ -266,8 +266,7 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -284,8 +283,7 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -301,8 +299,7 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -318,8 +315,7 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshEdgeInterface.cpp b/tests/test_MeshEdgeInterface.cpp
index b42324c5a..328a1ce63 100644
--- a/tests/test_MeshEdgeInterface.cpp
+++ b/tests/test_MeshEdgeInterface.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshEdgeInterface", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("unordered 1d")
{
@@ -87,8 +87,8 @@ TEST_CASE("MeshEdgeInterface", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("hybrid 2d")
{
@@ -127,8 +127,8 @@ TEST_CASE("MeshEdgeInterface", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("hybrid 3d")
{
@@ -169,8 +169,7 @@ TEST_CASE("MeshEdgeInterface", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshFaceBoundary.cpp b/tests/test_MeshFaceBoundary.cpp
index 9345506d7..40de5b4e1 100644
--- a/tests/test_MeshFaceBoundary.cpp
+++ b/tests/test_MeshFaceBoundary.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("cartesian 1d")
{
@@ -120,8 +120,8 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("cartesian 2d")
{
@@ -192,8 +192,8 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("cartesian 3d")
{
@@ -266,8 +266,7 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -284,8 +283,7 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -301,8 +299,7 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -318,8 +315,7 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshFaceInterface.cpp b/tests/test_MeshFaceInterface.cpp
index d762b712c..b213ffd48 100644
--- a/tests/test_MeshFaceInterface.cpp
+++ b/tests/test_MeshFaceInterface.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("unordered 1d")
{
@@ -87,8 +87,8 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("hybrid 2d")
{
@@ -127,8 +127,8 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("hybrid 3d")
{
@@ -169,8 +169,7 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -187,8 +186,7 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -204,8 +202,7 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -221,8 +218,7 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshFlatEdgeBoundary.cpp b/tests/test_MeshFlatEdgeBoundary.cpp
index 18070e5db..f71756546 100644
--- a/tests/test_MeshFlatEdgeBoundary.cpp
+++ b/tests/test_MeshFlatEdgeBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R1 = TinyVector<1>;
@@ -186,8 +186,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -389,8 +389,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -752,8 +752,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -932,8 +932,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -1143,8 +1143,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -1244,8 +1244,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
diff --git a/tests/test_MeshFlatFaceBoundary.cpp b/tests/test_MeshFlatFaceBoundary.cpp
index f7a3ea2fa..f5630ee1d 100644
--- a/tests/test_MeshFlatFaceBoundary.cpp
+++ b/tests/test_MeshFlatFaceBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R1 = TinyVector<1>;
@@ -186,8 +186,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -345,8 +345,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -532,8 +532,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -712,8 +712,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -923,8 +923,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -1024,8 +1024,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
diff --git a/tests/test_MeshFlatNodeBoundary.cpp b/tests/test_MeshFlatNodeBoundary.cpp
index bb5cbff8a..60348c53b 100644
--- a/tests/test_MeshFlatNodeBoundary.cpp
+++ b/tests/test_MeshFlatNodeBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R1 = TinyVector<1>;
@@ -186,8 +186,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -389,8 +389,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -752,8 +752,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -932,8 +932,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -1143,8 +1143,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -1237,8 +1237,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -1350,8 +1350,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -1451,8 +1451,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
diff --git a/tests/test_MeshLineEdgeBoundary.cpp b/tests/test_MeshLineEdgeBoundary.cpp
index 7eb85182b..39a93e888 100644
--- a/tests/test_MeshLineEdgeBoundary.cpp
+++ b/tests/test_MeshLineEdgeBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -253,8 +253,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -552,8 +552,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -732,8 +732,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -929,8 +929,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -1030,8 +1030,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
diff --git a/tests/test_MeshLineFaceBoundary.cpp b/tests/test_MeshLineFaceBoundary.cpp
index dc0a1b8f8..559986225 100644
--- a/tests/test_MeshLineFaceBoundary.cpp
+++ b/tests/test_MeshLineFaceBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshLineFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -256,8 +256,8 @@ TEST_CASE("MeshLineFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -439,8 +439,8 @@ TEST_CASE("MeshLineFaceBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
diff --git a/tests/test_MeshLineNodeBoundary.cpp b/tests/test_MeshLineNodeBoundary.cpp
index cccc65686..748c45335 100644
--- a/tests/test_MeshLineNodeBoundary.cpp
+++ b/tests/test_MeshLineNodeBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -253,8 +253,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -552,8 +552,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -732,8 +732,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
@@ -929,8 +929,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R2 = TinyVector<2>;
@@ -1030,8 +1030,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
using R3 = TinyVector<3>;
diff --git a/tests/test_MeshNodeBoundary.cpp b/tests/test_MeshNodeBoundary.cpp
index b91de432f..68d398095 100644
--- a/tests/test_MeshNodeBoundary.cpp
+++ b/tests/test_MeshNodeBoundary.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("cartesian 1d")
{
@@ -120,8 +120,8 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("cartesian 2d")
{
@@ -194,8 +194,8 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("cartesian 3d")
{
@@ -284,8 +284,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -302,8 +301,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -319,8 +317,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -336,8 +333,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshNodeInterface.cpp b/tests/test_MeshNodeInterface.cpp
index 88884df79..f8ce8a5fb 100644
--- a/tests/test_MeshNodeInterface.cpp
+++ b/tests/test_MeshNodeInterface.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("unordered 1d")
{
@@ -87,8 +87,8 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("hybrid 2d")
{
@@ -127,8 +127,8 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
SECTION("hybrid 3d")
{
@@ -169,8 +169,7 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -187,8 +186,7 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
{
static constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -204,8 +202,7 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
{
static constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
@@ -221,8 +218,7 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
{
static constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
const MeshType& mesh = *p_mesh->get<MeshType>();
diff --git a/tests/test_ParallelChecker_read.cpp b/tests/test_ParallelChecker_read.cpp
index b7996db7b..026cd4063 100644
--- a/tests/test_ParallelChecker_read.cpp
+++ b/tests/test_ParallelChecker_read.cpp
@@ -199,7 +199,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
{
// ItemValues
{ // 1d
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -363,7 +363,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
const Connectivity<1>& other_connectivity = other_mesh->connectivity();
CellValue<double> other_shape{other_connectivity};
@@ -377,7 +377,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// ItemArray
{ // 1d
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -503,7 +503,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
const Connectivity<1>& other_connectivity = other_mesh->connectivity();
CellArray<double> other_shape{other_connectivity, 2};
@@ -517,7 +517,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// ItemValues
{ // 2d
- auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -610,7 +610,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// ItemArray
{ // 2d
- auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -747,7 +747,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
const Connectivity<2>& other_connectivity = other_mesh->connectivity();
FaceArray<DataType> other_shape{other_connectivity, 2};
@@ -761,7 +761,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// ItemValues
{ // 3d
- auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -858,7 +858,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// ItemArray
{ // 3d
- auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -991,7 +991,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
const Connectivity<2>& other_connectivity = other_mesh->connectivity();
FaceArray<DataType> other_shape{other_connectivity, 2};
@@ -1007,7 +1007,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
{
// SubItemValuePerItem
{ // 1d
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -1198,7 +1198,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
const Connectivity<1>& other_connectivity = other_mesh->connectivity();
CellValuePerNode<double> other_shape{other_connectivity};
@@ -1212,7 +1212,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// SubItemArrayPerItem
{ // 1d
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -1352,7 +1352,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
const Connectivity<1>& other_connectivity = other_mesh->connectivity();
CellArray<double> other_shape{other_connectivity, 2};
@@ -1366,7 +1366,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// SubItemValuePerItem
{ // 2d
- auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -1503,7 +1503,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
const Connectivity<2>& other_connectivity = other_mesh->connectivity();
FaceArray<DataType> other_shape{other_connectivity, 2};
@@ -1517,7 +1517,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// SubItemArrayPerItem
{ // 2d
- auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -1708,7 +1708,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
const Connectivity<2>& other_connectivity = other_mesh->connectivity();
CellValuePerNode<double> other_shape{other_connectivity};
@@ -1722,7 +1722,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// SubItemValuePerItem
{ // 3d
- auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -1855,7 +1855,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
const Connectivity<2>& other_connectivity = other_mesh->connectivity();
FaceArray<DataType> other_shape{other_connectivity, 2};
@@ -1868,7 +1868,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
// SubItemArrayPerItem
{ // 3d
- auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
std::string filename = ParallelChecker::instance().filename();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -2008,7 +2008,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- auto other_mesh = MeshDataBaseForTests::get().cartesian3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto other_mesh = MeshDataBaseForTests::get().cartesian3DMesh()->get<Mesh<3>>();
const Connectivity<3>& other_connectivity = other_mesh->connectivity();
CellArray<double> other_shape{other_connectivity, 2};
@@ -2046,7 +2046,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
REQUIRE_NOTHROW(ParallelChecker::instance().setMode(ParallelChecker::Mode::read));
REQUIRE_NOTHROW(not ParallelChecker::instance().isWriting());
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh->connectivity();
diff --git a/tests/test_ParallelChecker_write.cpp b/tests/test_ParallelChecker_write.cpp
index d9237c7da..e34165999 100644
--- a/tests/test_ParallelChecker_write.cpp
+++ b/tests/test_ParallelChecker_write.cpp
@@ -131,7 +131,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
// ItemValues
{ // 1d
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -172,7 +172,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
}
{ // 2d
- auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -202,7 +202,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
}
{ // 3d
- auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -244,7 +244,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
// ItemArrays
{ // 1d
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -285,7 +285,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
}
{ // 2d
- auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -315,7 +315,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
}
{ // 3d
- auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -394,7 +394,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
// ItemValues
{ // 1d
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -424,7 +424,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
}
{ // 2d
- auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -454,7 +454,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
}
{ // 3d
- auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -485,7 +485,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
// ItemArrays
{ // 1d
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh->connectivity();
@@ -515,7 +515,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
}
{ // 2d
- auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh->connectivity();
@@ -545,7 +545,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
}
{ // 3d
- auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh->connectivity();
@@ -620,7 +620,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
REQUIRE_NOTHROW(ParallelChecker::instance().setMode(ParallelChecker::Mode::automatic));
REQUIRE_NOTHROW(ParallelChecker::instance().isWriting() == (parallel::size() == 1));
- auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh->connectivity();
diff --git a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
index 76882047e..68a2301df 100644
--- a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
@@ -17,8 +17,8 @@ TEST_CASE("PrimalToDiamondDualConnectivityDataMapper", "[mesh]")
{
constexpr static size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
@@ -44,8 +44,8 @@ TEST_CASE("PrimalToDiamondDualConnectivityDataMapper", "[mesh]")
{
constexpr static size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
@@ -223,8 +223,8 @@ TEST_CASE("PrimalToDiamondDualConnectivityDataMapper", "[mesh]")
{
constexpr static size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_PrimalToDual1DConnectivityDataMapper.cpp b/tests/test_PrimalToDual1DConnectivityDataMapper.cpp
index df4e58046..10a6fc4b7 100644
--- a/tests/test_PrimalToDual1DConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToDual1DConnectivityDataMapper.cpp
@@ -14,8 +14,8 @@ TEST_CASE("PrimalToDual1DConnectivityDataMapper", "[mesh]")
{
constexpr static size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
index 7c9a25d68..7fb1e02a0 100644
--- a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
@@ -17,8 +17,8 @@ TEST_CASE("PrimalToMedianDualConnectivityDataMapper", "[mesh]")
{
constexpr static size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
@@ -44,8 +44,8 @@ TEST_CASE("PrimalToMedianDualConnectivityDataMapper", "[mesh]")
{
constexpr static size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
- using MeshType = Mesh<ConnectivityType>;
+ using MeshType = Mesh<Dimension>;
+ using ConnectivityType = typename MeshType::Connectivity;
std::shared_ptr<const MeshType> mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<MeshType>();
const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_SubItemArrayPerItem.cpp b/tests/test_SubItemArrayPerItem.cpp
index f027c56be..23f32a41b 100644
--- a/tests/test_SubItemArrayPerItem.cpp
+++ b/tests/test_SubItemArrayPerItem.cpp
@@ -69,7 +69,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -192,7 +192,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -358,7 +358,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -555,7 +555,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -628,7 +628,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -700,7 +700,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -772,7 +772,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -883,7 +883,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -994,7 +994,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -1068,7 +1068,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
SECTION("checking invalid table size in constructor")
{
- auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -1090,7 +1090,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
diff --git a/tests/test_SubItemArrayPerItemUtils.cpp b/tests/test_SubItemArrayPerItemUtils.cpp
index 8d4c75167..1ff8bb17f 100644
--- a/tests/test_SubItemArrayPerItemUtils.cpp
+++ b/tests/test_SubItemArrayPerItemUtils.cpp
@@ -23,7 +23,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -95,7 +95,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -127,7 +127,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -159,7 +159,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -194,7 +194,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -226,7 +226,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -258,7 +258,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -294,7 +294,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -324,7 +324,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name() + " for size_t data")
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -347,7 +347,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
SECTION(named_mesh.name() + " for N^2 data")
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -373,7 +373,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
SECTION(named_mesh.name() + " for float data")
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -417,7 +417,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name() + " for size_t data")
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -440,7 +440,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
SECTION(named_mesh.name() + " for N^2x3 data")
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -466,7 +466,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
SECTION(named_mesh.name() + " for R^2x3 data")
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
diff --git a/tests/test_SubItemArrayPerItemVariant.cpp b/tests/test_SubItemArrayPerItemVariant.cpp
index e40386701..7a224e10a 100644
--- a/tests/test_SubItemArrayPerItemVariant.cpp
+++ b/tests/test_SubItemArrayPerItemVariant.cpp
@@ -11,9 +11,9 @@
TEST_CASE("SubItemArrayPerItemVariant", "[mesh]")
{
- std::shared_ptr mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ std::shared_ptr mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
- const Connectivity<3>& connectivity = *mesh->shared_connectivity();
+ const Connectivity<3>& connectivity = mesh->connectivity();
using R1 = TinyVector<1>;
using R2 = TinyVector<2>;
diff --git a/tests/test_SubItemValuePerItem.cpp b/tests/test_SubItemValuePerItem.cpp
index 92569d982..72b794bb1 100644
--- a/tests/test_SubItemValuePerItem.cpp
+++ b/tests/test_SubItemValuePerItem.cpp
@@ -79,7 +79,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -215,7 +215,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -391,7 +391,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -596,7 +596,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -712,7 +712,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -898,7 +898,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -1119,7 +1119,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -1164,7 +1164,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -1208,7 +1208,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -1254,7 +1254,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -1353,7 +1353,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -1420,7 +1420,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
SECTION("checking invalid array size in constructor")
{
- auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -1442,7 +1442,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
diff --git a/tests/test_SubItemValuePerItemUtils.cpp b/tests/test_SubItemValuePerItemUtils.cpp
index ee73b6072..69214c1c9 100644
--- a/tests/test_SubItemValuePerItemUtils.cpp
+++ b/tests/test_SubItemValuePerItemUtils.cpp
@@ -23,7 +23,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -90,7 +90,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -120,7 +120,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -150,7 +150,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -183,7 +183,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -213,7 +213,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -243,7 +243,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -278,7 +278,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name())
{
- auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+ auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
const Connectivity<1>& connectivity = mesh_1d->connectivity();
@@ -307,7 +307,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name() + " for size_t data")
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -329,7 +329,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
SECTION(named_mesh.name() + " for R^2 data")
{
- auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+ auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
const Connectivity<2>& connectivity = mesh_2d->connectivity();
@@ -366,7 +366,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
for (const auto& named_mesh : mesh_list) {
SECTION(named_mesh.name() + " for size_t data")
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -388,7 +388,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
SECTION(named_mesh.name() + " for N^2x3 data")
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
@@ -413,7 +413,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
SECTION(named_mesh.name() + " for R^3x2 float")
{
- auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+ auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
const Connectivity<3>& connectivity = mesh_3d->connectivity();
diff --git a/tests/test_SubItemValuePerItemVariant.cpp b/tests/test_SubItemValuePerItemVariant.cpp
index 01ff40651..28f62ace4 100644
--- a/tests/test_SubItemValuePerItemVariant.cpp
+++ b/tests/test_SubItemValuePerItemVariant.cpp
@@ -11,9 +11,9 @@
TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
{
- std::shared_ptr mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+ std::shared_ptr mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
- const Connectivity<3>& connectivity = *mesh->shared_connectivity();
+ const Connectivity<3>& connectivity = mesh->connectivity();
using R1 = TinyVector<1>;
using R2 = TinyVector<2>;
diff --git a/tests/test_Synchronizer.cpp b/tests/test_Synchronizer.cpp
index e14aff66a..b54f9321a 100644
--- a/tests/test_Synchronizer.cpp
+++ b/tests/test_Synchronizer.cpp
@@ -29,7 +29,7 @@ TEST_CASE("Synchronizer", "[mesh]")
using ConnectivityType = Connectivity<Dimension>;
const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>()->connectivity();
+ MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>()->connectivity();
SECTION("synchonize NodeValue")
{
@@ -137,8 +137,7 @@ TEST_CASE("Synchronizer", "[mesh]")
constexpr size_t Dimension = 2;
using ConnectivityType = Connectivity<Dimension>;
- const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>()->connectivity();
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>()->connectivity();
SECTION("synchonize NodeValue")
{
@@ -246,8 +245,7 @@ TEST_CASE("Synchronizer", "[mesh]")
constexpr size_t Dimension = 3;
using ConnectivityType = Connectivity<Dimension>;
- const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>()->connectivity();
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>()->connectivity();
SECTION("synchonize NodeValue")
{
@@ -370,7 +368,7 @@ TEST_CASE("Synchronizer", "[mesh]")
using ConnectivityType = Connectivity<Dimension>;
const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>()->connectivity();
+ MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>()->connectivity();
SECTION("synchonize NodeArray")
{
@@ -502,8 +500,7 @@ TEST_CASE("Synchronizer", "[mesh]")
constexpr size_t Dimension = 2;
using ConnectivityType = Connectivity<Dimension>;
- const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>()->connectivity();
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>()->connectivity();
SECTION("synchonize NodeArray")
{
@@ -635,8 +632,7 @@ TEST_CASE("Synchronizer", "[mesh]")
constexpr size_t Dimension = 3;
using ConnectivityType = Connectivity<Dimension>;
- const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>()->connectivity();
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>()->connectivity();
SECTION("synchonize NodeArray")
{
@@ -796,7 +792,7 @@ TEST_CASE("Synchronizer", "[mesh]")
using ConnectivityType = Connectivity<Dimension>;
const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>()->connectivity();
+ MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>()->connectivity();
SECTION("synchonize NodeValuePerCell")
{
@@ -1071,8 +1067,7 @@ TEST_CASE("Synchronizer", "[mesh]")
constexpr size_t Dimension = 2;
using ConnectivityType = Connectivity<Dimension>;
- const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>()->connectivity();
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>()->connectivity();
SECTION("synchonize NodeValuePerCell")
{
@@ -1525,8 +1520,7 @@ TEST_CASE("Synchronizer", "[mesh]")
constexpr size_t Dimension = 3;
using ConnectivityType = Connectivity<Dimension>;
- const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>()->connectivity();
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>()->connectivity();
SECTION("synchonize NodeValuePerCell")
{
@@ -2103,7 +2097,7 @@ TEST_CASE("Synchronizer", "[mesh]")
using ConnectivityType = Connectivity<Dimension>;
const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>()->connectivity();
+ MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>()->connectivity();
SECTION("synchonize NodeArrayPerCell")
{
@@ -2408,8 +2402,7 @@ TEST_CASE("Synchronizer", "[mesh]")
constexpr size_t Dimension = 2;
using ConnectivityType = Connectivity<Dimension>;
- const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>()->connectivity();
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>()->connectivity();
SECTION("synchonize NodeArrayPerCell")
{
@@ -2912,8 +2905,7 @@ TEST_CASE("Synchronizer", "[mesh]")
constexpr size_t Dimension = 3;
using ConnectivityType = Connectivity<Dimension>;
- const ConnectivityType& connectivity =
- MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>()->connectivity();
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>()->connectivity();
SECTION("synchonize NodeArrayPerCell")
{
--
GitLab