transform Hdiv base fluxes from reference element to physical triangle More...

#include <src/finite_elements/DataOperators.hpp>

Inheritance diagram for MoFEM::OpSetContravariantPiolaTransformOnFace:

Collaboration diagram for MoFEM::OpSetContravariantPiolaTransformOnFace:

Public Member Functions
	OpSetContravariantPiolaTransformOnFace (const VectorDouble &normal, const MatrixDouble &normals_at_pts, const int normal_shift=0)

	OpSetContravariantPiolaTransformOnFace (const VectorDouble normal_raw_ptr=nullptr, const MatrixDouble normals_at_pts_ptr=nullptr, const int normal_shift=0)

MoFEMErrorCode	doWork (int side, EntityType type, EntitiesFieldData::EntData &data)
	Operator for linear form, usually to calculate values on right hand side. More...

Public Member Functions inherited from MoFEM::DataOperator
	DataOperator (const bool symm=true)

virtual	~DataOperator ()=default

virtual MoFEMErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
	Operator for bi-linear form, usually to calculate values on left hand side. More...

virtual MoFEMErrorCode	opLhs (EntitiesFieldData &row_data, EntitiesFieldData &col_data)

virtual MoFEMErrorCode	opRhs (EntitiesFieldData &data, const bool error_if_no_base=false)

bool	getSymm () const
	Get if operator uses symmetry of DOFs or not. More...

void	setSymm ()
	set if operator is executed taking in account symmetry More...

void	unSetSymm ()
	unset if operator is executed for non symmetric problem More...

Public Attributes
const VectorDouble *	normalRawPtr

const MatrixDouble *	normalsAtGaussPtsRawPtr

int	normalShift
	Shift in vector for linear geometry. More...

Public Attributes inherited from MoFEM::DataOperator
DoWorkLhsHookFunType	doWorkLhsHook

DoWorkRhsHookFunType	doWorkRhsHook

bool	sYmm
	If true assume that matrix is symmetric structure. More...

std::array< bool, MBMAXTYPE >	doEntities
	If true operator is executed for entity. More...

bool &	doVertices
	\deprectaed If false skip vertices More...

bool &	doEdges
	\deprectaed If false skip edges More...

bool &	doQuads
	\deprectaed More...

bool &	doTris
	\deprectaed More...

bool &	doTets
	\deprectaed More...

bool &	doPrisms
	\deprectaed More...

Additional Inherited Members
Public Types inherited from MoFEM::DataOperator
using	DoWorkLhsHookFunType = boost::function< MoFEMErrorCode(DataOperator *op_ptr, int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)>

using	DoWorkRhsHookFunType = boost::function< MoFEMErrorCode(DataOperator *op_ptr, int side, EntityType type, EntitiesFieldData::EntData &data)>

Detailed Description

transform Hdiv base fluxes from reference element to physical triangle

Deprecated:: It is used in contact elements. Contact elements should be minified to work as face element,

Definition at line 416 of file DataOperators.hpp.

Constructor & Destructor Documentation

◆ OpSetContravariantPiolaTransformOnFace() [1/2]

MoFEM::OpSetContravariantPiolaTransformOnFace::OpSetContravariantPiolaTransformOnFace	(	const VectorDouble &	normal,
		const MatrixDouble &	normals_at_pts,
		const int	normal_shift = `0`
	)

inline

Definition at line 433 of file DataOperators.hpp.

436 : normalRawPtr(&normal), normalsAtGaussPtsRawPtr(&normals_at_pts),

437 normalShift(normal_shift) {}

◆ OpSetContravariantPiolaTransformOnFace() [2/2]

MoFEM::OpSetContravariantPiolaTransformOnFace::OpSetContravariantPiolaTransformOnFace	(	const VectorDouble *	normal_raw_ptr = `nullptr`,
		const MatrixDouble *	normals_at_pts_ptr = `nullptr`,
		const int	normal_shift = `0`
	)

inline

Definition at line 439 of file DataOperators.hpp.

       : normalRawPtr(normal_raw_ptr),
         normalsAtGaussPtsRawPtr(normals_at_pts_ptr), normalShift(normal_shift) {
   }

Member Function Documentation

◆ doWork()

MoFEMErrorCode MoFEM::OpSetContravariantPiolaTransformOnFace::doWork	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

virtual

Operator for linear form, usually to calculate values on right hand side.

Reimplemented from MoFEM::DataOperator.

Definition at line 492 of file DataOperators.cpp.

                                                                {
   FTensor::Index<'i', 3> i;
   MoFEMFunctionBegin;
  
   if (moab::CN::Dimension(type) != 2)
     MoFEMFunctionReturnHot(0);
  
   if (normalRawPtr == nullptr && normalsAtGaussPtsRawPtr == nullptr)
     SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
             "Pointer to normal/normals not set");
  
   bool normal_is_at_gauss_pts = (normalsAtGaussPtsRawPtr != nullptr);
   if (normal_is_at_gauss_pts)
     normal_is_at_gauss_pts = (normalsAtGaussPtsRawPtr->size1() != 0);
  
   auto apply_transform_linear_geometry = [&](auto base, auto nb_gauss_pts,
                                              auto nb_base_functions) {
     MoFEMFunctionBegin;
     const auto &normal = *normalRawPtr;
     auto t_normal = FTensor::Tensor1<double, 3>{normal[normalShift + 0],
                                                 normal[normalShift + 1],
                                                 normal[normalShift + 2]};
     const auto l02 = t_normal(i) * t_normal(i);
     auto t_base = data.getFTensor1N<3>(base);
     for (int gg = 0; gg != nb_gauss_pts; ++gg) {
       for (int bb = 0; bb != nb_base_functions; ++bb) {
         const auto v = t_base(0);
         t_base(i) = (v / l02) * t_normal(i);
         ++t_base;
       }
     }
     MoFEMFunctionReturn(0);
   };
  
   auto apply_transform_nonlinear_geometry = [&](auto base, auto nb_gauss_pts,
                                                 auto nb_base_functions) {
     MoFEMFunctionBegin;
     const MatrixDouble &normals_at_pts = *normalsAtGaussPtsRawPtr;
     auto t_normal = FTensor::Tensor1<FTensor::PackPtr<const double *, 3>, 3>(
         &normals_at_pts(0, 0), &normals_at_pts(0, 1), &normals_at_pts(0, 2));
  
     auto t_base = data.getFTensor1N<3>(base);
     for (int gg = 0; gg != nb_gauss_pts; ++gg) {
       const auto l2 = t_normal(i) * t_normal(i);
       for (int bb = 0; bb != nb_base_functions; ++bb) {
         const auto v = t_base(0);
         t_base(i) = (v / l2) * t_normal(i);
         ++t_base;
       }
       ++t_normal;
     }
     MoFEMFunctionReturn(0);
   };
  
   if (normal_is_at_gauss_pts) {
     for (int b = AINSWORTH_LEGENDRE_BASE; b != LASTBASE; b++) {
  
       FieldApproximationBase base = static_cast<FieldApproximationBase>(b);
       const auto &base_functions = data.getN(base);
       const auto nb_gauss_pts = base_functions.size1();
  
       if (nb_gauss_pts) {
  
         if (normalsAtGaussPtsRawPtr->size1() != nb_gauss_pts)
           SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                   "normalsAtGaussPtsRawPtr has inconsistent number of "
                   "integration "
                   "points");
  
         const auto nb_base_functions = base_functions.size2() / 3;
         CHKERR apply_transform_nonlinear_geometry(base, nb_gauss_pts,
                                                   nb_base_functions);
       }
     }
   } else {
     for (int b = AINSWORTH_LEGENDRE_BASE; b != LASTBASE; b++) {
  
       FieldApproximationBase base = static_cast<FieldApproximationBase>(b);
       const auto &base_functions = data.getN(base);
       const auto nb_gauss_pts = base_functions.size1();
  
       if (nb_gauss_pts) {
         const auto nb_base_functions = base_functions.size2() / 3;
         CHKERR apply_transform_linear_geometry(base, nb_gauss_pts,
                                                nb_base_functions);
       }
     }
   }
  
   MoFEMFunctionReturn(0);
 }

Member Data Documentation

◆ normalRawPtr

const VectorDouble* MoFEM::OpSetContravariantPiolaTransformOnFace::normalRawPtr

Definition at line 419 of file DataOperators.hpp.

◆ normalsAtGaussPtsRawPtr

const MatrixDouble* MoFEM::OpSetContravariantPiolaTransformOnFace::normalsAtGaussPtsRawPtr

Definition at line 420 of file DataOperators.hpp.

◆ normalShift

int MoFEM::OpSetContravariantPiolaTransformOnFace::normalShift

Shift in vector for linear geometry.

Normal can have size larger than three, for example normal for contact prism and flat prims element have six comonents, for top and bottom triangle of the prims.

Definition at line 431 of file DataOperators.hpp.

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

src/finite_elements/DataOperators.hpp
src/finite_elements/impl/DataOperators.cpp

Public Member Functions

Public Attributes

Additional Inherited Members