OpStabBrokenBaseImpl< OP > Struct Template Reference

#include "users_modules/eshelbian_plasticity/src/EshelbianOperators.hpp"

Inheritance diagram for OpStabBrokenBaseImpl< OP >:

Collaboration diagram for OpStabBrokenBaseImpl< OP >:

Public Types
using	BASE = OpBrokenBaseImpl< OP >

Public Member Functions
MoFEMErrorCode	doWork (int row_side, EntityType row_type, EntitiesFieldData::EntData &row_data)

Protected Attributes
boost::weak_ptr< MatrixDouble >	fluxMatPtr

Detailed Description

template<typename OP>
struct OpStabBrokenBaseImpl< OP >

Definition at line 1071 of file EshelbianOperators.hpp.

Member Typedef Documentation

BASE

template<typename OP >

using OpStabBrokenBaseImpl< OP >::BASE = OpBrokenBaseImpl<OP>

Definition at line 1073 of file EshelbianOperators.hpp.

Member Function Documentation

doWork()

template<typename OP >

MoFEMErrorCode OpStabBrokenBaseImpl< OP >::doWork ( int  row_side, EntityType  row_type, EntitiesFieldData::EntData &  row_data  )

inline

Definition at line 1076 of file EshelbianOperators.hpp.

                                                            {
    MoFEMFunctionBegin;
 
    if (OP::entsPtr) {
      if (OP::entsPtr->find(this->getFEEntityHandle()) == OP::entsPtr->end())
        MoFEMFunctionReturnHot(0);
    }
 
#ifndef NDEBUG
    if (!BASE::brokenBaseSideData) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "space not set");
    }
#endif // NDEBUG
 
    auto do_work_rhs = [this](int, EntityType,
                              EntitiesFieldData::EntData &row_data) {
      MoFEMFunctionBegin;
      // get number of dofs on row
      OP::nbRows = row_data.getIndices().size();
      if (!OP::nbRows)
        MoFEMFunctionReturnHot(0);
      // get number of integration points
      OP::nbIntegrationPts = OP::getGaussPts().size2();
      // get row base functions
      OP::nbRowBaseFunctions = OP::getNbOfBaseFunctions(row_data);
      // resize and clear the right hand side vector
      OP::locF.resize(OP::nbRows, false);
      OP::locF.clear();
      // integrate local vector
      CHKERR this->iNtegrate(row_data);
      // assemble local vector
      CHKERR this->aSsemble(row_data);
      MoFEMFunctionReturn(0);
    };
 
    auto do_work_lhs = [this](int row_side, int col_side, EntityType row_type,
                              EntityType col_type,
                              EntitiesFieldData::EntData &row_data,
                              EntitiesFieldData::EntData &col_data) {
      MoFEMFunctionBegin;
 
      auto check_if_assemble_transpose = [&] {
        if (this->sYmm) {
          if (OP::rowSide != OP::colSide || OP::rowType != OP::colType)
            return true;
          else
            return false;
        } else if (OP::assembleTranspose) {
          return true;
        }
        return false;
      };
 
      OP::rowSide = row_side;
      OP::rowType = row_type;
      OP::colSide = col_side;
      OP::colType = col_type;
      OP::nbCols = col_data.getIndices().size();
      OP::locMat.resize(OP::nbRows, OP::nbCols, false);
      OP::locMat.clear();
      CHKERR this->iNtegrate(row_data, col_data);
      CHKERR this->aSsemble(row_data, col_data, check_if_assemble_transpose());
      MoFEMFunctionReturn(0);
    };
 
    switch (OP::opType) {
    case OP::OPROW:
 
      OP::nbRows = row_data.getIndices().size();
      if (!OP::nbRows)
        MoFEMFunctionReturnHot(0);
      OP::nbIntegrationPts = OP::getGaussPts().size2();
      OP::nbRowBaseFunctions = OP::getNbOfBaseFunctions(row_data);
 
      if (!OP::nbRows)
        MoFEMFunctionReturnHot(0);
 
      for (auto &bd : *BASE::brokenBaseSideData) {
 
#ifndef NDEBUG
        if (!bd.getData().getNSharedPtr(bd.getData().getBase())) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "base functions not set");
        }
#endif
 
        CHKERR do_work_lhs(
 
            // side
            row_side, bd.getSide(),
 
            // type
            row_type, bd.getType(),
 
            // row_data
            row_data, bd.getData()
 
        );
      }
 
      break;
    case OP::OPSPACE:
      for (auto &bd : *BASE::brokenBaseSideData) {
        fluxMatPtr = boost::shared_ptr<MatrixDouble>(BASE::brokenBaseSideData,
                                                     &bd.getFlux());
        CHKERR do_work_rhs(bd.getSide(), bd.getType(), bd.getData());
      }
      break;
    default:
      CHK_MOAB_THROW(
          MOFEM_IMPOSSIBLE_CASE,
          (std::string("wrong op type ") +
           OpBaseDerivativesBase::OpTypeNames[static_cast<unsigned char>(
               OP::opType)])
              .c_str());
    }
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

fluxMatPtr

template<typename OP >

boost::weak_ptr<MatrixDouble> OpStabBrokenBaseImpl< OP >::fluxMatPtr

protected

Definition at line 1198 of file EshelbianOperators.hpp.

---

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

• users_modules/eshelbian_plasticity/src/EshelbianOperators.hpp