Dune::Copasi::ISTL Namespace Reference

Namespaces
namespace	Concept

Classes
class	BlockJacobi
struct	DenseInverse
class	UMFPackWapper

Typedefs
template<class M , class X , class Y , class A >
using	DirectSolverFactorySignature
template<class M , class X , class Y , class A >
using	DirectSolverRegistry = ParameterizedObjectFactoryWrapper<DirectSolverFactorySignature<M, X, Y, A>>
template<class X , class Y , class A >
using	IterativeSolverFactorySignature
template<class X , class Y , class A >
using	IterativeSolverRegistry
template<Concept::LinearOperator O, class A >
using	PreconditionerFactorySignature
template<Concept::LinearOperator O, class A >
using	PreconditionerRegistry = ParameterizedObjectFactoryWrapper<PreconditionerFactorySignature<O, A>>

Functions
template<Concept::AssembledLinearOperator O, class Alloc >
const DirectSolverRegistry< typename O::matrix_type, typename O::domain_type, typename O::range_type, Alloc > &	getDirectSolverRegistry ()
template<Concept::AssembledLinearOperator Op, class Alloc = std::allocator<Op>>
std::shared_ptr< InverseOperator< typename Op::domain_type, typename Op::range_type > >	makeDirectSolver (const std::shared_ptr< Op > &op, const ParameterTree &config, const Alloc &alloc=Alloc())
template<Concept::LinearOperator Op, class Alloc = std::allocator<Op>>
std::shared_ptr< InverseOperator< typename Op::domain_type, typename Op::range_type > >	makeInverseOperator (const std::shared_ptr< Op > &op, const ParameterTree &config, const Alloc &alloc=Alloc())
template<Concept::LinearOperator O, class Alloc >
const IterativeSolverRegistry< typename O::domain_type, typename O::range_type, Alloc > &	getIterativeSolverRegistry ()
template<Concept::LinearOperator Op, class Alloc = std::allocator<Op>>
std::shared_ptr< IterativeSolver< typename Op::domain_type, typename Op::range_type > >	makeIterativeSolver (const std::shared_ptr< Op > &op, const std::shared_ptr< ScalarProduct< typename Op::domain_type > > &sp, const std::shared_ptr< Preconditioner< typename Op::domain_type, typename Op::range_type > > &prec, const ParameterTree &config, const Alloc &alloc=Alloc())
template<Concept::LinearOperator O, class Alloc >
const PreconditionerRegistry< O, Alloc > &	getPreconditionerRegistry ()
template<Concept::LinearOperator Op, class Alloc = std::allocator<Op>>
std::shared_ptr< Preconditioner< typename Op::domain_type, typename Op::range_type > >	makePreconditioner (const std::shared_ptr< Op > &op, const ParameterTree &config, const Alloc &alloc=Alloc())

Typedef Documentation

DirectSolverFactorySignature

template<class M , class X , class Y , class A >

using Dune::Copasi::ISTL::DirectSolverFactorySignature

Initial value:

 
  std::shared_ptr<InverseOperator<X, Y>>(const std::shared_ptr<AssembledLinearOperator<M, X, Y>>&,
                                         const ParameterTree&,
                                         const A&)

DirectSolverRegistry

template<class M , class X , class Y , class A >

using Dune::Copasi::ISTL::DirectSolverRegistry = ParameterizedObjectFactoryWrapper<DirectSolverFactorySignature<M, X, Y, A>>

IterativeSolverFactorySignature

template<class X , class Y , class A >

using Dune::Copasi::ISTL::IterativeSolverFactorySignature

Initial value:

 
  std::shared_ptr<IterativeSolver<X, Y>>(const std::shared_ptr<LinearOperator<X, Y>>&,
                                         const std::shared_ptr<ScalarProduct<X>>&,
                                         const std::shared_ptr<Preconditioner<X, Y>>&,
                                         const ParameterTree&,
                                         const A&)

IterativeSolverRegistry

template<class X , class Y , class A >

using Dune::Copasi::ISTL::IterativeSolverRegistry

Initial value:

 
  ParameterizedObjectFactoryWrapper<IterativeSolverFactorySignature<X, Y, A>>

PreconditionerFactorySignature

template<Concept::LinearOperator O, class A >

using Dune::Copasi::ISTL::PreconditionerFactorySignature

Initial value:

 
  std::shared_ptr<Preconditioner<typename O::domain_type, typename O::range_type>>(
    const std::shared_ptr<O>&,
    const ParameterTree&,
    const A&)

PreconditionerRegistry

template<Concept::LinearOperator O, class A >

using Dune::Copasi::ISTL::PreconditionerRegistry = ParameterizedObjectFactoryWrapper<PreconditionerFactorySignature<O, A>>

Function Documentation

getDirectSolverRegistry()

template<Concept::AssembledLinearOperator O, class Alloc >

const DirectSolverRegistry< typename O::matrix_type, typename O::domain_type, typename O::range_type, Alloc > & Dune::Copasi::ISTL::getDirectSolverRegistry

(

)

getIterativeSolverRegistry()

template<Concept::LinearOperator O, class Alloc >

const IterativeSolverRegistry< typename O::domain_type, typename O::range_type, Alloc > & Dune::Copasi::ISTL::getIterativeSolverRegistry

(

)

getPreconditionerRegistry()

template<Concept::LinearOperator O, class Alloc >

const PreconditionerRegistry< O, Alloc > & Dune::Copasi::ISTL::getPreconditionerRegistry

(

)

makeDirectSolver()

template<Concept::AssembledLinearOperator Op, class Alloc = std::allocator<Op>>

std::shared_ptr< InverseOperator< typename Op::domain_type, typename Op::range_type > > Dune::Copasi::ISTL::makeDirectSolver	(	const std::shared_ptr< Op > &	op,
		const ParameterTree &	config,
		const Alloc &	alloc = Alloc() )

makeInverseOperator()

template<Concept::LinearOperator Op, class Alloc = std::allocator<Op>>

std::shared_ptr< InverseOperator< typename Op::domain_type, typename Op::range_type > > Dune::Copasi::ISTL::makeInverseOperator	(	const std::shared_ptr< Op > &	op,
		const ParameterTree &	config,
		const Alloc &	alloc = Alloc() )

makeIterativeSolver()

template<Concept::LinearOperator Op, class Alloc = std::allocator<Op>>

std::shared_ptr< IterativeSolver< typename Op::domain_type, typename Op::range_type > > Dune::Copasi::ISTL::makeIterativeSolver	(	const std::shared_ptr< Op > &	op,
		const std::shared_ptr< ScalarProduct< typename Op::domain_type > > &	sp,
		const std::shared_ptr< Preconditioner< typename Op::domain_type, typename Op::range_type > > &	prec,
		const ParameterTree &	config,
		const Alloc &	alloc = Alloc() )

makePreconditioner()

template<Concept::LinearOperator Op, class Alloc = std::allocator<Op>>

std::shared_ptr< Preconditioner< typename Op::domain_type, typename Op::range_type > > Dune::Copasi::ISTL::makePreconditioner	(	const std::shared_ptr< Op > &	op,
		const ParameterTree &	config,
		const Alloc &	alloc = Alloc() )