def test(model, spaceName, dimD, dimR, storage):
# print("########################################")
# print("#### ",spaceName,storage,dimD,dimR,flush=True)
spaceD = create.space(spaceName,
grid,
dimRange=dimD,
order=1,
storage=storage)
spaceR = create.space(spaceName,
grid,
dimRange=dimR,
order=1,
storage=storage)
scheme = create.operator("galerkin", model, spaceD, spaceR)
uD = create.function("discrete", spaceD, name=storage)
uD.clear()
start = time.time()
for i in range(testLoop):
A = linearOperator(scheme) # , parameters={"petsc.blockedmode":False})
end = time.time()
# print( "setup+assembly:",(end-start)/testLoop, flush=True )
start = time.time()
for i in range(testLoop):
jacobian(scheme, uD, A)
end = time.time()
# print( "assembly only: ",(end-start)/testLoop, flush=True )
# sys.stdout.flush()
try:
import petsc4py
from petsc4py import PETSc
mat = A.as_petsc
# print(mat.getInfo(), flush=True)
except:
pass
def test(space):
if test_numpy:
numpySpace = create.space(space,
grid,
dimRange=1,
order=1,
storage='numpy')
numpyScheme = create.scheme("galerkin", model, numpySpace)
numpy_h = create.function("discrete", numpySpace, name="numpy")
numpy_dofs = numpy_h.as_numpy
# numpyScheme.solve(target = numpy_h)
start = time.time()
for i in range(testLoop):
linOp = linearOperator(numpyScheme)
numpyScheme.jacobian(numpy_h, linOp)
numpy_mat = linOp.as_numpy
end = time.time()
# print( "numpy:", (end-start)/testLoop, flush=True )
# sys.stdout.flush()
numpy_coo = numpy_mat.tocoo()
# for i,j,v in zip(numpy_coo.row,numpy_coo.col,numpy_coo.data):
# print(i,j,v)
# print("****************************",flush=True)
if test_istl:
istlSpace = create.space(space,
grid,
dimRange=1,
order=1,
storage='istl')
istlScheme = create.scheme("galerkin", model, istlSpace)
istl_h = create.function("discrete", istlSpace, name="istl")
istl_dofs = istl_h.as_istl
# istlScheme.solve(target = istl_h)
start = time.time()
for i in range(testLoop):
linOp = linearOperator(istlScheme)
istlScheme.jacobian(istl_h, linOp)
istl_mat = linOp.as_istl
end = time.time()
# print( "istl:", (end-start)/testLoop, flush=True )
# sys.stdout.flush()
# there is no way yet to go from istl to scipy - would be nice to have
# istl_coo = istl_mat.tocoo()
# for i,j,v in zip(eigen_coo.row,eigen_coo.col,eigen_coo.data):
# print(i,j,v)
# print("****************************",flush=True)
if test_petsc:
import petsc4py
from petsc4py import PETSc
petsc4py.init(sys.argv)
petscSpace = create.space(space,
grid,
dimRange=1,
order=1,
storage='petsc')
petscScheme = create.scheme("galerkin", model, petscSpace)
petsc_h = create.function("discrete", petscSpace, name="petsc")
petsc_dofs = petsc_h.as_petsc
# petscScheme.solve(target = petsc_h)
linOp = linearOperator(petscScheme)
petscScheme.jacobian(petsc_h, linOp)
petsc_mat = linOp.as_petsc
rptr, cind, vals = petsc_mat.getValuesCSR()
petsc_coo = scipy.sparse.csr_matrix((vals, cind, rptr)).tocoo()
start = time.time()
for i in range(testLoop):
linOp = linearOperator(petscScheme)
petscScheme.jacobian(petsc_h, linOp)
petsc_mat = linOp.as_petsc
end = time.time()
# print( "petsc:", (end-start)/testLoop, flush=True )
# sys.stdout.flush()
ksp = PETSc.KSP()
ksp.create(PETSc.COMM_WORLD)
ksp.setType("cg")
# ksp.getPC().setType("icc")
petsc_h.clear()
res = petsc_h.copy()
petscScheme(petsc_h, res)
petscScheme.jacobian(petsc_h, linOp)
petsc_mat = linOp.as_petsc
ksp.setOperators(petsc_mat, petsc_mat)
ksp.setFromOptions()
ksp.solve(res.as_petsc, petsc_h.as_petsc)
# print("****************************",flush=True)
# print(petsc_mat.size, petsc_mat.getSize(), petsc_mat.getSizes())
# print(petsc_mat.getType())
# print(type(petsc_mat))
# print(petscSpace.size)
# print(petsc_mat.assembled)
# rptr, cind, vals = petsc_mat.getValuesCSR()
# petsc_coo = scipy.sparse.csr_matrix((vals,cind,rptr),shape=(100,100)).tocoo()
# for i,j,v in zip(petsc_coo.row,petsc_coo.col,petsc_coo.data):
# print(i,j,v)
if test_istl:
try: # istl_coo does not exist
assert (istl_coo.row == numpy_coo.row).all()
assert (istl_coo.col == numpy_coo.col).all()
assert np.allclose(istl_coo.data, numpy_coo.data)
except:
# print("issue between istl and numpy matrices")
pass
if test_petsc:
try:
assert (petsc_coo.row == numpy_coo.row).all()
assert (petsc_coo.col == numpy_coo.col).all()
assert np.allclose(petsc_coo.data, numpy_coo.data)
except:
# print("issue between petsc and numpy matrices")
pass
q_n = 0
q_w = 0
useCutOff = False
P = AnisotropicLens()
# <markdowncell>
# Setup grid, discrete spaces and functions
# <codecell>
grid = create.view("adaptive", "ALUCube", P.domain, dimgrid=2)
if coupled:
spc = create.space("dglegendrehp", grid, dimRange=2, order=maxOrder)
else:
spc1 = create.space("dglegendrehp", grid, dimRange=1, order=maxOrder)
spc = create.space("product", spc1, spc1, components=["p", "s"])
solution = spc.interpolate([0, 0], name="solution")
solution_old = spc.interpolate([0, 0], name="solution_old")
sol_pm1 = spc.interpolate([0, 0], name="sol_pm1")
intermediate = spc.interpolate([0, 0], name="iterate")
persistentDF = [solution, solution_old, intermediate]
fvspc = create.space("finitevolume", grid, dimRange=1, storage="fem")
estimate = fvspc.interpolate([0], name="estimate")
estimate_pm1 = fvspc.interpolate([0], name="estimate-pm1")
# <markdowncell>
import numpy
from dune.fem.plotting import plotPointData as plot
import dune.create as create
from dune.grid import structuredGrid
from dune.istl import blockVector
import ufl
g = structuredGrid([0, 0], [1, 1], [2, 3])
s = create.space("lagrange", g, dimRange=2, storage="istl")
f1 = s.interpolate(expr=[2, 1], name="tmp")
dofs = blockVector(int(s.size / s.localBlockSize), s.localBlockSize)
# f2 = s.function("tmp", expr=[2,1], dofVector=dofs)
f2 = s.function("tmp", dofVector=dofs)
f2.interpolate([2, 1])
assert all([(d1 - d2).two_norm == 0 for d1, d2 in zip(dofs, f1.as_istl)])
assert all([(d1 - d2).two_norm == 0 for d1, d2 in zip(dofs, f2.as_istl)])
operator = create.operator(
"galerkin",
ufl.dot(ufl.TrialFunction(s), ufl.TestFunction(s)) * ufl.dx)
f1 = s.function("tmp", [2, 1],
blockVector(s.size // s.localBlockSize, s.localBlockSize))
f2 = s.function("tmp", [2, 1],
blockVector(s.size // s.localBlockSize, s.localBlockSize))
operator(f1, f2)
s = create.space("lagrange", g, dimRange=2, storage="numpy")
f1 = s.interpolate([2, 1], name="tmp")
dofs = numpy.ndarray(s.size)
f2 = s.function("tmp", [2, 1], dofs)
assert not (dofs - f1.as_numpy).any()
from __future__ import print_function, division
import math
import numpy
from dune.grid import structuredGrid
import dune.create as create
grid = structuredGrid([0, 0], [1, 1], [10, 10])
fvspc = create.space("finitevolume", grid, dimRange=2, storage="numpy")
estimate = fvspc.interpolate([1, 1], name="estimate")
lf = estimate.localFunction(grid.elements.__next__())
y = lf.evaluate([0, 0])
assert y == (1, 1)
# print(y)
lf = estimate.setLocalContribution()
lf.bind(grid.elements.__next__())
y1, y2 = lf[0], lf[1]
assert y1 == 0 and y2 == 0
# print(y1,y2)
lf[0] = 10
y1, y2 = lf[0], lf[1]
assert y1 == 10 and y2 == 0
# print(y1,y2)
lf.unbind()
lf = estimate.localContribution("set")
lf.bind(grid.elements.__next__())
y1, y2 = lf[0], lf[1]
"istl.preconditioning.method": "ilu",
"istl.preconditioning.iterations": 1,
"istl.preconditioning.relaxation": 1
})
# set up grid
grid = create.grid("ALUSimplex", gridSelect, dimgrid=2, dimworld=3)
grid.hierarchicalGrid.globalRefine(2)
print("Number of elements:", grid.size(0))
print("Number of vertices:", grid.size(grid.dimension))
# set up a lagrange scalar space with polynomial order 2 over that grid
spc = create.space("Lagrange",
grid,
dimrange=grid.dimWorld,
order=order,
store="istl")
# non spherical initial surgface
uDimWorld = 6
positions = spc.interpolate(lambda x: surfaceOptions[case](x), name="position")
surface = create.view("geometry", positions)
SolutionSpace = create.space("Lagrange",
surface,
dimrange=uDimWorld,
order=order,
storage="istl")
if Graphics == 1:
import numpy
from scipy.sparse import bmat, linalg
import dune.create as create
from dune.grid import cartesianDomain
from ufl import SpatialCoordinate, CellVolume, TrialFunction, TestFunction,\
inner, dot, div, grad, dx, as_vector, transpose, Identity
from dune.ufl import Constant, DirichletBC
import dune.fem
from dune.fem.operator import linear as linearOperator
order = 2
grid = create.grid("ALUCube",
constructor=cartesianDomain([0, 0], [3, 1], [30, 10]))
spcU = create.space("lagrange",
grid,
dimRange=grid.dimension,
order=order,
storage="fem")
spcP = create.space("lagrange",
grid,
dimRange=1,
order=order - 1,
storage="fem")
cell = spcU.cell()
x = SpatialCoordinate(cell)
mu = Constant(0, "mu")
nu = Constant(0, "nu")
u = TrialFunction(spcU)
v = TestFunction(spcU)
p = TrialFunction(spcP)
from dune.fem import spaceAdapt, adapt
from dune.grid import cartesianDomain, gridFunction
from dune.alugrid import aluConformGrid as leafGridView
from dune.fem.view import adaptiveLeafGridView as adaptiveGridView
from dune.fem import parameter, doerflerMark, globalRefine
from dune.fem.function import levelFunction
from dune.ufl import Space
import dune.create as create
parameter.append({"fem.verboserank": 0})
domain = cartesianDomain([0, 0], [1, 1], [16, 16])
grid = adaptiveGridView(leafGridView(domain))
space = create.space("lagrangehp", grid, maxOrder=4, storage="istl")
u = TrialFunction(space)
v = TestFunction(space)
x = SpatialCoordinate(space)
n = FacetNormal(space)
mu = 20 * 16
hT = MaxCellEdgeLength(space)
hS = avg(MaxFacetEdgeLength(space))
hs = MaxFacetEdgeLength(space)('+')
diffusiveFlux = lambda w, d: d
source = -sin(pi * x[0]) * sin(6 * pi * x[1])
a = (inner(diffusiveFlux(u, grad(u)), grad(v)) + source * v) * dx
a -= ( inner( outer(jump(u), n('+')), avg(diffusiveFlux(u,grad(v))) ) +\
from ufl import *
import math
import dune.fem
from dune.fem.function import integrate
import dune.create as create
from dune.ufl import DirichletBC, Space
dimRange = 12 # needs to be >= 4, test with 4,8,11
grid = create.grid("ALUConform", "../data/mixed.dgf", dimgrid=2)
from ufl import SpatialCoordinate
uflSpace = dune.ufl.Space(2, dimRange)
x = SpatialCoordinate(uflSpace.cell())
from math import pi, log, sqrt
from ufl import cos, sin, as_vector
exact = as_vector(
[sin(3 * pi * x[0]), x[1] * x[1], x[0] *
x[0], cos(3. * pi * x[1])] + [0] * (dimRange - 4))
v1 = integrate(grid, exact, 5).two_norm
space = create.space("Lagrange", grid, dimRange=dimRange, order=1)
u = space.interpolate(exact, name="u")
v2 = integrate(grid, u, 5).two_norm
print(v1, v2, v1 - v2)
v3 = integrate(grid, inner(grad(u[11]), grad(u[11])), 5)
from ufl import TestFunction, TrialFunction, SpatialCoordinate, triangle, exp,\
dx, grad, inner, as_vector, replace, sqrt
from dune.ufl import Constant
parameter.append({"fem.verboserank": -1})
grid = structuredGrid([0, 0], [1, 1], [4, 4])
order = 2
dimR = 1
quadOrder = 2 * order + 3
spaceName = "lagrange"
#spaceName = "dgonb"
if use_codegen:
space = create.space(spaceName, grid, dimRange=dimR, order=order,
interiorQuadratureOrders=[quadOrder, 2*order],\
skeletonQuadratureOrders=[quadOrder, 2*order, order, 2*order+1] )
else:
space = create.space(spaceName, grid, dimRange=dimR, order=order)
x = SpatialCoordinate(space)
initial = 1 / 2 * (x[0]**2 + x[1]**2) - 1 / 3 * (x[0]**3 - x[1]**3) + 1
u_h = space.interpolate(as_vector([
initial,
] * dimR), name='u_h')
u_h_n = u_h.copy(name="previous")
u = TrialFunction(space)
v = TestFunction(space)
# print(vec, len(vec), vec[0], vec[0][0])
#set first element in first field vector equal to one
vec[0][0] = 2
# print(vec, len(vec), vec[0], vec[0][0])
#change element to 1
vec[0][0] = 1
assert (vec[0][0] == 1), "dune.istl blockvector not changing value correctly "
#now test with with other fieldvector created in dune=fempy
view = create.grid("yasp",
dune.grid.cartesianDomain([0, 0], [1, 1], [1, 1]),
dimgrid=2)
spc = create.space("Lagrange", view, dimRange=2, order=3, storage='istl')
#initialise all to 2
uh = spc.interpolate([2, 3], name="solution")
df = uh.as_istl
# print(df, len(df), df[0], df[0][0])
df[0][0] = 1
# print(df, len(df), df[0], df[0][0])
# print(uh.dofVector[0][0])
#reset equalt to one againt
assert (df[0][0] == 1), "blockvector from dune-fempy not changing correctly"
err = [inner(edf, edf), inner(grad(edf), grad(edf))]
errors = [math.sqrt(e) for e in integrate(grid, err, order=8)]
return df, errors, info
# <markdowncell>
# Finally we iterate over the requested methods and solve the problems
# <codecell>
fig = pyplot.figure(figsize=(10 * len(methods), 10))
figPos = 100 + 10 * len(methods) + 1
for i, m in enumerate(methods):
space = create.space(m[1],
polyGrid,
order=order,
dimRange=1,
storage="istl",
**m[3])
dfs, errors, info = compute(polyGrid, space, m[2], m[4])
print("method:(",
m[0],
m[2],
")",
"Size: ",
space.size,
"L^2: ",
errors[0],
"H^1: ",
errors[1],
info["linear_iterations"],
flush=True)
parameter.append({"fem.verboserank": 0})
newtonParameter = {
"tolerance": 1e-7,
"verbose": "false",
"linear.absolutetol": 1e-8,
"linear.reductiontol": 1e-8,
"linear.preconditioning.method": "jacobi",
"linear.preconditioning.iterations": 1,
"linear.preconditioning.relaxation": 1.2,
"linear.verbose": "false"
}
grid = create.grid("ALUConform",
cartesianDomain([0, 0], [1, 1], [10, 10]),
dimgrid=2)
spc = create.space("lagrange", grid, dimRange=1, order=2, storage="istl")
uflSpace = Space((grid.dimGrid, grid.dimWorld), 1)
u = TrialFunction(uflSpace)
v = TestFunction(uflSpace)
x = SpatialCoordinate(uflSpace.cell())
n = FacetNormal(uflSpace.cell())
mu = 1.
# he = MaxFacetEdgeLength(uflSpace.cell())('+') # this is wrong
# hT = MaxCellEdgeLength(uflSpace.cell())
hT = CellVolume(uflSpace.cell())
hF = FacetArea(uflSpace.cell())
# he = FacetArea(uflSpace.cell()) / Min( avg('+'), avg('-') )
heInv = hF / avg(hT)
exact = as_vector([cos(pi * x[0]) * cos(pi * x[1])])
u = TrialFunction(uflSpace)
v = TestFunction(uflSpace)
x = SpatialCoordinate(uflSpace.cell())
from math import pi, log, sqrt
from ufl import cos, sin, as_vector, dx, ds, grad, inner
exact = as_vector(
[sin(3 * pi * x[0]) * x[1] * x[1], x[0] * x[0] * cos(3. * pi * x[1])])
laplace = lambda u: grad(grad(u))[0, 0] + grad(grad(u))[1, 1]
f = as_vector([-laplace(exact[0]) + exact[0], -laplace(exact[1]) + exact[1]])
left = conditional(x[0] < 1e-5, 1, 0)
equation = inner(grad(u), grad(v)) * dx + inner(u,v) * dx - inner(f,v) * dx \
+ 3*pi*x[1]**2*v[0] * left*ds == 0
# spc = create.space("dgonb", grid, dimRange=dimRange, order=1)
spc = create.space("lagrange", grid, dimRange=dimRange, order=1)
def test(operator):
model = [
equation,
DirichletBC(uflSpace, [None, x[0]**2], 2), # bottom
DirichletBC(uflSpace, [exact[0], None], 3), # top
DirichletBC(uflSpace, [None, None], 4), # left
DirichletBC(uflSpace, exact, 1)
] # right
parameters = {"newton." + k: v for k, v in newtonParameter.items()}
scheme = create.scheme(operator, model, spc, parameters=parameters)
solution = spc.interpolate([0, 0], name="solution")
scheme.solve(target=solution)
from dune.fem.function import integrate
import dune.create as create
from ufl import TestFunction, TrialFunction, SpatialCoordinate, triangle, exp,\
dx, grad, inner, as_vector, replace, sqrt, dot,\
derivative, action
from ufl.algorithms.apply_derivatives import apply_derivatives
from dune.fem.operator import linear as linearOperator
parameter.append({"fem.verboserank": -1})
grid = structuredGrid([0, 0], [1, 1], [40, 40])
order = 2
dimR = 2
spaceName = "lagrange"
space = create.space(spaceName, grid, dimRange=dimR, order=order)
arg = space.interpolate(as_vector([
1,
] * dimR), name='arg')
destA = space.interpolate([
0,
] * dimR, name='destA') # note: this uses an efficient approach in C++
destB = space.interpolate(
as_vector([
0.,
] * dimR), name='destB'
) # note: this needs to generate a ufl local function in the current implementation
destC = space.interpolate(as_vector([
0,
] * dimR), name='destC')
