3#ifndef DUNE_GRID_YASPGRID_HH
4#define DUNE_GRID_YASPGRID_HH
21#include <dune/common/power.hh>
22#include <dune/common/bigunsignedint.hh>
23#include <dune/common/typetraits.hh>
24#include <dune/common/reservedvector.hh>
25#include <dune/common/parallel/collectivecommunication.hh>
26#include <dune/common/parallel/mpihelper.hh>
27#include <dune/common/deprecated.hh>
28#include <dune/geometry/genericgeometry/topologytypes.hh>
29#include <dune/geometry/axisalignedcubegeometry.hh>
35#include <dune/common/parallel/mpicollectivecommunication.hh>
56 template<
int dim,
class Coordinates>
class YaspGrid;
57 template<
int mydim,
int cdim,
class Gr
idImp>
class YaspGeometry;
58 template<
int codim,
int dim,
class Gr
idImp>
class YaspEntity;
61 template<
int codim, PartitionIteratorType pitype,
class Gr
idImp>
class YaspLevelIterator;
65 template<
class Gr
idImp,
bool isLeafIndexSet>
class YaspIndexSet;
88 template<
int dim,
class Coordinates>
92 typedef CollectiveCommunication<MPI_Comm>
CCType;
94 typedef CollectiveCommunication<No_Comm>
CCType;
111 bigunsignedint<dim*yaspgrid_dim_bits+yaspgrid_level_bits+dim>,
113 bigunsignedint<dim*yaspgrid_dim_bits+yaspgrid_level_bits+dim>,
121 template<
int dim,
int codim>
122 struct YaspCommunicateMeta {
123 template<
class G,
class DataHandle>
126 if (data.contains(dim,codim))
128 g.template communicateCodim<DataHandle,codim>(data,iftype,dir,level);
130 YaspCommunicateMeta<dim,codim-1>::comm(g,data,iftype,dir,level);
135 struct YaspCommunicateMeta<dim,0> {
136 template<
class G,
class DataHandle>
137 static void comm (
const G& g, DataHandle& data, InterfaceType iftype, CommunicationDirection dir,
int level)
139 if (data.contains(dim,0))
140 g.template communicateCodim<DataHandle,0>(data,iftype,dir,level);
162 template<
int dim,
class Coordinates = Equ
idistantCoordinates<
double, dim> >
167 template<
int, PartitionIteratorType,
typename>
179 typedef typename Coordinates::ctype
ctype;
202 std::array<YGrid, dim+1> overlapfront;
203 std::array<YGridComponent<Coordinates>, StaticPower<2,dim>::power> overlapfront_data;
204 std::array<YGrid, dim+1> overlap;
205 std::array<YGridComponent<Coordinates>, StaticPower<2,dim>::power> overlap_data;
206 std::array<YGrid, dim+1> interiorborder;
207 std::array<YGridComponent<Coordinates>, StaticPower<2,dim>::power> interiorborder_data;
208 std::array<YGrid, dim+1> interior;
209 std::array<YGridComponent<Coordinates>, StaticPower<2,dim>::power> interior_data;
211 std::array<YGridList<Coordinates>,dim+1> send_overlapfront_overlapfront;
212 std::array<std::deque<Intersection>, StaticPower<2,dim>::power> send_overlapfront_overlapfront_data;
213 std::array<YGridList<Coordinates>,dim+1> recv_overlapfront_overlapfront;
214 std::array<std::deque<Intersection>, StaticPower<2,dim>::power> recv_overlapfront_overlapfront_data;
216 std::array<YGridList<Coordinates>,dim+1> send_overlap_overlapfront;
217 std::array<std::deque<Intersection>, StaticPower<2,dim>::power> send_overlap_overlapfront_data;
218 std::array<YGridList<Coordinates>,dim+1> recv_overlapfront_overlap;
219 std::array<std::deque<Intersection>, StaticPower<2,dim>::power> recv_overlapfront_overlap_data;
221 std::array<YGridList<Coordinates>,dim+1> send_interiorborder_interiorborder;
222 std::array<std::deque<Intersection>, StaticPower<2,dim>::power> send_interiorborder_interiorborder_data;
223 std::array<YGridList<Coordinates>,dim+1> recv_interiorborder_interiorborder;
224 std::array<std::deque<Intersection>, StaticPower<2,dim>::power> recv_interiorborder_interiorborder_data;
226 std::array<YGridList<Coordinates>,dim+1> send_interiorborder_overlapfront;
227 std::array<std::deque<Intersection>, StaticPower<2,dim>::power> send_interiorborder_overlapfront_data;
228 std::array<YGridList<Coordinates>,dim+1> recv_overlapfront_interiorborder;
229 std::array<std::deque<Intersection>, StaticPower<2,dim>::power> recv_overlapfront_interiorborder_data;
241 typedef std::array<int, dim> iTupel;
242 typedef FieldVector<ctype, dim> fTupel;
269 return _coarseSize[i] * (1 << l);
276 for (
int i=0; i<dim; ++i)
305 DUNE_THROW(
GridError,
"level not existing");
330 void makelevel (
const Coordinates& coords, std::bitset<dim> periodic, iTupel o_interior,
int overlap)
332 YGridLevel& g = _levels.back();
333 g.overlapSize = overlap;
337 g.keepOverlap = keep_ovlp;
340 typename std::array<YGridComponent<Coordinates>, StaticPower<2,dim>::power>::iterator overlapfront_it = g.overlapfront_data.begin();
341 typename std::array<YGridComponent<Coordinates>, StaticPower<2,dim>::power>::iterator overlap_it = g.overlap_data.begin();
342 typename std::array<YGridComponent<Coordinates>, StaticPower<2,dim>::power>::iterator interiorborder_it = g.interiorborder_data.begin();
343 typename std::array<YGridComponent<Coordinates>, StaticPower<2,dim>::power>::iterator interior_it = g.interior_data.begin();
345 typename std::array<std::deque<Intersection>, StaticPower<2,dim>::power>::iterator
346 send_overlapfront_overlapfront_it = g.send_overlapfront_overlapfront_data.begin();
347 typename std::array<std::deque<Intersection>, StaticPower<2,dim>::power>::iterator
348 recv_overlapfront_overlapfront_it = g.recv_overlapfront_overlapfront_data.begin();
350 typename std::array<std::deque<Intersection>, StaticPower<2,dim>::power>::iterator
351 send_overlap_overlapfront_it = g.send_overlap_overlapfront_data.begin();
352 typename std::array<std::deque<Intersection>, StaticPower<2,dim>::power>::iterator
353 recv_overlapfront_overlap_it = g.recv_overlapfront_overlap_data.begin();
355 typename std::array<std::deque<Intersection>, StaticPower<2,dim>::power>::iterator
356 send_interiorborder_interiorborder_it = g.send_interiorborder_interiorborder_data.begin();
357 typename std::array<std::deque<Intersection>, StaticPower<2,dim>::power>::iterator
358 recv_interiorborder_interiorborder_it = g.recv_interiorborder_interiorborder_data.begin();
360 typename std::array<std::deque<Intersection>, StaticPower<2,dim>::power>::iterator
361 send_interiorborder_overlapfront_it = g.send_interiorborder_overlapfront_data.begin();
362 typename std::array<std::deque<Intersection>, StaticPower<2,dim>::power>::iterator
363 recv_overlapfront_interiorborder_it = g.recv_overlapfront_interiorborder_data.begin();
366 std::array<int,dim> n;
367 std::fill(n.begin(), n.end(), 0);
370 std::bitset<dim> ovlp_low(0ULL);
371 std::bitset<dim> ovlp_up(0ULL);
377 for (
int i=0; i<dim; i++)
381 s_overlap[i] = g.coords.size(i);
386 o_overlap[i] = o_interior[i]-overlap;
393 if (o_interior[i] - overlap < 0)
397 o_overlap[i] = o_interior[i] - overlap;
402 if (o_overlap[i] + g.coords.size(i) <
globalSize(i))
407 for (
unsigned int codim = 0; codim < dim + 1; codim++)
410 g.overlapfront[codim].setBegin(overlapfront_it);
411 g.overlap[codim].setBegin(overlap_it);
412 g.interiorborder[codim].setBegin(interiorborder_it);
413 g.interior[codim].setBegin(interior_it);
414 g.send_overlapfront_overlapfront[codim].setBegin(send_overlapfront_overlapfront_it);
415 g.recv_overlapfront_overlapfront[codim].setBegin(recv_overlapfront_overlapfront_it);
416 g.send_overlap_overlapfront[codim].setBegin(send_overlap_overlapfront_it);
417 g.recv_overlapfront_overlap[codim].setBegin(recv_overlapfront_overlap_it);
418 g.send_interiorborder_interiorborder[codim].setBegin(send_interiorborder_interiorborder_it);
419 g.recv_interiorborder_interiorborder[codim].setBegin(recv_interiorborder_interiorborder_it);
420 g.send_interiorborder_overlapfront[codim].setBegin(send_interiorborder_overlapfront_it);
421 g.recv_overlapfront_interiorborder[codim].setBegin(recv_overlapfront_interiorborder_it);
424 for (
unsigned int index = 0; index < (1<<dim); index++)
427 std::bitset<dim> r(index);
428 if (r.count() != dim-codim)
432 std::array<int,dim> origin(o_overlap);
433 std::array<int,dim>
size(s_overlap);
437 for (
int i=0; i<dim; i++)
443 for (
int i=0; i<dim; i++)
459 for (
int i=0; i<dim; i++)
463 origin[i] += overlap;
481 for (
int i=0; i<dim; i++)
496 intersections(*overlapfront_it,*overlapfront_it,*send_overlapfront_overlapfront_it, *recv_overlapfront_overlapfront_it);
497 intersections(*overlap_it,*overlapfront_it,*send_overlap_overlapfront_it, *recv_overlapfront_overlap_it);
498 intersections(*interiorborder_it,*interiorborder_it,*send_interiorborder_interiorborder_it,*recv_interiorborder_interiorborder_it);
499 intersections(*interiorborder_it,*overlapfront_it,*send_interiorborder_overlapfront_it,*recv_overlapfront_interiorborder_it);
506 ++send_overlapfront_overlapfront_it;
507 ++recv_overlapfront_overlapfront_it;
508 ++send_overlap_overlapfront_it;
509 ++recv_overlapfront_overlap_it;
510 ++send_interiorborder_interiorborder_it;
511 ++recv_interiorborder_interiorborder_it;
512 ++send_interiorborder_overlapfront_it;
513 ++recv_overlapfront_interiorborder_it;
517 g.overlapfront[codim].finalize(overlapfront_it);
518 g.overlap[codim].finalize(overlap_it);
519 g.interiorborder[codim].finalize(interiorborder_it);
520 g.interior[codim].finalize(interior_it);
521 g.send_overlapfront_overlapfront[codim].finalize(send_overlapfront_overlapfront_it,g.overlapfront[codim]);
522 g.recv_overlapfront_overlapfront[codim].finalize(recv_overlapfront_overlapfront_it,g.overlapfront[codim]);
523 g.send_overlap_overlapfront[codim].finalize(send_overlap_overlapfront_it,g.overlapfront[codim]);
524 g.recv_overlapfront_overlap[codim].finalize(recv_overlapfront_overlap_it,g.overlapfront[codim]);
525 g.send_interiorborder_interiorborder[codim].finalize(send_interiorborder_interiorborder_it,g.overlapfront[codim]);
526 g.recv_interiorborder_interiorborder[codim].finalize(recv_interiorborder_interiorborder_it,g.overlapfront[codim]);
527 g.send_interiorborder_overlapfront[codim].finalize(send_interiorborder_overlapfront_it,g.overlapfront[codim]);
528 g.recv_overlapfront_interiorborder[codim].finalize(recv_overlapfront_interiorborder_it,g.overlapfront[codim]);
541 struct mpifriendly_ygrid {
544 std::fill(origin.begin(), origin.end(), 0);
545 std::fill(size.begin(), size.end(), 0);
547 mpifriendly_ygrid (
const YGridComponent<Coordinates>& grid)
548 : origin(grid.origin()), size(grid.size())
564 std::deque<Intersection>& sendlist, std::deque<Intersection>& recvlist)
569 std::vector<YGridComponent<Coordinates> > send_recvgrid(_torus.
neighbors());
570 std::vector<YGridComponent<Coordinates> > recv_recvgrid(_torus.
neighbors());
571 std::vector<YGridComponent<Coordinates> > send_sendgrid(_torus.
neighbors());
572 std::vector<YGridComponent<Coordinates> > recv_sendgrid(_torus.
neighbors());
575 std::vector<mpifriendly_ygrid> mpifriendly_send_recvgrid(_torus.
neighbors());
576 std::vector<mpifriendly_ygrid> mpifriendly_recv_recvgrid(_torus.
neighbors());
577 std::vector<mpifriendly_ygrid> mpifriendly_send_sendgrid(_torus.
neighbors());
578 std::vector<mpifriendly_ygrid> mpifriendly_recv_sendgrid(_torus.
neighbors());
586 iTupel coord = _torus.
coord();
587 iTupel delta = i.delta();
589 for (
int k=0; k<dim; k++) nb[k] += delta[k];
591 std::fill(v.begin(), v.end(), 0);
593 for (
int k=0; k<dim; k++)
602 if (nb[k]>=_torus.
dims(k))
615 send_sendgrid[i.index()] = sendgrid.
move(v);
616 send_recvgrid[i.index()] = recvgrid.
move(v);
628 mpifriendly_send_sendgrid[i.index()] = mpifriendly_ygrid(send_sendgrid[i.index()]);
629 _torus.
send(i.rank(), &mpifriendly_send_sendgrid[i.index()],
sizeof(mpifriendly_ygrid));
634 _torus.
recv(i.rank(), &mpifriendly_recv_sendgrid[i.index()],
sizeof(mpifriendly_ygrid));
642 mpifriendly_send_recvgrid[i.index()] = mpifriendly_ygrid(send_recvgrid[i.index()]);
643 _torus.
send(i.rank(), &mpifriendly_send_recvgrid[i.index()],
sizeof(mpifriendly_ygrid));
648 _torus.
recv(i.rank(), &mpifriendly_recv_recvgrid[i.index()],
sizeof(mpifriendly_ygrid));
658 mpifriendly_ygrid yg = mpifriendly_recv_recvgrid[i.index()];
660 send_intersection.grid = sendgrid.
intersection(recv_recvgrid[i.index()]);
661 send_intersection.rank = i.rank();
662 send_intersection.distance = i.distance();
663 if (!send_intersection.grid.empty()) sendlist.push_front(send_intersection);
666 yg = mpifriendly_recv_sendgrid[i.index()];
668 recv_intersection.grid = recvgrid.
intersection(recv_sendgrid[i.index()]);
669 recv_intersection.rank = i.rank();
670 recv_intersection.distance = i.distance();
671 if(!recv_intersection.grid.empty()) recvlist.push_back(recv_intersection);
681 Yasp::BinomialTable<dim>::init();
682 Yasp::EntityShiftTable<Yasp::calculate_entity_shift<dim>,dim>
::init();
683 Yasp::EntityShiftTable<Yasp::calculate_entity_move<dim>,dim>
::init();
691 std::array<int, dim> sides;
693 for (
int i=0; i<dim; i++)
696 ((
begin()->overlap[0].dataBegin()->origin(i) == 0)+
697 (
begin()->overlap[0].dataBegin()->origin(i) +
begin()->overlap[0].dataBegin()->size(i)
702 for (
int k=0; k<dim; k++)
705 for (
int l=0; l<dim; l++)
708 offset *=
begin()->overlap[0].dataBegin()->size(l);
710 nBSegments += sides[k]*offset;
738 std::array<int, dim> s,
739 std::bitset<dim> periodic = std::bitset<dim>(0ULL),
743 : ccobj(
comm), _torus(
comm,tag,s,lb), leafIndexSet_(*this),
744 _L(L), _periodic(periodic), _coarseSize(s), _overlap(overlap),
745 keep_ovlp(true), adaptRefCount(0), adaptActive(false)
748 static_assert(std::is_same<Coordinates,EquidistantCoordinates<ctype,dim> >::value,
749 "YaspGrid coordinate container template parameter and given constructor values do not match!");
754 std::fill(o.begin(), o.end(), 0);
755 iTupel o_interior(o);
756 iTupel s_interior(s);
762 for (
int i=0; i<dim; i++)
765 int toosmall = (s_interior[i] <= overlap) &&
766 (periodic[i] || (s_interior[i] != s[i]));
769 MPI_Allreduce(&toosmall, &global, 1, MPI_INT, MPI_LOR,
comm);
776 for (
int i=0; i<dim; i++)
779 iTupel s_overlap(s_interior);
780 for (
int i=0; i<dim; i++)
782 if ((o_interior[i] - overlap > 0) || (periodic[i]))
783 s_overlap[i] += overlap;
784 if ((o_interior[i] + s_interior[i] + overlap <= _coarseSize[i]) || (periodic[i]))
785 s_overlap[i] += overlap;
791 makelevel(cc,periodic,o_interior,overlap);
806 Dune::FieldVector<ctype, dim> upperright,
807 std::array<int, dim> s,
808 std::bitset<dim> periodic = std::bitset<dim>(0ULL),
812 : ccobj(
comm), _torus(
comm,tag,s,lb), leafIndexSet_(*this),
813 _L(upperright - lowerleft),
814 _periodic(periodic), _coarseSize(s), _overlap(overlap),
815 keep_ovlp(true), adaptRefCount(0), adaptActive(false)
818 static_assert(std::is_same<Coordinates,EquidistantOffsetCoordinates<ctype,dim> >::value,
819 "YaspGrid coordinate container template parameter and given constructor values do not match!");
824 std::fill(o.begin(), o.end(), 0);
825 iTupel o_interior(o);
826 iTupel s_interior(s);
832 for (
int i=0; i<dim; i++)
835 int toosmall = (s_interior[i] <= overlap) &&
836 (periodic[i] || (s_interior[i] != s[i]));
839 MPI_Allreduce(&toosmall, &global, 1, MPI_INT, MPI_LOR,
comm);
845 Dune::FieldVector<ctype,dim> extension(upperright);
846 Dune::FieldVector<ctype,dim> h;
847 for (
int i=0; i<dim; i++)
849 extension[i] -= lowerleft[i];
850 h[i] = extension[i] / s[i];
853 iTupel s_overlap(s_interior);
854 for (
int i=0; i<dim; i++)
856 if ((o_interior[i] - overlap > 0) || (periodic[i]))
857 s_overlap[i] += overlap;
858 if ((o_interior[i] + s_interior[i] + overlap <= _coarseSize[i]) || (periodic[i]))
859 s_overlap[i] += overlap;
865 makelevel(cc,periodic,o_interior,overlap);
877 YaspGrid (std::array<std::vector<ctype>, dim> coords,
878 std::bitset<dim> periodic = std::bitset<dim>(0ULL),
882 : ccobj(
comm), _torus(
comm,tag,
Dune::Yasp::sizeArray<dim>(coords),lb),
883 leafIndexSet_(*this), _periodic(periodic), _overlap(overlap),
884 keep_ovlp(true), adaptRefCount(0), adaptActive(false)
886 if (!Dune::Yasp::checkIfMonotonous(coords))
887 DUNE_THROW(
Dune::GridError,
"Setup of a tensorproduct grid requires monotonous sequences of coordinates.");
890 static_assert(std::is_same<Coordinates,TensorProductCoordinates<ctype,dim> >::value,
891 "YaspGrid coordinate container template parameter and given constructor values do not match!");
896 for (
int i=0; i<dim; i++) {
897 _coarseSize[i] = coords[i].size() - 1;
898 _L[i] = coords[i][_coarseSize[i]] - coords[i][0];
902 std::fill(o.begin(), o.end(), 0);
903 iTupel o_interior(o);
904 iTupel s_interior(_coarseSize);
906 _torus.
partition(_torus.
rank(),o,_coarseSize,o_interior,s_interior);
910 for (
int i=0; i<dim; i++)
913 int toosmall = (s_interior[i] <= overlap) &&
914 (periodic[i] || (s_interior[i] != _coarseSize[i]));
917 MPI_Allreduce(&toosmall, &global, 1, MPI_INT, MPI_LOR,
comm);
924 std::array<std::vector<ctype>,dim> newcoords;
925 std::array<int, dim> offset(o_interior);
928 for (
int i=0; i<dim; ++i)
931 typename std::vector<ctype>::iterator
begin = coords[i].begin() + o_interior[i];
932 typename std::vector<ctype>::iterator
end =
begin + s_interior[i] + 1;
936 if (o_interior[i] - overlap > 0)
939 offset[i] -= overlap;
941 if (o_interior[i] + s_interior[i] + overlap < _coarseSize[i])
950 if ((periodic[i]) && (o_interior[i] + s_interior[i] + overlap >= _coarseSize[i]))
953 typename std::vector<ctype>::iterator it = coords[i].begin();
954 for (
int j=0; j<overlap; ++j)
955 newcoords[i].push_back(newcoords[i].back() - *it + *(++it));
958 if ((periodic[i]) && (o_interior[i] - overlap <= 0))
960 offset[i] -= overlap;
963 typename std::vector<ctype>::iterator it = coords[i].end() - 1;
964 for (
int j=0; j<overlap; ++j)
965 newcoords[i].insert(newcoords[i].
begin(), newcoords[i].front() - *it + *(--it));
972 makelevel(cc,periodic,o_interior,overlap);
992 YaspGrid (std::array<std::vector<ctype>, dim> coords,
993 std::bitset<dim> periodic,
996 std::array<int,dim> coarseSize,
998 : ccobj(
comm), _torus(
comm,tag,coarseSize,lb), leafIndexSet_(*this),
999 _periodic(periodic), _coarseSize(coarseSize), _overlap(overlap),
1000 keep_ovlp(true), adaptRefCount(0), adaptActive(false)
1003 static_assert(std::is_same<Coordinates,TensorProductCoordinates<ctype,dim> >::value,
1004 "YaspGrid coordinate container template parameter and given constructor values do not match!");
1006 if (!Dune::Yasp::checkIfMonotonous(coords))
1007 DUNE_THROW(
Dune::GridError,
"Setup of a tensorproduct grid requires monotonous sequences of coordinates.");
1009 for (
int i=0; i<dim; i++)
1010 _L[i] = coords[i][coords[i].
size() - 1] - coords[i][0];
1014 std::array<int,dim> o;
1015 std::fill(o.begin(), o.end(), 0);
1016 std::array<int,dim> o_interior(o);
1017 std::array<int,dim> s_interior(coarseSize);
1019 _torus.
partition(_torus.
rank(),o,coarseSize,o_interior,s_interior);
1022 std::array<int,dim> offset(o_interior);
1023 for (
int i=0; i<dim; i++)
1024 if ((periodic[i]) || (o_interior[i] > 0))
1025 offset[i] -= overlap;
1030 makelevel(cc,periodic,o_interior,overlap);
1048 return _levels.size()-1;
1056 "Coarsening " << -refCount <<
" levels requested!");
1059 for (
int k=refCount; k<0; k++)
1063 _levels.back() = empty;
1067 indexsets.pop_back();
1071 for (
int k=0; k<refCount; k++)
1074 YGridLevel& cg = _levels[
maxLevel()];
1076 std::bitset<dim> ovlp_low(0ULL), ovlp_up(0ULL);
1077 for (
int i=0; i<dim; i++)
1079 if (cg.overlap[0].dataBegin()->origin(i) > 0 || _periodic[i])
1081 if (cg.overlap[0].dataBegin()->max(i) + 1 <
globalSize(i) || _periodic[i])
1085 Coordinates newcont(cg.coords.refine(ovlp_low, ovlp_up, cg.overlapSize, keep_ovlp));
1087 int overlap = (keep_ovlp) ? 2*cg.overlapSize : cg.overlapSize;
1091 for (
int i=0; i<dim; i++)
1092 o_interior[i] = 2*cg.interior[0].dataBegin()->origin(i);
1095 _levels.resize(_levels.size() + 1);
1096 makelevel(newcont,_periodic,o_interior,overlap);
1108 keep_ovlp = keepPhysicalOverlap;
1124 assert(adaptActive ==
false);
1125 if (e.level() !=
maxLevel())
return false;
1126 adaptRefCount = std::max(adaptRefCount, refCount);
1138 return ( e.level() ==
maxLevel() ) ? adaptRefCount : 0;
1145 return (adaptRefCount > 0);
1152 adaptRefCount =
comm().max(adaptRefCount);
1153 return (adaptRefCount < 0);
1159 adaptActive =
false;
1164 template<
int cd, PartitionIteratorType pitype>
1167 return levelbegin<cd,pitype>(level);
1171 template<
int cd, PartitionIteratorType pitype>
1174 return levelend<cd,pitype>(level);
1181 return levelbegin<cd,All_Partition>(level);
1188 return levelend<cd,All_Partition>(level);
1192 template<
int cd, PartitionIteratorType pitype>
1195 return levelbegin<cd,pitype>(
maxLevel());
1199 template<
int cd, PartitionIteratorType pitype>
1202 return levelend<cd,pitype>(
maxLevel());
1209 return levelbegin<cd,All_Partition>(
maxLevel());
1216 return levelend<cd,All_Partition>(
maxLevel());
1220 template <
typename Seed>
1221 typename Traits::template Codim<Seed::codimension>::Entity
1224 const int codim = Seed::codimension;
1231 return Entity(EntityImp(g,YIterator(g->overlapfront[codim],this->getRealImplementation(seed).coord(),this->getRealImplementation(seed).offset())));
1238 return g->overlapSize;
1245 return g->overlapSize;
1261 int size (
int level,
int codim)
const
1267 typedef typename std::array<YGridComponent<Coordinates>, StaticPower<2,dim>::power>::iterator DAI;
1268 for (DAI it = g->overlapfront[codim].dataBegin(); it != g->overlapfront[codim].dataEnd(); ++it)
1269 count += it->totalsize();
1281 int size (
int level, GeometryType type)
const
1283 return (type.isCube()) ?
size(level,dim-type.dim()) : 0;
1307 template<
class DataHandleImp,
class DataType>
1310 YaspCommunicateMeta<dim,dim>::comm(*
this,data,iftype,dir,level);
1317 template<
class DataHandleImp,
class DataType>
1320 YaspCommunicateMeta<dim,dim>::comm(*
this,data,iftype,dir,this->
maxLevel());
1327 template<
class DataHandle,
int codim>
1331 if (!data.contains(dim,codim))
return;
1334 typedef typename DataHandle::DataType DataType;
1345 sendlist = &g->send_interiorborder_interiorborder[codim];
1346 recvlist = &g->recv_interiorborder_interiorborder[codim];
1350 sendlist = &g->send_interiorborder_overlapfront[codim];
1351 recvlist = &g->recv_overlapfront_interiorborder[codim];
1355 sendlist = &g->send_overlap_overlapfront[codim];
1356 recvlist = &g->recv_overlapfront_overlap[codim];
1360 sendlist = &g->send_overlapfront_overlapfront[codim];
1361 recvlist = &g->recv_overlapfront_overlapfront[codim];
1371 std::vector<int> send_size(sendlist->
size(),-1);
1372 std::vector<int> recv_size(recvlist->
size(),-1);
1373 std::vector<size_t*> send_sizes(sendlist->
size(),
static_cast<size_t*
>(0));
1374 std::vector<size_t*> recv_sizes(recvlist->
size(),
static_cast<size_t*
>(0));
1379 if (data.fixedSize(dim,codim))
1383 for (ListIt is=sendlist->
begin(); is!=sendlist->
end(); ++is)
1387 send_size[cnt] = is->grid.totalsize() * data.size(*it);
1391 for (ListIt is=recvlist->
begin(); is!=recvlist->
end(); ++is)
1395 recv_size[cnt] = is->grid.totalsize() * data.size(*it);
1403 for (ListIt is=sendlist->
begin(); is!=sendlist->
end(); ++is)
1406 size_t *buf =
new size_t[is->grid.totalsize()];
1407 send_sizes[cnt] = buf;
1410 int i=0;
size_t n=0;
1415 for ( ; it!=itend; ++it)
1417 buf[i] = data.size(*it);
1426 torus().
send(is->rank,buf,is->grid.totalsize()*
sizeof(
size_t));
1432 for (ListIt is=recvlist->
begin(); is!=recvlist->
end(); ++is)
1435 size_t *buf =
new size_t[is->grid.totalsize()];
1436 recv_sizes[cnt] = buf;
1439 torus().
recv(is->rank,buf,is->grid.totalsize()*
sizeof(
size_t));
1448 for (ListIt is=sendlist->
begin(); is!=sendlist->
end(); ++is)
1450 delete[] send_sizes[cnt];
1451 send_sizes[cnt] = 0;
1457 for (ListIt is=recvlist->
begin(); is!=recvlist->
end(); ++is)
1460 size_t *buf = recv_sizes[cnt];
1464 for (
int i=0; i<is->grid.totalsize(); ++i)
1475 std::vector<DataType*> sends(sendlist->
size(),
static_cast<DataType*
>(0));
1477 for (ListIt is=sendlist->
begin(); is!=sendlist->
end(); ++is)
1480 DataType *buf =
new DataType[send_size[cnt]];
1486 MessageBuffer<DataType> mb(buf);
1493 for ( ; it!=itend; ++it)
1494 data.gather(mb,*it);
1497 torus().
send(is->rank,buf,send_size[cnt]*
sizeof(DataType));
1502 std::vector<DataType*> recvs(recvlist->
size(),
static_cast<DataType*
>(0));
1504 for (ListIt is=recvlist->
begin(); is!=recvlist->
end(); ++is)
1507 DataType *buf =
new DataType[recv_size[cnt]];
1513 torus().
recv(is->rank,buf,recv_size[cnt]*
sizeof(DataType));
1522 for (ListIt is=sendlist->
begin(); is!=sendlist->
end(); ++is)
1524 delete[] sends[cnt];
1531 for (ListIt is=recvlist->
begin(); is!=recvlist->
end(); ++is)
1534 DataType *buf = recvs[cnt];
1537 MessageBuffer<DataType> mb(buf);
1540 if (data.fixedSize(dim,codim))
1544 size_t n=data.size(*it);
1547 for ( ; it!=itend; ++it)
1548 data.scatter(mb,*it,n);
1553 size_t *sbuf = recv_sizes[cnt];
1558 for ( ; it!=itend; ++it)
1559 data.scatter(mb,*it,sbuf[i++]);
1572 return theglobalidset;
1577 return theglobalidset;
1582 if (level<0 || level>
maxLevel()) DUNE_THROW(RangeError,
"level out of range");
1583 return *(indexsets[level]);
1588 return leafIndexSet_;
1611 friend class
Dune::YaspEntity<0, dim, const Dune::YaspGrid<dim, Coordinates> >;
1613 template <int codim_, class GridImp_>
1616 template<int codim_, int dim_, class GridImp_, template<int,int,class> class EntityImp_>
1620 class MessageBuffer {
1623 MessageBuffer (DT *p)
1632 void write (
const Y& data)
1634 static_assert(( std::is_same<DT,Y>::value ),
"DataType mismatch");
1640 void read (Y& data)
const
1642 static_assert(( std::is_same<DT,Y>::value ),
"DataType mismatch");
1653 template<
int cd, PartitionIteratorType pitype>
1657 if (level<0 || level>
maxLevel()) DUNE_THROW(RangeError,
"level out of range");
1668 return levelend <cd, pitype> (level);
1670 DUNE_THROW(
GridError,
"YaspLevelIterator with this codim or partition type not implemented");
1674 template<
int cd, PartitionIteratorType pitype>
1675 YaspLevelIterator<cd,pitype,GridImp> levelend (
int level)
const
1678 if (level<0 || level>
maxLevel()) DUNE_THROW(RangeError,
"level out of range");
1681 return YaspLevelIterator<cd,pitype,GridImp>(g,g->interior[cd].end());
1683 return YaspLevelIterator<cd,pitype,GridImp>(g,g->interiorborder[cd].end());
1685 return YaspLevelIterator<cd,pitype,GridImp>(g,g->overlap[cd].end());
1687 return YaspLevelIterator<cd,pitype,GridImp>(g,g->overlapfront[cd].end());
1689 DUNE_THROW(GridError,
"YaspLevelIterator with this codim or partition type not implemented");
1694 Torus<CollectiveCommunicationType,dim> _torus;
1696 std::vector< std::shared_ptr< YaspIndexSet<const YaspGrid<dim,Coordinates>,
false > > > indexsets;
1697 YaspIndexSet<const YaspGrid<dim,Coordinates>,
true> leafIndexSet_;
1698 YaspGlobalIdSet<const YaspGrid<dim,Coordinates> > theglobalidset;
1700 Dune::FieldVector<ctype, dim> _L;
1702 std::bitset<dim> _periodic;
1704 ReservedVector<YGridLevel,32> _levels;
1713 template <
int d,
class CC>
1718 s <<
"[" << rank <<
"]:" <<
" YaspGrid maxlevel=" << grid.
maxLevel() << std::endl;
1720 s <<
"Printing the torus: " <<std::endl;
1721 s << grid.
torus() << std::endl;
1725 s <<
"[" << rank <<
"]: " << std::endl;
1726 s <<
"[" << rank <<
"]: " <<
"==========================================" << std::endl;
1727 s <<
"[" << rank <<
"]: " <<
"level=" << g->level() << std::endl;
1729 for (
int codim = 0; codim < d + 1; ++codim)
1731 s <<
"[" << rank <<
"]: " <<
"overlapfront[" << codim <<
"]: " << g->overlapfront[codim] << std::endl;
1732 s <<
"[" << rank <<
"]: " <<
"overlap[" << codim <<
"]: " << g->overlap[codim] << std::endl;
1733 s <<
"[" << rank <<
"]: " <<
"interiorborder[" << codim <<
"]: " << g->interiorborder[codim] << std::endl;
1734 s <<
"[" << rank <<
"]: " <<
"interior[" << codim <<
"]: " << g->interior[codim] << std::endl;
1737 for (I i=g->send_overlapfront_overlapfront[codim].begin();
1738 i!=g->send_overlapfront_overlapfront[codim].end(); ++i)
1739 s <<
"[" << rank <<
"]: " <<
" s_of_of[" << codim <<
"] to rank "
1740 << i->rank <<
" " << i->grid << std::endl;
1742 for (I i=g->recv_overlapfront_overlapfront[codim].begin();
1743 i!=g->recv_overlapfront_overlapfront[codim].end(); ++i)
1744 s <<
"[" << rank <<
"]: " <<
" r_of_of[" << codim <<
"] to rank "
1745 << i->rank <<
" " << i->grid << std::endl;
1747 for (I i=g->send_overlap_overlapfront[codim].begin();
1748 i!=g->send_overlap_overlapfront[codim].end(); ++i)
1749 s <<
"[" << rank <<
"]: " <<
" s_o_of[" << codim <<
"] to rank "
1750 << i->rank <<
" " << i->grid << std::endl;
1752 for (I i=g->recv_overlapfront_overlap[codim].begin();
1753 i!=g->recv_overlapfront_overlap[codim].end(); ++i)
1754 s <<
"[" << rank <<
"]: " <<
" r_of_o[" << codim <<
"] to rank "
1755 << i->rank <<
" " << i->grid << std::endl;
1757 for (I i=g->send_interiorborder_interiorborder[codim].begin();
1758 i!=g->send_interiorborder_interiorborder[codim].end(); ++i)
1759 s <<
"[" << rank <<
"]: " <<
" s_ib_ib[" << codim <<
"] to rank "
1760 << i->rank <<
" " << i->grid << std::endl;
1762 for (I i=g->recv_interiorborder_interiorborder[codim].begin();
1763 i!=g->recv_interiorborder_interiorborder[codim].end(); ++i)
1764 s <<
"[" << rank <<
"]: " <<
" r_ib_ib[" << codim <<
"] to rank "
1765 << i->rank <<
" " << i->grid << std::endl;
1767 for (I i=g->send_interiorborder_overlapfront[codim].begin();
1768 i!=g->send_interiorborder_overlapfront[codim].end(); ++i)
1769 s <<
"[" << rank <<
"]: " <<
" s_ib_of[" << codim <<
"] to rank "
1770 << i->rank <<
" " << i->grid << std::endl;
1772 for (I i=g->recv_overlapfront_interiorborder[codim].begin();
1773 i!=g->recv_overlapfront_interiorborder[codim].end(); ++i)
1774 s <<
"[" << rank <<
"]: " <<
" r_of_ib[" << codim <<
"] to rank "
1775 << i->rank <<
" " << i->grid << std::endl;
1784 namespace Capabilities
1794 template<
int dim,
class Coordinates>
1795 struct hasBackupRestoreFacilities< YaspGrid<dim, Coordinates> >
1797 static const bool v =
true;
1803 template<
int dim,
class Coordinates>
1804 struct hasSingleGeometryType< YaspGrid<dim, Coordinates> >
1806 static const bool v =
true;
1807 static const unsigned int topologyId = GenericGeometry :: CubeTopology< dim > :: type :: id ;
1813 template<
int dim,
class Coordinates>
1814 struct isCartesian< YaspGrid<dim, Coordinates> >
1816 static const bool v =
true;
1822 template<
int dim,
class Coordinates,
int codim>
1823 struct hasEntity< YaspGrid<dim, Coordinates>, codim>
1825 static const bool v =
true;
1831 template<
int dim,
int codim,
class Coordinates>
1832 struct canCommunicate< YaspGrid< dim, Coordinates>, codim >
1834 static const bool v =
true;
1840 template<
int dim,
class Coordinates>
1841 struct isLevelwiseConforming< YaspGrid<dim, Coordinates> >
1843 static const bool v =
true;
1849 template<
int dim,
class Coordinates>
1850 struct isLeafwiseConforming< YaspGrid<dim, Coordinates> >
1852 static const bool v =
true;
This provides container classes for the coordinates to be used in YaspGrid Upon implementation of the...
Specialization of the StructuredGridFactory class for YaspGrid.
This file provides the infrastructure for toroidal communication in YaspGrid.
the YaspEntity class and its specializations
The YaspEntityPointer class.
The YaspEntitySeed class.
The YaspGeometry class and its specializations.
level-wise, non-persistent, consecutive indices for YaspGrid
The YaspIntersection class.
The YaspIntersectionIterator class.
The YaspLevelIterator class.
Specialization of the PersistentContainer for YaspGrid.
This provides a YGrid, the elemental component of the yaspgrid implementation.
Describes the parallel communication interface class for MessageBuffers and DataHandles.
Provides base classes for index and id sets.
unsigned char uint8_t
Definition yaspgrid.hh:15
std::ostream & operator<<(std::ostream &out, const PartitionType &type)
write a PartitionType to a stream
Definition gridenums.hh:70
CommunicationDirection
Define a type for communication direction parameter.
Definition gridenums.hh:168
InterfaceType
Parameter to be used for the communication functions.
Definition gridenums.hh:84
@ All_Partition
all entities
Definition gridenums.hh:139
@ Interior_Partition
only interior entities
Definition gridenums.hh:135
@ InteriorBorder_Partition
interior and border entities
Definition gridenums.hh:136
@ Overlap_Partition
interior, border, and overlap entities
Definition gridenums.hh:137
@ Ghost_Partition
only ghost entities
Definition gridenums.hh:140
@ BackwardCommunication
reverse communication direction
Definition gridenums.hh:170
@ InteriorBorder_All_Interface
send interior and border, receive all entities
Definition gridenums.hh:86
@ All_All_Interface
send all and receive all entities
Definition gridenums.hh:89
@ Overlap_All_Interface
send overlap, receive all entities
Definition gridenums.hh:88
@ Overlap_OverlapFront_Interface
send overlap, receive overlap and front entities
Definition gridenums.hh:87
@ InteriorBorder_InteriorBorder_Interface
send/receive interior and border entities
Definition gridenums.hh:85
void swap(Dune::PersistentContainer< G, T > &a, Dune::PersistentContainer< G, T > &b)
Definition utility/persistentcontainer.hh:81
Include standard header files.
Definition agrid.hh:60
const int yaspgrid_level_bits
Definition yaspgrid.hh:50
const int yaspgrid_dim_bits
Definition yaspgrid.hh:49
Intersection of a mesh entity of codimension 0 ("element") with a "neighboring" element or with the d...
Definition common/intersection.hh:162
facility for writing and reading grids
Definition common/backuprestore.hh:41
static const bool v
Definition common/capabilities.hh:26
static const unsigned int topologyId
Definition common/capabilities.hh:29
static const bool v
Definition common/capabilities.hh:48
static const bool v
Definition common/capabilities.hh:57
static const bool v
Definition common/capabilities.hh:70
static const bool v
Definition common/capabilities.hh:79
static const bool v
Definition common/capabilities.hh:88
static const bool v
Definition common/capabilities.hh:97
CommDataHandleIF describes the features of a data handle for communication in parallel runs using the...
Definition datahandleif.hh:73
Definition defaultgridview.hh:24
Definition defaultgridview.hh:221
Wrapper class for entities.
Definition common/entity.hh:62
Base class for exceptions in Dune grid modules.
Definition exceptions.hh:18
Definition common/grid.hh:924
static std::conditional< std::is_reference< InterfaceType >::value, typenamestd::add_lvalue_reference< typenameReturnImplementationType< typenamestd::remove_reference< InterfaceType >::type >::ImplementationType >::type, typenamestd::remove_const< typenameReturnImplementationType< typenamestd::remove_reference< InterfaceType >::type >::ImplementationType >::type >::type getRealImplementation(InterfaceType &&i)
return real implementation of interface class
Definition common/grid.hh:1119
Index Set Interface base class.
Definition indexidset.hh:76
Id Set Interface.
Definition indexidset.hh:397
GridFamily::Traits::CollectiveCommunication CollectiveCommunication
A type that is a model of Dune::CollectiveCommunication. It provides a portable way for collective co...
Definition common/grid.hh:519
A Traits struct that collects all associated types of one implementation.
Definition common/grid.hh:415
A traits struct that collects all associated types of one grid model.
Definition common/grid.hh:1157
[ provides Dune::Grid ]
Definition yaspgrid.hh:165
YaspGridFamily< dim, Coordinates > GridFamily
the GridFamily of this grid
Definition yaspgrid.hh:720
YaspIndexSet< YaspGrid< dim, Coordinates >, false > LevelIndexSetType
Definition yaspgrid.hh:725
int ghostSize(int level, int codim) const
return size (= distance in graph) of ghost region
Definition yaspgrid.hh:1249
YaspGrid(std::array< std::vector< ctype >, dim > coords, std::bitset< dim > periodic=std::bitset< dim >(0ULL), int overlap=1, CollectiveCommunicationType comm=CollectiveCommunicationType(), const YLoadBalance< dim > *lb=defaultLoadbalancer())
Standard constructor for a tensorproduct YaspGrid.
Definition yaspgrid.hh:877
const Traits::LeafIndexSet & leafIndexSet() const
Definition yaspgrid.hh:1586
void init()
Definition yaspgrid.hh:679
Traits::template Codim< cd >::template Partition< All_Partition >::LevelIterator lbegin(int level) const
version without second template parameter for convenience
Definition yaspgrid.hh:1179
int size(int level, GeometryType type) const
number of entities per level and geometry type in this process
Definition yaspgrid.hh:1281
Traits::template Codim< Seed::codimension >::Entity entity(const Seed &seed) const
Definition yaspgrid.hh:1222
Traits::template Codim< cd >::template Partition< All_Partition >::LeafIterator leafbegin() const
return LeafIterator which points to the first entity in maxLevel
Definition yaspgrid.hh:1207
const Traits::GlobalIdSet & globalIdSet() const
Definition yaspgrid.hh:1570
const Traits::LocalIdSet & localIdSet() const
Definition yaspgrid.hh:1575
YaspGridFamily< dim, Coordinates >::Traits Traits
Definition yaspgrid.hh:722
bool getRefineOption() const
Definition yaspgrid.hh:287
void globalRefine(int refCount)
refine the grid refCount times.
Definition yaspgrid.hh:1052
const Torus< CollectiveCommunicationType, dim > & torus() const
return reference to torus
Definition yaspgrid.hh:249
int getMark(const typename Traits::template Codim< 0 >::Entity &e) const
returns adaptation mark for given entity
Definition yaspgrid.hh:1136
void boundarysegmentssize()
Definition yaspgrid.hh:688
YaspIndexSet< YaspGrid< dim, Coordinates >, true > LeafIndexSetType
Definition yaspgrid.hh:726
int ghostSize(int codim) const
return size (= distance in graph) of ghost region
Definition yaspgrid.hh:1255
int overlapSize(int codim) const
return size (= distance in graph) of overlap region
Definition yaspgrid.hh:1242
int globalSize(int i) const
return number of cells on finest level in given direction on all processors
Definition yaspgrid.hh:255
Traits::template Codim< cd >::template Partition< pitype >::LeafIterator leafend() const
return LeafIterator which points behind the last entity in maxLevel
Definition yaspgrid.hh:1200
void postAdapt()
clean up some markers
Definition yaspgrid.hh:1157
const Dune::FieldVector< ctype, dim > & domainSize() const
returns the size of the physical domain
Definition yaspgrid.hh:1299
YGridLevelIterator end() const
return iterator pointing to one past the finest level
Definition yaspgrid.hh:310
friend class Entity
Definition yaspgrid.hh:1617
int size(GeometryType type) const
number of leaf entities per geometry type in this process
Definition yaspgrid.hh:1287
YaspGrid(Dune::FieldVector< ctype, dim > lowerleft, Dune::FieldVector< ctype, dim > upperright, std::array< int, dim > s, std::bitset< dim > periodic=std::bitset< dim >(0ULL), int overlap=1, CollectiveCommunicationType comm=CollectiveCommunicationType(), const YLoadBalance< dim > *lb=defaultLoadbalancer())
Definition yaspgrid.hh:805
int maxLevel() const
Definition yaspgrid.hh:1046
Traits::template Codim< cd >::template Partition< All_Partition >::LeafIterator leafend() const
return LeafIterator which points behind the last entity in maxLevel
Definition yaspgrid.hh:1214
void communicate(CommDataHandleIF< DataHandleImp, DataType > &data, InterfaceType iftype, CommunicationDirection dir, int level) const
Definition yaspgrid.hh:1308
void intersections(const YGridComponent< Coordinates > &sendgrid, const YGridComponent< Coordinates > &recvgrid, std::deque< Intersection > &sendlist, std::deque< Intersection > &recvlist)
Construct list of intersections with neighboring processors.
Definition yaspgrid.hh:563
Traits::template Codim< cd >::template Partition< pitype >::LeafIterator leafbegin() const
return LeafIterator which points to the first entity in maxLevel
Definition yaspgrid.hh:1193
bool preAdapt()
returns true, if the grid will be coarsened
Definition yaspgrid.hh:1149
iTupel levelSize(int l) const
return size vector of the grid (in cells) on level l
Definition yaspgrid.hh:273
bool mark(int refCount, const typename Traits::template Codim< 0 >::Entity &e)
Marks an entity to be refined/coarsened in a subsequent adapt.
Definition yaspgrid.hh:1122
int overlapSize(int level, int codim) const
return size (= distance in graph) of overlap region
Definition yaspgrid.hh:1235
const CollectiveCommunicationType & comm() const
return a collective communication object
Definition yaspgrid.hh:1593
void communicate(CommDataHandleIF< DataHandleImp, DataType > &data, InterfaceType iftype, CommunicationDirection dir) const
Definition yaspgrid.hh:1318
int size(int codim) const
number of leaf entities per codim in this process
Definition yaspgrid.hh:1275
bool isPeriodic(int i) const
return whether the grid is periodic in direction i
Definition yaspgrid.hh:282
const Traits::LevelIndexSet & levelIndexSet(int level) const
Definition yaspgrid.hh:1580
void refineOptions(bool keepPhysicalOverlap)
set options for refinement
Definition yaspgrid.hh:1106
YaspGrid(Dune::FieldVector< ctype, dim > L, std::array< int, dim > s, std::bitset< dim > periodic=std::bitset< dim >(0ULL), int overlap=1, CollectiveCommunicationType comm=CollectiveCommunicationType(), const YLoadBalance< dim > *lb=defaultLoadbalancer())
Definition yaspgrid.hh:737
int size(int level, int codim) const
number of entities per level and codim in this process
Definition yaspgrid.hh:1261
YaspGlobalIdSet< YaspGrid< dim, Coordinates > > GlobalIdSetType
Definition yaspgrid.hh:727
bool adapt()
map adapt to global refine
Definition yaspgrid.hh:1142
Traits::template Codim< cd >::template Partition< All_Partition >::LevelIterator lend(int level) const
version without second template parameter for convenience
Definition yaspgrid.hh:1186
ReservedVector< YGridLevel, 32 >::const_iterator YGridLevelIterator
Iterator over the grid levels.
Definition yaspgrid.hh:293
size_t numBoundarySegments() const
returns the number of boundary segments within the macro grid
Definition yaspgrid.hh:1293
void communicateCodim(DataHandle &data, InterfaceType iftype, CommunicationDirection dir, int level) const
Definition yaspgrid.hh:1328
CollectiveCommunication< MPI_Comm > CollectiveCommunicationType
Definition yaspgrid.hh:181
void makelevel(const Coordinates &coords, std::bitset< dim > periodic, iTupel o_interior, int overlap)
Make a new YGridLevel structure.
Definition yaspgrid.hh:330
bigunsignedint< dim *yaspgrid_dim_bits+yaspgrid_level_bits+dim > PersistentIndexType
Definition yaspgrid.hh:717
Traits::template Codim< cd >::template Partition< pitype >::LevelIterator lend(int level) const
Iterator to one past the last entity of given codim on level for partition type.
Definition yaspgrid.hh:1172
static const YLoadBalanceDefault< dim > * defaultLoadbalancer()
Definition yaspgrid.hh:316
Traits::template Codim< cd >::template Partition< pitype >::LevelIterator lbegin(int level) const
one past the end on this level
Definition yaspgrid.hh:1165
iTupel globalSize() const
return number of cells on finest level on all processors
Definition yaspgrid.hh:261
const YaspGrid< dim, Coordinates > GridImp
Definition yaspgrid.hh:677
YGridLevelIterator begin(int i) const
return iterator pointing to given level
Definition yaspgrid.hh:302
Coordinates::ctype ctype
Type used for coordinates.
Definition yaspgrid.hh:179
int levelSize(int l, int i) const
return size of the grid (in cells) on level l in direction i
Definition yaspgrid.hh:267
YGridLevelIterator begin() const
return iterator pointing to coarsest level
Definition yaspgrid.hh:296
The general version that handles all codimensions but 0 and dim.
Definition yaspgridgeometry.hh:29
Definition yaspgridentity.hh:239
A pointer to a YaspGrid::Entity.
Definition yaspgridentitypointer.hh:16
Describes the minimal information necessary to create a fully functional YaspEntity.
Definition yaspgridentityseed.hh:16
Iterates over entities of one grid level.
Definition yaspgridleveliterator.hh:18
YaspIntersectionIterator enables iteration over intersections with neighboring codim 0 entities.
Definition yaspgridintersectioniterator.hh:20
YaspIntersection provides data about intersection with neighboring codim 0 entities.
Definition yaspgridintersection.hh:20
YaspHierarchicIterator enables iteration over son entities of codim 0.
Definition yaspgridhierarchiciterator.hh:19
Implementation of Level- and LeafIndexSets for YaspGrid.
Definition yaspgridindexsets.hh:23
persistent, globally unique Ids
Definition yaspgrididset.hh:23
Definition yaspgridpersistentcontainer.hh:33
Definition yaspgrid.hh:90
GridTraits< dim, dim, Dune::YaspGrid< dim, Coordinates >, YaspGeometry, YaspEntity, YaspLevelIterator, YaspIntersection, YaspIntersection, YaspIntersectionIterator, YaspIntersectionIterator, YaspHierarchicIterator, YaspLevelIterator, YaspIndexSet< const YaspGrid< dim, Coordinates >, false >, YaspIndexSet< const YaspGrid< dim, Coordinates >, true >, YaspGlobalIdSet< const YaspGrid< dim, Coordinates > >, bigunsignedint< dim *yaspgrid_dim_bits+yaspgrid_level_bits+dim >, YaspGlobalIdSet< const YaspGrid< dim, Coordinates > >, bigunsignedint< dim *yaspgrid_dim_bits+yaspgrid_level_bits+dim >, CCType, DefaultLevelGridViewTraits, DefaultLeafGridViewTraits, YaspEntitySeed > Traits
Definition yaspgrid.hh:117
CollectiveCommunication< MPI_Comm > CCType
Definition yaspgrid.hh:92
Container for equidistant coordinates in a YaspGrid.
Definition coordinates.hh:27
Container for equidistant coordinates in a YaspGrid with non-trivial origin.
Definition coordinates.hh:125
Coordinate container for a tensor product YaspGrid.
Definition coordinates.hh:234
a base class for the yaspgrid partitioning strategy The name might be irritating. It will probably ch...
Definition partitioning.hh:24
Implement the default load balance strategy of yaspgrid.
Definition partitioning.hh:35
int neighbors() const
return the number of neighbors, which is
Definition torus.hh:206
ProcListIterator sendbegin() const
first process in send list
Definition torus.hh:340
int rank() const
return own rank
Definition torus.hh:97
ProcListIterator recvbegin() const
first process in receive list
Definition torus.hh:352
void recv(int rank, void *buffer, int size) const
store a receive request; buffers are received in order; handles also local requests with memcpy
Definition torus.hh:377
ProcListIterator recvend() const
last process in receive list
Definition torus.hh:358
void send(int rank, void *buffer, int size) const
store a send request; buffers are sent in order; handles also local requests with memcpy
Definition torus.hh:364
double partition(int rank, iTupel origin_in, iTupel size_in, iTupel &origin_out, iTupel &size_out) const
partition the given grid onto the torus and return the piece of the process with given rank; returns ...
Definition torus.hh:242
iTupel coord() const
return own coordinates
Definition torus.hh:103
void exchange() const
exchange messages stored in request buffers; clear request buffers afterwards
Definition torus.hh:390
ProcListIterator sendend() const
end of send list
Definition torus.hh:346
const iTupel & dims() const
return dimensions of torus
Definition torus.hh:115
YGridComponent< Coordinates > move(iTupel v) const
return grid moved by the vector v
Definition ygrid.hh:260
YGridComponent< Coordinates > intersection(const YGridComponent< Coordinates > &r) const
Return YGridComponent of supergrid of self which is the intersection of self and another YGridCompone...
Definition ygrid.hh:268
implements a collection of YGridComponents which form a codimension Entities of given codimension c n...
Definition ygrid.hh:548
Iterator over a collection o YGrids A YGrid::Iterator is the heart of an entity in YaspGrid.
Definition ygrid.hh:591
implements a collection of multiple std::deque<Intersection> Intersections with neighboring processor...
Definition ygrid.hh:821
int size() const
return the size of the container, this is the sum of the sizes of all deques
Definition ygrid.hh:951
Iterator end() const
return iterator pointing to the end of the container
Definition ygrid.hh:927
Iterator begin() const
return iterator pointing to the begin of the container
Definition ygrid.hh:921
type describing an intersection with a neighboring processor
Definition ygrid.hh:827
A set of traits classes to store static information about grid implementation.
Different resources needed by all grid implementations.