OpPostProcHookeElement< ELEMENT > Struct Template Reference

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

Inheritance diagram for OpPostProcHookeElement< ELEMENT >:

Collaboration diagram for 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 OpPostProcHookeElement< ELEMENT >

Examples

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

Definition at line 637 of file HookeElement.hpp.

Constructor & Destructor Documentation

OpPostProcHookeElement()

template<class ELEMENT >

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
	)

Definition at line 1399 of file HookeElement.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 OpPostProcHookeElement< ELEMENT >::doWork	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

Definition at line 1409 of file HookeElement.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);
  };
 
  std::array<double, 9> def_val;
  def_val.fill(0);
 
  auto make_tag = [&](auto name, auto size) {
    Tag th;
    CHKERR postProcMesh.tag_get_handle(name, size, MB_TYPE_DOUBLE, th,
                                       MB_TAG_CREAT | MB_TAG_SPARSE,
                                       def_val.data());
    return th;
  };
 
  auto th_stress = make_tag("STRESS", 9);
  auto th_psi = make_tag("ENERGY", 1);
 
  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));
 
  EntityHandle ent = this->getFEEntityHandle();
  auto type = type_from_handle(ent);
  EntityHandle ent_3d = ent;
  if (type == MBTRI || type == MBQUAD) {
    Range ents;
    auto &m_field = this->getPtrFE()->mField;
    CHKERR m_field.get_moab().get_adjacencies(&ent, 1, 3, false, ents,
                                              moab::Interface::UNION);
#ifndef NDEBUG
    if (ents.empty())
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Could not find a 3D element adjacent to a given face element");
#endif
    ent_3d = ents.front();
  }
 
  bool found_block = false;
  int block_id = -1;
  for (auto &m : (blockSetsPtr)) {
    if (m.second.tEts.find(ent_3d) != m.second.tEts.end()) {
      const double young = m.second.E;
      const double poisson = m.second.PoissonRatio;
      const double coefficient = young / ((1 + poisson) * (1 - 2 * poisson));
      block_id = m.second.iD;
 
      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;
 
      found_block = true;
      break;
    }
  }
  if (!found_block)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Element not found in any of material blocksets");
 
  int def_val_int = 0;
  Tag tag_mat;
  CHKERR postProcMesh.tag_get_handle("MAT_ELASTIC", 1, MB_TYPE_INTEGER, tag_mat,
                                     MB_TAG_CREAT | MB_TAG_SPARSE, &def_val_int);
  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;
 
  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);
 
    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(tag_mat, &mapGaussPts[gg], 1,
                                     &block_id);
 
    ++t_h;
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

blockSetsPtr

template<class ELEMENT >

map<int, BlockData>& OpPostProcHookeElement< ELEMENT >::blockSetsPtr

Definition at line 640 of file HookeElement.hpp.

dataAtPts

template<class ELEMENT >

boost::shared_ptr<DataAtIntegrationPts> OpPostProcHookeElement< ELEMENT >::dataAtPts

Definition at line 638 of file HookeElement.hpp.

isALE

template<class ELEMENT >

bool OpPostProcHookeElement< ELEMENT >::isALE

Definition at line 643 of file HookeElement.hpp.

isFieldDisp

template<class ELEMENT >

bool OpPostProcHookeElement< ELEMENT >::isFieldDisp

Definition at line 644 of file HookeElement.hpp.

mapGaussPts

template<class ELEMENT >

std::vector<EntityHandle>& OpPostProcHookeElement< ELEMENT >::mapGaussPts

Definition at line 642 of file HookeElement.hpp.

postProcMesh

template<class ELEMENT >

moab::Interface& OpPostProcHookeElement< ELEMENT >::postProcMesh

Definition at line 641 of file HookeElement.hpp.

---

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

• users_modules/basic_finite_elements/src/HookeElement.hpp