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)

MoFEMErrorCode	operator() ()

Protected Attributes
MoFEM::Interface &	mField

boost::weak_ptr< FEMethod >	fePtr

double	vDiag

SmartPetscObj< Vec >	vRhs

Detailed Description

Specialization for DisplacementCubitBcData.

Template Parameters

Examples: adolc_plasticity.cpp, nonlinear_elastic.cpp, plastic.cpp, and seepage.cpp.

Definition at line 111 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.

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

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);
 }