def test(filename, control_values):
# read the mesh
this_path = os.path.dirname(os.path.realpath(__file__))
filename = os.path.join(this_path, filename)
mesh, point_data, field_data, _ = meshplex.read(filename)
mu = 1.0e-2
# build the model evaluator
modeleval = modelevaluator_nls.NlsModelEvaluator(
mesh, V=point_data["V"], A=point_data["A"]
)
# compute the Ginzburg-Landau residual
psi = point_data["psi"][:, 0] + 1j * point_data["psi"][:, 1]
r = modeleval.compute_f(psi, mu, 1.0)
# scale with D for compliance with the Nosh (C++) tests
if mesh.control_volumes is None:
mesh.compute_control_volumes()
r *= mesh.control_volumes.reshape(r.shape)
tol = 1.0e-13
# For C++ Nosh compatibility:
# Compute 1-norm of vector (Re(psi[0]), Im(psi[0]), Re(psi[1]), ... )
alpha = numpy.linalg.norm(r.real, ord=1) + numpy.linalg.norm(r.imag, ord=1)
assert abs(control_values[0] - alpha) < tol
assert abs(control_values[1] - numpy.linalg.norm(r, ord=2)) < tol
# For C++ Nosh compatibility:
# Compute inf-norm of vector (Re(psi[0]), Im(psi[0]), Re(psi[1]), ... )
alpha = max(
numpy.linalg.norm(r.real, ord=numpy.inf),
numpy.linalg.norm(r.imag, ord=numpy.inf),
)
assert abs(control_values[2] - alpha) < tol
return
def test_mark_subdomain2d():
filename = download_mesh("pacman.msh", "2da8ff96537f844a95a83abb48471b6a")
mesh, _, _, _ = meshplex.read(filename)
class Subdomain1(object):
is_boundary_only = True
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] < 0.0
class Subdomain2(object):
is_boundary_only = False
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] > 0.0
sd1 = Subdomain1()
vertex_mask = mesh.get_vertex_mask(sd1)
assert vertex_mask.sum() == 27
face_mask = mesh.get_face_mask(sd1)
assert face_mask.sum() == 26
cell_mask = mesh.get_cell_mask(sd1)
assert cell_mask.sum() == 0
sd2 = Subdomain2()
vertex_mask = mesh.get_vertex_mask(sd2)
assert vertex_mask.sum() == 214
face_mask = mesh.get_face_mask(sd2)
assert face_mask.sum() == 1137
cell_mask = mesh.get_cell_mask(sd2)
assert cell_mask.sum() == 371
return
def test(filename, control_values):
this_path = os.path.dirname(os.path.realpath(__file__))
filename = os.path.join(this_path, filename)
mu = 1.0e-2
# read the mesh
mesh, point_data, field_data, _ = meshplex.read(filename)
# build the model evaluator
modeleval = modelevaluator_nls.NlsModelEvaluator(mesh,
V=point_data["V"],
A=point_data["A"])
# Assemble the KEO.
keo = modeleval._get_keo(mu)
tol = 1.0e-13
# Check that the matrix is Hermitian.
KK = keo - keo.H
assert abs(KK.sum()) < tol
# Check the matrix sum.
assert abs(control_values[0] - keo.sum()) < tol
# Check the 1-norm of the matrix |Re(K)| + |Im(K)|.
# This equals the 1-norm of the matrix defined by the block
# structure
# Re(K) -Im(K)
# Im(K) Re(K).
K = abs(keo.real) + abs(keo.imag)
assert abs(control_values[1] - numpy.max(K.sum(0))) < tol
return
def test_mark_subdomain2d():
mesh = meshplex.read(this_dir / "meshes" / "pacman.vtu")
class Subdomain1:
is_boundary_only = True
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] < 0.0
class Subdomain2:
is_boundary_only = False
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] > 0.0
sd1 = Subdomain1()
vertex_mask = mesh.get_vertex_mask(sd1)
assert vertex_mask.sum() == 45
face_mask = mesh.get_face_mask(sd1)
assert face_mask.sum() == 44
cell_mask = mesh.get_cell_mask(sd1)
assert cell_mask.sum() == 0
sd2 = Subdomain2()
vertex_mask = mesh.get_vertex_mask(sd2)
assert vertex_mask.sum() == 395
face_mask = mesh.get_face_mask(sd2)
assert face_mask.sum() == 2148
cell_mask = mesh.get_cell_mask(sd2)
assert cell_mask.sum() == 706
def test_mark_subdomain3d():
filename = download_mesh("tetrahedron.msh",
"27a5d7e102e6613a1e58629c252cb293")
mesh, _, _, _ = meshplex.read(filename)
class Subdomain1(object):
is_boundary_only = True
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] < 0.5
class Subdomain2(object):
is_boundary_only = False
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] > 0.5
sd1 = Subdomain1()
vertex_mask = mesh.get_vertex_mask(sd1)
assert vertex_mask.sum() == 16
face_mask = mesh.get_face_mask(sd1)
assert face_mask.sum() == 20
cell_mask = mesh.get_cell_mask(sd1)
assert cell_mask.sum() == 0
sd2 = Subdomain2()
vertex_mask = mesh.get_vertex_mask(sd2)
assert vertex_mask.sum() == 10
face_mask = mesh.get_face_mask(sd2)
assert face_mask.sum() == 25
cell_mask = mesh.get_cell_mask(sd2)
assert cell_mask.sum() == 5
return
def test_keo(filename, control_values):
filename = download_mesh(filename)
mu = 1.0e-2
# read the mesh
mesh, point_data, field_data, _ = meshplex.read(filename)
keo = pyfvm.get_fvm_matrix(mesh, edge_kernels=[Energy(mu)])
tol = 1.0e-13
# Check that the matrix is Hermitian.
KK = keo - keo.H
assert abs(KK.sum()) < tol
# Check the matrix sum.
assert abs(control_values[0] - keo.sum()) < tol
# Check the 1-norm of the matrix |Re(K)| + |Im(K)|.
# This equals the 1-norm of the matrix defined by the block
# structure
# Re(K) -Im(K)
# Im(K) Re(K).
K = abs(keo.real) + abs(keo.imag)
assert abs(control_values[1] - numpy.max(K.sum(0))) < tol
return
def _main():
args = _parse_input_arguments()
# read the mesh
print("Reading the mesh...")
mesh, _, _, _ = meshplex.read(args.filename)
print("done.")
# Hardcode V, A
n = mesh.node_coords.shape[0]
X = mesh.node_coords.T
A = 0.5 * np.column_stack([-X[1], X[0], np.zeros(n)])
point_data = {"V": -np.ones(n), "A": A}
# build the model evaluator
modeleval = gm.NlsModelEvaluator(mesh,
V=point_data["V"],
A=point_data["A"])
mu_range = np.linspace(args.mu_range[0], args.mu_range[1],
args.num_parameter_steps)
print("Looking for solutions for mu in")
print(mu_range)
print()
find_beautiful_states(modeleval, mu_range, args.forcing_term)
return
def test(filename, control_values):
# read the mesh
this_path = os.path.dirname(os.path.realpath(__file__))
filename = os.path.join(this_path, filename)
mesh, point_data, field_data, _ = meshplex.read(filename)
mu = 1.0e-2
# build the model evaluator
modeleval = modelevaluator_nls.NlsModelEvaluator(mesh,
V=point_data["V"],
A=point_data["A"])
# compute the Ginzburg-Landau residual
psi = point_data["psi"][:, 0] + 1j * point_data["psi"][:, 1]
r = modeleval.compute_f(psi, mu, 1.0)
# scale with D for compliance with the Nosh (C++) tests
if mesh.control_volumes is None:
mesh.compute_control_volumes()
r *= mesh.control_volumes.reshape(r.shape)
tol = 1.0e-13
# For C++ Nosh compatibility:
# Compute 1-norm of vector (Re(psi[0]), Im(psi[0]), Re(psi[1]), ... )
alpha = numpy.linalg.norm(r.real, ord=1) + numpy.linalg.norm(r.imag, ord=1)
assert abs(control_values[0] - alpha) < tol
assert abs(control_values[1] - numpy.linalg.norm(r, ord=2)) < tol
# For C++ Nosh compatibility:
# Compute inf-norm of vector (Re(psi[0]), Im(psi[0]), Re(psi[1]), ... )
alpha = max(
numpy.linalg.norm(r.real, ord=numpy.inf),
numpy.linalg.norm(r.imag, ord=numpy.inf),
)
assert abs(control_values[2] - alpha) < tol
return
def test_mark_subdomain3d():
filename = download_mesh("tetrahedron.vtk", "10f3ccd1642b634b22741894fe6e7f1f")
mesh = meshplex.read(filename)
class Subdomain1(object):
is_boundary_only = True
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] < 0.5
class Subdomain2(object):
is_boundary_only = False
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] > 0.5
sd1 = Subdomain1()
vertex_mask = mesh.get_vertex_mask(sd1)
assert vertex_mask.sum() == 16
face_mask = mesh.get_face_mask(sd1)
assert face_mask.sum() == 20
cell_mask = mesh.get_cell_mask(sd1)
assert cell_mask.sum() == 0
sd2 = Subdomain2()
vertex_mask = mesh.get_vertex_mask(sd2)
assert vertex_mask.sum() == 10
face_mask = mesh.get_face_mask(sd2)
assert face_mask.sum() == 25
cell_mask = mesh.get_cell_mask(sd2)
assert cell_mask.sum() == 5
return
def test_mark_subdomain2d():
filename = download_mesh("pacman.vtk", "c621cb22f8b87cecd77724c2c0601c36")
mesh = meshplex.read(filename)
class Subdomain1(object):
is_boundary_only = True
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] < 0.0
class Subdomain2(object):
is_boundary_only = False
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] > 0.0
sd1 = Subdomain1()
vertex_mask = mesh.get_vertex_mask(sd1)
assert vertex_mask.sum() == 27
face_mask = mesh.get_face_mask(sd1)
assert face_mask.sum() == 26
cell_mask = mesh.get_cell_mask(sd1)
assert cell_mask.sum() == 0
sd2 = Subdomain2()
vertex_mask = mesh.get_vertex_mask(sd2)
assert vertex_mask.sum() == 214
face_mask = mesh.get_face_mask(sd2)
assert face_mask.sum() == 1137
cell_mask = mesh.get_cell_mask(sd2)
assert cell_mask.sum() == 371
return
def test(filename, control_values):
this_path = os.path.dirname(os.path.realpath(__file__))
filename = os.path.join(this_path, filename)
mu = 1.0e-2
# read the mesh
mesh, point_data, field_data, _ = meshplex.read(filename)
# build the model evaluator
modeleval = modelevaluator_nls.NlsModelEvaluator(
mesh, V=point_data["V"], A=point_data["A"]
)
# Assemble the KEO.
keo = modeleval._get_keo(mu)
tol = 1.0e-13
# Check that the matrix is Hermitian.
KK = keo - keo.H
assert abs(KK.sum()) < tol
# Check the matrix sum.
assert abs(control_values[0] - keo.sum()) < tol
# Check the 1-norm of the matrix |Re(K)| + |Im(K)|.
# This equals the 1-norm of the matrix defined by the block
# structure
# Re(K) -Im(K)
# Im(K) Re(K).
K = abs(keo.real) + abs(keo.imag)
assert abs(control_values[1] - numpy.max(K.sum(0))) < tol
return
def test_keo(filename, control_values):
filename = download_mesh(filename)
mu = 1.0e-2
# read the mesh
mesh = meshplex.read(filename)
keo = pyfvm.get_fvm_matrix(mesh, edge_kernels=[Energy(mu)])
tol = 1.0e-13
# Check that the matrix is Hermitian.
KK = keo - keo.H
assert abs(KK.sum()) < tol
# Check the matrix sum.
assert abs(control_values[0] - keo.sum()) < tol
# Check the 1-norm of the matrix |Re(K)| + |Im(K)|.
# This equals the 1-norm of the matrix defined by the block
# structure
# Re(K) -Im(K)
# Im(K) Re(K).
K = abs(keo.real) + abs(keo.imag)
assert abs(control_values[1] - numpy.max(K.sum(0))) < tol
return
def test_show_vertex():
filename = download_mesh("pacman-optimized.vtk",
"5036d9ce5307caa0d9de80cba7ba1c4c")
mesh = meshplex.read(filename)
# mesh.plot_vertex(125)
mesh.show_vertex(125)
return
def test_mark_subdomain3d():
mesh = meshplex.read(this_dir / "meshes" / "tetrahedron.vtk")
class Subdomain1:
is_boundary_only = True
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] < 0.5
class Subdomain2:
is_boundary_only = False
# pylint: disable=no-self-use
def is_inside(self, x):
return x[0] > 0.5
sd1 = Subdomain1()
vertex_mask = mesh.get_vertex_mask(sd1)
assert vertex_mask.sum() == 16
face_mask = mesh.get_face_mask(sd1)
assert face_mask.sum() == 20
cell_mask = mesh.get_cell_mask(sd1)
assert cell_mask.sum() == 0
sd2 = Subdomain2()
vertex_mask = mesh.get_vertex_mask(sd2)
assert vertex_mask.sum() == 10
face_mask = mesh.get_face_mask(sd2)
assert face_mask.sum() == 25
cell_mask = mesh.get_cell_mask(sd2)
assert cell_mask.sum() == 5
def test_signed_volume():
filename = download_mesh("toy.msh", "1d125d3fa9f373823edd91ebae5f7a81")
mesh, _, _, _ = meshplex.read(filename)
vols = meshplex.get_signed_simplex_volumes(mesh.cells["nodes"], mesh.node_coords)
assert numpy.all(abs(abs(vols) - mesh.cell_volumes) < 1.0e-12 * mesh.cell_volumes)
return
def test_get_edges():
filename = download_mesh("pacman.msh", "2da8ff96537f844a95a83abb48471b6a")
mesh, _, _, _ = meshplex.read(filename)
mesh.create_edges()
edge_mask = mesh.get_edge_mask()
edge_nodes = mesh.edges["nodes"][edge_mask]
assert len(edge_nodes) == 1276
return
def test_show_mesh():
filename = download_mesh("pacman-optimized.vtk",
"5036d9ce5307caa0d9de80cba7ba1c4c")
mesh = meshplex.read(filename)
print(mesh) # test __repr__
# mesh.plot(show_axes=False)
mesh.show(show_axes=False,
cell_quality_coloring=("viridis", 0.0, 1.0, True))
def test_get_edges():
filename = download_mesh("pacman.vtk", "c621cb22f8b87cecd77724c2c0601c36")
mesh = meshplex.read(filename)
mesh.create_edges()
edge_mask = mesh.get_edge_mask()
edge_nodes = mesh.edges["nodes"][edge_mask]
assert len(edge_nodes) == 1276
return
def test_sphere():
mesh = meshplex.read(this_dir / "meshes" / "sphere.vtk")
run(
mesh,
12.273645818711595,
[1.0177358705967492, 0.10419690304323895],
[366.3982135866799, 1.7062353589387327],
[0.72653362732751214, 0.05350373815413411],
)
def test_sphere():
filename = download_mesh("sphere.vtk", "06b163871cc0f23344d71c990dffe577")
mesh = meshplex.read(filename)
run(
mesh,
12.273645818711595,
[1.0177358705967492, 0.10419690304323895],
[366.3982135866799, 1.7062353589387327],
[0.72653362732751214, 0.05350373815413411],
)
def test_tetrahedron():
mesh = meshplex.read(this_dir / "meshes" / "tetrahedron.vtk")
run(
mesh,
64.1500299099584,
[16.308991595922095, 7.0264329635751395],
[6.898476155562041, 0.34400453539215237],
[11.571692332290635, 2.9699087921277054],
)
def test_signed_volume():
filename = download_mesh("toy.vtk", "f48abda972822bab224b91a74d695573")
mesh = meshplex.read(filename)
vols = meshplex.get_signed_simplex_volumes(mesh.cells["nodes"],
mesh.node_coords)
assert numpy.all(
abs(abs(vols) - mesh.cell_volumes) < 1.0e-12 * mesh.cell_volumes)
return
def test_pacman():
mesh = meshplex.read(this_dir / ".." / "meshes" / "pacman.vtu")
run(
mesh,
54.312974717523744,
[1.9213504740523146, 0.07954185111555329],
[403.5307055719196, 0.5512267577002408],
[1.3816992621175055, 0.0443755870238773],
)
assert mesh.num_delaunay_violations == 0
def test_pacman():
mesh = meshplex.read(this_dir / "meshes" / "pacman.vtk")
run(
mesh,
73.64573933105898,
[3.596101914906618, 0.26638548094154696],
[379.275476266239, 1.2976923100235962],
[2.6213234038171014, 0.13841739494523228],
)
assert mesh.num_delaunay_violations() == 0
def test_tetrahedron():
filename = download_mesh("tetrahedron.msh", "27a5d7e102e6613a1e58629c252cb293")
mesh, _, _, _ = meshplex.read(filename)
run(
mesh,
64.1500299099584,
[16.308991595922095, 7.0264329635751395],
[6.898476155562041, 0.34400453539215237],
[11.571692332290635, 2.9699087921277054],
)
return
def test_jacobian(filename, control_values):
filename = download_mesh(filename)
mu = 1.0e-2
mesh = meshplex.read(filename)
m2 = meshio.read(filename)
psi = m2.point_data["psi"][:, 0] + 1j * m2.point_data["psi"][:, 1]
V = -1.0
g = 1.0
keo = pyfvm.get_fvm_matrix(mesh, edge_kernels=[Energy(mu)])
def jacobian(psi):
def _apply_jacobian(phi):
cv = mesh.control_volumes
y = keo * phi / cv + alpha * phi + gPsi0Squared * phi.conj()
return y
alpha = V + g * 2.0 * (psi.real**2 + psi.imag**2)
gPsi0Squared = g * psi**2
num_unknowns = len(mesh.node_coords)
return pykry.LinearOperator(
(num_unknowns, num_unknowns),
complex,
dot=_apply_jacobian,
dot_adj=_apply_jacobian,
)
# Get the Jacobian
J = jacobian(psi)
tol = 1.0e-12
num_unknowns = psi.shape[0]
# [1+i, 1+i, 1+i, ... ]
phi = numpy.full(num_unknowns, 1 + 1j)
val = numpy.vdot(phi, mesh.control_volumes * (J * phi)).real
assert abs(control_values[0] - val) < tol
# [1, 1, 1, ... ]
phi = numpy.full(num_unknowns, 1.0, dtype=complex)
val = numpy.vdot(phi, mesh.control_volumes * (J * phi)).real
assert abs(control_values[1] - val) < tol
# [i, i, i, ... ]
phi = numpy.full(num_unknowns, 1j, dtype=complex)
val = numpy.vdot(phi, mesh.control_volumes * (J * phi)).real
assert abs(control_values[2] - val) < tol
return
def test_sphere():
filename = download_mesh("sphere.msh", "70a5dbf79c3b259ed993458ff4aa2e93")
mesh, _, _, _ = meshplex.read(filename)
run(
mesh,
12.273645818711595,
[1.0177358705967492, 0.10419690304323895],
[366.3982135866799, 1.7062353589387327],
[0.72653362732751214, 0.05350373815413411],
)
# assertEqual(mesh.num_delaunay_violations(), 60)
return
def test_tetrahedron():
filename = download_mesh("tetrahedron.vtk",
"10f3ccd1642b634b22741894fe6e7f1f")
mesh = meshplex.read(filename)
run(
mesh,
64.1500299099584,
[16.308991595922095, 7.0264329635751395],
[6.898476155562041, 0.34400453539215237],
[11.571692332290635, 2.9699087921277054],
)
return
def test_pacman():
filename = download_mesh("pacman.vtk", "c621cb22f8b87cecd77724c2c0601c36")
mesh = meshplex.read(filename)
run(
mesh,
73.64573933105898,
[3.596101914906618, 0.26638548094154696],
[379.275476266239, 1.2976923100235962],
[2.6213234038171014, 0.13841739494523228],
)
assert mesh.num_delaunay_violations() == 0
def test_jacobian(filename, control_values):
filename = download_mesh(filename)
mu = 1.0e-2
mesh, point_data, field_data, _ = meshplex.read(filename)
psi = point_data["psi"][:, 0] + 1j * point_data["psi"][:, 1]
V = -1.0
g = 1.0
keo = pyfvm.get_fvm_matrix(mesh, edge_kernels=[Energy(mu)])
def jacobian(psi):
def _apply_jacobian(phi):
cv = mesh.control_volumes
y = keo * phi / cv + alpha * phi + gPsi0Squared * phi.conj()
return y
alpha = V + g * 2.0 * (psi.real ** 2 + psi.imag ** 2)
gPsi0Squared = g * psi ** 2
num_unknowns = len(mesh.node_coords)
return pykry.LinearOperator(
(num_unknowns, num_unknowns),
complex,
dot=_apply_jacobian,
dot_adj=_apply_jacobian,
)
# Get the Jacobian
J = jacobian(psi)
tol = 1.0e-12
num_unknowns = psi.shape[0]
# [1+i, 1+i, 1+i, ... ]
phi = numpy.full(num_unknowns, 1 + 1j)
val = numpy.vdot(phi, mesh.control_volumes * (J * phi)).real
assert abs(control_values[0] - val) < tol
# [1, 1, 1, ... ]
phi = numpy.full(num_unknowns, 1.0, dtype=complex)
val = numpy.vdot(phi, mesh.control_volumes * (J * phi)).real
assert abs(control_values[1] - val) < tol
# [i, i, i, ... ]
phi = numpy.full(num_unknowns, 1j, dtype=complex)
val = numpy.vdot(phi, mesh.control_volumes * (J * phi)).real
assert abs(control_values[2] - val) < tol
return
def test_io_2d():
vertices, cells = meshzoo.rectangle_tri(np.linspace(0.0, 1.0, 3),
np.linspace(0.0, 1.0, 3))
mesh = meshplex.MeshTri(vertices, cells)
# mesh = meshplex.read('pacman.vtu')
assert mesh.num_delaunay_violations == 0
# mesh.show(show_axes=False, boundary_edge_color="g")
# mesh.show_vertex(0)
with tempfile.TemporaryDirectory() as tmpdir:
mesh.write(tmpdir + "test.vtk")
mesh2 = meshplex.read(tmpdir + "test.vtk")
assert np.all(mesh.cells("points") == mesh2.cells("points"))
def test_pacman():
filename = download_mesh("pacman.msh", "2da8ff96537f844a95a83abb48471b6a")
mesh, _, _, _ = meshplex.read(filename)
run(
mesh,
73.64573933105898,
[3.596101914906618, 0.26638548094154696],
[379.275476266239, 1.2976923100235962],
[2.6213234038171014, 0.13841739494523228],
)
assert mesh.num_delaunay_violations() == 0
return
def test_io_2d():
vertices, cells = meshzoo.rectangle(0.0, 1.0, 0.0, 1.0, 2, 2)
mesh = meshplex.MeshTri(vertices, cells)
# mesh = meshplex.read('pacman.vtu')
assert mesh.num_delaunay_violations() == 0
# mesh.show(show_axes=False, boundary_edge_color="g")
# mesh.show_vertex(0)
_, fname = tempfile.mkstemp(suffix=".vtk")
mesh.write(fname)
mesh2 = meshplex.read(fname)
for k in range(len(mesh.cells["nodes"])):
assert tuple(mesh.cells["nodes"][k]) == tuple(mesh2.cells["nodes"][k])
def _main():
"""Main function.
"""
args = _parse_input_arguments()
# Setting the default file_mvp.
if args.file_mvp is None:
args.file_mvp = args.filename
# Read the magnetic vector potential.
mesh, point_data, field_data = meshplex.read(args.file_mvp)
# build the model evaluator
print(("Creating model evaluator...", ))
start = time.time()
num_coords = len(mesh.node_coords)
nls_modeleval = pynosh.modelevaluator_nls.NlsModelEvaluator(
mesh,
V=-np.ones(num_coords),
A=point_data["A"],
preconditioner_type=args.preconditioner_type,
num_amg_cycles=args.num_amg_cycles,
)
if args.bordering:
modeleval = pynosh.bordered_modelevaluator.BorderedModelEvaluator(
nls_modeleval)
else:
modeleval = nls_modeleval
end = time.time()
print(("done. (%gs)" % (end - start)))
# Run through all time steps.
assert len(args.timesteps) == len(
args.mu), ("There must be as many time steps as mus (%d != %d)." %
(len(args.timesteps), len(args.mu)))
for (timestep, mu) in zip(args.timesteps, args.mu):
relresvec = _solve_system(modeleval, args.filename, timestep, mu, args)
print("relresvec:")
print(relresvec)
print(("num iters:", len(relresvec) - 1))
if args.show_relres:
pp.semilogy(relresvec, "k")
pp.show()
return
def _main():
"""Main function.
"""
args = _parse_input_arguments()
# Setting the default file_mvp.
if args.file_mvp is None:
args.file_mvp = args.filename
# Read the magnetic vector potential.
mesh, point_data, field_data = meshplex.read(args.file_mvp)
# build the model evaluator
print(("Creating model evaluator...",))
start = time.time()
num_coords = len(mesh.node_coords)
nls_modeleval = pynosh.modelevaluator_nls.NlsModelEvaluator(
mesh,
V=-np.ones(num_coords),
A=point_data["A"],
preconditioner_type=args.preconditioner_type,
num_amg_cycles=args.num_amg_cycles,
)
if args.bordering:
modeleval = pynosh.bordered_modelevaluator.BorderedModelEvaluator(nls_modeleval)
else:
modeleval = nls_modeleval
end = time.time()
print(("done. (%gs)" % (end - start)))
# Run through all time steps.
assert len(args.timesteps) == len(args.mu), (
"There must be as many time steps as mus (%d != %d)."
% (len(args.timesteps), len(args.mu))
)
for (timestep, mu) in zip(args.timesteps, args.mu):
relresvec = _solve_system(modeleval, args.filename, timestep, mu, args)
print("relresvec:")
print(relresvec)
print(("num iters:", len(relresvec) - 1))
if args.show_relres:
pp.semilogy(relresvec, "k")
pp.show()
return
def _run(filename, control_values):
"""Test $\int_{\Omega} A^2$."""
# read the mesh
mesh, _, _, _ = meshplex.read(filename)
if mesh.control_volumes is None:
mesh.compute_control_volumes()
tol = 1.0e-10
A = mvp.constant_field(mesh.node_coords, numpy.array([0, 0, 1]))
integral = numpy.sum(mesh.control_volumes * numpy.sum(A ** 2, axis=1))
assert numpy.all(numpy.abs(control_values["z"] - integral) < tol)
# If this is a 2D mesh, append the z-component 0 to each node
# to make sure that the magnetic vector potentials can be
# calculated.
points = mesh.node_coords.copy()
if points.shape[1] == 2:
points = numpy.column_stack((points, numpy.zeros(len(points))))
A = mvp.magnetic_dipole(
points, x0=numpy.array([0, 0, 10]), m=numpy.array([0, 0, 1])
)
integral = numpy.sum(mesh.control_volumes * numpy.sum(A ** 2, axis=1))
assert numpy.all(numpy.abs(control_values["dipole"] - integral) < tol)
# import time
# start = time.time()
A = mvp.magnetic_dot(mesh.node_coords, 2.0, [10.0, 11.0])
# A = numpy.empty((len(points), 3), dtype=float)
# for k, node in enumerate(points):
# A[k] = mvp.magnetic_dot(node[0], node[1], 2.0, 10.0, 11.0)
# end = time.time()
# print end-start
integral = numpy.sum(mesh.control_volumes * numpy.sum(A ** 2, axis=1))
assert numpy.all(numpy.abs(control_values["dot"] - integral) < tol)
return
def _main():
args = _parse_input_arguments()
# read the mesh
print("Reading the mesh...")
mesh, _, _, _ = meshplex.read(args.filename)
print("done.")
# Hardcode V, A
n = mesh.node_coords.shape[0]
X = mesh.node_coords.T
A = 0.5 * np.column_stack([-X[1], X[0], np.zeros(n)])
point_data = {"V": -np.ones(n), "A": A}
# build the model evaluator
modeleval = gm.NlsModelEvaluator(mesh, V=point_data["V"], A=point_data["A"])
mu_range = np.linspace(args.mu_range[0], args.mu_range[1], args.num_parameter_steps)
print("Looking for solutions for mu in")
print(mu_range)
print()
find_beautiful_states(modeleval, mu_range, args.forcing_term)
return
def test(filename, control_values):
# read the mesh
this_path = os.path.dirname(os.path.realpath(__file__))
filename = os.path.join(this_path, filename)
mu = 1.0e-2
mesh, point_data, field_data, _ = meshplex.read(filename)
psi = point_data["psi"][:, 0] + 1j * point_data["psi"][:, 1]
num_unknowns = len(psi)
psi = psi.reshape(num_unknowns, 1)
# build the model evaluator
modeleval = modelevaluator_nls.NlsModelEvaluator(
mesh, V=point_data["V"], A=point_data["A"]
)
# Get the Jacobian
J = modeleval.get_jacobian(psi, mu, 1.0)
tol = 1.0e-12
# [1+i, 1+i, 1+i, ... ]
phi = (1 + 1j) * numpy.ones((num_unknowns, 1), dtype=complex)
val = numpy.vdot(phi, mesh.control_volumes.reshape(phi.shape) * (J * phi)).real
assert abs(control_values[0] - val) < tol
# [1, 1, 1, ... ]
phi = numpy.ones((num_unknowns, 1), dtype=complex)
val = numpy.vdot(phi, mesh.control_volumes[:, None] * (J * phi)).real
assert abs(control_values[1] - val) < tol
# [i, i, i, ... ]
phi = 1j * numpy.ones((num_unknowns, 1), dtype=complex)
val = numpy.vdot(phi, mesh.control_volumes[:, None] * (J * phi)).real
assert abs(control_values[2] - val) < tol
return
def test_f(filename, control_values):
filename = download_mesh(filename)
mesh, point_data, field_data, _ = meshplex.read(filename)
mu = 1.0e-2
V = -1.0
g = 1.0
keo = pyfvm.get_fvm_matrix(mesh, edge_kernels=[Energy(mu)])
# compute the Ginzburg-Landau residual
psi = point_data["psi"][:, 0] + 1j * point_data["psi"][:, 1]
cv = mesh.control_volumes
# One divides by the control volumes here. No idea why this has been done in pynosh.
# Perhaps to make sure that even the small control volumes have a significant
# contribution to the residual?
r = keo * psi / cv + psi * (V + g * abs(psi) ** 2)
# scale with D for compliance with the Nosh (C++) tests
if mesh.control_volumes is None:
mesh.compute_control_volumes()
r *= mesh.control_volumes
tol = 1.0e-13
# For C++ Nosh compatibility:
# Compute 1-norm of vector (Re(psi[0]), Im(psi[0]), Re(psi[1]), ... )
alpha = numpy.linalg.norm(r.real, ord=1) + numpy.linalg.norm(r.imag, ord=1)
assert abs(control_values[0] - alpha) < tol
assert abs(control_values[1] - numpy.linalg.norm(r, ord=2)) < tol
# For C++ Nosh compatibility:
# Compute inf-norm of vector (Re(psi[0]), Im(psi[0]), Re(psi[1]), ... )
alpha = max(
numpy.linalg.norm(r.real, ord=numpy.inf),
numpy.linalg.norm(r.imag, ord=numpy.inf),
)
assert abs(control_values[2] - alpha) < tol
return
def _main():
# get the command line arguments
args = _parse_options()
# read the mesh
print("Reading mesh...", end=" ")
start = time.time()
mesh, point_data, field_data = meshplex.read(args.infile)
elapsed = time.time() - start
print("done. (%gs)" % elapsed)
num_nodes = len(mesh.node_coords)
# create values
if not args.force_override and "psi" in point_data:
psi = point_data["psi"]
else:
print("Creating psi...", end=" ")
start = time.time()
psi = np.empty(num_nodes, dtype=complex)
psi[:] = complex(1.0, 0.0)
# for k, node in enumerate(mesh.node_coords):
# import random, cmath
# psi[k] = cmath.rect( random.random(), 2.0 * pi * random.random() )
# psi[k] = 0.9 * np.cos(0.5 * node[0])
elapsed = time.time() - start
print("done. (%gs)" % elapsed)
if not args.force_override and "V" in point_data:
V = point_data["V"]
else:
# create values
print("Creating V...", end=" ")
start = time.time()
V = np.empty(num_nodes)
V[:] = -1.0
# for k, node in enumerate(mesh.node_coords):
# import random, cmath
# X[k] = cmath.rect( random.random(), 2.0 * pi * random.random() )
# X[k] = 0.9 * np.cos(0.5 * node[0])
elapsed = time.time() - start
print("done. (%gs)" % elapsed)
if not args.force_override and "A" in point_data:
A = point_data["A"]
else:
# If this is a 2D mesh, append the z-component 0 to each node
# to make sure that the magnetic vector potentials can be
# calculated.
points = mesh.node_coords.copy()
if points.shape[1] == 2:
points = np.column_stack((points, np.zeros(len(points))))
# Add magnetic vector potential.
print("Creating A...", end=" ")
start = time.time()
# A = points # field A(X) = X -- test case
import pynosh.magnetic_vector_potentials as mvp
# A = np.zeros((num_nodes,3))
# B = np.array([np.cos(theta) * np.cos(phi),
# np.cos(theta) * np.sin(phi),
# np.sin(theta)])
A = mvp.constant_field(points, np.array([0, 0, 1]))
# A = mvp.magnetic_dipole(points,
# x0 = np.array([0,0,2]),
# m = np.array([0,0,1])
# )
# A = mvp.magnetic_dot(points, radius=2.0, heights=[0.1, 1.1])
# A = np.empty((num_nodes, 3), dtype=float)
# for k, node in enumerate(points):
# A[k] = mvp.magnetic_dot(node, radius=2.0, height0=0.1, height1=1.1)
elapsed = time.time() - start
print("done. (%gs)" % elapsed)
# if 'thickness' in point_data:
# thickness = point_data['thickness']
# else:
# # Add values for thickness:
# thickness = np.empty(num_nodes, dtype = float)
# alpha = 0.5 # thickness at the center of the tube
# beta = 2.0 # thickness at the boundary
# t = (beta-alpha) / b**2
# for k, x in enumerate(mesh.nodes):
# thickness[k] = alpha + t * x[1]**2
# if not args.force_override and 'g' in field_data:
# g = field_data['g']
# else:
# g = 1.0
# if not args.force_override and 'mu' in field_data:
# mu = field_data['mu']
# else:
# mu = 1.0
# write the mesh
print("Writing mesh...", end=" ")
start = time.time()
mesh.write(
args.outfile,
point_data={"psi": psi, "V": V, "A": A},
# field_data={'g': g, 'mu': mu}
)
elapsed = time.time() - start
print("done. (%gs)" % elapsed)
return
def _main():
"""Main function.
"""
args = _parse_input_arguments()
# read the mesh
mesh, point_data, field_data = meshplex.read(args.filename, timestep=args.timestep)
num_nodes = len(mesh.node_coords)
if not args.mu is None:
mu = args.mu
print("Using mu=%g from command line." % mu)
elif "mu" in field_data:
mu = field_data["mu"]
else:
raise ValueError(
"Parameter " "mu" " not found in file. Please provide on command line."
)
if not args.g is None:
g = args.g
print("Using g=%g from command line." % g)
elif "g" in field_data:
g = field_data["g"]
else:
raise ValueError(
"Parameter " "g" " not found in file. Please provide on command line."
)
# build the model evaluator
nls_modeleval = nme.NlsModelEvaluator(
mesh=mesh,
V=point_data["V"],
A=point_data["A"],
preconditioner_type="exact",
num_amg_cycles=1,
)
psi0 = point_data["psi"][:, 0] + 1j * point_data["psi"][:, 1]
if args.bordering:
# Build bordered system.
x0 = np.empty(num_nodes + 1, dtype=complex)
x0[0:num_nodes] = psi0
x0[-1] = 0.0
# Use psi0 as initial bordering.
modeleval = bme.BorderedModelEvaluator(nls_modeleval)
else:
x0 = psi0
modeleval = nls_modeleval
if not args.series:
# compute the eigenvalues once
# p0 = 1j * psi0
# p0 /= np.sqrt(modeleval.inner_product(p0, p0))
# y0 = modeleval.get_jacobian(psi0) * p0
# print '||(ipsi) J (ipsi)|| =', np.linalg.norm(y0)
## Check with the rotation vector.
# grad_psi0 = mesh.compute_gradient(psi0)
# x_tilde = np.array( [-mesh.node_coords[:,1], mesh.node_coords[:,0]] ).T
# p1 = np.sum(x_tilde * grad_psi0, axis=1)
# mesh.write('test.e', point_data={'x grad': p1})
# nrm_p1 = np.sqrt(modeleval.inner_product(p1, p1))
# p1 /= nrm_p1
# y1 = modeleval.get_jacobian(psi0) * p1
# print '||(grad) J (grad)|| =', np.linalg.norm(y1)
# Check the equality
# grad(|psi|^2 psi) = 2 |psi|^2 grad(psi) + psi^2 grad(psi)*.
#
# p2 = mesh.compute_gradient(psi0 * abs(psi0)**2)
# gradPsi0 = mesh.compute_gradient(psi0)
# p2d = 2 * np.multiply(abs(psi0)**2, gradPsi0.T).T \
# + np.multiply(psi0**2, gradPsi0.conjugate().T).T
# mesh.write('diff.vtu',
# point_data = {'psi': psi0, 'p2': p2, 'p2d': p2d, 'diff': diff}
# )
# Check the equality
# grad(|psi|^2) = 2 Re(psi* grad(psi)).
#
# p2 = mesh.compute_gradient(abs(psi0)**2)
# p2d = 2 * np.multiply(psi0.conjugate(), mesh.compute_gradient(psi0).T).T.real
# diff = p2 - p2d
# mesh.write('diff.vtu',
# point_data = {'psi': psi0, 'p2': p2, 'p2d': p2d, 'diff': diff}
# )
# J = modeleval.get_jacobian(psi0)
# K = modeleval._keo
# x = np.random.rand(len(psi0))
# print 'x', np.linalg.norm(J*x - K*x/ mesh.control_volumes.reshape(x.shape))
eigenvals, X = _compute_eigenvalues(
args.operator,
args.eigenvalue_type,
args.num_eigenvalues,
None,
x0[:, None],
modeleval,
mu,
g,
)
print("The following eigenvalues were computed:")
print(sorted(eigenvals))
# Check residuals.
print("Residuals:")
for k in range(len(eigenvals)):
# Convert to complex representation.
z = X[0::2, k] + 1j * X[1::2, k]
z /= np.sqrt(modeleval.inner_product(z, z))
y0 = modeleval.get_jacobian(x0, mu, g) * z
print(np.linalg.norm(y0 - eigenvals[k] * z))
# Normalize and store all eigenvectors & values.
print("Storing corresponding eigenstates...", end=" ")
k = 0
for k in range(len(eigenvals)):
filename = "eigen%d.vtu" % k
# Convert to complex representation.
z = X[0::2, k] + 1j * X[1::2, k]
z /= np.sqrt(modeleval.inner_product(z, z))
mesh.write(
filename,
point_data={
"psi": point_data["psi"],
"A": point_data["A"],
"V": point_data["V"],
"eigen": z,
},
field_data={"g": g, "mu": mu, "eigenvalue": eigenvals[k]},
)
print("done.")
else:
# initial guess for the eigenvectors
X = np.ones((len(mesh.node_coords), 1))
# set the range of parameters
steps = 51
mus = np.linspace(0.0, 0.5, steps)
eigenvals_list = []
# small_eigenvals_approx = []
for mu in mus:
modeleval.set_parameter(mu)
eigenvals, X = _compute_eigenvalues(
args.operator,
args.eigenvalue_type,
args.num_eigenvalues,
X[:, 0],
modeleval,
mu,
g,
)
# small_eigenval, X = my_lobpcg( modeleval._keo,
# X,
# tolerance = 1.0e-5,
# maxiter = len(pynoshmesh.nodes),
# verbosity = 1
# )
# print 'Calculated values: ', small_eigenval
# alpha = modeleval.keo_smallest_eigenvalue_approximation()
# print 'Linear approximation: ', alpha
# small_eigenvals_approx.append( alpha )
# print
eigenvals_list.append(eigenvals)
# plot all the eigenvalues as balls
_plot_eigenvalue_series(mus, eigenvals_list)
# pp.legend()
pp.title("%s eigenvalues of %s" % (args.eigenvalue_type, args.operator))
# pp.ylim( ymin = 0.0 )
pp.xlabel("$\mu$")
pp.show()
# matplotlib2tikz.save('eigenvalues.tikz',
# figurewidth = '\\figurewidth',
# figureheight = '\\figureheight'
# )
return
def _main():
"""Main function.
"""
args = _parse_input_arguments()
mesh, point_data, field_data = meshplex.read(args.filename, timestep=args.timestep)
N = len(mesh.node_coords)
# build the model evaluator
nls_modeleval = pynosh.modelevaluator_nls.NlsModelEvaluator(
mesh,
V=-np.ones(N),
A=point_data["A"],
preconditioner_type=args.preconditioner_type,
num_amg_cycles=args.num_amg_cycles,
)
current_psi = np.random.rand(N, 1) + 1j * np.random.rand(N, 1)
if args.bordering:
modeleval = pynosh.bordered_modelevaluator.BorderedModelEvaluator(nls_modeleval)
# right hand side
x = np.empty((N + 1, 1), dtype=complex)
x[0:N] = current_psi
x[N] = 1.0
else:
modeleval = nls_modeleval
x = current_psi
print(("machine eps = %g" % np.finfo(np.complex).eps))
mu = args.mu
g = 1.0
# check the jacobian operator
J = modeleval.get_jacobian(x, mu, g)
print(
(
"max(|<v,Ju> - <Jv,u>|) = %g"
% _check_selfadjointness(J, modeleval.inner_product)
)
)
if args.preconditioner_type != "none":
# check the preconditioner
P = modeleval.get_preconditioner(x, mu, g)
print(
(
"max(|<v,Pu> - <Pv,u>|) = %g"
% _check_selfadjointness(P, modeleval.inner_product)
)
)
# Check positive definiteness of P.
print(
(
"min(<u,Pu>) = %g"
% _check_positivedefiniteness(P, modeleval.inner_product)
)
)
# check the inverse preconditioner
# Pinv = modeleval.get_preconditioner_inverse(x, mu, g)
# print('max(|<v,P^{-1}u> - <P^{-1}v,u>|) = %g'
# % _check_selfadjointness(Pinv, modeleval.inner_product
# )
# check positive definiteness of P^{-1}
# print('min(<u,P^{-1}u>) = %g'
# % _check_positivedefiniteness(Pinv, inner_product)
# )
return
def _main():
"""Main function.
"""
args = _parse_input_arguments()
# read the mesh
mesh, point_data, field_data = meshplex.read(args.filename, timestep=args.timestep)
# build the model evaluator
modeleval = pynosh.modelevaluator_nls.NlsModelEvaluator(
mesh=mesh, A=point_data["A"], V=point_data["V"], preconditioner_type="exact"
)
# set the range of parameters
steps = 10
mus = np.linspace(0.5, 5.5, steps)
num_unknowns = len(mesh.node_coords)
# initial guess for the eigenvectors
# psi = np.random.rand(num_unknowns) + 1j * np.random.rand(num_unknowns)
psi = np.ones(num_unknowns) # + 1j * np.ones(num_unknowns)
psi *= 0.5
# psi = 4.0 * 1.0j * np.ones(num_unknowns)
print(num_unknowns)
eigenvals_list = []
g = 10.0
for mu in mus:
if args.operator == "k":
# build dense KEO
A = modeleval._get_keo(mu).toarray()
B = None
elif args.operator == "p":
# build dense preconditioner
P = modeleval.get_preconditioner(psi, mu, g)
A = P.toarray()
B = None
elif args.operator == "j":
# build dense jacobian
J1, J2 = modeleval.get_jacobian_blocks(psi, mu, g)
A = _build_stacked_operator(J1.toarray(), J2.toarray())
B = None
elif args.operator == "kj":
J1, J2 = modeleval.get_jacobian_blocks(psi)
A = _build_stacked_operator(J1.toarray(), J2.toarray())
modeleval._assemble_keo()
K = _modeleval._keo
B = _build_stacked_operator(K.toarray())
elif args.operator == "pj":
J1, J2 = modeleval.get_jacobian_blocks(psi)
A = _build_stacked_operator(J1.toarray(), J2.toarray())
P = modeleval.get_preconditioner(psi)
B = _build_stacked_operator(P.toarray())
else:
raise ValueError("Unknown operator '", args.operator, "'.")
print("Compute eigenvalues for mu =", mu, "...")
# get smallesteigenvalues
start_time = time.clock()
# use eig as the problem is not symmetric (but it is self-adjoint)
eigenvals, U = eig(
A,
b=B,
# lower = True,
)
end_time = time.clock()
print("done. (", end_time - start_time, "s).")
# sort by ascending eigenvalues
assert norm(eigenvals.imag, np.inf) < 1.0e-14
eigenvals = eigenvals.real
sort_indices = np.argsort(eigenvals.real)
eigenvals = eigenvals[sort_indices]
U = U[:, sort_indices]
# rebuild complex-valued U
U_complex = _build_complex_vector(U)
# normalize
for k in range(U_complex.shape[1]):
norm_Uk = np.sqrt(
modeleval.inner_product(U_complex[:, [k]], U_complex[:, [k]])
)
U_complex[:, [k]] /= norm_Uk
## Compare the different expressions for the eigenvalues.
# for k in xrange(len(eigenvals)):
# JU_complex = J1 * U_complex[:,[k]] + J2 * U_complex[:,[k]].conj()
# uJu = modeleval.inner_product(U_complex[:,k], JU_complex)[0]
# PU_complex = P * U_complex[:,[k]]
# uPu = modeleval.inner_product(U_complex[:,k], PU_complex)[0]
# KU_complex = modeleval._keo * U_complex[:,[k]]
# uKu = modeleval.inner_product(U_complex[:,k], KU_complex)[0]
# # expression 1
# lambd = uJu / uPu
# assert abs(eigenvals[k] - lambd) < 1.0e-10, abs(eigenvals[k] - lambd)
# # expression 2
# alpha = modeleval.inner_product(U_complex[:,k]**2, psi**2)
# lambd = uJu / (-uJu + 1.0 - alpha)
# assert abs(eigenvals[k] - lambd) < 1.0e-10
# # expression 3
# alpha = modeleval.inner_product(U_complex[:,k]**2, psi**2)
# beta = modeleval.inner_product(abs(U_complex[:,k])**2, abs(psi)**2)
# lambd = -1.0 + (1.0-alpha) / (uKu + 2*beta)
# assert abs(eigenvals[k] - lambd) < 1.0e-10
# # overwrite for plotting
# eigenvals[k] = 1- alpha
eigenvals_list.append(eigenvals)
# plot the eigenvalues
# _plot_eigenvalue_series( mus, eigenvals_list )
for ev in eigenvals_list:
pp.plot(ev, ".")
# pp.plot( mus,
# small_eigenvals_approx,
# '--'
# )
# pp.legend()
pp.title("eigenvalues of %s" % args.operator)
# pp.ylim( ymin = 0.0 )
# pp.xlabel( '$\mu$' )
pp.show()
# matplotlib2tikz.save('eigenvalues.tikz',
# figurewidth = '\\figurewidth',
# figureheight = '\\figureheight'
# )
return
def _solve_system(modeleval, filename, timestep, mu, args):
# read the mesh
print(("Reading current psi...",))
start = time.time()
mesh, point_data, field_data = meshplex.read(filename, timestep=timestep)
total = time.time() - start
print(("done (%gs)." % total))
num_coords = len(mesh.node_coords)
# set psi at which to create the Jacobian
print(("Creating initial guess and right-hand side...",))
start = time.time()
current_psi = (point_data["psi"][:, 0] + 1j * point_data["psi"][:, 1]).reshape(
-1, 1
)
# Perturb a bit.
eps = 1.0e-10
perturbation = eps * (np.random.rand(num_coords) + 1j * np.random.rand(num_coords))
current_psi += perturbation.reshape(current_psi.shape)
if args.bordering:
phi0 = np.zeros((num_coords + 1, 1), dtype=complex)
# right hand side
x = np.empty((num_coords + 1, 1), dtype=complex)
x[0:num_coords] = current_psi
x[num_coords] = 0.0
else:
# create right hand side and initial guess
phi0 = np.zeros((num_coords, 1), dtype=complex)
x = current_psi
# right hand side
# rhs = np.ones( (num_coords,1), dtype=complex )
# rhs = np.empty( num_coords, dtype = complex )
# radius = np.random.rand( num_coords )
# arg = np.random.rand( num_coords ) * 2.0 * cmath.pi
# for k in range( num_coords ):
# rhs[ k ] = cmath.rect(radius[k], arg[k])
rhs = modeleval.compute_f(x=x, mu=mu, g=1.0)
end = time.time()
print(("done. (%gs)" % (end - start)))
print(("||rhs|| = %g" % np.sqrt(modeleval.inner_product(rhs, rhs))))
# create the linear operator
print(("Getting Jacobian...",))
start_time = time.clock()
jacobian = modeleval.get_jacobian(x=x, mu=mu, g=1.0)
end_time = time.clock()
print(("done. (%gs)" % (end_time - start_time)))
# create precondictioner object
print(("Getting preconditioner...",))
start_time = time.clock()
prec = modeleval.get_preconditioner_inverse(x=x, mu=mu, g=1.0)
end_time = time.clock()
print(("done. (%gs)" % (end_time - start_time)))
# Get reference solution
# print 'Get reference solution (dim = %d)...' % (2*num_coords),
# start_time = time.clock()
# ref_sol, info, relresvec, errorvec = nm.minres_wrap( jacobian, rhs,
# x0 = phi0,
# tol = 1.0e-14,
# M = prec,
# inner_product = modeleval.inner_product,
# explicit_residual = True
# )
# end_time = time.clock()
# if info == 0:
# print 'success!',
# else:
# print 'no convergence.',
# print ' (', end_time - start_time, 's,', len(relresvec)-1 ,' iters).'
if args.use_deflation:
W = 1j * x
AW = jacobian * W
P, x0new = nm.get_projection(
W, AW, rhs, phi0, inner_product=modeleval.inner_product
)
else:
# AW = np.zeros((len(current_psi),1), dtype=np.complex)
P = None
x0new = phi0
if args.krylov_method == "cg":
lin_solve = nm.cg
elif args.krylov_method == "minres":
lin_solve = nm.minres
# elif args.krylov_method == 'minresfo':
# lin_solve = nm.minres
# lin_solve_args.update({'full_reortho': True})
elif args.krylov_method == "gmres":
lin_solve = nm.gmres
else:
raise ValueError("Unknown Krylov solver " "%s" "." % args.krylov_method)
print(
(
"Solving the system (len(x) = %d, bordering: %r)..."
% (len(x), args.bordering),
)
)
start_time = time.clock()
timer = False
out = lin_solve(
jacobian,
rhs,
x0new,
tol=args.tolerance,
Mr=P,
M=prec,
# maxiter = 2*num_coords,
maxiter=500,
inner_product=modeleval.inner_product,
explicit_residual=True,
# timer=timer
# exact_solution = ref_sol
)
end_time = time.clock()
print(("done. (%gs)" % (end_time - start_time)))
print(("(%d,%d)" % (2 * num_coords, len(out["relresvec"]) - 1)))
# compute actual residual
# res = rhs - jacobian * out['xk']
# print '||b-Ax|| = %g' % np.sqrt(modeleval.inner_product(res, res))
if timer:
# pretty-print timings
print(
(
" " * 22
+ "sum".rjust(14)
+ "mean".rjust(14)
+ "min".rjust(14)
+ "std dev".rjust(14)
)
)
for key, item in list(out["times"].items()):
print(
(
"'%s': %12g %12g %12g %12g"
% (key.ljust(20), item.sum(), item.mean(), item.min(), item.std())
)
)
# Get the number of MG cycles.
# 'modeleval.num_cycles' contains the number of MG cycles executed
# for all AMG calls run.
# In nm.minres, two calls to the precondictioner are done prior to the
# actual iteration for the normalization of the residuals.
# With explicit_residual=True, *two* calls to the preconditioner are done
# in each iteration.
# What we would like to have here is the number of V-cycles done per loop
# when explicit_residual=False. Also, forget about the precondictioner
# calls for the initialization.
# Hence, cut of the first two and replace it by 0, and out of the
# remainder take every other one.
# nc = [0] + modeleval.tot_amg_cycles[2::2]
# nc_cumsum = np.cumsum(nc)
# pp.semilogy(nc_cumsum, out['relresvec'], color='0.0')
# pp.show()
# import matplotlib2tikz
# matplotlib2tikz.save('cycle10.tex')
# matplotlib2tikz.save('inf.tex')
return out["relresvec"]
