Classes for using SuperLU with ISTL matrices. │ │ │ │ -More...
│ │ │ │ -#include "superlufunctions.hh"#include "solvers.hh"#include "supermatrix.hh"#include <algorithm>#include <functional>#include "bcrsmatrix.hh"#include "bvector.hh"#include "istlexception.hh"#include <dune/common/fmatrix.hh>#include <dune/common/fvector.hh>#include <dune/common/stdstreams.hh>#include <dune/istl/solvertype.hh>#include <dune/istl/solverfactory.hh>#include "supermatrix.h"#include "slu_util.h"Go to the source code of this file.
│ │ │ ││ │ │ │ -Classes | |
| struct | Dune::SuperLUSolveChooser< T > |
| struct | Dune::SuperLUDenseMatChooser< T > |
| struct | Dune::SuperLUQueryChooser< T > |
| struct | Dune::QuerySpaceChooser< T > |
| class | Dune::SuperLU< M > |
| SuperLu Solver. More... | |
| struct | Dune::IsDirectSolver< SuperLU< BCRSMatrix< T, A > > > |
| struct | Dune::StoresColumnCompressed< SuperLU< BCRSMatrix< T, A > > > |
| struct | Dune::SuperLUCreator |
| struct | Dune::SuperLUCreator::isValidBlock< class > |
| struct | Dune::SuperLUCreator::isValidBlock< Dune::FieldVector< double, k > > |
| struct | Dune::SuperLUCreator::isValidBlock< Dune::FieldVector< std::complex< double >, k > > |
| struct | Dune::SuperLUCreator::isValidBlock< double > |
| struct | Dune::SuperLUCreator::isValidBlock< std::complex< double > > |
│ │ │ │ -Namespaces | |
| namespace | Dune |
│ │ │ │ -Functions | |
| Dune::DUNE_REGISTER_DIRECT_SOLVER ("superlu", SuperLUCreator()) | |
│ │ │ │ +Macros | |
| #define | int_t SUPERLU_INT_TYPE |
Classes for using SuperLU with ISTL matrices.
│ │ │ │ - │ │ │ │ -| #define int_t SUPERLU_INT_TYPE | │ │ │ │ +
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,65 +1,19 @@
│ │ │ │ │ dune-istl 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -superlu.hh File Reference
│ │ │ │ │ -_I_t_e_r_a_t_i_v_e_ _S_o_l_v_e_r_s_ _T_e_m_p_l_a_t_e_ _L_i_b_r_a_r_y_ _(_I_S_T_L_)
│ │ │ │ │ -Classes for using SuperLU with ISTL matrices. _M_o_r_e_._._.
│ │ │ │ │ -#include "_s_u_p_e_r_l_u_f_u_n_c_t_i_o_n_s_._h_h"
│ │ │ │ │ -#include "_s_o_l_v_e_r_s_._h_h"
│ │ │ │ │ -#include "_s_u_p_e_r_m_a_t_r_i_x_._h_h"
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,947 +1,129 @@
│ │ │ │ │ dune-istl 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -superlu.hh
│ │ │ │ │ +superlufunctions.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ 3// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 4// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ -5#ifndef DUNE_ISTL_SUPERLU_HH
│ │ │ │ │ -6#define DUNE_ISTL_SUPERLU_HH
│ │ │ │ │ -7
│ │ │ │ │ -8#if HAVE_SUPERLU
│ │ │ │ │ +5#ifndef DUNE_ISTL_SUPERLUFUNCTIONS_HH
│ │ │ │ │ +6#define DUNE_ISTL_SUPERLUFUNCTIONS_HH
│ │ │ │ │ +7#if HAVE_SUPERLU
│ │ │ │ │ +8
│ │ │ │ │ 9
│ │ │ │ │ -10#include "_s_u_p_e_r_l_u_f_u_n_c_t_i_o_n_s_._h_h"
│ │ │ │ │ -11#include "_s_o_l_v_e_r_s_._h_h"
│ │ │ │ │ -12#include "_s_u_p_e_r_m_a_t_r_i_x_._h_h"
│ │ │ │ │ -13#include #include <iostream>#include <fstream>#include <vector>#include <sstream>#include <cmath>#include <dune/common/timer.hh>#include "io.hh"#include "bvector.hh"#include "vbvector.hh"#include "bcrsmatrix.hh"#include "gsetc.hh"#include "ilu.hh"#include "operators.hh"#include "solvers.hh"#include "preconditioners.hh"#include "scalarproducts.hh"#include "owneroverlapcopy.hh"Functionality for redistributing a sparse matrix. │ │ │ │ +More...
│ │ │ │ +#include <memory>#include "repartition.hh"#include <dune/common/exceptions.hh>#include <dune/common/parallel/indexset.hh>#include <dune/istl/owneroverlapcopy.hh>#include <dune/istl/paamg/pinfo.hh>Go to the source code of this file.
│ │ │ ││ │ │ │ Classes | |
| class | Dune::OverlappingSchwarzOperator< M, X, Y, C > |
| An overlapping Schwarz operator. More... | |
| struct | Dune::RedistributeInformation< T > |
| class | Dune::RedistributeInformation< OwnerOverlapCopyCommunication< T, T1 > > |
| struct | Dune::CommMatrixRowSize< M, RI > |
| Utility class to communicate and set the row sizes of a redistributed matrix. More... | |
| struct | Dune::CommMatrixSparsityPattern< M, I > |
| Utility class to communicate and build the sparsity pattern of a redistributed matrix. More... | |
| struct | Dune::CommPolicy< CommMatrixSparsityPattern< M, I > > |
| struct | Dune::CommMatrixRow< M, I > |
| Utility class for comunicating the matrix entries. More... | |
| class | Dune::ParSSOR< M, X, Y, C > |
| A parallel SSOR preconditioner. More... | |
| struct | Dune::CommPolicy< CommMatrixRow< M, I > > |
| class | Dune::BlockPreconditioner< X, Y, C, P > |
| Block parallel preconditioner. More... | |
| struct | Dune::MatrixRowSizeGatherScatter< M, I, RI > |
| struct | Dune::MatrixCopyRowSizeGatherScatter< M, I, RI > |
| struct | Dune::MatrixSparsityPatternGatherScatter< M, I > |
| struct | Dune::MatrixRowGatherScatter< M, I > |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::Amg |
│ │ │ │ +Functions | |
| template<typename M , typename C > | |
| void | Dune::redistributeSparsityPattern (M &origMatrix, M &newMatrix, C &origComm, C &newComm, RedistributeInformation< C > &ri) |
| template<typename M , typename C > | |
| void | Dune::redistributeMatrixEntries (M &origMatrix, M &newMatrix, C &origComm, C &newComm, RedistributeInformation< C > &ri) |
| template<typename M , typename C > | |
| void | Dune::redistributeMatrix (M &origMatrix, M &newMatrix, C &origComm, C &newComm, RedistributeInformation< C > &ri) |
| Redistribute a matrix according to given domain decompositions. | |
| template<typename M > | |
| void | Dune::redistributeMatrixEntries (M &origMatrix, M &newMatrix, Dune::Amg::SequentialInformation &origComm, Dune::Amg::SequentialInformation &newComm, RedistributeInformation< Dune::Amg::SequentialInformation > &ri) |
| template<typename M > | |
| void | Dune::redistributeMatrix (M &origMatrix, M &newMatrix, Dune::Amg::SequentialInformation &origComm, Dune::Amg::SequentialInformation &newComm, RedistributeInformation< Dune::Amg::SequentialInformation > &ri) |
Functionality for redistributing a sparse matrix.
│ │ │ │ + │ │ │ │ + 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,43 +1,80 @@
│ │ │ │ │ dune-istl 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ -schwarz.hh File Reference
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,395 +1,1173 @@
│ │ │ │ │ dune-istl 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -schwarz.hh
│ │ │ │ │ +matrixredistribute.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ 3// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 4// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ -5#ifndef DUNE_ISTL_SCHWARZ_HH
│ │ │ │ │ -6#define DUNE_ISTL_SCHWARZ_HH
│ │ │ │ │ -7
│ │ │ │ │ -8#include & p, const _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e&
│ │ │ │ │ -c)
│ │ │ │ │ -318 : _preconditioner(p), _communication(c)
│ │ │ │ │ -319 { }
│ │ │ │ │ -320
│ │ │ │ │ -_3_2_6 virtual void _p_r_e (X& x, Y& b)
│ │ │ │ │ -327 {
│ │ │ │ │ -328 _communication.copyOwnerToAll(x,x); // make dirichlet values consistent
│ │ │ │ │ -329 _preconditioner->pre(x,b);
│ │ │ │ │ +299 if(nnz>0) {
│ │ │ │ │ +300 m.setSize(_a_g_g_i_d_x_s_e_t.size(), _a_g_g_i_d_x_s_e_t.size(), nnz);
│ │ │ │ │ +301 m.setBuildMode(M::row_wise);
│ │ │ │ │ +302 typename M::CreateIterator citer=m.createbegin();
│ │ │ │ │ +303#ifdef DEBUG_REPART
│ │ │ │ │ +304 std::size_t idx=0;
│ │ │ │ │ +305 bool correct=true;
│ │ │ │ │ +306 Dune::GlobalLookupIndexSet global(_a_g_g_i_d_x_s_e_t);
│ │ │ │ │ +307#endif
│ │ │ │ │ +308 typedef typename std::vector _preconditioner;
│ │ │ │ │ -369
│ │ │ │ │ -371 const _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e& _communication;
│ │ │ │ │ -372 };
│ │ │ │ │ -373
│ │ │ │ │ -376} // end namespace
│ │ │ │ │ -377
│ │ │ │ │ -378#endif
│ │ │ │ │ -_g_s_e_t_c_._h_h
│ │ │ │ │ -Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a
│ │ │ │ │ -generic way.
│ │ │ │ │ -_i_o_._h_h
│ │ │ │ │ -Some generic functions for pretty printing vectors and matrices.
│ │ │ │ │ -_p_r_e_c_o_n_d_i_t_i_o_n_e_r_s_._h_h
│ │ │ │ │ -Define general preconditioner interface.
│ │ │ │ │ -_s_c_a_l_a_r_p_r_o_d_u_c_t_s_._h_h
│ │ │ │ │ -Define base class for scalar product and norm.
│ │ │ │ │ -_b_c_r_s_m_a_t_r_i_x_._h_h
│ │ │ │ │ -Implementation of the BCRSMatrix class.
│ │ │ │ │ -_s_o_l_v_e_r_s_._h_h
│ │ │ │ │ -Implementations of the inverse operator interface.
│ │ │ │ │ -_i_l_u_._h_h
│ │ │ │ │ -The incomplete LU factorization kernels.
│ │ │ │ │ -_o_p_e_r_a_t_o_r_s_._h_h
│ │ │ │ │ -Define general, extensible interface for operators. The available
│ │ │ │ │ -implementation wraps a matrix.
│ │ │ │ │ -_v_b_v_e_c_t_o_r_._h_h
│ │ │ │ │ -???
│ │ │ │ │ +331 }
│ │ │ │ │ +332
│ │ │ │ │ +_3_4_0 void _c_o_m_p_l_e_t_e_S_p_a_r_s_i_t_y_P_a_t_t_e_r_n(std::vector
#include "bcrsmatrix.hh"#include "bvector.hh"#include <dune/common/fmatrix.hh>#include <dune/common/fvector.hh>#include <dune/common/typetraits.hh>#include <limits>#include <dune/istl/bccsmatrixinitializer.hh>#include "superlufunctions.hh"#include <iostream>#include <fstream>#include <vector>#include <sstream>#include <cmath>#include <dune/common/timer.hh>#include "io.hh"#include "bvector.hh"#include "vbvector.hh"#include "bcrsmatrix.hh"#include "gsetc.hh"#include "ilu.hh"#include "operators.hh"#include "solvers.hh"#include "preconditioners.hh"#include "scalarproducts.hh"#include "owneroverlapcopy.hh"Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::Amg |
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,50 +1,43 @@
│ │ │ │ │ dune-istl 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ _C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ -supermatrix.hh File Reference
│ │ │ │ │ -#include "_b_c_r_s_m_a_t_r_i_x_._h_h"
│ │ │ │ │ +schwarz.hh File Reference
│ │ │ │ │ +#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,461 +1,395 @@
│ │ │ │ │ dune-istl 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -supermatrix.hh
│ │ │ │ │ +schwarz.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ 3// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 4// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ -5#ifndef DUNE_ISTL_SUPERMATRIX_HH
│ │ │ │ │ -6#define DUNE_ISTL_SUPERMATRIX_HH
│ │ │ │ │ +5#ifndef DUNE_ISTL_SCHWARZ_HH
│ │ │ │ │ +6#define DUNE_ISTL_SCHWARZ_HH
│ │ │ │ │ 7
│ │ │ │ │ -8#if HAVE_SUPERLU
│ │ │ │ │ -9
│ │ │ │ │ -10#include "_b_c_r_s_m_a_t_r_i_x_._h_h"
│ │ │ │ │ -11#include "_b_v_e_c_t_o_r_._h_h"
│ │ │ │ │ -12#include & p, const _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e&
│ │ │ │ │ +c)
│ │ │ │ │ +318 : _preconditioner(p), _communication(c)
│ │ │ │ │ +319 { }
│ │ │ │ │ +320
│ │ │ │ │ +_3_2_6 virtual void _p_r_e (X& x, Y& b)
│ │ │ │ │ +327 {
│ │ │ │ │ +328 _communication.copyOwnerToAll(x,x); // make dirichlet values consistent
│ │ │ │ │ +329 _preconditioner->pre(x,b);
│ │ │ │ │ +330 }
│ │ │ │ │ +331
│ │ │ │ │ +_3_3_7 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +338 {
│ │ │ │ │ +339 _preconditioner->apply(v,d);
│ │ │ │ │ +340 _communication.copyOwnerToAll(v,v);
│ │ │ │ │ +341 }
│ │ │ │ │ +342
│ │ │ │ │ +343 template _preconditioner;
│ │ │ │ │ +369
│ │ │ │ │ +371 const _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e& _communication;
│ │ │ │ │ +372 };
│ │ │ │ │ +373
│ │ │ │ │ +376} // end namespace
│ │ │ │ │ +377
│ │ │ │ │ +378#endif
│ │ │ │ │ +_s_c_a_l_a_r_p_r_o_d_u_c_t_s_._h_h
│ │ │ │ │ +Define base class for scalar product and norm.
│ │ │ │ │ +_i_o_._h_h
│ │ │ │ │ +Some generic functions for pretty printing vectors and matrices.
│ │ │ │ │ +_o_w_n_e_r_o_v_e_r_l_a_p_c_o_p_y_._h_h
│ │ │ │ │ +Classes providing communication interfaces for overlapping Schwarz methods.
│ │ │ │ │ +_g_s_e_t_c_._h_h
│ │ │ │ │ +Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a
│ │ │ │ │ +generic way.
│ │ │ │ │ +_v_b_v_e_c_t_o_r_._h_h
│ │ │ │ │ +???
│ │ │ │ │ _b_v_e_c_t_o_r_._h_h
│ │ │ │ │ This file implements a vector space as a tensor product of a given vector
│ │ │ │ │ space. The number of compon...
│ │ │ │ │ -_m_a_t
│ │ │ │ │ -Matrix & mat
│ │ │ │ │ -DDeeffiinniittiioonn matrixmatrix.hh:347
│ │ │ │ │ -_s_t_d
│ │ │ │ │ -STL namespace.
│ │ │ │ │ +_b_c_r_s_m_a_t_r_i_x_._h_h
│ │ │ │ │ +Implementation of the BCRSMatrix class.
│ │ │ │ │ +_s_o_l_v_e_r_s_._h_h
│ │ │ │ │ +Implementations of the inverse operator interface.
│ │ │ │ │ +_o_p_e_r_a_t_o_r_s_._h_h
│ │ │ │ │ +Define general, extensible interface for operators. The available
│ │ │ │ │ +implementation wraps a matrix.
│ │ │ │ │ +_p_r_e_c_o_n_d_i_t_i_o_n_e_r_s_._h_h
│ │ │ │ │ +Define general preconditioner interface.
│ │ │ │ │ +_i_l_u_._h_h
│ │ │ │ │ +The incomplete LU factorization kernels.
│ │ │ │ │ +_D_u_n_e_:_:_b_s_o_r_b
│ │ │ │ │ +void bsorb(const M &A, X &x, const Y &b, const K &w)
│ │ │ │ │ +SSOR step.
│ │ │ │ │ +DDeeffiinniittiioonn gsetc.hh:646
│ │ │ │ │ +_D_u_n_e_:_:_b_s_o_r_f
│ │ │ │ │ +void bsorf(const M &A, X &x, const Y &b, const K &w)
│ │ │ │ │ +SOR step.
│ │ │ │ │ +DDeeffiinniittiioonn gsetc.hh:634
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn allocator.hh:11
│ │ │ │ │ -_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ -Initializer for SuperLU Matrices representing the subdomains.
│ │ │ │ │ -DDeeffiinniittiioonn overlappingschwarz.hh:47
│ │ │ │ │ -_D_u_n_e_:_:_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_:_:_c_o_l_d_i_m
│ │ │ │ │ -static auto coldim(const M &A)
│ │ │ │ │ -DDeeffiinniittiioonn matrixutils.hh:219
│ │ │ │ │ -_D_u_n_e_:_:_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_:_:_r_o_w_d_i_m
│ │ │ │ │ -static auto rowdim(const M &A)
│ │ │ │ │ -DDeeffiinniittiioonn matrixutils.hh:214
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -A sparse block matrix with compressed row storage.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:466
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ -A::size_type size_type
│ │ │ │ │ -The type for the index access and the size.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:500
│ │ │ │ │ -_D_u_n_e_:_:_S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z
│ │ │ │ │ -Sequential overlapping Schwarz preconditioner.
│ │ │ │ │ -DDeeffiinniittiioonn overlappingschwarz.hh:755
│ │ │ │ │ -_D_u_n_e_:_:_S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_A_s_s_e_m_b_l_e_r_H_e_l_p_e_r
│ │ │ │ │ -DDeeffiinniittiioonn overlappingschwarz.hh:694
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U
│ │ │ │ │ -SuperLu Solver.
│ │ │ │ │ -DDeeffiinniittiioonn superlu.hh:271
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_C_r_e_a_t_e_S_p_a_r_s_e_C_h_o_o_s_e_r
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:26
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_P_r_i_n_t_e_r
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:30
│ │ │ │ │ -_D_u_n_e_:_:_B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:126
│ │ │ │ │ -_D_u_n_e_:_:_B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e_:_:_t_y_p_e
│ │ │ │ │ -static const Dtype_t type
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:127
│ │ │ │ │ -_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:132
│ │ │ │ │ -_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _d_o_u_b_l_e_ _>_:_:_f_l_o_a_t___t_y_p_e
│ │ │ │ │ -double float_type
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:144
│ │ │ │ │ -_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _f_l_o_a_t_ _>_:_:_f_l_o_a_t___t_y_p_e
│ │ │ │ │ -float float_type
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:151
│ │ │ │ │ -_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _s_t_d_:_:_c_o_m_p_l_e_x_<_ _d_o_u_b_l_e_ _>_ _>_:_:_f_l_o_a_t___t_y_p_e
│ │ │ │ │ -double float_type
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:158
│ │ │ │ │ -_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _s_t_d_:_:_c_o_m_p_l_e_x_<_ _f_l_o_a_t_ _>_ _>_:_:_f_l_o_a_t___t_y_p_e
│ │ │ │ │ -float float_type
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:165
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ -Utility class for converting an ISTL Matrix into a SuperLU Matrix.
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:175
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:179
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_f_r_e_e
│ │ │ │ │ -virtual void free()
│ │ │ │ │ -free allocated space.
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:303
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ -SuperLUMatrix< BCRSMatrix< B, TA > > & operator=(const SuperLUMatrix<
│ │ │ │ │ -BCRSMatrix< B, TA > > &mat)
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:256
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ -SuperLUMatrix< BCRSMatrix< B, TA > > & operator=(const BCRSMatrix< B, TA >
│ │ │ │ │ -&mat)
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:237
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ -SuperLUMatrix(const Matrix &mat)
│ │ │ │ │ -Constructor that initializes the data.
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:212
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_s_e_t_M_a_t_r_i_x
│ │ │ │ │ -virtual void setMatrix(const Matrix &mat)
│ │ │ │ │ -Initialize data from given matrix.
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:293
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ -SuperLUMatrix()
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:215
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ -Matrix::size_type size_type
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:206
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_M_a_t_r_i_x
│ │ │ │ │ -BCRSMatrix< B, TA > Matrix
│ │ │ │ │ -The type of the matrix to convert.
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:202
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_s_e_t_M_a_t_r_i_x
│ │ │ │ │ -virtual void setMatrix(const Matrix &mat, const std::set< std::size_t > &mrs)
│ │ │ │ │ -Initialize data from a given set of matrix rows and columns.
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:281
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_~_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ -virtual ~SuperLUMatrix()
│ │ │ │ │ -Destructor.
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:219
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ -Dune::SuperLUMatrix< Matrix > SuperLUMatrix
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:320
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_M_a_t_r_i_x
│ │ │ │ │ -BCRSMatrix< B, A > Matrix
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:319
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ -SuperMatrixInitializer()
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:326
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_c_r_e_a_t_e_M_a_t_r_i_x
│ │ │ │ │ -virtual void createMatrix() const
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:329
│ │ │ │ │ -_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ -SuperMatrixInitializer(SuperLUMatrix &lum)
│ │ │ │ │ -DDeeffiinniittiioonn supermatrix.hh:322
│ │ │ │ │ +_D_u_n_e_:_:_A_s_s_e_m_b_l_e_d_L_i_n_e_a_r_O_p_e_r_a_t_o_r
│ │ │ │ │ +A linear operator exporting itself in matrix form.
│ │ │ │ │ +DDeeffiinniittiioonn operators.hh:109
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r
│ │ │ │ │ +An overlapping Schwarz operator.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:75
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_g_e_t_C_o_m_m_u_n_i_c_a_t_i_o_n
│ │ │ │ │ +const communication_type & getCommunication() const
│ │ │ │ │ +Get the object responsible for communication.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:146
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_g_e_t_m_a_t
│ │ │ │ │ +virtual const matrix_type & getmat() const
│ │ │ │ │ +get the sequential assembled linear operator.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:133
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_a_p_p_l_y_s_c_a_l_e_a_d_d
│ │ │ │ │ +virtual void applyscaleadd(field_type alpha, const X &x, Y &y) const
│ │ │ │ │ +apply operator to x, scale and add:
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:125
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(const X &x, Y &y) const
│ │ │ │ │ +apply operator to x:
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:116
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e
│ │ │ │ │ +C communication_type
│ │ │ │ │ +The type of the communication object.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:98
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The type of the domain.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:86
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +M matrix_type
│ │ │ │ │ +The type of the matrix we operate on.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:81
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The type of the range.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:91
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the range.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:93
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r
│ │ │ │ │ +OverlappingSchwarzOperator(const matrix_type &A, const communication_type &com)
│ │ │ │ │ +constructor: just store a reference to a matrix.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:107
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r
│ │ │ │ │ +OverlappingSchwarzOperator(const std::shared_ptr< matrix_type > A, const
│ │ │ │ │ +communication_type &com)
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:111
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the linear operator (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:139
│ │ │ │ │ +_D_u_n_e_:_:_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +Base class for matrix free definition of preconditioners.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioner.hh:32
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R
│ │ │ │ │ +A parallel SSOR preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:175
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:184
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e
│ │ │ │ │ +C communication_type
│ │ │ │ │ +The type of the communication object.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:186
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:233
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_P_a_r_S_S_O_R
│ │ │ │ │ +ParSSOR(const matrix_type &A, int n, field_type w, const communication_type &c)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:197
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:230
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:180
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:182
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +M matrix_type
│ │ │ │ │ +The matrix type the preconditioner is for.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:178
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the precondtioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:216
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:206
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +Block parallel preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:278
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:326
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:285
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +BlockPreconditioner(const std::shared_ptr< P > &p, const communication_type &c)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:317
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:337
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +BlockPreconditioner(P &p, const communication_type &c)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:306
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_a_p_p_l_y
│ │ │ │ │ +void apply(X &v, const Y &d)
│ │ │ │ │ +Apply one step of the preconditioner to the system A(v)=d.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:344
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e
│ │ │ │ │ +C communication_type
│ │ │ │ │ +The type of the communication object..
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:297
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:292
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:355
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:290
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:361
│ │ │ │ │ +_D_u_n_e_:_:_S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y
│ │ │ │ │ +Category
│ │ │ │ │ +DDeeffiinniittiioonn solvercategory.hh:23
│ │ │ │ │ +_D_u_n_e_:_:_S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_o_v_e_r_l_a_p_p_i_n_g
│ │ │ │ │ +@ overlapping
│ │ │ │ │ +Category for overlapping solvers.
│ │ │ │ │ +DDeeffiinniittiioonn solvercategory.hh:29
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00017.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a generic way. │ │ │ │ +
Provides classes for reading and writing MatrixMarket Files with an extension for parallel matrices. │ │ │ │ More...
│ │ │ │ -#include <cmath>#include <algorithm>#include <complex>#include <cstddef>#include <fstream>#include <ios>#include <iostream>#include <iomanip>#include <istream>#include <limits>#include <ostream>#include <set>#include <sstream>#include <string>#include <tuple>#include <type_traits>#include <vector>#include <dune/common/exceptions.hh>#include <dune/common/fmatrix.hh>#include <dune/common/fvector.hh>#include <dune/common/hybridutilities.hh>#include "multitypeblockvector.hh"#include "multitypeblockmatrix.hh"#include "istlexception.hh"#include <dune/common/stdstreams.hh>#include <dune/common/simd/simd.hh>#include <dune/istl/bcrsmatrix.hh>#include <dune/istl/bvector.hh>#include <dune/istl/matrixutils.hh>#include <dune/istl/owneroverlapcopy.hh>Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::MatrixMarketImpl |
│ │ │ │ Functions | |
| template<class M , class X , class Y > | |
| void | Dune::bltsolve (const M &A, X &v, const Y &d) |
| block lower triangular solve | |
| template<class M , class X , class Y , class K > | |
| void | Dune::bltsolve (const M &A, X &v, const Y &d, const K &w) |
| relaxed block lower triangular solve | |
| template<class M , class X , class Y > | |
| void | Dune::ubltsolve (const M &A, X &v, const Y &d) |
| unit block lower triangular solve | |
| template<class M , class X , class Y , class K > | |
| void | Dune::ubltsolve (const M &A, X &v, const Y &d, const K &w) |
| relaxed unit block lower triangular solve | |
| template<class M , class X , class Y > | |
| void | Dune::butsolve (const M &A, X &v, const Y &d) |
| block upper triangular solve | |
| template<class M , class X , class Y , class K > | |
| void | Dune::butsolve (const M &A, X &v, const Y &d, const K &w) |
| relaxed block upper triangular solve | |
| template<class M , class X , class Y > | |
| void | Dune::ubutsolve (const M &A, X &v, const Y &d) |
| unit block upper triangular solve | |
| template<class M , class X , class Y , class K > | |
| void | Dune::ubutsolve (const M &A, X &v, const Y &d, const K &w) |
| relaxed unit block upper triangular solve | |
| template<class M , class X , class Y , int l> | |
| void | Dune::bltsolve (const M &A, X &v, const Y &d, BL< l >) |
| block lower triangular solve | |
| template<class M , class X , class Y , class K , int l> | |
| void | Dune::bltsolve (const M &A, X &v, const Y &d, const K &w, BL< l >) |
| relaxed block lower triangular solve | |
| template<class M , class X , class Y , int l> | |
| void | Dune::ubltsolve (const M &A, X &v, const Y &d, BL< l >) |
| unit block lower triangular solve | |
| template<class M , class X , class Y , class K , int l> | |
| void | Dune::ubltsolve (const M &A, X &v, const Y &d, const K &w, BL< l >) |
| relaxed unit block lower triangular solve | |
| template<class M , class X , class Y , int l> | |
| void | Dune::butsolve (const M &A, X &v, const Y &d, BL< l > bl) |
| block upper triangular solve | |
| template<class M , class X , class Y , class K , int l> | |
| void | Dune::butsolve (const M &A, X &v, const Y &d, const K &w, BL< l > bl) |
| relaxed block upper triangular solve | |
| template<class M , class X , class Y , int l> | |
| void | Dune::ubutsolve (const M &A, X &v, const Y &d, BL< l > bl) |
| unit block upper triangular solve | |
| template<class M , class X , class Y , class K , int l> | |
| void | Dune::ubutsolve (const M &A, X &v, const Y &d, const K &w, BL< l > bl) |
| relaxed unit block upper triangular solve | |
| template<class M , class X , class Y > | |
| void | Dune::bdsolve (const M &A, X &v, const Y &d) |
| block diagonal solve, no relaxation | |
| template<class M , class X , class Y , class K > | |
| void | Dune::bdsolve (const M &A, X &v, const Y &d, const K &w) |
| block diagonal solve, with relaxation | |
| template<class M , class X , class Y , int l> | |
| void | Dune::bdsolve (const M &A, X &v, const Y &d, BL< l >) |
| block diagonal solve, no relaxation | |
| template<class M , class X , class Y , class K , int l> | |
| void | Dune::bdsolve (const M &A, X &v, const Y &d, const K &w, BL< l >) |
| block diagonal solve, with relaxation | |
| template<class M , class X , class Y , class K > | |
| void | Dune::dbgs (const M &A, X &x, const Y &b, const K &w) |
| GS step. | |
| template<class M , class X , class Y , class K , int l> | |
| void | Dune::dbgs (const M &A, X &x, const Y &b, const K &w, BL< l >) |
| GS step. | |
| template<class M , class X , class Y , class K > | |
| void | Dune::bsorf (const M &A, X &x, const Y &b, const K &w) |
| SOR step. | |
| template<class M , class X , class Y , class K , int l> | |
| void | Dune::bsorf (const M &A, X &x, const Y &b, const K &w, BL< l >) |
| SOR step. | |
| template<class M , class X , class Y , class K > | |
| void | Dune::bsorb (const M &A, X &x, const Y &b, const K &w) |
| SSOR step. | |
| template<class M , class X , class Y , class K , int l> | |
| void | Dune::bsorb (const M &A, X &x, const Y &b, const K &w, BL< l >) |
| Backward SOR step. | |
| template<class M , class X , class Y , class K > | |
| void | Dune::dbjac (const M &A, X &x, const Y &b, const K &w) |
| Jacobi step. | |
| template<class M , class X , class Y , class K , int l> | |
| void | Dune::dbjac (const M &A, X &x, const Y &b, const K &w, BL< l >) |
| Jacobi step. | |
| bool | Dune::MatrixMarketImpl::lineFeed (std::istream &file) |
| void | Dune::MatrixMarketImpl::skipComments (std::istream &file) |
| bool | Dune::MatrixMarketImpl::readMatrixMarketBanner (std::istream &file, MMHeader &mmHeader) |
| template<std::size_t brows, std::size_t bcols> | |
| std::tuple< std::size_t, std::size_t, std::size_t > | Dune::MatrixMarketImpl::calculateNNZ (std::size_t rows, std::size_t cols, std::size_t entries, const MMHeader &header) |
| template<typename T > | |
| std::istream & | Dune::MatrixMarketImpl::operator>> (std::istream &is, NumericWrapper< T > &num) |
| std::istream & | Dune::MatrixMarketImpl::operator>> (std::istream &is, NumericWrapper< PatternDummy > &num) |
| template<typename T > | |
| bool | Dune::MatrixMarketImpl::operator< (const IndexData< T > &i1, const IndexData< T > &i2) |
| LessThan operator. | |
| template<typename T > | |
| std::istream & | Dune::MatrixMarketImpl::operator>> (std::istream &is, IndexData< T > &data) |
| Read IndexData from a stream. | |
| template<typename T > | |
| std::istream & | Dune::MatrixMarketImpl::operator>> (std::istream &is, IndexData< NumericWrapper< std::complex< T > > > &data) |
| Read IndexData from a stream. Specialization for std::complex. | |
| template<class T > | |
| std::enable_if_t<!is_complex< T >::value, T > | Dune::MatrixMarketImpl::conj (const T &r) |
| template<class T > | |
| std::enable_if_t< is_complex< T >::value, T > | Dune::MatrixMarketImpl::conj (const T &r) |
| template<typename T , typename A , typename D > | |
| void | Dune::MatrixMarketImpl::readSparseEntries (Dune::BCRSMatrix< T, A > &matrix, std::istream &file, std::size_t entries, const MMHeader &mmHeader, const D &) |
| std::tuple< std::string, std::string > | Dune::MatrixMarketImpl::splitFilename (const std::string &filename) |
| void | Dune::mm_read_header (std::size_t &rows, std::size_t &cols, MatrixMarketImpl::MMHeader &header, std::istream &istr, bool isVector) |
| template<typename T , typename A > | |
| void | Dune::mm_read_vector_entries (Dune::BlockVector< T, A > &vector, std::size_t size, std::istream &istr, size_t lane) |
| template<typename T , typename A , int entries> | |
| void | Dune::mm_read_vector_entries (Dune::BlockVector< Dune::FieldVector< T, entries >, A > &vector, std::size_t size, std::istream &istr, size_t lane) |
| template<typename T , typename A > | |
| void | Dune::readMatrixMarket (Dune::BlockVector< T, A > &vector, std::istream &istr) |
| Reads a BlockVector from a matrix market file. | |
| template<typename T , typename A > | |
| void | Dune::readMatrixMarket (Dune::BCRSMatrix< T, A > &matrix, std::istream &istr) |
| Reads a sparse matrix from a matrix market file. | |
| template<typename B > | |
| void | Dune::mm_print_entry (const B &entry, std::size_t rowidx, std::size_t colidx, std::ostream &ostr) |
| template<typename V > | |
| void | Dune::mm_print_vector_entry (const V &entry, std::ostream &ostr, const std::integral_constant< int, 1 > &, size_t lane) |
| template<typename V > | |
| void | Dune::mm_print_vector_entry (const V &vector, std::ostream &ostr, const std::integral_constant< int, 0 > &, size_t lane) |
| template<typename T , typename A > | |
| std::size_t | Dune::countEntries (const BlockVector< T, A > &vector) |
| template<typename T , typename A , int i> | |
| std::size_t | Dune::countEntries (const BlockVector< FieldVector< T, i >, A > &vector) |
| template<typename V > | |
| void | Dune::writeMatrixMarket (const V &vector, std::ostream &ostr, const std::integral_constant< int, 0 > &) |
| template<typename M > | |
| void | Dune::writeMatrixMarket (const M &matrix, std::ostream &ostr, const std::integral_constant< int, 1 > &) |
| template<typename M > | |
| void | Dune::writeMatrixMarket (const M &matrix, std::ostream &ostr) |
| writes a ISTL matrix or vector to a stream in matrix market format. | |
| template<typename M > | |
| void | Dune::storeMatrixMarket (const M &matrix, std::string filename, int prec=default_precision) |
| Stores a parallel matrix/vector in matrix market format in a file. | |
| template<typename M , typename G , typename L > | |
| void | Dune::storeMatrixMarket (const M &matrix, std::string filename, const OwnerOverlapCopyCommunication< G, L > &comm, bool storeIndices=true, int prec=default_precision) |
| Stores a parallel matrix/vector in matrix market format in a file. | |
| template<typename M , typename G , typename L > | |
| void | Dune::loadMatrixMarket (M &matrix, const std::string &filename, OwnerOverlapCopyCommunication< G, L > &comm, bool readIndices=true) |
| Load a parallel matrix/vector stored in matrix market format. | |
| template<typename M > | |
| void | Dune::loadMatrixMarket (M &matrix, const std::string &filename) |
| Load a matrix/vector stored in matrix market format. | |
│ │ │ │ +Variables | |
| static const int | Dune::default_precision = -1 |
Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a generic way.
│ │ │ │ +Provides classes for reading and writing MatrixMarket Files with an extension for parallel matrices.
│ │ │ │ + │ │ │ │ 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,173 +1,316 @@
│ │ │ │ │ dune-istl 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _E_n_u_m_e_r_a_t_i_o_n_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -gsetc.hh File Reference
│ │ │ │ │ -Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a
│ │ │ │ │ -generic way. _M_o_r_e_._._.
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,832 +1,1632 @@
│ │ │ │ │ dune-istl 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -gsetc.hh
│ │ │ │ │ +matrixmarket.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ 3// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 4// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ -5#ifndef DUNE_ISTL_GSETC_HH
│ │ │ │ │ -6#define DUNE_ISTL_GSETC_HH
│ │ │ │ │ +5#ifndef DUNE_ISTL_MATRIXMARKET_HH
│ │ │ │ │ +6#define DUNE_ISTL_MATRIXMARKET_HH
│ │ │ │ │ 7
│ │ │ │ │ -8#include