}
#endif // DEAL_II_WITH_P4EST
- template <class VectorType, typename dummy = void>
+ template <typename VectorType, typename dummy = void>
struct BlockTypeHelper
{
using type = VectorType;
};
- template <class VectorType>
+ template <typename VectorType>
struct BlockTypeHelper<VectorType,
std::enable_if_t<IsBlockVector<VectorType>::value>>
{
using type = typename VectorType::BlockType;
};
- template <class VectorType>
+ template <typename VectorType>
using BlockType = typename BlockTypeHelper<VectorType>::type;
- template <class VectorType, class DH>
+ template <typename VectorType, class DH>
void
reinit_distributed(const DH &dh, VectorType &vector)
{
- template <class VectorType, class DH>
+ template <typename VectorType, class DH>
void
reinit_ghosted(const DH & /*dh*/, VectorType & /*vector*/)
{
{
namespace AffineConstraintsImplementation
{
- template <class VectorType>
+ template <typename VectorType>
void
set_zero_all(const std::vector<types::global_dof_index> &cm,
VectorType & vec);
* @note This function does not work for MPI vectors. Use condense() with
* two vector arguments instead.
*/
- template <class VectorType>
+ template <typename VectorType>
void
condense(VectorType &vec) const;
* called in parallel, @p vec_ghosted is supposed to contain ghost elements
* while @p output should not.
*/
- template <class VectorType>
+ template <typename VectorType>
void
condense(const VectorType &vec_ghosted, VectorType &output) const;
* See the general documentation of this class for more detailed
* information.
*/
- template <class VectorType>
+ template <typename VectorType>
void
condense(SparseMatrix<number> &matrix, VectorType &vector) const;
* Same function as above, but condenses square block sparse matrices and
* vectors.
*/
- template <class BlockVectorType>
+ template <typename BlockVectorType>
void
condense(BlockSparseMatrix<number> &matrix, BlockVectorType &vector) const;
* BlockVector<tt><...></tt>, a PETSc or Trilinos vector wrapper class, or
* any other type having the same interface.
*/
- template <class VectorType>
+ template <typename VectorType>
void
set_zero(VectorType &vec) const;
/**
* Enter a single value into a result vector, obeying constraints.
*/
- template <class VectorType>
+ template <typename VectorType>
void
distribute_local_to_global(const size_type index,
const number value,
*/
template <typename ForwardIteratorVec,
typename ForwardIteratorInd,
- class VectorType>
+ typename VectorType>
void
distribute_local_to_global(ForwardIteratorVec local_vector_begin,
ForwardIteratorVec local_vector_end,
*/
template <typename ForwardIteratorVec,
typename ForwardIteratorInd,
- class VectorType>
+ typename VectorType>
void
get_dof_values(const VectorType & global_vector,
ForwardIteratorInd local_indices_begin,
* @note If this function is called with a parallel vector @p vec, then the
* vector must not contain ghost elements.
*/
- template <class VectorType>
+ template <typename VectorType>
void
distribute(VectorType &vec) const;
template <typename number>
-template <class VectorType>
+template <typename VectorType>
inline void
AffineConstraints<number>::set_zero(VectorType &vec) const
{
}
template <typename number>
-template <class VectorType>
+template <typename VectorType>
inline void
AffineConstraints<number>::distribute_local_to_global(
const size_type index,
template <typename number>
template <typename ForwardIteratorVec,
typename ForwardIteratorInd,
- class VectorType>
+ typename VectorType>
inline void
AffineConstraints<number>::distribute_local_to_global(
ForwardIteratorVec local_vector_begin,
template <typename number>
template <typename ForwardIteratorVec,
typename ForwardIteratorInd,
- class VectorType>
+ typename VectorType>
inline void
AffineConstraints<number>::get_dof_values(
const VectorType & global_vector,
template <typename number>
-template <class VectorType>
+template <typename VectorType>
void
AffineConstraints<number>::condense(const VectorType &vec_ghosted,
VectorType & vec) const
template <typename number>
-template <class VectorType>
+template <typename VectorType>
void
AffineConstraints<number>::condense(VectorType &vec) const
{
template <typename number>
-template <class VectorType>
+template <typename VectorType>
void
AffineConstraints<number>::condense(SparseMatrix<number> &uncondensed,
VectorType & vec) const
template <typename number>
-template <class BlockVectorType>
+template <typename BlockVectorType>
void
AffineConstraints<number>::condense(BlockSparseMatrix<number> &uncondensed,
BlockVectorType & vec) const
{
using size_type = types::global_dof_index;
- template <class VectorType>
+ template <typename VectorType>
void
set_zero_parallel(const std::vector<size_type> &cm,
VectorType & vec,
vec.zero_out_ghost_values();
}
- template <class VectorType>
+ template <typename VectorType>
void
set_zero_in_parallel(const std::vector<size_type> &cm,
VectorType & vec,
}
// in parallel for BlockVectors
- template <class VectorType>
+ template <typename VectorType>
void
set_zero_in_parallel(const std::vector<size_type> &cm,
VectorType & vec,
}
}
- template <class VectorType>
+ template <typename VectorType>
void
set_zero_serial(const std::vector<size_type> &cm, VectorType &vec)
{
vec(index) = 0.;
}
- template <class VectorType>
+ template <typename VectorType>
void
set_zero_all(const std::vector<size_type> &cm, VectorType &vec)
{
}
// for block vectors, simply dispatch to the individual blocks
- template <class VectorType>
+ template <typename VectorType>
void
import_vector_with_ghost_elements(
const VectorType &vec,
} // namespace internal
template <typename number>
-template <class VectorType>
+template <typename VectorType>
void
AffineConstraints<number>::distribute(VectorType &vec) const
{
* Adding Matrix-vector multiplication. Add $M*src$ on $dst$ with $M$ being
* this matrix.
*/
- template <class BlockVectorType>
+ template <typename BlockVectorType>
void
vmult_add(BlockVectorType &dst, const BlockVectorType &src) const;
* <i>dst</i> with <i>M</i> being this matrix. This function does the same
* as vmult_add() but takes the transposed matrix.
*/
- template <class BlockVectorType>
+ template <typename BlockVectorType>
void
Tvmult_add(BlockVectorType &dst, const BlockVectorType &src) const;
*
* Obviously, the matrix needs to be square for this operation.
*/
- template <class BlockVectorType>
+ template <typename BlockVectorType>
value_type
matrix_norm_square(const BlockVectorType &v) const;
/**
* Compute the matrix scalar product $\left(u,Mv\right)$.
*/
- template <class BlockVectorType>
+ template <typename BlockVectorType>
value_type
matrix_scalar_product(const BlockVectorType &u,
const BlockVectorType &v) const;
/**
* Compute the residual <i>r=b-Ax</i>. Write the residual into <tt>dst</tt>.
*/
- template <class BlockVectorType>
+ template <typename BlockVectorType>
value_type
residual(BlockVectorType & dst,
const BlockVectorType &x,
* calls to the implementations provided here under a unique name for which
* template arguments can be derived by the compiler.
*/
- template <class BlockVectorType>
+ template <typename BlockVectorType>
void
vmult_block_block(BlockVectorType &dst, const BlockVectorType &src) const;
* calls to the implementations provided here under a unique name for which
* template arguments can be derived by the compiler.
*/
- template <class BlockVectorType, class VectorType>
+ template <typename BlockVectorType, typename VectorType>
void
vmult_block_nonblock(BlockVectorType &dst, const VectorType &src) const;
* calls to the implementations provided here under a unique name for which
* template arguments can be derived by the compiler.
*/
- template <class BlockVectorType, class VectorType>
+ template <typename BlockVectorType, typename VectorType>
void
vmult_nonblock_block(VectorType &dst, const BlockVectorType &src) const;
* calls to the implementations provided here under a unique name for which
* template arguments can be derived by the compiler.
*/
- template <class VectorType>
+ template <typename VectorType>
void
vmult_nonblock_nonblock(VectorType &dst, const VectorType &src) const;
* calls to the implementations provided here under a unique name for which
* template arguments can be derived by the compiler.
*/
- template <class BlockVectorType>
+ template <typename BlockVectorType>
void
Tvmult_block_block(BlockVectorType &dst, const BlockVectorType &src) const;
* calls to the implementations provided here under a unique name for which
* template arguments can be derived by the compiler.
*/
- template <class BlockVectorType, class VectorType>
+ template <typename BlockVectorType, typename VectorType>
void
Tvmult_block_nonblock(BlockVectorType &dst, const VectorType &src) const;
* calls to the implementations provided here under a unique name for which
* template arguments can be derived by the compiler.
*/
- template <class BlockVectorType, class VectorType>
+ template <typename BlockVectorType, typename VectorType>
void
Tvmult_nonblock_block(VectorType &dst, const BlockVectorType &src) const;
* calls to the implementations provided here under a unique name for which
* template arguments can be derived by the compiler.
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tvmult_nonblock_nonblock(VectorType &dst, const VectorType &src) const;
template <class MatrixType>
-template <class BlockVectorType>
+template <typename BlockVectorType>
void
BlockMatrixBase<MatrixType>::vmult_block_block(BlockVectorType & dst,
const BlockVectorType &src) const
template <class MatrixType>
-template <class BlockVectorType, class VectorType>
+template <typename BlockVectorType, typename VectorType>
void
BlockMatrixBase<MatrixType>::vmult_nonblock_block(
VectorType & dst,
template <class MatrixType>
-template <class BlockVectorType, class VectorType>
+template <typename BlockVectorType, typename VectorType>
void
BlockMatrixBase<MatrixType>::vmult_block_nonblock(BlockVectorType & dst,
const VectorType &src) const
template <class MatrixType>
-template <class VectorType>
+template <typename VectorType>
void
BlockMatrixBase<MatrixType>::vmult_nonblock_nonblock(
VectorType & dst,
template <class MatrixType>
-template <class BlockVectorType>
+template <typename BlockVectorType>
void
BlockMatrixBase<MatrixType>::vmult_add(BlockVectorType & dst,
const BlockVectorType &src) const
template <class MatrixType>
-template <class BlockVectorType>
+template <typename BlockVectorType>
void
BlockMatrixBase<MatrixType>::Tvmult_block_block(
BlockVectorType & dst,
template <class MatrixType>
-template <class BlockVectorType, class VectorType>
+template <typename BlockVectorType, typename VectorType>
void
BlockMatrixBase<MatrixType>::Tvmult_block_nonblock(BlockVectorType & dst,
const VectorType &src) const
template <class MatrixType>
-template <class BlockVectorType, class VectorType>
+template <typename BlockVectorType, typename VectorType>
void
BlockMatrixBase<MatrixType>::Tvmult_nonblock_block(
VectorType & dst,
template <class MatrixType>
-template <class VectorType>
+template <typename VectorType>
void
BlockMatrixBase<MatrixType>::Tvmult_nonblock_nonblock(
VectorType & dst,
template <class MatrixType>
-template <class BlockVectorType>
+template <typename BlockVectorType>
void
BlockMatrixBase<MatrixType>::Tvmult_add(BlockVectorType & dst,
const BlockVectorType &src) const
template <class MatrixType>
-template <class BlockVectorType>
+template <typename BlockVectorType>
typename BlockMatrixBase<MatrixType>::value_type
BlockMatrixBase<MatrixType>::matrix_norm_square(const BlockVectorType &v) const
{
template <class MatrixType>
-template <class BlockVectorType>
+template <typename BlockVectorType>
typename BlockMatrixBase<MatrixType>::value_type
BlockMatrixBase<MatrixType>::matrix_scalar_product(
const BlockVectorType &u,
template <class MatrixType>
-template <class BlockVectorType>
+template <typename BlockVectorType>
typename BlockMatrixBase<MatrixType>::value_type
BlockMatrixBase<MatrixType>::residual(BlockVectorType & dst,
const BlockVectorType &x,
*
* All diagonal blocks must be square matrices for this operation.
*/
- template <class BlockVectorType>
+ template <typename BlockVectorType>
void
precondition_Jacobi(BlockVectorType & dst,
const BlockVectorType &src,
template <typename number>
-template <class BlockVectorType>
+template <typename BlockVectorType>
inline void
BlockSparseMatrix<number>::precondition_Jacobi(BlockVectorType & dst,
const BlockVectorType &src,
* constant and we again have that the iterator satisfies the requirements
* of a random access iterator.
*/
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
class Iterator
{
public:
* @see
* @ref GlossBlockLA "Block (linear algebra)"
*/
-template <class VectorType>
+template <typename VectorType>
class BlockVectorBase : public Subscriptor,
public ReadVector<typename VectorType::value_type>
{
/**
* Copy operator for template arguments of different types.
*/
- template <class VectorType2>
+ template <typename VectorType2>
BlockVectorBase &
operator=(const BlockVectorBase<VectorType2> &V);
* Check for equality of two block vector types. This operation is only
* allowed if the two vectors already have the same block structure.
*/
- template <class VectorType2>
+ template <typename VectorType2>
bool
operator==(const BlockVectorBase<VectorType2> &v) const;
{
namespace BlockVectorIterators
{
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>::Iterator(
const Iterator<BlockVectorType, Constness> &c)
: parent(c.parent)
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>::Iterator(
const Iterator<BlockVectorType, !Constness> &c)
: parent(c.parent)
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>::Iterator(
BlockVector & parent,
const size_type global_index,
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness> &
Iterator<BlockVectorType, Constness>::operator=(const Iterator &c)
{
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline typename Iterator<BlockVectorType, Constness>::dereference_type
Iterator<BlockVectorType, Constness>::operator*() const
{
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline typename Iterator<BlockVectorType, Constness>::dereference_type
Iterator<BlockVectorType, Constness>::operator[](
const difference_type d) const
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness> &
Iterator<BlockVectorType, Constness>::operator++()
{
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>
Iterator<BlockVectorType, Constness>::operator++(int)
{
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness> &
Iterator<BlockVectorType, Constness>::operator--()
{
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>
Iterator<BlockVectorType, Constness>::operator--(int)
{
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
Iterator<BlockVectorType, Constness>::operator==(
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
Iterator<BlockVectorType, Constness>::operator!=(
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
Iterator<BlockVectorType, Constness>::operator<(
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
Iterator<BlockVectorType, Constness>::operator<=(
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
Iterator<BlockVectorType, Constness>::operator>(
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
template <bool OtherConstness>
inline bool
Iterator<BlockVectorType, Constness>::operator>=(
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
template <bool OtherConstness>
inline typename Iterator<BlockVectorType, Constness>::difference_type
Iterator<BlockVectorType, Constness>::operator-(
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>
Iterator<BlockVectorType, Constness>::operator+(
const difference_type &d) const
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness>
Iterator<BlockVectorType, Constness>::operator-(
const difference_type &d) const
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness> &
Iterator<BlockVectorType, Constness>::operator+=(const difference_type &d)
{
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
inline Iterator<BlockVectorType, Constness> &
Iterator<BlockVectorType, Constness>::operator-=(const difference_type &d)
{
}
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
Iterator<BlockVectorType, Constness>::Iterator(BlockVector & parent,
const size_type global_index)
: parent(&parent)
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
void
Iterator<BlockVectorType, Constness>::move_forward()
{
- template <class BlockVectorType, bool Constness>
+ template <typename BlockVectorType, bool Constness>
void
Iterator<BlockVectorType, Constness>::move_backward()
{
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::size_type
BlockVectorBase<VectorType>::size() const
{
-template <class VectorType>
+template <typename VectorType>
inline std::size_t
BlockVectorBase<VectorType>::locally_owned_size() const
{
-template <class VectorType>
+template <typename VectorType>
inline IndexSet
BlockVectorBase<VectorType>::locally_owned_elements() const
{
-template <class VectorType>
+template <typename VectorType>
inline unsigned int
BlockVectorBase<VectorType>::n_blocks() const
{
}
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::BlockType &
BlockVectorBase<VectorType>::block(const unsigned int i)
{
-template <class VectorType>
+template <typename VectorType>
inline const typename BlockVectorBase<VectorType>::BlockType &
BlockVectorBase<VectorType>::block(const unsigned int i) const
{
-template <class VectorType>
+template <typename VectorType>
inline const BlockIndices &
BlockVectorBase<VectorType>::get_block_indices() const
{
}
-template <class VectorType>
+template <typename VectorType>
inline void
BlockVectorBase<VectorType>::collect_sizes()
{
-template <class VectorType>
+template <typename VectorType>
inline void
BlockVectorBase<VectorType>::compress(VectorOperation::values operation)
{
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::iterator
BlockVectorBase<VectorType>::begin()
{
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::const_iterator
BlockVectorBase<VectorType>::begin() const
{
}
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::iterator
BlockVectorBase<VectorType>::end()
{
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::const_iterator
BlockVectorBase<VectorType>::end() const
{
}
-template <class VectorType>
+template <typename VectorType>
inline bool
BlockVectorBase<VectorType>::in_local_range(const size_type global_index) const
{
}
-template <class VectorType>
+template <typename VectorType>
bool
BlockVectorBase<VectorType>::all_zero() const
{
-template <class VectorType>
+template <typename VectorType>
bool
BlockVectorBase<VectorType>::is_non_negative() const
{
-template <class VectorType>
+template <typename VectorType>
typename BlockVectorBase<VectorType>::value_type
BlockVectorBase<VectorType>::operator*(
const BlockVectorBase<VectorType> &v) const
}
-template <class VectorType>
+template <typename VectorType>
typename BlockVectorBase<VectorType>::real_type
BlockVectorBase<VectorType>::norm_sqr() const
{
-template <class VectorType>
+template <typename VectorType>
typename BlockVectorBase<VectorType>::value_type
BlockVectorBase<VectorType>::mean_value() const
{
-template <class VectorType>
+template <typename VectorType>
typename BlockVectorBase<VectorType>::real_type
BlockVectorBase<VectorType>::l1_norm() const
{
-template <class VectorType>
+template <typename VectorType>
typename BlockVectorBase<VectorType>::real_type
BlockVectorBase<VectorType>::l2_norm() const
{
-template <class VectorType>
+template <typename VectorType>
typename BlockVectorBase<VectorType>::real_type
BlockVectorBase<VectorType>::linfty_norm() const
{
-template <class VectorType>
+template <typename VectorType>
typename BlockVectorBase<VectorType>::value_type
BlockVectorBase<VectorType>::add_and_dot(
const typename BlockVectorBase<VectorType>::value_type a,
-template <class VectorType>
+template <typename VectorType>
BlockVectorBase<VectorType> &
BlockVectorBase<VectorType>::operator+=(const BlockVectorBase<VectorType> &v)
{
-template <class VectorType>
+template <typename VectorType>
BlockVectorBase<VectorType> &
BlockVectorBase<VectorType>::operator-=(const BlockVectorBase<VectorType> &v)
{
-template <class VectorType>
+template <typename VectorType>
template <typename Number>
inline void
BlockVectorBase<VectorType>::add(const std::vector<size_type> &indices,
-template <class VectorType>
+template <typename VectorType>
template <typename Number>
inline void
BlockVectorBase<VectorType>::add(const std::vector<size_type> &indices,
-template <class VectorType>
+template <typename VectorType>
template <typename Number>
inline void
BlockVectorBase<VectorType>::add(const size_type n_indices,
-template <class VectorType>
+template <typename VectorType>
void
BlockVectorBase<VectorType>::add(const value_type a)
{
-template <class VectorType>
+template <typename VectorType>
void
BlockVectorBase<VectorType>::add(const value_type a,
const BlockVectorBase<VectorType> &v)
-template <class VectorType>
+template <typename VectorType>
void
BlockVectorBase<VectorType>::add(const value_type a,
const BlockVectorBase<VectorType> &v,
-template <class VectorType>
+template <typename VectorType>
void
BlockVectorBase<VectorType>::sadd(const value_type x,
const BlockVectorBase<VectorType> &v)
-template <class VectorType>
+template <typename VectorType>
void
BlockVectorBase<VectorType>::sadd(const value_type x,
const value_type a,
-template <class VectorType>
+template <typename VectorType>
void
BlockVectorBase<VectorType>::sadd(const value_type x,
const value_type a,
-template <class VectorType>
+template <typename VectorType>
void
BlockVectorBase<VectorType>::sadd(const value_type x,
const value_type a,
-template <class VectorType>
+template <typename VectorType>
template <class BlockVector2>
void
BlockVectorBase<VectorType>::scale(const BlockVector2 &v)
-template <class VectorType>
+template <typename VectorType>
std::size_t
BlockVectorBase<VectorType>::memory_consumption() const
{
-template <class VectorType>
+template <typename VectorType>
template <class BlockVector2>
void
BlockVectorBase<VectorType>::equ(const value_type a, const BlockVector2 &v)
-template <class VectorType>
+template <typename VectorType>
void
BlockVectorBase<VectorType>::update_ghost_values() const
{
-template <class VectorType>
+template <typename VectorType>
BlockVectorBase<VectorType> &
BlockVectorBase<VectorType>::operator=(const value_type s)
{
}
-template <class VectorType>
+template <typename VectorType>
BlockVectorBase<VectorType> &
BlockVectorBase<VectorType>::operator=(const BlockVectorBase<VectorType> &v)
{
}
-template <class VectorType>
-template <class VectorType2>
+template <typename VectorType>
+template <typename VectorType2>
BlockVectorBase<VectorType> &
BlockVectorBase<VectorType>::operator=(const BlockVectorBase<VectorType2> &v)
{
-template <class VectorType>
+template <typename VectorType>
BlockVectorBase<VectorType> &
BlockVectorBase<VectorType>::operator=(const VectorType &v)
{
-template <class VectorType>
-template <class VectorType2>
+template <typename VectorType>
+template <typename VectorType2>
inline bool
BlockVectorBase<VectorType>::operator==(
const BlockVectorBase<VectorType2> &v) const
-template <class VectorType>
+template <typename VectorType>
inline BlockVectorBase<VectorType> &
BlockVectorBase<VectorType>::operator*=(const value_type factor)
{
-template <class VectorType>
+template <typename VectorType>
inline BlockVectorBase<VectorType> &
BlockVectorBase<VectorType>::operator/=(const value_type factor)
{
}
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::value_type
BlockVectorBase<VectorType>::operator()(const size_type i) const
{
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::reference
BlockVectorBase<VectorType>::operator()(const size_type i)
{
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::value_type
BlockVectorBase<VectorType>::operator[](const size_type i) const
{
-template <class VectorType>
+template <typename VectorType>
inline typename BlockVectorBase<VectorType>::reference
BlockVectorBase<VectorType>::operator[](const size_type i)
{
//---------------------------------------------------------------------------
-template <class VectorType>
+template <typename VectorType>
EigenPower<VectorType>::EigenPower(SolverControl & cn,
VectorMemory<VectorType> &mem,
const AdditionalData & data)
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType>
void
EigenPower<VectorType>::solve(double &value, const MatrixType &A, VectorType &x)
//---------------------------------------------------------------------------
-template <class VectorType>
+template <typename VectorType>
EigenInverse<VectorType>::EigenInverse(SolverControl & cn,
VectorMemory<VectorType> &mem,
const AdditionalData & data)
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType>
void
EigenInverse<VectorType>::solve(double & value,
* A wrapper to least_squares(), implementing the standard MatrixType
* interface.
*/
- template <class VectorType>
+ template <typename VectorType>
void
vmult(VectorType &dst, const VectorType &src) const;
* A wrapper to least_squares() that implements multiplication with
* the transpose matrix.
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tvmult(VectorType &dst, const VectorType &src) const;
template <typename number>
-template <class VectorType>
+template <typename VectorType>
void
Householder<number>::vmult(VectorType &dst, const VectorType &src) const
{
template <typename number>
-template <class VectorType>
+template <typename VectorType>
void
Householder<number>::Tvmult(VectorType &, const VectorType &) const
{
* MatrixType. No index computations are done, thus, the vectors need to
* have sizes matching #matrix.
*/
- template <class VectorType>
+ template <typename VectorType>
void
vmult(VectorType &w, const VectorType &v) const;
* MatrixType. No index computations are done, thus, the vectors need to
* have sizes matching #matrix.
*/
- template <class VectorType>
+ template <typename VectorType>
void
vmult_add(VectorType &w, const VectorType &v) const;
* MatrixType. No index computations are done, thus, the vectors need to
* have sizes matching #matrix.
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tvmult(VectorType &w, const VectorType &v) const;
* MatrixType. No index computations are done, thus, the vectors need to
* have sizes matching #matrix.
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tvmult_add(VectorType &w, const VectorType &v) const;
template <typename MatrixType>
-template <class VectorType>
+template <typename VectorType>
inline void
MatrixBlock<MatrixType>::vmult(VectorType &w, const VectorType &v) const
{
template <typename MatrixType>
-template <class VectorType>
+template <typename VectorType>
inline void
MatrixBlock<MatrixType>::vmult_add(VectorType &w, const VectorType &v) const
{
template <typename MatrixType>
-template <class VectorType>
+template <typename VectorType>
inline void
MatrixBlock<MatrixType>::Tvmult(VectorType &w, const VectorType &v) const
{
template <typename MatrixType>
-template <class VectorType>
+template <typename VectorType>
inline void
MatrixBlock<MatrixType>::Tvmult_add(VectorType &w, const VectorType &v) const
{
* methods:
*
* @code
- * class VectorType : public Subscriptor
+ * typename VectorType : public Subscriptor
* ...
* explicit VectorType(Vec);
* ...
* methods:
*
* @code
- * class VectorType : public Subscriptor
+ * typename VectorType : public Subscriptor
* ...
* explicit VectorType(Vec);
* ...
/**
* Apply preconditioner.
*/
- template <class VectorType>
+ template <typename VectorType>
void
vmult(VectorType &, const VectorType &) const;
* Apply transpose preconditioner. Since this is the identity, this function
* is the same as vmult().
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tvmult(VectorType &, const VectorType &) const;
/**
* Apply preconditioner, adding to the previous value.
*/
- template <class VectorType>
+ template <typename VectorType>
void
vmult_add(VectorType &, const VectorType &) const;
* Apply transpose preconditioner, adding. Since this is the identity, this
* function is the same as vmult_add().
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tvmult_add(VectorType &, const VectorType &) const;
/**
* Apply preconditioner.
*/
- template <class VectorType>
+ template <typename VectorType>
void
vmult(VectorType &, const VectorType &) const;
* Apply transpose preconditioner. Since this is the identity, this function
* is the same as vmult().
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tvmult(VectorType &, const VectorType &) const;
/**
* Apply preconditioner, adding to the previous value.
*/
- template <class VectorType>
+ template <typename VectorType>
void
vmult_add(VectorType &, const VectorType &) const;
* Apply transpose preconditioner, adding. Since this is the identity, this
* function is the same as vmult_add().
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tvmult_add(VectorType &, const VectorType &) const;
* @endcode
*/
template <typename MatrixType = SparseMatrix<double>,
- class VectorType = Vector<double>>
+ typename VectorType = Vector<double>>
class PreconditionUseMatrix : public Subscriptor
{
public:
/**
* Apply preconditioner.
*/
- template <class VectorType>
+ template <typename VectorType>
void
vmult(VectorType &, const VectorType &) const;
* Apply transpose preconditioner. Since this is a symmetric preconditioner,
* this function is the same as vmult().
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tvmult(VectorType &, const VectorType &) const;
/**
* Perform one step of the preconditioned Richardson iteration
*/
- template <class VectorType>
+ template <typename VectorType>
void
step(VectorType &x, const VectorType &rhs) const;
/**
* Perform one transposed step of the preconditioned Richardson iteration.
*/
- template <class VectorType>
+ template <typename VectorType>
void
Tstep(VectorType &x, const VectorType &rhs) const;
}
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionIdentity::vmult(VectorType &dst, const VectorType &src) const
{
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionIdentity::Tvmult(VectorType &dst, const VectorType &src) const
{
dst = src;
}
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionIdentity::vmult_add(VectorType &dst, const VectorType &src) const
{
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionIdentity::Tvmult_add(VectorType &dst, const VectorType &src) const
{
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionRichardson::vmult(VectorType &dst, const VectorType &src) const
{
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionRichardson::Tvmult(VectorType &dst, const VectorType &src) const
{
dst.equ(relaxation, src);
}
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionRichardson::vmult_add(VectorType &dst, const VectorType &src) const
{
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionRichardson::Tvmult_add(VectorType &dst, const VectorType &src) const
{
}
template <typename MatrixType, typename PreconditionerType>
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionRelaxation<MatrixType, PreconditionerType>::vmult(
VectorType & dst,
}
template <typename MatrixType, typename PreconditionerType>
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionRelaxation<MatrixType, PreconditionerType>::Tvmult(
VectorType & dst,
}
template <typename MatrixType, typename PreconditionerType>
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionRelaxation<MatrixType, PreconditionerType>::step(
VectorType & dst,
}
template <typename MatrixType, typename PreconditionerType>
-template <class VectorType>
+template <typename VectorType>
inline void
PreconditionRelaxation<MatrixType, PreconditionerType>::Tstep(
VectorType & dst,
//---------------------------------------------------------------------------
-template <typename MatrixType, class VectorType>
+template <typename MatrixType, typename VectorType>
PreconditionUseMatrix<MatrixType, VectorType>::PreconditionUseMatrix(
const MatrixType & M,
const function_ptr method)
-template <typename MatrixType, class VectorType>
+template <typename MatrixType, typename VectorType>
void
PreconditionUseMatrix<MatrixType, VectorType>::vmult(
VectorType & dst,
-template <typename MatrixType, class VectorType, typename PreconditionerType>
+template <typename MatrixType, typename VectorType, typename PreconditionerType>
inline PreconditionChebyshev<MatrixType, VectorType, PreconditionerType>::
AdditionalData::AdditionalData(const unsigned int degree,
const double smoothing_range,
-template <typename MatrixType, class VectorType, typename PreconditionerType>
+template <typename MatrixType, typename VectorType, typename PreconditionerType>
inline typename PreconditionChebyshev<MatrixType,
VectorType,
PreconditionerType>::AdditionalData &
-template <class VectorType>
+template <typename VectorType>
boost::signals2::connection
BaseQR<VectorType>::connect_givens_slot(
const std::function<void(const unsigned int i,
-template <class VectorType>
+template <typename VectorType>
boost::signals2::connection
ImplicitQR<VectorType>::connect_append_column_slot(
const std::function<bool(const Vector<Number> &u,
* Default implementation for serial vectors. Here we don't need to make a
* copy into a ghosted vector, so just return a reference to @p prev.
*/
- template <class VectorType>
+ template <typename VectorType>
const VectorType &
prepare_ghost_vector(const VectorType &prev, VectorType *other)
{
*
* @ingroup Solvers
*/
-template <class VectorType = Vector<double>>
+template <typename VectorType = Vector<double>>
class SolverBase : public Subscriptor
{
public:
/*-------------------------------- Inline functions ------------------------*/
-template <class VectorType>
+template <typename VectorType>
inline SolverControl::State
SolverBase<VectorType>::StateCombiner::operator()(
const SolverControl::State state1,
}
-template <class VectorType>
+template <typename VectorType>
template <typename Iterator>
inline SolverControl::State
SolverBase<VectorType>::StateCombiner::operator()(const Iterator begin,
}
-template <class VectorType>
+template <typename VectorType>
inline SolverBase<VectorType>::SolverBase(
SolverControl & solver_control,
VectorMemory<VectorType> &vector_memory)
-template <class VectorType>
+template <typename VectorType>
inline SolverBase<VectorType>::SolverBase(SolverControl &solver_control)
: // use the static memory object this class owns
memory(static_vector_memory)
-template <class VectorType>
+template <typename VectorType>
inline boost::signals2::connection
SolverBase<VectorType>::connect(
const std::function<SolverControl::State(const unsigned int iteration,
* connect_condition_number_slot and @p connect_eigenvalues_slot. These slots
* will then be called from the solver with the estimates as argument.
*/
-template <class VectorType = Vector<double>>
+template <typename VectorType = Vector<double>>
class SolverGMRES : public SolverBase<VectorType>
{
public:
*
* For more details see @cite Saad1991.
*/
-template <class VectorType = Vector<double>>
+template <typename VectorType = Vector<double>>
class SolverFGMRES : public SolverBase<VectorType>
{
public:
{
namespace SolverGMRESImplementation
{
- template <class VectorType>
+ template <typename VectorType>
inline TmpVectors<VectorType>::TmpVectors(const unsigned int max_size,
VectorMemory<VectorType> &vmem)
: mem(vmem)
- template <class VectorType>
+ template <typename VectorType>
inline VectorType &
TmpVectors<VectorType>::operator[](const unsigned int i) const
{
- template <class VectorType>
+ template <typename VectorType>
inline VectorType &
TmpVectors<VectorType>::operator()(const unsigned int i,
const VectorType & temp)
- template <class VectorType>
+ template <typename VectorType>
unsigned int
TmpVectors<VectorType>::size() const
{
-template <class VectorType>
+template <typename VectorType>
inline SolverGMRES<VectorType>::AdditionalData::AdditionalData(
const unsigned int max_n_tmp_vectors,
const bool right_preconditioning,
-template <class VectorType>
+template <typename VectorType>
SolverGMRES<VectorType>::SolverGMRES(SolverControl & cn,
VectorMemory<VectorType> &mem,
const AdditionalData & data)
-template <class VectorType>
+template <typename VectorType>
SolverGMRES<VectorType>::SolverGMRES(SolverControl & cn,
const AdditionalData &data)
: SolverBase<VectorType>(cn)
-template <class VectorType>
+template <typename VectorType>
inline void
SolverGMRES<VectorType>::givens_rotation(Vector<double> &h,
Vector<double> &b,
- template <class VectorType,
+ template <typename VectorType,
std::enable_if_t<
!is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
- template <class VectorType,
+ template <typename VectorType,
std::enable_if_t<
is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
- template <class VectorType,
+ template <typename VectorType,
std::enable_if_t<
!is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
- template <class VectorType,
+ template <typename VectorType,
std::enable_if_t<
is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
}
- template <class VectorType,
+ template <typename VectorType,
std::enable_if_t<
!is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
}
- template <class VectorType,
+ template <typename VectorType,
std::enable_if_t<
is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
- template <class VectorType,
+ template <typename VectorType,
std::enable_if_t<
!is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
- template <class VectorType,
+ template <typename VectorType,
std::enable_if_t<
is_dealii_compatible_distributed_vector<VectorType>::value,
VectorType> * = nullptr>
* All subsequent iterations use re-orthogonalization.
* Calls the signal re_orthogonalize_signal if it is connected.
*/
- template <class VectorType>
+ template <typename VectorType>
inline double
iterated_gram_schmidt(
const LinearAlgebra::OrthogonalizationStrategy orthogonalization_strategy,
-template <class VectorType>
+template <typename VectorType>
inline void
SolverGMRES<VectorType>::compute_eigs_and_cond(
const FullMatrix<double> &H_orig,
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
SolverGMRES<VectorType>::solve(const MatrixType & A,
-template <class VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_condition_number_slot(
const std::function<void(double)> &slot,
-template <class VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_eigenvalues_slot(
const std::function<void(const std::vector<std::complex<double>> &)> &slot,
-template <class VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_hessenberg_slot(
const std::function<void(const FullMatrix<double> &)> &slot,
-template <class VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_krylov_space_slot(
const std::function<void(
-template <class VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_re_orthogonalization_slot(
const std::function<void(int)> &slot)
-template <class VectorType>
+template <typename VectorType>
double
SolverGMRES<VectorType>::criterion()
{
//----------------------------------------------------------------------//
-template <class VectorType>
+template <typename VectorType>
SolverFGMRES<VectorType>::SolverFGMRES(SolverControl & cn,
VectorMemory<VectorType> &mem,
const AdditionalData & data)
-template <class VectorType>
+template <typename VectorType>
SolverFGMRES<VectorType>::SolverFGMRES(SolverControl & cn,
const AdditionalData &data)
: SolverBase<VectorType>(cn)
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
SolverFGMRES<VectorType>::solve(const MatrixType & A,
* these steps is stored and therefore there will be multiple values per
* iteration.
*/
-template <class VectorType = Vector<double>>
+template <typename VectorType = Vector<double>>
class SolverIDR : public SolverBase<VectorType>
{
public:
{
namespace SolverIDRImplementation
{
- template <class VectorType>
+ template <typename VectorType>
inline TmpVectors<VectorType>::TmpVectors(const unsigned int s_param,
VectorMemory<VectorType> &vmem)
: mem(vmem)
- template <class VectorType>
+ template <typename VectorType>
inline VectorType &
TmpVectors<VectorType>::operator[](const unsigned int i) const
{
- template <class VectorType>
+ template <typename VectorType>
inline VectorType &
TmpVectors<VectorType>::operator()(const unsigned int i,
const VectorType & temp)
-template <class VectorType>
+template <typename VectorType>
SolverIDR<VectorType>::SolverIDR(SolverControl & cn,
VectorMemory<VectorType> &mem,
const AdditionalData & data)
-template <class VectorType>
+template <typename VectorType>
SolverIDR<VectorType>::SolverIDR(SolverControl &cn, const AdditionalData &data)
: SolverBase<VectorType>(cn)
, additional_data(data)
-template <class VectorType>
+template <typename VectorType>
void
SolverIDR<VectorType>::print_vectors(const unsigned int,
const VectorType &,
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
SolverIDR<VectorType>::solve(const MatrixType & A,
* Solver base class to determine convergence. This mechanism can also be used
* to observe the progress of the iteration.
*/
-template <class VectorType = Vector<double>>
+template <typename VectorType = Vector<double>>
class SolverMinRes : public SolverBase<VectorType>
{
public:
#ifndef DOXYGEN
-template <class VectorType>
+template <typename VectorType>
SolverMinRes<VectorType>::SolverMinRes(SolverControl & cn,
VectorMemory<VectorType> &mem,
const AdditionalData &)
-template <class VectorType>
+template <typename VectorType>
SolverMinRes<VectorType>::SolverMinRes(SolverControl &cn,
const AdditionalData &)
: SolverBase<VectorType>(cn)
-template <class VectorType>
+template <typename VectorType>
double
SolverMinRes<VectorType>::criterion()
{
}
-template <class VectorType>
+template <typename VectorType>
void
SolverMinRes<VectorType>::print_vectors(const unsigned int,
const VectorType &,
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
SolverMinRes<VectorType>::solve(const MatrixType & A,
#ifndef DOXYGEN
-template <class VectorType>
+template <typename VectorType>
SolverQMRS<VectorType>::IterationResult::IterationResult(
const SolverControl::State state,
const double last_residual)
-template <class VectorType>
+template <typename VectorType>
SolverQMRS<VectorType>::SolverQMRS(SolverControl & cn,
VectorMemory<VectorType> &mem,
const AdditionalData & data)
, step(0)
{}
-template <class VectorType>
+template <typename VectorType>
SolverQMRS<VectorType>::SolverQMRS(SolverControl & cn,
const AdditionalData &data)
: SolverBase<VectorType>(cn)
, step(0)
{}
-template <class VectorType>
+template <typename VectorType>
void
SolverQMRS<VectorType>::print_vectors(const unsigned int,
const VectorType &,
const VectorType &) const
{}
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
SolverQMRS<VectorType>::solve(const MatrixType & A,
// otherwise exit as normal
}
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
typename SolverQMRS<VectorType>::IterationResult
SolverQMRS<VectorType>::iterate(const MatrixType & A,
//----------------------------------------------------------------------//
-template <class VectorType>
+template <typename VectorType>
SolverRelaxation<VectorType>::SolverRelaxation(SolverControl &cn,
const AdditionalData &)
: SolverBase<VectorType>(cn)
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType, class RelaxationType>
void
SolverRelaxation<VectorType>::solve(const MatrixType & A,
* Solver base class to determine convergence. This mechanism can also be used
* to observe the progress of the iteration.
*/
-template <class VectorType = Vector<double>>
+template <typename VectorType = Vector<double>>
class SolverRichardson : public SolverBase<VectorType>
{
public:
#ifndef DOXYGEN
-template <class VectorType>
+template <typename VectorType>
inline SolverRichardson<VectorType>::AdditionalData::AdditionalData(
const double omega,
const bool use_preconditioned_residual)
{}
-template <class VectorType>
+template <typename VectorType>
SolverRichardson<VectorType>::SolverRichardson(SolverControl & cn,
VectorMemory<VectorType> &mem,
const AdditionalData & data)
-template <class VectorType>
+template <typename VectorType>
SolverRichardson<VectorType>::SolverRichardson(SolverControl & cn,
const AdditionalData &data)
: SolverBase<VectorType>(cn)
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
SolverRichardson<VectorType>::solve(const MatrixType & A,
-template <class VectorType>
+template <typename VectorType>
template <typename MatrixType, typename PreconditionerType>
void
SolverRichardson<VectorType>::Tsolve(const MatrixType & A,
}
-template <class VectorType>
+template <typename VectorType>
void
SolverRichardson<VectorType>::print_vectors(const unsigned int,
const VectorType &,
-template <class VectorType>
+template <typename VectorType>
inline typename VectorType::value_type
SolverRichardson<VectorType>::criterion(const VectorType &r,
const VectorType &d) const
}
-template <class VectorType>
+template <typename VectorType>
inline void
SolverRichardson<VectorType>::set_omega(const double om)
{
* see
* https://docs.trilinos.org/latest-release/packages/belos/doc/html/classBelos_1_1MultiVec.html.
*/
- template <class VectorType>
+ template <typename VectorType>
class MultiVecWrapper
: public Belos::MultiVec<typename VectorType::value_type>
{
* operators/preconditioners. For details, see
* https://docs.trilinos.org/latest-release/packages/belos/doc/html/classBelos_1_1Operator.html.
*/
- template <class OperatorType, class VectorType>
+ template <class OperatorType, typename VectorType>
class OperatorWrapper
: public Belos::Operator<typename VectorType::value_type>
{
* by seeing whether the `is_serial_vector` type is declared for the
* given vector type.
*/
- template <class VectorType>
+ template <typename VectorType>
using is_vector_type = decltype(is_serial_vector<VectorType>::value);
/**
* A predicate stating whether something is a vector type and is
* indeed a serial vector.
*/
- template <class VectorType>
+ template <typename VectorType>
using is_serial_vector_type =
decltype(std::enable_if_t<is_serial_vector<VectorType>::value, int>());
* a vector type at all, or (ii) if it is a vector type,
* that it is not a parallel vector type.
*/
- template <class VectorType>
+ template <typename VectorType>
constexpr bool is_not_parallel_vector =
(is_supported_operation<is_vector_type, VectorType> == false) ||
(is_supported_operation<is_serial_vector_type, VectorType> == true);
* Coarse grid solver using smoother only. This is a little wrapper,
* transforming a smoother into a coarse grid solver.
*/
-template <class VectorType = Vector<double>>
+template <typename VectorType = Vector<double>>
class MGCoarseGridApplySmoother : public MGCoarseGridBase<VectorType>
{
public:
* This class provides a wrapper for a deal.II iterative solver with a given
* matrix and preconditioner as a coarse grid operator.
*/
-template <class VectorType,
+template <typename VectorType,
class SolverType,
class MatrixType,
class PreconditionerType>
* the operator() uses Householder::least_squares() to compute the action of
* the inverse.
*/
-template <typename number = double, class VectorType = Vector<number>>
+template <typename number = double, typename VectorType = Vector<number>>
class MGCoarseGridHouseholder : public MGCoarseGridBase<VectorType>
{
public:
* Upon initialization, the singular value decomposition of the matrix is
* computed. then, the operator() uses
*/
-template <typename number = double, class VectorType = Vector<number>>
+template <typename number = double, typename VectorType = Vector<number>>
class MGCoarseGridSVD : public MGCoarseGridBase<VectorType>
{
public:
#ifndef DOXYGEN
/* ------------------ Functions for MGCoarseGridApplySmoother -----------*/
-template <class VectorType>
+template <typename VectorType>
MGCoarseGridApplySmoother<VectorType>::MGCoarseGridApplySmoother()
: coarse_smooth(nullptr)
{}
-template <class VectorType>
+template <typename VectorType>
MGCoarseGridApplySmoother<VectorType>::MGCoarseGridApplySmoother(
const MGSmootherBase<VectorType> &coarse_smooth)
: coarse_smooth(nullptr)
}
-template <class VectorType>
+template <typename VectorType>
void
MGCoarseGridApplySmoother<VectorType>::initialize(
const MGSmootherBase<VectorType> &coarse_smooth_)
}
-template <class VectorType>
+template <typename VectorType>
void
MGCoarseGridApplySmoother<VectorType>::clear()
{
}
-template <class VectorType>
+template <typename VectorType>
void
MGCoarseGridApplySmoother<VectorType>::operator()(const unsigned int level,
VectorType & dst,
/* ------------------ Functions for MGCoarseGridIterativeSolver ------------ */
-template <class VectorType,
+template <typename VectorType,
class SolverType,
class MatrixType,
class PreconditionerType>
-template <class VectorType,
+template <typename VectorType,
class SolverType,
class MatrixType,
class PreconditionerType>
-template <class VectorType,
+template <typename VectorType,
class SolverType,
class MatrixType,
class PreconditionerType>
-template <class VectorType,
+template <typename VectorType,
class SolverType,
class MatrixType,
class PreconditionerType>
namespace MGCoarseGridIterativeSolver
{
template <
- class VectorType,
+ typename VectorType,
class SolverType,
class MatrixType,
class PreconditionerType,
}
template <
- class VectorType,
+ typename VectorType,
class SolverType,
class MatrixType,
class PreconditionerType,
-template <class VectorType,
+template <typename VectorType,
class SolverType,
class MatrixType,
class PreconditionerType>
/* ------------------ Functions for MGCoarseGridHouseholder ------------ */
-template <typename number, class VectorType>
+template <typename number, typename VectorType>
MGCoarseGridHouseholder<number, VectorType>::MGCoarseGridHouseholder(
const FullMatrix<number> *A)
{
-template <typename number, class VectorType>
+template <typename number, typename VectorType>
void
MGCoarseGridHouseholder<number, VectorType>::initialize(
const FullMatrix<number> &A)
-template <typename number, class VectorType>
+template <typename number, typename VectorType>
void
MGCoarseGridHouseholder<number, VectorType>::operator()(
const unsigned int /*level*/,
-template <typename number, class VectorType>
+template <typename number, typename VectorType>
void
MGCoarseGridSVD<number, VectorType>::initialize(const FullMatrix<number> &A,
double threshold)
}
-template <typename number, class VectorType>
+template <typename number, typename VectorType>
void
MGCoarseGridSVD<number, VectorType>::operator()(const unsigned int /*level*/,
VectorType & dst,
}
-template <typename number, class VectorType>
+template <typename number, typename VectorType>
void
MGCoarseGridSVD<number, VectorType>::log() const
{
* and @p level_set are stored internally, so these need to have a longer life
* span than the instance of this class.
*/
- template <class VectorType>
+ template <typename VectorType>
FEValues(const hp::FECollection<dim> &fe_collection,
const Quadrature<1> & quadrature,
const RegionUpdateFlags region_update_flags,
* internally, so these need to have a longer life span than the instance of
* this class.
*/
- template <class VectorType>
+ template <typename VectorType>
FEValues(const hp::MappingCollection<dim> &mapping_collection,
const hp::FECollection<dim> & fe_collection,
const hp::QCollection<dim> & q_collection,
* and @p level_set are stored internally, so these need to have a longer life
* span than the instance of this class.
*/
- template <class VectorType>
+ template <typename VectorType>
FEInterfaceValues(const hp::FECollection<dim> &fe_collection,
const Quadrature<1> & quadrature,
const RegionUpdateFlags region_update_flags,
* internally, so these need to have a longer life span than the instance of
* this class.
*/
- template <class VectorType>
+ template <typename VectorType>
FEInterfaceValues(const hp::MappingCollection<dim> &mapping_collection,
const hp::FECollection<dim> & fe_collection,
const hp::QCollection<dim - 1> & q_collection,
* Vector. The triangulation attached to DoFHandler is the one that will be
* classified.
*/
- template <class VectorType>
+ template <typename VectorType>
MeshClassifier(const DoFHandler<dim> &level_set_dof_handler,
const VectorType & level_set);
* class. The hp::QCollection<1> and AdditionalData is passed to the
* QuadratureGenerator class.
*/
- template <class VectorType>
+ template <typename VectorType>
DiscreteQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
const DoFHandler<dim> & dof_handler,
* class. The hp::QCollection<1> and AdditionalData is passed to the
* QuadratureGenerator class.
*/
- template <class VectorType>
+ template <typename VectorType>
DiscreteFaceQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
const DoFHandler<dim> & dof_handler,
* which FEValues can extract values on a cell using the
* FEValuesBase::get_function_values() function.
*/
- template <class VectorType>
+ template <typename VectorType>
void
add_data_vector(
const VectorType & data,
* which FEValues can extract values on a cell using the
* FEValuesBase::get_function_values() function.
*/
- template <class VectorType>
+ template <typename VectorType>
void
add_data_vector(
const VectorType & data,
* represents dof data, the data vector type argument present in the other
* methods above is not necessary.
*/
- template <class VectorType>
+ template <typename VectorType>
void
add_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
* This function is an abbreviation of the function above with only a scalar
* @p dof_handler given and a single data name.
*/
- template <class VectorType>
+ template <typename VectorType>
void
add_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
* error by declaring the data postprocessor variable before the DataOut
* variable as objects are destroyed in reverse order of declaration.
*/
- template <class VectorType>
+ template <typename VectorType>
void
add_data_vector(const VectorType & data,
const DataPostprocessor<spacedim> &data_postprocessor);
* postprocessor can only read data from the given DoFHandler and solution
* vector, not other solution vectors or DoFHandlers.
*/
- template <class VectorType>
+ template <typename VectorType>
void
add_data_vector(const DoFHandler<dim, spacedim> & dof_handler,
const VectorType & data,
* The handling of @p names and @p data_component_interpretation is identical
* to the add_data_vector() function.
*/
- template <class VectorType>
+ template <typename VectorType>
void
add_mg_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
/**
* Scalar version of the function above.
*/
- template <class VectorType>
+ template <typename VectorType>
void
add_mg_data_vector(const DoFHandler<dim, spacedim> &dof_handler,
const MGLevelObject<VectorType> &data,
/**
* Common function called by the four public add_data_vector methods.
*/
- template <class VectorType>
+ template <typename VectorType>
void
add_data_vector_internal(
const DoFHandler<dim, spacedim> *dof_handler,
template <int dim, int patch_dim, int spacedim, int patch_spacedim>
-template <class VectorType>
+template <typename VectorType>
void
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_mg_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
template <int dim, int patch_dim, int spacedim, int patch_spacedim>
-template <class VectorType>
+template <typename VectorType>
void
DataOut_DoFData<dim, patch_dim, spacedim, patch_spacedim>::add_mg_data_vector(
const DoFHandler<dim, spacedim> &dof_handler,
*
* @ingroup output
*/
-template <int dim, typename SolverType, class VectorType = Vector<double>>
+template <int dim, typename SolverType, typename VectorType = Vector<double>>
class DoFPrintSolverStep : public SolverType
{
public:
/* ----------------------- template functions --------------- */
-template <int dim, typename SolverType, class VectorType>
+template <int dim, typename SolverType, typename VectorType>
DoFPrintSolverStep<dim, SolverType, VectorType>::DoFPrintSolverStep(
SolverControl & control,
VectorMemory<VectorType> &mem,
{}
-template <int dim, typename SolverType, class VectorType>
+template <int dim, typename SolverType, typename VectorType>
void
DoFPrintSolverStep<dim, SolverType, VectorType>::print_vectors(
const unsigned int step,
* called for each dataset (time step, iteration, etc) for each vector_name,
* otherwise a @p ExcDataLostSync error can occur.
*/
- template <class VectorType>
+ template <typename VectorType>
void
evaluate_field(const std::string &name, const VectorType &solution);
* method must be called for each dataset (time step, iteration, etc) for
* each vector_name, otherwise a @p ExcDataLostSync error can occur.
*/
- template <class VectorType>
+ template <typename VectorType>
void
evaluate_field(const std::vector<std::string> &names,
const VectorType & solution,
* call the above function. The above function is more efficient if multiple
* fields use the same @p DataPostprocessor object.
*/
- template <class VectorType>
+ template <typename VectorType>
void
evaluate_field(const std::string & name,
const VectorType & solution,
* called for each dataset (time step, iteration, etc) for each vector_name,
* otherwise a @p ExcDataLostSync error can occur.
*/
- template <class VectorType>
+ template <typename VectorType>
void
evaluate_field_at_requested_location(const std::string &name,
const VectorType & solution);
*
* @dealiiConceptRequires{concepts::is_writable_dealii_vector_type<VectorType>}
*/
- template <class VectorType, int dim, int spacedim = dim>
+ template <typename VectorType, int dim, int spacedim = dim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void add_constant(VectorType & solution,
const DoFHandler<dim, spacedim> & dof_handler,
- template <class VectorType, int dim, int spacedim>
+ template <typename VectorType, int dim, int spacedim>
DEAL_II_CXX20_REQUIRES(concepts::is_writable_dealii_vector_type<VectorType>)
void add_constant(VectorType & solution,
const DoFHandler<dim, spacedim> & dof_handler,
-template <class VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverBFGS<VectorType>::connect_line_search_slot(
const std::function<
-template <class VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverBFGS<VectorType>::connect_preconditioner_slot(
const std::function<void(VectorType & g,
* be interpreted as a displacement vector, or a vector of absolute
* positions.
*/
- template <class VectorType>
+ template <typename VectorType>
std::enable_if_t<
std::is_convertible<VectorType *, Function<spacedim> *>::value == false>
set_particle_positions(const VectorType &input_vector,
* @param[in] add_to_output_vector Control if the function should set the
* entries of the @p output_vector or if should add to them.
*/
- template <class VectorType>
+ template <typename VectorType>
void
get_particle_positions(VectorType &output_vector,
const bool add_to_output_vector = false);
template <int dim, int spacedim>
- template <class VectorType>
+ template <typename VectorType>
inline std::enable_if_t<
std::is_convertible<VectorType *, Function<spacedim> *>::value == false>
ParticleHandler<dim, spacedim>::set_particle_positions(
template <int dim, int spacedim>
- template <class VectorType>
+ template <typename VectorType>
inline void
ParticleHandler<dim, spacedim>::get_particle_positions(
VectorType &output_vector,
DEAL_II_NAMESPACE_OPEN
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
MappingQ1Eulerian<dim, VectorType, spacedim>::MappingQ1Eulerian(
const DoFHandler<dim, spacedim> &shiftmap_dof_handler,
const VectorType & euler_transform_vectors)
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
boost::container::small_vector<Point<spacedim>,
GeometryInfo<dim>::vertices_per_cell>
MappingQ1Eulerian<dim, VectorType, spacedim>::get_vertices(
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
std::vector<Point<spacedim>>
MappingQ1Eulerian<dim, VectorType, spacedim>::compute_mapping_support_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell) const
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
std::unique_ptr<Mapping<dim, spacedim>>
MappingQ1Eulerian<dim, VectorType, spacedim>::clone() const
{
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
CellSimilarity::Similarity
MappingQ1Eulerian<dim, VectorType, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
// .... MAPPING Q EULERIAN CONSTRUCTOR
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
MappingQEulerian<dim, VectorType, spacedim>::MappingQEulerian(
const unsigned int degree,
const DoFHandler<dim, spacedim> &euler_dof_handler,
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
std::unique_ptr<Mapping<dim, spacedim>>
MappingQEulerian<dim, VectorType, spacedim>::clone() const
{
// .... SUPPORT QUADRATURE CONSTRUCTOR
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
MappingQEulerian<dim, VectorType, spacedim>::SupportQuadrature::
SupportQuadrature(const unsigned int map_degree)
: Quadrature<dim>(Utilities::fixed_power<dim>(map_degree + 1))
// .... COMPUTE MAPPING SUPPORT POINTS
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
boost::container::small_vector<Point<spacedim>,
GeometryInfo<dim>::vertices_per_cell>
MappingQEulerian<dim, VectorType, spacedim>::get_vertices(
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
std::vector<Point<spacedim>>
MappingQEulerian<dim, VectorType, spacedim>::compute_mapping_support_points(
const typename Triangulation<dim, spacedim>::cell_iterator &cell) const
-template <int dim, class VectorType, int spacedim>
+template <int dim, typename VectorType, int spacedim>
CellSimilarity::Similarity
MappingQEulerian<dim, VectorType, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &cell,
template <int dim>
- template <class VectorType>
+ template <typename VectorType>
FEValues<dim>::FEValues(const hp::FECollection<dim> &fe_collection,
const Quadrature<1> & quadrature,
const RegionUpdateFlags region_update_flags,
template <int dim>
- template <class VectorType>
+ template <typename VectorType>
FEValues<dim>::FEValues(const hp::MappingCollection<dim> &mapping_collection,
const hp::FECollection<dim> & fe_collection,
const hp::QCollection<dim> & q_collection,
template <int dim>
- template <class VectorType>
+ template <typename VectorType>
FEInterfaceValues<dim>::FEInterfaceValues(
const hp::FECollection<dim> &fe_collection,
const Quadrature<1> & quadrature,
template <int dim>
- template <class VectorType>
+ template <typename VectorType>
FEInterfaceValues<dim>::FEInterfaceValues(
const hp::MappingCollection<dim> &mapping_collection,
const hp::FECollection<dim> & fe_collection,
* vector are negative/positive, otherwise return
* LocationToLevelSet::intersected.
*/
- template <class VectorType>
+ template <typename VectorType>
LocationToLevelSet
location_from_dof_signs(const VectorType &local_levelset_values)
{
* The concrete LevelSetDescription used when the level set function is
* described as a (DoFHandler, Vector)-pair.
*/
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
class DiscreteLevelSetDescription : public LevelSetDescription<dim>
{
public:
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
DiscreteLevelSetDescription<dim, VectorType>::DiscreteLevelSetDescription(
const DoFHandler<dim> &dof_handler,
const VectorType & level_set)
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
const hp::FECollection<dim> &
DiscreteLevelSetDescription<dim, VectorType>::get_fe_collection() const
{
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
void
DiscreteLevelSetDescription<dim, VectorType>::get_local_level_set_values(
const typename Triangulation<dim>::active_cell_iterator &cell,
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
unsigned int
DiscreteLevelSetDescription<dim, VectorType>::active_fe_index(
const typename Triangulation<dim>::active_cell_iterator &cell) const
template <int dim>
- template <class VectorType>
+ template <typename VectorType>
MeshClassifier<dim>::MeshClassifier(const DoFHandler<dim> &dof_handler,
const VectorType & level_set)
: triangulation(&dof_handler.get_triangulation())
* function must be called to specify which cell the function should be
* evaluated on.
*/
- template <int dim, class VectorType = Vector<double>>
+ template <int dim, typename VectorType = Vector<double>>
class RefSpaceFEFieldFunction : public CellWiseFunction<dim>
{
public:
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
RefSpaceFEFieldFunction<dim, VectorType>::RefSpaceFEFieldFunction(
const DoFHandler<dim> &dof_handler,
const VectorType & dof_values)
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
void
RefSpaceFEFieldFunction<dim, VectorType>::set_active_cell(
const typename Triangulation<dim>::active_cell_iterator &cell)
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
bool
RefSpaceFEFieldFunction<dim, VectorType>::cell_is_set() const
{
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
double
RefSpaceFEFieldFunction<dim, VectorType>::value(
const Point<dim> & point,
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
Tensor<1, dim>
RefSpaceFEFieldFunction<dim, VectorType>::gradient(
const Point<dim> & point,
- template <int dim, class VectorType>
+ template <int dim, typename VectorType>
SymmetricTensor<2, dim>
RefSpaceFEFieldFunction<dim, VectorType>::hessian(
const Point<dim> & point,
template <int dim>
- template <class VectorType>
+ template <typename VectorType>
DiscreteQuadratureGenerator<dim>::DiscreteQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
const DoFHandler<dim> & dof_handler,
template <int dim>
- template <class VectorType>
+ template <typename VectorType>
DiscreteFaceQuadratureGenerator<dim>::DiscreteFaceQuadratureGenerator(
const hp::QCollection<1> &quadratures1D,
const DoFHandler<dim> & dof_handler,
projects / dealii.git / commitdiff