zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

codeStream: Typed substitutions

Browse Source 
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
    ();
This commit is contained in:
Will Bainbridge
2023-06-21 16:01:38 +01:00
parent 0927fd47fa
commit b2d4f25fff
7 changed files with 147 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
src/OpenFOAM/primitives/strings/stringOps/stringOps.C
View File

@ -410,6 +410,7 @@ Foam::string& Foam::stringOps::inplaceExpandCodeString
(
string& s,
const dictionary& dict,
const word& dictVar,
const char sigil
)
{
@ -427,16 +428,28 @@ Foam::string& Foam::stringOps::inplaceExpandCodeString
{
// Find end of first occurrence
string::size_type endVar = begVar;
string::size_type delim = 0;
string::size_type begDelim = 0, endDelim = 0;
if (s[begVar+1] == '{')
// Get the type, if any
word varType;
if (s[begVar+1] == '<')
{
endVar = s.find('}', begVar);
delim = 1;
begDelim += s.findClosing('>', begVar+1) - begVar;
varType = s.substr(begVar+2, begDelim-2);
}
// Parse any braces and find the end of the variable
if (s[begVar+begDelim+1] == '{')
{
endVar = s.find('}', begVar+begDelim);
begDelim += 1;
endDelim += 1;
}
else
{
string::iterator iter = s.begin() + begVar + 1;
endVar = begVar + begDelim;
string::iterator iter = s.begin() + begVar + begDelim + 1;
// Accept all dictionary and environment variable characters
while
@ -474,8 +487,8 @@ Foam::string& Foam::stringOps::inplaceExpandCodeString
(
s.substr
(
begVar + 1 + delim,
endVar - begVar - 2*delim
begVar + begDelim + 1,
(endVar - endDelim) - (begVar + begDelim)
),
false
);
@ -491,25 +504,54 @@ Foam::string& Foam::stringOps::inplaceExpandCodeString
// Substitute if found
if (ePtr)
{
// Write to string buffer. Force floating point numbers to
// be printed with at least some decimal digits.
OStringStream buf;
buf << scientific;
buf.precision(IOstream::defaultPrecision());
if (ePtr->isDict())
if (!dictVar.empty() && !varType.empty())
{
ePtr->dict().write(buf, false);
// If the dictionary is accessible and the type is
// known, then lookup the variable in the code, rather
// than substituting its value. That way we don't need
// to recompile this string if the value changes.
buf << dictVar
<< ".lookupScoped<" << varType << ">"
<< "(\"" << varName << "\", true, false)";
}
else if (isA<primitiveEntry>(*ePtr))
if (dictVar.empty() && !varType.empty())
{
dynamicCast<const primitiveEntry>(*ePtr)
.write(buf, true);
// If the dictionary is not accessible but the type is
// known, then read the substituted value from a string
buf << "read<" << varType << ">(\"";
}
else
if (dictVar.empty() || varType.empty())
{
// Can't do any other types. Fail.
dynamicCast<const primitiveEntry>(*ePtr);
// If the dictionary is not accessible and/or the type
// is not known, then we need to substitute the
// variable's value
// Make sure floating point values print with at least
// some decimal points
buf << scientific;
buf.precision(IOstream::defaultPrecision());
// Write the dictionary or primitive entry. Fail if
// anything else.
if (ePtr->isDict())
{
ePtr->dict().write(buf, false);
}
else
{
dynamicCast<const primitiveEntry>(*ePtr)
.write(buf, true);
}
}
if (dictVar.empty() && !varType.empty())
{
// Close the string and read function as necessary
buf << "\")";
}
s.std::string::replace