LevelSet::OpLhsSkeleton Struct Reference

Inheritance diagram for LevelSet::OpLhsSkeleton:

Collaboration diagram for LevelSet::OpLhsSkeleton:

Public Member Functions
	OpLhsSkeleton (boost::shared_ptr< SideData > side_data_ptr, boost::shared_ptr< FaceSideEle > side_fe_ptr)
MoFEMErrorCode	doWork (int side, EntityType type, EntitiesFieldData::EntData &data)

Private Attributes
boost::shared_ptr< SideData >	sideDataPtr
boost::shared_ptr< FaceSideEle >	sideFEPtr
	pointer to element to get data on edge/face sides More...
MatrixDouble	matSkeleton

Detailed Description

Examples

level_set.cpp.

Definition at line 450 of file level_set.cpp.

Constructor & Destructor Documentation

OpLhsSkeleton()

LevelSet::OpLhsSkeleton::OpLhsSkeleton	(	boost::shared_ptr< SideData >	side_data_ptr,
		boost::shared_ptr< FaceSideEle >	side_fe_ptr
	)

Examples

level_set.cpp.

Definition at line 604 of file level_set.cpp.

    : BoundaryEleOp(NOSPACE, BoundaryEleOp::OPSPACE),
      sideDataPtr(side_data_ptr), sideFEPtr(side_fe_ptr) {}

Member Function Documentation

doWork()

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

Examples

level_set.cpp.

Definition at line 809 of file level_set.cpp.

                                                                {
  MoFEMFunctionBegin;
 
  // Collect data from side domain elements
  CHKERR loopSideFaces("dFE", *sideFEPtr);
  const auto in_the_loop =
      sideFEPtr->nInTheLoop; // return number of elements on the side
 
  auto not_side = [](auto s) {
    return s == LEFT_SIDE ? RIGHT_SIDE : LEFT_SIDE;
  };
 
  auto get_ntensor = [](auto &base_mat) {
    return FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(
        &*base_mat.data().begin());
  };
 
  if (in_the_loop > 0) {
 
    // get normal of the face or edge
    auto t_normal = getFTensor1Normal();
    const auto nb_gauss_pts = getGaussPts().size2();
 
    for (auto s0 : {LEFT_SIDE, RIGHT_SIDE}) {
 
      // gent number of DOFs on the right side.
      const auto nb_rows = sideDataPtr->indicesRowSideMap[s0].size();
 
      if (nb_rows) {
 
        // get orientation of the local element edge
        const auto opposite_s0 = not_side(s0);
        const auto sense_row = sideDataPtr->senseMap[s0];
 
        // iterate the side cols
        const auto nb_row_base_functions =
            sideDataPtr->rowBaseSideMap[s0].size2();
 
        for (auto s1 : {LEFT_SIDE, RIGHT_SIDE}) {
 
          // gent number of DOFs on the right side.
          const auto nb_cols = sideDataPtr->indicesColSideMap[s1].size();
          const auto sense_col = sideDataPtr->senseMap[s1];
 
          // resize local element matrix
          matSkeleton.resize(nb_rows, nb_cols, false);
          matSkeleton.clear();
 
          auto t_w = getFTensor0IntegrationWeight();
          auto arr_t_vel = make_array(
              getFTensor1FromMat<SPACE_DIM>(sideDataPtr->velMat[LEFT_SIDE]),
              getFTensor1FromMat<SPACE_DIM>(sideDataPtr->velMat[RIGHT_SIDE]));
 
          auto next = [&]() {
            for (auto &t_vel : arr_t_vel)
              ++t_vel;
          };
 
          auto t_row_base = get_ntensor(sideDataPtr->rowBaseSideMap[s0]);
          for (int gg = 0; gg != nb_gauss_pts; ++gg) {
            FTensor::Tensor1<double, SPACE_DIM> t_vel;
            t_vel(i) =
                (arr_t_vel[LEFT_SIDE](i) + arr_t_vel[RIGHT_SIDE](i)) / 2.;
            const auto dot = sense_row * (t_normal(i) * t_vel(i));
            const auto l_upwind_side = (dot > 0) ? s0 : opposite_s0;
            const auto sense_upwind = sideDataPtr->senseMap[l_upwind_side];
            FTensor::Tensor2<double, DIM1, DIM2> t_res;
            t_res(I, J) = t_w * dot;
            next();
            ++t_w;
            auto rr = 0;
            if (s1 == l_upwind_side) {
              for (; rr != nb_rows; ++rr) {
                auto get_ntensor = [](auto &base_mat, auto gg, auto bb) {
                  double *ptr = &base_mat(gg, bb);
                  return FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(ptr);
                };
                auto t_col_base =
                    get_ntensor(sideDataPtr->colBaseSideMap[s1], gg, 0);
 
                auto t_mat_skeleton =
                    getFTensor2FromPtr<DIM1, DIM2>(&matSkeleton(rr * DIM1, 0));
                FTensor::Tensor2<double, DIM1, DIM2> t_res_row;
                t_res_row(I, J) = t_res(I, J) * t_row_base;
                ++t_row_base;
                // iterate columns
                for (size_t cc = 0; cc != nb_cols; ++cc) {
                  t_mat_skeleton(I, J) += t_res_row(I, J) * t_col_base;
                  ++t_col_base;
                  ++t_mat_skeleton;
                }
              }
            }
            for (; rr < nb_row_base_functions; ++rr) {
              ++t_row_base;
            }
          }
          // assemble system
          CHKERR ::MatSetValues(getTSB(),
                                sideDataPtr->indicesRowSideMap[s0].size(),
                                &*sideDataPtr->indicesRowSideMap[s0].begin(),
                                sideDataPtr->indicesColSideMap[s1].size(),
                                &*sideDataPtr->indicesColSideMap[s1].begin(),
                                &*matSkeleton.data().begin(), ADD_VALUES);
        }
      }
    }
  }
  MoFEMFunctionReturn(0);
}

Member Data Documentation

matSkeleton

MatrixDouble LevelSet::OpLhsSkeleton::matSkeleton

private

Definition at line 461 of file level_set.cpp.

sideDataPtr

boost::shared_ptr<SideData> LevelSet::OpLhsSkeleton::sideDataPtr

private

Definition at line 457 of file level_set.cpp.

sideFEPtr

boost::shared_ptr<FaceSideEle> LevelSet::OpLhsSkeleton::sideFEPtr

private

pointer to element to get data on edge/face sides

Definition at line 459 of file level_set.cpp.

---

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

• tutorials/adv-3/level_set.cpp