.gitlab-ci.yml

 ---
 # Install external dependencies
-before_script:
-  - duneci-install-module https://git.imp.fu-berlin.de/agnumpde/dune-matrix-vector.git
 
-dune:git  clang  C++17:
-  image: registry.dune-project.org/docker/ci/dune:git-debian-10-clang-7-libcpp-17
+# For release-based jobs, we use corresponding images,
+# that already contain all core and staging dependencies.
+.release_based_job:
+  before_script:
+    - duneci-install-module https://gitlab.dune-project.org/fufem/dune-matrix-vector.git
+
+# For branch-based-based jobs, we need to install all dependencies manually.
+.branch_base_job:
+  before_script:
+    - . /duneci/bin/duneci-init-job
+    - duneci-install-module https://gitlab.dune-project.org/core/dune-common.git
+    - duneci-install-module https://gitlab.dune-project.org/core/dune-geometry.git
+    - duneci-install-module https://gitlab.dune-project.org/core/dune-localfunctions.git
+    - duneci-install-module https://gitlab.dune-project.org/staging/dune-uggrid.git
+    - duneci-install-module https://gitlab.dune-project.org/core/dune-grid.git
+    - duneci-install-module https://gitlab.dune-project.org/core/dune-istl.git
+    - duneci-install-module https://gitlab.dune-project.org/fufem/dune-matrix-vector.git
+
+# The 2.9 release is the one in Debian 12 ('bookworm', 'stable' at the time of writing)
+dune:2.9 debian-11 gcc-10 C++20:
+  extends: .release_based_job
+  variables:
+    DUNECI_BRANCH: releases/2.9
+  image: registry.dune-project.org/docker/ci/dune:2.9-debian-11-gcc-10-20
   script: duneci-standard-test
 
-dune:git  gcc-9  C++20:
-  image: registry.dune-project.org/docker/ci/dune:git-debian-11-gcc-9-20
+# The 2.10 release is the one in Debian 13 ('trixie', 'testing' at the time of writing)
+# To test against 2.10 we need an image with the corresponding version of the core modules.
+# Unfortunately, there is no 2.10 image with a recent enough compiler.
+dune:2.10 debian-11 gcc-10  C++20:
+  extends: .release_based_job
+  variables:
+    DUNECI_BRANCH: releases/2.10
+  image: registry.dune-project.org/docker/ci/dune:2.10-debian-11-gcc-10-20
   script: duneci-standard-test
 
-dune:git  gcc-8  C++17:
-  image: registry.dune-project.org/docker/ci/dune:git-debian-10-gcc-8-17
+# Also test with the current development branch
+dune:git debian-11 clang-13  C++20:
+  extends: .branch_base_job
+#  image: registry.dune-project.org/docker/ci/dune:git-debian-11-clang-13-20
+  image: registry.dune-project.org/docker/ci/debian:11
+  variables:
+    DUNECI_TOOLCHAIN: clang-13-20
   script: duneci-standard-test
+
+dune:git debian-11 gcc-10  C++20:
+  extends: .branch_base_job
+#  image: registry.dune-project.org/docker/ci/dune:git-debian-11-gcc-10-20
+  image: registry.dune-project.org/docker/ci/debian:11
+  variables:
+    DUNECI_TOOLCHAIN: gcc-10-20
+  script: duneci-standard-test
+
+# Check for spelling mistakes in text
+code-spelling-check:
+  stage: .pre
+  # Avoid the global 'before_script'
+  before_script: ""
+  image: registry.dune-project.org/docker/ci/debian:11
+  script:
+  - codespell
+    --ignore-words-list foo,bar

CHANGELOG.md

-# Master (will become release 2.9)
+# Master (will become release 2.11)
+
+- ...
+
+# Release 2.10
+
+- Deprecate the file `tuplevector.hh`.  An equivalent file exists in `dune-common`
+  since 2016. Please use that from now on.
+
+- `UMFPackSolver` accepts each correctly formed blocked matrix. The user has to make sure that the vector types of `x` and `rhs` are compatible to the matrix.
+  The main advantage is that it is now possible to use `MultiTypeBlockMatrix`.
+
+- A new solver `ProximalNewtonSolver` is added which solves non-smooth minimization problems.
+
+# Release 2.9
 
 - The internal matrix of the`EnergyNorm` can now be accessed by `getMatrix()`.
 
+- The default `BitVectorType` of the class `IterationStep` is now
+  `Solvers::DefaultBitVector_t<VectorType>` rather than `Dune::BitSetVector`.
+  This should do the right thing in more situations, while being fully
+  backward-compatible.
+
+- `codespell` spell checker is now active for automated spell checking in the Gitlab CI. 
+  To exclude false positives add the words to the `--ignore-words-list` in `.gitlab-ci.yml`.
+
 # Release 2.8
 
 - `UMFPackSolver` can now handle matrices and vectors with scalar entries.

CMakeLists.txt

-cmake_minimum_required(VERSION 2.8.6)
+if(dune-common_VERSION VERSION_GREATER_EQUAL 2.10.0)
+    cmake_minimum_required(VERSION 3.16)
+else()
+    cmake_minimum_required(VERSION 3.13)
+endif()
 project(dune-solvers CXX)
 
 if(NOT (dune-common_DIR OR dune-common_ROOT OR
@@ -22,9 +26,17 @@ dune_project()
 find_package(SuiteSparse OPTIONAL_COMPONENTS UMFPACK)
 include(AddSuiteSparseFlags)
 
+# Create library target and export it as Dune::Solvers
+dune_add_library(dunesolvers EXPORT_NAME Solvers LINK_LIBRARIES ${DUNE_LIBS})
+
+dune_register_package_flags(LIBRARIES dunesolvers)
+
 add_subdirectory("dune")
 add_subdirectory("doc")
 add_subdirectory("cmake/modules")
 
-# finalize the dune project, e.g. generating config.h etc.
-finalize_dune_project(GENERATE_CONFIG_H_CMAKE)
+if(dune-common_VERSION VERSION_GREATER_EQUAL 2.10.0)
+    finalize_dune_project()
+else()
+    finalize_dune_project(GENERATE_CONFIG_H_CMAKE)
+endif()

cmake/modules/FindIPOpt.cmake

@@ -9,12 +9,12 @@ find_library(DL_LIBRARY dl)
 find_path(IPOPT_INCLUDE_DIR
   NAMES "IpNLP.hpp"
   PATHS ${IPOPT_ROOT}
-  PATH_SUFFIXES "include" "include/coin"
+  PATH_SUFFIXES "include" "include/coin" "include/coin-or"
   NO_DEFAULT_PATH
 )
 find_path(IPOPT_INCLUDE_DIR
   NAMES "IpNLP.hpp"
-  PATH_SUFFIXES "include" "include/coin"
+  PATH_SUFFIXES "include" "include/coin" "include/coin-or"
 )
 
 find_library(IPOPT_LIBRARY
@@ -40,7 +40,7 @@ find_library(HSL_LIBRARY
 
 find_package_handle_standard_args(hsl DEFAULT_MSG HSL_LIBRARY)
 find_package_handle_standard_args(dl DEFAULT_MSG DL_LIBRARY)
-find_package_handle_standard_args(Ipopt DEFAULT_MSG IPOPT_INCLUDE_DIR IPOPT_LIBRARY)
+find_package_handle_standard_args(IPOpt DEFAULT_MSG IPOPT_INCLUDE_DIR IPOPT_LIBRARY)
 
 if(IPOPT_FOUND)
     set(HAVE_IPOPT ENABLE_IPOPT)

doc/LOWRANKBRANCH-BACKPORT-CHANGES

@@ -21,7 +21,7 @@ CHANGES REQUIRING CODE ADAPTATION
 ---------------------------------------------------------------------------------------
 
 
-CHANGES POSSIBLY AFFECTING PERFOMANCE (INCLUDING BUGFIXES)
+CHANGES POSSIBLY AFFECTING PERFORMANCE (INCLUDING BUGFIXES)
 ----------------------------------------------------------
 ----------------------------------------------------------
 

dune.module

@@ -4,7 +4,7 @@
 
 #Name of the module
 Module: dune-solvers
-Version: 2.9-git
+Version: 2.11-git
 Maintainer: oliver.sander@tu-dresden.de
 #depending on
 Depends: dune-common dune-grid dune-istl dune-localfunctions dune-matrix-vector

dune/solvers/CMakeLists.txt

-dune_add_library("dunesolvers"
-    iterationsteps/blockgssteps.cc
-    solvers/criterion.cc)
-
-dune_register_package_flags(LIBRARIES dunesolvers)
-
 add_subdirectory("common")
 add_subdirectory("iterationsteps")
 add_subdirectory("norms")
@@ -12,6 +6,10 @@ add_subdirectory("solvers")
 add_subdirectory("test")
 add_subdirectory("transferoperators")
 
+target_sources(dunesolvers PRIVATE
+    iterationsteps/blockgssteps.cc
+    solvers/criterion.cc)
+
 install(FILES
     computeenergy.hh
     DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/solvers)

dune/solvers/common/CMakeLists.txt

 install(FILES
-    arithmetic.hh
     boxconstraint.hh
     canignore.hh
     copyorreference.hh

dune/solvers/common/arithmetic.hh

-// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
-// vi: set et ts=8 sw=4 sts=4:
-#ifndef ARITHMETIC_HH
-#define ARITHMETIC_HH
-
-#warning arithmetic.hh is deprecated, please use dune-matrix-vector instead!
-
-#include <dune/matrix-vector/axpy.hh>
-#include <dune/matrix-vector/axy.hh>
-#include <dune/matrix-vector/crossproduct.hh>
-#include <dune/matrix-vector/matrixtraits.hh>
-#include <dune/matrix-vector/promote.hh>
-#include <dune/matrix-vector/scalartraits.hh>
-#include <dune/matrix-vector/transpose.hh>
-
-namespace Arithmetic
-{
-    using Dune::MatrixVector::Promote;
-    using Dune::MatrixVector::ScalarTraits;
-    using Dune::MatrixVector::MatrixTraits;
-    using Dune::MatrixVector::Transposed;
-    using Dune::MatrixVector::addProduct;
-    using Dune::MatrixVector::subtractProduct;
-    using Dune::MatrixVector::crossProduct;
-    using Dune::MatrixVector::transpose;
-    using Dune::MatrixVector::Axy;
-    using Dune::MatrixVector::bmAxy;
-}
-
-#endif

dune/solvers/common/defaultbitvector.hh

@@ -10,7 +10,7 @@
 #include <dune/istl/bvector.hh>
 #include <dune/istl/multitypeblockvector.hh>
 
-#include <dune/solvers/common/tuplevector.hh>
+#include <dune/common/tuplevector.hh>
 
 namespace Dune {
 namespace Solvers {

dune/solvers/common/genericvectortools.hh

@@ -48,7 +48,7 @@ struct GenericVector
         Dune::MatrixVector::Generic::readBinary(s, v);
     }
 
-    //! Resize vector recursivly to size of given vector/matrix
+    //! Resize vector recursively to size of given vector/matrix
     template <class VectorTypeA, class VectorTypeB>
     [[deprecated("Please use Dune::MatrixVector::resize instead.")]]
     static void resize(VectorTypeA& a, const VectorTypeB& b)
@@ -56,7 +56,7 @@ struct GenericVector
         Dune::MatrixVector::resize(a, b);
     }
 
-    //! Set vector to zero at indices that are true in bitvector recursivly
+    //! Set vector to zero at indices that are true in bitvector recursively
     template <class VectorType, class BitVectorType>
     [[deprecated("Please use Dune::MatrixVector::Generic::truncate instead.")]]
     static void truncate(VectorType& v, const BitVectorType& tr)
@@ -183,7 +183,7 @@ struct GenericVector
 struct GenericMatrix
 {
 
-    //! Set matrix to zero at indices that are true in bitvector recursivly
+    //! Set matrix to zero at indices that are true in bitvector recursively
     template <class MatrixType, class BitVectorTypeR, class BitVectorTypeC>
     static void truncate(MatrixType& mat, const BitVectorTypeR& trows, const BitVectorTypeC& tcols, bool setTruncatedDiagonalOne)
     {

dune/solvers/common/numproc.hh

@@ -16,7 +16,7 @@ public:
   /** \brief Different levels of verbosity */
   enum VerbosityMode {QUIET, REDUCED, FULL};
 
-  /** \brief Constructor, per defaut uses FULL. */
+  /** \brief Constructor, per default uses FULL. */
   NumProc(VerbosityMode verbosity = FULL)
     : verbosity_(verbosity)
   {}

dune/solvers/common/permutationmanager.hh

@@ -15,7 +15,7 @@
 //! Idea of implementation: define an ordering for the nodes (with respect to the axis of anisotropy)
 //! and then use a merge sort algorithm to renumerate the nodes along the lines which are parallel to this axis.
 //! to do so, we introduce a 'NodeList' class.
-//! everything is handeled by the PermutationManager
+//! everything is handled by the PermutationManager
 
 
 // type of nodes:
@@ -151,7 +151,7 @@ public:
 
 
 
-// the information about the axis of anisotropy is in NodeList, since this list contains a methode "less_equal", which describes the ordering of the nodes.
+// the information about the axis of anisotropy is in NodeList, since this list contains a method "less_equal", which describes the ordering of the nodes.
 // this ordering depends on the axis of anisotropy
 template< class GridViewImp >
 class PermutationManager{
@@ -430,9 +430,9 @@ public:
 
       for( int i = 0; i < node_list_.size(); ++i )
        {
-	 std::cout << "Original node[" << get_inverse_permuted_index( i ) << "] = (" << node_list_[i].get_global_coordinate() << ") recieved permuted index " << i << std::endl;
+	 std::cout << "Original node[" << get_inverse_permuted_index( i ) << "] = (" << node_list_[i].get_global_coordinate() << ") received permuted index " << i << std::endl;
          // alternative:
-	 //std::cout << "Original node[" << get_inverse_permuted_index( i ) << "] = (" << original_node_list_[get_inverse_permuted_index( i )].get_global_coordinate() << ") recieved permuted index " << i << std::endl;
+	 //std::cout << "Original node[" << get_inverse_permuted_index( i ) << "] = (" << original_node_list_[get_inverse_permuted_index( i )].get_global_coordinate() << ") received permuted index " << i << std::endl;
        }
 
 #if 0

dune/solvers/common/staticmatrixtools.hh

@@ -16,8 +16,6 @@
 #include <dune/matrix-vector/scalartraits.hh>
 #include <dune/matrix-vector/transformmatrix.hh>
 
-#include "arithmetic.hh"
-
 namespace StaticMatrix
 {
         // type promotion (smallest matrix that can hold the sum of two matrices *******************

dune/solvers/common/tuplevector.hh

@@ -3,9 +3,9 @@
 #ifndef DUNE_SOLVERS_COMMON_TUPLEVECTOR_HH
 #define DUNE_SOLVERS_COMMON_TUPLEVECTOR_HH
 
-#include <tuple>
+#warning This file is deprecated!  Use tuplevector.hh from the dune-common module instead!
 
-#include <dune/common/indices.hh>
+#include <dune/common/tuplevector.hh>
 
 namespace Dune
 {
@@ -16,38 +16,7 @@ namespace Solvers
    * \brief A std::tuple that allows access to its element via operator[]
    */
   template<class... T>
-  class TupleVector : public std::tuple<T...>
-  {
-    using Base = std::tuple<T...>;
-
-  public:
-
-    // inherit all constructors from std::tuple
-    using Base::Base;
-
-    /** \brief Const access to the tuple elements */
-    template<std::size_t i>
-    auto operator[](const Dune::index_constant<i>&) const
-      ->decltype(std::get<i>(*this))
-    {
-      return std::get<i>(*this);
-    }
-
-    /** \brief Non-const access to the tuple elements */
-    template<std::size_t i>
-    auto operator[](const Dune::index_constant<i>&)
-      ->decltype(std::get<i>(*this))
-    {
-      return std::get<i>(*this);
-    }
-
-    /** \brief Number of elements of the tuple */
-    static constexpr std::size_t size()
-    {
-      return std::tuple_size<Base>::value;
-    }
-
-  };
+  using TupleVector = Dune::TupleVector<T...>;
 
 }  // namespace Functions
 

dune/solvers/iterationsteps/blockgssteps.hh

@@ -3,6 +3,7 @@
 
 #include <cassert>
 #include <functional>
+#include <type_traits>
 
 #include <dune/common/parametertree.hh>
 
@@ -181,7 +182,7 @@ template <class LinearSolver>
 auto truncateSymmetrically(LinearSolver&& linearSolver) {
   return [linearSolver = std::move(linearSolver) ](
       const auto& m, const auto& b, const auto& ignore) {
-    using Return = typename std::result_of<LinearSolver(decltype(m), decltype(b))>::type;
+    using Return = std::invoke_result_t<LinearSolver, decltype(m), decltype(b)>;
     if (ignore.all())
       return Return(0);
 

dune/solvers/iterationsteps/iterationstep.hh

@@ -6,8 +6,8 @@
 #include <vector>
 #include <string>
 
-#include <dune/common/bitsetvector.hh>
 #include <dune/solvers/common/canignore.hh>
+#include <dune/solvers/common/defaultbitvector.hh>
 #include <dune/solvers/common/numproc.hh>
 
 namespace Dune {
@@ -15,7 +15,7 @@ namespace Dune {
 namespace Solvers {
 
     //! Base class for iteration steps being called by an iterative solver
-template<class VectorType, class BitVectorType = Dune::BitSetVector<VectorType::block_type::dimension> >
+template<class VectorType, class BitVectorType = Solvers::DefaultBitVector_t<VectorType> >
 class IterationStep : virtual public NumProc, public CanIgnore<BitVectorType>
     {
     public:

dune/solvers/iterationsteps/linegsstep.cc

@@ -23,7 +23,7 @@ void LineGSStep<MatrixType, DiscFuncType, BitVectorType >::iterate()
 
         const int current_block_size = blockStructure_[b_num].size();
 
-        //! compute and save the residuals for the curent block:
+        //! compute and save the residuals for the current block:
         // determine the (permuted) residuals r[p(i)],..., r[p(i+current_block_size-1)]
         // this means that we determine the residuals for the current block
         DiscFuncType permuted_r_i(current_block_size);

dune/solvers/iterationsteps/minimalpolynomialextrapolationstep.hh

@@ -44,7 +44,7 @@ public:
     virtual void iterate();
 
     /** \brief To be called before starting to iterate
-       \note This calls the preprocess method for the dependant iteration step class, too!
+       \note This calls the preprocess method for the dependent iteration step class, too!
      */
     virtual void preprocess();
 

dune/solvers/iterationsteps/multigridstep.cc

@@ -73,17 +73,14 @@ void MultigridStep<MatrixType, VectorType, BitVectorType>::preprocess()
 
     xHierarchy_.resize(numLevels());
     rhsHierarchy_.resize(numLevels());
-    matrixHierarchy_.resize(numLevels());
     ignoreNodesHierarchy_.resize(numLevels());
 
-    for (int i=0; i<int(matrixHierarchy_.size())-1; i++)
+    for (int i=0; i<int(xHierarchy_.size())-1; i++)
     {
-        matrixHierarchy_[i].reset();
         xHierarchy_[i].reset();
         ignoreNodesHierarchy_[i] = NULL;
     }
 
-    matrixHierarchy_.back() = this->mat_;
     xHierarchy_.back()      = Dune::stackobject_to_shared_ptr(*(this->x_));
     rhsHierarchy_.back()    = *(this->rhs_);
 
@@ -117,22 +114,35 @@ void MultigridStep<MatrixType, VectorType, BitVectorType>::preprocess()
     // /////////////////////////////////////////////////////
     //   Assemble the complete hierarchy of matrices
     // /////////////////////////////////////////////////////
-    for (int i=this->numLevels()-2; i>=0; i--)
+    if (not matrixHierarchyManuallySet_)
     {
-        this->matrixHierarchy_[i] = std::make_shared<MatrixType>();
-        this->xHierarchy_[i] = std::make_shared<VectorType>();
+        matrixHierarchy_.resize(numLevels());
+        for (int i=0; i<int(matrixHierarchy_.size())-1; i++)
+            matrixHierarchy_[i].reset();
+        matrixHierarchy_.back() = this->mat_;
+        for (int i=this->numLevels()-2; i>=0; i--)
+        {
+            this->matrixHierarchy_[i] = std::make_shared<MatrixType>();
 
-        // Compute which entries are present in the (sparse) coarse grid stiffness
-        // matrices.
-        this->mgTransfer_[i]->galerkinRestrictSetOccupation(*this->matrixHierarchy_[i+1], *std::const_pointer_cast<MatrixType>(this->matrixHierarchy_[i]));
+            // Compute which entries are present in the (sparse) coarse grid stiffness
+            // matrices.
+            this->mgTransfer_[i]->galerkinRestrictSetOccupation(*this->matrixHierarchy_[i+1], *std::const_pointer_cast<MatrixType>(this->matrixHierarchy_[i]));
+
+            // setup matrix
+            this->mgTransfer_[i]->galerkinRestrict(*this->matrixHierarchy_[i+1], *std::const_pointer_cast<MatrixType>(this->matrixHierarchy_[i]));
+        }
+        matrixHierarchyManuallySet_ = false;
+    }
 
-        // setup matrix
-        this->mgTransfer_[i]->galerkinRestrict(*this->matrixHierarchy_[i+1], *std::const_pointer_cast<MatrixType>(this->matrixHierarchy_[i]));
+    for (int i=this->numLevels()-2; i>=0; i--)
+    {
+        this->xHierarchy_[i] = std::make_shared<VectorType>();
 
         // Set solution vector sizes for the lower levels
         MatrixVector::resize(*(this->xHierarchy_[i]),*this->matrixHierarchy_[i]);
     }
 
+
     // /////////////////////////////////////////////////////
     //   Setup dirichlet bitfields
     // /////////////////////////////////////////////////////