From 60e213fce18bd59c96612ff881880414f9f8cc05 Mon Sep 17 00:00:00 2001
From: Stephane Del Pino <stephane.delpino44@gmail.com>
Date: Fri, 29 Mar 2019 18:17:58 +0100
Subject: [PATCH] Continue clean-up
Use more ItemOfItem structure to improve readability
---
src/mesh/Connectivity.hpp | 4 +-
src/mesh/ConnectivityComputer.cpp | 106 ++++++++++++++++++++---------
src/mesh/ConnectivityComputer.hpp | 5 +-
src/mesh/IConnectivity.hpp | 7 +-
src/mesh/ItemOfItemType.hpp | 9 +--
src/mesh/SubItemValuePerItem.hpp | 107 +++++++++++++++---------------
6 files changed, 138 insertions(+), 100 deletions(-)
diff --git a/src/mesh/Connectivity.hpp b/src/mesh/Connectivity.hpp
index e07a26a27..4c19ae6b5 100644
--- a/src/mesh/Connectivity.hpp
+++ b/src/mesh/Connectivity.hpp
@@ -158,11 +158,11 @@ class Connectivity final
const SubItemValuePerItemType&
_lazzyBuildItemNumberInTheirChild(const SubItemValuePerItemType& sub_item_value_per_item) const
{
+ using ReversedItemOfItem = typename SubItemValuePerItemType::ItemOfItemType::Reversed;
if (not sub_item_value_per_item.isBuilt()) {
const_cast<SubItemValuePerItemType&>(sub_item_value_per_item)
= m_connectivity_computer
- . computeLocalItemNumberInChildItem<SubItemValuePerItemType::item_t,
- SubItemValuePerItemType::sub_item_t>(*this);
+ . computeLocalItemNumberInChildItem<ReversedItemOfItem>(*this);
}
return sub_item_value_per_item;
}
diff --git a/src/mesh/ConnectivityComputer.cpp b/src/mesh/ConnectivityComputer.cpp
index b82037098..294b15591 100644
--- a/src/mesh/ConnectivityComputer.cpp
+++ b/src/mesh/ConnectivityComputer.cpp
@@ -76,18 +76,22 @@ _computeInverse(const ConnectivityMatrix& item_to_child_matrix) const
return ConnectivityMatrix(child_to_items_vector);
}
-template <ItemType item_type,
- ItemType child_item_type,
+template <typename ItemOfItem,
typename ConnectivityType>
-WeakSubItemValuePerItem<const unsigned short, child_item_type, item_type>
+WeakSubItemValuePerItem<const unsigned short, typename ItemOfItem::Reversed>
ConnectivityComputer::computeLocalItemNumberInChildItem(const ConnectivityType& connectivity) const
{
+ using ReversedItemOfItem = typename ItemOfItem::Reversed;
+
+ constexpr ItemType item_type = ReversedItemOfItem::item_type;
+ constexpr ItemType child_item_type = ReversedItemOfItem::sub_item_type;
+
const ConnectivityMatrix& child_item_to_items_matrix
= connectivity._getMatrix(child_item_type, item_type);
const ConnectivityMatrix& item_to_child_items_matrix
= connectivity._getMatrix(item_type, child_item_type);
- WeakSubItemValuePerItem<unsigned short, child_item_type, item_type> item_number_in_child_item(connectivity);
+ WeakSubItemValuePerItem<unsigned short, ReversedItemOfItem> item_number_in_child_item(connectivity);
for (ItemIdT<item_type> r=0; r<item_to_child_items_matrix.numRows(); ++r) {
const auto& item_to_child_items = item_to_child_items_matrix.rowConst(r);
for (unsigned short J=0; J<item_to_child_items.length; ++J) {
@@ -108,51 +112,89 @@ ConnectivityComputer::computeLocalItemNumberInChildItem(const ConnectivityType&
// 1D
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::node>
+template WeakSubItemValuePerItem<const unsigned short, CellOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfCell>(const Connectivity1D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, NodeOfCell>
ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::node,
- ItemType::cell>(const Connectivity1D&) const;
+computeLocalItemNumberInChildItem<CellOfNode>(const Connectivity1D&) const;
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::face>
+// 2D
+
+template WeakSubItemValuePerItem<const unsigned short, CellOfNode>
ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::face,
- ItemType::cell>(const Connectivity1D&) const;
+computeLocalItemNumberInChildItem<NodeOfCell>(const Connectivity2D&) const;
-template WeakSubItemValuePerItem<const unsigned short, ItemType::node, ItemType::cell>
+template WeakSubItemValuePerItem<const unsigned short, CellOfFace>
ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::cell,
- ItemType::node>(const Connectivity1D&) const;
+computeLocalItemNumberInChildItem<FaceOfCell>(const Connectivity2D&) const;
-// 2D
+template WeakSubItemValuePerItem<const unsigned short, FaceOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfFace>(const Connectivity2D&) const;
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::node>
+template WeakSubItemValuePerItem<const unsigned short, FaceOfCell>
ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::node,
- ItemType::cell>(const Connectivity2D&) const;
+computeLocalItemNumberInChildItem<CellOfFace>(const Connectivity2D&) const;
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::face>
+template WeakSubItemValuePerItem<const unsigned short, NodeOfFace>
ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::face,
- ItemType::cell>(const Connectivity2D&) const;
+computeLocalItemNumberInChildItem<FaceOfNode>(const Connectivity2D&) const;
-template WeakSubItemValuePerItem<const unsigned short, ItemType::node, ItemType::cell>
+template WeakSubItemValuePerItem<const unsigned short, NodeOfCell>
ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::cell,
- ItemType::node>(const Connectivity2D&) const;
+computeLocalItemNumberInChildItem<CellOfNode>(const Connectivity2D&) const;
// 3D
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::node>
+template WeakSubItemValuePerItem<const unsigned short, CellOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfCell>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, CellOfEdge>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<EdgeOfCell>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, CellOfFace>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<FaceOfCell>(const Connectivity3D&) const;
+
+
+template WeakSubItemValuePerItem<const unsigned short, FaceOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfFace>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, FaceOfEdge>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<EdgeOfFace>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, FaceOfCell>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<CellOfFace>(const Connectivity3D&) const;
+
+
+template WeakSubItemValuePerItem<const unsigned short, EdgeOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfEdge>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, EdgeOfFace>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<FaceOfEdge>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, EdgeOfCell>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<CellOfEdge>(const Connectivity3D&) const;
+
+
+template WeakSubItemValuePerItem<const unsigned short, NodeOfEdge>
ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::node,
- ItemType::cell>(const Connectivity3D&) const;
+computeLocalItemNumberInChildItem<EdgeOfNode>(const Connectivity3D&) const;
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::face>
+template WeakSubItemValuePerItem<const unsigned short, NodeOfFace>
ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::face,
- ItemType::cell>(const Connectivity3D&) const;
+computeLocalItemNumberInChildItem<FaceOfNode>(const Connectivity3D&) const;
-template WeakSubItemValuePerItem<const unsigned short, ItemType::node, ItemType::cell>
+template WeakSubItemValuePerItem<const unsigned short, NodeOfCell>
ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::cell,
- ItemType::node>(const Connectivity3D&) const;
+computeLocalItemNumberInChildItem<CellOfNode>(const Connectivity3D&) const;
diff --git a/src/mesh/ConnectivityComputer.hpp b/src/mesh/ConnectivityComputer.hpp
index 17b620459..d5c6019d5 100644
--- a/src/mesh/ConnectivityComputer.hpp
+++ b/src/mesh/ConnectivityComputer.hpp
@@ -18,10 +18,9 @@ class ConnectivityComputer
const ItemType& child_item_type) const;
- template <ItemType item_type,
- ItemType child_item_type,
+ template <typename ItemOfItem,
typename ConnectivityType>
- WeakSubItemValuePerItem<const unsigned short, child_item_type, item_type>
+ WeakSubItemValuePerItem<const unsigned short, typename ItemOfItem::Reversed>
computeLocalItemNumberInChildItem(const ConnectivityType& connectivity) const;
ConnectivityComputer(const ConnectivityComputer&) = default;
diff --git a/src/mesh/IConnectivity.hpp b/src/mesh/IConnectivity.hpp
index 359c9c75c..63ae03f3a 100644
--- a/src/mesh/IConnectivity.hpp
+++ b/src/mesh/IConnectivity.hpp
@@ -2,6 +2,7 @@
#define ICONNECTIVITY_HPP
#include <ItemType.hpp>
+#include <ItemOfItemType.hpp>
#include <ConnectivityMatrix.hpp>
#include <memory>
@@ -9,10 +10,8 @@ class IConnectivity : public std::enable_shared_from_this<IConnectivity>
{
protected:
template <typename DataType,
- ItemType sub_item_type,
- ItemType item_type,
- typename ConnectivityPtr,
- typename Allowed>
+ typename ItemOfItem,
+ typename ConnectivityPtr>
friend
class SubItemValuePerItem;
diff --git a/src/mesh/ItemOfItemType.hpp b/src/mesh/ItemOfItemType.hpp
index ce588bb9a..53a7d5ffe 100644
--- a/src/mesh/ItemOfItemType.hpp
+++ b/src/mesh/ItemOfItemType.hpp
@@ -3,7 +3,6 @@
#include <ItemType.hpp>
-#warning Should use this type in all sub item constructions
template <ItemType sub_item_t,
ItemType item_t>
struct ItemOfItemType
@@ -12,21 +11,23 @@ struct ItemOfItemType
constexpr static ItemType sub_item_type = sub_item_t;
constexpr static ItemType item_type = item_t;
+
+ using Reversed = ItemOfItemType<item_type, sub_item_type>;
};
using FaceOfCell = ItemOfItemType<ItemType::face, ItemType::cell>;
using EdgeOfCell = ItemOfItemType<ItemType::edge, ItemType::cell>;
using NodeOfCell = ItemOfItemType<ItemType::node, ItemType::cell>;
-using CellofFace = ItemOfItemType<ItemType::cell, ItemType::face>;
+using CellOfFace = ItemOfItemType<ItemType::cell, ItemType::face>;
using EdgeOfFace = ItemOfItemType<ItemType::edge, ItemType::face>;
using NodeOfFace = ItemOfItemType<ItemType::node, ItemType::face>;
-using CellofEdge = ItemOfItemType<ItemType::cell, ItemType::edge>;
+using CellOfEdge = ItemOfItemType<ItemType::cell, ItemType::edge>;
using FaceOfEdge = ItemOfItemType<ItemType::face, ItemType::edge>;
using NodeOfEdge = ItemOfItemType<ItemType::node, ItemType::edge>;
-using CellofNode = ItemOfItemType<ItemType::cell, ItemType::node>;
+using CellOfNode = ItemOfItemType<ItemType::cell, ItemType::node>;
using FaceOfNode = ItemOfItemType<ItemType::face, ItemType::node>;
using EdgeOfNode = ItemOfItemType<ItemType::edge, ItemType::node>;
diff --git a/src/mesh/SubItemValuePerItem.hpp b/src/mesh/SubItemValuePerItem.hpp
index 2460e971c..821acbd2b 100644
--- a/src/mesh/SubItemValuePerItem.hpp
+++ b/src/mesh/SubItemValuePerItem.hpp
@@ -6,35 +6,37 @@
#include <PastisAssert.hpp>
#include <Array.hpp>
-#include <ItemType.hpp>
#include <ItemId.hpp>
#include <ConnectivityMatrix.hpp>
#include <IConnectivity.hpp>
+
+#include <ItemType.hpp>
+#include <ItemOfItemType.hpp>
+
#include <memory>
-template <typename DataType,
- ItemType sub_item_type,
- ItemType item_type,
- typename ConnectivityPtr = std::shared_ptr<const IConnectivity>,
- typename Allowed=void>
-class SubItemValuePerItem;
+// template <typename DataType,
+// typename ItemOfItem,
+// typename ConnectivityPtr = std::shared_ptr<const IConnectivity>,
+// typename Allowed=void>
+// class SubItemValuePerItem;
template <typename DataType,
- ItemType sub_item_type,
- ItemType item_type,
- typename ConnectivityPtr>
-class SubItemValuePerItem<DataType,
- sub_item_type,
- item_type,
- ConnectivityPtr,
- std::enable_if_t<sub_item_type != item_type>>
+ typename ItemOfItem,
+ typename ConnectivityPtr = std::shared_ptr<const IConnectivity>>
+class SubItemValuePerItem// <DataType,
+ // ItemOfItem,
+ // ConnectivityPtr// ,
+ // // std::enable_if_t<sub_item_type != item_type>
+ // >
{
public:
- static const ItemType item_t{item_type};
- static const ItemType sub_item_t{sub_item_type};
+ static constexpr ItemType item_type{ItemOfItem::item_type};
+ static constexpr ItemType sub_item_type{ItemOfItem::sub_item_type};
+ using ItemOfItemType = ItemOfItem;
using data_type = DataType;
using ItemId = ItemIdT<item_type>;
using index_type = ItemId;
@@ -53,22 +55,18 @@ class SubItemValuePerItem<DataType,
// Allow const std:shared_ptr version to access our data
friend SubItemValuePerItem<std::add_const_t<DataType>,
- sub_item_type,
- item_type,
+ ItemOfItem,
ConnectivitySharedPtr>;
// Allow const std:weak_ptr version to access our data
friend SubItemValuePerItem<std::add_const_t<DataType>,
- sub_item_type,
- item_type,
+ ItemOfItem,
ConnectivityWeakPtr>;
public:
using ToShared = SubItemValuePerItem<DataType,
- sub_item_type,
- item_type,
- ConnectivitySharedPtr,
- std::enable_if_t<sub_item_type != item_type>>;
+ ItemOfItem,
+ ConnectivitySharedPtr>;
class SubView
{
@@ -136,7 +134,7 @@ class SubItemValuePerItem<DataType,
PASTIS_FORCEINLINE
DataType& operator()(const IndexType& j, const size_t& r) const noexcept(NO_ASSERT)
{
- static_assert(std::is_same_v<IndexType, size_t>,
+ static_assert(std::is_same_v<IndexType, ItemId>,
"SubItemValuePerItem indexed by ItemId");
Assert(this->isBuilt());
return m_values[m_host_row_map(size_t{j})+r];
@@ -206,7 +204,7 @@ class SubItemValuePerItem<DataType,
typename ConnectivityPtr2>
PASTIS_INLINE
SubItemValuePerItem&
- operator=(const SubItemValuePerItem<DataType2, sub_item_type, item_type, ConnectivityPtr2>& sub_item_value_per_item) noexcept
+ operator=(const SubItemValuePerItem<DataType2, ItemOfItem, ConnectivityPtr2>& sub_item_value_per_item) noexcept
{
// ensures that DataType is the same as source DataType2
static_assert(std::is_same_v<std::remove_const_t<DataType>, std::remove_const_t<DataType2>>,
@@ -231,7 +229,7 @@ class SubItemValuePerItem<DataType,
template <typename DataType2,
typename ConnectivityPtr2>
PASTIS_INLINE
- SubItemValuePerItem(const SubItemValuePerItem<DataType2, sub_item_type, item_type, ConnectivityPtr2>& sub_item_value_per_item) noexcept
+ SubItemValuePerItem(const SubItemValuePerItem<DataType2, ItemOfItem, ConnectivityPtr2>& sub_item_value_per_item) noexcept
{
this->operator=(sub_item_value_per_item);
}
@@ -257,95 +255,94 @@ class SubItemValuePerItem<DataType,
// Item values at nodes
template <typename DataType>
-using NodeValuePerEdge = SubItemValuePerItem<DataType, ItemType::node, ItemType::edge>;
+using NodeValuePerEdge = SubItemValuePerItem<DataType, NodeOfEdge>;
template <typename DataType>
-using NodeValuePerFace = SubItemValuePerItem<DataType, ItemType::node, ItemType::face>;
+using NodeValuePerFace = SubItemValuePerItem<DataType, NodeOfFace>;
template <typename DataType>
-using NodeValuePerCell = SubItemValuePerItem<DataType, ItemType::node, ItemType::cell>;
+using NodeValuePerCell = SubItemValuePerItem<DataType, NodeOfCell>;
// Item values at edges
template <typename DataType>
-using EdgeValuePerNode = SubItemValuePerItem<DataType, ItemType::edge, ItemType::node>;
+using EdgeValuePerNode = SubItemValuePerItem<DataType, EdgeOfNode>;
template <typename DataType>
-using EdgeValuePerFace = SubItemValuePerItem<DataType, ItemType::edge, ItemType::face>;
+using EdgeValuePerFace = SubItemValuePerItem<DataType, EdgeOfFace>;
template <typename DataType>
-using EdgeValuePerCell = SubItemValuePerItem<DataType, ItemType::edge, ItemType::cell>;
+using EdgeValuePerCell = SubItemValuePerItem<DataType, EdgeOfCell>;
// Item values at faces
template <typename DataType>
-using FaceValuePerNode = SubItemValuePerItem<DataType, ItemType::face, ItemType::node>;
+using FaceValuePerNode = SubItemValuePerItem<DataType, FaceOfNode>;
template <typename DataType>
-using FaceValuePerEdge = SubItemValuePerItem<DataType, ItemType::face, ItemType::edge>;
+using FaceValuePerEdge = SubItemValuePerItem<DataType, FaceOfEdge>;
template <typename DataType>
-using FaceValuePerCell = SubItemValuePerItem<DataType, ItemType::face, ItemType::cell>;
+using FaceValuePerCell = SubItemValuePerItem<DataType, FaceOfCell>;
// Item values at cells
template <typename DataType>
-using CellValuePerNode = SubItemValuePerItem<DataType, ItemType::cell, ItemType::node>;
+using CellValuePerNode = SubItemValuePerItem<DataType, CellOfNode>;
template <typename DataType>
-using CellValuePerEdge = SubItemValuePerItem<DataType, ItemType::cell, ItemType::edge>;
+using CellValuePerEdge = SubItemValuePerItem<DataType, CellOfEdge>;
template <typename DataType>
-using CellValuePerFace = SubItemValuePerItem<DataType, ItemType::cell, ItemType::face>;
+using CellValuePerFace = SubItemValuePerItem<DataType, CellOfFace>;
// Weak versions: should not be used outside of Connectivity
// Item values at nodes
template <typename DataType,
- ItemType sub_item_type,
- ItemType item_type>
-using WeakSubItemValuePerItem = SubItemValuePerItem<DataType, sub_item_type, item_type, std::weak_ptr<const IConnectivity>>;
+ typename ItemOfItem>
+using WeakSubItemValuePerItem = SubItemValuePerItem<DataType, ItemOfItem, std::weak_ptr<const IConnectivity>>;
template <typename DataType>
-using WeakNodeValuePerEdge = WeakSubItemValuePerItem<DataType, ItemType::node, ItemType::edge>;
+using WeakNodeValuePerEdge = WeakSubItemValuePerItem<DataType, NodeOfEdge>;
template <typename DataType>
-using WeakNodeValuePerFace = WeakSubItemValuePerItem<DataType, ItemType::node, ItemType::face>;
+using WeakNodeValuePerFace = WeakSubItemValuePerItem<DataType, NodeOfFace>;
template <typename DataType>
-using WeakNodeValuePerCell = WeakSubItemValuePerItem<DataType, ItemType::node, ItemType::cell>;
+using WeakNodeValuePerCell = WeakSubItemValuePerItem<DataType, NodeOfCell>;
// Item values at edges
template <typename DataType>
-using WeakEdgeValuePerNode = WeakSubItemValuePerItem<DataType, ItemType::edge, ItemType::node>;
+using WeakEdgeValuePerNode = WeakSubItemValuePerItem<DataType, EdgeOfNode>;
template <typename DataType>
-using WeakEdgeValuePerFace = WeakSubItemValuePerItem<DataType, ItemType::edge, ItemType::face>;
+using WeakEdgeValuePerFace = WeakSubItemValuePerItem<DataType, EdgeOfFace>;
template <typename DataType>
-using WeakEdgeValuePerCell = WeakSubItemValuePerItem<DataType, ItemType::edge, ItemType::cell>;
+using WeakEdgeValuePerCell = WeakSubItemValuePerItem<DataType, EdgeOfCell>;
// Item values at faces
template <typename DataType>
-using WeakFaceValuePerNode = WeakSubItemValuePerItem<DataType, ItemType::face, ItemType::node>;
+using WeakFaceValuePerNode = WeakSubItemValuePerItem<DataType, FaceOfNode>;
template <typename DataType>
-using WeakFaceValuePerEdge = WeakSubItemValuePerItem<DataType, ItemType::face, ItemType::edge>;
+using WeakFaceValuePerEdge = WeakSubItemValuePerItem<DataType, FaceOfEdge>;
template <typename DataType>
-using WeakFaceValuePerCell = WeakSubItemValuePerItem<DataType, ItemType::face, ItemType::cell>;
+using WeakFaceValuePerCell = WeakSubItemValuePerItem<DataType, FaceOfCell>;
// Item values at cells
template <typename DataType>
-using WeakCellValuePerNode = WeakSubItemValuePerItem<DataType, ItemType::cell, ItemType::node>;
+using WeakCellValuePerNode = WeakSubItemValuePerItem<DataType, CellOfNode>;
template <typename DataType>
-using WeakCellValuePerEdge = WeakSubItemValuePerItem<DataType, ItemType::cell, ItemType::edge>;
+using WeakCellValuePerEdge = WeakSubItemValuePerItem<DataType, CellOfEdge>;
template <typename DataType>
-using WeakCellValuePerFace = WeakSubItemValuePerItem<DataType, ItemType::cell, ItemType::face>;
+using WeakCellValuePerFace = WeakSubItemValuePerItem<DataType, CellOfFace>;
#endif // SUBITEM_VALUE_PER_ITEM_HPP
--
GitLab