#include <users_modules/fracture_mechanics/src/ConstantArea.hpp>

Inheritance diagram for FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >:

Collaboration diagram for FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >:

Public Member Functions
PetscErrorCode	sPin (ublas::matrix< TYPE > &spin, ublas::vector< TYPE > &vec)

PetscErrorCode	matrixB (int gg, DataForcesAndSourcesCore::EntData &data)

PetscErrorCode	dIffX ()

PetscErrorCode	nOrmal ()

PetscErrorCode	matrixA ()

PetscErrorCode	calculateAreaIncrementDirection (double beta)

PetscErrorCode	calculateFrontTangent (double beta)

Public Attributes
MatrixDouble	N

MatrixDouble	NTN

MatrixDouble	Bksi

MatrixDouble	Beta

ublas::vector< TYPE >	referenceCoords

ublas::vector< TYPE >	referenceXdKsi

ublas::vector< TYPE >	referenceXdEta

ublas::matrix< TYPE >	referenceSpinKsi

ublas::matrix< TYPE >	referenceSpinEta

ublas::vector< TYPE >	referenceNormal

TYPE	referenceArea

ublas::vector< TYPE >	currentCoords

ublas::vector< TYPE >	currentXdKsi

ublas::vector< TYPE >	currentXdEta

ublas::matrix< TYPE >	currentSpinKsi

ublas::matrix< TYPE >	currentSpinEta

ublas::vector< TYPE >	currentNormal

TYPE	currentArea

ublas::matrix< TYPE >	A

ublas::vector< TYPE >	crackAreaIncrement

ublas::vector< TYPE >	crackFrontTangent

FTensor::Tensor2< TYPE, 3, 3 >	tSpin

Detailed Description

template<typename TYPE>
struct FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >

\[ A = \| \mathbf{N} \| = \left\| \textrm{Spin}\left[ \frac{\partial\mathbf{N}\mathbf{X}}{\partial\xi} \right] \frac{\partial\mathbf{N}\mathbf{X}}{\partial\eta} \right\| \]

Definition at line 267 of file ConstantArea.hpp.

Member Function Documentation

◆ calculateAreaIncrementDirection()

template<typename TYPE >

PetscErrorCode FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >::calculateAreaIncrementDirection ( double beta )

inline

Definition at line 377 of file ConstantArea.hpp.

                                                                   {
         MoFEMFunctionBeginHot;
         for (int dd = 0; dd != 9; dd++) {
           for (int ii = 0; ii != 3; ii++) {
             crackAreaIncrement[dd] +=
                 beta * A(ii, dd) * currentNormal[ii] / currentArea;
           }
         }
         MoFEMFunctionReturnHot(0);
       }

◆ calculateFrontTangent()

template<typename TYPE >

PetscErrorCode FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >::calculateFrontTangent ( double beta )

inline

Definition at line 393 of file ConstantArea.hpp.

                                                         {
         MoFEMFunctionBeginHot;
         FTensor::Index<'i', 3> i;
         FTensor::Index<'j', 3> j;
         tSpin(i, j) = 0;
         tSpin(0, 1) = -currentNormal[2];
         tSpin(0, 2) = +currentNormal[1];
         tSpin(1, 0) = +currentNormal[2];
         tSpin(1, 2) = -currentNormal[0];
         tSpin(2, 0) = -currentNormal[1];
         tSpin(2, 1) = +currentNormal[0];
         tSpin(i, j) /= beta * currentArea;
         crackFrontTangent.resize(9, false);
         FTensor::Tensor1<TYPE *, 3> t_crack_front_tangent(
             &crackFrontTangent[0], &crackFrontTangent[1], &crackFrontTangent[2],
             3);
         FTensor::Tensor1<TYPE *, 3> t_area_increment(&crackAreaIncrement[0],
                                                      &crackAreaIncrement[1],
                                                      &crackAreaIncrement[2], 3);
         for (int ii = 0; ii != 3; ++ii) {
           t_crack_front_tangent(i) = tSpin(i, j) * t_area_increment(j);
           ++t_area_increment;
           ++t_crack_front_tangent;
         }
         MoFEMFunctionReturnHot(0);
       }

◆ dIffX()

template<typename TYPE >

PetscErrorCode FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >::dIffX ( )

inline

Definition at line 326 of file ConstantArea.hpp.

                              {
         MoFEMFunctionBeginHot;
         currentXdKsi.resize(3, false);
         currentXdEta.resize(3, false);
         std::fill(currentXdKsi.begin(), currentXdKsi.end(), 0);
         std::fill(currentXdEta.begin(), currentXdEta.end(), 0);
         for (auto ii = 0; ii != Bksi.size1(); ++ii)
           for (auto jj = 0; jj != Bksi.size2(); ++jj)
             currentXdKsi(ii) += Bksi(ii, jj) * currentCoords(jj);
         for (auto ii = 0; ii != Beta.size1(); ++ii)
           for (auto jj = 0; jj != Beta.size2(); ++jj)
             currentXdEta(ii) += Beta(ii, jj) * currentCoords(jj);
         // noalias(currentXdKsi) = prod(Bksi, currentCoords);
         // noalias(currentXdEta) = prod(Beta, currentCoords);
         MoFEMFunctionReturnHot(0);
       }

◆ matrixA()

template<typename TYPE >

PetscErrorCode FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >::matrixA ( )

inline

Definition at line 363 of file ConstantArea.hpp.

                                {
         MoFEMFunctionBeginHot;
         A.resize(3, 9, false);
         A.clear();
         for (auto ii = 0; ii != A.size1(); ++ii)
           for (auto jj = 0; jj != A.size2(); ++jj)
             for (auto kk = 0; kk != currentSpinKsi.size2(); ++kk)
               A(ii, jj) += 0.5 * (currentSpinKsi(ii, kk) * Beta(kk, jj) -
                                   currentSpinEta(ii, kk) * Bksi(kk, jj));
         // noalias(A) =
         //     0.5 * (prod(currentSpinKsi, Beta) - prod(currentSpinEta, Bksi));
         MoFEMFunctionReturnHot(0);
       }

◆ matrixB()

template<typename TYPE >

PetscErrorCode FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >::matrixB	(	int	gg,
		DataForcesAndSourcesCore::EntData &	data
	)

inline

Definition at line 307 of file ConstantArea.hpp.

                                                                             {
         MoFEMFunctionBeginHot;
         Bksi.resize(3, 9, false);
         Bksi.clear();
         for (int ii = 0; ii < 3; ++ii) {
           for (int jj = 0; jj < 3; ++jj) {
             Bksi(jj, ii * 3 + jj) = data.getDiffN(gg)(ii, 0);
           }
         }
         Beta.resize(3, 9, false);
         Beta.clear();
         for (int ii = 0; ii < 3; ++ii) {
           for (int jj = 0; jj < 3; ++jj) {
             Beta(jj, ii * 3 + jj) = data.getDiffN(gg)(ii, 1);
           }
         }
         MoFEMFunctionReturnHot(0);
       }

◆ nOrmal()

template<typename TYPE >

PetscErrorCode FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >::nOrmal ( )

inline

Definition at line 343 of file ConstantArea.hpp.

                               {
         MoFEMFunctionBeginHot;
  
         CHKERR sPin(currentSpinKsi, currentXdKsi);
         CHKERR sPin(currentSpinEta, currentXdEta);
         currentNormal.resize(3, false);
         std::fill(currentNormal.begin(), currentNormal.end(), 0);
         for (auto ii = 0; ii != currentSpinKsi.size1(); ++ii)
           for (auto jj = 0; jj != currentSpinKsi.size2(); ++jj)
             currentNormal(ii) +=
                 0.5 * currentSpinKsi(ii, jj) * currentXdEta(jj);
         // noalias(currentNormal) = 0.5 * prod(currentSpinKsi, currentXdEta);
         currentArea = 0;
         for (int dd = 0; dd != 3; ++dd) {
           currentArea += currentNormal[dd] * currentNormal[dd];
         }
         currentArea = sqrt(currentArea);
         MoFEMFunctionReturnHot(0);
       }

◆ sPin()

template<typename TYPE >

PetscErrorCode FractureMechanics::ConstantArea::OpAreaJacobian::AuxFunctions< TYPE >::sPin	(	ublas::matrix< TYPE > &	spin,
		ublas::vector< TYPE > &	vec
	)

inline

Definition at line 294 of file ConstantArea.hpp.

                                                                            {
         MoFEMFunctionBeginHot;
         spin.resize(3, 3, false);
         std::fill(spin.data().begin(), spin.data().end(), 0);
         spin(0, 1) = -vec[2];
         spin(0, 2) = +vec[1];
         spin(1, 0) = +vec[2];
         spin(1, 2) = -vec[0];
         spin(2, 0) = -vec[1];
         spin(2, 1) = +vec[0];
         MoFEMFunctionReturnHot(0);
       }