codedFunctionObject.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
11  OpenFOAM is free software: you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation, either version 3 of the License, or
14  (at your option) any later version.
15 
16  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19  for more details.
20 
21  You should have received a copy of the GNU General Public License
22  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
23 
24 Class
25  Foam::codedFunctionObject
26 
27 Description
28  Provides a general interface to enable dynamic code compilation.
29 
30  The entries are:
31  \plaintable
32  codeInclude | include files
33  codeOptions | include paths; inserted into EXE_INC in Make/options
34  codeLibs | link line; inserted into LIB_LIBS in Make/options
35  codeData | c++; local member data (null constructed);
36  localCode | c++; local static functions;
37  codeRead | c++; upon functionObject::read();
38  codeExecute | c++; upon functionObject::execute();
39  codeWrite | c++; upon functionObject::write()
40  codeEnd | c++; upon functionObject::end();
41  \endplaintable
42 
43  Example of function object specification:
44  \verbatim
45  difference
46  {
47  libs ("libutilityFunctionObjects.so");
48 
49  type coded;
50  // Name of on-the-fly generated functionObject
51  name writeMagU;
52  codeWrite
53  #{
54  // Lookup U
55  const volVectorField& U = mesh().lookupObject<volVectorField>("U");
56  // Write
57  mag(U)().write();
58  #};
59  }
60  \endverbatim
61 
62 See also
63  Foam::functionObject
64  Foam::codedBase
65 
66 SourceFiles
67  codedFunctionObject.C
68 
69 \*---------------------------------------------------------------------------*/
70 
71 #ifndef functionObjects_codedFunctionObject_H
72 #define functionObjects_codedFunctionObject_H
73 
74 #include "functionObject.H"
75 #include "CodedBase.H"
76 
77 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
78 
79 namespace Foam
80 {
81 
82 /*---------------------------------------------------------------------------*\
83  Class codedFunctionObject Declaration
84 \*---------------------------------------------------------------------------*/
85 
86 class codedFunctionObject
87 :
88  public functionObject,
89  public CodedBase<functionObject>
90 {
91  // Private Data
92 
93  //- Reference to the time database
94  const Time& time_;
95 
96  //- The dynamically generated functionObject pointer
97  mutable autoPtr<functionObject> redirectFunctionObjectPtr_;
98 
99 
100  // Private Member Functions
101 
102  //- Adapt the context for the current object
103  virtual void prepare(dynamicCode&, const dynamicCodeContext&) const;
104 
105  //- Clear any redirected objects
106  virtual void clearRedirect() const;
107 
108  //- Compile, link and return the now coded functionObject
109  functionObject& redirectFunctionObject() const;
110 
111 
112 public:
113 
114  //- Runtime type information
115  TypeName("coded");
116 
117 
118  // Constructors
119 
120  //- Construct from Time and dictionary
122  (
123  const word& name,
124  const Time& time,
125  const dictionary& dict
126  );
127 
128  //- Disallow default bitwise copy construction
129  codedFunctionObject(const codedFunctionObject&) = delete;
130 
131 
132  //- Destructor
133  virtual ~codedFunctionObject();
134 
135 
136  // Member Functions
137 
138  //- Called at each ++ or += of the time-loop.
139  // postProcess overrides the usual executeControl behaviour and
140  // forces execution (used in post-processing mode)
141  virtual bool execute();
142 
143  //- Called at each ++ or += of the time-loop.
144  // postProcess overrides the usual writeControl behaviour and
145  // forces writing always (used in post-processing mode)
146  virtual bool write();
147 
148  //- Called when Time::run() determines that the time-loop exits.
149  // By default it simply calls execute().
150  virtual bool end();
151 
152  //- Read and set the function object if its data have changed
153  virtual bool read(const dictionary&);
154 
155 
156  // Member Operators
157 
158  //- Disallow default bitwise assignment
159  void operator=(const codedFunctionObject&) = delete;
160 };
161 
162 
163 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
164 
165 } // End namespace Foam
166 
167 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
168 
169 #endif
170 
171 // ************************************************************************* //
dictionary dict
virtual bool read(const dictionary &)
Read and set the function object if its data have changed.
const word & name() const
Return the name of this functionObject.
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:158
codedFunctionObject(const word &name, const Time &time, const dictionary &dict)
Construct from Time and dictionary.
void operator=(const codedFunctionObject &)=delete
Disallow default bitwise assignment.
Class to control time during OpenFOAM simulations that is also the top-level objectRegistry.
Definition: Time.H:68
Provides a general interface to enable dynamic code compilation.
A class for handling words, derived from string.
Definition: word.H:59
virtual bool end()
Called when Time::run() determines that the time-loop exits.
functionObject(const word &name)
Construct from components.
virtual ~codedFunctionObject()
Destructor.
TypeName("coded")
Runtime type information.
virtual bool execute()
Called at each ++ or += of the time-loop.
virtual bool write()
Called at each ++ or += of the time-loop.
Namespace for OpenFOAM.