def test_domain_with_circle(self):
fname = 'circle.npz'
dom2d = copy.deepcopy(self.dom2d)
dom2d['elements'] = [pylbm.Circle([0.5, 1.], .5, label=10)]
dom = pylbm.Domain(dom2d)
check_from_file(dom, fname)
def test_domain_with_fluid_circle(self):
fname = 'fluid_circle.npz'
dom2d = copy.deepcopy(self.dom2d)
dom2d['elements'] = [
pylbm.Parallelogram([0., 0.], [1., 0], [0., 2.], label=20),
pylbm.Circle([0.5, 1.], .5, label=10, isfluid=True)
]
dom = pylbm.Domain(dom2d)
check_from_file(dom, fname)
# Authors:
# Loic Gouarin <*****@*****.**>
# Benjamin Graille <*****@*****.**>
#
# License: BSD 3 clause
"""
Example of a 2D geometry: the square [0,1]x[0,1] with a circular hole
"""
import pylbm
d = {
'box': {
'x': [0, 1],
'y': [0, 1],
'label': 0
},
'elements': [pylbm.Circle((.5, .5), .125, label=1)],
}
g = pylbm.Geometry(d)
g.visualize(viewlabel=True)
{
'box': {'x': [0, 1], 'label': 0},
'space_step': 0.1,
'schemes': [{'velocities': list(range(3))}],
},
{
'box': {'x': [0, 2], 'y': [0, 1], 'label': 0},
'elements': [
pylbm.Ellipse((0.5, 0.5), (0.25, 0.25), (0.1, -0.1), label=1)
],
'space_step': 0.05,
'schemes':[{'velocities': list(range(13))}],
},
{
'box': {'x': [0, 2], 'y': [0, 1], 'label': 0},
'elements':[pylbm.Circle((0.5, 0.5), 0.2, label=1)],
'space_step': 0.05,
'schemes':[{'velocities': list(range(13))}],
},
{
'box': {'x': [0, 1], 'y': [0, 1], 'label': [0, 1, 2, 3]},
'space_step': 0.1,
'schemes':[{'velocities': list(range(9))}],
},
{
'box': {'x': [0, 3], 'y': [0, 1], 'label': [0, 1, 0, 2]},
'elements': [
pylbm.Parallelogram((0., 0.), (.5, 0.), (0., .5), label=0)
],
'space_step': 0.125,
'schemes':[{'velocities': list(range(9))}],
# Authors:
# Loic Gouarin <*****@*****.**>
# Benjamin Graille <*****@*****.**>
#
# License: BSD 3 clause
"""
Example of a 2D geometry: the square [0,1]x[0,1] with a circular hole
"""
import pylbm
# pylint: disable=invalid-name
dgeom = {
'box': {
'x': [0, 1],
'y': [0, 1],
'label': 0
},
'elements': [pylbm.Circle((0.5, 0.5), 0.125, label=1)],
}
geom = pylbm.Geometry(dgeom)
print(geom)
geom.visualize(viewlabel=True, alpha=0.5)
# Authors:
# Loic Gouarin <*****@*****.**>
# Benjamin Graille <*****@*****.**>
#
# License: BSD 3 clause
"""
Example of a square in 2D with a circular hole with a D2Q13
"""
from six.moves import range
import pylbm
dico = {
'box': {
'x': [0, 2],
'y': [0, 1],
'label': 0
},
'elements': [pylbm.Circle((0.5, 0.5), 0.2)],
'space_step': 0.05,
'schemes': [{
'velocities': list(range(13))
}],
}
dom = pylbm.Domain(dico)
dom.visualize()
dom.visualize(view_distance=True)
def run(dx, Tf, generator="cython", sorder=None, withPlot=True):
"""
Parameters
----------
dx: double
spatial step
Tf: double
final time
generator: pylbm generator
sorder: list
storage order
withPlot: boolean
if True plot the solution otherwise just compute the solution
"""
# parameters
xmin, xmax, ymin, ymax = 0., 2., 0., 1.
radius = 0.125
la = 1. # velocity of the scheme
rhoo = 1.
uo = 0.05
mu = 2.5e-5 #0.00185
zeta = 10 * mu
dummy = 3.0 / (la * rhoo * dx)
s1 = 1.0 / (0.5 + zeta * dummy)
s2 = 1.0 / (0.5 + mu * dummy)
s = [0., 0., 0., s1, s1, s1, s1, s2, s2]
dummy = 1. / (LA**2 * rhoo)
qx2 = dummy * qx**2
qy2 = dummy * qy**2
q2 = qx2 + qy2
qxy = dummy * qx * qy
dico = {
'box': {
'x': [xmin, xmax],
'y': [ymin, ymax],
'label': [0, 1, 0, 0]
},
'elements':
[pylbm.Circle([.3, 0.5 * (ymin + ymax) + 2 * dx], radius, label=2)],
'space_step':
dx,
'scheme_velocity':
la,
'schemes': [
{
'velocities':
list(range(9)),
'polynomials': [
1, LA * X, LA * Y, 3 * (X**2 + Y**2) - 4,
0.5 * (9 * (X**2 + Y**2)**2 - 21 * (X**2 + Y**2) + 8),
3 * X * (X**2 + Y**2) - 5 * X,
3 * Y * (X**2 + Y**2) - 5 * Y, X**2 - Y**2, X * Y
],
'relaxation_parameters':
s,
'equilibrium': [
rho, qx, qy, -2 * rho + 3 * q2, rho - 3 * q2, -qx / LA,
-qy / LA, qx2 - qy2, qxy
],
'conserved_moments': [rho, qx, qy],
'init': {
rho: rhoo,
qx: rhoo * uo,
qy: 0.
},
},
],
'parameters': {
LA: la
},
'boundary_conditions': {
0: {
'method': {
0: pylbm.bc.BouzidiBounceBack
},
'value': (bc_rect, (rhoo, uo))
},
1: {
'method': {
0: pylbm.bc.NeumannX
}
},
2: {
'method': {
0: pylbm.bc.BouzidiBounceBack
}
},
},
'generator':
generator,
'show_code':
True
}
sol = pylbm.Simulation(dico, sorder=sorder)
if withPlot:
Re = rhoo * uo * 2 * radius / mu
print("Reynolds number {0:10.3e}".format(Re))
# init viewer
viewer = pylbm.viewer.matplotlib_viewer
fig = viewer.Fig()
ax = fig[0]
ax.ellipse([.3 / dx, 0.5 * (ymin + ymax) / dx + 2],
[radius / dx, radius / dx], 'r')
image = ax.image(vorticity(sol), cmap='jet', clim=[0, .05])
def update(iframe):
nrep = 100
for i in range(nrep):
sol.one_time_step()
image.set_data(vorticity(sol))
ax.title = "Solution t={0:f}".format(sol.t)
# run the simulation
fig.animate(update, interval=1)
fig.show()
else:
while sol.t < Tf:
sol.one_time_step()
return sol
s_q = s_eta
s_es = s_mu
s = [0., 0., 0., s_mu, s_es, s_q, s_q, s_eta, s_eta]
dummy = 1. / (LA**2 * rhoo)
qx2 = dummy * qx**2
qy2 = dummy * qy**2
q2 = qx2 + qy2
qxy = dummy * qx * qy
dico = {
'box': {
'x': [xmin, xmax],
'y': [ymin, ymax],
'label': [0, 2, 0, 0]
},
'elements': [pylbm.Circle([.3, 0.5 * (ymin + ymax) + dx], rayon, label=1)],
'space_step':
dx,
'scheme_velocity':
la,
'parameters': {
LA: la
},
'schemes': [
{
'velocities':
list(range(9)),
'conserved_moments': [rho, qx, qy],
'polynomials': [
1, LA * X, LA * Y, 3 * (X**2 + Y**2) - 4,
(9 * (X**2 + Y**2)**2 - 21 * (X**2 + Y**2) + 8) / 2,
# Authors:
# Loic Gouarin <*****@*****.**>
# Benjamin Graille <*****@*****.**>
#
# License: BSD 3 clause
"""
pylbm: tests for the geometry
"""
import pytest
import pylbm
ELEMENTS = [
[2, pylbm.Circle([0, 0], 1)],
[2, pylbm.Ellipse([0, 0], [1, 0], [0, 1])],
[2, pylbm.Triangle([-1, -1], [0, 2], [2, 0])],
[2, pylbm.Parallelogram([-1, -1], [0, 2], [2, 0])],
[3, pylbm.CylinderCircle([0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1])],
[3, pylbm.CylinderEllipse([0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1])],
[3, pylbm.CylinderTriangle([0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1])],
[3, pylbm.Parallelepiped([-1, -1, -1], [2, 0, 0], [0, 2, 0], [0, 0, 2])],
[3, pylbm.Ellipsoid([0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1])],
[3, pylbm.Sphere([0, 0, 0], 1)],
]
@pytest.fixture(params=ELEMENTS,
ids=[elem[1].__class__.__name__ for elem in ELEMENTS])
def get_element(request):
"""get one element of the geometry"""
return request.param
# Authors:
# Loic Gouarin <*****@*****.**>
# Benjamin Graille <*****@*****.**>
#
# License: BSD 3 clause
"""
Example of a complex geometry in 2D
"""
import pylbm
square = pylbm.Parallelogram((.1, .1), (.8, 0), (0, .8), isfluid=False)
strip = pylbm.Parallelogram((0, .4), (1, 0), (0, .2), isfluid=True)
circle = pylbm.Circle((.5, .5), .25, isfluid=True)
inner_square = pylbm.Parallelogram((.4, .5), (.1, .1), (.1, -.1), isfluid=False)
d = {'box':{'x': [0, 1], 'y': [0, 1], 'label':0},
'elements':[square, strip, circle, inner_square],
}
g = pylbm.Geometry(d)
g.visualize()
# rounded inner angles
g.add_elem(pylbm.Parallelogram((0.1, 0.9), (0.05, 0), (0, -0.05), isfluid=True))
g.add_elem(pylbm.Circle((0.15, 0.85), 0.05, isfluid=False))
g.add_elem(pylbm.Parallelogram((0.1, 0.1), (0.05, 0), (0, 0.05), isfluid=True))
g.add_elem(pylbm.Circle((0.15, 0.15), 0.05, isfluid=False))
g.add_elem(pylbm.Parallelogram((0.9, 0.9), (-0.05, 0), (0, -0.05), isfluid=True))
g.add_elem(pylbm.Circle((0.85, 0.85), 0.05, isfluid=False))
g.add_elem(pylbm.Parallelogram((0.9, 0.1), (-0.05, 0), (0, 0.05), isfluid=True))
g.add_elem(pylbm.Circle((0.85, 0.15), 0.05, isfluid=False))
g.visualize()
def main():
# parameters
xmin, xmax, ymin, ymax = 0., 2., 0., 1.
radius = 0.125
if h5_save:
dx = 1. / 512 # spatial step
else:
dx = 1. / 128
la = 1. # velocity of the scheme
rhoo = 1.
uo = 0.05
mu = 5.e-5
zeta = 10 * mu
dummy = 3.0 / (la * rhoo * dx)
s1 = 1.0 / (0.5 + zeta * dummy)
s2 = 1.0 / (0.5 + mu * dummy)
s = [0., 0., 0., s1, s1, s1, s1, s2, s2]
dummy = 1. / (LA**2 * rhoo)
qx2 = dummy * qx**2
qy2 = dummy * qy**2
q2 = qx2 + qy2
qxy = dummy * qx * qy
dico = {
'box': {
'x': [xmin, xmax],
'y': [ymin, ymax],
'label': [0, 1, 0, 0]
},
'elements':
[pylbm.Circle([.3, 0.5 * (ymin + ymax) + 2 * dx], radius, label=2)],
'space_step':
dx,
'scheme_velocity':
LA,
'schemes': [
{
'velocities':
list(range(9)),
'polynomials': [
1, LA * X, LA * Y, 3 * (X**2 + Y**2) - 4,
0.5 * (9 * (X**2 + Y**2)**2 - 21 * (X**2 + Y**2) + 8),
3 * X * (X**2 + Y**2) - 5 * X,
3 * Y * (X**2 + Y**2) - 5 * Y, X**2 - Y**2, X * Y
],
'relaxation_parameters':
s,
'equilibrium': [
rho, qx, qy, -2 * rho + 3 * q2, rho - 3 * q2, -qx / LA,
-qy / LA, qx2 - qy2, qxy
],
'conserved_moments': [rho, qx, qy],
},
],
'init': {
rho: rhoo,
qx: rhoo * uo,
qy: 0.
},
'parameters': {
LA: la
},
'boundary_conditions': {
0: {
'method': {
0: pylbm.bc.BouzidiBounceBack
},
'value': (bc_rect, (rhoo, uo))
},
1: {
'method': {
0: pylbm.bc.NeumannX
}
},
2: {
'method': {
0: pylbm.bc.BouzidiBounceBack
}
},
},
'generator':
"cython",
}
sol = pylbm.Simulation(dico)
Re = rhoo * uo * 2 * radius / mu
print("Reynolds number {0:10.3e}".format(Re))
x, y = sol.domain.x, sol.domain.y
if h5_save:
Tf = 500.
im = 0
l = Tf / sol.dt / 64
printProgress(im,
l,
prefix='Progress:',
suffix='Complete',
barLength=50)
filename = 'Karman'
path = './data_' + filename
save(x, y, sol.m, im)
while sol.t < Tf:
for k in range(64):
sol.one_time_step()
im += 1
printProgress(im,
l,
prefix='Progress:',
suffix='Complete',
barLength=50)
save(sol.mpi_topo, x, y, sol.m, im)
else:
viewer = pylbm.viewer.matplotlib_viewer
fig = viewer.Fig(figsize=(8, 6))
ax = fig[0]
ax.ellipse([.3 / dx, 0.5 * (ymin + ymax) / dx + 2],
[radius / dx, radius / dx], 'r')
image = ax.image(vorticity(sol), cmap='cubehelix', clim=[0, .05])
def update(iframe):
nrep = 64
for i in range(nrep):
sol.one_time_step()
image.set_data(vorticity(sol))
ax.title = "Solution t={0:f}".format(sol.t)
# run the simulation
fig.animate(update, interval=1)
fig.show()
s2 = 1.0 / (0.5 + mu * dummy)
s = [0., 0., 0., s1, s1, s1, s1, s2, s2]
dummy = 1. / (LA**2 * rhoo)
qx2 = dummy * qx**2
qy2 = dummy * qy**2
q2 = qx2 + qy2
qxy = dummy * qx * qy
dico = {
'box': {
'x': [xmin, xmax],
'y': [ymin, ymax],
'label': [0, 1, 0, 0]
},
'elements':
[pylbm.Circle([.3, 0.5 * (ymin + ymax) + 2 * dx], radius, label=2)],
'space_step':
dx,
'scheme_velocity':
LA,
'schemes': [
{
'velocities':
list(range(9)),
'polynomials': [
1, LA * X, LA * Y, 3 * (X**2 + Y**2) - 4,
0.5 * (9 * (X**2 + Y**2)**2 - 21 * (X**2 + Y**2) + 8),
3 * X * (X**2 + Y**2) - 5 * X, 3 * Y * (X**2 + Y**2) - 5 * Y,
X**2 - Y**2, X * Y
],
'relaxation_parameters':
def format_input(input_data):
boundary = get_boundary(input_data)
if input_data["Library"] == 1:
if input_data["Problem"] == 1:
def bc_in(f, m, x, y):
m[qx] = input_data["Density"] * (input_data["Velocity"]/20)
dummy = 3.0/(input_data["Velocity"]*input_data["Density"]*(1./64))
s_mu = 1.0/(0.5+input_data["BulkViscosity"]*dummy)
eta = input_data["Density"]*(1./20)*2*0.05/input_data["ReynoldsNumber"]
s_q = 1.0/(0.5+eta*dummy)
s = [0., 0., 0., s_mu, s_mu, s_q, s_q, s_q, s_q]
dummy2 = 1./(LA**2*input_data["Density"])
qx2 = dummy2 * qx ** 2
qy2 = dummy2 * qy ** 2
q2 = qx2 + qy2
qxy = dummy2 * qx * qy
problem_parameters = {
'box': {'x': [boundary["x_min"], boundary["x_max"]],
'y': [boundary["y_min"], boundary["y_max"]],
'label': [0, 2, 0, 0]
},
'elements': [pylbm.Circle([.3, 0.5 * (boundary["y_min"] + boundary["y_max"]) + 1./64], 0.05, label=1)],
'space_step': 1./64,
'scheme_velocity': input_data["Velocity"],
'parameters': {LA: input_data["Velocity"]},
'schemes': [
{
'velocities': list(range(9)),
'conserved_moments': [rho, qx, qy],
'polynomials': [
1, LA * X, LA * Y,
3 * (X ** 2 + Y ** 2) - 4,
(9 * (X ** 2 + Y ** 2) ** 2 - 21 * (X ** 2 + Y ** 2) + 8) / 2,
3 * X * (X ** 2 + Y ** 2) - 5 * X, 3 * Y * (X ** 2 + Y ** 2) - 5 * Y,
X ** 2 - Y ** 2, X * Y
],
'relaxation_parameters': s,
'equilibrium': [
rho, qx, qy,
-2 * rho + 3 * q2,
rho - 3 * q2,
-qx / LA, -qy / LA,
qx2 - qy2, qxy
],
},
],
'init': {rho: input_data["Density"],
qx: 0.,
qy: 0.
},
'boundary_conditions': {
0: {'method': {0: pylbm.bc.BouzidiBounceBack}, 'value': bc_in},
1: {'method': {0: pylbm.bc.BouzidiBounceBack}},
2: {'method': {0: pylbm.bc.NeumannX}},
},
'generator': 'cython',
}
return problem_parameters
def run(space_step,
final_time,
generator="cython",
sorder=None,
with_plot=True):
"""
Parameters
----------
space_step: double
spatial step
final_time: double
final time
generator: string
pylbm generator
sorder: list
storage order
with_plot: boolean
if True plot the solution otherwise just compute the solution
Returns
-------
sol
<class 'pylbm.simulation.Simulation'>
"""
# parameters
scheme_name = 'Geier'
xmin, xmax, ymin, ymax = 0., 2., 0., 1. # bounds of the domain
radius = 1. / 32 # radius of the obstacle
la = 1. # velocity of the scheme
rho_o = 1. # reference value of the mass
u_o = 0.05 # boundary value of the velocity
mu = 5.e-6 # bulk viscosity
zeta = 10 * mu # shear viscosity
def moments_choice(scheme_name, mu, zeta):
if scheme_name == 'dHumiere':
dummy = 1. / rho_o
QX2 = dummy * QX**2
QY2 = dummy * QY**2
Q2 = QX2 + QY2
QXY = dummy * QX * QY
polynomials = [
1, X, Y, 3 * (X**2 + Y**2) - 4 * LA**2,
0.5 * (9 * (X**2 + Y**2)**2 - 21 *
(X**2 + Y**2) * LA**2 + 8 * LA**4),
3 * X * (X**2 + Y**2) - 5 * X * LA**2,
3 * Y * (X**2 + Y**2) - 5 * Y * LA**2, X**2 - Y**2, X * Y
]
equilibrium = [
RHO, QX, QY, -2 * RHO * LA**2 + 3 * Q2, RHO * LA**2 - 3 * Q2,
-QX * LA**2, -QY * LA**2, QX2 - QY2, QXY
]
dummy = 3.0 / (la * rho_o * space_step)
sigma_1 = dummy * zeta
sigma_2 = dummy * mu
s_1 = 1 / (.5 + sigma_1)
s_2 = 1 / (.5 + sigma_2)
if scheme_name == 'Geier':
UX, UY = QX / RHO, QY / RHO
RHOU2 = RHO * (UX**2 + UY**2)
polynomials = [
1,
X,
Y,
X**2 + Y**2,
X * Y**2,
Y * X**2,
X**2 * Y**2,
X**2 - Y**2,
X * Y,
]
equilibrium = [
RHO,
QX,
QY,
RHOU2 + 2 / 3 * RHO * LA**2,
QX * (LA**2 / 3 + UY**2),
QY * (LA**2 / 3 + UX**2),
RHO * (LA**2 / 3 + UX**2) * (LA**2 / 3 + UY**2),
RHO * (UX**2 - UY**2),
RHO * UX * UY,
]
dummy = 3.0 / (la * rho_o * space_step)
sigma_1 = dummy * (zeta - 2 * mu / 3)
sigma_2 = dummy * mu
s_1 = 1 / (.5 + sigma_1)
s_2 = 1 / (.5 + sigma_2)
if scheme_name == 'Lallemand':
dummy = 1. / rho_o
QX2 = dummy * QX**2
QY2 = dummy * QY**2
Q2 = QX2 + QY2
QXY = dummy * QX * QY
polynomials = [
1,
X,
Y,
X**2 + Y**2,
X * (X**2 + Y**2),
Y * (X**2 + Y**2),
(X**2 + Y**2)**2,
X**2 - Y**2,
X * Y,
]
equilibrium = [
RHO,
QX,
QY,
Q2 + 2 / 3 * LA**2 * RHO,
4 / 3 * QX * LA**2,
4 / 3 * QY * LA**2,
((21 * Q2 + 6 * RHO * LA**2) * LA**2 -
(6 * Q2 - 2 * RHO * LA**2)) / 9,
QX2 - QY2,
QXY,
]
dummy = 3.0 / (la * rho_o * space_step)
sigma_1 = dummy * zeta
sigma_2 = dummy * mu
s_1 = 1 / (.5 + sigma_1)
s_2 = 1 / (.5 + sigma_2)
s = [0., 0., 0., s_1, s_1, s_1, s_1, s_2, s_2]
return polynomials, equilibrium, s
polynomials, equilibrium, s = moments_choice(scheme_name, mu, zeta)
simu_cfg = {
'box': {
'x': [xmin, xmax],
'y': [ymin, ymax],
'label': [0, 1, 0, 0]
},
'elements': [
pylbm.Circle([.3, 0.5 * (ymin + ymax) + 2 * space_step],
radius,
label=2)
],
'space_step':
space_step,
'scheme_velocity':
la,
'schemes': [
{
'velocities': list(range(9)),
'polynomials': polynomials,
'relaxation_parameters': s,
'equilibrium': equilibrium,
'conserved_moments': [RHO, QX, QY],
},
],
'parameters': {
LA: la
},
'init': {
RHO: rho_o,
QX: rho_o * u_o,
QY: 0.
},
'boundary_conditions': {
0: {
'method': {
0: pylbm.bc.BouzidiBounceBack
},
'value': (bc_in, (rho_o, u_o))
},
1: {
'method': {
0: pylbm.bc.NeumannX
}
},
2: {
'method': {
0: pylbm.bc.BouzidiBounceBack
}
},
},
'generator':
generator,
'relative_velocity': [QX / RHO, QY / RHO],
# 'show_code': True
}
sol = pylbm.Simulation(simu_cfg, sorder=sorder)
if with_plot:
Re = rho_o * u_o * 2 * radius / mu
print("Reynolds number {0:10.3e}".format(Re))
# init viewer
viewer = pylbm.viewer.matplotlib_viewer
fig = viewer.Fig()
axe = fig[0]
axe.grid(visible=False)
axe.xaxis_set_visible(False)
axe.yaxis_set_visible(False)
axe.ellipse(
[.3 / space_step - 1.5, 0.5 * (ymin + ymax) / space_step + .5],
[radius / space_step, radius / space_step], 'black')
surf = axe.SurfaceImage(vorticity(sol), cmap='jet', clim=[0, .1])
def update(iframe): # pylint: disable=unused-argument
nrep = 32
for _ in range(nrep):
sol.one_time_step()
surf.update(vorticity(sol))
axe.title = "Solution t={0:f}".format(sol.t)
# run the simulation
fig.animate(update, interval=1)
fig.show()
else:
while sol.t < final_time:
sol.one_time_step()
return sol
#
# License: BSD 3 clause
"""
Example of a square in 2D with a cavity
"""
import pylbm
D_DOM = {
'box': {
'x': [0, 1],
'y': [0, 1],
'label': 0
},
'elements': [
pylbm.Parallelogram((0.4, 0.3), (0, 0.4), (0.2, 0), label=1),
pylbm.Circle((0.4, 0.5), 0.2, label=3),
pylbm.Circle((0.6, 0.5), 0.2, label=3),
pylbm.Parallelogram((0.45, 0.3), (0, 0.4), (0.1, 0),
label=2,
isfluid=True),
],
'space_step':
0.025,
'schemes': [{
'velocities': list(range(9))
}],
}
DOMAIN = pylbm.Domain(D_DOM)
print(DOMAIN)
DOMAIN.visualize(view_distance=True,
label=None,
# Benjamin Graille <*****@*****.**>
#
# License: BSD 3 clause
"""
Example of a square in 2D with a circular hole
"""
import pylbm
D_DOM = {
'box': {
'x': [0, 2],
'y': [0, 1],
'label': 0
},
'elements': [
pylbm.Circle((0.5, 0.5), 0.2, label=1),
],
'space_step': 0.05,
'schemes': [{
'velocities': list(range(13))
}],
}
DOMAIN = pylbm.Domain(D_DOM)
print(DOMAIN)
DOMAIN.visualize(scale=1.5)
DOMAIN.visualize(view_distance=True,
label=None,
view_in=True,
view_out=True,
view_bound=True)
DOMAIN.visualize(
obs_num = 0
while batch_counter < 500:
uo = np.random.rand(1) * .2 + .05
uo = uo[0]
radius = np.random.rand(1) * .4 + .05
radius = radius[0]
first = True
print("Obstacle number", obs_num)
# obs = obs_gen.get_random_triangle()
x_loc = np.random.rand(1) * 1.25 + radius + .05
y_loc = 0.5 * (np.random.rand(1)) + radius + .05
x_loc = x_loc[0]
y_loc = y_loc[0]
obs = pylbm.Circle([x_loc, y_loc], radius, label=2)
dico = {
'box': {
'x': [xmin, xmax],
'y': [ymin, ymax],
'label': [0, 1, 0, 0]
},
'elements': [obs],
'space_step':
dx,
'scheme_velocity':
LA,
'schemes': [
{
'velocities':
