1 #ifndef DUNE_FEM_OEMSOLVER_HH 2 #define DUNE_FEM_OEMSOLVER_HH 40 virtual void multOEM (
const double *u,
double *w )
const = 0;
47 virtual double ddotOEM (
const double *u,
const double *v )
const = 0;
56 virtual void precondition (
const double *u,
double *w )
const = 0;
74 template <
class OperatorImp>
77 :
public PARDG::Function
80 const OperatorImp & op_;
84 : op_(op), size_(size)
87 void setSize(
int size ) { size_ = size; }
89 void operator () (
const double *arg,
double * dest,
int i = 0 )
91 op_.multOEM(arg,dest);
94 void mult(
const double *arg,
double * dest)
const 96 op_.multOEM(arg,dest);
116 template <
class PreconditionerImp>
119 :
public PARDG::Function
122 const PreconditionerImp& pre_;
126 : pre_(pre), size_(size)
131 void operator () (
const double *arg,
double * dest,
int i = 0 )
133 pre_.precondition(arg,dest);
136 void mult(
const double *arg,
double * dest)
const 138 pre_.precondition(arg,dest);
156 using DuneCBlas :: daxpy;
157 using DuneCBlas :: dcopy;
158 using DuneCBlas :: ddot;
159 using DuneCBlas :: dnrm2;
160 using DuneCBlas :: dscal;
164 template <
class MatrixImp,
class VectorType>
165 void mult(
const MatrixImp & m,
const VectorType * x, VectorType * ret)
172 template <
class Matrix ,
class PC_Matrix ,
bool >
175 static inline double ddot(
const Matrix& A,
179 return A.ddotOEM(x,y);
189 const PC_Matrix & C,
double* solution,
double* tmp)
192 if( C.rightPrecondition() )
194 C.precondition(solution,tmp);
196 std::memcpy(solution,tmp, size *
sizeof(
double));
200 static bool mult_pc (
const Matrix &A,
const PC_Matrix & C,
201 const double *arg,
double *dest ,
double * tmp)
205 bool rightPreCon = C.rightPrecondition();
210 C.precondition(arg,tmp);
221 C.precondition(tmp,dest);
228 template <
class Matrix>
229 struct Mult<Matrix,Matrix,false>
231 static inline double ddot(
const Matrix& A,
235 return A.ddotOEM(x,y);
245 const Matrix & C,
double* solution,
double* tmp)
250 static bool mult_pc(
const Matrix &A,
const Matrix & C,
const double *arg ,
251 double *dest ,
double * tmp)
265 #define USE_MEMPROVIDER 266 #include "bicgstab.h" 270 #undef USE_MEMPROVIDER 281 std::vector<int> indices_;
284 template <
class SolverOperatorImp>
289 double * diag =
new double [size_];
290 double * tmp =
new double [size_];
294 for(
int i=0; i<size_; ++i) tmp[i] = i;
297 int newSize = (int) 0.25 * size_;
298 indices_.reserve( newSize );
299 indices_.resize( 0 );
302 for(
int i=0; i<size_; ++i)
306 indices_.push_back( i );
323 void multOEM(
const double * arg,
double * dest)
const 325 std::memcpy( dest, arg , size_ *
sizeof(
double) );
327 const int s = indices_.size();
328 for(
int i=0; i<s; ++i)
330 dest[indices_[i]] = 0.0;
352 template <
class DiscreteFunctionType,
class OpType >
354 DiscreteFunctionType,DiscreteFunctionType>
362 typename DiscreteFunctionType::RangeFieldType epsilon_;
365 mutable int iterations_;
367 typedef std::pair < int , double > ReturnValueType;
369 template <
class OperatorImp,
bool hasPreconditioning>
372 template <
class DiscreteFunctionImp>
373 static ReturnValueType call(OperatorImp & op,
374 const DiscreteFunctionImp & arg,
375 DiscreteFunctionImp & dest,
376 double eps,
int maxIter,
bool verbose)
381 int size = arg.space().size();
383 if(op.hasPreconditionMatrix())
386 size,op.systemMatrix(),op.preconditionMatrix(),
387 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
392 size,op.systemMatrix(),
393 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
399 template <
class OperatorImp>
400 struct SolverCaller<OperatorImp,false>
402 template <
class DiscreteFunctionImp>
403 static ReturnValueType call(OperatorImp & op,
404 const DiscreteFunctionImp & arg,
405 DiscreteFunctionImp & dest,
406 double eps,
int maxIter,
bool verbose)
411 int size = arg.space().size();
413 size,op.systemMatrix(),
414 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
428 double redEps,
double absLimit,
int maxIter,
bool verbose,
431 epsilon_( absLimit ),
438 double redEps,
double absLimit,
int maxIter,
441 epsilon_( absLimit ),
443 verbose_( parameter.getValue< bool >(
"fem.solver.verbose", false ) ),
448 double redEps,
double absLimit,
451 epsilon_( absLimit ),
452 maxIter_(
std::numeric_limits< int >::
max() ),
453 verbose_( parameter.getValue< bool >(
"fem.solver.verbose", false ) ),
457 void prepare (
const DiscreteFunctionType& Arg, DiscreteFunctionType& Dest)
const 474 void apply(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 477 prepare ( arg, dest );
479 ReturnValueType val =
480 SolverCaller<OperatorType,
484 Conversion<OperatorType, OEMSolver::PreconditionInterface > ::exists >::
486 call(op_,arg,dest,epsilon_,maxIter_,verbose_);
488 iterations_ = val.first;
490 if(arg.space().gridPart().comm().rank() == 0)
492 std::cout <<
"OEM-CG: " << val.first <<
" iterations! Error: " << val.second <<
"\n";
503 void operator ()(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 510 template <
class DiscreteFunctionType,
class OpType>
512 DiscreteFunctionType,DiscreteFunctionType>
520 typename DiscreteFunctionType::RangeFieldType epsilon_;
523 mutable int iterations_;
525 typedef std::pair < int , double > ReturnValueType;
527 template <
class OperatorImp,
bool hasPreconditioning>
530 template <
class DiscreteFunctionImp>
531 static ReturnValueType call(OperatorImp & op,
532 const DiscreteFunctionImp & arg,
533 DiscreteFunctionImp & dest,
534 double eps,
int maxIter,
bool verbose)
536 int size = arg.space().size();
537 if(op.hasPreconditionMatrix())
540 size,op.systemMatrix(),op.preconditionMatrix(),
541 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
546 size,op.systemMatrix(),
547 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
553 template <
class OperatorImp>
554 struct SolverCaller<OperatorImp,false>
556 template <
class DiscreteFunctionImp>
557 static ReturnValueType call(OperatorImp & op,
558 const DiscreteFunctionImp & arg,
559 DiscreteFunctionImp & dest,
560 double eps,
int maxIter,
bool verbose)
562 int size = arg.space().size();
564 size,op.systemMatrix(),
565 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
578 double redEps,
double absLimit,
int maxIter,
bool verbose,
581 epsilon_( absLimit ),
589 double redEps,
double absLimit,
int maxIter,
592 epsilon_( absLimit ),
594 verbose_( parameter.getValue< bool >(
"fem.solver.verbose", false ) ),
600 double redEps,
double absLimit,
603 epsilon_( absLimit ),
604 maxIter_(
std::numeric_limits< int >::
max() ),
605 verbose_( parameter.getValue< bool >(
"fem.solver.verbose", false ) ),
609 void prepare (
const DiscreteFunctionType& Arg, DiscreteFunctionType& Dest)
const 627 void apply(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 630 prepare ( arg, dest );
632 ReturnValueType val =
633 SolverCaller<OperatorType,
637 Conversion<OperatorType, OEMSolver::PreconditionInterface > ::exists >::
639 call(op_,arg,dest,epsilon_,maxIter_,verbose_);
641 iterations_ = val.first;
643 if(arg.space().gridPart().comm().rank() == 0)
645 std::cout <<
"OEM-BICGstab: " << val.first <<
" iterations! Error: " << val.second <<
"\n";
656 void operator ()(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 667 template <
class DiscreteFunctionType,
class OpType>
669 DiscreteFunctionType,DiscreteFunctionType>
677 typename DiscreteFunctionType::RangeFieldType epsilon_;
680 mutable int iterations_;
691 double redEps,
double absLimit,
int maxIter,
bool verbose,
694 epsilon_( absLimit ),
702 double redEps,
double absLimit,
705 epsilon_( absLimit ),
706 maxIter_(
std::numeric_limits< int >::
max() ),
707 verbose_( parameter.getValue< bool >(
"fem.solver.verbose", false ) ),
713 double redEps,
double absLimit,
int maxIter,
716 epsilon_( absLimit ),
718 verbose_( parameter.getValue< bool >(
"fem.solver.verbose", false ) ),
723 void prepare (
const DiscreteFunctionType& Arg, DiscreteFunctionType& Dest)
const 740 void apply(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 743 prepare ( arg, dest );
745 int size = arg.space().size();
748 arg.leakPointer(),dest.leakPointer(),epsilon_,maxIter_,verbose_);
752 std::cout <<
"OEM-BICGGsq: " << iter <<
" iterations!\n";
761 void operator ()(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 770 template<
class DiscreteFunctionType,
class Op >
772 :
public Operator< DiscreteFunctionType, DiscreteFunctionType >
783 typedef std::pair < int , double > ReturnValueType;
785 template <
class OperatorImp,
bool hasPreconditioning>
788 template <
class DiscreteFunctionImp>
789 static ReturnValueType call(OperatorImp & op,
790 const DiscreteFunctionImp & arg,
791 DiscreteFunctionImp & dest,
792 int inner,
double eps,
int maxIter,
bool verbose)
794 int size = arg.space().size();
795 if(op.hasPreconditionMatrix())
798 inner,size,op.systemMatrix(),op.preconditionMatrix(),
799 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
802 else if( arg.space().gridPart().comm().size() > 1 )
804 typedef typename OperatorImp::SystemMatrixType SystemMatrixType;
806 FakeConditionerType preConditioner( size, opSolve );
808 inner,size,op.systemMatrix(),preConditioner,
809 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
814 inner,size,op.systemMatrix(),
815 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
821 template <
class OperatorImp>
822 struct SolverCaller<OperatorImp,false>
824 template <
class DiscreteFunctionImp>
825 static ReturnValueType call(OperatorImp & op,
826 const DiscreteFunctionImp & arg,
827 DiscreteFunctionImp & dest,
828 int inner,
double eps,
int maxIter,
bool verbose)
830 int size = arg.space().size();
831 if( arg.space().gridPart().comm().size() > 1 )
833 typedef typename OperatorImp::MatrixType MatrixType;
835 FakeConditionerType preConditioner( size, opSolve );
837 inner,size,op.matrix(),preConditioner,
838 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
843 inner,size,op.matrix(),
844 arg.leakPointer(),dest.leakPointer(),eps,maxIter,verbose);
858 double redEps,
double absLimit,
int maxIter,
bool verbose,
861 epsilon_( absLimit ),
863 restart_( parameter.getValue< int >(
"oemsolver.gmres.restart", 20 ) ),
869 double redEps,
double absLimit,
int maxIter,
872 epsilon_( absLimit ),
874 restart_( parameter.getValue< int >(
"oemsolver.gmres.restart", 20 ) ),
875 verbose_( parameter.getValue< bool >(
"fem.solver.verbose", false ) ),
880 double redEps,
double absLimit,
883 epsilon_( absLimit ),
884 maxIter_(
std::numeric_limits< int >::
max() ),
885 restart_( parameter.getValue< int >(
"oemsolver.gmres.restart", 20 ) ),
886 verbose_( parameter.getValue< bool >(
"fem.solver.verbose", false ) ),
890 void prepare (
const DiscreteFunctionType& Arg, DiscreteFunctionType& Dest)
const 907 void apply(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 910 prepare ( arg, dest );
912 int size = arg.space().size();
913 int inner =
std::min( size, restart_ );
915 ReturnValueType val =
916 SolverCaller<OperatorType,
920 Conversion<OperatorType, OEMSolver::PreconditionInterface > ::exists >::
922 call(op_,arg,dest,inner,epsilon_,maxIter_,verbose_);
924 iterations_ = val.first;
926 if( arg.space().gridPart().comm().rank() == 0 && verbose_ )
928 std::cout <<
"OEM-GMRES: " << val.first <<
" iterations! Error: " << val.second <<
"\n";
939 void operator ()(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 947 typename DiscreteFunctionType::RangeFieldType epsilon_;
951 mutable int iterations_;
957 #ifdef USE_PARDG_ODE_SOLVER 964 template <
class DiscreteFunctionType,
class OperatorImp>
966 DiscreteFunctionType,DiscreteFunctionType>
969 typedef OperatorImp OperatorType;
973 template <
class SolverType,
bool hasPreconditioning>
976 template<
class OperatorImpA,
class PreConMatrix,
class DiscreteFunctionImp >
977 static void solve(SolverType & solver,
979 const PreConMatrix & pm,
980 const DiscreteFunctionImp & arg,
981 DiscreteFunctionImp & dest)
983 int size = arg.space().size();
989 if(op.hasPreconditionMatrix())
992 solver.set_preconditioner(pre);
995 solver.solve(opSolve, dest.leakPointer() , arg.leakPointer() );
997 solver.unset_preconditioner();
1002 solver.solve(opSolve, dest.leakPointer() , arg.leakPointer() );
1006 template <
class OperatorImpA,
class DiscreteFunctionImp>
1007 static void call(SolverType & solver,
1009 const DiscreteFunctionImp & arg,
1010 DiscreteFunctionImp & dest)
1012 solve(solver,op,op.preconditionMatrix(),arg,dest);
1017 template <
class SolverType>
1018 struct SolverCaller<SolverType,false>
1020 template <
class OperatorImpA,
class DiscreteFunctionImp>
1021 static void call(SolverType & solver,
1023 const DiscreteFunctionImp & arg,
1024 DiscreteFunctionImp & dest)
1026 int size = arg.space().size();
1031 if(arg.space().gridPart().comm().size() > 1)
1033 FakeConditioner fake(size,opSolve);
1035 solver.set_preconditioner(pre);
1038 solver.solve(opSolve, dest.leakPointer() , arg.leakPointer() );
1039 solver.unset_preconditioner();
1044 solver.solve(opSolve, dest.leakPointer() , arg.leakPointer() );
1050 typedef PARDG::GMRES SolverType;
1051 mutable SolverType solver_;
1056 typename DiscreteFunctionType::RangeFieldType epsilon_;
1059 mutable int iterations_;
1062 GMRESOp( OperatorType & op ,
double redEps ,
double absLimit ,
int maxIter ,
bool verbose,
1064 : solver_(PARDG::Communicator::instance(), parameter.getValue<
int >(
"oemsolver.gmres.restart", 20 ) )
1065 , op_(op) , epsilon_ ( absLimit )
1066 , maxIter_ (maxIter ) , verbose_ ( verbose )
1071 void prepare (
const DiscreteFunctionType& Arg, DiscreteFunctionType& Dest)
const 1075 void finalize ()
const 1079 int iterations ()
const 1088 void apply(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 1091 prepare ( arg, dest );
1093 solver_.set_tolerance(epsilon_);
1094 solver_.set_max_number_of_iterations( maxIter_ );
1098 solver_.IterativeSolver::set_output(std::cout);
1099 solver_.DynamicalObject::set_output(std::cout);
1102 SolverCaller<SolverType,
1106 Conversion<OperatorType, OEMSolver::PreconditionInterface > ::exists >::
1108 call(solver_,op_.systemMatrix(),arg,dest);
1110 iterations_ = solver_.number_of_iterations();
1120 void operator ()(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 1126 template <
class DiscreteFunctionType,
class OperatorImp>
1128 DiscreteFunctionType,DiscreteFunctionType>
1131 typedef OperatorImp OperatorType;
1135 template <
class SolverType,
bool hasPreconditioning>
1138 template <
class OperatorImpA,
class PreConMatrix,
class DiscreteFunctionImp>
1139 static void solve(SolverType & solver,
1141 const PreConMatrix & pm,
1142 const DiscreteFunctionImp & arg,
1143 DiscreteFunctionImp & dest)
1145 int size = arg.space().size();
1148 solver.set_preconditioner(pre);
1151 solver.solve(opSolve, dest.leakPointer() , arg.leakPointer() );
1152 solver.unset_preconditioner();
1155 template <
class OperatorImpA,
class DiscreteFunctionImp>
1156 static void call(SolverType & solver,
1158 const DiscreteFunctionImp & arg,
1159 DiscreteFunctionImp & dest)
1161 if(op.hasPreconditionMatrix() )
1163 solve(solver,op.systemMatrix(),op.preconditionMatrix(),arg,dest);
1167 SolverCaller<SolverType,false>::call(solver,op,arg,dest);
1173 template <
class SolverType>
1174 struct SolverCaller<SolverType,false>
1176 template <
class OperatorImpA,
class DiscreteFunctionImp>
1177 static void solve(SolverType & solver,
1179 const DiscreteFunctionImp & arg,
1180 DiscreteFunctionImp & dest)
1182 int size = arg.space().size();
1184 FakeConditionerType fake(size,opSolve);
1185 SolverCaller<SolverType,true>::solve(solver,op,fake,arg,dest);
1188 template <
class OperatorImpA,
class DiscreteFunctionImp>
1189 static void call(SolverType & solver,
1191 const DiscreteFunctionImp & arg,
1192 DiscreteFunctionImp & dest)
1196 solve(solver,op.systemMatrix(),arg,dest);
1201 typedef PARDG::FGMRES SolverType;
1202 mutable SolverType solver_;
1207 typename DiscreteFunctionType::RangeFieldType epsilon_;
1210 mutable int iterations_;
1213 FGMRESOp( OperatorType & op ,
double redEps ,
double absLimit ,
int maxIter ,
bool verbose,
1215 : solver_(PARDG::Communicator::instance(), parameter.getValue<
int >(
"oemsolver.gmres.restart", 20 ) )
1216 , op_(op) , epsilon_ ( absLimit )
1217 , maxIter_ (maxIter ) , verbose_ ( verbose )
1222 void prepare (
const DiscreteFunctionType& Arg, DiscreteFunctionType& Dest)
const 1226 void finalize ()
const 1230 int iterations ()
const 1236 void apply(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 1239 prepare ( arg, dest );
1241 solver_.set_tolerance(epsilon_);
1242 solver_.set_max_number_of_iterations( maxIter_ );
1246 solver_.IterativeSolver::set_output(std::cout);
1247 solver_.DynamicalObject::set_output(std::cout);
1250 SolverCaller<SolverType,
1254 Conversion<OperatorType, OEMSolver::PreconditionInterface > ::exists >::
1256 call(solver_,op_,arg,dest);
1258 iterations_ = solver_.number_of_iterations();
1265 void operator ()(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 1281 template <
class DiscreteFunctionType,
class OperatorImp>
1282 class BICGSTABOp :
public Operator<
1283 DiscreteFunctionType,DiscreteFunctionType>
1286 typedef OperatorImp OperatorType;
1288 template <
class SolverType,
bool hasPreconditioning>
1291 template <
class OperatorImpA,
class PreConMatrix,
class DiscreteFunctionImp>
1292 static void solve(SolverType & solver,
1294 const PreConMatrix & pm,
1295 const DiscreteFunctionImp & arg,
1296 DiscreteFunctionImp & dest)
1298 int size = arg.space().size();
1302 solver.set_preconditioner(pre);
1305 solver.solve(opSolve, dest.leakPointer() , arg.leakPointer() );
1306 solver.unset_preconditioner();
1309 template <
class OperatorImpA,
class DiscreteFunctionImp>
1310 static void call(SolverType & solver,
1312 const DiscreteFunctionImp & arg,
1313 DiscreteFunctionImp & dest)
1315 if(op.hasPreconditionMatrix())
1317 solve(solver,op.systemMatrix(),op.preconditionMatrix(),arg,dest);
1321 SolverCaller<SolverType,false>::call(solver,op,arg,dest);
1327 template <
class SolverType>
1328 struct SolverCaller<SolverType,false>
1330 template <
class OperatorImpA,
class DiscreteFunctionImp>
1331 static void solve(SolverType & solver,
1333 const DiscreteFunctionImp & arg,
1334 DiscreteFunctionImp & dest)
1336 int size = arg.space().size();
1340 solver.solve(opSolve, dest.leakPointer() , arg.leakPointer() );
1342 template <
class OperatorImpA,
class DiscreteFunctionImp>
1343 static void call(SolverType & solver,
1345 const DiscreteFunctionImp & arg,
1346 DiscreteFunctionImp & dest)
1348 solve(solver,op.systemMatrix(),arg,dest);
1353 typedef PARDG::BICGSTAB SolverType;
1354 mutable SolverType solver_;
1358 typename DiscreteFunctionType::RangeFieldType epsilon_;
1361 mutable int iterations_;
1364 BICGSTABOp( OperatorType & op ,
double redEps ,
double absLimit ,
int maxIter ,
bool verbose ,
1366 : solver_(PARDG::Communicator::instance())
1367 , op_(op), epsilon_ ( absLimit )
1368 , maxIter_ (maxIter ) , verbose_ ( verbose )
1373 void prepare (
const DiscreteFunctionType& Arg, DiscreteFunctionType& Dest)
const 1377 void finalize ()
const 1381 int iterations ()
const 1387 void apply(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 1390 prepare ( arg, dest );
1392 solver_.set_tolerance( epsilon_ );
1393 solver_.set_max_number_of_iterations( maxIter_ );
1397 solver_.IterativeSolver::set_output(std::cout);
1398 solver_.DynamicalObject::set_output(std::cout);
1401 SolverCaller<SolverType,
1405 Conversion<OperatorType, OEMSolver::PreconditionInterface > ::exists >::
1407 call(solver_,op_,arg,dest);
1409 iterations_ = solver_.number_of_iterations();
1416 void operator ()(
const DiscreteFunctionType& arg, DiscreteFunctionType& dest )
const 1428 #endif //#indef DUNE_FEM_OEMSOLVER_HH void mult(const double *arg, double *dest) const
Definition: oemsolver/oemsolver.hh:94
int iterations() const
Definition: oemsolver/oemsolver.hh:617
Op OperatorType
Definition: oemsolver/oemsolver.hh:777
static bool mult_pc(const Matrix &A, const PC_Matrix &C, const double *arg, double *dest, double *tmp)
Definition: oemsolver/oemsolver.hh:200
static constexpr T min(T a)
Definition: utility.hh:81
void apply(const DiscreteFunctionType &arg, DiscreteFunctionType &dest) const
solve the system
Definition: oemsolver/oemsolver.hh:627
void setSize(int size)
Definition: oemsolver/oemsolver.hh:87
void apply(const DiscreteFunctionType &arg, DiscreteFunctionType &dest) const
solve the system
Definition: oemsolver/oemsolver.hh:907
std::pair< int, double > bicgstab(const CommunicatorType &comm, unsigned int N, const MATRIX &A, const double *b, double *x, double eps, int maxIter, bool verbose)
Definition: oemsolver/oemsolver.hh:199
mult method when given pre conditioning matrix
Definition: oemsolver/oemsolver.hh:173
Definition: oemsolver/oemsolver.hh:75
static void back_solve(const int size, const PC_Matrix &C, double *solution, double *tmp)
Definition: oemsolver/oemsolver.hh:188
OEMBICGSQOp(OperatorType &op, double redEps, double absLimit, const ParameterReader ¶meter=Parameter::container())
Definition: oemsolver/oemsolver.hh:701
bool mult_t(const Matrix &A, const Matrix &C, const double *arg, double *dest, double *tmp)
Definition: oemsolver/oemsolver.hh:238
static void back_solve(const int size, const Matrix &C, double *solution, double *tmp)
Definition: oemsolver/oemsolver.hh:244
OEM-CG scheme after Hestenes and Stiefel.
Definition: oemsolver/oemsolver.hh:353
OEMBICGSQOp(OperatorType &op, double redEps, double absLimit, int maxIter, bool verbose, const ParameterReader ¶meter=Parameter::container())
constructor of OEM-BiCG-SQ
Definition: oemsolver/oemsolver.hh:690
int dim_of_argument(int i=0) const
Definition: oemsolver/oemsolver.hh:99
static double max(const Double &v, const double p)
Definition: double.hh:387
PreconditionerImpl(const PreconditionerImp &pre, int size=0)
Definition: oemsolver/oemsolver.hh:125
void setSize(int size)
Definition: oemsolver/oemsolver.hh:129
OEMCGOp(OperatorType &op, double redEps, double absLimit, int maxIter, bool verbose, const ParameterReader ¶meter=Parameter::container())
constructor of OEM-CG
Definition: oemsolver/oemsolver.hh:427
OEMCGOp(OperatorType &op, double redEps, double absLimit, int maxIter, const ParameterReader ¶meter=Parameter::container())
Definition: oemsolver/oemsolver.hh:437
static double ddot(const Matrix &A, const double *x, const double *y)
Definition: oemsolver/oemsolver.hh:175
OEMGMRESOp(OperatorType &op, double redEps, double absLimit, const ParameterReader ¶meter=Parameter::container())
Definition: oemsolver/oemsolver.hh:879
FakeConditioner(int size, SolverOperatorImp &op)
Definition: oemsolver/oemsolver.hh:285
int dim_of_value(int i=0) const
Definition: oemsolver/oemsolver.hh:104
void multOEM(const double *arg, double *dest) const
only keep internal parts of arg
Definition: oemsolver/oemsolver.hh:323
void prepare(const DiscreteFunctionType &Arg, DiscreteFunctionType &Dest) const
Definition: oemsolver/oemsolver.hh:890
Double abs(const Double &a)
Definition: double.hh:860
abstract operator
Definition: operator.hh:25
#define USE_PARDG_ODE_SOLVER
Definition: pardg.hh:15
int dim_of_value(int i=0) const
Definition: oemsolver/oemsolver.hh:146
virtual ~OEMMatrix()
Definition: oemsolver/oemsolver.hh:33
BiCG-stab solver.
Definition: oemsolver/oemsolver.hh:511
Definition: coordinate.hh:4
std::pair< int, double > cghs(const CommunicatorType &comm, unsigned int N, const MATRIX &A, const PC_MATRIX &C, const double *b, double *x, double eps, int maxIter, bool detailed)
Definition: oemsolver/oemsolver.hh:139
OpType OperatorType
Definition: oemsolver/oemsolver.hh:515
void finalize() const
Definition: oemsolver/oemsolver.hh:613
Definition: oemsolver/oemsolver.hh:275
static bool mult_pc(const Matrix &A, const Matrix &C, const double *arg, double *dest, double *tmp)
Definition: oemsolver/oemsolver.hh:250
void mult(const double *arg, double *dest) const
Definition: oemsolver/oemsolver.hh:136
static ParameterContainer & container()
Definition: io/parameter.hh:190
std::pair< int, double > gmres(const CommunicatorType &comm, int m, int n, const Matrix &A, const double *b, double *x, double eps, int maxIter, bool verbose)
Definition: oemsolver/oemsolver.hh:203
static double ddot(const Matrix &A, const double *x, const double *y)
Definition: oemsolver/oemsolver.hh:231
virtual double ddotOEM(const double *u, const double *v) const =0
evaluate scalar product
void prepare(const DiscreteFunctionType &Arg, DiscreteFunctionType &Dest) const
Definition: oemsolver/oemsolver.hh:457
bool mult_t(const Matrix &A, const PC_Matrix &C, const double *arg, double *dest, double *tmp)
Definition: oemsolver/oemsolver.hh:182
OEMBICGSTABOp(OperatorType &op, double redEps, double absLimit, const ParameterReader ¶meter=Parameter::container())
Definition: oemsolver/oemsolver.hh:599
OEMBICGSQOp(OperatorType &op, double redEps, double absLimit, int maxIter, const ParameterReader ¶meter=Parameter::container())
Definition: oemsolver/oemsolver.hh:712
Definition: oemsolver/oemsolver.hh:66
int iterations() const
Definition: oemsolver/oemsolver.hh:731
bool rightPrecondition() const
Definition: oemsolver/oemsolver.hh:314
interface for matrices to be used with OEM sovlers
Definition: oemsolver/oemsolver.hh:31
OEMBICGSTABOp(OperatorType &op, double redEps, double absLimit, int maxIter, bool verbose, const ParameterReader ¶meter=Parameter::container())
constructor of OEM-BiCG-stab
Definition: oemsolver/oemsolver.hh:577
Definition: oemsolver/oemsolver.hh:117
int iterations() const
Definition: oemsolver/oemsolver.hh:465
void apply(const DiscreteFunctionType &arg, DiscreteFunctionType &dest) const
solve the system
Definition: oemsolver/oemsolver.hh:740
OEMCGOp(OperatorType &op, double redEps, double absLimit, const ParameterReader ¶meter=Parameter::container())
Definition: oemsolver/oemsolver.hh:447
int dim_of_argument(int i=0) const
Definition: oemsolver/oemsolver.hh:141
int bicgsq(unsigned N, const MATRIX &A, const double *b, double *x, double eps, int maxIter)
Definition: oemsolver/oemsolver.hh:202
OpType OperatorType
Definition: oemsolver/oemsolver.hh:672
void finalize() const
Definition: oemsolver/oemsolver.hh:461
void prepare(const DiscreteFunctionType &Arg, DiscreteFunctionType &Dest) const
Definition: oemsolver/oemsolver.hh:723
virtual void multOEM(const double *u, double *w) const =0
evaluate matrix vector multiplication
void prepare(const DiscreteFunctionType &Arg, DiscreteFunctionType &Dest) const
Definition: oemsolver/oemsolver.hh:609
void mult(const MatrixImp &m, const VectorType *x, VectorType *ret)
Definition: oemsolver/oemsolver.hh:165
BiCG-SQ method.
Definition: oemsolver/oemsolver.hh:668
SolverInterfaceImpl(const OperatorImp &op, int size=0)
Definition: oemsolver/oemsolver.hh:83
OEMGMRESOp(OperatorType &op, double redEps, double absLimit, int maxIter, const ParameterReader ¶meter=Parameter::container())
Definition: oemsolver/oemsolver.hh:868
void finalize() const
Definition: oemsolver/oemsolver.hh:894
OEMBICGSTABOp(OperatorType &op, double redEps, double absLimit, int maxIter, const ParameterReader ¶meter=Parameter::container())
Definition: oemsolver/oemsolver.hh:588
OpType OperatorType
Definition: oemsolver/oemsolver.hh:357
OEMGMRESOp(OperatorType &op, double redEps, double absLimit, int maxIter, bool verbose, const ParameterReader ¶meter=Parameter::container())
constructor of OEM-GMRES
Definition: oemsolver/oemsolver.hh:857
void precondition(const double *arg, double *dest) const
only keep internal parts of arg
Definition: oemsolver/oemsolver.hh:317
void apply(const DiscreteFunctionType &arg, DiscreteFunctionType &dest) const
solve the system
Definition: oemsolver/oemsolver.hh:474
GMRES solver.
Definition: oemsolver/oemsolver.hh:771
void finalize() const
Definition: oemsolver/oemsolver.hh:727
int iterations() const
Definition: oemsolver/oemsolver.hh:898