diff --git a/src/mesh/Connectivity.cpp b/src/mesh/Connectivity.cpp index 5ce0c5aabfaa8a13533c2a3a0da459d9161a163f..93354d6de0cdb2714fa156e7f809aa6b750050d9 100644 --- a/src/mesh/Connectivity.cpp +++ b/src/mesh/Connectivity.cpp @@ -4,13 +4,12 @@ template<> void Connectivity<3>::_computeFaceCellConnectivities() { - Kokkos::View<unsigned short*> cell_nb_faces("cell_nb_faces", this->numberOfCells()); - typedef std::tuple<unsigned int, unsigned short, bool> CellFaceInfo; const auto& cell_to_node_matrix - = m_item_to_item_matrix[itemId(ItemType::cell)][itemId(ItemType::node)]; + = this->getMatrix(ItemType::cell, ItemType::node); + Kokkos::View<unsigned short*> cell_nb_faces("cell_nb_faces", this->numberOfCells()); std::map<Face, std::vector<CellFaceInfo>> face_cells_map; for (unsigned int j=0; j<this->numberOfCells(); ++j) { const auto& cell_nodes = cell_to_node_matrix.rowConst(j); @@ -151,16 +150,6 @@ void Connectivity<3>::_computeFaceCellConnectivities() } } - const auto& cell_to_face_matrix - = m_item_to_item_matrix[itemId(ItemType::cell)][itemId(ItemType::face)]; - auto& face_to_cell_matrix - = m_item_to_item_matrix[itemId(ItemType::face)][itemId(ItemType::cell)]; - m_connectivity_computer.computeInverseConnectivityMatrix(cell_to_face_matrix, - face_to_cell_matrix); - - m_face_local_numbers_in_their_cells - = m_connectivity_computer.computeLocalItemNumberInChildItem<ItemType::face, - ItemType::cell>(*this); #warning check that the number of cell per faces is <=2 } @@ -168,7 +157,7 @@ template<> void Connectivity<2>::_computeFaceCellConnectivities() { const auto& cell_to_node_matrix - = m_item_to_item_matrix[itemId(ItemType::cell)][itemId(ItemType::node)]; + = this->getMatrix(ItemType::cell, ItemType::node); // In 2D faces are simply define typedef std::pair<unsigned int, unsigned short> CellFaceId; @@ -243,12 +232,6 @@ Connectivity(const std::vector<std::vector<unsigned int>>& cell_by_node_vector) m_inv_cell_nb_nodes = inv_cell_nb_nodes; } - auto& node_to_cell_matrix - = m_item_to_item_matrix[itemId(ItemType::node)][itemId(ItemType::cell)]; - - m_connectivity_computer.computeInverseConnectivityMatrix(cell_to_node_matrix, - node_to_cell_matrix); - if constexpr (Dimension>1) { this->_computeFaceCellConnectivities(); } diff --git a/src/mesh/Connectivity.hpp b/src/mesh/Connectivity.hpp index 420dbb8d0bce68a4aada4178bf78c3599e51c74c..6647cecb9f0b6348a942bd8ddf649f02425097d8 100644 --- a/src/mesh/Connectivity.hpp +++ b/src/mesh/Connectivity.hpp @@ -275,16 +275,29 @@ class Connectivity final } public: - template <ItemType item_type_0, ItemType item_type_1> - const ConnectivityMatrix& itemToItemMatrix() const + + KOKKOS_INLINE_FUNCTION + const bool& isConnectivityMatrixBuilt(const ItemType& item_type_0, + const ItemType& item_type_1) const { - return m_item_to_item_matrix[itemId(item_type_0)][itemId(item_type_1)]; - }; + const ConnectivityMatrix& connectivity_matrix + = m_item_to_item_matrix[itemId(item_type_0)][itemId(item_type_1)]; + return connectivity_matrix.isBuilt(); + } + KOKKOS_INLINE_FUNCTION const ConnectivityMatrix& getMatrix(const ItemType& item_type_0, const ItemType& item_type_1) const { - return m_item_to_item_matrix[itemId(item_type_0)][itemId(item_type_1)]; + const ConnectivityMatrix& connectivity_matrix + = m_item_to_item_matrix[itemId(item_type_0)][itemId(item_type_1)]; + if (not connectivity_matrix.isBuilt()) { + const_cast<ConnectivityMatrix&>(connectivity_matrix) + = m_connectivity_computer + . computeConnectivityMatrix(*this, item_type_0, item_type_1); + + } + return connectivity_matrix; } const auto& cellFaceIsReversed() const @@ -352,7 +365,7 @@ class Connectivity final size_t numberOfNodes() const { const auto& node_to_cell_matrix - = m_item_to_item_matrix[itemId(ItemType::node)][itemId(ItemType::cell)]; + = this->getMatrix(ItemType::node,ItemType::cell); return node_to_cell_matrix.numRows(); } @@ -360,7 +373,7 @@ class Connectivity final size_t numberOfFaces() const { const auto& face_to_node_matrix - = m_item_to_item_matrix[itemId(ItemType::face)][itemId(ItemType::node)]; + = this->getMatrix(ItemType::face,ItemType::cell); return face_to_node_matrix.numRows(); } @@ -368,12 +381,13 @@ class Connectivity final size_t numberOfCells() const { const auto& cell_to_node_matrix - = m_item_to_item_matrix[itemId(ItemType::cell)][itemId(ItemType::node)]; + = this->getMatrix(ItemType::cell,ItemType::node); return cell_to_node_matrix.numRows(); } const Kokkos::View<const double*> invCellNbNodes() const { +#warning add calculation on demand when variables will be defined return m_inv_cell_nb_nodes; } diff --git a/src/mesh/ConnectivityComputer.cpp b/src/mesh/ConnectivityComputer.cpp index a128d1ed1939c9c597332da88481ef75f5bdb1bb..336c88170b5a316356814a7a915e6bf4d2930ea9 100644 --- a/src/mesh/ConnectivityComputer.cpp +++ b/src/mesh/ConnectivityComputer.cpp @@ -1,26 +1,61 @@ #include <Connectivity.hpp> -#include <ConnectivityUtils.hpp> #include <ConnectivityComputer.hpp> #include <map> -void ConnectivityComputer:: -computeInverseConnectivityMatrix(const ConnectivityMatrix& item_to_child_item_matrix, - ConnectivityMatrix& child_item_to_item_matrix) const + +template <typename ConnectivityType> +KOKKOS_INLINE_FUNCTION +ConnectivityMatrix ConnectivityComputer:: +computeConnectivityMatrix(const ConnectivityType& connectivity, + const ItemType& item_type, + const ItemType& child_item_type) const { - std::map<unsigned int, std::vector<unsigned int>> child_item_to_item_vector_map; - const size_t& number_of_items = item_to_child_item_matrix.numRows(); + ConnectivityMatrix item_to_child_item_matrix; + if (connectivity.isConnectivityMatrixBuilt(child_item_type, item_type)) { + const ConnectivityMatrix& child_to_item_matrix + = connectivity.getMatrix(child_item_type, item_type); + + item_to_child_item_matrix + = this->_computeInverse(child_to_item_matrix); + } else { + std::cerr << "unable to compute connectivity " << '\n'; + std::exit(0); + } + + return item_to_child_item_matrix; +} + +template +ConnectivityMatrix ConnectivityComputer:: +computeConnectivityMatrix(const Connectivity1D&, const ItemType&, const ItemType&) const; + +template +ConnectivityMatrix ConnectivityComputer:: +computeConnectivityMatrix(const Connectivity2D&, const ItemType&, const ItemType&) const; + + +template +ConnectivityMatrix ConnectivityComputer:: +computeConnectivityMatrix(const Connectivity3D&, const ItemType&, const ItemType&) const; + +ConnectivityMatrix +ConnectivityComputer:: +_computeInverse(const ConnectivityMatrix& item_to_child_matrix) const +{ + std::map<unsigned int, std::vector<unsigned int>> child_to_item_vector_map; + const size_t& number_of_items = item_to_child_matrix.numRows(); for (unsigned int j=0; j<number_of_items; ++j) { - const auto& item_to_child_items = item_to_child_item_matrix.rowConst(j); - for (unsigned int r=0; r<item_to_child_items.length; ++r) { - child_item_to_item_vector_map[item_to_child_items(r)].push_back(j); + const auto& item_to_child = item_to_child_matrix.rowConst(j); + for (unsigned int r=0; r<item_to_child.length; ++r) { + child_to_item_vector_map[item_to_child(r)].push_back(j); } } { size_t i=0; - for (const auto& [child_item_id, item_vector] : child_item_to_item_vector_map) { + for (const auto& [child_item_id, item_vector] : child_to_item_vector_map) { if (child_item_id != i) { std::cerr << "sparse item numerotation NIY\n"; std::exit(0); @@ -29,11 +64,12 @@ computeInverseConnectivityMatrix(const ConnectivityMatrix& item_to_child_item_ma } } - std::vector<std::vector<unsigned int>> child_item_to_items_vector(child_item_to_item_vector_map.size()); - for (const auto& [child_item_id, item_vector] : child_item_to_item_vector_map) { - child_item_to_items_vector[child_item_id] = item_vector; + std::vector<std::vector<unsigned int>> child_to_items_vector(child_to_item_vector_map.size()); + for (const auto& [child_item_id, item_vector] : child_to_item_vector_map) { + child_to_items_vector[child_item_id] = item_vector; } - child_item_to_item_matrix = child_item_to_items_vector; + + return ConnectivityMatrix(child_to_items_vector); } template <ItemType item_type, @@ -43,9 +79,9 @@ SubItemValuePerItem<const unsigned short, child_item_type, item_type> ConnectivityComputer::computeLocalItemNumberInChildItem(const ConnectivityType& connectivity) const { const ConnectivityMatrix& child_item_to_items_matrix - = getConnectivityMatrix<child_item_type, item_type>(connectivity); + = connectivity.getMatrix(child_item_type, item_type); const ConnectivityMatrix& item_to_child_items_matrix - = getConnectivityMatrix<item_type, child_item_type>(connectivity); + = connectivity.getMatrix(item_type, child_item_type); SubItemValuePerItem<unsigned short, child_item_type, item_type> item_number_in_child_item(connectivity); for (unsigned int r=0; r<item_to_child_items_matrix.numRows(); ++r) { @@ -71,49 +107,48 @@ ConnectivityComputer::computeLocalItemNumberInChildItem(const ConnectivityType& template SubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::node> ConnectivityComputer:: computeLocalItemNumberInChildItem<ItemType::node, - ItemType::cell>(const Connectivity1D& connectivity) const; + ItemType::cell>(const Connectivity1D&) const; template SubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::face> ConnectivityComputer:: computeLocalItemNumberInChildItem<ItemType::face, - ItemType::cell>(const Connectivity1D& connectivity) const; + ItemType::cell>(const Connectivity1D&) const; template SubItemValuePerItem<const unsigned short, ItemType::node, ItemType::cell> ConnectivityComputer:: computeLocalItemNumberInChildItem<ItemType::cell, - ItemType::node>(const Connectivity1D& connectivity) const; + ItemType::node>(const Connectivity1D&) const; // 2D template SubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::node> ConnectivityComputer:: computeLocalItemNumberInChildItem<ItemType::node, - ItemType::cell>(const Connectivity2D& connectivity) const; + ItemType::cell>(const Connectivity2D&) const; template SubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::face> ConnectivityComputer:: computeLocalItemNumberInChildItem<ItemType::face, - ItemType::cell>(const Connectivity2D& connectivity) const; + ItemType::cell>(const Connectivity2D&) const; template SubItemValuePerItem<const unsigned short, ItemType::node, ItemType::cell> ConnectivityComputer:: computeLocalItemNumberInChildItem<ItemType::cell, - ItemType::node>(const Connectivity2D& connectivity) const; + ItemType::node>(const Connectivity2D&) const; // 3D template SubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::node> ConnectivityComputer:: computeLocalItemNumberInChildItem<ItemType::node, - ItemType::cell>(const Connectivity3D& connectivity) const; - + ItemType::cell>(const Connectivity3D&) const; template SubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::face> ConnectivityComputer:: computeLocalItemNumberInChildItem<ItemType::face, - ItemType::cell>(const Connectivity3D& connectivity) const; + ItemType::cell>(const Connectivity3D&) const; template SubItemValuePerItem<const unsigned short, ItemType::node, ItemType::cell> ConnectivityComputer:: computeLocalItemNumberInChildItem<ItemType::cell, - ItemType::node>(const Connectivity3D& connectivity) const; + ItemType::node>(const Connectivity3D&) const; diff --git a/src/mesh/ConnectivityComputer.hpp b/src/mesh/ConnectivityComputer.hpp index 6a726e52da790b3099223f7f499d3e3bbb6bd13f..8b4fdfc3ab20bf2d6290d234a13b833dc6451cb6 100644 --- a/src/mesh/ConnectivityComputer.hpp +++ b/src/mesh/ConnectivityComputer.hpp @@ -4,16 +4,29 @@ #include <ConnectivityMatrix.hpp> #include <SubItemValuePerItem.hpp> -struct ConnectivityComputer +class ConnectivityComputer { - void computeInverseConnectivityMatrix(const ConnectivityMatrix& item_to_child_item_matrix, - ConnectivityMatrix& child_item_to_item_matrix) const; + private: + ConnectivityMatrix + _computeInverse(const ConnectivityMatrix& item_to_child_matrix) const; + + public: + template <typename ConnectivityType> + ConnectivityMatrix + computeConnectivityMatrix(const ConnectivityType& connectivity, + const ItemType& item_type, + const ItemType& child_item_type) const; + template <ItemType item_type, ItemType child_item_type, typename ConnectivityType> SubItemValuePerItem<const unsigned short, child_item_type, item_type> computeLocalItemNumberInChildItem(const ConnectivityType& connectivity) const; + + ConnectivityComputer(const ConnectivityComputer&) = default; + ConnectivityComputer() = default; + ~ConnectivityComputer() = default; }; #endif // CONNECTIVITY_COMPUTER_HPP diff --git a/src/mesh/ConnectivityMatrix.hpp b/src/mesh/ConnectivityMatrix.hpp index 30a40e1802a3bf0888374614fc7c1aadf8c8440a..1a0ab4880b8cc61757c63492e46e8a2612c83664 100644 --- a/src/mesh/ConnectivityMatrix.hpp +++ b/src/mesh/ConnectivityMatrix.hpp @@ -10,9 +10,16 @@ class ConnectivityMatrix typedef Kokkos::StaticCrsGraph<unsigned int, Kokkos::HostSpace> HostMatrix; HostMatrix m_host_matrix; + bool m_is_built{false}; + public: typedef HostMatrix::row_map_type HostRowType; + const bool& isBuilt() const + { + return m_is_built; + } + const auto& entries() const { return m_host_matrix.entries; @@ -49,7 +56,8 @@ class ConnectivityMatrix KOKKOS_INLINE_FUNCTION ConnectivityMatrix(const std::vector<std::vector<unsigned int>>& initializer) - : m_host_matrix(Kokkos::create_staticcrsgraph<HostMatrix>("connecticity_matrix", initializer)) + : m_host_matrix{Kokkos::create_staticcrsgraph<HostMatrix>("connecticity_matrix", initializer)}, + m_is_built{true} { ; } diff --git a/src/mesh/ConnectivityUtils.hpp b/src/mesh/ConnectivityUtils.hpp deleted file mode 100644 index e073d552132019c4172c5cb1b6920ca4f199f428..0000000000000000000000000000000000000000 --- a/src/mesh/ConnectivityUtils.hpp +++ /dev/null @@ -1,16 +0,0 @@ -#ifndef CONNECTIVITY_UTILS_HPP -#define CONNECTIVITY_UTILS_HPP - -#include <ItemType.hpp> -#include <ConnectivityMatrix.hpp> - -template <ItemType item_type_0, - ItemType item_type_1, - typename ConnectivityType> -inline -const ConnectivityMatrix& getConnectivityMatrix(const ConnectivityType& connectivity) -{ - return connectivity.template itemToItemMatrix<item_type_0, item_type_1>(); -} - -#endif // CONNECTIVITY_UTILS_HPP diff --git a/src/mesh/MeshData.hpp b/src/mesh/MeshData.hpp index 66ba3626a0458ad0660e0184a2e0304e52def5c4..0fe98256bb87d8d02b29899906e475737f4e835d 100644 --- a/src/mesh/MeshData.hpp +++ b/src/mesh/MeshData.hpp @@ -36,8 +36,8 @@ class MeshData const Kokkos::View<const Rd*> xr = m_mesh.xr(); const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); Kokkos::parallel_for(m_mesh.numberOfCells(), KOKKOS_LAMBDA(const int& j){ const auto& cell_nodes = cell_to_node_matrix.rowConst(j); @@ -49,8 +49,8 @@ class MeshData = m_mesh.connectivity().invCellNbNodes(); const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); Kokkos::parallel_for(m_mesh.numberOfCells(), KOKKOS_LAMBDA(const int& j){ Rd X = zero; @@ -68,8 +68,8 @@ class MeshData { const Kokkos::View<const Rd*> xr = m_mesh.xr(); const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); Kokkos::parallel_for(m_mesh.numberOfCells(), KOKKOS_LAMBDA(const int& j){ double sum_cjr_xr = 0; @@ -90,8 +90,8 @@ class MeshData else if constexpr (dimension == 2) { const Kokkos::View<const Rd*> xr = m_mesh.xr(); const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); Kokkos::parallel_for(m_mesh.numberOfCells(), KOKKOS_LAMBDA(const int& j){ const auto& cell_nodes = cell_to_node_matrix.rowConst(j); @@ -118,8 +118,8 @@ class MeshData NodeValuePerFace<Rd> Nlr(m_mesh.connectivity()); const auto& face_to_node_matrix - = getConnectivityMatrix<ItemType::face, - ItemType::node>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::face, + ItemType::node); Kokkos::parallel_for(m_mesh.numberOfFaces(), KOKKOS_LAMBDA(const int& l) { const auto& face_nodes = face_to_node_matrix.rowConst(l); @@ -146,12 +146,12 @@ class MeshData }); const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); const auto& cell_to_face_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::face>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::cell, + ItemType::face); const auto& cell_face_is_reversed = m_mesh.connectivity().cellFaceIsReversed(); Kokkos::parallel_for(m_mesh.numberOfCells(), KOKKOS_LAMBDA(const int& j) { diff --git a/src/mesh/MeshNodeBoundary.hpp b/src/mesh/MeshNodeBoundary.hpp index cf9df04f0b92112e7b8d907652bc78be06890c2a..87c537439bf1a27e8443865677cd6b58c132378c 100644 --- a/src/mesh/MeshNodeBoundary.hpp +++ b/src/mesh/MeshNodeBoundary.hpp @@ -9,7 +9,7 @@ #include <RefFaceList.hpp> #include <ConnectivityMatrix.hpp> -#include <ConnectivityUtils.hpp> +#include <IConnectivity.hpp> #include <iostream> template <size_t dimension> @@ -32,8 +32,7 @@ class MeshNodeBoundary { static_assert(dimension == MeshType::dimension); const auto& face_to_cell_matrix - = getConnectivityMatrix<ItemType::face, - ItemType::cell>(mesh.connectivity()); + = mesh.connectivity().getMatrix(ItemType::face, ItemType::cell); const Kokkos::View<const unsigned int*>& face_list = ref_face_list.faceList(); Kokkos::parallel_for(face_list.extent(0), KOKKOS_LAMBDA(const int& l){ @@ -48,8 +47,8 @@ class MeshNodeBoundary // not enough but should reduce significantly the number of resizing node_ids.reserve(dimension*face_list.extent(0)); const auto& face_to_node_matrix - = getConnectivityMatrix<ItemType::face, - ItemType::node>(mesh.connectivity()); + = mesh.connectivity().getMatrix(ItemType::face, + ItemType::node); for (size_t l=0; l<face_list.extent(0); ++l) { const size_t face_number = face_list[l]; @@ -317,12 +316,12 @@ _getOutgoingNormal(const MeshType& mesh) const Kokkos::View<const R*>& xr = mesh.xr(); const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(mesh.connectivity()); + = mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); const auto& node_to_cell_matrix - = getConnectivityMatrix<ItemType::node, - ItemType::cell>(mesh.connectivity()); + = mesh.connectivity().getMatrix(ItemType::node, + ItemType::cell); const size_t r0 = m_node_list[0]; const size_t j0 = node_to_cell_matrix.rowConst(r0)(0); @@ -354,12 +353,12 @@ _getOutgoingNormal(const MeshType& mesh) const Kokkos::View<const R2*>& xr = mesh.xr(); const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(mesh.connectivity()); + = mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); const auto& node_to_cell_matrix - = getConnectivityMatrix<ItemType::node, - ItemType::cell>(mesh.connectivity()); + = mesh.connectivity().getMatrix(ItemType::node, + ItemType::cell); const size_t r0 = m_node_list[0]; const size_t j0 = node_to_cell_matrix.rowConst(r0)(0); @@ -391,12 +390,12 @@ _getOutgoingNormal(const MeshType& mesh) const Kokkos::View<const R3*>& xr = mesh.xr(); const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(mesh.connectivity()); + = mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); const auto& node_to_cell_matrix - = getConnectivityMatrix<ItemType::node, - ItemType::cell>(mesh.connectivity()); + = mesh.connectivity().getMatrix(ItemType::node, + ItemType::cell); const size_t r0 = m_node_list[0]; const size_t j0 = node_to_cell_matrix.rowConst(r0)(0); diff --git a/src/mesh/SubItemValuePerItem.hpp b/src/mesh/SubItemValuePerItem.hpp index c6e98dcf6cebe539f008038051ce52a9927ef6a8..3ab0ac48718747a01c68dbf12d330cde6593e052 100644 --- a/src/mesh/SubItemValuePerItem.hpp +++ b/src/mesh/SubItemValuePerItem.hpp @@ -7,7 +7,6 @@ #include <ConnectivityMatrix.hpp> #include <IConnectivity.hpp> -#include <ConnectivityUtils.hpp> template <typename DataType, ItemType sub_item_type, diff --git a/src/output/VTKWriter.hpp b/src/output/VTKWriter.hpp index a2454cb0fc2b375c71267ff622a79e9dca381bc4..a33fef0bfbe2abf2c73b34e7c3b564fb2cd81461 100644 --- a/src/output/VTKWriter.hpp +++ b/src/output/VTKWriter.hpp @@ -6,7 +6,7 @@ #include <iomanip> #include <sstream> #include <TinyVector.hpp> -#include <ConnectivityUtils.hpp> +#include <IConnectivity.hpp> class VTKWriter { @@ -72,8 +72,8 @@ class VTKWriter fout << "<DataArray type=\"Int32\" Name=\"connectivity\" NumberOfComponents=\"1\" format=\"ascii\">\n"; const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(mesh.connectivity()); + = mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); for (unsigned int j=0; j<mesh.numberOfCells(); ++j) { const auto& cell_nodes = cell_to_node_matrix.rowConst(j); diff --git a/src/scheme/AcousticSolver.hpp b/src/scheme/AcousticSolver.hpp index 4145c01ea62352436fecbe43ce33983e0db19143..0cc6ec0df7a97b91999376873ed7b35a0c5acf6c 100644 --- a/src/scheme/AcousticSolver.hpp +++ b/src/scheme/AcousticSolver.hpp @@ -99,8 +99,8 @@ class AcousticSolver const Kokkos::View<const Rdd*> computeAr(const NodeValuePerCell<Rdd>& Ajr) { const auto& node_to_cell_matrix - = getConnectivityMatrix<ItemType::node, - ItemType::cell>(m_connectivity); + = m_connectivity.getMatrix(ItemType::node, + ItemType::cell); const auto& node_local_numbers_in_their_cells = m_connectivity.nodeLocalNumbersInTheirCells(); @@ -128,8 +128,8 @@ class AcousticSolver const Kokkos::View<const Rd*>& uj, const Kokkos::View<const double*>& pj) { const auto& node_to_cell_matrix - = getConnectivityMatrix<ItemType::node, - ItemType::cell>(m_connectivity); + = m_connectivity.getMatrix(ItemType::node, + ItemType::cell); const auto& node_local_numbers_in_their_cells = m_connectivity.nodeLocalNumbersInTheirCells(); @@ -212,8 +212,8 @@ class AcousticSolver const Kokkos::View<const double*>& pj) { const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); Kokkos::parallel_for(m_mesh.numberOfCells(), KOKKOS_LAMBDA(const int& j) { const auto& cell_nodes = cell_to_node_matrix.rowConst(j); @@ -291,8 +291,8 @@ class AcousticSolver { const NodeValuePerCell<double>& ljr = m_mesh_data.ljr(); const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); Kokkos::parallel_for(m_mesh.numberOfCells(), KOKKOS_LAMBDA(const int& j){ const auto& cell_nodes = cell_to_node_matrix.rowConst(j); @@ -335,8 +335,8 @@ class AcousticSolver const NodeValuePerCell<Rd>& Fjr = m_Fjr; const Kokkos::View<const Rd*> ur = m_ur; const auto& cell_to_node_matrix - = getConnectivityMatrix<ItemType::cell, - ItemType::node>(m_mesh.connectivity()); + = m_mesh.connectivity().getMatrix(ItemType::cell, + ItemType::node); const Kokkos::View<const double*> inv_mj = unknowns.invMj(); Kokkos::parallel_for(m_mesh.numberOfCells(), KOKKOS_LAMBDA(const int& j) {