v0.13.1
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
virtual MoFEMErrorCode query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const =0
 
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.

Examples
dm_partitioned_no_field.cpp, elasticity.cpp, mesh_smoothing.cpp, mixed_poisson.cpp, navier_stokes.cpp, and partition_mesh.cpp.

Definition at line 21 of file CommInterface.hpp.

Constructor & Destructor Documentation

◆ CommInterface()

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

Definition at line 24 of file CommInterface.cpp.

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

◆ ~CommInterface()

MoFEM::CommInterface::~CommInterface ( )

Destructor.

Definition at line 26 of file CommInterface.cpp.

26{}

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 467 of file CommInterface.cpp.

468 {
469 MoFEM::Interface &m_field = cOre;
471 if (m_field.get_comm_size() > 1) {
472
473 Range exchange_ents_data_verts, exchange_ents_data;
474
475 auto *field_ents = m_field.get_field_ents();
476 auto field_bit_number = m_field.get_field_bit_number(field_name);
477 auto lo = field_ents->get<Unique_mi_tag>().lower_bound(
478 FieldEntity::getLoBitNumberUId(field_bit_number));
479 auto hi = field_ents->get<Unique_mi_tag>().lower_bound(
480 FieldEntity::getHiBitNumberUId(field_bit_number));
481
482 for (auto it = lo; it != hi; ++it)
483 if (
484
485 ((*it)->getPStatus()) &&
486
487 (*it)->getNbDofsOnEnt()
488
489 ) {
490 if ((*it)->getEntType() == MBVERTEX)
491 exchange_ents_data_verts.insert((*it)->getEnt());
492 else
493 exchange_ents_data.insert((*it)->getEnt());
494 }
495
496 auto field_ptr = m_field.get_field_structure(field_name);
497 ParallelComm *pcomm = ParallelComm::get_pcomm(
498 &m_field.get_moab(), m_field.get_basic_entity_data_ptr()->pcommID);
499
500 auto exchange = [&](const Range &ents, Tag th) {
502 if (!ents.empty()) {
503 std::vector<Tag> tags;
504 tags.push_back(th);
505 CHKERR pcomm->exchange_tags(tags, tags, ents);
506 }
508 };
509
510 CHKERR exchange(exchange_ents_data_verts, field_ptr->th_FieldDataVerts);
511 CHKERR exchange(exchange_ents_data, field_ptr->th_FieldData);
512 }
514}
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
#define CHKERR
Inline error check.
Definition: definitions.h:535
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
constexpr auto field_name
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 303 of file CommInterface.cpp.

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

438 {
439 MoFEM::Interface &m_field = cOre;
441 if (m_field.get_comm_size() > 1) {
442 const int num_ents = entities.size();
443 std::vector<EntityHandle> vec_ents(num_ents);
444 std::copy(entities.begin(), entities.end(), vec_ents.begin());
445 CHKERR makeEntitiesMultishared(&*vec_ents.begin(), num_ents, owner_proc,
446 verb);
447 }
449}
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 452 of file CommInterface.cpp.

453 {
454 MoFEM::Interface &m_field = cOre;
456 if (m_field.get_comm_size() > 1) {
457 EntityHandle field_meshset = m_field.get_field_meshset(field_name);
458 std::vector<EntityHandle> field_ents;
459 CHKERR m_field.get_moab().get_entities_by_handle(field_meshset, field_ents,
460 true);
461 CHKERR makeEntitiesMultishared(&*field_ents.begin(), field_ents.size(),
462 owner_proc, verb);
463 }
465}
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 17 of file CommInterface.cpp.

18 {
20 *iface = const_cast<CommInterface *>(this);
22}
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:440
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 28 of file CommInterface.cpp.

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

◆ dEbug

bool MoFEM::CommInterface::dEbug

Definition at line 27 of file CommInterface.hpp.


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