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\}}\)
matrix_tools.h
Go to the documentation of this file.
1// ---------------------------------------------------------------------
2//
3// Copyright (C) 1998 - 2020 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#ifndef dealii_matrix_tools_h
17#define dealii_matrix_tools_h
18
19
20#include <deal.II/base/config.h>
21
22#include <deal.II/base/exceptions.h>
23#include <deal.II/base/function.h>
24
25#include <deal.II/lac/affine_constraints.h>
26
27#include <map>
28
29#ifdef DEAL_II_WITH_PETSC
30# include <petscsys.h>
31#endif
32
33DEAL_II_NAMESPACE_OPEN
34
35
36// forward declarations
37#ifndef DOXYGEN
38template <int dim>
39class Quadrature;
40
41
42template <typename number>
43class Vector;
44template <typename number>
45class FullMatrix;
46template <typename number>
47class SparseMatrix;
48
49template <typename number>
50class BlockSparseMatrix;
51template <typename Number>
52class BlockVector;
53
54template <int dim, int spacedim>
55class Mapping;
56template <int dim, int spacedim>
57class DoFHandler;
58
59namespace hp
60{
61 template <int>
62 class QCollection;
63 template <int, int>
64 class MappingCollection;
65 template <int, int>
66 class DoFHandler;
67} // namespace hp
68
69
70# ifdef DEAL_II_WITH_PETSC
71namespace PETScWrappers
72{
73 class MatrixBase;
74 class VectorBase;
75 namespace MPI
76 {
77 class BlockSparseMatrix;
78 class BlockVector;
79 } // namespace MPI
80} // namespace PETScWrappers
81# endif
82
83# ifdef DEAL_II_WITH_TRILINOS
84namespace TrilinosWrappers
85{
86 class SparseMatrix;
87 class BlockSparseMatrix;
88 namespace MPI
89 {
90 class Vector;
91 class BlockVector;
92 } // namespace MPI
93} // namespace TrilinosWrappers
94# endif
95#endif
96
97
230namespace MatrixCreator
231{
251 template <int dim, int spacedim, typename number>
252 void
253 create_mass_matrix(
254 const Mapping<dim, spacedim> & mapping,
255 const DoFHandler<dim, spacedim> & dof,
256 const Quadrature<dim> & q,
257 SparseMatrix<number> & matrix,
258 const Function<spacedim, number> *const a = nullptr,
259 const AffineConstraints<number> &constraints = AffineConstraints<number>());
260
265 template <int dim, int spacedim, typename number>
266 void
267 create_mass_matrix(
268 const DoFHandler<dim, spacedim> & dof,
269 const Quadrature<dim> & q,
270 SparseMatrix<number> & matrix,
271 const Function<spacedim, number> *const a = nullptr,
272 const AffineConstraints<number> &constraints = AffineConstraints<number>());
273
293 template <int dim, int spacedim, typename number>
294 void
295 create_mass_matrix(
296 const Mapping<dim, spacedim> & mapping,
297 const DoFHandler<dim, spacedim> & dof,
298 const Quadrature<dim> & q,
299 SparseMatrix<number> & matrix,
300 const Function<spacedim, number> & rhs,
301 Vector<number> & rhs_vector,
302 const Function<spacedim, number> *const a = nullptr,
303 const AffineConstraints<number> &constraints = AffineConstraints<number>());
304
309 template <int dim, int spacedim, typename number>
310 void
311 create_mass_matrix(
312 const DoFHandler<dim, spacedim> & dof,
313 const Quadrature<dim> & q,
314 SparseMatrix<number> & matrix,
315 const Function<spacedim, number> & rhs,
316 Vector<number> & rhs_vector,
317 const Function<spacedim, number> *const a = nullptr,
318 const AffineConstraints<number> &constraints = AffineConstraints<number>());
319
323 template <int dim, int spacedim, typename number>
324 void
325 create_mass_matrix(
326 const hp::MappingCollection<dim, spacedim> &mapping,
327 const DoFHandler<dim, spacedim> & dof,
328 const hp::QCollection<dim> & q,
329 SparseMatrix<number> & matrix,
330 const Function<spacedim, number> *const a = nullptr,
331 const AffineConstraints<number> &constraints = AffineConstraints<number>());
332
336 template <int dim, int spacedim, typename number>
337 void
338 create_mass_matrix(
339 const DoFHandler<dim, spacedim> & dof,
340 const hp::QCollection<dim> & q,
341 SparseMatrix<number> & matrix,
342 const Function<spacedim, number> *const a = nullptr,
343 const AffineConstraints<number> &constraints = AffineConstraints<number>());
344
348 template <int dim, int spacedim, typename number>
349 void
350 create_mass_matrix(
351 const hp::MappingCollection<dim, spacedim> &mapping,
352 const DoFHandler<dim, spacedim> & dof,
353 const hp::QCollection<dim> & q,
354 SparseMatrix<number> & matrix,
355 const Function<spacedim, number> & rhs,
356 Vector<number> & rhs_vector,
357 const Function<spacedim, number> *const a = nullptr,
358 const AffineConstraints<number> &constraints = AffineConstraints<number>());
359
363 template <int dim, int spacedim, typename number>
364 void
365 create_mass_matrix(
366 const DoFHandler<dim, spacedim> & dof,
367 const hp::QCollection<dim> & q,
368 SparseMatrix<number> & matrix,
369 const Function<spacedim, number> & rhs,
370 Vector<number> & rhs_vector,
371 const Function<spacedim, number> *const a = nullptr,
372 const AffineConstraints<number> &constraints = AffineConstraints<number>());
373
374
400 template <int dim, int spacedim, typename number>
401 void
402 create_boundary_mass_matrix(
403 const Mapping<dim, spacedim> & mapping,
404 const DoFHandler<dim, spacedim> &dof,
405 const Quadrature<dim - 1> & q,
406 SparseMatrix<number> & matrix,
407 const std::map<types::boundary_id, const Function<spacedim, number> *>
408 & boundary_functions,
409 Vector<number> & rhs_vector,
410 std::vector<types::global_dof_index> & dof_to_boundary_mapping,
411 const Function<spacedim, number> *const weight = 0,
412 std::vector<unsigned int> component_mapping = {});
413
414
419 template <int dim, int spacedim, typename number>
420 void
421 create_boundary_mass_matrix(
422 const DoFHandler<dim, spacedim> &dof,
423 const Quadrature<dim - 1> & q,
424 SparseMatrix<number> & matrix,
425 const std::map<types::boundary_id, const Function<spacedim, number> *>
426 & boundary_functions,
427 Vector<number> & rhs_vector,
428 std::vector<types::global_dof_index> & dof_to_boundary_mapping,
429 const Function<spacedim, number> *const a = nullptr,
430 std::vector<unsigned int> component_mapping = {});
431
435 template <int dim, int spacedim, typename number>
436 void
437 create_boundary_mass_matrix(
438 const hp::MappingCollection<dim, spacedim> &mapping,
439 const DoFHandler<dim, spacedim> & dof,
440 const hp::QCollection<dim - 1> & q,
441 SparseMatrix<number> & matrix,
442 const std::map<types::boundary_id, const Function<spacedim, number> *>
443 & boundary_functions,
444 Vector<number> & rhs_vector,
445 std::vector<types::global_dof_index> & dof_to_boundary_mapping,
446 const Function<spacedim, number> *const a = nullptr,
447 std::vector<unsigned int> component_mapping = {});
448
452 template <int dim, int spacedim, typename number>
453 void
454 create_boundary_mass_matrix(
455 const DoFHandler<dim, spacedim> &dof,
456 const hp::QCollection<dim - 1> & q,
457 SparseMatrix<number> & matrix,
458 const std::map<types::boundary_id, const Function<spacedim, number> *>
459 & boundary_functions,
460 Vector<number> & rhs_vector,
461 std::vector<types::global_dof_index> & dof_to_boundary_mapping,
462 const Function<spacedim, number> *const a = nullptr,
463 std::vector<unsigned int> component_mapping = {});
464
484 template <int dim, int spacedim>
485 void
486 create_laplace_matrix(
487 const Mapping<dim, spacedim> & mapping,
488 const DoFHandler<dim, spacedim> &dof,
489 const Quadrature<dim> & q,
490 SparseMatrix<double> & matrix,
491 const Function<spacedim> *const a = nullptr,
492 const AffineConstraints<double> &constraints = AffineConstraints<double>());
493
498 template <int dim, int spacedim>
499 void
500 create_laplace_matrix(
501 const DoFHandler<dim, spacedim> &dof,
502 const Quadrature<dim> & q,
503 SparseMatrix<double> & matrix,
504 const Function<spacedim> *const a = nullptr,
505 const AffineConstraints<double> &constraints = AffineConstraints<double>());
506
525 template <int dim, int spacedim>
526 void
527 create_laplace_matrix(
528 const Mapping<dim, spacedim> & mapping,
529 const DoFHandler<dim, spacedim> &dof,
530 const Quadrature<dim> & q,
531 SparseMatrix<double> & matrix,
532 const Function<spacedim> & rhs,
533 Vector<double> & rhs_vector,
534 const Function<spacedim> *const a = nullptr,
535 const AffineConstraints<double> &constraints = AffineConstraints<double>());
536
541 template <int dim, int spacedim>
542 void
543 create_laplace_matrix(
544 const DoFHandler<dim, spacedim> &dof,
545 const Quadrature<dim> & q,
546 SparseMatrix<double> & matrix,
547 const Function<spacedim> & rhs,
548 Vector<double> & rhs_vector,
549 const Function<spacedim> *const a = nullptr,
550 const AffineConstraints<double> &constraints = AffineConstraints<double>());
551
555 template <int dim, int spacedim>
556 void
557 create_laplace_matrix(
558 const hp::MappingCollection<dim, spacedim> &mapping,
559 const DoFHandler<dim, spacedim> & dof,
560 const hp::QCollection<dim> & q,
561 SparseMatrix<double> & matrix,
562 const Function<spacedim> *const a = nullptr,
563 const AffineConstraints<double> &constraints = AffineConstraints<double>());
564
568 template <int dim, int spacedim>
569 void
570 create_laplace_matrix(
571 const DoFHandler<dim, spacedim> &dof,
572 const hp::QCollection<dim> & q,
573 SparseMatrix<double> & matrix,
574 const Function<spacedim> *const a = nullptr,
575 const AffineConstraints<double> &constraints = AffineConstraints<double>());
576
580 template <int dim, int spacedim>
581 void
582 create_laplace_matrix(
583 const hp::MappingCollection<dim, spacedim> &mapping,
584 const DoFHandler<dim, spacedim> & dof,
585 const hp::QCollection<dim> & q,
586 SparseMatrix<double> & matrix,
587 const Function<spacedim> & rhs,
588 Vector<double> & rhs_vector,
589 const Function<spacedim> *const a = nullptr,
590 const AffineConstraints<double> &constraints = AffineConstraints<double>());
591
595 template <int dim, int spacedim>
596 void
597 create_laplace_matrix(
598 const DoFHandler<dim, spacedim> &dof,
599 const hp::QCollection<dim> & q,
600 SparseMatrix<double> & matrix,
601 const Function<spacedim> & rhs,
602 Vector<double> & rhs_vector,
603 const Function<spacedim> *const a = nullptr,
604 const AffineConstraints<double> &constraints = AffineConstraints<double>());
605
609 DeclExceptionMsg(ExcComponentMismatch,
610 "You are providing either a right hand side function or a "
611 "coefficient with a number of vector components that is "
612 "inconsistent with the rest of the arguments. If you do "
613 "provide a coefficient or right hand side function, then "
614 "it either needs to have as many components as the finite "
615 "element in use, or only a single vector component. In "
616 "the latter case, the same value will be taken for "
617 "each vector component of the finite element.");
618} // namespace MatrixCreator
619
620
621
829namespace MatrixTools
830{
836 using namespace MatrixCreator;
837
842 template <typename number>
843 void
844 apply_boundary_values(
845 const std::map<types::global_dof_index, number> &boundary_values,
846 SparseMatrix<number> & matrix,
847 Vector<number> & solution,
848 Vector<number> & right_hand_side,
849 const bool eliminate_columns = true);
850
856 template <typename number>
857 void
858 apply_boundary_values(
859 const std::map<types::global_dof_index, number> &boundary_values,
860 BlockSparseMatrix<number> & matrix,
861 BlockVector<number> & solution,
862 BlockVector<number> & right_hand_side,
863 const bool eliminate_columns = true);
864
865#ifdef DEAL_II_WITH_PETSC
901 void
902 apply_boundary_values(
903 const std::map<types::global_dof_index, PetscScalar> &boundary_values,
904 PETScWrappers::MatrixBase & matrix,
905 PETScWrappers::VectorBase & solution,
906 PETScWrappers::VectorBase & right_hand_side,
907 const bool eliminate_columns = true);
908
912 void
913 apply_boundary_values(
914 const std::map<types::global_dof_index, PetscScalar> &boundary_values,
915 PETScWrappers::MPI::BlockSparseMatrix & matrix,
916 PETScWrappers::MPI::BlockVector & solution,
917 PETScWrappers::MPI::BlockVector & right_hand_side,
918 const bool eliminate_columns = true);
919
920#endif
921
922#ifdef DEAL_II_WITH_TRILINOS
956 void
957 apply_boundary_values(
958 const std::map<types::global_dof_index, TrilinosScalar> &boundary_values,
959 TrilinosWrappers::SparseMatrix & matrix,
960 TrilinosWrappers::MPI::Vector & solution,
961 TrilinosWrappers::MPI::Vector & right_hand_side,
962 const bool eliminate_columns = true);
963
968 void
969 apply_boundary_values(
970 const std::map<types::global_dof_index, TrilinosScalar> &boundary_values,
971 TrilinosWrappers::BlockSparseMatrix & matrix,
972 TrilinosWrappers::MPI::BlockVector & solution,
973 TrilinosWrappers::MPI::BlockVector & right_hand_side,
974 const bool eliminate_columns = true);
975#endif
976
995 template <typename number>
996 void
997 local_apply_boundary_values(
998 const std::map<types::global_dof_index, number> &boundary_values,
999 const std::vector<types::global_dof_index> & local_dof_indices,
1000 FullMatrix<number> & local_matrix,
1001 Vector<number> & local_rhs,
1002 const bool eliminate_columns);
1003
1007 DeclExceptionMsg(ExcBlocksDontMatch,
1008 "You are providing a matrix whose subdivision into "
1009 "blocks in either row or column direction does not use "
1010 "the same blocks sizes as the solution vector or "
1011 "right hand side vectors, respectively.");
1012} // namespace MatrixTools
1013
1014
1015
1016DEAL_II_NAMESPACE_CLOSE
1017
1018#endif
affine_constraints.h
Mapping
Abstract base class for mapping classes.
Definition: mapping.h:304
Vector
Definition: vector.h:110
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
MatrixTools::ExcBlocksDontMatch
static ::ExceptionBase & ExcBlocksDontMatch()
DeclExceptionMsg
#define DeclExceptionMsg(Exception, defaulttext)
Definition: exceptions.h:493
MatrixCreator::ExcComponentMismatch
static ::ExceptionBase & ExcComponentMismatch()
LAPACKSupport::matrix
@ matrix
Contents is actually a matrix.
Definition: lapack_support.h:58
MatrixCreator::create_boundary_mass_matrix
void create_boundary_mass_matrix(const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim - 1 > &q, SparseMatrix< number > &matrix, const std::map< types::boundary_id, const Function< spacedim, number > * > &boundary_functions, Vector< number > &rhs_vector, std::vector< types::global_dof_index > &dof_to_boundary_mapping, const Function< spacedim, number > *const weight=0, std::vector< unsigned int > component_mapping={})
MatrixCreator::create_laplace_matrix
void create_laplace_matrix(const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > *const a=nullptr, const AffineConstraints< double > &constraints=AffineConstraints< double >())
MatrixCreator::create_mass_matrix
void create_mass_matrix(const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim, number > *const a=nullptr, const AffineConstraints< number > &constraints=AffineConstraints< number >())
MatrixTools::apply_boundary_values
void apply_boundary_values(const std::map< types::global_dof_index, number > &boundary_values, SparseMatrix< number > &matrix, Vector< number > &solution, Vector< number > &right_hand_side, const bool eliminate_columns=true)
Definition: matrix_tools.cc:81
MatrixTools::local_apply_boundary_values
void local_apply_boundary_values(const std::map< types::global_dof_index, number > &boundary_values, const std::vector< types::global_dof_index > &local_dof_indices, FullMatrix< number > &local_matrix, Vector< number > &local_rhs, const bool eliminate_columns)
Definition: matrix_tools.cc:505
hp
Definition: hp.h:118
Generated by doxygen 1.9.4