DUNE PDELab (git)

owneroverlapcopy.hh
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
3// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
4// vi: set et ts=4 sw=2 sts=2:
5#ifndef DUNE_ISTL_OWNEROVERLAPCOPY_HH
6#define DUNE_ISTL_OWNEROVERLAPCOPY_HH
7
8#include <new>
9#include <iostream>
10#include <vector>
11#include <list>
12#include <map>
13#include <set>
14#include <tuple>
15
16#include <cmath>
17
18// MPI header
19#if HAVE_MPI
20#include <mpi.h>
21#endif
22
24
25#if HAVE_MPI
30#endif
31
32#include "solvercategory.hh"
33#include "istlexception.hh"
36
37template<int dim, template<class,class> class Comm>
38void testRedistributed(int s);
39
40
41namespace Dune {
42
59 {
60 enum AttributeSet {
61 owner=1, overlap=2, copy=3
62 };
63 };
64
76 template <class G, class L>
78 {
79 public:
81 typedef G GlobalIdType;
82
84 typedef L LocalIdType;
85
92 typedef std::tuple<GlobalIdType,LocalIdType,int> IndexTripel;
99 typedef std::tuple<int,GlobalIdType,int> RemoteIndexTripel;
100
107 {
108 if (std::get<2>(x)!=OwnerOverlapCopyAttributeSet::owner &&
109 std::get<2>(x)!=OwnerOverlapCopyAttributeSet::overlap &&
110 std::get<2>(x)!=OwnerOverlapCopyAttributeSet::copy)
111 DUNE_THROW(ISTLError,"OwnerOverlapCopyCommunication: global index not in index set");
112 localindices.insert(x);
113 }
114
121 {
122 if (std::get<2>(x)!=OwnerOverlapCopyAttributeSet::owner &&
123 std::get<2>(x)!=OwnerOverlapCopyAttributeSet::overlap &&
124 std::get<2>(x)!=OwnerOverlapCopyAttributeSet::copy)
125 DUNE_THROW(ISTLError,"OwnerOverlapCopyCommunication: global index not in index set");
126 remoteindices.insert(x);
127 }
128
133 const std::set<IndexTripel>& localIndices () const
134 {
135 return localindices;
136 }
137
142 const std::set<RemoteIndexTripel>& remoteIndices () const
143 {
144 return remoteindices;
145 }
146
150 void clear ()
151 {
152 localindices.clear();
153 remoteindices.clear();
154 }
155
156 private:
158 std::set<IndexTripel> localindices;
160 std::set<RemoteIndexTripel> remoteindices;
161 };
162
163
164#if HAVE_MPI
165
172 template <class GlobalIdType, class LocalIdType=int>
174 {
175 template<typename M, typename G, typename L>
176 friend void loadMatrixMarket(M&,
177 const std::string&,
179 bool);
180 // used types
183 typedef typename std::set<IndexTripel>::const_iterator localindex_iterator;
184 typedef typename std::set<RemoteIndexTripel>::const_iterator remoteindex_iterator;
185 typedef typename OwnerOverlapCopyAttributeSet::AttributeSet AttributeSet;
187 public:
191 typedef typename RI::RemoteIndex RX;
193 typedef Dune::Interface IF;
198 protected:
199
200
202 template<typename T>
204 {
205 typedef typename CommPolicy<T>::IndexedType V;
206
207 static V gather(const T& a, std::size_t i)
208 {
209 return a[i];
210 }
211
212 static void scatter(T& a, V v, std::size_t i)
213 {
214 a[i] = v;
215 }
216 };
217 template<typename T>
218 struct AddGatherScatter
219 {
220 typedef typename CommPolicy<T>::IndexedType V;
221
222 static V gather(const T& a, std::size_t i)
223 {
224 return a[i];
225 }
226
227 static void scatter(T& a, V v, std::size_t i)
228 {
229 a[i] += v;
230 }
231 };
232
233 void buildOwnerOverlapToAllInterface () const
234 {
235 if (OwnerOverlapToAllInterfaceBuilt)
236 OwnerOverlapToAllInterface.free();
237 OwnerOverlapSet sourceFlags;
238 Combine<OwnerOverlapSet,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,AttributeSet>
239 destFlags;
240 OwnerOverlapToAllInterface.build(ri,sourceFlags,destFlags);
241 OwnerOverlapToAllInterfaceBuilt = true;
242 }
243
244 void buildOwnerToAllInterface () const
245 {
246 if (OwnerToAllInterfaceBuilt)
247 OwnerToAllInterface.free();
248 OwnerSet sourceFlags;
249 AllSet destFlags;
250 OwnerToAllInterface.build(ri,sourceFlags,destFlags);
251 OwnerToAllInterfaceBuilt = true;
252 }
253
254 void buildOwnerCopyToAllInterface () const
255 {
256 if (OwnerCopyToAllInterfaceBuilt)
257 OwnerCopyToAllInterface.free();
258
259 typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,AttributeSet> OwnerCopySet;
260 OwnerCopySet sourceFlags;
261 Combine<OwnerCopySet,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::overlap>,AttributeSet> destFlags;
262 OwnerCopyToAllInterface.build(ri,sourceFlags,destFlags);
263 OwnerCopyToAllInterfaceBuilt = true;
264 }
265
266 void buildOwnerCopyToOwnerCopyInterface () const
267 {
268 if (OwnerCopyToOwnerCopyInterfaceBuilt)
269 OwnerCopyToOwnerCopyInterface.free();
270
271
272 typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,AttributeSet> OwnerCopySet;
273 OwnerCopySet sourceFlags;
274 OwnerCopySet destFlags;
275 OwnerCopyToOwnerCopyInterface.build(ri,sourceFlags,destFlags);
276 OwnerCopyToOwnerCopyInterfaceBuilt = true;
277 }
278
279 void buildCopyToAllInterface () const
280 {
281 if (CopyToAllInterfaceBuilt)
282 CopyToAllInterface.free();
283 CopySet sourceFlags;
284 AllSet destFlags;
285 CopyToAllInterface.build(ri,sourceFlags,destFlags);
286 CopyToAllInterfaceBuilt = true;
287 }
288
289 public:
290
296 return category_;
297 }
298
299 const Communication<MPI_Comm>& communicator() const
300 {
301 return cc;
302 }
303
310 template<class T>
311 void copyOwnerToAll (const T& source, T& dest) const
312 {
313 if (!OwnerToAllInterfaceBuilt)
314 buildOwnerToAllInterface ();
315 BC communicator;
316 communicator.template build<T>(OwnerToAllInterface);
317 communicator.template forward<CopyGatherScatter<T> >(source,dest);
318 communicator.free();
319 }
320
327 template<class T>
328 void copyCopyToAll (const T& source, T& dest) const
329 {
330 if (!CopyToAllInterfaceBuilt)
331 buildCopyToAllInterface ();
332 BC communicator;
333 communicator.template build<T>(CopyToAllInterface);
334 communicator.template forward<CopyGatherScatter<T> >(source,dest);
335 communicator.free();
336 }
337
344 template<class T>
345 void addOwnerOverlapToAll (const T& source, T& dest) const
346 {
347 if (!OwnerOverlapToAllInterfaceBuilt)
348 buildOwnerOverlapToAllInterface ();
349 BC communicator;
350 communicator.template build<T>(OwnerOverlapToAllInterface);
351 communicator.template forward<AddGatherScatter<T> >(source,dest);
352 communicator.free();
353 }
354
361 template<class T>
362 void addOwnerCopyToAll (const T& source, T& dest) const
363 {
364 if (!OwnerCopyToAllInterfaceBuilt)
365 buildOwnerCopyToAllInterface ();
366 BC communicator;
367 communicator.template build<T>(OwnerCopyToAllInterface);
368 communicator.template forward<AddGatherScatter<T> >(source,dest);
369 communicator.free();
370 }
371
378 template<class T>
379 void addOwnerCopyToOwnerCopy (const T& source, T& dest) const
380 {
381 if (!OwnerCopyToOwnerCopyInterfaceBuilt)
382 buildOwnerCopyToOwnerCopyInterface ();
383 BC communicator;
384 communicator.template build<T>(OwnerCopyToOwnerCopyInterface);
385 communicator.template forward<AddGatherScatter<T> >(source,dest);
386 communicator.free();
387 }
388
389
397 template<class T1, class T2>
398 void dot (const T1& x, const T1& y, T2& result) const
399 {
400 using real_type = typename FieldTraits<typename T1::field_type>::real_type;
401 // set up mask vector
402 if (mask.size()!=static_cast<typename std::vector<double>::size_type>(x.size()))
403 {
404 mask.resize(x.size());
405 for (typename std::vector<double>::size_type i=0; i<mask.size(); i++)
406 mask[i] = 1;
407 for (typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
408 if (i->local().attribute()!=OwnerOverlapCopyAttributeSet::owner)
409 mask[i->local().local()] = 0;
410 }
411 result = T2(0.0);
412
413 for (typename T1::size_type i=0; i<x.size(); i++)
414 result += (x[i]*(y[i]))*static_cast<real_type>(mask[i]);
415 result = cc.sum(result);
416 }
417
424 template<class T1>
425 typename FieldTraits<typename T1::field_type>::real_type norm (const T1& x) const
426 {
427 using real_type = typename FieldTraits<typename T1::field_type>::real_type;
428
429 // set up mask vector
430 if (mask.size()!=static_cast<typename std::vector<double>::size_type>(x.size()))
431 {
432 mask.resize(x.size());
433 for (typename std::vector<double>::size_type i=0; i<mask.size(); i++)
434 mask[i] = 1;
435 for (typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
436 if (i->local().attribute()!=OwnerOverlapCopyAttributeSet::owner)
437 mask[i->local().local()] = 0;
438 }
439 auto result = real_type(0.0);
440 for (typename T1::size_type i=0; i<x.size(); i++)
441 result += Impl::asVector(x[i]).two_norm2()*mask[i];
442 using std::sqrt;
443 return sqrt(cc.sum(result));
444 }
445
447
450
453
457
463 {
464 return pis;
465 }
466
472 {
473 return ri;
474 }
475
481 {
482 return pis;
483 }
484
485
491 {
492 return ri;
493 }
494
495 void buildGlobalLookup()
496 {
497 if(globalLookup_) {
498 if(pis.seqNo()==oldseqNo)
499 // Nothing changed!
500 return;
501 delete globalLookup_;
502 }
503
504 globalLookup_ = new GlobalLookupIndexSet(pis);
505 oldseqNo = pis.seqNo();
506 }
507
508 void buildGlobalLookup(std::size_t size)
509 {
510 if(globalLookup_) {
511 if(pis.seqNo()==oldseqNo)
512 // Nothing changed!
513 return;
514 delete globalLookup_;
515 }
516 globalLookup_ = new GlobalLookupIndexSet(pis, size);
517 oldseqNo = pis.seqNo();
518 }
519
520 void freeGlobalLookup()
521 {
522 delete globalLookup_;
523 globalLookup_=0;
524 }
525
526 const GlobalLookupIndexSet& globalLookup() const
527 {
528 assert(globalLookup_ != 0);
529 return *globalLookup_;
530 }
531
537 template<class T1>
538 void project (T1& x) const
539 {
540 for (typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
541 if (i->local().attribute()==OwnerOverlapCopyAttributeSet::copy)
542 x[i->local().local()] = 0;
543 }
544
556 bool freecomm_ = false)
557 : comm(comm_), cc(comm_), pis(), ri(pis,pis,comm_),
558 OwnerToAllInterfaceBuilt(false), OwnerOverlapToAllInterfaceBuilt(false),
559 OwnerCopyToAllInterfaceBuilt(false), OwnerCopyToOwnerCopyInterfaceBuilt(false),
560 CopyToAllInterfaceBuilt(false), globalLookup_(0), category_(cat_),
561 freecomm(freecomm_)
562 {}
563
573 : comm(MPI_COMM_WORLD), cc(MPI_COMM_WORLD), pis(), ri(pis,pis,MPI_COMM_WORLD),
574 OwnerToAllInterfaceBuilt(false), OwnerOverlapToAllInterfaceBuilt(false),
575 OwnerCopyToAllInterfaceBuilt(false), OwnerCopyToOwnerCopyInterfaceBuilt(false),
576 CopyToAllInterfaceBuilt(false), globalLookup_(0), category_(cat_), freecomm(false)
577 {}
578
587 MPI_Comm comm_,
589 bool freecomm_ = false)
590 : comm(comm_), cc(comm_), OwnerToAllInterfaceBuilt(false),
591 OwnerOverlapToAllInterfaceBuilt(false), OwnerCopyToAllInterfaceBuilt(false),
592 OwnerCopyToOwnerCopyInterfaceBuilt(false), CopyToAllInterfaceBuilt(false),
593 globalLookup_(0), category_(cat_), freecomm(freecomm_)
594 {
595 // set up an ISTL index set
596 pis.beginResize();
597 for (localindex_iterator i=indexinfo.localIndices().begin(); i!=indexinfo.localIndices().end(); ++i)
598 {
599 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::owner)
600 pis.add(std::get<0>(*i),LI(std::get<1>(*i),OwnerOverlapCopyAttributeSet::owner,true));
601 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::overlap)
602 pis.add(std::get<0>(*i),LI(std::get<1>(*i),OwnerOverlapCopyAttributeSet::overlap,true));
603 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::copy)
604 pis.add(std::get<0>(*i),LI(std::get<1>(*i),OwnerOverlapCopyAttributeSet::copy,true));
605 // std::cout << cc.rank() << ": adding index " << std::get<0>(*i) << " " << std::get<1>(*i) << " " << std::get<2>(*i) << std::endl;
606 }
607 pis.endResize();
608
609 // build remote indices WITHOUT communication
610 // std::cout << cc.rank() << ": build remote indices" << std::endl;
611 ri.setIndexSets(pis,pis,cc);
612 if (indexinfo.remoteIndices().size()>0)
613 {
614 remoteindex_iterator i=indexinfo.remoteIndices().begin();
615 int p = std::get<0>(*i);
616 RILM modifier = ri.template getModifier<false,true>(p);
617 typename PIS::const_iterator pi=pis.begin();
618 for ( ; i!=indexinfo.remoteIndices().end(); ++i)
619 {
620 // handle processor change
621 if (p!=std::get<0>(*i))
622 {
623 p = std::get<0>(*i);
624 modifier = ri.template getModifier<false,true>(p);
625 pi=pis.begin();
626 }
627
628 // position to correct entry in parallel index set
629 while (pi->global()!=std::get<1>(*i) && pi!=pis.end())
630 ++pi;
631 if (pi==pis.end())
632 DUNE_THROW(ISTLError,"OwnerOverlapCopyCommunication: global index not in index set");
633
634 // insert entry
635 // std::cout << cc.rank() << ": adding remote index " << std::get<0>(*i) << " " << std::get<1>(*i) << " " << std::get<2>(*i) << std::endl;
636 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::owner)
637 modifier.insert(RX(OwnerOverlapCopyAttributeSet::owner,&(*pi)));
638 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::overlap)
639 modifier.insert(RX(OwnerOverlapCopyAttributeSet::overlap,&(*pi)));
640 if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::copy)
641 modifier.insert(RX(OwnerOverlapCopyAttributeSet::copy,&(*pi)));
642 }
643 }else{
644 // Force remote indices to be synced!
645 ri.template getModifier<false,true>(0);
646 }
647 }
648
649 // destructor: free memory in some objects
651 {
652 ri.free();
653 if (OwnerToAllInterfaceBuilt) OwnerToAllInterface.free();
654 if (OwnerOverlapToAllInterfaceBuilt) OwnerOverlapToAllInterface.free();
655 if (OwnerCopyToAllInterfaceBuilt) OwnerCopyToAllInterface.free();
656 if (OwnerCopyToOwnerCopyInterfaceBuilt) OwnerCopyToOwnerCopyInterface.free();
657 if (CopyToAllInterfaceBuilt) CopyToAllInterface.free();
658 if (globalLookup_) delete globalLookup_;
659 if (freecomm && (comm != MPI_COMM_NULL))
660 {
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 MPI_Comm_free(&comm);
668 }
669 }
670 }
671
672 private:
674 {}
675 MPI_Comm comm;
676 Communication<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:44
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:111
Specialization of Communication for MPI.
Definition: mpicommunication.hh:108
T sum(const T &in) const
Compute the sum of the argument over all processes and return the result in every process....
Definition: mpicommunication.hh:208
A constant random access iterator for the Dune::ArrayList class.
Definition: arraylist.hh:368
A set consisting only of one item.
Definition: enumset.hh:61
derive error class from the base class in common
Definition: istlexception.hh:19
Information about the index distribution.
Definition: owneroverlapcopy.hh:78
std::tuple< GlobalIdType, LocalIdType, int > IndexTripel
A triple describing a local index.
Definition: owneroverlapcopy.hh:92
void addRemoteIndex(const RemoteIndexTripel &x)
Add a new remote index triple to the set of remote indices.
Definition: owneroverlapcopy.hh:120
G GlobalIdType
The type of the global index.
Definition: owneroverlapcopy.hh:81
const std::set< IndexTripel > & localIndices() const
Get the set of indices local to the process.
Definition: owneroverlapcopy.hh:133
const std::set< RemoteIndexTripel > & remoteIndices() const
Get the set of remote indices.
Definition: owneroverlapcopy.hh:142
L LocalIdType
The type of the local index.
Definition: owneroverlapcopy.hh:84
void clear()
Remove all indices from the sets.
Definition: owneroverlapcopy.hh:150
void addLocalIndex(const IndexTripel &x)
Add a new index triple to the set of local indices.
Definition: owneroverlapcopy.hh:106
std::tuple< int, GlobalIdType, int > RemoteIndexTripel
A triple describing a remote index.
Definition: owneroverlapcopy.hh:99
Communication interface between remote and local indices.
Definition: interface.hh:218
A class setting up standard communication for a two-valued attribute set with owner/overlap/copy sema...
Definition: owneroverlapcopy.hh:174
FieldTraits< typenameT1::field_type >::real_type norm(const T1 &x) const
Compute the global Euclidean norm of a vector.
Definition: owneroverlapcopy.hh:425
OwnerOverlapCopyCommunication(const IndexInfoFromGrid< GlobalIdType, LocalIdType > &indexinfo, MPI_Comm comm_, SolverCategory::Category cat_=SolverCategory::overlapping, bool freecomm_=false)
Constructor.
Definition: owneroverlapcopy.hh:586
SolverCategory::Category category() const
Get Solver Category.
Definition: owneroverlapcopy.hh:295
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:379
RemoteIndices & remoteIndices()
Get the underlying remote indices.
Definition: owneroverlapcopy.hh:490
const ParallelIndexSet & indexSet() const
Get the underlying parallel index set.
Definition: owneroverlapcopy.hh:462
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:345
Dune::RemoteIndices< PIS > RemoteIndices
The type of the remote indices.
Definition: owneroverlapcopy.hh:452
void project(T1 &x) const
Set vector to zero at copy dofs.
Definition: owneroverlapcopy.hh:538
void copyCopyToAll(const T &source, T &dest) const
Communicate values from copy data points to all other data points.
Definition: owneroverlapcopy.hh:328
Dune::GlobalLookupIndexSet< ParallelIndexSet > GlobalLookupIndexSet
The type of the reverse lookup of indices.
Definition: owneroverlapcopy.hh:456
OwnerOverlapCopyCommunication(MPI_Comm comm_, SolverCategory::Category cat_=SolverCategory::overlapping, bool freecomm_=false)
Construct the communication without any indices.
Definition: owneroverlapcopy.hh:554
ParallelIndexSet & indexSet()
Get the underlying parallel index set.
Definition: owneroverlapcopy.hh:480
void dot(const T1 &x, const T1 &y, T2 &result) const
Compute a global dot product of two vectors.
Definition: owneroverlapcopy.hh:398
OwnerOverlapCopyCommunication(SolverCategory::Category cat_=SolverCategory::overlapping)
Construct the communication without any indices using MPI_COMM_WORLD.
Definition: owneroverlapcopy.hh:572
void copyOwnerToAll(const T &source, T &dest) const
Communicate values from owner data points to all other data points.
Definition: owneroverlapcopy.hh:311
const RemoteIndices & remoteIndices() const
Get the underlying remote indices.
Definition: owneroverlapcopy.hh:471
friend void loadMatrixMarket(M &, const std::string &, OwnerOverlapCopyCommunication< G, L > &, bool)
Load a parallel matrix/vector stored in matrix market format.
Definition: matrixmarket.hh:1269
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:362
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > ParallelIndexSet
The type of the parallel index set.
Definition: owneroverlapcopy.hh:449
An index present on the local process with an additional attribute flag.
Definition: plocalindex.hh:52
Modifier for adding and/or deleting remote indices from the remote index list.
Definition: remoteindices.hh:550
Information about an index residing on another processor.
Definition: remoteindices.hh:74
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:470
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:983
void free()
Free the index lists.
Definition: remoteindices.hh:1428
void insert(const RemoteIndex &index)
Insert an index to the list.
Definition: remoteindices.hh:1604
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:501
#define DUNE_THROW(E, m)
Definition: exceptions.hh:218
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:13
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
Classes describing a distributed indexset.
V::value_type IndexedType
The type we get at each index with operator[].
Definition: communicator.hh:147
Attribute set for overlapping Schwarz.
Definition: owneroverlapcopy.hh:59
gather/scatter callback for communication
Definition: owneroverlapcopy.hh:204
Category
Definition: solvercategory.hh:23
@ overlapping
Category for overlapping solvers.
Definition: solvercategory.hh:29
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Nov 24, 23:30, 2024)