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

Merge branch 'master' of /home/dm4/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
sergio
2012-11-01 17:48:11 +00:00
parent 708743752a ccc801b6f4
commit ea2a6e7f95
10 changed files with 902 additions and 497 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
applications/solvers/combustion/chemFoam/chemFoam.C
View File

@ -69,14 +69,9 @@ int main(int argc, char *argv[])
Info<< "Time = " << runTime.timeName() << nl << endl; Info<< "Time = " << runTime.timeName() << nl << endl;
#include "solveChemistry.H" #include "solveChemistry.H"
#include "YEqn.H"
{ #include "hEqn.H"
#include "YEqn.H" #include "pEqn.H"
#include "hEqn.H"
#include "pEqn.H"
}
#include "output.H" #include "output.H"

2
applications/solvers/combustion/chemFoam/hEqn.H
View File

@ -9,4 +9,6 @@
{ {
h[0] = h0 + integratedHeat; h[0] = h0 + integratedHeat;
} }
thermo.correct();
} }

1
applications/solvers/combustion/chemFoam/pEqn.H
View File

@ -1,5 +1,4 @@
{ {
thermo.correct();
rho = thermo.rho(); rho = thermo.rho();
if (constProp == "volume") if (constProp == "volume")
{ {

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

@ -226,37 +226,37 @@ castellatedMeshControls
// Settings for the snapping. // Settings for the snapping.
snapControls snapControls
{ {
//- Number of patch smoothing iterations before finding correspondence // Number of patch smoothing iterations before finding correspondence
// to surface // to surface
nSmoothPatch 3; nSmoothPatch 3;
//- Maximum relative distance for points to be attracted by surface. // Maximum relative distance for points to be attracted by surface.
// True distance is this factor times local maximum edge length. // True distance is this factor times local maximum edge length.
// Note: changed(corrected) w.r.t 17x! (17x used 2* tolerance) // Note: changed(corrected) w.r.t 17x! (17x used 2* tolerance)
tolerance 2.0; tolerance 2.0;
//- Number of mesh displacement relaxation iterations. // Number of mesh displacement relaxation iterations.
nSolveIter 30; nSolveIter 30;
//- Maximum number of snapping relaxation iterations. Should stop // Maximum number of snapping relaxation iterations. Should stop
// before upon reaching a correct mesh. // before upon reaching a correct mesh.
nRelaxIter 5; nRelaxIter 5;
// Feature snapping // Feature snapping
//- Number of feature edge snapping iterations. // Number of feature edge snapping iterations.
// Leave out altogether to disable. // Leave out altogether to disable.
nFeatureSnapIter 10; nFeatureSnapIter 10;
//- Detect (geometric only) features by sampling the surface // Detect (geometric only) features by sampling the surface
// (default=false). // (default=false).
implicitFeatureSnap false; implicitFeatureSnap false;
//- Use castellatedMeshControls::features (default = true) // Use castellatedMeshControls::features (default = true)
explicitFeatureSnap true; explicitFeatureSnap true;
//- Detect features between multiple surfaces // Detect features between multiple surfaces
// (only for explicitFeatureSnap, default = false) // (only for explicitFeatureSnap, default = false)
multiRegionFeatureSnap false; multiRegionFeatureSnap false;
} }
@ -267,9 +267,43 @@ addLayersControls
// size of the refined cell outside layer (true) or absolute sizes (false). // size of the refined cell outside layer (true) or absolute sizes (false).
relativeSizes true; relativeSizes true;
// Layer thickness specification. This can be specified in one of four ways
// - expansionRatio and finalLayerThickness (cell nearest internal mesh)
// - expansionRatio and firstLayerThickness (cell on surface)
// - overall thickness and firstLayerThickness
// - overall thickness and finalLayerThickness
// 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.25;
// Per final patch (so not geometry!) the layer information // Per final patch (so not geometry!) the layer information
// Note: This behaviour changed after 21x. Any non-mentioned patches // Note: This behaviour changed after 21x. Any non-mentioned patches
// now slide unless nSurfaceLayers is explicitly mentioned to be 0. // now slide unless:
// - nSurfaceLayers is explicitly mentioned to be 0.
// - angle to nearest surface < slipFeatureAngle (see below)
layers layers
{ {
sphere.stl_firstSolid sphere.stl_firstSolid
@ -281,9 +315,9 @@ addLayersControls
{ {
nSurfaceLayers 1; nSurfaceLayers 1;
// Per patch layer data // Per patch layer data
expansionRatio 1.3; expansionRatio 1.3;
finalLayerThickness 0.3; finalLayerThickness 0.3;
minThickness 0.1; minThickness 0.1;
} }
// Disable any mesh shrinking and layer addition on any point of // Disable any mesh shrinking and layer addition on any point of
@ -294,41 +328,24 @@ addLayersControls
} }
} }
// Expansion factor for layer mesh // If points get not extruded do nGrow layers of connected faces that are
expansionRatio 1.0; // also not grown. This helps convergence of the layer addition process
// close to features.
//- Wanted thickness of final added cell layer. If multiple layers
// is the
// thickness of the layer furthest away from the wall.
// Relative to undistorted size of cell outside layer.
// is the thickness of the layer furthest away from the wall.
// See relativeSizes parameter.
finalLayerThickness 0.3;
//- Minimum thickness of cell layer. If for any reason layer
// cannot be above minThickness do not add layer.
// Relative to undistorted size of cell outside layer.
// See relativeSizes parameter.
minThickness 0.25;
//- If points get not extruded do nGrow layers of connected faces that are
// also not grown. This helps convergence of the layer addition process
// close to features.
// Note: changed(corrected) w.r.t 17x! (didn't do anything in 17x) // Note: changed(corrected) w.r.t 17x! (didn't do anything in 17x)
nGrow 0; nGrow 0;
// Advanced settings // Advanced settings
//- When not to extrude surface. 0 is flat surface, 90 is when two faces // When not to extrude surface. 0 is flat surface, 90 is when two faces
// make straight angle. // make straight angle.
featureAngle 60; featureAngle 60;
//- At non-patched sides allow mesh to slip if extrusion direction makes // At non-patched sides allow mesh to slip if extrusion direction makes
// angle larger than slipFeatureAngle. // angle larger than slipFeatureAngle.
slipFeatureAngle 30; slipFeatureAngle 30;
//- Maximum number of snapping relaxation iterations. Should stop // Maximum number of snapping relaxation iterations. Should stop
// before upon reaching a correct mesh. // before upon reaching a correct mesh.
nRelaxIter 5; nRelaxIter 5;
// Number of smoothing iterations of surface normals // Number of smoothing iterations of surface normals
@ -374,51 +391,51 @@ addLayersControls
// where to undo. // where to undo.
meshQualityControls meshQualityControls
{ {
//- Maximum non-orthogonality allowed. Set to 180 to disable. // Maximum non-orthogonality allowed. Set to 180 to disable.
maxNonOrtho 65; maxNonOrtho 65;
//- Max skewness allowed. Set to <0 to disable. // Max skewness allowed. Set to <0 to disable.
maxBoundarySkewness 20; maxBoundarySkewness 20;
maxInternalSkewness 4; maxInternalSkewness 4;
//- Max concaveness allowed. Is angle (in degrees) below which concavity // Max concaveness allowed. Is angle (in degrees) below which concavity
// is allowed. 0 is straight face, <0 would be convex face. // is allowed. 0 is straight face, <0 would be convex face.
// Set to 180 to disable. // Set to 180 to disable.
maxConcave 80; maxConcave 80;
//- Minimum pyramid volume. Is absolute volume of cell pyramid. // Minimum pyramid volume. Is absolute volume of cell pyramid.
// Set to a sensible fraction of the smallest cell volume expected. // Set to a sensible fraction of the smallest cell volume expected.
// Set to very negative number (e.g. -1E30) to disable. // Set to very negative number (e.g. -1E30) to disable.
minVol 1e-13; minVol 1e-13;
//- Minimum quality of the tet formed by the face-centre // Minimum quality of the tet formed by the face-centre
// and variable base point minimum decomposition triangles and // and variable base point minimum decomposition triangles and
// the cell centre. This has to be a positive number for tracking // the cell centre. This has to be a positive number for tracking
// to work. Set to very negative number (e.g. -1E30) to // to work. Set to very negative number (e.g. -1E30) to
// disable. // disable.
// <0 = inside out tet, // <0 = inside out tet,
// 0 = flat tet // 0 = flat tet
// 1 = regular tet // 1 = regular tet
minTetQuality 1e-9; minTetQuality 1e-9;
//- Minimum face area. Set to <0 to disable. // Minimum face area. Set to <0 to disable.
minArea -1; minArea -1;
//- Minimum face twist. Set to <-1 to disable. dot product of face normal // Minimum face twist. Set to <-1 to disable. dot product of face normal
//- and face centre triangles normal // and face centre triangles normal
minTwist 0.05; minTwist 0.05;
//- minimum normalised cell determinant // minimum normalised cell determinant
//- 1 = hex, <= 0 = folded or flattened illegal cell // 1 = hex, <= 0 = folded or flattened illegal cell
minDeterminant 0.001; minDeterminant 0.001;
//- minFaceWeight (0 -> 0.5) // minFaceWeight (0 -> 0.5)
minFaceWeight 0.05; minFaceWeight 0.05;
//- minVolRatio (0 -> 1) // minVolRatio (0 -> 1)
minVolRatio 0.01; minVolRatio 0.01;
//must be >0 for Fluent compatibility // must be >0 for Fluent compatibility
minTriangleTwist -1; minTriangleTwist -1;
//- if >0 : preserve single cells with all points on the surface if the //- if >0 : preserve single cells with all points on the surface if the
@ -429,9 +446,9 @@ meshQualityControls
// Advanced // Advanced
//- Number of error distribution iterations // Number of error distribution iterations
nSmoothScale 4; nSmoothScale 4;
//- amount to scale back displacement at error points // amount to scale back displacement at error points
errorReduction 0.75; errorReduction 0.75;
// Optional : some meshing phases allow usage of relaxed rules. // Optional : some meshing phases allow usage of relaxed rules.

11
applications/utilities/postProcessing/sampling/sample/sampleDict
View File

@ -90,6 +90,8 @@ fields
// uniform: extra number of sampling points // uniform: extra number of sampling points
// polyLine, cloud: list of coordinates // polyLine, cloud: list of coordinates
// patchCloud: list of coordinates and set of patches to look for nearest // patchCloud: list of coordinates and set of patches to look for nearest
// patchSeed: random sampling on set of patches. Points slightly off
// face centre.
sets sets
( (
lineX1 lineX1
@ -135,6 +137,15 @@ sets
maxDistance 0.1; // maximum distance to search maxDistance 0.1; // maximum distance to search
patches (".*Wall.*"); patches (".*Wall.*");
} }
patchSeed
{
patches (".*Wall.*");
// Number of points to seed. Divided amongst all processors according
// to fraction of patches they hold.
maxPoints 100;
}
); );

414
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
View File

@ -318,7 +318,6 @@ void Foam::autoLayerDriver::handleNonManifolds
} }
} }
Info<< "Set displacement to zero for all " << nNonManif Info<< "Set displacement to zero for all " << nNonManif
<< " non-manifold points" << endl; << " non-manifold points" << endl;
} }
@ -443,86 +442,6 @@ void Foam::autoLayerDriver::handleFeatureAngle
} }
//Foam::tmp<Foam::scalarField> Foam::autoLayerDriver::undistortedEdgeLength
//(
// const indirectPrimitivePatch& pp,
// const bool relativeSizes,
// const bool faceSize
//)
//{
// const fvMesh& mesh = meshRefiner_.mesh();
//
// tmp<scalarField> tfld(new scalarField());
// scalarField& fld = tfld();
//
// if (faceSize)
// {
// fld.setSize(pp.size());
// }
// else
// {
// fld.setSize(pp.nPoints());
// }
//
//
// if (relativeSizes)
// {
// const scalar edge0Len = meshRefiner_.meshCutter().level0EdgeLength();
// const labelList& cellLevel = meshRefiner_.meshCutter().cellLevel();
//
// if (faceSize)
// {
// forAll(pp, i)
// {
// label faceI = pp.addressing()[i];
// label ownLevel = cellLevel[mesh.faceOwner()[faceI]];
// fld[i] = edge0Len/(1<<ownLevel);
// }
// }
// else
// {
// // Determine per point the max cell level of connected cells
// // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// labelList maxPointLevel(pp.nPoints(), labelMin);
//
// forAll(pp, i)
// {
// label faceI = pp.addressing()[i];
// label ownLevel = cellLevel[mesh.faceOwner()[faceI]];
//
// const face& f = pp.localFaces()[i];
// forAll(f, fp)
// {
// maxPointLevel[f[fp]] =
// max(maxPointLevel[f[fp]], ownLevel);
// }
// }
//
// syncTools::syncPointList
// (
// mesh,
// pp.meshPoints(),
// maxPointLevel,
// maxEqOp<label>(),
// labelMin // null value
// );
//
//
// forAll(maxPointLevel, pointI)
// {
// // Find undistorted edge size for this level.
// fld[i] = edge0Len/(1<<maxPointLevel[pointI]);
// }
// }
// }
// else
// {
// // Use actual cell size
// }
//}
// No extrusion on cells with warped faces. Calculates the thickness of the // No extrusion on cells with warped faces. Calculates the thickness of the
// layer and compares it to the space the warped face takes up. Disables // layer and compares it to the space the warped face takes up. Disables
// extrusion if layer thickness is more than faceRatio of the thickness of // extrusion if layer thickness is more than faceRatio of the thickness of
@ -702,7 +621,6 @@ void Foam::autoLayerDriver::handleWarpedFaces
//} //}
// No extrusion on faces with differing number of layers for points
void Foam::autoLayerDriver::setNumLayers void Foam::autoLayerDriver::setNumLayers
( (
const labelList& patchToNLayers, const labelList& patchToNLayers,
@ -865,15 +783,6 @@ Foam::autoLayerDriver::makeLayerDisplacementField
} }
//Pout<< "*** makeLayerDisplacementField : boundary conditions:" << endl;
//forAll(patchFieldTypes, patchI)
//{
// Pout<< "\t" << patchI << " name:" << pointPatches[patchI].name()
// << " type:" << patchFieldTypes[patchI]
// << " nLayers:" << numLayers[patchI]
// << endl;
//}
const polyMesh& mesh = pMesh(); const polyMesh& mesh = pMesh();
// Note: time().timeName() instead of meshRefinement::timeName() since // Note: time().timeName() instead of meshRefinement::timeName() since
@ -1053,11 +962,10 @@ void Foam::autoLayerDriver::determineSidePatches
patchDict.add("nFaces", 0); patchDict.add("nFaces", 0);
patchDict.add("startFace", mesh.nFaces()); patchDict.add("startFace", mesh.nFaces());
Pout<< "Adding patch " << patchI //Pout<< "Adding patch " << patchI
<< " name:" << name // << " name:" << name
<< " between " << Pstream::myProcNo() // << " between " << Pstream::myProcNo()
<< " and " << nbrProcI // << " and " << nbrProcI << endl;
<< endl;
label procPatchI = meshRefiner_.appendPatch label procPatchI = meshRefiner_.appendPatch
( (
@ -1090,12 +998,7 @@ void Foam::autoLayerDriver::calculateLayerThickness
( (
const indirectPrimitivePatch& pp, const indirectPrimitivePatch& pp,
const labelList& patchIDs, const labelList& patchIDs,
const scalarField& patchExpansionRatio, const layerParameters& layerParams,
const bool relativeSizes,
const scalarField& patchFinalLayerThickness,
const scalarField& patchMinThickness,
const labelList& cellLevel, const labelList& cellLevel,
const labelList& patchNLayers, const labelList& patchNLayers,
const scalar edge0Len, const scalar edge0Len,
@ -1111,12 +1014,13 @@ void Foam::autoLayerDriver::calculateLayerThickness
// Rework patch-wise layer parameters into minimum per point // Rework patch-wise layer parameters into minimum per point
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Note: only layer parameters consistent with layer specification
// method (see layerParameters) will be correct.
scalarField firstLayerThickness(pp.nPoints(), GREAT);
scalarField finalLayerThickness(pp.nPoints(), GREAT);
scalarField totalThickness(pp.nPoints(), GREAT);
scalarField expRatio(pp.nPoints(), GREAT);
// Reuse input fields
expansionRatio.setSize(pp.nPoints());
expansionRatio = GREAT;
thickness.setSize(pp.nPoints());
thickness = GREAT;
minThickness.setSize(pp.nPoints()); minThickness.setSize(pp.nPoints());
minThickness = GREAT; minThickness = GREAT;
@ -1130,20 +1034,30 @@ void Foam::autoLayerDriver::calculateLayerThickness
{ {
label ppPointI = pp.meshPointMap()[meshPoints[patchPointI]]; label ppPointI = pp.meshPointMap()[meshPoints[patchPointI]];
expansionRatio[ppPointI] = min firstLayerThickness[ppPointI] = min
( (
expansionRatio[ppPointI], firstLayerThickness[ppPointI],
patchExpansionRatio[patchI] layerParams.firstLayerThickness()[patchI]
); );
thickness[ppPointI] = min finalLayerThickness[ppPointI] = min
( (
thickness[ppPointI], finalLayerThickness[ppPointI],
patchFinalLayerThickness[patchI] layerParams.finalLayerThickness()[patchI]
);
totalThickness[ppPointI] = min
(
totalThickness[ppPointI],
layerParams.thickness()[patchI]
);
expRatio[ppPointI] = min
(
expRatio[ppPointI],
layerParams.expansionRatio()[patchI]
); );
minThickness[ppPointI] = min minThickness[ppPointI] = min
( (
minThickness[ppPointI], minThickness[ppPointI],
patchMinThickness[patchI] layerParams.minThickness()[patchI]
); );
} }
} }
@ -1152,7 +1066,7 @@ void Foam::autoLayerDriver::calculateLayerThickness
( (
mesh, mesh,
pp.meshPoints(), pp.meshPoints(),
expansionRatio, firstLayerThickness,
minEqOp<scalar>(), minEqOp<scalar>(),
GREAT // null value GREAT // null value
); );
@ -1160,7 +1074,23 @@ void Foam::autoLayerDriver::calculateLayerThickness
( (
mesh, mesh,
pp.meshPoints(), pp.meshPoints(),
thickness, finalLayerThickness,
minEqOp<scalar>(),
GREAT // null value
);
syncTools::syncPointList
(
mesh,
pp.meshPoints(),
totalThickness,
minEqOp<scalar>(),
GREAT // null value
);
syncTools::syncPointList
(
mesh,
pp.meshPoints(),
expRatio,
minEqOp<scalar>(), minEqOp<scalar>(),
GREAT // null value GREAT // null value
); );
@ -1182,14 +1112,18 @@ void Foam::autoLayerDriver::calculateLayerThickness
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// by multiplying with the internal cell size. // by multiplying with the internal cell size.
if (relativeSizes) if (layerParams.relativeSizes())
{ {
if (min(patchMinThickness) < 0 || max(patchMinThickness) > 2) if
(
min(layerParams.minThickness()) < 0
|| max(layerParams.minThickness()) > 2
)
{ {
FatalErrorIn("calculateLayerThickness(..)") FatalErrorIn("calculateLayerThickness(..)")
<< "Thickness should be factor of local undistorted cell size." << "Thickness should be factor of local undistorted cell size."
<< " Valid values are [0..2]." << nl << " Valid values are [0..2]." << nl
<< " minThickness:" << patchMinThickness << " minThickness:" << layerParams.minThickness()
<< exit(FatalError); << exit(FatalError);
} }
@ -1225,38 +1159,114 @@ void Foam::autoLayerDriver::calculateLayerThickness
{ {
// Find undistorted edge size for this level. // Find undistorted edge size for this level.
scalar edgeLen = edge0Len/(1<<maxPointLevel[pointI]); scalar edgeLen = edge0Len/(1<<maxPointLevel[pointI]);
thickness[pointI] *= edgeLen; firstLayerThickness[pointI] *= edgeLen;
finalLayerThickness[pointI] *= edgeLen;
totalThickness[pointI] *= edgeLen;
minThickness[pointI] *= edgeLen; minThickness[pointI] *= edgeLen;
} }
} }
// Rework thickness (of final layer) into overall thickness of all layers // Rework thickness parameters into overall thickness
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
forAll(thickness, pointI) forAll(firstLayerThickness, pointI)
{ {
// Calculate layer thickness based on expansion ratio thickness[pointI] = layerParams.layerThickness
// and final layer height (
if (expansionRatio[pointI] == 1) patchNLayers[pointI],
{ firstLayerThickness[pointI],
thickness[pointI] *= patchNLayers[pointI]; finalLayerThickness[pointI],
} totalThickness[pointI],
else expRatio[pointI]
{ );
scalar invExpansion = 1.0 / expansionRatio[pointI]; expansionRatio[pointI] = layerParams.layerExpansionRatio
label nLay = patchNLayers[pointI]; (
thickness[pointI] *= patchNLayers[pointI],
(1.0 - pow(invExpansion, nLay)) firstLayerThickness[pointI],
/ (1.0 - invExpansion); finalLayerThickness[pointI],
} totalThickness[pointI],
expRatio[pointI]
);
} }
//Info<< "calculateLayerThickness : min:" << gMin(thickness) //Info<< "calculateLayerThickness : min:" << gMin(thickness)
// << " max:" << gMax(thickness) << endl; // << " max:" << gMax(thickness) << endl;
// Print a bit
{
const polyBoundaryMesh& patches = mesh.boundaryMesh();
// Find maximum length of a patch name, for a nicer output
label maxPatchNameLen = 0;
forAll(patchIDs, i)
{
label patchI = patchIDs[i];
word patchName = patches[patchI].name();
maxPatchNameLen = max(maxPatchNameLen, label(patchName.size()));
}
Info<< nl
<< setf(ios_base::left) << setw(maxPatchNameLen) << "patch"
<< setw(0) << " faces layers avg thickness[m]" << nl
<< setf(ios_base::left) << setw(maxPatchNameLen) << " "
<< setw(0) << " near-wall overall" << nl
<< setf(ios_base::left) << setw(maxPatchNameLen) << "-----"
<< setw(0) << " ----- ------ --------- -------" << endl;
forAll(patchIDs, i)
{
label patchI = patchIDs[i];
const labelList& meshPoints = patches[patchI].meshPoints();
scalar sumThickness = 0;
scalar sumNearWallThickness = 0;
forAll(meshPoints, patchPointI)
{
label ppPointI = pp.meshPointMap()[meshPoints[patchPointI]];
sumThickness += thickness[ppPointI];
sumNearWallThickness += layerParams.firstLayerThickness
(
patchNLayers[ppPointI],
firstLayerThickness[ppPointI],
finalLayerThickness[ppPointI],
thickness[ppPointI],
expansionRatio[ppPointI]
);
}
label totNPoints = returnReduce(meshPoints.size(), sumOp<label>());
// For empty patches, totNPoints is 0.
scalar avgThickness = 0;
scalar avgNearWallThickness = 0;
if (totNPoints > 0)
{
avgThickness =
returnReduce(sumThickness, sumOp<scalar>())
/ totNPoints;
avgNearWallThickness =
returnReduce(sumNearWallThickness, sumOp<scalar>())
/ totNPoints;
}
Info<< setf(ios_base::left) << setw(maxPatchNameLen)
<< patches[patchI].name() << setprecision(3)
<< " " << setw(8)
<< returnReduce(patches[patchI].size(), sumOp<scalar>())
<< " " << setw(6) << layerParams.numLayers()[patchI]
<< " " << setw(8) << avgNearWallThickness
<< " " << setw(8) << avgThickness
<< endl;
}
Info<< endl;
}
} }
@ -2618,7 +2628,8 @@ void Foam::autoLayerDriver::addLayers
const scalar edge0Len = meshRefiner_.meshCutter().level0EdgeLength(); const scalar edge0Len = meshRefiner_.meshCutter().level0EdgeLength();
const labelList& cellLevel = meshRefiner_.meshCutter().cellLevel(); const labelList& cellLevel = meshRefiner_.meshCutter().cellLevel();
// Determine (wanted) point-wise layer thickness and expansion ratio // Determine (wanted) point-wise overall layer thickness and expansion
// ratio
scalarField thickness(pp().nPoints()); scalarField thickness(pp().nPoints());
scalarField minThickness(pp().nPoints()); scalarField minThickness(pp().nPoints());
scalarField expansionRatio(pp().nPoints()); scalarField expansionRatio(pp().nPoints());
@ -2626,12 +2637,7 @@ void Foam::autoLayerDriver::addLayers
( (
pp, pp,
meshMover().adaptPatchIDs(), meshMover().adaptPatchIDs(),
layerParams.expansionRatio(), layerParams,
layerParams.relativeSizes(), // thickness relative to cellsize?
layerParams.finalLayerThickness(), // wanted thicknes
layerParams.minThickness(), // minimum thickness
cellLevel, cellLevel,
patchNLayers, patchNLayers,
edge0Len, edge0Len,
@ -2642,87 +2648,6 @@ void Foam::autoLayerDriver::addLayers
); );
// Print a bit
{
const polyBoundaryMesh& patches = mesh.boundaryMesh();
// Find maximum length of a patch name, for a nicer output
label maxPatchNameLen = 0;
forAll(meshMover().adaptPatchIDs(), i)
{
label patchI = meshMover().adaptPatchIDs()[i];
word patchName = patches[patchI].name();
maxPatchNameLen = max(maxPatchNameLen, label(patchName.size()));
}
Info<< nl
<< setf(ios_base::left) << setw(maxPatchNameLen) << "patch"
<< setw(0) << " faces layers avg thickness[m]" << nl
<< setf(ios_base::left) << setw(maxPatchNameLen) << " "
<< setw(0) << " near-wall overall" << nl
<< setf(ios_base::left) << setw(maxPatchNameLen) << "-----"
<< setw(0) << " ----- ------ --------- -------" << endl;
forAll(meshMover().adaptPatchIDs(), i)
{
label patchI = meshMover().adaptPatchIDs()[i];
const labelList& meshPoints = patches[patchI].meshPoints();
scalar sumThickness = 0;
scalar sumNearWallThickness = 0;
forAll(meshPoints, patchPointI)
{
label ppPointI = pp().meshPointMap()[meshPoints[patchPointI]];
sumThickness += thickness[ppPointI];
label nLay = patchNLayers[ppPointI];
if (nLay > 0)
{
if (expansionRatio[ppPointI] == 1)
{
sumNearWallThickness += thickness[ppPointI]/nLay;
}
else
{
scalar s =
(1.0-pow(expansionRatio[ppPointI], nLay))
/ (1.0-expansionRatio[ppPointI]);
sumNearWallThickness += thickness[ppPointI]/s;
}
}
}
label totNPoints = returnReduce(meshPoints.size(), sumOp<label>());
// For empty patches, totNPoints is 0.
scalar avgThickness = 0;
scalar avgNearWallThickness = 0;
if (totNPoints > 0)
{
avgThickness =
returnReduce(sumThickness, sumOp<scalar>())
/ totNPoints;
avgNearWallThickness =
returnReduce(sumNearWallThickness, sumOp<scalar>())
/ totNPoints;
}
Info<< setf(ios_base::left) << setw(maxPatchNameLen)
<< patches[patchI].name() << setprecision(3)
<< " " << setw(8)
<< returnReduce(patches[patchI].size(), sumOp<scalar>())
<< " " << setw(6) << layerParams.numLayers()[patchI]
<< " " << setw(8) << avgNearWallThickness
<< " " << setw(8) << avgThickness
<< endl;
}
Info<< endl;
}
// Calculate wall to medial axis distance for smoothing displacement // Calculate wall to medial axis distance for smoothing displacement
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -2958,8 +2883,8 @@ void Foam::autoLayerDriver::addLayers
// Determine per point/per face number of layers to extrude. Also // Determine per point/per face number of layers to extrude. Also
// handles the slow termination of layers when going switching layers // handles the slow termination of layers when going switching layers
labelList nPatchPointLayers(pp().nPoints(),-1); labelList nPatchPointLayers(pp().nPoints(), -1);
labelList nPatchFaceLayers(pp().localFaces().size(),-1); labelList nPatchFaceLayers(pp().size(), -1);
setupLayerInfoTruncation setupLayerInfoTruncation
( (
meshMover(), meshMover(),
@ -2970,31 +2895,22 @@ void Foam::autoLayerDriver::addLayers
nPatchFaceLayers nPatchFaceLayers
); );
// Calculate displacement for first layer for addPatchLayer. // Calculate displacement for final layer for addPatchLayer.
// (first layer = layer of cells next to the original mesh) // (layer of cells next to the original mesh)
vectorField firstDisp(patchNLayers.size(), vector::zero); vectorField finalDisp(patchNLayers.size(), vector::zero);
forAll(nPatchPointLayers, i) forAll(nPatchPointLayers, i)
{ {
if (nPatchPointLayers[i] > 0) scalar ratio = layerParams.finalLayerThicknessRatio
{ (
if (expansionRatio[i] == 1.0) nPatchPointLayers[i],
{ expansionRatio[i]
firstDisp[i] = patchDisp[i]/nPatchPointLayers[i]; );
} finalDisp[i] = ratio*patchDisp[i];
else
{
label nLay = nPatchPointLayers[i];
scalar h =
pow(expansionRatio[i], nLay - 1)
* (1.0 - expansionRatio[i])
/ (1.0 - pow(expansionRatio[i], nLay));
firstDisp[i] = h*patchDisp[i];
}
}
} }
const scalarField invExpansionRatio(1.0 / expansionRatio);
const scalarField invExpansionRatio(1.0/expansionRatio);
// Add topo regardless of whether extrudeStatus is extruderemove. // Add topo regardless of whether extrudeStatus is extruderemove.
// Not add layer if patchDisp is zero. // Not add layer if patchDisp is zero.
@ -3009,7 +2925,7 @@ void Foam::autoLayerDriver::addLayers
labelList(0), // exposed patchIDs, not used for adding layers labelList(0), // exposed patchIDs, not used for adding layers
nPatchFaceLayers, // layers per face nPatchFaceLayers, // layers per face
nPatchPointLayers, // layers per point nPatchPointLayers, // layers per point
firstDisp, // thickness of layer nearest internal mesh finalDisp, // thickness of layer nearest internal mesh
meshMod meshMod
); );

7
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H
View File

@ -237,12 +237,7 @@ class autoLayerDriver
( (
const indirectPrimitivePatch& pp, const indirectPrimitivePatch& pp,
const labelList& patchIDs, const labelList& patchIDs,
const layerParameters& layerParams,
const scalarField& patchExpansionRatio,
const bool relativeSizes,
const scalarField& patchFinalLayerThickness,
const scalarField& patchMinThickness,
const labelList& cellLevel, const labelList& cellLevel,
const labelList& patchNLayers, const labelList& patchNLayers,
const scalar edge0Len, const scalar edge0Len,

440
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
View File

@ -34,6 +34,72 @@ License
const Foam::scalar Foam::layerParameters::defaultConcaveAngle = 90; const Foam::scalar Foam::layerParameters::defaultConcaveAngle = 90;
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
Foam::scalar Foam::layerParameters::layerExpansionRatio
(
const label n,
const scalar totalOverFirst
) const
{
if (n <= 1)
{
return 1.0;
}
//scalar totalOverFirst = totalThickness/firstLayerThickess;
const label maxIters = 10;
const scalar tol = 1e-8;
if (mag(n-totalOverFirst) < tol)
{
return 1.0;
}
// Calculate the bounds of the solution
scalar minR;
scalar maxR;
if (totalOverFirst < n)
{
minR = 0.0;
maxR = pow(totalOverFirst/n, 1/(n-1));
}
else
{
minR = pow(totalOverFirst/n, 1/(n-1));
maxR = totalOverFirst/(n - 1);
}
//Info<< "Solution bounds = (" << minR << ", " << maxR << ")" << nl << endl;
// Starting guess
scalar r = 0.5*(minR + maxR);
for (label i = 0; i < maxIters; ++i)
{
const scalar prevr = r;
const scalar fx = pow(r, n) - totalOverFirst*r - (1 - totalOverFirst);
const scalar dfx = n*pow(r, n - 1) - totalOverFirst;
r -= fx/dfx;
const scalar error = mag(r - prevr);
//Info<< i << " " << r << " Error = " << error << endl;
if (error < tol)
{
break;
}
}
return r;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from dictionary // Construct from dictionary
@ -44,17 +110,12 @@ Foam::layerParameters::layerParameters
) )
: :
numLayers_(boundaryMesh.size(), -1), numLayers_(boundaryMesh.size(), -1),
expansionRatio_
(
boundaryMesh.size(),
readScalar(dict.lookup("expansionRatio"))
),
relativeSizes_(dict.lookup("relativeSizes")), relativeSizes_(dict.lookup("relativeSizes")),
finalLayerThickness_ layerSpec_(ILLEGAL),
( firstLayerThickness_(boundaryMesh.size(), -123),
boundaryMesh.size(), finalLayerThickness_(boundaryMesh.size(), -123),
readScalar(dict.lookup("finalLayerThickness")) thickness_(boundaryMesh.size(), -123),
), expansionRatio_(boundaryMesh.size(), -123),
minThickness_ minThickness_
( (
boundaryMesh.size(), boundaryMesh.size(),
@ -103,24 +164,108 @@ Foam::layerParameters::layerParameters
nRelaxedIter_(labelMax), nRelaxedIter_(labelMax),
additionalReporting_(dict.lookupOrDefault("additionalReporting", false)) additionalReporting_(dict.lookupOrDefault("additionalReporting", false))
{ {
if (nGrow_ > 0) // Detect layer specification mode
label nSpec = 0;
bool haveFirst = dict.found("firstLayerThickness");
if (haveFirst)
{ {
WarningIn("layerParameters::layerParameters(..)") firstLayerThickness_ = scalarField
<< "The nGrow parameter effect has changed with respect to 1.6.x." (
<< endl boundaryMesh.size(),
<< "Please set nGrow=0 for 1.6.x behaviour." readScalar(dict.lookup("firstLayerThickness"))
);
nSpec++;
}
bool haveFinal = dict.found("finalLayerThickness");
if (haveFinal)
{
finalLayerThickness_ = scalarField
(
boundaryMesh.size(),
readScalar(dict.lookup("finalLayerThickness"))
);
nSpec++;
}
bool haveTotal = dict.found("thickness");
if (haveTotal)
{
thickness_ = scalarField
(
boundaryMesh.size(),
readScalar(dict.lookup("thickness"))
);
nSpec++;
}
bool haveExp = dict.found("expansionRatio");
if (haveExp)
{
expansionRatio_ = scalarField
(
boundaryMesh.size(),
readScalar(dict.lookup("expansionRatio"))
);
nSpec++;
}
if (haveFirst && haveTotal)
{
layerSpec_ = FIRST_AND_TOTAL;
Info<< "Layer thickness specified as first layer and overall thickness."
<< endl; << endl;
} }
else if (haveFirst && haveExp)
{
layerSpec_ = FIRST_AND_EXPANSION;
Info<< "Layer thickness specified as first layer and expansion ratio."
<< endl;
}
else if (haveFinal && haveTotal)
{
layerSpec_ = FINAL_AND_TOTAL;
Info<< "Layer thickness specified as final layer and overall thickness."
<< endl;
}
else if (haveFinal && haveExp)
{
layerSpec_ = FINAL_AND_EXPANSION;
Info<< "Layer thickness specified as final layer and expansion ratio."
<< endl;
}
if (layerSpec_ == ILLEGAL || nSpec != 2)
{
FatalIOErrorIn
(
"layerParameters::layerParameters"
"(const dictionary&, const polyBoundaryMesh&)",
dict
) << "Over- or underspecified layer thickness."
<< " Please specify" << nl
<< " first layer thickness ('firstLayerThickness')"
<< " and overall thickness ('thickness') or" << nl
<< " first layer thickness ('firstLayerThickness')"
<< " and expansion ratio ('expansionRatio') or" << nl
<< " final layer thickness ('finalLayerThickness')"
<< " and expansion ratio ('expansionRatio') or" << nl
<< " final layer thickness ('finalLayerThickness')"
<< " and overall thickness ('thickness')"
<< exit(FatalIOError);
}
dict.readIfPresent("nRelaxedIter", nRelaxedIter_); dict.readIfPresent("nRelaxedIter", nRelaxedIter_);
if (nLayerIter_ < 0 || nRelaxedIter_ < 0) if (nLayerIter_ < 0 || nRelaxedIter_ < 0)
{ {
FatalErrorIn("layerParameters::layerParameters(..)") FatalIOErrorIn("layerParameters::layerParameters(..)", dict)
<< "Layer iterations should be >= 0." << endl << "Layer iterations should be >= 0." << endl
<< "nLayerIter:" << nLayerIter_ << "nLayerIter:" << nLayerIter_
<< " nRelaxedIter:" << nRelaxedIter_ << " nRelaxedIter:" << nRelaxedIter_
<< exit(FatalError); << exit(FatalIOError);
} }
@ -130,7 +275,7 @@ Foam::layerParameters::layerParameters
{ {
if (iter().isDict()) if (iter().isDict())
{ {
const word& key = iter().keyword(); const keyType& key = iter().keyword();
const labelHashSet patchIDs const labelHashSet patchIDs
( (
boundaryMesh.patchSet(List<wordRe>(1, key)) boundaryMesh.patchSet(List<wordRe>(1, key))
@ -154,16 +299,69 @@ Foam::layerParameters::layerParameters
numLayers_[patchI] = numLayers_[patchI] =
readLabel(layerDict.lookup("nSurfaceLayers")); readLabel(layerDict.lookup("nSurfaceLayers"));
layerDict.readIfPresent switch (layerSpec_)
( {
"expansionRatio", case FIRST_AND_TOTAL:
expansionRatio_[patchI] layerDict.readIfPresent
); (
layerDict.readIfPresent "firstLayerThickness",
( firstLayerThickness_[patchI]
"finalLayerThickness", );
finalLayerThickness_[patchI] layerDict.readIfPresent
); (
"thickness",
thickness_[patchI]
);
break;
case FIRST_AND_EXPANSION:
layerDict.readIfPresent
(
"firstLayerThickness",
firstLayerThickness_[patchI]
);
layerDict.readIfPresent
(
"expansionRatio",
expansionRatio_[patchI]
);
break;
case FINAL_AND_TOTAL:
layerDict.readIfPresent
(
"finalLayerThickness",
finalLayerThickness_[patchI]
);
layerDict.readIfPresent
(
"thickness",
thickness_[patchI]
);
break;
case FINAL_AND_EXPANSION:
layerDict.readIfPresent
(
"finalLayerThickness",
finalLayerThickness_[patchI]
);
layerDict.readIfPresent
(
"expansionRatio",
expansionRatio_[patchI]
);
break;
default:
FatalIOErrorIn
(
"layerParameters::layerParameters(..)",
dict
) << "problem." << exit(FatalIOError);
break;
}
layerDict.readIfPresent layerDict.readIfPresent
( (
"minThickness", "minThickness",
@ -176,4 +374,190 @@ Foam::layerParameters::layerParameters
} }
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::scalar Foam::layerParameters::layerThickness
(
const label nLayers,
const scalar firstLayerThickess,
const scalar finalLayerThickess,
const scalar totalThickness,
const scalar expansionRatio
) const
{
switch (layerSpec_)
{
case FIRST_AND_TOTAL:
case FINAL_AND_TOTAL:
{
return totalThickness;
}
break;
case FIRST_AND_EXPANSION:
{
if (mag(expansionRatio-1) < SMALL)
{
return firstLayerThickess * nLayers;
}
else
{
return firstLayerThickess *
(1.0 - pow(expansionRatio, nLayers))
/ (1.0 - expansionRatio);
}
}
break;
case FINAL_AND_EXPANSION:
{
if (mag(expansionRatio-1) < SMALL)
{
return finalLayerThickess * nLayers;
}
else
{
scalar invExpansion = 1.0 / expansionRatio;
return finalLayerThickess *
(1.0 - pow(invExpansion, nLayers))
/ (1.0 - invExpansion);
}
}
break;
default:
{
FatalErrorIn("layerParameters::layerThickness(..)")
<< "Illegal thickness specification " << layerSpec_
<< exit(FatalError);
return -VGREAT;
}
}
}
Foam::scalar Foam::layerParameters::layerExpansionRatio
(
const label nLayers,
const scalar firstLayerThickess,
const scalar finalLayerThickess,
const scalar totalThickness,
const scalar expansionRatio
) const
{
switch (layerSpec_)
{
case FIRST_AND_EXPANSION:
case FINAL_AND_EXPANSION:
{
return expansionRatio;
}
break;
case FIRST_AND_TOTAL:
{
return layerExpansionRatio
(
nLayers,
totalThickness/firstLayerThickess
);
}
break;
case FINAL_AND_TOTAL:
{
return
1.0
/ layerExpansionRatio
(
nLayers,
totalThickness/finalLayerThickess
);
}
break;
default:
{
FatalErrorIn("layerParameters::layerThickness(..)")
<< "Illegal thickness specification" << exit(FatalError);
return -VGREAT;
}
}
}
Foam::scalar Foam::layerParameters::firstLayerThickness
(
const label nLayers,
const scalar firstLayerThickess,
const scalar finalLayerThickess,
const scalar totalThickness,
const scalar expansionRatio
) const
{
switch (layerSpec_)
{
case FIRST_AND_EXPANSION:
case FIRST_AND_TOTAL:
{
return firstLayerThickess;
}
case FINAL_AND_EXPANSION:
{
return finalLayerThickess*pow(1.0/expansionRatio, nLayers-1);
}
break;
case FINAL_AND_TOTAL:
{
scalar r = layerExpansionRatio
(
nLayers,
firstLayerThickess,
finalLayerThickess,
totalThickness,
expansionRatio
);
return finalLayerThickess/pow(r, nLayers-1);
}
break;
default:
{
FatalErrorIn("layerParameters::layerThickness(..)")
<< "Illegal thickness specification" << exit(FatalError);
return -VGREAT;
}
}
}
Foam::scalar Foam::layerParameters::finalLayerThicknessRatio
(
const label nLayers,
const scalar expansionRatio
) const
{
if (nLayers > 0)
{
if (mag(expansionRatio-1) < SMALL)
{
return 1.0/nLayers;
}
else
{
return
pow(expansionRatio, nLayers - 1)
* (1.0 - expansionRatio)
/ (1.0 - pow(expansionRatio, nLayers));
}
}
else
{
return 0.0;
}
}
// ************************************************************************* // // ************************************************************************* //

341
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
View File

@ -55,6 +55,27 @@ class refinementSurfaces;
class layerParameters class layerParameters
{ {
public:
// Public data types
//- Enumeration defining the layer specification:
// - first and total thickness specified
// - first and expansion ratio specified
// - final and total thickness specified
// - final and expansion ratio specified
enum layerSpecification
{
ILLEGAL,
FIRST_AND_TOTAL,
FIRST_AND_EXPANSION,
FINAL_AND_TOTAL,
FINAL_AND_EXPANSION
};
private:
// Static data members // Static data members
//- Default angle for faces to be convcave //- Default angle for faces to be convcave
@ -68,12 +89,21 @@ class layerParameters
//- How many layers to add. //- How many layers to add.
labelList numLayers_; labelList numLayers_;
scalarField expansionRatio_; //- Are sizes relative to local cell size
Switch relativeSizes_; Switch relativeSizes_;
scalarField finalLayerThickness_; //- How thickness is specified.
layerSpecification layerSpec_;
scalarField firstLayerThickness_;
scalarField finalLayerThickness_;
scalarField thickness_;
scalarField expansionRatio_;
//- Minimum total thickness
scalarField minThickness_; scalarField minThickness_;
@ -111,6 +141,14 @@ class layerParameters
// Private Member Functions // Private Member Functions
//- Calculate expansion ratio from overall size v.s. thickness of
// first layer.
scalar layerExpansionRatio
(
const label n,
const scalar totalOverFirst
) const;
//- Disallow default bitwise copy construct //- Disallow default bitwise copy construct
layerParameters(const layerParameters&); layerParameters(const layerParameters&);
@ -128,154 +166,209 @@ public:
// Member Functions // Member Functions
// Access // Per patch information
// Per patch information //- How many layers to add.
// -1 : no specification. Assume 0 layers but allow sliding
//- How many layers to add. // to make layers
// -1 : no specification. Assume 0 layers but allow sliding // 0 : specified to have 0 layers. No sliding allowed.
// to make layers // >0 : number of layers
// 0 : specified to have 0 layers. No sliding allowed. const labelList& numLayers() const
// >0 : number of layers
const labelList& numLayers() const
{
return numLayers_;
}
// Expansion factor for layer mesh
const scalarField& expansionRatio() const
{
return expansionRatio_;
}
//- Are size parameters relative to inner cell size or
// absolute distances.
bool relativeSizes() const
{
return relativeSizes_;
}
//- Wanted thickness of final added cell layer. If multiple
// layers is the thickness of the layer furthest away
// from the wall (i.e. nearest the original mesh)
// If relativeSize() this number is relative to undistorted
// size of the cell outside layer.
const scalarField& finalLayerThickness() const
{
return finalLayerThickness_;
}
//- Minimum thickness of cell layer. If for any reason layer
// cannot be above minThickness do not add layer.
// If relativeSize() this number is relative to undistorted
// size of the cell outside layer.
const scalarField& minThickness() const
{
return minThickness_;
}
scalar featureAngle() const
{ {
return featureAngle_; return numLayers_;
} }
//- At non-patched sides allow mesh to slip if extrusion //- Are size parameters relative to inner cell size or
// direction makes angle larger than slipFeatureAngle. // absolute distances.
scalar slipFeatureAngle() const bool relativeSizes() const
{ {
return slipFeatureAngle_; return relativeSizes_;
} }
scalar concaveAngle() const // Expansion factor for layer mesh
const scalarField& expansionRatio() const
{ {
return concaveAngle_; return expansionRatio_;
} }
//- If points get not extruded do nGrow layers of connected faces //- Wanted thickness of the layer furthest away
// that are not grown. Is used to not do layers at all close to // from the wall (i.e. nearest the original mesh).
// features. // If relativeSize() this number is relative to undistorted
label nGrow() const // size of the cell outside layer.
const scalarField& finalLayerThickness() const
{ {
return nGrow_; return finalLayerThickness_;
} }
//- Number of smoothing iterations of surface normals //- Wanted thickness of the layer nearest to the wall.
label nSmoothSurfaceNormals() const // If relativeSize() this number is relative to undistorted
// size of the cell outside layer.
const scalarField& firstLayerThickness() const
{ {
return nSmoothSurfaceNormals_; return firstLayerThickness_;
} }
//- Number of smoothing iterations of interior mesh movement //- Wanted overall thickness of all layers.
// direction // If relativeSize() this number is relative to undistorted
label nSmoothNormals() const // size of the cell outside layer.
const scalarField& thickness() const
{ {
return nSmoothNormals_; return thickness_;
} }
//- Stop layer growth on highly warped cells //- Minimum overall thickness of cell layer. If for any reason layer
scalar maxFaceThicknessRatio() const // cannot be above minThickness do not add layer.
// If relativeSize() this number is relative to undistorted
// size of the cell outside layer.
const scalarField& minThickness() const
{ {
return maxFaceThicknessRatio_; return minThickness_;
}
scalar layerTerminationCos() const
{
return layerTerminationCos_;
}
//- Smooth layer thickness over surface patches
label nSmoothThickness() const
{
return nSmoothThickness_;
}
//- Reduce layer growth where ratio thickness to medial
// distance is large
scalar maxThicknessToMedialRatio() const
{
return maxThicknessToMedialRatio_;
}
//- Angle used to pick up medial axis points
scalar minMedianAxisAngleCos() const
{
return minMedianAxisAngleCos_;
}
//- Create buffer region for new layer terminations
label nBufferCellsNoExtrude() const
{
return nBufferCellsNoExtrude_;
}
label nSnap() const
{
return nSnap_;
}
const Switch& additionalReporting() const
{
return additionalReporting_;
} }
// Overall scalar featureAngle() const
{
return featureAngle_;
}
//- Number of overall layer addition iterations //- At non-patched sides allow mesh to slip if extrusion
label nLayerIter() const // direction makes angle larger than slipFeatureAngle.
{ scalar slipFeatureAngle() const
return nLayerIter_; {
} return slipFeatureAngle_;
}
//- Number of iterations after which relaxed motion rules scalar concaveAngle() const
// are to be used. {
label nRelaxedIter() const return concaveAngle_;
{ }
return nRelaxedIter_;
} //- If points get not extruded do nGrow layers of connected faces
// that are not grown. Is used to not do layers at all close to
// features.
label nGrow() const
{
return nGrow_;
}
//- Number of smoothing iterations of surface normals
label nSmoothSurfaceNormals() const
{
return nSmoothSurfaceNormals_;
}
//- Number of smoothing iterations of interior mesh movement
// direction
label nSmoothNormals() const
{
return nSmoothNormals_;
}
//- Stop layer growth on highly warped cells
scalar maxFaceThicknessRatio() const
{
return maxFaceThicknessRatio_;
}
scalar layerTerminationCos() const
{
return layerTerminationCos_;
}
//- Smooth layer thickness over surface patches
label nSmoothThickness() const
{
return nSmoothThickness_;
}
//- Reduce layer growth where ratio thickness to medial
// distance is large
scalar maxThicknessToMedialRatio() const
{
return maxThicknessToMedialRatio_;
}
//- Angle used to pick up medial axis points
scalar minMedianAxisAngleCos() const
{
return minMedianAxisAngleCos_;
}
//- Create buffer region for new layer terminations
label nBufferCellsNoExtrude() const
{
return nBufferCellsNoExtrude_;
}
label nSnap() const
{
return nSnap_;
}
const Switch& additionalReporting() const
{
return additionalReporting_;
}
// Overall
//- Number of overall layer addition iterations
label nLayerIter() const
{
return nLayerIter_;
}
//- Number of iterations after which relaxed motion rules
// are to be used.
label nRelaxedIter() const
{
return nRelaxedIter_;
}
// Helper
//- Determine overall thickness. Uses two of the four parameters
// according to the layerSpecification
scalar layerThickness
(
const label nLayers,
const scalar firstLayerThickess,
const scalar finalLayerThickess,
const scalar totalThickness,
const scalar expansionRatio
) const;
//- Determine expansion ratio. Uses two of the four parameters
// according to the layerSpecification
scalar layerExpansionRatio
(
const label nLayers,
const scalar firstLayerThickess,
const scalar finalLayerThickess,
const scalar totalThickness,
const scalar expansionRatio
) const;
//- Determine first layer (near-wall) thickness. Uses two of the
// four parameters according to the layerSpecification
scalar firstLayerThickness
(
const label nLayers,
const scalar firstLayerThickess,
const scalar finalLayerThickess,
const scalar totalThickness,
const scalar expansionRatio
) const;
//- Determine ratio of final layer thickness to
// overall layer thickness
scalar finalLayerThicknessRatio
(
const label nLayers,
const scalar expansionRatio
) const;
}; };

17
src/thermophysicalModels/specie/thermo/thermo/thermoI.H
View File

@ -298,22 +298,15 @@ template<class Thermo, template<class> class Type>
inline Foam::scalar inline Foam::scalar
Foam::species::thermo<Thermo, Type>::K(const scalar p, const scalar T) const Foam::species::thermo<Thermo, Type>::K(const scalar p, const scalar T) const
{ {
if (equal(this->nMoles(), SMALL)) scalar arg = -this->nMoles()*this->g(p, T)/(this->RR*T);
if (arg < 600.0)
{ {
return 1.0; return exp(arg);
} }
else else
{ {
scalar arg = -this->nMoles()*this->g(p, T)/(this->RR*T); return VGREAT;
if (arg < 600.0)
{
return exp(arg);
}
else
{
return VGREAT;
}
} }
} }