MoFEM::OpSetContravariantPiolaTransformOnFace Struct Reference

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, DataForcesAndSourcesCore::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, DataForcesAndSourcesCore::EntData &row_data, DataForcesAndSourcesCore::EntData &col_data)
	Operator for bi-linear form, usually to calculate values on left hand side. More...
virtual MoFEMErrorCode	opLhs (DataForcesAndSourcesCore &row_data, DataForcesAndSourcesCore &col_data)
virtual MoFEMErrorCode	opRhs (DataForcesAndSourcesCore &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
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...

Detailed Description

transform Hdiv base fluxes from reference element to physical triangle

Definition at line 506 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
	)

Definition at line 523 of file DataOperators.hpp.

      : normalRawPtr(&normal), normalsAtGaussPtsRawPtr(&normals_at_pts),
        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
	)

Definition at line 529 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, DataForcesAndSourcesCore::EntData &  data  )

virtual

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

Reimplemented from MoFEM::DataOperator.

Definition at line 896 of file DataOperators.cpp.

                                                                      {
  FTensor::Index<'i', 3> i;
  MoFEMFunctionBegin;

  if (type != MBTRI)
    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) {
      for (int bb = 0; bb != nb_base_functions; ++bb) {
        const auto v = t_base(0);
        const auto l2 = t_normal(i) * t_normal(i);
        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 509 of file DataOperators.hpp.

normalsAtGaussPtsRawPtr

const MatrixDouble* MoFEM::OpSetContravariantPiolaTransformOnFace::normalsAtGaussPtsRawPtr

Definition at line 510 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 521 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