[GeoMechanicsApplication] Add the missing conditions to Geomechanics Application for 2D

applications/GeoMechanicsApplication/custom_conditions/Pw_condition.cpp

@@ -132,10 +132,11 @@ Condition::DofsVectorType PwCondition<TDim, TNumNodes>::GetDofs() const
 //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 template class PwCondition<2,1>;
 template class PwCondition<2,2>;
+template class PwCondition<2,3>;
+template class PwCondition<2,4>;
+template class PwCondition<2,5>;
 template class PwCondition<3,1>;
 template class PwCondition<3,3>;
 template class PwCondition<3,4>;
 
-template class PwCondition<2,3>;
-
 } // Namespace Kratos.

applications/GeoMechanicsApplication/custom_conditions/Pw_condition.hpp

@@ -13,9 +13,7 @@
 //                   Aron Noordam
 //
 
-
-#if !defined(KRATOS_GEO_PW_CONDITION_H_INCLUDED )
-#define  KRATOS_GEO_PW_CONDITION_H_INCLUDED
+#pragma once
 
 // System includes
 #include <cmath>
@@ -110,6 +108,4 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) PwCondition : public Condition
 
 }; // class PwCondition.
 
-} // namespace Kratos.
-
-#endif // KRATOS_GEO_PW_CONDITION_H_INCLUDED defined 
+} // namespace Kratos.

applications/GeoMechanicsApplication/custom_conditions/Pw_normal_flux_condition.cpp

@@ -16,6 +16,7 @@
 
 // Application includes
 #include "custom_conditions/Pw_normal_flux_condition.hpp"
+#include "custom_utilities/condition_utilities.hpp"
 
 namespace Kratos
 {
@@ -66,7 +67,9 @@ void PwNormalFluxCondition<TDim,TNumNodes>::
         noalias(Variables.Np) = row(NContainer,GPoint);
 
         //Compute weighting coefficient for integration
-        Variables.IntegrationCoefficient = this->CalculateIntegrationCoefficient(JContainer[GPoint], IntegrationPoints[GPoint].Weight() );
+        Variables.IntegrationCoefficient = 
+            ConditionUtilities::CalculateIntegrationCoefficient<TDim, TNumNodes>(
+            JContainer[GPoint], IntegrationPoints[GPoint].Weight());
 
         //Contributions to the right hand side
         this->CalculateAndAddRHS(rRightHandSideVector, Variables);
@@ -89,65 +92,10 @@ void PwNormalFluxCondition<TDim,TNumNodes>::
 }
 
 
-//----------------------------------------------------------------------------------------
-template< >
-double PwNormalFluxCondition<2, 2>::
-CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight)
-{
-    double dx_dxi = Jacobian(0, 0);
-    double dy_dxi = Jacobian(1, 0);
-
-    double ds = sqrt(dx_dxi * dx_dxi + dy_dxi * dy_dxi);
-
-    return ds * Weight;
-}
-
-
-//----------------------------------------------------------------------------------------
-template< >
-double PwNormalFluxCondition<3, 3>::
-CalculateIntegrationCoefficient(const Matrix& Jacobian,
-    const double& Weight)
-{
-    double NormalVector[3];
-
-    NormalVector[0] = Jacobian(1, 0) * Jacobian(2, 1) - Jacobian(2, 0) * Jacobian(1, 1);
-
-    NormalVector[1] = Jacobian(2, 0) * Jacobian(0, 1) - Jacobian(0, 0) * Jacobian(2, 1);
-
-    NormalVector[2] = Jacobian(0, 0) * Jacobian(1, 1) - Jacobian(1, 0) * Jacobian(0, 1);
-
-    double dA = sqrt(NormalVector[0] * NormalVector[0]
-        + NormalVector[1] * NormalVector[1]
-        + NormalVector[2] * NormalVector[2]);
-
-    return dA * Weight;
-}
-
-//----------------------------------------------------------------------------------------
-template< >
-double PwNormalFluxCondition<3, 4>::
-CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight)
-{
-    double NormalVector[3];
-
-    NormalVector[0] = Jacobian(1, 0) * Jacobian(2, 1) - Jacobian(2, 0) * Jacobian(1, 1);
-
-    NormalVector[1] = Jacobian(2, 0) * Jacobian(0, 1) - Jacobian(0, 0) * Jacobian(2, 1);
-
-    NormalVector[2] = Jacobian(0, 0) * Jacobian(1, 1) - Jacobian(1, 0) * Jacobian(0, 1);
-
-    double dA = sqrt(NormalVector[0] * NormalVector[0]
-        + NormalVector[1] * NormalVector[1]
-        + NormalVector[2] * NormalVector[2]);
-
-    return dA * Weight;
-}
-
-
-//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
 template class PwNormalFluxCondition<2,2>;
+template class PwNormalFluxCondition<2,3>;
+template class PwNormalFluxCondition<2,4>;
+template class PwNormalFluxCondition<2,5>;
 template class PwNormalFluxCondition<3,3>;
 template class PwNormalFluxCondition<3,4>;
 

applications/GeoMechanicsApplication/custom_conditions/Pw_normal_flux_condition.hpp

@@ -13,9 +13,7 @@
 //                   Aron Noordam
 //
 
-
-#if !defined(KRATOS_GEO_PW_NORMAL_FLUX_CONDITION_H_INCLUDED )
-#define  KRATOS_GEO_PW_NORMAL_FLUX_CONDITION_H_INCLUDED
+#pragma once
 
 // Project includes
 #include "includes/serializer.h"
@@ -81,8 +79,6 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) PwNormalFluxCondition : public PwCon
 
     void CalculateAndAddRHS(VectorType& rRightHandSideVector, NormalFluxVariables& rVariables);
 
-    virtual double CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight);
-
 //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
 private:
@@ -107,6 +103,4 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) PwNormalFluxCondition : public PwCon
 
 }; // class PwNormalFluxCondition.
 
-} // namespace Kratos.
-
-#endif // KRATOS_GEO_PW_NORMAL_FLUX_CONDITION_H_INCLUDED defined 
+} // namespace Kratos.

applications/GeoMechanicsApplication/custom_conditions/U_Pw_face_load_condition.cpp

@@ -15,6 +15,7 @@
 
 // Application includes
 #include "custom_conditions/U_Pw_face_load_condition.hpp"
+#include "custom_utilities/condition_utilities.hpp" 
 
 namespace Kratos
 {
@@ -66,116 +67,22 @@ void UPwFaceLoadCondition<TDim,TNumNodes>::
         ConditionUtilities::CalculateNuMatrix<TDim, TNumNodes>(Nu,NContainer,GPoint);
 
         //Compute weighting coefficient for integration
-        double integration_coefficient = this->CalculateIntegrationCoefficient(JContainer[GPoint],
-                                                                              IntegrationPoints[GPoint].Weight());
+        double integration_coefficient = 
+            ConditionUtilities::CalculateIntegrationCoefficient<TDim, TNumNodes>(
+            JContainer[GPoint], IntegrationPoints[GPoint].Weight());
 
         //Contributions to the right hand side
         noalias(UVector) = prod(trans(Nu),TractionVector) * integration_coefficient;
         ConditionUtilities::AssembleUBlockVector<TDim, TNumNodes>(rRightHandSideVector, UVector);
     }
 }
 
-//----------------------------------------------------------------------------------------
-template< >
-double UPwFaceLoadCondition<2,2>::
-    CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight)
-{
-    double dx_dxi = Jacobian(0,0);
-    double dy_dxi = Jacobian(1,0);
-
-    double ds = sqrt(dx_dxi*dx_dxi + dy_dxi*dy_dxi);
-
-    return ds * Weight;
-}
-
-//----------------------------------------------------------------------------------------
-template< >
-double UPwFaceLoadCondition<2,3>::
-    CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight)
-{
-    double dx_dxi = Jacobian(0,0);
-    double dy_dxi = Jacobian(1,0);
-
-    double ds = sqrt(dx_dxi*dx_dxi + dy_dxi*dy_dxi);
-
-    return ds * Weight;
-}
-
-//----------------------------------------------------------------------------------------
-template< >
-double UPwFaceLoadCondition<2,4>::
-CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight)
-{
-    const double dx_dxi = Jacobian(0, 0);
-    const double dy_dxi = Jacobian(1, 0);
-
-    const double ds = std::sqrt(dx_dxi * dx_dxi + dy_dxi * dy_dxi);
-
-    return ds * Weight;
-}
-
-//----------------------------------------------------------------------------------------
-template< >
-double UPwFaceLoadCondition<2,5>::
-CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight)
-{
-    const double dx_dxi = Jacobian(0, 0);
-    const double dy_dxi = Jacobian(1, 0);
-
-    const double ds = std::sqrt(dx_dxi * dx_dxi + dy_dxi * dy_dxi);
-
-    return ds * Weight;
-}
-
-//----------------------------------------------------------------------------------------
-template< >
-double UPwFaceLoadCondition<3,3>::
-    CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight)
-{
-    double NormalVector[3];
-
-    NormalVector[0] = Jacobian(1,0) * Jacobian(2,1) - Jacobian(2,0) * Jacobian(1,1);
-
-    NormalVector[1] = Jacobian(2,0) * Jacobian(0,1) - Jacobian(0,0) * Jacobian(2,1);
-
-    NormalVector[2] = Jacobian(0,0) * Jacobian(1,1) - Jacobian(1,0) * Jacobian(0,1);
-
-    double dA = sqrt(  NormalVector[0]*NormalVector[0]
-                     + NormalVector[1]*NormalVector[1]
-                     + NormalVector[2]*NormalVector[2]);
-
-    return dA * Weight;
-}
-
-//----------------------------------------------------------------------------------------
-template< >
-double UPwFaceLoadCondition<3,4>::
-    CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight)
-{
-    double NormalVector[3];
-
-    NormalVector[0] = Jacobian(1,0) * Jacobian(2,1) - Jacobian(2,0) * Jacobian(1,1);
-
-    NormalVector[1] = Jacobian(2,0) * Jacobian(0,1) - Jacobian(0,0) * Jacobian(2,1);
-
-    NormalVector[2] = Jacobian(0,0) * Jacobian(1,1) - Jacobian(1,0) * Jacobian(0,1);
-
-    double dA = sqrt(  NormalVector[0]*NormalVector[0]
-                     + NormalVector[1]*NormalVector[1]
-                     + NormalVector[2]*NormalVector[2]);
-
-    return dA * Weight;
-}
-
-//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
 template class UPwFaceLoadCondition<2,2>;
 template class UPwFaceLoadCondition<2,3>;
 template class UPwFaceLoadCondition<2,4>;
 template class UPwFaceLoadCondition<2,5>;
-
 template class UPwFaceLoadCondition<3,3>;
 template class UPwFaceLoadCondition<3,4>;
 
-
 } // Namespace Kratos.

applications/GeoMechanicsApplication/custom_conditions/U_Pw_face_load_condition.hpp

@@ -12,9 +12,7 @@
 //                   Vahid Galavi
 //
 
-
-#if !defined(KRATOS_GEO_U_PW_FACE_LOAD_CONDITION_H_INCLUDED )
-#define  KRATOS_GEO_U_PW_FACE_LOAD_CONDITION_H_INCLUDED
+#pragma once
 
 // Project includes
 #include "includes/serializer.h"
@@ -77,8 +75,6 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) UPwFaceLoadCondition
     void CalculateRHS(VectorType& rRightHandSideVector,
                       const ProcessInfo& CurrentProcessInfo) override;
 
-    virtual double CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight);
-
 //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
 private:
@@ -103,6 +99,4 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) UPwFaceLoadCondition
 
 }; // class UPwFaceLoadCondition.
 
-} // namespace Kratos.
-
-#endif // KRATOS_GEO_U_PW_FACE_LOAD_CONDITION_H_INCLUDED defined 
+} // namespace Kratos.

applications/GeoMechanicsApplication/custom_conditions/U_Pw_face_load_interface_condition.cpp

@@ -298,21 +298,14 @@ double UPwFaceLoadInterfaceCondition<2,2>::CalculateIntegrationCoefficient(const
 //----------------------------------------------------------------------------------------
 
 template< >
-double UPwFaceLoadInterfaceCondition<3,4>::CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight, const double& JointWidth)
+double UPwFaceLoadInterfaceCondition<3, 4>::CalculateIntegrationCoefficient(const Matrix& Jacobian, const double& Weight, const double& JointWidth)
 {
     KRATOS_TRY
-
-    double dx_dxi = Jacobian(0,0);
-
-    double dy_dxi = Jacobian(1,0);
-
-    double dz_dxi = Jacobian(2,0);
-
-    double ds = sqrt(dx_dxi*dx_dxi + dy_dxi*dy_dxi + dz_dxi*dz_dxi);
-
+
+    double ds = MathUtils<double>::Norm(column(Jacobian, 0));
     return Weight * ds * JointWidth;
 
-    KRATOS_CATCH( "" )
+    KRATOS_CATCH("")
 }
 
 //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

applications/GeoMechanicsApplication/custom_conditions/U_Pw_face_load_interface_condition.hpp

@@ -12,9 +12,7 @@
 //                   Vahid Galavi
 //
 
-
-#if !defined(KRATOS_GEO_U_PW_FACE_LOAD_INTERFACE_CONDITION_H_INCLUDED )
-#define  KRATOS_GEO_U_PW_FACE_LOAD_INTERFACE_CONDITION_H_INCLUDED
+#pragma once
 
 // Project includes
 #include "includes/serializer.h"
@@ -110,5 +108,3 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) UPwFaceLoadInterfaceCondition : publ
 }; // class UPwFaceLoadInterfaceCondition.
 
 } // namespace Kratos.
-
-#endif // KRATOS_GEO_U_PW_FACE_LOAD_INTERFACE_CONDITION_H_INCLUDED defined

applications/GeoMechanicsApplication/custom_conditions/U_Pw_force_condition.hpp

@@ -12,9 +12,7 @@
 //                   Vahid Galavi
 //
 
-
-#if !defined(KRATOS_GEO_U_PW_FORCE_CONDITION_H_INCLUDED )
-#define  KRATOS_GEO_U_PW_FORCE_CONDITION_H_INCLUDED
+#pragma once
 
 // Project includes
 #include "includes/serializer.h"
@@ -92,6 +90,4 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) UPwForceCondition : public UPwCondit
 
 }; // class UPwForceCondition.
 
-} // namespace Kratos.
-
-#endif // KRATOS_GEO_U_PW_FORCE_CONDITION_H_INCLUDED defined 
+} // namespace Kratos.