// ------------------------------------------------------------------------ // // SPDX-License-Identifier: LGPL-2.1-or-later // Copyright (C) 2024 - 2025 by the deal.II authors // // This file is part of the deal.II library. // // Part of the source code is dual licensed under Apache-2.0 WITH // LLVM-exception OR LGPL-2.1-or-later. Detailed license information // governing the source code and code contributions can be found in // LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II. // // ------------------------------------------------------------------------ #ifndef dealii_trilinos_tpetra_precondition_templates_h #define dealii_trilinos_tpetra_precondition_templates_h #include #include #include #include #include #ifdef DEAL_II_TRILINOS_WITH_TPETRA # ifdef DEAL_II_TRILINOS_WITH_IFPACK2 # include # include # include # include # include # include # include # include # include # include # include DEAL_II_NAMESPACE_OPEN namespace LinearAlgebra { namespace TpetraWrappers { /* ---------------------- PreconditionBase ------------------------ */ template void PreconditionBase::clear() { preconditioner.reset(); } template const TpetraTypes::LinearOperator & PreconditionBase::trilinos_operator() const { return *preconditioner; } template Teuchos::RCP> PreconditionBase::trilinos_rcp() const { return preconditioner; } template IndexSet PreconditionBase::locally_owned_domain_indices() const { return IndexSet(preconditioner->getDomainMap()); } template IndexSet PreconditionBase::locally_owned_range_indices() const { return IndexSet(preconditioner->getRangeMap()); } template inline void PreconditionBase::vmult( Vector &dst, const Vector &src) const { Assert(dst.trilinos_vector().getMap()->isSameAs( *(preconditioner->getRangeMap())), ExcNonMatchingMaps("dst")); Assert(src.trilinos_rcp()->getMap()->isSameAs( *(preconditioner->getDomainMap())), ExcNonMatchingMaps("src")); preconditioner->apply(src.trilinos_vector(), dst.trilinos_vector()); } template inline void PreconditionBase::Tvmult( Vector &dst, const Vector &src) const { Assert(preconditioner->hasTransposeApply(), ExcTransposeNotSupported()); Assert(dst.trilinos_rcp()->getMap()->isSameAs( *(preconditioner->getDomainMap())), ExcNonMatchingMaps("dst")); Assert(src.trilinos_rcp()->getMap()->isSameAs( *(preconditioner->getRangeMap())), ExcNonMatchingMaps("src")); preconditioner->apply(src.trilinos_vector(), dst.trilinos_vector(), Teuchos::TRANS); } template inline void PreconditionBase::vmult( dealii::Vector &dst, dealii::Vector &src) const { AssertDimension(dst.size(), preconditioner->getRangeMap()->getGlobalNumElements()); AssertDimension(src.size(), preconditioner->getDomainMap()->getGlobalNumElements()); // Construct Tpetra Vectors as views to the actual dealii::Vector data // Since all of Tpetra is based on Kokkos::DualView this is a bit of a // process // 1. Make host view with underlying dealii::Vector data. // (This is always a n x 1 matrix since multivector expects that.) // Tpetra uses Kokkos::complex<> internally for std::complex<> using value_type = typename TpetraTypes::HostViewType::value_type; static_assert((numbers::NumberTraits::is_complex && sizeof(value_type) == sizeof(Number)) || (!numbers::NumberTraits::is_complex && std::is_same_v)); TpetraTypes::HostViewType host_src( reinterpret_cast(src.data()), src.size(), 1); TpetraTypes::HostViewType host_dst( reinterpret_cast(dst.data()), dst.size(), 1); // 2. Create device mirror (if Device == Host, no alloc ) auto dev_src = Kokkos::create_mirror_view_and_copy( typename MemorySpace::kokkos_space::execution_space(), host_src); auto dev_dst = Kokkos::create_mirror_view_and_copy( typename MemorySpace::kokkos_space::execution_space(), host_dst); // 3. Create dual views from the previous ones TpetraTypes::DualViewType dual_src(dev_src, host_src); TpetraTypes::DualViewType dual_dst(dev_dst, host_dst); // 4. Create Tpetra Vector from TpetraTypes::VectorType tpetra_dst( preconditioner->getRangeMap(), dual_dst); TpetraTypes::VectorType tpetra_src( preconditioner->getDomainMap(), dual_src); // 5. Finally, apply our preconditioner preconditioner->apply(tpetra_src, tpetra_dst); } template inline void PreconditionBase::Tvmult( dealii::Vector &dst, dealii::Vector &src) const { AssertDimension(dst.size(), preconditioner->getDomainMap()->getGlobalNumElements()); AssertDimension(src.size(), preconditioner->getRangeMap()->getGlobalNumElements()); Assert(preconditioner->hasTransposeApply(), ExcTransposeNotSupported()); // Construct Tpetra Vectors as views to the actual dealii::Vector data // Since all of Tpetra is based on Kokkos::DualView this is a bit of a // process // 1. Make host view with underlying dealii::Vector data. // (This is always a n x 1 matrix since multivector expects that.) // Tpetra uses Kokkos::complex<> internally for std::complex<> using value_type = typename TpetraTypes::HostViewType::value_type; static_assert((numbers::NumberTraits::is_complex && sizeof(value_type) == sizeof(Number)) || (!numbers::NumberTraits::is_complex && std::is_same_v)); TpetraTypes::HostViewType host_src( reinterpret_cast(src.data()), src.size(), 1); TpetraTypes::HostViewType host_dst( reinterpret_cast(dst.data()), dst.size(), 1); // 2. Create device mirror (if Device == Host, no alloc ) auto dev_src = Kokkos::create_mirror_view_and_copy( typename MemorySpace::kokkos_space::execution_space(), host_src); auto dev_dst = Kokkos::create_mirror_view_and_copy( typename MemorySpace::kokkos_space::execution_space(), host_dst); // 3. Create dual views from the previous ones TpetraTypes::DualViewType dual_src(dev_src, host_src); TpetraTypes::DualViewType dual_dst(dev_dst, host_dst); // 4. Create Tpetra Vector from TpetraTypes::VectorType tpetra_dst( preconditioner->getRangeMap(), dual_dst); TpetraTypes::VectorType tpetra_src( preconditioner->getDomainMap(), dual_src); // 5. Finally, apply our preconditioner preconditioner->apply(tpetra_src, tpetra_dst, Teuchos::TRANS); } /* ---------------------- PreconditionIdentity ------------------------ */ template void PreconditionIdentity::initialize( const SparseMatrix &A) { Teuchos::RCP>> ifpack2Preconditioner; ifpack2Preconditioner = rcp(new Ifpack2::IdentitySolver< TpetraTypes::RowMatrixType>(A.trilinos_rcp())); ifpack2Preconditioner->initialize(); ifpack2Preconditioner->compute(); this->preconditioner = ifpack2Preconditioner; } /* ---------------------- PreconditionIfpackBase ------------------------ */ template PreconditionIfpackBase::PreconditionIfpackBase( const std::string &preconditioner_type) : preconditioner_type(preconditioner_type) { # if DEAL_II_TRILINOS_VERSION_GTE(13, 0, 0) Ifpack2::Factory factory; AssertThrow( (factory.isSupported>( preconditioner_type)), ExcTrilinosIpack2PreconditionerUnsupported(preconditioner_type)); # endif } template void PreconditionIfpackBase::initialize( const SparseMatrix &A) { Ifpack2::Factory factory; Teuchos::RCP> ifpack2Preconditioner; ifpack2Preconditioner = factory.create(preconditioner_type, A.trilinos_rcp()); ifpack2Preconditioner->setParameters(this->parameter_list); ifpack2Preconditioner->initialize(); ifpack2Preconditioner->compute(); this->preconditioner = ifpack2Preconditioner; } /* ---------------------- PreconditionIfpack ------------------------ */ template PreconditionIfpack::PreconditionIfpack( const std::string &preconditioner_type) : PreconditionIfpackBase(preconditioner_type) {} template void PreconditionIfpack::set_parameter_list( Teuchos::ParameterList ¶meter_list) { this->parameter_list.setParameters(parameter_list); } /* ---------------------- PreconditionJacobi ------------------------ */ template PreconditionJacobi::AdditionalData::AdditionalData( const double omega, const bool fix_diagonal, const double min_diagonal, const int n_sweeps) : omega(omega) , fix_diagonal(fix_diagonal) , min_diagonal(min_diagonal) , n_sweeps(n_sweeps) {} template PreconditionJacobi::PreconditionJacobi() : PreconditionIfpackBase("RELAXATION") {} template void PreconditionJacobi::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("relaxation: type", "Jacobi"); this->parameter_list.set("relaxation: damping factor", ad.omega); this->parameter_list.set("relaxation: sweeps", ad.n_sweeps); this->parameter_list.set("relaxation: fix tiny diagonal entries", ad.fix_diagonal); this->parameter_list.set("relaxation: min diagonal value", ad.min_diagonal); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionL1Jacobi ------------------------ */ template PreconditionL1Jacobi::AdditionalData::AdditionalData( const double omega, const bool fix_diagonal, const double min_diagonal, const int n_sweeps) : omega(omega) , fix_diagonal(fix_diagonal) , min_diagonal(min_diagonal) , n_sweeps(n_sweeps) {} template PreconditionL1Jacobi::PreconditionL1Jacobi() : PreconditionIfpackBase("RELAXATION") {} template void PreconditionL1Jacobi::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("relaxation: type", "Jacobi"); this->parameter_list.set("relaxation: use l1", true); this->parameter_list.set("relaxation: damping factor", ad.omega); this->parameter_list.set("relaxation: sweeps", ad.n_sweeps); this->parameter_list.set("relaxation: fix tiny diagonal entries", ad.fix_diagonal); this->parameter_list.set("relaxation: min diagonal value", ad.min_diagonal); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionL1GaussSeidel -------------------- */ template PreconditionL1GaussSeidel::AdditionalData:: AdditionalData(const double omega, const double eta, const bool fix_diagonal, const double min_diagonal, const int n_sweeps) : omega(omega) , eta(eta) , fix_diagonal(fix_diagonal) , min_diagonal(min_diagonal) , n_sweeps(n_sweeps) {} template PreconditionL1GaussSeidel::PreconditionL1GaussSeidel() : PreconditionIfpackBase("RELAXATION") {} template void PreconditionL1GaussSeidel::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("relaxation: type", "Gauss-Seidel"); this->parameter_list.set("relaxation: use l1", true); this->parameter_list.set("relaxation: damping factor", ad.omega); this->parameter_list.set("relaxation: l1 eta", ad.eta); this->parameter_list.set("relaxation: sweeps", ad.n_sweeps); this->parameter_list.set("relaxation: fix tiny diagonal entries", ad.fix_diagonal); this->parameter_list.set("relaxation: min diagonal value", ad.min_diagonal); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionSOR ------------------------ */ template PreconditionSOR::AdditionalData::AdditionalData( const double omega, const int overlap, const bool fix_diagonal, const double min_diagonal, const int n_sweeps) : omega(omega) , overlap(overlap) , fix_diagonal(fix_diagonal) , min_diagonal(min_diagonal) , n_sweeps(n_sweeps) {} template PreconditionSOR::PreconditionSOR() : PreconditionIfpackBase("SCHWARZ") {} template void PreconditionSOR::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("schwarz: subdomain solver name", "RELAXATION"); { Teuchos::ParameterList &relaxParams = this->parameter_list.sublist("schwarz: subdomain solver parameters", false); relaxParams.set("relaxation: type", "Gauss-Seidel"); relaxParams.set("relaxation: damping factor", ad.omega); relaxParams.set("relaxation: sweeps", ad.n_sweeps); relaxParams.set("relaxation: fix tiny diagonal entries", ad.fix_diagonal); relaxParams.set("relaxation: min diagonal value", ad.min_diagonal); } this->parameter_list.set("schwarz: combine mode", "ADD"); this->parameter_list.set("schwarz: overlap level", ad.overlap); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionSSOR ----------------------*/ template PreconditionSSOR::AdditionalData::AdditionalData( const double omega, const int overlap, const bool fix_diagonal, const double min_diagonal, const int n_sweeps) : omega(omega) , overlap(overlap) , fix_diagonal(fix_diagonal) , min_diagonal(min_diagonal) , n_sweeps(n_sweeps) {} template PreconditionSSOR::PreconditionSSOR() : PreconditionIfpackBase("SCHWARZ") {} template void PreconditionSSOR::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("schwarz: subdomain solver name", "RELAXATION"); { Teuchos::ParameterList &relaxParams = this->parameter_list.sublist("schwarz: subdomain solver parameters", false); relaxParams.set("relaxation: type", "Symmetric Gauss-Seidel"); relaxParams.set("relaxation: damping factor", ad.omega); relaxParams.set("relaxation: sweeps", ad.n_sweeps); relaxParams.set("relaxation: fix tiny diagonal entries", ad.fix_diagonal); relaxParams.set("relaxation: min diagonal value", ad.min_diagonal); } this->parameter_list.set("schwarz: combine mode", "ADD"); this->parameter_list.set("schwarz: overlap level", ad.overlap); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionBlockJacobi ----------------------*/ template PreconditionBlockJacobi::AdditionalData:: AdditionalData(const int n_local_parts, const double omega, const int block_overlap, const int n_sweeps) : n_local_parts(n_local_parts) , omega(omega) , block_overlap(block_overlap) , n_sweeps(n_sweeps) {} template PreconditionBlockJacobi::PreconditionBlockJacobi() : PreconditionIfpackBase("BLOCK_RELAXATION") {} template void PreconditionBlockJacobi::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("relaxation: type", "Jacobi"); this->parameter_list.set("relaxation: damping factor", ad.omega); this->parameter_list.set("relaxation: sweeps", ad.n_sweeps); this->parameter_list.set("partitioner: local parts", ad.n_local_parts); this->parameter_list.set("partitioner: overlap", ad.block_overlap); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionBlockSOR ----------------------*/ template PreconditionBlockSOR::AdditionalData::AdditionalData( const int n_local_parts, const double omega, const int overlap, const int n_sweeps) : n_local_parts(n_local_parts) , omega(omega) , overlap(overlap) , n_sweeps(n_sweeps) {} template PreconditionBlockSOR::PreconditionBlockSOR() : PreconditionIfpackBase("SCHWARZ") {} template void PreconditionBlockSOR::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("schwarz: subdomain solver name", "BLOCK_RELAXATION"); { Teuchos::ParameterList &relaxParams = this->parameter_list.sublist("schwarz: subdomain solver parameters", false); relaxParams.set("relaxation: type", "Gauss-Seidel"); relaxParams.set("relaxation: damping factor", ad.omega); relaxParams.set("relaxation: sweeps", ad.n_sweeps); relaxParams.set("partitioner: local parts", ad.n_local_parts); } this->parameter_list.set("schwarz: combine mode", "ADD"); this->parameter_list.set("schwarz: overlap level", ad.overlap); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionBlockSSOR ----------------------*/ template PreconditionBlockSSOR::AdditionalData::AdditionalData( const int n_local_parts, const double omega, const int overlap, const int n_sweeps) : n_local_parts(n_local_parts) , omega(omega) , overlap(overlap) , n_sweeps(n_sweeps) {} template PreconditionBlockSSOR::PreconditionBlockSSOR() : PreconditionIfpackBase("SCHWARZ") {} template void PreconditionBlockSSOR::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("schwarz: subdomain solver name", "BLOCK_RELAXATION"); { Teuchos::ParameterList &relaxParams = this->parameter_list.sublist("schwarz: subdomain solver parameters", false); relaxParams.set("relaxation: type", "Symmetric Gauss-Seidel"); relaxParams.set("relaxation: damping factor", ad.omega); relaxParams.set("relaxation: sweeps", ad.n_sweeps); relaxParams.set("partitioner: local parts", ad.n_local_parts); } this->parameter_list.set("schwarz: combine mode", "ADD"); this->parameter_list.set("schwarz: overlap level", ad.overlap); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionChebyshev ----------------------*/ template PreconditionChebyshev::AdditionalData::AdditionalData( const int degree, const double max_eigenvalue, const double eigenvalue_ratio, const double min_eigenvalue, const double min_diagonal, const bool nonzero_starting) : degree(degree) , max_eigenvalue(max_eigenvalue) , min_eigenvalue(min_eigenvalue) , eigenvalue_ratio(eigenvalue_ratio) , min_diagonal(min_diagonal) , nonzero_starting(nonzero_starting) {} template PreconditionChebyshev::PreconditionChebyshev() : PreconditionIfpackBase("CHEBYSHEV") {} template void PreconditionChebyshev::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("chebyshev: degree", ad.degree); this->parameter_list.set("chebyshev: max eigenvalue", ad.max_eigenvalue); this->parameter_list.set("chebyshev: min eigenvalue", ad.min_eigenvalue); this->parameter_list.set("chebyshev: ratio eigenvalue", ad.eigenvalue_ratio); this->parameter_list.set("chebyshev: min diagonal value", ad.min_diagonal); this->parameter_list.set("chebyshev: zero starting solution", !ad.nonzero_starting); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionILU ----------------------*/ template PreconditionILU::AdditionalData::AdditionalData( const int ilu_fill, const double ilu_atol, const double ilu_rtol, const int overlap) : ilu_fill(ilu_fill) , ilu_atol(ilu_atol) , ilu_rtol(ilu_rtol) , overlap(overlap) {} template PreconditionILU::PreconditionILU() : PreconditionIfpackBase("SCHWARZ") {} template void PreconditionILU::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("schwarz: subdomain solver name", "RILUK"); { Teuchos::ParameterList &rilukParams = this->parameter_list.sublist("schwarz: subdomain solver parameters", false); rilukParams.set("fact: iluk level-of-fill", ad.ilu_fill); rilukParams.set("fact: absolute threshold", ad.ilu_atol); rilukParams.set("fact: relative threshold", ad.ilu_rtol); } this->parameter_list.set("schwarz: combine mode", "ADD"); this->parameter_list.set("schwarz: overlap level", ad.overlap); PreconditionIfpackBase::initialize(A); } /* ---------------------- PreconditionILUT ----------------------*/ template PreconditionILUT::AdditionalData::AdditionalData( const double ilut_drop, const double ilut_fill, const double ilut_atol, const double ilut_rtol, const int overlap) : ilut_drop(ilut_drop) , ilut_fill(ilut_fill) , ilut_atol(ilut_atol) , ilut_rtol(ilut_rtol) , overlap(overlap) {} template PreconditionILUT::PreconditionILUT() : PreconditionIfpackBase("SCHWARZ") {} template void PreconditionILUT::initialize( const SparseMatrix &A, const AdditionalData &ad) { this->parameter_list.set("schwarz: subdomain solver name", "ILUT"); { Teuchos::ParameterList &ilutParams = this->parameter_list.sublist("schwarz: subdomain solver parameters", false); ilutParams.set("fact: drop tolerance", ad.ilut_drop); ilutParams.set("fact: ilut level-of-fill", ad.ilut_fill); ilutParams.set("fact: absolute threshold", ad.ilut_atol); ilutParams.set("fact: relative threshold", ad.ilut_rtol); } this->parameter_list.set("schwarz: combine mode", "ADD"); this->parameter_list.set("schwarz: overlap level", ad.overlap); PreconditionIfpackBase::initialize(A); } } // namespace TpetraWrappers } // namespace LinearAlgebra DEAL_II_NAMESPACE_CLOSE # endif // DEAL_II_TRILINOS_WITH_IFPACK2 #else // Make sure the scripts that create the C++20 module input files have // something to latch on if the preprocessor #ifdef above would // otherwise lead to an empty content of the file. DEAL_II_NAMESPACE_OPEN DEAL_II_NAMESPACE_CLOSE #endif // DEAL_II_TRILINOS_WITH_TPETRA #endif