Commit e0f8dbda authored by Franjo's avatar Franjo
Browse files

Initial commit

parents
#!/bin/sh
# Compile mesh library
wclean libso meshLibrary
# Compile executables
wclean all executables
# Compile utilities
wclean all utilities
#!/bin/sh
# Compile mesh library
wmake libso meshLibrary
# Compile executables
wmake all executables
# Compile utilities
wmake all utilities
# -*- mode: org; -*-
#
#+TITLE: *cfMesh README for version 1.0*
#+AUTHOR: Franjo Juretic.
#+DATE: May 2014
#+LINK: http://www.c-fields.com
#+OPTIONS:
cfMesh is a library for mesh generation built on OpenFOAM.
* License
cfMesh is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.
* System requirements
cfMesh is developed and tested on Linux and MS Windows.
* Installation
The binaries can be downloaded from www.c-fields.com
* Building from Sources (Optional)
cfMesh can be built with recent versions of OpenFOAM and foam-extend. In order to build the library, a working OpenFOAM environment is needed. The build started by the Allwmake script located in this folder. It can be built with gcc and mingw compilers which support OpenMP (gcc-4.2.4 and above). Other compilers are not tested.
* Getting Started
Copy the 'tutorials' examples directory in the cfMesh distribution to the
'run' directory. If the OpenFOAM environment variables are set correctly,
then the following command will work correctly:
+ cp -r tutorials $FOAM_RUN
Run the first example case of a simplified car body:
+ cd $FOAM_RUN/tutorials/asmoOctree
+ cartesianMesh
* Documentation
http://www.c-fields.com
\ No newline at end of file
cartesian2DMesh.C
EXE = $(FOAM_USER_APPBIN)/cartesian2DMesh
EXE_INC = \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I../../meshLibrary/lnInclude
EXE_LIBS = \
-lmeshTools \
-ltriSurface \
-lfiniteVolume \
-L$(FOAM_USER_LIBBIN) \
-lmeshLibrary
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | cfMesh: A library for mesh generation
\\ / O peration |
\\ / A nd | Author: Franjo Juretic (franjo.juretic@c-fields.com)
\\/ M anipulation | Copyright (C) Creative Fields, Ltd.
-------------------------------------------------------------------------------
License
This file is part of cfMesh.
cfMesh is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.
cfMesh is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with cfMesh. If not, see <http://www.gnu.org/licenses/>.
Application
Generates cartesian mesh
Description
Generates a 2D cartesian mesh
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "Time.H"
#include "cartesian2DMeshGenerator.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
//- 2d cartesian mesher cannot be run in parallel
argList::noParallel();
cartesian2DMeshGenerator cmg(runTime);
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n"
<< "ClockTime = " << runTime.elapsedClockTime() << " s" << endl;
cmg.writeMesh();
Info << "End\n" << endl;
return 0;
}
// ************************************************************************* //
cartesianMesh.C
EXE = $(FOAM_USER_APPBIN)/cartesianMesh
EXE_INC = \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I../../meshLibrary/lnInclude
EXE_LIBS = \
-lmeshTools \
-ltriSurface \
-lfiniteVolume \
-L$(FOAM_USER_LIBBIN) \
-lmeshLibrary
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | cfMesh: A library for mesh generation
\\ / O peration |
\\ / A nd | Author: Franjo Juretic (franjo.juretic@c-fields.com)
\\/ M anipulation | Copyright (C) Creative Fields, Ltd.
-------------------------------------------------------------------------------
License
This file is part of cfMesh.
cfMesh is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.
cfMesh is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with cfMesh. If not, see <http://www.gnu.org/licenses/>.
Application
Generates cartesian mesh
Description
- takes a triangulated surface and generates a cartesian mesh
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "objectRegistry.H"
#include "Time.H"
#include "cartesianMeshGenerator.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
cartesianMeshGenerator cmg(runTime);
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n"
<< "ClockTime = " << runTime.elapsedClockTime() << " s" << endl;
cmg.writeMesh();
Info << "End\n" << endl;
return 0;
}
// ************************************************************************* //
tetMesh.C
EXE = $(FOAM_USER_APPBIN)/tetMesh
EXE_INC = \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I../../meshLibrary/lnInclude
EXE_LIBS = \
-lmeshTools \
-ltriSurface \
-lfiniteVolume \
-L$(FOAM_USER_LIBBIN) \
-lmeshLibrary
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | cfMesh: A library for mesh generation
\\ / O peration |
\\ / A nd | Author: Franjo Juretic (franjo.juretic@c-fields.com)
\\/ M anipulation | Copyright (C) Creative Fields, Ltd.
-------------------------------------------------------------------------------
License
This file is part of cfMesh.
cfMesh is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.
cfMesh is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with cfMesh. If not, see <http://www.gnu.org/licenses/>.
Application
Generates tetrahedral mesh
Description
- takes a triangulated surface and generates a tetrahedral mesh
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "Time.H"
#include "tetMeshGenerator.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
//- tetrahedral mesher cannot be run in parallel yet
argList::noParallel();
tetMeshGenerator tmg(runTime);
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n"
<< "ClockTime = " << runTime.elapsedClockTime() << endl;
tmg.writeMesh();
Info << "End\n" << endl;
return 0;
}
// ************************************************************************* //
meshSurfaceEngine = utilities/surfaceTools/meshSurfaceEngine
meshSurfacePartitioner = utilities/surfaceTools/meshSurfacePartitioner
boundaryLayers = utilities/boundaryLayers
checkMeshDict = utilities/checkMeshDict
meshSurfaceCheckInvertedVertices = utilities/surfaceTools/meshSurfaceCheckInvertedVertices
meshSurfaceCheckEdgeTypes = utilities/surfaceTools/meshSurfaceCheckEdgeTypes
meshSurfaceCutter = utilities/surfaceTools/meshSurfaceCutter
meshSurfaceMapper = utilities/surfaceTools/meshSurfaceMapper
meshSurfaceMapper2D = utilities/surfaceTools/meshSurfaceMapper2D
edgeExtraction = utilities/surfaceTools/edgeExtraction
edgeExtractor = $(edgeExtraction)/edgeExtractor
meshSurfaceEdgeExtractor = utilities/surfaceTools/meshSurfaceEdgeExtractor
meshSurfaceEdgeExtractorNonTopo = utilities/surfaceTools/meshSurfaceEdgeExtractorNonTopo
meshSurfaceEdgeExtractor2D = utilities/surfaceTools/meshSurfaceEdgeExtractor2D
correctEdgesBetweenPatches = utilities/surfaceTools/correctEdgesBetweenPatches
decomposeCellsNearConcaveEdges = utilities/surfaceTools/decomposeCellsNearConcaveEdges
renameBoundaryPatches = utilities/surfaceTools/renameBoundaryPatches
intersectionTools = utilities/intersectionTools
findCellsIntersectingSurface = $(intersectionTools)/findCellsIntersectingSurface
meshOptimizer = utilities/smoothers/geometry/meshOptimizer
tetMeshOptimisation = $(meshOptimizer)/tetMeshOptimisation
simplexSmoother = $(tetMeshOptimisation)/advancedSmoothers/simplexSmoother
knuppMetric = $(tetMeshOptimisation)/advancedSmoothers/knuppMetric
meshUntangler = $(tetMeshOptimisation)/advancedSmoothers/meshUntangler
quadricMetric = $(tetMeshOptimisation)/advancedSmoothers/quadricMetric
volumeOptimizer = $(tetMeshOptimisation)/advancedSmoothers/volumeOptimizer
meshSurfaceOptimizer = utilities/smoothers/geometry/meshSurfaceOptimizer
surfaceOptimizer = $(meshSurfaceOptimizer)/advancedSurfaceSmoothers/surfaceOptimizer
surfaceMorpherCells = utilities/surfaceTools/surfaceMorpherCells
utilitiesOctrees = utilities/octrees
meshOctree = utilities/octrees/meshOctree
meshOctreeCube = utilities/octrees/meshOctree/meshOctreeCube
meshOctreeInsideOutside = utilities/octrees/meshOctree/meshOctreeInsideOutside
meshOctreeCreator = utilities/octrees/meshOctree/meshOctreeCreator
meshOctreeAddressing = utilities/octrees/meshOctree/meshOctreeAddressing
meshOctreeModifier = utilities/octrees/meshOctree/meshOctreeModifier
meshOctreeAutoRef = utilities/octrees/meshOctree/meshOctreeAutomaticRefinement
patchRefinement = utilities/octrees/meshOctree/refinementControls/patchRefinement
objectRefinement = utilities/octrees/meshOctree/refinementControls/objectRefinement
helperFunctions = utilities/helperFunctions
createFacesFromChain = utilities/helperClasses/createFacesFromChain
sortEdgesIntoChains = utilities/helperClasses/sortEdgesIntoChains
trianglePlaneIntersections = utilities/helperClasses/trianglePlaneIntersections
tetCreatorOctree = utilities/tetrahedra/tetCreatorOctree
faceDecomposition = utilities/faceDecomposition
decomposeCells = utilities/decomposeCells
topology = utilities/smoothers/topology
topologicalCleaner = $(topology)/topologicalCleaner
checkBoundaryFacesSharingTwoEdges = $(topology)/checkBoundaryFacesSharingTwoEdges
checkCellConnectionsOverFaces = $(topology)/checkCellConnectionsOverFaces
checkIrregularSurfaceConnections = $(topology)/checkIrregularSurfaceConnections
checkNonMappableCellConnections = $(topology)/checkNonMappableCellConnections
triSurfaceTools = utilities/triSurfaceTools
triSurfaceCleanupDuplicates = $(triSurfaceTools)/triSurfaceCleanupDuplicates
triSurfaceCopyParts = $(triSurfaceTools)/triSurfaceCopyParts
triSurfaceCurvatureEstimator = $(triSurfaceTools)/triSurfaceCurvatureEstimator
triSurfacePartitioner = $(triSurfaceTools)/triSurfacePartitioner
triSurfaceDetectFeatureEdges = $(triSurfaceTools)/triSurfaceDetectFeatureEdges
triSurfaceClassifyEdges = $(triSurfaceTools)/triSurfaceClassifyEdges
triSurfacePatchManipulator = $(triSurfaceTools)/triSurfacePatchManipulator
triSurfaceRemoveFacets = $(triSurfaceTools)/triSurfaceRemoveFacets
triSurfaceExtrude2DEdges = $(triSurfaceTools)/triSurfaceExtrude2DEdges
triSurfaceMetaData = $(triSurfaceTools)/triSurfaceMetaData
polyMeshGen = utilities/meshes/polyMeshGen
boundaryPatch = utilities/meshes/polyMeshGen/boundaryPatch
polyMeshGen2DEngine = utilities/meshes/polyMeshGen2DEngine
polyMeshGenModifier = utilities/meshes/polyMeshGenModifier
polyMeshGenAddressing = utilities/meshes/polyMeshGenAddressing
polyMeshGenChecks = utilities/meshes/polyMeshGenChecks
partTetMesh = utilities/meshes/partTetMesh
partTriMesh = utilities/meshes/partTriMesh
primitiveMesh = utilities/meshes/primitiveMesh
triSurf = utilities/meshes/triSurf
cell = utilities/meshes/primitives/cell
edge = utilities/meshes/primitives/edge
face = utilities/meshes/primitives/face
containers = utilities/containers
VRWGraph = $(containers)/VRWGraph
VRWGraphList = $(containers)/VRWGraphList
graphs = $(containers)/Graphs
lists = $(containers)/Lists
meshZipper = utilities/meshZipper
writeAsFPMA = utilities/dataConversion/foamToFPMA
polyMeshExtractor = pMeshLibrary/polyMeshExtractor
polyMeshGenerator = pMeshLibrary/polyMeshGenerator
cartesianMeshExtractor = cartesianMesh/cartesianMeshExtractor
cartesianMeshGenerator = cartesianMesh/cartesianMeshGenerator
cartesian2DMeshGenerator = cartesian2DMesh/cartesian2DMeshGenerator
tetMeshExtractor = tetMesh/tetMeshExtractor
tetMeshExtractorOctree = tetMesh/tetMeshExtractorOctree
tetMeshGenerator = tetMesh/tetMeshGenerator
$(checkMeshDict)/checkMeshDict.C
$(lists)/pointFieldPMG.C
$(lists)/faceListPMG.C
$(VRWGraph)/VRWGraph.C
$(VRWGraph)/VRWGraphSMPModifier.C
$(VRWGraphList)/VRWGraphList.C
$(graphs)/cellIOGraph.C
$(graphs)/faceIOGraph.C
$(polyMeshGen)/polyMeshGen.C
$(polyMeshGen)/polyMeshGenPoints.C
$(polyMeshGen)/polyMeshGenFaces.C
$(polyMeshGen)/polyMeshGenCells.C
$(polyMeshGen2DEngine)/polyMeshGen2DEngine.C
$(boundaryPatch)/boundaryPatchBase.C
$(boundaryPatch)/boundaryPatch.C
$(boundaryPatch)/processorBoundaryPatch.C
$(polyMeshGenModifier)/polyMeshGenModifierRemoveUnusedVertices.C
$(polyMeshGenModifier)/polyMeshGenModifierRemoveFaces.C
$(polyMeshGenModifier)/polyMeshGenModifierRemoveCells.C
$(polyMeshGenModifier)/polyMeshGenModifierReorderBoundaryFaces.C
$(polyMeshGenModifier)/polyMeshGenModifierAddCells.C
$(polyMeshGenModifier)/polyMeshGenModifierAddProcessorFaces.C
$(polyMeshGenModifier)/polyMeshGenModifierAddBufferCells.C
$(polyMeshGenModifier)/polyMeshGenModifierReplaceBoundary.C
$(polyMeshGenModifier)/polyMeshGenModifierZipUpCells.C
$(polyMeshGenModifier)/polyMeshGenModifierRenumberMesh.C
$(polyMeshGenModifier)/polyMeshGenModifierAddCellByCell.C
$(polyMeshGenAddressing)/polyMeshGenAddressing.C
$(polyMeshGenAddressing)/polyMeshGenAddressingCellCells.C
$(polyMeshGenAddressing)/polyMeshGenAddressingCellEdges.C
$(polyMeshGenAddressing)/polyMeshGenAddressingCellPoints.C
$(polyMeshGenAddressing)/polyMeshGenAddressingCentresAndAreas.C
$(polyMeshGenAddressing)/polyMeshGenAddressingCentresAndVols.C
$(polyMeshGenAddressing)/polyMeshGenAddressingClear.C
$(polyMeshGenAddressing)/polyMeshGenAddressingUpdateGeometry.C
$(polyMeshGenAddressing)/polyMeshGenAddressingEdgeCells.C
$(polyMeshGenAddressing)/polyMeshGenAddressingEdgeFaces.C
$(polyMeshGenAddressing)/polyMeshGenAddressingFaceEdges.C
$(polyMeshGenAddressing)/polyMeshGenAddressingEdges.C
$(polyMeshGenAddressing)/polyMeshGenAddressingPointCells.C
$(polyMeshGenAddressing)/polyMeshGenAddressingPointEdges.C
$(polyMeshGenAddressing)/polyMeshGenAddressingPointFaces.C
$(polyMeshGenAddressing)/polyMeshGenAddressingPointPoints.C
$(polyMeshGenAddressing)/polyMeshGenAddressingParallelAddressing.C
$(polyMeshGenChecks)/polyMeshGenChecks.C
$(polyMeshGenChecks)/polyMeshGenChecksGeometry.C
$(polyMeshGenChecks)/polyMeshGenChecksTopology.C
$(partTetMesh)/partTetMesh.C
$(partTetMesh)/partTetMeshAddressing.C
$(partTetMesh)/partTetMeshParallelAddressing.C
$(partTetMesh)/partTetMeshSimplex.C
$(partTriMesh)/partTriMesh.C
$(partTriMesh)/partTriMeshAddressing.C
$(partTriMesh)/partTriMeshParallelAddressing.C
$(partTriMesh)/partTriMeshSimplex.C
$(triSurf)/triSurf.C
$(triSurf)/triSurfPoints.C
$(triSurf)/triSurfFacets.C
$(triSurf)/triSurfFeatureEdges.C
$(triSurf)/triSurfAddressing.C
$(triSurf)/triSurfModifier.C
$(findCellsIntersectingSurface)/findCellsIntersectingSurface.C
$(tetCreatorOctree)/tetCreatorOctree.C
$(tetCreatorOctree)/tetCreatorOctreePointsAndAddressing.C
$(tetCreatorOctree)/tetCreatorOctreeFromFacesWithCentreNode.C
$(tetCreatorOctree)/tetCreatorOctreeTetsAroundEdges.C
$(tetCreatorOctree)/tetCreatorOctreeTetsAroundSplitEdges.C
$(tetCreatorOctree)/tetCreatorOctreeTetsFromSplitFaces.C
$(faceDecomposition)/faceDecomposition.C
$(faceDecomposition)/decomposeFaces.C
$(helperFunctions)/helperFunctionsStringConversion.C
$(sortEdgesIntoChains)/sortEdgesIntoChains.C
$(surfaceMorpherCells)/surfaceMorpherCells.C
$(surfaceMorpherCells)/surfaceMorpherCellsMorphInternalFaces.C
$(surfaceMorpherCells)/surfaceMorpherCellsCreateBoundaryFaces.C
$(decomposeCells)/decomposeCells.C
$(decomposeCells)/decomposeCellsPyramids.C
$(decomposeCells)/decomposeCellsDecomposition.C
$(topologicalCleaner)/topologicalCleaner.C
$(topologicalCleaner)/topologyCleanerNonConsecutiveBoundaryVertices.C
$(topologicalCleaner)/topologicalCleanerInvalidVertices.C
$(topologicalCleaner)/topologyCleanerNonMappableCells.C
$(checkCellConnectionsOverFaces)/checkCellConnectionsOverFaces.C
$(checkIrregularSurfaceConnections)/checkIrregularSurfaceConnections.C
$(checkIrregularSurfaceConnections)/checkIrregularSurfaceConnectionsFunctions.C
$(checkNonMappableCellConnections)/checkNonMappableCellConnections.C
$(checkBoundaryFacesSharingTwoEdges)/checkBoundaryFacesSharingTwoEdges.C
$(boundaryLayers)/boundaryLayers.C
$(boundaryLayers)/boundaryLayersCreateVertices.C
$(boundaryLayers)/boundaryLayersFacesAndCells.C
$(boundaryLayers)/boundaryLayerCells.C
$(boundaryLayers)/boundaryLayersCheckTopologyOfBndFaces.C
$(boundaryLayers)/boundaryLayersWrapperLayer.C
$(boundaryLayers)/extrudeLayer.C
$(boundaryLayers)/refineBoundaryLayers.C
$(boundaryLayers)/refineBoundaryLayersFunctions.C
$(boundaryLayers)/refineBoundaryLayersFaces.C
$(boundaryLayers)/refineBoundaryLayersCells.C
$(meshSurfaceEngine)/meshSurfaceEngine.C
$(meshSurfaceEngine)/meshSurfaceEngineCalculateBoundaryNodesAndFaces.C
$(meshSurfaceEngine)/meshSurfaceEngineParallelAddressing.C
$(meshSurfaceEngine)/meshSurfaceEngineModifier.C
$(meshSurfacePartitioner)/meshSurfacePartitioner.C
$(meshSurfacePartitioner)/meshSurfacePartitionerFunctions.C
$(meshSurfaceCheckInvertedVertices)/meshSurfaceCheckInvertedVertices.C
$(meshSurfaceCheckEdgeTypes)/meshSurfaceCheckEdgeTypes.C
$(meshSurfaceMapper)/meshSurfaceMapper.C
$(meshSurfaceMapper)/meshSurfaceMapperMapVertices.C
$(meshSurfaceMapper)/meshSurfaceMapperCornersAndEdges.C
$(meshSurfaceMapper)/meshSurfaceMapperPremapVertices.C
$(meshSurfaceMapper2D)/meshSurfaceMapper2D.C
$(meshSurfaceMapper2D)/meshSurfaceMapper2DMapVertices.C
$(meshSurfaceMapper2D)/meshSurfaceMapper2DPremapVertices.C
$(edgeExtractor)/edgeExtractor.C
$(edgeExtractor)/edgeExtractorCorners.C
$(meshSurfaceEdgeExtractorNonTopo)/meshSurfaceEdgeExtractorNonTopo.C
$(meshSurfaceEdgeExtractorNonTopo)/meshSurfaceEdgeExtractorNonTopoDistributeFaces.C
$(meshSurfaceEdgeExtractor2D)/meshSurfaceEdgeExtractor2D.C
$(meshSurfaceEdgeExtractor2D)/meshSurfaceEdgeExtractor2DDistributeFaces.C
$(correctEdgesBetweenPatches)/correctEdgesBetweenPatches.C
$(correctEdgesBetweenPatches)/correctEdgesBetweenPatchesDistributeFaces.C
$(renameBoundaryPatches)/renameBoundaryPatches.C
$(meshOptimizer)/meshOptimizer.C
$(meshOptimizer)/meshOptimizerOptimizePoint.C
$(meshOptimizer)/meshOptimizerOptimizePointParallel.C
$(meshOptimizer)/meshOptimizerOptimizeSurface.C
$(meshOptimizer)/optimizeMeshFV.C
$(tetMeshOptimisation)/tetMeshOptimisation.C
$(tetMeshOptimisation)/tetMeshOptimisationParallel.C
$(simplexSmoother)/simplexSmoother.C
$(knuppMetric)/knuppMetric.C
$(meshUntangler)/meshUntangler.C
$(meshUntangler)/meshUntanglerCutRegion.C
$(meshUntangler)/meshUntanglerCutRegionPoints.C
$(meshUntangler)/meshUntanglerCutRegionEdges.C
$(meshUntangler)/meshUntanglerCutRegionFaces.C
$(meshUntangler)/meshUntanglerCutRegionTieBreak.C
$(quadricMetric)/quadricMetric.C
$(volumeOptimizer)/volumeOptimizer.C
$(volumeOptimizer)/volumeOptimizerEvaluateGradients.C
$(meshSurfaceOptimizer)/meshSurfaceOptimizer.C
$(meshSurfaceOptimizer)/meshSurfaceOptimizerCalculateTrianglesAndAddressing.C
$(meshSurfaceOptimizer)/meshSurfaceOptimizerOptimizePoint.C
$(meshSurfaceOptimizer)/meshSurfaceOptimizerOptimizeSurface.C
$(meshSurfaceOptimizer)/meshSurfaceOptimizerOptimizePointParallel.C
$(surfaceOptimizer)/surfaceOptimizer.C
$(meshOctreeCube)/meshOctreeCube.C
$(meshOctreeCube)/meshOctreeCubeIntersections.C
$(meshOctreeCube)/meshOctreeCubeRecursiveFunctions.C
$(meshOctreeCube)/meshOctreeCubeRefine.C
$(meshOctreeCube)/meshOctreeCubeCoordinatesIntersections.C
$(meshOctreeModifier)/meshOctreeModifier.C
$(meshOctreeModifier)/meshOctreeModifierRefineSelectedBoxes.C
$(meshOctreeModifier)/meshOctreeModifierEnsureCorrectRegularity.C
$(meshOctreeModifier)/meshOctreeModifierParallelRefinement.C