Merge pull request #13589 from KratosMultiphysics/core/minor-clean

[Core] Minor clean up and modernization of `ExactMortarIntegrationUtility`

Author: loumalouomega

applications/ContactStructuralMechanicsApplication/custom_conditions/mesh_tying_mortar_condition.h

@@ -97,6 +97,9 @@ class KRATOS_API(CONTACT_STRUCTURAL_MECHANICS_APPLICATION) MeshTyingMortarCondit
     /// Definition of a point
     using PointType = Point;
 
+    /// Geometry point type definition
+    using GeometryPointType = Geometry<PointType>;
+
     /// Definition of the geometry type
     using GeometryType = Geometry<Node>;
 

applications/ContactStructuralMechanicsApplication/custom_utilities/mortar_explicit_contribution_utilities.h

@@ -76,6 +76,9 @@ class KRATOS_API(CONTACT_STRUCTURAL_MECHANICS_APPLICATION) MortarExplicitContrib
     /// Point definition
     using PointType = Point;
 
+    /// Geometry point type definition
+    using GeometryPointType = Geometry<PointType>;
+
     /// Geometry type definition
     using GeometryType = Geometry<Node>;
 
@@ -204,7 +207,7 @@ class KRATOS_API(CONTACT_STRUCTURAL_MECHANICS_APPLICATION) MortarExplicitContrib
         GeneralVariables& rVariables,
         const ConditionArrayListType& rConditionsPointsSlave,
         BoundedMatrix<double, TNumNodes, TNumNodes>& rAe,
-        const IntegrationMethod& rIntegrationMethod,
+        const GeometryData::IntegrationMethod& rIntegrationMethod,
         const double AxiSymCoeff = 1.0
         );
 

kratos/processes/simple_mortar_mapper_process.cpp

@@ -595,11 +595,10 @@ void SimpleMortarMapperProcess<TDim, TNumNodes, TVarType, TNumNodesMaster>::Crea
 /***********************************************************************************/
 
 template<SizeType TDim, SizeType TNumNodes, class TVarType, const SizeType TNumNodesMaster>
-IntegrationMethod SimpleMortarMapperProcess<TDim, TNumNodes, TVarType, TNumNodesMaster>::GetIntegrationMethod()
+GeometryData::IntegrationMethod SimpleMortarMapperProcess<TDim, TNumNodes, TVarType, TNumNodesMaster>::GetIntegrationMethod()
 {
     const int integration_order = mThisParameters["integration_order"].GetInt();
-    switch ( integration_order )
-    {
+    switch ( integration_order ) {
         case 1: return GeometryData::IntegrationMethod::GI_GAUSS_1;
         case 2: return GeometryData::IntegrationMethod::GI_GAUSS_2;
         case 3: return GeometryData::IntegrationMethod::GI_GAUSS_3;
@@ -860,7 +859,7 @@ void SimpleMortarMapperProcess<TDim, TNumNodes, TVarType, TNumNodesMaster>::Exec
             residual_norm[i_size] = 0.0;
         }
 
-        block_for_each(mDestinationModelPart.Nodes(), [&](NodeType& rNode) {
+        block_for_each(mDestinationModelPart.Nodes(), [&](Node& rNode) {
             if(mOptions.Is(DESTINATION_IS_HISTORICAL)) {
                 MortarUtilities::AddAreaWeightedNodalValue<TVarType, MortarUtilitiesSettings::SaveAsHistoricalVariable>(rNode, *mpDestinationVariable, ref_area);
             } else {

kratos/utilities/exact_mortar_segmentation_utility.cpp

@@ -5,13 +5,13 @@
 //   _|\_\_|  \__,_|\__|\___/ ____/
 //                   Multi-Physics
 //
-//  License:		 BSD License
-//					 Kratos default license: kratos/license.txt
+//  License:         BSD License
+//                   Kratos default license: kratos/license.txt
 //
 //  Main authors:    Vicente Mataix Ferrandiz
 //
-#if !defined(KRATOS_EXACT_MORTAR_INTEGRATION_UTILITY_H_INCLUDED)
-#define KRATOS_EXACT_MORTAR_INTEGRATION_UTILITY_H_INCLUDED
+
+#pragma once
 
 // System includes
 #include <iostream>
@@ -47,19 +47,8 @@ namespace Kratos {
 ///@name Type Definitions
 ///@{
 
-    /// Geometric definitions
-    typedef Point PointType;
-    typedef Node NodeType;
-    typedef Geometry<NodeType> GeometryType;
-    typedef Geometry<PointType> GeometryPointType;
-
-    ///Type definition for integration methods
-    typedef GeometryData::IntegrationMethod IntegrationMethod;
-    typedef IntegrationPoint<2> IntegrationPointType;
-    typedef GeometryType::IntegrationPointsArrayType IntegrationPointsType;
-
     /// The definition of the size type
-    typedef std::size_t SizeType;
+    using SizeType = std::size_t;
 
 ///@}
 ///@name  Enum's
@@ -91,50 +80,70 @@ class KRATOS_API(KRATOS_CORE) ExactMortarIntegrationUtility
     ///@name Type Definitions
     ///@{
 
-    /// The type of points belongfs to be considered
-    typedef typename std::conditional<TNumNodes == 2, PointBelongsLine2D2N, typename std::conditional<TNumNodes == 3, typename std::conditional<TNumNodesMaster == 3, PointBelongsTriangle3D3N, PointBelongsTriangle3D3NQuadrilateral3D4N>::type, typename std::conditional<TNumNodesMaster == 3, PointBelongsQuadrilateral3D4NTriangle3D3N, PointBelongsQuadrilateral3D4N>::type>::type>::type BelongType;
+    /// The definition of the class
+    using ClassType = ExactMortarIntegrationUtility<TDim, TNumNodes, TBelong, TNumNodesMaster>;
+    
+    /// Geometric definitions
+    using GeometryType = Geometry<Node>;
+    using GeometryPointType = Geometry<Point>;
+
+    /// Type definition for integration methods
+    using IntegrationMethod = GeometryData::IntegrationMethod;
+    using IntegrationPointType = IntegrationPoint<2>;
+    using IntegrationPointsType = GeometryType::IntegrationPointsArrayType;
+
+    /// The type of points to be considered
+    using BelongType = typename std::conditional<TNumNodes == 2,
+        PointBelongsLine2D2N,
+        typename std::conditional<TNumNodes == 3,
+            typename std::conditional<TNumNodesMaster == 3,
+                PointBelongsTriangle3D3N,
+                PointBelongsTriangle3D3NQuadrilateral3D4N>::type,
+            typename std::conditional<TNumNodesMaster == 3,
+                PointBelongsQuadrilateral3D4NTriangle3D3N,
+                PointBelongsQuadrilateral3D4N>::type>::type>::type;
 
     /// The definition of the point with belonging
-    typedef PointBelong<TNumNodes, TNumNodesMaster> PointBelongType;
+    using PointBelongType = PointBelong<TNumNodes, TNumNodesMaster>;
 
-    /// An array of points belong
-    typedef std::vector<array_1d<PointBelongType, TDim>> VectorArrayPointsBelong;
+    /// An array of points with belonging
+    using VectorArrayPointsBelong = std::vector<array_1d<PointBelongType, TDim>>;
 
-    /// A vector of points
-    typedef std::vector<array_1d<PointType, TDim>> VectorArrayPoints;
+    /// A vector of normal points
+    using VectorArrayPoints = std::vector<array_1d<Point, TDim>>;
 
     /// The type of array of points to be considered depending if we are interested in derivatives or not
-    typedef typename std::conditional<TBelong, VectorArrayPointsBelong,VectorArrayPoints>::type ConditionArrayListType;
+    using ConditionArrayListType = typename std::conditional<TBelong, VectorArrayPointsBelong, VectorArrayPoints>::type;
 
     /// A vector of points for derivatives
-    typedef std::vector<PointBelongType> VectorPointsBelong;
+    using VectorPointsBelong = std::vector<PointBelongType>;
 
     /// A vector of normal points
-    typedef std::vector<PointType> VectorPoints;
+    using VectorPoints = std::vector<Point>;
 
     /// The type of vector of points to be considered depending if we are interested in define derivatives or not
-    typedef typename std::conditional<TBelong, VectorPointsBelong, VectorPoints>::type PointListType;
+    using PointListType = typename std::conditional<TBelong, VectorPointsBelong, VectorPoints>::type;
 
-    /// An array of points belong
-    typedef array_1d<PointBelongType, 3> ArrayPointsBelong;
+    /// An array of points with belonging
+    using ArrayPointsBelong = array_1d<PointBelongType, 3>;
 
     /// An array of normal points
-    typedef array_1d<PointType, 3> ArrayPoints;
+    using ArrayPoints = array_1d<Point, 3>;
 
-    /// The type of arrayt of points to be used depending if we are interested in derivatives or not
-    typedef typename std::conditional<TBelong, ArrayPointsBelong, ArrayPoints>::type ArrayTriangleType;
+    /// The type of array of points to be used depending if we are interested in derivatives or not
+    using ArrayTriangleType = typename std::conditional<TBelong, ArrayPointsBelong, ArrayPoints>::type;
 
     /// The points line geometry
-    typedef Line2D2<Point> LineType;
+    using LineType = Line2D2<Point>;
 
     /// The points triangle geometry
-    typedef Triangle3D3<Point> TriangleType;
+    using TriangleType = Triangle3D3<Point>;
 
     /// The geometry that will be considered for decomposition
-    typedef typename std::conditional<TDim == 2, LineType, TriangleType>::type DecompositionType;
+    using DecompositionType = typename std::conditional<TDim == 2, LineType, TriangleType>::type;
 
     /// The definition of the index type
-    typedef std::size_t IndexType;
+    using IndexType = std::size_t;
 
     /// Definition of epsilon
     static constexpr double ZeroTolerance = std::numeric_limits<double>::epsilon();
@@ -434,11 +443,11 @@ class KRATOS_API(KRATOS_CORE) ExactMortarIntegrationUtility
      * @return True if there is a intersection point, false otherwise
      */
     static inline bool Clipping2D(
-        PointType& rPointIntersection,
-        const PointType& rPointOrig1,
-        const PointType& rPointOrig2,
-        const PointType& rPointDest1,
-        const PointType& rPointDest2
+        Point& rPointIntersection,
+        const Point& rPointOrig1,
+        const Point& rPointOrig2,
+        const Point& rPointDest1,
+        const Point& rPointDest2
         )
     {
         const array_1d<double, 3>& r_coord_point_orig1 = rPointOrig1.Coordinates();
@@ -501,8 +510,8 @@ class KRATOS_API(KRATOS_CORE) ExactMortarIntegrationUtility
      * @return angle The angle formed
      */
     static inline double AnglePoints(
-        const PointType& rPointOrig1,
-        const PointType& rPointOrig2,
+        const Point& rPointOrig1,
+        const Point& rPointOrig2,
         const array_1d<double, 3>& rAxis1,
         const array_1d<double, 3>& rAxis2
         )
@@ -524,8 +533,8 @@ class KRATOS_API(KRATOS_CORE) ExactMortarIntegrationUtility
      * @return check The check done
      */
     static inline bool CheckPoints(
-        const PointType& rPointOrig,
-        const PointType& rPointDest
+        const Point& rPointOrig,
+        const Point& rPointDest
         )
     {
 //         const double tolerance = std::numeric_limits<double>::epsilon(); // NOTE: Giving some problems, too tight
@@ -541,9 +550,9 @@ class KRATOS_API(KRATOS_CORE) ExactMortarIntegrationUtility
      * @return The DetJ
      */
     static inline double FastTriagleCheck2D(
-        const PointType& rPointOrig1,
-        const PointType& rPointOrig2,
-        const PointType& rPointOrig3
+        const Point& rPointOrig1,
+        const Point& rPointOrig2,
+        const Point& rPointOrig3
         )
     {
         const double x10 = rPointOrig2.X() - rPointOrig1.X();
@@ -660,7 +669,7 @@ class KRATOS_API(KRATOS_CORE) ExactMortarIntegrationUtility
         PointListType& rPointList,
         const GeometryPointType& rSlaveGeometry,
         const GeometryPointType& rMasterGeometry,
-        const PointType& rRefCenter
+        const Point& rRefCenter
         );
 
     /**
@@ -684,7 +693,7 @@ class KRATOS_API(KRATOS_CORE) ExactMortarIntegrationUtility
         const GeometryPointType& rMasterGeometry,
         const array_1d<double, 3>& rSlaveTangentXi,
         const array_1d<double, 3>& rSlaveTangentEta,
-        const PointType& rRefCenter,
+        const Point& rRefCenter,
         const bool IsAllInside = false
         );
 
@@ -700,21 +709,7 @@ class KRATOS_API(KRATOS_CORE) ExactMortarIntegrationUtility
         );
 
     ///@}
-    ///@name Protected  Access
-    ///@{
-
-    ///@}
-    ///@name Protected Inquiry
-    ///@{
-
-    ///@}
-    ///@name Protected LifeCycle
-    ///@{
-    ///@}
 private:
-    ///@name Static Member Variables
-    ///@{
-    ///@}
     ///@name Member Variables
     ///@{
 
@@ -726,29 +721,5 @@ class KRATOS_API(KRATOS_CORE) ExactMortarIntegrationUtility
     bool mConsiderDelaunator;                /// If consider the DelaunatorUtilities in 3D in order to construct the triangles
 
     ///@}
-    ///@name Private Operators
-    ///@{
-
-    ///@}
-    ///@name Private Operations
-    ///@{
-
-    ///@}
-    ///@name Private  Access
-    ///@{
-    ///@}
-
-    ///@}
-    ///@name Serialization
-    ///@{
-
-    ///@name Private Inquiry
-    ///@{
-    ///@}
-
-    ///@name Unaccessible methods
-    ///@{
-    ///@}
 };  // Class ExactMortarIntegrationUtility
 }
-#endif /* KRATOS_EXACT_MORTAR_INTEGRATION_UTILITY_H_INCLUDED defined */

kratos/utilities/exact_mortar_segmentation_utility.h

@@ -4,8 +4,8 @@
 //   _|\_\_|  \__,_|\__|\___/ ____/
 //                   Multi-Physics
 //
-//  License:		 BSD License
-//					 Kratos default license: kratos/license.txt
+//  License:         BSD License
+//                   Kratos default license: kratos/license.txt
 //
 //  Main authors:    Vicente Mataix Ferrandiz
 //
@@ -208,7 +208,7 @@ void ComputeNodesTangentFromNormalModelPart(ModelPart& rModelPart)
 /***********************************************************************************/
 
 void ComputeTangentsFromNormal(
-    NodeType& rNode,
+    Node& rNode,
     const array_1d<double, 3>& rNormal,
     const std::size_t Dimension
     )
@@ -235,7 +235,7 @@ void ComputeTangentsFromNormal(
 /***********************************************************************************/
 
 void ComputeTangentNodeWithLMAndSlip(
-    NodeType& rNode,
+    Node& rNode,
     const std::size_t StepLM,
     const Variable<array_1d<double, 3>>* pSlipVariable,
     const double SlipCoefficient,
@@ -293,7 +293,7 @@ void ComputeTangentNodeWithLMAndSlip(
 /***********************************************************************************/
 
 void ComputeTangentNodeWithSlip(
-    NodeType& rNode,
+    Node& rNode,
     const std::size_t StepLM,
     const Variable<array_1d<double, 3>>* pSlipVariable,
     const double SlipCoefficient,
@@ -453,7 +453,7 @@ const std::string GetAuxiliarVariable<Variable<array_1d<double, 3>>>()
 
 template< >
 double GetAuxiliarValue<Variable<double>>(
-    NodeType& rThisNode,
+    Node& rThisNode,
     const std::size_t iSize
     )
 {
@@ -465,7 +465,7 @@ double GetAuxiliarValue<Variable<double>>(
 
 template< >
 double GetAuxiliarValue<Variable<array_1d<double, 3>>>(
-    NodeType& rThisNode,
+    Node& rThisNode,
     const std::size_t iSize
     )
 {
@@ -636,7 +636,7 @@ void AddValue<Variable<array_1d<double, 3>>, MortarUtilitiesSettings::SaveAsNonH
 
 template<>
 void AddAreaWeightedNodalValue<Variable<double>, MortarUtilitiesSettings::SaveAsHistoricalVariable>(
-    NodeType& rThisNode,
+    Node& rThisNode,
     const Variable<double>& rThisVariable,
     const double RefArea,
     const double Tolerance
@@ -653,7 +653,7 @@ void AddAreaWeightedNodalValue<Variable<double>, MortarUtilitiesSettings::SaveAs
 
 template<>
 void AddAreaWeightedNodalValue<Variable<array_1d<double, 3>>, MortarUtilitiesSettings::SaveAsHistoricalVariable>(
-    NodeType& rThisNode,
+    Node& rThisNode,
     const Variable<array_1d<double, 3>>& rThisVariable,
     const double RefArea,
     const double Tolerance
@@ -670,7 +670,7 @@ void AddAreaWeightedNodalValue<Variable<array_1d<double, 3>>, MortarUtilitiesSet
 
 template<>
 void AddAreaWeightedNodalValue<Variable<double>, MortarUtilitiesSettings::SaveAsNonHistoricalVariable>(
-    NodeType& rThisNode,
+    Node& rThisNode,
     const Variable<double>& rThisVariable,
     const double RefArea,
     const double Tolerance
@@ -687,7 +687,7 @@ void AddAreaWeightedNodalValue<Variable<double>, MortarUtilitiesSettings::SaveAs
 
 template<>
 void AddAreaWeightedNodalValue<Variable<array_1d<double, 3>>, MortarUtilitiesSettings::SaveAsNonHistoricalVariable>(
-    NodeType& rThisNode,
+    Node& rThisNode,
     const Variable<array_1d<double, 3>>& rThisVariable,
     const double RefArea,
     const double Tolerance