diff --git a/Unstructured_mesh/Unstructured_mesh.pro.user b/Unstructured_mesh/Unstructured_mesh.pro.user
index d45594a497b3316ba58510c9d77aec0f2e24f2d0..6af9df7b850baa325a6087665c0a92a91f3cf0c6 100644
--- a/Unstructured_mesh/Unstructured_mesh.pro.user
+++ b/Unstructured_mesh/Unstructured_mesh.pro.user
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 4.10.0, 2019-09-27T19:25:22. -->
+<!-- Written by QtCreator 4.10.0, 2019-09-29T16:23:43. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>
diff --git a/Unstructured_mesh/main.cpp b/Unstructured_mesh/main.cpp
index cd48d54e021a060607fb6f908a28fc64b5d24a9a..d93d04595fef355fd6cdeb0b2f388ce7d59eca09 100644
--- a/Unstructured_mesh/main.cpp
+++ b/Unstructured_mesh/main.cpp
@@ -9,246 +9,246 @@ using namespace std;
 
 void cube(UnstructuredMesh<3, size_t, double, 6>& mesh3){
     DBGCHECK;
-        mesh3.GetVertices().push_back({0, {0,0,0}});
-        mesh3.GetVertices().push_back({1, {1,0,0}});
-        mesh3.GetVertices().push_back({2, {0,1,0}});
-        mesh3.GetVertices().push_back({3, {1,1,0}});
-        mesh3.GetVertices().push_back({4, {0,0,1}});
-        mesh3.GetVertices().push_back({5, {1,0,1}});
-        mesh3.GetVertices().push_back({6, {0,1,1}});
-        mesh3.GetVertices().push_back({7, {1,1,1}});
+        mesh3.getVertices().push_back({0, {0,0,0}});
+        mesh3.getVertices().push_back({1, {1,0,0}});
+        mesh3.getVertices().push_back({2, {0,1,0}});
+        mesh3.getVertices().push_back({3, {1,1,0}});
+        mesh3.getVertices().push_back({4, {0,0,1}});
+        mesh3.getVertices().push_back({5, {1,0,1}});
+        mesh3.getVertices().push_back({6, {0,1,1}});
+        mesh3.getVertices().push_back({7, {1,1,1}});
     DBGCHECK;
-        mesh3.GetEdges().push_back({0,0,1});
-        mesh3.GetEdges().push_back({1,0,2});
-        mesh3.GetEdges().push_back({2,1,3});
-        mesh3.GetEdges().push_back({3,2,3});
-        mesh3.GetEdges().push_back({4,0,4});
-        mesh3.GetEdges().push_back({5,1,5});
-        mesh3.GetEdges().push_back({6,3,7});
-        mesh3.GetEdges().push_back({7,2,6});
-        mesh3.GetEdges().push_back({8,4,5});
-        mesh3.GetEdges().push_back({9,5,7});
-        mesh3.GetEdges().push_back({10,6,7});
-        mesh3.GetEdges().push_back({11,4,6});
+        mesh3.getEdges().push_back({0,0,1});
+        mesh3.getEdges().push_back({1,0,2});
+        mesh3.getEdges().push_back({2,1,3});
+        mesh3.getEdges().push_back({3,2,3});
+        mesh3.getEdges().push_back({4,0,4});
+        mesh3.getEdges().push_back({5,1,5});
+        mesh3.getEdges().push_back({6,3,7});
+        mesh3.getEdges().push_back({7,2,6});
+        mesh3.getEdges().push_back({8,4,5});
+        mesh3.getEdges().push_back({9,5,7});
+        mesh3.getEdges().push_back({10,6,7});
+        mesh3.getEdges().push_back({11,4,6});
     DBGCHECK;
-        mesh3.GetFaces().push_back(0);
-        mesh3.GetFaces().at(0).getSubelements().addSubelement(0,true);
-        mesh3.GetFaces().at(0).getSubelements().addSubelement(1,true);
-        mesh3.GetFaces().at(0).getSubelements().addSubelement(2,true);
-        mesh3.GetFaces().at(0).getSubelements().addSubelement(3,true);
-        mesh3.GetFaces().push_back(1);
-        mesh3.GetFaces().at(1).getSubelements().addSubelement(0,true);
-        mesh3.GetFaces().at(1).getSubelements().addSubelement(5,true);
-        mesh3.GetFaces().at(1).getSubelements().addSubelement(8,true);
-        mesh3.GetFaces().at(1).getSubelements().addSubelement(4,true);
-        mesh3.GetFaces().push_back(2);
-        mesh3.GetFaces().at(2).getSubelements().addSubelement(1,true);
-        mesh3.GetFaces().at(2).getSubelements().addSubelement(4,true);
-        mesh3.GetFaces().at(2).getSubelements().addSubelement(11,true);
-        mesh3.GetFaces().at(2).getSubelements().addSubelement(7,true);
-        mesh3.GetFaces().push_back(3);
-        mesh3.GetFaces().at(3).getSubelements().addSubelement(3,true);
-        mesh3.GetFaces().at(3).getSubelements().addSubelement(6,true);
-        mesh3.GetFaces().at(3).getSubelements().addSubelement(10,true);
-        mesh3.GetFaces().at(3).getSubelements().addSubelement(7,true);
-        mesh3.GetFaces().push_back(4);
-        mesh3.GetFaces().at(4).getSubelements().addSubelement(2,true);
-        mesh3.GetFaces().at(4).getSubelements().addSubelement(6,true);
-        mesh3.GetFaces().at(4).getSubelements().addSubelement(9,true);
-        mesh3.GetFaces().at(4).getSubelements().addSubelement(5,true);
-        mesh3.GetFaces().push_back(5);
-        mesh3.GetFaces().at(5).getSubelements().addSubelement(8,true);
-        mesh3.GetFaces().at(5).getSubelements().addSubelement(9,true);
-        mesh3.GetFaces().at(5).getSubelements().addSubelement(10,true);
-        mesh3.GetFaces().at(5).getSubelements().addSubelement(11,true);
+        mesh3.getFaces().push_back(0);
+        mesh3.getFaces().at(0).getSubelements().addSubelement(0,true);
+        mesh3.getFaces().at(0).getSubelements().addSubelement(1,true);
+        mesh3.getFaces().at(0).getSubelements().addSubelement(2,true);
+        mesh3.getFaces().at(0).getSubelements().addSubelement(3,true);
+        mesh3.getFaces().push_back(1);
+        mesh3.getFaces().at(1).getSubelements().addSubelement(0,true);
+        mesh3.getFaces().at(1).getSubelements().addSubelement(5,true);
+        mesh3.getFaces().at(1).getSubelements().addSubelement(8,true);
+        mesh3.getFaces().at(1).getSubelements().addSubelement(4,true);
+        mesh3.getFaces().push_back(2);
+        mesh3.getFaces().at(2).getSubelements().addSubelement(1,true);
+        mesh3.getFaces().at(2).getSubelements().addSubelement(4,true);
+        mesh3.getFaces().at(2).getSubelements().addSubelement(11,true);
+        mesh3.getFaces().at(2).getSubelements().addSubelement(7,true);
+        mesh3.getFaces().push_back(3);
+        mesh3.getFaces().at(3).getSubelements().addSubelement(3,true);
+        mesh3.getFaces().at(3).getSubelements().addSubelement(6,true);
+        mesh3.getFaces().at(3).getSubelements().addSubelement(10,true);
+        mesh3.getFaces().at(3).getSubelements().addSubelement(7,true);
+        mesh3.getFaces().push_back(4);
+        mesh3.getFaces().at(4).getSubelements().addSubelement(2,true);
+        mesh3.getFaces().at(4).getSubelements().addSubelement(6,true);
+        mesh3.getFaces().at(4).getSubelements().addSubelement(9,true);
+        mesh3.getFaces().at(4).getSubelements().addSubelement(5,true);
+        mesh3.getFaces().push_back(5);
+        mesh3.getFaces().at(5).getSubelements().addSubelement(8,true);
+        mesh3.getFaces().at(5).getSubelements().addSubelement(9,true);
+        mesh3.getFaces().at(5).getSubelements().addSubelement(10,true);
+        mesh3.getFaces().at(5).getSubelements().addSubelement(11,true);
     DBGCHECK;
 
-        mesh3.GetFaces().at(0).setNextBElem(1,0);
-        mesh3.GetFaces().at(1).setNextBElem(2,0);
-        mesh3.GetFaces().at(2).setNextBElem(3,0);
-        mesh3.GetFaces().at(3).setNextBElem(4,0);
-        mesh3.GetFaces().at(4).setNextBElem(5,0);
-        mesh3.GetFaces().at(5).setNextBElem(0,0);
+        mesh3.getFaces().at(0).setNextBElem(1,0);
+        mesh3.getFaces().at(1).setNextBElem(2,0);
+        mesh3.getFaces().at(2).setNextBElem(3,0);
+        mesh3.getFaces().at(3).setNextBElem(4,0);
+        mesh3.getFaces().at(4).setNextBElem(5,0);
+        mesh3.getFaces().at(5).setNextBElem(0,0);
 
-        mesh3.GetCells().push_back(0);
-        mesh3.GetCells().at(0).setBoundaryElementIndex(3);
+        mesh3.getCells().push_back(0);
+        mesh3.getCells().at(0).setBoundaryElementIndex(3);
     DBGCHECK;
 }
 
 void twoPrisms(UnstructuredMesh<3, size_t, double, 6>& mesh3){
     DBGCHECK;
-        mesh3.GetVertices().push_back({0, {0,0,0}});
-        mesh3.GetVertices().push_back({1, {1,0,0}});
-        mesh3.GetVertices().push_back({2, {0,1,0}});
-        mesh3.GetVertices().push_back({3, {1,1,0}});
-        mesh3.GetVertices().push_back({4, {0,0,1}});
-        mesh3.GetVertices().push_back({5, {1,0,1}});
-        mesh3.GetVertices().push_back({6, {0,1,1}});
-        mesh3.GetVertices().push_back({7, {1,1,1}});
+        mesh3.getVertices().push_back({0, {0,0,0}});
+        mesh3.getVertices().push_back({1, {1,0,0}});
+        mesh3.getVertices().push_back({2, {0,1,0}});
+        mesh3.getVertices().push_back({3, {1,1,0}});
+        mesh3.getVertices().push_back({4, {0,0,1}});
+        mesh3.getVertices().push_back({5, {1,0,1}});
+        mesh3.getVertices().push_back({6, {0,1,1}});
+        mesh3.getVertices().push_back({7, {1,1,1}});
     DBGCHECK;
-        mesh3.GetEdges().push_back({0,0,1});
-        mesh3.GetEdges().push_back({1,0,2});
-        mesh3.GetEdges().push_back({2,1,3});
-        mesh3.GetEdges().push_back({3,2,3});
-        mesh3.GetEdges().push_back({4,0,4});
-        mesh3.GetEdges().push_back({5,1,5});
-        mesh3.GetEdges().push_back({6,3,7});
-        mesh3.GetEdges().push_back({7,2,6});
-        mesh3.GetEdges().push_back({8,4,5});
-        mesh3.GetEdges().push_back({9,5,7});
-        mesh3.GetEdges().push_back({10,6,7});
-        mesh3.GetEdges().push_back({11,4,6});
-        mesh3.GetEdges().push_back({12,6,5});
-        mesh3.GetEdges().push_back({13,2,1});
+        mesh3.getEdges().push_back({0,0,1});
+        mesh3.getEdges().push_back({1,0,2});
+        mesh3.getEdges().push_back({2,1,3});
+        mesh3.getEdges().push_back({3,2,3});
+        mesh3.getEdges().push_back({4,0,4});
+        mesh3.getEdges().push_back({5,1,5});
+        mesh3.getEdges().push_back({6,3,7});
+        mesh3.getEdges().push_back({7,2,6});
+        mesh3.getEdges().push_back({8,4,5});
+        mesh3.getEdges().push_back({9,5,7});
+        mesh3.getEdges().push_back({10,6,7});
+        mesh3.getEdges().push_back({11,4,6});
+        mesh3.getEdges().push_back({12,6,5});
+        mesh3.getEdges().push_back({13,2,1});
     DBGCHECK;
     size_t index = 0;
-        mesh3.GetFaces().push_back(index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(0,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(1,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(13,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(13,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(2,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(3,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(0,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(5,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(8,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(4,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(1,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(4,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(11,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(7,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(3,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(6,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(10,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(7,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(2,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(6,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(9,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(5,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(8,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(12,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(11,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(9,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(10,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(12,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(12,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(7,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(13,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(5,true);
+        mesh3.getFaces().push_back(index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(0,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(1,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(13,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(13,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(2,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(3,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(0,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(5,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(8,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(4,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(1,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(4,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(11,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(7,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(3,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(6,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(10,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(7,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(2,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(6,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(9,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(5,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(8,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(12,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(11,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(9,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(10,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(12,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(12,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(7,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(13,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(5,true);
     DBGCHECK;
 
-        mesh3.GetFaces().at(0).setNextBElem(2,0);
-        mesh3.GetFaces().at(2).setNextBElem(3,0);
-        mesh3.GetFaces().at(3).setNextBElem(8,0);
-        mesh3.GetFaces().at(8).setNextBElem(6,0);
-        mesh3.GetFaces().at(6).setNextBElem(0,0);
-        mesh3.GetCells().push_back(0);
-        mesh3.GetCells().at(0).setBoundaryElementIndex(0);
-
-        mesh3.GetFaces().at(1).setNextBElem(5,1);
-        mesh3.GetFaces().at(5).setNextBElem(4,1);
-        mesh3.GetFaces().at(4).setNextBElem(8,1);
-        mesh3.GetFaces().at(8).setNextBElem(7,1);
-        mesh3.GetFaces().at(7).setNextBElem(1,1);
-        mesh3.GetCells().push_back(1);
-        mesh3.GetCells().at(1).setBoundaryElementIndex(1);
+        mesh3.getFaces().at(0).setNextBElem(2,0);
+        mesh3.getFaces().at(2).setNextBElem(3,0);
+        mesh3.getFaces().at(3).setNextBElem(8,0);
+        mesh3.getFaces().at(8).setNextBElem(6,0);
+        mesh3.getFaces().at(6).setNextBElem(0,0);
+        mesh3.getCells().push_back(0);
+        mesh3.getCells().at(0).setBoundaryElementIndex(0);
+
+        mesh3.getFaces().at(1).setNextBElem(5,1);
+        mesh3.getFaces().at(5).setNextBElem(4,1);
+        mesh3.getFaces().at(4).setNextBElem(8,1);
+        mesh3.getFaces().at(8).setNextBElem(7,1);
+        mesh3.getFaces().at(7).setNextBElem(1,1);
+        mesh3.getCells().push_back(1);
+        mesh3.getCells().at(1).setBoundaryElementIndex(1);
 
     DBGCHECK;
 }
 
 void twoDeformedPrisms(UnstructuredMesh<3, size_t, double, 6>& mesh3){
     DBGCHECK;
-        mesh3.GetVertices().push_back({0, {0,0,1}});
-        mesh3.GetVertices().push_back({1, {1,0,0}});
-        mesh3.GetVertices().push_back({2, {0,1,0}});
-        mesh3.GetVertices().push_back({3, {1,1,0}});
-        mesh3.GetVertices().push_back({4, {0,0,2}});
-        mesh3.GetVertices().push_back({5, {1,0,1}});
-        mesh3.GetVertices().push_back({6, {0,1,1}});
-        mesh3.GetVertices().push_back({7, {1,1,2}});
+        mesh3.getVertices().push_back({0, {0,0,1}});
+        mesh3.getVertices().push_back({1, {1,0,0}});
+        mesh3.getVertices().push_back({2, {0,1,0}});
+        mesh3.getVertices().push_back({3, {1,1,0}});
+        mesh3.getVertices().push_back({4, {0,0,2}});
+        mesh3.getVertices().push_back({5, {1,0,1}});
+        mesh3.getVertices().push_back({6, {0,1,1}});
+        mesh3.getVertices().push_back({7, {1,1,2}});
     DBGCHECK;
-        mesh3.GetEdges().push_back({0,0,1});
-        mesh3.GetEdges().push_back({1,0,2});
-        mesh3.GetEdges().push_back({2,1,3});
-        mesh3.GetEdges().push_back({3,2,3});
-        mesh3.GetEdges().push_back({4,0,4});
-        mesh3.GetEdges().push_back({5,1,5});
-        mesh3.GetEdges().push_back({6,3,7});
-        mesh3.GetEdges().push_back({7,2,6});
-        mesh3.GetEdges().push_back({8,4,5});
-        mesh3.GetEdges().push_back({9,5,7});
-        mesh3.GetEdges().push_back({10,6,7});
-        mesh3.GetEdges().push_back({11,4,6});
-        mesh3.GetEdges().push_back({12,6,5});
-        mesh3.GetEdges().push_back({13,2,1});
+        mesh3.getEdges().push_back({0,0,1});
+        mesh3.getEdges().push_back({1,0,2});
+        mesh3.getEdges().push_back({2,1,3});
+        mesh3.getEdges().push_back({3,2,3});
+        mesh3.getEdges().push_back({4,0,4});
+        mesh3.getEdges().push_back({5,1,5});
+        mesh3.getEdges().push_back({6,3,7});
+        mesh3.getEdges().push_back({7,2,6});
+        mesh3.getEdges().push_back({8,4,5});
+        mesh3.getEdges().push_back({9,5,7});
+        mesh3.getEdges().push_back({10,6,7});
+        mesh3.getEdges().push_back({11,4,6});
+        mesh3.getEdges().push_back({12,6,5});
+        mesh3.getEdges().push_back({13,2,1});
     DBGCHECK;
     size_t index = 0;
-        mesh3.GetFaces().push_back(index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(0,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(1,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(13,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(13,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(2,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(3,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(0,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(5,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(8,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(4,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(1,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(4,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(11,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(7,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(3,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(6,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(10,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(7,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(2,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(6,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(9,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(5,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(8,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(12,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(11,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(9,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(10,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(12,true);
-        mesh3.GetFaces().push_back(++index);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(12,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(7,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(13,true);
-        mesh3.GetFaces().at(index).getSubelements().addSubelement(5,true);
+        mesh3.getFaces().push_back(index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(0,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(1,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(13,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(13,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(2,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(3,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(0,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(5,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(8,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(4,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(1,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(4,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(11,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(7,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(3,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(6,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(10,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(7,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(2,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(6,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(9,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(5,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(8,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(12,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(11,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(9,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(10,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(12,true);
+        mesh3.getFaces().push_back(++index);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(12,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(7,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(13,true);
+        mesh3.getFaces().at(index).getSubelements().addSubelement(5,true);
     DBGCHECK;
 
-        mesh3.GetFaces().at(0).setNextBElem(2,0);
-        mesh3.GetFaces().at(2).setNextBElem(3,0);
-        mesh3.GetFaces().at(3).setNextBElem(8,0);
-        mesh3.GetFaces().at(8).setNextBElem(6,0);
-        mesh3.GetFaces().at(6).setNextBElem(0,0);
-        mesh3.GetCells().push_back(0);
-        mesh3.GetCells().at(0).setBoundaryElementIndex(0);
-
-        mesh3.GetFaces().at(1).setNextBElem(5,1);
-        mesh3.GetFaces().at(5).setNextBElem(4,1);
-        mesh3.GetFaces().at(4).setNextBElem(8,1);
-        mesh3.GetFaces().at(8).setNextBElem(7,1);
-        mesh3.GetFaces().at(7).setNextBElem(1,1);
-        mesh3.GetCells().push_back(1);
-        mesh3.GetCells().at(1).setBoundaryElementIndex(1);
+        mesh3.getFaces().at(0).setNextBElem(2,0);
+        mesh3.getFaces().at(2).setNextBElem(3,0);
+        mesh3.getFaces().at(3).setNextBElem(8,0);
+        mesh3.getFaces().at(8).setNextBElem(6,0);
+        mesh3.getFaces().at(6).setNextBElem(0,0);
+        mesh3.getCells().push_back(0);
+        mesh3.getCells().at(0).setBoundaryElementIndex(0);
+
+        mesh3.getFaces().at(1).setNextBElem(5,1);
+        mesh3.getFaces().at(5).setNextBElem(4,1);
+        mesh3.getFaces().at(4).setNextBElem(8,1);
+        mesh3.getFaces().at(8).setNextBElem(7,1);
+        mesh3.getFaces().at(7).setNextBElem(1,1);
+        mesh3.getCells().push_back(1);
+        mesh3.getCells().at(1).setBoundaryElementIndex(1);
 
     DBGCHECK;
 }
@@ -258,52 +258,52 @@ void testMesh2D() {
     sit mesh;
 
 
-    mesh.GetVertices().resize(4);
-
-    mesh.GetVertices().at(0).SetIndex(0);
-    mesh.GetVertices().at(0) = {0,0};
-    mesh.GetVertices().at(1).SetIndex(1);
-    mesh.GetVertices().at(1) = {0,1};
-    mesh.GetVertices().at(2).SetIndex(2);
-    mesh.GetVertices().at(2) = {1,0};
-    mesh.GetVertices().at(3).SetIndex(3);
-    mesh.GetVertices().at(3) = {1,1};
-
-    mesh.GetFaces().resize(5);
-    mesh.GetFaces().at(0).vertexAIndex = 1;
-    mesh.GetFaces().at(0).vertexBIndex = 0;
-    mesh.GetFaces().at(1).vertexAIndex = 0;
-    mesh.GetFaces().at(1).vertexBIndex = 2;
-    mesh.GetFaces().at(2).vertexAIndex = 2;
-    mesh.GetFaces().at(2).vertexBIndex = 1;
-    mesh.GetFaces().at(3).vertexAIndex = 3;
-    mesh.GetFaces().at(3).vertexBIndex = 1;
-    mesh.GetFaces().at(4).vertexAIndex = 2;
-    mesh.GetFaces().at(4).vertexBIndex = 3;
+    mesh.getVertices().resize(4);
+
+    mesh.getVertices().at(0).setIndex(0);
+    mesh.getVertices().at(0) = {0,0};
+    mesh.getVertices().at(1).setIndex(1);
+    mesh.getVertices().at(1) = {0,1};
+    mesh.getVertices().at(2).setIndex(2);
+    mesh.getVertices().at(2) = {1,0};
+    mesh.getVertices().at(3).setIndex(3);
+    mesh.getVertices().at(3) = {1,1};
+
+    mesh.getFaces().resize(5);
+    mesh.getFaces().at(0).vertexAIndex = 1;
+    mesh.getFaces().at(0).vertexBIndex = 0;
+    mesh.getFaces().at(1).vertexAIndex = 0;
+    mesh.getFaces().at(1).vertexBIndex = 2;
+    mesh.getFaces().at(2).vertexAIndex = 2;
+    mesh.getFaces().at(2).vertexBIndex = 1;
+    mesh.getFaces().at(3).vertexAIndex = 3;
+    mesh.getFaces().at(3).vertexBIndex = 1;
+    mesh.getFaces().at(4).vertexAIndex = 2;
+    mesh.getFaces().at(4).vertexBIndex = 3;
     for(size_t i = 0; i < 5; i++)
-        mesh.GetFaces().at(i).SetIndex(i);
+        mesh.getFaces().at(i).setIndex(i);
 
-    mesh.GetFaces().at(0).setNextBElem(1,0);
-    mesh.GetFaces().at(1).setNextBElem(2,0);
-    mesh.GetFaces().at(2).setNextBElem(0,0);
+    mesh.getFaces().at(0).setNextBElem(1,0);
+    mesh.getFaces().at(1).setNextBElem(2,0);
+    mesh.getFaces().at(2).setNextBElem(0,0);
 
-    mesh.GetFaces().at(2).setNextBElem(3,1);
-    mesh.GetFaces().at(3).setNextBElem(4,1);
-    mesh.GetFaces().at(4).setNextBElem(2,1);
+    mesh.getFaces().at(2).setNextBElem(3,1);
+    mesh.getFaces().at(3).setNextBElem(4,1);
+    mesh.getFaces().at(4).setNextBElem(2,1);
 
 
-    mesh.GetCells().resize(2);
-    mesh.GetCells().at(0).setBoundaryElementIndex(0);
-    mesh.GetCells().at(0).SetIndex(0);
-    mesh.GetCells().at(1).setBoundaryElementIndex(2);
-    mesh.GetCells().at(1).SetIndex(1);
+    mesh.getCells().resize(2);
+    mesh.getCells().at(0).setBoundaryElementIndex(0);
+    mesh.getCells().at(0).setIndex(0);
+    mesh.getCells().at(1).setBoundaryElementIndex(2);
+    mesh.getCells().at(1).setIndex(1);
 
     mesh.InitializeCenters();
 
 
 
-    sit::MeshElementWrap<1> ele(&mesh, mesh.GetEdges().at(0));
-    sit::MeshElementWrap<2> cell(&mesh, mesh.GetCells().at(0));
+    sit::MeshElementWrap<1> ele(&mesh, mesh.getEdges().at(0));
+    sit::MeshElementWrap<2> cell(&mesh, mesh.getCells().at(0));
 
     DBGMSG("cell boundary iterator test");
 
@@ -312,24 +312,24 @@ void testMesh2D() {
     }
 
 
-    for(auto i : mesh.GetElement<2>(1).getSubelements()){
+    for(auto i : mesh.getElement<2>(1).getSubelements()){
         DBGVAR(i)
     }
 
     DBGMSG("cell vertices using iterator");
-    for(size_t i = 0; i < mesh.GetCells().size(); i++){
-        for(auto j : mesh.GetElement<2>(i).getSubelements()){
-            auto e = mesh.GetElement<1>(j);
-            DBGVAR(e.GetElement().GetVertexAIndex(), e.GetElement().GetVertexBIndex())
+    for(size_t i = 0; i < mesh.getCells().size(); i++){
+        for(auto j : mesh.getElement<2>(i).getSubelements()){
+            auto e = mesh.getElement<1>(j);
+            DBGVAR(e.getElement().getVertexAIndex(), e.getElement().getVertexBIndex())
         }
     }
 
     MeshDataContainer<std::set<size_t>, 2> vertices(mesh);
 
     DBGMSG("vertices of cells in 2D");
-    for (auto& cell : mesh.GetCells()){
+    for (auto& cell : mesh.getCells()){
         std::set<size_t>& _set = vertices.at(cell);
-        DBGVAR(cell.GetIndex())
+        DBGVAR(cell.getIndex())
         for (size_t index: _set){
             DBGVAR(index)
         }
@@ -344,8 +344,8 @@ void testMesh2D() {
         DBGVAR(center)
     }
     DBGMSG("cellCenter");
-    for(sit::Cell& cell : mesh.GetCells()){
-        DBGVAR(centers.GetDataDim<2>().at(cell.GetIndex()))
+    for(sit::Cell& cell : mesh.getCells()){
+        DBGVAR(centers.GetDataDim<2>().at(cell.getIndex()))
     }
 
 
@@ -367,15 +367,15 @@ void testMesh2D() {
     DBGMSG("2D normals test");
 
     auto normals = ComputeFaceNormals(mesh);
-    for(auto& edge : mesh.GetEdges()){
-        DBGVAR(edge.GetIndex(),normals.at(edge))
+    for(auto& edge : mesh.getEdges()){
+        DBGVAR(edge.getIndex(),normals.at(edge))
     }
 
     DBGMSG("2D cells distances");
 
     auto distances = ComputeCellsDistance(mesh);
-    for(auto& edge : mesh.GetEdges()){
-        DBGVAR(edge.GetIndex(),distances.at(edge))
+    for(auto& edge : mesh.getEdges()){
+        DBGVAR(edge.getIndex(),distances.at(edge))
     }
 
 }
@@ -387,24 +387,24 @@ void testMesh3D() {
     using sit3 = UnstructuredMesh<3, size_t, double, 6>;
     UnstructuredMesh<3, size_t, double, 6> mesh3;
     twoPrisms(mesh3);
-    size_t tmp_face = mesh3.GetCells().at(0).getBoundaryElementIndex();
+    size_t tmp_face = mesh3.getCells().at(0).getBoundaryElementIndex();
 
     do {
         DBGVAR(tmp_face)
-        for (auto& sube : mesh3.GetFaces().at(tmp_face).getSubelements()) {
+        for (auto& sube : mesh3.getFaces().at(tmp_face).getSubelements()) {
             DBGVAR(sube.index)
             if (sube.index != INVALID_INDEX(size_t) ){
-                DBGVAR(sube.index, mesh3.GetVertices().at(mesh3.GetEdges().at(sube.index).GetVertexAIndex()),mesh3.GetVertices().at(mesh3.GetEdges().at(sube.index).GetVertexBIndex()))
+                DBGVAR(sube.index, mesh3.getVertices().at(mesh3.getEdges().at(sube.index).getVertexAIndex()),mesh3.getVertices().at(mesh3.getEdges().at(sube.index).getVertexBIndex()))
             }
         }
 
-        tmp_face = mesh3.GetFaces().at(tmp_face).getNextBElem(0);
-    } while (tmp_face != mesh3.GetCells().at(0).getBoundaryElementIndex());
-//    mesh3.GetElements<0>().at(0).;
+        tmp_face = mesh3.getFaces().at(tmp_face).getNextBElem(0);
+    } while (tmp_face != mesh3.getCells().at(0).getBoundaryElementIndex());
+//    mesh3.getElements<0>().at(0).;
 
 
     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()){
         DBGVAR(i.index)
     }
@@ -433,13 +433,13 @@ void testMesh3D() {
     //_ComputeCenters<1,3, 3,2,1>::compute<size_t, double, 6>(centers, mesh3);
     auto centers = ComputeCenters(mesh3);
 
-    for(auto& face : mesh3.GetFaces()) {
-        face.setCenter(centers.template GetDataDim<2>().at(face.GetIndex()));
+    for(auto& face : mesh3.getFaces()) {
+        face.setCenter(centers.template GetDataDim<2>().at(face.getIndex()));
         DBGVAR(face.getCenter())
     }
     DBGMSG("cellCenter");
-    for(auto& cell : mesh3.GetCells()) {
-        cell.setCenter(centers.template GetDataDim<3>().at(cell.GetIndex()));
+    for(auto& cell : mesh3.getCells()) {
+        cell.setCenter(centers.template GetDataDim<3>().at(cell.getIndex()));
         DBGVAR(cell.getCenter())
     }
 
@@ -461,8 +461,8 @@ void testMesh3D() {
     DBGMSG("2D normals test");
 
     auto normals = mesh3.ComputeFaceNormals();
-    for(auto& face : mesh3.GetFaces()){
-        DBGVAR(face.GetIndex(),normals.at(face))
+    for(auto& face : mesh3.getFaces()){
+        DBGVAR(face.getIndex(),normals.at(face))
     }
 
     DBGMSG("mesh apply test");
@@ -477,8 +477,8 @@ void testMesh3D() {
 
     DBGMSG("connection test");
     auto con = temp1::MeshConnections<3,0>::connections(mesh3);
-    for (auto& cell : mesh3.GetCells()){
-        DBGVAR(cell.GetIndex())
+    for (auto& cell : mesh3.getCells()){
+        DBGVAR(cell.getIndex())
         for(size_t i : con[cell]){
             DBGVAR(i)
         }
@@ -487,8 +487,8 @@ void testMesh3D() {
 
     DBGMSG("connection test oposite");
     auto con1 = temp1::MeshConnections<0,3>::connections(mesh3);
-    for (auto& vert : mesh3.GetVertices()){
-        DBGVAR(vert.GetIndex())
+    for (auto& vert : mesh3.getVertices()){
+        DBGVAR(vert.getIndex())
         for(size_t i : con1[vert]){
             DBGVAR(i)
         }
@@ -496,14 +496,14 @@ void testMesh3D() {
 
     DBGMSG("face to vertex colouring");
     auto colours = temp1::ColourMesh<2,0>::colour(mesh3);
-    for (auto& face : mesh3.GetFaces()){
-        DBGVAR(face.GetIndex(), colours.at(face))
+    for (auto& face : mesh3.getFaces()){
+        DBGVAR(face.getIndex(), colours.at(face))
     }
 
     DBGMSG("vertex to face colouring");
     auto colours1 = temp1::ColourMesh<0,2>::colour(mesh3);
-    for (auto& vert : mesh3.GetVertices()){
-        DBGVAR(vert.GetIndex(), colours1.at(vert))
+    for (auto& vert : mesh3.getVertices()){
+        DBGVAR(vert.getIndex(), colours1.at(vert))
     }
 }
 
@@ -516,12 +516,12 @@ void test3DMeshDeformedPrisms() {
     //_ComputeCenters<1,3, 3,2,1>::compute<size_t, double, 6>(centers, mesh3);
     auto centers = ComputeCenters(mesh3);
 
-    for(auto& face : mesh3.GetFaces()) {
+    for(auto& face : mesh3.getFaces()) {
         face.setCenter(centers[face]);
         DBGVAR(face.getCenter())
     }
     DBGMSG("cellCenter");
-    for(auto& cell : mesh3.GetCells()) {
+    for(auto& cell : mesh3.getCells()) {
         cell.setCenter(centers[cell]);
         DBGVAR(cell.getCenter())
     }
@@ -561,7 +561,7 @@ void testMeshDataContainer() {
         c=42;
     }
 
-    for(auto& v : mesh3.GetVertices()){
+    for(auto& v : mesh3.getVertices()){
         DBGVAR(container.at(v))
     }
 
diff --git a/Unstructured_mesh/mesh_element.h b/Unstructured_mesh/mesh_element.h
index b2cb42bc1adaf91b01ddaa33aa062907dfa189d6..107acf6a0570a7313eb08abbc3415c8b08451231 100644
--- a/Unstructured_mesh/mesh_element.h
+++ b/Unstructured_mesh/mesh_element.h
@@ -30,19 +30,19 @@ public:
         elementIndex = index;
     }
 
-    IndexType GetIndex(){
+    IndexType getIndex(){
         return elementIndex;
     }
 
-    void SetIndex(IndexType index){
+    void setIndex(IndexType index){
         elementIndex = index;
     }
 /*
-    IndexType GetGlobalIndex(){
+    IndexType getGlobalIndex(){
         return globalElementIndex;
     }
 
-    void SetGlobalIndex(IndexType index){
+    void setGlobalIndex(IndexType index){
         globalElementIndex = index;
     }
 */
@@ -171,26 +171,26 @@ public:
                 IndexType vertexAIndex = INVALID_INDEX(IndexType),
                 IndexType vertexBIndex = INVALID_INDEX(IndexType))
         :MeshElementBase<IndexType>(index) {
-        SetVertexAIndex(vertexAIndex);
-        SetVertexBIndex(vertexBIndex);
+        setVertexAIndex(vertexAIndex);
+        setVertexBIndex(vertexBIndex);
     }
 
 
 
-    IndexType GetVertexAIndex(){
+    IndexType getVertexAIndex(){
         return vertexAIndex;
     }
 
-    IndexType GetVertexBIndex(){
+    IndexType getVertexBIndex(){
         return vertexBIndex;
     }
 
-    void SetVertexAIndex(IndexType index){
+    void setVertexAIndex(IndexType index){
         vertexAIndex = index;
     }
 
 
-    void SetVertexBIndex(IndexType index){
+    void setVertexBIndex(IndexType index){
         vertexBIndex = index;
     }
 
@@ -280,73 +280,71 @@ public:
     using Face = MeshElement<Dimension, Dimension - 1, IndexType, Real, reserve<Dimension - 1>()>;
     using Cell = MeshElement<Dimension, Dimension, IndexType, Real, 0>;
 
-    template <unsigned int dim>
-    struct ElemType //lze nahradit šablonovým using
-    {
-        using type = MeshElement<Dimension, dim, IndexType, Real, reserve<dim>()>;
-    };
+    template<unsigned int ElementDimension>
+    using ElementType = MeshElement<Dimension, ElementDimension, IndexType, Real, reserve<ElementDimension>()>;
+
 
     template<unsigned int dim>
-    std::vector<typename ElemType<dim>::type>& GetElements(){
+    std::vector<ElementType<dim>>& getElements(){
         static_assert (Dimension >= dim, "In GetElements template parameter dim must be less or equal to Dimension.");
         return Refs._MeshElements<Dimension, dim, IndexType, Real, Reserve...>::elements;
     }
 
 
     template<unsigned int dim>
-    const std::vector<typename ElemType<dim>::type>&  GetElements() const {
+    const std::vector<ElementType<dim>>&  getElements() const {
         static_assert (Dimension >= dim, "In GetElements template parameter dim must be less or equal to Dimension.");
         return Refs._MeshElements<Dimension, dim, IndexType, Real, Reserve...>::elements;
     }
 
-    std::vector<Vertex>& GetVertices(){
-        return GetElements<0>();
+    std::vector<Vertex>& getVertices(){
+        return getElements<0>();
     }
 
 
-    std::vector<Edge>& GetEdges(){
-        return GetElements<1>();
+    std::vector<Edge>& getEdges(){
+        return getElements<1>();
     }
 
-    std::vector<Face>& GetFaces(){
-        return GetElements<Dimension - 1>();
+    std::vector<Face>& getFaces(){
+        return getElements<Dimension - 1>();
     }
 
-    std::vector<Cell>& GetCells(){
-        return GetElements<Dimension>();
+    std::vector<Cell>& getCells(){
+        return getElements<Dimension>();
     }
 
-    std::vector<Cell>& GetBoundaryCells() {
+    std::vector<Cell>& getBoundaryCells() {
         return BoundaryCells;
     }
 
-    void AppendBoundaryCell(IndexType cellIndex, IndexType faceIndex){
+    void appendBoundaryCell(IndexType cellIndex, IndexType faceIndex){
         Cell c;
-        c.SetIndex(cellIndex);
+        c.setIndex(cellIndex);
         c.SetBoundaryElementIndex(faceIndex);
         BoundaryCells.push_back(c);
     }
 
-    void SetupBoundaryCells(){
-        for (Face& face : GetFaces()){
+    void setupBoundaryCells(){
+        for (Face& face : getFaces()){
             if (face.GetCellLeftIndex == INVALID_INDEX(IndexType)){
                 IndexType cellIndex = BoundaryCells.size() | BOUNDARY_INDEX(IndexType);
                 face.SetCellLeftIndex(cellIndex);
-                AppendBoundaryCell(cellIndex, face.GetIndex());
+                appendBoundaryCell(cellIndex, face.getIndex());
             }
             if (face.GetCellRightIndex == INVALID_INDEX(IndexType)){
                 IndexType cellIndex = BoundaryCells.size() | BOUNDARY_INDEX(IndexType);
                 face.SetCellRightIndex(cellIndex);
-                AppendBoundaryCell(cellIndex, face.GetIndex());
+                appendBoundaryCell(cellIndex, face.getIndex());
             }
         }
         BoundaryCells.shrink_to_fit();
     }
 
 
-    void SetupBoundaryCellsCenters() {
+    void setupBoundaryCellsCenters() {
         for(Cell& cell : BoundaryCells){
-            cell.SetCenter(GetFaces().at(cell.getBoundaryElementIndex()).GetCenter());
+            cell.SetCenter(getFaces().at(cell.getBoundaryElementIndex()).GetCenter());
         }
     }
 
@@ -363,8 +361,8 @@ public:
             actual = firstBElem;
             this->parentMesh = parentMesh;
         }
-        CellSubelementIterator& operator++ () {actual = parentMesh->GetFaces().at(actual).getNextBElem(cellIndex) == firstBElem ? INVALID_INDEX(IndexType) : parentMesh->GetFaces().at(actual).getNextBElem(cellIndex); return *this;}
-        CellSubelementIterator& operator++ (int) {actual = parentMesh->GetFaces().at(actual).getNextBElem(cellIndex) == firstBElem ? INVALID_INDEX(IndexType) : parentMesh->GetFaces().at(actual).getNextBElem(cellIndex); return *this;}
+        CellSubelementIterator& operator++ () {actual = parentMesh->getFaces().at(actual).getNextBElem(cellIndex) == firstBElem ? INVALID_INDEX(IndexType) : parentMesh->getFaces().at(actual).getNextBElem(cellIndex); return *this;}
+        CellSubelementIterator& operator++ (int) {actual = parentMesh->getFaces().at(actual).getNextBElem(cellIndex) == firstBElem ? INVALID_INDEX(IndexType) : parentMesh->getFaces().at(actual).getNextBElem(cellIndex); return *this;}
         IndexType operator* (){return actual;}
         bool operator== (CellSubelementIterator& it) {return actual == it.actual;}
         bool operator!= (CellSubelementIterator& it) {return actual != it.actual;}
@@ -380,7 +378,7 @@ public:
         }
 
         CellSubelementIterator begin() {
-            return CellSubelementIterator(cellIndex, parentMesh->GetCells()[cellIndex].getBoundaryElementIndex(), parentMesh);
+            return CellSubelementIterator(cellIndex, parentMesh->getCells()[cellIndex].getBoundaryElementIndex(), parentMesh);
         }
 
         CellSubelementIterator end() {
@@ -395,7 +393,7 @@ public:
         MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh;
     public:
         MeshElementWrap(MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh, MeshElement<Dimension, ElementDim, IndexType, Real, reserve<ElementDim>()>& meshElement){
-            elementIndex = meshElement.GetIndex();
+            elementIndex = meshElement.getIndex();
             this->parentMesh = parentMesh;
         }
 
@@ -404,12 +402,12 @@ public:
             this->parentMesh = parentMesh;
         }
 
-        IndexType GetIndex(){
+        IndexType getIndex(){
             return elementIndex;
         }
 
         SubelementContainer<IndexType, reserve<ElementDim>()>& getSubelements(){
-            return parentMesh->template GetElements<ElementDim>()[elementIndex].getSubelements();
+            return parentMesh->template getElements<ElementDim>()[elementIndex].getSubelements();
         }
     };
 
@@ -420,7 +418,7 @@ public:
         MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh;
     public:
         MeshElementWrap(MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh, MeshElement<Dimension, Dimension, IndexType, Real, 0>& meshElement){
-            elementIndex = meshElement.GetIndex();
+            elementIndex = meshElement.getIndex();
             this->parentMesh = parentMesh;
         }
 
@@ -429,7 +427,7 @@ public:
             this->parentMesh = parentMesh;
         }
 
-        IndexType GetIndex(){
+        IndexType getIndex(){
             return elementIndex;
         }
 
@@ -447,7 +445,7 @@ public:
         MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh;
     public:
         MeshElementWrap(MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh, MeshElement<Dimension, 1, IndexType, Real, 0>& meshElement){
-            elementIndex = meshElement.GetIndex();
+            elementIndex = meshElement.getIndex();
             this->parentMesh = parentMesh;
         }
 
@@ -456,12 +454,12 @@ public:
             this->parentMesh = parentMesh;
         }
 
-        IndexType GetIndex(){
+        IndexType getIndex(){
             return elementIndex;
         }
 
-        Edge& GetElement() {
-            return parentMesh->GetEdges()[elementIndex];
+        Edge& getElement() {
+            return parentMesh->getEdges()[elementIndex];
         }
 
     };
@@ -472,7 +470,7 @@ public:
         MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh;
     public:
         MeshElementWrap(MeshElements<Dimension, IndexType, Real, Reserve...>* parentMesh, Vertex& meshElement){
-            elementIndex = meshElement.GetIndex();
+            elementIndex = meshElement.getIndex();
             this->parentMesh = parentMesh;
         }
 
@@ -481,17 +479,17 @@ public:
             this->parentMesh = parentMesh;
         }
 
-        IndexType GetIndex(){
+        IndexType getIndex(){
             return elementIndex;
         }
 
-        Vertex& GetElement() {
+        Vertex& getElement() {
             return parentMesh->GetVertices()[elementIndex];
         }
     };
 
     template<unsigned int ElementDim>
-    MeshElementWrap<ElementDim> GetElement(IndexType elementIndex){
+    MeshElementWrap<ElementDim> getElement(IndexType elementIndex){
         return MeshElementWrap<ElementDim>(this, elementIndex);
     }
 
@@ -501,13 +499,5 @@ public:
 
 
 
-
-
-
-
-
-
-
-
 #endif // MESH_ELEMENT_H
 
diff --git a/Unstructured_mesh/mesh_functions.h b/Unstructured_mesh/mesh_functions.h
index 200d42fd8a35903775fe03304204309fa3e0622f..82ccbd68716618ca74bfbc18ba07c4b9c2fae62e 100644
--- a/Unstructured_mesh/mesh_functions.h
+++ b/Unstructured_mesh/mesh_functions.h
@@ -38,8 +38,8 @@ struct _ComputeCenters{
         auto& subElemCenters = centers.template GetDataDim<dim - 1>();
 
 
-        for (IndexType i = 0; i < mesh.template GetElements<dim>().size(); i++) {
-            auto& element = mesh.template GetElements<dim>().at(i);
+        for (IndexType i = 0; i < mesh.template getElements<dim>().size(); i++) {
+            auto& element = mesh.template getElements<dim>().at(i);
 
             Real subElemCnt = 0;
             for(auto& sub : element.getSubelements()){
@@ -64,15 +64,15 @@ struct _ComputeCenters<Dimension, Dimension>{
         auto& subElemCenters = centers.template GetDataDim<Dimension - 1>();
 
 
-        for (IndexType i = 0; i < mesh.template GetElements<Dimension>().size(); i++) {
-            auto& element = mesh.template GetElements<Dimension>().at(i);
+        for (IndexType i = 0; i < mesh.template getElements<Dimension>().size(); i++) {
+            auto& element = mesh.template getElements<Dimension>().at(i);
 
             Real subElemCnt = 0;
             IndexType tmpFaceIndex = element.getBoundaryElementIndex();
             do {
                 elemCenters.at(i) +=  subElemCenters.at(tmpFaceIndex);
                 subElemCnt++;
-                tmpFaceIndex = mesh.GetFaces()[tmpFaceIndex].getNextBElem(i);
+                tmpFaceIndex = mesh.getFaces()[tmpFaceIndex].getNextBElem(i);
             } while (tmpFaceIndex != element.getBoundaryElementIndex());
 
             elemCenters.at(i) /= subElemCnt;
@@ -91,10 +91,10 @@ struct _ComputeCenters<1, Dimension>{
 
         std::vector<Vertex<Dimension, Real>>& edgeCenters = centers.template GetDataDim<1>();
 
-        for (auto& edge : mesh.template GetElements<1>()) {
+        for (auto& edge : mesh.template getElements<1>()) {
 
-            edgeCenters.at(edge.GetIndex()) = (mesh.template GetElements<0>().at(edge.GetVertexAIndex()) +
-                                mesh.template GetElements<0>().at(edge.GetVertexBIndex())) * 0.5;
+            edgeCenters.at(edge.getIndex()) = (mesh.template getElements<0>().at(edge.getVertexAIndex()) +
+                                mesh.template getElements<0>().at(edge.getVertexBIndex())) * 0.5;
         }
 
         DBGMSG("1");
@@ -154,23 +154,23 @@ struct _ComputeMeasures<3, 3>{
 
         auto& cellMeasures = measures.template GetDataDim<3>();
 
-        for (typename MeshElements<3, IndexType, Real, Reserve...>::template ElemType<3>::type& cell : mesh.GetCells()) {
+        for (typename MeshElements<3, IndexType, Real, Reserve...>::template ElementType<3>& cell : mesh.getCells()) {
             IndexType tmpFace = cell.getBoundaryElementIndex();
             Real measure = Real();
             Vertex<3,Real>& cellCenter = cell.getCenter();
 
             do {
                 // select 3 different vertices
-                IndexType vAIndex = mesh.GetEdges().at(mesh.GetFaces().at(tmpFace).getSubelements()[0].index).GetVertexAIndex();
-                IndexType vBIndex = mesh.GetEdges().at(mesh.GetFaces().at(tmpFace).getSubelements()[0].index).GetVertexBIndex();
-                IndexType vCIndex = mesh.GetEdges().at(mesh.GetFaces().at(tmpFace).getSubelements()[1].index).GetVertexAIndex();
+                IndexType vAIndex = mesh.getEdges().at(mesh.getFaces().at(tmpFace).getSubelements()[0].index).getVertexAIndex();
+                IndexType vBIndex = mesh.getEdges().at(mesh.getFaces().at(tmpFace).getSubelements()[0].index).getVertexBIndex();
+                IndexType vCIndex = mesh.getEdges().at(mesh.getFaces().at(tmpFace).getSubelements()[1].index).getVertexAIndex();
                 if(vCIndex == vAIndex || vCIndex == vBIndex) {
-                    vCIndex = mesh.GetEdges().at(mesh.GetFaces().at(tmpFace).getSubelements()[1].index).GetVertexBIndex();
+                    vCIndex = mesh.getEdges().at(mesh.getFaces().at(tmpFace).getSubelements()[1].index).getVertexBIndex();
                 }
 
-                Vertex<3,Real>& a = mesh.GetVertices().at(vAIndex);
-                Vertex<3,Real>& b = mesh.GetVertices().at(vBIndex);
-                Vertex<3,Real>& c = mesh.GetVertices().at(vCIndex);
+                Vertex<3,Real>& a = mesh.getVertices().at(vAIndex);
+                Vertex<3,Real>& b = mesh.getVertices().at(vBIndex);
+                Vertex<3,Real>& c = mesh.getVertices().at(vCIndex);
 
                 // preparing quiantities
                 Vertex<3,Real> vAmcC = (a-cellCenter);
@@ -191,10 +191,10 @@ struct _ComputeMeasures<3, 3>{
                 Real tmp = distance * measures.template GetDataDim<2>().at(tmpFace);
                 measure += tmp / 3.0;
 
-                tmpFace = mesh.GetFaces().at(tmpFace).getNextBElem(cell.GetIndex());
+                tmpFace = mesh.getFaces().at(tmpFace).getNextBElem(cell.getIndex());
             } while (tmpFace != cell.getBoundaryElementIndex());
 
-            cellMeasures.at(cell.GetIndex()) = measure;
+            cellMeasures.at(cell.getIndex()) = measure;
         }
     }
 };
@@ -206,21 +206,21 @@ struct _ComputeMeasures<2, 2>{
 
         auto& surfaceMeasures = measures.template GetDataDim<2>();
 
-        for (typename MeshElements<2, IndexType, Real, Reserve...>::template ElemType<2>::type& cell : mesh.GetCells()) {
+        for (typename MeshElements<2, IndexType, Real, Reserve...>::template ElementType<2>& cell : mesh.getCells()) {
             IndexType tmpEdge = cell.getBoundaryElementIndex();
             Real measure = Real();
             Vertex<2,Real>& cellCenter = cell.getCenter();
             do {
-                Vertex<2,Real>& a = mesh.GetVertices().at(mesh.GetEdges().at(tmpEdge).GetVertexAIndex());
-                Vertex<2,Real>& b = mesh.GetVertices().at(mesh.GetEdges().at(tmpEdge).GetVertexBIndex());
+                Vertex<2,Real>& a = mesh.getVertices().at(mesh.getEdges().at(tmpEdge).getVertexAIndex());
+                Vertex<2,Real>& b = mesh.getVertices().at(mesh.getEdges().at(tmpEdge).getVertexBIndex());
                 double tmp = (cellCenter[0] - a[0]) * (b[1] - a[1]);
                 tmp -= (cellCenter[1] - a[1]) * (b[0] - a[0]);
                 measure += 0.5 * fabs(tmp);
 
-                tmpEdge = mesh.GetEdges().at(tmpEdge).getNextBElem(cell.GetIndex());
+                tmpEdge = mesh.getEdges().at(tmpEdge).getNextBElem(cell.getIndex());
             } while (tmpEdge != cell.getBoundaryElementIndex());
 
-            surfaceMeasures.at(cell.GetIndex()) = measure;
+            surfaceMeasures.at(cell.getIndex()) = measure;
         }
     }
 };
@@ -234,14 +234,14 @@ struct _ComputeMeasures<2, 3>{
 
         auto& surfaceMeasures = measures.template GetDataDim<2>();
 
-        for (typename MeshElements<3, IndexType, Real, Reserve...>::template ElemType<2>::type& face : mesh.template GetElements<2>()) {
+        for (typename MeshElements<3, IndexType, Real, Reserve...>::template ElementType<2>& face : mesh.template getElements<2>()) {
 
             Real measure = Real();
             Vertex<3,Real>& faceCenter = face.getCenter();
             for(auto sube : face.getSubelements()){
 
-                Vertex<3,Real>& a = mesh.GetVertices().at(mesh.GetEdges().at(sube.index).GetVertexAIndex());
-                Vertex<3,Real>& b = mesh.GetVertices().at(mesh.GetEdges().at(sube.index).GetVertexBIndex());
+                Vertex<3,Real>& a = mesh.getVertices().at(mesh.getEdges().at(sube.index).getVertexAIndex());
+                Vertex<3,Real>& b = mesh.getVertices().at(mesh.getEdges().at(sube.index).getVertexBIndex());
 
                 Real distance = Real();
 
@@ -252,7 +252,7 @@ struct _ComputeMeasures<2, 3>{
                 Real tmp = distance * measures.template GetDataDim<1>().at(sube.index);
                 measure += tmp * 0.5;
             }
-            surfaceMeasures.at(face.GetIndex()) = measure;
+            surfaceMeasures.at(face.getIndex()) = measure;
         }
         _ComputeMeasures<3, 3>::compute(measures, mesh);
     }
@@ -271,9 +271,9 @@ struct _ComputeMeasures<1, Dimension>{
 
         auto& edgeLengths = measures.template GetDataDim<1>();
 
-        for (auto& edge : mesh.GetEdges()) {
-            edgeLengths.at(edge.GetIndex()) = (mesh.GetVertices().at(edge.GetVertexAIndex()) -
-                                               mesh.GetVertices().at(edge.GetVertexBIndex())).normEukleid();
+        for (auto& edge : mesh.getEdges()) {
+            edgeLengths.at(edge.getIndex()) = (mesh.getVertices().at(edge.getVertexAIndex()) -
+                                               mesh.getVertices().at(edge.getVertexBIndex())).normEukleid();
         }
 
         _ComputeMeasures<2, Dimension>::compute(measures, mesh);
@@ -311,9 +311,9 @@ template <>
 struct _ComputeNormals<2>{
     template <typename IndexType, typename Real, unsigned int ...Reserve>
     static void compute(MeshDataContainer<Vector<2, Real>, 1>& normals,MeshElements<2, IndexType, Real, Reserve...>& mesh){
-        for (auto& face : mesh.GetEdges()) {
-            Vertex<2,Real> a = mesh.GetVertices().at(face.GetVertexAIndex());
-            Vertex<2,Real> b = mesh.GetVertices().at(face.GetVertexBIndex());
+        for (auto& face : mesh.getEdges()) {
+            Vertex<2,Real> a = mesh.getVertices().at(face.getVertexAIndex());
+            Vertex<2,Real> b = mesh.getVertices().at(face.getVertexBIndex());
             Vertex<2,Real> dif = b-a;
             normals[face][0] = dif[1];
             normals[face][1] = -dif[0];
@@ -327,7 +327,7 @@ template <>
 struct _ComputeNormals<3>{
     template <typename IndexType, typename Real, unsigned int ...Reserve>
     static void compute(MeshDataContainer<Vector<3, Real>, 2>& normals,MeshElements<3, IndexType, Real, Reserve...>& mesh){
-        for (auto& face : mesh.GetFaces()) {
+        for (auto& face : mesh.getFaces()) {
 
             bool vectorSign = true;
             IndexType cellIndex = face.getCellLeftIndex();
@@ -339,20 +339,20 @@ struct _ComputeNormals<3>{
                 cellIndex = face.getCellRightIndex();
             }
 
-            Vertex<3,Real>& cellCenter = mesh.GetCells().at(cellIndex).getCenter();
+            Vertex<3,Real>& cellCenter = mesh.getCells().at(cellIndex).getCenter();
 
 
             // select 3 different vertices
-            IndexType vAIndex = mesh.GetEdges().at(face.getSubelements()[0].index).GetVertexAIndex();
-            IndexType vBIndex = mesh.GetEdges().at(face.getSubelements()[0].index).GetVertexBIndex();
-            IndexType vCIndex = mesh.GetEdges().at(face.getSubelements()[1].index).GetVertexAIndex();
+            IndexType vAIndex = mesh.getEdges().at(face.getSubelements()[0].index).getVertexAIndex();
+            IndexType vBIndex = mesh.getEdges().at(face.getSubelements()[0].index).getVertexBIndex();
+            IndexType vCIndex = mesh.getEdges().at(face.getSubelements()[1].index).getVertexAIndex();
             if(vCIndex == vAIndex || vCIndex == vBIndex) {
-                vCIndex = mesh.GetEdges().at(face.getSubelements()[1].index).GetVertexBIndex();
+                vCIndex = mesh.getEdges().at(face.getSubelements()[1].index).getVertexBIndex();
             }
 
-            Vertex<3,Real>& a = mesh.GetVertices().at(vAIndex);
-            Vertex<3,Real>& b = mesh.GetVertices().at(vBIndex);
-            Vertex<3,Real>& c = mesh.GetVertices().at(vCIndex);
+            Vertex<3,Real>& a = mesh.getVertices().at(vAIndex);
+            Vertex<3,Real>& b = mesh.getVertices().at(vBIndex);
+            Vertex<3,Real>& c = mesh.getVertices().at(vCIndex);
 
             // preparing quiantities
             Vertex<3,Real> vAmcC = (a-cellCenter);
@@ -402,37 +402,37 @@ MeshDataContainer<Real, Dimension-1> ComputeCellsDistance(MeshElements<Dimension
 
     MeshDataContainer<Real, Dimension-1> distances(mesh);
 
-    if(mesh.GetBoundaryCells().empty()){
-        for(auto& face : mesh.GetFaces()) {
+    if(mesh.getBoundaryCells().empty()){
+        for(auto& face : mesh.getFaces()) {
             if (face.getCellLeftIndex() != INVALID_INDEX(IndexType) &&
                 face.getCellRightIndex() != INVALID_INDEX(IndexType)){
 
-                distances.at(face) = (mesh.GetCells().at(face.getCellLeftIndex()).getCenter() -
-                                      mesh.GetCells().at(face.getCellRightIndex()).getCenter()).normEukleid();
+                distances.at(face) = (mesh.getCells().at(face.getCellLeftIndex()).getCenter() -
+                                      mesh.getCells().at(face.getCellRightIndex()).getCenter()).normEukleid();
 
             } else if(face.getCellLeftIndex() != INVALID_INDEX(IndexType) &&
                       face.getCellRightIndex() == INVALID_INDEX(IndexType)){
 
-                distances.at(face) = (mesh.GetCells().at(face.getCellLeftIndex()).getCenter() -
+                distances.at(face) = (mesh.getCells().at(face.getCellLeftIndex()).getCenter() -
                                       face.getCenter()).normEukleid();
 
             } else if(face.getCellLeftIndex() == INVALID_INDEX(IndexType) &&
                       face.getCellRightIndex() != INVALID_INDEX(IndexType)){
 
-                distances.at(face) = (mesh.GetCells().at(face.getCellRightIndex()).getCenter() -
+                distances.at(face) = (mesh.getCells().at(face.getCellRightIndex()).getCenter() -
                                       face.getCenter()).normEukleid();
             }
         }
 
     } else {
 
-        for(auto& face : mesh.GetFaces()) {
+        for(auto& face : mesh.getFaces()) {
             auto& cellLeft = (face.getCellLeftIndex() & BOUNDARY_INDEX(IndexType)) == BOUNDARY_INDEX(IndexType)?
-                      mesh.GetBoundaryCells().at(face.getCellLeftIndex()&EXTRACTING_INDEX(IndexType)):
-                      mesh.GetCells().at(face.getCellLeftIndex());
+                      mesh.getBoundaryCells().at(face.getCellLeftIndex()&EXTRACTING_INDEX(IndexType)):
+                      mesh.getCells().at(face.getCellLeftIndex());
             auto& cellRight = (face.getCellRightIndex() & BOUNDARY_INDEX(IndexType)) == BOUNDARY_INDEX(IndexType)?
-                      mesh.GetBoundaryCells().at(face.getCellRightIndex()&EXTRACTING_INDEX(IndexType)):
-                      mesh.GetCells().at(face.getCellRightIndex());
+                      mesh.getBoundaryCells().at(face.getCellRightIndex()&EXTRACTING_INDEX(IndexType)):
+                      mesh.getCells().at(face.getCellRightIndex());
 
             distances.at(face) = (cellLeft.getCenter() - cellRight.getCenter()).normEukleid();
         }
@@ -459,8 +459,8 @@ struct MeshRun {
                     Func fun){
 
 
-        auto i = mesh.template GetElements<CurrentDimension>().at(index);
-        for (auto sube: mesh.template GetElement<CurrentDimension>(i.GetIndex()).getSubelements())
+        auto i = mesh.template getElements<CurrentDimension>().at(index);
+        for (auto sube: mesh.template getElement<CurrentDimension>(i.getIndex()).getSubelements())
         MeshRun< CurrentDimension - 1, StartDimension, TargetDimension, MeshDimension, TargetDimension == CurrentDimension - 1, Ascend>::run(mesh, origElementIndex, sube.index, fun);
 
 
@@ -476,11 +476,11 @@ struct MeshRun<MeshDimension, StartDimension, TargetDimension, MeshDimension, fa
                     IndexType index,
                     Func fun){
 
-        auto& cell = mesh.GetCells().at(index);
+        auto& cell = mesh.getCells().at(index);
         IndexType tmpFace = cell.getBoundaryElementIndex();
         do {
             MeshRun<MeshDimension - 1, StartDimension, TargetDimension, MeshDimension, TargetDimension == MeshDimension - 1, Ascend>::run(mesh, origElementIndex, tmpFace, fun);
-            tmpFace = mesh.GetFaces().at(tmpFace).getNextBElem(cell.GetIndex());
+            tmpFace = mesh.getFaces().at(tmpFace).getNextBElem(cell.getIndex());
         } while (tmpFace != cell.getBoundaryElementIndex());
 
     }
@@ -496,9 +496,9 @@ struct MeshRun<1, StartDimension, TargetDimension, MeshDimension, false, Ascend>
                     IndexType index,
                     Func fun){
 
-        auto& edge = mesh.GetEdges().at(index);
-        MeshRun<0, StartDimension, TargetDimension, MeshDimension, TargetDimension == 0, Ascend>::run(mesh, origElementIndex, edge.GetVertexAIndex(), fun);
-        MeshRun<0, StartDimension, TargetDimension, MeshDimension, TargetDimension == 0, Ascend>::run(mesh, origElementIndex, edge.GetVertexBIndex(), fun);
+        auto& edge = mesh.getEdges().at(index);
+        MeshRun<0, StartDimension, TargetDimension, MeshDimension, TargetDimension == 0, Ascend>::run(mesh, origElementIndex, edge.getVertexAIndex(), fun);
+        MeshRun<0, StartDimension, TargetDimension, MeshDimension, TargetDimension == 0, Ascend>::run(mesh, origElementIndex, edge.getVertexBIndex(), fun);
     }
 };
 
@@ -529,14 +529,14 @@ struct MeshApply {
     template<typename Functor, typename IndexType, typename Real, unsigned int ...Reserve>
     static void apply(MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh,
                       Functor f) {
-        for (auto& startElement : mesh.template GetElements<(StartDimension > TargetDimension) ? StartDimension : TargetDimension>()){
+        for (auto& startElement : mesh.template getElements<(StartDimension > TargetDimension) ? StartDimension : TargetDimension>()){
             MeshRun<
                     (StartDimension > TargetDimension) ? StartDimension : TargetDimension,
                     (StartDimension > TargetDimension) ? StartDimension : TargetDimension,
                     (StartDimension > TargetDimension) ? TargetDimension : StartDimension,
                     MeshDimension,
                     false,
-                    (StartDimension > TargetDimension)>::run(mesh, startElement.GetIndex(), startElement.GetIndex(), f);
+                    (StartDimension > TargetDimension)>::run(mesh, startElement.getIndex(), startElement.getIndex(), f);
         }
     }
 };
@@ -572,12 +572,12 @@ struct MeshColouring {
 
 
 
-        for (auto& startElement : mesh.template GetElements<FromDim>()){
+        for (auto& startElement : mesh.template getElements<FromDim>()){
             std::valarray<bool> possibleColours(true,reserve);
             MeshRun<FromDim, FromDim, ToDim, MeshDimension, false, true>::
                 run(mesh,
-                    startElement.GetIndex(),
-                    startElement.GetIndex(),
+                    startElement.getIndex(),
+                    startElement.getIndex(),
                     [&possibleColours, &attachedColours](unsigned int, unsigned int, IndexType, IndexType element){
                         DBGTRY(possibleColours &= !attachedColours.template GetDataPos<0>().at(element);)
                     }
@@ -588,11 +588,11 @@ struct MeshColouring {
             while (!possibleColours[selectedColour]) {
                 selectedColour++;
             }
-            result.template GetDataPos<0>().at(startElement.GetIndex()) = selectedColour;
+            result.template GetDataPos<0>().at(startElement.getIndex()) = selectedColour;
             MeshRun<FromDim, FromDim, ToDim, MeshDimension, false, true>::
                 run(mesh,
-                    startElement.GetIndex(),
-                    startElement.GetIndex(),
+                    startElement.getIndex(),
+                    startElement.getIndex(),
                     [selectedColour, &attachedColours](unsigned int, unsigned int, IndexType, IndexType element){
                         DBGTRY(attachedColours.template GetDataPos<0>().at(element)[selectedColour] = true;)
                     }
@@ -617,7 +617,7 @@ struct MeshColouring <FromDim, ToDim, false> {
 
         auto connections = MeshConnections<FromDim, ToDim>::connections(mesh);
 
-        for (auto& startElement : mesh.template GetElements<FromDim>()){
+        for (auto& startElement : mesh.template getElements<FromDim>()){
             std::valarray<bool> possibleColours(true,reserve);
             for (IndexType element : connections.at(startElement)){
 
@@ -630,7 +630,7 @@ struct MeshColouring <FromDim, ToDim, false> {
                 selectedColour++;
             }
 
-            result.template GetDataPos<0>().at(startElement.GetIndex()) = selectedColour;
+            result.template GetDataPos<0>().at(startElement.getIndex()) = selectedColour;
 
             for (IndexType element : connections.at(startElement)){
                 DBGTRY(attachedColours.template GetDataPos<0>().at(element)[selectedColour] = true;)
diff --git a/Unstructured_mesh/meshdatacontainer.h b/Unstructured_mesh/meshdatacontainer.h
index 5721b96d2fcd7602cdba63b9e630ae0f15305aa9..1ec4da19ad5b0271f3174969114ed446026ac243 100644
--- a/Unstructured_mesh/meshdatacontainer.h
+++ b/Unstructured_mesh/meshdatacontainer.h
@@ -45,7 +45,7 @@ private:
         template<unsigned int Dimension, typename IndexType, typename Real, unsigned int ...Reserve>
         static void AlocateMemory(MeshDataContainer<DataType, Dimensions...>& parent ,MeshElements<Dimension, IndexType, Real, Reserve...>& mesh) {
             parent.template GetDataPos<pos>().resize(
-                        mesh.template GetElements<std::get<pos>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size());
+                        mesh.template getElements<std::get<pos>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size());
             Alocator<pos - 1>::AlocateMemory(parent, mesh);
         }
 
@@ -54,7 +54,7 @@ private:
                                   MeshElements<Dimension, IndexType, Real, Reserve...>& mesh,
                                   const DataType& initialValue) {
             parent.template GetDataPos<pos>().resize(
-                        mesh.template GetElements<std::get<pos>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size(),
+                        mesh.template getElements<std::get<pos>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size(),
                         initialValue);
             Alocator<pos - 1>::AlocateMemory(parent, mesh, initialValue);
         }
@@ -66,7 +66,7 @@ private:
         static void AlocateMemory(MeshDataContainer<DataType, Dimensions...>& parent ,MeshElements<Dimension, IndexType, Real, Reserve...>& mesh) {
 
             parent.template GetDataPos<0>().resize(
-                        mesh.template GetElements<std::get<0>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size());
+                        mesh.template getElements<std::get<0>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size());
 
         }
         template<unsigned int Dimension, typename IndexType, typename Real, unsigned int ...Reserve>
@@ -75,7 +75,7 @@ private:
                                   const DataType& initialValue) {
 
             parent.template GetDataPos<0>().resize(
-                        mesh.template GetElements<std::get<0>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size(),
+                        mesh.template getElements<std::get<0>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size(),
                         initialValue);
 
         }
@@ -115,12 +115,12 @@ public:
 
     template <unsigned int ElementDim, unsigned int Dimension, typename IndexType, typename Real, unsigned int Reserve>
     DataType& at(MeshElement<Dimension, ElementDim, IndexType, Real, Reserve>& element) {
-        return GetDataDim<ElementDim>().at(element.GetIndex());
+        return GetDataDim<ElementDim>().at(element.getIndex());
     }
 
     template <unsigned int ElementDim, unsigned int Dimension, typename IndexType, typename Real, unsigned int Reserve>
     DataType& operator[](MeshElement<Dimension, ElementDim, IndexType, Real, Reserve>& element) {
-        return GetDataDim<ElementDim>()[element.GetIndex()];
+        return GetDataDim<ElementDim>()[element.getIndex()];
     }
 
 
@@ -212,7 +212,7 @@ public:
         template<unsigned int Dimension, typename IndexType, typename Real, unsigned int ...Reserve>
         static void AlocateMemory(MeshDataContainer<std::tuple<DataTypes...>, Dimensions...>& parent ,MeshElements<Dimension, IndexType, Real, Reserve...>& mesh) {
             parent.template GetDataPos<pos>().resize(
-                        mesh.template GetElements<std::get<pos>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size());
+                        mesh.template getElements<std::get<pos>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size());
             Alocator<pos + 1, _DataTypes...>::AlocateMemory(parent, mesh);
         }
 
@@ -222,7 +222,7 @@ public:
                                   const _DataType& initialValue,
                                   const _DataTypes&... values) {
             parent.template GetDataPos<pos>().resize(
-                        mesh.template GetElements<std::get<pos>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size(),
+                        mesh.template getElements<std::get<pos>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size(),
                         initialValue);
             Alocator<pos + 1, _DataTypes...>::AlocateMemory(parent, mesh, values...);
         }
@@ -234,7 +234,7 @@ public:
         static void AlocateMemory(MeshDataContainer<std::tuple<DataTypes...>, Dimensions...>& parent ,MeshElements<Dimension, IndexType, Real, Reserve...>& mesh) {
 
             parent.template GetDataPos<sizeof... (Dimensions) - 1>().resize(
-                        mesh.template GetElements<std::get<sizeof... (Dimensions) - 1>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size());
+                        mesh.template getElements<std::get<sizeof... (Dimensions) - 1>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size());
 
         }
         template<unsigned int Dimension, typename IndexType, typename Real, unsigned int ...Reserve>
@@ -244,7 +244,7 @@ public:
                                   const _DataTypes&...) {
 
             parent.template GetDataPos<sizeof... (Dimensions) - 1>().resize(
-                        mesh.template GetElements<std::get<sizeof... (Dimensions) - 1>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size(),
+                        mesh.template getElements<std::get<sizeof... (Dimensions) - 1>(std::array<unsigned int, sizeof... (Dimensions)>{Dimensions...})>().size(),
                         initialValue);
 
         }
@@ -284,12 +284,12 @@ public:
 
     template <unsigned int ElementDim, unsigned int Dimension, typename IndexType, typename Real, unsigned int Reserve>
     std::tuple_element_t<DimIndex<ElementDim>(), std::tuple<DataTypes...>>& at(MeshElement<Dimension, ElementDim, IndexType, Real, Reserve>& element) {
-        return GetDataDim<ElementDim>().at(element.GetIndex());
+        return GetDataDim<ElementDim>().at(element.getIndex());
     }
 
     template <unsigned int ElementDim, unsigned int Dimension, typename IndexType, typename Real, unsigned int Reserve>
     std::tuple_element_t<DimIndex<ElementDim>(), std::tuple<DataTypes...>>& operator[](MeshElement<Dimension, ElementDim, IndexType, Real, Reserve>& element) {
-        return GetDataDim<ElementDim>()[element.GetIndex()];
+        return GetDataDim<ElementDim>()[element.getIndex()];
     }
 
 
diff --git a/Unstructured_mesh/unstructuredmesh.h b/Unstructured_mesh/unstructuredmesh.h
index a944da49478cc6cb0be45f80f80066374686d896..859e57a27ffe285fedbbd7f9df864f0e88621fc0 100644
--- a/Unstructured_mesh/unstructuredmesh.h
+++ b/Unstructured_mesh/unstructuredmesh.h
@@ -13,10 +13,10 @@ public:
     void InitializeCenters(){
         auto centers = ComputeCenters(*this);
 
-        for (auto& face : this->GetFaces()){
+        for (auto& face : this->getFaces()){
             face.setCenter(centers[face]);
         }
-        for (auto& cell : this->GetCells()){
+        for (auto& cell : this->getCells()){
             cell.setCenter(centers[cell]);
         }
     }
@@ -32,14 +32,14 @@ public:
 /*
     Real CalculateFaceMeasureOverCellDist(IndexType edgeIndex, MeshDataContainer){
 
-        const auto& edge = this->GetEdges().at(edgeIndex);
+        const auto& edge = this->getEdges().at(edgeIndex);
         return CalculateEdgeMeasure(edgeIndex) / CalculateCellDist(edge.GetCellLeftIndex(), edge.GetCellRightIndex());
 
     }
   */
 public:
     Real ComputeCellDist(IndexType cellIndex1, IndexType cellIndex2){
-        return (this->GetCells().at(cellIndex1).GetCenter() - this->GetCells().at(cellIndex2).GetCenter()).NormEukleid();
+        return (this->getCells().at(cellIndex1).GetCenter() - this->getCells().at(cellIndex2).GetCenter()).NormEukleid();
     }
 };