Files
OpenFOAM-12/etc/codeTemplates/dynamicCode/codeStreamTemplate.C
Will Bainbridge b2d4f25fff codeStream: Typed substitutions
Dictionary entries constructed with #calc and #codeStream can now
conveniently access and use typed variables. This means calculations
involving vectors and tensors and list and field types are now possible.

To access a variable and construct it as a given type within a #calc
or #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.

Examples:

- Reflect a point in a plane defined by a normal

    p       (1 2 3);
    n       (1 1 0);
    pStar   #calc "$<vector>p - (2*sqr($<vector>n)/magSqr($<vector>n)&$<vector>p)";

- Rotate a list of points around an axis by a given angle

    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)() << ";";
        #};
    };

- Compute the centre and trianglation of a polygon

   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() << ";";
       #};
    };

- Generate a single block blockMeshDict for use with snappyHexMesh with no redundant information

    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
    ();
2023-06-22 12:53:21 +01:00

74 lines
2.1 KiB
C++

/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) YEAR 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/>.
Description
Template for use with codeStream.
\*---------------------------------------------------------------------------*/
#include "dictionary.H"
#include "fieldTypes.H"
#include "Ostream.H"
#include "Pstream.H"
#include "read.H"
#include "unitConversion.H"
//{{{ begin codeInclude
${codeInclude}
//}}} end codeInclude
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Local Functions * * * * * * * * * * * * * * //
//{{{ begin localCode
${localCode}
//}}} end localCode
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
extern "C"
{
void ${typeName}
(
Ostream& os,
const dictionary& dict
)
{
//{{{ begin code
${code}
//}}} end code
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //