dune-pdelab  2.4-dev
chunkedblockordering.hh
Go to the documentation of this file.
1 // -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 // vi: set et ts=8 sw=2 sts=2:
3 
4 #ifndef DUNE_PDELAB_ORDERING_CHUNKEDBLOCKORDERING_HH
5 #define DUNE_PDELAB_ORDERING_CHUNKEDBLOCKORDERING_HH
6 
7 #include <dune/typetree/typetree.hh>
8 
12 
13 namespace Dune {
14  namespace PDELab {
15 
16  namespace ordering {
17 
18 #ifndef DOXYGEN // implementation internals
19 
20  namespace chunked {
21 
22  struct tag_base
23  {
24 
25  tag_base(std::size_t block_size)
26  : _block_size(block_size)
27  {}
28 
29  std::size_t blockSize() const
30  {
31  return _block_size;
32  }
33 
34  private:
35 
36  const std::size_t _block_size;
37 
38  };
39 
40  template<std::size_t i>
41  struct base_holder
42  : public tag_base
43  {
44 
45  base_holder(std::size_t block_size)
46  : tag_base(block_size)
47  {}
48 
49  };
50 
51  } // namespace chunked
52 
53 #endif // DOXYGEN
54 
57 
65  template<typename OrderingTag>
66  struct Chunked
67  : public chunked::base_holder<decorated_ordering_tag<Chunked<OrderingTag>,OrderingTag>::level>
68  , public decorated_ordering_tag<Chunked<OrderingTag>,OrderingTag>
69  {
70 
71  Chunked(std::size_t block_size)
72  : chunked::base_holder<decorated_ordering_tag<Chunked<OrderingTag>,OrderingTag>::level>(block_size)
73  {}
74 
75  Chunked(std::size_t block_size, const OrderingTag& tag)
76  : chunked::base_holder<decorated_ordering_tag<Chunked<OrderingTag>,OrderingTag>::level>(block_size)
77  , decorated_ordering_tag<Chunked<OrderingTag>,OrderingTag>(tag)
78  {}
79 
80  Chunked(std::size_t block_size, OrderingTag&& tag)
81  : chunked::base_holder<decorated_ordering_tag<Chunked<OrderingTag>,OrderingTag>::level>(block_size)
82  , decorated_ordering_tag<Chunked<OrderingTag>,OrderingTag>(std::move(tag))
83  {}
84 
85  template<std::size_t i>
86  const chunked::base_holder<i>& chunked() const
87  {
88  return *this;
89  }
90 
91  template<std::size_t i>
92  chunked::base_holder<i>& chunked()
93  {
94  return *this;
95  }
96 
97  };
98 
99  template<typename Decorated>
101  {
102  return true;
103  }
104 
105  } // namespace ordering
106 
109 
111  template<typename Ordering>
113  : public TypeTree::CompositeNode<Ordering>
114  , public VirtualOrderingBase<typename Ordering::Traits::DOFIndex,
115  typename Ordering::Traits::ContainerIndex>
116  , public OrderingBase<typename Ordering::Traits::DOFIndex,
117  typename Ordering::Traits::ContainerIndex>
118  {
119  public:
120  typedef typename Ordering::Traits Traits;
121 
122  static const bool consume_tree_index = false;
123 
124  private:
125 
126  typedef TypeTree::CompositeNode<Ordering> NodeT;
127 
128  typedef OrderingBase<
129  typename Ordering::Traits::DOFIndex,
130  typename Ordering::Traits::ContainerIndex
131  > BaseT;
132 
133  public:
134 
135  Ordering& ordering()
136  {
137  return this->template child<0>();
138  }
139 
140  const Ordering& ordering() const
141  {
142  return this->template child<0>();
143  }
144 
145 
146  ChunkedBlockOrdering(const typename NodeT::NodeStorage& ordering, const ordering::chunked::tag_base& tag)
147  : NodeT(ordering)
148  , BaseT(*this,true,nullptr,this)
149  , _tag(tag)
150  {
151  // copy grid partition information from local ordering.
152  this->setPartitionSet(this->ordering());
153  }
154 
156  : NodeT(r.nodeStorage())
157  , BaseT(r)
158  ,_tag(r._tag)
159  {
160  this->setDelegate(this);
161  }
162 
164  : NodeT(r.nodeStorage())
165  , BaseT(std::move(r))
166  ,_tag(r._tag)
167  {
168  this->setDelegate(this);
169  }
170 
171  virtual void map_index_dynamic(typename Traits::DOFIndexView di, typename Traits::ContainerIndex& ci) const
172  {
173  ordering().mapIndex(di,ci);
174  std::size_t flat_index = ci.back();
175  std::size_t block_index = flat_index / _tag.blockSize();
176  std::size_t inner_index = flat_index % _tag.blockSize();
177  ci.back() = inner_index;
178  ci.push_back(block_index);
179  }
180 
181  template<typename ItIn, typename ItOut>
182  void map_lfs_indices(ItIn in, const ItIn end, ItOut out) const
183  {
184  for (; in != end; ++in, ++out)
185  {
186  std::size_t flat_index = out->back();
187  std::size_t block_index = flat_index / _tag.blockSize();
188  std::size_t inner_index = flat_index % _tag.blockSize();
189  out->back() = inner_index;
190  out->push_back(block_index);
191  }
192  }
193 
194  template<typename CIOutIterator>
195  typename Traits::SizeType
196  extract_entity_indices(const typename Traits::DOFIndex::EntityIndex& ei,
197  typename Traits::SizeType child_index,
198  CIOutIterator ci_out, const CIOutIterator ci_end) const
199  {
200  for (; ci_out != ci_end; ++ci_out)
201  {
202  std::size_t flat_index = ci_out->back();
203  std::size_t block_index = flat_index / _tag.blockSize();
204  std::size_t inner_index = flat_index % _tag.blockSize();
205  ci_out->back() = inner_index;
206  ci_out->push_back(block_index);
207  }
208  return 0;
209  }
210 
211  void update()
212  {
213  ordering().update();
214  BaseT::update();
215  if (ordering().blockCount() % _tag.blockSize() != 0)
217  "Block size of chunked block ordering does not divide the block count "
218  "of the underlying ordering: "
219  << ordering().blockCount()
220  << " % "
221  << _tag.blockSize()
222  << " != 0"
223  );
224  this->_block_count = ordering().blockCount() / _tag.blockSize();
225  }
226 
227  private:
228 
229  const ordering::chunked::tag_base& _tag;
230 
231  };
232 
233  namespace ordering {
234 
235  namespace chunked {
236 
237  template<typename GFS, typename Transformation, typename Undecorated, typename Tag>
239  {
240 
242  typedef std::shared_ptr<transformed_type> transformed_storage_type;
243 
244  static transformed_type transform(const GFS& gfs, const Transformation& t, std::shared_ptr<Undecorated> undecorated)
245  {
246  return transformed_type(make_tuple(undecorated),gfs.orderingTag().template chunked<Tag::level>());
247  }
248 
249  static transformed_storage_type transform_storage(std::shared_ptr<const GFS> gfs_pointer, const Transformation& t, std::shared_ptr<Undecorated> undecorated)
250  {
251  return std::make_shared<transformed_type>(make_tuple(undecorated),gfs_pointer->orderingTag().template chunked<Tag::level>());
252  }
253 
254  };
255 
256  template<typename GFS, typename Transformation, typename Undecorated, typename GlueTag, typename UndecoratedTag>
257  gfs_to_chunked<GFS,Transformation,Undecorated,GlueTag>
258  register_gfs_to_decorator_descriptor(GFS*,Transformation*,Undecorated*,GlueTag*,Chunked<UndecoratedTag>*);
259 
260  } // namespace chunked
261  } // namespace ordering
262 
263 
264  template<typename GFS, typename Transformation, typename U>
265  struct power_gfs_to_local_ordering_descriptor<GFS,Transformation,ordering::Chunked<U> >
266  : public power_gfs_to_local_ordering_descriptor<GFS,Transformation,U>
267  {};
268 
269 
270  template<typename GFS, typename Transformation, typename U>
271  struct composite_gfs_to_local_ordering_descriptor<GFS,Transformation,ordering::Chunked<U> >
272  : public composite_gfs_to_local_ordering_descriptor<GFS,Transformation,U>
273  {};
274 
276  } // namespace PDELab
277 } // namespace Dune
278 
279 #endif // DUNE_PDELAB_ORDERING_CHUNKEDBLOCKORDERING_HH
const Ordering & ordering() const
Definition: chunkedblockordering.hh:140
DUNE_CONSTEXPR bool deactivate_standard_blocking_for_ordering(const Chunked< Decorated > &)
Definition: chunkedblockordering.hh:100
Chunked(std::size_t block_size, const OrderingTag &tag)
Definition: chunkedblockordering.hh:75
std::shared_ptr< transformed_type > transformed_storage_type
Definition: chunkedblockordering.hh:242
Chunked(std::size_t block_size)
Definition: chunkedblockordering.hh:71
Chunked(std::size_t block_size, OrderingTag &&tag)
Definition: chunkedblockordering.hh:80
static transformed_type transform(const GFS &gfs, const Transformation &t, std::shared_ptr< Undecorated > undecorated)
Definition: chunkedblockordering.hh:244
Traits::SizeType extract_entity_indices(const typename Traits::DOFIndex::EntityIndex &ei, typename Traits::SizeType child_index, CIOutIterator ci_out, const CIOutIterator ci_end) const
Definition: chunkedblockordering.hh:196
STL namespace.
gfs_to_chunked< GFS, Transformation, Undecorated, GlueTag > register_gfs_to_decorator_descriptor(GFS *, Transformation *, Undecorated *, GlueTag *, Chunked< UndecoratedTag > *)
ChunkedBlockOrdering(ChunkedBlockOrdering &&r)
Definition: chunkedblockordering.hh:163
The block size of a ChunkedBlockOrdering does not divide the block count of the underlying ordering...
Definition: exceptions.hh:54
Definition: chunkedblockordering.hh:238
virtual void map_index_dynamic(typename Traits::DOFIndexView di, typename Traits::ContainerIndex &ci) const
Definition: chunkedblockordering.hh:171
static transformed_storage_type transform_storage(std::shared_ptr< const GFS > gfs_pointer, const Transformation &t, std::shared_ptr< Undecorated > undecorated)
Definition: chunkedblockordering.hh:249
const chunked::base_holder< i > & chunked() const
Definition: chunkedblockordering.hh:86
void setPartitionSet(const std::bitset< 6 > &partitions)
Sets the set of contained partitions to the passed-in value.
Definition: partitioninfoprovider.hh:58
Definition: adaptivity.hh:27
static const bool consume_tree_index
Definition: chunkedblockordering.hh:122
ChunkedBlockOrdering(const ChunkedBlockOrdering &r)
Definition: chunkedblockordering.hh:155
Ordering that permutes top-level ContainerIndex entries.
Definition: chunkedblockordering.hh:112
void setDelegate(const VirtualOrderingBase< Ordering::Traits::DOFIndex, Ordering::Traits::ContainerIndex > *delegate)
Set the delegate called in mapIndex().
Definition: orderingbase.hh:228
void map_lfs_indices(ItIn in, const ItIn end, ItOut out) const
Definition: chunkedblockordering.hh:182
void update()
Definition: chunkedblockordering.hh:211
Definition: ordering/utility.hh:230
Definition: orderingbase.hh:21
Ordering & ordering()
Definition: chunkedblockordering.hh:135
Ordering::Traits Traits
Definition: chunkedblockordering.hh:120
ChunkedBlockOrdering(const typename NodeT::NodeStorage &ordering, const ordering::chunked::tag_base &tag)
Definition: chunkedblockordering.hh:146
chunked::base_holder< i > & chunked()
Definition: chunkedblockordering.hh:92
ChunkedBlockOrdering< Undecorated > transformed_type
Definition: chunkedblockordering.hh:241
Definition: chunkedblockordering.hh:66
void update()
Definition: orderingbase.hh:99