def BoxMesh(lower, upper, xspacing, yspacing=None, zspaceing=None, **unused): from dune.grid import structuredGrid if (zspaceing is None): if (yspacing is None): return structuredGrid(lower, upper, [xspacing]) else: return structuredGrid(lower, upper, [xspacing, yspacing]) else: return structuredGrid(lower, upper, [xspacing, yspacing, zspaceing])
def run(restore=False): if not restore: grid = structuredGrid([0, 0], [1, 1], [2, 2]) grid.hierarchicalGrid.globalRefine(2) checkPointer = CheckPointer("dumpA", grid.hierarchicalGrid) else: checkPointer = CheckPointer("dumpA") grid = checkPointer.hierarchicalGrid().leafView space = lagrange(grid) df = space.interpolate([0], name="test") checkPointer.add(df) spc = lagrange(grid, storage='istl') df_istl = spc.interpolate([0], name="test_istl") # test discrete function assignment df.assign(df_istl) df_istl.assign(df) if not restore: print("interpolating grid function") @gridFunction(grid, name="gf", order=2) def gf(x): return x[0] * x[1] * (1 - x[0]) * (1 - x[1]) df.interpolate(gf) else: print("restoring discrete function") checkPointer.restore() # df.plot() if not restore: checkPointer.backup()
def backup(): from dune.grid import structuredGrid grid = structuredGrid([0,0],[1,1],[2,2]) grid.hierarchicalGrid.globalRefine(2) a = numpy.array([1,2,3]) pickle.dump([a,"hallo",grid.hierarchicalGrid,10], open("dumpA",'wb')) return grid
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]
from __future__ import print_function, division from ufl import as_vector, dot, grad, cos, pi, SpatialCoordinate, triangle from dune.grid import structuredGrid, gridFunction from dune.fem.space import lagrange, combined, product x = SpatialCoordinate(triangle) exact = as_vector([cos(2. * pi * x[0]) * cos(2. * pi * x[1]), dot(x, x)]) grid = structuredGrid([0, 0], [1, 1], [16, 16]) spc1 = lagrange(grid, dimRange=1, order=1) spc2 = lagrange(grid, dimRange=1, order=2) test1 = spc1.interpolate(exact[0], name="test") test2 = spc2.interpolate(exact[1], name="test") spc = combined(spc1, spc2) solution = spc.interpolate(exact, name="solution") space = product(spc1, spc2, components=["p", "s"]) df = space.interpolate(exact, name="df") # print(df.dofVector.size,solution.dofVector.size, # df.components[0].dofVector.size,df.p.dofVector.size,test1.dofVector.size) assert df.components[0].dofVector.size == test1.dofVector.size assert df.s.dofVector.size == test2.dofVector.size assert df.dofVector.size == solution.dofVector.size df.interpolate(solution) solution.interpolate(df) test1.interpolate(df.p) df.s.interpolate(test2) df.components[0].interpolate(solution[0]) df.p.interpolate(solution[0])
try: import matplotlib.pyplot as plt plt.ion() except ImportError: print("Warning: Plots are not generated as matplotlib could not be found.") plotting = False ######################## # Create grid geometry # ######################## dimension = 2 cells = 20 gridView = structuredGrid([0] * dimension, [1] * dimension, [cells] * dimension) gridGeometry = GridGeometry(gridView, discMethod="cctpfa") elementMapper = gridView.indexSet ############################################## # Define problem (inital/boundary condtions) # ############################################## @FVProblem(gridGeometry) class Problem: numEq = 1 def name(self):
#!/usr/bin/env python3 from dune.grid import structuredGrid from dumux.discretization import GridGeometry gridView = structuredGrid([0, 0], [1, 1], [5, 5]) gridGeometry = GridGeometry(gridView, discMethod="cctpfa") gridGeometry.update() print("The total number of scvs is {}".format(gridGeometry.numScv())) print("The total number of scvfs is {}".format(gridGeometry.numScvf())) for e in gridView.elements: fvGeometry = gridGeometry.localView() fvGeometry.bind(e) for scv in fvGeometry.scvs(): print("scv dofIndex: {}".format(scv.dofIndex())) print("scv center: {}".format(scv.center())) print("scv volume: {}".format(scv.volume()))
includes = problem._includes + ["test/python/test_boundaryloop.hh"] typeName = "Dumux::Python::PrintProblemTest<{}>".format(problem._typeName) moduleName = moduleName = "printbs_" + hashIt(problem._typeName) generator = SimpleGenerator("PrintProblemTest", "Dumux::Python") module = generator.load(includes, typeName, moduleName) return module.PrintProblemTest(problem) ############################################################ # The actual Python test ############################################################ from dune.grid import structuredGrid from dumux.discretization import GridGeometry from dumux.common import BoundaryTypes, FVProblem gridView = structuredGrid([0, 0, 0], [1, 1, 1], [3, 3, 3]) gridGeometry = GridGeometry(gridView, discMethod="box") @FVProblem(gridGeometry) class Problem: numEq = 2 def name(self): return "python_problem" def boundaryTypes(self, element, scv): bTypes = BoundaryTypes(self.numEq) bTypes.setDirichlet() return bTypes
import sys import time from dune.grid import structuredGrid, cartesianDomain from dune.fem.view import adaptiveLeafGridView as gridView dim = sys.argv[1] if dim == "2": # 2d structured grid grid = structuredGrid([0, 0], [1, 1], [4, 4]) try: from dune.alugrid import aluConformGrid, aluSimplexGrid, aluCubeGrid domain = cartesianDomain([0, 0], [1, 1], [4, 4]) # 2d alu conform grid grid = gridView(aluConformGrid(domain)) # 2d alu simplex grid grid = gridView(aluSimplexGrid(domain)) # 2d alu cube grid grid = gridView(aluCubeGrid(domain)) except ImportError: print("Cannot import module dune-alugrid, skipping grid creation!") elif dim == "3": # 3d structured grid grid = structuredGrid([0, 0, 0], [1, 1, 1], [4, 4, 4]) try: from dune.alugrid import aluConformGrid, aluSimplexGrid, aluCubeGrid domain = cartesianDomain([0, 0, 0], [1, 1, 1], [4, 4, 4])
import math # constructed a Cartesian grid from dune.grid import structuredGrid grid = structuredGrid([-1,-1],[1,1],[10,10]) print("number of elements of Cartesian grid:",grid.size(0)) grid.plot() # define a grid function and visualize from dune.grid import gridFunction @gridFunction(grid) def f(x): return math.cos(2.*math.pi/(1+abs(x[0]*x[1]))) f.plot() grid.writeVTK("example", pointdata={"gf":f}) # integrate the grid function using a quadrature rule from dune.geometry from dune.geometry import quadratureRules rules = quadratureRules(5) l2norm2 = 0 for e in grid.elements: geo = e.geometry for qp in rules(e.type): x,w = qp.position, qp.weight l2norm2 += f(e,x)**2*w*geo.integrationElement(x) print("integral of grid function=",math.sqrt(l2norm2))
use_codegen = True import time from dune.grid import structuredGrid from dune.fem import parameter from dune.fem.operator import linear as linearOperator import dune.create as create 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], [40, 40]) order = 4 dimR = 5 quadOrder = 2 * order + 3 spaceName = "lagrange" if use_codegen: space = create.space(spaceName, grid, dimRange=dimR, order=order, interiorQuadratureOrders=[quadOrder, 2*order],\ skeletonQuadratureOrders=[quadOrder] ) 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([