Exemplo n.º 1
0
        print 'MAP: min(a)={}, max(a)={}'.format(mina, maxa)
        print 'med_misfit={:.4e}, err={:.1f}%'.format(norm_mmfa, erra)

        print '\ntarget: min(b)={}, max(b)={}'.format(minbt, maxbt)
        print 'init: min(b)={}, max(b)={}'.format(minb0, maxb0)
        print 'MAP: min(b)={}, max(b)={}'.format(minb, maxb)
        print 'med_misfit={:.4e}, err={:.1f}%'.format(norm_mmfb, errb)

        print '\ntarget: min(c)={}, max(c)={}'.format(minct, maxct)
        print 'MAP: min(c)={}, max(c)={}'.format(minc, maxc)
        print 'med_misfit={:.4e}, err={:.1f}%'.format(norm_mmfc, errc)

        # WARNING: only makes sense if mpicomm_local == mpi_comm_self
        # otherwise, can't be restricted to PRINT processor only
        plotfolder = PARAM + '_k' + str(k) + '_e' + str(eps)
        myplot = PlotFenics(Outputfolder='output_transmission/plots/' + plotfolder, \
        comm = mesh.mpi_comm())
        waveobj._plotab(
            myplot,
            '-map_' + PARAM + '-VTV_' + amg + '_k' + str(k) + '_e' + str(eps))

        myplot.set_varname('c-map_' + PARAM + '-VTV_' + amg + '_k' + str(k) +
                           '_e' + str(eps))
        myplot.plot_vtk(cf)
    """
    # Test gradient and Hessian after several steps of Newton method
    waveobj.GN = False
    waveobj.regularization = ZeroRegularization(Vl)
    if ALL and (PARAM == 'a' or PARAM == 'b') and PRINT:
        print '*** Warning: Single inversion but changing both parameters'
    MPa = [
    dl.Constant('1.0'), 
Exemplo n.º 2
0
"""
Plot selected medium parameters
"""
import sys
from os.path import splitext, isdir
from shutil import rmtree
import dolfin as dl
from dolfin import MPI
from fenicstools.plotfenics import PlotFenics
from mediumparameters1 import \
targetmediumparameters, initmediumparameters, loadparameters

LARGE = True
Nxy, Dt, fpeak, _, _, _, tf = loadparameters(LARGE)

X, Y = 1, 1
mesh = dl.UnitSquareMesh(Nxy, Nxy)
Vl = dl.FunctionSpace(mesh, 'Lagrange', 1)

mpicomm = mesh.mpi_comm()
mpirank = MPI.rank(mpicomm)
filename, ext = splitext(sys.argv[0])
if mpirank == 0:
    if isdir(filename + '/'): rmtree(filename + '/')
MPI.barrier(mpicomm)
myplot = PlotFenics(mpicomm, filename)

at, bt, c, lam, rho = targetmediumparameters(Vl, X, myplot)
a0, b0, _, _, _ = initmediumparameters(Vl, X, myplot)
    # define pde operator:
    wavepde = AcousticWave({'V': V, 'Vm': Vm})
    wavepde.timestepper = 'backward'
    wavepde.lump = True
    wavepde.update({'a':a_target_fn, 'b':b_target_fn, \
    't0':t0, 'tf':tf, 'Dt':Dt, 'u0init':dl.Function(V), 'utinit':dl.Function(V)})

    # parameters
    Vm = wavepde.Vm
    V = wavepde.V
    lenobspts = obsop.PtwiseObs.nbPts

    # set up plots:
    filename, ext = splitext(sys.argv[0])
    if isdir(filename + '/'): rmtree(filename + '/')
    myplot = PlotFenics(filename + str(Nxy))
    myplot.set_varname('a_target')
    myplot.plot_vtk(a_target_fn)

    # define objective function:
    regul = LaplacianPrior({
        'Vm': Vm,
        'gamma': 5e-4,
        'beta': 5e-4,
        'm0': a_target_fn
    })
    waveobj = ObjectiveAcoustic(wavepde, mysrc, 'a', regul)
    waveobj.obsop = obsop

    # noisy data
    print 'generate noisy data'
Exemplo n.º 4
0
from fenicstools.acousticwave import AcousticWave
from fenicstools.plotfenics import PlotFenics
from fenicstools.miscfenics import setfct

r = 2  # polynomial order
c = 1.0  # wave velocity
freq = 4.0  # Hz
maxfreq = 10.0
cmin = c / maxfreq
Ricker = RickerWavelet(freq, 1e-10)
Dt = 1e-4
tf = 0.5

filename, ext = splitext(sys.argv[0])
if isdir(filename + '/'): rmtree(filename + '/')
myplot = PlotFenics(filename)
boolplot = 100

print 'Compute most accurate solution as reference'
qq = 20
N = int(qq / cmin)
h = 1. / N
mesh = dl.UnitSquareMesh(N, N)
Vl = dl.FunctionSpace(mesh, 'Lagrange', 1)
Vex = dl.FunctionSpace(mesh, 'Lagrange', r)
Pt = PointSources(Vex, [[.5, .5]])
mydelta = Pt[0].array()


def mysrc(tt):
    return Ricker(tt) * mydelta
    Wave.timestepper = 'centered'
    Wave.lump = True
    Wave.set_abc(mesh, AllFour(), True)
    Wave.exact = Function(V)
    Wave.update({'b':1.0, 'a':1.0, 't0':0.0, 'tf':tf, 'Dt':Dt,\
    'u0init':Function(V), 'utinit':Function(V)})
    Wave.ftime = mysrc
    sol, error = Wave.solve()
    ERROR.append(error)
    if myrank == 0: print 'relative error = {:.5e}'.format(error)
    if not mycomm == None: MPI.barrier(mycomm)

# Plots:
try:
    boolplot = int(sys.argv[1])
except:
    boolplot = 0
if boolplot > 0:
    filename, ext = splitext(sys.argv[0])
    if myrank == 0:
        if isdir(filename + '/'): rmtree(filename + '/')
    if not mycomm == None: MPI.barrier(mycomm)
    myplot = PlotFenics(filename)
    myplot.set_varname('p')
    plotp = Function(V)
    for index, pp in enumerate(sol):
        if index % boolplot == 0:
            plotp.vector()[:] = pp[0]
            myplot.plot_vtk(plotp, index)
    myplot.gather_vtkplots()
u0 = dl.Constant("0.0")
bc = dl.DirichletBC(V, u0, u0_boundary)

mtrue_exp = \
dl.Expression('1.0 + 7.0*(x[0]<=0.8)*(x[0]>=0.2)*(x[1]<=0.8)*(x[1]>=0.2)')
mtrue = dl.interpolate(mtrue_exp, Vme)  # target medium
mtrueVm = dl.interpolate(mtrue_exp, Vm)  # target medium
f = dl.Expression("1.0")  # source term

# set up plots:
if PLOT:
    filename, ext = splitext(sys.argv[0])
    if mpirank == 0 and isdir(filename + '/'):
        rmtree(filename + '/')
    MPI.barrier(mpicomm)
    myplot = PlotFenics(filename)
    MPI.barrier(mpicomm)
    myplot.set_varname('m_target')
    myplot.plot_vtk(mtrue)
    myplot.set_varname('m_targetVm')
    myplot.plot_vtk(mtrueVm)
else:
    myplot = None

if mpirank == 0: print 'Compute noisy data'
OPPS = 15
NB = OPPS + 1.
Points = np.array([[[ii/NB,jj/NB] for ii in range(1,OPPS+1)]\
 for jj in range(1,OPPS+1)])
Points.resize((OPPS * OPPS, 2))
ObsOp = ObsPointwise({'V': V, 'Points': Points}, mpicomm)
Exemplo n.º 7
0
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()
def run_test(fpeak, lambdamin, lambdamax, Nxy, tfilterpts, r, Dt, skip):
    h = 1./Nxy
    checkdt(Dt, h, r, np.sqrt(lambdamax), True)
    mesh = dl.UnitSquareMesh(Nxy, Nxy)
    Vl = dl.FunctionSpace(mesh, 'Lagrange', 1)
    V = dl.FunctionSpace(mesh, 'Lagrange', r)
    fctV = dl.Function(V)
    # set up plots:
    filename, ext = splitext(sys.argv[0])
    if isdir(filename + '/'):   rmtree(filename + '/')
    myplot = PlotFenics(filename)
    # source:
    Ricker = RickerWavelet(fpeak, 1e-10)
    Pt = PointSources(V, [[0.5,0.5]])
    mydelta = Pt[0].array()
    def mysrc(tt):
        return Ricker(tt)*mydelta
    # target medium:
    lambda_target = dl.Expression('lmin + x[0]*(lmax-lmin)', \
    lmin=lambdamin, lmax=lambdamax)
    lambda_target_fn = dl.interpolate(lambda_target, Vl)
    myplot.set_varname('lambda_target')
    myplot.plot_vtk(lambda_target_fn)
    # initial medium:
    lambda_init = dl.Constant(lambdamin)
    lambda_init_fn = dl.interpolate(lambda_init, Vl)
    myplot.set_varname('lambda_init')
    myplot.plot_vtk(lambda_init_fn)
    # observation operator:
    #obspts = [[0.2, 0.5], [0.5, 0.2], [0.5, 0.8], [0.8, 0.5]]
    obspts = [[0.2, ii/10.] for ii in range(2,9)] + \
    [[0.8, ii/10.] for ii in range(2,9)] + \
    [[ii/10., 0.2] for ii in range(3,8)] + \
    [[ii/10., 0.8] for ii in range(3,8)]
    obsop = TimeObsPtwise({'V':V, 'Points':obspts}, tfilterpts)
    # define pde operator:
    wavepde = AcousticWave({'V':V, 'Vl':Vl, 'Vr':Vl})
    wavepde.timestepper = 'centered'
    wavepde.lump = True
    wavepde.set_abc(mesh, LeftRight(), True)
    wavepde.update({'lambda':lambda_target_fn, 'rho':1.0, \
    't0':t0, 'tf':tf, 'Dt':Dt, 'u0init':dl.Function(V), 'utinit':dl.Function(V)})
    wavepde.ftime = mysrc
    # define objective function:
    waveobj = ObjectiveAcoustic(wavepde)
    waveobj.obsop = obsop
    # data
    print 'generate noisy data'
    waveobj.solvefwd()
    myplot.plot_timeseries(waveobj.solfwd, 'pd', 0, skip, fctV)
    dd = waveobj.Bp.copy()
    nbobspt, dimsol = dd.shape
    noiselevel = 0.1   # = 10%
    sigmas = np.sqrt((dd**2).sum(axis=1)/dimsol)*noiselevel
    rndnoise = np.random.randn(nbobspt*dimsol).reshape((nbobspt, dimsol))
    waveobj.dd = dd + sigmas.reshape((len(sigmas),1))*rndnoise
    # gradient
    print 'generate observations'
    waveobj.update_m(lambda_init_fn)
    waveobj.solvefwd_cost()
    cost1 = waveobj.misfit
    print 'misfit = {}'.format(waveobj.misfit)
    myplot.plot_timeseries(waveobj.solfwd, 'p', 0, skip, fctV)
    # Plot data and observations
    fig = plt.figure()
    if len(obspts) > 9: fig.set_size_inches(20., 15.)
    for ii in range(len(obspts)):
        if len(obspts) == 4:    ax = fig.add_subplot(2,2,ii+1)
        else:   ax = fig.add_subplot(4,6,ii+1)
        ax.plot(waveobj.PDE.times, waveobj.dd[ii,:], 'k--')
        ax.plot(waveobj.PDE.times, waveobj.Bp[ii,:], 'b')
        ax.set_title('Plot'+str(ii))
    fig.savefig(filename + '/observations.eps')
    print 'compute gradient'
    waveobj.solveadj_constructgrad()
    myplot.plot_timeseries(waveobj.soladj, 'v', 0, skip, fctV)
    MG = waveobj.MGv.array().copy()
    myplot.set_varname('grad')
    myplot.plot_vtk(waveobj.Grad)
    print 'check gradient with FD'
    Medium = np.zeros((5, Vl.dim()))
    for ii in range(5):
        smoothperturb = dl.Expression('sin(n*pi*x[0])*sin(n*pi*x[1])', n=ii+1)
        smoothperturb_fn = dl.interpolate(smoothperturb, Vl)
        Medium[ii,:] = smoothperturb_fn.vector().array()
    checkgradfd_med(waveobj, Medium, 1e-6, [1e-5, 1e-4])
    print 'check Hessian with FD'
    checkhessfd_med(waveobj, Medium, 1e-6, [1e-1, 1e-2, 1e-3, 1e-4, 1e-5], False)
def run_test(fpeak, lambdamin, lambdamax, Nxy, tfilterpts, r, Dt, skip):
    h = 1. / Nxy
    checkdt(Dt, h, r, np.sqrt(lambdamax), True)
    mesh = dl.UnitSquareMesh(Nxy, Nxy)
    Vl = dl.FunctionSpace(mesh, 'Lagrange', 1)
    V = dl.FunctionSpace(mesh, 'Lagrange', r)
    fctV = dl.Function(V)
    # set up plots:
    filename, ext = splitext(sys.argv[0])
    if isdir(filename + '/'): rmtree(filename + '/')
    myplot = PlotFenics(filename)
    # source:
    Ricker = RickerWavelet(fpeak, 1e-10)
    Pt = PointSources(V, [[0.5, 0.5]])
    mydelta = Pt[0].array()

    def mysrc(tt):
        return Ricker(tt) * mydelta

    # target medium:
    lambda_target = dl.Expression('lmin + x[0]*(lmax-lmin)', \
    lmin=lambdamin, lmax=lambdamax)
    lambda_target_fn = dl.interpolate(lambda_target, Vl)
    myplot.set_varname('lambda_target')
    myplot.plot_vtk(lambda_target_fn)
    # initial medium:
    lambda_init = dl.Constant(lambdamin)
    lambda_init_fn = dl.interpolate(lambda_init, Vl)
    myplot.set_varname('lambda_init')
    myplot.plot_vtk(lambda_init_fn)
    # observation operator:
    #obspts = [[0.2, 0.5], [0.5, 0.2], [0.5, 0.8], [0.8, 0.5]]
    obspts = [[0.2, ii/10.] for ii in range(2,9)] + \
    [[0.8, ii/10.] for ii in range(2,9)] + \
    [[ii/10., 0.2] for ii in range(3,8)] + \
    [[ii/10., 0.8] for ii in range(3,8)]
    obsop = TimeObsPtwise({'V': V, 'Points': obspts}, tfilterpts)
    # define pde operator:
    wavepde = AcousticWave({'V': V, 'Vl': Vl, 'Vr': Vl})
    wavepde.timestepper = 'backward'
    wavepde.lump = True
    wavepde.set_abc(mesh, LeftRight(), True)
    wavepde.update({'lambda':lambda_target_fn, 'rho':1.0, \
    't0':t0, 'tf':tf, 'Dt':Dt, 'u0init':dl.Function(V), 'utinit':dl.Function(V)})
    wavepde.ftime = mysrc
    # define objective function:
    waveobj = ObjectiveAcoustic(wavepde)
    waveobj.obsop = obsop
    # data
    print 'generate data'
    waveobj.solvefwd()
    myplot.plot_timeseries(waveobj.solfwd, 'pd', 0, skip, fctV)
    dd = waveobj.Bp.copy()
    # gradient
    print 'generate observations'
    waveobj.dd = dd
    waveobj.update_m(lambda_init_fn)
    waveobj.solvefwd_cost()
    cost1 = waveobj.misfit
    print 'misfit = {}'.format(waveobj.misfit)
    myplot.plot_timeseries(waveobj.solfwd, 'p', 0, skip, fctV)
    # Plot data and observations
    fig = plt.figure()
    if len(obspts) > 9: fig.set_size_inches(20., 15.)
    for ii in range(len(obspts)):
        if len(obspts) == 4: ax = fig.add_subplot(2, 2, ii + 1)
        else: ax = fig.add_subplot(4, 6, ii + 1)
        ax.plot(waveobj.PDE.times, waveobj.dd[ii, :], 'k--')
        ax.plot(waveobj.PDE.times, waveobj.Bp[ii, :], 'b')
        ax.set_title('Plot' + str(ii))
    fig.savefig(filename + '/observations.eps')
    print 'compute gradient'
    waveobj.solveadj_constructgrad()
    myplot.plot_timeseries(waveobj.soladj, 'v', 0, skip, fctV)
    MG = waveobj.MGv.array().copy()
    myplot.set_varname('grad')
    myplot.plot_vtk(waveobj.Grad)
    """
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)
    plotp = Function(V)
    myplot.plot_timeseries(sol, 'p', 0, boolplot, plotp)
    # Plot medium
    myplot.set_varname('lambda')
    myplot.plot_vtk(lambda_target_fn)
    # Plot observations
    fig = plt.figure()
    for ii in range(Bp.shape[0]):
        ax = fig.add_subplot(2, 2, ii + 1)
        ax.plot(mytimes, Bp[ii, :], 'b')
        ax.plot(mytimes, Bpf[ii, :], 'r--')
        ax.set_title('Plot' + str(ii))
    fig.savefig(filename + '/observations_p' + str(myrank) + '.eps')
bc = DirichletBC(V, u0, u0_boundary)
# Define target medium and rhs:
mtrue_exp = Expression("1 + 7*(pow(pow(x[0] - 0.5,2) +" + " pow(x[1] - 0.5,2),0.5) > 0.2)")
mtrue = interpolate(mtrue_exp, Vme)
f = Expression("1.0")

if myrank == 0:
    print "Compute target data".format(myrank)
obspts = [[ii / 5.0, jj / 5.0] for ii in range(1, 5) for jj in range(1, 5)]
noisepercent = 0.10  # e.g., 0.02 = 2% noise level
ObsOp = ObsPointwise({"V": V, "Points": obspts, "noise": noisepercent}, mycomm)
goal = ObjFctalElliptic(V, Vme, bc, bc, [f], ObsOp, [], [], [], False, mycomm)
goal.update_m(mtrue)
goal.solvefwd()
UDnoise = goal.U

if myrank == 0:
    print "Define prior and sample from prior"
m0 = Function(Vm)
m0.vector()[:] = 1.0
myprior = BilaplacianPrior({"Vm": Vm, "gamma": 10.0, "beta": 10.0, "m0": m0})
filename, ext = splitext(sys.argv[0])
if isdir(filename + "/"):
    rmtree(filename + "/")
plotprior = PlotFenics(filename + "/Prior/")
plotprior.set_varname("m_prior")
for ii in range(10):
    mypriorsample = myprior.sample()
    plotprior.plot_vtk(mypriorsample, ii)
plotprior.gather_vtkplots()
    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 + '/')
    if not mycomm == None:  MPI.barrier(mycomm)
    myplot = PlotFenics(filename)
    plotp = Function(V)
    myplot.plot_timeseries(sol, 'p', 0, boolplot, plotp)
#    myplot.set_varname('p')
#    for index, pp in enumerate(sol):
#        if index%boolplot == 0:
#            setfct(plotp, pp[0])
#            myplot.plot_vtk(plotp, index)
#    myplot.gather_vtkplots()
    # Plot medium
    myplot.set_varname('lambda')
    myplot.plot_vtk(lambda_target_fn)
    # Plot observations
    fig = plt.figure()
    for ii in range(Bp.shape[0]):
        ax = fig.add_subplot(2,2,ii+1)
Exemplo n.º 13
0
from fenicstools.acousticwave import AcousticWave
from fenicstools.plotfenics import PlotFenics
from fenicstools.miscfenics import setfct

r = 2   # polynomial order
c = 1.0 # wave velocity
freq = 4.0  # Hz
maxfreq = 10.0
cmin = c/maxfreq
Ricker = RickerWavelet(freq, 1e-10)
Dt = 1e-4
tf = 0.5

filename, ext = splitext(sys.argv[0])
if isdir(filename + '/'):   rmtree(filename + '/')
myplot = PlotFenics(filename)
boolplot = 100

print 'Compute most accurate solution as reference'
qq = 20
N = int(qq/cmin)
h = 1./N
mesh = dl.UnitSquareMesh(N,N)
Vl = dl.FunctionSpace(mesh, 'Lagrange', 1)
Vex = dl.FunctionSpace(mesh, 'Lagrange', r)
Pt = PointSources(Vex, [[.5,.5]])
mydelta = Pt[0].array()
def mysrc(tt):
    return Ricker(tt)*mydelta
Waveex = AcousticWave({'V':Vex, 'Vl':Vl, 'Vr':Vl})
Waveex.timestepper = 'backward'
Exemplo n.º 14
0
from fenicstools.miscfenics import createMixedFS
from fenicstools.plotfenics import PlotFenics
from fenicstools.jointregularization import crossgradient, normalizedcrossgradient
from fenicstools.linalg.miscroutines import compute_eigfenics

N = 40
mesh = dl.UnitSquareMesh(N,N)
V = dl.FunctionSpace(mesh, 'CG', 1)
mpirank = dl.MPI.rank(mesh.mpi_comm())

VV = createMixedFS(V, V)
cg = crossgradient(VV)
ncg = normalizedcrossgradient(VV)

outdir = 'Output-CGvsNCG-' + str(N) + 'x' + str(N) + '/'
plotfenics = PlotFenics(mesh.mpi_comm(), outdir)

a1true = [
dl.interpolate(dl.Expression('log(10 - ' + 
'(x[0]>0.25)*(x[0]<0.75)*(x[1]>0.25)*(x[1]<0.75) * 8 )'), V),
dl.interpolate(dl.Expression('log(10 - ' + 
'(x[0]>0.25)*(x[0]<0.75)*(x[1]>0.25)*(x[1]<0.75) * (' + 
'4*(x[0]<=0.5) + 8*(x[0]>0.5) ))'), V),
dl.interpolate(dl.Expression('log(10 - ' + 
'(x[0]>0.25)*(x[0]<0.75)*(x[1]>0.25)*(x[1]<0.75) * (' + 
'4*(x[0]<=0.5) + 8*(x[0]>0.5) ))'), V),
dl.interpolate(dl.Expression('log(10 - ' + 
'(x[0]>0.25)*(x[0]<0.75)*(x[1]>0.25)*(x[1]<0.75) * (' + 
'4*(x[0]<=0.5) + 8*(x[0]>0.5) ))'), V)]
a2true = [
dl.interpolate(dl.Expression('log(10 - ' + 
cmax = 3.0
epsmin = -1.0  # medium perturbation
epsmax = 1.0  # medium perturbation
h = 1.0 / Nxy
r = 2
checkdt(Dt, h, r, cmax + epsmax, True)
# mesh
mesh = dl.UnitSquareMesh(Nxy, Nxy)
Vl, V = dl.FunctionSpace(mesh, "Lagrange", 1), dl.FunctionSpace(mesh, "Lagrange", r)
fctV = dl.Function(V)
fctVl = dl.Function(Vl)
# set up plots:
filename, ext = splitext(sys.argv[0])
if isdir(filename + "/"):
    rmtree(filename + "/")
myplot = PlotFenics(filename)
# source:
Ricker = RickerWavelet(fpeak, 1e-10)
Pt = PointSources(V, [[0.5, 1.0]])
mydelta = Pt[0].array()


def mysrc(tt):
    return Ricker(tt) * mydelta


# target medium
medformula = "A*A*(x[1]>=0.5) + 2.0*2.0*(x[1]<0.5)"
TargetMedExpr = dl.Expression(medformula, A=1.5)
TargetMed = dl.interpolate(TargetMedExpr, Vl)
myplot.set_varname("target_medium")
Exemplo n.º 16
0
# Convergence order:
CONVORDER = []
for ii in range(len(ERROR)-1):
    CONVORDER.append(np.log(ERROR[ii+1]/ERROR[ii])/np.log((1./NN[ii+1])/(1./NN[ii])))
print '\n\norder of convergence:', CONVORDER

# Save plots:
try:
    boolplot = int(sys.argv[1])
except:
    boolplot = 0
if boolplot > 0:
    filename, ext = splitext(sys.argv[0])
    if isdir(filename + '/'):   rmtree(filename + '/')
    myplot = PlotFenics(filename)
    myplot.set_varname('p')
    plotp = Function(V)
    for index, pp in enumerate(sol):
        plotp.vector()[:] = pp[0]
        myplot.plot_vtk(plotp, index)
    myplot.gather_vtkplots()

    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.loglog(1./NN, ERROR, '-o')
    ax.set_xlabel('h')
    ax.set_ylabel('error')
    fig.savefig(filename + '/convergence.eps')

Exemplo n.º 17
0
# mesh
if mpirank == 0: print 'meshing'
mesh = dl.UnitSquareMesh(Nxy, Nxy)
Vm = dl.FunctionSpace(mesh, 'Lagrange', 1)
V = dl.FunctionSpace(mesh, 'Lagrange', 2)

# target medium:
b_target = dl.Expression(\
'1.0 + 1.0*(x[0]<=0.7)*(x[0]>=0.3)*(x[1]<=0.7)*(x[1]>=0.3)')
b_target_fn = dl.interpolate(b_target, Vm)
a_target = dl.Expression('1.0')
a_target_fn = dl.interpolate(a_target, Vm)

# set up plots:
filename, ext = splitext(sys.argv[0])
myplot = PlotFenics(outputdirectory + filename + str(freq))
MPI.barrier(mpicomm)
if PLOT:
    myplot.set_varname('b_target')
    myplot.plot_vtk(b_target_fn)
else:
    myplot = None

# observations:
obspts = [[0.0, ii/10.] for ii in range(1,10)] + \
[[1.0, ii/10.] for ii in range(1,10)] + \
[[ii/10., 0.0] for ii in range(1,10)]
#obspts = [[0.9, 0.1]]

# define pde operator:
if mpirank == 0: print 'define wave pde'