3 #ifndef DUNE_AMGHIERARCHY_HH
4 #define DUNE_AMGHIERARCHY_HH
9 #include <dune/common/stdstreams.hh>
10 #include <dune/common/unused.hh>
11 #include <dune/common/timer.hh>
12 #include <dune/common/bigunsignedint.hh>
37 template<
typename T,
typename A=std::allocator<T> >
46 template<
typename T1,
typename T2>
59 std::weak_ptr<Element> coarser_;
62 std::shared_ptr<Element> finer_;
65 std::shared_ptr<MemberType> element_;
68 std::shared_ptr<MemberType> redistributed_;
75 typedef typename A::template rebind<Element>::other
Allocator;
83 Hierarchy(
const std::shared_ptr<MemberType> & first);
116 template<
class C,
class T1>
118 :
public BidirectionalIteratorFacade<LevelIterator<C,T1>,T1,T1&>
120 friend class LevelIterator<typename std::remove_const<C>::type,
121 typename std::remove_const<T1>::type >;
122 friend class
LevelIterator<const typename std::remove_const<C>::type,
123 const typename std::remove_const<T1>::type >;
136 typename std::remove_const<T1>::type>& other)
137 : element_(other.element_)
142 const typename std::remove_const<T1>::type>& other)
143 : element_(other.element_)
150 typename std::remove_const<T1>::type>& other)
const
152 return element_ == other.element_;
159 const typename std::remove_const<T1>::type>& other)
const
161 return element_ == other.element_;
167 return *(element_->element_);
173 element_ = element_->coarser_.lock();
179 element_ = element_->finer_;
188 return (
bool)element_->redistributed_;
197 assert(element_->redistributed_);
198 return *element_->redistributed_;
202 element_->redistributed_ = t;
207 element_->redistributed_ =
nullptr;
211 std::shared_ptr<Element> element_;
249 std::size_t
levels()
const;
257 std::shared_ptr<MemberType> originalFinest_;
259 std::shared_ptr<Element> finest_;
261 std::shared_ptr<Element> coarsest_;
268 template<
class T,
class A>
270 : originalFinest_(first)
272 finest_ = std::allocate_shared<Element>(allocator_);
273 finest_->element_ = originalFinest_;
280 template<
class T,
class A>
282 : allocator_(other.allocator_),
283 levels_(other.levels_)
287 finest_=coarsest_=
nullptr;
290 finest_ = std::allocate_shared<Element>(allocator_);
291 std::shared_ptr<Element> finer_;
292 std::shared_ptr<Element> current_ = finest_;
293 std::weak_ptr<Element> otherWeak_ = other.finest_;
295 while(! otherWeak_.expired())
298 std::shared_ptr<Element> otherCurrent_ = std::shared_ptr<Element>(otherWeak_);
302 std::make_shared<MemberType>(*(otherCurrent_->element_));
303 current_->finer_=finer_;
304 if(otherCurrent_->redistributed_)
305 current_->redistributed_ =
306 std::make_shared<MemberType>(*(otherCurrent_->redistributed_));
308 if(not otherCurrent_->coarser_.expired())
310 auto c = std::allocate_shared<Element>(allocator_);
311 current_->coarser_ = c;
315 otherWeak_ = otherCurrent_->coarser_;
320 template<
class T,
class A>
326 template<
class T,
class A>
332 template<
class T,
class A>
340 coarsest_ = std::allocate_shared<Element>(allocator_);
341 coarsest_->element_ = originalFinest_;
344 auto old_coarsest = coarsest_;
345 coarsest_ = std::allocate_shared<Element>(allocator_);
346 coarsest_->finer_ = old_coarsest;
348 old_coarsest->coarser_ = coarsest_;
354 template<
class T,
class A>
363 finest_ = std::allocate_shared<Element>(allocator_);
364 finest_->element = originalFinest_;
367 finest_->finer_ = std::allocate_shared<Element>(allocator_);
368 finest_->finer_->coarser_ = finest_;
369 finest_ = finest_->finer_;
375 template<
class T,
class A>
381 template<
class T,
class A>
387 template<
class T,
class A>
390 return ConstIterator(finest_);
393 template<
class T,
class A>
394 typename Hierarchy<T,A>::ConstIterator Hierarchy<T,A>::coarsest()
const
396 return ConstIterator(coarsest_);