defaultmatrixvectortraits.hh

Go to the documentation of this file.

// 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_DEFAULT_MATRIX_VECTOR_TRAITS_HH
#define DUNE_ISTL_DEFAULT_MATRIX_VECTOR_TRAITS_HH
 
#include <memory>
 
#include <dune/common/concepts/number.hh>
 
namespace Dune::Experimental
{
  template<class, class, class> class BCRSMatrix;
  template<class, class, class> class Matrix;
} // end namespace Dune::Experimental
 
namespace Dune {
 
// forward declarations
template<class, class> class BCRSMatrix;
template<class, class> class BDMatrix;
template<class, class> class BlockVector;
template<class, class> class BTDMatrix;
template<class, int> class DiagonalMatrix;
template<class> class DynamicMatrix;
template<class, class> class DynamicVector;
template<class, int, int> class FieldMatrix;
template<class, int> class FieldVector;
template<class, class> class Matrix;
template<class, class...> class MultiTypeBlockMatrix;
template<class...> class MultiTypeBlockVector;
template<class, int> class ScaledIdentityMatrix;
 
template<class Matrix>
struct DefaultMatrixVectorTraits;
 
template<class LO>
  requires requires{ typename LO::domain_type; typename LO::range_type; }
struct DefaultMatrixVectorTraits<LO>
{
  using domain_type = typename LO::domain_type;
  using range_type = typename LO::range_type;
};
 
template<Concept::Number N>
struct DefaultMatrixVectorTraits<N>
{
  using domain_type = N;
  using range_type  = N;
};
 
template<class T, int n, int m>
struct DefaultMatrixVectorTraits<FieldMatrix<T,n,m>>
{
  using domain_type = FieldVector<typename DefaultMatrixVectorTraits<T>::domain_type,m>;
  using range_type  = FieldVector<typename DefaultMatrixVectorTraits<T>::range_type,n>;
};
 
template<class T>
struct DefaultMatrixVectorTraits<DynamicMatrix<T>>
{
  using domain_type = DynamicVector<typename DefaultMatrixVectorTraits<T>::domain_type,
    std::allocator<typename DefaultMatrixVectorTraits<T>::domain_type>>;
  using range_type  = DynamicVector<typename DefaultMatrixVectorTraits<T>::range_type,
    std::allocator<typename DefaultMatrixVectorTraits<T>::range_type>>;
};
 
template<class T, int n>
struct DefaultMatrixVectorTraits<DiagonalMatrix<T,n>>
{
  using domain_type = FieldVector<typename DefaultMatrixVectorTraits<T>::domain_type,n>;
  using range_type  = FieldVector<typename DefaultMatrixVectorTraits<T>::range_type,n>;
};
 
template<class T, int n>
struct DefaultMatrixVectorTraits<ScaledIdentityMatrix<T,n>>
{
  using domain_type = FieldVector<typename DefaultMatrixVectorTraits<T>::domain_type,n>;
  using range_type  = FieldVector<typename DefaultMatrixVectorTraits<T>::range_type,n>;
};
 
template<class T, class A>
struct DefaultMatrixVectorTraits<BCRSMatrix<T,A>>
{
  // In case of recursive deduction (e.g., BCRSMatrix<FieldMatrix, Allocator<FieldMatrix>>)
  // the allocator needs to be converted to the sub-block allocator type too (e.g.,
  // Allocator<FieldVector>). Note that matrix allocator is assumed to be the same as
  // the domain/range type of allocators
 
  using domain_type = BlockVector<typename DefaultMatrixVectorTraits<T>::domain_type,
    typename std::allocator_traits<A>::template rebind_alloc<typename DefaultMatrixVectorTraits<T>::domain_type>>;
  using range_type  = BlockVector<typename DefaultMatrixVectorTraits<T>::range_type,
    typename std::allocator_traits<A>::template rebind_alloc<typename DefaultMatrixVectorTraits<T>::range_type>>;
};
 
template<class T, class A>
struct DefaultMatrixVectorTraits<BDMatrix<T,A>>
  : public DefaultMatrixVectorTraits<BCRSMatrix<T,A>>
{};
 
template<class T, class A>
struct DefaultMatrixVectorTraits<BTDMatrix<T,A>>
  : public DefaultMatrixVectorTraits<BCRSMatrix<T,A>>
{};
 
template<class T, class A>
struct DefaultMatrixVectorTraits<Matrix<T,A>>
  : public DefaultMatrixVectorTraits<BCRSMatrix<T,A>>
{};
 
template<class T, class P, class A>
struct DefaultMatrixVectorTraits<Experimental::Matrix<T,P,A>>
  : public DefaultMatrixVectorTraits<BCRSMatrix<T,A>>
{};
 
 
 
template<class T, class I, class A>
struct DefaultMatrixVectorTraits<Experimental::BCRSMatrix<T,I,A>>
  : public DefaultMatrixVectorTraits<BCRSMatrix<T,A>>
{};
 
namespace Impl
{
  template <class V>
  struct MultiTypeDefaultMatrixVectorTraits;
 
  // to make the `DefaultMatrixVectorTraits` work with `MultiTypeBlockMatrix`, we need to add
  // an intermediate step for the rows, which are typically `MultiTypeBlockVector`
  template<class FirstBlock, class... Blocks>
  struct MultiTypeDefaultMatrixVectorTraits<MultiTypeBlockVector<FirstBlock, Blocks...>>
  {
    using domain_type = MultiTypeBlockVector<
      typename DefaultMatrixVectorTraits<FirstBlock>::domain_type,
      typename DefaultMatrixVectorTraits<Blocks>::domain_type...>;
    using range_type  = typename DefaultMatrixVectorTraits<FirstBlock>::range_type;
  };
 
} // end namespace Impl
 
template<class FirstRow, class... Rows>
struct DefaultMatrixVectorTraits<MultiTypeBlockMatrix<FirstRow, Rows...>>
{
  using domain_type = typename Impl::MultiTypeDefaultMatrixVectorTraits<FirstRow>::domain_type;
  using range_type  = MultiTypeBlockVector<
    typename Impl::MultiTypeDefaultMatrixVectorTraits<FirstRow>::range_type,
    typename Impl::MultiTypeDefaultMatrixVectorTraits<Rows>::range_type... >;
};
 
} // end namespace Dune
 
#endif // DUNE_ISTL_DEFAULT_MATRIX_VECTOR_TRAITS_HH