nutkRoughWallFunctionFvPatchScalarField.H 6.17 KB
Newer Older
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
5
    \\  /    A nd           | Copyright (C) 2011-2012 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::RASModels::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
79
80

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

namespace Foam
{
namespace incompressible
{
namespace RASModels
{

/*---------------------------------------------------------------------------*\
81
           Class nutkRoughWallFunctionFvPatchScalarField Declaration
82
83
\*---------------------------------------------------------------------------*/

84
class nutkRoughWallFunctionFvPatchScalarField
85
:
86
    public nutkWallFunctionFvPatchScalarField
87
{
88
protected:
89

90
    // Protected data
91

92
93
94
95
96
97
98
        //- Roughness height
        scalarField Ks_;

        //- Roughness constant
        scalarField Cs_;


99
    // Protected Member Functions
100
101

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

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


public:

    //- Runtime type information
111
    TypeName("nutkRoughWallFunction");
112
113
114
115
116


    // Constructors

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

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

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

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

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

        //- Construct as copy setting internal field reference
158
        nutkRoughWallFunctionFvPatchScalarField
159
        (
160
            const nutkRoughWallFunctionFvPatchScalarField&,
161
162
163
164
165
166
167
168
169
170
171
            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>
            (
172
                new nutkRoughWallFunctionFvPatchScalarField(*this, iF)
173
174
175
176
177
178
            );
        }


    // Member functions

179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
        // Acces functions

            // Return Ks
             scalarField& Ks()
            {
                return Ks_;
            }

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


194
195
196
        // Mapping functions

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

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


        // I-O

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


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

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

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

#endif

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