#include "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.

virtual MoFEMErrorCode	iNtegrate (EntitiesFieldData::EntData &data)=0
	Class dedicated to integrate operator.

virtual MoFEMErrorCode	aSsemble (EntitiesFieldData::EntData &data)=0
	Class dedicated to assemble operator to global system vector.

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

Protected Member Functions inherited from PoissonExample::OpF
MoFEMErrorCode	iNtegrate (EntitiesFieldData::EntData &data)
	Integrate local entity vector.

MoFEMErrorCode	aSsemble (EntitiesFieldData::EntData &data)
	assemble local entity vector to the global right hand side

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

int	nbIntegrationPts
	number of integration points

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 662 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

Definition at line 664 of file PoissonOperators.hpp.

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

a

constexpr double a

Definition approx_sphere.cpp:30

PoissonExample::OpF::OpF

OpF(FSource f_source)

Definition PoissonOperators.hpp:225

PoissonExample::OpResF_Domain::gradVals

boost::shared_ptr< MatrixDouble > gradVals

Definition PoissonOperators.hpp:726

PoissonExample::OpResF_Domain::fieldVals

boost::shared_ptr< VectorDouble > fieldVals

Definition PoissonOperators.hpp:725

PoissonExample::OpResF_Domain::A

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

Definition PoissonOperators.hpp:724

Member Function Documentation

◆ iNtegrate()

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

inlineprotected

Integrate local entity vector.

Parameters

data	entity data on element row

Returns: error code

Examples: mofem/tutorials/cor-2to5/src/PoissonOperators.hpp.

Definition at line 677 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);
  }