OpH1LhsSkeleton Struct Reference

Operator the left hand side matrix. More...

Inheritance diagram for OpH1LhsSkeleton:

Collaboration diagram for OpH1LhsSkeleton:

Public Member Functions
	OpH1LhsSkeleton (boost::shared_ptr< FaceSideEle > side_fe_ptr, boost::shared_ptr< MatrixDouble > d_mat_ptr)
	Construct a new OpH1LhsSkeleton.
MoFEMErrorCode	doWork (int side, EntityType type, EntitiesFieldData::EntData &data)

Private Attributes
boost::shared_ptr< FaceSideEle >	sideFEPtr
	pointer to element to get data on edge/face sides
MatrixDouble	locMat
	local operator matrix
boost::shared_ptr< MatrixDouble >	dMatPtr

Detailed Description

Operator the left hand side matrix.

Examples

mofem/tutorials/vec-6/plate.cpp.

Definition at line 120 of file plate.cpp.

Constructor & Destructor Documentation

OpH1LhsSkeleton()

OpH1LhsSkeleton::OpH1LhsSkeleton	(	boost::shared_ptr< FaceSideEle >	side_fe_ptr,
		boost::shared_ptr< MatrixDouble >	mat_d_ptr
	)

Construct a new OpH1LhsSkeleton.

Parameters

side_fe_ptr

pointer to FE to evaluate side elements

Examples

mofem/tutorials/vec-6/plate.cpp.

Definition at line 505 of file plate.cpp.

    : BoundaryEleOp(NOSPACE, BoundaryEleOp::OPSPACE), sideFEPtr(side_fe_ptr),
      dMatPtr(mat_d_ptr) {}

Member Function Documentation

doWork()

MoFEMErrorCode OpH1LhsSkeleton::doWork	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

Examples

mofem/tutorials/vec-6/plate.cpp.

Definition at line 510 of file plate.cpp.

                                                                       {
  MoFEMFunctionBegin;
 
  // Collect data from side domian elements
  CHKERR loopSideFaces("dFE", *sideFEPtr);
  const auto in_the_loop =
      sideFEPtr->nInTheLoop; // return number of elements on the side
 
  // calculate  penalty
  const double s = getMeasure() / (areaMap[0] + areaMap[1]);
  const double p = penalty * s;
 
  // get normal of the face or edge
  auto t_normal = getFTensor1Normal();
  t_normal.normalize();
 
  // Elastic stiffness tensor (4th rank tensor with minor and major
  // symmetry)
  auto t_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(*dMatPtr);
 
  // get number of integration points on face
  const size_t nb_integration_pts = getGaussPts().size2();
 
  // beta paramter is zero, when penalty method is used, also, takes value 1,
  // when boundary edge/face is evaluated, and 2 when is skeleton edge/face.
  const double beta = static_cast<double>(nitsche) / (in_the_loop + 1);
 
  auto integrate = [&](auto sense_row, auto &row_ind, auto &row_diff,
                       auto &row_diff2, auto sense_col, auto &col_ind,
                       auto &col_diff, auto &col_diff2) {
    MoFEMFunctionBeginHot;
 
    // number of dofs, for homogenous approximation this value is
    // constant.
    const auto nb_rows = row_ind.size();
    const auto nb_cols = col_ind.size();
 
    const auto nb_row_base_functions = row_diff.size2() / SPACE_DIM;
 
    if (nb_cols) {
 
      // resize local element matrix
      locMat.resize(nb_rows, nb_cols, false);
      locMat.clear();
 
      // get base functions, and integration weights
      auto t_diff_row_base = get_diff_ntensor(row_diff);
      auto t_diff2_row_base = get_diff2_ntensor(row_diff2);
 
      auto t_w = getFTensor0IntegrationWeight();
 
      // iterate integration points on face/edge
      for (size_t gg = 0; gg != nb_integration_pts; ++gg) {
 
        // t_w is integration weight, and measure is element area, or
        // volume, depending if problem is in 2d/3d.
        const double alpha = getMeasure() * t_w;
        auto t_mat = locMat.data().begin();
 
        // iterate rows
        size_t rr = 0;
        for (; rr != nb_rows; ++rr) {
 
          FTensor::Tensor2_symmetric<double, SPACE_DIM> t_mv;
          t_mv(i, j) = t_D(i, j, k, l) * t_diff2_row_base(k, l);
 
          // calculate tetting function
          FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_vn_plus;
          t_vn_plus(i, j) = beta * (phi * t_mv(i, j) / p);
          FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_vn;
          t_vn(i, j) = (t_diff_row_base(j) * (t_normal(i) * sense_row)) -
                       t_vn_plus(i, j);
 
          // get base functions on columns
          auto t_diff_col_base = get_diff_ntensor(col_diff, gg, 0);
          auto t_diff2_col_base = get_diff2_ntensor(col_diff2, gg, 0);
 
          // iterate columns
          for (size_t cc = 0; cc != nb_cols; ++cc) {
 
            FTensor::Tensor2_symmetric<double, SPACE_DIM> t_mu;
            t_mu(i, j) = t_D(i, j, k, l) * t_diff2_col_base(k, l);
 
            // // calculate variance of tested function
            FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_un;
            t_un(i, j) = -p * ((t_diff_col_base(j) * (t_normal(i) * sense_col) -
                                beta * t_mu(i, j) / p));
 
            // assemble matrix
            *t_mat -= alpha * (t_vn(i, j) * t_un(i, j));
            *t_mat -= alpha * (t_vn_plus(i, j) * (beta * t_mu(i, j)));
 
            // move to next column base and element of matrix
            ++t_diff_col_base;
            ++t_diff2_col_base;
            ++t_mat;
          }
 
          // move to next row base
          ++t_diff_row_base;
          ++t_diff2_row_base;
        }
 
        // this is obsolete for this particular example, we keep it for
        // generality. in case of multi-physcis problems diffrent fields
        // can chare hierarchical base but use diffrent approx. order,
        // so is possible to have more base functions than DOFs on
        // element.
        for (; rr < nb_row_base_functions; ++rr) {
          ++t_diff_row_base;
          ++t_diff2_row_base;
        }
 
        ++t_w;
      }
 
      // assemble system
      CHKERR ::MatSetValues(getKSPB(), nb_rows, &*row_ind.begin(),
                            col_ind.size(), &*col_ind.begin(),
                            &*locMat.data().begin(), ADD_VALUES);
    }
 
    MoFEMFunctionReturnHot(0);
  };
 
  // iterate the sides rows
  for (auto s0 : {LEFT_SIDE, RIGHT_SIDE}) {
 
    const auto sense_row = senseMap[s0];
 
    for (auto x0 = 0; x0 != indicesSideMap[s0].size(); ++x0) {
 
      for (auto s1 : {LEFT_SIDE, RIGHT_SIDE}) {
        const auto sense_col = senseMap[s1];
 
        for (auto x1 = 0; x1 != indicesSideMap[s1].size(); ++x1) {
 
          CHKERR integrate(sense_row, indicesSideMap[s0][x0],
                           diffBaseSideMap[s0][x0], diff2BaseSideMap[s0][x0],
 
                           sense_col, indicesSideMap[s1][x1],
                           diffBaseSideMap[s1][x1], diff2BaseSideMap[s1][x1]
 
          );
        }
      }
    }
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

dMatPtr

boost::shared_ptr<MatrixDouble> OpH1LhsSkeleton::dMatPtr

private

Examples

mofem/tutorials/vec-6/plate.cpp.

Definition at line 137 of file plate.cpp.

locMat

MatrixDouble OpH1LhsSkeleton::locMat

private

local operator matrix

Examples

mofem/tutorials/vec-6/plate.cpp.

Definition at line 136 of file plate.cpp.

sideFEPtr

boost::shared_ptr<FaceSideEle> OpH1LhsSkeleton::sideFEPtr

private

pointer to element to get data on edge/face sides

Examples

mofem/tutorials/vec-6/plate.cpp.

Definition at line 135 of file plate.cpp.

---

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

• tutorials/vec-6/plate.cpp