Loading...
Searching...
No Matches
twolevelmethod.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_TWOLEVELMETHOD_HH
#define DUNE_ISTL_TWOLEVELMETHOD_HH
#include <tuple>
#include<dune/istl/operators.hh>
#include"amg.hh"
#include"galerkin.hh"
#include<dune/istl/solver.hh>
namespace Dune
{
namespace Amg
{
template<class FO, class CO>
class LevelTransferPolicy
{
public:
typedef FO FineOperatorType;
typedef typename FineOperatorType::range_type FineRangeType;
typedef typename FineOperatorType::domain_type FineDomainType;
typedef CO CoarseOperatorType;
typedef typename CoarseOperatorType::range_type CoarseRangeType;
typedef typename CoarseOperatorType::domain_type CoarseDomainType;
std::shared_ptr<CoarseOperatorType>& getCoarseLevelOperator()
{
return operator_;
}
CoarseRangeType& getCoarseLevelRhs()
{
return rhs_;
}
CoarseDomainType& getCoarseLevelLhs()
{
return lhs_;
}
virtual void moveToCoarseLevel(const FineRangeType& fineRhs)=0;
virtual void moveToFineLevel(FineDomainType& fineLhs)=0;
virtual void createCoarseLevelSystem(const FineOperatorType& fineOperator)=0;
virtual LevelTransferPolicy* clone() const =0;
virtual ~LevelTransferPolicy(){}
protected:
CoarseRangeType rhs_;
CoarseDomainType lhs_;
std::shared_ptr<CoarseOperatorType> operator_;
};
template<class O, class C>
class AggregationLevelTransferPolicy
: public LevelTransferPolicy<O,O>
{
typedef Dune::Amg::AggregatesMap<typename O::matrix_type::size_type> AggregatesMap;
public:
typedef LevelTransferPolicy<O,O> FatherType;
typedef C Criterion;
typedef SequentialInformation ParallelInformation;
AggregationLevelTransferPolicy(const Criterion& crit)
: criterion_(crit)
{}
void createCoarseLevelSystem(const O& fineOperator)
{
prolongDamp_ = criterion_.getProlongationDampingFactor();
GalerkinProduct<ParallelInformation> productBuilder;
typedef typename Dune::Amg::MatrixGraph<const typename O::matrix_type> MatrixGraph;
typedef typename Dune::Amg::PropertiesGraph<MatrixGraph,Dune::Amg::VertexProperties,
Dune::Amg::EdgeProperties,Dune::IdentityMap,Dune::IdentityMap> PropertiesGraph;
MatrixGraph mg(fineOperator.getmat());
PropertiesGraph pg(mg,Dune::IdentityMap(),Dune::IdentityMap());
typedef NegateSet<typename ParallelInformation::OwnerSet> OverlapFlags;
aggregatesMap_ = std::make_shared<AggregatesMap>(pg.maxVertex()+1);
int noAggregates, isoAggregates, oneAggregates, skippedAggregates;
std::tie(noAggregates, isoAggregates, oneAggregates, skippedAggregates) =
aggregatesMap_->buildAggregates(fineOperator.getmat(), pg, criterion_, true);
std::cout<<"no aggregates="<<noAggregates<<" iso="<<isoAggregates<<" one="<<oneAggregates<<" skipped="<<skippedAggregates<<std::endl;
// misuse coarsener to renumber aggregates
Dune::Amg::IndicesCoarsener<Dune::Amg::SequentialInformation,int> renumberer;
typedef std::vector<bool>::iterator Iterator;
typedef Dune::IteratorPropertyMap<Iterator, Dune::IdentityMap> VisitedMap;
std::vector<bool> excluded(fineOperator.getmat().N(), false);
VisitedMap vm(excluded.begin(), Dune::IdentityMap());
ParallelInformation pinfo;
std::size_t aggregates = renumberer.coarsen(pinfo, pg, vm,
*aggregatesMap_, pinfo,
noAggregates);
std::vector<bool>& visited=excluded;
typedef std::vector<bool>::iterator Iterator;
for(Iterator iter= visited.begin(), end=visited.end();
iter != end; ++iter)
*iter=false;
matrix_.reset(productBuilder.build(mg, vm,
SequentialInformation(),
*aggregatesMap_,
aggregates,
OverlapFlags()));
productBuilder.calculate(fineOperator.getmat(), *aggregatesMap_, *matrix_, pinfo, OverlapFlags());
this->lhs_.resize(this->matrix_->M());
this->rhs_.resize(this->matrix_->N());
this->operator_ = std::make_shared<O>(*matrix_);
}
void moveToCoarseLevel(const typename FatherType::FineRangeType& fineRhs)
{
Transfer<typename AggregatesMap::VertexDescriptor,typename FatherType::FineRangeType,ParallelInformation>
::restrictVector(*aggregatesMap_, this->rhs_, fineRhs, ParallelInformation());
this->lhs_=0;
}
void moveToFineLevel(typename FatherType::FineDomainType& fineLhs)
{
Transfer<typename AggregatesMap::VertexDescriptor,typename FatherType::FineRangeType,ParallelInformation>
::prolongateVector(*aggregatesMap_, this->lhs_, fineLhs,
prolongDamp_, ParallelInformation());
}
AggregationLevelTransferPolicy* clone() const
{
return new AggregationLevelTransferPolicy(*this);
}
private:
typename O::matrix_type::field_type prolongDamp_;
std::shared_ptr<AggregatesMap> aggregatesMap_;
Criterion criterion_;
std::shared_ptr<typename O::matrix_type> matrix_;
};
template<class O, class S, class C>
class OneStepAMGCoarseSolverPolicy
{
public:
typedef O Operator;
typedef typename O::range_type X;
typedef C Criterion;
typedef S Smoother;
typedef typename Dune::Amg::SmootherTraits<S>::Arguments SmootherArgs;
typedef AMG<Operator,X,Smoother> AMGType;
OneStepAMGCoarseSolverPolicy(const SmootherArgs& args, const Criterion& c)
: smootherArgs_(args), criterion_(c)
{}
OneStepAMGCoarseSolverPolicy(const OneStepAMGCoarseSolverPolicy& other)
: coarseOperator_(other.coarseOperator_), smootherArgs_(other.smootherArgs_),
criterion_(other.criterion_)
{}
private:
struct AMGInverseOperator : public InverseOperator<X,X>
{
AMGInverseOperator(const typename AMGType::Operator& op,
const Criterion& crit,
const typename AMGType::SmootherArgs& args)
: amg_(op, crit,args), first_(true)
{}
void apply(X& x, X& b, [[maybe_unused]] double reduction, [[maybe_unused]] InverseOperatorResult& res) override
{
if(first_)
{
amg_.pre(x,b);
first_=false;
x_=x;
}
amg_.apply(x,b);
}
void apply(X& x, X& b, InverseOperatorResult& res) override
{
return apply(x,b,1e-8,res);
}
SolverCategory::Category category() const override
{
return amg_.category();
}
~AMGInverseOperator()
{
if(!first_)
amg_.post(x_);
}
AMGInverseOperator(const AMGInverseOperator& other)
: x_(other.x_), amg_(other.amg_), first_(other.first_)
{
}
private:
X x_;
AMGType amg_;
bool first_;
};
public:
typedef AMGInverseOperator CoarseLevelSolver;
template<class P>
CoarseLevelSolver* createCoarseLevelSolver(P& transferPolicy)
{
coarseOperator_=transferPolicy.getCoarseLevelOperator();
AMGInverseOperator* inv = new AMGInverseOperator(*coarseOperator_,
criterion_,
smootherArgs_);
return inv; //std::shared_ptr<InverseOperator<X,X> >(inv);
}
private:
std::shared_ptr<Operator> coarseOperator_;
SmootherArgs smootherArgs_;
Criterion criterion_;
};
template<class FO, class CSP, class S>
class TwoLevelMethod :
public Preconditioner<typename FO::domain_type, typename FO::range_type>
{
public:
typedef CSP CoarseLevelSolverPolicy;
typedef typename CoarseLevelSolverPolicy::CoarseLevelSolver CoarseLevelSolver;
typedef FO FineOperatorType;
typedef typename FineOperatorType::range_type FineRangeType;
typedef typename FineOperatorType::domain_type FineDomainType;
typedef typename CSP::Operator CoarseOperatorType;
typedef typename CoarseOperatorType::range_type CoarseRangeType;
typedef typename CoarseOperatorType::domain_type CoarseDomainType;
typedef S SmootherType;
TwoLevelMethod(const FineOperatorType& op,
std::shared_ptr<SmootherType> smoother,
const LevelTransferPolicy<FineOperatorType,
CoarseOperatorType>& policy,
CoarseLevelSolverPolicy& coarsePolicy,
std::size_t preSteps=1, std::size_t postSteps=1)
: operator_(&op), smoother_(smoother),
preSteps_(preSteps), postSteps_(postSteps)
{
policy_ = policy.clone();
policy_->createCoarseLevelSystem(*operator_);
coarseSolver_=coarsePolicy.createCoarseLevelSolver(*policy_);
}
TwoLevelMethod(const TwoLevelMethod& other)
: operator_(other.operator_), coarseSolver_(new CoarseLevelSolver(*other.coarseSolver_)),
smoother_(other.smoother_), policy_(other.policy_->clone()),
preSteps_(other.preSteps_), postSteps_(other.postSteps_)
{}
~TwoLevelMethod()
{
// Each instance has its own policy.
delete policy_;
delete coarseSolver_;
}
void pre(FineDomainType& x, FineRangeType& b) override
{
smoother_->pre(x,b);
}
void post([[maybe_unused]] FineDomainType& x) override
{}
void apply(FineDomainType& v, const FineRangeType& d) override
{
FineDomainType u(v);
FineRangeType rhs(d);
LevelContext context;
SequentialInformation info;
context.pinfo=&info;
context.lhs=&u;
context.update=&v;
context.smoother=smoother_;
context.rhs=&rhs;
context.matrix=operator_;
// Presmoothing
presmooth(context, preSteps_);
//Coarse grid correction
policy_->moveToCoarseLevel(*context.rhs);
InverseOperatorResult res;
coarseSolver_->apply(policy_->getCoarseLevelLhs(), policy_->getCoarseLevelRhs(), res);
*context.lhs=0;
policy_->moveToFineLevel(*context.lhs);
*context.update += *context.lhs;
// Postsmoothing
postsmooth(context, postSteps_);
}
SolverCategory::Category category() const override
{
return SolverCategory::sequential;
}
private:
struct LevelContext
{
typedef S SmootherType;
std::shared_ptr<SmootherType> smoother;
FineDomainType* lhs;
/*
* @brief The right hand side holding the current residual.
*
* This is passed to the smoother as the right hand side.
*/
FineRangeType* rhs;
FineDomainType* update;
SequentialInformation* pinfo;
const FineOperatorType* matrix;
};
const FineOperatorType* operator_;
CoarseLevelSolver* coarseSolver_;
std::shared_ptr<S> smoother_;
LevelTransferPolicy<FO,typename CSP::Operator>* policy_;
std::size_t preSteps_;
std::size_t postSteps_;
};
}// end namespace Amg
}// end namespace Dune
#endif
amg.hh
The AMG preconditioner.
galerkin.hh
Provides a class for building the galerkin product based on a aggregation scheme.
operators.hh
Define general, extensible interface for operators. The available implementation wraps a matrix.
solver.hh
Define general, extensible interface for inverse operators.
Dune::Amg::AMG::pre
void pre(Domain &x, Range &b)
Prepare the preconditioner.
Definition amg.hh:802
Dune::Amg::SmootherTraits::Arguments
DefaultSmootherArgs< typename T::matrix_type::field_type > Arguments
Definition smoother.hh:67
Dune::Amg::GalerkinProduct::build
G::MutableMatrix * build(G &fineGraph, V &visitedMap, const ParallelInformation &pinfo, AggregatesMap< typename G::VertexDescriptor > &aggregates, const typename G::Matrix::size_type &size, const Set &copy)
Calculates the coarse matrix via a Galerkin product.
Definition galerkin.hh:563
Dune::Amg::AMG< Operator, X, Smoother >::SmootherArgs
SmootherTraits< Smoother >::Arguments SmootherArgs
Definition amg.hh:101
Dune::Amg::AMG< Operator, X, Smoother >::Operator
Operator Operator
Definition amg.hh:74
Dune::Amg::presmooth
void presmooth(LevelContext &levelContext, size_t steps)
Apply pre smoothing on the current level.
Definition smoother.hh:406
Dune::Amg::postsmooth
void postsmooth(LevelContext &levelContext, size_t steps)
Apply post smoothing on the current level.
Definition smoother.hh:428
Dune::Amg::AMG::apply
void apply(Domain &v, const Range &d)
Apply one step of the preconditioner to the system A(v)=d.
Definition amg.hh:889
Dune::Amg::BaseGalerkinProduct::calculate
void calculate(const M &fine, const AggregatesMap< V > &aggregates, M &coarse, const I &pinfo, const O &copy)
Calculate the galerkin product.
Dune
Definition allocator.hh:11
Dune::Amg
Definition novlpschwarz.hh:256
Dune::Amg::AggregatesMap
Class providing information about the mapping of the vertices onto aggregates.
Definition aggregates.hh:566
Dune::Amg::AMG
Parallel algebraic multigrid based on agglomeration.
Definition amg.hh:66
Dune::Amg::EdgeProperties
Class representing the properties of an edge in the matrix graph.
Definition dependency.hh:39
Dune::Amg::VertexProperties
Class representing a node in the matrix graph.
Definition dependency.hh:126
Dune::Amg::GalerkinProduct
Definition galerkin.hh:118
Dune::Amg::MatrixGraph
The (undirected) graph of a matrix.
Definition graph.hh:51
Dune::Amg::PropertiesGraph
Attaches properties to the edges and vertices of a graph.
Definition graph.hh:978
Dune::Amg::PropertiesGraph::maxVertex
VertexDescriptor maxVertex() const
Get the maximal vertex descriptor.
Dune::Amg::IndicesCoarsener
Definition indicescoarsener.hh:36
Dune::Amg::SequentialInformation
Definition pinfo.hh:28
Dune::Amg::Transfer
Definition transfer.hh:32
Dune::Amg::LevelTransferPolicy
Abstract base class for transfer between levels and creation of the coarse level system.
Definition twolevelmethod.hh:38
Dune::Amg::LevelTransferPolicy::CoarseOperatorType
CO CoarseOperatorType
The linear operator of the finel level system. Has to be derived from AssembledLinearOperator.
Definition twolevelmethod.hh:57
Dune::Amg::LevelTransferPolicy::moveToCoarseLevel
virtual void moveToCoarseLevel(const FineRangeType &fineRhs)=0
Transfers the data to the coarse level.
Dune::Amg::LevelTransferPolicy::FineRangeType
FineOperatorType::range_type FineRangeType
The type of the range of the fine level operator.
Definition twolevelmethod.hh:48
Dune::Amg::LevelTransferPolicy::createCoarseLevelSystem
virtual void createCoarseLevelSystem(const FineOperatorType &fineOperator)=0
Algebraically creates the coarse level system.
Dune::Amg::LevelTransferPolicy::CoarseRangeType
CoarseOperatorType::range_type CoarseRangeType
The type of the range of the coarse level operator.
Definition twolevelmethod.hh:61
Dune::Amg::LevelTransferPolicy::~LevelTransferPolicy
virtual ~LevelTransferPolicy()
Destructor.
Definition twolevelmethod.hh:124
Dune::Amg::LevelTransferPolicy< O, O >::lhs_
CoarseDomainType lhs_
Definition twolevelmethod.hh:130
Dune::Amg::LevelTransferPolicy::clone
virtual LevelTransferPolicy * clone() const =0
Clone the current object.
Dune::Amg::LevelTransferPolicy::getCoarseLevelLhs
CoarseDomainType & getCoarseLevelLhs()
Get the coarse level left hand side.
Definition twolevelmethod.hh:87
Dune::Amg::LevelTransferPolicy< O, O >::operator_
std::shared_ptr< CoarseOperatorType > operator_
Definition twolevelmethod.hh:132
Dune::Amg::LevelTransferPolicy< O, O >::rhs_
CoarseRangeType rhs_
Definition twolevelmethod.hh:128
Dune::Amg::LevelTransferPolicy::moveToFineLevel
virtual void moveToFineLevel(FineDomainType &fineLhs)=0
Updates the fine level linear system after the correction of the coarse levels system.
Dune::Amg::LevelTransferPolicy::getCoarseLevelOperator
std::shared_ptr< CoarseOperatorType > & getCoarseLevelOperator()
Get the coarse level operator.
Definition twolevelmethod.hh:70
Dune::Amg::LevelTransferPolicy::getCoarseLevelRhs
CoarseRangeType & getCoarseLevelRhs()
Get the coarse level right hand side.
Definition twolevelmethod.hh:78
Dune::Amg::LevelTransferPolicy::FineOperatorType
FO FineOperatorType
The linear operator of the finel level system. Has to be derived from AssembledLinearOperator.
Definition twolevelmethod.hh:44
Dune::Amg::LevelTransferPolicy::CoarseDomainType
CoarseOperatorType::domain_type CoarseDomainType
The type of the domain of the coarse level operator.
Definition twolevelmethod.hh:65
Dune::Amg::LevelTransferPolicy::FineDomainType
FineOperatorType::domain_type FineDomainType
The type of the domain of the fine level operator.
Definition twolevelmethod.hh:52
Dune::Amg::AggregationLevelTransferPolicy::Criterion
C Criterion
Definition twolevelmethod.hh:147
Dune::Amg::AggregationLevelTransferPolicy::AggregationLevelTransferPolicy
AggregationLevelTransferPolicy(const Criterion &crit)
Definition twolevelmethod.hh:150
Dune::Amg::AggregationLevelTransferPolicy::clone
AggregationLevelTransferPolicy * clone() const
Clone the current object.
Definition twolevelmethod.hh:214
Dune::Amg::AggregationLevelTransferPolicy::moveToFineLevel
void moveToFineLevel(typename FatherType::FineDomainType &fineLhs)
Updates the fine level linear system after the correction of the coarse levels system.
Definition twolevelmethod.hh:207
Dune::Amg::AggregationLevelTransferPolicy::moveToCoarseLevel
void moveToCoarseLevel(const typename FatherType::FineRangeType &fineRhs)
Definition twolevelmethod.hh:200
Dune::Amg::AggregationLevelTransferPolicy::ParallelInformation
SequentialInformation ParallelInformation
Definition twolevelmethod.hh:148
Dune::Amg::AggregationLevelTransferPolicy::FatherType
LevelTransferPolicy< O, O > FatherType
Definition twolevelmethod.hh:146
Dune::Amg::AggregationLevelTransferPolicy::createCoarseLevelSystem
void createCoarseLevelSystem(const O &fineOperator)
Algebraically creates the coarse level system.
Definition twolevelmethod.hh:154
Dune::Amg::OneStepAMGCoarseSolverPolicy::OneStepAMGCoarseSolverPolicy
OneStepAMGCoarseSolverPolicy(const SmootherArgs &args, const Criterion &c)
Constructs the coarse solver policy.
Definition twolevelmethod.hh:253
Dune::Amg::OneStepAMGCoarseSolverPolicy::CoarseLevelSolver
AMGInverseOperator CoarseLevelSolver
The type of solver constructed for the coarse level.
Definition twolevelmethod.hh:315
Dune::Amg::OneStepAMGCoarseSolverPolicy::OneStepAMGCoarseSolverPolicy
OneStepAMGCoarseSolverPolicy(const OneStepAMGCoarseSolverPolicy &other)
Copy constructor.
Definition twolevelmethod.hh:257
Dune::Amg::OneStepAMGCoarseSolverPolicy::X
O::range_type X
The type of the range and domain of the operator.
Definition twolevelmethod.hh:239
Dune::Amg::OneStepAMGCoarseSolverPolicy::Criterion
C Criterion
The type of the crition used for the aggregation within AMG.
Definition twolevelmethod.hh:241
Dune::Amg::OneStepAMGCoarseSolverPolicy::SmootherArgs
Dune::Amg::SmootherTraits< S >::Arguments SmootherArgs
The type of the arguments used for constructing the smoother.
Definition twolevelmethod.hh:245
Dune::Amg::OneStepAMGCoarseSolverPolicy::Operator
O Operator
The type of the linear operator used.
Definition twolevelmethod.hh:237
Dune::Amg::OneStepAMGCoarseSolverPolicy::AMGType
AMG< Operator, X, Smoother > AMGType
The type of the AMG construct on the coarse level.
Definition twolevelmethod.hh:247
Dune::Amg::OneStepAMGCoarseSolverPolicy::createCoarseLevelSolver
CoarseLevelSolver * createCoarseLevelSolver(P &transferPolicy)
Constructs a coarse level solver.
Definition twolevelmethod.hh:325
Dune::Amg::OneStepAMGCoarseSolverPolicy::Smoother
S Smoother
The type of the smoother used in AMG.
Definition twolevelmethod.hh:243
Dune::Amg::TwoLevelMethod::CoarseRangeType
CoarseOperatorType::range_type CoarseRangeType
The type of the range of the coarse level operator.
Definition twolevelmethod.hh:380
Dune::Amg::TwoLevelMethod::FineDomainType
FineOperatorType::domain_type FineDomainType
The type of the domain of the fine level operator.
Definition twolevelmethod.hh:371
Dune::Amg::TwoLevelMethod::TwoLevelMethod
TwoLevelMethod(const TwoLevelMethod &other)
Definition twolevelmethod.hh:418
Dune::Amg::TwoLevelMethod::post
void post(FineDomainType &x) override
Definition twolevelmethod.hh:436
Dune::Amg::TwoLevelMethod::FineOperatorType
FO FineOperatorType
The linear operator of the finel level system. Has to be derived from AssembledLinearOperator.
Definition twolevelmethod.hh:363
Dune::Amg::TwoLevelMethod::CoarseLevelSolver
CoarseLevelSolverPolicy::CoarseLevelSolver CoarseLevelSolver
The type of the coarse level solver.
Definition twolevelmethod.hh:358
Dune::Amg::TwoLevelMethod::apply
void apply(FineDomainType &v, const FineRangeType &d) override
Definition twolevelmethod.hh:439
Dune::Amg::TwoLevelMethod::CoarseLevelSolverPolicy
CSP CoarseLevelSolverPolicy
The type of the policy for constructing the coarse level solver.
Definition twolevelmethod.hh:356
Dune::Amg::TwoLevelMethod::CoarseDomainType
CoarseOperatorType::domain_type CoarseDomainType
The type of the domain of the coarse level operator.
Definition twolevelmethod.hh:384
Dune::Amg::TwoLevelMethod::TwoLevelMethod
TwoLevelMethod(const FineOperatorType &op, std::shared_ptr< SmootherType > smoother, const LevelTransferPolicy< FineOperatorType, CoarseOperatorType > &policy, CoarseLevelSolverPolicy &coarsePolicy, std::size_t preSteps=1, std::size_t postSteps=1)
Constructs a two level method.
Definition twolevelmethod.hh:404
Dune::Amg::TwoLevelMethod::category
SolverCategory::Category category() const override
Category of the preconditioner (see SolverCategory::Category).
Definition twolevelmethod.hh:466
Dune::Amg::TwoLevelMethod::pre
void pre(FineDomainType &x, FineRangeType &b) override
Definition twolevelmethod.hh:431
Dune::Amg::TwoLevelMethod::FineRangeType
FineOperatorType::range_type FineRangeType
The type of the range of the fine level operator.
Definition twolevelmethod.hh:367
Dune::Amg::TwoLevelMethod::~TwoLevelMethod
~TwoLevelMethod()
Definition twolevelmethod.hh:424
Dune::Amg::TwoLevelMethod::CoarseOperatorType
CSP::Operator CoarseOperatorType
The linear operator of the finel level system. Has to be derived from AssembledLinearOperator.
Definition twolevelmethod.hh:376
Dune::Amg::TwoLevelMethod::SmootherType
S SmootherType
The type of the fine level smoother.
Definition twolevelmethod.hh:388
Dune::Preconditioner
Base class for matrix free definition of preconditioners.
Definition preconditioner.hh:33
Dune::InverseOperatorResult
Statistics about the application of an inverse operator.
Definition solver.hh:50
Dune::InverseOperator
Abstract base class for all solvers.
Definition solver.hh:101
Dune::InverseOperator< X, X >::category
virtual SolverCategory::Category category() const=0
Dune::SolverCategory::Category
Category
Definition solvercategory.hh:23
Dune::SolverCategory::sequential
@ sequential
Category for sequential solvers.
Definition solvercategory.hh:25