openfoam/tutorials/incompressible/pimpleFoam/RAS/oscillatingInletACMI2D/README

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 patch pair applied to the inlet channel outlet

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


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

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


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 either created within blockMesh or using the
createBaffles utility. Using the blockMesh path will result in a warning
message of the form

    'Trying to specify a boundary face '
    'already belongs to some other patch'

since there are now in total 7 faces defined for the hex shape and blockMesh
does not yet know whether the definition is incorrect.

Using the createBaffles utility is slightly more work.
Firstly, the original (non-duplicated) patch faces are collected into zones
using the topoSet utility.

Note: when specifying the ACMI patch-pairs, the coupled patch must be specified
before its associated non-overlapping patch.

Each ACMI/non-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 cyclic ACMI patch
        master
        {
            //- Master side patch
            name            ACMI1_couple;
            type            cyclicACMI;
            matchTolerance  0.0001;
            neighbourPatch  ACMI2_couple;
            nonOverlapPatch ACMI1_blockage;
            transform       noOrdering;
        }
        slave // dummy entries only
        {
            //- Slave side patch
            name            ACMI1_couple;
            type            patch;
        }
        // create blockage patch
        master2
        {
            //- Master side patch
            name            ACMI1_blockage;
            type            wall;
        }
        slave12 // dummy entries only
        {
            //- Slave side patch
            name            ACMI1_blockage;
            type            wall;
        }

    }

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.


checkMesh
---------
Older versions of checkMesh would see the 'duplicate' boundary faces before
the area factors were know so would complain:

     ***Boundary openness (-0.0103092 2.3845e-17 3.80774e-17) possible hole in boundary description.
     ***Open cells found, max cell openness: 0.333333, number of open cells 136
      <<Writing 136 non closed cells to set nonClosedCells

As long as these non-closed cells are on the ACMI they can be ignored.

In current checkMesh the area factors are updated before the check:

    AMI: Creating addressing and weights between 40 source faces and 96 target faces
    AMI: Patch source sum(weights) min:1 max:1 average:1
    AMI: Patch target sum(weights) min:0 max:1 average:0.4
    ACMI: Patch source uncovered/blended/covered = 0, 0, 40
    ACMI: Patch target uncovered/blended/covered = 56, 2, 38


pimpleFoam
----------
In the 'createBaffles' method the ACMI patches would be created after
the 'empty' patch. In the 'blockMesh' method however the 'empty' patch
will be last. This results in a slight difference in face ordering which
is enough to give a slightly different truncation error in the geometry
calculation and hence in the results. For all practical purposes however the
results are the same. For cases which do not have 'empty' patches (i.e. 2D)
this limitation does not apply.


paraFoam
--------
- display: it will not display the outside of the ACMI, there will be a hole.
- cuttingPlanes: they leave out the duplicate faces (i.e. the cells on
  the ACMI patches)
- interpolation: the interpolation does not take into account the
area-weights on the ACMI.


pointFields
-----------
Same as paraFoam: the interpolation does not take into account the
area-weights on the ACMI.