>;
│ │ │ │ │ +278 using X = typename P::domain_type;
│ │ │ │ │ +279 using Y = typename P::range_type;
│ │ │ │ │ +280 public:
│ │ │ │ │ +_2_8_2 typedef typename P::domain_type _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_2_8_4 typedef typename P::range_type _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_2_8_6 typedef C _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e;
│ │ │ │ │ +287
│ │ │ │ │ +_2_9_5 _N_o_n_o_v_e_r_l_a_p_p_i_n_g_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r (P& p, const _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e& c)
│ │ │ │ │ +296 : _preconditioner(stackobject_to_shared_ptr(p)), _communication(c)
│ │ │ │ │ +297 { }
│ │ │ │ │ +298
│ │ │ │ │ +_3_0_6 _N_o_n_o_v_e_r_l_a_p_p_i_n_g_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r (const std::shared_ptr& p, const
│ │ │ │ │ +_c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e& c)
│ │ │ │ │ +307 : _preconditioner(p), _communication(c)
│ │ │ │ │ +308 { }
│ │ │ │ │ +309
│ │ │ │ │ +_3_1_5 virtual void _p_r_e (_d_o_m_a_i_n___t_y_p_e& x, _r_a_n_g_e___t_y_p_e& b)
│ │ │ │ │ +316 {
│ │ │ │ │ +317 _preconditioner->pre(x,b);
│ │ │ │ │ +318 }
│ │ │ │ │ +319
│ │ │ │ │ +_3_2_5 virtual void _a_p_p_l_y (_d_o_m_a_i_n___t_y_p_e& v, const _r_a_n_g_e___t_y_p_e& d)
│ │ │ │ │ +326 {
│ │ │ │ │ +327 // block preconditioner equivalent to WrappedPreconditioner from
│ │ │ │ │ +328 // pdelab/backend/ovlpistsolverbackend.hh,
│ │ │ │ │ +329 // but not to BlockPreconditioner from schwarz.hh
│ │ │ │ │ +330 _preconditioner->apply(v,d);
│ │ │ │ │ +331 _communication.addOwnerCopyToOwnerCopy(v,v);
│ │ │ │ │ +332 }
│ │ │ │ │ +333
│ │ │ │ │ +334 template
│ │ │ │ │ +_3_3_5 void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +336 {
│ │ │ │ │ +337 _preconditioner->template apply(v,d);
│ │ │ │ │ +338 _communication.addOwnerCopyToOwnerCopy(v,v);
│ │ │ │ │ +339 }
│ │ │ │ │ +340
│ │ │ │ │ +_3_4_6 virtual void _p_o_s_t (_d_o_m_a_i_n___t_y_p_e& x)
│ │ │ │ │ +347 {
│ │ │ │ │ +348 _preconditioner->post(x);
│ │ │ │ │ +349 }
│ │ │ │ │ +350
│ │ │ │ │ +_3_5_2 virtual _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y() const
│ │ │ │ │ +353 {
│ │ │ │ │ +354 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_n_o_n_o_v_e_r_l_a_p_p_i_n_g;
│ │ │ │ │ +355 }
│ │ │ │ │ +356
│ │ │ │ │ +357 private:
│ │ │ │ │ +359 std::shared_ptr _preconditioner;
│ │ │ │ │ +360
│ │ │ │ │ +362 const _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e& _communication;
│ │ │ │ │ +363 };
│ │ │ │ │ +364
│ │ │ │ │ +367} // end namespace
│ │ │ │ │ +368
│ │ │ │ │ +369#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.
│ │ │ │ │ +_p_r_e_c_o_n_d_i_t_i_o_n_e_r_s_._h_h
│ │ │ │ │ +Define general preconditioner interface.
│ │ │ │ │ +_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.
│ │ │ │ │ +_i_l_u_._h_h
│ │ │ │ │ +The incomplete LU factorization kernels.
│ │ │ │ │ +_g_s_e_t_c_._h_h
│ │ │ │ │ +Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a
│ │ │ │ │ +generic way.
│ │ │ │ │ +_b_c_r_s_m_a_t_r_i_x_._h_h
│ │ │ │ │ +Implementation of the BCRSMatrix class.
│ │ │ │ │ +_v_b_v_e_c_t_o_r_._h_h
│ │ │ │ │ +???
│ │ │ │ │ +_i_o_._h_h
│ │ │ │ │ +Some generic functions for pretty printing vectors and matrices.
│ │ │ │ │ +_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...
│ │ │ │ │ +_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.
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn allocator.hh:11
│ │ │ │ │ -_D_u_n_e_:_:_R_e_b_o_u_n_d_A_l_l_o_c_a_t_o_r_T_y_p_e
│ │ │ │ │ -typename std::allocator_traits< typename AllocatorTraits< T >::type >::template
│ │ │ │ │ -rebind_alloc< X > ReboundAllocatorType
│ │ │ │ │ -DDeeffiinniittiioonn allocator.hh:37
│ │ │ │ │ -_D_u_n_e_:_:_A_l_l_o_c_a_t_o_r_T_y_p_e
│ │ │ │ │ -typename AllocatorTraits< T >::type AllocatorType
│ │ │ │ │ -DDeeffiinniittiioonn allocator.hh:34
│ │ │ │ │ -_D_u_n_e_:_:_e_x_i_s_t_s
│ │ │ │ │ -DDeeffiinniittiioonn allocator.hh:14
│ │ │ │ │ -_D_u_n_e_:_:_e_x_i_s_t_s_:_:_v_a_l_u_e
│ │ │ │ │ -static const bool value
│ │ │ │ │ -DDeeffiinniittiioonn allocator.hh:15
│ │ │ │ │ -_D_u_n_e_:_:_D_e_f_a_u_l_t_A_l_l_o_c_a_t_o_r_T_r_a_i_t_s
│ │ │ │ │ -DDeeffiinniittiioonn allocator.hh:20
│ │ │ │ │ -_D_u_n_e_:_:_D_e_f_a_u_l_t_A_l_l_o_c_a_t_o_r_T_r_a_i_t_s_:_:_t_y_p_e
│ │ │ │ │ -std::allocator< T > type
│ │ │ │ │ -DDeeffiinniittiioonn allocator.hh:21
│ │ │ │ │ -_D_u_n_e_:_:_D_e_f_a_u_l_t_A_l_l_o_c_a_t_o_r_T_r_a_i_t_s_<_ _T_,_ _s_t_d_:_:_v_o_i_d___t_<_ _t_y_p_e_n_a_m_e_ _T_:_:_a_l_l_o_c_a_t_o_r___t_y_p_e_ _>_ _>_:_:
│ │ │ │ │ -_t_y_p_e
│ │ │ │ │ -typename T::allocator_type type
│ │ │ │ │ -DDeeffiinniittiioonn allocator.hh:27
│ │ │ │ │ -_D_u_n_e_:_:_A_l_l_o_c_a_t_o_r_T_r_a_i_t_s
│ │ │ │ │ -DDeeffiinniittiioonn allocator.hh:31
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 nonoverlapping operator with communication object.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:61
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_:_:_P_I_S
│ │ │ │ │ +C::PIS PIS
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:74
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 novlpschwarz.hh:72
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_I_M_a_p
│ │ │ │ │ +std::multimap< int, std::pair< int, RILIterator > > RIMap
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:82
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_I
│ │ │ │ │ +C::RI RI
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:75
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_:_:_n_o_v_l_p___o_p___a_p_p_l_y
│ │ │ │ │ +void novlp_op_apply(const X &x, Y &y, field_type alpha) const
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:126
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_:_:_N_o_n_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
│ │ │ │ │ +NonoverlappingSchwarzOperator(std::shared_ptr< const matrix_type > A, const
│ │ │ │ │ +communication_type &com)
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:96
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_l_I_t_e_r_a_t_o_r
│ │ │ │ │ +M::ConstColIterator ColIterator
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:79
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 novlpschwarz.hh:101
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 novlpschwarz.hh:66
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 novlpschwarz.hh:235
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_I_M_a_p_i_t
│ │ │ │ │ +RIMap::iterator RIMapit
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:83
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 matrix via *
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:121
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_I_L_I_t_e_r_a_t_o_r
│ │ │ │ │ +RIL::const_iterator RILIterator
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:78
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_M
│ │ │ │ │ +std::multimap< int, int > MM
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:81
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 novlpschwarz.hh:68
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 novlpschwarz.hh:64
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_o_w_I_t_e_r_a_t_o_r
│ │ │ │ │ +M::ConstRowIterator RowIterator
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:80
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 novlpschwarz.hh:241
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 novlpschwarz.hh:109
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_I_L
│ │ │ │ │ +RI::RemoteIndexList RIL
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:76
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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 novlpschwarz.hh:70
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_:_:_N_o_n_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
│ │ │ │ │ +NonoverlappingSchwarzOperator(const matrix_type &A, const communication_type
│ │ │ │ │ +&com)
│ │ │ │ │ +constructor: just store a reference to a matrix.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:92
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_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_I_I_t_e_r_a_t_o_r
│ │ │ │ │ +RI::const_iterator RIIterator
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:77
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +Nonoverlapping parallel preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:276
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +NonoverlappingBlockPreconditioner(P &p, const communication_type &c)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:295
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_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 novlpschwarz.hh:352
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_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(domain_type &v, const range_type &d)
│ │ │ │ │ +Apply the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:325
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_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
│ │ │ │ │ +P::range_type range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:284
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +NonoverlappingBlockPreconditioner(const std::shared_ptr< P > &p, const
│ │ │ │ │ +communication_type &c)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:306
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_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(domain_type &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:346
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_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 novlpschwarz.hh:286
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_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(domain_type &x, range_type &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:315
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_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 novlpschwarz.hh:335
│ │ │ │ │ +_D_u_n_e_:_:_N_o_n_o_v_e_r_l_a_p_p_i_n_g_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
│ │ │ │ │ +P::domain_type domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn novlpschwarz.hh:282
│ │ │ │ │ +_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:111
│ │ │ │ │ +_D_u_n_e_:_:_O_w_n_e_r_O_v_e_r_l_a_p_C_o_p_y_A_t_t_r_i_b_u_t_e_S_e_t_:_:_o_w_n_e_r
│ │ │ │ │ +@ owner
│ │ │ │ │ +DDeeffiinniittiioonn owneroverlapcopy.hh:61
│ │ │ │ │ +_D_u_n_e_:_:_O_w_n_e_r_O_v_e_r_l_a_p_C_o_p_y_A_t_t_r_i_b_u_t_e_S_e_t_:_:_c_o_p_y
│ │ │ │ │ +@ copy
│ │ │ │ │ +DDeeffiinniittiioonn owneroverlapcopy.hh:61
│ │ │ │ │ +_D_u_n_e_:_:_O_w_n_e_r_O_v_e_r_l_a_p_C_o_p_y_A_t_t_r_i_b_u_t_e_S_e_t_:_:_o_v_e_r_l_a_p
│ │ │ │ │ +@ overlap
│ │ │ │ │ +DDeeffiinniittiioonn owneroverlapcopy.hh:61
│ │ │ │ │ +_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:33
│ │ │ │ │ +_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_:_:_n_o_n_o_v_e_r_l_a_p_p_i_n_g
│ │ │ │ │ +@ nonoverlapping
│ │ │ │ │ +Category for non-overlapping solvers.
│ │ │ │ │ +DDeeffiinniittiioonn solvercategory.hh:27
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00011.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: solvercategory.hh File Reference
│ │ │ │ +dune-istl: ildl.hh File Reference
│ │ │ │
│ │ │ │ -
#include <dune/common/exceptions.hh>
│ │ │ │ +
│ │ │ │ +
Incomplete LDL decomposition.
│ │ │ │ +More...
│ │ │ │ +
#include <dune/common/scalarvectorview.hh>
│ │ │ │ +
#include <dune/common/scalarmatrixview.hh>
│ │ │ │ +
#include "ilu.hh "
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ namespace Dune
│ │ │ │ +template<class K , int m, int n> static void Dune::bildl_subtractBCT (const FieldMatrix < K, m, n > &B, const FieldMatrix < K, m, n > &CT, FieldMatrix < K, m, n > &A) template<class K > static void Dune::bildl_subtractBCT (const K &B, const K &CT, K &A, typename std::enable_if_t< Dune::IsNumber< K >::value > *sfinae=nullptr) template<class Matrix > static void Dune::bildl_subtractBCT (const Matrix &B, const Matrix &CT, Matrix &A, typename std::enable_if_t<!Dune::IsNumber< Matrix >::value > *sfinae=nullptr) template<class Matrix > void Dune::bildl_decompose (Matrix &A) compute ILDL decomposition of a symmetric matrix A template<class Matrix , class X , class Y > void Dune::bildl_backsolve (const Matrix &A, X &v, const Y &d, bool isLowerTriangular=false)
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
Incomplete LDL decomposition.
│ │ │ │ +
Author Martin Nolte
│ │ │ │ +
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ +ildl.hh File Reference
│ │ │ │ │ +Incomplete LDL decomposition. _M_o_r_e_._._.
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include "_i_l_u_._h_h"
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -CCllaasssseess
│ │ │ │ │ -struct _D_u_n_e_:_:_S_o_l_v_e_r_C_a_t_e_g_o_r_y
│ │ │ │ │ - Categories for the solvers. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ - class _D_u_n_e_:_:_I_n_v_a_l_i_d_S_o_l_v_e_r_C_a_t_e_g_o_r_y
│ │ │ │ │ -
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ +FFuunnccttiioonnss
│ │ │ │ │ +template
│ │ │ │ │ +static void _D_u_n_e_:_:_b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T (const _F_i_e_l_d_M_a_t_r_i_x< K, m, n > &B, const
│ │ │ │ │ + _F_i_e_l_d_M_a_t_r_i_x< K, m, n > &CT, _F_i_e_l_d_M_a_t_r_i_x< K, m, n > &A)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +static void _D_u_n_e_:_:_b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T (const K &B, const K &CT, K &A, typename
│ │ │ │ │ + std::enable_if_t< Dune::IsNumber< K >::value > *sfinae=nullptr)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +static void _D_u_n_e_:_:_b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T (const _M_a_t_r_i_x &B, const _M_a_t_r_i_x &CT, _M_a_t_r_i_x
│ │ │ │ │ + &A, typename std::enable_if_t::value >
│ │ │ │ │ + *sfinae=nullptr)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ + void _D_u_n_e_:_:_b_i_l_d_l___d_e_c_o_m_p_o_s_e (_M_a_t_r_i_x &A)
│ │ │ │ │ + compute ILDL decomposition of a symmetric matrix A
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ + void _D_u_n_e_:_:_b_i_l_d_l___b_a_c_k_s_o_l_v_e (const _M_a_t_r_i_x &A, X &v, const Y &d, bool
│ │ │ │ │ + isLowerTriangular=false)
│ │ │ │ │ +
│ │ │ │ │ +********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ +Incomplete LDL decomposition.
│ │ │ │ │ + Author
│ │ │ │ │ + Martin Nolte
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00011_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: solvercategory.hh Source File
│ │ │ │ +dune-istl: ildl.hh Source File
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
5 #ifndef DUNE_ISTL_SOLVERCATEGORY_HH
│ │ │ │ -
6 #define DUNE_ISTL_SOLVERCATEGORY_HH
│ │ │ │ -
│ │ │ │ -
8 #include <dune/common/exceptions.hh>
│ │ │ │ +
3 #ifndef DUNE_ISTL_ILDL_HH
│ │ │ │ +
4 #define DUNE_ISTL_ILDL_HH
│ │ │ │ +
│ │ │ │ +
6 #include <dune/common/scalarvectorview.hh>
│ │ │ │ +
7 #include <dune/common/scalarmatrixview.hh>
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
23 template <
class K,
int m,
int n >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
26 for (
int i = 0; i < m; ++i )
│ │ │ │ +
│ │ │ │ +
28 for (
int j = 0; j < n; ++j )
│ │ │ │ +
│ │ │ │ +
30 for (
int k = 0; k < n; ++k )
│ │ │ │ +
31 A[ i ][ j ] -= B[ i ][ k ] * CT[ j ][ k ];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
38 typename std::enable_if_t<Dune::IsNumber<K>::value>* sfinae =
nullptr )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
43 template <
class Matrix >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
45 typename std::enable_if_t<!Dune::IsNumber<Matrix>::value>* sfinae =
nullptr )
│ │ │ │ +
│ │ │ │ +
47 for (
auto i = A.
begin (), iend = A.
end (); i != iend; ++i )
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
50 auto &&B_i = B[ i.index() ];
│ │ │ │ +
51 const auto ikend = B_i.
end ();
│ │ │ │ +
52 for (
auto j = A_i.begin(), jend = A_i.end(); j != jend; ++j )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
55 auto &&CT_j = CT[ j.index() ];
│ │ │ │ +
56 const auto jkend = CT_j.
end ();
│ │ │ │ +
57 for (
auto ik = B_i.begin(), jk = CT_j.begin(); (ik != ikend) && (jk != jkend); )
│ │ │ │ +
│ │ │ │ +
59 if ( ik.index() == jk.index() )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
64 else if ( ik.index() < jk.index() )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
87 template <
class Matrix >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
90 for (
auto i = A.
begin (), iend = A.
end (); i != iend; ++i )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
94 auto ij = A_i.begin();
│ │ │ │ +
95 for ( ; ij.index() < i.index(); ++ij )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
98 auto &&A_j = A[ ij.index() ];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
102 auto ik = A_i.
begin ();
│ │ │ │ +
103 auto jk = A_j.begin();
│ │ │ │ +
104 while ( (ik != ij) && (jk.index() < ij.index()) )
│ │ │ │ +
│ │ │ │ +
106 if ( ik.index() == jk.index() )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
111 else if ( ik.index() < jk.index() )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
118 if ( ij.index() != i.index() )
│ │ │ │ +
119 DUNE_THROW(
ISTLError ,
"diagonal entry missing" );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
123 for (
auto ik = A_i.begin(); ik != ij; ++ik )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
126 const auto &A_k = A[ ik.index() ];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
129 Impl::asMatrix(A_ik).rightmultiply( Impl::asMatrix(*A_k.find( ik.index() )) );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
134 Impl::asMatrix(A_ii).invert();
│ │ │ │ +
│ │ │ │ +
136 catch (
const Dune::FMatrixError &e )
│ │ │ │ +
│ │ │ │ +
138 DUNE_THROW(
MatrixBlockError ,
"ILDL failed to invert matrix block A[" << i.index() <<
"][" << ij.index() <<
"]" << e.what(); th__ex.r = i.index(); th__ex.c = ij.index() );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
148 template <
class Matrix,
class X,
class Y >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
152 for (
auto i = A.
begin (), iend = A.
end (); i != iend; ++i )
│ │ │ │ +
│ │ │ │ +
154 const auto &A_i = *i;
│ │ │ │ +
155 v[ i.index() ] = d[ i.index() ];
│ │ │ │ +
156 for (
auto ij = A_i.begin(); ij.index() < i.index(); ++ij )
│ │ │ │ +
│ │ │ │ +
158 auto && vi = Impl::asVector( v[ i.index() ] );
│ │ │ │ +
159 Impl::asMatrix(*ij).mmv(Impl::asVector( v[ ij.index() ] ), vi);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
164 if ( isLowerTriangular )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
168 for (
auto i = A.
begin (), iend = A.
end (); i != iend; ++i )
│ │ │ │ +
│ │ │ │ +
170 const auto &A_i = *i;
│ │ │ │ +
171 const auto ii = A_i.beforeEnd();
│ │ │ │ +
172 assert( ii.index() == i.index() );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
179 auto rhsValue = v[ i.index() ];
│ │ │ │ +
180 auto && rhs = Impl::asVector(rhsValue);
│ │ │ │ +
181 auto && vi = Impl::asVector( v[ i.index() ] );
│ │ │ │ +
182 Impl::asMatrix(*ii).mv(rhs, vi);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
189 for (
auto i = A.
begin (), iend = A.
end (); i != iend; ++i )
│ │ │ │ +
│ │ │ │ +
191 const auto &A_i = *i;
│ │ │ │ +
192 const auto ii = A_i.find( i.index() );
│ │ │ │ +
193 assert( ii.index() == i.index() );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
200 auto rhsValue = v[ i.index() ];
│ │ │ │ +
201 auto && rhs = Impl::asVector(rhsValue);
│ │ │ │ +
202 auto && vi = Impl::asVector( v[ i.index() ] );
│ │ │ │ +
203 Impl::asMatrix(*ii).mv(rhs, vi);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
211 const auto &A_i = *i;
│ │ │ │ +
212 for (
auto ij = A_i.begin(); ij.index() < i.index(); ++ij )
│ │ │ │ +
│ │ │ │ +
214 auto && vij = Impl::asVector( v[ ij.index() ] );
│ │ │ │ +
215 Impl::asMatrix(*ij).mmtv(Impl::asVector( v[ i.index() ] ), vij);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
The incomplete LU factorization kernels.
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
Categories for the solvers.
Definition solvercategory.hh:22
│ │ │ │ -
Category
Definition solvercategory.hh:23
│ │ │ │ -
@ sequential
Category for sequential solvers.
Definition solvercategory.hh:25
│ │ │ │ -
@ nonoverlapping
Category for non-overlapping solvers.
Definition solvercategory.hh:27
│ │ │ │ -
@ overlapping
Category for overlapping solvers.
Definition solvercategory.hh:29
│ │ │ │ -
static Category category(const OP &op, decltype(op.category()) *=nullptr)
Helperfunction to extract the solver category either from an enum, or from the newly introduced virtu...
Definition solvercategory.hh:34
│ │ │ │ -
Definition solvercategory.hh:54
│ │ │ │ +
void bildl_decompose(Matrix &A)
compute ILDL decomposition of a symmetric matrix A
Definition ildl.hh:88
│ │ │ │ +
void bildl_backsolve(const Matrix &A, X &v, const Y &d, bool isLowerTriangular=false)
Definition ildl.hh:149
│ │ │ │ +
static void bildl_subtractBCT(const FieldMatrix< K, m, n > &B, const FieldMatrix< K, m, n > &CT, FieldMatrix< K, m, n > &A)
Definition ildl.hh:24
│ │ │ │ +
derive error class from the base class in common
Definition istlexception.hh:19
│ │ │ │ +
Error when performing an operation on a matrix block.
Definition istlexception.hh:52
│ │ │ │ +
A generic dynamic dense matrix.
Definition matrix.hh:561
│ │ │ │ +
RowIterator beforeBegin()
Definition matrix.hh:630
│ │ │ │ +
RowIterator beforeEnd()
Definition matrix.hh:623
│ │ │ │ +
RowIterator end()
Get iterator to one beyond last row.
Definition matrix.hh:616
│ │ │ │ +
RowIterator begin()
Get iterator to first row.
Definition matrix.hh:610
│ │ │ │ +
Definition matrixutils.hh:27
│ │ │ │
│ │ │ │ │ +3#ifndef DUNE_ISTL_ILDL_HH
│ │ │ │ │ +4#define DUNE_ISTL_ILDL_HH
│ │ │ │ │ +5
│ │ │ │ │ +6#include
│ │ │ │ │ +7#include
│ │ │ │ │ +8#include "_i_l_u_._h_h"
│ │ │ │ │ 9
│ │ │ │ │ -10
│ │ │ │ │ -11namespace _D_u_n_e {
│ │ │ │ │ -12
│ │ │ │ │ -_2_1 struct _S_o_l_v_e_r_C_a_t_e_g_o_r_y
│ │ │ │ │ -22 {
│ │ │ │ │ -_2_3 enum _C_a_t_e_g_o_r_y {
│ │ │ │ │ -_2_5 _s_e_q_u_e_n_t_i_a_l,
│ │ │ │ │ -_2_7 _n_o_n_o_v_e_r_l_a_p_p_i_n_g,
│ │ │ │ │ -29 _o_v_e_r_l_a_p_p_i_n_g
│ │ │ │ │ -_3_0 };
│ │ │ │ │ -31
│ │ │ │ │ -33 template
│ │ │ │ │ -_3_4 static _C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y(const OP& op, decltype(op.category())* = nullptr)
│ │ │ │ │ -35 {
│ │ │ │ │ -36 return op.category();
│ │ │ │ │ -37 }
│ │ │ │ │ -38
│ │ │ │ │ -39#ifndef DOXYGEN
│ │ │ │ │ -40 // template
│ │ │ │ │ -41 // static Category category(const OP& op, decltype(op.getSolverCategory())*
│ │ │ │ │ -= nullptr)
│ │ │ │ │ -42 // {
│ │ │ │ │ -43 // return op.getSolverCategory();
│ │ │ │ │ -44 // }
│ │ │ │ │ -45
│ │ │ │ │ -46 template
│ │ │ │ │ -47 static _C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y(const OP& op, decltype(op.category)* = nullptr)
│ │ │ │ │ +17namespace _D_u_n_e
│ │ │ │ │ +18{
│ │ │ │ │ +19
│ │ │ │ │ +20 // bildl_subtractBCT
│ │ │ │ │ +21 // -----------------
│ │ │ │ │ +22
│ │ │ │ │ +23 template< class K, int m, int n >
│ │ │ │ │ +_2_4 inline static void _b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T ( const _F_i_e_l_d_M_a_t_r_i_x_<_ _K_,_ _m_,_ _n_ _> &B,
│ │ │ │ │ +const _F_i_e_l_d_M_a_t_r_i_x_<_ _K_,_ _m_,_ _n_ _> &CT, _F_i_e_l_d_M_a_t_r_i_x_<_ _K_,_ _m_,_ _n_ _> &A )
│ │ │ │ │ +25 {
│ │ │ │ │ +26 for( int i = 0; i < m; ++i )
│ │ │ │ │ +27 {
│ │ │ │ │ +28 for( int j = 0; j < n; ++j )
│ │ │ │ │ +29 {
│ │ │ │ │ +30 for( int k = 0; k < n; ++k )
│ │ │ │ │ +31 A[ i ][ j ] -= B[ i ][ k ] * CT[ j ][ k ];
│ │ │ │ │ +32 }
│ │ │ │ │ +33 }
│ │ │ │ │ +34 }
│ │ │ │ │ +35
│ │ │ │ │ +36 template< class K >
│ │ │ │ │ +_3_7 inline static void _b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T ( const K &B, const K &CT, K &A,
│ │ │ │ │ +38 typename std::enable_if_t::value>* sfinae = nullptr )
│ │ │ │ │ +39 {
│ │ │ │ │ +40 A -= B * CT;
│ │ │ │ │ +41 }
│ │ │ │ │ +42
│ │ │ │ │ +43 template< class Matrix >
│ │ │ │ │ +_4_4 inline static void _b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T ( const _M_a_t_r_i_x &B, const _M_a_t_r_i_x &CT,
│ │ │ │ │ +_M_a_t_r_i_x &A,
│ │ │ │ │ +45 typename std::enable_if_t::value>* sfinae = nullptr
│ │ │ │ │ +)
│ │ │ │ │ +46 {
│ │ │ │ │ +47 for( auto i = A._b_e_g_i_n(), iend = A._e_n_d(); i != iend; ++i )
│ │ │ │ │ 48 {
│ │ │ │ │ -49 return OP::category;
│ │ │ │ │ -50 }
│ │ │ │ │ -51#endif
│ │ │ │ │ -52 };
│ │ │ │ │ -53
│ │ │ │ │ -_5_4 class _I_n_v_a_l_i_d_S_o_l_v_e_r_C_a_t_e_g_o_r_y : public InvalidStateException{};
│ │ │ │ │ -55
│ │ │ │ │ -58} // end namespace
│ │ │ │ │ -59
│ │ │ │ │ -60#endif
│ │ │ │ │ +49 auto &&A_i = *i;
│ │ │ │ │ +50 auto &&B_i = B[ i.index() ];
│ │ │ │ │ +51 const auto ikend = B_i._e_n_d();
│ │ │ │ │ +52 for( auto j = A_i.begin(), jend = A_i.end(); j != jend; ++j )
│ │ │ │ │ +53 {
│ │ │ │ │ +54 auto &&A_ij = *j;
│ │ │ │ │ +55 auto &&CT_j = CT[ j.index() ];
│ │ │ │ │ +56 const auto jkend = CT_j._e_n_d();
│ │ │ │ │ +57 for( auto ik = B_i.begin(), jk = CT_j.begin(); (ik != ikend) && (jk !=
│ │ │ │ │ +jkend); )
│ │ │ │ │ +58 {
│ │ │ │ │ +59 if( ik.index() == jk.index() )
│ │ │ │ │ +60 {
│ │ │ │ │ +61 _b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T( *ik, *jk, A_ij );
│ │ │ │ │ +62 ++ik; ++jk;
│ │ │ │ │ +63 }
│ │ │ │ │ +64 else if( ik.index() < jk.index() )
│ │ │ │ │ +65 ++ik;
│ │ │ │ │ +66 else
│ │ │ │ │ +67 ++jk;
│ │ │ │ │ +68 }
│ │ │ │ │ +69 }
│ │ │ │ │ +70 }
│ │ │ │ │ +71 }
│ │ │ │ │ +72
│ │ │ │ │ +73
│ │ │ │ │ +74
│ │ │ │ │ +75 // bildl_decompose
│ │ │ │ │ +76 // ---------------
│ │ │ │ │ +77
│ │ │ │ │ +87 template< class Matrix >
│ │ │ │ │ +_8_8 inline void _b_i_l_d_l___d_e_c_o_m_p_o_s_e ( _M_a_t_r_i_x &A )
│ │ │ │ │ +89 {
│ │ │ │ │ +90 for( auto i = A._b_e_g_i_n(), iend = A._e_n_d(); i != iend; ++i )
│ │ │ │ │ +91 {
│ │ │ │ │ +92 auto &&A_i = *i;
│ │ │ │ │ +93
│ │ │ │ │ +94 auto ij = A_i.begin();
│ │ │ │ │ +95 for( ; ij.index() < i.index(); ++ij )
│ │ │ │ │ +96 {
│ │ │ │ │ +97 auto &&A_ij = *ij;
│ │ │ │ │ +98 auto &&A_j = A[ ij.index() ];
│ │ │ │ │ +99
│ │ │ │ │ +100 // store L_ij Dj in A_ij (note: for k < i: A_kj = L_kj)
│ │ │ │ │ +101 // L_ij Dj = A_ij - \sum_{k < j} (L_ik D_k) L_jk^T
│ │ │ │ │ +102 auto ik = A_i._b_e_g_i_n();
│ │ │ │ │ +103 auto jk = A_j.begin();
│ │ │ │ │ +104 while( (ik != ij) && (jk.index() < ij.index()) )
│ │ │ │ │ +105 {
│ │ │ │ │ +106 if( ik.index() == jk.index() )
│ │ │ │ │ +107 {
│ │ │ │ │ +108 _b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T(*ik, *jk, A_ij);
│ │ │ │ │ +109 ++ik; ++jk;
│ │ │ │ │ +110 }
│ │ │ │ │ +111 else if( ik.index() < jk.index() )
│ │ │ │ │ +112 ++ik;
│ │ │ │ │ +113 else
│ │ │ │ │ +114 ++jk;
│ │ │ │ │ +115 }
│ │ │ │ │ +116 }
│ │ │ │ │ +117
│ │ │ │ │ +118 if( ij.index() != i.index() )
│ │ │ │ │ +119 DUNE_THROW( _I_S_T_L_E_r_r_o_r, "diagonal entry missing" );
│ │ │ │ │ +120
│ │ │ │ │ +121 // update diagonal and multiply A_ij by D_j^{-1}
│ │ │ │ │ +122 auto &&A_ii = *ij;
│ │ │ │ │ +123 for( auto ik = A_i.begin(); ik != ij; ++ik )
│ │ │ │ │ +124 {
│ │ │ │ │ +125 auto &&A_ik = *ik;
│ │ │ │ │ +126 const auto &A_k = A[ ik.index() ];
│ │ │ │ │ +127
│ │ │ │ │ +128 auto B = A_ik;
│ │ │ │ │ +129 Impl::asMatrix(A_ik).rightmultiply( Impl::asMatrix(*A_k.find( ik.index() ))
│ │ │ │ │ +);
│ │ │ │ │ +130 _b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T( B, A_ik, A_ii );
│ │ │ │ │ +131 }
│ │ │ │ │ +132 try
│ │ │ │ │ +133 {
│ │ │ │ │ +134 Impl::asMatrix(A_ii).invert();
│ │ │ │ │ +135 }
│ │ │ │ │ +136 catch( const Dune::FMatrixError &e )
│ │ │ │ │ +137 {
│ │ │ │ │ +138 DUNE_THROW( _M_a_t_r_i_x_B_l_o_c_k_E_r_r_o_r, "ILDL failed to invert matrix block A[" <<
│ │ │ │ │ +i.index() << "][" << ij.index() << "]" << e.what(); th__ex.r = i.index();
│ │ │ │ │ +th__ex.c = ij.index() );
│ │ │ │ │ +139 }
│ │ │ │ │ +140 }
│ │ │ │ │ +141 }
│ │ │ │ │ +142
│ │ │ │ │ +143
│ │ │ │ │ +144
│ │ │ │ │ +145 // bildl_backsolve
│ │ │ │ │ +146 // ---------------
│ │ │ │ │ +147
│ │ │ │ │ +148 template< class Matrix, class X, class Y >
│ │ │ │ │ +_1_4_9 inline void _b_i_l_d_l___b_a_c_k_s_o_l_v_e ( const _M_a_t_r_i_x &A, X &v, const Y &d, bool
│ │ │ │ │ +isLowerTriangular = false )
│ │ │ │ │ +150 {
│ │ │ │ │ +151 // solve L v = d, note: Lii = I
│ │ │ │ │ +152 for( auto i = A._b_e_g_i_n(), iend = A._e_n_d(); i != iend; ++i )
│ │ │ │ │ +153 {
│ │ │ │ │ +154 const auto &A_i = *i;
│ │ │ │ │ +155 v[ i.index() ] = d[ i.index() ];
│ │ │ │ │ +156 for( auto ij = A_i.begin(); ij.index() < i.index(); ++ij )
│ │ │ │ │ +157 {
│ │ │ │ │ +158 auto&& vi = Impl::asVector( v[ i.index() ] );
│ │ │ │ │ +159 Impl::asMatrix(*ij).mmv(Impl::asVector( v[ ij.index() ] ), vi);
│ │ │ │ │ +160 }
│ │ │ │ │ +161 }
│ │ │ │ │ +162
│ │ │ │ │ +163 // solve D w = v, note: diagonal stores Dii^{-1}
│ │ │ │ │ +164 if( isLowerTriangular )
│ │ │ │ │ +165 {
│ │ │ │ │ +166 // The matrix is lower triangular, so the diagonal entry is the
│ │ │ │ │ +167 // last one in each row.
│ │ │ │ │ +168 for( auto i = A._b_e_g_i_n(), iend = A._e_n_d(); i != iend; ++i )
│ │ │ │ │ +169 {
│ │ │ │ │ +170 const auto &A_i = *i;
│ │ │ │ │ +171 const auto ii = A_i.beforeEnd();
│ │ │ │ │ +172 assert( ii.index() == i.index() );
│ │ │ │ │ +173 // We need to be careful here: Directly using
│ │ │ │ │ +174 // auto rhs = Impl::asVector(v[ i.index() ]);
│ │ │ │ │ +175 // is not OK in case this is a proxy. Hence
│ │ │ │ │ +176 // we first have to copy the value. Notice that
│ │ │ │ │ +177 // this is still not OK, if the vector type itself returns
│ │ │ │ │ +178 // proxy references.
│ │ │ │ │ +179 auto rhsValue = v[ i.index() ];
│ │ │ │ │ +180 auto&& rhs = Impl::asVector(rhsValue);
│ │ │ │ │ +181 auto&& vi = Impl::asVector( v[ i.index() ] );
│ │ │ │ │ +182 Impl::asMatrix(*ii).mv(rhs, vi);
│ │ │ │ │ +183 }
│ │ │ │ │ +184 }
│ │ │ │ │ +185 else
│ │ │ │ │ +186 {
│ │ │ │ │ +187 // Without assumptions on the sparsity pattern we have to search
│ │ │ │ │ +188 // for the diagonal entry in each row.
│ │ │ │ │ +189 for( auto i = A._b_e_g_i_n(), iend = A._e_n_d(); i != iend; ++i )
│ │ │ │ │ +190 {
│ │ │ │ │ +191 const auto &A_i = *i;
│ │ │ │ │ +192 const auto ii = A_i.find( i.index() );
│ │ │ │ │ +193 assert( ii.index() == i.index() );
│ │ │ │ │ +194 // We need to be careful here: Directly using
│ │ │ │ │ +195 // auto rhs = Impl::asVector(v[ i.index() ]);
│ │ │ │ │ +196 // is not OK in case this is a proxy. Hence
│ │ │ │ │ +197 // we first have to copy the value. Notice that
│ │ │ │ │ +198 // this is still not OK, if the vector type itself returns
│ │ │ │ │ +199 // proxy references.
│ │ │ │ │ +200 auto rhsValue = v[ i.index() ];
│ │ │ │ │ +201 auto&& rhs = Impl::asVector(rhsValue);
│ │ │ │ │ +202 auto&& vi = Impl::asVector( v[ i.index() ] );
│ │ │ │ │ +203 Impl::asMatrix(*ii).mv(rhs, vi);
│ │ │ │ │ +204 }
│ │ │ │ │ +205 }
│ │ │ │ │ +206
│ │ │ │ │ +207 // solve L^T v = w, note: only L is stored
│ │ │ │ │ +208 // note: we perform the operation column-wise from right to left
│ │ │ │ │ +209 for( auto i = A._b_e_f_o_r_e_E_n_d(), iend = A._b_e_f_o_r_e_B_e_g_i_n(); i != iend; --i )
│ │ │ │ │ +210 {
│ │ │ │ │ +211 const auto &A_i = *i;
│ │ │ │ │ +212 for( auto ij = A_i.begin(); ij.index() < i.index(); ++ij )
│ │ │ │ │ +213 {
│ │ │ │ │ +214 auto&& vij = Impl::asVector( v[ ij.index() ] );
│ │ │ │ │ +215 Impl::asMatrix(*ij).mmtv(Impl::asVector( v[ i.index() ] ), vij);
│ │ │ │ │ +216 }
│ │ │ │ │ +217 }
│ │ │ │ │ +218 }
│ │ │ │ │ +219
│ │ │ │ │ +220} // namespace Dune
│ │ │ │ │ +221
│ │ │ │ │ +222#endif // #ifndef DUNE_ISTL_ILDL_HH
│ │ │ │ │ +_i_l_u_._h_h
│ │ │ │ │ +The incomplete LU factorization kernels.
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn allocator.hh:11
│ │ │ │ │ -_D_u_n_e_:_:_S_o_l_v_e_r_C_a_t_e_g_o_r_y
│ │ │ │ │ -Categories for the solvers.
│ │ │ │ │ -DDeeffiinniittiioonn solvercategory.hh:22
│ │ │ │ │ -_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_:_:_s_e_q_u_e_n_t_i_a_l
│ │ │ │ │ -@ sequential
│ │ │ │ │ -Category for sequential solvers.
│ │ │ │ │ -DDeeffiinniittiioonn solvercategory.hh:25
│ │ │ │ │ -_D_u_n_e_:_:_S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_n_o_n_o_v_e_r_l_a_p_p_i_n_g
│ │ │ │ │ -@ nonoverlapping
│ │ │ │ │ -Category for non-overlapping solvers.
│ │ │ │ │ -DDeeffiinniittiioonn solvercategory.hh:27
│ │ │ │ │ -_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
│ │ │ │ │ -_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
│ │ │ │ │ -static Category category(const OP &op, decltype(op.category()) *=nullptr)
│ │ │ │ │ -Helperfunction to extract the solver category either from an enum, or from the
│ │ │ │ │ -newly introduced virtu...
│ │ │ │ │ -DDeeffiinniittiioonn solvercategory.hh:34
│ │ │ │ │ -_D_u_n_e_:_:_I_n_v_a_l_i_d_S_o_l_v_e_r_C_a_t_e_g_o_r_y
│ │ │ │ │ -DDeeffiinniittiioonn solvercategory.hh:54
│ │ │ │ │ +_D_u_n_e_:_:_b_i_l_d_l___d_e_c_o_m_p_o_s_e
│ │ │ │ │ +void bildl_decompose(Matrix &A)
│ │ │ │ │ +compute ILDL decomposition of a symmetric matrix A
│ │ │ │ │ +DDeeffiinniittiioonn ildl.hh:88
│ │ │ │ │ +_D_u_n_e_:_:_b_i_l_d_l___b_a_c_k_s_o_l_v_e
│ │ │ │ │ +void bildl_backsolve(const Matrix &A, X &v, const Y &d, bool
│ │ │ │ │ +isLowerTriangular=false)
│ │ │ │ │ +DDeeffiinniittiioonn ildl.hh:149
│ │ │ │ │ +_D_u_n_e_:_:_b_i_l_d_l___s_u_b_t_r_a_c_t_B_C_T
│ │ │ │ │ +static void bildl_subtractBCT(const FieldMatrix< K, m, n > &B, const
│ │ │ │ │ +FieldMatrix< K, m, n > &CT, FieldMatrix< K, m, n > &A)
│ │ │ │ │ +DDeeffiinniittiioonn ildl.hh:24
│ │ │ │ │ +_D_u_n_e_:_:_I_S_T_L_E_r_r_o_r
│ │ │ │ │ +derive error class from the base class in common
│ │ │ │ │ +DDeeffiinniittiioonn istlexception.hh:19
│ │ │ │ │ +_D_u_n_e_:_:_M_a_t_r_i_x_B_l_o_c_k_E_r_r_o_r
│ │ │ │ │ +Error when performing an operation on a matrix block.
│ │ │ │ │ +DDeeffiinniittiioonn istlexception.hh:52
│ │ │ │ │ +_D_u_n_e_:_:_M_a_t_r_i_x
│ │ │ │ │ +A generic dynamic dense matrix.
│ │ │ │ │ +DDeeffiinniittiioonn matrix.hh:561
│ │ │ │ │ +_D_u_n_e_:_:_M_a_t_r_i_x_:_:_b_e_f_o_r_e_B_e_g_i_n
│ │ │ │ │ +RowIterator beforeBegin()
│ │ │ │ │ +DDeeffiinniittiioonn matrix.hh:630
│ │ │ │ │ +_D_u_n_e_:_:_M_a_t_r_i_x_:_:_b_e_f_o_r_e_E_n_d
│ │ │ │ │ +RowIterator beforeEnd()
│ │ │ │ │ +DDeeffiinniittiioonn matrix.hh:623
│ │ │ │ │ +_D_u_n_e_:_:_M_a_t_r_i_x_:_:_e_n_d
│ │ │ │ │ +RowIterator end()
│ │ │ │ │ +Get iterator to one beyond last row.
│ │ │ │ │ +DDeeffiinniittiioonn matrix.hh:616
│ │ │ │ │ +_D_u_n_e_:_:_M_a_t_r_i_x_:_:_b_e_g_i_n
│ │ │ │ │ +RowIterator begin()
│ │ │ │ │ +Get iterator to first row.
│ │ │ │ │ +DDeeffiinniittiioonn matrix.hh:610
│ │ │ │ │ +_D_u_n_e_:_:_F_i_e_l_d_M_a_t_r_i_x
│ │ │ │ │ +DDeeffiinniittiioonn matrixutils.hh:27
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00014.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: spqr.hh File Reference
│ │ │ │ +dune-istl: scalarproducts.hh File Reference
│ │ │ │
│ │ │ │ -
#include <dune/common/fmatrix.hh>
│ │ │ │ -
#include <dune/common/fvector.hh>
│ │ │ │ -
#include <dune/common/typetraits.hh>
│ │ │ │ +
│ │ │ │ +
Define general preconditioner interface.
│ │ │ │ +More...
│ │ │ │ +
#include <cmath>
│ │ │ │ +
#include <complex>
│ │ │ │ +
#include <iostream>
│ │ │ │ +
#include <iomanip>
│ │ │ │ +
#include <memory>
│ │ │ │ +
#include <string>
│ │ │ │ +
#include <dune/common/simd/simd.hh>
│ │ │ │ +
#include <dune/common/parametertree.hh>
│ │ │ │ +
#include <dune/istl/solverregistry.hh >
│ │ │ │ +
#include "preconditioner.hh "
│ │ │ │ +
#include "solver.hh "
│ │ │ │ +
#include "solvercategory.hh "
│ │ │ │ +
#include "istlexception.hh "
│ │ │ │ +
#include "matrixutils.hh "
│ │ │ │ +
#include "gsetc.hh "
│ │ │ │ +
#include "dilu.hh "
│ │ │ │ +
#include "ildl.hh "
│ │ │ │ +
#include "ilu.hh "
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ +class Dune::InverseOperator2Preconditioner< O, c > Turns an InverseOperator into a Preconditioner . More... class Dune::SeqSSOR< M, X, Y, l > Sequential SSOR preconditioner. More... class Dune::SeqSOR< M, X, Y, l > Sequential SOR preconditioner. More... class Dune::SeqJac< M, X, Y, l > The sequential jacobian preconditioner. More... class Dune::SeqDILU< M, X, Y, l > Sequential DILU preconditioner. More... class Dune::SeqILU< M, X, Y, l > Sequential ILU preconditioner. More... class Dune::Richardson< X, Y > Richardson preconditioner. More... class Dune::SeqILDL< M, X, Y > sequential ILDL preconditioner More...
│ │ │ │ namespace Dune namespace Dune::ISTL
│ │ │ │ +template<class M , class X , class Y , int l = 1> using Dune::SeqGS = SeqSOR < M, X, Y, l > Sequential Gauss Seidel preconditioner.
│ │ │ │ + Dune::DUNE_REGISTER_PRECONDITIONER ("ssor", defaultPreconditionerBlockLevelCreator < Dune::SeqSSOR >()) Dune::DUNE_REGISTER_PRECONDITIONER ("sor", defaultPreconditionerBlockLevelCreator < Dune::SeqSOR >()) Dune::DUNE_REGISTER_PRECONDITIONER ("gs", defaultPreconditionerBlockLevelCreator < Dune::SeqGS >()) Dune::DUNE_REGISTER_PRECONDITIONER ("jac", defaultPreconditionerBlockLevelCreator < Dune::SeqJac >()) Dune::DUNE_REGISTER_PRECONDITIONER ("dilu", defaultPreconditionerBlockLevelCreator < Dune::SeqDILU >()) Dune::DUNE_REGISTER_PRECONDITIONER ("ilu", defaultPreconditionerBlockLevelCreator < Dune::SeqILU >()) Dune::DUNE_REGISTER_PRECONDITIONER ("richardson", [](auto tl, const auto &, const ParameterTree &config){ using D=typename Dune::TypeListElement< 1, decltype(tl)>::type;using R=typename Dune::TypeListElement< 2, decltype(tl)>::type;return std::make_shared< Richardson < D, R > >(config);}) Dune::DUNE_REGISTER_PRECONDITIONER ("ildl", defaultPreconditionerCreator < Dune::SeqILDL >())
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
Define general preconditioner interface.
│ │ │ │ +
Wrap the methods implemented by ISTL in this interface. However, the interface is extensible such that new preconditioners can be implemented and used with the solvers.
│ │ │ │ +
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ +preconditioners.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_) » _I_t_e_r_a_t_i_v_e_ _S_o_l_v_e_r_s » _P_r_e_c_o_n_d_i_t_i_o_n_e_r_s
│ │ │ │ │ +Define general preconditioner interface. _M_o_r_e_._._.
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_s_o_l_v_e_r_r_e_g_i_s_t_r_y_._h_h>
│ │ │ │ │ +#include "_p_r_e_c_o_n_d_i_t_i_o_n_e_r_._h_h"
│ │ │ │ │ +#include "_s_o_l_v_e_r_._h_h"
│ │ │ │ │ +#include "_s_o_l_v_e_r_c_a_t_e_g_o_r_y_._h_h"
│ │ │ │ │ +#include "_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h"
│ │ │ │ │ +#include "_m_a_t_r_i_x_u_t_i_l_s_._h_h"
│ │ │ │ │ +#include "_g_s_e_t_c_._h_h"
│ │ │ │ │ +#include "_d_i_l_u_._h_h"
│ │ │ │ │ +#include "_i_l_d_l_._h_h"
│ │ │ │ │ +#include "_i_l_u_._h_h"
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ +CCllaasssseess
│ │ │ │ │ +class _D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_<_ _O_,_ _c_ _>
│ │ │ │ │ + Turns an _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r into a _P_r_e_c_o_n_d_i_t_i_o_n_e_r. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_S_S_O_R_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + Sequential SSOR preconditioner. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_S_O_R_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + Sequential SOR preconditioner. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_J_a_c_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + The sequential jacobian preconditioner. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_D_I_L_U_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + Sequential _D_I_L_U preconditioner. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_I_L_U_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + Sequential _I_L_U preconditioner. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +class _D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_<_ _X_,_ _Y_ _>
│ │ │ │ │ + _R_i_c_h_a_r_d_s_o_n preconditioner. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_I_L_D_L_<_ _M_,_ _X_,_ _Y_ _>
│ │ │ │ │ + sequential ILDL preconditioner _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ -namespace _D_u_n_e_:_:_I_S_T_L
│ │ │ │ │ +TTyyppeeddeeffss
│ │ │ │ │ +template
│ │ │ │ │ +using _D_u_n_e_:_:_S_e_q_G_S = _S_e_q_S_O_R< M, X, Y, l >
│ │ │ │ │ + Sequential Gauss Seidel preconditioner.
│ │ │ │ │ +
│ │ │ │ │ +FFuunnccttiioonnss
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("ssor",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_S_S_O_R >())
│ │ │ │ │ +
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("sor",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_S_O_R >())
│ │ │ │ │ +
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("gs",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_G_S >())
│ │ │ │ │ +
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("jac",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_J_a_c >())
│ │ │ │ │ +
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("dilu",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_D_I_L_U >())
│ │ │ │ │ +
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("ilu",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_I_L_U >())
│ │ │ │ │ +
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("richardson", [](auto tl, const auto &,
│ │ │ │ │ + const ParameterTree &config){ using D=typename Dune::TypeListElement< 1,
│ │ │ │ │ + decltype(tl)>::type;using R=typename Dune::TypeListElement< 2, decltype
│ │ │ │ │ + (tl)>::type;return std::make_shared< _R_i_c_h_a_r_d_s_o_n< D, R > >(config);})
│ │ │ │ │ +
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("ildl", _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_C_r_e_a_t_o_r<
│ │ │ │ │ + _D_u_n_e_:_:_S_e_q_I_L_D_L >())
│ │ │ │ │
│ │ │ │ │ +********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ +Define general preconditioner interface.
│ │ │ │ │ +Wrap the methods implemented by ISTL in this interface. However, the interface
│ │ │ │ │ +is extensible such that new preconditioners can be implemented and used with
│ │ │ │ │ +the solvers.
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00017_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: bccsmatrix.hh Source File
│ │ │ │ +dune-istl: preconditioners.hh Source File
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_ISTL_BCCSMATRIX_HH
│ │ │ │ -
6 #define DUNE_ISTL_BCCSMATRIX_HH
│ │ │ │ +
5 #ifndef DUNE_ISTL_PRECONDITIONERS_HH
│ │ │ │ +
6 #define DUNE_ISTL_PRECONDITIONERS_HH
│ │ │ │
│ │ │ │ -
8 #include <dune/common/fmatrix.hh>
│ │ │ │ -
9 #include <dune/common/fvector.hh>
│ │ │ │ -
10 #include <dune/common/typetraits.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
12 namespace Dune::ISTL::Impl
│ │ │ │ -
│ │ │ │ -
27 template<class B, class I = typename std::allocator<B>::size_type>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
32 using size_type = std::size_t;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
37 : N_(0), M_(0), Nnz_(0), values(0), rowindex(0), colstart(0)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
48 void setSize(size_type rows, size_type columns)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
64 size_type nonzeroes()
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
95 Index* getRowIndex()
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
106 Index* getColStart()
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
112 BCCSMatrix& operator=(
const BCCSMatrix&
mat )
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
120 colstart=
new size_type[M_+1];
│ │ │ │ -
121 for (size_type i=0; i<=M_; ++i)
│ │ │ │ -
122 colstart[i]=
mat .colstart[i];
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
15 #include <dune/common/simd/simd.hh>
│ │ │ │ +
16 #include <dune/common/parametertree.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
73 template <
class O,
int c = -1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
75 public Preconditioner <typename O::domain_type, typename O::range_type>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
96 : inverse_operator_(inverse_operator)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
99 DUNE_THROW(InvalidStateException,
"User-supplied solver category does not match that of the given inverse operator" );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
109 inverse_operator_.apply(v, copy, res);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
126 values =
new B[Nnz_];
│ │ │ │ -
127 rowindex =
new size_type[Nnz_];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
129 for (size_type i=0; i<Nnz_; ++i)
│ │ │ │ -
130 values[i]=
mat .values[i];
│ │ │ │ -
│ │ │ │ -
132 for (size_type i=0; i<Nnz_; ++i)
│ │ │ │ -
133 rowindex[i]=
mat .rowindex[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
150 size_type N_, M_, Nnz_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
141 template <
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
165 : _A_(A), _n(n), _w(w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
184 :
SeqSSOR (A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
200 SeqSSOR (
const M& A,
const ParameterTree& configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
209 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
217 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
219 for (
int i=0; i<_n; i++) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
230 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
261 template <
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
285 : _A_(A), _n(n), _w(w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
304 :
SeqSOR (A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
320 SeqSOR (
const M& A,
const ParameterTree& configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
329 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
337 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
339 this->
template apply<true>(v,d);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
350 template <
bool forward>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
354 for (
int i=0; i<_n; i++) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
358 for (
int i=0; i<_n; i++) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
368 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
398 template <
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
412 template <
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
436 : _A_(A), _n(n), _w(w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
455 :
SeqJac (A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
471 SeqJac (
const M& A,
const ParameterTree& configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
480 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
488 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
490 for (
int i=0; i<_n; i++) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
500 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
562 template <
class M,
class X,
class Y,
int l = 1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
595 Dinv_.resize(_A_.N());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
613 :
SeqDILU (A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
629 SeqDILU (
const M &A,
const ParameterTree &config)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
639 virtual void pre ([[maybe_unused]] X &x, [[maybe_unused]] Y &b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
648 virtual void apply (X &v,
const Y &d)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
664 virtual void post ([[maybe_unused]] X &x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
696 template <
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
727 :
SeqILU ( A, 0, w, resort )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
746 :
SeqILU (A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
763 SeqILU (
const M& A,
const ParameterTree& config)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
766 config.
get (
"resort" , false))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
813 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
821 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
843 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
854 std::unique_ptr< matrix_type >
ILU_ ;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
859 std::vector< block_type, typename matrix_type::allocator_type >
inv_ ;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
877 template <
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
920 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
928 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
939 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
953 using D =
typename Dune::TypeListElement<1,
decltype (tl)>::type;
│ │ │ │ +
954 using R =
typename Dune::TypeListElement<2,
decltype (tl)>::type;
│ │ │ │ +
955 return std::make_shared<Richardson<D,R>>(config);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
969 template <
class M,
class X,
class Y >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1003 :
SeqILDL (A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1031 : decomposition_( A.N(), A.M(),
matrix_type ::random ),
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1035 for (
auto i = A.begin(), iend = A.end(); i != iend; ++i )
│ │ │ │ +
│ │ │ │ +
1037 const auto &A_i = *i;
│ │ │ │ +
1038 const auto ij = A_i.find( i.index() );
│ │ │ │ +
1039 if ( ij != A_i.end() )
│ │ │ │ +
1040 decomposition_.setrowsize( i.index(), ij.offset()+1 );
│ │ │ │ +
│ │ │ │ +
1042 DUNE_THROW(
ISTLError ,
"diagonal entry missing" );
│ │ │ │ +
│ │ │ │ +
1044 decomposition_.endrowsizes();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1047 for (
auto i = A.begin(), iend = A.end(); i != iend; ++i )
│ │ │ │ +
│ │ │ │ +
1049 const auto &A_i = *i;
│ │ │ │ +
1050 for (
auto ij = A_i.begin(); ij.index() < i.index() ; ++ij )
│ │ │ │ +
1051 decomposition_.addindex( i.index(), ij.index() );
│ │ │ │ +
1052 decomposition_.addindex( i.index(), i.index() );
│ │ │ │ +
│ │ │ │ +
1054 decomposition_.endindices();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1058 for (
auto row = decomposition_.begin(), rowend = decomposition_.end(); row != rowend; ++row, ++i )
│ │ │ │ +
│ │ │ │ +
1060 auto ij = i->begin();
│ │ │ │ +
1061 for (
auto col = row->begin(), colend = row->end();
col != colend; ++
col , ++ij )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1070 void pre ([[maybe_unused]] X &x, [[maybe_unused]] Y &b)
override
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1074 void apply ( X &v,
const Y &d )
override
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1081 void post ([[maybe_unused]] X &x)
override
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
Matrix & mat
Definition matrixmatrix.hh:347
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Incomplete LDL decomposition.
│ │ │ │ +
│ │ │ │ +
#define DUNE_REGISTER_PRECONDITIONER(name,...)
Definition solverregistry.hh:16
│ │ │ │ +
│ │ │ │ +
The incomplete LU factorization kernels.
│ │ │ │ +
Some handy generic functions for ISTL matrices.
│ │ │ │ +
Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a generic way.
│ │ │ │ +
│ │ │ │ +
The diagonal incomplete LU factorization kernels.
│ │ │ │ +
Define general, extensible interface for inverse operators.
│ │ │ │ +
│ │ │ │ +
Col col
Definition matrixmatrix.hh:351
│ │ │ │ +
void bsorb(const M &A, X &x, const Y &b, const K &w)
SSOR step.
Definition gsetc.hh:646
│ │ │ │ +
void dbjac(const M &A, X &x, const Y &b, const K &w)
Jacobi step.
Definition gsetc.hh:658
│ │ │ │ +
void bsorf(const M &A, X &x, const Y &b, const K &w)
SOR step.
Definition gsetc.hh:634
│ │ │ │ +
Definition allocator.hh:11
│ │ │ │ +
void bildl_decompose(Matrix &A)
compute ILDL decomposition of a symmetric matrix A
Definition ildl.hh:88
│ │ │ │ +
PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > >::Type get(const Amg::VertexVisitedTag &tag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > &graph)
Definition dependency.hh:293
│ │ │ │ +
void bildl_backsolve(const Matrix &A, X &v, const Y &d, bool isLowerTriangular=false)
Definition ildl.hh:149
│ │ │ │ +
void blockDILUDecomposition(M &A, std::vector< typename M::block_type > &Dinv_)
Definition dilu.hh:51
│ │ │ │ +
void blockDILUBacksolve(const M &A, const std::vector< typename M::block_type > Dinv_, X &v, const Y &d)
Definition dilu.hh:107
│ │ │ │ +
void convertToCRS(const M &A, CRS &lower, CRS &upper, InvVector &inv)
convert ILU decomposition into CRS format for lower and upper triangular and inverse.
Definition ilu.hh:307
│ │ │ │ +
void blockILUBacksolve(const M &A, X &v, const Y &d)
LU backsolve with stored inverse.
Definition ilu.hh:94
│ │ │ │ +
void blockILU0Decomposition(M &A)
compute ILU decomposition of A. A is overwritten by its decomposition
Definition ilu.hh:33
│ │ │ │ +
void blockILUDecomposition(const M &A, int n, M &ILU)
Definition ilu.hh:167
│ │ │ │ +
compile-time parameter for block recursion depth
Definition gsetc.hh:45
│ │ │ │ +
a simple compressed row storage matrix class
Definition ilu.hh:259
│ │ │ │ +
derive error class from the base class in common
Definition istlexception.hh:19
│ │ │ │ +
static void check(const Matrix &mat)
Check whether the a matrix has diagonal values on blocklevel recursion levels.
Definition matrixutils.hh:53
│ │ │ │ +
A linear operator exporting itself in matrix form.
Definition operators.hh:111
│ │ │ │ +
Base class for matrix free definition of preconditioners.
Definition preconditioner.hh:33
│ │ │ │ +
Turns an InverseOperator into a Preconditioner.
Definition preconditioners.hh:76
│ │ │ │ +
O::range_type range_type
The range type of the preconditioner.
Definition preconditioners.hh:81
│ │ │ │ +
O::domain_type domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:79
│ │ │ │ +
virtual void post(domain_type &)
Clean up.
Definition preconditioners.hh:112
│ │ │ │ +
range_type::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:83
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:87
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:85
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:116
│ │ │ │ +
virtual void pre(domain_type &, range_type &)
Prepare the preconditioner.
Definition preconditioners.hh:102
│ │ │ │ +
InverseOperator2Preconditioner(InverseOperator &inverse_operator)
Construct the preconditioner from the solver.
Definition preconditioners.hh:95
│ │ │ │ +
O InverseOperator
type of the wrapped inverse operator
Definition preconditioners.hh:89
│ │ │ │ +
virtual void apply(domain_type &v, const range_type &d)
Apply one step of the preconditioner to the system A(v)=d.
Definition preconditioners.hh:105
│ │ │ │ +
Sequential SSOR preconditioner.
Definition preconditioners.hh:142
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:230
│ │ │ │ +
SeqSSOR(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:183
│ │ │ │ +
SeqSSOR(const M &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:200
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:234
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:151
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:153
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:147
│ │ │ │ +
M matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:145
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:217
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:209
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:149
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:155
│ │ │ │ +
SeqSSOR(const M &A, int n, real_field_type w)
Constructor.
Definition preconditioners.hh:164
│ │ │ │ +
Sequential SOR preconditioner.
Definition preconditioners.hh:262
│ │ │ │ +
SeqSOR(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:303
│ │ │ │ +
M matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:265
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:275
│ │ │ │ +
void apply(X &v, const Y &d)
Apply the preconditioner in a special direction.
Definition preconditioners.hh:351
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:267
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:368
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:329
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:273
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:372
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:337
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:269
│ │ │ │ +
SeqSOR(const M &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:320
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:271
│ │ │ │ +
SeqSOR(const M &A, int n, real_field_type w)
Constructor.
Definition preconditioners.hh:284
│ │ │ │ +
The sequential jacobian preconditioner.
Definition preconditioners.hh:413
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:500
│ │ │ │ +
SeqJac(const M &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:471
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:488
│ │ │ │ +
M matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:416
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:424
│ │ │ │ +
SeqJac(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:454
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:422
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:480
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:418
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:426
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:504
│ │ │ │ +
SeqJac(const M &A, int n, real_field_type w)
Constructor.
Definition preconditioners.hh:435
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:420
│ │ │ │ +
Sequential DILU preconditioner.
Definition preconditioners.hh:564
│ │ │ │ +
const bool wNotIdentity_
true if w != 1.0
Definition preconditioners.hh:681
│ │ │ │ +
typename X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:576
│ │ │ │ +
const real_field_type _w
The relaxation factor to use.
Definition preconditioners.hh:679
│ │ │ │ +
const M & _A_
The matrix we operate on.
Definition preconditioners.hh:677
│ │ │ │ +
SeqDILU(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:612
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:579
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:664
│ │ │ │ +
typename FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:581
│ │ │ │ +
M matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:567
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:571
│ │ │ │ +
typename matrix_type::block_type block_type
block type of matrix
Definition preconditioners.hh:569
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:648
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:639
│ │ │ │ +
SeqDILU(const M &A, real_field_type w)
Constructor.
Definition preconditioners.hh:589
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:669
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:573
│ │ │ │ +
SeqDILU(const M &A, const ParameterTree &config)
Constructor.
Definition preconditioners.hh:629
│ │ │ │ +
std::vector< block_type > Dinv_
Definition preconditioners.hh:675
│ │ │ │ +
Sequential ILU preconditioner.
Definition preconditioners.hh:697
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:843
│ │ │ │ +
SeqILU(const M &A, int n, real_field_type w, const bool resort=false)
Constructor.
Definition preconditioners.hh:777
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:813
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:821
│ │ │ │ +
ILU::CRS< block_type, typename M::allocator_type > CRS
type of ILU storage
Definition preconditioners.hh:717
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:706
│ │ │ │ +
CRS lower_
The ILU(n) decomposition of the matrix. As storage a CRS structure is used.
Definition preconditioners.hh:857
│ │ │ │ +
const bool wNotIdentity_
true if w != 1.0
Definition preconditioners.hh:864
│ │ │ │ +
SeqILU(const M &A, const ParameterTree &config)
Constructor.
Definition preconditioners.hh:763
│ │ │ │ +
std::remove_const< M >::type matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:700
│ │ │ │ +
matrix_type::block_type block_type
block type of matrix
Definition preconditioners.hh:702
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:714
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:709
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:847
│ │ │ │ +
SeqILU(const M &A, real_field_type w, const bool resort=false)
Constructor.
Definition preconditioners.hh:726
│ │ │ │ +
const real_field_type w_
The relaxation factor to use.
Definition preconditioners.hh:862
│ │ │ │ +
SeqILU(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:745
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:704
│ │ │ │ +
std::vector< block_type, typename matrix_type::allocator_type > inv_
Definition preconditioners.hh:859
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:712
│ │ │ │ +
std::unique_ptr< matrix_type > ILU_
The ILU(n) decomposition of the matrix. As storage a BCRSMatrix is used.
Definition preconditioners.hh:854
│ │ │ │ +
CRS upper_
Definition preconditioners.hh:858
│ │ │ │ +
Richardson preconditioner.
Definition preconditioners.hh:878
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:885
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:943
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:883
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:920
│ │ │ │ +
Richardson(real_field_type w=1.0)
Constructor.
Definition preconditioners.hh:896
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:939
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:889
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:887
│ │ │ │ +
Richardson(const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:911
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:881
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the precondioner.
Definition preconditioners.hh:928
│ │ │ │ +
sequential ILDL preconditioner
Definition preconditioners.hh:972
│ │ │ │ +
SeqILDL(const matrix_type &A, const ParameterTree &config)
Constructor.
Definition preconditioners.hh:1018
│ │ │ │ +
SeqILDL(const matrix_type &A, real_field_type relax=real_field_type(1))
constructor
Definition preconditioners.hh:1030
│ │ │ │ +
X domain_type
domain type of the preconditioner
Definition preconditioners.hh:980
│ │ │ │ +
void post(X &x) override
Clean up.
Definition preconditioners.hh:1081
│ │ │ │ +
Y range_type
range type of the preconditioner
Definition preconditioners.hh:982
│ │ │ │ +
std::remove_const_t< M > matrix_type
type of matrix the preconditioner is for
Definition preconditioners.hh:978
│ │ │ │ +
void apply(X &v, const Y &d) override
Apply one step of the preconditioner to the system A(v)=d.
Definition preconditioners.hh:1074
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:988
│ │ │ │ +
SeqILDL(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:1002
│ │ │ │ +
void pre(X &x, Y &b) override
Prepare the preconditioner.
Definition preconditioners.hh:1070
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:986
│ │ │ │ +
X::field_type field_type
field type of the preconditioner
Definition preconditioners.hh:984
│ │ │ │ +
SolverCategory::Category category() const override
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:1085
│ │ │ │ +
Statistics about the application of an inverse operator.
Definition solver.hh:50
│ │ │ │ +
Abstract base class for all solvers.
Definition solver.hh:101
│ │ │ │ +
Category
Definition solvercategory.hh:23
│ │ │ │ +
@ sequential
Category for sequential solvers.
Definition solvercategory.hh:25
│ │ │ │ +
static Category category(const OP &op, decltype(op.category()) *=nullptr)
Helperfunction to extract the solver category either from an enum, or from the newly introduced virtu...
Definition solvercategory.hh:34
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,125 +1,1171 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -bccsmatrix.hh
│ │ │ │ │ +preconditioners.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 © 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_BCCSMATRIX_HH
│ │ │ │ │ -6#define DUNE_ISTL_BCCSMATRIX_HH
│ │ │ │ │ +5#ifndef DUNE_ISTL_PRECONDITIONERS_HH
│ │ │ │ │ +6#define DUNE_ISTL_PRECONDITIONERS_HH
│ │ │ │ │ 7
│ │ │ │ │ -8#include
│ │ │ │ │ -9#include
│ │ │ │ │ -10#include
│ │ │ │ │ -11
│ │ │ │ │ -_1_2namespace Dune::ISTL::Impl
│ │ │ │ │ -13{
│ │ │ │ │ -27 template::size_type>
│ │ │ │ │ -28 class BCCSMatrix
│ │ │ │ │ -29 {
│ │ │ │ │ -30 public:
│ │ │ │ │ -31 using Index = I;
│ │ │ │ │ -32 using size_type = std::size_t;
│ │ │ │ │ -33
│ │ │ │ │ -36 BCCSMatrix()
│ │ │ │ │ -37 : N_(0), M_(0), Nnz_(0), values(0), rowindex(0), colstart(0)
│ │ │ │ │ -38 {}
│ │ │ │ │ -39
│ │ │ │ │ -41 ~BCCSMatrix()
│ │ │ │ │ -42 {
│ │ │ │ │ -43 if(N_+M_+Nnz_!=0)
│ │ │ │ │ -44 free();
│ │ │ │ │ -45 }
│ │ │ │ │ -46
│ │ │ │ │ -48 void setSize(size_type rows, size_type columns)
│ │ │ │ │ -49 {
│ │ │ │ │ -50 N_ = rows;
│ │ │ │ │ -51 M_ = columns;
│ │ │ │ │ -52 }
│ │ │ │ │ -53
│ │ │ │ │ -58 size_type N() const
│ │ │ │ │ -59 {
│ │ │ │ │ -60 return N_;
│ │ │ │ │ -61 }
│ │ │ │ │ -62
│ │ │ │ │ -64 size_type nonzeroes() const
│ │ │ │ │ -65 {
│ │ │ │ │ -66 return Nnz_;
│ │ │ │ │ -67 }
│ │ │ │ │ -68
│ │ │ │ │ -73 size_type M() const
│ │ │ │ │ -74 {
│ │ │ │ │ -75 return M_;
│ │ │ │ │ -76 }
│ │ │ │ │ -77
│ │ │ │ │ -84 B* getValues() const
│ │ │ │ │ -85 {
│ │ │ │ │ -86 return values;
│ │ │ │ │ -87 }
│ │ │ │ │ -88
│ │ │ │ │ -95 Index* getRowIndex() const
│ │ │ │ │ -96 {
│ │ │ │ │ -97 return rowindex;
│ │ │ │ │ -98 }
│ │ │ │ │ -99
│ │ │ │ │ -106 Index* getColStart() const
│ │ │ │ │ -107 {
│ │ │ │ │ -108 return colstart;
│ │ │ │ │ -109 }
│ │ │ │ │ -110
│ │ │ │ │ -112 BCCSMatrix& operator=(const BCCSMatrix& _m_a_t)
│ │ │ │ │ -113 {
│ │ │ │ │ -114 if(N_+M_+Nnz_!=0)
│ │ │ │ │ -115 free();
│ │ │ │ │ -116 N_=_m_a_t.N_;
│ │ │ │ │ -117 M_=_m_a_t.M_;
│ │ │ │ │ -118 Nnz_= _m_a_t.Nnz_;
│ │ │ │ │ -119 if(M_>0) {
│ │ │ │ │ -120 colstart=new size_type[M_+1];
│ │ │ │ │ -121 for(size_type i=0; i<=M_; ++i)
│ │ │ │ │ -122 colstart[i]=_m_a_t.colstart[i];
│ │ │ │ │ -123 }
│ │ │ │ │ +8#include
│ │ │ │ │ +9#include
│ │ │ │ │ +10#include
│ │ │ │ │ +11#include
│ │ │ │ │ +12#include
│ │ │ │ │ +13#include
│ │ │ │ │ +14
│ │ │ │ │ +15#include
│ │ │ │ │ +16#include
│ │ │ │ │ +17
│ │ │ │ │ +18#include <_d_u_n_e_/_i_s_t_l_/_s_o_l_v_e_r_r_e_g_i_s_t_r_y_._h_h>
│ │ │ │ │ +19#include "_p_r_e_c_o_n_d_i_t_i_o_n_e_r_._h_h"
│ │ │ │ │ +20#include "_s_o_l_v_e_r_._h_h"
│ │ │ │ │ +21#include "_s_o_l_v_e_r_c_a_t_e_g_o_r_y_._h_h"
│ │ │ │ │ +22#include "_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h"
│ │ │ │ │ +23#include "_m_a_t_r_i_x_u_t_i_l_s_._h_h"
│ │ │ │ │ +24#include "_g_s_e_t_c_._h_h"
│ │ │ │ │ +25#include "_d_i_l_u_._h_h"
│ │ │ │ │ +26#include "_i_l_d_l_._h_h"
│ │ │ │ │ +27#include "_i_l_u_._h_h"
│ │ │ │ │ +28
│ │ │ │ │ +29
│ │ │ │ │ +30namespace _D_u_n_e {
│ │ │ │ │ +73 template
│ │ │ │ │ +_7_4 class _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r :
│ │ │ │ │ +75 public _P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +76 {
│ │ │ │ │ +77 public:
│ │ │ │ │ +_7_9 typedef typename O::domain_type _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_8_1 typedef typename O::range_type _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_8_3 typedef typename range_type::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_5 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_7 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_9 typedef O _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r;
│ │ │ │ │ +90
│ │ │ │ │ +_9_5 _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r(_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r& inverse_operator)
│ │ │ │ │ +96 : inverse_operator_(inverse_operator)
│ │ │ │ │ +97 {
│ │ │ │ │ +98 if(c != -1 && _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_c_a_t_e_g_o_r_y(inverse_operator_) != c)
│ │ │ │ │ +99 DUNE_THROW(InvalidStateException, "User-supplied solver category does not
│ │ │ │ │ +match that of the given inverse operator");
│ │ │ │ │ +100 }
│ │ │ │ │ +101
│ │ │ │ │ +_1_0_2 virtual void _p_r_e(_d_o_m_a_i_n___t_y_p_e&,_r_a_n_g_e___t_y_p_e&)
│ │ │ │ │ +103 {}
│ │ │ │ │ +104
│ │ │ │ │ +_1_0_5 virtual void _a_p_p_l_y(_d_o_m_a_i_n___t_y_p_e& v, const _r_a_n_g_e___t_y_p_e& d)
│ │ │ │ │ +106 {
│ │ │ │ │ +107 _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_R_e_s_u_l_t res;
│ │ │ │ │ +108 _r_a_n_g_e___t_y_p_e copy(d);
│ │ │ │ │ +109 inverse_operator_.apply(v, copy, res);
│ │ │ │ │ +110 }
│ │ │ │ │ +111
│ │ │ │ │ +_1_1_2 virtual void _p_o_s_t(_d_o_m_a_i_n___t_y_p_e&)
│ │ │ │ │ +113 {}
│ │ │ │ │ +114
│ │ │ │ │ +_1_1_6 virtual _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y() const
│ │ │ │ │ +117 {
│ │ │ │ │ +118 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_c_a_t_e_g_o_r_y(inverse_operator_);
│ │ │ │ │ +119 }
│ │ │ │ │ +120
│ │ │ │ │ +121 private:
│ │ │ │ │ +122 _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r& inverse_operator_;
│ │ │ │ │ +123 };
│ │ │ │ │ 124
│ │ │ │ │ -125 if(Nnz_>0) {
│ │ │ │ │ -126 values = new B[Nnz_];
│ │ │ │ │ -127 rowindex = new size_type[Nnz_];
│ │ │ │ │ +125 //=====================================================================
│ │ │ │ │ +126 // Implementation of this interface for sequential ISTL-preconditioners
│ │ │ │ │ +127 //=====================================================================
│ │ │ │ │ 128
│ │ │ │ │ -129 for(size_type i=0; i
│ │ │ │ │ +_1_4_2 class _S_e_q_S_S_O_R : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r {
│ │ │ │ │ +143 public:
│ │ │ │ │ +_1_4_5 typedef M _m_a_t_r_i_x___t_y_p_e;
│ │ │ │ │ +_1_4_7 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_1_4_9 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_1_5_1 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_1_5_3 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_1_5_5 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +156
│ │ │ │ │ +_1_6_4 _S_e_q_S_S_O_R (const M& A, int n, _r_e_a_l___f_i_e_l_d___t_y_p_e w)
│ │ │ │ │ +165 : _A_(A), _n(n), _w(w)
│ │ │ │ │ +166 {
│ │ │ │ │ +167 _C_h_e_c_k_I_f_D_i_a_g_o_n_a_l_P_r_e_s_e_n_t_<_M_,_l_>_:_:_c_h_e_c_k(_A_);
│ │ │ │ │ +168 }
│ │ │ │ │ +169
│ │ │ │ │ +_1_8_3 _S_e_q_S_S_O_R (const std::shared_ptr>& A,
│ │ │ │ │ +const ParameterTree& configuration)
│ │ │ │ │ +184 : _S_e_q_S_S_O_R(A->getmat(), configuration)
│ │ │ │ │ +185 {}
│ │ │ │ │ +186
│ │ │ │ │ +_2_0_0 _S_e_q_S_S_O_R (const M& A, const ParameterTree& configuration)
│ │ │ │ │ +201 : _S_e_q_S_S_O_R(A, configuration._g_e_t("iterations",1),
│ │ │ │ │ +configuration._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation",1.0))
│ │ │ │ │ +202 {}
│ │ │ │ │ +203
│ │ │ │ │ +_2_0_9 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +210 {}
│ │ │ │ │ +211
│ │ │ │ │ +_2_1_7 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +218 {
│ │ │ │ │ +219 for (int i=0; i<_n; i++) {
│ │ │ │ │ +220 _b_s_o_r_f(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ +221 _b_s_o_r_b(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ +222 }
│ │ │ │ │ +223 }
│ │ │ │ │ +224
│ │ │ │ │ +_2_3_0 virtual void _p_o_s_t ([[maybe_unused]] X& x)
│ │ │ │ │ +231 {}
│ │ │ │ │ +232
│ │ │ │ │ +_2_3_4 virtual _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y() const
│ │ │ │ │ +235 {
│ │ │ │ │ +236 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ +237 }
│ │ │ │ │ +238
│ │ │ │ │ +239 private:
│ │ │ │ │ +241 const M& _A_;
│ │ │ │ │ +243 int _n;
│ │ │ │ │ +245 _r_e_a_l___f_i_e_l_d___t_y_p_e _w;
│ │ │ │ │ +246 };
│ │ │ │ │ +_2_4_7 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("ssor",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +248
│ │ │ │ │ +249
│ │ │ │ │ +261 template
│ │ │ │ │ +_2_6_2 class _S_e_q_S_O_R : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r {
│ │ │ │ │ +263 public:
│ │ │ │ │ +_2_6_5 typedef M _m_a_t_r_i_x___t_y_p_e;
│ │ │ │ │ +_2_6_7 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_2_6_9 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_2_7_1 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_2_7_3 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_2_7_5 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +276
│ │ │ │ │ +_2_8_4 _S_e_q_S_O_R (const M& A, int n, _r_e_a_l___f_i_e_l_d___t_y_p_e w)
│ │ │ │ │ +285 : _A_(A), _n(n), _w(w)
│ │ │ │ │ +286 {
│ │ │ │ │ +287 _C_h_e_c_k_I_f_D_i_a_g_o_n_a_l_P_r_e_s_e_n_t_<_M_,_l_>_:_:_c_h_e_c_k(_A_);
│ │ │ │ │ +288 }
│ │ │ │ │ +289
│ │ │ │ │ +_3_0_3 _S_e_q_S_O_R (const std::shared_ptr>& A,
│ │ │ │ │ +const ParameterTree& configuration)
│ │ │ │ │ +304 : _S_e_q_S_O_R(A->getmat(), configuration)
│ │ │ │ │ +305 {}
│ │ │ │ │ +306
│ │ │ │ │ +_3_2_0 _S_e_q_S_O_R (const M& A, const ParameterTree& configuration)
│ │ │ │ │ +321 : _S_e_q_S_O_R(A, configuration._g_e_t("iterations",1),
│ │ │ │ │ +configuration._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation",1.0))
│ │ │ │ │ +322 {}
│ │ │ │ │ +323
│ │ │ │ │ +_3_2_9 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +330 {}
│ │ │ │ │ +331
│ │ │ │ │ +_3_3_7 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +338 {
│ │ │ │ │ +339 this->template apply(v,d);
│ │ │ │ │ +340 }
│ │ │ │ │ +341
│ │ │ │ │ +350 template
│ │ │ │ │ +_3_5_1 void _a_p_p_l_y(X& v, const Y& d)
│ │ │ │ │ +352 {
│ │ │ │ │ +353 if(forward)
│ │ │ │ │ +354 for (int i=0; i<_n; i++) {
│ │ │ │ │ +355 _b_s_o_r_f(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ +356 }
│ │ │ │ │ +357 else
│ │ │ │ │ +358 for (int i=0; i<_n; i++) {
│ │ │ │ │ +359 _b_s_o_r_b(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ +360 }
│ │ │ │ │ +361 }
│ │ │ │ │ +362
│ │ │ │ │ +_3_6_8 virtual void _p_o_s_t ([[maybe_unused]] X& x)
│ │ │ │ │ +369 {}
│ │ │ │ │ +370
│ │ │ │ │ +_3_7_2 virtual _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y() const
│ │ │ │ │ +373 {
│ │ │ │ │ +374 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ +375 }
│ │ │ │ │ +376
│ │ │ │ │ +377 private:
│ │ │ │ │ +379 const M& _A_;
│ │ │ │ │ +381 int _n;
│ │ │ │ │ +383 _r_e_a_l___f_i_e_l_d___t_y_p_e _w;
│ │ │ │ │ +384 };
│ │ │ │ │ +_3_8_5 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("sor",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +386
│ │ │ │ │ +387
│ │ │ │ │ +398 template
│ │ │ │ │ +_3_9_9 using _S_e_q_G_S = _S_e_q_S_O_R_<_M_,_X_,_Y_,_l_>;
│ │ │ │ │ +_4_0_0 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("gs",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +401
│ │ │ │ │ +412 template
│ │ │ │ │ +_4_1_3 class _S_e_q_J_a_c : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r_<_X_,_Y_> {
│ │ │ │ │ +414 public:
│ │ │ │ │ +_4_1_6 typedef M _m_a_t_r_i_x___t_y_p_e;
│ │ │ │ │ +_4_1_8 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_4_2_0 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_4_2_2 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_4_2_4 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_4_2_6 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +427
│ │ │ │ │ +_4_3_5 _S_e_q_J_a_c (const M& A, int n, _r_e_a_l___f_i_e_l_d___t_y_p_e w)
│ │ │ │ │ +436 : _A_(A), _n(n), _w(w)
│ │ │ │ │ +437 {
│ │ │ │ │ +438 _C_h_e_c_k_I_f_D_i_a_g_o_n_a_l_P_r_e_s_e_n_t_<_M_,_l_>_:_:_c_h_e_c_k(_A_);
│ │ │ │ │ +439 }
│ │ │ │ │ +440
│ │ │ │ │ +_4_5_4 _S_e_q_J_a_c (const std::shared_ptr>& A,
│ │ │ │ │ +const ParameterTree& configuration)
│ │ │ │ │ +455 : _S_e_q_J_a_c(A->getmat(), configuration)
│ │ │ │ │ +456 {}
│ │ │ │ │ +457
│ │ │ │ │ +_4_7_1 _S_e_q_J_a_c (const M& A, const ParameterTree& configuration)
│ │ │ │ │ +472 : _S_e_q_J_a_c(A, configuration._g_e_t("iterations",1),
│ │ │ │ │ +configuration._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation",1.0))
│ │ │ │ │ +473 {}
│ │ │ │ │ +474
│ │ │ │ │ +_4_8_0 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +481 {}
│ │ │ │ │ +482
│ │ │ │ │ +_4_8_8 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +489 {
│ │ │ │ │ +490 for (int i=0; i<_n; i++) {
│ │ │ │ │ +491 _d_b_j_a_c(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ +492 }
│ │ │ │ │ +493 }
│ │ │ │ │ +494
│ │ │ │ │ +_5_0_0 virtual void _p_o_s_t ([[maybe_unused]] X& x)
│ │ │ │ │ +501 {}
│ │ │ │ │ +502
│ │ │ │ │ +_5_0_4 virtual _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y() const
│ │ │ │ │ +505 {
│ │ │ │ │ +506 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ +507 }
│ │ │ │ │ +508
│ │ │ │ │ +509 private:
│ │ │ │ │ +511 const M& _A_;
│ │ │ │ │ +513 int _n;
│ │ │ │ │ +515 real_field_type _w;
│ │ │ │ │ +516 };
│ │ │ │ │ +_5_1_7 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("jac",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +518
│ │ │ │ │ +562 template
│ │ │ │ │ +_5_6_3 class _S_e_q_D_I_L_U : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r_<_X_,_ _Y_>
│ │ │ │ │ +564 {
│ │ │ │ │ +565 public:
│ │ │ │ │ +_5_6_7 using _m_a_t_r_i_x___t_y_p_e = M;
│ │ │ │ │ +_5_6_9 using _b_l_o_c_k___t_y_p_e = typename matrix_type::block_type;
│ │ │ │ │ +_5_7_1 using _d_o_m_a_i_n___t_y_p_e = X;
│ │ │ │ │ +_5_7_3 using _r_a_n_g_e___t_y_p_e = Y;
│ │ │ │ │ +574
│ │ │ │ │ +_5_7_6 using _f_i_e_l_d___t_y_p_e = typename X::field_type;
│ │ │ │ │ +577
│ │ │ │ │ +_5_7_9 using _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e = Simd::Scalar;
│ │ │ │ │ +_5_8_1 using _r_e_a_l___f_i_e_l_d___t_y_p_e = typename FieldTraits::real_type;
│ │ │ │ │ +582
│ │ │ │ │ +_5_8_9 _S_e_q_D_I_L_U(const M &A, _r_e_a_l___f_i_e_l_d___t_y_p_e w)
│ │ │ │ │ +590 : _A_(A),
│ │ │ │ │ +591 _w(w),
│ │ │ │ │ +592 wNotIdentity_([w]
│ │ │ │ │ +593 {using std::abs; return abs(w - _r_e_a_l___f_i_e_l_d___t_y_p_e(1)) > 1e-15; }())
│ │ │ │ │ +594 {
│ │ │ │ │ +595 Dinv_.resize(_A_.N());
│ │ │ │ │ +596 _C_h_e_c_k_I_f_D_i_a_g_o_n_a_l_P_r_e_s_e_n_t_<_M_,_ _l_>_:_:_c_h_e_c_k(_A_);
│ │ │ │ │ +597 _D_I_L_U_:_:_b_l_o_c_k_D_I_L_U_D_e_c_o_m_p_o_s_i_t_i_o_n(_A_, Dinv_);
│ │ │ │ │ +598 }
│ │ │ │ │ +599
│ │ │ │ │ +_6_1_2 _S_e_q_D_I_L_U(const std::shared_ptr> &A,
│ │ │ │ │ +const ParameterTree &configuration)
│ │ │ │ │ +613 : _S_e_q_D_I_L_U(A->getmat(), configuration)
│ │ │ │ │ +614 {
│ │ │ │ │ +615 }
│ │ │ │ │ +616
│ │ │ │ │ +_6_2_9 _S_e_q_D_I_L_U(const M &A, const ParameterTree &config)
│ │ │ │ │ +630 : _S_e_q_D_I_L_U(A, config._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation", 1.0))
│ │ │ │ │ +631 {
│ │ │ │ │ +632 }
│ │ │ │ │ +633
│ │ │ │ │ +_6_3_9 virtual void _p_r_e([[maybe_unused]] X &x, [[maybe_unused]] Y &b)
│ │ │ │ │ +640 {
│ │ │ │ │ +641 }
│ │ │ │ │ +642
│ │ │ │ │ +_6_4_8 virtual void _a_p_p_l_y(X &v, const Y &d)
│ │ │ │ │ +649 {
│ │ │ │ │ +650
│ │ │ │ │ +651 _D_I_L_U_:_:_b_l_o_c_k_D_I_L_U_B_a_c_k_s_o_l_v_e(_A_, Dinv_, v, d);
│ │ │ │ │ +652
│ │ │ │ │ +653 if (wNotIdentity_)
│ │ │ │ │ +654 {
│ │ │ │ │ +655 v *= _w;
│ │ │ │ │ +656 }
│ │ │ │ │ +657 }
│ │ │ │ │ +658
│ │ │ │ │ +_6_6_4 virtual void _p_o_s_t([[maybe_unused]] X &x)
│ │ │ │ │ +665 {
│ │ │ │ │ +666 }
│ │ │ │ │ +667
│ │ │ │ │ +_6_6_9 virtual _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y() const
│ │ │ │ │ +670 {
│ │ │ │ │ +671 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ +672 }
│ │ │ │ │ +673
│ │ │ │ │ +674 protected:
│ │ │ │ │ +_6_7_5 std::vector _D_i_n_v__;
│ │ │ │ │ +_6_7_7 const M &___A__;
│ │ │ │ │ +_6_7_9 const _r_e_a_l___f_i_e_l_d___t_y_p_e ___w;
│ │ │ │ │ +_6_8_1 const bool _w_N_o_t_I_d_e_n_t_i_t_y__;
│ │ │ │ │ +682 };
│ │ │ │ │ +_6_8_3 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("dilu",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +684
│ │ │ │ │ +696 template
│ │ │ │ │ +_6_9_7 class _S_e_q_I_L_U : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r {
│ │ │ │ │ +698 public:
│ │ │ │ │ +_7_0_0 typedef typename std::remove_const::type _m_a_t_r_i_x___t_y_p_e;
│ │ │ │ │ +_7_0_2 typedef typename matrix_type :: block_type _b_l_o_c_k___t_y_p_e;
│ │ │ │ │ +_7_0_4 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_7_0_6 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +707
│ │ │ │ │ +_7_0_9 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +710
│ │ │ │ │ +_7_1_2 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_7_1_4 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +715
│ │ │ │ │ +_7_1_7 typedef typename _I_L_U_:_:_C_R_S_<_ _b_l_o_c_k___t_y_p_e_ _,_ _t_y_p_e_n_a_m_e_ _M_:_:_a_l_l_o_c_a_t_o_r___t_y_p_e_> _C_R_S;
│ │ │ │ │ +718
│ │ │ │ │ +_7_2_6 _S_e_q_I_L_U (const M& A, _r_e_a_l___f_i_e_l_d___t_y_p_e w, const bool resort = false )
│ │ │ │ │ +727 : _S_e_q_I_L_U( A, 0, w, resort ) // construct ILU(0)
│ │ │ │ │ +728 {
│ │ │ │ │ +729 }
│ │ │ │ │ +730
│ │ │ │ │ +_7_4_5 _S_e_q_I_L_U (const std::shared_ptr>& A,
│ │ │ │ │ +const ParameterTree& configuration)
│ │ │ │ │ +746 : _S_e_q_I_L_U(A->getmat(), configuration)
│ │ │ │ │ +747 {}
│ │ │ │ │ +748
│ │ │ │ │ +_7_6_3 _S_e_q_I_L_U(const M& A, const ParameterTree& config)
│ │ │ │ │ +764 : _S_e_q_I_L_U(A, config._g_e_t("n", 0),
│ │ │ │ │ +765 config._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation", 1.0),
│ │ │ │ │ +766 config._g_e_t("resort", false))
│ │ │ │ │ +767 {}
│ │ │ │ │ +768
│ │ │ │ │ +_7_7_7 _S_e_q_I_L_U (const M& A, int n, _r_e_a_l___f_i_e_l_d___t_y_p_e w, const bool resort = false )
│ │ │ │ │ +778 : _I_L_U__(),
│ │ │ │ │ +779 _l_o_w_e_r__(),
│ │ │ │ │ +780 _u_p_p_e_r__(),
│ │ │ │ │ +781 _i_n_v__(),
│ │ │ │ │ +782 _w__(w),
│ │ │ │ │ +783 _w_N_o_t_I_d_e_n_t_i_t_y__([w]{using std::abs; return abs(w - _r_e_a_l___f_i_e_l_d___t_y_p_e(1)) > 1e-
│ │ │ │ │ +15;}() )
│ │ │ │ │ +784 {
│ │ │ │ │ +785 if( n == 0 )
│ │ │ │ │ +786 {
│ │ │ │ │ +787 // copy A
│ │ │ │ │ +788 _I_L_U__.reset( new _m_a_t_r_i_x___t_y_p_e( A ) );
│ │ │ │ │ +789 // create ILU(0) decomposition
│ │ │ │ │ +790 _I_L_U_:_:_b_l_o_c_k_I_L_U_0_D_e_c_o_m_p_o_s_i_t_i_o_n( *_I_L_U__ );
│ │ │ │ │ +791 }
│ │ │ │ │ +792 else
│ │ │ │ │ +793 {
│ │ │ │ │ +794 // create matrix in build mode
│ │ │ │ │ +795 _I_L_U__.reset( new _m_a_t_r_i_x___t_y_p_e( A.N(), A.M(), matrix_type::row_wise) );
│ │ │ │ │ +796 // create ILU(n) decomposition
│ │ │ │ │ +797 _I_L_U_:_:_b_l_o_c_k_I_L_U_D_e_c_o_m_p_o_s_i_t_i_o_n( A, n, *_I_L_U__ );
│ │ │ │ │ +798 }
│ │ │ │ │ +799
│ │ │ │ │ +800 if( resort )
│ │ │ │ │ +801 {
│ │ │ │ │ +802 // store ILU in simple CRS format
│ │ │ │ │ +803 _I_L_U_:_:_c_o_n_v_e_r_t_T_o_C_R_S( *_I_L_U__, _l_o_w_e_r__, _u_p_p_e_r__, _i_n_v__ );
│ │ │ │ │ +804 _I_L_U__.reset();
│ │ │ │ │ +805 }
│ │ │ │ │ +806 }
│ │ │ │ │ +807
│ │ │ │ │ +_8_1_3 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +814 {}
│ │ │ │ │ +815
│ │ │ │ │ +_8_2_1 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +822 {
│ │ │ │ │ +823 if( _I_L_U__ )
│ │ │ │ │ +824 {
│ │ │ │ │ +825 _I_L_U_:_:_b_l_o_c_k_I_L_U_B_a_c_k_s_o_l_v_e( *_I_L_U__, v, d);
│ │ │ │ │ +826 }
│ │ │ │ │ +827 else
│ │ │ │ │ +828 {
│ │ │ │ │ +829 _I_L_U_:_:_b_l_o_c_k_I_L_U_B_a_c_k_s_o_l_v_e(_l_o_w_e_r__, _u_p_p_e_r__, _i_n_v__, v, d);
│ │ │ │ │ +830 }
│ │ │ │ │ +831
│ │ │ │ │ +832 if( _w_N_o_t_I_d_e_n_t_i_t_y__ )
│ │ │ │ │ +833 {
│ │ │ │ │ +834 v *= _w__;
│ │ │ │ │ +835 }
│ │ │ │ │ +836 }
│ │ │ │ │ +837
│ │ │ │ │ +_8_4_3 virtual void _p_o_s_t ([[maybe_unused]] X& x)
│ │ │ │ │ +844 {}
│ │ │ │ │ +845
│ │ │ │ │ +_8_4_7 virtual _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y() const
│ │ │ │ │ +848 {
│ │ │ │ │ +849 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ +850 }
│ │ │ │ │ +851
│ │ │ │ │ +852 protected:
│ │ │ │ │ +_8_5_4 std::unique_ptr< matrix_type > _I_L_U__;
│ │ │ │ │ +855
│ │ │ │ │ +_8_5_7 _C_R_S _l_o_w_e_r__;
│ │ │ │ │ +_8_5_8 _C_R_S _u_p_p_e_r__;
│ │ │ │ │ +_8_5_9 std::vector< block_type, typename matrix_type::allocator_type > _i_n_v__;
│ │ │ │ │ +860
│ │ │ │ │ +_8_6_2 const _r_e_a_l___f_i_e_l_d___t_y_p_e _w__;
│ │ │ │ │ +_8_6_4 const bool _w_N_o_t_I_d_e_n_t_i_t_y__;
│ │ │ │ │ +865 };
│ │ │ │ │ +_8_6_6 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("ilu",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +867
│ │ │ │ │ +868
│ │ │ │ │ +877 template
│ │ │ │ │ +_8_7_8 class _R_i_c_h_a_r_d_s_o_n : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r {
│ │ │ │ │ +879 public:
│ │ │ │ │ +_8_8_1 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_8_8_3 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_8_8_5 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_8_7 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_8_9 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +890
│ │ │ │ │ +_8_9_6 _R_i_c_h_a_r_d_s_o_n (_r_e_a_l___f_i_e_l_d___t_y_p_e w=1.0) :
│ │ │ │ │ +897 _w(w)
│ │ │ │ │ +898 {}
│ │ │ │ │ +899
│ │ │ │ │ +_9_1_1 _R_i_c_h_a_r_d_s_o_n (const ParameterTree& configuration)
│ │ │ │ │ +912 : _R_i_c_h_a_r_d_s_o_n(configuration._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation", 1.0))
│ │ │ │ │ +913 {}
│ │ │ │ │ +914
│ │ │ │ │ +_9_2_0 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +921 {}
│ │ │ │ │ +922
│ │ │ │ │ +_9_2_8 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +929 {
│ │ │ │ │ +930 v = d;
│ │ │ │ │ +931 v *= _w;
│ │ │ │ │ +932 }
│ │ │ │ │ +933
│ │ │ │ │ +_9_3_9 virtual void _p_o_s_t ([[maybe_unused]] X& x)
│ │ │ │ │ +940 {}
│ │ │ │ │ +941
│ │ │ │ │ +_9_4_3 virtual _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y() const
│ │ │ │ │ +944 {
│ │ │ │ │ +945 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ +946 }
│ │ │ │ │ +947
│ │ │ │ │ +948 private:
│ │ │ │ │ +950 _r_e_a_l___f_i_e_l_d___t_y_p_e _w;
│ │ │ │ │ +951 };
│ │ │ │ │ +_9_5_2 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("richardson", [](auto tl, const auto& /* mat
│ │ │ │ │ +*/, const ParameterTree& config){
│ │ │ │ │ +953 using D = typename Dune::TypeListElement<1, decltype(tl)>::type;
│ │ │ │ │ +954 using R = typename Dune::TypeListElement<2, decltype(tl)>::type;
│ │ │ │ │ +955 return std::make_shared>(config);
│ │ │ │ │ +956 });
│ │ │ │ │ +957
│ │ │ │ │ +958
│ │ │ │ │ +969 template< class M, class X, class Y >
│ │ │ │ │ +_9_7_0 class _S_e_q_I_L_D_L
│ │ │ │ │ +971 : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r< X, Y >
│ │ │ │ │ +972 {
│ │ │ │ │ +973 typedef _S_e_q_I_L_D_L_<_ _M_,_ _X_,_ _Y_ _> _T_h_i_s;
│ │ │ │ │ +974 typedef _P_r_e_c_o_n_d_i_t_i_o_n_e_r_<_ _X_,_ _Y_ _> _B_a_s_e;
│ │ │ │ │ +975
│ │ │ │ │ +976 public:
│ │ │ │ │ +_9_7_8 typedef std::remove_const_t< M > _m_a_t_r_i_x___t_y_p_e;
│ │ │ │ │ +_9_8_0 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_9_8_2 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_9_8_4 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_9_8_6 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_9_8_8 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +989
│ │ │ │ │ +_1_0_0_2 _S_e_q_I_L_D_L (const std::shared_ptr>& A,
│ │ │ │ │ +const ParameterTree& configuration)
│ │ │ │ │ +1003 : _S_e_q_I_L_D_L(A->getmat(), configuration)
│ │ │ │ │ +1004 {}
│ │ │ │ │ +1005
│ │ │ │ │ +_1_0_1_8 _S_e_q_I_L_D_L(const _m_a_t_r_i_x___t_y_p_e& A, const ParameterTree& config)
│ │ │ │ │ +1019 : _S_e_q_I_L_D_L(A, config._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation", 1.0))
│ │ │ │ │ +1020 {}
│ │ │ │ │ +1021
│ │ │ │ │ +_1_0_3_0 explicit _S_e_q_I_L_D_L ( const _m_a_t_r_i_x___t_y_p_e &A, _r_e_a_l___f_i_e_l_d___t_y_p_e relax =
│ │ │ │ │ +_r_e_a_l___f_i_e_l_d___t_y_p_e( 1 ) )
│ │ │ │ │ +1031 : decomposition_( A.N(), A.M(), _m_a_t_r_i_x___t_y_p_e::random ),
│ │ │ │ │ +1032 relax_( relax )
│ │ │ │ │ +1033 {
│ │ │ │ │ +1034 // setup row sizes for lower triangular matrix
│ │ │ │ │ +1035 for( auto i = A.begin(), iend = A.end(); i != iend; ++i )
│ │ │ │ │ +1036 {
│ │ │ │ │ +1037 const auto &A_i = *i;
│ │ │ │ │ +1038 const auto ij = A_i.find( i.index() );
│ │ │ │ │ +1039 if( ij != A_i.end() )
│ │ │ │ │ +1040 decomposition_.setrowsize( i.index(), ij.offset()+1 );
│ │ │ │ │ +1041 else
│ │ │ │ │ +1042 DUNE_THROW( _I_S_T_L_E_r_r_o_r, "diagonal entry missing" );
│ │ │ │ │ +1043 }
│ │ │ │ │ +1044 decomposition_.endrowsizes();
│ │ │ │ │ +1045
│ │ │ │ │ +1046 // setup row indices for lower triangular matrix
│ │ │ │ │ +1047 for( auto i = A.begin(), iend = A.end(); i != iend; ++i )
│ │ │ │ │ +1048 {
│ │ │ │ │ +1049 const auto &A_i = *i;
│ │ │ │ │ +1050 for( auto ij = A_i.begin(); ij.index() < i.index() ; ++ij )
│ │ │ │ │ +1051 decomposition_.addindex( i.index(), ij.index() );
│ │ │ │ │ +1052 decomposition_.addindex( i.index(), i.index() );
│ │ │ │ │ +1053 }
│ │ │ │ │ +1054 decomposition_.endindices();
│ │ │ │ │ +1055
│ │ │ │ │ +1056 // copy values of lower triangular matrix
│ │ │ │ │ +1057 auto i = A.begin();
│ │ │ │ │ +1058 for( auto row = decomposition_.begin(), rowend = decomposition_.end(); row
│ │ │ │ │ +!= rowend; ++row, ++i )
│ │ │ │ │ +1059 {
│ │ │ │ │ +1060 auto ij = i->begin();
│ │ │ │ │ +1061 for( auto _c_o_l = row->begin(), colend = row->end(); _c_o_l != colend; ++_c_o_l,
│ │ │ │ │ +++ij )
│ │ │ │ │ +1062 *_c_o_l = *ij;
│ │ │ │ │ +1063 }
│ │ │ │ │ +1064
│ │ │ │ │ +1065 // perform ILDL decomposition
│ │ │ │ │ +1066 _b_i_l_d_l___d_e_c_o_m_p_o_s_e( decomposition_ );
│ │ │ │ │ +1067 }
│ │ │ │ │ +1068
│ │ │ │ │ +_1_0_7_0 void _p_r_e ([[maybe_unused]] X &x, [[maybe_unused]] Y &b) override
│ │ │ │ │ +1071 {}
│ │ │ │ │ +1072
│ │ │ │ │ +_1_0_7_4 void _a_p_p_l_y ( X &v, const Y &d ) override
│ │ │ │ │ +1075 {
│ │ │ │ │ +1076 _b_i_l_d_l___b_a_c_k_s_o_l_v_e( decomposition_, v, d, true );
│ │ │ │ │ +1077 v *= relax_;
│ │ │ │ │ +1078 }
│ │ │ │ │ +1079
│ │ │ │ │ +_1_0_8_1 void _p_o_s_t ([[maybe_unused]] X &x) override
│ │ │ │ │ +1082 {}
│ │ │ │ │ +1083
│ │ │ │ │ +_1_0_8_5 _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y () const override { return
│ │ │ │ │ +_S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l; }
│ │ │ │ │ +1086
│ │ │ │ │ +1087 private:
│ │ │ │ │ +1088 _m_a_t_r_i_x___t_y_p_e decomposition_;
│ │ │ │ │ +1089 _r_e_a_l___f_i_e_l_d___t_y_p_e relax_;
│ │ │ │ │ +1090 };
│ │ │ │ │ +_1_0_9_1 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("ildl", defaultPreconditionerCreator());
│ │ │ │ │ +1092
│ │ │ │ │ +1095} // end namespace
│ │ │ │ │ +1096
│ │ │ │ │ +1097
│ │ │ │ │ +1098#endif
│ │ │ │ │ +_i_l_d_l_._h_h
│ │ │ │ │ +Incomplete LDL decomposition.
│ │ │ │ │ +_s_o_l_v_e_r_r_e_g_i_s_t_r_y_._h_h
│ │ │ │ │ +_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R
│ │ │ │ │ +#define DUNE_REGISTER_PRECONDITIONER(name,...)
│ │ │ │ │ +DDeeffiinniittiioonn solverregistry.hh:16
│ │ │ │ │ +_p_r_e_c_o_n_d_i_t_i_o_n_e_r_._h_h
│ │ │ │ │ +_i_l_u_._h_h
│ │ │ │ │ +The incomplete LU factorization kernels.
│ │ │ │ │ +_m_a_t_r_i_x_u_t_i_l_s_._h_h
│ │ │ │ │ +Some handy generic functions for ISTL matrices.
│ │ │ │ │ +_g_s_e_t_c_._h_h
│ │ │ │ │ +Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a
│ │ │ │ │ +generic way.
│ │ │ │ │ +_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h
│ │ │ │ │ +_d_i_l_u_._h_h
│ │ │ │ │ +The diagonal incomplete LU factorization kernels.
│ │ │ │ │ +_s_o_l_v_e_r_._h_h
│ │ │ │ │ +Define general, extensible interface for inverse operators.
│ │ │ │ │ +_s_o_l_v_e_r_c_a_t_e_g_o_r_y_._h_h
│ │ │ │ │ +_c_o_l
│ │ │ │ │ +Col col
│ │ │ │ │ +DDeeffiinniittiioonn matrixmatrix.hh:351
│ │ │ │ │ +_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_:_:_d_b_j_a_c
│ │ │ │ │ +void dbjac(const M &A, X &x, const Y &b, const K &w)
│ │ │ │ │ +Jacobi step.
│ │ │ │ │ +DDeeffiinniittiioonn gsetc.hh:658
│ │ │ │ │ +_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_:_:_b_i_l_d_l___d_e_c_o_m_p_o_s_e
│ │ │ │ │ +void bildl_decompose(Matrix &A)
│ │ │ │ │ +compute ILDL decomposition of a symmetric matrix A
│ │ │ │ │ +DDeeffiinniittiioonn ildl.hh:88
│ │ │ │ │ +_D_u_n_e_:_:_g_e_t
│ │ │ │ │ +PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::
│ │ │ │ │ +VertexProperties, EP, VM, EM > >::Type get(const Amg::VertexVisitedTag &tag,
│ │ │ │ │ +Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > &graph)
│ │ │ │ │ +DDeeffiinniittiioonn dependency.hh:293
│ │ │ │ │ +_D_u_n_e_:_:_b_i_l_d_l___b_a_c_k_s_o_l_v_e
│ │ │ │ │ +void bildl_backsolve(const Matrix &A, X &v, const Y &d, bool
│ │ │ │ │ +isLowerTriangular=false)
│ │ │ │ │ +DDeeffiinniittiioonn ildl.hh:149
│ │ │ │ │ +_D_u_n_e_:_:_D_I_L_U_:_:_b_l_o_c_k_D_I_L_U_D_e_c_o_m_p_o_s_i_t_i_o_n
│ │ │ │ │ +void blockDILUDecomposition(M &A, std::vector< typename M::block_type > &Dinv_)
│ │ │ │ │ +DDeeffiinniittiioonn dilu.hh:51
│ │ │ │ │ +_D_u_n_e_:_:_D_I_L_U_:_:_b_l_o_c_k_D_I_L_U_B_a_c_k_s_o_l_v_e
│ │ │ │ │ +void blockDILUBacksolve(const M &A, const std::vector< typename M::block_type >
│ │ │ │ │ +Dinv_, X &v, const Y &d)
│ │ │ │ │ +DDeeffiinniittiioonn dilu.hh:107
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_:_:_c_o_n_v_e_r_t_T_o_C_R_S
│ │ │ │ │ +void convertToCRS(const M &A, CRS &lower, CRS &upper, InvVector &inv)
│ │ │ │ │ +convert ILU decomposition into CRS format for lower and upper triangular and
│ │ │ │ │ +inverse.
│ │ │ │ │ +DDeeffiinniittiioonn ilu.hh:307
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_:_:_b_l_o_c_k_I_L_U_B_a_c_k_s_o_l_v_e
│ │ │ │ │ +void blockILUBacksolve(const M &A, X &v, const Y &d)
│ │ │ │ │ +LU backsolve with stored inverse.
│ │ │ │ │ +DDeeffiinniittiioonn ilu.hh:94
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_:_:_b_l_o_c_k_I_L_U_0_D_e_c_o_m_p_o_s_i_t_i_o_n
│ │ │ │ │ +void blockILU0Decomposition(M &A)
│ │ │ │ │ +compute ILU decomposition of A. A is overwritten by its decomposition
│ │ │ │ │ +DDeeffiinniittiioonn ilu.hh:33
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_:_:_b_l_o_c_k_I_L_U_D_e_c_o_m_p_o_s_i_t_i_o_n
│ │ │ │ │ +void blockILUDecomposition(const M &A, int n, M &ILU)
│ │ │ │ │ +DDeeffiinniittiioonn ilu.hh:167
│ │ │ │ │ +_D_u_n_e_:_:_B_L
│ │ │ │ │ +compile-time parameter for block recursion depth
│ │ │ │ │ +DDeeffiinniittiioonn gsetc.hh:45
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_:_:_C_R_S
│ │ │ │ │ +a simple compressed row storage matrix class
│ │ │ │ │ +DDeeffiinniittiioonn ilu.hh:259
│ │ │ │ │ +_D_u_n_e_:_:_I_S_T_L_E_r_r_o_r
│ │ │ │ │ +derive error class from the base class in common
│ │ │ │ │ +DDeeffiinniittiioonn istlexception.hh:19
│ │ │ │ │ +_D_u_n_e_:_:_C_h_e_c_k_I_f_D_i_a_g_o_n_a_l_P_r_e_s_e_n_t_:_:_c_h_e_c_k
│ │ │ │ │ +static void check(const Matrix &mat)
│ │ │ │ │ +Check whether the a matrix has diagonal values on blocklevel recursion levels.
│ │ │ │ │ +DDeeffiinniittiioonn matrixutils.hh:53
│ │ │ │ │ +_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:111
│ │ │ │ │ +_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:33
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +Turns an InverseOperator into a Preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:76
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +O::range_type range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:81
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +O::domain_type domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:79
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(domain_type &)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:112
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +range_type::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:83
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_r_e_a_l___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +FieldTraits< scalar_field_type >::real_type real_field_type
│ │ │ │ │ +real scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:87
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_s_c_a_l_a_r___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +Simd::Scalar< field_type > scalar_field_type
│ │ │ │ │ +scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:85
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_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 preconditioners.hh:116
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_p_r_e
│ │ │ │ │ +virtual void pre(domain_type &, range_type &)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:102
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +InverseOperator2Preconditioner(InverseOperator &inverse_operator)
│ │ │ │ │ +Construct the preconditioner from the solver.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:95
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r
│ │ │ │ │ +O InverseOperator
│ │ │ │ │ +type of the wrapped inverse operator
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:89
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(domain_type &v, const range_type &d)
│ │ │ │ │ +Apply one step of the preconditioner to the system A(v)=d.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:105
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R
│ │ │ │ │ +Sequential SSOR preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:142
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:230
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_S_e_q_S_S_O_R
│ │ │ │ │ +SeqSSOR(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A,
│ │ │ │ │ +const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:183
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_S_e_q_S_S_O_R
│ │ │ │ │ +SeqSSOR(const M &A, const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:200
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_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 preconditioners.hh:234
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_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 preconditioners.hh:151
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_s_c_a_l_a_r___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +Simd::Scalar< field_type > scalar_field_type
│ │ │ │ │ +scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:153
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:147
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_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 preconditioners.hh:145
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:217
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:209
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:149
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_r_e_a_l___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +FieldTraits< scalar_field_type >::real_type real_field_type
│ │ │ │ │ +real scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:155
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_S_O_R_:_:_S_e_q_S_S_O_R
│ │ │ │ │ +SeqSSOR(const M &A, int n, real_field_type w)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:164
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R
│ │ │ │ │ +Sequential SOR preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:262
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_S_e_q_S_O_R
│ │ │ │ │ +SeqSOR(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A,
│ │ │ │ │ +const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:303
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +M matrix_type
│ │ │ │ │ +The matrix type the preconditioner is for.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:265
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_r_e_a_l___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +FieldTraits< scalar_field_type >::real_type real_field_type
│ │ │ │ │ +real scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:275
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_a_p_p_l_y
│ │ │ │ │ +void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the preconditioner in a special direction.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:351
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:267
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:368
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:329
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_s_c_a_l_a_r___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +Simd::Scalar< field_type > scalar_field_type
│ │ │ │ │ +scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:273
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:372
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:337
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:269
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_S_e_q_S_O_R
│ │ │ │ │ +SeqSOR(const M &A, const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:320
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:271
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_S_O_R_:_:_S_e_q_S_O_R
│ │ │ │ │ +SeqSOR(const M &A, int n, real_field_type w)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:284
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c
│ │ │ │ │ +The sequential jacobian preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:413
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:500
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_S_e_q_J_a_c
│ │ │ │ │ +SeqJac(const M &A, const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:471
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:488
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +M matrix_type
│ │ │ │ │ +The matrix type the preconditioner is for.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:416
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_s_c_a_l_a_r___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +Simd::Scalar< field_type > scalar_field_type
│ │ │ │ │ +scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:424
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_S_e_q_J_a_c
│ │ │ │ │ +SeqJac(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A,
│ │ │ │ │ +const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:454
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:422
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:480
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:418
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_r_e_a_l___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +FieldTraits< scalar_field_type >::real_type real_field_type
│ │ │ │ │ +real scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:426
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:504
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_S_e_q_J_a_c
│ │ │ │ │ +SeqJac(const M &A, int n, real_field_type w)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:435
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_J_a_c_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:420
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U
│ │ │ │ │ +Sequential DILU preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:564
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_w_N_o_t_I_d_e_n_t_i_t_y__
│ │ │ │ │ +const bool wNotIdentity_
│ │ │ │ │ +true if w != 1.0
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:681
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +typename X::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:576
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:___w
│ │ │ │ │ +const real_field_type _w
│ │ │ │ │ +The relaxation factor to use.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:679
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:___A__
│ │ │ │ │ +const M & _A_
│ │ │ │ │ +The matrix we operate on.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:677
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_S_e_q_D_I_L_U
│ │ │ │ │ +SeqDILU(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A,
│ │ │ │ │ +const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:612
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_s_c_a_l_a_r___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +Simd::Scalar< field_type > scalar_field_type
│ │ │ │ │ +scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:579
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:664
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_r_e_a_l___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +typename FieldTraits< scalar_field_type >::real_type real_field_type
│ │ │ │ │ +real scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:581
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +M matrix_type
│ │ │ │ │ +The matrix type the preconditioner is for.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:567
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:571
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_b_l_o_c_k___t_y_p_e
│ │ │ │ │ +typename matrix_type::block_type block_type
│ │ │ │ │ +block type of matrix
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:569
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:648
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:639
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_S_e_q_D_I_L_U
│ │ │ │ │ +SeqDILU(const M &A, real_field_type w)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:589
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:669
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:573
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_S_e_q_D_I_L_U
│ │ │ │ │ +SeqDILU(const M &A, const ParameterTree &config)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:629
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_D_I_L_U_:_:_D_i_n_v__
│ │ │ │ │ +std::vector< block_type > Dinv_
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:675
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U
│ │ │ │ │ +Sequential ILU preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:697
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:843
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_S_e_q_I_L_U
│ │ │ │ │ +SeqILU(const M &A, int n, real_field_type w, const bool resort=false)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:777
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:813
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:821
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_C_R_S
│ │ │ │ │ +ILU::CRS< block_type, typename M::allocator_type > CRS
│ │ │ │ │ +type of ILU storage
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:717
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:706
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_l_o_w_e_r__
│ │ │ │ │ +CRS lower_
│ │ │ │ │ +The ILU(n) decomposition of the matrix. As storage a CRS structure is used.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:857
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_w_N_o_t_I_d_e_n_t_i_t_y__
│ │ │ │ │ +const bool wNotIdentity_
│ │ │ │ │ +true if w != 1.0
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:864
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_S_e_q_I_L_U
│ │ │ │ │ +SeqILU(const M &A, const ParameterTree &config)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:763
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +std::remove_const< M >::type matrix_type
│ │ │ │ │ +The matrix type the preconditioner is for.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:700
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_b_l_o_c_k___t_y_p_e
│ │ │ │ │ +matrix_type::block_type block_type
│ │ │ │ │ +block type of matrix
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:702
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_r_e_a_l___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +FieldTraits< scalar_field_type >::real_type real_field_type
│ │ │ │ │ +real scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:714
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:709
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:847
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_S_e_q_I_L_U
│ │ │ │ │ +SeqILU(const M &A, real_field_type w, const bool resort=false)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:726
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_w__
│ │ │ │ │ +const real_field_type w_
│ │ │ │ │ +The relaxation factor to use.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:862
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_S_e_q_I_L_U
│ │ │ │ │ +SeqILU(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A,
│ │ │ │ │ +const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:745
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:704
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_i_n_v__
│ │ │ │ │ +std::vector< block_type, typename matrix_type::allocator_type > inv_
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:859
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_s_c_a_l_a_r___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +Simd::Scalar< field_type > scalar_field_type
│ │ │ │ │ +scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:712
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_I_L_U__
│ │ │ │ │ +std::unique_ptr< matrix_type > ILU_
│ │ │ │ │ +The ILU(n) decomposition of the matrix. As storage a BCRSMatrix is used.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:854
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_U_:_:_u_p_p_e_r__
│ │ │ │ │ +CRS upper_
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:858
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n
│ │ │ │ │ +Richardson preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:878
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:885
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:943
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:883
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:920
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_R_i_c_h_a_r_d_s_o_n
│ │ │ │ │ +Richardson(real_field_type w=1.0)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:896
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:939
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_r_e_a_l___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +FieldTraits< scalar_field_type >::real_type real_field_type
│ │ │ │ │ +real scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:889
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_s_c_a_l_a_r___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +Simd::Scalar< field_type > scalar_field_type
│ │ │ │ │ +scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:887
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_R_i_c_h_a_r_d_s_o_n
│ │ │ │ │ +Richardson(const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:911
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:881
│ │ │ │ │ +_D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the precondioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:928
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L
│ │ │ │ │ +sequential ILDL preconditioner
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:972
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_S_e_q_I_L_D_L
│ │ │ │ │ +SeqILDL(const matrix_type &A, const ParameterTree &config)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:1018
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_S_e_q_I_L_D_L
│ │ │ │ │ +SeqILDL(const matrix_type &A, real_field_type relax=real_field_type(1))
│ │ │ │ │ +constructor
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:1030
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +domain type of the preconditioner
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:980
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_p_o_s_t
│ │ │ │ │ +void post(X &x) override
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:1081
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +range type of the preconditioner
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:982
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +std::remove_const_t< M > matrix_type
│ │ │ │ │ +type of matrix the preconditioner is for
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:978
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_a_p_p_l_y
│ │ │ │ │ +void apply(X &v, const Y &d) override
│ │ │ │ │ +Apply one step of the preconditioner to the system A(v)=d.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:1074
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_r_e_a_l___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +FieldTraits< scalar_field_type >::real_type real_field_type
│ │ │ │ │ +real scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:988
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_S_e_q_I_L_D_L
│ │ │ │ │ +SeqILDL(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A,
│ │ │ │ │ +const ParameterTree &configuration)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:1002
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_p_r_e
│ │ │ │ │ +void pre(X &x, Y &b) override
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:1070
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_s_c_a_l_a_r___f_i_e_l_d___t_y_p_e
│ │ │ │ │ +Simd::Scalar< field_type > scalar_field_type
│ │ │ │ │ +scalar type underlying the field_type
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:986
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +field type of the preconditioner
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:984
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_I_L_D_L_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +SolverCategory::Category category() const override
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn preconditioners.hh:1085
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_R_e_s_u_l_t
│ │ │ │ │ +Statistics about the application of an inverse operator.
│ │ │ │ │ +DDeeffiinniittiioonn solver.hh:50
│ │ │ │ │ +_D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r
│ │ │ │ │ +Abstract base class for all solvers.
│ │ │ │ │ +DDeeffiinniittiioonn solver.hh:101
│ │ │ │ │ +_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_:_:_s_e_q_u_e_n_t_i_a_l
│ │ │ │ │ +@ sequential
│ │ │ │ │ +Category for sequential solvers.
│ │ │ │ │ +DDeeffiinniittiioonn solvercategory.hh:25
│ │ │ │ │ +_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
│ │ │ │ │ +static Category category(const OP &op, decltype(op.category()) *=nullptr)
│ │ │ │ │ +Helperfunction to extract the solver category either from an enum, or from the
│ │ │ │ │ +newly introduced virtu...
│ │ │ │ │ +DDeeffiinniittiioonn solvercategory.hh:34
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00020.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: scaledidmatrix.hh File Reference
│ │ │ │ +dune-istl: counter.hh File Reference
│ │ │ │
│ │ │ │ -
│ │ │ │ -
This file implements a quadratic matrix of fixed size which is a multiple of the identity.
│ │ │ │ -More...
│ │ │ │ -
#include <cmath>
│ │ │ │ -
#include <cstddef>
│ │ │ │ -
#include <complex>
│ │ │ │ +
#include <cassert>#include <typeinfo>#include <iostream>#include <dune/common/exceptions.hh>#include <dune/common/fmatrix.hh>#include <dune/common/diagonalmatrix.hh>#include <dune/common/ftraits.hh>#include <memory>#include <tuple>#include <utility>#include <dune/common/typeutilities.hh>
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ +constexpr std::size_t maxcount = 100
│ │ │ │ -
│ │ │ │ -
This file implements a quadratic matrix of fixed size which is a multiple of the identity.
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
◆
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + #define DUNE_GET_COUNTER
│ │ │ │ + (
│ │ │ │ +
│ │ │ │ + Tag )
│ │ │ │ + (counterFunc(Dune::PriorityTag<maxcount >{}, Tag{}, Dune::CounterImpl::ADLTag{}))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
◆
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + #define DUNE_INC_COUNTER
│ │ │ │ + (
│ │ │ │ +
│ │ │ │ + Tag )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Value: namespace { \
│ │ │ │ +
namespace CounterImpl { \
│ │ │ │ +
constexpr std::size_t \
│ │ │ │ +
│ │ │ │ +
{ \
│ │ │ │ +
return p.value; \
│ │ │ │ +
} \
│ │ │ │ +
} \
│ │ │ │ +
} \
│ │ │ │ +
static_assert(true , "unfudge indentation" )
│ │ │ │ +
#define DUNE_GET_COUNTER(Tag)
Definition counter.hh:17
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
◆
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + constexpr std::size_t maxcount = 100
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +constexpr
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ + * _c_o_m_m_o_n
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _M_a_c_r_o_s | _V_a_r_i_a_b_l_e_s
│ │ │ │ │ +counter.hh File Reference
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ #include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -CCllaasssseess
│ │ │ │ │ - class _D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_ _K_,_ _n_ _>
│ │ │ │ │ - A multiple of the identity matrix of static size. _M_o_r_e_._._.
│ │ │ │ │ +NNaammeessppaacceess
│ │ │ │ │ +namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_D_e_n_s_e_M_a_t_r_i_x_A_s_s_i_g_n_e_r_<_ _D_e_n_s_e_M_a_t_r_i_x_,_ _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_ _f_i_e_l_d_,_ _N
│ │ │ │ │ - _>_ _>
│ │ │ │ │ +namespace _D_u_n_e_:_:_C_o_u_n_t_e_r_I_m_p_l
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_ _K_,_ _n_ _>_ _>
│ │ │ │ │ +MMaaccrrooss
│ │ │ │ │ +#define _D_U_N_E___G_E_T___C_O_U_N_T_E_R(Tag) (counterFunc(Dune::PriorityTag<_m_a_x_c_o_u_n_t>{},
│ │ │ │ │ + Tag{}, Dune::CounterImpl::ADLTag{}))
│ │ │ │ │
│ │ │ │ │ -NNaammeessppaacceess
│ │ │ │ │ -namespace _D_u_n_e
│ │ │ │ │ +#define _D_U_N_E___I_N_C___C_O_U_N_T_E_R(Tag)
│ │ │ │ │ +
│ │ │ │ │ +VVaarriiaabblleess
│ │ │ │ │ +constexpr std::size_t _m_a_x_c_o_u_n_t = 100
│ │ │ │ │
│ │ │ │ │ -********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ -This file implements a quadratic matrix of fixed size which is a multiple of
│ │ │ │ │ -the identity.
│ │ │ │ │ +********** MMaaccrroo DDeeffiinniittiioonn DDooccuummeennttaattiioonn **********
│ │ │ │ │ +********** _?◆_? DDUUNNEE__GGEETT__CCOOUUNNTTEERR **********
│ │ │ │ │ +#define DUNE_GET_COUNTER ( Tag ) (counterFunc(Dune::PriorityTag<_m_a_x_c_o_u_n_t>
│ │ │ │ │ + {}, Tag{}, Dune::CounterImpl::ADLTag{}))
│ │ │ │ │ +********** _?◆_? DDUUNNEE__IINNCC__CCOOUUNNTTEERR **********
│ │ │ │ │ +#define DUNE_INC_COUNTER ( Tag )
│ │ │ │ │ +VVaalluuee::
│ │ │ │ │ +namespace { \
│ │ │ │ │ +namespace CounterImpl { \
│ │ │ │ │ +constexpr std::size_t \
│ │ │ │ │ +counterFunc(Dune::PriorityTag<_D_U_N_E___G_E_T___C_O_U_N_T_E_R(Tag)+1> p, Tag, ADLTag) \
│ │ │ │ │ +{ \
│ │ │ │ │ +return p.value; \
│ │ │ │ │ +} \
│ │ │ │ │ +} \
│ │ │ │ │ +} \
│ │ │ │ │ +static_assert(true, "unfudge indentation")
│ │ │ │ │ +_D_U_N_E___G_E_T___C_O_U_N_T_E_R
│ │ │ │ │ +#define DUNE_GET_COUNTER(Tag)
│ │ │ │ │ +DDeeffiinniittiioonn counter.hh:17
│ │ │ │ │ +********** VVaarriiaabbllee DDooccuummeennttaattiioonn **********
│ │ │ │ │ +********** _?◆_? mmaaxxccoouunntt **********
│ │ │ │ │ +constexpr std::size_t maxcount = 100 constexpr
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00020_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: scaledidmatrix.hh Source File
│ │ │ │ +dune-istl: counter.hh Source File
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
5 #ifndef DUNE_ISTL_SCALEDIDMATRIX_HH
│ │ │ │ -
6 #define DUNE_ISTL_SCALEDIDMATRIX_HH
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
18 #include <dune/common/exceptions.hh>
│ │ │ │ -
19 #include <dune/common/fmatrix.hh>
│ │ │ │ -
20 #include <dune/common/diagonalmatrix.hh>
│ │ │ │ -
21 #include <dune/common/ftraits.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
28 template <
class K,
int n>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
31 typedef DiagonalMatrixWrapper< ScaledIdentityMatrix<K,n> > WrapperType;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
3 #ifndef DUNE_ISTL_COMMON_COUNTER_HH
│ │ │ │ +
4 #define DUNE_ISTL_COMMON_COUNTER_HH
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
13 #include <dune/common/typeutilities.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
17 #define DUNE_GET_COUNTER(Tag) \
│ │ │ │ +
18 (counterFunc(Dune::PriorityTag<maxcount>{}, Tag{}, Dune::CounterImpl::ADLTag{}))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
20 #define DUNE_INC_COUNTER(Tag) \
│ │ │ │ +
│ │ │ │ +
22 namespace CounterImpl { \
│ │ │ │ +
23 constexpr std::size_t \
│ │ │ │ +
24 counterFunc(Dune::PriorityTag<DUNE_GET_COUNTER(Tag)+1> p, Tag, ADLTag) \
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
30 static_assert(true, "unfudge indentation")
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
35 namespace CounterImpl {
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
40 constexpr std::size_t counterFunc(Dune::PriorityTag<0>, Tag, ADLTag)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
80 return (
this ==&other);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
85 typedef ContainerWrapperIterator<const WrapperType, reference, reference>
Iterator ;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
96 return Iterator (WrapperType(
this ),0);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
102 return Iterator (WrapperType(
this ),n);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
109 return Iterator (WrapperType(
this ),n-1);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
116 return Iterator (WrapperType(
this ),-1);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
121 typedef ContainerWrapperIterator<const WrapperType, const_reference, const_reference>
ConstIterator ;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
201 template <
class Scalar,
│ │ │ │ -
202 std::enable_if_t<IsNumber<Scalar>::value,
int > = 0>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
209 template <
class Scalar,
│ │ │ │ -
210 std::enable_if_t<IsNumber<Scalar>::value,
int > = 0>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
221 return p_==other.
scalar ();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
227 return p_!=other.
scalar ();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
233 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
234 void mv (
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
236 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
237 if (x.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
238 if (y.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
245 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
246 void mtv (
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
252 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
253 void umv (
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
255 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
256 if (x.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
257 if (y.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
264 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
265 void umtv (
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
267 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
268 if (x.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
269 if (y.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
276 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
277 void umhv (
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
279 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
280 if (x.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
281 if (y.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
284 y[i] += conjugateComplex(p_)*x[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
288 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
289 void mmv (
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
291 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
292 if (x.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
293 if (y.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
300 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
301 void mmtv (
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
303 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
304 if (x.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
305 if (y.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
312 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
313 void mmhv (
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
315 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
316 if (x.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
317 if (y.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
320 y[i] -= conjugateComplex(p_)*x[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
324 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
325 void usmv (
const K& alpha,
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
327 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
328 if (x.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
329 if (y.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
332 y[i] += alpha * p_ * x[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
336 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
337 void usmtv (
const K& alpha,
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
339 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
340 if (x.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
341 if (y.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
344 y[i] += alpha * p_ * x[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
348 template <
class X,
class Y>
│ │ │ │ -
│ │ │ │ -
349 void usmhv (
const K& alpha,
const X& x, Y& y)
const
│ │ │ │ -
│ │ │ │ -
351 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
352 if (x.N()!=
N ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
353 if (y.N()!=
M ()) DUNE_THROW(FMatrixError,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
356 y[i] += alpha * conjugateComplex(p_) * x[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
364 return fvmeta::sqrt(n*p_*p_);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
382 return fvmeta::absreal(p_);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
392 for (
int i=0; i<n; i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
405 return std::pow(p_,n);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
427 #ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ -
428 if (i<0 || i>=n) DUNE_THROW(FMatrixError,
"row index out of range" );
│ │ │ │ -
429 if (j<0 || j>=n) DUNE_THROW(FMatrixError,
"column index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
441 s << ((i==j) ? a.p_ : 0) <<
" " ;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
450 return reference (
const_cast< K*
> (&p_), i);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
491 template <
class DenseMatrix,
class field,
int N>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
493 static void apply (DenseMatrix& denseMatrix,
│ │ │ │ -
│ │ │ │ -
495 assert(denseMatrix.M() == N);
│ │ │ │ -
496 assert(denseMatrix.N() == N);
│ │ │ │ -
497 denseMatrix = field(0);
│ │ │ │ -
498 for (
int i = 0; i < N; ++i)
│ │ │ │ -
499 denseMatrix[i][i] = rhs.
scalar ();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
503 template <
class K,
int n>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
507 using real_type =
typename FieldTraits<field_type>::real_type;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
constexpr std::size_t maxcount
Definition counter.hh:15
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
A multiple of the identity matrix of static size.
Definition scaledidmatrix.hh:30
│ │ │ │ -
void usmhv(const K &alpha, const X &x, Y &y) const
y += alpha A^H x
Definition scaledidmatrix.hh:349
│ │ │ │ -
void mmtv(const X &x, Y &y) const
y -= A^T x
Definition scaledidmatrix.hh:301
│ │ │ │ -
ScaledIdentityMatrix & operator-=(const ScaledIdentityMatrix &y)
vector space subtraction
Definition scaledidmatrix.hh:165
│ │ │ │ -
const_row_type::ConstIterator ConstColIterator
rename the iterators for easier access
Definition scaledidmatrix.hh:127
│ │ │ │ -
ConstIterator end() const
end iterator
Definition scaledidmatrix.hh:136
│ │ │ │ -
Iterator beforeBegin()
Definition scaledidmatrix.hh:114
│ │ │ │ -
bool operator!=(const ScaledIdentityMatrix &other) const
incomparison operator
Definition scaledidmatrix.hh:225
│ │ │ │ -
void mmv(const X &x, Y &y) const
y -= A x
Definition scaledidmatrix.hh:289
│ │ │ │ -
std::size_t size_type
The type used for the index access and size operations.
Definition scaledidmatrix.hh:43
│ │ │ │ -
void usmv(const K &alpha, const X &x, Y &y) const
y += alpha A x
Definition scaledidmatrix.hh:325
│ │ │ │ -
row_type::Iterator ColIterator
rename the iterators for easier access
Definition scaledidmatrix.hh:91
│ │ │ │ -
const_row_type const_reference
Definition scaledidmatrix.hh:49
│ │ │ │ -
void mv(const X &x, Y &y) const
y = A x
Definition scaledidmatrix.hh:234
│ │ │ │ -
void umtv(const X &x, Y &y) const
y += A^T x
Definition scaledidmatrix.hh:265
│ │ │ │ -
void umhv(const X &x, Y &y) const
y += A^H x
Definition scaledidmatrix.hh:277
│ │ │ │ -
DiagonalRowVector< K, n > row_type
Each row is implemented by a field vector.
Definition scaledidmatrix.hh:46
│ │ │ │ -
ContainerWrapperIterator< const WrapperType, reference, reference > Iterator
Iterator class for sequential access.
Definition scaledidmatrix.hh:85
│ │ │ │ -
Iterator beforeEnd()
Definition scaledidmatrix.hh:107
│ │ │ │ -
K determinant() const
calculates the determinant of this matrix
Definition scaledidmatrix.hh:404
│ │ │ │ -
K field_type
export the type representing the field
Definition scaledidmatrix.hh:37
│ │ │ │ -
void usmtv(const K &alpha, const X &x, Y &y) const
y += alpha A^T x
Definition scaledidmatrix.hh:337
│ │ │ │ -
Iterator end()
end iterator
Definition scaledidmatrix.hh:100
│ │ │ │ -
Iterator iterator
typedef for stl compliant access
Definition scaledidmatrix.hh:87
│ │ │ │ -
const K & scalar() const
Get const reference to the scalar diagonal value.
Definition scaledidmatrix.hh:473
│ │ │ │ -
void umv(const X &x, Y &y) const
y += A x
Definition scaledidmatrix.hh:253
│ │ │ │ -
const K & diagonal(size_type) const
Get const reference to diagonal entry.
Definition scaledidmatrix.hh:460
│ │ │ │ -
@ rows
The number of rows.
Definition scaledidmatrix.hh:54
│ │ │ │ -
@ cols
The number of columns.
Definition scaledidmatrix.hh:56
│ │ │ │ -
ScaledIdentityMatrix & operator=(const K &k)
Definition scaledidmatrix.hh:71
│ │ │ │ -
ContainerWrapperIterator< const WrapperType, const_reference, const_reference > ConstIterator
Iterator class for sequential access.
Definition scaledidmatrix.hh:121
│ │ │ │ -
K & diagonal(size_type)
Get reference to diagonal entry.
Definition scaledidmatrix.hh:466
│ │ │ │ -
void solve(V &x, const V &b) const
Solve system A x = b.
Definition scaledidmatrix.hh:390
│ │ │ │ -
bool exists(size_type i, size_type j) const
return true when (i,j) is in pattern
Definition scaledidmatrix.hh:425
│ │ │ │ -
Iterator RowIterator
rename the iterators for easier access
Definition scaledidmatrix.hh:89
│ │ │ │ -
ConstIterator const_iterator
typedef for stl compliant access
Definition scaledidmatrix.hh:123
│ │ │ │ -
ScaledIdentityMatrix()
Default constructor.
Definition scaledidmatrix.hh:62
│ │ │ │ -
bool operator==(const ScaledIdentityMatrix &other) const
comparison operator
Definition scaledidmatrix.hh:219
│ │ │ │ -
ConstIterator beforeBegin() const
Definition scaledidmatrix.hh:150
│ │ │ │ -
ScaledIdentityMatrix & operator/=(const K &k)
vector space division by scalar
Definition scaledidmatrix.hh:192
│ │ │ │ -
friend std::ostream & operator<<(std::ostream &s, const ScaledIdentityMatrix< K, n > &a)
Sends the matrix to an output stream.
Definition scaledidmatrix.hh:437
│ │ │ │ -
FieldTraits< field_type >::real_type frobenius_norm2() const
square of frobenius norm, need for block recursion
Definition scaledidmatrix.hh:368
│ │ │ │ -
FieldTraits< field_type >::real_type frobenius_norm() const
frobenius norm: sqrt(sum over squared values of entries)
Definition scaledidmatrix.hh:362
│ │ │ │ -
FieldTraits< field_type >::real_type infinity_norm() const
infinity norm (row sum norm, how to generalize for blocks?)
Definition scaledidmatrix.hh:374
│ │ │ │ -
ConstIterator ConstRowIterator
rename the iterators for easier access
Definition scaledidmatrix.hh:125
│ │ │ │ -
ConstIterator beforeEnd() const
Definition scaledidmatrix.hh:143
│ │ │ │ -
size_type M() const
number of blocks in column direction
Definition scaledidmatrix.hh:417
│ │ │ │ -
const_reference operator[](size_type i) const
Return const_reference object as row replacement.
Definition scaledidmatrix.hh:454
│ │ │ │ -
ScaledIdentityMatrix(const K &k)
Constructor initializing the whole matrix with a scalar.
Definition scaledidmatrix.hh:66
│ │ │ │ -
friend auto operator*(const ScaledIdentityMatrix &matrix, Scalar scalar)
vector space multiplication with scalar
Definition scaledidmatrix.hh:203
│ │ │ │ -
FieldTraits< field_type >::real_type infinity_norm_real() const
simplified infinity norm (uses Manhattan norm for complex values)
Definition scaledidmatrix.hh:380
│ │ │ │ -
ScaledIdentityMatrix & operator*=(const K &k)
vector space multiplication with scalar
Definition scaledidmatrix.hh:185
│ │ │ │ -
bool identical(const ScaledIdentityMatrix< K, n > &other) const
Definition scaledidmatrix.hh:78
│ │ │ │ -
void invert()
Compute inverse.
Definition scaledidmatrix.hh:398
│ │ │ │ -
Iterator begin()
begin iterator
Definition scaledidmatrix.hh:94
│ │ │ │ -
K & scalar()
Get reference to the scalar diagonal value.
Definition scaledidmatrix.hh:480
│ │ │ │ -
row_type reference
Definition scaledidmatrix.hh:47
│ │ │ │ -
K block_type
export the type representing the components
Definition scaledidmatrix.hh:40
│ │ │ │ -
void mmhv(const X &x, Y &y) const
y -= A^H x
Definition scaledidmatrix.hh:313
│ │ │ │ -
ScaledIdentityMatrix & operator+=(const ScaledIdentityMatrix &y)
vector space addition
Definition scaledidmatrix.hh:158
│ │ │ │ -
DiagonalRowVectorConst< K, n > const_row_type
Definition scaledidmatrix.hh:48
│ │ │ │ -
void mtv(const X &x, Y &y) const
y = A^T x
Definition scaledidmatrix.hh:246
│ │ │ │ -
reference operator[](size_type i)
Return reference object as row replacement.
Definition scaledidmatrix.hh:448
│ │ │ │ -
ConstIterator begin() const
begin iterator
Definition scaledidmatrix.hh:130
│ │ │ │ -
size_type N() const
number of blocks in row direction
Definition scaledidmatrix.hh:411
│ │ │ │ -
static void apply(DenseMatrix &denseMatrix, ScaledIdentityMatrix< field, N > const &rhs)
Definition scaledidmatrix.hh:493
│ │ │ │ -
typename ScaledIdentityMatrix< K, n >::field_type field_type
Definition scaledidmatrix.hh:506
│ │ │ │ -
typename FieldTraits< field_type >::real_type real_type
Definition scaledidmatrix.hh:507
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,711 +1,66 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -scaledidmatrix.hh
│ │ │ │ │ + * _c_o_m_m_o_n
│ │ │ │ │ +counter.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 © 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_SCALEDIDMATRIX_HH
│ │ │ │ │ -6#define DUNE_ISTL_SCALEDIDMATRIX_HH
│ │ │ │ │ -7
│ │ │ │ │ -14#include
│ │ │ │ │ -15#include
│ │ │ │ │ -16#include
│ │ │ │ │ -17#include
│ │ │ │ │ -18#include
│ │ │ │ │ -19#include
│ │ │ │ │ -20#include
│ │ │ │ │ -21#include
│ │ │ │ │ -22
│ │ │ │ │ -23namespace _D_u_n_e {
│ │ │ │ │ -24
│ │ │ │ │ -28 template
│ │ │ │ │ -_2_9 class _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x
│ │ │ │ │ -30 {
│ │ │ │ │ -31 typedef DiagonalMatrixWrapper< ScaledIdentityMatrix > WrapperType;
│ │ │ │ │ -32
│ │ │ │ │ -33 public:
│ │ │ │ │ -34 //===== type definitions and constants
│ │ │ │ │ -35
│ │ │ │ │ -_3_7 typedef K _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +3#ifndef DUNE_ISTL_COMMON_COUNTER_HH
│ │ │ │ │ +4#define DUNE_ISTL_COMMON_COUNTER_HH
│ │ │ │ │ +5
│ │ │ │ │ +6#include
│ │ │ │ │ +7#include
│ │ │ │ │ +8#include
│ │ │ │ │ +9#include
│ │ │ │ │ +10#include
│ │ │ │ │ +11#include
│ │ │ │ │ +12
│ │ │ │ │ +13#include
│ │ │ │ │ +14
│ │ │ │ │ +_1_5constexpr std::size_t _m_a_x_c_o_u_n_t = 100;
│ │ │ │ │ +16
│ │ │ │ │ +_1_7#define DUNE_GET_COUNTER(Tag) \
│ │ │ │ │ +18 (counterFunc(Dune::PriorityTag{}, Tag{}, Dune::CounterImpl::ADLTag
│ │ │ │ │ +{}))
│ │ │ │ │ +19
│ │ │ │ │ +_2_0#define DUNE_INC_COUNTER(Tag) \
│ │ │ │ │ +21 namespace { \
│ │ │ │ │ +22 namespace CounterImpl { \
│ │ │ │ │ +23 constexpr std::size_t \
│ │ │ │ │ +24 counterFunc(Dune::PriorityTag p, Tag, ADLTag) \
│ │ │ │ │ +25 { \
│ │ │ │ │ +26 return p.value; \
│ │ │ │ │ +27 } \
│ │ │ │ │ +28 } \
│ │ │ │ │ +29 } \
│ │ │ │ │ +30 static_assert(true, "unfudge indentation")
│ │ │ │ │ +31
│ │ │ │ │ +32namespace _D_u_n_e {
│ │ │ │ │ +33 namespace {
│ │ │ │ │ +34
│ │ │ │ │ +_3_5 namespace CounterImpl {
│ │ │ │ │ +36
│ │ │ │ │ +37 struct ADLTag {};
│ │ │ │ │ 38
│ │ │ │ │ -_4_0 typedef K _b_l_o_c_k___t_y_p_e;
│ │ │ │ │ -41
│ │ │ │ │ -_4_3 typedef std::size_t _s_i_z_e___t_y_p_e;
│ │ │ │ │ +39 template
│ │ │ │ │ +40 constexpr std::size_t counterFunc(Dune::PriorityTag<0>, Tag, ADLTag)
│ │ │ │ │ +41 {
│ │ │ │ │ +42 return 0;
│ │ │ │ │ +43 }
│ │ │ │ │ 44
│ │ │ │ │ -_4_6 typedef DiagonalRowVector _r_o_w___t_y_p_e;
│ │ │ │ │ -_4_7 typedef _r_o_w___t_y_p_e _r_e_f_e_r_e_n_c_e;
│ │ │ │ │ -_4_8 typedef DiagonalRowVectorConst _c_o_n_s_t___r_o_w___t_y_p_e;
│ │ │ │ │ -_4_9 typedef _c_o_n_s_t___r_o_w___t_y_p_e _c_o_n_s_t___r_e_f_e_r_e_n_c_e;
│ │ │ │ │ -50
│ │ │ │ │ -52 enum {
│ │ │ │ │ -_5_4 _r_o_w_s = n,
│ │ │ │ │ -56 _c_o_l_s = n
│ │ │ │ │ -_5_7 };
│ │ │ │ │ -58
│ │ │ │ │ -59 //===== constructors
│ │ │ │ │ -_6_2 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x () {}
│ │ │ │ │ -63
│ │ │ │ │ -_6_6 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x (const K& k)
│ │ │ │ │ -67 : p_(k)
│ │ │ │ │ -68 {}
│ │ │ │ │ -69
│ │ │ │ │ -70 //===== assignment from scalar
│ │ │ │ │ -_7_1 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_=_ (const K& k)
│ │ │ │ │ -72 {
│ │ │ │ │ -73 p_ = k;
│ │ │ │ │ -74 return *this;
│ │ │ │ │ -75 }
│ │ │ │ │ -76
│ │ │ │ │ -77 // check if matrix is identical to other matrix (not only identical values)
│ │ │ │ │ -_7_8 bool _i_d_e_n_t_i_c_a_l(const _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_K_,_n_>& other) const
│ │ │ │ │ -79 {
│ │ │ │ │ -80 return (this==&other);
│ │ │ │ │ -81 }
│ │ │ │ │ -82
│ │ │ │ │ -83 //===== iterator interface to rows of the matrix
│ │ │ │ │ -_8_5 typedef ContainerWrapperIterator
│ │ │ │ │ -_I_t_e_r_a_t_o_r;
│ │ │ │ │ -_8_7 typedef _I_t_e_r_a_t_o_r _i_t_e_r_a_t_o_r;
│ │ │ │ │ -_8_9 typedef _I_t_e_r_a_t_o_r _R_o_w_I_t_e_r_a_t_o_r;
│ │ │ │ │ -_9_1 typedef typename row_type::Iterator _C_o_l_I_t_e_r_a_t_o_r;
│ │ │ │ │ -92
│ │ │ │ │ -_9_4 _I_t_e_r_a_t_o_r _b_e_g_i_n ()
│ │ │ │ │ -95 {
│ │ │ │ │ -96 return _I_t_e_r_a_t_o_r(WrapperType(this),0);
│ │ │ │ │ -97 }
│ │ │ │ │ -98
│ │ │ │ │ -_1_0_0 _I_t_e_r_a_t_o_r _e_n_d ()
│ │ │ │ │ -101 {
│ │ │ │ │ -102 return _I_t_e_r_a_t_o_r(WrapperType(this),n);
│ │ │ │ │ -103 }
│ │ │ │ │ -104
│ │ │ │ │ -_1_0_7 _I_t_e_r_a_t_o_r _b_e_f_o_r_e_E_n_d ()
│ │ │ │ │ -108 {
│ │ │ │ │ -109 return _I_t_e_r_a_t_o_r(WrapperType(this),n-1);
│ │ │ │ │ -110 }
│ │ │ │ │ -111
│ │ │ │ │ -_1_1_4 _I_t_e_r_a_t_o_r _b_e_f_o_r_e_B_e_g_i_n ()
│ │ │ │ │ -115 {
│ │ │ │ │ -116 return _I_t_e_r_a_t_o_r(WrapperType(this),-1);
│ │ │ │ │ -117 }
│ │ │ │ │ -118
│ │ │ │ │ -119
│ │ │ │ │ -_1_2_1 typedef ContainerWrapperIterator _C_o_n_s_t_I_t_e_r_a_t_o_r;
│ │ │ │ │ -_1_2_3 typedef _C_o_n_s_t_I_t_e_r_a_t_o_r _c_o_n_s_t___i_t_e_r_a_t_o_r;
│ │ │ │ │ -_1_2_5 typedef _C_o_n_s_t_I_t_e_r_a_t_o_r _C_o_n_s_t_R_o_w_I_t_e_r_a_t_o_r;
│ │ │ │ │ -_1_2_7 typedef typename const_row_type::ConstIterator _C_o_n_s_t_C_o_l_I_t_e_r_a_t_o_r;
│ │ │ │ │ -128
│ │ │ │ │ -_1_3_0 _C_o_n_s_t_I_t_e_r_a_t_o_r _b_e_g_i_n () const
│ │ │ │ │ -131 {
│ │ │ │ │ -132 return _C_o_n_s_t_I_t_e_r_a_t_o_r(WrapperType(this),0);
│ │ │ │ │ -133 }
│ │ │ │ │ -134
│ │ │ │ │ -_1_3_6 _C_o_n_s_t_I_t_e_r_a_t_o_r _e_n_d () const
│ │ │ │ │ -137 {
│ │ │ │ │ -138 return _C_o_n_s_t_I_t_e_r_a_t_o_r(WrapperType(this),n);
│ │ │ │ │ -139 }
│ │ │ │ │ -140
│ │ │ │ │ -_1_4_3 _C_o_n_s_t_I_t_e_r_a_t_o_r _b_e_f_o_r_e_E_n_d() const
│ │ │ │ │ -144 {
│ │ │ │ │ -145 return _C_o_n_s_t_I_t_e_r_a_t_o_r(WrapperType(this),n-1);
│ │ │ │ │ -146 }
│ │ │ │ │ -147
│ │ │ │ │ -_1_5_0 _C_o_n_s_t_I_t_e_r_a_t_o_r _b_e_f_o_r_e_B_e_g_i_n () const
│ │ │ │ │ -151 {
│ │ │ │ │ -152 return _C_o_n_s_t_I_t_e_r_a_t_o_r(WrapperType(this),-1);
│ │ │ │ │ -153 }
│ │ │ │ │ -154
│ │ │ │ │ -155 //===== vector space arithmetic
│ │ │ │ │ -156
│ │ │ │ │ -_1_5_8 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_+_=_ (const _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& y)
│ │ │ │ │ -159 {
│ │ │ │ │ -160 p_ += y.p_;
│ │ │ │ │ -161 return *this;
│ │ │ │ │ -162 }
│ │ │ │ │ -163
│ │ │ │ │ -_1_6_5 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_-_=_ (const _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& y)
│ │ │ │ │ -166 {
│ │ │ │ │ -167 p_ -= y.p_;
│ │ │ │ │ -168 return *this;
│ │ │ │ │ -169 }
│ │ │ │ │ -170
│ │ │ │ │ -_1_7_2 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_+_=_ (const K& k)
│ │ │ │ │ -173 {
│ │ │ │ │ -174 p_ += k;
│ │ │ │ │ -175 return *this;
│ │ │ │ │ -176 }
│ │ │ │ │ -177
│ │ │ │ │ -_1_7_9 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_-_=_ (const K& k)
│ │ │ │ │ -180 {
│ │ │ │ │ -181 p_ -= k;
│ │ │ │ │ -182 return *this;
│ │ │ │ │ -183 }
│ │ │ │ │ -_1_8_5 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_*_=_ (const K& k)
│ │ │ │ │ -186 {
│ │ │ │ │ -187 p_ *= k;
│ │ │ │ │ -188 return *this;
│ │ │ │ │ -189 }
│ │ │ │ │ -190
│ │ │ │ │ -_1_9_2 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_/_=_ (const K& k)
│ │ │ │ │ -193 {
│ │ │ │ │ -194 p_ /= k;
│ │ │ │ │ -195 return *this;
│ │ │ │ │ -196 }
│ │ │ │ │ -197
│ │ │ │ │ -198 //===== binary operators
│ │ │ │ │ -199
│ │ │ │ │ -201 template ::value, int> = 0>
│ │ │ │ │ -_2_0_3 friend auto _o_p_e_r_a_t_o_r_*_ ( const _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& matrix, Scalar _s_c_a_l_a_r)
│ │ │ │ │ -204 {
│ │ │ │ │ -205 return _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_t_y_p_e_n_a_m_e_ _P_r_o_m_o_t_i_o_n_T_r_a_i_t_s_<_K_,_S_c_a_l_a_r_>_:_:
│ │ │ │ │ -_P_r_o_m_o_t_e_d_T_y_p_e, n>{matrix._s_c_a_l_a_r()*_s_c_a_l_a_r};
│ │ │ │ │ -206 }
│ │ │ │ │ -207
│ │ │ │ │ -209 template ::value, int> = 0>
│ │ │ │ │ -_2_1_1 friend auto _o_p_e_r_a_t_o_r_*_ (Scalar _s_c_a_l_a_r, const _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& matrix)
│ │ │ │ │ -212 {
│ │ │ │ │ -213 return _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_t_y_p_e_n_a_m_e_ _P_r_o_m_o_t_i_o_n_T_r_a_i_t_s_<_S_c_a_l_a_r_,_K_>_:_:
│ │ │ │ │ -_P_r_o_m_o_t_e_d_T_y_p_e, n>{_s_c_a_l_a_r*matrix._s_c_a_l_a_r()};
│ │ │ │ │ -214 }
│ │ │ │ │ -215
│ │ │ │ │ -216 //===== comparison ops
│ │ │ │ │ -217
│ │ │ │ │ -_2_1_9 bool _o_p_e_r_a_t_o_r_=_=(const _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& other) const
│ │ │ │ │ -220 {
│ │ │ │ │ -221 return p_==other._s_c_a_l_a_r();
│ │ │ │ │ -222 }
│ │ │ │ │ -223
│ │ │ │ │ -_2_2_5 bool _o_p_e_r_a_t_o_r_!_=(const _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x& other) const
│ │ │ │ │ -226 {
│ │ │ │ │ -227 return p_!=other._s_c_a_l_a_r();
│ │ │ │ │ -228 }
│ │ │ │ │ -229
│ │ │ │ │ -230 //===== linear maps
│ │ │ │ │ -231
│ │ │ │ │ -233 template
│ │ │ │ │ -_2_3_4 void _m_v (const X& x, Y& y) const
│ │ │ │ │ -235 {
│ │ │ │ │ -236#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -237 if (x.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -238 if (y.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -239#endif
│ │ │ │ │ -240 for (_s_i_z_e___t_y_p_e i=0; i
│ │ │ │ │ -_2_4_6 void _m_t_v (const X& x, Y& y) const
│ │ │ │ │ -247 {
│ │ │ │ │ -248 _m_v(x, y);
│ │ │ │ │ -249 }
│ │ │ │ │ -250
│ │ │ │ │ -252 template
│ │ │ │ │ -_2_5_3 void _u_m_v (const X& x, Y& y) const
│ │ │ │ │ -254 {
│ │ │ │ │ -255#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -256 if (x.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -257 if (y.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -258#endif
│ │ │ │ │ -259 for (_s_i_z_e___t_y_p_e i=0; i
│ │ │ │ │ -_2_6_5 void _u_m_t_v (const X& x, Y& y) const
│ │ │ │ │ -266 {
│ │ │ │ │ -267#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -268 if (x.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -269 if (y.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -270#endif
│ │ │ │ │ -271 for (_s_i_z_e___t_y_p_e i=0; i
│ │ │ │ │ -_2_7_7 void _u_m_h_v (const X& x, Y& y) const
│ │ │ │ │ -278 {
│ │ │ │ │ -279#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -280 if (x.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -281 if (y.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -282#endif
│ │ │ │ │ -283 for (_s_i_z_e___t_y_p_e i=0; i
│ │ │ │ │ -_2_8_9 void _m_m_v (const X& x, Y& y) const
│ │ │ │ │ -290 {
│ │ │ │ │ -291#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -292 if (x.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -293 if (y.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -294#endif
│ │ │ │ │ -295 for (_s_i_z_e___t_y_p_e i=0; i
│ │ │ │ │ -_3_0_1 void _m_m_t_v (const X& x, Y& y) const
│ │ │ │ │ -302 {
│ │ │ │ │ -303#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -304 if (x.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -305 if (y.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -306#endif
│ │ │ │ │ -307 for (_s_i_z_e___t_y_p_e i=0; i
│ │ │ │ │ -_3_1_3 void _m_m_h_v (const X& x, Y& y) const
│ │ │ │ │ -314 {
│ │ │ │ │ -315#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -316 if (x.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -317 if (y.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -318#endif
│ │ │ │ │ -319 for (_s_i_z_e___t_y_p_e i=0; i
│ │ │ │ │ -_3_2_5 void _u_s_m_v (const K& alpha, const X& x, Y& y) const
│ │ │ │ │ -326 {
│ │ │ │ │ -327#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -328 if (x.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -329 if (y.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -330#endif
│ │ │ │ │ -331 for (_s_i_z_e___t_y_p_e i=0; i
│ │ │ │ │ -_3_3_7 void _u_s_m_t_v (const K& alpha, const X& x, Y& y) const
│ │ │ │ │ -338 {
│ │ │ │ │ -339#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -340 if (x.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -341 if (y.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -342#endif
│ │ │ │ │ -343 for (_s_i_z_e___t_y_p_e i=0; i
│ │ │ │ │ -_3_4_9 void _u_s_m_h_v (const K& alpha, const X& x, Y& y) const
│ │ │ │ │ -350 {
│ │ │ │ │ -351#ifdef DUNE_FMatrix_WITH_CHECKING
│ │ │ │ │ -352 if (x.N()!=_N()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -353 if (y.N()!=_M()) DUNE_THROW(FMatrixError,"index out of range");
│ │ │ │ │ -354#endif
│ │ │ │ │ -355 for (_s_i_z_e___t_y_p_e i=0; i::real_type _f_r_o_b_e_n_i_u_s___n_o_r_m () const
│ │ │ │ │ -363 {
│ │ │ │ │ -364 return fvmeta::sqrt(n*p_*p_);
│ │ │ │ │ -365 }
│ │ │ │ │ -366
│ │ │ │ │ -_3_6_8 typename FieldTraits::real_type _f_r_o_b_e_n_i_u_s___n_o_r_m_2 () const
│ │ │ │ │ -369 {
│ │ │ │ │ -370 return n*p_*p_;
│ │ │ │ │ -371 }
│ │ │ │ │ -372
│ │ │ │ │ -_3_7_4 typename FieldTraits::real_type _i_n_f_i_n_i_t_y___n_o_r_m () const
│ │ │ │ │ -375 {
│ │ │ │ │ -376 return std::abs(p_);
│ │ │ │ │ -377 }
│ │ │ │ │ -378
│ │ │ │ │ -_3_8_0 typename FieldTraits::real_type _i_n_f_i_n_i_t_y___n_o_r_m___r_e_a_l () const
│ │ │ │ │ -381 {
│ │ │ │ │ -382 return fvmeta::absreal(p_);
│ │ │ │ │ -383 }
│ │ │ │ │ -384
│ │ │ │ │ -385 //===== solve
│ │ │ │ │ -386
│ │ │ │ │ -389 template
│ │ │ │ │ -_3_9_0 void _s_o_l_v_e (V& x, const V& b) const
│ │ │ │ │ -391 {
│ │ │ │ │ -392 for (int i=0; i=n) DUNE_THROW(FMatrixError,"row index out of range");
│ │ │ │ │ -429 if (j<0 || j>=n) DUNE_THROW(FMatrixError,"column index out of range");
│ │ │ │ │ -430#endif
│ │ │ │ │ -431 return i==j;
│ │ │ │ │ -432 }
│ │ │ │ │ -433
│ │ │ │ │ -434 //===== conversion operator
│ │ │ │ │ -435
│ │ │ │ │ -_4_3_7 friend std::ostream& _o_p_e_r_a_t_o_r_<_<_ (std::ostream& s, const
│ │ │ │ │ -_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_K_,_n_>& a)
│ │ │ │ │ -438 {
│ │ │ │ │ -439 for (_s_i_z_e___t_y_p_e i=0; i(&p_), i);
│ │ │ │ │ -451 }
│ │ │ │ │ -452
│ │ │ │ │ -_4_5_4 _c_o_n_s_t___r_e_f_e_r_e_n_c_e _o_p_e_r_a_t_o_r_[_](_s_i_z_e___t_y_p_e i) const
│ │ │ │ │ -455 {
│ │ │ │ │ -456 return _c_o_n_s_t___r_e_f_e_r_e_n_c_e(const_cast(&p_), i);
│ │ │ │ │ -457 }
│ │ │ │ │ -458
│ │ │ │ │ -_4_6_0 const K& _d_i_a_g_o_n_a_l(_s_i_z_e___t_y_p_e /*i*/) const
│ │ │ │ │ -461 {
│ │ │ │ │ -462 return p_;
│ │ │ │ │ -463 }
│ │ │ │ │ -464
│ │ │ │ │ -_4_6_6 K& _d_i_a_g_o_n_a_l(_s_i_z_e___t_y_p_e /*i*/)
│ │ │ │ │ -467 {
│ │ │ │ │ -468 return p_;
│ │ │ │ │ -469 }
│ │ │ │ │ -470
│ │ │ │ │ -_4_7_3 const K& _s_c_a_l_a_r() const
│ │ │ │ │ -474 {
│ │ │ │ │ -475 return p_;
│ │ │ │ │ -476 }
│ │ │ │ │ -477
│ │ │ │ │ -_4_8_0 K& _s_c_a_l_a_r()
│ │ │ │ │ -481 {
│ │ │ │ │ -482 return p_;
│ │ │ │ │ -483 }
│ │ │ │ │ -484
│ │ │ │ │ -485 private:
│ │ │ │ │ -486 // the data, very simply a single number
│ │ │ │ │ -487 K p_;
│ │ │ │ │ -488
│ │ │ │ │ -489 };
│ │ │ │ │ -490
│ │ │ │ │ -491 template
│ │ │ │ │ -_4_9_2 struct DenseMatrixAssigner> {
│ │ │ │ │ -_4_9_3 static void _a_p_p_l_y(DenseMatrix& denseMatrix,
│ │ │ │ │ -494 _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_f_i_e_l_d_,_ _N_> const& rhs) {
│ │ │ │ │ -495 assert(denseMatrix.M() == N);
│ │ │ │ │ -496 assert(denseMatrix.N() == N);
│ │ │ │ │ -497 denseMatrix = field(0);
│ │ │ │ │ -498 for (int i = 0; i < N; ++i)
│ │ │ │ │ -499 denseMatrix[i][i] = rhs._s_c_a_l_a_r();
│ │ │ │ │ -500 }
│ │ │ │ │ -501 };
│ │ │ │ │ -502
│ │ │ │ │ -503 template
│ │ │ │ │ -_5_0_4 struct FieldTraits< _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x >
│ │ │ │ │ -505 {
│ │ │ │ │ -_5_0_6 using _f_i_e_l_d___t_y_p_e = typename _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_K_,_ _n_>_:_:_f_i_e_l_d___t_y_p_e;
│ │ │ │ │ -_5_0_7 using _r_e_a_l___t_y_p_e = typename FieldTraits::real_type;
│ │ │ │ │ -508 };
│ │ │ │ │ -509
│ │ │ │ │ -510} // end namespace
│ │ │ │ │ -511
│ │ │ │ │ -512#endif
│ │ │ │ │ +45 } // end namespace CounterImpl
│ │ │ │ │ +46 } // end empty namespace
│ │ │ │ │ +47} // end namespace Dune
│ │ │ │ │ +48#endif // DUNE_ISTL_COMMON_COUNTER_HH
│ │ │ │ │ +_m_a_x_c_o_u_n_t
│ │ │ │ │ +constexpr std::size_t maxcount
│ │ │ │ │ +DDeeffiinniittiioonn counter.hh:15
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn allocator.hh:11
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x
│ │ │ │ │ -A multiple of the identity matrix of static size.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:30
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_u_s_m_h_v
│ │ │ │ │ -void usmhv(const K &alpha, const X &x, Y &y) const
│ │ │ │ │ -y += alpha A^H x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:349
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_m_m_t_v
│ │ │ │ │ -void mmtv(const X &x, Y &y) const
│ │ │ │ │ -y -= A^T x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:301
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_-_=
│ │ │ │ │ -ScaledIdentityMatrix & operator-=(const ScaledIdentityMatrix &y)
│ │ │ │ │ -vector space subtraction
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:165
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_C_o_n_s_t_C_o_l_I_t_e_r_a_t_o_r
│ │ │ │ │ -const_row_type::ConstIterator ConstColIterator
│ │ │ │ │ -rename the iterators for easier access
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:127
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_e_n_d
│ │ │ │ │ -ConstIterator end() const
│ │ │ │ │ -end iterator
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:136
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_b_e_f_o_r_e_B_e_g_i_n
│ │ │ │ │ -Iterator beforeBegin()
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:114
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_!_=
│ │ │ │ │ -bool operator!=(const ScaledIdentityMatrix &other) const
│ │ │ │ │ -incomparison operator
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:225
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_m_m_v
│ │ │ │ │ -void mmv(const X &x, Y &y) const
│ │ │ │ │ -y -= A x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:289
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ -std::size_t size_type
│ │ │ │ │ -The type used for the index access and size operations.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:43
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_u_s_m_v
│ │ │ │ │ -void usmv(const K &alpha, const X &x, Y &y) const
│ │ │ │ │ -y += alpha A x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:325
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_C_o_l_I_t_e_r_a_t_o_r
│ │ │ │ │ -row_type::Iterator ColIterator
│ │ │ │ │ -rename the iterators for easier access
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:91
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_c_o_n_s_t___r_e_f_e_r_e_n_c_e
│ │ │ │ │ -const_row_type const_reference
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:49
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_m_v
│ │ │ │ │ -void mv(const X &x, Y &y) const
│ │ │ │ │ -y = A x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:234
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_u_m_t_v
│ │ │ │ │ -void umtv(const X &x, Y &y) const
│ │ │ │ │ -y += A^T x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:265
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_u_m_h_v
│ │ │ │ │ -void umhv(const X &x, Y &y) const
│ │ │ │ │ -y += A^H x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:277
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_r_o_w___t_y_p_e
│ │ │ │ │ -DiagonalRowVector< K, n > row_type
│ │ │ │ │ -Each row is implemented by a field vector.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:46
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_I_t_e_r_a_t_o_r
│ │ │ │ │ -ContainerWrapperIterator< const WrapperType, reference, reference > Iterator
│ │ │ │ │ -Iterator class for sequential access.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:85
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_b_e_f_o_r_e_E_n_d
│ │ │ │ │ -Iterator beforeEnd()
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:107
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_d_e_t_e_r_m_i_n_a_n_t
│ │ │ │ │ -K determinant() const
│ │ │ │ │ -calculates the determinant of this matrix
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:404
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ -K field_type
│ │ │ │ │ -export the type representing the field
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:37
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_u_s_m_t_v
│ │ │ │ │ -void usmtv(const K &alpha, const X &x, Y &y) const
│ │ │ │ │ -y += alpha A^T x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:337
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_e_n_d
│ │ │ │ │ -Iterator end()
│ │ │ │ │ -end iterator
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:100
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_i_t_e_r_a_t_o_r
│ │ │ │ │ -Iterator iterator
│ │ │ │ │ -typedef for stl compliant access
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:87
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_s_c_a_l_a_r
│ │ │ │ │ -const K & scalar() const
│ │ │ │ │ -Get const reference to the scalar diagonal value.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:473
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_u_m_v
│ │ │ │ │ -void umv(const X &x, Y &y) const
│ │ │ │ │ -y += A x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:253
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_d_i_a_g_o_n_a_l
│ │ │ │ │ -const K & diagonal(size_type) const
│ │ │ │ │ -Get const reference to diagonal entry.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:460
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_r_o_w_s
│ │ │ │ │ -@ rows
│ │ │ │ │ -The number of rows.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:54
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_c_o_l_s
│ │ │ │ │ -@ cols
│ │ │ │ │ -The number of columns.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:56
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ -ScaledIdentityMatrix & operator=(const K &k)
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:71
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_C_o_n_s_t_I_t_e_r_a_t_o_r
│ │ │ │ │ -ContainerWrapperIterator< const WrapperType, const_reference, const_reference >
│ │ │ │ │ -ConstIterator
│ │ │ │ │ -Iterator class for sequential access.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:121
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_d_i_a_g_o_n_a_l
│ │ │ │ │ -K & diagonal(size_type)
│ │ │ │ │ -Get reference to diagonal entry.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:466
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_s_o_l_v_e
│ │ │ │ │ -void solve(V &x, const V &b) const
│ │ │ │ │ -Solve system A x = b.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:390
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_e_x_i_s_t_s
│ │ │ │ │ -bool exists(size_type i, size_type j) const
│ │ │ │ │ -return true when (i,j) is in pattern
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:425
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_R_o_w_I_t_e_r_a_t_o_r
│ │ │ │ │ -Iterator RowIterator
│ │ │ │ │ -rename the iterators for easier access
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:89
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_c_o_n_s_t___i_t_e_r_a_t_o_r
│ │ │ │ │ -ConstIterator const_iterator
│ │ │ │ │ -typedef for stl compliant access
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:123
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x
│ │ │ │ │ -ScaledIdentityMatrix()
│ │ │ │ │ -Default constructor.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:62
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_=_=
│ │ │ │ │ -bool operator==(const ScaledIdentityMatrix &other) const
│ │ │ │ │ -comparison operator
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:219
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_b_e_f_o_r_e_B_e_g_i_n
│ │ │ │ │ -ConstIterator beforeBegin() const
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:150
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_/_=
│ │ │ │ │ -ScaledIdentityMatrix & operator/=(const K &k)
│ │ │ │ │ -vector space division by scalar
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:192
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_<_<
│ │ │ │ │ -friend std::ostream & operator<<(std::ostream &s, const ScaledIdentityMatrix<
│ │ │ │ │ -K, n > &a)
│ │ │ │ │ -Sends the matrix to an output stream.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:437
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_f_r_o_b_e_n_i_u_s___n_o_r_m_2
│ │ │ │ │ -FieldTraits< field_type >::real_type frobenius_norm2() const
│ │ │ │ │ -square of frobenius norm, need for block recursion
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:368
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_f_r_o_b_e_n_i_u_s___n_o_r_m
│ │ │ │ │ -FieldTraits< field_type >::real_type frobenius_norm() const
│ │ │ │ │ -frobenius norm: sqrt(sum over squared values of entries)
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:362
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_i_n_f_i_n_i_t_y___n_o_r_m
│ │ │ │ │ -FieldTraits< field_type >::real_type infinity_norm() const
│ │ │ │ │ -infinity norm (row sum norm, how to generalize for blocks?)
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:374
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_C_o_n_s_t_R_o_w_I_t_e_r_a_t_o_r
│ │ │ │ │ -ConstIterator ConstRowIterator
│ │ │ │ │ -rename the iterators for easier access
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:125
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_b_e_f_o_r_e_E_n_d
│ │ │ │ │ -ConstIterator beforeEnd() const
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:143
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_M
│ │ │ │ │ -size_type M() const
│ │ │ │ │ -number of blocks in column direction
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:417
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_[_]
│ │ │ │ │ -const_reference operator[](size_type i) const
│ │ │ │ │ -Return const_reference object as row replacement.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:454
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x
│ │ │ │ │ -ScaledIdentityMatrix(const K &k)
│ │ │ │ │ -Constructor initializing the whole matrix with a scalar.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:66
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_*
│ │ │ │ │ -friend auto operator*(const ScaledIdentityMatrix &matrix, Scalar scalar)
│ │ │ │ │ -vector space multiplication with scalar
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:203
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_i_n_f_i_n_i_t_y___n_o_r_m___r_e_a_l
│ │ │ │ │ -FieldTraits< field_type >::real_type infinity_norm_real() const
│ │ │ │ │ -simplified infinity norm (uses Manhattan norm for complex values)
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:380
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_*_=
│ │ │ │ │ -ScaledIdentityMatrix & operator*=(const K &k)
│ │ │ │ │ -vector space multiplication with scalar
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:185
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_i_d_e_n_t_i_c_a_l
│ │ │ │ │ -bool identical(const ScaledIdentityMatrix< K, n > &other) const
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:78
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_i_n_v_e_r_t
│ │ │ │ │ -void invert()
│ │ │ │ │ -Compute inverse.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:398
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_b_e_g_i_n
│ │ │ │ │ -Iterator begin()
│ │ │ │ │ -begin iterator
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:94
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_s_c_a_l_a_r
│ │ │ │ │ -K & scalar()
│ │ │ │ │ -Get reference to the scalar diagonal value.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:480
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_r_e_f_e_r_e_n_c_e
│ │ │ │ │ -row_type reference
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:47
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_b_l_o_c_k___t_y_p_e
│ │ │ │ │ -K block_type
│ │ │ │ │ -export the type representing the components
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:40
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_m_m_h_v
│ │ │ │ │ -void mmhv(const X &x, Y &y) const
│ │ │ │ │ -y -= A^H x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:313
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_+_=
│ │ │ │ │ -ScaledIdentityMatrix & operator+=(const ScaledIdentityMatrix &y)
│ │ │ │ │ -vector space addition
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:158
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_c_o_n_s_t___r_o_w___t_y_p_e
│ │ │ │ │ -DiagonalRowVectorConst< K, n > const_row_type
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:48
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_m_t_v
│ │ │ │ │ -void mtv(const X &x, Y &y) const
│ │ │ │ │ -y = A^T x
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:246
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_[_]
│ │ │ │ │ -reference operator[](size_type i)
│ │ │ │ │ -Return reference object as row replacement.
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:448
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_b_e_g_i_n
│ │ │ │ │ -ConstIterator begin() const
│ │ │ │ │ -begin iterator
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:130
│ │ │ │ │ -_D_u_n_e_:_:_S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_:_:_N
│ │ │ │ │ -size_type N() const
│ │ │ │ │ -number of blocks in row direction
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:411
│ │ │ │ │ -_D_u_n_e_:_:_D_e_n_s_e_M_a_t_r_i_x_A_s_s_i_g_n_e_r_<_ _D_e_n_s_e_M_a_t_r_i_x_,_ _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_ _f_i_e_l_d_,_ _N_ _>_ _>_:_:
│ │ │ │ │ -_a_p_p_l_y
│ │ │ │ │ -static void apply(DenseMatrix &denseMatrix, ScaledIdentityMatrix< field, N >
│ │ │ │ │ -const &rhs)
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:493
│ │ │ │ │ -_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_ _K_,_ _n_ _>_ _>_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ -typename ScaledIdentityMatrix< K, n >::field_type field_type
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:506
│ │ │ │ │ -_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _S_c_a_l_e_d_I_d_e_n_t_i_t_y_M_a_t_r_i_x_<_ _K_,_ _n_ _>_ _>_:_:_r_e_a_l___t_y_p_e
│ │ │ │ │ -typename FieldTraits< field_type >::real_type real_type
│ │ │ │ │ -DDeeffiinniittiioonn scaledidmatrix.hh:507
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00023.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: btdmatrix.hh File Reference
│ │ │ │ +dune-istl: registry.hh File Reference
│ │ │ │
│ │ │ │ -
│ │ │ │ -
Implementation of the BTDMatrix class.
│ │ │ │ -More...
│ │ │ │ -
#include <dune/common/fmatrix.hh>
│ │ │ │ -
#include <dune/common/scalarvectorview.hh>
│ │ │ │ -
#include <dune/common/scalarmatrixview.hh>
│ │ │ │ -
#include <dune/istl/bcrsmatrix.hh >
│ │ │ │ -
#include <dune/istl/blocklevel.hh >
│ │ │ │ +
#include <cstddef>
│ │ │ │ +
#include <iostream>
│ │ │ │ +
#include <memory>
│ │ │ │ +
#include <string>
│ │ │ │ +
#include <utility>
│ │ │ │ +
#include "counter.hh "
│ │ │ │ +
#include <dune/common/typelist.hh>
│ │ │ │ +
#include <dune/common/hybridutilities.hh>
│ │ │ │ +
#include <dune/common/parameterizedobject.hh>
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ namespace Dune
│ │ │ │ -
│ │ │ │ -
Implementation of the BTDMatrix class.
│ │ │ │ -
Author Oliver Sander
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
◆
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + #define DUNE_REGISTRY_PUT
│ │ │ │ + (
│ │ │ │ +
│ │ │ │ + Tag,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + id,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + ...
│ │ │ │ +
│ │ │ │ + )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Value: namespace { \
│ │ │ │ +
template <> \
│ │ │ │ +
│ │ │ │ +
{ \
│ │ │ │ +
static auto getCreator() \
│ │ │ │ +
{ \
│ │ │ │ +
return __VA_ARGS__; \
│ │ │ │ +
} \
│ │ │ │ +
static std::string name() { return id; } \
│ │ │ │ +
}; \
│ │ │ │ +
} \
│ │ │ │ +
DUNE_INC_COUNTER(Tag)
│ │ │ │ +
#define DUNE_GET_COUNTER(Tag)
Definition counter.hh:17
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include <_d_u_n_e_/_i_s_t_l_/_b_c_r_s_m_a_t_r_i_x_._h_h>
│ │ │ │ │ -#include <_d_u_n_e_/_i_s_t_l_/_b_l_o_c_k_l_e_v_e_l_._h_h>
│ │ │ │ │ + * _c_o_m_m_o_n
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _M_a_c_r_o_s
│ │ │ │ │ +registry.hh File Reference
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include "_c_o_u_n_t_e_r_._h_h"
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -CCllaasssseess
│ │ │ │ │ - class _D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>
│ │ │ │ │ - A block-tridiagonal matrix. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _B_T_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>
│ │ │ │ │ -
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ -********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ -Implementation of the BTDMatrix class.
│ │ │ │ │ - Author
│ │ │ │ │ - Oliver Sander
│ │ │ │ │ +MMaaccrrooss
│ │ │ │ │ +#define _D_U_N_E___R_E_G_I_S_T_R_Y___P_U_T(Tag, id, ...)
│ │ │ │ │ +
│ │ │ │ │ +********** MMaaccrroo DDeeffiinniittiioonn DDooccuummeennttaattiioonn **********
│ │ │ │ │ +********** _?◆_? DDUUNNEE__RREEGGIISSTTRRYY__PPUUTT **********
│ │ │ │ │ +#define DUNE_REGISTRY_PUT ( Tag,
│ │ │ │ │ + id,
│ │ │ │ │ + ......
│ │ │ │ │ + )
│ │ │ │ │ +VVaalluuee::
│ │ │ │ │ +namespace { \
│ │ │ │ │ +template<> \
│ │ │ │ │ +struct Registry \
│ │ │ │ │ +{ \
│ │ │ │ │ +static auto getCreator() \
│ │ │ │ │ +{ \
│ │ │ │ │ +return __VA_ARGS__; \
│ │ │ │ │ +} \
│ │ │ │ │ +static std::string name() { return id; } \
│ │ │ │ │ +}; \
│ │ │ │ │ +} \
│ │ │ │ │ +DUNE_INC_COUNTER(Tag)
│ │ │ │ │ +_D_U_N_E___G_E_T___C_O_U_N_T_E_R
│ │ │ │ │ +#define DUNE_GET_COUNTER(Tag)
│ │ │ │ │ +DDeeffiinniittiioonn counter.hh:17
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00023_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: btdmatrix.hh Source File
│ │ │ │ +dune-istl: registry.hh Source File
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
5 #ifndef DUNE_ISTL_BTDMATRIX_HH
│ │ │ │ -
6 #define DUNE_ISTL_BTDMATRIX_HH
│ │ │ │ -
│ │ │ │ -
8 #include <dune/common/fmatrix.hh>
│ │ │ │ -
9 #include <dune/common/scalarvectorview.hh>
│ │ │ │ -
10 #include <dune/common/scalarmatrixview.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
3 #ifndef DUNE_ISTL_COMMON_REGISTRY_HH
│ │ │ │ +
4 #define DUNE_ISTL_COMMON_REGISTRY_HH
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
29 template <
class B,
class A=std::allocator<B> >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
37 using field_type =
typename Imp::BlockTraits<B>::field_type;
│ │ │ │ +
14 #include <dune/common/typelist.hh>
│ │ │ │ +
15 #include <dune/common/hybridutilities.hh>
│ │ │ │ +
16 #include <dune/common/parameterizedobject.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
18 #define DUNE_REGISTRY_PUT(Tag, id, ...) \
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
21 struct Registry<Tag, DUNE_GET_COUNTER(Tag)> \
│ │ │ │ +
│ │ │ │ +
23 static auto getCreator() \
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
27 static std::string name() { return id; } \
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
35 template <
class Tag, std::
size_t index>
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
59 for (
size_t i=0; i<size; i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
65 for (
size_t i=0; i<size; i++) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
79 auto nonZeros = (size==0) ? 0 : size + 2*(size-1);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
86 for (
size_t i=0; i<size; i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
92 for (
size_t i=0; i<size; i++) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
121 void solve (V& x,
const V& rhs)
const {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
125 auto && x0 = Impl::asVector(x[0]);
│ │ │ │ -
126 auto && rhs0 = Impl::asVector(rhs[0]);
│ │ │ │ -
127 Impl::asMatrix((*
this )[0][0]).solve(x0, rhs0);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
133 std::vector<block_type> c(this->
N ()-1);
│ │ │ │ -
134 for (
size_t i=0; i<this->
N ()-1; i++)
│ │ │ │ -
135 c[i] = (*
this )[i][i+1];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
139 Impl::asMatrix(a_00_inv).invert();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
143 Impl::asMatrix(tmp).rightmultiply(Impl::asMatrix(c[0]));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
148 auto && d_0 = Impl::asVector(d[0]);
│ │ │ │ -
149 Impl::asMatrix(a_00_inv).mv(Impl::asVector(d_0_tmp),d_0);
│ │ │ │ -
│ │ │ │ -
151 for (
unsigned int i = 1; i < this->
N (); i++) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
155 tmp = (*this)[i][i-1];
│ │ │ │ -
156 Impl::asMatrix(tmp).rightmultiply(Impl::asMatrix(c[i-1]));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
160 Impl::asMatrix(
id ).invert();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
163 Impl::asMatrix(c[i]).leftmultiply(Impl::asMatrix(
id ));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
167 auto && d_i = Impl::asVector(d[i]);
│ │ │ │ -
168 Impl::asMatrix((*
this )[i][i-1]).mmv(Impl::asVector(d[i-1]), d_i);
│ │ │ │ -
│ │ │ │ -
170 Impl::asMatrix(
id ).mv(Impl::asVector(tmpVec), d_i);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
174 x[this->
N () - 1] = d[this->
N () - 1];
│ │ │ │ -
175 for (
int i = this->
N () - 2; i >= 0; i--) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
178 auto && x_i = Impl::asVector(x[i]);
│ │ │ │ -
179 Impl::asMatrix(c[i]).mmv(Impl::asVector(x[i+1]), x_i);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
195 void endrowsizes () {}
│ │ │ │ -
│ │ │ │ -
197 void endindices () {}
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
200 template <
typename B,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
204 using real_type =
typename FieldTraits<field_type>::real_type;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
Implementation of the BCRSMatrix class.
│ │ │ │ -
Helper functions for determining the vector/matrix block level.
│ │ │ │ -
Col col
Definition matrixmatrix.hh:351
│ │ │ │ +
│ │ │ │ +
40 template <
template <
class >
class Base,
class V,
class Tag,
typename ... Args>
│ │ │ │ +
41 auto registryGet(Tag , std::string name, Args... args)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
44 std::shared_ptr<Base<V> > result;
│ │ │ │ +
45 Dune::Hybrid::forEach(std::make_index_sequence<count>{},
│ │ │ │ +
│ │ │ │ +
47 using Reg = Registry<Tag, index>;
│ │ │ │ +
48 if (!result && Reg::name() == name) {
│ │ │ │ +
49 result = Reg::getCreator()(Dune::MetaType<V>{}, args...);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
60 template <
class V,
class Type,
class Tag,
class ... Args>
│ │ │ │ +
61 int addRegistryToFactory(Dune::ParameterizedObjectFactory<Type(Args...), std::string>& factory,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
64 Dune::Hybrid::forEach(std::make_index_sequence<count>{},
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
69 using Reg = Registry<Tag, index>;
│ │ │ │ +
70 auto genericcreator = Reg::getCreator();
│ │ │ │ +
71 factory.define(Reg::name(), [genericcreator](Args... args){
│ │ │ │ +
72 return genericcreator(V{}, args...);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
#define DUNE_GET_COUNTER(Tag)
Definition counter.hh:17
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
A sparse block matrix with compressed row storage.
Definition bcrsmatrix.hh:466
│ │ │ │ -
void endrowsizes()
indicate that size of all rows is defined
Definition bcrsmatrix.hh:1146
│ │ │ │ -
@ random
Build entries randomly.
Definition bcrsmatrix.hh:526
│ │ │ │ -
void addindex(size_type row, size_type col)
add index (row,col) to the matrix
Definition bcrsmatrix.hh:1188
│ │ │ │ -
void endindices()
indicate that all indices are defined, check consistency
Definition bcrsmatrix.hh:1269
│ │ │ │ -
size_type N() const
number of rows (counted in blocks)
Definition bcrsmatrix.hh:2001
│ │ │ │ -
void setSize(size_type rows, size_type columns, size_type nnz=0)
Set the size of the matrix.
Definition bcrsmatrix.hh:858
│ │ │ │ -
BCRSMatrix & operator=(const BCRSMatrix &Mat)
assignment
Definition bcrsmatrix.hh:908
│ │ │ │ -
A block-tridiagonal matrix.
Definition btdmatrix.hh:31
│ │ │ │ -
BTDMatrix(size_type size)
Definition btdmatrix.hh:54
│ │ │ │ -
void solve(V &x, const V &rhs) const
Use the Thomas algorithm to solve the system Ax=b in O(n) time.
Definition btdmatrix.hh:121
│ │ │ │ -
A::size_type size_type
implement row_type with compressed vector
Definition btdmatrix.hh:49
│ │ │ │ -
A allocator_type
export the allocator type
Definition btdmatrix.hh:43
│ │ │ │ -
B block_type
export the type representing the components
Definition btdmatrix.hh:40
│ │ │ │ -
typename Imp::BlockTraits< B >::field_type field_type
export the type representing the field
Definition btdmatrix.hh:37
│ │ │ │ -
BTDMatrix & operator=(const BTDMatrix &other)
assignment
Definition btdmatrix.hh:104
│ │ │ │ -
BTDMatrix()
Default constructor.
Definition btdmatrix.hh:52
│ │ │ │ -
void setSize(size_type size)
Resize the matrix. Invalidates the content!
Definition btdmatrix.hh:77
│ │ │ │ -
typename FieldTraits< field_type >::real_type real_type
Definition btdmatrix.hh:204
│ │ │ │ -
typename BTDMatrix< B, A >::field_type field_type
Definition btdmatrix.hh:203
│ │ │ │
│ │ │ │ │ -9#include
│ │ │ │ │ -10#include
│ │ │ │ │ -11#include <_d_u_n_e_/_i_s_t_l_/_b_c_r_s_m_a_t_r_i_x_._h_h>
│ │ │ │ │ -12#include <_d_u_n_e_/_i_s_t_l_/_b_l_o_c_k_l_e_v_e_l_._h_h>
│ │ │ │ │ +3#ifndef DUNE_ISTL_COMMON_REGISTRY_HH
│ │ │ │ │ +4#define DUNE_ISTL_COMMON_REGISTRY_HH
│ │ │ │ │ +5
│ │ │ │ │ +6#include
│ │ │ │ │ +7#include
│ │ │ │ │ +8#include
│ │ │ │ │ +9#include
│ │ │ │ │ +10#include
│ │ │ │ │ +11
│ │ │ │ │ +12#include "_c_o_u_n_t_e_r_._h_h"
│ │ │ │ │ 13
│ │ │ │ │ -19namespace _D_u_n_e {
│ │ │ │ │ -29 template >
│ │ │ │ │ -_3_0 class _B_T_D_M_a_t_r_i_x : public _B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -31 {
│ │ │ │ │ -32 public:
│ │ │ │ │ -33
│ │ │ │ │ -34 //===== type definitions and constants
│ │ │ │ │ -35
│ │ │ │ │ -_3_7 using _f_i_e_l_d___t_y_p_e = typename Imp::BlockTraits::field_type;
│ │ │ │ │ +14#include
│ │ │ │ │ +15#include
│ │ │ │ │ +16#include
│ │ │ │ │ +17
│ │ │ │ │ +_1_8#define DUNE_REGISTRY_PUT(Tag, id, ...) \
│ │ │ │ │ +19 namespace { \
│ │ │ │ │ +20 template<> \
│ │ │ │ │ +21 struct Registry \
│ │ │ │ │ +22 { \
│ │ │ │ │ +23 static auto getCreator() \
│ │ │ │ │ +24 { \
│ │ │ │ │ +25 return __VA_ARGS__; \
│ │ │ │ │ +26 } \
│ │ │ │ │ +27 static std::string name() { return id; } \
│ │ │ │ │ +28 }; \
│ │ │ │ │ +29 } \
│ │ │ │ │ +30 DUNE_INC_COUNTER(Tag)
│ │ │ │ │ +31
│ │ │ │ │ +32
│ │ │ │ │ +33namespace _D_u_n_e {
│ │ │ │ │ +34 namespace {
│ │ │ │ │ +35 template
│ │ │ │ │ +36 struct Registry;
│ │ │ │ │ +37 }
│ │ │ │ │ 38
│ │ │ │ │ -_4_0 typedef B _b_l_o_c_k___t_y_p_e;
│ │ │ │ │ -41
│ │ │ │ │ -_4_3 typedef A _a_l_l_o_c_a_t_o_r___t_y_p_e;
│ │ │ │ │ -44
│ │ │ │ │ -46 //typedef BCRSMatrix::row_type row_type;
│ │ │ │ │ -47
│ │ │ │ │ -_4_9 typedef typename A::size_type _s_i_z_e___t_y_p_e;
│ │ │ │ │ -50
│ │ │ │ │ -_5_2 _B_T_D_M_a_t_r_i_x() : _B_C_R_S_M_a_t_r_i_x() {}
│ │ │ │ │ -53
│ │ │ │ │ -_5_4 explicit _B_T_D_M_a_t_r_i_x(_s_i_z_e___t_y_p_e size)
│ │ │ │ │ -55 : _B_C_R_S_M_a_t_r_i_x(size, size, _B_C_R_S_M_a_t_r_i_x::_r_a_n_d_o_m)
│ │ │ │ │ -56 {
│ │ │ │ │ -57 // Set number of entries for each row
│ │ │ │ │ -58 // All rows get three entries, except for the first and the last one
│ │ │ │ │ -59 for (size_t i=0; i_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_s_e_t_r_o_w_s_i_z_e(i, 3 - (i==0) - (i==(size-1)));
│ │ │ │ │ -61
│ │ │ │ │ -62 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_r_o_w_s_i_z_e_s();
│ │ │ │ │ -63
│ │ │ │ │ -64 // The actual entries for each row
│ │ │ │ │ -65 for (size_t i=0; i0)
│ │ │ │ │ -67 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i-1);
│ │ │ │ │ -68 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i );
│ │ │ │ │ -69 if (i_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i+1);
│ │ │ │ │ -71 }
│ │ │ │ │ -72
│ │ │ │ │ -73 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_i_n_d_i_c_e_s();
│ │ │ │ │ -74 }
│ │ │ │ │ -75
│ │ │ │ │ -_7_7 void _s_e_t_S_i_z_e(size_type size)
│ │ │ │ │ -78 {
│ │ │ │ │ -79 auto nonZeros = (size==0) ? 0 : size + 2*(size-1);
│ │ │ │ │ -80 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_s_e_t_S_i_z_e(size, // rows
│ │ │ │ │ -81 size, // columns
│ │ │ │ │ -82 nonZeros);
│ │ │ │ │ -83
│ │ │ │ │ -84 // Set number of entries for each row
│ │ │ │ │ -85 // All rows get three entries, except for the first and the last one
│ │ │ │ │ -86 for (size_t i=0; i_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_s_e_t_r_o_w_s_i_z_e(i, 3 - (i==0) - (i==(size-1)));
│ │ │ │ │ -88
│ │ │ │ │ -89 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_r_o_w_s_i_z_e_s();
│ │ │ │ │ -90
│ │ │ │ │ -91 // The actual entries for each row
│ │ │ │ │ -92 for (size_t i=0; i0)
│ │ │ │ │ -94 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i-1);
│ │ │ │ │ -95 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i );
│ │ │ │ │ -96 if (i_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i+1);
│ │ │ │ │ -98 }
│ │ │ │ │ -99
│ │ │ │ │ -100 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_i_n_d_i_c_e_s();
│ │ │ │ │ -101 }
│ │ │ │ │ -102
│ │ │ │ │ -_1_0_4 _B_T_D_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_=_ (const _B_T_D_M_a_t_r_i_x& other) {
│ │ │ │ │ -105 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_o_p_e_r_a_t_o_r_=(other);
│ │ │ │ │ -106 return *this;
│ │ │ │ │ -107 }
│ │ │ │ │ -108
│ │ │ │ │ -_1_1_0 _B_T_D_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_=_ (const _f_i_e_l_d___t_y_p_e& k) {
│ │ │ │ │ -111 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_o_p_e_r_a_t_o_r_=(k);
│ │ │ │ │ -112 return *this;
│ │ │ │ │ -113 }
│ │ │ │ │ -114
│ │ │ │ │ -120 template
│ │ │ │ │ -_1_2_1 void _s_o_l_v_e (V& x, const V& rhs) const {
│ │ │ │ │ -122
│ │ │ │ │ -123 // special handling for 1x1 matrices. The generic algorithm doesn't work
│ │ │ │ │ -for them
│ │ │ │ │ -124 if (this->_N()==1) {
│ │ │ │ │ -125 auto&& x0 = Impl::asVector(x[0]);
│ │ │ │ │ -126 auto&& rhs0 = Impl::asVector(rhs[0]);
│ │ │ │ │ -127 Impl::asMatrix((*this)[0][0]).solve(x0, rhs0);
│ │ │ │ │ -128 return;
│ │ │ │ │ -129 }
│ │ │ │ │ -130
│ │ │ │ │ -131 // Make copies of the rhs and the right matrix band
│ │ │ │ │ -132 V d = rhs;
│ │ │ │ │ -133 std::vector c(this->_N()-1);
│ │ │ │ │ -134 for (size_t i=0; i_N()-1; i++)
│ │ │ │ │ -135 c[i] = (*this)[i][i+1];
│ │ │ │ │ -136
│ │ │ │ │ -137 /* Modify the coefficients. */
│ │ │ │ │ -138 _b_l_o_c_k___t_y_p_e a_00_inv = (*this)[0][0];
│ │ │ │ │ -139 Impl::asMatrix(a_00_inv).invert();
│ │ │ │ │ -140
│ │ │ │ │ -141 //c[0] /= (*this)[0][0]; /* Division by zero risk. */
│ │ │ │ │ -142 _b_l_o_c_k___t_y_p_e tmp = a_00_inv;
│ │ │ │ │ -143 Impl::asMatrix(tmp).rightmultiply(Impl::asMatrix(c[0]));
│ │ │ │ │ -144 c[0] = tmp;
│ │ │ │ │ -145
│ │ │ │ │ -146 // d = a^{-1} d /* Division by zero would imply a singular matrix. */
│ │ │ │ │ -147 auto d_0_tmp = d[0];
│ │ │ │ │ -148 auto&& d_0 = Impl::asVector(d[0]);
│ │ │ │ │ -149 Impl::asMatrix(a_00_inv).mv(Impl::asVector(d_0_tmp),d_0);
│ │ │ │ │ -150
│ │ │ │ │ -151 for (unsigned int i = 1; i < this->_N(); i++) {
│ │ │ │ │ -152
│ │ │ │ │ -153 // id = ( a_ii - c_{i-1} a_{i, i-1} ) ^{-1}
│ │ │ │ │ -154 _b_l_o_c_k___t_y_p_e tmp;
│ │ │ │ │ -155 tmp = (*this)[i][i-1];
│ │ │ │ │ -156 Impl::asMatrix(tmp).rightmultiply(Impl::asMatrix(c[i-1]));
│ │ │ │ │ -157
│ │ │ │ │ -158 _b_l_o_c_k___t_y_p_e id = (*this)[i][i];
│ │ │ │ │ -159 id -= tmp;
│ │ │ │ │ -160 Impl::asMatrix(id).invert(); /* Division by zero risk. */
│ │ │ │ │ -161
│ │ │ │ │ -162 if (i_N() - 1] = d[this->_N() - 1];
│ │ │ │ │ -175 for (int i = this->_N() - 2; i >= 0; i--) {
│ │ │ │ │ -176 //x[i] = d[i] - c[i] * x[i + 1];
│ │ │ │ │ -177 x[i] = d[i];
│ │ │ │ │ -178 auto&& x_i = Impl::asVector(x[i]);
│ │ │ │ │ -179 Impl::asMatrix(c[i]).mmv(Impl::asVector(x[i+1]), x_i);
│ │ │ │ │ -180 }
│ │ │ │ │ -181
│ │ │ │ │ -182 }
│ │ │ │ │ -183
│ │ │ │ │ -184 private:
│ │ │ │ │ -185
│ │ │ │ │ -186 // ////////////////////////////////////////////////////////////////////////
│ │ │ │ │ -////
│ │ │ │ │ -187 // The following methods from the base class should now actually be called
│ │ │ │ │ -188 // ////////////////////////////////////////////////////////////////////////
│ │ │ │ │ -////
│ │ │ │ │ -189
│ │ │ │ │ -190 // createbegin and createend should be in there, too, but I can't get it to
│ │ │ │ │ -compile
│ │ │ │ │ -191 // BCRSMatrix::CreateIterator createbegin () {}
│ │ │ │ │ -192 // BCRSMatrix::CreateIterator createend () {}
│ │ │ │ │ -193 void setrowsize (_s_i_z_e___t_y_p_e i, _s_i_z_e___t_y_p_e s) {}
│ │ │ │ │ -194 void incrementrowsize (_s_i_z_e___t_y_p_e i) {}
│ │ │ │ │ -195 void endrowsizes () {}
│ │ │ │ │ -196 void addindex (_s_i_z_e___t_y_p_e row, _s_i_z_e___t_y_p_e _c_o_l) {}
│ │ │ │ │ -197 void endindices () {}
│ │ │ │ │ -198 };
│ │ │ │ │ -199
│ │ │ │ │ -200 template
│ │ │ │ │ -_2_0_1 struct FieldTraits< _B_T_D_M_a_t_r_i_x >
│ │ │ │ │ -202 {
│ │ │ │ │ -_2_0_3 using _f_i_e_l_d___t_y_p_e = typename _B_T_D_M_a_t_r_i_x_<_B_,_ _A_>_:_:_f_i_e_l_d___t_y_p_e;
│ │ │ │ │ -_2_0_4 using _r_e_a_l___t_y_p_e = typename FieldTraits::real_type;
│ │ │ │ │ -205 };
│ │ │ │ │ -206
│ │ │ │ │ -209} // end namespace Dune
│ │ │ │ │ -210
│ │ │ │ │ -211#endif
│ │ │ │ │ -_b_c_r_s_m_a_t_r_i_x_._h_h
│ │ │ │ │ -Implementation of the BCRSMatrix class.
│ │ │ │ │ -_b_l_o_c_k_l_e_v_e_l_._h_h
│ │ │ │ │ -Helper functions for determining the vector/matrix block level.
│ │ │ │ │ -_c_o_l
│ │ │ │ │ -Col col
│ │ │ │ │ -DDeeffiinniittiioonn matrixmatrix.hh:351
│ │ │ │ │ +39 namespace {
│ │ │ │ │ +40 template class Base, class V, class Tag, typename... Args>
│ │ │ │ │ +41 auto registryGet(Tag , std::string name, Args... args)
│ │ │ │ │ +42 {
│ │ │ │ │ +43 constexpr auto count = _D_U_N_E___G_E_T___C_O_U_N_T_E_R(Tag);
│ │ │ │ │ +44 std::shared_ptr > result;
│ │ │ │ │ +45 Dune::Hybrid::forEach(std::make_index_sequence{},
│ │ │ │ │ +46 [&](auto index) {
│ │ │ │ │ +47 using Reg = Registry;
│ │ │ │ │ +48 if(!result && Reg::name() == name) {
│ │ │ │ │ +49 result = Reg::getCreator()(Dune::MetaType{}, args...);
│ │ │ │ │ +50 }
│ │ │ │ │ +51 });
│ │ │ │ │ +52 return result;
│ │ │ │ │ +53 }
│ │ │ │ │ +54
│ │ │ │ │ +55 /*
│ │ │ │ │ +56 Register all creators from the registry in the Parameterizedobjectfactory An
│ │ │ │ │ +57 object of V is passed in the creator and should be used to determine the
│ │ │ │ │ +58 template arguments.
│ │ │ │ │ +59 */
│ │ │ │ │ +60 template
│ │ │ │ │ +61 int addRegistryToFactory(Dune::ParameterizedObjectFactory& factory,
│ │ │ │ │ +62 Tag){
│ │ │ │ │ +63 constexpr auto count = _D_U_N_E___G_E_T___C_O_U_N_T_E_R(Tag);
│ │ │ │ │ +64 Dune::Hybrid::forEach(std::make_index_sequence{},
│ │ │ │ │ +65 [&](auto index) {
│ │ │ │ │ +66 // we first get the generic lambda
│ │ │ │ │ +67 // and later specialize it with given parameters.
│ │ │ │ │ +68 // doing all at once leads to an ICE with g++-6
│ │ │ │ │ +69 using Reg = Registry;
│ │ │ │ │ +70 auto genericcreator = Reg::getCreator();
│ │ │ │ │ +71 factory.define(Reg::name(), [genericcreator](Args... args){
│ │ │ │ │ +72 return genericcreator(V{}, args...);
│ │ │ │ │ +73 });
│ │ │ │ │ +74 });
│ │ │ │ │ +75 return count;
│ │ │ │ │ +76 }
│ │ │ │ │ +77 } // end anonymous namespace
│ │ │ │ │ +78} // end namespace Dune
│ │ │ │ │ +79
│ │ │ │ │ +80#endif // DUNE_ISTL_COMMON_REGISTRY_HH
│ │ │ │ │ +_c_o_u_n_t_e_r_._h_h
│ │ │ │ │ +_D_U_N_E___G_E_T___C_O_U_N_T_E_R
│ │ │ │ │ +#define DUNE_GET_COUNTER(Tag)
│ │ │ │ │ +DDeeffiinniittiioonn counter.hh:17
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn allocator.hh:11
│ │ │ │ │ -_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_:_:_e_n_d_r_o_w_s_i_z_e_s
│ │ │ │ │ -void endrowsizes()
│ │ │ │ │ -indicate that size of all rows is defined
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1146
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_r_a_n_d_o_m
│ │ │ │ │ -@ random
│ │ │ │ │ -Build entries randomly.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:526
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a_d_d_i_n_d_e_x
│ │ │ │ │ -void addindex(size_type row, size_type col)
│ │ │ │ │ -add index (row,col) to the matrix
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1188
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_e_n_d_i_n_d_i_c_e_s
│ │ │ │ │ -void endindices()
│ │ │ │ │ -indicate that all indices are defined, check consistency
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1269
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_N
│ │ │ │ │ -size_type N() const
│ │ │ │ │ -number of rows (counted in blocks)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2001
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_S_i_z_e
│ │ │ │ │ -void setSize(size_type rows, size_type columns, size_type nnz=0)
│ │ │ │ │ -Set the size of the matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:858
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ -BCRSMatrix & operator=(const BCRSMatrix &Mat)
│ │ │ │ │ -assignment
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:908
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x
│ │ │ │ │ -A block-tridiagonal matrix.
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:31
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_:_:_B_T_D_M_a_t_r_i_x
│ │ │ │ │ -BTDMatrix(size_type size)
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:54
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_:_:_s_o_l_v_e
│ │ │ │ │ -void solve(V &x, const V &rhs) const
│ │ │ │ │ -Use the Thomas algorithm to solve the system Ax=b in O(n) time.
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:121
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ -A::size_type size_type
│ │ │ │ │ -implement row_type with compressed vector
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:49
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_:_:_a_l_l_o_c_a_t_o_r___t_y_p_e
│ │ │ │ │ -A allocator_type
│ │ │ │ │ -export the allocator type
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:43
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_:_:_b_l_o_c_k___t_y_p_e
│ │ │ │ │ -B block_type
│ │ │ │ │ -export the type representing the components
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:40
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ -typename Imp::BlockTraits< B >::field_type field_type
│ │ │ │ │ -export the type representing the field
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:37
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ -BTDMatrix & operator=(const BTDMatrix &other)
│ │ │ │ │ -assignment
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:104
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_:_:_B_T_D_M_a_t_r_i_x
│ │ │ │ │ -BTDMatrix()
│ │ │ │ │ -Default constructor.
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:52
│ │ │ │ │ -_D_u_n_e_:_:_B_T_D_M_a_t_r_i_x_:_:_s_e_t_S_i_z_e
│ │ │ │ │ -void setSize(size_type size)
│ │ │ │ │ -Resize the matrix. Invalidates the content!
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:77
│ │ │ │ │ -_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _B_T_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_r_e_a_l___t_y_p_e
│ │ │ │ │ -typename FieldTraits< field_type >::real_type real_type
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:204
│ │ │ │ │ -_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _B_T_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ -typename BTDMatrix< B, A >::field_type field_type
│ │ │ │ │ -DDeeffiinniittiioonn btdmatrix.hh:203
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00026.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: vbvector.hh File Reference
│ │ │ │ +dune-istl: bdmatrix.hh File Reference
│ │ │ │ dune istl
│ │ │ │
│ │ │ │ -
???
│ │ │ │ +
Implementation of the BDMatrix class.
│ │ │ │ More...
│ │ │ │ -
#include <cmath>
│ │ │ │ -
#include <complex>
│ │ │ │ -
#include <iostream>
│ │ │ │ -
#include <iterator>
│ │ │ │ -
#include <memory>
│ │ │ │ -
#include <dune/common/ftraits.hh>
│ │ │ │ -
#include <dune/common/indexediterator.hh>
│ │ │ │ -
#include <dune/common/iteratorfacades.hh>
│ │ │ │ -
#include "istlexception.hh "
│ │ │ │ -
#include "bvector.hh "
│ │ │ │ -
#include <dune/istl/blocklevel.hh >
│ │ │ │ +
#include <memory>
│ │ │ │ +
#include <dune/common/rangeutilities.hh>
│ │ │ │ +
#include <dune/common/scalarmatrixview.hh>
│ │ │ │ +
#include <dune/istl/bcrsmatrix.hh >
│ │ │ │ +
#include <dune/istl/blocklevel.hh >
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ namespace Dune
│ │ │ │
│ │ │ │ -
???
│ │ │ │ +
Implementation of the BDMatrix class.
│ │ │ │ +
Author Oliver Sander
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,37 +1,30 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ 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
│ │ │ │ │ -vbvector.hh File Reference
│ │ │ │ │ -??? _M_o_r_e_._._.
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +bdmatrix.hh File Reference
│ │ │ │ │ +Implementation of the BDMatrix class. _M_o_r_e_._._.
│ │ │ │ │ #include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include "_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h"
│ │ │ │ │ -#include "_b_v_e_c_t_o_r_._h_h"
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_b_c_r_s_m_a_t_r_i_x_._h_h>
│ │ │ │ │ #include <_d_u_n_e_/_i_s_t_l_/_b_l_o_c_k_l_e_v_e_l_._h_h>
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ CCllaasssseess
│ │ │ │ │ - class _D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_<_ _B_,_ _A_ _>
│ │ │ │ │ - A Vector of blocks with different blocksizes. _M_o_r_e_._._.
│ │ │ │ │ + class _D_u_n_e_:_:_B_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>
│ │ │ │ │ + A block-diagonal matrix. _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ - class _D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_<_ _B_,_ _A_ _>_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r
│ │ │ │ │ - Iterator class for sequential creation of blocks. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_<_ _B_,_ _A_ _>_ _>
│ │ │ │ │ +struct _D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _B_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>
│ │ │ │ │
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ ********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ -???
│ │ │ │ │ +Implementation of the BDMatrix class.
│ │ │ │ │ + Author
│ │ │ │ │ + Oliver Sander
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00026_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: vbvector.hh Source File
│ │ │ │ +dune-istl: bdmatrix.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_ISTL_VBVECTOR_HH
│ │ │ │ -
6 #define DUNE_ISTL_VBVECTOR_HH
│ │ │ │ +
5 #ifndef DUNE_ISTL_BDMATRIX_HH
│ │ │ │ +
6 #define DUNE_ISTL_BDMATRIX_HH
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
14 #include <dune/common/ftraits.hh>
│ │ │ │ -
15 #include <dune/common/indexediterator.hh>
│ │ │ │ -
16 #include <dune/common/iteratorfacades.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
43 template <
class B,
class A=std::allocator<B> >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
49 using Base = Imp::block_vector_unmanaged<B,typename A::size_type>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
52 using window_type = Imp::BlockVectorWindow<B,A>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
55 using VectorWindows = std::vector<window_type, typename std::allocator_traits<A>::template rebind_alloc<window_type>>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
58 static_assert (not std::is_same_v<B,bool>,
"Block type 'bool' not supported by VariableBlockVector." );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
10 #include <dune/common/rangeutilities.hh>
│ │ │ │ +
11 #include <dune/common/scalarmatrixview.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
31 template <
class B,
class A=std::allocator<B> >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
39 using field_type =
typename Imp::BlockTraits<B>::field_type;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
59 for (
int i=0; i<size; i++)
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
65 using field_type =
typename Imp::BlockTraits<B>::field_type;
│ │ │ │ +
64 for (
int i=0; i<size; i++)
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
72 BDMatrix (std::initializer_list<B>
const &list)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
76 for (
auto it = list.begin(); it != list.end(); ++it, ++i)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
87 for (
auto i : range(size))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
92 for (
auto i : range(size))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
128 storage_(numBlocks*blockSize)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
116 void solve (V& x,
const V& rhs)
const {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
119 auto && xv = Impl::asVector(x[i]);
│ │ │ │ +
120 auto && rhsv = Impl::asVector(rhs[i]);
│ │ │ │ +
121 Impl::asMatrix((*
this )[i][i]).solve(xv,rhsv);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
128 Impl::asMatrix((*
this )[i][i]).
invert ();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
135 block[i].set(blockSize,this->p+(i*blockSize));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
143 Base(static_cast<const Base&>(a)),
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
150 if (block.size()>0) {
│ │ │ │ -
151 block[0].set(block[0].getsize(),this->p);
│ │ │ │ -
│ │ │ │ -
153 block[i].set(block[i].getsize(),block[i-1].getptr()+block[i-1].getsize());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
157 initialized = a.initialized;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
181 swap (storage_, other.storage_);
│ │ │ │ -
182 swap (block, other.block);
│ │ │ │ -
183 swap (initialized, other.initialized);
│ │ │ │ -
│ │ │ │ -
185 other.syncBaseArray();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
203 block.resize(numBlocks);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
213 storage_.resize(numBlocks*blockSize);
│ │ │ │ -
214 block.resize(numBlocks);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
219 block[i].set(blockSize,this->p+(i*blockSize));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
230 (
static_cast< Imp::block_vector_unmanaged<B,size_type>&
> (*this)) = k;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
237 class CreateIterator;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
249 operator size_type ()
const
│ │ │ │ -
│ │ │ │ -
251 return target->getsize();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
254 SizeProxy& operator= (size_type size)
│ │ │ │ -
│ │ │ │ -
256 target->setsize(size);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
262 friend class CreateIterator;
│ │ │ │ -
│ │ │ │ -
264 SizeProxy (window_type& t) :
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
311 if (not isEnd && i==v.block.size() && not v.initialized)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
335 return (i!=it.i) || (&v!=&it.v);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
341 return (i==it.i) && (&v==&it.v);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
353 v.block[i].setsize(_k);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
379 #ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ -
380 if (initialized) DUNE_THROW(
ISTLError ,
"no CreateIterator in initialized state" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
399 #ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ -
400 if (i>=block.size()) DUNE_THROW(
ISTLError ,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
408 #ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ -
409 if (i<0 || i>=block.size()) DUNE_THROW(
ISTLError ,
"index out of range" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
414 using Iterator = IndexedIterator<typename VectorWindows::iterator>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
446 using ConstIterator = IndexedIterator<typename VectorWindows::const_iterator>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
487 tmp+=std::min(i, block.size());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
495 tmp+=std::min(i, block.size());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
521 if (this->initialized)
│ │ │ │ -
522 DUNE_THROW(
ISTLError ,
"Attempt to re-allocate already initialized VariableBlockVector" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
526 for (
size_type i = 0; i < block.size(); i++)
│ │ │ │ -
527 storageNeeded += block[i].
size ();
│ │ │ │ -
│ │ │ │ -
529 storage_.resize(storageNeeded);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
533 block[0].setptr(this->p);
│ │ │ │ -
│ │ │ │ -
535 block[j].setptr(block[j-1].getptr()+block[j-1].getsize());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
538 this->initialized =
true ;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
541 void syncBaseArray () noexcept
│ │ │ │ -
│ │ │ │ -
543 this->p = storage_.data();
│ │ │ │ -
544 this->n = storage_.size();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
547 VectorWindows block = {};
│ │ │ │ -
548 std::vector<B, A> storage_ = {};
│ │ │ │ -
549 bool initialized =
false ;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
555 template <
class B,
class A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
This file implements a vector space as a tensor product of a given vector space. The number of compon...
│ │ │ │ -
│ │ │ │ -
Helper functions for determining the vector/matrix block level.
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
142 void endrowsizes () {}
│ │ │ │ +
│ │ │ │ +
144 void endindices () {}
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
147 template <
typename B,
typename A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
151 using real_type =
typename FieldTraits<field_type>::real_type;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Implementation of the BCRSMatrix class.
│ │ │ │ +
Helper functions for determining the vector/matrix block level.
│ │ │ │ +
Col col
Definition matrixmatrix.hh:351
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
A vector of blocks with memory management.
Definition bvector.hh:392
│ │ │ │ -
derive error class from the base class in common
Definition istlexception.hh:19
│ │ │ │ -
A Vector of blocks with different blocksizes.
Definition vbvector.hh:48
│ │ │ │ -
VariableBlockVector(size_type numBlocks, size_type blockSize)
Construct a vector with given number of blocks each having a constant size.
Definition vbvector.hh:125
│ │ │ │ -
VariableBlockVector()
Constructor without arguments makes an empty vector.
Definition vbvector.hh:102
│ │ │ │ -
friend void swap(VariableBlockVector &lhs, VariableBlockVector &rhs) noexcept
Free function to swap the storage and internal state of lhs with rhs.
Definition vbvector.hh:190
│ │ │ │ -
Iterator iterator
Export the iterator type using std naming rules.
Definition vbvector.hh:443
│ │ │ │ -
VariableBlockVector & operator=(VariableBlockVector tmp)
Copy and move assignment.
Definition vbvector.hh:171
│ │ │ │ -
VariableBlockVector(size_type numBlocks)
Construct a vector with given number of blocks, but size of each block is not yet known.
Definition vbvector.hh:112
│ │ │ │ -
typename Imp::BlockTraits< B >::field_type field_type
export the type representing the field
Definition vbvector.hh:65
│ │ │ │ -
typename A::size_type size_type
The size type for the index access.
Definition vbvector.hh:83
│ │ │ │ -
size_type N() const noexcept
number of blocks in the vector (are of variable size here)
Definition vbvector.hh:502
│ │ │ │ -
VariableBlockVector(const VariableBlockVector &a)
Copy constructor, has copy semantics.
Definition vbvector.hh:142
│ │ │ │ -
window_type & operator[](size_type i)
random access to blocks
Definition vbvector.hh:397
│ │ │ │ -
A allocator_type
export the allocator type
Definition vbvector.hh:68
│ │ │ │ -
CreateIterator createend()
get create iterator pointing to one after the last block
Definition vbvector.hh:386
│ │ │ │ -
VariableBlockVector(VariableBlockVector &&tmp)
Move constructor:
Definition vbvector.hh:161
│ │ │ │ -
CreateIterator createbegin()
get initial create iterator
Definition vbvector.hh:377
│ │ │ │ -
ConstIterator const_iterator
Export the const iterator type using std naming rules.
Definition vbvector.hh:449
│ │ │ │ -
window_type & reference
Export type used for references to container entries.
Definition vbvector.hh:74
│ │ │ │ -
ConstIterator rend() const
end ConstIterator
Definition vbvector.hh:478
│ │ │ │ -
const window_type & const_reference
Export type used for const references to container entries.
Definition vbvector.hh:80
│ │ │ │ -
ConstIterator find(size_type i) const
random access returning iterator (end if not contained)
Definition vbvector.hh:492
│ │ │ │ -
ConstIterator beforeEnd() const
Definition vbvector.hh:465
│ │ │ │ -
Iterator find(size_type i)
random access returning iterator (end if not contained)
Definition vbvector.hh:484
│ │ │ │ -
IndexedIterator< typename VectorWindows::const_iterator > ConstIterator
Const iterator.
Definition vbvector.hh:446
│ │ │ │ -
~VariableBlockVector()=default
│ │ │ │ -
ConstIterator beforeBegin() const
Definition vbvector.hh:472
│ │ │ │ -
void resize(size_type numBlocks)
same effect as constructor with same argument
Definition vbvector.hh:196
│ │ │ │ -
Iterator end()
end Iterator
Definition vbvector.hh:423
│ │ │ │ -
void swap(VariableBlockVector &other) noexcept
Exchange the storage and internal state with other.
Definition vbvector.hh:178
│ │ │ │ -
ConstIterator begin() const
begin ConstIterator
Definition vbvector.hh:452
│ │ │ │ -
size_type size() const noexcept
Definition vbvector.hh:511
│ │ │ │ -
void resize(size_type numBlocks, size_type blockSize)
same effect as constructor with same argument
Definition vbvector.hh:210
│ │ │ │ -
IndexedIterator< typename VectorWindows::iterator > Iterator
Definition vbvector.hh:414
│ │ │ │ -
ConstIterator end() const
end ConstIterator
Definition vbvector.hh:458
│ │ │ │ -
Iterator beforeBegin()
Definition vbvector.hh:437
│ │ │ │ -
Iterator beforeEnd()
Definition vbvector.hh:430
│ │ │ │ -
Iterator begin()
begin Iterator
Definition vbvector.hh:417
│ │ │ │ -
Iterator class for sequential creation of blocks.
Definition vbvector.hh:275
│ │ │ │ -
bool operator==(const CreateIterator &it) const
equality
Definition vbvector.hh:339
│ │ │ │ -
size_type index() const
dereferencing
Definition vbvector.hh:345
│ │ │ │ -
SizeProxy reference
reference type
Definition vbvector.hh:295
│ │ │ │ -
size_type * pointer
pointer type
Definition vbvector.hh:292
│ │ │ │ -
bool operator!=(const CreateIterator &it) const
inequality
Definition vbvector.hh:333
│ │ │ │ -
~CreateIterator()
Definition vbvector.hh:304
│ │ │ │ -
size_type value_type
value type
Definition vbvector.hh:281
│ │ │ │ -
CreateIterator(VariableBlockVector &_v, int _i, bool _isEnd)
constructor
Definition vbvector.hh:298
│ │ │ │ -
void setblocksize(size_type _k)
set size of current block
Definition vbvector.hh:351
│ │ │ │ -
size_type & operator*()
Access size of current block.
Definition vbvector.hh:362
│ │ │ │ -
std::output_iterator_tag iterator_category
iterator category
Definition vbvector.hh:278
│ │ │ │ -
CreateIterator & operator++()
prefix increment
Definition vbvector.hh:316
│ │ │ │ -
void difference_type
difference type (unused)
Definition vbvector.hh:289
│ │ │ │ -
FieldTraits< B >::real_type real_type
Definition vbvector.hh:559
│ │ │ │ -
FieldTraits< B >::field_type field_type
Definition vbvector.hh:558
│ │ │ │ +
A sparse block matrix with compressed row storage.
Definition bcrsmatrix.hh:466
│ │ │ │ +
void endrowsizes()
indicate that size of all rows is defined
Definition bcrsmatrix.hh:1146
│ │ │ │ +
@ random
Build entries randomly.
Definition bcrsmatrix.hh:526
│ │ │ │ +
void endindices()
indicate that all indices are defined, check consistency
Definition bcrsmatrix.hh:1269
│ │ │ │ +
size_type N() const
number of rows (counted in blocks)
Definition bcrsmatrix.hh:2001
│ │ │ │ +
void setSize(size_type rows, size_type columns, size_type nnz=0)
Set the size of the matrix.
Definition bcrsmatrix.hh:858
│ │ │ │ +
BCRSMatrix & operator=(const BCRSMatrix &Mat)
assignment
Definition bcrsmatrix.hh:908
│ │ │ │ +
A block-diagonal matrix.
Definition bdmatrix.hh:33
│ │ │ │ +
typename Imp::BlockTraits< B >::field_type field_type
export the type representing the field
Definition bdmatrix.hh:39
│ │ │ │ +
A::size_type size_type
implement row_type with compressed vector
Definition bdmatrix.hh:51
│ │ │ │ +
BDMatrix()
Default constructor.
Definition bdmatrix.hh:54
│ │ │ │ +
BDMatrix(std::initializer_list< B > const &list)
Construct from a std::initializer_list.
Definition bdmatrix.hh:72
│ │ │ │ +
B block_type
export the type representing the components
Definition bdmatrix.hh:42
│ │ │ │ +
void solve(V &x, const V &rhs) const
Solve the system Ax=b in O(n) time.
Definition bdmatrix.hh:116
│ │ │ │ +
A allocator_type
export the allocator type
Definition bdmatrix.hh:45
│ │ │ │ +
BDMatrix(int size)
Definition bdmatrix.hh:56
│ │ │ │ +
BDMatrix & operator=(const BDMatrix &other)
assignment
Definition bdmatrix.hh:99
│ │ │ │ +
void setSize(size_type size)
Resize the matrix. Invalidates the content!
Definition bdmatrix.hh:81
│ │ │ │ +
void invert()
Inverts the matrix.
Definition bdmatrix.hh:126
│ │ │ │ +
typename BDMatrix< B, A >::field_type field_type
Definition bdmatrix.hh:150
│ │ │ │ +
typename FieldTraits< field_type >::real_type real_type
Definition bdmatrix.hh:151
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,685 +1,227 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -vbvector.hh
│ │ │ │ │ +bdmatrix.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 © 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_VBVECTOR_HH
│ │ │ │ │ -6#define DUNE_ISTL_VBVECTOR_HH
│ │ │ │ │ +5#ifndef DUNE_ISTL_BDMATRIX_HH
│ │ │ │ │ +6#define DUNE_ISTL_BDMATRIX_HH
│ │ │ │ │ 7
│ │ │ │ │ -8#include
│ │ │ │ │ -9#include
│ │ │ │ │ -10#include
│ │ │ │ │ -11#include
│ │ │ │ │ -12#include
│ │ │ │ │ -13
│ │ │ │ │ -14#include
│ │ │ │ │ -15#include
│ │ │ │ │ -16#include
│ │ │ │ │ -17#include "_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h"
│ │ │ │ │ -18#include "_b_v_e_c_t_o_r_._h_h"
│ │ │ │ │ -19
│ │ │ │ │ -20#include <_d_u_n_e_/_i_s_t_l_/_b_l_o_c_k_l_e_v_e_l_._h_h>
│ │ │ │ │ -21
│ │ │ │ │ -26namespace _D_u_n_e {
│ │ │ │ │ -27
│ │ │ │ │ -43 template >
│ │ │ │ │ -_4_4 class _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r : public Imp::block_vector_unmanaged
│ │ │ │ │ -45 // this derivation gives us all the blas level 1 and norms
│ │ │ │ │ -46 // on the large array. However, access operators have to be
│ │ │ │ │ -47 // overwritten.
│ │ │ │ │ -48 {
│ │ │ │ │ -49 using Base = Imp::block_vector_unmanaged;
│ │ │ │ │ -50
│ │ │ │ │ -51 // just a shorthand
│ │ │ │ │ -52 using window_type = Imp::BlockVectorWindow;
│ │ │ │ │ -53
│ │ │ │ │ -54 // data-structure holding the windows (but not the actual data)
│ │ │ │ │ -55 using VectorWindows = std::vector::template rebind_alloc>;
│ │ │ │ │ -56
│ │ │ │ │ -57 // block type bool is not supported since std::vector is used for
│ │ │ │ │ -storage
│ │ │ │ │ -58 static_assert(not std::is_same_v, "Block type 'bool' not supported
│ │ │ │ │ -by VariableBlockVector.");
│ │ │ │ │ -59
│ │ │ │ │ -60 public:
│ │ │ │ │ +8#include
│ │ │ │ │ +9
│ │ │ │ │ +10#include
│ │ │ │ │ +11#include
│ │ │ │ │ +12
│ │ │ │ │ +13#include <_d_u_n_e_/_i_s_t_l_/_b_c_r_s_m_a_t_r_i_x_._h_h>
│ │ │ │ │ +14#include <_d_u_n_e_/_i_s_t_l_/_b_l_o_c_k_l_e_v_e_l_._h_h>
│ │ │ │ │ +15
│ │ │ │ │ +21namespace _D_u_n_e {
│ │ │ │ │ +31 template >
│ │ │ │ │ +_3_2 class _B_D_M_a_t_r_i_x : public _B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ +33 {
│ │ │ │ │ +34 public:
│ │ │ │ │ +35
│ │ │ │ │ +36 //===== type definitions and constants
│ │ │ │ │ +37
│ │ │ │ │ +_3_9 using _f_i_e_l_d___t_y_p_e = typename Imp::BlockTraits::field_type;
│ │ │ │ │ +40
│ │ │ │ │ +_4_2 typedef B _b_l_o_c_k___t_y_p_e;
│ │ │ │ │ +43
│ │ │ │ │ +_4_5 typedef A _a_l_l_o_c_a_t_o_r___t_y_p_e;
│ │ │ │ │ +46
│ │ │ │ │ +48 //typedef BCRSMatrix::row_type row_type;
│ │ │ │ │ +49
│ │ │ │ │ +_5_1 typedef typename A::size_type _s_i_z_e___t_y_p_e;
│ │ │ │ │ +52
│ │ │ │ │ +_5_4 _B_D_M_a_t_r_i_x() : _B_C_R_S_M_a_t_r_i_x() {}
│ │ │ │ │ +55
│ │ │ │ │ +_5_6 explicit _B_D_M_a_t_r_i_x(int size)
│ │ │ │ │ +57 : _B_C_R_S_M_a_t_r_i_x(size, size, _B_C_R_S_M_a_t_r_i_x::_r_a_n_d_o_m) {
│ │ │ │ │ +58
│ │ │ │ │ +59 for (int i=0; i_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_s_e_t_r_o_w_s_i_z_e(i, 1);
│ │ │ │ │ 61
│ │ │ │ │ -62 //===== type definitions and constants
│ │ │ │ │ +62 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_r_o_w_s_i_z_e_s();
│ │ │ │ │ 63
│ │ │ │ │ -_6_5 using _f_i_e_l_d___t_y_p_e = typename Imp::BlockTraits::field_type;
│ │ │ │ │ +64 for (int i=0; i_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i);
│ │ │ │ │ 66
│ │ │ │ │ -_6_8 using _a_l_l_o_c_a_t_o_r___t_y_p_e = A;
│ │ │ │ │ -69
│ │ │ │ │ -_7_4 using _r_e_f_e_r_e_n_c_e = window_type&;
│ │ │ │ │ -75
│ │ │ │ │ -_8_0 using _c_o_n_s_t___r_e_f_e_r_e_n_c_e = const window_type&;
│ │ │ │ │ -81
│ │ │ │ │ -_8_3 using _s_i_z_e___t_y_p_e = typename A::size_type;
│ │ │ │ │ -84
│ │ │ │ │ -_9_0 using _v_a_l_u_e___t_y_p_e = _B_l_o_c_k_V_e_c_t_o_r_<_B_,_A_>;
│ │ │ │ │ +67 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_i_n_d_i_c_e_s();
│ │ │ │ │ +68
│ │ │ │ │ +69 }
│ │ │ │ │ +70
│ │ │ │ │ +_7_2 _B_D_M_a_t_r_i_x (std::initializer_list const &list)
│ │ │ │ │ +73 : _B_D_M_a_t_r_i_x(list.size())
│ │ │ │ │ +74 {
│ │ │ │ │ +75 size_t i=0;
│ │ │ │ │ +76 for (auto it = list.begin(); it != list.end(); ++it, ++i)
│ │ │ │ │ +77 (*this)[i][i] = *it;
│ │ │ │ │ +78 }
│ │ │ │ │ +79
│ │ │ │ │ +_8_1 void _s_e_t_S_i_z_e(_s_i_z_e___t_y_p_e size)
│ │ │ │ │ +82 {
│ │ │ │ │ +83 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_s_e_t_S_i_z_e(size, // rows
│ │ │ │ │ +84 size, // columns
│ │ │ │ │ +85 size); // nonzeros
│ │ │ │ │ +86
│ │ │ │ │ +87 for (auto i : range(size))
│ │ │ │ │ +88 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_s_e_t_r_o_w_s_i_z_e(i, 1);
│ │ │ │ │ +89
│ │ │ │ │ +90 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_r_o_w_s_i_z_e_s();
│ │ │ │ │ 91
│ │ │ │ │ -_9_4 using _b_l_o_c_k___t_y_p_e = _B_l_o_c_k_V_e_c_t_o_r_<_B_,_A_>;
│ │ │ │ │ -95
│ │ │ │ │ -96 //===== constructors and such
│ │ │ │ │ +92 for (auto i : range(size))
│ │ │ │ │ +93 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i);
│ │ │ │ │ +94
│ │ │ │ │ +95 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_i_n_d_i_c_e_s();
│ │ │ │ │ +96 }
│ │ │ │ │ 97
│ │ │ │ │ -_1_0_2 _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r () :
│ │ │ │ │ -103 Base()
│ │ │ │ │ -104 {}
│ │ │ │ │ -105
│ │ │ │ │ -_1_1_2 explicit _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r (_s_i_z_e___t_y_p_e numBlocks) :
│ │ │ │ │ -113 Base(),
│ │ │ │ │ -114 block(numBlocks)
│ │ │ │ │ -115 {}
│ │ │ │ │ -116
│ │ │ │ │ -_1_2_5 _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r (_s_i_z_e___t_y_p_e numBlocks, _s_i_z_e___t_y_p_e blockSize) :
│ │ │ │ │ -126 Base(),
│ │ │ │ │ -127 block(numBlocks),
│ │ │ │ │ -128 storage_(numBlocks*blockSize)
│ │ │ │ │ -129 {
│ │ │ │ │ -130 // and we can allocate the big array in the base class
│ │ │ │ │ -131 syncBaseArray();
│ │ │ │ │ +_9_9 _B_D_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_=_ (const _B_D_M_a_t_r_i_x& other) {
│ │ │ │ │ +100 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_o_p_e_r_a_t_o_r_=(other);
│ │ │ │ │ +101 return *this;
│ │ │ │ │ +102 }
│ │ │ │ │ +103
│ │ │ │ │ +_1_0_5 _B_D_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_=_ (const _f_i_e_l_d___t_y_p_e& k) {
│ │ │ │ │ +106 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_o_p_e_r_a_t_o_r_=(k);
│ │ │ │ │ +107 return *this;
│ │ │ │ │ +108 }
│ │ │ │ │ +109
│ │ │ │ │ +115 template
│ │ │ │ │ +_1_1_6 void _s_o_l_v_e (V& x, const V& rhs) const {
│ │ │ │ │ +117 for (_s_i_z_e___t_y_p_e i=0; i_N(); i++)
│ │ │ │ │ +118 {
│ │ │ │ │ +119 auto&& xv = Impl::asVector(x[i]);
│ │ │ │ │ +120 auto&& rhsv = Impl::asVector(rhs[i]);
│ │ │ │ │ +121 Impl::asMatrix((*this)[i][i]).solve(xv,rhsv);
│ │ │ │ │ +122 }
│ │ │ │ │ +123 }
│ │ │ │ │ +124
│ │ │ │ │ +_1_2_6 void _i_n_v_e_r_t() {
│ │ │ │ │ +127 for (_s_i_z_e___t_y_p_e i=0; i_N(); i++)
│ │ │ │ │ +128 Impl::asMatrix((*this)[i][i])._i_n_v_e_r_t();
│ │ │ │ │ +129 }
│ │ │ │ │ +130
│ │ │ │ │ +131 private:
│ │ │ │ │ 132
│ │ │ │ │ -133 // set the windows into the big array
│ │ │ │ │ -134 for (_s_i_z_e___t_y_p_e i=0; ip+(i*blockSize));
│ │ │ │ │ +133 // ////////////////////////////////////////////////////////////////////////
│ │ │ │ │ +////
│ │ │ │ │ +134 // The following methods from the base class should now actually be called
│ │ │ │ │ +135 // ////////////////////////////////////////////////////////////////////////
│ │ │ │ │ +////
│ │ │ │ │ 136
│ │ │ │ │ -137 // and the vector is usable
│ │ │ │ │ -138 initialized = true;
│ │ │ │ │ -139 }
│ │ │ │ │ -140
│ │ │ │ │ -_1_4_2 _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r (const _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r& a) :
│ │ │ │ │ -143 Base(static_cast(a)),
│ │ │ │ │ -144 block(a.block),
│ │ │ │ │ -145 storage_(a.storage_)
│ │ │ │ │ -146 {
│ │ │ │ │ -147 syncBaseArray();
│ │ │ │ │ -148
│ │ │ │ │ -149 // and we must set the windows
│ │ │ │ │ -150 if (block.size()>0) {
│ │ │ │ │ -151 block[0].set(block[0].getsize(),this->p); // first block
│ │ │ │ │ -152 for (_s_i_z_e___t_y_p_e i=1; ip+(i*blockSize));
│ │ │ │ │ -220
│ │ │ │ │ -221 // and the vector is usable
│ │ │ │ │ -222 initialized = true;
│ │ │ │ │ -223 }
│ │ │ │ │ -224
│ │ │ │ │ -225 //===== assignment from scalar
│ │ │ │ │ -226
│ │ │ │ │ -_2_2_8 _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r& _o_p_e_r_a_t_o_r_=_ (const _f_i_e_l_d___t_y_p_e& k)
│ │ │ │ │ -229 {
│ │ │ │ │ -230 (static_cast&>(*this)) = k;
│ │ │ │ │ -231 return *this;
│ │ │ │ │ -232 }
│ │ │ │ │ -233
│ │ │ │ │ -234
│ │ │ │ │ -235 //===== the creation interface
│ │ │ │ │ -236
│ │ │ │ │ -237 class CreateIterator;
│ │ │ │ │ -238
│ │ │ │ │ -239#ifndef DOXYGEN
│ │ │ │ │ -240
│ │ │ │ │ -241 // The window_type does not hand out a reference to its size,
│ │ │ │ │ -242 // so in order to provide a valid iterator, we need a workaround
│ │ │ │ │ -243 // to make assignment possible. This proxy enables just that by
│ │ │ │ │ -244 // implicitly converting to the stored size for read access and
│ │ │ │ │ -245 // tunneling assignment to the accessor method of the window.
│ │ │ │ │ -246 struct SizeProxy
│ │ │ │ │ -247 {
│ │ │ │ │ -248
│ │ │ │ │ -249 operator size_type () const
│ │ │ │ │ -250 {
│ │ │ │ │ -251 return target->getsize();
│ │ │ │ │ -252 }
│ │ │ │ │ -253
│ │ │ │ │ -254 SizeProxy& operator= (size_type size)
│ │ │ │ │ -255 {
│ │ │ │ │ -256 target->setsize(size);
│ │ │ │ │ -257 return *this;
│ │ │ │ │ -258 }
│ │ │ │ │ -259
│ │ │ │ │ -260 private:
│ │ │ │ │ -261
│ │ │ │ │ -262 friend class CreateIterator;
│ │ │ │ │ -263
│ │ │ │ │ -264 SizeProxy (window_type& t) :
│ │ │ │ │ -265 target(&t)
│ │ │ │ │ -266 {}
│ │ │ │ │ -267
│ │ │ │ │ -268 window_type* target;
│ │ │ │ │ -269 };
│ │ │ │ │ -270
│ │ │ │ │ -271#endif // DOXYGEN
│ │ │ │ │ -272
│ │ │ │ │ -_2_7_4 class _C_r_e_a_t_e_I_t_e_r_a_t_o_r
│ │ │ │ │ -275 {
│ │ │ │ │ -276 public:
│ │ │ │ │ -_2_7_8 using _i_t_e_r_a_t_o_r___c_a_t_e_g_o_r_y = std::output_iterator_tag;
│ │ │ │ │ -279
│ │ │ │ │ -_2_8_1 using _v_a_l_u_e___t_y_p_e = _s_i_z_e___t_y_p_e;
│ │ │ │ │ -282
│ │ │ │ │ -_2_8_9 using _d_i_f_f_e_r_e_n_c_e___t_y_p_e = void;
│ │ │ │ │ -290
│ │ │ │ │ -_2_9_2 using _p_o_i_n_t_e_r = _s_i_z_e___t_y_p_e*;
│ │ │ │ │ -293
│ │ │ │ │ -_2_9_5 using _r_e_f_e_r_e_n_c_e = SizeProxy;
│ │ │ │ │ -296
│ │ │ │ │ -_2_9_8 _C_r_e_a_t_e_I_t_e_r_a_t_o_r (_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r& _v, int _i, bool _isEnd) :
│ │ │ │ │ -299 v(_v),
│ │ │ │ │ -300 i(_i),
│ │ │ │ │ -301 isEnd(_isEnd)
│ │ │ │ │ -302 {}
│ │ │ │ │ -303
│ │ │ │ │ -_3_0_4 _~_C_r_e_a_t_e_I_t_e_r_a_t_o_r ()
│ │ │ │ │ -305 {
│ │ │ │ │ -306 // When the iterator gets destructed, we allocate the memory
│ │ │ │ │ -307 // for the VariableBlockVector if
│ │ │ │ │ -308 // 1. the current iterator was not created as enditerator
│ │ │ │ │ -309 // 2. we're at the last block
│ │ │ │ │ -310 // 3. the vector hasn't been initialized earlier
│ │ │ │ │ -311 if (not isEnd && i==v.block.size() && not v.initialized)
│ │ │ │ │ -312 v.allocate();
│ │ │ │ │ -313 }
│ │ │ │ │ -314
│ │ │ │ │ -_3_1_6 _C_r_e_a_t_e_I_t_e_r_a_t_o_r& _o_p_e_r_a_t_o_r_+_+()
│ │ │ │ │ -317 {
│ │ │ │ │ -318 // go to next block
│ │ │ │ │ -319 ++i;
│ │ │ │ │ -320
│ │ │ │ │ -321 return *this;
│ │ │ │ │ -322 }
│ │ │ │ │ -323
│ │ │ │ │ -_3_2_5 _C_r_e_a_t_e_I_t_e_r_a_t_o_r _o_p_e_r_a_t_o_r_+_+_ (int)
│ │ │ │ │ -326 {
│ │ │ │ │ -327 _C_r_e_a_t_e_I_t_e_r_a_t_o_r tmp(*this);
│ │ │ │ │ -328 this->_o_p_e_r_a_t_o_r_+_+();
│ │ │ │ │ -329 return tmp;
│ │ │ │ │ -330 }
│ │ │ │ │ -331
│ │ │ │ │ -_3_3_3 bool _o_p_e_r_a_t_o_r_!_=_ (const _C_r_e_a_t_e_I_t_e_r_a_t_o_r& it) const
│ │ │ │ │ -334 {
│ │ │ │ │ -335 return (i!=it.i) || (&v!=&it.v);
│ │ │ │ │ -336 }
│ │ │ │ │ -337
│ │ │ │ │ -_3_3_9 bool _o_p_e_r_a_t_o_r_=_=_ (const _C_r_e_a_t_e_I_t_e_r_a_t_o_r& it) const
│ │ │ │ │ -340 {
│ │ │ │ │ -341 return (i==it.i) && (&v==&it.v);
│ │ │ │ │ -342 }
│ │ │ │ │ -343
│ │ │ │ │ -_3_4_5 _s_i_z_e___t_y_p_e _i_n_d_e_x () const
│ │ │ │ │ -346 {
│ │ │ │ │ -347 return i;
│ │ │ │ │ -348 }
│ │ │ │ │ -349
│ │ │ │ │ -_3_5_1 void _s_e_t_b_l_o_c_k_s_i_z_e (_s_i_z_e___t_y_p_e _k)
│ │ │ │ │ -352 {
│ │ │ │ │ -353 v.block[i].setsize(_k);
│ │ │ │ │ -354 }
│ │ │ │ │ -355
│ │ │ │ │ -357#ifdef DOXYGEN
│ │ │ │ │ -358 _s_i_z_e___t_y_p_e&
│ │ │ │ │ -359#else
│ │ │ │ │ -360 SizeProxy
│ │ │ │ │ -361#endif
│ │ │ │ │ -_3_6_2 _o_p_e_r_a_t_o_r_*()
│ │ │ │ │ -363 {
│ │ │ │ │ -364 return {v.block[i]};
│ │ │ │ │ -365 }
│ │ │ │ │ -366
│ │ │ │ │ -367 private:
│ │ │ │ │ -368 _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r& v; // my vector
│ │ │ │ │ -369 _s_i_z_e___t_y_p_e i; // current block to be defined
│ │ │ │ │ -370 const bool isEnd; // flag if this object was created as the end iterator.
│ │ │ │ │ -371 };
│ │ │ │ │ -372
│ │ │ │ │ -373 // CreateIterator wants to set all the arrays ...
│ │ │ │ │ -_3_7_4 friend class _C_r_e_a_t_e_I_t_e_r_a_t_o_r;
│ │ │ │ │ -375
│ │ │ │ │ -_3_7_7 _C_r_e_a_t_e_I_t_e_r_a_t_o_r _c_r_e_a_t_e_b_e_g_i_n ()
│ │ │ │ │ -378 {
│ │ │ │ │ -379#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ │ -380 if (initialized) DUNE_THROW(_I_S_T_L_E_r_r_o_r,"no CreateIterator in initialized
│ │ │ │ │ -state");
│ │ │ │ │ -381#endif
│ │ │ │ │ -382 return _C_r_e_a_t_e_I_t_e_r_a_t_o_r(*this, 0, false);
│ │ │ │ │ -383 }
│ │ │ │ │ -384
│ │ │ │ │ -_3_8_6 _C_r_e_a_t_e_I_t_e_r_a_t_o_r _c_r_e_a_t_e_e_n_d ()
│ │ │ │ │ -387 {
│ │ │ │ │ -388 return _C_r_e_a_t_e_I_t_e_r_a_t_o_r(*this, block.size(), true);
│ │ │ │ │ -389 }
│ │ │ │ │ -390
│ │ │ │ │ -391
│ │ │ │ │ -392 //===== access to components
│ │ │ │ │ -393 // has to be overwritten from base class because it must
│ │ │ │ │ -394 // return access to the windows
│ │ │ │ │ -395
│ │ │ │ │ -_3_9_7 window_type& _o_p_e_r_a_t_o_r_[_]_ (_s_i_z_e___t_y_p_e i)
│ │ │ │ │ -398 {
│ │ │ │ │ -399#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ │ -400 if (i>=block.size()) DUNE_THROW(_I_S_T_L_E_r_r_o_r,"index out of range");
│ │ │ │ │ -401#endif
│ │ │ │ │ -402 return block[i];
│ │ │ │ │ -403 }
│ │ │ │ │ -404
│ │ │ │ │ -_4_0_6 const window_type& _o_p_e_r_a_t_o_r_[_]_ (_s_i_z_e___t_y_p_e i) const
│ │ │ │ │ -407 {
│ │ │ │ │ -408#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ │ -409 if (i<0 || i>=block.size()) DUNE_THROW(_I_S_T_L_E_r_r_o_r,"index out of range");
│ │ │ │ │ -410#endif
│ │ │ │ │ -411 return block[i];
│ │ │ │ │ -412 }
│ │ │ │ │ -413
│ │ │ │ │ -_4_1_4 using _I_t_e_r_a_t_o_r = IndexedIterator;
│ │ │ │ │ -415
│ │ │ │ │ -_4_1_7 _I_t_e_r_a_t_o_r _b_e_g_i_n ()
│ │ │ │ │ -418 {
│ │ │ │ │ -419 return _I_t_e_r_a_t_o_r{block.begin()};
│ │ │ │ │ -420 }
│ │ │ │ │ -421
│ │ │ │ │ -_4_2_3 _I_t_e_r_a_t_o_r _e_n_d ()
│ │ │ │ │ -424 {
│ │ │ │ │ -425 return _I_t_e_r_a_t_o_r{block.end()};
│ │ │ │ │ -426 }
│ │ │ │ │ -427
│ │ │ │ │ -_4_3_0 _I_t_e_r_a_t_o_r _b_e_f_o_r_e_E_n_d ()
│ │ │ │ │ -431 {
│ │ │ │ │ -432 return _I_t_e_r_a_t_o_r{--block.end()};
│ │ │ │ │ -433 }
│ │ │ │ │ -434
│ │ │ │ │ -_4_3_7 _I_t_e_r_a_t_o_r _b_e_f_o_r_e_B_e_g_i_n ()
│ │ │ │ │ -438 {
│ │ │ │ │ -439 return _I_t_e_r_a_t_o_r{--block.begin()};
│ │ │ │ │ -440 }
│ │ │ │ │ -441
│ │ │ │ │ -_4_4_3 using _i_t_e_r_a_t_o_r = _I_t_e_r_a_t_o_r;
│ │ │ │ │ -444
│ │ │ │ │ -_4_4_6 using _C_o_n_s_t_I_t_e_r_a_t_o_r = IndexedIterator;
│ │ │ │ │ -447
│ │ │ │ │ -_4_4_9 using _c_o_n_s_t___i_t_e_r_a_t_o_r = _C_o_n_s_t_I_t_e_r_a_t_o_r;
│ │ │ │ │ -450
│ │ │ │ │ -_4_5_2 _C_o_n_s_t_I_t_e_r_a_t_o_r _b_e_g_i_n () const
│ │ │ │ │ -453 {
│ │ │ │ │ -454 return _C_o_n_s_t_I_t_e_r_a_t_o_r{block.begin()};
│ │ │ │ │ -455 }
│ │ │ │ │ -456
│ │ │ │ │ -_4_5_8 _C_o_n_s_t_I_t_e_r_a_t_o_r _e_n_d () const
│ │ │ │ │ -459 {
│ │ │ │ │ -460 return _C_o_n_s_t_I_t_e_r_a_t_o_r{block.end()};
│ │ │ │ │ -461 }
│ │ │ │ │ -462
│ │ │ │ │ -_4_6_5 _C_o_n_s_t_I_t_e_r_a_t_o_r _b_e_f_o_r_e_E_n_d () const
│ │ │ │ │ -466 {
│ │ │ │ │ -467 return _C_o_n_s_t_I_t_e_r_a_t_o_r{--block.end()};
│ │ │ │ │ -468 }
│ │ │ │ │ -469
│ │ │ │ │ -_4_7_2 _C_o_n_s_t_I_t_e_r_a_t_o_r _b_e_f_o_r_e_B_e_g_i_n () const
│ │ │ │ │ -473 {
│ │ │ │ │ -474 return _C_o_n_s_t_I_t_e_r_a_t_o_r{--block.begin()};
│ │ │ │ │ -475 }
│ │ │ │ │ -476
│ │ │ │ │ -_4_7_8 _C_o_n_s_t_I_t_e_r_a_t_o_r _r_e_n_d () const
│ │ │ │ │ -479 {
│ │ │ │ │ -480 return _C_o_n_s_t_I_t_e_r_a_t_o_r{block.rend()};
│ │ │ │ │ -481 }
│ │ │ │ │ -482
│ │ │ │ │ -_4_8_4 _I_t_e_r_a_t_o_r _f_i_n_d (_s_i_z_e___t_y_p_e i)
│ │ │ │ │ -485 {
│ │ │ │ │ -486 _I_t_e_r_a_t_o_r tmp = block.begin();
│ │ │ │ │ -487 tmp+=std::min(i, block.size());
│ │ │ │ │ -488 return tmp;
│ │ │ │ │ -489 }
│ │ │ │ │ -490
│ │ │ │ │ -_4_9_2 _C_o_n_s_t_I_t_e_r_a_t_o_r _f_i_n_d (_s_i_z_e___t_y_p_e i) const
│ │ │ │ │ -493 {
│ │ │ │ │ -494 _C_o_n_s_t_I_t_e_r_a_t_o_r tmp = block.begin();
│ │ │ │ │ -495 tmp+=std::min(i, block.size());
│ │ │ │ │ -496 return tmp;
│ │ │ │ │ -497 }
│ │ │ │ │ -498
│ │ │ │ │ -499 //===== sizes
│ │ │ │ │ -500
│ │ │ │ │ -_5_0_2 _s_i_z_e___t_y_p_e _N () const noexcept
│ │ │ │ │ -503 {
│ │ │ │ │ -504 return block.size();
│ │ │ │ │ -505 }
│ │ │ │ │ -506
│ │ │ │ │ -_5_1_1 _s_i_z_e___t_y_p_e _s_i_z_e () const noexcept
│ │ │ │ │ -512 {
│ │ │ │ │ -513 return block.size();
│ │ │ │ │ -514 }
│ │ │ │ │ -515
│ │ │ │ │ -516
│ │ │ │ │ -517 private:
│ │ │ │ │ -518
│ │ │ │ │ -519 void allocate ()
│ │ │ │ │ -520 {
│ │ │ │ │ -521 if (this->initialized)
│ │ │ │ │ -522 DUNE_THROW(_I_S_T_L_E_r_r_o_r, "Attempt to re-allocate already initialized
│ │ │ │ │ -VariableBlockVector");
│ │ │ │ │ -523
│ │ │ │ │ -524 // calculate space needed:
│ │ │ │ │ -525 _s_i_z_e___t_y_p_e storageNeeded = 0;
│ │ │ │ │ -526 for(_s_i_z_e___t_y_p_e i = 0; i < block.size(); i++)
│ │ │ │ │ -527 storageNeeded += block[i]._s_i_z_e();
│ │ │ │ │ -528
│ │ │ │ │ -529 storage_.resize(storageNeeded);
│ │ │ │ │ -530 syncBaseArray();
│ │ │ │ │ -531
│ │ │ │ │ -532 // and we set the window pointers
│ │ │ │ │ -533 block[0].setptr(this->p); // pointer to first block
│ │ │ │ │ -534 for (_s_i_z_e___t_y_p_e j=1; jinitialized = true;
│ │ │ │ │ -539 }
│ │ │ │ │ -540
│ │ │ │ │ -541 void syncBaseArray () noexcept
│ │ │ │ │ -542 {
│ │ │ │ │ -543 this->p = storage_.data();
│ │ │ │ │ -544 this->n = storage_.size();
│ │ │ │ │ -545 }
│ │ │ │ │ -546
│ │ │ │ │ -547 VectorWindows block = {}; // vector of blocks pointing to the array in the
│ │ │ │ │ -base class
│ │ │ │ │ -548 std::vector storage_ = {};
│ │ │ │ │ -549 bool initialized = false; // true if vector has been initialized
│ │ │ │ │ -550 };
│ │ │ │ │ -551
│ │ │ │ │ -555 template
│ │ │ │ │ -_5_5_6 struct FieldTraits< _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r >
│ │ │ │ │ -557 {
│ │ │ │ │ -_5_5_8 typedef typename FieldTraits::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ -_5_5_9 typedef typename FieldTraits::real_type _r_e_a_l___t_y_p_e;
│ │ │ │ │ -560 };
│ │ │ │ │ -568} // end namespace
│ │ │ │ │ -569
│ │ │ │ │ -570#endif
│ │ │ │ │ -_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...
│ │ │ │ │ -_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h
│ │ │ │ │ +137 // createbegin and createend should be in there, too, but I can't get it to
│ │ │ │ │ +compile
│ │ │ │ │ +138 // BCRSMatrix::CreateIterator createbegin () {}
│ │ │ │ │ +139 // BCRSMatrix::CreateIterator createend () {}
│ │ │ │ │ +140 void setrowsize (_s_i_z_e___t_y_p_e i, _s_i_z_e___t_y_p_e s) {}
│ │ │ │ │ +141 void incrementrowsize (_s_i_z_e___t_y_p_e i) {}
│ │ │ │ │ +142 void endrowsizes () {}
│ │ │ │ │ +143 void addindex (_s_i_z_e___t_y_p_e row, _s_i_z_e___t_y_p_e _c_o_l) {}
│ │ │ │ │ +144 void endindices () {}
│ │ │ │ │ +145 };
│ │ │ │ │ +146
│ │ │ │ │ +147 template
│ │ │ │ │ +_1_4_8 struct FieldTraits< _B_D_M_a_t_r_i_x >
│ │ │ │ │ +149 {
│ │ │ │ │ +_1_5_0 using _f_i_e_l_d___t_y_p_e = typename _B_D_M_a_t_r_i_x_<_B_,_ _A_>_:_:_f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_1_5_1 using _r_e_a_l___t_y_p_e = typename FieldTraits::real_type;
│ │ │ │ │ +152 };
│ │ │ │ │ +155} // end namespace Dune
│ │ │ │ │ +156
│ │ │ │ │ +157#endif
│ │ │ │ │ +_b_c_r_s_m_a_t_r_i_x_._h_h
│ │ │ │ │ +Implementation of the BCRSMatrix class.
│ │ │ │ │ _b_l_o_c_k_l_e_v_e_l_._h_h
│ │ │ │ │ Helper functions for determining the vector/matrix block level.
│ │ │ │ │ +_c_o_l
│ │ │ │ │ +Col col
│ │ │ │ │ +DDeeffiinniittiioonn matrixmatrix.hh:351
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn allocator.hh:11
│ │ │ │ │ -_D_u_n_e_:_:_B_l_o_c_k_V_e_c_t_o_r
│ │ │ │ │ -A vector of blocks with memory management.
│ │ │ │ │ -DDeeffiinniittiioonn bvector.hh:392
│ │ │ │ │ -_D_u_n_e_:_:_I_S_T_L_E_r_r_o_r
│ │ │ │ │ -derive error class from the base class in common
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:19
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r
│ │ │ │ │ -A Vector of blocks with different blocksizes.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:48
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r
│ │ │ │ │ -VariableBlockVector(size_type numBlocks, size_type blockSize)
│ │ │ │ │ -Construct a vector with given number of blocks each having a constant size.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:125
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r
│ │ │ │ │ -VariableBlockVector()
│ │ │ │ │ -Constructor without arguments makes an empty vector.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:102
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_s_w_a_p
│ │ │ │ │ -friend void swap(VariableBlockVector &lhs, VariableBlockVector &rhs) noexcept
│ │ │ │ │ -Free function to swap the storage and internal state of lhs with rhs.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:190
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_i_t_e_r_a_t_o_r
│ │ │ │ │ -Iterator iterator
│ │ │ │ │ -Export the iterator type using std naming rules.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:443
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ -VariableBlockVector & operator=(VariableBlockVector tmp)
│ │ │ │ │ -Copy and move assignment.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:171
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r
│ │ │ │ │ -VariableBlockVector(size_type numBlocks)
│ │ │ │ │ -Construct a vector with given number of blocks, but size of each block is not
│ │ │ │ │ -yet known.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:112
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +_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_:_:_e_n_d_r_o_w_s_i_z_e_s
│ │ │ │ │ +void endrowsizes()
│ │ │ │ │ +indicate that size of all rows is defined
│ │ │ │ │ +DDeeffiinniittiioonn bcrsmatrix.hh:1146
│ │ │ │ │ +_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_r_a_n_d_o_m
│ │ │ │ │ +@ random
│ │ │ │ │ +Build entries randomly.
│ │ │ │ │ +DDeeffiinniittiioonn bcrsmatrix.hh:526
│ │ │ │ │ +_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_e_n_d_i_n_d_i_c_e_s
│ │ │ │ │ +void endindices()
│ │ │ │ │ +indicate that all indices are defined, check consistency
│ │ │ │ │ +DDeeffiinniittiioonn bcrsmatrix.hh:1269
│ │ │ │ │ +_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_N
│ │ │ │ │ +size_type N() const
│ │ │ │ │ +number of rows (counted in blocks)
│ │ │ │ │ +DDeeffiinniittiioonn bcrsmatrix.hh:2001
│ │ │ │ │ +_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_S_i_z_e
│ │ │ │ │ +void setSize(size_type rows, size_type columns, size_type nnz=0)
│ │ │ │ │ +Set the size of the matrix.
│ │ │ │ │ +DDeeffiinniittiioonn bcrsmatrix.hh:858
│ │ │ │ │ +_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ +BCRSMatrix & operator=(const BCRSMatrix &Mat)
│ │ │ │ │ +assignment
│ │ │ │ │ +DDeeffiinniittiioonn bcrsmatrix.hh:908
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x
│ │ │ │ │ +A block-diagonal matrix.
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:33
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ typename Imp::BlockTraits< B >::field_type field_type
│ │ │ │ │ export the type representing the field
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:65
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ -typename A::size_type size_type
│ │ │ │ │ -The size type for the index access.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:83
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_N
│ │ │ │ │ -size_type N() const noexcept
│ │ │ │ │ -number of blocks in the vector (are of variable size here)
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:502
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r
│ │ │ │ │ -VariableBlockVector(const VariableBlockVector &a)
│ │ │ │ │ -Copy constructor, has copy semantics.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:142
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_o_p_e_r_a_t_o_r_[_]
│ │ │ │ │ -window_type & operator[](size_type i)
│ │ │ │ │ -random access to blocks
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:397
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_a_l_l_o_c_a_t_o_r___t_y_p_e
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:39
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ +A::size_type size_type
│ │ │ │ │ +implement row_type with compressed vector
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:51
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_B_D_M_a_t_r_i_x
│ │ │ │ │ +BDMatrix()
│ │ │ │ │ +Default constructor.
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:54
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_B_D_M_a_t_r_i_x
│ │ │ │ │ +BDMatrix(std::initializer_list< B > const &list)
│ │ │ │ │ +Construct from a std::initializer_list.
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:72
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_b_l_o_c_k___t_y_p_e
│ │ │ │ │ +B block_type
│ │ │ │ │ +export the type representing the components
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:42
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_s_o_l_v_e
│ │ │ │ │ +void solve(V &x, const V &rhs) const
│ │ │ │ │ +Solve the system Ax=b in O(n) time.
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:116
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_a_l_l_o_c_a_t_o_r___t_y_p_e
│ │ │ │ │ A allocator_type
│ │ │ │ │ export the allocator type
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:68
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_c_r_e_a_t_e_e_n_d
│ │ │ │ │ -CreateIterator createend()
│ │ │ │ │ -get create iterator pointing to one after the last block
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:386
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r
│ │ │ │ │ -VariableBlockVector(VariableBlockVector &&tmp)
│ │ │ │ │ -Move constructor:
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:161
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_c_r_e_a_t_e_b_e_g_i_n
│ │ │ │ │ -CreateIterator createbegin()
│ │ │ │ │ -get initial create iterator
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:377
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_c_o_n_s_t___i_t_e_r_a_t_o_r
│ │ │ │ │ -ConstIterator const_iterator
│ │ │ │ │ -Export the const iterator type using std naming rules.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:449
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_r_e_f_e_r_e_n_c_e
│ │ │ │ │ -window_type & reference
│ │ │ │ │ -Export type used for references to container entries.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:74
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_r_e_n_d
│ │ │ │ │ -ConstIterator rend() const
│ │ │ │ │ -end ConstIterator
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:478
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_c_o_n_s_t___r_e_f_e_r_e_n_c_e
│ │ │ │ │ -const window_type & const_reference
│ │ │ │ │ -Export type used for const references to container entries.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:80
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_f_i_n_d
│ │ │ │ │ -ConstIterator find(size_type i) const
│ │ │ │ │ -random access returning iterator (end if not contained)
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:492
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_b_e_f_o_r_e_E_n_d
│ │ │ │ │ -ConstIterator beforeEnd() const
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:465
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_f_i_n_d
│ │ │ │ │ -Iterator find(size_type i)
│ │ │ │ │ -random access returning iterator (end if not contained)
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:484
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_o_n_s_t_I_t_e_r_a_t_o_r
│ │ │ │ │ -IndexedIterator< typename VectorWindows::const_iterator > ConstIterator
│ │ │ │ │ -Const iterator.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:446
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_~_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r
│ │ │ │ │ -~VariableBlockVector()=default
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_b_e_f_o_r_e_B_e_g_i_n
│ │ │ │ │ -ConstIterator beforeBegin() const
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:472
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_r_e_s_i_z_e
│ │ │ │ │ -void resize(size_type numBlocks)
│ │ │ │ │ -same effect as constructor with same argument
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:196
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_e_n_d
│ │ │ │ │ -Iterator end()
│ │ │ │ │ -end Iterator
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:423
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_s_w_a_p
│ │ │ │ │ -void swap(VariableBlockVector &other) noexcept
│ │ │ │ │ -Exchange the storage and internal state with other.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:178
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_b_e_g_i_n
│ │ │ │ │ -ConstIterator begin() const
│ │ │ │ │ -begin ConstIterator
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:452
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_s_i_z_e
│ │ │ │ │ -size_type size() const noexcept
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:511
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_r_e_s_i_z_e
│ │ │ │ │ -void resize(size_type numBlocks, size_type blockSize)
│ │ │ │ │ -same effect as constructor with same argument
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:210
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_I_t_e_r_a_t_o_r
│ │ │ │ │ -IndexedIterator< typename VectorWindows::iterator > Iterator
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:414
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_e_n_d
│ │ │ │ │ -ConstIterator end() const
│ │ │ │ │ -end ConstIterator
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:458
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_b_e_f_o_r_e_B_e_g_i_n
│ │ │ │ │ -Iterator beforeBegin()
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:437
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_b_e_f_o_r_e_E_n_d
│ │ │ │ │ -Iterator beforeEnd()
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:430
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_b_e_g_i_n
│ │ │ │ │ -Iterator begin()
│ │ │ │ │ -begin Iterator
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:417
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r
│ │ │ │ │ -Iterator class for sequential creation of blocks.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:275
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_o_p_e_r_a_t_o_r_=_=
│ │ │ │ │ -bool operator==(const CreateIterator &it) const
│ │ │ │ │ -equality
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:339
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_i_n_d_e_x
│ │ │ │ │ -size_type index() const
│ │ │ │ │ -dereferencing
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:345
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_r_e_f_e_r_e_n_c_e
│ │ │ │ │ -SizeProxy reference
│ │ │ │ │ -reference type
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:295
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_p_o_i_n_t_e_r
│ │ │ │ │ -size_type * pointer
│ │ │ │ │ -pointer type
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:292
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_o_p_e_r_a_t_o_r_!_=
│ │ │ │ │ -bool operator!=(const CreateIterator &it) const
│ │ │ │ │ -inequality
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:333
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_~_C_r_e_a_t_e_I_t_e_r_a_t_o_r
│ │ │ │ │ -~CreateIterator()
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:304
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_v_a_l_u_e___t_y_p_e
│ │ │ │ │ -size_type value_type
│ │ │ │ │ -value type
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:281
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r
│ │ │ │ │ -CreateIterator(VariableBlockVector &_v, int _i, bool _isEnd)
│ │ │ │ │ -constructor
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:298
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_s_e_t_b_l_o_c_k_s_i_z_e
│ │ │ │ │ -void setblocksize(size_type _k)
│ │ │ │ │ -set size of current block
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:351
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_o_p_e_r_a_t_o_r_*
│ │ │ │ │ -size_type & operator*()
│ │ │ │ │ -Access size of current block.
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:362
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_i_t_e_r_a_t_o_r___c_a_t_e_g_o_r_y
│ │ │ │ │ -std::output_iterator_tag iterator_category
│ │ │ │ │ -iterator category
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:278
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_o_p_e_r_a_t_o_r_+_+
│ │ │ │ │ -CreateIterator & operator++()
│ │ │ │ │ -prefix increment
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:316
│ │ │ │ │ -_D_u_n_e_:_:_V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_d_i_f_f_e_r_e_n_c_e___t_y_p_e
│ │ │ │ │ -void difference_type
│ │ │ │ │ -difference type (unused)
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:289
│ │ │ │ │ -_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_<_ _B_,_ _A_ _>_ _>_:_:_r_e_a_l___t_y_p_e
│ │ │ │ │ -FieldTraits< B >::real_type real_type
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:559
│ │ │ │ │ -_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _V_a_r_i_a_b_l_e_B_l_o_c_k_V_e_c_t_o_r_<_ _B_,_ _A_ _>_ _>_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ -FieldTraits< B >::field_type field_type
│ │ │ │ │ -DDeeffiinniittiioonn vbvector.hh:558
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:45
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_B_D_M_a_t_r_i_x
│ │ │ │ │ +BDMatrix(int size)
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:56
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ +BDMatrix & operator=(const BDMatrix &other)
│ │ │ │ │ +assignment
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:99
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_s_e_t_S_i_z_e
│ │ │ │ │ +void setSize(size_type size)
│ │ │ │ │ +Resize the matrix. Invalidates the content!
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:81
│ │ │ │ │ +_D_u_n_e_:_:_B_D_M_a_t_r_i_x_:_:_i_n_v_e_r_t
│ │ │ │ │ +void invert()
│ │ │ │ │ +Inverts the matrix.
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:126
│ │ │ │ │ +_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _B_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +typename BDMatrix< B, A >::field_type field_type
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:150
│ │ │ │ │ +_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _B_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_r_e_a_l___t_y_p_e
│ │ │ │ │ +typename FieldTraits< field_type >::real_type real_type
│ │ │ │ │ +DDeeffiinniittiioonn bdmatrix.hh:151
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00029.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: supermatrix.hh File Reference
│ │ │ │ +dune-istl: renumberer.hh File Reference
│ │ │ │
│ │ │ │ -
#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 "aggregates.hh "
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ namespace Dune namespace Dune::Amg
│ │ │ │ +template<class G , class I , class V > void Dune::Amg::renumberAggregates (const G &graph, I index, I endIndex, V &visitedMap, AggregatesMap < typename G::VertexDescriptor > &aggregates)
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,50 +1,26 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ 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"
│ │ │ │ │ -#include "_b_v_e_c_t_o_r_._h_h"
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include <_d_u_n_e_/_i_s_t_l_/_b_c_c_s_m_a_t_r_i_x_i_n_i_t_i_a_l_i_z_e_r_._h_h>
│ │ │ │ │ -#include "_s_u_p_e_r_l_u_f_u_n_c_t_i_o_n_s_._h_h"
│ │ │ │ │ + * _p_a_a_m_g
│ │ │ │ │ +_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
│ │ │ │ │ +renumberer.hh File Reference
│ │ │ │ │ +#include "_a_g_g_r_e_g_a_t_e_s_._h_h"
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ CCllaasssseess
│ │ │ │ │ -struct _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_<_ _T_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_P_r_i_n_t_e_r_<_ _T_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _T_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _T_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _d_o_u_b_l_e_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _f_l_o_a_t_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _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_ _>_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _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_ _>_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _M_ _>
│ │ │ │ │ - Utility class for converting an _I_S_T_L _M_a_t_r_i_x into a _S_u_p_e_r_L_U _M_a_t_r_i_x.
│ │ │ │ │ - _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _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_<_ _M_ _>
│ │ │ │ │ -
│ │ │ │ │ - class _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_ _>_ _>
│ │ │ │ │ - Converter for _B_C_R_S_M_a_t_r_i_x to _S_u_p_e_r_L_U _M_a_t_r_i_x. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ - class _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_ _>_ _>
│ │ │ │ │ +class _D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_<_ _G_ _>
│ │ │ │ │
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ +namespace _D_u_n_e_:_:_A_m_g
│ │ │ │ │ +
│ │ │ │ │ +FFuunnccttiioonnss
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_A_m_g_:_:_r_e_n_u_m_b_e_r_A_g_g_r_e_g_a_t_e_s (const G &graph, I index, I endIndex, V
│ │ │ │ │ + &visitedMap, _A_g_g_r_e_g_a_t_e_s_M_a_p< typename G::VertexDescriptor > &aggregates)
│ │ │ │ │ +
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00029_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: supermatrix.hh Source File
│ │ │ │ +dune-istl: renumberer.hh Source File
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_ISTL_SUPERMATRIX_HH
│ │ │ │ -
6 #define DUNE_ISTL_SUPERMATRIX_HH
│ │ │ │ +
5 #ifndef DUNE_AMG_RENUMBERER_HH
│ │ │ │ +
6 #define DUNE_AMG_RENUMBERER_HH
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
12 #include <dune/common/fmatrix.hh>
│ │ │ │ -
13 #include <dune/common/fvector.hh>
│ │ │ │ -
14 #include <dune/common/typetraits.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
19 typedef typename G::VertexDescriptor
Vertex ;
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
30 void operator() (
const typename G::ConstEdgeIterator& edge);
│ │ │ │
│ │ │ │ -
32 #if __has_include("slu_sdefs.h")
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
36 static void create(SuperMatrix *
mat ,
int n,
int m,
int offset,
│ │ │ │ -
37 float *values,
int *rowindex,
int * colindex,
│ │ │ │ -
38 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ -
│ │ │ │ -
40 sCreate_CompCol_Matrix(
mat , n, m, offset, values, rowindex, colindex,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
46 struct SuperMatrixPrinter<float>
│ │ │ │ -
│ │ │ │ -
48 static void print(
char * name, SuperMatrix*
mat )
│ │ │ │ -
│ │ │ │ -
50 sPrint_CompCol_Matrix(name,
mat );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
55 #if __has_include("slu_ddefs.h")
│ │ │ │ -
│ │ │ │ -
57 struct SuperMatrixCreateSparseChooser<double>
│ │ │ │ -
│ │ │ │ -
59 static void create(SuperMatrix *
mat ,
int n,
int m,
int offset,
│ │ │ │ -
60 double *values,
int *rowindex,
int * colindex,
│ │ │ │ -
61 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ -
│ │ │ │ -
63 dCreate_CompCol_Matrix(
mat , n, m, offset, values, rowindex, colindex,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
41 : number_(0), aggregates_(aggregates)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
53 aggregates_[edge.target()]=number_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
62 template <
class G,
class I,
class V>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
69 struct SuperMatrixPrinter<double>
│ │ │ │ -
│ │ │ │ -
71 static void print(
char * name, SuperMatrix*
mat )
│ │ │ │ -
│ │ │ │ -
73 dPrint_CompCol_Matrix(name,
mat );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
78 #if __has_include("slu_cdefs.h")
│ │ │ │ -
│ │ │ │ -
80 struct SuperMatrixCreateSparseChooser<
std ::complex<float> >
│ │ │ │ -
│ │ │ │ -
82 static void create(SuperMatrix *
mat ,
int n,
int m,
int offset,
│ │ │ │ -
83 std::complex<float> *values,
int *rowindex,
int * colindex,
│ │ │ │ -
84 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ -
│ │ │ │ -
86 cCreate_CompCol_Matrix(
mat , n, m, offset,
reinterpret_cast< ::complex*
> (values),
│ │ │ │ -
87 rowindex, colindex, stype, dtype, mtype);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
92 struct SuperMatrixPrinter<
std ::complex<float> >
│ │ │ │ -
│ │ │ │ -
94 static void print(
char * name, SuperMatrix*
mat )
│ │ │ │ -
│ │ │ │ -
96 cPrint_CompCol_Matrix(name,
mat );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
101 #if __has_include("slu_zdefs.h")
│ │ │ │ -
│ │ │ │ -
103 struct SuperMatrixCreateSparseChooser<
std ::complex<double> >
│ │ │ │ -
│ │ │ │ -
105 static void create(SuperMatrix *
mat ,
int n,
int m,
int offset,
│ │ │ │ -
106 std::complex<double> *values,
int *rowindex,
int * colindex,
│ │ │ │ -
107 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ -
│ │ │ │ -
109 zCreate_CompCol_Matrix(
mat , n, m, offset,
reinterpret_cast< doublecomplex*
> (values),
│ │ │ │ -
110 rowindex, colindex, stype, dtype, mtype);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
115 struct SuperMatrixPrinter<
std ::complex<double> >
│ │ │ │ -
│ │ │ │ -
117 static void print(
char * name, SuperMatrix*
mat )
│ │ │ │ -
│ │ │ │ -
119 zPrint_CompCol_Matrix(name,
mat );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
136 std::is_same<T,float>::value ? SLU_S :
│ │ │ │ -
137 ( std::is_same<T,std::complex<double> >::value ? SLU_Z :
│ │ │ │ -
138 ( std::is_same<T,std::complex<float> >::value ? SLU_C : SLU_D ));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
184 template <
class M,
class X,
class TM,
class TD,
class T1>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
187 template <
class T,
bool flag>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
193 template <
class B,
class TA>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
195 :
public ISTL::Impl::BCCSMatrix<typename BCRSMatrix<B,TA>::field_type, int>
│ │ │ │ -
│ │ │ │ -
197 template <
class M,
class X,
class TM,
class TD,
class T1>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
221 if (this->N_+this->M_*this->Nnz_ != 0)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
226 operator SuperMatrix&()
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
232 operator const SuperMatrix&()
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
239 if (this->N_ + this->M_ + this->Nnz_!=0)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
245 ISTL::Impl::BCCSMatrixInitializer<Matrix, int> initializer(*
this );
│ │ │ │ -
│ │ │ │ -
247 copyToBCCSMatrix(initializer,
mat );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
250 ::create (&A, this->N_, this->M_, this->colstart[this->N_],
│ │ │ │ -
251 this->values,this->rowindex, this->colstart, SLU_NC,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
258 if (this->N_ + this->M_ + this->Nnz_!=0)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
264 ISTL::Impl::BCCSMatrixInitializer<Matrix, int> initializer(*
this );
│ │ │ │ -
│ │ │ │ -
266 copyToBCCSMatrix(initializer,
mat );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
269 ::create (&A, this->N_, this->M_, this->colstart[this->N_],
│ │ │ │ -
270 this->values,this->rowindex, this->colstart, SLU_NC,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
283 if (this->N_+this->M_+this->Nnz_!=0)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
289 copyToBCCSMatrix(initializer, ISTL::Impl::MatrixRowSubset<
Matrix ,std::set<std::size_t> >(
mat ,mrs));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
299 copyToBCCSMatrix(initializer,
mat );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
305 ISTL::Impl::BCCSMatrix<typename BCRSMatrix<B,TA>::field_type,
int >::free();
│ │ │ │ -
306 SUPERLU_FREE(A.Store);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
312 template <
class B,
class A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
314 :
public ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<B,A>, int>
│ │ │ │ -
│ │ │ │ -
316 template <
class I,
class S,
class D>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
331 ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<B,A>,
int >::createMatrix();
│ │ │ │ -
│ │ │ │ -
333 ::create (&slumat->A, slumat->N_, slumat->M_, slumat->colstart[this->cols],
│ │ │ │ -
334 slumat->values,slumat->rowindex, slumat->colstart, SLU_NC,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
This file implements a vector space as a tensor product of a given vector space. The number of compon...
│ │ │ │ -
Implementation of the BCRSMatrix class.
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
Matrix & mat
Definition matrixmatrix.hh:347
│ │ │ │ -
│ │ │ │ +
68 for (I index1=index; index1 != endIndex; ++index1)
│ │ │ │ +
│ │ │ │ +
70 !
get (visitedMap, index1.index())) {
│ │ │ │ +
│ │ │ │ +
72 aggregates.template breadthFirstSearch<false>(index1.index(), aggregates[index1.index()],
│ │ │ │ +
73 graph, renumberer, visitedMap);
│ │ │ │ +
74 aggregates[index1.index()] = renumberer;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
77 for (; index != endIndex; ++index)
│ │ │ │ +
78 put(visitedMap, index.index(),
false );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Provides classes for the Coloring process of AMG.
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
Initializer for SuperLU Matrices representing the subdomains.
Definition overlappingschwarz.hh:47
│ │ │ │ -
static auto coldim(const M &A)
Definition matrixutils.hh:219
│ │ │ │ -
static auto rowdim(const M &A)
Definition matrixutils.hh:214
│ │ │ │ -
A sparse block matrix with compressed row storage.
Definition bcrsmatrix.hh:466
│ │ │ │ -
A::size_type size_type
The type for the index access and the size.
Definition bcrsmatrix.hh:497
│ │ │ │ -
Sequential overlapping Schwarz preconditioner.
Definition overlappingschwarz.hh:755
│ │ │ │ -
Definition overlappingschwarz.hh:694
│ │ │ │ -
SuperLu Solver.
Definition superlu.hh:271
│ │ │ │ -
Definition supermatrix.hh:26
│ │ │ │ -
Definition supermatrix.hh:30
│ │ │ │ -
Definition supermatrix.hh:126
│ │ │ │ -
static const Dtype_t type
Definition supermatrix.hh:127
│ │ │ │ -
Definition supermatrix.hh:132
│ │ │ │ -
double float_type
Definition supermatrix.hh:144
│ │ │ │ -
float float_type
Definition supermatrix.hh:151
│ │ │ │ -
double float_type
Definition supermatrix.hh:158
│ │ │ │ -
float float_type
Definition supermatrix.hh:165
│ │ │ │ -
Utility class for converting an ISTL Matrix into a SuperLU Matrix.
Definition supermatrix.hh:175
│ │ │ │ -
Definition supermatrix.hh:179
│ │ │ │ -
virtual void free()
free allocated space.
Definition supermatrix.hh:303
│ │ │ │ -
SuperLUMatrix< BCRSMatrix< B, TA > > & operator=(const SuperLUMatrix< BCRSMatrix< B, TA > > &mat)
Definition supermatrix.hh:256
│ │ │ │ -
SuperLUMatrix< BCRSMatrix< B, TA > > & operator=(const BCRSMatrix< B, TA > &mat)
Definition supermatrix.hh:237
│ │ │ │ -
SuperLUMatrix(const Matrix &mat)
Constructor that initializes the data.
Definition supermatrix.hh:212
│ │ │ │ -
virtual void setMatrix(const Matrix &mat)
Initialize data from given matrix.
Definition supermatrix.hh:293
│ │ │ │ -
SuperLUMatrix()
Definition supermatrix.hh:215
│ │ │ │ -
Matrix::size_type size_type
Definition supermatrix.hh:206
│ │ │ │ -
BCRSMatrix< B, TA > Matrix
The type of the matrix to convert.
Definition supermatrix.hh:202
│ │ │ │ -
virtual void setMatrix(const Matrix &mat, const std::set< std::size_t > &mrs)
Initialize data from a given set of matrix rows and columns.
Definition supermatrix.hh:281
│ │ │ │ -
virtual ~SuperLUMatrix()
Destructor.
Definition supermatrix.hh:219
│ │ │ │ -
Dune::SuperLUMatrix< Matrix > SuperLUMatrix
Definition supermatrix.hh:320
│ │ │ │ -
BCRSMatrix< B, A > Matrix
Definition supermatrix.hh:319
│ │ │ │ -
SuperMatrixInitializer()
Definition supermatrix.hh:326
│ │ │ │ -
virtual void createMatrix() const
Definition supermatrix.hh:329
│ │ │ │ -
SuperMatrixInitializer(SuperLUMatrix &lum)
Definition supermatrix.hh:322
│ │ │ │ +
PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > >::Type get(const Amg::VertexVisitedTag &tag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > &graph)
Definition dependency.hh:293
│ │ │ │ +
void renumberAggregates(const G &graph, I index, I endIndex, V &visitedMap, AggregatesMap< typename G::VertexDescriptor > &aggregates)
Definition renumberer.hh:63
│ │ │ │ +
Class providing information about the mapping of the vertices onto aggregates.
Definition aggregates.hh:560
│ │ │ │ +
Definition renumberer.hh:16
│ │ │ │ +
void operator++()
Definition renumberer.hh:57
│ │ │ │ +
G::VertexDescriptor Vertex
The vertex type.
Definition renumberer.hh:19
│ │ │ │ +
void operator()(const typename G::ConstEdgeIterator &edge)
Definition renumberer.hh:51
│ │ │ │ +
AggregatesMap< Vertex > & aggregates_
Definition renumberer.hh:36
│ │ │ │ +
AggregateRenumberer(AggregatesMap< Vertex > &aggregates)
Constructor.
Definition renumberer.hh:40
│ │ │ │ +
Vertex number_
Definition renumberer.hh:35
│ │ │ │
│ │ │ │ │ -13#include
│ │ │ │ │ -14#include
│ │ │ │ │ -15#include
│ │ │ │ │ -16
│ │ │ │ │ -17#include <_d_u_n_e_/_i_s_t_l_/_b_c_c_s_m_a_t_r_i_x_i_n_i_t_i_a_l_i_z_e_r_._h_h>
│ │ │ │ │ -18
│ │ │ │ │ -19#include "_s_u_p_e_r_l_u_f_u_n_c_t_i_o_n_s_._h_h"
│ │ │ │ │ +10namespace _D_u_n_e
│ │ │ │ │ +11{
│ │ │ │ │ +12 namespace Amg
│ │ │ │ │ +13 {
│ │ │ │ │ +14 template
│ │ │ │ │ +_1_5 class _A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r
│ │ │ │ │ +16 {
│ │ │ │ │ +17 public:
│ │ │ │ │ +_1_9 typedef typename G::VertexDescriptor _V_e_r_t_e_x;
│ │ │ │ │ 20
│ │ │ │ │ -21namespace _D_u_n_e
│ │ │ │ │ -22{
│ │ │ │ │ -23
│ │ │ │ │ -24 template
│ │ │ │ │ -_2_5 struct _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
│ │ │ │ │ -26 {};
│ │ │ │ │ -27
│ │ │ │ │ -28 template
│ │ │ │ │ -_2_9 struct _S_u_p_e_r_M_a_t_r_i_x_P_r_i_n_t_e_r
│ │ │ │ │ -30 {};
│ │ │ │ │ +25 _A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r(_A_g_g_r_e_g_a_t_e_s_M_a_p_<_V_e_r_t_e_x_>& aggregates);
│ │ │ │ │ +26
│ │ │ │ │ +28 operator _V_e_r_t_e_x() const;
│ │ │ │ │ +29
│ │ │ │ │ +30 void _o_p_e_r_a_t_o_r_(_)(const typename G::ConstEdgeIterator& edge);
│ │ │ │ │ 31
│ │ │ │ │ -32#if __has_include("slu_sdefs.h")
│ │ │ │ │ -33 template<>
│ │ │ │ │ -34 struct _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
│ │ │ │ │ -35 {
│ │ │ │ │ -36 static void create(SuperMatrix *_m_a_t, int n, int m, int offset,
│ │ │ │ │ -37 float *values, int *rowindex, int* colindex,
│ │ │ │ │ -38 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ │ -39 {
│ │ │ │ │ -40 sCreate_CompCol_Matrix(_m_a_t, n, m, offset, values, rowindex, colindex,
│ │ │ │ │ -41 stype, dtype, mtype);
│ │ │ │ │ -42 }
│ │ │ │ │ -43 };
│ │ │ │ │ -44
│ │ │ │ │ -45 template<>
│ │ │ │ │ -46 struct SuperMatrixPrinter
│ │ │ │ │ -47 {
│ │ │ │ │ -48 static void print(char* name, SuperMatrix* _m_a_t)
│ │ │ │ │ -49 {
│ │ │ │ │ -50 sPrint_CompCol_Matrix(name, _m_a_t);
│ │ │ │ │ -51 }
│ │ │ │ │ -52 };
│ │ │ │ │ -53#endif
│ │ │ │ │ -54
│ │ │ │ │ -55#if __has_include("slu_ddefs.h")
│ │ │ │ │ -56 template<>
│ │ │ │ │ -57 struct SuperMatrixCreateSparseChooser
│ │ │ │ │ +32 void _o_p_e_r_a_t_o_r_+_+();
│ │ │ │ │ +33
│ │ │ │ │ +34 protected:
│ │ │ │ │ +_3_5 _V_e_r_t_e_x _n_u_m_b_e_r__;
│ │ │ │ │ +_3_6 _A_g_g_r_e_g_a_t_e_s_M_a_p_<_V_e_r_t_e_x_>& _a_g_g_r_e_g_a_t_e_s__;
│ │ │ │ │ +37 };
│ │ │ │ │ +38
│ │ │ │ │ +39 template
│ │ │ │ │ +_4_0 _A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_<_G_>_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r(_A_g_g_r_e_g_a_t_e_s_M_a_p_<_V_e_r_t_e_x_>&
│ │ │ │ │ +aggregates)
│ │ │ │ │ +41 : number_(0), aggregates_(aggregates)
│ │ │ │ │ +42 {}
│ │ │ │ │ +43
│ │ │ │ │ +44 template
│ │ │ │ │ +_4_5 _A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_<_G_>_:_:_o_p_e_r_a_t_o_r _V_e_r_t_e_x() const
│ │ │ │ │ +46 {
│ │ │ │ │ +47 return number_;
│ │ │ │ │ +48 }
│ │ │ │ │ +49
│ │ │ │ │ +50 template
│ │ │ │ │ +_5_1 void _A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_<_G_>_:_:_o_p_e_r_a_t_o_r_(_)(const typename G::ConstEdgeIterator&
│ │ │ │ │ +edge)
│ │ │ │ │ +52 {
│ │ │ │ │ +53 aggregates_[edge.target()]=number_;
│ │ │ │ │ +54 }
│ │ │ │ │ +55
│ │ │ │ │ +56 template
│ │ │ │ │ +_5_7 void _A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_<_G_>_:_:_o_p_e_r_a_t_o_r_+_+()
│ │ │ │ │ 58 {
│ │ │ │ │ -59 static void create(SuperMatrix *_m_a_t, int n, int m, int offset,
│ │ │ │ │ -60 double *values, int *rowindex, int* colindex,
│ │ │ │ │ -61 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ │ -62 {
│ │ │ │ │ -63 dCreate_CompCol_Matrix(_m_a_t, n, m, offset, values, rowindex, colindex,
│ │ │ │ │ -64 stype, dtype, mtype);
│ │ │ │ │ -65 }
│ │ │ │ │ -66 };
│ │ │ │ │ +59 ++number_;
│ │ │ │ │ +60 }
│ │ │ │ │ +61
│ │ │ │ │ +62 template
│ │ │ │ │ +_6_3 void _r_e_n_u_m_b_e_r_A_g_g_r_e_g_a_t_e_s(const G& graph, I index, I endIndex, V& visitedMap,
│ │ │ │ │ +64 _A_g_g_r_e_g_a_t_e_s_M_a_p_<_t_y_p_e_n_a_m_e_ _G_:_:_V_e_r_t_e_x_D_e_s_c_r_i_p_t_o_r_>& aggregates)
│ │ │ │ │ +65 {
│ │ │ │ │ +66 _A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_<_G_> renumberer(aggregates);
│ │ │ │ │ 67
│ │ │ │ │ -68 template<>
│ │ │ │ │ -69 struct SuperMatrixPrinter
│ │ │ │ │ -70 {
│ │ │ │ │ -71 static void print(char* name, SuperMatrix* _m_a_t)
│ │ │ │ │ -72 {
│ │ │ │ │ -73 dPrint_CompCol_Matrix(name, _m_a_t);
│ │ │ │ │ -74 }
│ │ │ │ │ -75 };
│ │ │ │ │ -76#endif
│ │ │ │ │ -77
│ │ │ │ │ -78#if __has_include("slu_cdefs.h")
│ │ │ │ │ -79 template<>
│ │ │ │ │ -80 struct SuperMatrixCreateSparseChooser<_s_t_d::complex >
│ │ │ │ │ -81 {
│ │ │ │ │ -82 static void create(SuperMatrix *_m_a_t, int n, int m, int offset,
│ │ │ │ │ -83 std::complex *values, int *rowindex, int* colindex,
│ │ │ │ │ -84 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ │ -85 {
│ │ │ │ │ -86 cCreate_CompCol_Matrix(_m_a_t, n, m, offset, reinterpret_cast< ::complex*>
│ │ │ │ │ -(values),
│ │ │ │ │ -87 rowindex, colindex, stype, dtype, mtype);
│ │ │ │ │ -88 }
│ │ │ │ │ -89 };
│ │ │ │ │ -90
│ │ │ │ │ -91 template<>
│ │ │ │ │ -92 struct SuperMatrixPrinter<_s_t_d::complex >
│ │ │ │ │ -93 {
│ │ │ │ │ -94 static void print(char* name, SuperMatrix* _m_a_t)
│ │ │ │ │ -95 {
│ │ │ │ │ -96 cPrint_CompCol_Matrix(name, _m_a_t);
│ │ │ │ │ -97 }
│ │ │ │ │ -98 };
│ │ │ │ │ -99#endif
│ │ │ │ │ -100
│ │ │ │ │ -101#if __has_include("slu_zdefs.h")
│ │ │ │ │ -102 template<>
│ │ │ │ │ -103 struct SuperMatrixCreateSparseChooser<_s_t_d::complex >
│ │ │ │ │ -104 {
│ │ │ │ │ -105 static void create(SuperMatrix *_m_a_t, int n, int m, int offset,
│ │ │ │ │ -106 std::complex *values, int *rowindex, int* colindex,
│ │ │ │ │ -107 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ │ -108 {
│ │ │ │ │ -109 zCreate_CompCol_Matrix(_m_a_t, n, m, offset, reinterpret_cast
│ │ │ │ │ -(values),
│ │ │ │ │ -110 rowindex, colindex, stype, dtype, mtype);
│ │ │ │ │ -111 }
│ │ │ │ │ -112 };
│ │ │ │ │ -113
│ │ │ │ │ -114 template<>
│ │ │ │ │ -115 struct SuperMatrixPrinter<_s_t_d::complex >
│ │ │ │ │ -116 {
│ │ │ │ │ -117 static void print(char* name, SuperMatrix* _m_a_t)
│ │ │ │ │ -118 {
│ │ │ │ │ -119 zPrint_CompCol_Matrix(name, _m_a_t);
│ │ │ │ │ -120 }
│ │ │ │ │ -121 };
│ │ │ │ │ -122#endif
│ │ │ │ │ -123
│ │ │ │ │ -124 template
│ │ │ │ │ -_1_2_5 struct _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ -126 {
│ │ │ │ │ -_1_2_7 static const Dtype_t _t_y_p_e;
│ │ │ │ │ -128 };
│ │ │ │ │ -129
│ │ │ │ │ -130 template
│ │ │ │ │ -_1_3_1 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ -132 {};
│ │ │ │ │ -133
│ │ │ │ │ -134 template
│ │ │ │ │ -135 const Dtype_t _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_T_>_:_:_t_y_p_e =
│ │ │ │ │ -136 std::is_same::value ? SLU_S :
│ │ │ │ │ -137 ( std::is_same >::value ? SLU_Z :
│ │ │ │ │ -138 ( std::is_same >::value ? SLU_C : SLU_D ));
│ │ │ │ │ -139
│ │ │ │ │ -140 template<>
│ │ │ │ │ -_1_4_1 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ -142 : public _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ -143 {
│ │ │ │ │ -_1_4_4 typedef double _f_l_o_a_t___t_y_p_e;
│ │ │ │ │ -145 };
│ │ │ │ │ -146
│ │ │ │ │ -147 template<>
│ │ │ │ │ -_1_4_8 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ -149 : public _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ -150 {
│ │ │ │ │ -_1_5_1 typedef float _f_l_o_a_t___t_y_p_e;
│ │ │ │ │ -152 };
│ │ │ │ │ -153
│ │ │ │ │ -154 template<>
│ │ │ │ │ -_1_5_5 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e<_s_t_d::complex >
│ │ │ │ │ -156 : public _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e >
│ │ │ │ │ -157 {
│ │ │ │ │ -_1_5_8 typedef double _f_l_o_a_t___t_y_p_e;
│ │ │ │ │ -159 };
│ │ │ │ │ -160
│ │ │ │ │ -161 template<>
│ │ │ │ │ -_1_6_2 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e<_s_t_d::complex >
│ │ │ │ │ -163 : public _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e >
│ │ │ │ │ -164 {
│ │ │ │ │ -_1_6_5 typedef float _f_l_o_a_t___t_y_p_e;
│ │ │ │ │ -166
│ │ │ │ │ -167 };
│ │ │ │ │ -168
│ │ │ │ │ -173 template
│ │ │ │ │ -_1_7_4 struct _S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ -175 {};
│ │ │ │ │ -176
│ │ │ │ │ -177 template
│ │ │ │ │ -_1_7_8 struct _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ -179 {};
│ │ │ │ │ -180
│ │ │ │ │ -181 template
│ │ │ │ │ -182 class _S_u_p_e_r_L_U;
│ │ │ │ │ -183
│ │ │ │ │ -184 template
│ │ │ │ │ -185 class _S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z;
│ │ │ │ │ -186
│ │ │ │ │ -187 template
│ │ │ │ │ -188 struct _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;
│ │ │ │ │ -189
│ │ │ │ │ -193 template
│ │ │ │ │ -_1_9_4 class _S_u_p_e_r_L_U_M_a_t_r_i_x<_B_C_R_S_M_a_t_r_i_x >
│ │ │ │ │ -195 : public ISTL::Impl::BCCSMatrix::field_type, int>
│ │ │ │ │ -196 {
│ │ │ │ │ -197 template
│ │ │ │ │ -_1_9_8 friend class _S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z;
│ │ │ │ │ -199 friend struct _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 >;
│ │ │ │ │ -200 public:
│ │ │ │ │ -_2_0_2 typedef _B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_> _M_a_t_r_i_x;
│ │ │ │ │ -203
│ │ │ │ │ -204 friend struct _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<_S_u_p_e_r_L_U<_M_a_t_r_i_x>, true>;
│ │ │ │ │ -205
│ │ │ │ │ -_2_0_6 typedef typename _M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e _s_i_z_e___t_y_p_e;
│ │ │ │ │ -207
│ │ │ │ │ -_2_1_2 explicit _S_u_p_e_r_L_U_M_a_t_r_i_x(const _M_a_t_r_i_x& _m_a_t) : ISTL::Impl::
│ │ │ │ │ -BCCSMatrix<_B_C_R_S_M_a_t_r_i_x, int>(_m_a_t)
│ │ │ │ │ -213 {}
│ │ │ │ │ -214
│ │ │ │ │ -_2_1_5 _S_u_p_e_r_L_U_M_a_t_r_i_x() : ISTL::Impl::BCCSMatrix::
│ │ │ │ │ -field_type, int>()
│ │ │ │ │ -216 {}
│ │ │ │ │ -217
│ │ │ │ │ -_2_1_9 virtual _~_S_u_p_e_r_L_U_M_a_t_r_i_x()
│ │ │ │ │ -220 {
│ │ │ │ │ -221 if (this->N_+this->M_*this->Nnz_ != 0)
│ │ │ │ │ -222 free();
│ │ │ │ │ -223 }
│ │ │ │ │ -224
│ │ │ │ │ -_2_2_6 operator SuperMatrix&()
│ │ │ │ │ -227 {
│ │ │ │ │ -228 return A;
│ │ │ │ │ -229 }
│ │ │ │ │ -230
│ │ │ │ │ -_2_3_2 operator const SuperMatrix&() const
│ │ │ │ │ -233 {
│ │ │ │ │ -234 return A;
│ │ │ │ │ -235 }
│ │ │ │ │ -236
│ │ │ │ │ -_2_3_7 _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_=(const _B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_>& _m_a_t)
│ │ │ │ │ -238 {
│ │ │ │ │ -239 if (this->N_ + this->M_ + this->Nnz_!=0)
│ │ │ │ │ -240 free();
│ │ │ │ │ -241
│ │ │ │ │ -242 using _M_a_t_r_i_x = _B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_>;
│ │ │ │ │ -243 this->N_ = _M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_r_o_w_d_i_m(_m_a_t);
│ │ │ │ │ -244 this->M_ = _M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_c_o_l_d_i_m(_m_a_t);
│ │ │ │ │ -245 ISTL::Impl::BCCSMatrixInitializer initializer(*this);
│ │ │ │ │ -246
│ │ │ │ │ -247 copyToBCCSMatrix(initializer, _m_a_t);
│ │ │ │ │ -248
│ │ │ │ │ -249 _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_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e_>
│ │ │ │ │ -250_ _:_:_c_r_e_a_t_e(&A, this->N_, this->M_, this->colstart[this->N_],
│ │ │ │ │ -251 this->values,this->rowindex, this->colstart, SLU_NC,
│ │ │ │ │ -252 static_cast(_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e_>_:_:_t_y_p_e),
│ │ │ │ │ -SLU_GE);
│ │ │ │ │ -253 return *this;
│ │ │ │ │ -254 }
│ │ │ │ │ -255
│ │ │ │ │ -_2_5_6 _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_=(const _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)
│ │ │ │ │ -257 {
│ │ │ │ │ -258 if (this->N_ + this->M_ + this->Nnz_!=0)
│ │ │ │ │ -259 free();
│ │ │ │ │ -260
│ │ │ │ │ -261 using _M_a_t_r_i_x = _B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_>;
│ │ │ │ │ -262 this->N_ = _M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_r_o_w_d_i_m(_m_a_t);
│ │ │ │ │ -263 this->M_ = _M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_c_o_l_d_i_m(_m_a_t);
│ │ │ │ │ -264 ISTL::Impl::BCCSMatrixInitializer initializer(*this);
│ │ │ │ │ -265
│ │ │ │ │ -266 copyToBCCSMatrix(initializer, _m_a_t);
│ │ │ │ │ -267
│ │ │ │ │ -268 _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_<_B_>
│ │ │ │ │ -269_ _:_:_c_r_e_a_t_e(&A, this->N_, this->M_, this->colstart[this->N_],
│ │ │ │ │ -270 this->values,this->rowindex, this->colstart, SLU_NC,
│ │ │ │ │ -271 static_cast(_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_B_>_:_:_t_y_p_e), SLU_GE);
│ │ │ │ │ -272 return *this;
│ │ │ │ │ -273 }
│ │ │ │ │ -274
│ │ │ │ │ -_2_8_1 virtual void _s_e_t_M_a_t_r_i_x(const _M_a_t_r_i_x& _m_a_t, const std::set& mrs)
│ │ │ │ │ -282 {
│ │ │ │ │ -283 if(this->N_+this->M_+this->Nnz_!=0)
│ │ │ │ │ -284 free();
│ │ │ │ │ -285 this->N_=mrs.size()*_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_b_l_o_c_k___t_y_p_e_>_:_:_r_o_w_d_i_m(*
│ │ │ │ │ -(_m_a_t[0].begin()));
│ │ │ │ │ -286 this->M_=mrs.size()*_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_b_l_o_c_k___t_y_p_e_>_:_:_c_o_l_d_i_m(*
│ │ │ │ │ -(_m_a_t[0].begin()));
│ │ │ │ │ -287 _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_M_a_t_r_i_x_> initializer(*this);
│ │ │ │ │ -288
│ │ │ │ │ -289 copyToBCCSMatrix(initializer, ISTL::Impl::MatrixRowSubset<_M_a_t_r_i_x,std::
│ │ │ │ │ -set >(_m_a_t,mrs));
│ │ │ │ │ -290 }
│ │ │ │ │ -291
│ │ │ │ │ -_2_9_3 virtual void _s_e_t_M_a_t_r_i_x(const _M_a_t_r_i_x& _m_a_t)
│ │ │ │ │ -294 {
│ │ │ │ │ -295 this->N_=_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_r_o_w_d_i_m(_m_a_t);
│ │ │ │ │ -296 this->M_=_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_c_o_l_d_i_m(_m_a_t);
│ │ │ │ │ -297 _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_M_a_t_r_i_x_> initializer(*this);
│ │ │ │ │ -298
│ │ │ │ │ -299 copyToBCCSMatrix(initializer, _m_a_t);
│ │ │ │ │ -300 }
│ │ │ │ │ -301
│ │ │ │ │ -_3_0_3 virtual void _f_r_e_e()
│ │ │ │ │ -304 {
│ │ │ │ │ -305 ISTL::Impl::BCCSMatrix::field_type, int>::free();
│ │ │ │ │ -306 SUPERLU_FREE(A.Store);
│ │ │ │ │ -307 }
│ │ │ │ │ -308 private:
│ │ │ │ │ -309 SuperMatrix A;
│ │ │ │ │ -310 };
│ │ │ │ │ -311
│ │ │ │ │ -312 template
│ │ │ │ │ -_3_1_3 class _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 >
│ │ │ │ │ -314 : public ISTL::Impl::BCCSMatrixInitializer, int>
│ │ │ │ │ -315 {
│ │ │ │ │ -316 template
│ │ │ │ │ -_3_1_7 friend class _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;
│ │ │ │ │ -318 public:
│ │ │ │ │ -_3_1_9 typedef _B_C_R_S_M_a_t_r_i_x_<_B_,_A_> _M_a_t_r_i_x;
│ │ │ │ │ -_3_2_0 typedef _D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_M_a_t_r_i_x_> _S_u_p_e_r_L_U_M_a_t_r_i_x;
│ │ │ │ │ -321
│ │ │ │ │ -_3_2_2 _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r(_S_u_p_e_r_L_U_M_a_t_r_i_x& lum) : ISTL::Impl::
│ │ │ │ │ -BCCSMatrixInitializer<_B_C_R_S_M_a_t_r_i_x, int>(lum)
│ │ │ │ │ -323 ,slumat(&lum)
│ │ │ │ │ -324 {}
│ │ │ │ │ -325
│ │ │ │ │ -_3_2_6 _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r() : ISTL::Impl::
│ │ │ │ │ -BCCSMatrixInitializer<_B_C_R_S_M_a_t_r_i_x, int>()
│ │ │ │ │ -327 {}
│ │ │ │ │ -328
│ │ │ │ │ -_3_2_9 virtual void _c_r_e_a_t_e_M_a_t_r_i_x() const
│ │ │ │ │ -330 {
│ │ │ │ │ -331 ISTL::Impl::BCCSMatrixInitializer, int>::createMatrix();
│ │ │ │ │ -332 _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_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e_>
│ │ │ │ │ -333_ _:_:_c_r_e_a_t_e(&slumat->A, slumat->N_, slumat->M_, slumat->colstart[this->cols],
│ │ │ │ │ -334 slumat->values,slumat->rowindex, slumat->colstart, SLU_NC,
│ │ │ │ │ -335 static_cast(_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e_>_:_:_t_y_p_e),
│ │ │ │ │ -SLU_GE);
│ │ │ │ │ -336 }
│ │ │ │ │ -337 private:
│ │ │ │ │ -338 _S_u_p_e_r_L_U_M_a_t_r_i_x* slumat;
│ │ │ │ │ -339 };
│ │ │ │ │ -340}
│ │ │ │ │ -341#endif // HAVE_SUPERLU
│ │ │ │ │ -342#endif
│ │ │ │ │ -_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...
│ │ │ │ │ -_b_c_r_s_m_a_t_r_i_x_._h_h
│ │ │ │ │ -Implementation of the BCRSMatrix class.
│ │ │ │ │ -_s_u_p_e_r_l_u_f_u_n_c_t_i_o_n_s_._h_h
│ │ │ │ │ -_b_c_c_s_m_a_t_r_i_x_i_n_i_t_i_a_l_i_z_e_r_._h_h
│ │ │ │ │ -_m_a_t
│ │ │ │ │ -Matrix & mat
│ │ │ │ │ -DDeeffiinniittiioonn matrixmatrix.hh:347
│ │ │ │ │ -_s_t_d
│ │ │ │ │ -STL namespace.
│ │ │ │ │ +68 for(I index1=index; index1 != endIndex; ++index1)
│ │ │ │ │ +69 if(aggregates[index1.index()]!=_A_g_g_r_e_g_a_t_e_s_M_a_p_<_t_y_p_e_n_a_m_e_ _G_:_:_V_e_r_t_e_x_D_e_s_c_r_i_p_t_o_r_>_:_:
│ │ │ │ │ +_I_S_O_L_A_T_E_D &&
│ │ │ │ │ +70 !_g_e_t(visitedMap, index1.index())) {
│ │ │ │ │ +71
│ │ │ │ │ +72 aggregates.template breadthFirstSearch(index1.index(), aggregates
│ │ │ │ │ +[index1.index()],
│ │ │ │ │ +73 graph, renumberer, visitedMap);
│ │ │ │ │ +74 aggregates[index1.index()] = renumberer;
│ │ │ │ │ +75 ++renumberer;
│ │ │ │ │ +76 }
│ │ │ │ │ +77 for(; index != endIndex; ++index)
│ │ │ │ │ +78 put(visitedMap, index.index(), false);
│ │ │ │ │ +79 }
│ │ │ │ │ +80
│ │ │ │ │ +81 } // namespace AMG
│ │ │ │ │ +82} // namespace Dune
│ │ │ │ │ +83#endif
│ │ │ │ │ +_a_g_g_r_e_g_a_t_e_s_._h_h
│ │ │ │ │ +Provides classes for the Coloring process of AMG.
│ │ │ │ │ _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:497
│ │ │ │ │ -_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_:_:_g_e_t
│ │ │ │ │ +PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::
│ │ │ │ │ +VertexProperties, EP, VM, EM > >::Type get(const Amg::VertexVisitedTag &tag,
│ │ │ │ │ +Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > &graph)
│ │ │ │ │ +DDeeffiinniittiioonn dependency.hh:293
│ │ │ │ │ +_D_u_n_e_:_:_A_m_g_:_:_r_e_n_u_m_b_e_r_A_g_g_r_e_g_a_t_e_s
│ │ │ │ │ +void renumberAggregates(const G &graph, I index, I endIndex, V &visitedMap,
│ │ │ │ │ +AggregatesMap< typename G::VertexDescriptor > &aggregates)
│ │ │ │ │ +DDeeffiinniittiioonn renumberer.hh:63
│ │ │ │ │ +_D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_s_M_a_p
│ │ │ │ │ +Class providing information about the mapping of the vertices onto aggregates.
│ │ │ │ │ +DDeeffiinniittiioonn aggregates.hh:560
│ │ │ │ │ +_D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r
│ │ │ │ │ +DDeeffiinniittiioonn renumberer.hh:16
│ │ │ │ │ +_D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_:_:_o_p_e_r_a_t_o_r_+_+
│ │ │ │ │ +void operator++()
│ │ │ │ │ +DDeeffiinniittiioonn renumberer.hh:57
│ │ │ │ │ +_D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_:_:_V_e_r_t_e_x
│ │ │ │ │ +G::VertexDescriptor Vertex
│ │ │ │ │ +The vertex type.
│ │ │ │ │ +DDeeffiinniittiioonn renumberer.hh:19
│ │ │ │ │ +_D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_:_:_o_p_e_r_a_t_o_r_(_)
│ │ │ │ │ +void operator()(const typename G::ConstEdgeIterator &edge)
│ │ │ │ │ +DDeeffiinniittiioonn renumberer.hh:51
│ │ │ │ │ +_D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_:_:_a_g_g_r_e_g_a_t_e_s__
│ │ │ │ │ +AggregatesMap< Vertex > & aggregates_
│ │ │ │ │ +DDeeffiinniittiioonn renumberer.hh:36
│ │ │ │ │ +_D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r
│ │ │ │ │ +AggregateRenumberer(AggregatesMap< Vertex > &aggregates)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn renumberer.hh:40
│ │ │ │ │ +_D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_R_e_n_u_m_b_e_r_e_r_:_:_n_u_m_b_e_r__
│ │ │ │ │ +Vertex number_
│ │ │ │ │ +DDeeffiinniittiioonn renumberer.hh:35
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00032.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: bdmatrix.hh File Reference
│ │ │ │ +dune-istl: matrixhierarchy.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │ -
Implementation of the BDMatrix class.
│ │ │ │ +
Provides a classes representing the hierarchies in AMG.
│ │ │ │ More...
│ │ │ │ -
#include <memory>
│ │ │ │ -
#include <dune/common/rangeutilities.hh>
│ │ │ │ -
#include <dune/common/scalarmatrixview.hh>
│ │ │ │ -
#include <dune/istl/bcrsmatrix.hh >
│ │ │ │ -
#include <dune/istl/blocklevel.hh >
│ │ │ │ +
#include <algorithm>
│ │ │ │ +
#include <tuple>
│ │ │ │ +
#include "aggregates.hh "
│ │ │ │ +
#include "graph.hh "
│ │ │ │ +
#include "galerkin.hh "
│ │ │ │ +
#include "renumberer.hh "
│ │ │ │ +
#include "graphcreator.hh "
│ │ │ │ +
#include "hierarchy.hh "
│ │ │ │ +
#include <dune/istl/bvector.hh >
│ │ │ │ +
#include <dune/common/parallel/indexset.hh>
│ │ │ │ +
#include <dune/istl/matrixutils.hh >
│ │ │ │ +
#include <dune/istl/matrixredistribute.hh >
│ │ │ │ +
#include <dune/istl/paamg/dependency.hh >
│ │ │ │ +
#include <dune/istl/paamg/indicescoarsener.hh >
│ │ │ │ +
#include <dune/istl/paamg/globalaggregates.hh >
│ │ │ │ +
#include <dune/istl/paamg/construction.hh >
│ │ │ │ +
#include <dune/istl/paamg/smoother.hh >
│ │ │ │ +
#include <dune/istl/paamg/transfer.hh >
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ namespace Dune namespace Dune::Amg
│ │ │ │ +template<typename M , typename C1 > bool Dune::Amg::repartitionAndDistributeMatrix (const M &origMatrix, std::shared_ptr< M > newMatrix, SequentialInformation &origComm, std::shared_ptr< SequentialInformation > &newComm, RedistributeInformation < SequentialInformation > &ri, int nparts, C1 &criterion) template<typename M , typename C , typename C1 > bool Dune::Amg::repartitionAndDistributeMatrix (const M &origMatrix, std::shared_ptr< M > newMatrix, C &origComm, std::shared_ptr< C > &newComm, RedistributeInformation < C > &ri, int nparts, C1 &criterion)
│ │ │ │
│ │ │ │ -
Implementation of the BDMatrix class.
│ │ │ │ -
Author Oliver Sander
│ │ │ │ +
Provides a classes representing the hierarchies in AMG.
│ │ │ │ +
Author Markus Blatt
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,30 +1,68 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ 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
│ │ │ │ │ -bdmatrix.hh File Reference
│ │ │ │ │ -Implementation of the BDMatrix class. _M_o_r_e_._._.
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include <_d_u_n_e_/_i_s_t_l_/_b_c_r_s_m_a_t_r_i_x_._h_h>
│ │ │ │ │ -#include <_d_u_n_e_/_i_s_t_l_/_b_l_o_c_k_l_e_v_e_l_._h_h>
│ │ │ │ │ + * _p_a_a_m_g
│ │ │ │ │ +_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
│ │ │ │ │ +matrixhierarchy.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_) » _I_t_e_r_a_t_i_v_e_ _S_o_l_v_e_r_s » _P_r_e_c_o_n_d_i_t_i_o_n_e_r_s
│ │ │ │ │ +» _P_a_r_a_l_l_e_l_ _A_l_g_e_b_r_a_i_c_ _M_u_l_t_i_g_r_i_d
│ │ │ │ │ +Provides a classes representing the hierarchies in AMG. _M_o_r_e_._._.
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include "_a_g_g_r_e_g_a_t_e_s_._h_h"
│ │ │ │ │ +#include "_g_r_a_p_h_._h_h"
│ │ │ │ │ +#include "_g_a_l_e_r_k_i_n_._h_h"
│ │ │ │ │ +#include "_r_e_n_u_m_b_e_r_e_r_._h_h"
│ │ │ │ │ +#include "_g_r_a_p_h_c_r_e_a_t_o_r_._h_h"
│ │ │ │ │ +#include "_h_i_e_r_a_r_c_h_y_._h_h"
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_b_v_e_c_t_o_r_._h_h>
│ │ │ │ │ +#include
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_m_a_t_r_i_x_u_t_i_l_s_._h_h>
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_m_a_t_r_i_x_r_e_d_i_s_t_r_i_b_u_t_e_._h_h>
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_d_e_p_e_n_d_e_n_c_y_._h_h>
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_i_n_d_i_c_e_s_c_o_a_r_s_e_n_e_r_._h_h>
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_g_l_o_b_a_l_a_g_g_r_e_g_a_t_e_s_._h_h>
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_c_o_n_s_t_r_u_c_t_i_o_n_._h_h>
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_s_m_o_o_t_h_e_r_._h_h>
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_t_r_a_n_s_f_e_r_._h_h>
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ CCllaasssseess
│ │ │ │ │ - class _D_u_n_e_:_:_B_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>
│ │ │ │ │ - A block-diagonal matrix. _M_o_r_e_._._.
│ │ │ │ │ + class _D_u_n_e_:_:_A_m_g_:_:_M_a_t_r_i_x_H_i_e_r_a_r_c_h_y_<_ _M_,_ _P_I_,_ _A_ _>
│ │ │ │ │ + The hierarchies build by the coarsening process. _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _B_D_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>
│ │ │ │ │ +struct _D_u_n_e_:_:_A_m_g_:_:_M_a_t_r_i_x_H_i_e_r_a_r_c_h_y_<_ _M_,_ _P_I_,_ _A_ _>_:_:_M_a_t_r_i_x_S_t_a_t_s_<_ _M_a_t_r_i_x_,_ _t_r_u_e_ _>_:_:
│ │ │ │ │ + _c_a_l_c
│ │ │ │ │ +
│ │ │ │ │ + class _D_u_n_e_:_:_A_m_g_:_:_C_o_a_r_s_e_n_C_r_i_t_e_r_i_o_n_<_ _T_ _>
│ │ │ │ │ + The criterion describing the stop criteria for the coarsening process.
│ │ │ │ │ + _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ +namespace _D_u_n_e_:_:_A_m_g
│ │ │ │ │ +
│ │ │ │ │ +EEnnuummeerraattiioonnss
│ │ │ │ │ +enum { _D_u_n_e_:_:_A_m_g_:_:_M_A_X___P_R_O_C_E_S_S_E_S = 72000 }
│ │ │ │ │ +
│ │ │ │ │ +FFuunnccttiioonnss
│ │ │ │ │ +template
│ │ │ │ │ +bool _D_u_n_e_:_:_A_m_g_:_:_r_e_p_a_r_t_i_t_i_o_n_A_n_d_D_i_s_t_r_i_b_u_t_e_M_a_t_r_i_x (const M &origMatrix, std::
│ │ │ │ │ + shared_ptr< M > newMatrix, _S_e_q_u_e_n_t_i_a_l_I_n_f_o_r_m_a_t_i_o_n &origComm, std::
│ │ │ │ │ + shared_ptr< _S_e_q_u_e_n_t_i_a_l_I_n_f_o_r_m_a_t_i_o_n > &newComm, _R_e_d_i_s_t_r_i_b_u_t_e_I_n_f_o_r_m_a_t_i_o_n<
│ │ │ │ │ + _S_e_q_u_e_n_t_i_a_l_I_n_f_o_r_m_a_t_i_o_n > &ri, int nparts, C1 &criterion)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +bool _D_u_n_e_:_:_A_m_g_:_:_r_e_p_a_r_t_i_t_i_o_n_A_n_d_D_i_s_t_r_i_b_u_t_e_M_a_t_r_i_x (const M &origMatrix, std::
│ │ │ │ │ + shared_ptr< M > newMatrix, C &origComm, std::shared_ptr< C > &newComm,
│ │ │ │ │ + _R_e_d_i_s_t_r_i_b_u_t_e_I_n_f_o_r_m_a_t_i_o_n< C > &ri, int nparts, C1 &criterion)
│ │ │ │ │ +
│ │ │ │ │ ********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ -Implementation of the BDMatrix class.
│ │ │ │ │ +Provides a classes representing the hierarchies in AMG.
│ │ │ │ │ Author
│ │ │ │ │ - Oliver Sander
│ │ │ │ │ + Markus Blatt
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00032_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: bdmatrix.hh Source File
│ │ │ │ +dune-istl: matrixhierarchy.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_ISTL_BDMATRIX_HH
│ │ │ │ -
6 #define DUNE_ISTL_BDMATRIX_HH
│ │ │ │ +
5 #ifndef DUNE_AMG_MATRIXHIERARCHY_HH
│ │ │ │ +
6 #define DUNE_AMG_MATRIXHIERARCHY_HH
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
10 #include <dune/common/rangeutilities.hh>
│ │ │ │ -
11 #include <dune/common/scalarmatrixview.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
31 template <
class B,
class A=std::allocator<B> >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
39 using field_type =
typename Imp::BlockTraits<B>::field_type;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
17 #include <dune/common/parallel/indexset.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
59 for (
int i=0; i<size; i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
64 for (
int i=0; i<size; i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
59 template <
class M,
class PI,
class A=std::allocator<M> >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
67 typedef typename MatrixOperator::matrix_type
Matrix ;
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
72 BDMatrix (std::initializer_list<B>
const &list)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
76 for (
auto it = list.begin(); it != list.end(); ++it, ++i)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
85 using AAllocator =
typename std::allocator_traits<Allocator>::template rebind_alloc<AggregatesMap*>;
│ │ │ │
│ │ │ │ -
87 for (
auto i : range(size))
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
92 for (
auto i : range(size))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
116 void solve (V& x,
const V& rhs)
const {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
119 auto && xv = Impl::asVector(x[i]);
│ │ │ │ -
120 auto && rhsv = Impl::asVector(rhs[i]);
│ │ │ │ -
121 Impl::asMatrix((*
this )[i][i]).solve(xv,rhsv);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
128 Impl::asMatrix((*
this )[i][i]).
invert ();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
142 void endrowsizes () {}
│ │ │ │ -
│ │ │ │ -
144 void endindices () {}
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
147 template <
typename B,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
151 using real_type =
typename FieldTraits<field_type>::real_type;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
94 using RILAllocator =
typename std::allocator_traits<Allocator>::template rebind_alloc<RedistributeInfoType>;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
105 std::shared_ptr<ParallelInformation> pinfo = std::make_shared<ParallelInformation>());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
114 template <
typename O,
typename T>
│ │ │ │ +
115 void build (
const T& criterion);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
131 template <
class V,
class BA,
class TA>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
139 template <
class S,
class TA>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
147 std::size_t
levels ()
const ;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
Implementation of the BCRSMatrix class.
│ │ │ │ -
Helper functions for determining the vector/matrix block level.
│ │ │ │ -
Col col
Definition matrixmatrix.hh:351
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
228 template <
class Matrix,
bool pr
int >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
235 static void stats([[maybe_unused]]
const Matrix & matrix)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
239 template <
class Matrix>
│ │ │ │ +
240 struct MatrixStats<
Matrix ,true>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
249 min=std::numeric_limits<size_type>::max();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
256 min=std::min(min, row.size());
│ │ │ │ +
257 max=std::max(max, row.size());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
268 static void stats(
const Matrix & matrix)
│ │ │ │ +
│ │ │ │ +
270 calc c= for_each(matrix.begin(), matrix.end(), calc());
│ │ │ │ +
271 dinfo<<
"Matrix row: min=" <<c.min<<
" max=" <<c.max
│ │ │ │ +
272 <<
" average=" <<
static_cast< double > (c.sum)/matrix.N()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
315 template <
typename M,
typename C1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
317 [[maybe_unused]] std::shared_ptr<M> newMatrix,
│ │ │ │ +
│ │ │ │ +
319 [[maybe_unused]] std::shared_ptr<SequentialInformation>& newComm,
│ │ │ │ +
│ │ │ │ +
321 [[maybe_unused]]
int nparts,
│ │ │ │ +
322 [[maybe_unused]] C1& criterion)
│ │ │ │ +
│ │ │ │ +
324 DUNE_THROW(NotImplemented,
"Redistribution does not make sense in sequential code!" );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
328 template <
typename M,
typename C,
typename C1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
330 std::shared_ptr<M> newMatrix,
│ │ │ │ +
│ │ │ │ +
332 std::shared_ptr<C>& newComm,
│ │ │ │ +
│ │ │ │ +
334 int nparts, C1& criterion)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
337 #ifdef AMG_REPART_ON_COMM_GRAPH
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
341 criterion.debugLevel()>1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
355 if (origComm.communicator().rank()==0)
│ │ │ │ +
356 std::cout<<
"Original matrix" <<std::endl;
│ │ │ │ +
357 origComm.communicator().barrier();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
361 newComm, ri.getInterface(),
│ │ │ │ +
362 criterion.debugLevel()>1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
365 if (origComm.communicator().rank()==0 && criterion.debugLevel()>1)
│ │ │ │ +
366 std::cout<<
"Repartitioning took " <<time.elapsed()<<
" seconds." <<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
371 ri.checkInterface(origComm.indexSet(), newComm->indexSet(), origComm.communicator());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
377 if (origComm.communicator().rank()==0)
│ │ │ │ +
378 std::cout<<
"Original matrix" <<std::endl;
│ │ │ │ +
379 origComm.communicator().barrier();
│ │ │ │ +
380 if (newComm->communicator().size()>0)
│ │ │ │ +
│ │ │ │ +
382 origComm.communicator().barrier();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
385 if (origComm.communicator().rank()==0 && criterion.debugLevel()>1)
│ │ │ │ +
386 std::cout<<
"Redistributing matrix took " <<time.elapsed()<<
" seconds." <<std::endl;
│ │ │ │ +
387 return existentOnRedist;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
391 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
393 std::shared_ptr<ParallelInformation> pinfo)
│ │ │ │ +
394 : matrices_(fineMatrix),
│ │ │ │ +
395 parallelInformation_(pinfo)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
398 DUNE_THROW(
ISTLError ,
"MatrixOperator and ParallelInformation must belong to the same category!" );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
401 template <
class M,
class IS,
class A>
│ │ │ │ +
402 template <
typename O,
typename T>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
405 prolongDamp_ = criterion.getProlongationDampingFactor();
│ │ │ │ +
406 typedef O OverlapFlags;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
412 typedef bigunsignedint<
sizeof (int)*8*noints> BIGINT;
│ │ │ │ +
│ │ │ │ +
414 MatIterator mlevel = matrices_.finest();
│ │ │ │ +
415 MatrixStats<typename M::matrix_type,MINIMAL_DEBUG_LEVEL<=INFO_DEBUG_LEVEL>::stats(mlevel->getmat());
│ │ │ │ +
│ │ │ │ +
417 PInfoIterator infoLevel = parallelInformation_.finest();
│ │ │ │ +
│ │ │ │ +
419 finenonzeros = infoLevel->communicator().sum(finenonzeros);
│ │ │ │ +
420 BIGINT allnonzeros = finenonzeros;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
426 BIGINT unknowns = mlevel->getmat().N();
│ │ │ │ +
│ │ │ │ +
428 unknowns = infoLevel->communicator().sum(unknowns);
│ │ │ │ +
429 double dunknowns=unknowns.todouble();
│ │ │ │ +
430 infoLevel->buildGlobalLookup(mlevel->getmat().N());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
433 for (; level < criterion.maxLevel(); ++level, ++mlevel) {
│ │ │ │ +
434 assert(matrices_.levels()==redistributes_.size());
│ │ │ │ +
435 rank = infoLevel->communicator().rank();
│ │ │ │ +
436 if (rank==0 && criterion.debugLevel()>1)
│ │ │ │ +
437 std::cout<<
"Level " <<level<<
" has " <<dunknowns<<
" unknowns, " <<dunknowns/infoLevel->communicator().size()
│ │ │ │ +
438 <<
" unknowns per proc (procs=" <<infoLevel->communicator().size()<<
")" <<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
450 && dunknowns < 30*infoLevel->communicator().size()))
│ │ │ │ +
451 && infoLevel->communicator().size()>1 &&
│ │ │ │ +
452 dunknowns/infoLevel->communicator().size() <= criterion.coarsenTarget())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
455 std::shared_ptr<Matrix> redistMat = std::make_shared<Matrix>();
│ │ │ │ +
456 std::shared_ptr<ParallelInformation> redistComm;
│ │ │ │ +
457 std::size_t nodomains = (std::size_t)std::ceil(dunknowns/(criterion.minAggregateSize()
│ │ │ │ +
458 *criterion.coarsenTarget()));
│ │ │ │ +
459 if ( nodomains<=criterion.minAggregateSize()/2 ||
│ │ │ │ +
460 dunknowns <= criterion.coarsenTarget() )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
463 bool existentOnNextLevel =
│ │ │ │ +
│ │ │ │ +
465 redistComm, redistributes_.back(), nodomains,
│ │ │ │ +
│ │ │ │ +
467 BIGINT unknownsRedist = redistMat->N();
│ │ │ │ +
468 unknownsRedist = infoLevel->communicator().sum(unknownsRedist);
│ │ │ │ +
469 dunknowns= unknownsRedist.todouble();
│ │ │ │ +
470 if (redistComm->communicator().rank()==0 && criterion.debugLevel()>1)
│ │ │ │ +
471 std::cout<<
"Level " <<level<<
" (redistributed) has " <<dunknowns<<
" unknowns, " <<dunknowns/redistComm->communicator().size()
│ │ │ │ +
472 <<
" unknowns per proc (procs=" <<redistComm->communicator().size()<<
")" <<std::endl;
│ │ │ │ +
473 MatrixArgs args(redistMat, *redistComm);
│ │ │ │ +
│ │ │ │ +
475 assert(mlevel.isRedistributed());
│ │ │ │ +
476 infoLevel.addRedistributed(redistComm);
│ │ │ │ +
477 infoLevel->freeGlobalLookup();
│ │ │ │ +
│ │ │ │ +
479 if (!existentOnNextLevel)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
484 matrix = &(mlevel.getRedistributed());
│ │ │ │ +
485 info = &(infoLevel.getRedistributed());
│ │ │ │ +
486 info->buildGlobalLookup(matrix->getmat().N());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
489 rank = info->communicator().rank();
│ │ │ │ +
490 if (dunknowns <= criterion.coarsenTarget())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
496 typedef typename GraphCreator::GraphTuple GraphTuple;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
500 std::vector<bool> excluded(matrix->getmat().N(),
false );
│ │ │ │ +
│ │ │ │ +
502 GraphTuple graphs = GraphCreator::create(*matrix, excluded, *info, OverlapFlags());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
506 aggregatesMaps_.push_back(aggregatesMap);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
510 auto [noAggregates, isoAggregates, oneAggregates, skippedAggregates] =
│ │ │ │ +
511 aggregatesMap->
buildAggregates (matrix->getmat(), *(std::get<1>(graphs)), criterion, level==0);
│ │ │ │ +
│ │ │ │ +
513 if (rank==0 && criterion.debugLevel()>2)
│ │ │ │ +
514 std::cout<<
" Have built " <<noAggregates<<
" aggregates totally (" <<isoAggregates<<
" isolated aggregates, " <<
│ │ │ │ +
515 oneAggregates<<
" aggregates of one vertex, and skipped " <<
│ │ │ │ +
516 skippedAggregates<<
" aggregates)." <<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
520 int start, end, overlapStart, overlapEnd;
│ │ │ │ +
521 int procs=info->communicator().rank();
│ │ │ │ +
522 int n = UNKNOWNS/procs;
│ │ │ │ +
523 int bigger = UNKNOWNS%procs;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
528 end = (rank+1)*(n+1);
│ │ │ │ +
│ │ │ │ +
530 start = bigger + rank * n;
│ │ │ │ +
531 end = bigger + (rank + 1) * n;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
536 overlapStart = start - 1;
│ │ │ │ +
│ │ │ │ +
538 overlapStart = start;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
541 overlapEnd = end + 1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
545 assert((UNKNOWNS)*(overlapEnd-overlapStart)==aggregatesMap->
noVertices ());
│ │ │ │ +
546 for (
int j=0; j< UNKNOWNS; ++j)
│ │ │ │ +
547 for (
int i=0; i < UNKNOWNS; ++i)
│ │ │ │ +
│ │ │ │ +
549 if (i>=overlapStart && i<overlapEnd)
│ │ │ │ +
│ │ │ │ +
551 int no = (j/2)*((UNKNOWNS)/2)+i/2;
│ │ │ │ +
552 (*aggregatesMap)[j*(overlapEnd-overlapStart)+i-overlapStart]=no;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
557 if (criterion.debugLevel()>1 && info->communicator().rank()==0)
│ │ │ │ +
558 std::cout<<
"aggregating finished." <<std::endl;
│ │ │ │ +
│ │ │ │ +
560 BIGINT gnoAggregates=noAggregates;
│ │ │ │ +
561 gnoAggregates = info->communicator().sum(gnoAggregates);
│ │ │ │ +
562 double dgnoAggregates = gnoAggregates.todouble();
│ │ │ │ +
│ │ │ │ +
564 BIGINT gnoAggregates=((UNKNOWNS)/2)*((UNKNOWNS)/2);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
567 if (criterion.debugLevel()>2 && rank==0)
│ │ │ │ +
568 std::cout <<
"Building " <<dgnoAggregates<<
" aggregates took " <<watch.elapsed()<<
" seconds." <<std::endl;
│ │ │ │ +
│ │ │ │ +
570 if (dgnoAggregates==0 || dunknowns/dgnoAggregates<criterion.minCoarsenRate())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
575 std::cerr <<
"Stopped coarsening because of rate breakdown " <<dunknowns<<
"/" <<dgnoAggregates
│ │ │ │ +
576 <<
"=" <<dunknowns/dgnoAggregates<<
"<"
│ │ │ │ +
577 <<criterion.minCoarsenRate()<<std::endl;
│ │ │ │ +
│ │ │ │ +
579 std::cerr<<
"Could not build any aggregates. Probably no connected nodes." <<std::endl;
│ │ │ │ +
│ │ │ │ +
581 aggregatesMap->
free ();
│ │ │ │ +
582 delete aggregatesMap;
│ │ │ │ +
583 aggregatesMaps_.pop_back();
│ │ │ │ +
│ │ │ │ +
585 if (criterion.accumulate() && mlevel.isRedistributed() && info->communicator().size()>1) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
589 delete &(mlevel.getRedistributed().getmat());
│ │ │ │ +
590 mlevel.deleteRedistributed();
│ │ │ │ +
591 delete &(infoLevel.getRedistributed());
│ │ │ │ +
592 infoLevel.deleteRedistributed();
│ │ │ │ +
593 redistributes_.back().resetSetup();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
598 unknowns = noAggregates;
│ │ │ │ +
599 dunknowns = dgnoAggregates;
│ │ │ │ +
│ │ │ │ +
601 CommunicationArgs commargs(info->communicator(),info->category());
│ │ │ │ +
602 parallelInformation_.addCoarser(commargs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
606 typename PropertyMapTypeSelector<VertexVisitedTag,PropertiesGraph>::Type visitedMap =
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
612 *(std::get<1>(graphs)),
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
617 criterion.useFixedOrder());
│ │ │ │ +
618 GraphCreator::free(graphs);
│ │ │ │ +
│ │ │ │ +
620 if (criterion.debugLevel()>2) {
│ │ │ │ +
│ │ │ │ +
622 std::cout<<
"Coarsening of index sets took " <<watch.elapsed()<<
" seconds." <<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
627 infoLevel->buildGlobalLookup(aggregates);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
630 infoLevel->globalLookup());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
633 if (criterion.debugLevel()>2) {
│ │ │ │ +
│ │ │ │ +
635 std::cout<<
"Communicating global aggregate numbers took " <<watch.elapsed()<<
" seconds." <<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
639 std::vector<bool>& visited=excluded;
│ │ │ │ +
│ │ │ │ +
641 typedef std::vector<bool>::iterator Iterator;
│ │ │ │ +
642 typedef IteratorPropertyMap<Iterator, IdentityMap> VisitedMap2;
│ │ │ │ +
643 Iterator end = visited.end();
│ │ │ │ +
644 for (Iterator iter= visited.begin(); iter != end; ++iter)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
647 VisitedMap2 visitedMap2(visited.begin(), Dune::IdentityMap());
│ │ │ │ +
│ │ │ │ +
649 std::shared_ptr<typename MatrixOperator::matrix_type>
│ │ │ │ +
650 coarseMatrix(productBuilder.build(*(std::get<0>(graphs)), visitedMap2,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
655 dverb<<
"Building of sparsity pattern took " <<watch.elapsed()<<std::endl;
│ │ │ │ +
│ │ │ │ +
657 info->freeGlobalLookup();
│ │ │ │ +
│ │ │ │ +
659 delete std::get<0>(graphs);
│ │ │ │ +
660 productBuilder.calculate(matrix->getmat(), *aggregatesMap, *coarseMatrix, *infoLevel, OverlapFlags());
│ │ │ │ +
│ │ │ │ +
662 if (criterion.debugLevel()>2) {
│ │ │ │ +
│ │ │ │ +
664 std::cout<<
"Calculation entries of Galerkin product took " <<watch.elapsed()<<
" seconds." <<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
668 allnonzeros = allnonzeros + infoLevel->communicator().sum(nonzeros);
│ │ │ │ +
669 MatrixArgs args(coarseMatrix, *infoLevel);
│ │ │ │ +
│ │ │ │ +
671 matrices_.addCoarser(args);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
676 infoLevel->freeGlobalLookup();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
680 aggregatesMaps_.push_back(aggregatesMap);
│ │ │ │ +
│ │ │ │ +
682 if (criterion.debugLevel()>0) {
│ │ │ │ +
683 if (level==criterion.maxLevel()) {
│ │ │ │ +
684 BIGINT unknownsLevel = mlevel->getmat().N();
│ │ │ │ +
685 unknownsLevel = infoLevel->communicator().sum(unknownsLevel);
│ │ │ │ +
686 if (rank==0 && criterion.debugLevel()>1) {
│ │ │ │ +
687 double dunknownsLevel = unknownsLevel.todouble();
│ │ │ │ +
688 std::cout<<
"Level " <<level<<
" has " <<dunknownsLevel<<
" unknowns, " <<dunknownsLevel/infoLevel->communicator().size()
│ │ │ │ +
689 <<
" unknowns per proc (procs=" <<infoLevel->communicator().size()<<
")" <<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
694 if (criterion.accumulate() && !redistributes_.back().isSetup() &&
│ │ │ │ +
695 infoLevel->communicator().size()>1) {
│ │ │ │ +
696 #if HAVE_MPI && !HAVE_PARMETIS
│ │ │ │ +
│ │ │ │ +
698 infoLevel->communicator().rank()==0)
│ │ │ │ +
699 std::cerr<<
"Successive accumulation of data on coarse levels only works with ParMETIS installed."
│ │ │ │ +
700 <<
" Fell back to accumulation to one domain on coarsest level" <<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
704 std::shared_ptr<Matrix> redistMat = std::make_shared<Matrix>();
│ │ │ │ +
705 std::shared_ptr<ParallelInformation> redistComm;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
709 redistComm, redistributes_.back(), nodomains,criterion);
│ │ │ │ +
710 MatrixArgs args(redistMat, *redistComm);
│ │ │ │ +
711 BIGINT unknownsRedist = redistMat->N();
│ │ │ │ +
712 unknownsRedist = infoLevel->communicator().sum(unknownsRedist);
│ │ │ │ +
│ │ │ │ +
714 if (redistComm->communicator().rank()==0 && criterion.debugLevel()>1) {
│ │ │ │ +
715 double dunknownsRedist = unknownsRedist.todouble();
│ │ │ │ +
716 std::cout<<
"Level " <<level<<
" redistributed has " <<dunknownsRedist<<
" unknowns, " <<dunknownsRedist/redistComm->communicator().size()
│ │ │ │ +
717 <<
" unknowns per proc (procs=" <<redistComm->communicator().size()<<
")" <<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
720 infoLevel.addRedistributed(redistComm);
│ │ │ │ +
721 infoLevel->freeGlobalLookup();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
724 int levels = matrices_.levels();
│ │ │ │ +
725 maxlevels_ = parallelInformation_.finest()->communicator().max(levels);
│ │ │ │ +
726 assert(matrices_.levels()==redistributes_.size());
│ │ │ │ +
727 if (hasCoarsest() && rank==0 && criterion.debugLevel()>1)
│ │ │ │ +
728 std::cout<<
"operator complexity: " <<allnonzeros.todouble()/finenonzeros.todouble()<<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
732 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
739 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
743 return parallelInformation_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
746 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
749 int levels=aggregatesMaps().size();
│ │ │ │ +
750 int maxlevels=parallelInformation_.
finest ()->communicator().max(levels);
│ │ │ │ +
751 std::size_t size=(*(aggregatesMaps().begin()))->noVertices();
│ │ │ │ +
│ │ │ │ +
753 std::vector<std::size_t> tmp;
│ │ │ │ +
754 std::vector<std::size_t> *coarse, *fine;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
771 if (levels==maxlevels) {
│ │ │ │ +
772 const AggregatesMap & map = *(*(++aggregatesMaps().rbegin()));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
781 srand((
unsigned )std::clock());
│ │ │ │ +
782 std::set<size_t> used;
│ │ │ │ +
783 for (
typename std::vector<std::size_t>::iterator iter=coarse->begin(); iter != coarse->end();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
786 std::pair<std::set<std::size_t>::iterator,
bool > ibpair
│ │ │ │ +
787 = used.insert(
static_cast< std::size_t
> ((((
double )rand())/(RAND_MAX+1.0)))*coarse->size());
│ │ │ │ +
│ │ │ │ +
789 while (!ibpair.second)
│ │ │ │ +
790 ibpair = used.insert(
static_cast< std::size_t
> ((((
double )rand())/(RAND_MAX+1.0))*coarse->size()));
│ │ │ │ +
791 *iter=*(ibpair.first);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
799 for (
typename AggregatesMapList::const_reverse_iterator aggregates=++aggregatesMaps().rbegin();
│ │ │ │ +
800 aggregates != aggregatesMaps().rend(); ++aggregates,--levels) {
│ │ │ │ +
│ │ │ │ +
802 fine->resize((*aggregates)->noVertices());
│ │ │ │ +
803 fine->assign(fine->size(), 0);
│ │ │ │ +
│ │ │ │ +
805 ::prolongateVector(*(*aggregates), *coarse, *fine,
static_cast< std::size_t
> (1), *pinfo);
│ │ │ │ +
│ │ │ │ +
807 std::swap(coarse, fine);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
811 assert(coarse==&data);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
814 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
818 return aggregatesMaps_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
820 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
824 return redistributes_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
827 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
830 typedef typename AggregatesMapList::reverse_iterator AggregatesMapIterator;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
834 AggregatesMapIterator amap = aggregatesMaps_.rbegin();
│ │ │ │ +
835 InfoIterator info = parallelInformation_.coarsest();
│ │ │ │ +
836 for (Iterator level=matrices_.coarsest(), finest=matrices_.finest(); level != finest; --level, --info, ++amap) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
843 template <
class M,
class IS,
class A>
│ │ │ │ +
844 template <
class V,
class BA,
class TA>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
847 assert(hierarchy.levels()==1);
│ │ │ │ +
│ │ │ │ +
849 typedef typename RedistributeInfoList::const_iterator RIter;
│ │ │ │ +
850 RIter redist = redistributes_.begin();
│ │ │ │ +
│ │ │ │ +
852 Iterator matrix = matrices_.finest(), coarsest = matrices_.coarsest();
│ │ │ │ +
│ │ │ │ +
854 if (redist->isSetup())
│ │ │ │ +
855 hierarchy.addRedistributedOnCoarsest(matrix.getRedistributed().getmat().N());
│ │ │ │ +
856 Dune::dvverb<<
"Level " <<level<<
" has " <<matrices_.finest()->getmat().N()<<
" unknowns!" <<std::endl;
│ │ │ │ +
│ │ │ │ +
858 while (matrix != coarsest) {
│ │ │ │ +
859 ++matrix; ++level; ++redist;
│ │ │ │ +
860 Dune::dvverb<<
"Level " <<level<<
" has " <<matrix->getmat().N()<<
" unknowns!" <<std::endl;
│ │ │ │ +
│ │ │ │ +
862 hierarchy.addCoarser(matrix->getmat().N());
│ │ │ │ +
863 if (redist->isSetup())
│ │ │ │ +
864 hierarchy.addRedistributedOnCoarsest(matrix.getRedistributed().getmat().N());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
870 template <
class M,
class IS,
class A>
│ │ │ │ +
871 template <
class S,
class TA>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
875 assert(smoothers.
levels ()==0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
878 typedef typename AggregatesMapList::const_iterator AggregatesIterator;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
881 cargs.setArgs(sargs);
│ │ │ │ +
882 PinfoIterator pinfo = parallelInformation_.finest();
│ │ │ │ +
883 AggregatesIterator aggregates = aggregatesMaps_.begin();
│ │ │ │ +
│ │ │ │ +
885 for (MatrixIterator matrix = matrices_.finest(), coarsest = matrices_.coarsest();
│ │ │ │ +
886 matrix != coarsest; ++matrix, ++pinfo, ++aggregates, ++level) {
│ │ │ │ +
887 cargs.setMatrix(matrix->getmat(), **aggregates);
│ │ │ │ +
888 cargs.setComm(*pinfo);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
891 if (maxlevels()>levels()) {
│ │ │ │ +
│ │ │ │ +
893 cargs.setMatrix(matrices_.coarsest()->getmat(), **aggregates);
│ │ │ │ +
894 cargs.setComm(*pinfo);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
900 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
904 typedef typename AggregatesMapList::iterator AggregatesMapIterator;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
908 AggregatesMapIterator amap = aggregatesMaps_.begin();
│ │ │ │ +
│ │ │ │ +
910 InfoIterator info = parallelInformation_.finest();
│ │ │ │ +
911 typename RedistributeInfoList::iterator riIter = redistributes_.begin();
│ │ │ │ +
912 Iterator level = matrices_.finest(), coarsest=matrices_.coarsest();
│ │ │ │ +
913 if (level.isRedistributed()) {
│ │ │ │ +
914 info->buildGlobalLookup(level->getmat().N());
│ │ │ │ +
│ │ │ │ +
916 const_cast< Matrix &
> (level.getRedistributed().getmat()),
│ │ │ │ +
917 *info,info.getRedistributed(), *riIter);
│ │ │ │ +
918 info->freeGlobalLookup();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
921 for (; level!=coarsest; ++amap) {
│ │ │ │ +
922 const Matrix & fine = (level.isRedistributed() ? level.getRedistributed() : *level).getmat();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
926 productBuilder.
calculate (fine, *(*amap),
const_cast< Matrix &
> (level->getmat()), *info, copyFlags);
│ │ │ │ +
927 if (level.isRedistributed()) {
│ │ │ │ +
928 info->buildGlobalLookup(level->getmat().N());
│ │ │ │ +
│ │ │ │ +
930 const_cast< Matrix &
> (level.getRedistributed().getmat()), *info,
│ │ │ │ +
931 info.getRedistributed(), *riIter);
│ │ │ │ +
932 info->freeGlobalLookup();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
937 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
940 return matrices_.levels();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
943 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
949 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
952 return levels()==maxlevels() &&
│ │ │ │ +
953 (!matrices_.coarsest().isRedistributed() ||matrices_.coarsest()->getmat().N()>0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
956 template <
class M,
class IS,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Provides a classes representing the hierarchies in AMG.
│ │ │ │ +
Classes for the generic construction and application of the smoothers.
│ │ │ │ +
Prolongation and restriction for amg.
│ │ │ │ +
Provdes class for identifying aggregates globally.
│ │ │ │ +
Provides a class for building the galerkin product based on a aggregation scheme.
│ │ │ │ +
Provides classes for initializing the link attributes of a matrix graph.
│ │ │ │ +
Provides a class for building the index set and remote indices on the coarse level.
│ │ │ │ +
Helper classes for the construction of classes without empty constructor.
│ │ │ │ +
Provides classes for the Coloring process of AMG.
│ │ │ │ +
│ │ │ │ +
Provides classes for building the matrix graph.
│ │ │ │ +
Some handy generic functions for ISTL matrices.
│ │ │ │ +
This file implements a vector space as a tensor product of a given vector space. The number of compon...
│ │ │ │ +
Functionality for redistributing a sparse matrix.
│ │ │ │ +
auto countNonZeros(const M &, typename std::enable_if_t< Dune::IsNumber< M >::value > *sfinae=nullptr)
Get the number of nonzero fields in the matrix.
Definition matrixutils.hh:119
│ │ │ │ +
const AggregatesMapList & aggregatesMaps() const
Get the hierarchy of the mappings of the nodes onto aggregates.
Definition matrixhierarchy.hh:816
│ │ │ │ +
bool isBuilt() const
Whether the hierarchy was built.
Definition matrixhierarchy.hh:957
│ │ │ │ +
bool hasCoarsest() const
Definition matrixhierarchy.hh:950
│ │ │ │ +
std::size_t levels() const
Get the number of levels in the hierarchy.
Definition hierarchy.hh:322
│ │ │ │ +
std::size_t levels() const
Get the number of levels in the hierarchy.
Definition matrixhierarchy.hh:938
│ │ │ │ +
void addCoarser(Arguments &args)
Add an element on a coarser level.
Definition hierarchy.hh:334
│ │ │ │ +
const RedistributeInfoList & redistributeInformation() const
Get the hierarchy of the information about redistributions,.
Definition matrixhierarchy.hh:822
│ │ │ │ +
const ParallelInformationHierarchy & parallelInformation() const
Get the hierarchy of the parallel data distribution information.
Definition matrixhierarchy.hh:741
│ │ │ │ +
bool repartitionAndDistributeMatrix(const M &origMatrix, std::shared_ptr< M > newMatrix, SequentialInformation &origComm, std::shared_ptr< SequentialInformation > &newComm, RedistributeInformation< SequentialInformation > &ri, int nparts, C1 &criterion)
Definition matrixhierarchy.hh:316
│ │ │ │ +
const_iterator begin() const
Definition aggregates.hh:725
│ │ │ │ +
const ParallelMatrixHierarchy & matrices() const
Get the matrix hierarchy.
Definition matrixhierarchy.hh:734
│ │ │ │ +
std::size_t maxlevels() const
Get the max number of levels in the hierarchy of processors.
Definition matrixhierarchy.hh:944
│ │ │ │ +
const_iterator end() const
Definition aggregates.hh:730
│ │ │ │ +
static const V ISOLATED
Identifier of isolated vertices.
Definition aggregates.hh:571
│ │ │ │ +
void recalculateGalerkin(const F ©Flags)
Recalculate the galerkin products.
Definition matrixhierarchy.hh:902
│ │ │ │ +
const void * Arguments
A type holding all the arguments needed to call the constructor.
Definition construction.hh:44
│ │ │ │ +
std::size_t noVertices() const
Get the number of vertices.
│ │ │ │ +
static std::shared_ptr< T > construct(Arguments &args)
Construct an object with the specified arguments.
Definition construction.hh:52
│ │ │ │ +
void coarsenVector(Hierarchy< BlockVector< V, BA >, TA > &hierarchy) const
Coarsen the vector hierarchy according to the matrix hierarchy.
Definition matrixhierarchy.hh:845
│ │ │ │ +
const AggregateDescriptor * const_iterator
Definition aggregates.hh:723
│ │ │ │ +
MatrixHierarchy(std::shared_ptr< MatrixOperator > fineMatrix, std::shared_ptr< ParallelInformation > pinfo=std::make_shared< ParallelInformation >())
Constructor.
Definition matrixhierarchy.hh:392
│ │ │ │ +
AccumulationMode
Identifiers for the different accumulation modes.
Definition parameters.hh:231
│ │ │ │ +
Iterator finest()
Get an iterator positioned at the finest level.
Definition hierarchy.hh:377
│ │ │ │ +
void build(const T &criterion)
Build the matrix hierarchy using aggregation.
Definition matrixhierarchy.hh:403
│ │ │ │ +
void free()
Free the allocated memory.
│ │ │ │ +
void coarsenSmoother(Hierarchy< S, TA > &smoothers, const typename SmootherTraits< S >::Arguments &args) const
Coarsen the smoother hierarchy according to the matrix hierarchy.
Definition matrixhierarchy.hh:872
│ │ │ │ +
void buildDependency(G &graph, const typename C::Matrix &matrix, C criterion, bool finestLevel)
Build the dependency of the matrix graph.
│ │ │ │ +
std::tuple< int, int, int, int > buildAggregates(const M &matrix, G &graph, const C &criterion, bool finestLevel)
Build the aggregates.
│ │ │ │ +
void calculate(const M &fine, const AggregatesMap< V > &aggregates, M &coarse, const I &pinfo, const O ©)
Calculate the galerkin product.
│ │ │ │ +
void getCoarsestAggregatesOnFinest(std::vector< std::size_t > &data) const
Get the mapping of fine level unknowns to coarse level aggregates.
Definition matrixhierarchy.hh:747
│ │ │ │ +
~MatrixHierarchy()
Definition matrixhierarchy.hh:828
│ │ │ │ +
@ MAX_PROCESSES
Hard limit for the number of processes allowed.
Definition matrixhierarchy.hh:50
│ │ │ │ +
@ atOnceAccu
Accumulate data to one process at once.
Definition parameters.hh:243
│ │ │ │ +
@ successiveAccu
Successively accumulate to fewer processes.
Definition parameters.hh:247
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
A sparse block matrix with compressed row storage.
Definition bcrsmatrix.hh:466
│ │ │ │ -
void endrowsizes()
indicate that size of all rows is defined
Definition bcrsmatrix.hh:1146
│ │ │ │ -
@ random
Build entries randomly.
Definition bcrsmatrix.hh:526
│ │ │ │ -
void endindices()
indicate that all indices are defined, check consistency
Definition bcrsmatrix.hh:1269
│ │ │ │ -
size_type N() const
number of rows (counted in blocks)
Definition bcrsmatrix.hh:2001
│ │ │ │ -
void setSize(size_type rows, size_type columns, size_type nnz=0)
Set the size of the matrix.
Definition bcrsmatrix.hh:858
│ │ │ │ -
BCRSMatrix & operator=(const BCRSMatrix &Mat)
assignment
Definition bcrsmatrix.hh:908
│ │ │ │ -
A block-diagonal matrix.
Definition bdmatrix.hh:33
│ │ │ │ -
typename Imp::BlockTraits< B >::field_type field_type
export the type representing the field
Definition bdmatrix.hh:39
│ │ │ │ -
A::size_type size_type
implement row_type with compressed vector
Definition bdmatrix.hh:51
│ │ │ │ -
BDMatrix()
Default constructor.
Definition bdmatrix.hh:54
│ │ │ │ -
BDMatrix(std::initializer_list< B > const &list)
Construct from a std::initializer_list.
Definition bdmatrix.hh:72
│ │ │ │ -
B block_type
export the type representing the components
Definition bdmatrix.hh:42
│ │ │ │ -
void solve(V &x, const V &rhs) const
Solve the system Ax=b in O(n) time.
Definition bdmatrix.hh:116
│ │ │ │ -
A allocator_type
export the allocator type
Definition bdmatrix.hh:45
│ │ │ │ -
BDMatrix(int size)
Definition bdmatrix.hh:56
│ │ │ │ -
BDMatrix & operator=(const BDMatrix &other)
assignment
Definition bdmatrix.hh:99
│ │ │ │ -
void setSize(size_type size)
Resize the matrix. Invalidates the content!
Definition bdmatrix.hh:81
│ │ │ │ -
void invert()
Inverts the matrix.
Definition bdmatrix.hh:126
│ │ │ │ -
typename BDMatrix< B, A >::field_type field_type
Definition bdmatrix.hh:150
│ │ │ │ -
typename FieldTraits< field_type >::real_type real_type
Definition bdmatrix.hh:151
│ │ │ │ +
void printGlobalSparseMatrix(const M &mat, C &ooc, std::ostream &os)
Definition matrixutils.hh:154
│ │ │ │ +
PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > >::Type get(const Amg::VertexVisitedTag &tag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > &graph)
Definition dependency.hh:293
│ │ │ │ +
void redistributeMatrixEntries(M &origMatrix, M &newMatrix, C &origComm, C &newComm, RedistributeInformation< C > &ri)
Definition matrixredistribute.hh:757
│ │ │ │ +
bool commGraphRepartition(const M &mat, Dune::OwnerOverlapCopyCommunication< T1, T2 > &oocomm, Metis::idx_t nparts, std::shared_ptr< Dune::OwnerOverlapCopyCommunication< T1, T2 > > &outcomm, RedistributeInterface &redistInf, bool verbose=false)
Definition repartition.hh:822
│ │ │ │ +
void redistributeMatrix(M &origMatrix, M &newMatrix, C &origComm, C &newComm, RedistributeInformation< C > &ri)
Redistribute a matrix according to given domain decompositions.
Definition matrixredistribute.hh:820
│ │ │ │ +
bool graphRepartition(const G &graph, Dune::OwnerOverlapCopyCommunication< T1, T2 > &oocomm, Metis::idx_t nparts, std::shared_ptr< Dune::OwnerOverlapCopyCommunication< T1, T2 > > &outcomm, RedistributeInterface &redistInf, bool verbose=false)
execute a graph repartition for a giving graph and indexset.
Definition repartition.hh:1228
│ │ │ │ +
A vector of blocks with memory management.
Definition bvector.hh:392
│ │ │ │ +
derive error class from the base class in common
Definition istlexception.hh:19
│ │ │ │ +
A generic dynamic dense matrix.
Definition matrix.hh:561
│ │ │ │ +
A::size_type size_type
Type for indices and sizes.
Definition matrix.hh:577
│ │ │ │ +
MatrixImp::DenseMatrixBase< T, A >::window_type row_type
The type implementing a matrix row.
Definition matrix.hh:574
│ │ │ │ +
Definition matrixredistribute.hh:22
│ │ │ │ +
Class providing information about the mapping of the vertices onto aggregates.
Definition aggregates.hh:560
│ │ │ │ +
Class representing the properties of an edge in the matrix graph.
Definition dependency.hh:39
│ │ │ │ +
Class representing a node in the matrix graph.
Definition dependency.hh:126
│ │ │ │ +
Definition galerkin.hh:99
│ │ │ │ +
Definition galerkin.hh:118
│ │ │ │ +
Definition globalaggregates.hh:131
│ │ │ │ +
The (undirected) graph of a matrix.
Definition graph.hh:51
│ │ │ │ +
Attaches properties to the edges and vertices of a graph.
Definition graph.hh:978
│ │ │ │ +
Graph::VertexDescriptor VertexDescriptor
The vertex descriptor.
Definition graph.hh:988
│ │ │ │ +
Definition graphcreator.hh:22
│ │ │ │ +
A hierarchy of containers (e.g. matrices or vectors)
Definition hierarchy.hh:40
│ │ │ │ +
LevelIterator< Hierarchy< MatrixOperator, Allocator >, MatrixOperator > Iterator
Type of the mutable iterator.
Definition hierarchy.hh:216
│ │ │ │ +
LevelIterator< const Hierarchy< MatrixOperator, Allocator >, const MatrixOperator > ConstIterator
Type of the const iterator.
Definition hierarchy.hh:219
│ │ │ │ +
Definition indicescoarsener.hh:36
│ │ │ │ +
The hierarchies build by the coarsening process.
Definition matrixhierarchy.hh:61
│ │ │ │ +
typename std::allocator_traits< Allocator >::template rebind_alloc< AggregatesMap * > AAllocator
Allocator for pointers.
Definition matrixhierarchy.hh:85
│ │ │ │ +
Dune::Amg::Hierarchy< ParallelInformation, Allocator > ParallelInformationHierarchy
The type of the parallel informarion hierarchy.
Definition matrixhierarchy.hh:82
│ │ │ │ +
std::list< AggregatesMap *, AAllocator > AggregatesMapList
The type of the aggregates maps list.
Definition matrixhierarchy.hh:88
│ │ │ │ +
PI ParallelInformation
The type of the index set.
Definition matrixhierarchy.hh:70
│ │ │ │ +
Dune::Amg::Hierarchy< MatrixOperator, Allocator > ParallelMatrixHierarchy
The type of the parallel matrix hierarchy.
Definition matrixhierarchy.hh:79
│ │ │ │ +
A Allocator
The allocator to use.
Definition matrixhierarchy.hh:73
│ │ │ │ +
RedistributeInformation< ParallelInformation > RedistributeInfoType
The type of the redistribute information.
Definition matrixhierarchy.hh:91
│ │ │ │ +
double getProlongationDampingFactor() const
Definition matrixhierarchy.hh:188
│ │ │ │ +
typename std::allocator_traits< Allocator >::template rebind_alloc< RedistributeInfoType > RILAllocator
Allocator for RedistributeInfoType.
Definition matrixhierarchy.hh:94
│ │ │ │ +
std::list< RedistributeInfoType, RILAllocator > RedistributeInfoList
The type of the list of redistribute information.
Definition matrixhierarchy.hh:97
│ │ │ │ +
Dune::Amg::AggregatesMap< typename MatrixGraph< Matrix >::VertexDescriptor > AggregatesMap
The type of the aggregates map we use.
Definition matrixhierarchy.hh:76
│ │ │ │ +
MatrixOperator::matrix_type Matrix
The type of the matrix.
Definition matrixhierarchy.hh:67
│ │ │ │ +
M MatrixOperator
The type of the matrix operator.
Definition matrixhierarchy.hh:64
│ │ │ │ +
void operator()(const matrix_row &row)
Definition matrixhierarchy.hh:254
│ │ │ │ +
Matrix::row_type matrix_row
Definition matrixhierarchy.hh:245
│ │ │ │ +
size_type min
Definition matrixhierarchy.hh:261
│ │ │ │ +
calc()
Definition matrixhierarchy.hh:247
│ │ │ │ +
size_type max
Definition matrixhierarchy.hh:262
│ │ │ │ +
size_type sum
Definition matrixhierarchy.hh:263
│ │ │ │ +
Matrix::size_type size_type
Definition matrixhierarchy.hh:244
│ │ │ │ +
The criterion describing the stop criteria for the coarsening process.
Definition matrixhierarchy.hh:283
│ │ │ │ +
CoarsenCriterion(const Dune::Amg::Parameters &parms)
Definition matrixhierarchy.hh:309
│ │ │ │ +
T AggregationCriterion
The criterion for tagging connections as strong and nodes as isolated. This might be e....
Definition matrixhierarchy.hh:289
│ │ │ │ +
CoarsenCriterion(int maxLevel=100, int coarsenTarget=1000, double minCoarsenRate=1.2, double prolongDamp=1.6, AccumulationMode accumulate=successiveAccu, bool useFixedOrder=false)
Constructor.
Definition matrixhierarchy.hh:304
│ │ │ │ +
All parameters for AMG.
Definition parameters.hh:416
│ │ │ │ +
│ │ │ │ +
Tag idnetifying the visited property of a vertex.
Definition properties.hh:29
│ │ │ │ +
The default class for the smoother arguments.
Definition smoother.hh:38
│ │ │ │ +
Definition transfer.hh:32
│ │ │ │ +
static Category category(const OP &op, decltype(op.category()) *=nullptr)
Helperfunction to extract the solver category either from an enum, or from the newly introduced virtu...
Definition solvercategory.hh:34
│ │ │ │
│ │ │ │ │ -9
│ │ │ │ │ -10#include
│ │ │ │ │ -11#include
│ │ │ │ │ -12
│ │ │ │ │ -13#include <_d_u_n_e_/_i_s_t_l_/_b_c_r_s_m_a_t_r_i_x_._h_h>
│ │ │ │ │ -14#include <_d_u_n_e_/_i_s_t_l_/_b_l_o_c_k_l_e_v_e_l_._h_h>
│ │ │ │ │ -15
│ │ │ │ │ -21namespace _D_u_n_e {
│ │ │ │ │ -31 template >
│ │ │ │ │ -_3_2 class _B_D_M_a_t_r_i_x : public _B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -33 {
│ │ │ │ │ -34 public:
│ │ │ │ │ -35
│ │ │ │ │ -36 //===== type definitions and constants
│ │ │ │ │ -37
│ │ │ │ │ -_3_9 using _f_i_e_l_d___t_y_p_e = typename Imp::BlockTraits::field_type;
│ │ │ │ │ -40
│ │ │ │ │ -_4_2 typedef B _b_l_o_c_k___t_y_p_e;
│ │ │ │ │ -43
│ │ │ │ │ -_4_5 typedef A _a_l_l_o_c_a_t_o_r___t_y_p_e;
│ │ │ │ │ -46
│ │ │ │ │ -48 //typedef BCRSMatrix::row_type row_type;
│ │ │ │ │ -49
│ │ │ │ │ -_5_1 typedef typename A::size_type _s_i_z_e___t_y_p_e;
│ │ │ │ │ +8#include
│ │ │ │ │ +9#include
│ │ │ │ │ +10#include "_a_g_g_r_e_g_a_t_e_s_._h_h"
│ │ │ │ │ +11#include "_g_r_a_p_h_._h_h"
│ │ │ │ │ +12#include "_g_a_l_e_r_k_i_n_._h_h"
│ │ │ │ │ +13#include "_r_e_n_u_m_b_e_r_e_r_._h_h"
│ │ │ │ │ +14#include "_g_r_a_p_h_c_r_e_a_t_o_r_._h_h"
│ │ │ │ │ +15#include "_h_i_e_r_a_r_c_h_y_._h_h"
│ │ │ │ │ +16#include <_d_u_n_e_/_i_s_t_l_/_b_v_e_c_t_o_r_._h_h>
│ │ │ │ │ +17#include
│ │ │ │ │ +18#include <_d_u_n_e_/_i_s_t_l_/_m_a_t_r_i_x_u_t_i_l_s_._h_h>
│ │ │ │ │ +19#include <_d_u_n_e_/_i_s_t_l_/_m_a_t_r_i_x_r_e_d_i_s_t_r_i_b_u_t_e_._h_h>
│ │ │ │ │ +20#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_d_e_p_e_n_d_e_n_c_y_._h_h>
│ │ │ │ │ +21#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_g_r_a_p_h_._h_h>
│ │ │ │ │ +22#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_i_n_d_i_c_e_s_c_o_a_r_s_e_n_e_r_._h_h>
│ │ │ │ │ +23#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_g_l_o_b_a_l_a_g_g_r_e_g_a_t_e_s_._h_h>
│ │ │ │ │ +24#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_c_o_n_s_t_r_u_c_t_i_o_n_._h_h>
│ │ │ │ │ +25#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_s_m_o_o_t_h_e_r_._h_h>
│ │ │ │ │ +26#include <_d_u_n_e_/_i_s_t_l_/_p_a_a_m_g_/_t_r_a_n_s_f_e_r_._h_h>
│ │ │ │ │ +27
│ │ │ │ │ +28namespace _D_u_n_e
│ │ │ │ │ +29{
│ │ │ │ │ +30 namespace Amg
│ │ │ │ │ +31 {
│ │ │ │ │ +42 enum {
│ │ │ │ │ +50 _M_A_X___P_R_O_C_E_S_S_E_S = 72000
│ │ │ │ │ +_5_1 };
│ │ │ │ │ 52
│ │ │ │ │ -_5_4 _B_D_M_a_t_r_i_x() : _B_C_R_S_M_a_t_r_i_x() {}
│ │ │ │ │ -55
│ │ │ │ │ -_5_6 explicit _B_D_M_a_t_r_i_x(int size)
│ │ │ │ │ -57 : _B_C_R_S_M_a_t_r_i_x(size, size, _B_C_R_S_M_a_t_r_i_x::_r_a_n_d_o_m) {
│ │ │ │ │ -58
│ │ │ │ │ -59 for (int i=0; i_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_s_e_t_r_o_w_s_i_z_e(i, 1);
│ │ │ │ │ -61
│ │ │ │ │ -62 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_r_o_w_s_i_z_e_s();
│ │ │ │ │ -63
│ │ │ │ │ -64 for (int i=0; i_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i);
│ │ │ │ │ -66
│ │ │ │ │ -67 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_i_n_d_i_c_e_s();
│ │ │ │ │ +59 template >
│ │ │ │ │ +_6_0 class _M_a_t_r_i_x_H_i_e_r_a_r_c_h_y
│ │ │ │ │ +61 {
│ │ │ │ │ +62 public:
│ │ │ │ │ +_6_4 typedef M _M_a_t_r_i_x_O_p_e_r_a_t_o_r;
│ │ │ │ │ +65
│ │ │ │ │ +_6_7 typedef typename MatrixOperator::matrix_type _M_a_t_r_i_x;
│ │ │ │ │ 68
│ │ │ │ │ -69 }
│ │ │ │ │ -70
│ │ │ │ │ -_7_2 _B_D_M_a_t_r_i_x (std::initializer_list const &list)
│ │ │ │ │ -73 : _B_D_M_a_t_r_i_x(list.size())
│ │ │ │ │ -74 {
│ │ │ │ │ -75 size_t i=0;
│ │ │ │ │ -76 for (auto it = list.begin(); it != list.end(); ++it, ++i)
│ │ │ │ │ -77 (*this)[i][i] = *it;
│ │ │ │ │ -78 }
│ │ │ │ │ -79
│ │ │ │ │ -_8_1 void _s_e_t_S_i_z_e(_s_i_z_e___t_y_p_e size)
│ │ │ │ │ -82 {
│ │ │ │ │ -83 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_s_e_t_S_i_z_e(size, // rows
│ │ │ │ │ -84 size, // columns
│ │ │ │ │ -85 size); // nonzeros
│ │ │ │ │ +_7_0 typedef PI _P_a_r_a_l_l_e_l_I_n_f_o_r_m_a_t_i_o_n;
│ │ │ │ │ +71
│ │ │ │ │ +_7_3 typedef A _A_l_l_o_c_a_t_o_r;
│ │ │ │ │ +74
│ │ │ │ │ +_7_6 typedef _D_u_n_e_:_:_A_m_g_:_:_A_g_g_r_e_g_a_t_e_s_M_a_p_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_G_r_a_p_h_<_M_a_t_r_i_x_>_:_:
│ │ │ │ │ +_V_e_r_t_e_x_D_e_s_c_r_i_p_t_o_r> _A_g_g_r_e_g_a_t_e_s_M_a_p;
│ │ │ │ │ +77
│ │ │ │ │ +_7_9 typedef _D_u_n_e_:_:_A_m_g_:_:_H_i_e_r_a_r_c_h_y_<_M_a_t_r_i_x_O_p_e_r_a_t_o_r_,_A_l_l_o_c_a_t_o_r_>
│ │ │ │ │ +_P_a_r_a_l_l_e_l_M_a_t_r_i_x_H_i_e_r_a_r_c_h_y;
│ │ │ │ │ +80
│ │ │ │ │ +_8_2 typedef _D_u_n_e_:_:_A_m_g_:_:_H_i_e_r_a_r_c_h_y_<_P_a_r_a_l_l_e_l_I_n_f_o_r_m_a_t_i_o_n_,_A_l_l_o_c_a_t_o_r_>
│ │ │ │ │ +_P_a_r_a_l_l_e_l_I_n_f_o_r_m_a_t_i_o_n_H_i_e_r_a_r_c_h_y;
│ │ │ │ │ +83
│ │ │ │ │ +_8_5 using _A_A_l_l_o_c_a_t_o_r = typename std::allocator_traits::template
│ │ │ │ │ +rebind_alloc;
│ │ │ │ │ 86
│ │ │ │ │ -87 for (auto i : range(size))
│ │ │ │ │ -88 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_s_e_t_r_o_w_s_i_z_e(i, 1);
│ │ │ │ │ +_8_8 typedef std::list _A_g_g_r_e_g_a_t_e_s_M_a_p_L_i_s_t;
│ │ │ │ │ 89
│ │ │ │ │ -90 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_r_o_w_s_i_z_e_s();
│ │ │ │ │ -91
│ │ │ │ │ -92 for (auto i : range(size))
│ │ │ │ │ -93 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_a_d_d_i_n_d_e_x(i, i);
│ │ │ │ │ -94
│ │ │ │ │ -95 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_e_n_d_i_n_d_i_c_e_s();
│ │ │ │ │ -96 }
│ │ │ │ │ -97
│ │ │ │ │ -_9_9 _B_D_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_=_ (const _B_D_M_a_t_r_i_x& other) {
│ │ │ │ │ -100 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_o_p_e_r_a_t_o_r_=(other);
│ │ │ │ │ -101 return *this;
│ │ │ │ │ -102 }
│ │ │ │ │ -103
│ │ │ │ │ -_1_0_5 _B_D_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_=_ (const _f_i_e_l_d___t_y_p_e& k) {
│ │ │ │ │ -106 this->_B_C_R_S_M_a_t_r_i_x_<_B_,_A_>_:_:_o_p_e_r_a_t_o_r_=(k);
│ │ │ │ │ -107 return *this;
│ │ │ │ │ -108 }
│ │ │ │ │ -109
│ │ │ │ │ -115 template
│ │ │ │ │ -_1_1_6 void _s_o_l_v_e (V& x, const V& rhs) const {
│ │ │ │ │ -117 for (_s_i_z_e___t_y_p_e i=0; i_N(); i++)
│ │ │ │ │ -118 {
│ │ │ │ │ -119 auto&& xv = Impl::asVector(x[i]);
│ │ │ │ │ -120 auto&& rhsv = Impl::asVector(rhs[i]);
│ │ │ │ │ -121 Impl::asMatrix((*this)[i][i]).solve(xv,rhsv);
│ │ │ │ │ -122 }
│ │ │ │ │ -123 }
│ │ │ │ │ -124
│ │ │ │ │ -_1_2_6 void _i_n_v_e_r_t() {
│ │ │ │ │ -127 for (_s_i_z_e___t_y_p_e i=0; i_N(); i++)
│ │ │ │ │ -128 Impl::asMatrix((*this)[i][i])._i_n_v_e_r_t();
│ │ │ │ │ -129 }
│ │ │ │ │ -130
│ │ │ │ │ -131 private:
│ │ │ │ │ -132
│ │ │ │ │ -133 // ////////////////////////////////////////////////////////////////////////
│ │ │ │ │ -////
│ │ │ │ │ -134 // The following methods from the base class should now actually be called
│ │ │ │ │ -135 // ////////////////////////////////////////////////////////////////////////
│ │ │ │ │ -////
│ │ │ │ │ -136
│ │ │ │ │ -137 // createbegin and createend should be in there, too, but I can't get it to
│ │ │ │ │ -compile
│ │ │ │ │ -138 // BCRSMatrix::CreateIterator createbegin () {}
│ │ │ │ │ -139 // BCRSMatrix::CreateIterator createend () {}
│ │ │ │ │ -140 void setrowsize (_s_i_z_e___t_y_p_e i, _s_i_z_e___t_y_p_e s) {}
│ │ │ │ │ -141 void incrementrowsize (_s_i_z_e___t_y_p_e i) {}
│ │ │ │ │ -142 void endrowsizes () {}
│ │ │ │ │ -143 void addindex (_s_i_z_e___t_y_p_e row, _s_i_z_e___t_y_p_e _c_o_l) {}
│ │ │ │ │ -144 void endindices () {}
│ │ │ │ │ -145 };
│ │ │ │ │ -146
│ │ │ │ │ -147 template
│ │ │ │ │ -_1_4_8 struct FieldTraits< _B_D_M_a_t_r_i_x >
│ │ │ │ │ -149 {
│ │ │ │ │ -_1_5_0 using _f_i_e_l_d___t_y_p_e = typename _B_D_M_a_t_r_i_x_<_B_,_ _A_>_:_:_f_i_e_l_d___t_y_p_e;
│ │ │ │ │ -_1_5_1 using _r_e_a_l___t_y_p_e = typename FieldTraits::real_type;
│ │ │ │ │ -152 };
│ │ │ │ │ -155} // end namespace Dune
│ │ │ │ │ +_9_1 typedef _R_e_d_i_s_t_r_i_b_u_t_e_I_n_f_o_r_m_a_t_i_o_n_<_P_a_r_a_l_l_e_l_I_n_f_o_r_m_a_t_i_o_n_> _R_e_d_i_s_t_r_i_b_u_t_e_I_n_f_o_T_y_p_e;
│ │ │ │ │ +92
│ │ │ │ │ +_9_4 using _R_I_L_A_l_l_o_c_a_t_o_r = typename std::allocator_traits::template
│ │ │ │ │ +rebind_alloc;
│ │ │ │ │ +95
│ │ │ │ │ +_9_7 typedef std::list _R_e_d_i_s_t_r_i_b_u_t_e_I_n_f_o_L_i_s_t;
│ │ │ │ │ +98
│ │ │ │ │ +104 _M_a_t_r_i_x_H_i_e_r_a_r_c_h_y(std::shared_ptr fineMatrix,
│ │ │ │ │ +105 std::shared_ptr pinfo = std::
│ │ │ │ │ +make_shared());
│ │ │ │ │ +106
│ │ │ │ │ +107 _~_M_a_t_r_i_x_H_i_e_r_a_r_c_h_y();
│ │ │ │ │ +108
│ │ │ │ │ +114 template
│ │ │ │ │ +115 void _b_u_i_l_d(const T& criterion);
│ │ │ │ │ +116
│ │ │ │ │ +124 template
│ │ │ │ │ +125 void _r_e_c_a_l_c_u_l_a_t_e_G_a_l_e_r_k_i_n(const F& copyFlags);
│ │ │ │ │ +126
│ │ │ │ │ +131 template
│ │ │ │ │ +132 void _c_o_a_r_s_e_n_V_e_c_t_o_r(_H_i_e_r_a_r_c_h_y<_B_l_o_c_k_V_e_c_t_o_r_<_V_,_B_A_>, TA>& hierarchy) const;
│ │ │ │ │ +133
│ │ │ │ │ +139 template
│ │ │ │ │ +140 void _c_o_a_r_s_e_n_S_m_o_o_t_h_e_r(_H_i_e_r_a_r_c_h_y_<_S_,_T_A_>& smoothers,
│ │ │ │ │ +141 const typename _S_m_o_o_t_h_e_r_T_r_a_i_t_s_<_S_>_:_:_A_r_g_u_m_e_n_t_s& args) const;
│ │ │ │ │ +142
│ │ │ │ │ +147 std::size_t _l_e_v_e_l_s() const;
│ │ │ │ │ +148
│ │ │ │ │ +153 std::size_t _m_a_x_l_e_v_e_l_s() const;
│ │ │ │ │ +154
│ │ │ │ │ +155 bool _h_a_s_C_o_a_r_s_e_s_t() const;
│ │ │ │ │ 156
│ │ │ │ │ -157#endif
│ │ │ │ │ -_b_c_r_s_m_a_t_r_i_x_._h_h
│ │ │ │ │ -Implementation of the BCRSMatrix class.
│ │ │ │ │ -_b_l_o_c_k_l_e_v_e_l_._h_h
│ │ │ │ │ -Helper functions for determining the vector/matrix block level.
│ │ │ │ │ -_c_o_l
│ │ │ │ │ -Col col
│ │ │ │ │ -DDeeffiinniittiioonn matrixmatrix.hh:351
│ │ │ │ │ +161 bool _i_s_B_u_i_l_t() const;
│ │ │ │ │ +162
│ │ │ │ │ +167 const _P_a_r_a_l_l_e_l_M_a_t_r_i_x_H_i_e_r_a_r_c_h_y& _m_a_t_r_i_c_e_s() const;
│ │ │ │ │ +168
│ │ │ │ │ +173 const _P_a_r_a_l_l_e_l_I_n_f_o_r_m_a_t_i_o_n_H_i_e_r_a_r_c_h_y& _p_a_r_a_l_l_e_l_I_n_f_o_r_m_a_t_i_o_n() const;
│ │ │ │ │ +174
│ │ │ │ │ +179 const _A_g_g_r_e_g_a_t_e_s_M_a_p_L_i_s_t& _a_g_g_r_e_g_a_t_e_s_M_a_p_s() const;
│ │ │ │ │ +180
│ │ │ │ │ +186 const _R_e_d_i_s_t_r_i_b_u_t_e_I_n_f_o_L_i_s_t& _r_e_d_i_s_t_r_i_b_u_t_e_I_n_f_o_r_m_a_t_i_o_n() const;
│ │ │ │ │ +187
│ │ │ │ │ +_1_8_8 double _g_e_t_P_r_o_l_o_n_g_a_t_i_o_n_D_a_m_p_i_n_g_F_a_c_t_o_r() const
│ │ │ │ │ +189 {
│ │ │ │ │ +190 return prolongDamp_;
│ │ │ │ │ +191 }
│ │ │ │ │ +192
│ │ │ │ │ +203 void _g_e_t_C_o_a_r_s_e_s_t_A_g_g_r_e_g_a_t_e_s_O_n_F_i_n_e_s_t(std::vector& data) const;
│ │ │ │ │ +204
│ │ │ │ │ +205 private:
│ │ │ │ │ +206 typedef typename _C_o_n_s_t_r_u_c_t_i_o_n_T_r_a_i_t_s_<_M_a_t_r_i_x_O_p_e_r_a_t_o_r_>_:_:_A_r_g_u_m_e_n_t_s MatrixArgs;
│ │ │ │ │ +207 typedef typename _C_o_n_s_t_r_u_c_t_i_o_n_T_r_a_i_t_s_<_P_a_r_a_l_l_e_l_I_n_f_o_r_m_a_t_i_o_n_>_:_:_A_r_g_u_m_e_n_t_s
│ │ │ │ │ +CommunicationArgs;
│ │ │ │ │ +209 _A_g_g_r_e_g_a_t_e_s_M_a_p_L_i_s_t aggregatesMaps_;
│ │ │ │ │ +211 _R_e_d_i_s_t_r_i_b_u_t_e_I_n_f_o_L_i_s_t redistributes_;
│ │ │ │ │ +213 _P_a_r_a_l_l_e_l_M_a_t_r_i_x_H_i_e_r_a_r_c_h_y matrices_;
│ │ │ │ │ +215 _P_a_r_a_l_l_e_l_I_n_f_o_r_m_a_t_i_o_n_H_i_e_r_a_r_c_h_y parallelInformation_;
│ │ │ │ │ +216
│ │ │ │ │ +218 bool built_;
│ │ │ │ │ +219
│ │ │ │ │ +221 int maxlevels_;
│ │ │ │ │ +222
│ │ │ │ │ +223 double prolongDamp_;
│ │ │ │ │ +224
│ │ │ │ │ +228 template
│ │ │ │ │ +229 struct MatrixStats
│ │ │ │ │ +230 {
│ │ │ │ │ +231
│ │ │ │ │ +235 static void stats([[maybe_unused]] const _M_a_t_r_i_x& matrix)
│ │ │ │ │ +236 {}
│ │ │ │ │ +237 };
│ │ │ │ │ +238
│ │ │ │ │ +239 template
│ │ │ │ │ +240 struct MatrixStats<_M_a_t_r_i_x,true>
│ │ │ │ │ +241 {
│ │ │ │ │ +_2_4_2 struct calc
│ │ │ │ │ +243 {
│ │ │ │ │ +_2_4_4 typedef typename _M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e _s_i_z_e___t_y_p_e;
│ │ │ │ │ +_2_4_5 typedef typename _M_a_t_r_i_x_:_:_r_o_w___t_y_p_e _m_a_t_r_i_x___r_o_w;
│ │ │ │ │ +246
│ │ │ │ │ +_2_4_7 _c_a_l_c()
│ │ │ │ │ +248 {
│ │ │ │ │ +249 min=std::numeric_limits::max();
│ │ │ │ │ +250 max=0;
│ │ │ │ │ +251 sum=0;
│ │ │ │ │ +252 }
│ │ │ │ │ +253
│ │ │ │ │ +_2_5_4 void _o_p_e_r_a_t_o_r_(_)(const _m_a_t_r_i_x___r_o_w& row)
│ │ │ │ │ +255 {
│ │ │ │ │ +256 min=std::min(min, row.size());
│ │ │ │ │ +257 max=std::max(max, row.size());
│ │ │ │ │ +258 sum += row.size();
│ │ │ │ │ +259 }
│ │ │ │ │ +260
│ │ │ │ │ +_2_6_1 _s_i_z_e___t_y_p_e _m_i_n;
│ │ │ │ │ +_2_6_2 _s_i_z_e___t_y_p_e _m_a_x;
│ │ │ │ │ +_2_6_3 _s_i_z_e___t_y_p_e _s_u_m;
│ │ │ │ │ +264 };
│ │ │ │ │ +268 static void stats(const _M_a_t_r_i_x& matrix)
│ │ │ │ │ +269 {
│ │ │ │ │ +270 calc c= for_each(matrix.begin(), matrix.end(), calc());
│ │ │ │ │ +271 dinfo<<"Matrix row: min="<
│ │ │ │ │ +_3_2_9 bool _r_e_p_a_r_t_i_t_i_o_n_A_n_d_D_i_s_t_r_i_b_u_t_e_M_a_t_r_i_x(const M& origMatrix,
│ │ │ │ │ +330 std::shared_ptr newMatrix,
│ │ │ │ │ +331 C& origComm,
│ │ │ │ │ +332 std::shared_ptr& newComm,
│ │ │ │ │ +333 _R_e_d_i_s_t_r_i_b_u_t_e_I_n_f_o_r_m_a_t_i_o_n_<_C_>& ri,
│ │ │ │ │ +334 int nparts, C1& criterion)
│ │ │ │ │ +335 {
│ │ │ │ │ +336 Timer time;
│ │ │ │ │ +337#ifdef AMG_REPART_ON_COMM_GRAPH
│ │ │ │ │ +338 // Done not repartition the matrix graph, but a graph of the communication
│ │ │ │ │ +scheme.
│ │ │ │ │ +339 bool existentOnRedist=_D_u_n_e_:_:_c_o_m_m_G_r_a_p_h_R_e_p_a_r_t_i_t_i_o_n(origMatrix, origComm,
│ │ │ │ │ +nparts, newComm,
│ │ │ │ │ +340 ri.getInterface(),
│ │ │ │ │ +341 criterion.debugLevel()>1);
│ │ │ │ │ +342
│ │ │ │ │ +343#else
│ │ │ │ │ +344 typedef _D_u_n_e_:_:_A_m_g_:_:_M_a_t_r_i_x_G_r_a_p_h_<_c_o_n_s_t_ _M_> _M_a_t_r_i_x_G_r_a_p_h;
│ │ │ │ │ +345 typedef _D_u_n_e_:_:_A_m_g_:_:_P_r_o_p_e_r_t_i_e_s_G_r_a_p_h<_M_a_t_r_i_x_G_r_a_p_h,
│ │ │ │ │ +346 _V_e_r_t_e_x_P_r_o_p_e_r_t_i_e_s,
│ │ │ │ │ +347 _E_d_g_e_P_r_o_p_e_r_t_i_e_s,
│ │ │ │ │ +348 IdentityMap,
│ │ │ │ │ +349 IdentityMap> _P_r_o_p_e_r_t_i_e_s_G_r_a_p_h;
│ │ │ │ │ +350 _M_a_t_r_i_x_G_r_a_p_h graph(origMatrix);
│ │ │ │ │ +351 _P_r_o_p_e_r_t_i_e_s_G_r_a_p_h pgraph(graph);
│ │ │ │ │ +352 _b_u_i_l_d_D_e_p_e_n_d_e_n_c_y(pgraph, origMatrix, criterion, false);
│ │ │ │ │ +353
│ │ │ │ │ +354#ifdef DEBUG_REPART
│ │ │ │ │ +355 if(origComm.communicator().rank()==0)
│ │ │ │ │ +356 std::cout<<"Original matrix"<1);
│ │ │ │ │ +363#endif // if else AMG_REPART
│ │ │ │ │ +364
│ │ │ │ │ +365 if(origComm.communicator().rank()==0 && criterion.debugLevel()>1)
│ │ │ │ │ +366 std::cout<<"Repartitioning took "<
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,35 +1,41 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ 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 | _T_y_p_e_d_e_f_s
│ │ │ │ │ -allocator.hh File Reference
│ │ │ │ │ -#include