Operator calculate source term,. More...

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

Inheritance diagram for PoissonExample::OpF:

Collaboration diagram for PoissonExample::OpF:

Public Types
typedef boost::function< double(const double, const double, const double)>	FSource

Public Member Functions
	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...

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

Protected Attributes
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...

Detailed Description

Operator calculate source term,.

\[ \mathbf{F} = \int_\Omega \boldsymbol\phi f \textrm{d}\Omega \]

Definition at line 216 of file PoissonOperators.hpp.

Member Typedef Documentation

◆ FSource

typedef boost::function<double(const double, const double, const double)> PoissonExample::OpF::FSource

Examples: PoissonOperators.hpp.

Definition at line 220 of file PoissonOperators.hpp.

Constructor & Destructor Documentation

◆ OpF()

PoissonExample::OpF::OpF ( FSource f_source )

inline

Examples: PoissonOperators.hpp.

Definition at line 222 of file PoissonOperators.hpp.

223 : OpBaseRhs<VolumeElementForcesAndSourcesCore::UserDataOperator>("U"),

224 fSource(f_source) {}

Member Function Documentation

◆ aSsemble()

MoFEMErrorCode PoissonExample::OpF::aSsemble ( EntitiesFieldData::EntData & data )

inlineprotectedvirtual

assemble local entity vector to the global right hand side

Parameters

data	entity data, i.e. global indices of local vector

Returns: error code

Implements PoissonExample::OpBaseRhs< VolumeElementForcesAndSourcesCore::UserDataOperator >.

Examples: PoissonOperators.hpp.

Definition at line 279 of file PoissonOperators.hpp.

                                                           {
     MoFEMFunctionBegin;
     // get global indices of local vector
     const int *indices = &*data.getIndices().data().begin();
     // get values from local vector
     const double *vals = &*locVec.data().begin();
     Vec f = getFEMethod()->ksp_f != PETSC_NULL ? getFEMethod()->ksp_f
                                                : getFEMethod()->snes_f;
     // assemble vector
     CHKERR VecSetValues(f, nbRows, indices, vals, ADD_VALUES);
     MoFEMFunctionReturn(0);
   }

◆ iNtegrate()

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

inlineprotectedvirtual

Integrate local entity vector.

Parameters

data	entity data on element row

Returns: error code

Implements PoissonExample::OpBaseRhs< VolumeElementForcesAndSourcesCore::UserDataOperator >.

Reimplemented in PoissonExample::OpResF_Domain.

Examples: PoissonOperators.hpp.

Definition at line 239 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 base functions on entity
     auto t_v = data.getFTensor0N();
     // 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 * fSource(t_coords(NX), t_coords(NY), t_coords(NZ));
       // 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 -= alpha * t_v;
         ++t_a; // move to next element of local vector
         ++t_v; // move to next base function
       }
       ++t_w;      // move to next integration weight
       ++t_coords; // move to next physical coordinates at integration point
     }
     MoFEMFunctionReturn(0);
   }