An error occurred while retrieving target projects.

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Target

Show changes

Only incoming changes from source

Include changes to target since source was created

Commits on Source 19

Add _gatherFrom mechanism for SubItemValuePerItem · 42349d4d
Stéphane Del Pino authored Apr 2, 2019

42349d4d
Change type of ConnectivityDescriptor::cell_face_is_reversed_vector · c05d0eb6
Stéphane Del Pino authored Apr 2, 2019
```
use more appropriate std::vector<Array<bool>>
```
c05d0eb6
Fix MPI_Waitall call in the case of empty processors · 1db7c7ef
Stéphane Del Pino authored Apr 2, 2019
```
This allows to plug the synchronization in ConnectivityDispatcher::_buildNewOwner
```
1db7c7ef
Fix few typos · 4c192cd7
Stéphane Del Pino authored Apr 4, 2019

4c192cd7

Add two template helpers · 3ebaba6d

Stéphane Del Pino authored Apr 4, 2019

- 'template <typename T> is_false_v' and
- 'template <ItemType item_type> is_false_item_type_v'

Which ever parameter is given these 'inline boolean' are always 'false'. Their
purpose is to help writing of 'static_assert'.

3ebaba6d

Rename ConnectivityDescriptor::cell_by_node_vector · 71f4827c
Stéphane Del Pino authored Apr 4, 2019
```
ConnectivityDescriptor::cell_by_node_vector ->  ConnectivityDescriptor::cell_to_node_vector
```
71f4827c
Continue clean-up: more template factorization · 9d7da3cd
Stéphane Del Pino authored Apr 4, 2019

9d7da3cd

Continue clean-up · af1fa0f8

Stéphane Del Pino authored Apr 5, 2019

Mainly replace _get-like functions by _build-like calls. This removes many
unnecessary references.

af1fa0f8

Continue clean-up: wording · 50f68013
Stéphane Del Pino authored Apr 5, 2019

50f68013
Begin generalization of item references dispatching · d79221ca
Stéphane Del Pino authored Apr 5, 2019
```
Starting point only deals with wording of face-reference-list management.
```
d79221ca
Replace Ref{Face,Node}List by a generic RefItemList · bfbef602
Stéphane Del Pino authored Apr 5, 2019
```
This will ease the generic dispatching of reference item lists
```
bfbef602
Continue clean-up · a76e76a6
Stéphane Del Pino authored Apr 8, 2019
```
RefFaceList's are now dispatched using generic coding
```
a76e76a6
Fix linkage on Ubuntu 18.04 · 46b97a4b
Stéphane Del Pino authored Apr 8, 2019

46b97a4b
Remove useless statements · c6647937
Stéphane Del Pino authored Apr 8, 2019

c6647937
Manage references of cells · 848e27c5
Stéphane Del Pino authored Apr 9, 2019
```
Also dispatch all ref-item lists
```
848e27c5

Manage edges in 3D · 9721b088

Stéphane Del Pino authored Apr 9, 2019

- building/reading of edges
- dispatching in parallel

This implies that [Sub]ItemValue<edge> are also now available

9721b088

Fix and remove warnings · 1041f7bc
Stéphane Del Pino authored Apr 11, 2019
```
the untreated #warning have been converted to issues
```
1041f7bc
Move ConnectivityDescriptor to its own file · b608903d
Stéphane Del Pino authored Apr 11, 2019

b608903d
Merge branch 'feature/mpi' into 'develop' · 7843720c
Stéphane Del Pino authored Apr 11, 2019
```
Feature/mpi

Closes #4 and #2

See merge request code/pastis!11
```
7843720c

CMakeLists.txt

+3 −2

Original line number	Original line	Diff line number	Diff line
	@@ -271,8 +271,9 @@ add_executable(
	# Libraries		# Libraries
	target_link_libraries(		target_link_libraries(
	pastis		pastis
			PastisMesh
			PastisUtils
	kokkos		kokkos
	${PARMETIS_LIBRARIES}		${PARMETIS_LIBRARIES}
	${MPI_CXX_LINK_FLAGS} ${MPI_CXX_LIBRARIES}		${MPI_CXX_LINK_FLAGS} ${MPI_CXX_LIBRARIES}
	PastisMesh		)
	PastisUtils)

src/algebra/TinyMatrix.hpp

+8 −8

Original line number	Original line	Diff line number	Diff line
	@@ -296,7 +296,7 @@ template <size_t N, typename T>
	PASTIS_INLINE		PASTIS_INLINE
	constexpr T det(const TinyMatrix<N,T>& A)		constexpr T det(const TinyMatrix<N,T>& A)
	{		{
	static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non arithmetic types");		static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non-arithmetic types");
	static_assert(std::is_floating_point<T>::value, "determinent for arbitrary dimension N is defined for floating point types only");		static_assert(std::is_floating_point<T>::value, "determinent for arbitrary dimension N is defined for floating point types only");
	TinyMatrix<N,T> M = A;		TinyMatrix<N,T> M = A;

	@@ -340,7 +340,7 @@ template <typename T>
	PASTIS_INLINE		PASTIS_INLINE
	constexpr T det(const TinyMatrix<1,T>& A)		constexpr T det(const TinyMatrix<1,T>& A)
	{		{
	static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non arithmetic types");		static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non-arithmetic types");
	return A(0,0);		return A(0,0);
	}		}

	@@ -348,7 +348,7 @@ template <typename T>
	PASTIS_INLINE		PASTIS_INLINE
	constexpr T det(const TinyMatrix<2,T>& A)		constexpr T det(const TinyMatrix<2,T>& A)
	{		{
	static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non arithmetic types");		static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non-arithmetic types");
	return A(0,0)A(1,1)-A(1,0)A(0,1);		return A(0,0)A(1,1)-A(1,0)A(0,1);
	}		}

	@@ -356,7 +356,7 @@ template <typename T>
	PASTIS_INLINE		PASTIS_INLINE
	constexpr T det(const TinyMatrix<3,T>& A)		constexpr T det(const TinyMatrix<3,T>& A)
	{		{
	static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non arithmetic types");		static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non-arithmetic types");
	return		return
	A(0,0)(A(1,1)A(2,2)-A(2,1)*A(1,2))		A(0,0)(A(1,1)A(2,2)-A(2,1)*A(1,2))
	-A(1,0)(A(0,1)A(2,2)-A(2,1)*A(0,2))		-A(1,0)(A(0,1)A(2,2)-A(2,1)*A(0,2))
	@@ -399,7 +399,7 @@ template <typename T>
	PASTIS_INLINE		PASTIS_INLINE
	constexpr TinyMatrix<1,T> inverse(const TinyMatrix<1,T>& A)		constexpr TinyMatrix<1,T> inverse(const TinyMatrix<1,T>& A)
	{		{
	static_assert(std::is_arithmetic<T>::value, "inverse is not defined for non arithmetic types");		static_assert(std::is_arithmetic<T>::value, "inverse is not defined for non-arithmetic types");
	static_assert(std::is_floating_point<T>::value, "inverse is defined for floating point types only");		static_assert(std::is_floating_point<T>::value, "inverse is defined for floating point types only");

	TinyMatrix<1,T> A_1(1./A(0,0));		TinyMatrix<1,T> A_1(1./A(0,0));
	@@ -412,7 +412,7 @@ constexpr T cofactor(const TinyMatrix<N,T>& A,
	const size_t& i,		const size_t& i,
	const size_t& j)		const size_t& j)
	{		{
	static_assert(std::is_arithmetic<T>::value, "cofactor is not defined for non arithmetic types");		static_assert(std::is_arithmetic<T>::value, "cofactor is not defined for non-arithmetic types");
	const T sign = ((i+j)%2) ? -1 : 1;		const T sign = ((i+j)%2) ? -1 : 1;

	return sign * det(getMinor(A, i, j));		return sign * det(getMinor(A, i, j));
	@@ -422,7 +422,7 @@ template <typename T>
	PASTIS_INLINE		PASTIS_INLINE
	constexpr TinyMatrix<2,T> inverse(const TinyMatrix<2,T>& A)		constexpr TinyMatrix<2,T> inverse(const TinyMatrix<2,T>& A)
	{		{
	static_assert(std::is_arithmetic<T>::value, "inverse is not defined for non arithmetic types");		static_assert(std::is_arithmetic<T>::value, "inverse is not defined for non-arithmetic types");
	static_assert(std::is_floating_point<T>::value, "inverse is defined for floating point types only");		static_assert(std::is_floating_point<T>::value, "inverse is defined for floating point types only");

	const T determinent = det(A);		const T determinent = det(A);
	@@ -438,7 +438,7 @@ template <typename T>
	PASTIS_INLINE		PASTIS_INLINE
	constexpr TinyMatrix<3,T> inverse(const TinyMatrix<3,T>& A)		constexpr TinyMatrix<3,T> inverse(const TinyMatrix<3,T>& A)
	{		{
	static_assert(std::is_arithmetic<T>::value, "inverse is not defined for non arithmetic types");		static_assert(std::is_arithmetic<T>::value, "inverse is not defined for non-arithmetic types");
	static_assert(std::is_floating_point<T>::value, "inverse is defined for floating point types only");		static_assert(std::is_floating_point<T>::value, "inverse is defined for floating point types only");

	const T determinent = det(A);		const T determinent = det(A);

src/main.cpp

+6 −6

src/mesh/Connectivity.cpp

+53 −23

Original line number	Original line	Diff line number	Diff line
	@@ -3,6 +3,8 @@

	#include <Messenger.hpp>		#include <Messenger.hpp>

			#include <ConnectivityDescriptor.hpp>

	template<size_t Dimension>		template<size_t Dimension>
	Connectivity<Dimension>::Connectivity() {}		Connectivity<Dimension>::Connectivity() {}

	@@ -10,8 +12,7 @@ template<size_t Dimension>
	void Connectivity<Dimension>::		void Connectivity<Dimension>::
	_buildFrom(const ConnectivityDescriptor& descriptor)		_buildFrom(const ConnectivityDescriptor& descriptor)
	{		{
	#warning All of these should be checked by ConnectivityDescriptor		Assert(descriptor.cell_to_node_vector.size() == descriptor.cell_type_vector.size());
	Assert(descriptor.cell_by_node_vector.size() == descriptor.cell_type_vector.size());
	Assert(descriptor.cell_number_vector.size() == descriptor.cell_type_vector.size());		Assert(descriptor.cell_number_vector.size() == descriptor.cell_type_vector.size());
	if constexpr (Dimension>1) {		if constexpr (Dimension>1) {
	Assert(descriptor.cell_to_face_vector.size() == descriptor.cell_type_vector.size());		Assert(descriptor.cell_to_face_vector.size() == descriptor.cell_type_vector.size());
	@@ -21,7 +22,7 @@ _buildFrom(const ConnectivityDescriptor& descriptor)

	auto& cell_to_node_matrix		auto& cell_to_node_matrix
	= m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::node)];		= m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::node)];
	cell_to_node_matrix = descriptor.cell_by_node_vector;		cell_to_node_matrix = descriptor.cell_to_node_vector;

	{		{
	WeakCellValue<CellType> cell_type(*this);		WeakCellValue<CellType> cell_type(*this);
	@@ -45,8 +46,6 @@ _buildFrom(const ConnectivityDescriptor& descriptor)

	{		{
	WeakCellValue<int> cell_global_index(*this);		WeakCellValue<int> cell_global_index(*this);
	#warning index must start accounting number of global indices of other procs
	#warning must take care of ghost cells
	int first_index = 0;		int first_index = 0;
	parallel_for(this->numberOfCells(), PASTIS_LAMBDA(const CellId& j) {		parallel_for(this->numberOfCells(), PASTIS_LAMBDA(const CellId& j) {
	cell_global_index[j] = first_index+j;		cell_global_index[j] = first_index+j;
	@@ -54,16 +53,6 @@ _buildFrom(const ConnectivityDescriptor& descriptor)
	m_cell_global_index = cell_global_index;		m_cell_global_index = cell_global_index;
	}		}


	{
	WeakCellValue<double> inv_cell_nb_nodes(*this);
	parallel_for(this->numberOfCells(), PASTIS_LAMBDA(const CellId& j) {
	const auto& cell_nodes = cell_to_node_matrix.rowConst(j);
	inv_cell_nb_nodes[j] = 1./cell_nodes.length;
	});
	m_inv_cell_nb_nodes = inv_cell_nb_nodes;
	}

	{		{
	WeakCellValue<int> cell_owner(*this);		WeakCellValue<int> cell_owner(*this);
	cell_owner = convert_to_array(descriptor.cell_owner_vector);		cell_owner = convert_to_array(descriptor.cell_owner_vector);
	@@ -94,14 +83,13 @@ _buildFrom(const ConnectivityDescriptor& descriptor)
	m_node_is_owned = node_is_owned;		m_node_is_owned = node_is_owned;
	}		}

			m_ref_node_list_vector = descriptor.template refItemListVector<ItemType::node>();
			m_ref_cell_list_vector = descriptor.template refItemListVector<ItemType::cell>();

	if constexpr (Dimension>1) {		if constexpr (Dimension>1) {
	auto& face_to_node_matrix		m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::node)] = descriptor.face_to_node_vector;
	= m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::node)];
	face_to_node_matrix = descriptor.face_to_node_vector;

	auto& cell_to_face_matrix		m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::face)] = descriptor.cell_to_face_vector;
	= m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::face)];
	cell_to_face_matrix = descriptor.cell_to_face_vector;

	{		{
	FaceValuePerCell<bool> cell_face_is_reversed(*this);		FaceValuePerCell<bool> cell_face_is_reversed(*this);
	@@ -111,14 +99,15 @@ _buildFrom(const ConnectivityDescriptor& descriptor)
	cell_face_is_reversed(j,lj) = face_cells_vector[lj];		cell_face_is_reversed(j,lj) = face_cells_vector[lj];
	}		}
	}		}

	m_cell_face_is_reversed = cell_face_is_reversed;		m_cell_face_is_reversed = cell_face_is_reversed;
	}		}

	{		{
	WeakFaceValue<int> face_number(*this);		WeakFaceValue<int> face_number(*this);
	face_number = convert_to_array(descriptor.face_number_vector);		face_number = convert_to_array(descriptor.face_number_vector);
	m_face_number = face_number;		m_face_number = face_number;
	}		}

	{		{
	WeakFaceValue<int> face_owner(*this);		WeakFaceValue<int> face_owner(*this);
	face_owner = convert_to_array(descriptor.face_owner_vector);		face_owner = convert_to_array(descriptor.face_owner_vector);
	@@ -134,8 +123,49 @@ _buildFrom(const ConnectivityDescriptor& descriptor)
	m_face_is_owned = face_is_owned;		m_face_is_owned = face_is_owned;
	}		}

			m_ref_face_list_vector = descriptor.template refItemListVector<ItemType::face>();

			if constexpr (Dimension>2) {
			m_item_to_item_matrix[itemTId(ItemType::edge)][itemTId(ItemType::node)] = descriptor.edge_to_node_vector;

	m_ref_face_list = descriptor.refFaceList();		m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::edge)] = descriptor.face_to_edge_vector;

			m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::edge)] = descriptor.cell_to_edge_vector;

			{
			EdgeValuePerFace<bool> face_edge_is_reversed(*this);
			for (FaceId l=0; l<descriptor.face_edge_is_reversed_vector.size(); ++l) {
			const auto& edge_faces_vector = descriptor.face_edge_is_reversed_vector[l];
			for (unsigned short el=0; el<edge_faces_vector.size(); ++el) {
			face_edge_is_reversed(l,el) = edge_faces_vector[el];
			}
			}
			m_face_edge_is_reversed = face_edge_is_reversed;
			}

			{
			WeakEdgeValue<int> edge_number(*this);
			edge_number = convert_to_array(descriptor.edge_number_vector);
			m_edge_number = edge_number;
			}

			{
			WeakEdgeValue<int> edge_owner(*this);
			edge_owner = convert_to_array(descriptor.edge_owner_vector);
			m_edge_owner = edge_owner;
			}

			{
			const int rank = parallel::rank();
			WeakEdgeValue<bool> edge_is_owned(*this);
			parallel_for(this->numberOfEdges(), PASTIS_LAMBDA(const EdgeId& e) {
			edge_is_owned[e] = (m_edge_owner[e] == rank);
			});
			m_edge_is_owned = edge_is_owned;
			}

			m_ref_edge_list_vector = descriptor.template refItemListVector<ItemType::edge>();
			}
	}		}
	}		}

src/mesh/Connectivity.hpp

+74 −76

Original line number	Original line	Diff line number	Diff line
	@@ -7,6 +7,8 @@
	#include <PastisOStream.hpp>		#include <PastisOStream.hpp>
	#include <PastisUtils.hpp>		#include <PastisUtils.hpp>

			#include <PastisTraits.hpp>

	#include <TinyVector.hpp>		#include <TinyVector.hpp>

	#include <ItemValue.hpp>		#include <ItemValue.hpp>
	@@ -28,58 +30,14 @@

	#include <RefId.hpp>		#include <RefId.hpp>
	#include <ItemType.hpp>		#include <ItemType.hpp>
	#include <RefNodeList.hpp>		#include <RefItemList.hpp>
	#include <RefFaceList.hpp>

	#include <SynchronizerManager.hpp>		#include <SynchronizerManager.hpp>

	#include <tuple>
	#include <algorithm>
	#include <set>		#include <set>

	class ConnectivityDescriptor		class ConnectivityDescriptor;
	{
	private:
	std::vector<RefFaceList> m_ref_face_list;

	public:
	std::vector<std::vector<unsigned int>> cell_by_node_vector;

	#warning should be set in 2d
	std::vector<std::vector<unsigned int>> cell_to_face_vector;
	std::vector<std::vector<bool>> cell_face_is_reversed_vector;

	// std::vector<std::vector<unsigned int>> face_to_cell_vector;
	std::vector<std::vector<unsigned int>> face_to_node_vector;

	std::vector<CellType> cell_type_vector;

	std::vector<int> cell_number_vector;
	std::vector<int> face_number_vector;
	std::vector<int> node_number_vector;

	std::vector<int> cell_owner_vector;
	std::vector<int> face_owner_vector;
	std::vector<int> node_owner_vector;

	const std::vector<RefFaceList>& refFaceList() const
	{
	return m_ref_face_list;
	}

	void addRefFaceList(const RefFaceList& ref_face_list)
	{
	m_ref_face_list.push_back(ref_face_list);
	}

	ConnectivityDescriptor& operator=(const ConnectivityDescriptor&) = delete;
	ConnectivityDescriptor& operator=(ConnectivityDescriptor&&) = delete;

	ConnectivityDescriptor() = default;
	ConnectivityDescriptor(const ConnectivityDescriptor&) = default;
	ConnectivityDescriptor(ConnectivityDescriptor&&) = delete;
	~ConnectivityDescriptor() = default;
	};

	template <size_t Dim>		template <size_t Dim>
	class Connectivity final		class Connectivity final
	@@ -105,12 +63,10 @@ class Connectivity final
	ConnectivityMatrix m_item_to_item_matrix[Dimension+1][Dimension+1];		ConnectivityMatrix m_item_to_item_matrix[Dimension+1][Dimension+1];
	WeakCellValue<const CellType> m_cell_type;		WeakCellValue<const CellType> m_cell_type;

	#warning is m_cell_global_index really necessary? should it be computed on demand instead?
	WeakCellValue<const int> m_cell_global_index;		WeakCellValue<const int> m_cell_global_index;

	WeakCellValue<const int> m_cell_number;		WeakCellValue<const int> m_cell_number;
	WeakFaceValue<const int> m_face_number;		WeakFaceValue<const int> m_face_number;
	#warning check that m_edge_number is filled correctly
	WeakEdgeValue<const int> m_edge_number;		WeakEdgeValue<const int> m_edge_number;
	WeakNodeValue<const int> m_node_number;		WeakNodeValue<const int> m_node_number;

	@@ -127,6 +83,7 @@ class Connectivity final
	WeakNodeValue<const bool> m_node_is_owned;		WeakNodeValue<const bool> m_node_is_owned;

	WeakFaceValuePerCell<const bool> m_cell_face_is_reversed;		WeakFaceValuePerCell<const bool> m_cell_face_is_reversed;
			WeakEdgeValuePerFace<const bool> m_face_edge_is_reversed;

	WeakNodeValuePerCell<const unsigned short> m_cell_local_numbers_in_their_nodes;		WeakNodeValuePerCell<const unsigned short> m_cell_local_numbers_in_their_nodes;
	WeakEdgeValuePerCell<const unsigned short> m_cell_local_numbers_in_their_edges;		WeakEdgeValuePerCell<const unsigned short> m_cell_local_numbers_in_their_edges;
	@@ -146,8 +103,10 @@ class Connectivity final

	ConnectivityComputer m_connectivity_computer;		ConnectivityComputer m_connectivity_computer;

	std::vector<RefFaceList> m_ref_face_list;		std::vector<RefCellList> m_ref_cell_list_vector;
	std::vector<RefNodeList> m_ref_node_list;		std::vector<RefFaceList> m_ref_face_list_vector;
			std::vector<RefEdgeList> m_ref_edge_list_vector;
			std::vector<RefNodeList> m_ref_node_list_vector;

	WeakCellValue<const double> m_inv_cell_nb_nodes;		WeakCellValue<const double> m_inv_cell_nb_nodes;

	@@ -228,8 +187,7 @@ class Connectivity final
	} else if constexpr(item_type == ItemType::node) {		} else if constexpr(item_type == ItemType::node) {
	return m_node_number;		return m_node_number;
	} else {		} else {
	static_assert(item_type == ItemType::cell, "unknown ItemType");		static_assert(is_false_item_type_v<item_type>, "unknown ItemType");
	return m_cell_number;
	}		}
	}		}

	@@ -272,8 +230,7 @@ class Connectivity final
	} else if constexpr(item_type == ItemType::node) {		} else if constexpr(item_type == ItemType::node) {
	return m_node_owner;		return m_node_owner;
	} else {		} else {
	static_assert(item_type == ItemType::cell, "unknown ItemType");		static_assert(is_false_item_type_v<item_type>, "unknown ItemType");
	return m_cell_owner;
	}		}
	}		}

	@@ -316,8 +273,7 @@ class Connectivity final
	} else if constexpr(item_type == ItemType::node) {		} else if constexpr(item_type == ItemType::node) {
	return m_node_is_owned;		return m_node_is_owned;
	} else {		} else {
	static_assert(item_type == ItemType::cell, "unknown ItemType");		static_assert(is_false_item_type_v<item_type>, "unknown ItemType");
	return m_cell_is_owned;
	}		}
	}		}

	@@ -418,6 +374,13 @@ class Connectivity final
	return m_cell_face_is_reversed;		return m_cell_face_is_reversed;
	}		}

			PASTIS_INLINE
			const auto& faceEdgeIsReversed() const
			{
			static_assert(Dimension>2, "reversed edges makes no sense in dimension 1 or 2");
			return m_face_edge_is_reversed;
			}

	PASTIS_INLINE		PASTIS_INLINE
	const auto& cellLocalNumbersInTheirNodes() const		const auto& cellLocalNumbersInTheirNodes() const
	{		{
	@@ -512,29 +475,53 @@ class Connectivity final
	return _lazzyBuildItemNumberInTheirChild(m_node_local_numbers_in_their_faces);		return _lazzyBuildItemNumberInTheirChild(m_node_local_numbers_in_their_faces);
	}		}

	size_t numberOfRefFaceList() const		template <ItemType item_type>
			size_t numberOfRefItemList() const
	{		{
	return m_ref_face_list.size();		if constexpr (item_type == ItemType::cell) {
			return m_ref_cell_list_vector.size();
			} else if constexpr (item_type == ItemType::face) {
			return m_ref_face_list_vector.size();
			} else if constexpr (item_type == ItemType::edge) {
			return m_ref_edge_list_vector.size();
			} else if constexpr (item_type == ItemType::node) {
			return m_ref_node_list_vector.size();
			} else {
			static_assert(is_false_item_type_v<item_type>, "Unexpected item type");
	}		}

	const RefFaceList& refFaceList(const size_t& i) const
	{
	return m_ref_face_list[i];
	}		}

	void addRefNodeList(const RefNodeList& ref_node_list)		template <ItemType item_type>
			const RefItemList<item_type>& refItemList(const size_t& i) const
	{		{
	m_ref_node_list.push_back(ref_node_list);		if constexpr (item_type == ItemType::cell) {
			return m_ref_cell_list_vector[i];
			} else if constexpr (item_type == ItemType::face) {
			return m_ref_face_list_vector[i];
			} else if constexpr (item_type == ItemType::edge) {
			return m_ref_edge_list_vector[i];
			} else if constexpr (item_type == ItemType::node) {
			return m_ref_node_list_vector[i];
			} else {
			static_assert(is_false_item_type_v<item_type>, "Unexpected item type");
	}		}

	size_t numberOfRefNodeList() const
	{
	return m_ref_node_list.size();
	}		}

	const RefNodeList& refNodeList(const size_t& i) const		template <ItemType item_type>
			void addRefItemList(const RefItemList<item_type>& ref_item_list)
	{		{
	return m_ref_node_list[i];		if constexpr (item_type == ItemType::cell) {
			m_ref_cell_list_vector.push_back(ref_item_list);
			} else if constexpr (item_type == ItemType::face) {
			m_ref_face_list_vector.push_back(ref_item_list);
			} else if constexpr (item_type == ItemType::edge) {
			m_ref_edge_list_vector.push_back(ref_item_list);
			} else if constexpr (item_type == ItemType::node) {
			m_ref_node_list_vector.push_back(ref_item_list);
			} else {
			static_assert(is_false_item_type_v<item_type>, "Unexpected item type");
			}
	}		}

	PASTIS_INLINE		PASTIS_INLINE
	@@ -624,7 +611,18 @@ class Connectivity final

	CellValue<const double> invCellNbNodes() const		CellValue<const double> invCellNbNodes() const
	{		{
	#warning add calculation on demand when variables will be defined		if (not m_inv_cell_nb_nodes.isBuilt()) {
			const auto& cell_to_node_matrix
			= m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::node)];

			WeakCellValue<double> inv_cell_nb_nodes(*this);
			parallel_for(this->numberOfCells(), PASTIS_LAMBDA(const CellId& j) {
			const auto& cell_nodes = cell_to_node_matrix.rowConst(j);
			inv_cell_nb_nodes[j] = 1./cell_nodes.length;
			});
			const_cast<WeakCellValue<const double>&>(m_inv_cell_nb_nodes) = inv_cell_nb_nodes;
			}

	return m_inv_cell_nb_nodes;		return m_inv_cell_nb_nodes;
	}		}

src/mesh/ConnectivityDescriptor.hpp

0 → 100644

+121 −0

Original line number	Original line	Diff line number	Diff line
			#ifndef CONNECTIVITY_DESCRIPTOR_HPP
			#define CONNECTIVITY_DESCRIPTOR_HPP

			#include <RefItemList.hpp>
			#include <PastisTraits.hpp>
			#include <ItemOfItemType.hpp>

			#include <vector>

			class ConnectivityDescriptor
			{
			private:
			std::vector<RefCellList> m_ref_cell_list_vector;
			std::vector<RefFaceList> m_ref_face_list_vector;
			std::vector<RefEdgeList> m_ref_edge_list_vector;
			std::vector<RefNodeList> m_ref_node_list_vector;

			public:
			std::vector<std::vector<unsigned int>> cell_to_node_vector;
			std::vector<std::vector<unsigned int>> cell_to_face_vector;
			std::vector<std::vector<unsigned int>> cell_to_edge_vector;

			std::vector<std::vector<unsigned int>> face_to_node_vector;
			std::vector<std::vector<unsigned int>> face_to_edge_vector;

			std::vector<std::vector<unsigned int>> edge_to_node_vector;

			template <typename ItemOfItemT>
			auto& itemOfItemVector()
			{
			if constexpr (std::is_same_v<ItemOfItemT,NodeOfCell>) {
			return cell_to_node_vector;
			} else if constexpr (std::is_same_v<ItemOfItemT,FaceOfCell>) {
			return cell_to_face_vector;
			} else if constexpr (std::is_same_v<ItemOfItemT,EdgeOfCell>) {
			return cell_to_edge_vector;
			} else if constexpr (std::is_same_v<ItemOfItemT,EdgeOfFace>) {
			return face_to_edge_vector;
			} else if constexpr (std::is_same_v<ItemOfItemT,NodeOfFace>) {
			return face_to_node_vector;
			} else if constexpr (std::is_same_v<ItemOfItemT,NodeOfEdge>) {
			return edge_to_node_vector;
			} else {
			static_assert(is_false_v<ItemOfItemT>, "Unexpected item of item type");
			}
			}

			std::vector<Array<bool>> cell_face_is_reversed_vector;
			std::vector<Array<bool>> face_edge_is_reversed_vector;

			std::vector<CellType> cell_type_vector;

			std::vector<int> cell_number_vector;
			std::vector<int> face_number_vector;
			std::vector<int> edge_number_vector;
			std::vector<int> node_number_vector;

			template <ItemType item_type>
			const std::vector<int>& itemNumberVector() const
			{
			if constexpr (item_type == ItemType::cell) {
			return cell_number_vector;
			} else if constexpr (item_type == ItemType::face) {
			return face_number_vector;
			} else if constexpr (item_type == ItemType::edge) {
			return edge_number_vector;
			} else if constexpr (item_type == ItemType::node) {
			return node_number_vector;
			} else {
			static_assert(is_false_item_type_v<item_type>, "Unexpected item type");
			}
			}

			std::vector<int> cell_owner_vector;
			std::vector<int> face_owner_vector;
			std::vector<int> edge_owner_vector;
			std::vector<int> node_owner_vector;

			template <ItemType item_type>
			const std::vector<RefItemList<item_type>>& refItemListVector() const
			{
			if constexpr (item_type == ItemType::cell) {
			return m_ref_cell_list_vector;
			} else if constexpr (item_type == ItemType::face) {
			return m_ref_face_list_vector;
			} else if constexpr (item_type == ItemType::edge) {
			return m_ref_edge_list_vector;
			} else if constexpr (item_type == ItemType::node) {
			return m_ref_node_list_vector;
			} else {
			static_assert(is_false_item_type_v<item_type>, "Unexpected item type");
			}
			}

			template <ItemType item_type>
			void addRefItemList(const RefItemList<item_type>& ref_item_list)
			{
			if constexpr (item_type == ItemType::cell) {
			m_ref_cell_list_vector.push_back(ref_item_list);
			} else if constexpr (item_type == ItemType::face) {
			m_ref_face_list_vector.push_back(ref_item_list);
			} else if constexpr (item_type == ItemType::edge) {
			m_ref_edge_list_vector.push_back(ref_item_list);
			} else if constexpr (item_type == ItemType::node) {
			m_ref_node_list_vector.push_back(ref_item_list);
			} else {
			static_assert(is_false_item_type_v<item_type>, "Unexpected item type");
			}
			}

			ConnectivityDescriptor& operator=(const ConnectivityDescriptor&) = delete;
			ConnectivityDescriptor& operator=(ConnectivityDescriptor&&) = delete;

			ConnectivityDescriptor() = default;
			ConnectivityDescriptor(const ConnectivityDescriptor&) = default;
			ConnectivityDescriptor(ConnectivityDescriptor&&) = delete;
			~ConnectivityDescriptor() = default;
			};


			#endif // CONNECTIVITY_DESCRIPTOR_HPP

src/mesh/ConnectivityDispatcher.cpp

+345 −305

File changed.

Preview size limit exceeded, changes collapsed.

src/mesh/ConnectivityDispatcher.hpp

+111 −8

Original line number	Original line	Diff line number	Diff line
	@@ -6,6 +6,7 @@
	#include <ItemValueUtils.hpp>		#include <ItemValueUtils.hpp>

	#include <unordered_map>		#include <unordered_map>
			#include <ConnectivityDescriptor.hpp>

	template <int Dimension>		template <int Dimension>
	class ConnectivityDispatcher		class ConnectivityDispatcher
	@@ -23,8 +24,8 @@ class ConnectivityDispatcher
	{		{
	using ItemId = ItemIdT<item_type>;		using ItemId = ItemIdT<item_type>;
	ItemValue<const int, item_type> m_new_owner;		ItemValue<const int, item_type> m_new_owner;
			Array<const unsigned int> m_list_to_send_size_by_proc;
	std::vector<Array<const ItemId>> m_list_to_send_by_proc;		std::vector<Array<const ItemId>> m_list_to_send_by_proc;
	#warning is m_list_to_recv_size_by_proc really necessary?
	Array<const unsigned int> m_list_to_recv_size_by_proc;		Array<const unsigned int> m_list_to_recv_size_by_proc;
	std::unordered_map<int, int> m_number_to_id_map;		std::unordered_map<int, int> m_number_to_id_map;
	std::vector<Array<const ItemId>> m_recv_id_correspondance_by_proc;		std::vector<Array<const ItemId>> m_recv_id_correspondance_by_proc;
	@@ -65,36 +66,138 @@ class ConnectivityDispatcher
	}		}
	}		}

			template <typename ItemToItem>
			struct DispatchedItemOfItemInfo
			{
			std::vector<Array<const int>> m_number_of_sub_item_per_item_to_recv_by_proc;
			std::vector<Array<const int>> m_sub_item_numbers_to_recv_by_proc;
			};

			DispatchedItemOfItemInfo<NodeOfCell> m_dispatched_node_of_cell_info;
			DispatchedItemOfItemInfo<EdgeOfCell> m_dispatched_edge_of_cell_info;
			DispatchedItemOfItemInfo<FaceOfCell> m_dispatched_face_of_cell_info;

			DispatchedItemOfItemInfo<NodeOfEdge> m_dispatched_node_of_edge_info;
			DispatchedItemOfItemInfo<FaceOfEdge> m_dispatched_face_of_edge_info;
			DispatchedItemOfItemInfo<CellOfEdge> m_dispatched_cell_of_edge_info;

			DispatchedItemOfItemInfo<NodeOfFace> m_dispatched_node_of_face_info;
			DispatchedItemOfItemInfo<EdgeOfFace> m_dispatched_edge_of_face_info;
			DispatchedItemOfItemInfo<CellOfFace> m_dispatched_cell_of_face_info;

			DispatchedItemOfItemInfo<EdgeOfNode> m_dispatched_edge_of_node_info;
			DispatchedItemOfItemInfo<FaceOfNode> m_dispatched_face_of_node_info;
			DispatchedItemOfItemInfo<CellOfNode> m_dispatched_cell_of_node_info;

			template <typename ItemOfItem>
			PASTIS_INLINE
			DispatchedItemOfItemInfo<ItemOfItem>& _dispatchedInfo()
			{
			if constexpr (std::is_same_v<NodeOfCell, ItemOfItem>) {
			return m_dispatched_node_of_cell_info;
			} else if constexpr (std::is_same_v<EdgeOfCell, ItemOfItem>) {
			return m_dispatched_edge_of_cell_info;
			} else if constexpr (std::is_same_v<FaceOfCell, ItemOfItem>) {
			return m_dispatched_face_of_cell_info;
			} else if constexpr (std::is_same_v<NodeOfEdge, ItemOfItem>) {
			return m_dispatched_node_of_edge_info;
			} else if constexpr (std::is_same_v<FaceOfEdge, ItemOfItem>) {
			return m_dispatched_face_of_edge_info;
			} else if constexpr (std::is_same_v<CellOfEdge, ItemOfItem>) {
			return m_dispatched_cell_of_edge_info;
			} else if constexpr (std::is_same_v<NodeOfFace, ItemOfItem>) {
			return m_dispatched_node_of_face_info;
			} else if constexpr (std::is_same_v<EdgeOfFace, ItemOfItem>) {
			return m_dispatched_edge_of_face_info;
			} else if constexpr (std::is_same_v<CellOfFace, ItemOfItem>) {
			return m_dispatched_cell_of_face_info;
			} else if constexpr (std::is_same_v<EdgeOfNode, ItemOfItem>) {
			return m_dispatched_edge_of_node_info;
			} else if constexpr (std::is_same_v<FaceOfNode, ItemOfItem>) {
			return m_dispatched_face_of_node_info;
			} else if constexpr (std::is_same_v<CellOfNode, ItemOfItem>) {
			return m_dispatched_cell_of_node_info;
			} else {
			static_assert(is_false_v<ItemOfItem>, "Unexpected ItemOfItem type");
			}
			}

			template <typename ItemOfItem>
			PASTIS_INLINE
			const DispatchedItemOfItemInfo<ItemOfItem>& _dispatchedInfo() const
			{
			if constexpr (std::is_same_v<NodeOfCell, ItemOfItem>) {
			return m_dispatched_node_of_cell_info;
			} else if constexpr (std::is_same_v<EdgeOfCell, ItemOfItem>) {
			return m_dispatched_edge_of_cell_info;
			} else if constexpr (std::is_same_v<FaceOfCell, ItemOfItem>) {
			return m_dispatched_face_of_cell_info;
			} else if constexpr (std::is_same_v<NodeOfEdge, ItemOfItem>) {
			return m_dispatched_node_of_edge_info;
			} else if constexpr (std::is_same_v<FaceOfEdge, ItemOfItem>) {
			return m_dispatched_face_of_edge_info;
			} else if constexpr (std::is_same_v<CellOfEdge, ItemOfItem>) {
			return m_dispatched_cell_of_edge_info;
			} else if constexpr (std::is_same_v<NodeOfFace, ItemOfItem>) {
			return m_dispatched_node_of_face_info;
			} else if constexpr (std::is_same_v<EdgeOfFace, ItemOfItem>) {
			return m_dispatched_edge_of_face_info;
			} else if constexpr (std::is_same_v<CellOfFace, ItemOfItem>) {
			return m_dispatched_cell_of_face_info;
			} else if constexpr (std::is_same_v<EdgeOfNode, ItemOfItem>) {
			return m_dispatched_edge_of_node_info;
			} else if constexpr (std::is_same_v<FaceOfNode, ItemOfItem>) {
			return m_dispatched_face_of_node_info;
			} else if constexpr (std::is_same_v<CellOfNode, ItemOfItem>) {
			return m_dispatched_cell_of_node_info;
			} else {
			static_assert(is_false_v<ItemOfItem>, "Unexpected ItemOfItem type");
			}
			}

	template <ItemType item_type>		template <ItemType item_type>
	void _buildNewOwner();		void _buildNewOwner();

	template <ItemType item_type>		template <ItemType item_type>
	void _buildItemListToSend();		void _buildItemListToSend();

	Array<const unsigned int> _buildNbCellToSend();

	void _buildCellNumberIdMap();		void _buildCellNumberIdMap();

	template <typename ItemOfItemT>		template <typename ItemOfItemT>
	void _buildSubItemNumberToIdMap(const std::vector<Array<const int>>& recv_cell_node_number_by_proc);		void _buildSubItemNumberToIdMap();

			template <ItemType item_type>
			void _buildItemToExchangeLists();

			template <ItemType item_type>
			void _buildNumberOfItemToExchange();

			template <typename ItemOfItemT>
			void _buildItemToSubItemDescriptor();

			void _dispatchEdges();
	void _dispatchFaces();		void _dispatchFaces();

	template<typename DataType, ItemType item_type, typename ConnectivityPtr>		template<typename DataType, ItemType item_type, typename ConnectivityPtr>
	void _gatherFrom(const ItemValue<DataType, item_type, ConnectivityPtr>& data_to_gather,		void _gatherFrom(const ItemValue<DataType, item_type, ConnectivityPtr>& data_to_gather,
	std::vector<std::remove_const_t<DataType>>& gathered_vector);		std::vector<std::remove_const_t<DataType>>& gathered_vector);

			template<typename DataType, typename ItemOfItem, typename ConnectivityPtr>
			void _gatherFrom(const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>& data_to_gather,
			std::vector<Array<std::remove_const_t<DataType>>>& gathered_vector);

	template <typename SubItemOfItemT>		template <typename SubItemOfItemT>
	std::vector<Array<const int>>		void _buildNumberOfSubItemPerItemToRecvByProc();
	_getRecvNumberOfSubItemPerItemByProc();

	template <typename SubItemOfItemT>		template <typename SubItemOfItemT>
	std::vector<Array<const int>>		void _buildSubItemNumbersToRecvByProc();
	_getRecvItemSubItemNumberingByProc(const std::vector<Array<const int>>& recv_number_of_sub_item_per_item_by_proc);

	template <ItemType item_type>		template <ItemType item_type>
	void _buildRecvItemIdCorrespondanceByProc();		void _buildRecvItemIdCorrespondanceByProc();

			template <ItemType item_type>
			void _buildItemReferenceList();

	public:		public:
	std::shared_ptr<const ConnectivityType>		std::shared_ptr<const ConnectivityType>
	dispatchedConnectivity() const		dispatchedConnectivity() const

src/mesh/GmshReader.cpp

+416 −172

File changed.

Preview size limit exceeded, changes collapsed.

src/mesh/GmshReader.hpp

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -262,6 +262,9 @@ private:
	template <size_t Dimension>		template <size_t Dimension>
	void __computeCellFaceAndFaceNodeConnectivities(ConnectivityDescriptor& descriptor);		void __computeCellFaceAndFaceNodeConnectivities(ConnectivityDescriptor& descriptor);

			template <size_t Dimension>
			void __computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(ConnectivityDescriptor& descriptor);

	template <int Dimension>		template <int Dimension>
	void _dispatch();		void _dispatch();

src/mesh/ItemToItemMatrix.hpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -83,7 +83,7 @@ class ItemToItemMatrix
	PASTIS_INLINE		PASTIS_INLINE
	const auto& operator[](const IndexType& source_id) const		const auto& operator[](const IndexType& source_id) const
	{		{
	static_assert(std::is_same<IndexType, SourceItemId>(),		static_assert(std::is_same_v<IndexType, SourceItemId>,
	"ItemToItemMatrix must be indexed using correct ItemId");		"ItemToItemMatrix must be indexed using correct ItemId");
	using RowType = decltype(m_connectivity_matrix.rowConst(source_id));		using RowType = decltype(m_connectivity_matrix.rowConst(source_id));
	return SubItemList<RowType>(m_connectivity_matrix.rowConst(source_id));		return SubItemList<RowType>(m_connectivity_matrix.rowConst(source_id));

src/mesh/ItemType.hpp

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -118,4 +118,8 @@ struct ItemTypeId<3>
	}		}
	};		};

			template <ItemType item_type>
			PASTIS_INLINE
			constexpr bool is_false_item_type_v = false;

	#endif // ITEM_TYPE_HPP		#endif // ITEM_TYPE_HPP

src/mesh/ItemValue.hpp

+1 −4

Original line number	Original line	Diff line number	Diff line
	@@ -95,13 +95,10 @@ class ItemValue
	}		}

	template <typename IndexType>		template <typename IndexType>
	DataType& operator[](const IndexType& i) const noexcept(NO_ASSERT)		DataType& operator[](const IndexType&) const noexcept(NO_ASSERT)
	{		{
	static_assert(std::is_same_v<IndexType,ItemId>,		static_assert(std::is_same_v<IndexType,ItemId>,
	"ItemValue must be indexed by ItemId");		"ItemValue must be indexed by ItemId");
	static_assert(not std::is_const_v<DataType>,
	"Cannot modify ItemValue of const");
	return m_values[i];
	}		}

	PASTIS_INLINE		PASTIS_INLINE

src/mesh/Mesh.hpp

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -11,7 +11,6 @@
	struct IMesh		struct IMesh
	{		{
	virtual size_t dimension() const = 0;		virtual size_t dimension() const = 0;
	// virtual CSRGraph cellToCellGraph() const = 0;
	~IMesh() = default;		~IMesh() = default;
	};		};

	@@ -66,7 +65,6 @@ public:
	return m_xr;		return m_xr;
	}		}

	[[deprecated("should rework this class: quite ugly")]]
	PASTIS_INLINE		PASTIS_INLINE
	NodeValue<Rd> mutableXr() const		NodeValue<Rd> mutableXr() const
	{		{

src/mesh/MeshData.hpp

+6 −2

Original line number	Original line	Diff line number	Diff line
	@@ -178,13 +178,11 @@ class MeshData
	const FaceId& l = cell_faces[L];		const FaceId& l = cell_faces[L];
	const auto& face_nodes = face_to_node_matrix[l];		const auto& face_nodes = face_to_node_matrix[l];

	#warning should this lambda be replaced by a precomputed correspondance?
	auto local_node_number_in_cell		auto local_node_number_in_cell
	= [&](const NodeId& node_number) {		= [&](const NodeId& node_number) {
	for (size_t i_node=0; i_node<cell_nodes.size(); ++i_node) {		for (size_t i_node=0; i_node<cell_nodes.size(); ++i_node) {
	if (node_number == cell_nodes[i_node]) {		if (node_number == cell_nodes[i_node]) {
	return i_node;		return i_node;
	break;
	}		}
	}		}
	return std::numeric_limits<size_t>::max();		return std::numeric_limits<size_t>::max();
	@@ -227,31 +225,37 @@ class MeshData
	}		}

	public:		public:
			PASTIS_INLINE
	const MeshType& mesh() const		const MeshType& mesh() const
	{		{
	return m_mesh;		return m_mesh;
	}		}

			PASTIS_INLINE
	const NodeValuePerCell<const Rd>& Cjr() const		const NodeValuePerCell<const Rd>& Cjr() const
	{		{
	return m_Cjr;		return m_Cjr;
	}		}

			PASTIS_INLINE
	const NodeValuePerCell<const double>& ljr() const		const NodeValuePerCell<const double>& ljr() const
	{		{
	return m_ljr;		return m_ljr;
	}		}

			PASTIS_INLINE
	const NodeValuePerCell<const Rd>& njr() const		const NodeValuePerCell<const Rd>& njr() const
	{		{
	return m_njr;		return m_njr;
	}		}

			PASTIS_INLINE
	const CellValue<const Rd>& xj() const		const CellValue<const Rd>& xj() const
	{		{
	return m_xj;		return m_xj;
	}		}

			PASTIS_INLINE
	const CellValue<const double>& Vj() const		const CellValue<const double>& Vj() const
	{		{
	return m_Vj;		return m_Vj;

src/mesh/MeshNodeBoundary.hpp

+3 −7

Original line number	Original line	Diff line number	Diff line
	@@ -7,8 +7,7 @@
	#include <Kokkos_Vector.hpp>		#include <Kokkos_Vector.hpp>
	#include <TinyVector.hpp>		#include <TinyVector.hpp>

	#include <RefNodeList.hpp>		#include <RefItemList.hpp>
	#include <RefFaceList.hpp>

	#include <ConnectivityMatrix.hpp>		#include <ConnectivityMatrix.hpp>
	#include <IConnectivity.hpp>		#include <IConnectivity.hpp>
	@@ -38,7 +37,7 @@ class MeshNodeBoundary
	const auto& face_to_cell_matrix		const auto& face_to_cell_matrix
	= mesh.connectivity().faceToCellMatrix();		= mesh.connectivity().faceToCellMatrix();

	const Array<const FaceId>& face_list = ref_face_list.faceList();		const Array<const FaceId>& face_list = ref_face_list.list();
	parallel_for(face_list.size(), PASTIS_LAMBDA(const int& l){		parallel_for(face_list.size(), PASTIS_LAMBDA(const int& l){
	const auto& face_cells = face_to_cell_matrix[face_list[l]];		const auto& face_cells = face_to_cell_matrix[face_list[l]];
	if (face_cells.size()>1) {		if (face_cells.size()>1) {
	@@ -74,7 +73,7 @@ class MeshNodeBoundary

	template <typename MeshType>		template <typename MeshType>
	MeshNodeBoundary(const MeshType&, const RefNodeList& ref_node_list)		MeshNodeBoundary(const MeshType&, const RefNodeList& ref_node_list)
	: m_node_list(ref_node_list.nodeList())		: m_node_list(ref_node_list.list())
	{		{
	static_assert(Dimension == MeshType::Dimension);		static_assert(Dimension == MeshType::Dimension);
	}		}
	@@ -288,7 +287,6 @@ _getNormal(const MeshType& mesh)
	zmax = x;		zmax = x;
	}		}
	}		}
	#warning re work this part to avoir parallelism dependance
	Array<R3> xmin_array = parallel::allGather(xmin);		Array<R3> xmin_array = parallel::allGather(xmin);
	Array<R3> xmax_array = parallel::allGather(xmax);		Array<R3> xmax_array = parallel::allGather(xmax);
	Array<R3> ymin_array = parallel::allGather(ymin);		Array<R3> ymin_array = parallel::allGather(ymin);
	@@ -321,7 +319,6 @@ _getNormal(const MeshType& mesh)
	if (x[2] > zmax[2]) { zmax = x; }		if (x[2] > zmax[2]) { zmax = x; }
	}		}


	const R3 u = xmax-xmin;		const R3 u = xmax-xmin;
	const R3 v = ymax-ymin;		const R3 v = ymax-ymin;
	const R3 w = zmax-zmin;		const R3 w = zmax-zmin;
	@@ -356,7 +353,6 @@ _getNormal(const MeshType& mesh)

	normal *= 1./sqrt(normal_l2);		normal *= 1./sqrt(normal_l2);

	#warning Add flatness test
	// this->_checkBoundaryIsFlat(normal, xmin, xmax, mesh);		// this->_checkBoundaryIsFlat(normal, xmin, xmax, mesh);

	return normal;		return normal;

src/mesh/RefFaceList.hpp

deleted100644 → 0

+0 −40

Original line number	Original line	Diff line number	Diff line
	#ifndef REF_FACE_LIST_HPP
	#define REF_FACE_LIST_HPP

	#include <Array.hpp>
	#include <RefId.hpp>

	class RefFaceList
	{
	private:
	RefId m_ref_id;
	Array<const FaceId> m_face_id_list;

	public:
	const RefId& refId() const
	{
	return m_ref_id;
	}

	const Array<const FaceId>& faceList() const
	{
	return m_face_id_list;
	}

	RefFaceList(const RefId& ref_id,
	const Array<const FaceId>& face_id_list)
	: m_ref_id(ref_id),
	m_face_id_list(face_id_list)
	{
	;
	}

	RefFaceList& operator=(const RefFaceList&) = default;
	RefFaceList& operator=(RefFaceList&&) = default;

	RefFaceList() = default;
	RefFaceList(const RefFaceList&) = default;
	~RefFaceList() = default;
	};

	#endif // REF_FACE_LIST_HPP

src/mesh/RefItemList.hpp

0 → 100644

+50 −0

Original line number	Original line	Diff line number	Diff line
			#ifndef REF_ITEM_LIST_HPP
			#define REF_ITEM_LIST_HPP

			#include <Array.hpp>
			#include <RefId.hpp>
			#include <ItemId.hpp>

			template <ItemType item_type>
			class RefItemList
			{
			public:
			using ItemId = ItemIdT<item_type>;

			private:
			RefId m_ref_id;
			Array<const ItemId> m_item_id_list;

			public:
			const RefId& refId() const
			{
			return m_ref_id;
			}

			const Array<const ItemId>& list() const
			{
			return m_item_id_list;
			}

			RefItemList(const RefId& ref_id,
			const Array<const ItemId>& item_id_list)
			: m_ref_id(ref_id),
			m_item_id_list(item_id_list)
			{
			;
			}

			RefItemList& operator=(const RefItemList&) = default;
			RefItemList& operator=(RefItemList&&) = default;

			RefItemList() = default;
			RefItemList(const RefItemList&) = default;
			~RefItemList() = default;
			};

			using RefNodeList = RefItemList<ItemType::node>;
			using RefEdgeList = RefItemList<ItemType::edge>;
			using RefFaceList = RefItemList<ItemType::face>;
			using RefCellList = RefItemList<ItemType::cell>;

			#endif // REF_ITEM_LIST_HPP

src/mesh/RefNodeList.hpp

deleted100644 → 0

+0 −40

Original line number	Original line	Diff line number	Diff line
	#ifndef REF_NODE_LIST_HPP
	#define REF_NODE_LIST_HPP

	#include <Array.hpp>
	#include <RefId.hpp>

	class RefNodeList
	{
	private:
	RefId m_ref_id;
	Array<const NodeId> m_node_id_list;

	public:
	const RefId& refId() const
	{
	return m_ref_id;
	}

	const Array<const NodeId>& nodeList() const
	{
	return m_node_id_list;
	}

	RefNodeList(const RefId& ref_id,
	const Array<const NodeId>& node_id_list)
	: m_ref_id(ref_id),
	m_node_id_list(node_id_list)
	{
	;
	}

	RefNodeList& operator=(const RefNodeList&) = default;
	RefNodeList& operator=(RefNodeList&&) = default;

	RefNodeList() = default;
	RefNodeList(const RefNodeList&) = default;
	~RefNodeList() = default;
	};

	#endif // REF_NODE_LIST_HPP

src/mesh/SubItemValuePerItem.hpp

+1 −11

Original line number	Original line	Diff line number	Diff line
	@@ -17,20 +17,10 @@

	#include <memory>		#include <memory>

	// template <typename DataType,
	// typename ItemOfItem,
	// typename ConnectivityPtr = std::shared_ptr<const IConnectivity>,
	// typename Allowed=void>
	// class SubItemValuePerItem;

	template <typename DataType,		template <typename DataType,
	typename ItemOfItem,		typename ItemOfItem,
	typename ConnectivityPtr = std::shared_ptr<const IConnectivity>>		typename ConnectivityPtr = std::shared_ptr<const IConnectivity>>
	class SubItemValuePerItem// <DataType,		class SubItemValuePerItem
	// ItemOfItem,
	// ConnectivityPtr// ,
	// // std::enable_if_t<sub_item_type != item_type>
	// >
	{		{
	public:		public:
	static constexpr ItemType item_type{ItemOfItem::item_type};		static constexpr ItemType item_type{ItemOfItem::item_type};

src/scheme/BoundaryCondition.hpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -6,7 +6,7 @@

	#include <Array.hpp>		#include <Array.hpp>

	#include <RefNodeList.hpp>		#include <RefItemList.hpp>
	#include <MeshNodeBoundary.hpp>		#include <MeshNodeBoundary.hpp>

	class BoundaryCondition		class BoundaryCondition

src/utils/Messenger.cpp

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -26,7 +26,8 @@ void Messenger::destroy()
	}		}

	Messenger::		Messenger::
	Messenger(int& argc, char* argv[])		Messenger([[maybe_unused]] int& argc,
			[[maybe_unused]] char* argv[])
	{		{
	#ifdef PASTIS_HAS_MPI		#ifdef PASTIS_HAS_MPI
	MPI_Init(&argc, &argv);		MPI_Init(&argc, &argv);

src/utils/Messenger.hpp

+19 −18

Original line number	Original line	Diff line number	Diff line
	@@ -37,7 +37,7 @@ class Messenger
	} else {		} else {
	static_assert(std::is_arithmetic_v<DataType>,		static_assert(std::is_arithmetic_v<DataType>,
	"Unexpected arithmetic type! Should not occur!");		"Unexpected arithmetic type! Should not occur!");
	static_assert(not std::is_arithmetic_v<DataType>,		static_assert(is_false_v<DataType>,
	"MPI_Datatype are only defined for arithmetic types!");		"MPI_Datatype are only defined for arithmetic types!");
	return MPI_Datatype();		return MPI_Datatype();
	}		}
	@@ -138,7 +138,8 @@ class Messenger
	}		}

	template <typename DataType>		template <typename DataType>
	void _broadcast_value(DataType& data, const size_t& root_rank) const		void _broadcast_value([[maybe_unused]] DataType& data,
			[[maybe_unused]] const size_t& root_rank) const
	{		{
	static_assert(not std::is_const_v<DataType>);		static_assert(not std::is_const_v<DataType>);
	static_assert(std::is_arithmetic_v<DataType>);		static_assert(std::is_arithmetic_v<DataType>);
	@@ -152,7 +153,8 @@ class Messenger
	}		}

	template <typename ArrayType>		template <typename ArrayType>
	void _broadcast_array(ArrayType& array, const size_t& root_rank) const		void _broadcast_array([[maybe_unused]] ArrayType& array,
			[[maybe_unused]] const size_t& root_rank) const
	{		{
	using DataType = typename ArrayType::data_type;		using DataType = typename ArrayType::data_type;
	static_assert(not std::is_const_v<DataType>);		static_assert(not std::is_const_v<DataType>);
	@@ -231,6 +233,7 @@ class Messenger
	}		}
	}		}

			if (request_list.size()>0) {
	std::vector<MPI_Status> status_list(request_list.size());		std::vector<MPI_Status> status_list(request_list.size());
	if (MPI_SUCCESS != MPI_Waitall(request_list.size(), &(request_list[0]), &(status_list[0]))) {		if (MPI_SUCCESS != MPI_Waitall(request_list.size(), &(request_list[0]), &(status_list[0]))) {
	// LCOV_EXCL_START		// LCOV_EXCL_START
	@@ -238,6 +241,7 @@ class Messenger
	std::exit(1);		std::exit(1);
	// LCOV_EXCL_STOP		// LCOV_EXCL_STOP
	}		}
			}

	#else // PASTIS_HAS_MPI		#else // PASTIS_HAS_MPI
	Assert(sent_array_list.size() == 1);		Assert(sent_array_list.size() == 1);
	@@ -377,7 +381,7 @@ class Messenger

	_allGather(cast_value_array, cast_gather_array);		_allGather(cast_value_array, cast_gather_array);
	} else {		} else {
	static_assert(is_trivially_castable<DataType>, "unexpected type of data");		static_assert(is_false_v<DataType>, "unexpected type of data");
	}		}
	return gather_array;		return gather_array;
	}		}
	@@ -401,7 +405,7 @@ class Messenger

	_allGather(cast_array, cast_gather_array);		_allGather(cast_array, cast_gather_array);
	} else {		} else {
	static_assert(is_trivially_castable<DataType>, "unexpected type of data");		static_assert(is_false_v<DataType>, "unexpected type of data");
	}		}
	return gather_array;		return gather_array;
	}		}
	@@ -430,7 +434,7 @@ class Messenger
	auto recv_cast_array = cast_array_to<CastType>::from(recv_array);		auto recv_cast_array = cast_array_to<CastType>::from(recv_array);
	_allToAll(send_cast_array, recv_cast_array);		_allToAll(send_cast_array, recv_cast_array);
	} else {		} else {
	static_assert(is_trivially_castable<DataType>, "unexpected type of data");		static_assert(is_false_v<DataType>, "unexpected type of data");
	}		}
	return recv_array;		return recv_array;
	}		}
	@@ -453,8 +457,7 @@ class Messenger
	_broadcast_array(cast_array, root_rank);		_broadcast_array(cast_array, root_rank);
	}		}
	} else {		} else {
	static_assert(is_trivially_castable<DataType>,		static_assert(is_false_v<DataType>, "unexpected type of data");
	"unexpected non trivial type of data");
	}		}
	}		}

	@@ -483,8 +486,7 @@ class Messenger
	auto cast_array = cast_array_to<CastType>::from(array);		auto cast_array = cast_array_to<CastType>::from(array);
	_broadcast_array(cast_array, root_rank);		_broadcast_array(cast_array, root_rank);
	} else{		} else{
	static_assert(is_trivially_castable<DataType>,		static_assert(is_false_v<DataType>, "unexpected type of data");
	"unexpected non trivial type of data");
	}		}
	}		}

	@@ -521,8 +523,7 @@ class Messenger
	using CastType = helper::split_cast_t<DataType>;		using CastType = helper::split_cast_t<DataType>;
	_exchange_through_cast<SendDataType, CastType>(send_array_list, recv_array_list);		_exchange_through_cast<SendDataType, CastType>(send_array_list, recv_array_list);
	} else {		} else {
	static_assert(is_trivially_castable<RecvDataType>,		static_assert(is_false_v<RecvDataType>, "unexpected type of data");
	"unexpected non trivial type of data");
	}		}
	}		}

src/utils/Partitioner.cpp

+1 −3

Original line number	Original line	Diff line number	Diff line
	@@ -60,8 +60,6 @@ Array<int> Partitioner::partition(const CSRGraph& graph)
	part = Array<int>(local_number_of_nodes);		part = Array<int>(local_number_of_nodes);
	std::vector<int> vtxdist{0,local_number_of_nodes};		std::vector<int> vtxdist{0,local_number_of_nodes};

	static_assert(std::is_same<int, int>());

	const Array<int>& entries = graph.entries();		const Array<int>& entries = graph.entries();
	const Array<int>& neighbors = graph.neighbors();		const Array<int>& neighbors = graph.neighbors();

	@@ -85,7 +83,7 @@ Array<int> Partitioner::partition(const CSRGraph& graph)

	#else // PASTIS_HAS_MPI		#else // PASTIS_HAS_MPI

	Array<int> Partitioner::partition(const CSRGraph& graph)		Array<int> Partitioner::partition(const CSRGraph&)
	{		{
	return Array<int>(0);		return Array<int>(0);
	}		}

src/utils/PastisTraits.hpp

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -19,4 +19,7 @@ inline constexpr bool is_trivially_castable<TinyMatrix<N,T>> = is_trivially_cast
	template <size_t N, typename T>		template <size_t N, typename T>
	inline constexpr bool is_trivially_castable<const TinyMatrix<N,T>> = is_trivially_castable<T>;		inline constexpr bool is_trivially_castable<const TinyMatrix<N,T>> = is_trivially_castable<T>;

			template <typename T>
			inline constexpr bool is_false_v = false;

	#endif // PASTIS_TRAITS_HPP		#endif // PASTIS_TRAITS_HPP

src/utils/SignalManager.cpp

+1 −3

Original line number	Original line	Diff line number	Diff line
	@@ -36,9 +36,7 @@ std::string SignalManager::signalName(const int& signal)
	void SignalManager::pauseForDebug(const int& signal)		void SignalManager::pauseForDebug(const int& signal)
	{		{
	if (std::string(PASTIS_BUILD_TYPE) != "Release") {		if (std::string(PASTIS_BUILD_TYPE) != "Release") {
	#warning should try to detect if outputs to a terminal (buggy with mpi)		if (s_pause_on_error == "yes") {
	if (// (ConsoleManager::isTerminal(pout()) and (s_pause_on_error == "auto")) or
	(s_pause_on_error == "yes")) {
	std::cerr << "\n======================================\n"		std::cerr << "\n======================================\n"
	<< rang::style::reset		<< rang::style::reset
	<< rang::fg::reset		<< rang::fg::reset

Original line number	Original line	Diff line number	Diff line
	@@ -74,9 +74,9 @@ int main(int argc, char *argv[])
	case BoundaryConditionDescriptor::Type::symmetry: {		case BoundaryConditionDescriptor::Type::symmetry: {
	const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor		const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor
	= dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(*bc_descriptor);		= dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(*bc_descriptor);
	for (size_t i_ref_node_list=0; i_ref_node_list<mesh.connectivity().numberOfRefNodeList();		for (size_t i_ref_node_list=0; i_ref_node_list<mesh.connectivity().numberOfRefItemList<ItemType::node>();
	++i_ref_node_list) {		++i_ref_node_list) {
	const RefNodeList& ref_node_list = mesh.connectivity().refNodeList(i_ref_node_list);		const RefNodeList& ref_node_list = mesh.connectivity().refItemList<ItemType::node>(i_ref_node_list);
	const RefId& ref = ref_node_list.refId();		const RefId& ref = ref_node_list.refId();
	if (ref == sym_bc_descriptor.boundaryDescriptor()) {		if (ref == sym_bc_descriptor.boundaryDescriptor()) {
	SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc		SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc
	@@ -191,9 +191,9 @@ int main(int argc, char *argv[])
	case BoundaryConditionDescriptor::Type::symmetry: {		case BoundaryConditionDescriptor::Type::symmetry: {
	const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor		const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor
	= dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(*bc_descriptor);		= dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(*bc_descriptor);
	for (size_t i_ref_face_list=0; i_ref_face_list<mesh.connectivity().numberOfRefFaceList();		for (size_t i_ref_face_list=0; i_ref_face_list<mesh.connectivity().numberOfRefItemList<ItemType::face>();
	++i_ref_face_list) {		++i_ref_face_list) {
	const RefFaceList& ref_face_list = mesh.connectivity().refFaceList(i_ref_face_list);		const RefFaceList& ref_face_list = mesh.connectivity().refItemList<ItemType::face>(i_ref_face_list);
	const RefId& ref = ref_face_list.refId();		const RefId& ref = ref_face_list.refId();
	if (ref == sym_bc_descriptor.boundaryDescriptor()) {		if (ref == sym_bc_descriptor.boundaryDescriptor()) {
	SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc		SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc
	@@ -295,9 +295,9 @@ int main(int argc, char *argv[])
	case BoundaryConditionDescriptor::Type::symmetry: {		case BoundaryConditionDescriptor::Type::symmetry: {
	const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor		const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor
	= dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(*bc_descriptor);		= dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(*bc_descriptor);
	for (size_t i_ref_face_list=0; i_ref_face_list<mesh.connectivity().numberOfRefFaceList();		for (size_t i_ref_face_list=0; i_ref_face_list<mesh.connectivity().numberOfRefItemList<ItemType::face>();
	++i_ref_face_list) {		++i_ref_face_list) {
	const RefFaceList& ref_face_list = mesh.connectivity().refFaceList(i_ref_face_list);		const RefFaceList& ref_face_list = mesh.connectivity().refItemList<ItemType::face>(i_ref_face_list);
	const RefId& ref = ref_face_list.refId();		const RefId& ref = ref_face_list.refId();
	if (ref == sym_bc_descriptor.boundaryDescriptor()) {		if (ref == sym_bc_descriptor.boundaryDescriptor()) {
	SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc		SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc

Source

Target

Files