Reference documentation for deal.II version GIT 5dcc62ab57 2022-07-04 21:05:02+00:00
\(\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 - 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 
35 namespace 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,
252  ExcMessage(
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  {
355  ::vectorized_load_and_transpose(dofs_per_cell,
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  {
386  ::vectorized_load_and_transpose(dofs_per_cell,
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)
548  vector_access_add(vec,
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  {
659  vector_access_add_global(vec, index, res);
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 & ExcInternalError()
#define Assert(cond, exc)
Definition: exceptions.h:1473
std::string to_string(const T &t)
Definition: patterns.h:2403
static ::ExceptionBase & ExcNotImplemented()
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1667
static ::ExceptionBase & ExcMessage(std::string arg1)
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
T sum(const T &t, const MPI_Comm &mpi_communicator)
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
unsigned int global_dof_index
Definition: types.h:76
std::shared_ptr< const Utilities::MPI::Partitioner > vector_partitioner
Definition: dof_info.h:629
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)