MoFEM::PostProcBrokenMeshInMoabBase< E > Struct Template Reference

#include "src/post_proc/PostProcBrokenMeshInMoabBase.hpp"

Inheritance diagram for MoFEM::PostProcBrokenMeshInMoabBase< E >:

Collaboration diagram for MoFEM::PostProcBrokenMeshInMoabBase< E >:

Public Member Functions
	PostProcBrokenMeshInMoabBase (MoFEM::Interface &m_field, std::string opts_prefix="")
	PostProcBrokenMeshInMoabBase (MoFEM::Interface &m_field, boost::shared_ptr< moab::Core > core_mesh_ptr, std::string opts_prefix="")
virtual	~PostProcBrokenMeshInMoabBase ()
auto &	getMapGaussPts ()
	Get vector of vectors associated to integration points.
auto &	getPostProcMesh ()
	Get postprocessing mesh.
auto &	getPostProcElements ()
	Get postprocessing elements.
MoFEMErrorCode	writeFile (const std::string file_name)
	wrote results in (MOAB) format, use "file_name.h5m"
MoFEMErrorCode	setTagsToTransfer (std::vector< Tag > tags_to_transfer)
	Set tags to be transferred to post-processing mesh.

Protected Member Functions
MoFEMErrorCode	setGaussPts (int order)
MoFEMErrorCode	preProcess ()
	Generate vertices and elements.
MoFEMErrorCode	postProcess ()
int	getRule (int order)
virtual int	getMaxLevel () const
	Determine refinement level based on fields approx ordre.
virtual MoFEMErrorCode	preProcPostProc ()
virtual MoFEMErrorCode	postProcPostProc ()
virtual MoFEMErrorCode	transferTags ()
auto	getPostProcMeshPcommPtr ()

Protected Attributes
boost::shared_ptr< moab::Core >	coreMeshPtr = boost::make_shared<moab::Core>()
std::vector< EntityHandle >	mapGaussPts
Range	postProcElements
std::map< EntityType, PostProcGenerateRefMeshPtr >	refElementsMap
std::vector< Tag >	tagsToTransfer
std::string	optionsPrefix = ""
	Prefix for options.

Detailed Description

template<typename E>
struct MoFEM::PostProcBrokenMeshInMoabBase< E >

Examples

mofem/tools/mesh_smoothing.cpp, mofem/tutorials/vec-2_nonlinear_elasticity/nonlinear_elastic.cpp, mofem/tutorials/vec-9_arc_length/arc_length.cpp, mofem/users_modules/adolc-plasticity/adolc_plasticity.cpp, and nonlinear_elastic.cpp.

Definition at line 94 of file PostProcBrokenMeshInMoabBase.hpp.

Constructor & Destructor Documentation

PostProcBrokenMeshInMoabBase() [1/2]

template<typename E >

MoFEM::PostProcBrokenMeshInMoabBase< E >::PostProcBrokenMeshInMoabBase	(	MoFEM::Interface &	m_field,
		std::string	opts_prefix = ""
	)

Definition at line 290 of file PostProcBrokenMeshInMoabBase.hpp.

    : E(m_field), optionsPrefix(opts_prefix) {}

PostProcBrokenMeshInMoabBase() [2/2]

template<typename E >

MoFEM::PostProcBrokenMeshInMoabBase< E >::PostProcBrokenMeshInMoabBase	(	MoFEM::Interface &	m_field,
		boost::shared_ptr< moab::Core >	core_mesh_ptr,
		std::string	opts_prefix = ""
	)

Definition at line 295 of file PostProcBrokenMeshInMoabBase.hpp.

    : PostProcBrokenMeshInMoabBase(m_field, opts_prefix) {
  coreMeshPtr = core_mesh_ptr;
}

~PostProcBrokenMeshInMoabBase()

template<typename E >

MoFEM::PostProcBrokenMeshInMoabBase< E >::~PostProcBrokenMeshInMoabBase ( )

virtual

Definition at line 303 of file PostProcBrokenMeshInMoabBase.hpp.

                                                               {
  MeshPCommRegistry::getMap().erase(coreMeshPtr.get());
}

Member Function Documentation

getMapGaussPts()

template<typename E >

auto & MoFEM::PostProcBrokenMeshInMoabBase< E >::getMapGaussPts ( )

inline

Get vector of vectors associated to integration points.

Returns

std::vector<EntityHandle>&

Definition at line 652 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                            {
  return mapGaussPts;
}

getMaxLevel()

template<typename E >

int MoFEM::PostProcBrokenMeshInMoabBase< E >::getMaxLevel ( ) const

protectedvirtual

Determine refinement level based on fields approx ordre.

level = (order - 1) / 2

Returns

int

Reimplemented in EshelbianPlasticity::ContactTree.

Definition at line 198 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                             {
  auto get_element_max_dofs_order = [&]() {
    int max_order = 0;
    auto dofs_vec = E::getDataVectorDofsPtr();
    for (auto &dof : *dofs_vec) {
      const int dof_order = dof->getDofOrder();
      max_order = (max_order < dof_order) ? dof_order : max_order;
    };
    return max_order;
  };
  const auto dof_max_order = get_element_max_dofs_order();
  return (dof_max_order > 0) ? (dof_max_order - 1) / 2 : 0;
};

getPostProcElements()

template<typename E >

auto & MoFEM::PostProcBrokenMeshInMoabBase< E >::getPostProcElements ( )

inline

Get postprocessing elements.

Returns

auto&

Definition at line 664 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                  {
  return postProcElements;
}

getPostProcMesh()

template<typename E >

auto & MoFEM::PostProcBrokenMeshInMoabBase< E >::getPostProcMesh ( )

inline

Get postprocessing mesh.

Returns

moab::Interface&

Definition at line 656 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                             {
  if (!coreMeshPtr)
    CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY, "Core mesh not set");
  moab::Interface &post_proc_mesh_interface = *coreMeshPtr;
  return post_proc_mesh_interface;
}

getPostProcMeshPcommPtr()

template<typename E >

auto MoFEM::PostProcBrokenMeshInMoabBase< E >::getPostProcMeshPcommPtr ( )

inlineprotected

Definition at line 184 of file PostProcBrokenMeshInMoabBase.hpp.

                                 {
    return MeshPCommRegistry::getOrCreate(coreMeshPtr);
  }

getRule()

template<typename E >

int MoFEM::PostProcBrokenMeshInMoabBase< E >::getRule ( int  order )

protected

Definition at line 307 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                            {
  return -1;
};

postProcess()

template<typename E >

MoFEMErrorCode MoFEM::PostProcBrokenMeshInMoabBase< E >::postProcess ( )

protected

Definition at line 638 of file PostProcBrokenMeshInMoabBase.hpp.

                                                            {
  MoFEMFunctionBeginHot;
 
  auto pcomm_post_proc_mesh = getPostProcMeshPcommPtr();
  if (!pcomm_post_proc_mesh)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "ParallelComm not allocated");
 
  CHKERR postProcPostProc();
  CHKERR pcomm_post_proc_mesh->resolve_shared_ents(0);
 
  MoFEMFunctionReturnHot(0);
}

postProcPostProc()

template<typename E >

MoFEMErrorCode MoFEM::PostProcBrokenMeshInMoabBase< E >::postProcPostProc ( )

protectedvirtual

Definition at line 554 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                 {
  MoFEMFunctionBegin;
 
  auto update_elements = [&]() {
    ReadUtilIface *iface;
    CHKERR getPostProcMesh().query_interface(iface);
    MoFEMFunctionBegin;
 
    Range ents;
    for (auto &m : refElementsMap) {
      if (m.second->nbEles) {
        MOFEM_TAG_AND_LOG("SELF", Sev::noisy, "PostProc")
            << "Update < " << moab::CN::EntityTypeName(m.first)
            << " number of processed " << m.second->countEle;
        CHKERR iface->update_adjacencies(
            m.second->startingEleHandle, m.second->countEle,
            m.second->levelRef[0].size2(), m.second->eleConn);
        ents.merge(Range(m.second->startingEleHandle,
                         m.second->startingEleHandle + m.second->countEle - 1));
      }
    }
 
    MoFEMFunctionReturn(0);
  };
 
  auto remove_obsolete_entities = [&]() {
    MoFEMFunctionBegin;
    Range ents, adj;
    for (auto &m : refElementsMap) {
      if (m.second->nbEles) {
        ents.merge(Range(m.second->startingEleHandle,
                         m.second->startingEleHandle + m.second->countEle - 1));
        const int dim = moab::CN::Dimension(m.first);
        for (auto d = 1; d != dim; ++d) {
          CHKERR getPostProcMesh().get_adjacencies(ents, d, false, adj,
                                                   moab::Interface::UNION);
        }
      }
    }
    CHKERR getPostProcMesh().delete_entities(adj);
    MoFEMFunctionReturn(0);
  };
 
  auto set_proc_tags = [&]() {
    MoFEMFunctionBegin;
    ParallelComm *pcomm_post_proc_mesh =
        ParallelComm::get_pcomm(&(getPostProcMesh()), MYPCOMM_INDEX);
    if (pcomm_post_proc_mesh) {
      Range ents;
      for (auto &m : refElementsMap) {
        if (m.second->nbEles) {
          ents.merge(
              Range(m.second->startingEleHandle,
                    m.second->startingEleHandle + m.second->countEle - 1));
        }
      }
 
      int rank = E::mField.get_comm_rank();
      CHKERR getPostProcMesh().tag_clear_data(pcomm_post_proc_mesh->part_tag(),
                                              ents, &rank);
    }
    MoFEMFunctionReturn(0);
  };
 
  CHKERR update_elements();
  CHKERR remove_obsolete_entities();
  CHKERR set_proc_tags();
 
  MoFEMFunctionReturn(0);
}

preProcess()

template<typename E >

MoFEMErrorCode MoFEM::PostProcBrokenMeshInMoabBase< E >::preProcess ( )

protected

Generate vertices and elements.

Returns

MoFEMErrorCode

Definition at line 626 of file PostProcBrokenMeshInMoabBase.hpp.

                                                           {
  MoFEMFunctionBegin;
 
  CHKERR getPostProcMesh().delete_mesh();
  
 
  CHKERR preProcPostProc();
 
  MoFEMFunctionReturn(0);
}

preProcPostProc()

template<typename E >

MoFEMErrorCode MoFEM::PostProcBrokenMeshInMoabBase< E >::preProcPostProc ( )

protectedvirtual

Definition at line 439 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                {
  MoFEMFunctionBegin;
 
auto get_ref_ele = [&](const EntityType type) {
  PostProcGenerateRefMeshPtr ref_ele_ptr;
  
  auto it = refElementsMap.find(type);
  if (it != refElementsMap.end()) {
    ref_ele_ptr = it->second;
  } else {
    switch (type) {
    case MBTET:
      ref_ele_ptr = boost::make_shared<PostProcGenerateRefMesh<MBTET>>();
      break;
    case MBHEX:
      ref_ele_ptr = boost::make_shared<PostProcGenerateRefMesh<MBHEX>>();
      break;
    case MBTRI:
      ref_ele_ptr = boost::make_shared<PostProcGenerateRefMesh<MBTRI>>();
      break;
    case MBQUAD:
      ref_ele_ptr = boost::make_shared<PostProcGenerateRefMesh<MBQUAD>>();
      break;
    case MBEDGE:
      ref_ele_ptr = boost::make_shared<PostProcGenerateRefMesh<MBEDGE>>();
      break;
    default:
      MOFEM_LOG("SELF", Sev::error)
          << "Generation of reference elements for type < "
          << moab::CN::EntityTypeName(type) << " > is not implemented";
      CHK_THROW_MESSAGE(MOFEM_NOT_IMPLEMENTED, "Element not implemented");
    }
 
    CHK_THROW_MESSAGE(ref_ele_ptr->getOptions(optionsPrefix), "getOptions");
    CHK_THROW_MESSAGE(ref_ele_ptr->generateReferenceElementMesh(),
                      "Error when generating reference element");
    
    refElementsMap[type] = ref_ele_ptr;
  }
 
  return ref_ele_ptr;
};
 
  auto fe_ptr = this->problemPtr->numeredFiniteElementsPtr;
 
  auto miit =
      fe_ptr->template get<Composite_Name_And_Part_mi_tag>().lower_bound(
          boost::make_tuple(this->getFEName(), this->getLoFERank()));
  auto hi_miit =
      fe_ptr->template get<Composite_Name_And_Part_mi_tag>().upper_bound(
          boost::make_tuple(this->getFEName(), this->getHiFERank()));
 
  const int number_of_ents_in_the_loop = this->getLoopSize();
  if (std::distance(miit, hi_miit) != number_of_ents_in_the_loop) {
    SETERRQ(E::mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
            "Wrong size of indicies. Inconsistent size number of iterated "
            "elements iterated by problem and from range.");
  }
 
  for (auto &m : refElementsMap) {
    m.second->nbVertices = 0;
    m.second->nbEles = 0;
    m.second->countEle = 0;
    m.second->countVertEle = 0;
  }
 
  for (; miit != hi_miit; ++miit) {
    auto type = (*miit)->getEntType();
    auto ref_ele = get_ref_ele(type);
 
    // Set pointer to element. So that getDataVectorDofsPtr in getMaxLevel
    // can work
    E::numeredEntFiniteElementPtr = *miit;
    bool add = true;
    if (E::exeTestHook) {
      add = E::exeTestHook(this);
    }
 
    if (add) {
      size_t level = getMaxLevel();
      level = std::min(level, ref_ele->levelGaussPtsOnRefMesh.size() - 1);
      ref_ele->nbVertices += ref_ele->levelGaussPtsOnRefMesh[level].size2();
      ref_ele->nbEles += ref_ele->levelRef[level].size1();
    }
  }
 
  auto alloc_vertices_and_elements_on_post_proc_mesh = [&]() {
    MoFEMFunctionBegin;
 
    ReadUtilIface *iface;
    CHKERR getPostProcMesh().query_interface(iface);
 
    for (auto &m : refElementsMap) {
      if (m.second->nbEles) {
        CHKERR iface->get_node_coords(3, m.second->nbVertices, 0,
                                      m.second->startingVertEleHandle,
                                      m.second->verticesOnEleArrays);
        CHKERR iface->get_element_connect(
            m.second->nbEles, m.second->levelRef[0].size2(), m.first, 0,
            m.second->startingEleHandle, m.second->eleConn);
 
        m.second->countEle = 0;
        m.second->countVertEle = 0;
      }
    }
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR alloc_vertices_and_elements_on_post_proc_mesh();
 
  MoFEMFunctionReturn(0);
}

setGaussPts()

template<typename E >

MoFEMErrorCode MoFEM::PostProcBrokenMeshInMoabBase< E >::setGaussPts ( int  order )

protected

Definition at line 312 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                     {
  MoFEMFunctionBegin;
 
  auto type = type_from_handle(this->getFEEntityHandle());
 
  PostProcGenerateRefMeshPtr ref_ele;
 
  try {
    ref_ele = refElementsMap.at(type);
  } catch (const out_of_range &e) {
    SETERRQ(
        PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
        "Generation of reference elements for type <%s> is not implemented",
        moab::CN::EntityTypeName(type));
  }
 
  auto set_gauss_pts = [&](auto &level_gauss_pts_on_ref_mesh, auto &level_ref,
                           auto &level_shape_functions,
 
                           auto start_vert_handle, auto start_ele_handle,
                           auto &verts_array, auto &conn, auto &ver_count,
                           auto &ele_count
 
                       ) {
    MoFEMFunctionBegin;
 
    size_t level = getMaxLevel();
    level = std::min(level, level_gauss_pts_on_ref_mesh.size() - 1);
 
    auto &level_ref_gauss_pts = level_gauss_pts_on_ref_mesh[level];
    auto &level_ref_ele = level_ref[level];
    auto &shape_functions = level_shape_functions[level];
    E::gaussPts.resize(level_ref_gauss_pts.size1(), level_ref_gauss_pts.size2(),
                       false);
    noalias(E::gaussPts) = level_ref_gauss_pts;
 
    const auto fe_ent = E::numeredEntFiniteElementPtr->getEnt();
    auto get_fe_coords = [&]() {
      const EntityHandle *conn;
      int num_nodes;
      CHK_MOAB_THROW(
          E::mField.get_moab().get_connectivity(fe_ent, conn, num_nodes, true),
          "error get connectivity");
      VectorDouble coords(num_nodes * 3);
      CHK_MOAB_THROW(
          E::mField.get_moab().get_coords(conn, num_nodes, &*coords.begin()),
          "error get coordinates");
      return coords;
    };
 
    auto coords = get_fe_coords();
 
    const int num_nodes = level_ref_gauss_pts.size2();
    mapGaussPts.resize(level_ref_gauss_pts.size2());
 
    FTensor::Index<'i', 3> i;
    FTensor::Tensor0<FTensor::PackPtr<double *, 1>> t_n(
        &*shape_functions.data().begin());
    FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 3> t_coords(
        &verts_array[0][ver_count], &verts_array[1][ver_count],
        &verts_array[2][ver_count]);
    for (int gg = 0; gg != num_nodes; ++gg, ++ver_count) {
 
      mapGaussPts[gg] = start_vert_handle + ver_count;
 
      auto set_float_precision = [](const double x) {
        if (std::abs(x) < std::numeric_limits<float>::epsilon())
          return 0.;
        else
          return x;
      };
 
      t_coords(i) = 0;
      auto t_ele_coords = getFTensor1FromArray<3, 3>(coords);
      for (int nn = 0; nn != CN::VerticesPerEntity(type); ++nn) {
        t_coords(i) += t_n * t_ele_coords(i);
        ++t_ele_coords;
        ++t_n;
      }
 
      for (auto ii : {0, 1, 2})
        t_coords(ii) = set_float_precision(t_coords(ii));
 
      ++t_coords;
    }
 
    Tag th;
    int def_in_the_loop = -1;
    CHKERR getPostProcMesh().tag_get_handle(
        "NB_IN_THE_LOOP", 1, MB_TYPE_INTEGER, th, MB_TAG_CREAT | MB_TAG_SPARSE,
        &def_in_the_loop);
 
    postProcElements.clear();
    const int num_el = level_ref_ele.size1();
    const int num_nodes_on_ele = level_ref_ele.size2();
    auto start_e = start_ele_handle + ele_count;
    postProcElements = Range(start_e, start_e + num_el - 1);
    for (auto tt = 0; tt != level_ref_ele.size1(); ++tt, ++ele_count) {
      for (int nn = 0; nn != num_nodes_on_ele; ++nn) {
        conn[num_nodes_on_ele * ele_count + nn] =
            mapGaussPts[level_ref_ele(tt, nn)];
      }
    }
 
    const int n_in_the_loop = E::nInTheLoop;
    CHKERR getPostProcMesh().tag_clear_data(th, postProcElements,
                                            &n_in_the_loop);
    CHKERR transferTags();
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR set_gauss_pts(
 
      ref_ele->levelGaussPtsOnRefMesh, ref_ele->levelRef,
      ref_ele->levelShapeFunctions,
 
      ref_ele->startingVertEleHandle, ref_ele->startingEleHandle,
      ref_ele->verticesOnEleArrays, ref_ele->eleConn, ref_ele->countVertEle,
      ref_ele->countEle
 
  );
 
  MoFEMFunctionReturn(0);
};

setTagsToTransfer()

template<typename E >

MoFEMErrorCode MoFEM::PostProcBrokenMeshInMoabBase< E >::setTagsToTransfer

(

std::vector< Tag >

tags_to_transfer

)

Set tags to be transferred to post-processing mesh.

Parameters

tags_to_transfer

Returns

MoFEMErrorCode

Definition at line 191 of file PostProcBrokenMeshInMoabBase.hpp.

                                     {
  MoFEMFunctionBegin;
  tagsToTransfer.swap(tags_to_transfer);
  MoFEMFunctionReturn(0);
}

transferTags()

template<typename E >

MoFEMErrorCode MoFEM::PostProcBrokenMeshInMoabBase< E >::transferTags ( )

protectedvirtual

transfer tags from mesh to post-process mesh

Definition at line 213 of file PostProcBrokenMeshInMoabBase.hpp.

                                                             {
  MoFEMFunctionBegin;
 
  auto &calc_mesh = this->mField.get_moab();
 
  auto name = [&](auto tag) {
    std::string name;
    CHK_MOAB_THROW(calc_mesh.tag_get_name(tag, name), "get name");
    return name;
  };
 
  auto data_type = [&](auto tag) {
    moab::DataType data_type;
    CHK_MOAB_THROW(calc_mesh.tag_get_data_type(tag, data_type),
                   "get data type");
    return data_type;
  };
 
  auto type = [&](auto tag) {
    moab::TagType type;
    CHK_MOAB_THROW(calc_mesh.tag_get_type(tag, type), "get tag type");
    return type;
  };
 
  auto length = [&](auto tag) {
    int length;
    CHK_MOAB_THROW(calc_mesh.tag_get_length(tag, length), "get length ");
    return length;
  };
 
  auto default_value = [&](auto tag) {
    const void *def_val;
    int size;
    CHK_MOAB_THROW(calc_mesh.tag_get_default_value(tag, def_val, size),
                   "get default tag value");
    return def_val;
  };
 
  std::vector<double> tag_data_vec;
  auto data_ptr = [&](auto tag) {
    const void *tag_data;
    auto core_ent = this->getFEEntityHandle();
    CHK_MOAB_THROW(calc_mesh.tag_get_by_ptr(tag, &core_ent, 1, &tag_data),
                   "get tag data");
    if (data_type(tag) == MB_TYPE_DOUBLE) {
      tag_data_vec.resize(length(tag));
      std::copy(static_cast<const double *>(tag_data),
                static_cast<const double *>(tag_data) + length(tag),
                tag_data_vec.begin());
      for (auto &v : tag_data_vec)
        v = std::abs(v) < std::numeric_limits<float>::min() ? 0. : v;
      for (auto &v : tag_data_vec)
        v = v > std::numeric_limits<float>::max()
                ? std::numeric_limits<float>::max()
                : v;
      for (auto &v : tag_data_vec)
        v = v < std::numeric_limits<float>::lowest()
                ? std::numeric_limits<float>::lowest()
                : v;
      return static_cast<const void *>(tag_data_vec.data());
    }
    return tag_data;
  };
 
  for (auto tag : tagsToTransfer) {
    Tag tag_postproc;
    CHKERR getPostProcMesh().tag_get_handle(
        name(tag).c_str(), length(tag), data_type(tag), tag_postproc,
        type(tag) | MB_TAG_CREAT, default_value(tag));
    CHKERR getPostProcMesh().tag_clear_data(tag_postproc, postProcElements,
                                            data_ptr(tag));
  }
 
  MoFEMFunctionReturn(0);
};

Member Data Documentation

coreMeshPtr

template<typename E >

boost::shared_ptr<moab::Core> MoFEM::PostProcBrokenMeshInMoabBase< E >::coreMeshPtr = boost::make_shared<moab::Core>()

protected

Definition at line 165 of file PostProcBrokenMeshInMoabBase.hpp.

mapGaussPts

template<typename E >

std::vector<EntityHandle> MoFEM::PostProcBrokenMeshInMoabBase< E >::mapGaussPts

protected

Definition at line 167 of file PostProcBrokenMeshInMoabBase.hpp.

optionsPrefix

template<typename E >

std::string MoFEM::PostProcBrokenMeshInMoabBase< E >::optionsPrefix = ""

protected

Prefix for options.

Definition at line 176 of file PostProcBrokenMeshInMoabBase.hpp.

postProcElements

template<typename E >

Range MoFEM::PostProcBrokenMeshInMoabBase< E >::postProcElements

protected

Definition at line 168 of file PostProcBrokenMeshInMoabBase.hpp.

refElementsMap

template<typename E >

std::map<EntityType, PostProcGenerateRefMeshPtr> MoFEM::PostProcBrokenMeshInMoabBase< E >::refElementsMap

protected

Storing data about element types, and data for ReadUtilIface to create element entities on post-process mesh.

Definition at line 171 of file PostProcBrokenMeshInMoabBase.hpp.

tagsToTransfer

template<typename E >

std::vector<Tag> MoFEM::PostProcBrokenMeshInMoabBase< E >::tagsToTransfer

protected

Set of tags on mesh to transfer to postprocessing mesh

Definition at line 174 of file PostProcBrokenMeshInMoabBase.hpp.

---

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

• src/post_proc/PostProcBrokenMeshInMoabBase.hpp