Sheet 7

sheet7/jacobi.template/jacsolve.h

@@ -0,0 +1,154 @@
+#ifndef JACSOLVE_FILE
+#define JACSOLVE_FILE
+#include "geom.h"
+#include "getmatrix.h"
+#include <vector>
+
+
+/**
+ * Solves linear system of equations  K @p u = @p f  via the Jacobi iteration.
+ * We use a distributed symmetric  CSR matrix @p SK and initial guess of the
+ * solution is set to 0.
+ * @param[in] SK	CSR matrix
+ * @param[in] f		distributed local vector storing the right hand side
+ * @param[out] u	accumulated local vector storing the solution.
+*/
+void JacobiSolve(CRS_Matrix const &SK, std::vector<double> const &f, std::vector<double> &u);
+
+
+/**
+ * Solves linear system of equations  K @p u = @p f  via the Jacobi iteration.
+ * We use a distributed symmetric  CSR matrix @p SK and initial guess of the
+ * solution is set to 0.
+ *
+ * In each smoothing step: @f$ \widehat{u} := u + \omega D^{-1}\left({f-K*u}\right) @f$
+ *
+ * @param[in]  SK	CSR matrix
+ * @param[in]  f	distributed local vector storing the right hand side
+ * @param[out] u	accumulated local vector storing the solution.
+ * @param[in,out] r	auxiliary local vector.
+ * @param[in] nsmooth	number of smoothing steps.
+ * @param[in] omega	relaxation parameter.
+ * @param[in] zero	initial solution @p u is assumed to be zero.
+*/
+void JacobiSmoother(Matrix const &SK, std::vector<double> const &f, std::vector<double> &u,
+                    std::vector<double> & r, int nsmooth=1, double const omega=1.0, bool zero=false);
+
+/**
+ * @brief Simple diagonale preconditioning.
+ *
+ * The residuum @p r scaled by the inverse diagonal of matríx @p SK results in the correction @p w.
+ *
+ * @f$ w :=  \omega D^{-1}*r @f$
+ *
+ * @param[in]  SK	matrix
+ * @param[in]  r	distributed local vector storing the residuum
+ * @param[out] w	accumulated local vector storing the correction.
+ * @param[in] omega	relaxation parameter.
+*/
+void DiagPrecond(Matrix const &SK, std::vector<double> const &r, std::vector<double> &w,
+                 double const omega=1.0);
+
+
+
+/**
+ * @brief The Multigrid hierarchy including meshes, vectors and matrices, prolongations is stored.
+*/
+class Multigrid
+{
+    public:
+       /**
+		 * Generates the mesh hierachy with @p nlevel meshes starting from coarse mesh @p cmesg .
+         *
+         * The refined meshes are generated by edge bisection.
+         * All memory is allocated but stiffness matrices are yet not calculated
+		 *
+		 * @param[in] cmesh	  initial coarse mesh
+		 * @param[in] nlevel  number of meshes in hierarchy, including the initial coarse mesh
+		 *
+		*/
+       Multigrid(Mesh const& cmesh, int nlevel);
+
+       Multigrid(Multigrid const&)            = delete;
+       Multigrid& operator=(Multigrid const&) = delete;
+
+       ~Multigrid();
+
+       /**
+		 * @return  Number of meshes in hierarchy.
+		 */
+       size_t Nlevels() const
+       {return _meshes.size(); }
+
+       /**
+		 * @return  Number of Unknowns.
+		 */
+       int Ndofs() const
+       {return _meshes[Nlevels()-1].Nnodes(); }
+
+       /**
+		 * @return  Meshes number @p lev .
+		*/
+       Mesh const& GetMesh(int lev) const
+       { return _meshes[lev]; }
+
+       /**
+		 * @return  Solution vector at level @p lev .
+		 */
+       std::vector<double> const&  GetSolution(int lev) const
+       { return _u.at(lev); }
+
+       /**
+		 * Calculates PDE matrices for all levels.
+		 */
+       void DefineOperators();
+
+       /**
+		 * Calculates PDE matrix for level @p lev.
+         *
+         * @param[in] lev  level in hierachy
+		 */
+       void DefineOperator(size_t lev);
+
+       /**
+		 * Solves the system of equations at level @p lev via Jacobi iterations
+         *
+         * @param[in] lev  level in hierachy
+		 */
+       void JacobiSolve(size_t lev);
+
+      /**
+		 * Peformes one multigrid step at level @p lev .
+         *
+         * @param[in] lev         level in hierachy
+         * @param[in] pre_smooth  number of pre/post-smoothing sweeps
+         * @param[in] bzero       start with zero-vector as solution
+         * @param[in] nu          defines the multigrid cycle (1/2 = V/W)
+		 */
+       void MG_Step(size_t lev, int pre_smooth=1, bool const bzero=false, int nu=1);
+
+      /**
+		 * Solves the system of equations at finest level via multigrid
+         *
+         * @param[in] pre_smooth  number of pre/post-smoothing sweeps
+         * @param[in] eps         stopping criteria (relative error)
+         * @param[in] nu          defines the multigrid cycle (1/2 = V/W)
+		 */
+       void MG_Solve(int pre_smooth=1, double eps=1e-6, int nu=1);
+
+
+    private:
+       gMesh_Hierarchy _meshes;                //!< mesh hierarchy from coarse (level 0) to fine.
+       std::vector<FEM_Matrix>           _SK;  //!< Sparse matrix on each level.
+       std::vector<std::vector<double>>  _u;   //!< Solution vector on each level.
+       std::vector<std::vector<double>>  _f;   //!< Right hand side vector on each level.
+       std::vector<std::vector<double>>  _d;   //!< Defect vector on each level.
+       std::vector<std::vector<double>>  _w;   //!< Correction vector on each level.
+       std::vector<BisectIntDirichlet> _Pc2f;  //!< Interpolation to level from next coarser level.
+
+};
+
+
+
+
+#endif