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 ()

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 >

Definition at line 94 of file PostProcBrokenMeshInMoabBase.hpp.

Constructor & Destructor Documentation

PostProcBrokenMeshInMoabBase() [1/2]

template<typename E >

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

Definition at line 277 of file PostProcBrokenMeshInMoabBase.hpp.

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

PostProcBrokenMeshInMoabBase() [2/2]

template<typename E >

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

Definition at line 282 of file PostProcBrokenMeshInMoabBase.hpp.

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

~PostProcBrokenMeshInMoabBase()

template<typename E >

PostProcBrokenMeshInMoabBase::~PostProcBrokenMeshInMoabBase ( )

virtual

Definition at line 290 of file PostProcBrokenMeshInMoabBase.hpp.

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

Member Function Documentation

getMapGaussPts()

template<typename E >

auto & PostProcBrokenMeshInMoabBase::getMapGaussPts ( )

inline

Get vector of vectors associated to integration points.

Returns

std::vector<EntityHandle>&

Definition at line 647 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                            {
  return mapGaussPts;
}

getMaxLevel()

template<typename E >

int PostProcBrokenMeshInMoabBase::getMaxLevel ( ) const

protectedvirtual

Determine refinement level based on fields approx ordre.

level = (order - 1) / 2

Returns

int

Definition at line 193 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 & PostProcBrokenMeshInMoabBase::getPostProcElements ( )

inline

Get postprocessing elements.

Returns

auto&

Definition at line 659 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                  {
  return postProcElements;
}

getPostProcMesh()

template<typename E >

auto & PostProcBrokenMeshInMoabBase::getPostProcMesh ( )

inline

Get postprocessing mesh.

Returns

moab::Interface&

Definition at line 651 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;
}

getRule()

template<typename E >

int PostProcBrokenMeshInMoabBase::getRule ( int order )

protected

Definition at line 297 of file PostProcBrokenMeshInMoabBase.hpp.

                                                                            {
  return -1;
};

postProcess()

template<typename E >

MoFEMErrorCode PostProcBrokenMeshInMoabBase::postProcess ( )

protected

Definition at line 633 of file PostProcBrokenMeshInMoabBase.hpp.

                                                            {
  MoFEMFunctionBeginHot;
 
  ParallelComm *pcomm_post_proc_mesh =
      ParallelComm::get_pcomm(&getPostProcMesh(), MYPCOMM_INDEX);
  if(pcomm_post_proc_mesh == nullptr)
    SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY, "PComm not allocated");
 
  CHKERR postProcPostProc();
  CHKERR pcomm_post_proc_mesh->resolve_shared_ents(0);
 
  MoFEMFunctionReturnHot(0);
}

postProcPostProc()

template<typename E >

MoFEMErrorCode PostProcBrokenMeshInMoabBase::postProcPostProc ( )

protectedvirtual

Definition at line 544 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 PostProcBrokenMeshInMoabBase::preProcess ( )

protected

Generate vertices and elements.

Returns

MoFEMErrorCode

Definition at line 616 of file PostProcBrokenMeshInMoabBase.hpp.

                                                           {
  MoFEMFunctionBegin;
 
  ParallelComm *pcomm_post_proc_mesh =
      ParallelComm::get_pcomm(&getPostProcMesh(), MYPCOMM_INDEX);
  if (pcomm_post_proc_mesh != NULL)
    delete pcomm_post_proc_mesh;
  CHKERR getPostProcMesh().delete_mesh();
  pcomm_post_proc_mesh =
      new ParallelComm(&(getPostProcMesh()), PETSC_COMM_WORLD);
 
  CHKERR preProcPostProc();
 
  MoFEMFunctionReturn(0);
}

preProcPostProc()

template<typename E >

MoFEMErrorCode PostProcBrokenMeshInMoabBase::preProcPostProc ( )

protectedvirtual

Definition at line 429 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 PostProcBrokenMeshInMoabBase::setGaussPts ( int order )

protected

Definition at line 302 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 PostProcBrokenMeshInMoabBase::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 186 of file PostProcBrokenMeshInMoabBase.hpp.

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

transferTags()

template<typename E >

MoFEMErrorCode PostProcBrokenMeshInMoabBase::transferTags ( )

protectedvirtual

transfer tags from mesh to post-process mesh

Definition at line 208 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>::epsilon() ? 0. : 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