FEAT 3
Finite Element Analysis Toolbox
Loading...
Searching...
No Matches
uzawa_precond.hpp
1// FEAT3: Finite Element Analysis Toolbox, Version 3
2// Copyright (C) 2010 by Stefan Turek & the FEAT group
3// FEAT3 is released under the GNU General Public License version 3,
4// see the file 'copyright.txt' in the top level directory for details.
5
6#pragma once
7
8// includes, FEAT
9#include <kernel/solver/base.hpp>
10#include <kernel/lafem/saddle_point_matrix.hpp>
11#include <kernel/lafem/tuple_filter.hpp>
12#include <kernel/lafem/tuple_vector.hpp>
13#include <kernel/lafem/tuple_mirror.hpp>
14#include <kernel/global/matrix.hpp>
15#include <kernel/global/vector.hpp>
16#include <kernel/global/filter.hpp>
17
18namespace FEAT
19{
20 namespace Solver
21 {
28 enum class UzawaType
29 {
31 diagonal,
33 lower,
35 upper,
37 full
38 };
39
75 template<typename MatrixA_, typename MatrixB_, typename MatrixD_, typename FilterV_, typename FilterP_>
76 class UzawaPrecond :
77 public SolverBase<LAFEM::TupleVector<typename MatrixB_::VectorTypeL, typename MatrixD_::VectorTypeL> >
78 {
79 public:
81 typedef typename MatrixA_::DataType DataType;
83 typedef typename MatrixB_::VectorTypeL VectorTypeV;
85 typedef typename MatrixD_::VectorTypeL VectorTypeP;
87 typedef LAFEM::TupleVector<VectorTypeV, VectorTypeP> VectorType;
89 typedef SolverBase<VectorType> BaseClass;
90
92 typedef SolverBase<VectorTypeV> SolverA;
94 typedef SolverBase<VectorTypeP> SolverS;
95
96 private:
97 const MatrixA_& _matrix_a;
98 const MatrixB_& _matrix_b;
99 const MatrixD_& _matrix_d;
101 const FilterV_& _filter_v;
102 const FilterP_& _filter_p;
104 std::shared_ptr<SolverA> _solver_a;
106 std::shared_ptr<SolverS> _solver_s;
108 UzawaType _uzawa_type;
110 const bool _auto_init_s;
112 VectorTypeV _vec_tmp_v;
113 VectorTypeP _vec_tmp_p;
114
115 public:
139 explicit UzawaPrecond(
140 const MatrixA_& matrix_a,
141 const MatrixB_& matrix_b,
142 const MatrixD_& matrix_d,
143 const FilterV_& filter_v,
144 const FilterP_& filter_p,
145 std::shared_ptr<SolverA> solver_a,
146 std::shared_ptr<SolverS> solver_s,
147 UzawaType type = UzawaType::diagonal,
148 bool auto_init_s = true) :
149 _matrix_a(matrix_a),
150 _matrix_b(matrix_b),
151 _matrix_d(matrix_d),
152 _filter_v(filter_v),
153 _filter_p(filter_p),
154 _solver_a(solver_a),
155 _solver_s(solver_s),
156 _uzawa_type(type),
157 _auto_init_s(auto_init_s)
158 {
159 XASSERTM(solver_a != nullptr, "A-solver must be given");
160 XASSERTM(solver_s != nullptr, "S-solver must be given");
161 }
162
163 virtual ~UzawaPrecond()
164 {
165 }
166
167 virtual String name() const override
168 {
169 return "Uzawa";
170 }
171
172 virtual void init_symbolic() override
173 {
174 BaseClass::init_symbolic();
175 _solver_a->init_symbolic();
176 if(_auto_init_s)
177 {
178 _solver_s->init_symbolic();
179 }
180
181 // create a temporary vector
182 if(_uzawa_type != UzawaType::diagonal)
183 {
184 _vec_tmp_v = _matrix_b.create_vector_l();
185 _vec_tmp_p = _matrix_d.create_vector_l();
186 }
187 }
188
189 virtual void init_numeric() override
190 {
191 BaseClass::init_numeric();
192 _solver_a->init_numeric();
193 if(_auto_init_s)
194 {
195 _solver_s->init_numeric();
196 }
197 }
198
199 virtual void done_numeric() override
200 {
201 if(_auto_init_s)
202 {
203 _solver_s->done_numeric();
204 }
205 _solver_a->done_numeric();
206 BaseClass::done_numeric();
207 }
208
209 virtual void done_symbolic() override
210 {
211 if(_uzawa_type != UzawaType::diagonal)
212 {
213 _vec_tmp_p.clear();
214 _vec_tmp_v.clear();
215 }
216 if(_auto_init_s)
217 {
218 _solver_s->done_symbolic();
219 }
220 _solver_a->done_symbolic();
221 BaseClass::done_symbolic();
222 }
223
224 virtual Status apply(VectorType& vec_cor, const VectorType& vec_def) override
225 {
226 Statistics::add_solver_expression(std::make_shared<ExpressionStartSolve>(this->name()));
227 // fetch the references
228 VectorTypeV& tmp_v = this->_vec_tmp_v;
229 VectorTypeP& tmp_p = this->_vec_tmp_p;
230 VectorTypeV& sol_v = vec_cor.template at<0>();
231 VectorTypeP& sol_p = vec_cor.template at<1>();
232 const VectorTypeV& rhs_v = vec_def.template at<0>();
233 const VectorTypeP& rhs_p = vec_def.template at<1>();
234
235 // now let's check the preconditioner type
236 switch(_uzawa_type)
237 {
238 case UzawaType::diagonal:
239 // solve A*u_v = f_v
240 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
241 if(!status_success(_solver_a->apply(sol_v, rhs_v)))
242 {
243 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
244 return Status::aborted;
245 }
246
247 // solve S*u_p = f_p
248 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaS>(this->name(), this->_solver_s->name()));
249 if(!status_success(_solver_s->apply(sol_p, rhs_p)))
250 {
251 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
252 return Status::aborted;
253 }
254
255 // okay
256 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::success, 0));
257 return Status::success;
258
259 case UzawaType::lower:
260 // solve A*u_v = f_v
261 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
262 if(!status_success(_solver_a->apply(sol_v, rhs_v)))
263 {
264 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
265 return Status::aborted;
266 }
267
268 // compute g_p := f_p - D*u_v
269 this->_matrix_d.apply(tmp_p, sol_v, rhs_p, -DataType(1));
270
271 // apply pressure defect filter
272 this->_filter_p.filter_def(tmp_p);
273
274 // solve S*u_p = g_p
275 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaS>(this->name(), this->_solver_s->name()));
276 if(!status_success(_solver_s->apply(sol_p, tmp_p)))
277 {
278 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
279 return Status::aborted;
280 }
281
282 // okay
283 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::success, 0));
284 return Status::success;
285
286 case UzawaType::upper:
287 // solve S*u_p = f_p
288 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaS>(this->name(), this->_solver_s->name()));
289 if(!status_success(_solver_s->apply(sol_p, rhs_p)))
290 {
291 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
292 return Status::aborted;
293 }
294
295 // compute g_v := f_v - B*u_p
296 this->_matrix_b.apply(tmp_v, sol_p, rhs_v, -DataType(1));
297
298 // apply velocity defect filter
299 this->_filter_v.filter_def(tmp_v);
300
301 // solve A*u_v = g_v
302 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
303 if(!status_success(_solver_a->apply(sol_v, tmp_v)))
304 {
305 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
306 return Status::aborted;
307 }
308
309 // okay
310 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::success, 0));
311 return Status::success;
312
313 case UzawaType::full:
314 // Note: We will use the first component of the solution vector here.
315 // It will be overwritten by the third solution step below.
316 // solve A*u_v = f_v
317 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
318 if(!status_success(_solver_a->apply(sol_v, rhs_v)))
319 {
320 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
321 return Status::aborted;
322 }
323
324 // compute g_p := f_p - D*u_v
325 this->_matrix_d.apply(tmp_p, sol_v, rhs_p, -DataType(1));
326
327 // apply pressure defect filter
328 this->_filter_p.filter_def(tmp_p);
329
330 // solve S*u_p = g_p
331 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaS>(this->name(), this->_solver_s->name()));
332 if(!status_success(_solver_s->apply(sol_p, tmp_p)))
333 {
334 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
335 return Status::aborted;
336 }
337
338 // compute g_v := f_v - B*u_p
339 this->_matrix_b.apply(tmp_v, sol_p, rhs_v, -DataType(1));
340
341 // apply velocity defect filter
342 this->_filter_v.filter_def(tmp_v);
343
344 // solve A*u_v = g_v
345 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
346 if(!status_success(_solver_a->apply(sol_v, tmp_v)))
347 {
348 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
349 return Status::aborted;
350 }
351
352 // okay
353 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::success, 0));
354 return Status::success;
355 }
356
357 // we should never come out here...
358 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
359 return Status::aborted;
360 }
361 }; // class UzawaPrecond<...>
362
368 template<
369 typename MatrixA_, typename MatrixB_, typename MatrixD_,
370 typename FilterV_, typename FilterP_,
371 typename MirrorV_, typename MirrorP_>
372 class UzawaPrecond
373 <
374 Global::Matrix<MatrixA_, MirrorV_, MirrorV_>,
375 Global::Matrix<MatrixB_, MirrorV_, MirrorP_>,
376 Global::Matrix<MatrixD_, MirrorP_, MirrorV_>,
377 Global::Filter<FilterV_, MirrorV_>,
378 Global::Filter<FilterP_, MirrorP_>
379 > :
380 public Solver::SolverBase<
381 Global::Vector<
382 LAFEM::TupleVector<
383 typename MatrixB_::VectorTypeL,
384 typename MatrixD_::VectorTypeL>,
385 LAFEM::TupleMirror<
386 MirrorV_,
387 MirrorP_>
388 >
389 >
390 {
391 public:
392 typedef LAFEM::SaddlePointMatrix<MatrixA_, MatrixB_, MatrixD_> LocalMatrixType;
393 typedef LAFEM::TupleFilter<FilterV_, FilterP_> LocalFilterType;
394 typedef LAFEM::TupleVector<typename MatrixB_::VectorTypeL, typename MatrixD_::VectorTypeL> LocalVectorType;
395 typedef LAFEM::TupleMirror<MirrorV_, MirrorP_> MirrorType;
396
397 typedef Global::Matrix<LocalMatrixType, MirrorType, MirrorType> GlobalMatrixType;
398 typedef Global::Filter<LocalFilterType, MirrorType> GlobalFilterType;
399 typedef Global::Vector<LocalVectorType, MirrorType> GlobalVectorType;
400
401 typedef typename GlobalVectorType::DataType DataType;
402
403 typedef Solver::SolverBase<GlobalVectorType> BaseClass;
404
405 typedef Global::Matrix<MatrixA_, MirrorV_, MirrorV_> GlobalMatrixTypeA;
406 typedef Global::Matrix<MatrixB_, MirrorV_, MirrorP_> GlobalMatrixTypeB;
407 typedef Global::Matrix<MatrixD_, MirrorP_, MirrorV_> GlobalMatrixTypeD;
408
409 typedef Global::Filter<FilterV_, MirrorV_> GlobalFilterTypeV;
410 typedef Global::Filter<FilterP_, MirrorP_> GlobalFilterTypeP;
411
412 typedef typename MatrixB_::VectorTypeL LocalVectorTypeV;
413 typedef typename MatrixD_::VectorTypeL LocalVectorTypeP;
414
415 typedef Global::Vector<LocalVectorTypeV, MirrorV_> GlobalVectorTypeV;
416 typedef Global::Vector<LocalVectorTypeP, MirrorP_> GlobalVectorTypeP;
417
418 typedef Global::Gate<LocalVectorTypeV, MirrorV_> GateTypeV;
419 typedef Global::Gate<LocalVectorTypeP, MirrorP_> GateTypeP;
420
421 typedef Solver::SolverBase<GlobalVectorTypeV> SolverA;
422 typedef Solver::SolverBase<GlobalVectorTypeP> SolverS;
423
424 protected:
425 const GlobalMatrixTypeA& _matrix_a;
426 const GlobalMatrixTypeB& _matrix_b;
427 const GlobalMatrixTypeD& _matrix_d;
428 const GlobalFilterTypeV& _filter_v;
429 const GlobalFilterTypeP& _filter_p;
430 GlobalVectorTypeV _vec_rhs_v, _vec_sol_v, _vec_def_v;
431 GlobalVectorTypeP _vec_rhs_p, _vec_sol_p, _vec_def_p;
432 std::shared_ptr<SolverA> _solver_a;
433 std::shared_ptr<SolverS> _solver_s;
434 UzawaType _uzawa_type;
435 const bool _auto_init_s;
436
437 public:
438 explicit UzawaPrecond(
439 const GlobalMatrixTypeA& matrix_a,
440 const GlobalMatrixTypeB& matrix_b,
441 const GlobalMatrixTypeD& matrix_d,
442 const GlobalFilterTypeV& filter_v,
443 const GlobalFilterTypeP& filter_p,
444 std::shared_ptr<SolverA> solver_a,
445 std::shared_ptr<SolverS> solver_s,
446 UzawaType type = UzawaType::diagonal,
447 bool auto_init_s = true
448 ) :
449 _matrix_a(matrix_a),
450 _matrix_b(matrix_b),
451 _matrix_d(matrix_d),
452 _filter_v(filter_v),
453 _filter_p(filter_p),
454 _solver_a(solver_a),
455 _solver_s(solver_s),
456 _uzawa_type(type),
457 _auto_init_s(auto_init_s)
458 {
459 }
460
461 virtual String name() const override
462 {
463 return "Uzawa";
464 }
465
466 virtual void init_symbolic() override
467 {
468 BaseClass::init_symbolic();
469 _solver_a->init_symbolic();
470 if(_auto_init_s)
471 {
472 _solver_s->init_symbolic();
473 }
474
475 _vec_rhs_v = _matrix_b.create_vector_l();
476 _vec_sol_v = _matrix_b.create_vector_l();
477 _vec_rhs_p = _matrix_d.create_vector_l();
478 _vec_sol_p = _matrix_d.create_vector_l();
479
480 if(_uzawa_type != UzawaType::diagonal)
481 {
482 _vec_def_v = _matrix_b.create_vector_l();
483 _vec_def_p = _matrix_d.create_vector_l();
484 }
485 }
486
487 virtual void init_numeric() override
488 {
489 BaseClass::init_numeric();
490 _solver_a->init_numeric();
491 if(_auto_init_s)
492 {
493 _solver_s->init_numeric();
494 }
495 }
496
497 virtual void done_numeric() override
498 {
499 if(_auto_init_s)
500 {
501 _solver_s->done_numeric();
502 }
503 _solver_a->done_numeric();
504 BaseClass::done_numeric();
505 }
506
507 virtual void done_symbolic() override
508 {
509 if(_uzawa_type != UzawaType::diagonal)
510 {
511 _vec_def_p.clear();
512 _vec_def_v.clear();
513 }
514 _vec_sol_p.clear();
515 _vec_rhs_p.clear();
516 _vec_sol_v.clear();
517 _vec_rhs_v.clear();
518 if(_auto_init_s)
519 {
520 _solver_s->done_symbolic();
521 }
522 _solver_a->done_symbolic();
523 BaseClass::done_symbolic();
524 }
525
526 virtual Status apply(GlobalVectorType& vec_cor, const GlobalVectorType& vec_def) override
527 {
528 Statistics::add_solver_expression(std::make_shared<ExpressionStartSolve>(this->name()));
529 // first of all, copy RHS
530 _vec_rhs_v.local().copy(vec_def.local().template at<0>());
531 _vec_rhs_p.local().copy(vec_def.local().template at<1>());
532
533 // now let's check the preconditioner type
534 switch(_uzawa_type)
535 {
536 case UzawaType::diagonal:
537 // solve A*u_v = f_v
538 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
539 if(!status_success(_solver_a->apply(_vec_sol_v, _vec_rhs_v)))
540 {
541 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
542 return Status::aborted;
543 }
544
545 // solve S*u_p = f_p
546 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaS>(this->name(), this->_solver_s->name()));
547 if(!status_success(_solver_s->apply(_vec_sol_p, _vec_rhs_p)))
548 {
549 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
550 return Status::aborted;
551 }
552
553 // okay
554 break;
555
556 case UzawaType::lower:
557 // solve A*u_v = f_v
558 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
559 if(!status_success(_solver_a->apply(_vec_sol_v, _vec_rhs_v)))
560 {
561 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
562 return Status::aborted;
563 }
564
565 // compute g_p := f_p - D*u_v
566 _matrix_d.apply(_vec_def_p, _vec_sol_v, _vec_rhs_p, -DataType(1));
567
568 // apply pressure defect filter
569 _filter_p.filter_def(_vec_def_p);
570
571 // solve S*u_p = g_p
572 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaS>(this->name(), this->_solver_s->name()));
573 if(!status_success(_solver_s->apply(_vec_sol_p, _vec_def_p)))
574 {
575 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
576 return Status::aborted;
577 }
578
579 // okay
580 break;
581
582 case UzawaType::upper:
583 // solve S*u_p = f_p
584 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaS>(this->name(), this->_solver_s->name()));
585 if(!status_success(_solver_s->apply(_vec_sol_p, _vec_rhs_p)))
586 {
587 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
588 return Status::aborted;
589 }
590
591 // compute g_v := f_v - B*u_p
592 _matrix_b.apply(_vec_def_v, _vec_sol_p, _vec_rhs_v, -DataType(1));
593
594 // apply velocity defect filter
595 _filter_v.filter_def(_vec_def_v);
596
597 // solve A*u_v = g_v
598 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
599 if(!status_success(_solver_a->apply(_vec_sol_v, _vec_def_v)))
600 {
601 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
602 return Status::aborted;
603 }
604
605 // okay
606 break;
607
608 case UzawaType::full:
609 // Note: We will use the first component of the solution vector here.
610 // It will be overwritten by the third solution step below.
611 // solve A*u_v = f_v
612 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
613 if(!status_success(_solver_a->apply(_vec_sol_v, _vec_rhs_v)))
614 {
615 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
616 return Status::aborted;
617 }
618
619 // compute g_p := f_p - D*u_v
620 _matrix_d.apply(_vec_def_p, _vec_sol_v, _vec_rhs_p, -DataType(1));
621
622 // apply pressure defect filter
623 _filter_p.filter_def(_vec_def_p);
624
625 // solve S*u_p = g_p
626 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaS>(this->name(), this->_solver_s->name()));
627 if(!status_success(_solver_s->apply(_vec_sol_p, _vec_def_p)))
628 {
629 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
630 return Status::aborted;
631 }
632
633 // compute g_v := f_v - B*u_p
634 _matrix_b.apply(_vec_def_v, _vec_sol_p, _vec_rhs_v, -DataType(1));
635
636 // apply velocity defect filter
637 _filter_v.filter_def(_vec_def_v);
638
639 // solve A*u_v = g_v
640 Statistics::add_solver_expression(std::make_shared<ExpressionCallUzawaA>(this->name(), this->_solver_a->name()));
641 if(!status_success(_solver_a->apply(_vec_sol_v, _vec_def_v)))
642 {
643 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::aborted, 0));
644 return Status::aborted;
645 }
646
647 // okay
648 break;
649 }
650
651 // finally, copy sol
652 vec_cor.local().template at<0>().copy(_vec_sol_v.local());
653 vec_cor.local().template at<1>().copy(_vec_sol_p.local());
654
655 // okay
656 Statistics::add_solver_expression(std::make_shared<ExpressionEndSolve>(this->name(), Status::success, 0));
657 return Status::success;
658 }
659 }; // class UzawaPrecond<...>
660
685 template<typename MatrixA_, typename MatrixB_, typename MatrixD_, typename FilterV_, typename FilterP_>
686 inline std::shared_ptr<UzawaPrecond<MatrixA_, MatrixB_, MatrixD_, FilterV_, FilterP_>> new_uzawa_precond(
687 const MatrixA_& matrix_a, const MatrixB_& matrix_b, const MatrixD_& matrix_d,
688 const FilterV_& filter_v, const FilterP_& filter_p,
689 std::shared_ptr<SolverBase<typename MatrixB_::VectorTypeL>> solver_a,
690 std::shared_ptr<SolverBase<typename MatrixD_::VectorTypeL>> solver_s,
691 UzawaType type = UzawaType::diagonal,
692 bool auto_init_s = true)
693 {
694 return std::make_shared<UzawaPrecond<MatrixA_, MatrixB_, MatrixD_, FilterV_, FilterP_>>
695 (matrix_a, matrix_b, matrix_d, filter_v, filter_p, solver_a, solver_s, type, auto_init_s);
696 }
697 } // namespace Solver
698} // namespace FEAT
XASSERTM
#define XASSERTM(expr, msg)
Assertion macro definition with custom message.
Definition: assertion.hpp:263
FEAT::Global::Filter
Global Filter wrapper class template.
Definition: filter.hpp:21
FEAT::Global::Gate
Global gate implementation.
Definition: gate.hpp:51
FEAT::Global::Matrix
Global Matrix wrapper class template.
Definition: matrix.hpp:40
FEAT::Global::Matrix::create_vector_l
VectorTypeL create_vector_l() const
Creates and returns a new L-compatible global vector object.
Definition: matrix.hpp:197
FEAT::Global::Matrix::apply
void apply(VectorTypeL &r, const VectorTypeR &x) const
Performs a matrix-vector multiplication: r <- A*x.
Definition: matrix.hpp:311
FEAT::Global::Vector
Global vector wrapper class template.
Definition: vector.hpp:68
FEAT::Global::Vector::local
LocalVector_ & local()
Returns a reference to the internal local LAFEM vector object.
Definition: vector.hpp:122
FEAT::Global::Vector::clear
void clear()
Clears the underlying vector.
Definition: vector.hpp:293
FEAT::LAFEM::SaddlePointMatrix
Saddle-Point matrix meta class template.
Definition: saddle_point_matrix.hpp:66
FEAT::LAFEM::TupleFilter
TupleVector meta-filter class template.
Definition: tuple_filter.hpp:34
FEAT::LAFEM::TupleMirror
TupleVector meta-mirror class template.
Definition: tuple_mirror.hpp:31
FEAT::LAFEM::TupleVector
Variadic TupleVector class template.
Definition: tuple_vector.hpp:34
FEAT::Solver::SolverBase
Polymorphic solver interface.
Definition: base.hpp:183
FEAT::Solver::SolverBase::init_symbolic
virtual void init_symbolic()
Symbolic initialization method.
Definition: base.hpp:227
FEAT::Solver::SolverBase::init_numeric
virtual void init_numeric()
Numeric initialization method.
Definition: base.hpp:237
FEAT::Solver::SolverBase::done_symbolic
virtual void done_symbolic()
Symbolic finalization method.
Definition: base.hpp:255
FEAT::Solver::SolverBase::done_numeric
virtual void done_numeric()
Numeric finalization method.
Definition: base.hpp:246
FEAT::Solver::UzawaPrecond< Global::Matrix< MatrixA_, MirrorV_, MirrorV_ >, Global::Matrix< MatrixB_, MirrorV_, MirrorP_ >, Global::Matrix< MatrixD_, MirrorP_, MirrorV_ >, Global::Filter< FilterV_, MirrorV_ >, Global::Filter< FilterP_, MirrorP_ > >::init_symbolic
virtual void init_symbolic() override
Symbolic initialization method.
Definition: uzawa_precond.hpp:466
FEAT::Solver::UzawaPrecond< Global::Matrix< MatrixA_, MirrorV_, MirrorV_ >, Global::Matrix< MatrixB_, MirrorV_, MirrorP_ >, Global::Matrix< MatrixD_, MirrorP_, MirrorV_ >, Global::Filter< FilterV_, MirrorV_ >, Global::Filter< FilterP_, MirrorP_ > >::name
virtual String name() const override
Returns a descriptive string.
Definition: uzawa_precond.hpp:461
FEAT::Solver::UzawaPrecond< Global::Matrix< MatrixA_, MirrorV_, MirrorV_ >, Global::Matrix< MatrixB_, MirrorV_, MirrorP_ >, Global::Matrix< MatrixD_, MirrorP_, MirrorV_ >, Global::Filter< FilterV_, MirrorV_ >, Global::Filter< FilterP_, MirrorP_ > >::done_symbolic
virtual void done_symbolic() override
Symbolic finalization method.
Definition: uzawa_precond.hpp:507
FEAT::Solver::UzawaPrecond< Global::Matrix< MatrixA_, MirrorV_, MirrorV_ >, Global::Matrix< MatrixB_, MirrorV_, MirrorP_ >, Global::Matrix< MatrixD_, MirrorP_, MirrorV_ >, Global::Filter< FilterV_, MirrorV_ >, Global::Filter< FilterP_, MirrorP_ > >::done_numeric
virtual void done_numeric() override
Numeric finalization method.
Definition: uzawa_precond.hpp:497
FEAT::Solver::UzawaPrecond< Global::Matrix< MatrixA_, MirrorV_, MirrorV_ >, Global::Matrix< MatrixB_, MirrorV_, MirrorP_ >, Global::Matrix< MatrixD_, MirrorP_, MirrorV_ >, Global::Filter< FilterV_, MirrorV_ >, Global::Filter< FilterP_, MirrorP_ > >::init_numeric
virtual void init_numeric() override
Numeric initialization method.
Definition: uzawa_precond.hpp:487
FEAT::Solver::UzawaPrecond
Uzawa preconditioner.
Definition: uzawa_precond.hpp:78
FEAT::Solver::UzawaPrecond::done_symbolic
virtual void done_symbolic() override
Symbolic finalization method.
Definition: uzawa_precond.hpp:209
FEAT::Solver::UzawaPrecond::UzawaPrecond
UzawaPrecond(const MatrixA_ &matrix_a, const MatrixB_ &matrix_b, const MatrixD_ &matrix_d, const FilterV_ &filter_v, const FilterP_ &filter_p, std::shared_ptr< SolverA > solver_a, std::shared_ptr< SolverS > solver_s, UzawaType type=UzawaType::diagonal, bool auto_init_s=true)
Constructs a Uzawa preconditioner.
Definition: uzawa_precond.hpp:139
FEAT::Solver::UzawaPrecond::DataType
MatrixA_::DataType DataType
our data type
Definition: uzawa_precond.hpp:81
FEAT::Solver::UzawaPrecond::_vec_tmp_v
VectorTypeV _vec_tmp_v
a temporary defect vector
Definition: uzawa_precond.hpp:112
FEAT::Solver::UzawaPrecond::VectorType
LAFEM::TupleVector< VectorTypeV, VectorTypeP > VectorType
system vector type
Definition: uzawa_precond.hpp:87
FEAT::Solver::UzawaPrecond::_uzawa_type
UzawaType _uzawa_type
our Uzawa type
Definition: uzawa_precond.hpp:108
FEAT::Solver::UzawaPrecond::SolverS
SolverBase< VectorTypeP > SolverS
S-block solver type.
Definition: uzawa_precond.hpp:94
FEAT::Solver::UzawaPrecond::_filter_v
const FilterV_ & _filter_v
our system filter
Definition: uzawa_precond.hpp:101
FEAT::Solver::UzawaPrecond::name
virtual String name() const override
Returns a descriptive string.
Definition: uzawa_precond.hpp:167
FEAT::Solver::UzawaPrecond::BaseClass
SolverBase< VectorType > BaseClass
base-class typedef
Definition: uzawa_precond.hpp:89
FEAT::Solver::UzawaPrecond::_solver_a
std::shared_ptr< SolverA > _solver_a
our A-block solver
Definition: uzawa_precond.hpp:104
FEAT::Solver::UzawaPrecond::VectorTypeP
MatrixD_::VectorTypeL VectorTypeP
pressure vector type
Definition: uzawa_precond.hpp:85
FEAT::Solver::UzawaPrecond::VectorTypeV
MatrixB_::VectorTypeL VectorTypeV
velocity vector type
Definition: uzawa_precond.hpp:83
FEAT::Solver::UzawaPrecond::init_numeric
virtual void init_numeric() override
Numeric initialization method.
Definition: uzawa_precond.hpp:189
FEAT::Solver::UzawaPrecond::_solver_s
std::shared_ptr< SolverS > _solver_s
our S-block solver
Definition: uzawa_precond.hpp:106
FEAT::Solver::UzawaPrecond::init_symbolic
virtual void init_symbolic() override
Symbolic initialization method.
Definition: uzawa_precond.hpp:172
FEAT::Solver::UzawaPrecond::done_numeric
virtual void done_numeric() override
Numeric finalization method.
Definition: uzawa_precond.hpp:199
FEAT::Solver::UzawaPrecond::_auto_init_s
const bool _auto_init_s
auto-initialize of S-solver
Definition: uzawa_precond.hpp:110
FEAT::Solver::UzawaPrecond::SolverA
SolverBase< VectorTypeV > SolverA
A-block solver type.
Definition: uzawa_precond.hpp:92
FEAT::String
String class implementation.
Definition: string.hpp:47
FEAT::Solver::status_success
bool status_success(Status status)
Status success check function.
Definition: base.hpp:108
FEAT::Solver::new_uzawa_precond
std::shared_ptr< UzawaPrecond< MatrixA_, MatrixB_, MatrixD_, FilterV_, FilterP_ > > new_uzawa_precond(const MatrixA_ &matrix_a, const MatrixB_ &matrix_b, const MatrixD_ &matrix_d, const FilterV_ &filter_v, const FilterP_ &filter_p, std::shared_ptr< SolverBase< typename MatrixB_::VectorTypeL > > solver_a, std::shared_ptr< SolverBase< typename MatrixD_::VectorTypeL > > solver_s, UzawaType type=UzawaType::diagonal, bool auto_init_s=true)
Creates a new UzawaPrecond solver object.
Definition: uzawa_precond.hpp:686
FEAT::Solver::Status
Status
Solver status return codes enumeration.
Definition: base.hpp:47
FEAT::Solver::Status::success
@ success
solving successful (convergence criterion fulfilled)
FEAT::Solver::Status::aborted
@ aborted
premature abort (solver aborted due to internal errors or preconditioner failure)
FEAT::Solver::UzawaType
UzawaType
Uzawa preconditioner type.
Definition: uzawa_precond.hpp:29
FEAT::Solver::UzawaType::upper
@ upper
upper-diagonal Uzawa preconditioner
FEAT::Solver::UzawaType::lower
@ lower
lower-diagonal Uzawa preconditioner
FEAT::Solver::UzawaType::diagonal
@ diagonal
diagonal Uzawa preconditioner
FEAT::Solver::UzawaType::full
@ full
full Uzawa preconditioner
FEAT
FEAT namespace.
Definition: adjactor.hpp:12