ConstantField.C 6.97 KB
Newer Older
Mattijs Janssens's avatar
Mattijs Janssens committed
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
5
    \\  /    A nd           | Copyright (C) 2018-2019 OpenCFD Ltd.
Mattijs Janssens's avatar
Mattijs Janssens committed
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
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    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.

    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
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

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

#include "ConstantField.H"

// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const polyPatch& pp,
    const word& entryName,
35
36
37
    const bool isUniform,
    const Type& uniformValue,
    const Field<Type>& nonUniformValue,
Mattijs Janssens's avatar
Mattijs Janssens committed
38
39
40
41
42
    const dictionary& dict,
    const bool faceValues
)
:
    PatchFunction1<Type>(pp, entryName, dict, faceValues),
43
44
45
    isUniform_(isUniform),
    uniformValue_(uniformValue),
    value_(nonUniformValue)
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
{
    if (faceValues && nonUniformValue.size() != pp.size())
    {
        FatalIOErrorInFunction(dict)
            << "Supplied field size " << nonUniformValue.size()
            << " is not equal to the number of faces " << pp.size()
            << " of patch " << pp.name() << exit(FatalIOError);
    }
    else if (!faceValues && nonUniformValue.size() != pp.nPoints())
    {
        FatalIOErrorInFunction(dict)
            << "Supplied field size " << nonUniformValue.size()
            << " is not equal to the number of points " << pp.nPoints()
            << " of patch " << pp.name() << exit(FatalIOError);
    }
}
Mattijs Janssens's avatar
Mattijs Janssens committed
62
63


64
65
66
67
68
template<class Type>
Foam::Field<Type> Foam::PatchFunction1Types::ConstantField<Type>::getValue
(
    const word& keyword,
    const dictionary& dict,
69
70
71
    const label len,
    bool& isUniform,
    Type& uniformValue
72
73
)
{
74
75
76
    isUniform = true;
    uniformValue = Zero;

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
    Field<Type> fld;

    if (len)
    {
        ITstream& is = dict.lookup(keyword);

        // Read first token
        token firstToken(is);

        if (firstToken.isWord())
        {
            if
            (
                firstToken.wordToken() == "uniform"
             || firstToken.wordToken() == "constant"
            )
            {
94
                is >> uniformValue;
95
                fld.setSize(len);
96
                fld = uniformValue;
97
            }
98
99
100
101
            else if (firstToken.wordToken() == "nonuniform")
            {
                List<Type>& list = fld;
                is >> list;
102
103
                isUniform = false;

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
                label currentSize = fld.size();
                if (currentSize != len)
                {
                    if
                    (
                        len < currentSize
                     && FieldBase::allowConstructFromLargerSize
                    )
                    {
                        #ifdef FULLDEBUG
                        IOWarningInFunction(dict)
                            << "Sizes do not match. "
                            << "Re-sizing " << currentSize
                            << " entries to " << len
                            << endl;
                        #endif

                        // Resize the data
                        fld.setSize(len);
                    }
                    else
                    {
                        FatalIOErrorInFunction(dict)
                            << "size " << fld.size()
                            << " is not equal to the given value of " << len
                            << exit(FatalIOError);
                    }
                }
            }
133
134
            else
            {
135
                isUniform = false;
136
                FatalIOErrorInFunction(dict)
137
                    << "Expected keyword 'uniform', 'nonuniform' or 'constant'"
138
                    << ", found " << firstToken.wordToken()
139
140
141
142
143
144
                    << exit(FatalIOError);
            }
        }
        else
        {
            is.putBack(firstToken);
145
146
147
            is >> uniformValue;
            fld.setSize(len);
            fld = uniformValue;
148
149
        }
    }
150

151
152
153
154
    return fld;
}


Mattijs Janssens's avatar
Mattijs Janssens committed
155
156
157
158
template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const polyPatch& pp,
159
    const word& type,
Mattijs Janssens's avatar
Mattijs Janssens committed
160
161
162
163
164
165
    const word& entryName,
    const dictionary& dict,
    const bool faceValues
)
:
    PatchFunction1<Type>(pp, entryName, dict, faceValues),
166
167
168
169
170
171
172
173
174
175
176
    value_
    (
        getValue
        (
            entryName,
            dict,
            (faceValues ? pp.size() : pp.nPoints()),
            isUniform_,
            uniformValue_
        )
    )
Mattijs Janssens's avatar
Mattijs Janssens committed
177
178
179
180
181
182
183
184
185
186
{}


template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const ConstantField<Type>& cnst
)
:
    PatchFunction1<Type>(cnst),
187
188
    isUniform_(cnst.isUniform_),
    uniformValue_(cnst.uniformValue_),
Mattijs Janssens's avatar
Mattijs Janssens committed
189
190
191
192
193
194
195
196
197
198
199
200
    value_(cnst.value_)
{}


template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const ConstantField<Type>& cnst,
    const polyPatch& pp
)
:
    PatchFunction1<Type>(cnst, pp),
201
202
    isUniform_(cnst.isUniform_),
    uniformValue_(cnst.uniformValue_),
Mattijs Janssens's avatar
Mattijs Janssens committed
203
    value_(cnst.value_)
204
205
{
    // If different sizes do what?
206
207
208
209
210
211
    value_.setSize
    (
        this->faceValues_
      ? this->patch_.size()
      : this->patch_.nPoints()
    );
212
213
214
215
216
    if (isUniform_)
    {
        value_ = uniformValue_;
    }
}
Mattijs Janssens's avatar
Mattijs Janssens committed
217
218
219
220
221
222
223
224
225
226
227


// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //

template<class Type>
void Foam::PatchFunction1Types::ConstantField<Type>::autoMap
(
    const FieldMapper& mapper
)
{
    value_.autoMap(mapper);
228
229
230
231
232
233

    // If originating from single value override just to make sure
    if (isUniform_)
    {
        value_ = uniformValue_;
    }
Mattijs Janssens's avatar
Mattijs Janssens committed
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
}


template<class Type>
void Foam::PatchFunction1Types::ConstantField<Type>::rmap
(
    const PatchFunction1<Type>& pf1,
    const labelList& addr
)
{
    const auto& cst = refCast<const ConstantField<Type>>(pf1);
    value_.rmap(cst.value_, addr);
}


template<class Type>
void Foam::PatchFunction1Types::ConstantField<Type>::writeData
(
    Ostream& os
) const
{
    PatchFunction1<Type>::writeData(os);
256
257
258
259
260
261
262
263
264
265
266

    if (isUniform_)
    {
        os.writeKeyword(this->name_)
            << "constant " << uniformValue_
            << token::END_STATEMENT << nl;
    }
    else
    {
        value_.writeEntry(this->name_, os);
    }
Mattijs Janssens's avatar
Mattijs Janssens committed
267
268
269
270
}


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