Inheritance diagram for INMOST::Mesh:

Collaboration diagram for INMOST::Mesh:

[legend]

Classes
class	base_iterator

class	BulkComparator

class	BulkDFComparator

class	CentroidComparator

class	elements_by_type

struct	exch_recv_reqs_t

class	exchange_data

class	GlobalIDComparator

class	HierarchyComparator

class	IntegerComparator

class	IntegerDFComparator

class	MarkerComparator

class	MeasureComparator

class	PrivateMarkerComparator

class	RealComparator

class	RealDFComparator

class	SetNameComparator

Public Types
enum	MeshState { Serial , Parallel }

enum	Action { AGhost , AMigrate }

enum	Prepare { UnknownSize , UnknownSource }

typedef chunk_array< integer, chunk_bits_empty >	empty_container

typedef chunk_array< integer, chunk_bits_elems >	links_container

typedef TagManager::sparse_sub_type	sparse_type

typedef TagManager::sparse_sub_record	sparse_rec

typedef sparse_type::size_type	senum

typedef void(*	ReduceOperation) (const Tag &tag, const Element &element, const INMOST_DATA_BULK_TYPE *recv_data, INMOST_DATA_ENUM_TYPE recv_size)

typedef std::vector< Tag >	tag_set

typedef std::vector< HandleType >	element_set

typedef std::vector< INMOST_DATA_BULK_TYPE >	buffer_type

typedef std::map< int, element_set >	proc_elements

typedef std::pair< int, buffer_type >	proc_buffer_type

typedef std::vector< proc_buffer_type >	exch_buffer_type

typedef std::vector< INMOST_MPI_Request >	exch_reqs_type

typedef struct INMOST::Mesh::exch_recv_reqs_t	exch_recv_reqs_type

typedef std::map< int, elements_by_type >	parallel_storage

typedef std::map< int, elements_by_type >	proc_elements_by_type

typedef base_iterator< Storage >	iteratorStorage

typedef base_iterator< Element >	iteratorElement

typedef base_iterator< ElementSet >	iteratorSet

typedef base_iterator< Cell >	iteratorCell

typedef base_iterator< Face >	iteratorFace

typedef base_iterator< Edge >	iteratorEdge

typedef base_iterator< Node >	iteratorNode

typedef std::map< GeometricData, ElementType >	GeomParam

Public Types inherited from INMOST::TagManager
typedef tag_array_type::iterator	iteratorTag

Public Types inherited from INMOST::Storage
typedef INMOST_DATA_REAL_TYPE	real
	Storage type for representing real values.

typedef INMOST_DATA_INTEGER_TYPE	integer
	Storage type for representing integer values.

typedef INMOST_DATA_BULK_TYPE	bulk
	Storage type for representing one byte of abstract data.

typedef INMOST_DATA_ENUM_TYPE	enumerator
	type for representing unsigned integer values.

typedef HandleType	reference
	Storage type for representing references to Element.

typedef RemoteHandleType	remote_reference
	Storage type for representing references to Element in another Mesh.

typedef shell< real >	real_array
	Storage type for representing arrays of real values.

typedef shell< integer >	integer_array
	Storage type for representing arrays of integer values.

typedef shell< bulk >	bulk_array
	Storage type for representing abstract data as a series of bytes.

typedef variable	var
	Storage type for representing real value with vector of variations.

typedef shell< variable >	var_array
	Storage type for representing array of values with vectors of variations.

Public Member Functions
void	AddOrientedTag (Tag t)
	Add a data tag that follows normal orientation.

void	RemOrientedTag (Tag t)
	Remove a data tag that follows normal orientation.

void	OrientTags (Face f)
	Swap sign for oriented data.

void	OrientTag (Face f, Tag t)
	Swap sign for oriented data of a single tag.

void	ReportConnection (HandleType h)
	Go through all elements and detect presence of prescribed element in any reference data tag.

bool	HaveGlobalID (ElementType types) const
	Test whether global identificator was set on certain type of elements. More...

void	Clear ()
	Remove all data and all elements from the mesh Reset geometry service and topology check flags.

enumerator	MemoryUsage (HandleType h)
	For parmetis return total number in bytes of occupied memory by element and its data.

	Mesh (std::string name)

	Mesh (const Mesh &other)

Mesh &	operator= (Mesh const &other)

MarkerType	CreateMarker ()
	Allocate a new marker. More...

MarkerType	CreatePrivateMarker ()

void	ReleaseMarker (MarkerType n, ElementType cleanup=NONE)
	Release marker back for reuse. More...

void	ReleasePrivateMarker (MarkerType n, ElementType cleanup=NONE)

__INLINE void	SetEpsilon (real e)
	Set tolerance for coordinates comparison. More...

__INLINE real	GetEpsilon () const
	Retrieve tolerance for coordinates comparison. More...

void	SetDimensions (integer dim)
	Set number of dimensions for mesh. More...

__INLINE integer	GetDimensions () const
	Get number of dimensions of mesh. More...

__INLINE MeshState	GetMeshState () const
	Get parallel state of the mesh. More...

__INLINE const Tag &	GlobalIDTag () const

__INLINE const Tag &	CoordsTag () const

__INLINE const Tag &	LowConnTag () const

__INLINE const Tag &	HighConnTag () const

__INLINE const Tag &	MarkersTag () const

__INLINE const Tag &	GeomTypeTag () const

__INLINE const Tag &	SendtoTag () const

__INLINE const Tag &	SharedTag () const

__INLINE const Tag &	OwnerTag () const

__INLINE const Tag &	LayersTag () const

__INLINE const Tag &	BridgeTag () const

__INLINE const Tag &	ProcessorsTag () const

__INLINE const Tag &	SetNameTag () const

__INLINE const Tag &	SetComparatorTag () const

__INLINE Tag	RedistributeTag ()
	Don't put this shortcut to any function directly, as it creates tag inside assign to other object of type Tag and put this object to functions.

Tag	CreateTag (std::string name, DataType dtype, ElementType etype, ElementType sparse, INMOST_DATA_ENUM_TYPE size=ENUMUNDEF)
	Create the tag by name, type and size. More...

Tag	DeleteTag (Tag tag, ElementType mask=NODE\|EDGE\|FACE\|CELL\|ESET\|MESH)
	Remove the data that is represented by the tag from elements of selected type. More...

__INLINE iteratorTag	BeginTag ()
	Returns the first tag defined on the mesh. More...

__INLINE enumerator	NumberOfTags () const
	Retrieve the total number of valid tags. More...

__INLINE iteratorTag	EndTag ()
	Returns the indicator for loop to end iteration over tags. More...

Node	CreateNode (const real *coords)
	Create node by given coordinates. More...

std::pair< Edge, bool >	CreateEdge (const ElementArray< Node > &nodes)

std::pair< Face, bool >	CreateFace (const ElementArray< Edge > &edges)

std::pair< Face, bool >	CreateFace (const ElementArray< Node > &nodes)

std::pair< Cell, bool >	CreateCell (const ElementArray< Face > &faces, const ElementArray< Node > &suggest_nodes=ElementArray< Node >(NULL))

std::pair< Cell, bool >	CreateCell (const ElementArray< Node > &c_f_nodes, const integer *c_f_numnodes, integer num_c_faces, const ElementArray< Node > &suggest_nodes=ElementArray< Node >(NULL))

std::pair< Cell, bool >	CreateCell (const ElementArray< Node > &c_nodes, const integer c_f_nodeinds, const integer c_f_numnodes, integer num_c_faces, const ElementArray< Node > &suggest_nodes=ElementArray< Node >(NULL))

std::pair< ElementSet, bool >	CreateSet (std::string name)

std::pair< ElementSet, bool >	CreateSetUnique (std::string name)
	Same as Mesh::CreateSet without checking existence of the set.

ElementSet	GetSet (std::string name)
	Retrieve set by name. More...

ElementArray< ElementSet >	GetSetsByPrefix (std::string prefix)
	Retrieve all the sets whose names start with given prefix.

HandleType	LastCreated () const

bool	isValidHandleRange (HandleType h) const

bool	isValidElementNum (integer etypenum, integer lid) const

bool	isValidElement (ElementType etype, integer lid) const

bool	isValidCell (integer lid) const

bool	isValidFace (integer lid) const

bool	isValidEdge (integer lid) const

bool	isValidNode (integer lid) const

bool	isValidElementSet (integer lid) const

bool	isValidElement (HandleType h) const

HandleType	FindSharedAdjacency (const HandleType *arr, enumerator num) const
	Retrieve upper adjacent that is shared by multiple lower adjacencies. More...

void	ReorderEmpty (ElementType reordertypes)

void	ReorderApply (Tag index, ElementType mask)

void	RestoreCellNodes (HandleType hc, ElementArray< Node > &ret)

real &	Real (HandleType h, const Tag &tag)
	Returns a reference to inner memory location of the first element of the array of real values. More...

integer &	Integer (HandleType h, const Tag &tag)
	Returns a reference to inner memory location of the first element of the array of integer values. More...

bulk &	Bulk (HandleType h, const Tag &tag)
	Returns a reference in inner representation to the first element of array of bytes. More...

reference &	Reference (HandleType h, const Tag &tag)
	Returns a reference in an inner representation to the first element of array of element handles. More...

remote_reference &	RemoteReference (HandleType h, const Tag &tag)
	Returns a reference in an inner representation to the first element of array of element remote handles. More...

real_array	RealArray (HandleType h, const Tag &tag)
	Returns an array of real values. More...

integer_array	IntegerArray (HandleType h, const Tag &tag)
	Returns an array of integer values. More...

bulk_array	BulkArray (HandleType h, const Tag &tag)
	Returns an array of bytes. More...

reference_array	ReferenceArray (HandleType h, const Tag &tag)
	Returns an array of element handles. More...

remote_reference_array	RemoteReferenceArray (HandleType h, const Tag &tag)
	Returns an array of element remote handles. More...

real &	RealDF (HandleType h, const Tag &tag)
	Returns a reference to inner memory location of the first element of the array of real values. More...

integer &	IntegerDF (HandleType h, const Tag &tag)
	Returns a reference to inner memory location of the first element of the array of integer values. More...

bulk &	BulkDF (HandleType h, const Tag &tag)
	Returns a reference in dense array to the first element of constant size array of bytes. More...

reference &	ReferenceDF (HandleType h, const Tag &tag)
	Returns a reference in dense array to the first element of constant size array of element handles. More...

remote_reference &	RemoteReferenceDF (HandleType h, const Tag &tag)
	Returns a reference in dense array to the first element of constant size array of element remote handles. More...

real_array	RealArrayDF (HandleType h, const Tag &tag)
	Returns an array of real values in dense array. More...

integer_array	IntegerArrayDF (HandleType h, const Tag &tag)
	Returns an array of integer values in dense array. More...

bulk_array	BulkArrayDF (HandleType h, const Tag &tag)
	Returns an array of bytes in dense array. More...

reference_array	ReferenceArrayDF (HandleType h, const Tag &tag)
	Returns an array of element handles in dense array. More...

remote_reference_array	RemoteReferenceArrayDF (HandleType h, const Tag &tag)
	Returns an array of element remote handles in dense array. More...

real &	RealDV (HandleType h, const Tag &tag)
	Returns a reference in dense array to the first element of variable size array of real values. More...

integer &	IntegerDV (HandleType h, const Tag &tag)
	Returns a reference in dense array to the first element of variable size array of integer values. More...

bulk &	BulkDV (HandleType h, const Tag &tag)
	Returns a reference in dense array to the first element of variable size array of bytes. More...

reference &	ReferenceDV (HandleType h, const Tag &tag)
	Returns a reference in dense array to the first element of variable size array of element handles. More...

remote_reference &	RemoteReferenceDV (HandleType h, const Tag &tag)
	Returns a reference in dense array to the first element of variable size array of element remote handles. More...

real_array	RealArrayDV (HandleType h, const Tag &tag)
	Returns an array of real values in dense array of variable size. More...

integer_array	IntegerArrayDV (HandleType h, const Tag &tag)
	Returns an array of integer values in dense array of variable size. More...

bulk_array	BulkArrayDV (HandleType h, const Tag &tag)
	Returns an array of bytes in dense array of variable size. More...

reference_array	ReferenceArrayDV (HandleType h, const Tag &tag)
	Returns an array of element handles in dense array of variable size. More...

remote_reference_array	RemoteReferenceArrayDV (HandleType h, const Tag &tag)
	Returns an array of element remote handles in dense array of variable size. More...

var &	Variable (HandleType h, const Tag &tag)

var &	VariableDF (HandleType h, const Tag &tag)

var &	VariableDV (HandleType h, const Tag &tag)

var_array	VariableArray (HandleType h, const Tag &tag)

var_array	VariableArrayDF (HandleType h, const Tag &tag)

var_array	VariableArrayDV (HandleType h, const Tag &tag)

__INLINE void	SetMarker (HandleType h, MarkerType n)
	Set a marker on the element represented by handle. More...

void	SetPrivateMarker (HandleType h, MarkerType n)

__INLINE void	SetAnyMarker (HandleType h, MarkerType n)

__INLINE void	SetMarkerArray (const HandleType *h, enumerator n, MarkerType m)
	Set a marker on the set of handles. More...

__INLINE void	SetPrivateMarkerArray (const HandleType *h, enumerator n, MarkerType m)

__INLINE void	SetAnyMarkerArray (const HandleType *h, enumerator n, MarkerType m)

__INLINE bool	GetMarker (HandleType h, MarkerType n) const
	Check whether the marker is set one the element. More...

bool	GetPrivateMarker (HandleType h, MarkerType n) const

__INLINE bool	GetAnyMarker (HandleType h, MarkerType n) const

__INLINE void	RemMarker (HandleType h, MarkerType n)
	Remove the marker from the element. More...

void	RemPrivateMarker (HandleType h, MarkerType n)

__INLINE void	RemAnyMarker (HandleType h, MarkerType n)

void	RemMarkerArray (const HandleType *h, enumerator n, MarkerType m)
	Remove the marker from the set of handles. More...

void	RemPrivateMarkerArray (const HandleType *h, enumerator n, MarkerType m)

void	ClearMarkerSpace (HandleType h)
	Remove all the markers from the element.

void	GetMarkerSpace (HandleType h, bulk copy[MarkerFields]) const
	Get a copy of the bytes that store markers on the element. More...

void	SetMarkerSpace (HandleType h, bulk source[MarkerFields])
	Overwrite the bytes that store markers on the element. More...

Element::adj_type &	HighConn (HandleType h)
	Access directly higher order adjacencies of current element with right of modification. More...

ElementType	HaveUpperAdjacencies () const
	Check that upper adjacencies are stored.

void	RemoveUpperAdjacencies (ElementType mask=(NODE\|EDGE\|FACE))
	Delete all upper adjacencies, access to HighConn should fire assertion and retrieval of upper adjacencies is no longer valid.

void	RestoreUpperAdjacencies (ElementType mask=(NODE\|EDGE\|FACE))
	Restore all upper adjacencies.

ElementType	HaveLowerAdjacencies () const
	Check that upper adjacencies are stored.

void	RemoveLowerAdjacencies (ElementType mask=(EDGE\|FACE\|CELL))
	Delete all upper adjacencies, access to HighConn should fire assertion and retrieval of upper adjacencies is no longer valid.

void	RestoreLowerAdjacencies (ElementType mask=(EDGE\|FACE\|CELL))
	Restore all upper adjacencies.

Element::adj_type const &	HighConn (HandleType h) const
	Access directly higher order adjacencies of current element without right of modification.

Element::adj_type &	LowConn (HandleType h)
	Access directly lower order adjacencies of current element with right of modification. More...

Element::adj_type const &	LowConn (HandleType h) const
	Access directly lower order adjacencies of current element without right of modification.

INMOST_DATA_ENUM_TYPE	GetDataSize (HandleType h, const Tag &tag) const
	Return the size of the array. More...

INMOST_DATA_ENUM_TYPE	GetDataCapacity (HandleType h, const Tag &tag) const
	Return the size of the structure in bytes required to represent the data on current element. More...

INMOST_DATA_ENUM_TYPE	GetDataCapacity (const INMOST_DATA_BULK_TYPE *data, INMOST_DATA_ENUM_TYPE size, const Tag &tag) const
	Returns the number of bytes in data used for given type of tag. More...

void	SetDataSize (HandleType h, const Tag &tag, enumerator new_size)
	Sets the size of the array for data of variable size. More...

void	GetData (HandleType h, const Tag &tag, enumerator shift, enumerator size, void *data) const
	Copy inner data array of size elements to provided array beginning from shift element. More...

void	SetData (HandleType h, const Tag &tag, enumerator shift, enumerator size, const void *data)
	Copy into inner data array of size elements from provided array beginning from shift element. More...

void	DelData (HandleType h, const Tag &tag)
	Remove tag data from given element. More...

void	DelDenseData (HandleType h, const Tag &tag)
	Removes data of variable size, clears to zero data of fixed size. More...

void	DelDenseData (void *data, const Tag &tag)
	Removes data of variable size, clears to zero data of fixed size. More...

bool	DelSparseData (HandleType h, const Tag &tag)
	Removes data of variable size and sparse tag data. More...

bool	HaveData (HandleType h, const Tag &tag) const
	Check whether data is present on given element. More...

Element::GeometricType	GetGeometricType (HandleType h) const

void	SetGeometricType (HandleType h, Element::GeometricType type)

integer &	GlobalID (HandleType h)
	Retrieve global id of the element with right of modification (dangerous to modify). More...

integer	GlobalID (HandleType h) const
	Retrieve global id of the element without right of modification. More...

integer	DataLocalID (HandleType h) const
	Retrieve position of the data position of current element. More...

Element::Status	GetStatus (HandleType h) const
	Retrieve parallel status of the element. More...

void	SetStatus (HandleType h, Element::Status s)
	Set parallel status of the element. More...

void	Destroy (HandleType h)
	Completely destroy element from mesh. More...

void	Destroy (const Storage &e)
	Shortcut for typed elements.

bool	Hide (HandleType h)
	Hide element from mesh. More...

bool	Show (HandleType h)
	Show element from mesh. More...

bool	Delete (HandleType h)
	This function will hide element in modification state (between BeginModification and EndModification) or call Destroy in non-modification state. More...

bool	Hidden (HandleType h) const
	Check whether element is hidden. More...

bool	New (HandleType h) const
	Check whether element is new. More...

void	ComputeGeometricType (HandleType h)
	Recompute geometrical type of current element and set it to element. More...

INMOST_DATA_ENUM_TYPE	GetArrayCapacity (integer etypenum)
	This function is needed by TagManager, may be made private in future follows definition of chunk_array to estimate current occupancy of arrays.

HandleType	FindSharedGhost (ElementType etype, Storage::integer global_id, int source_proc, int owner_proc)

void	ClearFile ()

void	SetParallelFileStrategy (int strategy)
	Set parallel strategy for inner communications. More...

int	GetParallelFileStrategy () const
	Retrieve currently set parallel strategy for ".pmf" files. More...

int	GetProcessorRank () const
	Get rank of current processor.

int	GetProcessorsNumber () const
	Get number of processors.

int	GetLocalProcessorRank () const
	Get rank of current processor in shared environment (OpenMP)

int	GetLocalProcessorNumber () const
	Get number of processors in shared environment (OpenMP)

INMOST_MPI_Comm	GetCommunicator () const
	Retrieve MPI communicator.

INMOST_MPI_Group	GetGroup () const
	Retrieve MPI group corresponding to the communicator.

void	SetCommunicator (INMOST_MPI_Comm _comm)
	Set MPI communicator.

void	ResolveShared (bool only_new=false)
	Find elements that are common between processors.

void	ResolveSets ()
	Find sets that are common between processors.

void	RemoveGhost (MarkerType marker=0)
	Delete all the ghost cells.

void	RemoveGhostElements (const HandleType *ghost, enumerator num)
	Delete some ghost cells provided in array. More...

template<typename EType >
void	RemoveGhostElements (const ElementArray< EType > &ghost)

void	RemoveGhostElements (const ElementSet &ghost)

void	AssignGlobalID (ElementType mask)
	Assign unique numbers to elements. More...

void	ExchangeData (const Tag &tag, ElementType mask, MarkerType select=0)
	Update data from Shared elements to Ghost elements. More...

void	ExchangeOrientedData (const Tag &tag, ElementType mask, MarkerType select=0, MarkerType orient=0)
	This function is similar to ExchangeData, except that it will change the orientation of recieved data upon completion for the exchanged tags, registered through AddOrientedTag. More...

void	ExchangeDataBegin (const Tag &tag, ElementType mask, MarkerType select, exchange_data &storage)
	Start asynchronous synchronization of data. More...

void	ExchangeDataEnd (const Tag &tag, ElementType mask, MarkerType select, exchange_data &storage)
	Complete asynchronous synchronization of data. More...

void	ExchangeData (const tag_set &tags, ElementType mask, MarkerType select=0)
	This function will perform exchange of multiple data tags. More...

void	ExchangeOrientedData (const tag_set &tags, ElementType mask, MarkerType select=0, MarkerType orient=0)
	This function is similar to ExchangeData, except that it will change the orientation of recieved data upon completion for the exchanged tags, registered through AddOrientedTag. More...

void	ExchangeDataBegin (const tag_set &tags, ElementType mask, MarkerType select, exchange_data &storage)
	This function will initialize exchange of multiple data tags. More...

void	ExchangeDataEnd (const tag_set &tags, ElementType mask, MarkerType select, exchange_data &storage)
	This function will finalize exchange of multiple data tags. More...

void	ReduceData (const Tag &tag, ElementType mask, MarkerType select, ReduceOperation op)
	Accumulation of data from ghost elements to shared elements. More...

void	ReduceDataBegin (const Tag &tag, ElementType mask, MarkerType select, exchange_data &storage)
	This function intializes data reduction. More...

void	ReduceDataEnd (const Tag &tag, ElementType mask, MarkerType select, ReduceOperation op, exchange_data &storage)
	This function completes data reduction. More...

void	ReduceData (const tag_set &tags, ElementType mask, MarkerType select, ReduceOperation op)
	This function will perform reduction of multiple data tags. More...

void	ReduceDataBegin (const tag_set &tags, ElementType mask, MarkerType select, exchange_data &storage)
	This function will initialize reduction of multiple data tags. More...

void	ReduceDataEnd (const tag_set &tags, ElementType mask, MarkerType select, ReduceOperation op, exchange_data &storage)
	This function will finalize exchange of multiple data tags. More...

void	ExchangeMarked (enum Action action=AGhost)
	This function realizes two algorithms: ghosting of elements and migration of elements. More...

void	ExchangeGhost (integer layers, ElementType bridge, MarkerType select=0, bool delete_ghost=true)
	Form several layers of ghost cells that are adjacent through bridge elements to current cells. More...

void	Redistribute ()
	Migrate all the elements to the new owners prescribed in data corresponding to RedistributeTag. More...

integer	Enumerate (ElementType mask, Tag num_tag, integer start=0, bool define_sparse=false)
	Enumerate all elements beginning with start and put numeration to data associated with num_tag for all elements with given type mask. More...

integer	Enumerate (const HandleType *h, enumerator num, const Tag &num_tag, integer start=0, bool define_sparse=true)
	Enumerate all elements beginning with start and put numeration to data associated with num_tag. More...

template<typename EType >
integer	Enumerate (const ElementArray< EType > &elements, const Tag &num_tag, integer start=0, bool define_sparse=true)
	Enumerate all elements beginning with start and put numeration to data associated with num_tag. More...

integer	EnumerateSet (const ElementSet &set, const Tag &num_tag, integer start=0, bool define_sparse=true)
	Enumerate all elements in the set. More...

integer	TotalNumberOf (ElementType mask)
	Sum of all physical elements, it excludes ghost copies. More...

real	Integrate (real input)
	Integrate real value over all processors. More...

enumerator	Integrate (enumerator input)
	Integrate unsigned integer value over all processors. More...

integer	Integrate (integer input)
	Integrate integer value over all processors. More...

void	Integrate (real *input, integer size)
	Integrate an array of real values over all processors. More...

void	Integrate (enumerator *input, integer size)
	Integrate an array of unsigned integer values over all processors. More...

void	Integrate (integer *input, integer size)
	Integrate an array of integer values over all processors. More...

real	Integrate (const Tag &t, enumerator entry, ElementType mask)
	Integrate data corresponding to tag between all processors. More...

integer	ExclusiveSum (integer input)
	Compute sum of integer values for all processors with rank lower then current, excluding current processor. More...

enumerator	ExclusiveSum (enumerator input)

real	AggregateMax (real input)

integer	AggregateMax (integer input)

enumerator	AggregateMax (enumerator input)

void	AggregateMax (real *input, integer size)

void	AggregateMax (integer *input, integer size)

void	AggregateMax (enumerator *input, integer size)

real	AggregateMin (real input)

integer	AggregateMin (integer input)

enumerator	AggregateMin (enumerator input)

void	AggregateMin (real *input, integer size)

void	AggregateMin (integer *input, integer size)

void	AggregateMin (enumerator *input, integer size)

void	RecomputeParallelStorage (ElementType mask)
	Regather ghost and shared element sets for data exchange. More...

void	SortParallelStorage (ElementType mask)
	Sort parallel storage. More...

void	RecordParallelStorage (ElementType mask)
	Outputs parallel storage into xml log files. More...

ElementType	SynchronizeElementType (ElementType etype)
	Synchronize bitwise mask of element types between processors. More...

void	SynchronizeMarker (MarkerType marker, ElementType mask, SyncBitOp op)
	Synchronize marker on elements between processors using provided operation. More...

void	Barrier ()

void	BeginSequentialCode ()

void	EndSequentialCode ()

Element	ElementByLocalIDNum (integer etypenum, integer lid)

Element	ElementByLocalID (ElementType etype, integer lid)

Element	ElementByHandle (HandleType h)

HandleType	NextHandle (HandleType h) const

HandleType	PrevHandle (HandleType h) const

HandleType	NextHandle (HandleType h, ElementType mask) const

HandleType	PrevHandle (HandleType h, ElementType mask) const

HandleType	FirstHandle () const

HandleType	LastHandle () const

HandleType	FirstHandle (ElementType etype) const

HandleType	LastHandle (ElementType etype) const

Node	NodeByLocalID (integer lid)

Edge	EdgeByLocalID (integer lid)

Face	FaceByLocalID (integer lid)

Cell	CellByLocalID (integer lid)

ElementSet	EsetByLocalID (integer lid)

integer	NodeNextLocalID (integer lid) const

integer	EdgeNextLocalID (integer lid) const

integer	FaceNextLocalID (integer lid) const

integer	CellNextLocalID (integer lid) const

integer	EsetNextLocalID (integer lid) const

integer	NodePrevLocalID (integer lid) const

integer	EdgePrevLocalID (integer lid) const

integer	FacePrevLocalID (integer lid) const

integer	CellPrevLocalID (integer lid) const

integer	EsetPrevLocalID (integer lid) const

__INLINE integer	NodeLastLocalID () const

__INLINE integer	EdgeLastLocalID () const

__INLINE integer	FaceLastLocalID () const

__INLINE integer	CellLastLocalID () const

__INLINE integer	EsetLastLocalID () const

integer	LastLocalIDNum (integer n) const

integer	NextLocalID (ElementType etype, integer lid) const

integer	PrevLocalID (ElementType etype, integer lid) const

integer	FirstLocalID (ElementType etype) const

integer	LastLocalID (ElementType etype) const

integer	NextLocalIDIter (ElementType etype, integer lid) const

integer	PrevLocalIDIter (ElementType etype, integer lid) const

integer	LastLocalIDThr (ElementType etype) const

integer	FirstLocalIDThr (ElementType etype) const

__INLINE integer	NumberOfSets () const

__INLINE integer	NumberOfCells () const

__INLINE integer	NumberOfFaces () const

__INLINE integer	NumberOfEdges () const

__INLINE integer	NumberOfNodes () const

__INLINE integer	NumberOfElements () const

__INLINE integer	NumberOfAll () const

integer	NumberOf (ElementType t) const

iteratorStorage	Begin (ElementType Types)
	These iterators skip invalid elements but don't skip modified elements.

iteratorStorage	End ()

iteratorElement	BeginElement (ElementType Types)

iteratorElement	EndElement ()

iteratorSet	BeginSet ()

iteratorSet	EndSet ()

iteratorCell	BeginCell ()

iteratorCell	EndCell ()

iteratorFace	BeginFace ()

iteratorFace	EndFace ()

iteratorEdge	BeginEdge ()

iteratorEdge	EndEdge ()

iteratorNode	BeginNode ()

iteratorNode	EndNode ()

void	SetFileOption (std::string, std::string)
	Set file option. More...

std::string	GetFileOption (std::string key) const
	Get current option corresponding to key. More...

std::set< std::string >	TagOptions (std::string name) const
	Collect file options related to records Tag:TAGNAME. More...

bool	CheckLoadSkip (std::string name, const std::set< std::string > &noload, const std::set< std::string > &loadonly) const
	Check if tag loading should be skipped.

bool	CheckSaveSkip (std::string name, const std::set< std::string > &noload, const std::set< std::string > &loadonly) const
	Check if tag saving should be skipped.

void	Load (std::string File)
	Acceptable file formats for reading. More...

void	LoadMSH (std::string File)

void	LoadECL (std::string File)

void	LoadXML (std::string File)

void	LoadPMF (std::string File)

void	LoadVTK (std::string File)

void	LoadVTU (std::string File)

void	LoadPVTK (std::string File)

void	LoadPVTU (std::string File)

void	LoadMKF (std::string File)

void	Save (std::string File)
	Acceptable file formats for writing. More...

void	SaveXML (std::string File)

void	SavePMF (std::string File)

void	SaveVTK (std::string File)

void	SaveVTU (std::string File)

void	SavePVTK (std::string File)

void	SavePVTU (std::string File)

void	SaveGMV (std::string File)

bool	isParallelFileFormat (std::string File)

void	RepairGeometricTags ()

bool	HideGeometricData (GeometricData type, ElementType mask)

bool	ShowGeometricData (GeometricData type, ElementType mask)

void	FacesOrientation (const ElementArray< Face > &faces, MarkerType rev)
	Marks face with the orientation direction by marker. More...

void	FacesOrientation (const HandleType *faces, enumerator size, MarkerType rev, bool check_convexity=true, enumerator start=0)

void	CollectCentroidsNormals (const HandleType faces, enumerator size, real x, real *n)

bool	CheckConvexity (const real x, const real n, enumerator size) const

bool	CheckConvexity (const ElementArray< Face > &faces)

bool	CheckConvexity (const HandleType *faces, enumerator size)

void	PrepareGeometricData (GeomParam table)

void	RemoveGeometricData (GeomParam table)

bool	HaveGeometricData (GeometricData type, ElementType mask) const

void	GetGeometricData (HandleType e, GeometricData type, real *ret)

const Tag &	GetGeometricTag (GeometricData type) const

bool	TestClosure (const HandleType *elements, integer num) const

ElementArray< Face >	GatherBoundaryFaces ()

ElementArray< Face >	GatherInteriorFaces ()

integer	CountBoundaryFaces ()

integer	CountInteriorFaces ()

bool	FixEdgeOrder (HandleType *edges, enumerator nedges) const

void	RecomputeGeometricData (HandleType e)

void	RecomputeGeometricData (HandleType e, GeometricData d)

Element::GeometricType	ComputeGeometricType (ElementType element_type, const HandleType *lower_adjacent, INMOST_DATA_ENUM_TYPE lower_adjacent_size)

void	ComputeCentroid (Element e, TagRealArray coords, real *x) const

void	ComputeBarycenter (Element e, TagRealArray coords, real *x) const

void	ComputeNormal (Element e, TagRealArray coords, real *n) const

void	ComputeMeasure (Element e, TagRealArray coords, real &m) const

void	ComputeCentroid (Element e, TagVariableArray coords, variable *x) const

void	ComputeBarycenter (Element e, TagVariableArray coords, variable *x) const

void	ComputeNormal (Element e, TagVariableArray coords, variable *n) const

void	ComputeMeasure (Element e, TagVariableArray coords, variable &m) const

void	WachspressInterpolation2D (const real *x, const Face &f, std::map< HandleType, real > &nodes_stencil) const
	Compute node-centered interpolation on 2d face for point. More...

void	WachspressInterpolation3D (const real *x, const Cell &c, std::map< HandleType, real > &nodes_stencil) const
	Compute node-centered interpolation on 3d cell for point Point should be inside cell or on its boundary. More...

void	MarkBoundaryFaces (MarkerType boundary_marker)
	Sets marker for all the faces that have only one neighbouring cell, works correctly in parallel environment. More...

void	MarkNormalOrientation (MarkerType mrk)
	This function should be used to detect normal inversion on ghost interfaces with respect to normal orientation on owner of the interface. More...

bool	isMeshModified () const
	Check whether code runs between Mesh::BeginModification, Mesh::EndModification scope. More...

MarkerType	HideMarker () const

MarkerType	NewMarker () const

void	SwapModification (bool recompute_geometry)

void	BeginModification ()

void	ApplyModification ()
	After this function any link to deleted element will be replaced by InvalidHandle(). More...

void	ResolveModification ()
	This function is not yet implemented. More...

void	EndModification ()

enumerator	getNext (const HandleType *arr, enumerator size, enumerator k, MarkerType marker) const

enumerator	Count (const HandleType *arr, enumerator size, MarkerType marker) const

void	EquilibrateGhost ()

void	CheckCentroids (std::string file, int line)
	Check that centroids of ghost and shared elements match to each other. More...

void	CheckProcsSorted (std::string file, int line)
	Check that processors are sorted on every element.

void	CheckGhostSharedCount (std::string file, int line, ElementType etype=ESET\|CELL\|FACE\|EDGE\|NODE)
	Check that number of ghost and shared elements match to each other. More...

void	CheckOwners (std::string file, int line)
	Let ghost elements send processors list to master elements and see if they match.

void	CheckGIDs (std::string file, int line, ElementType mask=NODE\|EDGE\|FACE\|CELL\|ESET)
	Let ghost elements send global ids to master elements and see if they match.

void	CheckProcessors ()
	Let ghost elements send owner processor to master elements and see if they match.

void	CheckSetLinks (std::string file, int line)
	Checks that there are no invalid links in sets.

TopologyCheck	BeginTopologyCheck (ElementType etype, const HandleType *adj, enumerator num)
	This function allows you to perform some topological checks before you create an element. More...

bool	EndTopologyCheck (HandleType e, TopologyCheck begin_check)
	This function performs some topological checks after construction of element. More...

Tag	TopologyErrorTag () const
	This will return tag by which you can retrieve error mark to any element on which topology check failed. More...

TopologyCheck	GetTopologyCheck (TopologyCheck mask=ENUMUNDEF) const
	Retrieve currently set topology checks.

void	SetTopologyCheck (TopologyCheck mask)
	Set topology checks.

void	RemTopologyCheck (TopologyCheck mask)
	Remove topology checks.

void	SetTopologyError (TopologyCheck mask)
	This will turn mesh into the state indicating that some topology error occurred.

TopologyCheck	GetTopologyError (TopologyCheck mask=ENUMUNDEF) const
	Retrieve topology error state, this indicates that some error have occurred.

void	ClearTopologyError (TopologyCheck mask=ENUMUNDEF)
	Revert mesh to clean topology error state.

void	SortHandles (HandleType *h, enumerator num)

void	SortByGlobalID (HandleType *h, enumerator num)

std::string	GetMeshName ()
	Retrieve the name of the current mesh.

void	SetMeshName (std::string new_name)
	Be careful changing mesh name if you have already established remote links.

Public Member Functions inherited from INMOST::TagManager
bool	HaveTag (std::string name) const
	Check existence of a data tag by it's name.

Tag	GetTag (std::string name) const
	Retrieve a data tag by it's name.

void	ListTagNames (std::vector< std::string > &list) const
	Retrieve names for all the tags present on the mesh.

Tag	CreateTag (Mesh *m, std::string name, DataType dtype, ElementType etype, ElementType sparse, INMOST_DATA_ENUM_TYPE size=ENUMUNDEF)
	Create tag with prescribed attributes.

bool	ElementDefined (Tag const &tag, ElementType etype) const
	Check that the tag was defined on certain elements.

bool	RenameTag (std::string oldname, std::string newname)
	Change tag name.

Public Member Functions inherited from INMOST::Storage
	Storage (const Storage &other)

	Storage (Mesh *mesh, HandleType handle)

	Storage (Mesh mesh, HandleType handle)
	This constructor allows for remote handle modification.

Storage &	operator= (Storage const &other)
	If there is a link to handle provided (automatically by ElementArray and reference_array), then remote handle value will be modified.

__INLINE bool	operator< (const Storage &other) const

__INLINE bool	operator> (const Storage &other) const

__INLINE bool	operator<= (const Storage &other) const

__INLINE bool	operator>= (const Storage &other) const

__INLINE bool	operator== (const Storage &other) const

__INLINE bool	operator!= (const Storage &other) const

__INLINE Storage *	operator-> ()

__INLINE const Storage *	operator-> () const

__INLINE Storage &	self ()

__INLINE const Storage &	self () const

__INLINE real &	Real (const Tag &tag) const
	Retrieve real value associated with Tag. More...

__INLINE integer &	Integer (const Tag &tag) const
	Retrieve integer value associated with Tag. More...

__INLINE bulk &	Bulk (const Tag &tag) const
	Retrieve one byte of abstract data associated with Tag. More...

__INLINE reference &	Reference (const Tag &tag) const
	Retrieve Element reference associated with Tag. More...

__INLINE remote_reference &	RemoteReference (const Tag &tag) const
	Retrieve remote Element reference associated with Tag. More...

__INLINE real_array	RealArray (const Tag &tag) const
	Retrieve array of real values associated with Tag. More...

__INLINE integer_array	IntegerArray (const Tag &tag) const
	Retrieve array of integer values associated with Tag. More...

__INLINE bulk_array	BulkArray (const Tag &tag) const
	Retrieve abstract data associated with Tag as a series of bytes. More...

__INLINE reference_array	ReferenceArray (const Tag &tag) const
	Retrieve array of Element references associated with Tag. More...

__INLINE remote_reference_array	RemoteReferenceArray (const Tag &tag) const
	Retrieve array of Element references associated with Tag. More...

__INLINE real_array	RealArrayDF (const Tag &tag) const

__INLINE integer_array	IntegerArrayDF (const Tag &tag) const

__INLINE bulk_array	BulkArrayDF (const Tag &tag) const

__INLINE reference_array	ReferenceArrayDF (const Tag &tag) const

__INLINE remote_reference_array	RemoteReferenceArrayDF (const Tag &tag) const

__INLINE real &	RealDF (const Tag &tag) const

__INLINE integer &	IntegerDF (const Tag &tag) const

__INLINE bulk &	BulkDF (const Tag &tag) const

__INLINE reference &	ReferenceDF (const Tag &tag) const

__INLINE remote_reference &	RemoteReferenceDF (const Tag &tag) const

__INLINE real_array	RealArrayDV (const Tag &tag) const

__INLINE integer_array	IntegerArrayDV (const Tag &tag) const

__INLINE bulk_array	BulkArrayDV (const Tag &tag) const

__INLINE reference_array	ReferenceArrayDV (const Tag &tag) const

__INLINE remote_reference_array	RemoteReferenceArrayDV (const Tag &tag) const

__INLINE real &	RealDV (const Tag &tag) const

__INLINE integer &	IntegerDV (const Tag &tag) const

__INLINE bulk &	BulkDV (const Tag &tag) const

__INLINE reference &	ReferenceDV (const Tag &tag) const

__INLINE remote_reference &	RemoteReferenceDV (const Tag &tag) const

__INLINE var &	Variable (const Tag &tag) const
	Retrieve variable reference associated with Tag.

__INLINE var &	VariableDF (const Tag &tag) const

__INLINE var &	VariableDV (const Tag &tag) const

__INLINE var_array	VariableArray (const Tag &tag) const
	Retrieve array of variables associated with Tag.

__INLINE var_array	VariableArrayDF (const Tag &tag) const

__INLINE var_array	VariableArrayDV (const Tag &tag) const

__INLINE INMOST_DATA_ENUM_TYPE	GetDataSize (const Tag &tag) const
	Return the data length associated with Tag. More...

__INLINE INMOST_DATA_ENUM_TYPE	GetDataCapacity (const Tag &tag) const
	Return the size of the structure required to represent the data on current element. More...

__INLINE void	SetDataSize (const Tag &tag, INMOST_DATA_ENUM_TYPE new_size) const
	Set the length of data associated with Tag. More...

__INLINE void	GetData (const Tag &tag, INMOST_DATA_ENUM_TYPE shift, INMOST_DATA_ENUM_TYPE size, void *data) const
	Extract part of the data associated with Tag. More...

__INLINE void	SetData (const Tag &tag, INMOST_DATA_ENUM_TYPE shift, INMOST_DATA_ENUM_TYPE size, const void *data) const

__INLINE void	DelData (const Tag &tag) const

__INLINE bool	DelSparseData (const Tag &tag) const
	Deallocates space allocated for sparse data, frees variable array if necessary.

__INLINE void	DelDenseData (const Tag &tag) const
	Frees variable array or fills field with zeroes.

__INLINE bool	HaveData (const Tag &tag) const
	Check if any data is associated with Tag.

__INLINE ElementType	GetElementType () const

__INLINE integer	GetElementNum () const

__INLINE void	SetMarker (MarkerType n) const

__INLINE bool	GetMarker (MarkerType n) const

__INLINE void	RemMarker (MarkerType n) const

__INLINE void	SetPrivateMarker (MarkerType n) const

__INLINE bool	GetPrivateMarker (MarkerType n) const

__INLINE void	RemPrivateMarker (MarkerType n) const

__INLINE void	ClearMarkerSpace () const

__INLINE void	GetMarkerSpace (bulk copy[MarkerFields]) const

__INLINE void	SetMarkerSpace (bulk source[MarkerFields]) const

__INLINE integer	LocalID () const

__INLINE integer	DataLocalID () const
	This number is guaranteed to be between 0 and Mesh::NumberOf(type of element) after Mesh::ReorderEmpty.

__INLINE bool	isValid () const

__INLINE Mesh *	GetMeshLink () const

__INLINE HandleType	GetHandle () const

__INLINE Element	getAsElement () const

__INLINE Node	getAsNode () const

__INLINE Edge	getAsEdge () const

__INLINE Face	getAsFace () const

__INLINE Cell	getAsCell () const

__INLINE ElementSet	getAsSet () const

Static Public Member Functions
static void	Initialize (int argc, char **argv)
	Initial initialization. More...

static void	Finalize ()
	Finalizes operation with MPI, recommended to call, otherwise MPI may produce warnings.

static void	CopyData (Element a, Element b)
	Copy all the data from b to a (a = b). More...

static Mesh *	GetMesh (std::string name)
	Find mesh by name.

Public Attributes
Tag	tag_sendto

Tag	tag_processors

Additional Inherited Members
Protected Types inherited from INMOST::TagManager
typedef chunk_array< INMOST_DATA_ENUM_TYPE, chunk_bits_empty >	empty_data

typedef chunk_array< Tag, chunk_bits_tags >	tag_array_type

typedef chunk_bulk_array< chunk_bits_elems >	dense_sub_type

typedef chunk_array< dense_sub_type, chunk_bits_dense >	dense_data_array_type

typedef array< sparse_sub_record >	sparse_sub_type

typedef chunk_array< sparse_sub_type, chunk_bits_elems >	sparse_data_array_type

typedef chunk_array< INMOST_DATA_INTEGER_TYPE, chunk_bits_elems >	back_links_type

typedef tag_array_type::iterator	tag_iterator

typedef tag_array_type::const_iterator	tag_const_iterator

Protected Member Functions inherited from INMOST::TagManager
	TagManager (const TagManager &other)

TagManager &	operator= (TagManager const &other)

void	ReallocateData (const Tag &t, INMOST_DATA_INTEGER_TYPE etypenum, INMOST_DATA_ENUM_TYPE new_size)
	Shrink or enlarge arrays for a dense data.

void	ReallocateData (INMOST_DATA_INTEGER_TYPE etypenum, INMOST_DATA_ENUM_TYPE new_size)
	Reallocate all the data for all the tags.

__INLINE sparse_sub_type const &	GetSparseData (int etypenum, int local_id) const
	Retrieve substructure for representation of the sparse data without permission for modification.

__INLINE sparse_sub_type &	GetSparseData (int etypenum, int local_id)
	Retrieve substructure for representation of the sparse data.

__INLINE dense_sub_type const &	GetDenseData (int pos) const
	Retrieve substructure for representation of the dense data without permission for modification.

__INLINE dense_sub_type &	GetDenseData (int pos)
	Retrieve substructure for representation of the dense data.

Static Protected Member Functions inherited from INMOST::TagManager
static void	CopyData (const Tag &t, void adata, const void bdata)
	Copy data from one element to another.

static void	DestroyVariableData (const Tag &t, void *adata)
	Destroy data that represents array of variable size.

Protected Attributes inherited from INMOST::TagManager
tag_array_type	tags

empty_data	empty_dense_data

dense_data_array_type	dense_data

sparse_data_array_type	sparse_data [NUM_ELEMENT_TYPS]

back_links_type	back_links [NUM_ELEMENT_TYPS]

Protected Attributes inherited from INMOST::Storage
HandleType	handle

HandleType *	handle_link

Detailed Description

Definition at line 1303 of file inmost_mesh.h.

Member Function Documentation

◆ ApplyModification()

void INMOST::Mesh::ApplyModification ( )

After this function any link to deleted element will be replaced by InvalidHandle().

This will modify DATA_REFERENCE tags and contents of sets, so that all deleted elements are not referenced anymore. If you have any tags of type DATA_REMOTE_REFERENCE on current mesh linking to the elements of the current mesh or there are other meshes that possess tags of type DATA_REMOTE_REFERENCE and link elements on the current mesh, you should check that there are no links to deleted elements manually with Element::Old().

Todo:

maybe instead of forming set of deleted elements and subtracting set from other sets it is better to remove each modified element (done, check and compare)
parent/child elements in set would not be replaced or reconnected, this may lead to wrong behavior (done, check and compare)

See also: Element::Old

◆ AssignGlobalID()

void INMOST::Mesh::AssignGlobalID ( ElementType mask )

Assign unique numbers to elements.

Internally this will create Mesh::GlobalIDTag and make call to Element::GlobalID and Mesh::GlobalID functions valid. Internally this will also set have_global_id variable that will indicate that all the comparisons in parallel algorithms should be performed using global identificators instead of centroids which is faster.

Todo:

invoking function before loading mesh will not renew global identificators after load but would not unset have_global_id either. There are probably too many places when global ids may become invalid but no flag will be set. It may be benefitial to set such flags along with updating geometrical data which seems to be maintained fairly well during mesh modification

◆ BeginTag()

__INLINE iteratorTag INMOST::Mesh::BeginTag ( )

inline

Returns the first tag defined on the mesh.

For safety while iterating through tags you should check for validity of the tag

Returns: first tag

Definition at line 1492 of file inmost_mesh.h.

◆ BeginTopologyCheck()

TopologyCheck INMOST::Mesh::BeginTopologyCheck	(	ElementType	etype,
		const HandleType *	adj,
		enumerator	num
	)

This function allows you to perform some topological checks before you create an element.

Function is used internally by CreateEdge, CreateFace, CreateCell functions If you perform topological checks on your own, you'd probably better turn off checks before calling CreateXXX functions. Note that check for duplicates within mesh is performed by Mesh::FindSharedAdjacency.

Todo:: list checks performed inside in description

◆ Bulk()

bulk& INMOST::Mesh::Bulk	(	HandleType	h,
		const Tag &	tag
	)

Returns a reference in inner representation to the first element of array of bytes.

Future recommendation: If variable size array was not allocated then this function will generate segmentation fault.

If you know that data is certanly dense and fixed or variable on elements you access then it is faster to use specialized variants of this function.

Reference to the data is guaranteed to be valid during mesh modification.

Parameters

h	element handle
tag	tag that represents data

◆ BulkArray()

bulk_array INMOST::Mesh::BulkArray	(	HandleType	h,
		const Tag &	tag
	)

Returns an array of bytes.

If you know that data is certanly sparse or dense on elements you access then it is faster to use variants of this function with hint data structure.

Array data structure is guaranteed to be valid during mesh modification.

Parameters

h	element handle
tag	tag that represents data

◆ BulkArrayDF()

bulk_array INMOST::Mesh::BulkArrayDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of bytes in dense array.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set), likely to result in segfault.

Note that as array is fixed you shouldn't use any functions that alter size of the array as resize, erase, insert, you may use replace if initial and final size will match, in debug mode assert will fire if you try to do this in release (NDEBUG is set) it will lead to segfault.

Parameters

h	element handle
tag	tag that represents dense data of fixed size on given handle

Definition at line 1806 of file inmost_mesh.h.

◆ BulkArrayDV()

bulk_array INMOST::Mesh::BulkArrayDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of bytes in dense array of variable size.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

Parameters

h	element handle
tag	tag that represents data

Definition at line 1960 of file inmost_mesh.h.

◆ BulkDF()

bulk& INMOST::Mesh::BulkDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference in dense array to the first element of constant size array of bytes.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set).

Parameters

h	element handle
tag	tag that represents dense data of fixed size on given handle

Definition at line 1741 of file inmost_mesh.h.

◆ BulkDV()

bulk& INMOST::Mesh::BulkDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference in dense array to the first element of variable size array of bytes.

Future recommendation: If array was not allocated then this function will generate segmentation fault.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

Parameters

h	element handle
tag	tag that represents data

See also: TagDenseVariable

Definition at line 1901 of file inmost_mesh.h.

◆ CheckCentroids()

void INMOST::Mesh::CheckCentroids	(	std::string	file,
		int	line
	)

Check that centroids of ghost and shared elements match to each other.

Exits if does not match.

◆ CheckGhostSharedCount()

void INMOST::Mesh::CheckGhostSharedCount	(	std::string	file,
		int	line,
		ElementType	etype = `ESET\|CELL\|FACE\|EDGE\|NODE`
	)

Check that number of ghost and shared elements match to each other.

Exits if does not match.

◆ ComputeGeometricType()

void INMOST::Mesh::ComputeGeometricType ( HandleType h )

Recompute geometrical type of current element and set it to element.

Parameters

h	handle of element

◆ CopyData()

static void INMOST::Mesh::CopyData	(	Element	a,
		Element	b
	)

static

Copy all the data from b to a (a = b).

Except for protected data. Non-private markers are copied. Elements should be of the same type.

◆ CreateMarker()

MarkerType INMOST::Mesh::CreateMarker ( )

Allocate a new marker.

Assert will fire in debug mode (NDEBUG not set) if you run out of space for markers, in this case you either use too many markers, then you can just increase MarkerFields variable (increasing by 1 gives you 8 more markers) or you forget to release markers after you use them.

In release mode (NDEBUG is set) if you run out of space for markers function will return InvalidMarker()

Returns: New marker or InvalidMarker(), see description.

◆ CreateNode()

Node INMOST::Mesh::CreateNode ( const real * coords )

Create node by given coordinates.

This operation would not involve searching existing nodes for node with the same coordinates. It is potentially dangerous to have nodes whose coordinates differ by less than GetEpsilon since ResolveShared algorithm would not know how to resolve parallel statuses of the elements. However this may be subject to change, if ResolveShared algorithm will be rewritten to resolve cells first by their centroids and only then resolve all the rest elements by adjacency information.

Parameters

coords array of coordinates at least of size GetDimensions()

Returns: interface to created node

◆ CreateTag()

Tag INMOST::Mesh::CreateTag	(	std::string	name,
		DataType	dtype,
		ElementType	etype,
		ElementType	sparse,
		INMOST_DATA_ENUM_TYPE	size = `ENUMUNDEF`
	)

Create the tag by name, type and size.

You cannot create the tag with the same name and different type or size.

You may make subsequent calls to the function with the same name, same type and same size (or undefined size, then it will be deduced) but different selection of element.

The following recommendation is for future: When you create data of variable size, every array of data for every element will be empty at first, so before accessing it through mechanism for single-valued data (Real, Integer, Bulk, Reference) you should first resize arrays otherwise your program very likely to be halted by segmentation fault. For this case arrays are not allocated automatically from performance considerations.

Parameters

name	name of the tag
dtype	type of the tag
etype	the selection of elements on which the data of the tag is defined, you may use bitwise or operations to define tag on multiple types of elements, example CELL \| FACE
sparse	the selection of elements from etype on which the tag is sparse, for example, if you know that the data is used on all cells and only on boundary faces, then you may should set etype = CELL \| FACE and sparse = FACE
size	size of associated data

Returns: returns the tag that represents the data

◆ DataLocalID()

integer INMOST::Mesh::DataLocalID ( HandleType h ) const

inline

Retrieve position of the data position of current element.

After ReorderEmpty this number is guaranteed to be between 0 and NumberOf(type of element)

Parameters

h	handle of the element

Returns: local id of data

Definition at line 2208 of file inmost_mesh.h.

◆ DelData()

void INMOST::Mesh::DelData	(	HandleType	h,
		const Tag &	tag
	)

Remove tag data from given element.

Removes data of variable size and sparse tag data. Clears to zero data of fixed size.

Parameters

h	handle to the element
tag	tag that indicates the data

◆ DelDenseData() [1/2]

void INMOST::Mesh::DelDenseData	(	HandleType	h,
		const Tag &	tag
	)

Removes data of variable size, clears to zero data of fixed size.

Parameters

h	handle to the element
tag	tag that indicates the data

◆ DelDenseData() [2/2]

void INMOST::Mesh::DelDenseData	(	void *	data,
		const Tag &	tag
	)

Removes data of variable size, clears to zero data of fixed size.

Parameters

data	link to data
tag	tag that indicates the data

◆ Delete()

bool INMOST::Mesh::Delete ( HandleType h )

This function will hide element in modification state (between BeginModification and EndModification) or call Destroy in non-modification state.

Parameters

h	handle of the element

Returns: if true then element was deleted, otherwise it was hidden

See also: Mesh::Hide; Mesh::BeginModification; Mesh::EndModification; Mesh::Destroy

◆ DeleteTag()

Tag INMOST::Mesh::DeleteTag	(	Tag	tag,
		ElementType	mask = `NODE\|EDGE\|FACE\|CELL\|ESET\|MESH`
	)

virtual

Remove the data that is represented by the tag from elements of selected type.

Parameters

tag	tag that indicates the data
mask	the selection of the elements on which the data should be removed, may be set by bitwise or operation

Returns: returns tag that returns false on isValid() request if all the data was removed and the tag is no more occupied, otherwise returns the tag

See also: Tag::isValid

Reimplemented from INMOST::TagManager.

◆ DelSparseData()

bool INMOST::Mesh::DelSparseData	(	HandleType	h,
		const Tag &	tag
	)

Removes data of variable size and sparse tag data.

Parameters

h	handle to the element
tag	tag that indicates the data

◆ Destroy()

void INMOST::Mesh::Destroy ( HandleType h )

Completely destroy element from mesh.

This function bypass check that mesh is in modification state and will remove element immediatly. It will disconnect element from lower adjacencies and delete all the upper adjacencies that depend on current element. If you don't want upper adjacencies to be deleted you should first use Element::Disconnect function to explicitly disconnect current element and then destroy it.

Parameters

h	handle of the element

See also: Element::Disconnect

◆ EndTag()

__INLINE iteratorTag INMOST::Mesh::EndTag ( )

inline

Returns the indicator for loop to end iteration over tags.

Returns: the inexistent tag that is located the one position after the last tag

Definition at line 1498 of file inmost_mesh.h.

◆ EndTopologyCheck()

bool INMOST::Mesh::EndTopologyCheck	(	HandleType	e,
		TopologyCheck	begin_check
	)

This function performs some topological checks after construction of element.

Function is used internally by CreateEdge, CreateFace, CreateCell functions.

Todo:: list checks performed inside in description.

◆ Enumerate() [1/3]

template<typename EType >

integer INMOST::Mesh::Enumerate	(	const ElementArray< EType > &	elements,
		const Tag &	num_tag,
		integer	start = `0`,
		bool	define_sparse = `true`
	)

inline

Enumerate all elements beginning with start and put numeration to data associated with num_tag.

Collective operation.

Parameters

elements	array of elements
num_tag	a tag that is associated with the data
start	starting value for enumeration
define_sparse	if true then function will define sparse data on elements that don't have it, otherwise it will skip those elements

Returns: last value on all the processors

Definition at line 2905 of file inmost_mesh.h.

◆ Enumerate() [2/3]

integer INMOST::Mesh::Enumerate	(	const HandleType *	h,
		enumerator	num,
		const Tag &	num_tag,
		integer	start = `0`,
		bool	define_sparse = `true`
	)

Enumerate all elements beginning with start and put numeration to data associated with num_tag.

Collective operation.

Parameters

h	array of handles
num	number of handles
num_tag	a tag that is associated with the data
start	starting value for enumeration
define_sparse	if true then function will define sparse data on elements that don't have it, otherwise it will skip those elements

Returns: last value on all the processors

◆ Enumerate() [3/3]

integer INMOST::Mesh::Enumerate	(	ElementType	mask,
		Tag	num_tag,
		integer	start = `0`,
		bool	define_sparse = `false`
	)

Enumerate all elements beginning with start and put numeration to data associated with num_tag for all elements with given type mask.

Collective operation.

Parameters

mask	bitwise or of types of elements
num_tag	a tag that is associated with the data
start	starting value for enumeration
define_sparse	if true then function will define sparse data on elements that don't have it, otherwise it will skip those elements

Returns: last value on all the processors

◆ EnumerateSet()

integer INMOST::Mesh::EnumerateSet	(	const ElementSet &	set,
		const Tag &	num_tag,
		integer	start = `0`,
		bool	define_sparse = `true`
	)

Enumerate all elements in the set.

Collective operation.

Parameters

set	handle of the set
num_tag	a tag that is associated with the data
start	starting value for enumeration
define_sparse	if true then function will define sparse data on elements that don't have it, otherwise it will skip those elements

Returns: last value on all the processors

◆ ExchangeData() [1/2]

void INMOST::Mesh::ExchangeData	(	const Tag &	tag,
		ElementType	mask,
		MarkerType	select = `0`
	)

Update data from Shared elements to Ghost elements.

For backward direction please see Mesh::ReduceData. If you have a tag of DATA_BULK type and you store your own custom data structure in it, it is highly recommended that you provide MPI information about your structure through Tag::SetBulkDataType, this would not do any difference on homogeneous architecture, but it may help you save a lot of time and nerves in heterogeneous parallel environment.

Todo:: see TODO in Mesh::ReduceData

Blocking, Collective point-2-point

Parameters

tag	tag that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements

See also: Mesh::ReduceData

◆ ExchangeData() [2/2]

void INMOST::Mesh::ExchangeData	(	const tag_set &	tags,
		ElementType	mask,
		MarkerType	select = `0`
	)

This function will perform exchange of multiple data tags.

Blocking, Collective point-2-point

Parameters

tags	multiple tags that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements

◆ ExchangeDataBegin() [1/2]

void INMOST::Mesh::ExchangeDataBegin	(	const Tag &	tag,
		ElementType	mask,
		MarkerType	select,
		exchange_data &	storage
	)

Start asynchronous synchronization of data.

You should define object of type exchange_data that will hold temporary buffers for data. every Mesh::ExchangeDataBegin should be matched with Mesh::ExchangeDataEnd with the same exchange_data object. After matching Mesh::ExchangeDataEnd the exchange_data object may be reused If you will go out of the scope where exchange_data object was defined it will be deallocated and may result in segmentation fault.

You should also never put the same exchange_data object to any other Mesh::ExchangeDataBegin or Mesh::ReduceDataBegin, until matching Mesh::ExchangeDataEnd because it may override or reallocate buffers, internally used by MPI and remote processor will receive garbage instead of data.

Nonblocking, Collective point-2-point

Parameters

tag	tag that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
storage	buffer that will temporary hold sended data

See also: Mesh::ExchangeDataEnd

◆ ExchangeDataBegin() [2/2]

void INMOST::Mesh::ExchangeDataBegin	(	const tag_set &	tags,
		ElementType	mask,
		MarkerType	select,
		exchange_data &	storage
	)

This function will initialize exchange of multiple data tags.

Using this function may lead to good overlapping between communication and computation.

Nonblocking, Collective point-2-point

Parameters

tags	multiple tags that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
storage	buffer that will temporary hold sended data

◆ ExchangeDataEnd() [1/2]

void INMOST::Mesh::ExchangeDataEnd	(	const Tag &	tag,
		ElementType	mask,
		MarkerType	select,
		exchange_data &	storage
	)

Complete asynchronous synchronization of data.

Blocking

Parameters

tag	tag that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
storage	buffer that will temporary hold sended data

See also: Mesh::ExchangeDataBegin

◆ ExchangeDataEnd() [2/2]

void INMOST::Mesh::ExchangeDataEnd	(	const tag_set &	tags,
		ElementType	mask,
		MarkerType	select,
		exchange_data &	storage
	)

This function will finalize exchange of multiple data tags.

Blocking

Parameters

tags	multiple tags that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
storage	buffer that will temporary hold sended data

◆ ExchangeGhost()

void INMOST::Mesh::ExchangeGhost	(	integer	layers,
		ElementType	bridge,
		MarkerType	select = `0`,
		bool	delete_ghost = `true`
	)

Form several layers of ghost cells that are adjacent through bridge elements to current cells.

This function acceptes any mesh topology, failure on some mesh should be considered a bug and sample example should be provided for testing purposes.

This function internally calculates layer by layer and invokes ExchangeMarked for each layer, you can either reproduce the algorithm on your own if you want to bypass the function and call Mesh::ExchangeMarked directly, but then you will lose optimization in Mesh::Redistribute, that expects that layers are formed the same way they are formed in Mesh::ExchangeGhost. Internally it sets up LayersTag and BridgeTag for the mesh with provided values, which are used by Mesh::Redistribute but you are discouraged to override these tags since using non-matching algorithms is not tested and should be considered dangerous.

Nevertheless you can use this function first for layers then request any additional ghost elements by ExchangeMarked.

Collective point-2-point.

Parameters

layers	number of required layers of ghost elements
bridge	bitwise mask of elements for which neighbouring cells should be considered a layer

See also: Mesh::ExchangeMarked; Mesh::Redistribute

◆ ExchangeMarked()

void INMOST::Mesh::ExchangeMarked ( enum Action action = AGhost )

This function realizes two algorithms: ghosting of elements and migration of elements.

ghosting:

Creates ghost elements at other processors prescribed in SendtoTag() performs sending and receiving of elements and all operations to keep parallel state of the mesh.

Given that all the data was up to date among processors all the data at the end of the algorithm will be also up to data

migration:

To correctly perform migration of elements it is necessary to set up tags besides SendToTag(), which indicates to where every element should be sent:

tag "TEMPORARY_NEW_PROCESSORS", of type DATA_INTEGER with variable size, tells which processors will have copy of the element after migration;
tag "TEMPORARY_NEW_OWNER", of type DATA_INTEGER of size 1, tells which processor will have the main copy of the element.

if there is no current processor in "TEMPORARY_NEW_PROCESSORS", then current processor will remove the copy of the element. All this actions are performed automatically by Mesh::Redistribute based on information provided in Mesh::RedistributeTag which effectively contains new owner.

Given that all the data was up to date among processors all the data at the end of the algorithm will be also up to date

Todo:

test halo exchange algorithm (if used then change collective point-2-point to collective)
see TODO 2 in Mesh::Redistribute

Collective point-2-point.

Parameters

action

See also: Mesh::SendtoTag; Mesh::Redistribute

◆ ExchangeOrientedData() [1/2]

void INMOST::Mesh::ExchangeOrientedData	(	const Tag &	tag,
		ElementType	mask,
		MarkerType	select = `0`,
		MarkerType	orient = `0`
	)

This function is similar to ExchangeData, except that it will change the orientation of recieved data upon completion for the exchanged tags, registered through AddOrientedTag.

The orientation marker is computed using MarkNormalOrientation and could be provided by the user. If marker is provided it is assumed to be consistent. It is computed internally if zero marker is provided.

Blocking, Collective point-2-point

Parameters

tag	tag that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
orient	set the marker to change the sign of oriented tags, computed internally if zero

See also: Mesh::ExchangeData

◆ ExchangeOrientedData() [2/2]

void INMOST::Mesh::ExchangeOrientedData	(	const tag_set &	tags,
		ElementType	mask,
		MarkerType	select = `0`,
		MarkerType	orient = `0`
	)

This function is similar to ExchangeData, except that it will change the orientation of recieved data upon completion for the exchanged tags, registered through AddOrientedTag.

The orientation marker is computed using MarkNormalOrientation and could be provided by the user. If marker is provided it is assumed to be consistent. It is computed internally if zero marker is provided. This function allows to mix oriented and normal data.

Blocking, Collective point-2-point

Parameters

tags	multiple tags that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements

◆ ExclusiveSum()

integer INMOST::Mesh::ExclusiveSum ( integer input )

Compute sum of integer values for all processors with rank lower then current, excluding current processor.

Collective operation.

Parameters

input value on current processor

Returns: described sum

◆ FacesOrientation()

void INMOST::Mesh::FacesOrientation	(	const ElementArray< Face > &	faces,
		MarkerType	rev
	)

inline

Marks face with the orientation direction by marker.

If marker is set then face is reversed. Then all faces are oriented either inside or outside of the cell.

Definition at line 3312 of file inmost_mesh.h.

◆ FindSharedAdjacency()

HandleType INMOST::Mesh::FindSharedAdjacency	(	const HandleType *	arr,
		enumerator	num
	)		const

Retrieve upper adjacent that is shared by multiple lower adjacencies.

Returns: handle of found element or InvalidHandle()

◆ GetData()

void INMOST::Mesh::GetData	(	HandleType	h,
		const Tag &	tag,
		enumerator	shift,
		enumerator	size,
		void *	data
	)		const

Copy inner data array of size elements to provided array beginning from shift element.

It is assumed that user-provided array don't overlap inner data.

Parameters

h	handle of element
tag	tag that represents data
shift	for which element to start to copy
size	how many elements to copy
data	user-provided array where data should be copied

◆ GetDataCapacity() [1/2]

INMOST_DATA_ENUM_TYPE INMOST::Mesh::GetDataCapacity	(	const INMOST_DATA_BULK_TYPE *	data,
		INMOST_DATA_ENUM_TYPE	size,
		const Tag &	tag
	)		const

Returns the number of bytes in data used for given type of tag.

Trivial for all the types except DATA_VARIABLE.

◆ GetDataCapacity() [2/2]

INMOST_DATA_ENUM_TYPE INMOST::Mesh::GetDataCapacity	(	HandleType	h,
		const Tag &	tag
	)		const

Return the size of the structure in bytes required to represent the data on current element.

This is equal to GetDataSize times Tag::GetBytesSize for all the data types, except for DATA_VARIABLE, that requires a larger structure to accommodate derivatives.

Parameters

h	handle of element
tag	tag that represents the data

◆ GetDataSize()

INMOST_DATA_ENUM_TYPE INMOST::Mesh::GetDataSize	(	HandleType	h,
		const Tag &	tag
	)		const

Return the size of the array.

For variable size arrays returns current size of the array. For constant size array returns the same value that may be obtained through GetSize.

Parameters

h	handle of element
tag	tag that represents the data

See also: Tag::GetSize

◆ GetDimensions()

__INLINE integer INMOST::Mesh::GetDimensions ( ) const

inline

Get number of dimensions of mesh.

Size of the array returned by Node::Coords will match this number.

See also: Node::Coords

Definition at line 1440 of file inmost_mesh.h.

◆ GetEpsilon()

__INLINE real INMOST::Mesh::GetEpsilon ( ) const

inline

Retrieve tolerance for coordinates comparison.

Returns: real value

Definition at line 1430 of file inmost_mesh.h.

◆ GetFileOption()

std::string INMOST::Mesh::GetFileOption ( std::string key ) const

Get current option corresponding to key.

Parameters

key	options for which options should be retrieven

◆ GetMarker()

__INLINE bool INMOST::Mesh::GetMarker	(	HandleType	h,
		MarkerType	n
	)		const

inline

Check whether the marker is set one the element.

Parameters

h	element handle
n	stores byte number and byte bit mask that represent marker

Definition at line 2038 of file inmost_mesh.h.

◆ GetMarkerSpace()

void INMOST::Mesh::GetMarkerSpace	(	HandleType	h,
		bulk	copy[MarkerFields]
	)		const

Get a copy of the bytes that store markers on the element.

Parameters

h	element handle
copy	storage to put data to

◆ GetMeshState()

__INLINE MeshState INMOST::Mesh::GetMeshState ( ) const

inline

Get parallel state of the mesh.

Returns: either Mesh::Serial or Mesh::Parallel

Definition at line 1443 of file inmost_mesh.h.

◆ GetParallelFileStrategy()

int INMOST::Mesh::GetParallelFileStrategy ( ) const

inline

Retrieve currently set parallel strategy for ".pmf" files.

See also: Mesh::GetParallelStrategy

Definition at line 2540 of file inmost_mesh.h.

◆ GetSet()

ElementSet INMOST::Mesh::GetSet ( std::string name )

Retrieve set by name.

Parameters

name set name

Returns: set whose name match or InvalidHandle()

◆ GetStatus()

Element::Status INMOST::Mesh::GetStatus ( HandleType h ) const

inline

Retrieve parallel status of the element.

If mesh is in Serial state then call always returns Element::Owned. otherwise it will return:

Element::Owned if there is a single copy of the element on the current processor
Element::Shared if the main copy of the element is located on the current processor
Element::Ghost if current processor stores dependent copy of the element
Parameters

h handle of the element

Returns
Element::Status, see function description

Definition at line 2217 of file inmost_mesh.h.

◆ GlobalID() [1/2]

integer& INMOST::Mesh::GlobalID ( HandleType h )

inline

Retrieve global id of the element with right of modification (dangerous to modify).

Run AssignGlobalID so that tag is automatically allocated and shortcut is set within mesh, otherwise tag is not created and call will fail.

Parameters

h	handle of the element

Returns: global id

See also: Mesh::AssignGlobalID

Definition at line 2196 of file inmost_mesh.h.

◆ GlobalID() [2/2]

integer INMOST::Mesh::GlobalID ( HandleType h ) const

inline

Retrieve global id of the element without right of modification.

Run AssignGlobalID so that tag is automatically allocated and shortcut is set within mesh, otherwise tag is not created and call will fail.

Parameters

h	handle of the element

Returns: global id

See also: Mesh::AssignGlobalID

Definition at line 2203 of file inmost_mesh.h.

◆ HaveData()

bool INMOST::Mesh::HaveData	(	HandleType	h,
		const Tag &	tag
	)		const

Check whether data is present on given element.

Always returns true for dense tag data.

Parameters

h	handle to the element
tag	tag that indicates data

Returns: true, if data exists otherwise false

◆ HaveGlobalID()

bool INMOST::Mesh::HaveGlobalID ( ElementType types ) const

Test whether global identificator was set on certain type of elements.

This function does not validate correctness of global identificators.

Parameters

type	Single type of elements on which to test presence of global identificators.

Returns: Returns true if global identificators are present on provided type of elements.

◆ Hidden()

bool INMOST::Mesh::Hidden ( HandleType h ) const

Check whether element is hidden.

Returns: true if hidden

See also: Mesh::Hide

◆ Hide()

bool INMOST::Mesh::Hide ( HandleType h )

Hide element from mesh.

All the functions (except direct access like LowConn,HighConn or ElementSet::getElementsHandles) involving adjacencies retrieval would not return this element. Works only inside BeginModification and EndModification, on EndModification all Hidden elements are destroyed.

Parameters

h	handle of the element

Returns: if true then element was hidden

See also: Mesh::BeginModification; Mesh::EndModification

◆ HighConn()

Element::adj_type& INMOST::Mesh::HighConn ( HandleType h )

inline

Access directly higher order adjacencies of current element with right of modification.

This function gives direct access to elements and allows you to overwrite handles which is not recommended. You bypass topology checks, correct connectivity establishment and geometric data updates. If you do so then check connectivity afterwards by Element::CheckElementConnectivity for debugging purposes. Then for correct function of geometrical algorithms in order from lower modified adjacenices to upper modified adjacencies (if some element have lower adjacencies updated then it should be updated otherwise it shouldn't) call ComputeGeometricType to deduce geometric representation or force it by SetGeometricType, then for element of type CELL call RestoreCellNodes, clear current mutual connection to the nodes and establish new mutual connections from nodes returned by RestoreCellNodes; then for all elements call RecomputeGeometricData to automatically recompute all geometric quantities. Don't forget that edges of the face should be ordered for correct retrieval of nodes, otherwise Face::getNodes and Element::getNodes for FACE in 3 dimensions or Cell::getNodes and Element::getNodes for CELL in 2 dimensions will return garbage

For NODE this returns edges that are connected to this node;
For EDGE this returns faces that are connected to this edge;
For FACE this returns cells that are connected to this face
For CELL this returns nodes of the cell
For ESET first three entries are parent, sibling, child then records represent empty positions in LowConn

Parameters

h	handle of the element

Returns: see description

See also: Element::CheckElementConnectivity; Element::Connect; Element::Disconnect; Mesh::SetGeometricType; Mesh::ComputeGeometricType; Mesh::RestoreCellNodes; Mesh::RecomputeGeometricData; Face::FixNormalOrientation; Mesh::LowConn

Definition at line 2095 of file inmost_mesh.h.

◆ Initialize()

static void INMOST::Mesh::Initialize	(	int *	argc,
		char ***	argv
	)

static

Initial initialization.

Calls MPI_Initialize, if MPI was not initialized it is necessary to invoke this function if you plan to use any parallel algorithms Accepts arguments passed to console application or NULL

Parameters

argc	number of arguments for command line
argv	strings of arguments of command line

◆ Integer()

integer& INMOST::Mesh::Integer	(	HandleType	h,
		const Tag &	tag
	)

Returns a reference to inner memory location of the first element of the array of integer values.

Future recommendation: If variable size array was not allocated then this function will generate segmentation fault.

If you know that data is certanly dense and fixed or variable on elements you access then it is faster to use specialized variants of this function.

Reference to the data is guaranteed to be valid during mesh modification.

Parameters

h	element handle
tag	tag that represents data

◆ IntegerArray()

integer_array INMOST::Mesh::IntegerArray	(	HandleType	h,
		const Tag &	tag
	)

Returns an array of integer values.

If you know that data is certanly dense and fixed or variable on elements you access then it is faster to use specialized variants of this function. variants of this function with hint data structure.

Array data structure is guaranteed to be valid during mesh modification.

Parameters

h	element handle
tag	tag that represents data

◆ IntegerArrayDF()

integer_array INMOST::Mesh::IntegerArrayDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of integer values in dense array.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set), likely to result in segfault.

Note that as array is fixed you shouldn't use any functions that alter size of the array as resize, erase, insert, you may use replace if initial and final size will match, in debug mode assert will fire if you try to do this in release (NDEBUG is set) it will lead to segfault.

Parameters

h	element handle
tag	tag that represents dense data of fixed size on given handle

Definition at line 1793 of file inmost_mesh.h.

◆ IntegerArrayDV()

integer_array INMOST::Mesh::IntegerArrayDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of integer values in dense array of variable size.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

Parameters

h	element handle
tag	tag that represents data

Definition at line 1951 of file inmost_mesh.h.

◆ IntegerDF()

integer& INMOST::Mesh::IntegerDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference to inner memory location of the first element of the array of integer values.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set).

Parameters

h	element handle
tag	tag that represents dense data of fixed size on given handle

Definition at line 1732 of file inmost_mesh.h.

◆ IntegerDV()

integer& INMOST::Mesh::IntegerDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference in dense array to the first element of variable size array of integer values.

Future recommendation: If array was not allocated then this function will generate segmentation fault.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

Parameters

h	element handle
tag	tag that represents data

Definition at line 1888 of file inmost_mesh.h.

◆ Integrate() [1/7]

real INMOST::Mesh::Integrate	(	const Tag &	t,
		enumerator	entry,
		ElementType	mask
	)

Integrate data corresponding to tag between all processors.

Elements without the data defined on them or when entry not present will be skipped.

Collective operation.

Parameters

t	tag that correspond to data to be integrated
entry	in the array of data
mask	bitwise or of types of elements on which to integrate

Returns: sum between all processors

◆ Integrate() [2/7]

void INMOST::Mesh::Integrate	(	enumerator *	input,
		integer	size
	)

Integrate an array of unsigned integer values over all processors.

Collective operation.

Parameters

input	An array of values on current processor.
size	Size of the array.

Returns: Sum over all processors.

◆ Integrate() [3/7]

enumerator INMOST::Mesh::Integrate ( enumerator input )

Integrate unsigned integer value over all processors.

Collective operation.

Parameters

input Value on current processor

Returns: Sum over all processors

◆ Integrate() [4/7]

void INMOST::Mesh::Integrate	(	integer *	input,
		integer	size
	)

Integrate an array of integer values over all processors.

Collective operation.

Parameters

input	An array of values on current processor.
size	Size of the array.

Returns: Sum over all processors.

◆ Integrate() [5/7]

integer INMOST::Mesh::Integrate ( integer input )

Integrate integer value over all processors.

Collective operation.

Parameters

input Value on current processor

Returns: Sum over all processors

◆ Integrate() [6/7]

void INMOST::Mesh::Integrate	(	real *	input,
		integer	size
	)

Integrate an array of real values over all processors.

Collective operation.

Parameters

input	An array of values on current processor.
size	Size of the array.

Returns: sum over all processors.

◆ Integrate() [7/7]

real INMOST::Mesh::Integrate ( real input )

Integrate real value over all processors.

Collective operation.

Parameters

input Value on current processor

Returns: Sum over all processors

◆ isMeshModified()

bool INMOST::Mesh::isMeshModified ( ) const

inline

Check whether code runs between Mesh::BeginModification, Mesh::EndModification scope.

In case mesh is modified, on element construction Mesh::TieElements will always place elements to the end of the array as a result all the newly created elements will be iterated after current or hidden elements.

Definition at line 3377 of file inmost_mesh.h.

◆ Load()

void INMOST::Mesh::Load ( std::string File )

Acceptable file formats for reading.

".vtk" - legacy vtk format for unstructured grid
".pvtk" - legacy parallel vtk format
".gmv" - format acceptable by general mesh viewer
".msh" - gmsh generator format
".grdecl" - eclipse format (under construction)
".grid" - mesh format by Mohammad Karimi-Fard
".pmf" - internal parallel portable binary format, saves all features

Parameters

File	path to the file

Todo:

When loading mesh with the same tag name but different type or size, load will fail.
When loading tags in internal format should remember definition and sparsity masks for subsequent data loading. This will cure the case when tags were already previously defined on mesh with different masks and data will be read incorrectly.

◆ LowConn()

Element::adj_type& INMOST::Mesh::LowConn ( HandleType h )

inline

Access directly lower order adjacencies of current element with right of modification.

This function gives direct access to elements and allows you to overwrite handles. If you are going to overwrite them then read recommendations in description for HighConn function.

For NODE this returns cells that are connected to this node;
For EDGE this returns nodes of the edge
For FACE this returns edges of the face
For CELL this returns faces of the cell
For ESET handles of the elements that this set contain
Parameters

h handle of the element

Returns
see description

See also
Mesh::HighConn

Definition at line 2121 of file inmost_mesh.h.

◆ MarkBoundaryFaces()

void INMOST::Mesh::MarkBoundaryFaces ( MarkerType boundary_marker )

Sets marker for all the faces that have only one neighbouring cell, works correctly in parallel environment.

Parameters

boundary_marker Non-private marker that will indicate boundary faces.

◆ MarkNormalOrientation()

void INMOST::Mesh::MarkNormalOrientation ( MarkerType mrk )

This function should be used to detect normal inversion on ghost interfaces with respect to normal orientation on owner of the interface.

Due to automatic control over normal orientation in the grid, it may happen that some ghost faces have different orientation rather then face on owner processor. It may happen that some data depends on normal orientation, then one should be aware on a local processor orientation may be different from owner value, then the data may have incorrect sign.

Parameters

mrk	Non-private marker that will indicate inverted normals

◆ New()

bool INMOST::Mesh::New ( HandleType h ) const

Check whether element is new.

Works only in modification state (between BeginModification and EndModification), when you create elements all of them are marked.

Returns: true if new

See also: Mesh::BeginModification; Mesh::EndModification

◆ NumberOfTags()

__INLINE enumerator INMOST::Mesh::NumberOfTags ( ) const

inline

Retrieve the total number of valid tags.

Returns: returns the number of valid tags

Definition at line 1495 of file inmost_mesh.h.

◆ Real()

real& INMOST::Mesh::Real	(	HandleType	h,
		const Tag &	tag
	)

Returns a reference to inner memory location of the first element of the array of real values.

Future recommendation: If variable size array was not allocated then this function will generate segmentation fault.

If you know that data is certanly dense and fixed or variable on elements you access then it is faster to use specialized variants of this function.

Reference to the data is guaranteed to be valid during mesh modification.

Parameters

h	element handle
tag	tag that represents data

See also: Mesh::RealDF; Mesh::RealDV

◆ RealArray()

real_array INMOST::Mesh::RealArray	(	HandleType	h,
		const Tag &	tag
	)

Returns an array of real values.

If you know that data is certanly dense on elements you access then it is faster to use variants of this function with hint data structure.

Array data structure is guaranteed to be valid during mesh modification.

Parameters

h	element handle
tag	tag that represents data

◆ RealArrayDF()

real_array INMOST::Mesh::RealArrayDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of real values in dense array.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set).

Note that as array is fixed you shouldn't use any functions that alter size of the array as resize, erase, insert, you may use replace if initial and final size will match, in debug mode assert will fire if you try to do this in release (NDEBUG is set) it will lead to segfault.

Parameters

h	element handle
tag	tag that represents dense data of fixed size on given handle

Definition at line 1780 of file inmost_mesh.h.

◆ RealArrayDV()

real_array INMOST::Mesh::RealArrayDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of real values in dense array of variable size.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

Parameters

h	element handle
tag	tag that represents data

Definition at line 1942 of file inmost_mesh.h.

◆ RealDF()

real& INMOST::Mesh::RealDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference to inner memory location of the first element of the array of real values.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set).

Parameters

h	element handle
tag	tag that represents data

Definition at line 1723 of file inmost_mesh.h.

◆ RealDV()

real& INMOST::Mesh::RealDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference in dense array to the first element of variable size array of real values.

Future recommendation: If array was not allocated (resized) then this function will generate segmentation fault.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

Parameters

h	element handle
tag	tag that represents data

Definition at line 1876 of file inmost_mesh.h.

◆ RecomputeParallelStorage()

void INMOST::Mesh::RecomputeParallelStorage ( ElementType mask )

Regather ghost and shared element sets for data exchange.

This function will be quite useful if you change statuses of elements or modify mesh on your own bypassing internal algorithms.

No action will be performed if USE_PARALLEL_STORAGE is not set in inmost_common.h, since all the elements are computed during exchange phase.

Generally this is not needed if you use high-level algorithms for mesh modification or mesh redistribution.

Parameters

mask	Bitwise mask of element types for which to recompute the parallel storage.

See also: Mesh::BeginModification; Mesh::EndModification; Mesh::ExchangeMarked; Mesh::RemoveGhostElements

◆ RecordParallelStorage()

void INMOST::Mesh::RecordParallelStorage ( ElementType mask )

Outputs parallel storage into xml log files.

USE_PARALLEL_STORAGE and USE_PARALLEL_WRITE_TIME should be activated in inmost_common.h.

Parameters

mask	Bitwise mask of element types for which to log the parallel storage.

◆ Redistribute()

void INMOST::Mesh::Redistribute ( )

Migrate all the elements to the new owners prescribed in data corresponding to RedistributeTag.

This will perform all the actions to send mesh elements and data and reproduce new mesh partitions on remote elements and correctly resolve parallel state of the mesh. If you have previously prescribed number of layers through ExchangeGhost, then minimal number of actions will be performed to reproduce layers of ghost elements without involving removal of all ghost elements.

Internally function sets up following data on elements using provided information:

"TEMPORARY_NEW_PROCESSORS" - new set processors that contain copy of the element
"TEMPORARY_NEW_OWNER" - new owner for each processor (effectively RedistributeTag)

Action of this function regarding restoration of layers of ghost elements in the case you have modified mesh without involving Mesh::ResolveModification is yet to be tested and should be considered dangerous.

If you have output from Zoltan or ParMetis for cells of the mesh then just write this output to RedistributeTag and call Mesh::Redistribute.

Todo:

introduce "TEMPORARY_KEEP_GHOSTED" tag that will store processors on which copy of element should be kept, internally just merge it with "TEMPORARY_NEW_PROCESSORS" tag this will allow user to control ghosting of certain elements and not to invoke ExchangeMarked every time after Redistribute. This is probably already done using Mesh::SendtoTag, because function fills it without clearing and ExchangeMarked performs initial action based on SendtoTag, it is due to check that SendtoTag is properly merged with "TEMPORARY_NEW_PROCESSORS" before call to ExchangeMarked and received elements are not deleted by accident.
let user provide any integer tag as input without involving RedistributeTag

Collective point-2-point.

See also: Mesh::RedistributeTag; Mesh::ExchangeGhost

◆ ReduceData() [1/2]

void INMOST::Mesh::ReduceData	(	const Tag &	tag,
		ElementType	mask,
		MarkerType	select,
		ReduceOperation	op
	)

Accumulation of data from ghost elements to shared elements.

Accumulation is performed based on user-provided function. When processor - owner of the element receives data addressed to this element then it calls user-defined op function. Since there may be multiple ghost elements per one shared element, function may be called multiple times.

Several examples of reduction functions may be found within the parallel.cpp source.

Remember that the result will be up to date only on the owner processor of the element. You will have to run Mesh::ExchangeData to make the data up to date among all of the processors.

If you have a tag of DATA_BULK type and you store your own custom data structure in it, it is highly recommended that you provide MPI information about your structure through Tag::SetBulkDataType, this would not do any difference on homogeneous architecture, but it may help you save a lot of time and nerves in heterogeneous parallel environment.

Exchanging tags of DATA_REFERENCE is not implemented, TODO 14.

Todo:

Exchanging DATA_REFERENCE,DATA_REMOTE_REFERENCE tags not implemented, this is due to the absence of any conclusion

on how it should behave: either only search within elements owned by the other processor and establish references and set InvalidHandle() to elements that are not found (fairly easy, will involve search operations to check against owned elements for similar entry, efficient implementation will require bounding search trees (see TODO 49);
or: send all the referenced elements through PackElementsData and establish all the links within elements reproduced by UnpackElementsData (UnpackElementsData calls UnpackTagData with set of unpacked elements using which it will be very comfortable to establish references on remote processor). Drawback is that exchanging laplacian operator in such a manner should result in the whole grid being shared among all the processors.

Blocking, Collective point-2-point

Parameters

tag	tag that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
op	user-defined operation on received data

See also: Mesh::ExchangeData

◆ ReduceData() [2/2]

void INMOST::Mesh::ReduceData	(	const tag_set &	tags,
		ElementType	mask,
		MarkerType	select,
		ReduceOperation	op
	)

This function will perform reduction of multiple data tags.

Note that function will be the same for all tags, you can differentiate behavior of function depending on tag name (may be expensive).

Blocking, collective point-2-point

Parameters

tags	multiple tags that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
op	user-defined operation on received data

◆ ReduceDataBegin() [1/2]

void INMOST::Mesh::ReduceDataBegin	(	const Tag &	tag,
		ElementType	mask,
		MarkerType	select,
		exchange_data &	storage
	)

This function intializes data reduction.

Read recommendations about exchange_storage object in Mesh::ExchangeDataBegin

Nonblocking, Collective point-2-point

Parameters

tag	tag that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
storage	buffer that will temporary hold sended data

See also: Mesh::ReduceData; Mesh::ExchangeDataBegin

◆ ReduceDataBegin() [2/2]

void INMOST::Mesh::ReduceDataBegin	(	const tag_set &	tags,
		ElementType	mask,
		MarkerType	select,
		exchange_data &	storage
	)

This function will initialize reduction of multiple data tags.

Nonblocking, collective point-2-point

Parameters

tags	multiple tags that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
storage	buffer that will temporary hold sended data

◆ ReduceDataEnd() [1/2]

void INMOST::Mesh::ReduceDataEnd	(	const Tag &	tag,
		ElementType	mask,
		MarkerType	select,
		ReduceOperation	op,
		exchange_data &	storage
	)

This function completes data reduction.

Read Mesh::ReduceData for information about op function

Blocking

Parameters

tag	tag that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
storage	buffer that will temporary hold sended data
op	user-defined operation on received data

See also: Mesh::ReduceData

◆ ReduceDataEnd() [2/2]

void INMOST::Mesh::ReduceDataEnd	(	const tag_set &	tags,
		ElementType	mask,
		MarkerType	select,
		ReduceOperation	op,
		exchange_data &	storage
	)

This function will finalize exchange of multiple data tags.

Blocking

Parameters

tags	multiple tags that represents data
mask	bitwise or of element types
select	set the marker to filter elements that perform operation, set 0 to select all elements
storage	buffer that will temporary hold sended data
op	user-defined operation on received data

◆ Reference()

reference& INMOST::Mesh::Reference	(	HandleType	h,
		const Tag &	tag
	)

Returns a reference in an inner representation to the first element of array of element handles.

Future recommendation: If variable size array was not allocated then this function will generate segmentation fault.

If you know that data is certanly dense and fixed or variable on elements you access then it is faster to use specialized variants of this function.

Reference to the data is guaranteed to be valid during mesh modification.

Using handle you can construct objects of type Storage, Element, Node, Edge, Face, Cell, ElementSet by calling their constructor with pointer to mesh and handle as arguments.

Parameters

h	element handle
tag	tag that represents data

◆ ReferenceArray()

reference_array INMOST::Mesh::ReferenceArray	(	HandleType	h,
		const Tag &	tag
	)

Returns an array of element handles.

If you know that data is certanly sparse or dense on elements you access then it is faster to use variants of this function with hint data structure.

The class reference_array that is used to represent array of elements stores handles inside but accessing them through square scopes [] or by arrow -> in iterator will automatically form object of type Element. If you are not sure that stored handles are valid, you should either check that by Element::isValid (involves deep check) or test handle against InvalidHandle (simple check). To obtain handle you may use reference_array::at function or dereference * operator for iterator. If you need custom object like Node, Edge, Face, Cell or ElementSet you may use Element::getAsNode, Element::getAsEdge, Element::getAsFace, Element::getAsCell and Element::getAsSet functions.

Array data structure is guaranteed to be valid during mesh modification. If you delete elements by Mesh::Delete or Element::Delete all the references are also will be valid and reverted to InvalidHandle on Mesh::ApplyModification. If you use Mesh::Destroy to delete mesh elements or you delete elements not within modification state then references may become either invalid but not testable against InvalidHandle (situation may be tested by Element::isValid or Mesh::isValidHandle) or reference may be reused by another element. If you mix deletion and construction of elements then there is no way to resolve this situation, except if you have created only one element, then it may be retrieved by Mesh::LastHandle.

Parameters

h	element handle
tag	tag that represents data

See also: InvalidHandle; Element::isValid; Element::getAsNode; Element::getAsEdge; Element::getAsFace; Element::getAsCell; Element::getAsSet

◆ ReferenceArrayDF()

reference_array INMOST::Mesh::ReferenceArrayDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of element handles in dense array.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set), likely to result in segfault.

Note that as array is fixed you shouldn't use any functions that alter size of the array as resize, erase, insert, you may use replace if initial and final size will match, in debug mode assert will fire if you try to do this in release (NDEBUG is set) it will lead to segfault.

The class reference_array that is used to represent array of elements stores handles inside but accessing them through square scopes [] or by arrow -> in iterator will automatically form object of type Element. If you are not sure that stored handles are valid, you should either check that by Element::isValid (involves deep check) or test handle against InvalidHandle (simple check). To obtain handle you may use reference_array::at function or dereference * operator for iterator. If you need custom object like Node, Edge, Face, Cell or ElementSet you may use Element::getAsNode, Element::getAsEdge, Element::getAsFace, Element::getAsCell and Element::getAsSet functions.

Parameters

h	element handle
tag	tag that represents dense data of fixed size on given handle

See also: InvalidHandle; Element::isValid; Element::getAsNode; Element::getAsEdge; Element::getAsFace; Element::getAsCell; Element::getAsSet

Definition at line 1835 of file inmost_mesh.h.

◆ ReferenceArrayDV()

reference_array INMOST::Mesh::ReferenceArrayDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of element handles in dense array of variable size.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

The class reference_array that is used to represent array of elements stores handles inside but accessing them through square scopes [] or by arrow -> in iterator will automatically form object of type Element. If you are not sure that stored handles are valid, you should either check that by Element::isValid (involves deep check) or test handle against InvalidHandle (simple check). To obtain handle you may use reference_array::at function or dereference * operator for iterator. If you need custom object like Node, Edge, Face, Cell or ElementSet you may use Element::getAsNode, Element::getAsEdge, Element::getAsFace, Element::getAsCell and Element::getAsSet functions.

Parameters

h	element handle
tag	tag that represents data

See also: InvalidHandle; Element::isValid; Element::getAsNode; Element::getAsEdge; Element::getAsFace; Element::getAsCell; Element::getAsSet

Definition at line 1985 of file inmost_mesh.h.

◆ ReferenceDF()

reference& INMOST::Mesh::ReferenceDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference in dense array to the first element of constant size array of element handles.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set).

Using handle you can construct objects of type Storage, Element, Node, Edge, Face, Cell, ElementSet by calling their constructor with pointer to mesh and handle as arguments.

Parameters

h	element handle
tag	tag that represents dense data of fixed size on given handle

Definition at line 1754 of file inmost_mesh.h.

◆ ReferenceDV()

reference& INMOST::Mesh::ReferenceDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference in dense array to the first element of variable size array of element handles.

Future recommendation: If array was not allocated then this function will generate segmentation fault.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

Using handle you can construct objects of type Storage, Element, Node, Edge, Face, Cell, ElementSet by calling their constructor with pointer to mesh and handle as arguments.

Parameters

h	element handle
tag	tag that represents data

Definition at line 1917 of file inmost_mesh.h.

◆ ReleaseMarker()

void INMOST::Mesh::ReleaseMarker	(	MarkerType	n,
		ElementType	cleanup = `NONE`
	)

Release marker back for reuse.

This function will only notice mesh that the marker is free to be reused, this will not clear markers from elements. Before releasing the marker you should ensure that all the marker is removed from all the elements. Since many inner algorithms use markers, not properly clearing markers from elements may lead to undefined behavior.

Since it is expensive to check asserts will fire in debug mode (NDEBUG not set) only if you define CHECKS_MARKERS in inmost_common.h, no checks will be performed in release mode(NDEBUG is set).

Parameters

n	Byte position and byte bit mask.
cleanup	Elements on which marker should be removed.

◆ RemMarker()

__INLINE void INMOST::Mesh::RemMarker	(	HandleType	h,
		MarkerType	n
	)

inline

Remove the marker from the element.

Parameters

h	element handle
n	stores byte number and byte bit mask that represent marker

Definition at line 2044 of file inmost_mesh.h.

◆ RemMarkerArray()

void INMOST::Mesh::RemMarkerArray	(	const HandleType *	h,
		enumerator	n,
		MarkerType	m
	)

inline

Remove the marker from the set of handles.

Parameters

h	set of handles
n	number of handles
m	stores byte number and byte bit mask that represent marker

See also: Mesh::RemMarker

Definition at line 2052 of file inmost_mesh.h.

◆ RemoteReference()

remote_reference& INMOST::Mesh::RemoteReference	(	HandleType	h,
		const Tag &	tag
	)

Returns a reference in an inner representation to the first element of array of element remote handles.

Future recomendation: If variable size array was not allocated then this function will generate segmentation fault.

If you know that data is certanly dense and fixed or variable on elements you access then it is faster to use specialized variants of this function.

Reference to the data is guaranteed to be valid during mesh modification.

Using remote handle you can construct objects of type Element with the function MakeElement or MakeElementRef.

Parameters

h	element handle
tag	tag that represents data

See also: MakeElement; MakeElementRef

◆ RemoteReferenceArray()

remote_reference_array INMOST::Mesh::RemoteReferenceArray	(	HandleType	h,
		const Tag &	tag
	)

Returns an array of element remote handles.

If you know that data is certanly sparse or dense on elements you access then it is faster to use variants of this function with hint data structure.

The class reference_array that is used to represent array of elements stores remote handles inside but accessing them through square scopes [] or by arrow -> in iterator will automatically form an object of type Element. If you are not sure that stored handles are valid, you should either check that by Element::isValid (involves deep check) or test handle against InvalidHandle (simple check). To obtain remote handle you may use remote_reference_array::at function or dereference * operator for iterator. If you need custom object like Node, Edge, Face, Cell or ElementSet you may use Element::getAsNode, Element::getAsEdge, Element::getAsFace, Element::getAsCell and Element::getAsSet functions.

Array data structure is guaranteed to be valid during mesh modification. If you delete elements by Mesh::Delete or Element::Delete all the references are also will be valid and reverted to InvalidHandle on Mesh::ApplyModification. If you use Mesh::Destroy to delete mesh elements or you delete elements not within modification state then references may become either invalid but not testable against InvalidHandle (situation may be tested by Element::isValid or Mesh::isValidHandle) or reference may be reused by another element. If you mix deletion and construction of elements then there is no way to resolve this situation, except if you have created only one element, then it may be retrieved by Mesh::LastHandle.

Parameters

h	element handle
tag	tag that represents data

See also: InvalidHandle; Element::isValid; Element::getAsNode; Element::getAsEdge; Element::getAsFace; Element::getAsCell; Element::getAsSet

◆ RemoteReferenceArrayDF()

remote_reference_array INMOST::Mesh::RemoteReferenceArrayDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of element remote handles in dense array.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set), likely to result in segfault.

Note that as array is fixed you shouldn't use any functions that alter size of the array as resize, erase, insert, you may use replace if initial and final size will match, in debug mode assert will fire if you try to do this in release (NDEBUG is set) it will lead to segfault.

The class remote_reference_array that is used to represent array of elements stores handles inside but accessing them through square scopes [] or by arrow -> in iterator will automatically form object of type Element. If you are not sure that stored handles are valid, you should either check that by Element::isValid (involves deep check) or test handle against InvalidHandle (simple check). To obtain handle you may use reference_array::at function or dereference * operator for iterator. If you need custom object like Node, Edge, Face, Cell or ElementSet you may use Element::getAsNode, Element::getAsEdge, Element::getAsFace, Element::getAsCell and Element::getAsSet functions.

Parameters

h	element handle
tag	tag that represents dense data of fixed size on given handle

See also: InvalidHandle; Element::isValid; Element::getAsNode; Element::getAsEdge; Element::getAsFace; Element::getAsCell; Element::getAsSet

Definition at line 1864 of file inmost_mesh.h.

◆ RemoteReferenceArrayDV()

remote_reference_array INMOST::Mesh::RemoteReferenceArrayDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns an array of element remote handles in dense array of variable size.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

The class remote_reference_array that is used to represent array of elements stores remote handles inside but accessing them through square scopes [] or by arrow -> in iterator will automatically form object of type Element. If you are not sure that stored handles are valid, you should either check that by Element::isValid (involves deep check) or test handle against InvalidHandle (simple check). To obtain handle you may use reference_array::at function or dereference * operator for iterator. If you need custom object like Node, Edge, Face, Cell or ElementSet you may use Element::getAsNode, Element::getAsEdge, Element::getAsFace, Element::getAsCell and Element::getAsSet functions.

Parameters

h	element handle
tag	tag that represents data

See also: InvalidHandle; Element::isValid; Element::getAsNode; Element::getAsEdge; Element::getAsFace; Element::getAsCell; Element::getAsSet

Definition at line 2010 of file inmost_mesh.h.

◆ RemoteReferenceDF()

remote_reference& INMOST::Mesh::RemoteReferenceDF	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference in dense array to the first element of constant size array of element remote handles.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and fixed is incorrect, no checks performed in release mode (NDEBUG is set).

Using handle you can construct objects of type Storage, Element, Node, Edge, Face, Cell, ElementSet by calling their constructor with pointer to mesh and handle as arguments.

Parameters

h	element handle
tag	tag that represents dense data of fixed size on given handle

Definition at line 1767 of file inmost_mesh.h.

◆ RemoteReferenceDV()

remote_reference& INMOST::Mesh::RemoteReferenceDV	(	HandleType	h,
		const Tag &	tag
	)

inline

Returns a reference in dense array to the first element of variable size array of element remote handles.

Future recommendation: If array was not allocated then this function will generate segmentation fault.

If you don't know any hint information about tag data you should not use this function.

Asserts will fire in debug mode if assumption that data is dense and variable is incorrect, no checks performed in release mode (NDEBUG is set).

Using handle you can construct objects of type Storage, Element, Node, Edge, Face, Cell, ElementSet by calling their constructor with pointer to mesh and handle as arguments.

Parameters

h	element handle
tag	tag that represents data

Definition at line 1933 of file inmost_mesh.h.

◆ RemoveGhostElements()

void INMOST::Mesh::RemoveGhostElements	(	const HandleType *	ghost,
		enumerator	num
	)

Delete some ghost cells provided in array.

Non-ghost elements will also be deleted.

This algorithm will properly communicate between processors so that parallel states of deleted elements properly updated on remote processors. Internally function invokes Destroy function, not Delete, which hides elements during modification state, currently it is not expected that any parallel algorithms will be performed between BeginModification and EndModification since modification may break parallel state though it is never checked whether the mesh is in the modification state, so you are free to experiment. This behavior may change in future.

Collective point-2-point.

Parameters

ghost	array of handles
num	number of handles

Todo:

Currently request for deletion of elements of lower level then cell will be simply ignored, ensure in future that algorithm will properly rise deletion data from lower to upper adjacencies to delete all the upper adjacencies that depend on deleted lower adjacencies

◆ ResolveModification()

void INMOST::Mesh::ResolveModification ( )

This function is not yet implemented.

It should correctly resolve parallel state of newly created elements, provide them valid global identificators, resolve owners of the elements potentially optimized using information from BridgeTag and LayersTag May use ResolveShared function as basis but instead the whole mesh run the same algorithm for subset.

◆ Save()

void INMOST::Mesh::Save ( std::string File )

Acceptable file formats for writing.

".vtk" - legacy vtk format for unstructured grid
".pvtk" - legacy parallel vtk format
".gmv" - format acceptable by general mesh viewer
".pmf" - internal parallel portable binary format, saves all features

Remeber: .pmf stores all references to elements. If reference are broken due to mesh modification, saving or loading such a mesh may lead to segfault. To automatically maintain correct references modify mesh using BeginModification, ApplyModification, EndModification

Parameters

File	path to the file

Todo:

Markers are not saved in internal format due to possible conflict during load.

◆ SetData()

void INMOST::Mesh::SetData	(	HandleType	h,
		const Tag &	tag,
		enumerator	shift,
		enumerator	size,
		const void *	data
	)

Copy into inner data array of size elements from provided array beginning from shift element.

Parameters

h	handle of element
tag	tag that represents data
shift	for which element to start to copy
size	how many elements to copy
data	user-provided array where data should be copied

◆ SetDataSize()

void INMOST::Mesh::SetDataSize	(	HandleType	h,
		const Tag &	tag,
		enumerator	new_size
	)

Sets the size of the array for data of variable size.

If you try to change size of data of constant size then if size is different from current then in debug mode (NDEBUG not set) assertion will fail, in release mode nothing happens.

Parameters

h	handle of element
tag	tag that represents the data
new_size	new size of the array

◆ SetDimensions()

void INMOST::Mesh::SetDimensions ( integer dim )

Set number of dimensions for mesh.

It sets the size for number of internally stored coordinates. Size of the array returned by Node::Coords will match this number. When you change number of dimensions and there are nodes with bigger number of dimensions then first dim coordinates are copied and the rest are dropped.

See also: Node::Coords

◆ SetEpsilon()

__INLINE void INMOST::Mesh::SetEpsilon ( real e )

inline

Set tolerance for coordinates comparison.

This tolerance is used in comparators when two meshes are merged during loading, in ResolveShared to check that nodes on different processors match and in UnpackElementsData

Parameters

e	small real value

Definition at line 1427 of file inmost_mesh.h.

◆ SetFileOption()

void INMOST::Mesh::SetFileOption	(	std::string	,
		std::string
	)

Set file option.

Current available file options:

"VERBOSITY" - Set "2" for progress messages, "1" for reports, "0" for silence
"VTK_GRID_DIMS" - Set "2" for two-dimensional vtk grids, "3" for three-dimensional vtk grids or "AUTO" for automatic detection.
"VTK_OUTPUT_FACES" - Set "1" for vtk output of values on faces
"ECL_SPLIT_GLUED" - Set "TRUE" to triangulate faces of the blocks that degenerate on three pillars.
"ECL_PROJECT_PERM" - Set "TRUE" to project permeability tensor from grid block coordinates into global coordinates. Otherwise the tensor is considered to be defined on global coordinates. Default "FALSE".
"ECL_COMPUTE_TRAN" - compute and store transmissibilities on the faces using NEWTRAN approach in eclipse 100
"ECL_DEGENERATE" - In GRDECL format some active grid block may have zero volume, which means there is a fault. Set "TRUE" to introduce a gap between blocks that share degenerate active grid block, set to "TRANM" to introduce zero transmissibility multiplier and keep the grid connected and "FALSE" to simply keep the grid connected. Default: "TRUE".
"ECL_TOPOLOGY" - If "TRUE" checks topology of the grid for errors, this may provide useful warnings if layers of the mesh enter each other and the grid cannot be considered conformal. Default: "FALSE". "ECL_PARALLEL_READ"- If "TRUE" then each processor loads part of the eclipse mesh, requires some synchronization. Otherwise if "FALSE" then each processor loads entire mesh. Default: "TRUE". "KEEP_GHOST" - If options is set, the ghost elements are written into files. By default ghost elements are skipped. "Tag:TAGNAME" - Set comma-separated rules for tag with the name TAGNAME, the rules list is: nosave - do not save the tag data into files; noload - do not load the tag data from files; noderivatives - do not save/load the derivatives for data with type DATA_VARIABLE (for .xml and .pmf); loadonly - this creates an exclusive list for data to be loaded from files, all other tag names will be ignored; saveonly - this creates an exclusive list for data to be saved to files, all other tag names will be ignored. Example: mesh->SetFileOption("Tag:PressureGradient","noload,noderivatives"); the tag with the name PressureGradient will not be loaded from files and when recording the derivaives data will be not saved.

◆ SetMarker()

__INLINE void INMOST::Mesh::SetMarker	(	HandleType	h,
		MarkerType	n
	)

inline

Set a marker on the element represented by handle.

Parameters

h	element handle
n	stores byte number and byte bit mask that represent marker

Definition at line 2023 of file inmost_mesh.h.

◆ SetMarkerArray()

__INLINE void INMOST::Mesh::SetMarkerArray	(	const HandleType *	h,
		enumerator	n,
		MarkerType	m
	)

inline

Set a marker on the set of handles.

Parameters

h	set of handles
n	number of handles
m	stores byte number and byte bit mask that represent marker

See also: Mesh::SetMarker

Definition at line 2032 of file inmost_mesh.h.

◆ SetMarkerSpace()

void INMOST::Mesh::SetMarkerSpace	(	HandleType	h,
		bulk	source[MarkerFields]
	)

Overwrite the bytes that store markers on the element.

Parameters

h	element handle
source	storage to get data from

◆ SetParallelFileStrategy()

void INMOST::Mesh::SetParallelFileStrategy ( int strategy )

inline

Set parallel strategy for inner communications.

There are three possible scenarios in parallel communication associated in accordance to enum Prepare structure:

The communicating processors and sizes of the messages are known apriori
UnknownSize: Communicating processors are known but sizes are unknown
unknownSource: Communicationg processors are unknown

Currently with UnknownSize it will run the following algorithm none for strategy 0, following for strategies 1 and 2:

Post asynchronous receive with MPI_Irecv of size of buffer to be sent
Post asynchronous send with MPI_Isend for required corresponding receive buffer size
Wait for all asynchronous operations by MPI_Waitall

With UnknownSource there are two options depending from the USE_MPI_P2P define. If USE_MPI_P2P is defined then MPI-2 api operations will be used

MPI_Win_fence to start operations
MPI_Put from specially allocated memory location to remote processor of array size is performed
MPI_Win_fence to stop operations

if USE_MPI_P2P not set then MPI-1 api will be used

MPI_Allgather for number of processors to which current processor wants to send data
MPI_Allgatherv for sizes and destinations for each processors

Initially it was intended to mainly use MPI-2 functionality for both scenarios but it was realized that there is no available hardware on which MPI-2 functionality performs much better than MPI-1 counterparts, especially in the case of UnknownSize. Probably this happens due to lack of support of RDMA operations. If you believe it will be better to use MPI-2 in both cases you are free to uncomment definition of PREFFER_MPI_P2P in inmost_common.h then MPI-2 will be used in both scenarios. These algorithms above are implemented in Mesh::ExchangeBufferInner.

After first problem was resolved following strategies are available for main communication: strategy = 0

Asynchronous send of data by MPI_Isend;
Check incoming messages by MPI_Probe;
Check incoming message size by MPI_Get_size;
Allocation of buffers of required size;
Asynchronous receive of data
MPI_Waitsome to copy received results to buffers

This strategy shows to be the fastest on mac with intel core 2 duo it appears to be independent of apriori knowledge of sizes of incoming messages and skips the step of determining sizes in all the cases but still it requires establishing knowledge of communicating processors Asynchronous sending and receiving may be performed by breaking the steps 1) and 2-5) but should be considered bad since it will be performed without appropriate receive buffers posted for sends, as a result messages will stuck in network pipeline and would be repeatedly rejected resulting in bad networking performance especially if processors have small memory. As a result non-asynchronous communication is implemented with this strategy breaking steps 1-5) and 6) when you ask for asynchronous communication strategy = 1

Post asynchronous receive of data by MPI_Irecv
Post asynchronous send of data by MPI_Isend
MPI_Waitsome for any received data

True asynchronous behavior is reproduced by breaking 1-2) and 3) strategy = 2

Post asynchronous receive of data by MPI_Irecv
Set MPI_Barrier to ensure that all the receives were properly set by the time

Perform direct send of data by MPI_Irsend
MPI_Waitsome for any received data

For asynchronous communication algorithm is broken into 1-3) and 4) which is fairly asynchronous. The only provisional benefit it may have on machines with small memory since it should bypass any allocation of buffers for sent and received data by MPI and probably not perform any rendezvous communication to ensure data allocation. But MPI_Barrier looks like elephant here.

Algorithms above are implemented in Mesh::ExchangeBuffersInner

See also: Mesh::PrepareReceiveInner; Mesh::ExchangeBuffersInner Retrieve currently set parallel strategy.; Mesh::SetParallelStrategy This strategy corresponds only to internal ".pmf" mesh format. There are two available strategies for ".pmf" files loading and saving:

strategy = 0

on save
1. every processor gather local data to some buffer
2. MPI_Gather to obtain sizes of data among processors
3. MPI_Gatherv to obtain the whole data on zeros processor
4. the first processor writes all the data to disk by std::fstream
on load
1. first processors reads the whole file by std::fstream
2. MPI_Scatter distributes block sizes among processors
3. MPI_Scatterv distributes blocks among processors
4. Each processor parses its block

This strategy requires one processor to hold all the data, which is quite bad for large files. New strategy may be created from this one in the future when each processors consequently obtain access to the file using std::fstream and writes the data.

strategy = 1

on save it will perform:
1. MPI_Gather to obtain sizes of data among processors on zeroth processor
2. MPI_File_open to get parallel handle for the file
3. MPI_File_write_shared called by processor with zeroth rank to write header
4. MPI_File_write_ordered to write contents of individual data
5. MPI_File_close to close parallel file handle
on load it will perform
1. MPI_File_open to open the file in parallel
2. MPI_File_read_shared to get contents of header on zeroth processor
3. MPI_Scatter to distribute block sizes among processors
4. MPI_File_read_ordered to obtain contents
5. MPI_File_close to close parallel file handle
Availible only when USE_MPI_P2P is set because it rely on MPI-2 api that begins with MPI_File_xxx some MPI-1 standards contain this API as an extension.

The strategy 1 appeared to be considerably slower on INM cluster than strategy 0, this may happen due to lack of read-write devices that able to work in parallel. On IBM Bluegene/p strategy 1 was not working due to same old problem with shared file pointers in their MPI realization

Definition at line 2537 of file inmost_mesh.h.

◆ SetStatus()

void INMOST::Mesh::SetStatus	(	HandleType	h,
		Element::Status	s
	)

inline

Set parallel status of the element.

If mesh is in Serial state then call will fire asserts in debug mode and segfault in relese mode.

Parallel status controls how exchange of data between elements will be performed, it is expected that number of elements and copies of elements do match between processors. This kind of check is never performed and if you fail to setup statuses correctly, you may end up with data being copied to incorrect elements. If you modify statuses on your own don't forget to call RecomputeParallelStorage, otherwise exchange will be performed by old status guidelines.

Parameters

h	handle of the element
s	new status of the element

Definition at line 2229 of file inmost_mesh.h.

◆ Show()

bool INMOST::Mesh::Show ( HandleType h )

Show element from mesh.

Parameters

h	handle of the element

Returns: true then element was recovered

See also: Mesh::Hide

◆ SortByGlobalID()

void INMOST::Mesh::SortByGlobalID	(	HandleType *	h,
		enumerator	num
	)

Todo:: TODO 53 check that putting global ids to array will be faster

◆ SortParallelStorage()

void INMOST::Mesh::SortParallelStorage ( ElementType mask )

Sort parallel storage.

Parallel storage is sorted according to global identificators or centroids of elements if global identificators are not available. If you manually change global identificators or if global identificators are not available and coordinates of nodes change, then you should invoke this function. You can check presence of global identificators on single type of elements using function Mesh::HaveGlobalID. This function is called automatically inside Mesh::AssignGlobalID. No action will be performed if USE_PARALLEL_STORAGE is not set in inmost_common.h.

Parameters

mask	Bitwise mask of element types for which to sort the parallel storage.

◆ SynchronizeElementType()

ElementType INMOST::Mesh::SynchronizeElementType ( ElementType etype )

Synchronize bitwise mask of element types between processors.

Collective operation

Parameters

etype bitwise type mask

Returns: bitwise result among processors

◆ SynchronizeMarker()

void INMOST::Mesh::SynchronizeMarker	(	MarkerType	marker,
		ElementType	mask,
		SyncBitOp	op
	)

Synchronize marker on elements between processors using provided operation.

Depending on requested operation following action is performed:

SYNC_BIT_SET - value on ghost elements is set by value on corresponding shared processors;
SYNC_BIT_OR - bitwise OR between values in ghost and shared elements;
SYNC_BIT_AND - bitwise AND between values in ghost and shared elements;
SYNC_BIT_XOR - bitwise XOR between values in ghost and shared elements.
Parameters

marker marker to be synchronized

mask bitwise or type mask

op operation, one of SYNC_BIT_SET, SYNC_BIT_OR, SYNC_BIT_XOR, SYNC_BIT_AND

◆ TagOptions()

std::set<std::string> INMOST::Mesh::TagOptions ( std::string name ) const

Collect file options related to records Tag:TAGNAME.

Parameters

given option name, such as nosave, noload, noderivatives, loadonly, saveonly

Returns: a set of tags that has given option

◆ TopologyErrorTag()

Tag INMOST::Mesh::TopologyErrorTag ( ) const

inline

This will return tag by which you can retrieve error mark to any element on which topology check failed.

As this is sparse tag you can check presence of error by Element::HaveData or Mesh::HaveData check. This tag will be valid only if you pass MARK_ON_ERROR to Mesh::GetTopologyCheck and will be deleted if you pass MARK_ON_ERROR to Mesh::RemTopologyCheck

Definition at line 3451 of file inmost_mesh.h.

◆ TotalNumberOf()

integer INMOST::Mesh::TotalNumberOf ( ElementType mask )

Sum of all physical elements, it excludes ghost copies.

To compute total number including ghost copies run Integrate(NumberOf(mask))

Collective operation.

Parameters

mask	bitwise mask of element types, example: NODE \| CELL

Returns: sum of elements

See also: Mesh::NumberOf

◆ WachspressInterpolation2D()

void INMOST::Mesh::WachspressInterpolation2D	(	const real *	x,
		const Face &	f,
		std::map< HandleType, real > &	nodes_stencil
	)		const

Compute node-centered interpolation on 2d face for point.

Point should be inside face or on its boundary.

Parameters

x	Interpolation point
f	Face (should be 2d) which contains point
nodes_stencil	Vector of pairs (node handle, coefficient) to store interpolation data

◆ WachspressInterpolation3D()

void INMOST::Mesh::WachspressInterpolation3D	(	const real *	x,
		const Cell &	c,
		std::map< HandleType, real > &	nodes_stencil
	)		const

Compute node-centered interpolation on 3d cell for point Point should be inside cell or on its boundary.

Parameters

x	Interpolation point
c	Cell (should be 3d) which contains point
nodes_stencil	Vector of pairs (node handle, coefficient) to store interpolation data

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

inmost_mesh.h

marker	marker to be synchronized
mask	bitwise or type mask
op	operation, one of SYNC_BIT_SET, SYNC_BIT_OR, SYNC_BIT_XOR, SYNC_BIT_AND

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ ApplyModification()

◆ AssignGlobalID()

◆ BeginTag()

◆ BeginTopologyCheck()

◆ Bulk()

◆ BulkArray()

◆ BulkArrayDF()

◆ BulkArrayDV()

◆ BulkDF()

◆ BulkDV()

◆ CheckCentroids()

◆ CheckGhostSharedCount()

◆ ComputeGeometricType()

◆ CopyData()

◆ CreateMarker()

◆ CreateNode()

◆ CreateTag()

◆ DataLocalID()

◆ DelData()

◆ DelDenseData() [1/2]

◆ DelDenseData() [2/2]

◆ Delete()

◆ DeleteTag()

◆ DelSparseData()

◆ Destroy()

◆ EndTag()

◆ EndTopologyCheck()

◆ Enumerate() [1/3]

◆ Enumerate() [2/3]

◆ Enumerate() [3/3]

◆ EnumerateSet()

◆ ExchangeData() [1/2]

◆ ExchangeData() [2/2]

◆ ExchangeDataBegin() [1/2]

◆ ExchangeDataBegin() [2/2]

◆ ExchangeDataEnd() [1/2]

◆ ExchangeDataEnd() [2/2]

◆ ExchangeGhost()

◆ ExchangeMarked()

◆ ExchangeOrientedData() [1/2]

◆ ExchangeOrientedData() [2/2]

◆ ExclusiveSum()

◆ FacesOrientation()

◆ FindSharedAdjacency()

◆ GetData()

◆ GetDataCapacity() [1/2]

◆ GetDataCapacity() [2/2]

◆ GetDataSize()

◆ GetDimensions()

◆ GetEpsilon()

◆ GetFileOption()

◆ GetMarker()

◆ GetMarkerSpace()

◆ GetMeshState()

◆ GetParallelFileStrategy()

◆ GetSet()

◆ GetStatus()

◆ GlobalID() [1/2]

◆ GlobalID() [2/2]

◆ HaveData()

◆ HaveGlobalID()

◆ Hidden()

◆ Hide()

◆ HighConn()

◆ Initialize()

◆ Integer()

◆ IntegerArray()

◆ IntegerArrayDF()

◆ IntegerArrayDV()

◆ IntegerDF()

◆ IntegerDV()

◆ Integrate() [1/7]