diff --git "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/AneuMeshLoader.cpp" "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/AneuMeshLoader.cpp"
index 661bb00f9071e3271005c68cdc85f741f5a316cf..163cd59acea7e887181c8de3b9bfe3a845b4bcd8 100644
--- "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/AneuMeshLoader.cpp"	
+++ "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/AneuMeshLoader.cpp"	
@@ -11,38 +11,64 @@ void AneuMeshLoader::loadMesh(const std::string& fileName)
 
     // количество узлов (вершин) и размерность пространства
     inputFile >> nodeNumber >> dimension;
-    nodeSTL.reserve(nodeNumber);
-    for (int i = 0; i < nodeNumber; ++i) 
+    VectorOfNodes.reserve(nodeNumber);
+    for (int i = 1; i <= nodeNumber; ++i) 
     {
-        nodeSTL.emplace_back();
-        nodeSTL[i].id = i + 1;
-        inputFile >> nodeSTL[i].coordinates[0] >> nodeSTL[i].coordinates[1] >> nodeSTL[i].coordinates[2];
-        nodeSTL[i].isVertex = false;
+
+        Node temp_node;
+        temp_node.NodeId = i;
+        inputFile 
+            >> temp_node.coordinates[0] 
+            >> temp_node.coordinates[1] 
+            >> temp_node.coordinates[2];
+        temp_node.isVertex = true;
+        VectorOfNodes.push_back(temp_node); 
     }
 
     // количество конечных элементов (граней) и количество вершин в одном конечном элементе (грани)
     inputFile >> elementNumber >> nodesInElement;
-    finiteSTL.reserve(elementNumber);
-    for (int i = 0; i < elementNumber; ++i) 
+    VectorOfFE.reserve(elementNumber);
+    for (int i = 1; i <= elementNumber; ++i) 
     {
-        finiteSTL.emplace_back();
-        finiteSTL[i].FiniteElementIdList.resize(nodesInElement);
-        finiteSTL[i].id = i + 1;
-        inputFile >> finiteSTL[i].MaterialId;
-        for (auto& nodeId : finiteSTL[i].FiniteElementIdList)
-            inputFile >> nodeId;
+        FiniteElement temp_FE;
+        temp_FE.FEId = i;
+        inputFile >> temp_FE.MaterialId;
+        temp_FE.FiniteElementIdList.reserve(nodesInElement);
+        int temp_id;
+        for (int j = 0; j < nodesInElement; ++j)
+        {
+            inputFile >> temp_id;
+            temp_FE.FiniteElementIdList.push_back(temp_id);
+        }
+        VectorOfFE.push_back(std::move(temp_FE));
     }
 
     // количество ребер куба и то, сколько ребер связывает одна вершина (в 3-х мерном пространстве - 3)
     inputFile >> boundaryNumber >> nodesInBoundary;
-    boundarySTL.reserve(boundaryNumber);
-    for (int i = 0; i < boundaryNumber; ++i) 
+    VectorOfBFE.reserve(boundaryNumber);
+    for (int i = 1; i <= boundaryNumber; ++i) 
     {
-        boundarySTL.emplace_back();
-        boundarySTL[i].elementId = i + 1;
-        inputFile >> boundarySTL[i].boundaryId;
-        boundarySTL[i].BoundaryFiniteElementIdList.reserve(nodesInBoundary);
-        for (auto& nodeId : boundarySTL[i].BoundaryFiniteElementIdList)
-            inputFile >> nodeId;
+        BoundaryFiniteElement temp_BFE;
+        temp_BFE.BFEId = i;
+        inputFile >> temp_BFE.boundaryId;
+        temp_BFE.FiniteElementIdList.reserve(nodesInBoundary);
+        int temp_id;
+        for (int j = 0; j < nodesInBoundary; ++j)
+        {
+            inputFile >> temp_id;
+            temp_BFE.FiniteElementIdList.push_back(temp_id);
+        }
+
+        std::vector<FiniteElement> temp_FiniteElements = getFiniteElementsById(
+            temp_BFE.FiniteElementIdList[0],
+            temp_BFE.FiniteElementIdList[1],
+            temp_BFE.FiniteElementIdList[2]);
+
+        temp_BFE.FEId = temp_FiniteElements[0].FEId;
+        temp_BFE.MaterialId = temp_FiniteElements[0].MaterialId;
+        VectorOfBFE.push_back(std::move(temp_BFE));
+
     }
+    inputFile.close();
+    std::cout << "Data loaded successfully" << std::endl;
 }
\ No newline at end of file
diff --git "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/MeshLoader.cpp" "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/MeshLoader.cpp"
index d684e06d159ad0dbc74680e6e6c88d4a51634b77..7a5b88f32a80f1c49dd078c5a9152fa8bd49487f 100644
--- "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/MeshLoader.cpp"	
+++ "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/MeshLoader.cpp"	
@@ -1,43 +1,42 @@
 #include "MeshLoader.h"
 
-const std::vector<Node>& MeshLoader::getNodeSTL() const 
+std::vector<Node>& MeshLoader::getVectorOfNodes() 
 {
-    return nodeSTL;
+    return VectorOfNodes;
 }
 
-const std::vector<FiniteElement>& MeshLoader::getFiniteSTL() const 
+std::vector<FiniteElement>& MeshLoader::getVectorOfFE() 
 {
-    return finiteSTL;
+    return VectorOfFE;
 }
 
-const std::vector<BoundaryFiniteElement>& MeshLoader::getBoundarySTL() const 
+std::vector<BoundaryFiniteElement>& MeshLoader::getVectorOfBFE() 
 {
-    return boundarySTL;
+    return VectorOfBFE;
 }
 
-std::vector<size_t> MeshLoader::findFiniteElementById(int x, int y, int z) const 
+std::vector<FiniteElement> MeshLoader::getFiniteElementsById(int id1, int id2, int id3)
 {
-    std::vector<size_t> element{};
-    auto pred = [x, y, z](const FiniteElement& FE)
+    std::vector<FiniteElement> answer;
+    auto current_iter = VectorOfFE.begin();
+    auto last_iter = VectorOfFE.end();
+    while (current_iter != last_iter) 
     {
-        return std::find(FE.FiniteElementIdList.begin(), FE.FiniteElementIdList.end(), x) != FE.FiniteElementIdList.end()
-            && std::find(FE.FiniteElementIdList.begin(), FE.FiniteElementIdList.end(), y) != FE.FiniteElementIdList.end()
-            && std::find(FE.FiniteElementIdList.begin(), FE.FiniteElementIdList.end(), z) != FE.FiniteElementIdList.end();
-    };
-    auto iter = finiteSTL.begin();
-    while (iter != finiteSTL.end()) 
-    {
-        iter = std::find_if(iter, finiteSTL.end(), pred);
-        if (iter != finiteSTL.end()) 
+        current_iter = std::find_if(current_iter, last_iter, [id1, id2, id3](FiniteElement current_element) 
+            {
+            return std::find(current_element.FiniteElementIdList.begin(), current_element.FiniteElementIdList.end(), id1) != current_element.FiniteElementIdList.end()
+                && std::find(current_element.FiniteElementIdList.begin(), current_element.FiniteElementIdList.end(), id2) != current_element.FiniteElementIdList.end()
+                && std::find(current_element.FiniteElementIdList.begin(), current_element.FiniteElementIdList.end(), id3) != current_element.FiniteElementIdList.end(); });
+        if (current_iter != last_iter) 
         {
-            element.push_back(iter->id);
-            ++iter;
+            answer.push_back(*current_iter);
+            ++current_iter;
         }
     }
-    return element;
+    return answer;
 }
 
-std::vector<FiniteElement> MeshLoader::findFiniteElementByEdge(int x, int y) const 
+std::vector<FiniteElement> MeshLoader::getFiniteElementsByEdge(int x, int y) const 
 {
     std::vector<FiniteElement> element{};
     auto pred = [x, y](const FiniteElement& FE)
@@ -45,11 +44,11 @@ std::vector<FiniteElement> MeshLoader::findFiniteElementByEdge(int x, int y) con
         return std::find(FE.FiniteElementIdList.begin(), FE.FiniteElementIdList.end(), x) != FE.FiniteElementIdList.end()
             && std::find(FE.FiniteElementIdList.begin(), FE.FiniteElementIdList.end(), y) != FE.FiniteElementIdList.end();
     };
-    auto iter = finiteSTL.begin();
-    while (iter != finiteSTL.end()) 
+    auto iter = VectorOfFE.begin();
+    while (iter != VectorOfFE.end())
     {
-        iter = std::find_if(iter, finiteSTL.end(), pred);
-        if (iter != finiteSTL.end()) 
+        iter = std::find_if(iter, VectorOfFE.end(), pred);
+        if (iter != VectorOfFE.end())
         {
             element.push_back(*iter);
             ++iter;
@@ -58,18 +57,18 @@ std::vector<FiniteElement> MeshLoader::findFiniteElementByEdge(int x, int y) con
     return element;
 }
 
-std::vector<BoundaryFiniteElement> MeshLoader::getBoundaryFiniteElementSTLByBoundaryId(size_t boundaryId) const 
+std::vector<BoundaryFiniteElement> MeshLoader::getBoundaryFiniteElementsSTLByBoundaryId(size_t boundaryId) const 
 {
     std::vector<BoundaryFiniteElement> element{};
     auto pred = [boundaryId](const BoundaryFiniteElement& BFE) 
     {
         return BFE.boundaryId == boundaryId;
     };
-    auto iter = boundarySTL.begin();
-    while (iter != boundarySTL.end()) 
+    auto iter = VectorOfBFE.begin();
+    while (iter != VectorOfBFE.end())
     {
-        iter = std::find_if(iter, boundarySTL.end(), pred);
-        if (iter != boundarySTL.end()) 
+        iter = std::find_if(iter, VectorOfBFE.end(), pred);
+        if (iter != VectorOfBFE.end())
         {
             element.push_back(*iter);
             ++iter;
@@ -85,13 +84,13 @@ std::set<size_t> MeshLoader::getNodeSTLByBoundaryId(size_t boundaryId) const
     {
         return BFE.boundaryId == boundaryId;
     };
-    auto iter = boundarySTL.begin();
-    while (iter != boundarySTL.end()) 
+    auto iter = VectorOfBFE.begin();
+    while (iter != VectorOfBFE.end())
     {
-        iter = std::find_if(iter, boundarySTL.end(), pred);
-        if (iter != boundarySTL.end()) 
+        iter = std::find_if(iter, VectorOfBFE.end(), pred);
+        if (iter != VectorOfBFE.end())
         {
-            for (const auto& node : iter->BoundaryFiniteElementIdList) 
+            for (const auto& node : iter->FiniteElementIdList) 
                 element.insert(node);
             ++iter;
         }
@@ -99,18 +98,18 @@ std::set<size_t> MeshLoader::getNodeSTLByBoundaryId(size_t boundaryId) const
     return element;
 }
 
-std::vector<FiniteElement> MeshLoader::getFiniteElementByMaterial(size_t MaterialId) const 
+std::vector<FiniteElement> MeshLoader::getFiniteElementsByMaterial(size_t MaterialId) const 
 {
     std::vector<FiniteElement> element{};
     auto pred = [MaterialId](const FiniteElement& FE) 
     {
         return MaterialId == FE.MaterialId;
     };
-    auto iter = finiteSTL.begin();
-    while (iter != finiteSTL.end()) 
+    auto iter = VectorOfFE.begin();
+    while (iter != VectorOfFE.end())
     {
-        iter = std::find_if(iter, finiteSTL.end(), pred);
-        if (iter != finiteSTL.end()) 
+        iter = std::find_if(iter, VectorOfFE.end(), pred);
+        if (iter != VectorOfFE.end())
         {
             element.push_back(*iter);
             ++iter;
@@ -119,21 +118,21 @@ std::vector<FiniteElement> MeshLoader::getFiniteElementByMaterial(size_t Materia
     return element;
 }
 
-std::vector<std::set<size_t>> MeshLoader::getNeighbourSTL() const 
+std::vector<std::set<size_t>> MeshLoader::getNeighbourSTL() const
 {
-    std::vector<std::set<size_t>> vector(nodeSTL.size() + 1);
-    for (const auto& element : finiteSTL)
+    std::vector<std::set<size_t>> vector(VectorOfNodes.size() + 1);
+    for (const auto& element : VectorOfFE)
         for (const auto& id : element.FiniteElementIdList)
             for (const auto& neighbourId : element.FiniteElementIdList)
                 if (id != neighbourId)
                     vector[id].insert(neighbourId);
-    return vector;
+    return vector; 
 }
 
 void MeshLoader::insertNodesInCenter()
 {
     std::unordered_set <Edge, Hash> edge_set;
-    for (auto& element : finiteSTL) 
+    for (auto& element : VectorOfFE)
     {
         std::vector<size_t> FiniteElementNodeId = element.FiniteElementIdList;
         for (int first = 0; first < 3; ++first) 
@@ -144,9 +143,9 @@ void MeshLoader::insertNodesInCenter()
                 if (edge_set.insert(currentEdge).second) // check if such point already exists
                 {
                     Node new_Node = getCenterNode(currentEdge);
-                    currentEdge.setCenter(new_Node.id);
-                    nodeSTL.push_back(new_Node);
-                    element.FiniteElementIdList.push_back(new_Node.id);
+                    currentEdge.setCenter(new_Node.NodeId);
+                    VectorOfNodes.push_back(new_Node);
+                    element.FiniteElementIdList.push_back(new_Node.NodeId);
                 }
                 else 
                 {
@@ -155,7 +154,7 @@ void MeshLoader::insertNodesInCenter()
             }
         }
     }
-    for (auto& element : finiteSTL) 
+    for (auto& element : VectorOfFE)
     {
         std::vector<size_t> BoundaryFiniteElementNodeId = element.FiniteElementIdList;
         for (auto first = 0; first < 3; ++first) 
@@ -175,17 +174,25 @@ void MeshLoader::insertNodesInCenter()
 
 std::array<double, 3> MeshLoader::getCenterEdge(const Edge& edge) 
 {
-    double centerX = ((nodeSTL.at(edge.nodePair.first - 1).coordinates.at(0)) +
-        (nodeSTL.at(edge.nodePair.second - 1).coordinates.at(0))) / 2;
-    double centerY = ((nodeSTL.at(edge.nodePair.first - 1).coordinates.at(1)) +
-        (nodeSTL.at(edge.nodePair.second - 1).coordinates.at(1))) / 2;
-    double centerZ = ((nodeSTL.at(edge.nodePair.first - 1).coordinates.at(2)) +
-        (nodeSTL.at(edge.nodePair.second - 1).coordinates.at(2))) / 2;
+    double centerX = ((VectorOfNodes.at(edge.nodePair.first - 1).coordinates.at(0)) +
+        (VectorOfNodes.at(edge.nodePair.second - 1).coordinates.at(0))) / 2;
+    double centerY = ((VectorOfNodes.at(edge.nodePair.first - 1).coordinates.at(1)) +
+        (VectorOfNodes.at(edge.nodePair.second - 1).coordinates.at(1))) / 2;
+    double centerZ = ((VectorOfNodes.at(edge.nodePair.first - 1).coordinates.at(2)) +
+        (VectorOfNodes.at(edge.nodePair.second - 1).coordinates.at(2))) / 2;
     return {centerX, centerY, centerZ};
 }
 
 Node MeshLoader::getCenterNode(const Edge& edge) 
 {
-    Node new_Node(nodeSTL.size() + 1, getCenterEdge(edge), false); // using new Node constructor
+    Node new_Node(VectorOfNodes.size() + 1, getCenterEdge(edge), false); // using new Node constructor
     return new_Node;
+}
+
+void MeshLoader::PrintData()
+{
+    std::cout 
+        << getVectorOfNodes() << std::endl
+        << getVectorOfFE() << std::endl
+        << getVectorOfBFE() << std::endl;
 }
\ No newline at end of file
diff --git "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/MeshLoader.h" "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/MeshLoader.h"
index 28ea930cb1742793d8601c80fc13a060d1662dcf..ace066063c01ea711f87ae2309cd18efc48f3a77 100644
--- "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/MeshLoader.h"	
+++ "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/MeshLoader.h"	
@@ -6,22 +6,25 @@
 class MeshLoader 
 {
 protected:
-    std::vector<Node> nodeSTL;
-    std::vector<FiniteElement> finiteSTL;
-    std::vector<BoundaryFiniteElement> boundarySTL;
+    std::vector<Node> VectorOfNodes;
+    std::vector<FiniteElement> VectorOfFE;
+    std::vector<BoundaryFiniteElement> VectorOfBFE;
 public:
     virtual ~MeshLoader() = default;
     virtual void loadMesh(const std::string&) = 0;
-    const std::vector<Node>& getNodeSTL() const;
-    const std::vector<FiniteElement>& getFiniteSTL() const;
-    const std::vector<BoundaryFiniteElement>& getBoundarySTL() const;
-    std::vector<size_t> findFiniteElementById(int x, int y, int z) const;
-    std::vector<FiniteElement> findFiniteElementByEdge(int x, int y) const;
-    std::vector<FiniteElement> getFiniteElementByMaterial(size_t MaterialId) const;
+
+    std::vector<Node>& getVectorOfNodes();
+    std::vector<FiniteElement>& getVectorOfFE();
+    std::vector<BoundaryFiniteElement>& getVectorOfBFE();
+
+    std::vector<FiniteElement> getFiniteElementsById(int x, int y, int z);
+    std::vector<FiniteElement> getFiniteElementsByEdge(int x, int y) const;
+    std::vector<FiniteElement> getFiniteElementsByMaterial(size_t MaterialId) const;
     std::set<size_t> getNodeSTLByBoundaryId(size_t boundaryId) const;
-    std::vector<BoundaryFiniteElement> getBoundaryFiniteElementSTLByBoundaryId(size_t boundaryId) const;
+    std::vector<BoundaryFiniteElement> getBoundaryFiniteElementsSTLByBoundaryId(size_t boundaryId) const;
     std::vector<std::set<size_t>> getNeighbourSTL() const;
     Node getCenterNode(const Edge&);
     std::array<double, 3> getCenterEdge(const Edge& edge);
     void insertNodesInCenter();
+    void PrintData();
 };
diff --git "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/Structures.cpp" "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/Structures.cpp"
index 693d46e3ea5d62c493105dfaa17c9a1176beaacd..5a22ef44fce3640be5036d4d95272248a1141ab8 100644
--- "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/Structures.cpp"	
+++ "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/Structures.cpp"	
@@ -2,78 +2,66 @@
 
 std::istream& operator>>(std::istream& in, Node& node) 
 {
-    in >> node.id;
-    in >> node.coordinates[0] >> node.coordinates[1] >> node.coordinates[2];
+    in >> node.NodeId;
+    in >> node.coordinates[0] 
+        >> node.coordinates[1] 
+        >> node.coordinates[2];
     in >> node.isVertex;
     return in;
 }
 
 std::ostream& operator<<(std::ostream& out, const Node& node) 
 {
-    out << node.id 
-        << ' ' 
-        << node.coordinates[0] 
-        << ' ' 
-        << node.coordinates[1] 
-        << ' ' 
-        << node.coordinates[2] 
-        << ' ' 
-        << node.isVertex;
+    out << std::setw(4) << node.NodeId << " |"
+        << std::right << std::setw(11) << node.coordinates[0] << std::setw(11) << node.coordinates[1] << std::setw(11) << node.coordinates[2]
+        << " | " << node.isVertex << "\n";
     return out;
 }
 
-std::istream& operator>>(std::istream& in, FiniteElement& element) 
+std::istream& operator>>(std::istream& in, FiniteElement& FE) 
 {
-    in >> element.id;
-    in >> element.MaterialId;
-    in >> element.FiniteElementIdList[0] >> element.FiniteElementIdList[1] >> element.FiniteElementIdList[2];
+    in >> FE.FEId;
+    in >> FE.MaterialId;
+    in >> FE.FiniteElementIdList[0] 
+        >> FE.FiniteElementIdList[1] 
+        >> FE.FiniteElementIdList[2];
     return in;
 }
 
-std::ostream& operator<<(std::ostream& out, const FiniteElement& element) 
+std::ostream& operator<<(std::ostream& out, const FiniteElement& FE) 
 {
-    out << element.id 
-        << ' ' 
-        << element.MaterialId 
-        << ' ' 
-        << element.FiniteElementIdList[0]
-        << ' ' 
-        << element.FiniteElementIdList[1]
-        << ' ' 
-        << element.FiniteElementIdList[2];
+    out << std::setw(4) << FE.FEId << " |"
+        << std::setw(11) << FE.MaterialId << " |";
+    for (const auto& nodes_ID_it : FE.FiniteElementIdList)
+        out << std::right << std::setw(4) << nodes_ID_it;
+    out << "\n";
     return out;
 }
 
 
-std::istream& operator>>(std::istream& in, BoundaryFiniteElement& element) 
+std::istream& operator>>(std::istream& in, BoundaryFiniteElement& BFE) 
 {
-    in >> element.elementId;
-    in >> element.boundaryId;
-    in >> element.BoundaryFiniteElementIdList[0] 
-        >> element.BoundaryFiniteElementIdList[1] 
-        >> element.BoundaryFiniteElementIdList[2] 
-        >> element.BoundaryFiniteElementIdList[3];
+    in >> BFE.BFEId;
+    in >> BFE.boundaryId;
+    in >> BFE.FiniteElementIdList[0] 
+        >> BFE.FiniteElementIdList[1]
+        >> BFE.FiniteElementIdList[2]
+        >> BFE.FiniteElementIdList[3];
     return in;
 }
 
-std::ostream& operator<<(std::ostream& out, const BoundaryFiniteElement& element) 
+std::ostream& operator<<(std::ostream& out, const BoundaryFiniteElement& BFE) 
 {
-    out << element.elementId
-        << ' '
-        << element.boundaryId
-        << ' '
-        << element.BoundaryFiniteElementIdList[0]
-        << ' '
-        << element.BoundaryFiniteElementIdList[1]
-        << ' '
-        << element.BoundaryFiniteElementIdList[2]
-        << ' '
-        << element.BoundaryFiniteElementIdList[3];
+    out << std::setw(9) << BFE.BFEId << " |"
+        << std::setw(9) << BFE.boundaryId << " |";
+    for (const auto& nodes_ID_it : BFE.FiniteElementIdList)
+        out << std::right << std::setw(4) << nodes_ID_it;
+    out << "\n";
     return out;
 }
 
 Node::Node(int nodeId, const std::array<double, 3>& nodeCoordinates, bool isVertex1):
-    id(nodeId),
+    NodeId(nodeId),
     coordinates(nodeCoordinates),
     isVertex(isVertex1)
 {}
@@ -91,3 +79,32 @@ bool Edge::operator==(const Edge& a) const
 {
     return (nodePair.first == a.nodePair.first) && (nodePair.second == a.nodePair.second);
 }
+
+std::ostream& operator<<(std::ostream& out_stream, const std::vector<Node>& VectorOfNodes) 
+{
+    out_stream << VectorOfNodes.size() << (VectorOfNodes.size() > 1 ? " Nodes:\n" : " Node:\n") << " ID"
+        << std::setw(10) << "X" << std::setw(11) << "Y" << std::setw(11) << "Z" << std::setw(14) << "Vertex\n";
+    for (const auto& it : VectorOfNodes)
+        out_stream << it;
+    return out_stream;
+}
+
+std::ostream& operator<<(std::ostream& out_stream, const std::vector<FiniteElement>& VectorOfFE) 
+{
+    int elements_size = VectorOfFE.size();
+    out_stream << elements_size << (elements_size > 1 ? " FiniteElements:\n" : " FiniteElement:\n")
+        << " ID" << std::setw(15) << "Material_ID" << std::setw(15) << "Nodes ID\n";
+    for (const auto& it : VectorOfFE)
+        out_stream << it;
+    return out_stream;
+}
+
+std::ostream& operator<<(std::ostream& out, const std::vector<BoundaryFiniteElement>& VectorOfBFE) 
+{
+    int surfaces_size = VectorOfBFE.size();
+    out << surfaces_size << (surfaces_size > 1 ? " BoundaryFiniteElements:\n" : " BoundaryFiniteElement:\n")
+        << "Surface_ID" << std::setw(12) << "Boundary_ID" << std::setw(14) << "Nodes ID\n";
+    for (const auto& it : VectorOfBFE)
+        out << it;
+    return out;
+}
diff --git "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/Structures.h" "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/Structures.h"
index 2c187eb0529a00c8951bb53c30fac0e865295e06..9552c7856d4d3c981f009d050136f50926dad830 100644
--- "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/Structures.h"	
+++ "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/Structures.h"	
@@ -4,11 +4,12 @@
 #include <set>
 #include <array>
 #include <unordered_map>
+#include <iomanip>
 
 class Node 
 {
 public:
-    size_t id;
+    size_t NodeId;
     std::array<double, 3> coordinates;
     bool isVertex = false;
 
@@ -16,12 +17,13 @@ public:
     Node(int, const std::array<double, 3>&, bool);
     friend std::istream& operator>>(std::istream&, Node&);
     friend std::ostream& operator<<(std::ostream&, const Node&);
+    friend std::ostream& operator<<(std::ostream&, const std::vector<Node>&);
 };
 
 class FiniteElement 
 {
 public:
-    size_t id;
+    size_t FEId;
     size_t MaterialId;
     std::vector<size_t> FiniteElementIdList;
 
@@ -29,18 +31,19 @@ public:
     FiniteElement(const FiniteElement&) = default;
     friend std::istream& operator>>(std::istream&, FiniteElement&);
     friend std::ostream& operator<<(std::ostream&, const FiniteElement&);
-
+    friend std::ostream& operator<<(std::ostream&, const std::vector<FiniteElement>&);
 };
 
-class BoundaryFiniteElement 
+class BoundaryFiniteElement : public FiniteElement
 {
 public:
-    size_t elementId;
+    size_t BFEId;
     size_t boundaryId;
-    std::vector<size_t> BoundaryFiniteElementIdList;
+    //std::vector<size_t> BoundaryFiniteElementIdList;
 
     friend std::istream& operator>>(std::istream&, BoundaryFiniteElement&);
     friend std::ostream& operator<<(std::ostream&, const BoundaryFiniteElement&);
+    friend std::ostream& operator<<(std::ostream&, const std::vector<BoundaryFiniteElement>&);
 };
 
 class Edge 
diff --git "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/main.cpp" "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/main.cpp"
index ddb7e89cd54d9ae50e24d62840ca17881452163d..3503c247a5db9bc3243d3d86fd59d6a65828a210 100644
--- "a/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/main.cpp"	
+++ "b/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/\320\233\320\260\320\261\320\276\321\200\320\260\321\202\320\276\321\200\320\275\320\260\321\217 \321\200\320\260\320\261\320\276\321\202\320\260 \342\204\2261 (2 \321\201\320\265\320\274\320\265\321\201\321\202\321\200)/main.cpp"	
@@ -9,19 +9,20 @@ int main()
     MeshLoader* loader = new AneuMeshLoader;
     std::shared_ptr<MeshLoader> smart_loader(loader);
     smart_loader->loadMesh("cube.aneu");
-    const auto& nodeSTL = smart_loader->getNodeSTL();
-    const auto& finiteSTL = smart_loader->getFiniteSTL();
-    const auto& boundarySTL = smart_loader->getBoundarySTL();
+    const auto& nodeSTL = smart_loader->getVectorOfNodes();
+    const auto& finiteSTL = smart_loader->getVectorOfFE();
+    const auto& boundarySTL = smart_loader->getVectorOfBFE();
 
-    auto elementById = smart_loader->findFiniteElementById(0, 0, 0);
-    auto elementByEdge = smart_loader->findFiniteElementByEdge(1, 0);
-
-    auto FEByType = smart_loader->getFiniteElementByMaterial(1);
-    auto nodesByBoundary = smart_loader->getNodeSTLByBoundaryId(3);
-    auto BFEByBoundary = smart_loader->getBoundaryFiniteElementSTLByBoundaryId(1);
+    auto FEById = smart_loader->getFiniteElementsById(2, 4, 8);
+    auto FEByEdge = smart_loader->getFiniteElementsByEdge(2, 8);
+    auto FEByType = smart_loader->getFiniteElementsByMaterial(0);
+    auto nodesByBoundary = smart_loader->getNodeSTLByBoundaryId(1);
+    auto BFEByBoundary = smart_loader->getBoundaryFiniteElementsSTLByBoundaryId(1);
     auto neighbours = smart_loader->getNeighbourSTL();
 
+    smart_loader->PrintData();
     smart_loader->insertNodesInCenter();
+    smart_loader->PrintData();
 
     return 0;
 }