#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
	)

Examples: PoissonOperators.hpp.

Definition at line 600 of file PoissonOperators.hpp.

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

605 gradVals(grad_vals) {}

PoissonExample::OpK::OpK

OpK(bool symm=true)

Definition: PoissonOperators.hpp:39

PoissonExample::OpKt::A

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

Definition: PoissonOperators.hpp:666

PoissonExample::OpKt::diffA

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

Definition: PoissonOperators.hpp:667

PoissonExample::OpKt::fieldVals

boost::shared_ptr< VectorDouble > fieldVals

Definition: PoissonOperators.hpp:668

PoissonExample::OpKt::gradVals

boost::shared_ptr< MatrixDouble > gradVals

Definition: PoissonOperators.hpp:669

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.

Examples: PoissonOperators.hpp.

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);
   }