#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

Examples: HookeInternalStressElement.hpp.

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);
 }