ConstantField.C 7.29 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
45
46
47
48
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),
    value_((faceValues ? pp.size() : pp.nPoints()), uniformValue_)
{}


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
67
68
    const label len = (faceValues ? pp.size() : pp.nPoints());

    if (fieldValues.size() != len)
69
70
    {
        FatalIOErrorInFunction(dict)
71
72
73
74
75
            << "Supplied field size " << fieldValues.size()
            << " is not equal to the number of "
            << (faceValues ? "faces" : "points") << ' '
            << len << " of patch " << pp.name() << nl
            << exit(FatalIOError);
76
77
    }
}
Mattijs Janssens's avatar
Mattijs Janssens committed
78
79


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

93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
    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"
            )
            {
110
                is >> uniformValue;
111
                fld.setSize(len);
112
                fld = uniformValue;
113
            }
114
115
116
117
            else if (firstToken.wordToken() == "nonuniform")
            {
                List<Type>& list = fld;
                is >> list;
118
119
                isUniform = false;

120
                const label currentSize = fld.size();
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
                if (currentSize != len)
                {
                    if
                    (
                        len < currentSize
                     && FieldBase::allowConstructFromLargerSize
                    )
                    {
                        #ifdef FULLDEBUG
                        IOWarningInFunction(dict)
                            << "Sizes do not match. "
                            << "Re-sizing " << currentSize
                            << " entries to " << len
                            << endl;
                        #endif

137
                        // Resize (shrink) the data
138
139
140
141
142
143
144
145
146
147
148
                        fld.setSize(len);
                    }
                    else
                    {
                        FatalIOErrorInFunction(dict)
                            << "size " << fld.size()
                            << " is not equal to the given value of " << len
                            << exit(FatalIOError);
                    }
                }
            }
149
150
            else
            {
151
                isUniform = false;
152
                FatalIOErrorInFunction(dict)
153
                    << "Expected keyword 'uniform', 'nonuniform' or 'constant'"
154
                    << ", found " << firstToken.wordToken()
155
156
157
158
159
160
                    << exit(FatalIOError);
            }
        }
        else
        {
            is.putBack(firstToken);
161
162
163
            is >> uniformValue;
            fld.setSize(len);
            fld = uniformValue;
164
165
        }
    }
166

167
168
169
170
    return fld;
}


Mattijs Janssens's avatar
Mattijs Janssens committed
171
172
173
174
template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const polyPatch& pp,
175
    const word& type,
Mattijs Janssens's avatar
Mattijs Janssens committed
176
177
178
179
180
181
    const word& entryName,
    const dictionary& dict,
    const bool faceValues
)
:
    PatchFunction1<Type>(pp, entryName, dict, faceValues),
182
183
184
185
186
187
188
189
190
191
192
    value_
    (
        getValue
        (
            entryName,
            dict,
            (faceValues ? pp.size() : pp.nPoints()),
            isUniform_,
            uniformValue_
        )
    )
Mattijs Janssens's avatar
Mattijs Janssens committed
193
194
195
196
197
198
199
200
201
202
{}


template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const ConstantField<Type>& cnst
)
:
    PatchFunction1<Type>(cnst),
203
204
    isUniform_(cnst.isUniform_),
    uniformValue_(cnst.uniformValue_),
Mattijs Janssens's avatar
Mattijs Janssens committed
205
206
207
208
209
210
211
212
213
214
215
216
    value_(cnst.value_)
{}


template<class Type>
Foam::PatchFunction1Types::ConstantField<Type>::ConstantField
(
    const ConstantField<Type>& cnst,
    const polyPatch& pp
)
:
    PatchFunction1<Type>(cnst, pp),
217
218
    isUniform_(cnst.isUniform_),
    uniformValue_(cnst.uniformValue_),
Mattijs Janssens's avatar
Mattijs Janssens committed
219
    value_(cnst.value_)
220
{
221
222
    // If sizes are different...
    value_.resize
223
    (
224
225
        (this->faceValues_ ? this->patch_.size() : this->patch_.nPoints()),
        Zero
226
    );
227

228
229
230
231
232
    if (isUniform_)
    {
        value_ = uniformValue_;
    }
}
Mattijs Janssens's avatar
Mattijs Janssens committed
233
234
235
236
237
238
239
240
241
242
243


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

template<class Type>
void Foam::PatchFunction1Types::ConstantField<Type>::autoMap
(
    const FieldMapper& mapper
)
{
    value_.autoMap(mapper);
244
245
246
247
248
249

    // If originating from single value override just to make sure
    if (isUniform_)
    {
        value_ = uniformValue_;
    }
Mattijs Janssens's avatar
Mattijs Janssens committed
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
}


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);
272
273
274
275

    if (isUniform_)
    {
        os.writeKeyword(this->name_)
276
            << word("constant") << token::SPACE << uniformValue_
277
278
279
280
281
282
            << token::END_STATEMENT << nl;
    }
    else
    {
        value_.writeEntry(this->name_, os);
    }
Mattijs Janssens's avatar
Mattijs Janssens committed
283
284
285
286
}


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