Operator calculate source term,. More...

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

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.

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

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

int	nbIntegrationPts
	number of integration points

Detailed Description

Operator calculate source term,.

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

Definition at line 219 of file PoissonOperators.hpp.

Member Typedef Documentation

◆ FSource

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

Examples: PoissonOperators.hpp.

Definition at line 223 of file PoissonOperators.hpp.

Constructor & Destructor Documentation

◆ OpF()

PoissonExample::OpF::OpF ( FSource f_source )

inline

Examples: PoissonOperators.hpp.

Definition at line 225 of file PoissonOperators.hpp.

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

227 fSource(f_source) {}

PoissonExample::OpF::fSource

FSource fSource

Definition PoissonOperators.hpp:233

Member Function Documentation

◆ aSsemble()

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

inlineprotected

assemble local entity vector to the global right hand side

Parameters

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

Returns: error code

Examples: PoissonOperators.hpp.

Definition at line 282 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_NULLPTR ? 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 )

inlineprotected

Integrate local entity vector.

Parameters

data	entity data on element row

Returns: error code

Examples: PoissonOperators.hpp.

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