vel_outlet = api.Neumann(foam, name='vel_outlet')
vel_outlet.data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_outlet = api.Dirichlet(foam, name='pres_outlet')
pres_outlet.data[CUBA.VARIABLE] = CUBA.PRESSURE
pres_outlet.data[CUBA.PRESSURE] = 0.0

vel_walls = api.ShearStressPowerLawSlipVelocity(foam,
                                                density=250.0,
                                                linear_constant=3.1e-3,
                                                power_law_index=1.16,
                                                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()
示例#2
0
                                               name='vel_outlet')
pres_outlet = api.ConstantPressureCondition(0.0, mat, name='pres_outlet')
vel_outlet.data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_outlet.data[CUBA.VARIABLE] = CUBA.PRESSURE

vel_walls = api.ConstantVelocityCondition((0, 0, 0), mat, name='vel_walls')
pres_walls = api.ZeroGradientPressureCondition(0.0, mat, name='pres_walls')
vel_walls.data[CUBA.VARIABLE] = CUBA.VELOCITY
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])

sim = Simulation(cuds, 'OpenFOAM', engine_interface=EngineInterface.FileIO)

sim.run()

average_pressure = 0.0
mesh_in_engine = cuds.get_by_name(mesh_name)
print "working directory ", mesh_in_engine.path
示例#3
0
pres_walls = api.ZeroGradientPressureCondition(0.0, water, name='pres_walls')
vf_walls = api.ZeroGradientVolumeFractionCondition(0.0, water, name='vf_walls')

vel_top = api.FreeSlipVelocity(name='vel_top')
pres_top = api.ZeroGradientPressureCondition(0.0, water, name='pres_top')
vf_top = api.ZeroGradientVolumeFractionCondition(0.0, water, name='vf_top')

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.DYNAMIC_PRESSURE
vf_frontAndBack = api.EmptyCondition(name='vf_frontAndBack')
vf_frontAndBack.data[CUBA.VARIABLE] = CUBA.VOLUME_FRACTION

# boundaries
inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet, vf_inlet])
bottom_wall = api.Boundary(name='bottomWall', condition=[vel_walls,
                                                         pres_walls,
                                                         vf_walls])
end_wall = api.Boundary(name='endWall', condition=[vel_walls, pres_walls,
                                                   vf_walls])
top = api.Boundary(name='top', condition=[vel_top, pres_top, vf_top])
outlet = api.Boundary(name='outlet', condition=[vel_outlet, pres_outlet,
                                                vf_outlet])
frontAndBack = api.Boundary(name='frontAndBack', condition=[vel_frontAndBack,
                                                            pres_frontAndBack,
                                                            vf_frontAndBack])

cuds.add([inlet, bottom_wall, end_wall, top, outlet, frontAndBack])

mesh_in_cuds = cuds.get_by_name(mesh_name)
pres_atm = api.ConstantPressureCondition(0.0, water, name='pres_atm')
vf_atm = api.ZeroGradientVolumeFractionCondition(0.0, water, name='vf_atm')

vel_walls = api.ConstantVelocityCondition((0, 0, 0), water, name='vel_walls')
pres_walls = api.ZeroGradientPressureCondition(0.0, water, name='pres_walls')

vf_walls = api.WettingAngle([water, air], contact_angle=45.0, name='vf_walls')

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.DYNAMIC_PRESSURE
vf_frontAndBack = api.EmptyCondition(name='vf_frontAndBack')
vf_frontAndBack.data[CUBA.VARIABLE] = CUBA.VOLUME_FRACTION

inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet, vf_inlet])
walls = api.Boundary(name='walls', condition=[vel_walls, pres_walls, vf_walls])
atm = api.Boundary(name='atmosphere', condition=[vel_atm, pres_atm,
                                                 vf_atm])
frontAndBack = api.Boundary(name='frontAndBack', condition=[vel_frontAndBack,
                                                            pres_frontAndBack,
                                                            vf_frontAndBack])

cuds.add([inlet, walls, atm, frontAndBack])

# create mesh
mesh = foam_controlwrapper.create_block_mesh(tempfile.mkdtemp(), mesh_name,
                                             tube_mesh.blockMeshDict)
cuds.add([mesh])

mesh_in_cuds = cuds.get_by_name(mesh_name)
    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)
vel_b[3] = api.FreeSlipVelocity(name='vel_b3')
pres_b[3] = api.ZeroGradientPressureCondition(0.0, mat, name='pres_b3')

vel_b[4] = api.ConstantVelocityCondition((0, 0, 0), mat, name='vel_b4')
pres_b[4] = api.ZeroGradientPressureCondition(0.0, mat, name='pres_b4')

vel_b[5] = api.EmptyCondition(name='vel_b5')
vel_b[5].data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_b[5] = api.EmptyCondition(name='pres_b5')
pres_b[5].data[CUBA.VARIABLE] = CUBA.PRESSURE

boundaries = []
for i in range(6):
    boundaries.append(
        api.Boundary(name='boundary' + str(i), condition=[vel_b[i],
                                                          pres_b[i]]))
cuds.add(boundaries)

sim = Simulation(cuds, 'OpenFOAM', engine_interface=EngineInterface.Internal)

sim.run()

mesh_in_engine = cuds.get_by_name(mesh_name)

# compute velocity magnitude for visualization
updated_cells = []

for cell in mesh_in_engine.iter(item_type=CUBA.CELL):
    velo = cell.data[CUBA.VELOCITY]
    cell.data[CUBA.MAGNITUDE] = math.sqrt(
        sum(velo[i] * velo[i] for i in range(3)))