From c13c18c17521bda51822fbbfc88861c59912b390 Mon Sep 17 00:00:00 2001 From: Zakhar Khomenkov Date: Sun, 8 Oct 2023 20:44:15 +0300 Subject: [PATCH 1/2] 52 --- meshLoader/AneuMeshLoader.cpp | 64 +++++++++++ meshLoader/AneuMeshLoader.h | 15 +++ meshLoader/Components.cpp | 70 ++++++++++++ meshLoader/Components.h | 35 ++++++ meshLoader/Exceptions.h | 17 +++ meshLoader/Hash.h | 23 ++++ meshLoader/MeshLoader.cpp | 207 ++++++++++++++++++++++++++++++++++ meshLoader/MeshLoader.h | 38 +++++++ meshLoader/main.cpp | 96 ++++++++++++++++ 9 files changed, 565 insertions(+) create mode 100644 meshLoader/AneuMeshLoader.cpp create mode 100644 meshLoader/AneuMeshLoader.h create mode 100644 meshLoader/Components.cpp create mode 100644 meshLoader/Components.h create mode 100644 meshLoader/Exceptions.h create mode 100644 meshLoader/Hash.h create mode 100644 meshLoader/MeshLoader.cpp create mode 100644 meshLoader/MeshLoader.h create mode 100644 meshLoader/main.cpp diff --git a/meshLoader/AneuMeshLoader.cpp b/meshLoader/AneuMeshLoader.cpp new file mode 100644 index 0000000..6387668 --- /dev/null +++ b/meshLoader/AneuMeshLoader.cpp @@ -0,0 +1,64 @@ +#include "AneuMeshLoader.h" +#include +#include + +void AneuMeshLoader::loadMesh(const std::string& fileName) { + std::ifstream file(fileName); + if (!file) { + throw FileNotFound(); + } + else std::cout << "File " << fileName << " was opened successfully." << std::endl; + + + //çàãðóçêà óçëîâ + int count, dimension; + file >> count >> dimension; + Nodes.reserve(count); + for (int i = 0; i < count; ++i) { + Node temp; + file >> temp.m_coordinates[0] >> temp.m_coordinates[1] >> temp.m_coordinates[2]; + temp.m_ID = i + 1; + temp.m_vertexDot = false; + Nodes.push_back(std::move(temp)); + } + + + //çàãðóçêà ÊÝ + file >> count >> dimension; + FiniteElements.reserve(count); + for (int i = 0; i < count; ++i) { + FiniteElement temp; + int IDNode; + file >> temp.m_GeometryAreaID; + for (int j = 0; j < dimension; ++j) { + file >> IDNode; + temp.m_NodeIDs.push_back(IDNode); + } + temp.m_FiniteElementID = i + 1; + FiniteElements.push_back(std::move(temp)); + } + + + //çàãðóçêà ãðàíè÷íûõ ÊÝ + file >> count >> dimension; + BoundaryElements.reserve(count); + for (int i = 0; i < count; ++i) { + FiniteElement temp; + int IDNode; + file >> temp.m_GeometryAreaID; + for (int j = 0; j < dimension; ++j) { + file >> IDNode; + temp.m_NodeIDs.push_back(IDNode); + } + temp.m_FiniteElementID = i + 1; + BoundaryElements.push_back(std::move(temp)); + } +} + + + + + + + + diff --git a/meshLoader/AneuMeshLoader.h b/meshLoader/AneuMeshLoader.h new file mode 100644 index 0000000..bac571a --- /dev/null +++ b/meshLoader/AneuMeshLoader.h @@ -0,0 +1,15 @@ +#pragma once +#include "MeshLoader.h" +#include "Components.h" +#include "Exceptions.h" +#include +#include + +class AneuMeshLoader : public MeshLoader { +private: +public: + void loadMesh(const std::string&) override; +}; + + + diff --git a/meshLoader/Components.cpp b/meshLoader/Components.cpp new file mode 100644 index 0000000..2d9c190 --- /dev/null +++ b/meshLoader/Components.cpp @@ -0,0 +1,70 @@ +#include "Components.h" + +#include + + +Node::Node(int p_ID, const std::array& p_coordinates, bool p_VertexDot) : + m_ID(p_ID), m_coordinates(p_coordinates), m_vertexDot(p_VertexDot) {} + + +//ôîðìàòèðîâàííûé âûâîä óçëà +std::ostream& operator<<(std::ostream& out, const Node& p_node) { + out << "Node ID: " << p_node.m_ID << "\t"; + out << "Node coordinate: (" << p_node.m_coordinates[0] << ";" << p_node.m_coordinates[1] << ";" << p_node.m_coordinates[2] << ")\t"; + if (p_node.m_vertexDot) + out << "Node is a vertex\n"; + else + out << "Node is internal\n"; + out << std::endl; + return out; +} + + +std::ostream& operator<<(std::ostream& out, const std::vector& p_node) { + for (const auto& node : p_node) + out << node; + return out; +}; + + +//ôîðìàòèðîâàííûé âûâîä ÊÝ +std::ostream& operator<<(std::ostream& out, const FiniteElement& p_finiteElement) { + out << "Finite Element ID: " << p_finiteElement.m_FiniteElementID << "\t"; + out << "Geometry Area ID: " << p_finiteElement.m_GeometryAreaID << "\t"; + out << "Nodes of Finite Element: "; + for (auto& node : p_finiteElement.m_NodeIDs) { + out << node << " "; + } + out << "\n" << std::endl; + return out; +} + + +std::ostream& operator<<(std::ostream& out, const std::vector& p_finiteElement) { + for (const auto& node : p_finiteElement) + out << node; + return out; +} + + +Edge::Edge(int firstNodeId, int secNodeId) + : m_edgeNodes({ firstNodeId, secNodeId }) {} + + +Edge& Edge::operator=(const Edge& p_edge) { + if (this != &p_edge) { + this->m_edgeNodes = p_edge.m_edgeNodes; + this->m_midNode = p_edge.m_midNode; + } + return *this; +} + + +bool Edge::operator==(const Edge& p_edge) const { + return ((m_edgeNodes.first == p_edge.m_edgeNodes.first) && + (m_edgeNodes.second == p_edge.m_edgeNodes.second)) || ((m_edgeNodes.first == p_edge.m_edgeNodes.second) && + (m_edgeNodes.second == p_edge.m_edgeNodes.first)); +} + + + diff --git a/meshLoader/Components.h b/meshLoader/Components.h new file mode 100644 index 0000000..45981f9 --- /dev/null +++ b/meshLoader/Components.h @@ -0,0 +1,35 @@ +#pragma once +#include +#include +#include +struct Node { + int m_ID; + static constexpr int dim = 3; + std::array m_coordinates{}; + bool m_vertexDot; + + Node() = default; + Node(int, const std::array&, bool); + + friend std::ostream& operator<<(std::ostream&, const Node&); + friend std::ostream& operator<<(std::ostream&, const std::vector&); +}; + +struct FiniteElement { + int m_FiniteElementID; + int m_GeometryAreaID; + std::vector m_NodeIDs; + + friend std::ostream& operator<<(std::ostream&, const FiniteElement&); + friend std::ostream& operator<<(std::ostream&, const std::vector&); + +}; + +struct Edge { + std::pair m_edgeNodes; + int m_midNode = -1; + Edge() = default; + Edge(int, int); + Edge& operator=(const Edge&); + bool operator==(const Edge&) const; +}; diff --git a/meshLoader/Exceptions.h b/meshLoader/Exceptions.h new file mode 100644 index 0000000..5518f24 --- /dev/null +++ b/meshLoader/Exceptions.h @@ -0,0 +1,17 @@ +#pragma once +#include +#include + +class FileNotFound : public std::exception +{ + std::string err; +public: + FileNotFound() { + err.assign("File wasn't found!"); + } + + const char* what() const noexcept override { + return err.c_str(); + } +}; + diff --git a/meshLoader/Hash.h b/meshLoader/Hash.h new file mode 100644 index 0000000..1d1d02f --- /dev/null +++ b/meshLoader/Hash.h @@ -0,0 +1,23 @@ +#pragma once + +#include "Components.h" + +inline void hashCombine(std::size_t& seed, unsigned int& val) { + seed ^= std::hash()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2); +}; + +inline std::size_t hashVal(const Edge& edge) { + std::size_t seed = 0; + unsigned int a = std::min(edge.m_edgeNodes.first, edge.m_edgeNodes.second); + unsigned int b = std::max(edge.m_edgeNodes.first, edge.m_edgeNodes.second); + hashCombine(seed, a); + hashCombine(seed, b); + return seed; +}; + +class Hash { +public: + std::size_t operator()(const Edge& edge) const { + return hashVal(edge); + } +}; \ No newline at end of file diff --git a/meshLoader/MeshLoader.cpp b/meshLoader/MeshLoader.cpp new file mode 100644 index 0000000..dae73b3 --- /dev/null +++ b/meshLoader/MeshLoader.cpp @@ -0,0 +1,207 @@ +#include +#include +#include +#include +#include "MeshLoader.h" +#include "Hash.h" +#include +#include + + +const std::vector& MeshLoader::getNodes() { + return Nodes; +} + + +const std::vector& MeshLoader::getFiniteElements() { + return FiniteElements; +} + + +const std::vector& MeshLoader::getBoundaryElements() { + return BoundaryElements; +} + + +void MeshLoader::printNodes(const std::vector& p_nodes) { + std::cout << p_nodes; +} + + +void MeshLoader::printFiniteElements(const std::vector& p_elem) { + std::cout << p_elem; +} + + +//ïîëó÷àåò ÊÝ ïî òð¸ì óçëàì +std::vector MeshLoader::getFiniteElementByID(int p_id1, int p_id2, int p_id3) { + std::vector res; + + auto findFiniteElement = [&p_id1, &p_id2, &p_id3, &res](const FiniteElement& elem) { + + if ((std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), + [p_id1](const int id) {return id == p_id1; })) && + (std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), + [p_id2](const int id) {return id == p_id2; })) && + (std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), + [p_id3](const int id) {return id == p_id3; }))) { + res.push_back(elem.m_FiniteElementID); + } + }; + + std::for_each(FiniteElements.begin(), FiniteElements.end(), findFiniteElement); + return res; +} + + +//ïîëó÷àåò ÊÝ ïî äâóì óçëàì(ðåáðó) +std::vector MeshLoader::getFiniteElementByEdge(int p_id1, int p_id2) { + std::vector res; + auto findFiniteElement = [&p_id1, &p_id2, &res](const FiniteElement& elem) { + + if ((std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), + [p_id1](const int id) {return id == p_id1; })) && + (std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), + [p_id2](const int id) {return id == p_id2; }))) { + res.push_back(elem.m_FiniteElementID); + } + }; + + std::for_each(FiniteElements.begin(), FiniteElements.end(), findFiniteElement); + return res; +} + + +//âîçâðàùàåò êîíòåéíåð ID óçëîâ ïî ID ãðàíèöû +std::vector MeshLoader::getNodesIDByBorder(int p_id) { + std::set res; + auto cur = BoundaryElements.begin(); + + while (cur != BoundaryElements.end()) { + cur = std::find_if(cur, BoundaryElements.end(), [p_id](const FiniteElement& elem) { + return elem.m_GeometryAreaID == p_id; + } + ); + if (cur != BoundaryElements.end()) { + for (const auto& nod : cur->m_NodeIDs) { + Node nodeId = Nodes[nod - 1]; + res.insert(nodeId.m_ID); + } + ++cur; + } + } + return std::vector(res.begin(), res.end()); +} + + +//ïîëó÷àåò êîíòåéíåð ID ÊÝ ïî ID ïîâåðõíîñòè +std::vector MeshLoader::getFiniteElementIdBySurface(int p_id) { + std::vector res; + auto findFiniteElement = [&p_id, &res](const FiniteElement& elem) { + if (elem.m_GeometryAreaID == p_id) { + res.push_back(elem.m_FiniteElementID); + } + }; + + std::for_each(FiniteElements.begin(), FiniteElements.end(), findFiniteElement); + return res; +} + + +//ïîëó÷àåò êîíòåéíåð ID ãðàíè÷íîãî ÊÝ ïî ID ãðàíèöû +std::vector MeshLoader::getBoundElementIDByBorder(int _id) { + std::vector res; + auto po = [&_id, &res](const FiniteElement& elem) { + if (elem.m_GeometryAreaID == _id) { + res.push_back(elem.m_FiniteElementID); + } + }; + + std::for_each(BoundaryElements.begin(), BoundaryElements.end(), po); + return res; +} + + +//âîçâðàùàåò âåêòîð ñîñåäíèõ óçëîâ +std::vector> MeshLoader::createNeighborsVector() { + std::vector> neighbors(Nodes.size()+1); + for (const auto& elem : BoundaryElements) { + for (auto nodeId : elem.m_NodeIDs) { + for (auto anthNodeId : elem.m_NodeIDs) + if (nodeId != anthNodeId) { + neighbors[nodeId].insert(anthNodeId); + } + } + } + + auto it = neighbors.begin(); + std::advance(it, 1); + int i = 1; + for (; it != neighbors.end(); ++it) { + std::cout << " neighbours of node " << i++ << ": "; + for (const auto& element : *it) { + std::cout << element << " "; + } + std::cout << std::endl; + } + std::cout << std::endl; + + return neighbors; +} + + +// âñòàâêà óçëîâ â ñåðåäèíû ð¸áåð +std::array MeshLoader::getMiddleCoords(const Edge& edge) { + double MiddleX = ((Nodes.at(edge.m_edgeNodes.first - 1).m_coordinates.at(0)) + + (Nodes.at(edge.m_edgeNodes.second - 1).m_coordinates.at(0))) / 2; + double MiddleY = ((Nodes.at(edge.m_edgeNodes.first - 1).m_coordinates.at(1)) + + (Nodes.at(edge.m_edgeNodes.second - 1).m_coordinates.at(1))) / 2; + double MiddleZ = ((Nodes.at(edge.m_edgeNodes.first - 1).m_coordinates.at(2)) + + (Nodes.at(edge.m_edgeNodes.second - 1).m_coordinates.at(2))) / 2; + return { MiddleX, MiddleY, MiddleZ }; +} + + +Node MeshLoader::getMiddleNode(const Edge& edge) { + Node newNode(Nodes.size() + 1, getMiddleCoords(edge), false); + return newNode; +} + + +void MeshLoader::insertNodeMid() { + std::unordered_set edge; + for (auto& elem : FiniteElements) { + std::vector ElemNodeID = elem.m_NodeIDs; + size_t size = elem.m_NodeIDs.size(); + for (int first = 0; first < size; ++first) { + for (auto sec = first + 1; sec < size; ++sec) { + Edge curEdge(ElemNodeID[first], ElemNodeID[sec]); + Node newNode = getMiddleNode(curEdge); + curEdge.m_midNode = newNode.m_ID; + if (edge.insert(curEdge).second) { + Nodes.push_back(newNode); + elem.m_NodeIDs.push_back(newNode.m_ID); + } + else { + elem.m_NodeIDs.push_back(curEdge.m_midNode); + } + } + } + std::cout << elem << std::endl; + } + + + for (auto& belem : BoundaryElements) { + std::vector bfeNodesId = belem.m_NodeIDs; + size_t size = belem.m_NodeIDs.size(); + for (auto first = 0; first < size; ++first) { + for (auto sec = first + 1; sec < size; ++sec) { + auto curEdgeIter = edge.find({ bfeNodesId[first], bfeNodesId[sec] }); + if (curEdgeIter == edge.end()) { + curEdgeIter = edge.find({ bfeNodesId[sec], bfeNodesId[first] }); + } + belem.m_NodeIDs.push_back(curEdgeIter->m_midNode); + } + } + } +} \ No newline at end of file diff --git a/meshLoader/MeshLoader.h b/meshLoader/MeshLoader.h new file mode 100644 index 0000000..4e2d05b --- /dev/null +++ b/meshLoader/MeshLoader.h @@ -0,0 +1,38 @@ +#pragma once +#include +#include +#include +#include +#include +#include "Components.h" +class MeshLoader { +private: + Node getMiddleNode(const Edge&); + std::array getMiddleCoords(const Edge&); +protected: + std::vector Nodes; + std::vector FiniteElements; + std::vector BoundaryElements; +public: + virtual void loadMesh(const std::string&) = 0; + virtual ~MeshLoader() = default; + + const std::vector& getNodes(); + const std::vector& getFiniteElements(); + const std::vector& getBoundaryElements(); + + std::vector getFiniteElementByID(int, int, int); + std::vector getFiniteElementByEdge(int, int); + std::vector getNodesIDByBorder(int); + + std::vector getFiniteElementIdBySurface(int); + std::vector getBoundElementIDByBorder(int); + + static void printNodes(const std::vector&); + static void printFiniteElements(const std::vector&); + + void insertNodeMid(); + + std::vector> createNeighborsVector(); +}; + diff --git a/meshLoader/main.cpp b/meshLoader/main.cpp new file mode 100644 index 0000000..763feb6 --- /dev/null +++ b/meshLoader/main.cpp @@ -0,0 +1,96 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include "MeshLoader.h" +#include "AneuMeshLoader.h" +using namespace std; + +int main(int argc, char* argv[]) { + std::string filepath = "./cube.aneu"; + if (argc !=2) + std::cout << "Wrong number of arguments, using standard file PATH\n" << std::endl; + else { + std::cout << "Set file path to " << argv[1] << "\n" << std::endl; + filepath = argv[1]; + }; + + + MeshLoader* l = new AneuMeshLoader(); + try { + l->loadMesh(filepath); + } + catch (std::exception& er) { + std::cerr << er.what() << std::endl; + delete l; + return 0; + } + + + std::cout << "Nodes from file: \n" << std::endl; + l->printNodes(l->getNodes()); + + + std::cout << "Finite Elements from file: \n" << std::endl; + l->printFiniteElements(l->getFiniteElements()); + + + std::cout << "Bouundary Finite Elements from file: \n" << std::endl; + l->printFiniteElements(l->getBoundaryElements()); + + + std::cout << "Neighbours of Nodes: \n" << std::endl; + l->createNeighborsVector(); + + + std::cout << "ID Finite elements by nodes (4,1,2)" << std::endl; + auto finelem_1 = l->getFiniteElementByID(4,1,2); + for (int elem : finelem_1) { + std::cout << elem << " "; + } + std::cout << std::endl << "-----------------------------------" << std::endl; + + + std::cout << "ID Finite elements by Edge (4,6)" << std::endl; + auto finelem_2 = l->getFiniteElementByEdge(4, 6); + for (int elem : finelem_2) { + std::cout << elem << " "; + } + std::cout << std::endl << "-----------------------------------" << std::endl; + + + std::cout << "Boundary element ID by boundary ID (2)" << std::endl; + auto finelem_3 = l->getBoundElementIDByBorder(2); + for (int elem : finelem_3) { + std::cout << elem << " "; + } + std::cout << std::endl << "-----------------------------------" << std::endl; + + + std::cout << "ID of Nodes by ID of Bounder element (3)" << std::endl; + auto finnode = l->getNodesIDByBorder(3); + for (int node : finnode) { + std::cout << node << " "; + } + std::cout << std::endl << "-----------------------------------" << std::endl; + + + std::cout << "inserting middle Elements: \n" << std::endl; + l->insertNodeMid(); + + + std::cout << "Nodes after inserting middle Element: \n" << std::endl; + l->printNodes(l->getNodes()); + + + std::cout << "Neighbours of new Nodes: \n" << std::endl; + l->createNeighborsVector(); + + + delete l; + return 0; +} \ No newline at end of file -- GitLab From 28db0287623caa73197a28589e2876c45a08f28a Mon Sep 17 00:00:00 2001 From: Zakhar Khomenkov Date: Tue, 7 Nov 2023 06:21:44 +0300 Subject: [PATCH 2/2] fix --- meshLoader/AneuMeshLoader.cpp | 60 ++++--- meshLoader/AneuMeshLoader.h | 5 +- meshLoader/Components.cpp | 62 +++++--- meshLoader/Components.h | 42 ++++- meshLoader/Hash.h | 8 +- meshLoader/MeshLoader.cpp | 285 ++++++++++++++++++++-------------- meshLoader/MeshLoader.h | 39 +++-- meshLoader/main.cpp | 36 +++-- 8 files changed, 323 insertions(+), 214 deletions(-) diff --git a/meshLoader/AneuMeshLoader.cpp b/meshLoader/AneuMeshLoader.cpp index 6387668..7a08b94 100644 --- a/meshLoader/AneuMeshLoader.cpp +++ b/meshLoader/AneuMeshLoader.cpp @@ -2,63 +2,55 @@ #include #include -void AneuMeshLoader::loadMesh(const std::string& fileName) { - std::ifstream file(fileName); +void AneuMeshLoader::loadMesh(const std::string& p_fileName) { + std::ifstream file(p_fileName); if (!file) { throw FileNotFound(); } - else std::cout << "File " << fileName << " was opened successfully." << std::endl; + else std::cout << "File " << p_fileName << " was opened successfully." << std::endl; //çàãðóçêà óçëîâ - int count, dimension; - file >> count >> dimension; + int count; + file >> count; + file.ignore(std::numeric_limits::max(), '\n'); Nodes.reserve(count); for (int i = 0; i < count; ++i) { Node temp; file >> temp.m_coordinates[0] >> temp.m_coordinates[1] >> temp.m_coordinates[2]; - temp.m_ID = i + 1; temp.m_vertexDot = false; - Nodes.push_back(std::move(temp)); + Nodes.insert({ m_nodeId.generateId(), std::move(temp) }); } //çàãðóçêà ÊÝ - file >> count >> dimension; + file >> count; + file.ignore(std::numeric_limits::max(), '\n'); FiniteElements.reserve(count); for (int i = 0; i < count; ++i) { - FiniteElement temp; - int IDNode; - file >> temp.m_GeometryAreaID; - for (int j = 0; j < dimension; ++j) { - file >> IDNode; - temp.m_NodeIDs.push_back(IDNode); + int geometryAreaID; + file >> geometryAreaID; + std::vector idLst(Tetrahedron::m_size); + for (int j = 0; j < Tetrahedron::m_size; ++j) { + file >> idLst[j]; } - temp.m_FiniteElementID = i + 1; - FiniteElements.push_back(std::move(temp)); + Tetrahedron temp(geometryAreaID, idLst); + FiniteElements.insert({ m_finiteElementId.generateId(), std::move(temp) }); } //çàãðóçêà ãðàíè÷íûõ ÊÝ - file >> count >> dimension; + file >> count; + file.ignore(std::numeric_limits::max(), '\n'); BoundaryElements.reserve(count); for (int i = 0; i < count; ++i) { - FiniteElement temp; - int IDNode; - file >> temp.m_GeometryAreaID; - for (int j = 0; j < dimension; ++j) { - file >> IDNode; - temp.m_NodeIDs.push_back(IDNode); + int geometryAreaID; + file >> geometryAreaID; + std::vector idLst(Triangle::m_size); + for (int j = 0; j < Triangle::m_size; ++j) { + file >> idLst[j]; } - temp.m_FiniteElementID = i + 1; - BoundaryElements.push_back(std::move(temp)); + Triangle temp(geometryAreaID, idLst); + BoundaryElements.insert({ m_boundaryElementId.generateId(), std::move(temp) }); } -} - - - - - - - - +} \ No newline at end of file diff --git a/meshLoader/AneuMeshLoader.h b/meshLoader/AneuMeshLoader.h index bac571a..ce08b46 100644 --- a/meshLoader/AneuMeshLoader.h +++ b/meshLoader/AneuMeshLoader.h @@ -9,7 +9,4 @@ class AneuMeshLoader : public MeshLoader { private: public: void loadMesh(const std::string&) override; -}; - - - +}; \ No newline at end of file diff --git a/meshLoader/Components.cpp b/meshLoader/Components.cpp index 2d9c190..b07406f 100644 --- a/meshLoader/Components.cpp +++ b/meshLoader/Components.cpp @@ -1,15 +1,14 @@ #include "Components.h" - #include -Node::Node(int p_ID, const std::array& p_coordinates, bool p_VertexDot) : - m_ID(p_ID), m_coordinates(p_coordinates), m_vertexDot(p_VertexDot) {} +Node::Node(const std::array& p_coordinates, bool p_VertexDot) : + m_coordinates(p_coordinates), m_vertexDot(p_VertexDot) {} + //ôîðìàòèðîâàííûé âûâîä óçëà std::ostream& operator<<(std::ostream& out, const Node& p_node) { - out << "Node ID: " << p_node.m_ID << "\t"; out << "Node coordinate: (" << p_node.m_coordinates[0] << ";" << p_node.m_coordinates[1] << ";" << p_node.m_coordinates[2] << ")\t"; if (p_node.m_vertexDot) out << "Node is a vertex\n"; @@ -20,19 +19,24 @@ std::ostream& operator<<(std::ostream& out, const Node& p_node) { } -std::ostream& operator<<(std::ostream& out, const std::vector& p_node) { - for (const auto& node : p_node) - out << node; +std::ostream& operator<<(std::ostream& out, const std::unordered_map& p_node) { + int i = 1; + for (const auto& node : p_node) { + out << "Node ID: " << node.first << " " << node.second; + } return out; }; +FiniteElement::FiniteElement(int p_GeometryAreaID, const std::vector& p_NodeIDs) : + m_GeometryAreaID(p_GeometryAreaID), m_NodeIDs(p_NodeIDs) {} + + //ôîðìàòèðîâàííûé âûâîä ÊÝ -std::ostream& operator<<(std::ostream& out, const FiniteElement& p_finiteElement) { - out << "Finite Element ID: " << p_finiteElement.m_FiniteElementID << "\t"; - out << "Geometry Area ID: " << p_finiteElement.m_GeometryAreaID << "\t"; +std::ostream& operator<<(std::ostream& out, const Tetrahedron& p_Tetrahedron) { + out << "Geometry Area ID: " << p_Tetrahedron.m_GeometryAreaID << "\t"; out << "Nodes of Finite Element: "; - for (auto& node : p_finiteElement.m_NodeIDs) { + for (auto& node : p_Tetrahedron.m_NodeIDs) { out << node << " "; } out << "\n" << std::endl; @@ -40,15 +44,34 @@ std::ostream& operator<<(std::ostream& out, const FiniteElement& p_finiteElement } -std::ostream& operator<<(std::ostream& out, const std::vector& p_finiteElement) { - for (const auto& node : p_finiteElement) - out << node; +std::ostream& operator<<(std::ostream& out, const std::unordered_map& p_Tetrahedrons) { + for (const auto& elem : p_Tetrahedrons) + out << "Finite Element ID: " << elem.first << " " << elem.second; return out; } -Edge::Edge(int firstNodeId, int secNodeId) - : m_edgeNodes({ firstNodeId, secNodeId }) {} +std::ostream& operator<<(std::ostream& out, const Triangle& p_Triangle) { + out << "Geometry Area ID: " << p_Triangle.m_GeometryAreaID << "\t"; + out << "Nodes of Boundary Element: "; + for (auto& node : p_Triangle.m_NodeIDs) { + out << node << " "; + } + out << "\n" << std::endl; + return out; +} + + +std::ostream& operator<<(std::ostream& out, const std::unordered_map& p_Triangle) { + for (const auto& elem : p_Triangle) + out << "Boundary Element ID: " << elem.first << " " << elem.second; + return out; +} + + + +Edge::Edge(int p_firstNodeId, int p_secNodeId) + : m_edgeNodes({ p_firstNodeId, p_secNodeId }) {} Edge& Edge::operator=(const Edge& p_edge) { @@ -63,8 +86,5 @@ Edge& Edge::operator=(const Edge& p_edge) { bool Edge::operator==(const Edge& p_edge) const { return ((m_edgeNodes.first == p_edge.m_edgeNodes.first) && (m_edgeNodes.second == p_edge.m_edgeNodes.second)) || ((m_edgeNodes.first == p_edge.m_edgeNodes.second) && - (m_edgeNodes.second == p_edge.m_edgeNodes.first)); -} - - - + (m_edgeNodes.second == p_edge.m_edgeNodes.first)); +} \ No newline at end of file diff --git a/meshLoader/Components.h b/meshLoader/Components.h index 45981f9..430d3ea 100644 --- a/meshLoader/Components.h +++ b/meshLoader/Components.h @@ -2,29 +2,57 @@ #include #include #include +#include + +class IdGenerator { +public: + IdGenerator() : currentId(1) {} + int generateId() { + return currentId++; + } +private: + int currentId; +}; + + struct Node { - int m_ID; static constexpr int dim = 3; std::array m_coordinates{}; - bool m_vertexDot; + bool m_vertexDot; Node() = default; - Node(int, const std::array&, bool); + Node(const std::array&, bool); friend std::ostream& operator<<(std::ostream&, const Node&); - friend std::ostream& operator<<(std::ostream&, const std::vector&); + friend std::ostream& operator<<(std::ostream&, const std::unordered_map&); }; + struct FiniteElement { - int m_FiniteElementID; int m_GeometryAreaID; std::vector m_NodeIDs; + FiniteElement(int p_GeometryAreaID, const std::vector& p_NodeIDs); +}; - friend std::ostream& operator<<(std::ostream&, const FiniteElement&); - friend std::ostream& operator<<(std::ostream&, const std::vector&); +class Tetrahedron : public FiniteElement { +public: + static constexpr int m_size = 4; + Tetrahedron(int p_geomId, const std::vector& p_nodes) : FiniteElement(p_geomId, p_nodes) {}; + friend std::ostream& operator<<(std::ostream&, const Tetrahedron&); + friend std::ostream& operator<<(std::ostream&, const std::unordered_map&); }; + +class Triangle : public FiniteElement { +public: + static constexpr int m_size = 3; + Triangle(int p_geomId, const std::vector& p_nodes) : FiniteElement(p_geomId, p_nodes) {}; + friend std::ostream& operator<<(std::ostream&, const Triangle&); + friend std::ostream& operator<<(std::ostream&, const std::unordered_map&); +}; + + struct Edge { std::pair m_edgeNodes; int m_midNode = -1; diff --git a/meshLoader/Hash.h b/meshLoader/Hash.h index 1d1d02f..8dbd1e8 100644 --- a/meshLoader/Hash.h +++ b/meshLoader/Hash.h @@ -2,12 +2,12 @@ #include "Components.h" -inline void hashCombine(std::size_t& seed, unsigned int& val) { +inline void hashCombine(int& seed, unsigned int& val) { seed ^= std::hash()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2); }; -inline std::size_t hashVal(const Edge& edge) { - std::size_t seed = 0; +inline int hashVal(const Edge& edge) { + int seed = 0; unsigned int a = std::min(edge.m_edgeNodes.first, edge.m_edgeNodes.second); unsigned int b = std::max(edge.m_edgeNodes.first, edge.m_edgeNodes.second); hashCombine(seed, a); @@ -17,7 +17,7 @@ inline std::size_t hashVal(const Edge& edge) { class Hash { public: - std::size_t operator()(const Edge& edge) const { + int operator()(const Edge& edge) const { return hashVal(edge); } }; \ No newline at end of file diff --git a/meshLoader/MeshLoader.cpp b/meshLoader/MeshLoader.cpp index dae73b3..807fef2 100644 --- a/meshLoader/MeshLoader.cpp +++ b/meshLoader/MeshLoader.cpp @@ -8,139 +8,198 @@ #include -const std::vector& MeshLoader::getNodes() { +const std::unordered_map& MeshLoader::getNodes() { return Nodes; } -const std::vector& MeshLoader::getFiniteElements() { +const std::unordered_map& MeshLoader::getFiniteElements() { return FiniteElements; } -const std::vector& MeshLoader::getBoundaryElements() { +const std::unordered_map& MeshLoader::getBoundaryElements() { return BoundaryElements; } -void MeshLoader::printNodes(const std::vector& p_nodes) { +void MeshLoader::printNodes(const std::unordered_map& p_nodes) { std::cout << p_nodes; } -void MeshLoader::printFiniteElements(const std::vector& p_elem) { +void MeshLoader::printFiniteElements(const std::unordered_map& p_elem) { std::cout << p_elem; } -//ïîëó÷àåò ÊÝ ïî òð¸ì óçëàì -std::vector MeshLoader::getFiniteElementByID(int p_id1, int p_id2, int p_id3) { - std::vector res; - - auto findFiniteElement = [&p_id1, &p_id2, &p_id3, &res](const FiniteElement& elem) { - - if ((std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), - [p_id1](const int id) {return id == p_id1; })) && - (std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), - [p_id2](const int id) {return id == p_id2; })) && - (std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), - [p_id3](const int id) {return id == p_id3; }))) { - res.push_back(elem.m_FiniteElementID); +void MeshLoader::printBoundaryElements(const std::unordered_map& p_elem) { + std::cout << p_elem; +} + + +//ïîëó÷àåò ID ÊÝ ïî òð¸ì óçëàì +std::unordered_set MeshLoader::getFiniteElementIDByNodesID(int p_id1, int p_id2, int p_id3) { + std::unordered_set res; + + for (const auto& pair : FiniteElements) { + const Tetrahedron& elem = pair.second; + if (std::find(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), p_id1) != elem.m_NodeIDs.end() && + std::find(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), p_id2) != elem.m_NodeIDs.end() && + std::find(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), p_id3) != elem.m_NodeIDs.end()) { + res.insert(pair.first); } - }; + } + return res; +} + - std::for_each(FiniteElements.begin(), FiniteElements.end(), findFiniteElement); +//ïîëó÷àåò ID ÊÝ ïî äâóì óçëàì(ðåáðó) +std::unordered_set MeshLoader::getFiniteElementIDByEdge(int p_id1, int p_id2) { + std::unordered_set res; + for (const auto& elementPair : FiniteElements) { + const Tetrahedron& element = elementPair.second; + if (std::find(element.m_NodeIDs.begin(), element.m_NodeIDs.end(), p_id1) != element.m_NodeIDs.end() && + std::find(element.m_NodeIDs.begin(), element.m_NodeIDs.end(), p_id2) != element.m_NodeIDs.end()) { + res.insert(elementPair.first); + } + } return res; } -//ïîëó÷àåò ÊÝ ïî äâóì óçëàì(ðåáðó) -std::vector MeshLoader::getFiniteElementByEdge(int p_id1, int p_id2) { - std::vector res; - auto findFiniteElement = [&p_id1, &p_id2, &res](const FiniteElement& elem) { - - if ((std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), - [p_id1](const int id) {return id == p_id1; })) && - (std::any_of(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), - [p_id2](const int id) {return id == p_id2; }))) { - res.push_back(elem.m_FiniteElementID); +//ïîëó÷àåò êîíòåéíåð ID óçëîâ ïî ID ãðàíèöû +std::unordered_set MeshLoader::getNodesIDByBorder(int p_id) { + std::unordered_set res; + for (const auto& elementPair : BoundaryElements) { + const Triangle& elem = elementPair.second; + if (elem.m_GeometryAreaID == p_id) { + for (const auto& nodeId : elem.m_NodeIDs) { + res.insert(nodeId); + } } - }; + } + return res; +} + - std::for_each(FiniteElements.begin(), FiniteElements.end(), findFiniteElement); +//ïîëó÷àåò êîíòåéíåð ID ÊÝ ïî ID ïîâåðõíîñòè +std::unordered_set MeshLoader::getFiniteElementIdBySurface(int p_id) { + std::unordered_set res; + for (const auto& elementPair : FiniteElements) { + const int elementId = elementPair.first; + const Tetrahedron& element = elementPair.second; + if (element.m_GeometryAreaID == p_id) { + res.insert(elementId); + } + } return res; } -//âîçâðàùàåò êîíòåéíåð ID óçëîâ ïî ID ãðàíèöû -std::vector MeshLoader::getNodesIDByBorder(int p_id) { - std::set res; - auto cur = BoundaryElements.begin(); +//ïîëó÷àåò êîíòåéíåð ID ãðàíè÷íîãî ÊÝ ïî ID ãðàíèöû +std::unordered_set MeshLoader::getBoundElementIDByBorder(int _id) { + std::unordered_set res; + for (const auto& pair : BoundaryElements) { + const int elementId = pair.first; + const Triangle& elem = pair.second; + if (elem.m_GeometryAreaID == _id) { + res.insert(elementId); + } + } + return res; +} - while (cur != BoundaryElements.end()) { - cur = std::find_if(cur, BoundaryElements.end(), [p_id](const FiniteElement& elem) { - return elem.m_GeometryAreaID == p_id; - } - ); - if (cur != BoundaryElements.end()) { - for (const auto& nod : cur->m_NodeIDs) { - Node nodeId = Nodes[nod - 1]; - res.insert(nodeId.m_ID); - } - ++cur; + +//ïîëó÷àåò ÊÝ ïî òð¸ì óçëàì +std::vector MeshLoader::getFiniteElementByNodesID(int p_id1, int p_id2, int p_id3) { + std::vector res; + + for (const auto& pair : FiniteElements) { + const Tetrahedron& elem = pair.second; + if (std::find(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), p_id1) != elem.m_NodeIDs.end() && + std::find(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), p_id2) != elem.m_NodeIDs.end() && + std::find(elem.m_NodeIDs.begin(), elem.m_NodeIDs.end(), p_id3) != elem.m_NodeIDs.end()) { + res.push_back(pair.second); } } - return std::vector(res.begin(), res.end()); + return res; } -//ïîëó÷àåò êîíòåéíåð ID ÊÝ ïî ID ïîâåðõíîñòè -std::vector MeshLoader::getFiniteElementIdBySurface(int p_id) { - std::vector res; - auto findFiniteElement = [&p_id, &res](const FiniteElement& elem) { +//ïîëó÷àåò ÊÝ ïî äâóì óçëàì(ðåáðó) +std::vector MeshLoader::getFiniteElementByEdge(int p_id1, int p_id2) { + std::vector res; + for (const auto& elementPair : FiniteElements) { + const Tetrahedron& element = elementPair.second; + if (std::find(element.m_NodeIDs.begin(), element.m_NodeIDs.end(), p_id1) != element.m_NodeIDs.end() && + std::find(element.m_NodeIDs.begin(), element.m_NodeIDs.end(), p_id2) != element.m_NodeIDs.end()) { + res.push_back(elementPair.second); + } + } + return res; +} + + +//ïîëó÷àåò êîíòåéíåð óçëîâ ïî ID ãðàíèöû +std::vector MeshLoader::getNodesByBorder(int p_id) { + std::vector res; + for (const auto& elementPair : BoundaryElements) { + const Triangle& elem = elementPair.second; if (elem.m_GeometryAreaID == p_id) { - res.push_back(elem.m_FiniteElementID); + for (const auto& nodeId : elem.m_NodeIDs) { + res.push_back(Nodes[nodeId]); + } } - }; + } + return res; +} - std::for_each(FiniteElements.begin(), FiniteElements.end(), findFiniteElement); + +//ïîëó÷àåò êîíòåéíåð ÊÝ ïî ID ïîâåðõíîñòè +std::vector MeshLoader::getFiniteElementBySurface(int p_id) { + std::vector res; + for (const auto& elementPair : FiniteElements) { + const Tetrahedron& elem = elementPair.second; + if (elem.m_GeometryAreaID == p_id) { + res.push_back(elem); + } + } return res; } -//ïîëó÷àåò êîíòåéíåð ID ãðàíè÷íîãî ÊÝ ïî ID ãðàíèöû -std::vector MeshLoader::getBoundElementIDByBorder(int _id) { - std::vector res; - auto po = [&_id, &res](const FiniteElement& elem) { +//ïîëó÷àåò êîíòåéíåð ãðàíè÷íûõ ÊÝ ïî ID ãðàíèöû +std::vector MeshLoader::getBoundElementByBorder(int _id) { + std::vector res; + for (const auto& pair : BoundaryElements) { + const Triangle& elem = pair.second; if (elem.m_GeometryAreaID == _id) { - res.push_back(elem.m_FiniteElementID); + res.push_back(elem); } - }; - - std::for_each(BoundaryElements.begin(), BoundaryElements.end(), po); + } return res; } -//âîçâðàùàåò âåêòîð ñîñåäíèõ óçëîâ -std::vector> MeshLoader::createNeighborsVector() { - std::vector> neighbors(Nodes.size()+1); - for (const auto& elem : BoundaryElements) { +//âîçâðàùàåò âåêòîð ID ñîñåäíèõ óçëîâ +std::unordered_map> MeshLoader::createNeighborsMap() { + std::unordered_map> neighbors; + for (const auto& pair : BoundaryElements) { + const Triangle& elem = pair.second; for (auto nodeId : elem.m_NodeIDs) { - for (auto anthNodeId : elem.m_NodeIDs) + for (auto anthNodeId : elem.m_NodeIDs) { if (nodeId != anthNodeId) { neighbors[nodeId].insert(anthNodeId); } + } } } - auto it = neighbors.begin(); - std::advance(it, 1); - int i = 1; - for (; it != neighbors.end(); ++it) { - std::cout << " neighbours of node " << i++ << ": "; - for (const auto& element : *it) { - std::cout << element << " "; + for (const auto& pair : neighbors) { + std::cout << "Neighbours of node " << pair.first << ": "; + for (const auto& neighborId : pair.second) { + std::cout << neighborId << " "; } std::cout << std::endl; } @@ -151,57 +210,53 @@ std::vector> MeshLoader::createNeighborsVector() { // âñòàâêà óçëîâ â ñåðåäèíû ð¸áåð -std::array MeshLoader::getMiddleCoords(const Edge& edge) { - double MiddleX = ((Nodes.at(edge.m_edgeNodes.first - 1).m_coordinates.at(0)) + - (Nodes.at(edge.m_edgeNodes.second - 1).m_coordinates.at(0))) / 2; - double MiddleY = ((Nodes.at(edge.m_edgeNodes.first - 1).m_coordinates.at(1)) + - (Nodes.at(edge.m_edgeNodes.second - 1).m_coordinates.at(1))) / 2; - double MiddleZ = ((Nodes.at(edge.m_edgeNodes.first - 1).m_coordinates.at(2)) + - (Nodes.at(edge.m_edgeNodes.second - 1).m_coordinates.at(2))) / 2; - return { MiddleX, MiddleY, MiddleZ }; -} - - Node MeshLoader::getMiddleNode(const Edge& edge) { - Node newNode(Nodes.size() + 1, getMiddleCoords(edge), false); + double MiddleX = (Nodes[edge.m_edgeNodes.first].m_coordinates[0] + + Nodes[edge.m_edgeNodes.second].m_coordinates[0]) / 2.0; + double MiddleY = (Nodes[edge.m_edgeNodes.first].m_coordinates[1] + + Nodes[edge.m_edgeNodes.second].m_coordinates[1]) / 2.0; + double MiddleZ = (Nodes[edge.m_edgeNodes.first].m_coordinates[2] + + Nodes[edge.m_edgeNodes.second].m_coordinates[2]) / 2.0; + Node newNode({ MiddleX, MiddleY, MiddleZ }, (Nodes[edge.m_edgeNodes.first].m_vertexDot && Nodes[edge.m_edgeNodes.first].m_vertexDot)); return newNode; } void MeshLoader::insertNodeMid() { - std::unordered_set edge; - for (auto& elem : FiniteElements) { - std::vector ElemNodeID = elem.m_NodeIDs; - size_t size = elem.m_NodeIDs.size(); - for (int first = 0; first < size; ++first) { - for (auto sec = first + 1; sec < size; ++sec) { - Edge curEdge(ElemNodeID[first], ElemNodeID[sec]); - Node newNode = getMiddleNode(curEdge); - curEdge.m_midNode = newNode.m_ID; - if (edge.insert(curEdge).second) { - Nodes.push_back(newNode); - elem.m_NodeIDs.push_back(newNode.m_ID); - } - else { - elem.m_NodeIDs.push_back(curEdge.m_midNode); + std::unordered_set edges; + std::unordered_map edgeToMidNodeId; + + for (auto& elemPair : FiniteElements) { + Tetrahedron& elem = elemPair.second; + std::vector newMidNodeIDs; + for (int i = 0; i < elem.m_NodeIDs.size(); ++i) { + for (int j = i + 1; j < elem.m_NodeIDs.size(); ++j) { + Edge curEdge(elem.m_NodeIDs[i], elem.m_NodeIDs[j]); + if (edges.insert(curEdge).second) { + Node newNode = getMiddleNode(curEdge); + int newId = m_nodeId.generateId(); + Nodes[newId] = newNode; + edgeToMidNodeId[curEdge] = newId; + newMidNodeIDs.push_back(newId); } } } - std::cout << elem << std::endl; + elem.m_NodeIDs.insert(elem.m_NodeIDs.end(), newMidNodeIDs.begin(), newMidNodeIDs.end()); } - - - for (auto& belem : BoundaryElements) { - std::vector bfeNodesId = belem.m_NodeIDs; - size_t size = belem.m_NodeIDs.size(); - for (auto first = 0; first < size; ++first) { - for (auto sec = first + 1; sec < size; ++sec) { - auto curEdgeIter = edge.find({ bfeNodesId[first], bfeNodesId[sec] }); - if (curEdgeIter == edge.end()) { - curEdgeIter = edge.find({ bfeNodesId[sec], bfeNodesId[first] }); + for (auto& belemPair : BoundaryElements) { + Triangle& belem = belemPair.second; + for (int i = 0; i < belem.m_NodeIDs.size(); ++i) { + for (int j = i + 1; j < belem.m_NodeIDs.size(); ++j) { + Edge curEdge(belem.m_NodeIDs[i], belem.m_NodeIDs[j]); + auto it = edgeToMidNodeId.find(curEdge); + if (it == edgeToMidNodeId.end()) { + curEdge = { curEdge.m_edgeNodes.second, curEdge.m_edgeNodes.first }; + it = edgeToMidNodeId.find(curEdge); + } + if (it != edgeToMidNodeId.end()) { + belem.m_NodeIDs.push_back(it->second); } - belem.m_NodeIDs.push_back(curEdgeIter->m_midNode); } } } -} \ No newline at end of file +} diff --git a/meshLoader/MeshLoader.h b/meshLoader/MeshLoader.h index 4e2d05b..07f7f1c 100644 --- a/meshLoader/MeshLoader.h +++ b/meshLoader/MeshLoader.h @@ -5,34 +5,43 @@ #include #include #include "Components.h" +#include "unordered_set" class MeshLoader { private: Node getMiddleNode(const Edge&); - std::array getMiddleCoords(const Edge&); protected: - std::vector Nodes; - std::vector FiniteElements; - std::vector BoundaryElements; + IdGenerator m_nodeId; + IdGenerator m_finiteElementId; + IdGenerator m_boundaryElementId; + std::unordered_map Nodes; + std::unordered_map FiniteElements; + std::unordered_map BoundaryElements; public: virtual void loadMesh(const std::string&) = 0; virtual ~MeshLoader() = default; - const std::vector& getNodes(); - const std::vector& getFiniteElements(); - const std::vector& getBoundaryElements(); + const std::unordered_map& getNodes(); + const std::unordered_map& getFiniteElements(); + const std::unordered_map& getBoundaryElements(); - std::vector getFiniteElementByID(int, int, int); - std::vector getFiniteElementByEdge(int, int); - std::vector getNodesIDByBorder(int); + std::unordered_set getFiniteElementIDByNodesID(int, int, int); + std::unordered_set getFiniteElementIDByEdge(int, int); + std::unordered_set getNodesIDByBorder(int); + std::unordered_set getFiniteElementIdBySurface(int); + std::unordered_set getBoundElementIDByBorder(int); - std::vector getFiniteElementIdBySurface(int); - std::vector getBoundElementIDByBorder(int); + std::vector getFiniteElementByNodesID(int, int, int); + std::vector getFiniteElementByEdge(int, int); + std::vector getNodesByBorder(int); + std::vector getFiniteElementBySurface(int); + std::vector getBoundElementByBorder(int); - static void printNodes(const std::vector&); - static void printFiniteElements(const std::vector&); + static void printNodes(const std::unordered_map&); + static void printFiniteElements(const std::unordered_map&); + static void printBoundaryElements(const std::unordered_map&); void insertNodeMid(); - std::vector> createNeighborsVector(); + std::unordered_map> createNeighborsMap(); }; diff --git a/meshLoader/main.cpp b/meshLoader/main.cpp index 763feb6..2d3d227 100644 --- a/meshLoader/main.cpp +++ b/meshLoader/main.cpp @@ -12,7 +12,7 @@ using namespace std; int main(int argc, char* argv[]) { std::string filepath = "./cube.aneu"; - if (argc !=2) + if (argc != 2) std::cout << "Wrong number of arguments, using standard file PATH\n" << std::endl; else { std::cout << "Set file path to " << argv[1] << "\n" << std::endl; @@ -20,7 +20,7 @@ int main(int argc, char* argv[]) { }; - MeshLoader* l = new AneuMeshLoader(); + MeshLoader* l = new AneuMeshLoader(); try { l->loadMesh(filepath); } @@ -40,41 +40,49 @@ int main(int argc, char* argv[]) { std::cout << "Bouundary Finite Elements from file: \n" << std::endl; - l->printFiniteElements(l->getBoundaryElements()); + l->printBoundaryElements(l->getBoundaryElements()); std::cout << "Neighbours of Nodes: \n" << std::endl; - l->createNeighborsVector(); + l->createNeighborsMap(); std::cout << "ID Finite elements by nodes (4,1,2)" << std::endl; - auto finelem_1 = l->getFiniteElementByID(4,1,2); + auto finelem_1 = l->getFiniteElementIDByNodesID(4, 1, 2); for (int elem : finelem_1) { std::cout << elem << " "; } std::cout << std::endl << "-----------------------------------" << std::endl; - std::cout << "ID Finite elements by Edge (4,6)" << std::endl; - auto finelem_2 = l->getFiniteElementByEdge(4, 6); + std::cout << "ID Finite elements by Edge (4,7)" << std::endl; + auto finelem_2 = l->getFiniteElementIDByEdge(4, 7); for (int elem : finelem_2) { std::cout << elem << " "; } std::cout << std::endl << "-----------------------------------" << std::endl; - std::cout << "Boundary element ID by boundary ID (2)" << std::endl; - auto finelem_3 = l->getBoundElementIDByBorder(2); + std::cout << "ID of Nodes by Geometry Area ID of Bounder element (3)" << std::endl; + auto finnode = l->getNodesIDByBorder(3); + for (int node : finnode) { + std::cout << node << " "; + } + std::cout << std::endl << "-----------------------------------" << std::endl; + + + std::cout << "ID Finite elements by surface ID (1)" << std::endl; + auto finelem_3 = l->getFiniteElementIdBySurface(1); for (int elem : finelem_3) { std::cout << elem << " "; } std::cout << std::endl << "-----------------------------------" << std::endl; - std::cout << "ID of Nodes by ID of Bounder element (3)" << std::endl; - auto finnode = l->getNodesIDByBorder(3); - for (int node : finnode) { - std::cout << node << " "; + std::cout << "Boundary element ID by boundary ID (2)" << std::endl; + auto finelem_4 = l->getBoundElementIDByBorder(2); + for (int elem : finelem_4) { + std::cout << elem << " "; } std::cout << std::endl << "-----------------------------------" << std::endl; @@ -88,7 +96,7 @@ int main(int argc, char* argv[]) { std::cout << "Neighbours of new Nodes: \n" << std::endl; - l->createNeighborsVector(); + l->createNeighborsMap(); delete l; -- GitLab