ConstantField.C 7.42 KB
Newer Older
Mattijs Janssens's avatar
Mattijs Janssens committed
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
OpenFOAM bot's avatar
OpenFOAM bot committed
5
    \\  /    A nd           | www.openfoam.com
Mattijs Janssens's avatar
Mattijs Janssens committed
6
     \\/     M anipulation  |
OpenFOAM bot's avatar
OpenFOAM bot committed
7
-------------------------------------------------------------------------------
8
    Copyright (C) 2018-2021 OpenCFD Ltd.
Mattijs Janssens's avatar
Mattijs Janssens committed
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
-------------------------------------------------------------------------------
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  * * * * * * * * * * * * * * //

32
33
34
35
36
37
38
39
40
41
42
43
44
template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const polyPatch& pp,
    const word& entryName,
    const Type& uniformValue,
    const dictionary& dict,
    const bool faceValues
)
:
    PatchFunction1<Type>(pp, entryName, dict, faceValues),
    isUniform_(true),
    uniformValue_(uniformValue),
45
    value_(this->size(), uniformValue_)
46
47
48
{}


Mattijs Janssens's avatar
Mattijs Janssens committed
49
50
51
52
53
template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const polyPatch& pp,
    const word& entryName,
54
55
    const bool isUniform,
    const Type& uniformValue,
56
    const Field<Type>& fieldValues,
Mattijs Janssens's avatar
Mattijs Janssens committed
57
58
59
60
61
    const dictionary& dict,
    const bool faceValues
)
:
    PatchFunction1<Type>(pp, entryName, dict, faceValues),
62
63
    isUniform_(isUniform),
    uniformValue_(uniformValue),
64
    value_(fieldValues)
65
{
66
    if (fieldValues.size() != this->size())
67
68
    {
        FatalIOErrorInFunction(dict)
69
70
71
            << "Supplied field size " << fieldValues.size()
            << " is not equal to the number of "
            << (faceValues ? "faces" : "points") << ' '
72
            << this->size() << " of patch " << pp.name() << nl
73
            << exit(FatalIOError);
74
75
    }
}
Mattijs Janssens's avatar
Mattijs Janssens committed
76
77


78
template<class Type>
79
80
Foam::Field<Type>
Foam::PatchFunction1Types::ConstantField<Type>::getValue
81
(
82
    const entry* eptr,
83
    const dictionary& dict,
84
85
86
    const label len,
    bool& isUniform,
    Type& uniformValue
87
88
)
{
89
90
91
    isUniform = true;
    uniformValue = Zero;

92
93
    Field<Type> fld;

94
    if (!eptr || !eptr->isStream())
95
    {
96
97
98
99
100
101
102
103
104
105
106
        FatalIOErrorInFunction(dict)
            << "Null or invalid entry" << nl
            << exit(FatalIOError);
    }
    ITstream& is = eptr->stream();

    if (is.peek().isWord())
    {
        const word contentType(is);

        if (contentType == "constant" || contentType == "uniform")
107
        {
108
109
110
            is >> uniformValue;
            fld.resize(len);
            fld = uniformValue;
111
        }
112
        else if (contentType == "nonuniform")
113
        {
114
            if (len)
115
            {
116
                isUniform = false;
117
            }
118
119
120
121

            is >> static_cast<List<Type>&>(fld);
            const label lenRead = fld.size();
            if (len != lenRead)
122
            {
123
124
125
126
127
                if
                (
                    len < lenRead
                 && FieldBase::allowConstructFromLargerSize
                )
128
                {
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
                    #ifdef FULLDEBUG
                    IOWarningInFunction(dict)
                        << "Sizes do not match. Truncating " << lenRead
                        << " entries to " << len << endl;
                    #endif

                    // Truncate the data
                    fld.resize(len);
                }
                else
                {
                    FatalIOErrorInFunction(dict)
                        << "size " << lenRead
                        << " is not equal to the expected length " << len
                        << exit(FatalIOError);
144
                }
145
146
147
148
            }
        }
        else
        {
149
150
151
152
            FatalIOErrorInFunction(dict)
                << "Expected keyword 'constant', 'uniform', or 'nonuniform'"
                << ", found " << contentType
                << exit(FatalIOError);
153
154
        }
    }
155
156
157
158
159
160
161
    else
    {
        // Uniform (constant) field
        is >> uniformValue;
        fld.resize(len);
        fld = uniformValue;
    }
162

163
164
165
166
    return fld;
}


Mattijs Janssens's avatar
Mattijs Janssens committed
167
168
169
170
template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const polyPatch& pp,
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
    const word& redirectType,
    const word& entryName,
    const dictionary& dict,
    const bool faceValues
)
:
    PatchFunction1<Type>(pp, entryName, dict, faceValues),
    isUniform_(true),  // overwritten by getValue()
    uniformValue_(Zero),  // overwritten by getValue()
    value_
    (
        getValue
        (
            dict.findEntry(entryName, keyType::LITERAL),
            dict,
            this->size(),
            isUniform_,
            uniformValue_
        )
    )
{}


template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const polyPatch& pp,
    const entry* eptr,
Mattijs Janssens's avatar
Mattijs Janssens committed
199
200
201
202
203
204
    const word& entryName,
    const dictionary& dict,
    const bool faceValues
)
:
    PatchFunction1<Type>(pp, entryName, dict, faceValues),
205
206
    isUniform_(true),  // overwritten by getValue()
    uniformValue_(Zero),  // overwritten by getValue()
207
208
209
210
    value_
    (
        getValue
        (
211
            eptr,
212
            dict,
213
            this->size(),
214
215
216
217
            isUniform_,
            uniformValue_
        )
    )
Mattijs Janssens's avatar
Mattijs Janssens committed
218
219
220
221
222
223
{}


template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
224
    const ConstantField<Type>& rhs
Mattijs Janssens's avatar
Mattijs Janssens committed
225
226
)
:
227
    ConstantField<Type>(rhs, rhs.patch())
Mattijs Janssens's avatar
Mattijs Janssens committed
228
229
230
231
232
233
{}


template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
234
    const ConstantField<Type>& rhs,
Mattijs Janssens's avatar
Mattijs Janssens committed
235
236
237
    const polyPatch& pp
)
:
238
239
240
241
    PatchFunction1<Type>(rhs, pp),
    isUniform_(rhs.isUniform_),
    uniformValue_(rhs.uniformValue_),
    value_(rhs.value_)
242
{
243
    // If sizes are different...
244
    value_.resize(this->size(), Zero);
245

246
247
248
249
250
    if (isUniform_)
    {
        value_ = uniformValue_;
    }
}
Mattijs Janssens's avatar
Mattijs Janssens committed
251
252
253
254
255
256
257
258
259
260
261


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

template<class Type>
void Foam::PatchFunction1Types::ConstantField<Type>::autoMap
(
    const FieldMapper& mapper
)
{
    value_.autoMap(mapper);
262
263
264
265
266
267

    // If originating from single value override just to make sure
    if (isUniform_)
    {
        value_ = uniformValue_;
    }
Mattijs Janssens's avatar
Mattijs Janssens committed
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
}


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);
290
291
292

    if (isUniform_)
    {
293
        os.writeKeyword(this->name())
294
295
            << word("constant") << token::SPACE << uniformValue_;
        os.endEntry();
296
297
298
    }
    else
    {
299
        value_.writeEntry(this->name(), os);
300
    }
Mattijs Janssens's avatar
Mattijs Janssens committed
301
302
303
304
}


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