[aerogt3]

Having read this thread (and the links), I cannot figure out how to mesh two domains. In the image below you can see I have a cube shaped domain (orange), with a black duct. The duct has a wall thickness, so air can pass through the duct or around it. Inside the duct is a "radiator," which to use porousZones, must be a separate cell zone.I have inlet (green), outlet (blue), and walls (red) for this separate zone.


the duct and the domain (and the inlet/outlet) are written to flow.stl, and the radiator inlet/outlet and walls (red) are written to rad.stl. Then I use the following snappyhexmeshdict:

// Which of the steps to run
castellatedMesh true;
snap            true;
addLayers       false;

// Geometry. Definition of all surfaces. All surfaces are of class  // searchableSurface.       // Surfaces are used
// - to specify refinement for any mesh cell intersecting it        // - to specify refinement for any mesh cell inside/outside/near        // - to 'snap' the mesh boundary to the surface

geometry
  {
      flow.stl // STL filename
      {
          type triSurfaceMesh;
          name flow;
      }
      rad.stl
      {
          type triSurfaceMesh;
          name rad;
      }
    ref
    {
        type searchableBox;
        min (-1.2 -1 -1);
        max (1 0 1.2);
    }
};

// Settings for the castellatedMesh generation.
castellatedMeshControls
{
    maxLocalCells 10000000;
    maxGlobalCells 30000000;
    minRefinementCells 10;
    maxLoadUnbalance 0.10;
    nCellsBetweenLevels 6;
    // Specifies a level for any cell intersected by its edges. This is a featureEdgeMesh, read from constant/triSurface for now.
    features
    (
        {
           file "rad.eMesh";
           level 5;
        }
        {
           file "flow.eMesh";
           level 0;
        }
    );

    // Surface based refinement #####################################################
    refinementSurfaces
    {
        rad
        {
            // Surface-wise min and max refinement level
            level (5 5);
            faceZone rad;
            cellZone rad;
            cellZoneInside inside;
        }
        flow
        {
            // Surface-wise min and max refinement level
            level (0 0);
            faceZone flow;
            cellZone flow;
            cellZoneInside inside;
        }
    }

    // Resolve sharp angles
    resolveFeatureAngle 30;

    // Region-wise refinement       // Specifies refinement level for cells in relation to a surface. One of three modes

    refinementRegions
    {
        ref
        {
            mode inside;
            levels ((1E15 5));
        }
    }

    // Mesh selection
    // After refinement patches get added for all refinementSurfaces and  all cells intersecting the surfaces get put into these patches. The section reachable from the locationInMesh is kept.
    // NOTE: This point should never be on a face, always inside a cell, even after refinement.
    locationInMesh (-2 -3 3);

    // Whether any faceZones (as specified in the refinementSurfaces) are only on the boundary of corresponding cellZones or also allow free-standing zone faces. Not used if there are no faceZones.
    allowFreeStandingZoneFaces true;
}

The results is complete garbage! (see third image) Any ideas how to get a proper results? Where it says "faceZone flow;" - I have also tried "faceZone INLET", etc. with no luck either.

[wyldckat]

Greetings Robert,

I've moved your post from the other thread http://www.cfd-online.com/Forums/ope...e-regions.html, because this is a topic that deserves its own thread! Tobi is trying to meld several regions into a single one, while you are trying to generate a multi-region mesh with porous regions, which is a whole other problem

A few suggestions, ideas and questions:

1. The first suggestion is to first simplify a bit the problem at hand, before doing it all in a single go, namely: your geometry is not aligned with the base mesh. That can lead to serious meshing problems, some of which are shown on the third image you provided. So first start working on a test case with the geometry aligned with the base mesh.
2. Are you going to need to use multi-regions or just a single region with a porous zone inside it?
3. I ask this because if you only need the radiator to be a porous zone, while the rest of the mesh is just one domain, then you only need to assign a single cell zone to said radiator!
4. Once you've managed to get the hang of how things work with the aligned mesh, give a try to SwiftBlock: http://openfoamwiki.net/index.php/Contrib/SwiftBlock - it can help you create a base mesh that is properly aligned on that zone where you have the pipe and radiator, while having the rest of the mesh drawn with your current orientation!

Best regards,
Bruno

[aerogt3]

Originally Posted by wyldckat

Greetings Robert,

I've moved your post from the other thread http://www.cfd-online.com/Forums/ope...e-regions.html, because this is a topic that deserves its own thread! Tobi is trying to meld several regions into a single one, while you are trying to generate a multi-region mesh with porous regions, which is a whole other problem

A few suggestions, ideas and questions:

1. The first suggestion is to first simplify a bit the problem at hand, before doing it all in a single go, namely: your geometry is not aligned with the base mesh. That can lead to serious meshing problems, some of which are shown on the third image you provided. So first start working on a test case with the geometry aligned with the base mesh.
2. Are you going to need to use multi-regions or just a single region with a porous zone inside it?
3. I ask this because if you only need the radiator to be a porous zone, while the rest of the mesh is just one domain, then you only need to assign a single cell zone to said radiator!
4. Once you've managed to get the hang of how things work with the aligned mesh, give a try to SwiftBlock: http://openfoamwiki.net/index.php/Contrib/SwiftBlock - it can help you create a base mesh that is properly aligned on that zone where you have the pipe and radiator, while having the rest of the mesh drawn with your current orientation!

Best regards,
Bruno

Fair enough on the thread move.

1.) The problem is already a simplification! The real problem is [going to be] a full vehicle, where a duct within the bodywork carries air to and from a porous zone. I know a non-aligned mesh is bad for the solution, but I am not going to solve this - I'm just testing the meshing strategy.
2-3.) In the end I want a fluid zone that encloses the actual radiator (where I will apply porous zones), and another region which does both upstream and downstream to connect with thee external flow domain around the vehicle. So two cellZones total: external flow, and porous zone.

Basically, the only way I can mesh this correctly is for the mesh to stop at the inlets and outlets (and not mesh inside the radiator). What I am looking for is a way to tell snappyhexmesh that the inlet and outlet faces are just faceZones that I want included in the mesh, not walls where the mesh should end! Any ideas? I know I would just mesh the outside first, the inside separately, and then merge them - with a non conformal interface set on the shared inlet/outlet faces. But doing it in one step would be quicker and easier!

[wyldckat]

From what I saw now in the tutorial "incompressible/porousSimpleFoam/angledDuctExplicit", you do need the mesh to be generated the way that you've described, namely to have both cell zones: one for the radiator and another for the external air.
Having just the face zones won't be enough.

When snappyHexMesh handles cell zones, it has to mesh all sides of the surfaces, which can lead to some problems if mesh resolution and mesh orientation aren't well adjusted locally. It's not a solution issue, it's a meshing issue! This is why I was suggesting that you align the base mesh as much as possible with the radiator surfaces.

[wyldckat]

Hi Robert,

I've been playing around with snappyHexMesh since yesterday and the best I got is here: https://www.dropbox.com/s/m3mnh3js6x...tSnappy.tar.gz
... at least while doing things without the assistance of SwiftBlock and SwiftSnap.

It is based on the tutorial "incompressible/porousSimpleFoam/angledDuctImplicit", where I replaced using blockMesh+m4 with blockMesh+snappyHexMesh. The scripts Allrun and Allclean do all of the necessary steps for running and cleaning the case.

Best regards,
Bruno

[aerogt3]

Originally Posted by wyldckat

From what I saw now in the tutorial "incompressible/porousSimpleFoam/angledDuctExplicit", you do need the mesh to be generated the way that you've described, namely to have both cell zones: one for the radiator and another for the external air.
Having just the face zones won't be enough.

When snappyHexMesh handles cell zones, it has to mesh all sides of the surfaces, which can lead to some problems if mesh resolution and mesh orientation aren't well adjusted locally. It's not a solution issue, it's a meshing issue! This is why I was suggesting that you align the base mesh as much as possible with the radiator surfaces.

Well, I think I have made some progress, but not enough to fully solve the problem. Using blockMesh I generate a cellZone called "external" which is the flow around the geometry. The geometry is the duct itself, and has no faces for the radiator at all (see image 1). Then, I have a second file, rad.stl which is just the radiator - inlet/outlet faces, plus the side walls of the radiator. (shown in pic 2) Both geometries are open to the left side in the images because that is the symmetry plane. These two stl's are appropriately handled in snappyhexmeshdict.

When I run snappyhex, I get two cellZones, just as I hoped! However, I need a faceZone in between them (to measure mass flow rate), and this zone doesn't exist! In paraview I can see the radiator inlet/outlet patch, but it is empty! The third photo shows the resulting two-cellZone mesh read into paraview. You can see the radiator in the middle, but there is clearly non a conformal interface between the radiator cellzone and the external cellZone.

This means (if I understand correctly) that there should be a patch in between the two, but the patch that would define this surface (OUTLET_to_flow) is empty (0 faces)! I noticed the following statements in the log about this zone, which are curious.... I am attaching my files, so anyone interested can have a better look.... just run blockmesh and snappyhexmesh to reproduce the case.

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Create time

Create mesh for time = 0

Read mesh in = 0.08 s

Overall mesh bounding box  : (-20.48 -10.24 -1.024) (46.08 0 10.24)
Relative tolerance         : 1e-06
Absolute matching distance : 6.82786e-05

Reading refinement surfaces.
Read refinement surfaces in = 0 s

Reading refinement shells.
Refinement level 3 for all cells inside ref
Read refinement shells in = 0 s

Setting refinement level of surface to be consistent with shells.
Checked shell refinement in = 0 s

Reading features.
Refinement level 5 for all cells crossed by feature "box.eMesh" (50 points, 64 edges).
Detected 25 featurePoints out of 50 on feature box.eMesh
Read features in = 0 s


Determining initial surface intersections
-----------------------------------------

Edge intersection testing:
    Number of edges             : 25146
    Number of edges to retest   : 25146
    Number of intersected edges : 12
Calculated surface intersections in = 0.08 s

Initial mesh : cells:7865  faces:25146  points:9504
Cells per refinement level:
    0    7865

Adding patches for surface regions
----------------------------------

Patch    Type    Region
-----    ----    ------
box.stl:

6    wall    WALL_L_BOX

rad.stl:

7    wall    rad.stl_WALL_L_RAD
8    wall    OUTLET_to_flow

There has to be some way to add this STL region as a FACE and not a WALL, right?

Introducing zones for interfaces
--------------------------------

Surface : rad.stl
    faceZone : OUTLET_to_flow
    cellZone : zoneA
Found 1 closed, named surfaces. Assigning cells in/outside these surfaces to the corresponding cellZone.

Walking from location-in-mesh (-2 -3 3) to assign cellZones - crossing a faceZone face changes cellZone

Found point (-2 -3 3) in cell 18752 in global region 0 out of 4 regions.
CellZones:
    fluid_external    size:12977
    zoneA    size:88656

FaceZones:
    OUTLET_to_flow    size:5862

Edge intersection testing:
    Number of edges             : 326557
    Number of edges to retest   : 0
    Number of intersected edges : 13992

Morphing phase
--------------

Converting zoned faces into baffles ...
For surface rad.stl found faceZone OUTLET_to_flow and patch rad.stl_WALL_L_RAD
Edge intersection testing:
    Number of edges             : 330401
    Number of edges to retest   : 24318
    Number of intersected edges : 14982
Created 4306 baffles in = 0.61 s

[wyldckat]

Quick answer: I can't look into this any time soon, but my suggestion is that you search for information on how to use "topoSetDict", because I vaguely remember it's possible to make a selection of faces (a "faceSet") by using an STL file as a reference. Then you can convert that "faceSet" to a "faceZone" with topoSet or setSet.

[g7fernandes]

Hi,
I want to do something very similar to angledDuctImplicitSnappy, but with a circular pipe.
I used the files of wyldckat but I have a problem: the background mesh isn't being deleted (look the image). I created different .slt for the pipe and for the porous region. I divided the .stl of the whole pipe in inlet, outlet, porouswall and wall region. (files attached)




What I'm doing wrong? Could please someone help? Please please please

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

// Which of the steps to run
castellatedMesh true;    // make basic mesh ?
snap            true;    // decide to snap back to surface ?
addLayers       false;   // decide to add viscous layers ?


geometry // Load in STL files here
{
    pipein.stl
    {
        type triSurfaceMesh;
        name inlet;
    }
    pipeout.stl
    {
        type triSurfaceMesh;
        name outlet;
    }
    pipecy.stl    
    {
        type triSurfaceMesh;
        regions
        {
            wall
            {
                name wall;
            }
            porosityWall
            {
                name porosityWall;
            }
            inlet
            {
                name inlet;
            }
            outlet
            {
                name outlet;
            }
        }
    }
    porosity.stl        
    {
        type triSurfaceMesh;
        name porosity;
    }
//    refinementBox {type searchableBox; min (-0.3 -0.3 -0.3); max ( 0.3 0.3 0.3);}
};

castellatedMeshControls
{
    maxLocalCells 100000;  //max cells per CPU core
    maxGlobalCells 2000000; //max cells to use before mesh deletion step
    minRefinementCells 10;  //was 0 - zero means no bad cells are allowed during refinement stages
    maxLoadUnbalance 0.10;
    nCellsBetweenLevels 2;  // expansion factor between each high & low refinement zone

    // Explicit feature edge refinement
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    features // taken from STL from each .eMesh file created by "SurfaceFeatureExtract" command
    (
        {file "pipecy.eMesh"; level 0;} 
        {file "porosity.eMesh"; level 0;}  
        {file "pipein.eMesh"; level 0;} 
        {file "pipeout.eMesh"; level 0;}  
    );

    // Surface based refinement
    // ~~~~~~~~~~~~~~~~~~~~~~~~

    refinementSurfaces // Surface-wise min and max refinement level
     {
        inlet
        {
            // Surface-wise min and max refinement level
            level (2 2);

            faceZone inlet;
            cellZone inlet;
            cellZoneInside inside;
        }

        outlet
        {
            // Surface-wise min and max refinement level
            level (2 2);

            faceZone outlet;
            cellZone outlet;
            cellZoneInside inside;
        }

        porosity
        {
            // Surface-wise min and max refinement level
            level (2 2);

            faceZone porosity;
            cellZone porosity;
            cellZoneInside inside;
        }

        pipecy
        {
            // Surface-wise min and max refinement level
            level (2 2);
        }
    }    

    resolveFeatureAngle 30;  // Resolve sharp angles // Default 30
    refinementRegions
    {
//         refinementBox
//         {
//             mode inside;
//             levels ((1E15 4));
//         }

        inlet
        {
            mode inside;
            levels ((1E15 1));
        }
      
        outlet
        {
            mode inside;
            levels ((1E15 1));
        }
      
        porosity
        {
            mode inside;
            levels ((1E15 1));
        }
      
        angledDuct
        {
            mode inside;
            levels ((1E15 1));
        }
      
    }


    // Mesh selection
    // ~~~~~~~~~~~~~~

    // After refinement patches get added for all refinementSurfaces and
    // all cells intersecting the surfaces get put into these patches. The
    // section reachable from the locationInMesh is kept.
    // NOTE: This point should never be on a face, always inside a cell, even
    // after refinement.
    locationInMesh (0.001 0.001 0.001);


    // Whether any faceZones (as specified in the refinementSurfaces)
    // are only on the boundary of corresponding cellZones or also allow
    // free-standing zone faces. Not used if there are no faceZones.
    allowFreeStandingZoneFaces false;
}


// Settings for the snapping.
snapControls
{
    //- Number of patch smoothing iterations before finding correspondence
    //  to surface
    nSmoothPatch 2;

    //- Relative distance for points to be attracted by surface feature point
    //  or edge. True distance is this factor times local
    //  maximum edge length.
    tolerance 1.0;

    //- Number of mesh displacement relaxation iterations.
    nSolveIter 50;

    //- Maximum number of snapping relaxation iterations. Should stop
    //  before upon reaching a correct mesh.
    nRelaxIter 5;

    //- Highly experimental and wip: number of feature edge snapping
    //  iterations. Leave out altogether to disable.
    //  Of limited use in this case since faceZone faces not handled.
    nFeatureSnapIter 10;
}



// Settings for the layer addition.
addLayersControls
{
    relativeSizes true;

    // Per final patch (so not geometry!) the layer information
    layers
    {
        maxY
        {
            nSurfaceLayers 3;
        }
    }

    // Expansion factor for layer mesh
    expansionRatio 1.3;

    //- Wanted thickness of final added cell layer. If multiple layers
    //  is the
    //  thickness of the layer furthest away from the wall.
    //  Relative to undistorted size of cell outside layer.
    finalLayerThickness 1;

    //- Minimum thickness of cell layer. If for any reason layer
    //  cannot be above minThickness do not add layer.
    //  Relative to undistorted size of cell outside layer.
    minThickness 0.1;

    //- If points get not extruded do nGrow layers of connected faces that are
    //  also not grown. This helps convergence of the layer addition process
    //  close to features.
    // Note: changed(corrected) w.r.t 17x! (didn't do anything in 17x)
    nGrow 0;

    // Advanced settings

    //- When not to extrude surface. 0 is flat surface, 90 is when two faces
    //  make straight angle.
    featureAngle 30;

    //- Maximum number of snapping relaxation iterations. Should stop
    //  before upon reaching a correct mesh.
    nRelaxIter 3;

    // Number of smoothing iterations of surface normals
    nSmoothSurfaceNormals 1;

    // Number of smoothing iterations of interior mesh movement direction
    nSmoothNormals 3;

    // Smooth layer thickness over surface patches
    nSmoothThickness 2;

    // Stop layer growth on highly warped cells
    maxFaceThicknessRatio 0.5;

    // Reduce layer growth where ratio thickness to medial
    // distance is large
    maxThicknessToMedialRatio 1;

    // Angle used to pick up medial axis points
    // Note: changed(corrected) w.r.t 17x! 90 degrees corresponds to 130 in 17x.
    minMedianAxisAngle 90;

    // Create buffer region for new layer terminations
    nBufferCellsNoExtrude 0;

    // Overall max number of layer addition iterations. The mesher will exit
    // if it reaches this number of iterations; possibly with an illegal
    // mesh.
    nLayerIter 50;
}



// Generic mesh quality settings. At any undoable phase these determine
// where to undo.
meshQualityControls
{
    //- Maximum non-orthogonality allowed. Set to 180 to disable.
    maxNonOrtho 65;

    //- Max skewness allowed. Set to <0 to disable.
    maxBoundarySkewness 20;
    maxInternalSkewness 4;

    //- Max concaveness allowed. Is angle (in degrees) below which concavity
    //  is allowed. 0 is straight face, <0 would be convex face.
    //  Set to 180 to disable.
    maxConcave 75;

    //- Minimum pyramid volume. Is absolute volume of cell pyramid.
    //  Set to very negative number (e.g. -1E30) to disable.
    minVol 0;

    //- Minimum quality of the tet formed by the face-centre
    //  and variable base point minimum decomposition triangles and
    //  the cell centre.  Set to very negative number (e.g. -1E30) to
    //  disable.
    //     <0 = inside out tet,
    //      0 = flat tet
    //      1 = regular tet
    minTetQuality 1e-30;

    //- Minimum face area. Set to <0 to disable.
    minArea -1;

    //- Minimum face twist. Set to <-1 to disable. dot product of face normal
    //- and face centre triangles normal
    minTwist -1; //0.02;

    //- minimum normalised cell determinant
    //- 1 = hex, <= 0 = folded or flattened illegal cell
    minDeterminant 0.001;

    //- minFaceWeight (0 -> 0.5)
    minFaceWeight 0.02;

    //- minVolRatio (0 -> 1)
    minVolRatio 0.001;

    //must be >0 for Fluent compatibility
    minTriangleTwist -1;


    // Advanced

    //- Number of error distribution iterations
    nSmoothScale 4;
    //- amount to scale back displacement at error points
    errorReduction 0.75;
}

// Advanced

debug 0;


// Merge tolerance. Is fraction of overall bounding box of initial mesh.
// Note: the write tolerance needs to be higher than this.
mergeTolerance 1E-6;


// ************************************************************************* //

[Carno]

Check after loading the mesh for final time. It appears that the mesh is at 0 time, which will be block in your case.

[tmaffei]

Hello everyone,

I am facing a similar problem.

I have a mesh (msh file from ansys) constituted by several zones: fluid-gas, fluid-porous, fluid-outlet, solid-1, solid-2, etc ....
Using the following utilities I convert the mesh to openfoam format:

fluentMeshToFoam file.msh -writeZones -writeSets
setToZones -noFlipMap
splitMeshRegion -cellZones -overwrite

In this way, the original mesh is split into several regions, one for each zones. What I would like to obtain instead, they are only two regions (solid and fluid) each characterized by own multi cellZones.
For instance
-region fluid with cellZones fluid-gas, fluid-porous, fluid-outlet
-region solid with cellZones solid-1, etc ..

Could you kindly provide me any advice to solve this problem?

Thank you in advance for your availability

Tiziano