v0.8.23
Classes | Public Types | Public Member Functions | Public Attributes | Private Attributes | List of all members
PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT > Struct Template Reference

#include <users_modules/basic_finite_elements/src/PostProcOnRefMesh.hpp>

Inheritance diagram for PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >:
[legend]
Collaboration diagram for PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >:
[legend]

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)
 
virtual ~PostProcTemplateVolumeOnRefinedMesh ()
 
int getRule (int order)
 
virtual PostProcCommonOnRefMesh::CommonDatagetCommonData ()
 
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)
 
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< EntityHandlemapGaussPts
 

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

Member Typedef Documentation

◆ CommonData

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

Definition at line 275 of file PostProcOnRefMesh.hpp.

◆ T

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

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

◆ ~PostProcTemplateVolumeOnRefinedMesh()

template<class VOLUME_ELEMENT>
virtual PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::~PostProcTemplateVolumeOnRefinedMesh ( )
virtual

Definition at line 265 of file PostProcOnRefMesh.hpp.

265  {
266  moab::Interface &moab = T::coreMesh;
267  ParallelComm *pcomm_post_proc_mesh =
268  ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
269  if (pcomm_post_proc_mesh != NULL) {
270  delete pcomm_post_proc_mesh;
271  }
272  }
moab::Core coreMesh
#define MYPCOMM_INDEX
default communicator number PCOMM
Definition: definitions.h:284

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

578  {
580  T::getOpPtrVector().push_back(
581  new OpHdivFunctions(T::postProcMesh, T::mapGaussPts, field_name));
583  }
moab::Interface & postProcMesh
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:500
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:507
std::vector< EntityHandle > mapGaussPts

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

524  {
526  T::getOpPtrVector().clear();
528  }
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:500
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:507

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

292  {
294 
295  auto get_nb_of_ref_levels_from_options = [this] {
296  if (nbOfRefLevels == -1) {
297  int max_level = 0;
298  PetscBool flg = PETSC_TRUE;
299  PetscOptionsGetInt(PETSC_NULL, PETSC_NULL,
300  "-my_max_post_proc_ref_level", &max_level, &flg);
301  return max_level;
302  } else {
303  return nbOfRefLevels;
304  }
305  return 0;
306  };
307  const int max_level = get_nb_of_ref_levels_from_options();
308 
309  moab::Core core_ref;
310  moab::Interface &moab_ref = core_ref;
311 
312  auto create_reference_element = [&moab_ref]() {
314  const double base_coords[] = {0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1};
315  EntityHandle nodes[4];
316  for (int nn = 0; nn < 4; nn++) {
317  CHKERR moab_ref.create_vertex(&base_coords[3 * nn], nodes[nn]);
318  }
319  EntityHandle tet;
320  CHKERR moab_ref.create_element(MBTET, nodes, 4, tet);
322  };
323 
324  MoFEM::Core m_core_ref(moab_ref, PETSC_COMM_SELF, -2);
325  MoFEM::Interface &m_field_ref = m_core_ref;
326 
327  auto refine_ref_tetrahedron = [this, &m_field_ref, max_level]() {
329  // seed ref mofem database by setting bit ref level to reference
330  // tetrahedron
331  CHKERR m_field_ref.getInterface<BitRefManager>()->setBitRefLevelByDim(
332  0, 3, BitRefLevel().set(0));
333  for (int ll = 0; ll != max_level; ++ll) {
334  PetscPrintf(T::mField.get_comm(), "Refine Level %d\n", ll);
335  Range edges;
336  CHKERR m_field_ref.getInterface<BitRefManager>()
337  ->getEntitiesByTypeAndRefLevel(BitRefLevel().set(ll),
338  BitRefLevel().set(), MBEDGE, edges);
339  Range tets;
340  CHKERR m_field_ref.getInterface<BitRefManager>()
341  ->getEntitiesByTypeAndRefLevel(BitRefLevel().set(ll),
342  BitRefLevel(ll).set(), MBTET, tets);
343  // refine mesh
344  MeshRefinement *m_ref;
345  CHKERR m_field_ref.getInterface(m_ref);
346  CHKERR m_ref->add_vertices_in_the_middel_of_edges(
347  edges, BitRefLevel().set(ll + 1));
348  CHKERR m_ref->refine_TET(tets, BitRefLevel().set(ll + 1));
349  }
351  };
352 
353  auto get_ref_gauss_pts_and_shape_functions = [this, max_level, &moab_ref,
354  &m_field_ref]() {
356  for (int ll = 0; ll != max_level + 1; ++ll) {
357  Range tets;
358  CHKERR m_field_ref.getInterface<BitRefManager>()
359  ->getEntitiesByTypeAndRefLevel(BitRefLevel().set(ll),
360  BitRefLevel().set(ll), MBTET, tets);
361  if (tenNodesPostProcTets) {
362  EntityHandle meshset;
363  CHKERR moab_ref.create_meshset(MESHSET_SET, meshset);
364  CHKERR moab_ref.add_entities(meshset, tets);
365  CHKERR moab_ref.convert_entities(meshset, true, false, false);
366  CHKERR moab_ref.delete_entities(&meshset, 1);
367  }
368  Range elem_nodes;
369  CHKERR moab_ref.get_connectivity(tets, elem_nodes, false);
370 
371  auto &gauss_pts = levelGaussPtsOnRefMesh[ll];
372  gauss_pts.resize(elem_nodes.size(), 4, false);
373  std::map<EntityHandle, int> little_map;
374  Range::iterator nit = elem_nodes.begin();
375  for (int gg = 0; nit != elem_nodes.end(); nit++, gg++) {
376  CHKERR moab_ref.get_coords(&*nit, 1, &gauss_pts(gg, 0));
377  little_map[*nit] = gg;
378  }
379  gauss_pts = trans(gauss_pts);
380 
381  auto &ref_tets = levelRefTets[ll];
382  Range::iterator tit = tets.begin();
383  for (int tt = 0; tit != tets.end(); ++tit, ++tt) {
384  const EntityHandle *conn;
385  int num_nodes;
386  CHKERR moab_ref.get_connectivity(*tit, conn, num_nodes, false);
387  if (tt == 0) {
388  // Ref tets has number of rows equal to number of tets on element,
389  // columns are number of gauss points
390  ref_tets.resize(tets.size(), num_nodes);
391  }
392  for (int nn = 0; nn != num_nodes; ++nn) {
393  ref_tets(tt, nn) = little_map[conn[nn]];
394  }
395  }
396 
397  auto &shape_functions = levelShapeFunctions[ll];
398  shape_functions.resize(elem_nodes.size(), 4);
399  CHKERR ShapeMBTET(&*shape_functions.data().begin(), &gauss_pts(0, 0),
400  &gauss_pts(1, 0), &gauss_pts(2, 0),
401  elem_nodes.size());
402  }
404  };
405 
406  levelRefTets.resize(max_level + 1);
407  levelGaussPtsOnRefMesh.resize(max_level + 1);
408  levelShapeFunctions.resize(max_level + 1);
409 
410  CHKERR create_reference_element();
411  CHKERR refine_ref_tetrahedron();
412  CHKERR get_ref_gauss_pts_and_shape_functions();
413 
415  }
PetscErrorCode ShapeMBTET(double *N, const double *G_X, const double *G_Y, const double *G_Z, int DIM)
calculate shape functions
Definition: fem_tools.c:318
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:476
Core (interface) class.
Definition: Core.hpp:50
std::vector< ublas::matrix< int > > levelRefTets
bool tenNodesPostProcTets
MoFEMErrorCode getInterface(const MOFEMuuid &uuid, IFACE *&iface) const
Get interface by uuid and return reference to pointer of interface.
int nbOfRefLevels
std::vector< MatrixDouble > levelShapeFunctions
std::vector< MatrixDouble > levelGaussPtsOnRefMesh
#define CHKERR
Inline error check.
Definition: definitions.h:595
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition: Types.hpp:51
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:406

◆ getCommonData()

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

Reimplemented from PostProcTemplateOnRefineMesh< VOLUME_ELEMENT >.

Definition at line 280 of file PostProcOnRefMesh.hpp.

280  {
281  return commonData;
282  }
CommonData commonData

◆ getRule()

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

Definition at line 275 of file PostProcOnRefMesh.hpp.

275 { return -1; };

◆ postProcess()

template<class VOLUME_ELEMENT>
MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::postProcess ( )

Definition at line 542 of file PostProcOnRefMesh.hpp.

542  {
544 
545  moab::Interface &moab = T::coreMesh;
546  ParallelComm *pcomm =
547  ParallelComm::get_pcomm(&T::mField.get_moab(), MYPCOMM_INDEX);
548  ParallelComm *pcomm_post_proc_mesh =
549  ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
550  if (pcomm_post_proc_mesh == NULL) {
551  pcomm_post_proc_mesh = new ParallelComm(&moab, T::mField.get_comm());
552  }
553 
554  Range edges;
555  CHKERR T::postProcMesh.get_entities_by_type(0, MBEDGE, edges, false);
556  CHKERR T::postProcMesh.delete_entities(edges);
557  Range tris;
558  CHKERR T::postProcMesh.get_entities_by_type(0, MBTRI, tris, false);
559  CHKERR T::postProcMesh.delete_entities(tris);
560 
561  Range tets;
562  CHKERR T::postProcMesh.get_entities_by_type(0, MBTET, tets, false);
563 
564  int rank = pcomm->rank();
565  Range::iterator tit = tets.begin();
566  for (; tit != tets.end(); tit++) {
567  CHKERR T::postProcMesh.tag_set_data(pcomm_post_proc_mesh->part_tag(),
568  &*tit, 1, &rank);
569  }
570 
571  CHKERR pcomm_post_proc_mesh->resolve_shared_ents(0);
572 
574  }
moab::Interface & postProcMesh
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:500
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:507
moab::Core coreMesh
#define CHKERR
Inline error check.
Definition: definitions.h:595
#define MYPCOMM_INDEX
default communicator number PCOMM
Definition: definitions.h:284

◆ preProcess()

template<class VOLUME_ELEMENT>
MoFEMErrorCode PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::preProcess ( )

Definition at line 530 of file PostProcOnRefMesh.hpp.

530  {
532  moab::Interface &moab = T::coreMesh;
533  ParallelComm *pcomm_post_proc_mesh =
534  ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
535  if (pcomm_post_proc_mesh != NULL) {
536  delete pcomm_post_proc_mesh;
537  }
538  CHKERR T::postProcMesh.delete_mesh();
540  }
moab::Interface & postProcMesh
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:500
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:507
moab::Core coreMesh
#define CHKERR
Inline error check.
Definition: definitions.h:595
#define MYPCOMM_INDEX
default communicator number PCOMM
Definition: definitions.h:284

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

424  {
426 
427  auto get_element_max_dofs_order = [this]() {
428  int max_order = 0;
429  auto &dofs_multi_index = *this->dataPtr;
430  for (auto &dof : dofs_multi_index) {
431  const int dof_order = dof->getDofOrder();
432  max_order = (max_order < dof_order) ? dof_order : max_order;
433  };
434  return max_order;
435  };
436 
437  const int dof_max_order = get_element_max_dofs_order();
438  int level = (dof_max_order > 0) ? (dof_max_order - 1) / 2 : 0;
439  if (level > levelGaussPtsOnRefMesh.size() - 1) {
440  level = levelGaussPtsOnRefMesh.size() - 1;
441  }
442 
443  auto &level_ref_gauss_pts = levelGaussPtsOnRefMesh[level];
444  auto &level_ref_tets = levelRefTets[level];
445  auto &shape_functions = levelShapeFunctions[level];
446  T::gaussPts.resize(level_ref_gauss_pts.size1(),
447  level_ref_gauss_pts.size2(), false);
448  noalias(T::gaussPts) = level_ref_gauss_pts;
449 
450  ReadUtilIface *iface;
451  CHKERR T::postProcMesh.query_interface(iface);
452 
453  const int num_nodes = level_ref_gauss_pts.size2();
454  std::vector<double *> arrays;
455  EntityHandle startv;
456  CHKERR iface->get_node_coords(3, num_nodes, 0, startv, arrays);
457  T::mapGaussPts.resize(level_ref_gauss_pts.size2());
458  for (int gg = 0; gg != num_nodes; ++gg)
459  T::mapGaussPts[gg] = startv + gg;
460 
461 
462  Tag th;
463  int def_in_the_loop = -1;
464  CHKERR T::postProcMesh.tag_get_handle("NB_IN_THE_LOOP", 1, MB_TYPE_INTEGER,
465  th, MB_TAG_CREAT | MB_TAG_SPARSE,
466  &def_in_the_loop);
467 
468  commonData.tEts.clear();
469  const int num_el = level_ref_tets.size1();
470  const int num_nodes_on_ele = level_ref_tets.size2();
471  EntityHandle starte;
472  EntityHandle *conn;
473  CHKERR iface->get_element_connect(num_el, num_nodes_on_ele, MBTET, 0,
474  starte, conn);
475  for (unsigned int tt = 0; tt != level_ref_tets.size1(); ++tt) {
476  for (int nn = 0; nn != num_nodes_on_ele; ++nn)
477  conn[num_nodes_on_ele * tt + nn] =
478  T::mapGaussPts[level_ref_tets(tt, nn)];
479  }
480  CHKERR iface->update_adjacencies(starte, num_el, num_nodes_on_ele, conn);
481  commonData.tEts = Range(starte, starte + num_el - 1);
482  CHKERR T::postProcMesh.tag_clear_data(th, commonData.tEts,
483  &(T::nInTheLoop));
484 
485  EntityHandle fe_ent = T::numeredEntFiniteElementPtr->getEnt();
486  T::coords.resize(12, false);
487  {
488  const EntityHandle *conn;
489  int num_nodes;
490  T::mField.get_moab().get_connectivity(fe_ent, conn, num_nodes, true);
491  CHKERR T::mField.get_moab().get_coords(conn, num_nodes, &T::coords[0]);
492  }
493 
496  &*shape_functions.data().begin());
498  arrays[0], arrays[1], arrays[2]);
499  const double *t_coords_ele_x = &T::coords[0];
500  const double *t_coords_ele_y = &T::coords[1];
501  const double *t_coords_ele_z = &T::coords[2];
502  for (unsigned int gg = 0; gg != num_nodes; ++gg) {
504  t_coords_ele_x, t_coords_ele_y, t_coords_ele_z);
505  t_coords(i) = 0;
506  for (int nn = 0; nn != 4; ++nn) {
507  t_coords(i) += t_n * t_ele_coords(i);
508  ++t_ele_coords;
509  ++t_n;
510  }
511  ++t_coords;
512  }
513 
515  }
CommonData commonData
Range tEts
moab::Interface & postProcMesh
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:476
std::vector< ublas::matrix< int > > levelRefTets
std::vector< MatrixDouble > levelShapeFunctions
std::vector< MatrixDouble > levelGaussPtsOnRefMesh
#define CHKERR
Inline error check.
Definition: definitions.h:595
std::vector< EntityHandle > mapGaussPts
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:406

Member Data Documentation

◆ commonData

template<class VOLUME_ELEMENT>
CommonData PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::commonData

Definition at line 278 of file PostProcOnRefMesh.hpp.

◆ levelGaussPtsOnRefMesh

template<class VOLUME_ELEMENT>
std::vector<MatrixDouble> PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::levelGaussPtsOnRefMesh
private

Definition at line 646 of file PostProcOnRefMesh.hpp.

◆ levelRefTets

template<class VOLUME_ELEMENT>
std::vector<ublas::matrix<int> > PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::levelRefTets
private

Definition at line 647 of file PostProcOnRefMesh.hpp.

◆ levelShapeFunctions

template<class VOLUME_ELEMENT>
std::vector<MatrixDouble> PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::levelShapeFunctions
private

Definition at line 645 of file PostProcOnRefMesh.hpp.

◆ nbOfRefLevels

template<class VOLUME_ELEMENT>
int PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::nbOfRefLevels

Definition at line 256 of file PostProcOnRefMesh.hpp.

◆ tenNodesPostProcTets

template<class VOLUME_ELEMENT>
bool PostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::tenNodesPostProcTets

Definition at line 255 of file PostProcOnRefMesh.hpp.


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