Calculate trace of vector (Hdiv/Hcurl) space. More...

#include <src/finite_elements/UserDataOperators.hpp>

Inheritance diagram for MoFEM::OpCalculateHVecTensorTrace< Tensor_Dim, OpBase >:

Collaboration diagram for MoFEM::OpCalculateHVecTensorTrace< Tensor_Dim, OpBase >:

Public Member Functions
	OpCalculateHVecTensorTrace (const std::string field_name, boost::shared_ptr< MatrixDouble > data_ptr, boost::shared_ptr< double > scale_ptr, const EntityType zero_type=MBEDGE, const int zero_side=0)

	OpCalculateHVecTensorTrace (const std::string field_name, boost::shared_ptr< MatrixDouble > data_ptr, const EntityType zero_type=MBEDGE, const int zero_side=0)

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

Private Attributes
boost::shared_ptr< MatrixDouble >	dataPtr

boost::shared_ptr< double >	scalePtr

const EntityHandle	zeroType

const int	zeroSide

FTensor::Index< 'i', Tensor_Dim >	i

FTensor::Index< 'j', Tensor_Dim >	j

Detailed Description

template<int Tensor_Dim, typename OpBase>
struct MoFEM::OpCalculateHVecTensorTrace< Tensor_Dim, OpBase >

Calculate trace of vector (Hdiv/Hcurl) space.

Template Parameters

Tensor_Dim
OpBase

Examples: EshelbianPlasticity.cpp, and tensor_divergence_operator.cpp.

Definition at line 3184 of file UserDataOperators.hpp.

Constructor & Destructor Documentation

◆ OpCalculateHVecTensorTrace() [1/2]

template<int Tensor_Dim, typename OpBase >

MoFEM::OpCalculateHVecTensorTrace< Tensor_Dim, OpBase >::OpCalculateHVecTensorTrace	(	const std::string	field_name,
		boost::shared_ptr< MatrixDouble >	data_ptr,
		boost::shared_ptr< double >	scale_ptr,
		const EntityType	zero_type = `MBEDGE`,
		const int	zero_side = `0`
	)

inline

Definition at line 3186 of file UserDataOperators.hpp.

       : OpBase(field_name, OpBase::OPROW), dataPtr(data_ptr),
         scalePtr(scale_ptr), zeroType(zero_type), zeroSide(zero_side) {
     if (!dataPtr)
       THROW_MESSAGE("Pointer is not set");
   }

◆ OpCalculateHVecTensorTrace() [2/2]

template<int Tensor_Dim, typename OpBase >

MoFEM::OpCalculateHVecTensorTrace< Tensor_Dim, OpBase >::OpCalculateHVecTensorTrace	(	const std::string	field_name,
		boost::shared_ptr< MatrixDouble >	data_ptr,
		const EntityType	zero_type = `MBEDGE`,
		const int	zero_side = `0`
	)

inline

Definition at line 3197 of file UserDataOperators.hpp.

3201 : OpCalculateHVecTensorTrace(field_name, data_ptr, nullptr, zero_type,

3202 zero_side) {}

Member Function Documentation

◆ doWork()

template<int Tensor_Dim, typename OpBase >

MoFEMErrorCode MoFEM::OpCalculateHVecTensorTrace< Tensor_Dim, OpBase >::doWork	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

inline

Definition at line 3204 of file UserDataOperators.hpp.

                                                         {
     MoFEMFunctionBegin;
     const size_t nb_integration_points = OpBase::getGaussPts().size2();
     if (type == zeroType && side == 0) {
       dataPtr->resize(Tensor_Dim, nb_integration_points, false);
       dataPtr->clear();
     }
     const size_t nb_dofs = data.getFieldData().size();
     if (nb_dofs) {
       double scale_val = (scalePtr) ? *scalePtr : 1.0;
       auto t_normal = OpBase::getFTensor1NormalsAtGaussPts();
       const size_t nb_base_functions = data.getN().size2() / 3;
       auto t_base = data.getFTensor1N<3>();
       auto t_data = getFTensor1FromMat<Tensor_Dim>(*dataPtr);
       for (size_t gg = 0; gg != nb_integration_points; ++gg) {
         FTensor::Tensor1<double, Tensor_Dim> t_normalized_normal;
         t_normalized_normal(j) = t_normal(j);
         t_normalized_normal.normalize();
         auto t_dof = data.getFTensor1FieldData<Tensor_Dim>();
         size_t bb = 0;
         for (; bb != nb_dofs / Tensor_Dim; ++bb) {
           t_data(i) +=
               (scale_val * t_dof(i)) * (t_base(j) * t_normalized_normal(j));
           ++t_base;
           ++t_dof;
         }
         for (; bb < nb_base_functions; ++bb) {
           ++t_base;
         }
         ++t_data;
         ++t_normal;
       }
     }
     MoFEMFunctionReturn(0);
   }