MoFEM::EssentialPostProcRhs< DisplacementCubitBcData > Struct Reference

Specialization for DisplacementCubitBcData. More...

#include "src/boundary_conditions/EssentialDisplacementCubitBcData.hpp"

Collaboration diagram for MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >:

Public Member Functions
	EssentialPostProcRhs (MoFEM::Interface &m_field, boost::shared_ptr< FEMethod > fe_ptr, double diag, SmartPetscObj< Vec > rhs=nullptr)
virtual	~EssentialPostProcRhs ()=default
MoFEMErrorCode	operator() ()

Protected Attributes
MoFEM::Interface &	mField
boost::weak_ptr< FEMethod >	fePtr
double	vDiag
SmartPetscObj< Vec >	vRhs

Detailed Description

Specialization for DisplacementCubitBcData.

Template Parameters

Definition at line 113 of file EssentialDisplacementCubitBcData.hpp.

Constructor & Destructor Documentation

EssentialPostProcRhs()

MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::EssentialPostProcRhs	(	MoFEM::Interface &	m_field,
		boost::shared_ptr< FEMethod >	fe_ptr,
		double	diag,
		SmartPetscObj< Vec >	rhs = nullptr )

Definition at line 171 of file EssentialDisplacementCubitBcData.cpp.

    : mField(m_field), fePtr(fe_ptr), vDiag(diag), vRhs(rhs) {}

~EssentialPostProcRhs()

virtual MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::~EssentialPostProcRhs ( )

virtualdefault

Member Function Documentation

operator()()

MoFEMErrorCode MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::operator()

(

)

Definition at line 176 of file EssentialDisplacementCubitBcData.cpp.

                                                                         {
  MOFEM_LOG_CHANNEL("WORLD");
  MoFEMFunctionBegin;
 
  if (auto fe_method_ptr = fePtr.lock()) {
 
    auto bc_mng = mField.getInterface<BcManager>();
    auto vec_mng = mField.getInterface<VecManager>();
    auto is_mng = mField.getInterface<ISManager>();
 
    const auto problem_name = fe_method_ptr->problemPtr->getName();
 
    SmartPetscObj<IS> is_sum;
 
    for (auto bc : bc_mng->getBcMapByBlockName()) {
      if (auto disp_bc = bc.second->dispBcPtr) {
 
        auto &bc_id = bc.first;
 
        auto regex_str = (boost::format("%s_(.*)") % problem_name).str();
        if (std::regex_match(bc_id, std::regex(regex_str))) {
 
          auto [field_name, block_name] =
              BcManager::extractStringFromBlockId(bc_id, problem_name);
 
          MOFEM_LOG("WORLD", Sev::noisy)
              << "Apply EssentialPreProc<DisplacementCubitBcData>: "
              << problem_name << "_" << field_name << "_" << block_name;
 
          const bool is_rotation =
              disp_bc->data.flag4 || disp_bc->data.flag5 || disp_bc->data.flag6;
 
          auto ents = bc.second->bcEnts;
 
          std::array<SmartPetscObj<IS>, 3> is_xyz;
          auto prb_name = fe_method_ptr->problemPtr->getName();
 
          if (disp_bc->data.flag1 || is_rotation) {
            CHKERR is_mng->isCreateProblemFieldAndRankLocal(
                prb_name, ROW, field_name, 0, 0, is_xyz[0], &ents);
          }
          if (disp_bc->data.flag2 || is_rotation) {
            CHKERR is_mng->isCreateProblemFieldAndRankLocal(
                prb_name, ROW, field_name, 1, 1, is_xyz[1], &ents);
          }
          if (disp_bc->data.flag3 || is_rotation) {
            CHKERR is_mng->isCreateProblemFieldAndRankLocal(
                prb_name, ROW, field_name, 2, 2, is_xyz[2], &ents);
          }
 
          auto get_is_sum = [](auto is1, auto is2) {
            IS is;
            CHK_THROW_MESSAGE(ISExpand(is1, is2, &is), "is sum");
            return SmartPetscObj<IS>(is);
          };
 
          for (auto &is : is_xyz) {
            if (is) {
              if (!is_sum) {
                is_sum = is;
              } else {
                is_sum = get_is_sum(is_sum, is);
              }
            }
          }
        }
      }
    }
 
    if (is_sum) {
      if (auto fe_ptr = fePtr.lock()) {
 
        auto snes_ctx = fe_ptr->snes_ctx;
        auto ts_ctx = fe_ptr->ts_ctx;
 
        SmartPetscObj<Vec> f =
            vRhs ? vRhs : SmartPetscObj<Vec>(fe_ptr->f, true);
 
        if (fe_ptr->vecAssembleSwitch) {
          if ((*fe_ptr->vecAssembleSwitch) && !vRhs) {
            CHKERR VecGhostUpdateBegin(f, ADD_VALUES, SCATTER_REVERSE);
            CHKERR VecGhostUpdateEnd(f, ADD_VALUES, SCATTER_REVERSE);
            CHKERR VecAssemblyBegin(f);
            CHKERR VecAssemblyEnd(f);
            *fe_ptr->vecAssembleSwitch = false;
          }
        }
 
        const int *index_ptr;
        CHKERR ISGetIndices(is_sum, &index_ptr);
        int size;
        CHKERR ISGetLocalSize(is_sum, &size);
        double *a;
        CHKERR VecGetArray(f, &a);
 
        auto tmp_x = vectorDuplicate(f);
        CHKERR vec_mng->setLocalGhostVector(problem_name, ROW, tmp_x,
                                            INSERT_VALUES, SCATTER_FORWARD);
        const double *u;
        CHKERR VecGetArrayRead(tmp_x, &u);
 
        if (snes_ctx != FEMethod::CTX_SNESNONE ||
            ts_ctx != FEMethod::CTX_TSNONE) {
 
          auto x = fe_ptr->x;
          CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
          CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
 
          const double *v;
          CHKERR VecGetArrayRead(x, &v);
 
          for (auto i = 0; i != size; ++i) {
            a[index_ptr[i]] = vDiag * (v[index_ptr[i]] - u[index_ptr[i]]);
          }
 
          CHKERR VecRestoreArrayRead(x, &v);
 
        } else {
          for (auto i = 0; i != size; ++i) {
            a[index_ptr[i]] = vDiag * u[index_ptr[i]];
          }
        }
 
        CHKERR VecRestoreArrayRead(tmp_x, &u);
        CHKERR VecRestoreArray(f, &a);
        CHKERR ISRestoreIndices(is_sum, &index_ptr);
      }
    }
 
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Can not lock shared pointer");
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

fePtr

boost::weak_ptr<FEMethod> MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::fePtr

protected

Definition at line 124 of file EssentialDisplacementCubitBcData.hpp.

mField

MoFEM::Interface& MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::mField

protected

Definition at line 123 of file EssentialDisplacementCubitBcData.hpp.

vDiag

double MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::vDiag

protected

Definition at line 125 of file EssentialDisplacementCubitBcData.hpp.

vRhs

SmartPetscObj<Vec> MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::vRhs

protected

Definition at line 126 of file EssentialDisplacementCubitBcData.hpp.

---

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

• src/boundary_conditions/EssentialDisplacementCubitBcData.hpp
• src/boundary_conditions/impl/EssentialDisplacementCubitBcData.cpp