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: reduced usage of Switch

Browse Source 
- Since 'bool' and 'Switch' use the _identical_ input mechanism
  (ie, both accept true/false, on/off, yes/no, none, 1/0), the main
  reason to prefer one or the other is the output.

  The output for Switch is as text (eg, "true"), whereas for bool
  it is label (0 or 1). If the output is required for a dictionary,
  Switch may be appropriate. If the output is not required, or is only
  used for Pstream exchange, bool can be more appropriate.
This commit is contained in:
Mark Olesen
2018-06-01 20:51:48 +02:00
parent 0f60cc9263
commit 84b109219a
72 changed files with 227 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
View File

@ -297,7 +297,7 @@ int main(int argc, char *argv[])
autoPtr<extrudeModel> model(extrudeModel::New(dict));
// Whether to flip normals
const Switch flipNormals(dict.lookup("flipNormals"));
const bool flipNormals(dict.get<bool>("flipNormals"));
// What to extrude
const ExtrudeMode mode = ExtrudeModeNames.lookup
@ -983,8 +983,7 @@ int main(int argc, char *argv[])
// Merging front and back patch faces
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Switch mergeFaces(dict.lookup("mergeFaces"));
if (mergeFaces)
if (dict.get<bool>("mergeFaces"))
{
if (mode == MESH)
{
@ -1009,7 +1008,6 @@ int main(int argc, char *argv[])
}
polyTopoChanger stitcher(mesh);
stitcher.setSize(1);

6
applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C
View File

@ -1536,8 +1536,8 @@ int main(int argc, char *argv[])
mappedPatchBase::sampleMode sampleMode =
mappedPatchBase::sampleModeNames_[dict.lookup("sampleMode")];
const Switch oneD(dict.lookup("oneD"));
Switch oneDNonManifoldEdges(false);
const bool oneD(dict.get<bool>("oneD"));
bool oneDNonManifoldEdges(false);
word oneDPatchType(emptyPolyPatch::typeName);
if (oneD)
{
@ -1545,7 +1545,7 @@ int main(int argc, char *argv[])
dict.lookup("oneDPolyPatchType") >> oneDPatchType;
}
const Switch adaptMesh(dict.lookup("adaptMesh"));
const bool adaptMesh(dict.get<bool>("adaptMesh"));
if (hasZones)
{

17
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.C
View File

@ -97,7 +97,7 @@ Foam::automatic::automatic
(
const dictionary& cellSizeCalcTypeDict,
const triSurfaceMesh& surface,
const scalar& defaultCellSize
const scalar defaultCellSize
)
:
cellSizeCalculationType
@ -109,12 +109,15 @@ Foam::automatic::automatic
),
coeffsDict_(cellSizeCalcTypeDict.optionalSubDict(typeName + "Coeffs")),
surfaceName_(surface.searchableSurface::name()),
readCurvature_(Switch(coeffsDict_.lookup("curvature"))),
curvatureFile_(coeffsDict_.lookup("curvatureFile")),
readFeatureProximity_(Switch(coeffsDict_.lookup("featureProximity"))),
featureProximityFile_(coeffsDict_.lookup("featureProximityFile")),
readInternalCloseness_(Switch(coeffsDict_.lookup("internalCloseness"))),
internalClosenessFile_(coeffsDict_.lookup("internalClosenessFile")),
readCurvature_(coeffsDict_.get<bool>("curvature")),
readFeatureProximity_(coeffsDict_.get<bool>("featureProximity")),
readInternalCloseness_(coeffsDict_.get<bool>("internalCloseness")),
curvatureFile_(coeffsDict_.get<word>("curvatureFile")),
featureProximityFile_(coeffsDict_.get<word>("featureProximityFile")),
internalClosenessFile_(coeffsDict_.get<word>("internalClosenessFile")),
curvatureCellSizeCoeff_
(
readScalar(coeffsDict_.lookup("curvatureCellSizeCoeff"))

18
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.H
View File

@ -37,7 +37,6 @@ SourceFiles
#include "cellSizeCalculationType.H"
#include "triSurfaceFields.H"
#include "PrimitivePatchInterpolation.H"
#include "Switch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -54,9 +53,6 @@ class automatic
:
public cellSizeCalculationType
{
private:
// Private data
//- Dictionary of coefficients for automatic cell sizing
@ -65,13 +61,12 @@ private:
//- Name of the surface. Used to write the cell size field
const fileName surfaceName_;
const Switch readCurvature_;
const bool readCurvature_;
const bool readFeatureProximity_;
const bool readInternalCloseness_;
const word curvatureFile_;
const Switch readFeatureProximity_;
const word featureProximityFile_;
const Switch readInternalCloseness_;
const word internalClosenessFile_;
//- The curvature values are multiplied by the inverse of this value to
@ -100,13 +95,12 @@ public:
(
const dictionary& cellSizeCalcTypeDict,
const triSurfaceMesh& surface,
const scalar& defaultCellSize
const scalar defaultCellSize
);
//- Destructor
virtual ~automatic()
{}
virtual ~automatic() = default;
// Member Functions

165
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cvControls/cvControls.C
View File

@ -42,43 +42,30 @@ Foam::cvControls::cvControls
foamyHexMeshDict_.subDict("surfaceConformation")
);
pointPairDistanceCoeff_ = readScalar
(
surfDict.lookup("pointPairDistanceCoeff")
);
pointPairDistanceCoeff_ =
surfDict.get<scalar>("pointPairDistanceCoeff");
mixedFeaturePointPPDistanceCoeff_ = readScalar
(
surfDict.lookup("mixedFeaturePointPPDistanceCoeff")
);
mixedFeaturePointPPDistanceCoeff_ =
surfDict.get<scalar>("mixedFeaturePointPPDistanceCoeff");
featurePointExclusionDistanceCoeff_ = readScalar
(
surfDict.lookup("featurePointExclusionDistanceCoeff")
);
featurePointExclusionDistanceCoeff_ =
surfDict.get<scalar>("featurePointExclusionDistanceCoeff");
featureEdgeExclusionDistanceCoeff_ = readScalar
(
surfDict.lookup("featureEdgeExclusionDistanceCoeff")
);
featureEdgeExclusionDistanceCoeff_ =
surfDict.get<scalar>("featureEdgeExclusionDistanceCoeff");
surfaceSearchDistanceCoeff_ =
surfDict.get<scalar>("surfaceSearchDistanceCoeff");
surfaceSearchDistanceCoeff_ = readScalar
(
surfDict.lookup("surfaceSearchDistanceCoeff")
);
maxSurfaceProtrusionCoeff_ =
surfDict.get<scalar>("maxSurfaceProtrusionCoeff");
maxSurfaceProtrusionCoeff_ = readScalar
(
surfDict.lookup("maxSurfaceProtrusionCoeff")
);
maxQuadAngle_ = readScalar(surfDict.lookup("maxQuadAngle"));
maxQuadAngle_ = surfDict.get<scalar>("maxQuadAngle");
surfaceConformationRebuildFrequency_ = max
(
1,
readLabel(surfDict.lookup("surfaceConformationRebuildFrequency"))
surfDict.get<label>("surfaceConformationRebuildFrequency")
);
@ -87,33 +74,23 @@ Foam::cvControls::cvControls
surfDict.subDict("featurePointControls")
);
specialiseFeaturePoints_ = Switch
(
featurePointControlsDict.lookup("specialiseFeaturePoints")
);
specialiseFeaturePoints_ =
featurePointControlsDict.get<Switch>("specialiseFeaturePoints");
guardFeaturePoints_ = Switch
(
featurePointControlsDict.lookup("guardFeaturePoints")
);
guardFeaturePoints_ =
featurePointControlsDict.get<Switch>("guardFeaturePoints");
edgeAiming_ = Switch
(
featurePointControlsDict.lookup("edgeAiming")
);
edgeAiming_ =
featurePointControlsDict.get<Switch>("edgeAiming");
if (!guardFeaturePoints_)
{
snapFeaturePoints_ = Switch
(
featurePointControlsDict.lookup("snapFeaturePoints")
);
snapFeaturePoints_ =
featurePointControlsDict.get<Switch>("snapFeaturePoints");
}
circulateEdges_ = Switch
(
featurePointControlsDict.lookup("circulateEdges")
);
circulateEdges_ =
featurePointControlsDict.get<Switch>("circulateEdges");
// Controls for coarse surface conformation
@ -122,62 +99,47 @@ Foam::cvControls::cvControls
surfDict.subDict("conformationControls")
);
surfacePtExclusionDistanceCoeff_ = readScalar
(
conformationControlsDict.lookup("surfacePtExclusionDistanceCoeff")
);
surfacePtExclusionDistanceCoeff_ =
conformationControlsDict.get<scalar>("surfacePtExclusionDistanceCoeff");
edgeSearchDistCoeffSqr_ = sqr
(
readScalar
(
conformationControlsDict.lookup("edgeSearchDistCoeff")
)
conformationControlsDict.get<scalar>("edgeSearchDistCoeff")
);
surfacePtReplaceDistCoeffSqr_ = sqr
(
readScalar
(
conformationControlsDict.lookup("surfacePtReplaceDistCoeff")
)
conformationControlsDict.get<scalar>("surfacePtReplaceDistCoeff")
);
maxConformationIterations_ = readLabel
(
conformationControlsDict.lookup("maxIterations")
);
maxConformationIterations_ =
conformationControlsDict.get<label>("maxIterations");
iterationToInitialHitRatioLimit_ = readScalar
(
conformationControlsDict.lookup("iterationToInitialHitRatioLimit")
);
iterationToInitialHitRatioLimit_ =
conformationControlsDict.get<scalar>("iterationToInitialHitRatioLimit");
// Motion control controls
const dictionary& motionDict(foamyHexMeshDict_.subDict("motionControl"));
defaultCellSize_ = readScalar(motionDict.lookup("defaultCellSize"));
defaultCellSize_ = motionDict.get<scalar>("defaultCellSize");
minimumCellSize_ =
readScalar(motionDict.lookup("minimumCellSizeCoeff"))*defaultCellSize_;
motionDict.get<scalar>("minimumCellSizeCoeff")*defaultCellSize_;
objOutput_ = Switch(motionDict.lookupOrDefault<Switch>("objOutput", false));
objOutput_ =
motionDict.lookupOrDefault<Switch>("objOutput", false);
timeChecks_ = Switch
(
motionDict.lookupOrDefault<Switch>("timeChecks", false)
);
timeChecks_ =
motionDict.lookupOrDefault<Switch>("timeChecks", false);
printVertexInfo_ = Switch
(
motionDict.lookupOrDefault<Switch>("printVertexInfo", false)
);
printVertexInfo_ =
motionDict.lookupOrDefault<Switch>("printVertexInfo", false);
if (Pstream::parRun())
{
maxLoadUnbalance_ = readScalar(motionDict.lookup("maxLoadUnbalance"));
maxLoadUnbalance_ = motionDict.get<scalar>("maxLoadUnbalance");
}
else
{
@ -186,7 +148,7 @@ Foam::cvControls::cvControls
cosAlignmentAcceptanceAngle_ = cos
(
degToRad(readScalar(motionDict.lookup("alignmentAcceptanceAngle")))
degToRad(motionDict.get<scalar>("alignmentAcceptanceAngle"))
);
@ -197,19 +159,15 @@ Foam::cvControls::cvControls
motionDict.subDict("pointInsertionCriteria")
);
insertionDistCoeff_ = readScalar
(
insertionDict.lookup("cellCentreDistCoeff")
);
insertionDistCoeff_ =
insertionDict.get<scalar>("cellCentreDistCoeff");
faceAreaRatioCoeff_ = readScalar
(
insertionDict.lookup("faceAreaRatioCoeff")
);
faceAreaRatioCoeff_ =
insertionDict.get<scalar>("faceAreaRatioCoeff");
cosInsertionAcceptanceAngle_ = cos
(
degToRad(readScalar(insertionDict.lookup("acceptanceAngle")))
degToRad(insertionDict.get<scalar>("acceptanceAngle"))
);
// Point removal criteria
@ -219,10 +177,8 @@ Foam::cvControls::cvControls
motionDict.subDict("pointRemovalCriteria")
);
removalDistCoeff_ = readScalar
(
removalDict.lookup("cellCentreDistCoeff")
);
removalDistCoeff_ =
removalDict.get<scalar>("cellCentreDistCoeff");
// polyMesh filtering controls
@ -231,34 +187,31 @@ Foam::cvControls::cvControls
foamyHexMeshDict_.subDict("polyMeshFiltering")
);
filterEdges_ = Switch
(
filteringDict.lookupOrDefault<Switch>("filterEdges", true)
);
filterEdges_ =
filteringDict.lookupOrDefault<Switch>("filterEdges", true);
filterFaces_ = Switch
(
filteringDict.lookupOrDefault<Switch>("filterFaces", false)
);
filterFaces_ =
filteringDict.lookupOrDefault<Switch>("filterFaces", false);
if (filterFaces_)
{
filterEdges_ = Switch::ON;
filterEdges_ = filterFaces_;
}
writeTetDualMesh_ = Switch(filteringDict.lookup("writeTetDualMesh"));
writeTetDualMesh_ =
filteringDict.get<Switch>("writeTetDualMesh");
writeCellShapeControlMesh_ =
Switch(filteringDict.lookup("writeCellShapeControlMesh"));
filteringDict.get<Switch>("writeCellShapeControlMesh");
if (Pstream::parRun())
{
writeBackgroundMeshDecomposition_ =
Switch(filteringDict.lookup("writeBackgroundMeshDecomposition"));
filteringDict.get<Switch>("writeBackgroundMeshDecomposition");
}
else
{
writeBackgroundMeshDecomposition_ = Switch(false);
writeBackgroundMeshDecomposition_ = Switch::FALSE;
}
}

9
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/initialPointsMethod/initialPointsMethod/initialPointsMethod.C
View File

@ -58,13 +58,10 @@ Foam::initialPointsMethod::initialPointsMethod
(
sqr
(
readScalar
(
initialPointsDict.lookup("minimumSurfaceDistanceCoeff")
)
initialPointsDict.get<scalar>("minimumSurfaceDistanceCoeff")
)
),
fixInitialPoints_(Switch(initialPointsDict.lookup("fixInitialPoints")))
fixInitialPoints_(initialPointsDict.get<bool>("fixInitialPoints"))
{}
@ -80,7 +77,7 @@ Foam::autoPtr<Foam::initialPointsMethod> Foam::initialPointsMethod::New
const autoPtr<backgroundMeshDecomposition>& decomposition
)
{
const word methodName(initialPointsDict.lookup("initialPointsMethod"));
const word methodName(initialPointsDict.get<word>("initialPointsMethod"));
Info<< nl << "Selecting initialPointsMethod "
<< methodName << endl;

5
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/initialPointsMethod/initialPointsMethod/initialPointsMethod.H
View File

@ -40,7 +40,6 @@ SourceFiles
#include "backgroundMeshDecomposition.H"
#include "dictionary.H"
#include "Random.H"
#include "Switch.H"
#include "autoPtr.H"
#include "runTimeSelectionTables.H"
@ -80,7 +79,7 @@ protected:
// the local target cell size. Store square of value.
scalar minimumSurfaceDistanceCoeffSqr_;
Switch fixInitialPoints_;
bool fixInitialPoints_;
private:
@ -194,7 +193,7 @@ public:
return detailsDict_;
}
Switch fixInitialPoints() const
bool fixInitialPoints() const
{
return fixInitialPoints_;
}

2
applications/utilities/mesh/generation/foamyMesh/foamyQuadMesh/foamyQuadMesh.C
View File

@ -81,7 +81,7 @@ int main(int argc, char *argv[])
);
const dictionary& extrusionDict(controlDict.subDict("extrusion"));
Switch extrude(extrusionDict.lookup("extrude"));
const bool extrude = extrusionDict.get<bool>("extrude");
const bool overwrite = args.found("overwrite");
// Read and triangulation

28
applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
View File

@ -141,12 +141,13 @@ autoPtr<refinementSurfaces> createRefinementSurfaces
// Invert surfaceCellSize to get the refinementLevel
const word scsFuncName =
shapeDict.lookup("surfaceCellSizeFunction");
shapeDict.get<word>("surfaceCellSizeFunction");
const dictionary& scsDict =
shapeDict.optionalSubDict(scsFuncName + "Coeffs");
const scalar surfaceCellSize =
readScalar(scsDict.lookup("surfaceCellSizeCoeff"));
scsDict.get<scalar>("surfaceCellSizeCoeff");
const label refLevel = sizeCoeffToRefinement
(
@ -222,7 +223,7 @@ autoPtr<refinementSurfaces> createRefinementSurfaces
);
const word scsFuncName =
shapeControlRegionDict.lookup
shapeControlRegionDict.get<word>
(
"surfaceCellSizeFunction"
);
@ -233,10 +234,7 @@ autoPtr<refinementSurfaces> createRefinementSurfaces
);
const scalar surfaceCellSize =
readScalar
(
scsDict.lookup("surfaceCellSizeCoeff")
);
scsDict.get<scalar>("surfaceCellSizeCoeff");
const label refLevel = sizeCoeffToRefinement
(
@ -780,10 +778,10 @@ int main(int argc, char *argv[])
const scalar mergeDist = getMergeDistance
(
mesh,
readScalar(meshDict.lookup("mergeTolerance"))
meshDict.get<scalar>("mergeTolerance")
);
const Switch keepPatches(meshDict.lookupOrDefault("keepPatches", false));
const bool keepPatches(meshDict.lookupOrDefault("keepPatches", false));
// Read decomposePar dictionary
@ -958,7 +956,7 @@ int main(int argc, char *argv[])
// Calculate current ratio of hex cells v.s. wanted cell size
const scalar defaultCellSize =
readScalar(motionDict.lookup("defaultCellSize"));
motionDict.get<scalar>("defaultCellSize");
const scalar initialCellSize = ::pow(meshPtr().V()[0], 1.0/3.0);
@ -1020,7 +1018,7 @@ int main(int argc, char *argv[])
if (patchInfo.set(globalRegioni))
{
patchTypes[geomi][regioni] =
word(patchInfo[globalRegioni].lookup("type"));
patchInfo[globalRegioni].get<word>("type");
}
else
{
@ -1449,11 +1447,11 @@ int main(int argc, char *argv[])
// Now do the real work -refinement -snapping -layers
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
const Switch wantRefine(meshDict.lookup("castellatedMesh"));
const Switch wantSnap(meshDict.lookup("snap"));
const Switch wantLayers(meshDict.lookup("addLayers"));
const bool wantRefine(meshDict.get<bool>("castellatedMesh"));
const bool wantSnap(meshDict.get<bool>("snap"));
const bool wantLayers(meshDict.get<bool>("addLayers"));
const Switch mergePatchFaces
const bool mergePatchFaces
(
meshDict.lookupOrDefault("mergePatchFaces", true)
);