OpPostProcMap< DIM1, DIM2 > Struct Template Reference

Post post-proc data at points from hash maps. More...

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

Inheritance diagram for OpPostProcMap< DIM1, DIM2 >:

Collaboration diagram for OpPostProcMap< DIM1, DIM2 >:

Public Types
using	DataMapVec = std::map< std::string, boost::shared_ptr< VectorDouble > >
using	DataMapMat = std::map< std::string, boost::shared_ptr< MatrixDouble > >

Public Member Functions
	OpPostProcMap (moab::Interface &post_proc_mesh, std::vector< EntityHandle > &map_gauss_pts, DataMapVec data_map_scalar, DataMapMat data_map_vec, DataMapMat data_map_mat, DataMapMat data_symm_map_mat)
	Construct a new OpPostProcMap object. More...
MoFEMErrorCode	doWork (int side, EntityType type, EntitiesFieldData::EntData &data)

Private Attributes
moab::Interface &	postProcMesh
std::vector< EntityHandle > &	mapGaussPts
DataMapVec	dataMapScalar
DataMapMat	dataMapVec
DataMapMat	dataMapMat
DataMapMat	dataMapSymmMat

Detailed Description

template<int DIM1, int DIM2>
struct OpPostProcMap< DIM1, DIM2 >

Post post-proc data at points from hash maps.

Template Parameters

DIM1	dimension of vector in data_map_vec and first column of data_map_may
DIM2	dimension of second column in data_map_mat

Definition at line 1185 of file PostProcOnRefMesh.hpp.

Member Typedef Documentation

DataMapMat

template<int DIM1, int DIM2>

using OpPostProcMap< DIM1, DIM2 >::DataMapMat = std::map<std::string, boost::shared_ptr<MatrixDouble> >

Definition at line 1188 of file PostProcOnRefMesh.hpp.

DataMapVec

template<int DIM1, int DIM2>

using OpPostProcMap< DIM1, DIM2 >::DataMapVec = std::map<std::string, boost::shared_ptr<VectorDouble> >

Definition at line 1187 of file PostProcOnRefMesh.hpp.

Constructor & Destructor Documentation

OpPostProcMap()

template<int DIM1, int DIM2>

OpPostProcMap< DIM1, DIM2 >::OpPostProcMap ( moab::Interface &  post_proc_mesh, std::vector< EntityHandle > &  map_gauss_pts, DataMapVec  data_map_scalar, DataMapMat  data_map_vec, DataMapMat  data_map_mat, DataMapMat  data_symm_map_mat  )

inline

Construct a new OpPostProcMap object.

Parameters

post_proc_mesh	postprocessing mesh
map_gauss_pts	map of gauss points to nodes of postprocessing mesh
data_map_scalar	hash map of scalar values (string is name of the tag)
data_map_vec	hash map of vector values
data_map_mat	hash map of second order tensor values
data_symm_map_mat	hash map of symmetric second order tensor values

Definition at line 1201 of file PostProcOnRefMesh.hpp.

      : ForcesAndSourcesCore::UserDataOperator(
            NOSPACE, ForcesAndSourcesCore::UserDataOperator::OPSPACE),
        postProcMesh(post_proc_mesh), mapGaussPts(map_gauss_pts),
        dataMapScalar(data_map_scalar), dataMapVec(data_map_vec),
        dataMapMat(data_map_mat), dataMapSymmMat(data_symm_map_mat) {
    // Operator is only executed for vertices
    std::fill(&doEntities[MBEDGE], &doEntities[MBMAXTYPE], false);
  }

Member Function Documentation

doWork()

template<int DIM1, int DIM2>

MoFEMErrorCode OpPostProcMap< DIM1, DIM2 >::doWork	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

Definition at line 1227 of file PostProcOnRefMesh.hpp.

                                                                  {
  MoFEMFunctionBegin;
 
  std::array<double, 9> def;
  std::fill(def.begin(), def.end(), 0);
 
  auto get_tag = [&](const std::string name, size_t size) {
    Tag th;
    CHKERR postProcMesh.tag_get_handle(name.c_str(), size, MB_TYPE_DOUBLE, th,
                                       MB_TAG_CREAT | MB_TAG_SPARSE,
                                       def.data());
    return th;
  };
 
  MatrixDouble3by3 mat(3, 3);
 
  auto set_vector_3d = [&](auto &t) -> MatrixDouble3by3 & {
    mat.clear();
    for (size_t r = 0; r != DIM1; ++r)
      mat(0, r) = t(r);
    return mat;
  };
 
  auto set_matrix_3d = [&](auto &t) -> MatrixDouble3by3 & {
    mat.clear();
    for (size_t r = 0; r != DIM1; ++r)
      for (size_t c = 0; c != DIM2; ++c)
        mat(r, c) = t(r, c);
    return mat;
  };
 
  auto set_matrix_symm_3d = [&](auto &t) -> MatrixDouble3by3 & {
    mat.clear();
    for (size_t r = 0; r != DIM1; ++r)
      for (size_t c = 0; c != DIM1; ++c)
        mat(r, c) = t(r, c);
    return mat;
  };
 
  auto set_scalar = [&](auto t) -> MatrixDouble3by3 & {
    mat.clear();
    mat(0, 0) = t;
    return mat;
  };
 
  auto set_float_precision = [](const double x) {
    if (std::abs(x) < std::numeric_limits<float>::epsilon())
      return 0.;
    else
      return x;
  };
 
  auto set_tag = [&](auto th, auto gg, MatrixDouble3by3 &mat) {
    for (auto &v : mat.data())
      v = set_float_precision(v);
    return postProcMesh.tag_set_data(th, &mapGaussPts[gg], 1,
                                     &*mat.data().begin());
  };
 
  for (auto &m : dataMapScalar) {
    auto th = get_tag(m.first, 1);
    auto t_scl = getFTensor0FromVec(*m.second);
    auto nb_integration_pts = getGaussPts().size2();
    size_t gg = 0;
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
      CHKERR set_tag(th, gg, set_scalar(t_scl));
      ++t_scl;
    }
  }
 
  for (auto &m : dataMapVec) {
    auto th = get_tag(m.first, 3);
    auto t_vec = getFTensor1FromMat<DIM1>(*m.second);
    auto nb_integration_pts = getGaussPts().size2();
    size_t gg = 0;
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
      CHKERR set_tag(th, gg, set_vector_3d(t_vec));
      ++t_vec;
    }
  }
 
  for (auto &m : dataMapMat) {
    auto th = get_tag(m.first, 9);
    auto t_mat = getFTensor2FromMat<DIM1, DIM2>(*m.second);
    auto nb_integration_pts = getGaussPts().size2();
    size_t gg = 0;
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
      CHKERR set_tag(th, gg, set_matrix_3d(t_mat));
      ++t_mat;
    }
  }
 
  for (auto &m : dataMapSymmMat) {
    auto th = get_tag(m.first, 9);
    auto t_mat = getFTensor2SymmetricFromMat<DIM1>(*m.second);
    auto nb_integration_pts = getGaussPts().size2();
    size_t gg = 0;
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
      CHKERR set_tag(th, gg, set_matrix_symm_3d(t_mat));
      ++t_mat;
    }
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

dataMapMat

template<int DIM1, int DIM2>

DataMapMat OpPostProcMap< DIM1, DIM2 >::dataMapMat

private

Definition at line 1221 of file PostProcOnRefMesh.hpp.

dataMapScalar

template<int DIM1, int DIM2>

DataMapVec OpPostProcMap< DIM1, DIM2 >::dataMapScalar

private

Definition at line 1219 of file PostProcOnRefMesh.hpp.

dataMapSymmMat

template<int DIM1, int DIM2>

DataMapMat OpPostProcMap< DIM1, DIM2 >::dataMapSymmMat

private

Definition at line 1222 of file PostProcOnRefMesh.hpp.

dataMapVec

template<int DIM1, int DIM2>

DataMapMat OpPostProcMap< DIM1, DIM2 >::dataMapVec

private

Definition at line 1220 of file PostProcOnRefMesh.hpp.

mapGaussPts

template<int DIM1, int DIM2>

std::vector<EntityHandle>& OpPostProcMap< DIM1, DIM2 >::mapGaussPts

private

Definition at line 1218 of file PostProcOnRefMesh.hpp.

postProcMesh

template<int DIM1, int DIM2>

moab::Interface& OpPostProcMap< DIM1, DIM2 >::postProcMesh

private

Definition at line 1217 of file PostProcOnRefMesh.hpp.

---

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

• users_modules/basic_finite_elements/src/PostProcOnRefMesh.hpp