Refactor (72800df0) · Commits · Tomáš Jakubec / GTMesh

src/UnstructuredMesh/MeshDataContainer/MeshDataContainer.h

+27 −23

src/UnstructuredMesh/MeshElements/MeshElement.h

+30 −7

Original line number	Original line	Diff line number	Diff line
	@@ -35,7 +35,7 @@ public:
	elementIndex = index;		elementIndex = index;
	}		}

	IndexType getIndex(){		IndexType getIndex() const {
	return elementIndex;		return elementIndex;
	}		}

	@@ -65,15 +65,15 @@ class SubelementContainer : public std::array<Subelement<IndexType>, Reserve>{
	unsigned int numberOfElements = 0;		unsigned int numberOfElements = 0;

	public:		public:
	unsigned int getNumberOfSubElements(){		unsigned int getNumberOfSubElements() const {
	return numberOfElements;		return numberOfElements;
	}		}

	unsigned int size() {		unsigned int size() const {
	return numberOfElements;		return numberOfElements;
	}		}

	unsigned int reserve() {		unsigned int reserve() const {
	return Reserve;		return Reserve;
	}		}

	@@ -206,11 +206,11 @@ public:



	IndexType getVertexAIndex(){		IndexType getVertexAIndex() const {
	return vertexAIndex;		return vertexAIndex;
	}		}

	IndexType getVertexBIndex(){		IndexType getVertexBIndex() const {
	return vertexBIndex;		return vertexBIndex;
	}		}

	@@ -250,7 +250,7 @@ public:

	}		}

	IndexType getBoundaryElementIndex(){		IndexType getBoundaryElementIndex() const {
	return boundaryElementIndex;		return boundaryElementIndex;
	}		}

	@@ -348,6 +348,29 @@ public:
	std::vector<Cell>& getBoundaryCells() {		std::vector<Cell>& getBoundaryCells() {
	return BoundaryCells;		return BoundaryCells;
	}		}
			/*
			* Constant version of getters
			* */
			const std::vector<Vertex>& getVertices() const {
			return getElements<0>();
			}


			const std::vector<Edge>& getEdges() const {
			return getElements<1>();
			}

			const std::vector<Face>& getFaces() const {
			return getElements<Dimension - 1>();
			}

			const std::vector<Cell>& getCells() const {
			return getElements<Dimension>();
			}

			const std::vector<Cell>& getBoundaryCells() const {
			return BoundaryCells;
			}

	private:		private:
	template<unsigned int Dim, typename Dummy = void>		template<unsigned int Dim, typename Dummy = void>

src/UnstructuredMesh/MeshFunctions/CellsDistance.h

+1 −1

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


	template <unsigned int Dimension,typename IndexType, typename Real, unsigned int ...Reserve>		template <unsigned int Dimension,typename IndexType, typename Real, unsigned int ...Reserve>
	MeshDataContainer<Real, Dimension-1> ComputeCellsDistance(MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){		MeshDataContainer<Real, Dimension-1> ComputeCellsDistance(const MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){

	MeshDataContainer<Real, Dimension-1> distances(mesh);		MeshDataContainer<Real, Dimension-1> distances(mesh);

src/UnstructuredMesh/MeshFunctions/ComputeCenter.h

+35 −30

Original line number	Original line	Diff line number	Diff line
	@@ -14,20 +14,24 @@ struct _ComputeCenters {
	template <typename IndexType, typename Real, unsigned int ...Reserve>		template <typename IndexType, typename Real, unsigned int ...Reserve>
	static void compute(		static void compute(
	MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>>& centers,		MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>>& centers,
	MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){		const MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){

	auto& elemCenters = centers.template getDataByDim<dim>();		auto& elemCenters = centers.template getDataByDim<dim>();
	auto& subElemCenters = centers.template getDataByDim<dim - 1>();		auto& subElemCenters = centers.template getDataByDim<dim - 1>();


	for (IndexType i = 0; i < mesh.template getElements<dim>().size(); i++) {		for (IndexType i = 0; i < mesh.template getElements<dim>().size(); i++) {
	auto& element = mesh.template getElements<dim>().at(i);

	Real subElemCnt = 0;		Real subElemCnt = 0;
	for(auto& sub : element.getSubelements()){		MeshApply<dim, dim - 1, Dimension>::apply(
	elemCenters.at(i) += subElemCenters.at(sub.index);		i,
			mesh,
			[&elemCenters, &subElemCenters, &subElemCnt](IndexType elementIndex, IndexType subelementIndex){

			elemCenters.at(elementIndex) += subElemCenters.at(subelementIndex);
	subElemCnt++;		subElemCnt++;
	}		}
			);

	elemCenters.at(i) /= subElemCnt;		elemCenters.at(i) /= subElemCnt;
	}		}
	@@ -44,22 +48,25 @@ struct _ComputeCenters {
	template <unsigned int Dimension, ComputationMethod Method>		template <unsigned int Dimension, ComputationMethod Method>
	struct _ComputeCenters<Dimension, Dimension, Method>{		struct _ComputeCenters<Dimension, Dimension, Method>{
	template <typename IndexType, typename Real, unsigned int ...Reserve>		template <typename IndexType, typename Real, unsigned int ...Reserve>
	static void compute(MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>>& centers,MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){		static void compute(MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>>& centers,
			const MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){

	auto& elemCenters = centers.template getDataByDim<Dimension>();		auto& elemCenters = centers.template getDataByDim<Dimension>();
	auto& subElemCenters = centers.template getDataByDim<Dimension - 1>();		auto& subElemCenters = centers.template getDataByDim<Dimension - 1>();


	for (IndexType i = 0; i < mesh.template getElements<Dimension>().size(); i++) {		for (IndexType i = 0; i < mesh.template getElements<Dimension>().size(); i++) {
	auto& element = mesh.template getElements<Dimension>().at(i);

	Real subElemCnt = 0;		Real subElemCnt = 0;
	IndexType tmpFaceIndex = element.getBoundaryElementIndex();		MeshApply<Dimension, Dimension - 1, Dimension>::apply(
	do {		i,
	elemCenters.at(i) += subElemCenters.at(tmpFaceIndex);		mesh,
			[&elemCenters, &subElemCenters, &subElemCnt](IndexType elementIndex, IndexType subelementIndex){

			elemCenters.at(elementIndex) += subElemCenters.at(subelementIndex);
	subElemCnt++;		subElemCnt++;
	tmpFaceIndex = mesh.getFaces()[tmpFaceIndex].getNextBElem(i);		}
	} while (tmpFaceIndex != element.getBoundaryElementIndex());		);

	elemCenters.at(i) /= subElemCnt;		elemCenters.at(i) /= subElemCnt;
	}		}
	@@ -72,7 +79,7 @@ struct _ComputeCenters<1, Dimension, Method>{
	template <typename IndexType, typename Real, unsigned int ...Reserve>		template <typename IndexType, typename Real, unsigned int ...Reserve>
	static void compute(		static void compute(
	MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>>& centers,		MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>>& centers,
	MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){		const MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){

	std::vector<Vertex<Dimension, Real>>& edgeCenters = centers.template getDataByDim<1>();		std::vector<Vertex<Dimension, Real>>& edgeCenters = centers.template getDataByDim<1>();

	@@ -98,40 +105,38 @@ struct _ComputeCenters<2, 3, ComputationMethod::TESSELLATED> {
	template <typename IndexType, typename Real, unsigned int ...Reserve>		template <typename IndexType, typename Real, unsigned int ...Reserve>
	static void compute(		static void compute(
	MakeMeshDataContainer_t<Vertex<3, Real>, make_custom_integer_sequence_t<unsigned int, 1, 3>>& centers,		MakeMeshDataContainer_t<Vertex<3, Real>, make_custom_integer_sequence_t<unsigned int, 1, 3>>& centers,
	MeshElements<3, IndexType, Real, Reserve...>& mesh){		const MeshElements<3, IndexType, Real, Reserve...>& mesh){
	DBGMSG("centers computation tessellated");
	auto& elemCenters = centers.template getDataByDim<2>();		auto& elemCenters = centers.template getDataByDim<2>();
	auto& subElemCenters = centers.template getDataByDim<2 - 1>();		auto& subElemCenters = centers.template getDataByDim<2 - 1>();

	for (IndexType i = 0; i < mesh.template getElements<2>().size(); i++) {		for (IndexType i = 0; i < mesh.template getElements<2>().size(); i++) {
	auto& element = mesh.template getElements<2>().at(i);

	Real subElemCnt = 0;		Real subElemCnt = 0;
	for(auto& sub : element.getSubelements()){		MeshApply<2, 1, 3>::apply(i, mesh,[&](IndexType faceIndex, IndexType edgeIndex){
	elemCenters.at(i) += subElemCenters.at(sub.index);
			elemCenters.at(faceIndex) += subElemCenters.at(edgeIndex);
	subElemCnt++;		subElemCnt++;
	}		});

	elemCenters.at(i) /= subElemCnt;
	}

	// calculate volume		elemCenters.at(i) /= subElemCnt;
	for (IndexType i = 0; i < mesh.template getElements<2>().size(); i++) {
	auto& element = mesh.template getElements<2>().at(i);

	Vertex<3, Real> tempVert = {};		Vertex<3, Real> tempVert = {};
	Real surfTotal = 0.0;		Real surfTotal = 0.0;
	for(auto& sub : element.getSubelements()){		MeshApply<2, 1, 3>::apply(i, mesh,[&](IndexType faceIndex, IndexType edgeIndex){
	IndexType AI = mesh.getEdges().at(sub.index).getVertexAIndex();
	IndexType BI = mesh.getEdges().at(sub.index).getVertexBIndex();		IndexType AI = mesh.getEdges().at(edgeIndex).getVertexAIndex();
	std::array<Vertex<3, Real>, 2> v = {elemCenters.at(i) - mesh.getVertices().at(AI), elemCenters.at(i) - mesh.getVertices().at(BI)};		IndexType BI = mesh.getEdges().at(edgeIndex).getVertexBIndex();
			std::array<Vertex<3, Real>, 2> v = {elemCenters.at(faceIndex) - mesh.getVertices().at(AI), elemCenters.at(faceIndex) - mesh.getVertices().at(BI)};
	std::array<Real, 2> norms;		std::array<Real, 2> norms;
	grammSchmidt<2, 3, IndexType, Real>(v, norms);		grammSchmidt<2, 3, IndexType, Real>(v, norms);
	Real surf = norms.at(0) * 0.5 * norms.at(1);		Real surf = norms.at(0) * 0.5 * norms.at(1);

	tempVert += subElemCenters.at(sub.index) * (surf * (2.0 / 3.0));		tempVert += subElemCenters.at(edgeIndex) * (surf * (2.0 / 3.0));
	surfTotal += surf;		surfTotal += surf;
	}		});


	elemCenters.at(i) = (elemCenters.at(i) / 3.0) + (tempVert / surfTotal);		elemCenters.at(i) = (elemCenters.at(i) / 3.0) + (tempVert / surfTotal);
	}		}
	@@ -144,7 +149,7 @@ struct _ComputeCenters<2, 3, ComputationMethod::TESSELLATED> {

	template <ComputationMethod Method, unsigned int Dimension,typename IndexType, typename Real, unsigned int ...Reserve>		template <ComputationMethod Method, unsigned int Dimension,typename IndexType, typename Real, unsigned int ...Reserve>
	MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>>		MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>>
	ComputeCenters(MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){		ComputeCenters(const MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){

	MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>> centers(mesh);		MakeMeshDataContainer_t<Vertex<Dimension, Real>, make_custom_integer_sequence_t<unsigned int, 1, Dimension>> centers(mesh);

src/UnstructuredMesh/MeshFunctions/MeshApply.h

+25 −12

Original line number	Original line	Diff line number	Diff line
	@@ -10,7 +10,7 @@ template <unsigned int CurrentDimension, unsigned int StartDimension, unsigned i
	struct MeshRun {		struct MeshRun {

	template<typename Func, typename IndexType, typename Real, unsigned int ...Reserve>		template<typename Func, typename IndexType, typename Real, unsigned int ...Reserve>
	static void run(MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,		static void run(const MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,
	IndexType origElementIndex,		IndexType origElementIndex,
	IndexType index,		IndexType index,
	Func fun){		Func fun){
	@@ -32,7 +32,7 @@ template <unsigned int StartDimension, unsigned int TargetDimension, unsigned in
	struct MeshRun<MeshDimension, StartDimension, TargetDimension, MeshDimension, false, Descend> {		struct MeshRun<MeshDimension, StartDimension, TargetDimension, MeshDimension, false, Descend> {

	template<typename Func, typename IndexType, typename Real, unsigned int ...Reserve>		template<typename Func, typename IndexType, typename Real, unsigned int ...Reserve>
	static void run(MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,		static void run(const MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,
	IndexType origElementIndex,		IndexType origElementIndex,
	IndexType index,		IndexType index,
	Func fun){		Func fun){
	@@ -55,7 +55,7 @@ template <unsigned int StartDimension, unsigned int TargetDimension, unsigned in
	struct MeshRun<1, StartDimension, TargetDimension, MeshDimension, false, Descend> {		struct MeshRun<1, StartDimension, TargetDimension, MeshDimension, false, Descend> {

	template<typename Func, typename IndexType, typename Real, unsigned int ...Reserve>		template<typename Func, typename IndexType, typename Real, unsigned int ...Reserve>
	static void run(MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,		static void run(const MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,
	IndexType origElementIndex,		IndexType origElementIndex,
	IndexType index,		IndexType index,
	Func fun){		Func fun){
	@@ -70,33 +70,46 @@ struct MeshRun<1, StartDimension, TargetDimension, MeshDimension, false, Descend



	template <unsigned int CurrentDimension,unsigned int StartDimension, unsigned int TargetDimension, unsigned int MeshDimension, bool Descend>		template <unsigned int CurrentDimension,unsigned int StartDimension, unsigned int TargetDimension, unsigned int MeshDimension>
	struct MeshRun<CurrentDimension, StartDimension, TargetDimension, MeshDimension, true, Descend> {		struct MeshRun<CurrentDimension, StartDimension, TargetDimension, MeshDimension, true, true> {

	template<typename Functor, typename IndexType, typename Real, unsigned int ...Reserve>		template<typename Functor, typename IndexType, typename Real, unsigned int ...Reserve>
	static void run(MeshElements<MeshDimension, IndexType, Real, Reserve...>& ,		static void run(const MeshElements<MeshDimension, IndexType, Real, Reserve...>& ,
	IndexType origElementIndex,		IndexType origElementIndex,
	IndexType index,		IndexType index,
	Functor fun){		Functor fun){
	static_assert (std::is_assignable<std::function<void(IndexType, IndexType)>,Functor>::value,		static_assert (std::is_assignable<std::function<void(IndexType, IndexType)>,Functor>::value,
	"The Functor fun must be a function with void return type and two arguments of IndexType,\		"The Functor fun must be a function with void return type and two arguments of IndexType,\
	the first is index of StartDimension element and the second is the index of the TargetDimension element");		the first is index of StartDimension element and the second is the index of the TargetDimension element");
	if(Descend){
	fun(origElementIndex, index);		fun(origElementIndex, index);
	}else{
	fun(index, origElementIndex);
	}
	}		}
	};		};

			template <unsigned int CurrentDimension,unsigned int StartDimension, unsigned int TargetDimension, unsigned int MeshDimension>
			struct MeshRun<CurrentDimension, StartDimension, TargetDimension, MeshDimension, true, false> {

			template<typename Functor, typename IndexType, typename Real, unsigned int ...Reserve>
			static void run(const MeshElements<MeshDimension, IndexType, Real, Reserve...>& ,
			IndexType origElementIndex,
			IndexType index,
			Functor fun){
			static_assert (std::is_assignable<std::function<void(IndexType, IndexType)>,Functor>::value,
			"The Functor fun must be a function with void return type and two arguments of IndexType,\
			the first is index of StartDimension element and the second is the index of the TargetDimension element");

			fun(index, origElementIndex);

			}
			};



	template <unsigned int StartDimension, unsigned int TargetDimension, unsigned int MeshDimension>		template <unsigned int StartDimension, unsigned int TargetDimension, unsigned int MeshDimension>
	struct MeshApply {		struct MeshApply {
	template<typename Functor, typename IndexType, typename Real, unsigned int ...Reserve>		template<typename Functor, typename IndexType, typename Real, unsigned int ...Reserve>
	static void apply(MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,		static void apply(const MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,
	Functor f) {		Functor f) {
	for (auto& startElement : mesh.template getElements<(StartDimension > TargetDimension) ? StartDimension : TargetDimension>()){		for (auto& startElement : mesh.template getElements<(StartDimension > TargetDimension) ? StartDimension : TargetDimension>()){
	MeshRun<		MeshRun<
	@@ -111,7 +124,7 @@ struct MeshApply {

	template<typename Functor, typename IndexType, typename Real, unsigned int ...Reserve>		template<typename Functor, typename IndexType, typename Real, unsigned int ...Reserve>
	static void apply(IndexType elementIndex,		static void apply(IndexType elementIndex,
	MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,		const MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,
	Functor f) {		Functor f) {
	MeshRun<		MeshRun<
	(StartDimension > TargetDimension) ? StartDimension : TargetDimension,		(StartDimension > TargetDimension) ? StartDimension : TargetDimension,

src/UnstructuredMesh/MeshElements/CellConnection.h

+5 −5

File changed.

Contains only whitespace changes.