[simpomann]

Hi,

I create 2 cyclic patches using createPatch. Unluckily the patchField ability does not work as intended.
The workflow:


1)
Create 2 patches with snappyHexMesh baffle functionality:

    vent_in_fs_0
        {
        level (3 6);
        faceZone vent_in_fs_0;

        // Create baffles for all faces on the surface
        faceType baffle;
        
        patchInfo
         {
            type patch;
 
             }

        }

--> patch vent_in_fs_0 and vent_in_fs_0_slave are created


2)
Convert the 2 baffle faces to cyclics using createPatch:

    {
        // Name of new patch
        name vent_in_fs_0_cyclic;

        // Dictionary to construct new patch from
        patchInfo
        {
           type cyclic;
       neighbourPatch vent_in_fs_0_slave_cyclic;

                patchFields
                {
                    p
                    {
                    type            fan;
                    patchType       cyclic;
                    jump            uniform 0;
                    value           uniform 0;
                    jumpTable       polynomial 1((100000000 0));
                    }
                }
        }

        // How to construct: either from 'patches' or 'set'
        constructFrom patches;

        // If constructFrom = patches : names of patches. Wildcards allowed.
        patches (vent_in_fs_0);
    }

    {
        // Name of new patch
        name vent_in_fs_0_slave_cyclic;

        // Dictionary to construct new patch from
        patchInfo
        {
            type cyclic;
            neighbourPatch vent_in_fs_0_cyclic;

                patchFields
                {
                    p
                    {
            type            fan;
            patchType       cyclic;
            value           uniform 0;

                    }
                }
        }

The two cyclic patches are created, unluckily the patchFields part is skipped! Snippet from patchSummary:

cyclic    : vent_in_fs_0_cyclic
    scalar        nut        cyclic
    scalar        k        cyclic
    scalar        p        cyclic
    scalar        omega        cyclic
    vector        U        cyclic

cyclic    : vent_in_fs_0_slave_cyclic
    scalar        nut        cyclic
    scalar        k        cyclic
    scalar        p        cyclic
    scalar        omega        cyclic
    vector        U        cyclic

The boundary type for field variable p should be set from "cyclic" to "fan".

Snippet from constant/boundary:

    vent_in_fs_0_cyclic
    {
        type            cyclic;
        inGroups        1(cyclic);
        nFaces          56;
        startFace       5644731;
        matchTolerance  0.0001;
        transform       unknown;
        neighbourPatch  vent_in_fs_0_slave_cyclic;
    }
    vent_in_fs_0_slave_cyclic
    {
        type            cyclic;
        inGroups        1(cyclic);
        nFaces          56;
        startFace       5644787;
        matchTolerance  0.0001;
        transform       unknown;
        neighbourPatch  vent_in_fs_0_cyclic;
    }

I reviewed the patches in paraFoam, they are of correct shape and surfaces are correctly (=opposingly) orientated.
Why is "patchFields" not performed?
I compared it to the TJunctionFan Tutorial, where patchSummary looks like this:

cyclic    : cyclicFaces_master
    scalar        nut        cyclic
    scalar        k        cyclic
    scalar        nuTilda        cyclic
    scalar        p        fan
    scalar        epsilon        cyclic
    vector        U        cyclic

cyclic    : cyclicFaces_slave
    scalar        nut        cyclic
    scalar        k        cyclic
    scalar        nuTilda        cyclic
    scalar        p        fan
    scalar        epsilon        cyclic
    vector        U        cyclic

I know that the tutorial makes use of createBaffles instead of createPatch, so I switched over to createBaffles but I am stuck with the same behaviour: Patches are generated correctly but patchFields does not work as intended. I also generated a pair of cyclics in the exact same way as in the tutorial, but "patchFields" fails to update them here as well.
Note: In this case my cyclic patches are derived directly from the geometry via searchableSurface/STL (and the baffle creation in snappyHexMesh is commented out, so there is no name conflict etc.).

baffles
{
  cyclicFaces
    {
        //- Select faces and orientation through a searchableSurface
        type        searchableSurface;
        surface     searchablePlate;
        origin      (10 -3 2);
        span        (0 1 1);

        patchPairs
        {
            type            cyclic;

            //- Optional override of added patchfields. If not specified
            //  any added patchfields are of type calculated.
            patchFields
            {
                p
                {
                    type            fan;
                    patchType       cyclic;
                    jump            uniform 0;
                    value           uniform 0;
                    jumpTable       polynomial 1((100000000 0));
                }
            }
        }
    }

    cyclicFaces1
    {
        //- Use surface to select faces and orientation.
        type        searchableSurface;
        surface     triSurfaceMesh;
        name        vent_in_fs_0.obj;
        //- Optional flip
 //       flip        true;

        // Generate patches explicitly
        patches
        {
            master
            {
                //- Master side patch

                name            vent_in_fs_0;
         type            cyclic;

                neighbourPatch  vent_in_fs_0_slave;

                patchFields
                {
                    type            fan;
                    patchType       cyclic;
                    jump            uniform 0;
                    value           uniform 0;
                    jumpTable       polynomial 1((1000000000 0));
                }
            }
            slave
            {
                //- Slave side patch

                name            vent_in_fs_0_slave;
         type            cyclic;

                neighbourPatch  vent_in_fs_0;

                patchFields
                {
            type            fan;
            patchType       cyclic;
            value           uniform 0;

                }
            }
        }
    }
}

The tutorial on the other hand works fine, even when I remove the topoSet and baffle (not cyclic) faces the pair of cyclics is created sucessfully and the "patchField" entry updates the fields sucessfully..

My Allrun-Skript:

#!/bin/sh
cd ${0%/*} || exit 1    # run from this directory

# Source tutorial run functions
. $WM_PROJECT_DIR/bin/tools/RunFunctions

runApplication surfaceFeatureExtract

runApplication blockMesh

runApplication decomposePar
runParallel snappyHexMesh 20 -overwrite

runParallel createPatch 20 -overwrite

#- For non-parallel running
#cp -r 0.org 0 > /dev/null 2>&1

#- For parallel running
ls -d processor* | xargs -i rm -rf ./{}/0 $1
ls -d processor* | xargs -i cp -r 0.org ./{}/0 $1

runParallel patchSummary 20 -expand
runParallel potentialFoam 20 -noFunctionObjects -writep
runParallel $(getApplication) 20

runApplication reconstructParMesh -constant
runApplication reconstructPar 

# ----------------------------------------------------------------- end-of-file

I use openFoam 2.3.0, solver is SIMPLE and the case is processed parallel.
I tried to switch to serial processing and PIMPLE without sucess. In addition I changed from "fan" boundary to fixedJump and uniformJump - unluckily they are not updated neither.




Thanks in advance for every help!

[simpomann]

deleted for improved reading

[simpomann]

Update:

I resolved the problem and it was entirely my fault: The Allrun script was in wrong order! The xargs-line overwrote the decomposed patch fields.
Corrected:

#- For parallel running ls -d processor* | xargs -i rm -rf ./{}/0 $1 ls -d processor* | xargs -i cp -r 0.org ./{}/0 $1

runParallel createPatch 20 -overwrite

 /*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  2.3.0                                 |
|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    object      createBafflesDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

// Sample for creating baffles:
// - usually converting internal faces into two boundary faces
// - or converting boundary faces into a boundary face
//   (internalFacesOnly=false)(though should use really createPatch
//    to do this)
// - specification in one of two modes:
//      - patchPairs : create two patches of same type, same input
//      - patches    : create patches separately, full control over what
//                     to create on what side
//                     (this mode can also create duplicate (overlapping)
//                      sets of baffles:
//                      - internalFacesOnly = false
//                      - have 4 entries in patches:
//                          - master
//                          - slave
//                          - additional master
//                          - additional slave)


// Whether to convert internal faces only (so leave boundary faces intact).
// This is only relevant if your face selection type can pick up boundary
// faces.
internalFacesOnly true;

// Optionally do not read/convert/write any fields.
//noFields true;


// Baffles to create.
baffles
{   vent_in_fs_0
    {
        //- Select faces and orientation through a searchableSurface
        type        searchableSurface;
        surface     triSurfaceMesh;
        name        vent_in_fs_0.obj;

        //- Optional flip
        flip        true;

        patchPairs
        {
            type            cyclic;

            //- Optional override of added patchfields. If not specified
            //  any added patchfields are of type calculated.
            patchFields
            {
                p
                {
                    type            fan;
                    patchType       cyclic;
                    jump            uniform 0;
                    value           uniform 0;
                    jumpTable       polynomial 5((171.52 0) (-10.09 1) (-1.71 2) (-0.48 3) (0.03 4));
                }
            }
        }

....

Now I am succesfully creating fan cyclics with the createBaffle utility

Thread can be closed or deleted.

Greetings!
Simon