zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

STYLE: centralize example dictionaries under etc/ (issue #1074)

Browse Source 
- as well as being more convenient to find, this is necessary when the
  OpenFOAM installation is without sources or tutorials
This commit is contained in:
Mark Olesen
2019-01-26 17:46:08 +01:00
parent dd23155d81
commit 3b91160027
49 changed files with 7 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
applications/utilities/mesh/advanced/PDRMesh/PDRMeshDict
View File

@ -1,38 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object PDRMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
//- Per faceSet the patch the faces should go into blocked baffles
blockedFaces ((blockedFacesSet blockedFaces));
//- Per faceSet the duplicate baffles to generate (one 'normal', wall baffle,
// one cyclic baffle). For use with active baffle boundary conditions.
coupledFaces
{
coupledFacesSet
{
wallPatchName baffleWall;
cyclicMasterPatchName baffleCyclic_half0;
}
}
//- Name of cellSet that holds the cells to fully remove
blockedCells blockedCellsSet;
//- All exposed faces that are not specified in blockedFaces go into
// this patch
defaultPatch outer;
// ************************************************************************* //

90
applications/utilities/mesh/advanced/collapseEdges/collapseDict
View File

@ -1,90 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object collapseDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// If on, after collapsing check the quality of the mesh. If bad faces are
// generated then redo the collapsing with stricter filtering.
controlMeshQuality on;
collapseEdgesCoeffs
{
// Edges shorter than this absolute value will be merged
minimumEdgeLength 1e-6;
// The maximum angle between two edges that share a point attached to
// no other edges
maximumMergeAngle 30;
}
collapseFacesCoeffs
{
// The initial face length factor
initialFaceLengthFactor 0.5;
// If the face can't be collapsed to an edge, and it has a span less than
// the target face length multiplied by this coefficient, collapse it
// to a point.
maxCollapseFaceToPointSideLengthCoeff 0.3;
// Allow early collapse of edges to a point
allowEarlyCollapseToPoint on;
// Fraction to premultiply maxCollapseFaceToPointSideLengthCoeff by if
// allowEarlyCollapseToPoint is enabled
allowEarlyCollapseCoeff 0.2;
// Defining how close to the midpoint (M) of the projected
// vertices line a projected vertex (X) can be before making this
// an invalid edge collapse
//
// X---X-g----------------M----X-----------g----X--X
//
// Only allow a collapse if all projected vertices are outwith
// guardFraction (g) of the distance form the face centre to the
// furthest vertex in the considered direction
guardFraction 0.1;
}
controlMeshQualityCoeffs
{
// Name of the dictionary that has the mesh quality coefficients used
// by motionSmoother::checkMesh
#include "meshQualityDict";
// The amount that minimumEdgeLength will be reduced by for each
// edge if that edge's collapse generates a poor quality face
edgeReductionFactor 0.5;
// The amount that initialFaceLengthFactor will be reduced by for each
// face if its collapse generates a poor quality face
faceReductionFactor 0.5;
// Maximum number of smoothing iterations for the reductionFactors
maximumSmoothingIterations 2;
// Maximum number of outer iterations is mesh quality checking is enabled
maximumIterations 10;
// Maximum number of iterations deletion of a point can cause a bad face
// to be constructed before it is forced to not be deleted
maxPointErrorCount 5;
}
// ************************************************************************* //

67
applications/utilities/mesh/advanced/collapseEdges/meshQualityDict
View File

@ -1,67 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object meshQualityDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
//- Maximum non-orthogonality allowed. Set to 180 to disable.
maxNonOrtho 65;
//- Max skewness allowed. Set to <0 to disable.
maxBoundarySkewness 50;
//- Max skewness allowed. Set to <0 to disable.
maxInternalSkewness 10;
//- 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 80;
//- Minimum pyramid volume. Is absolute volume of cell pyramid.
// Set to a sensible fraction of the smallest cell volume expected.
// Set to very negative number (e.g. -1E30) to disable.
minVol 1e-20;
//- Minimum quality of the tet formed by the face-centre
// and variable base point minimum decomposition triangles and
// the cell centre. This has to be a positive number for tracking
// to work. 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 0.0;
//- 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.01;
//must be >0 for Fluent compatibility
minTriangleTwist -1;
// ************************************************************************* //

79
applications/utilities/mesh/advanced/modifyMesh/modifyMeshDict
View File

@ -1,79 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object modifyMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Move boundary points:
// Every entry is two coordinates. First one is location of the point to move,
// the second is the position to move to.
pointsToMove
(
(( -0.17861 -0.45073 0.75276)( -0.18 -0.45073 0.75276))
);
// Split boundary edge in two:
// First coord is a point on the (boundary) edge to cut, second is the
// position of the newly introduced point
edgesToSplit
(
(( -0.17692 -0.45312 0.74516)( -0.18 -0.45 0.742))
);
// Triangulate a boundary face:
// First coord is a point on the face to triangulate. It will introduce a
// point on the face, triangulate and move the point to the second coordinate.
facesToTriangulate
(
(( -0.039123 -0.45045 0.74083) (-0.03844 -0.45049 0.73572))
);
// Boundary edges to collapse. First coord is point on the edge, second
// is coordinate to collapse to.
edgesToCollapse
(
((0.054975 0.099987 0.0044074)(0.054975 0.099987 0.0044074))
);
// Split cells:
// First coord is a point inside the cell to split. A point inside the cell will
// be introduced and the cell will get decomposed into polygonal base pyramids
// with this new point as top. (so the original faces will not get split)
cellsToSplit
(
(( -0.039123 -0.45045 0.74083) (-0.03844 -0.45049 0.73572))
);
// Change patch:
// Changes patchID of boundary faces. Coord selects the face, label is the
// patch index.
facesToRepatch
(
(( -0.039123 -0.45045 0.74083) 1)
);
//// Create cell:
//// Creates a cell on the boundary given a face covering a cavity. Gets
//// the vertices of the face (outwards pointing normal) and a point internal
//// to the new cell. (used to check the orientation of the face). Walks all
//// boundary faces reachable from any edge on the face and constructs cell
//// from it.
//cellsToCreate
//(
// (
// ((0 0 0) (1 0 0) (1 1 0) (0 1 0)) // vertices of face
// (0.5 0.5 0.1) // cell centre
// )
//);
// ************************************************************************* //

40
applications/utilities/mesh/advanced/selectCells/selectCellsDict
View File

@ -1,40 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object selectCellsDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Whether to use surface. If false no surface will be read and only
// outsidePoints/selectOutside will be used to determine cells to keep.
useSurface false;
// Surface to keep to
surface "plexi.obj";
// What is outside
outsidePoints ((-1 -1 -1));
//
// Selection of final set
//
// Select based on side of surface. Usually select inside cells and project
// outwards or select outside cells and project inwards.
selectCut false;
selectInside false;
selectOutside true;
// Leave out cell closer than nearDistance to the surface. Usually
// 0.5*of the cell size. Set to <0 to disable.
nearDistance -1;
// ************************************************************************* //

112
applications/utilities/mesh/advanced/snappyRefineMesh/snappyRefineMeshDict
View File

@ -1,112 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object snappyRefineMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Surface to keep to
surface "plexi.obj";
// What is outside. These points have to be inside a cell (so not on a face!)
outsidePoints ((-0.99001 -0.99001 -0.99001));
//
// Selection of cells to refine
//
// If smallest edge of mesh > maxEdgeLen select all cut cells for refinement.
// If < maxEdgeLen select only those cut cells which are closer than
// curvatureDistance to surface
// and with cos of angle between normals on surface < curvature.
maxEdgeLen 0.1;
curvatureDistance 1.0;
curvature 0.9;
// if > 0: Remove inside cells at every step. Inside is given by number of
// layers separating outside from inside.
// (note that we cannot remove outside
// cells since these contain the outsidePoints)
// Do not use this option if you want mesh to spill through a hole which is
// not visible on the coarsest level but only becomes visible after refinement
nCutLayers 2;
// Refine until smallest edge of mesh < minEdgeLen
minEdgeLen 0.1;
// Or until the number of cells would become more than (stops one level before
// this)
cellLimit 2500000;
//
// Selection of final set
//
// Select based on side of surface. Usually select inside cells and project
// outwards or select outside cells and project inwards.
selectCut false;
selectInside false;
selectOutside true;
// Leave out cell closer than nearDistance to the surface. Usually
// 0.5*minEdgeLen. Set to -1 to disable.
nearDistance -1;
// Some cells on the surface of the selected cells might have all their
// points on the 'outside'. These would get flattened when projecting so
// are either kept and refined (selectHanging) or removed from the set
selectHanging false;
//
// Refinement parameters
//
// Type of coordinate system
coordinateSystem global;
//coordinateSystem patchLocal;
// .. and its coefficients. x,y in this case. (normal = tan1^tan2)
globalCoeffs
{
tan1 (1 0 0);
tan2 (0 1 0);
}
patchLocalCoeffs
{
patch outside; // Normal direction is facenormal of zero'th face of patch
tan1 (1 0 0);
}
// List of directions to refine
directions
(
tan1
tan2
normal
);
// refinement level difference between neighbouring cells. Set to large if
// there is no need for a limit.
splitLevel 2;
// Cut purely geometric (will cut hexes through vertices) or take topology
// into account.
geometricCut false;
// Whether to use hex topology. This will never cut hex through vertices.
useHexTopology yes;
// Write meshes from intermediate steps
writeMesh true;
// ************************************************************************* //

129
applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMeshDict
View File

@ -1,129 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object extrudeMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// What to extrude:
// patch : from patch of another case ('sourceCase')
// mesh : as above but with original case included
// surface : from externally read surface
//constructFrom mesh;
constructFrom patch;
//constructFrom surface;
// If construct from patch/mesh:
sourceCase "../cavity";
sourcePatches (movingWall);
// If construct from patch: patch to use for back (can be same as sourcePatch)
exposedPatchName movingWall;
// If construct from surface:
surface "movingWall.stl";
// Flip surface normals before usage. Valid only for extrude from surface or
// patch.
flipNormals false;
//- Linear extrusion in point-normal direction
//extrudeModel linearNormal;
//- Single layer linear extrusion in point-normal direction
// with empty patches on front and back
//extrudeModel plane;
//- Linear extrusion in specified direction
//extrudeModel linearDirection;
//- Sector extrusion
//extrudeModel sector;
//- Wedge extrusion of a single layer
// with wedge patches on front and back
extrudeModel wedge;
//- Extrudes into sphere around (0 0 0)
//extrudeModel linearRadial;
//- Extrudes into sphere around (0 0 0) with specified radii
//extrudeModel radial;
//- Extrudes into sphere with grading according to pressure (atmospherics)
//extrudeModel sigmaRadial;
//- Extrudes by interpolating along path inbetween two (topologically identical)
// surfaces (e.g. one is an offsetted version of the other)
//extrudeModel offsetSurface;
nLayers 10;
expansionRatio 1.0;
sectorCoeffs //<- Also used for wedge
{
point (0 0.1 -0.05);
axis (-1 0 0);
angle 360; // For nLayers=1 assume symmetry so angle/2 on each side
}
linearNormalCoeffs
{
thickness 0.05;
}
linearDirectionCoeffs
{
direction (0 1 0);
thickness 0.05;
}
linearRadialCoeffs
{
R 0.1;
Rsurface 0.01; // Optional inner radius
}
radialCoeffs
{
// Radii specified through interpolation table
R table ((0 0.01)(3 0.03)(10 0.1));
}
sigmaRadialCoeffs
{
RTbyg 1;
pRef 1;
pStrat 1;
}
offsetSurfaceCoeffs
{
// Surface that mesh has been meshed to
baseSurface "<constant>/triSurface/DTC-scaled-inflated.obj";
// Surface to fill in to
offsetSurface "<constant>/triSurface/DTC-scaled.obj";
}
// Do front and back need to be merged? Usually only makes sense for 360
// degree wedges.
mergeFaces false;
// Merge small edges. Fraction of bounding box.
mergeTol 0;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

121
applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMeshDict
View File

@ -1,121 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object extrudeToRegionMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Name of region to create
region liquidFilm;
// Specification of faces to extrude. Either faceZones (either exclusively
// internal faces or boundary faces) or faceSets (boundary faces only).
// FaceZones to extrude
faceZones (f0 f1);
//faceZonesShadow (f0Shadow f1Shadow);
// faceSets to extrude
//faceSets (f0 f1);
//faceSetsShadow (f0Shadow f1Shadow);
// Adapt the original mesh to have mapped patches at where the
// faceZones are?
// If true:
// - extruding internal faces: become baffles on mapped patches
// - extruding boundary faces: repatched to be on mapped patches
// If false: leave original mesh intact. Extruded mesh will still have
// mapped patch which might need to be adapted.
adaptMesh true;
// Sample mode for inter-region communication
sampleMode nearestPatchFace;
// 1 D extrusion
// ~~~~~~~~~~~~~
// Extrude 1D-columns of cells? This by default duplicates points so can
// have overlapping columns (i.e. non space filling)
oneD false;
//- If oneD: specify which boundary is wanted between the layers
//oneDPolyPatchType empty; //wedge
//- If oneD: specify whether to duplicate points (i.e. disconnect 1D
// columns) or only on non-manifold extrusion areas. Default is false.
// nonManifold true;
//- Extrusion model to use. The only logical choice is linearNormal?
//- Linear extrusion in normal direction
extrudeModel linearNormal;
//- Linear extrusion in specified direction
// extrudeModel linearDirection;
//- Wedge extrusion. If nLayers is 1 assumes symmetry around plane.
// extrudeModel wedge;
//- Extrudes into sphere around (0 0 0)
// extrudeModel linearRadial;
//- Extrudes into sphere around (0 0 0) with specified radii
//extrudeModel radial;
//- Extrudes into sphere with grading according to pressure (atmospherics)
// extrudeModel sigmaRadial;
nLayers 10;
expansionRatio 0.9;
linearNormalCoeffs
{
thickness 0.05;
}
sectorCoeffs //<- Also used for wedge
{
point (0 0.1 -0.05);
axis (-1 0 0);
angle 360; // For nLayers=1 assume symmetry so angle/2 on each side
}
linearDirectionCoeffs
{
direction (0 1 0);
thickness 0.05;
}
linearRadialCoeffs
{
R 0.1;
Rsurface 0.01; // Optional inner radius
}
radialCoeffs
{
// Radii specified through interpolation table
R table ((0 0.01)(3 0.03)(10 0.1));
}
sigmaRadialCoeffs
{
RTbyg 1;
pRef 1;
pStrat 1;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

42
applications/utilities/mesh/generation/extrude2DMesh/extrude2DMeshDict
View File

@ -1,42 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object extrude2DMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
extrudeModel linearDirection;
//extrudeModel wedge;
patchType empty;
//patchType wedge;
nLayers 1;
expansionRatio 1.0;
linearDirectionCoeffs
{
direction (0 0 1);
thickness 0.1;
}
sectorCoeffs //<- Also used for wedge
{
point (0 0 0);
axis (1 0 0);
angle 10;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

490
applications/utilities/mesh/generation/foamyMesh/foamyHexMesh/foamyHexMeshDict
View File

@ -1,490 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object foamyHexMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
/*
Control dictionary for foamyHexMesh - automatic mesh generator.
foamyHexMesh phases:
1. fill volume with initial points (initialPoints subdictionary). An option
is to reread from previous set of points.
2. internal point motion (motionControl subdictionary)
3. every once in a while add point duplets/triplets to conform to
surfaces and features (surfaceConformation subdictionary)
4. back to 2
5. construct polyMesh.
- filter (polyMeshFiltering subdictionary)
- check (meshQualityControls subdictionary) and undo filtering
See also cvControls.H in the conformalVoronoiMesh library
*/
// Important:
// ----------
// Any scalar with a name <name>Coeff specifies a value that will be implemented
// as a faction of the local target cell size
// Any scalar with a name <name>Size specifies an absolute size.
// Geometry. Definition of all surfaces. All surfaces are of class
// searchableSurface.
// Surfaces need to be (almost) closed - use closedTriSurfaceMesh
// if they are not topologically closed. Surfaces need to be oriented so
// the space to be meshed is always on the inside of all surfaces. Use e.g.
// surfaceOrient.
geometry
{
// Surface to conform to
flange.obj
{
type triSurfaceMesh;
}
// Surface used for cell size control
ref7.stl
{
name ref7;
type triSurfaceMesh;
}
refinementBox
{
type searchableBox;
}
}
//Optional: single region surfaces get patch names according to
// surface only. Multi-region surfaces get patch name
// surface "_ "region. Default is true
//singleRegionName false;
// Controls for conforming to the surfaces.
surfaceConformation
{
// A point inside surfaces that is inside mesh.
locationInMesh (0 0 0);
// How far apart are point-duplets generated. Balance this between
// - very low distance: little chance of interference from other
// surfaces
// - largish distance: less non-orthogonality in final cell
// (circumcentre far away from centroid)
pointPairDistanceCoeff 0.1;
// Mixed feature points - connected to both inside and outside edges.
// Recreated by inserting triplets of points to recreate a single edge.
// Done for all edges emanating from point. triplets of points get inserted
// mixedFeaturePointPPDistanceCoeff distance away from feature point.
// Set to a negative number to disable.
mixedFeaturePointPPDistanceCoeff 5.0; //-1;
// Distance to a feature point within which surface and edge
// conformation points are excluded - fraction of the local target
// cell size
featurePointExclusionDistanceCoeff 0.65;
// Distance to an existing feature edge conformation location
// within which other edge conformation location are excluded -
// fraction of the local target cell size
featureEdgeExclusionDistanceCoeff 0.65;
// Optimisation: do not check for surface intersection (of dual edges)
// for points near to surface.
surfaceSearchDistanceCoeff 5;
// Maximum allowable protrusion through the surface before
// conformation points are added - fraction of the local target
// cell size. These small protusions are (hopefully) done by mesh filtering
// instead.
maxSurfaceProtrusionCoeff 0.1;
// If feature edge with large angle (so more than 125 degrees) introduce
// additional points to create two half angled cells (= mitering).
maxQuadAngle 125;
// Frequency to redo surface conformation (expensive).
surfaceConformationRebuildFrequency 10;
featurePointControls
{
specialiseFeaturePoints on;
guardFeaturePoints on;
snapFeaturePoints on;
circulateEdges on;
}
// Initial and intermediate controls
conformationControls
{
// We've got a point poking through the surface. Don't do any
// surface conformation if near feature edge (since feature edge
// conformation should have priority)
// distance to search for near feature edges
edgeSearchDistCoeff 1.1;
// Proximity to a feature edge where a surface hit is
// not created, only the edge conformation is created
// - fraction of the local target cell size. Coarse
// conformation, initial protrusion tests.
surfacePtReplaceDistCoeff 0.5; // instead of surface point insert
// edge-conformation point
surfacePtExclusionDistanceCoeff 0.5; // do not place surface point
// altogether
// Stop either at maxIterations or if the number of surface pokes
// is very small (iterationToInitialHitRatioLimit * initial number)
// Note: perhaps iterationToInitialHitRatioLimit should be absolute
// count?
maxIterations 15;
iterationToInitialHitRatioLimit 0.001;
}
// Geometry to mesh to
geometryToConformTo
{
flange.obj
{
featureMethod extendedFeatureEdgeMesh; // or none;
extendedFeatureEdgeMesh "flange.extendedFeatureEdgeMesh";
}
}
// Additional features.
additionalFeatures
{
//line
//{
// featureMethod extendedFeatureEdgeMesh; // or none;
// extendedFeatureEdgeMesh "line.extendedFeatureEdgeMesh";
//}
}
}
// Controls for seeding initial points and general control of the target
// cell size (used everywhere)
initialPoints
{
// Do not place point closer than minimumSurfaceDistanceCoeff
// to the surface. Is fraction of local target cell size (see below)
minimumSurfaceDistanceCoeff 0.55;
initialPointsMethod autoDensity;
// initialPointsMethod uniformGrid;
// initialPointsMethod bodyCentredCubic;
// initialPointsMethod pointFile;
// Take boundbox of all geometry. Sample with this box. If too much
// samples in box (due to target cell size) split box.
autoDensityCoeffs
{
// Initial number of refinement levels. Needs to be enough to pick
// up features due to size ratio. If not enough it will take longer
// to determine point seeding.
minLevels 4;
// Split box if ratio of min to max cell size larger than maxSizeRatio
maxSizeRatio 5.0;
// Per box sample 5x5x5 internally
sampleResolution 5;
// Additionally per face of the box sample 5x5
surfaceSampleResolution 5;
}
uniformGridCoeffs
{
// Absolute cell size.
initialCellSize 0.0015;
randomiseInitialGrid yes;
randomPerturbationCoeff 0.02;
}
bodyCentredCubicCoeffs
{
initialCellSize 0.0015;
randomiseInitialGrid no;
randomPerturbationCoeff 0.1;
}
pointFileCoeffs
{
// Reads points from file. Still rejects points that are too
// close to the surface (minimumSurfaceDistanceCoeff) or on the
// wrong side of the surfaces.
pointFile "constant/internalDelaunayVertices";
}
}
// Control size of voronoi cells i.e. distance between points. This
// determines the target cell size which is used everywhere.
// It determines the cell size given a location. It then uses all
// the rules
// - defaultCellSize
// - cellShapeControl
// to determine target cell size. Rule with highest priority wins. If same
// priority smallest cell size wins.
motionControl
{
// Absolute cell size of back ground mesh. This is the maximum cell size.
defaultCellSize 0.25;
minimumCellSizeCoeff 0;
maxSmoothingIterations 200;
maxRefinementIterations 2;
// Calculate the sizes and alignments from surfaces
shapeControlFunctions
{
flange
{
type searchableSurfaceControl;
forceInitialPointInsertion on;
priority 1;
mode inside;
// Cell size at surface
surfaceCellSizeFunction uniformValue;
uniformValueCoeffs
{
surfaceCellSizeCoeff 0.5;
}
// Cell size inside domain by having a region of thickness
// surfaceOffsetaround the surface with the surface cell size
// (so constant) and then down to distanceCellSize over a distance
// of linearDistance.
cellSizeFunction surfaceOffsetLinearDistance;
surfaceOffsetLinearDistanceCoeffs
{
distanceCellSizeCoeff 1;
surfaceOffsetCoeff 1;
linearDistanceCoeff 1;
}
}
fileControl
{
type fileControl;
priority 1;
pointsFile "points";
sizesFile "sizes";
alignmentsFile "alignments";
}
}
// Provide an aspect ratio and the direction in which it acts on the mesh.
// Default is 1.0 if this section is not present in the dictionary
cellAspectRatioControl
{
// Aspect ratio.
aspectRatio 1.0;
// Direction of action of the aspect ratio
aspectRatioDirection (1 0 0);
}
// Underrelaxation for point motion. Simulated annealing: starts off at 1
// and lowers to 0 (at simulation endTime) to converge points.
// adaptiveLinear is preferred choice.
// Points move by e.g. 10% of tet size.
relaxationModel adaptiveLinear; //rampHoldFall
adaptiveLinearCoeffs
{
relaxationStart 1.0;
relaxationEnd 0.0;
}
// Output lots and lots of .obj files
objOutput no;
// Timing and memory usage.
timeChecks no;
// For each delaunay edge (between two vertices, becomes
// the Voronoi face normal) snap to the alignment direction if within
// alignmentAcceptanceAngle. Slightly > 45 is a good choice - prevents
// flipping.
alignmentAcceptanceAngle 48;
// When to insert points. Not advisable change to
// these settings.
pointInsertionCriteria
{
// If edge larger than 1.75 target cell size
// (so tets too large/stretched) insert point
cellCentreDistCoeff 1.75;
// Do not insert point if voronoi face (on edge) very small.
faceAreaRatioCoeff 0.0025;
// Insert point only if edge closely aligned to local alignment
// direction.
acceptanceAngle 21.5;
}
// Opposite: remove point if mesh too compressed. Do not change these
// settings.
pointRemovalCriteria
{
cellCentreDistCoeff 0.65;
}
// How to determine the point motion. All edges got some direction.
// Sum all edge contributions to determine point motion. Weigh by
// face area so motion is preferentially determined by large faces
// (or more importantly ignore contribution from small faces).
// Do not change these settings.
faceAreaWeightModel piecewiseLinearRamp;
piecewiseLinearRampCoeffs
{
lowerAreaFraction 0.5;
upperAreaFraction 1.0;
}
}
// After simulation, when converting to polyMesh, filter out small faces/edges.
// Do not change. See cvControls.H
polyMeshFiltering
{
// Filter small edges
filterEdges on;
// Filter small and sliver faces
filterFaces off;
// Write the underlying Delaunay tet mesh (at output time)
writeTetDualMesh false;
// Write the Delaunay tet mesh used for interpolating cell size and
// alignment (at output time)
writeCellShapeControlMesh true;
// Write the hex/split-hex mesh used for parallel load balancing
// (at output time)
writeBackgroundMeshDecomposition true;
// Upper limit on the size of faces to be filtered.
// fraction of the local target cell size
filterSizeCoeff 0.2;
// Upper limit on how close two dual vertices can be before
// being merged, fraction of the local target cell size
mergeClosenessCoeff 1e-9;
// To not filter: set maxNonOrtho to 1 (so check fails) and then
// set continueFilteringOnBadInitialPolyMesh to false.
continueFilteringOnBadInitialPolyMesh true;
// When a face is "bad", what fraction should the filterSizeCoeff be
// reduced by. Recursive, so for a filterCount value of fC, the
// filterSizeCoeff is reduced by pow(filterErrorReductionCoeff, fC)
filterErrorReductionCoeff 0.5;
// Maximum number of filterCount applications before a face
// is not attempted to be filtered
filterCountSkipThreshold 4;
// Maximum number of permissible iterations of the face collapse
// algorithm. The value to choose will be related the maximum number
// of points on a face that is to be collapsed and how many faces
// around it need to be collapsed.
maxCollapseIterations 25;
// Maximum number of times an to allow an equal faceSet to be
// returned from the face quality assessment before stopping iterations
// to break an infinite loop.
maxConsecutiveEqualFaceSets 5;
// Remove little steps (almost perp to surface) by collapsing face.
surfaceStepFaceAngle 80;
// Do not collapse face to edge if should become edges
edgeCollapseGuardFraction 0.3;
// Only collapse face to point if high aspect ratio
maxCollapseFaceToPointSideLengthCoeff 0.35;
}
// Generic mesh quality settings. At any undoable phase these determine
// where to undo. Same as in snappyHexMeshDict
meshQualityControls
{
//- Maximum non-orthogonality allowed. Set to 180 to disable.
maxNonOrtho 65;
//- Max skewness allowed. Set to <0 to disable.
maxBoundarySkewness 50;
maxInternalSkewness 10;
//- 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 80;
//- Minimum pyramid volume. Is absolute volume of cell pyramid.
// Set to a sensible fraction of the smallest cell volume expected.
// Set to very negative number (e.g. -1E30) to disable.
minVol -1E30;
//- Minimum quality of the tet formed by the
// variable base point minimum decomposition triangles and
// the cell centre (so not face-centre decomposition).
// This has to be a positive number for tracking
// to work. Set to very negative number (e.g. -1E30) to
// disable.
// <0 = inside out tet,
// 0 = flat tet
// 1 = regular tet
minTetQuality 1e-30;
//- Minimum absolute 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 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.01;
//must be >0 for Fluent compatibility
minTriangleTwist -1;
}
// ************************************************************************* //

187
applications/utilities/mesh/generation/foamyMesh/foamyQuadMesh/foamyQuadMeshDict
View File

@ -1,187 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object foamyQuadMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
geometry
{
surfaceFile.stl
{
name surfaceFile;
type triSurfaceMesh;
}
}
surfaceConformation
{
locationInMesh (-2.8 0.7 0.5);
pointPairDistanceCoeff 0.005;
minEdgeLenCoeff 0.005;
maxNotchLenCoeff 0.003;
minNearPointDistCoeff 0.0025;
maxQuadAngle 125;
// Insert near-boundary point mirror or point-pairs
insertSurfaceNearestPointPairs yes;
// Mirror near-boundary points rather than insert point-pairs
mirrorPoints no;
// Insert point-pairs vor dual-cell vertices very near the surface
insertSurfaceNearPointPairs yes;
// Maximum number of iterations used in boundaryConform.
maxBoundaryConformingIter 5;
geometryToConformTo
{
surfaceFile
{
featureMethod extendedFeatureEdgeMesh;
extendedFeatureEdgeMesh "surfaceFile.extendedFeatureEdgeMesh";
}
}
additionalFeatures
{}
// Choose if to randomise the initial grid created by insertGrid.
randomiseInitialGrid yes;
// Perturbation fraction, 1 = cell-size.
randomPerturbation 0.1;
}
motionControl
{
defaultCellSize 0.05;
// Assign a priority to all requests for cell sizes, the highest overrules.
defaultPriority 0;
cellSizeControlGeometry
{
surfaceFile
{
priority 1;
mode bothSides;
cellSizeFunction linearDistance;
linearDistanceCoeffs
{
distanceCellSize 0.05;
surfaceCellSize 0.01;
distance 0.5;
}
uniformCoeffs
{
cellSize 0.01;
}
}
// refinementBox
// {
// priority 1;
// mode outside;
// cellSizeFunction linearDistance;
// linearDistanceCoeffs
// {
// distanceCellSize 0.04;
// surfaceCellSize 0.005;
// distance 0.2;
// }
// }
// refinementSphere
// {
// priority 1;
// mode outside;
// cellSizeFunction linearDistance;
// linearDistanceCoeffs
// {
// distanceCellSize 0.04;
// surfaceCellSize 0.005;
// distance 0.2;
// }
// }
}
relaxationModel adaptiveLinear;
adaptiveLinearCoeffs
{
relaxationStart 1.0;
relaxationEnd 0.0;
}
objOutput no;
// Near-wall region where cells are aligned with the wall specified as a number
// of cell layers
nearWallAlignedDist 3;
}
shortEdgeFilter
{
// Factor to multiply the average of a face's edge lengths by.
// If an edge of that face is smaller than that value then delete it.
shortEdgeFilterFactor 0.2;
// Weighting for the lengths of edges that are attached to the boundaries.
// Used when calculating the length of an edge. Default 2.0.
edgeAttachedToBoundaryFactor 2.0;
}
extrusion
{
extrude on;
extrudeModel linearDirection;
//extrudeModel wedge;
patchInfo
{
//type empty;
//startFace
}
patchType empty;
//patchType wedge;
nLayers 1;
expansionRatio 1.0; //0.9;
linearDirectionCoeffs
{
direction (0 0 1);
thickness 0.1;
}
sectorCoeffs //<- Also used for wedge
{
point (0 0 0);
axis (1 0 0);
angle 10;
}
}
// ************************************************************************* //

21
applications/utilities/mesh/generation/snappyHexMesh/meshQualityDict
View File

@ -1,21 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object meshQualityDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Include defaults parameters from master dictionary
#includeEtc "caseDicts/meshQualityDict"
// ************************************************************************* //

796
applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
View File

@ -1,796 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object snappyHexMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Which of the steps to run
castellatedMesh true;
snap true;
addLayers false;
// Optional: single region surfaces get patch names according to
// surface only. Multi-region surfaces get patch name
// surface "_ "region. Default is true
// singleRegionName false;
// Optional: avoid patch-face merging. Allows mesh to be used for
// refinement/unrefinement
// mergePatchFaces false; // default true
// Optional: preserve all generated patches. Default is to remove
// zero-sized patches.
// keepPatches true;
// 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
{
box1x1x1
{
type searchableBox;
min (1.5 1 -0.5);
max (3.5 2 0.5);
}
// Shell for directional refinement
wakeBox
{
type searchableBox;
min (1.5 1 -0.5);
max (3.5 2 0.5);
}
sphere.stl
{
type triSurfaceMesh;
//tolerance 1E-5; // optional:non-default tolerance on intersections
//maxTreeDepth 10; // optional:depth of octree. Decrease only in case
// of memory limitations.
// Per region the patchname. If not provided will be <surface>_<region>.
// Note: this name cannot be used to identity this region in any
// other part of this dictionary; it is only a name
// for the combination of surface+region (which is only used
// when creating patches)
regions
{
secondSolid
{
name mySecondPatch;
}
}
}
sphere2
{
type searchableSphere;
centre (1.5 1.5 1.5);
radius 1.03;
}
};
// 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 100000;
// 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 2000000;
// The surface refinement loop might spend lots of iterations refining just
// a few cells. This setting will cause refinement to stop if
// <= minRefinementCells cells are selected for refinement. Note: it will
// at least do one iteration unless
// a: the number of cells to refine is 0
// b: minRefinementCells = -1. This is a special value indicating
// no refinement.
minRefinementCells 0;
// Allow a certain level of imbalance during refining
// (since balancing is quite expensive)
// Expressed as fraction of perfect balance (= overall number of cells /
// nProcs). 0=balance always.
maxLoadUnbalance 0.10;
// Number of buffer layers between different levels.
// 1 means normal 2:1 refinement restriction, larger means slower
// refinement.
nCellsBetweenLevels 1;
// Explicit feature edge refinement
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Specifies a level for any cell intersected by explicitly provided
// edges.
// This is a featureEdgeMesh, read from constant/triSurface for now.
// Specify 'levels' in the same way as the 'distance' mode in the
// refinementRegions (see below). The old specification
// level 2;
// is equivalent to
// levels ((0 2));
features
(
//{
// file "someLine.eMesh";
// //level 2; // Have level 2 for all cells intersected
// // by feature.
// levels ((0.1 2)); // Have level 2 for all cells within
// // 0.1 of feature.
//}
);
// 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
{
sphere.stl
{
// Surface-wise min and max refinement level
level (2 2);
// Optional region-wise level specification
regions
{
secondSolid
{
level (3 3);
}
}
// Optional specification of patch type (default is wall). No
// constraint types (cyclic, symmetry) etc. are allowed.
patchInfo
{
type patch;
inGroups (meshedPatches);
}
//- Optional increment (on top of max level) in small gaps
//gapLevelIncrement 2;
//- Optional angle to detect small-large cell situation
// perpendicular to the surface. Is the angle of face w.r.t.
// the local surface normal. Use on flat(ish) surfaces only.
// Otherwise leave out or set to negative number.
//perpendicularAngle 10;
//- Optional faceZone and (for closed surface) cellZone with
// how to select the cells that are in the cellZone
// (inside / outside / specified insidePoint)
// The orientation of the faceZone is
// - if on cellZone(s) : point out of (minimum) cellZone
// - if freestanding : oriented according to surface
//faceZone sphere;
//cellZone sphere;
//cellZoneInside inside; // outside/insidePoint
//insidePoint (1 1 1); // if (cellZoneInside == insidePoint)
//- Optional specification of what to do with faceZone faces:
// internal : keep them as internal faces (default)
// baffle : create baffles from them. This gives more
// freedom in mesh motion
// boundary : create free-standing boundary faces (baffles
// but without the shared points)
//faceType baffle;
}
}
// Feature angle:
// - used if min and max refinement level of a surface differ
// - used if feature snapping (see snapControls below) is used
resolveFeatureAngle 30;
//- Optional increment (on top of max level) in small gaps
//gapLevelIncrement 2;
// Planar angle:
// - used to determine if surface normals
// are roughly the same or opposite. Used
// - in proximity refinement
// - to decide when to merge free-standing baffles
// (if e.g. running in surfaceSimplify mode set this to 180 to
// merge all baffles)
// - in snapping to avoid snapping to nearest on 'wrong' side
// of thin gap
//
// If not specified same as resolveFeatureAngle
planarAngle 30;
// 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
// increasing 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
{
box1x1x1
{
mode inside;
levels ((1.0 4));
}
//sphere.stl
//{
// mode inside;
// levels ((1.0 4));
// // Optional override of uniform refinement level such
// // that in small gaps we're getting more cells.
// // The specification is
// // - numGapCells : minimum number of cells in the gap
// // (usually >3; lower than this might not
// // resolve correctly)
// // - minLevel : min refinement level at which to kick in
// // - maxLevel : upper refinement level (to avoid refinement
// // continuing on a single extraneous feature)
// // All three settings can be overridden on a surface by
// // surface basis in the refinementSurfaces section.
// gapLevel (<numGapCells> <minLevel> <maxlevel>);
// // Optional: when doing the gapLevel refinement directly remove
// // based on orientation w.r.t. gap. This limits the
// // amount of cells before doing the 'locationInMesh'
// // cell selection. Default is 'mixed' i.e. keep cells
// // whilst doing the gap-level refinement.
// //gapMode inside; // inside/outside/mixed
//}
//wakeBox
//{
// mode inside;
// // Dummy base level
// levels ((10000 0));
//
// // Optional directional refinement (after all other refinement)
// // Directional refinement
// // for all cells according to 'mode' ('inside' or 'outside';
// // 'distance' not supported) and within certain range. E.g.
// // - for all cells with level 2-5
// // - do one split in x direction
// levelIncrement (2 5 (1 0 0));
//
// // Note
// // - ignores 'levels' and gap* settings.
// // - the cellLevel/pointLevels files are no longer consistent
// // with the mesh, the resulting mesh is no longer compatible
// // with e.g. dynamic refinement/unrefinement.
// // - cellLevel will include any directional refinement
// // (i.e. it will be the maximum of all three directions)
//}
//wakeBox
//{
// mode inside;
// // Dummy base level
// levels ((10000 0));
//
// // Optional directional refinement (after all other refinement)
// // Directional refinement
// // for all cells according to 'mode' ('inside' or 'outside';
// // 'distance' not supported) and within certain range. E.g.
// // - for all cells with level 2-5
// // - do one split in x direction
// levelIncrement (2 5 (1 0 0));
//
// // Note
// // - ignores 'levels' and gap* settings.
// // - the cellLevel/pointLevels files are no longer consistent
// // with the mesh, the resulting mesh is no longer compatible
// // with e.g. dynamic refinement/unrefinement.
// // - cellLevel will include any directional refinement
// // (i.e. it will be the maximum of all three directions)
//
// // Optional directional expansion-ratio smoothing (after all
// // refinement). This will try to smooth out edge/cell size jumps
// // Specify smoothing direction and number of iterations
// smoothDirection (1 0 0);
// // Smoothing of expansion ratio
// nSmoothExpansion 100;
// // Smoothing of positions
// nSmoothPosition 100;
//}
}
// Optionally limit refinement in geometric region. This limits all
// refinement (from features, refinementSurfaces, refinementRegions)
// in a given geometric region. The syntax is exactly the same as for the
// refinementRegions; the cell level now specifies the upper limit
// for any cell. (a special setting is cell level -1 which will remove
// any cells inside the region). Note that it does not override the
// refinement constraints given by the nCellsBetweenLevels setting.
limitRegions
{
}
// 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 location(s)InMesh is kept.
// NOTE: This point should never be on a face, always inside a cell, even
// after refinement.
//
// There are two different ways of specifying the regions to keep:
// 1. a single locationInMesh. This is the unzoned part of the mesh.
// All the 'zoned' surfaces are marked as such
// in the refinementSurfaces with the faceZone and cellZone keywords.
// It is illegal to have the locationInMesh inside a surface for which
// a cellZone is specified.
//
// or
//
// 2. multiple locationsInMesh, with per location the name of the cellZone.
// This uses walking to determine zones and automatically creates
// faceZones on the outside of cellZones. The special name 'none' is
// used to indicate the unzoned/background part of the mesh.
// Ad 1. Specify a single location and how to treat faces inbetween
// cellZones
locationInMesh (5 0.28 0.43);
// Whether any faceZones (as specified in the refinementSurfaces)
// are only on the boundary of corresponding cellZones.
// Not used if there are no faceZones. The behaviour has changed
// with respect to previous versions:
// true : all intersections with surface are put in faceZone
// (same behaviour as before)
// false : depending on the type of surface intersected:
// - if intersecting surface has faceZone only (so no cellZone)
// leave in faceZone (so behave as if set to true) (= changed
// behaviour)
// - if intersecting surface has faceZone and cellZone
// remove if inbetween same cellZone or if on boundary
// (same behaviour as before)
allowFreeStandingZoneFaces true;
// 2. Specify multiple locations with optional cellZones for the
// regions (use cellZone "none" to specify the unzoned cells)
// FaceZones are automatically constructed from the
// names of the cellZones: <cellZoneA> _to_ <cellZoneB>
// where the cellZoneA is the lowest numbered cellZone (non-cellZone
// cells are in a special region called "none" which is always
// last).
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;
}
}
// Optional locations that should not be reachable from
// location(s)InMesh
locationsOutsideMesh ((100 100 100));
// Optional: do not remove cells likely to give snapping problems
// handleSnapProblems false;
// Optional: switch off topological test for cells to-be-squashed
// and use geometric test instead
//useTopologicalSnapDetection false;
// Optional: do not refine surface cells with opposite faces of
// differing refinement levels
//interfaceRefine false;
// Optional: use an erosion instead of region assignment to allocate
// left-over cells to the background region (i.e. make cellZones
// consistent with the intersections of the surface).
// Erosion is specified as a number of erosion iterations.
// Erosion has less chance of bleeding and changing the zone
// for a complete region.
//nCellZoneErodeIter 2;
}
// Settings for the snapping.
snapControls
{
// Number of patch smoothing iterations before finding correspondence
// to surface
nSmoothPatch 3;
// Optional: number of smoothing iterations for internal points on
// refinement interfaces. This will reduce non-orthogonality on
// refinement interfaces.
//nSmoothInternal $nSmoothPatch;
// Maximum relative distance for points to be attracted by surface.
// True distance is this factor times local maximum edge length.
tolerance 2.0;
// Number of mesh displacement relaxation iterations.
nSolveIter 30;
// Maximum number of snapping relaxation iterations. Should stop
// before upon reaching a correct mesh.
nRelaxIter 5;
// (wip) disable snapping to opposite near surfaces (revert to 22x
// behaviour)
// detectNearSurfacesSnap false;
// Feature snapping
// Number of feature edge snapping iterations.
// Leave out altogether to disable.
nFeatureSnapIter 10;
// Detect (geometric only) features by sampling the surface
// (default=false).
implicitFeatureSnap false;
// Use castellatedMeshControls::features (default = true)
explicitFeatureSnap true;
// Detect features between multiple surfaces
// (only for explicitFeatureSnap, default = false)
multiRegionFeatureSnap 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
// to multi-region edges/points take priority. This might aid snapping
// to sharp edges that are also region edges. The default is false.
//releasePoints true;
//- Walk along feature edges, adding missing ones. Default is true.
//stringFeatures false;
//- If diagonal attraction also attract other face points. Default is
// false
//avoidDiagonal true;
//- When splitting what concave faces to leave intact. Default is 45
// degrees.
//concaveAngle 30;
//- When splitting the minimum area ratio of faces. If face split
// causes ratio of area less than this do not split. Default is 0.3
//minAreaRatio 0.3;
//- Attract points only to the surface they originate from. Default
// false. This can improve snapping of intersecting surfaces.
// strictRegionSnap true;
}
// 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 in one of following
// ways:
// - expansionRatio and finalLayerThickness (cell nearest internal mesh)
// - expansionRatio and firstLayerThickness (cell on surface)
// - overall thickness and firstLayerThickness
// - overall thickness and finalLayerThickness
// - overall thickness and expansionRatio
//
// Note: the mode thus selected is global, i.e. one cannot override the
// mode on a per-patch basis (only the values can be overridden)
// 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;
// Wanted thickness of the layer next to the wall.
// If relativeSizes this is relative to undistorted size of cell
// outside layer.
//firstLayerThickness 0.3;
// Wanted overall thickness of layers.
// If relativeSizes this is relative to undistorted size of cell
// outside layer.
//thickness 0.5
// Minimum overall thickness of total layers. If for any reason layer
// cannot be above minThickness do not add layer.
// If relativeSizes this is relative to undistorted size of cell
// outside layer..
minThickness 0.1;
// Per final patch or faceZone (so not geometry!) the layer information
// Note: This behaviour changed after 21x. Any non-mentioned patches
// now slide unless:
// - nSurfaceLayers is explicitly mentioned to be 0.
// - angle to nearest surface < slipFeatureAngle (see below)
layers
{
sphere.stl_firstSolid
{
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;
// 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;
// Choice of mesh shrinking algorithm
// Optional mesh shrinking algorithm (default is displacementMedialAxis)
// The displacementMotionSolver is a wrapper around the displacement
// motion solvers. It needs specification of the solver to use and
// its control dictionary.
//meshShrinker displacementMotionSolver;
//solver displacementLaplacian;
//displacementLaplacianCoeffs
//{
// diffusivity quadratic inverseDistance
// (
// sphere.stl_firstSolid
// maxY
// );
//}
// Note that e.g. displacementLaplacian needs entries in
// fvSchemes, fvSolution. Also specify a minIter > 1 when solving
// cellDisplacement since otherwise solution might not be sufficiently
// accurate on points.
// Medial axis analysis (for use with default displacementMedialAxis)
// Angle used to pick up medial axis points
// Note: changed(corrected) w.r.t 1.7.x! 90 degrees corresponds to 130
// in 1.7.x.
minMedialAxisAngle 90;
// Reduce layer growth where ratio thickness to medial
// distance is large
maxThicknessToMedialRatio 0.3;
// Number of smoothing iterations of interior mesh movement direction
nSmoothNormals 3;
// Optional: limit the number of steps walking away from the surface.
// Default is unlimited.
//nMedialAxisIter 10;
// Optional: smooth displacement after medial axis determination.
// default is 0.
//nSmoothDisplacement 90;
// (wip)Optional: do not extrude any point where
// (false) : all surrounding faces are not fully extruded
// (true) : all surrounding points are not extruded
// Default is false.
//detectExtrusionIsland true;
// Optional: do not extrude around sharp edges if both faces are not
// fully extruded i.e. if one of the faces on either side would
// become a wedge.
// Default is 0.5*featureAngle. Set to -180 always attempt extrusion
//layerTerminationAngle 25;
// Optional: disable shrinking of edges that have one (or two) points
// on an extruded patch.
// Default is false to enable single/two cell thick channels to still
// have layers. In <=1806 this was true by default. On larger gaps it
// should have no effect.
//disableWallEdges true;
// Optional: at non-patched sides allow mesh to slip if extrusion
// direction makes angle larger than slipFeatureAngle. Default is
// 0.5*featureAngle.
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;
}
// Advanced
//// Debug flags
//debugFlags
//(
// mesh // write intermediate meshes
// intersections // write current mesh intersections as .obj files
// featureSeeds // write information about explicit feature edge
// // refinement
// attraction // write attraction as .obj files
// layerInfo // write information about layers
//);
//
//// Write flags
//writeFlags
//(
// scalarLevels // write volScalarField with cellLevel for postprocessing
// layerSets // write cellSets, faceSets of faces in layer
// layerFields // write volScalarField for layer coverage
//);
//// Format for writing lines. E.g. leak path. Default is vtk format.
//setFormat ensight;
// Merge tolerance. Is fraction of overall bounding box of initial mesh.
// Note: the write tolerance needs to be higher than this.
mergeTolerance 1e-6;
// ************************************************************************* //

144
applications/utilities/mesh/manipulation/createBaffles/createBafflesDict
View File

@ -1,144 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ 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)
//
// - selection of faces (and orientation) to 'baffle' through:
// faceZone:
// type faceZone;
// zoneName f0;
// searchableSurface:
// type searchableSurface;
// surface triSurfaceMesh;
// name baffle1D.stl;
//
// - specification of patches for baffle sides 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
{
baffle1
{
//- Use surface to select faces and orientation.
type searchableSurface;
surface triSurfaceMesh;
name baffle1D.stl;
//- Optional flip
//flip false;
// Generate patchGroup baffle1 with two patches:
// - baffle1_master
// - baffle1_slave
patchPairs
{
type wall;
//- Optional override of added patchfields. If not specified
// any added patchfields are of type calculated.
patchFields
{
U
{
type fixedValue;
value uniform (0 0 0);
}
}
}
}
cyclicFaces
{
//- Select faces and orientation through a searchableSurface
type searchableSurface;
surface searchablePlate;
origin (0.099 -0.006 0.004);
span (0 0.012 0.012);
// Generate patches explicitly
patches
{
master
{
//- Master side patch
name fan_half0;
type cyclic;
neighbourPatch fan_half1;
patchFields
{
p
{
type fan;
patchType cyclic;
jump uniform 0;
value uniform 0;
jumpTable polynomial 1((100 0));
}
}
}
slave
{
//- Slave side patch
name fan_half1;
type cyclic;
neighbourPatch fan_half0;
patchFields
{
p
{
type fan;
patchType cyclic;
value uniform 0;
}
}
}
}
}
}
// ************************************************************************* //

112
applications/utilities/mesh/manipulation/createPatch/createPatchDict
View File

@ -1,112 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object createPatchDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// This application/dictionary controls:
// - optional: create new patches from boundary faces (either given as
// a set of patches or as a faceSet)
// - always: order faces on coupled patches such that they are opposite. This
// is done for all coupled faces, not just for any patches created.
// - optional: synchronise points on coupled patches.
// - always: remove zero-sized (non-coupled) patches (that were not added)
// 1. Create cyclic:
// - specify where the faces should come from
// - specify the type of cyclic. If a rotational specify the rotationAxis
// and centre to make matching easier
// - always create both halves in one invocation with correct 'neighbourPatch'
// setting.
// - optionally pointSync true to guarantee points to line up.
// 2. Correct incorrect cyclic:
// This will usually fail upon loading:
// "face 0 area does not match neighbour 2 by 0.0100005%"
// " -- possible face ordering problem."
// - in polyMesh/boundary file:
// - loosen matchTolerance of all cyclics to get case to load
// - or change patch type from 'cyclic' to 'patch'
// and regenerate cyclic as above
// Do a synchronisation of coupled points after creation of any patches.
// Note: this does not work with points that are on multiple coupled patches
// with transformations (i.e. cyclics).
pointSync false;
// Patches to create.
patches
(
{
// Name of new patch
name cyc_half0;
// Dictionary to construct new patch from
patchInfo
{
type cyclic;
neighbourPatch cyc_half1;
// Optional: explicitly set transformation tensor.
// Used when matching and synchronising points.
transform rotational;
rotationAxis (1 0 0);
rotationCentre (0 0 0);
// transform translational;
// separationVector (1 0 0);
// Optional non-default tolerance to be able to define cyclics
// on bad meshes
//matchTolerance 1E-2;
}
// How to construct: either from 'patches' or 'set'
constructFrom patches;
// If constructFrom = patches : names of patches. Wildcards allowed.
patches (periodic1);
// If constructFrom = set : name of faceSet
set f0;
}
{
// Name of new patch
name cyc_half1;
// Dictionary to construct new patch from
patchInfo
{
type cyclic;
neighbourPatch cyc_half0;
// Optional: explicitly set transformation tensor.
// Used when matching and synchronising points.
transform rotational;
rotationAxis (1 0 0);
rotationCentre (0 0 0);
// transform translational;
// separationVector (1 0 0);
}
// How to construct: either from 'patches' or 'set'
constructFrom patches;
// If constructFrom = patches : names of patches. Wildcards allowed.
patches (periodic2);
// If constructFrom = set : name of faceSet
set f0;
}
);
// ************************************************************************* //

39
applications/utilities/mesh/manipulation/mergeOrSplitBaffles/mergeOrSplitBafflesDict
View File

@ -1,39 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object mergeOrSplitBafflesDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Detect baffles (boundary faces sharing points) on selected set of patches
// and write to a faceSet.
detect
{
patches (".*Wall");
}
// Detect baffles (on selected patches) and merge these into internal faces.
merge
{
patches ("mergePatch");
}
// Detect baffles (on selected patches) and duplicate the points. This is
// used if e.g. the two sides need to move separately. Note that since the
// points are duplicated the two faces are no longer baffles.
split
{
patches ("split.*Patches");
}
// ************************************************************************* //

27
applications/utilities/mesh/manipulation/mirrorMesh/mirrorMeshDict
View File

@ -1,27 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object mirrorMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
planeType pointAndNormal;
pointAndNormalDict
{
point (0 0 0);
normal (0 1 0);
}
planeTolerance 1e-3;
// ************************************************************************* //

75
applications/utilities/mesh/manipulation/refineMesh/refineMeshDict
View File

@ -1,75 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object refineMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Cells to refine; name of cell set
set c0;
// Type of coordinate system:
// - global : coordinate system same for every cell. Usually aligned with
// x,y,z axis. Specify in globalCoeffs section below.
// - patchLocal : coordinate system different for every cell. Specify in
// patchLocalCoeffs section below.
// - fieldBased : uses the list of field names from the directions list for
// selecting the directions to cut. Meant to be used with geometricCut, but
// can also be used with useHexTopology.
coordinateSystem global;
//coordinateSystem patchLocal;
//coordinateSystem fieldBased;
// .. and its coefficients. x,y in this case. (normal direction is calculated
// as tan1^tan2)
globalCoeffs
{
tan1 (1 0 0);
tan2 (0 1 0);
}
patchLocalCoeffs
{
patch outside; // Normal direction is facenormal of zero'th face of patch
tan1 (1 0 0);
}
// List of directions to refine, if global or patchLocal
directions
(
tan1
tan2
normal
);
// List of directions to refine, if "fieldBased". Keep in mind that these
// fields must be of type "vectorField", not "volVectorField".
//directions
//(
// radialDirectionFieldName
// angularDirectionFieldName
// heightDirectionFieldName
//);
// Whether to use hex topology. This will
// - if patchLocal: all cells on selected patch should be hex
// - split all hexes in 2x2x2 through the middle of edges.
useHexTopology true;
// Cut purely geometric (will cut hexes through vertices) or take topology
// into account. Incompatible with useHexTopology
geometricCut false;
// Write meshes from intermediate steps
writeMesh false;
// ************************************************************************* //

109
applications/utilities/mesh/manipulation/renumberMesh/renumberMeshDict
View File

@ -1,109 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
note "mesh renumbering dictionary";
object renumberMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Write maps from renumbered back to original mesh
writeMaps false;
// Optional entry: sort cells on coupled boundaries to last for use with
// e.g. nonBlockingGaussSeidel.
sortCoupledFaceCells false;
// Optional entry: renumber on a block-by-block basis. It uses a
// blockCoeffs dictionary to construct a decompositionMethod to do
// a block subdivision) and then applies the renumberMethod to each
// block in turn. This can be used in large cases to keep the blocks
// fitting in cache with all the cache misses bunched at the end.
// This number is the approximate size of the blocks - this gets converted
// to a number of blocks that is the input to the decomposition method.
//blockSize 1000;
// Optional entry: sort points into internal and boundary points
//orderPoints false;
method CuthillMcKee;
//method Sloan;
//method manual;
//method random;
//method structured;
//method spring;
//method zoltan; // only if compiled with zoltan support
//CuthillMcKeeCoeffs
//{
// // Reverse CuthillMcKee (RCM) or plain
// reverse true;
//}
manualCoeffs
{
// In system directory: new-to-original (i.e. order) labelIOList
dataFile "cellMap";
}
// For extruded (i.e. structured in one direction) meshes
structuredCoeffs
{
// Patches that mesh was extruded from. These determine the starting
// layer of cells
patches (movingWall);
// Method to renumber the starting layer of cells
method random;
// Renumber in columns (depthFirst) or in layers
depthFirst true;
// Reverse ordering
reverse false;
}
springCoeffs
{
// Maximum jump of cell indices. Is fraction of number of cells
maxCo 0.01;
// Limit the amount of movement; the fraction maxCo gets decreased
// with every iteration
freezeFraction 0.999;
// Maximum number of iterations
maxIter 1000;
}
blockCoeffs
{
method scotch;
//method hierarchical;
//hierarchicalCoeffs
//{
// n (1 2 1);
// delta 0.001;
// order xyz;
//}
}
zoltanCoeffs
{
ORDER_METHOD LOCAL_HSFC;
}
// ************************************************************************* //

38
applications/utilities/mesh/manipulation/stitchMesh/stitchMeshDict
View File

@ -1,38 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object stitchMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
outerx
{
match partial; // partial | integral | perfect
master outerx;
slave innerx;
}
outery
{
match partial;
master outery;
slave innery;
}
outerz
{
match partial;
master outerz;
slave innerz;
}
// ************************************************************************* //

45
applications/utilities/mesh/manipulation/stitchMesh/toleranceDict
View File

@ -1,45 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object toleranceDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// For complete details on what this dictionary file should provide, see
// src/dynamicMesh/slidingInterface/slidingInterface.C
// method: Foam::slidingInterface::setTolerances
//- Point merge tolerance
pointMergeTol 0.05;
//- Edge merge tolerance
edgeMergeTol 0.01;
//- Estimated number of faces an edge goes through
nFacesPerSlaveEdge 5;
//- Edge-face interaction escape limit
edgeFaceEscapeLimit 10;
//- Integral match point adjustment tolerance
integralAdjTol 0.05;
//- Edge intersection master catch fraction
edgeMasterCatchFraction 0.4;
//- Edge intersection co-planar tolerance
edgeCoPlanarTol 0.8;
//- Edge end cut-off tolerance
edgeEndCutoffTol 0.0001;
// ************************************************************************* //

108
applications/utilities/mesh/manipulation/topoSet/topoSetDict
View File

@ -1,108 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object topoSetDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// The topoSetDict comprises a list of actions to perform on different
// set types (cellSet, faceSet, pointSet, etc).
//
// Each action is a dictionary with e.g.
// // Name of set
// name c0;
//
// // type: pointSet/faceSet/cellSet/faceZoneSet/cellZoneSet
// type cellSet;
//
// // action to perform on set. Two types:
// // - require no source : clear/invert/remove
// // clear : clears set or zone
// // invert : select all currently non-selected elements
// // remove : removes set or zone
// // - require source : new/add/subtract/subset
// // new : create new set or zone from source
// // add : add source to contents
// // subtract : subtract source from contents
// // subset : keeps elements both in contents and source
// action new;
//
// The source entry varies according to the type of set.
//
// In OpenFOAM 1806 and earlier, it was compulsory to use a 'sourceInfo'
// sub-dictionary to define the sources.
// In OpenFOAM 1812 and later, this sub-directory is optional, unless
// there would be a name clash (Eg, 'type' or 'name' appearing at both levels).
// In most cases, the source definitions have been adjusted to avoid such
// clashes.
//
// More detailed listing in the annotated topoSetSourcesDict
actions
(
// Example: pick up internal faces on outside of cellSet
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Load initial cellSet
{
name c0;
type cellSet;
action new;
source labelToCell;
value (12 13 56);
}
// Get all faces in cellSet
{
name f0;
type faceSet;
action new;
source cellToFace;
set c0;
option all;
}
// Determine inverse cellSet
{
name c1;
type cellSet;
action new;
source cellToCell;
set c0;
}
{
name c1;
type cellSet;
action invert;
}
// Keep in f0 all faces in c1
{
name f0;
type faceSet;
action subset;
source cellToFace;
set c1;
option all;
}
// Example: create cellZone from geometric region
{
name c0;
type cellZoneSet;
action new;
source boxToCell;
box (0.04 0 0)(0.06 100 100);
}
);
// ************************************************************************* //

607
applications/utilities/mesh/manipulation/topoSet/topoSetSourcesDict
View File

@ -1,607 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1812 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object topoSetDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Information about topoSetSource types
cellSet_doc
{
//- Select all external (boundary) faces.
{
source boundaryToCell;
}
//- Cells with cell centre within multiple boxes or single box
{
source boxToCell;
boxes ((0 0 0) (1 1 1) (10 10 10)(11 11 11));
// or
box (0 0 0) (1 1 1);
// or
min (0 0 0);
max (1 1 1);
}
//- Copy elements from one or more other cellSets
{
source cellToCell;
sets (c1 c2);
// or
set c1;
}
//- Cells with centre within cylinder or cylinder annulus
{
source cylinderToCell;
p1 (0.2 0.2 -10); // start point on cylinder axis
p2 (0.2 0.2 0); // end point on cylinder axis
radius 5.0;
// optional
innerRadius 1.0;
}
//- Cells with centre within cylinder annulus
// Can also simply use cylinderToCell
{
source cylinderAnnulusToCell;
p1 (0.2 0.2 -10); // start point on cylinder axis
p2 (0.2 0.2 0); // end point on cylinder axis
outerRadius 5.0;
innerRadius 1.0;
}
//- Select based on faceSet
{
source faceToCell;
sets (f0 f1);
// or
set f0; // Name of faceSet
//- selection option (mandatory)
option any; // cell with any face in faceSet
// option all; // cell with all faces in faceSet
// option neighbour; // cell with neighbour in faceSet
// option owner; // cell with owner in faceSet
}
//- Cells on master or slave side of faceZone
{
source faceZoneToCell;
zones (".*Zone"); // Names of faceZones, word or regex
// OR zone ".*Zone"; // Name of faceZone, word or regex
option master; // master/slave
//- Compat
// sourceInfo
// {
// name ".*Zone";
// option master;
// }
}
//- values of field within certain range
{
source fieldToCell;
field U; // Note: uses mag(U) since volVectorField
min 0.1;
max 0.5;
}
//- Select by explicitly providing cell labels
{
source labelToCell;
value (12 13 56); // labels of cells
}
//- Select based on number of neighbouring cells
{
source nbrToCell;
neighbours 4; // min neighbours
}
//- Cells with cellCentre nearest to coordinates
{
source nearestToCell;
points ((0 0 0) (1 1 1)(2 2 2));
}
//- Select cells associated with patch
{
source patchToCell;
patches ("patch.*");
// or
patch somePatch;
}
//- Select based on pointSet
{
source pointToCell;
sets (p0 p1);
// or
sets p0;
option any; // cell with any point in pointSet
//option edge; // cell with an edge with both points in pointSet
}
//- Mesh region (non-face connected part of (subset of)mesh)
{
source regionToCell;
insidePoints ((1 2 3)); // points inside region to select
set c0; // optional name of cellSet giving mesh subset
nErode 0; // optional number of layers to erode selection
}
//- Cells with cell centre within box
// Is skewed, rotated box. Given as origin and three spanning vectors.
{
source rotatedBoxToCell;
origin (0.2 0.2 -10);
i (0.2 0.2 0);
j (-0.2 0.2 0);
k (10 10 10);
}
//- Select cells with centres within a searchableSurface
{
source searchableSurfaceToCell;
surfaceType triSurfaceMesh; // The surface type
surfaceName blob.obj; // Name for the IOobject
// or
surface triSurfaceMesh; // Same as surface type
}
//- Select based on cellShape
{
source shapeToCell;
shape hex; // hex/wedge/prism/pyr/tet/tetWedge/splitHex
}
//- Cells with centre within sphere
{
source sphereToCell;
origin (0.2 0.2 -10);
radius 5.0;
// optional
innerRadius 1.0;
}
//- Select based on surface
{
source surfaceToCell;
file "geometry.stl";
outsidePoints ((-99 -99 -59)); // definition of outside
includeCut false; // cells cut by surface
includeInside false; // cells not on outside of surf
includeOutside false; // cells on outside of surf
nearDistance -1; // cells with centre near surf
// (set to -1 if not used)
curvature 0.9; // cells within nearDistance
// and near surf curvature
// (set to -100 if not used)
// optional
useSurfaceOrientation false; // use closed surface inside/outside
// test (ignores includeCut,
// outsidePoints)
}
//- Cells underneath plane such that volume is reached.
// E.g. for use in setFields to set the level given a wanted volume.
{
source targetVolumeToCell;
volume 2e-05;
normal (0 1 0); // usually in direction of gravity
// optional
set c0; // restrict to named cellSet
}
//- Cells in cell zone
{
source zoneToCell;
zones (".*Zone"); // Names of cellZones, word or regex
// OR zone ".*Zone"; // Name of cellZone, word or regex
//- Compat
// sourceInfo
// {
// name ".*Zone";
// }
}
}
faceSet_doc
{
//- All boundary faces
{
source boundaryToFace;
}
//- Faces with face centre within box ('box') or multiple boxes ('boxes')
{
source boxToFace;
boxes ((0 0 0) (1 1 1) (10 10 10)(11 11 11));
// or
box (0 0 0) (1 1 1);
// or
min (0 0 0);
max (1 1 1);
}
//- Select based on cellSet
{
source cellToFace;
source faceToCell;
sets (c0 c1);
// or
set c0; // Name of cellSet
option all; // All faces of cells
//option both; // Only faces with owner+neighbour in cellSet
}
//- Faces with centre within cylinder or cylinder annulus
{
source cylinderToFace;
p1 (0.2 0.2 -10); // start point on cylinder axis
p2 (0.2 0.2 0); // end point on cylinder axis
radius 5.0;
// optional
innerRadius 1.0;
}
//- Faces with centre within cylinder annulus
// Can also simply use cylinderToCell
{
source cylinderAnnulusToFace;
p1 (0.2 0.2 -10); // start point on cylinder axis
p2 (0.2 0.2 0); // end point on cylinder axis
outerRadius 5.0;
innerRadius 1.0;
}
//- Copy elements from faceSet
{
source faceToFace;
set f1;
}
//- Select by explicitly providing face labels
{
source labelToFace;
value (12 13 56); // labels of faces
}
//- Faces with normal to within certain angle aligned with vector.
{
source normalToFace;
normal (0 0 1); // Vector
cos 0.01; // Tolerance (max cos of angle)
}
//- All faces of patch
{
source patchToFace;
patches ("patch.*");
// or
patch somePatch;
// Compat
sourceInfo
{
name ".*Wall"; // Name of patch or patch group,
}
}
//- Select based on pointSet
{
source pointToFace;
sets (p0 p1);
// or
set p0; // Name of pointSet
option any; // Faces using any point in pointSet
//option all // Faces with all points in pointSet
//option edge // Faces with two consecutive points in pointSet
}
//- Walk on faces in faceSet, starting from face nearest given position
{
source regionToFace;
set f0;
nearPoint (0.1 0.1 0.005);
}
//- Select faces with centres within a searchableSurface
{
source searchableSurfaceToFace;
surfaceType triSurfaceMesh; // The surface type
surfaceName blob.obj; // Name for the IOobject
// or
surface triSurfaceMesh; // Same as surface type
}
//- Faces with centre within sphere
{
source sphereToFace;
origin (0.2 0.2 -10);
radius 5.0;
// optional
innerRadius 1.0;
}
//- All faces of faceZone
{
source zoneToFace;
zones (".*Zone"); // Names of faceZones, word or regex
// OR zone ".*Zone"; // Name of faceZone, word or regex
// Compat
// sourceInfo
// {
// name ".*Zone1";
// }
}
}
pointSet_doc
{
//- Points within multiple boxes or single box
{
source boxToPoint;
boxes ((0 0 0) (1 1 1) (10 10 10)(11 11 11));
// or
box (0 0 0) (1 1 1);
// or
min (0 0 0);
max (1 1 1);
}
//- Points associated with cellSet
{
source cellToPoint;
sets (c1 c2);
// or
set c1;
option all; // all points of cell
}
//- Points within cylinder or cylinder annulus
{
source cylinderToPoint;
p1 (0.2 0.2 -10); // start point on cylinder axis
p2 (0.2 0.2 0); // end point on cylinder axis
radius 5.0;
// optional
innerRadius 1.0;
}
//- Points associated with faceSet
{
source faceToPoint;
sets (f1 f2);
// or
set f1;
option all; // all points of face
}
//- Select by explicitly providing point labels
{
source labelToPoint;
value (12 13 56); // labels of points
}
//- Points nearest to coordinates
{
source nearestToPoint;
points ((0 0 0) (1 1 1));
}
//- Copy elements from pointSet
{
source pointToPoint;
sets (p1 p2);
// or
set p1;
}
//- Points within a searchableSurface
{
source searchableSurfaceToCell;
surfaceType triSurfaceMesh; // The surface type
surfaceName blob.obj; // Name for the IOobject
// or
surface triSurfaceMesh; // Same as surface type
}
//- Points centre within sphere
{
source sphereToPoint;
origin (0.2 0.2 -10);
radius 5.0;
// optional
innerRadius 1.0;
}
//- Select based on surface
{
source surfaceToPoint;
file "geometry.stl";
nearDistance 0.1; // points near to surface
includeInside false; // points on inside of surface
// (requires closed surface with consistent
// normals)
includeOutside false; // ,, outside ,,
}
//- Points from pointZone
{
source zoneToPoint;
zones (".*Zone"); // Names of pointZones, word or regex
// OR zone ".*Zone"; // Name of pointZone, word or regex
//- Compat
// sourceInfo
// {
// name ".*Zone";
// }
}
}
// cellZoneSet
// ~~~~~~~~~~~
// Manipulates a cellZone (as well as a cellSet)
// Takes any cellSet source. The difference with a cellSet is
// - reads the cells from the cellZone, not the cellSet
// - write to the cellZone as well as the cellSet
cellZoneSet_doc
{
// For backwards compatibility:
//- Select based on cellSet
{
source setToCellZone;
set c0; // name of cellSet
}
}
// faceZoneSet
// ~~~~~~~~~~~
// Manipulates a faceZone (as well as a faceSet).
// It can only be used with special sources.
faceZoneSet_doc
{
//- Select from another faceZone
{
source faceZoneToFaceZone;
zone z1; // Zone name, no regex
}
//- Select based on surface. Orientation from normals on surface
{
source searchableSurfaceToFaceZone;
surfaceType searchableSphere;
surfaceName blob.obj; // Optional name if surface triSurfaceMesh
// or
surface searchableSphere; // Same as 'surfaceType'
// Parameters for surface
origin (0.05 0.05 0.005);
radius 0.025;
}
//- Select based on faceSet, using supplied normal to determine orientation
{
source setAndNormalToFaceZone;
faceSet f0; // name of faceSet
normal (1 0 0); // normal orientation
}
//- Select based on faceSet without orientation
{
source setToFaceZone;
faceSet f0; // name of faceSet
}
//- Select based on faceSet, using cellSet to determine orientation
{
source setsToFaceZone;
faceSet f0; // name of faceSet
cellSet c0; // name of cellSet of slave side
flip false; // optional: flip the faceZone (so now the cellSet
// is the master side)
}
}
// pointZoneSet
// ~~~~~~~~~~~~
// Manipulates a pointZone (as well as a pointSet)
// Takes any pointSet source. The difference with a pointSet is
// - reads the cells from the pointZone, not the pointSet
// - write to the pointZone as well as the pointSet
pointZoneSet_doc
{
// For backwards compatibility
//- Select based on pointSet
{
source setToPointZone;
set p0; // name of pointSet
}
}
// ************************************************************************* //