#include <users_modules/tutorials/cor-2to5/src/PoissonOperators.hpp>

Inheritance diagram for PoissonExample::OpResF_Domain:

Collaboration diagram for PoissonExample::OpResF_Domain:

Public Member Functions
	OpResF_Domain (FSource f_source, boost::function< double(const double)> a, boost::shared_ptr< VectorDouble > &field_vals, boost::shared_ptr< MatrixDouble > &grad_vals)

Public Member Functions inherited from PoissonExample::OpF
	OpF (FSource f_source)

Public Member Functions inherited from PoissonExample::OpBaseRhs< VolumeElementForcesAndSourcesCore::UserDataOperator >
	OpBaseRhs (const std::string field_name)

MoFEMErrorCode	doWork (int row_side, EntityType row_type, EntitiesFieldData::EntData &row_data)
	This function is called by finite element. More...

Protected Member Functions
MoFEMErrorCode	iNtegrate (EntitiesFieldData::EntData &data)
	Integrate local entity vector. More...

Protected Member Functions inherited from PoissonExample::OpF
MoFEMErrorCode	aSsemble (EntitiesFieldData::EntData &data)
	assemble local entity vector to the global right hand side More...

Protected Attributes
FTensor::Index< 'i', 3 >	i

boost::function< double(const double)>	A

boost::shared_ptr< VectorDouble >	fieldVals

boost::shared_ptr< MatrixDouble >	gradVals

Protected Attributes inherited from PoissonExample::OpF
FTensor::Number< 0 >	NX

FTensor::Number< 1 >	NY

FTensor::Number< 2 >	NZ

FSource	fSource

VectorDouble	locVec

Protected Attributes inherited from PoissonExample::OpBaseRhs< VolumeElementForcesAndSourcesCore::UserDataOperator >
int	nbRows
	< error code More...

int	nbIntegrationPts
	number of integration points More...

Additional Inherited Members
Public Types inherited from PoissonExample::OpF
typedef boost::function< double(const double, const double, const double)>	FSource

Detailed Description

Definition at line 659 of file PoissonOperators.hpp.

Constructor & Destructor Documentation

◆ OpResF_Domain()

PoissonExample::OpResF_Domain::OpResF_Domain	(	FSource	f_source,
		boost::function< double(const double)>	a,
		boost::shared_ptr< VectorDouble > &	field_vals,
		boost::shared_ptr< MatrixDouble > &	grad_vals
	)

inline

Examples: PoissonOperators.hpp.

Definition at line 661 of file PoissonOperators.hpp.

664 : OpF(f_source), A(a), fieldVals(field_vals), gradVals(grad_vals) {}

Member Function Documentation

◆ iNtegrate()

MoFEMErrorCode PoissonExample::OpResF_Domain::iNtegrate ( EntitiesFieldData::EntData & data )

inlineprotectedvirtual

Integrate local entity vector.

Parameters

data	entity data on element row

Returns: error code

Reimplemented from PoissonExample::OpF.

Examples: PoissonOperators.hpp.

Definition at line 674 of file PoissonOperators.hpp.

                                                            {
     MoFEMFunctionBegin;
     // set size of local vector
     locVec.resize(nbRows, false);
     // clear local entity vector
     locVec.clear();
     // get finite element volume
     double vol = getVolume();
     // get integration weights
     auto t_w = getFTensor0IntegrationWeight();
     // get solution at integration point
     auto t_u = getFTensor0FromVec(*fieldVals);
     // get solution at integration point
     auto t_grad = getFTensor1FromMat<3>(*gradVals);
     // get base functions on entity
     auto t_v = data.getFTensor0N();
     // get base function gradient on rows
     auto t_v_grad = data.getFTensor1DiffN<3>();
     // get coordinates at integration points
     auto t_coords = getFTensor1CoordsAtGaussPts();
     // loop over all integration points
     for (int gg = 0; gg != nbIntegrationPts; gg++) {
       // evaluate constant term
       const double alpha = vol * t_w;
       const double source_term =
           alpha * fSource(t_coords(NX), t_coords(NY), t_coords(NZ));
       FTensor::Tensor1<double, 3> grad_term;
       grad_term(i) = (alpha * A(t_u)) * t_grad(i);
       // get element of local vector
       FTensor::Tensor0<FTensor::PackPtr<double *, 1>> t_a(
           &*locVec.data().begin());
       // loop over base functions
       for (int rr = 0; rr != nbRows; rr++) {
         // add to local vector source term
         t_a += t_v_grad(i) * grad_term(i) + t_v * source_term;
         ++t_a;      // move to next element of local vector
         ++t_v;      // move to next base function
         ++t_v_grad; // move to next gradient of base function
       }
       ++t_w;      // move to next integration weights
       ++t_u;      // move to next value
       ++t_grad;   // move to next gradient value
       ++t_coords; // move to next physical coordinates at integration point
     }
     MoFEMFunctionReturn(0);
   }