Skip to content
Snippets Groups Projects
Commit 60e213fc authored by Stéphane Del Pino's avatar Stéphane Del Pino
Browse files

Continue clean-up

Use more ItemOfItem structure to improve readability
parent 862db2db
No related branches found
No related tags found
1 merge request!11Feature/mpi
......@@ -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;
}
......
......@@ -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;
......@@ -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;
......
......@@ -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;
......
......@@ -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>;
......
......@@ -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
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment