#include "moab/Interface.hpp"
#include "moab/ParallelComm.hpp"
#include "moab/WriteUtilIface.hpp"
#include "moab/ReadUtilIface.hpp"
#include "SequenceManager.hpp"
#include "moab/Error.hpp"
#include "EntitySequence.hpp"
#include "MBTagConventions.hpp"
#include "moab/Skinner.hpp"
#include "MBParallelConventions.h"
#include "moab/Core.hpp"
#include "ElementSequence.hpp"
#include "moab/CN.hpp"
#include "moab/RangeMap.hpp"
#include "moab/MeshTopoUtil.hpp"
#include "TagInfo.hpp"
#include "DebugOutput.hpp"
#include "SharedSetData.hpp"
#include "moab/ScdInterface.hpp"
#include "moab/TupleList.hpp"
#include "moab/gs.hpp"
#include <iostream>
#include <sstream>
#include <algorithm>
#include <functional>
#include <numeric>
#include <math.h>
#include <assert.h>

Classes
struct	moab::set_tuple
struct	moab::ProcList
Namespaces
namespace	moab
	Class representing axis-aligned bounding box.
Defines
#define	PC(n, m)
#define	UPC(n, m)
#define	PRINT_DEBUG_ISEND(A, B, C, D, E) print_debug_isend((A),(B),(C),(D),(E))
#define	PRINT_DEBUG_IRECV(A, B, C, D, E, F) print_debug_irecv((A),(B),(C),(D),(E),(F))
#define	PRINT_DEBUG_RECD(A) print_debug_recd((A))
#define	PRINT_DEBUG_WAITANY(A, B, C) print_debug_waitany((A),(B),(C))
#define	RR(a)
#define	RRA(a)
#define	RRAI(i, e, a)
#define	PARALLEL_COMM_TAG_NAME "__PARALLEL_COMM"
	Tag storing parallel communication objects.
#define	ppstat(a, b) {if (pstat & a) {if (num) str << ", "; str << b; num++;};}
Enumerations
enum	moab::MBMessageTag { moab::MB_MESG_ANY = MPI_ANY_TAG, moab::MB_MESG_ENTS_ACK, moab::MB_MESG_ENTS_SIZE, moab::MB_MESG_ENTS_LARGE, moab::MB_MESG_REMOTEH_ACK, moab::MB_MESG_REMOTEH_SIZE, moab::MB_MESG_REMOTEH_LARGE, moab::MB_MESG_TAGS_ACK, moab::MB_MESG_TAGS_SIZE, moab::MB_MESG_TAGS_LARGE }
Functions
template<typename T >
static void	moab::UNPACK (unsigned char &buff, T val, size_t count)
template<typename T >
static void	moab::PACK (unsigned char &buff, const T val, size_t count)
static void	moab::PACK_INTS (unsigned char &buff, const int int_val, size_t num)
static void	moab::PACK_INT (unsigned char *&buff, int int_val)
static void	moab::PACK_DBLS (unsigned char &buff, const double dbl_val, size_t num)
static void	moab::PACK_EH (unsigned char &buff, const EntityHandle eh_val, size_t num)
static void	moab::PACK_VOID (unsigned char &buff, const void val, size_t num)
static void	moab::PACK_BYTES (unsigned char &buff, const void val, int num)
static void	moab::PACK_RANGE (unsigned char *&buff, const Range &rng)
static void	moab::UNPACK_INTS (unsigned char &buff, int int_val, size_t num)
static void	moab::UNPACK_INT (unsigned char *&buff, int &int_val)
static void	moab::UNPACK_DBLS (unsigned char &buff, double dbl_val, size_t num)
static void	moab::UNPACK_DBL (unsigned char *&buff, double &dbl_val)
static void	moab::UNPACK_EH (unsigned char &buff, EntityHandle eh_val, size_t num)
static void	moab::UNPACK_VOID (unsigned char &buff, void val, size_t num)
static void	moab::UNPACK_TYPE (unsigned char *&buff, EntityType &type)
static void	moab::UNPACK_RANGE (unsigned char *&buff, Range &rng)
static size_t	moab::RANGE_SIZE (const Range &rng)
template<class T >
T	moab::LAND (const T &arg1, const T &arg2)
template<class T >
T	moab::LOR (const T &arg1, const T &arg2)
template<class T >
T	moab::LXOR (const T &arg1, const T &arg2)
template<class T >
T	moab::MAX (const T &arg1, const T &arg2)
template<class T >
T	moab::MIN (const T &arg1, const T &arg2)
template<class T >
T	moab::ADD (const T &arg1, const T &arg2)
template<class T >
T	moab::MULT (const T &arg1, const T &arg2)
static size_t	moab::choose_owner_idx (const std::vector< unsigned > &proc_list)
bool	moab::is_sorted_unique (std::vector< unsigned > &v)
static bool	moab::operator< (const ProcList &a, const ProcList &b)
Variables
const int	moab::MAX_BCAST_SIZE = (1<<28)
std::vector < ParallelComm::Buffer * >	moab::msgs
unsigned int	moab::__PACK_num = 0
unsigned int	moab::__UNPACK_num = 0
unsigned int	moab::__PACK_count = 0
unsigned int	moab::__UNPACK_count = 0
std::string	moab::__PACK_string
std::string	moab::__UNPACK_string
const char *	moab::PARTITIONING_PCOMM_TAG_NAME = "__PRTN_PCOMM"

Define Documentation

#define PARALLEL_COMM_TAG_NAME "__PARALLEL_COMM"

Tag storing parallel communication objects.

This tag stores pointers to ParallelComm communication objects; one of these is allocated for each different communicator used to read mesh. ParallelComm stores partition and interface sets corresponding to its parallel mesh. By default, a parallel read uses the first ParallelComm object on the interface instance; if instantiated with one, ReadParallel adds this object to the interface instance too.

Tag type: opaque Tag size: MAX_SHARING_PROCS*sizeof(ParallelComm*)

Definition at line 290 of file ParallelComm.cpp.

#define PC	(	n,
		m
	)

Definition at line 72 of file ParallelComm.cpp.

#define ppstat	(	a,
		b
	)	{if (pstat & a) {if (num) str << ", "; str << b; num++;};}

#define PRINT_DEBUG_IRECV	(	A,
		B,
		C,
		D,
		E,
		F
	)	print_debug_irecv((A),(B),(C),(D),(E),(F))

Definition at line 214 of file ParallelComm.cpp.

#define PRINT_DEBUG_ISEND	(	A,
		B,
		C,
		D,
		E
	)	print_debug_isend((A),(B),(C),(D),(E))

Definition at line 213 of file ParallelComm.cpp.

#define PRINT_DEBUG_RECD ( A ) print_debug_recd((A))

Definition at line 215 of file ParallelComm.cpp.

#define PRINT_DEBUG_WAITANY	(	A,
		B,
		C
	)	print_debug_waitany((A),(B),(C))

Definition at line 216 of file ParallelComm.cpp.

#define RR ( a )

Value:

if (MB_SUCCESS != result) {        \
    errorHandler->set_last_error(a);                \
    return result;}

Definition at line 258 of file ParallelComm.cpp.

#define RRA ( a )

Value:

if (MB_SUCCESS != result) {                        \
    std::string tmp_str; mbImpl->get_last_error(tmp_str);        \
    tmp_str.append("\n"); tmp_str.append(a);                        \
    errorHandler->set_last_error(tmp_str);                        \
    return result;}

Definition at line 262 of file ParallelComm.cpp.

#define RRAI	(	i,
		e,
		a
	)

Value:

if (MB_SUCCESS != result) {        \
    std::string tmp_str; i->get_last_error(tmp_str);        \
    tmp_str.append("\n"); tmp_str.append(a);                \
    e->set_last_error(tmp_str);                                \
    return result;}

Definition at line 268 of file ParallelComm.cpp.

#define UPC	(	n,
		m
	)

Definition at line 73 of file ParallelComm.cpp.

Classes

Namespaces

Defines

Enumerations

Functions

Variables

Define Documentation