Dune Core Modules (2.8.0)

owneroverlapcopy.hh
Go to the documentation of this file.
1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2// vi: set et ts=4 sw=2 sts=2:
3#ifndef DUNE_ISTL_OWNEROVERLAPCOPY_HH
4#define DUNE_ISTL_OWNEROVERLAPCOPY_HH
5
6#include <new>
7#include <iostream>
8#include <vector>
9#include <list>
10#include <map>
11#include <set>
12#include <tuple>
13
14#include "cmath"
15
16// MPI header
17#if HAVE_MPI
18#include <mpi.h>
19#endif
20
22
23#if HAVE_MPI
28#endif
29
30#include "solvercategory.hh"
31#include "istlexception.hh"
34
35template<int dim, template<class,class> class Comm>
36void testRedistributed(int s);
37
38
39namespace Dune {
40
57 {
58 enum AttributeSet {
59 owner=1, overlap=2, copy=3
60 };
61 };
62
74 template <class G, class L>
76 {
77 public:
79 typedef G GlobalIdType;
80
82 typedef L LocalIdType;
83
90 typedef std::tuple<GlobalIdType,LocalIdType,int> IndexTripel;
97 typedef std::tuple<int,GlobalIdType,int> RemoteIndexTripel;
98
105 {
106 if (std::get<2>(x)!=OwnerOverlapCopyAttributeSet::owner &&
107 std::get<2>(x)!=OwnerOverlapCopyAttributeSet::overlap &&
108 std::get<2>(x)!=OwnerOverlapCopyAttributeSet::copy)
109 DUNE_THROW(ISTLError,"OwnerOverlapCopyCommunication: global index not in index set");
110 localindices.insert(x);
111 }
112
119 {
120 if (std::get<2>(x)!=OwnerOverlapCopyAttributeSet::owner &&
121 std::get<2>(x)!=OwnerOverlapCopyAttributeSet::overlap &&
122 std::get<2>(x)!=OwnerOverlapCopyAttributeSet::copy)
123 DUNE_THROW(ISTLError,"OwnerOverlapCopyCommunication: global index not in index set");
124 remoteindices.insert(x);
125 }
126
131 const std::set<IndexTripel>& localIndices () const
132 {
133 return localindices;
134 }
135
140 const std::set<RemoteIndexTripel>& remoteIndices () const
141 {
142 return remoteindices;
143 }
144
148 void clear ()
149 {
150 localindices.clear();
151 remoteindices.clear();
152 }
153
154 private:
156 std::set<IndexTripel> localindices;
158 std::set<RemoteIndexTripel> remoteindices;
159 };
160
161
162#if HAVE_MPI
163
170 template <class GlobalIdType, class LocalIdType=int>
172 {
173 template<typename M, typename G, typename L>
174 friend void loadMatrixMarket(M&,
175 const std::string&,
177 bool);
178 // used types
181 typedef typename std::set<IndexTripel>::const_iterator localindex_iterator;
182 typedef typename std::set<RemoteIndexTripel>::const_iterator remoteindex_iterator;
183 typedef typename OwnerOverlapCopyAttributeSet::AttributeSet AttributeSet;
185 public:
189 typedef typename RI::RemoteIndex RX;
191 typedef Dune::Interface IF;
196 protected:
197
198
200 template<typename T>
202 {
203 typedef typename CommPolicy<T>::IndexedType V;
204
205 static V gather(const T& a, std::size_t i)
206 {
207 return a[i];
208 }
209
210 static void scatter(T& a, V v, std::size_t i)
211 {
212 a[i] = v;
213 }
214 };
215 template<typename T>
216 struct AddGatherScatter
217 {
218 typedef typename CommPolicy<T>::IndexedType V;
219
220 static V gather(const T& a, std::size_t i)
221 {
222 return a[i];
223 }
224
225 static void scatter(T& a, V v, std::size_t i)
226 {
227 a[i] += v;
228 }
229 };
230
231 void buildOwnerOverlapToAllInterface () const
232 {
233 if (OwnerOverlapToAllInterfaceBuilt)
234 OwnerOverlapToAllInterface.free();
235 OwnerOverlapSet sourceFlags;
236 Combine<OwnerOverlapSet,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,AttributeSet>
237 destFlags;
238 OwnerOverlapToAllInterface.build(ri,sourceFlags,destFlags);
239 OwnerOverlapToAllInterfaceBuilt = true;
240 }
241
242 void buildOwnerToAllInterface () const
243 {
244 if (OwnerToAllInterfaceBuilt)
245 OwnerToAllInterface.free();
246 OwnerSet sourceFlags;
247 AllSet destFlags;
248 OwnerToAllInterface.build(ri,sourceFlags,destFlags);
249 OwnerToAllInterfaceBuilt = true;
250 }
251
252 void buildOwnerCopyToAllInterface () const
253 {
254 if (OwnerCopyToAllInterfaceBuilt)
255 OwnerCopyToAllInterface.free();
256
257 typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,AttributeSet> OwnerCopySet;
258 OwnerCopySet sourceFlags;
259 Combine<OwnerCopySet,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::overlap>,AttributeSet> destFlags;
260 OwnerCopyToAllInterface.build(ri,sourceFlags,destFlags);
261 OwnerCopyToAllInterfaceBuilt = true;
262 }
263
264 void buildOwnerCopyToOwnerCopyInterface () const
265 {
266 if (OwnerCopyToOwnerCopyInterfaceBuilt)
267 OwnerCopyToOwnerCopyInterface.free();
268
269
270 typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,AttributeSet> OwnerCopySet;
271 OwnerCopySet sourceFlags;
272 OwnerCopySet destFlags;
273 OwnerCopyToOwnerCopyInterface.build(ri,sourceFlags,destFlags);
274 OwnerCopyToOwnerCopyInterfaceBuilt = true;
275 }
276
277 void buildCopyToAllInterface () const
278 {
279 if (CopyToAllInterfaceBuilt)
280 CopyToAllInterface.free();
281 CopySet sourceFlags;
282 AllSet destFlags;
283 CopyToAllInterface.build(ri,sourceFlags,destFlags);
284 CopyToAllInterfaceBuilt = true;
285 }
286
287 public:
288
294 return category_;
295 }
296
297 const CollectiveCommunication<MPI_Comm>& communicator() const
298 {
299 return cc;
300 }
301
308 template<class T>
309 void copyOwnerToAll (const T& source, T& dest) const
310 {
311 if (!OwnerToAllInterfaceBuilt)
312 buildOwnerToAllInterface ();
313 BC communicator;
314 communicator.template build<T>(OwnerToAllInterface);
315 communicator.template forward<CopyGatherScatter<T> >(source,dest);
316 communicator.free();
317 }
318
325 template<class T>
326 void copyCopyToAll (const T& source, T& dest) const
327 {
328 if (!CopyToAllInterfaceBuilt)
329 buildCopyToAllInterface ();
330 BC communicator;
331 communicator.template build<T>(CopyToAllInterface);
332 communicator.template forward<CopyGatherScatter<T> >(source,dest);
333 communicator.free();
334 }
335
342 template<class T>
343 void addOwnerOverlapToAll (const T& source, T& dest) const
344 {
345 if (!OwnerOverlapToAllInterfaceBuilt)
346 buildOwnerOverlapToAllInterface ();
347 BC communicator;
348 communicator.template build<T>(OwnerOverlapToAllInterface);
349 communicator.template forward<AddGatherScatter<T> >(source,dest);
350 communicator.free();
351 }
352
359 template<class T>
360 void addOwnerCopyToAll (const T& source, T& dest) const
361 {
362 if (!OwnerCopyToAllInterfaceBuilt)
363 buildOwnerCopyToAllInterface ();
364 BC communicator;
365 communicator.template build<T>(OwnerCopyToAllInterface);
366 communicator.template forward<AddGatherScatter<T> >(source,dest);
367 communicator.free();
368 }
369
376 template<class T>
377 void addOwnerCopyToOwnerCopy (const T& source, T& dest) const
378 {
379 if (!OwnerCopyToOwnerCopyInterfaceBuilt)
380 buildOwnerCopyToOwnerCopyInterface ();
381 BC communicator;
382 communicator.template build<T>(OwnerCopyToOwnerCopyInterface);
383 communicator.template forward<AddGatherScatter<T> >(source,dest);
384 communicator.free();
385 }
386
387
395 template<class T1, class T2>
396 void dot (const T1& x, const T1& y, T2& result) const
397 {
398 using real_type = typename FieldTraits<typename T1::field_type>::real_type;
399 // set up mask vector
400 if (mask.size()!=static_cast<typename std::vector<double>::size_type>(x.size()))
401 {
402 mask.resize(x.size());
403 for (typename std::vector<double>::size_type i=0; i<mask.size(); i++)
404 mask[i] = 1;
405 for (typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
406 if (i->local().attribute()!=OwnerOverlapCopyAttributeSet::owner)
407 mask[i->local().local()] = 0;
408 }
409 result = T2(0.0);
410
411 for (typename T1::size_type i=0; i<x.size(); i++)
412 result += (x[i]*(y[i]))*static_cast<real_type>(mask[i]);
413 result = cc.sum(result);
414 }
415
422 template<class T1>
423 typename FieldTraits<typename T1::field_type>::real_type norm (const T1& x) const
424 {
425 using real_type = typename FieldTraits<typename T1::field_type>::real_type;
426
427 // set up mask vector
428 if (mask.size()!=static_cast<typename std::vector<double>::size_type>(x.size()))
429 {
430 mask.resize(x.size());
431 for (typename std::vector<double>::size_type i=0; i<mask.size(); i++)
432 mask[i] = 1;
433 for (typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
434 if (i->local().attribute()!=OwnerOverlapCopyAttributeSet::owner)
435 mask[i->local().local()] = 0;
436 }
437 auto result = real_type(0.0);
438 for (typename T1::size_type i=0; i<x.size(); i++)
439 result += Impl::asVector(x[i]).two_norm2()*mask[i];
440 using std::sqrt;
441 return sqrt(cc.sum(result));
442 }
443
445
448
451
455
461 {
462 return pis;
463 }
464
470 {
471 return ri;
472 }
473
479 {
480 return pis;
481 }
482
483
489 {
490 return ri;
491 }
492
493 void buildGlobalLookup()
494 {
495 if(globalLookup_) {
496 if(pis.seqNo()==oldseqNo)
497 // Nothing changed!
498 return;
499 delete globalLookup_;
500 }
501
502 globalLookup_ = new GlobalLookupIndexSet(pis);
503 oldseqNo = pis.seqNo();
504 }
505
506 void buildGlobalLookup(std::size_t size)
507 {
508 if(globalLookup_) {
509 if(pis.seqNo()==oldseqNo)
510 // Nothing changed!
511 return;
512 delete globalLookup_;
513 }
514 globalLookup_ = new GlobalLookupIndexSet(pis, size);
515 oldseqNo = pis.seqNo();
516 }
517
518 void freeGlobalLookup()
519 {
520 delete globalLookup_;
521 globalLookup_=0;
522 }
523
524 const GlobalLookupIndexSet& globalLookup() const
525 {
526 assert(globalLookup_ != 0);
527 return *globalLookup_;
528 }
529
535 template<class T1>
536 void project (T1& x) const
537 {
538 for (typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
539 if (i->local().attribute()==OwnerOverlapCopyAttributeSet::copy)
540 x[i->local().local()] = 0;
541 }
542
554 bool freecomm_ = false)
555 : comm(comm_), cc(comm_), pis(), ri(pis,pis,comm_),
556 OwnerToAllInterfaceBuilt(false), OwnerOverlapToAllInterfaceBuilt(false),
557 OwnerCopyToAllInterfaceBuilt(false), OwnerCopyToOwnerCopyInterfaceBuilt(false),
558 CopyToAllInterfaceBuilt(false), globalLookup_(0), category_(cat_),
559 freecomm(freecomm_)
560 {}
561
571 : comm(MPI_COMM_WORLD), cc(MPI_COMM_WORLD), pis(), ri(pis,pis,MPI_COMM_WORLD),
572 OwnerToAllInterfaceBuilt(false), OwnerOverlapToAllInterfaceBuilt(false),
573 OwnerCopyToAllInterfaceBuilt(false), OwnerCopyToOwnerCopyInterfaceBuilt(false),
574 CopyToAllInterfaceBuilt(false), globalLookup_(0), category_(cat_), freecomm(false)
575 {}
576
585 MPI_Comm comm_,
587 bool freecomm_ = false)
588 : comm(comm_), cc(comm_), OwnerToAllInterfaceBuilt(false),
589 OwnerOverlapToAllInterfaceBuilt(false), OwnerCopyToAllInterfaceBuilt(false),
590 OwnerCopyToOwnerCopyInterfaceBuilt(false), CopyToAllInterfaceBuilt(false),
591 globalLookup_(0), category_(cat_), freecomm(freecomm_)
592 {
593 // set up an ISTL index set
594 pis.beginResize();
595 for (localindex_iterator i=indexinfo.localIndices().begin(); i!=indexinfo.localIndices().end(); ++i)
596 {
597 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::owner)
598 pis.add(std::get<0>(*i),LI(std::get<1>(*i),OwnerOverlapCopyAttributeSet::owner,true));
599 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::overlap)
600 pis.add(std::get<0>(*i),LI(std::get<1>(*i),OwnerOverlapCopyAttributeSet::overlap,true));
601 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::copy)
602 pis.add(std::get<0>(*i),LI(std::get<1>(*i),OwnerOverlapCopyAttributeSet::copy,true));
603 // std::cout << cc.rank() << ": adding index " << std::get<0>(*i) << " " << std::get<1>(*i) << " " << std::get<2>(*i) << std::endl;
604 }
605 pis.endResize();
606
607 // build remote indices WITHOUT communication
608 // std::cout << cc.rank() << ": build remote indices" << std::endl;
609 ri.setIndexSets(pis,pis,cc);
610 if (indexinfo.remoteIndices().size()>0)
611 {
612 remoteindex_iterator i=indexinfo.remoteIndices().begin();
613 int p = std::get<0>(*i);
614 RILM modifier = ri.template getModifier<false,true>(p);
615 typename PIS::const_iterator pi=pis.begin();
616 for ( ; i!=indexinfo.remoteIndices().end(); ++i)
617 {
618 // handle processor change
619 if (p!=std::get<0>(*i))
620 {
621 p = std::get<0>(*i);
622 modifier = ri.template getModifier<false,true>(p);
623 pi=pis.begin();
624 }
625
626 // position to correct entry in parallel index set
627 while (pi->global()!=std::get<1>(*i) && pi!=pis.end())
628 ++pi;
629 if (pi==pis.end())
630 DUNE_THROW(ISTLError,"OwnerOverlapCopyCommunication: global index not in index set");
631
632 // insert entry
633 // std::cout << cc.rank() << ": adding remote index " << std::get<0>(*i) << " " << std::get<1>(*i) << " " << std::get<2>(*i) << std::endl;
634 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::owner)
635 modifier.insert(RX(OwnerOverlapCopyAttributeSet::owner,&(*pi)));
636 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::overlap)
637 modifier.insert(RX(OwnerOverlapCopyAttributeSet::overlap,&(*pi)));
638 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::copy)
639 modifier.insert(RX(OwnerOverlapCopyAttributeSet::copy,&(*pi)));
640 }
641 }else{
642 // Force remote indices to be synced!
643 ri.template getModifier<false,true>(0);
644 }
645 }
646
647 // destructor: free memory in some objects
649 {
650 ri.free();
651 if (OwnerToAllInterfaceBuilt) OwnerToAllInterface.free();
652 if (OwnerOverlapToAllInterfaceBuilt) OwnerOverlapToAllInterface.free();
653 if (OwnerCopyToAllInterfaceBuilt) OwnerCopyToAllInterface.free();
654 if (OwnerCopyToOwnerCopyInterfaceBuilt) OwnerCopyToOwnerCopyInterface.free();
655 if (CopyToAllInterfaceBuilt) CopyToAllInterface.free();
656 if (globalLookup_) delete globalLookup_;
657 if (freecomm==true)
658 if(comm!=MPI_COMM_NULL)
659 {
660#ifdef MPI_2
661 // If it is possible to query whether MPI_Finalize
662 // was called, only free the communicator before
663 // calling MPI_Finalize.
664 int wasFinalized = 0;
665 MPI_Finalized( &wasFinalized );
666 if(!wasFinalized)
667#endif
668 MPI_Comm_free(&comm);
669 }
670 }
671
672 private:
674 {}
675 MPI_Comm comm;
676 CollectiveCommunication<MPI_Comm> cc;
677 PIS pis;
678 RI ri;
679 mutable IF OwnerToAllInterface;
680 mutable bool OwnerToAllInterfaceBuilt;
681 mutable IF OwnerOverlapToAllInterface;
682 mutable bool OwnerOverlapToAllInterfaceBuilt;
683 mutable IF OwnerCopyToAllInterface;
684 mutable bool OwnerCopyToAllInterfaceBuilt;
685 mutable IF OwnerCopyToOwnerCopyInterface;
686 mutable bool OwnerCopyToOwnerCopyInterfaceBuilt;
687 mutable IF CopyToAllInterface;
688 mutable bool CopyToAllInterfaceBuilt;
689 mutable std::vector<double> mask;
690 int oldseqNo;
691 GlobalLookupIndexSet* globalLookup_;
692 const SolverCategory::Category category_;
693 bool freecomm;
694 };
695
696#endif
697
698
701} // end namespace
702
703#endif
A set containing everything.
Definition: enumset.hh:42
A communicator that uses buffers to gather and scatter the data to be send or received.
Definition: communicator.hh:458
void free()
Free the allocated memory (i.e. buffers and message information.
A set combining two other sets.
Definition: enumset.hh:109
A constant random access iterator for the Dune::ArrayList class.
Definition: arraylist.hh:377
A set consisting only of one item.
Definition: enumset.hh:59
derive error class from the base class in common
Definition: istlexception.hh:17
Information about the index distribution.
Definition: owneroverlapcopy.hh:76
std::tuple< GlobalIdType, LocalIdType, int > IndexTripel
A triple describing a local index.
Definition: owneroverlapcopy.hh:90
void addRemoteIndex(const RemoteIndexTripel &x)
Add a new remote index triple to the set of remote indices.
Definition: owneroverlapcopy.hh:118
G GlobalIdType
The type of the global index.
Definition: owneroverlapcopy.hh:79
const std::set< IndexTripel > & localIndices() const
Get the set of indices local to the process.
Definition: owneroverlapcopy.hh:131
const std::set< RemoteIndexTripel > & remoteIndices() const
Get the set of remote indices.
Definition: owneroverlapcopy.hh:140
L LocalIdType
The type of the local index.
Definition: owneroverlapcopy.hh:82
void clear()
Remove all indices from the sets.
Definition: owneroverlapcopy.hh:148
void addLocalIndex(const IndexTripel &x)
Add a new index triple to the set of local indices.
Definition: owneroverlapcopy.hh:104
std::tuple< int, GlobalIdType, int > RemoteIndexTripel
A triple describing a remote index.
Definition: owneroverlapcopy.hh:97
Communication interface between remote and local indices.
Definition: interface.hh:207
A class setting up standard communication for a two-valued attribute set with owner/overlap/copy sema...
Definition: owneroverlapcopy.hh:172
FieldTraits< typenameT1::field_type >::real_type norm(const T1 &x) const
Compute the global Euclidean norm of a vector.
Definition: owneroverlapcopy.hh:423
OwnerOverlapCopyCommunication(const IndexInfoFromGrid< GlobalIdType, LocalIdType > &indexinfo, MPI_Comm comm_, SolverCategory::Category cat_=SolverCategory::overlapping, bool freecomm_=false)
Constructor.
Definition: owneroverlapcopy.hh:584
SolverCategory::Category category() const
Get Solver Category.
Definition: owneroverlapcopy.hh:293
void addOwnerCopyToOwnerCopy(const T &source, T &dest) const
Communicate values from owner and copy data points to owner and copy data points and add them to thos...
Definition: owneroverlapcopy.hh:377
RemoteIndices & remoteIndices()
Get the underlying remote indices.
Definition: owneroverlapcopy.hh:488
const ParallelIndexSet & indexSet() const
Get the underlying parallel index set.
Definition: owneroverlapcopy.hh:460
void addOwnerOverlapToAll(const T &source, T &dest) const
Communicate values from owner data points to all other data points and add them to those values.
Definition: owneroverlapcopy.hh:343
Dune::RemoteIndices< PIS > RemoteIndices
The type of the remote indices.
Definition: owneroverlapcopy.hh:450
void project(T1 &x) const
Set vector to zero at copy dofs.
Definition: owneroverlapcopy.hh:536
void copyCopyToAll(const T &source, T &dest) const
Communicate values from copy data points to all other data points.
Definition: owneroverlapcopy.hh:326
Dune::GlobalLookupIndexSet< ParallelIndexSet > GlobalLookupIndexSet
The type of the reverse lookup of indices.
Definition: owneroverlapcopy.hh:454
OwnerOverlapCopyCommunication(MPI_Comm comm_, SolverCategory::Category cat_=SolverCategory::overlapping, bool freecomm_=false)
Construct the communication without any indices.
Definition: owneroverlapcopy.hh:552
ParallelIndexSet & indexSet()
Get the underlying parallel index set.
Definition: owneroverlapcopy.hh:478
void dot(const T1 &x, const T1 &y, T2 &result) const
Compute a global dot product of two vectors.
Definition: owneroverlapcopy.hh:396
OwnerOverlapCopyCommunication(SolverCategory::Category cat_=SolverCategory::overlapping)
Construct the communication without any indices using MPI_COMM_WORLD.
Definition: owneroverlapcopy.hh:570
void copyOwnerToAll(const T &source, T &dest) const
Communicate values from owner data points to all other data points.
Definition: owneroverlapcopy.hh:309
const RemoteIndices & remoteIndices() const
Get the underlying remote indices.
Definition: owneroverlapcopy.hh:469
friend void loadMatrixMarket(M &, const std::string &, OwnerOverlapCopyCommunication< G, L > &, bool)
Load a parallel matrix/vector stored in matrix market format.
Definition: matrixmarket.hh:1222
void addOwnerCopyToAll(const T &source, T &dest) const
Communicate values from owner and copy data points to all other data points and add them to those val...
Definition: owneroverlapcopy.hh:360
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > ParallelIndexSet
The type of the parallel index set.
Definition: owneroverlapcopy.hh:447
An index present on the local process with an additional attribute flag.
Definition: plocalindex.hh:47
Modifier for adding and/or deleting remote indices from the remote index list.
Definition: remoteindices.hh:549
void insert(const RemoteIndex &index)
Insert an index to the list.
Definition: remoteindices.hh:1605
Information about an index residing on another processor.
Definition: remoteindices.hh:71
void 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.
Definition: remoteindices.hh:984
void free()
Free the index lists.
Definition: remoteindices.hh:1429
Implements an utility class that provides collective communication methods for sequential programs.
Provides utility classes for syncing distributed data via MPI communication.
Classes for building sets out of enumeration values.
void beginResize()
Indicate that the index set is to be resized.
void build(const R &remoteIndices, const T1 &sourceFlags, const T2 &destFlags)
Builds the interface.
Definition: interface.hh:459
void add(const GlobalIndex &global)
Add an new index to the set.
iterator begin()
Get an iterator over the indices positioned at the first index.
iterator end()
Get an iterator over the indices positioned after the last index.
void endResize()
Indicate that the resizing finishes.
int seqNo() const
Get the internal sequence number.
void free()
Frees memory allocated during the build.
Definition: interface.hh:490
#define DUNE_THROW(E, m)
Definition: exceptions.hh:216
Provides a map between global and local indices.
Provides classes for reading and writing MatrixMarket Files with an extension for parallel matrices.
Implements an utility class that provides MPI's collective communication methods.
Dune namespace.
Definition: alignedallocator.hh:11
Classes describing a distributed indexset.
V::value_type IndexedType
The type we get at each index with operator[].
Definition: communicator.hh:145
Attribute set for overlapping Schwarz.
Definition: owneroverlapcopy.hh:57
gather/scatter callback for communcation
Definition: owneroverlapcopy.hh:202
Category
Definition: solvercategory.hh:21
@ overlapping
Category for overlapping solvers.
Definition: solvercategory.hh:27
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Nov 12, 23:30, 2024)