deal.II version GIT relicensing-2169-gec1b43f35b 2024-11-22 07:10: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_creator.h
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 1998 - 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_creator_h
16#define dealii_matrix_creator_h
17
18
19#include <deal.II/base/config.h>
20
21#include <deal.II/base/exceptions.h>
22#include <deal.II/base/function.h>
23
24#include <deal.II/lac/affine_constraints.h>
25
26#include <map>
27
28#ifdef DEAL_II_WITH_PETSC
29# include <petscsys.h>
30#endif
31
32DEAL_II_NAMESPACE_OPEN
33
34
35// forward declarations
36#ifndef DOXYGEN
37template <int dim>
38class Quadrature;
39
40
41template <typename number>
42class Vector;
43template <typename number>
44class SparseMatrix;
45
46template <int dim, int spacedim>
47class Mapping;
48template <int dim, int spacedim>
49DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
50class DoFHandler;
51
52namespace hp
53{
54 template <int>
55 class QCollection;
56 template <int, int>
57 class MappingCollection;
58} // namespace hp
59
60#endif
61
62
195namespace MatrixCreator
196{
216 template <int dim, int spacedim, typename MatrixType>
217 void
218 create_mass_matrix(
219 const Mapping<dim, spacedim> &mapping,
220 const DoFHandler<dim, spacedim> &dof,
221 const Quadrature<dim> &q,
222 MatrixType &matrix,
223 const Function<spacedim, typename MatrixType::value_type> *const a =
224 nullptr,
225 const AffineConstraints<typename MatrixType::value_type> &constraints =
226 AffineConstraints<typename MatrixType::value_type>());
227
232 template <int dim, int spacedim, typename MatrixType>
233 void
234 create_mass_matrix(
235 const DoFHandler<dim, spacedim> &dof,
236 const Quadrature<dim> &q,
237 MatrixType &matrix,
238 const Function<spacedim, typename MatrixType::value_type> *const a =
239 nullptr,
240 const AffineConstraints<typename MatrixType::value_type> &constraints =
241 AffineConstraints<typename MatrixType::value_type>());
242
262 template <int dim, int spacedim, typename MatrixType>
263 void
264 create_mass_matrix(
265 const Mapping<dim, spacedim> &mapping,
266 const DoFHandler<dim, spacedim> &dof,
267 const Quadrature<dim> &q,
268 MatrixType &matrix,
269 const Function<spacedim, typename MatrixType::value_type> &rhs,
270 Vector<typename MatrixType::value_type> &rhs_vector,
271 const Function<spacedim, typename MatrixType::value_type> *const a =
272 nullptr,
273 const AffineConstraints<typename MatrixType::value_type> &constraints =
274 AffineConstraints<typename MatrixType::value_type>());
275
280 template <int dim, int spacedim, typename MatrixType>
281 void
282 create_mass_matrix(
283 const DoFHandler<dim, spacedim> &dof,
284 const Quadrature<dim> &q,
285 MatrixType &matrix,
286 const Function<spacedim, typename MatrixType::value_type> &rhs,
287 Vector<typename MatrixType::value_type> &rhs_vector,
288 const Function<spacedim, typename MatrixType::value_type> *const a =
289 nullptr,
290 const AffineConstraints<typename MatrixType::value_type> &constraints =
291 AffineConstraints<typename MatrixType::value_type>());
292
296 template <int dim, int spacedim, typename MatrixType>
297 void
298 create_mass_matrix(
299 const hp::MappingCollection<dim, spacedim> &mapping,
300 const DoFHandler<dim, spacedim> &dof,
301 const hp::QCollection<dim> &q,
302 MatrixType &matrix,
303 const Function<spacedim, typename MatrixType::value_type> *const a =
304 nullptr,
305 const AffineConstraints<typename MatrixType::value_type> &constraints =
306 AffineConstraints<typename MatrixType::value_type>());
307
311 template <int dim, int spacedim, typename MatrixType>
312 void
313 create_mass_matrix(
314 const DoFHandler<dim, spacedim> &dof,
315 const hp::QCollection<dim> &q,
316 MatrixType &matrix,
317 const Function<spacedim, typename MatrixType::value_type> *const a =
318 nullptr,
319 const AffineConstraints<typename MatrixType::value_type> &constraints =
320 AffineConstraints<typename MatrixType::value_type>());
321
325 template <int dim, int spacedim, typename MatrixType>
326 void
327 create_mass_matrix(
328 const hp::MappingCollection<dim, spacedim> &mapping,
329 const DoFHandler<dim, spacedim> &dof,
330 const hp::QCollection<dim> &q,
331 MatrixType &matrix,
332 const Function<spacedim, typename MatrixType::value_type> &rhs,
333 Vector<typename MatrixType::value_type> &rhs_vector,
334 const Function<spacedim, typename MatrixType::value_type> *const a =
335 nullptr,
336 const AffineConstraints<typename MatrixType::value_type> &constraints =
337 AffineConstraints<typename MatrixType::value_type>());
338
342 template <int dim, int spacedim, typename MatrixType>
343 void
344 create_mass_matrix(
345 const DoFHandler<dim, spacedim> &dof,
346 const hp::QCollection<dim> &q,
347 MatrixType &matrix,
348 const Function<spacedim, typename MatrixType::value_type> &rhs,
349 Vector<typename MatrixType::value_type> &rhs_vector,
350 const Function<spacedim, typename MatrixType::value_type> *const a =
351 nullptr,
352 const AffineConstraints<typename MatrixType::value_type> &constraints =
353 AffineConstraints<typename MatrixType::value_type>());
354
355
381 template <int dim, int spacedim, typename number>
382 void
383 create_boundary_mass_matrix(
384 const Mapping<dim, spacedim> &mapping,
385 const DoFHandler<dim, spacedim> &dof,
386 const Quadrature<dim - 1> &q,
387 SparseMatrix<number> &matrix,
388 const std::map<types::boundary_id, const Function<spacedim, number> *>
389 &boundary_functions,
390 Vector<number> &rhs_vector,
391 std::vector<types::global_dof_index> &dof_to_boundary_mapping,
392 const Function<spacedim, number> *const weight = 0,
393 std::vector<unsigned int> component_mapping = {});
394
395
400 template <int dim, int spacedim, typename number>
401 void
402 create_boundary_mass_matrix(
403 const DoFHandler<dim, spacedim> &dof,
404 const Quadrature<dim - 1> &q,
405 SparseMatrix<number> &matrix,
406 const std::map<types::boundary_id, const Function<spacedim, number> *>
407 &boundary_functions,
408 Vector<number> &rhs_vector,
409 std::vector<types::global_dof_index> &dof_to_boundary_mapping,
410 const Function<spacedim, number> *const a = nullptr,
411 std::vector<unsigned int> component_mapping = {});
412
416 template <int dim, int spacedim, typename number>
417 void
418 create_boundary_mass_matrix(
419 const hp::MappingCollection<dim, spacedim> &mapping,
420 const DoFHandler<dim, spacedim> &dof,
421 const hp::QCollection<dim - 1> &q,
422 SparseMatrix<number> &matrix,
423 const std::map<types::boundary_id, const Function<spacedim, number> *>
424 &boundary_functions,
425 Vector<number> &rhs_vector,
426 std::vector<types::global_dof_index> &dof_to_boundary_mapping,
427 const Function<spacedim, number> *const a = nullptr,
428 std::vector<unsigned int> component_mapping = {});
429
433 template <int dim, int spacedim, typename number>
434 void
435 create_boundary_mass_matrix(
436 const DoFHandler<dim, spacedim> &dof,
437 const hp::QCollection<dim - 1> &q,
438 SparseMatrix<number> &matrix,
439 const std::map<types::boundary_id, const Function<spacedim, number> *>
440 &boundary_functions,
441 Vector<number> &rhs_vector,
442 std::vector<types::global_dof_index> &dof_to_boundary_mapping,
443 const Function<spacedim, number> *const a = nullptr,
444 std::vector<unsigned int> component_mapping = {});
445
465 template <int dim, int spacedim, typename MatrixType>
466 void
467 create_laplace_matrix(
468 const Mapping<dim, spacedim> &mapping,
469 const DoFHandler<dim, spacedim> &dof,
470 const Quadrature<dim> &q,
471 MatrixType &matrix,
472 const Function<spacedim, typename MatrixType::value_type> *const a =
473 nullptr,
474 const AffineConstraints<typename MatrixType::value_type> &constraints =
475 AffineConstraints<typename MatrixType::value_type>());
476
481 template <int dim, int spacedim, typename MatrixType>
482 void
483 create_laplace_matrix(
484 const DoFHandler<dim, spacedim> &dof,
485 const Quadrature<dim> &q,
486 MatrixType &matrix,
487 const Function<spacedim, typename MatrixType::value_type> *const a =
488 nullptr,
489 const AffineConstraints<typename MatrixType::value_type> &constraints =
490 AffineConstraints<typename MatrixType::value_type>());
491
510 template <int dim, int spacedim, typename MatrixType>
511 void
512 create_laplace_matrix(
513 const Mapping<dim, spacedim> &mapping,
514 const DoFHandler<dim, spacedim> &dof,
515 const Quadrature<dim> &q,
516 MatrixType &matrix,
517 const Function<spacedim, typename MatrixType::value_type> &rhs,
518 Vector<typename MatrixType::value_type> &rhs_vector,
519 const Function<spacedim, typename MatrixType::value_type> *const a =
520 nullptr,
521 const AffineConstraints<typename MatrixType::value_type> &constraints =
522 AffineConstraints<typename MatrixType::value_type>());
523
528 template <int dim, int spacedim, typename MatrixType>
529 void
530 create_laplace_matrix(
531 const DoFHandler<dim, spacedim> &dof,
532 const Quadrature<dim> &q,
533 MatrixType &matrix,
534 const Function<spacedim, typename MatrixType::value_type> &rhs,
535 Vector<typename MatrixType::value_type> &rhs_vector,
536 const Function<spacedim, typename MatrixType::value_type> *const a =
537 nullptr,
538 const AffineConstraints<typename MatrixType::value_type> &constraints =
539 AffineConstraints<typename MatrixType::value_type>());
540
544 template <int dim, int spacedim, typename MatrixType>
545 void
546 create_laplace_matrix(
547 const hp::MappingCollection<dim, spacedim> &mapping,
548 const DoFHandler<dim, spacedim> &dof,
549 const hp::QCollection<dim> &q,
550 MatrixType &matrix,
551 const Function<spacedim, typename MatrixType::value_type> *const a =
552 nullptr,
553 const AffineConstraints<typename MatrixType::value_type> &constraints =
554 AffineConstraints<typename MatrixType::value_type>());
555
559 template <int dim, int spacedim, typename MatrixType>
560 void
561 create_laplace_matrix(
562 const DoFHandler<dim, spacedim> &dof,
563 const hp::QCollection<dim> &q,
564 MatrixType &matrix,
565 const Function<spacedim, typename MatrixType::value_type> *const a =
566 nullptr,
567 const AffineConstraints<typename MatrixType::value_type> &constraints =
568 AffineConstraints<typename MatrixType::value_type>());
569
573 template <int dim, int spacedim, typename MatrixType>
574 void
575 create_laplace_matrix(
576 const hp::MappingCollection<dim, spacedim> &mapping,
577 const DoFHandler<dim, spacedim> &dof,
578 const hp::QCollection<dim> &q,
579 MatrixType &matrix,
580 const Function<spacedim, typename MatrixType::value_type> &rhs,
581 Vector<typename MatrixType::value_type> &rhs_vector,
582 const Function<spacedim, typename MatrixType::value_type> *const a =
583 nullptr,
584 const AffineConstraints<typename MatrixType::value_type> &constraints =
585 AffineConstraints<typename MatrixType::value_type>());
586
590 template <int dim, int spacedim, typename MatrixType>
591 void
592 create_laplace_matrix(
593 const DoFHandler<dim, spacedim> &dof,
594 const hp::QCollection<dim> &q,
595 MatrixType &matrix,
596 const Function<spacedim, typename MatrixType::value_type> &rhs,
597 Vector<typename MatrixType::value_type> &rhs_vector,
598 const Function<spacedim, typename MatrixType::value_type> *const a =
599 nullptr,
600 const AffineConstraints<typename MatrixType::value_type> &constraints =
601 AffineConstraints<typename MatrixType::value_type>());
602
606 DeclExceptionMsg(ExcComponentMismatch,
607 "You are providing either a right hand side function or a "
608 "coefficient with a number of vector components that is "
609 "inconsistent with the rest of the arguments. If you do "
610 "provide a coefficient or right hand side function, then "
611 "it either needs to have as many components as the finite "
612 "element in use, or only a single vector component. In "
613 "the latter case, the same value will be taken for "
614 "each vector component of the finite element.");
615} // namespace MatrixCreator
616
617
618DEAL_II_NAMESPACE_CLOSE
619
620#endif
affine_constraints.h
Mapping
Abstract base class for mapping classes.
Definition mapping.h:318
concepts::is_valid_dim_spacedim
Definition template_constraints.h:721
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:498
DEAL_II_CXX20_REQUIRES
#define DEAL_II_CXX20_REQUIRES(condition)
Definition config.h:175
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:499
DeclExceptionMsg
#define DeclExceptionMsg(Exception, defaulttext)
Definition exceptions.h:489
MatrixCreator::ExcComponentMismatch
static ::ExceptionBase & ExcComponentMismatch()
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_mass_matrix
void create_mass_matrix(const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, MatrixType &matrix, const Function< spacedim, typename MatrixType::value_type > *const a=nullptr, const AffineConstraints< typename MatrixType::value_type > &constraints=AffineConstraints< typename MatrixType::value_type >())
MatrixCreator::create_laplace_matrix
void create_laplace_matrix(const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, MatrixType &matrix, const Function< spacedim, typename MatrixType::value_type > *const a=nullptr, const AffineConstraints< typename MatrixType::value_type > &constraints=AffineConstraints< typename MatrixType::value_type >())
hp
Definition hp.h:117
Generated by doxygen 1.9.8