The DBGVAR now can write almost every varible. Moreover it recognizes (31128a4b) · Commits · Tomáš Jakubec / GTMesh

Unstructured_mesh/MeshNativeType.h

+13 −1

Original line number	Diff line number	Diff line
		@@ -9,11 +9,23 @@ struct MeshNativeType{
		template<>
		struct MeshNativeType<2>{
		enum ElementType{
		LINE = 1,
		LINE = 200,
		TRIANGLE,
		QUAD,
		POLYGON
		};
		};

		template<>
		struct MeshNativeType<3>{
		enum ElementType{
		TETRA = 300,
		HEXAHEDRON,
		WEDGE,
		PYRAMID,
		N_PYRAMID,
		POLYHEDRON
		};
		};

		#endif // MESHNATIVETYPE_H

Unstructured_mesh/Unstructured_mesh.pro

+1 −0

Original line number	Diff line number	Diff line
		@@ -8,6 +8,7 @@ SOURCES += \
		../debug/debug.cpp

		HEADERS += \
		../debug/consolelogger.h \
		CellBoundaryConnection.h \
		CellConnection.h \
		ComputationalySignificantElement.h \

Unstructured_mesh/Unstructured_mesh.pro.user

+1 −1

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="UTF-8"?>
		<!DOCTYPE QtCreatorProject>
		<!-- Written by QtCreator 4.10.0, 2019-10-01T16:36:35. -->
		<!-- Written by QtCreator 4.10.0, 2019-10-02T13:13:57. -->
		<qtcreator>
		<data>
		<variable>EnvironmentId</variable>

Unstructured_mesh/VTKMeshReader.h

+162 −0

Original line number	Diff line number	Diff line
		@@ -180,4 +180,166 @@ public:
		};


		template<typename IndexType, typename Real, unsigned int... Reserve>
		class VTKMeshReader<3, IndexType, Real, Reserve...> : public MeshReader<3, IndexType, Real>{
		using reader = MeshReader<3, IndexType, Real>;
		std::map<int, typename reader::type::ElementType> TypeConversionTable{
		{10, reader::type::ElementType::TETRA},
		{11, reader::type::ElementType::HEXAHEDRON},
		{12, reader::type::ElementType::HEXAHEDRON},
		{13, reader::type::ElementType::WEDGE},
		{14, reader::type::ElementType::PYRAMID},
		};

		std::unordered_map<std::string, IndexType> edges;
		std::unordered_map<std::string, IndexType> faces;

		MeshDataContainer<typename reader::type::ElementType, 3> cellTypes;
		// file indexing
		//

		//
		//MeshDataContainer<IndexType>
		public:
		VTKMeshReader() = default;
		VTKMeshReader(const MeshElements<3, IndexType, Real, Reserve...>&){}

		MeshDataContainer<typename reader::type::ElementType, 3> getCellTypes() {
		return cellTypes;
		}

		void loadPoints(std::istream& ist, MeshElements<3, IndexType, Real, Reserve...>& mesh){
		IndexType numPoints;
		ist >> numPoints;
		Real dummy = 0;
		mesh.getVertices().resize(numPoints);
		ist.ignore(20, '\n');
		for (IndexType vertIndex = 0; vertIndex < numPoints; vertIndex++) {
		mesh.getVertices().at(vertIndex).setIndex(vertIndex);
		ist >> mesh.getVertices().at(vertIndex)[0];
		ist >> mesh.getVertices().at(vertIndex)[1];
		ist >> mesh.getVertices().at(vertIndex)[2];
		}
		}

		void loadCells(std::istream& ist, MeshElements<3, IndexType, Real, Reserve...>& mesh){
		IndexType numCells;
		ist >> numCells;
		mesh.getCells().resize(numCells);
		// Skip the total number of numbers
		ist.ignore(50, '\n');
		for (IndexType cellIndex = 0; cellIndex < numCells; cellIndex++) {
		mesh.getCells().at(cellIndex).setIndex(cellIndex);
		IndexType numVert;
		ist >> numVert;

		std::vector<IndexType> vertices(numVert);
		for(IndexType j = 0; j < numVert; j++){
		ist >> vertices.at(j);
		}

		IndexType prevEdge = INVALID_INDEX(IndexType);
		for(IndexType j = 0; j < numVert; j++){
		IndexType iA = vertices.at(j), iB = vertices.at((j+1)%numVert);
		std::string edgeKey = iA < iB ? std::to_string(iA) +";"+ std::to_string(iB) : std::to_string(iB) +";"+ std::to_string(iA);
		typename std::unordered_map<std::string, IndexType>::iterator edgeIt = edges.find(edgeKey);

		IndexType edgeIndex = IndexType();

		if (edgeIt == edges.end()){

		edgeIndex = mesh.getEdges().size();
		mesh.getEdges().push_back({});
		mesh.getEdges().at(edgeIndex).setVertexAIndex(iA);
		mesh.getEdges().at(edgeIndex).setVertexBIndex(iB);
		mesh.getEdges().at(edgeIndex).setIndex(edgeIndex);

		mesh.getEdges().at(edgeIndex).setCellLeftIndex(cellIndex);
		} else {
		edgeIndex = edgeIt->second;
		mesh.getEdges().at(edgeIt->second).setCellRightIndex(cellIndex);
		}

		if (prevEdge != INVALID_INDEX(IndexType)){
		mesh.getEdges().at(prevEdge).setNextBElem(edgeIndex, cellIndex);
		}

		if (j == 0){
		mesh.getCells().at(cellIndex).setBoundaryElementIndex(edgeIndex);
		}
		if (j == numVert - 1) {
		mesh.getEdges().at(edgeIndex).setNextBElem(mesh.getCells().at(cellIndex).getBoundaryElementIndex(), cellIndex);
		}
		prevEdge = edgeIndex;
		}

		}
		}


		void loadCellTypes(std::istream& ist, MeshElements<3, IndexType, Real, Reserve...>& mesh){
		IndexType numCells;
		ist >> numCells;
		cellTypes.alocateData(mesh);
		for (IndexType i = 0; i < numCells; i++) {
		int vtkType = 0;
		ist >> vtkType;
		typename std::map<int, typename reader::type::ElementType>::iterator typeIt = TypeConversionTable.find(vtkType);
		if (typeIt != TypeConversionTable.end()){
		cellTypes.template getDataByPos<0>().at(i) = typeIt->second;
		} else {
		std::runtime_error("unsuported cell type");
		}
		}
		}


		void loadFromStream(std::istream& ist,MeshElements<3, IndexType, Real, Reserve...>& mesh){
		ist.seekg(ist.beg);
		// Ignore first row "# vtk DataFile Version 2.0"
		ist.ignore(1024, '\n');
		// Ignore name of the data set
		ist.ignore(1024, '\n');
		// ASCII or BINARY
		std::string buf;
		std::getline(ist, buf);
		if (buf != "ASCII"){
		throw std::runtime_error("ASCII expected but got " + buf);
		}

		ist >> buf;
		if (buf != "DATASET"){
		throw std::runtime_error("the keyword DATASET expected");
		}

		ist >> buf;
		if (buf != "UNSTRUCTURED_GRID"){
		throw std::runtime_error("only unstructured grid is supported but got " + buf);
		}


		ist >> buf;
		if (buf == "POINTS") {
		loadPoints(ist, mesh);
		}

		ist >> buf;
		if (buf == "CELLS") {
		loadCells(ist, mesh);
		}

		ist >> buf;
		if (buf == "CELL_TYPES") {
		loadCellTypes(ist, mesh);
		}

		}

		MeshElements<3, IndexType, Real, Reserve...> loadFromStream(std::istream& ist){
		MeshElements<3, IndexType, Real, Reserve...> resultMesh;
		loadFromStream(ist, resultMesh);
		return resultMesh;
		}
		};

		#endif // VTKMESHREADER_H

Unstructured_mesh/main.cpp

+71 −55

Original line number	Diff line number	Diff line
		@@ -5,6 +5,7 @@
		#include "VTKMeshReader.h"
		#include "VTKMeshWriter.h"
		#include <fstream>
		#include <list>
		using namespace std;


		@@ -311,19 +312,19 @@ void testMesh2D() {
		DBGMSG("cell boundary iterator test");

		for(auto i : cell.getSubelements()){
		DBGVAR(i)
		DBGVAR(i);
		}


		for(auto i : mesh.getElement<2>(1).getSubelements()){
		DBGVAR(i)
		DBGVAR(i);
		}

		DBGMSG("cell vertices using iterator");
		for(size_t i = 0; i < mesh.getCells().size(); i++){
		for(auto j : mesh.getElement<2>(i).getSubelements()){
		auto e = mesh.getElement<1>(j);
		DBGVAR(e.getElement().getVertexAIndex(), e.getElement().getVertexBIndex())
		DBGVAR(e.getElement().getVertexAIndex(), e.getElement().getVertexBIndex());
		}
		}

		@@ -332,9 +333,9 @@ void testMesh2D() {
		DBGMSG("vertices of cells in 2D");
		for (auto& cell : mesh.getCells()){
		std::set<size_t>& _set = vertices.at(cell);
		DBGVAR(cell.getIndex())
		DBGVAR(cell.getIndex());
		for (size_t index: _set){
		DBGVAR(index)
		DBGVAR(index);
		}
		}

		@@ -344,11 +345,11 @@ void testMesh2D() {

		auto& faceCent = centers.getDataByDim<1>();
		for(auto& center : faceCent) {
		DBGVAR(center)
		DBGVAR(center);
		}
		DBGMSG("cellCenter");
		for(sit::Cell& cell : mesh.getCells()){
		DBGVAR(centers.getDataByDim<2>().at(cell.getIndex()))
		DBGVAR(centers.getDataByDim<2>().at(cell.getIndex()));
		}


		@@ -358,11 +359,11 @@ void testMesh2D() {


		for(double edgeM :measures.getDataByDim<1>()) {
		DBGVAR(edgeM)
		DBGVAR(edgeM);
		}

		for(double cellM :measures.getDataByDim<2>()) {
		DBGVAR(cellM)
		DBGVAR(cellM);
		}


		@@ -371,14 +372,14 @@ void testMesh2D() {

		auto normals = ComputeFaceNormals(mesh);
		for(auto& edge : mesh.getEdges()){
		DBGVAR(edge.getIndex(),normals.at(edge))
		DBGVAR(edge.getIndex(),normals.at(edge));
		}

		DBGMSG("2D cells distances");

		auto distances = ComputeCellsDistance(mesh);
		for(auto& edge : mesh.getEdges()){
		DBGVAR(edge.getIndex(),distances.at(edge))
		DBGVAR(edge.getIndex(),distances.at(edge));
		}

		}
		@@ -391,21 +392,21 @@ void testMesh2DLoadAndWrite(){
		DBGMSG("load from vtk file test");
		VTKMeshReader<2, size_t, double> reader;
		ifstream ifst("Test_obdelnik.vtk");
		DBGVAR(bool(ifst))
		DBGVAR(bool(ifst));
		reader.loadFromStream(ifst, mesh);

		DBGVAR(mesh.getVertices().size(), mesh.getVertices().at(4),mesh.getCells().size())
		DBGVAR(mesh.getVertices().size(), mesh.getVertices().at(4),mesh.getCells().size());


		DBGMSG("mesh apply test");
		temp1::MeshRun<2, 2, 0, 2,false, true>::run(mesh,size_t(4), size_t(4), [](unsigned int S, unsigned int T, size_t ori, size_t i){
		DBGVAR(S,T,ori,i)
		DBGVAR(S,T,ori,i);
		});

		mesh.initializeCenters();
		auto normals = mesh.computeFaceNormals();
		auto measures = mesh.computeElementMeasures();
		DBGVAR(normals.getDataByPos<0>().at(0), measures.getDataByDim<2>().at(100), measures.getDataByDim<1>().at(100), mesh.getCells().at(100).getCenter())
		DBGVAR(normals.getDataByPos<0>().at(0), measures.getDataByDim<2>().at(100), measures.getDataByDim<1>().at(100), mesh.getCells().at(100).getCenter());

		VTKMeshWriter<2,size_t, double> writer;
		ofstream ofst("test_mesh_export.vtk");
		@@ -422,11 +423,11 @@ void testMesh3D() {
		size_t tmp_face = mesh3.getCells().at(0).getBoundaryElementIndex();

		do {
		DBGVAR(tmp_face)
		DBGVAR(tmp_face);
		for (auto& sube : mesh3.getFaces().at(tmp_face).getSubelements()) {
		DBGVAR(sube.index)
		DBGVAR(sube.index);
		if (sube.index != INVALID_INDEX(size_t) ){
		DBGVAR(sube.index, mesh3.getVertices().at(mesh3.getEdges().at(sube.index).getVertexAIndex()),mesh3.getVertices().at(mesh3.getEdges().at(sube.index).getVertexBIndex()))
		DBGVAR(sube.index, mesh3.getVertices().at(mesh3.getEdges().at(sube.index).getVertexAIndex()),mesh3.getVertices().at(mesh3.getEdges().at(sube.index).getVertexBIndex()));
		}
		}

		@@ -438,7 +439,7 @@ void testMesh3D() {
		DBGMSG("Iterator wrapper test");
		sit3::MeshElementWrap<2> elem(&mesh3, mesh3.getFaces().at(0));
		for(auto i : elem.getSubelements()){
		DBGVAR(i.index)
		DBGVAR(i.index);
		}


		@@ -451,11 +452,11 @@ void testMesh3D() {


		//cont.getDataByDim<3>().resize(20);
		DBGVAR(cont.getDataByPos<1>().size())
		DBGVAR(cont.getDataByPos<1>().size());

		DBGVAR(cont.getDataByPos<0>().size())
		DBGVAR(cont.getDataByPos<0>().size());

		DBGVAR(cont.getDataByDim<3>().size())
		DBGVAR(cont.getDataByDim<3>().size());


		DBGMSG("faceCenters");
		@@ -467,26 +468,26 @@ void testMesh3D() {

		for(auto& face : mesh3.getFaces()) {
		face.setCenter(centers.template getDataByDim<2>().at(face.getIndex()));
		DBGVAR(face.getCenter())
		DBGVAR(face.getCenter());
		}
		DBGMSG("cellCenter");
		for(auto& cell : mesh3.getCells()) {
		cell.setCenter(centers.template getDataByDim<3>().at(cell.getIndex()));
		DBGVAR(cell.getCenter())
		DBGVAR(cell.getCenter());
		}

		DBGMSG("measure computation");

		auto measures = ComputeMeasures(mesh3);
		for(double edgeM : measures.getDataByDim<1>()) {
		DBGVAR(edgeM)
		DBGVAR(edgeM);
		}
		for(double faceM : measures.getDataByDim<2>()) {
		DBGVAR(faceM)
		DBGVAR(faceM);
		}

		for(double cellM : measures.getDataByDim<3>()) {
		DBGVAR(cellM)
		DBGVAR(cellM);
		}


		@@ -494,25 +495,25 @@ void testMesh3D() {

		auto normals = mesh3.computeFaceNormals();
		for(auto& face : mesh3.getFaces()){
		DBGVAR(face.getIndex(),normals.at(face))
		DBGVAR(face.getIndex(),normals.at(face));
		}

		DBGMSG("mesh apply test");
		temp1::MeshApply<3, 2, 3>::apply(mesh3, [](unsigned int S, unsigned int T, size_t ori, size_t i){
		DBGVAR(S,T,ori,i)
		DBGVAR(S,T,ori,i);
		});
		DBGMSG("mesh apply test");
		temp1::MeshApply<2, 3, 3>::apply(mesh3,[](unsigned int S, unsigned int T, size_t ori, size_t i){
		DBGVAR(S,T,ori,i)
		DBGVAR(S,T,ori,i);
		});


		DBGMSG("connection test");
		auto con = temp1::MeshConnections<3,0>::connections(mesh3);
		for (auto& cell : mesh3.getCells()){
		DBGVAR(cell.getIndex())
		DBGVAR(cell.getIndex());
		for(size_t i : con[cell]){
		DBGVAR(i)
		DBGVAR(i);
		}
		}

		@@ -520,22 +521,22 @@ void testMesh3D() {
		DBGMSG("connection test oposite");
		auto con1 = temp1::MeshConnections<0,3>::connections(mesh3);
		for (auto& vert : mesh3.getVertices()){
		DBGVAR(vert.getIndex())
		DBGVAR(vert.getIndex());
		for(size_t i : con1[vert]){
		DBGVAR(i)
		DBGVAR(i);
		}
		}

		DBGMSG("face to vertex colouring");
		auto colours = temp1::ColourMesh<2,0>::colour(mesh3);
		for (auto& face : mesh3.getFaces()){
		DBGVAR(face.getIndex(), colours.at(face))
		DBGVAR(face.getIndex(), colours.at(face));
		}

		DBGMSG("vertex to face colouring");
		auto colours1 = temp1::ColourMesh<0,2>::colour(mesh3);
		for (auto& vert : mesh3.getVertices()){
		DBGVAR(vert.getIndex(), colours1.at(vert))
		DBGVAR(vert.getIndex(), colours1.at(vert));
		}
		}

		@@ -551,26 +552,26 @@ void test3DMeshDeformedPrisms() {

		for(auto& face : mesh3.getFaces()) {
		face.setCenter(centers[face]);
		DBGVAR(face.getCenter())
		DBGVAR(face.getCenter());
		}
		DBGMSG("cellCenter");
		for(auto& cell : mesh3.getCells()) {
		cell.setCenter(centers[cell]);
		DBGVAR(cell.getCenter())
		DBGVAR(cell.getCenter());
		}

		DBGMSG("measure computation");

		auto measures = ComputeMeasures(mesh3);
		for(double edgeM : measures.getDataByDim<1>()) {
		DBGVAR(edgeM)
		DBGVAR(edgeM);
		}
		for(double faceM : measures.getDataByDim<2>()) {
		DBGVAR(faceM)
		DBGVAR(faceM);
		}

		for(double cellM : measures.getDataByDim<3>()) {
		DBGVAR(cellM)
		DBGVAR(cellM);
		}
		}

		@@ -595,25 +596,25 @@ void testMeshDataContainer() {
		}

		for(auto& v : mesh3.getVertices()){
		DBGVAR(container.at(v))
		DBGVAR(container.at(v));
		}

		MeshDataContainer<std::tuple<int, double, char, int>, 3, 2, 0, 2> containerIni(mesh3,3, 42.15, 'a', 15);

		for (auto& val : containerIni.getDataByPos<0>()){
		DBGVAR(val)
		DBGVAR(val);
		}

		for (auto& val : containerIni.getDataByPos<1>()){
		DBGVAR(val)
		DBGVAR(val);
		}

		for (auto& val : containerIni.getDataByPos<2>()){
		DBGVAR(val)
		DBGVAR(val);
		}

		for (auto& val : containerIni.getDataByPos<3>()){
		DBGVAR(val)
		DBGVAR(val);
		}
		}

		@@ -622,10 +623,10 @@ class ClassA
		{
		public:
		ClassA (std::integer_sequence<unsigned int,Is...>)
		{DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})) }
		{DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})); }

		static void fun (std::index_sequence<Is...>)
		{DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})) }
		{DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})); }

		};

		@@ -638,7 +639,7 @@ class ClassB
		public:
		ClassB (const std::integer_sequence<unsigned int, Is...>, Tuple t)
		{std::tuple_element_t<0,Tuple> typ = 0;
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), std::get<0>(t), typ) }
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), std::get<0>(t), typ); }

		};

		@@ -651,12 +652,12 @@ class ClassC<std::integer_sequence<unsigned int,Is...>, std::tuple<Types...>>
		public:
		ClassC (const std::integer_sequence<unsigned int, Is...>, std::tuple<Types...>)
		{std::tuple_element_t<0,std::tuple<Types...>> typ = 0;
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ) }
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ); }

		ClassC () {
		std::tuple_element_t<0,std::tuple<Types...>> typ = 42.15;
		std::tuple_element_t<1,std::tuple<Types...>> typ2 = 42.15;
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ, typ2)
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ, typ2);
		}
		};

		@@ -679,17 +680,32 @@ void testTemplate() {
		}



		void testDebug() {
		double r = 42.15;
		int i = 15;
		char c = 42;
		bool b = false;
		std::list<int> list = {1,2,3};
		std::vector<std::list<int>> vec(5, list);
		std::map<std::string, size_t> m{
		{"prvni", 1},
		{"druhy", 2},
		{"treti", 3}
		};
		ConsoleLogger::writeVar(__LINE__, __FILE__, "r", r, "i", i, "c", c, "list", list, "vec", vec, "b", b, "map", m);
		DBGVAR(r, i, c, list, vec, b, m);
		}


		int main()
		{
		//testMesh2D();
		testMesh2DLoadAndWrite();
		//testMesh3D();
		//testMesh2DLoadAndWrite();
		testMesh3D();
		//test3DMeshDeformedPrisms();
		//testMeshDataContainer();
		//testTemplate();
		UnstructuredMesh<5, size_t, double, 6,5,4> m;
		//UnstructuredMesh<5, size_t, double, 6,5,4> m;
		//m.ComputeElementMeasures();

		}