nutkRoughWallFunctionFvPatchScalarField.H 6.11 KB
Newer Older
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
andy's avatar
andy committed
5
    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
6
7
8
9
10
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

11
12
13
14
    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
15
16
17
18
19
20
21

    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.

    You should have received a copy of the GNU General Public License
22
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
23
24

Class
25
    Foam::incompressible::nutkRoughWallFunctionFvPatchScalarField
26

andy's avatar
andy committed
27
28
29
Group
    grpIcoWallFunctions

30
Description
31
32
    This boundary condition provides a turbulent kinematic viscosity condition
    when using wall functions for rough walls, based on turbulence kinetic
andy's avatar
andy committed
33
34
    energy.  The condition manipulates the E parameter to account for roughness
    effects.
35

36
    Parameter ranges
37
    - roughness height = sand-grain roughness (0 for smooth walls)
38
39
    - roughness constant = 0.5-1.0

andy's avatar
andy committed
40
    \heading Patch usage
41

andy's avatar
andy committed
42
    \table
43
44
45
        Property     | Description             | Required    | Default value
        Ks           | sand-grain roughness height | yes     |
        Cs           | roughness constant      | yes         |
andy's avatar
andy committed
46
    \endtable
47
48
49
50
51

    Example of the boundary condition specification:
    \verbatim
    myPatch
    {
andy's avatar
andy committed
52
        type            nutkRoughWallFunction;
53
54
55
56
57
58
59
        Ks              uniform 0;
        Cs              uniform 0.5;
    }
    \endverbatim

SeeAlso
    Foam::nutkRoughWallFunctionFvPatchScalarField
60
61

SourceFiles
62
    nutkRoughWallFunctionFvPatchScalarField.C
63
64
65

\*---------------------------------------------------------------------------*/

66
67
#ifndef nutkRoughWallFunctionFvPatchScalarField_H
#define nutkRoughWallFunctionFvPatchScalarField_H
68

69
#include "nutkWallFunctionFvPatchScalarField.H"
70
71
72
73
74
75
76
77
78

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

namespace Foam
{
namespace incompressible
{

/*---------------------------------------------------------------------------*\
79
           Class nutkRoughWallFunctionFvPatchScalarField Declaration
80
81
\*---------------------------------------------------------------------------*/

82
class nutkRoughWallFunctionFvPatchScalarField
83
:
84
    public nutkWallFunctionFvPatchScalarField
85
{
86
protected:
87

88
    // Protected data
89

90
91
92
93
94
95
96
        //- Roughness height
        scalarField Ks_;

        //- Roughness constant
        scalarField Cs_;


97
    // Protected Member Functions
98
99

        //- Compute the roughness function
100
101
102
103
        virtual scalar fnRough(const scalar KsPlus, const scalar Cs) const;

        //- Calculate the turbulence viscosity
        virtual tmp<scalarField> calcNut() const;
104
105
106
107
108


public:

    //- Runtime type information
109
    TypeName("nutkRoughWallFunction");
110
111
112
113
114


    // Constructors

        //- Construct from patch and internal field
115
        nutkRoughWallFunctionFvPatchScalarField
116
117
118
119
120
121
        (
            const fvPatch&,
            const DimensionedField<scalar, volMesh>&
        );

        //- Construct from patch, internal field and dictionary
122
        nutkRoughWallFunctionFvPatchScalarField
123
124
125
126
127
128
129
        (
            const fvPatch&,
            const DimensionedField<scalar, volMesh>&,
            const dictionary&
        );

        //- Construct by mapping given
130
        //  nutkRoughWallFunctionFvPatchScalarField
131
        //  onto a new patch
132
        nutkRoughWallFunctionFvPatchScalarField
133
        (
134
            const nutkRoughWallFunctionFvPatchScalarField&,
135
136
137
138
139
140
            const fvPatch&,
            const DimensionedField<scalar, volMesh>&,
            const fvPatchFieldMapper&
        );

        //- Construct as copy
141
        nutkRoughWallFunctionFvPatchScalarField
142
        (
143
            const nutkRoughWallFunctionFvPatchScalarField&
144
145
146
147
148
149
150
        );

        //- Construct and return a clone
        virtual tmp<fvPatchScalarField> clone() const
        {
            return tmp<fvPatchScalarField>
            (
151
                new nutkRoughWallFunctionFvPatchScalarField(*this)
152
153
154
155
            );
        }

        //- Construct as copy setting internal field reference
156
        nutkRoughWallFunctionFvPatchScalarField
157
        (
158
            const nutkRoughWallFunctionFvPatchScalarField&,
159
160
161
162
163
164
165
166
167
168
169
            const DimensionedField<scalar, volMesh>&
        );

        //- Construct and return a clone setting internal field reference
        virtual tmp<fvPatchScalarField> clone
        (
            const DimensionedField<scalar, volMesh>& iF
        ) const
        {
            return tmp<fvPatchScalarField>
            (
170
                new nutkRoughWallFunctionFvPatchScalarField(*this, iF)
171
172
173
174
175
176
            );
        }


    // Member functions

177
178
179
        // Acces functions

            // Return Ks
andy's avatar
andy committed
180
            scalarField& Ks()
181
182
183
184
185
186
187
188
189
190
191
            {
                return Ks_;
            }

            // Return Cs
            scalarField& Cs()
            {
                return Cs_;
            }


192
193
194
        // Mapping functions

            //- Map (and resize as needed) from self given a mapping object
195
            virtual void autoMap(const fvPatchFieldMapper&);
196
197
198
199
200
201
202
203
204
205
206
207

            //- Reverse map the given fvPatchField onto this fvPatchField
            virtual void rmap
            (
                const fvPatchScalarField&,
                const labelList&
            );


        // I-O

            //- Write
208
            virtual void write(Ostream&) const;
209
210
211
212
213
214
215
216
217
218
219
220
221
};


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

} // End namespace incompressible
} // End namespace Foam

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

#endif

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