[MeL] Rename _nodes args in element_nodes

MeshLib/Elements/CellRule.h

@@ -36,7 +36,7 @@ public:
 protected:
     /// Returns the ID of a face given an array of nodes.
     template <typename ElementRule>
-    static unsigned identifyFace(Node const* const* _nodes,
+    static unsigned identifyFace(Node const* const* element_nodes,
                                  Node const* nodes[ElementRule::dimension])
     {
         for (unsigned i = 0; i < ElementRule::n_faces; i++)
@@ -49,7 +49,8 @@ protected:
                 for (unsigned k = 0; k < ElementRule::dimension; k++)
                 {
                     if (ElementRule::face_nodes[i][j] != 99 &&
-                        _nodes[ElementRule::face_nodes[i][j]] == nodes[k])
+                        element_nodes[ElementRule::face_nodes[i][j]] ==
+                            nodes[k])
                     {
                         flag++;
                     }

MeshLib/Elements/FaceRule.h

@@ -45,7 +45,7 @@ public:
 protected:
     /// Returns the ID of an edge given an array of nodes.
     template <typename ElementRule>
-    static unsigned identifyFace(Node const* const* _nodes,
+    static unsigned identifyFace(Node const* const* element_nodes,
                                  Node const* nodes[ElementRule::dimension])
     {
         for (unsigned i = 0; i < ElementRule::n_edges; i++)
@@ -57,7 +57,8 @@ protected:
             {
                 for (unsigned k = 0; k < ElementRule::dimension; k++)
                 {
-                    if (_nodes[ElementRule::edge_nodes[i][j]] == nodes[k])
+                    if (element_nodes[ElementRule::edge_nodes[i][j]] ==
+                        nodes[k])
                     {
                         flag++;
                     }

MeshLib/Elements/HexRule.cpp

@@ -15,20 +15,32 @@
 
 namespace MeshLib
 {
-double HexRule::computeVolume(Node const* const* _nodes)
+double HexRule::computeVolume(Node const* const* element_nodes)
 {
-    return MathLib::calcTetrahedronVolume(
-               *_nodes[4], *_nodes[7], *_nodes[5], *_nodes[0]) +
-           MathLib::calcTetrahedronVolume(
-               *_nodes[5], *_nodes[3], *_nodes[1], *_nodes[0]) +
-           MathLib::calcTetrahedronVolume(
-               *_nodes[5], *_nodes[7], *_nodes[3], *_nodes[0]) +
-           MathLib::calcTetrahedronVolume(
-               *_nodes[5], *_nodes[7], *_nodes[6], *_nodes[2]) +
-           MathLib::calcTetrahedronVolume(
-               *_nodes[1], *_nodes[3], *_nodes[5], *_nodes[2]) +
-           MathLib::calcTetrahedronVolume(
-               *_nodes[3], *_nodes[7], *_nodes[5], *_nodes[2]);
+    return MathLib::calcTetrahedronVolume(*element_nodes[4],
+                                          *element_nodes[7],
+                                          *element_nodes[5],
+                                          *element_nodes[0]) +
+           MathLib::calcTetrahedronVolume(*element_nodes[5],
+                                          *element_nodes[3],
+                                          *element_nodes[1],
+                                          *element_nodes[0]) +
+           MathLib::calcTetrahedronVolume(*element_nodes[5],
+                                          *element_nodes[7],
+                                          *element_nodes[3],
+                                          *element_nodes[0]) +
+           MathLib::calcTetrahedronVolume(*element_nodes[5],
+                                          *element_nodes[7],
+                                          *element_nodes[6],
+                                          *element_nodes[2]) +
+           MathLib::calcTetrahedronVolume(*element_nodes[1],
+                                          *element_nodes[3],
+                                          *element_nodes[5],
+                                          *element_nodes[2]) +
+           MathLib::calcTetrahedronVolume(*element_nodes[3],
+                                          *element_nodes[7],
+                                          *element_nodes[5],
+                                          *element_nodes[2]);
 }
 
 bool HexRule::isPntInElement(Node const* const* nodes,

MeshLib/Elements/HexRule.h

@@ -48,6 +48,6 @@ public:
 
     /// Calculates the volume of a convex hexahedron by partitioning it into six
     /// tetrahedra.
-    static double computeVolume(Node const* const* _nodes);
+    static double computeVolume(Node const* const* element_nodes);
 };
 }  // namespace MeshLib

MeshLib/Elements/HexRule20.h

@@ -63,10 +63,10 @@ public:
     static const Element* getFace(const Element* e, unsigned i);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const* _nodes,
+    static unsigned identifyFace(Node const* const* element_nodes,
                                  Node const* nodes[3])
     {
-        return CellRule::identifyFace<HexRule20>(_nodes, nodes);
+        return CellRule::identifyFace<HexRule20>(element_nodes, nodes);
     }
 }; /* class */
 

MeshLib/Elements/HexRule8.h

@@ -62,10 +62,10 @@ public:
     static const Element* getFace(const Element* e, unsigned i);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const* _nodes,
+    static unsigned identifyFace(Node const* const* element_nodes,
                                  Node const* nodes[3])
     {
-        return CellRule::identifyFace<HexRule8>(_nodes, nodes);
+        return CellRule::identifyFace<HexRule8>(element_nodes, nodes);
     }
 }; /* class */
 

MeshLib/Elements/LineRule.cpp

@@ -14,9 +14,9 @@
 
 namespace MeshLib
 {
-double LineRule::computeVolume(Node const* const* _nodes)
+double LineRule::computeVolume(Node const* const* element_nodes)
 {
-    return std::sqrt(MathLib::sqrDist(*_nodes[0], *_nodes[1]));
+    return std::sqrt(MathLib::sqrDist(*element_nodes[0], *element_nodes[1]));
 }
 
 bool LineRule::isPntInElement(Node const* const* nodes,
@@ -52,13 +52,14 @@ bool LineRule::isPntInElement(Node const* const* nodes,
     }
 }
 
-unsigned LineRule::identifyFace(Node const* const* _nodes, Node const* nodes[1])
+unsigned LineRule::identifyFace(Node const* const* element_nodes,
+                                Node const* nodes[1])
 {
-    if (nodes[0] == _nodes[0])
+    if (nodes[0] == element_nodes[0])
     {
         return 0;
     }
-    if (nodes[0] == _nodes[1])
+    if (nodes[0] == element_nodes[1])
     {
         return 1;
     }

MeshLib/Elements/LineRule.h

@@ -44,10 +44,10 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const* /*_nodes*/,
+    static unsigned identifyFace(Node const* const* /*element_nodes*/,
                                  Node const* nodes[1]);
 
     /// Calculates the length of a line.
-    static double computeVolume(Node const* const* _nodes);
+    static double computeVolume(Node const* const* element_nodes);
 };
 }  // namespace MeshLib

MeshLib/Elements/PointRule1.cpp

@@ -17,7 +17,7 @@ namespace MeshLib
 {
 const unsigned PointRule1::edge_nodes[1][1] = {{0}};
 
-double PointRule1::computeVolume(Node const* const* /*_nodes*/)
+double PointRule1::computeVolume(Node const* const* /*element_nodes*/)
 {
     return 0;
 }
@@ -29,10 +29,10 @@ bool PointRule1::isPntInElement(Node const* const* nodes,
     return (dist < eps);
 }
 
-unsigned PointRule1::identifyFace(Node const* const* _nodes,
+unsigned PointRule1::identifyFace(Node const* const* element_nodes,
                                   Node const* nodes[1])
 {
-    if (nodes[0] == _nodes[0])
+    if (nodes[0] == element_nodes[0])
     {
         return 0;
     }

MeshLib/Elements/PointRule1.h

@@ -56,10 +56,10 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const* /*_nodes*/,
+    static unsigned identifyFace(Node const* const* /*element_nodes*/,
                                  Node const* nodes[1]);
 
     /// Calculates the length of a line
-    static double computeVolume(Node const* const* _nodes);
+    static double computeVolume(Node const* const* element_nodes);
 };
 }  // namespace MeshLib

MeshLib/Elements/PrismRule.cpp

@@ -15,14 +15,20 @@
 
 namespace MeshLib
 {
-double PrismRule::computeVolume(Node const* const* _nodes)
+double PrismRule::computeVolume(Node const* const* element_nodes)
 {
-    return MathLib::calcTetrahedronVolume(
-               *_nodes[0], *_nodes[1], *_nodes[2], *_nodes[3]) +
-           MathLib::calcTetrahedronVolume(
-               *_nodes[1], *_nodes[4], *_nodes[2], *_nodes[3]) +
-           MathLib::calcTetrahedronVolume(
-               *_nodes[2], *_nodes[4], *_nodes[5], *_nodes[3]);
+    return MathLib::calcTetrahedronVolume(*element_nodes[0],
+                                          *element_nodes[1],
+                                          *element_nodes[2],
+                                          *element_nodes[3]) +
+           MathLib::calcTetrahedronVolume(*element_nodes[1],
+                                          *element_nodes[4],
+                                          *element_nodes[2],
+                                          *element_nodes[3]) +
+           MathLib::calcTetrahedronVolume(*element_nodes[2],
+                                          *element_nodes[4],
+                                          *element_nodes[5],
+                                          *element_nodes[3]);
 }
 
 bool PrismRule::isPntInElement(Node const* const* nodes,

MeshLib/Elements/PrismRule.h

@@ -48,6 +48,6 @@ public:
 
     /// Calculates the volume of a prism with flat faces by partitioning it into
     /// three tetrahedra.
-    static double computeVolume(Node const* const* _nodes);
+    static double computeVolume(Node const* const* element_nodes);
 };
 }  // namespace MeshLib

MeshLib/Elements/PrismRule15.h

@@ -66,10 +66,10 @@ public:
     static const Element* getFace(const Element* e, unsigned i);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const* _nodes,
+    static unsigned identifyFace(Node const* const* element_nodes,
                                  Node const* nodes[3])
     {
-        return CellRule::identifyFace<PrismRule15>(_nodes, nodes);
+        return CellRule::identifyFace<PrismRule15>(element_nodes, nodes);
     }
 }; /* class */
 

MeshLib/Elements/PrismRule6.h

@@ -66,10 +66,10 @@ public:
     static const Element* getFace(const Element* e, unsigned i);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const* _nodes,
+    static unsigned identifyFace(Node const* const* element_nodes,
                                  Node const* nodes[3])
     {
-        return CellRule::identifyFace<PrismRule6>(_nodes, nodes);
+        return CellRule::identifyFace<PrismRule6>(element_nodes, nodes);
     }
 }; /* class */
 

MeshLib/Elements/PyramidRule.cpp

@@ -15,12 +15,16 @@
 
 namespace MeshLib
 {
-double PyramidRule::computeVolume(Node const* const* _nodes)
+double PyramidRule::computeVolume(Node const* const* element_nodes)
 {
-    return MathLib::calcTetrahedronVolume(
-               *_nodes[0], *_nodes[1], *_nodes[2], *_nodes[4]) +
-           MathLib::calcTetrahedronVolume(
-               *_nodes[2], *_nodes[3], *_nodes[0], *_nodes[4]);
+    return MathLib::calcTetrahedronVolume(*element_nodes[0],
+                                          *element_nodes[1],
+                                          *element_nodes[2],
+                                          *element_nodes[4]) +
+           MathLib::calcTetrahedronVolume(*element_nodes[2],
+                                          *element_nodes[3],
+                                          *element_nodes[0],
+                                          *element_nodes[4]);
 }
 
 bool PyramidRule::isPntInElement(Node const* const* nodes,

MeshLib/Elements/PyramidRule.h

@@ -49,6 +49,6 @@ public:
 
     /// Calculates the volume of a flat-sided pyramid by partitioning it into
     /// two tetrahedra.
-    static double computeVolume(Node const* const* _nodes);
+    static double computeVolume(Node const* const* element_nodes);
 };
 }  // namespace MeshLib

MeshLib/Elements/PyramidRule13.h

@@ -65,10 +65,10 @@ public:
     static const Element* getFace(const Element* e, unsigned i);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const* _nodes,
+    static unsigned identifyFace(Node const* const* element_nodes,
                                  Node const* nodes[3])
     {
-        return CellRule::identifyFace<PyramidRule13>(_nodes, nodes);
+        return CellRule::identifyFace<PyramidRule13>(element_nodes, nodes);
     }
 }; /* class */
 

MeshLib/Elements/PyramidRule5.h

@@ -65,10 +65,10 @@ public:
     static const Element* getFace(const Element* e, unsigned i);
 
     /// Returns the ID of a face given an array of nodes.
-    static unsigned identifyFace(Node const* const* _nodes,
+    static unsigned identifyFace(Node const* const* element_nodes,
                                  Node const* nodes[3])
     {
-        return CellRule::identifyFace<PyramidRule5>(_nodes, nodes);
+        return CellRule::identifyFace<PyramidRule5>(element_nodes, nodes);
     }
 }; /* class */
 

MeshLib/Elements/QuadRule.cpp

@@ -14,10 +14,12 @@
 
 namespace MeshLib
 {
-double QuadRule::computeVolume(Node const* const* _nodes)
+double QuadRule::computeVolume(Node const* const* element_nodes)
 {
-    return MathLib::calcTriangleArea(*_nodes[0], *_nodes[1], *_nodes[2]) +
-           MathLib::calcTriangleArea(*_nodes[2], *_nodes[3], *_nodes[0]);
+    return MathLib::calcTriangleArea(
+               *element_nodes[0], *element_nodes[1], *element_nodes[2]) +
+           MathLib::calcTriangleArea(
+               *element_nodes[2], *element_nodes[3], *element_nodes[0]);
 }
 
 bool QuadRule::isPntInElement(Node const* const* nodes,
@@ -33,18 +35,25 @@ ElementErrorCode QuadRule::validate(const Element* e)
 {
     ElementErrorCode error_code;
     error_code[ElementErrorFlag::ZeroVolume] = hasZeroVolume(*e);
-    Node const* const* _nodes = e->getNodes();
+    Node const* const* element_nodes = e->getNodes();
     error_code[ElementErrorFlag::NonCoplanar] =
-        (!MathLib::isCoplanar(*_nodes[0], *_nodes[1], *_nodes[2], *_nodes[3]));
+        (!MathLib::isCoplanar(*element_nodes[0],
+                              *element_nodes[1],
+                              *element_nodes[2],
+                              *element_nodes[3]));
     // for collapsed quads (i.e. reduced to a line) this test might result
     // "false" as all four points are actually located on a line.
     if (!error_code[ElementErrorFlag::ZeroVolume])
     {
         error_code[ElementErrorFlag::NonConvex] =
-            (!(MathLib::dividedByPlane(
-                   *_nodes[0], *_nodes[2], *_nodes[1], *_nodes[3]) &&
-               MathLib::dividedByPlane(
-                   *_nodes[1], *_nodes[3], *_nodes[0], *_nodes[2])));
+            (!(MathLib::dividedByPlane(*element_nodes[0],
+                                       *element_nodes[2],
+                                       *element_nodes[1],
+                                       *element_nodes[3]) &&
+               MathLib::dividedByPlane(*element_nodes[1],
+                                       *element_nodes[3],
+                                       *element_nodes[0],
+                                       *element_nodes[2])));
     }
     error_code[ElementErrorFlag::NodeOrder] = !e->testElementNodeOrder();
     return error_code;

MeshLib/Elements/QuadRule.h

@@ -48,6 +48,6 @@ public:
     static ElementErrorCode validate(const Element* e);
 
     /// Calculates the area of a quad with straight edges.
-    static double computeVolume(Node const* const* _nodes);
+    static double computeVolume(Node const* const* element_nodes);
 };
 }  // namespace MeshLib