deal.II version GIT relicensing-2289-g1e5549a87a 2024-12-21 21:30:00+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\}}\)
Loading...
Searching...
No Matches
matrix_block.h
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 2009 - 2024 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15#ifndef dealii_matrix_block_h
16#define dealii_matrix_block_h
17
18#include <deal.II/base/config.h>
19
20#include <deal.II/algorithms/any_data.h>
21
22#include <deal.II/base/memory_consumption.h>
23#include <deal.II/base/mg_level_object.h>
24#include <deal.II/base/observer_pointer.h>
25
26#include <deal.II/lac/block_indices.h>
27#include <deal.II/lac/block_sparsity_pattern.h>
28#include <deal.II/lac/full_matrix.h>
29#include <deal.II/lac/sparse_matrix.h>
30
31#include <memory>
32
33
34DEAL_II_NAMESPACE_OPEN
35
36// Forward declarations
37#ifndef DOXYGEN
38template <typename MatrixType>
39class MatrixBlock;
40#endif
41
42namespace internal
43{
44 template <typename MatrixType>
45 void
46 reinit(MatrixBlock<MatrixType> &v, const BlockSparsityPattern &p);
47
48 template <typename number>
49 void
50 reinit(MatrixBlock<::SparseMatrix<number>> &v,
51 const BlockSparsityPattern &p);
52} // namespace internal
53
91template <typename MatrixType>
92class MatrixBlock : public EnableObserverPointer
93{
94public:
98 using size_type = types::global_dof_index;
99
103 using value_type = typename MatrixType::value_type;
104
108 MatrixBlock();
109
113 MatrixBlock(const MatrixBlock<MatrixType> &M) = default;
114
118 MatrixBlock<MatrixType> &
119 operator=(const MatrixBlock<MatrixType> &) = default;
120
125 MatrixBlock(size_type i, size_type j);
126
134 void
135 reinit(const BlockSparsityPattern &sparsity);
136
137 operator MatrixType &();
138 operator const MatrixType &() const;
139
144 void
145 add(const size_type i,
146 const size_type j,
147 const typename MatrixType::value_type value);
148
164 template <typename number>
165 void
166 add(const std::vector<size_type> &indices,
167 const FullMatrix<number> &full_matrix,
168 const bool elide_zero_values = true);
169
184 template <typename number>
185 void
186 add(const std::vector<size_type> &row_indices,
187 const std::vector<size_type> &col_indices,
188 const FullMatrix<number> &full_matrix,
189 const bool elide_zero_values = true);
190
207 template <typename number>
208 void
209 add(const size_type row_index,
210 const std::vector<size_type> &col_indices,
211 const std::vector<number> &values,
212 const bool elide_zero_values = true);
213
223 template <typename number>
224 void
225 add(const size_type row,
226 const size_type n_cols,
227 const size_type *col_indices,
228 const number *values,
229 const bool elide_zero_values = true,
230 const bool col_indices_are_sorted = false);
231
237 template <typename VectorType>
238 void
239 vmult(VectorType &w, const VectorType &v) const;
240
246 template <typename VectorType>
247 void
248 vmult_add(VectorType &w, const VectorType &v) const;
249
255 template <typename VectorType>
256 void
257 Tvmult(VectorType &w, const VectorType &v) const;
258
264 template <typename VectorType>
265 void
266 Tvmult_add(VectorType &w, const VectorType &v) const;
267
271 std::size_t
272 memory_consumption() const;
273
278 DeclException2(ExcBlockIndexMismatch,
279 size_type,
280 size_type,
281 << "Block index " << arg1 << " does not match " << arg2);
282
287 size_type row;
292 size_type column;
293
297 MatrixType matrix;
298
299private:
304 BlockIndices row_indices;
310 BlockIndices column_indices;
311
312 template <class OTHER_MatrixType>
313 friend void
314 ::internal::reinit(MatrixBlock<OTHER_MatrixType> &,
315 const BlockSparsityPattern &);
316
317 template <typename number>
318 friend void
319 internal::reinit(MatrixBlock<::SparseMatrix<number>> &v,
320 const BlockSparsityPattern &p);
321};
322
323
332template <typename MatrixType>
333class MatrixBlockVector : private AnyData
334{
335public:
339 using size_type = types::global_dof_index;
340
344 using value_type = MatrixBlock<MatrixType>;
345
350 using ptr_type = std::shared_ptr<value_type>;
351
356 void
357 add(size_type row, size_type column, const std::string &name);
358
363 void
364 reinit(const BlockSparsityPattern &sparsity);
365
376 void
377 clear(bool really_clean = false);
378
382 std::size_t
383 memory_consumption() const;
384
388 const value_type &
389 block(size_type i) const;
390
394 value_type &
395 block(size_type i);
396
400 MatrixType &
401 matrix(size_type i);
402
406 using AnyData::name;
407 using AnyData::size;
408 using AnyData::subscribe;
409 using AnyData::unsubscribe;
410};
411
412
421template <typename MatrixType>
422class MGMatrixBlockVector : public EnableObserverPointer
423{
424public:
428 using size_type = types::global_dof_index;
429
433 using value_type = MGLevelObject<MatrixBlock<MatrixType>>;
443 MGMatrixBlockVector(const bool edge_matrices = false,
444 const bool edge_flux_matrices = false);
445
449 unsigned int
450 size() const;
451
457 void
458 add(size_type row, size_type column, const std::string &name);
459
466 void
467 reinit_matrix(const MGLevelObject<BlockSparsityPattern> &sparsity);
475 void
476 reinit_edge(const MGLevelObject<BlockSparsityPattern> &sparsity);
483 void
484 reinit_edge_flux(const MGLevelObject<BlockSparsityPattern> &sparsity);
485
496 void
497 clear(bool really_clean = false);
498
502 const value_type &
503 block(size_type i) const;
504
508 value_type &
509 block(size_type i);
510
515 const value_type &
516 block_in(size_type i) const;
517
521 value_type &
522 block_in(size_type i);
523
528 const value_type &
529 block_out(size_type i) const;
530
534 value_type &
535 block_out(size_type i);
536
541 const value_type &
542 block_up(size_type i) const;
543
547 value_type &
548 block_up(size_type i);
549
554 const value_type &
555 block_down(size_type i) const;
556
560 value_type &
561 block_down(size_type i);
562
566 std::size_t
567 memory_consumption() const;
568
569private:
571 void
572 clear_object(AnyData &);
573
575 const bool edge_matrices;
576
578 const bool edge_flux_matrices;
579
581 AnyData matrices;
583 AnyData matrices_in;
585 AnyData matrices_out;
587 AnyData flux_matrices_down;
589 AnyData flux_matrices_up;
590};
591
592
593//----------------------------------------------------------------------//
594
595namespace internal
596{
597 template <typename MatrixType>
598 void
604
605
606 template <typename number>
607 void
608 reinit(MatrixBlock<::SparseMatrix<number>> &v,
609 const BlockSparsityPattern &p)
610 {
611 v.row_indices = p.get_row_indices();
612 v.column_indices = p.get_column_indices();
613 v.matrix.reinit(p.block(v.row, v.column));
614 }
615} // namespace internal
616
617
618template <typename MatrixType>
619inline MatrixBlock<MatrixType>::MatrixBlock()
620 : row(numbers::invalid_size_type)
621 , column(numbers::invalid_size_type)
622{}
623
624
625template <typename MatrixType>
626inline MatrixBlock<MatrixType>::MatrixBlock(size_type i, size_type j)
627 : row(i)
628 , column(j)
629{}
630
631
632template <typename MatrixType>
633inline void
634MatrixBlock<MatrixType>::reinit(const BlockSparsityPattern &sparsity)
635{
636 internal::reinit(*this, sparsity);
637}
638
639
640template <typename MatrixType>
641inline MatrixBlock<MatrixType>::operator MatrixType &()
642{
643 return matrix;
644}
645
646
647template <typename MatrixType>
648inline MatrixBlock<MatrixType>::operator const MatrixType &() const
649{
650 return matrix;
651}
652
653
654template <typename MatrixType>
655inline void
656MatrixBlock<MatrixType>::add(const size_type gi,
657 const size_type gj,
658 const typename MatrixType::value_type value)
659{
660 Assert(row_indices.size() != 0, ExcNotInitialized());
661 Assert(column_indices.size() != 0, ExcNotInitialized());
662
663 const std::pair<unsigned int, size_type> bi = row_indices.global_to_local(gi);
664 const std::pair<unsigned int, size_type> bj =
665 column_indices.global_to_local(gj);
666
667 Assert(bi.first == row, ExcBlockIndexMismatch(bi.first, row));
668 Assert(bj.first == column, ExcBlockIndexMismatch(bj.first, column));
669
670 matrix.add(bi.second, bj.second, value);
671}
672
673
674template <typename MatrixType>
675template <typename number>
676inline void
677MatrixBlock<MatrixType>::add(const std::vector<size_type> &r_indices,
678 const std::vector<size_type> &c_indices,
679 const FullMatrix<number> &values,
680 const bool elide_zero_values)
681{
682 Assert(row_indices.size() != 0, ExcNotInitialized());
683 Assert(column_indices.size() != 0, ExcNotInitialized());
684
685 AssertDimension(r_indices.size(), values.m());
686 AssertDimension(c_indices.size(), values.n());
687
688 for (size_type i = 0; i < row_indices.size(); ++i)
689 add(r_indices[i],
690 c_indices.size(),
691 c_indices.data(),
692 &values(i, 0),
693 elide_zero_values);
694}
695
696
697template <typename MatrixType>
698template <typename number>
699inline void
700MatrixBlock<MatrixType>::add(const size_type b_row,
701 const size_type n_cols,
702 const size_type *col_indices,
703 const number *values,
704 const bool,
705 const bool)
706{
707 Assert(row_indices.size() != 0, ExcNotInitialized());
708 Assert(column_indices.size() != 0, ExcNotInitialized());
709
710 const std::pair<unsigned int, size_type> bi =
711 row_indices.global_to_local(b_row);
712
713 // In debug mode, we check whether
714 // all indices are in the correct
715 // block.
716
717 // Actually, for the time being, we
718 // leave it at this. While it may
719 // not be the most efficient way,
720 // it is at least thread safe.
721 // #ifdef DEBUG
722 Assert(bi.first == row, ExcBlockIndexMismatch(bi.first, row));
723
724 for (size_type j = 0; j < n_cols; ++j)
725 {
726 const std::pair<unsigned int, size_type> bj =
727 column_indices.global_to_local(col_indices[j]);
728 Assert(bj.first == column, ExcBlockIndexMismatch(bj.first, column));
729
730 matrix.add(bi.second, bj.second, values[j]);
731 }
732 // #endif
733}
734
735
736template <typename MatrixType>
737template <typename number>
738inline void
739MatrixBlock<MatrixType>::add(const std::vector<size_type> &indices,
740 const FullMatrix<number> &values,
741 const bool elide_zero_values)
742{
743 Assert(row_indices.size() != 0, ExcNotInitialized());
744 Assert(column_indices.size() != 0, ExcNotInitialized());
745
746 AssertDimension(indices.size(), values.m());
747 Assert(values.n() == values.m(), ExcNotQuadratic());
748
749 for (size_type i = 0; i < indices.size(); ++i)
750 add(indices[i],
751 indices.size(),
752 indices.data(),
753 &values(i, 0),
754 elide_zero_values);
755}
756
757
758
759template <typename MatrixType>
760template <typename number>
761inline void
762MatrixBlock<MatrixType>::add(const size_type row,
763 const std::vector<size_type> &col_indices,
764 const std::vector<number> &values,
765 const bool elide_zero_values)
766{
767 Assert(row_indices.size() != 0, ExcNotInitialized());
768 Assert(column_indices.size() != 0, ExcNotInitialized());
769
770 AssertDimension(col_indices.size(), values.size());
771 add(row,
772 col_indices.size(),
773 col_indices.data(),
774 values.data(),
775 elide_zero_values);
776}
777
778
779template <typename MatrixType>
780template <typename VectorType>
781inline void
782MatrixBlock<MatrixType>::vmult(VectorType &w, const VectorType &v) const
783{
784 matrix.vmult(w, v);
785}
786
787
788template <typename MatrixType>
789template <typename VectorType>
790inline void
791MatrixBlock<MatrixType>::vmult_add(VectorType &w, const VectorType &v) const
792{
793 matrix.vmult_add(w, v);
794}
795
796
797template <typename MatrixType>
798template <typename VectorType>
799inline void
800MatrixBlock<MatrixType>::Tvmult(VectorType &w, const VectorType &v) const
801{
802 matrix.Tvmult(w, v);
803}
804
805
806template <typename MatrixType>
807template <typename VectorType>
808inline void
809MatrixBlock<MatrixType>::Tvmult_add(VectorType &w, const VectorType &v) const
810{
811 matrix.Tvmult_add(w, v);
812}
813
814
815template <typename MatrixType>
816inline std::size_t
817MatrixBlock<MatrixType>::memory_consumption() const
818{
819 return (sizeof(*this) + MemoryConsumption::memory_consumption(matrix) -
820 sizeof(matrix));
821}
822
823//----------------------------------------------------------------------//
824
825template <typename MatrixType>
826inline void
827MatrixBlockVector<MatrixType>::add(size_type row,
828 size_type column,
829 const std::string &name)
830{
831 ptr_type p(new value_type(row, column));
832 AnyData::add(p, name);
833}
834
835
836template <typename MatrixType>
837inline void
838MatrixBlockVector<MatrixType>::reinit(const BlockSparsityPattern &sparsity)
839{
840 for (size_type i = 0; i < this->size(); ++i)
841 {
842 block(i).reinit(sparsity);
843 }
844}
845
846
847template <typename MatrixType>
848inline void
849MatrixBlockVector<MatrixType>::clear(bool really_clean)
850{
851 if (really_clean)
852 {
853 DEAL_II_NOT_IMPLEMENTED();
854 }
855 else
856 {
857 for (size_type i = 0; i < this->size(); ++i)
858 matrix(i).clear();
859 }
860}
861
862
863
864template <typename MatrixType>
865inline const MatrixBlock<MatrixType> &
866MatrixBlockVector<MatrixType>::block(size_type i) const
867{
868 return *this->read<ptr_type>(i);
869}
870
871
872template <typename MatrixType>
873inline MatrixBlock<MatrixType> &
874MatrixBlockVector<MatrixType>::block(size_type i)
875{
876 return *this->entry<ptr_type>(i);
877}
878
879
880template <typename MatrixType>
881inline MatrixType &
882MatrixBlockVector<MatrixType>::matrix(size_type i)
883{
884 return this->entry<ptr_type>(i)->matrix;
885}
886
887
888
889//----------------------------------------------------------------------//
890
891template <typename MatrixType>
892inline MGMatrixBlockVector<MatrixType>::MGMatrixBlockVector(const bool e,
893 const bool f)
894 : edge_matrices(e)
895 , edge_flux_matrices(f)
896{}
897
898
899template <typename MatrixType>
900inline unsigned int
901MGMatrixBlockVector<MatrixType>::size() const
902{
903 return matrices.size();
904}
905
906
907template <typename MatrixType>
908inline void
909MGMatrixBlockVector<MatrixType>::add(size_type row,
910 size_type column,
911 const std::string &name)
912{
913 MGLevelObject<MatrixBlock<MatrixType>> p(0, 1);
914 p[0].row = row;
915 p[0].column = column;
916
917 matrices.add(p, name);
918 if (edge_matrices)
919 {
920 matrices_in.add(p, name);
921 matrices_out.add(p, name);
922 }
923 if (edge_flux_matrices)
924 {
925 flux_matrices_up.add(p, name);
926 flux_matrices_down.add(p, name);
927 }
928}
929
930
931template <typename MatrixType>
932inline const MGLevelObject<MatrixBlock<MatrixType>> &
933MGMatrixBlockVector<MatrixType>::block(size_type i) const
934{
935 return *matrices.read<const MGLevelObject<MatrixType> *>(i);
936}
937
938
939template <typename MatrixType>
940inline MGLevelObject<MatrixBlock<MatrixType>> &
945
946
947template <typename MatrixType>
948inline const MGLevelObject<MatrixBlock<MatrixType>> &
949MGMatrixBlockVector<MatrixType>::block_in(size_type i) const
950{
951 return *matrices_in.read<const MGLevelObject<MatrixType> *>(i);
952}
953
954
955template <typename MatrixType>
956inline MGLevelObject<MatrixBlock<MatrixType>> &
957MGMatrixBlockVector<MatrixType>::block_in(size_type i)
958{
959 return *matrices_in.entry<MGLevelObject<MatrixType> *>(i);
960}
961
962
963template <typename MatrixType>
964inline const MGLevelObject<MatrixBlock<MatrixType>> &
965MGMatrixBlockVector<MatrixType>::block_out(size_type i) const
966{
967 return *matrices_out.read<const MGLevelObject<MatrixType> *>(i);
968}
969
970
971template <typename MatrixType>
972inline MGLevelObject<MatrixBlock<MatrixType>> &
973MGMatrixBlockVector<MatrixType>::block_out(size_type i)
974{
975 return *matrices_out.entry<MGLevelObject<MatrixType> *>(i);
976}
977
978
979template <typename MatrixType>
980inline const MGLevelObject<MatrixBlock<MatrixType>> &
981MGMatrixBlockVector<MatrixType>::block_up(size_type i) const
982{
983 return *flux_matrices_up.read<const MGLevelObject<MatrixType> *>(i);
984}
985
986
987template <typename MatrixType>
988inline MGLevelObject<MatrixBlock<MatrixType>> &
989MGMatrixBlockVector<MatrixType>::block_up(size_type i)
990{
991 return *flux_matrices_up.entry<MGLevelObject<MatrixType> *>(i);
992}
993
994
995template <typename MatrixType>
996inline const MGLevelObject<MatrixBlock<MatrixType>> &
997MGMatrixBlockVector<MatrixType>::block_down(size_type i) const
998{
999 return *flux_matrices_down.read<const MGLevelObject<MatrixType> *>(i);
1000}
1001
1002
1003template <typename MatrixType>
1004inline MGLevelObject<MatrixBlock<MatrixType>> &
1005MGMatrixBlockVector<MatrixType>::block_down(size_type i)
1006{
1007 return *flux_matrices_down.entry<MGLevelObject<MatrixType> *>(i);
1008}
1009
1010
1011template <typename MatrixType>
1012inline void
1013MGMatrixBlockVector<MatrixType>::reinit_matrix(
1014 const MGLevelObject<BlockSparsityPattern> &sparsity)
1015{
1016 for (size_type i = 0; i < this->size(); ++i)
1017 {
1018 MGLevelObject<MatrixBlock<MatrixType>> &o = block(i);
1019 const size_type row = o[o.min_level()].row;
1020 const size_type col = o[o.min_level()].column;
1021
1022 o.resize(sparsity.min_level(), sparsity.max_level());
1023 for (size_type level = o.min_level(); level <= o.max_level(); ++level)
1024 {
1025 o[level].row = row;
1026 o[level].column = col;
1027 internal::reinit(o[level], sparsity[level]);
1028 }
1029 }
1030}
1031
1032
1033template <typename MatrixType>
1034inline void
1035MGMatrixBlockVector<MatrixType>::reinit_edge(
1036 const MGLevelObject<BlockSparsityPattern> &sparsity)
1037{
1038 for (size_type i = 0; i < this->size(); ++i)
1039 {
1040 MGLevelObject<MatrixBlock<MatrixType>> &o = block(i);
1041 const size_type row = o[o.min_level()].row;
1042 const size_type col = o[o.min_level()].column;
1043
1044 block_in(i).resize(sparsity.min_level(), sparsity.max_level());
1045 block_out(i).resize(sparsity.min_level(), sparsity.max_level());
1046 for (size_type level = o.min_level(); level <= o.max_level(); ++level)
1047 {
1048 block_in(i)[level].row = row;
1049 block_in(i)[level].column = col;
1050 internal::reinit(block_in(i)[level], sparsity[level]);
1051 block_out(i)[level].row = row;
1052 block_out(i)[level].column = col;
1053 internal::reinit(block_out(i)[level], sparsity[level]);
1054 }
1055 }
1056}
1057
1058
1059template <typename MatrixType>
1060inline void
1061MGMatrixBlockVector<MatrixType>::reinit_edge_flux(
1062 const MGLevelObject<BlockSparsityPattern> &sparsity)
1063{
1064 for (size_type i = 0; i < this->size(); ++i)
1065 {
1066 MGLevelObject<MatrixBlock<MatrixType>> &o = block(i);
1067 const size_type row = o[o.min_level()].row;
1068 const size_type col = o[o.min_level()].column;
1069
1070 block_up(i).resize(sparsity.min_level(), sparsity.max_level());
1071 block_down(i).resize(sparsity.min_level(), sparsity.max_level());
1072 for (size_type level = o.min_level(); level <= o.max_level(); ++level)
1073 {
1074 block_up(i)[level].row = row;
1075 block_up(i)[level].column = col;
1076 internal::reinit(block_up(i)[level], sparsity[level]);
1077 block_down(i)[level].row = row;
1078 block_down(i)[level].column = col;
1079 internal::reinit(block_down(i)[level], sparsity[level]);
1080 }
1081 }
1082}
1083
1084
1085template <typename MatrixType>
1086inline void
1087MGMatrixBlockVector<MatrixType>::clear_object(AnyData &mo)
1088{
1089 for (size_type i = 0; i < mo.size(); ++i)
1090 {
1091 MGLevelObject<MatrixBlock<MatrixType>> &o =
1092 mo.entry<MGLevelObject<MatrixType> *>(i);
1093 for (size_type level = o.min_level(); level <= o.max_level(); ++level)
1094 o[level].matrix.clear();
1095 }
1096}
1097
1098
1099template <typename MatrixType>
1100inline void
1101MGMatrixBlockVector<MatrixType>::clear(bool really_clean)
1102{
1103 if (really_clean)
1104 {
1105 DEAL_II_NOT_IMPLEMENTED();
1106 }
1107 else
1108 {
1109 clear_object(matrices);
1110 clear_object(matrices_in);
1111 clear_object(matrices_out);
1112 clear_object(flux_matrices_up);
1113 clear_object(flux_matrices_down);
1114 }
1115}
1116
1117
1118
1119DEAL_II_NAMESPACE_CLOSE
1120
1121#endif
any_data.h
block_indices.h
block_sparsity_pattern.h
AnyData::name
const std::string & name(const unsigned int i) const
Name of object at index.
Definition any_data.h:309
AnyData::entry
type entry(const std::string &name)
Access to stored data object by name.
Definition any_data.h:349
AnyData::add
void add(type entry, const std::string &name)
Add a new data object.
Definition any_data.h:430
AnyData::size
unsigned int size() const
Number of stored data objects.
Definition any_data.h:221
BlockIndices::reinit
void reinit(const unsigned int n_blocks, const size_type n_elements_per_block)
Definition block_indices.h:257
BlockSparsityPatternBase::block
SparsityPatternType & block(const size_type row, const size_type column)
Definition block_sparsity_pattern.h:780
BlockSparsityPatternBase::get_column_indices
const BlockIndices & get_column_indices() const
Definition block_sparsity_pattern.h:814
BlockSparsityPatternBase::get_row_indices
const BlockIndices & get_row_indices() const
Definition block_sparsity_pattern.h:805
EnableObserverPointer::subscribe
void subscribe(std::atomic< bool > *const validity, const std::string &identifier="") const
Definition enable_observer_pointer.cc:131
EnableObserverPointer::unsubscribe
void unsubscribe(std::atomic< bool > *const validity, const std::string &identifier="") const
Definition enable_observer_pointer.cc:151
MGLevelObject::resize
void resize(const unsigned int new_minlevel, const unsigned int new_maxlevel, Args &&...args)
Definition mg_level_object.h:256
MGLevelObject::max_level
unsigned int max_level() const
Definition mg_level_object.h:313
MGLevelObject::min_level
unsigned int min_level() const
Definition mg_level_object.h:305
MGMatrixBlockVector::flux_matrices_up
AnyData flux_matrices_up
The DG flux from the lower level to a level.
Definition matrix_block.h:589
MGMatrixBlockVector::block_down
const value_type & block_down(size_type i) const
Definition matrix_block.h:997
MGMatrixBlockVector::clear_object
void clear_object(AnyData &)
Clear one of the matrix objects.
Definition matrix_block.h:1087
MGMatrixBlockVector::block
const value_type & block(size_type i) const
Definition matrix_block.h:933
MGMatrixBlockVector::clear
void clear(bool really_clean=false)
Definition matrix_block.h:1101
MGMatrixBlockVector::reinit_edge_flux
void reinit_edge_flux(const MGLevelObject< BlockSparsityPattern > &sparsity)
Definition matrix_block.h:1061
MGMatrixBlockVector::edge_flux_matrices
const bool edge_flux_matrices
Flag for storing flux_matrices_up and flux_matrices_down.
Definition matrix_block.h:578
MGMatrixBlockVector::matrices_out
AnyData matrices_out
The matrix from the refinement edge to the interior of a level.
Definition matrix_block.h:585
MGMatrixBlockVector::reinit_matrix
void reinit_matrix(const MGLevelObject< BlockSparsityPattern > &sparsity)
Definition matrix_block.h:1013
MGMatrixBlockVector::block_in
const value_type & block_in(size_type i) const
Definition matrix_block.h:949
MGMatrixBlockVector::MGMatrixBlockVector
MGMatrixBlockVector(const bool edge_matrices=false, const bool edge_flux_matrices=false)
Definition matrix_block.h:892
MGMatrixBlockVector::block_out
const value_type & block_out(size_type i) const
Definition matrix_block.h:965
MGMatrixBlockVector::memory_consumption
std::size_t memory_consumption() const
MGMatrixBlockVector::flux_matrices_down
AnyData flux_matrices_down
The DG flux from a level to the lower level.
Definition matrix_block.h:587
MGMatrixBlockVector::matrices
AnyData matrices
The level matrices.
Definition matrix_block.h:581
MGMatrixBlockVector::reinit_edge
void reinit_edge(const MGLevelObject< BlockSparsityPattern > &sparsity)
Definition matrix_block.h:1035
MGMatrixBlockVector::matrices_in
AnyData matrices_in
The matrix from the interior of a level to the refinement edge.
Definition matrix_block.h:583
MGMatrixBlockVector::edge_matrices
const bool edge_matrices
Flag for storing matrices_in and matrices_out.
Definition matrix_block.h:575
MGMatrixBlockVector::add
void add(size_type row, size_type column, const std::string &name)
Definition matrix_block.h:909
MGMatrixBlockVector::size
unsigned int size() const
Definition matrix_block.h:901
MGMatrixBlockVector::block_up
const value_type & block_up(size_type i) const
Definition matrix_block.h:981
MatrixBlockVector::name
const std::string & name(const unsigned int i) const
Definition any_data.h:309
MatrixBlockVector::ptr_type
std::shared_ptr< value_type > ptr_type
Definition matrix_block.h:350
MatrixBlockVector::add
void add(size_type row, size_type column, const std::string &name)
Definition matrix_block.h:827
MatrixBlockVector::block
const value_type & block(size_type i) const
Definition matrix_block.h:866
MatrixBlockVector::clear
void clear(bool really_clean=false)
Definition matrix_block.h:849
MatrixBlockVector::memory_consumption
std::size_t memory_consumption() const
MatrixBlockVector::reinit
void reinit(const BlockSparsityPattern &sparsity)
Definition matrix_block.h:838
MatrixBlockVector::matrix
MatrixType & matrix(size_type i)
Definition matrix_block.h:882
MatrixBlock::operator=
MatrixBlock< MatrixType > & operator=(const MatrixBlock< MatrixType > &)=default
MatrixBlock::vmult_add
void vmult_add(VectorType &w, const VectorType &v) const
Definition matrix_block.h:791
MatrixBlock::reinit
void reinit(const BlockSparsityPattern &sparsity)
Definition matrix_block.h:634
MatrixBlock::column_indices
BlockIndices column_indices
Definition matrix_block.h:310
MatrixBlock::MatrixBlock
MatrixBlock(size_type i, size_type j)
Definition matrix_block.h:626
MatrixBlock::add
void add(const size_type i, const size_type j, const typename MatrixType::value_type value)
Definition matrix_block.h:656
MatrixBlock::memory_consumption
std::size_t memory_consumption() const
Definition matrix_block.h:817
MatrixBlock::matrix
MatrixType matrix
Definition matrix_block.h:297
MatrixBlock::add
void add(const std::vector< size_type > &row_indices, const std::vector< size_type > &col_indices, const FullMatrix< number > &full_matrix, const bool elide_zero_values=true)
Definition matrix_block.h:677
MatrixBlock::Tvmult_add
void Tvmult_add(VectorType &w, const VectorType &v) const
Definition matrix_block.h:809
MatrixBlock::add
void add(const std::vector< size_type > &indices, const FullMatrix< number > &full_matrix, const bool elide_zero_values=true)
Definition matrix_block.h:739
MatrixBlock::add
void add(const size_type row_index, const std::vector< size_type > &col_indices, const std::vector< number > &values, const bool elide_zero_values=true)
Definition matrix_block.h:762
MatrixBlock::vmult
void vmult(VectorType &w, const VectorType &v) const
Definition matrix_block.h:782
MatrixBlock::Tvmult
void Tvmult(VectorType &w, const VectorType &v) const
Definition matrix_block.h:800
MatrixBlock::row_indices
BlockIndices row_indices
Definition matrix_block.h:304
MatrixBlock::value_type
typename MatrixType::value_type value_type
Definition matrix_block.h:103
MatrixBlock::row
size_type row
Definition matrix_block.h:287
MatrixBlock::MatrixBlock
MatrixBlock(const MatrixBlock< MatrixType > &M)=default
MatrixBlock::column
size_type column
Definition matrix_block.h:292
MatrixBlock::add
void add(const size_type row, const size_type n_cols, const size_type *col_indices, const number *values, const bool elide_zero_values=true, const bool col_indices_are_sorted=false)
Definition matrix_block.h:700
MatrixBlock::reinit
friend void internal::reinit(MatrixBlock<::SparseMatrix< number > > &v, const BlockSparsityPattern &p)
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:498
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:499
full_matrix.h
level
unsigned int level
Definition grid_out.cc:4632
MatrixBlock::ExcBlockIndexMismatch
static ::ExceptionBase & ExcBlockIndexMismatch(size_type arg1, size_type arg2)
Assert
#define Assert(cond, exc)
Definition exceptions.h:1659
DeclException2
#define DeclException2(Exception2, type1, type2, outsequence)
Definition exceptions.h:534
AssertDimension
#define AssertDimension(dim1, dim2)
Definition exceptions.h:2026
StandardExceptions::ExcNotInitialized
static ::ExceptionBase & ExcNotInitialized()
LACExceptions::ExcNotQuadratic
static ::ExceptionBase & ExcNotQuadratic()
DEAL_II_NOT_IMPLEMENTED
#define DEAL_II_NOT_IMPLEMENTED()
Definition exceptions.h:1855
memory_consumption.h
mg_level_object.h
size
std::size_t size
Definition mpi.cc:734
MemoryConsumption::memory_consumption
std::enable_if_t< std::is_fundamental_v< T >, std::size_t > memory_consumption(const T &t)
Definition memory_consumption.h:271
internal::reinit
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
Definition matrix_block.h:599
types::global_dof_index
unsigned int global_dof_index
Definition types.h:81
observer_pointer.h
sparse_matrix.h
Generated by doxygen 1.9.8