v0.13.0
Public Member Functions | Public Attributes | List of all members
MoFEM::CommInterface Struct Reference

Managing BitRefLevels. More...

#include <src/interfaces/CommInterface.hpp>

Inheritance diagram for MoFEM::CommInterface:
[legend]
Collaboration diagram for MoFEM::CommInterface:
[legend]

Public Member Functions

MoFEMErrorCode query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
 
 CommInterface (const MoFEM::Core &core)
 
 ~CommInterface ()
 Destructor. More...
 
- Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode registerInterface (bool error_if_registration_failed=true)
 Register interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE *&iface) const
 Get interface refernce to pointer of interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE **const iface) const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get reference to interface. More...
 
template<class IFACE >
IFACE * getInterface () const
 Function returning pointer to interface. More...
 
virtual ~UnknownInterface ()=default
 

Public Attributes

MoFEM::CorecOre
 
bool dEbug
 

Make elemnts multishared

MoFEMErrorCode resolveSharedFiniteElements (const Problem *problem_ptr, const std::string &fe_name, int verb=DEFAULT_VERBOSITY)
 resolve shared entities for finite elements in the problem More...
 
MoFEMErrorCode resolveSharedFiniteElements (const std::string &name, const std::string &fe_name, int verb=DEFAULT_VERBOSITY)
 resolve shared entities for finite elements in the problem More...
 

Make entities multishared

MoFEMErrorCode makeEntitiesMultishared (const EntityHandle *entities, const int num_entities, const int owner_proc=0, int verb=DEFAULT_VERBOSITY)
 make entities from proc 0 shared on all proc More...
 
MoFEMErrorCode makeEntitiesMultishared (Range &entities, const int owner_proc=0, int verb=DEFAULT_VERBOSITY)
 make entities from proc 0 shared on all proc More...
 
MoFEMErrorCode makeFieldEntitiesMultishared (const std::string field_name, const int owner_proc=0, int verb=DEFAULT_VERBOSITY)
 make field entities multi shared More...
 
MoFEMErrorCode exchangeFieldData (const std::string field_name, int verb=DEFAULT_VERBOSITY)
 Exchange field data. More...
 

Synchronize entities (Following functions in future will be

deprecated)

MoFEMErrorCode synchroniseEntities (Range &ent, int verb=DEFAULT_VERBOSITY)
 
MoFEMErrorCode synchroniseFieldEntities (const std::string name, int verb=DEFAULT_VERBOSITY)
 

Read load and boradcoast

@

MoFEMErrorCode partitionMesh (const Range &ents, const int dim, const int adj_dim, const int n_parts, Tag *th_vertex_weights=nullptr, Tag *th_edge_weights=nullptr, Tag *th_part_weights=nullptr, int verb=VERBOSE, const bool debug=false)
 Set partition tag to each finite element in the problem. More...
 

Additional Inherited Members

- Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode getLibVersion (Version &version)
 Get library version. More...
 
static MoFEMErrorCode getFileVersion (moab::Interface &moab, Version &version)
 Get database major version. More...
 
static MoFEMErrorCode setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
 Get database major version. More...
 
static MoFEMErrorCode getInterfaceVersion (Version &version)
 Get database major version. More...
 

Detailed Description

Managing BitRefLevels.

Definition at line 31 of file CommInterface.hpp.

Constructor & Destructor Documentation

◆ CommInterface()

MoFEM::CommInterface::CommInterface ( const MoFEM::Core core)

Definition at line 37 of file CommInterface.cpp.

38  : cOre(const_cast<MoFEM::Core &>(core)), dEbug(false) {}
Core (interface) class.
Definition: Core.hpp:92

◆ ~CommInterface()

MoFEM::CommInterface::~CommInterface ( )

Destructor.

Definition at line 39 of file CommInterface.cpp.

39 {}

Member Function Documentation

◆ exchangeFieldData()

MoFEMErrorCode MoFEM::CommInterface::exchangeFieldData ( const std::string  field_name,
int  verb = DEFAULT_VERBOSITY 
)

Exchange field data.

Exchange field for all shared and ghosted entities. This function should be called collectively over the communicator for this ParallelComm. If the entities vector is empty, all shared entities participate in the exchange. If a proc has no owned entities this function must still be called since it is collective.

Note
collective - need tu be run on all processors in communicator
Todo:
It is not working if field has entities diffrent than vertices.
Parameters
verb
field_name
Returns
MoFEMErrorCode

Definition at line 480 of file CommInterface.cpp.

481  {
482  MoFEM::Interface &m_field = cOre;
484  if (m_field.get_comm_size() > 1) {
485 
486  Range exchange_ents_data_verts, exchange_ents_data;
487 
488  auto *field_ents = m_field.get_field_ents();
489  auto field_bit_number = m_field.get_field_bit_number(field_name);
490  auto lo = field_ents->get<Unique_mi_tag>().lower_bound(
491  FieldEntity::getLoBitNumberUId(field_bit_number));
492  auto hi = field_ents->get<Unique_mi_tag>().lower_bound(
493  FieldEntity::getHiBitNumberUId(field_bit_number));
494 
495  for (auto it = lo; it != hi; ++it)
496  if (
497 
498  ((*it)->getPStatus()) &&
499 
500  (*it)->getNbDofsOnEnt()
501 
502  ) {
503  if ((*it)->getEntType() == MBVERTEX)
504  exchange_ents_data_verts.insert((*it)->getEnt());
505  else
506  exchange_ents_data.insert((*it)->getEnt());
507  }
508 
509  auto field_ptr = m_field.get_field_structure(field_name);
510  ParallelComm *pcomm = ParallelComm::get_pcomm(
511  &m_field.get_moab(), m_field.get_basic_entity_data_ptr()->pcommID);
512 
513  auto exchange = [&](const Range &ents, Tag th) {
515  if (!ents.empty()) {
516  std::vector<Tag> tags;
517  tags.push_back(th);
518  CHKERR pcomm->exchange_tags(tags, tags, ents);
519  }
521  };
522 
523  CHKERR exchange(exchange_ents_data_verts, field_ptr->th_FieldDataVerts);
524  CHKERR exchange(exchange_ents_data, field_ptr->th_FieldData);
525  }
527 }
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:429
#define CHKERR
Inline error check.
Definition: definitions.h:548
virtual const FieldEntity_multiIndex * get_field_ents() const =0
Get the field ents object.
virtual Field * get_field_structure(const std::string &name)=0
get field structure
virtual int get_comm_size() const =0
virtual FieldBitNumber get_field_bit_number(const std::string name) const =0
get field bit number
virtual moab::Interface & get_moab()=0
virtual boost::shared_ptr< BasicEntityData > & get_basic_entity_data_ptr()=0
Get pointer to basic entity data.
Deprecated interface functions.
static UId getHiBitNumberUId(const FieldBitNumber bit_number)
static UId getLoBitNumberUId(const FieldBitNumber bit_number)

◆ makeEntitiesMultishared() [1/2]

MoFEMErrorCode MoFEM::CommInterface::makeEntitiesMultishared ( const EntityHandle entities,
const int  num_entities,
const int  owner_proc = 0,
int  verb = DEFAULT_VERBOSITY 
)

make entities from proc 0 shared on all proc

Note
collective - need tu be run on all processors in communicator
Parameters
entities
num_entities
my_procdefault proc id to share from
verb
Returns
MoFEMErrorCode

Definition at line 316 of file CommInterface.cpp.

318  {
319  MoFEM::Interface &m_field = cOre;
321 
322  if (m_field.get_comm_size() > 1) {
323 
324  ParallelComm *pcomm = ParallelComm::get_pcomm(
325  &m_field.get_moab(), m_field.get_basic_entity_data_ptr()->pcommID);
326 
327  Range all_ents_range;
328  all_ents_range.insert_list(entities, entities + num_entities);
329 
330  auto get_tag = [&]() { return m_field.get_moab().globalId_tag(); };
331 
332  auto delete_tag = [&](auto &&th_gid) {
334  CHKERR m_field.get_moab().tag_delete(th_gid);
336  };
337 
338  auto resolve_shared_ents = [&](auto &&th_gid, auto &all_ents_range) {
339  auto set_gid = [&](auto &th_gid) {
340  std::vector<int> gids(num_entities);
341  for (size_t g = 0; g != all_ents_range.size(); ++g)
342  gids[g] = g + 1;
343  CHKERR m_field.get_moab().tag_set_data(th_gid, all_ents_range,
344  &*gids.begin());
345 
346  return &th_gid;
347  };
348 
349  auto get_skin_ents = [&](auto &all_ents_range) {
350  std::array<Range, 4> proc_ents_skin;
351  proc_ents_skin[3] = all_ents_range.subset_by_dimension(3);
352  proc_ents_skin[2] = all_ents_range.subset_by_dimension(2);
353  proc_ents_skin[1] = all_ents_range.subset_by_dimension(1);
354  proc_ents_skin[0] = all_ents_range.subset_by_dimension(0);
355  return proc_ents_skin;
356  };
357 
358  auto resolve_dim = [&](auto &all_ents_range) {
359  for (int resolve_dim = 3; resolve_dim >= 0; --resolve_dim) {
360  if (all_ents_range.num_of_dimension(resolve_dim))
361  return resolve_dim;
362  }
363  return -1;
364  };
365 
366  auto get_proc_ent = [&](auto &all_ents_range) {
367  Range proc_ent;
368  if (m_field.get_comm_rank() == owner_proc)
369  proc_ent = all_ents_range;
370  return proc_ent;
371  };
372 
373  auto resolve_shared_ents = [&](auto &&proc_ents, auto &&skin_ents) {
374  return pcomm->resolve_shared_ents(
375  0, proc_ents, resolve_dim(all_ents_range),
376  resolve_dim(all_ents_range), skin_ents.data(), set_gid(th_gid));
377  };
378 
379  CHKERR resolve_shared_ents(get_proc_ent(all_ents_range),
380  get_skin_ents(all_ents_range));
381 
382  return th_gid;
383  };
384 
385  CHKERR delete_tag(resolve_shared_ents(get_tag(), all_ents_range));
386 
387  if (verb >= NOISY) {
388 
389  auto print_owner = [&](const EntityHandle e) {
391  int moab_owner_proc;
392  EntityHandle moab_owner_handle;
393  CHKERR pcomm->get_owner_handle(e, moab_owner_proc, moab_owner_handle);
394 
395  unsigned char pstatus = 0;
396 
397  CHKERR m_field.get_moab().tag_get_data(pcomm->pstatus_tag(), &e, 1,
398  &pstatus);
399 
400  std::vector<int> shprocs(MAX_SHARING_PROCS, 0);
401  std::vector<EntityHandle> shhandles(MAX_SHARING_PROCS, 0);
402 
403  CHKERR m_field.get_moab().tag_get_data(pcomm->sharedp_tag(), &e, 1,
404  &shprocs[0]);
405  CHKERR m_field.get_moab().tag_get_data(pcomm->sharedh_tag(), &e, 1,
406  &shhandles[0]);
407  if (pstatus & PSTATUS_MULTISHARED) {
408  CHKERR m_field.get_moab().tag_get_data(pcomm->sharedps_tag(), &e, 1,
409  &shprocs[0]);
410  CHKERR m_field.get_moab().tag_get_data(pcomm->sharedhs_tag(), &e, 1,
411  &shhandles[0]);
412  }
413 
414  std::ostringstream ss;
415 
416  ss << "Rank " << m_field.get_comm_rank() << " ";
417  if (!(pstatus & PSTATUS_NOT_OWNED))
418  ss << "OWNER ";
419  if (pstatus & PSTATUS_SHARED)
420  ss << "PSTATUS_SHARED ";
421  if (pstatus & PSTATUS_MULTISHARED)
422  ss << "PSTATUS_MULTISHARED ";
423 
424  ss << "owner " << moab_owner_proc << " (" << owner_proc << ") ";
425 
426  ss << "shprocs: ";
427  for (size_t r = 0; r != m_field.get_comm_size() + 1; ++r)
428  ss << shprocs[r] << " ";
429 
430  ss << "shhandles: ";
431  for (size_t r = 0; r != m_field.get_comm_size() + 1; ++r)
432  ss << shhandles[r] << " ";
433 
434  ss << std::endl;
435  MOFEM_LOG("SYNC", Sev::noisy) << ss.str();
436  MOFEM_LOG_SYNCHRONISE(m_field.get_comm());
437 
439  };
440 
441  for (auto e : all_ents_range)
442  CHKERR print_owner(e);
443  }
444  }
445 
447 }
#define MOFEM_LOG_SYNCHRONISE(comm)
Synchronise "SYNC" channel.
Definition: LogManager.hpp:348
@ NOISY
Definition: definitions.h:224
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:311
const double r
rate factor
constexpr double g
virtual MPI_Comm & get_comm() const =0
virtual int get_comm_rank() const =0

◆ makeEntitiesMultishared() [2/2]

MoFEMErrorCode MoFEM::CommInterface::makeEntitiesMultishared ( Range &  entities,
const int  owner_proc = 0,
int  verb = DEFAULT_VERBOSITY 
)

make entities from proc 0 shared on all proc

Note
collective - need tu be run on all processors in communicator
Parameters
entities
my_procdefault proc id to share from
verb
Returns
MoFEMErrorCode

Definition at line 449 of file CommInterface.cpp.

451  {
452  MoFEM::Interface &m_field = cOre;
454  if (m_field.get_comm_size() > 1) {
455  const int num_ents = entities.size();
456  std::vector<EntityHandle> vec_ents(num_ents);
457  std::copy(entities.begin(), entities.end(), vec_ents.begin());
458  CHKERR makeEntitiesMultishared(&*vec_ents.begin(), num_ents, owner_proc,
459  verb);
460  }
462 }
MoFEMErrorCode makeEntitiesMultishared(const EntityHandle *entities, const int num_entities, const int owner_proc=0, int verb=DEFAULT_VERBOSITY)
make entities from proc 0 shared on all proc

◆ makeFieldEntitiesMultishared()

MoFEMErrorCode MoFEM::CommInterface::makeFieldEntitiesMultishared ( const std::string  field_name,
const int  owner_proc = 0,
int  verb = DEFAULT_VERBOSITY 
)

make field entities multi shared

Note
collective - need tu be run on all processors in communicator
Parameters
field_name
owner_proc
verb
Returns
MoFEMErrorCode

Definition at line 465 of file CommInterface.cpp.

466  {
467  MoFEM::Interface &m_field = cOre;
469  if (m_field.get_comm_size() > 1) {
470  EntityHandle field_meshset = m_field.get_field_meshset(field_name);
471  std::vector<EntityHandle> field_ents;
472  CHKERR m_field.get_moab().get_entities_by_handle(field_meshset, field_ents,
473  true);
474  CHKERR makeEntitiesMultishared(&*field_ents.begin(), field_ents.size(),
475  owner_proc, verb);
476  }
478 }
virtual EntityHandle get_field_meshset(const std::string name) const =0
get field meshset

◆ query_interface()

MoFEMErrorCode MoFEM::CommInterface::query_interface ( boost::typeindex::type_index  type_index,
UnknownInterface **  iface 
) const
virtual

Implements MoFEM::UnknownInterface.

Definition at line 30 of file CommInterface.cpp.

31  {
33  *iface = const_cast<CommInterface *>(this);
35 }
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:460
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:453
CommInterface(const MoFEM::Core &core)

◆ synchroniseEntities()

MoFEMErrorCode MoFEM::CommInterface::synchroniseEntities ( Range &  ent,
int  verb = DEFAULT_VERBOSITY 
)

synchronize entity range on processors (collective)

Note
collective - need tu be run on all processors in communicator

Definition at line 41 of file CommInterface.cpp.

41  {
42  MoFEM::Interface &m_field = cOre;
43  auto ref_ents_ptr = m_field.get_ref_ents();
45 
46  // make a buffer
47  std::vector<std::vector<EntityHandle>> sbuffer(m_field.get_comm_size());
48 
49  Range::iterator eit = ents.begin();
50  for (; eit != ents.end(); eit++) {
51 
52  auto meit = ref_ents_ptr->get<Ent_mi_tag>().find(*eit);
53  if (meit == ref_ents_ptr->get<Ent_mi_tag>().end()) {
54  continue;
55  SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
56  "rank %d entity %lu not exist on database, local entity can not "
57  "be found for this owner",
58  m_field.get_comm_rank(), *eit);
59  }
60 
61  unsigned char pstatus = (*meit)->getPStatus();
62 
63  if (pstatus == 0)
64  continue;
65 
66  if (verb >= NOISY) {
67  MOFEM_LOG("SYNC", Sev::noisy) << "pstatus " << std::bitset<8>(pstatus);
68  }
69 
70  for (int proc = 0;
71  proc < MAX_SHARING_PROCS && -1 != (*meit)->getSharingProcsPtr()[proc];
72  proc++) {
73  if ((*meit)->getSharingProcsPtr()[proc] == -1)
74  SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSIBLE_CASE,
75  "sharing processor not set");
76 
77  if ((*meit)->getSharingProcsPtr()[proc] == m_field.get_comm_rank())
78  continue;
79 
80  EntityHandle handle_on_sharing_proc =
81  (*meit)->getSharingHandlersPtr()[proc];
82  sbuffer[(*meit)->getSharingProcsPtr()[proc]].push_back(
83  handle_on_sharing_proc);
84  if (verb >= NOISY)
85  MOFEM_LOG_C("SYNC", Sev::noisy, "send %lu (%lu) to %d at %d\n",
86  (*meit)->getEnt(), handle_on_sharing_proc,
87  (*meit)->getSharingProcsPtr()[proc],
88  m_field.get_comm_rank());
89 
90  if (!(pstatus & PSTATUS_MULTISHARED))
91  break;
92  }
93  }
94 
95  int nsends = 0; // number of messages to send
96  std::vector<int> sbuffer_lengths(
97  m_field.get_comm_size()); // length of the message to proc
98  const size_t block_size = sizeof(EntityHandle) / sizeof(int);
99  for (int proc = 0; proc < m_field.get_comm_size(); proc++) {
100 
101  if (!sbuffer[proc].empty()) {
102 
103  sbuffer_lengths[proc] = sbuffer[proc].size() * block_size;
104  nsends++;
105 
106  } else {
107 
108  sbuffer_lengths[proc] = 0;
109  }
110  }
111 
112  // // Make sure it is a PETSc m_field.get_comm()
113  MPI_Comm comm;
114  CHKERR PetscCommDuplicate(m_field.get_comm(), &comm, NULL);
115 
116  std::vector<MPI_Status> status(m_field.get_comm_size());
117 
118  // Computes the number of messages a node expects to receive
119  int nrecvs; // number of messages received
120  CHKERR PetscGatherNumberOfMessages(comm, NULL, &sbuffer_lengths[0], &nrecvs);
121 
122  // Computes info about messages that a MPI-node will receive, including
123  // (from-id,length) pairs for each message.
124  int *onodes; // list of node-ids from which messages are expected
125  int *olengths; // corresponding message lengths
126  CHKERR PetscGatherMessageLengths(comm, nsends, nrecvs, &sbuffer_lengths[0],
127  &onodes, &olengths);
128 
129  // Gets a unique new tag from a PETSc communicator. All processors that share
130  // the communicator MUST call this routine EXACTLY the same number of times.
131  // This tag should only be used with the current objects communicator; do NOT
132  // use it with any other MPI communicator.
133  int tag;
134  CHKERR PetscCommGetNewTag(comm, &tag);
135 
136  // Allocate a buffer sufficient to hold messages of size specified in
137  // olengths. And post Irecvs on these buffers using node info from onodes
138  int **rbuf; // must bee freed by user
139  MPI_Request *r_waits; // must bee freed by user
140  // rbuf has a pointers to messages. It has size of of nrecvs (number of
141  // messages) +1. In the first index a block is allocated,
142  // such that rbuf[i] = rbuf[i-1]+olengths[i-1].
143  CHKERR PetscPostIrecvInt(comm, tag, nrecvs, onodes, olengths, &rbuf,
144  &r_waits);
145 
146  MPI_Request *s_waits; // status of sens messages
147  CHKERR PetscMalloc1(nsends, &s_waits);
148 
149  // Send messages
150  for (int proc = 0, kk = 0; proc < m_field.get_comm_size(); proc++) {
151  if (!sbuffer_lengths[proc])
152  continue; // no message to send to this proc
153  CHKERR MPI_Isend(&(sbuffer[proc])[0], // buffer to send
154  sbuffer_lengths[proc], // message length
155  MPIU_INT, proc, // to proc
156  tag, comm, s_waits + kk);
157  kk++;
158  }
159 
160  // Wait for received
161  if (nrecvs)
162  CHKERR MPI_Waitall(nrecvs, r_waits, &status[0]);
163 
164  // Wait for send messages
165  if (nsends)
166  CHKERR MPI_Waitall(nsends, s_waits, &status[0]);
167 
168  if (verb >= VERY_VERBOSE) {
169  MOFEM_LOG_C("SYNC", Sev::verbose, "Rank %d nb. before ents %u\n",
170  m_field.get_comm_rank(), ents.size());
171  }
172 
173  // synchronise range
174  for (int kk = 0; kk < nrecvs; kk++) {
175 
176  int len = olengths[kk];
177  int *data_from_proc = rbuf[kk];
178 
179  for (int ee = 0; ee < len; ee += block_size) {
180 
181  EntityHandle ent;
182  bcopy(&data_from_proc[ee], &ent, sizeof(EntityHandle));
183  auto meit = ref_ents_ptr->get<Ent_mi_tag>().find(ent);
184  if (meit == ref_ents_ptr->get<Ent_mi_tag>().end())
185  SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
186  "rank %d entity %lu not exist on database, local entity can "
187  "not be found for this owner",
188  m_field.get_comm_rank(), ent);
189 
190  if (verb >= VERY_VERBOSE)
191  MOFEM_LOG_C("SYNC", Sev::verbose, "received %ul (%ul) from %d at %d\n",
192  (*meit)->getEnt(), ent, onodes[kk],
193  m_field.get_comm_rank());
194 
195  ents.insert((*meit)->getEnt());
196  }
197  }
198 
199  if (verb >= VERBOSE)
200  PetscSynchronizedPrintf(m_field.get_comm(), "Rank %d nb. after ents %u\n",
201  m_field.get_comm_rank(), ents.size());
202 
203  // Cleaning
204  CHKERR PetscFree(s_waits);
205  CHKERR PetscFree(rbuf[0]);
206  CHKERR PetscFree(rbuf);
207  CHKERR PetscFree(r_waits);
208  CHKERR PetscFree(onodes);
209  CHKERR PetscFree(olengths);
210  CHKERR PetscCommDestroy(&comm);
211 
212  if (verb >= VERBOSE)
213  MOFEM_LOG_SYNCHRONISE(m_field.get_comm());
214 
216 }
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:314
@ VERY_VERBOSE
Definition: definitions.h:223
@ VERBOSE
Definition: definitions.h:222
@ MOFEM_IMPOSIBLE_CASE
Definition: definitions.h:48
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:44
virtual const RefEntity_multiIndex * get_ref_ents() const =0
Get the ref ents object.

Member Data Documentation

◆ cOre

MoFEM::Core& MoFEM::CommInterface::cOre

Definition at line 36 of file CommInterface.hpp.

◆ dEbug

bool MoFEM::CommInterface::dEbug

Definition at line 37 of file CommInterface.hpp.


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