FlowAroundSphereCodeGen.py 4.38 KB
Newer Older
1
2
from pystencils.field import fields

3
from lbmpy.advanced_streaming.utility import get_timesteps
4
5
from lbmpy.macroscopic_value_kernels import macroscopic_values_setter
from lbmpy.stencils import get_stencil
6
from lbmpy.creationfunctions import create_lb_collision_rule
7
8
9
10
11
12
13
14
15
16
17
from lbmpy.boundaries import NoSlip, UBB, ExtrapolationOutflow

from pystencils_walberla import CodeGeneration, generate_sweep, generate_info_header

from lbmpy_walberla.additional_data_handler import UBBAdditionalDataHandler, OutflowAdditionalDataHandler
from lbmpy_walberla import generate_boundary, generate_lb_pack_info
from lbmpy_walberla import generate_alternating_lbm_sweep, generate_alternating_lbm_boundary

import sympy as sp

with CodeGeneration() as ctx:
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
    data_type = "float64" if ctx.double_accuracy else "float32"
    stencil = get_stencil("D3Q27")
    q = len(stencil)
    dim = len(stencil[0])
    streaming_pattern = 'esotwist'
    timesteps = get_timesteps(streaming_pattern)

    pdfs, velocity_field, density_field = fields(f"pdfs({q}), velocity({dim}), density(1) : {data_type}[{dim}D]",
                                                 layout='fzyx')
    omega = sp.Symbol("omega")
    u_max = sp.Symbol("u_max")

    output = {
        'density': density_field,
        'velocity': velocity_field
    }

    opt = {'symbolic_field': pdfs,
           'cse_global': False,
           'cse_pdfs': False,
           'double_precision': True if ctx.double_accuracy else False}

    method_params = {'method': 'cumulant',
                     'stencil': stencil,
                     'relaxation_rate': omega,
                     'galilean_correction': True,
                     'field_name': 'pdfs',
                     'streaming_pattern': streaming_pattern,
                     'output': output,
                     'optimization': opt}

    collision_rule = create_lb_collision_rule(**method_params)
    lb_method = collision_rule.method

    # getter & setter
    setter_assignments = macroscopic_values_setter(lb_method, velocity=velocity_field.center_vector,
                                                   pdfs=pdfs, density=1.0,
                                                   streaming_pattern=streaming_pattern,
                                                   previous_timestep=timesteps[0])

    # opt = {'instruction_set': 'sse', 'assume_aligned': True, 'nontemporal': False, 'assume_inner_stride_one': True}

    stencil_typedefs = {'Stencil_T': stencil}
    field_typedefs = {'PdfField_T': pdfs,
                      'VelocityField_T': velocity_field,
                      'ScalarField_T': density_field}

65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
    if ctx.cuda:
        target = 'gpu'
    else:
        target = 'cpu'

    opt['target'] = target

    # sweeps
    generate_alternating_lbm_sweep(ctx, 'FlowAroundSphereCodeGen_LbSweep',
                                   collision_rule, streaming_pattern, optimization=opt)
    generate_sweep(ctx, 'FlowAroundSphereCodeGen_MacroSetter', setter_assignments, target=target)

    # boundaries
    ubb = UBB(lambda *args: None, dim=dim)
    ubb_data_handler = UBBAdditionalDataHandler(stencil, ubb)
    outflow = ExtrapolationOutflow(stencil[4], lb_method, streaming_pattern=streaming_pattern)
    outflow_data_handler = OutflowAdditionalDataHandler(stencil, outflow, target=target)

    generate_alternating_lbm_boundary(ctx, 'FlowAroundSphereCodeGen_UBB', ubb, lb_method,
                                      target=target, streaming_pattern=streaming_pattern,
                                      additional_data_handler=ubb_data_handler)

    generate_alternating_lbm_boundary(ctx, 'FlowAroundSphereCodeGen_NoSlip', NoSlip(), lb_method,
                                      target=target, streaming_pattern=streaming_pattern)

    generate_alternating_lbm_boundary(ctx, 'FlowAroundSphereCodeGen_Outflow', outflow, lb_method,
                                      target=target, streaming_pattern=streaming_pattern,
                                      additional_data_handler=outflow_data_handler)

    # communication
    generate_lb_pack_info(ctx, 'FlowAroundSphereCodeGen_PackInfo', stencil, pdfs,
                          streaming_pattern=streaming_pattern, always_generate_separate_classes=True, target=target)

    # Info header containing correct template definitions for stencil and field
    generate_info_header(ctx, 'FlowAroundSphereCodeGen_InfoHeader',
                         stencil_typedefs=stencil_typedefs, field_typedefs=field_typedefs)