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/axisalignedcubegeometry.hh> 29 #include <dune/geometry/type.hh> 35 #include <dune/common/parallel/mpicollectivecommunication.hh> 56 template<
int dim,
class Coordinates>
class YaspGrid;
58 template<
int codim,
int dim,
class Gr
idImp>
class YaspEntity;
88 template<
int dim,
class Coordinates>
92 typedef CollectiveCommunication<MPI_Comm>
CCType;
94 typedef CollectiveCommunication<No_Comm>
CCType;
105 YaspIntersectionIterator,
109 YaspIndexSet< const YaspGrid< dim, Coordinates >,
true >,
111 bigunsignedint<dim*yaspgrid_dim_bits+yaspgrid_level_bits+dim>,
112 YaspGlobalIdSet<const YaspGrid<dim, Coordinates> >,
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>
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;
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;
257 return levelSize(maxLevel(),i);
263 return levelSize(maxLevel());
269 return _coarseSize[i] * (1 << l);
276 for (
int i=0; i<dim; ++i)
277 s[i] = levelSize(l,i);
298 return YGridLevelIterator(_levels,0);
302 YGridLevelIterator
begin (
int i)
const 304 if (i<0 || i>maxLevel())
305 DUNE_THROW(
GridError,
"level not existing");
306 return YGridLevelIterator(_levels,i);
310 YGridLevelIterator
end ()
const 312 return YGridLevelIterator(_levels,maxLevel()+1);
330 void makelevel (
const Coordinates& coords, std::bitset<dim> periodic, iTupel o_interior,
int overlap)
332 YGridLevel& g = _levels.back();
335 g.level_ = maxLevel();
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++)
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);
564 std::deque<Intersection>& sendlist, std::deque<Intersection>& recvlist)
566 iTupel size = globalSize();
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));
657 Intersection send_intersection;
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);
665 Intersection recv_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();
685 boundarysegmentssize();
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),
741 CollectiveCommunicationType comm = CollectiveCommunicationType(),
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)
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);
758 _torus.partition(_torus.rank(),o,s,o_interior,s_interior);
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);
773 #endif // #if HAVE_MPI 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]))
784 if ((o_interior[i] + s_interior[i] +
overlap <= _coarseSize[i]) || (periodic[i]))
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),
810 CollectiveCommunicationType comm = CollectiveCommunicationType(),
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)
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);
828 _torus.partition(_torus.rank(),o,s,o_interior,s_interior);
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);
843 #endif // #if HAVE_MPI 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]))
858 if ((o_interior[i] + s_interior[i] +
overlap <= _coarseSize[i]) || (periodic[i]))
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),
880 CollectiveCommunicationType comm = CollectiveCommunicationType(),
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)
887 DUNE_THROW(
Dune::GridError,
"Setup of a tensorproduct grid requires monotonous sequences of coordinates.");
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);
921 #endif // #if HAVE_MPI 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)
941 if (o_interior[i] + s_interior[i] +
overlap < _coarseSize[i])
945 newcoords[i].resize(end-begin);
946 std::copy(begin, end, newcoords[i].begin());
950 if ((periodic[i]) && (o_interior[i] + s_interior[i] + overlap >= _coarseSize[i]))
953 typename std::vector<ctype>::iterator it = coords[i].begin();
955 newcoords[i].push_back(newcoords[i].back() - *it + *(++it));
958 if ((periodic[i]) && (o_interior[i] - overlap <= 0))
963 typename std::vector<ctype>::iterator it = coords[i].end() - 1;
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,
995 CollectiveCommunicationType comm,
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)
1004 "YaspGrid coordinate container template parameter and given constructor values do not match!");
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))
1030 makelevel(cc,periodic,o_interior,overlap);
1048 return _levels.size()-1;
1054 if (refCount < -maxLevel())
1055 DUNE_THROW(
GridError,
"Only " << maxLevel() <<
" levels left. " <<
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;
1144 globalRefine(adaptRefCount);
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>
1224 const int codim = Seed::codimension;
1225 YGridLevelIterator g = begin(this->getRealImplementation(seed).level());
1231 return Entity(EntityImp(g,YIterator(g->overlapfront[codim],this->getRealImplementation(seed).coord(),this->getRealImplementation(seed).offset())));
1237 YGridLevelIterator g = begin(level);
1238 return g->overlapSize;
1244 YGridLevelIterator g = begin(maxLevel());
1245 return g->overlapSize;
1261 int size (
int level,
int codim)
const 1263 YGridLevelIterator g = begin(level);
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();
1277 return size(maxLevel(),codim);
1283 return (type.isCube()) ? size(level,dim-type.dim()) : 0;
1289 return size(maxLevel(),type);
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;
1337 YGridLevelIterator g = begin(level);
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];
1366 std::swap(sendlist,recvlist);
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_;
1593 const CollectiveCommunicationType&
comm ()
const 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>
1656 YGridLevelIterator g = begin(level);
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>
1677 YGridLevelIterator g = begin(level);
1678 if (level<0 || level>maxLevel()) DUNE_THROW(RangeError,
"level out of range");
1689 DUNE_THROW(
GridError,
"YaspLevelIterator with this codim or partition type not implemented");
1692 CollectiveCommunicationType ccobj;
1696 std::vector< std::shared_ptr< YaspIndexSet<const YaspGrid<dim,Coordinates>,
false > > > indexsets;
1700 Dune::FieldVector<ctype, dim> _L;
1702 std::bitset<dim> _periodic;
1704 ReservedVector<YGridLevel,32> _levels;
1713 template <
int d,
class CC>
1714 std::ostream& operator<< (std::ostream& s, const YaspGrid<d,CC>& grid)
1716 int rank = grid.torus().rank();
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>
1797 static const bool v =
true;
1803 template<
int dim,
class Coordinates>
1806 static const bool v =
true;
1807 static const unsigned int topologyId = Impl::CubeTopology< dim >::type::id;
1813 template<
int dim,
class Coordinates>
1816 static const bool v =
true;
1822 template<
int dim,
class Coordinates,
int codim>
1825 static const bool v =
true;
1831 template<
int dim,
int codim,
class Coordinates>
1834 static const bool v =
true;
1840 template<
int dim,
class Coordinates>
1843 static const bool v =
true;
1849 template<
int dim,
class Coordinates>
1852 static const bool v =
true;
only interior entities
Definition: gridenums.hh:135
unsigned char uint8_t
Definition: yaspgrid.hh:15
A traits struct that collects all associated types of one grid model.
Definition: common/grid.hh:1152
Specialize with 'true' if implementation provides backup and restore facilities. (default=false) ...
Definition: common/capabilities.hh:95
int size(int i) const
return size in direction i
Definition: ygrid.hh:194
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
Definition: yaspgrid.hh:89
Coordinates::ctype ctype
Type used for coordinates.
Definition: yaspgrid.hh:179
Base class for exceptions in Dune grid modules.
Definition: exceptions.hh:16
Intersection of a mesh entity of codimension 0 ("element") with a "neighboring" element or with the d...
Definition: albertagrid/dgfparser.hh:26
The YaspEntityPointer class.
int ghostSize(int codim) const
return size (= distance in graph) of ghost region
Definition: yaspgrid.hh:1255
YGridLevelIterator begin(int i) const
return iterator pointing to given level
Definition: yaspgrid.hh:302
IdSet< const GridImp, GlobalIdSetImp, GIDType > GlobalIdSet
The type of the global id set.
Definition: common/grid.hh:1224
void communicate(CommDataHandleIF< DataHandleImp, DataType > &data, InterfaceType iftype, CommunicationDirection dir) const
Definition: yaspgrid.hh:1318
The YaspLevelIterator class.
size_t numBoundarySegments() const
returns the number of boundary segments within the macro grid
Definition: yaspgrid.hh:1293
Describes the parallel communication interface class for MessageBuffers and DataHandles.
int size(int codim) const
number of leaf entities per codim in this process
Definition: yaspgrid.hh:1275
int globalSize(int i) const
return number of cells on finest level in given direction on all processors
Definition: yaspgrid.hh:255
const Traits::LocalIdSet & localIdSet() const
Definition: yaspgrid.hh:1575
the YaspEntity class and its specializations
const CollectiveCommunicationType & comm() const
return a collective communication object
Definition: yaspgrid.hh:1593
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
send overlap, receive all entities
Definition: gridenums.hh:88
GeometryType
Type representing VTK's entity geometry types.
Definition: common.hh:178
bool checkIfMonotonous(const std::array< std::vector< ctype >, dim > &coords)
Definition: coordinates.hh:361
int maxLevel() const
Definition: yaspgrid.hh:1046
bool getRefineOption() const
Definition: yaspgrid.hh:287
CommunicationDirection
Define a type for communication direction parameter.
Definition: gridenums.hh:168
void communicateCodim(DataHandle &data, InterfaceType iftype, CommunicationDirection dir, int level) const
Definition: yaspgrid.hh:1328
This provides a YGrid, the elemental component of the yaspgrid implementation.
Overlap overlap
PartitionSet for the overlap partition.
Definition: partitionset.hh:226
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::LevelIndexSet & levelIndexSet(int level) const
Definition: yaspgrid.hh:1580
CollectiveCommunication< MPI_Comm > CCType
Definition: yaspgrid.hh:92
send all and receive all entities
Definition: gridenums.hh:89
Traits::template Codim< cd >::template Partition< pitype >::LeafIterator leafbegin() const
return LeafIterator which points to the first entity in maxLevel
Definition: yaspgrid.hh:1193
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
Definition: common/geometry.hh:24
facility for writing and reading grids
Definition: common/backuprestore.hh:40
Specialization of the PersistentContainer for YaspGrid.
bigunsignedint< dim *yaspgrid_dim_bits+yaspgrid_level_bits+dim > PersistentIndexType
Definition: yaspgrid.hh:717
Iterator over a collection o YGrids A YGrid::Iterator is the heart of an entity in YaspGrid...
Definition: ygrid.hh:590
YaspGridFamily< dim, Coordinates > GridFamily
the GridFamily of this grid
Definition: yaspgrid.hh:720
level-wise, non-persistent, consecutive indices for YaspGrid
YaspGlobalIdSet< YaspGrid< dim, Coordinates > > GlobalIdSetType
Definition: yaspgrid.hh:727
send/receive interior and border entities
Definition: gridenums.hh:85
IndexSet< const GridImp, LevelIndexSetImp > LevelIndexSet
The type of the level index set.
Definition: common/grid.hh:1220
reverse communication direction
Definition: gridenums.hh:170
int size(int level, GeometryType type) const
number of entities per level and geometry type in this process
Definition: yaspgrid.hh:1281
const YaspGrid< dim, Coordinates > GridImp
Definition: yaspgrid.hh:677
iTupel globalSize() const
return number of cells on finest level on all processors
Definition: yaspgrid.hh:261
ProcListIterator sendbegin() const
first process in send list
Definition: torus.hh:340
static const YLoadBalanceDefault< dim > * defaultLoadbalancer()
Definition: yaspgrid.hh:316
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
send interior and border, receive all entities
Definition: gridenums.hh:86
bool adapt()
map adapt to global refine
Definition: yaspgrid.hh:1142
int ghostSize(int level, int codim) const
return size (= distance in graph) of ghost region
Definition: yaspgrid.hh:1249
interior and border entities
Definition: gridenums.hh:136
Describes the minimal information necessary to create a fully functional YaspEntity.
Definition: yaspgrid.hh:60
The YaspIntersection class.
void boundarysegmentssize()
Definition: yaspgrid.hh:688
Implement the default load balance strategy of yaspgrid.
Definition: partitioning.hh:34
CollectiveCommunication< MPI_Comm > CollectiveCommunicationType
Definition: yaspgrid.hh:181
Provides base classes for index and id sets.
interior, border, and overlap entities
Definition: gridenums.hh:137
all entities
Definition: gridenums.hh:139
Traits::template Codim< cd >::template Partition< pitype >::LevelIterator lbegin(int level) const
one past the end on this level
Definition: yaspgrid.hh:1165
void communicate(CommDataHandleIF< DataHandleImp, DataType > &data, InterfaceType iftype, CommunicationDirection dir, int level) const
Definition: yaspgrid.hh:1308
int overlapSize(int codim) const
return size (= distance in graph) of overlap region
Definition: yaspgrid.hh:1242
The YaspIntersectionIterator class.
void refineOptions(bool keepPhysicalOverlap)
set options for refinement
Definition: yaspgrid.hh:1106
specialize with 'true' for all codims that a grid can communicate data on (default=false) ...
Definition: common/capabilities.hh:68
Implementation of Level- and LeafIndexSets for YaspGrid.
Definition: yaspgrid.hh:65
This provides container classes for the coordinates to be used in YaspGrid Upon implementation of the...
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
YaspIndexSet< YaspGrid< dim, Coordinates >, true > LeafIndexSetType
Definition: yaspgrid.hh:726
YGridLevelIterator end() const
return iterator pointing to one past the finest level
Definition: yaspgrid.hh:310
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
const int yaspgrid_dim_bits
Definition: yaspgrid.hh:49
The general version that handles all codimensions but 0 and dim.
Definition: yaspgrid.hh:57
const Torus< CollectiveCommunicationType, dim > & torus() const
return reference to torus
Definition: yaspgrid.hh:249
IdSet< const GridImp, LocalIdSetImp, LIDType > LocalIdSet
The type of the local id set.
Definition: common/grid.hh:1226
Iterator begin() const
return iterator pointing to the begin of the container
Definition: ygrid.hh:921
Container for equidistant coordinates in a YaspGrid with non-trivial origin.
Definition: coordinates.hh:124
int getMark(const typename Traits::template Codim< 0 >::Entity &e) const
returns adaptation mark for given entity
Definition: yaspgrid.hh:1136
type describing an intersection with a neighboring processor
Definition: ygrid.hh:826
A set of traits classes to store static information about grid implementation.
const int yaspgrid_level_bits
Definition: yaspgrid.hh:50
void init()
Definition: yaspgrid.hh:679
implements a collection of YGridComponents which form a codimension Entities of given codimension c n...
Definition: ygrid.hh:547
Include standard header files.
Definition: agrid.hh:59
Specialize with 'true' for if the codimension 0 entity of the grid has only one possible geometry typ...
Definition: common/capabilities.hh:24
int size() const
return the size of the container, this is the sum of the sizes of all deques
Definition: ygrid.hh:951
Traits::template Codim< cd >::template Partition< All_Partition >::LevelIterator lend(int level) const
version without second template parameter for convenience
Definition: yaspgrid.hh:1186
Traits::template Codim< cd >::template Partition< pitype >::LeafIterator leafend() const
return LeafIterator which points behind the last entity in maxLevel
Definition: yaspgrid.hh:1200
ReservedVector< YGridLevel, 32 >::const_iterator YGridLevelIterator
Iterator over the grid levels.
Definition: yaspgrid.hh:293
Definition: defaultgridview.hh:23
YaspIntersectionIterator enables iteration over intersections with neighboring codim 0 entities...
Definition: yaspgrid.hh:62
iTupel levelSize(int l) const
return size vector of the grid (in cells) on level l
Definition: yaspgrid.hh:273
YaspIndexSet< YaspGrid< dim, Coordinates >, false > LevelIndexSetType
Definition: yaspgrid.hh:725
bool isPeriodic(int i) const
return whether the grid is periodic in direction i
Definition: yaspgrid.hh:282
CommDataHandleIF describes the features of a data handle for communication in parallel runs using the...
Definition: datahandleif.hh:72
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
A pointer to a YaspGrid::Entity.
Definition: yaspgrid.hh:59
a base class for the yaspgrid partitioning strategy The name might be irritating. It will probably ch...
Definition: partitioning.hh:23
[ provides Dune::Grid ]
Definition: yaspgrid.hh:56
Container for equidistant coordinates in a YaspGrid.
Definition: coordinates.hh:26
implements a collection of multiple std::deque<Intersection> Intersections with neighboring processor...
Definition: ygrid.hh:820
int levelSize(int l, int i) const
return size of the grid (in cells) on level l in direction i
Definition: yaspgrid.hh:267
const Traits::GlobalIdSet & globalIdSet() const
Definition: yaspgrid.hh:1570
ProcListIterator recvbegin() const
first process in receive list
Definition: torus.hh:352
Wrapper class for entities.
Definition: common/entity.hh:64
Specialize with 'true' if implementation guarantees a conforming leaf grid. (default=false) ...
Definition: common/capabilities.hh:86
int size(GeometryType type) const
number of leaf entities per geometry type in this process
Definition: yaspgrid.hh:1287
Traits::template Codim< Seed::codimension >::Entity entity(const Seed &seed) const
Definition: yaspgrid.hh:1222
std::array< int, d > sizeArray(const std::array< std::vector< ct >, d > &v)
Definition: ygrid.hh:26
Front front
PartitionSet for the front partition.
Definition: partitionset.hh:229
A Traits struct that collects all associated types of one implementation.
Definition: common/grid.hh:414
Specialize with 'true' for all codims that a grid implements entities for. (default=false) ...
Definition: common/capabilities.hh:55
Definition: yaspgrid.hh:67
void makelevel(const Coordinates &coords, std::bitset< dim > periodic, iTupel o_interior, int overlap)
Make a new YGridLevel structure.
Definition: yaspgrid.hh:330
int origin(int i) const
Return origin in direction i.
Definition: ygrid.hh:141
YaspHierarchicIterator enables iteration over son entities of codim 0.
Definition: yaspgrid.hh:64
const Dune::FieldVector< ctype, dim > & domainSize() const
returns the size of the physical domain
Definition: yaspgrid.hh:1299
void globalRefine(int refCount)
refine the grid refCount times.
Definition: yaspgrid.hh:1052
Iterates over entities of one grid level.
Definition: yaspgrid.hh:61
const Traits::LeafIndexSet & leafIndexSet() const
Definition: yaspgrid.hh:1586
YGridComponent< Coordinates > move(iTupel v) const
return grid moved by the vector v
Definition: ygrid.hh:260
The YaspEntitySeed class.
Definition: yaspgrid.hh:58
bool preAdapt()
returns true, if the grid will be coarsened
Definition: yaspgrid.hh:1149
Iterator end() const
return iterator pointing to the end of the container
Definition: ygrid.hh:927
IndexSet< const GridImp, LeafIndexSetImp > LeafIndexSet
The type of the leaf index set.
Definition: common/grid.hh:1222
Coordinate container for a tensor product YaspGrid.
Definition: coordinates.hh:233
only ghost entities
Definition: gridenums.hh:140
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
Traits::template Codim< cd >::template Partition< All_Partition >::LevelIterator lbegin(int level) const
version without second template parameter for convenience
Definition: yaspgrid.hh:1179
Interior interior
PartitionSet for the interior partition.
Definition: partitionset.hh:220
Different resources needed by all grid implementations.
Specialize with 'true' if implementation guarantees conforming level grids. (default=false) ...
Definition: common/capabilities.hh:77
void postAdapt()
clean up some markers
Definition: yaspgrid.hh:1157
Definition: defaultgridview.hh:206
The YaspGeometry class and its specializations.
Specialize with 'true' if the grid is a Cartesian grid. Cartesian grids satisfy the following propert...
Definition: common/capabilities.hh:45
persistent, globally unique Ids
Definition: yaspgrid.hh:66
send overlap, receive overlap and front entities
Definition: gridenums.hh:87
This file provides the infrastructure for toroidal communication in YaspGrid.
YaspIntersection provides data about intersection with neighboring codim 0 entities.
Definition: yaspgrid.hh:63
InterfaceType
Parameter to be used for the communication functions.
Definition: gridenums.hh:84
YaspGridFamily< dim, Coordinates >::Traits Traits
Definition: yaspgrid.hh:722
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
YGridLevelIterator begin() const
return iterator pointing to coarsest level
Definition: yaspgrid.hh:296
Specialization of the StructuredGridFactory class for YaspGrid.
int max(const DofVectorPointer< int > &dofVector)
Definition: dofvector.hh:335
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 overlapSize(int level, int codim) const
return size (= distance in graph) of overlap region
Definition: yaspgrid.hh:1235