[Paxxtor]

Hello there,


I have a problem to refine the right edges of my system.
Since I can use symmetries, I only have to calculate 1/4 of the whole system. But my Problem is that I cannot refine the edges of the symmetry faces, only the other not necessary edges are refined with refine surfaces.



here is a screen of paraview:


https://imgur.com/a/B0rA7Kx




Here is my snappyhexmeshdict:

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



mergeAcrossPatches   true;   // default false


geometry
{
    Body.stl
    {
        type triSurfaceMesh;
    name body;
         
    }
    
    InletRight.stl
        {
        type triSurfaceMesh;
        name right;
        }
};


// Settings for the castellatedMesh generation.
castellatedMeshControls
{

   
    maxLocalCells 10000000;

   
    maxGlobalCells 200000000;

  
    minRefinementCells 0;

   
    maxLoadUnbalance 0.10;


    nCellsBetweenLevels 1;


    

    features
    (
     
    );


    
    refinementSurfaces
    {
        body
        {
            // Surface-wise min and max refinement level
            level (1 3);

            // Optional region-wise level specification

      
            }
            
        right
        {
            // Surface-wise min and max refinement level
            level (0 0);

            // Optional region-wise level specification

      
            }
            
          
            
         }
       
           
           

         

            
   
    resolveFeatureAngle 30;

    
    planarAngle 30;


    

    refinementRegions
    {
    
    
/*         body
         
        {
            mode inside;
            levels ((1.0 2));
        }
*/    
      

       

    }



   
    limitRegions
    {
    }


    
        locationsInMesh 
        
        (
        ((0 0.003123 0) body)
        ((0.00085 0.006486 0) right)
        
        );

       
        allowFreeStandingZoneFaces true;



       
/*
        locationsInMesh
        (
            ((-0.09 -0.039 -0.049)  bottomAir)  // cellZone 0
            ((-0.09 0.009 -0.049)   topAir)     // cellZone 1
            ((-0.09 0.001 -0.049)   leftSolid)  // cellZone 2
            ((0.02  0.001 -0.049)   rightSolid) // cellZone 3
            ((-0.001 -0.039 0.0015) heater)     // cellZone 4
        );
*/
        // Per synthesised faceZone name the faceType and type of baffles to
        // create
        faceZoneControls
        {
            bottomAir_to_heater
            {
                // Optional specification of patch type (default is wall). No
                // constraint types (cyclic, symmetry) etc. are allowed.
                patchInfo
                {
                    type patch;
                    inGroups (patchPatches);
                }
                faceType baffle;
            }
        }



   
}


snapControls
{
   
    nSmoothPatch 3;


  
    tolerance 2.0;

   
    nSolveIter 30;

   
    nRelaxIter 5;

   


    // Feature snapping

        // Number of feature edge snapping iterations.
        // Leave out altogether to disable.
        nFeatureSnapIter 3;//10

        // Detect (geometric only) features by sampling the surface
        // (default=false).
        implicitFeatureSnap false;//true

        // Use castellatedMeshControls::features (default = true)
        explicitFeatureSnap true; //false

        // Detect features between multiple surfaces
        // (only for explicitFeatureSnap, default = false)
        multiRegionFeatureSnap true;//false


        //- When to run face splitting (never at first iteration, always
        //  at last iteration). Is interval. Default -1 (disabled)
        //nFaceSplitInterval 5;


        // (wip) Optional for explicit feature snapping:
        //- Detect baffle edges. Default is true.
        //detectBaffles false;
        //- On any faces where points are on multiple regions (see
        //  multiRegionFeatureSnap) have the other points follow these points
        //  instead of having their own independent movement, i.e. have snapping
        
        releasePoints true;//false
       
}

// Settings for the layer addition.
addLayersControls
{
    // Are the thickness parameters below relative to the undistorted
    // size of the refined cell outside layer (true) or absolute sizes (false).
    relativeSizes true;

    // Layer thickness specification. This can be specified either through the
   


        // Expansion factor for layer mesh
        expansionRatio 1.0;

        // Wanted thickness of the layer furthest away from the wall.
        // If relativeSizes this is relative to undistorted size of cell
        // outside layer.
        finalLayerThickness 0.3;


   
    minThickness 0.1;


    layers
    {
        body
        {
            nSurfaceLayers 1;

        }
 
     maxY
        {
            nSurfaceLayers 1;
            // Per patch layer data
            expansionRatio      1.3;
            finalLayerThickness 0.3;
            minThickness        0.1;
        }

        // Disable any mesh shrinking and layer addition on any point of
        // a patch by setting nSurfaceLayers to 0
        frozenPatches
        {
            nSurfaceLayers 0;
        }
    
    
    
        right
        {
            nSurfaceLayers 1;

        }
 
     maxY
        {
            nSurfaceLayers 1;
            // Per patch layer data
            expansionRatio      1.3;
            finalLayerThickness 0.3;
            minThickness        0.1;
        }

        // Disable any mesh shrinking and layer addition on any point of
        // a patch by setting nSurfaceLayers to 0
        frozenPatches
        {
            nSurfaceLayers 0;
        }
    }

    // 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 1.7.x! (didn't do anything in 1.7.x)
    nGrow 0;

    // Advanced settings


    // Static analysis of starting mesh

        // When not to extrude surface. 0 is flat surface, 90 is when two faces
        // are perpendicular. Note: was not working correctly < 1806
        featureAngle 120;

        // When to merge patch faces. Default is featureAngle. Useful when
        // featureAngle is large.
        mergePatchFacesAngle 45; //normally off

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


    // Patch displacement

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

        // Smooth layer thickness over surface patches
        nSmoothThickness 10;



    

    
        minMedialAxisAngle 90;

      
        maxThicknessToMedialRatio 0.3;

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

       
        slipFeatureAngle 30;

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


    // Mesh shrinking

        // Create buffer region for new layer terminations, i.e. gradually
        // step down number of layers. Set to <0 to terminate layer in one go.
        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;

        // Max number of iterations after which relaxed meshQuality controls
        // get used. Up to nRelaxedIter it uses the settings in
        // meshQualityControls,
        // after nRelaxedIter it uses the values in
        // meshQualityControls::relaxed.
        nRelaxedIter 20;

        // Additional reporting: if there are just a few faces where there
        // are mesh errors (after adding the layers) print their face centres.
        // This helps in tracking down problematic mesh areas.
        //additionalReporting true;
}

// Generic mesh quality settings. At any undoable phase these determine
// where to undo.
meshQualityControls
{
    // Specify mesh quality constraints in separate dictionary so can
    // be reused (e.g. checkMesh -meshQuality)
    #include "meshQualityDict"


    // Optional : some meshing phases allow usage of relaxed rules.
    // See e.g. addLayersControls::nRelaxedIter.
    relaxed
    {
        // Maximum non-orthogonality allowed. Set to 180 to disable.
        maxNonOrtho 75;
    }


    // Advanced

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


mergeTolerance 1e-6;

 //

I have removed some // comments, so it could be the case that some brackets are wrong now, but i hope that you can help me.