Commit 9cde05b1 authored by Mark Olesen's avatar Mark Olesen
Browse files

Merge commit 'OpenCFD/master' into olesenm

Resolved conflicts:
	src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C
	src/OpenFOAM/interpolations/interpolationTable/interpolationTable.H
parents 21f54116 15cad22d
......@@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 OpenCFD Ltd.
\\ / A nd | Copyright (C) 1991-2007 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
......@@ -33,12 +33,86 @@ Description
#include "argList.H"
#include "Time.H"
#include "fvMesh.H"
#include "autoHexMeshDriver.H"
#include "autoRefineDriver.H"
#include "autoSnapDriver.H"
#include "autoLayerDriver.H"
#include "searchableSurfaces.H"
#include "refinementSurfaces.H"
#include "shellSurfaces.H"
#include "decompositionMethod.H"
#include "fvMeshDistribute.H"
#include "wallPolyPatch.H"
#include "refinementParameters.H"
#include "snapParameters.H"
#include "layerParameters.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Check writing tolerance before doing any serious work
scalar getMergeDistance(const polyMesh& mesh, const scalar mergeTol)
{
const boundBox& meshBb = mesh.bounds();
scalar mergeDist = mergeTol*mag(meshBb.max() - meshBb.min());
scalar writeTol = std::pow
(
scalar(10.0),
-scalar(IOstream::defaultPrecision())
);
Info<< nl
<< "Overall mesh bounding box : " << meshBb << nl
<< "Relative tolerance : " << mergeTol << nl
<< "Absolute matching distance : " << mergeDist << nl
<< endl;
if (mesh.time().writeFormat() == IOstream::ASCII && mergeTol < writeTol)
{
FatalErrorIn("getMergeDistance(const polyMesh&, const scalar)")
<< "Your current settings specify ASCII writing with "
<< IOstream::defaultPrecision() << " digits precision." << endl
<< "Your merging tolerance (" << mergeTol << ") is finer than this."
<< endl
<< "Please change your writeFormat to binary"
<< " or increase the writePrecision" << endl
<< "or adjust the merge tolerance (-mergeTol)."
<< exit(FatalError);
}
return mergeDist;
}
// Write mesh and additional information
void writeMesh
(
const string& msg,
const meshRefinement& meshRefiner,
const label debug
)
{
const fvMesh& mesh = meshRefiner.mesh();
meshRefiner.printMeshInfo(debug, msg);
Info<< "Writing mesh to time " << mesh.time().timeName() << endl;
meshRefiner.write(meshRefinement::MESH|meshRefinement::SCALARLEVELS, "");
if (debug & meshRefinement::OBJINTERSECTIONS)
{
meshRefiner.write
(
meshRefinement::OBJINTERSECTIONS,
mesh.time().path()/mesh.time().timeName()
);
}
Info<< "Written mesh in = "
<< mesh.time().cpuTimeIncrement() << " s." << endl;
}
int main(int argc, char *argv[])
{
# include "setRootCase.H"
......@@ -49,6 +123,11 @@ int main(int argc, char *argv[])
Info<< "Read mesh in = "
<< runTime.cpuTimeIncrement() << " s" << endl;
// Check patches and faceZones are synchronised
mesh.boundaryMesh().checkParallelSync(true);
meshRefinement::checkCoupledFaceZones(mesh);
// Read decomposePar dictionary
IOdictionary decomposeDict
(
......@@ -75,47 +154,282 @@ int main(int argc, char *argv[])
)
);
// refinement parameters
const dictionary& refineDict = meshDict.subDict("refineDict");
// all surface geometry
const dictionary& geometryDict = meshDict.subDict("geometry");
// snap-to-surface parameters
const dictionary& snapDict = meshDict.subDict("snapDict");
// refinement parameters
const dictionary& refineDict = meshDict.subDict("castellatedMeshControls");
// mesh motion and mesh quality parameters
const dictionary& motionDict = meshDict.subDict("motionDict");
const dictionary& motionDict = meshDict.subDict("meshQualityControls");
// snap-to-surface parameters
const dictionary& snapDict = meshDict.subDict("snapControls");
// layer addition parameters
const dictionary& layerDict = meshDict.subDict("layerDict");
const dictionary& layerDict = meshDict.subDict("addLayersControls");
// Debug
// ~~~~~
const label debug(readLabel(meshDict.lookup("debug")));
if (debug > 0)
{
meshRefinement::debug = debug;
autoRefineDriver::debug = debug;
autoSnapDriver::debug = debug;
autoLayerDriver::debug = debug;
}
// Read geometry
// ~~~~~~~~~~~~~
searchableSurfaces allGeometry
(
IOobject
(
"abc", // dummy name
mesh.time().constant(), // directory
"triSurface", // instance
mesh.time(), // registry
IOobject::MUST_READ,
IOobject::NO_WRITE
),
geometryDict
);
// Read refinement surfaces
// ~~~~~~~~~~~~~~~~~~~~~~~~
Info<< "Reading refinement surfaces." << endl;
refinementSurfaces surfaces
(
allGeometry,
refineDict.subDict("refinementSurfaces")
);
Info<< "Read refinement surfaces in = "
<< mesh.time().cpuTimeIncrement() << " s" << nl << endl;
// Read refinement shells
// ~~~~~~~~~~~~~~~~~~~~~~
Info<< "Reading refinement shells." << endl;
shellSurfaces shells
(
allGeometry,
refineDict.subDict("refinementRegions")
);
Info<< "Read refinement shells in = "
<< mesh.time().cpuTimeIncrement() << " s" << nl << endl;
Info<< "Setting refinement level of surface to be consistent"
<< " with shells." << endl;
surfaces.setMinLevelFields(shells);
Info<< "Checked shell refinement in = "
<< mesh.time().cpuTimeIncrement() << " s" << nl << endl;
// Main meshing driver. Read surfaces. Determine initial intersections.
autoHexMeshDriver meshEngine
// Add all the surface regions as patches
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
labelList globalToPatch;
{
Info<< nl
<< "Adding patches for surface regions" << nl
<< "----------------------------------" << nl
<< endl;
// From global region number to mesh patch.
globalToPatch.setSize(surfaces.nRegions(), -1);
Info<< "Patch\tRegion" << nl
<< "-----\t------"
<< endl;
const labelList& surfaceGeometry = surfaces.surfaces();
forAll(surfaceGeometry, surfI)
{
label geomI = surfaceGeometry[surfI];
const wordList& regNames = allGeometry.regionNames()[geomI];
Info<< surfaces.names()[surfI] << ':' << nl << nl;
forAll(regNames, i)
{
label patchI = meshRefinement::addPatch
(
mesh,
regNames[i],
wallPolyPatch::typeName
);
Info<< patchI << '\t' << regNames[i] << nl;
globalToPatch[surfaces.globalRegion(surfI, i)] = patchI;
}
Info<< nl;
}
Info<< "Added patches in = "
<< mesh.time().cpuTimeIncrement() << " s" << nl << endl;
}
// Parallel
// ~~~~~~~~
// Decomposition
autoPtr<decompositionMethod> decomposerPtr
(
decompositionMethod::New
(
decomposeDict,
mesh
)
);
decompositionMethod& decomposer = decomposerPtr();
if (Pstream::parRun() && !decomposer.parallelAware())
{
FatalErrorIn(args.executable())
<< "You have selected decomposition method "
<< decomposer.typeName
<< " which is not parallel aware." << endl
<< "Please select one that is (hierarchical, parMetis)"
<< exit(FatalError);
}
const scalar mergeDist = getMergeDistance
(
mesh,
meshDict, // global control parameters
refineDict, // refinement parameters
decomposeDict
readScalar(meshDict.lookup("mergeTolerance"))
);
Switch wantRefine(meshDict.lookup("doRefine"));
Switch wantSnap(meshDict.lookup("doSnap"));
Switch wantLayers(meshDict.lookup("doLayers"));
// Mesh distribution engine (uses tolerance to reconstruct meshes)
fvMeshDistribute distributor(mesh, mergeDist);
// Refinement engine
// ~~~~~~~~~~~~~~~~~
Info<< nl
<< "Determining initial surface intersections" << nl
<< "-----------------------------------------" << nl
<< endl;
// Main refinement engine
meshRefinement meshRefiner
(
mesh,
mergeDist, // tolerance used in sorting coordinates
surfaces, // for surface intersection refinement
shells // for volume (inside/outside) refinement
);
Info<< "Calculated surface intersections in = "
<< mesh.time().cpuTimeIncrement() << " s" << nl << endl;
// Some stats
meshRefiner.printMeshInfo(debug, "Initial mesh");
meshRefiner.write
(
debug&meshRefinement::OBJINTERSECTIONS,
mesh.time().path()/mesh.time().timeName()
);
// Now do the real work -refinement -snapping -layers
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Switch wantRefine(meshDict.lookup("castellatedMesh"));
Switch wantSnap(meshDict.lookup("snap"));
Switch wantLayers(meshDict.lookup("addLayers"));
if (wantRefine)
{
meshEngine.doRefine(refineDict, wantSnap);
autoRefineDriver refineDriver
(
meshRefiner,
decomposer,
distributor,
globalToPatch
);
// Refinement parameters
refinementParameters refineParams(refineDict);
refineDriver.doRefine(refineDict, refineParams, wantSnap);
writeMesh
(
"Refined mesh",
meshRefiner,
debug
);
}
if (wantSnap)
{
meshEngine.doSnap(snapDict, motionDict);
autoSnapDriver snapDriver
(
meshRefiner,
globalToPatch
);
// Snap parameters
snapParameters snapParams(snapDict);
snapDriver.doSnap(snapDict, motionDict, snapParams);
writeMesh
(
"Snapped mesh",
meshRefiner,
debug
);
}
if (wantLayers)
{
meshEngine.doLayers(layerDict, motionDict);
autoLayerDriver layerDriver
(
meshRefiner,
globalToPatch
);
// Layer addition parameters
layerParameters layerParams(layerDict, mesh.boundaryMesh());
layerDriver.doLayers
(
layerDict,
motionDict,
layerParams,
decomposer,
distributor
);
writeMesh
(
"Layer mesh",
meshRefiner,
debug
);
}
Info<< "Finished meshing in = "
<< runTime.elapsedCpuTime() << " s." << endl;
......
......@@ -22,161 +22,171 @@ FoamFile
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Which phases to run.
doRefine true;
doSnap true;
doLayers true; // includes autoMergeFaces
// Which of the steps to run
castellatedMesh true;
snap true;
addLayers false;
// Geometry. Definition of all surfaces. All surfaces are of class
// searchableSurface.
// Surfaces are used
// - to specify refinement for any mesh cell intersecting it
// - to specify refinement for any mesh cell inside/outside/near
// - to 'snap' the mesh boundary to the surface
geometry
{
box1x1x1
{
type searchableBox;
min (1.5 1 -0.5);
max (3.5 2 0.5);
}
sphere.stl
{
type triSurfaceMesh;
// Per region the patchname. If not provided will be <name>_<region>.
regions
{
secondSolid
{
name mySecondPatch;
}
}
}
sphere2
{
type searchableSphere;
centre (1.5 1.5 1.5);
radius 1.03;
}
};
// Whether to dump intermediate meshes and print lots
// 1 : write mesh
// 2 : write volScalarField with cellLevel for postprocessing
// 4 : write current intersections as .obj files
debug 0;
refineDict
{
// Which part to keep.
// NOTE: This point should never be on a face, always inside a cell, even
// after refinement.
keepPoints ((3 0.28 0.43));
// Whether to remove/split cells likely to give problems when snapping
handleSnapProblems on;
// Settings for the castellatedMesh generation.
castellatedMeshControls
{
// Merge tolerance. Is fraction of overall bounding box of initial mesh
mergeTolerance 1E-6;
// Refinement parameters
// ~~~~~~~~~~~~~~~~~~~~~
// While refining maximum number of cells per processor. This is basically
// the number of cells that fit on a processor. If you choose this too small
// it will do just more refinement iterations to obtain a similar mesh.
procCellLimit 1000000;
maxLocalCells 1000000;
// 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.
cellLimit 2000000;
// 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 <= minimumRefine
// are selected for refinement. Note: it will at least do one iteration
// (unless the number of cells to refine is 0)
minimumRefine 0;
minRefinementCells 0;
// Number of buffer layers between different levels.
// 1 means normal 2:1 refinement restriction, larger means slower
// refinement.
nBufferLayers 1;
nCellsBetweenLevels 1;
// Feature Edge Refinement
// ~~~~~~~~~~~~~~~~~~~~~~~
// External feature file. Read from constant/triSurface for now.
// Limitations:
// - either start or edge of any feature line has to be inside domain
// and be visible from keepPoint on starting mesh.
// - refining cells containing features is separate phase before refining
// based on surface.
// - no load balancing, no check for cellLimit is done while doing this.
// 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 "someLine.eMesh";
// level 2;
// }
//{
// file "someLine.eMesh";
// level 2;
//}
);
// Internal Mesh Refinement
// Surface based refinement
// ~~~~~~~~~~~~~~~~~~~~~~~~
// Specifies the areas where the refinement has to be a certain level.
// These surfaces have to be closed. Refinement is either inside
// (refineInside = true) or outside. (note:insideness or outsideness
// is with respect to far away)
// Note:that even using these the transition can never be faster than
// nBufferLayers!
// Note:the refinement level can never be higher than any of the surfaces
// they overlap with. See below for the surface refinement level specification.
refinementShells
(
// 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
{
//type triSurfaceMesh;
//name cube1x1x1.stl;
type searchableBox;
name box1x1x1;
min (2.5 -0.5 -0.5);
max (3.5 0.5 0.5);
level 4;
refineInside true;
// Surface-wise min and max refinement level
level (2 2);
// Optional region-wise level specification
regions
{
secondSolid
{
level (3 3);
}
}
}
);
}
resolveFeatureAngle 30;
// Surface based refinement
// ~~~~~~~~~~~~~~~~~~~~~~~~