arc-length element More...

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

Inheritance diagram for FractureMechanics::GriffithForceElement::FrontArcLengthControl:

Collaboration diagram for FractureMechanics::GriffithForceElement::FrontArcLengthControl:

Classes
struct	OpAssemble_db
	assemble internal residual derivative More...

struct	OpIntLambda
	assemble internal residual More...

Public Member Functions
	FrontArcLengthControl (int tag, GriffithForceElement::BlockData &block_data, GriffithForceElement::CommonData &common_data, const std::string &lambda_field_name, boost::shared_ptr< ArcLengthCtx > &arc_ptr)

virtual	~FrontArcLengthControl ()

MoFEMErrorCode	preProcess ()

double	calculateLambdaInt ()
	Calculate internal lambda. More...

MoFEMErrorCode	operator() ()

MoFEMErrorCode	postProcess ()

MoFEMErrorCode	calculateDb ()
	Calculate db. More...

MoFEMErrorCode	calculateDxAndDlambda (Vec x)

Public Attributes
int	tAg

boost::shared_ptr< ArcLengthCtx >	arcPtr

BlockData &	blockData

CommonData &	commonData

std::string	lambdaFieldName

Vec	ghostIntLambda

double	intLambdaArray [2]

double &	intLambdaDelta

double &	intLambdaLambda

double	intLambda

boost::shared_ptr< MyTriangleFE >	feIntLambda

Detailed Description

arc-length element

Calualte residual for arc length method amd vector db, which is derivative of residual.

Definition at line 1288 of file GriffithForceElement.hpp.

Constructor & Destructor Documentation

◆ FrontArcLengthControl()

FractureMechanics::GriffithForceElement::FrontArcLengthControl::FrontArcLengthControl	(	int	tag,
		GriffithForceElement::BlockData &	block_data,
		GriffithForceElement::CommonData &	common_data,
		const std::string &	lambda_field_name,
		boost::shared_ptr< ArcLengthCtx > &	arc_ptr
	)

inline

Definition at line 1497 of file GriffithForceElement.hpp.

         : tAg(tag), arcPtr(arc_ptr), blockData(block_data),
           commonData(common_data), lambdaFieldName(lambda_field_name),
           intLambdaDelta(intLambdaArray[0]),
           intLambdaLambda(intLambdaArray[1]) {
       int two[] = {0, 1};
       int nb_local = arcPtr->mField.get_comm_rank() == 0 ? 2 : 0;
       int nb_ghost = nb_local ? 0 : 2;
       ierr = VecCreateGhostWithArray(PETSC_COMM_WORLD, nb_local, 2, nb_ghost,
                                      two, intLambdaArray, &ghostIntLambda);
       CHKERRABORT(PETSC_COMM_WORLD, ierr);
       feIntLambda = boost::shared_ptr<MyTriangleFE>(
           new GriffithForceElement::MyTriangleFE(arcPtr->mField));
     }

◆ ~FrontArcLengthControl()

virtual FractureMechanics::GriffithForceElement::FrontArcLengthControl::~FrontArcLengthControl ( )

inlinevirtual

Definition at line 1514 of file GriffithForceElement.hpp.

                                      {
       ierr = VecDestroy(&ghostIntLambda);
       CHKERRABORT(PETSC_COMM_WORLD, ierr);
     }

Member Function Documentation

◆ calculateDb()

MoFEMErrorCode FractureMechanics::GriffithForceElement::FrontArcLengthControl::calculateDb ( )

inline

Calculate db.

Definition at line 1588 of file GriffithForceElement.hpp.

                                  {
       MoFEMFunctionBegin;
  
       MOFEM_LOG_CHANNEL("WORLD");
       MOFEM_LOG_FUNCTION();
       MOFEM_LOG_TAG("WORLD", "Arc");
  
       double alpha = arcPtr->alpha;
       double beta = arcPtr->beta;
       double d_lambda = arcPtr->dLambda;
  
       CHKERR VecZeroEntries(ghostIntLambda);
       CHKERR VecGhostUpdateBegin(ghostIntLambda, INSERT_VALUES,
                                  SCATTER_FORWARD);
       CHKERR VecGhostUpdateEnd(ghostIntLambda, INSERT_VALUES, SCATTER_FORWARD);
       CHKERR VecZeroEntries(arcPtr->db);
       CHKERR VecGhostUpdateBegin(arcPtr->db, INSERT_VALUES, SCATTER_FORWARD);
       CHKERR VecGhostUpdateEnd(arcPtr->db, INSERT_VALUES, SCATTER_FORWARD);
  
       // calculate internal lambda
       feIntLambda->getOpPtrVector().clear();
       feIntLambda->getOpPtrVector().push_back(new OpIntLambda(
           arcPtr->mField, blockData, commonData, lambdaFieldName, *this));
       feIntLambda->getOpPtrVector().push_back(new OpAssemble_db(
           tAg, arcPtr->mField, blockData, commonData, lambdaFieldName, *this));
       CHKERR arcPtr->mField.loop_finite_elements(
           problemPtr->getName(), "CRACKFRONT_AREA_ELEM", (*feIntLambda));
       const double *dx;
       const auto bit_field_number = getFieldBitNumber(lambdaFieldName);
       CHKERR VecGetArrayRead(arcPtr->dx, &dx);
       for (_IT_NUMEREDDOF_ROW_BY_BITNUMBER_FOR_LOOP_(problemPtr,
                                                      bit_field_number, dit)) {
         if (static_cast<int>(dit->get()->getPart()) !=
             arcPtr->mField.get_comm_rank())
           continue;
         int idx = dit->get()->getPetscLocalDofIdx();
         double val = dx[idx];
         CHKERR VecSetValue(ghostIntLambda, 1, val, ADD_VALUES);
       }
       CHKERR VecRestoreArrayRead(arcPtr->dx, &dx);
  
       CHKERR VecAssemblyBegin(ghostIntLambda);
       CHKERR VecAssemblyEnd(ghostIntLambda);
       CHKERR VecGhostUpdateBegin(ghostIntLambda, ADD_VALUES, SCATTER_REVERSE);
       CHKERR VecGhostUpdateEnd(ghostIntLambda, ADD_VALUES, SCATTER_REVERSE);
       CHKERR VecGhostUpdateBegin(ghostIntLambda, INSERT_VALUES,
                                  SCATTER_FORWARD);
       CHKERR VecGhostUpdateEnd(ghostIntLambda, INSERT_VALUES, SCATTER_FORWARD);
  
       CHKERR VecAssemblyBegin(arcPtr->db);
       CHKERR VecAssemblyEnd(arcPtr->db);
       CHKERR VecGhostUpdateBegin(arcPtr->db, ADD_VALUES, SCATTER_REVERSE);
       CHKERR VecGhostUpdateEnd(arcPtr->db, ADD_VALUES, SCATTER_REVERSE);
       CHKERR VecGhostUpdateBegin(arcPtr->db, INSERT_VALUES, SCATTER_FORWARD);
       CHKERR VecGhostUpdateEnd(arcPtr->db, INSERT_VALUES, SCATTER_FORWARD);
  
       intLambda = alpha * intLambdaDelta +
                   alpha * beta * beta * d_lambda * d_lambda * arcPtr->F_lambda2;
  
       MOFEM_LOG_C(
           "WORLD", Sev::noisy,
           "\tintLambdaLambda = %9.8e intLambdaDelta = %9.8e intLambda = %9.8e",
           intLambdaLambda, intLambdaDelta, intLambda);
  
       double nrm;
       CHKERR VecNorm(arcPtr->db, NORM_2, &nrm);
       MOFEM_LOG_C("WORLD", Sev::noisy, "\tdb nrm  = %9.8e", nrm);
  
       MoFEMFunctionReturn(0);
     }

◆ calculateDxAndDlambda()

MoFEMErrorCode FractureMechanics::GriffithForceElement::FrontArcLengthControl::calculateDxAndDlambda ( Vec x )

inline

Definition at line 1659 of file GriffithForceElement.hpp.

                                                 {
       MoFEMFunctionBegin;
       MOFEM_LOG_CHANNEL("WORLD");
       MOFEM_LOG_FUNCTION();
       MOFEM_LOG_TAG("WORLD", "Arc");
  
       // Calculate dx
       CHKERR VecGhostUpdateBegin(arcPtr->x0, INSERT_VALUES, SCATTER_FORWARD);
       CHKERR VecGhostUpdateEnd(arcPtr->x0, INSERT_VALUES, SCATTER_FORWARD);
  
       Vec l_x, l_x0, l_dx;
       CHKERR VecGhostGetLocalForm(x, &l_x);
       CHKERR VecGhostGetLocalForm(arcPtr->x0, &l_x0);
       CHKERR VecGhostGetLocalForm(arcPtr->dx, &l_dx);
       {
         double *x_array, *x0_array, *dx_array;
         CHKERR VecGetArray(l_x, &x_array);
         CHKERR VecGetArray(l_x0, &x0_array);
         CHKERR VecGetArray(l_dx, &dx_array);
         int size =
             problemPtr->getNbLocalDofsRow() + problemPtr->getNbGhostDofsRow();
         for (int i = 0; i != size; ++i) {
           dx_array[i] = x_array[i] - x0_array[i];
         }
         CHKERR VecRestoreArray(l_x, &x_array);
         CHKERR VecRestoreArray(l_x0, &x0_array);
         CHKERR VecRestoreArray(l_dx, &dx_array);
       }
       CHKERR VecGhostRestoreLocalForm(x, &l_x);
       CHKERR VecGhostRestoreLocalForm(arcPtr->x0, &l_x0);
       CHKERR VecGhostRestoreLocalForm(arcPtr->dx, &l_dx);
  
       // Calculate dlambda
       if (arcPtr->getPetscLocalDofIdx() != -1) {
         double *array;
         CHKERR VecGetArray(arcPtr->dx, &array);
         arcPtr->dLambda = array[arcPtr->getPetscLocalDofIdx()];
         array[arcPtr->getPetscLocalDofIdx()] = 0;
         CHKERR VecRestoreArray(arcPtr->dx, &array);
       }
       CHKERR VecGhostUpdateBegin(arcPtr->ghosTdLambda, INSERT_VALUES,
                                  SCATTER_FORWARD);
       CHKERR VecGhostUpdateEnd(arcPtr->ghosTdLambda, INSERT_VALUES,
                                SCATTER_FORWARD);
  
       // Calculate dx2
       double x_nrm, x0_nrm;
       CHKERR VecNorm(x, NORM_2, &x_nrm);
       CHKERR VecNorm(arcPtr->x0, NORM_2, &x0_nrm);
       CHKERR VecDot(arcPtr->dx, arcPtr->dx, &arcPtr->dx2);
       MOFEM_LOG_C("WORLD", Sev::noisy,
                   "\tx norm = %6.4e x0 norm = %6.4e dx2 = %6.4e", x_nrm, x0_nrm,
                   arcPtr->dx2);
       MoFEMFunctionReturn(0);
     }

◆ calculateLambdaInt()

double FractureMechanics::GriffithForceElement::FrontArcLengthControl::calculateLambdaInt ( )

inline

Calculate internal lambda.

Definition at line 1536 of file GriffithForceElement.hpp.

                                 {
       MoFEMFunctionBeginHot;
       return intLambda;
       MoFEMFunctionReturnHot(0);
     }

◆ operator()()

MoFEMErrorCode FractureMechanics::GriffithForceElement::FrontArcLengthControl::operator() ( )

inline

Definition at line 1542 of file GriffithForceElement.hpp.

                                 {
       MoFEMFunctionBegin;
       MOFEM_LOG_CHANNEL("WORLD");
       MOFEM_LOG_FUNCTION();
       MOFEM_LOG_TAG("WORLD", "Arc");
  
       switch (snes_ctx) {
       case CTX_SNESSETFUNCTION: {
         arcPtr->res_lambda = calculateLambdaInt() - arcPtr->alpha * arcPtr->s;
         CHKERR VecSetValue(snes_f, arcPtr->getPetscGlobalDofIdx(),
                            arcPtr->res_lambda, ADD_VALUES);
       } break;
       case CTX_SNESSETJACOBIAN: {
         arcPtr->dIag = 2 * arcPtr->dLambda * arcPtr->alpha *
                        pow(arcPtr->beta, 2) * arcPtr->F_lambda2;
         MOFEM_LOG_C("WORLD", Sev::noisy, "diag = %9.8e", arcPtr->dIag);
         CHKERR MatSetValue(snes_B, arcPtr->getPetscGlobalDofIdx(),
                            arcPtr->getPetscGlobalDofIdx(), 1, ADD_VALUES);
       } break;
       default:
         break;
       }
       MoFEMFunctionReturn(0);
     }

◆ postProcess()

MoFEMErrorCode FractureMechanics::GriffithForceElement::FrontArcLengthControl::postProcess ( )

inline

Definition at line 1567 of file GriffithForceElement.hpp.

                                  {
       MoFEMFunctionBegin;
       switch (snes_ctx) {
       case CTX_SNESSETFUNCTION: {
         CHKERR VecAssemblyBegin(snes_f);
         CHKERR VecAssemblyEnd(snes_f);
       } break;
       case CTX_SNESSETJACOBIAN: {
         CHKERR VecGhostUpdateBegin(arcPtr->ghostDiag, INSERT_VALUES,
                                    SCATTER_FORWARD);
         CHKERR VecGhostUpdateEnd(arcPtr->ghostDiag, INSERT_VALUES,
                                  SCATTER_FORWARD);
       } break;
       default:
         break;
       }
       MoFEMFunctionReturn(0);
     }

◆ preProcess()

MoFEMErrorCode FractureMechanics::GriffithForceElement::FrontArcLengthControl::preProcess ( )

inline

Definition at line 1519 of file GriffithForceElement.hpp.

                                 {
       MoFEMFunctionBegin;
       switch (snes_ctx) {
       case CTX_SNESSETFUNCTION: {
         CHKERR VecAssemblyBegin(snes_f);
         CHKERR VecAssemblyEnd(snes_f);
         CHKERR calculateDxAndDlambda(snes_x);
         CHKERR calculateDb();
       } break;
       default:
         break;
       }
       MoFEMFunctionReturn(0);
     }

Member Data Documentation

◆ arcPtr

boost::shared_ptr<ArcLengthCtx> FractureMechanics::GriffithForceElement::FrontArcLengthControl::arcPtr

Definition at line 1291 of file GriffithForceElement.hpp.

◆ blockData

BlockData& FractureMechanics::GriffithForceElement::FrontArcLengthControl::blockData

Definition at line 1292 of file GriffithForceElement.hpp.

◆ commonData

CommonData& FractureMechanics::GriffithForceElement::FrontArcLengthControl::commonData

Definition at line 1293 of file GriffithForceElement.hpp.

◆ feIntLambda

boost::shared_ptr<MyTriangleFE> FractureMechanics::GriffithForceElement::FrontArcLengthControl::feIntLambda

Definition at line 1302 of file GriffithForceElement.hpp.

◆ ghostIntLambda

Vec FractureMechanics::GriffithForceElement::FrontArcLengthControl::ghostIntLambda

Definition at line 1296 of file GriffithForceElement.hpp.

◆ intLambda

double FractureMechanics::GriffithForceElement::FrontArcLengthControl::intLambda

Definition at line 1300 of file GriffithForceElement.hpp.

◆ intLambdaArray

double FractureMechanics::GriffithForceElement::FrontArcLengthControl::intLambdaArray[2]

Definition at line 1297 of file GriffithForceElement.hpp.

◆ intLambdaDelta

double& FractureMechanics::GriffithForceElement::FrontArcLengthControl::intLambdaDelta

Definition at line 1298 of file GriffithForceElement.hpp.

◆ intLambdaLambda

double& FractureMechanics::GriffithForceElement::FrontArcLengthControl::intLambdaLambda

Definition at line 1299 of file GriffithForceElement.hpp.

◆ lambdaFieldName

std::string FractureMechanics::GriffithForceElement::FrontArcLengthControl::lambdaFieldName

Definition at line 1294 of file GriffithForceElement.hpp.

◆ tAg

int FractureMechanics::GriffithForceElement::FrontArcLengthControl::tAg

Definition at line 1290 of file GriffithForceElement.hpp.

The documentation for this struct was generated from the following file:

users_modules/fracture_mechanics/src/GriffithForceElement.hpp

Classes

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FrontArcLengthControl()

◆ ~FrontArcLengthControl()

Member Function Documentation

◆ calculateDb()

◆ calculateDxAndDlambda()

◆ calculateLambdaInt()

◆ operator()()

◆ postProcess()

◆ preProcess()

Member Data Documentation

◆ arcPtr

◆ blockData

◆ commonData

◆ feIntLambda

◆ ghostIntLambda

◆ intLambda

◆ intLambdaArray

◆ intLambdaDelta

◆ intLambdaLambda

◆ lambdaFieldName

◆ tAg