openfoam/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D

oscillatingInletACMI2D

This tutorial case gives an example of the Arbitrarily Coupled Mesh Interface
(ACMI) usage.  The mesh is composed of two mesh regions: an inlet channel which
oscillates in the +/- Y-direction, and a fixed mesh region.

Each ACMI patch requires the specification of a 'non-overlapping' patch.  In
this example, the non-overlapping patches are described as walls, e.g. taken
from the constant/polyMesh/boundary file:

    1. First ACMI poatch pair applied to the inlet channel outlet

        ACMI1_blockage
        {
            type            wall;
            nFaces          40;
            startFace       43680;
        }
        ACMI1_couple
        {
            type            cyclicACMI;
            nFaces          40;
            startFace       43720;
            matchTolerance  0.0001;
            transform       noOrdering;
            neighbourPatch  ACMI2_couple;
            nonOverlapPatch ACMI1_blockage;
        }


    1. Second ACMI poatch pair applied to the fixed mesh region inlet

        ACMI2_blockage
        {
            type            wall;
            nFaces          96;
            startFace       43760;
        }
        ACMI2_couple
        {
            type            cyclicACMI;
            nFaces          96;
            startFace       43856;
            matchTolerance  0.0001;
            transform       noOrdering;
            neighbourPatch  ACMI1_couple;
            nonOverlapPatch ACMI2_blockage;
        }


In the above, the ACMI1_blockage and ACMI1_couple patches occupy the same space,
with duplicate points, edges and faces.  The ACMI2_blockage and ACMI2_couple
patches are created similarly.

The duplicate patches are initially created using the createBaffles utility.
Firstly, the original (non-duplicated) patch faces are collected into zones
using the topoSet utility.

Each ACMI/no-overlapping patch pair is specified using a master-slave approach.
However, since we are generating boundary patches (which are always master
patches) the slave patches are simply defined using 'dummy' entries, e.g.:

    type        faceZone;
    zoneName    couple1Faces;

    patches
    {
        // create blockage patch
        master
        {
            //- Master side patch
            name            ACMI1_blockage;
            type            wall;
        }
        slave1 // dummy entries only
        {
            //- Slave side patch
            name            ACMI1_blockage;
            type            wall;
        }

        // create cyclic ACMI patch
        master2
        {
            //- Master side patch
            name            ACMI1_couple;
            type            cyclicACMI;
            matchTolerance  0.0001;
            neighbourPatch  ACMI2_couple;
            nonOverlapPatch ACMI1_blockage;
            transform       noOrdering;
        }
        slave2 // dummy entries only
        {
            //- Slave side patch
            name            ACMI1_couple;
            type            patch;
        }
    }

Boundary conditions must then be applied to all geometric patches in the usual,
manner, and the cases can be executed in parallel (as shown when running the
Allrun-parallel script) without any speacial treatment, i.e. the case set-up is
the same as when operating in serial mode.