Loading [MathJax]/extensions/TeX/newcommand.js
 Reference documentation for deal.II version 9.4.1
\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\}}
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
vector_access_internal.h
Go to the documentation of this file.
1// ---------------------------------------------------------------------
2//
3// Copyright (C) 2019 - 2022 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
17#ifndef dealii_matrix_free_vector_access_internal_h
18#define dealii_matrix_free_vector_access_internal_h
19
20#include <deal.II/base/config.h>
21
23
27
28#if DEBUG
29# include <boost/algorithm/string/join.hpp>
30#endif
31
33
34
35namespace internal
36{
37 // below we use type-traits from matrix-free/type_traits.h
38
39 // access to generic const vectors that have operator ().
40 // FIXME: this is wrong for Trilinos/Petsc MPI vectors
41 // where we should first do Partitioner::local_to_global()
42 template <typename VectorType,
43 typename std::enable_if<!has_local_element<VectorType>,
44 VectorType>::type * = nullptr>
45 inline typename VectorType::value_type
46 vector_access(const VectorType &vec, const unsigned int entry)
47 {
48 return vec(entry);
49 }
50
51
52
53 // access to generic non-const vectors that have operator ().
54 // FIXME: this is wrong for Trilinos/Petsc MPI vectors
55 // where we should first do Partitioner::local_to_global()
56 template <typename VectorType,
57 typename std::enable_if<!has_local_element<VectorType>,
58 VectorType>::type * = nullptr>
59 inline typename VectorType::value_type &
60 vector_access(VectorType &vec, const unsigned int entry)
61 {
62 return vec(entry);
63 }
64
65
66
67 // access to distributed MPI vectors that have a local_element(uint)
68 // method to access data in local index space, which is what we use in
69 // DoFInfo and hence in read_dof_values etc.
70 template <typename VectorType,
71 typename std::enable_if<has_local_element<VectorType>,
72 VectorType>::type * = nullptr>
73 inline typename VectorType::value_type &
74 vector_access(VectorType &vec, const unsigned int entry)
75 {
76 return vec.local_element(entry);
77 }
78
79
80
81 // same for const access
82 template <typename VectorType,
83 typename std::enable_if<has_local_element<VectorType>,
84 VectorType>::type * = nullptr>
85 inline typename VectorType::value_type
86 vector_access(const VectorType &vec, const unsigned int entry)
87 {
88 return vec.local_element(entry);
89 }
90
91
92
93 template <typename VectorType,
94 typename std::enable_if<has_add_local_element<VectorType>,
95 VectorType>::type * = nullptr>
96 inline void
97 vector_access_add(VectorType & vec,
98 const unsigned int entry,
99 const typename VectorType::value_type &val)
100 {
101 vec.add_local_element(entry, val);
102 }
103
104
105
106 template <typename VectorType,
107 typename std::enable_if<!has_add_local_element<VectorType>,
108 VectorType>::type * = nullptr>
109 inline void
110 vector_access_add(VectorType & vec,
111 const unsigned int entry,
112 const typename VectorType::value_type &val)
113 {
114 vector_access(vec, entry) += val;
115 }
116
117
118
119 template <typename VectorType,
120 typename std::enable_if<has_add_local_element<VectorType>,
121 VectorType>::type * = nullptr>
122 inline void
123 vector_access_add_global(VectorType & vec,
124 const types::global_dof_index entry,
125 const typename VectorType::value_type &val)
126 {
127 vec.add(entry, val);
128 }
129
130
131
132 template <typename VectorType,
133 typename std::enable_if<!has_add_local_element<VectorType>,
134 VectorType>::type * = nullptr>
135 inline void
136 vector_access_add_global(VectorType & vec,
137 const types::global_dof_index entry,
138 const typename VectorType::value_type &val)
139 {
140 vec(entry) += val;
141 }
142
143
144
145 template <typename VectorType,
146 typename std::enable_if<has_set_local_element<VectorType>,
147 VectorType>::type * = nullptr>
148 inline void
149 vector_access_set(VectorType & vec,
150 const unsigned int entry,
151 const typename VectorType::value_type &val)
152 {
153 vec.set_local_element(entry, val);
154 }
155
156
157
158 template <typename VectorType,
159 typename std::enable_if<!has_set_local_element<VectorType>,
160 VectorType>::type * = nullptr>
161 inline void
162 vector_access_set(VectorType & vec,
163 const unsigned int entry,
164 const typename VectorType::value_type &val)
165 {
166 vector_access(vec, entry) = val;
167 }
168
169
170
171 // this is to make sure that the parallel partitioning in VectorType
172 // is really the same as stored in MatrixFree.
173 // version below is when has_partitioners_are_compatible == false
174 // FIXME: this is incorrect for PETSc/Trilinos MPI vectors
175 template <
176 int dim,
177 typename Number,
178 typename VectorizedArrayType,
179 typename VectorType,
180 typename std::enable_if<!has_partitioners_are_compatible<VectorType>,
181 VectorType>::type * = nullptr>
182 inline void
184 const VectorType & vec,
187 {
188 (void)vec;
189 (void)matrix_free;
190 (void)dof_info;
191
192 AssertDimension(vec.size(), dof_info.vector_partitioner->size());
193 }
194
195
196
197 // same as above for has_partitioners_are_compatible == true
198 template <int dim,
199 typename Number,
200 typename VectorizedArrayType,
201 typename VectorType,
202 typename std::enable_if<has_partitioners_are_compatible<VectorType>,
203 VectorType>::type * = nullptr>
204 inline void
206 const VectorType & vec,
209 {
210 (void)vec;
211 (void)matrix_free;
212 (void)dof_info;
213
214#if DEBUG
215 if (vec.partitioners_are_compatible(*dof_info.vector_partitioner) == false)
216 {
217 unsigned int dof_index = numbers::invalid_unsigned_int;
218
219 for (unsigned int i = 0; i < matrix_free.n_components(); ++i)
220 if (&matrix_free.get_dof_info(i) == &dof_info)
221 {
222 dof_index = i;
223 break;
224 }
225
227
228 std::vector<std::string> dof_indices_with_compatible_partitioners;
229
230 for (unsigned int i = 0; i < matrix_free.n_components(); ++i)
231 if (vec.partitioners_are_compatible(
232 *matrix_free.get_dof_info(i).vector_partitioner))
233 dof_indices_with_compatible_partitioners.push_back(
234 std::to_string(i));
235
236 if (dof_indices_with_compatible_partitioners.empty())
237 {
238 Assert(false,
239 ExcMessage("The parallel layout of the given vector is "
240 "compatible neither with the Partitioner of the "
241 "current FEEvaluation with dof_handler_index=" +
242 std::to_string(dof_index) +
243 " nor with any Partitioner in MatrixFree. A "
244 "potential reason is that you did not use "
245 "MatrixFree::initialize_dof_vector() to get a "
246 "compatible vector."));
247 }
248 else
249 {
250 Assert(
251 false,
253 "The parallel layout of the given vector is "
254 "not compatible with the Partitioner of the "
255 "current FEEvaluation with dof_handler_index=" +
256 std::to_string(dof_index) +
257 ". However, the underlying "
258 "MatrixFree contains Partitioner objects that are compatible. "
259 "They have the following dof_handler_index values: " +
260 boost::algorithm::join(dof_indices_with_compatible_partitioners,
261 ", ") +
262 ". Did you want to pass any of these values to the "
263 "constructor of the current FEEvaluation object or "
264 "did you not use MatrixFree::initialize_dof_vector() "
265 "with dof_handler_index=" +
266 std::to_string(dof_index) +
267 " to get a "
268 "compatible vector?"));
269 }
270 }
271#endif
272 }
273
274
275
276 // Below, three classes (VectorReader, VectorSetter,
277 // VectorDistributorLocalToGlobal) implement the same interface and can be
278 // used to to read from vector, set elements of a vector and add to elements
279 // of the vector.
280
281 // 1. A class to read data from vector
282 template <typename Number, typename VectorizedArrayType>
284 {
285 template <typename VectorType>
286 void
287 process_dof(const unsigned int index,
288 const VectorType & vec,
289 Number & res) const
290 {
291 res = vector_access(vec, index);
292 }
293
294
295
296 template <typename VectorNumberType>
297 void
298 process_dof(const VectorNumberType &global, Number &local) const
299 {
300 local = global;
301 }
302
303
304
305 template <typename VectorType>
306 void
307 process_dofs_vectorized(const unsigned int dofs_per_cell,
308 const unsigned int dof_index,
309 VectorType & vec,
310 VectorizedArrayType *dof_values,
311 std::integral_constant<bool, true>) const
312 {
313#ifdef DEBUG
314 // in debug mode, run non-vectorized version because this path
315 // has additional checks (e.g., regarding ghosting)
316 process_dofs_vectorized(dofs_per_cell,
317 dof_index,
318 vec,
319 dof_values,
320 std::integral_constant<bool, false>());
321#else
322 const Number *vec_ptr = vec.begin() + dof_index;
323 for (unsigned int i = 0; i < dofs_per_cell;
324 ++i, vec_ptr += VectorizedArrayType::size())
325 dof_values[i].load(vec_ptr);
326#endif
327 }
328
329
330
331 template <typename VectorType>
332 void
333 process_dofs_vectorized(const unsigned int dofs_per_cell,
334 const unsigned int dof_index,
335 const VectorType & vec,
336 VectorizedArrayType *dof_values,
337 std::integral_constant<bool, false>) const
338 {
339 for (unsigned int i = 0; i < dofs_per_cell; ++i)
340 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
341 dof_values[i][v] =
342 vector_access(vec, dof_index + v + i * VectorizedArrayType::size());
343 }
344
345
346
347 template <typename VectorType>
348 void
349 process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
350 const unsigned int * dof_indices,
351 VectorType & vec,
352 VectorizedArrayType *dof_values,
353 std::integral_constant<bool, true>) const
354 {
356 vec.begin(),
357 dof_indices,
358 dof_values);
359 }
360
361
362
363 template <typename VectorType>
364 void
365 process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
366 const unsigned int * dof_indices,
367 const VectorType & vec,
368 VectorizedArrayType *dof_values,
369 std::integral_constant<bool, false>) const
370 {
371 for (unsigned int d = 0; d < dofs_per_cell; ++d)
372 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
373 dof_values[d][v] = vector_access(vec, dof_indices[v] + d);
374 }
375
376
377
378 template <typename Number2>
379 void
381 const unsigned int dofs_per_cell,
382 const std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
383 VectorizedArrayType * dof_values,
384 std::integral_constant<bool, true>) const
385 {
387 global_ptr,
388 dof_values);
389 }
390
391
392
393 template <typename Number2>
394 void
396 const unsigned int,
397 const std::array<Number2 *, VectorizedArrayType::size()> &,
398 VectorizedArrayType *,
399 std::integral_constant<bool, false>) const
400 {
401 Assert(false, ExcNotImplemented());
402 }
403
404
405
406 // variant where VectorType::value_type is the same as Number -> can call
407 // gather
408 template <typename VectorType>
409 void
410 process_dof_gather(const unsigned int * indices,
411 VectorType & vec,
412 const unsigned int constant_offset,
413 VectorizedArrayType &res,
414 std::integral_constant<bool, true>) const
415 {
416#ifdef DEBUG
417 // in debug mode, run non-vectorized version because this path
418 // has additional checks (e.g., regarding ghosting)
419 process_dof_gather(indices,
420 vec,
421 constant_offset,
422 res,
423 std::integral_constant<bool, false>());
424#else
425 res.gather(vec.begin() + constant_offset, indices);
426#endif
427 }
428
429
430
431 // variant where VectorType::value_type is not the same as Number -> must
432 // manually load the data
433 template <typename VectorType>
434 void
435 process_dof_gather(const unsigned int * indices,
436 const VectorType & vec,
437 const unsigned int constant_offset,
438 VectorizedArrayType &res,
439 std::integral_constant<bool, false>) const
440 {
441 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
442 res[v] = vector_access(vec, indices[v] + constant_offset);
443 }
444
445
446
447 template <typename VectorType>
448 void
450 const VectorType & vec,
451 Number & res) const
452 {
453 res = vec(index);
454 }
455
456
457
458 void
459 pre_constraints(const Number &, Number &res) const
460 {
461 res = Number();
462 }
463
464
465
466 template <typename VectorType>
467 void
468 process_constraint(const unsigned int index,
469 const Number weight,
470 const VectorType & vec,
471 Number & res) const
472 {
473 res += weight * vector_access(vec, index);
474 }
475
476
477
478 void
479 post_constraints(const Number &sum, Number &write_pos) const
480 {
481 write_pos = sum;
482 }
483
484
485
486 void
487 process_empty(VectorizedArrayType &res) const
488 {
489 res = VectorizedArrayType();
490 }
491 };
492
493
494
495 // 2. A class to add values to the vector during
496 // FEEvaluation::distribute_local_to_global() call
497 template <typename Number, typename VectorizedArrayType>
499 {
500 template <typename VectorType>
501 void
502 process_dof(const unsigned int index, VectorType &vec, Number &res) const
503 {
504 vector_access_add(vec, index, res);
505 }
506
507
508 template <typename VectorNumberType>
509 void
510 process_dof(VectorNumberType &global, Number &local) const
511 {
512 global += local;
513 }
514
515
516
517 template <typename VectorType>
518 void
519 process_dofs_vectorized(const unsigned int dofs_per_cell,
520 const unsigned int dof_index,
521 VectorType & vec,
522 VectorizedArrayType *dof_values,
523 std::integral_constant<bool, true>) const
524 {
525 Number *vec_ptr = vec.begin() + dof_index;
526 for (unsigned int i = 0; i < dofs_per_cell;
527 ++i, vec_ptr += VectorizedArrayType::size())
528 {
529 VectorizedArrayType tmp;
530 tmp.load(vec_ptr);
531 tmp += dof_values[i];
532 tmp.store(vec_ptr);
533 }
534 }
535
536
537
538 template <typename VectorType>
539 void
540 process_dofs_vectorized(const unsigned int dofs_per_cell,
541 const unsigned int dof_index,
542 VectorType & vec,
543 VectorizedArrayType *dof_values,
544 std::integral_constant<bool, false>) const
545 {
546 for (unsigned int i = 0; i < dofs_per_cell; ++i)
547 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
549 dof_index + v + i * VectorizedArrayType::size(),
550 dof_values[i][v]);
551 }
552
553
554
555 template <typename VectorType>
556 void
557 process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
558 const unsigned int * dof_indices,
559 VectorType & vec,
560 VectorizedArrayType *dof_values,
561 std::integral_constant<bool, true>) const
562 {
564 true, dofs_per_cell, dof_values, dof_indices, vec.begin());
565 }
566
567
568
569 template <typename VectorType>
570 void
571 process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
572 const unsigned int * dof_indices,
573 VectorType & vec,
574 VectorizedArrayType *dof_values,
575 std::integral_constant<bool, false>) const
576 {
577 for (unsigned int d = 0; d < dofs_per_cell; ++d)
578 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
579 vector_access_add(vec, dof_indices[v] + d, dof_values[d][v]);
580 }
581
582
583
584 template <typename Number2>
585 void
587 const unsigned int dofs_per_cell,
588 std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
589 VectorizedArrayType * dof_values,
590 std::integral_constant<bool, true>) const
591 {
593 dofs_per_cell,
594 dof_values,
595 global_ptr);
596 }
597
598
599
600 template <typename Number2>
601 void
603 const unsigned int,
604 std::array<Number2 *, VectorizedArrayType::size()> &,
605 VectorizedArrayType *,
606 std::integral_constant<bool, false>) const
607 {
608 Assert(false, ExcNotImplemented());
609 }
610
611
612
613 // variant where VectorType::value_type is the same as Number -> can call
614 // scatter
615 template <typename VectorType>
616 void
617 process_dof_gather(const unsigned int * indices,
618 VectorType & vec,
619 const unsigned int constant_offset,
620 VectorizedArrayType &res,
621 std::integral_constant<bool, true>) const
622 {
623#if DEAL_II_VECTORIZATION_WIDTH_IN_BITS < 512
624 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
625 vector_access(vec, indices[v] + constant_offset) += res[v];
626#else
627 // only use gather in case there is also scatter.
628 VectorizedArrayType tmp;
629 tmp.gather(vec.begin() + constant_offset, indices);
630 tmp += res;
631 tmp.scatter(indices, vec.begin() + constant_offset);
632#endif
633 }
634
635
636
637 // variant where VectorType::value_type is not the same as Number -> must
638 // manually append all data
639 template <typename VectorType>
640 void
641 process_dof_gather(const unsigned int * indices,
642 VectorType & vec,
643 const unsigned int constant_offset,
644 VectorizedArrayType &res,
645 std::integral_constant<bool, false>) const
646 {
647 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
648 vector_access_add(vec, indices[v] + constant_offset, res[v]);
649 }
650
651
652
653 template <typename VectorType>
654 void
656 VectorType & vec,
657 Number & res) const
658 {
660 }
661
662
663
664 void
665 pre_constraints(const Number &input, Number &res) const
666 {
667 res = input;
668 }
669
670
671
672 template <typename VectorType>
673 void
674 process_constraint(const unsigned int index,
675 const Number weight,
676 VectorType & vec,
677 Number & res) const
678 {
679 vector_access_add(vec, index, weight * res);
680 }
681
682
683
684 void
685 post_constraints(const Number &, Number &) const
686 {}
687
688
689
690 void
691 process_empty(VectorizedArrayType &) const
692 {}
693 };
694
695
696
697 // 3. A class to set elements of the vector
698 template <typename Number, typename VectorizedArrayType>
700 {
701 template <typename VectorType>
702 void
703 process_dof(const unsigned int index, VectorType &vec, Number &res) const
704 {
705 vector_access(vec, index) = res;
706 }
707
708
709
710 template <typename VectorNumberType>
711 void
712 process_dof(VectorNumberType &global, Number &local) const
713 {
714 global = local;
715 }
716
717
718
719 template <typename VectorType>
720 void
721 process_dofs_vectorized(const unsigned int dofs_per_cell,
722 const unsigned int dof_index,
723 VectorType & vec,
724 VectorizedArrayType *dof_values,
725 std::integral_constant<bool, true>) const
726 {
727 Number *vec_ptr = vec.begin() + dof_index;
728 for (unsigned int i = 0; i < dofs_per_cell;
729 ++i, vec_ptr += VectorizedArrayType::size())
730 dof_values[i].store(vec_ptr);
731 }
732
733
734
735 template <typename VectorType>
736 void
737 process_dofs_vectorized(const unsigned int dofs_per_cell,
738 const unsigned int dof_index,
739 VectorType & vec,
740 VectorizedArrayType *dof_values,
741 std::integral_constant<bool, false>) const
742 {
743 for (unsigned int i = 0; i < dofs_per_cell; ++i)
744 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
745 vector_access(vec, dof_index + v + i * VectorizedArrayType::size()) =
746 dof_values[i][v];
747 }
748
749
750
751 template <typename VectorType>
752 void
753 process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
754 const unsigned int * dof_indices,
755 VectorType & vec,
756 VectorizedArrayType *dof_values,
757 std::integral_constant<bool, true>) const
758 {
760 false, dofs_per_cell, dof_values, dof_indices, vec.begin());
761 }
762
763
764
765 template <typename VectorType, bool booltype>
766 void
767 process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
768 const unsigned int * dof_indices,
769 VectorType & vec,
770 VectorizedArrayType *dof_values,
771 std::integral_constant<bool, false>) const
772 {
773 for (unsigned int i = 0; i < dofs_per_cell; ++i)
774 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
775 vector_access(vec, dof_indices[v] + i) = dof_values[i][v];
776 }
777
778
779
780 template <typename Number2>
781 void
783 const unsigned int dofs_per_cell,
784 std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
785 VectorizedArrayType * dof_values,
786 std::integral_constant<bool, true>) const
787 {
789 dofs_per_cell,
790 dof_values,
791 global_ptr);
792 }
793
794
795
796 template <typename Number2>
797 void
799 const unsigned int,
800 std::array<Number2 *, VectorizedArrayType::size()> &,
801 VectorizedArrayType *,
802 std::integral_constant<bool, false>) const
803 {
804 Assert(false, ExcNotImplemented());
805 }
806
807
808
809 template <typename VectorType>
810 void
811 process_dof_gather(const unsigned int * indices,
812 VectorType & vec,
813 const unsigned int constant_offset,
814 VectorizedArrayType &res,
815 std::integral_constant<bool, true>) const
816 {
817 res.scatter(indices, vec.begin() + constant_offset);
818 }
819
820
821
822 template <typename VectorType>
823 void
824 process_dof_gather(const unsigned int * indices,
825 VectorType & vec,
826 const unsigned int constant_offset,
827 VectorizedArrayType &res,
828 std::integral_constant<bool, false>) const
829 {
830 for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
831 vector_access(vec, indices[v] + constant_offset) = res[v];
832 }
833
834
835
836 template <typename VectorType>
837 void
839 VectorType & vec,
840 Number & res) const
841 {
842 vec(index) = res;
843 }
844
845
846
847 void
848 pre_constraints(const Number &, Number &) const
849 {}
850
851
852
853 template <typename VectorType>
854 void
855 process_constraint(const unsigned int,
856 const Number,
857 VectorType &,
858 Number &) const
859 {}
860
861
862
863 void
864 post_constraints(const Number &, Number &) const
865 {}
866
867
868
869 void
870 process_empty(VectorizedArrayType &) const
871 {}
872 };
873} // namespace internal
874
875
877
878#endif
const internal::MatrixFreeFunctions::DoFInfo & get_dof_info(const unsigned int dof_handler_index_component=0) const
unsigned int n_components() const
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:442
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:443
static ::ExceptionBase & ExcNotImplemented()
#define Assert(cond, exc)
Definition: exceptions.h:1473
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1667
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcMessage(std::string arg1)
void vector_access_add(VectorType &vec, const unsigned int entry, const typename VectorType::value_type &val)
void check_vector_compatibility(const VectorType &vec, const MatrixFree< dim, Number, VectorizedArrayType > &matrix_free, const internal::MatrixFreeFunctions::DoFInfo &dof_info)
void vector_access_add_global(VectorType &vec, const types::global_dof_index entry, const typename VectorType::value_type &val)
VectorType::value_type vector_access(const VectorType &vec, const unsigned int entry)
void vector_access_set(VectorType &vec, const unsigned int entry, const typename VectorType::value_type &val)
static const unsigned int invalid_unsigned_int
Definition: types.h:201
std::shared_ptr< const Utilities::MPI::Partitioner > vector_partitioner
Definition: dof_info.h:621
void process_dof_gather(const unsigned int *indices, VectorType &vec, const unsigned int constant_offset, VectorizedArrayType &res, std::integral_constant< bool, true >) const
void pre_constraints(const Number &input, Number &res) const
void process_dofs_vectorized_transpose(const unsigned int dofs_per_cell, const unsigned int *dof_indices, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) const
void process_dofs_vectorized_transpose(const unsigned int, std::array< Number2 *, VectorizedArrayType::size()> &, VectorizedArrayType *, std::integral_constant< bool, false >) const
void process_empty(VectorizedArrayType &) const
void process_dof(const unsigned int index, VectorType &vec, Number &res) const
void process_dofs_vectorized(const unsigned int dofs_per_cell, const unsigned int dof_index, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) const
void post_constraints(const Number &, Number &) const
void process_dofs_vectorized_transpose(const unsigned int dofs_per_cell, const unsigned int *dof_indices, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, false >) const
void process_dofs_vectorized_transpose(const unsigned int dofs_per_cell, std::array< Number2 *, VectorizedArrayType::size()> &global_ptr, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) const
void process_dof_gather(const unsigned int *indices, VectorType &vec, const unsigned int constant_offset, VectorizedArrayType &res, std::integral_constant< bool, false >) const
void process_dof(VectorNumberType &global, Number &local) const
void process_dofs_vectorized(const unsigned int dofs_per_cell, const unsigned int dof_index, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, false >) const
void process_constraint(const unsigned int index, const Number weight, VectorType &vec, Number &res) const
void process_dof_global(const types::global_dof_index index, VectorType &vec, Number &res) const
void process_dof_gather(const unsigned int *indices, VectorType &vec, const unsigned int constant_offset, VectorizedArrayType &res, std::integral_constant< bool, true >) const
void process_dof_gather(const unsigned int *indices, const VectorType &vec, const unsigned int constant_offset, VectorizedArrayType &res, std::integral_constant< bool, false >) const
void process_dofs_vectorized(const unsigned int dofs_per_cell, const unsigned int dof_index, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) const
void pre_constraints(const Number &, Number &res) const
void post_constraints(const Number &sum, Number &write_pos) const
void process_dofs_vectorized_transpose(const unsigned int dofs_per_cell, const unsigned int *dof_indices, const VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, false >) const
void process_dof_global(const types::global_dof_index index, const VectorType &vec, Number &res) const
void process_dofs_vectorized_transpose(const unsigned int dofs_per_cell, const unsigned int *dof_indices, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) const
void process_dofs_vectorized(const unsigned int dofs_per_cell, const unsigned int dof_index, const VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, false >) const
void process_constraint(const unsigned int index, const Number weight, const VectorType &vec, Number &res) const
void process_dof(const VectorNumberType &global, Number &local) const
void process_dofs_vectorized_transpose(const unsigned int dofs_per_cell, const std::array< Number2 *, VectorizedArrayType::size()> &global_ptr, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) const
void process_empty(VectorizedArrayType &res) const
void process_dofs_vectorized_transpose(const unsigned int, const std::array< Number2 *, VectorizedArrayType::size()> &, VectorizedArrayType *, std::integral_constant< bool, false >) const
void process_dof(const unsigned int index, const VectorType &vec, Number &res) const
void process_dofs_vectorized(const unsigned int dofs_per_cell, const unsigned int dof_index, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) const
void process_empty(VectorizedArrayType &) const
void process_dofs_vectorized_transpose(const unsigned int, std::array< Number2 *, VectorizedArrayType::size()> &, VectorizedArrayType *, std::integral_constant< bool, false >) const
void process_dofs_vectorized_transpose(const unsigned int dofs_per_cell, const unsigned int *dof_indices, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, false >) const
void process_dof_global(const types::global_dof_index index, VectorType &vec, Number &res) const
void pre_constraints(const Number &, Number &) const
void process_dofs_vectorized_transpose(const unsigned int dofs_per_cell, std::array< Number2 *, VectorizedArrayType::size()> &global_ptr, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) const
void process_dofs_vectorized(const unsigned int dofs_per_cell, const unsigned int dof_index, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, false >) const
void process_dofs_vectorized_transpose(const unsigned int dofs_per_cell, const unsigned int *dof_indices, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) const
void process_constraint(const unsigned int, const Number, VectorType &, Number &) const
void process_dof(const unsigned int index, VectorType &vec, Number &res) const
void process_dof_gather(const unsigned int *indices, VectorType &vec, const unsigned int constant_offset, VectorizedArrayType &res, std::integral_constant< bool, true >) const
void process_dof_gather(const unsigned int *indices, VectorType &vec, const unsigned int constant_offset, VectorizedArrayType &res, std::integral_constant< bool, false >) const
void post_constraints(const Number &, Number &) const
void process_dof(VectorNumberType &global, Number &local) const
void vectorized_load_and_transpose(const unsigned int n_entries, const Number *in, const unsigned int *offsets, VectorizedArray< Number, width > *out)
void vectorized_transpose_and_store(const bool add_into, const unsigned int n_entries, const VectorizedArray< Number, width > *in, const unsigned int *offsets, Number *out)