Loading...
Searching...
No Matches
Parallel Computing based on Indexsets
Common » Parallel Communication

Provides classes for syncing distributed indexed data structures. More...

Collaboration diagram for Parallel Computing based on Indexsets:

## Files

file | communicator.hh
| Provides utility classes for syncing distributed data via MPI communication.
file | indexset.hh
| Provides a map between global and local indices.
file | indicessyncer.hh
| Class for adding missing indices of a distributed index set in a local communication.
file | interface.hh
| Provides classes for building the communication interface between remote indices.
file | localindex.hh
| Provides classes for use as the local index in ParallelIndexSet.
file | plocalindex.hh
| Provides classes for use as the local index in ParallelIndexSet for distributed computing.
file | remoteindices.hh
| Classes describing a distributed indexset.
file | selection.hh
| Provides classes for selecting indices based on attribute flags.
file | variablesizecommunicator.hh
| A communicator that only needs to know the number of elements per index at the sender side.

## Classes

struct | Dune::SizeOne
| Flag for marking indexed data structures where data at each index is of the same size. More...
struct | Dune::VariableSize
| Flag for marking indexed data structures where the data at each index may be a variable multiple of another type. More...
struct | Dune::CommPolicy< V >
| Default policy used for communicating an indexed type. More...
class | Dune::BufferedCommunicator
| A communicator that uses buffers to gather and scatter the data to be send or received. More...
class | Dune::IndexPair< TG, TL >
| A pair consisting of a global and local index. More...
struct | Dune::MPITraits< T >
| A traits class describing the mapping of types onto MPI_Datatypes. More...
class | Dune::InvalidIndexSetState
| Exception indicating that the index set is not in the expected state. More...
class | Dune::GlobalLookupIndexSet< I >
| Decorates an index set with the possibility to find a global index that is mapped to a specific local. More...
class | Dune::ParallelIndexSet< TG, TL, N >
| Manager class for the mapping between local indices and globally unique indices. More...
class | Dune::ParallelIndexSet< TG, TL, N >::iterator
| The iterator over the pairs. More...
struct | Dune::LocalIndexComparator< T >
struct | Dune::IndexSetSortFunctor< TG, TL >
class | Dune::IndicesSyncer< T >
| Class for recomputing missing indices of a distributed index set. More...
class | Dune::Interface
| Communication interface between remote and local indices. More...
class | Dune::LocalIndex
| An index present on the local process. More...
class | Dune::ParallelLocalIndex< T >
| An index present on the local process with an additional attribute flag. More...
struct | Dune::LocalIndexComparator< ParallelLocalIndex< T > >
class | Dune::MPITraits< ParallelLocalIndex< T > >
class | Dune::MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >
class | Dune::RemoteIndices< T, A >
| The indices present on remote processes. More...
class | Dune::RemoteIndex< T1, T2 >
| Information about an index residing on another processor. More...
class | Dune::RemoteIndexListModifier< T, A, mode >
| Modifier for adding and/or deleting remote indices from the remote index list. More...
class | Dune::CollectiveIterator< T, A >
| A collective iterator for moving over the remote indices for all processes collectively. More...
class | Dune::OwnerOverlapCopyCommunication< T1, T2 >
class | Dune::SelectionIterator< TS, TG, TL, N >
| A const iterator over an uncached selection. More...
class | Dune::UncachedSelection< TS, TG, TL, N >
| An uncached selection of indices. More...
class | Dune::Selection< TS, TG, TL, N >
| A cached selection of indices. More...
class | Dune::VariableSizeCommunicator< Allocator >
| A buffered communicator where the amount of data sent does not have to be known a priori. More...

## Typedefs

typedef TG | Dune::IndexPair< TG, TL >::GlobalIndex
| the type of the global index.
typedef TL | Dune::IndexPair< TG, TL >::LocalIndex
| the type of the local index.
typedef TG | Dune::ParallelIndexSet< TG, TL, N >::GlobalIndex
| the type of the global index. This type has to provide at least a operator< for sorting.
typedef TL | Dune::ParallelIndexSet< TG, TL, N >::LocalIndex
| The type of the local index, e.g. ParallelLocalIndex.
typedef Dune::IndexPair< GlobalIndex, LocalIndex > | Dune::ParallelIndexSet< TG, TL, N >::IndexPair
| The type of the pair stored.
typedef ArrayList< IndexPair, N >::const_iterator | Dune::ParallelIndexSet< TG, TL, N >::const_iterator
| The constant iterator over the pairs.
typedef I | Dune::GlobalLookupIndexSet< I >::ParallelIndexSet
| The type of the index set.
typedef ParallelIndexSet::LocalIndex | Dune::GlobalLookupIndexSet< I >::LocalIndex
| The type of the local index.
typedef ParallelIndexSet::GlobalIndex | Dune::GlobalLookupIndexSet< I >::GlobalIndex
| The type of the global index.
typedef ParallelIndexSet::const_iterator | Dune::GlobalLookupIndexSet< I >::const_iterator
| The iterator over the index pairs.
typedef Dune::IndexPair< typename I::GlobalIndex, typename I::LocalIndex > | Dune::GlobalLookupIndexSet< I >::IndexPair
typedef T | Dune::IndicesSyncer< T >::ParallelIndexSet
| The type of the index set.
typedef ParallelIndexSet::IndexPair | Dune::IndicesSyncer< T >::IndexPair
| The type of the index pair.
typedef ParallelIndexSet::GlobalIndex | Dune::IndicesSyncer< T >::GlobalIndex
| Type of the global index used in the index set.
typedef ParallelIndexSet::LocalIndex::Attribute | Dune::IndicesSyncer< T >::Attribute
| Type of the attribute used in the index set.
typedef Dune::RemoteIndices< ParallelIndexSet > | Dune::IndicesSyncer< T >::RemoteIndices
| Type of the remote indices.

## Enumerations

enum | Dune::ParallelIndexSetState { Dune::GROUND , Dune::RESIZE }
| The states the index set can be in. More...
enum | Dune::LocalIndexState { Dune::VALID , Dune::DELETED }
| The states available for the local indices. More...

## Functions

template<class TG, class TL>
std::ostream & | Dune::operator<< (std::ostream &os, const IndexPair< TG, TL > &pair)
| Print an index pair.
template<class TG, class TL>
bool | Dune::operator== (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | Dune::operator!= (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | Dune::operator< (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | Dune::operator> (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | Dune::operator<= (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | Dune::operator>= (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | Dune::operator== (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | Dune::operator!= (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | Dune::operator< (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | Dune::operator> (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | Dune::operator<= (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | Dune::operator>= (const IndexPair< TG, TL > &a, const TG &b)
| Dune::IndexPair< TG, TL >::IndexPair (const GlobalIndex &global, const LocalIndex &local)
| Constructs a new Pair.
| Dune::IndexPair< TG, TL >::IndexPair ()
| Construct a new Pair.
| Dune::IndexPair< TG, TL >::IndexPair (const GlobalIndex &global)
| Constructs a new Pair.
const GlobalIndex & | Dune::IndexPair< TG, TL >::global () const
| Get the global index.
LocalIndex & | Dune::IndexPair< TG, TL >::local ()
| Get the local index.
const LocalIndex & | Dune::IndexPair< TG, TL >::local () const
| Get the local index.
void | Dune::IndexPair< TG, TL >::setLocal (int index)
| Set the local index.
| Dune::ParallelIndexSet< TG, TL, N >::iterator::iterator (ParallelIndexSet< TG, TL, N > &indexSet, const Father &father)
| Dune::ParallelIndexSet< TG, TL, N >::ParallelIndexSet ()
| Constructor.
const ParallelIndexSetState & | Dune::ParallelIndexSet< TG, TL, N >::state ()
| Get the state the index set is in.
void | Dune::ParallelIndexSet< TG, TL, N >::beginResize ()
| Indicate that the index set is to be resized.
void | Dune::ParallelIndexSet< TG, TL, N >::add (const GlobalIndex &global)
| Add an new index to the set.
void | Dune::ParallelIndexSet< TG, TL, N >::add (const GlobalIndex &global, const LocalIndex &local)
| Add an new index to the set.
void | Dune::ParallelIndexSet< TG, TL, N >::markAsDeleted (const iterator &position)
| Mark an index as deleted.
void | Dune::ParallelIndexSet< TG, TL, N >::endResize ()
| Indicate that the resizing finishes.
IndexPair & | Dune::ParallelIndexSet< TG, TL, N >::operator[] (const GlobalIndex &global)
| Find the index pair with a specific global id.
IndexPair & | Dune::ParallelIndexSet< TG, TL, N >::at (const GlobalIndex &global)
| Find the index pair with a specific global id.
bool | Dune::ParallelIndexSet< TG, TL, N >::exists (const GlobalIndex &global) const
| Find the index pair with a specific global id.
const IndexPair & | Dune::ParallelIndexSet< TG, TL, N >::operator[] (const GlobalIndex &global) const
| Find the index pair with a specific global id.
const IndexPair & | Dune::ParallelIndexSet< TG, TL, N >::at (const GlobalIndex &global) const
| Find the index pair with a specific global id.
iterator | Dune::ParallelIndexSet< TG, TL, N >::begin ()
| Get an iterator over the indices positioned at the first index.
iterator | Dune::ParallelIndexSet< TG, TL, N >::end ()
| Get an iterator over the indices positioned after the last index.
const_iterator | Dune::ParallelIndexSet< TG, TL, N >::begin () const
| Get an iterator over the indices positioned at the first index.
const_iterator | Dune::ParallelIndexSet< TG, TL, N >::end () const
| Get an iterator over the indices positioned after the last index.
void | Dune::ParallelIndexSet< TG, TL, N >::renumberLocal ()
| Renumbers the local index numbers.
int | Dune::ParallelIndexSet< TG, TL, N >::seqNo () const
| Get the internal sequence number.
size_t | Dune::ParallelIndexSet< TG, TL, N >::size () const
| Get the total number (public and nonpublic) indices.
template<class TG, class TL, int N>
std::ostream & | Dune::operator<< (std::ostream &os, const ParallelIndexSet< TG, TL, N > &indexSet)
| Print an index set.
| Dune::GlobalLookupIndexSet< I >::GlobalLookupIndexSet (const ParallelIndexSet &indexset, std::size_t size)
| Constructor.
| Dune::GlobalLookupIndexSet< I >::GlobalLookupIndexSet (const ParallelIndexSet &indexset)
| Constructor.
| Dune::GlobalLookupIndexSet< I >::~GlobalLookupIndexSet ()
| Destructor.
const IndexPair & | Dune::GlobalLookupIndexSet< I >::operator[] (const GlobalIndex &global) const
| Find the index pair with a specific global id.
const IndexPair * | Dune::GlobalLookupIndexSet< I >::pair (const std::size_t &local) const
| Get the index pair corresponding to a local index.
const_iterator | Dune::GlobalLookupIndexSet< I >::begin () const
| Get an iterator over the indices positioned at the first index.
const_iterator | Dune::GlobalLookupIndexSet< I >::end () const
| Get an iterator over the indices positioned after the last index.
int | Dune::GlobalLookupIndexSet< I >::seqNo () const
| Get the internal sequence number.
size_t | Dune::GlobalLookupIndexSet< I >::size () const
| Get the total number (public and nonpublic) indices.
static bool | Dune::LocalIndexComparator< T >::compare (const T &t1, const T &t2)
bool | Dune::IndexSetSortFunctor< TG, TL >::operator() (const IndexPair< TG, TL > &i1, const IndexPair< TG, TL > &i2)
| Dune::IndicesSyncer< T >::IndicesSyncer (ParallelIndexSet &indexSet, RemoteIndices &remoteIndices)
| Constructor.
void | Dune::IndicesSyncer< T >::sync ()
| Sync the index set.
template<typename T1>
void | Dune::IndicesSyncer< T >::sync (T1 &numberer, bool useFixedOrder=false)
| Sync the index set and assign local numbers to new indices.
| Dune::IndicesSyncer< T >::MessageInformation::MessageInformation ()
std::size_t | Dune::IndicesSyncer< T >::DefaultNumberer::operator() (const GlobalIndex &global)
| Provide the local index, always std::numeric_limits<size_t>::max().
| Dune::IndicesSyncer< T >::Iterators::Iterators (RemoteIndexList &remoteIndices, GlobalIndexList &globalIndices, BoolList &booleans)
| Constructor.
| Dune::IndicesSyncer< T >::Iterators::Iterators ()
| Default constructor.
Iterators & | Dune::IndicesSyncer< T >::Iterators::operator++ ()
| Increment all iterators.
void | Dune::IndicesSyncer< T >::Iterators::insert (const RemoteIndex &index, const std::pair< GlobalIndex, Attribute > &global)
| Insert a new remote index to the underlying remote index list.
RemoteIndex & | Dune::IndicesSyncer< T >::Iterators::remoteIndex () const
| Get the remote index at current position.
std::pair< GlobalIndex, Attribute > & | Dune::IndicesSyncer< T >::Iterators::globalIndexPair () const
| Get the global index of the remote index at current position.
Attribute & | Dune::IndicesSyncer< T >::Iterators::attribute () const
bool | Dune::IndicesSyncer< T >::Iterators::isOld () const
| Was this entry already in the remote index list before the sync process?
void | Dune::IndicesSyncer< T >::Iterators::reset (RemoteIndexList &remoteIndices, GlobalIndexList &globalIndices, BoolList &booleans)
| Reset all the underlying iterators.
bool | Dune::IndicesSyncer< T >::Iterators::isNotAtEnd () const
| Are we not at the end of the list?
bool | Dune::IndicesSyncer< T >::Iterators::isAtEnd () const
| Are we at the end of the list?
template<typename TG, typename TA>
bool | Dune::operator< (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
template<typename TG, typename TA>
bool | Dune::operator< (const std::pair< TG, TA > &i1, const IndexPair< TG, ParallelLocalIndex< TA > > &i2)
template<typename TG, typename TA>
bool | Dune::operator== (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
template<typename TG, typename TA>
bool | Dune::operator!= (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
template<typename TG, typename TA>
bool | Dune::operator== (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
template<typename TG, typename TA>
bool | Dune::operator!= (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
template<typename T, typename A, typename A1>
void | Dune::storeGlobalIndicesOfRemoteIndices (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, const RemoteIndices< T, A1 > &remoteIndices)
| Stores the corresponding global indices of the remote index information.
template<typename T, typename A, typename A1>
void | Dune::repairLocalIndexPointers (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, RemoteIndices< T, A1 > &remoteIndices, const T &indexSet)
| Repair the pointers to the local indices in the remote indices.
template<class T>
std::ostream & | Dune::operator<< (std::ostream &os, const ParallelLocalIndex< T > &index)
| Print the local index to a stream.
template<typename T>
bool | Dune::operator== (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
template<typename T>
bool | Dune::operator!= (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
template<typename T1, typename T2>
std::ostream & | Dune::operator<< (std::ostream &os, const RemoteIndex< T1, T2 > &index)
template<class T, class A>
std::ostream & | Dune::operator<< (std::ostream &os, const RemoteIndices< T, A > &indices)
template<typename TG, typename TA>
std::ostream & | Dune::operator<< (std::ostream &os, const RemoteIndex< TG, TA > &index)
template<class R, class T1, class T2, class Op, bool send>
void | Dune::InterfaceBuilder::buildInterface (const R &remoteIndices, const T1 &sourceFlags, const T2 &destFlags, Op &functor) const
| Builds the interface between remote processes.
MPI_Comm | Dune::Interface::communicator () const
| Get the MPI Communicator.
const InformationMap & | Dune::Interface::interfaces () const
| Get information about the interfaces.
InformationMap & | Dune::Interface::interfaces ()
| Get information about the interfaces.
void | Dune::Interface::print () const
| Print the interface to std::out for debugging.
template<typename R, typename T1, typename T2>
void | Dune::Interface::build (const R &remoteIndices, const T1 &sourceFlags, const T2 &destFlags)
| Builds the interface.
void | Dune::Interface::strip ()
void | Dune::Interface::free ()
| Frees memory allocated during the build.
virtual | Dune::Interface::~Interface ()
| Destructor.
const std::size_t & | Dune::LocalIndex::local () const
| get the local index.
| Dune::LocalIndex::operator std::size_t () const
| Convert to the local index represented by an int.
LocalIndex & | Dune::LocalIndex::operator= (std::size_t index)
| Assign a new local index.
LocalIndexState | Dune::LocalIndex::state () const
| Get the state.
void | Dune::LocalIndex::setState (LocalIndexState state)
| Set the state.
| Dune::ParallelLocalIndex< T >::ParallelLocalIndex (const Attribute &attribute, bool isPublic)
| Constructor.
| Dune::ParallelLocalIndex< T >::ParallelLocalIndex (size_t localIndex, const Attribute &attribute, bool isPublic=true)
| Constructor.
| Dune::ParallelLocalIndex< T >::ParallelLocalIndex ()
| Parameterless constructor.
const Attribute | Dune::ParallelLocalIndex< T >::attribute () const
| Get the attribute of the index.
void | Dune::ParallelLocalIndex< T >::setAttribute (const Attribute &attribute)
| Set the attribute of the index.
size_t | Dune::ParallelLocalIndex< T >::local () const
| get the local index.
| Dune::ParallelLocalIndex< T >::operator size_t () const
| Convert to the local index represented by an int.
ParallelLocalIndex< Attribute > & | Dune::ParallelLocalIndex< T >::operator= (size_t index)
| Assign a new local index.
bool | Dune::ParallelLocalIndex< T >::isPublic () const
| Check whether the index might also be known other processes.
LocalIndexState | Dune::ParallelLocalIndex< T >::state () const
| Get the state.
void | Dune::ParallelLocalIndex< T >::setState (const LocalIndexState &state)
| Set the state.
static MPI_Datatype | Dune::MPITraits< ParallelLocalIndex< T > >::getType ()
static MPI_Datatype | Dune::MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >::getType ()
| Dune::RemoteIndex< T1, T2 >::RemoteIndex (const T2 &attribute, const PairType *local)
| Constructor.
| Dune::RemoteIndex< T1, T2 >::RemoteIndex (const T2 &attribute)
| Constructor. Private as it should only be called from within Indexset.
| Dune::RemoteIndex< T1, T2 >::RemoteIndex ()
| Parameterless Constructor.
bool | Dune::RemoteIndex< T1, T2 >::operator== (const RemoteIndex &ri) const
bool | Dune::RemoteIndex< T1, T2 >::operator!= (const RemoteIndex &ri) const
const Attribute | Dune::RemoteIndex< T1, T2 >::attribute () const
| Get the attribute of the index on the remote process.
const PairType & | Dune::RemoteIndex< T1, T2 >::localIndexPair () const
| Get the corresponding local index pair.
| Dune::RemoteIndices< T, A >::RemoteIndices (const ParallelIndexSet &source, const ParallelIndexSet &destination, const MPI_Comm &comm, const std::vector< int > &neighbours=std::vector< int >(), bool includeSelf=false)
| Constructor.
void | Dune::RemoteIndices< T, A >::setIncludeSelf (bool includeSelf)
| Tell whether sending from indices of the processor to other indices on the same processor is enabled even if the same indexset is used on both the sending and receiving side.
| Dune::RemoteIndices< T, A >::RemoteIndices ()
void | Dune::RemoteIndices< T, A >::setIndexSets (const ParallelIndexSet &source, const ParallelIndexSet &destination, const MPI_Comm &comm, const std::vector< int > &neighbours=std::vector< int >())
| Set the index sets and communicator we work with.
const ParallelIndexSet & | Dune::RemoteIndices< T, A >::sourceIndexSet () const
| Get the index set at the source.
const ParallelIndexSet & | Dune::RemoteIndices< T, A >::destinationIndexSet () const
| Get the index set at destination.
| Dune::RemoteIndices< T, A >::~RemoteIndices ()
| Destructor.
template<bool ignorePublic>
void | Dune::RemoteIndices< T, A >::packEntries (IndexPair< GlobalIndex, LocalIndex > **pairs, const ParallelIndexSet &indexSet, char *p_out, MPI_Datatype type, int bufferSize, int *position, int n)
void | Dune::RemoteIndices< T, A >::free ()
| Free the index lists.
int | Dune::RemoteIndices< T, A >::neighbours () const
| Get the number of processors we share indices with.
template<bool ignorePublic>
void | Dune::RemoteIndices< T, A >::rebuild ()
| Rebuilds the set of remote indices.
bool | Dune::RemoteIndices< T, A >::isSynced () const
| Checks whether the remote indices are synced with the indexsets.
template<bool mode, bool send>
RemoteIndexListModifier< T, A, mode > | Dune::RemoteIndices< T, A >::getModifier (int process)
| Get a modifier for a remote index list.
const_iterator | Dune::RemoteIndices< T, A >::find (int proc) const
| Find an iterator over the remote index lists of a specific process.
const_iterator | Dune::RemoteIndices< T, A >::begin () const
| Get an iterator over all remote index lists.
const_iterator | Dune::RemoteIndices< T, A >::end () const
| Get an iterator over all remote index lists.
bool | Dune::RemoteIndices< T, A >::operator== (const RemoteIndices &ri) const
| Dune::RemoteIndexListModifier< T, A, mode >::RemoteIndexListModifier (const RemoteIndexListModifier &)
void | Dune::RemoteIndexListModifier< T, A, mode >::repairLocalIndexPointers ()
| Repair the pointers to the local index pairs.
void | Dune::RemoteIndexListModifier< T, A, mode >::insert (const RemoteIndex &index)
| Insert an index to the list.
void | Dune::RemoteIndexListModifier< T, A, mode >::insert (const RemoteIndex &index, const GlobalIndex &global)
| Insert an index to the list.
bool | Dune::RemoteIndexListModifier< T, A, mode >::remove (const GlobalIndex &global)
| Remove a remote index.
template<bool send>
CollectiveIteratorT | Dune::RemoteIndices< T, A >::iterator () const
| Get an iterator for collectively iterating over the remote indices of all remote processes.
MPI_Comm | Dune::RemoteIndices< T, A >::communicator () const
| Get the mpi communicator used.
| Dune::CollectiveIterator< T, A >::CollectiveIterator (const RemoteIndexMap &map_, bool send)
| Constructor.
void | Dune::CollectiveIterator< T, A >::advance (const GlobalIndex &global)
| Advances all underlying iterators.
void | Dune::CollectiveIterator< T, A >::advance (const GlobalIndex &global, const Attribute &attribute)
| Advances all underlying iterators.
CollectiveIterator & | Dune::CollectiveIterator< T, A >::operator++ ()
bool | Dune::CollectiveIterator< T, A >::empty () const
| Checks whether there are still iterators in the map.
iterator | Dune::CollectiveIterator< T, A >::begin ()
iterator | Dune::CollectiveIterator< T, A >::end ()
void | Dune::Selection< TS, TG, TL, N >::setIndexSet (const ParallelIndexSet &indexset)
| Set the index set of the selection.
const_iterator | Dune::Selection< TS, TG, TL, N >::begin () const
| Get the index set we are a selection for.
const_iterator | Dune::Selection< TS, TG, TL, N >::end () const
| Get an iterator over the selected indices.
void | Dune::Selection< TS, TG, TL, N >::free ()
| Free allocated memory.
| Dune::Selection< TS, TG, TL, N >::~Selection ()
const_iterator | Dune::UncachedSelection< TS, TG, TL, N >::begin () const
| Get the index set we are a selection for.
const_iterator | Dune::UncachedSelection< TS, TG, TL, N >::end () const
| Get an iterator over the selected indices.
void | Dune::UncachedSelection< TS, TG, TL, N >::setIndexSet (const ParallelIndexSet &indexset)
| Set the index set of the selection.

## Variables

static constexpr int | Dune::ParallelIndexSet< TG, TL, N >::arraySize = (N>0) ? N : 1
| The size of the individual arrays in the underlying ArrayList.
int | Dune::IndicesSyncer< T >::MessageInformation::publish
| The number of indices we publish for the other process.
int | Dune::IndicesSyncer< T >::MessageInformation::pairs
| The number of pairs (attribute and process number) we publish to the neighbour process.
template<typename T>
MPI_Datatype | Dune::MPITraits< ParallelLocalIndex< T > >::type = MPI_DATATYPE_NULL
template<typename TG, typename TA>
MPI_Datatype | Dune::MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >::type =MPI_DATATYPE_NULL

## Friends

struct | Dune::IndexPair< TG, TL >::MPITraits< IndexPair< TG, TL > >
class | Dune::ParallelIndexSet< TG, TL, N >::GlobalLookupIndexSet< ParallelIndexSet< TG, TL, N > >
class | Dune::ParallelIndexSet< TG, TL, N >::iterator::ParallelIndexSet< GlobalIndex, LocalIndex, N >
class | Dune::IndicesSyncer< T >::Iterators::IndicesSyncer< T >
std::ostream & | Dune::IndexPair< TG, TL >::operator<< (std::ostream &os, const IndexPair< TG, TL > &pair)
| Print an index pair.
bool | Dune::IndexPair< TG, TL >::operator== (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
bool | Dune::IndexPair< TG, TL >::operator!= (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
bool | Dune::IndexPair< TG, TL >::operator< (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
bool | Dune::IndexPair< TG, TL >::operator> (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
bool | Dune::IndexPair< TG, TL >::operator<= (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
bool | Dune::IndexPair< TG, TL >::operator>= (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
bool | Dune::IndexPair< TG, TL >::operator== (const IndexPair< TG, TL > &a, const TG &b)
bool | Dune::IndexPair< TG, TL >::operator!= (const IndexPair< TG, TL > &a, const TG &b)
bool | Dune::IndexPair< TG, TL >::operator< (const IndexPair< TG, TL > &a, const TG &b)
bool | Dune::IndexPair< TG, TL >::operator> (const IndexPair< TG, TL > &a, const TG &b)
bool | Dune::IndexPair< TG, TL >::operator<= (const IndexPair< TG, TL > &a, const TG &b)
bool | Dune::IndexPair< TG, TL >::operator>= (const IndexPair< TG, TL > &a, const TG &b)

## Detailed Description

Provides classes for syncing distributed indexed data structures.

In a parallel representation a container , e.g. a plain C-array, cannot be stored with all entries on each process because of limited memory and efficiency reasons. Therefore it is represented by individual pieces , , where is the piece stored on process of the processes participating in the calculation. Although the global representation of the container is not available on any process, a process needs to know how the entries of it's local piece correspond to the entries of the global container , which would be used in a sequential program. In this module we present classes describing the mapping of the local pieces to the global view and the communication interfaces.

# Parallel Index Sets

Form an abstract point of view a random access container provides a mapping from an index set onto a set of objects . Note that we do not require to be consecutive. The piece of the container stored on process is a mapping , where . Due to efficiency the entries of should be stored in consecutive memory.

This means that for the local computation the data must be addressable by a consecutive index starting from . When using adaptive discretisation methods there might be the need to reorder the indices after adding and/or deleting some of the discretisation points. Therefore this index does not have to be persistent. Further on we will call this index local index.

For the communication phases of our algorithms these locally stored entries must also be addressable by a global identifier to be able to store the received values tagged with the global identifiers at the correct local index in the consecutive local memory chunk. To ease the addition and removal of discretisation points this global identifier has to be persistent. Further on we will call this global identifier global index.

Classes to build the mapping are ParallelIndexSet and ParallelLocalIndex. As these just provide a mapping from the global index to the local index, the wrapper class GlobalLookupIndexSet facilitates the reverse lookup.

# Remote Index Information

To setup communication between the processes every process needs to know what indices are also known to other processes and what attributes are attached to them on the remote side. This information is calculated and encapsulated in class RemoteIndices.

# Communication

Based on the information about the distributed index sets, data independent interfaces between different sets of the index sets can be setup using the class Interface. For the actual communication data dependent communicators can be setup using BufferedCommunicator, DatatypeCommunicator VariableSizeCommunicator based on the interface information. In contrast to the former the latter is independent of the class Interface which can work on a map from process number to a pair of index lists describing which local indices are sent and received from that process.

## Typedef Documentation

## Attribute

template<typename T>

typedef ParallelIndexSet::LocalIndex::Attribute Dune::IndicesSyncer< T >::Attribute

Type of the attribute used in the index set.

## const_iterator [1/2]

template<class I>

typedef ParallelIndexSet::const_iterator Dune::GlobalLookupIndexSet< I >::const_iterator

The iterator over the index pairs.

## const_iterator [2/2]

template<typename TG, typename TL, int N = 100>

typedef ArrayList<IndexPair,N>::const_iterator Dune::ParallelIndexSet< TG, TL, N >::const_iterator

The constant iterator over the pairs.

## GlobalIndex [1/4]

template<class I>

typedef ParallelIndexSet::GlobalIndex Dune::GlobalLookupIndexSet< I >::GlobalIndex

The type of the global index.

## GlobalIndex [2/4]

template<class TG, class TL>

typedef TG Dune::IndexPair< TG, TL >::GlobalIndex

the type of the global index.

This type has to provide at least a operator< for sorting.

## GlobalIndex [3/4]

template<typename T>

typedef ParallelIndexSet::GlobalIndex Dune::IndicesSyncer< T >::GlobalIndex

Type of the global index used in the index set.

## GlobalIndex [4/4]

template<typename TG, typename TL, int N = 100>

typedef TG Dune::ParallelIndexSet< TG, TL, N >::GlobalIndex

the type of the global index. This type has to provide at least a operator< for sorting.

## IndexPair [1/3]

template<class I>

typedef Dune::IndexPair<typename I::GlobalIndex, typename I::LocalIndex> Dune::GlobalLookupIndexSet< I >::IndexPair

## IndexPair [2/3]

template<typename T>

typedef ParallelIndexSet::IndexPair Dune::IndicesSyncer< T >::IndexPair

The type of the index pair.

## IndexPair [3/3]

template<typename TG, typename TL, int N = 100>

typedef Dune::IndexPair<GlobalIndex,LocalIndex> Dune::ParallelIndexSet< TG, TL, N >::IndexPair

The type of the pair stored.

## LocalIndex [1/3]

template<class I>

typedef ParallelIndexSet::LocalIndex Dune::GlobalLookupIndexSet< I >::LocalIndex

The type of the local index.

## LocalIndex [2/3]

template<class TG, class TL>

typedef TL Dune::IndexPair< TG, TL >::LocalIndex

the type of the local index.

This class to provide the following functions:

LocalIndex operator=(int);
operator int() const;
LocalIndexState state() const;
void setState(LocalIndexState);
Dune::IndexPair::LocalIndex
TL LocalIndex
the type of the local index.
Definition indexset.hh:120
Dune::LocalIndexState
LocalIndexState
The states available for the local indices.
Definition localindex.hh:28

## LocalIndex [3/3]

template<typename TG, typename TL, int N = 100>

typedef TL Dune::ParallelIndexSet< TG, TL, N >::LocalIndex

The type of the local index, e.g. ParallelLocalIndex.

This class to provide the following functions:

LocalIndex operator=(int);
operator int() const;
LocalIndexState state() const;
void setState(LocalIndexState);
Dune::ParallelIndexSet::state
const ParallelIndexSetState & state()
Get the state the index set is in.
Definition indexset.hh:307
Dune::ParallelIndexSet::LocalIndex
TL LocalIndex
The type of the local index, e.g. ParallelLocalIndex.
Definition indexset.hh:239

## ParallelIndexSet [1/2]

template<class I>

typedef I Dune::GlobalLookupIndexSet< I >::ParallelIndexSet

The type of the index set.

## ParallelIndexSet [2/2]

template<typename T>

typedef T Dune::IndicesSyncer< T >::ParallelIndexSet

The type of the index set.

## RemoteIndices

template<typename T>

typedef Dune::RemoteIndices<ParallelIndexSet> Dune::IndicesSyncer< T >::RemoteIndices

Type of the remote indices.

## Enumeration Type Documentation

## LocalIndexState

enum Dune::LocalIndexState

The states available for the local indices.

See also
  LocalIndex::state()

Enumerator
VALID |
DELETED |

## ParallelIndexSetState

enum Dune::ParallelIndexSetState

The states the index set can be in.

See also
  ParallelIndexSet::state_

Enumerator
GROUND | The default mode. Indicates that the index set is ready to be used.
RESIZE | Indicates that the index set is currently being resized. Indicates that all previously deleted indices are now deleted. CLEAN, Indicates that the index set is currently being reordered. REORDER

## Function Documentation

## add() [1/2]

template<typename TG, typename TL, int N = 100>

void Dune::ParallelIndexSet< TG, TL, N >::add | ( | const GlobalIndex & | global | ) |

inline

Add an new index to the set.

The local index is created by the default constructor.

Parameters

  global | The globally unique id of the index.

Exceptions

  InvalidState | If index set is not in ParallelIndexSetState::RESIZE mode.

## add() [2/2]

template<typename TG, typename TL, int N = 100>

void Dune::ParallelIndexSet< TG, TL, N >::add | ( | const GlobalIndex & | global,
|  | const LocalIndex & | local )

inline

Add an new index to the set.

Parameters

  global | The globally unique id of the index.
  local | The local index.

Exceptions

  InvalidState | If index set is not in ParallelIndexSetState::RESIZE mode.

## advance() [1/2]

template<typename T, typename A>

void Dune::CollectiveIterator< T, A >::advance | ( | const GlobalIndex & | global | ) |

inline

Advances all underlying iterators.

All iterators are advanced until they point to a remote index whose global id is bigger or equal to global. Iterators pointing to their end are removed.

Parameters

  global | The index we search for.

## advance() [2/2]

template<typename T, typename A>

void Dune::CollectiveIterator< T, A >::advance | ( | const GlobalIndex & | global,
|  | const Attribute & | attribute )

inline

Advances all underlying iterators.

All iterators are advanced until they point to a remote index whose global id is bigger or equal to global. Iterators pointing to their end are removed.

Parameters

  global | The index we search for.
  attribute | The attribute we search for.

## at() [1/2]

template<typename TG, typename TL, int N = 100>

IndexPair & Dune::ParallelIndexSet< TG, TL, N >::at | ( | const GlobalIndex & | global | ) |

inline

Find the index pair with a specific global id.

This starts a binary search for the entry and therefore has complexity log(N).

Parameters

  global | The globally unique id of the pair.

Returns
  The pair of indices for the id.

Exceptions

  RangeError | Thrown if the global id is not known.

## at() [2/2]

template<typename TG, typename TL, int N = 100>

const IndexPair & Dune::ParallelIndexSet< TG, TL, N >::at | ( | const GlobalIndex & | global | ) | const

inline

Find the index pair with a specific global id.

This starts a binary search for the entry and therefore has complexity log(N).

Parameters

  global | The globally unique id of the pair.

Returns
  The pair of indices for the id.

Exceptions

  RangeError | Thrown if the global id is not known.

## attribute() [1/3]

template<typename T>

Attribute & Dune::IndicesSyncer< T >::Iterators::attribute | ( |  | ) | const

## attribute() [2/3]

template<class T>

const T Dune::ParallelLocalIndex< T >::attribute | ( |  | ) | const

inline

Get the attribute of the index.

Returns
  The associated attribute.

## attribute() [3/3]

template<typename T1, typename T2>

const T2 Dune::RemoteIndex< T1, T2 >::attribute | ( |  | ) | const

inline

Get the attribute of the index on the remote process.

Returns
  The remote attribute.

## begin() [1/7]

template<typename T, typename A>

CollectiveIterator< T, A >::iterator Dune::CollectiveIterator< T, A >::begin | ( |  | ) |

inline

## begin() [2/7]

template<class I>

const_iterator Dune::GlobalLookupIndexSet< I >::begin | ( |  | ) | const

inline

Get an iterator over the indices positioned at the first index.

Returns
  Iterator over the local indices.

## begin() [3/7]

template<typename TG, typename TL, int N = 100>

iterator Dune::ParallelIndexSet< TG, TL, N >::begin | ( |  | ) |

inline

Get an iterator over the indices positioned at the first index.

Returns
  Iterator over the local indices.

## begin() [4/7]

template<typename TG, typename TL, int N = 100>

const_iterator Dune::ParallelIndexSet< TG, TL, N >::begin | ( |  | ) | const

inline

Get an iterator over the indices positioned at the first index.

Returns
  Iterator over the local indices.

## begin() [5/7]

template<typename T, typename A>

RemoteIndices< T, A >::const_iterator Dune::RemoteIndices< T, A >::begin | ( |  | ) | const

inline

Get an iterator over all remote index lists.

Returns
  The iterator over all remote index lists positioned at the first process.

## begin() [6/7]

template<typename TS, typename TG, typename TL, int N>

uint32_t * Dune::Selection< TS, TG, TL, N >::begin | ( |  | ) | const

Get the index set we are a selection for.

Get an iterator over the selected indices.

Returns
  An iterator positioned at the first selected index.

## begin() [7/7]

template<typename TS, typename TG, typename TL, int N>

SelectionIterator< TS, TG, TL, N > Dune::UncachedSelection< TS, TG, TL, N >::begin | ( |  | ) | const

Get the index set we are a selection for.

Get an iterator over the selected indices.

Returns
  An iterator positioned at the first selected index.

## beginResize()

template<typename TG, typename TL, int N = 100>

void Dune::ParallelIndexSet< TG, TL, N >::beginResize | ( |  | ) |

Indicate that the index set is to be resized.

Exceptions

  InvalidState | If index set was not in ParallelIndexSetState::GROUND mode.

## build()

template<typename R, typename T1, typename T2>

void Dune::Interface::build | ( | const R & | remoteIndices,
|  | const T1 & | sourceFlags,
|  | const T2 & | destFlags )

inline

Builds the interface.

The types T1 and T2 are classes representing a set of enumeration values of type Interface::Attribute. They have to provide a (static) method

bool contains(Attribute flag) const;
Dune::contains
constexpr std::bool_constant<((II==value)||...)> contains(std::integer_sequence< T, II... >, std::integral_constant< T, value >)
Checks whether or not a given sequence contains a value.
Definition integersequence.hh:137

for checking whether the set contains a specific flag. This functionality is for example provided the classes EnumItem, EnumRange and Combine.

Parameters

  remoteIndices | The indices known to remote processes.
  sourceFlags | The set of flags marking indices we send from.
  destFlags | The set of flags marking indices we receive for.

## buildInterface()

template<class R, class T1, class T2, class Op, bool send>

void Dune::InterfaceBuilder::buildInterface | ( | const R & | remoteIndices,
|  | const T1 & | sourceFlags,
|  | const T2 & | destFlags,
|  | Op & | functor ) const

protected

Builds the interface between remote processes.

The types T1 and T2 are classes representing a set of enumeration values of type InterfaceBuilder::Attribute. They have to provide a (static) method

bool contains(Attribute flag) const;

for checking whether the set contains a specific flag. This functionality is for example provided the classes EnumItem, EnumRange and Combine.

If the template parameter send is true the sending side of the interface will be built, otherwise the information for receiving will be built.

If the template parameter send is true we create interface for sending in a forward communication.

Parameters

  remoteIndices | The indices known to remote processes.
  sourceFlags | The set of flags marking source indices.
  destFlags | The setof flags markig destination indices.

  functor

  A functor for callbacks. It should provide the following methods:
  // Reserve memory for the interface to processor proc. The interface
  // has to hold size entries
  void reserve(int proc, int size);
  // Add an entry to the interface
  // We will send/receive size entries at index local to process proc
  void add(int proc, int local);
  Dune::size
  constexpr std::integral_constant< std::size_t, sizeof...(II)> size(std::integer_sequence< T, II... >)
  Return the size of the sequence.
  Definition integersequence.hh:75

## CollectiveIterator()

template<typename T, typename A>

Dune::CollectiveIterator< T, A >::CollectiveIterator | ( | const RemoteIndexMap & | map_,
|  | bool | send )

inline

Constructor.

Parameters

  map_ | The map of the remote indices.
  send | True if we want iterate over the remote indices used for sending.

## communicator() [1/2]

MPI_Comm Dune::Interface::communicator | ( |  | ) | const

inline

Get the MPI Communicator.

## communicator() [2/2]

template<typename T, typename A>

MPI_Comm Dune::RemoteIndices< T, A >::communicator | ( |  | ) | const

inline

Get the mpi communicator used.

## compare()

template<typename T>

bool Dune::LocalIndexComparator< T >::compare | ( | const T & | t1,
|  | const T & | t2 )

inline static

## destinationIndexSet()

template<typename T, typename A>

const RemoteIndices< T, A >::ParallelIndexSet & Dune::RemoteIndices< T, A >::destinationIndexSet | ( |  | ) | const

inline

Get the index set at destination.

## empty()

template<typename T, typename A>

bool Dune::CollectiveIterator< T, A >::empty | ( |  | ) | const

inline

Checks whether there are still iterators in the map.

## end() [1/7]

template<typename T, typename A>

CollectiveIterator< T, A >::iterator Dune::CollectiveIterator< T, A >::end | ( |  | ) |

inline

## end() [2/7]

template<class I>

const_iterator Dune::GlobalLookupIndexSet< I >::end | ( |  | ) | const

inline

Get an iterator over the indices positioned after the last index.

Returns
  Iterator over the local indices.

## end() [3/7]

template<typename TG, typename TL, int N = 100>

iterator Dune::ParallelIndexSet< TG, TL, N >::end | ( |  | ) |

inline

Get an iterator over the indices positioned after the last index.

Returns
  Iterator over the local indices.

## end() [4/7]

template<typename TG, typename TL, int N = 100>

const_iterator Dune::ParallelIndexSet< TG, TL, N >::end | ( |  | ) | const

inline

Get an iterator over the indices positioned after the last index.

Returns
  Iterator over the local indices.

## end() [5/7]

template<typename T, typename A>

RemoteIndices< T, A >::const_iterator Dune::RemoteIndices< T, A >::end | ( |  | ) | const

inline

Get an iterator over all remote index lists.

Returns
  The iterator over all remote index lists positioned at the end.

## end() [6/7]

template<typename TS, typename TG, typename TL, int N>

uint32_t * Dune::Selection< TS, TG, TL, N >::end | ( |  | ) | const

Get an iterator over the selected indices.

Returns
  An iterator positioned at the first selected index.

## end() [7/7]

template<typename TS, typename TG, typename TL, int N>

SelectionIterator< TS, TG, TL, N > Dune::UncachedSelection< TS, TG, TL, N >::end | ( |  | ) | const

Get an iterator over the selected indices.

Returns
  An iterator positioned at the first selected index.

## endResize()

template<typename TG, typename TL, int N = 100>

void Dune::ParallelIndexSet< TG, TL, N >::endResize | ( |  | ) |

Indicate that the resizing finishes.

Warning
  Invalidates all pointers stored to the elements of this index set. The local indices will be ordered according to the global indices: Let be the set of all indices then if and only if for arbitrary .

Exceptions

  InvalidState | If index set was not in ParallelIndexSetState::RESIZE mode.

## exists()

template<typename TG, typename TL, int N = 100>

bool Dune::ParallelIndexSet< TG, TL, N >::exists | ( | const GlobalIndex & | global | ) | const

inline

Find the index pair with a specific global id.

This starts a binary search for the entry and therefore has complexity log(N).

Parameters

  global | The globally unique id of the pair.

Returns
  The pair of indices for the id.

Exceptions

  RangeError | Thrown if the global id is not known.

## find()

template<typename T, typename A>

RemoteIndices< T, A >::const_iterator Dune::RemoteIndices< T, A >::find | ( | int | proc | ) | const

inline

Find an iterator over the remote index lists of a specific process.

Parameters

  proc | The identifier of the process.

Returns
  The iterator the remote index lists positioned at the process. If there's is no list for this process, the end iterator is returned.

## free() [1/3]

void Dune::Interface::free | ( |  | ) |

inline

Frees memory allocated during the build.

## free() [2/3]

template<typename T, typename A>

void Dune::RemoteIndices< T, A >::free | ( |  | ) |

inline

Free the index lists.

## free() [3/3]

template<typename TS, typename TG, typename TL, int N>

void Dune::Selection< TS, TG, TL, N >::free | ( |  | ) |

inline

Free allocated memory.

## getModifier()

template<typename T, typename A>
template<bool mode, bool send>

RemoteIndexListModifier< T, A, mode > Dune::RemoteIndices< T, A >::getModifier | ( | int | process | ) |

inline

Get a modifier for a remote index list.

Sometimes the user knows in advance which indices will be present on other processors, too. Then he can set them up using this modifier.

Warning
  Use with care. If the remote index list is inconsistent after the modification the communication might result in a dead lock!

Template Parameters

  mode | If true the index set corresponding to the remote indices might get modified. Therefore the internal pointers to the indices need to be repaired.
  send | If true the remote index information at the sending side will be modified, if false the receiving side.

## getType() [1/2]

template<typename TG, typename TA>

MPI_Datatype Dune::MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >::getType | ( |  | ) |

inline static

## getType() [2/2]

template<typename T>

MPI_Datatype Dune::MPITraits< ParallelLocalIndex< T > >::getType | ( |  | ) |

static

## global()

template<class TG, class TL>

const GlobalIndex & Dune::IndexPair< TG, TL >::global | ( |  | ) | const

inline

Get the global index.

Returns
  The global index.

## globalIndexPair()

template<typename T>

std::pair< typename IndicesSyncer< T >::GlobalIndex, typename IndicesSyncer< T >::Attribute > & Dune::IndicesSyncer< T >::Iterators::globalIndexPair | ( |  | ) | const

inline

Get the global index of the remote index at current position.

Returns
  The current global index.

## GlobalLookupIndexSet() [1/2]

template<class I>

Dune::GlobalLookupIndexSet< I >::GlobalLookupIndexSet | ( | const ParallelIndexSet & | indexset | ) |

Constructor.

Parameters

  indexset | The index set we want to be able to lookup the corresponding global index of a local index.

## GlobalLookupIndexSet() [2/2]

template<class I>

Dune::GlobalLookupIndexSet< I >::GlobalLookupIndexSet | ( | const ParallelIndexSet & | indexset,
|  | std::size_t | size )

Constructor.

Parameters

  indexset | The index set we want to be able to lookup the corresponding global index of a local index.
  size | The number of indices present, i.e. one more than the maximum local index.

## IndexPair() [1/3]

template<class TG, class TL>

Dune::IndexPair< TG, TL >::IndexPair | ( |  | ) |

Construct a new Pair.

## IndexPair() [2/3]

template<class TG, class TL>

Dune::IndexPair< TG, TL >::IndexPair | ( | const GlobalIndex & | global | ) |

Constructs a new Pair.

The local index will be 0.

Parameters

  global | The global index.

## IndexPair() [3/3]

template<class TG, class TL>

Dune::IndexPair< TG, TL >::IndexPair | ( | const GlobalIndex & | global,
|  | const LocalIndex & | local )

Constructs a new Pair.

Parameters

  global | The global index.
  local | The local index.

## IndicesSyncer()

template<typename T>

Dune::IndicesSyncer< T >::IndicesSyncer | ( | ParallelIndexSet & | indexSet,
|  | RemoteIndices & | remoteIndices )

Constructor.

The source as well as the target index set of the remote indices have to be the same as the provided index set.

Parameters

  indexSet | The index set with the information of the locally present indices.
  remoteIndices | The remoteIndices.

## insert() [1/3]

template<typename T>

void Dune::IndicesSyncer< T >::Iterators::insert | ( | const RemoteIndex & | index,
|  | const std::pair< GlobalIndex, Attribute > & | global )

inline

Insert a new remote index to the underlying remote index list.

Parameters

  index | The remote index.
  global | The global index corresponding to the remote index.

## insert() [2/3]

template<typename T, typename A, bool mode>

void Dune::RemoteIndexListModifier< T, A, mode >::insert | ( | const RemoteIndex & | index | ) |

inline

Insert an index to the list.

Moves to the position where the index fits and inserts it. After the insertion only indices with an bigger global index than the inserted can be inserted.

This method is only available if MODIFYINDEXSET is false.

Parameters

  index | The index to insert.

Exceptions

  InvalidPosition | Thrown if the index at the current position or the one before has bigger global index than the one to be inserted.

## insert() [3/3]

template<typename T, typename A, bool mode>

void Dune::RemoteIndexListModifier< T, A, mode >::insert | ( | const RemoteIndex & | index,
|  | const GlobalIndex & | global )

inline

Insert an index to the list.

Moves to the position where the index fits and inserts it. After the insertion only indices with an bigger global index than the inserted can be inserted.

This method is only available if MODIFYINDEXSET is true.

Parameters

  index | The index to insert.
  global | The global index of the remote index.

Exceptions

  InvalidPosition | Thrown if the index at the current position or the one before has bigger global index than the one to be inserted.

## interfaces() [1/2]

std::map< int, std::pair< InterfaceInformation, InterfaceInformation > > & Dune::Interface::interfaces | ( |  | ) |

inline protected

Get information about the interfaces.

Returns
  Map of the interfaces. The key of the map is the process number and the value is the information pair (first the send and then the receive information).

## interfaces() [2/2]

const std::map< int, std::pair< InterfaceInformation, InterfaceInformation > > & Dune::Interface::interfaces | ( |  | ) | const

inline

Get information about the interfaces.

Returns
  Map of the interfaces. The key of the map is the process number and the value is the information pair (first the send and then the receive information).

## isAtEnd()

template<typename T>

bool Dune::IndicesSyncer< T >::Iterators::isAtEnd | ( |  | ) | const

inline

Are we at the end of the list?

Returns
  True if the iterators are positioned at the end of the list and the tail of the list respectively.

## isNotAtEnd()

template<typename T>

bool Dune::IndicesSyncer< T >::Iterators::isNotAtEnd | ( |  | ) | const

inline

Are we not at the end of the list?

Returns
  True if the iterators are not positioned at the end of the list and the tail of the list respectively.

## isOld()

template<typename T>

bool Dune::IndicesSyncer< T >::Iterators::isOld | ( |  | ) | const

inline

Was this entry already in the remote index list before the sync process?

Returns
  True if the current index wasalready in the remote index list before the sync process.

## isPublic()

template<class T>

bool Dune::ParallelLocalIndex< T >::isPublic | ( |  | ) | const

inline

Check whether the index might also be known other processes.

Returns
  True if the index might be known to other processors.

## isSynced()

template<typename T, typename A>

bool Dune::RemoteIndices< T, A >::isSynced | ( |  | ) | const

inline

Checks whether the remote indices are synced with the indexsets.

If they are not synced the remote indices need to be rebuild.

Returns
  True if they are synced.

## iterator() [1/2]

template<typename TG, typename TL, int N = 100>

Dune::ParallelIndexSet< TG, TL, N >::iterator::iterator | ( | ParallelIndexSet< TG, TL, N > & | indexSet,
|  | const Father & | father )

inline

## iterator() [2/2]

template<typename T, typename A>
template<bool send>

RemoteIndices< T, A >::CollectiveIteratorT Dune::RemoteIndices< T, A >::iterator | ( |  | ) | const

inline

Get an iterator for collectively iterating over the remote indices of all remote processes.

## Iterators() [1/2]

template<typename T>

Dune::IndicesSyncer< T >::Iterators::Iterators | ( |  | ) |

Default constructor.

## Iterators() [2/2]

template<typename T>

Dune::IndicesSyncer< T >::Iterators::Iterators | ( | RemoteIndexList & | remoteIndices,
|  | GlobalIndexList & | globalIndices,
|  | BoolList & | booleans )

Constructor.

Initializes all iterator to first entry and the one before the first entry, respectively.

Parameters

  remoteIndices | The list of the remote indices.
  globalIndices | The list of the corresponding global indices. This is needed because the the pointers to the local index will become invalid due to the merging of the index sets.
  booleans | Whether the remote index was there before the sync process started.

## local() [1/4]

template<class TG, class TL>

LocalIndex & Dune::IndexPair< TG, TL >::local | ( |  | ) |

inline

Get the local index.

Returns
  The local index.

## local() [2/4]

template<class TG, class TL>

const LocalIndex & Dune::IndexPair< TG, TL >::local | ( |  | ) | const

inline

Get the local index.

Returns
  The local index.

## local() [3/4]

const std::size_t & Dune::LocalIndex::local | ( |  | ) | const

inline

get the local index.

Returns
  The local index.

## local() [4/4]

template<class T>

size_t Dune::ParallelLocalIndex< T >::local | ( |  | ) | const

inline

get the local index.

Returns
  The local index.

## localIndexPair()

template<typename T1, typename T2>

const IndexPair< T1, ParallelLocalIndex< T2 > > & Dune::RemoteIndex< T1, T2 >::localIndexPair | ( |  | ) | const

inline

Get the corresponding local index pair.

Returns
  The corresponding local index pair.

## markAsDeleted()

template<typename TG, typename TL, int N = 100>

void Dune::ParallelIndexSet< TG, TL, N >::markAsDeleted | ( | const iterator & | position | ) |

inline

Mark an index as deleted.

The index will be deleted during endResize().

Parameters

  position | An iterator at the position we want to delete.

Exceptions

  InvalidState | If index set is not in ParallelIndexSetState::RESIZE mode.

## MessageInformation()

template<typename T>

Dune::IndicesSyncer< T >::MessageInformation::MessageInformation | ( |  | ) |

inline

## neighbours()

template<typename T, typename A>

int Dune::RemoteIndices< T, A >::neighbours | ( |  | ) | const

inline

Get the number of processors we share indices with.

Returns
  The number of neighbours.

## operator size_t()

template<class T>

Dune::ParallelLocalIndex< T >::operator size_t | ( |  | ) | const

inline

Convert to the local index represented by an int.

## operator std::size_t()

Dune::LocalIndex::operator std::size_t | ( |  | ) | const

inline

Convert to the local index represented by an int.

## operator!=() [1/6]

template<typename TG, typename TA>

bool Dune::operator!= | ( | const IndexPair< TG, ParallelLocalIndex< TA > > & | i1,
|  | const std::pair< TG, TA > & | i2 )

## operator!=() [2/6]

template<class TG, class TL>

bool Dune::operator!= | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

inline

## operator!=() [3/6]

template<class TG, class TL>

bool Dune::operator!= | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

inline

## operator!=() [4/6]

template<typename T>

bool Dune::operator!= | ( | const ParallelLocalIndex< T > & | p1,
|  | const ParallelLocalIndex< T > & | p2 )

## operator!=() [5/6]

template<typename TG, typename TA>

bool Dune::operator!= | ( | const std::pair< TG, TA > & | i2,
|  | const IndexPair< TG, ParallelLocalIndex< TA > > & | i1 )

## operator!=() [6/6]

template<typename T1, typename T2>

bool Dune::RemoteIndex< T1, T2 >::operator!= | ( | const RemoteIndex< T1, T2 > & | ri | ) | const

inline

## operator()() [1/2]

template<class TG, class TL>

bool Dune::IndexSetSortFunctor< TG, TL >::operator() | ( | const IndexPair< TG, TL > & | i1,
|  | const IndexPair< TG, TL > & | i2 )

inline

## operator()() [2/2]

template<typename T>

std::size_t Dune::IndicesSyncer< T >::DefaultNumberer::operator() | ( | const GlobalIndex & | global | ) |

inline

Provide the local index, always std::numeric_limits<size_t>::max().

Parameters

  global | The global index (ignored).

## operator++() [1/2]

template<typename T, typename A>

CollectiveIterator< T, A > & Dune::CollectiveIterator< T, A >::operator++ | ( |  | ) |

inline

## operator++() [2/2]

template<typename T>

IndicesSyncer< T >::Iterators & Dune::IndicesSyncer< T >::Iterators::operator++ | ( |  | ) |

inline

Increment all iterators.

## operator<() [1/4]

template<typename TG, typename TA>

bool Dune::operator< | ( | const IndexPair< TG, ParallelLocalIndex< TA > > & | i1,
|  | const std::pair< TG, TA > & | i2 )

## operator<() [2/4]

template<class TG, class TL>

bool Dune::operator< | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

inline

## operator<() [3/4]

template<class TG, class TL>

bool Dune::operator< | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

inline

## operator<() [4/4]

template<typename TG, typename TA>

bool Dune::operator< | ( | const std::pair< TG, TA > & | i1,
|  | const IndexPair< TG, ParallelLocalIndex< TA > > & | i2 )

## operator<<() [1/6]

template<class TG, class TL>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const IndexPair< TG, TL > & | pair )

inline

Print an index pair.

Parameters

  os | The outputstream to print to.
  pair | The index pair to print.

## operator<<() [2/6]

template<class TG, class TL, int N>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const ParallelIndexSet< TG, TL, N > & | indexSet )

inline

Print an index set.

Parameters

  os | The outputstream to print to.
  indexSet | The index set to print.

## operator<<() [3/6]

template<class T>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const ParallelLocalIndex< T > & | index )

Print the local index to a stream.

Parameters

  os | The output stream to print to.
  index | The index to print.

## operator<<() [4/6]

template<typename T1, typename T2>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const RemoteIndex< T1, T2 > & | index )

## operator<<() [5/6]

template<typename TG, typename TA>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const RemoteIndex< TG, TA > & | index )

inline

## operator<<() [6/6]

template<class T, class A>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const RemoteIndices< T, A > & | indices )

inline

## operator<=() [1/2]

template<class TG, class TL>

bool Dune::operator<= | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

inline

## operator<=() [2/2]

template<class TG, class TL>

bool Dune::operator<= | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

inline

## operator=() [1/2]

LocalIndex & Dune::LocalIndex::operator= | ( | std::size_t | index | ) |

inline

Assign a new local index.

Parameters

  index | The new local index.

## operator=() [2/2]

template<class T>

ParallelLocalIndex< T > & Dune::ParallelLocalIndex< T >::operator= | ( | size_t | index | ) |

inline

Assign a new local index.

Parameters

  index | The new local index.

## operator==() [1/7]

template<typename TG, typename TA>

bool Dune::operator== | ( | const IndexPair< TG, ParallelLocalIndex< TA > > & | i1,
|  | const std::pair< TG, TA > & | i2 )

## operator==() [2/7]

template<class TG, class TL>

bool Dune::operator== | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

inline

## operator==() [3/7]

template<class TG, class TL>

bool Dune::operator== | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

inline

## operator==() [4/7]

template<typename T>

bool Dune::operator== | ( | const ParallelLocalIndex< T > & | p1,
|  | const ParallelLocalIndex< T > & | p2 )

## operator==() [5/7]

template<typename TG, typename TA>

bool Dune::operator== | ( | const std::pair< TG, TA > & | i2,
|  | const IndexPair< TG, ParallelLocalIndex< TA > > & | i1 )

## operator==() [6/7]

template<typename T1, typename T2>

bool Dune::RemoteIndex< T1, T2 >::operator== | ( | const RemoteIndex< T1, T2 > & | ri | ) | const

inline

## operator==() [7/7]

template<typename T, typename A>

bool Dune::RemoteIndices< T, A >::operator== | ( | const RemoteIndices< T, A > & | ri | ) | const

## operator>() [1/2]

template<class TG, class TL>

bool Dune::operator> | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

inline

## operator>() [2/2]

template<class TG, class TL>

bool Dune::operator> | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

inline

## operator>=() [1/2]

template<class TG, class TL>

bool Dune::operator>= | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

inline

## operator>=() [2/2]

template<class TG, class TL>

bool Dune::operator>= | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

inline

## operator[]() [1/3]

template<class I>

const IndexPair & Dune::GlobalLookupIndexSet< I >::operator[] | ( | const GlobalIndex & | global | ) | const

inline

Find the index pair with a specific global id.

This starts a binary search for the entry and therefore has complexity log(N). This method is forwarded to the underlying index set.

Parameters

  global | The globally unique id of the pair.

Returns
  The pair of indices for the id.

Exceptions

  RangeError | Thrown if the global id is not known.

## operator[]() [2/3]

template<typename TG, typename TL, int N = 100>

IndexPair & Dune::ParallelIndexSet< TG, TL, N >::operator[] | ( | const GlobalIndex & | global | ) |

inline

Find the index pair with a specific global id.

This starts a binary search for the entry and therefore has complexity log(N).

Parameters

  global | The globally unique id of the pair.

Returns
  The pair of indices for the id.

Warning
  If the global index is not in the set a wrong or even a null reference might be returned. To be save use the throwing alternative at.

## operator[]() [3/3]

template<typename TG, typename TL, int N = 100>

const IndexPair & Dune::ParallelIndexSet< TG, TL, N >::operator[] | ( | const GlobalIndex & | global | ) | const

inline

Find the index pair with a specific global id.

This starts a binary search for the entry and therefore has complexity log(N).

Parameters

  global | The globally unique id of the pair.

Returns
  The pair of indices for the id.

Warning
  If the global index is not in the set a wrong or even a null reference might be returned. To be save use the throwing alternative at.

## packEntries()

template<class T, class A = std::allocator<RemoteIndex<typename T::GlobalIndex, typename T::LocalIndex::Attribute> >>
template<bool ignorePublic>

void Dune::RemoteIndices< T, A >::packEntries | ( | IndexPair< GlobalIndex, LocalIndex > ** | pairs,
|  | const ParallelIndexSet & | indexSet,
|  | char * | p_out,
|  | MPI_Datatype | type,
|  | int | bufferSize,
|  | int * | position,
|  | int | n )

inline

## pair()

template<class I>

const IndexPair * Dune::GlobalLookupIndexSet< I >::pair | ( | const std::size_t & | local | ) | const

inline

Get the index pair corresponding to a local index.

## ParallelIndexSet()

template<typename TG, typename TL, int N = 100>

Dune::ParallelIndexSet< TG, TL, N >::ParallelIndexSet | ( |  | ) |

Constructor.

## ParallelLocalIndex() [1/3]

template<class T>

Dune::ParallelLocalIndex< T >::ParallelLocalIndex | ( |  | ) |

Parameterless constructor.

Needed for use in container classes.

## ParallelLocalIndex() [2/3]

template<class T>

Dune::ParallelLocalIndex< T >::ParallelLocalIndex | ( | const Attribute & | attribute,
|  | bool | isPublic )

Constructor.

The local index will be initialized to 0.

Parameters

  attribute | The attribute of the index.
  isPublic | True if the index might also be known to other processes.

## ParallelLocalIndex() [3/3]

template<class T>

Dune::ParallelLocalIndex< T >::ParallelLocalIndex | ( | size_t | localIndex,
|  | const Attribute & | attribute,
|  | bool | isPublic = true )

Constructor.

Parameters

  localIndex | The local index.
  attribute | The attribute of the index.
  isPublic | True if the index might also be known to other processes.

## print()

void Dune::Interface::print | ( |  | ) | const

inline

Print the interface to std::out for debugging.

## rebuild()

template<typename T, typename A>
template<bool ignorePublic>

void Dune::RemoteIndices< T, A >::rebuild | ( |  | ) |

inline

Rebuilds the set of remote indices.

This has to be called whenever the underlying index sets change.

If the template parameter ignorePublic is true all indices will be treated as public.

## RemoteIndex() [1/3]

template<typename T1, typename T2>

Dune::RemoteIndex< T1, T2 >::RemoteIndex | ( |  | ) |

Parameterless Constructor.

## RemoteIndex() [2/3]

template<typename T1, typename T2>

Dune::RemoteIndex< T1, T2 >::RemoteIndex | ( | const T2 & | attribute | ) |

Constructor. Private as it should only be called from within Indexset.

Parameters

  attribute | The attribute of the index on the remote processor.

## RemoteIndex() [3/3]

template<typename T1, typename T2>

Dune::RemoteIndex< T1, T2 >::RemoteIndex | ( | const T2 & | attribute,
|  | const PairType * | local )

Constructor.

Parameters

  attribute | The attribute of the index on the remote processor.
  local | The corresponding local index.

## remoteIndex()

template<typename T>

IndicesSyncer< T >::RemoteIndex & Dune::IndicesSyncer< T >::Iterators::remoteIndex | ( |  | ) | const

inline

Get the remote index at current position.

Returns
  The current remote index.

## RemoteIndexListModifier()

template<typename T, typename A, bool mode>

Dune::RemoteIndexListModifier< T, A, mode >::RemoteIndexListModifier | ( | const RemoteIndexListModifier< T, A, mode > & | other | ) |

## RemoteIndices() [1/2]

template<typename T, typename A>

Dune::RemoteIndices< T, A >::RemoteIndices | ( |  | ) |

## RemoteIndices() [2/2]

template<typename T, typename A>

Dune::RemoteIndices< T, A >::RemoteIndices | ( | const ParallelIndexSet & | source,
|  | const ParallelIndexSet & | destination,
|  | const MPI_Comm & | comm,
|  | const std::vector< int > & | neighbours = std::vector<int>(),
|  | bool | includeSelf = false )

inline

Constructor.

Parameters

  comm | The communicator to use.
  source | The indexset which represents the global to local mapping at the source of the communication
  destination | The indexset to which the communication which represents the global to local mapping at the destination of the communication. May be the same as the source indexset.
  neighbours | Optional: The neighbours the process shares indices with. If this parameter is omitted a ring communication with all indices will take place to calculate this information which is O(P).
  includeSelf | If true, sending from indices of the processor to other indices on the same processor is enabled even if the same indexset is used on both the sending and receiving side.

## remove()

template<typename T, typename A, bool mode>

bool Dune::RemoteIndexListModifier< T, A, mode >::remove | ( | const GlobalIndex & | global | ) |

Remove a remote index.

Parameters

  global | The global index corresponding to the remote index.

Returns
  True If there was a corresponding remote index.

Exceptions

  InvalidPostion | If there was an insertion or deletion of a remote index corresponding to a bigger global index before.

## renumberLocal()

template<typename TG, typename TL, int N = 100>

void Dune::ParallelIndexSet< TG, TL, N >::renumberLocal | ( |  | ) |

inline

Renumbers the local index numbers.

After this function returns the indices are consecutively numbered beginning from 0. Let $(g_i,l_i)$, $(g_j,l_j)$ be two arbitrary index pairs with $g_i<g_j$ then after renumbering $l_i<l_j$ will hold.

## repairLocalIndexPointers() [1/2]

template<typename T, typename A, bool mode>

void Dune::RemoteIndexListModifier< T, A, mode >::repairLocalIndexPointers | ( |  | ) |

inline

Repair the pointers to the local index pairs.

Due to adding new indices or/and deleting indices in the index set all pointers to the local index pair might become invalid during ParallelIndexSet::endResize(). This method repairs them.

Exceptions

  InvalidIndexSetState | Thrown if the underlying index set is not in ParallelIndexSetState::GROUND mode (only when compiled with DUNE_ISTL_WITH_CHECKING!).

## repairLocalIndexPointers() [2/2]

template<typename T, typename A, typename A1>

void Dune::repairLocalIndexPointers | ( | std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > & | globalMap,
|  | RemoteIndices< T, A1 > & | remoteIndices,
|  | const T & | indexSet )

inline

Repair the pointers to the local indices in the remote indices.

Parameters

  globalMap | The map of the process number to the list of global indices corresponding to the remote index list of the process.
  remoteIndices | The known remote indices.
  indexSet | The set of local indices of the current process.

## reset()

template<typename T>

void Dune::IndicesSyncer< T >::Iterators::reset | ( | RemoteIndexList & | remoteIndices,
|  | GlobalIndexList & | globalIndices,
|  | BoolList & | booleans )

inline

Reset all the underlying iterators.

Position them to first list entry and the entry before the first entry respectively.

Parameters

  remoteIndices | The list of the remote indices.
  globalIndices | The list of the corresponding global indices. This is needed because the the pointers to the local index will become invalid due to the merging of the index sets.
  booleans | Whether the remote index was there before the sync process started.

## seqNo() [1/2]

template<class I>

int Dune::GlobalLookupIndexSet< I >::seqNo | ( |  | ) | const

inline

Get the internal sequence number.

Is initially 0 is incremented for each resize.

Returns
  The sequence number.

## seqNo() [2/2]

template<typename TG, typename TL, int N = 100>

int Dune::ParallelIndexSet< TG, TL, N >::seqNo | ( |  | ) | const

inline

Get the internal sequence number.

Is initially 0 is incremented for each resize.

Returns
  The sequence number.

## setAttribute()

template<class T>

void Dune::ParallelLocalIndex< T >::setAttribute | ( | const Attribute & | attribute | ) |

inline

Set the attribute of the index.

Parameters

  attribute | The associated attribute.

## setIncludeSelf()

template<typename T, typename A>

void Dune::RemoteIndices< T, A >::setIncludeSelf | ( | bool | includeSelf | ) |

Tell whether sending from indices of the processor to other indices on the same processor is enabled even if the same indexset is used on both the sending and receiving side.

Parameters

  includeSelf | If true it is enabled.

## setIndexSet() [1/2]

template<typename TS, typename TG, typename TL, int N>

void Dune::Selection< TS, TG, TL, N >::setIndexSet | ( | const ParallelIndexSet & | indexset | ) |

inline

Set the index set of the selection.

Parameters

  indexset | The index set to use.

## setIndexSet() [2/2]

template<typename TS, typename TG, typename TL, int N>

void Dune::UncachedSelection< TS, TG, TL, N >::setIndexSet | ( | const ParallelIndexSet & | indexset | ) |

Set the index set of the selection.

Parameters

  indexset | The index set to use.

## setIndexSets()

template<class T, typename A>

void Dune::RemoteIndices< T, A >::setIndexSets | ( | const ParallelIndexSet & | source,
|  | const ParallelIndexSet & | destination,
|  | const MPI_Comm & | comm,
|  | const std::vector< int > & | neighbours = std::vector<int>() )

Set the index sets and communicator we work with.

Warning
  All remote indices already setup will be deleted!

Parameters

  comm | The communicator to use.
  source | The indexset which represents the global to local mapping at the source of the communication
  destination | The indexset to which the communication which represents the global to local mapping at the destination of the communication. May be the same as the source indexset.
  neighbours | Optional: The neighbours the process shares indices with. If this parameter is omitted a ring communication with all indices will take place to calculate this information which is O(P).

## setLocal()

template<class TG, class TL>

void Dune::IndexPair< TG, TL >::setLocal | ( | int | index | ) |

inline

Set the local index.

Parameters

  index | The index to set it to.

## setState() [1/2]

void Dune::LocalIndex::setState | ( | LocalIndexState | state | ) |

inline

Set the state.

Parameters

  state | The state to set.

## setState() [2/2]

template<class T>

void Dune::ParallelLocalIndex< T >::setState | ( | const LocalIndexState & | state | ) |

inline

Set the state.

Parameters

  state | The state to set.

## size() [1/2]

template<class I>

size_t Dune::GlobalLookupIndexSet< I >::size | ( |  | ) | const

inline

Get the total number (public and nonpublic) indices.

Returns
  The total number (public and nonpublic) indices.

## size() [2/2]

template<typename TG, typename TL, int N = 100>

size_t Dune::ParallelIndexSet< TG, TL, N >::size | ( |  | ) | const

inline

Get the total number (public and nonpublic) indices.

Returns
  The total number (public and nonpublic) indices.

## sourceIndexSet()

template<typename T, typename A>

const RemoteIndices< T, A >::ParallelIndexSet & Dune::RemoteIndices< T, A >::sourceIndexSet | ( |  | ) | const

inline

Get the index set at the source.

## state() [1/3]

LocalIndexState Dune::LocalIndex::state | ( |  | ) | const

inline

Get the state.

Returns
  The state.

## state() [2/3]

template<typename TG, typename TL, int N = 100>

const ParallelIndexSetState & Dune::ParallelIndexSet< TG, TL, N >::state | ( |  | ) |

inline

Get the state the index set is in.

Returns
  The state of the index set.

## state() [3/3]

template<class T>

LocalIndexState Dune::ParallelLocalIndex< T >::state | ( |  | ) | const

inline

Get the state.

Returns
  The state.

## storeGlobalIndicesOfRemoteIndices()

template<typename T, typename A, typename A1>

void Dune::storeGlobalIndicesOfRemoteIndices | ( | std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > & | globalMap,
|  | const RemoteIndices< T, A1 > & | remoteIndices )

Stores the corresponding global indices of the remote index information.

Whenever a ParallelIndexSet is resized all RemoteIndices that use it will be invalided as the pointers to the index set are invalid after calling ParallelIndexSet::Resize() One can rebuild them by storing the global indices in a map with this function and later repairing the pointers by calling repairLocalIndexPointers.

Warning
  The RemoteIndices class has to be build with the same index set for both the sending and receiving side

Parameters

  globalMap | Map to store the corresponding global indices in.
  remoteIndices | The remote index information we need to store the corresponding global indices of.
  indexSet | The index set that is for both the sending and receiving side of the remote index information.

## strip()

void Dune::Interface::strip | ( |  | ) |

inline

## sync() [1/2]

template<typename T>

void Dune::IndicesSyncer< T >::sync | ( |  | ) |

inline

Sync the index set.

Computes the missing indices in the local and the remote index list and adds them. No global communication is necessary! All indices added to the index will become the local index std::numeric_limits<size_t>::max()

## sync() [2/2]

template<typename T>
template<typename T1>

void Dune::IndicesSyncer< T >::sync | ( | T1 & | numberer,
|  | bool | useFixedOrder = false )

Sync the index set and assign local numbers to new indices.

Computes the missing indices in the local and the remote index list and adds them. No global communication is necessary!

Parameters

  numberer | Functor providing the local indices for the added global indices. has to provide a function size_t operator()(const TG& global) that provides the local index to a global one. It will be called for ascending global indices.
  useFixedOrder | Flag indicating if the new indices should be created in a fixed order. If set to true, this makes the runs reproducible but might slow down performance.

## ~GlobalLookupIndexSet()

template<class I>

Dune::GlobalLookupIndexSet< I >::~GlobalLookupIndexSet | ( |  | ) |

Destructor.

## ~Interface()

Dune::Interface::~Interface | ( |  | ) |

inline virtual

Destructor.

## ~RemoteIndices()

template<typename T, typename A>

Dune::RemoteIndices< T, A >::~RemoteIndices | ( |  | ) |

Destructor.

## ~Selection()

template<typename TS, typename TG, typename TL, int N>

Dune::Selection< TS, TG, TL, N >::~Selection | ( |  | ) |

inline

## Variable Documentation

## arraySize

template<typename TG, typename TL, int N = 100>

int Dune::ParallelIndexSet< TG, TL, N >::arraySize = (N>0) ? N : 1

static constexpr

The size of the individual arrays in the underlying ArrayList.

The default value is 100.

See also
  ArrayList::size

## MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >::type

template<typename TG, typename TA>

MPI_Datatype Dune::MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >::type =MPI_DATATYPE_NULL

## MPITraits< ParallelLocalIndex< T > >::type

template<typename T>

MPI_Datatype Dune::MPITraits< ParallelLocalIndex< T > >::type = MPI_DATATYPE_NULL

## pairs

template<typename T>

int Dune::IndicesSyncer< T >::MessageInformation::pairs

The number of pairs (attribute and process number) we publish to the neighbour process.

## publish

template<typename T>

int Dune::IndicesSyncer< T >::MessageInformation::publish

The number of indices we publish for the other process.

## Friends

## GlobalLookupIndexSet< ParallelIndexSet< TG, TL, N > >

template<typename TG, typename TL, int N = 100>

friend class GlobalLookupIndexSet< ParallelIndexSet< TG, TL, N > >

friend

## IndicesSyncer< T >

template<typename T>

friend class IndicesSyncer< T >

friend

## MPITraits< IndexPair< TG, TL > >

template<class TG, class TL>

friend struct MPITraits< IndexPair< TG, TL > >

friend

## operator!= [1/2]

template<class TG, class TL>

bool operator!= | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

friend

## operator!= [2/2]

template<class TG, class TL>

bool operator!= | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

friend

## operator< [1/2]

template<class TG, class TL>

bool operator< | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

friend

## operator< [2/2]

template<class TG, class TL>

bool operator< | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

friend

## operator<<

template<class TG, class TL>

std::ostream & operator<< | ( | std::ostream & | os,
|  | const IndexPair< TG, TL > & | pair )

friend

Print an index pair.

Parameters

  os | The outputstream to print to.
  pair | The index pair to print.

## operator<= [1/2]

template<class TG, class TL>

bool operator<= | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

friend

## operator<= [2/2]

template<class TG, class TL>

bool operator<= | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

friend

## operator== [1/2]

template<class TG, class TL>

bool operator== | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

friend

## operator== [2/2]

template<class TG, class TL>

bool operator== | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

friend

## operator> [1/2]

template<class TG, class TL>

bool operator> | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

friend

## operator> [2/2]

template<class TG, class TL>

bool operator> | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

friend

## operator>= [1/2]

template<class TG, class TL>

bool operator>= | ( | const IndexPair< TG, TL > & | a,
|  | const IndexPair< TG, TL > & | b )

friend

## operator>= [2/2]

template<class TG, class TL>

bool operator>= | ( | const IndexPair< TG, TL > & | a,
|  | const TG & | b )

friend

## ParallelIndexSet< GlobalIndex, LocalIndex, N >

template<typename TG, typename TL, int N = 100>

friend class ParallelIndexSet< GlobalIndex, LocalIndex, N >

friend