#include "src/finite_elements/FormsBrokenSpaceConstraintImpl.hpp"

Inheritance diagram for MoFEM::OpBrokenBaseImpl< OpBase >:

Collaboration diagram for MoFEM::OpBrokenBaseImpl< OpBase >:

Public Types
using	OP = OpBase

Public Types inherited from MoFEM::OpBaseImpl< A, EleOp >
using	OpType = typename EleOp::OpType

using	EntData = EntitiesFieldData::EntData

using	MatSetValuesHook

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)

Public Member Functions inherited from MoFEM::OpBaseImpl< A, EleOp >
	OpBaseImpl (const std::string row_field_name, const std::string col_field_name, const OpType type, boost::shared_ptr< Range > ents_ptr=nullptr)

MoFEMErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
	Do calculations for the left hand side.

MoFEMErrorCode	doWork (int row_side, EntityType row_type, EntData &row_data)
	Do calculations for the right hand side.

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

Protected Attributes inherited from MoFEM::OpBaseImpl< A, EleOp >
int	nbRows
	number of dofs on rows

int	nbCols
	number if dof on column

int	nbIntegrationPts
	number of integration points

int	nbRowBaseFunctions
	number or row base functions

int	rowSide
	row side number

int	colSide
	column side number

EntityType	rowType
	row type

EntityType	colType
	column type

bool	assembleTranspose

bool	onlyTranspose

MatrixDouble	locMat
	local entity block matrix

MatrixDouble	locMatTranspose
	local entity block matrix

VectorDouble	locF
	local entity vector

Additional Inherited Members
Public Attributes inherited from MoFEM::OpBaseImpl< A, EleOp >
TimeFun	timeScalingFun
	assumes that time variable is set

FEFun	feScalingFun
	assumes that time variable is set

boost::shared_ptr< Range >	entsPtr
	Entities on which element is run.

Static Public Attributes inherited from MoFEM::OpBaseImpl< A, EleOp >
static MatSetValuesHook	matSetValuesHook

Protected Member Functions inherited from MoFEM::OpBaseImpl< A, EleOp >
template<int DIM>
FTensor::Tensor1< FTensor::PackPtr< double *, DIM >, DIM >	getNf ()

template<int DIM>
FTensor::Tensor2< FTensor::PackPtr< double *, DIM >, DIM, DIM >	getLocMat (const int rr)

virtual MoFEMErrorCode	iNtegrate (EntData &row_data, EntData &col_data)
	Integrate grad-grad operator.

virtual MoFEMErrorCode	aSsemble (EntData &row_data, EntData &col_data, const bool trans)

virtual MoFEMErrorCode	iNtegrate (EntData &data)
	Class dedicated to integrate operator.

virtual MoFEMErrorCode	aSsemble (EntData &data)

virtual size_t	getNbOfBaseFunctions (EntitiesFieldData::EntData &data)
	Get number of base functions.

Detailed Description

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

Definition at line 296 of file FormsIntegrators.hpp.

Member Typedef Documentation

◆ OP

template<typename OpBase >

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

Definition at line 192 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 194 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 201 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 223 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, "%s",
                (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 218 of file FormsBrokenSpaceConstraintImpl.hpp.

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

src/finite_elements/FormsBrokenSpaceConstraintImpl.hpp
src/finite_elements/FormsIntegrators.hpp

Public Types

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ OP

Constructor & Destructor Documentation

◆ OpBrokenBaseImpl() [1/2]

◆ OpBrokenBaseImpl() [2/2]

Member Function Documentation

◆ doWork()

Member Data Documentation

◆ brokenBaseSideData