PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT > Struct Template Reference

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

Inheritance diagram for PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >:

Collaboration diagram for PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >:

Classes
struct	OpHdivFunctions

Public Types
typedef PostProcTemplateOnRefineMesh< VOLUME_ELEMENT >	T
typedef PostProcCommonOnRefMesh::CommonDataForVolume	CommonData

Public Member Functions
	PostProcTemplateVolumeOnRefinedMesh (MoFEM::Interface &m_field, bool ten_nodes_post_proc_tets=true, int nb_ref_levels=-1)
int	getRule (int order)
virtual PostProcCommonOnRefMesh::CommonData &	getCommonData ()
MoFEMErrorCode	generateReferenceElementMesh ()
	Generate reference mesh on single element.
size_t	getMaxLevel () const
MoFEMErrorCode	setGaussPts (int order)
	Set integration points.
MoFEMErrorCode	clearOperators ()
	Clear operators list.
MoFEMErrorCode	preProcess ()
MoFEMErrorCode	postProcess ()
MoFEMErrorCode	addHdivFunctionsPostProc (const std::string field_name)
	Add operator to post-process Hdiv field.
Public Member Functions inherited from PostProcTemplateOnRefineMesh< VOLUME_ELEMENT >
	PostProcTemplateOnRefineMesh (MoFEM::Interface &m_field)
virtual	~PostProcTemplateOnRefineMesh ()
MoFEMErrorCode	addFieldValuesPostProc (const std::string field_name, Vec v=PETSC_NULLPTR)
	Add operator to post-process L2, H1, Hdiv, Hcurl field value.
MoFEMErrorCode	addFieldValuesPostProc (const std::string field_name, const std::string tag_name, Vec v=PETSC_NULLPTR)
	Add operator to post-process L2 or H1 field value.
MoFEMErrorCode	addFieldValuesGradientPostProc (const std::string field_name, Vec v=PETSC_NULLPTR)
	Add operator to post-process L2 or H1 field gradient.
MoFEMErrorCode	addFieldValuesGradientPostProc (const std::string field_name, const std::string tag_name, Vec v=PETSC_NULLPTR)
	Add operator to post-process L2 or H1 field gradient.
MoFEMErrorCode	addFieldValuesGradientPostProc (const std::string field_name, int space_dim, Vec v=PETSC_NULLPTR)
	Add operator to post-process L2 or H1 field gradient.
MoFEMErrorCode	writeFile (const std::string file_name, const char *file_type="MOAB", const char *file_options="PARALLEL=WRITE_PART")
	wrote results in (MOAB) format, use "file_name.h5m"

Public Attributes
bool	tenNodesPostProcTets
int	nbOfRefLevels
CommonData	commonData
Public Attributes inherited from PostProcTemplateOnRefineMesh< VOLUME_ELEMENT >
moab::Core	coreMesh
moab::Interface &	postProcMesh
boost::shared_ptr< WrapMPIComm >	wrapRefMeshComm
std::vector< EntityHandle >	mapGaussPts

Private Attributes
std::vector< MatrixDouble >	levelShapeFunctionsTets
std::vector< MatrixDouble >	levelGaussPtsOnRefMeshTets
std::vector< ublas::matrix< int > >	levelRefTets
std::vector< MatrixDouble >	levelShapeFunctionsHexes
std::vector< MatrixDouble >	levelGaussPtsOnRefMeshHexes
std::vector< ublas::matrix< int > >	levelRefHexes
EntityHandle	startingVertTetHandle
std::vector< double * >	verticesOnTetArrays
EntityHandle	startingEleTetHandle
EntityHandle *	tetConn
int	countTet
int	countVertTet
EntityHandle	startingVertHexHandle
std::vector< double * >	verticesOnHexArrays
EntityHandle	startingEleHexHandle
EntityHandle *	hexConn
int	countHex
int	countVertHex

Detailed Description

template<class VOLUME_ELEMENT>
struct PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >

Definition at line 268 of file PostProcOnRefMesh.hpp.

Member Typedef Documentation

CommonData

template<class VOLUME_ELEMENT >

typedef PostProcCommonOnRefMesh::CommonDataForVolume PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::CommonData

Definition at line 286 of file PostProcOnRefMesh.hpp.

T

template<class VOLUME_ELEMENT >

typedef PostProcTemplateOnRefineMesh<VOLUME_ELEMENT> PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::T

Definition at line 271 of file PostProcOnRefMesh.hpp.

Constructor & Destructor Documentation

PostProcTemplateVolumeOnRefinedMesh()

template<class VOLUME_ELEMENT >

PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::PostProcTemplateVolumeOnRefinedMesh ( MoFEM::Interface &  m_field, bool  ten_nodes_post_proc_tets = true, int  nb_ref_levels = -1  )

inline

Definition at line 276 of file PostProcOnRefMesh.hpp.

      : PostProcTemplateOnRefineMesh<VOLUME_ELEMENT>(m_field),
        tenNodesPostProcTets(ten_nodes_post_proc_tets),
        nbOfRefLevels(nb_ref_levels) {}

Member Function Documentation

addHdivFunctionsPostProc()

template<class VOLUME_ELEMENT >

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::addHdivFunctionsPostProc ( const std::string  field_name )

inline

Add operator to post-process Hdiv field.

Definition at line 865 of file PostProcOnRefMesh.hpp.

                                                                      {
    MoFEMFunctionBeginHot;
    T::getOpPtrVector().push_back(
        new OpHdivFunctions(T::postProcMesh, T::mapGaussPts, field_name));
    MoFEMFunctionReturnHot(0);
  }

clearOperators()

template<class VOLUME_ELEMENT >

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::clearOperators ( )

inline

Clear operators list.

Clear operators list, user can use the same mesh instance to post-process different problem or the same problem with different set of post-processed fields.

Definition at line 692 of file PostProcOnRefMesh.hpp.

                                  {
    MoFEMFunctionBeginHot;
    T::getOpPtrVector().clear();
    MoFEMFunctionReturnHot(0);
  }

generateReferenceElementMesh()

template<class VOLUME_ELEMENT >

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::generateReferenceElementMesh ( )

inline

Generate reference mesh on single element.

Each element is subdivided on smaller elements, i.e. a reference mesh on single element is created. Nodes of such reference mesh are used as integration points at which field values are calculated and to each node a "moab" tag is attached to store those values.

Definition at line 301 of file PostProcOnRefMesh.hpp.

                                                {
    MoFEMFunctionBegin;
 
    auto get_nb_of_ref_levels_from_options = [this] {
      if (nbOfRefLevels == -1) {
        int max_level = 0;
        PetscBool flg = PETSC_TRUE;
        PetscOptionsGetInt(PETSC_NULLPTR, PETSC_NULLPTR,
                           "-my_max_post_proc_ref_level", &max_level, &flg);
        return max_level;
      } else {
        return nbOfRefLevels;
      }
      return 0;
    };
 
    auto generate_for_hex = [&]() {
      MoFEMFunctionBegin;
 
      moab::Core core_ref;
      moab::Interface &moab_ref = core_ref;
 
      auto create_reference_element = [&moab_ref]() {
        MoFEMFunctionBegin;
        constexpr double base_coords[] = {0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
                                          0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1};
        EntityHandle nodes[8];
        for (int nn = 0; nn < 8; nn++)
          CHKERR moab_ref.create_vertex(&base_coords[3 * nn], nodes[nn]);
        EntityHandle hex;
        CHKERR moab_ref.create_element(MBHEX, nodes, 8, hex);
        MoFEMFunctionReturn(0);
      };
 
      auto add_ho_nodes = [&]() {
        MoFEMFunctionBegin;
        Range hexes;
        CHKERR moab_ref.get_entities_by_type(0, MBHEX, hexes, true);
        EntityHandle meshset;
        CHKERR moab_ref.create_meshset(MESHSET_SET, meshset);
        CHKERR moab_ref.add_entities(meshset, hexes);
        CHKERR moab_ref.convert_entities(meshset, true, true, true);
        CHKERR moab_ref.delete_entities(&meshset, 1);
        MoFEMFunctionReturn(0);
      };
 
      auto set_gauss_pts = [&](std::map<EntityHandle, int> &little_map) {
        MoFEMFunctionBegin;
        Range hexes;
        CHKERR moab_ref.get_entities_by_type(0, MBHEX, hexes, true);
        Range hexes_nodes;
        CHKERR moab_ref.get_connectivity(hexes, hexes_nodes, false);
        auto &gauss_pts = levelGaussPtsOnRefMeshHexes[0];
        gauss_pts.resize(hexes_nodes.size(), 4, false);
        size_t gg = 0;
        for (auto node : hexes_nodes) {
          CHKERR moab_ref.get_coords(&node, 1, &gauss_pts(gg, 0));
          little_map[node] = gg;
          ++gg;
        }
        gauss_pts = trans(gauss_pts);
        MoFEMFunctionReturn(0);
      };
 
      auto set_ref_hexes = [&](std::map<EntityHandle, int> &little_map) {
        MoFEMFunctionBegin;
        Range hexes;
        CHKERR moab_ref.get_entities_by_type(0, MBHEX, hexes, true);
        size_t hh = 0;
        auto &ref_hexes = levelRefHexes[0];
        for (auto hex : hexes) {
          const EntityHandle *conn;
          int num_nodes;
          CHKERR moab_ref.get_connectivity(hex, conn, num_nodes, false);
          if (ref_hexes.size2() != num_nodes) {
            ref_hexes.resize(hexes.size(), num_nodes);
          }
          for (int nn = 0; nn != num_nodes; ++nn) {
            ref_hexes(hh, nn) = little_map[conn[nn]];
          }
          ++hh;
        }
        MoFEMFunctionReturn(0);
      };
 
      auto set_shape_functions = [&]() {
        MoFEMFunctionBegin;
        auto &gauss_pts = levelGaussPtsOnRefMeshHexes[0];
        auto &shape_functions = levelShapeFunctionsHexes[0];
        const auto nb_gauss_pts = gauss_pts.size2();
        shape_functions.resize(nb_gauss_pts, 8);
        for (int gg = 0; gg != nb_gauss_pts; ++gg) {
          const double ksi = gauss_pts(0, gg);
          const double zeta = gauss_pts(1, gg);
          const double eta = gauss_pts(2, gg);
          shape_functions(gg, 0) = N_MBHEX0(ksi, zeta, eta);
          shape_functions(gg, 1) = N_MBHEX1(ksi, zeta, eta);
          shape_functions(gg, 2) = N_MBHEX2(ksi, zeta, eta);
          shape_functions(gg, 3) = N_MBHEX3(ksi, zeta, eta);
          shape_functions(gg, 4) = N_MBHEX4(ksi, zeta, eta);
          shape_functions(gg, 5) = N_MBHEX5(ksi, zeta, eta);
          shape_functions(gg, 6) = N_MBHEX6(ksi, zeta, eta);
          shape_functions(gg, 7) = N_MBHEX7(ksi, zeta, eta);
        }
        MoFEMFunctionReturn(0);
      };
 
      levelRefHexes.resize(1);
      levelGaussPtsOnRefMeshHexes.resize(1);
      levelShapeFunctionsHexes.resize(1);
 
      CHKERR create_reference_element();
      if (tenNodesPostProcTets)
        CHKERR add_ho_nodes();
      std::map<EntityHandle, int> little_map;
      CHKERR set_gauss_pts(little_map);
      CHKERR set_ref_hexes(little_map);
      CHKERR set_shape_functions();
 
      MoFEMFunctionReturn(0);
    };
 
    auto generate_for_tet = [&]() {
      MoFEMFunctionBegin;
 
      const int max_level = get_nb_of_ref_levels_from_options();
 
      moab::Core core_ref;
      moab::Interface &moab_ref = core_ref;
 
      auto create_reference_element = [&moab_ref]() {
        MoFEMFunctionBegin;
        constexpr double base_coords[] = {0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1};
        EntityHandle nodes[4];
        for (int nn = 0; nn < 4; nn++) {
          CHKERR
          moab_ref.create_vertex(&base_coords[3 * nn], nodes[nn]);
        }
        EntityHandle tet;
        CHKERR moab_ref.create_element(MBTET, nodes, 4, tet);
        MoFEMFunctionReturn(0);
      };
 
      MoFEM::CoreTmp<-1> m_core_ref(moab_ref, PETSC_COMM_SELF, -2);
      MoFEM::Interface &m_field_ref = m_core_ref;
 
      auto refine_ref_tetrahedron = [this, &m_field_ref, max_level]() {
        MoFEMFunctionBegin;
        // seed ref mofem database by setting bit ref level to reference
        // tetrahedron
        CHKERR
        m_field_ref.getInterface<BitRefManager>()->setBitRefLevelByDim(
            0, 3, BitRefLevel().set(0));
        for (int ll = 0; ll != max_level; ++ll) {
          MOFEM_TAG_AND_LOG_C("WORLD", Sev::verbose, "PostProc",
                              "Refine Level %d", ll);
          Range edges;
          CHKERR m_field_ref.getInterface<BitRefManager>()
              ->getEntitiesByTypeAndRefLevel(
                  BitRefLevel().set(ll), BitRefLevel().set(), MBEDGE, edges);
          Range tets;
          CHKERR m_field_ref.getInterface<BitRefManager>()
              ->getEntitiesByTypeAndRefLevel(
                  BitRefLevel().set(ll), BitRefLevel(ll).set(), MBTET, tets);
          // refine mesh
          MeshRefinement *m_ref;
          CHKERR m_field_ref.getInterface(m_ref);
          CHKERR m_ref->addVerticesInTheMiddleOfEdges(
              edges, BitRefLevel().set(ll + 1));
          CHKERR m_ref->refineTets(tets, BitRefLevel().set(ll + 1));
        }
        MoFEMFunctionReturn(0);
      };
 
      auto get_ref_gauss_pts_and_shape_functions = [this, max_level, &moab_ref,
                                                    &m_field_ref]() {
        MoFEMFunctionBegin;
        for (int ll = 0; ll != max_level + 1; ++ll) {
          Range tets;
          CHKERR
          m_field_ref.getInterface<BitRefManager>()
              ->getEntitiesByTypeAndRefLevel(
                  BitRefLevel().set(ll), BitRefLevel().set(ll), MBTET, tets);
          if (tenNodesPostProcTets) {
            EntityHandle meshset;
            CHKERR moab_ref.create_meshset(MESHSET_SET, meshset);
            CHKERR moab_ref.add_entities(meshset, tets);
            CHKERR moab_ref.convert_entities(meshset, true, false, false);
            CHKERR moab_ref.delete_entities(&meshset, 1);
          }
          Range elem_nodes;
          CHKERR moab_ref.get_connectivity(tets, elem_nodes, false);
 
          auto &gauss_pts = levelGaussPtsOnRefMeshTets[ll];
          gauss_pts.resize(elem_nodes.size(), 4, false);
          std::map<EntityHandle, int> little_map;
          Range::iterator nit = elem_nodes.begin();
          for (int gg = 0; nit != elem_nodes.end(); nit++, gg++) {
            CHKERR moab_ref.get_coords(&*nit, 1, &gauss_pts(gg, 0));
            little_map[*nit] = gg;
          }
          gauss_pts = trans(gauss_pts);
 
          auto &ref_tets = levelRefTets[ll];
          Range::iterator tit = tets.begin();
          for (int tt = 0; tit != tets.end(); ++tit, ++tt) {
            const EntityHandle *conn;
            int num_nodes;
            CHKERR moab_ref.get_connectivity(*tit, conn, num_nodes, false);
            if (tt == 0) {
              ref_tets.resize(tets.size(), num_nodes);
            }
            for (int nn = 0; nn != num_nodes; ++nn) {
              ref_tets(tt, nn) = little_map[conn[nn]];
            }
          }
 
          auto &shape_functions = levelShapeFunctionsTets[ll];
          shape_functions.resize(elem_nodes.size(), 4);
          CHKERR ShapeMBTET(&*shape_functions.data().begin(), &gauss_pts(0, 0),
                            &gauss_pts(1, 0), &gauss_pts(2, 0),
                            elem_nodes.size());
        }
        MoFEMFunctionReturn(0);
      };
 
      levelRefTets.resize(max_level + 1);
      levelGaussPtsOnRefMeshTets.resize(max_level + 1);
      levelShapeFunctionsTets.resize(max_level + 1);
 
      CHKERR create_reference_element();
      CHKERR refine_ref_tetrahedron();
      CHKERR get_ref_gauss_pts_and_shape_functions();
 
      MoFEMFunctionReturn(0);
    };
 
    CHKERR generate_for_hex();
    CHKERR generate_for_tet();
 
    MoFEMFunctionReturn(0);
  }

getCommonData()

template<class VOLUME_ELEMENT >

virtual PostProcCommonOnRefMesh::CommonData & PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::getCommonData ( )

inlinevirtual

Reimplemented from PostProcTemplateOnRefineMesh< VOLUME_ELEMENT >.

Definition at line 289 of file PostProcOnRefMesh.hpp.

                                                             {
    return commonData;
  }

getMaxLevel()

template<class VOLUME_ELEMENT >

size_t PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::getMaxLevel ( ) const

inline

Definition at line 544 of file PostProcOnRefMesh.hpp.

                             {
    auto get_element_max_dofs_order = [&]() {
      int max_order = 0;
      auto dofs_vec = this->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;
  };

getRule()

template<class VOLUME_ELEMENT >

int PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::getRule ( int  order )

inline

Definition at line 284 of file PostProcOnRefMesh.hpp.

{ return -1; };

postProcess()

template<class VOLUME_ELEMENT >

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::postProcess ( )

inline

Definition at line 799 of file PostProcOnRefMesh.hpp.

                               {
    MoFEMFunctionBeginHot;
 
    auto update_elements = [&]() {
      MoFEMFunctionBegin;
      ReadUtilIface *iface;
      CHKERR this->postProcMesh.query_interface(iface);
 
      if (countTet) {
        MOFEM_TAG_AND_LOG("SELF", Sev::noisy, "PostProc")
            << "Update tets " << countTet;
 
        MOFEM_TAG_AND_LOG("SELF", Sev::noisy, "PostProc")
            << "Nb nodes on tets " << levelRefTets[0].size2();
 
        CHKERR iface->update_adjacencies(startingEleTetHandle, countTet,
                                         levelRefTets[0].size2(), tetConn);
      }
      if (countHex) {
        MOFEM_TAG_AND_LOG("SELF", Sev::noisy, "PostProc")
            << "Update hexes " << countHex;
        CHKERR iface->update_adjacencies(startingEleHexHandle, countHex,
                                         levelRefHexes[0].size2(), hexConn);
      }
      MoFEMFunctionReturn(0);
    };
 
    auto resolve_shared_ents = [&]() {
      MoFEMFunctionBegin;
      ParallelComm *pcomm_post_proc_mesh =
          ParallelComm::get_pcomm(&(T::postProcMesh), MYPCOMM_INDEX);
      if (pcomm_post_proc_mesh == NULL) {
        // T::wrapRefMeshComm =
            // boost::make_shared<WrapMPIComm>(T::mField.get_comm(), false);
        pcomm_post_proc_mesh = new ParallelComm(
            &(T::postProcMesh),
            PETSC_COMM_WORLD /*(T::wrapRefMeshComm)->get_comm()*/);
      }
 
      Range edges;
      CHKERR T::postProcMesh.get_entities_by_type(0, MBEDGE, edges, false);
      CHKERR T::postProcMesh.delete_entities(edges);
      Range faces;
      CHKERR T::postProcMesh.get_entities_by_dimension(0, 2, faces, false);
      CHKERR T::postProcMesh.delete_entities(faces);
 
      Range ents;
      CHKERR T::postProcMesh.get_entities_by_dimension(0, 3, ents, false);
 
      int rank = T::mField.get_comm_rank();
      CHKERR T::postProcMesh.tag_clear_data(pcomm_post_proc_mesh->part_tag(),
                                            ents, &rank);
 
      CHKERR pcomm_post_proc_mesh->resolve_shared_ents(0);
 
      MoFEMFunctionReturn(0);
    };
 
    CHKERR resolve_shared_ents();
    CHKERR update_elements();
 
    MoFEMFunctionReturnHot(0);
  }

preProcess()

template<class VOLUME_ELEMENT >

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::preProcess ( )

inline

Definition at line 698 of file PostProcOnRefMesh.hpp.

                              {
    MoFEMFunctionBeginHot;
    moab::Interface &moab = T::coreMesh;
    ParallelComm *pcomm_post_proc_mesh =
        ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
    if (pcomm_post_proc_mesh != NULL)
      delete pcomm_post_proc_mesh;
 
    CHKERR T::postProcMesh.delete_mesh();
 
    auto alloc_vertices_and_elements_on_post_proc_mesh = [&]() {
      MoFEMFunctionBegin;
 
      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(this->mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
                "Wrong size of indicices. Inconsistent size number of iterated "
                "elements iterated by problem and from range.");
      }
 
      int nb_tet_vertices = 0;
      int nb_tets = 0;
      int nb_hex_vertices = 0;
      int nb_hexes = 0;
 
      for (; miit != hi_miit; ++miit) {
        auto type = (*miit)->getEntType();
 
        // Set pointer to element. So that getDataVectorDofsPtr in getMaxLevel
        // can work
        this->numeredEntFiniteElementPtr = *miit;
 
        bool add = true;
        if (this->exeTestHook) {
          add = this->exeTestHook(this);
        }
 
        if (add) {
 
          auto level = getMaxLevel();
 
          switch (type) {
          case MBTET:
            level = std::min(level, levelGaussPtsOnRefMeshTets.size() - 1);
            nb_tet_vertices += levelGaussPtsOnRefMeshTets[level].size2();
            nb_tets += levelRefTets[level].size1();
            break;
          case MBHEX:
            level = std::min(level, levelGaussPtsOnRefMeshHexes.size() - 1);
            nb_hex_vertices += levelGaussPtsOnRefMeshHexes[level].size2();
            nb_hexes += levelRefHexes[level].size1();
            break;
          default:
            SETERRQ(this->mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
                    "Element type not implemented");
            break;
          }
        }
      }
 
      ReadUtilIface *iface;
      CHKERR this->postProcMesh.query_interface(iface);
 
      if (nb_tets) {
        CHKERR iface->get_node_coords(
            3, nb_tet_vertices, 0, startingVertTetHandle, verticesOnTetArrays);
        CHKERR iface->get_element_connect(nb_tets, levelRefTets[0].size2(),
                                          MBTET, 0, startingEleTetHandle,
                                          tetConn);
      }
 
      if (nb_hexes) {
        CHKERR iface->get_node_coords(
            3, nb_hex_vertices, 0, startingVertHexHandle, verticesOnHexArrays);
        CHKERR iface->get_element_connect(nb_hexes, levelRefHexes[0].size2(),
                                          MBHEX, 0, startingEleHexHandle,
                                          hexConn);
      }
 
      countTet = 0;
      countVertTet = 0;
      countHex = 0;
      countVertHex = 0;
 
      MoFEMFunctionReturn(0);
    };
 
    CHKERR alloc_vertices_and_elements_on_post_proc_mesh();
 
    MoFEMFunctionReturnHot(0);
  }

setGaussPts()

template<class VOLUME_ELEMENT >

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::setGaussPts ( int  order )

inline

Set integration points.

If reference mesh is generated on single elements. This function maps reference coordinates into physical coordinates and create element on post-processing mesh.

Definition at line 565 of file PostProcOnRefMesh.hpp.

                                        {
    MoFEMFunctionBegin;
 
    auto type = type_from_handle(this->getFEEntityHandle());
 
    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;
 
      auto level =
          std::min(getMaxLevel(), 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];
      T::gaussPts.resize(level_ref_gauss_pts.size1(),
                         level_ref_gauss_pts.size2(), false);
      noalias(T::gaussPts) = level_ref_gauss_pts;
 
      EntityHandle fe_ent = T::numeredEntFiniteElementPtr->getEnt();
      {
        const EntityHandle *conn;
        int num_nodes;
        T::mField.get_moab().get_connectivity(fe_ent, conn, num_nodes, true);
        T::coords.resize(3 * num_nodes, false);
        CHKERR T::mField.get_moab().get_coords(conn, num_nodes, &T::coords[0]);
      }
 
      const int num_nodes = level_ref_gauss_pts.size2();
      T::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) {
 
        T::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>(T::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 T::postProcMesh.tag_get_handle(
          "NB_IN_THE_LOOP", 1, MB_TYPE_INTEGER, th,
          MB_TAG_CREAT | MB_TAG_SPARSE, &def_in_the_loop);
 
      commonData.tEts.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;
      commonData.tEts = 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] =
              T::mapGaussPts[level_ref_ele(tt, nn)];
        }
      }
 
      const int n_in_the_loop = T::nInTheLoop;
      CHKERR T::postProcMesh.tag_clear_data(th, commonData.tEts,
                                            &n_in_the_loop);
 
      MoFEMFunctionReturn(0);
    };
 
    switch (type) {
    case MBTET:
      CHKERR set_gauss_pts(levelGaussPtsOnRefMeshTets, levelRefTets,
                           levelShapeFunctionsTets,
 
                           startingVertTetHandle, startingEleTetHandle,
                           verticesOnTetArrays, tetConn, countVertTet, countTet
 
      );
      break;
    case MBHEX:
      CHKERR set_gauss_pts(levelGaussPtsOnRefMeshHexes, levelRefHexes,
                           levelShapeFunctionsHexes,
 
                           startingVertHexHandle, startingEleHexHandle,
                           verticesOnHexArrays, hexConn, countVertHex, countHex
 
      );
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "Element type not implemented");
    }
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

commonData

template<class VOLUME_ELEMENT >

CommonData PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::commonData

Definition at line 287 of file PostProcOnRefMesh.hpp.

countHex

template<class VOLUME_ELEMENT >

int PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::countHex

private

Definition at line 950 of file PostProcOnRefMesh.hpp.

countTet

template<class VOLUME_ELEMENT >

int PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::countTet

private

Definition at line 943 of file PostProcOnRefMesh.hpp.

countVertHex

template<class VOLUME_ELEMENT >

int PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::countVertHex

private

Definition at line 951 of file PostProcOnRefMesh.hpp.

countVertTet

template<class VOLUME_ELEMENT >

int PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::countVertTet

private

Definition at line 944 of file PostProcOnRefMesh.hpp.

hexConn

template<class VOLUME_ELEMENT >

EntityHandle* PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::hexConn

private

Definition at line 949 of file PostProcOnRefMesh.hpp.

levelGaussPtsOnRefMeshHexes

template<class VOLUME_ELEMENT >

std::vector<MatrixDouble> PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::levelGaussPtsOnRefMeshHexes

private

Definition at line 936 of file PostProcOnRefMesh.hpp.

levelGaussPtsOnRefMeshTets

template<class VOLUME_ELEMENT >

std::vector<MatrixDouble> PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::levelGaussPtsOnRefMeshTets

private

Definition at line 933 of file PostProcOnRefMesh.hpp.

levelRefHexes

template<class VOLUME_ELEMENT >

std::vector<ublas::matrix<int> > PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::levelRefHexes

private

Definition at line 937 of file PostProcOnRefMesh.hpp.

levelRefTets

template<class VOLUME_ELEMENT >

std::vector<ublas::matrix<int> > PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::levelRefTets

private

Definition at line 934 of file PostProcOnRefMesh.hpp.

levelShapeFunctionsHexes

template<class VOLUME_ELEMENT >

std::vector<MatrixDouble> PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::levelShapeFunctionsHexes

private

Definition at line 935 of file PostProcOnRefMesh.hpp.

levelShapeFunctionsTets

template<class VOLUME_ELEMENT >

std::vector<MatrixDouble> PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::levelShapeFunctionsTets

private

Definition at line 932 of file PostProcOnRefMesh.hpp.

nbOfRefLevels

template<class VOLUME_ELEMENT >

int PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::nbOfRefLevels

Definition at line 274 of file PostProcOnRefMesh.hpp.

startingEleHexHandle

template<class VOLUME_ELEMENT >

EntityHandle PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::startingEleHexHandle

private

Definition at line 948 of file PostProcOnRefMesh.hpp.

startingEleTetHandle

template<class VOLUME_ELEMENT >

EntityHandle PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::startingEleTetHandle

private

Definition at line 941 of file PostProcOnRefMesh.hpp.

startingVertHexHandle

template<class VOLUME_ELEMENT >

EntityHandle PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::startingVertHexHandle

private

Definition at line 946 of file PostProcOnRefMesh.hpp.

startingVertTetHandle

template<class VOLUME_ELEMENT >

EntityHandle PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::startingVertTetHandle

private

Definition at line 939 of file PostProcOnRefMesh.hpp.

tenNodesPostProcTets

template<class VOLUME_ELEMENT >

bool PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::tenNodesPostProcTets

Definition at line 273 of file PostProcOnRefMesh.hpp.

tetConn

template<class VOLUME_ELEMENT >

EntityHandle* PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::tetConn

private

Definition at line 942 of file PostProcOnRefMesh.hpp.

verticesOnHexArrays

template<class VOLUME_ELEMENT >

std::vector<double *> PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::verticesOnHexArrays

private

Definition at line 947 of file PostProcOnRefMesh.hpp.

verticesOnTetArrays

template<class VOLUME_ELEMENT >

std::vector<double *> PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::verticesOnTetArrays

private

Definition at line 940 of file PostProcOnRefMesh.hpp.

---

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

• users_modules/basic_finite_elements/src/PostProcOnRefMesh.hpp