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. More...
MoFEMErrorCode	setGaussPts (int order)
	Set integration points. More...
MoFEMErrorCode	clearOperators ()
	Clear operators list. More...
MoFEMErrorCode	preProcess ()
MoFEMErrorCode	postProcess ()
MoFEMErrorCode	addHdivFunctionsPostProc (const std::string field_name)
	Add operator to post-process Hdiv field. More...
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_NULL)
	Add operator to post-process L2, H1, Hdiv, Hcurl field value. More...
MoFEMErrorCode	addFieldValuesPostProc (const std::string field_name, const std::string tag_name, Vec v=PETSC_NULL)
	Add operator to post-process L2 or H1 field value. More...
MoFEMErrorCode	addFieldValuesGradientPostProc (const std::string field_name, Vec v=PETSC_NULL)
	Add operator to post-process L2 or H1 field gradient. More...
MoFEMErrorCode	addFieldValuesGradientPostProc (const std::string field_name, const std::string tag_name, Vec v=PETSC_NULL)
	Add operator to post-process L2 or H1 field gradient. More...
MoFEMErrorCode	writeFile (const std::string file_name)
	wrote results in (MOAB) format, use "file_name.h5m" More...

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

Private Attributes
std::vector< MatrixDouble >	levelShapeFunctions
std::vector< MatrixDouble >	levelGaussPtsOnRefMesh
std::vector< ublas::matrix< int > >	levelRefTets

Detailed Description

template<class VOLUME_ELEMENT>
struct PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >

Definition at line 248 of file PostProcOnRefMesh.hpp.

Member Typedef Documentation

CommonData

template<class VOLUME_ELEMENT>

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

Definition at line 264 of file PostProcOnRefMesh.hpp.

T

template<class VOLUME_ELEMENT>

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

Definition at line 251 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
	)

Definition at line 256 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

)

Add operator to post-process Hdiv field.

Definition at line 565 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

(

)

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 511 of file PostProcOnRefMesh.hpp.

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

generateReferenceElementMesh()

template<class VOLUME_ELEMENT>

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::generateReferenceElementMesh

(

)

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 281 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_NULL, PETSC_NULL,
                           "-my_max_post_proc_ref_level", &max_level, &flg);
        return max_level;
      } else {
        return nbOfRefLevels;
      }
      return 0;
    };
    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;
      const 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::Core 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) {
        PetscPrintf(T::mField.get_comm(), "Refine Level %d\n", 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->add_vertices_in_the_middle_of_edges(
            edges, BitRefLevel().set(ll + 1));
        CHKERR m_ref->refine_TET(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 = levelGaussPtsOnRefMesh[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 has number of rows equal to number of tets on element,
            // columns are number of gauss points
            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 = levelShapeFunctions[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);
    levelGaussPtsOnRefMesh.resize(max_level + 1);
    levelShapeFunctions.resize(max_level + 1);

    CHKERR create_reference_element();
    CHKERR refine_ref_tetrahedron();
    CHKERR get_ref_gauss_pts_and_shape_functions();

    MoFEMFunctionReturn(0);
  }

getCommonData()

template<class VOLUME_ELEMENT>

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

virtual

Reimplemented from PostProcTemplateOnRefineMesh< VOLUME_ELEMENT >.

Definition at line 269 of file PostProcOnRefMesh.hpp.

                                                             {
    return commonData;
  }

getRule()

template<class VOLUME_ELEMENT>

int PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::getRule

(

int

order

)

Definition at line 264 of file PostProcOnRefMesh.hpp.

{ return -1; };

postProcess()

template<class VOLUME_ELEMENT>

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::postProcess

(

)

Definition at line 529 of file PostProcOnRefMesh.hpp.

                               {
    MoFEMFunctionBeginHot;

    moab::Interface &moab = T::coreMesh;
    ParallelComm *pcomm =
        ParallelComm::get_pcomm(&T::mField.get_moab(), MYPCOMM_INDEX);
    ParallelComm *pcomm_post_proc_mesh =
        ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
    if (pcomm_post_proc_mesh == NULL) {
      pcomm_post_proc_mesh = new ParallelComm(&moab, T::mField.get_comm());
    }

    Range edges;
    CHKERR T::postProcMesh.get_entities_by_type(0, MBEDGE, edges, false);
    CHKERR T::postProcMesh.delete_entities(edges);
    Range tris;
    CHKERR T::postProcMesh.get_entities_by_type(0, MBTRI, tris, false);
    CHKERR T::postProcMesh.delete_entities(tris);

    Range tets;
    CHKERR T::postProcMesh.get_entities_by_type(0, MBTET, tets, false);

    int rank = pcomm->rank();
    Range::iterator tit = tets.begin();
    for (; tit != tets.end(); tit++) {
      CHKERR T::postProcMesh.tag_set_data(pcomm_post_proc_mesh->part_tag(),
                                          &*tit, 1, &rank);
    }

    CHKERR pcomm_post_proc_mesh->resolve_shared_ents(0);

    MoFEMFunctionReturnHot(0);
  }

preProcess()

template<class VOLUME_ELEMENT>

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::preProcess

(

)

Definition at line 517 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();
    MoFEMFunctionReturnHot(0);
  }

setGaussPts()

template<class VOLUME_ELEMENT>

MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::setGaussPts

(

int

order

)

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 413 of file PostProcOnRefMesh.hpp.

                                        {
    MoFEMFunctionBegin;

    auto get_element_max_dofs_order = [this]() {
      int max_order = 0;
      auto &dofs_multi_index = *this->dataPtr;
      for (auto &dof : dofs_multi_index) {
        const int dof_order = dof->getDofOrder();
        max_order = (max_order < dof_order) ? dof_order : max_order;
      };
      return max_order;
    };

    const int dof_max_order = get_element_max_dofs_order();
    size_t level = (dof_max_order > 0) ? (dof_max_order - 1) / 2 : 0;
    if (level > (levelGaussPtsOnRefMesh.size() - 1))
      level = levelGaussPtsOnRefMesh.size() - 1;

    auto &level_ref_gauss_pts = levelGaussPtsOnRefMesh[level];
    auto &level_ref_tets = levelRefTets[level];
    auto &shape_functions = levelShapeFunctions[level];
    T::gaussPts.resize(level_ref_gauss_pts.size1(), level_ref_gauss_pts.size2(),
                       false);
    noalias(T::gaussPts) = level_ref_gauss_pts;

    ReadUtilIface *iface;
    CHKERR T::postProcMesh.query_interface(iface);

    const int num_nodes = level_ref_gauss_pts.size2();
    std::vector<double *> arrays;
    EntityHandle startv;
    CHKERR iface->get_node_coords(3, num_nodes, 0, startv, arrays);
    T::mapGaussPts.resize(level_ref_gauss_pts.size2());
    for (int gg = 0; gg != num_nodes; ++gg)
      T::mapGaussPts[gg] = startv + gg;

    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_tets.size1();
    const int num_nodes_on_ele = level_ref_tets.size2();
    EntityHandle starte;
    EntityHandle *conn;
    CHKERR iface->get_element_connect(num_el, num_nodes_on_ele, MBTET, 0,
                                      starte, conn);
    for (unsigned int tt = 0; tt != level_ref_tets.size1(); ++tt) {
      for (int nn = 0; nn != num_nodes_on_ele; ++nn)
        conn[num_nodes_on_ele * tt + nn] =
            T::mapGaussPts[level_ref_tets(tt, nn)];
    }
    CHKERR iface->update_adjacencies(starte, num_el, num_nodes_on_ele, conn);
    commonData.tEts = Range(starte, starte + num_el - 1);
    CHKERR T::postProcMesh.tag_clear_data(th, commonData.tEts,
                                          &(T::nInTheLoop));

    EntityHandle fe_ent = T::numeredEntFiniteElementPtr->getEnt();
    T::coords.resize(12, false);
    {
      const EntityHandle *conn;
      int num_nodes;
      T::mField.get_moab().get_connectivity(fe_ent, conn, num_nodes, true);
      CHKERR T::mField.get_moab().get_coords(conn, num_nodes, &T::coords[0]);
    }

    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(
        arrays[0], arrays[1], arrays[2]);
    const double *t_coords_ele_x = &T::coords[0];
    const double *t_coords_ele_y = &T::coords[1];
    const double *t_coords_ele_z = &T::coords[2];
    for (int gg = 0; gg != num_nodes; ++gg) {
      FTensor::Tensor1<FTensor::PackPtr<const double *, 3>, 3> t_ele_coords(
          t_coords_ele_x, t_coords_ele_y, t_coords_ele_z);
      t_coords(i) = 0;
      for (int nn = 0; nn != 4; ++nn) {
        t_coords(i) += t_n * t_ele_coords(i);
        ++t_ele_coords;
        ++t_n;
      }
      ++t_coords;
    }

    MoFEMFunctionReturn(0);
  }

Member Data Documentation

commonData

template<class VOLUME_ELEMENT>

CommonData PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::commonData

Definition at line 267 of file PostProcOnRefMesh.hpp.

levelGaussPtsOnRefMesh

template<class VOLUME_ELEMENT>

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

private

Definition at line 633 of file PostProcOnRefMesh.hpp.

levelRefTets

template<class VOLUME_ELEMENT>

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

private

Definition at line 634 of file PostProcOnRefMesh.hpp.

levelShapeFunctions

template<class VOLUME_ELEMENT>

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

private

Definition at line 632 of file PostProcOnRefMesh.hpp.

nbOfRefLevels

template<class VOLUME_ELEMENT>

int PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::nbOfRefLevels

Definition at line 254 of file PostProcOnRefMesh.hpp.

tenNodesPostProcTets

template<class VOLUME_ELEMENT>

bool PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::tenNodesPostProcTets

Definition at line 253 of file PostProcOnRefMesh.hpp.

---

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

• users_modules/basic_finite_elements/src/PostProcOnRefMesh.hpp