/
volFieldValue.H
378 lines (295 loc) · 10.3 KB
/
volFieldValue.H
1
2
3
4
5
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
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
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ 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/>.
Class
Foam::functionObjects::fieldValues::volFieldValue
Description
Provides a 'volRegion' specialisation of the fieldValue function object.
Given a list of user-specified fields and a 'volRegion', a number of
operations can be performed, such as sums, averages and integrations.
Example of function object specification:
\verbatim
volFieldValue1
{
type volFieldValue;
libs ("libfieldFunctionObjects.so");
log true;
writeControl writeTime;
writeFields true;
regionType cellZone;
name c0;
operation volAverage;
weightField alpha1;
fields
(
p
U
);
}
\endverbatim
Usage
\table
Property | Description | Required | Default value
type | Type name: volFieldValue | yes |
log | Write data to standard output | no | no
writeFields | Write the region field values | yes |
writeLocation| Write the location (if available) | no | no
regionType | volRegion type: see below | yes |
name | Name of volRegion if required | no |
operation | Operation to perform | yes |
weightField | Name of field to apply weighting | no |
weightFields | Names of fields to apply weighting | no |
fields | List of fields to operate on | yes |
\endtable
Where \c regionType is defined by
\plaintable
cellZone | requires a 'name' entry to specify the cellZone
all | all cells
\endplaintable
The \c operation is one of:
\plaintable
none | No operation
sum | Sum
sumMag | Sum of component magnitudes
average | Ensemble average
volAverage | Volume weighted average
volIntegrate | Volume integral
min | Minimum
max | Maximum
minMag | Minimum magnitude
maxMag | Maximum magnitude
CoV | Coefficient of variation: standard deviation/mean
\endplaintable
See also
Foam::functionObjects::fieldValues::fieldValue
Foam::functionObjects::volRegion
Foam::functionObject
SourceFiles
volFieldValue.C
\*---------------------------------------------------------------------------*/
#ifndef functionObjects_volFieldValue_H
#define functionObjects_volFieldValue_H
#include "fieldValue.H"
#include "volRegion.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace functionObjects
{
namespace fieldValues
{
/*---------------------------------------------------------------------------*\
Class volFieldValue Declaration
\*---------------------------------------------------------------------------*/
class volFieldValue
:
public fieldValue,
public volRegion
{
public:
// Public data types
//- Operation type enumeration
enum class operationType
{
none,
sum,
sumMag,
average,
volAverage,
volIntegrate,
min,
max,
minMag,
maxMag,
CoV
};
//- Operation type names
static const NamedEnum<operationType, 11> operationTypeNames_;
// Public classes
//- Forward declare the result structure
template<class Type>
struct Result;
protected:
// Protected data
//- Write the location if available for this operation - optional
Switch writeLocation_;
//- Operation to apply to values
operationType operation_;
//- Weight field names
wordList weightFieldNames_;
//- Scale factor - optional
scalar scaleFactor_;
// Protected Member Functions
//- Initialise, e.g. cell addressing
void initialise(const dictionary& dict);
//- Return true if the field name is valid
template<class Type>
bool validField(const word& fieldName) const;
//- Insert field values into values list
template<class Type>
tmp<Field<Type>> getFieldValues(const word& fieldName) const;
//- Apply a comparison operation to the values, returning the limiting
// value, its index and processor index
template<class Op>
void compareScalars
(
const scalarField& values,
Result<scalar>& result,
const Op& op
) const;
//- Apply the operation to the values, and return true if successful.
// Does nothing unless overloaded below.
template<class Type, class ResultType>
bool processValues
(
const Field<Type>& values,
const scalarField& weights,
const scalarField& V,
Result<ResultType>& result
) const;
//- Apply Type -> Type operation to the values. Calls
// processValuesTypeType.
template<class Type>
bool processValues
(
const Field<Type>& values,
const scalarField& weights,
const scalarField& V,
Result<Type>& result
) const;
//- Apply Type -> scalar operation to the values
template<class Type>
bool processValues
(
const Field<Type>& values,
const scalarField& weights,
const scalarField& V,
Result<scalar>& result
) const;
//- Apply scalar -> scalar operation to the values. Calls
// processValuesTypeType.
bool processValues
(
const Field<scalar>& values,
const scalarField& weights,
const scalarField& V,
Result<scalar>& result
) const;
//- Apply a Type -> Type operation to the values
template<class Type>
bool processValuesTypeType
(
const Field<Type>& values,
const scalarField& weights,
const scalarField& V,
Result<Type>& result
) const;
//- Output file header location information for a given type
template<class Type>
void writeFileHeaderLocation();
//- Output file header information
virtual void writeFileHeader(const label i);
public:
//- Run-time type information
TypeName("volFieldValue");
// Constructors
//- Construct from name, Time and dictionary
volFieldValue
(
const word& name,
const Time& runTime,
const dictionary& dict
);
//- Construct from name, objectRegistry and dictionary
volFieldValue
(
const word& name,
const objectRegistry& obr,
const dictionary& dict
);
//- Destructor
virtual ~volFieldValue();
// Public Member Functions
//- Templated helper function to output field values
template<class Type>
bool writeValues
(
const word& fieldName,
const scalarField& weights,
const scalarField& V
);
//- Templated helper function to output field values
template<class Type, class ResultType>
bool writeValues
(
const word& fieldName,
const Field<Type>& values,
const scalarField& weights,
const scalarField& V
);
//- Filter a field according to cellIds
template<class Type>
tmp<Field<Type>> filterField(const Field<Type>& field) const;
//- Read from dictionary
virtual bool read(const dictionary&);
//- Calculate and write
virtual bool write();
};
template<>
void volFieldValue::writeFileHeaderLocation<scalar>();
/*---------------------------------------------------------------------------*\
Class volFieldValue::Result Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
struct volFieldValue::Result
{
Type value;
label celli;
label proci;
point cc;
};
template<class Type>
inline Istream& operator>>
(
Istream& is,
volFieldValue::Result<Type>& result
)
{
return is >> result.value >> result.celli >> result.proci >> result.cc;
}
template<class Type>
inline Ostream& operator<<
(
Ostream& os,
const volFieldValue::Result<Type>& result
)
{
return os << result.value << result.celli << result.proci << result.cc;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace fieldValues
} // End namespace functionObjects
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "volFieldValueTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //