diff --git a/MeshLoader.cpp b/MeshLoader.cpp
index 109b2458afdf8a615bfdf82d6ea567e2994eed3a..c9131523a4bb7f1e9fdeae36b7cea9173d7f4dfc 100644
--- a/MeshLoader.cpp
+++ b/MeshLoader.cpp
@@ -22,7 +22,8 @@ void MeshLoader::Print_Data()
 	std::cout << get_Nodes() << std::endl << get_FiniteElements() << std::endl << get_BoundaryElements() << std::endl;
 }
 
-int MeshLoader::get_last_node_id() {
+int MeshLoader::get_last_node_id() 
+{
     return nodes.rbegin()->id;
 }
 
@@ -33,26 +34,28 @@ std::vector<Node>& MeshLoader::get_Nodes()
 
 std::vector<FiniteElement>& MeshLoader::get_FiniteElements()
 {
-        return elements;
+    return elements;
 }
 
 std::vector<BoundaryFiniteElement>& MeshLoader::get_BoundaryElements()
 {
-        return boundary_elements;
+    return boundary_elements;
 }
 
 std::vector<FiniteElement> MeshLoader::find_Elements_by_nodes(int idx, int idy, int idz)
 {
 	std::set<FiniteElement> res;
+
 	auto iter1 = elements.begin();
 	auto iter2 = elements.end();
+
 	while(iter1 != iter2)
 	{
-		iter1 = std::find_if(iter1, iter2, [idx, idy, idz](const FiniteElement& cur){ 
+		iter1 = std::find_if(iter1, iter2, [idx, idy, idz](const FiniteElement& cur)
+			{ 
 			return (std::find(cur.nodes_id.begin(), cur.nodes_id.end(), idx) != cur.nodes_id.end()
-				&& std::find(cur.nodes_id.begin(), cur.nodes_id.end(), idy) != cur.nodes_id.end() &&
-			std::find(cur.nodes_id.begin(), cur.nodes_id.end(), idz) != cur.nodes_id.end()
-		);
+				 && std::find(cur.nodes_id.begin(), cur.nodes_id.end(), idy) != cur.nodes_id.end() 
+				 && std::find(cur.nodes_id.begin(), cur.nodes_id.end(), idz) != cur.nodes_id.end()	);
 		});
 		if(iter1 != iter2)
 		{
@@ -69,12 +72,13 @@ std::vector<FiniteElement> MeshLoader::find_Elements_by_edge(int id1, int id2)
 
 		auto iter1 = elements.begin();
 		auto iter2 = elements.end();
+
         while(iter1 != iter2)
         {
-			iter1 = std::find_if(iter1, iter2, [id1, id2](const FiniteElement& cur){ 
+			iter1 = std::find_if(iter1, iter2, [id1, id2](const FiniteElement& cur)
+				{ 
 				return (std::find(cur.nodes_id.begin(), cur.nodes_id.end(), id1) != cur.nodes_id.end()
-                        && std::find(cur.nodes_id.begin(), cur.nodes_id.end(), id2) != cur.nodes_id.end()
-                	);
+                        && std::find(cur.nodes_id.begin(), cur.nodes_id.end(), id2) != cur.nodes_id.end());
                 });
                 if(iter1 != iter2)
                 {
@@ -88,13 +92,17 @@ std::vector<FiniteElement> MeshLoader::find_Elements_by_edge(int id1, int id2)
 std::vector<Node> MeshLoader::find_Nodes_by_s_id(int s_id)
 {
 	std::vector<Node> res;
+
 	auto iter1 = nodes.begin();
     auto iter2 = nodes.end();
+
 	while(iter1 != iter2)
     {
-		iter1 = std::find_if(iter1, iter2, [s_id](const Node& belem){
+		iter1 = std::find_if(iter1, iter2, [s_id](const Node& belem)
+		{
 			return (belem.id == s_id);
 		});
+
 		if(iter1 != iter2)
 		{
 			res.push_back(*iter1);
@@ -107,34 +115,52 @@ std::vector<Node> MeshLoader::find_Nodes_by_s_id(int s_id)
 std::vector<FiniteElement> MeshLoader::find_Elements_by_material(int mat_id)
 {
 	std::vector<FiniteElement> res;
+
 	auto iter1 = elements.begin();
     auto iter2 = elements.end();
+
 	while(iter1 != iter2)
 	{
 		std::copy_if(iter1, iter2, inserter(res, res.end()), [mat_id](const FiniteElement& elem){return elem.id_material == mat_id;}); 
 	}
+	
+	//!!! Зачем нужно копировать по 10 раз? У нас кол-во КЭ большое по условию. В ЛР экономим память и добиваемся высокого быстродействия.
+	
 	std::vector<FiniteElement> res1(res.begin(),res.end());
+
 	return res1;                           
 }
 
 std::vector<BoundaryFiniteElement>  MeshLoader::find_Belements_by_b_id(int b_id)
 {
 	std::vector<BoundaryFiniteElement> res;
+
 	auto iter1 = boundary_elements.begin();
 	auto iter2 = boundary_elements.end();
+
 	while(iter1 != iter2)
 	{
         std::copy_if(iter1, iter2, inserter(res, res.end()), [b_id](const BoundaryFiniteElement& b){ return b.border_id == b_id; });
 	}
+
 	return res;                                
 }
 
-Node* MeshLoader::get_node_by_id(int id) {
-	return nodes.find(id);                 
+Node* MeshLoader::get_node_by_id(int id) 
+{
+    //!!! Потеряны преимущества контейнера узлов. Вы по ID не можете сразу найти узел?
+    
+    //for (auto& cur : nodes)
+    //    if (cur.id == id)
+    //        return &cur;
+
+	return &nodes[id];                 
 }
 
-std::vector<std::vector<Node>> MeshLoader::get_nodes_neighbors() {
+std::vector<std::vector<Node>> MeshLoader::get_nodes_neighbors() 
+{
 	std::vector<std::set<int>> res(nodes.size() + 1);
+
 	for (auto& it : elements)
 	{
 		for (auto node_it : it.nodes_id)
@@ -145,56 +171,76 @@ std::vector<std::vector<Node>> MeshLoader::get_nodes_neighbors() {
 	}
 	
 	std::vector<std::vector<Node>> result(nodes.size() + 1);
-	for (int i = 1; i < int(nodes.size()) + 1; ++i) {
+
+	for (int i = 1; i < int(nodes.size()) + 1; ++i)
+	{
         	std::vector<Node> temp_vec;
         	temp_vec.reserve(res[i].size());
-        	for (auto& it : res[i])
-            		temp_vec.push_back(*get_node_by_id(it));
+			for (auto& it : res[i])
+			{
+				temp_vec.push_back(*get_node_by_id(it));
+			}
         	result[i] = std::move(temp_vec);
     	}
 	return result;
 }
 
 
-void MeshLoader::Transform_Elements() {
-    std::unordered_set<Edge, hash_u_set<Edge>> edges;
 
-    for (auto& it : elements) {
+
+
+void MeshLoader::Transform_Elements() 
+{
+    std::unordered_set<Edge, hash_u_set<Edge>> edges; //!!! Не нашел определения hash_u_set
+
+    for (auto& it : elements)
+	{
         std::vector<int> current_nodes(it.nodes_id);
+
         for (auto i = current_nodes.begin(); i < current_nodes.end() - 1; ++i)
-            for (auto j = i + 1; j < current_nodes.end(); ++j) {
+            for (auto j = i + 1; j < current_nodes.end(); ++j) 
+			{
                 Edge current_edge(*i, *j, 0);
+                
+                //!!! Потеря быстродействия при использовании алгоритма вместо спец. метода.
                 auto founded_edge = edges.find(current_edge);
-                if (founded_edge == edges.end()) {
+
+                if (founded_edge == edges.end()) 
+				{
                     Node left_node = *get_node_by_id(*i);
                     Node right_node = *get_node_by_id(*j);
                     int center_id_ = get_last_node_id() + 1;
 					Node center_node(center_id_, (left_node.cords[0] + right_node.cords[0]) / 2,
 						(left_node.cords[1] + right_node.cords[1]) / 2, (left_node.cords[2]+ right_node.cords[2]) / 2, false);
+
 					current_edge.update(center_id_);
                     nodes.push_back(center_node);
                     edges.insert(current_edge);
                     it.nodes_id.push_back(center_id_);
-                } else {
+                } else 
+				{
                     it.nodes_id.push_back(founded_edge->c_id);
                 }
             }
         it.nodes_id.shrink_to_fit();
     }
-	for (auto& it : boundary_elements) {
+	for (auto& it : boundary_elements) 
+	{
         std::vector<int> current_nodes(it.nodes_id);
         for (auto i = current_nodes.begin(); i < current_nodes.end() - 1; ++i)
-            for (auto j = i + 1; j < current_nodes.end(); ++j) {
+            for (auto j = i + 1; j < current_nodes.end(); ++j) 
+			{
                 Edge current_edge(*i, *j, 0);
                 
-                //!!! Использование алгоритма всместо метода - получаем линейное время по кол-ву ребер
-                auto founded_edge = std::find(edges.begin(), edges.end(), current_edge);
-                
+                //!!! Потеря быстродействия при использовании алгоритма вместо спец. метода.
+                auto founded_edge = edges.find(current_edge);
+
                 if (founded_edge != edges.end())
                     it.nodes_id.push_back(founded_edge->c_id);
             }
         it.nodes_id.shrink_to_fit();
     }
+
 	boundary_elements.shrink_to_fit();
     nodes.shrink_to_fit();
 }