Assemble G *. More...

#include <tutorials/cor-7/src/ElasticityMixedFormulation.hpp>

Inheritance diagram for OpAssembleG:

Collaboration diagram for OpAssembleG:

Public Member Functions
	OpAssembleG (DataAtIntegrationPts &common_data, BlockData &data)

PetscErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)

Public Attributes
DataAtIntegrationPts &	commonData

MatrixDouble	locG

BlockData &	dAta

Detailed Description

Assemble G *.

\[ {\bf{G}} = - \int\limits_\Omega {{{\bf{B}}^T}{\bf m}{{\bf{N}}_p}d\Omega } \]

Examples: elasticity_mixed_formulation.cpp, and ElasticityMixedFormulation.hpp.

Definition at line 215 of file ElasticityMixedFormulation.hpp.

Constructor & Destructor Documentation

◆ OpAssembleG()

OpAssembleG::OpAssembleG	(	DataAtIntegrationPts &	common_data,
		BlockData &	data
	)

inline

Examples: ElasticityMixedFormulation.hpp.

Definition at line 222 of file ElasticityMixedFormulation.hpp.

       : VolumeElementForcesAndSourcesCore::UserDataOperator(
             "U", "P", UserDataOperator::OPROWCOL),
         commonData(common_data), dAta(data) {
     sYmm = false;
   }

Member Function Documentation

◆ doWork()

PetscErrorCode OpAssembleG::doWork	(	int	row_side,
		int	col_side,
		EntityType	row_type,
		EntityType	col_type,
		EntitiesFieldData::EntData &	row_data,
		EntitiesFieldData::EntData &	col_data
	)

inline

Examples: ElasticityMixedFormulation.hpp.

Definition at line 229 of file ElasticityMixedFormulation.hpp.

                                                             {
  
     MoFEMFunctionBegin;
  
     const int row_nb_dofs = row_data.getIndices().size();
     if (!row_nb_dofs)
       MoFEMFunctionReturnHot(0);
     const int col_nb_dofs = col_data.getIndices().size();
     if (!col_nb_dofs)
       MoFEMFunctionReturnHot(0);
  
     if (dAta.tEts.find(getNumeredEntFiniteElementPtr()->getEnt()) ==
         dAta.tEts.end()) {
       MoFEMFunctionReturnHot(0);
     }
     commonData.getBlockData(dAta);
  
     // Set size can clear local tangent matrix
     locG.resize(row_nb_dofs, col_nb_dofs, false);
     locG.clear();
     const int row_nb_gauss_pts = row_data.getN().size1();
     if (!row_nb_gauss_pts)
       MoFEMFunctionReturnHot(0);
     const int row_nb_base_functions = row_data.getN().size2();
     auto row_diff_base_functions = row_data.getFTensor1DiffN<3>();
  
     FTensor::Tensor1<double, 3> t1;
     FTensor::Index<'i', 3> i;
     FTensor::Index<'j', 3> j;
  
     // INTEGRATION
     for (int gg = 0; gg != row_nb_gauss_pts; gg++) {
  
       // Get volume and integration weight
       double w = getVolume() * getGaussPts()(3, gg);
  
       int row_bb = 0;
       for (; row_bb != row_nb_dofs / 3; row_bb++) {
  
         t1(i) = w * row_diff_base_functions(i);
  
         auto base_functions = col_data.getFTensor0N(gg, 0);
         for (int col_bb = 0; col_bb != col_nb_dofs; col_bb++) {
  
           FTensor::Tensor1<double *, 3> k(&locG(3 * row_bb + 0, col_bb),
                                           &locG(3 * row_bb + 1, col_bb),
                                           &locG(3 * row_bb + 2, col_bb));
  
           k(i) += t1(i) * base_functions;
           ++base_functions;
         }
         ++row_diff_base_functions;
       }
       for (; row_bb != row_nb_base_functions; row_bb++) {
         ++row_diff_base_functions;
       }
     }
  
     CHKERR MatSetValues(getFEMethod()->ksp_B, row_nb_dofs,
                         &*row_data.getIndices().begin(), col_nb_dofs,
                         &*col_data.getIndices().begin(), &*locG.data().begin(),
                         ADD_VALUES);
  
     // ASSEMBLE THE TRANSPOSE
     locG = trans(locG);
     CHKERR MatSetValues(getFEMethod()->ksp_B, col_nb_dofs,
                         &*col_data.getIndices().begin(), row_nb_dofs,
                         &*row_data.getIndices().begin(), &*locG.data().begin(),
                         ADD_VALUES);
     MoFEMFunctionReturn(0);
   }