Reference documentation for deal.II version Git e87e13460a 2021-10-28 06:28:57 +0200
\(\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 
23 
26 
27 
29 
30 
31 namespace 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
177  const VectorType & vec,
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
195  const VectorType & vec,
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>
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
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
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
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>
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  {
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
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  {
510  dofs_per_cell,
511  dof_values,
512  global_ptr);
513  }
514 
515 
516 
517  template <typename Number2>
518  void
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
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>
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  {
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
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  {
706  dofs_per_cell,
707  dof_values,
708  global_ptr);
709  }
710 
711 
712 
713  template <typename Number2>
714  void
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
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 
794 
795 #endif
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_constraint(const unsigned int index, const Number weight, 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, false >) const
void process_dofs_vectorized_transpose(const unsigned int, std::array< Number2 *, VectorizedArrayType::size()> &, VectorizedArrayType *, std::integral_constant< bool, false >) const
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1655
void pre_constraints(const Number &, Number &) const
void pre_constraints(const Number &, 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_dof_gather(const unsigned int *indices, VectorType &vec, const unsigned int constant_offset, VectorizedArrayType &res, std::integral_constant< bool, false >) const
void pre_constraints(const Number &input, Number &res) const
void process_constraint(const unsigned int index, const Number weight, VectorType &vec, Number &res) const
std::shared_ptr< const Utilities::MPI::Partitioner > vector_partitioner
Definition: dof_info.h:598
void process_constraint(const unsigned int, const Number, VectorType &, Number &) const
void post_constraints(const Number &, Number &) 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_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(const unsigned int dofs_per_cell, const unsigned int dof_index, VectorType &vec, VectorizedArrayType *dof_values, std::integral_constant< bool, true >) 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_global(const types::global_dof_index index, VectorType &vec, Number &res) const
void vector_access_add_global(VectorType &vec, const types::global_dof_index entry, const typename VectorType::value_type &val)
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 post_constraints(const Number &sum, Number &write_pos) const
VectorType::value_type vector_access(const VectorType &vec, const unsigned int entry)
void vectorized_load_and_transpose(const unsigned int n_entries, const Number *in, const unsigned int *offsets, VectorizedArray< Number, width > *out)
static ::ExceptionBase & ExcMessage(std::string arg1)
void process_empty(VectorizedArrayType &) const
T sum(const T &t, const MPI_Comm &mpi_communicator)
#define Assert(cond, exc)
Definition: exceptions.h:1461
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(VectorNumberType &global, Number &local) const
void process_dofs_vectorized_transpose(const unsigned int, const std::array< Number2 *, VectorizedArrayType::size()> &, VectorizedArrayType *, std::integral_constant< bool, false >) const
void process_dofs_vectorized_transpose(const unsigned int, std::array< Number2 *, VectorizedArrayType::size()> &, VectorizedArrayType *, std::integral_constant< bool, false >) const
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:401
void process_empty(VectorizedArrayType &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_empty(VectorizedArrayType &) 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
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
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_dof(const unsigned int index, const VectorType &vec, Number &res) const
void post_constraints(const Number &, Number &) const
unsigned int global_dof_index
Definition: types.h:76
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_dof(const VectorNumberType &global, Number &local) 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
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:400
void process_dof_global(const types::global_dof_index index, const VectorType &vec, Number &res) const
void vector_access_add(VectorType &vec, const unsigned int entry, const typename VectorType::value_type &val)
static ::ExceptionBase & ExcNotImplemented()
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 vectorized_transpose_and_store(const bool add_into, const unsigned int n_entries, const VectorizedArray< Number, width > *in, const unsigned int *offsets, Number *out)
void process_dof_gather(const unsigned int *indices, VectorType &vec, const unsigned int constant_offset, VectorizedArrayType &res, std::integral_constant< bool, false >) const
void check_vector_compatibility(const VectorType &vec, const internal::MatrixFreeFunctions::DoFInfo &dof_info)
void process_dof(const unsigned int index, VectorType &vec, Number &res) const
void vector_access_set(VectorType &vec, const unsigned int entry, const typename VectorType::value_type &val)
void process_dof(VectorNumberType &global, Number &local) 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, false >) 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_global(const types::global_dof_index index, 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