def moola_problem(request):
if request.param[0] == "structured mesh":
N = request.param[1]
mesh = UnitSquareMesh(N, N)
if request.param[0] == "nonstructured mesh":
number_of_refinements = request.param[1]
mesh = Mesh(Rectangle(0, 0, 1, 1), 10)
for k in range(number_of_refinements):
mesh = randomly_refine(mesh)
V = FunctionSpace(mesh, 'CG', 2)
Q = FunctionSpace(mesh, "CG", 2)
u = Function(V, name='State')
expr = Expression('2*x[0]-1.')
bc = DirichletBC(Q, 0.0, "on_boundary")
m = interpolate(expr, Q)
alpha = Constant(0.1)
u_d = interpolate(Expression('pow(sin(pi*x[0])*sin(pi*x[1]),2)'), Q)
#from numpy.random import rand
#epsilon = 0.05
#u_d.vector()[:] += epsilon * (rand(len(u_d.vector()))*2 - 1)
#u_d = Function(V)
#solve_pde(u_d, V, m_ex)
J = Functional((.5 * inner(u - u_d, u - u_d)) * dx +
.5 * alpha * m**2 * dx)
# Run the forward model once to create the annotation
solve_pde(u, V, m)
# Run the optimisation
rf = ReducedFunctional(J, Control(m, value=m))
x_init = moola.DolfinPrimalVector(m)
options = {
'jtol': None,
'gtol': None,
'display': 3,
'maxiter': 100,
}
return MoolaOptimizationProblem(rf), x_init, options
def moola_problem():
adj_reset()
mesh = UnitSquareMesh(256, 256)
V = FunctionSpace(mesh, "CG", 1)
f = interpolate(Constant(1), V)
u = Function(V)
phi = TestFunction(V)
F = inner(grad(u), grad(phi)) * dx - f * phi * dx
bc = DirichletBC(V, Constant(0), "on_boundary")
solve(F == 0, u, bc)
J = Functional(inner(u, u) * dx)
m = Control(f)
rf = ReducedFunctional(J, m)
obj = rf.moola_problem().obj
pf = moola.DolfinPrimalVector(f)
return obj, pf
def solve_moola_bfgs(rf, ctrls, optimization_parameters=None):
if optimization_parameters is None:
optimization_parameters = {
'jtol': 1e-6,
'gtol': 1e-6,
'Hinit': "default",
'maxiter': 100,
'mem_lim': 10
}
problem = MoolaOptimizationProblem(rf)
f_moola = moola.DolfinPrimalVectorSet(
[moola.DolfinPrimalVector(c, inner_product="L2") for c in ctrls])
solver = moola.BFGS(problem, f_moola, options=optimization_parameters)
sol = solver.solve()
opt_ctrls = sol['control'].data
return opt_ctrls
d = da.Function(V)
d.vector()[:] = u.vector()[:]
J = da.assemble((0.5 * fa.inner(u - d, u - d)) * fa.dx +
alpha / 2 * f**2 * fa.dx)
control = da.Control(f)
rf = da.ReducedFunctional(J, control)
# set the initial value to be zero for optimization
f.vector()[:] = 0
# N = len(f.vector()[:])
# f.vector()[:] = np.random.rand(N)*2 -1
problem = da.MoolaOptimizationProblem(rf)
f_moola = moola.DolfinPrimalVector(f)
solver = moola.BFGS(problem,
f_moola,
options={
'jtol': 0,
'gtol': 1e-9,
'Hinit': "default",
'maxiter': 100,
'mem_lim': 10
})
sol = solver.solve()
f_opt = sol['control'].data
file = fa.File('f.pvd')
f_opt.rename('f', 'f')
file << f_opt
### denoising
l = 1e-2
epsilon = 1e-3
def func(u, l, epsilon, f):
return (l * (sqrt(inner(nabla_grad(u), nabla_grad(u)) + epsilon)) +
0.5 * f * f) * dx
J = Functional(func(u, l, epsilon, f))
control = Control(f)
rf = ReducedFunctional(J, control)
problem = MoolaOptimizationProblem(rf)
f_moola = moola.DolfinPrimalVector(f, inner_product="L2")
solver = moola.NewtonCG(problem,
f_moola,
options={
'gtol': 1e-9,
'maxiter': 200,
'display': 3,
'ncg_hesstol': 0,
'line_search': 'strong_wolfe'
})
sol = solver.solve()
print sol
#### Saving results
f_opt = sol['control'].data
W = FunctionSpace(mesh, "DG", 0)
f = Function(W, name='Source')
g = Function(W, name='Diffusivity')
u_d = 1 / (2 * pi**2) * sin(pi * x[0]) * sin(pi * x[1])
alpha = Constant(1e-12)
J = Functional(0.5 * (inner(u - u_d, u - u_d)) * dx +
alpha * 0.5 * f**2 * dx)
# Run the forward model once to create the annotation
solve_pde(u, V, f, g)
# Run the optimisation
m = SteadyParameter(f, value=f), SteadyParameter(g, value=g)
m_moola = moola.DolfinPrimalVector((f, g))
rf = ReducedFunctional(J, m)
problem = rf.moola_problem()
solver = moola.TrustRegionNewtonCG(problem,
m_moola,
options={
'gtol': 1e-12,
"tr_D0": 0.5
})
#solver = moola.NewtonCG(options={'gtol': 1e-10, 'maxiter': 20, 'ncg_reltol':1e-20, 'ncg_hesstol': "default"})
#solver = moola.BFGS(tol=1e-200, options={'gtol': 1e-7, 'maxiter': 20, 'mem_lim': 20})
sol = solver.solve()
m_opt = sol['Optimizer'].data
print(moola.events)
x = SpatialCoordinate(mesh)
u_d = 1/(2*pi**2)*sin(pi*x[0])*sin(pi*x[1])
J = Functional((inner(u-u_d, u-u_d))*dx*dt[FINISH_TIME])
# Run the forward model once to create the annotation
solve_pde(u, V, m, n)
# Run the optimisation
controls = [Control(m, value=m), Control(n, value=n)]
rf = ReducedFunctional(J, controls)
problem = MoolaOptimizationProblem(rf, memoize=False)
controls = moola.DolfinPrimalVector(m), moola.DolfinPrimalVector(n)
control_set = moola.DolfinPrimalVectorSet(controls)
solver = moola.SteepestDescent(problem, control_set, options={'jtol': 0, 'gtol': 1e-10, 'maxiter': 1})
sol = solver.solve()
m_opt, n_opt = sol['control'].data
#assert max(abs(sol["Optimizer"].data + 1./2*np.pi)) < 1e-9
#assert sol["Number of iterations"] < 50
#plot(m_opt, interactive=True)
solve_pde(u, V, m_opt, n_opt)
my_expr = Expression("0.0001/3.14/(((x[0])-4)^2 + 0.0001^2)", degree=2)
my_expr = Expression("1E-2 / pi * 1.0/(pow(x[0]-4.0,2) + 1E-4)", degree=10)
target_time = 4.0 #TODO: Incorporate Target Time.
thresh = 1.0
#assign(v, [Constant(1.0), Constant(1.0)])
#assign(v1, Constant(1.0))
J = (v1 - thresh)**2 * my_expr * dx + 100 * weight1.dx(0)**2 * dx
J = assemble(J)
print(J)
rf = ReducedFunctional(J, Control(weight1))
problem = MoolaOptimizationProblem(rf)
f_moola = moola.DolfinPrimalVector(weight1)
solver = moola.NewtonCG(problem,
f_moola,
options={
'gtol': 1e-5,
'maxiter': 20,
'display': 3,
'ncg_hesstol': 0
})
#solver = moola.BFGS(problem, f_moola, options={'jtol': 0,
# 'gtol': 1e-9,
# 'Hinit': "default",
# 'maxiter': 100,
# 'mem_lim': 10})
sol = solver.solve()
