dune-istl  2.5.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/mpicollectivecommunication.hh>
28 #endif
29 
30 #include "solvercategory.hh"
31 #include "istlexception.hh"
32 #include <dune/common/parallel/collectivecommunication.hh>
34 
35 template<int dim, template<class,class> class Comm>
36 void testRedistributed(int s);
37 
38 
39 namespace 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 
104  void addLocalIndex (const IndexTripel& x)
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 
118  void addRemoteIndex (const RemoteIndexTripel& x)
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
180  typedef typename IndexInfoFromGrid<GlobalIdType,LocalIdType>::RemoteIndexTripel RemoteIndexTripel;
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  typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::overlap>,AttributeSet> OwnerOverlapSet;
236  typedef Combine<OwnerOverlapSet,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,AttributeSet> AllSet;
237  OwnerOverlapSet sourceFlags;
238  AllSet destFlags;
239  OwnerOverlapToAllInterface.build(ri,sourceFlags,destFlags);
240  OwnerOverlapToAllInterfaceBuilt = true;
241  }
242 
244  {
245  if (OwnerToAllInterfaceBuilt)
246  OwnerToAllInterface.free();
247  OwnerSet sourceFlags;
248  AllSet destFlags;
249  OwnerToAllInterface.build(ri,sourceFlags,destFlags);
250  OwnerToAllInterfaceBuilt = true;
251  }
252 
254  {
255  if (OwnerCopyToAllInterfaceBuilt)
256  OwnerCopyToAllInterface.free();
257  typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,AttributeSet> OwnerCopySet;
258  typedef Combine<OwnerCopySet,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::overlap>,AttributeSet> AllSet;
259  OwnerCopySet sourceFlags;
260  AllSet destFlags;
261  OwnerCopyToAllInterface.build(ri,sourceFlags,destFlags);
262  OwnerCopyToAllInterfaceBuilt = true;
263  }
264 
266  {
267  if (OwnerCopyToOwnerCopyInterfaceBuilt)
268  OwnerCopyToOwnerCopyInterface.free();
269  typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,AttributeSet> OwnerCopySet;
270  OwnerCopySet sourceFlags;
271  OwnerCopySet destFlags;
272  OwnerCopyToOwnerCopyInterface.build(ri,sourceFlags,destFlags);
273  OwnerCopyToOwnerCopyInterfaceBuilt = true;
274  }
275 
277  {
278  if (CopyToAllInterfaceBuilt)
279  CopyToAllInterface.free();
280  CopySet sourceFlags;
281  AllSet destFlags;
282  CopyToAllInterface.build(ri,sourceFlags,destFlags);
283  CopyToAllInterfaceBuilt = true;
284  }
285 
286  public:
287 
292  category = set;
293  }
294 
300  return category;
301  }
302 
303  const CollectiveCommunication<MPI_Comm>& communicator() const
304  {
305  return cc;
306  }
307 
314  template<class T>
315  void copyOwnerToAll (const T& source, T& dest) const
316  {
317  if (!OwnerToAllInterfaceBuilt)
318  buildOwnerToAllInterface ();
319  BC communicator;
320  communicator.template build<T>(OwnerToAllInterface);
321  communicator.template forward<CopyGatherScatter<T> >(source,dest);
322  communicator.free();
323  }
324 
331  template<class T>
332  void copyCopyToAll (const T& source, T& dest) const
333  {
334  if (!CopyToAllInterfaceBuilt)
335  buildCopyToAllInterface ();
336  BC communicator;
337  communicator.template build<T>(CopyToAllInterface);
338  communicator.template forward<CopyGatherScatter<T> >(source,dest);
339  communicator.free();
340  }
341 
348  template<class T>
349  void addOwnerOverlapToAll (const T& source, T& dest) const
350  {
351  if (!OwnerOverlapToAllInterfaceBuilt)
352  buildOwnerOverlapToAllInterface ();
353  BC communicator;
354  communicator.template build<T>(OwnerOverlapToAllInterface);
355  communicator.template forward<AddGatherScatter<T> >(source,dest);
356  communicator.free();
357  }
358 
365  template<class T>
366  void addOwnerCopyToAll (const T& source, T& dest) const
367  {
368  if (!OwnerCopyToAllInterfaceBuilt)
369  buildOwnerCopyToAllInterface ();
370  BC communicator;
371  communicator.template build<T>(OwnerCopyToAllInterface);
372  communicator.template forward<AddGatherScatter<T> >(source,dest);
373  communicator.free();
374  }
375 
382  template<class T>
383  void addOwnerCopyToOwnerCopy (const T& source, T& dest) const
384  {
385  if (!OwnerCopyToOwnerCopyInterfaceBuilt)
386  buildOwnerCopyToOwnerCopyInterface ();
387  BC communicator;
388  communicator.template build<T>(OwnerCopyToOwnerCopyInterface);
389  communicator.template forward<AddGatherScatter<T> >(source,dest);
390  communicator.free();
391  }
392 
393 
401  template<class T1, class T2>
402  void dot (const T1& x, const T1& y, T2& result) const
403  {
404  // set up mask vector
405  if (mask.size()!=static_cast<typename std::vector<double>::size_type>(x.size()))
406  {
407  mask.resize(x.size());
408  for (typename std::vector<double>::size_type i=0; i<mask.size(); i++)
409  mask[i] = 1;
410  for (typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
411  if (i->local().attribute()!=OwnerOverlapCopyAttributeSet::owner)
412  mask[i->local().local()] = 0;
413  }
414  result = T2(0.0);
415 
416  for (typename T1::size_type i=0; i<x.size(); i++)
417  result += x[i]*(y[i])*mask[i];
418  result = cc.sum(result);
419  return;
420  }
421 
428  template<class T1>
429  typename FieldTraits<typename T1::field_type>::real_type norm (const T1& x) const
430  {
431  // set up mask vector
432  if (mask.size()!=static_cast<typename std::vector<double>::size_type>(x.size()))
433  {
434  mask.resize(x.size());
435  for (typename std::vector<double>::size_type i=0; i<mask.size(); i++)
436  mask[i] = 1;
437  for (typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
438  if (i->local().attribute()!=OwnerOverlapCopyAttributeSet::owner)
439  mask[i->local().local()] = 0;
440  }
441  typename T1::field_type result = typename T1::field_type(0.0);
442  for (typename T1::size_type i=0; i<x.size(); i++)
443  result += x[i].two_norm2()*mask[i];
444  return static_cast<double>(sqrt(cc.sum(result)));
445  }
446 
447  typedef Dune::EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy> CopyFlags;
448 
450  typedef Dune::ParallelIndexSet<GlobalIdType,LI,512> ParallelIndexSet;
451 
453  typedef Dune::RemoteIndices<PIS> RemoteIndices;
454 
457  typedef Dune::GlobalLookupIndexSet<ParallelIndexSet> GlobalLookupIndexSet;
458 
463  const ParallelIndexSet& indexSet() const
464  {
465  return pis;
466  }
467 
472  const RemoteIndices& remoteIndices() const
473  {
474  return ri;
475  }
476 
481  ParallelIndexSet& indexSet()
482  {
483  return pis;
484  }
485 
486 
491  RemoteIndices& remoteIndices()
492  {
493  return ri;
494  }
495 
497  {
498  if(globalLookup_) {
499  if(pis.seqNo()==oldseqNo)
500  // Nothing changed!
501  return;
502  delete globalLookup_;
503  }
504 
505  globalLookup_ = new GlobalLookupIndexSet(pis);
506  oldseqNo = pis.seqNo();
507  }
508 
509  void buildGlobalLookup(std::size_t size)
510  {
511  if(globalLookup_) {
512  if(pis.seqNo()==oldseqNo)
513  // Nothing changed!
514  return;
515  delete globalLookup_;
516  }
517  globalLookup_ = new GlobalLookupIndexSet(pis, size);
518  oldseqNo = pis.seqNo();
519  }
520 
522  {
523  delete globalLookup_;
524  globalLookup_=0;
525  }
526 
527  const GlobalLookupIndexSet& globalLookup() const
528  {
529  assert(globalLookup_ != 0);
530  return *globalLookup_;
531  }
532 
538  template<class T1>
539  void project (T1& x) const
540  {
541  for (typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
542  if (i->local().attribute()==OwnerOverlapCopyAttributeSet::copy)
543  x[i->local().local()] = 0;
544  }
545 
557  bool freecomm_ = false)
558  : comm(comm_), cc(comm_), pis(), ri(pis,pis,comm_),
559  OwnerToAllInterfaceBuilt(false), OwnerOverlapToAllInterfaceBuilt(false),
560  OwnerCopyToAllInterfaceBuilt(false), OwnerCopyToOwnerCopyInterfaceBuilt(false),
561  CopyToAllInterfaceBuilt(false), globalLookup_(0), category(cat_),
562  freecomm(freecomm_)
563  {}
564 
574  : comm(MPI_COMM_WORLD), cc(MPI_COMM_WORLD), pis(), ri(pis,pis,MPI_COMM_WORLD),
575  OwnerToAllInterfaceBuilt(false), OwnerOverlapToAllInterfaceBuilt(false),
576  OwnerCopyToAllInterfaceBuilt(false), OwnerCopyToOwnerCopyInterfaceBuilt(false),
577  CopyToAllInterfaceBuilt(false), globalLookup_(0), category(cat_), freecomm(false)
578  {}
579 
588  MPI_Comm comm_,
590  bool freecomm_ = false)
591  : comm(comm_), cc(comm_), OwnerToAllInterfaceBuilt(false),
592  OwnerOverlapToAllInterfaceBuilt(false), OwnerCopyToAllInterfaceBuilt(false),
593  OwnerCopyToOwnerCopyInterfaceBuilt(false), CopyToAllInterfaceBuilt(false),
594  globalLookup_(0), category(cat_), freecomm(freecomm_)
595  {
596  // set up an ISTL index set
597  pis.beginResize();
598  for (localindex_iterator i=indexinfo.localIndices().begin(); i!=indexinfo.localIndices().end(); ++i)
599  {
600  if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::owner)
601  pis.add(std::get<0>(*i),LI(std::get<1>(*i),OwnerOverlapCopyAttributeSet::owner,true));
602  if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::overlap)
603  pis.add(std::get<0>(*i),LI(std::get<1>(*i),OwnerOverlapCopyAttributeSet::overlap,true));
604  if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::copy)
605  pis.add(std::get<0>(*i),LI(std::get<1>(*i),OwnerOverlapCopyAttributeSet::copy,true));
606  // std::cout << cc.rank() << ": adding index " << std::get<0>(*i) << " " << std::get<1>(*i) << " " << std::get<2>(*i) << std::endl;
607  }
608  pis.endResize();
609 
610  // build remote indices WITHOUT communication
611  // std::cout << cc.rank() << ": build remote indices" << std::endl;
612  ri.setIndexSets(pis,pis,cc);
613  if (indexinfo.remoteIndices().size()>0)
614  {
615  remoteindex_iterator i=indexinfo.remoteIndices().begin();
616  int p = std::get<0>(*i);
617  RILM modifier = ri.template getModifier<false,true>(p);
618  typename PIS::const_iterator pi=pis.begin();
619  for ( ; i!=indexinfo.remoteIndices().end(); ++i)
620  {
621  // handle processor change
622  if (p!=std::get<0>(*i))
623  {
624  p = std::get<0>(*i);
625  modifier = ri.template getModifier<false,true>(p);
626  pi=pis.begin();
627  }
628 
629  // position to correct entry in parallel index set
630  while (pi->global()!=std::get<1>(*i) && pi!=pis.end())
631  ++pi;
632  if (pi==pis.end())
633  DUNE_THROW(ISTLError,"OwnerOverlapCopyCommunication: global index not in index set");
634 
635  // insert entry
636  // std::cout << cc.rank() << ": adding remote index " << std::get<0>(*i) << " " << std::get<1>(*i) << " " << std::get<2>(*i) << std::endl;
637  if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::owner)
638  modifier.insert(RX(OwnerOverlapCopyAttributeSet::owner,&(*pi)));
639  if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::overlap)
640  modifier.insert(RX(OwnerOverlapCopyAttributeSet::overlap,&(*pi)));
641  if (std::get<2>(*i)==OwnerOverlapCopyAttributeSet::copy)
642  modifier.insert(RX(OwnerOverlapCopyAttributeSet::copy,&(*pi)));
643  }
644  }else{
645  // Force remote indices to be synced!
646  ri.template getModifier<false,true>(0);
647  }
648  }
649 
650  // destructor: free memory in some objects
652  {
653  ri.free();
654  if (OwnerToAllInterfaceBuilt) OwnerToAllInterface.free();
655  if (OwnerOverlapToAllInterfaceBuilt) OwnerOverlapToAllInterface.free();
656  if (OwnerCopyToAllInterfaceBuilt) OwnerCopyToAllInterface.free();
657  if (OwnerCopyToOwnerCopyInterfaceBuilt) OwnerCopyToOwnerCopyInterface.free();
658  if (CopyToAllInterfaceBuilt) CopyToAllInterface.free();
659  if (globalLookup_) delete globalLookup_;
660  if (freecomm==true)
661  if(comm!=MPI_COMM_NULL)
662  {
663 #ifdef MPI_2
664  // If it is possible to query whether MPI_Finalize
665  // was called, only free the communicator before
666  // calling MPI_Finalize.
667  int wasFinalized = 0;
668  MPI_Finalized( &wasFinalized );
669  if(!wasFinalized)
670 #endif
671  MPI_Comm_free(&comm);
672  }
673  }
674 
675  private:
677  {}
678  MPI_Comm comm;
679  CollectiveCommunication<MPI_Comm> cc;
680  PIS pis;
681  RI ri;
682  mutable IF OwnerToAllInterface;
683  mutable bool OwnerToAllInterfaceBuilt;
684  mutable IF OwnerOverlapToAllInterface;
685  mutable bool OwnerOverlapToAllInterfaceBuilt;
686  mutable IF OwnerCopyToAllInterface;
687  mutable bool OwnerCopyToAllInterfaceBuilt;
688  mutable IF OwnerCopyToOwnerCopyInterface;
689  mutable bool OwnerCopyToOwnerCopyInterfaceBuilt;
690  mutable IF CopyToAllInterface;
691  mutable bool CopyToAllInterfaceBuilt;
692  mutable std::vector<double> mask;
693  int oldseqNo;
694  GlobalLookupIndexSet* globalLookup_;
695  SolverCategory::Category category;
696  bool freecomm;
697  };
698 
699 #endif
700 
701 
704 } // end namespace
705 
706 #endif
Definition: owneroverlapcopy.hh:59
Dune::GlobalLookupIndexSet< ParallelIndexSet > GlobalLookupIndexSet
The type of the reverse lookup of indices.
Definition: owneroverlapcopy.hh:457
void addRemoteIndex(const RemoteIndexTripel &x)
Add a new remote index triple to the set of remote indices.
Definition: owneroverlapcopy.hh:118
Dune::RemoteIndexListModifier< PIS, typename RI::Allocator, false > RILM
Definition: owneroverlapcopy.hh:188
const GlobalLookupIndexSet & globalLookup() const
Definition: owneroverlapcopy.hh:527
Dune::RemoteIndices< PIS > RI
Definition: owneroverlapcopy.hh:187
CommPolicy< T >::IndexedType V
Definition: owneroverlapcopy.hh:218
Category
Definition: solvercategory.hh:19
Provides classes for reading and writing MatrixMarket Files with an extension for parallel matrices...
FieldTraits< typename T1::field_type >::real_type norm(const T1 &x) const
Compute the global euclidian norm of a vector.
Definition: owneroverlapcopy.hh:429
Information about the index distribution.
Definition: owneroverlapcopy.hh:75
void buildOwnerToAllInterface() const
Definition: owneroverlapcopy.hh:243
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:383
SolverCategory::Category getSolverCategory() const
Get Solver Category.
Definition: owneroverlapcopy.hh:299
Categories for the solvers.
Definition: solvercategory.hh:17
void setSolverCategory(SolverCategory set)
Set right Solver Category (default is overlapping).
Definition: owneroverlapcopy.hh:291
gather/scatter callback for communcation
Definition: owneroverlapcopy.hh:201
Attribute set for overlapping schwarz.
Definition: owneroverlapcopy.hh:56
Dune::RemoteIndices< PIS > RemoteIndices
The type of the remote indices.
Definition: owneroverlapcopy.hh:453
Dune::AllSet< AttributeSet > AllSet
Definition: owneroverlapcopy.hh:195
void dot(const T1 &x, const T1 &y, T2 &result) const
Compute a global dot product of two vectors.
Definition: owneroverlapcopy.hh:402
Combine< EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::owner >, EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::overlap >, AttributeSet > OwnerOverlapSet
Definition: owneroverlapcopy.hh:194
OwnerOverlapCopyCommunication(SolverCategory::Category cat_=SolverCategory::overlapping)
Construct the communication without any indices using MPI_COMM_WORLD.
Definition: owneroverlapcopy.hh:573
void addLocalIndex(const IndexTripel &x)
Add a new index triple to the set of local indices.
Definition: owneroverlapcopy.hh:104
G GlobalIdType
The type of the global index.
Definition: owneroverlapcopy.hh:79
Dune::BufferedCommunicator BC
Definition: owneroverlapcopy.hh:190
void copyOwnerToAll(const T &source, T &dest) const
Communicate values from owner data points to all other data points.
Definition: owneroverlapcopy.hh:315
L LocalIdType
The type of the local index.
Definition: owneroverlapcopy.hh:82
void copyCopyToAll(const T &source, T &dest) const
Communicate values from copy data points to all other data points.
Definition: owneroverlapcopy.hh:332
AttributeSet
Definition: owneroverlapcopy.hh:58
const ParallelIndexSet & indexSet() const
Get the underlying parallel index set.
Definition: owneroverlapcopy.hh:463
void buildOwnerCopyToAllInterface() const
Definition: owneroverlapcopy.hh:253
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > PIS
Definition: owneroverlapcopy.hh:186
RI::RemoteIndex RX
Definition: owneroverlapcopy.hh:189
static V gather(const T &a, std::size_t i)
Definition: owneroverlapcopy.hh:205
CommPolicy< T >::IndexedType V
Definition: owneroverlapcopy.hh:203
void project(T1 &x) const
Set vector to zero at copy dofs.
Definition: owneroverlapcopy.hh:539
void loadMatrixMarket(M &matrix, const std::string &filename, OwnerOverlapCopyCommunication< G, L > &comm, bool readIndices=true)
Load a parallel matrix/vector stored in matrix market format.
Definition: matrixmarket.hh:1031
Dune::Interface IF
Definition: owneroverlapcopy.hh:191
void buildCopyToAllInterface() const
Definition: owneroverlapcopy.hh:276
Definition: owneroverlapcopy.hh:59
std::tuple< int, GlobalIdType, int > RemoteIndexTripel
A triple describing a remote index.
Definition: owneroverlapcopy.hh:97
void buildGlobalLookup()
Definition: owneroverlapcopy.hh:496
OwnerOverlapCopyCommunication(MPI_Comm comm_, SolverCategory::Category cat_=SolverCategory::overlapping, bool freecomm_=false)
Construct the communication without any indices.
Definition: owneroverlapcopy.hh:555
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:349
EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::copy > CopySet
Definition: owneroverlapcopy.hh:193
~OwnerOverlapCopyCommunication()
Definition: owneroverlapcopy.hh:651
Category for overlapping solvers.
Definition: solvercategory.hh:25
Definition: basearray.hh:19
const std::set< RemoteIndexTripel > & remoteIndices() const
Get the set of remote indices.
Definition: owneroverlapcopy.hh:140
void buildOwnerOverlapToAllInterface() const
Definition: owneroverlapcopy.hh:231
const CollectiveCommunication< MPI_Comm > & communicator() const
Definition: owneroverlapcopy.hh:303
RemoteIndices & remoteIndices()
Get the underlying remote indices.
Definition: owneroverlapcopy.hh:491
Definition: owneroverlapcopy.hh:59
void buildGlobalLookup(std::size_t size)
Definition: owneroverlapcopy.hh:509
static void scatter(T &a, V v, std::size_t i)
Definition: owneroverlapcopy.hh:225
static V gather(const T &a, std::size_t i)
Definition: owneroverlapcopy.hh:220
Dune::EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::copy > CopyFlags
Definition: owneroverlapcopy.hh:447
ParallelIndexSet & indexSet()
Get the underlying parallel index set.
Definition: owneroverlapcopy.hh:481
void buildOwnerCopyToOwnerCopyInterface() const
Definition: owneroverlapcopy.hh:265
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:366
const std::set< IndexTripel > & localIndices() const
Get the set of indices local to the process.
Definition: owneroverlapcopy.hh:131
void testRedistributed(int s)
A class setting up standard communication for a two-valued attribute set with owner/overlap/copy sema...
Definition: owneroverlapcopy.hh:171
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > ParallelIndexSet
The type of the parallel index set.
Definition: owneroverlapcopy.hh:450
derive error class from the base class in common
Definition: istlexception.hh:16
void clear()
Remove all indices from the sets.
Definition: owneroverlapcopy.hh:148
OwnerOverlapCopyCommunication(const IndexInfoFromGrid< GlobalIdType, LocalIdType > &indexinfo, MPI_Comm comm_, SolverCategory::Category cat_=SolverCategory::overlapping, bool freecomm_=false)
Constructor.
Definition: owneroverlapcopy.hh:587
std::tuple< GlobalIdType, LocalIdType, int > IndexTripel
A triple describing a local index.
Definition: owneroverlapcopy.hh:90
static void scatter(T &a, V v, std::size_t i)
Definition: owneroverlapcopy.hh:210
const RemoteIndices & remoteIndices() const
Get the underlying remote indices.
Definition: owneroverlapcopy.hh:472
EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::owner > OwnerSet
Definition: owneroverlapcopy.hh:192
void freeGlobalLookup()
Definition: owneroverlapcopy.hh:521