def test_equality_constraint(pytestconfig):
mesh = fs.DiskMesh(0.05, radius=2.)
Q = fs.FeControlSpace(mesh)
inner = fs.ElasticityInnerProduct(Q, direct_solve=True)
mesh_m = Q.mesh_m
(x, y) = fd.SpatialCoordinate(mesh_m)
q = fs.ControlVector(Q, inner)
if pytestconfig.getoption("verbose"):
out = fd.File("domain.pvd")
def cb(*args):
out.write(Q.mesh_m.coordinates)
else:
cb = None
f = (pow(2 * x, 2)) + pow(y - 0.1, 2) - 1.2
J = fsz.LevelsetFunctional(f, Q, cb=cb)
vol = fsz.LevelsetFunctional(fd.Constant(1.0), Q)
e = fs.EqualityConstraint([vol])
emul = ROL.StdVector(1)
params_dict = {
'Step': {
'Type': 'Augmented Lagrangian',
'Augmented Lagrangian': {
'Subproblem Step Type': 'Line Search',
'Penalty Parameter Growth Factor': 2.,
'Initial Penalty Parameter': 1.,
'Subproblem Iteration Limit': 20,
},
'Line Search': {
'Descent Method': {
'Type': 'Quasi-Newton Step'
}
},
},
'General': {
'Secant': {
'Type': 'Limited-Memory BFGS',
'Maximum Storage': 5
}
},
'Status Test': {
'Gradient Tolerance': 1e-4,
'Step Tolerance': 1e-10,
'Iteration Limit': 10
}
}
params = ROL.ParameterList(params_dict, "Parameters")
problem = ROL.OptimizationProblem(J, q, econ=e, emul=emul)
solver = ROL.OptimizationSolver(problem, params)
solver.solve()
state = solver.getAlgorithmState()
assert (state.gnorm < 1e-4)
assert (state.cnorm < 1e-6)
n = 30
# mesh = fd.UnitSquareMesh(n, n)
mesh = fd.Mesh("UnitSquareCrossed.msh")
mesh = fd.MeshHierarchy(mesh, 1)[-1]
Q = fs.FeMultiGridControlSpace(mesh, refinements=3, order=2)
inner = fs.LaplaceInnerProduct(Q)
mesh_m = Q.mesh_m
V_m = fd.FunctionSpace(mesh_m, "CG", 1)
f_m = fd.Function(V_m)
(x, y) = fd.SpatialCoordinate(mesh_m)
f = (pow(x - 0.5, 2)) + pow(y - 0.5, 2) - 2.
out = fd.File("domain.pvd")
J = fsz.LevelsetFunctional(f, Q, cb=lambda: out.write(mesh_m.coordinates))
q = fs.ControlVector(Q, inner)
params_dict = {
'General': {
'Secant': {
'Type': 'Limited-Memory BFGS',
'Maximum Storage': 5
}
},
'Step': {
'Type': 'Line Search',
'Line Search': {
'Descent Method': {
'Type': 'Quasi-Newton Step'
inner = fs.ElasticityInnerProduct(Q, mu=mu_base, direct_solve=True)
elif args.base_inner == "laplace":
inner = fs.LaplaceInnerProduct(Q, mu=mu_base, direct_solve=True)
else:
raise NotImplementedError
if args.alpha is not None:
mu_cr = mu_base / args.alpha
inner = CauchyRiemannAugmentation(mu_cr, inner)
mesh_m = Q.mesh_m
(x, y) = fd.SpatialCoordinate(mesh_m)
r = fd.sqrt(x**2 + y**2)
expr = (r - fd.Constant(rs)) * (r - fd.Constant(Rs))
J = 0.1 * fsz.LevelsetFunctional(expr, Q, quadrature_degree=5)
q = fs.ControlVector(Q, inner)
params_dict = {
"General": {
"Secant": {
"Type": "Limited-Memory BFGS",
"Maximum Storage": 1
}
},
"Step": {
"Type": "Line Search",
"Line Search": {
"Descent Method": {
"Type": "Quasi-Newton Step"
}
def test_levelset(dim, inner_t, controlspace_t, use_extension, pytestconfig):
verbose = pytestconfig.getoption("verbose")
""" Test template for fsz.LevelsetFunctional."""
clscale = 0.1 if dim == 2 else 0.2
# make the mesh a bit coarser if we are using a multigrid control space as
# we are refining anyway
if controlspace_t == fs.FeMultiGridControlSpace:
clscale *= 4
if dim == 2:
mesh = fs.DiskMesh(clscale)
elif dim == 3:
mesh = fs.SphereMesh(clscale)
else:
raise NotImplementedError
if controlspace_t == fs.BsplineControlSpace:
if dim == 2:
bbox = [(-2, 2), (-2, 2)]
orders = [2, 2]
levels = [4, 4]
else:
bbox = [(-3, 3), (-3, 3), (-3, 3)]
orders = [2, 2, 2]
levels = [3, 3, 3]
Q = fs.BsplineControlSpace(mesh, bbox, orders, levels)
elif controlspace_t == fs.FeMultiGridControlSpace:
Q = fs.FeMultiGridControlSpace(mesh, refinements=1, order=2)
else:
Q = controlspace_t(mesh)
inner = inner_t(Q)
# if running with -v or --verbose, then export the shapes
if verbose:
out = fd.File("domain.pvd")
def cb(*args):
out.write(Q.mesh_m.coordinates)
cb()
else:
cb = None
# levelset test case
if dim == 2:
(x, y) = fd.SpatialCoordinate(Q.mesh_m)
f = (pow(x, 2)) + pow(1.3 * y, 2) - 1.
elif dim == 3:
(x, y, z) = fd.SpatialCoordinate(Q.mesh_m)
f = (pow(x, 2)) + pow(0.8 * y, 2) + pow(1.3 * z, 2) - 1.
else:
raise NotImplementedError
J = fsz.LevelsetFunctional(f, Q, cb=cb, scale=0.1)
if use_extension == "w_ext":
ext = fs.ElasticityExtension(Q.V_r)
if use_extension == "w_ext_fixed_dim":
ext = fs.ElasticityExtension(Q.V_r, fixed_dims=[0])
else:
ext = None
q = fs.ControlVector(Q, inner, boundary_extension=ext)
# these tolerances are not very stringent, but solutions are correct with
# tighter tolerances, the combination
# FeMultiGridControlSpace-ElasticityInnerProduct fails because the mesh
# self-intersects (one should probably be more careful with the opt params)
grad_tol = 1e-1
itlim = 15
itlimsub = 15
# Volume constraint
vol = fsz.LevelsetFunctional(fd.Constant(1.0), Q, scale=1)
initial_vol = vol.value(q, None)
econ = fs.EqualityConstraint([vol], target_value=[initial_vol])
emul = ROL.StdVector(1)
# ROL parameters
params_dict = {
'Step': {
'Type': 'Augmented Lagrangian',
'Augmented Lagrangian': {
'Subproblem Step Type': 'Line Search',
'Penalty Parameter Growth Factor': 1.05,
'Print Intermediate Optimization History': True,
'Subproblem Iteration Limit': itlimsub
},
'Line Search': {
'Descent Method': {
'Type': 'Quasi-Newton Step'
}
},
},
'General': {
'Secant': {
'Type': 'Limited-Memory BFGS',
'Maximum Storage': 50
}
},
'Status Test': {
'Gradient Tolerance': grad_tol,
'Step Tolerance': 1e-10,
'Iteration Limit': itlim
}
}
params = ROL.ParameterList(params_dict, "Parameters")
problem = ROL.OptimizationProblem(J, q, econ=econ, emul=emul)
solver = ROL.OptimizationSolver(problem, params)
solver.solve()
# verify that the norm of the gradient at optimum is small enough
# and that the volume has not changed too much
state = solver.getAlgorithmState()
assert (state.gnorm < grad_tol)
assert abs(vol.value(q, None) - initial_vol) < 1e-2
if args.spectral:
Js = fsz.MoYoSpectralConstraint(1e3, fd.Constant(0.5), Q)
J = J + Js
if args.tikhonov > 0:
Jt = args.tikhonov * fsz.CoarseDeformationRegularization(extension, Q)
J = J + Jt
if args.smooth:
control_constraint = fs.InteriorControlConstraint(Q.V_r_coarse,
form=extension)
else:
dirichlet_extension = None
control_constraint = None
q = fs.ControlVector(Q, innerp, control_constraint=control_constraint)
vol = fsz.LevelsetFunctional(fd.Constant(10.0), Q)
if args.problem == "pipe":
econ_unscaled = fs.EqualityConstraint([vol])
def wrap(f):
return fs.DeformationCheckObjective(
f,
delta_threshold=0.25 if args.dim == 2 else 0.25, # noqa
strict=False)
scale = 1e1
J = wrap(scale * J)
volweight = 0.1 if args.dim == 2 else 1.
vol = wrap(volweight * scale**0.5 * vol)
econ = fs.EqualityConstraint([vol])
emul = ROL.StdVector(1)
def test_objective_plus_box_constraint(pytestconfig):
n = 10
mesh = fd.UnitSquareMesh(n, n)
T = mesh.coordinates.copy(deepcopy=True)
(x, y) = fd.SpatialCoordinate(mesh)
T.interpolate(T + fd.Constant((0, 0)))
mesh = fd.Mesh(T)
Q = fs.FeControlSpace(mesh)
inner = fs.LaplaceInnerProduct(Q)
mesh_m = Q.mesh_m
q = fs.ControlVector(Q, inner)
if pytestconfig.getoption("verbose"):
out = fd.File("domain.pvd")
def cb():
out.write(mesh_m.coordinates)
else:
def cb():
pass
lower_bound = Q.T.copy(deepcopy=True)
lower_bound.interpolate(fd.Constant((-0.2, -0.2)))
upper_bound = Q.T.copy(deepcopy=True)
upper_bound.interpolate(fd.Constant((+1.2, +1.2)))
# levelset test case
(x, y) = fd.SpatialCoordinate(Q.mesh_m)
f = (pow(x - 0.5, 2)) + pow(y - 0.5, 2) - 4.
J1 = fsz.LevelsetFunctional(f, Q, cb=cb, quadrature_degree=10)
J2 = fsz.MoYoBoxConstraint(10., [1, 2, 3, 4],
Q,
lower_bound=lower_bound,
upper_bound=upper_bound,
cb=cb,
quadrature_degree=10)
J3 = fsz.MoYoSpectralConstraint(100,
fd.Constant(0.6),
Q,
cb=cb,
quadrature_degree=100)
J = 0.1 * J1 + J2 + J3
g = q.clone()
J.gradient(g, q, None)
taylor_result = J.checkGradient(q, g, 9, 1)
for i in range(len(taylor_result) - 1):
if taylor_result[i][3] > 1e-6 and taylor_result[i][3] < 1e-3:
assert taylor_result[i + 1][3] <= taylor_result[i][3] * 0.15
params_dict = {
'Step': {
'Type': 'Line Search',
'Line Search': {
'Descent Method': {
'Type': 'Quasi-Newton Step'
}
}
},
'General': {
'Secant': {
'Type': 'Limited-Memory BFGS',
'Maximum Storage': 2
}
},
'Status Test': {
'Gradient Tolerance': 1e-10,
'Step Tolerance': 1e-10,
'Iteration Limit': 10
}
}
params = ROL.ParameterList(params_dict, "Parameters")
problem = ROL.OptimizationProblem(J, q)
solver = ROL.OptimizationSolver(problem, params)
solver.solve()
Tvec = Q.T.vector()
nodes = fd.DirichletBC(Q.V_r, fd.Constant((0.0, 0.0)), [2]).nodes
assert np.all(Tvec[nodes, 0] <= 1.2 + 1e-1)
assert np.all(Tvec[nodes, 1] <= 1.2 + 1e-1)
(x, y) = fd.SpatialCoordinate(mesh_m)
f = (pow(x, 2)) + pow(2 * y, 2) - 1
outdef = fd.File("deformation.pvd")
out = fd.File("domain.pvd")
V, I = Q.get_space_for_inner()
T = fd.Function(V)
def cb():
out.write(mesh_m.coordinates)
Q.visualize_control(q, T)
outdef.write(T)
J = fsz.LevelsetFunctional(f, Q, cb=cb)
J = 0.1 * J
g = q.clone()
J.gradient(g, q, None)
J.checkGradient(q, g, 4, 1)
params_dict = {
'Step': {
'Type': 'Line Search',
'Line Search': {
'Descent Method': {
'Type': 'Quasi-Newton Step'
}
}
},
def test_levelset(dim, inner_t, controlspace_t, use_extension, pytestconfig):
verbose = pytestconfig.getoption("verbose")
""" Test template for fsz.LevelsetFunctional."""
clscale = 0.1 if dim == 2 else 0.2
# make the mesh a bit coarser if we are using a multigrid control space as
# we are refining anyway
if controlspace_t == fs.FeMultiGridControlSpace:
clscale *= 2
if dim == 2:
mesh = fs.DiskMesh(clscale)
elif dim == 3:
mesh = fs.SphereMesh(clscale)
else:
raise NotImplementedError
if controlspace_t == fs.BsplineControlSpace:
if dim == 2:
bbox = [(-2, 2), (-2, 2)]
orders = [2, 2]
levels = [4, 4]
else:
bbox = [(-3, 3), (-3, 3), (-3, 3)]
orders = [2, 2, 2]
levels = [3, 3, 3]
Q = fs.BsplineControlSpace(mesh, bbox, orders, levels)
elif controlspace_t == fs.FeMultiGridControlSpace:
Q = fs.FeMultiGridControlSpace(mesh, refinements=1, order=2)
else:
Q = controlspace_t(mesh)
inner = inner_t(Q)
# if running with -v or --verbose, then export the shapes
if verbose:
out = fd.File("domain.pvd")
def cb(*args):
out.write(Q.mesh_m.coordinates)
cb()
else:
cb = None
# levelset test case
if dim == 2:
(x, y) = fd.SpatialCoordinate(Q.mesh_m)
f = (pow(x, 2)) + pow(1.3 * y, 2) - 1.
elif dim == 3:
(x, y, z) = fd.SpatialCoordinate(Q.mesh_m)
f = (pow(x, 2)) + pow(0.8 * y, 2) + pow(1.3 * z, 2) - 1.
else:
raise NotImplementedError
J = fsz.LevelsetFunctional(f, Q, cb=cb, scale=0.1)
if use_extension == "w_ext":
ext = fs.ElasticityExtension(Q.V_r)
if use_extension == "w_ext_fixed_dim":
ext = fs.ElasticityExtension(Q.V_r, fixed_dims=[0])
else:
ext = None
q = fs.ControlVector(Q, inner, boundary_extension=ext)
"""
move mesh a bit to check that we are not doing the
taylor test in T=id
"""
g = q.clone()
J.gradient(g, q, None)
q.plus(g)
J.update(q, None, 1)
""" Start taylor test """
J.gradient(g, q, None)
res = J.checkGradient(q, g, 5, 1)
errors = [l[-1] for l in res]
assert (errors[-1] < 0.11 * errors[-2])
q.scale(0)
""" End taylor test """
grad_tol = 1e-6 if dim == 2 else 1e-4
# ROL parameters
params_dict = {
'General': {
'Secant': {
'Type': 'Limited-Memory BFGS',
'Maximum Storage': 50
}
},
'Step': {
'Type': 'Line Search',
'Line Search': {
'Descent Method': {
'Type': 'Quasi-Newton Step'
}
}
},
'Status Test': {
'Gradient Tolerance': grad_tol,
'Step Tolerance': 1e-10,
'Iteration Limit': 150
}
}
# assemble and solve ROL optimization problem
params = ROL.ParameterList(params_dict, "Parameters")
problem = ROL.OptimizationProblem(J, q)
solver = ROL.OptimizationSolver(problem, params)
solver.solve()
# verify that the norm of the gradient at optimum is small enough
state = solver.getAlgorithmState()
assert (state.gnorm < grad_tol)