LevelSet::OpRhsSkeleton Struct Reference

Inheritance diagram for LevelSet::OpRhsSkeleton:

Collaboration diagram for LevelSet::OpRhsSkeleton:

Public Member Functions
	OpRhsSkeleton (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...
VectorDouble	resSkelton

Detailed Description

Examples

level_set.cpp.

Definition at line 435 of file level_set.cpp.

Constructor & Destructor Documentation

OpRhsSkeleton()

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

Examples

level_set.cpp.

Definition at line 598 of file level_set.cpp.

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

Member Function Documentation

doWork()

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

Examples

level_set.cpp.

Definition at line 703 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) {
 
        resSkelton.resize(nb_rows, false);
        resSkelton.clear();
 
        // get orientation of the local element edge
        const auto opposite_s0 = not_side(s0);
        const auto sense_row = sideDataPtr->senseMap[s0];
#ifndef NDEBUG
        const auto opposite_sense_row = sideDataPtr->senseMap[opposite_s0];
        if (sense_row * opposite_sense_row > 0)
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "Should be opposite sign");
#endif
 
        // iterate the side cols
        const auto nb_row_base_functions =
            sideDataPtr->rowBaseSideMap[s0].size2();
 
        auto t_w = getFTensor0IntegrationWeight();
        auto arr_t_l = make_array(
            getFTensor2FromMat<DIM1, DIM2>(sideDataPtr->lVec[LEFT_SIDE]),
            getFTensor2FromMat<DIM1, DIM2>(sideDataPtr->lVec[RIGHT_SIDE]));
        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_l : arr_t_l)
            ++t_l;
          for (auto &t_vel : arr_t_vel)
            ++t_vel;
        };
 
#ifndef NDEBUG
        if (nb_gauss_pts != sideDataPtr->rowBaseSideMap[s0].size1())
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "Inconsistent number of DOFs");
#endif
 
        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 l_upwind = arr_t_l[l_upwind_side];
          FTensor::Tensor2<double, DIM1, DIM2> t_res;
          t_res(I, J) = t_w * dot * l_upwind(I, J);
          next();
          ++t_w;
 
          auto t_res_skeleton =
              getFTensor2FromPtr<DIM1, DIM2>(&*resSkelton.data().begin());
          auto rr = 0;
          for (; rr != nb_rows; ++rr) {
            t_res_skeleton(I, J) += t_row_base * t_res(I, J);
            ++t_row_base;
            ++t_res_skeleton;
          }
          for (; rr < nb_row_base_functions; ++rr) {
            ++t_row_base;
          }
        }
        // assemble local operator vector to global vector
        CHKERR ::VecSetValues(getTSf(),
                              sideDataPtr->indicesRowSideMap[s0].size(),
                              &*sideDataPtr->indicesRowSideMap[s0].begin(),
                              &*resSkelton.begin(), ADD_VALUES);
      }
    }
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

resSkelton

VectorDouble LevelSet::OpRhsSkeleton::resSkelton

private

Definition at line 447 of file level_set.cpp.

sideDataPtr

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

private

Definition at line 443 of file level_set.cpp.

sideFEPtr

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

private

pointer to element to get data on edge/face sides

Definition at line 445 of file level_set.cpp.

---

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

• tutorials/adv-3/level_set.cpp