createBafflesDict 4.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  dev                                   |
|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    object      createBafflesDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

// Whether to convert internal faces only (so leave boundary faces intact).
// This is only relevant if your face selection type can pick up boundary
// faces.
internalFacesOnly true;


// Baffles to create.
baffles
{
    baffleFaces
    {
        //- Use predefined faceZone to select faces and orientation.
        type        faceZone;
        zoneName    baffleFaces;


        //- Optional flip
        //flip        false;

        patches
        {
            master
            {
                //- Master side patch
                name            baffles;
                type            wall;

                patchFields
                {
                    epsilon
                    {
                        type            epsilonWallFunction;
                        Cmu             0.09;
                        kappa           0.41;
51
                        E               9.8;
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
                        value           uniform 0;
                    }
                    k
                    {
                        type            kqRWallFunction;
                        value           uniform 0;
                    }
                    nut
                    {
                        type            nutkWallFunction;
                        Cmu             0.09;
                        kappa           0.41;
                        E               9.8;
                        value           uniform 0;
                    }
                    nuTilda
                    {
                        type            zeroGradient;
                    }
                    p
                    {
                        type            zeroGradient;
                    }
                    U
                    {
                        type            fixedValue;
                        value           uniform (0 0 0);
                    }
                }
            }
            slave
            {
mattijs's avatar
mattijs committed
84
85
                // Reuse master data
                ${..master}
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
            }
        }
    }



    cyclicFaces
    {
        //- Select faces and orientation through a searchableSurface
        type        searchableSurface;
        surface     searchablePlate;
        origin      (0.099 -0.006 0.004);
        span        (0 0.012 0.012);

        patches
        {
            master
            {
                //- Master side patch

                name            fan_half0;
                type            cyclic;
                neighbourPatch  fan_half1;

                //- Optional override of added patchfields. If not specified
                //  any added patchfields are of type calculated.
                patchFields
                {
                    p
                    {
                        type            fan;
                        patchType       cyclic;
                        jump            uniform 0;
                        value           uniform 0;
                        jumpTable       polynomial 1((100 0));
                    }
                }
            }
            slave
            {
                //- Slave side patch

                name            fan_half1;
                type            cyclic;
                neighbourPatch  fan_half0;

                patchFields
                {
                    p
                    {
                        type            fan;
                        patchType       cyclic;
                        value           uniform 0;
                    }
                }
            }
        }
    }
}


// ************************************************************************* //