PoissonExample::OpKt Struct Reference

#include <users_modules/basic_finite_elements/poisson/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, DataForcesAndSourcesCore::EntData &row_data, DataForcesAndSourcesCore::EntData &col_data)
	Do calculations for give operator. More...

Protected Member Functions
MoFEMErrorCode	iNtegrate (DataForcesAndSourcesCore::EntData &row_data, DataForcesAndSourcesCore::EntData &col_data)
	Integrate grad-grad operator. More...
Protected Member Functions inherited from PoissonExample::OpK
virtual MoFEMErrorCode	aSsemble (DataForcesAndSourcesCore::EntData &row_data, DataForcesAndSourcesCore::EntData &col_data)
	Assemble local entity block matrix. More...

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 More...
int	nbCols
	number if dof on column More...
int	nbIntegrationPts
	number of integration points More...
bool	isDiag
	true if this block is on diagonal More...
FTensor::Index< 'i', 3 >	i
	summit Index More...
MatrixDouble	locMat
	local entity block matrix More...

Detailed Description

Definition at line 598 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
	)

Definition at line 600 of file PoissonOperators.hpp.

      : OpK(false), A(a), diffA(diff_a), fieldVals(field_vals),
        gradVals(grad_vals) {}

Member Function Documentation

iNtegrate()

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

protectedvirtual

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.

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

Member Data Documentation

A

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

protected

Definition at line 666 of file PoissonOperators.hpp.

diffA

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

protected

Definition at line 667 of file PoissonOperators.hpp.

fieldVals

boost::shared_ptr<VectorDouble> PoissonExample::OpKt::fieldVals

protected

Definition at line 668 of file PoissonOperators.hpp.

gradVals

boost::shared_ptr<MatrixDouble> PoissonExample::OpKt::gradVals

protected

Definition at line 669 of file PoissonOperators.hpp.

---

The documentation for this struct was generated from the following file:

• users_modules/basic_finite_elements/poisson/src/PoissonOperators.hpp