#include <users_modules/mortar_contact/src/HookeInternalStressElement.hpp>

Inheritance diagram for HookeInternalStressElement::OpPostProcHookeElement< ELEMENT >:

Collaboration diagram for HookeInternalStressElement::OpPostProcHookeElement< ELEMENT >:

Public Member Functions
	OpPostProcHookeElement (const string row_field, boost::shared_ptr< DataAtIntegrationPts > data_at_pts, map< int, BlockData > &block_sets_ptr, moab::Interface &post_proc_mesh, std::vector< EntityHandle > &map_gauss_pts, bool is_ale=false, bool is_field_disp=true)

MoFEMErrorCode	doWork (int side, EntityType type, EntitiesFieldData::EntData &data)

Public Attributes
boost::shared_ptr< DataAtIntegrationPts >	dataAtPts

map< int, BlockData > &	blockSetsPtr

moab::Interface &	postProcMesh

std::vector< EntityHandle > &	mapGaussPts

bool	isALE

bool	isFieldDisp

Detailed Description

template<class ELEMENT>
struct HookeInternalStressElement::OpPostProcHookeElement< ELEMENT >

Examples: mortar_contact_thermal.cpp, and simple_contact_thermal.cpp.

Definition at line 142 of file HookeInternalStressElement.hpp.

Constructor & Destructor Documentation

◆ OpPostProcHookeElement()

template<class ELEMENT >

HookeInternalStressElement::OpPostProcHookeElement< ELEMENT >::OpPostProcHookeElement	(	const string	row_field,
		boost::shared_ptr< DataAtIntegrationPts >	data_at_pts,
		map< int, BlockData > &	block_sets_ptr,
		moab::Interface &	post_proc_mesh,
		std::vector< EntityHandle > &	map_gauss_pts,
		bool	is_ale = `false`,
		bool	is_field_disp = `true`
	)

inline

Definition at line 151 of file HookeInternalStressElement.hpp.

        : ELEMENT::UserDataOperator(row_field, UserDataOperator::OPROW),
          dataAtPts(data_at_pts), blockSetsPtr(block_sets_ptr),
          postProcMesh(post_proc_mesh), mapGaussPts(map_gauss_pts),
          isALE(is_ale), isFieldDisp(is_field_disp) {}

Member Function Documentation

◆ doWork()

template<class ELEMENT >

MoFEMErrorCode HookeInternalStressElement::OpPostProcHookeElement< ELEMENT >::doWork	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

Examples: HookeInternalStressElement.hpp.

Definition at line 487 of file HookeInternalStressElement.hpp.

                                                               {
  MoFEMFunctionBegin;
 
  if (type != MBVERTEX) {
    MoFEMFunctionReturnHot(0);
  }
 
  auto tensor_to_tensor = [](const auto &t1, auto &t2) {
    t2(0, 0) = t1(0, 0);
    t2(1, 1) = t1(1, 1);
    t2(2, 2) = t1(2, 2);
    t2(0, 1) = t2(1, 0) = t1(1, 0);
    t2(0, 2) = t2(2, 0) = t1(2, 0);
    t2(1, 2) = t2(2, 1) = t1(2, 1);
  };
 
  auto get_tag_handle = [&](auto name, auto size) {
    Tag th;
    std::vector<double> def_vals(size, 0.0);
    CHKERR postProcMesh.tag_get_handle(name, size, MB_TYPE_DOUBLE, th,
                                       MB_TAG_CREAT | MB_TAG_SPARSE,
                                       def_vals.data());
    return th;
  };
 
  auto th_stress = get_tag_handle("STRESS", 9);
  auto th_strain = get_tag_handle("STRAIN", 9);
  auto th_psi = get_tag_handle("ENERGY", 1);
  auto th_disp = get_tag_handle("DISPLACEMENT", 3);
 
  const int nb_integration_pts = mapGaussPts.size();
 
  FTensor::Index<'i', 3> i;
  FTensor::Index<'j', 3> j;
  FTensor::Index<'k', 3> k;
  FTensor::Index<'l', 3> l;
 
  auto t_h = getFTensor2FromMat<3, 3>(*dataAtPts->hMat);
  auto t_H = getFTensor2FromMat<3, 3>(*dataAtPts->HMat);
 
  dataAtPts->stiffnessMat->resize(36, 1, false);
  FTensor::Ddg<FTensor::PackPtr<double *, 1>, 3, 3> t_D(
      MAT_TO_DDG(dataAtPts->stiffnessMat));
  for (auto &m : (blockSetsPtr)) {
    const double young = m.second.E;
    const double poisson = m.second.PoissonRatio;
 
    const double coefficient = young / ((1 + poisson) * (1 - 2 * poisson));
 
    t_D(i, j, k, l) = 0.;
    t_D(0, 0, 0, 0) = t_D(1, 1, 1, 1) = t_D(2, 2, 2, 2) = 1 - poisson;
    t_D(0, 1, 0, 1) = t_D(0, 2, 0, 2) = t_D(1, 2, 1, 2) =
        0.5 * (1 - 2 * poisson);
    t_D(0, 0, 1, 1) = t_D(1, 1, 0, 0) = t_D(0, 0, 2, 2) = t_D(2, 2, 0, 0) =
        t_D(1, 1, 2, 2) = t_D(2, 2, 1, 1) = poisson;
    t_D(i, j, k, l) *= coefficient;
 
    break; // FIXME: calculates only first block
  }
 
  double detH = 0.;
  FTensor::Tensor2<double, 3, 3> t_invH;
  FTensor::Tensor2<double, 3, 3> t_F;
  FTensor::Tensor2<double, 3, 3> t_stress;
  FTensor::Tensor2<double, 3, 3> t_small_strain;
 
  FTensor::Tensor2_symmetric<double, 3> t_stress_symm;
  FTensor::Tensor2_symmetric<double, 3> t_small_strain_symm;
 
  auto t_spat_pos = getFTensor1FromMat<3>(*dataAtPts->spatPosMat);
  auto t_mesh_node_pos = getFTensor1FromMat<3>(*dataAtPts->meshNodePosMat);
  FTensor::Tensor1<double, 3> t_disp;
 
  for (int gg = 0; gg != nb_integration_pts; ++gg) {
 
    if (isFieldDisp) {
      t_h(0, 0) += 1;
      t_h(1, 1) += 1;
      t_h(2, 2) += 1;
    }
 
    if (!isALE) {
      t_small_strain_symm(i, j) = (t_h(i, j) || t_h(j, i)) / 2.;
    } else {
      CHKERR determinantTensor3by3(t_H, detH);
      CHKERR invertTensor3by3(t_H, detH, t_invH);
      t_F(i, j) = t_h(i, k) * t_invH(k, j);
      t_small_strain_symm(i, j) = (t_F(i, j) || t_F(j, i)) / 2.;
      ++t_H;
    }
 
    t_small_strain_symm(0, 0) -= 1;
    t_small_strain_symm(1, 1) -= 1;
    t_small_strain_symm(2, 2) -= 1;
 
    // symmetric tensors need improvement
    t_stress_symm(i, j) = t_D(i, j, k, l) * t_small_strain_symm(k, l);
    tensor_to_tensor(t_stress_symm, t_stress);
    tensor_to_tensor(t_small_strain_symm, t_small_strain);
 
    t_disp(i) = t_spat_pos(i) - t_mesh_node_pos(i);
 
    const double psi = 0.5 * t_stress_symm(i, j) * t_small_strain_symm(i, j);
 
    CHKERR postProcMesh.tag_set_data(th_psi, &mapGaussPts[gg], 1, &psi);
    CHKERR postProcMesh.tag_set_data(th_stress, &mapGaussPts[gg], 1,
                                     &t_stress(0, 0));
    CHKERR postProcMesh.tag_set_data(th_strain, &mapGaussPts[gg], 1,
                                     &t_small_strain(0, 0));
    CHKERR postProcMesh.tag_set_data(th_disp, &mapGaussPts[gg], 1, &t_disp(0));
 
    ++t_h;
    ++t_spat_pos;
    ++t_mesh_node_pos;
  }
 
  MoFEMFunctionReturn(0);
}