ConstantField.C 7.68 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-2020 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
94
95
    Field<Type> fld;

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

104
        if (is.peek().isWord())
105
        {
106
107
108
            const word contentType(is);

            if (contentType == "uniform" || contentType == "constant")
109
            {
110
                is >> uniformValue;
111
                fld.resize(len);
112
                fld = uniformValue;
113
            }
114
            else if (contentType == "nonuniform")
115
            {
116
                isUniform = false;
117
118
119
                is >> static_cast<List<Type>&>(fld);
                const label lenRead = fld.size();
                if (len != lenRead)
120
121
122
                {
                    if
                    (
123
                        len < lenRead
124
125
126
127
128
                     && FieldBase::allowConstructFromLargerSize
                    )
                    {
                        #ifdef FULLDEBUG
                        IOWarningInFunction(dict)
129
130
                            << "Sizes do not match. Truncating " << lenRead
                            << " entries to " << len << endl;
131
132
                        #endif

133
134
                        // Truncate the data
                        fld.resize(len);
135
136
137
138
                    }
                    else
                    {
                        FatalIOErrorInFunction(dict)
139
140
                            << "size " << lenRead
                            << " is not equal to the expected length " << len
141
142
143
144
                            << exit(FatalIOError);
                    }
                }
            }
145
146
            else
            {
147
                isUniform = false;
148
                FatalIOErrorInFunction(dict)
149
                    << "Expected keyword 'uniform', 'nonuniform' or 'constant'"
150
                    << ", found " << contentType
151
152
153
154
155
                    << exit(FatalIOError);
            }
        }
        else
        {
156
            // Uniform (constant) field
157
            is >> uniformValue;
158
            fld.resize(len);
159
            fld = uniformValue;
160
161
        }
    }
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
            << word("constant") << token::SPACE << uniformValue_
295
296
297
298
            << token::END_STATEMENT << nl;
    }
    else
    {
299
        value_.writeEntry(this->name(), os);
300
    }
Mattijs Janssens's avatar
Mattijs Janssens committed
301
302
303
304
}


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