import dolfin as df

mesh = df.Rectangle(0,0,10,10,300, 300)

uexp = df.Expression("sin(x[0]*x[1])+2.0")
F = df.FunctionSpace(mesh, "Lagrange", 1)
u = df.interpolate(uexp,F)
df.plot(u)
df.interactive()





















import sys
sys.exit(0)

def test_diff_power():
    """
    Compute the Laplacian of a scalar function of space called f.
    With f = x^3 + y^4, you get Laplace(f) = 6x + 12y^2.

    """
    f = df.interpolate(df.Expression("pow(x[0], 3) + pow(x[1], 4)"), F)
    laplace_f = df.project(df.div(df.grad(f)), F)
    laplace_f_ref = df.project(df.Expression("6*x[0] + 12*x[1]*x[1]"), F)
    #diff = df.project(laplace_f_ref - laplace_f, F)
    diff = laplace_f.vector().array() - laplace_f_ref.vector().array()
    #df.plot(laplace_f)
    #df.plot(laplace_f_ref)
    #df.plot(df.project(laplace_f-laplace_f_ref, F))
    #df.interactive()
    assert max(abs(diff)) < TOLERANCE

def test_diff_trig():
    """
    Compute the Laplacian of a scalar function of space f.
    With f = cos(x-0.5)*cos(y-0.5) you get Laplace(f) = -2*f.

    """
    f = df.interpolate(df.Expression("-1*cos(x[0]-0.5)*cos(x[1]-0.5)"), F)
    laplace_f = df.div(df.grad(f))
    laplace_f_ref = df.Expression("2*cos(x[0]-0.5)*cos(x[1]-0.5)")
    diff = df.project(laplace_f - laplace_f_ref, F)
    print "max diff=",max(abs(diff.vector().array()))
    df.plot(laplace_f)
    df.plot(df.project(laplace_f_ref,F))
    df.plot(diff)
    df.interactive()
    #assert not  < TOLERANCE


#==========

F = df.FunctionSpace(mesh, "Lagrange", 3)

fexpr = df.Expression("-1*cos(x[0]-0.5)*cos(x[1]-0.5)")
f = df.project(df.Expression("-1*cos(x[0]-0.5)*cos(x[1]-0.5)"), F)

laplace_f = df.div(df.grad(f))

u = df.TrialFunction(F)
v = df.TestFunction(F)

a = df.inner(u, v) * df.dx

L = df.inner( df.div(df.grad(f)),v) * df.dx
L = -df.inner(df.grad(f), df.grad(v)) * df.dx

sol = df.Function(F)
df.solve(a == L, sol)

#df.plot(sol)
#df.plot(laplace_f)
diff = df.project(laplace_f - sol, F)
print "max diff=",max(abs(diff.vector().array()))

print "diff is ",diff
#df.interactive()

#==========

#meshsmall=df.Rectangle(0.3,0.3,0.7,0.7,100,100)
eps=1e-5*0
meshsmall=df.Rectangle(0.0+eps,0.0+eps,1.0-eps,1.0-eps,200,200)
FDG = df.FunctionSpace(meshsmall, "DG", 0)
Fsmall1 = df.FunctionSpace(meshsmall, "Lagrange", 1)
Fsmall2 = df.FunctionSpace(meshsmall, "Lagrange", 2)

solsmall = df.interpolate(sol,Fsmall1)

refsmall = df.project(laplace_f,F3)
#refsmall = df.project(laplace_f,Fsmall)


#df.plot(sol)
#df.plot(solsmall)
#df.plot(refsmall)
df.plot(df.project(laplace_f, F1))
df.interactive()





#diff = df.project(u - laplace_f, F)
#df.plot(u)
#df.plot(df.project(laplace_f, F))
#df.plot(laplace_f)
#df.interactive()
#assert not max(abs((diff.vector().array()))) < TOLERANCE


#test_compare_explicit_way_with_solving_variational_problem()
#test_diff_trig()