OpCalculateMassMatrix Struct Reference

Assemble mass matrix for elastic element TODO: CHANGE FORMULA *. More...

#include "users_modules/basic_finite_elements/src/HookeElement.hpp"

Inheritance diagram for OpCalculateMassMatrix:

Collaboration diagram for OpCalculateMassMatrix:

Public Member Functions
	OpCalculateMassMatrix (const std::string row_field, const std::string col_field, BlockData &data, MassBlockData &mass_data, boost::shared_ptr< DataAtIntegrationPts > &common_data, bool symm=true)
PetscErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)

Public Attributes
MatrixDouble	locK
MatrixDouble	translocK
BlockData &	dAta
MassBlockData &	massData
boost::shared_ptr< DataAtIntegrationPts >	commonData

Detailed Description

Assemble mass matrix for elastic element TODO: CHANGE FORMULA *.

*

\[ {\bf{M}} = \int\limits_\Omega \]

Examples

mofem/users_modules/basic_finite_elements/src/HookeElement.hpp.

Definition at line 212 of file HookeElement.hpp.

Constructor & Destructor Documentation

OpCalculateMassMatrix()

OpCalculateMassMatrix::OpCalculateMassMatrix ( const std::string  row_field, const std::string  col_field, BlockData &  data, MassBlockData &  mass_data, boost::shared_ptr< DataAtIntegrationPts > &  common_data, bool  symm = true  )

inline

Definition at line 222 of file HookeElement.hpp.

        : VolumeElementForcesAndSourcesCore::UserDataOperator(
              row_field, col_field, OPROWCOL, symm),
          commonData(common_data), dAta(data), massData(mass_data) {}

Member Function Documentation

doWork()

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

inline

Definition at line 231 of file HookeElement.hpp.

                                                              {
      MoFEMFunctionBegin;
 
      auto get_tensor2 = [](MatrixDouble &m, const int r, const int c) {
        return FTensor::Tensor2<double *, 3, 3>(
            &m(3 * r + 0, 3 * c + 0), &m(3 * r + 0, 3 * c + 1),
            &m(3 * r + 0, 3 * c + 2), &m(3 * r + 1, 3 * c + 0),
            &m(3 * r + 1, 3 * c + 1), &m(3 * r + 1, 3 * c + 2),
            &m(3 * r + 2, 3 * c + 0), &m(3 * r + 2, 3 * c + 1),
            &m(3 * r + 2, 3 * c + 2));
      };
 
      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(getFEEntityHandle()) == dAta.tEts.end()) {
        MoFEMFunctionReturnHot(0);
      }
      if (massData.tEts.find(getFEEntityHandle()) == massData.tEts.end()) {
        MoFEMFunctionReturnHot(0);
      }
 
      const bool diagonal_block =
          (row_type == col_type) && (row_side == col_side);
      // get number of integration points
      // Set size can clear local tangent matrix
      locK.resize(row_nb_dofs, col_nb_dofs, false);
      locK.clear();
 
      const int row_nb_gauss_pts = row_data.getN().size1();
      const int row_nb_base_functions = row_data.getN().size2();
 
      FTensor::Index<'i', 3> i;
      FTensor::Index<'j', 3> j;
      FTensor::Index<'k', 3> k;
      FTensor::Index<'l', 3> l;
 
      double density = massData.rho0;
 
      // get integration weights
      auto t_w = getFTensor0IntegrationWeight();
 
      // integrate local matrix for entity block
      for (int gg = 0; gg != row_nb_gauss_pts; gg++) {
 
        auto t_row_base_func = row_data.getFTensor0N(gg, 0);
 
        // Get volume and integration weight
        double w = getVolume() * t_w;
 
        for (int row_bb = 0; row_bb != row_nb_dofs / 3; row_bb++) {
          auto t_col_base_func = col_data.getFTensor0N(gg, 0);
          for (int col_bb = 0; col_bb != col_nb_dofs / 3; col_bb++) {
            auto t_assemble = get_tensor2(locK, row_bb, col_bb);
            t_assemble(i, j) += density * t_row_base_func * t_col_base_func * w;
            // Next base function for column
            ++t_col_base_func;
          }
          // Next base function for row
          ++t_row_base_func;
        }
        // Next integration point for getting weight
        ++t_w;
      }
 
      CHKERR MatSetValues(getKSPB(), row_data, col_data, &locK(0, 0),
                          ADD_VALUES);
 
      // is symmetric
      if (row_type != col_type || row_side != col_side) {
        translocK.resize(col_nb_dofs, row_nb_dofs, false);
        noalias(translocK) = trans(locK);
 
        CHKERR MatSetValues(getKSPB(), col_data, row_data, &translocK(0, 0),
                            ADD_VALUES);
      }
 
      MoFEMFunctionReturn(0);
    }

Member Data Documentation

commonData

boost::shared_ptr<DataAtIntegrationPts> OpCalculateMassMatrix::commonData

Definition at line 220 of file HookeElement.hpp.

dAta

BlockData& OpCalculateMassMatrix::dAta

Definition at line 217 of file HookeElement.hpp.

locK

MatrixDouble OpCalculateMassMatrix::locK

Definition at line 215 of file HookeElement.hpp.

massData

MassBlockData& OpCalculateMassMatrix::massData

Definition at line 218 of file HookeElement.hpp.

translocK

MatrixDouble OpCalculateMassMatrix::translocK

Definition at line 216 of file HookeElement.hpp.

---

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

• users_modules/basic_finite_elements/src/HookeElement.hpp