Cell boundary iterator is succesfully done (789e1f9a) · Commits · Tomáš Jakubec / GTMesh

Unstructured_mesh/main.cpp

+24 −2

Original line number	Original line	Diff line number	Diff line
	@@ -63,12 +63,28 @@ int main()
	}		}

	for(size_t i = 0; i < 2; i++) {		for(size_t i = 0; i < 2; i++) {
	DBGVAR(mesh.GetCells().at(i).GetCenter(), mesh.CalculateCellMeasure(i));		DBGVAR(mesh.GetCells().at(i).GetCenter(), mesh.CalculateCellMeasure(i))
	DBGVAR(mesh.GetCells().at(i).GetFlag());		DBGVAR(mesh.GetCells().at(i).GetFlag())
	}		}
	DBGVAR(mesh.CalculateEdgeMeasure(2)/mesh.CalculateCellDist(0,1));		DBGVAR(mesh.CalculateEdgeMeasure(2)/mesh.CalculateCellDist(0,1));
	DBGVAR(mesh.CalculateFaceMeasureOverCellDist(2));		DBGVAR(mesh.CalculateFaceMeasureOverCellDist(2));


			sit::MeshElementWrap<1> ele(mesh.GetEdges().at(0));
			sit::MeshElementWrap<2> cell(&mesh, mesh.GetCells().at(0));

			DBGMSG("cell boundary iterator test");

			for(auto i : cell.GetSubelements()){
			DBGVAR(i)
			}




			DBGMSG("3D test");

			using sit3 = UnstructuredMesh<3, size_t, double, 6>;
	UnstructuredMesh<3, size_t, double, 6> mesh3;		UnstructuredMesh<3, size_t, double, 6> mesh3;
	size_t index = 0;		size_t index = 0;
	DBGCHECK;		DBGCHECK;
	@@ -152,6 +168,12 @@ DBGCHECK;
	// mesh3.GetElements<0>().at(0).;		// mesh3.GetElements<0>().at(0).;


			DBGMSG("Iterator wrapper test");
			sit3::MeshElementWrap<2> elem(&mesh3, mesh3.GetFaces().at(0));
			for(auto i : elem.GetSubelements()){
			DBGVAR(i.index);
			}

	MeshDataContainer<double, 3,2> cont(mesh3);		MeshDataContainer<double, 3,2> cont(mesh3);

	//cont.GetDataDim<3>().resize(20);		//cont.GetDataDim<3>().resize(20);

Unstructured_mesh/mesh_element.h

+112 −23

Original line number	Original line	Diff line number	Diff line
	@@ -109,6 +109,9 @@ struct emptyStruct{};
	struct emptyStruct2{};		struct emptyStruct2{};





	template <unsigned int MeshDim, unsigned int ElementDim, typename IndexType, typename Real, unsigned int Reserve = 0>		template <unsigned int MeshDim, unsigned int ElementDim, typename IndexType, typename Real, unsigned int Reserve = 0>
	class MeshElement : public MeshElementBase<IndexType>,		class MeshElement : public MeshElementBase<IndexType>,
	public std::conditional<ElementDim == MeshDim - 1,CellBoundaryConnection<IndexType>, emptyStruct>::type,		public std::conditional<ElementDim == MeshDim - 1,CellBoundaryConnection<IndexType>, emptyStruct>::type,
	@@ -146,15 +149,6 @@ public:












	template <unsigned int MeshDim, typename IndexType, typename Real, unsigned int Reserve>		template <unsigned int MeshDim, typename IndexType, typename Real, unsigned int Reserve>
	class MeshElement<MeshDim, 0, IndexType, Real, Reserve>		class MeshElement<MeshDim, 0, IndexType, Real, Reserve>
	: public MeshElementBase<IndexType>, public Vertex<MeshDim, Real>{		: public MeshElementBase<IndexType>, public Vertex<MeshDim, Real>{
	@@ -346,37 +340,132 @@ public:
	return GetElements<Dimension>();		return GetElements<Dimension>();
	}		}

	private:
	template<unsigned int _Dimension, typename Dummy = void>
	struct MeshSubelementIterator : public SubelementContainer<IndexType, reserve<_Dimension>>
	{

	};		struct CellSubelementIterator: public std::iterator<std::forward_iterator_tag, IndexType>

	template<typename Dummy>
	struct MeshSubelementIterator<Dimension, Dummy> : public std::iterator<std::forward_iterator_tag, IndexType>
	{		{

	IndexType Actual;		IndexType Actual;
	IndexType FirstBElem;		IndexType FirstBElem;
	IndexType Cell;		IndexType Cell;
			MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh;
	public:		public:
	MeshSubelementIterator(IndexType ci, IndexType act = INVALID_INDEX(IndexType)):Cell(ci){		CellSubelementIterator(IndexType ci, IndexType act, MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh):Cell(ci){
	FirstBElem = act == INVALID_INDEX(IndexType) ? GetCells().at(Cell).GetBElemeIndex() : act;		FirstBElem = act;
	Actual = FirstBElem;		Actual = FirstBElem;
			this->parentMesh = parentMesh;
	}		}
	MeshSubelementIterator& operator++ () {Actual = GetFaces().at(Actual).GetNextBElem(Cell) == FirstBElem ? INVALID_INDEX(IndexType) : GetFaces().at(Actual).GetNextBElem(Cell); return *this;}		CellSubelementIterator& operator++ () {Actual = parentMesh->GetFaces().at(Actual).GetNextBElem(Cell) == FirstBElem ? INVALID_INDEX(IndexType) : parentMesh->GetFaces().at(Actual).GetNextBElem(Cell); return *this;}
	MeshSubelementIterator& operator++ (int) {Actual = GetFaces().at(Actual).GetNextBElem(Cell) == FirstBElem ? INVALID_INDEX(IndexType) : GetFaces().at(Actual).GetNextBElem(Cell); return *this;}		CellSubelementIterator& operator++ (int) {Actual = parentMesh->GetFaces().at(Actual).GetNextBElem(Cell) == FirstBElem ? INVALID_INDEX(IndexType) : parentMesh->GetFaces().at(Actual).GetNextBElem(Cell); return *this;}
	IndexType operator* (){return Actual;}		IndexType operator* (){return Actual;}
	bool operator== (MeshSubelementIterator& it) {return Actual == it.Actual;}		bool operator== (CellSubelementIterator& it) {return Actual == it.Actual;}
	bool operator!= (MeshSubelementIterator& it) {return Actual != it.Actual;}		bool operator!= (CellSubelementIterator& it) {return Actual != it.Actual;}
			};

			class CellSubelements {
			IndexType cellIndex;
			MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh;
			public:
			CellSubelements(MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh, IndexType cellIndex){
			this->cellIndex = cellIndex;
			this->parentMesh = parentMesh;
			}

			CellSubelementIterator begin() {
			return CellSubelementIterator(cellIndex, parentMesh->GetCells()[cellIndex].GetBoundaryElementIndex(), parentMesh);
			}

			CellSubelementIterator end() {
			return CellSubelementIterator(cellIndex, INVALID_INDEX(IndexType), parentMesh);
			}
	};		};

			public:
			template<unsigned int ElementDim, typename Dummy = void>
			class MeshElementWrap {
			IndexType elementIndex;
			MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh;
			public:
			MeshElementWrap(MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh, MeshElement<Dimension, ElementDim, IndexType, Real, reserve<ElementDim>()>& meshElement){
			elementIndex = meshElement.GetIndex();
			this->parentMesh = parentMesh;
			}

			MeshElementWrap(MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh, IndexType elementIndex){
			this->elementIndex = elementIndex;
			this->parentMesh = parentMesh;
			}

			IndexType GetIndex(){
			return elementIndex;
			}

			SubelementContainer<IndexType, reserve<ElementDim>()>& GetSubelements(){
			return parentMesh->template GetElements<ElementDim>()[elementIndex].GetSubelements();
			}
	};		};


			template<typename Dummy>
			class MeshElementWrap<Dimension, Dummy> {
			IndexType elementIndex;
			MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh;
			public:
			MeshElementWrap(MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh, MeshElement<Dimension, Dimension, IndexType, Real, 0>& meshElement){
			elementIndex = meshElement.GetIndex();
			this->parentMesh = parentMesh;
			}

			MeshElementWrap(MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh, IndexType elementIndex){
			this->elementIndex = elementIndex;
			this->parentMesh = parentMesh;
			}

			IndexType GetIndex(){
			return elementIndex;
			}

			CellSubelements GetSubelements(){
			return CellSubelements(parentMesh, elementIndex);
			}
			};




			template<typename Dummy>
			class MeshElementWrap<1, Dummy> {
			IndexType elementIndex;
			public:
			MeshElementWrap(MeshElement<Dimension, 1, IndexType, Real, 0>& meshElement){
			elementIndex = meshElement.GetIndex();
			}

			MeshElementWrap(IndexType elementIndex){
			this->elementIndex = elementIndex;
			}

			IndexType GetIndex(){
			return elementIndex;
			}


			};



			};













	#endif // MESH_ELEMENT_H		#endif // MESH_ELEMENT_H