Managing BitRefLevels. More...

#include <src/interfaces/CommInterface.hpp>

Inheritance diagram for MoFEM::CommInterface:

Collaboration diagram for MoFEM::CommInterface:

Public Member Functions
MoFEMErrorCode	query_interface (const MOFEMuuid &uuid, UnknownInterface **iface) const

	CommInterface (const MoFEM::Core &core)

	~CommInterface ()
	Destructor. More...

Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (const MOFEMuuid &uuid, bool error_if_registration_failed=true)
	Register interface. More...

template<class IFACE , bool VERIFY = false>
MoFEMErrorCode	getInterface (const MOFEMuuid &uuid, IFACE *&iface) const
	Get interface by uuid and return reference to pointer of 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 ()

virtual MoFEMErrorCode	getLibVersion (Version &version) const
	Get library version. More...

virtual const MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version) const
	Get database major version. More...

virtual MoFEMErrorCode	getInterfaceVersion (Version &version) const
	Get database major version. More...

template<>
MoFEMErrorCode	getInterface (const MOFEMuuid &uuid, UnknownInterface *&iface) const

Public Attributes
MoFEM::Core &	cOre

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)

Additional Inherited Members
Protected Member Functions inherited from MoFEM::UnknownInterface
boost::typeindex::type_index	getClassIdx (const MOFEMuuid &uid) const
	Get type name for interface Id. More...

MOFEMuuid	getUId (const boost::typeindex::type_index &class_idx) const
	Get interface Id for class name. More...

Detailed Description

Managing BitRefLevels.

Examples: dm_partitioned_no_field.cpp.

Definition at line 33 of file CommInterface.hpp.

Constructor & Destructor Documentation

◆ CommInterface()

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

Definition at line 34 of file CommInterface.cpp.

35 : cOre(const_cast<MoFEM::Core &>(core)), dEbug(false) {}

MoFEM::CommInterface::dEbug

bool dEbug

Definition: CommInterface.hpp:39

MoFEM::CommInterface::cOre

MoFEM::Core & cOre

Definition: CommInterface.hpp:38

◆ ~CommInterface()

MoFEM::CommInterface::~CommInterface ( )

Destructor.

Definition at line 36 of file CommInterface.cpp.

36 {}

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

                                                           {
   MoFEM::Interface &m_field = cOre;
   MoFEMFunctionBegin;
   if (m_field.get_comm_size() > 1) {
 
     const FieldEntity_multiIndex *field_ents;
     CHKERR m_field.get_field_ents(&field_ents);
 
     Range exchange_ents_data_verts, exchange_ents_data;
 
     for (auto it = field_ents->get<FieldName_mi_tag>().lower_bound(field_name);
          it != field_ents->get<FieldName_mi_tag>().upper_bound(field_name);
          ++it)
       if (
 
           ((*it)->getPStatus()) &&
 
           (*it)->getNbDofsOnEnt()
 
       ) {
         if ((*it)->getEntType() == MBVERTEX)
           exchange_ents_data_verts.insert((*it)->getRefEnt());
         else
           exchange_ents_data.insert((*it)->getRefEnt());
       }
 
     auto field_ptr = m_field.get_field_structure(field_name);
     ParallelComm *pcomm = ParallelComm::get_pcomm(
         &m_field.get_moab(), m_field.get_basic_entity_data_ptr()->pcommID);
 
     auto exchange = [&](const Range &ents, Tag th) {
       MoFEMFunctionBegin;
       if (!ents.empty()) {
         std::vector<Tag> tags;
         tags.push_back(th);
         CHKERR pcomm->exchange_tags(tags, tags, ents);
       }
       MoFEMFunctionReturn(0);
     };
 
     CHKERR exchange(exchange_ents_data_verts, field_ptr->th_FieldDataVerts);
     CHKERR exchange(exchange_ents_data, field_ptr->th_FieldData);
   }
   MoFEMFunctionReturn(0);
 }

◆ 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_proc	default proc id to share from
verb

Returns: MoFEMErrorCode

Definition at line 319 of file CommInterface.cpp.

                                                                        {
   MoFEM::Interface &m_field = cOre;
   MoFEMFunctionBegin;
 
   if (m_field.get_comm_size() > 1) {
 
     ParallelComm *pcomm = ParallelComm::get_pcomm(
         &m_field.get_moab(), m_field.get_basic_entity_data_ptr()->pcommID);
     const EntityHandle *ent = entities;
     const EntityHandle *const end = entities + num_entities;
     std::vector<EntityHandle> all_ents_vec(ent, end);
 
     auto print_vec = [&](auto name, auto &vec) {
       std::ostringstream ss;
       ss << "Proc " << m_field.get_comm_rank() << " ";
       ss << "vector " << name << " [ ";
       for (auto v : vec)
         ss << v << " ";
       ss << "]" << endl;
       PetscSynchronizedPrintf(m_field.get_comm(), "%s", ss.str().c_str());
       PetscSynchronizedFlush(m_field.get_comm(), PETSC_STDOUT);
     };
 
     if (verb >= NOISY)
       print_vec("all_ents_vec", all_ents_vec);
 
     const size_t block_size = sizeof(EntityHandle) / sizeof(int);
 
     int tag;
     CHKERR PetscCommGetNewTag(m_field.get_comm(), &tag);
 
     std::vector<EntityHandle> recv_ents_vec[m_field.get_comm_size()];
     std::vector<MPI_Request> r_waits(m_field.get_comm_size());
     for (int proc = 0, kk = 0; proc < m_field.get_comm_size(); ++proc) {
       if (proc != m_field.get_comm_rank()) {
         recv_ents_vec[proc].resize(all_ents_vec.size());
         CHKERR MPI_Irecv(&*recv_ents_vec[proc].begin(), // buffer to receive
                          recv_ents_vec[proc].size() *
                              block_size, // message length
                          MPIU_INT, proc, // to proc
                          tag, m_field.get_comm(), &r_waits[kk]);
         ++kk;
       }
     }
 
     std::vector<MPI_Request> s_waits(
         m_field.get_comm_size()); // status of send messages
     for (int proc = 0, kk = 0; proc < m_field.get_comm_size(); ++proc) {
       if (proc != m_field.get_comm_rank()) {
         CHKERR MPI_Isend(&*all_ents_vec.begin(),           // buffer to send
                          all_ents_vec.size() * block_size, // message length
                          MPIU_INT, proc,                   // to proc
                          tag, m_field.get_comm(), &s_waits[kk]);
         ++kk;
       }
     }
 
     std::vector<MPI_Status> status(m_field.get_comm_size());
 
     // Wait for received
     CHKERR MPI_Waitall(m_field.get_comm_size() - 1, &*r_waits.begin(),
                        &*status.begin());
 
     // Wait for send messages
     CHKERR MPI_Waitall(m_field.get_comm_size() - 1, &*s_waits.begin(),
                        &*status.begin());
 
     if (verb >= NOISY) {
       for (int proc = 0; proc < m_field.get_comm_size(); ++proc) {
         if (proc != m_field.get_comm_rank()) {
           print_vec("recv_ents_vec received from " +
                         boost::lexical_cast<std::string>(proc),
                     recv_ents_vec[proc]);
         }
       }
     }
 
     unsigned char pstatus = 0;
 
     if (m_field.get_comm_rank() != owner_proc)
       pstatus = PSTATUS_NOT_OWNED;
 
     pstatus |= PSTATUS_SHARED;
     if (m_field.get_comm_size() > 2)
       pstatus |= PSTATUS_MULTISHARED;
 
     if (pcomm->size() != m_field.get_comm_size())
       SETERRQ(PETSC_COMM_WORLD, MOFEM_NOT_IMPLEMENTED,
               "Implementation that size of PComm and MoFEM are diffrent not "
               "implemented");
 
     std::vector<int> shprocs(MAX_SHARING_PROCS, 0);
     std::vector<EntityHandle> shhandles(MAX_SHARING_PROCS, 0);
 
     for (int e = 0; e != all_ents_vec.size(); ++e) {
 
       size_t rrr = 0;
       if (m_field.get_comm_rank() != owner_proc) {
         shhandles[rrr] = (recv_ents_vec[owner_proc])[e];
         shprocs[rrr] = owner_proc;
         ++rrr;
       }
 
       for (size_t rr = 0; rr < m_field.get_comm_size(); ++rr) {
         if (rr != owner_proc && rr != m_field.get_comm_rank()) {
           shhandles[rrr] = (recv_ents_vec[rr])[e];
           shprocs[rrr] = rr;
           ++rrr;
         }
       }
 
       for (; rrr != MAX_SHARING_PROCS; ++rrr)
         shprocs[rrr] = -1;
 
       CHKERR m_field.get_moab().tag_set_data(pcomm->sharedp_tag(),
                                              &all_ents_vec[e], 1, &shprocs[0]);
       CHKERR m_field.get_moab().tag_set_data(
           pcomm->sharedh_tag(), &all_ents_vec[e], 1, &shhandles[0]);
       if (pstatus & PSTATUS_MULTISHARED) {
         CHKERR m_field.get_moab().tag_set_data(
             pcomm->sharedps_tag(), &all_ents_vec[e], 1, &shprocs[0]);
         CHKERR m_field.get_moab().tag_set_data(
             pcomm->sharedhs_tag(), &all_ents_vec[e], 1, &shhandles[0]);
       }
 
       CHKERR m_field.get_moab().tag_set_data(pcomm->pstatus_tag(),
                                              &all_ents_vec[e], 1, &pstatus);
 
       auto print_owner = [&]() {
         MoFEMFunctionBegin;
         int moab_owner_proc;
         EntityHandle moab_owner_handle;
         CHKERR pcomm->get_owner_handle(all_ents_vec[e], moab_owner_proc,
                                        moab_owner_handle);
 
         std::ostringstream ss;
 
         ss << "Rank " << m_field.get_comm_rank() << " ";
         if (!(pstatus & PSTATUS_NOT_OWNED))
           ss << "OWNER ";
         if (pstatus & PSTATUS_SHARED)
           ss << "PSTATUS_SHARED ";
         else if (pstatus & PSTATUS_MULTISHARED)
           ss << "PSTATUS_MULTISHARED ";
 
         ss << "owner " << moab_owner_proc << " (" << owner_proc << ") ";
 
         ss << std::endl;
         PetscSynchronizedPrintf(m_field.get_comm(), "%s", ss.str().c_str());
         PetscSynchronizedFlush(m_field.get_comm(), PETSC_STDOUT);
 
         MoFEMFunctionReturn(0);
       };
 
       if (verb >= NOISY)
         CHKERR print_owner();
 
       auto check_owner = [&]() {
         MoFEMFunctionBegin;
         int moab_owner_proc;
         EntityHandle moab_owner_handle;
         CHKERR pcomm->get_owner_handle(all_ents_vec[e], moab_owner_proc,
                                        moab_owner_handle);
         if (owner_proc != moab_owner_proc)
           SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "%d != %d",
                    owner_proc, moab_owner_proc);
         if (m_field.get_comm_rank() != owner_proc)
           if (recv_ents_vec[owner_proc][e] != moab_owner_handle)
             SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "%lu != %lu",
                      recv_ents_vec[owner_proc][e], moab_owner_handle);
         MoFEMFunctionReturn(0);
       };
 
       CHKERR check_owner();
     }
   }
 
   MoFEMFunctionReturn(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_proc	default proc id to share from
verb

Returns: MoFEMErrorCode

Definition at line 501 of file CommInterface.cpp.

                                                                 {
   MoFEM::Interface &m_field = cOre;
   MoFEMFunctionBegin;
   if (m_field.get_comm_size() > 1) {
     const int num_ents = entities.size();
     std::vector<EntityHandle> vec_ents(num_ents);
     std::copy(entities.begin(), entities.end(), vec_ents.begin());
     CHKERR makeEntitiesMultishared(&*vec_ents.begin(), num_ents, owner_proc,
                                    verb);
   }
   MoFEMFunctionReturn(0);
 }

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

                                                                             {
   MoFEM::Interface &m_field = cOre;
   MoFEMFunctionBegin;
   if (m_field.get_comm_size() > 1) {
     EntityHandle field_meshset = m_field.get_field_meshset(field_name);
     std::vector<EntityHandle> field_ents;
     CHKERR m_field.get_moab().get_entities_by_handle(field_meshset, field_ents,
                                                      true);
     CHKERR makeEntitiesMultishared(&*field_ents.begin(), field_ents.size(),
                                    owner_proc, verb);
   }
   MoFEMFunctionReturn(0);
 }

◆ query_interface()

MoFEMErrorCode MoFEM::CommInterface::query_interface	(	const MOFEMuuid &	uuid,
		UnknownInterface **	iface
	)		const

virtual

Implements MoFEM::UnknownInterface.

Definition at line 22 of file CommInterface.cpp.

                                                                               {
   MoFEMFunctionBeginHot;
   *iface = NULL;
   if (uuid == IDD_MOFEMComm) {
     *iface = const_cast<CommInterface *>(this);
     MoFEMFunctionReturnHot(0);
   }
   SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "unknown interface");
   MoFEMFunctionReturnHot(0);
 }

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

                                                                        {
   MoFEM::Interface &m_field = cOre;
   const RefEntity_multiIndex *ref_ents_ptr;
   MoFEMFunctionBegin;
   CHKERR m_field.get_ref_ents(&ref_ents_ptr);
 
   // make a buffer
   std::vector<std::vector<EntityHandle>> sbuffer(m_field.get_comm_size());
 
   Range::iterator eit = ents.begin();
   for (; eit != ents.end(); eit++) {
 
     auto meit = ref_ents_ptr->get<Ent_mi_tag>().find(*eit);
     if (meit == ref_ents_ptr->get<Ent_mi_tag>().end()) {
       continue;
       SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "rank %d entity %lu not exist on database, local entity can not "
                "be found for this owner",
                m_field.get_comm_rank(), *eit);
     }
 
     unsigned char pstatus = (*meit)->getPStatus();
 
     if (pstatus == 0)
       continue;
 
     if (verb >= NOISY) {
       std::ostringstream zz;
       zz << "pstatus " << std::bitset<8>(pstatus) << " ";
       PetscSynchronizedPrintf(m_field.get_comm(), "%s", zz.str().c_str());
     }
 
     for (int proc = 0;
          proc < MAX_SHARING_PROCS && -1 != (*meit)->getSharingProcsPtr()[proc];
          proc++) {
       if ((*meit)->getSharingProcsPtr()[proc] == -1)
         SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSIBLE_CASE,
                 "sharing processor not set");
 
       if ((*meit)->getSharingProcsPtr()[proc] == m_field.get_comm_rank())
         continue;
 
       EntityHandle handle_on_sharing_proc =
           (*meit)->getSharingHandlersPtr()[proc];
       sbuffer[(*meit)->getSharingProcsPtr()[proc]].push_back(
           handle_on_sharing_proc);
       if (verb >= NOISY)
         PetscSynchronizedPrintf(
             m_field.get_comm(), "send %lu (%lu) to %d at %d\n",
             (*meit)->getRefEnt(), handle_on_sharing_proc,
             (*meit)->getSharingProcsPtr()[proc], m_field.get_comm_rank());
 
       if (!(pstatus & PSTATUS_MULTISHARED))
         break;
     }
   }
 
   int nsends = 0; // number of messages to send
   std::vector<int> sbuffer_lengths(
       m_field.get_comm_size()); // length of the message to proc
   const size_t block_size = sizeof(EntityHandle) / sizeof(int);
   for (int proc = 0; proc < m_field.get_comm_size(); proc++) {
 
     if (!sbuffer[proc].empty()) {
 
       sbuffer_lengths[proc] = sbuffer[proc].size() * block_size;
       nsends++;
 
     } else {
 
       sbuffer_lengths[proc] = 0;
     }
   }
 
   // Make sure it is a PETSc m_field.get_comm()
   CHKERR PetscCommDuplicate(m_field.get_comm(), &m_field.get_comm(), NULL);
 
   std::vector<MPI_Status> status(m_field.get_comm_size());
 
   // Computes the number of messages a node expects to receive
   int nrecvs; // number of messages received
   CHKERR PetscGatherNumberOfMessages(m_field.get_comm(), NULL,
                                      &sbuffer_lengths[0], &nrecvs);
 
   // Computes info about messages that a MPI-node will receive, including
   // (from-id,length) pairs for each message.
   int *onodes;   // list of node-ids from which messages are expected
   int *olengths; // corresponding message lengths
   CHKERR PetscGatherMessageLengths(m_field.get_comm(), nsends, nrecvs,
                                    &sbuffer_lengths[0], &onodes, &olengths);
 
   // Gets a unique new tag from a PETSc communicator. All processors that share
   // the communicator MUST call this routine EXACTLY the same number of times.
   // This tag should only be used with the current objects communicator; do NOT
   // use it with any other MPI communicator.
   int tag;
   CHKERR PetscCommGetNewTag(m_field.get_comm(), &tag);
 
   // Allocate a buffer sufficient to hold messages of size specified in
   // olengths. And post Irecvs on these buffers using node info from onodes
   int **rbuf;           // must bee freed by user
   MPI_Request *r_waits; // must bee freed by user
   // rbuf has a pointers to messages. It has size of of nrecvs (number of
   // messages) +1. In the first index a block is allocated,
   // such that rbuf[i] = rbuf[i-1]+olengths[i-1].
   CHKERR PetscPostIrecvInt(m_field.get_comm(), tag, nrecvs, onodes, olengths,
                            &rbuf, &r_waits);
 
   MPI_Request *s_waits; // status of sens messages
   CHKERR PetscMalloc1(nsends, &s_waits);
 
   // Send messages
   for (int proc = 0, kk = 0; proc < m_field.get_comm_size(); proc++) {
     if (!sbuffer_lengths[proc])
       continue;                             // no message to send to this proc
     CHKERR MPI_Isend(&(sbuffer[proc])[0],   // buffer to send
                      sbuffer_lengths[proc], // message length
                      MPIU_INT, proc,        // to proc
                      tag, m_field.get_comm(), s_waits + kk);
     kk++;
   }
 
   // Wait for received
   if (nrecvs)
     CHKERR MPI_Waitall(nrecvs, r_waits, &status[0]);
 
   // Wait for send messages
   if (nsends)
     CHKERR MPI_Waitall(nsends, s_waits, &status[0]);
 
   if (verb >= VERY_VERBOSE) {
     PetscSynchronizedPrintf(m_field.get_comm(), "Rank %d nb. before ents %u\n",
                             m_field.get_comm_rank(), ents.size());
   }
 
   // synchronise range
   for (int kk = 0; kk < nrecvs; kk++) {
 
     int len = olengths[kk];
     int *data_from_proc = rbuf[kk];
 
     for (int ee = 0; ee < len; ee += block_size) {
 
       EntityHandle ent;
       bcopy(&data_from_proc[ee], &ent, sizeof(EntityHandle));
       auto meit = ref_ents_ptr->get<Ent_mi_tag>().find(ent);
       if (meit == ref_ents_ptr->get<Ent_mi_tag>().end())
         SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "rank %d entity %lu not exist on database, local entity can "
                  "not be found for this owner",
                  m_field.get_comm_rank(), ent);
 
       if (verb >= VERY_VERBOSE)
         PetscSynchronizedPrintf(
             m_field.get_comm(), "received %ul (%ul) from %d at %d\n",
             (*meit)->getRefEnt(), ent, onodes[kk], m_field.get_comm_rank());
 
       ents.insert((*meit)->getRefEnt());
     }
   }
 
   if (verb >= VERBOSE)
     PetscSynchronizedPrintf(m_field.get_comm(), "Rank %d nb. after ents %u\n",
                             m_field.get_comm_rank(), ents.size());
 
   // Cleaning
   CHKERR PetscFree(s_waits);
   CHKERR PetscFree(rbuf[0]);
   CHKERR PetscFree(rbuf);
   CHKERR PetscFree(r_waits);
   CHKERR PetscFree(onodes);
   CHKERR PetscFree(olengths);
 
   if (verb >= VERBOSE)
     PetscSynchronizedFlush(m_field.get_comm(), PETSC_STDOUT);
 
   MoFEMFunctionReturn(0);
 }

Member Data Documentation

◆ cOre

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

Definition at line 38 of file CommInterface.hpp.

◆ dEbug

bool MoFEM::CommInterface::dEbug

Definition at line 39 of file CommInterface.hpp.

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

src/interfaces/CommInterface.hpp
src/interfaces/impl/CommInterface.cpp

Public Member Functions

Public Attributes

Make elemnts multishared

Make entities multishared

Synchronize entities (Following functions in future will be

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CommInterface()

◆ ~CommInterface()

Member Function Documentation

◆ exchangeFieldData()

◆ makeEntitiesMultishared() [1/2]

◆ makeEntitiesMultishared() [2/2]

◆ makeFieldEntitiesMultishared()

◆ query_interface()

◆ synchroniseEntities()

Member Data Documentation

◆ cOre

◆ dEbug