def test_run(self):
""" Test if cfd can run
"""
path = os.path.join(os.path.dirname(__file__), "CFD_exampleFluid")
cuds = CUDS(name='example_kratos_cfd_simulatiob')
itime = api.IntegrationTime(name="cfd_integration_time")
itime.time = 0.0001
itime.step = 0.0025
itime.final = 0.0075
cuds.add([itime])
cfd_utils = CFD_Utils()
model_fluid = cfd_utils.read_modelpart(path)
for model in [model_fluid]:
cuds.add(list(model['datasets']))
cuds.add(list(model['conditions']))
cuds.add(list(model['materials']))
cuds.add([model['pe']])
# Create the simulation and run the problem
sim = Simulation(cuds, "KRATOS_CFD", engine_interface=True)
sim.run()
def test_get_dataset(self):
"""Test get_dataset method
"""
sim = Simulation(self.cuds, 'OpenFOAM', engine_interface=self.engine)
wrapper = sim._wrapper
mesh_inside_wrapper = wrapper.get_dataset(self.mesh.name)
self.assertEqual(self.mesh.name, mesh_inside_wrapper.name)
label = 0
for point in self.mesh.iter(item_type=CUBA.POINT):
puid = mesh_inside_wrapper._foamPointLabelToUuid[label]
point_f = mesh_inside_wrapper.get(puid)
self.assertEqual(point.coordinates, point_f.coordinates)
label += 1
label = 0
for cell in self.mesh.iter(item_type=CUBA.CELL):
cuid = mesh_inside_wrapper._foamCellLabelToUuid[label]
cell_f = mesh_inside_wrapper.get(cuid)
self.assertEqual(cell.data[CUBA.PRESSURE],
cell_f.data[CUBA.PRESSURE])
self.assertEqual(cell.data[CUBA.VELOCITY],
cell_f.data[CUBA.VELOCITY])
label += 1
def test_add_dataset(self):
"""Test add_dataset method
"""
sim = Simulation(self.cuds, 'OpenFOAM', engine_interface=self.engine)
wrapper = sim._wrapper
self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 1)
def test_remove_dataset(self):
"""Test remove_dataset method
"""
sim = Simulation(self.cuds, 'OpenFOAM', engine_interface=self.engine)
wrapper = sim._wrapper
wrapper.remove_dataset(self.mesh.name)
with self.assertRaises(ValueError):
wrapper.get_dataset(self.mesh.name)
def test_run(self):
get_engine_manager().register_extension(get_example_engine_extension())
cuds = CUDS()
engine_names = get_engine_manager().get_supported_engine_names()
# There should be at least one dummy extension there
self.assertGreater(len(engine_names), 0)
engine_a_name = engine_names[0]
engine_a = None
for engine_ext in get_engine_manager().get_supported_engines():
for engine in engine_ext.get_supported_engines():
if engine.name == engine_a_name:
engine_a = engine
self.assertIsNotNone(engine_a)
self.assertGreater(len(engine_a.interfaces), 0)
sim = Simulation(cuds, engine_a_name, engine_a.interfaces[0])
sim.run()
self.assertEqual(sim.get_cuds(), cuds)
def test_iter_datasets(self):
"""Test iter_datasets method
"""
sim = Simulation(self.cuds, 'OpenFOAM', engine_interface=self.engine)
wrapper = sim._wrapper
mesh2 = self.mesh
mesh2.name = "mesh2"
wrapper.add_dataset(mesh2)
self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 2)
def test_run(self):
get_engine_manager().register_extension(get_example_engine_extension())
cuds = CUDS()
engine_names = get_engine_manager().get_supported_engine_names()
# There should be at least one dummy extension there
self.assertGreater(len(engine_names), 0)
engine_a_name = engine_names[0]
engine_a = None
for engine_ext in get_engine_manager().get_supported_engines():
for engine in engine_ext.get_supported_engines():
if engine.name == engine_a_name:
engine_a = engine
self.assertIsNotNone(engine_a)
self.assertGreater(len(engine_a.interfaces), 0)
sim = Simulation(cuds,
engine_a_name,
engine_a.interfaces[0])
sim.run()
self.assertEqual(sim.get_cuds(), cuds)
def test_run(self):
""" Test if cfd can run
"""
pathParticles = os.path.join(
"/home/travis/build/simphony/simphony-kratos/simkratos/tests/dem",
"3balls"
)
pathSolid = os.path.join(
"/home/travis/build/simphony/simphony-kratos/simkratos/tests/dem",
"3ballsDEM_FEM_boundary"
)
cuds = CUDS(name='example_kratos_dem_somulation')
itime = api.IntegrationTime(name="dem_integration_time")
itime.time = 0.0001
itime.step = 0.001
itime.final = 60 * itime.step
cuds.add([itime])
utils = DEM_Utils()
print(pathParticles)
model_particles = utils.read_modelpart_as_particles(pathParticles)
model_solid = utils.read_modelpart_as_mesh(pathSolid)
for model in [model_particles, model_solid]:
cuds.add(list(model['datasets']))
cuds.add(list(model['conditions']))
cuds.add(list(model['materials']))
cuds.add([model['pe']])
sim = Simulation(cuds, "KRATOS_DEM", engine_interface=True)
sim.run()
def test_get_dataset_names(self):
"""Test get_dataset_names method
"""
sim = Simulation(self.cuds, 'OpenFOAM', engine_interface=self.engine)
wrapper = sim._wrapper
name1 = self.mesh.name
mesh2 = self.mesh
name2 = "mesh2"
mesh2.name = name2
wrapper.add_dataset(mesh2)
self.assertEqual(list(wrapper.get_dataset_names())[0], name1)
self.assertEqual(list(wrapper.get_dataset_names())[1], name2)
def test_multiple_meshes(self):
"""Test multiple meshes inside wrapper
"""
sim = Simulation(self.cuds, 'OpenFOAM', engine_interface=self.engine)
wrapper = sim._wrapper
mesh2 = self.mesh
mesh2.name = "mesh2"
wrapper.add_dataset(mesh2)
mesh_inside_wrapper1 = wrapper.get_dataset(self.mesh.name)
mesh_inside_wrapper2 = wrapper.get_dataset(mesh2.name)
self.assertEqual(
sum(1 for _ in mesh_inside_wrapper1.iter(item_type=CUBA.POINT)),
sum(1 for _ in mesh_inside_wrapper2.iter(item_type=CUBA.POINT)))
name='vel_walls')
vel_walls.data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_walls = api.Neumann(foam, name='pres_walls')
pres_walls.data[CUBA.VARIABLE] = CUBA.PRESSURE
inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet])
walls = api.Boundary(name='walls', condition=[vel_walls, pres_walls])
outlet = api.Boundary(name='outlet', condition=[vel_outlet, pres_outlet])
cuds.add([inlet, walls, outlet])
end = time.time()
print "Time spend in boundary settings: ", end - start
start = time.time()
sim = Simulation(cuds, 'OpenFOAM', engine_interface=EngineInterface.Internal)
end = time.time()
print "Time spend in Simulation initialization: ", end - start
start = time.time()
sim.run()
end = time.time()
print "Time spend in run: ", end - start
start = time.time()
mesh_in_engine = cuds.get_by_name(mesh_name)
print "Working directory ", mesh_in_engine.path
average_pressure = 0.0
for cell in mesh_in_engine.get_boundary_cells(inlet.name):
average_pressure += cell.data[CUBA.PRESSURE]
class WrapperRunTestCase(unittest.TestCase):
def setUp(self):
case_name = "simplemeshIO"
mesh_name = "simplemeshIO_mesh"
cuds = CUDS(name=case_name)
# physics model
cfd = api.Cfd(name='default model')
cuds.add([cfd])
self.sim_time = api.IntegrationTime(name='simulation_time',
current=0.0,
final=1.0,
size=0.5)
cuds.add([self.sim_time])
mat = api.Material(name='a_material')
mat._data[CUBA.DENSITY] = 1.0
mat._data[CUBA.DYNAMIC_VISCOSITY] = 1.0
cuds.add([mat])
vel_inlet = api.Dirichlet(mat, name='vel_inlet')
vel_inlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_inlet._data[CUBA.VELOCITY] = (0.1, 0, 0)
pres_inlet = api.Neumann(mat, name='pres_inlet')
pres_inlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_outlet = api.Neumann(mat, name='vel_outlet')
vel_outlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_outlet = api.Dirichlet(mat, name='pres_outlet')
pres_outlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
pres_outlet._data[CUBA.PRESSURE] = 0.0
vel_walls = api.Dirichlet(mat, name='vel_walls')
vel_walls._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_walls._data[CUBA.VELOCITY] = (0, 0, 0)
pres_walls = api.Neumann(mat, name='pres_walls')
pres_walls._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_frontAndBack = api.EmptyCondition(name='vel_frontAndBack')
vel_frontAndBack._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_frontAndBack = api.EmptyCondition(name='pres_frontAndBack')
pres_frontAndBack._data[CUBA.VARIABLE] = CUBA.PRESSURE
inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet])
walls = api.Boundary(name='walls', condition=[vel_walls, pres_walls])
outlet = api.Boundary(name='outlet',
condition=[vel_outlet, pres_outlet])
frontAndBack = api.Boundary(
name='frontAndBack',
condition=[vel_frontAndBack, pres_frontAndBack])
cuds.add([inlet, walls, outlet, frontAndBack])
corner_points = [(0.0, 0.0, 0.0), (5.0, 0.0, 0.0), (5.0, 5.0, 0.0),
(0.0, 5.0, 0.0), (0.0, 0.0, 1.0), (5.0, 0.0, 1.0),
(5.0, 5.0, 1.0), (0.0, 5.0, 1.0)]
self.mesh_path = tempfile.mkdtemp()
mesh = create_quad_mesh(self.mesh_path, mesh_name, corner_points, 5, 5,
5)
cuds.add([mesh])
self.cuds = cuds
self.sim = Simulation(cuds,
'OpenFOAM',
engine_interface=EngineInterface.FileIO)
self.mesh_in_cuds = self.cuds.get_by_name(mesh_name)
def tearDown(self):
if os.path.exists(self.mesh_in_cuds.path):
shutil.rmtree(self.mesh_in_cuds.path)
if os.path.exists(self.mesh_path):
shutil.rmtree(self.mesh_path)
def test_run_time(self):
"""Test that field variable value is changed after
consecutive calls of run method
"""
self.sim.run()
for cell in self.mesh_in_cuds.iter(item_type=CUBA.CELL):
old_vel = cell.data[CUBA.VELOCITY]
old_pres = cell.data[CUBA.PRESSURE]
cell_uid = cell.uid
self.sim.run()
cell = self.mesh_in_cuds.get(cell_uid)
new_vel = cell.data[CUBA.VELOCITY]
new_pres = cell.data[CUBA.PRESSURE]
self.assertNotEqual(old_vel, new_vel)
self.assertNotEqual(old_pres, new_pres)
def setUp(self):
case_name = "simplemesh_parallel"
mesh_name = "simplemesh_parallel_mesh"
cuds = CUDS(name=case_name)
# physics model
cfd = api.Cfd(name='default model')
cuds.add([cfd])
self.sp = api.SolverParameter(name='solver_parameters')
self.sp._data[CUBA.NUMBER_OF_CORES] = 4
cuds.add([self.sp])
sim_time = api.IntegrationTime(name='simulation_time',
current=0.0,
final=1.0,
size=1.0)
cuds.add([sim_time])
mat = api.Material(name='a_material')
mat._data[CUBA.DENSITY] = 1.0
mat._data[CUBA.DYNAMIC_VISCOSITY] = 1.0
cuds.add([mat])
vel_inlet = api.Dirichlet(mat, name='vel_inlet')
vel_inlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_inlet._data[CUBA.VELOCITY] = (0.1, 0, 0)
pres_inlet = api.Neumann(mat, name='pres_inlet')
pres_inlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_outlet = api.Neumann(mat, name='vel_outlet')
vel_outlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_outlet = api.Dirichlet(mat, name='pres_outlet')
pres_outlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
pres_outlet._data[CUBA.PRESSURE] = 0.0
vel_walls = api.Dirichlet(mat, name='vel_walls')
vel_walls._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_walls._data[CUBA.VELOCITY] = (0, 0, 0)
pres_walls = api.Neumann(mat, name='pres_walls')
pres_walls._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_frontAndBack = api.EmptyCondition(name='vel_frontAndBack')
vel_frontAndBack._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_frontAndBack = api.EmptyCondition(name='pres_frontAndBack')
pres_frontAndBack._data[CUBA.VARIABLE] = CUBA.PRESSURE
inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet])
walls = api.Boundary(name='walls', condition=[vel_walls, pres_walls])
outlet = api.Boundary(name='outlet', condition=[vel_outlet,
pres_outlet])
frontAndBack = api.Boundary(name='frontAndBack',
condition=[vel_frontAndBack,
pres_frontAndBack])
cuds.add([inlet, walls, outlet, frontAndBack])
corner_points = [(0.0, 0.0, 0.0), (5.0, 0.0, 0.0),
(5.0, 5.0, 0.0), (0.0, 5.0, 0.0),
(0.0, 0.0, 1.0), (5.0, 0.0, 1.0),
(5.0, 5.0, 1.0), (0.0, 5.0, 1.0)]
self.mesh_path = tempfile.mkdtemp()
mesh = create_quad_mesh(self.mesh_path, mesh_name,
corner_points, 5, 5, 5)
cuds.add([mesh])
self.cuds = cuds
self.sim = Simulation(cuds, 'OpenFOAM',
engine_interface=EngineInterface.FileIO)
self.mesh_in_cuds = self.cuds.get_by_name(mesh_name)
class WrapperRunTestCase(unittest.TestCase):
def setUp(self):
case_name = "simplemesh_parallel"
mesh_name = "simplemesh_parallel_mesh"
cuds = CUDS(name=case_name)
# physics model
cfd = api.Cfd(name='default model')
cuds.add([cfd])
self.sp = api.SolverParameter(name='solver_parameters')
self.sp._data[CUBA.NUMBER_OF_CORES] = 4
cuds.add([self.sp])
sim_time = api.IntegrationTime(name='simulation_time',
current=0.0,
final=1.0,
size=1.0)
cuds.add([sim_time])
mat = api.Material(name='a_material')
mat._data[CUBA.DENSITY] = 1.0
mat._data[CUBA.DYNAMIC_VISCOSITY] = 1.0
cuds.add([mat])
vel_inlet = api.Dirichlet(mat, name='vel_inlet')
vel_inlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_inlet._data[CUBA.VELOCITY] = (0.1, 0, 0)
pres_inlet = api.Neumann(mat, name='pres_inlet')
pres_inlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_outlet = api.Neumann(mat, name='vel_outlet')
vel_outlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_outlet = api.Dirichlet(mat, name='pres_outlet')
pres_outlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
pres_outlet._data[CUBA.PRESSURE] = 0.0
vel_walls = api.Dirichlet(mat, name='vel_walls')
vel_walls._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_walls._data[CUBA.VELOCITY] = (0, 0, 0)
pres_walls = api.Neumann(mat, name='pres_walls')
pres_walls._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_frontAndBack = api.EmptyCondition(name='vel_frontAndBack')
vel_frontAndBack._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_frontAndBack = api.EmptyCondition(name='pres_frontAndBack')
pres_frontAndBack._data[CUBA.VARIABLE] = CUBA.PRESSURE
inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet])
walls = api.Boundary(name='walls', condition=[vel_walls, pres_walls])
outlet = api.Boundary(name='outlet', condition=[vel_outlet,
pres_outlet])
frontAndBack = api.Boundary(name='frontAndBack',
condition=[vel_frontAndBack,
pres_frontAndBack])
cuds.add([inlet, walls, outlet, frontAndBack])
corner_points = [(0.0, 0.0, 0.0), (5.0, 0.0, 0.0),
(5.0, 5.0, 0.0), (0.0, 5.0, 0.0),
(0.0, 0.0, 1.0), (5.0, 0.0, 1.0),
(5.0, 5.0, 1.0), (0.0, 5.0, 1.0)]
self.mesh_path = tempfile.mkdtemp()
mesh = create_quad_mesh(self.mesh_path, mesh_name,
corner_points, 5, 5, 5)
cuds.add([mesh])
self.cuds = cuds
self.sim = Simulation(cuds, 'OpenFOAM',
engine_interface=EngineInterface.FileIO)
self.mesh_in_cuds = self.cuds.get_by_name(mesh_name)
def tearDown(self):
if os.path.exists(self.mesh_in_cuds.path):
shutil.rmtree(self.mesh_in_cuds.path)
if os.path.exists(self.mesh_path):
shutil.rmtree(self.mesh_path)
def test_parallel_run(self):
"""Test parallel running of OpenFoam
"""
self.sim.run()
self.assertEqual(self.sp._data[CUBA.NUMBER_OF_CORES],
len([d for d in
os.listdir(self.mesh_in_cuds.path)
if re.match(r'processor*', d)]))
class WrapperRunTestCase(unittest.TestCase):
def setUp(self):
case_name = "simplemeshIO"
mesh_name = "simplemeshIO_mesh"
cuds = CUDS(name=case_name)
# physics model
cfd = api.Cfd(name='default model')
cuds.add([cfd])
self.sim_time = api.IntegrationTime(name='simulation_time',
current=0.0,
final=1.0,
size=0.5)
cuds.add([self.sim_time])
mat = api.Material(name='a_material')
mat._data[CUBA.DENSITY] = 1.0
mat._data[CUBA.DYNAMIC_VISCOSITY] = 1.0
cuds.add([mat])
vel_inlet = api.Dirichlet(mat, name='vel_inlet')
vel_inlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_inlet._data[CUBA.VELOCITY] = (0.1, 0, 0)
pres_inlet = api.Neumann(mat, name='pres_inlet')
pres_inlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_outlet = api.Neumann(mat, name='vel_outlet')
vel_outlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_outlet = api.Dirichlet(mat, name='pres_outlet')
pres_outlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
pres_outlet._data[CUBA.PRESSURE] = 0.0
vel_walls = api.Dirichlet(mat, name='vel_walls')
vel_walls._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_walls._data[CUBA.VELOCITY] = (0, 0, 0)
pres_walls = api.Neumann(mat, name='pres_walls')
pres_walls._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_frontAndBack = api.EmptyCondition(name='vel_frontAndBack')
vel_frontAndBack._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_frontAndBack = api.EmptyCondition(name='pres_frontAndBack')
pres_frontAndBack._data[CUBA.VARIABLE] = CUBA.PRESSURE
inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet])
walls = api.Boundary(name='walls', condition=[vel_walls, pres_walls])
outlet = api.Boundary(name='outlet', condition=[vel_outlet,
pres_outlet])
frontAndBack = api.Boundary(name='frontAndBack',
condition=[vel_frontAndBack,
pres_frontAndBack])
cuds.add([inlet, walls, outlet, frontAndBack])
corner_points = [(0.0, 0.0, 0.0), (5.0, 0.0, 0.0),
(5.0, 5.0, 0.0), (0.0, 5.0, 0.0),
(0.0, 0.0, 1.0), (5.0, 0.0, 1.0),
(5.0, 5.0, 1.0), (0.0, 5.0, 1.0)]
self.mesh_path = tempfile.mkdtemp()
mesh = create_quad_mesh(self.mesh_path, mesh_name,
corner_points, 5, 5, 5)
cuds.add([mesh])
self.cuds = cuds
self.sim = Simulation(cuds, 'OpenFOAM',
engine_interface=EngineInterface.FileIO)
self.mesh_in_cuds = self.cuds.get_by_name(mesh_name)
def tearDown(self):
if os.path.exists(self.mesh_in_cuds.path):
shutil.rmtree(self.mesh_in_cuds.path)
if os.path.exists(self.mesh_path):
shutil.rmtree(self.mesh_path)
def test_run_time(self):
"""Test that field variable value is changed after
consecutive calls of run method
"""
self.sim.run()
for cell in self.mesh_in_cuds.iter(item_type=CUBA.CELL):
old_vel = cell.data[CUBA.VELOCITY]
old_pres = cell.data[CUBA.PRESSURE]
cell_uid = cell.uid
self.sim.run()
cell = self.mesh_in_cuds.get(cell_uid)
new_vel = cell.data[CUBA.VELOCITY]
new_pres = cell.data[CUBA.PRESSURE]
self.assertNotEqual(old_vel, new_vel)
self.assertNotEqual(old_pres, new_pres)
name='vel_walls')
vel_walls.data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_walls = api.Neumann(foam, name='pres_walls')
pres_walls.data[CUBA.VARIABLE] = CUBA.PRESSURE
inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet])
walls = api.Boundary(name='walls', condition=[vel_walls, pres_walls])
outlet = api.Boundary(name='outlet', condition=[vel_outlet, pres_outlet])
cuds.add([inlet, walls, outlet])
end = time.time()
print "Time spend in boundary settings: ", end-start
start = time.time()
sim = Simulation(cuds, 'OpenFOAM', engine_interface=EngineInterface.Internal)
end = time.time()
print "Time spend in Simulation initialization: ", end-start
start = time.time()
sim.run()
end = time.time()
print "Time spend in run: ", end-start
start = time.time()
mesh_in_engine = cuds.get_by_name(mesh_name)
print "Working directory ", mesh_in_engine.path
average_pressure = 0.0
for cell in mesh_in_engine.get_boundary_cells(inlet.name):
average_pressure += cell.data[CUBA.PRESSURE]
def setUp(self):
case_name = "simplemeshIO"
mesh_name = "simplemeshIO_mesh"
cuds = CUDS(name=case_name)
# physics model
cfd = api.Cfd(name='default model')
cuds.add([cfd])
self.sim_time = api.IntegrationTime(name='simulation_time',
current=0.0,
final=1.0,
size=0.5)
cuds.add([self.sim_time])
mat = api.Material(name='a_material')
mat._data[CUBA.DENSITY] = 1.0
mat._data[CUBA.DYNAMIC_VISCOSITY] = 1.0
cuds.add([mat])
vel_inlet = api.Dirichlet(mat, name='vel_inlet')
vel_inlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_inlet._data[CUBA.VELOCITY] = (0.1, 0, 0)
pres_inlet = api.Neumann(mat, name='pres_inlet')
pres_inlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_outlet = api.Neumann(mat, name='vel_outlet')
vel_outlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_outlet = api.Dirichlet(mat, name='pres_outlet')
pres_outlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
pres_outlet._data[CUBA.PRESSURE] = 0.0
vel_walls = api.Dirichlet(mat, name='vel_walls')
vel_walls._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_walls._data[CUBA.VELOCITY] = (0, 0, 0)
pres_walls = api.Neumann(mat, name='pres_walls')
pres_walls._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_frontAndBack = api.EmptyCondition(name='vel_frontAndBack')
vel_frontAndBack._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_frontAndBack = api.EmptyCondition(name='pres_frontAndBack')
pres_frontAndBack._data[CUBA.VARIABLE] = CUBA.PRESSURE
inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet])
walls = api.Boundary(name='walls', condition=[vel_walls, pres_walls])
outlet = api.Boundary(name='outlet',
condition=[vel_outlet, pres_outlet])
frontAndBack = api.Boundary(
name='frontAndBack',
condition=[vel_frontAndBack, pres_frontAndBack])
cuds.add([inlet, walls, outlet, frontAndBack])
corner_points = [(0.0, 0.0, 0.0), (5.0, 0.0, 0.0), (5.0, 5.0, 0.0),
(0.0, 5.0, 0.0), (0.0, 0.0, 1.0), (5.0, 0.0, 1.0),
(5.0, 5.0, 1.0), (0.0, 5.0, 1.0)]
self.mesh_path = tempfile.mkdtemp()
mesh = create_quad_mesh(self.mesh_path, mesh_name, corner_points, 5, 5,
5)
cuds.add([mesh])
self.cuds = cuds
self.sim = Simulation(cuds,
'OpenFOAM',
engine_interface=EngineInterface.FileIO)
self.mesh_in_cuds = self.cuds.get_by_name(mesh_name)
cuds.add([model['pe']])
# Add all datasets from the particles / fibers to the DEM wrapper
for model in [model_particles]:
cuds.add(list(model['datasets']))
cuds.add(list(model['conditions']))
cuds.add(list(model['materials']))
cuds.add([model['pe']])
# Get a reference to the datasets that we will use in the coupling
fluid_dataset_name = model_fluid['datasets'][0].name
particles_dataset_name = model_particles['datasets'][0].name
fibers_dataset_name = model_particles['datasets'][1].name
# Create the simulation and run the problem
simCFD = Simulation(cuds, "KRATOS_CFD", engine_interface=True)
simDEM = Simulation(cuds, "KRATOS_DEM", engine_interface=True)
simPRO = Simulation(cuds, "KRATOS_PRO", engine_interface=True)
simGID = Simulation(cuds, "KRATOS_GID", engine_interface=True)
for step in xrange(0, 10):
# Set interval times
CFDitime.final = 0.0125 * (step + 1) # 5 Kratos Timesteps
DEMitime.final = 0.0125 * (step + 1) # 5 Kratos Timesteps
# Make sure the timestep between wrappers are consistent
COUiTime.time = 0.0125 * (step + 0)
COUiTime.step = CFDitime.step
COUiTime.final = CFDitime.final
# Add the problem path to the script
path = os.path.join(os.path.dirname(__file__), "CFD_exampleFluid")
cuds = CUDS(name='example_fluid_name')
# Integration time:
itime = api.IntegrationTime(name="md_nve_integration_time")
itime.time = 0.0001
itime.step = 0.0025
itime.final = 0.0125 # 5 Kratos Timesteps
cuds.add([itime])
# Utils are used to read an existing Kratos model as raw data so we can
# initialize the correct simphony datasets. We can also use manualy written
# datasets.
cfd_utils = CFD_Utils()
# Reads kratos data so its interpretable by simphony
model_fluid = cfd_utils.read_modelpart(path)
# Add all datasets from the fluid to the CFD wrapper
for model in [model_fluid]:
cuds.add(list(model['datasets']))
cuds.add(list(model['conditions']))
cuds.add(list(model['materials']))
cuds.add([model['pe']])
# Create the simulation and run the problem
sim = Simulation(cuds, "KRATOS_CFD", engine_interface=True)
sim.run()