FractureMechanics::GriffithForceElement::OpLhs Struct Reference

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

Inheritance diagram for FractureMechanics::GriffithForceElement::OpLhs:

Collaboration diagram for FractureMechanics::GriffithForceElement::OpLhs:

Public Member Functions
	OpLhs (int tag, BlockData &block_data, CommonData &common_data, const double beta_gc=0)
MoFEMErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, DataForcesAndSourcesCore::EntData &row_data, DataForcesAndSourcesCore::EntData &col_data)
Public Member Functions inherited from FractureMechanics::GriffithForceElement::AuxOp
	AuxOp (int tag, BlockData &block_data, CommonData &common_data)
MoFEMErrorCode	setIndices (DataForcesAndSourcesCore::EntData &data)
MoFEMErrorCode	setVariables (FaceElementForcesAndSourcesCore::UserDataOperator *fe_ptr, DataForcesAndSourcesCore::EntData &data)
MoFEMErrorCode	setLambdaNodes (FaceElementForcesAndSourcesCore::UserDataOperator *fe_ptr, const std::string &lambda_field_name)
MoFEMErrorCode	setLambdaIndices (FaceElementForcesAndSourcesCore::UserDataOperator *fe_ptr, const std::string &lambda_field_name)

Public Attributes
MatrixDouble	mat
const double	betaGC
Public Attributes inherited from FractureMechanics::GriffithForceElement::AuxOp
int	tAg
BlockData &	blockData
CommonData &	commonData
ublas::vector< int >	rowIndices
ublas::vector< int >	rowIndicesLocal
VectorInt3	rowLambdaIndices
VectorInt3	rowLambdaIndicesLocal
VectorDouble3	lambdaAtNodes
VectorDouble	activeVariables

Detailed Description

Definition at line 601 of file GriffithForceElement.hpp.

Constructor & Destructor Documentation

OpLhs()

FractureMechanics::GriffithForceElement::OpLhs::OpLhs ( int  tag, BlockData &  block_data, CommonData &  common_data, const double  beta_gc = 0  )

inline

Definition at line 604 of file GriffithForceElement.hpp.

        : FaceElementForcesAndSourcesCore::UserDataOperator(
              "MESH_NODE_POSITIONS", "MESH_NODE_POSITIONS",
              UserDataOperator::OPROWCOL),
          betaGC(beta_gc), AuxOp(tag, block_data, common_data) {}

Member Function Documentation

doWork()

MoFEMErrorCode FractureMechanics::GriffithForceElement::OpLhs::doWork ( int  row_side, int  col_side, EntityType  row_type, EntityType  col_type, DataForcesAndSourcesCore::EntData &  row_data, DataForcesAndSourcesCore::EntData &  col_data  )

inline

Definition at line 614 of file GriffithForceElement.hpp.

                                                                     {
      MoFEMFunctionBegin;
 
      if (row_type != MBVERTEX) {
        MoFEMFunctionReturnHot(0);
      }
 
      FTensor::Index<'i', 3> i;
      FTensor::Index<'j', 3> j;
      FTensor::Index<'l', 3> l;
      FTensor::Index<'m', 3> m;
      FTensor::Index<'k', 3> k;
      FTensor::Number<0> N0;
      FTensor::Number<1> N1;
 
      AuxFunctions<double> auxFun;
      auxFun.currentCoords.resize(9, false);
 
      int nb_dofs = row_data.getFieldData().size();
      for (int dd = 0; dd != nb_dofs; dd++)
        auxFun.currentCoords[dd] = row_data.getFieldData()[dd];
 
      CHKERR setIndices(row_data);
      CHKERR setVariables(this, row_data);
      int nb_gauss_pts = row_data.getN().size1();
      int nb_base_row = row_data.getFieldData().size() / 3;
      int nb_base_col = col_data.getFieldData().size() / 3;
      int row_nb_dofs = row_data.getIndices().size();
 
      mat.resize(9, 9, false);
      mat.clear();
      auto calculate_derivative = [&](FTensor::Tensor1<double *, 2> &t_diff) {
        FTensor::Tensor2<double, 3, 3> t_d_n;
        t_d_n(i, j) = FTensor::levi_civita(i, j, k) * auxFun.t_Tangent1_ksi(k) *
                      t_diff(N1);
        t_d_n(i, j) -= FTensor::levi_civita(i, j, k) *
                       auxFun.t_Tangent2_eta(k) * t_diff(N0);
 
        return t_d_n;
      };
 
      CHKERR auxFun.calculateAreaAndNormal(col_data.getDiffN());
      auto t_normal = auxFun.t_Normal;
      const double coefficient_1 = 0.5 * pow((t_normal(i) * t_normal(i)), -0.5);
      const double coefficient_2 = 0.5 * pow((t_normal(i) * t_normal(i)), -1.5);
 
      // for homogeneous case, this is a bit ugly
      auto &rho_v = commonData.densityRho;
      if (rho_v.empty() || rho_v.size() != nb_base_row) {
        rho_v.resize(nb_base_row, false);
      }
      auto rho = getFTensor0FromVec(rho_v);
      for (int gg = 0; gg != nb_gauss_pts; gg++) {
 
        double val = getGaussPts()(2, gg) * 0.5;
        auto t_row_diff = row_data.getFTensor1DiffN<2>(gg, 0);
        for (int rrr = 0; rrr != nb_base_row; rrr++) {
 
          FTensor::Tensor2<double *, 3, 3> t_mat(
              &mat(3 * rrr + 0, 0), &mat(3 * rrr + 0, 1), &mat(3 * rrr + 0, 2),
              &mat(3 * rrr + 1, 0), &mat(3 * rrr + 1, 1), &mat(3 * rrr + 1, 2),
              &mat(3 * rrr + 2, 0), &mat(3 * rrr + 2, 1), &mat(3 * rrr + 2, 2),
              3);
 
          auto t_tan_row = calculate_derivative(t_row_diff);
          auto t_col_diff = col_data.getFTensor1DiffN<2>(gg, 0);
          const double coef = blockData.gc * val * pow(rho, betaGC);
          for (int ccc = 0; ccc != nb_base_col; ccc++) {
 
            auto t_tan_col = calculate_derivative(t_col_diff);
 
            t_mat(i, j) -= coefficient_1 *
                           (t_tan_row(i, l) * t_tan_col(l, j) +
                            FTensor::levi_civita(i, j, k) * t_col_diff(N0) *
                                t_row_diff(N1) * t_normal(k) -
                            FTensor::levi_civita(i, j, k) * t_col_diff(N1) *
                                t_row_diff(N0) * t_normal(k));
 
            t_mat(i, j) += coefficient_2 * (t_tan_row(i, k) * t_normal(k)) *
                           (t_tan_col(l, j) * t_normal(l));
 
            t_mat(i, j) *= coef;
            ++t_col_diff;
            ++t_mat;
          }
          ++t_row_diff;
          ++rho;
        }
      }
 
      int col_nb_dofs = col_data.getIndices().size();
 
      CHKERR MatSetValues(getFEMethod()->snes_B, row_nb_dofs,
                          &*rowIndices.data().begin(), col_nb_dofs,
                          &*col_data.getIndices().data().begin(),
                          &*mat.data().begin(), ADD_VALUES);
 
      MoFEMFunctionReturn(0);
    }

Member Data Documentation

betaGC

const double FractureMechanics::GriffithForceElement::OpLhs::betaGC

Definition at line 612 of file GriffithForceElement.hpp.

mat

MatrixDouble FractureMechanics::GriffithForceElement::OpLhs::mat

Definition at line 611 of file GriffithForceElement.hpp.

---

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

• users_modules/fracture_mechanics/src/GriffithForceElement.hpp