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

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

	#endif // MESHNATIVETYPE_H		#endif // MESHNATIVETYPE_H

Unstructured_mesh/Unstructured_mesh.pro

+1 −0

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

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

Unstructured_mesh/Unstructured_mesh.pro.user

+1 −1

Original line number	Original line	Diff line number	Diff line
	<?xml version="1.0" encoding="UTF-8"?>		<?xml version="1.0" encoding="UTF-8"?>
	<!DOCTYPE QtCreatorProject>		<!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>		<qtcreator>
	<data>		<data>
	<variable>EnvironmentId</variable>		<variable>EnvironmentId</variable>

Unstructured_mesh/VTKMeshReader.h

+162 −0

Original line number	Original line	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		#endif // VTKMESHREADER_H

Unstructured_mesh/main.cpp

+71 −55

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


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

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


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

	DBGMSG("cell vertices using iterator");		DBGMSG("cell vertices using iterator");
	for(size_t i = 0; i < mesh.getCells().size(); i++){		for(size_t i = 0; i < mesh.getCells().size(); i++){
	for(auto j : mesh.getElement<2>(i).getSubelements()){		for(auto j : mesh.getElement<2>(i).getSubelements()){
	auto e = mesh.getElement<1>(j);		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");		DBGMSG("vertices of cells in 2D");
	for (auto& cell : mesh.getCells()){		for (auto& cell : mesh.getCells()){
	std::set<size_t>& _set = vertices.at(cell);		std::set<size_t>& _set = vertices.at(cell);
	DBGVAR(cell.getIndex())		DBGVAR(cell.getIndex());
	for (size_t index: _set){		for (size_t index: _set){
	DBGVAR(index)		DBGVAR(index);
	}		}
	}		}

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

	auto& faceCent = centers.getDataByDim<1>();		auto& faceCent = centers.getDataByDim<1>();
	for(auto& center : faceCent) {		for(auto& center : faceCent) {
	DBGVAR(center)		DBGVAR(center);
	}		}
	DBGMSG("cellCenter");		DBGMSG("cellCenter");
	for(sit::Cell& cell : mesh.getCells()){		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>()) {		for(double edgeM :measures.getDataByDim<1>()) {
	DBGVAR(edgeM)		DBGVAR(edgeM);
	}		}

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


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

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

	DBGMSG("2D cells distances");		DBGMSG("2D cells distances");

	auto distances = ComputeCellsDistance(mesh);		auto distances = ComputeCellsDistance(mesh);
	for(auto& edge : mesh.getEdges()){		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");		DBGMSG("load from vtk file test");
	VTKMeshReader<2, size_t, double> reader;		VTKMeshReader<2, size_t, double> reader;
	ifstream ifst("Test_obdelnik.vtk");		ifstream ifst("Test_obdelnik.vtk");
	DBGVAR(bool(ifst))		DBGVAR(bool(ifst));
	reader.loadFromStream(ifst, mesh);		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");		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){		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();		mesh.initializeCenters();
	auto normals = mesh.computeFaceNormals();		auto normals = mesh.computeFaceNormals();
	auto measures = mesh.computeElementMeasures();		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;		VTKMeshWriter<2,size_t, double> writer;
	ofstream ofst("test_mesh_export.vtk");		ofstream ofst("test_mesh_export.vtk");
	@@ -422,11 +423,11 @@ void testMesh3D() {
	size_t tmp_face = mesh3.getCells().at(0).getBoundaryElementIndex();		size_t tmp_face = mesh3.getCells().at(0).getBoundaryElementIndex();

	do {		do {
	DBGVAR(tmp_face)		DBGVAR(tmp_face);
	for (auto& sube : mesh3.getFaces().at(tmp_face).getSubelements()) {		for (auto& sube : mesh3.getFaces().at(tmp_face).getSubelements()) {
	DBGVAR(sube.index)		DBGVAR(sube.index);
	if (sube.index != INVALID_INDEX(size_t) ){		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");		DBGMSG("Iterator wrapper test");
	sit3::MeshElementWrap<2> elem(&mesh3, mesh3.getFaces().at(0));		sit3::MeshElementWrap<2> elem(&mesh3, mesh3.getFaces().at(0));
	for(auto i : elem.getSubelements()){		for(auto i : elem.getSubelements()){
	DBGVAR(i.index)		DBGVAR(i.index);
	}		}


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


	//cont.getDataByDim<3>().resize(20);		//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");		DBGMSG("faceCenters");
	@@ -467,26 +468,26 @@ void testMesh3D() {

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

	DBGMSG("measure computation");		DBGMSG("measure computation");

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

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


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

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

	DBGMSG("mesh apply test");		DBGMSG("mesh apply test");
	temp1::MeshApply<3, 2, 3>::apply(mesh3, [](unsigned int S, unsigned int T, size_t ori, size_t i){		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");		DBGMSG("mesh apply test");
	temp1::MeshApply<2, 3, 3>::apply(mesh3,[](unsigned int S, unsigned int T, size_t ori, size_t i){		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");		DBGMSG("connection test");
	auto con = temp1::MeshConnections<3,0>::connections(mesh3);		auto con = temp1::MeshConnections<3,0>::connections(mesh3);
	for (auto& cell : mesh3.getCells()){		for (auto& cell : mesh3.getCells()){
	DBGVAR(cell.getIndex())		DBGVAR(cell.getIndex());
	for(size_t i : con[cell]){		for(size_t i : con[cell]){
	DBGVAR(i)		DBGVAR(i);
	}		}
	}		}

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

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

	DBGMSG("vertex to face colouring");		DBGMSG("vertex to face colouring");
	auto colours1 = temp1::ColourMesh<0,2>::colour(mesh3);		auto colours1 = temp1::ColourMesh<0,2>::colour(mesh3);
	for (auto& vert : mesh3.getVertices()){		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()) {		for(auto& face : mesh3.getFaces()) {
	face.setCenter(centers[face]);		face.setCenter(centers[face]);
	DBGVAR(face.getCenter())		DBGVAR(face.getCenter());
	}		}
	DBGMSG("cellCenter");		DBGMSG("cellCenter");
	for(auto& cell : mesh3.getCells()) {		for(auto& cell : mesh3.getCells()) {
	cell.setCenter(centers[cell]);		cell.setCenter(centers[cell]);
	DBGVAR(cell.getCenter())		DBGVAR(cell.getCenter());
	}		}

	DBGMSG("measure computation");		DBGMSG("measure computation");

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

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

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

	for(auto& v : mesh3.getVertices()){		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);		MeshDataContainer<std::tuple<int, double, char, int>, 3, 2, 0, 2> containerIni(mesh3,3, 42.15, 'a', 15);

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

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

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

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

	@@ -622,10 +623,10 @@ class ClassA
	{		{
	public:		public:
	ClassA (std::integer_sequence<unsigned int,Is...>)		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...>)		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:		public:
	ClassB (const std::integer_sequence<unsigned int, Is...>, Tuple t)		ClassB (const std::integer_sequence<unsigned int, Is...>, Tuple t)
	{std::tuple_element_t<0,Tuple> typ = 0;		{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:		public:
	ClassC (const std::integer_sequence<unsigned int, Is...>, std::tuple<Types...>)		ClassC (const std::integer_sequence<unsigned int, Is...>, std::tuple<Types...>)
	{std::tuple_element_t<0,std::tuple<Types...>> typ = 0;		{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 () {		ClassC () {
	std::tuple_element_t<0,std::tuple<Types...>> typ = 42.15;		std::tuple_element_t<0,std::tuple<Types...>> typ = 42.15;
	std::tuple_element_t<1,std::tuple<Types...>> typ2 = 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()		int main()
	{		{
	//testMesh2D();		//testMesh2D();
	testMesh2DLoadAndWrite();		//testMesh2DLoadAndWrite();
	//testMesh3D();		testMesh3D();
	//test3DMeshDeformedPrisms();		//test3DMeshDeformedPrisms();
	//testMeshDataContainer();		//testMeshDataContainer();
	//testTemplate();		//testTemplate();
	UnstructuredMesh<5, size_t, double, 6,5,4> m;		//UnstructuredMesh<5, size_t, double, 6,5,4> m;
	//m.ComputeElementMeasures();		//m.ComputeElementMeasures();

	}		}