def test_std_vector_check():
x = ROL.StdVector(2)
y = ROL.StdVector(2)
z = ROL.StdVector(2)
x[0] = 1.5
x[1] = 0.5
y[0] = 1.2
y[1] = 0.2
u = x.checkVector(y, z)
assert sum(u) < 1e-12
def test_std_vector_run():
params_dict = {
'General': {
'Secant': {
'Type': 'Limited-Memory BFGS',
'Maximum Storage': 5
}
},
'Step': {
'Type': 'Line Search',
'Line Search': {
'Descent Method': {
'Type': 'Quasi-Newton Method'
}
}
},
'Status Test': {
'Gradient Tolerance': 1e-15,
'Relative Gradient Tolerance': 1e-10,
'Step Tolerance': 1e-16,
'Relative Step Tolerance': 1e-10,
'Iteration Limit': 10
}
}
params = ROL.ParameterList(params_dict, "Parameters")
algo = ROL.Algorithm("Line Search", params)
x = ROL.StdVector(2)
x[0] = -1.0
x[1] = 2.0
algo.run(x, obj)
# Check answer to 8 decimal places
assert round(x[0] - 1.0, 8) == 0.0
assert round(x[1], 8) == 0.0
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)
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
return out.write(e.solution.split()[0])
# create PDEconstrained objective functional
J_ = PipeObjective(e, Q, cb=cb)
J = fs.ReducedObjective(J_, e)
# add regularization to improve mesh quality
Jq = fsz.MoYoSpectralConstraint(10, fd.Constant(0.5), Q)
J = J + Jq
# Set up volume constraint
vol = fsz.VolumeFunctional(Q)
initial_vol = vol.value(q, None)
econ = fs.EqualityConstraint([vol], target_value=[initial_vol])
emul = ROL.StdVector(1)
# ROL parameters
params_dict = {
'General': {'Print Verbosity': 0, # set to 1 to understand output
'Secant': {'Type': 'Limited-Memory BFGS',
'Maximum Storage': 10}},
'Step': {'Type': 'Augmented Lagrangian',
'Augmented Lagrangian':
{'Subproblem Step Type': 'Trust Region',
'Print Intermediate Optimization History': False,
'Subproblem Iteration Limit': 10}},
'Status Test': {'Gradient Tolerance': 1e-2,
'Step Tolerance': 1e-2,
'Constraint Tolerance': 1e-1,
'Iteration Limit': 10}}
jv[0] = assemble(da * dx)
def applyAdjointJacobian(self, ajv, v, x, tol):
da = TestFunction(A)
deriv = assemble(da * dx)
if self.inner_product is not None:
grad = self.inner_product.riesz_map(deriv)
else:
grad = deriv
ajv.scale(0)
ajv.vec += grad
ajv.scale(v[0])
# Initialise 'ROLVector'
l_initializacao = ROL.StdVector(1)
x = interpolate(Constant(V / delta), A)
x = FeVector(x.vector(), dot_product)
lower = interpolate(Constant(0.0), A)
lower = FeVector(lower.vector(), dot_product)
upper = interpolate(Constant(1.0), A)
upper = FeVector(upper.vector(), dot_product)
# Instantiate Objective class for poisson problem
obj = ObjR(dot_product)
volConstr = VolConstraint(dot_product)
#set_log_level(30)
da = Function(A, v.vec)
jv[0] = assemble(da * dx)
def applyAdjointJacobian(self, ajv, v, x, tol):
da = TestFunction(A)
deriv = assemble(da*dx)
if self.inner_product is not None:
grad = self.inner_product.riesz_map(deriv)
else:
grad = deriv
ajv.scale(0)
ajv.vec += grad
ajv.scale(v[0])
# Initialise 'ROLVector'
l = ROL.StdVector(1)
c = ROL.StdVector(1)
v = ROL.StdVector(1)
v[0] = 1.0
dualv = ROL.StdVector(1)
v.checkVector(c, l)
x = interpolate(Constant(0.5), A)
x = FeVector(x.vector(), dot_product)
g = Function(A)
g = FeVector(g.vector(), dot_product)
d = interpolate(Expression("1 + x[0] * (1-x[0])*x[1] * (1-x[1])", degree=1), A)
d = FeVector(d.vector(), dot_product)
x.checkVector(d, g)
jd = Function(A)
class Objective(ROL.Objective):
def __init__(self):
super().__init__()
def value(self, x, tol):
return (x[0] - 1)**2 + x[1]**2
def gradient(self, g, x, tol):
g[0] = 2 * (x[0] - 1)
g[1] = 2 * x[1]
obj = Objective()
x = ROL.StdVector(2)
x[0] = -1.0
x[1] = 2.0
lower = ROL.StdVector(2)
lower[0] = -10
lower[1] = -10
upper = ROL.StdVector(2)
upper[0] = 0.5
upper[1] = 0.5
bnd = ROL.Bounds(lower, upper, 1.0)
params = ROL.ParameterList(params_dict, "Parameters")
problem = ROL.OptimizationProblem(obj, x)
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)
econ_val = ROL.StdVector(1)
elif args.problem == "obstacle":
if args.dim == 2:
x, y = fd.SpatialCoordinate(Q.mesh_m)
else:
x, y, z = fd.SpatialCoordinate(Q.mesh_m)
baryx = fsz.LevelsetFunctional(x, Q)
baryy = fsz.LevelsetFunctional(y, Q)
econ_unscaled = fs.EqualityConstraint([vol, baryx, baryy])
if args.dim == 3:
baryz = fsz.LevelsetFunctional(z, Q)
econ_unscaled = fs.EqualityConstraint([vol, baryx, baryy, baryz])
if args.surf:
scale = 1e-3
else:
direct=True,
pin_pressure=True)
# e.solve()
# fd.File("out.pvd").write(e.solution.split()[0])
# import sys; sys.exit()
directory = f"./output/stokes/base_{base_inner}_cr_{use_cr}/"
if not os.path.exists(directory):
os.makedirs(directory, exist_ok=True)
out = fd.File(directory + "u.pvd")
vol = fsz.LevelsetFunctional(fd.Constant(1.0), Q)
baryx = fsz.LevelsetFunctional(x, Q)
baryy = fsz.LevelsetFunctional(y, Q)
econ = fs.EqualityConstraint([vol, baryx, baryy])
emul = ROL.StdVector(3)
econ_val = ROL.StdVector(3)
Je = fsz.EnergyObjective(e, Q, cb=None)
Jr = fs.ReducedObjective(Je, e)
# J = 2e-4 * Jr
J = 1e-2 * Jr
q = fs.ControlVector(Q, inner)
params_dict = {
"General": {
"Secant": {
"Type": "Limited-Memory BFGS",
"Maximum Storage": 5
}
},