def exportPointwiseObservation(Vh, B, data, fname, varname="observation"):
"""
This function write a VTK PolyData file to visualize pointwise data.
Inputs:
- B: observation operator
- mesh: mesh
- data: dl.Vector containing the data
- fname: filename for the file to export (without extension)
- varname: name of the variable for the vtk file
"""
mesh = Vh.mesh()
if mesh.geometry().dim() == 1:
xyz_fun = [dl.Expression("x[0]", degree=1)]
elif mesh.geometry().dim() == 2:
xyz_fun = [
dl.Expression("x[0]", degree=1),
dl.Expression("x[1]", degree=1)
]
else:
xyz_fun = [
dl.Expression("x[0]", degree=1),
dl.Expression("x[1]", degree=1),
dl.Expression("x[2]", degree=1)
]
xyz = [B * dl.interpolate(fun, Vh).vector() for fun in xyz_fun]
if dlversion() >= (2016, 1, 0):
xyz_array = np.stack([xi.array() for xi in xyz])
pp = [
dl.Point((xyz_array[:, i]).flatten())
for i in np.arange(xyz_array.shape[1])
]
values = data.array()
fid = dl.XDMFFile(dl.mpi_comm_world(), fname + ".xdmf")
fid.write(pp, values)
else:
data_on_pzero = data.gather_on_zero()
xyz_on_pzero = np.zeros((data_on_pzero.shape[0], 3))
for i in range(len(xyz)):
xyz_on_pzero[:, i] = xyz[i].gather_on_zero()
#check if I'm rank 0, walkaroud to avoid mpi4py
if B.local_range(0)[0] == 0:
write_vtk(xyz_on_pzero, data_on_pzero, fname + ".vtp", varname)
# hIPPYlib is free software; you can redistribute it and/or modify it under the
# terms of the GNU General Public License (as published by the Free
# Software Foundation) version 3.0 dated June 2007.
import dolfin as dl
import numpy as np
from checkDolfinVersion import dlversion
import os
abspath = os.path.dirname(os.path.abspath(__file__))
sdir = os.path.join(abspath, "AssemblePointwiseObservation")
header_file = open(os.path.join(sdir, "AssemblePointwiseObservation.h"), "r")
code = header_file.read()
header_file.close()
#check the dolfin version to decide which cpp to include
if dlversion() == (1, 4, 0):
cpp_sources = ["AssemblePointwiseObservation_v14.cpp"]
elif dlversion() == (1, 5, 0):
cpp_sources = ["AssemblePointwiseObservation_v15.cpp"]
elif dlversion() >= (1, 6, 0):
cpp_sources = ["AssemblePointwiseObservation_v16.cpp"]
else:
raise Exception("Dolfin Version")
cpp_module = dl.compile_extension_module(code=code,
source_directory=sdir,
sources=cpp_sources,
include_dirs=[".", sdir])
def assemblePointwiseObservation(Vh, targets):
def __init__(self,
Vh,
gamma,
delta,
locations,
m_true,
Theta=None,
pen=1e1,
order=2,
rel_tol=1e-12,
max_iter=1000):
"""
Construct the Prior model.
Input:
- Vh: the finite element space for the parameter
- gamma and delta: the coefficient in the PDE
- locations: the points x_i at which we assume to know the
true value of the parameter
- m_true: the true model
- Theta: the s.p.d. tensor for anisotropic diffusion of the pde
- pen: a penalization parameter for the mollifier
"""
assert delta != 0. or pen != 0, "Intrinsic Gaussian Prior are not supported"
self.Vh = Vh
trial = dl.TrialFunction(Vh)
test = dl.TestFunction(Vh)
if Theta == None:
varfL = dl.inner(dl.nabla_grad(trial), dl.nabla_grad(test)) * dl.dx
else:
varfL = dl.inner(Theta * dl.grad(trial), dl.grad(test)) * dl.dx
varfM = dl.inner(trial, test) * dl.dx
self.M = dl.assemble(varfM)
self.Msolver = dl.PETScKrylovSolver("cg", "jacobi")
self.Msolver.set_operator(self.M)
self.Msolver.parameters["maximum_iterations"] = max_iter
self.Msolver.parameters["relative_tolerance"] = rel_tol
self.Msolver.parameters["error_on_nonconvergence"] = True
self.Msolver.parameters["nonzero_initial_guess"] = False
#mfun = Mollifier(gamma/delta, dl.inv(Theta), order, locations)
mfun = dl.Expression(code_Mollifier,
degree=Vh.ufl_element().degree() + 2)
mfun.l = gamma / delta
mfun.o = order
mfun.theta0 = 1. / Theta.theta0
mfun.theta1 = 1. / Theta.theta1
mfun.alpha = Theta.alpha
for ii in range(locations.shape[0]):
mfun.addLocation(locations[ii, 0], locations[ii, 1])
varfmo = mfun * dl.inner(trial, test) * dl.dx
MO = dl.assemble(pen * varfmo)
self.A = dl.assemble(gamma * varfL + delta * varfM + pen * varfmo)
self.Asolver = dl.PETScKrylovSolver("cg", amg_method())
self.Asolver.set_operator(self.A)
self.Asolver.parameters["maximum_iterations"] = max_iter
self.Asolver.parameters["relative_tolerance"] = rel_tol
self.Asolver.parameters["error_on_nonconvergence"] = True
self.Asolver.parameters["nonzero_initial_guess"] = False
old_qr = dl.parameters["form_compiler"]["quadrature_degree"]
dl.parameters["form_compiler"]["quadrature_degree"] = -1
qdegree = 2 * Vh._ufl_element.degree()
metadata = {"quadrature_degree": qdegree}
if dlversion() == (2017, 1, 0):
representation_old = dl.parameters["form_compiler"][
"representation"]
dl.parameters["form_compiler"]["representation"] = "quadrature"
if dlversion() <= (1, 6, 0):
Qh = dl.FunctionSpace(Vh.mesh(), 'Quadrature', qdegree)
else:
element = dl.FiniteElement("Quadrature",
Vh.mesh().ufl_cell(),
qdegree,
quad_scheme="default")
Qh = dl.FunctionSpace(Vh.mesh(), element)
ph = dl.TrialFunction(Qh)
qh = dl.TestFunction(Qh)
Mqh = dl.assemble(ph * qh * dl.dx(metadata=metadata))
ones = dl.interpolate(dl.Constant(1.), Qh).vector()
dMqh = Mqh * ones
Mqh.zero()
dMqh.set_local(ones.array() / np.sqrt(dMqh.array()))
Mqh.set_diagonal(dMqh)
MixedM = dl.assemble(ph * test * dl.dx(metadata=metadata))
self.sqrtM = MatMatMult(MixedM, Mqh)
dl.parameters["form_compiler"]["quadrature_degree"] = old_qr
if dlversion() == (2017, 1, 0):
dl.parameters["form_compiler"][
"representation"] = representation_old
self.R = _BilaplacianR(self.A, self.Msolver)
self.Rsolver = _BilaplacianRsolver(self.Asolver, self.M)
rhs = dl.Vector()
self.mean = dl.Vector()
self.init_vector(rhs, 0)
self.init_vector(self.mean, 0)
MO.mult(m_true, rhs)
self.Asolver.solve(self.mean, rhs)
def __init__(self,
Vh,
gamma,
delta,
Theta=None,
mean=None,
rel_tol=1e-12,
max_iter=1000):
"""
Construct the Prior model.
Input:
- Vh: the finite element space for the parameter
- gamma and delta: the coefficient in the PDE
- Theta: the s.p.d. tensor for anisotropic diffusion of the pde
- mean: the prior mean
"""
assert delta != 0., "Intrinsic Gaussian Prior are not supported"
self.Vh = Vh
trial = dl.TrialFunction(Vh)
test = dl.TestFunction(Vh)
if Theta == None:
varfL = dl.inner(dl.nabla_grad(trial), dl.nabla_grad(test)) * dl.dx
else:
varfL = dl.inner(Theta * dl.grad(trial), dl.grad(test)) * dl.dx
varfM = dl.inner(trial, test) * dl.dx
self.M = dl.assemble(varfM)
self.Msolver = dl.PETScKrylovSolver("cg", "jacobi")
self.Msolver.set_operator(self.M)
self.Msolver.parameters["maximum_iterations"] = max_iter
self.Msolver.parameters["relative_tolerance"] = rel_tol
self.Msolver.parameters["error_on_nonconvergence"] = True
self.Msolver.parameters["nonzero_initial_guess"] = False
self.A = dl.assemble(gamma * varfL + delta * varfM)
self.Asolver = dl.PETScKrylovSolver("cg", amg_method())
self.Asolver.set_operator(self.A)
self.Asolver.parameters["maximum_iterations"] = max_iter
self.Asolver.parameters["relative_tolerance"] = rel_tol
self.Asolver.parameters["error_on_nonconvergence"] = True
self.Asolver.parameters["nonzero_initial_guess"] = False
old_qr = dl.parameters["form_compiler"]["quadrature_degree"]
dl.parameters["form_compiler"]["quadrature_degree"] = -1
qdegree = 2 * Vh._ufl_element.degree()
metadata = {"quadrature_degree": qdegree}
if dlversion() == (2017, 1, 0):
representation_old = dl.parameters["form_compiler"][
"representation"]
dl.parameters["form_compiler"]["representation"] = "quadrature"
if dlversion() <= (1, 6, 0):
Qh = dl.FunctionSpace(Vh.mesh(), 'Quadrature', qdegree)
else:
#element = dl.FiniteElement("Quadrature", Vh.mesh().ufl_cell(), qdegree, quad_scheme="default")
element = dl.VectorElement("Quadrature",
Vh.mesh().ufl_cell(),
qdegree,
quad_scheme="default")
Qh = dl.FunctionSpace(Vh.mesh(), element)
ph = dl.TrialFunction(Qh)
qh = dl.TestFunction(Qh)
#Mqh = dl.assemble(ph*qh*dl.dx(metadata=metadata))
Mqh = dl.assemble(dl.inner(ph, qh) * dl.dx(metadata=metadata))
#ones = dl.interpolate(dl.Constant(1., 1., 1.), Qh).vector()
ones = dl.Vector()
Mqh.init_vector(ones, 0)
ones.set_local(np.ones(ones.array().shape, dtype=ones.array().dtype))
dMqh = Mqh * ones
Mqh.zero()
dMqh.set_local(ones.array() / np.sqrt(dMqh.array()))
Mqh.set_diagonal(dMqh)
#MixedM = dl.assemble(ph*test*dl.dx(metadata=metadata))
MixedM = dl.assemble(dl.inner(ph, test) * dl.dx(metadata=metadata))
self.sqrtM = MatMatMult(MixedM, Mqh)
dl.parameters["form_compiler"]["quadrature_degree"] = old_qr
if dlversion() == (2017, 1, 0):
dl.parameters["form_compiler"][
"representation"] = representation_old
self.R = _BilaplacianR(self.A, self.Msolver)
self.Rsolver = _BilaplacianRsolver(self.Asolver, self.M)
self.mean = mean
if self.mean is None:
self.mean = dl.Vector()
self.init_vector(self.mean, 0)
def __init__(self,
Vh,
gamma,
delta,
mean=None,
rel_tol=1e-12,
max_iter=100):
"""
Construct the Prior model.
Input:
- Vh: the finite element space for the parameter
- gamma and delta: the coefficient in the PDE
- Theta: the s.p.d. tensor for anisotropic diffusion of the pde
- mean: the prior mean
"""
assert delta != 0., "Intrinsic Gaussian Prior are not supported"
self.Vh = Vh
trial = dl.TrialFunction(Vh)
test = dl.TestFunction(Vh)
varfL = dl.inner(dl.nabla_grad(trial), dl.nabla_grad(test)) * dl.dx
varfM = dl.inner(trial, test) * dl.dx
self.M = dl.assemble(varfM)
self.R = dl.assemble(gamma * varfL + delta * varfM)
self.Rsolver = dl.PETScKrylovSolver("cg", amg_method())
self.Rsolver.set_operator(self.R)
self.Rsolver.parameters["maximum_iterations"] = max_iter
self.Rsolver.parameters["relative_tolerance"] = rel_tol
self.Rsolver.parameters["error_on_nonconvergence"] = True
self.Rsolver.parameters["nonzero_initial_guess"] = False
self.Msolver = dl.PETScKrylovSolver("cg", "jacobi")
self.Msolver.set_operator(self.M)
self.Msolver.parameters["maximum_iterations"] = max_iter
self.Msolver.parameters["relative_tolerance"] = rel_tol
self.Msolver.parameters["error_on_nonconvergence"] = True
self.Msolver.parameters["nonzero_initial_guess"] = False
ndim = Vh.mesh().geometry().dim()
qdegree = 2 * Vh._ufl_element.degree()
metadata = {"quadrature_degree": qdegree}
if dlversion() <= (1, 6, 0):
Qh = dl.VectorFunctionSpace(Vh.mesh(),
'Quadrature',
qdegree,
dim=(ndim + 1))
else:
element = dl.VectorElement("Quadrature",
Vh.mesh().ufl_cell(),
qdegree,
dim=(ndim + 1),
quad_scheme="default")
Qh = dl.FunctionSpace(Vh.mesh(), element)
ph = dl.TrialFunction(Qh)
qh = dl.TestFunction(Qh)
pph = dl.split(ph)
Mqh = dl.assemble(dl.inner(ph, qh) * dl.dx(metadata=metadata))
ones = dl.Vector()
Mqh.init_vector(ones, 0)
ones.set_local(np.ones(ones.array().shape, dtype=ones.array().dtype))
dMqh = Mqh * ones
dMqh.set_local(ones.array() / np.sqrt(dMqh.array()))
Mqh.zero()
Mqh.set_diagonal(dMqh)
sqrtdelta = math.sqrt(delta)
sqrtgamma = math.sqrt(gamma)
varfGG = sqrtdelta * pph[0] * test * dl.dx(metadata=metadata)
for i in range(ndim):
varfGG = varfGG + sqrtgamma * pph[i + 1] * test.dx(i) * dl.dx(
metadata=metadata)
GG = dl.assemble(varfGG)
self.sqrtR = MatMatMult(GG, Mqh)
self.mean = mean
if self.mean is None:
self.mean = dl.Vector()
self.init_vector(self.mean, 0)
def _createLUSolver(self):
if dlversion() <= (1,6,0):
return dl.PETScLUSolver()
else:
return dl.PETScLUSolver(self.Vh[STATE].mesh().mpi_comm() )
