ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian Struct Reference

#include <users_modules/basic_finite_elements/src/ConvectiveMassElement.hpp>

Inheritance diagram for ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian:

Collaboration diagram for ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian:

Public Member Functions
	OpEshelbyDynamicMaterialMomentumJacobian (const std::string field_name, BlockData &data, CommonData &common_data, int tag, bool jacobian=true)
MoFEMErrorCode	doWork (int row_side, EntityType row_type, EntitiesFieldData::EntData &row_data)

Public Attributes
BlockData &	dAta
CommonData &	commonData
int	tAg
bool	jAcobian
bool	fieldDisp
VectorBoundedArray< adouble, 3 >	a
VectorBoundedArray< adouble, 3 >	v
VectorBoundedArray< adouble, 3 >	a_T
MatrixBoundedArray< adouble, 9 >	g
MatrixBoundedArray< adouble, 9 >	H
MatrixBoundedArray< adouble, 9 >	invH
MatrixBoundedArray< adouble, 9 >	h
MatrixBoundedArray< adouble, 9 >	F
MatrixBoundedArray< adouble, 9 >	G
VectorDouble	active

Detailed Description

Definition at line 347 of file ConvectiveMassElement.hpp.

Constructor & Destructor Documentation

OpEshelbyDynamicMaterialMomentumJacobian()

ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::OpEshelbyDynamicMaterialMomentumJacobian	(	const std::string	field_name,
		BlockData &	data,
		CommonData &	common_data,
		int	tag,
		bool	jacobian = true
	)

Definition at line 1234 of file ConvectiveMassElement.cpp.

    : VolumeElementForcesAndSourcesCore::UserDataOperator(
          field_name, ForcesAndSourcesCore::UserDataOperator::OPROW),
      dAta(data), commonData(common_data), tAg(tag), jAcobian(jacobian),
      fieldDisp(false) {}

Member Function Documentation

doWork()

MoFEMErrorCode ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::doWork	(	int	row_side,
		EntityType	row_type,
		EntitiesFieldData::EntData &	row_data
	)

Definition at line 1244 of file ConvectiveMassElement.cpp.

                                                                           {
  MoFEMFunctionBeginHot;
 
  if (dAta.tEts.find(getNumeredEntFiniteElementPtr()->getEnt()) ==
      dAta.tEts.end()) {
    MoFEMFunctionReturnHot(0);
  }
 
  // do it only once, no need to repeat this for edges,faces or tets
  if (row_type != MBVERTEX)
    MoFEMFunctionReturnHot(0);
 
  int nb_dofs = row_data.getIndices().size();
  if (nb_dofs == 0)
    MoFEMFunctionReturnHot(0);
 
  try {
 
    a.resize(3);
    v.resize(3);
    g.resize(3, 3);
    G.resize(3, 3);
    h.resize(3, 3);
    F.resize(3, 3);
    H.resize(3, 3);
    H.clear();
    invH.resize(3, 3);
    invH.clear();
    for (int dd = 0; dd < 3; dd++) {
      H(dd, dd) = 1;
      invH(dd, dd) = 1;
    }
 
    int nb_gauss_pts = row_data.getN().size1();
    commonData.valT.resize(nb_gauss_pts);
    commonData.jacTRowPtr.resize(nb_gauss_pts);
    commonData.jacT.resize(nb_gauss_pts);
 
    int nb_active_vars = 0;
    for (int gg = 0; gg < nb_gauss_pts; gg++) {
 
      if (gg == 0) {
 
        trace_on(tAg);
 
        for (int nn1 = 0; nn1 < 3; nn1++) { // 0
          a[nn1] <<=
              commonData.dataAtGaussPts["DOT_" + commonData.spatialVelocities]
                                       [gg][nn1];
          nb_active_vars++;
        }
 
        for (int nn1 = 0; nn1 < 3; nn1++) { // 3
          v[nn1] <<=
              commonData.dataAtGaussPts[commonData.spatialVelocities][gg][nn1];
          nb_active_vars++;
        }
        for (int nn1 = 0; nn1 < 3; nn1++) { // 3+3
          for (int nn2 = 0; nn2 < 3; nn2++) {
            g(nn1, nn2) <<=
                commonData.gradAtGaussPts[commonData.spatialVelocities][gg](
                    nn1, nn2);
            nb_active_vars++;
          }
        }
        for (int nn1 = 0; nn1 < 3; nn1++) { // 3+3+9
          for (int nn2 = 0; nn2 < 3; nn2++) {
            h(nn1, nn2) <<=
                commonData.gradAtGaussPts[commonData.spatialPositions][gg](nn1,
                                                                           nn2);
            nb_active_vars++;
            if (fieldDisp) {
              if (nn1 == nn2) {
                h(nn1, nn2) += 1;
              }
            }
          }
        }
        if (commonData.gradAtGaussPts[commonData.meshPositions].size() > 0) {
          for (int nn1 = 0; nn1 < 3; nn1++) { // 3+3+9+9
            for (int nn2 = 0; nn2 < 3; nn2++) {
              H(nn1, nn2) <<=
                  commonData.gradAtGaussPts[commonData.meshPositions][gg](nn1,
                                                                          nn2);
              nb_active_vars++;
            }
          }
        }
        adouble detH;
        detH = 1;
        if (commonData.gradAtGaussPts[commonData.meshPositions].size() > 0) {
          detH = determinantTensor3by3(H);
        }
        CHKERR invertTensor3by3(H, detH, invH);
 
        FTensor::Index<'i', 3> i;
        FTensor::Index<'j', 3> j;
        FTensor::Index<'k', 3> k;
 
        a_T.resize(3);
 
        auto t_h = getFTensor2FromArray3by3(h, FTensor::Number<0>(), 0);
        auto t_invH = getFTensor2FromArray3by3(invH, FTensor::Number<0>(), 0);
        auto t_F = getFTensor2FromArray3by3(F, FTensor::Number<0>(), 0);
        auto t_g = getFTensor2FromArray3by3(g, FTensor::Number<0>(), 0);
        auto t_G = getFTensor2FromArray3by3(G, FTensor::Number<0>(), 0);
 
        auto t_a = FTensor::Tensor1<adouble *, 3>{&a[0], &a[1], &a[2]};
        auto t_v = FTensor::Tensor1<adouble *, 3>{&v[0], &v[1], &v[2]};
        auto t_a_T = FTensor::Tensor1<adouble *, 3>{&a_T[0], &a_T[1], &a_T[2]};
 
        t_F(i, j) = t_h(i, k) * t_invH(k, j);
        t_G(i, j) = t_g(i, k) * t_invH(k, j);
        t_a_T(i) = t_F(k, i) * t_a(k) + t_G(k, i) * t_v(k);
        const auto rho0 = dAta.rho0;
        t_a_T(i) = -rho0 * detH;
 
        commonData.valT[gg].resize(3);
        for (int nn = 0; nn < 3; nn++) {
          a_T[nn] >>= (commonData.valT[gg])[nn];
        }
        trace_off();
      }
 
      active.resize(nb_active_vars);
      int aa = 0;
      for (int nn1 = 0; nn1 < 3; nn1++) { // 0
        active[aa++] =
            commonData
                .dataAtGaussPts["DOT_" + commonData.spatialVelocities][gg][nn1];
      }
 
      for (int nn1 = 0; nn1 < 3; nn1++) { // 3
        active[aa++] =
            commonData.dataAtGaussPts[commonData.spatialVelocities][gg][nn1];
      }
      for (int nn1 = 0; nn1 < 3; nn1++) { // 3+3
        for (int nn2 = 0; nn2 < 3; nn2++) {
          active[aa++] =
              commonData.gradAtGaussPts[commonData.spatialVelocities][gg](nn1,
                                                                          nn2);
        }
      }
      for (int nn1 = 0; nn1 < 3; nn1++) { // 3+3+9
        for (int nn2 = 0; nn2 < 3; nn2++) {
          if (fieldDisp && nn1 == nn2) {
            active[aa++] =
                commonData.gradAtGaussPts[commonData.spatialPositions][gg](
                    nn1, nn2) +
                1;
          } else {
            active[aa++] =
                commonData.gradAtGaussPts[commonData.spatialPositions][gg](nn1,
                                                                           nn2);
          }
        }
      }
      if (commonData.gradAtGaussPts[commonData.meshPositions].size() > 0) {
        for (int nn1 = 0; nn1 < 3; nn1++) { // 3+3+9+9
          for (int nn2 = 0; nn2 < 3; nn2++) {
            active[aa++] =
                commonData.gradAtGaussPts[commonData.meshPositions][gg](nn1,
                                                                        nn2);
          }
        }
      }
 
      if (!jAcobian) {
        VectorDouble &res = commonData.valT[gg];
        if (gg > 0) {
          res.resize(3);
          int r;
          r = ::function(tAg, 3, nb_active_vars, &active[0], &res[0]);
          if (r != 3) { // function is locally analytic
            SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                     "ADOL-C function evaluation with error r = %d", r);
          }
        }
        double val = getVolume() * getGaussPts()(3, gg);
        res *= val;
      } else {
        commonData.jacTRowPtr[gg].resize(3);
        commonData.jacT[gg].resize(3, nb_active_vars);
        for (int nn1 = 0; nn1 < 3; nn1++) {
          (commonData.jacTRowPtr[gg])[nn1] = &(commonData.jacT[gg](nn1, 0));
        }
        int r;
        r = jacobian(tAg, 3, nb_active_vars, &active[0],
                     &(commonData.jacTRowPtr[gg])[0]);
        if (r != 3) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                  "ADOL-C function evaluation with error");
        }
        double val = getVolume() * getGaussPts()(3, gg);
        commonData.jacT[gg] *= val;
      }
    }
 
  } catch (const std::exception &ex) {
    std::ostringstream ss;
    ss << "throw in method: " << ex.what() << std::endl;
    SETERRQ(PETSC_COMM_SELF, 1, ss.str().c_str());
  }
 
  MoFEMFunctionReturnHot(0);
}

Member Data Documentation

a

VectorBoundedArray<adouble, 3> ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::a

Definition at line 362 of file ConvectiveMassElement.hpp.

a_T

VectorBoundedArray<adouble, 3> ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::a_T

Definition at line 362 of file ConvectiveMassElement.hpp.

active

VectorDouble ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::active

Definition at line 364 of file ConvectiveMassElement.hpp.

commonData

CommonData& ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::commonData

Definition at line 352 of file ConvectiveMassElement.hpp.

dAta

BlockData& ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::dAta

Definition at line 351 of file ConvectiveMassElement.hpp.

F

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::F

Definition at line 363 of file ConvectiveMassElement.hpp.

fieldDisp

bool ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::fieldDisp

Definition at line 355 of file ConvectiveMassElement.hpp.

G

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::G

Definition at line 363 of file ConvectiveMassElement.hpp.

g

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::g

Definition at line 363 of file ConvectiveMassElement.hpp.

H

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::H

Definition at line 363 of file ConvectiveMassElement.hpp.

h

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::h

Definition at line 363 of file ConvectiveMassElement.hpp.

invH

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::invH

Definition at line 363 of file ConvectiveMassElement.hpp.

jAcobian

bool ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::jAcobian

Definition at line 354 of file ConvectiveMassElement.hpp.

tAg

int ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::tAg

Definition at line 353 of file ConvectiveMassElement.hpp.

v

VectorBoundedArray<adouble, 3> ConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian::v

Definition at line 362 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