exaFOAM/foam-extend4.1-coherent-io
Archived
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Tet fem reorganisation

Browse source
This commit is contained in:
Hrvoje Jasak 2013-08-13 16:01:45 +01:00
parent bfa51c9392
commit 1a0318c0ca
283 changed files with 951 additions and 10372 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
applications/solvers/engine/icoDyMEngineFoam/Make/options
View file

@ -13,6 +13,7 @@ EXE_LIBS = \
-ltopoChangerFvMesh \ -ltopoChangerFvMesh \
-lmeshTools \ -lmeshTools \
-lfiniteVolume \ -lfiniteVolume \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-ltetMotionSolver \
-llduSolvers \ -llduSolvers \
-L$(MESQUITE_LIB_DIR) -lmesquite -L$(MESQUITE_LIB_DIR) -lmesquite

3
applications/solvers/engine/sonicTurbDyMEngineFoam/Make/options
View file

@ -19,6 +19,7 @@ EXE_LIBS = \
-lbasicThermophysicalModels \ -lbasicThermophysicalModels \
-lspecie \ -lspecie \
-lmeshTools \ -lmeshTools \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-ltetMotionSolver \
-llduSolvers \ -llduSolvers \
-L$(MESQUITE_LIB_DIR) -lmesquite -L$(MESQUITE_LIB_DIR) -lmesquite

3
applications/solvers/engine/turbDyMEngineFoam/Make/options
View file

@ -20,6 +20,7 @@ EXE_LIBS = \
-lincompressibleLESModels \ -lincompressibleLESModels \
-lincompressibleTransportModels \ -lincompressibleTransportModels \
-lfiniteVolume \ -lfiniteVolume \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-ltetMotionSolver \
-llduSolvers \ -llduSolvers \
-L$(MESQUITE_LIB_DIR) -lmesquite -L$(MESQUITE_LIB_DIR) -lmesquite

1
applications/solvers/multiSolver/multiSolverDemo/Make/options
View file

@ -5,5 +5,4 @@ EXE_INC = \
EXE_LIBS = \ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
-L$(FOAM_USER_LIBBIN) \
-lmultiSolver -lmultiSolver

4
applications/solvers/solidMechanics/elasticContactSolidFoam/Make/options
View file

@ -1,12 +1,12 @@
EXE_INC = \ EXE_INC = \
-I../solidModels/lnInclude \
-I$(FOAM_SRC)/finiteVolume/lnInclude \ -I$(FOAM_SRC)/finiteVolume/lnInclude \
-I$(FOAM_SRC)/meshTools/lnInclude \ -I$(FOAM_SRC)/meshTools/lnInclude \
-I$(FOAM_SRC)/lagrangian/basic/lnInclude \ -I$(FOAM_SRC)/lagrangian/basic/lnInclude \
-I../solidModels/lnInclude \
-I$(FOAM_SRC)/VectorN/lnInclude -I$(FOAM_SRC)/VectorN/lnInclude
EXE_LIBS = \ EXE_LIBS = \
-L$(FOAM_USER_LIBBIN) -lsolidModels \ -lsolidModels \
-lfiniteVolume \ -lfiniteVolume \
-llduSolvers \ -llduSolvers \
-lmeshTools \ -lmeshTools \

8
applications/solvers/solidMechanics/icoFsiElasticNonLinULSolidFoam/Make/options
View file

@ -10,9 +10,8 @@ EXE_INC = \
-I$(LIB_SRC)/turbulenceModels \ -I$(LIB_SRC)/turbulenceModels \
-I$(LIB_SRC)/LESmodels \ -I$(LIB_SRC)/LESmodels \
-I$(LIB_SRC)/LESmodels/LESdeltas/lnInclude \ -I$(LIB_SRC)/LESmodels/LESdeltas/lnInclude \
$(WM_DECOMP_INC) \ -I$(LIB_SRC)/tetFiniteElement/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetMotionSolver/lnInclude \
-I$(LIB_SRC)/tetDecompositionMotionSolver/lnInclude \
-I../solidModels/lnInclude \ -I../solidModels/lnInclude \
-I$(FOAM_SRC)/VectorN/lnInclude -I$(FOAM_SRC)/VectorN/lnInclude
@ -22,6 +21,7 @@ EXE_LIBS = \
-ldynamicFvMesh \ -ldynamicFvMesh \
-ldynamicMesh \ -ldynamicMesh \
-llduSolvers \ -llduSolvers \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-ltetMotionSolver \
-L$(FOAM_USER_LIBBIN) -lsolidModels \ -L$(FOAM_USER_LIBBIN) -lsolidModels \
-lVectorN -lVectorN

2
applications/solvers/solidMechanics/solidModels/Make/files
View file

@ -56,4 +56,4 @@ interpolation/leastSquaresVolPointInterpolation/leastSquaresVolPointInterpolatio
solidInterface/solidInterface.C solidInterface/solidInterface.C
LIB = $(FOAM_USER_LIBBIN)/libsolidModels LIB = $(FOAM_LIBBIN)/libsolidModels

8
applications/solvers/stressAnalysis/icoFsiFoam/Make/options
View file

@ -2,15 +2,15 @@ EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
$(WM_DECOMP_INC) \ -I$(LIB_SRC)/tetFiniteElement/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/tetMotionSolver/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/tetDecompositionMotionSolver/lnInclude \
EXE_LIBS = \ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
-ldynamicFvMesh \ -ldynamicFvMesh \
-ldynamicMesh \ -ldynamicMesh \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-ltetMotionSolver \
-llduSolvers \ -llduSolvers \
-L$(MESQUITE_LIB_DIR) -lmesquite -L$(MESQUITE_LIB_DIR) -lmesquite

5
applications/solvers/stressAnalysis/stressFemFoam/Make/options
View file

@ -1,10 +1,9 @@
EXE_INC = \ EXE_INC = \
-IfemStress/Traction \ -IfemStress/Traction \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude
$(WM_DECOMP_INC)
EXE_LIBS = \ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-llduSolvers -llduSolvers

10
applications/solvers/surfaceTracking/freeSurface/Make/options
View file

@ -3,14 +3,14 @@ EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \ -I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude\
-I$(LIB_SRC)/dynamicMesh/meshMotion/tetDecompositionMotionSolver/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/tetMotionSolver/lnInclude
$(WM_DECOMP_INC)
EXE_LIBS = \ EXE_LIBS = \
-lfiniteArea \ -lfiniteArea \
-lfiniteVolume \ -lfiniteVolume \
-lmeshTools \ -lmeshTools \
-ldynamicMesh \ -ldynamicMesh \
$(WM_DECOMP_LIBS) -ltetFiniteElement \
-ltetMotionSolver

8
applications/solvers/surfaceTracking/utilities/setFluidIndicator/Make/options
View file

@ -5,9 +5,8 @@ EXE_INC = \
-I$(LIB_SRC)/finiteArea/lnInclude \ -I$(LIB_SRC)/finiteArea/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \ -I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \
$(WM_DECOMP_INC) \ -I$(LIB_SRC)/tetFiniteElement/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetMotionSolver/lnInclude
-I$(LIB_SRC)/tetDecompositionMotionSolver/lnInclude
EXE_LIBS = \ EXE_LIBS = \
-lfreeSurface \ -lfreeSurface \
@ -16,4 +15,5 @@ EXE_LIBS = \
-ldynamicFvMesh \ -ldynamicFvMesh \
-ldynamicMesh \ -ldynamicMesh \
-lmeshTools \ -lmeshTools \
$(WM_DECOMP_LIBS) -ltetFiniteElement \
-ltetMotionSolver

4
applications/utilities/mesh/manipulation/deformedTetFemGeom/Make/options
View file

@ -1,7 +1,5 @@
EXE_INC = \ EXE_INC = \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \
$(WM_DECOMP_INC) \
-I$(LIB_SRC)/tetFiniteElement/lnInclude -I$(LIB_SRC)/tetFiniteElement/lnInclude
EXE_LIBS = \ EXE_LIBS = \
$(WM_DECOMP_LIBS) -ltetFiniteElement

6
applications/utilities/mesh/manipulation/moveDyMEngineMesh/Make/options
View file

@ -3,8 +3,7 @@ EXE_INC = \
-I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \ -I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/engine/lnInclude \ -I$(LIB_SRC)/engine/lnInclude
$(WM_DECOMP_INC)
EXE_LIBS = \ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
@ -13,6 +12,7 @@ EXE_LIBS = \
-lmeshTools \ -lmeshTools \
-lengine \ -lengine \
-lmeshTools \ -lmeshTools \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-ltetMotionSolver \
-llduSolvers \ -llduSolvers \
-L$(MESQUITE_LIB_DIR) -lmesquite -L$(MESQUITE_LIB_DIR) -lmesquite

5
applications/utilities/mesh/manipulation/tetDecomposition/Make/options
View file

@ -1,8 +1,7 @@
EXE_INC = \ EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude
$(WM_DECOMP_INC)
EXE_LIBS = \ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
$(WM_DECOMP_LIBS) -ltetFiniteElement

3
applications/utilities/miscellaneous/foamDebugSwitches/Make/options
View file

@ -12,7 +12,8 @@ EXE_LIBS = \
-lerrorEstimation \ -lerrorEstimation \
-lfiniteVolume \ -lfiniteVolume \
-lfiniteArea \ -lfiniteArea \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-ltetMotionSolver \
-lforces \ -lforces \
-lfvMotionSolver \ -lfvMotionSolver \
-lincompressibleLESModels \ -lincompressibleLESModels \

5
applications/utilities/parallelProcessing/decomposePar/Make/options
View file

@ -4,8 +4,7 @@ EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/finiteArea/lnInclude \ -I$(LIB_SRC)/finiteArea/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \ -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude
$(WM_DECOMP_INC)
EXE_LIBS = \ EXE_LIBS = \
-ldecompositionMethods \ -ldecompositionMethods \
@ -13,4 +12,4 @@ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
-lfiniteArea \ -lfiniteArea \
-llagrangian \ -llagrangian \
$(WM_DECOMP_LIBS) -ltetFiniteElement

5
applications/utilities/parallelProcessing/reconstructPar/Make/options
View file

@ -2,12 +2,11 @@ EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/finiteArea/lnInclude \ -I$(LIB_SRC)/finiteArea/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \ -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude
$(WM_DECOMP_INC)
EXE_LIBS = \ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
-lfiniteArea \ -lfiniteArea \
-llagrangian \ -llagrangian \
-lmeshTools \ -lmeshTools \
$(WM_DECOMP_LIBS) -ltetFiniteElement

5
applications/utilities/parallelProcessing/reconstructParMesh/Make/options
View file

@ -2,12 +2,11 @@ EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/finiteArea/lnInclude \ -I$(LIB_SRC)/finiteArea/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \ -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude
$(WM_DECOMP_INC)
EXE_LIBS = \ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
-lfiniteArea \ -lfiniteArea \
-llagrangian \ -llagrangian \
-lmeshTools \ -lmeshTools \
$(WM_DECOMP_LIBS) -ltetFiniteElement

5
etc/settings.csh
View file

@ -45,11 +45,6 @@ setenv WM_LINK_LANGUAGE c++
setenv WM_OPTIONS $WM_ARCH$WM_COMPILER$WM_PRECISION_OPTION$WM_COMPILE_OPTION setenv WM_OPTIONS $WM_ARCH$WM_COMPILER$WM_PRECISION_OPTION$WM_COMPILE_OPTION
set path=($WM_DIR $path) set path=($WM_DIR $path)
#setenv WM_DECOMP_INC -DCELL_DECOMP
#setenv WM_DECOMP_LIBS "-lcellDecompFiniteElement -lcellDecompositionMotionSolver"
setenv WM_DECOMP_INC -DFACE_DECOMP
setenv WM_DECOMP_LIBS "-lfaceDecompFiniteElement -lfaceDecompositionMotionSolver"
# base configuration # base configuration
setenv FOAM_APP $WM_PROJECT_DIR/applications setenv FOAM_APP $WM_PROJECT_DIR/applications
setenv FOAM_APPBIN $WM_PROJECT_DIR/applications/bin/$WM_OPTIONS setenv FOAM_APPBIN $WM_PROJECT_DIR/applications/bin/$WM_OPTIONS

5
etc/settings.sh
View file

@ -82,11 +82,6 @@ export WM_LINK_LANGUAGE=c++
export WM_OPTIONS=$WM_ARCH$WM_COMPILER$WM_PRECISION_OPTION$WM_COMPILE_OPTION export WM_OPTIONS=$WM_ARCH$WM_COMPILER$WM_PRECISION_OPTION$WM_COMPILE_OPTION
export PATH=$WM_DIR:$PATH export PATH=$WM_DIR:$PATH
#export WM_DECOMP_INC=-DCELL_DECOMP
#export WM_DECOMP_LIBS="-lcellDecompFiniteElement -lcellDecompositionMotionSolver"
export WM_DECOMP_INC=-DFACE_DECOMP
export WM_DECOMP_LIBS="-lfaceDecompFiniteElement -lfaceDecompositionMotionSolver"
# base configuration # base configuration
export FOAM_APP=$WM_PROJECT_DIR/applications export FOAM_APP=$WM_PROJECT_DIR/applications
export FOAM_APPBIN=$WM_PROJECT_DIR/applications/bin/$WM_OPTIONS export FOAM_APPBIN=$WM_PROJECT_DIR/applications/bin/$WM_OPTIONS

2
src/Allwmake
View file

@ -41,7 +41,7 @@ wmake libso finiteArea
wmake libso lduSolvers wmake libso lduSolvers
wmake libso VectorN wmake libso VectorN
(cd tetDecompositionFiniteElement ; ./Allwmake) wmake libso tetFiniteElement
# Make dynamicMesh tools # Make dynamicMesh tools
dynamicMesh/AllwmakeLnInclude dynamicMesh/AllwmakeLnInclude

2
src/OpenFOAM/containers/Lists/UPtrList/UPtrList.C
View file

@ -78,7 +78,7 @@ void Foam::UPtrList<T>::setSize(const label newSize)
ptrs_.setSize(newSize); ptrs_.setSize(newSize);
// set new elements to NULL // set new elements to NULL
for (register label i=oldSize; i<newSize; i++) for (register label i = oldSize; i < newSize; i++)
{ {
ptrs_[i] = NULL; ptrs_[i] = NULL;
} }

8
src/dynamicMesh/dynamicFvMesh/Make/options
View file

@ -4,9 +4,8 @@ EXE_INC = \
-I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/solidBodyMotion/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/solidBodyMotion/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/tetDecompositionMotionSolver/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/tetMotionSolver/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude \
$(WM_DECOMP_INC) \
-I$(LIB_SRC)/dynamicMesh/meshMotion/fvMotionSolver/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/fvMotionSolver/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/RBFMotionSolver/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/RBFMotionSolver/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/mesquiteMotionSolver/lnInclude -I$(LIB_SRC)/dynamicMesh/meshMotion/mesquiteMotionSolver/lnInclude
@ -17,7 +16,8 @@ LIB_LIBS = \
-ldynamicMesh \ -ldynamicMesh \
-lfiniteVolume \ -lfiniteVolume \
-lsolidBodyMotion \ -lsolidBodyMotion \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-ltetMotionSolver \
-lfvMotionSolver \ -lfvMotionSolver \
-lRBFMotionSolver \ -lRBFMotionSolver \
-lmesquiteMotionSolver -lmesquiteMotionSolver

12
src/dynamicMesh/dynamicFvMesh/dynamicBodyFvMesh/dynamicBodyFvMesh.C
View file

@ -29,8 +29,8 @@ License
#include "motionSolver.H" #include "motionSolver.H"
#include "volFields.H" #include "volFields.H"
#include "mathematicalConstants.H" #include "mathematicalConstants.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "laplaceTetDecompositionMotionSolver.H" #include "laplaceTetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "transformField.H" #include "transformField.H"
@ -131,11 +131,11 @@ bool Foam::dynamicBodyFvMesh::update()
if if
( (
motionPtr_->type() motionPtr_->type()
== laplaceTetDecompositionMotionSolver::typeName == laplaceTetMotionSolver::typeName
) )
{ {
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
dynamic_cast<tetDecompositionMotionSolver&> dynamic_cast<tetMotionSolver&>
( (
motionPtr_() motionPtr_()
); );
@ -216,7 +216,7 @@ bool Foam::dynamicBodyFvMesh::update()
<< "Selected mesh motion solver is " << "Selected mesh motion solver is "
<< motionPtr_->type() << motionPtr_->type()
<< ", instead " << ", instead "
<< tetDecompositionMotionSolver::typeName << tetMotionSolver::typeName
<< exit(FatalError); << exit(FatalError);
} }

14
src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C
View file

@ -180,7 +180,7 @@ void eMesh::calcEdgePoints() const
// NOTE: Will work only on tetrahedral meshes! // NOTE: Will work only on tetrahedral meshes!
bool found; bool found;
label faceIndex = -1 label faceIndex = -1;
label cellIndex = -1; label cellIndex = -1;
const labelList& owner = mesh_.faceOwner(); const labelList& owner = mesh_.faceOwner();
const labelList& neighbour = mesh_.faceNeighbour(); const labelList& neighbour = mesh_.faceNeighbour();
@ -259,7 +259,8 @@ void eMesh::calcEdgePoints() const
) )
{ {
faceIndex = cellToCheck[0]; faceIndex = cellToCheck[0];
found = true; break; found = true;
break;
} }
if if
@ -269,7 +270,8 @@ void eMesh::calcEdgePoints() const
) )
{ {
faceIndex = cellToCheck[1]; faceIndex = cellToCheck[1];
found = true; break; found = true;
break;
} }
if if
@ -279,7 +281,8 @@ void eMesh::calcEdgePoints() const
) )
{ {
faceIndex = cellToCheck[2]; faceIndex = cellToCheck[2];
found = true; break; found = true;
break;
} }
if if
@ -289,7 +292,8 @@ void eMesh::calcEdgePoints() const
) )
{ {
faceIndex = cellToCheck[3]; faceIndex = cellToCheck[3];
found = true; break; found = true;
break;
} }
} }

3
src/dynamicMesh/meshMotion/Allwmake
View file

@ -7,7 +7,6 @@ wmake libso solidBodyMotion
wmake libso fvMotionSolver wmake libso fvMotionSolver
wmake libso RBFMotionSolver wmake libso RBFMotionSolver
wmake libso mesquiteMotionSolver wmake libso mesquiteMotionSolver
(cd tetDecompositionMotionSolver ; ./Allwmake) wmake libso tetMotionSolver
wmake libso solidBodyMotion
# ----------------------------------------------------------------- end-of-file # ----------------------------------------------------------------- end-of-file

8
src/dynamicMesh/meshMotion/solidBodyMotion/Make/options
View file

@ -3,9 +3,8 @@ EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude \ -I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/tetDecompositionMotionSolver/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/tetMotionSolver/lnInclude \
$(WM_DECOMP_INC) \
-I$(LIB_SRC)/dynamicMesh/meshMotion/fvMotionSolver/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/fvMotionSolver/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/RBFMotionSolver/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/RBFMotionSolver/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/mesquiteMotionSolver/lnInclude -I$(LIB_SRC)/dynamicMesh/meshMotion/mesquiteMotionSolver/lnInclude
@ -15,7 +14,8 @@ LIB_LIBS = \
-lmeshTools \ -lmeshTools \
-ldynamicMesh \ -ldynamicMesh \
-lfiniteVolume \ -lfiniteVolume \
$(WM_DECOMP_LIBS) \ -ltetFiniteElement \
-ltetMotionSolver \
-lfvMotionSolver \ -lfvMotionSolver \
-lRBFMotionSolver \ -lRBFMotionSolver \
-lmesquiteMotionSolver -lmesquiteMotionSolver

4
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/Allwmake
View file

@ -1,4 +0,0 @@
#!/bin/sh
wmake libso . Make.cellDecomp
wmake libso . Make.faceDecomp

11
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/Make.cellDecomp/options
View file

@ -1,11 +0,0 @@
EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \
-DCELL_DECOMP
LIB_LIBS = \
-ldynamicMesh \
-lmeshTools \
-lcellDecompFiniteElement

17
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/Make.faceDecomp/files
View file

@ -1,17 +0,0 @@
tetDecompositionMotionSolver/tetDecompositionMotionSolver.C
tetDecompositionMotionSolver/laplace/laplaceTetDecompositionMotionSolver.C
tetDecompositionMotionSolver/pseudoSolid/pseudoSolidTetDecompositionMotionSolver.C
cellQuality/cellQuality.C
motionDiffs/motionDiff/motionDiff.C
motionDiffs/uniform/uniformDiff.C
motionDiffs/deformationEnergy/deformationEnergyDiff.C
motionDiffs/distortionEnergy/distortionEnergyDiff.C
motionDiffs/linear/linearDiff.C
motionDiffs/quadratic/quadraticDiff.C
motionDiffs/exponential/exponentialDiff.C
motionDiffs/patchEnhanced/patchEnhancedDiff.C
motionDiffs/file/fileDiff.C
LIB = $(FOAM_LIBBIN)/libfaceDecompositionMotionSolver

8
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/Make.cellDecomp/files → src/dynamicMesh/meshMotion/tetMotionSolver/Make/files
View file

@ -1,6 +1,6 @@
tetDecompositionMotionSolver/tetDecompositionMotionSolver.C tetMotionSolver/tetMotionSolver.C
tetDecompositionMotionSolver/laplace/laplaceTetDecompositionMotionSolver.C tetMotionSolver/laplace/laplaceTetMotionSolver.C
tetDecompositionMotionSolver/pseudoSolid/pseudoSolidTetDecompositionMotionSolver.C tetMotionSolver/pseudoSolid/pseudoSolidTetMotionSolver.C
cellQuality/cellQuality.C cellQuality/cellQuality.C
@ -14,4 +14,4 @@ motionDiffs/exponential/exponentialDiff.C
motionDiffs/patchEnhanced/patchEnhancedDiff.C motionDiffs/patchEnhanced/patchEnhancedDiff.C
motionDiffs/file/fileDiff.C motionDiffs/file/fileDiff.C
LIB = $(FOAM_LIBBIN)/libcellDecompositionMotionSolver LIB = $(FOAM_LIBBIN)/libtetMotionSolver

5
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/Make.faceDecomp/options → src/dynamicMesh/meshMotion/tetMotionSolver/Make/options
View file

@ -2,10 +2,9 @@ EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude \ -I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \ -I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude
-DFACE_DECOMP
LIB_LIBS = \ LIB_LIBS = \
-ldynamicMesh \ -ldynamicMesh \
-lmeshTools \ -lmeshTools \
-lfaceDecompFiniteElement -ltetFiniteElement

0
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/cellQuality/cellQuality.C → src/dynamicMesh/meshMotion/tetMotionSolver/cellQuality/cellQuality.C
View file

0
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/cellQuality/cellQuality.H → src/dynamicMesh/meshMotion/tetMotionSolver/cellQuality/cellQuality.H
View file

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/deformationEnergy/deformationEnergyDiff.C → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/deformationEnergy/deformationEnergyDiff.C
View file

@ -46,7 +46,7 @@ namespace Foam
// Construct from components // Construct from components
Foam::deformationEnergyDiff::deformationEnergyDiff Foam::deformationEnergyDiff::deformationEnergyDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
) )
: :
motionDiff(mSolver), motionDiff(mSolver),

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/deformationEnergy/deformationEnergyDiff.H → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/deformationEnergy/deformationEnergyDiff.H
View file

@ -85,7 +85,7 @@ public:
//- Construct from components //- Construct from components
deformationEnergyDiff deformationEnergyDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
); );

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/distortionEnergy/distortionEnergyDiff.C → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/distortionEnergy/distortionEnergyDiff.C
View file

@ -46,7 +46,7 @@ namespace Foam
// Construct from components // Construct from components
Foam::distortionEnergyDiff::distortionEnergyDiff Foam::distortionEnergyDiff::distortionEnergyDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
) )
: :
motionDiff(mSolver), motionDiff(mSolver),

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/distortionEnergy/distortionEnergyDiff.H → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/distortionEnergy/distortionEnergyDiff.H
View file

@ -89,7 +89,7 @@ public:
//- Construct from components //- Construct from components
distortionEnergyDiff distortionEnergyDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
); );

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/exponential/exponentialDiff.C → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/exponential/exponentialDiff.C
View file

@ -45,7 +45,7 @@ namespace Foam
// Construct from components // Construct from components
Foam::exponentialDiff::exponentialDiff Foam::exponentialDiff::exponentialDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
) )
: :
linearDiff(mSolver) linearDiff(mSolver)

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/exponential/exponentialDiff.H → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/exponential/exponentialDiff.H
View file

@ -71,7 +71,7 @@ public:
//- Construct from components //- Construct from components
exponentialDiff exponentialDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
); );

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/file/fileDiff.C → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/file/fileDiff.C
View file

@ -46,7 +46,7 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components // Construct from components
Foam::fileDiff::fileDiff(const tetDecompositionMotionSolver& mSolver) Foam::fileDiff::fileDiff(const tetMotionSolver& mSolver)
: :
motionDiff(mSolver), motionDiff(mSolver),
motionGamma_ motionGamma_

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/file/fileDiff.H → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/file/fileDiff.H
View file

@ -76,7 +76,7 @@ public:
// Constructors // Constructors
//- Construct from components //- Construct from components
fileDiff(const tetDecompositionMotionSolver& mSolver); fileDiff(const tetMotionSolver& mSolver);
// Destructor // Destructor

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/linear/linearDiff.C → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/linear/linearDiff.C
View file

@ -45,7 +45,7 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components // Construct from components
Foam::linearDiff::linearDiff(const tetDecompositionMotionSolver& mSolver) Foam::linearDiff::linearDiff(const tetMotionSolver& mSolver)
: :
motionDiff(mSolver), motionDiff(mSolver),
patchNames_(mSolver.lookup("distancePatches")), patchNames_(mSolver.lookup("distancePatches")),

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/linear/linearDiff.H → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/linear/linearDiff.H
View file

@ -91,7 +91,7 @@ public:
//- Construct from components //- Construct from components
linearDiff linearDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
); );

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/motionDiff/motionDiff.C → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/motionDiff/motionDiff.C
View file

@ -42,7 +42,7 @@ namespace Foam
Foam::autoPtr<Foam::motionDiff> Foam::motionDiff::New Foam::autoPtr<Foam::motionDiff> Foam::motionDiff::New
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
) )
{ {
const dictionary& dict = mSolver; const dictionary& dict = mSolver;

12
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/motionDiff/motionDiff.H → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/motionDiff/motionDiff.H
View file

@ -38,7 +38,7 @@ SourceFiles
#include "tetPolyMesh.H" #include "tetPolyMesh.H"
#include "elementFieldsFwd.H" #include "elementFieldsFwd.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -56,7 +56,7 @@ private:
// Private data // Private data
//- Mesh reference //- Mesh reference
const tetDecompositionMotionSolver& mSolver_; const tetMotionSolver& mSolver_;
public: public:
@ -73,7 +73,7 @@ public:
motionDiff, motionDiff,
dictionary, dictionary,
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
), ),
(mSolver) (mSolver)
); );
@ -84,14 +84,14 @@ public:
//- Select null constructed //- Select null constructed
static autoPtr<motionDiff> New static autoPtr<motionDiff> New
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
); );
// Constructors // Constructors
//- Construct from components //- Construct from components
motionDiff(const tetDecompositionMotionSolver& mSolver) motionDiff(const tetMotionSolver& mSolver)
: :
mSolver_(mSolver) mSolver_(mSolver)
{} {}
@ -105,7 +105,7 @@ public:
// Member Functions // Member Functions
//- Return reference to mesh //- Return reference to mesh
const tetDecompositionMotionSolver& mSolver() const const tetMotionSolver& mSolver() const
{ {
return mSolver_; return mSolver_;
} }

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/patchEnhanced/patchEnhancedDiff.C → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/patchEnhanced/patchEnhancedDiff.C
View file

@ -45,7 +45,7 @@ namespace Foam
// Construct from components // Construct from components
Foam::patchEnhancedDiff::patchEnhancedDiff Foam::patchEnhancedDiff::patchEnhancedDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
) )
: :
motionDiff(mSolver), motionDiff(mSolver),

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/patchEnhanced/patchEnhancedDiff.H → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/patchEnhanced/patchEnhancedDiff.H
View file

@ -81,7 +81,7 @@ public:
//- Construct from components //- Construct from components
patchEnhancedDiff patchEnhancedDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
); );

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/quadratic/quadraticDiff.C → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/quadratic/quadraticDiff.C
View file

@ -45,7 +45,7 @@ namespace Foam
// Construct from components // Construct from components
Foam::quadraticDiff::quadraticDiff Foam::quadraticDiff::quadraticDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
) )
: :
linearDiff(mSolver) linearDiff(mSolver)

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/quadratic/quadraticDiff.H → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/quadratic/quadraticDiff.H
View file

@ -71,7 +71,7 @@ public:
//- Construct from components //- Construct from components
quadraticDiff quadraticDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
); );

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/uniform/uniformDiff.C → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/uniform/uniformDiff.C
View file

@ -46,7 +46,7 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components // Construct from components
Foam::uniformDiff::uniformDiff(const tetDecompositionMotionSolver& mSolver) Foam::uniformDiff::uniformDiff(const tetMotionSolver& mSolver)
: :
motionDiff(mSolver), motionDiff(mSolver),
motionGamma_ motionGamma_

2
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/motionDiffs/uniform/uniformDiff.H → src/dynamicMesh/meshMotion/tetMotionSolver/motionDiffs/uniform/uniformDiff.H
View file

@ -80,7 +80,7 @@ public:
//- Construct from components //- Construct from components
uniformDiff uniformDiff
( (
const tetDecompositionMotionSolver& mSolver const tetMotionSolver& mSolver
); );

22
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/tetDecompositionMotionSolver/laplace/laplaceTetDecompositionMotionSolver.C → src/dynamicMesh/meshMotion/tetMotionSolver/tetMotionSolver/laplace/laplaceTetMotionSolver.C
View file

@ -29,7 +29,7 @@ Description
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "laplaceTetDecompositionMotionSolver.H" #include "laplaceTetMotionSolver.H"
#include "motionDiff.H" #include "motionDiff.H"
#include "addToRunTimeSelectionTable.H" #include "addToRunTimeSelectionTable.H"
#include "tetFem.H" #include "tetFem.H"
@ -40,11 +40,11 @@ Description
namespace Foam namespace Foam
{ {
defineTypeNameAndDebug(laplaceTetDecompositionMotionSolver, 0); defineTypeNameAndDebug(laplaceTetMotionSolver, 0);
addToRunTimeSelectionTable addToRunTimeSelectionTable
( (
tetDecompositionMotionSolver, tetMotionSolver,
laplaceTetDecompositionMotionSolver, laplaceTetMotionSolver,
dictionary dictionary
); );
} }
@ -52,13 +52,13 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components // Construct from components
Foam::laplaceTetDecompositionMotionSolver::laplaceTetDecompositionMotionSolver Foam::laplaceTetMotionSolver::laplaceTetMotionSolver
( (
const polyMesh& mesh, const polyMesh& mesh,
Istream& Istream&
) )
: :
tetDecompositionMotionSolver(mesh), tetMotionSolver(mesh),
diffusionPtr_(motionDiff::New(*this).ptr()), diffusionPtr_(motionDiff::New(*this).ptr()),
firstMotion_(true), firstMotion_(true),
solverPerf_() solverPerf_()
@ -69,8 +69,8 @@ Foam::laplaceTetDecompositionMotionSolver::laplaceTetDecompositionMotionSolver
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::laplaceTetDecompositionMotionSolver:: Foam::laplaceTetMotionSolver::
~laplaceTetDecompositionMotionSolver() ~laplaceTetMotionSolver()
{ {
deleteDemandDrivenData(diffusionPtr_); deleteDemandDrivenData(diffusionPtr_);
} }
@ -78,7 +78,7 @@ Foam::laplaceTetDecompositionMotionSolver::
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::laplaceTetDecompositionMotionSolver::solve() void Foam::laplaceTetMotionSolver::solve()
{ {
// Solve for mesh motion // Solve for mesh motion
@ -126,13 +126,13 @@ void Foam::laplaceTetDecompositionMotionSolver::solve()
} }
void Foam::laplaceTetDecompositionMotionSolver::updateMesh void Foam::laplaceTetMotionSolver::updateMesh
( (
const mapPolyMesh& mpm const mapPolyMesh& mpm
) )
{ {
firstMotion_ = true; firstMotion_ = true;
tetDecompositionMotionSolver::updateMesh(mpm); tetMotionSolver::updateMesh(mpm);
} }

34
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/tetDecompositionMotionSolver/laplace/laplaceTetDecompositionMotionSolver.H → src/dynamicMesh/meshMotion/tetMotionSolver/tetMotionSolver/laplace/laplaceTetMotionSolver.H
View file

@ -23,7 +23,7 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class Class
laplaceTetDecompositionMotionSolver laplaceTetMotionSolver
Description Description
Mesh motion solver for a polyMesh. Based on solving the Mesh motion solver for a polyMesh. Based on solving the
@ -31,14 +31,14 @@ Description
boundary condition on the motion velocity variable motionU. boundary condition on the motion velocity variable motionU.
SourceFiles SourceFiles
laplaceTetDecompositionMotionSolver.C laplaceTetMotionSolver.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef laplaceTetDecompositionMotionSolver_H #ifndef laplaceTetMotionSolver_H
#define laplaceTetDecompositionMotionSolver_H #define laplaceTetMotionSolver_H
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "tetPolyMesh.H" #include "tetPolyMesh.H"
#include "tetPointFields.H" #include "tetPointFields.H"
#include "elementFields.H" #include "elementFields.H"
@ -54,12 +54,12 @@ namespace Foam
class motionDiff; class motionDiff;
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class laplaceTetDecompositionMotionSolver Declaration Class laplaceTetMotionSolver Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
class laplaceTetDecompositionMotionSolver class laplaceTetMotionSolver
: :
public tetDecompositionMotionSolver public tetMotionSolver
{ {
// Private data // Private data
@ -67,13 +67,13 @@ class laplaceTetDecompositionMotionSolver
// Private Member Functions // Private Member Functions
//- Disallow default bitwise copy construct //- Disallow default bitwise copy construct
laplaceTetDecompositionMotionSolver laplaceTetMotionSolver
( (
const laplaceTetDecompositionMotionSolver& const laplaceTetMotionSolver&
); );
//- Disallow default bitwise assignment //- Disallow default bitwise assignment
void operator=(const laplaceTetDecompositionMotionSolver&); void operator=(const laplaceTetMotionSolver&);
protected: protected:
@ -100,18 +100,12 @@ protected:
public: public:
//- Runtime type information //- Runtime type information
#ifdef CELL_DECOMP TypeName("laplace");
TypeName("laplaceCellDecomposition");
#elif defined(FACE_DECOMP)
TypeName("laplaceFaceDecomposition");
#else
#error Undefined: cell or face decomposition
#endif
// Constructors // Constructors
laplaceTetDecompositionMotionSolver laplaceTetMotionSolver
( (
const polyMesh& mesh, const polyMesh& mesh,
Istream& msData Istream& msData
@ -120,7 +114,7 @@ public:
// Destructor // Destructor
virtual ~laplaceTetDecompositionMotionSolver(); virtual ~laplaceTetMotionSolver();
// Member Functions // Member Functions

20
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/tetDecompositionMotionSolver/pseudoSolid/pseudoSolidTetDecompositionMotionSolver.C → src/dynamicMesh/meshMotion/tetMotionSolver/tetMotionSolver/pseudoSolid/pseudoSolidTetMotionSolver.C
View file

@ -29,7 +29,7 @@ Description
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "pseudoSolidTetDecompositionMotionSolver.H" #include "pseudoSolidTetMotionSolver.H"
#include "motionDiff.H" #include "motionDiff.H"
#include "addToRunTimeSelectionTable.H" #include "addToRunTimeSelectionTable.H"
#include "tetFem.H" #include "tetFem.H"
@ -38,11 +38,11 @@ Description
namespace Foam namespace Foam
{ {
defineTypeNameAndDebug(pseudoSolidTetDecompositionMotionSolver, 0); defineTypeNameAndDebug(pseudoSolidTetMotionSolver, 0);
addToRunTimeSelectionTable addToRunTimeSelectionTable
( (
tetDecompositionMotionSolver, tetMotionSolver,
pseudoSolidTetDecompositionMotionSolver, pseudoSolidTetMotionSolver,
dictionary dictionary
); );
} }
@ -51,14 +51,14 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components // Construct from components
Foam::pseudoSolidTetDecompositionMotionSolver:: Foam::pseudoSolidTetMotionSolver::
pseudoSolidTetDecompositionMotionSolver pseudoSolidTetMotionSolver
( (
const polyMesh& mesh, const polyMesh& mesh,
Istream& msData Istream& msData
) )
: :
laplaceTetDecompositionMotionSolver(mesh, msData) laplaceTetMotionSolver(mesh, msData)
{ {
const dictionary& pseudoSolidDic = subDict("pseudoSolid"); const dictionary& pseudoSolidDic = subDict("pseudoSolid");
@ -74,14 +74,14 @@ pseudoSolidTetDecompositionMotionSolver
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::pseudoSolidTetDecompositionMotionSolver:: Foam::pseudoSolidTetMotionSolver::
~pseudoSolidTetDecompositionMotionSolver() ~pseudoSolidTetMotionSolver()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::pseudoSolidTetDecompositionMotionSolver::solve() void Foam::pseudoSolidTetMotionSolver::solve()
{ {
// Solve for mesh motion // Solve for mesh motion

34
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/tetDecompositionMotionSolver/pseudoSolid/pseudoSolidTetDecompositionMotionSolver.H → src/dynamicMesh/meshMotion/tetMotionSolver/tetMotionSolver/pseudoSolid/pseudoSolidTetMotionSolver.H
View file

@ -23,7 +23,7 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class Class
pseudoSolidTetDecompositionMotionSolver pseudoSolidTetMotionSolver
Description Description
Mesh motion solver for a polyMesh. Based on solving the Mesh motion solver for a polyMesh. Based on solving the
@ -34,14 +34,14 @@ Description
as Lame's constant \mu as Lame's constant \mu
SourceFiles SourceFiles
pseudoSolidTetDecompositionMotionSolver.C pseudoSolidTetMotionSolver.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef pseudoSolidTetDecompositionMotionSolver_H #ifndef pseudoSolidTetMotionSolver_H
#define pseudoSolidTetDecompositionMotionSolver_H #define pseudoSolidTetMotionSolver_H
#include "laplaceTetDecompositionMotionSolver.H" #include "laplaceTetMotionSolver.H"
#include "tetPolyMesh.H" #include "tetPolyMesh.H"
#include "tetPointFields.H" #include "tetPointFields.H"
@ -53,12 +53,12 @@ namespace Foam
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class pseudoSolidTetDecompositionMotionSolver Declaration Class pseudoSolidTetMotionSolver Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
class pseudoSolidTetDecompositionMotionSolver class pseudoSolidTetMotionSolver
: :
public laplaceTetDecompositionMotionSolver public laplaceTetMotionSolver
{ {
// Private data // Private data
@ -75,30 +75,24 @@ class pseudoSolidTetDecompositionMotionSolver
// Private Member Functions // Private Member Functions
//- Disallow default bitwise copy construct //- Disallow default bitwise copy construct
pseudoSolidTetDecompositionMotionSolver pseudoSolidTetMotionSolver
( (
const pseudoSolidTetDecompositionMotionSolver& const pseudoSolidTetMotionSolver&
); );
//- Disallow default bitwise assignment //- Disallow default bitwise assignment
void operator=(const pseudoSolidTetDecompositionMotionSolver&); void operator=(const pseudoSolidTetMotionSolver&);
public: public:
//- Runtime type information //- Runtime type information
#ifdef CELL_DECOMP TypeName("pseudoSolid");
TypeName("pseudoSolidCellDecomposition");
#elif defined(FACE_DECOMP)
TypeName("pseudoSolidFaceDecomposition");
#else
#error Undefined: cell or face decomposition
#endif
// Constructors // Constructors
pseudoSolidTetDecompositionMotionSolver pseudoSolidTetMotionSolver
( (
const polyMesh& mesh, const polyMesh& mesh,
Istream& msData Istream& msData
@ -107,7 +101,7 @@ public:
// Destructor // Destructor
virtual ~pseudoSolidTetDecompositionMotionSolver(); virtual ~pseudoSolidTetMotionSolver();
// Member Functions // Member Functions

32
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/tetDecompositionMotionSolver/tetDecompositionMotionSolver.C → src/dynamicMesh/meshMotion/tetMotionSolver/tetMotionSolver/tetMotionSolver.C
View file

@ -27,19 +27,19 @@ Description
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "tetFec.H" #include "tetFec.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam namespace Foam
{ {
defineTypeNameAndDebug(tetDecompositionMotionSolver, 0); defineTypeNameAndDebug(tetMotionSolver, 0);
} }
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * // // * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
void Foam::tetDecompositionMotionSolver::applyConstraints void Foam::tetMotionSolver::applyConstraints
( (
tetFemVectorMatrix& matrix tetFemVectorMatrix& matrix
) )
@ -53,7 +53,7 @@ void Foam::tetDecompositionMotionSolver::applyConstraints
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::tetDecompositionMotionSolver::tetDecompositionMotionSolver Foam::tetMotionSolver::tetMotionSolver
( (
const polyMesh& mesh const polyMesh& mesh
) )
@ -80,7 +80,7 @@ Foam::tetDecompositionMotionSolver::tetDecompositionMotionSolver
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::tetDecompositionMotionSolver::~tetDecompositionMotionSolver() Foam::tetMotionSolver::~tetMotionSolver()
{ {
deleteDemandDrivenData(totDisplacementPtr_); deleteDemandDrivenData(totDisplacementPtr_);
} }
@ -89,7 +89,7 @@ Foam::tetDecompositionMotionSolver::~tetDecompositionMotionSolver()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::pointField> Foam::tmp<Foam::pointField>
Foam::tetDecompositionMotionSolver::curPoints() const Foam::tetMotionSolver::curPoints() const
{ {
// Process current point positions // Process current point positions
@ -120,7 +120,7 @@ Foam::tetDecompositionMotionSolver::curPoints() const
} }
void Foam::tetDecompositionMotionSolver::setConstraint void Foam::tetMotionSolver::setConstraint
( (
const label pointID, const label pointID,
const vector& fixedVel const vector& fixedVel
@ -132,14 +132,14 @@ void Foam::tetDecompositionMotionSolver::setConstraint
} }
void Foam::tetDecompositionMotionSolver::clearConstraints() void Foam::tetMotionSolver::clearConstraints()
{ {
fixedPoints_.clear(); fixedPoints_.clear();
fixedVelocity_.clear(); fixedVelocity_.clear();
} }
void Foam::tetDecompositionMotionSolver::updateMesh(const mapPolyMesh& mpm) void Foam::tetMotionSolver::updateMesh(const mapPolyMesh& mpm)
{ {
tetPolyMeshMapper mapper(tetMesh_, mpm); tetPolyMeshMapper mapper(tetMesh_, mpm);
tetMesh_.updateMesh(mapper); tetMesh_.updateMesh(mapper);
@ -152,7 +152,7 @@ void Foam::tetDecompositionMotionSolver::updateMesh(const mapPolyMesh& mpm)
Foam::tmp<Foam::elementScalarField> Foam::tmp<Foam::elementScalarField>
Foam::tetDecompositionMotionSolver::distortionEnergy() const Foam::tetMotionSolver::distortionEnergy() const
{ {
tmp<elementScalarField> tUd tmp<elementScalarField> tUd
( (
@ -184,7 +184,7 @@ Foam::tetDecompositionMotionSolver::distortionEnergy() const
Foam::tmp<Foam::elementScalarField> Foam::tmp<Foam::elementScalarField>
Foam::tetDecompositionMotionSolver::deformationEnergy() const Foam::tetMotionSolver::deformationEnergy() const
{ {
tmp<elementScalarField> tUd tmp<elementScalarField> tUd
( (
@ -219,7 +219,7 @@ Foam::tetDecompositionMotionSolver::deformationEnergy() const
Foam::tmp<Foam::elementScalarField> Foam::tmp<Foam::elementScalarField>
Foam::tetDecompositionMotionSolver::totDistortionEnergy() const Foam::tetMotionSolver::totDistortionEnergy() const
{ {
tmp<elementScalarField> tUd tmp<elementScalarField> tUd
( (
@ -244,9 +244,9 @@ Foam::tetDecompositionMotionSolver::totDistortionEnergy() const
{ {
FatalErrorIn FatalErrorIn
( (
"tetDecompositionMotionSolver::totDeformationEnergy()" "tetMotionSolver::totDeformationEnergy()"
) << "Total displacement field is not stored " ) << "Total displacement field is not stored "
<< "in tetDecompositionMotionSolver object." << endl << "in tetMotionSolver object." << endl
<< exit(FatalError); << exit(FatalError);
} }
@ -261,7 +261,7 @@ Foam::tetDecompositionMotionSolver::totDistortionEnergy() const
Foam::tmp<Foam::elementScalarField> Foam::tmp<Foam::elementScalarField>
Foam::tetDecompositionMotionSolver::totDeformationEnergy() const Foam::tetMotionSolver::totDeformationEnergy() const
{ {
tmp<elementScalarField> tUd tmp<elementScalarField> tUd
( (
@ -286,7 +286,7 @@ Foam::tetDecompositionMotionSolver::totDeformationEnergy() const
{ {
FatalErrorIn FatalErrorIn
( (
"tetDecompositionMotionSolver::totDistortionEnergy()" "tetMotionSolver::totDistortionEnergy()"
) << "Total displacement field is not stored." << endl ) << "Total displacement field is not stored." << endl
<< exit(FatalError); << exit(FatalError);
} }

25
src/dynamicMesh/meshMotion/tetDecompositionMotionSolver/tetDecompositionMotionSolver/tetDecompositionMotionSolver.H → src/dynamicMesh/meshMotion/tetMotionSolver/tetMotionSolver/tetMotionSolver.H
View file

@ -23,18 +23,18 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class Class
tetDecompositionMotionSolver tetMotionSolver
Description Description
Virtual base class for tetDecomposition mesh motion solvers. Virtual base class for tetDecomposition mesh motion solvers.
SourceFiles SourceFiles
tetDecompositionMotionSolver.C tetMotionSolver.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef tetDecompositionMotionSolver_H #ifndef tetMotionSolver_H
#define tetDecompositionMotionSolver_H #define tetMotionSolver_H
#include "motionSolver.H" #include "motionSolver.H"
#include "polyMesh.H" #include "polyMesh.H"
@ -51,10 +51,10 @@ namespace Foam
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class tetDecompositionMotionSolver Declaration Class tetMotionSolver Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
class tetDecompositionMotionSolver class tetMotionSolver
: :
public motionSolver public motionSolver
{ {
@ -87,23 +87,18 @@ protected:
public: public:
//- Runtime type information //- Runtime type information
#ifdef CELL_DECOMP TypeName("tetMotionSolver");
TypeName("cellDecompositionMotionSolver");
#elif defined(FACE_DECOMP)
TypeName("faceDecompositionMotionSolver");
#else
#error Undefined: cell or face decomposition
#endif
// Constructors // Constructors
//- Construct from components //- Construct from components
tetDecompositionMotionSolver(const polyMesh& mesh); tetMotionSolver(const polyMesh& mesh);
// Destructor // Destructor
virtual ~tetDecompositionMotionSolver(); virtual ~tetMotionSolver();
// Member Functions // Member Functions

8
src/dynamicMesh/topoChangerFvMesh/Make/options
View file

@ -4,9 +4,8 @@ EXE_INC = \
-I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \ -I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/solidBodyMotion/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/solidBodyMotion/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/tetDecompositionMotionSolver/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/tetMotionSolver/lnInclude
$(WM_DECOMP_INC)
LIB_LIBS = \ LIB_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
@ -14,4 +13,5 @@ LIB_LIBS = \
-ldynamicMesh \ -ldynamicMesh \
-lmeshTools \ -lmeshTools \
-lsolidBodyMotion \ -lsolidBodyMotion \
$(WM_DECOMP_LIBS) -ltetFiniteElement \
-ltetMotionSolver

7
src/engine/Make/options
View file

@ -6,9 +6,8 @@ EXE_INC = \
-I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \
-I$(LIB_SRC)/dynamicMesh/topoChangerFvMesh/lnInclude \ -I$(LIB_SRC)/dynamicMesh/topoChangerFvMesh/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/fvMotionSolver/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/fvMotionSolver/lnInclude \
-I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \ -I$(LIB_SRC)/tetFiniteElement/lnInclude \
-I$(LIB_SRC)/dynamicMesh/meshMotion/tetDecompositionMotionSolver/lnInclude \ -I$(LIB_SRC)/dynamicMesh/meshMotion/tetMotionSolver/lnInclude
$(WM_DECOMP_INC)
LIB_LIBS = \ LIB_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
@ -18,4 +17,4 @@ LIB_LIBS = \
-ldynamicFvMesh \ -ldynamicFvMesh \
-ltopoChangerFvMesh \ -ltopoChangerFvMesh \
-lfvMotionSolver \ -lfvMotionSolver \
$(WM_DECOMP_LIBS) -ltetFiniteElement -ltetMotionSolver

2
src/engine/engineTopoChangerMesh/accordionEngineMesh/accordionEngineMesh.C
View file

@ -37,7 +37,7 @@ License
#include "fvPatchField.H" #include "fvPatchField.H"
#include "Switch.H" #include "Switch.H"
#include "symmetryFvPatch.H" #include "symmetryFvPatch.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

6
src/engine/engineTopoChangerMesh/accordionEngineMesh/accordionEngineMeshMove.C
View file

@ -43,7 +43,7 @@ License
#include "wedgeFvPatch.H" #include "wedgeFvPatch.H"
#include "emptyFvPatch.H" #include "emptyFvPatch.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"
@ -57,8 +57,8 @@ License
bool Foam::accordionEngineMesh::update() bool Foam::accordionEngineMesh::update()
{ {
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
scalar deltaZ = engTime().pistonDisplacement().value(); scalar deltaZ = engTime().pistonDisplacement().value();

2
src/engine/engineTopoChangerMesh/accordionEngineMesh/addAccordionEngineMeshZones.C
View file

@ -31,7 +31,7 @@ License
#include "attachDetachFunctions.H" #include "attachDetachFunctions.H"
#include "directTopoChange.H" #include "directTopoChange.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"

2
src/engine/engineTopoChangerMesh/deformingEngineMesh/addDeformingEngineMeshZones.C
View file

@ -29,7 +29,7 @@ License
#include "regionSplit.H" #include "regionSplit.H"
#include "directTopoChange.H" #include "directTopoChange.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"

2
src/engine/engineTopoChangerMesh/deformingEngineMesh/deformingEngineMesh.C
View file

@ -36,7 +36,7 @@ License
#include "fvPatchField.H" #include "fvPatchField.H"
#include "Switch.H" #include "Switch.H"
#include "symmetryFvPatch.H" #include "symmetryFvPatch.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

6
src/engine/engineTopoChangerMesh/deformingEngineMesh/deformingEngineMeshMove.C
View file

@ -43,7 +43,7 @@ License
#include "wedgeFvPatch.H" #include "wedgeFvPatch.H"
#include "emptyFvPatch.H" #include "emptyFvPatch.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"
@ -54,8 +54,8 @@ License
bool Foam::deformingEngineMesh::update() bool Foam::deformingEngineMesh::update()
{ {
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
scalar deltaZ = engTime().pistonDisplacement().value(); scalar deltaZ = engTime().pistonDisplacement().value();

2
src/engine/engineTopoChangerMesh/engineValveSliding/engineValveSliding.C
View file

@ -41,7 +41,7 @@ Class
#include "fvPatchField.H" #include "fvPatchField.H"
#include "Switch.H" #include "Switch.H"
#include "symmetryFvPatch.H" #include "symmetryFvPatch.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

6
src/engine/engineTopoChangerMesh/engineValveSliding/engineValveSlidingMove.C
View file

@ -48,7 +48,7 @@ Class
#include "wedgeFvPatch.H" #include "wedgeFvPatch.H"
#include "emptyFvPatch.H" #include "emptyFvPatch.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"
@ -316,8 +316,8 @@ void Foam::engineValveSliding::prepareValveDetach()
bool Foam::engineValveSliding::update() bool Foam::engineValveSliding::update()
{ {
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
// Detaching the interfacethobois2DSlidingDeform // Detaching the interfacethobois2DSlidingDeform
if (attached()) if (attached())

6
src/engine/engineTopoChangerMesh/layerSmooth/layerSmoothMove.C
View file

@ -45,7 +45,7 @@ License
#include "wedgeFvPatch.H" #include "wedgeFvPatch.H"
#include "emptyFvPatch.H" #include "emptyFvPatch.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"
@ -243,8 +243,8 @@ bool Foam::layerSmooth::update()
Info << "bool Foam::layerSmooth::update()" << endl; Info << "bool Foam::layerSmooth::update()" << endl;
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
tetPointVectorField& motionU = mSolver.motionU(); tetPointVectorField& motionU = mSolver.motionU();

2
src/engine/engineTopoChangerMesh/pistonSliding/pistonSliding.C
View file

@ -41,7 +41,7 @@ Class
#include "fvPatchField.H" #include "fvPatchField.H"
#include "Switch.H" #include "Switch.H"
#include "symmetryFvPatch.H" #include "symmetryFvPatch.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

6
src/engine/engineTopoChangerMesh/pistonSliding/pistonSlidingMove.C
View file

@ -48,7 +48,7 @@ Class
#include "wedgeFvPatch.H" #include "wedgeFvPatch.H"
#include "emptyFvPatch.H" #include "emptyFvPatch.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"
@ -316,8 +316,8 @@ void Foam::pistonSliding::prepareValveDetach()
bool Foam::pistonSliding::update() bool Foam::pistonSliding::update()
{ {
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
// Detaching the interfacethobois2DSlidingDeform // Detaching the interfacethobois2DSlidingDeform
if (attached()) if (attached())

2
src/engine/engineTopoChangerMesh/thoboisMesh/thoboisMesh.C
View file

@ -38,7 +38,7 @@ License
#include "fvPatchField.H" #include "fvPatchField.H"
#include "Switch.H" #include "Switch.H"
#include "symmetryFvPatch.H" #include "symmetryFvPatch.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

6
src/engine/engineTopoChangerMesh/thoboisMesh/thoboisMeshMove.C
View file

@ -46,7 +46,7 @@ License
#include "wedgeFvPatch.H" #include "wedgeFvPatch.H"
#include "emptyFvPatch.H" #include "emptyFvPatch.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"
@ -249,8 +249,8 @@ void Foam::thoboisMesh::prepareValveDetach()
bool Foam::thoboisMesh::update() bool Foam::thoboisMesh::update()
{ {
Info << "bool Foam::layerSmooth::update()" << endl; Info << "bool Foam::layerSmooth::update()" << endl;
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
tetPointVectorField& motionU = mSolver.motionU(); tetPointVectorField& motionU = mSolver.motionU();

2
src/engine/engineTopoChangerMesh/thoboisSliding/thoboisSliding.C
View file

@ -41,7 +41,7 @@ Class
#include "fvPatchField.H" #include "fvPatchField.H"
#include "Switch.H" #include "Switch.H"
#include "symmetryFvPatch.H" #include "symmetryFvPatch.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

6
src/engine/engineTopoChangerMesh/thoboisSliding/thoboisSlidingMove.C
View file

@ -48,7 +48,7 @@ Class
#include "wedgeFvPatch.H" #include "wedgeFvPatch.H"
#include "emptyFvPatch.H" #include "emptyFvPatch.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"
@ -316,8 +316,8 @@ void Foam::thoboisSliding::prepareValveDetach()
bool Foam::thoboisSliding::update() bool Foam::thoboisSliding::update()
{ {
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
// Detaching the interfacethobois2DSlidingDeform // Detaching the interfacethobois2DSlidingDeform
if (attached()) if (attached())

6
src/engine/engineTopoChangerMesh/verticalValves/verticalValvesMove.C
View file

@ -48,7 +48,7 @@ Class
#include "wedgeFvPatch.H" #include "wedgeFvPatch.H"
#include "emptyFvPatch.H" #include "emptyFvPatch.H"
#include "zeroGradientTetPolyPatchFields.H" #include "zeroGradientTetPolyPatchFields.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "fixedValueTetPolyPatchFields.H" #include "fixedValueTetPolyPatchFields.H"
#include "mixedTetPolyPatchFields.H" #include "mixedTetPolyPatchFields.H"
@ -317,8 +317,8 @@ void Foam::verticalValves::prepareValveDetach()
bool Foam::verticalValves::update() bool Foam::verticalValves::update()
{ {
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
// Detaching the interface // Detaching the interface
if (attached()) if (attached())

14
src/engine/simpleEngineTopoFvMesh/simpleEngineTopoFvMesh.C
View file

@ -31,7 +31,7 @@ License
#include "componentMixedTetPolyPatchVectorField.H" #include "componentMixedTetPolyPatchVectorField.H"
#include "mapPolyMesh.H" #include "mapPolyMesh.H"
#include "polyTopoChange.H" #include "polyTopoChange.H"
#include "tetDecompositionMotionSolver.H" #include "tetMotionSolver.H"
#include "volMesh.H" #include "volMesh.H"
#include "addToRunTimeSelectionTable.H" #include "addToRunTimeSelectionTable.H"
@ -252,8 +252,8 @@ void Foam::simpleEngineTopoFvMesh::setBoundaryMotion()
Info << "Setting boundary motion" << endl; Info << "Setting boundary motion" << endl;
} }
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
tetPointVectorField& motionU = mSolver.motionU(); tetPointVectorField& motionU = mSolver.motionU();
@ -390,8 +390,8 @@ void Foam::simpleEngineTopoFvMesh::setBoundaryPosition()
Info << "Setting boundary position" << endl; Info << "Setting boundary position" << endl;
} }
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
tetPointVectorField& motionU = mSolver.motionU(); tetPointVectorField& motionU = mSolver.motionU();
@ -477,8 +477,8 @@ Foam::simpleEngineTopoFvMesh::simpleEngineTopoFvMesh
bool Foam::simpleEngineTopoFvMesh::update() bool Foam::simpleEngineTopoFvMesh::update()
{ {
tetDecompositionMotionSolver& mSolver = tetMotionSolver& mSolver =
refCast<tetDecompositionMotionSolver>(msPtr_()); refCast<tetMotionSolver>(msPtr_());
// Detaching the interface // Detaching the interface
if (attached()) if (attached())

4
src/tetDecompositionFiniteElement/Allwmake
View file

@ -1,4 +0,0 @@
#!/bin/sh
wmake libso . Make.cellDecomp
wmake libso . Make.faceDecomp

152
src/tetDecompositionFiniteElement/Make.cellDecomp/files
View file

@ -1,152 +0,0 @@
tetPolyMeshFaceDecomp = tetPolyMeshFaceDecomp
tetPolyBoundaryMeshFaceDecomp = $(tetPolyMeshFaceDecomp)/tetPolyBoundaryMesh
tetPolyPatchesFaceDecomp = $(tetPolyMeshFaceDecomp)/tetPolyPatches
tetPolyPatchFaceDecomp = $(tetPolyPatchesFaceDecomp)/tetPolyPatch
faceTetPolyPatchFaceDecomp = $(tetPolyPatchesFaceDecomp)/faceTetPolyPatch
basicTetPolyPatchesFaceDecomp = $(tetPolyPatchesFaceDecomp)/basic
constraintTetPolyPatchesFaceDecomp = $(tetPolyPatchesFaceDecomp)/constraint
derivedTetPolyPatchesFaceDecomp = $(tetPolyPatchesFaceDecomp)/derived
coupledTetPolyPatchFaceDecomp = $(basicTetPolyPatchesFaceDecomp)/coupled
coupledFaceTetPolyPatchFaceDecomp = $(basicTetPolyPatchesFaceDecomp)/coupledFace
emptyTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/empty
symmetryTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/symmetry
wedgeTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/wedge
processorTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/processor
globalTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/global
wallTetPolyPatchFaceDecomp = $(derivedTetPolyPatchesFaceDecomp)/wall
ggiTetPolyPatchFaceDecomp = $(derivedTetPolyPatchesFaceDecomp)/ggi
MapTetFemFieldsFaceDecomp = $(tetPolyMeshFaceDecomp)/MapTetFemFieldsFaceDecomp
tetPolyMeshCellDecomp = tetPolyMeshCellDecomp
tetPolyBoundaryMeshCellDecomp = $(tetPolyMeshCellDecomp)/tetPolyBoundaryMesh
tetPolyPatchesCellDecomp = $(tetPolyMeshCellDecomp)/tetPolyPatches
tetPolyPatchCellDecomp = $(tetPolyPatchesCellDecomp)/tetPolyPatch
faceTetPolyPatchCellDecomp = $(tetPolyPatchesCellDecomp)/faceTetPolyPatch
basicTetPolyPatchesCellDecomp = $(tetPolyPatchesCellDecomp)/basic
constraintTetPolyPatchesCellDecomp = $(tetPolyPatchesCellDecomp)/constraint
derivedTetPolyPatchesCellDecomp = $(tetPolyPatchesCellDecomp)/derived
coupledTetPolyPatchCellDecomp = $(basicTetPolyPatchesCellDecomp)/coupled
coupledFaceTetPolyPatchCellDecomp = $(basicTetPolyPatchesCellDecomp)/coupledFace
emptyTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/empty
symmetryTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/symmetry
wedgeTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/wedge
processorTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/processor
globalTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/global
wallTetPolyPatchCellDecomp = $(derivedTetPolyPatchesCellDecomp)/wall
ggiTetPolyPatchCellDecomp = $(derivedTetPolyPatchesCellDecomp)/ggi
MapTetFemFieldsCellDecomp = $(tetPolyMeshCellDecomp)/MapTetFemFieldsCellDecomp
tetPolyPatchInterpolation = tetPolyPatchInterpolation
tetPolyPatchInterpolationFaceDecomp = $(tetPolyPatchInterpolation)/tetPolyPatchInterpolationFaceDecomp
tetPolyPatchInterpolationCellDecomp = $(tetPolyPatchInterpolation)/tetPolyPatchInterpolationCellDecomp
/* Face decomposition mesh
$(tetPolyPatchFaceDecomp)/tetPolyPatchFaceDecomp.C
$(faceTetPolyPatchFaceDecomp)/faceTetPolyPatchFaceDecomp.C
$(faceTetPolyPatchFaceDecomp)/newFaceTetPolyPatchFaceDecomp.C
$(coupledTetPolyPatchFaceDecomp)/coupledTetPolyPatchFaceDecomp.C
$(emptyTetPolyPatchFaceDecomp)/emptyTetPolyPatchFaceDecomp.C
$(symmetryTetPolyPatchFaceDecomp)/symmetryTetPolyPatchFaceDecomp.C
$(wedgeTetPolyPatchFaceDecomp)/wedgeTetPolyPatchFaceDecomp.C
$(coupledFaceTetPolyPatchFaceDecomp)/coupledFaceTetPolyPatchFaceDecomp.C
$(processorTetPolyPatchFaceDecomp)/processorTetPolyPatchFaceDecompM.C
$(processorTetPolyPatchFaceDecomp)/calcProcessorTetPolyPatchFaceDecompAddr.C
$(processorTetPolyPatchFaceDecomp)/calcProcessorTetPolyPatchFaceDecompPointAddr.C
$(globalTetPolyPatchFaceDecomp)/globalTetPolyPatchFaceDecomp.C
$(globalTetPolyPatchFaceDecomp)/calcGlobalTetPolyPatchFaceDecompAddr.C
$(wallTetPolyPatchFaceDecomp)/wallTetPolyPatchFaceDecomp.C
$(ggiTetPolyPatchFaceDecomp)/ggiTetPolyPatchFaceDecomp.C
$(tetPolyBoundaryMeshFaceDecomp)/tetPolyBoundaryMeshFaceDecomp.C
$(tetPolyMeshFaceDecomp)/tetPolyMeshLduAddressingFaceDecomp.C
$(tetPolyMeshFaceDecomp)/tetPolyMeshFaceDecomp.C
$(tetPolyMeshFaceDecomp)/calcTetPolyMeshFaceDecompGeometry.C
$(tetPolyMeshFaceDecomp)/calcTetPolyMeshFaceDecompAddressing.C
$(tetPolyMeshFaceDecomp)/addParallelPointPatchFaceDecomp.C
$(tetPolyMeshFaceDecomp)/calcTetPolyMeshFaceDecompParPointData.C
$(MapTetFemFieldsFaceDecomp)/tetPointMapperFaceDecomp.C
$(MapTetFemFieldsFaceDecomp)/tetPolyPatchMapperFaceDecomp.C
$(tetPolyPatchInterpolationFaceDecomp)/tetPolyPatchInterpolationFaceDecomp.C
*/
$(tetPolyPatchCellDecomp)/tetPolyPatchCellDecomp.C
$(faceTetPolyPatchCellDecomp)/faceTetPolyPatchCellDecomp.C
$(faceTetPolyPatchCellDecomp)/newFaceTetPolyPatchCellDecomp.C
$(coupledTetPolyPatchCellDecomp)/coupledTetPolyPatchCellDecomp.C
$(emptyTetPolyPatchCellDecomp)/emptyTetPolyPatchCellDecomp.C
$(symmetryTetPolyPatchCellDecomp)/symmetryTetPolyPatchCellDecomp.C
$(wedgeTetPolyPatchCellDecomp)/wedgeTetPolyPatchCellDecomp.C
$(coupledFaceTetPolyPatchCellDecomp)/coupledFaceTetPolyPatchCellDecomp.C
$(processorTetPolyPatchCellDecomp)/processorTetPolyPatchCellDecompM.C
$(processorTetPolyPatchCellDecomp)/calcProcessorTetPolyPatchCellDecompAddr.C
$(processorTetPolyPatchCellDecomp)/calcProcessorTetPolyPatchCellDecompPointAddr.C
$(globalTetPolyPatchCellDecomp)/globalTetPolyPatchCellDecomp.C
$(globalTetPolyPatchCellDecomp)/calcGlobalTetPolyPatchCellDecompAddr.C
$(wallTetPolyPatchCellDecomp)/wallTetPolyPatchCellDecomp.C
$(ggiTetPolyPatchCellDecomp)/ggiTetPolyPatchCellDecomp.C
$(tetPolyBoundaryMeshCellDecomp)/tetPolyBoundaryMeshCellDecomp.C
$(tetPolyMeshCellDecomp)/tetPolyMeshLduAddressingCellDecomp.C
$(tetPolyMeshCellDecomp)/tetPolyMeshCellDecomp.C
$(tetPolyMeshCellDecomp)/calcTetPolyMeshCellDecompGeometry.C
$(tetPolyMeshCellDecomp)/calcTetPolyMeshCellDecompAddressing.C
$(tetPolyMeshCellDecomp)/addParallelPointPatchCellDecomp.C
$(tetPolyMeshCellDecomp)/calcTetPolyMeshCellDecompParPointData.C
$(MapTetFemFieldsCellDecomp)/tetPointMapperCellDecomp.C
$(MapTetFemFieldsCellDecomp)/tetPolyPatchMapperCellDecomp.C
$(tetPolyPatchInterpolationCellDecomp)/tetPolyPatchInterpolationCellDecomp.C
tetPolyPatchFields = fields/tetPolyPatchFields
$(tetPolyPatchFields)/tetPolyPatchField/tetPolyPatchFields.C
basicTetPolyPatchFields = $(tetPolyPatchFields)/basic
$(basicTetPolyPatchFields)/calculated/calculatedTetPolyPatchFields.C
$(basicTetPolyPatchFields)/coupled/coupledTetPolyPatchFields.C
$(basicTetPolyPatchFields)/coupledFace/coupledFaceTetPolyPatchFields.C
$(basicTetPolyPatchFields)/generic/genericTetPolyPatchFields.C
$(basicTetPolyPatchFields)/value/valueTetPolyPatchFields.C
$(basicTetPolyPatchFields)/fixedValue/fixedValueTetPolyPatchFields.C
$(basicTetPolyPatchFields)/mixed/mixedTetPolyPatchFields.C
$(basicTetPolyPatchFields)/zeroGradient/zeroGradientTetPolyPatchFields.C
constraintTetPolyPatchFields = $(tetPolyPatchFields)/constraint
$(constraintTetPolyPatchFields)/empty/emptyTetPolyPatchFields.C
$(constraintTetPolyPatchFields)/wedge/wedgeTetPolyPatchFields.C
$(constraintTetPolyPatchFields)/symmetry/symmetryTetPolyPatchFields.C
$(constraintTetPolyPatchFields)/processor/processorTetPolyPatchFields.C
derivedTetPolyPatchFields = $(tetPolyPatchFields)/derived
$(derivedTetPolyPatchFields)/global/globalTetPolyPatchFields.C
$(derivedTetPolyPatchFields)/componentMixed/componentMixedTetPolyPatchVectorField.C
$(derivedTetPolyPatchFields)/oscillatingFixedValue/oscillatingFixedValueTetPolyPatchFields.C
$(derivedTetPolyPatchFields)/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueTetPolyPatchFields.C
$(derivedTetPolyPatchFields)/slip/slipTetPolyPatchFields.C
elementPatchFields = fields/elementPatchFields
$(elementPatchFields)/elementPatchField/elementPatchFields.C
basicElementPatchFields = $(elementPatchFields)/basic
$(basicElementPatchFields)/calculated/calculatedElementPatchFields.C
$(basicElementPatchFields)/coupled/coupledElementPatchFields.C
$(basicElementPatchFields)/coupledFace/coupledFaceElementPatchFields.C
$(basicElementPatchFields)/value/valueElementPatchFields.C
constraintElementPatchFields = $(elementPatchFields)/constraint
$(constraintElementPatchFields)/empty/emptyElementPatchFields.C
$(constraintElementPatchFields)/wedge/wedgeElementPatchFields.C
$(constraintElementPatchFields)/symmetry/symmetryElementPatchFields.C
$(constraintElementPatchFields)/processor/processorElementPatchFields.C
$(constraintElementPatchFields)/global/globalElementPatchFields.C
fields/tetPointFields/tetPointFields.C
fields/elementFields/elementFields.C
tetFemMatrix/tetFemScalarMatrix.C
tetFemMatrix/tetFemMatrices.C
LIB = $(FOAM_LIBBIN)/libcellDecompFiniteElement

6
src/tetDecompositionFiniteElement/Make.cellDecomp/options
View file

@ -1,6 +0,0 @@
EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude \
-DCELL_DECOMP
EXE_LIBS = \
-lmeshTools

152
src/tetDecompositionFiniteElement/Make.faceDecomp/files
View file

@ -1,152 +0,0 @@
tetPolyMeshFaceDecomp = tetPolyMeshFaceDecomp
tetPolyBoundaryMeshFaceDecomp = $(tetPolyMeshFaceDecomp)/tetPolyBoundaryMesh
tetPolyPatchesFaceDecomp = $(tetPolyMeshFaceDecomp)/tetPolyPatches
tetPolyPatchFaceDecomp = $(tetPolyPatchesFaceDecomp)/tetPolyPatch
faceTetPolyPatchFaceDecomp = $(tetPolyPatchesFaceDecomp)/faceTetPolyPatch
basicTetPolyPatchesFaceDecomp = $(tetPolyPatchesFaceDecomp)/basic
constraintTetPolyPatchesFaceDecomp = $(tetPolyPatchesFaceDecomp)/constraint
derivedTetPolyPatchesFaceDecomp = $(tetPolyPatchesFaceDecomp)/derived
coupledTetPolyPatchFaceDecomp = $(basicTetPolyPatchesFaceDecomp)/coupled
coupledFaceTetPolyPatchFaceDecomp = $(basicTetPolyPatchesFaceDecomp)/coupledFace
emptyTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/empty
symmetryTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/symmetry
wedgeTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/wedge
processorTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/processor
globalTetPolyPatchFaceDecomp = $(constraintTetPolyPatchesFaceDecomp)/global
wallTetPolyPatchFaceDecomp = $(derivedTetPolyPatchesFaceDecomp)/wall
ggiTetPolyPatchFaceDecomp = $(derivedTetPolyPatchesFaceDecomp)/ggi
MapTetFemFieldsFaceDecomp = $(tetPolyMeshFaceDecomp)/MapTetFemFieldsFaceDecomp
tetPolyMeshCellDecomp = tetPolyMeshCellDecomp
tetPolyBoundaryMeshCellDecomp = $(tetPolyMeshCellDecomp)/tetPolyBoundaryMesh
tetPolyPatchesCellDecomp = $(tetPolyMeshCellDecomp)/tetPolyPatches
tetPolyPatchCellDecomp = $(tetPolyPatchesCellDecomp)/tetPolyPatch
faceTetPolyPatchCellDecomp = $(tetPolyPatchesCellDecomp)/faceTetPolyPatch
basicTetPolyPatchesCellDecomp = $(tetPolyPatchesCellDecomp)/basic
constraintTetPolyPatchesCellDecomp = $(tetPolyPatchesCellDecomp)/constraint
derivedTetPolyPatchesCellDecomp = $(tetPolyPatchesCellDecomp)/derived
coupledTetPolyPatchCellDecomp = $(basicTetPolyPatchesCellDecomp)/coupled
coupledFaceTetPolyPatchCellDecomp = $(basicTetPolyPatchesCellDecomp)/coupledFace
emptyTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/empty
symmetryTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/symmetry
wedgeTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/wedge
processorTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/processor
globalTetPolyPatchCellDecomp = $(constraintTetPolyPatchesCellDecomp)/global
wallTetPolyPatchCellDecomp = $(derivedTetPolyPatchesCellDecomp)/wall
ggiTetPolyPatchCellDecomp = $(derivedTetPolyPatchesCellDecomp)/ggi
MapTetFemFieldsCellDecomp = $(tetPolyMeshCellDecomp)/MapTetFemFieldsCellDecomp
tetPolyPatchInterpolation = tetPolyPatchInterpolation
tetPolyPatchInterpolationFaceDecomp = $(tetPolyPatchInterpolation)/tetPolyPatchInterpolationFaceDecomp
tetPolyPatchInterpolationCellDecomp = $(tetPolyPatchInterpolation)/tetPolyPatchInterpolationCellDecomp
$(tetPolyPatchFaceDecomp)/tetPolyPatchFaceDecomp.C
$(faceTetPolyPatchFaceDecomp)/faceTetPolyPatchFaceDecomp.C
$(faceTetPolyPatchFaceDecomp)/newFaceTetPolyPatchFaceDecomp.C
$(coupledTetPolyPatchFaceDecomp)/coupledTetPolyPatchFaceDecomp.C
$(emptyTetPolyPatchFaceDecomp)/emptyTetPolyPatchFaceDecomp.C
$(symmetryTetPolyPatchFaceDecomp)/symmetryTetPolyPatchFaceDecomp.C
$(wedgeTetPolyPatchFaceDecomp)/wedgeTetPolyPatchFaceDecomp.C
$(coupledFaceTetPolyPatchFaceDecomp)/coupledFaceTetPolyPatchFaceDecomp.C
$(processorTetPolyPatchFaceDecomp)/processorTetPolyPatchFaceDecompM.C
$(processorTetPolyPatchFaceDecomp)/calcProcessorTetPolyPatchFaceDecompAddr.C
$(processorTetPolyPatchFaceDecomp)/calcProcessorTetPolyPatchFaceDecompPointAddr.C
$(globalTetPolyPatchFaceDecomp)/globalTetPolyPatchFaceDecomp.C
$(globalTetPolyPatchFaceDecomp)/calcGlobalTetPolyPatchFaceDecompAddr.C
$(wallTetPolyPatchFaceDecomp)/wallTetPolyPatchFaceDecomp.C
$(ggiTetPolyPatchFaceDecomp)/ggiTetPolyPatchFaceDecomp.C
$(tetPolyBoundaryMeshFaceDecomp)/tetPolyBoundaryMeshFaceDecomp.C
$(tetPolyMeshFaceDecomp)/tetPolyMeshLduAddressingFaceDecomp.C
$(tetPolyMeshFaceDecomp)/tetPolyMeshFaceDecomp.C
$(tetPolyMeshFaceDecomp)/calcTetPolyMeshFaceDecompGeometry.C
$(tetPolyMeshFaceDecomp)/calcTetPolyMeshFaceDecompAddressing.C
$(tetPolyMeshFaceDecomp)/addParallelPointPatchFaceDecomp.C
$(tetPolyMeshFaceDecomp)/calcTetPolyMeshFaceDecompParPointData.C
$(MapTetFemFieldsFaceDecomp)/tetPointMapperFaceDecomp.C
$(MapTetFemFieldsFaceDecomp)/tetPolyPatchMapperFaceDecomp.C
$(tetPolyPatchInterpolationFaceDecomp)/tetPolyPatchInterpolationFaceDecomp.C
/* Cell decomposition mesh
$(tetPolyPatchCellDecomp)/tetPolyPatchCellDecomp.C
$(faceTetPolyPatchCellDecomp)/faceTetPolyPatchCellDecomp.C
$(faceTetPolyPatchCellDecomp)/newFaceTetPolyPatchCellDecomp.C
$(coupledTetPolyPatchCellDecomp)/coupledTetPolyPatchCellDecomp.C
$(emptyTetPolyPatchCellDecomp)/emptyTetPolyPatchCellDecomp.C
$(symmetryTetPolyPatchCellDecomp)/symmetryTetPolyPatchCellDecomp.C
$(wedgeTetPolyPatchCellDecomp)/wedgeTetPolyPatchCellDecomp.C
$(coupledFaceTetPolyPatchCellDecomp)/coupledFaceTetPolyPatchCellDecomp.C
$(processorTetPolyPatchCellDecomp)/processorTetPolyPatchCellDecompM.C
$(processorTetPolyPatchCellDecomp)/calcProcessorTetPolyPatchCellDecompAddr.C
$(processorTetPolyPatchCellDecomp)/calcProcessorTetPolyPatchCellDecompPointAddr.C
$(globalTetPolyPatchCellDecomp)/globalTetPolyPatchCellDecomp.C
$(globalTetPolyPatchCellDecomp)/calcGlobalTetPolyPatchCellDecompAddr.C
$(wallTetPolyPatchCellDecomp)/wallTetPolyPatchCellDecomp.C
$(ggiTetPolyPatchCellDecomp)/ggiTetPolyPatchCellDecomp.C
$(tetPolyBoundaryMeshCellDecomp)/tetPolyBoundaryMeshCellDecomp.C
$(tetPolyMeshCellDecomp)/tetPolyMeshLduAddressingCellDecomp.C
$(tetPolyMeshCellDecomp)/tetPolyMeshCellDecomp.C
$(tetPolyMeshCellDecomp)/calcTetPolyMeshCellDecompGeometry.C
$(tetPolyMeshCellDecomp)/calcTetPolyMeshCellDecompAddressing.C
$(tetPolyMeshCellDecomp)/addParallelPointPatchCellDecomp.C
$(tetPolyMeshCellDecomp)/calcTetPolyMeshCellDecompParPointData.C
$(MapTetFemFieldsCellDecomp)/tetPointMapperCellDecomp.C
$(MapTetFemFieldsCellDecomp)/tetPolyPatchMapperCellDecomp.C
$(tetPolyPatchInterpolationCellDecomp)/tetPolyPatchInterpolationCellDecomp.C
*/
tetPolyPatchFields = fields/tetPolyPatchFields
$(tetPolyPatchFields)/tetPolyPatchField/tetPolyPatchFields.C
basicTetPolyPatchFields = $(tetPolyPatchFields)/basic
$(basicTetPolyPatchFields)/calculated/calculatedTetPolyPatchFields.C
$(basicTetPolyPatchFields)/coupled/coupledTetPolyPatchFields.C
$(basicTetPolyPatchFields)/coupledFace/coupledFaceTetPolyPatchFields.C
$(basicTetPolyPatchFields)/generic/genericTetPolyPatchFields.C
$(basicTetPolyPatchFields)/value/valueTetPolyPatchFields.C
$(basicTetPolyPatchFields)/fixedValue/fixedValueTetPolyPatchFields.C
$(basicTetPolyPatchFields)/mixed/mixedTetPolyPatchFields.C
$(basicTetPolyPatchFields)/zeroGradient/zeroGradientTetPolyPatchFields.C
constraintTetPolyPatchFields = $(tetPolyPatchFields)/constraint
$(constraintTetPolyPatchFields)/empty/emptyTetPolyPatchFields.C
$(constraintTetPolyPatchFields)/wedge/wedgeTetPolyPatchFields.C
$(constraintTetPolyPatchFields)/symmetry/symmetryTetPolyPatchFields.C
$(constraintTetPolyPatchFields)/processor/processorTetPolyPatchFields.C
derivedTetPolyPatchFields = $(tetPolyPatchFields)/derived
$(derivedTetPolyPatchFields)/global/globalTetPolyPatchFields.C
$(derivedTetPolyPatchFields)/componentMixed/componentMixedTetPolyPatchVectorField.C
$(derivedTetPolyPatchFields)/oscillatingFixedValue/oscillatingFixedValueTetPolyPatchFields.C
$(derivedTetPolyPatchFields)/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueTetPolyPatchFields.C
$(derivedTetPolyPatchFields)/slip/slipTetPolyPatchFields.C
elementPatchFields = fields/elementPatchFields
$(elementPatchFields)/elementPatchField/elementPatchFields.C
basicElementPatchFields = $(elementPatchFields)/basic
$(basicElementPatchFields)/calculated/calculatedElementPatchFields.C
$(basicElementPatchFields)/coupled/coupledElementPatchFields.C
$(basicElementPatchFields)/coupledFace/coupledFaceElementPatchFields.C
$(basicElementPatchFields)/value/valueElementPatchFields.C
constraintElementPatchFields = $(elementPatchFields)/constraint
$(constraintElementPatchFields)/empty/emptyElementPatchFields.C
$(constraintElementPatchFields)/wedge/wedgeElementPatchFields.C
$(constraintElementPatchFields)/symmetry/symmetryElementPatchFields.C
$(constraintElementPatchFields)/processor/processorElementPatchFields.C
$(constraintElementPatchFields)/global/globalElementPatchFields.C
fields/tetPointFields/tetPointFields.C
fields/elementFields/elementFields.C
tetFemMatrix/tetFemScalarMatrix.C
tetFemMatrix/tetFemMatrices.C
LIB = $(FOAM_LIBBIN)/libfaceDecompFiniteElement

60
src/tetDecompositionFiniteElement/tetPolyMesh/coupledFaceTetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
coupledFaceTetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef coupledFaceTetPolyPatch_H
#define coupledFaceTetPolyPatch_H
#include "coupledFaceTetPolyPatchFaceDecomp.H"
#include "coupledFaceTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef coupledFaceTetPolyPatchCellDecomp coupledFaceTetPolyPatch;
#elif defined(FACE_DECOMP)
typedef coupledFaceTetPolyPatchFaceDecomp coupledFaceTetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/coupledTetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
coupledTetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef coupledTetPolyPatch_H
#define coupledTetPolyPatch_H
#include "coupledTetPolyPatchFaceDecomp.H"
#include "coupledTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef coupledTetPolyPatchCellDecomp coupledTetPolyPatch;
#elif defined(FACE_DECOMP)
typedef coupledTetPolyPatchFaceDecomp coupledTetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/emptyTetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
emptyTetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef emptyTetPolyPatch_H
#define emptyTetPolyPatch_H
#include "emptyTetPolyPatchFaceDecomp.H"
#include "emptyTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef emptyTetPolyPatchCellDecomp emptyTetPolyPatch;
#elif defined(FACE_DECOMP)
typedef emptyTetPolyPatchFaceDecomp emptyTetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/faceTetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
faceTetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef faceTetPolyPatch_H
#define faceTetPolyPatch_H
#include "faceTetPolyPatchFaceDecomp.H"
#include "faceTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef faceTetPolyPatchCellDecomp faceTetPolyPatch;
#elif defined(FACE_DECOMP)
typedef faceTetPolyPatchFaceDecomp faceTetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/globalTetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
globalTetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef globalTetPolyPatch_H
#define globalTetPolyPatch_H
#include "globalTetPolyPatchFaceDecomp.H"
#include "globalTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef globalTetPolyPatchCellDecomp globalTetPolyPatch;
#elif defined(FACE_DECOMP)
typedef globalTetPolyPatchFaceDecomp globalTetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/processorTetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
processorTetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef processorTetPolyPatch_H
#define processorTetPolyPatch_H
#include "processorTetPolyPatchFaceDecomp.H"
#include "processorTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef processorTetPolyPatchCellDecomp processorTetPolyPatch;
#elif defined(FACE_DECOMP)
typedef processorTetPolyPatchFaceDecomp processorTetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/symmetryTetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
symmetryTetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef symmetryTetPolyPatch_H
#define symmetryTetPolyPatch_H
#include "symmetryTetPolyPatchFaceDecomp.H"
#include "symmetryTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef symmetryTetPolyPatchCellDecomp symmetryTetPolyPatch;
#elif defined(FACE_DECOMP)
typedef symmetryTetPolyPatchFaceDecomp symmetryTetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/tetPolyBoundaryMesh.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
tetPolyBoundaryMesh
Description
\*---------------------------------------------------------------------------*/
#ifndef tetPolyBoundaryMesh_H
#define tetPolyBoundaryMesh_H
#include "tetPolyBoundaryMeshFaceDecomp.H"
#include "tetPolyBoundaryMeshCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef tetPolyBoundaryMeshCellDecomp tetPolyBoundaryMesh;
#elif defined(FACE_DECOMP)
typedef tetPolyBoundaryMeshFaceDecomp tetPolyBoundaryMesh;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/tetPolyMesh.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
tetPolyMesh
Description
\*---------------------------------------------------------------------------*/
#ifndef tetPolyMesh_H
#define tetPolyMesh_H
#include "tetPolyMeshFaceDecomp.H"
#include "tetPolyMeshCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef tetPolyMeshCellDecomp tetPolyMesh;
#elif defined(FACE_DECOMP)
typedef tetPolyMeshFaceDecomp tetPolyMesh;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/tetPolyMeshMapper.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
tetPolyMeshMapper
Description
\*---------------------------------------------------------------------------*/
#ifndef tetPolyMeshMapper_H
#define tetPolyMeshMapper_H
#include "tetPolyMeshMapperFaceDecomp.H"
#include "tetPolyMeshMapperCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef tetPolyMeshMapperCellDecomp tetPolyMeshMapper;
#elif defined(FACE_DECOMP)
typedef tetPolyMeshMapperFaceDecomp tetPolyMeshMapper;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/tetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
tetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef tetPolyPatch_H
#define tetPolyPatch_H
#include "tetPolyPatchFaceDecomp.H"
#include "tetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef tetPolyPatchCellDecomp tetPolyPatch;
#elif defined(FACE_DECOMP)
typedef tetPolyPatchFaceDecomp tetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/wallTetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
wallTetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef wallTetPolyPatch_H
#define wallTetPolyPatch_H
#include "wallTetPolyPatchFaceDecomp.H"
#include "wallTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef wallTetPolyPatchCellDecomp wallTetPolyPatch;
#elif defined(FACE_DECOMP)
typedef wallTetPolyPatchFaceDecomp wallTetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/tetDecompositionFiniteElement/tetPolyMesh/wedgeTetPolyPatch.H
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
wedgeTetPolyPatch
Description
\*---------------------------------------------------------------------------*/
#ifndef wedgeTetPolyPatch_H
#define wedgeTetPolyPatch_H
#include "wedgeTetPolyPatchFaceDecomp.H"
#include "wedgeTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
#ifdef CELL_DECOMP
typedef wedgeTetPolyPatchCellDecomp wedgeTetPolyPatch;
#elif defined(FACE_DECOMP)
typedef wedgeTetPolyPatchFaceDecomp wedgeTetPolyPatch;
#else
#error Undefined: cell or face decomposition
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

385
src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/MapTetFemFieldsCellDecomp/tetPointMapperCellDecomp.C
View file

@ -1,385 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Point mapper for the face tetFem decomposition
\*---------------------------------------------------------------------------*/
#include "tetPointMapperCellDecomp.H"
#include "tetPolyMeshCellDecomp.H"
#include "mapPolyMesh.H"
#include "pointMapper.H"
#include "faceMapper.H"
#include "cellMapper.H"
#include "tetPointMesh.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::tetPointMapperCellDecomp::calcAddressing() const
{
if (tetPolyMeshCellDecomp::debug)
{
Info<< "void tetPointMapperCellDecomp::calcAddressing() const : "
<< "Calculating addressing: ";
}
if
(
directPtr_
|| directAddrPtr_
|| interpolationAddrPtr_
|| weightsPtr_
|| insertedObjectsPtr_
|| insertedObjectLabelsPtr_
)
{
FatalErrorIn("void tetPointMapperCellDecomp::calcAddressing() const)")
<< "Addressing already calculated"
<< abort(FatalError);
}
const label oldCellOffset = mpm_.nOldPoints();
// Mapping
// Calculate direct (if all are direct)
directPtr_ =
new bool
(
pointMap_.direct()
&& cellMap_.direct()
);
// Assemble the maps
if (*directPtr_)
{
// Direct mapping
if (tetPolyMeshCellDecomp::debug)
{
Info<< " direct" << endl;
}
const labelList& mappedPoints = pointMap_.directAddressing();
const labelList& mappedCells = cellMap_.directAddressing();
directAddrPtr_ = new labelList(size());
labelList& addr = *directAddrPtr_;
label nAddr = 0;
forAll (mappedPoints, pointI)
{
addr[nAddr] = mappedPoints[pointI];
nAddr++;
}
forAll (mappedCells, cellI)
{
addr[nAddr] = mappedCells[cellI] + oldCellOffset;
nAddr++;
}
}
else
{
// Interpolative mapping
if (tetPolyMeshCellDecomp::debug)
{
Info<< " interpolative" << endl;
}
interpolationAddrPtr_ = new labelListList(size());
labelListList& addr = *interpolationAddrPtr_;
weightsPtr_ = new scalarListList(size());
scalarListList& w = *weightsPtr_;
label nAdded = 0;
// Insert points
const labelList& mappedPoints = pointMap_.directAddressing();
forAll (mappedPoints, pointI)
{
addr[nAdded] = labelList(1, mappedPoints[pointI]);
w[nAdded] = scalarList(1, 1.0);
nAdded++;
}
// Do cell addressing, direct or interpolative
if (cellMap_.direct())
{
// Direct for cells
const labelList& mappedCells = cellMap_.directAddressing();
// Insert cells
forAll (mappedCells, cellI)
{
addr[nAdded] =
labelList(1, mappedCells[cellI] + oldCellOffset);
w[nAdded] = scalarList(1, 1.0);
nAdded++;
}
}
else
{
// Interpolative for cells
const labelListList& mappedCells = cellMap_.addressing();
const scalarListList& cellWeights = cellMap_.weights();
// Do cell addressing,
// Insert cells
forAll (mappedCells, cellI)
{
labelList& curAddr = addr[nAdded];
const labelList& curMc = mappedCells[cellI];
curAddr.setSize(curMc.size());
forAll (curAddr, cI)
{
curAddr[cI] = curMc[cI] + oldCellOffset;
}
// Weights remain the same
w[nAdded] = cellWeights[cellI];
nAdded++;
}
}
}
// Inserted objects
// Are there inserted objects presents
insertedObjectsPtr_ =
new bool
(
pointMap_.insertedObjects()
|| cellMap_.insertedObjects()
);
// If there are, assemble the labels
if (*insertedObjectsPtr_)
{
const labelList& insPoints = pointMap_.insertedObjectLabels();
const labelList& insCells = cellMap_.insertedObjectLabels();
insertedObjectLabelsPtr_ =
new labelList(insPoints.size() + insCells.size());
labelList& ins = *insertedObjectLabelsPtr_;
label nIns = 0;
forAll (insPoints, pointI)
{
ins[nIns] = insPoints[pointI];
nIns++;
}
forAll (insCells, cellI)
{
ins[nIns] = insCells[cellI] + oldCellOffset;
nIns++;
}
}
else
{
// No inserted objects
insertedObjectLabelsPtr_ = new labelList(0);
}
if (tetPolyMeshCellDecomp::debug)
{
Info<< "void tetPointMapperCellDecomp::calcAddressing() const : "
<< "Finished calculating addressing."
<< endl;
}
}
void Foam::tetPointMapperCellDecomp::clearOut()
{
deleteDemandDrivenData(directPtr_);
deleteDemandDrivenData(directAddrPtr_);
deleteDemandDrivenData(interpolationAddrPtr_);
deleteDemandDrivenData(weightsPtr_);
deleteDemandDrivenData(insertedObjectsPtr_);
deleteDemandDrivenData(insertedObjectLabelsPtr_);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components
Foam::tetPointMapperCellDecomp::tetPointMapperCellDecomp
(
const tetPolyMeshCellDecomp& mesh,
const mapPolyMesh& meshMap,
const pointMapper& pMapper,
const cellMapper& cMapper
)
:
mesh_(mesh),
mpm_(meshMap),
pointMap_(pMapper),
cellMap_(cMapper),
size_(mesh().nPoints() + mesh().nCells()),
directPtr_(NULL),
directAddrPtr_(NULL),
interpolationAddrPtr_(NULL),
weightsPtr_(NULL),
insertedObjectsPtr_(NULL),
insertedObjectLabelsPtr_(NULL)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::tetPointMapperCellDecomp::~tetPointMapperCellDecomp()
{
clearOut();
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::label Foam::tetPointMapperCellDecomp::size() const
{
return size_;
}
Foam::label Foam::tetPointMapperCellDecomp::sizeBeforeMapping() const
{
return mpm_.nOldPoints() + mpm_.nOldCells();
}
bool Foam::tetPointMapperCellDecomp::direct() const
{
if (!directPtr_)
{
calcAddressing();
}
return *directPtr_;
}
const Foam::unallocLabelList&
Foam::tetPointMapperCellDecomp::directAddressing() const
{
if (!direct())
{
FatalErrorIn
(
"const unallocLabelList& tetPointMapperCellDecomp::"
"directAddressing() const"
) << "Requested direct addressing for an interpolative mapper."
<< abort(FatalError);
}
if (!directAddrPtr_)
{
calcAddressing();
}
return *directAddrPtr_;
}
const Foam::labelListList& Foam::tetPointMapperCellDecomp::addressing() const
{
if (direct())
{
FatalErrorIn
(
"const labelListList& tetPointMapperCellDecomp::addressing() const"
) << "Requested interpolative addressing for a direct mapper."
<< abort(FatalError);
}
if (!interpolationAddrPtr_)
{
calcAddressing();
}
return *interpolationAddrPtr_;
}
const Foam::scalarListList& Foam::tetPointMapperCellDecomp::weights() const
{
if (direct())
{
FatalErrorIn
(
"const scalarListList& tetPointMapperCellDecomp::weights() const"
) << "Requested interpolative weights for a direct mapper."
<< abort(FatalError);
}
if (!weightsPtr_)
{
calcAddressing();
}
return *weightsPtr_;
}
bool Foam::tetPointMapperCellDecomp::insertedObjects() const
{
if (!insertedObjectsPtr_)
{
calcAddressing();
}
return *insertedObjectsPtr_;
}
const Foam::labelList&
Foam::tetPointMapperCellDecomp::insertedObjectLabels() const
{
if (!insertedObjectLabelsPtr_)
{
calcAddressing();
}
return *insertedObjectLabelsPtr_;
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
// ************************************************************************* //

172
src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/MapTetFemFieldsCellDecomp/tetPointMapperCellDecomp.H
View file

@ -1,172 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
tetPointMapperCellDecomp
Description
Point mapper for the face tetFem decomposition
SourceFiles
tetPointMapperCellDecomp.C
\*---------------------------------------------------------------------------*/
#ifndef tetPointMapperCellDecomp_H
#define tetPointMapperCellDecomp_H
#include "morphFieldMapper.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Class forward declarations
class tetPolyMeshCellDecomp;
class mapPolyMesh;
class pointMapper;
class cellMapper;
/*---------------------------------------------------------------------------*\
Class tetPointMapperCellDecomp Declaration
\*---------------------------------------------------------------------------*/
class tetPointMapperCellDecomp
:
public morphFieldMapper
{
// Private data
//- Reference to mesh
const tetPolyMeshCellDecomp& mesh_;
//- Reference to mapPolyMesh
const mapPolyMesh& mpm_;
//- Reference to point mapper
const pointMapper& pointMap_;
//- Reference to face mapper
const cellMapper& cellMap_;
//- Size of target object
const label size_;
// Demand-driven private data
//- Is the mapping direct
mutable bool* directPtr_;
//- Direct addressing (only one for of addressing is used)
mutable labelList* directAddrPtr_;
//- Interpolated addressing (only one for of addressing is used)
mutable labelListList* interpolationAddrPtr_;
//- Interpolation weights
mutable scalarListList* weightsPtr_;
//- Are there any inserted (unmapped) objects
mutable bool* insertedObjectsPtr_;
//- Inserted faces
mutable labelList* insertedObjectLabelsPtr_;
// Private Member Functions
//- Disallow default bitwise copy construct
tetPointMapperCellDecomp(const tetPointMapperCellDecomp&);
//- Disallow default bitwise assignment
void operator=(const tetPointMapperCellDecomp&);
//- Calculate addressing
void calcAddressing() const;
//- Clear out local storage
void clearOut();
public:
// Constructors
//- Construct from components
tetPointMapperCellDecomp
(
const tetPolyMeshCellDecomp& mesh,
const mapPolyMesh& meshMap,
const pointMapper& pMapper,
const cellMapper& cMapper
);
// Destructor
virtual ~tetPointMapperCellDecomp();
// Member Functions
//- Return size
virtual label size() const;
//- Return size of field before mapping
virtual label sizeBeforeMapping() const;
//- Is the mapping direct
virtual bool direct() const;
//- Return direct addressing
virtual const unallocLabelList& directAddressing() const;
//- Return interpolated addressing
virtual const labelListList& addressing() const;
//- Return interpolation weights
virtual const scalarListList& weights() const;
//- Are there any inserted faces
bool insertedObjects() const;
//- Return list of inserted faces
const labelList& insertedObjectLabels() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

108
src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/MapTetFemFieldsCellDecomp/tetPolyBoundaryMapperCellDecomp.H
View file

@ -1,108 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
tetPolyBoundaryMapperCellDecomp
Description
SourceFiles
tetPolyBoundaryMapperCellDecomp.C
\*---------------------------------------------------------------------------*/
#ifndef tetPolyBoundaryMapperCellDecomp_H
#define tetPolyBoundaryMapperCellDecomp_H
#include "PtrList.H"
#include "tetPolyPatchMapperCellDecomp.H"
#include "pointMapper.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Class forward declarations
/*---------------------------------------------------------------------------*\
Class tetPolyBoundaryMapperCellDecomp Declaration
\*---------------------------------------------------------------------------*/
class tetPolyBoundaryMapperCellDecomp
:
public PtrList<tetPolyPatchMapperCellDecomp>
{
// Private Member Functions
//- Disallow default bitwise copy construct
tetPolyBoundaryMapperCellDecomp(const tetPolyBoundaryMapperCellDecomp&);
//- Disallow default bitwise assignment
void operator=(const tetPolyBoundaryMapperCellDecomp&);
public:
// Constructors
//- Construct from components
tetPolyBoundaryMapperCellDecomp
(
const tetPolyMeshCellDecomp& mesh,
const mapPolyMesh& meshMap
)
:
PtrList<tetPolyPatchMapperCellDecomp>(mesh.boundary().size())
{
const tetPolyBoundaryMeshCellDecomp& patches = mesh.boundary();
forAll (patches, patchI)
{
this->set
(
patchI,
new tetPolyPatchMapperCellDecomp
(
patches[patchI],
meshMap
)
);
}
}
// Destructor - default
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

148
src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/MapTetFemFieldsCellDecomp/tetPolyMeshMapperCellDecomp.H
View file

@ -1,148 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
tetPolyMeshMapperCellDecomp
Description
Class holds all the necessary information for mapping fields associated
with tetPolyMeshCellDecomp.
SourceFiles
tetPolyMeshMapperCellDecomp.C
\*---------------------------------------------------------------------------*/
#ifndef tetPolyMeshMapperCellDecomp_H
#define tetPolyMeshMapperCellDecomp_H
#include "tetPointMapperCellDecomp.H"
#include "pointMapper.H"
#include "cellMapper.H"
#include "tetPolyBoundaryMapperCellDecomp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Class forward declarations
class tetPolyMeshCellDecomp;
class mapPolyMesh;
/*---------------------------------------------------------------------------*\
Class tetPolyMeshMapperCellDecomp Declaration
\*---------------------------------------------------------------------------*/
class tetPolyMeshMapperCellDecomp
{
// Private data
//- Reference to mesh
const tetPolyMeshCellDecomp& mesh_;
//- Point mapper
pointMapper pointMap_;
//- Cell mapper
cellMapper cellMap_;
//- Point mapper (needs to be re-done to insert cells)
tetPointMapperCellDecomp tetPointMap_;
//- Boundary mapper
tetPolyBoundaryMapperCellDecomp boundaryMap_;
// Private Member Functions
//- Disallow default bitwise copy construct
tetPolyMeshMapperCellDecomp(const tetPolyMeshMapperCellDecomp&);
//- Disallow default bitwise assignment
void operator=(const tetPolyMeshMapperCellDecomp&);
public:
// Constructors
//- Construct from components
tetPolyMeshMapperCellDecomp
(
const tetPolyMeshCellDecomp& mesh,
const mapPolyMesh& meshMap
)
:
mesh_(mesh),
pointMap_(meshMap),
cellMap_(meshMap),
tetPointMap_(mesh, meshMap, pointMap_, cellMap_),
boundaryMap_(mesh, meshMap)
{}
// Member Functions
//- Return mesh
const tetPolyMeshCellDecomp& mesh() const
{
return mesh_;
}
//- Return reference to objectRegistry storing fields
// Needed in mappers. HJ, 16/Oct/2008
const objectRegistry& thisDb() const
{
return mesh_.thisDb();
}
//- Return point mapper
const morphFieldMapper& pointMap() const
{
return tetPointMap_;
}
//- Return element mapper
const morphFieldMapper& elementMap() const
{
return cellMap_;
}
//- Return boundary mapper
const tetPolyBoundaryMapperCellDecomp& boundaryMap() const
{
return boundaryMap_;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

142
src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/MapTetFemFieldsCellDecomp/tetPolyPatchMapperCellDecomp.C
View file

@ -1,142 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
PolyPatch mapper for the cell tetFem decomposition
\*---------------------------------------------------------------------------*/
#include "tetPolyPatchMapperCellDecomp.H"
#include "tetPolyPatchCellDecomp.H"
#include "tetPolyBoundaryMeshCellDecomp.H"
#include "tetPolyMeshCellDecomp.H"
#include "tetFemMatrices.H"
#include "mapPolyMesh.H"
#include "pointMapper.H"
#include "faceTetPolyPatchCellDecomp.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::tetPolyPatchMapperCellDecomp::calcAddressing() const
{
if (directAddrPtr_)
{
FatalErrorIn
(
"void tetPolyPatchMapperCellDecomp::calcAddressing() const)"
) << "Addressing already calculated"
<< abort(FatalError);
}
// Mapping
const labelList& curPatchPointMap = mpm_.patchPointMap()[patch_.index()];
// Assemble the map (direct mapping)
directAddrPtr_ = new labelList(size());
labelList& addr = *directAddrPtr_;
label nAddr = 0;
forAll (curPatchPointMap, pointI)
{
if (curPatchPointMap[pointI] > -1)
{
addr[nAddr] = curPatchPointMap[pointI];
}
else
{
addr[nAddr] = 0;
}
nAddr++;
}
}
void Foam::tetPolyPatchMapperCellDecomp::clearOut()
{
deleteDemandDrivenData(directPtr_);
deleteDemandDrivenData(directAddrPtr_);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components
Foam::tetPolyPatchMapperCellDecomp::tetPolyPatchMapperCellDecomp
(
const tetPolyPatchCellDecomp& patch,
const mapPolyMesh& meshMap
)
:
patch_(patch),
mpm_(meshMap),
directPtr_(NULL),
directAddrPtr_(NULL)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::tetPolyPatchMapperCellDecomp::~tetPolyPatchMapperCellDecomp()
{
clearOut();
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::label Foam::tetPolyPatchMapperCellDecomp::size() const
{
return patch_.size();
}
Foam::label Foam::tetPolyPatchMapperCellDecomp::sizeBeforeMapping() const
{
return mpm_.oldPatchNMeshPoints()[patch_.index()];
}
const Foam::unallocLabelList&
Foam::tetPolyPatchMapperCellDecomp::directAddressing() const
{
if (!directAddrPtr_)
{
calcAddressing();
}
return *directAddrPtr_;
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
// ************************************************************************* //

142
src/tetDecompositionFiniteElement/tetPolyMeshCellDecomp/MapTetFemFieldsCellDecomp/tetPolyPatchMapperCellDecomp.H
View file

@ -1,142 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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 2 of the License, or (at your
option) any later version.
OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
tetPolyPatchMapperCellDecomp
Description
Mapping class for a tetPolyPatchFieldCellDecomp
SourceFiles
tetPolyPatchMapperCellDecomp.C
\*---------------------------------------------------------------------------*/
#ifndef tetPolyPatchMapperCellDecomp_H
#define tetPolyPatchMapperCellDecomp_H
#include "PointPatchFieldMapper.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Class forward declarations
class tetPolyPatchCellDecomp;
class mapPolyMesh;
/*---------------------------------------------------------------------------*\
Class tetPolyPatchMapperCellDecomp Declaration
\*---------------------------------------------------------------------------*/
class tetPolyPatchMapperCellDecomp
:
public PointPatchFieldMapper
{
// Private data
//- Reference to patch
const tetPolyPatchCellDecomp& patch_;
//- Reference to mapPolyMesh
const mapPolyMesh& mpm_;
// Demand-driven private data
//- Is the mapping direct
mutable bool* directPtr_;
//- Direct addressing (only one for of addressing is used)
mutable labelList* directAddrPtr_;
// Private Member Functions
//- Disallow default bitwise copy construct
tetPolyPatchMapperCellDecomp
(
const tetPolyPatchMapperCellDecomp&
);
//- Disallow default bitwise assignment
void operator=(const tetPolyPatchMapperCellDecomp&);
//- Calculate addressing for mapping with inserted cells
void calcAddressing() const;
//- Clear out local storage
void clearOut();
public:
// Static data members
// Constructors
//- Construct from mappers
tetPolyPatchMapperCellDecomp
(
const tetPolyPatchCellDecomp& patch,
const mapPolyMesh& meshMap
);
// Destructor
virtual ~tetPolyPatchMapperCellDecomp();
// Member Functions
//- Return size
virtual label size() const;
//- Return size of field before mapping
virtual label sizeBeforeMapping() const;
//- Is the mapping direct
virtual bool direct() const
{
return true;
}
//- Return direct addressing
virtual const unallocLabelList& directAddressing() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

Some files were not shown because too many files have changed in this diff Show more