if mesh.topological_dimension() == 2: # in 2D
out = fd.File("solution/u2D.pvd")
elif mesh.topological_dimension() == 3: # in 3D
out = fd.File("solution/u3D.pvd")
def cb():
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':
def test_regularization(controlspace_t, use_extension):
n = 10
mesh = fd.UnitSquareMesh(n, n)
if controlspace_t == fs.FeMultiGridControlSpace:
Q = fs.FeMultiGridControlSpace(mesh, refinements=1, order=2)
else:
Q = controlspace_t(mesh)
if use_extension:
inner = fs.SurfaceInnerProduct(Q)
ext = fs.ElasticityExtension(Q.V_r)
else:
inner = fs.LaplaceInnerProduct(Q)
ext = None
q = fs.ControlVector(Q, inner, boundary_extension=ext)
X = fd.SpatialCoordinate(mesh)
q.fun.interpolate(0.5 * X)
lower_bound = Q.T.copy(deepcopy=True)
lower_bound.interpolate(fd.Constant((-0.0, -0.0)))
upper_bound = Q.T.copy(deepcopy=True)
upper_bound.interpolate(fd.Constant((+1.3, +0.9)))
J1 = fsz.MoYoBoxConstraint(1, [1, 2, 3, 4],
Q,
lower_bound=lower_bound,
upper_bound=upper_bound)
J2 = fsz.MoYoSpectralConstraint(1, fd.Constant(0.2), Q)
J3 = fsz.DeformationRegularization(Q,
l2_reg=.1,
sym_grad_reg=1.,
skew_grad_reg=.5)
if isinstance(Q, fs.FeMultiGridControlSpace):
J4 = fsz.CoarseDeformationRegularization(Q,
l2_reg=.1,
sym_grad_reg=1.,
skew_grad_reg=.5)
Js = 0.1 * J1 + J2 + 2. * (J3 + J4)
else:
Js = 0.1 * J1 + J2 + 2. * J3
g = q.clone()
def run_taylor_test(J):
J.update(q, None, 1)
J.gradient(g, q, None)
return J.checkGradient(q, g, 7, 1)
def check_result(test_result):
for i in range(len(test_result) - 1):
assert test_result[i + 1][3] <= test_result[i][3] * 0.11
check_result(run_taylor_test(J1))
check_result(run_taylor_test(J2))
check_result(run_taylor_test(J3))
if isinstance(Q, fs.FeMultiGridControlSpace):
check_result(run_taylor_test(J4))
check_result(run_taylor_test(Js))
("J(Omega)=%f" % fd.assemble(objective_form)))
except:
fd.warning(fd.RED % "Solver failed, let's try from scratch.")
solver.z.assign(0)
solver.z_adj.assign(0)
res = list(range(0, optre + 1, 25))
run_solver(solver, res, args)
constraint = Constraint()
obj = Objective(Q)
J = obj
out = fd.File("output/%s.pvd" % label)
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 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)
def test_spectral_constraint(pytestconfig):
n = 5
mesh = fd.UnitSquareMesh(n, n)
T = fd.Function(fd.VectorFunctionSpace(
mesh, "CG",
1)).interpolate(fd.SpatialCoordinate(mesh) - fd.Constant((0.5, 0.5)))
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
J = fsz.MoYoSpectralConstraint(0.5, fd.Constant(0.1), Q, cb=cb)
q.fun += Q.T
g = q.clone()
J.update(q, None, -1)
J.gradient(g, q, None)
cb()
taylor_result = J.checkGradient(q, g, 7, 1)
for i in range(len(taylor_result) - 1):
assert taylor_result[i + 1][3] <= taylor_result[i][3] * 0.11
params_dict = {
'General': {
'Secant': {
'Type': 'Limited-Memory BFGS',
'Maximum Storage': 2
}
},
'Step': {
'Type': 'Line Search',
'Line Search': {
'Descent Method': {
'Type': 'Quasi-Newton Step'
}
}
},
'Status Test': {
'Gradient Tolerance': 1e-10,
'Step Tolerance': 1e-10,
'Iteration Limit': 150
}
}
params = ROL.ParameterList(params_dict, "Parameters")
problem = ROL.OptimizationProblem(J, q)
solver = ROL.OptimizationSolver(problem, params)
solver.solve()
Tvec = Q.T.vector()[:, :]
for i in range(Tvec.shape[0]):
assert abs(Tvec[i, 0]) < 0.55 + 1e-4
assert abs(Tvec[i, 1]) < 0.55 + 1e-4
assert np.any(np.abs(Tvec) > 0.55 - 1e-4)
inflow_bids=[1, 2],
inflow_expr=inflow_expr,
noslip_bids=[4])
e.solve()
out = fd.File("u.pvd")
def cb(*args):
out.write(e.solution.split()[0])
cb()
Je = fsz.EnergyObjective(e, Q, cb=cb)
Jr = 1e-2 * fs.ReducedObjective(Je, e)
Js = fsz.MoYoSpectralConstraint(10., fd.Constant(0.7), Q)
Jd = 1e-3 * fsz.DeformationRegularization(
Q, l2_reg=1e-2, sym_grad_reg=1e0, skew_grad_reg=1e-2)
J = Jr + Jd + Js
q = fs.ControlVector(Q, inner)
g = q.clone()
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)
params_dict = {
'General': {
'Secant': {