[esujby]

Hello Bruno,

error still persist. i have run the mesh on of24x and followed your procedure. please have a look at the attached log file.


https://www.dropbox.com/s/qpmypl0qfk...exMesh.gz?dl=0


thanks

nas

[wyldckat]

Hi Nasir,

I've finally managed to take a look at the latest log file. Unfortunately I completely forgot that when we are running in parallel, we need to use "Pout" instead of "Info"
What happened is that in the log file you got, it only showed the output for the master process and it did not show the output for the slave process that crashed, which means that this way I can't see what really happened

Please follow these steps to update the source code and respective build:

foam
git pull wyldckat MultiOLoops
wmake libso src/dynamicMesh

Then run the mesh generation steps the same you did before, along with the command for sending the output to the log file, as indicated in post #18.

Best regards,
Bruno

[esujby]

Hello Bruno,

i have updated your source code and heres the output of the log file.

https://www.dropbox.com/s/qpmypl0qfk...exMesh.gz?dl=0

Also, i don't understand what you mean by pout and info, am i meant to modify

mpirun -np 16 snappyHexMesh -overwrite -parallel > log.snappyHexMesh 2>&1
kind regards

nas

[me3840]

Guess what guys! Now I have a case that has this same error!

Later this week I can download the code and try it out..

[wyldckat]

Hi Nasir and me3840,

Originally Posted by esujby

i have updated your source code and heres the output of the log file.

I'm looking into this right now (holiday today here in Portugal).

Originally Posted by esujby

Also, i don't understand what you mean by pout and info,

In the modified code I provided for OpenFOAM 2.4.x, I first used this code:

            Info
                << "cellI: " << cellI
                << "\tcEdges: " << cEdges << nl
                << "\tfaceRegion: " << faceRegion << endl;

Which outputs something like this:

    faceRegion: 
0
(
)
cellI: 23286    cEdges: 
12
(
651273
651275
651276
2077722
2077724
914463
541238
541242
541243
2088025
2088026
893919
)

The problem with this is that when you run in parallel, this is only showing the output for the master process.
When I changed the code to this:

            Pout
                << "cellI: " << cellI
                << "\tcEdges: " << cEdges << nl
                << "\tfaceRegion: " << faceRegion << endl;

We now get something like this:

[3] cellI: 524837    cEdges: 
[3] 12
[3] (
[3] 268946
[3] 262171
[3] 262172
[3] 262173
[3] 265001
[3] 265002
[3] 267699
[3] 267700
[3] 284912
[3] 284913
[3] 287602
[3] 284915
[3] )
[3] 
[3]     faceRegion: 
[3] 2
[3] (
[3] 1897870 0
[3] 1898007 0
[3] )
[1] cellI: 529679    cEdges: 
[1] 12
[1] (
[1] 1812109
[1] 1373846
[1] 1373848
[1] 1373850
[1] 1803296
[1] 1803298
[1] 1814983
[1] 1453931
[1] 1453932
[1] 1453937
[1] 1453938
[1] 1470710
[1] )
[1] 
[1]     faceRegion: 
[1] 0
[1] (
[1] )

In this example, we have the output from 2 different slave processes (#1 and #3), not just the master process (#0).

Originally Posted by me3840

Guess what guys! Now I have a case that has this same error!

How many cells does your mesh need before crashing? If it's lesser than 4-5 million cells, I can test with your case.

Best regards,
Bruno

[wyldckat]

I'm doing a separate post, since this is going to be a big long.

I've diagnosed part of the problem. In Nasir's latest log, there were 4 processes out of 16 that crashed with similar errors, not just one, therefore there are at least 4 sections of the mesh that share a common problem.

If we look at the output for process #15:

[15] cellI: 268506    cEdges: 
[15] 12
[15] (
[15] 1323428
[15] 1323429
[15] 1913565
[15] 1907422
[15] 275562
[15] 275563
[15] 275564
[15] 275568
[15] 275569
[15] 1323637
[15] 275573
[15] 275574
[15] )
[15] 
[15]     faceRegion: 
[15] 6
[15] (
[15] 1500378 0
[15] 1500379 0
[15] 1500389 0
[15] 1500133 0
[15] 1500134 0
[15] 1500135 0
[15] )
[15] bigFace: 
[15] 6
[15] (
[15] 4(682636 416857 86432 86433)
[15] 4(679566 86435 416930 682579)
[15] 4(679566 682579 682636 86433)
[15] 4(416930 86435 86432 416857)
[15] 4(416930 416857 682636 682579)
[15] 4(679566 86433 86432 86435)
[15] )
[15] 
[15]     bigFace.edgeLoops(): 0()
[15]     regionToFaces: 
[15] 1
[15] (
[15] 0 6(1500378 1500379 1500389 1500133 1500134 1500135)
[15] )
[15] 
[15] 
[15] 
[15] --> FOAM FATAL ERROR: 
[15] Multiple outside loops:0()
[15] 
[15]     From function combineFaces::getOutsideFace(const indirectPrimitivePatch&)
[15]     in file polyTopoChange/polyTopoChange/combineFaces.C at line 435.

The "bigFace" list shows us the list of 6 faces and the point indexes that each face uses to define itself:

[15] bigFace: 
[15] 6
[15] (
[15] 4(682636 416857 86432 86433)
[15] 4(679566 86435 416930 682579)
[15] 4(679566 682579 682636 86433)
[15] 4(416930 86435 86432 416857)
[15] 4(416930 416857 682636 682579)
[15] 4(679566 86433 86432 86435)
[15] )

The "bigFace" is meant to describe a group of faces for a single cell that are associated to a particular STL solid.
But in this case, all points of the list "bigFace" are repeated 3 times, which means that all 6 faces are associated to the same STL solid, which means that the cell is fully closed by the same surface, resulting in that there is no outside edge. In other words, the cell is like a sphere with a single face and no edges.

Now, the problem is to decide what snappyHexMesh should do in such a scenario...
The problem seems to be in the method "combineFaces::faceNeighboursValid", which is possibly incorrectly assessing that the face neighbours are valid... I'll update this post when I can figure it out or have any more news on this.


edit: Sorry, but I didn't manage to study this issue better the rest of the day. I've added this to my to-do list, which I will possibly only be able to look into in the upcoming weekend

[esujby]

Hello Bruno,

Thanks for your reply. yes i believe you are right, the way snappyhexmesh handles the meshing process might not be well suited for this application.

however, i have tried a slightly different mesh design, by ramping up my base mesh grid refinement to something like this:

blocks
(
    hex (0 1 2 3 4 5 6 7) (200 150 200) simpleGrading (1 1 1)
);

and decreased the refinement levels in my snappyhexmeshdict to:

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  3.0.x                                 |
|   \\  /    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;
snap            false;
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
{
.
.
.


// Settings for the castellatedMesh generation.
castellatedMeshControls
{

    // Refinement parameters
    // ~~~~~~~~~~~~~~~~~~~~~

    // If local number of cells is >= maxLocalCells on any processor
    // switches from from refinement followed by balancing
    // (current method) to (weighted) balancing before refinement.
    maxLocalCells 20000000;

    // Overall cell limit (approximately). Refinement will stop immediately
    // upon reaching this number so a refinement level might not complete.
    // Note that this is the number of cells before removing the part which
    // is not 'visible' from the keepPoint. The final number of cells might
    // actually be a lot less.
    maxGlobalCells 160000000;

    // The surface refinement loop might spend lots of iterations
    // refining just a few cells. This setting will cause refinement
    // to stop if <= minimumRefine are selected for refinement. Note:
    // it will at least do one iteration (unless the number of cells
    // to refine is 0)
    minRefinementCells 0;

    // Number of buffer layers between different levels.
    // 1 means normal 2:1 refinement restriction, larger means slower
    // refinement.
    nCellsBetweenLevels 10;



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

    // Specifies a level for any cell intersected by its edges.
    // This is a featureEdgeMesh, read from constant/triSurface for now.
    features
    (
        {
            file "inlet.eMesh";
            level 1;
        }
        {
            file "outlet.eMesh";
            level 1;
        }
        {
            file "lens.eMesh";
            levels ((0.0003 0));
        }
        {
            file "insulator.eMesh";
            levels ((0.0003 0));
        }
        {
            file "s1.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s2.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s3.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s4.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s5.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s6.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s7.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s8.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s9.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s10.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s11.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s12.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s13.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s14.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
        {
            file "s15.eMesh";
            levels ((0.00001 1) (0.00002 0));
        }
    );



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

    // Specifies two levels for every surface. The first is the minimum level,
    // every cell intersecting a surface gets refined up to the minimum level.
    // The second level is the maximum level. Cells that 'see' multiple
    // intersections where the intersections make an
    // angle > resolveFeatureAngle get refined up to the maximum level.

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

            faceZone inlet;
            cellZone inlet;
            zoneInside true;
        }

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

            faceZone outlet;
            cellZone outlet;
            zoneInside true;
        }

        lens
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone lens;
            cellZone lens;
            zoneInside true;
        }

        insulator
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone insulator;
            cellZone insulator;
            zoneInside true;
        }

        s1
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s1;
            cellZone s1;
            zoneInside true;
        }

        s2
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s2;
            cellZone s2;
            zoneInside true;
        }

        s3
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s3;
            cellZone s3;
            zoneInside true;
        }

        s4
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s4;
            cellZone s4;
            zoneInside true;
        }

        s5
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s5;
            cellZone s5;
            zoneInside true;
        }

        s6
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s6;
            cellZone s6;
            zoneInside true;
        }

        s7
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s7;
            cellZone s7;
            zoneInside true;
        }

        s8
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s8;
            faceType boundary;   
            cellZone s8;
            zoneInside true;
        }

        s9
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s9;
            cellZone s9;
            zoneInside true;
        }

        s10
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s10;
            cellZone s10;
            zoneInside true;
        }

        s11
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s11;  
            cellZone s11;
            zoneInside true;
        }

        s12
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s12;
            faceType boundary;  
            cellZone s12;
            zoneInside true;
        }

        s13
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s13;
            faceType boundary;  
            cellZone s13;
            zoneInside true;
        }

        s14
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s14;
            faceType boundary;   
            cellZone s14;
            zoneInside true;
        }

        s15
        {
            // Surface-wise min and max refinement level
            level (0 3);

            faceZone s15;
            faceType boundary;  
            cellZone s15;
            zoneInside true;
        }
    }

    // Resolve sharp angles
    resolveFeatureAngle 180;


    // Region-wise refinement
    // ~~~~~~~~~~~~~~~~~~~~~~

    // Specifies refinement level for cells in relation to a surface. One of
    // three modes
    // - distance. 'levels' specifies per distance to the surface the
    //   wanted refinement level. The distances need to be specified in
    //   descending order.
    // - inside. 'levels' is only one entry and only the level is used. All
    //   cells inside the surface get refined up to the level. The surface
    //   needs to be closed for this to be possible.
    // - outside. Same but cells outside.

    refinementRegions
    {
        inlet
        {
            mode inside;
            levels ((1E15 9));
        }
        outlet
        {
            mode inside;
            levels ((1E15 9));
        }
        lens
        {
            mode distance;
            levels ((0.001 1) (0.002 0));
        }
        insulator
        {
            mode distance;
            levels ((0.001 1) (0.002 0));
        }
        s1
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }

        s2
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s3
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s4
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s5
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s6
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s7
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s8
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s9
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s10
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s11
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s12
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s13
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s14
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
        s15
        {
            mode distance;
            levels ((0.00001 1) (0.00002 0));
        }
    } 


    // 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.0723594 0.0944272 0.0745);


    // 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 5; //was 3

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

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

    //- Maximum number of snapping relaxation iterations. Should stop
    //  before upon reaching a correct mesh.
    nRelaxIter 5; //was 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; // was 10

// New settings from openfoam 2.2 onwards for SHMesh

implicitFeatureSnap false; // default is false - detects without doing surfaceFeatureExtract
explicitFeatureSnap true; // default is true
multiRegionFeatureSnap false; // deafault is false - detects features between multiple surfaces

}



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

    // Per final patch (so not geometry!) the layer information
    layers
    {
	s1
         	{nSurfaceLayers 1;} // was 3
	s2 
		{nSurfaceLayers 1;} // was 3
	s3
		{nSurfaceLayers 1;} // was 3
	s4
         	{nSurfaceLayers 1;} // was 3
	s5 
		{nSurfaceLayers 1;} // was 3
	s6
		{nSurfaceLayers 1;} // was 3
	s7
         	{nSurfaceLayers 1;} // was 3
	s8 
		{nSurfaceLayers 1;} // was 3
	s9
		{nSurfaceLayers 1;} // was 3
	s10
         	{nSurfaceLayers 1;} // was 3
	s11 
		{nSurfaceLayers 1;} // was 3
	s12
		{nSurfaceLayers 1;} // was 3
	s13
         	{nSurfaceLayers 1;} // was 3
	s14 
		{nSurfaceLayers 1;} // was 3
	s15
		{nSurfaceLayers 1;} // was 3
    }

    // Expansion factor for layer mesh
    expansionRatio 1; //was 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.
    // See relativeSizes parameter.
    finalLayerThickness 0.000025; //was 0

    // 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.000015; //was 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
    // are perpendicular
    featureAngle 180;

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

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

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

    // Smooth layer thickness over surface patches
    nSmoothThickness 5; //was 2

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

    // Reduce layer growth where ratio thickness to medial
    // distance is large
    maxThicknessToMedialRatio 0.03; //was 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
{
    maxNonOrtho 180; //was 95
    maxBoundarySkewness 1; //was 20
    maxInternalSkewness  1; //was 4
    maxConcave 180; //was 80
    minFlatness 0.5; //was 0.5
    minVol 1e-15; //was 1e-15
    minTetQuality 1e-15; // was 1e-15
    minArea -1;
    minTwist 0.002; //was 0.002
    minDeterminant 0.001; //was 0.001
    minFaceWeight 0.001; //was 0.001
    minVolRatio 0.0000000000000001; // was 0.01
    minTriangleTwist -1;

    // Advanced

    nSmoothScale 10; //was 4
    errorReduction 1; // was 0.75
}


// Advanced

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


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

and for the first time, i can now see my cell cones getting filled up. i think snappy hex mesh overly depends on the base mesh gird refinement level which defines the mesh density. therefore the cells created by the blockmeshdict has to have its i,j,k dimensions to be smaller than thickness of the smallest feature associated with surfaces and or geometries.

so now i need to figure out a way to increase my my base mesh grid level to something like :

blocks
(
    hex (0 1 2 3 4 5 6 7) (800 800 800) simpleGrading (1 1 1)
);

but for now all my ram keeps getting used up and crashing. i remember you did mention the problem of having too much cells. however, most of the cells are associated with the basemesh (and not the geometries of interest) the geometric tend to have about 4-6 millions cells whereas overall cells is about 19 million. i don't know whether my observations are correct or not but am going to keep working on it as well.

kind regards

Nas

[wyldckat]

Quick answers:

1. The base mesh (the one created with blockMesh) is what gives snappyHexMesh the ability to see the STL objects. If the mesh is too coarse, it will try to iterate and search for more details of the surfaces it find after a few refinement steps.
   • Imagine if you were blind-folded and only had a stick to touch the objects around you. Each edge of the base mesh is the line you follow with your stick, until you hit an object. Then you split the edges in two and you should now be able to hit a few more details. This is what is also referred to as "ray tracing".
2. The base mesh should have just enough edges to see most of the objects, without having to do too many refinement iterations. The refinement levels are mostly for improving the mesh, not always for seeing new details.
3. 800x800x800 = 512000000 cells = 512 Mcells
   Each 1 million cells requires around 1 GB of RAM.
   Therefore, you are asking for 512 GB of RAM.

[esujby]

Hello Bruno,

i have decided to give salome to openFoam option a trial and encountered a little problem, o am wondering if you can give me any advice on how to tackle the problem.

http://www.cfd-online.com/Forums/ope...tml#post577812

thanks

Nas

[wyldckat]

Greetings to all!

For future reference, on this topic:

Originally Posted by wyldckat

Please follow these steps to update the source code and respective build:

foam
git pull wyldckat MultiOLoops
wmake libso src/dynamicMesh

Then run the mesh generation steps the same you did before, along with the command for sending the output to the log file, as indicated in post #18.

I've had to give up pursuing this bug. I managed to get access to machines with 32GB and 96GB of RAM and I was not able to reproduce this error

Best regards,
Bruno

[esujby]

Hello Bruno,

we can definitely continue hunting down the bug once i am done with my work. i still have all my snappy hex cases.

kind regards

nas

[ruikeradity1]

Solved!
I thought this problem arises when featureEdges of two different objects coincide with each other

[edomalley1]

Originally Posted by wyldckat

Greetings to all!

For future reference, on this topic:

I've had to give up pursuing this bug. I managed to get access to machines with 32GB and 96GB of RAM and I was not able to reproduce this error

Best regards,
Bruno

I know this is an old topic, but it came up for me today with OpenFOAM6.


I tried many ways to solve the problem in the SHMDict file, but ultimately, just providing slightly reduced tolerance for the Deviation and Angle when crating my .stl file in SolidWorks fixed the problem.


Hope this helps someone else!

[JoshWilliams1996]

Old problem but hope my solution will provide an alternative for someone who has this problem in the future. I had the same error message and my

resolveFeatureAngle = 175;

When it should've been

resolveFeatureAngle = 30;