dune-istl 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
21#include <dune/common/enumset.hh>
22
23#if HAVE_MPI
24#include <dune/common/parallel/indexset.hh>
25#include <dune/common/parallel/communicator.hh>
26#include <dune/common/parallel/remoteindices.hh>
27#include <dune/common/parallel/mpicommunication.hh>
28#endif
29
30#include "solvercategory.hh"
31#include "istlexception.hh"
32#include <dune/common/parallel/communication.hh>
34
35template<int dim, template<class,class> class Comm>
37
38
39namespace Dune {
40
57 {
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 &&
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 &&
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;
184 typedef Dune::ParallelLocalIndex<AttributeSet> LI;
185 public:
186 typedef Dune::ParallelIndexSet<GlobalIdType,LI,512> PIS;
187 typedef Dune::RemoteIndices<PIS> RI;
188 typedef Dune::RemoteIndexListModifier<PIS,typename RI::Allocator,false> RILM;
189 typedef typename RI::RemoteIndex RX;
190 typedef Dune::BufferedCommunicator BC;
191 typedef Dune::Interface IF;
192 typedef EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner> OwnerSet;
193 typedef EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy> CopySet;
194 typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::overlap>,AttributeSet> OwnerOverlapSet;
195 typedef Dune::AllSet<AttributeSet> AllSet;
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>
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
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
243 {
244 if (OwnerToAllInterfaceBuilt)
245 OwnerToAllInterface.free();
246 OwnerSet sourceFlags;
247 AllSet destFlags;
248 OwnerToAllInterface.build(ri,sourceFlags,destFlags);
249 OwnerToAllInterfaceBuilt = true;
250 }
251
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
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
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)
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)
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)
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)
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)
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
444 typedef Dune::EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy> CopyFlags;
445
447 typedef Dune::ParallelIndexSet<GlobalIdType,LI,512> ParallelIndexSet;
448
450 typedef Dune::RemoteIndices<PIS> RemoteIndices;
451
454 typedef Dune::GlobalLookupIndexSet<ParallelIndexSet> GlobalLookupIndexSet;
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
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
519 {
520 delete globalLookup_;
521 globalLookup_=0;
522 }
523
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
Provides classes for reading and writing MatrixMarket Files with an extension for parallel matrices.
void testRedistributed(int s)
Definition: allocator.hh:9
derive error class from the base class in common
Definition: istlexception.hh:17
Attribute set for overlapping Schwarz.
Definition: owneroverlapcopy.hh:57
AttributeSet
Definition: owneroverlapcopy.hh:58
@ owner
Definition: owneroverlapcopy.hh:59
@ copy
Definition: owneroverlapcopy.hh:59
@ overlap
Definition: owneroverlapcopy.hh:59
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
A class setting up standard communication for a two-valued attribute set with owner/overlap/copy sema...
Definition: owneroverlapcopy.hh:172
EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::copy > CopySet
Definition: owneroverlapcopy.hh:193
const GlobalLookupIndexSet & globalLookup() const
Definition: owneroverlapcopy.hh:524
FieldTraits< typenameT1::field_type >::real_type norm(const T1 &x) const
Compute the global Euclidean norm of a vector.
Definition: owneroverlapcopy.hh:423
void buildOwnerOverlapToAllInterface() const
Definition: owneroverlapcopy.hh:231
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > PIS
Definition: owneroverlapcopy.hh:186
void buildOwnerCopyToAllInterface() const
Definition: owneroverlapcopy.hh:252
void buildOwnerCopyToOwnerCopyInterface() const
Definition: owneroverlapcopy.hh:264
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
void buildCopyToAllInterface() const
Definition: owneroverlapcopy.hh:277
Dune::EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::copy > CopyFlags
Definition: owneroverlapcopy.hh:444
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
Dune::RemoteIndices< PIS > RI
Definition: owneroverlapcopy.hh:187
void buildGlobalLookup(std::size_t size)
Definition: owneroverlapcopy.hh:506
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
Dune::AllSet< AttributeSet > AllSet
Definition: owneroverlapcopy.hh:195
Combine< EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::owner >, EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::overlap >, AttributeSet > OwnerOverlapSet
Definition: owneroverlapcopy.hh:194
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
Dune::Interface IF
Definition: owneroverlapcopy.hh:191
~OwnerOverlapCopyCommunication()
Definition: owneroverlapcopy.hh:648
void buildGlobalLookup()
Definition: owneroverlapcopy.hh:493
Dune::BufferedCommunicator BC
Definition: owneroverlapcopy.hh:190
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
const CollectiveCommunication< MPI_Comm > & communicator() const
Definition: owneroverlapcopy.hh:297
EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::owner > OwnerSet
Definition: owneroverlapcopy.hh:192
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
RI::RemoteIndex RX
Definition: owneroverlapcopy.hh:189
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
void freeGlobalLookup()
Definition: owneroverlapcopy.hh:518
Dune::RemoteIndexListModifier< PIS, typename RI::Allocator, false > RILM
Definition: owneroverlapcopy.hh:188
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > ParallelIndexSet
The type of the parallel index set.
Definition: owneroverlapcopy.hh:447
void buildOwnerToAllInterface() const
Definition: owneroverlapcopy.hh:242
gather/scatter callback for communcation
Definition: owneroverlapcopy.hh:202
static V gather(const T &a, std::size_t i)
Definition: owneroverlapcopy.hh:205
static void scatter(T &a, V v, std::size_t i)
Definition: owneroverlapcopy.hh:210
CommPolicy< T >::IndexedType V
Definition: owneroverlapcopy.hh:203
CommPolicy< T >::IndexedType V
Definition: owneroverlapcopy.hh:218
static V gather(const T &a, std::size_t i)
Definition: owneroverlapcopy.hh:220
static void scatter(T &a, V v, std::size_t i)
Definition: owneroverlapcopy.hh:225
Category
Definition: solvercategory.hh:21
@ overlapping
Category for overlapping solvers.
Definition: solvercategory.hh:27