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)
virtual	~PostProcBrokenMeshInMoabBase ()
auto &	getMapGaussPts ()
	Get vector of vectors associated to integration points. More...
auto &	getPostProcMesh ()
	Get postprocessing mesh. More...
auto &	getPostProcElements ()
	Get postprocessing elements. More...
MoFEMErrorCode	writeFile (const std::string file_name)
	wrote results in (MOAB) format, use "file_name.h5m" More...
MoFEMErrorCode	preProcess ()
	Generate vertices and elements. More...
MoFEMErrorCode	postProcess ()
MoFEMErrorCode	setGaussPts (int order)
MoFEMErrorCode	setTagsToTransfer (std::vector< Tag > tags_to_transfer)

Public Attributes
std::vector< EntityHandle >	mapGaussPts
Range	postProcElements

Protected Member Functions
int	getRule (int order)
virtual int	getMaxLevel () const
	Determine refinment level based on fields approx ordre. More...
virtual MoFEMErrorCode	transferTags ()

Protected Attributes
moab::Core	coreMesh
moab::Interface &	postProcMesh
std::map< EntityType, PostProcGenerateRefMeshPtr >	refElementsMap
std::vector< Tag >	tagsToTransfer

Detailed Description

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

Definition at line 95 of file PostProcBrokenMeshInMoabBase.hpp.

Constructor & Destructor Documentation

PostProcBrokenMeshInMoabBase()

template<typename E >

MoFEM::PostProcBrokenMeshInMoabBase< E >::PostProcBrokenMeshInMoabBase

(

MoFEM::Interface &

m_field

)

Definition at line 252 of file PostProcBrokenMeshInMoabBase.hpp.

    : E(m_field), postProcMesh(coreMesh) {}

~PostProcBrokenMeshInMoabBase()

template<typename E >

MoFEM::PostProcBrokenMeshInMoabBase< E >::~PostProcBrokenMeshInMoabBase

virtual

Definition at line 257 of file PostProcBrokenMeshInMoabBase.hpp.

                                                               {
  ParallelComm *pcomm_post_proc_mesh =
      ParallelComm::get_pcomm(&postProcMesh, MYPCOMM_INDEX);
  if (pcomm_post_proc_mesh != NULL)
    delete pcomm_post_proc_mesh;
}

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 608 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                            {
  return mapGaussPts;
}

getMaxLevel()

template<typename E >

int MoFEM::PostProcBrokenMeshInMoabBase< E >::getMaxLevel

protectedvirtual

Determine refinment level based on fields approx ordre.

level = (order - 1) / 2

Returns

int

Definition at line 179 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 617 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 612 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                             {
  return postProcMesh;
}

getRule()

template<typename E >

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

protected

Definition at line 264 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                            {
  return -1;
};

postProcess()

template<typename E >

MoFEMErrorCode MoFEM::PostProcBrokenMeshInMoabBase< E >::postProcess

Definition at line 519 of file PostProcBrokenMeshInMoabBase.hpp.

                                                            {
  MoFEMFunctionBeginHot;
 
  auto update_elements = [&]() {
    ReadUtilIface *iface;
    CHKERR this->postProcMesh.query_interface(iface);
    MoFEMFunctionBegin;
 
    for (auto &m : refElementsMap) {
      if (m.second->nbEles) {
        MOFEM_TAG_AND_LOG("SELF", Sev::noisy, "PostProc")
            << "Update < " << moab::CN::EntityTypeName(m.first)
            << " number of processsed " << m.second->countEle;
        CHKERR iface->update_adjacencies(
            m.second->startingEleHandle, m.second->countEle,
            m.second->levelRef[0].size2(), m.second->eleConn);
      }
    }
 
    MoFEMFunctionReturn(0);
  };
 
  auto resolve_shared_ents = [&]() {
    MoFEMFunctionBegin;
    auto get_lower_dimension = [&]() {
      int min_dim = 3;
      for (auto &m : refElementsMap) {
        const int dim = moab::CN::Dimension(m.first);
        if (m.second->nbEles) {
          min_dim = std::min(dim, min_dim);
        }
      }
      return min_dim;
    };
 
    auto remove_obsolete_entities = [&](auto &&min_dim) {
      Range edges;
      CHKERR postProcMesh.get_entities_by_type(0, MBEDGE, edges, false);
 
      Range faces;
      CHKERR postProcMesh.get_entities_by_dimension(0, 2, faces, false);
 
      Range vols;
      CHKERR postProcMesh.get_entities_by_dimension(0, 3, vols, false);
 
      Range ents;
 
      if (min_dim > 1)
        CHKERR postProcMesh.delete_entities(edges);
      else
        ents.merge(edges);
 
      if (min_dim > 2)
        CHKERR postProcMesh.delete_entities(faces);
      else
        ents.merge(faces);
 
      ents.merge(vols);
 
      return ents;
    };
 
    auto ents = remove_obsolete_entities(get_lower_dimension());
 
    ParallelComm *pcomm_post_proc_mesh =
        ParallelComm::get_pcomm(&(postProcMesh), MYPCOMM_INDEX);
    if (pcomm_post_proc_mesh == NULL) {
      // wrapRefMeshComm =
      // boost::make_shared<WrapMPIComm>(T::mField.get_comm(), false);
      pcomm_post_proc_mesh = new ParallelComm(
          &(postProcMesh),
          PETSC_COMM_WORLD /*(T::wrapRefMeshComm)->get_comm()*/);
    }
 
    int rank = E::mField.get_comm_rank();
    CHKERR postProcMesh.tag_clear_data(pcomm_post_proc_mesh->part_tag(), ents,
                                       &rank);
 
    CHKERR pcomm_post_proc_mesh->resolve_shared_ents(0);
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR update_elements();
  CHKERR resolve_shared_ents();
 
  MoFEMFunctionReturnHot(0);
}

preProcess()

template<typename E >

MoFEMErrorCode MoFEM::PostProcBrokenMeshInMoabBase< E >::preProcess

Generate vertices and elements.

Returns

MoFEMErrorCode

Definition at line 395 of file PostProcBrokenMeshInMoabBase.hpp.

                                                           {
  moab::Interface &moab = coreMesh;
  MoFEMFunctionBegin;
 
  ParallelComm *pcomm_post_proc_mesh =
      ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
  if (pcomm_post_proc_mesh != NULL)
    delete pcomm_post_proc_mesh;
 
  CHKERR postProcMesh.delete_mesh();
 
  auto get_ref_ele = [&](const EntityType type) {
    PostProcGenerateRefMeshPtr ref_ele_ptr;
 
    try {
 
      ref_ele_ptr = refElementsMap.at(type);
 
    } catch (const out_of_range &e) {
 
      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->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 postProcMesh.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

)

Definition at line 269 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) {
    SETERRQ1(
        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 postProcMesh.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 postProcMesh.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

)

Definition at line 172 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 194 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;
  };
 
  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");
    return tag_data;
  };
 
  for (auto tag : tagsToTransfer) {
    Tag tag_postproc;
    CHKERR postProcMesh.tag_get_handle(
        name(tag).c_str(), length(tag), data_type(tag), tag_postproc,
        type(tag) | MB_TAG_CREAT, default_value(tag));
    CHKERR postProcMesh.tag_clear_data(tag_postproc, postProcElements,
                                       data_ptr(tag));
  }
 
  MoFEMFunctionReturn(0);
};

Member Data Documentation

coreMesh

template<typename E >

moab::Core MoFEM::PostProcBrokenMeshInMoabBase< E >::coreMesh

protected

Definition at line 159 of file PostProcBrokenMeshInMoabBase.hpp.

mapGaussPts

template<typename E >

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

Definition at line 100 of file PostProcBrokenMeshInMoabBase.hpp.

postProcElements

template<typename E >

Range MoFEM::PostProcBrokenMeshInMoabBase< E >::postProcElements

Definition at line 101 of file PostProcBrokenMeshInMoabBase.hpp.

postProcMesh

template<typename E >

moab::Interface& MoFEM::PostProcBrokenMeshInMoabBase< E >::postProcMesh

protected

Definition at line 160 of file PostProcBrokenMeshInMoabBase.hpp.

refElementsMap

template<typename E >

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

protected

Definition at line 162 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 164 of file PostProcBrokenMeshInMoabBase.hpp.

---

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

• src/post_proc/PostProcBrokenMeshInMoabBase.hpp