ArcLengthCtx Struct Reference

Store variables for ArcLength analysis. More...

#include "users_modules/basic_finite_elements/src/ArcLengthTools.hpp"

Collaboration diagram for ArcLengthCtx:

Public Member Functions
virtual	~ArcLengthCtx ()=default
MoFEMErrorCode	setS (double s)
	set arc radius
MoFEMErrorCode	setAlphaBeta (double alpha, double beta)
	set parameters controlling arc-length equations alpha controls off diagonal therms beta controls diagonal therm
	ArcLengthCtx (MoFEM::Interface &m_field, const std::string &problem_name, const std::string &field_name="LAMBDA")
DofIdx	getPetscGlobalDofIdx ()
	Get global index of load factor.
DofIdx	getPetscLocalDofIdx ()
	Get local index of load factor.
FieldData &	getFieldData ()
	Get value of load factor.
int	getPart ()
	Get proc owning lambda dof.

Public Attributes
MoFEM::Interface &	mField
double	s
	arc length radius
double	beta
	force scaling factor
double	alpha
	displacement scaling factor
SmartPetscObj< Vec >	ghosTdLambda
double	dLambda
	increment of load factor
SmartPetscObj< Vec >	ghostDiag
double	dIag
	diagonal value
double	dx2
	inner_prod(dX,dX)
double	F_lambda2
	inner_prod(F_lambda,F_lambda);
double	res_lambda
	f_lambda - s
SmartPetscObj< Vec >	F_lambda
	F_lambda reference load vector.
SmartPetscObj< Vec >	db
	db derivative of f(dx*dx), i.e. db = d[ f(dx*dx) ]/dx
SmartPetscObj< Vec >	xLambda
	solution of eq. K*xLambda = F_lambda
SmartPetscObj< Vec >	x0
	displacement vector at beginning of step
SmartPetscObj< Vec >	dx
	dx = x-x0

Private Attributes
NumeredDofEntity *	arcDofRawPtr

Detailed Description

Store variables for ArcLength analysis.

The constrain function if given by

\[ r_\lambda = f_\lambda(\mathbf{x},\lambda) - s^2 \]

where \(f_\lambda(\mathbf{x},\lambda)\) is some constrain function, which has general form given by

\[ f_\lambda(\mathbf{x},\lambda) = \alpha f(\Delta\mathbf{x}) + \beta^2 \Delta\lambda^2 \| \mathbf{F}_{\lambda} \|^2 \]

where for example \(f(\mathbf{x})=\|\Delta\mathbf{x}\|^2\) is some user defined function evaluating increments vector of degrees of freedom \(\Delta\mathbf{x}\). The increment vector is

\[ \Delta \mathbf{x} = \mathbf{x}-\mathbf{x}_0 \]

and

\[ \Delta \lambda = \lambda-\lambda_0. \]

For convenience we assume that

\[ \frac{\partial f}{\partial \mathbf{x}}\Delta \mathbf{x} = \textrm{d}\mathbf{b} \Delta \mathbf{x}, \]

as result linearised constrain equation takes form

\[ \textrm{d}\mathbf{b} \delta \Delta x + D \delta \Delta\lambda - r_{\lambda} = 0 \]

where

\[ D = 2\beta^2 \Delta\lambda \| \mathbf{F}_{\lambda} \|^2. \]

User need to implement functions calculating \(f(\mathbf{x},\lambda)\), i.e. function \(f(\|\Delta\mathbf{x}\|^2)\) and its derivative, \(\textrm{d}\mathbf{b}\).

Definition at line 65 of file ArcLengthTools.hpp.

Constructor & Destructor Documentation

~ArcLengthCtx()

virtual ArcLengthCtx::~ArcLengthCtx ( )

virtualdefault

ArcLengthCtx()

ArcLengthCtx::ArcLengthCtx	(	MoFEM::Interface &	m_field,
		const std::string &	problem_name,
		const std::string &	field_name = "LAMBDA"
	)

Definition at line 38 of file ArcLengthTools.cpp.

    : mField(m_field), dx2(0), F_lambda2(0), res_lambda(0) {
 
  auto create_f_lambda = [&]() {
    ArcFunctionBegin;
    CHKERR m_field.getInterface<VecManager>()->vecCreateGhost(problem_name, ROW,
                                                              F_lambda);
    CHKERR VecSetOption(F_lambda, VEC_IGNORE_NEGATIVE_INDICES, PETSC_TRUE);
    MoFEMFunctionReturn(0);
  };
 
  auto vec_duplicate = [&]() {
    MoFEMFunctionBegin;
    db = vectorDuplicate(F_lambda);
    xLambda = vectorDuplicate(F_lambda);
    x0 = vectorDuplicate(F_lambda);
    dx = vectorDuplicate(F_lambda);
    MoFEMFunctionReturn(0);
  };
 
  auto zero_vectors = [&]() {
    MoFEMFunctionBegin;
    CHKERR VecZeroEntries(F_lambda);
    CHKERR VecZeroEntries(db);
    CHKERR VecZeroEntries(xLambda);
    CHKERR VecZeroEntries(x0);
    CHKERR VecZeroEntries(dx);
    MoFEMFunctionReturn(0);
  };
 
  auto find_lambda_dof = [&]() {
    MoFEMFunctionBegin;
 
    const Problem *problem_ptr;
    CHKERR m_field.get_problem(problem_name, &problem_ptr);
    boost::shared_ptr<NumeredDofEntity_multiIndex> dofs_ptr_no_const =
        problem_ptr->getNumeredRowDofsPtr();
    auto bit_number = m_field.get_field_bit_number(field_name);
    auto dIt = dofs_ptr_no_const->get<Unique_mi_tag>().lower_bound(
        FieldEntity::getLoBitNumberUId(bit_number));
    auto hi_dit = dofs_ptr_no_const->get<Unique_mi_tag>().upper_bound(
        FieldEntity::getHiBitNumberUId(bit_number));
    if (std::distance(dIt, hi_dit) != 1)
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "%s",
              ("can not find unique LAMBDA (load factor) but found " +
               boost::lexical_cast<std::string>(std::distance(dIt, hi_dit)))
                  .c_str());
    arcDofRawPtr = (*dIt).get();
    MoFEMFunctionReturn(0);
  };
 
  auto create_ghost_vecs = [&]() {
    MoFEMFunctionBegin;
    Vec ghost_d_lambda, ghost_diag;
    if ((unsigned int)mField.get_comm_rank() == arcDofRawPtr->getPart()) {
      CHKERR VecCreateGhostWithArray(mField.get_comm(), 1, 1, 0, PETSC_NULLPTR,
                                     &dLambda, &ghost_d_lambda);
 
      CHKERR VecCreateGhostWithArray(mField.get_comm(), 1, 1, 0, PETSC_NULLPTR,
                                     &dIag, &ghost_diag);
    } else {
      int one[] = {0};
      CHKERR VecCreateGhostWithArray(mField.get_comm(), 0, 1, 1, one, &dLambda,
                                     &ghost_d_lambda);
      CHKERR VecCreateGhostWithArray(mField.get_comm(), 0, 1, 1, one, &dIag,
                                     &ghost_diag);
    }
    dLambda = 0;
    dIag = 0;
    ghosTdLambda = SmartPetscObj<Vec>(ghost_d_lambda);
    ghostDiag = SmartPetscObj<Vec>(ghost_diag);
    MoFEMFunctionReturn(0);
  };
 
  ierr = create_f_lambda();
  CHKERRABORT(PETSC_COMM_SELF, ierr);
 
  ierr = vec_duplicate();
  CHKERRABORT(PETSC_COMM_SELF, ierr);
 
  ierr = zero_vectors();
  CHKERRABORT(PETSC_COMM_SELF, ierr);
 
  ierr = find_lambda_dof();
  CHKERRABORT(PETSC_COMM_SELF, ierr);
 
  ierr = create_ghost_vecs();
  CHKERRABORT(PETSC_COMM_SELF, ierr);
}

Member Function Documentation

getFieldData()

FieldData & ArcLengthCtx::getFieldData ( )

inline

Get value of load factor.

Definition at line 117 of file ArcLengthTools.hpp.

{ return arcDofRawPtr->getFieldData(); }

getPart()

int ArcLengthCtx::getPart ( )

inline

Get proc owning lambda dof.

Definition at line 121 of file ArcLengthTools.hpp.

{ return arcDofRawPtr->getPart(); };

getPetscGlobalDofIdx()

DofIdx ArcLengthCtx::getPetscGlobalDofIdx ( )

inline

Get global index of load factor.

Definition at line 107 of file ArcLengthTools.hpp.

                                {
    return arcDofRawPtr->getPetscGlobalDofIdx();
  };

getPetscLocalDofIdx()

DofIdx ArcLengthCtx::getPetscLocalDofIdx ( )

inline

Get local index of load factor.

Definition at line 113 of file ArcLengthTools.hpp.

{ return arcDofRawPtr->getPetscLocalDofIdx(); };

setAlphaBeta()

MoFEMErrorCode ArcLengthCtx::setAlphaBeta	(	double	alpha,
		double	beta
	)

set parameters controlling arc-length equations alpha controls off diagonal therms beta controls diagonal therm

Definition at line 29 of file ArcLengthTools.cpp.

                                                                   {
  ArcFunctionBegin;
  this->alpha = alpha;
  this->beta = beta;
  MOFEM_LOG_C("WORLD", Sev::inform, "\tSet alpha = %6.4e beta = %6.4e",
              this->alpha, this->beta);
  MoFEMFunctionReturn(0);
}

setS()

MoFEMErrorCode ArcLengthCtx::setS

(

double

s

)

set arc radius

Definition at line 22 of file ArcLengthTools.cpp.

                                          {
  ArcFunctionBegin;
  this->s = s;
  MOFEM_LOG_C("WORLD", Sev::inform, "\tSet s = %6.4e", this->s);
  MoFEMFunctionReturn(0);
}

Member Data Documentation

alpha

double ArcLengthCtx::alpha

displacement scaling factor

Definition at line 73 of file ArcLengthTools.hpp.

arcDofRawPtr

NumeredDofEntity* ArcLengthCtx::arcDofRawPtr

private

Definition at line 124 of file ArcLengthTools.hpp.

beta

double ArcLengthCtx::beta

force scaling factor

Definition at line 72 of file ArcLengthTools.hpp.

db

SmartPetscObj<Vec> ArcLengthCtx::db

db derivative of f(dx*dx), i.e. db = d[ f(dx*dx) ]/dx

Definition at line 85 of file ArcLengthTools.hpp.

dIag

double ArcLengthCtx::dIag

diagonal value

Definition at line 78 of file ArcLengthTools.hpp.

dLambda

double ArcLengthCtx::dLambda

increment of load factor

Definition at line 76 of file ArcLengthTools.hpp.

dx

SmartPetscObj<Vec> ArcLengthCtx::dx

dx = x-x0

Definition at line 88 of file ArcLengthTools.hpp.

dx2

double ArcLengthCtx::dx2

inner_prod(dX,dX)

Definition at line 80 of file ArcLengthTools.hpp.

F_lambda

SmartPetscObj<Vec> ArcLengthCtx::F_lambda

F_lambda reference load vector.

Definition at line 83 of file ArcLengthTools.hpp.

F_lambda2

double ArcLengthCtx::F_lambda2

inner_prod(F_lambda,F_lambda);

Definition at line 81 of file ArcLengthTools.hpp.

ghostDiag

SmartPetscObj<Vec> ArcLengthCtx::ghostDiag

Definition at line 77 of file ArcLengthTools.hpp.

ghosTdLambda

SmartPetscObj<Vec> ArcLengthCtx::ghosTdLambda

Definition at line 75 of file ArcLengthTools.hpp.

mField

MoFEM::Interface& ArcLengthCtx::mField

Definition at line 69 of file ArcLengthTools.hpp.

res_lambda

double ArcLengthCtx::res_lambda

f_lambda - s

Definition at line 82 of file ArcLengthTools.hpp.

s

double ArcLengthCtx::s

arc length radius

Definition at line 71 of file ArcLengthTools.hpp.

x0

SmartPetscObj<Vec> ArcLengthCtx::x0

displacement vector at beginning of step

Definition at line 87 of file ArcLengthTools.hpp.

xLambda

SmartPetscObj<Vec> ArcLengthCtx::xLambda

solution of eq. K*xLambda = F_lambda

Definition at line 86 of file ArcLengthTools.hpp.

---

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

• users_modules/basic_finite_elements/src/ArcLengthTools.hpp
• users_modules/basic_finite_elements/src/impl/ArcLengthTools.cpp