MoFEM::OpBrokenBaseImpl< OpBase > Struct Template Reference

#include <src/finite_elements/FormsBrokenSpaceConstraintImpl.hpp>

Inheritance diagram for MoFEM::OpBrokenBaseImpl< OpBase >:

Collaboration diagram for MoFEM::OpBrokenBaseImpl< OpBase >:

Public Types
using	OP = OpBase

Public Member Functions
	OpBrokenBaseImpl (boost::shared_ptr< std::vector< BrokenBaseSideData >> broken_base_side_data, boost::shared_ptr< Range > ents_ptr=nullptr)
	OpBrokenBaseImpl (const std::string row_field, boost::shared_ptr< std::vector< BrokenBaseSideData >> broken_base_side_data, const bool assmb_transpose, const bool only_transpose, boost::shared_ptr< Range > ents_ptr=nullptr)
MoFEMErrorCode	doWork (int row_side, EntityType row_type, EntitiesFieldData::EntData &row_data)

Protected Attributes
boost::shared_ptr< std::vector< BrokenBaseSideData > >	brokenBaseSideData

Detailed Description

template<typename OpBase>
struct MoFEM::OpBrokenBaseImpl< OpBase >

Definition at line 171 of file FormsBrokenSpaceConstraintImpl.hpp.

Member Typedef Documentation

OP

template<typename OpBase >

using MoFEM::OpBrokenBaseImpl< OpBase >::OP = OpBase

Definition at line 173 of file FormsBrokenSpaceConstraintImpl.hpp.

Constructor & Destructor Documentation

OpBrokenBaseImpl() [1/2]

template<typename OpBase >

MoFEM::OpBrokenBaseImpl< OpBase >::OpBrokenBaseImpl ( boost::shared_ptr< std::vector< BrokenBaseSideData >>  broken_base_side_data, boost::shared_ptr< Range >  ents_ptr = nullptr  )

inline

Definition at line 175 of file FormsBrokenSpaceConstraintImpl.hpp.

      : OP(NOSPACE, OP::OPSPACE), brokenBaseSideData(broken_base_side_data) {
    OP::entsPtr = ents_ptr;
  }

OpBrokenBaseImpl() [2/2]

template<typename OpBase >

MoFEM::OpBrokenBaseImpl< OpBase >::OpBrokenBaseImpl ( const std::string  row_field, boost::shared_ptr< std::vector< BrokenBaseSideData >>  broken_base_side_data, const bool  assmb_transpose, const bool  only_transpose, boost::shared_ptr< Range >  ents_ptr = nullptr  )

inline

Definition at line 182 of file FormsBrokenSpaceConstraintImpl.hpp.

      : OP(row_field, row_field, OP::OPROW, ents_ptr),
        brokenBaseSideData(broken_base_side_data) {
    OP::entsPtr = ents_ptr;
    OP::assembleTranspose = assmb_transpose;
    OP::onlyTranspose = only_transpose;
    OP::sYmm = false;
  }

Member Function Documentation

doWork()

template<typename OpBase >

MoFEMErrorCode MoFEM::OpBrokenBaseImpl< OpBase >::doWork	(	int	row_side,
		EntityType	row_type,
		EntitiesFieldData::EntData &	row_data
	)

Definition at line 204 of file FormsBrokenSpaceConstraintImpl.hpp.

                                                                     {
  MoFEMFunctionBegin;
 
  if (OP::entsPtr) {
    if (OP::entsPtr->find(this->getFEEntityHandle()) == OP::entsPtr->end())
      MoFEMFunctionReturnHot(0);
  }
 
#ifndef NDEBUG
  if (!brokenBaseSideData) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "space not set");
  }
#endif // NDEBUG
 
  auto do_work_rhs = [this](int row_side, EntityType row_type,
                            EntitiesFieldData::EntData &row_data, int sense) {
    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
    OP::locF *= sense;
    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, int sense) {
    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);
    OP::locMat *= sense;
    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 : *brokenBaseSideData) {
 
#ifndef NDEBUG
      if (bd.getData().getSpace() != HDIV && bd.getData().getSpace() != HCURL) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                (std::string("Expect Hdiv or Hcurl space but received ") +
                 FieldSpaceNames[bd.getData().getSpace()])
                    .c_str());
      }
      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(),
 
          // sense
          bd.getSense()
 
      );
    }
 
    break;
  case OP::OPSPACE:
    for (auto &bd : *brokenBaseSideData) {
      CHKERR do_work_rhs(bd.getSide(), bd.getType(), bd.getData(),
                         bd.getSense());
    }
    break;
  default:
    CHK_MOAB_THROW(MOFEM_IMPOSSIBLE_CASE,
                   (std::string("wrong op type ") +
                    OpBaseDerivativesBase::OpTypeNames[OP::opType])
                       .c_str());
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

brokenBaseSideData

template<typename OpBase >

boost::shared_ptr<std::vector<BrokenBaseSideData> > MoFEM::OpBrokenBaseImpl< OpBase >::brokenBaseSideData

protected

Definition at line 199 of file FormsBrokenSpaceConstraintImpl.hpp.

---

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

• src/finite_elements/FormsBrokenSpaceConstraintImpl.hpp