1 #ifndef DUNE_FEM_SOLVER_PARDGINVERSEOPERATORS_HH 2 #define DUNE_FEM_SOLVER_PARDGINVERSEOPERATORS_HH 4 #include <dune/common/nullptr.hh> 11 #ifdef USE_PARDG_ODE_SOLVER 22 template<
class DomainFunction,
class RangeFunction = DomainFunction >
30 template<
class DomainFunctionSpace,
class RangeFunctionSpace >
31 class ParDGOperator< AdaptiveDiscreteFunction< DomainFunctionSpace >, AdaptiveDiscreteFunction< RangeFunctionSpace > >
32 :
public PARDG::Function
34 typedef ParDGOperator< AdaptiveDiscreteFunction< DomainFunctionSpace >, AdaptiveDiscreteFunction< RangeFunctionSpace > > ThisType;
36 typedef AdaptiveDiscreteFunction< DomainFunctionSpace > DomainFunctionType;
37 typedef AdaptiveDiscreteFunction< RangeFunctionSpace > RangeFunctionType;
40 typedef Operator< DomainFunctionType, RangeFunctionType > OperatorType;
42 typedef typename DomainFunctionType::DiscreteFunctionSpaceType DomainFunctionSpaceType;
43 typedef typename RangeFunctionType::DiscreteFunctionSpaceType RangeFunctionSpaceType;
45 ParDGOperator (
const OperatorType &op,
const DomainFunctionSpaceType &domainSpace,
const RangeFunctionSpaceType &rangeSpace )
47 domainSpace_( domainSpace ),
48 rangeSpace_( rangeSpace )
51 void operator() (
const double *u,
double *w,
int i = 0 )
53 DomainFunctionType uFunction(
"ParDGOperator u", domainSpace_, u );
54 RangeFunctionType wFunction(
"ParDGOperator w", rangeSpace_, w );
55 operator_( uFunction, wFunction );
58 int dim_of_argument(
int i = 0 )
const 61 return domainSpace_.size();
64 int dim_of_value (
int i = 0 )
const 67 return rangeSpace_.size();
71 const OperatorType &operator_;
72 const DomainFunctionSpaceType &domainSpace_;
73 const RangeFunctionSpaceType &rangeSpace_;
82 template<
class DiscreteFunction >
83 class ParDGGeneralizedMinResInverseOperator
84 :
public Operator< DiscreteFunction, DiscreteFunction >
88 typedef ParDGOperator< DiscreteFunction, DiscreteFunction > ParDGOperatorType;
91 typedef typename BaseType::DomainFunctionType DomainFunctionType;
92 typedef typename BaseType::RangeFunctionType RangeFunctionType;
97 ParDGGeneralizedMinResInverseOperator (
const OperatorType &op,
98 double redEps,
double absLimit,
unsigned int maxIterations,
bool verbose,
100 : ParDGGeneralizedMinResInverseOperator( op, nullptr, redEps, absLimit, maxIterations, verbose, parameter ) {}
102 ParDGGeneralizedMinResInverseOperator (
const OperatorType &op,
double redEps,
double absLimit,
104 : ParDGGeneralizedMinResInverseOperator( op, nullptr, redEps, absLimit,
std::numeric_limits< unsigned int >::
max(), false, parameter )
107 ParDGGeneralizedMinResInverseOperator (
const OperatorType &op,
double redEps,
double absLimit,
108 unsigned int maxIterations,
110 : ParDGGeneralizedMinResInverseOperator( op, nullptr, redEps, absLimit, maxIterations, false, parameter ) {}
113 ParDGGeneralizedMinResInverseOperator (
const OperatorType &op,
const PreconditionerType &preconditioner,
114 double redEps,
double absLimit,
unsigned int maxIterations,
bool verbose,
116 : ParDGGeneralizedMinResInverseOperator( op, &preconditioner, redEps, absLimit, maxIterations, verbose, parameter ) {}
118 ParDGGeneralizedMinResInverseOperator (
const OperatorType &op,
const PreconditionerType &preconditioner,
119 double redEps,
double absLimit,
121 : ParDGGeneralizedMinResInverseOperator( op, &preconditioner, redEps, absLimit,
std::numeric_limits< unsigned int >::
max(), false, parameter )
124 ParDGGeneralizedMinResInverseOperator (
const OperatorType &op,
const PreconditionerType &preconditioner,
125 double redEps,
double absLimit,
unsigned int maxIterations,
127 : ParDGGeneralizedMinResInverseOperator( op, &preconditioner, redEps, absLimit, maxIterations, false, parameter ) {}
130 virtual void operator() (
const DomainFunctionType &u, RangeFunctionType &w )
const 132 ParDGOperatorType parDGOperator( operator_, w.space(), u.space() );
133 if( preconditioner_ )
135 ParDGOperatorType parDGPreconditioner( *preconditioner_, w.space(), w.space() );
136 solver_.set_preconditioner( parDGPreconditioner );
137 solver_.solve( parDGOperator, w.leakPointer(), u.leakPointer() );
138 solver_.unset_preconditioner();
141 solver_.solve( parDGOperator, w.leakPointer(), u.leakPointer() );
144 unsigned int iterations ()
const 146 return solver_.number_of_iterations();
150 ParDGGeneralizedMinResInverseOperator (
const OperatorType &op,
151 const PreconditionerType *preconditioner,
152 double redEps,
double absLimit,
153 unsigned int maxIterations,
bool verbose,
155 : solver_(
PARDG::Communicator::instance(), parameter.getValue< int >(
"fem.solver.gmres.restart", 20 ) ),
157 preconditioner_( preconditioner )
159 static const std::string errorTypeTable[] = {
"absolute",
"relative" };
161 int errorType = parameter.getEnum(
"fem.solver.errormeasure", errorTypeTable, 0 );
163 solver_.set_tolerance( redEps,
true);
165 solver_.set_tolerance( absLimit,
false );
168 solver_.set_max_number_of_iterations(
int( maxIterations ) );
174 solver_.IterativeSolver::set_output( std::cout );
175 solver_.DynamicalObject::set_output( std::cout );
179 mutable PARDG::GMRES solver_;
180 const OperatorType &operator_;
181 const PreconditionerType *preconditioner_;
187 template<
class DiscreteFunction >
188 class ParDGBiCGStabInverseOperator
189 :
public Operator< DiscreteFunction, DiscreteFunction >
193 typedef ParDGOperator< DiscreteFunction, DiscreteFunction > ParDGOperatorType;
196 typedef typename BaseType::DomainFunctionType DomainFunctionType;
197 typedef typename BaseType::RangeFunctionType RangeFunctionType;
202 ParDGBiCGStabInverseOperator (
const OperatorType &op,
203 double redEps,
double absLimit,
unsigned int maxIterations,
bool verbose,
205 : ParDGBiCGStabInverseOperator( op, nullptr, redEps, absLimit, maxIterations, verbose, parameter ) {}
207 ParDGBiCGStabInverseOperator (
const OperatorType &op,
208 double redEps,
double absLimit,
210 : ParDGBiCGStabInverseOperator( op, nullptr, redEps, absLimit,
std::numeric_limits< unsigned int >::
max(), false, parameter ) {}
212 ParDGBiCGStabInverseOperator (
const OperatorType &op,
213 double redEps,
double absLimit,
unsigned int maxIterations,
215 : ParDGBiCGStabInverseOperator( op, nullptr, redEps, absLimit, maxIterations, false, parameter ) {}
218 ParDGBiCGStabInverseOperator (
const OperatorType &op,
const PreconditionerType &preconditioner,
219 double redEps,
double absLimit,
unsigned int maxIterations,
bool verbose,
221 : ParDGBiCGStabInverseOperator( op, &preconditioner, redEps, absLimit, maxIterations, verbose, parameter ) {}
223 ParDGBiCGStabInverseOperator (
const OperatorType &op,
const PreconditionerType &preconditioner,
224 double redEps,
double absLimit,
226 : ParDGBiCGStabInverseOperator( op, &preconditioner, redEps, absLimit,
std::numeric_limits< unsigned int >::
max(), false, parameter ) {}
228 ParDGBiCGStabInverseOperator (
const OperatorType &op,
const PreconditionerType &preconditioner,
229 double redEps,
double absLimit,
unsigned int maxIterations,
231 : ParDGBiCGStabInverseOperator( op, &preconditioner, redEps, absLimit, maxIterations, false, parameter ) {}
233 virtual void operator() (
const DomainFunctionType &u, RangeFunctionType &w )
const 235 ParDGOperatorType parDGOperator( operator_, w.space(), u.space() );
236 if( preconditioner_ )
238 ParDGOperatorType parDGPreconditioner( *preconditioner_, w.space(), w.space() );
239 solver_.set_preconditioner( parDGPreconditioner );
240 solver_.solve( parDGOperator, w.leakPointer(), u.leakPointer() );
241 solver_.unset_preconditioner();
244 solver_.solve( parDGOperator, w.leakPointer(), u.leakPointer() );
247 unsigned int iterations ()
const 249 return solver_.number_of_iterations();
253 ParDGBiCGStabInverseOperator (
const OperatorType &op,
const PreconditionerType *preconditioner,
254 double redEps,
double absLimit,
unsigned int maxIterations,
bool verbose,
256 : solver_(
PARDG::Communicator::instance() ),
258 preconditioner_( preconditioner )
260 static const std::string errorTypeTable[] = {
"absolute",
"relative" };
262 int errorType = parameter.getEnum(
"fem.solver.errormeasure", errorTypeTable, 0 );
264 solver_.set_tolerance( redEps,
true);
266 solver_.set_tolerance( absLimit,
false );
269 solver_.set_max_number_of_iterations(
int( maxIterations ) );
275 solver_.IterativeSolver::set_output( std::cout );
276 solver_.DynamicalObject::set_output( std::cout );
280 mutable PARDG::BICGSTAB solver_;
281 const OperatorType &operator_;
282 const PreconditionerType *preconditioner_;
289 #endif // #ifdef USE_PARDG_ODE_SOLVER 291 #endif // #ifndef DUNE_FEM_SOLVER_PARDGINVERSEOPERATORS_HH
static constexpr T min(T a)
Definition: utility.hh:81
BasicParameterReader< std::function< const std::string *(const std::string &, const std::string *) > > ParameterReader
Definition: reader.hh:264
static constexpr T max(T a)
Definition: utility.hh:65
static double max(const Double &v, const double p)
Definition: double.hh:387
Definition: coordinate.hh:4
static ParameterContainer & container()
Definition: io/parameter.hh:190
static bool verbose()
obtain the cached value for fem.verbose
Definition: io/parameter.hh:444
#define PARDG
Definition: pardg.hh:26