/
codedFunctionObject.H
177 lines (126 loc) · 5.28 KB
/
codedFunctionObject.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
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2024 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::codedFunctionObject
Description
Provides a general interface to enable dynamic code compilation.
The entries are:
\plaintable
codeInclude | include files
codeOptions | include paths; inserted into EXE_INC in Make/options
codeLibs | link line; inserted into LIB_LIBS in Make/options
codeData | c++; local member data (null constructed);
localCode | c++; local static functions;
codeRead | c++; upon functionObject::read();
codeFields | c++; upon functionObject::fields();
codeExecute | c++; upon functionObject::execute();
codeWrite | c++; upon functionObject::write()
codeEnd | c++; upon functionObject::end();
\endplaintable
Example of function object specification:
\verbatim
writeMagU
{
libs ("libutilityFunctionObjects.so");
type coded;
codeWrite
#{
// Lookup U
const volVectorField& U = mesh().lookupObject<volVectorField>("U");
// Write
mag(U)().write();
#};
}
\endverbatim
See also
Foam::functionObject
Foam::codedBase
SourceFiles
codedFunctionObject.C
\*---------------------------------------------------------------------------*/
#ifndef functionObjects_codedFunctionObject_H
#define functionObjects_codedFunctionObject_H
#include "functionObject.H"
#include "codedBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class codedFunctionObject Declaration
\*---------------------------------------------------------------------------*/
class codedFunctionObject
:
public functionObject,
public codedBase
{
// Private Data
//- The dynamically generated functionObject pointer
mutable autoPtr<functionObject> redirectFunctionObjectPtr_;
// Private Member Functions
//- Get the keywords associated with source code
virtual wordList codeKeys() const;
//- Get the name of the dictionary variables in the source code
virtual wordList codeDictVars() const;
//- Adapt the context for the current object
virtual void prepare(dynamicCode&, const dynamicCodeContext&) const;
//- Clear any redirected objects
virtual void clearRedirect() const;
//- Compile, link and return the now coded functionObject
functionObject& redirectFunctionObject() const;
public:
//- Runtime type information
TypeName("coded");
// Constructors
//- Construct from Time and dictionary
codedFunctionObject
(
const word& name,
const Time& time,
const dictionary& dict
);
//- Disallow default bitwise copy construction
codedFunctionObject(const codedFunctionObject&) = delete;
//- Destructor
virtual ~codedFunctionObject();
// Member Functions
//- Return the list of fields required
virtual wordList fields() const;
//- Called at each ++ or += of the time-loop.
// foamPostProcess overrides the usual executeControl behaviour and
// forces execution (used in post-processing mode)
virtual bool execute();
//- Called at each ++ or += of the time-loop.
// foamPostProcess overrides the usual writeControl behaviour and
// forces writing always (used in post-processing mode)
virtual bool write();
//- Called when Time::run() determines that the time-loop exits.
// By default it simply calls execute().
virtual bool end();
//- Read and set the function object if its data have changed
virtual bool read(const dictionary&);
// Member Operators
//- Disallow default bitwise assignment
void operator=(const codedFunctionObject&) = delete;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //