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