File size: 10,767 Bytes
5a600cf | 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 | /*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2026 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::functionEntries::codeStream
Description
Compiles and executes C++ OpenFOAM code string expressions
inserting the result into the dictionary or dictionary entry.
\c \#codeStream reads three entries: \c code, \c codeInclude (optional),
\c codeOptions (optional) to generate the library source code stored in the
local \c dynamicCode directory with a subdirectory name corresponding to the
SHA1 of the code. The code is then compiled into a dynamically loaded
library libcodeStream_<SHA1>.so stored in the
\c dynamicCode/platforms/$WM_OPTIONS/lib directory using 'wmake libso'.
The resulting library is loaded in executed with arguments
\code
(const dictionary& dict, Ostream& os)
\endcode
where the dictionary is the current dictionary. The code writes results to
the current entry via the \c Ostream \c os.
The verbatim string format \c \#{ ... \c \#} is used to allow multi-line
input without the need to escape the newlines.
Dictionary entries constructed with \c \#codeStream can conveniently access
and use typed variables. This means calculations involving vectors and
tensors and list etc. are possible. To access a variable and construct it
as a given type within a \c \#codeStream entry, put the type immediately
after the $ symbol inside angled brackets <>. So, $<vector>var or
$<vector>{var} substitutes a variable named var as a vector.
The variable values are looked-up at run-time making the code corresponding
to each \c \#codeStream independent of the values in the dictionary and of
each other. Hence the \c \#codeStream code does not need to be recompiled
when the values in the dictionary are changed, only if the code is changed.
Usage
Example to set the internal field of a field:
\verbatim
internalField #codeStream
{
code
#{
const IOdictionary& d = static_cast<const IOdictionary&>(dict);
const fvMesh& mesh = refCast<const fvMesh>(d.db());
scalarField fld(mesh.nCells(), 12.34);
writeEntry(os, "", fld);
#};
//- Optional:
codeInclude
#{
#include "volFields.H"
#};
//- Optional:
codeOptions
#{
-I$(LIB_SRC)/finiteVolume/lnInclude
#};
};
\endverbatim
Example to rotate a list of points around an axis by a given angle
\verbatim
points ((3 0 0) (2 1 1) (1 2 2) (0 3 3));
rotation
{
axis (0 1 1);
angle 45;
}
#codeStream
{
codeInclude
#{
#include "pointField.H"
#include "transform.H"
#};
code
#{
const pointField points($<List<point>>points);
const vector axis = $<vector>!rotation/axis;
const scalar angle = degToRad($!rotation/angle);
os << "pointsRotated" << nl
<< (Ra(axis, angle) & points)() << ";";
#};
};
\endverbatim
Example Compute the centre and trianglation of a polygon
\verbatim
polygon ((0 0 0) (1 0 0) (2 1 0) (0 2 0) (-1 1 0));
#codeStream
{
codeInclude
#{
#include "polygonTriangulate.H"
#};
code
#{
const List<point> polygon($<List<point>>polygon);
writeEntry(os, "polygonCentre", face::centre(polygon));
polygonTriangulate triEngine;
triEngine.triangulate(polygon);
os << "polygonTris" << ' ' << triEngine.triPoints() << ";";
#};
};
\endverbatim
Example to generate a single block blockMeshDict for use with snappyHexMesh
with no redundant information
\verbatim
min (-2.5 -1.2 -3.0); // Minimum coordinates of the block
max (2.5 1.2 3.0); // Maximum coordinates of the block
nCellsByL 33.3333; // Number of cells per unit length
// Calculate the number of cells in each block direction
nCells #calc
"Vector<label>($nCellsByL*($<vector>max - $<vector>min) + vector::one/2)";
// Generate the vertices using a boundBox
vertices #codeStream
{
codeInclude
#{
#include "boundBox.H"
#};
code
#{
os << boundBox($<vector>min, $<vector>max).points();
#};
};
blocks
(
hex (0 1 2 3 4 5 6 7) $nCells simpleGrading (1 1 1)
);
defaultPatch
{
type patch;
}
boundary
();
\endverbatim
See also
Foam::functionEntries::calcEntry
SourceFiles
codeStream.C
\*---------------------------------------------------------------------------*/
#ifndef codeStream_H
#define codeStream_H
#include "functionEntry.H"
#include "OTstream.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class dlLibraryTable;
namespace functionEntries
{
// Forward declaration of friend classes
class codeDict;
class streamEntry;
class calcEntry;
class codeBlockEntry;
class codeBlockStreamEntry;
/*---------------------------------------------------------------------------*\
Class codeStream Declaration
\*---------------------------------------------------------------------------*/
class codeStream
:
public functionEntry
{
//- Interpreter function type
typedef void (*streamingFunctionType)(Ostream&, const dictionary&);
// Private Member Functions
//- Helper function: parent (of parent etc.) of dictionary up to the top
static const dictionary& topDict(const dictionary&);
//- Return true for master only reading of global dictionary
static bool masterOnlyRead
(
const word& typeName,
const dictionary& dict
);
//- Return the code string
static string codeString
(
const word& typeName,
const word& templateFunctionName,
const label index,
const dictionary& codeDict,
Istream&
);
//- Return the code string
static string codeString
(
const label index,
const dictionary& codeDict,
Istream&
);
//- Construct, compile, load and return streaming function
static void* compile
(
const word& typeName,
const dictionary& contextDict,
const dictionary& codeDict,
const word& codeOptions,
const wordList& compileFiles,
word& codeName
);
//- Construct, compile, load and return streaming function
static streamingFunctionType getFunction
(
const dictionary& contextDict,
const dictionary& codeDict
);
//- Compile and execute the code and return the result in an OTstream
static OTstream resultStream
(
const dictionary& contextDict,
Istream& is
);
public:
// Static Data Members
//- Keywords associated with source code
static const wordList codeKeys;
//- Name of the dictionary variables in the source code
static const wordList codeDictVars;
//- Name of the code options file to be used
static const word codeOptions;
//- Name of the C code template to be used
static const wordList compileFiles;
// Related types
//- Declare friendship with the calcEntry class
friend class codeDict;
friend class streamEntry;
friend class calcEntry;
friend class codeBlockEntry;
friend class codeBlockStreamEntry;
//- Runtime type information
FunctionTypeName("#codeStream");
// Constructors
//- Construct from function type and parent dictionary
codeStream
(
const functionName&,
const label lineNumber,
const dictionary&
);
//- Construct from line number, dictionary and Istream
codeStream
(
const label lineNumber,
const dictionary& parentDict,
Istream& is
);
//- Copy construct
codeStream(const codeStream&) = default;
//- Clone
virtual autoPtr<entry> clone(const dictionary&) const
{
return autoPtr<entry>(new codeStream(*this));
}
// Member Functions
//- Expand the functionEntry into the contextDict
virtual bool execute(dictionary& contextDict, Istream&);
//- Expand the functionEntry into the contextEntry
static bool execute
(
const dictionary& contextDict,
primitiveEntry& contextEntry,
Istream&
);
// Member Operators
//- Disallow default bitwise assignment
void operator=(const codeStream&) = delete;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace functionEntries
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
|