Reference documentation for deal.II version Git 53084d8c6a 2020-10-21 00:34:33 -0400
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
block_indices.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2000 - 2020 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii_block_indices_h
17 #define dealii_block_indices_h
18 
19 
20 #include <deal.II/base/config.h>
21 
23 #include <deal.II/base/logstream.h>
25 #include <deal.II/base/utilities.h>
26 
27 #include <cstddef>
28 #include <vector>
29 
31 
32 
59 class BlockIndices : public Subscriptor
60 {
61 public:
66 
70  BlockIndices();
71 
77  BlockIndices(const std::vector<size_type> &block_sizes);
78 
83  BlockIndices(BlockIndices &&b) noexcept;
84 
88  BlockIndices(const BlockIndices &) = default;
89 
93  explicit BlockIndices(const unsigned int n_blocks,
94  const size_type block_size = 0);
95 
100  void
101  reinit(const unsigned int n_blocks, const size_type n_elements_per_block);
102 
109  void
110  reinit(const std::vector<size_type> &block_sizes);
111 
115  void
116  push_back(const size_type size);
117 
122 
126  unsigned int
127  size() const;
128 
133  size_type
134  total_size() const;
135 
139  size_type
140  block_size(const unsigned int i) const;
141 
147  std::string
148  to_string() const;
149 
151 
161 
167  std::pair<unsigned int, size_type>
168  global_to_local(const size_type i) const;
169 
173  size_type
174  local_to_global(const unsigned int block, const size_type index) const;
175 
179  size_type
180  block_start(const unsigned int i) const;
182 
186  BlockIndices &
187  operator=(const BlockIndices &b);
188 
193  BlockIndices &
194  operator=(BlockIndices &&) noexcept;
195 
200  bool
201  operator==(const BlockIndices &b) const;
202 
206  void
207  swap(BlockIndices &b);
208 
213  std::size_t
214  memory_consumption() const;
215 
216 private:
221  unsigned int n_blocks;
222 
228 };
229 
230 
237 inline LogStream &
238 operator<<(LogStream &s, const BlockIndices &bi)
239 {
240  const unsigned int n = bi.size();
241  s << n << ":[";
242  // Write first size without leading space
243  if (n > 0)
244  s << bi.block_size(0);
245  // Write all other sizes
246  for (unsigned int i = 1; i < n; ++i)
247  s << ' ' << bi.block_size(i);
248  s << "]->" << bi.total_size();
249  return s;
250 }
251 
252 
253 
254 /* ---------------------- template and inline functions ------------------- */
255 
256 inline void
257 BlockIndices::reinit(const unsigned int nb, const size_type block_size)
258 {
259  n_blocks = nb;
260  start_indices.resize(n_blocks + 1);
261  for (size_type i = 0; i <= n_blocks; ++i)
262  start_indices[i] = i * block_size;
263 }
264 
265 
266 
267 inline void
268 BlockIndices::reinit(const std::vector<size_type> &block_sizes)
269 {
270  if (start_indices.size() != block_sizes.size() + 1)
271  {
272  n_blocks = static_cast<unsigned int>(block_sizes.size());
273  start_indices.resize(n_blocks + 1);
274  }
275  start_indices[0] = 0;
276  for (size_type i = 1; i <= n_blocks; ++i)
277  start_indices[i] = start_indices[i - 1] + block_sizes[i - 1];
278 }
279 
280 
282  : n_blocks(0)
283  , start_indices(1, 0)
284 {}
285 
286 
287 
288 inline BlockIndices::BlockIndices(const unsigned int n_blocks,
289  const size_type block_size)
290  : n_blocks(n_blocks)
291  , start_indices(n_blocks + 1)
292 {
293  for (size_type i = 0; i <= n_blocks; ++i)
294  start_indices[i] = i * block_size;
295 }
296 
297 
298 
299 inline BlockIndices::BlockIndices(const std::vector<size_type> &block_sizes)
300  : n_blocks(static_cast<unsigned int>(block_sizes.size()))
301  , start_indices(block_sizes.size() + 1)
302 {
303  reinit(block_sizes);
304 }
305 
306 
307 
309  : n_blocks(b.n_blocks)
310  , start_indices(std::move(b.start_indices))
311 {
312  b.n_blocks = 0;
313  b.start_indices = std::vector<size_type>(1, 0);
314 }
315 
316 
317 
318 inline void
320 {
321  start_indices.push_back(start_indices[n_blocks] + sz);
322  ++n_blocks;
324 }
325 
326 
327 inline std::pair<unsigned int, BlockIndices::size_type>
329 {
331  Assert(n_blocks > 0, ExcLowerRangeType<size_type>(i, size_type(1)));
332 
333  // start_indices[0] == 0 so we might as well start from the next one
334  const auto it =
335  --std::upper_bound(++start_indices.begin(), start_indices.end(), i);
336 
337  return {std::distance(start_indices.begin(), it), i - *it};
338 }
339 
340 
342 BlockIndices::local_to_global(const unsigned int block,
343  const size_type index) const
344 {
345  AssertIndexRange(block, n_blocks);
346  AssertIndexRange(index, start_indices[block + 1] - start_indices[block]);
347 
348  return start_indices[block] + index;
349 }
350 
351 
352 inline unsigned int
354 {
355  return n_blocks;
356 }
357 
358 
359 
362 {
363  if (n_blocks == 0)
364  return 0;
365  return start_indices[n_blocks];
366 }
367 
368 
369 
371 BlockIndices::block_size(const unsigned int block) const
372 {
373  AssertIndexRange(block, n_blocks);
374  return start_indices[block + 1] - start_indices[block];
375 }
376 
377 
378 
379 inline std::string
381 {
382  std::string result = "[" + Utilities::int_to_string(n_blocks) + "->";
383  for (unsigned int i = 0; i < n_blocks; ++i)
384  {
385  if (i > 0)
386  result += ',';
387  result += std::to_string(block_size(i));
388  }
389  result += "|" + std::to_string(total_size()) + ']';
390  return result;
391 }
392 
393 
394 
396 BlockIndices::block_start(const unsigned int block) const
397 {
398  AssertIndexRange(block, n_blocks);
399  return start_indices[block];
400 }
401 
402 
403 
404 inline BlockIndices &
406 {
408  n_blocks = b.n_blocks;
409  return *this;
410 }
411 
412 
413 
414 inline BlockIndices &
416 {
417  start_indices = std::move(b.start_indices);
418  n_blocks = b.n_blocks;
419 
420  b.start_indices = std::vector<size_type>(1, 0);
421  b.n_blocks = 0;
422 
423  return *this;
424 }
425 
426 
427 
428 inline bool
430 {
431  if (n_blocks != b.n_blocks)
432  return false;
433 
434  for (size_type i = 0; i <= n_blocks; ++i)
435  if (start_indices[i] != b.start_indices[i])
436  return false;
437 
438  return true;
439 }
440 
441 
442 
443 inline void
445 {
448 }
449 
450 
451 
452 inline std::size_t
454 {
455  return (sizeof(*this) + start_indices.size() * sizeof(start_indices[0]));
456 }
457 
458 
459 
460 /* ----------------- global functions ---------------------------- */
461 
462 
470 inline void
472 {
473  u.swap(v);
474 }
475 
476 
477 
479 
480 #endif
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1580
#define AssertIndexRange(index, range)
Definition: exceptions.h:1648
STL namespace.
size_type block_size(const unsigned int i) const
size_type total_size() const
unsigned int n_blocks
bool operator==(const BlockIndices &b) const
#define Assert(cond, exc)
Definition: exceptions.h:1423
void reinit(const unsigned int n_blocks, const size_type n_elements_per_block)
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:369
std::string to_string() const
void swap(BlockIndices &u, BlockIndices &v)
std::string to_string(const T &t)
Definition: patterns.h:2341
size_type local_to_global(const unsigned int block, const size_type index) const
std::string int_to_string(const unsigned int value, const unsigned int digits=numbers::invalid_unsigned_int)
Definition: utilities.cc:474
std::vector< size_type > start_indices
SymmetricTensor< 2, dim, Number > b(const Tensor< 2, dim, Number > &F)
unsigned int global_dof_index
Definition: types.h:76
BlockIndices & operator=(const BlockIndices &b)
std::size_t memory_consumption() const
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:368
size_type block_start(const unsigned int i) const
void push_back(const size_type size)
void swap(BlockIndices &b)
types::global_dof_index size_type
Definition: block_indices.h:65
unsigned int size() const
std::pair< unsigned int, size_type > global_to_local(const size_type i) const