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