def test_hex_contact_3D_order2_onFace(self):
file="hex_contact_3D_order2_onFace.msh"
ms1=Brick(1,1,1,2,l2=0.5,useElementsOnFace=True)
ms2=Brick(1,1,1,2,l2=0.5,useElementsOnFace=True)
ms2.setX(ms2.getX()+[0,0,0.5])
my_dom=JoinFaces([ms1,ms2],optimize=False)
self.checker(my_dom,file)
def test_mesh_dump_to_NetCDF_brick(self):
mydomain1 = Brick(n0=NE0,
n1=NE1,
n2=NE2,
order=1,
l0=1.,
l1=1.,
l2=1.,
optimize=False)
dumpfile = os.path.join(DUDLEY_WORKDIR, "tempfile.mesh.nc")
mydomain1.dump(dumpfile)
mydomain2 = LoadMesh(dumpfile)
self.domainsEqual(mydomain1, mydomain2)
def test_data_dump_to_NetCDF_brick(self):
mydomain1 = Brick(n0=NE0,
n1=NE1,
n2=NE2,
order=1,
l0=1.,
l1=1.,
l2=1.,
optimize=False)
d1 = Data(mydomain1.getMPIRank(), Function(mydomain1))
d1.expand()
dumpfile = os.path.join(DUDLEY_WORKDIR, "tempfile.dump.nc")
d1.dump(dumpfile)
d2 = load(dumpfile, mydomain1)
self.assertTrue(Lsup(abs(d1 - d2)) <= REL_TOL, "data objects differ")
def test_Brick_optimize_order1(self):
mydomain1 = Brick(n0=NE0,
n1=NE1,
n2=NE2,
order=1,
l0=1.,
l1=1.,
l2=1.,
optimize=False)
mydomain2 = Brick(n0=NE0,
n1=NE1,
n2=NE2,
order=1,
l0=1.,
l1=1.,
l2=1.,
optimize=True)
self.domainsEqual(mydomain1, mydomain2)
def setUp(self):
self.domain = Brick(4, 4, 4)
self.functionspaces = [
ContinuousFunction(self.domain),
Function(self.domain),
ReducedFunction(self.domain),
FunctionOnBoundary(self.domain),
ReducedFunctionOnBoundary(self.domain)
]
def fixme_test_mesh_read_brick_from_dudley_file(self):
mydomain1 = Brick(n0=8,
n1=10,
n2=12,
order=1,
l0=1.,
l1=1.,
l2=1.,
optimize=False)
mydomain2 = ReadMesh(
os.path.join(DUDLEY_TEST_MESH_PATH, "brick_8x10x12.fly"))
self.domainsEqual(mydomain1, mydomain2)
def setUp(self):
self.domain = Brick(4, 4, 4)
self.functionspaces = [
ContinuousFunction(self.domain),
Function(self.domain),
ReducedFunction(self.domain),
FunctionOnBoundary(self.domain),
ReducedFunctionOnBoundary(self.domain)
]
#We aren't testing DiracDeltaFunctions
self.xn = 5 # number of grids on x axis
self.yn = 5 # number of grids on y axis
self.zn = 5
n=dataMgr.getValue('n')
dt=dataMgr.getValue('dt')
stress=dataMgr.getValue('stress')
v=dataMgr.getValue('v')
p=dataMgr.getValue('p')
T=dataMgr.getValue('T')
if CREATE_TOPO:
topography=dataMgr.getValue('topography')
#diagnostics_file=FileWriter(DIAGNOSTICS_FN,append=True)
print(("<%s> Restart at time step %d (t=%e) completed."%(time.asctime(),n,t)))
else:
if DIM==2:
dom=Rectangle(int(ceil(L*NE/H)),NE,l0=L/H,l1=1,order=-1,optimize=True)
else:
dom=Brick(int(ceil(L*NE/H)),int(ceil(L*NE/H)),NE,l0=L/H,l1=L/H,l2=1,order=-1,optimize=True)
x=dom.getX()
T=Scalar(1,Solution(dom))
for d in range(DIM):
if d == DIM-1:
T*=sin(x[d]/H*pi)
else:
T*=cos(x[d]/L*pi)
T=(1.-x[DIM-1])+PERT*T
v=Vector(0,Solution(dom))
stress=Tensor(0,Function(dom))
x2=ReducedSolution(dom).getX()
p=Ra*(x2[DIM-1]-0.5*x2[DIM-1]**2-0.5)
if CREATE_TOPO:
def setUp(self):
self.order = 1
self.domain = Brick(n0=NE, n1=NE, n2=NE)
def getMesh(NE_X, NE_Y, t, d, o, fullOrder, r, l_X):
if t == "Hex":
if d == 2:
dom = Rectangle(n0=NE_X,
n1=NE_Y,
l0=l_X,
order=o,
useFullElementOrder=fullOrder,
useElementsOnFace=r,
optimize=True)
else:
Brick()
dom = Brick(n0=NE_X,
n1=NE_Y,
n2=NE_Y,
l0=l_X,
order=o,
useFullElementOrder=fullOrder,
useElementsOnFace=r,
optimize=True)
else:
des = Design(dim=d,
order=o,
element_size=min(l_X / max(3, NE_X), 1. / max(3, NE_Y)),
keep_files=True)
des.setScriptFileName("tester.geo")
if d == 2:
p0 = Point(0., 0.)
p1 = Point(l_X, 0.)
p2 = Point(l_X, 1.)
p3 = Point(0., 1.)
l01 = Line(p0, p1)
l12 = Line(p1, p2)
l23 = Line(p2, p3)
l30 = Line(p3, p0)
s = PlaneSurface(CurveLoop(l01, l12, l23, l30))
des.addItems(s, l01, l12, l23, l30)
else:
p000 = Point(0., 0., 0.)
p100 = Point(l_X, 0., 0.)
p010 = Point(0., 1., 0.)
p110 = Point(l_X, 1., 0.)
p001 = Point(0., 0., 1.)
p101 = Point(l_X, 0., 1.)
p011 = Point(0., 1., 1.)
p111 = Point(l_X, 1., 1.)
l10 = Line(p000, p100)
l20 = Line(p100, p110)
l30 = Line(p110, p010)
l40 = Line(p010, p000)
l11 = Line(p000, p001)
l21 = Line(p100, p101)
l31 = Line(p110, p111)
l41 = Line(p010, p011)
l12 = Line(p001, p101)
l22 = Line(p101, p111)
l32 = Line(p111, p011)
l42 = Line(p011, p001)
bottom = PlaneSurface(-CurveLoop(l10, l20, l30, l40))
top = PlaneSurface(CurveLoop(l12, l22, l32, l42))
front = PlaneSurface(CurveLoop(l10, l21, -l12, -l11))
back = PlaneSurface(CurveLoop(l30, l41, -l32, -l31))
left = PlaneSurface(CurveLoop(l11, -l42, -l41, l40))
right = PlaneSurface(CurveLoop(-l21, l20, l31, -l22))
vol = Volume(SurfaceLoop(bottom, top, front, back, left, right))
des.addItems(vol)
dom = MakeDomain(des)
return dom
ts.append(t)
u_pc0.append(u_pc[0]), u_pc1.append(u_pc[1]), u_pc2.append(u_pc[2])
# ... save current acceleration in units of gravity and displacements
if n == 1 or n % 10 == 0:
saveVTK("./data/usoln.%i.vtu" % (n / 10),
acceleration=length(a) / 9.81,
displacement=length(u),
tensor=stress,
Ux=u[0])
return ts, u_pc0, u_pc1, u_pc2
#
# create domain:
#
mydomain = Brick(ne, ne, 10, l0=width, l1=width, l2=10. * width / ne)
#
# sety time step size:
#
h = inf(1. / 5.) * inf(sqrt(rho / (lam + 2 * mu)) * mydomain.getSize())
print("time step size = %s" % h)
#
# spherical source at middle of bottom face
#
xc = [width / 2., width / 2., 0.]
# define small radius around point xc
src_radius = 0.03 * width
print("src_radius = %s" % src_radius)
#
# run it
#
def XXX(dim, tend, dt, s, h, b, c, d, c_dir="x", d_dir="x", a=1., CN=True):
"""
dim - sparial dimension
s - width of initial profile
h - mesh size
"""
v_c = c / a * getDirection(dim, c_dir)
v_d = d / a * getDirection(dim, d_dir)
v = (v_c + v_d)
E = b / a
if VERBOSITY:
print("=" * 100)
print(
"XX Start test dim = %d , h=%e, b=%e, c=%e, d=%e, c_dir=%s, d_dir=%s, a=%e, s=%e"
% (dim, h, b, c, d, c_dir, d_dir, a, s))
print("=" * 100)
print("initial width s = ", s)
print("diffusion = ", E)
print("total velocity = ", v)
print("tend = ", tend)
print("tolerance = ", TOL)
print("number of elements over s =", s / h)
b0 = sqrt(-log(TAU) * 4 * (s**2 + E * tend))
b1 = sqrt(-log(TAU)) * 2 * s
X0_0 = max(b1, -v[0] * tend + b0)
X0_1 = max(b1, -v[1] * tend + b0)
l_0 = X0_0 + max(v[0] * tend + b0, b1)
l_1 = X0_1 + max(v[1] * tend + b0, b1)
NE_0 = max(int(l_0 / h + 0.5), 1)
NE_1 = max(int(l_1 / h + 0.5), 1)
if dim == 2:
if VERBOSITY:
print("%d x %d grid over %e x %e with element size %e." %
(NE_0, NE_1, l_0, l_1, h))
if NE_0 * NE_1 > NE_MAX:
raise ValueError("too many elements %s." % (NE_0 * NE_1, ))
dom = Rectangle(n0=NE_0, n1=NE_1, l0=l_0, l1=l_1)
x0 = [X0_0, X0_1]
else:
X0_2 = max(b1, -v[2] * tend + b0)
l_2 = X0_2 + max(v[2] * tend + b0, b1)
NE_2 = max(int(l_2 / h + 0.5), 1)
if VERBOSITY:
print(
"%d x %d x %d grid over %e x %e x %e with element size %e." %
(NE_0, NE_1, NE_2, l_0, l_1, l_2, h))
if NE_0 * NE_1 * NE_2 > NE_MAX:
raise ValueError("too many elements %s." % (NE_0 * NE_1 * NE_2, ))
dom = Brick(n0=NE_0, n1=NE_1, ne2=NE_2, l0=l_0, l1=l_1, l2=l_2)
x0 = [X0_0, X0_1, X0_2]
if VERBOSITY:
print("initial location = ", x0)
print("XX", interpolate(uRef(dom, 0., E, s, v, x0),
FunctionOnBoundary(dom)))
fc_BE = TransportPDE(dom, numEquations=1, useBackwardEuler=True)
fc_BE.setValue(M=a, A=-b * kronecker(dom), B=-v_d * a, C=-v_c * a)
fc_BE.getSolverOptions().setVerbosity(VERBOSITY)
fc_BE.getSolverOptions().setTolerance(TOL)
#
fc_BE.getSolverOptions().setPreconditioner(
fc_BE.getSolverOptions().GAUSS_SEIDEL)
fc_BE.getSolverOptions().setNumSweeps(5)
if VERBOSITY: print("Backward Euler Transport created")
fc_CN = TransportPDE(dom, numEquations=1, useBackwardEuler=False)
fc_CN.setValue(M=a, A=-b * kronecker(dom), B=-v_d * a, C=-v_c * a)
fc_CN.getSolverOptions().setVerbosity(VERBOSITY)
fc_CN.getSolverOptions().setTolerance(TOL)
#fc_CN.getSolverOptions().setPreconditioner(fc_CN.getSolverOptions().GAUSS_SEIDEL)
fc_CN.getSolverOptions().setNumSweeps(2)
if VERBOSITY: print("Crank Nicolson Transport created")
dt_CN = fc_CN.getSafeTimeStepSize()
if VERBOSITY: print("time step size by Crank Nicolson=", dt_CN)
U0 = uRef(dom, 0, E, s, v, x0)
U0_e = uRef(dom, 0, E, s, v, x0, True)
fc_CN.setInitialSolution(U0)
fc_BE.setInitialSolution(U0)
initial_error_L2 = sqrt(integrate((U0 - U0_e)**2))
if VERBOSITY:
print("initial Lsup = ", Lsup(U0), Lsup(U0_e))
print("initial integral = ", integrate(U0_e))
print("initial error = ", initial_error_L2)
print("used time step size =", dt)
if not CN:
n = int(ceil(tend / dt))
if VERBOSITY:
print("Solve Backward Euler:")
print("substeps : ", n)
t0 = clock()
for i in range(n):
u = fc_BE.getSolution(dt)
t0 = clock() - t0
else:
if VERBOSITY: print("Solve Crank Nicolson:")
dt = dt_CN
t0 = clock()
u = fc_CN.getSolution(tend)
t0 = clock() - t0
out = QUALITY(u, uRef(dom, tend, E, s, v, x0, True))
print("XX",
interpolate(uRef(dom, tend, E, s, v, x0), FunctionOnBoundary(dom)))
out['time'] = t0
out['tend'] = tend
out['dt'] = dt
out['dx'] = h
if abs(b) > 0:
out["peclet"] = length(v) * s / b
else:
out["peclet"] = 9999999.
# saveVTK("bb.vtu",u0=U0,u_CN=u_CN, uRef=uRef(dom,dt2,E,s,v,X0) )
return out
NE = 128
NE = 4
DIM = 2
THETA = 0.5
OMEGA0 = 1.
ALPHA = pi / 4
T0 = 0
T_END = 2. * pi
dt = 1e-3 * 10 * 10
E = 1.e-3
TEST_SUPG = False or True
if DIM == 2:
dom = Rectangle(NE, NE)
else:
dom = Brick(NE, NE, NE)
u0 = dom.getX()[0]
# saveVTK("u.%s.vtu"%0,u=u0)
# print "XX"*80
dom.setX(2 * dom.getX() - 1)
# set initial value
x = dom.getX()
r = sqrt(x[0]**2 + (x[1] - 1. / 3.)**2)
# u0=whereNegative(r-1./3.)*wherePositive(wherePositive(abs(x[0])-0.05)+wherePositive(x[1]-0.5))
x = Function(dom).getX()
if DIM == 2:
V = OMEGA0 * (x[0] * [0, -1] + x[1] * [1, 0])
else:
V = OMEGA0 * (x[0] * [0, cos(ALPHA), 0] + x[1] *
def getDomain():
"""
this defines a dom as a brick of length and width l and hight h
"""
global netotal
v_p = {}
for tag in sorted(rho_tab.keys()):
v_p[tag] = sqrt((2 * mu_tab[tag] + lmbd_tab[tag]) / rho_tab[tag])
v_p_ref = min(v_p.values())
print(
"velocities: bedrock = %s, sand = %s, water =%s, absorber =%s, reference =%s"
% (v_p[bedrock], v_p[sand], v_p[water], v_p[absorber], v_p_ref))
sections = {}
sections["x"] = [
d_absorber, x_sand, l_sand, l_x_water, l_sand,
l - x_sand - 2 * l_sand - l_x_water, d_absorber
]
sections["y"] = [
d_absorber, y_sand, l_sand, l_y_water, l_sand,
l - y_sand - 2 * l_sand - l_y_water, d_absorber
]
sections["z"] = [d_absorber, h - h_water - h_sand, h_sand, h_water]
if output:
print("sections x = ", sections["x"])
print("sections y = ", sections["y"])
print("sections z = ", sections["z"])
mats = [[
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber]
],
[[
absorber, absorber, absorber, absorber, absorber, absorber,
absorber
],
[absorber, bedrock, bedrock, bedrock, bedrock, bedrock, absorber],
[absorber, bedrock, bedrock, bedrock, bedrock, bedrock, absorber],
[absorber, bedrock, bedrock, bedrock, bedrock, bedrock, absorber],
[absorber, bedrock, bedrock, bedrock, bedrock, bedrock, absorber],
[absorber, bedrock, bedrock, bedrock, bedrock, bedrock, absorber],
[
absorber, absorber, absorber, absorber, absorber, absorber,
absorber
]],
[[
absorber, absorber, absorber, absorber, absorber, absorber,
absorber
],
[absorber, bedrock, bedrock, bedrock, bedrock, bedrock, absorber],
[absorber, bedrock, sand, sand, sand, bedrock, absorber],
[absorber, bedrock, sand, sand, sand, bedrock, absorber],
[absorber, bedrock, sand, sand, sand, bedrock, absorber],
[absorber, bedrock, bedrock, bedrock, bedrock, bedrock, absorber],
[
absorber, absorber, absorber, absorber, absorber, absorber,
absorber
]],
[[
absorber, absorber, absorber, absorber, absorber, absorber,
absorber
],
[absorber, bedrock, bedrock, bedrock, bedrock, bedrock, absorber],
[absorber, bedrock, sand, sand, sand, bedrock, absorber],
[absorber, bedrock, sand, water, sand, bedrock, absorber],
[absorber, bedrock, sand, sand, sand, bedrock, absorber],
[absorber, bedrock, bedrock, bedrock, bedrock, bedrock, absorber],
[
absorber, absorber, absorber, absorber, absorber, absorber,
absorber
]]]
num_elem = {}
for d in sections:
num_elem[d] = []
for i in range(len(sections[d])):
if d == "x":
v_p_min = v_p[mats[0][0][i]]
for q in range(len(sections["y"])):
for r in range(len(sections["z"])):
v_p_min = min(v_p[mats[r][q][i]], v_p_min)
elif d == "y":
v_p_min = v_p[mats[0][i][0]]
for q in range(len(sections["x"])):
for r in range(len(sections["z"])):
v_p_min = min(v_p[mats[r][i][q]], v_p_min)
elif d == "z":
v_p_min = v_p[mats[i][0][0]]
for q in range(len(sections["x"])):
for r in range(len(sections["y"])):
v_p_min = min(v_p[mats[i][r][q]], v_p_min)
num_elem[d].append(
max(1,
int(sections[d][i] * v_p_ref / v_p_min / resolution +
0.5)))
ne_x = sum(num_elem["x"])
ne_y = sum(num_elem["y"])
ne_z = sum(num_elem["z"])
netotal = ne_x * ne_y * ne_z
if output:
print("grid : %s x %s x %s (%s elements)" %
(ne_x, ne_y, ne_z, netotal))
dom = Brick(ne_x,
ne_y,
ne_z,
l0=o * ne_x,
l1=o * ne_y,
l2=o * ne_z,
order=o)
x_old = dom.getX()
x_new = 0
for d in sections:
if d == "x":
i = 0
f = [1, 0, 0]
if d == "y":
i = 1
f = [0, 1, 0]
if d == "z":
i = 2
f = [0, 0, 1]
x = x_old[i]
p = origin[d]
ne = 0
s = 0.
for i in range(len(sections[d]) - 1):
msk = whereNonPositive(x - o * ne + 0.5)
s = s * msk + (sections[d][i] / (o * num_elem[d][i]) *
(x - o * ne) + p) * (1. - msk)
ne += num_elem[d][i]
p += sections[d][i]
x_new = x_new + s * f
dom.setX(x_new)
fs = Function(dom)
x = Function(dom).getX()
x0 = x[0]
x1 = x[1]
x2 = x[2]
p_z = origin["z"]
for i in range(len(mats)):
f_z = wherePositive(x2 - p_z) * wherePositive(x2 - p_z +
sections["z"][i])
p_y = origin["y"]
for j in range(len(mats[i])):
f_y = wherePositive(x1 - p_y) * wherePositive(x1 - p_z +
sections["y"][j])
p_x = origin["x"]
for k in range(len(mats[i][j])):
f_x = wherePositive(x0 - p_x) * wherePositive(x0 - p_x +
sections["x"][k])
fs.setTags(mats[i][j][k], f_x * f_y * f_z)
p_x += sections["x"][k]
p_y += sections["y"][j]
p_z += sections["z"][i]
return dom
def setUp(self):
self.domain = Brick(NE0, NE1, NE2, optimize=OPTIMIZE)
self.package = SolverOptions.PASO
self.method = SolverOptions.PCG
self.preconditioner = SolverOptions.JACOBI
def setUp(self):
self.domain = Brick(NE0, NE1, NE2, optimize=OPTIMIZE)
self.package = SolverOptions.MKL
self.method = SolverOptions.DIRECT
def getDomain():
"""
this defines a dom as a brick of length and width l and hight h
"""
global netotal
v_p={}
for tag in sorted(rho_tab.keys()):
v_p[tag]=sqrt((2*mu_tab[tag]+lmbd_tab[tag])/rho_tab[tag])
v_p_ref=min(v_p.values())
print("velocities: bedrock = %s, sand = %s, water =%s, absorber =%s, reference =%s"%(v_p[bedrock],v_p[sand],v_p[water],v_p[absorber],v_p_ref))
sections={}
sections["x"]=[d_absorber, x_sand, l_sand, l_x_water, l_sand, l-x_sand-2*l_sand-l_x_water, d_absorber]
sections["y"]=[d_absorber, y_sand, l_sand, l_y_water, l_sand, l-y_sand-2*l_sand-l_y_water, d_absorber]
sections["z"]=[d_absorber,h-h_water-h_sand,h_sand,h_water]
if output:
print("sections x = ",sections["x"])
print("sections y = ",sections["y"])
print("sections z = ",sections["z"])
mats= [
[ [absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber] ],
[ [absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, bedrock , bedrock , bedrock , bedrock , bedrock , absorber],
[absorber, bedrock , bedrock , bedrock , bedrock , bedrock , absorber],
[absorber, bedrock , bedrock , bedrock , bedrock , bedrock , absorber],
[absorber, bedrock , bedrock , bedrock , bedrock , bedrock , absorber],
[absorber, bedrock , bedrock , bedrock , bedrock , bedrock , absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber] ],
[ [absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, bedrock , bedrock , bedrock , bedrock , bedrock , absorber],
[absorber, bedrock , sand , sand , sand , bedrock , absorber],
[absorber, bedrock , sand , sand , sand , bedrock , absorber],
[absorber, bedrock , sand , sand , sand , bedrock , absorber],
[absorber, bedrock , bedrock , bedrock , bedrock , bedrock , absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber] ],
[ [absorber, absorber, absorber, absorber, absorber, absorber, absorber],
[absorber, bedrock , bedrock , bedrock , bedrock , bedrock , absorber],
[absorber, bedrock , sand , sand , sand , bedrock , absorber],
[absorber, bedrock , sand , water , sand , bedrock , absorber],
[absorber, bedrock , sand , sand , sand , bedrock , absorber],
[absorber, bedrock , bedrock , bedrock , bedrock , bedrock , absorber],
[absorber, absorber, absorber, absorber, absorber, absorber, absorber] ] ]
num_elem={}
for d in sections:
num_elem[d]=[]
for i in range(len(sections[d])):
if d=="x":
v_p_min=v_p[mats[0][0][i]]
for q in range(len(sections["y"])):
for r in range(len(sections["z"])):
v_p_min=min(v_p[mats[r][q][i]],v_p_min)
elif d=="y":
v_p_min=v_p[mats[0][i][0]]
for q in range(len(sections["x"])):
for r in range(len(sections["z"])):
v_p_min=min(v_p[mats[r][i][q]],v_p_min)
elif d=="z":
v_p_min=v_p[mats[i][0][0]]
for q in range(len(sections["x"])):
for r in range(len(sections["y"])):
v_p_min=min(v_p[mats[i][r][q]],v_p_min)
num_elem[d].append(max(1,int(sections[d][i] * v_p_ref/v_p_min /resolution+0.5)))
ne_x=sum(num_elem["x"])
ne_y=sum(num_elem["y"])
ne_z=sum(num_elem["z"])
netotal=ne_x*ne_y*ne_z
if output: print("grid : %s x %s x %s (%s elements)"%(ne_x,ne_y,ne_z,netotal))
dom=Brick(ne_x,ne_y,ne_z,l0=o*ne_x,l1=o*ne_y,l2=o*ne_z,order=o)
x_old=dom.getX()
x_new=0
for d in sections:
if d=="x":
i=0
f=[1,0,0]
if d=="y":
i=1
f=[0,1,0]
if d=="z":
i=2
f=[0,0,1]
x=x_old[i]
p=origin[d]
ne=0
s=0.
for i in range(len(sections[d])-1):
msk=whereNonPositive(x-o*ne+0.5)
s=s*msk + (sections[d][i]/(o*num_elem[d][i])*(x-o*ne)+p)*(1.-msk)
ne+=num_elem[d][i]
p+=sections[d][i]
x_new=x_new + s * f
dom.setX(x_new)
fs=Function(dom)
x=Function(dom).getX()
x0=x[0]
x1=x[1]
x2=x[2]
p_z=origin["z"]
for i in range(len(mats)):
f_z=wherePositive(x2-p_z)*wherePositive(x2-p_z+sections["z"][i])
p_y=origin["y"]
for j in range(len(mats[i])):
f_y=wherePositive(x1-p_y)*wherePositive(x1-p_z+sections["y"][j])
p_x=origin["x"]
for k in range(len(mats[i][j])):
f_x=wherePositive(x0-p_x)*wherePositive(x0-p_x+sections["x"][k])
fs.setTags(mats[i][j][k],f_x*f_y*f_z)
p_x+=sections["x"][k]
p_y+=sections["y"][j]
p_z+=sections["z"][i]
return dom
def setUp(self):
self.domain = Brick(l0=1.,l1=1.,l2=1.,n0=10, n1=10, n2=10)
def setUp(self):
self.domain = Brick(NE, NE, NE)
self.order = 1
def setUp(self):
self.domain = Brick(NE0, NE1, NE2, 1, optimize=OPTIMIZE)
self.package = SolverOptions.TRILINOS
self.method = SolverOptions.PCG
self.preconditioner = SolverOptions.ILUT
def setUp(self):
self.domain = Brick(NE0, NE1, NE2, optimize=OPTIMIZE)
self.package = SolverOptions.TRILINOS
self.method = SolverOptions.TFQMR
self.preconditioner = SolverOptions.GAUSS_SEIDEL
def setUp(self):
self.domain = Brick(NE0, NE1, NE2, optimize=OPTIMIZE)
self.package = SolverOptions.PASO
self.method = SolverOptions.BICGSTAB
self.preconditioner = SolverOptions.GAUSS_SEIDEL
def setUp(self):
self.domain = Brick(NE0, NE1, NE2, optimize=OPTIMIZE)
self.package = SolverOptions.TRILINOS
self.method = SolverOptions.BICGSTAB
self.preconditioner = SolverOptions.JACOBI
