ConvectiveMassElement::OpMassLhs_dM_dv Struct Reference

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

Inheritance diagram for ConvectiveMassElement::OpMassLhs_dM_dv:

Collaboration diagram for ConvectiveMassElement::OpMassLhs_dM_dv:

Public Member Functions
	OpMassLhs_dM_dv (const std::string vel_field, const std::string field_name, BlockData &data, CommonData &common_data, Range *forcesonlyonentities_ptr=NULL)
virtual MoFEMErrorCode	getJac (EntitiesFieldData::EntData &col_data, int gg)
MoFEMErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)

Public Attributes
BlockData &	dAta
CommonData &	commonData
Range	forcesOnlyOnEntities
MatrixDouble	k
MatrixDouble	jac

Detailed Description

Definition at line 222 of file ConvectiveMassElement.hpp.

Constructor & Destructor Documentation

OpMassLhs_dM_dv()

ConvectiveMassElement::OpMassLhs_dM_dv::OpMassLhs_dM_dv	(	const std::string	vel_field,
		const std::string	field_name,
		BlockData &	data,
		CommonData &	common_data,
		Range *	forcesonlyonentities_ptr = NULL
	)

Definition at line 440 of file ConvectiveMassElement.cpp.

    : VolumeElementForcesAndSourcesCore::UserDataOperator(
          vel_field, field_name,
          ForcesAndSourcesCore::UserDataOperator::OPROWCOL),
      dAta(data), commonData(common_data) {
  sYmm = false;
  if (forcesonlyonentities_ptr != NULL) {
    forcesOnlyOnEntities = *forcesonlyonentities_ptr;
  }
}

Member Function Documentation

doWork()

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

Definition at line 522 of file ConvectiveMassElement.cpp.

                                        {
  MoFEMFunctionBeginHot;
 
  if (dAta.tEts.find(getNumeredEntFiniteElementPtr()->getEnt()) ==
      dAta.tEts.end()) {
    MoFEMFunctionReturnHot(0);
  }
 
  int nb_row = row_data.getIndices().size();
  int nb_col = col_data.getIndices().size();
  if (nb_row == 0)
    MoFEMFunctionReturnHot(0);
  if (nb_col == 0)
    MoFEMFunctionReturnHot(0);
 
  auto base = row_data.getFTensor0N();
  int nb_base_functions = row_data.getN().size2();
 
  {
 
    k.resize(nb_row, nb_col);
    k.clear();
    jac.resize(3, nb_col);
 
    for (unsigned int gg = 0; gg < row_data.getN().size1(); gg++) {
 
      try {
        CHKERR getJac(col_data, gg);
      } catch (const std::exception &ex) {
        std::ostringstream ss;
        ss << "throw in method: " << ex.what() << std::endl;
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "%s",
                ss.str().c_str());
      }
 
      FTensor::Index<'i', 3> i;
      FTensor::Index<'j', 3> j;
 
      {
        int dd1 = 0;
        // integrate element stiffness matrix
        for (; dd1 < nb_row / 3; dd1++) {
          FTensor::Tensor2<double *, 3, 3> t_jac(
              &jac(0, 0), &jac(0, 1), &jac(0, 2), &jac(1, 0), &jac(1, 1),
              &jac(1, 2), &jac(2, 0), &jac(2, 1), &jac(2, 2), 3);
          for (int dd2 = 0; dd2 < nb_col / 3; dd2++) {
            FTensor::Tensor2<double *, 3, 3> t_k(
                &k(3 * dd1 + 0, 3 * dd2 + 0), &k(3 * dd1 + 0, 3 * dd2 + 1),
                &k(3 * dd1 + 0, 3 * dd2 + 2), &k(3 * dd1 + 1, 3 * dd2 + 0),
                &k(3 * dd1 + 1, 3 * dd2 + 1), &k(3 * dd1 + 1, 3 * dd2 + 2),
                &k(3 * dd1 + 2, 3 * dd2 + 0), &k(3 * dd1 + 2, 3 * dd2 + 1),
                &k(3 * dd1 + 2, 3 * dd2 + 2));
            t_k(i, j) += base * t_jac(i, j);
            ++t_jac;
          }
          ++base;
          // for(int rr1 = 0;rr1<3;rr1++) {
          //   for(int dd2 = 0;dd2<nb_col;dd2++) {
          //     k(3*dd1+rr1,dd2) += row_data.getN()(gg,dd1)*jac(rr1,dd2);
          //   }
          // }
        }
        for (; dd1 != nb_base_functions; dd1++) {
          ++base;
        }
      }
    }
 
    if (!forcesOnlyOnEntities.empty()) {
      VectorInt indices = row_data.getIndices();
      VectorDofs &dofs = row_data.getFieldDofs();
      VectorDofs::iterator dit = dofs.begin();
      for (int ii = 0; dit != dofs.end(); dit++, ii++) {
        if (forcesOnlyOnEntities.find((*dit)->getEnt()) ==
            forcesOnlyOnEntities.end()) {
          indices[ii] = -1;
        }
      }
      CHKERR MatSetValues(getFEMethod()->ts_B, nb_row, &indices[0], nb_col,
                          &col_data.getIndices()[0], &k(0, 0), ADD_VALUES);
    } else {
      CHKERR MatSetValues(getFEMethod()->ts_B, nb_row,
                          &row_data.getIndices()[0], nb_col,
                          &col_data.getIndices()[0], &k(0, 0), ADD_VALUES);
    }
  }
  MoFEMFunctionReturnHot(0);
}

getJac()

MoFEMErrorCode ConvectiveMassElement::OpMassLhs_dM_dv::getJac ( EntitiesFieldData::EntData &  col_data, int  gg  )

virtual

Reimplemented in ConvectiveMassElement::OpMassLhs_dM_dx, ConvectiveMassElement::OpMassLhs_dM_dX, ConvectiveMassElement::OpVelocityLhs_dV_dv, ConvectiveMassElement::OpVelocityLhs_dV_dx, ConvectiveMassElement::OpVelocityLhs_dV_dX, ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumLhs_dv, ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumLhs_dx, and ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumLhs_dX.

Definition at line 453 of file ConvectiveMassElement.cpp.

                                                {
  MoFEMFunctionBeginHot;
  int nb_col = col_data.getIndices().size();
  jac.clear();
  if (!nb_col)
    MoFEMFunctionReturnHot(0);
  FTensor::Index<'i', 3> i;
  FTensor::Index<'j', 3> j;
  FTensor::Index<'k', 3> k;
  FTensor::Tensor2<double *, 3, 3> t_jac(&jac(0, 0), &jac(0, 1), &jac(0, 2),
                                         &jac(1, 0), &jac(1, 1), &jac(1, 2),
                                         &jac(2, 0), &jac(2, 1), &jac(2, 2), 3);
  FTensor::Tensor2<double *, 3, 3> t_mass1(
      &commonData.jacMass[gg](0, 0), &commonData.jacMass[gg](0, 1),
      &commonData.jacMass[gg](0, 2), &commonData.jacMass[gg](1, 0),
      &commonData.jacMass[gg](1, 1), &commonData.jacMass[gg](1, 2),
      &commonData.jacMass[gg](2, 0), &commonData.jacMass[gg](2, 1),
      &commonData.jacMass[gg](2, 2));
  double *base_ptr = const_cast<double *>(&col_data.getN(gg)[0]);
  FTensor::Tensor0<double *> base(base_ptr, 1);
  if (commonData.dataAtGaussPts["DOT_" + commonData.meshPositions].size() ==
      0) {
    for (int dd = 0; dd < nb_col / 3; dd++) {
      t_jac(i, j) += t_mass1(i, j) * base * getFEMethod()->ts_a;
      ++base;
      ++t_jac;
    }
  } else {
    const int s = 3 + 9;
    FTensor::Tensor3<double *, 3, 3, 3> t_mass3(
        // T* d000, T* d001, T* d002,
        // T* d010, T* d011, T* d012,
        // T* d020, T* d021, T* d022,
        // T* d100, T* d101, T* d102,
        // T* d110, T* d111, T* d112,
        // T* d120, T* d121, T* d122,
        // T* d200, T* d201, T* d202,
        // T* d210, T* d211, T* d212,
        // T* d220, T* d221, T* d222,
        &commonData.jacMass[gg](0, s + 0), &commonData.jacMass[gg](0, s + 1),
        &commonData.jacMass[gg](0, s + 2), &commonData.jacMass[gg](0, s + 3),
        &commonData.jacMass[gg](0, s + 4), &commonData.jacMass[gg](0, s + 5),
        &commonData.jacMass[gg](0, s + 6), &commonData.jacMass[gg](0, s + 7),
        &commonData.jacMass[gg](0, s + 8), &commonData.jacMass[gg](1, s + 0),
        &commonData.jacMass[gg](1, s + 1), &commonData.jacMass[gg](1, s + 2),
        &commonData.jacMass[gg](1, s + 3), &commonData.jacMass[gg](1, s + 4),
        &commonData.jacMass[gg](1, s + 5), &commonData.jacMass[gg](1, s + 6),
        &commonData.jacMass[gg](1, s + 7), &commonData.jacMass[gg](1, s + 8),
        &commonData.jacMass[gg](2, s + 0), &commonData.jacMass[gg](2, s + 1),
        &commonData.jacMass[gg](2, s + 2), &commonData.jacMass[gg](2, s + 3),
        &commonData.jacMass[gg](2, s + 4), &commonData.jacMass[gg](2, s + 5),
        &commonData.jacMass[gg](2, s + 6), &commonData.jacMass[gg](2, s + 7),
        &commonData.jacMass[gg](2, s + 8));
 
    double *diff_ptr =
        const_cast<double *>(&(col_data.getDiffN(gg, nb_col / 3)(0, 0)));
    FTensor::Tensor1<double *, 3> diff(diff_ptr, &diff_ptr[1], &diff_ptr[2], 3);
    for (int dd = 0; dd < nb_col / 3; dd++) {
      t_jac(i, j) += t_mass1(i, j) * base * getFEMethod()->ts_a;
      t_jac(i, j) += t_mass3(i, j, k) * diff(k);
      ++base;
      ++diff;
      ++t_jac;
    }
  }
  MoFEMFunctionReturnHot(0);
}

Member Data Documentation

commonData

CommonData& ConvectiveMassElement::OpMassLhs_dM_dv::commonData

Definition at line 227 of file ConvectiveMassElement.hpp.

dAta

BlockData& ConvectiveMassElement::OpMassLhs_dM_dv::dAta

Definition at line 226 of file ConvectiveMassElement.hpp.

forcesOnlyOnEntities

Range ConvectiveMassElement::OpMassLhs_dM_dv::forcesOnlyOnEntities

Definition at line 228 of file ConvectiveMassElement.hpp.

jac

MatrixDouble ConvectiveMassElement::OpMassLhs_dM_dv::jac

Definition at line 234 of file ConvectiveMassElement.hpp.

k

MatrixDouble ConvectiveMassElement::OpMassLhs_dM_dv::k

Definition at line 234 of file ConvectiveMassElement.hpp.

---

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

• users_modules/basic_finite_elements/src/ConvectiveMassElement.hpp
• users_modules/basic_finite_elements/src/impl/ConvectiveMassElement.cpp