// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root // SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- // vi: set et ts=4 sw=2 sts=2: #ifndef DUNE_ISTL_OVERLAPPINGSCHWARZ_HH #define DUNE_ISTL_OVERLAPPINGSCHWARZ_HH #include #include #include #include #include #include #include #include #include #include "preconditioners.hh" #include "superlu.hh" #include "umfpack.hh" #include "bvector.hh" #include "bcrsmatrix.hh" #include "ilusubdomainsolver.hh" #include namespace Dune { /** * @addtogroup ISTL_Prec * * @{ */ /** * @file * @author Markus Blatt * @brief Contains one level overlapping Schwarz preconditioners */ template class SeqOverlappingSchwarz; /** * @brief Initializer for SuperLU Matrices representing the subdomains. */ template class OverlappingSchwarzInitializer { public: /** @brief The vector type containing the subdomain to row index mapping. */ typedef D subdomain_vector; typedef I InitializerList; typedef typename InitializerList::value_type AtomInitializer; typedef typename AtomInitializer::Matrix Matrix; typedef typename Matrix::const_iterator Iter; typedef typename Matrix::row_type::const_iterator CIter; typedef S IndexSet; typedef typename IndexSet::size_type size_type; OverlappingSchwarzInitializer(InitializerList& il, const IndexSet& indices, const subdomain_vector& domains); void addRowNnz(const Iter& row); void allocate(); void countEntries(const Iter& row, const CIter& col) const; void calcColstart() const; void copyValue(const Iter& row, const CIter& col) const; void createMatrix() const; private: class IndexMap { public: typedef typename S::size_type size_type; typedef std::map Map; typedef typename Map::iterator iterator; typedef typename Map::const_iterator const_iterator; IndexMap(); void insert(size_type grow); const_iterator find(size_type grow) const; iterator find(size_type grow); iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const; private: std::map map_; size_type row; }; typedef typename InitializerList::iterator InitIterator; typedef typename IndexSet::const_iterator IndexIteratur; InitializerList* initializers; const IndexSet *indices; mutable std::vector indexMaps; const subdomain_vector& domains; }; /** * @brief Tag that the tells the Schwarz method to be additive. */ struct AdditiveSchwarzMode {}; /** * @brief Tag that tells the Schwarz method to be multiplicative. */ struct MultiplicativeSchwarzMode {}; /** * @brief Tag that tells the Schwarz method to be multiplicative * and symmetric. */ struct SymmetricMultiplicativeSchwarzMode {}; /** * @brief Exact subdomain solver using Dune::DynamicMatrix::solve * @tparam M The type of the matrix. */ template class DynamicMatrixSubdomainSolver; // Specialization for BCRSMatrix template class DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y > { typedef BCRSMatrix< K, Al> M; public: //! \brief The matrix type the preconditioner is for. typedef typename std::remove_const::type matrix_type; typedef typename X::field_type field_type; typedef typename std::remove_const::type rilu_type; //! \brief The domain type of the preconditioner. typedef X domain_type; //! \brief The range type of the preconditioner. typedef Y range_type; static constexpr size_t n = std::decay_t()))>::rows; /** * @brief Apply the subdomain solver. * @copydoc ILUSubdomainSolver::apply */ void apply (DynamicVector& v, DynamicVector& d) { assert(v.size() > 0); assert(v.size() == d.size()); assert(A.rows() <= v.size()); assert(A.cols() <= v.size()); size_t sz = A.rows(); v.resize(sz); d.resize(sz); A.solve(v,d); v.resize(v.capacity()); d.resize(d.capacity()); } /** * @brief Set the data of the local problem. * * @param BCRS The global matrix. * @param rowset The global indices of the local problem. * @tparam S The type of the set with the indices. */ template void setSubMatrix(const M& BCRS, S& rowset) { size_t sz = rowset.size(); A.resize(sz*n,sz*n); typedef typename S::const_iterator SIter; size_t r = 0; for(SIter rowIdx = rowset.begin(), rowEnd=rowset.end(); rowIdx!= rowEnd; ++rowIdx, r++) { size_t c = 0; for(SIter colIdx = rowset.begin(), colEnd=rowset.end(); colIdx!= colEnd; ++colIdx, c++) { if (BCRS[*rowIdx].find(*colIdx) == BCRS[*rowIdx].end()) continue; for (size_t i=0; i A; }; template class OverlappingAssignerHelper {}; template using OverlappingAssigner = OverlappingAssignerHelper::value>; // specialization for DynamicMatrix template class OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix, X, Y >,false> { public: typedef BCRSMatrix< K, Al> matrix_type; typedef typename X::field_type field_type; typedef Y range_type; typedef typename range_type::block_type block_type; typedef typename matrix_type::size_type size_type; static constexpr size_t n = std::decay_t()))>::rows; /** * @brief Constructor. * @param maxlength The maximum entries over all subdomains. * @param mat_ The global matrix. * @param b_ the global right hand side. * @param x_ the global left hand side. */ OverlappingAssignerHelper(std::size_t maxlength, const BCRSMatrix& mat_, const X& b_, Y& x_); /** * @brief Deallocates memory of the local vector. */ inline void deallocate(); /** * @brief Resets the local index to zero. */ inline void resetIndexForNextDomain(); /** * @brief Get the local left hand side. * @return The local left hand side. */ inline DynamicVector & lhs(); /** * @brief Get the local right hand side. * @return The local right hand side. */ inline DynamicVector & rhs(); /** * @brief relax the result. * @param relax The relaxation parameter. */ inline void relaxResult(field_type relax); /** * @brief calculate one entry of the local defect. * @param domainIndex One index of the domain. */ void operator()(const size_type& domainIndex); /** * @brief Assigns the block to the current local * index. * At the same time the local defect is calculated * for the index and stored in the rhs. * Afterwards the is incremented for the next block. */ inline void assignResult(block_type& res); private: /** * @brief The global matrix for the defect calculation. */ const matrix_type* mat; /** @brief The local right hand side. */ // we need a pointer, because we have to avoid deep copies DynamicVector * rhs_; /** @brief The local left hand side. */ // we need a pointer, because we have to avoid deep copies DynamicVector * lhs_; /** @brief The global right hand side for the defect calculation. */ const range_type* b; /** @brief The global right hand side for adding the local update to. */ range_type* x; /** @brief The current local index. */ std::size_t i; /** @brief The maximum entries over all subdomains. */ std::size_t maxlength_; }; #if HAVE_SUPERLU || HAVE_SUITESPARSE_UMFPACK template class S, typename T, typename A> struct OverlappingAssignerHelper>, true> { typedef BCRSMatrix matrix_type; typedef typename S>::range_type range_type; typedef typename range_type::field_type field_type; typedef typename range_type::block_type block_type; typedef typename matrix_type::size_type size_type; static constexpr size_t n = std::decay_t()))>::rows; static constexpr size_t m = std::decay_t()))>::cols; /** * @brief Constructor. * @param maxlength The maximum entries over all subdomains. * @param mat The global matrix. * @param b the global right hand side. * @param x the global left hand side. */ OverlappingAssignerHelper(std::size_t maxlength, const matrix_type& mat, const range_type& b, range_type& x); /** * @brief Deallocates memory of the local vector. * @warning memory is released by the destructor as this Functor * is copied and the copy needs to still have the data. */ void deallocate(); /* * @brief Resets the local index to zero. */ void resetIndexForNextDomain(); /** * @brief Get the local left hand side. * @return The local left hand side. */ field_type* lhs(); /** * @brief Get the local right hand side. * @return The local right hand side. */ field_type* rhs(); /** * @brief relax the result. * @param relax The relaxation parameter. */ void relaxResult(field_type relax); /** * @brief calculate one entry of the local defect. * @param domain One index of the domain. */ void operator()(const size_type& domain); /** * @brief Assigns the block to the current local * index. * At the same time the local defect is calculated * for the index and stored in the rhs. * Afterwards the is incremented for the next block. */ void assignResult(block_type& res); private: /** * @brief The global matrix for the defect calculation. */ const matrix_type* mat; /** @brief The local right hand side. */ field_type* rhs_; /** @brief The local left hand side. */ field_type* lhs_; /** @brief The global right hand side for the defect calculation. */ const range_type* b; /** @brief The global right hand side for adding the local update to. */ range_type* x; /** @brief The current local index. */ std::size_t i; /** @brief The maximum entries over all subdomains. */ std::size_t maxlength_; }; #endif // HAVE_SUPERLU || HAVE_SUITESPARSE_UMFPACK template class OverlappingAssignerILUBase { public: typedef M matrix_type; typedef typename Y::field_type field_type; typedef typename Y::block_type block_type; typedef typename matrix_type::size_type size_type; /** * @brief Constructor. * @param maxlength The maximum entries over all subdomains. * @param mat The global matrix. * @param b the global right hand side. * @param x the global left hand side. */ OverlappingAssignerILUBase(std::size_t maxlength, const M& mat, const Y& b, X& x); /** * @brief Deallocates memory of the local vector. * @warning memory is released by the destructor as this Functor * is copied and the copy needs to still have the data. */ void deallocate(); /** * @brief Resets the local index to zero. */ void resetIndexForNextDomain(); /** * @brief Get the local left hand side. * @return The local left hand side. */ X& lhs(); /** * @brief Get the local right hand side. * @return The local right hand side. */ Y& rhs(); /** * @brief relax the result. * @param relax The relaxation parameter. */ void relaxResult(field_type relax); /** * @brief calculate one entry of the local defect. * @param domain One index of the domain. */ void operator()(const size_type& domain); /** * @brief Assigns the block to the current local * index. * At the same time the local defect is calculated * for the index and stored in the rhs. * Afterwards the is incremented for the next block. */ void assignResult(block_type& res); private: /** * @brief The global matrix for the defect calculation. */ const M* mat; /** @brief The local left hand side. */ X* lhs_; /** @brief The local right hand side. */ Y* rhs_; /** @brief The global right hand side for the defect calculation. */ const Y* b; /** @brief The global left hand side for adding the local update to. */ X* x; /** @brief The maximum entries over all subdomains. */ size_type i; }; // specialization for ILU0 template class OverlappingAssignerHelper, false> : public OverlappingAssignerILUBase { public: /** * @brief Constructor. * @param maxlength The maximum entries over all subdomains. * @param mat The global matrix. * @param b the global right hand side. * @param x the global left hand side. */ OverlappingAssignerHelper(std::size_t maxlength, const M& mat, const Y& b, X& x) : OverlappingAssignerILUBase(maxlength, mat,b,x) {} }; // specialization for ILUN template class OverlappingAssignerHelper,false> : public OverlappingAssignerILUBase { public: /** * @brief Constructor. * @param maxlength The maximum entries over all subdomains. * @param mat The global matrix. * @param b the global right hand side. * @param x the global left hand side. */ OverlappingAssignerHelper(std::size_t maxlength, const M& mat, const Y& b, X& x) : OverlappingAssignerILUBase(maxlength, mat,b,x) {} }; template struct AdditiveAdder {}; template struct AdditiveAdder > { typedef typename A::size_type size_type; typedef typename std::decay_t()))>::field_type field_type; AdditiveAdder(BlockVector& v, BlockVector& x, OverlappingAssigner& assigner, const field_type& relax_); void operator()(const size_type& domain); void axpy(); static constexpr size_t n = std::decay_t()))>::dimension; private: BlockVector* v; BlockVector* x; OverlappingAssigner* assigner; field_type relax; }; template struct MultiplicativeAdder {}; template struct MultiplicativeAdder > { typedef typename A::size_type size_type; typedef typename std::decay_t()))>::field_type field_type; MultiplicativeAdder(BlockVector& v, BlockVector& x, OverlappingAssigner& assigner_, const field_type& relax_); void operator()(const size_type& domain); void axpy(); static constexpr size_t n = std::decay_t()))>::dimension; private: BlockVector* x; OverlappingAssigner* assigner; field_type relax; }; /** * @brief template meta program for choosing how to add the correction. * * There are specialization for the additive, the multiplicative, and the symmetric multiplicative mode. * * \tparam T The Schwarz mode (either AdditiveSchwarzMode or MuliplicativeSchwarzMode or * SymmetricMultiplicativeSchwarzMode) * \tparam X The vector field type */ template struct AdderSelector {}; template struct AdderSelector { typedef AdditiveAdder Adder; }; template struct AdderSelector { typedef MultiplicativeAdder Adder; }; template struct AdderSelector { typedef MultiplicativeAdder Adder; }; /** * @brief Helper template meta program for application of overlapping Schwarz. * * The is needed because when using the multiplicative Schwarz version one * might still want to make multigrid symmetric, i.e. forward sweep when pre- * and backward sweep when post-smoothing. * * @tparam T1 type of the vector with the subdomain solvers. * @tparam T2 type of the vector with the subdomain vector fields. * @tparam forward If true apply in a forward sweep. */ template struct IteratorDirectionSelector { typedef T1 solver_vector; typedef typename solver_vector::iterator solver_iterator; typedef T2 subdomain_vector; typedef typename subdomain_vector::const_iterator domain_iterator; static solver_iterator begin(solver_vector& sv) { return sv.begin(); } static solver_iterator end(solver_vector& sv) { return sv.end(); } static domain_iterator begin(const subdomain_vector& sv) { return sv.begin(); } static domain_iterator end(const subdomain_vector& sv) { return sv.end(); } }; template struct IteratorDirectionSelector { typedef T1 solver_vector; typedef typename solver_vector::reverse_iterator solver_iterator; typedef T2 subdomain_vector; typedef typename subdomain_vector::const_reverse_iterator domain_iterator; static solver_iterator begin(solver_vector& sv) { return sv.rbegin(); } static solver_iterator end(solver_vector& sv) { return sv.rend(); } static domain_iterator begin(const subdomain_vector& sv) { return sv.rbegin(); } static domain_iterator end(const subdomain_vector& sv) { return sv.rend(); } }; /** * @brief Helper template meta program for application of overlapping Schwarz. * * The is needed because when using the multiplicative Schwarz version one * might still want to make multigrid symmetric, i.e. forward sweep when pre- * and backward sweep when post-smoothing. * @tparam T The smoother to apply. */ template struct SeqOverlappingSchwarzApplier { typedef T smoother; typedef typename smoother::range_type range_type; static void apply(smoother& sm, range_type& v, const range_type& b) { sm.template apply(v, b); } }; template struct SeqOverlappingSchwarzApplier > { typedef SeqOverlappingSchwarz smoother; typedef typename smoother::range_type range_type; static void apply(smoother& sm, range_type& v, const range_type& b) { sm.template apply(v, b); sm.template apply(v, b); } }; template struct SeqOverlappingSchwarzAssemblerHelper {}; template using SeqOverlappingSchwarzAssembler = SeqOverlappingSchwarzAssemblerHelper::value>; template struct SeqOverlappingSchwarzAssemblerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false> { typedef BCRSMatrix< K, Al> matrix_type; static constexpr size_t n = std::decay_t()))>::rows; template static std::size_t assembleLocalProblems(const RowToDomain& rowToDomain, const matrix_type& mat, Solvers& solvers, const SubDomains& domains, bool onTheFly); }; template class S, typename T, typename A> struct SeqOverlappingSchwarzAssemblerHelper>,true> { typedef BCRSMatrix matrix_type; static constexpr size_t n = std::decay_t()))>::rows; template static std::size_t assembleLocalProblems(const RowToDomain& rowToDomain, const matrix_type& mat, Solvers& solvers, const SubDomains& domains, bool onTheFly); }; template struct SeqOverlappingSchwarzAssemblerILUBase { typedef M matrix_type; template static std::size_t assembleLocalProblems(const RowToDomain& rowToDomain, const matrix_type& mat, Solvers& solvers, const SubDomains& domains, bool onTheFly); }; template struct SeqOverlappingSchwarzAssemblerHelper,false> : public SeqOverlappingSchwarzAssemblerILUBase {}; template struct SeqOverlappingSchwarzAssemblerHelper,false> : public SeqOverlappingSchwarzAssemblerILUBase {}; /** * @brief Sequential overlapping Schwarz preconditioner * * @tparam M The matrix type. * @tparam X The range and domain type. * @tparam TM The Schwarz mode. Currently supported modes are AdditiveSchwarzMode, * MultiplicativeSchwarzMode, and SymmetricMultiplicativeSchwarzMode. (Default values is AdditiveSchwarzMode) * @tparam TD The type of the local subdomain solver to be used. * @tparam TA The type of the allocator to use. */ template, class TA=std::allocator > class SeqOverlappingSchwarz : public Preconditioner { public: /** * @brief The type of the matrix to precondition. */ typedef M matrix_type; /** * @brief The domain type of the preconditioner */ typedef X domain_type; /** * @brief The range type of the preconditioner. */ typedef X range_type; /** * @brief The mode (additive or multiplicative) of the Schwarz * method. * * Either AdditiveSchwarzMode or MultiplicativeSchwarzMode */ typedef TM Mode; /** * @brief The field type of the preconditioner. */ typedef typename X::field_type field_type; /** @brief The return type of the size method. */ typedef typename matrix_type::size_type size_type; /** @brief The allocator to use. */ typedef TA allocator; /** @brief The type for the subdomain to row index mapping. */ typedef std::set, typename std::allocator_traits::template rebind_alloc > subdomain_type; /** @brief The vector type containing the subdomain to row index mapping. */ typedef std::vector::template rebind_alloc > subdomain_vector; /** @brief The type for the row to subdomain mapping. */ typedef SLList::template rebind_alloc > subdomain_list; /** @brief The vector type containing the row index to subdomain mapping. */ typedef std::vector::template rebind_alloc > rowtodomain_vector; /** @brief The type for the subdomain solver in use. */ typedef TD slu; /** @brief The vector type containing subdomain solvers. */ typedef std::vector::template rebind_alloc > slu_vector; /** * @brief Construct the overlapping Schwarz method. * @param mat The matrix to precondition. * @param subDomains Array of sets of rowindices belonging to an overlapping * subdomain * @param relaxationFactor relaxation factor * @param onTheFly_ If true the decomposition of the exact local solvers is * computed on the fly for each subdomain and * iteration step. If false all decompositions are computed in pre and * only forward and backward substitution takes place * in the iteration steps. * @warning Each rowindex should be part of at least one subdomain! */ SeqOverlappingSchwarz(const matrix_type& mat, const subdomain_vector& subDomains, field_type relaxationFactor=1, bool onTheFly_=true); /** * Construct the overlapping Schwarz method * @param mat The matrix to precondition. * @param rowToDomain The mapping of the rows onto the domains. * @param relaxationFactor relaxation factor * @param onTheFly_ If true the decomposition of the exact local solvers is * computed on the fly for each subdomain and * iteration step. If false all decompositions are computed in pre and * only forward and backward substitution takes place * in the iteration steps. */ SeqOverlappingSchwarz(const matrix_type& mat, const rowtodomain_vector& rowToDomain, field_type relaxationFactor=1, bool onTheFly_=true); /*! \brief Prepare the preconditioner. \copydoc Preconditioner::pre(X&,Y&) */ void pre ([[maybe_unused]] X& x, [[maybe_unused]] X& b) override {} /*! \brief Apply the preconditioner \copydoc Preconditioner::apply(X&,const Y&) */ void apply (X& v, const X& d) override; /*! \brief Postprocess the preconditioner. \copydoc Preconditioner::post(X&) */ void post ([[maybe_unused]] X& x) override {} template void apply(X& v, const X& d); //! Category of the preconditioner (see SolverCategory::Category) SolverCategory::Category category() const override { return SolverCategory::sequential; } private: const M& mat; slu_vector solvers; subdomain_vector subDomains; field_type relax; typename M::size_type maxlength; bool onTheFly; }; template OverlappingSchwarzInitializer::OverlappingSchwarzInitializer(InitializerList& il, const IndexSet& idx, const subdomain_vector& domains_) : initializers(&il), indices(&idx), indexMaps(il.size()), domains(domains_) {} template void OverlappingSchwarzInitializer::addRowNnz(const Iter& row) { typedef typename IndexSet::value_type::const_iterator iterator; for(iterator domain=(*indices)[row.index()].begin(); domain != (*indices)[row.index()].end(); ++domain) { (*initializers)[*domain].addRowNnz(row, domains[*domain]); indexMaps[*domain].insert(row.index()); } } template void OverlappingSchwarzInitializer::allocate() { for(auto&& i: *initializers) i.allocateMatrixStorage(); for(auto&& i: *initializers) i.allocateMarker(); } template void OverlappingSchwarzInitializer::countEntries(const Iter& row, const CIter& col) const { typedef typename IndexSet::value_type::const_iterator iterator; for(iterator domain=(*indices)[row.index()].begin(); domain != (*indices)[row.index()].end(); ++domain) { typename std::map::const_iterator v = indexMaps[*domain].find(col.index()); if(v!= indexMaps[*domain].end()) { (*initializers)[*domain].countEntries(indexMaps[*domain].find(col.index())->second); } } } template void OverlappingSchwarzInitializer::calcColstart() const { for(auto&& i : *initializers) i.calcColstart(); } template void OverlappingSchwarzInitializer::copyValue(const Iter& row, const CIter& col) const { typedef typename IndexSet::value_type::const_iterator iterator; for(iterator domain=(*indices)[row.index()].begin(); domain!= (*indices)[row.index()].end(); ++domain) { typename std::map::const_iterator v = indexMaps[*domain].find(col.index()); if(v!= indexMaps[*domain].end()) { assert(indexMaps[*domain].end()!=indexMaps[*domain].find(row.index())); (*initializers)[*domain].copyValue(col, indexMaps[*domain].find(row.index())->second, v->second); } } } template void OverlappingSchwarzInitializer::createMatrix() const { std::vector().swap(indexMaps); for(auto&& i: *initializers) i.createMatrix(); } template OverlappingSchwarzInitializer::IndexMap::IndexMap() : row(0) {} template void OverlappingSchwarzInitializer::IndexMap::insert(size_type grow) { assert(map_.find(grow)==map_.end()); map_.insert(std::make_pair(grow, row++)); } template typename OverlappingSchwarzInitializer::IndexMap::const_iterator OverlappingSchwarzInitializer::IndexMap::find(size_type grow) const { return map_.find(grow); } template typename OverlappingSchwarzInitializer::IndexMap::iterator OverlappingSchwarzInitializer::IndexMap::find(size_type grow) { return map_.find(grow); } template typename OverlappingSchwarzInitializer::IndexMap::const_iterator OverlappingSchwarzInitializer::IndexMap::end() const { return map_.end(); } template typename OverlappingSchwarzInitializer::IndexMap::iterator OverlappingSchwarzInitializer::IndexMap::end() { return map_.end(); } template typename OverlappingSchwarzInitializer::IndexMap::const_iterator OverlappingSchwarzInitializer::IndexMap::begin() const { return map_.begin(); } template typename OverlappingSchwarzInitializer::IndexMap::iterator OverlappingSchwarzInitializer::IndexMap::begin() { return map_.begin(); } template SeqOverlappingSchwarz::SeqOverlappingSchwarz(const matrix_type& mat_, const rowtodomain_vector& rowToDomain, field_type relaxationFactor, bool fly) : mat(mat_), relax(relaxationFactor), onTheFly(fly) { typedef typename rowtodomain_vector::const_iterator RowDomainIterator; typedef typename subdomain_list::const_iterator DomainIterator; #ifdef DUNE_ISTL_WITH_CHECKING assert(rowToDomain.size()==mat.N()); assert(rowToDomain.size()==mat.M()); for(RowDomainIterator iter=rowToDomain.begin(); iter != rowToDomain.end(); ++iter) assert(iter->size()>0); #endif // calculate the number of domains size_type domains=0; for(RowDomainIterator iter=rowToDomain.begin(); iter != rowToDomain.end(); ++iter) for(DomainIterator d=iter->begin(); d != iter->end(); ++d) domains=std::max(domains, *d); ++domains; solvers.resize(domains); subDomains.resize(domains); // initialize subdomains to row mapping from row to subdomain mapping size_type row=0; for(RowDomainIterator iter=rowToDomain.begin(); iter != rowToDomain.end(); ++iter, ++row) for(DomainIterator d=iter->begin(); d != iter->end(); ++d) subDomains[*d].insert(row); #ifdef DUNE_ISTL_WITH_CHECKING size_type i=0; typedef typename subdomain_vector::const_iterator iterator; for(iterator iter=subDomains.begin(); iter != subDomains.end(); ++iter) { typedef typename subdomain_type::const_iterator entry_iterator; Dune::dvverb<<"domain "<begin(); entry != iter->end(); ++entry) { Dune::dvverb<<" "<<*entry; } Dune::dvverb< ::assembleLocalProblems(rowToDomain, mat, solvers, subDomains, onTheFly); } template SeqOverlappingSchwarz::SeqOverlappingSchwarz(const matrix_type& mat_, const subdomain_vector& sd, field_type relaxationFactor, bool fly) : mat(mat_), solvers(sd.size()), subDomains(sd), relax(relaxationFactor), onTheFly(fly) { typedef typename subdomain_vector::const_iterator DomainIterator; #ifdef DUNE_ISTL_WITH_CHECKING size_type i=0; for(DomainIterator d=sd.begin(); d != sd.end(); ++d,++i) { //std::cout<size()<size()>0); typedef typename DomainIterator::value_type::const_iterator entry_iterator; Dune::dvverb<<"domain "<begin(); entry != d->end(); ++entry) { Dune::dvverb<<" "<<*entry; } Dune::dvverb<begin(); row != domain->end(); ++row) rowToDomain[*row].push_back(domainId); } maxlength = SeqOverlappingSchwarzAssembler ::assembleLocalProblems(rowToDomain, mat, solvers, subDomains, onTheFly); } /** template helper struct to determine the size of a domain for the SeqOverlappingSchwarz solver only implemented for BCRSMatrix */ template struct SeqOverlappingSchwarzDomainSize {}; template struct SeqOverlappingSchwarzDomainSize > { static constexpr size_t n = std::decay_t()))>::rows; static constexpr size_t m = std::decay_t()))>::cols; template static int size(const Domain & d) { assert(n==m); return m*d.size(); } }; template template std::size_t SeqOverlappingSchwarzAssemblerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false>:: assembleLocalProblems([[maybe_unused]] const RowToDomain& rowToDomain, [[maybe_unused]] const matrix_type& mat, [[maybe_unused]] Solvers& solvers, const SubDomains& subDomains, [[maybe_unused]] bool onTheFly) { typedef typename SubDomains::const_iterator DomainIterator; std::size_t maxlength = 0; assert(onTheFly); for(DomainIterator domain=subDomains.begin(); domain!=subDomains.end(); ++domain) maxlength=std::max(maxlength, domain->size()); maxlength*=n; return maxlength; } #if HAVE_SUPERLU || HAVE_SUITESPARSE_UMFPACK template class S, typename T, typename A> template std::size_t SeqOverlappingSchwarzAssemblerHelper>,true>::assembleLocalProblems(const RowToDomain& rowToDomain, const matrix_type& mat, Solvers& solvers, const SubDomains& subDomains, bool onTheFly) { typedef typename S>::MatrixInitializer MatrixInitializer; typedef typename std::vector::iterator InitializerIterator; typedef typename SubDomains::const_iterator DomainIterator; typedef typename Solvers::iterator SolverIterator; std::size_t maxlength = 0; if(onTheFly) { for(DomainIterator domain=subDomains.begin(); domain!=subDomains.end(); ++domain) maxlength=std::max(maxlength, domain->size()); maxlength*=Impl::asMatrix(*mat[0].begin()).N(); }else{ // initialize the initializers DomainIterator domain=subDomains.begin(); // Create the initializers list. std::vector initializers(subDomains.size()); SolverIterator solver=solvers.begin(); for(InitializerIterator initializer=initializers.begin(); initializer!=initializers.end(); ++initializer, ++solver, ++domain) { solver->getInternalMatrix().N_=SeqOverlappingSchwarzDomainSize::size(*domain); solver->getInternalMatrix().M_=SeqOverlappingSchwarzDomainSize::size(*domain); //solver->setVerbosity(true); *initializer=MatrixInitializer(solver->getInternalMatrix()); } // Set up the supermatrices according to the subdomains typedef OverlappingSchwarzInitializer, RowToDomain, SubDomains> Initializer; Initializer initializer(initializers, rowToDomain, subDomains); copyToBCCSMatrix(initializer, mat); // Calculate the LU decompositions for(auto&& s: solvers) s.decompose(); for (SolverIterator solverIt = solvers.begin(); solverIt != solvers.end(); ++solverIt) { assert(solverIt->getInternalMatrix().N() == solverIt->getInternalMatrix().M()); maxlength = std::max(maxlength, solverIt->getInternalMatrix().N()); } } return maxlength; } #endif // HAVE_SUPERLU || HAVE_SUITESPARSE_UMFPACK template template std::size_t SeqOverlappingSchwarzAssemblerILUBase::assembleLocalProblems([[maybe_unused]] const RowToDomain& rowToDomain, const matrix_type& mat, Solvers& solvers, const SubDomains& subDomains, bool onTheFly) { typedef typename SubDomains::const_iterator DomainIterator; typedef typename Solvers::iterator SolverIterator; std::size_t maxlength = 0; if(onTheFly) { for(DomainIterator domain=subDomains.begin(); domain!=subDomains.end(); ++domain) maxlength=std::max(maxlength, domain->size()); }else{ // initialize the solvers of the local problems. SolverIterator solver=solvers.begin(); for(DomainIterator domain=subDomains.begin(); domain!=subDomains.end(); ++domain, ++solver) { solver->setSubMatrix(mat, *domain); maxlength=std::max(maxlength, domain->size()); } } return maxlength; } template void SeqOverlappingSchwarz::apply(X& x, const X& b) { SeqOverlappingSchwarzApplier::apply(*this, x, b); } template template void SeqOverlappingSchwarz::apply(X& x, const X& b) { typedef slu_vector solver_vector; typedef typename IteratorDirectionSelector::solver_iterator iterator; typedef typename IteratorDirectionSelector::domain_iterator domain_iterator; OverlappingAssigner assigner(maxlength, mat, b, x); domain_iterator domain=IteratorDirectionSelector::begin(subDomains); iterator solver = IteratorDirectionSelector::begin(solvers); X v(x); // temporary for the update v=0; typedef typename AdderSelector::Adder Adder; Adder adder(v, x, assigner, relax); for(; domain != IteratorDirectionSelector::end(subDomains); ++domain) { //Copy rhs to C-array for SuperLU std::for_each(domain->begin(), domain->end(), assigner); assigner.resetIndexForNextDomain(); if(onTheFly) { // Create the subdomain solver slu sdsolver; sdsolver.setSubMatrix(mat, *domain); // Apply sdsolver.apply(assigner.lhs(), assigner.rhs()); }else{ solver->apply(assigner.lhs(), assigner.rhs()); ++solver; } //Add relaxed correction to from SuperLU to v std::for_each(domain->begin(), domain->end(), adder); assigner.resetIndexForNextDomain(); } adder.axpy(); assigner.deallocate(); } template OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false> ::OverlappingAssignerHelper(std::size_t maxlength, const BCRSMatrix& mat_, const X& b_, Y& x_) : mat(&mat_), rhs_( new DynamicVector(maxlength, 42) ), lhs_( new DynamicVector(maxlength, -42) ), b(&b_), x(&x_), i(0), maxlength_(maxlength) {} template void OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false> ::deallocate() { delete rhs_; delete lhs_; } template void OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false> ::resetIndexForNextDomain() { i=0; } template DynamicVector & OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false> ::lhs() { return *lhs_; } template DynamicVector & OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false> ::rhs() { return *rhs_; } template void OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false> ::relaxResult(field_type relax) { lhs() *= relax; } template void OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false> ::operator()(const size_type& domainIndex) { lhs() = 0.0; #if 0 //assign right hand side of current domainindex block for(size_type j=0; j void OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al>, X, Y >,false> ::assignResult(block_type& res) { // assign the result of the local solve to the global vector for(size_type j=0; j class S, typename T, typename A> OverlappingAssignerHelper>,true> ::OverlappingAssignerHelper(std::size_t maxlength, const BCRSMatrix& mat_, const range_type& b_, range_type& x_) : mat(&mat_), b(&b_), x(&x_), i(0), maxlength_(maxlength) { rhs_ = new field_type[maxlength]; lhs_ = new field_type[maxlength]; } template class S, typename T, typename A> void OverlappingAssignerHelper >,true>::deallocate() { delete[] rhs_; delete[] lhs_; } template class S, typename T, typename A> void OverlappingAssignerHelper>,true>::operator()(const size_type& domainIndex) { //assign right hand side of current domainindex block // rhs is an array of doubles! // rhs[starti] = b[domainindex] for(size_type j=0; j class S, typename T, typename A> void OverlappingAssignerHelper>,true>::relaxResult(field_type relax) { for(size_type j=i+n; i class S, typename T, typename A> void OverlappingAssignerHelper>,true>::assignResult(block_type& res) { // assign the result of the local solve to the global vector for(size_type j=0; j class S, typename T, typename A> void OverlappingAssignerHelper>,true>::resetIndexForNextDomain() { i=0; } template class S, typename T, typename A> typename OverlappingAssignerHelper>,true>::field_type* OverlappingAssignerHelper>,true>::lhs() { return lhs_; } template class S, typename T, typename A> typename OverlappingAssignerHelper>,true>::field_type* OverlappingAssignerHelper>,true>::rhs() { return rhs_; } #endif // HAVE_SUPERLU || HAVE_SUITESPARSE_UMFPACK template OverlappingAssignerILUBase::OverlappingAssignerILUBase(std::size_t maxlength, const M& mat_, const Y& b_, X& x_) : mat(&mat_), b(&b_), x(&x_), i(0) { rhs_= new Y(maxlength); lhs_ = new X(maxlength); } template void OverlappingAssignerILUBase::deallocate() { delete rhs_; delete lhs_; } template void OverlappingAssignerILUBase::operator()(const size_type& domainIndex) { (*rhs_)[i]=(*b)[domainIndex]; // loop over all Matrix row entries and calculate defect. typedef typename matrix_type::ConstColIterator col_iterator; // calculate defect for current row index block for(col_iterator col=(*mat)[domainIndex].begin(); col!=(*mat)[domainIndex].end(); ++col) { Impl::asMatrix(*col).mmv((*x)[col.index()], (*rhs_)[i]); } // Goto next local index ++i; } template void OverlappingAssignerILUBase::relaxResult(field_type relax) { (*lhs_)[i]*=relax; } template void OverlappingAssignerILUBase::assignResult(block_type& res) { res+=(*lhs_)[i++]; } template X& OverlappingAssignerILUBase::lhs() { return *lhs_; } template Y& OverlappingAssignerILUBase::rhs() { return *rhs_; } template void OverlappingAssignerILUBase::resetIndexForNextDomain() { i=0; } template AdditiveAdder >::AdditiveAdder(BlockVector& v_, BlockVector& x_, OverlappingAssigner& assigner_, const field_type& relax_) : v(&v_), x(&x_), assigner(&assigner_), relax(relax_) {} template void AdditiveAdder >::operator()(const size_type& domainIndex) { // add the result of the local solve to the current update assigner->assignResult((*v)[domainIndex]); } template void AdditiveAdder >::axpy() { // relax the update and add it to the current guess. x->axpy(relax,*v); } template MultiplicativeAdder > ::MultiplicativeAdder([[maybe_unused]] BlockVector& v_, BlockVector& x_, OverlappingAssigner& assigner_, const field_type& relax_) : x(&x_), assigner(&assigner_), relax(relax_) {} template void MultiplicativeAdder >::operator()(const size_type& domainIndex) { // add the result of the local solve to the current guess assigner->relaxResult(relax); assigner->assignResult((*x)[domainIndex]); } template void MultiplicativeAdder >::axpy() { // nothing to do, as the corrections already relaxed and added in operator() } /** @} */ } #endif