#include "tutorials/cor-2to5/src/PoissonOperators.hpp"

Inheritance diagram for PoissonExample::OpKt:

Collaboration diagram for PoissonExample::OpKt:

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

Public Member Functions inherited from PoissonExample::OpK
	OpK (bool symm=true)

MoFEMErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
	Do calculations for give operator.

Protected Member Functions
MoFEMErrorCode	iNtegrate (EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
	Integrate grad-grad operator.

Protected Member Functions inherited from PoissonExample::OpK
virtual MoFEMErrorCode	aSsemble (EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
	Assemble local entity block matrix.

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

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

boost::shared_ptr< VectorDouble >	fieldVals

boost::shared_ptr< MatrixDouble >	gradVals

Protected Attributes inherited from PoissonExample::OpK
int	nbRows
	< error code

int	nbCols
	number if dof on column

int	nbIntegrationPts
	number of integration points

bool	isDiag
	true if this block is on diagonal

FTensor::Index< 'i', 3 >	i
	summit Index

MatrixDouble	locMat
	local entity block matrix

Detailed Description

Definition at line 588 of file PoissonOperators.hpp.

Constructor & Destructor Documentation

◆ OpKt()

PoissonExample::OpKt::OpKt	(	boost::function< double(const double)>	a,
		boost::function< double(const double)>	diff_a,
		boost::shared_ptr< VectorDouble > &	field_vals,
		boost::shared_ptr< MatrixDouble > &	grad_vals
	)

inline

Definition at line 590 of file PoissonOperators.hpp.

594 : OpK(false), A(a), diffA(diff_a), fieldVals(field_vals),

595 gradVals(grad_vals) {}

a

constexpr double a

Definition approx_sphere.cpp:30

OpK

Definition simple_elasticity.cpp:16

PoissonExample::OpKt::diffA

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

Definition PoissonOperators.hpp:657

PoissonExample::OpKt::gradVals

boost::shared_ptr< MatrixDouble > gradVals

Definition PoissonOperators.hpp:659

PoissonExample::OpKt::fieldVals

boost::shared_ptr< VectorDouble > fieldVals

Definition PoissonOperators.hpp:658

PoissonExample::OpKt::A

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

Definition PoissonOperators.hpp:656

Member Function Documentation

◆ iNtegrate()

MoFEMErrorCode PoissonExample::OpKt::iNtegrate	(	EntitiesFieldData::EntData &	row_data,
		EntitiesFieldData::EntData &	col_data
	)

inlineprotectedvirtual

Integrate grad-grad operator.

Parameters

row_data	row data (consist base functions on row entity)
col_data	column data (consist base functions on column entity)

Returns: error code

Reimplemented from PoissonExample::OpK.

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

Definition at line 604 of file PoissonOperators.hpp.

                                                                      {
    MoFEMFunctionBegin;
    // set size of local entity bock
    locMat.resize(nbRows, nbCols, false);
    // clear matrix
    locMat.clear();
    // get 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 function gradient on rows
    auto t_row_grad = row_data.getFTensor1DiffN<3>();
    // loop over integration points
    for (int gg = 0; gg != nbIntegrationPts; gg++) {
      // take into account Jacobian
      const double alpha = t_w * vol;
      const double beta = alpha * A(t_u);
      FTensor::Tensor1<double, 3> t_gamma;
      t_gamma(i) = (alpha * diffA(t_u)) * t_grad(i);
      // take fist element to local matrix
      FTensor::Tensor0<FTensor::PackPtr<double *, 1>> a(
          &*locMat.data().begin());
      // loop over rows base functions
      for (int rr = 0; rr != nbRows; rr++) {
        // get column base function
        auto t_col = col_data.getFTensor0N(gg, 0);
        // get column base functions gradient at gauss point gg
        auto t_col_grad = col_data.getFTensor1DiffN<3>(gg, 0);
        // loop over columns
        for (int cc = 0; cc != nbCols; cc++) {
          // calculate element of local matrix
          a += (t_row_grad(i) * beta) * t_col_grad(i) +
               t_row_grad(i) * (t_gamma(i) * t_col);
          ++t_col;      // move to next base function
          ++t_col_grad; // move to another gradient of base function on column
          ++a;          // move to another element of local matrix in column
        }
        ++t_row_grad; // move to another element of gradient of base function on
                      // row
      }
      ++t_w;    // move to another integration weight
      ++t_u;    // move to next value at integration point
      ++t_grad; // move to next gradient value
    }
    MoFEMFunctionReturn(0);
  }