Geometries

The Geometries block defines one or more CAD/mesh components that the solver will use to build the computational scene (e.g., fuselage, blades, stores).
Each geometry can load an external surface file, assign patches for local boundary tagging, and apply an ordered list of transforms (scale, translate, rotate).
You can also instantiate additional copies of an existing geometry and apply new transforms to each instance.

---

Basic structure

Geometries
{
    <geometry_name>
    {
        is_external = <bool>          // true -> flow external to the body. false -> flow internal to the body
        is_instance = <bool>          // create by referencing another geometry
        target      = "<name>"        // required when is_instance = true
        filename    = "<path>"        // required when is_instance = false
        
        Patches     { ... }           // optional: local surface subset labels
        Transforms  { ... }           // optional: ordered transformations
    }

// more geometry blocks...
}

Evaluation order matters

Transforms are applied top-to-bottom as written.

Expressions are allowed

Angles, deltas, scales can reference Dictionary values (e.g., aoa, disp_ang).

---

Patches

Use Patches to assign human-readable names to surface subsets (by id/index ranges) for later use in boundary conditions, wall models, or refinement regions.

Patches
{
    <patch_name> = [<id0>, <id1>, ...]     // or ["0", "4"] depending on id format
}

• Patch ids come from the source file (e.g., cell set / region / part ids).
• A geometry can define multiple patches. Patch names must be unique within that geometry.

---

Transforms

Each entry inside Transforms is a named transform with a specifier and the parameters for that operation.
Supported specifier values:

• "scale" — uniform or anisotropic scaling
• "translate" — shift by a vector
• "rotate" — rotation by angle (degrees) around an axis through a point

Scale

<name>
{
    specifier = "scale"
    scales    = [sx, sy, sz]     // numbers or expressions
}

Translate

<name>
{
    specifier = "translate"
    delta     = [dx, dy, dz]
}

Rotate

<name>
{
    specifier = "rotate"
    point     = [x0, y0, z0]     // pivot point
    axis      = [ax, ay, az]     // rotation axis (will be normalized)
    angle     = <deg|expression> // degrees; expressions allowed (e.g., "-1*aoa")
}

Transformation composition

You can chain many transforms to compose complex placements. Because order matters, consider grouping scale → rotate(s) → translate(s) for predictability.

---

Instances (cloning existing geometry)

To create repeated components (e.g., a rotor with multiple blades) without reloading the file, define an instance:

<new_geometry_name>
{
    is_instance = true
    target      = "<existing_geometry_name>"
    Transforms  { ... }     // additional transforms applied to this instance
}

• The instance inherits the target’s loaded mesh and patches.
• Only the instance’s own Transforms are applied on top of the target’s result.
• This is ideal for repeated patterns (e.g., four blades at 90° increments).

---

Full example

The following example assembles a fuselage and a 4-blade rotor by transforming a single blade geometry and then instantiating it three times with additional rotations:

Geometries
{
    fuselage
    {
        is_external = true
        filename    = "fuselage.vtk"
        Patches
        {
            nose = [0]
        }
    }
    
    blade
    {
        is_external = true
        filename    = "blade.vtk"
        Transforms
        {
            stretch
            {
                specifier = "scale"
                scales    = [0.5, 1.0, 1.0]
            }
            push
            {
                specifier = "translate"
                delta     = [0.2, 0, 0]
            }
            aoa
            {
                specifier = "rotate"
                point     = [0, 0, 0]
                axis      = [1, 0, 0]
                angle     = "-1*aoa"               // uses Dictionary value
            }
            up
            {
                specifier = "translate"
                delta     = [0, 0, 0.5]
            }
            out
            {
                specifier = "rotate"
                point     = [0, 0, 0]
                axis      = [0, 0, 1]
                angle     = 90
            }
            back
            {
                specifier = "translate"
                delta     = [0.7, 0, 0]
            }
            down
            {
                specifier = "translate"
                delta     = [0, 0, -0.1]
            }
            out2
            {
                specifier = "rotate"
                point     = [0.7, 0, 0]
                axis      = [0, 0, 1]
                angle     = disp_ang            // expression from Dictionary
            }
        }
    }
    
    blade2
    {
        is_instance = true
        target      = "blade"
        Transforms
        {
            out
            {
                specifier = "rotate"
                point     = [0.7, 0, 0]
                axis      = [0, 0, 1]
                angle     = 90
            }
        }
    }
    
    blade3
    {
        is_instance = true
        target      = "blade2"
        Transforms
        {
            out
            {
                specifier = "rotate"
                point     = [0.7, 0, 0]
                axis      = [0, 0, 1]
                angle     = 90
            }
        }
    }
    
    blade4
    {
        is_instance = true
        target      = "blade3"
        Transforms
        {
            out
            {
                specifier = "rotate"
                point     = [0.7, 0, 0]
                axis      = [0, 0, 1]
                angle     = 90
            }
        }
    }
}

---

Best practices

• Centralize parameters (e.g., aoa, disp_ang, scale factors) in Dictionary and reference them in transforms.
• Be explicit with units in your team conventions (e.g., millimetres vs metres) and apply a normalizing scale transform at load.
• Order transforms deliberately; a rotate-then-translate produces a different result than translate-then-rotate.
• Name transforms descriptively (up, back, out2) to make placement readable in reviews and diffs.
• Reuse with instances to save memory and keep repeated components consistent.

Common pitfalls

• Wrong axis or point for rotation: verify the pivot (point) is in the same coordinate frame as the loaded geometry.
• Unexpected scaling: anisotropic scales [sx, sy, sz] can skew geometry—use uniformly unless intentional.
• Patch id mismatches: confirm patch indices match those exported in the filename source.
• Expression resolution: if using variables (e.g., aoa), ensure they are defined in Dictionary or via CLI substitutions.