Debian Codegraph @

python/test/unit/la/test_slepc_solver.py

raw
1 """Unit tests for the KrylovSolver interface"""
2
3 # Copyright (C) 2016 Nate Sime
4 #
5 # This file is part of DOLFIN.
6 #
7 # DOLFIN is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU Lesser General Public License as published by
9 # the Free Software Foundation, either version 3 of the License, or
10 # (at your option) any later version.
11 #
12 # DOLFIN is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU Lesser General Public License for more details.
16 #
17 # You should have received a copy of the GNU Lesser General Public License
18 # along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
19
20 import pytest
21 from dolfin import *
22 from dolfin_utils.test import skip_if_not_PETsc_or_not_slepc, fixture
23
24 # Stiffness and mass bilinear formulations
25
26 def k(u, v):
27 return inner(grad(u), grad(v))*dx
28
29 def m(u, v):
30 return dot(u, v)*dx
31
32 # Wrappers around SLEPcEigenSolver for test_slepc_eigensolver_gen_hermitian
33 def SLEPcEigenSolverOperatorsFromInit(K, M):
34 return SLEPcEigenSolver(K, M)
35
36 def SLEPcEigenSolverOperatorsFromSetOperators(K, M):
37 slepc_eigen_solver = SLEPcEigenSolver(K.mpi_comm())
38 slepc_eigen_solver.set_operators(K, M)
39 return slepc_eigen_solver
40
41 # Fixtures
42
43 @fixture
44 def mesh():
45 return UnitSquareMesh(8, 8)
46
47 @fixture
48 def V(mesh):
49 return FunctionSpace(mesh, "CG", 1)
50
51 @fixture
52 def V_vec(mesh):
53 return VectorFunctionSpace(mesh, "CG", 1)
54
55 @fixture
56 def K_M(V):
57 u, v = TrialFunction(V), TestFunction(V)
58 K_mat, M_mat = PETScMatrix(), PETScMatrix()
59 x0 = PETScVector()
60 L = Constant(0.0)*v*dx
61 assemble_system(k(u, v), L, bcs=[], A_tensor=K_mat, b_tensor=x0)
62 assemble_system(m(u, v), L, bcs=[], A_tensor=M_mat, b_tensor=x0)
63 return K_mat, M_mat
64
65 @fixture
66 def K_M_vec(V_vec):
67 u, v = TrialFunction(V_vec), TestFunction(V_vec)
68 K_mat, M_mat = PETScMatrix(), PETScMatrix()
69 x0 = PETScVector()
70 L = dot(Constant([0.0]*V_vec.mesh().geometry().dim()), v)*dx
71 assemble_system(k(u, v), L, bcs=[], A_tensor=K_mat, b_tensor=x0)
72 assemble_system(m(u, v), L, bcs=[], A_tensor=M_mat, b_tensor=x0)
73 return K_mat, M_mat
74
75
76 # Tests
77
78 @skip_if_not_PETsc_or_not_slepc
79 def test_set_from_options():
80 "Test SLEPc options prefixes"
81
82 prefix = "my_slepc_"
83 solver = SLEPcEigenSolver(MPI.comm_world)
84 solver.set_options_prefix(prefix)
85 solver.set_from_options()
86
87 assert solver.get_options_prefix() == prefix
88
89 @skip_if_not_PETsc_or_not_slepc
90 @pytest.mark.parametrize("SLEPcEigenSolverWrapper", (SLEPcEigenSolverOperatorsFromInit, SLEPcEigenSolverOperatorsFromSetOperators))
91 def test_slepc_eigensolver_gen_hermitian(K_M, SLEPcEigenSolverWrapper):
92 "Test SLEPc eigen solver"
93
94 K, M = K_M
95 esolver = SLEPcEigenSolverWrapper(K, M)
96
97 esolver.parameters["solver"] = "krylov-schur"
98 esolver.parameters["spectral_transform"] = 'shift-and-invert'
99 esolver.parameters['spectral_shift'] = 0.5
100 esolver.parameters["problem_type"] = "gen_hermitian"
101
102 nevs = 10
103 esolver.solve(nevs)
104
105 # Test default eigenvalue
106 re_0, im_0 = esolver.get_eigenvalue(0)
107 assert near(re_0, 0.0, eps=1e-12)
108 assert near(im_0, 0.0)
109
110 re_0, im_0, v_re_0, v_im_0 = esolver.get_eigenpair(0)
111 assert near(re_0, 0.0, eps=1e-12)
112 assert near(im_0, 0.0)
113 assert v_re_0.norm("l2") > 0.0
114 assert near(v_im_0.norm("l2"), 0.0)
115
116 # Test remaining eigenvalues and eigenpairs
117 for j in range(1, nevs):
118 re, im = esolver.get_eigenvalue(j)
119 assert re > 0.0
120 assert near(im, 0.0)
121
122 for j in range(1, nevs):
123 re, im, v_re, v_im = esolver.get_eigenpair(j)
124 assert re > 0.0
125 assert near(im, 0.0)
126 assert v_re.norm("l2") > 0.0
127 assert near(v_im.norm("l2"), 0.0)
128
129
130 @skip_if_not_PETsc_or_not_slepc
131 def test_slepc_null_space(K_M, V):
132 "Test SLEPc eigen solver with nullspace as PETScVector"
133
134 K, M = K_M
135 esolver = SLEPcEigenSolver(K, M)
136
137 esolver.parameters["solver"] = "jacobi-davidson"
138 esolver.parameters["problem_type"] = "gen_hermitian"
139
140 u0 = Function(V)
141 nullspace_basis = as_backend_type(u0.vector().copy())
142 V.dofmap().set(nullspace_basis, 1.0)
143 esolver.set_deflation_space(VectorSpaceBasis([nullspace_basis]))
144
145 nevs = 10
146 esolver.solve(nevs)
147
148 phi_re, phi_im = Function(V), Function(V)
149
150 for j in range(1, nevs):
151 re, im, v_re, v_im = esolver.get_eigenpair(j)
152 assert re > 0.0
153 assert near(im, 0.0)
154 assert v_re.norm("l2") > 0.0
155 assert near(v_im.norm("l2"), 0.0)
156
157 esolver.get_eigenpair(phi_re.vector(), phi_im.vector(), j)
158 assert near(v_re.norm("l2"), phi_re.vector().norm("l2"))
159 assert near(v_im.norm("l2"), phi_im.vector().norm("l2"))
160
161
162 @skip_if_not_PETsc_or_not_slepc
163 def test_slepc_vector_null_space(K_M_vec, V_vec):
164 "Test SLEPc eigen solver with nullspace as VectorSpaceBasis"
165
166 def build_nullspace(V, x):
167 nullspace_basis = [x.copy() for i in range(2)]
168
169 V.sub(0).dofmap().set(nullspace_basis[0], 1.0)
170 V.sub(1).dofmap().set(nullspace_basis[1], 1.0)
171
172 for x in nullspace_basis:
173 x.apply("insert")
174
175 # Create vector space basis and orthogonalize
176 basis = VectorSpaceBasis(nullspace_basis)
177 basis.orthonormalize()
178
179 return basis
180
181 K, M = K_M_vec
182 esolver = SLEPcEigenSolver(K, M)
183
184 esolver.parameters["solver"] = "jacobi-davidson"
185 esolver.parameters["problem_type"] = "gen_hermitian"
186
187 u0 = Function(V_vec)
188 nullspace_basis = build_nullspace(V_vec, u0.vector())
189 esolver.set_deflation_space(nullspace_basis)
190
191 nevs = 10
192 esolver.solve(nevs)
193
194 phi_re, phi_im = Function(V_vec), Function(V_vec)
195
196 for j in range(1, nevs):
197 re, im, v_re, v_im = esolver.get_eigenpair(j)
198 assert re > 0.0
199 assert near(im, 0.0)
200 assert v_re.norm("l2") > 0.0
201 assert near(v_im.norm("l2"), 0.0)
202
203 esolver.get_eigenpair(phi_re.vector(), phi_im.vector(), j)
204 assert near(v_re.norm("l2"), phi_re.vector().norm("l2"))
205 assert near(v_im.norm("l2"), phi_im.vector().norm("l2"))
206
207 @skip_if_not_PETsc_or_not_slepc
208 def test_slepc_initial_space(K_M, V):
209 "Test SLEPc eigen solver with inital space as PETScVector"
210
211 K, M = K_M
212 esolver = SLEPcEigenSolver(K, M)
213
214 esolver.parameters["solver"] = "jacobi-davidson"
215 esolver.parameters["problem_type"] = "gen_hermitian"
216
217 u0 = as_backend_type(interpolate(Constant(2.0), V).vector())
218 esolver.set_initial_space(VectorSpaceBasis([u0]))
219
220 nevs = 10
221 esolver.solve(nevs)
222
223 phi_re, phi_im = Function(V), Function(V)
224
225 for j in range(1, nevs):
226 re, im, v_re, v_im = esolver.get_eigenpair(j)
227 assert re > 0.0
228 assert near(im, 0.0)
229 assert v_re.norm("l2") > 0.0
230 assert near(v_im.norm("l2"), 0.0)
231
232 esolver.get_eigenpair(phi_re.vector(), phi_im.vector(), j)
233 assert near(v_re.norm("l2"), phi_re.vector().norm("l2"))
234 assert near(v_im.norm("l2"), phi_im.vector().norm("l2"))
235
236
237 @skip_if_not_PETsc_or_not_slepc
238 def test_slepc_vector_initial_space(K_M_vec, V_vec):
239 "Test SLEPc eigen solver with initial space as VectorSpaceBasis"
240
241 K, M = K_M_vec
242 esolver = SLEPcEigenSolver(K, M)
243
244 esolver.parameters["solver"] = "jacobi-davidson"
245 esolver.parameters["problem_type"] = "gen_hermitian"
246
247 u0 = as_backend_type(interpolate(Constant((2.0, 1.0)), V_vec).vector())
248 u1 = as_backend_type(interpolate(Constant((0.0, -4.0)), V_vec).vector())
249 initial_space = VectorSpaceBasis([u0, u1])
250 esolver.set_initial_space(initial_space)
251
252 nevs = 10
253 esolver.solve(nevs)
254
255 phi_re, phi_im = Function(V_vec), Function(V_vec)
256
257 for j in range(1, nevs):
258 re, im, v_re, v_im = esolver.get_eigenpair(j)
259 assert re > 0.0
260 assert near(im, 0.0)
261 assert v_re.norm("l2") > 0.0
262 assert near(v_im.norm("l2"), 0.0)
263
264 esolver.get_eigenpair(phi_re.vector(), phi_im.vector(), j)
265 assert near(v_re.norm("l2"), phi_re.vector().norm("l2"))
266 assert near(v_im.norm("l2"), phi_im.vector().norm("l2"))