PetscSolverFeti.h 8.29 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ==  http://www.amdis-fem.org                                              ==
// ==                                                                        ==
// ============================================================================
//
// Software License for AMDiS
//
// Copyright (c) 2010 Dresden University of Technology 
// All rights reserved.
// Authors: Simon Vey, Thomas Witkowski et al.
//
// This file is part of AMDiS
//
// See also license.opensource.txt in the distribution.



/** \file PetscSolverFeti.h */

23
24
#include <map>
#include "parallel/MpiHelper.h"
25
#include "parallel/PetscSolver.h"
26
#include "parallel/PetscSolverFetiStructs.h"
27
#include "parallel/ParallelDofMapping.h"
28
#include "parallel/ParallelTypes.h"
29
#include "parallel/SubDomainSolver.h"
30
31
32
33
34
35
36
37

#ifndef AMDIS_PETSC_SOLVER_FETI_H
#define AMDIS_PETSC_SOLVER_FETI_H

namespace AMDiS {

  using namespace std;

38
39
40
  /** \brief
   * FETI-DP implementation based on PETSc.
   */
41
42
43
  class PetscSolverFeti : public PetscSolver
  {
  public:
44
    PetscSolverFeti();
45

46
47
48
49
50
51
    /// Assemble the sequentially created matrices to the global matrices
    /// required by the FETI-DP method.
    void fillPetscMatrix(Matrix<DOFMatrix*> *mat);

    /// Assembles the global rhs vectors from the sequentially created ones.
    void fillPetscRhs(SystemVector *vec);
52

53
    /// Solve the system using FETI-DP method.
54
    void solvePetscMatrix(SystemVector &vec, AdaptInfo *adaptInfo);
55

56
57
58
    /// Destroys all matrix data structures.
    void destroyMatrixData();

59
60
    /// Returns flags to denote which information of the boundary DOFs are 
    /// required by the FETI-DP solver.
61
62
63
64
65
66
67
    Flag getBoundaryDofRequirement()
    {
      return 
	MeshDistributor::BOUNDARY_SUBOBJ_SORTED |
	MeshDistributor::BOUNDARY_FILL_INFO_SEND_DOFS |
	MeshDistributor::BOUNDARY_FILL_INFO_RECV_DOFS;
    }
68

Thomas Witkowski's avatar
Thomas Witkowski committed
69
70
    void solveLocalProblem(Vec &rhs, Vec &sol);

71
  protected:
72
73
74
    /// After mesh changes, or if the solver is called the first time, this
    /// function creates all matrix and vector objects with the approriated
    /// sizes.
75
    void updateDofData();
76

77
78
    /// Defines which boundary nodes are primal. Creates global index of
    /// the primal variables.
79
    void createPrimals(const FiniteElemSpace *feSpace);
80

81
82
    /// Defines the set of dual variables and creates the global index of
    // dual variables.
83
    void createDuals(const FiniteElemSpace *feSpace);
84

85
86
    /// Create Lagrange multiplier variables corresponding to the dual 
    /// variables.
87
    void createLagrange(const FiniteElemSpace *feSpace);
88

89
    /// Creates a global index of the B variables.
90
    void createIndexB(const FiniteElemSpace *feSpace);
91

92
93
    /// Creates the Lagrange multiplier constraints and assembles them 
    /// to \ref mat_lagrange.
94
    void createMatLagrange(vector<const FiniteElemSpace*> &feSpaces);
95

96
97
    /// Creates PETSc KSP solver object for solving the Schur complement
    /// system on the primal variables, \ref ksp_schur_primal
98
    void createSchurPrimalKsp(vector<const FiniteElemSpace*> &feSpaces);
99

100
    /// Destroys PETSc KSP solver object \ref ksp_schur_primal
101
102
    void destroySchurPrimalKsp();

103
    /// Creates PETSc KSP solver object for the FETI-DP operator, \ref ksp_feti
104
    void createFetiKsp(vector<const FiniteElemSpace*> &feSpaces);
105

106
    /// Destroys FETI-DP operator, \ref ksp_feti
107
108
    void destroyFetiKsp();

109
110
111
112
113
114
115
116
117
118
119
120
121
122
    /** \brief
     * Recovers AMDiS solution vector from PETSc's solution vectors of the
     * FETI-DP system. First, the B variables can locally be copied to the
     * corresponding entries in the DOF vectors. The primal variable must
     * be communicated such that all ranks sharing a primal get a copy of
     * the corresponding value.
     *
     * \param[in]   vec_sol_b        Global PETSc vector of the solution of
     *                               the B variables.
     * \param[in]   vec_sol_primal   Global PETSc vector of the solution of
     *                               the primal variables.
     * \param[out]  vec              SystemVector containing all solution 
     *                               DOF vectors.
     */
123
124
125
126
    void recoverSolution(Vec &vec_sol_b,
			 Vec &vec_sol_primal,
			 SystemVector &vec);

Thomas Witkowski's avatar
Thomas Witkowski committed
127
128
129
130
131
132
133
134
135
    /** \brief
     * Solves the FETI-DP system globally, thus without reducing it to the 
     * Lagrange multipliers. This should be used for debugging only to test
     * if the FETI-DP system is setup correctly.
     *
     * \param[out]  vec    Solution DOF vectors.
     */
    void solveFetiMatrix(SystemVector &vec);

136
137
138
139
140
141
142
143
    /** \brief
     * Solves the FETI-DP system with reducing it first to the Lagrange
     * multipliers. This is what one expects when using the FETI-DP methid :)
     *
     * \param[out]  vec    Solution DOF vectors.
     */
    void solveReducedFetiMatrix(SystemVector &vec);

Thomas Witkowski's avatar
Thomas Witkowski committed
144
145
146
147
    void resetStatistics();

    void printStatistics();

148
    /// Checks whether a given DOF in a given FE space is a primal DOF.
149
150
151
152
153
    inline bool isPrimal(const FiniteElemSpace *feSpace, DegreeOfFreedom dof)
    {
      return primalDofMap[feSpace].isSet(dof);
    }

154
155
156
157
158
159
    /// Checks whether a given DOF in a give FE space is a dual DOF.
    inline bool isDual(const FiniteElemSpace *feSpace, DegreeOfFreedom dof)
    {
      return dualDofMap[feSpace].isSet(dof);
    }

160
  protected:
161
    /// Mapping from primal DOF indices to a global index of primals.
Thomas Witkowski's avatar
Thomas Witkowski committed
162
    ParallelDofMapping primalDofMap;
163

164
    /// Mapping from dual DOF indices to a global index of duals.
Thomas Witkowski's avatar
Thomas Witkowski committed
165
    ParallelDofMapping dualDofMap;
166

167
168
    /// Stores to each dual DOF index the index of the first Lagrange
    /// constraint that is assigned to this DOF.
Thomas Witkowski's avatar
Thomas Witkowski committed
169
    ParallelDofMapping lagrangeMap;
170
    
171
    /// Index for each non primal DOF to the global index of B variables.
Thomas Witkowski's avatar
Thomas Witkowski committed
172
    ParallelDofMapping localDofMap;
173

174
175
    /// Mapping of pure local DOF indices, thus no primal and no dual DOFs are
    /// in this map. Is used for the Dirichlet preconditioner only.
Thomas Witkowski's avatar
Thomas Witkowski committed
176
    ParallelDofMapping interiorDofMap;
177
178
179
180

    /// Stores to each dual boundary DOF in each finite elment space the set of
    /// ranks in which the DOF is contained in.
    map<const FiniteElemSpace*, DofIndexToPartitions> boundaryDofRanks;
181

182
    /// Global PETSc matrix of non primal variables.
183
184
    Mat mat_b_b;

185
    /// Global PETSc matrix of primal variables.
186
187
    Mat mat_primal_primal;

188
189
    /// Global PETSc matrices that connect the primal with the non 
    /// primal variables.
190
191
    Mat mat_b_primal, mat_primal_b;

192
    /// Global PETSc matrix of Lagrange variables.
193
194
    Mat mat_lagrange;

195
    /// Right hand side PETSc vectors for primal and non primal variables.
196
197
    Vec f_b, f_primal;

198
199
    /// PETSc solver object that inverts the matrix of non primal 
    /// variables, \ref mat_b_b
200
201
    KSP ksp_b;

Thomas Witkowski's avatar
Thomas Witkowski committed
202
203
204
205
206
    /// 0: Solve the Schur complement on primal variables with iterative solver.
    /// 1: Create the Schur complement matrix explicitly and solve it with a
    ///    direct solver.
    int schurPrimalSolver;

207
208
    /// PETSc solver object to solve the Schur complement on the 
    /// primal variables.
209
210
    KSP ksp_schur_primal;

211
212
    /// Matrix object that defines a matrix-free implementation for the action
    /// of the Schur complement on the primal variables.
213
214
    Mat mat_schur_primal;

215
    /// Data for MatMult operation in matrix \ref mat_schur_primal
216
    SchurPrimalData schurPrimalData;
217

218
    /// PETSc solver object to solve a system with FETI-DP.    
219
220
    KSP ksp_feti;

221
222
    /// Matrix object that defines a matrix-free implementation for the action
    /// of the FETI-DP operator.
223
    Mat mat_feti;
224

225
    /// Data for MatMult operation in matrix \ref mat_feti
226
    FetiData fetiData;
227

228
229
230
231
232
233
    /// Defines which preconditioner should be used to solve the reduced
    /// FETI-DP system.
    FetiPreconditioner fetiPreconditioner;

    /// Preconditioner object for the reduced FETI-DP system.
    PC precon_feti;
234
235
236

    Mat mat_lagrange_scaled;
   
237
    FetiDirichletPreconData fetiDirichletPreconData;
238

239
    FetiLumpedPreconData fetiLumpedPreconData;
240

241
    Mat mat_interior_interior, mat_duals_duals, mat_interior_duals, mat_duals_interior;
242
243

    KSP ksp_interior;
244
245
246
247

    bool multiLevelTest;

    SubDomainSolver *subDomainSolver;
248
  };
249

250
251
252
}

#endif