def run_test(nbrep=100):
mesh = dl.UnitSquareMesh(100,100)
V = dl.FunctionSpace(mesh, 'Lagrange', 2)
test, trial = dl.TestFunction(V), dl.TrialFunction(V)
k = dl.Function(V)
wkform = dl.inner(k*dl.nabla_grad(test), dl.nabla_grad(trial))*dl.dx
for ii in xrange(nbrep):
setfct(k, float(ii+1))
dl.assemble(wkform)
def run_exple(denoise, PLOT=True, TEST=False):
# testcase == 0
print 'Run basic example -- PLOT={}. TEST={}'.format(PLOT, TEST)
# Solve
#ALPHAS = 10**(-np.linspace(-3.,3.,7))
ALPHAS = [1.0]
denoise.g = dl.Function(denoise.V)
for aa in ALPHAS:
setfct(denoise.g, denoise.dn) # start from noisy image
denoise.regparam = aa
denoise.solve()
if PLOT: denoise.plot(2,'-'+str(aa))
def run_continuation(denoise, PLOT=True, TEST=False):
# testcase == 1
print 'Run continuation scheme on eps -- PLOT={}. TEST={}'.format(PLOT, TEST)
# Solve
denoise.regparam = 1e-2
EPS = 10**(-np.linspace(0.,4.,5))
#EPS = [1.0]
denoise.g = dl.Function(denoise.V)
setfct(denoise.g, denoise.dn) # start from noisy image
for eps in EPS:
print 'eps={}'.format(eps)
paramregul = {'regularization':'TV', 'eps':eps, 'k':1.0, 'GN':False}
denoise.define_regularization(paramregul)
denoise.solve()
if PLOT: denoise.plot(2,'-'+str(eps))
def run_test(nbrep=100):
# dl.parameters['form_compiler']['cpp_optimize'] = True
# dl.parameters['form_compiler']['cpp_optimize_flags'] = '-O3'
# dl.parameters['form_compiler']['optimize'] = True
# ffc.parameters.FFC_PARAMETERS['optimize'] = True
# ffc.parameters.FFC_PARAMETERS['cpp_optimize'] = True
# ffc.parameters.FFC_PARAMETERS['cpp_optimize_flags'] = '-O3'
mesh = dl.UnitSquareMesh(1000, 1000)
V = dl.FunctionSpace(mesh, 'Lagrange', 2)
test, trial = dl.TestFunction(V), dl.TrialFunction(V)
k = dl.Function(V)
wkform = dl.inner(k * dl.nabla_grad(test), dl.nabla_grad(trial)) * dl.dx
v2 = dl.assemble(wkform)
for ii in xrange(nbrep):
setfct(k, float(ii + 1))
dl.assemble(wkform)
def run_test2(nbrep=100):
mesh = dl.UnitSquareMesh(40, 40)
V = dl.FunctionSpace(mesh, 'Lagrange', 2)
Vr = dl.FunctionSpace(mesh, 'Lagrange', 1)
test = dl.TestFunction(Vr)
u, v = dl.Function(V), dl.Function(V)
# weak form
wkform = dl.inner(test * u, v) * dl.dx
# assemble tensor
M = LumpedMassMatrixPrime(Vr, V, 1.0)
for ii in xrange(nbrep):
setfct(u, np.random.randn(V.dim()))
setfct(v, np.random.randn(V.dim()))
dl.assemble(wkform)
M.get_gradient(u.vector(), v.vector())
def run():
mesh = dl.UnitSquareMesh(50, 50)
Vr = dl.FunctionSpace(mesh, 'Lagrange', 1)
Vphi = dl.FunctionSpace(mesh, 'Lagrange', 2)
Vphidofmap = Vphi.dofmap().dofs()
test, trial = dl.TestFunction(Vphi), dl.TrialFunction(Vphi)
u, v = dl.Function(Vphi), dl.Function(Vphi)
rho = dl.Function(Vr)
Mweak = dl.inner(rho * test, trial) * dl.dx
Mprime = LumpedMassMatrixPrime(Vr, Vphi, None)
h = 1e-5
fact = [1.0, -1.0]
RHO = \
[dl.interpolate(dl.Expression('2.0 + sin(n*pi*x[0])*sin(n*pi*x[1])', n=1.0, degree=10), Vr), \
dl.interpolate(dl.Expression('2.0 + sin(n*pi*x[0])*sin(n*pi*x[1])', n=8.0, degree=10), Vr), \
dl.interpolate(dl.Expression('2.0 + sin(2*pi*x[0])*sin(1*pi*x[1])*(x[0]<0.5)', degree=10), Vr), \
dl.interpolate(dl.Expression('2.0 + 2.0*(x[0]<0.5)*(x[1]<0.5) - 1.8*(x[0]>=0.5)*(x[1]<0.5)', degree=10), Vr)]
np.random.seed(11)
locsize = len(u.vector().array())
for jj, rho1 in enumerate(RHO):
if mpirank == 0: print '\nmedium {}'.format(jj)
setfct(rho, rho1)
M = dl.assemble(Mweak)
Ml = LumpedMatrixSolverS(Vphi)
Ml.set_operator(M)
Mprime.updater(Ml.ratio)
for ii in range(5):
rndvecu = np.random.randn(Vphi.dim())
rndvecv = np.random.randn(Vphi.dim())
if mpirank == 0: print 'test {}'.format(ii)
rnddir = dl.interpolate(dl.Expression('2.0+sin(n*pi*x[0])*sin(n*pi*x[1])',\
n=ii+1, degree=10), Vr)
setfct(u, rndvecu[Vphidofmap])
setfct(v, rndvecv[Vphidofmap])
analytical = rnddir.vector().inner(
Mprime.get_gradient(u.vector(), v.vector()))
uMv = []
for ff in fact:
setfct(rho, rho1)
rho.vector().axpy(ff * h, rnddir.vector())
M = dl.assemble(Mweak)
Ml = LumpedMatrixSolverS(Vphi)
Ml.set_operator(M)
uMv.append(u.vector().inner(Ml * v.vector()))
fd = (uMv[0] - uMv[1]) / (2 * h)
err = np.abs((analytical - fd) / analytical)
if mpirank == 0:
print 'analytical={}, fd={}, err={}'.format(
analytical, fd, err),
if err < 1e-6: print '\t =>> OK!!'
else: print ''
MPI.barrier(mycomm)
def run_continuation(denoise, PLOT=True, TEST=False):
# testcase == 1
print 'Run continuation scheme on eps -- PLOT={}. TEST={}'.format(
PLOT, TEST)
# Solve
denoise.regparam = 1e-2
EPS = 10**(-np.linspace(0., 4., 5))
#EPS = [1.0]
denoise.g = dl.Function(denoise.V)
setfct(denoise.g, denoise.dn) # start from noisy image
for eps in EPS:
print 'eps={}'.format(eps)
paramregul = {
'regularization': 'TV',
'eps': eps,
'k': 1.0,
'GN': False
}
denoise.define_regularization(paramregul)
denoise.solve()
if PLOT: denoise.plot(2, '-' + str(eps))
import dolfin as dl
from fenicstools.plotfenics import PlotFenics
from fenicstools.miscfenics import setfct
mesh = dl.UnitSquareMesh(40, 40)
V = dl.FunctionSpace(mesh, 'Lagrange', 1)
myplot = PlotFenics()
myplot.set_varname('u')
u = dl.Function(V)
for ii in range(10):
setfct(u, dl.interpolate(dl.Constant(ii), V))
myplot.plot_vtk(u, ii)
myplot.gather_vtkplots()
a = dl.interpolate(dl.Expression('1.0 + sin(n*pi*x[0])*sin(n*pi*x[1])',\
n=ii, degree=10), V)
b = dl.interpolate(dl.Expression('pow(x[0], n)*pow(x[1], n)',\
n=ii, degree=10), V)
grad = cg.gradab(a, b)
for jj in range(5):
directa = dl.interpolate(dl.Expression('pow(x[0], n)*pow(x[1], n)',\
n=jj+1, degree=10), V)
directb = dl.interpolate(dl.Expression('1.0 + sin(n*pi*x[0])*sin(n*pi*x[1])',\
n=jj+1, degree=10), V)
dl.assign(directab.sub(0), directa)
dl.assign(directab.sub(1), directb)
gradxdir = grad.inner(directab.vector())
print 'grad={}, '.format(gradxdir)
for h in H:
setfct(ak, a)
setfct(bk, b)
ak.vector().axpy(h, directa.vector())
bk.vector().axpy(h, directb.vector())
cost1 = cg.costab(ak, bk)
setfct(ak, a)
setfct(bk, b)
ak.vector().axpy(-h, directa.vector())
bk.vector().axpy(-h, directb.vector())
cost2 = cg.costab(ak, bk)
gradfddirect = (cost1 - cost2) / (2 * h)
if np.abs(gradxdir) > 1e-16:
err = np.abs(gradxdir - gradfddirect) / np.abs(gradxdir)
else:
err = np.abs(gradxdir - gradfddirect)
print '\th={}, fd={}, err={:.2e}'.format(h, gradfddirect, err),
def runcontobs():
mesh = dl.UnitSquareMesh(100, 100)
V = dl.FunctionSpace(mesh, 'Lagrange', 1)
myn = 1
m_exp = dl.Expression('sin(n*pi*x[0])*sin(n*pi*x[1])', n=myn)
m = dl.interpolate(m_exp, V)
m_in = dl.Function(V)
mv = m.vector()
shm = mv.array().shape
HH = [1e-4, 1e-5, 1e-6]
# CONTINUOUS obsop:
# Cost:
obsopcont = ObsEntireDomain({'V': V}, None)
cost_ex = (.5 - np.sin(2 * np.pi * myn) / (4 * np.pi * myn))**2
print 'relative error on cost: {:.2e}'.format(\
np.abs(2*obsopcont.costfct(mv.array(), np.zeros(shm)) - cost_ex) / cost_ex)
print 'relative error on cost_F: {:.2e}'.format(\
np.abs(2*obsopcont.costfct_F(m, dl.Function(V)) - cost_ex) / cost_ex)
md_exp = dl.Expression('sin(n*pi*x[0])*sin(n*pi*x[1])', n=3)
md = dl.interpolate(md_exp, V)
cost = obsopcont.costfct(mv.array(), md.vector().array())
cost_F = obsopcont.costfct_F(m, md)
print 'cost={}, cost_F={}, rel_err={:.2e}'.format(cost, cost_F,\
np.abs(cost-cost_F)/np.abs(cost_F))
# Gradient:
print '\nGradient:'
failures = 0
for nn in range(8):
print '\ttest ' + str(nn + 1)
dm_exp = dl.Expression('sin(n*pi*x[0])*sin(n*pi*x[1])', n=nn + 1)
dm = dl.interpolate(dm_exp, V)
for h in HH:
success = False
setfct(m_in, m)
m_in.vector().axpy(h, dm.vector())
cost1 = obsopcont.costfct_F(m_in, md)
setfct(m_in, m)
m_in.vector().axpy(-h, dm.vector())
cost2 = obsopcont.costfct_F(m_in, md)
cost = obsopcont.costfct_F(m, md)
GradFD1 = (cost1 - cost) / h
GradFD2 = (cost1 - cost2) / (2. * h)
Gradm = obsopcont.grad(m, md)
Gradm_h = Gradm.inner(dm.vector())
err1 = np.abs(GradFD1 - Gradm_h) / np.abs(Gradm_h)
err2 = np.abs(GradFD2 - Gradm_h) / np.abs(Gradm_h)
print 'h={}, GradFD1={:.5e}, GradFD2={:.5e} Gradm_h={:.5e}, err1={:.2e}, err2={:.2e}'.format(\
h, GradFD1, GradFD2, Gradm_h, err1, err2)
if err2 < 1e-6:
print 'test {}: OK!'.format(nn + 1)
success = True
break
if not success: failures += 1
print '\nTest gradient -- Summary: {} test(s) failed'.format(failures)
if failures < 5:
print '\n\nHessian:'
failures = 0
for nn in range(8):
print '\ttest ' + str(nn + 1)
dm_exp = dl.Expression('sin(n*pi*x[0])*sin(n*pi*x[1])', n=nn + 1)
dm = dl.interpolate(dm_exp, V)
for h in HH:
success = False
setfct(m_in, m)
m_in.vector().axpy(h, dm.vector())
grad1 = obsopcont.grad(m_in, md)
#
setfct(m_in, m)
m_in.vector().axpy(-h, dm.vector())
grad2 = obsopcont.grad(m_in, md)
#
HessFD = (grad1 - grad2) / (2. * h)
Hessmdm = obsopcont.hessian(dm.vector())
err = (HessFD - Hessmdm).norm('l2') / Hessmdm.norm('l2')
print 'h={}, err={}'.format(h, err)
if err < 1e-6:
print 'test {}: OK!'.format(nn + 1)
success = True
break
if not success: failures += 1
print '\nTest Hessian -- Summary: {} test(s) failed\n'.format(
failures)
'(x[0]>=0.3)*(x[0]<=0.7)*(x[1]>=0.3)*(x[1]<=0.7))')
lambda_target_fn = interpolate(lambda_target, Vl)
Wave.update({'b':lambda_target_fn, 'a':1.0, \
't0':0.0, 'tf':tf, 'Dt':Dt, 'u0init':Function(V), 'utinit':Function(V)})
Wave.ftime = mysrc
sol, tmp = Wave.solve()
# Observations
myObs = TimeObsPtwise({
'V': V,
'Points': [[.5, .2], [.5, .8], [.2, .5], [.8, .5]]
})
Bp = np.zeros((4, len(sol)))
mytimes = np.zeros(len(sol))
solp = Function(V)
for index, pp in enumerate(sol):
setfct(solp, pp[0])
Bp[:, index] = myObs.obs(solp)
mytimes[index] = pp[1]
Bpf = Bp * mytf.evaluate(mytimes)
# Plots:
try:
boolplot = int(sys.argv[1])
except:
boolplot = 20
if boolplot > 0:
filename, ext = splitext(sys.argv[0])
if myrank == 0:
if isdir(filename + '/'): rmtree(filename + '/')
if PARALLEL: MPI.barrier(mycomm)
myplot = PlotFenics(filename)
return Ricker(tt)*mydelta
Waveex = AcousticWave({'V':Vex, 'Vl':Vl, 'Vr':Vl})
Waveex.timestepper = 'backward'
Waveex.lump = True
Waveex.update({'lambda':1.0, 'rho':1.0, 't0':0.0, 'tf':tf, 'Dt':Dt,\
'u0init':dl.Function(Vex), 'utinit':dl.Function(Vex)})
Waveex.ftime = mysrc
sol,_ = Waveex.solve()
Waveex.exact = dl.Function(Vex)
normex = Waveex.computeabserror()
# plot
myplot.set_varname('u-q'+str(qq))
plotu = dl.Function(Vex)
for index, uu in enumerate(sol):
if index%boolplot == 0:
setfct(plotu, uu[0])
myplot.plot_vtk(plotu, index)
myplot.gather_vtkplots()
print 'Check different spatial sampling'
QQ = [4, 5, 6, 10]
for qq in QQ:
N = int(qq/cmin)
h = 1./N
mesh = dl.UnitSquareMesh(N,N)
Vl = dl.FunctionSpace(mesh, 'Lagrange', 1)
V = dl.FunctionSpace(mesh, 'Lagrange', r)
Pt = PointSources(V, [[.5,.5]])
mydelta = Pt[0].array()
def mysrc(tt):
return Ricker(tt)*mydelta
#Wave.set_abc(mesh, AllFour(), True)
lambda_target = Expression('1.0 + 3.0*(' \
'(x[0]>=0.3)*(x[0]<=0.7)*(x[1]>=0.3)*(x[1]<=0.7))')
lambda_target_fn = interpolate(lambda_target, Vl)
Wave.update({'lambda':lambda_target_fn, 'rho':1.0, \
't0':0.0, 'tf':tf, 'Dt':Dt, 'u0init':Function(V), 'utinit':Function(V)})
Wave.ftime = mysrc
sol, tmp = Wave.solve()
if not mycomm == None: MPI.barrier(mycomm)
# Observations
myObs = TimeObsPtwise({'V':V, 'Points':[[.5,.2], [.5,.8], [.2,.5], [.8,.5]]})
Bp = np.zeros((4, len(sol)))
mytimes = np.zeros(len(sol))
solp = Function(V)
for index, pp in enumerate(sol):
setfct(solp, pp[0])
Bp[:,index] = myObs.obs(solp)
mytimes[index] = pp[1]
Bpf = Bp*mytf.evaluate(mytimes)
# Plots:
try:
boolplot = int(sys.argv[1])
except:
boolplot = 20
if boolplot > 0:
filename, ext = splitext(sys.argv[0])
#filename = filename + '0'
if myrank == 0:
if isdir(filename + '/'): rmtree(filename + '/')
goal.update_m(mtrue)
goal.solvefwd()
# noise
np.random.seed(11)
noisepercent = 0.02 # e.g., 0.02 = 2% noise level
UD = goal.U[0]
rndnb = np.random.randn(UD.size)
rndnb = rndnb / np.linalg.norm(rndnb)
noiseres = noisepercent * np.linalg.norm(UD)
UDnoise = UD + rndnb * noiseres
if mpirank == 0: print 'noiseres={}, rndnb*noiseres={}'.format(\
MPI.sum(mpicomm, noiseres), MPI.sum(mpicomm, np.linalg.norm(rndnb*noiseres)))
if PLOT:
myplot.set_varname('u_target')
myplot.plot_vtk(goal.u)
setfct(goal.u, UDnoise)
myplot.set_varname('d_target')
myplot.plot_vtk(goal.u)
# Define regularization:
# Tikhonov
Regul = LaplacianPrior({'Vm': Vm, 'gamma': 1e-2, 'beta': 1e-2, 'm0': 9.0})
# Total Variation
# full TV w/o primal-dual
#Regul = TV({'Vm':Vm, 'eps':dl.Constant(1.0), 'GNhessian':False})
# GN Hessian for TV w/o primal-dual
#Regul = TV({'Vm':Vm, 'eps':dl.Constant(1e-4), 'GNhessian':True})
# full TV w/ primal-dual
#Regul = TVPD({'Vm':Vm, 'eps':dl.Constant(1.0)})
ObsOp.noise = False
if PRINT: print 'v1n={}, v2n={}, err={:.2e}'.format(v1n, v2n, err)
if err > 1e-14:
if PRINT: print '*** relative error too large!'
sys.exit(1)
if PRINT: print 'Test 5'
VwVwVwVw = createMixedFS(VwVw, VwVw)
testx, testy = TestFunctions(VwVwVwVw)
test1, test2 = TestFunction(VwVw)
m = Function(VV)
v1xf, v1yf = Function(VwVw), Function(VwVw)
v1f = Function(VwVwVwVw)
for ii in range(10):
m.vector()[:] = np.random.randn(m.vector().local_size())
m1, m2 = m.split(deepcopy=True)
v1x = assemble(inner(test1, m1.dx(0))*dx + inner(test2, m2.dx(0))*dx)
setfct(v1xf, v1x)
v1y = assemble(inner(test1, m1.dx(1))*dx + inner(test2, m2.dx(1))*dx)
setfct(v1yf, v1y)
assign(v1f.sub(0), v1xf)
assign(v1f.sub(1), v1yf)
v1 = v1f.vector()
v1n = v1.norm('l2')
v2 = assemble(inner(testx, m.dx(0))*dx + inner(testy, m.dx(1))*dx)
v2n = v2.norm('l2')
err = (v1-v2).norm('l2')/v1n
if PRINT: print 'v1n={}, v2n={}, err={:.2e}'.format(v1n, v2n, err)
if err > 1e-14:
if PRINT: print '*** relative error too large!'
sys.exit(1)
err2 = np.abs(costt2 - costl) / np.abs(costl)
print 'ii={}: err={}'.format(ii, err2)
if err2 > 1e-14:
print '*** WARNING: error too large'
sys.exit(1)
print '\t=>> cost OK!'
print 'gradient'
VV = createMixedFS(V, V)
grad = dl.Function(VV)
grada = dl.Function(V)
gradb = dl.Function(V)
for ii in range(10):
a.vector()[:] = np.random.randn(V.dim())
b.vector()[:] = np.random.randn(V.dim())
setfct(grada, reg1.grad(a))
setfct(gradb, reg2.grad(b))
dl.assign(grad.sub(0), grada)
dl.assign(grad.sub(1), gradb)
sumgradab = sumregul.gradab(a, b)
err2 = dl.norm(sumgradab - grad.vector()) / dl.norm(grad.vector())
print 'ii={}: err={}'.format(ii, err2)
if err2 > 1e-14:
print '*** WARNING: error too large'
sys.exit(1)
print '\t=>> gradient OK!'
print 'Hessian'
VV = createMixedFS(V, V)
hess = dl.Function(VV)
hessa = dl.Function(V)
rndnoise = np.random.randn(nbobspt*dimsol).reshape((nbobspt, dimsol))
DD[ii] = dd + sigmas.reshape((len(sigmas),1))*rndnoise
waveobj.dd = DD
waveobj.solvefwd_cost()
if mpirank == 0:
print 'noise misfit={}, regul cost={}, ratio={}'.format(waveobj.cost_misfit, \
waveobj.cost_reg, waveobj.cost_misfit/waveobj.cost_reg)
#myplot.plot_timeseries(waveobj.solfwd[2], 'pd', 0, skip, dl.Function(V))
# Matvec for Hessian
if mpirank == 0: print 'Compute gradient'
waveobj.update_PDE({'b':b_target_fn})
waveobj.solvefwd_cost()
waveobj.solveadj_constructgrad()
x, y = dl.Function(Vm), dl.Function(Vm)
setfct(x, 1.0)
if mpirank == 0: print 'Time Hessian matvec'
for ii in range(10):
MPI.barrier(mpicomm)
t0 = Wtime()
waveobj.mult(x.vector(), y.vector())
t1 = Wtime()
dt = t1-t0
mindt = MPI.min(mpicomm, t1-t0)
maxdt = MPI.max(mpicomm, t1-t0)
avgdt = MPI.sum(mpicomm, t1-t0) / float(mpisize)
if mpirank == 0:
print 'min={}, max={}, avg={}'.format(mindt, maxdt, avgdt)
def test_grad(eps_in, k_in):
mesh = UnitSquareMesh(10, 10)
param = {'eps': eps_in, 'k': k_in}
NN = NuclearNormSVD2D(mesh, param)
NN2 = NuclearNormformula(mesh, param)
direc12 = Function(NN.VV)
m1h, m2h = Function(NN.V), Function(NN.V)
H = [1e-4, 1e-5, 1e-6, 1e-7]
mpicomm = mesh.mpi_comm()
mpirank = MPI.rank(mpicomm)
mpisize = MPI.size(mpicomm)
if mpirank == 0:
print '-------------------------------------'
print 'Test gradient. eps={}'.format(eps)
print '-------------------------------------'
if mpirank == 0: print 'Test 1'
m1 = Function(NN.V)
m2 = Function(NN.V)
grad = NN.gradab(m1, m2)
grad2 = NN2.gradab(m1, m2)
normgrad = norm(grad)
normgrad2 = norm(grad2)
if mpirank == 0:
print '|grad|={}, err={}'.format(normgrad, np.abs(normgrad))
print '|grad2|={}, err={}'.format(normgrad2, np.abs(normgrad2))
M1 = [interpolate(Expression("x[0] + x[1]", degree=10), NN.V),
interpolate(Expression("x[0] * x[1]", degree=10), NN.V),
interpolate(Expression("x[0]*x[0] + x[1]", degree=10), NN.V),
interpolate(Expression('log(10 - ' + \
'(pow(pow(x[0]-0.5,2)+pow(x[1]-0.5,2),0.5)<0.4) * (' + \
'4*(x[0]<=0.5) + 8*(x[0]>0.5) ))', degree=10), NN.V),
interpolate(Expression('log(10 - ' + \
'(pow(pow(x[0]-0.5,2)+pow(x[1]-0.5,2),0.5)<0.4) * 8 )', degree=10), NN.V)]
M2 = [interpolate(Expression("x[0] + x[1]", degree=10), NN.V),
interpolate(Expression("1.0 + cos(x[0])", degree=10), NN.V),
interpolate(Expression("x[1]*x[1] + x[0]", degree=10), NN.V),
interpolate(Expression('log(10 - ' + \
'(pow(pow(x[0]-0.5,2)+pow(x[1]-0.5,2),0.5)<0.4) * (' + \
'8*(x[0]<=0.5) + 4*(x[0]>0.5) ))', degree=10), NN.V),
interpolate(Expression('log(10 - ' + \
'(pow(pow(x[0]-0.5,2)+pow(x[1]-0.5,2),0.5)<0.4) * (' + \
'8*(x[0]<=0.5) + 4*(x[0]>0.5) ))', degree=10), NN.V)]
tt = 2
for m1, m2 in zip(M1, M2):
if mpirank == 0: print '\nTest {}'.format(tt)
tt += 1
grad = NN.gradab(m1, m2)
grad2 = NN2.gradab(m1, m2)
for nn in range(5):
if mpirank == 0: print '--direction {}'.format(nn)
direc1 = interpolate(Expression('1 + sin(n*pi*x[0])*sin(n*pi*x[1])',\
n=nn, degree=10), NN.V)
direc2 = interpolate(Expression('1 + cos(n*pi*x[0])*cos(n*pi*x[1])',\
n=nn, degree=10), NN.V)
assign(direc12.sub(0), direc1)
assign(direc12.sub(1), direc2)
direcderiv = grad.inner(direc12.vector())
direcderiv2 = grad2.inner(direc12.vector())
if mpirank == 0:
print 'grad={}, '.format(direcderiv)
print 'grad2={}, diff={:.2e} '.format(direcderiv2, \
np.abs(direcderiv-direcderiv2)/np.abs(direcderiv))
for hh in H:
setfct(m1h, m1)
m1h.vector().axpy(hh, direc1.vector())
setfct(m2h, m2)
m2h.vector().axpy(hh, direc2.vector())
cost1 = NN.costab(m1h, m2h)
setfct(m1h, m1)
m1h.vector().axpy(-hh, direc1.vector())
setfct(m2h, m2)
m2h.vector().axpy(-hh, direc2.vector())
cost2 = NN.costab(m1h, m2h)
FDdirecderiv = (cost1 - cost2) / (2.0 * hh)
if np.abs(direcderiv) > 1e-16:
err = np.abs(direcderiv -
FDdirecderiv) / np.abs(direcderiv)
else:
err = np.abs(direcderiv - FDdirecderiv)
if mpirank == 0:
print '\th={}, fd={}, err={:.2e}'.format(
hh, FDdirecderiv, err),
if err < 1e-6:
if mpirank == 0: print '\t =>> OK!'
break
else:
if mpirank == 0: print ''
cost = obsopcont.costfct(mv.array(), md.vector().array())
cost_F = obsopcont.costfct_F(m, md)
print 'cost={}, cost_F={}, rel_err={:.2e}'.format(cost, cost_F,\
np.abs(cost-cost_F)/np.abs(cost_F))
# Gradient:
print '\nGradient:'
failures = 0
for nn in range(8):
print '\ttest ' + str(nn+1)
dm_exp = dl.Expression('sin(n*pi*x[0])*sin(n*pi*x[1])', n=nn+1)
dm = dl.interpolate(dm_exp, V)
for h in HH:
success = False
setfct(m_in, m)
m_in.vector().axpy(h, dm.vector())
cost1 = obsopcont.costfct_F(m_in, md)
setfct(m_in, m)
m_in.vector().axpy(-h, dm.vector())
cost2 = obsopcont.costfct_F(m_in, md)
cost = obsopcont.costfct_F(m, md)
GradFD1 = (cost1 - cost)/h
GradFD2 = (cost1 - cost2)/(2.*h)
Gradm = obsopcont.grad(m, md)
Gradm_h = Gradm.inner(dm.vector())
def test_hessian(eps_in):
mesh = UnitSquareMesh(10, 10)
param = {'eps': eps_in}
NN = NuclearNormSVD2D(mesh, param)
NN2 = NuclearNormformula(mesh, param)
direc12 = Function(NN.VV)
m1h, m2h = Function(NN.V), Function(NN.V)
H = [1e-4, 1e-5, 1e-6, 1e-7]
mpicomm = mesh.mpi_comm()
mpirank = MPI.rank(mpicomm)
mpisize = MPI.size(mpicomm)
if mpirank == 0:
print '-------------------------------------'
print 'Test Hessian. eps={}'.format(eps)
print '-------------------------------------'
M1 = [interpolate(Expression("x[0] + x[1]", degree=10), NN.V),
interpolate(Expression("x[0] * x[1]", degree=10), NN.V),
interpolate(Expression("x[0]*x[0] + x[1]", degree=10), NN.V),
interpolate(Expression('log(10 - ' + \
'(pow(pow(x[0]-0.5,2)+pow(x[1]-0.5,2),0.5)<0.4) * (' + \
'4*(x[0]<=0.5) + 8*(x[0]>0.5) ))', degree=10), NN.V),
interpolate(Expression('log(10 - ' + \
'(pow(pow(x[0]-0.5,2)+pow(x[1]-0.5,2),0.5)<0.4) * 8 )', degree=10), NN.V)]
M2 = [interpolate(Expression("x[0] + x[1]", degree=10), NN.V),
interpolate(Expression("1.0 + cos(x[0])", degree=10), NN.V),
interpolate(Expression("x[1]*x[1] + x[0]", degree=10), NN.V),
interpolate(Expression('log(10 - ' + \
'(pow(pow(x[0]-0.5,2)+pow(x[1]-0.5,2),0.5)<0.4) * (' + \
'8*(x[0]<=0.5) + 4*(x[0]>0.5) ))', degree=10), NN.V),
interpolate(Expression('log(10 - ' + \
'(pow(pow(x[0]-0.5,2)+pow(x[1]-0.5,2),0.5)<0.4) * (' + \
'8*(x[0]<=0.5) + 4*(x[0]>0.5) ))', degree=10), NN.V)]
tt = 1
for m1, m2 in zip(M1, M2):
if mpirank == 0: print '\nTest {}'.format(tt)
tt += 1
NN2.assemble_hessianab(m1, m2)
for nn in range(5):
if mpirank == 0: print '--direction {}'.format(nn)
direc1 = interpolate(Expression('1 + sin(n*pi*x[0])*sin(n*pi*x[1])',\
n=nn, degree=10), NN.V)
direc2 = interpolate(Expression('1 + cos(n*pi*x[0])*cos(n*pi*x[1])',\
n=nn, degree=10), NN.V)
assign(direc12.sub(0), direc1)
assign(direc12.sub(1), direc2)
Hv = NN2.hessianab(direc1.vector(), direc2.vector())
HMv = (NN2.H + NN2.sMass) * direc12.vector()
nHv = norm(Hv)
nHMv = norm(HMv)
ndiff = norm(Hv - HMv) / nHv
if mpirank == 0:
print '|Hv|={}, |HMV|={}, |diff|={:.2e}'.format(
nHv, nHMv, ndiff)
for hh in H:
setfct(m1h, m1)
m1h.vector().axpy(hh, direc1.vector())
setfct(m2h, m2)
m2h.vector().axpy(hh, direc2.vector())
grad1 = NN.gradab(m1h, m2h)
setfct(m1h, m1)
m1h.vector().axpy(-hh, direc1.vector())
setfct(m2h, m2)
m2h.vector().axpy(-hh, direc2.vector())
grad2 = NN.gradab(m1h, m2h)
FD = (grad1 - grad2) / (2.0 * hh)
nFD = norm(FD)
if nHv > 1e-16:
err = norm(FD - Hv) / nHv
else:
err = norm(FD - Hv)
if mpirank == 0:
print '\th={}, |FD|={}, err={:.2e}'.format(hh, nFD, err),
if err < 1e-6:
if mpirank == 0: print '\t =>> OK!'
break
else:
if mpirank == 0: print ''
Waveex = AcousticWave({'V': Vex, 'Vm': Vl})
Waveex.timestepper = 'backward'
Waveex.lump = True
Waveex.update({'a':1.0, 'b':1.0, 't0':0.0, 'tf':tf, 'Dt':Dt,\
'u0init':dl.Function(Vex), 'utinit':dl.Function(Vex)})
Waveex.ftime = mysrc
sol, _ = Waveex.solve()
Waveex.exact = dl.Function(Vex)
normex = Waveex.computeabserror()
# plot
myplot.set_varname('u-q' + str(qq))
plotu = dl.Function(Vex)
for index, uu in enumerate(sol):
if index % boolplot == 0:
setfct(plotu, uu[0])
myplot.plot_vtk(plotu, index)
myplot.gather_vtkplots()
print 'Check different spatial sampling'
QQ = [4, 5, 6, 10]
for qq in QQ:
N = int(qq / cmin)
h = 1. / N
mesh = dl.UnitSquareMesh(N, N)
Vl = dl.FunctionSpace(mesh, 'Lagrange', 1)
V = dl.FunctionSpace(mesh, 'Lagrange', r)
Pt = PointSources(V, [[.5, .5]])
mydelta = Pt[0].array()
def mysrc(tt):
def gradhesscheck():
sndorder = True
#HH = [1e-4]
#HH = [1e-4, 1e-5, 1e-6]
HH = [1e-4, 1e-5, 1e-6, 1e-7, 1e-8]
mesh = dl.UnitSquareMesh(100, 100)
V = dl.FunctionSpace(mesh, 'Lagrange', 1)
#k_exp = dl.Expression('1.0 + exp(x[0]*x[1])')
#k = dl.interpolate(k_exp, V)
#k = dl.Constant(1.0)
m_in = dl.Function(V)
TV1 = TV({'Vm': V, 'eps': 1e-4, 'k': 1e-2, 'GNhessian': False})
TV2 = TVPD({'Vm': V, 'eps': 1e-4, 'k': 1e-2, 'exact': True})
#M_EXP = [dl.Expression('1.0'),\
#dl.Expression('1.0 + (x[0]>=0.2)*(x[0]<=0.8)*(x[1]>=0.2)*(x[1]<=0.8)'), \
#dl.Expression('1.0 + (x[0]>=0.2)*(x[0]<=0.8)*(x[1]>=0.2)*(x[1]<=0.8) ' + \
#'+ (x[0]>=0.2)*(x[0]<=0.4)*(x[1]>=0.2)*(x[1]<=0.4)')]
M_EXP = [
dl.Expression('1.0 + (x[0]>=0.2)*(x[0]<=0.8)*(x[1]>=0.2)*(x[1]<=0.8)')
]
for ii, m_exp in enumerate(M_EXP):
# Verification point, i.e., point at which gradient and Hessian are checked
print 'Verification point', str(ii)
#m_exp = dl.Expression('sin(n*pi*x[0])*sin(n*pi*x[1])', n=ii)
m = dl.interpolate(m_exp, V)
print '\nGradient:'
failures = 0
for nn in range(8):
print '\ttest ' + str(nn + 1)
dm_exp = dl.Expression('sin(n*pi*x[0])*sin(n*pi*x[1])', n=nn + 1)
dm = dl.interpolate(dm_exp, V)
for h in HH:
success = False
setfct(m_in, m)
m_in.vector().axpy(h, dm.vector())
cost1 = TV1.cost(m_in)
cost12 = TV2.cost(m_in)
print 'cost1={}, cost12={}, err={}'.format(cost1, cost12, \
np.abs(cost1-cost12)/np.abs(cost1))
if sndorder:
setfct(m_in, m)
m_in.vector().axpy(-h, dm.vector())
cost2 = TV1.cost(m_in)
GradFD = (cost1 - cost2) / (2. * h)
else:
cost = TV1.cost(m)
GradFD = (cost1 - cost) / h
Grad1m = TV1.grad(m)
Grad1m_h = Grad1m.inner(dm.vector())
Grad2m = TV2.grad(m)
Grad2m_h = Grad2m.inner(dm.vector())
if np.abs(Grad1m_h) > 1e-16:
err1 = np.abs(GradFD - Grad1m_h) / np.abs(Grad1m_h)
err2 = np.abs(Grad1m_h - Grad2m_h) / np.abs(Grad1m_h)
else:
err1 = np.abs(GradFD - Grad1m_h)
err2 = np.abs(Grad1m_h - Grad2m_h)
print 'h={}, GradFD={}, Grad1m_h={}, err1={:.2e}'.format(\
h, GradFD, Grad1m_h, err1)
print 'Grad2m_h={}, err12={}'.format(Grad2m_h, err2)
if err1 < 1e-6:
print 'test {}: OK!'.format(nn + 1)
success = True
break
if not success: failures += 1
print '\nTest gradient -- Summary: {} test(s) failed'.format(failures)
#if failures < 5:
if True:
print '\n\nHessian:'
failures = 0
for nn in range(8):
print '\ttest ' + str(nn + 1)
dm_exp = dl.Expression('sin(n*pi*x[0])*sin(n*pi*x[1])',
n=nn + 1)
dm = dl.interpolate(dm_exp, V)
for h in HH:
success = False
setfct(m_in, m)
m_in.vector().axpy(h, dm.vector())
grad1 = TV1.grad(m_in)
if sndorder:
setfct(m_in, m)
m_in.vector().axpy(-h, dm.vector())
grad2 = TV1.grad(m_in)
HessFD = (grad1 - grad2) / (2. * h)
else:
grad = TV1.grad(m)
HessFD = (grad1 - grad) / h
TV1.assemble_hessian(m)
Hess1mdm = TV1.hessian(dm.vector())
TV2.assemble_hessian(m)
Hess2mdm = TV2.hessian(dm.vector())
err1 = (HessFD - Hess1mdm).norm('l2') / Hess1mdm.norm('l2')
err2 = (Hess1mdm -
Hess2mdm).norm('l2') / Hess2mdm.norm('l2')
print 'h={}, err1={}, err12={}'.format(h, err1, err2)
if err1 < 1e-6:
print 'test {}: OK!'.format(nn + 1)
success = True
break
if not success: failures += 1
print '\nTest Hessian -- Summary: {} test(s) failed\n'.format(
failures)
